projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* configure.tgt: Set targ_emul to arm_wince_pe for ARM Windows CE targets.
[deliverable/binutils-gdb.git] / bfd / elf64-ppc.c
CommitLineData
5bd4f169 1/* PowerPC64-specific support for 64-bit ELF.
bce50a28 2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
b2a8e766 3 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.
d37c89e5 6 Largely rewritten by Alan Modra <amodra@bigpond.net.au>
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
12 the Free Software Foundation; either version 2 of the License, or
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
4ce794b7
AM		 24/* The 64-bit PowerPC ELF ABI may be found at
25 http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
26 http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html */
5bd4f169
AM		 27
28#include "bfd.h"
29#include "sysdep.h"
30#include "bfdlink.h"
31#include "libbfd.h"
32#include "elf-bfd.h"
04c9666a 33#include "elf/ppc64.h"
5d1634d7 34#include "elf64-ppc.h"
5bd4f169 35
805fc799 36static bfd_reloc_status_type ppc64_elf_ha_reloc
4ce794b7 37 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
2441e016
AM		 38static bfd_reloc_status_type ppc64_elf_branch_reloc
39 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
805fc799 40static bfd_reloc_status_type ppc64_elf_brtaken_reloc
4ce794b7 41 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
805fc799 42static bfd_reloc_status_type ppc64_elf_sectoff_reloc
4ce794b7 43 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
805fc799 44static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
4ce794b7 45 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
805fc799 46static bfd_reloc_status_type ppc64_elf_toc_reloc
4ce794b7 47 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
805fc799 48static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
4ce794b7 49 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
805fc799 50static bfd_reloc_status_type ppc64_elf_toc64_reloc
4ce794b7 51 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
805fc799 52static bfd_reloc_status_type ppc64_elf_unhandled_reloc
4ce794b7 53 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
2441e016
AM		 54static bfd_vma opd_entry_value
55 (asection *, bfd_vma, asection **, bfd_vma *);
5bd4f169 56
ad8e1ba5
AM		 57#define TARGET_LITTLE_SYM bfd_elf64_powerpcle_vec
58#define TARGET_LITTLE_NAME "elf64-powerpcle"
59#define TARGET_BIG_SYM bfd_elf64_powerpc_vec
60#define TARGET_BIG_NAME "elf64-powerpc"
61#define ELF_ARCH bfd_arch_powerpc
62#define ELF_MACHINE_CODE EM_PPC64
63#define ELF_MAXPAGESIZE 0x10000
24718e3b 64#define ELF_COMMONPAGESIZE 0x1000
ad8e1ba5
AM		 65#define elf_info_to_howto ppc64_elf_info_to_howto
66
67#define elf_backend_want_got_sym 0
68#define elf_backend_want_plt_sym 0
69#define elf_backend_plt_alignment 3
70#define elf_backend_plt_not_loaded 1
ad8e1ba5 71#define elf_backend_got_header_size 8
ad8e1ba5
AM		 72#define elf_backend_can_gc_sections 1
73#define elf_backend_can_refcount 1
74#define elf_backend_rela_normal 1
75
e717da7e 76#define bfd_elf64_mkobject ppc64_elf_mkobject
ad8e1ba5
AM		 77#define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
78#define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
79#define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
80#define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
81#define bfd_elf64_bfd_link_hash_table_free ppc64_elf_link_hash_table_free
90e3cdf2 82#define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
ad8e1ba5
AM		 83
84#define elf_backend_object_p ppc64_elf_object_p
d37c89e5
AM		 85#define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
86#define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
ad8e1ba5
AM		 87#define elf_backend_create_dynamic_sections ppc64_elf_create_dynamic_sections
88#define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
555cd476 89#define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
8387904d
AM		 90#define elf_backend_check_directives ppc64_elf_check_directives
91#define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
ad8e1ba5 92#define elf_backend_check_relocs ppc64_elf_check_relocs
64d03ab5 93#define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
ad8e1ba5
AM		 94#define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
95#define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
96#define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
97#define elf_backend_hide_symbol ppc64_elf_hide_symbol
98#define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
99#define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
60124e18 100#define elf_backend_action_discarded ppc64_elf_action_discarded
ad8e1ba5
AM		 101#define elf_backend_relocate_section ppc64_elf_relocate_section
102#define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
103#define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
104#define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
754021d0 105#define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
29ef7005 106#define elf_backend_special_sections ppc64_elf_special_sections
ad8e1ba5 107
5bd4f169
AM		 108/* The name of the dynamic interpreter. This is put in the .interp
109 section. */
110#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
111
112/* The size in bytes of an entry in the procedure linkage table. */
113#define PLT_ENTRY_SIZE 24
114
115/* The initial size of the plt reserved for the dynamic linker. */
5d1634d7 116#define PLT_INITIAL_ENTRY_SIZE PLT_ENTRY_SIZE
5bd4f169
AM		 117
118/* TOC base pointers offset from start of TOC. */
411e1bfb
AM		 119#define TOC_BASE_OFF 0x8000
120
121/* Offset of tp and dtp pointers from start of TLS block. */
122#define TP_OFFSET 0x7000
123#define DTP_OFFSET 0x8000
5bd4f169 124
ad8e1ba5
AM		 125/* .plt call stub instructions. The normal stub is like this, but
126 sometimes the .plt entry crosses a 64k boundary and we need to
127 insert an addis to adjust r12. */
128#define PLT_CALL_STUB_SIZE (7*4)
5d1634d7
AM		 129#define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
130#define STD_R2_40R1 0xf8410028 /* std %r2,40(%r1) */
131#define LD_R11_0R12 0xe96c0000 /* ld %r11,xxx+0@l(%r12) */
132#define LD_R2_0R12 0xe84c0000 /* ld %r2,xxx+8@l(%r12) */
133#define MTCTR_R11 0x7d6903a6 /* mtctr %r11 */
134 /* ld %r11,xxx+16@l(%r12) */
135#define BCTR 0x4e800420 /* bctr */
136
5d1634d7 137
ee4bf8d2 138#define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,off@ha */
ad8e1ba5
AM		 139#define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
140#define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
141
142#define LD_R2_40R1 0xe8410028 /* ld %r2,40(%r1) */
143
ee4bf8d2 144/* glink call stub instructions. We enter with the index in R0. */
ad8e1ba5 145#define GLINK_CALL_STUB_SIZE (16*4)
ee4bf8d2
AM		 146 /* 0: */
147 /* .quad plt0-1f */
148 /* __glink: */
149#define MFLR_R12 0x7d8802a6 /* mflr %12 */
150#define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
151 /* 1: */
152#define MFLR_R11 0x7d6802a6 /* mflr %11 */
153#define LD_R2_M16R11 0xe84bfff0 /* ld %2,(0b-1b)(%11) */
154#define MTLR_R12 0x7d8803a6 /* mtlr %12 */
155#define ADD_R12_R2_R11 0x7d825a14 /* add %12,%2,%11 */
156 /* ld %11,0(%12) */
157 /* ld %2,8(%12) */
158 /* mtctr %11 */
159 /* ld %11,16(%12) */
160 /* bctr */
5d1634d7
AM		 161
162/* Pad with this. */
163#define NOP 0x60000000
164
721956f4
AM		 165/* Some other nops. */
166#define CROR_151515 0x4def7b82
167#define CROR_313131 0x4ffffb82
168
cedb70c5 169/* .glink entries for the first 32k functions are two instructions. */
5d1634d7
AM		 170#define LI_R0_0 0x38000000 /* li %r0,0 */
171#define B_DOT 0x48000000 /* b . */
172
173/* After that, we need two instructions to load the index, followed by
174 a branch. */
175#define LIS_R0_0 0x3c000000 /* lis %r0,0 */
10ed1bba 176#define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
41bd81ab 177
deb0e272
AM		 178/* Instructions used by the save and restore reg functions. */
179#define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
180#define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
181#define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
182#define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
82bd7b59
AM		 183#define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
184#define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
deb0e272
AM		 185#define LI_R12_0 0x39800000 /* li %r12,0 */
186#define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
187#define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
188#define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
82bd7b59
AM		 189#define BLR 0x4e800020 /* blr */
190
41bd81ab
AM		 191/* Since .opd is an array of descriptors and each entry will end up
192 with identical R_PPC64_RELATIVE relocs, there is really no need to
193 propagate .opd relocs; The dynamic linker should be taught to
1e2f5b6e 194 relocate .opd without reloc entries. */
41bd81ab
AM		 195#ifndef NO_OPD_RELOCS
196#define NO_OPD_RELOCS 0
197#endif
5bd4f169 198\f
f5e87a1d 199#define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
b34976b6 200
5bd4f169 201/* Relocation HOWTO's. */
04c9666a 202static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
5bd4f169
AM		 203
204static reloc_howto_type ppc64_elf_howto_raw[] = {
205 /* This reloc does nothing. */
206 HOWTO (R_PPC64_NONE, /* type */
207 0, /* rightshift */
411e1bfb
AM		 208 2, /* size (0 = byte, 1 = short, 2 = long) */
209 32, /* bitsize */
b34976b6 210 FALSE, /* pc_relative */
5bd4f169 211 0, /* bitpos */
f5e87a1d 212 complain_overflow_dont, /* complain_on_overflow */
5bd4f169
AM		 213 bfd_elf_generic_reloc, /* special_function */
214 "R_PPC64_NONE", /* name */
b34976b6 215 FALSE, /* partial_inplace */
d006db6c 216 0, /* src_mask */
5bd4f169 217 0, /* dst_mask */
b34976b6 218 FALSE), /* pcrel_offset */
5bd4f169
AM		 219
220 /* A standard 32 bit relocation. */
221 HOWTO (R_PPC64_ADDR32, /* type */
222 0, /* rightshift */
223 2, /* size (0 = byte, 1 = short, 2 = long) */
224 32, /* bitsize */
b34976b6 225 FALSE, /* pc_relative */
5bd4f169
AM		 226 0, /* bitpos */
227 complain_overflow_bitfield, /* complain_on_overflow */
228 bfd_elf_generic_reloc, /* special_function */
229 "R_PPC64_ADDR32", /* name */
b34976b6 230 FALSE, /* partial_inplace */
5bd4f169
AM		 231 0, /* src_mask */
232 0xffffffff, /* dst_mask */
b34976b6 233 FALSE), /* pcrel_offset */
5bd4f169
AM		 234
235 /* An absolute 26 bit branch; the lower two bits must be zero.
236 FIXME: we don't check that, we just clear them. */
237 HOWTO (R_PPC64_ADDR24, /* type */
238 0, /* rightshift */
239 2, /* size (0 = byte, 1 = short, 2 = long) */
240 26, /* bitsize */
b34976b6 241 FALSE, /* pc_relative */
5bd4f169
AM		 242 0, /* bitpos */
243 complain_overflow_bitfield, /* complain_on_overflow */
244 bfd_elf_generic_reloc, /* special_function */
245 "R_PPC64_ADDR24", /* name */
b34976b6 246 FALSE, /* partial_inplace */
d006db6c 247 0, /* src_mask */
f5e87a1d 248 0x03fffffc, /* dst_mask */
b34976b6 249 FALSE), /* pcrel_offset */
5bd4f169
AM		 250
251 /* A standard 16 bit relocation. */
252 HOWTO (R_PPC64_ADDR16, /* type */
253 0, /* rightshift */
254 1, /* size (0 = byte, 1 = short, 2 = long) */
255 16, /* bitsize */
b34976b6 256 FALSE, /* pc_relative */
5bd4f169
AM		 257 0, /* bitpos */
258 complain_overflow_bitfield, /* complain_on_overflow */
259 bfd_elf_generic_reloc, /* special_function */
260 "R_PPC64_ADDR16", /* name */
b34976b6 261 FALSE, /* partial_inplace */
5bd4f169
AM		 262 0, /* src_mask */
263 0xffff, /* dst_mask */
b34976b6 264 FALSE), /* pcrel_offset */
5bd4f169
AM		 265
266 /* A 16 bit relocation without overflow. */
267 HOWTO (R_PPC64_ADDR16_LO, /* type */
268 0, /* rightshift */
269 1, /* size (0 = byte, 1 = short, 2 = long) */
270 16, /* bitsize */
b34976b6 271 FALSE, /* pc_relative */
5bd4f169
AM		 272 0, /* bitpos */
273 complain_overflow_dont,/* complain_on_overflow */
274 bfd_elf_generic_reloc, /* special_function */
275 "R_PPC64_ADDR16_LO", /* name */
b34976b6 276 FALSE, /* partial_inplace */
5bd4f169
AM		 277 0, /* src_mask */
278 0xffff, /* dst_mask */
b34976b6 279 FALSE), /* pcrel_offset */
5bd4f169
AM		 280
281 /* Bits 16-31 of an address. */
282 HOWTO (R_PPC64_ADDR16_HI, /* type */
283 16, /* rightshift */
284 1, /* size (0 = byte, 1 = short, 2 = long) */
285 16, /* bitsize */
b34976b6 286 FALSE, /* pc_relative */
5bd4f169
AM		 287 0, /* bitpos */
288 complain_overflow_dont, /* complain_on_overflow */
289 bfd_elf_generic_reloc, /* special_function */
290 "R_PPC64_ADDR16_HI", /* name */
b34976b6 291 FALSE, /* partial_inplace */
5bd4f169
AM		 292 0, /* src_mask */
293 0xffff, /* dst_mask */
b34976b6 294 FALSE), /* pcrel_offset */
5bd4f169
AM		 295
296 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
297 bits, treated as a signed number, is negative. */
298 HOWTO (R_PPC64_ADDR16_HA, /* type */
299 16, /* rightshift */
300 1, /* size (0 = byte, 1 = short, 2 = long) */
301 16, /* bitsize */
b34976b6 302 FALSE, /* pc_relative */
5bd4f169
AM		 303 0, /* bitpos */
304 complain_overflow_dont, /* complain_on_overflow */
805fc799 305 ppc64_elf_ha_reloc, /* special_function */
5bd4f169 306 "R_PPC64_ADDR16_HA", /* name */
b34976b6 307 FALSE, /* partial_inplace */
5bd4f169
AM		 308 0, /* src_mask */
309 0xffff, /* dst_mask */
b34976b6 310 FALSE), /* pcrel_offset */
5bd4f169
AM		 311
312 /* An absolute 16 bit branch; the lower two bits must be zero.
313 FIXME: we don't check that, we just clear them. */
314 HOWTO (R_PPC64_ADDR14, /* type */
315 0, /* rightshift */
316 2, /* size (0 = byte, 1 = short, 2 = long) */
317 16, /* bitsize */
b34976b6 318 FALSE, /* pc_relative */
5bd4f169
AM		 319 0, /* bitpos */
320 complain_overflow_bitfield, /* complain_on_overflow */
2441e016 321 ppc64_elf_branch_reloc, /* special_function */
5bd4f169 322 "R_PPC64_ADDR14", /* name */
b34976b6 323 FALSE, /* partial_inplace */
d006db6c 324 0, /* src_mask */
f5e87a1d 325 0x0000fffc, /* dst_mask */
b34976b6 326 FALSE), /* pcrel_offset */
5bd4f169
AM		 327
328 /* An absolute 16 bit branch, for which bit 10 should be set to
329 indicate that the branch is expected to be taken. The lower two
330 bits must be zero. */
331 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
332 0, /* rightshift */
333 2, /* size (0 = byte, 1 = short, 2 = long) */
334 16, /* bitsize */
b34976b6 335 FALSE, /* pc_relative */
5bd4f169
AM		 336 0, /* bitpos */
337 complain_overflow_bitfield, /* complain_on_overflow */
805fc799 338 ppc64_elf_brtaken_reloc, /* special_function */
5bd4f169 339 "R_PPC64_ADDR14_BRTAKEN",/* name */
b34976b6 340 FALSE, /* partial_inplace */
d006db6c 341 0, /* src_mask */
f5e87a1d 342 0x0000fffc, /* dst_mask */
b34976b6 343 FALSE), /* pcrel_offset */
5bd4f169
AM		 344
345 /* An absolute 16 bit branch, for which bit 10 should be set to
346 indicate that the branch is not expected to be taken. The lower
347 two bits must be zero. */
348 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
349 0, /* rightshift */
350 2, /* size (0 = byte, 1 = short, 2 = long) */
351 16, /* bitsize */
b34976b6 352 FALSE, /* pc_relative */
5bd4f169
AM		 353 0, /* bitpos */
354 complain_overflow_bitfield, /* complain_on_overflow */
805fc799 355 ppc64_elf_brtaken_reloc, /* special_function */
5bd4f169 356 "R_PPC64_ADDR14_BRNTAKEN",/* name */
b34976b6 357 FALSE, /* partial_inplace */
d006db6c 358 0, /* src_mask */
f5e87a1d 359 0x0000fffc, /* dst_mask */
b34976b6 360 FALSE), /* pcrel_offset */
5bd4f169
AM		 361
362 /* A relative 26 bit branch; the lower two bits must be zero. */
363 HOWTO (R_PPC64_REL24, /* type */
364 0, /* rightshift */
365 2, /* size (0 = byte, 1 = short, 2 = long) */
366 26, /* bitsize */
b34976b6 367 TRUE, /* pc_relative */
5bd4f169
AM		 368 0, /* bitpos */
369 complain_overflow_signed, /* complain_on_overflow */
2441e016 370 ppc64_elf_branch_reloc, /* special_function */
5bd4f169 371 "R_PPC64_REL24", /* name */
b34976b6 372 FALSE, /* partial_inplace */
d006db6c 373 0, /* src_mask */
f5e87a1d 374 0x03fffffc, /* dst_mask */
b34976b6 375 TRUE), /* pcrel_offset */
5bd4f169
AM		 376
377 /* A relative 16 bit branch; the lower two bits must be zero. */
378 HOWTO (R_PPC64_REL14, /* type */
379 0, /* rightshift */
380 2, /* size (0 = byte, 1 = short, 2 = long) */
381 16, /* bitsize */
b34976b6 382 TRUE, /* pc_relative */
5bd4f169
AM		 383 0, /* bitpos */
384 complain_overflow_signed, /* complain_on_overflow */
2441e016 385 ppc64_elf_branch_reloc, /* special_function */
5bd4f169 386 "R_PPC64_REL14", /* name */
b34976b6 387 FALSE, /* partial_inplace */
d006db6c 388 0, /* src_mask */
f5e87a1d 389 0x0000fffc, /* dst_mask */
b34976b6 390 TRUE), /* pcrel_offset */
5bd4f169
AM		 391
392 /* A relative 16 bit branch. Bit 10 should be set to indicate that
393 the branch is expected to be taken. The lower two bits must be
394 zero. */
395 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
396 0, /* rightshift */
397 2, /* size (0 = byte, 1 = short, 2 = long) */
398 16, /* bitsize */
b34976b6 399 TRUE, /* pc_relative */
5bd4f169
AM		 400 0, /* bitpos */
401 complain_overflow_signed, /* complain_on_overflow */
805fc799 402 ppc64_elf_brtaken_reloc, /* special_function */
5bd4f169 403 "R_PPC64_REL14_BRTAKEN", /* name */
b34976b6 404 FALSE, /* partial_inplace */
d006db6c 405 0, /* src_mask */
f5e87a1d 406 0x0000fffc, /* dst_mask */
b34976b6 407 TRUE), /* pcrel_offset */
5bd4f169
AM		 408
409 /* A relative 16 bit branch. Bit 10 should be set to indicate that
410 the branch is not expected to be taken. The lower two bits must
411 be zero. */
412 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
413 0, /* rightshift */
414 2, /* size (0 = byte, 1 = short, 2 = long) */
415 16, /* bitsize */
b34976b6 416 TRUE, /* pc_relative */
5bd4f169
AM		 417 0, /* bitpos */
418 complain_overflow_signed, /* complain_on_overflow */
805fc799 419 ppc64_elf_brtaken_reloc, /* special_function */
5bd4f169 420 "R_PPC64_REL14_BRNTAKEN",/* name */
b34976b6 421 FALSE, /* partial_inplace */
d006db6c 422 0, /* src_mask */
f5e87a1d 423 0x0000fffc, /* dst_mask */
b34976b6 424 TRUE), /* pcrel_offset */
5bd4f169
AM		 425
426 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
427 symbol. */
428 HOWTO (R_PPC64_GOT16, /* type */
429 0, /* rightshift */
430 1, /* size (0 = byte, 1 = short, 2 = long) */
431 16, /* bitsize */
b34976b6 432 FALSE, /* pc_relative */
5bd4f169
AM		 433 0, /* bitpos */
434 complain_overflow_signed, /* complain_on_overflow */
805fc799 435 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 436 "R_PPC64_GOT16", /* name */
b34976b6 437 FALSE, /* partial_inplace */
5bd4f169
AM		 438 0, /* src_mask */
439 0xffff, /* dst_mask */
b34976b6 440 FALSE), /* pcrel_offset */
5bd4f169
AM		 441
442 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
443 the symbol. */
444 HOWTO (R_PPC64_GOT16_LO, /* type */
445 0, /* rightshift */
446 1, /* size (0 = byte, 1 = short, 2 = long) */
447 16, /* bitsize */
b34976b6 448 FALSE, /* pc_relative */
5bd4f169
AM		 449 0, /* bitpos */
450 complain_overflow_dont, /* complain_on_overflow */
805fc799 451 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 452 "R_PPC64_GOT16_LO", /* name */
b34976b6 453 FALSE, /* partial_inplace */
5bd4f169
AM		 454 0, /* src_mask */
455 0xffff, /* dst_mask */
b34976b6 456 FALSE), /* pcrel_offset */
5bd4f169
AM		 457
458 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
459 the symbol. */
460 HOWTO (R_PPC64_GOT16_HI, /* type */
461 16, /* rightshift */
462 1, /* size (0 = byte, 1 = short, 2 = long) */
463 16, /* bitsize */
b34976b6 464 FALSE, /* pc_relative */
5bd4f169
AM		 465 0, /* bitpos */
466 complain_overflow_dont,/* complain_on_overflow */
805fc799 467 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 468 "R_PPC64_GOT16_HI", /* name */
b34976b6 469 FALSE, /* partial_inplace */
5bd4f169
AM		 470 0, /* src_mask */
471 0xffff, /* dst_mask */
b34976b6 472 FALSE), /* pcrel_offset */
5bd4f169
AM		 473
474 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
475 the symbol. */
476 HOWTO (R_PPC64_GOT16_HA, /* type */
477 16, /* rightshift */
478 1, /* size (0 = byte, 1 = short, 2 = long) */
479 16, /* bitsize */
b34976b6 480 FALSE, /* pc_relative */
5bd4f169
AM		 481 0, /* bitpos */
482 complain_overflow_dont,/* complain_on_overflow */
805fc799 483 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 484 "R_PPC64_GOT16_HA", /* name */
b34976b6 485 FALSE, /* partial_inplace */
5bd4f169
AM		 486 0, /* src_mask */
487 0xffff, /* dst_mask */
b34976b6 488 FALSE), /* pcrel_offset */
5bd4f169
AM		 489
490 /* This is used only by the dynamic linker. The symbol should exist
491 both in the object being run and in some shared library. The
492 dynamic linker copies the data addressed by the symbol from the
493 shared library into the object, because the object being
494 run has to have the data at some particular address. */
495 HOWTO (R_PPC64_COPY, /* type */
496 0, /* rightshift */
f5e87a1d
AM		 497 0, /* this one is variable size */
498 0, /* bitsize */
b34976b6 499 FALSE, /* pc_relative */
5bd4f169 500 0, /* bitpos */
f5e87a1d
AM		 501 complain_overflow_dont, /* complain_on_overflow */
502 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 503 "R_PPC64_COPY", /* name */
b34976b6 504 FALSE, /* partial_inplace */
5bd4f169
AM		 505 0, /* src_mask */
506 0, /* dst_mask */
b34976b6 507 FALSE), /* pcrel_offset */
5bd4f169
AM		 508
509 /* Like R_PPC64_ADDR64, but used when setting global offset table
510 entries. */
511 HOWTO (R_PPC64_GLOB_DAT, /* type */
512 0, /* rightshift */
513 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
514 64, /* bitsize */
b34976b6 515 FALSE, /* pc_relative */
5bd4f169
AM		 516 0, /* bitpos */
517 complain_overflow_dont, /* complain_on_overflow */
805fc799 518 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 519 "R_PPC64_GLOB_DAT", /* name */
b34976b6 520 FALSE, /* partial_inplace */
5bd4f169 521 0, /* src_mask */
f5e87a1d 522 ONES (64), /* dst_mask */
b34976b6 523 FALSE), /* pcrel_offset */
5bd4f169
AM		 524
525 /* Created by the link editor. Marks a procedure linkage table
526 entry for a symbol. */
527 HOWTO (R_PPC64_JMP_SLOT, /* type */
528 0, /* rightshift */
529 0, /* size (0 = byte, 1 = short, 2 = long) */
530 0, /* bitsize */
b34976b6 531 FALSE, /* pc_relative */
5bd4f169
AM		 532 0, /* bitpos */
533 complain_overflow_dont, /* complain_on_overflow */
805fc799 534 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 535 "R_PPC64_JMP_SLOT", /* name */
b34976b6 536 FALSE, /* partial_inplace */
5bd4f169
AM		 537 0, /* src_mask */
538 0, /* dst_mask */
b34976b6 539 FALSE), /* pcrel_offset */
5bd4f169
AM		 540
541 /* Used only by the dynamic linker. When the object is run, this
542 doubleword64 is set to the load address of the object, plus the
543 addend. */
544 HOWTO (R_PPC64_RELATIVE, /* type */
545 0, /* rightshift */
546 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
547 64, /* bitsize */
b34976b6 548 FALSE, /* pc_relative */
5bd4f169
AM		 549 0, /* bitpos */
550 complain_overflow_dont, /* complain_on_overflow */
551 bfd_elf_generic_reloc, /* special_function */
552 "R_PPC64_RELATIVE", /* name */
b34976b6 553 FALSE, /* partial_inplace */
5bd4f169 554 0, /* src_mask */
f5e87a1d 555 ONES (64), /* dst_mask */
b34976b6 556 FALSE), /* pcrel_offset */
5bd4f169
AM		 557
558 /* Like R_PPC64_ADDR32, but may be unaligned. */
559 HOWTO (R_PPC64_UADDR32, /* type */
560 0, /* rightshift */
561 2, /* size (0 = byte, 1 = short, 2 = long) */
562 32, /* bitsize */
b34976b6 563 FALSE, /* pc_relative */
5bd4f169
AM		 564 0, /* bitpos */
565 complain_overflow_bitfield, /* complain_on_overflow */
566 bfd_elf_generic_reloc, /* special_function */
567 "R_PPC64_UADDR32", /* name */
b34976b6 568 FALSE, /* partial_inplace */
5bd4f169
AM		 569 0, /* src_mask */
570 0xffffffff, /* dst_mask */
b34976b6 571 FALSE), /* pcrel_offset */
5bd4f169
AM		 572
573 /* Like R_PPC64_ADDR16, but may be unaligned. */
574 HOWTO (R_PPC64_UADDR16, /* type */
575 0, /* rightshift */
576 1, /* size (0 = byte, 1 = short, 2 = long) */
577 16, /* bitsize */
b34976b6 578 FALSE, /* pc_relative */
5bd4f169
AM		 579 0, /* bitpos */
580 complain_overflow_bitfield, /* complain_on_overflow */
581 bfd_elf_generic_reloc, /* special_function */
582 "R_PPC64_UADDR16", /* name */
b34976b6 583 FALSE, /* partial_inplace */
5bd4f169
AM		 584 0, /* src_mask */
585 0xffff, /* dst_mask */
b34976b6 586 FALSE), /* pcrel_offset */
5bd4f169
AM		 587
588 /* 32-bit PC relative. */
589 HOWTO (R_PPC64_REL32, /* type */
590 0, /* rightshift */
591 2, /* size (0 = byte, 1 = short, 2 = long) */
592 32, /* bitsize */
b34976b6 593 TRUE, /* pc_relative */
5bd4f169 594 0, /* bitpos */
cedb70c5 595 /* FIXME: Verify. Was complain_overflow_bitfield. */
5bd4f169
AM		 596 complain_overflow_signed, /* complain_on_overflow */
597 bfd_elf_generic_reloc, /* special_function */
598 "R_PPC64_REL32", /* name */
b34976b6 599 FALSE, /* partial_inplace */
5bd4f169
AM		 600 0, /* src_mask */
601 0xffffffff, /* dst_mask */
b34976b6 602 TRUE), /* pcrel_offset */
5bd4f169 603
10ed1bba 604 /* 32-bit relocation to the symbol's procedure linkage table. */
5bd4f169
AM		 605 HOWTO (R_PPC64_PLT32, /* type */
606 0, /* rightshift */
607 2, /* size (0 = byte, 1 = short, 2 = long) */
608 32, /* bitsize */
b34976b6 609 FALSE, /* pc_relative */
5bd4f169
AM		 610 0, /* bitpos */
611 complain_overflow_bitfield, /* complain_on_overflow */
805fc799 612 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 613 "R_PPC64_PLT32", /* name */
b34976b6 614 FALSE, /* partial_inplace */
5bd4f169 615 0, /* src_mask */
f5e87a1d 616 0xffffffff, /* dst_mask */
b34976b6 617 FALSE), /* pcrel_offset */
5bd4f169
AM		 618
619 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
620 FIXME: R_PPC64_PLTREL32 not supported. */
621 HOWTO (R_PPC64_PLTREL32, /* type */
622 0, /* rightshift */
623 2, /* size (0 = byte, 1 = short, 2 = long) */
624 32, /* bitsize */
b34976b6 625 TRUE, /* pc_relative */
5bd4f169
AM		 626 0, /* bitpos */
627 complain_overflow_signed, /* complain_on_overflow */
628 bfd_elf_generic_reloc, /* special_function */
629 "R_PPC64_PLTREL32", /* name */
b34976b6 630 FALSE, /* partial_inplace */
5bd4f169 631 0, /* src_mask */
f5e87a1d 632 0xffffffff, /* dst_mask */
b34976b6 633 TRUE), /* pcrel_offset */
5bd4f169
AM		 634
635 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
636 the symbol. */
637 HOWTO (R_PPC64_PLT16_LO, /* type */
638 0, /* rightshift */
639 1, /* size (0 = byte, 1 = short, 2 = long) */
640 16, /* bitsize */
b34976b6 641 FALSE, /* pc_relative */
5bd4f169
AM		 642 0, /* bitpos */
643 complain_overflow_dont, /* complain_on_overflow */
805fc799 644 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 645 "R_PPC64_PLT16_LO", /* name */
b34976b6 646 FALSE, /* partial_inplace */
5bd4f169
AM		 647 0, /* src_mask */
648 0xffff, /* dst_mask */
b34976b6 649 FALSE), /* pcrel_offset */
5bd4f169
AM		 650
651 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
652 the symbol. */
653 HOWTO (R_PPC64_PLT16_HI, /* type */
654 16, /* rightshift */
655 1, /* size (0 = byte, 1 = short, 2 = long) */
656 16, /* bitsize */
b34976b6 657 FALSE, /* pc_relative */
5bd4f169
AM		 658 0, /* bitpos */
659 complain_overflow_dont, /* complain_on_overflow */
805fc799 660 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 661 "R_PPC64_PLT16_HI", /* name */
b34976b6 662 FALSE, /* partial_inplace */
5bd4f169
AM		 663 0, /* src_mask */
664 0xffff, /* dst_mask */
b34976b6 665 FALSE), /* pcrel_offset */
5bd4f169
AM		 666
667 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
668 the symbol. */
669 HOWTO (R_PPC64_PLT16_HA, /* type */
670 16, /* rightshift */
671 1, /* size (0 = byte, 1 = short, 2 = long) */
672 16, /* bitsize */
b34976b6 673 FALSE, /* pc_relative */
5bd4f169
AM		 674 0, /* bitpos */
675 complain_overflow_dont, /* complain_on_overflow */
805fc799 676 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 677 "R_PPC64_PLT16_HA", /* name */
b34976b6 678 FALSE, /* partial_inplace */
5bd4f169
AM		 679 0, /* src_mask */
680 0xffff, /* dst_mask */
b34976b6 681 FALSE), /* pcrel_offset */
5bd4f169 682
c061c2d8 683 /* 16-bit section relative relocation. */
5bd4f169
AM		 684 HOWTO (R_PPC64_SECTOFF, /* type */
685 0, /* rightshift */
c061c2d8
AM		 686 1, /* size (0 = byte, 1 = short, 2 = long) */
687 16, /* bitsize */
b34976b6 688 FALSE, /* pc_relative */
5bd4f169
AM		 689 0, /* bitpos */
690 complain_overflow_bitfield, /* complain_on_overflow */
805fc799 691 ppc64_elf_sectoff_reloc, /* special_function */
5bd4f169 692 "R_PPC64_SECTOFF", /* name */
b34976b6 693 FALSE, /* partial_inplace */
5bd4f169 694 0, /* src_mask */
c061c2d8 695 0xffff, /* dst_mask */
b34976b6 696 FALSE), /* pcrel_offset */
5bd4f169 697
c061c2d8 698 /* Like R_PPC64_SECTOFF, but no overflow warning. */
5bd4f169
AM		 699 HOWTO (R_PPC64_SECTOFF_LO, /* type */
700 0, /* rightshift */
701 1, /* size (0 = byte, 1 = short, 2 = long) */
702 16, /* bitsize */
b34976b6 703 FALSE, /* pc_relative */
5bd4f169
AM		 704 0, /* bitpos */
705 complain_overflow_dont, /* complain_on_overflow */
805fc799 706 ppc64_elf_sectoff_reloc, /* special_function */
5bd4f169 707 "R_PPC64_SECTOFF_LO", /* name */
b34976b6 708 FALSE, /* partial_inplace */
5bd4f169
AM		 709 0, /* src_mask */
710 0xffff, /* dst_mask */
b34976b6 711 FALSE), /* pcrel_offset */
5bd4f169
AM		 712
713 /* 16-bit upper half section relative relocation. */
714 HOWTO (R_PPC64_SECTOFF_HI, /* type */
715 16, /* rightshift */
716 1, /* size (0 = byte, 1 = short, 2 = long) */
717 16, /* bitsize */
b34976b6 718 FALSE, /* pc_relative */
5bd4f169
AM		 719 0, /* bitpos */
720 complain_overflow_dont, /* complain_on_overflow */
805fc799 721 ppc64_elf_sectoff_reloc, /* special_function */
5bd4f169 722 "R_PPC64_SECTOFF_HI", /* name */
b34976b6 723 FALSE, /* partial_inplace */
5bd4f169
AM		 724 0, /* src_mask */
725 0xffff, /* dst_mask */
b34976b6 726 FALSE), /* pcrel_offset */
5bd4f169
AM		 727
728 /* 16-bit upper half adjusted section relative relocation. */
729 HOWTO (R_PPC64_SECTOFF_HA, /* type */
730 16, /* rightshift */
731 1, /* size (0 = byte, 1 = short, 2 = long) */
732 16, /* bitsize */
b34976b6 733 FALSE, /* pc_relative */
5bd4f169
AM		 734 0, /* bitpos */
735 complain_overflow_dont, /* complain_on_overflow */
805fc799 736 ppc64_elf_sectoff_ha_reloc, /* special_function */
5bd4f169 737 "R_PPC64_SECTOFF_HA", /* name */
b34976b6 738 FALSE, /* partial_inplace */
5bd4f169
AM		 739 0, /* src_mask */
740 0xffff, /* dst_mask */
b34976b6 741 FALSE), /* pcrel_offset */
5bd4f169 742
04c9666a
AM		 743 /* Like R_PPC64_REL24 without touching the two least significant bits. */
744 HOWTO (R_PPC64_REL30, /* type */
5bd4f169
AM		 745 2, /* rightshift */
746 2, /* size (0 = byte, 1 = short, 2 = long) */
747 30, /* bitsize */
b34976b6 748 TRUE, /* pc_relative */
5bd4f169
AM		 749 0, /* bitpos */
750 complain_overflow_dont, /* complain_on_overflow */
751 bfd_elf_generic_reloc, /* special_function */
04c9666a 752 "R_PPC64_REL30", /* name */
b34976b6 753 FALSE, /* partial_inplace */
d006db6c 754 0, /* src_mask */
5bd4f169 755 0xfffffffc, /* dst_mask */
b34976b6 756 TRUE), /* pcrel_offset */
5bd4f169
AM		 757
758 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
759
760 /* A standard 64-bit relocation. */
761 HOWTO (R_PPC64_ADDR64, /* type */
762 0, /* rightshift */
763 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
764 64, /* bitsize */
b34976b6 765 FALSE, /* pc_relative */
5bd4f169
AM		 766 0, /* bitpos */
767 complain_overflow_dont, /* complain_on_overflow */
768 bfd_elf_generic_reloc, /* special_function */
769 "R_PPC64_ADDR64", /* name */
b34976b6 770 FALSE, /* partial_inplace */
5bd4f169 771 0, /* src_mask */
f5e87a1d 772 ONES (64), /* dst_mask */
b34976b6 773 FALSE), /* pcrel_offset */
5bd4f169
AM		 774
775 /* The bits 32-47 of an address. */
776 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
777 32, /* rightshift */
778 1, /* size (0 = byte, 1 = short, 2 = long) */
779 16, /* bitsize */
b34976b6 780 FALSE, /* pc_relative */
5bd4f169
AM		 781 0, /* bitpos */
782 complain_overflow_dont, /* complain_on_overflow */
783 bfd_elf_generic_reloc, /* special_function */
784 "R_PPC64_ADDR16_HIGHER", /* name */
b34976b6 785 FALSE, /* partial_inplace */
5bd4f169
AM		 786 0, /* src_mask */
787 0xffff, /* dst_mask */
b34976b6 788 FALSE), /* pcrel_offset */
5bd4f169
AM		 789
790 /* The bits 32-47 of an address, plus 1 if the contents of the low
791 16 bits, treated as a signed number, is negative. */
792 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
793 32, /* rightshift */
794 1, /* size (0 = byte, 1 = short, 2 = long) */
795 16, /* bitsize */
b34976b6 796 FALSE, /* pc_relative */
5bd4f169
AM		 797 0, /* bitpos */
798 complain_overflow_dont, /* complain_on_overflow */
805fc799 799 ppc64_elf_ha_reloc, /* special_function */
5bd4f169 800 "R_PPC64_ADDR16_HIGHERA", /* name */
b34976b6 801 FALSE, /* partial_inplace */
5bd4f169
AM		 802 0, /* src_mask */
803 0xffff, /* dst_mask */
b34976b6 804 FALSE), /* pcrel_offset */
5bd4f169
AM		 805
806 /* The bits 48-63 of an address. */
807 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
808 48, /* rightshift */
809 1, /* size (0 = byte, 1 = short, 2 = long) */
810 16, /* bitsize */
b34976b6 811 FALSE, /* pc_relative */
5bd4f169
AM		 812 0, /* bitpos */
813 complain_overflow_dont, /* complain_on_overflow */
814 bfd_elf_generic_reloc, /* special_function */
815 "R_PPC64_ADDR16_HIGHEST", /* name */
b34976b6 816 FALSE, /* partial_inplace */
5bd4f169
AM		 817 0, /* src_mask */
818 0xffff, /* dst_mask */
b34976b6 819 FALSE), /* pcrel_offset */
5bd4f169
AM		 820
821 /* The bits 48-63 of an address, plus 1 if the contents of the low
822 16 bits, treated as a signed number, is negative. */
823 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
824 48, /* rightshift */
825 1, /* size (0 = byte, 1 = short, 2 = long) */
826 16, /* bitsize */
b34976b6 827 FALSE, /* pc_relative */
5bd4f169
AM		 828 0, /* bitpos */
829 complain_overflow_dont, /* complain_on_overflow */
805fc799 830 ppc64_elf_ha_reloc, /* special_function */
5bd4f169 831 "R_PPC64_ADDR16_HIGHESTA", /* name */
b34976b6 832 FALSE, /* partial_inplace */
5bd4f169
AM		 833 0, /* src_mask */
834 0xffff, /* dst_mask */
b34976b6 835 FALSE), /* pcrel_offset */
5bd4f169
AM		 836
837 /* Like ADDR64, but may be unaligned. */
838 HOWTO (R_PPC64_UADDR64, /* type */
839 0, /* rightshift */
840 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
841 64, /* bitsize */
b34976b6 842 FALSE, /* pc_relative */
5bd4f169
AM		 843 0, /* bitpos */
844 complain_overflow_dont, /* complain_on_overflow */
845 bfd_elf_generic_reloc, /* special_function */
846 "R_PPC64_UADDR64", /* name */
b34976b6 847 FALSE, /* partial_inplace */
5bd4f169 848 0, /* src_mask */
f5e87a1d 849 ONES (64), /* dst_mask */
b34976b6 850 FALSE), /* pcrel_offset */
5bd4f169
AM		 851
852 /* 64-bit relative relocation. */
853 HOWTO (R_PPC64_REL64, /* type */
854 0, /* rightshift */
855 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
856 64, /* bitsize */
b34976b6 857 TRUE, /* pc_relative */
5bd4f169
AM		 858 0, /* bitpos */
859 complain_overflow_dont, /* complain_on_overflow */
860 bfd_elf_generic_reloc, /* special_function */
861 "R_PPC64_REL64", /* name */
b34976b6 862 FALSE, /* partial_inplace */
5bd4f169 863 0, /* src_mask */
f5e87a1d 864 ONES (64), /* dst_mask */
b34976b6 865 TRUE), /* pcrel_offset */
5bd4f169 866
cedb70c5 867 /* 64-bit relocation to the symbol's procedure linkage table. */
5bd4f169
AM		 868 HOWTO (R_PPC64_PLT64, /* type */
869 0, /* rightshift */
870 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
871 64, /* bitsize */
b34976b6 872 FALSE, /* pc_relative */
5bd4f169
AM		 873 0, /* bitpos */
874 complain_overflow_dont, /* complain_on_overflow */
805fc799 875 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 876 "R_PPC64_PLT64", /* name */
b34976b6 877 FALSE, /* partial_inplace */
5bd4f169 878 0, /* src_mask */
f5e87a1d 879 ONES (64), /* dst_mask */
b34976b6 880 FALSE), /* pcrel_offset */
5bd4f169
AM		 881
882 /* 64-bit PC relative relocation to the symbol's procedure linkage
883 table. */
884 /* FIXME: R_PPC64_PLTREL64 not supported. */
885 HOWTO (R_PPC64_PLTREL64, /* type */
886 0, /* rightshift */
887 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
888 64, /* bitsize */
b34976b6 889 TRUE, /* pc_relative */
5bd4f169
AM		 890 0, /* bitpos */
891 complain_overflow_dont, /* complain_on_overflow */
805fc799 892 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 893 "R_PPC64_PLTREL64", /* name */
b34976b6 894 FALSE, /* partial_inplace */
5bd4f169 895 0, /* src_mask */
f5e87a1d 896 ONES (64), /* dst_mask */
b34976b6 897 TRUE), /* pcrel_offset */
5bd4f169
AM		 898
899 /* 16 bit TOC-relative relocation. */
900
901 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
902 HOWTO (R_PPC64_TOC16, /* type */
903 0, /* rightshift */
904 1, /* size (0 = byte, 1 = short, 2 = long) */
905 16, /* bitsize */
b34976b6 906 FALSE, /* pc_relative */
5bd4f169
AM		 907 0, /* bitpos */
908 complain_overflow_signed, /* complain_on_overflow */
805fc799 909 ppc64_elf_toc_reloc, /* special_function */
5bd4f169 910 "R_PPC64_TOC16", /* name */
b34976b6 911 FALSE, /* partial_inplace */
5bd4f169
AM		 912 0, /* src_mask */
913 0xffff, /* dst_mask */
b34976b6 914 FALSE), /* pcrel_offset */
5bd4f169
AM		 915
916 /* 16 bit TOC-relative relocation without overflow. */
917
918 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
919 HOWTO (R_PPC64_TOC16_LO, /* type */
920 0, /* rightshift */
921 1, /* size (0 = byte, 1 = short, 2 = long) */
922 16, /* bitsize */
b34976b6 923 FALSE, /* pc_relative */
5bd4f169
AM		 924 0, /* bitpos */
925 complain_overflow_dont, /* complain_on_overflow */
805fc799 926 ppc64_elf_toc_reloc, /* special_function */
5bd4f169 927 "R_PPC64_TOC16_LO", /* name */
b34976b6 928 FALSE, /* partial_inplace */
5bd4f169
AM		 929 0, /* src_mask */
930 0xffff, /* dst_mask */
b34976b6 931 FALSE), /* pcrel_offset */
5bd4f169
AM		 932
933 /* 16 bit TOC-relative relocation, high 16 bits. */
934
935 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
936 HOWTO (R_PPC64_TOC16_HI, /* type */
937 16, /* rightshift */
938 1, /* size (0 = byte, 1 = short, 2 = long) */
939 16, /* bitsize */
b34976b6 940 FALSE, /* pc_relative */
5bd4f169
AM		 941 0, /* bitpos */
942 complain_overflow_dont, /* complain_on_overflow */
805fc799 943 ppc64_elf_toc_reloc, /* special_function */
5bd4f169 944 "R_PPC64_TOC16_HI", /* name */
b34976b6 945 FALSE, /* partial_inplace */
5bd4f169
AM		 946 0, /* src_mask */
947 0xffff, /* dst_mask */
b34976b6 948 FALSE), /* pcrel_offset */
5bd4f169
AM		 949
950 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
951 contents of the low 16 bits, treated as a signed number, is
952 negative. */
953
954 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
955 HOWTO (R_PPC64_TOC16_HA, /* type */
956 16, /* rightshift */
957 1, /* size (0 = byte, 1 = short, 2 = long) */
958 16, /* bitsize */
b34976b6 959 FALSE, /* pc_relative */
5bd4f169
AM		 960 0, /* bitpos */
961 complain_overflow_dont, /* complain_on_overflow */
805fc799 962 ppc64_elf_toc_ha_reloc, /* special_function */
5bd4f169 963 "R_PPC64_TOC16_HA", /* name */
b34976b6 964 FALSE, /* partial_inplace */
5bd4f169
AM		 965 0, /* src_mask */
966 0xffff, /* dst_mask */
b34976b6 967 FALSE), /* pcrel_offset */
5bd4f169
AM		 968
969 /* 64-bit relocation; insert value of TOC base (.TOC.). */
970
971 /* R_PPC64_TOC 51 doubleword64 .TOC. */
972 HOWTO (R_PPC64_TOC, /* type */
973 0, /* rightshift */
974 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
975 64, /* bitsize */
b34976b6 976 FALSE, /* pc_relative */
5bd4f169
AM		 977 0, /* bitpos */
978 complain_overflow_bitfield, /* complain_on_overflow */
805fc799 979 ppc64_elf_toc64_reloc, /* special_function */
5bd4f169 980 "R_PPC64_TOC", /* name */
b34976b6 981 FALSE, /* partial_inplace */
5bd4f169 982 0, /* src_mask */
f5e87a1d 983 ONES (64), /* dst_mask */
b34976b6 984 FALSE), /* pcrel_offset */
5bd4f169
AM		 985
986 /* Like R_PPC64_GOT16, but also informs the link editor that the
987 value to relocate may (!) refer to a PLT entry which the link
988 editor (a) may replace with the symbol value. If the link editor
989 is unable to fully resolve the symbol, it may (b) create a PLT
990 entry and store the address to the new PLT entry in the GOT.
991 This permits lazy resolution of function symbols at run time.
992 The link editor may also skip all of this and just (c) emit a
993 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
994 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
995 HOWTO (R_PPC64_PLTGOT16, /* type */
996 0, /* rightshift */
997 1, /* size (0 = byte, 1 = short, 2 = long) */
998 16, /* bitsize */
b34976b6 999 FALSE, /* pc_relative */
5bd4f169
AM		 1000 0, /* bitpos */
1001 complain_overflow_signed, /* complain_on_overflow */
805fc799 1002 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb
AM		 1003 "R_PPC64_PLTGOT16", /* name */
1004 FALSE, /* partial_inplace */
1005 0, /* src_mask */
1006 0xffff, /* dst_mask */
1007 FALSE), /* pcrel_offset */
1008
1009 /* Like R_PPC64_PLTGOT16, but without overflow. */
1010 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1011 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1012 0, /* rightshift */
1013 1, /* size (0 = byte, 1 = short, 2 = long) */
1014 16, /* bitsize */
1015 FALSE, /* pc_relative */
1016 0, /* bitpos */
1017 complain_overflow_dont, /* complain_on_overflow */
1018 ppc64_elf_unhandled_reloc, /* special_function */
1019 "R_PPC64_PLTGOT16_LO", /* name */
1020 FALSE, /* partial_inplace */
1021 0, /* src_mask */
1022 0xffff, /* dst_mask */
1023 FALSE), /* pcrel_offset */
1024
1025 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1026 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1027 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1028 16, /* rightshift */
1029 1, /* size (0 = byte, 1 = short, 2 = long) */
1030 16, /* bitsize */
1031 FALSE, /* pc_relative */
1032 0, /* bitpos */
1033 complain_overflow_dont, /* complain_on_overflow */
1034 ppc64_elf_unhandled_reloc, /* special_function */
1035 "R_PPC64_PLTGOT16_HI", /* name */
1036 FALSE, /* partial_inplace */
1037 0, /* src_mask */
1038 0xffff, /* dst_mask */
1039 FALSE), /* pcrel_offset */
1040
1041 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1042 1 if the contents of the low 16 bits, treated as a signed number,
1043 is negative. */
1044 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1045 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1046 16, /* rightshift */
1047 1, /* size (0 = byte, 1 = short, 2 = long) */
1048 16, /* bitsize */
1049 FALSE, /* pc_relative */
1050 0, /* bitpos */
1051 complain_overflow_dont,/* complain_on_overflow */
1052 ppc64_elf_unhandled_reloc, /* special_function */
1053 "R_PPC64_PLTGOT16_HA", /* name */
1054 FALSE, /* partial_inplace */
1055 0, /* src_mask */
1056 0xffff, /* dst_mask */
1057 FALSE), /* pcrel_offset */
1058
1059 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1060 HOWTO (R_PPC64_ADDR16_DS, /* type */
1061 0, /* rightshift */
1062 1, /* size (0 = byte, 1 = short, 2 = long) */
1063 16, /* bitsize */
1064 FALSE, /* pc_relative */
1065 0, /* bitpos */
1066 complain_overflow_bitfield, /* complain_on_overflow */
1067 bfd_elf_generic_reloc, /* special_function */
1068 "R_PPC64_ADDR16_DS", /* name */
1069 FALSE, /* partial_inplace */
1070 0, /* src_mask */
1071 0xfffc, /* dst_mask */
1072 FALSE), /* pcrel_offset */
1073
1074 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1075 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1076 0, /* rightshift */
1077 1, /* size (0 = byte, 1 = short, 2 = long) */
1078 16, /* bitsize */
1079 FALSE, /* pc_relative */
1080 0, /* bitpos */
1081 complain_overflow_dont,/* complain_on_overflow */
1082 bfd_elf_generic_reloc, /* special_function */
1083 "R_PPC64_ADDR16_LO_DS",/* name */
1084 FALSE, /* partial_inplace */
1085 0, /* src_mask */
1086 0xfffc, /* dst_mask */
1087 FALSE), /* pcrel_offset */
1088
1089 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1090 HOWTO (R_PPC64_GOT16_DS, /* type */
1091 0, /* rightshift */
1092 1, /* size (0 = byte, 1 = short, 2 = long) */
1093 16, /* bitsize */
1094 FALSE, /* pc_relative */
1095 0, /* bitpos */
1096 complain_overflow_signed, /* complain_on_overflow */
1097 ppc64_elf_unhandled_reloc, /* special_function */
1098 "R_PPC64_GOT16_DS", /* name */
1099 FALSE, /* partial_inplace */
1100 0, /* src_mask */
1101 0xfffc, /* dst_mask */
1102 FALSE), /* pcrel_offset */
1103
1104 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1105 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1106 0, /* rightshift */
1107 1, /* size (0 = byte, 1 = short, 2 = long) */
1108 16, /* bitsize */
1109 FALSE, /* pc_relative */
1110 0, /* bitpos */
1111 complain_overflow_dont, /* complain_on_overflow */
1112 ppc64_elf_unhandled_reloc, /* special_function */
1113 "R_PPC64_GOT16_LO_DS", /* name */
1114 FALSE, /* partial_inplace */
1115 0, /* src_mask */
1116 0xfffc, /* dst_mask */
1117 FALSE), /* pcrel_offset */
1118
1119 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1120 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1121 0, /* rightshift */
1122 1, /* size (0 = byte, 1 = short, 2 = long) */
1123 16, /* bitsize */
1124 FALSE, /* pc_relative */
1125 0, /* bitpos */
1126 complain_overflow_dont, /* complain_on_overflow */
1127 ppc64_elf_unhandled_reloc, /* special_function */
1128 "R_PPC64_PLT16_LO_DS", /* name */
1129 FALSE, /* partial_inplace */
1130 0, /* src_mask */
1131 0xfffc, /* dst_mask */
1132 FALSE), /* pcrel_offset */
1133
1134 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1135 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1136 0, /* rightshift */
1137 1, /* size (0 = byte, 1 = short, 2 = long) */
1138 16, /* bitsize */
1139 FALSE, /* pc_relative */
1140 0, /* bitpos */
1141 complain_overflow_bitfield, /* complain_on_overflow */
1142 ppc64_elf_sectoff_reloc, /* special_function */
1143 "R_PPC64_SECTOFF_DS", /* name */
1144 FALSE, /* partial_inplace */
1145 0, /* src_mask */
1146 0xfffc, /* dst_mask */
1147 FALSE), /* pcrel_offset */
1148
1149 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1150 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1151 0, /* rightshift */
1152 1, /* size (0 = byte, 1 = short, 2 = long) */
1153 16, /* bitsize */
1154 FALSE, /* pc_relative */
1155 0, /* bitpos */
1156 complain_overflow_dont, /* complain_on_overflow */
1157 ppc64_elf_sectoff_reloc, /* special_function */
1158 "R_PPC64_SECTOFF_LO_DS",/* name */
1159 FALSE, /* partial_inplace */
1160 0, /* src_mask */
1161 0xfffc, /* dst_mask */
1162 FALSE), /* pcrel_offset */
1163
1164 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1165 HOWTO (R_PPC64_TOC16_DS, /* type */
1166 0, /* rightshift */
1167 1, /* size (0 = byte, 1 = short, 2 = long) */
1168 16, /* bitsize */
1169 FALSE, /* pc_relative */
1170 0, /* bitpos */
1171 complain_overflow_signed, /* complain_on_overflow */
1172 ppc64_elf_toc_reloc, /* special_function */
1173 "R_PPC64_TOC16_DS", /* name */
1174 FALSE, /* partial_inplace */
1175 0, /* src_mask */
1176 0xfffc, /* dst_mask */
1177 FALSE), /* pcrel_offset */
1178
1179 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1180 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1181 0, /* rightshift */
1182 1, /* size (0 = byte, 1 = short, 2 = long) */
1183 16, /* bitsize */
1184 FALSE, /* pc_relative */
1185 0, /* bitpos */
1186 complain_overflow_dont, /* complain_on_overflow */
1187 ppc64_elf_toc_reloc, /* special_function */
1188 "R_PPC64_TOC16_LO_DS", /* name */
1189 FALSE, /* partial_inplace */
1190 0, /* src_mask */
1191 0xfffc, /* dst_mask */
1192 FALSE), /* pcrel_offset */
1193
1194 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1195 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1196 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1197 0, /* rightshift */
1198 1, /* size (0 = byte, 1 = short, 2 = long) */
1199 16, /* bitsize */
1200 FALSE, /* pc_relative */
1201 0, /* bitpos */
1202 complain_overflow_signed, /* complain_on_overflow */
1203 ppc64_elf_unhandled_reloc, /* special_function */
1204 "R_PPC64_PLTGOT16_DS", /* name */
1205 FALSE, /* partial_inplace */
1206 0, /* src_mask */
1207 0xfffc, /* dst_mask */
1208 FALSE), /* pcrel_offset */
1209
1210 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1211 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1212 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1213 0, /* rightshift */
1214 1, /* size (0 = byte, 1 = short, 2 = long) */
1215 16, /* bitsize */
1216 FALSE, /* pc_relative */
1217 0, /* bitpos */
1218 complain_overflow_dont, /* complain_on_overflow */
1219 ppc64_elf_unhandled_reloc, /* special_function */
1220 "R_PPC64_PLTGOT16_LO_DS",/* name */
1221 FALSE, /* partial_inplace */
1222 0, /* src_mask */
1223 0xfffc, /* dst_mask */
1224 FALSE), /* pcrel_offset */
1225
1226 /* Marker reloc for TLS. */
1227 HOWTO (R_PPC64_TLS,
1228 0, /* rightshift */
1229 2, /* size (0 = byte, 1 = short, 2 = long) */
1230 32, /* bitsize */
1231 FALSE, /* pc_relative */
1232 0, /* bitpos */
1233 complain_overflow_dont, /* complain_on_overflow */
1234 bfd_elf_generic_reloc, /* special_function */
1235 "R_PPC64_TLS", /* name */
1236 FALSE, /* partial_inplace */
1237 0, /* src_mask */
1238 0, /* dst_mask */
1239 FALSE), /* pcrel_offset */
1240
1241 /* Computes the load module index of the load module that contains the
1242 definition of its TLS sym. */
1243 HOWTO (R_PPC64_DTPMOD64,
1244 0, /* rightshift */
1245 4, /* size (0 = byte, 1 = short, 2 = long) */
1246 64, /* bitsize */
1247 FALSE, /* pc_relative */
1248 0, /* bitpos */
1249 complain_overflow_dont, /* complain_on_overflow */
1250 ppc64_elf_unhandled_reloc, /* special_function */
1251 "R_PPC64_DTPMOD64", /* name */
1252 FALSE, /* partial_inplace */
1253 0, /* src_mask */
1254 ONES (64), /* dst_mask */
1255 FALSE), /* pcrel_offset */
1256
1257 /* Computes a dtv-relative displacement, the difference between the value
1258 of sym+add and the base address of the thread-local storage block that
1259 contains the definition of sym, minus 0x8000. */
1260 HOWTO (R_PPC64_DTPREL64,
1261 0, /* rightshift */
1262 4, /* size (0 = byte, 1 = short, 2 = long) */
1263 64, /* bitsize */
1264 FALSE, /* pc_relative */
1265 0, /* bitpos */
1266 complain_overflow_dont, /* complain_on_overflow */
1267 ppc64_elf_unhandled_reloc, /* special_function */
1268 "R_PPC64_DTPREL64", /* name */
1269 FALSE, /* partial_inplace */
1270 0, /* src_mask */
1271 ONES (64), /* dst_mask */
1272 FALSE), /* pcrel_offset */
1273
1274 /* A 16 bit dtprel reloc. */
1275 HOWTO (R_PPC64_DTPREL16,
1276 0, /* rightshift */
1277 1, /* size (0 = byte, 1 = short, 2 = long) */
1278 16, /* bitsize */
1279 FALSE, /* pc_relative */
1280 0, /* bitpos */
1281 complain_overflow_signed, /* complain_on_overflow */
1282 ppc64_elf_unhandled_reloc, /* special_function */
1283 "R_PPC64_DTPREL16", /* name */
1284 FALSE, /* partial_inplace */
1285 0, /* src_mask */
1286 0xffff, /* dst_mask */
1287 FALSE), /* pcrel_offset */
1288
1289 /* Like DTPREL16, but no overflow. */
1290 HOWTO (R_PPC64_DTPREL16_LO,
1291 0, /* rightshift */
1292 1, /* size (0 = byte, 1 = short, 2 = long) */
1293 16, /* bitsize */
1294 FALSE, /* pc_relative */
1295 0, /* bitpos */
1296 complain_overflow_dont, /* complain_on_overflow */
1297 ppc64_elf_unhandled_reloc, /* special_function */
1298 "R_PPC64_DTPREL16_LO", /* name */
1299 FALSE, /* partial_inplace */
1300 0, /* src_mask */
1301 0xffff, /* dst_mask */
1302 FALSE), /* pcrel_offset */
1303
1304 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1305 HOWTO (R_PPC64_DTPREL16_HI,
1306 16, /* rightshift */
1307 1, /* size (0 = byte, 1 = short, 2 = long) */
1308 16, /* bitsize */
1309 FALSE, /* pc_relative */
1310 0, /* bitpos */
1311 complain_overflow_dont, /* complain_on_overflow */
1312 ppc64_elf_unhandled_reloc, /* special_function */
1313 "R_PPC64_DTPREL16_HI", /* name */
1314 FALSE, /* partial_inplace */
1315 0, /* src_mask */
1316 0xffff, /* dst_mask */
1317 FALSE), /* pcrel_offset */
1318
1319 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1320 HOWTO (R_PPC64_DTPREL16_HA,
1321 16, /* rightshift */
1322 1, /* size (0 = byte, 1 = short, 2 = long) */
1323 16, /* bitsize */
1324 FALSE, /* pc_relative */
1325 0, /* bitpos */
1326 complain_overflow_dont, /* complain_on_overflow */
1327 ppc64_elf_unhandled_reloc, /* special_function */
1328 "R_PPC64_DTPREL16_HA", /* name */
1329 FALSE, /* partial_inplace */
1330 0, /* src_mask */
1331 0xffff, /* dst_mask */
1332 FALSE), /* pcrel_offset */
1333
1334 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1335 HOWTO (R_PPC64_DTPREL16_HIGHER,
1336 32, /* rightshift */
1337 1, /* size (0 = byte, 1 = short, 2 = long) */
1338 16, /* bitsize */
1339 FALSE, /* pc_relative */
1340 0, /* bitpos */
1341 complain_overflow_dont, /* complain_on_overflow */
1342 ppc64_elf_unhandled_reloc, /* special_function */
1343 "R_PPC64_DTPREL16_HIGHER", /* name */
1344 FALSE, /* partial_inplace */
1345 0, /* src_mask */
1346 0xffff, /* dst_mask */
1347 FALSE), /* pcrel_offset */
1348
1349 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1350 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1351 32, /* rightshift */
1352 1, /* size (0 = byte, 1 = short, 2 = long) */
1353 16, /* bitsize */
1354 FALSE, /* pc_relative */
1355 0, /* bitpos */
1356 complain_overflow_dont, /* complain_on_overflow */
1357 ppc64_elf_unhandled_reloc, /* special_function */
1358 "R_PPC64_DTPREL16_HIGHERA", /* name */
1359 FALSE, /* partial_inplace */
1360 0, /* src_mask */
1361 0xffff, /* dst_mask */
1362 FALSE), /* pcrel_offset */
1363
1364 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1365 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1366 48, /* rightshift */
1367 1, /* size (0 = byte, 1 = short, 2 = long) */
1368 16, /* bitsize */
1369 FALSE, /* pc_relative */
1370 0, /* bitpos */
1371 complain_overflow_dont, /* complain_on_overflow */
1372 ppc64_elf_unhandled_reloc, /* special_function */
1373 "R_PPC64_DTPREL16_HIGHEST", /* name */
1374 FALSE, /* partial_inplace */
1375 0, /* src_mask */
1376 0xffff, /* dst_mask */
1377 FALSE), /* pcrel_offset */
1378
1379 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1380 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1381 48, /* rightshift */
1382 1, /* size (0 = byte, 1 = short, 2 = long) */
1383 16, /* bitsize */
1384 FALSE, /* pc_relative */
1385 0, /* bitpos */
1386 complain_overflow_dont, /* complain_on_overflow */
1387 ppc64_elf_unhandled_reloc, /* special_function */
1388 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1389 FALSE, /* partial_inplace */
1390 0, /* src_mask */
1391 0xffff, /* dst_mask */
1392 FALSE), /* pcrel_offset */
1393
1394 /* Like DTPREL16, but for insns with a DS field. */
1395 HOWTO (R_PPC64_DTPREL16_DS,
1396 0, /* rightshift */
1397 1, /* size (0 = byte, 1 = short, 2 = long) */
1398 16, /* bitsize */
1399 FALSE, /* pc_relative */
1400 0, /* bitpos */
1401 complain_overflow_signed, /* complain_on_overflow */
1402 ppc64_elf_unhandled_reloc, /* special_function */
1403 "R_PPC64_DTPREL16_DS", /* name */
1404 FALSE, /* partial_inplace */
1405 0, /* src_mask */
1406 0xfffc, /* dst_mask */
1407 FALSE), /* pcrel_offset */
1408
1409 /* Like DTPREL16_DS, but no overflow. */
1410 HOWTO (R_PPC64_DTPREL16_LO_DS,
1411 0, /* rightshift */
1412 1, /* size (0 = byte, 1 = short, 2 = long) */
1413 16, /* bitsize */
1414 FALSE, /* pc_relative */
1415 0, /* bitpos */
1416 complain_overflow_dont, /* complain_on_overflow */
1417 ppc64_elf_unhandled_reloc, /* special_function */
1418 "R_PPC64_DTPREL16_LO_DS", /* name */
1419 FALSE, /* partial_inplace */
1420 0, /* src_mask */
1421 0xfffc, /* dst_mask */
1422 FALSE), /* pcrel_offset */
1423
1424 /* Computes a tp-relative displacement, the difference between the value of
1425 sym+add and the value of the thread pointer (r13). */
1426 HOWTO (R_PPC64_TPREL64,
1427 0, /* rightshift */
1428 4, /* size (0 = byte, 1 = short, 2 = long) */
1429 64, /* bitsize */
1430 FALSE, /* pc_relative */
1431 0, /* bitpos */
1432 complain_overflow_dont, /* complain_on_overflow */
1433 ppc64_elf_unhandled_reloc, /* special_function */
1434 "R_PPC64_TPREL64", /* name */
1435 FALSE, /* partial_inplace */
1436 0, /* src_mask */
1437 ONES (64), /* dst_mask */
1438 FALSE), /* pcrel_offset */
1439
1440 /* A 16 bit tprel reloc. */
1441 HOWTO (R_PPC64_TPREL16,
1442 0, /* rightshift */
1443 1, /* size (0 = byte, 1 = short, 2 = long) */
1444 16, /* bitsize */
1445 FALSE, /* pc_relative */
1446 0, /* bitpos */
1447 complain_overflow_signed, /* complain_on_overflow */
1448 ppc64_elf_unhandled_reloc, /* special_function */
1449 "R_PPC64_TPREL16", /* name */
1450 FALSE, /* partial_inplace */
1451 0, /* src_mask */
1452 0xffff, /* dst_mask */
1453 FALSE), /* pcrel_offset */
1454
1455 /* Like TPREL16, but no overflow. */
1456 HOWTO (R_PPC64_TPREL16_LO,
1457 0, /* rightshift */
1458 1, /* size (0 = byte, 1 = short, 2 = long) */
1459 16, /* bitsize */
1460 FALSE, /* pc_relative */
1461 0, /* bitpos */
1462 complain_overflow_dont, /* complain_on_overflow */
1463 ppc64_elf_unhandled_reloc, /* special_function */
1464 "R_PPC64_TPREL16_LO", /* name */
1465 FALSE, /* partial_inplace */
1466 0, /* src_mask */
1467 0xffff, /* dst_mask */
1468 FALSE), /* pcrel_offset */
1469
1470 /* Like TPREL16_LO, but next higher group of 16 bits. */
1471 HOWTO (R_PPC64_TPREL16_HI,
1472 16, /* rightshift */
1473 1, /* size (0 = byte, 1 = short, 2 = long) */
1474 16, /* bitsize */
1475 FALSE, /* pc_relative */
1476 0, /* bitpos */
1477 complain_overflow_dont, /* complain_on_overflow */
1478 ppc64_elf_unhandled_reloc, /* special_function */
1479 "R_PPC64_TPREL16_HI", /* name */
1480 FALSE, /* partial_inplace */
1481 0, /* src_mask */
1482 0xffff, /* dst_mask */
1483 FALSE), /* pcrel_offset */
1484
1485 /* Like TPREL16_HI, but adjust for low 16 bits. */
1486 HOWTO (R_PPC64_TPREL16_HA,
1487 16, /* rightshift */
1488 1, /* size (0 = byte, 1 = short, 2 = long) */
1489 16, /* bitsize */
1490 FALSE, /* pc_relative */
1491 0, /* bitpos */
1492 complain_overflow_dont, /* complain_on_overflow */
1493 ppc64_elf_unhandled_reloc, /* special_function */
1494 "R_PPC64_TPREL16_HA", /* name */
1495 FALSE, /* partial_inplace */
1496 0, /* src_mask */
1497 0xffff, /* dst_mask */
1498 FALSE), /* pcrel_offset */
1499
1500 /* Like TPREL16_HI, but next higher group of 16 bits. */
1501 HOWTO (R_PPC64_TPREL16_HIGHER,
1502 32, /* rightshift */
1503 1, /* size (0 = byte, 1 = short, 2 = long) */
1504 16, /* bitsize */
1505 FALSE, /* pc_relative */
1506 0, /* bitpos */
1507 complain_overflow_dont, /* complain_on_overflow */
1508 ppc64_elf_unhandled_reloc, /* special_function */
1509 "R_PPC64_TPREL16_HIGHER", /* name */
1510 FALSE, /* partial_inplace */
1511 0, /* src_mask */
1512 0xffff, /* dst_mask */
1513 FALSE), /* pcrel_offset */
1514
1515 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1516 HOWTO (R_PPC64_TPREL16_HIGHERA,
1517 32, /* rightshift */
1518 1, /* size (0 = byte, 1 = short, 2 = long) */
1519 16, /* bitsize */
1520 FALSE, /* pc_relative */
1521 0, /* bitpos */
1522 complain_overflow_dont, /* complain_on_overflow */
1523 ppc64_elf_unhandled_reloc, /* special_function */
1524 "R_PPC64_TPREL16_HIGHERA", /* name */
1525 FALSE, /* partial_inplace */
1526 0, /* src_mask */
1527 0xffff, /* dst_mask */
1528 FALSE), /* pcrel_offset */
1529
1530 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1531 HOWTO (R_PPC64_TPREL16_HIGHEST,
1532 48, /* rightshift */
1533 1, /* size (0 = byte, 1 = short, 2 = long) */
1534 16, /* bitsize */
1535 FALSE, /* pc_relative */
1536 0, /* bitpos */
1537 complain_overflow_dont, /* complain_on_overflow */
1538 ppc64_elf_unhandled_reloc, /* special_function */
1539 "R_PPC64_TPREL16_HIGHEST", /* name */
1540 FALSE, /* partial_inplace */
1541 0, /* src_mask */
1542 0xffff, /* dst_mask */
1543 FALSE), /* pcrel_offset */
1544
1545 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1546 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1547 48, /* rightshift */
1548 1, /* size (0 = byte, 1 = short, 2 = long) */
1549 16, /* bitsize */
1550 FALSE, /* pc_relative */
1551 0, /* bitpos */
1552 complain_overflow_dont, /* complain_on_overflow */
1553 ppc64_elf_unhandled_reloc, /* special_function */
1554 "R_PPC64_TPREL16_HIGHESTA", /* name */
1555 FALSE, /* partial_inplace */
1556 0, /* src_mask */
1557 0xffff, /* dst_mask */
1558 FALSE), /* pcrel_offset */
1559
1560 /* Like TPREL16, but for insns with a DS field. */
1561 HOWTO (R_PPC64_TPREL16_DS,
1562 0, /* rightshift */
1563 1, /* size (0 = byte, 1 = short, 2 = long) */
1564 16, /* bitsize */
1565 FALSE, /* pc_relative */
1566 0, /* bitpos */
1567 complain_overflow_signed, /* complain_on_overflow */
1568 ppc64_elf_unhandled_reloc, /* special_function */
1569 "R_PPC64_TPREL16_DS", /* name */
1570 FALSE, /* partial_inplace */
1571 0, /* src_mask */
1572 0xfffc, /* dst_mask */
1573 FALSE), /* pcrel_offset */
1574
1575 /* Like TPREL16_DS, but no overflow. */
1576 HOWTO (R_PPC64_TPREL16_LO_DS,
1577 0, /* rightshift */
1578 1, /* size (0 = byte, 1 = short, 2 = long) */
1579 16, /* bitsize */
1580 FALSE, /* pc_relative */
1581 0, /* bitpos */
1582 complain_overflow_dont, /* complain_on_overflow */
1583 ppc64_elf_unhandled_reloc, /* special_function */
1584 "R_PPC64_TPREL16_LO_DS", /* name */
1585 FALSE, /* partial_inplace */
1586 0, /* src_mask */
1587 0xfffc, /* dst_mask */
1588 FALSE), /* pcrel_offset */
1589
1590 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1591 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1592 to the first entry relative to the TOC base (r2). */
1593 HOWTO (R_PPC64_GOT_TLSGD16,
1594 0, /* rightshift */
1595 1, /* size (0 = byte, 1 = short, 2 = long) */
1596 16, /* bitsize */
1597 FALSE, /* pc_relative */
1598 0, /* bitpos */
1599 complain_overflow_signed, /* complain_on_overflow */
1600 ppc64_elf_unhandled_reloc, /* special_function */
1601 "R_PPC64_GOT_TLSGD16", /* name */
b34976b6 1602 FALSE, /* partial_inplace */
5bd4f169
AM		 1603 0, /* src_mask */
1604 0xffff, /* dst_mask */
b34976b6 1605 FALSE), /* pcrel_offset */
5bd4f169 1606
411e1bfb
AM		 1607 /* Like GOT_TLSGD16, but no overflow. */
1608 HOWTO (R_PPC64_GOT_TLSGD16_LO,
5bd4f169
AM		 1609 0, /* rightshift */
1610 1, /* size (0 = byte, 1 = short, 2 = long) */
1611 16, /* bitsize */
b34976b6 1612 FALSE, /* pc_relative */
5bd4f169
AM		 1613 0, /* bitpos */
1614 complain_overflow_dont, /* complain_on_overflow */
805fc799 1615 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1616 "R_PPC64_GOT_TLSGD16_LO", /* name */
b34976b6 1617 FALSE, /* partial_inplace */
5bd4f169
AM		 1618 0, /* src_mask */
1619 0xffff, /* dst_mask */
b34976b6 1620 FALSE), /* pcrel_offset */
5bd4f169 1621
411e1bfb
AM		 1622 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1623 HOWTO (R_PPC64_GOT_TLSGD16_HI,
5bd4f169
AM		 1624 16, /* rightshift */
1625 1, /* size (0 = byte, 1 = short, 2 = long) */
1626 16, /* bitsize */
b34976b6 1627 FALSE, /* pc_relative */
5bd4f169
AM		 1628 0, /* bitpos */
1629 complain_overflow_dont, /* complain_on_overflow */
805fc799 1630 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1631 "R_PPC64_GOT_TLSGD16_HI", /* name */
b34976b6 1632 FALSE, /* partial_inplace */
5bd4f169
AM		 1633 0, /* src_mask */
1634 0xffff, /* dst_mask */
b34976b6 1635 FALSE), /* pcrel_offset */
5bd4f169 1636
411e1bfb
AM		 1637 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1638 HOWTO (R_PPC64_GOT_TLSGD16_HA,
5bd4f169
AM		 1639 16, /* rightshift */
1640 1, /* size (0 = byte, 1 = short, 2 = long) */
1641 16, /* bitsize */
b34976b6 1642 FALSE, /* pc_relative */
5bd4f169 1643 0, /* bitpos */
411e1bfb 1644 complain_overflow_dont, /* complain_on_overflow */
805fc799 1645 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1646 "R_PPC64_GOT_TLSGD16_HA", /* name */
b34976b6 1647 FALSE, /* partial_inplace */
5bd4f169
AM		 1648 0, /* src_mask */
1649 0xffff, /* dst_mask */
b34976b6 1650 FALSE), /* pcrel_offset */
5bd4f169 1651
411e1bfb
AM		 1652 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1653 with values (sym+add)@dtpmod and zero, and computes the offset to the
1654 first entry relative to the TOC base (r2). */
1655 HOWTO (R_PPC64_GOT_TLSLD16,
5bd4f169
AM		 1656 0, /* rightshift */
1657 1, /* size (0 = byte, 1 = short, 2 = long) */
1658 16, /* bitsize */
b34976b6 1659 FALSE, /* pc_relative */
5bd4f169 1660 0, /* bitpos */
411e1bfb
AM		 1661 complain_overflow_signed, /* complain_on_overflow */
1662 ppc64_elf_unhandled_reloc, /* special_function */
1663 "R_PPC64_GOT_TLSLD16", /* name */
b34976b6 1664 FALSE, /* partial_inplace */
d006db6c 1665 0, /* src_mask */
411e1bfb 1666 0xffff, /* dst_mask */
b34976b6 1667 FALSE), /* pcrel_offset */
5bd4f169 1668
411e1bfb
AM		 1669 /* Like GOT_TLSLD16, but no overflow. */
1670 HOWTO (R_PPC64_GOT_TLSLD16_LO,
5bd4f169
AM		 1671 0, /* rightshift */
1672 1, /* size (0 = byte, 1 = short, 2 = long) */
1673 16, /* bitsize */
b34976b6 1674 FALSE, /* pc_relative */
5bd4f169 1675 0, /* bitpos */
411e1bfb
AM		 1676 complain_overflow_dont, /* complain_on_overflow */
1677 ppc64_elf_unhandled_reloc, /* special_function */
1678 "R_PPC64_GOT_TLSLD16_LO", /* name */
b34976b6 1679 FALSE, /* partial_inplace */
d006db6c 1680 0, /* src_mask */
411e1bfb 1681 0xffff, /* dst_mask */
b34976b6 1682 FALSE), /* pcrel_offset */
5bd4f169 1683
411e1bfb
AM		 1684 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1685 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1686 16, /* rightshift */
5bd4f169
AM		 1687 1, /* size (0 = byte, 1 = short, 2 = long) */
1688 16, /* bitsize */
b34976b6 1689 FALSE, /* pc_relative */
5bd4f169 1690 0, /* bitpos */
411e1bfb 1691 complain_overflow_dont, /* complain_on_overflow */
805fc799 1692 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1693 "R_PPC64_GOT_TLSLD16_HI", /* name */
b34976b6 1694 FALSE, /* partial_inplace */
d006db6c 1695 0, /* src_mask */
411e1bfb 1696 0xffff, /* dst_mask */
b34976b6 1697 FALSE), /* pcrel_offset */
5bd4f169 1698
411e1bfb
AM		 1699 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1700 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1701 16, /* rightshift */
5bd4f169
AM		 1702 1, /* size (0 = byte, 1 = short, 2 = long) */
1703 16, /* bitsize */
b34976b6 1704 FALSE, /* pc_relative */
5bd4f169
AM		 1705 0, /* bitpos */
1706 complain_overflow_dont, /* complain_on_overflow */
805fc799 1707 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1708 "R_PPC64_GOT_TLSLD16_HA", /* name */
b34976b6 1709 FALSE, /* partial_inplace */
d006db6c 1710 0, /* src_mask */
411e1bfb 1711 0xffff, /* dst_mask */
b34976b6 1712 FALSE), /* pcrel_offset */
5bd4f169 1713
411e1bfb
AM		 1714 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1715 the offset to the entry relative to the TOC base (r2). */
1716 HOWTO (R_PPC64_GOT_DTPREL16_DS,
5bd4f169
AM		 1717 0, /* rightshift */
1718 1, /* size (0 = byte, 1 = short, 2 = long) */
1719 16, /* bitsize */
b34976b6 1720 FALSE, /* pc_relative */
5bd4f169 1721 0, /* bitpos */
411e1bfb 1722 complain_overflow_signed, /* complain_on_overflow */
805fc799 1723 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1724 "R_PPC64_GOT_DTPREL16_DS", /* name */
b34976b6 1725 FALSE, /* partial_inplace */
d006db6c 1726 0, /* src_mask */
5bd4f169 1727 0xfffc, /* dst_mask */
b34976b6 1728 FALSE), /* pcrel_offset */
5bd4f169 1729
411e1bfb
AM		 1730 /* Like GOT_DTPREL16_DS, but no overflow. */
1731 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
5bd4f169 1732 0, /* rightshift */
c061c2d8
AM		 1733 1, /* size (0 = byte, 1 = short, 2 = long) */
1734 16, /* bitsize */
b34976b6 1735 FALSE, /* pc_relative */
5bd4f169 1736 0, /* bitpos */
411e1bfb
AM		 1737 complain_overflow_dont, /* complain_on_overflow */
1738 ppc64_elf_unhandled_reloc, /* special_function */
1739 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
b34976b6 1740 FALSE, /* partial_inplace */
d006db6c 1741 0, /* src_mask */
c061c2d8 1742 0xfffc, /* dst_mask */
b34976b6 1743 FALSE), /* pcrel_offset */
5bd4f169 1744
411e1bfb
AM		 1745 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1746 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1747 16, /* rightshift */
5bd4f169
AM		 1748 1, /* size (0 = byte, 1 = short, 2 = long) */
1749 16, /* bitsize */
b34976b6 1750 FALSE, /* pc_relative */
5bd4f169
AM		 1751 0, /* bitpos */
1752 complain_overflow_dont, /* complain_on_overflow */
411e1bfb
AM		 1753 ppc64_elf_unhandled_reloc, /* special_function */
1754 "R_PPC64_GOT_DTPREL16_HI", /* name */
b34976b6 1755 FALSE, /* partial_inplace */
d006db6c 1756 0, /* src_mask */
411e1bfb 1757 0xffff, /* dst_mask */
b34976b6 1758 FALSE), /* pcrel_offset */
5bd4f169 1759
411e1bfb
AM		 1760 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1761 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1762 16, /* rightshift */
1763 1, /* size (0 = byte, 1 = short, 2 = long) */
1764 16, /* bitsize */
1765 FALSE, /* pc_relative */
1766 0, /* bitpos */
1767 complain_overflow_dont, /* complain_on_overflow */
1768 ppc64_elf_unhandled_reloc, /* special_function */
1769 "R_PPC64_GOT_DTPREL16_HA", /* name */
1770 FALSE, /* partial_inplace */
1771 0, /* src_mask */
1772 0xffff, /* dst_mask */
1773 FALSE), /* pcrel_offset */
1774
1775 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1776 offset to the entry relative to the TOC base (r2). */
1777 HOWTO (R_PPC64_GOT_TPREL16_DS,
5bd4f169
AM		 1778 0, /* rightshift */
1779 1, /* size (0 = byte, 1 = short, 2 = long) */
1780 16, /* bitsize */
b34976b6 1781 FALSE, /* pc_relative */
5bd4f169
AM		 1782 0, /* bitpos */
1783 complain_overflow_signed, /* complain_on_overflow */
411e1bfb
AM		 1784 ppc64_elf_unhandled_reloc, /* special_function */
1785 "R_PPC64_GOT_TPREL16_DS", /* name */
b34976b6 1786 FALSE, /* partial_inplace */
d006db6c 1787 0, /* src_mask */
ad8e1ba5 1788 0xfffc, /* dst_mask */
b34976b6 1789 FALSE), /* pcrel_offset */
5bd4f169 1790
411e1bfb
AM		 1791 /* Like GOT_TPREL16_DS, but no overflow. */
1792 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
5bd4f169
AM		 1793 0, /* rightshift */
1794 1, /* size (0 = byte, 1 = short, 2 = long) */
1795 16, /* bitsize */
b34976b6 1796 FALSE, /* pc_relative */
5bd4f169
AM		 1797 0, /* bitpos */
1798 complain_overflow_dont, /* complain_on_overflow */
411e1bfb
AM		 1799 ppc64_elf_unhandled_reloc, /* special_function */
1800 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
b34976b6 1801 FALSE, /* partial_inplace */
d006db6c 1802 0, /* src_mask */
ad8e1ba5 1803 0xfffc, /* dst_mask */
b34976b6 1804 FALSE), /* pcrel_offset */
5bd4f169 1805
411e1bfb
AM		 1806 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1807 HOWTO (R_PPC64_GOT_TPREL16_HI,
1808 16, /* rightshift */
5bd4f169
AM		 1809 1, /* size (0 = byte, 1 = short, 2 = long) */
1810 16, /* bitsize */
b34976b6 1811 FALSE, /* pc_relative */
5bd4f169 1812 0, /* bitpos */
411e1bfb 1813 complain_overflow_dont, /* complain_on_overflow */
805fc799 1814 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1815 "R_PPC64_GOT_TPREL16_HI", /* name */
b34976b6 1816 FALSE, /* partial_inplace */
d006db6c 1817 0, /* src_mask */
411e1bfb 1818 0xffff, /* dst_mask */
b34976b6 1819 FALSE), /* pcrel_offset */
5bd4f169 1820
411e1bfb
AM		 1821 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1822 HOWTO (R_PPC64_GOT_TPREL16_HA,
1823 16, /* rightshift */
5bd4f169
AM		 1824 1, /* size (0 = byte, 1 = short, 2 = long) */
1825 16, /* bitsize */
b34976b6 1826 FALSE, /* pc_relative */
5bd4f169
AM		 1827 0, /* bitpos */
1828 complain_overflow_dont, /* complain_on_overflow */
805fc799 1829 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1830 "R_PPC64_GOT_TPREL16_HA", /* name */
b34976b6 1831 FALSE, /* partial_inplace */
d006db6c 1832 0, /* src_mask */
411e1bfb 1833 0xffff, /* dst_mask */
b34976b6 1834 FALSE), /* pcrel_offset */
5bd4f169
AM		 1835
1836 /* GNU extension to record C++ vtable hierarchy. */
1837 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
1838 0, /* rightshift */
1839 0, /* size (0 = byte, 1 = short, 2 = long) */
1840 0, /* bitsize */
b34976b6 1841 FALSE, /* pc_relative */
5bd4f169
AM		 1842 0, /* bitpos */
1843 complain_overflow_dont, /* complain_on_overflow */
1844 NULL, /* special_function */
1845 "R_PPC64_GNU_VTINHERIT", /* name */
b34976b6 1846 FALSE, /* partial_inplace */
5bd4f169
AM		 1847 0, /* src_mask */
1848 0, /* dst_mask */
b34976b6 1849 FALSE), /* pcrel_offset */
5bd4f169
AM		 1850
1851 /* GNU extension to record C++ vtable member usage. */
1852 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
1853 0, /* rightshift */
1854 0, /* size (0 = byte, 1 = short, 2 = long) */
1855 0, /* bitsize */
b34976b6 1856 FALSE, /* pc_relative */
5bd4f169
AM		 1857 0, /* bitpos */
1858 complain_overflow_dont, /* complain_on_overflow */
1859 NULL, /* special_function */
1860 "R_PPC64_GNU_VTENTRY", /* name */
b34976b6 1861 FALSE, /* partial_inplace */
5bd4f169
AM		 1862 0, /* src_mask */
1863 0, /* dst_mask */
b34976b6 1864 FALSE), /* pcrel_offset */
5bd4f169
AM		 1865};
1866
1867\f
1868/* Initialize the ppc64_elf_howto_table, so that linear accesses can
1869 be done. */
1870
1871static void
4ce794b7 1872ppc_howto_init (void)
5bd4f169
AM		 1873{
1874 unsigned int i, type;
1875
1876 for (i = 0;
1877 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
1878 i++)
1879 {
1880 type = ppc64_elf_howto_raw[i].type;
1881 BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
1882 / sizeof (ppc64_elf_howto_table[0])));
1883 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
1884 }
1885}
1886
1887static reloc_howto_type *
4ce794b7
AM		 1888ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1889 bfd_reloc_code_real_type code)
5bd4f169 1890{
411e1bfb 1891 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
5bd4f169
AM		 1892
1893 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
1894 /* Initialize howto table if needed. */
1895 ppc_howto_init ();
1896
4ce794b7 1897 switch (code)
5bd4f169
AM		 1898 {
1899 default:
4ce794b7 1900 return NULL;
5bd4f169 1901
411e1bfb
AM		 1902 case BFD_RELOC_NONE: r = R_PPC64_NONE;
1903 break;
1904 case BFD_RELOC_32: r = R_PPC64_ADDR32;
1905 break;
1906 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
1907 break;
1908 case BFD_RELOC_16: r = R_PPC64_ADDR16;
1909 break;
1910 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
1911 break;
1912 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
1913 break;
1914 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
5bd4f169 1915 break;
411e1bfb 1916 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
5bd4f169 1917 break;
411e1bfb 1918 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
5bd4f169 1919 break;
411e1bfb 1920 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
5bd4f169 1921 break;
411e1bfb 1922 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
5bd4f169 1923 break;
411e1bfb 1924 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
5bd4f169 1925 break;
411e1bfb 1926 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
5bd4f169 1927 break;
411e1bfb 1928 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
5bd4f169 1929 break;
411e1bfb 1930 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
5bd4f169 1931 break;
411e1bfb 1932 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
5bd4f169 1933 break;
411e1bfb 1934 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
5bd4f169 1935 break;
411e1bfb 1936 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
5bd4f169 1937 break;
411e1bfb 1938 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
5bd4f169 1939 break;
411e1bfb 1940 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
5bd4f169 1941 break;
411e1bfb 1942 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
5bd4f169 1943 break;
411e1bfb 1944 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
5bd4f169 1945 break;
411e1bfb 1946 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
5bd4f169 1947 break;
411e1bfb 1948 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
5bd4f169 1949 break;
411e1bfb 1950 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
5bd4f169 1951 break;
411e1bfb 1952 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
5bd4f169 1953 break;
411e1bfb 1954 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
5bd4f169 1955 break;
411e1bfb 1956 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
5bd4f169 1957 break;
411e1bfb 1958 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
5bd4f169 1959 break;
411e1bfb 1960 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
5bd4f169 1961 break;
411e1bfb 1962 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
5bd4f169 1963 break;
411e1bfb 1964 case BFD_RELOC_64: r = R_PPC64_ADDR64;
5bd4f169 1965 break;
411e1bfb 1966 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
5bd4f169 1967 break;
411e1bfb 1968 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
5bd4f169 1969 break;
411e1bfb 1970 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
5bd4f169 1971 break;
411e1bfb 1972 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
5bd4f169 1973 break;
411e1bfb 1974 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
5bd4f169 1975 break;
411e1bfb 1976 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
5bd4f169 1977 break;
411e1bfb 1978 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
5bd4f169 1979 break;
411e1bfb 1980 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
5bd4f169 1981 break;
411e1bfb 1982 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
5bd4f169 1983 break;
411e1bfb 1984 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
5bd4f169 1985 break;
411e1bfb 1986 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
5bd4f169 1987 break;
411e1bfb 1988 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
5bd4f169 1989 break;
411e1bfb 1990 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
5bd4f169 1991 break;
411e1bfb 1992 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
5bd4f169 1993 break;
411e1bfb 1994 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
5bd4f169 1995 break;
411e1bfb 1996 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
5bd4f169 1997 break;
411e1bfb 1998 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
5bd4f169 1999 break;
411e1bfb 2000 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
5bd4f169 2001 break;
411e1bfb 2002 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
5bd4f169 2003 break;
411e1bfb 2004 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
5bd4f169 2005 break;
411e1bfb 2006 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
5bd4f169 2007 break;
411e1bfb 2008 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
5bd4f169 2009 break;
411e1bfb 2010 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
5bd4f169 2011 break;
411e1bfb 2012 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
5bd4f169 2013 break;
411e1bfb 2014 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
5bd4f169 2015 break;
411e1bfb 2016 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
5bd4f169 2017 break;
411e1bfb 2018 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
5bd4f169 2019 break;
411e1bfb 2020 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
5bd4f169 2021 break;
411e1bfb 2022 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
5bd4f169 2023 break;
411e1bfb 2024 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
5bd4f169 2025 break;
411e1bfb 2026 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
5bd4f169 2027 break;
411e1bfb 2028 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
5bd4f169 2029 break;
411e1bfb 2030 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
5bd4f169 2031 break;
411e1bfb 2032 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
5bd4f169 2033 break;
411e1bfb
AM		 2034 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2035 break;
2036 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2037 break;
2038 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2039 break;
2040 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2041 break;
2042 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2043 break;
2044 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2045 break;
2046 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2047 break;
2048 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2049 break;
2050 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2051 break;
2052 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2053 break;
2054 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2055 break;
2056 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2057 break;
2058 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2059 break;
2060 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2061 break;
2062 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2063 break;
2064 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2065 break;
2066 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2067 break;
2068 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2069 break;
2070 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2071 break;
2072 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2073 break;
2074 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2075 break;
2076 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2077 break;
2078 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2079 break;
2080 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2081 break;
2082 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2083 break;
2084 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2085 break;
2086 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2087 break;
2088 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2089 break;
2090 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2091 break;
2092 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2093 break;
2094 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2095 break;
2096 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2097 break;
2098 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2099 break;
2100 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2101 break;
2102 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
5bd4f169
AM		 2103 break;
2104 }
2105
4ce794b7 2106 return ppc64_elf_howto_table[r];
5bd4f169
AM		 2107};
2108
2109/* Set the howto pointer for a PowerPC ELF reloc. */
2110
2111static void
4ce794b7
AM		 2112ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2113 Elf_Internal_Rela *dst)
5bd4f169 2114{
65f38f15
AM		 2115 unsigned int type;
2116
ef60b7ff 2117 /* Initialize howto table if needed. */
5bd4f169 2118 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5bd4f169
AM		 2119 ppc_howto_init ();
2120
65f38f15 2121 type = ELF64_R_TYPE (dst->r_info);
d0fb9a8d
JJ		 2122 if (type >= (sizeof (ppc64_elf_howto_table)
2123 / sizeof (ppc64_elf_howto_table[0])))
2124 {
2125 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
3ec2b351
NC		 2126 abfd, (int) type);
2127 type = R_PPC64_NONE;
d0fb9a8d 2128 }
65f38f15 2129 cache_ptr->howto = ppc64_elf_howto_table[type];
5bd4f169
AM		 2130}
2131
04c9666a 2132/* Handle the R_PPC64_ADDR16_HA and similar relocs. */
5bd4f169
AM		 2133
2134static bfd_reloc_status_type
4ce794b7
AM		 2135ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2136 void *data, asection *input_section,
2137 bfd *output_bfd, char **error_message)
5bd4f169 2138{
805fc799
AM		 2139 /* If this is a relocatable link (output_bfd test tells us), just
2140 call the generic function. Any adjustment will be done at final
2141 link time. */
2142 if (output_bfd != NULL)
cedb70c5 2143 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2144 input_section, output_bfd, error_message);
2145
2146 /* Adjust the addend for sign extension of the low 16 bits.
2147 We won't actually be using the low 16 bits, so trashing them
2148 doesn't matter. */
2149 reloc_entry->addend += 0x8000;
2150 return bfd_reloc_continue;
2151}
5bd4f169 2152
2441e016
AM		 2153static bfd_reloc_status_type
2154ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2155 void *data, asection *input_section,
2156 bfd *output_bfd, char **error_message)
2157{
2158 if (output_bfd != NULL)
2159 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2160 input_section, output_bfd, error_message);
2161
699733f6
AM		 2162 if (strcmp (symbol->section->name, ".opd") == 0
2163 && (symbol->section->owner->flags & DYNAMIC) == 0)
2441e016
AM		 2164 {
2165 bfd_vma dest = opd_entry_value (symbol->section,
2166 symbol->value + reloc_entry->addend,
2167 NULL, NULL);
2168 if (dest != (bfd_vma) -1)
2169 reloc_entry->addend = dest - (symbol->value
2170 + symbol->section->output_section->vma
2171 + symbol->section->output_offset);
2172 }
2173 return bfd_reloc_continue;
2174}
2175
805fc799 2176static bfd_reloc_status_type
4ce794b7
AM		 2177ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2178 void *data, asection *input_section,
2179 bfd *output_bfd, char **error_message)
805fc799
AM		 2180{
2181 long insn;
04c9666a 2182 enum elf_ppc64_reloc_type r_type;
805fc799
AM		 2183 bfd_size_type octets;
2184 /* Disabled until we sort out how ld should choose 'y' vs 'at'. */
b34976b6 2185 bfd_boolean is_power4 = FALSE;
805fc799
AM		 2186
2187 /* If this is a relocatable link (output_bfd test tells us), just
2188 call the generic function. Any adjustment will be done at final
2189 link time. */
5bd4f169 2190 if (output_bfd != NULL)
cedb70c5 2191 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2192 input_section, output_bfd, error_message);
2193
2194 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2195 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2196 insn &= ~(0x01 << 21);
4ce794b7 2197 r_type = reloc_entry->howto->type;
805fc799
AM		 2198 if (r_type == R_PPC64_ADDR14_BRTAKEN
2199 || r_type == R_PPC64_REL14_BRTAKEN)
cedb70c5 2200 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
805fc799
AM		 2201
2202 if (is_power4)
5bd4f169 2203 {
805fc799
AM		 2204 /* Set 'a' bit. This is 0b00010 in BO field for branch
2205 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2206 for branch on CTR insns (BO == 1a00t or 1a01t). */
2207 if ((insn & (0x14 << 21)) == (0x04 << 21))
2208 insn |= 0x02 << 21;
2209 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2210 insn |= 0x08 << 21;
2211 else
2441e016 2212 goto out;
5bd4f169 2213 }
805fc799
AM		 2214 else
2215 {
2216 bfd_vma target = 0;
2217 bfd_vma from;
5bd4f169 2218
805fc799
AM		 2219 if (!bfd_is_com_section (symbol->section))
2220 target = symbol->value;
2221 target += symbol->section->output_section->vma;
2222 target += symbol->section->output_offset;
2223 target += reloc_entry->addend;
5bd4f169 2224
805fc799
AM		 2225 from = (reloc_entry->address
2226 + input_section->output_offset
2227 + input_section->output_section->vma);
5bd4f169 2228
805fc799
AM		 2229 /* Invert 'y' bit if not the default. */
2230 if ((bfd_signed_vma) (target - from) < 0)
2231 insn ^= 0x01 << 21;
2232 }
4ce794b7 2233 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2441e016
AM		 2234 out:
2235 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2236 input_section, output_bfd, error_message);
805fc799 2237}
5bd4f169 2238
805fc799 2239static bfd_reloc_status_type
4ce794b7
AM		 2240ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2241 void *data, asection *input_section,
2242 bfd *output_bfd, char **error_message)
805fc799
AM		 2243{
2244 /* If this is a relocatable link (output_bfd test tells us), just
2245 call the generic function. Any adjustment will be done at final
2246 link time. */
2247 if (output_bfd != NULL)
cedb70c5 2248 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799 2249 input_section, output_bfd, error_message);
5bd4f169 2250
805fc799
AM		 2251 /* Subtract the symbol section base address. */
2252 reloc_entry->addend -= symbol->section->output_section->vma;
5bd4f169
AM		 2253 return bfd_reloc_continue;
2254}
2255
805fc799 2256static bfd_reloc_status_type
4ce794b7
AM		 2257ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2258 void *data, asection *input_section,
2259 bfd *output_bfd, char **error_message)
805fc799
AM		 2260{
2261 /* If this is a relocatable link (output_bfd test tells us), just
2262 call the generic function. Any adjustment will be done at final
2263 link time. */
2264 if (output_bfd != NULL)
cedb70c5 2265 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2266 input_section, output_bfd, error_message);
2267
2268 /* Subtract the symbol section base address. */
2269 reloc_entry->addend -= symbol->section->output_section->vma;
2270
2271 /* Adjust the addend for sign extension of the low 16 bits. */
2272 reloc_entry->addend += 0x8000;
2273 return bfd_reloc_continue;
2274}
2275
2276static bfd_reloc_status_type
4ce794b7
AM		 2277ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2278 void *data, asection *input_section,
2279 bfd *output_bfd, char **error_message)
805fc799
AM		 2280{
2281 bfd_vma TOCstart;
2282
2283 /* If this is a relocatable link (output_bfd test tells us), just
2284 call the generic function. Any adjustment will be done at final
2285 link time. */
2286 if (output_bfd != NULL)
cedb70c5 2287 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2288 input_section, output_bfd, error_message);
2289
2290 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2291 if (TOCstart == 0)
2292 TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2293
2294 /* Subtract the TOC base address. */
2295 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2296 return bfd_reloc_continue;
2297}
2298
2299static bfd_reloc_status_type
4ce794b7
AM		 2300ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2301 void *data, asection *input_section,
2302 bfd *output_bfd, char **error_message)
805fc799
AM		 2303{
2304 bfd_vma TOCstart;
2305
2306 /* If this is a relocatable link (output_bfd test tells us), just
2307 call the generic function. Any adjustment will be done at final
2308 link time. */
2309 if (output_bfd != NULL)
cedb70c5 2310 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2311 input_section, output_bfd, error_message);
2312
2313 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2314 if (TOCstart == 0)
2315 TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2316
2317 /* Subtract the TOC base address. */
2318 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2319
2320 /* Adjust the addend for sign extension of the low 16 bits. */
2321 reloc_entry->addend += 0x8000;
2322 return bfd_reloc_continue;
2323}
2324
2325static bfd_reloc_status_type
4ce794b7
AM		 2326ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2327 void *data, asection *input_section,
2328 bfd *output_bfd, char **error_message)
805fc799
AM		 2329{
2330 bfd_vma TOCstart;
2331 bfd_size_type octets;
2332
2333 /* If this is a relocatable link (output_bfd test tells us), just
2334 call the generic function. Any adjustment will be done at final
2335 link time. */
2336 if (output_bfd != NULL)
cedb70c5 2337 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2338 input_section, output_bfd, error_message);
2339
2340 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2341 if (TOCstart == 0)
2342 TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2343
2344 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2345 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2346 return bfd_reloc_ok;
2347}
2348
2349static bfd_reloc_status_type
4ce794b7
AM		 2350ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2351 void *data, asection *input_section,
2352 bfd *output_bfd, char **error_message)
805fc799
AM		 2353{
2354 /* If this is a relocatable link (output_bfd test tells us), just
2355 call the generic function. Any adjustment will be done at final
2356 link time. */
2357 if (output_bfd != NULL)
cedb70c5 2358 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2359 input_section, output_bfd, error_message);
2360
2361 if (error_message != NULL)
2362 {
2363 static char buf[60];
2364 sprintf (buf, "generic linker can't handle %s",
2365 reloc_entry->howto->name);
2366 *error_message = buf;
2367 }
2368 return bfd_reloc_dangerous;
2369}
2370
e717da7e
AM		 2371struct ppc64_elf_obj_tdata
2372{
2373 struct elf_obj_tdata elf;
2374
2375 /* Shortcuts to dynamic linker sections. */
2376 asection *got;
2377 asection *relgot;
2378
433817dd
AM		 2379 union {
2380 /* Used during garbage collection. We attach global symbols defined
2381 on removed .opd entries to this section so that the sym is removed. */
2382 asection *deleted_section;
2383
2384 /* Used when adding symbols. */
2385 bfd_boolean has_dotsym;
2386 } u;
81688140 2387
e717da7e
AM		 2388 /* TLS local dynamic got entry handling. Suppose for multiple GOT
2389 sections means we potentially need one of these for each input bfd. */
2390 union {
2391 bfd_signed_vma refcount;
2392 bfd_vma offset;
2393 } tlsld_got;
8860955f
AM		 2394
2395 /* A copy of relocs before they are modified for --emit-relocs. */
2396 Elf_Internal_Rela *opd_relocs;
e717da7e
AM		 2397};
2398
2399#define ppc64_elf_tdata(bfd) \
2400 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2401
2402#define ppc64_tlsld_got(bfd) \
2403 (&ppc64_elf_tdata (bfd)->tlsld_got)
2404
2405/* Override the generic function because we store some extras. */
2406
2407static bfd_boolean
2408ppc64_elf_mkobject (bfd *abfd)
2409{
e717da7e 2410 if (abfd->tdata.any == NULL)
62d7a5f6
AM		 2411 {
2412 bfd_size_type amt = sizeof (struct ppc64_elf_obj_tdata);
2413 abfd->tdata.any = bfd_zalloc (abfd, amt);
2414 if (abfd->tdata.any == NULL)
2415 return FALSE;
2416 }
2417 return bfd_elf_mkobject (abfd);
e717da7e
AM		 2418}
2419
ee75fd95
AM		 2420/* Return 1 if target is one of ours. */
2421
7b53ace3 2422static bfd_boolean
ee75fd95 2423is_ppc64_elf_target (const struct bfd_target *targ)
7b53ace3
AM		 2424{
2425 extern const bfd_target bfd_elf64_powerpc_vec;
2426 extern const bfd_target bfd_elf64_powerpcle_vec;
2427
2428 return targ == &bfd_elf64_powerpc_vec || targ == &bfd_elf64_powerpcle_vec;
2429}
2430
feee612b
AM		 2431/* Fix bad default arch selected for a 64 bit input bfd when the
2432 default is 32 bit. */
2433
b34976b6 2434static bfd_boolean
4ce794b7 2435ppc64_elf_object_p (bfd *abfd)
feee612b
AM		 2436{
2437 if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2438 {
2439 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2440
2441 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2442 {
2443 /* Relies on arch after 32 bit default being 64 bit default. */
2444 abfd->arch_info = abfd->arch_info->next;
2445 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2446 }
2447 }
b34976b6 2448 return TRUE;
feee612b
AM		 2449}
2450
d37c89e5
AM		 2451/* Support for core dump NOTE sections. */
2452
2453static bfd_boolean
2454ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2455{
eea6121a 2456 size_t offset, size;
d37c89e5
AM		 2457
2458 if (note->descsz != 504)
2459 return FALSE;
2460
2461 /* pr_cursig */
2462 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
2463
2464 /* pr_pid */
2465 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 32);
2466
2467 /* pr_reg */
2468 offset = 112;
eea6121a 2469 size = 384;
d37c89e5
AM		 2470
2471 /* Make a ".reg/999" section. */
2472 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
eea6121a 2473 size, note->descpos + offset);
d37c89e5
AM		 2474}
2475
2476static bfd_boolean
2477ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2478{
2479 if (note->descsz != 136)
2480 return FALSE;
2481
2482 elf_tdata (abfd)->core_program
2483 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2484 elf_tdata (abfd)->core_command
2485 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2486
2487 return TRUE;
2488}
2489
5bd4f169
AM		 2490/* Merge backend specific data from an object file to the output
2491 object file when linking. */
2f6d9989 2492
b34976b6 2493static bfd_boolean
4ce794b7 2494ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5bd4f169 2495{
5bd4f169
AM		 2496 /* Check if we have the same endianess. */
2497 if (ibfd->xvec->byteorder != obfd->xvec->byteorder
87e226ce 2498 && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
5bd4f169
AM		 2499 && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
2500 {
2501 const char *msg;
2502
2503 if (bfd_big_endian (ibfd))
d003868e 2504 msg = _("%B: compiled for a big endian system "
4ce794b7 2505 "and target is little endian");
5bd4f169 2506 else
d003868e 2507 msg = _("%B: compiled for a little endian system "
4ce794b7 2508 "and target is big endian");
5bd4f169 2509
d003868e 2510 (*_bfd_error_handler) (msg, ibfd);
5bd4f169
AM		 2511
2512 bfd_set_error (bfd_error_wrong_format);
b34976b6 2513 return FALSE;
5bd4f169
AM		 2514 }
2515
b34976b6 2516 return TRUE;
5bd4f169 2517}
f0abc2a1 2518
5d35169e
AM		 2519/* Add extra PPC sections. */
2520
b35d266b 2521static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
7f4d3958
L		 2522{
2523 { ".plt", 4, 0, SHT_NOBITS, 0 },
7dcb9820 2524 { ".sbss", 5, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
551b43fd 2525 { ".sdata", 6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
7dcb9820
AM		 2526 { ".toc", 4, 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2527 { ".toc1", 5, 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2528 { ".tocbss", 7, 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2529 { NULL, 0, 0, 0, 0 }
5d35169e
AM		 2530};
2531
f0abc2a1
AM		 2532struct _ppc64_elf_section_data
2533{
2534 struct bfd_elf_section_data elf;
411e1bfb
AM		 2535
2536 /* An array with one entry for each opd function descriptor. */
f0abc2a1
AM		 2537 union
2538 {
411e1bfb 2539 /* Points to the function code section for local opd entries. */
f0abc2a1 2540 asection **func_sec;
411e1bfb 2541 /* After editing .opd, adjust references to opd local syms. */
f0abc2a1
AM		 2542 long *adjust;
2543 } opd;
411e1bfb
AM		 2544
2545 /* An array for toc sections, indexed by offset/8.
2546 Specifies the relocation symbol index used at a given toc offset. */
2547 unsigned *t_symndx;
f0abc2a1
AM		 2548};
2549
2550#define ppc64_elf_section_data(sec) \
411e1bfb 2551 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
f0abc2a1
AM		 2552
2553static bfd_boolean
4ce794b7 2554ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
f0abc2a1 2555{
f592407e
AM		 2556 if (!sec->used_by_bfd)
2557 {
2558 struct _ppc64_elf_section_data *sdata;
2559 bfd_size_type amt = sizeof (*sdata);
f0abc2a1 2560
f592407e
AM		 2561 sdata = bfd_zalloc (abfd, amt);
2562 if (sdata == NULL)
2563 return FALSE;
2564 sec->used_by_bfd = sdata;
2565 }
f0abc2a1
AM		 2566
2567 return _bfd_elf_new_section_hook (abfd, sec);
2568}
4025353c
AM		 2569
2570static void *
2571get_opd_info (asection * sec)
2572{
2573 if (sec != NULL
2574 && ppc64_elf_section_data (sec) != NULL
2575 && ppc64_elf_section_data (sec)->opd.adjust != NULL)
2576 return ppc64_elf_section_data (sec)->opd.adjust;
2577 return NULL;
2578}
90e3cdf2
JJ		 2579\f
2580/* Parameters for the qsort hook. */
2581static asection *synthetic_opd;
2582static bfd_boolean synthetic_relocatable;
2583
699733f6 2584/* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
90e3cdf2
JJ		 2585
2586static int
2587compare_symbols (const void *ap, const void *bp)
2588{
2589 const asymbol *a = * (const asymbol **) ap;
2590 const asymbol *b = * (const asymbol **) bp;
2591
699733f6
AM		 2592 /* Section symbols first. */
2593 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
90e3cdf2 2594 return -1;
699733f6 2595 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
90e3cdf2
JJ		 2596 return 1;
2597
699733f6 2598 /* then .opd symbols. */
90e3cdf2
JJ		 2599 if (a->section == synthetic_opd && b->section != synthetic_opd)
2600 return -1;
2601 if (a->section != synthetic_opd && b->section == synthetic_opd)
2602 return 1;
2603
699733f6 2604 /* then other code symbols. */
90e3cdf2
JJ		 2605 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2606 == (SEC_CODE | SEC_ALLOC)
2607 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2608 != (SEC_CODE | SEC_ALLOC))
2609 return -1;
2610
2611 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2612 != (SEC_CODE | SEC_ALLOC)
2613 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2614 == (SEC_CODE | SEC_ALLOC))
2615 return 1;
2616
2617 if (synthetic_relocatable)
2618 {
2619 if (a->section->id < b->section->id)
2620 return -1;
2621
2622 if (a->section->id > b->section->id)
2623 return 1;
2624 }
2625
2626 if (a->value + a->section->vma < b->value + b->section->vma)
2627 return -1;
2628
2629 if (a->value + a->section->vma > b->value + b->section->vma)
2630 return 1;
2631
4d35a0aa
AM		 2632 /* For syms with the same value, prefer strong dynamic global function
2633 syms over other syms. */
2634 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
2635 return -1;
2636
2637 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
2638 return 1;
2639
2640 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
2641 return -1;
2642
2643 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
2644 return 1;
2645
2646 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
2647 return -1;
2648
2649 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
2650 return 1;
2651
2652 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
2653 return -1;
2654
2655 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
2656 return 1;
2657
90e3cdf2
JJ		 2658 return 0;
2659}
2660
699733f6 2661/* Search SYMS for a symbol of the given VALUE. */
90e3cdf2 2662
699733f6
AM		 2663static asymbol *
2664sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
90e3cdf2 2665{
699733f6 2666 long mid;
90e3cdf2 2667
699733f6
AM		 2668 if (id == -1)
2669 {
2670 while (lo < hi)
2671 {
2672 mid = (lo + hi) >> 1;
2673 if (syms[mid]->value + syms[mid]->section->vma < value)
2674 lo = mid + 1;
2675 else if (syms[mid]->value + syms[mid]->section->vma > value)
2676 hi = mid;
2677 else
2678 return syms[mid];
2679 }
2680 }
2681 else
2682 {
2683 while (lo < hi)
2684 {
2685 mid = (lo + hi) >> 1;
2686 if (syms[mid]->section->id < id)
2687 lo = mid + 1;
2688 else if (syms[mid]->section->id > id)
2689 hi = mid;
2690 else if (syms[mid]->value < value)
2691 lo = mid + 1;
2692 else if (syms[mid]->value > value)
2693 hi = mid;
2694 else
2695 return syms[mid];
2696 }
2697 }
2698 return NULL;
90e3cdf2
JJ		 2699}
2700
699733f6
AM		 2701/* Create synthetic symbols, effectively restoring "dot-symbol" function
2702 entry syms. */
90e3cdf2
JJ		 2703
2704static long
a7535cf3
AM		 2705ppc64_elf_get_synthetic_symtab (bfd *abfd,
2706 long static_count, asymbol **static_syms,
2707 long dyn_count, asymbol **dyn_syms,
c9727e01 2708 asymbol **ret)
90e3cdf2
JJ		 2709{
2710 asymbol *s;
699733f6
AM		 2711 long i;
2712 long count;
90e3cdf2 2713 char *names;
a7535cf3 2714 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
699733f6 2715 asection *opd;
90e3cdf2 2716 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
a7535cf3 2717 asymbol **syms;
90e3cdf2
JJ		 2718
2719 *ret = NULL;
2720
2721 opd = bfd_get_section_by_name (abfd, ".opd");
2722 if (opd == NULL)
2723 return 0;
2724
a7535cf3 2725 symcount = static_count;
c9727e01 2726 if (!relocatable)
a7535cf3 2727 symcount += dyn_count;
90e3cdf2 2728 if (symcount == 0)
c9727e01 2729 return 0;
90e3cdf2 2730
a7535cf3
AM		 2731 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
2732 if (syms == NULL)
7356fed5 2733 return -1;
a7535cf3
AM		 2734
2735 if (!relocatable && static_count != 0 && dyn_count != 0)
2736 {
2737 /* Use both symbol tables. */
2738 memcpy (syms, static_syms, static_count * sizeof (*syms));
2739 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
2740 }
2741 else if (!relocatable && static_count == 0)
2742 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
2743 else
2744 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
2745
90e3cdf2
JJ		 2746 synthetic_opd = opd;
2747 synthetic_relocatable = relocatable;
595da8c5 2748 qsort (syms, symcount, sizeof (*syms), compare_symbols);
90e3cdf2 2749
c9727e01
AM		 2750 if (!relocatable && symcount > 1)
2751 {
2752 long j;
2753 /* Trim duplicate syms, since we may have merged the normal and
2754 dynamic symbols. Actually, we only care about syms that have
3b36f7e6 2755 different values, so trim any with the same value. */
c9727e01
AM		 2756 for (i = 1, j = 1; i < symcount; ++i)
2757 if (syms[i - 1]->value + syms[i - 1]->section->vma
2758 != syms[i]->value + syms[i]->section->vma)
2759 syms[j++] = syms[i];
2760 symcount = j;
2761 }
2762
699733f6
AM		 2763 i = 0;
2764 if (syms[i]->section == opd)
2765 ++i;
2766 codesecsym = i;
90e3cdf2 2767
699733f6
AM		 2768 for (; i < symcount; ++i)
2769 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2770 != (SEC_CODE | SEC_ALLOC))
2771 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
2772 break;
2773 codesecsymend = i;
90e3cdf2 2774
699733f6
AM		 2775 for (; i < symcount; ++i)
2776 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
2777 break;
2778 secsymend = i;
90e3cdf2 2779
699733f6
AM		 2780 for (; i < symcount; ++i)
2781 if (syms[i]->section != opd)
2782 break;
2783 opdsymend = i;
90e3cdf2 2784
699733f6
AM		 2785 for (; i < symcount; ++i)
2786 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2787 != (SEC_CODE | SEC_ALLOC))
2788 break;
2789 symcount = i;
2790
c9727e01 2791 count = 0;
699733f6 2792 if (opdsymend == secsymend)
c9727e01 2793 goto done;
90e3cdf2 2794
699733f6 2795 if (relocatable)
90e3cdf2 2796 {
699733f6
AM		 2797 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
2798 arelent *r;
2799 size_t size;
2800 long relcount;
90e3cdf2 2801
699733f6 2802 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
90e3cdf2 2803 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
7356fed5 2804 if (relcount == 0)
c9727e01 2805 goto done;
90e3cdf2 2806
7356fed5
AM		 2807 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
2808 {
2809 count = -1;
2810 goto done;
2811 }
2812
699733f6 2813 size = 0;
595da8c5 2814 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
699733f6
AM		 2815 {
2816 asymbol *sym;
90e3cdf2 2817
595da8c5 2818 while (r < opd->relocation + relcount
699733f6
AM		 2819 && r->address < syms[i]->value + opd->vma)
2820 ++r;
90e3cdf2 2821
595da8c5 2822 if (r == opd->relocation + relcount)
699733f6 2823 break;
90e3cdf2 2824
699733f6
AM		 2825 if (r->address != syms[i]->value + opd->vma)
2826 continue;
90e3cdf2 2827
699733f6
AM		 2828 if (r->howto->type != R_PPC64_ADDR64)
2829 continue;
90e3cdf2 2830
699733f6
AM		 2831 sym = *r->sym_ptr_ptr;
2832 if (!sym_exists_at (syms, opdsymend, symcount,
2833 sym->section->id, sym->value + r->addend))
2834 {
2835 ++count;
2836 size += sizeof (asymbol);
2837 size += strlen (syms[i]->name) + 2;
2838 }
2839 }
90e3cdf2 2840
699733f6
AM		 2841 s = *ret = bfd_malloc (size);
2842 if (s == NULL)
2843 {
7356fed5 2844 count = -1;
c9727e01 2845 goto done;
699733f6 2846 }
90e3cdf2 2847
699733f6 2848 names = (char *) (s + count);
90e3cdf2 2849
595da8c5 2850 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
90e3cdf2 2851 {
699733f6 2852 asymbol *sym;
90e3cdf2 2853
595da8c5 2854 while (r < opd->relocation + relcount
699733f6
AM		 2855 && r->address < syms[i]->value + opd->vma)
2856 ++r;
90e3cdf2 2857
595da8c5 2858 if (r == opd->relocation + relcount)
699733f6
AM		 2859 break;
2860
2861 if (r->address != syms[i]->value + opd->vma)
2862 continue;
2863
2864 if (r->howto->type != R_PPC64_ADDR64)
2865 continue;
90e3cdf2 2866
699733f6
AM		 2867 sym = *r->sym_ptr_ptr;
2868 if (!sym_exists_at (syms, opdsymend, symcount,
2869 sym->section->id, sym->value + r->addend))
2870 {
2871 size_t len;
2872
2873 *s = *syms[i];
2874 s->section = sym->section;
2875 s->value = sym->value + r->addend;
2876 s->name = names;
2877 *names++ = '.';
2878 len = strlen (syms[i]->name);
2879 memcpy (names, syms[i]->name, len + 1);
2880 names += len + 1;
2881 s++;
2882 }
2883 }
2884 }
2885 else
90e3cdf2 2886 {
699733f6
AM		 2887 bfd_byte *contents;
2888 size_t size;
90e3cdf2 2889
699733f6
AM		 2890 if (!bfd_malloc_and_get_section (abfd, opd, &contents))
2891 {
2892 if (contents)
c9727e01
AM		 2893 {
2894 free_contents_and_exit:
2895 free (contents);
2896 }
7356fed5 2897 count = -1;
c9727e01 2898 goto done;
699733f6 2899 }
90e3cdf2 2900
699733f6
AM		 2901 size = 0;
2902 for (i = secsymend; i < opdsymend; ++i)
2903 {
2904 bfd_vma ent;
90e3cdf2 2905
699733f6
AM		 2906 ent = bfd_get_64 (abfd, contents + syms[i]->value);
2907 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
2908 {
2909 ++count;
2910 size += sizeof (asymbol);
2911 size += strlen (syms[i]->name) + 2;
2912 }
2913 }
90e3cdf2 2914
699733f6
AM		 2915 s = *ret = bfd_malloc (size);
2916 if (s == NULL)
7356fed5 2917 goto free_contents_and_exit;
90e3cdf2 2918
699733f6 2919 names = (char *) (s + count);
90e3cdf2 2920
699733f6 2921 for (i = secsymend; i < opdsymend; ++i)
90e3cdf2 2922 {
699733f6 2923 bfd_vma ent;
90e3cdf2 2924
699733f6
AM		 2925 ent = bfd_get_64 (abfd, contents + syms[i]->value);
2926 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
90e3cdf2 2927 {
c9727e01 2928 long lo, hi;
699733f6 2929 size_t len;
c9727e01 2930 asection *sec = abfd->sections;
90e3cdf2 2931
699733f6
AM		 2932 *s = *syms[i];
2933 lo = codesecsym;
2934 hi = codesecsymend;
2935 while (lo < hi)
2936 {
c9727e01 2937 long mid = (lo + hi) >> 1;
699733f6
AM		 2938 if (syms[mid]->section->vma < ent)
2939 lo = mid + 1;
2940 else if (syms[mid]->section->vma > ent)
2941 hi = mid;
2942 else
c9727e01
AM		 2943 {
2944 sec = syms[mid]->section;
2945 break;
2946 }
699733f6
AM		 2947 }
2948
c9727e01 2949 if (lo >= hi && lo > codesecsym)
699733f6 2950 sec = syms[lo - 1]->section;
699733f6
AM		 2951
2952 for (; sec != NULL; sec = sec->next)
2953 {
2954 if (sec->vma > ent)
2955 break;
2956 if ((sec->flags & SEC_ALLOC) == 0
2957 || (sec->flags & SEC_LOAD) == 0)
2958 break;
2959 if ((sec->flags & SEC_CODE) != 0)
2960 s->section = sec;
2961 }
2962 s->value = ent - s->section->vma;
2963 s->name = names;
2964 *names++ = '.';
2965 len = strlen (syms[i]->name);
2966 memcpy (names, syms[i]->name, len + 1);
2967 names += len + 1;
2968 s++;
90e3cdf2 2969 }
90e3cdf2 2970 }
699733f6 2971 free (contents);
90e3cdf2
JJ		 2972 }
2973
c9727e01 2974 done:
a7535cf3 2975 free (syms);
90e3cdf2
JJ		 2976 return count;
2977}
5bd4f169 2978\f
65f38f15
AM		 2979/* The following functions are specific to the ELF linker, while
2980 functions above are used generally. Those named ppc64_elf_* are
2981 called by the main ELF linker code. They appear in this file more
2982 or less in the order in which they are called. eg.
2983 ppc64_elf_check_relocs is called early in the link process,
2984 ppc64_elf_finish_dynamic_sections is one of the last functions
e86ce104
AM		 2985 called.
2986
2987 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
2988 functions have both a function code symbol and a function descriptor
2989 symbol. A call to foo in a relocatable object file looks like:
2990
2991 . .text
2992 . x:
2993 . bl .foo
2994 . nop
2995
2996 The function definition in another object file might be:
2997
2998 . .section .opd
2999 . foo: .quad .foo
3000 . .quad .TOC.@tocbase
3001 . .quad 0
3002 .
3003 . .text
3004 . .foo: blr
3005
3006 When the linker resolves the call during a static link, the branch
3007 unsurprisingly just goes to .foo and the .opd information is unused.
3008 If the function definition is in a shared library, things are a little
3009 different: The call goes via a plt call stub, the opd information gets
3010 copied to the plt, and the linker patches the nop.
3011
3012 . x:
3013 . bl .foo_stub
3014 . ld 2,40(1)
3015 .
3016 .
3017 . .foo_stub:
3018 . addis 12,2,Lfoo@toc@ha # in practice, the call stub
411e1bfb 3019 . addi 12,12,Lfoo@toc@l # is slightly optimized, but
e86ce104
AM		 3020 . std 2,40(1) # this is the general idea
3021 . ld 11,0(12)
3022 . ld 2,8(12)
3023 . mtctr 11
3024 . ld 11,16(12)
3025 . bctr
3026 .
3027 . .section .plt
3028 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3029
3030 The "reloc ()" notation is supposed to indicate that the linker emits
3031 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3032 copying.
3033
3034 What are the difficulties here? Well, firstly, the relocations
3035 examined by the linker in check_relocs are against the function code
3036 sym .foo, while the dynamic relocation in the plt is emitted against
3037 the function descriptor symbol, foo. Somewhere along the line, we need
3038 to carefully copy dynamic link information from one symbol to the other.
3039 Secondly, the generic part of the elf linker will make .foo a dynamic
3040 symbol as is normal for most other backends. We need foo dynamic
3041 instead, at least for an application final link. However, when
3042 creating a shared library containing foo, we need to have both symbols
3043 dynamic so that references to .foo are satisfied during the early
3044 stages of linking. Otherwise the linker might decide to pull in a
8387904d
AM		 3045 definition from some other object, eg. a static library.
3046
3047 Update: As of August 2004, we support a new convention. Function
3048 calls may use the function descriptor symbol, ie. "bl foo". This
3049 behaves exactly as "bl .foo". */
65f38f15
AM		 3050
3051/* The linker needs to keep track of the number of relocs that it
3052 decides to copy as dynamic relocs in check_relocs for each symbol.
3053 This is so that it can later discard them if they are found to be
3054 unnecessary. We store the information in a field extending the
3055 regular ELF linker hash table. */
3056
3057struct ppc_dyn_relocs
3058{
3059 struct ppc_dyn_relocs *next;
3060
3061 /* The input section of the reloc. */
3062 asection *sec;
3063
3064 /* Total number of relocs copied for the input section. */
3065 bfd_size_type count;
3066
3067 /* Number of pc-relative relocs copied for the input section. */
3068 bfd_size_type pc_count;
3069};
3070
411e1bfb
AM		 3071/* Track GOT entries needed for a given symbol. We might need more
3072 than one got entry per symbol. */
3073struct got_entry
3074{
3075 struct got_entry *next;
3076
e7b938ca 3077 /* The symbol addend that we'll be placing in the GOT. */
411e1bfb
AM		 3078 bfd_vma addend;
3079
e717da7e
AM		 3080 /* Unlike other ELF targets, we use separate GOT entries for the same
3081 symbol referenced from different input files. This is to support
3082 automatic multiple TOC/GOT sections, where the TOC base can vary
3083 from one input file to another.
3084
3085 Point to the BFD owning this GOT entry. */
3086 bfd *owner;
3087
3088 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
3089 TLS_TPREL or TLS_DTPREL for tls entries. */
3090 char tls_type;
3091
e7b938ca 3092 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
411e1bfb
AM		 3093 union
3094 {
3095 bfd_signed_vma refcount;
3096 bfd_vma offset;
3097 } got;
411e1bfb
AM		 3098};
3099
3100/* The same for PLT. */
3101struct plt_entry
3102{
3103 struct plt_entry *next;
3104
3105 bfd_vma addend;
3106
3107 union
3108 {
3109 bfd_signed_vma refcount;
3110 bfd_vma offset;
3111 } plt;
3112};
3113
65f38f15 3114/* Of those relocs that might be copied as dynamic relocs, this macro
58ac9f71
AM		 3115 selects those that must be copied when linking a shared library,
3116 even when the symbol is local. */
65f38f15 3117
411e1bfb 3118#define MUST_BE_DYN_RELOC(RTYPE) \
805fc799
AM		 3119 ((RTYPE) != R_PPC64_REL32 \
3120 && (RTYPE) != R_PPC64_REL64 \
04c9666a 3121 && (RTYPE) != R_PPC64_REL30)
65f38f15 3122
f4656909
AM		 3123/* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3124 copying dynamic variables from a shared lib into an app's dynbss
3125 section, and instead use a dynamic relocation to point into the
5d35169e
AM		 3126 shared lib. With code that gcc generates, it's vital that this be
3127 enabled; In the PowerPC64 ABI, the address of a function is actually
3128 the address of a function descriptor, which resides in the .opd
3129 section. gcc uses the descriptor directly rather than going via the
3130 GOT as some other ABI's do, which means that initialized function
3131 pointers must reference the descriptor. Thus, a function pointer
3132 initialized to the address of a function in a shared library will
3133 either require a copy reloc, or a dynamic reloc. Using a copy reloc
4cc11e76 3134 redefines the function descriptor symbol to point to the copy. This
5d35169e
AM		 3135 presents a problem as a plt entry for that function is also
3136 initialized from the function descriptor symbol and the copy reloc
3137 may not be initialized first. */
a23b6845 3138#define ELIMINATE_COPY_RELOCS 1
f4656909 3139
721956f4
AM		 3140/* Section name for stubs is the associated section name plus this
3141 string. */
3142#define STUB_SUFFIX ".stub"
3143
3144/* Linker stubs.
3145 ppc_stub_long_branch:
3146 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3147 destination, but a 24 bit branch in a stub section will reach.
3148 . b dest
3149
3150 ppc_stub_plt_branch:
3151 Similar to the above, but a 24 bit branch in the stub section won't
3152 reach its destination.
87e226ce
AM		 3153 . addis %r12,%r2,xxx@toc@ha
3154 . ld %r11,xxx@toc@l(%r12)
721956f4
AM		 3155 . mtctr %r11
3156 . bctr
3157
3158 ppc_stub_plt_call:
2c66dc6c
AM		 3159 Used to call a function in a shared library. If it so happens that
3160 the plt entry referenced crosses a 64k boundary, then an extra
3161 "addis %r12,%r12,1" will be inserted before the load at xxx+8 or
3162 xxx+16 as appropriate.
87e226ce 3163 . addis %r12,%r2,xxx@toc@ha
721956f4 3164 . std %r2,40(%r1)
87e226ce
AM		 3165 . ld %r11,xxx+0@toc@l(%r12)
3166 . ld %r2,xxx+8@toc@l(%r12)
721956f4 3167 . mtctr %r11
87e226ce 3168 . ld %r11,xxx+16@toc@l(%r12)
721956f4 3169 . bctr
ad8e1ba5
AM		 3170
3171 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3172 code to adjust the value and save r2 to support multiple toc sections.
3173 A ppc_stub_long_branch with an r2 offset looks like:
3174 . std %r2,40(%r1)
3175 . addis %r2,%r2,off@ha
3176 . addi %r2,%r2,off@l
3177 . b dest
3178
3179 A ppc_stub_plt_branch with an r2 offset looks like:
3180 . std %r2,40(%r1)
3181 . addis %r12,%r2,xxx@toc@ha
3182 . ld %r11,xxx@toc@l(%r12)
3183 . addis %r2,%r2,off@ha
3184 . addi %r2,%r2,off@l
3185 . mtctr %r11
3186 . bctr
721956f4
AM		 3187*/
3188
3189enum ppc_stub_type {
3190 ppc_stub_none,
3191 ppc_stub_long_branch,
ad8e1ba5 3192 ppc_stub_long_branch_r2off,
721956f4 3193 ppc_stub_plt_branch,
ad8e1ba5 3194 ppc_stub_plt_branch_r2off,
721956f4
AM		 3195 ppc_stub_plt_call
3196};
3197
3198struct ppc_stub_hash_entry {
3199
3200 /* Base hash table entry structure. */
3201 struct bfd_hash_entry root;
3202
ad8e1ba5
AM		 3203 enum ppc_stub_type stub_type;
3204
721956f4
AM		 3205 /* The stub section. */
3206 asection *stub_sec;
3207
3208 /* Offset within stub_sec of the beginning of this stub. */
3209 bfd_vma stub_offset;
3210
3211 /* Given the symbol's value and its section we can determine its final
3212 value when building the stubs (so the stub knows where to jump. */
3213 bfd_vma target_value;
3214 asection *target_section;
3215
721956f4
AM		 3216 /* The symbol table entry, if any, that this was derived from. */
3217 struct ppc_link_hash_entry *h;
3218
411e1bfb
AM		 3219 /* And the reloc addend that this was derived from. */
3220 bfd_vma addend;
3221
721956f4
AM		 3222 /* Where this stub is being called from, or, in the case of combined
3223 stub sections, the first input section in the group. */
3224 asection *id_sec;
3225};
3226
3227struct ppc_branch_hash_entry {
3228
3229 /* Base hash table entry structure. */
3230 struct bfd_hash_entry root;
3231
c456f082 3232 /* Offset within branch lookup table. */
721956f4
AM		 3233 unsigned int offset;
3234
3235 /* Generation marker. */
3236 unsigned int iter;
3237};
65f38f15
AM		 3238
3239struct ppc_link_hash_entry
3240{
3241 struct elf_link_hash_entry elf;
3242
721956f4
AM		 3243 /* A pointer to the most recently used stub hash entry against this
3244 symbol. */
3245 struct ppc_stub_hash_entry *stub_cache;
3246
65f38f15
AM		 3247 /* Track dynamic relocs copied for this symbol. */
3248 struct ppc_dyn_relocs *dyn_relocs;
e86ce104 3249
721956f4 3250 /* Link between function code and descriptor symbols. */
34814b9f 3251 struct ppc_link_hash_entry *oh;
721956f4 3252
e86ce104
AM		 3253 /* Flag function code and descriptor symbols. */
3254 unsigned int is_func:1;
3255 unsigned int is_func_descriptor:1;
908b32fc 3256 unsigned int fake:1;
411e1bfb 3257
c5614fa4
AM		 3258 /* Whether global opd/toc sym has been adjusted or not.
3259 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3260 should be set for all globals defined in any opd/toc section. */
754021d0
AM		 3261 unsigned int adjust_done:1;
3262
99877b66
AM		 3263 /* Set if we twiddled this symbol to weak at some stage. */
3264 unsigned int was_undefined:1;
3265
411e1bfb 3266 /* Contexts in which symbol is used in the GOT (or TOC).
e7b938ca
AM		 3267 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3268 corresponding relocs are encountered during check_relocs.
3269 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3270 indicate the corresponding GOT entry type is not needed.
3271 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3272 a TPREL one. We use a separate flag rather than setting TPREL
3273 just for convenience in distinguishing the two cases. */
3274#define TLS_GD 1 /* GD reloc. */
3275#define TLS_LD 2 /* LD reloc. */
3276#define TLS_TPREL 4 /* TPREL reloc, => IE. */
3277#define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
3278#define TLS_TLS 16 /* Any TLS reloc. */
3279#define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
3280#define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
3281 char tls_mask;
65f38f15
AM		 3282};
3283
3284/* ppc64 ELF linker hash table. */
3285
3286struct ppc_link_hash_table
3287{
3288 struct elf_link_hash_table elf;
3289
721956f4
AM		 3290 /* The stub hash table. */
3291 struct bfd_hash_table stub_hash_table;
3292
3293 /* Another hash table for plt_branch stubs. */
3294 struct bfd_hash_table branch_hash_table;
3295
3296 /* Linker stub bfd. */
3297 bfd *stub_bfd;
3298
3299 /* Linker call-backs. */
4ce794b7
AM		 3300 asection * (*add_stub_section) (const char *, asection *);
3301 void (*layout_sections_again) (void);
721956f4
AM		 3302
3303 /* Array to keep track of which stub sections have been created, and
3304 information on stub grouping. */
3305 struct map_stub {
3306 /* This is the section to which stubs in the group will be attached. */
3307 asection *link_sec;
3308 /* The stub section. */
3309 asection *stub_sec;
ad8e1ba5
AM		 3310 /* Along with elf_gp, specifies the TOC pointer used in this group. */
3311 bfd_vma toc_off;
721956f4
AM		 3312 } *stub_group;
3313
ad8e1ba5
AM		 3314 /* Temp used when calculating TOC pointers. */
3315 bfd_vma toc_curr;
3316
8f3bab57
AM		 3317 /* Highest input section id. */
3318 int top_id;
3319
734b6cf9
AM		 3320 /* Highest output section index. */
3321 int top_index;
3322
3323 /* List of input sections for each output section. */
3324 asection **input_list;
721956f4 3325
65f38f15 3326 /* Short-cuts to get to dynamic linker sections. */
4ce794b7 3327 asection *got;
4ce794b7
AM		 3328 asection *plt;
3329 asection *relplt;
3330 asection *dynbss;
3331 asection *relbss;
3332 asection *glink;
82bd7b59 3333 asection *sfpr;
4ce794b7
AM		 3334 asection *brlt;
3335 asection *relbrlt;
ec338859 3336
8387904d
AM		 3337 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
3338 struct ppc_link_hash_entry *tls_get_addr;
3339 struct ppc_link_hash_entry *tls_get_addr_fd;
411e1bfb 3340
9b5ecbd0
AM		 3341 /* Statistics. */
3342 unsigned long stub_count[ppc_stub_plt_call];
3343
ee75fd95
AM		 3344 /* Number of stubs against global syms. */
3345 unsigned long stub_globals;
3346
ad8e1ba5 3347 /* Set if we should emit symbols for stubs. */
99877b66 3348 unsigned int emit_stub_syms:1;
ad8e1ba5 3349
4c52953f
AM		 3350 /* Support for multiple toc sections. */
3351 unsigned int no_multi_toc:1;
3352 unsigned int multi_toc_needed:1;
3353
5d1634d7 3354 /* Set on error. */
99877b66 3355 unsigned int stub_error:1;
721956f4
AM		 3356
3357 /* Flag set when small branches are detected. Used to
3358 select suitable defaults for the stub group size. */
99877b66
AM		 3359 unsigned int has_14bit_branch:1;
3360
3361 /* Temp used by ppc64_elf_check_directives. */
3362 unsigned int twiddled_syms:1;
721956f4
AM		 3363
3364 /* Incremented every time we size stubs. */
3365 unsigned int stub_iteration;
5d1634d7 3366
ec338859
AM		 3367 /* Small local sym to section mapping cache. */
3368 struct sym_sec_cache sym_sec;
65f38f15
AM		 3369};
3370
4c52953f
AM		 3371/* Rename some of the generic section flags to better document how they
3372 are used here. */
3373#define has_toc_reloc has_gp_reloc
3374#define makes_toc_func_call need_finalize_relax
3375#define call_check_in_progress reloc_done
3376
65f38f15
AM		 3377/* Get the ppc64 ELF linker hash table from a link_info structure. */
3378
3379#define ppc_hash_table(p) \
3380 ((struct ppc_link_hash_table *) ((p)->hash))
3381
721956f4
AM		 3382#define ppc_stub_hash_lookup(table, string, create, copy) \
3383 ((struct ppc_stub_hash_entry *) \
3384 bfd_hash_lookup ((table), (string), (create), (copy)))
3385
3386#define ppc_branch_hash_lookup(table, string, create, copy) \
3387 ((struct ppc_branch_hash_entry *) \
3388 bfd_hash_lookup ((table), (string), (create), (copy)))
3389
3390/* Create an entry in the stub hash table. */
3391
3392static struct bfd_hash_entry *
4ce794b7
AM		 3393stub_hash_newfunc (struct bfd_hash_entry *entry,
3394 struct bfd_hash_table *table,
3395 const char *string)
721956f4
AM		 3396{
3397 /* Allocate the structure if it has not already been allocated by a
3398 subclass. */
3399 if (entry == NULL)
3400 {
3401 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
3402 if (entry == NULL)
3403 return entry;
3404 }
3405
3406 /* Call the allocation method of the superclass. */
3407 entry = bfd_hash_newfunc (entry, table, string);
3408 if (entry != NULL)
3409 {
3410 struct ppc_stub_hash_entry *eh;
3411
3412 /* Initialize the local fields. */
3413 eh = (struct ppc_stub_hash_entry *) entry;
ad8e1ba5 3414 eh->stub_type = ppc_stub_none;
721956f4
AM		 3415 eh->stub_sec = NULL;
3416 eh->stub_offset = 0;
3417 eh->target_value = 0;
3418 eh->target_section = NULL;
721956f4
AM		 3419 eh->h = NULL;
3420 eh->id_sec = NULL;
3421 }
3422
3423 return entry;
3424}
3425
3426/* Create an entry in the branch hash table. */
3427
3428static struct bfd_hash_entry *
4ce794b7
AM		 3429branch_hash_newfunc (struct bfd_hash_entry *entry,
3430 struct bfd_hash_table *table,
3431 const char *string)
721956f4
AM		 3432{
3433 /* Allocate the structure if it has not already been allocated by a
3434 subclass. */
3435 if (entry == NULL)
3436 {
3437 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
3438 if (entry == NULL)
3439 return entry;
3440 }
3441
3442 /* Call the allocation method of the superclass. */
3443 entry = bfd_hash_newfunc (entry, table, string);
3444 if (entry != NULL)
3445 {
3446 struct ppc_branch_hash_entry *eh;
3447
3448 /* Initialize the local fields. */
3449 eh = (struct ppc_branch_hash_entry *) entry;
3450 eh->offset = 0;
3451 eh->iter = 0;
3452 }
3453
3454 return entry;
3455}
3456
65f38f15
AM		 3457/* Create an entry in a ppc64 ELF linker hash table. */
3458
3459static struct bfd_hash_entry *
4ce794b7
AM		 3460link_hash_newfunc (struct bfd_hash_entry *entry,
3461 struct bfd_hash_table *table,
3462 const char *string)
65f38f15
AM		 3463{
3464 /* Allocate the structure if it has not already been allocated by a
3465 subclass. */
3466 if (entry == NULL)
3467 {
3468 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
3469 if (entry == NULL)
3470 return entry;
3471 }
3472
3473 /* Call the allocation method of the superclass. */
3474 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
3475 if (entry != NULL)
3476 {
3477 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
3478
908b32fc
AM		 3479 memset (&eh->stub_cache, 0,
3480 (sizeof (struct ppc_link_hash_entry)
3481 - offsetof (struct ppc_link_hash_entry, stub_cache)));
65f38f15
AM		 3482 }
3483
3484 return entry;
3485}
3486
3487/* Create a ppc64 ELF linker hash table. */
3488
3489static struct bfd_link_hash_table *
4ce794b7 3490ppc64_elf_link_hash_table_create (bfd *abfd)
65f38f15
AM		 3491{
3492 struct ppc_link_hash_table *htab;
3493 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
3494
4ce794b7 3495 htab = bfd_zmalloc (amt);
65f38f15
AM		 3496 if (htab == NULL)
3497 return NULL;
3498
66eb6687
AM		 3499 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
3500 sizeof (struct ppc_link_hash_entry)))
65f38f15 3501 {
e2d34d7d 3502 free (htab);
65f38f15
AM		 3503 return NULL;
3504 }
3505
721956f4 3506 /* Init the stub hash table too. */
66eb6687
AM		 3507 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
3508 sizeof (struct ppc_stub_hash_entry)))
721956f4
AM		 3509 return NULL;
3510
3511 /* And the branch hash table. */
66eb6687
AM		 3512 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
3513 sizeof (struct ppc_branch_hash_entry)))
721956f4
AM		 3514 return NULL;
3515
3254fd24
AM		 3516 /* Initializing two fields of the union is just cosmetic. We really
3517 only care about glist, but when compiled on a 32-bit host the
3518 bfd_vma fields are larger. Setting the bfd_vma to zero makes
3519 debugger inspection of these fields look nicer. */
a6aa5195
AM		 3520 htab->elf.init_got_refcount.refcount = 0;
3521 htab->elf.init_got_refcount.glist = NULL;
3522 htab->elf.init_plt_refcount.refcount = 0;
3523 htab->elf.init_plt_refcount.glist = NULL;
3524 htab->elf.init_got_offset.offset = 0;
3525 htab->elf.init_got_offset.glist = NULL;
3526 htab->elf.init_plt_offset.offset = 0;
3527 htab->elf.init_plt_offset.glist = NULL;
3254fd24 3528
65f38f15
AM		 3529 return &htab->elf.root;
3530}
3531
721956f4
AM		 3532/* Free the derived linker hash table. */
3533
3534static void
4ce794b7 3535ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
721956f4
AM		 3536{
3537 struct ppc_link_hash_table *ret = (struct ppc_link_hash_table *) hash;
3538
3539 bfd_hash_table_free (&ret->stub_hash_table);
3540 bfd_hash_table_free (&ret->branch_hash_table);
3541 _bfd_generic_link_hash_table_free (hash);
3542}
3543
e717da7e
AM		 3544/* Satisfy the ELF linker by filling in some fields in our fake bfd. */
3545
3546void
3547ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
3548{
3549 struct ppc_link_hash_table *htab;
3550
3551 elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
3552
3553/* Always hook our dynamic sections into the first bfd, which is the
3554 linker created stub bfd. This ensures that the GOT header is at
3555 the start of the output TOC section. */
3556 htab = ppc_hash_table (info);
3557 htab->stub_bfd = abfd;
3558 htab->elf.dynobj = abfd;
3559}
3560
721956f4
AM		 3561/* Build a name for an entry in the stub hash table. */
3562
3563static char *
4ce794b7
AM		 3564ppc_stub_name (const asection *input_section,
3565 const asection *sym_sec,
3566 const struct ppc_link_hash_entry *h,
3567 const Elf_Internal_Rela *rel)
721956f4
AM		 3568{
3569 char *stub_name;
3570 bfd_size_type len;
3571
3572 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
3573 offsets from a sym as a branch target? In fact, we could
3574 probably assume the addend is always zero. */
3575 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
3576
3577 if (h)
3578 {
3579 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
3580 stub_name = bfd_malloc (len);
46de2a7c
AM		 3581 if (stub_name == NULL)
3582 return stub_name;
3583
3584 sprintf (stub_name, "%08x.%s+%x",
3585 input_section->id & 0xffffffff,
3586 h->elf.root.root.string,
3587 (int) rel->r_addend & 0xffffffff);
721956f4
AM		 3588 }
3589 else
3590 {
ad8e1ba5 3591 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
721956f4 3592 stub_name = bfd_malloc (len);
46de2a7c
AM		 3593 if (stub_name == NULL)
3594 return stub_name;
3595
3596 sprintf (stub_name, "%08x.%x:%x+%x",
3597 input_section->id & 0xffffffff,
3598 sym_sec->id & 0xffffffff,
3599 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
3600 (int) rel->r_addend & 0xffffffff);
721956f4 3601 }
ee75fd95
AM		 3602 if (stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
3603 stub_name[len - 2] = 0;
721956f4
AM		 3604 return stub_name;
3605}
3606
3607/* Look up an entry in the stub hash. Stub entries are cached because
3608 creating the stub name takes a bit of time. */
3609
3610static struct ppc_stub_hash_entry *
4ce794b7
AM		 3611ppc_get_stub_entry (const asection *input_section,
3612 const asection *sym_sec,
039b3fef 3613 struct ppc_link_hash_entry *h,
4ce794b7
AM		 3614 const Elf_Internal_Rela *rel,
3615 struct ppc_link_hash_table *htab)
721956f4
AM		 3616{
3617 struct ppc_stub_hash_entry *stub_entry;
721956f4
AM		 3618 const asection *id_sec;
3619
3620 /* If this input section is part of a group of sections sharing one
3621 stub section, then use the id of the first section in the group.
3622 Stub names need to include a section id, as there may well be
3623 more than one stub used to reach say, printf, and we need to
3624 distinguish between them. */
3625 id_sec = htab->stub_group[input_section->id].link_sec;
3626
3627 if (h != NULL && h->stub_cache != NULL
3628 && h->stub_cache->h == h
3629 && h->stub_cache->id_sec == id_sec)
3630 {
3631 stub_entry = h->stub_cache;
3632 }
3633 else
3634 {
3635 char *stub_name;
3636
3637 stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
3638 if (stub_name == NULL)
3639 return NULL;
3640
3641 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
b34976b6 3642 stub_name, FALSE, FALSE);
721956f4
AM		 3643 if (h != NULL)
3644 h->stub_cache = stub_entry;
3645
3646 free (stub_name);
3647 }
3648
3649 return stub_entry;
3650}
3651
3652/* Add a new stub entry to the stub hash. Not all fields of the new
3653 stub entry are initialised. */
3654
3655static struct ppc_stub_hash_entry *
4ce794b7
AM		 3656ppc_add_stub (const char *stub_name,
3657 asection *section,
3658 struct ppc_link_hash_table *htab)
721956f4
AM		 3659{
3660 asection *link_sec;
3661 asection *stub_sec;
3662 struct ppc_stub_hash_entry *stub_entry;
3663
3664 link_sec = htab->stub_group[section->id].link_sec;
3665 stub_sec = htab->stub_group[section->id].stub_sec;
3666 if (stub_sec == NULL)
3667 {
3668 stub_sec = htab->stub_group[link_sec->id].stub_sec;
3669 if (stub_sec == NULL)
3670 {
d4c88bbb 3671 size_t namelen;
721956f4
AM		 3672 bfd_size_type len;
3673 char *s_name;
3674
d4c88bbb
AM		 3675 namelen = strlen (link_sec->name);
3676 len = namelen + sizeof (STUB_SUFFIX);
721956f4
AM		 3677 s_name = bfd_alloc (htab->stub_bfd, len);
3678 if (s_name == NULL)
3679 return NULL;
3680
d4c88bbb
AM		 3681 memcpy (s_name, link_sec->name, namelen);
3682 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
721956f4
AM		 3683 stub_sec = (*htab->add_stub_section) (s_name, link_sec);
3684 if (stub_sec == NULL)
3685 return NULL;
3686 htab->stub_group[link_sec->id].stub_sec = stub_sec;
3687 }
3688 htab->stub_group[section->id].stub_sec = stub_sec;
3689 }
3690
3691 /* Enter this entry into the linker stub hash table. */
3692 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
b34976b6 3693 TRUE, FALSE);
721956f4
AM		 3694 if (stub_entry == NULL)
3695 {
d003868e
AM		 3696 (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
3697 section->owner, stub_name);
721956f4
AM		 3698 return NULL;
3699 }
3700
3701 stub_entry->stub_sec = stub_sec;
3702 stub_entry->stub_offset = 0;
3703 stub_entry->id_sec = link_sec;
3704 return stub_entry;
3705}
3706
82bd7b59
AM		 3707/* Create sections for linker generated code. */
3708
b34976b6 3709static bfd_boolean
4ce794b7 3710create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
82bd7b59
AM		 3711{
3712 struct ppc_link_hash_table *htab;
3713 flagword flags;
3714
3715 htab = ppc_hash_table (info);
3716
3717 /* Create .sfpr for code to save and restore fp regs. */
3718 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
3719 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3496cb2a
L		 3720 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
3721 flags);
82bd7b59 3722 if (htab->sfpr == NULL
82bd7b59 3723 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
b34976b6 3724 return FALSE;
82bd7b59 3725
721956f4 3726 /* Create .glink for lazy dynamic linking support. */
3496cb2a
L		 3727 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
3728 flags);
4ce794b7 3729 if (htab->glink == NULL
ee4bf8d2 3730 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
b34976b6 3731 return FALSE;
82bd7b59 3732
c456f082
AM		 3733 /* Create branch lookup table for plt_branch stubs. */
3734 if (info->shared)
3735 {
3736 flags = (SEC_ALLOC | SEC_LOAD
3737 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3738 htab->brlt
3739 = bfd_make_section_anyway_with_flags (dynobj, ".data.rel.ro.brlt",
3740 flags);
3741 }
3742 else
3743 {
3744 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
3745 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3746 htab->brlt
3747 = bfd_make_section_anyway_with_flags (dynobj, ".rodata.brlt", flags);
3748 }
3749
4ce794b7 3750 if (htab->brlt == NULL
4ce794b7 3751 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
b34976b6 3752 return FALSE;
721956f4 3753
c456f082 3754 if (info->shared)
721956f4
AM		 3755 {
3756 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
3757 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
c456f082
AM		 3758 htab->relbrlt
3759 = bfd_make_section_anyway_with_flags (dynobj, ".rela.data.rel.ro.brlt",
3760 flags);
721956f4 3761 }
c456f082
AM		 3762 else if (info->emitrelocations)
3763 {
3764 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
3765 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3766 htab->relbrlt
3767 = bfd_make_section_anyway_with_flags (dynobj, ".rela.rodata.brlt",
3768 flags);
3769 }
3770 else
3771 return TRUE;
3772
3773 if (!htab->relbrlt
3774 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
3775 return FALSE;
3776
b34976b6 3777 return TRUE;
82bd7b59
AM		 3778}
3779
e717da7e
AM		 3780/* Create .got and .rela.got sections in ABFD, and .got in dynobj if
3781 not already done. */
65f38f15 3782
b34976b6 3783static bfd_boolean
e717da7e 3784create_got_section (bfd *abfd, struct bfd_link_info *info)
65f38f15 3785{
e717da7e
AM		 3786 asection *got, *relgot;
3787 flagword flags;
3788 struct ppc_link_hash_table *htab = ppc_hash_table (info);
65f38f15 3789
4ce794b7 3790 if (!htab->got)
e717da7e
AM		 3791 {
3792 if (! _bfd_elf_create_got_section (htab->elf.dynobj, info))
3793 return FALSE;
3794
3795 htab->got = bfd_get_section_by_name (htab->elf.dynobj, ".got");
3796 if (!htab->got)
3797 abort ();
3798 }
3799
3800 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3801 | SEC_LINKER_CREATED);
3802
c456f082 3803 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
e717da7e 3804 if (!got
e717da7e
AM		 3805 || !bfd_set_section_alignment (abfd, got, 3))
3806 return FALSE;
65f38f15 3807
c456f082
AM		 3808 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
3809 flags | SEC_READONLY);
e717da7e 3810 if (!relgot
e717da7e 3811 || ! bfd_set_section_alignment (abfd, relgot, 3))
b34976b6 3812 return FALSE;
e717da7e
AM		 3813
3814 ppc64_elf_tdata (abfd)->got = got;
3815 ppc64_elf_tdata (abfd)->relgot = relgot;
b34976b6 3816 return TRUE;
65f38f15 3817}
5bd4f169 3818
82bd7b59 3819/* Create the dynamic sections, and set up shortcuts. */
5bd4f169 3820
b34976b6 3821static bfd_boolean
4ce794b7 3822ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
5bd4f169 3823{
65f38f15 3824 struct ppc_link_hash_table *htab;
5bd4f169 3825
65f38f15 3826 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
b34976b6 3827 return FALSE;
65f38f15 3828
e717da7e
AM		 3829 htab = ppc_hash_table (info);
3830 if (!htab->got)
3831 htab->got = bfd_get_section_by_name (dynobj, ".got");
4ce794b7
AM		 3832 htab->plt = bfd_get_section_by_name (dynobj, ".plt");
3833 htab->relplt = bfd_get_section_by_name (dynobj, ".rela.plt");
3834 htab->dynbss = bfd_get_section_by_name (dynobj, ".dynbss");
65f38f15 3835 if (!info->shared)
4ce794b7 3836 htab->relbss = bfd_get_section_by_name (dynobj, ".rela.bss");
65f38f15 3837
e717da7e 3838 if (!htab->got || !htab->plt || !htab->relplt || !htab->dynbss
4ce794b7 3839 || (!info->shared && !htab->relbss))
65f38f15
AM		 3840 abort ();
3841
b34976b6 3842 return TRUE;
5bd4f169
AM		 3843}
3844
40d16e0b
AM		 3845/* Merge PLT info on FROM with that on TO. */
3846
3847static void
3848move_plt_plist (struct ppc_link_hash_entry *from,
3849 struct ppc_link_hash_entry *to)
3850{
3851 if (from->elf.plt.plist != NULL)
3852 {
3853 if (to->elf.plt.plist != NULL)
3854 {
3855 struct plt_entry **entp;
3856 struct plt_entry *ent;
3857
3858 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
3859 {
3860 struct plt_entry *dent;
3861
3862 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
3863 if (dent->addend == ent->addend)
3864 {
3865 dent->plt.refcount += ent->plt.refcount;
3866 *entp = ent->next;
3867 break;
3868 }
3869 if (dent == NULL)
3870 entp = &ent->next;
3871 }
3872 *entp = to->elf.plt.plist;
3873 }
3874
3875 to->elf.plt.plist = from->elf.plt.plist;
3876 from->elf.plt.plist = NULL;
3877 }
3878}
3879
65f38f15
AM		 3880/* Copy the extra info we tack onto an elf_link_hash_entry. */
3881
3882static void
fcfa13d2
AM		 3883ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
3884 struct elf_link_hash_entry *dir,
3885 struct elf_link_hash_entry *ind)
65f38f15
AM		 3886{
3887 struct ppc_link_hash_entry *edir, *eind;
3888
3889 edir = (struct ppc_link_hash_entry *) dir;
3890 eind = (struct ppc_link_hash_entry *) ind;
3891
411e1bfb 3892 /* Copy over any dynamic relocs we may have on the indirect sym. */
bbd7ec4a 3893 if (eind->dyn_relocs != NULL)
65f38f15 3894 {
bbd7ec4a
AM		 3895 if (edir->dyn_relocs != NULL)
3896 {
3897 struct ppc_dyn_relocs **pp;
3898 struct ppc_dyn_relocs *p;
3899
fcfa13d2 3900 /* Add reloc counts against the indirect sym to the direct sym
bbd7ec4a
AM		 3901 list. Merge any entries against the same section. */
3902 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
3903 {
3904 struct ppc_dyn_relocs *q;
3905
3906 for (q = edir->dyn_relocs; q != NULL; q = q->next)
3907 if (q->sec == p->sec)
3908 {
3909 q->pc_count += p->pc_count;
3910 q->count += p->count;
3911 *pp = p->next;
3912 break;
3913 }
3914 if (q == NULL)
3915 pp = &p->next;
3916 }
3917 *pp = edir->dyn_relocs;
3918 }
3919
65f38f15
AM		 3920 edir->dyn_relocs = eind->dyn_relocs;
3921 eind->dyn_relocs = NULL;
3922 }
65f38f15 3923
6349e628
AM		 3924 edir->is_func |= eind->is_func;
3925 edir->is_func_descriptor |= eind->is_func_descriptor;
58ac9f71 3926 edir->tls_mask |= eind->tls_mask;
6349e628 3927
81848ca0 3928 /* If called to transfer flags for a weakdef during processing
f5385ebf 3929 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
81848ca0 3930 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
f5385ebf
AM		 3931 if (!(ELIMINATE_COPY_RELOCS
3932 && eind->elf.root.type != bfd_link_hash_indirect
3933 && edir->elf.dynamic_adjusted))
3934 edir->elf.non_got_ref |= eind->elf.non_got_ref;
81848ca0 3935
f5385ebf
AM		 3936 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
3937 edir->elf.ref_regular |= eind->elf.ref_regular;
3938 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
3939 edir->elf.needs_plt |= eind->elf.needs_plt;
6349e628
AM		 3940
3941 /* If we were called to copy over info for a weak sym, that's all. */
3942 if (eind->elf.root.type != bfd_link_hash_indirect)
3943 return;
3944
81848ca0
AM		 3945 /* Copy over got entries that we may have already seen to the
3946 symbol which just became indirect. */
411e1bfb
AM		 3947 if (eind->elf.got.glist != NULL)
3948 {
3949 if (edir->elf.got.glist != NULL)
3950 {
3951 struct got_entry **entp;
3952 struct got_entry *ent;
3953
3954 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
3955 {
3956 struct got_entry *dent;
3957
3958 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
3959 if (dent->addend == ent->addend
e717da7e 3960 && dent->owner == ent->owner
411e1bfb
AM		 3961 && dent->tls_type == ent->tls_type)
3962 {
3963 dent->got.refcount += ent->got.refcount;
3964 *entp = ent->next;
3965 break;
3966 }
3967 if (dent == NULL)
3968 entp = &ent->next;
3969 }
3970 *entp = edir->elf.got.glist;
3971 }
3972
3973 edir->elf.got.glist = eind->elf.got.glist;
3974 eind->elf.got.glist = NULL;
3975 }
3976
3977 /* And plt entries. */
40d16e0b 3978 move_plt_plist (eind, edir);
411e1bfb 3979
fcfa13d2 3980 if (eind->elf.dynindx != -1)
411e1bfb 3981 {
fcfa13d2
AM		 3982 if (edir->elf.dynindx != -1)
3983 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
3984 edir->elf.dynstr_index);
411e1bfb
AM		 3985 edir->elf.dynindx = eind->elf.dynindx;
3986 edir->elf.dynstr_index = eind->elf.dynstr_index;
3987 eind->elf.dynindx = -1;
3988 eind->elf.dynstr_index = 0;
3989 }
411e1bfb
AM		 3990}
3991
8387904d
AM		 3992/* Find the function descriptor hash entry from the given function code
3993 hash entry FH. Link the entries via their OH fields. */
3994
3995static struct ppc_link_hash_entry *
3996get_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
3997{
3998 struct ppc_link_hash_entry *fdh = fh->oh;
3999
4000 if (fdh == NULL)
4001 {
4002 const char *fd_name = fh->elf.root.root.string + 1;
4003
4004 fdh = (struct ppc_link_hash_entry *)
4005 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4006 if (fdh != NULL)
4007 {
4008 fdh->is_func_descriptor = 1;
4009 fdh->oh = fh;
4010 fh->is_func = 1;
4011 fh->oh = fdh;
4012 }
4013 }
4014
4015 return fdh;
4016}
4017
bb700d78
AM		 4018/* Make a fake function descriptor sym for the code sym FH. */
4019
4020static struct ppc_link_hash_entry *
4021make_fdh (struct bfd_link_info *info,
908b32fc 4022 struct ppc_link_hash_entry *fh)
bb700d78
AM		 4023{
4024 bfd *abfd;
4025 asymbol *newsym;
4026 struct bfd_link_hash_entry *bh;
4027 struct ppc_link_hash_entry *fdh;
4028
4029 abfd = fh->elf.root.u.undef.abfd;
4030 newsym = bfd_make_empty_symbol (abfd);
4031 newsym->name = fh->elf.root.root.string + 1;
4032 newsym->section = bfd_und_section_ptr;
4033 newsym->value = 0;
908b32fc 4034 newsym->flags = BSF_WEAK;
bb700d78
AM		 4035
4036 bh = NULL;
4037 if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4038 newsym->flags, newsym->section,
4039 newsym->value, NULL, FALSE, FALSE,
4040 &bh))
4041 return NULL;
4042
4043 fdh = (struct ppc_link_hash_entry *) bh;
4044 fdh->elf.non_elf = 0;
908b32fc
AM		 4045 fdh->fake = 1;
4046 fdh->is_func_descriptor = 1;
4047 fdh->oh = fh;
4048 fh->is_func = 1;
4049 fh->oh = fdh;
bb700d78
AM		 4050 return fdh;
4051}
4052
8387904d
AM		 4053/* Hacks to support old ABI code.
4054 When making function calls, old ABI code references function entry
4055 points (dot symbols), while new ABI code references the function
4056 descriptor symbol. We need to make any combination of reference and
4057 definition work together, without breaking archive linking.
4058
4059 For a defined function "foo" and an undefined call to "bar":
4060 An old object defines "foo" and ".foo", references ".bar" (possibly
4061 "bar" too).
4062 A new object defines "foo" and references "bar".
4063
4064 A new object thus has no problem with its undefined symbols being
4065 satisfied by definitions in an old object. On the other hand, the
4066 old object won't have ".bar" satisfied by a new object. */
4067
4068/* Fix function descriptor symbols defined in .opd sections to be
4069 function type. */
555cd476
AM		 4070
4071static bfd_boolean
433817dd 4072ppc64_elf_add_symbol_hook (bfd *ibfd,
555cd476
AM		 4073 struct bfd_link_info *info ATTRIBUTE_UNUSED,
4074 Elf_Internal_Sym *isym,
433817dd 4075 const char **name,
555cd476
AM		 4076 flagword *flags ATTRIBUTE_UNUSED,
4077 asection **sec,
4078 bfd_vma *value ATTRIBUTE_UNUSED)
4079{
8843416a
AM		 4080 if (*sec != NULL
4081 && strcmp (bfd_get_section_name (ibfd, *sec), ".opd") == 0)
555cd476 4082 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
433817dd
AM		 4083
4084 if ((*name)[0] == '.'
4085 && ELF_ST_BIND (isym->st_info) == STB_GLOBAL
4086 && ELF_ST_TYPE (isym->st_info) < STT_SECTION
4087 && is_ppc64_elf_target (ibfd->xvec))
4088 ppc64_elf_tdata (ibfd)->u.has_dotsym = 1;
4089
555cd476
AM		 4090 return TRUE;
4091}
4092
8387904d 4093/* This function makes an old ABI object reference to ".bar" cause the
908b32fc
AM		 4094 inclusion of a new ABI object archive that defines "bar".
4095 NAME is a symbol defined in an archive. Return a symbol in the hash
4096 table that might be satisfied by the archive symbols. */
8387904d
AM		 4097
4098static struct elf_link_hash_entry *
4099ppc64_elf_archive_symbol_lookup (bfd *abfd,
4100 struct bfd_link_info *info,
4101 const char *name)
4102{
4103 struct elf_link_hash_entry *h;
4104 char *dot_name;
4105 size_t len;
4106
4107 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
908b32fc
AM		 4108 if (h != NULL
4109 /* Don't return this sym if it is a fake function descriptor
4110 created by add_symbol_adjust. */
4111 && !(h->root.type == bfd_link_hash_undefweak
4112 && ((struct ppc_link_hash_entry *) h)->fake))
8387904d
AM		 4113 return h;
4114
4115 if (name[0] == '.')
4116 return h;
4117
4118 len = strlen (name);
4119 dot_name = bfd_alloc (abfd, len + 2);
4120 if (dot_name == NULL)
4121 return (struct elf_link_hash_entry *) 0 - 1;
4122 dot_name[0] = '.';
4123 memcpy (dot_name + 1, name, len + 1);
4124 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4125 bfd_release (abfd, dot_name);
4126 return h;
4127}
4128
4129/* This function satisfies all old ABI object references to ".bar" if a
99877b66
AM		 4130 new ABI object defines "bar". Well, at least, undefined dot symbols
4131 are made weak. This stops later archive searches from including an
4132 object if we already have a function descriptor definition. It also
35b0ce59
AM		 4133 prevents the linker complaining about undefined symbols.
4134 We also check and correct mismatched symbol visibility here. The
4135 most restrictive visibility of the function descriptor and the
4136 function entry symbol is used. */
8387904d 4137
bb700d78
AM		 4138struct add_symbol_adjust_data
4139{
4140 struct bfd_link_info *info;
4141 bfd_boolean ok;
4142};
4143
8387904d
AM		 4144static bfd_boolean
4145add_symbol_adjust (struct elf_link_hash_entry *h, void *inf)
4146{
bb700d78 4147 struct add_symbol_adjust_data *data;
8387904d 4148 struct ppc_link_hash_table *htab;
99877b66 4149 struct ppc_link_hash_entry *eh;
8387904d
AM		 4150 struct ppc_link_hash_entry *fdh;
4151
4152 if (h->root.type == bfd_link_hash_indirect)
4153 return TRUE;
4154
4155 if (h->root.type == bfd_link_hash_warning)
4156 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4157
35b0ce59 4158 if (h->root.root.string[0] != '.')
8387904d
AM		 4159 return TRUE;
4160
bb700d78
AM		 4161 data = inf;
4162 htab = ppc_hash_table (data->info);
99877b66
AM		 4163 eh = (struct ppc_link_hash_entry *) h;
4164 fdh = get_fdh (eh, htab);
bb700d78 4165 if (fdh == NULL
c4f68ce3 4166 && !data->info->relocatable
bb700d78
AM		 4167 && (eh->elf.root.type == bfd_link_hash_undefined
4168 || eh->elf.root.type == bfd_link_hash_undefweak)
4169 && eh->elf.ref_regular)
4170 {
4171 /* Make an undefweak function descriptor sym, which is enough to
4172 pull in an --as-needed shared lib, but won't cause link
4173 errors. Archives are handled elsewhere. */
908b32fc 4174 fdh = make_fdh (data->info, eh);
bb700d78
AM		 4175 if (fdh == NULL)
4176 data->ok = FALSE;
4177 else
4178 fdh->elf.ref_regular = 1;
4179 }
e87d886e 4180 else if (fdh != NULL)
8387904d 4181 {
35b0ce59
AM		 4182 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4183 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4184 if (entry_vis < descr_vis)
4185 fdh->elf.other += entry_vis - descr_vis;
4186 else if (entry_vis > descr_vis)
4187 eh->elf.other += descr_vis - entry_vis;
4188
e87d886e
AM		 4189 if ((fdh->elf.root.type == bfd_link_hash_defined
4190 || fdh->elf.root.type == bfd_link_hash_defweak)
4191 && eh->elf.root.type == bfd_link_hash_undefined)
35b0ce59
AM		 4192 {
4193 eh->elf.root.type = bfd_link_hash_undefweak;
4194 eh->was_undefined = 1;
4195 htab->twiddled_syms = 1;
4196 }
8387904d 4197 }
99877b66 4198
8387904d
AM		 4199 return TRUE;
4200}
4201
4202static bfd_boolean
433817dd 4203ppc64_elf_check_directives (bfd *abfd, struct bfd_link_info *info)
8387904d 4204{
99877b66 4205 struct ppc_link_hash_table *htab;
bb700d78 4206 struct add_symbol_adjust_data data;
99877b66 4207
433817dd
AM		 4208 if (!is_ppc64_elf_target (abfd->xvec))
4209 return TRUE;
4210
4211 if (!ppc64_elf_tdata (abfd)->u.has_dotsym)
4212 return TRUE;
4213 ppc64_elf_tdata (abfd)->u.deleted_section = NULL;
4214
99877b66 4215 htab = ppc_hash_table (info);
ee75fd95 4216 if (!is_ppc64_elf_target (htab->elf.root.creator))
35b0ce59
AM		 4217 return TRUE;
4218
bb700d78
AM		 4219 data.info = info;
4220 data.ok = TRUE;
4221 elf_link_hash_traverse (&htab->elf, add_symbol_adjust, &data);
99877b66
AM		 4222
4223 /* We need to fix the undefs list for any syms we have twiddled to
4224 undef_weak. */
4225 if (htab->twiddled_syms)
4226 {
77cfaee6 4227 bfd_link_repair_undef_list (&htab->elf.root);
99877b66
AM		 4228 htab->twiddled_syms = 0;
4229 }
bb700d78 4230 return data.ok;
8387904d
AM		 4231}
4232
411e1bfb 4233static bfd_boolean
4ce794b7
AM		 4234update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
4235 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
411e1bfb
AM		 4236{
4237 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
e7b938ca 4238 char *local_got_tls_masks;
411e1bfb
AM		 4239
4240 if (local_got_ents == NULL)
4241 {
4242 bfd_size_type size = symtab_hdr->sh_info;
4243
e7b938ca 4244 size *= sizeof (*local_got_ents) + sizeof (*local_got_tls_masks);
4ce794b7 4245 local_got_ents = bfd_zalloc (abfd, size);
411e1bfb
AM		 4246 if (local_got_ents == NULL)
4247 return FALSE;
4248 elf_local_got_ents (abfd) = local_got_ents;
4249 }
4250
4251 if ((tls_type & TLS_EXPLICIT) == 0)
4252 {
4253 struct got_entry *ent;
4254
4255 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
e717da7e
AM		 4256 if (ent->addend == r_addend
4257 && ent->owner == abfd
4258 && ent->tls_type == tls_type)
411e1bfb
AM		 4259 break;
4260 if (ent == NULL)
4261 {
4262 bfd_size_type amt = sizeof (*ent);
4ce794b7 4263 ent = bfd_alloc (abfd, amt);
411e1bfb
AM		 4264 if (ent == NULL)
4265 return FALSE;
4266 ent->next = local_got_ents[r_symndx];
4267 ent->addend = r_addend;
e717da7e 4268 ent->owner = abfd;
411e1bfb
AM		 4269 ent->tls_type = tls_type;
4270 ent->got.refcount = 0;
4271 local_got_ents[r_symndx] = ent;
4272 }
4273 ent->got.refcount += 1;
4274 }
4275
e7b938ca
AM		 4276 local_got_tls_masks = (char *) (local_got_ents + symtab_hdr->sh_info);
4277 local_got_tls_masks[r_symndx] |= tls_type;
411e1bfb 4278 return TRUE;
65f38f15
AM		 4279}
4280
411e1bfb 4281static bfd_boolean
4ce794b7 4282update_plt_info (bfd *abfd, struct ppc_link_hash_entry *eh, bfd_vma addend)
1e2f5b6e 4283{
411e1bfb 4284 struct plt_entry *ent;
1e2f5b6e 4285
411e1bfb
AM		 4286 for (ent = eh->elf.plt.plist; ent != NULL; ent = ent->next)
4287 if (ent->addend == addend)
4288 break;
4289 if (ent == NULL)
1e2f5b6e 4290 {
411e1bfb 4291 bfd_size_type amt = sizeof (*ent);
4ce794b7 4292 ent = bfd_alloc (abfd, amt);
411e1bfb
AM		 4293 if (ent == NULL)
4294 return FALSE;
4295 ent->next = eh->elf.plt.plist;
4296 ent->addend = addend;
4297 ent->plt.refcount = 0;
4298 eh->elf.plt.plist = ent;
1e2f5b6e 4299 }
411e1bfb 4300 ent->plt.refcount += 1;
f5385ebf 4301 eh->elf.needs_plt = 1;
93f3fa99
AM		 4302 if (eh->elf.root.root.string[0] == '.'
4303 && eh->elf.root.root.string[1] != '\0')
4304 eh->is_func = 1;
b34976b6 4305 return TRUE;
1e2f5b6e
AM		 4306}
4307
5bd4f169 4308/* Look through the relocs for a section during the first phase, and
65f38f15 4309 calculate needed space in the global offset table, procedure
5d1634d7 4310 linkage table, and dynamic reloc sections. */
5bd4f169 4311
b34976b6 4312static bfd_boolean
4ce794b7
AM		 4313ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
4314 asection *sec, const Elf_Internal_Rela *relocs)
5bd4f169 4315{
65f38f15 4316 struct ppc_link_hash_table *htab;
5bd4f169
AM		 4317 Elf_Internal_Shdr *symtab_hdr;
4318 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
4319 const Elf_Internal_Rela *rel;
4320 const Elf_Internal_Rela *rel_end;
5bd4f169 4321 asection *sreloc;
1e2f5b6e 4322 asection **opd_sym_map;
5bd4f169 4323
1049f94e 4324 if (info->relocatable)
b34976b6 4325 return TRUE;
5bd4f169 4326
680a3378
AM		 4327 /* Don't do anything special with non-loaded, non-alloced sections.
4328 In particular, any relocs in such sections should not affect GOT
4329 and PLT reference counting (ie. we don't allow them to create GOT
4330 or PLT entries), there's no possibility or desire to optimize TLS
4331 relocs, and there's not much point in propagating relocs to shared
4332 libs that the dynamic linker won't relocate. */
4333 if ((sec->flags & SEC_ALLOC) == 0)
4334 return TRUE;
4335
65f38f15 4336 htab = ppc_hash_table (info);
5bd4f169 4337 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5bd4f169
AM		 4338
4339 sym_hashes = elf_sym_hashes (abfd);
4340 sym_hashes_end = (sym_hashes
1e2f5b6e
AM		 4341 + symtab_hdr->sh_size / sizeof (Elf64_External_Sym)
4342 - symtab_hdr->sh_info);
5bd4f169
AM		 4343
4344 sreloc = NULL;
1e2f5b6e
AM		 4345 opd_sym_map = NULL;
4346 if (strcmp (bfd_get_section_name (abfd, sec), ".opd") == 0)
4347 {
4348 /* Garbage collection needs some extra help with .opd sections.
4349 We don't want to necessarily keep everything referenced by
4350 relocs in .opd, as that would keep all functions. Instead,
4351 if we reference an .opd symbol (a function descriptor), we
4352 want to keep the function code symbol's section. This is
4353 easy for global symbols, but for local syms we need to keep
4354 information about the associated function section. Later, if
4355 edit_opd deletes entries, we'll use this array to adjust
4356 local syms in .opd. */
4357 union opd_info {
4358 asection *func_section;
4359 long entry_adjust;
4360 };
4361 bfd_size_type amt;
4362
3f764659 4363 amt = sec->size * sizeof (union opd_info) / 8;
4ce794b7 4364 opd_sym_map = bfd_zalloc (abfd, amt);
1e2f5b6e 4365 if (opd_sym_map == NULL)
b34976b6 4366 return FALSE;
f0abc2a1 4367 ppc64_elf_section_data (sec)->opd.func_sec = opd_sym_map;
1e2f5b6e 4368 }
5bd4f169 4369
82bd7b59
AM		 4370 if (htab->sfpr == NULL
4371 && !create_linkage_sections (htab->elf.dynobj, info))
b34976b6 4372 return FALSE;
82bd7b59 4373
5bd4f169
AM		 4374 rel_end = relocs + sec->reloc_count;
4375 for (rel = relocs; rel < rel_end; rel++)
4376 {
4377 unsigned long r_symndx;
4378 struct elf_link_hash_entry *h;
04c9666a 4379 enum elf_ppc64_reloc_type r_type;
411e1bfb 4380 int tls_type = 0;
5bd4f169
AM		 4381
4382 r_symndx = ELF64_R_SYM (rel->r_info);
4383 if (r_symndx < symtab_hdr->sh_info)
4384 h = NULL;
4385 else
973a3492
L		 4386 {
4387 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4388 while (h->root.type == bfd_link_hash_indirect
4389 || h->root.type == bfd_link_hash_warning)
4390 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4391 }
5bd4f169 4392
4ce794b7 4393 r_type = ELF64_R_TYPE (rel->r_info);
a33d1f77 4394 switch (r_type)
5bd4f169 4395 {
411e1bfb
AM		 4396 case R_PPC64_GOT_TLSLD16:
4397 case R_PPC64_GOT_TLSLD16_LO:
4398 case R_PPC64_GOT_TLSLD16_HI:
4399 case R_PPC64_GOT_TLSLD16_HA:
e717da7e 4400 ppc64_tlsld_got (abfd)->refcount += 1;
951fd09b 4401 tls_type = TLS_TLS | TLS_LD;
411e1bfb
AM		 4402 goto dogottls;
4403
4404 case R_PPC64_GOT_TLSGD16:
4405 case R_PPC64_GOT_TLSGD16_LO:
4406 case R_PPC64_GOT_TLSGD16_HI:
4407 case R_PPC64_GOT_TLSGD16_HA:
951fd09b 4408 tls_type = TLS_TLS | TLS_GD;
411e1bfb
AM		 4409 goto dogottls;
4410
4411 case R_PPC64_GOT_TPREL16_DS:
4412 case R_PPC64_GOT_TPREL16_LO_DS:
4413 case R_PPC64_GOT_TPREL16_HI:
4414 case R_PPC64_GOT_TPREL16_HA:
4415 if (info->shared)
4416 info->flags |= DF_STATIC_TLS;
4417 tls_type = TLS_TLS | TLS_TPREL;
4418 goto dogottls;
4419
4420 case R_PPC64_GOT_DTPREL16_DS:
4421 case R_PPC64_GOT_DTPREL16_LO_DS:
4422 case R_PPC64_GOT_DTPREL16_HI:
4423 case R_PPC64_GOT_DTPREL16_HA:
4424 tls_type = TLS_TLS | TLS_DTPREL;
4425 dogottls:
4426 sec->has_tls_reloc = 1;
4427 /* Fall thru */
4428
5bd4f169 4429 case R_PPC64_GOT16:
5bd4f169 4430 case R_PPC64_GOT16_DS:
65f38f15
AM		 4431 case R_PPC64_GOT16_HA:
4432 case R_PPC64_GOT16_HI:
4433 case R_PPC64_GOT16_LO:
5bd4f169 4434 case R_PPC64_GOT16_LO_DS:
65f38f15 4435 /* This symbol requires a global offset table entry. */
4c52953f 4436 sec->has_toc_reloc = 1;
e717da7e
AM		 4437 if (ppc64_elf_tdata (abfd)->got == NULL
4438 && !create_got_section (abfd, info))
b34976b6 4439 return FALSE;
5bd4f169
AM		 4440
4441 if (h != NULL)
4442 {
411e1bfb
AM		 4443 struct ppc_link_hash_entry *eh;
4444 struct got_entry *ent;
65f38f15 4445
411e1bfb
AM		 4446 eh = (struct ppc_link_hash_entry *) h;
4447 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
4448 if (ent->addend == rel->r_addend
e717da7e 4449 && ent->owner == abfd
411e1bfb
AM		 4450 && ent->tls_type == tls_type)
4451 break;
4452 if (ent == NULL)
5bd4f169 4453 {
411e1bfb 4454 bfd_size_type amt = sizeof (*ent);
4ce794b7 4455 ent = bfd_alloc (abfd, amt);
411e1bfb 4456 if (ent == NULL)
b34976b6 4457 return FALSE;
411e1bfb
AM		 4458 ent->next = eh->elf.got.glist;
4459 ent->addend = rel->r_addend;
e717da7e 4460 ent->owner = abfd;
411e1bfb
AM		 4461 ent->tls_type = tls_type;
4462 ent->got.refcount = 0;
4463 eh->elf.got.glist = ent;
5bd4f169 4464 }
411e1bfb 4465 ent->got.refcount += 1;
e7b938ca 4466 eh->tls_mask |= tls_type;
5bd4f169 4467 }
411e1bfb
AM		 4468 else
4469 /* This is a global offset table entry for a local symbol. */
4470 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
4471 rel->r_addend, tls_type))
4472 return FALSE;
5bd4f169
AM		 4473 break;
4474
5bd4f169 4475 case R_PPC64_PLT16_HA:
65f38f15
AM		 4476 case R_PPC64_PLT16_HI:
4477 case R_PPC64_PLT16_LO:
4478 case R_PPC64_PLT32:
4479 case R_PPC64_PLT64:
5bd4f169 4480 /* This symbol requires a procedure linkage table entry. We
3fad3c7c
AM		 4481 actually build the entry in adjust_dynamic_symbol,
4482 because this might be a case of linking PIC code without
4483 linking in any dynamic objects, in which case we don't
4484 need to generate a procedure linkage table after all. */
5bd4f169
AM		 4485 if (h == NULL)
4486 {
4487 /* It does not make sense to have a procedure linkage
3fad3c7c 4488 table entry for a local symbol. */
5bd4f169 4489 bfd_set_error (bfd_error_bad_value);
b34976b6 4490 return FALSE;
5bd4f169 4491 }
411e1bfb
AM		 4492 else
4493 if (!update_plt_info (abfd, (struct ppc_link_hash_entry *) h,
4494 rel->r_addend))
4495 return FALSE;
5bd4f169
AM		 4496 break;
4497
4498 /* The following relocations don't need to propagate the
4499 relocation if linking a shared object since they are
4500 section relative. */
4501 case R_PPC64_SECTOFF:
4502 case R_PPC64_SECTOFF_LO:
4503 case R_PPC64_SECTOFF_HI:
4504 case R_PPC64_SECTOFF_HA:
4505 case R_PPC64_SECTOFF_DS:
4506 case R_PPC64_SECTOFF_LO_DS:
411e1bfb
AM		 4507 case R_PPC64_DTPREL16:
4508 case R_PPC64_DTPREL16_LO:
4509 case R_PPC64_DTPREL16_HI:
4510 case R_PPC64_DTPREL16_HA:
4511 case R_PPC64_DTPREL16_DS:
4512 case R_PPC64_DTPREL16_LO_DS:
4513 case R_PPC64_DTPREL16_HIGHER:
4514 case R_PPC64_DTPREL16_HIGHERA:
4515 case R_PPC64_DTPREL16_HIGHEST:
4516 case R_PPC64_DTPREL16_HIGHESTA:
5bd4f169
AM		 4517 break;
4518
ad8e1ba5
AM		 4519 /* Nor do these. */
4520 case R_PPC64_TOC16:
4521 case R_PPC64_TOC16_LO:
4522 case R_PPC64_TOC16_HI:
4523 case R_PPC64_TOC16_HA:
4524 case R_PPC64_TOC16_DS:
4525 case R_PPC64_TOC16_LO_DS:
4c52953f 4526 sec->has_toc_reloc = 1;
ad8e1ba5
AM		 4527 break;
4528
5bd4f169
AM		 4529 /* This relocation describes the C++ object vtable hierarchy.
4530 Reconstruct it for later use during GC. */
4531 case R_PPC64_GNU_VTINHERIT:
c152c796 4532 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
b34976b6 4533 return FALSE;
5bd4f169
AM		 4534 break;
4535
4536 /* This relocation describes which C++ vtable entries are actually
4537 used. Record for later use during GC. */
4538 case R_PPC64_GNU_VTENTRY:
c152c796 4539 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
b34976b6 4540 return FALSE;
5bd4f169
AM		 4541 break;
4542
721956f4
AM		 4543 case R_PPC64_REL14:
4544 case R_PPC64_REL14_BRTAKEN:
4545 case R_PPC64_REL14_BRNTAKEN:
220c76dd
AM		 4546 {
4547 asection *dest = NULL;
4548
4549 /* Heuristic: If jumping outside our section, chances are
4550 we are going to need a stub. */
4551 if (h != NULL)
4552 {
4553 /* If the sym is weak it may be overridden later, so
4554 don't assume we know where a weak sym lives. */
4555 if (h->root.type == bfd_link_hash_defined)
4556 dest = h->root.u.def.section;
4557 }
4558 else
4559 dest = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
4560 sec, r_symndx);
4561 if (dest != sec)
4562 htab->has_14bit_branch = 1;
4563 }
721956f4
AM		 4564 /* Fall through. */
4565
5d1634d7 4566 case R_PPC64_REL24:
8387904d 4567 if (h != NULL)
5d1634d7
AM		 4568 {
4569 /* We may need a .plt entry if the function this reloc
4570 refers to is in a shared lib. */
411e1bfb
AM		 4571 if (!update_plt_info (abfd, (struct ppc_link_hash_entry *) h,
4572 rel->r_addend))
4573 return FALSE;
8387904d
AM		 4574 if (h == &htab->tls_get_addr->elf
4575 || h == &htab->tls_get_addr_fd->elf)
411e1bfb 4576 sec->has_tls_reloc = 1;
8387904d
AM		 4577 else if (htab->tls_get_addr == NULL
4578 && !strncmp (h->root.root.string, ".__tls_get_addr", 15)
a48ebf4d
AM		 4579 && (h->root.root.string[15] == 0
4580 || h->root.root.string[15] == '@'))
411e1bfb 4581 {
8387904d
AM		 4582 htab->tls_get_addr = (struct ppc_link_hash_entry *) h;
4583 sec->has_tls_reloc = 1;
4584 }
4585 else if (htab->tls_get_addr_fd == NULL
4586 && !strncmp (h->root.root.string, "__tls_get_addr", 14)
4587 && (h->root.root.string[14] == 0
4588 || h->root.root.string[14] == '@'))
4589 {
4590 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) h;
411e1bfb
AM		 4591 sec->has_tls_reloc = 1;
4592 }
4593 }
4594 break;
4595
4596 case R_PPC64_TPREL64:
4597 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
4598 if (info->shared)
4599 info->flags |= DF_STATIC_TLS;
4600 goto dotlstoc;
4601
4602 case R_PPC64_DTPMOD64:
4603 if (rel + 1 < rel_end
4604 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
4605 && rel[1].r_offset == rel->r_offset + 8)
951fd09b 4606 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
411e1bfb 4607 else
951fd09b 4608 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
411e1bfb
AM		 4609 goto dotlstoc;
4610
4611 case R_PPC64_DTPREL64:
4612 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
4613 if (rel != relocs
4614 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
4615 && rel[-1].r_offset == rel->r_offset - 8)
4616 /* This is the second reloc of a dtpmod, dtprel pair.
4617 Don't mark with TLS_DTPREL. */
4618 goto dodyn;
4619
4620 dotlstoc:
4621 sec->has_tls_reloc = 1;
4622 if (h != NULL)
4623 {
4624 struct ppc_link_hash_entry *eh;
4625 eh = (struct ppc_link_hash_entry *) h;
e7b938ca 4626 eh->tls_mask |= tls_type;
411e1bfb
AM		 4627 }
4628 else
4629 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
4630 rel->r_addend, tls_type))
4631 return FALSE;
4632
4633 if (ppc64_elf_section_data (sec)->t_symndx == NULL)
4634 {
e7b938ca 4635 /* One extra to simplify get_tls_mask. */
eea6121a 4636 bfd_size_type amt = sec->size * sizeof (unsigned) / 8 + 1;
4ce794b7 4637 ppc64_elf_section_data (sec)->t_symndx = bfd_zalloc (abfd, amt);
411e1bfb
AM		 4638 if (ppc64_elf_section_data (sec)->t_symndx == NULL)
4639 return FALSE;
4640 }
4641 BFD_ASSERT (rel->r_offset % 8 == 0);
4642 ppc64_elf_section_data (sec)->t_symndx[rel->r_offset / 8] = r_symndx;
951fd09b
AM		 4643
4644 /* Mark the second slot of a GD or LD entry.
4645 -1 to indicate GD and -2 to indicate LD. */
4646 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
4647 ppc64_elf_section_data (sec)->t_symndx[rel->r_offset / 8 + 1] = -1;
4648 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
4649 ppc64_elf_section_data (sec)->t_symndx[rel->r_offset / 8 + 1] = -2;
411e1bfb
AM		 4650 goto dodyn;
4651
4652 case R_PPC64_TPREL16:
4653 case R_PPC64_TPREL16_LO:
4654 case R_PPC64_TPREL16_HI:
4655 case R_PPC64_TPREL16_HA:
4656 case R_PPC64_TPREL16_DS:
4657 case R_PPC64_TPREL16_LO_DS:
4658 case R_PPC64_TPREL16_HIGHER:
4659 case R_PPC64_TPREL16_HIGHERA:
4660 case R_PPC64_TPREL16_HIGHEST:
4661 case R_PPC64_TPREL16_HIGHESTA:
4662 if (info->shared)
4663 {
4664 info->flags |= DF_STATIC_TLS;
4665 goto dodyn;
5d1634d7
AM		 4666 }
4667 break;
4668
e86ce104 4669 case R_PPC64_ADDR64:
1e2f5b6e 4670 if (opd_sym_map != NULL
1e2f5b6e 4671 && rel + 1 < rel_end
4ce794b7 4672 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
1e2f5b6e 4673 {
8387904d
AM		 4674 if (h != NULL)
4675 {
4676 if (h->root.root.string[0] == '.'
4677 && h->root.root.string[1] != 0
4678 && get_fdh ((struct ppc_link_hash_entry *) h, htab))
4679 ;
4680 else
4681 ((struct ppc_link_hash_entry *) h)->is_func = 1;
4682 }
4683 else
4684 {
4685 asection *s;
1e2f5b6e 4686
8387904d
AM		 4687 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec, sec,
4688 r_symndx);
4689 if (s == NULL)
4690 return FALSE;
4691 else if (s != sec)
3f764659 4692 opd_sym_map[rel->r_offset / 8] = s;
8387904d 4693 }
1e2f5b6e 4694 }
e86ce104
AM		 4695 /* Fall through. */
4696
04c9666a 4697 case R_PPC64_REL30:
5bd4f169 4698 case R_PPC64_REL32:
04c9666a 4699 case R_PPC64_REL64:
65f38f15
AM		 4700 case R_PPC64_ADDR14:
4701 case R_PPC64_ADDR14_BRNTAKEN:
4702 case R_PPC64_ADDR14_BRTAKEN:
4703 case R_PPC64_ADDR16:
4704 case R_PPC64_ADDR16_DS:
4705 case R_PPC64_ADDR16_HA:
4706 case R_PPC64_ADDR16_HI:
4707 case R_PPC64_ADDR16_HIGHER:
4708 case R_PPC64_ADDR16_HIGHERA:
4709 case R_PPC64_ADDR16_HIGHEST:
4710 case R_PPC64_ADDR16_HIGHESTA:
4711 case R_PPC64_ADDR16_LO:
4712 case R_PPC64_ADDR16_LO_DS:
4713 case R_PPC64_ADDR24:
65f38f15 4714 case R_PPC64_ADDR32:
65f38f15
AM		 4715 case R_PPC64_UADDR16:
4716 case R_PPC64_UADDR32:
4717 case R_PPC64_UADDR64:
5bd4f169 4718 case R_PPC64_TOC:
81848ca0
AM		 4719 if (h != NULL && !info->shared)
4720 /* We may need a copy reloc. */
f5385ebf 4721 h->non_got_ref = 1;
81848ca0 4722
41bd81ab 4723 /* Don't propagate .opd relocs. */
1e2f5b6e 4724 if (NO_OPD_RELOCS && opd_sym_map != NULL)
e86ce104 4725 break;
e86ce104 4726
65f38f15
AM		 4727 /* If we are creating a shared library, and this is a reloc
4728 against a global symbol, or a non PC relative reloc
4729 against a local symbol, then we need to copy the reloc
4730 into the shared library. However, if we are linking with
4731 -Bsymbolic, we do not need to copy a reloc against a
4732 global symbol which is defined in an object we are
4733 including in the link (i.e., DEF_REGULAR is set). At
4734 this point we have not seen all the input files, so it is
4735 possible that DEF_REGULAR is not set now but will be set
4736 later (it is never cleared). In case of a weak definition,
4737 DEF_REGULAR may be cleared later by a strong definition in
4738 a shared library. We account for that possibility below by
f4656909 4739 storing information in the dyn_relocs field of the hash
65f38f15
AM		 4740 table entry. A similar situation occurs when creating
4741 shared libraries and symbol visibility changes render the
4742 symbol local.
4743
4744 If on the other hand, we are creating an executable, we
4745 may need to keep relocations for symbols satisfied by a
4746 dynamic library if we manage to avoid copy relocs for the
4747 symbol. */
411e1bfb 4748 dodyn:
65f38f15 4749 if ((info->shared
411e1bfb 4750 && (MUST_BE_DYN_RELOC (r_type)
65f38f15
AM		 4751 || (h != NULL
4752 && (! info->symbolic
4753 || h->root.type == bfd_link_hash_defweak
f5385ebf 4754 || !h->def_regular))))
f4656909
AM		 4755 || (ELIMINATE_COPY_RELOCS
4756 && !info->shared
65f38f15
AM		 4757 && h != NULL
4758 && (h->root.type == bfd_link_hash_defweak
f5385ebf 4759 || !h->def_regular)))
5bd4f169 4760 {
ec338859
AM		 4761 struct ppc_dyn_relocs *p;
4762 struct ppc_dyn_relocs **head;
4763
65f38f15
AM		 4764 /* We must copy these reloc types into the output file.
4765 Create a reloc section in dynobj and make room for
4766 this reloc. */
5bd4f169
AM		 4767 if (sreloc == NULL)
4768 {
4769 const char *name;
65f38f15 4770 bfd *dynobj;
5bd4f169
AM		 4771
4772 name = (bfd_elf_string_from_elf_section
4773 (abfd,
4774 elf_elfheader (abfd)->e_shstrndx,
4775 elf_section_data (sec)->rel_hdr.sh_name));
4776 if (name == NULL)
b34976b6 4777 return FALSE;
5bd4f169 4778
65f38f15
AM		 4779 if (strncmp (name, ".rela", 5) != 0
4780 || strcmp (bfd_get_section_name (abfd, sec),
4781 name + 5) != 0)
4782 {
4783 (*_bfd_error_handler)
d003868e
AM		 4784 (_("%B: bad relocation section name `%s\'"),
4785 abfd, name);
5d1634d7 4786 bfd_set_error (bfd_error_bad_value);
65f38f15
AM		 4787 }
4788
65f38f15 4789 dynobj = htab->elf.dynobj;
5bd4f169
AM		 4790 sreloc = bfd_get_section_by_name (dynobj, name);
4791 if (sreloc == NULL)
4792 {
4793 flagword flags;
4794
5bd4f169 4795 flags = (SEC_HAS_CONTENTS | SEC_READONLY
77623a34
AM		 4796 | SEC_IN_MEMORY | SEC_LINKER_CREATED
4797 | SEC_ALLOC | SEC_LOAD);
3496cb2a
L		 4798 sreloc = bfd_make_section_with_flags (dynobj,
4799 name,
4800 flags);
5bd4f169 4801 if (sreloc == NULL
65f38f15 4802 || ! bfd_set_section_alignment (dynobj, sreloc, 3))
b34976b6 4803 return FALSE;
5bd4f169 4804 }
65f38f15 4805 elf_section_data (sec)->sreloc = sreloc;
5bd4f169
AM		 4806 }
4807
65f38f15
AM		 4808 /* If this is a global symbol, we count the number of
4809 relocations we need for this symbol. */
4810 if (h != NULL)
4811 {
ec338859 4812 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
65f38f15
AM		 4813 }
4814 else
4815 {
ec338859
AM		 4816 /* Track dynamic relocs needed for local syms too.
4817 We really need local syms available to do this
4818 easily. Oh well. */
4819
4820 asection *s;
6edfbbad
DJ		 4821 void *vpp;
4822
ec338859
AM		 4823 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
4824 sec, r_symndx);
4825 if (s == NULL)
b34976b6 4826 return FALSE;
ec338859 4827
6edfbbad
DJ		 4828 vpp = &elf_section_data (s)->local_dynrel;
4829 head = (struct ppc_dyn_relocs **) vpp;
65f38f15 4830 }
ec338859
AM		 4831
4832 p = *head;
4833 if (p == NULL || p->sec != sec)
4834 {
4ce794b7 4835 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
ec338859 4836 if (p == NULL)
b34976b6 4837 return FALSE;
ec338859
AM		 4838 p->next = *head;
4839 *head = p;
4840 p->sec = sec;
4841 p->count = 0;
4842 p->pc_count = 0;
4843 }
4844
4845 p->count += 1;
411e1bfb 4846 if (!MUST_BE_DYN_RELOC (r_type))
ec338859 4847 p->pc_count += 1;
65f38f15 4848 }
5bd4f169 4849 break;
65f38f15
AM		 4850
4851 default:
96e0dda4 4852 break;
5bd4f169
AM		 4853 }
4854 }
4855
b34976b6 4856 return TRUE;
5bd4f169
AM		 4857}
4858
8387904d
AM		 4859/* OFFSET in OPD_SEC specifies a function descriptor. Return the address
4860 of the code entry point, and its section. */
4861
4862static bfd_vma
4863opd_entry_value (asection *opd_sec,
4864 bfd_vma offset,
4865 asection **code_sec,
4866 bfd_vma *code_off)
4867{
4868 bfd *opd_bfd = opd_sec->owner;
8860955f 4869 Elf_Internal_Rela *relocs;
8387904d 4870 Elf_Internal_Rela *lo, *hi, *look;
645ea6a9 4871 bfd_vma val;
8387904d 4872
4b85d634
AM		 4873 /* No relocs implies we are linking a --just-symbols object. */
4874 if (opd_sec->reloc_count == 0)
4875 {
4876 bfd_vma val;
4877
4878 if (!bfd_get_section_contents (opd_bfd, opd_sec, &val, offset, 8))
4879 return (bfd_vma) -1;
3b36f7e6 4880
4b85d634
AM		 4881 if (code_sec != NULL)
4882 {
4883 asection *sec, *likely = NULL;
4884 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
4885 if (sec->vma <= val
4886 && (sec->flags & SEC_LOAD) != 0
4887 && (sec->flags & SEC_ALLOC) != 0)
4888 likely = sec;
4889 if (likely != NULL)
4890 {
4891 *code_sec = likely;
4892 if (code_off != NULL)
4893 *code_off = val - likely->vma;
4894 }
4895 }
4896 return val;
4897 }
4898
8860955f
AM		 4899 relocs = ppc64_elf_tdata (opd_bfd)->opd_relocs;
4900 if (relocs == NULL)
4901 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
645ea6a9 4902
8387904d 4903 /* Go find the opd reloc at the sym address. */
8860955f 4904 lo = relocs;
8387904d
AM		 4905 BFD_ASSERT (lo != NULL);
4906 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
645ea6a9 4907 val = (bfd_vma) -1;
8387904d
AM		 4908 while (lo < hi)
4909 {
4910 look = lo + (hi - lo) / 2;
4911 if (look->r_offset < offset)
4912 lo = look + 1;
4913 else if (look->r_offset > offset)
4914 hi = look;
4915 else
4916 {
4917 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (opd_bfd)->symtab_hdr;
4918 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
4919 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
4920 {
4921 unsigned long symndx = ELF64_R_SYM (look->r_info);
8387904d
AM		 4922 asection *sec;
4923
4924 if (symndx < symtab_hdr->sh_info)
4925 {
4926 Elf_Internal_Sym *sym;
4927
4928 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
4929 if (sym == NULL)
4930 {
4931 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
4932 symtab_hdr->sh_info,
4933 0, NULL, NULL, NULL);
4934 if (sym == NULL)
645ea6a9 4935 break;
8387904d
AM		 4936 symtab_hdr->contents = (bfd_byte *) sym;
4937 }
4938
4939 sym += symndx;
4940 val = sym->st_value;
4941 sec = NULL;
4942 if ((sym->st_shndx != SHN_UNDEF
4943 && sym->st_shndx < SHN_LORESERVE)
4944 || sym->st_shndx > SHN_HIRESERVE)
4945 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
4946 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
4947 }
4948 else
4949 {
4950 struct elf_link_hash_entry **sym_hashes;
4951 struct elf_link_hash_entry *rh;
4952
4953 sym_hashes = elf_sym_hashes (opd_bfd);
4954 rh = sym_hashes[symndx - symtab_hdr->sh_info];
4955 while (rh->root.type == bfd_link_hash_indirect
4956 || rh->root.type == bfd_link_hash_warning)
4957 rh = ((struct elf_link_hash_entry *) rh->root.u.i.link);
4958 BFD_ASSERT (rh->root.type == bfd_link_hash_defined
4959 || rh->root.type == bfd_link_hash_defweak);
4960 val = rh->root.u.def.value;
4961 sec = rh->root.u.def.section;
4962 }
4963 val += look->r_addend;
4964 if (code_off != NULL)
4965 *code_off = val;
4966 if (code_sec != NULL)
4967 *code_sec = sec;
4968 if (sec != NULL && sec->output_section != NULL)
4969 val += sec->output_section->vma + sec->output_offset;
8387904d
AM		 4970 }
4971 break;
4972 }
4973 }
645ea6a9 4974
645ea6a9 4975 return val;
8387904d
AM		 4976}
4977
64d03ab5
AM		 4978/* Mark sections containing dynamically referenced symbols. When
4979 building shared libraries, we must assume that any visible symbol is
4980 referenced. */
4981
4982static bfd_boolean
4983ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
4984{
4985 struct bfd_link_info *info = (struct bfd_link_info *) inf;
4986 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
4987
4988 if (eh->elf.root.type == bfd_link_hash_warning)
4989 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4990
4991 /* Dynamic linking info is on the func descriptor sym. */
4992 if (eh->oh != NULL
4993 && eh->oh->is_func_descriptor
4994 && (eh->oh->elf.root.type == bfd_link_hash_defined
4995 || eh->oh->elf.root.type == bfd_link_hash_defweak))
4996 eh = eh->oh;
4997
4998 if ((eh->elf.root.type == bfd_link_hash_defined
4999 || eh->elf.root.type == bfd_link_hash_defweak)
5000 && (eh->elf.ref_dynamic
5001 || (!info->executable
5002 && eh->elf.def_regular
5003 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
5004 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN)))
5005 {
5006 asection *code_sec;
5007
5008 eh->elf.root.u.def.section->flags |= SEC_KEEP;
5009
5010 /* Function descriptor syms cause the associated
5011 function code sym section to be marked. */
5012 if (eh->is_func_descriptor
5013 && (eh->oh->elf.root.type == bfd_link_hash_defined
5014 || eh->oh->elf.root.type == bfd_link_hash_defweak))
5015 eh->oh->elf.root.u.def.section->flags |= SEC_KEEP;
5016 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5017 && opd_entry_value (eh->elf.root.u.def.section,
5018 eh->elf.root.u.def.value,
5019 &code_sec, NULL) != (bfd_vma) -1)
5020 code_sec->flags |= SEC_KEEP;
5021 }
5022
5023 return TRUE;
5024}
5025
5bd4f169
AM		 5026/* Return the section that should be marked against GC for a given
5027 relocation. */
5028
5029static asection *
4ce794b7 5030ppc64_elf_gc_mark_hook (asection *sec,
ccfa59ea 5031 struct bfd_link_info *info,
4ce794b7
AM		 5032 Elf_Internal_Rela *rel,
5033 struct elf_link_hash_entry *h,
5034 Elf_Internal_Sym *sym)
5bd4f169 5035{
ccfa59ea
AM		 5036 asection *rsec;
5037
5038 /* First mark all our entry sym sections. */
5039 if (info->gc_sym_list != NULL)
5040 {
5041 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5042 struct bfd_sym_chain *sym = info->gc_sym_list;
5043
5044 info->gc_sym_list = NULL;
b56cbdb9 5045 for (; sym != NULL; sym = sym->next)
ccfa59ea
AM		 5046 {
5047 struct ppc_link_hash_entry *eh;
5048
5049 eh = (struct ppc_link_hash_entry *)
5050 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, FALSE);
5051 if (eh == NULL)
5052 continue;
5053 if (eh->elf.root.type != bfd_link_hash_defined
5054 && eh->elf.root.type != bfd_link_hash_defweak)
5055 continue;
5056
c4f68ce3
AM		 5057 if (eh->is_func_descriptor
5058 && (eh->oh->elf.root.type == bfd_link_hash_defined
5059 || eh->oh->elf.root.type == bfd_link_hash_defweak))
ccfa59ea 5060 rsec = eh->oh->elf.root.u.def.section;
8387904d
AM		 5061 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5062 && opd_entry_value (eh->elf.root.u.def.section,
5063 eh->elf.root.u.def.value,
5064 &rsec, NULL) != (bfd_vma) -1)
5065 ;
ccfa59ea
AM		 5066 else
5067 continue;
5068
5069 if (!rsec->gc_mark)
5070 _bfd_elf_gc_mark (info, rsec, ppc64_elf_gc_mark_hook);
5071
5072 rsec = eh->elf.root.u.def.section;
5073 if (!rsec->gc_mark)
5074 _bfd_elf_gc_mark (info, rsec, ppc64_elf_gc_mark_hook);
ccfa59ea 5075 }
ccfa59ea
AM		 5076 }
5077
5078 /* Syms return NULL if we're marking .opd, so we avoid marking all
5079 function sections, as all functions are referenced in .opd. */
5080 rsec = NULL;
5081 if (get_opd_info (sec) != NULL)
5082 return rsec;
1e2f5b6e 5083
5bd4f169
AM		 5084 if (h != NULL)
5085 {
04c9666a 5086 enum elf_ppc64_reloc_type r_type;
ccfa59ea 5087 struct ppc_link_hash_entry *eh;
a33d1f77 5088
4ce794b7 5089 r_type = ELF64_R_TYPE (rel->r_info);
a33d1f77 5090 switch (r_type)
5bd4f169
AM		 5091 {
5092 case R_PPC64_GNU_VTINHERIT:
5093 case R_PPC64_GNU_VTENTRY:
5094 break;
5095
5096 default:
5097 switch (h->root.type)
5098 {
5099 case bfd_link_hash_defined:
5100 case bfd_link_hash_defweak:
ccfa59ea 5101 eh = (struct ppc_link_hash_entry *) h;
c4f68ce3
AM		 5102 if (eh->oh != NULL
5103 && eh->oh->is_func_descriptor
5104 && (eh->oh->elf.root.type == bfd_link_hash_defined
5105 || eh->oh->elf.root.type == bfd_link_hash_defweak))
ccfa59ea 5106 eh = eh->oh;
1e2f5b6e
AM		 5107
5108 /* Function descriptor syms cause the associated
5109 function code sym section to be marked. */
c4f68ce3
AM		 5110 if (eh->is_func_descriptor
5111 && (eh->oh->elf.root.type == bfd_link_hash_defined
5112 || eh->oh->elf.root.type == bfd_link_hash_defweak))
ccfa59ea
AM		 5113 {
5114 /* They also mark their opd section. */
5115 if (!eh->elf.root.u.def.section->gc_mark)
5116 _bfd_elf_gc_mark (info, eh->elf.root.u.def.section,
5117 ppc64_elf_gc_mark_hook);
5118
5119 rsec = eh->oh->elf.root.u.def.section;
5120 }
8387904d
AM		 5121 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5122 && opd_entry_value (eh->elf.root.u.def.section,
5123 eh->elf.root.u.def.value,
5124 &rsec, NULL) != (bfd_vma) -1)
5125 {
5126 if (!eh->elf.root.u.def.section->gc_mark)
5127 _bfd_elf_gc_mark (info, eh->elf.root.u.def.section,
5128 ppc64_elf_gc_mark_hook);
5129 }
ccfa59ea 5130 else
1e2f5b6e
AM		 5131 rsec = h->root.u.def.section;
5132 break;
5bd4f169
AM		 5133
5134 case bfd_link_hash_common:
1e2f5b6e
AM		 5135 rsec = h->root.u.c.p->section;
5136 break;
5bd4f169
AM		 5137
5138 default:
5139 break;
5140 }
5141 }
5142 }
5143 else
5144 {
1e2f5b6e
AM		 5145 asection **opd_sym_section;
5146
5147 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
ccfa59ea 5148 opd_sym_section = get_opd_info (rsec);
1e2f5b6e 5149 if (opd_sym_section != NULL)
ccfa59ea
AM		 5150 {
5151 if (!rsec->gc_mark)
5152 _bfd_elf_gc_mark (info, rsec, ppc64_elf_gc_mark_hook);
5153
b4f4e59f 5154 rsec = opd_sym_section[(sym->st_value + rel->r_addend) / 8];
ccfa59ea 5155 }
5bd4f169
AM		 5156 }
5157
1e2f5b6e 5158 return rsec;
5bd4f169
AM		 5159}
5160
65f38f15
AM		 5161/* Update the .got, .plt. and dynamic reloc reference counts for the
5162 section being removed. */
5bd4f169 5163
b34976b6 5164static bfd_boolean
4ce794b7
AM		 5165ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
5166 asection *sec, const Elf_Internal_Rela *relocs)
5bd4f169 5167{
411e1bfb 5168 struct ppc_link_hash_table *htab;
5bd4f169
AM		 5169 Elf_Internal_Shdr *symtab_hdr;
5170 struct elf_link_hash_entry **sym_hashes;
411e1bfb 5171 struct got_entry **local_got_ents;
5bd4f169 5172 const Elf_Internal_Rela *rel, *relend;
5bd4f169 5173
680a3378
AM		 5174 if ((sec->flags & SEC_ALLOC) == 0)
5175 return TRUE;
5176
ec338859
AM		 5177 elf_section_data (sec)->local_dynrel = NULL;
5178
411e1bfb 5179 htab = ppc_hash_table (info);
5bd4f169
AM		 5180 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5181 sym_hashes = elf_sym_hashes (abfd);
411e1bfb 5182 local_got_ents = elf_local_got_ents (abfd);
5bd4f169
AM		 5183
5184 relend = relocs + sec->reloc_count;
5185 for (rel = relocs; rel < relend; rel++)
a33d1f77
AM		 5186 {
5187 unsigned long r_symndx;
04c9666a 5188 enum elf_ppc64_reloc_type r_type;
58ac9f71 5189 struct elf_link_hash_entry *h = NULL;
411e1bfb 5190 char tls_type = 0;
5bd4f169 5191
a33d1f77 5192 r_symndx = ELF64_R_SYM (rel->r_info);
4ce794b7 5193 r_type = ELF64_R_TYPE (rel->r_info);
58ac9f71
AM		 5194 if (r_symndx >= symtab_hdr->sh_info)
5195 {
5196 struct ppc_link_hash_entry *eh;
5197 struct ppc_dyn_relocs **pp;
5198 struct ppc_dyn_relocs *p;
5199
5200 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3eb128b2
AM		 5201 while (h->root.type == bfd_link_hash_indirect
5202 || h->root.type == bfd_link_hash_warning)
5203 h = (struct elf_link_hash_entry *) h->root.u.i.link;
58ac9f71
AM		 5204 eh = (struct ppc_link_hash_entry *) h;
5205
5206 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
5207 if (p->sec == sec)
5208 {
5209 /* Everything must go for SEC. */
5210 *pp = p->next;
5211 break;
5212 }
5213 }
5214
a33d1f77
AM		 5215 switch (r_type)
5216 {
411e1bfb
AM		 5217 case R_PPC64_GOT_TLSLD16:
5218 case R_PPC64_GOT_TLSLD16_LO:
5219 case R_PPC64_GOT_TLSLD16_HI:
5220 case R_PPC64_GOT_TLSLD16_HA:
e717da7e 5221 ppc64_tlsld_got (abfd)->refcount -= 1;
951fd09b 5222 tls_type = TLS_TLS | TLS_LD;
411e1bfb
AM		 5223 goto dogot;
5224
5225 case R_PPC64_GOT_TLSGD16:
5226 case R_PPC64_GOT_TLSGD16_LO:
5227 case R_PPC64_GOT_TLSGD16_HI:
5228 case R_PPC64_GOT_TLSGD16_HA:
951fd09b 5229 tls_type = TLS_TLS | TLS_GD;
411e1bfb
AM		 5230 goto dogot;
5231
5232 case R_PPC64_GOT_TPREL16_DS:
5233 case R_PPC64_GOT_TPREL16_LO_DS:
5234 case R_PPC64_GOT_TPREL16_HI:
5235 case R_PPC64_GOT_TPREL16_HA:
5236 tls_type = TLS_TLS | TLS_TPREL;
5237 goto dogot;
5238
5239 case R_PPC64_GOT_DTPREL16_DS:
5240 case R_PPC64_GOT_DTPREL16_LO_DS:
5241 case R_PPC64_GOT_DTPREL16_HI:
5242 case R_PPC64_GOT_DTPREL16_HA:
5243 tls_type = TLS_TLS | TLS_DTPREL;
5244 goto dogot;
5245
a33d1f77
AM		 5246 case R_PPC64_GOT16:
5247 case R_PPC64_GOT16_DS:
5248 case R_PPC64_GOT16_HA:
5249 case R_PPC64_GOT16_HI:
5250 case R_PPC64_GOT16_LO:
5251 case R_PPC64_GOT16_LO_DS:
411e1bfb
AM		 5252 dogot:
5253 {
5254 struct got_entry *ent;
5255
58ac9f71
AM		 5256 if (h != NULL)
5257 ent = h->got.glist;
411e1bfb
AM		 5258 else
5259 ent = local_got_ents[r_symndx];
5260
5261 for (; ent != NULL; ent = ent->next)
5262 if (ent->addend == rel->r_addend
e717da7e 5263 && ent->owner == abfd
411e1bfb
AM		 5264 && ent->tls_type == tls_type)
5265 break;
5266 if (ent == NULL)
5267 abort ();
5268 if (ent->got.refcount > 0)
5269 ent->got.refcount -= 1;
5270 }
a33d1f77 5271 break;
65f38f15 5272
a33d1f77
AM		 5273 case R_PPC64_PLT16_HA:
5274 case R_PPC64_PLT16_HI:
5275 case R_PPC64_PLT16_LO:
5276 case R_PPC64_PLT32:
5277 case R_PPC64_PLT64:
721956f4
AM		 5278 case R_PPC64_REL14:
5279 case R_PPC64_REL14_BRNTAKEN:
5280 case R_PPC64_REL14_BRTAKEN:
5d1634d7 5281 case R_PPC64_REL24:
58ac9f71 5282 if (h != NULL)
5d1634d7 5283 {
411e1bfb
AM		 5284 struct plt_entry *ent;
5285
411e1bfb
AM		 5286 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5287 if (ent->addend == rel->r_addend)
5288 break;
5289 if (ent == NULL)
5290 abort ();
5291 if (ent->plt.refcount > 0)
5292 ent->plt.refcount -= 1;
5d1634d7 5293 }
e86ce104 5294 break;
5d1634d7 5295
a33d1f77
AM		 5296 default:
5297 break;
5298 }
5299 }
b34976b6 5300 return TRUE;
5bd4f169
AM		 5301}
5302
deb0e272
AM		 5303/* The maximum size of .sfpr. */
5304#define SFPR_MAX (218*4)
5305
5306struct sfpr_def_parms
5307{
699733f6
AM		 5308 const char name[12];
5309 unsigned char lo, hi;
deb0e272
AM		 5310 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
5311 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
5312};
5313
5314/* Auto-generate _save*, _rest* functions in .sfpr. */
5315
5316static unsigned int
5317sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
5318{
5319 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5320 unsigned int i;
5321 size_t len = strlen (parm->name);
5322 bfd_boolean writing = FALSE;
699733f6 5323 char sym[16];
deb0e272
AM		 5324
5325 memcpy (sym, parm->name, len);
5326 sym[len + 2] = 0;
5327
5328 for (i = parm->lo; i <= parm->hi; i++)
5329 {
5330 struct elf_link_hash_entry *h;
5331
5332 sym[len + 0] = i / 10 + '0';
5333 sym[len + 1] = i % 10 + '0';
5334 h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
5335 if (h != NULL
f5385ebf 5336 && !h->def_regular)
deb0e272
AM		 5337 {
5338 h->root.type = bfd_link_hash_defined;
5339 h->root.u.def.section = htab->sfpr;
5340 h->root.u.def.value = htab->sfpr->size;
5341 h->type = STT_FUNC;
f5385ebf 5342 h->def_regular = 1;
deb0e272
AM		 5343 _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
5344 writing = TRUE;
5345 if (htab->sfpr->contents == NULL)
5346 {
5347 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
5348 if (htab->sfpr->contents == NULL)
5349 return FALSE;
5350 }
5351 }
5352 if (writing)
5353 {
5354 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
5355 if (i != parm->hi)
5356 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
5357 else
5358 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
5359 htab->sfpr->size = p - htab->sfpr->contents;
5360 }
5361 }
5362
5363 return TRUE;
5364}
5365
5366static bfd_byte *
5367savegpr0 (bfd *abfd, bfd_byte *p, int r)
5368{
5369 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5370 return p + 4;
5371}
5372
5373static bfd_byte *
5374savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
5375{
5376 p = savegpr0 (abfd, p, r);
5377 bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
5378 p = p + 4;
5379 bfd_put_32 (abfd, BLR, p);
5380 return p + 4;
5381}
5382
5383static bfd_byte *
5384restgpr0 (bfd *abfd, bfd_byte *p, int r)
5385{
5386 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5387 return p + 4;
5388}
5389
5390static bfd_byte *
5391restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
5392{
5393 bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
5394 p = p + 4;
5395 p = restgpr0 (abfd, p, r);
5396 bfd_put_32 (abfd, MTLR_R0, p);
5397 p = p + 4;
5398 if (r == 29)
5399 {
5400 p = restgpr0 (abfd, p, 30);
5401 p = restgpr0 (abfd, p, 31);
5402 }
5403 bfd_put_32 (abfd, BLR, p);
5404 return p + 4;
5405}
5406
5407static bfd_byte *
5408savegpr1 (bfd *abfd, bfd_byte *p, int r)
5409{
5410 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5411 return p + 4;
5412}
5413
5414static bfd_byte *
5415savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
5416{
5417 p = savegpr1 (abfd, p, r);
5418 bfd_put_32 (abfd, BLR, p);
5419 return p + 4;
5420}
5421
5422static bfd_byte *
5423restgpr1 (bfd *abfd, bfd_byte *p, int r)
5424{
5425 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5426 return p + 4;
5427}
5428
5429static bfd_byte *
5430restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
5431{
5432 p = restgpr1 (abfd, p, r);
5433 bfd_put_32 (abfd, BLR, p);
5434 return p + 4;
5435}
5436
5437static bfd_byte *
5438savefpr (bfd *abfd, bfd_byte *p, int r)
5439{
5440 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5441 return p + 4;
5442}
5443
5444static bfd_byte *
5445savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
5446{
5447 p = savefpr (abfd, p, r);
5448 bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
5449 p = p + 4;
5450 bfd_put_32 (abfd, BLR, p);
5451 return p + 4;
5452}
5453
5454static bfd_byte *
5455restfpr (bfd *abfd, bfd_byte *p, int r)
5456{
5457 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5458 return p + 4;
5459}
5460
5461static bfd_byte *
5462restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
5463{
5464 bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
5465 p = p + 4;
5466 p = restfpr (abfd, p, r);
5467 bfd_put_32 (abfd, MTLR_R0, p);
5468 p = p + 4;
5469 if (r == 29)
5470 {
5471 p = restfpr (abfd, p, 30);
5472 p = restfpr (abfd, p, 31);
5473 }
5474 bfd_put_32 (abfd, BLR, p);
5475 return p + 4;
5476}
5477
5478static bfd_byte *
5479savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
5480{
5481 p = savefpr (abfd, p, r);
5482 bfd_put_32 (abfd, BLR, p);
5483 return p + 4;
5484}
5485
5486static bfd_byte *
5487restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
5488{
5489 p = restfpr (abfd, p, r);
5490 bfd_put_32 (abfd, BLR, p);
5491 return p + 4;
5492}
5493
5494static bfd_byte *
5495savevr (bfd *abfd, bfd_byte *p, int r)
5496{
5497 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
5498 p = p + 4;
5499 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
5500 return p + 4;
5501}
5502
5503static bfd_byte *
5504savevr_tail (bfd *abfd, bfd_byte *p, int r)
5505{
5506 p = savevr (abfd, p, r);
5507 bfd_put_32 (abfd, BLR, p);
5508 return p + 4;
5509}
5510
5511static bfd_byte *
5512restvr (bfd *abfd, bfd_byte *p, int r)
5513{
5514 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
5515 p = p + 4;
5516 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
5517 return p + 4;
5518}
5519
5520static bfd_byte *
5521restvr_tail (bfd *abfd, bfd_byte *p, int r)
5522{
5523 p = restvr (abfd, p, r);
5524 bfd_put_32 (abfd, BLR, p);
5525 return p + 4;
5526}
5527
e86ce104
AM		 5528/* Called via elf_link_hash_traverse to transfer dynamic linking
5529 information on function code symbol entries to their corresponding
5530 function descriptor symbol entries. */
deb0e272 5531
b34976b6 5532static bfd_boolean
4ce794b7 5533func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
5bd4f169 5534{
e86ce104 5535 struct bfd_link_info *info;
65f38f15 5536 struct ppc_link_hash_table *htab;
411e1bfb 5537 struct plt_entry *ent;
50bc7936
AM		 5538 struct ppc_link_hash_entry *fh;
5539 struct ppc_link_hash_entry *fdh;
5540 bfd_boolean force_local;
5bd4f169 5541
50bc7936
AM		 5542 fh = (struct ppc_link_hash_entry *) h;
5543 if (fh->elf.root.type == bfd_link_hash_indirect)
b34976b6 5544 return TRUE;
e86ce104 5545
50bc7936
AM		 5546 if (fh->elf.root.type == bfd_link_hash_warning)
5547 fh = (struct ppc_link_hash_entry *) fh->elf.root.u.i.link;
e92d460e 5548
4ce794b7 5549 info = inf;
65f38f15 5550 htab = ppc_hash_table (info);
5bd4f169 5551
c09bdfe5
AM		 5552 /* Resolve undefined references to dot-symbols as the value
5553 in the function descriptor, if we have one in a regular object.
5554 This is to satisfy cases like ".quad .foo". Calls to functions
5555 in dynamic objects are handled elsewhere. */
5556 if (fh->elf.root.type == bfd_link_hash_undefweak
5557 && fh->was_undefined
5558 && (fh->oh->elf.root.type == bfd_link_hash_defined
5559 || fh->oh->elf.root.type == bfd_link_hash_defweak)
5560 && get_opd_info (fh->oh->elf.root.u.def.section) != NULL
5561 && opd_entry_value (fh->oh->elf.root.u.def.section,
5562 fh->oh->elf.root.u.def.value,
5563 &fh->elf.root.u.def.section,
5564 &fh->elf.root.u.def.value) != (bfd_vma) -1)
5565 {
5566 fh->elf.root.type = fh->oh->elf.root.type;
f5385ebf 5567 fh->elf.forced_local = 1;
c09bdfe5
AM		 5568 }
5569
e86ce104
AM		 5570 /* If this is a function code symbol, transfer dynamic linking
5571 information to the function descriptor symbol. */
50bc7936 5572 if (!fh->is_func)
b34976b6 5573 return TRUE;
e86ce104 5574
50bc7936 5575 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
411e1bfb
AM		 5576 if (ent->plt.refcount > 0)
5577 break;
50bc7936
AM		 5578 if (ent == NULL
5579 || fh->elf.root.root.string[0] != '.'
5580 || fh->elf.root.root.string[1] == '\0')
5581 return TRUE;
5bd4f169 5582
50bc7936
AM		 5583 /* Find the corresponding function descriptor symbol. Create it
5584 as undefined if necessary. */
5bd4f169 5585
50bc7936
AM		 5586 fdh = get_fdh (fh, htab);
5587 if (fdh != NULL)
5588 while (fdh->elf.root.type == bfd_link_hash_indirect
5589 || fdh->elf.root.type == bfd_link_hash_warning)
5590 fdh = (struct ppc_link_hash_entry *) fdh->elf.root.u.i.link;
5bd4f169 5591
50bc7936
AM		 5592 if (fdh == NULL
5593 && info->shared
5594 && (fh->elf.root.type == bfd_link_hash_undefined
5595 || fh->elf.root.type == bfd_link_hash_undefweak))
5596 {
908b32fc 5597 fdh = make_fdh (info, fh);
bb700d78
AM		 5598 if (fdh == NULL)
5599 return FALSE;
50bc7936 5600 }
648cca2c 5601
908b32fc 5602 /* Fake function descriptors are made undefweak. If the function
433817dd
AM		 5603 code symbol is strong undefined, make the fake sym the same.
5604 If the function code symbol is defined, then force the fake
5605 descriptor local; We can't support overriding of symbols in a
5606 shared library on a fake descriptor. */
908b32fc
AM		 5607
5608 if (fdh != NULL
5609 && fdh->fake
433817dd 5610 && fdh->elf.root.type == bfd_link_hash_undefweak)
908b32fc 5611 {
433817dd
AM		 5612 if (fh->elf.root.type == bfd_link_hash_undefined)
5613 {
5614 fdh->elf.root.type = bfd_link_hash_undefined;
5615 bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
5616 }
5617 else if (fh->elf.root.type == bfd_link_hash_defined
5618 || fh->elf.root.type == bfd_link_hash_defweak)
5619 {
5620 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
5621 }
908b32fc
AM		 5622 }
5623
50bc7936 5624 if (fdh != NULL
f5385ebf 5625 && !fdh->elf.forced_local
50bc7936 5626 && (info->shared
f5385ebf
AM		 5627 || fdh->elf.def_dynamic
5628 || fdh->elf.ref_dynamic
50bc7936
AM		 5629 || (fdh->elf.root.type == bfd_link_hash_undefweak
5630 && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
5631 {
5632 if (fdh->elf.dynindx == -1)
c152c796 5633 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
50bc7936 5634 return FALSE;
f5385ebf
AM		 5635 fdh->elf.ref_regular |= fh->elf.ref_regular;
5636 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
5637 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
5638 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
50bc7936 5639 if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
e86ce104 5640 {
40d16e0b 5641 move_plt_plist (fh, fdh);
f5385ebf 5642 fdh->elf.needs_plt = 1;
e86ce104 5643 }
50bc7936 5644 fdh->is_func_descriptor = 1;
34814b9f
AM		 5645 fdh->oh = fh;
5646 fh->oh = fdh;
e86ce104
AM		 5647 }
5648
50bc7936
AM		 5649 /* Now that the info is on the function descriptor, clear the
5650 function code sym info. Any function code syms for which we
5651 don't have a definition in a regular file, we force local.
5652 This prevents a shared library from exporting syms that have
5653 been imported from another library. Function code syms that
5654 are really in the library we must leave global to prevent the
5655 linker dragging in a definition from a static library. */
93f3fa99
AM		 5656 force_local = (!fh->elf.def_regular
5657 || fdh == NULL
5658 || !fdh->elf.def_regular
5659 || fdh->elf.forced_local);
50bc7936
AM		 5660 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
5661
b34976b6 5662 return TRUE;
e86ce104 5663}
40b8271b 5664
e86ce104 5665/* Called near the start of bfd_elf_size_dynamic_sections. We use
82bd7b59
AM		 5666 this hook to a) provide some gcc support functions, and b) transfer
5667 dynamic linking information gathered so far on function code symbol
5668 entries, to their corresponding function descriptor symbol entries. */
deb0e272 5669
b34976b6 5670static bfd_boolean
4ce794b7
AM		 5671ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
5672 struct bfd_link_info *info)
e86ce104
AM		 5673{
5674 struct ppc_link_hash_table *htab;
82bd7b59 5675 unsigned int i;
deb0e272
AM		 5676 const struct sfpr_def_parms funcs[] =
5677 {
5678 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
5679 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
5680 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
5681 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
5682 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
5683 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
5684 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
5685 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
5686 { "._savef", 14, 31, savefpr, savefpr1_tail },
5687 { "._restf", 14, 31, restfpr, restfpr1_tail },
5688 { "_savevr_", 20, 31, savevr, savevr_tail },
5689 { "_restvr_", 20, 31, restvr, restvr_tail }
5690 };
e86ce104
AM		 5691
5692 htab = ppc_hash_table (info);
82bd7b59
AM		 5693 if (htab->sfpr == NULL)
5694 /* We don't have any relocs. */
b34976b6 5695 return TRUE;
82bd7b59 5696
deb0e272
AM		 5697 /* Provide any missing _save* and _rest* functions. */
5698 htab->sfpr->size = 0;
5699 for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
5700 if (!sfpr_define (info, &funcs[i]))
5701 return FALSE;
82bd7b59 5702
4ce794b7 5703 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
805fc799 5704
eea6121a 5705 if (htab->sfpr->size == 0)
8423293d 5706 htab->sfpr->flags |= SEC_EXCLUDE;
82bd7b59 5707
b34976b6 5708 return TRUE;
e86ce104
AM		 5709}
5710
5711/* Adjust a symbol defined by a dynamic object and referenced by a
5712 regular object. The current definition is in some section of the
5713 dynamic object, but we're not including those sections. We have to
5714 change the definition to something the rest of the link can
5715 understand. */
5716
b34976b6 5717static bfd_boolean
4ce794b7
AM		 5718ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
5719 struct elf_link_hash_entry *h)
e86ce104
AM		 5720{
5721 struct ppc_link_hash_table *htab;
e86ce104
AM		 5722 asection *s;
5723 unsigned int power_of_two;
5724
5725 htab = ppc_hash_table (info);
5726
5727 /* Deal with function syms. */
5728 if (h->type == STT_FUNC
f5385ebf 5729 || h->needs_plt)
e86ce104
AM		 5730 {
5731 /* Clear procedure linkage table information for any symbol that
5732 won't need a .plt entry. */
411e1bfb
AM		 5733 struct plt_entry *ent;
5734 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5735 if (ent->plt.refcount > 0)
5736 break;
8387904d 5737 if (ent == NULL
9c7a29a3
AM		 5738 || SYMBOL_CALLS_LOCAL (info, h)
5739 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
5740 && h->root.type == bfd_link_hash_undefweak))
40b8271b 5741 {
411e1bfb 5742 h->plt.plist = NULL;
f5385ebf 5743 h->needs_plt = 0;
40b8271b 5744 }
5bd4f169 5745 }
bbd7ec4a 5746 else
411e1bfb 5747 h->plt.plist = NULL;
5bd4f169
AM		 5748
5749 /* If this is a weak symbol, and there is a real definition, the
5750 processor independent code will have arranged for us to see the
5751 real definition first, and we can just use the same value. */
f6e332e6 5752 if (h->u.weakdef != NULL)
5bd4f169 5753 {
f6e332e6
AM		 5754 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
5755 || h->u.weakdef->root.type == bfd_link_hash_defweak);
5756 h->root.u.def.section = h->u.weakdef->root.u.def.section;
5757 h->root.u.def.value = h->u.weakdef->root.u.def.value;
a23b6845 5758 if (ELIMINATE_COPY_RELOCS)
f6e332e6 5759 h->non_got_ref = h->u.weakdef->non_got_ref;
b34976b6 5760 return TRUE;
5bd4f169
AM		 5761 }
5762
5bd4f169
AM		 5763 /* If we are creating a shared library, we must presume that the
5764 only references to the symbol are via the global offset table.
5765 For such cases we need not do anything here; the relocations will
5766 be handled correctly by relocate_section. */
5767 if (info->shared)
b34976b6 5768 return TRUE;
5bd4f169 5769
65f38f15
AM		 5770 /* If there are no references to this symbol that do not use the
5771 GOT, we don't need to generate a copy reloc. */
f5385ebf 5772 if (!h->non_got_ref)
b34976b6 5773 return TRUE;
65f38f15 5774
f4656909 5775 if (ELIMINATE_COPY_RELOCS)
65f38f15 5776 {
f4656909
AM		 5777 struct ppc_link_hash_entry * eh;
5778 struct ppc_dyn_relocs *p;
65f38f15 5779
f4656909
AM		 5780 eh = (struct ppc_link_hash_entry *) h;
5781 for (p = eh->dyn_relocs; p != NULL; p = p->next)
5782 {
5783 s = p->sec->output_section;
5784 if (s != NULL && (s->flags & SEC_READONLY) != 0)
5785 break;
5786 }
5787
5788 /* If we didn't find any dynamic relocs in read-only sections, then
5789 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
5790 if (p == NULL)
5791 {
f5385ebf 5792 h->non_got_ref = 0;
f4656909
AM		 5793 return TRUE;
5794 }
65f38f15
AM		 5795 }
5796
5d35169e 5797 if (h->plt.plist != NULL)
97b639ba
AM		 5798 {
5799 /* We should never get here, but unfortunately there are versions
5800 of gcc out there that improperly (for this ABI) put initialized
5801 function pointers, vtable refs and suchlike in read-only
5802 sections. Allow them to proceed, but warn that this might
5803 break at runtime. */
5804 (*_bfd_error_handler)
5805 (_("copy reloc against `%s' requires lazy plt linking; "
5806 "avoid setting LD_BIND_NOW=1 or upgrade gcc"),
5807 h->root.root.string);
5808 }
5d35169e
AM		 5809
5810 /* This is a reference to a symbol defined by a dynamic object which
5811 is not a function. */
5812
909272ee
AM		 5813 if (h->size == 0)
5814 {
5815 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
5816 h->root.root.string);
5817 return TRUE;
5818 }
5819
5bd4f169
AM		 5820 /* We must allocate the symbol in our .dynbss section, which will
5821 become part of the .bss section of the executable. There will be
5822 an entry for this symbol in the .dynsym section. The dynamic
5823 object will contain position independent code, so all references
5824 from the dynamic object to this symbol will go through the global
5825 offset table. The dynamic linker will use the .dynsym entry to
5826 determine the address it must put in the global offset table, so
5827 both the dynamic object and the regular object will refer to the
5828 same memory location for the variable. */
5bd4f169 5829
04c9666a
AM		 5830 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
5831 to copy the initial value out of the dynamic object and into the
5bd4f169
AM		 5832 runtime process image. We need to remember the offset into the
5833 .rela.bss section we are going to use. */
5834 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
5835 {
eea6121a 5836 htab->relbss->size += sizeof (Elf64_External_Rela);
f5385ebf 5837 h->needs_copy = 1;
5bd4f169
AM		 5838 }
5839
5840 /* We need to figure out the alignment required for this symbol. I
5841 have no idea how ELF linkers handle this. */
5842 power_of_two = bfd_log2 (h->size);
5843 if (power_of_two > 4)
5844 power_of_two = 4;
5845
5846 /* Apply the required alignment. */
4ce794b7 5847 s = htab->dynbss;
eea6121a 5848 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
65f38f15 5849 if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
5bd4f169 5850 {
65f38f15 5851 if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
b34976b6 5852 return FALSE;
5bd4f169
AM		 5853 }
5854
5855 /* Define the symbol as being at this point in the section. */
5856 h->root.u.def.section = s;
eea6121a 5857 h->root.u.def.value = s->size;
5bd4f169
AM		 5858
5859 /* Increment the section size to make room for the symbol. */
eea6121a 5860 s->size += h->size;
5bd4f169 5861
b34976b6 5862 return TRUE;
5bd4f169
AM		 5863}
5864
e86ce104
AM		 5865/* If given a function descriptor symbol, hide both the function code
5866 sym and the descriptor. */
5867static void
4ce794b7
AM		 5868ppc64_elf_hide_symbol (struct bfd_link_info *info,
5869 struct elf_link_hash_entry *h,
5870 bfd_boolean force_local)
e86ce104 5871{
34814b9f 5872 struct ppc_link_hash_entry *eh;
e86ce104
AM		 5873 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
5874
34814b9f
AM		 5875 eh = (struct ppc_link_hash_entry *) h;
5876 if (eh->is_func_descriptor)
e86ce104 5877 {
34814b9f 5878 struct ppc_link_hash_entry *fh = eh->oh;
e86ce104 5879
721956f4 5880 if (fh == NULL)
d1329ca3
AM		 5881 {
5882 const char *p, *q;
5883 struct ppc_link_hash_table *htab;
5884 char save;
5885
5886 /* We aren't supposed to use alloca in BFD because on
5887 systems which do not have alloca the version in libiberty
5888 calls xmalloc, which might cause the program to crash
5889 when it runs out of memory. This function doesn't have a
5890 return status, so there's no way to gracefully return an
5891 error. So cheat. We know that string[-1] can be safely
34814b9f
AM		 5892 accessed; It's either a string in an ELF string table,
5893 or allocated in an objalloc structure. */
d1329ca3 5894
34814b9f 5895 p = eh->elf.root.root.string - 1;
d1329ca3
AM		 5896 save = *p;
5897 *(char *) p = '.';
5898 htab = ppc_hash_table (info);
34814b9f
AM		 5899 fh = (struct ppc_link_hash_entry *)
5900 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
d1329ca3
AM		 5901 *(char *) p = save;
5902
5903 /* Unfortunately, if it so happens that the string we were
5904 looking for was allocated immediately before this string,
5905 then we overwrote the string terminator. That's the only
5906 reason the lookup should fail. */
5907 if (fh == NULL)
5908 {
34814b9f
AM		 5909 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
5910 while (q >= eh->elf.root.root.string && *q == *p)
d1329ca3 5911 --q, --p;
34814b9f
AM		 5912 if (q < eh->elf.root.root.string && *p == '.')
5913 fh = (struct ppc_link_hash_entry *)
5914 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
d1329ca3
AM		 5915 }
5916 if (fh != NULL)
5917 {
34814b9f
AM		 5918 eh->oh = fh;
5919 fh->oh = eh;
d1329ca3
AM		 5920 }
5921 }
e86ce104 5922 if (fh != NULL)
34814b9f 5923 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
e86ce104
AM		 5924 }
5925}
5926
411e1bfb 5927static bfd_boolean
8843416a
AM		 5928get_sym_h (struct elf_link_hash_entry **hp,
5929 Elf_Internal_Sym **symp,
5930 asection **symsecp,
5931 char **tls_maskp,
5932 Elf_Internal_Sym **locsymsp,
5933 unsigned long r_symndx,
5934 bfd *ibfd)
411e1bfb
AM		 5935{
5936 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
5937
5938 if (r_symndx >= symtab_hdr->sh_info)
5939 {
5940 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
5941 struct elf_link_hash_entry *h;
5942
5943 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5944 while (h->root.type == bfd_link_hash_indirect
5945 || h->root.type == bfd_link_hash_warning)
5946 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5947
5948 if (hp != NULL)
5949 *hp = h;
5950
5951 if (symp != NULL)
5952 *symp = NULL;
5953
5954 if (symsecp != NULL)
5955 {
5956 asection *symsec = NULL;
5957 if (h->root.type == bfd_link_hash_defined
5958 || h->root.type == bfd_link_hash_defweak)
5959 symsec = h->root.u.def.section;
5960 *symsecp = symsec;
5961 }
5962
e7b938ca 5963 if (tls_maskp != NULL)
411e1bfb
AM		 5964 {
5965 struct ppc_link_hash_entry *eh;
5966
5967 eh = (struct ppc_link_hash_entry *) h;
e7b938ca 5968 *tls_maskp = &eh->tls_mask;
411e1bfb
AM		 5969 }
5970 }
5971 else
5972 {
5973 Elf_Internal_Sym *sym;
5974 Elf_Internal_Sym *locsyms = *locsymsp;
5975
5976 if (locsyms == NULL)
5977 {
5978 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
5979 if (locsyms == NULL)
5980 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
5981 symtab_hdr->sh_info,
5982 0, NULL, NULL, NULL);
5983 if (locsyms == NULL)
5984 return FALSE;
5985 *locsymsp = locsyms;
5986 }
5987 sym = locsyms + r_symndx;
5988
5989 if (hp != NULL)
5990 *hp = NULL;
5991
5992 if (symp != NULL)
5993 *symp = sym;
5994
5995 if (symsecp != NULL)
5996 {
5997 asection *symsec = NULL;
5998 if ((sym->st_shndx != SHN_UNDEF
5999 && sym->st_shndx < SHN_LORESERVE)
6000 || sym->st_shndx > SHN_HIRESERVE)
6001 symsec = bfd_section_from_elf_index (ibfd, sym->st_shndx);
6002 *symsecp = symsec;
6003 }
6004
e7b938ca 6005 if (tls_maskp != NULL)
411e1bfb
AM		 6006 {
6007 struct got_entry **lgot_ents;
e7b938ca 6008 char *tls_mask;
411e1bfb 6009
e7b938ca 6010 tls_mask = NULL;
411e1bfb
AM		 6011 lgot_ents = elf_local_got_ents (ibfd);
6012 if (lgot_ents != NULL)
6013 {
e7b938ca
AM		 6014 char *lgot_masks = (char *) (lgot_ents + symtab_hdr->sh_info);
6015 tls_mask = &lgot_masks[r_symndx];
411e1bfb 6016 }
e7b938ca 6017 *tls_maskp = tls_mask;
411e1bfb
AM		 6018 }
6019 }
6020 return TRUE;
6021}
6022
e7b938ca 6023/* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
951fd09b 6024 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
ad8e1ba5 6025 type suitable for optimization, and 1 otherwise. */
951fd09b
AM		 6026
6027static int
0d4792f7
AM		 6028get_tls_mask (char **tls_maskp, unsigned long *toc_symndx,
6029 Elf_Internal_Sym **locsymsp,
4ce794b7 6030 const Elf_Internal_Rela *rel, bfd *ibfd)
411e1bfb
AM		 6031{
6032 unsigned long r_symndx;
0d4792f7 6033 int next_r;
411e1bfb
AM		 6034 struct elf_link_hash_entry *h;
6035 Elf_Internal_Sym *sym;
6036 asection *sec;
6037 bfd_vma off;
6038
6039 r_symndx = ELF64_R_SYM (rel->r_info);
e7b938ca 6040 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
951fd09b 6041 return 0;
411e1bfb 6042
e7b938ca 6043 if ((*tls_maskp != NULL && **tls_maskp != 0)
411e1bfb
AM		 6044 || sec == NULL
6045 || ppc64_elf_section_data (sec)->t_symndx == NULL)
951fd09b 6046 return 1;
411e1bfb
AM		 6047
6048 /* Look inside a TOC section too. */
6049 if (h != NULL)
6050 {
6051 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
6052 off = h->root.u.def.value;
6053 }
6054 else
6055 off = sym->st_value;
6056 off += rel->r_addend;
6057 BFD_ASSERT (off % 8 == 0);
6058 r_symndx = ppc64_elf_section_data (sec)->t_symndx[off / 8];
951fd09b 6059 next_r = ppc64_elf_section_data (sec)->t_symndx[off / 8 + 1];
e7b938ca 6060 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
951fd09b 6061 return 0;
0d4792f7
AM		 6062 if (toc_symndx != NULL)
6063 *toc_symndx = r_symndx;
6064 if ((h == NULL
6065 || ((h->root.type == bfd_link_hash_defined
6066 || h->root.type == bfd_link_hash_defweak)
f5385ebf 6067 && !h->def_dynamic))
0d4792f7
AM		 6068 && (next_r == -1 || next_r == -2))
6069 return 1 - next_r;
951fd09b 6070 return 1;
411e1bfb
AM		 6071}
6072
754021d0 6073/* Adjust all global syms defined in opd sections. In gcc generated
8387904d 6074 code for the old ABI, these will already have been done. */
754021d0
AM		 6075
6076static bfd_boolean
6077adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
6078{
6079 struct ppc_link_hash_entry *eh;
6080 asection *sym_sec;
6081 long *opd_adjust;
6082
6083 if (h->root.type == bfd_link_hash_indirect)
6084 return TRUE;
6085
6086 if (h->root.type == bfd_link_hash_warning)
6087 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6088
6089 if (h->root.type != bfd_link_hash_defined
6090 && h->root.type != bfd_link_hash_defweak)
6091 return TRUE;
6092
6093 eh = (struct ppc_link_hash_entry *) h;
6094 if (eh->adjust_done)
6095 return TRUE;
6096
6097 sym_sec = eh->elf.root.u.def.section;
4025353c
AM		 6098 opd_adjust = get_opd_info (sym_sec);
6099 if (opd_adjust != NULL)
754021d0 6100 {
3f764659 6101 long adjust = opd_adjust[eh->elf.root.u.def.value / 8];
4025353c
AM		 6102 if (adjust == -1)
6103 {
6104 /* This entry has been deleted. */
433817dd 6105 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->u.deleted_section;
81688140
AM		 6106 if (dsec == NULL)
6107 {
6108 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
6109 if (elf_discarded_section (dsec))
6110 {
433817dd 6111 ppc64_elf_tdata (sym_sec->owner)->u.deleted_section = dsec;
81688140
AM		 6112 break;
6113 }
6114 }
4025353c 6115 eh->elf.root.u.def.value = 0;
81688140 6116 eh->elf.root.u.def.section = dsec;
4025353c
AM		 6117 }
6118 else
6119 eh->elf.root.u.def.value += adjust;
754021d0
AM		 6120 eh->adjust_done = 1;
6121 }
6122 return TRUE;
6123}
6124
8c1d1bb8
AM		 6125/* Handles decrementing dynamic reloc counts for the reloc specified by
6126 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM_SEC
6127 have already been determined. */
6128
6129static bfd_boolean
6130dec_dynrel_count (bfd_vma r_info,
6131 asection *sec,
6132 struct bfd_link_info *info,
6133 Elf_Internal_Sym **local_syms,
6134 struct elf_link_hash_entry *h,
6135 asection *sym_sec)
6136{
6137 enum elf_ppc64_reloc_type r_type;
6138 struct ppc_dyn_relocs *p;
6139 struct ppc_dyn_relocs **pp;
6140
6141 /* Can this reloc be dynamic? This switch, and later tests here
6142 should be kept in sync with the code in check_relocs. */
6143 r_type = ELF64_R_TYPE (r_info);
6144 switch (r_type)
6145 {
6146 default:
6147 return TRUE;
6148
6149 case R_PPC64_TPREL16:
6150 case R_PPC64_TPREL16_LO:
6151 case R_PPC64_TPREL16_HI:
6152 case R_PPC64_TPREL16_HA:
6153 case R_PPC64_TPREL16_DS:
6154 case R_PPC64_TPREL16_LO_DS:
6155 case R_PPC64_TPREL16_HIGHER:
6156 case R_PPC64_TPREL16_HIGHERA:
6157 case R_PPC64_TPREL16_HIGHEST:
6158 case R_PPC64_TPREL16_HIGHESTA:
6159 if (!info->shared)
6160 return TRUE;
6161
6162 case R_PPC64_TPREL64:
6163 case R_PPC64_DTPMOD64:
6164 case R_PPC64_DTPREL64:
6165 case R_PPC64_ADDR64:
6166 case R_PPC64_REL30:
6167 case R_PPC64_REL32:
6168 case R_PPC64_REL64:
6169 case R_PPC64_ADDR14:
6170 case R_PPC64_ADDR14_BRNTAKEN:
6171 case R_PPC64_ADDR14_BRTAKEN:
6172 case R_PPC64_ADDR16:
6173 case R_PPC64_ADDR16_DS:
6174 case R_PPC64_ADDR16_HA:
6175 case R_PPC64_ADDR16_HI:
6176 case R_PPC64_ADDR16_HIGHER:
6177 case R_PPC64_ADDR16_HIGHERA:
6178 case R_PPC64_ADDR16_HIGHEST:
6179 case R_PPC64_ADDR16_HIGHESTA:
6180 case R_PPC64_ADDR16_LO:
6181 case R_PPC64_ADDR16_LO_DS:
6182 case R_PPC64_ADDR24:
6183 case R_PPC64_ADDR32:
6184 case R_PPC64_UADDR16:
6185 case R_PPC64_UADDR32:
6186 case R_PPC64_UADDR64:
6187 case R_PPC64_TOC:
6188 break;
6189 }
6190
6191 if (local_syms != NULL)
6192 {
6193 unsigned long r_symndx;
6194 Elf_Internal_Sym *sym;
6195 bfd *ibfd = sec->owner;
6196
6197 r_symndx = ELF64_R_SYM (r_info);
6198 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
6199 return FALSE;
6200 }
6201
6202 if ((info->shared
6203 && (MUST_BE_DYN_RELOC (r_type)
6204 || (h != NULL
6205 && (!info->symbolic
6206 || h->root.type == bfd_link_hash_defweak
6207 || !h->def_regular))))
6208 || (ELIMINATE_COPY_RELOCS
6209 && !info->shared
6210 && h != NULL
6211 && (h->root.type == bfd_link_hash_defweak
6212 || !h->def_regular)))
6213 ;
6214 else
6215 return TRUE;
6216
6217 if (h != NULL)
6218 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
8c1d1bb8 6219 else
6edfbbad 6220 {
60124e18
AM		 6221 if (sym_sec != NULL)
6222 {
6223 void *vpp = &elf_section_data (sym_sec)->local_dynrel;
6224 pp = (struct ppc_dyn_relocs **) vpp;
6225 }
6226 else
6227 {
6228 void *vpp = &elf_section_data (sec)->local_dynrel;
6229 pp = (struct ppc_dyn_relocs **) vpp;
6230 }
6231
6232 /* elf_gc_sweep may have already removed all dyn relocs associated
6233 with local syms for a given section. Don't report a dynreloc
6234 miscount. */
6235 if (*pp == NULL)
6236 return TRUE;
6edfbbad 6237 }
8c1d1bb8
AM		 6238
6239 while ((p = *pp) != NULL)
6240 {
6241 if (p->sec == sec)
6242 {
6243 if (!MUST_BE_DYN_RELOC (r_type))
6244 p->pc_count -= 1;
6245 p->count -= 1;
6246 if (p->count == 0)
6247 *pp = p->next;
6248 return TRUE;
6249 }
6250 pp = &p->next;
6251 }
6252
6253 (*_bfd_error_handler) (_("dynreloc miscount for %B, section %A"),
6254 sec->owner, sec);
6255 bfd_set_error (bfd_error_bad_value);
6256 return FALSE;
6257}
6258
754021d0
AM		 6259/* Remove unused Official Procedure Descriptor entries. Currently we
6260 only remove those associated with functions in discarded link-once
6261 sections, or weakly defined functions that have been overridden. It
6262 would be possible to remove many more entries for statically linked
6263 applications. */
6264
b34976b6 6265bfd_boolean
3f764659 6266ppc64_elf_edit_opd (bfd *obfd, struct bfd_link_info *info,
b4f4e59f 6267 bfd_boolean no_opd_opt,
3f764659 6268 bfd_boolean non_overlapping)
1e2f5b6e
AM		 6269{
6270 bfd *ibfd;
754021d0 6271 bfd_boolean some_edited = FALSE;
3f764659 6272 asection *need_pad = NULL;
1e2f5b6e 6273
411e1bfb 6274 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1e2f5b6e
AM		 6275 {
6276 asection *sec;
6277 Elf_Internal_Rela *relstart, *rel, *relend;
6278 Elf_Internal_Shdr *symtab_hdr;
6cdc0ccc 6279 Elf_Internal_Sym *local_syms;
1e2f5b6e
AM		 6280 struct elf_link_hash_entry **sym_hashes;
6281 bfd_vma offset;
d6fe2dc1 6282 bfd_size_type amt;
4025353c 6283 long *opd_adjust;
3f764659
JJ		 6284 bfd_boolean need_edit, add_aux_fields;
6285 bfd_size_type cnt_16b = 0;
1e2f5b6e
AM		 6286
6287 sec = bfd_get_section_by_name (ibfd, ".opd");
46de2a7c 6288 if (sec == NULL || sec->size == 0)
1e2f5b6e
AM		 6289 continue;
6290
3f764659 6291 amt = sec->size * sizeof (long) / 8;
4025353c
AM		 6292 opd_adjust = get_opd_info (sec);
6293 if (opd_adjust == NULL)
d6fe2dc1 6294 {
4b85d634
AM		 6295 /* check_relocs hasn't been called. Must be a ld -r link
6296 or --just-symbols object. */
b4f4e59f 6297 opd_adjust = bfd_alloc (obfd, amt);
46de2a7c
AM		 6298 if (opd_adjust == NULL)
6299 return FALSE;
4025353c 6300 ppc64_elf_section_data (sec)->opd.adjust = opd_adjust;
d6fe2dc1 6301 }
4025353c 6302 memset (opd_adjust, 0, amt);
1e2f5b6e 6303
b4f4e59f
AM		 6304 if (no_opd_opt)
6305 continue;
6306
4b85d634
AM		 6307 if (sec->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
6308 continue;
6309
1e2f5b6e
AM		 6310 if (sec->output_section == bfd_abs_section_ptr)
6311 continue;
6312
6313 /* Look through the section relocs. */
6314 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
6315 continue;
6316
6cdc0ccc 6317 local_syms = NULL;
1e2f5b6e
AM		 6318 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
6319 sym_hashes = elf_sym_hashes (ibfd);
6320
6321 /* Read the relocations. */
4ce794b7 6322 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
45d6a902 6323 info->keep_memory);
1e2f5b6e 6324 if (relstart == NULL)
b34976b6 6325 return FALSE;
1e2f5b6e
AM		 6326
6327 /* First run through the relocs to check they are sane, and to
6328 determine whether we need to edit this opd section. */
b34976b6 6329 need_edit = FALSE;
3f764659 6330 need_pad = sec;
1e2f5b6e
AM		 6331 offset = 0;
6332 relend = relstart + sec->reloc_count;
50bc7936 6333 for (rel = relstart; rel < relend; )
1e2f5b6e 6334 {
04c9666a 6335 enum elf_ppc64_reloc_type r_type;
1e2f5b6e
AM		 6336 unsigned long r_symndx;
6337 asection *sym_sec;
6338 struct elf_link_hash_entry *h;
6339 Elf_Internal_Sym *sym;
6340
3f764659 6341 /* .opd contains a regular array of 16 or 24 byte entries. We're
1e2f5b6e
AM		 6342 only interested in the reloc pointing to a function entry
6343 point. */
50bc7936
AM		 6344 if (rel->r_offset != offset
6345 || rel + 1 >= relend
6346 || (rel + 1)->r_offset != offset + 8)
1e2f5b6e
AM		 6347 {
6348 /* If someone messes with .opd alignment then after a
6349 "ld -r" we might have padding in the middle of .opd.
6350 Also, there's nothing to prevent someone putting
6351 something silly in .opd with the assembler. No .opd
b34976b6 6352 optimization for them! */
3f764659 6353 broken_opd:
1e2f5b6e 6354 (*_bfd_error_handler)
d003868e 6355 (_("%B: .opd is not a regular array of opd entries"), ibfd);
b34976b6 6356 need_edit = FALSE;
1e2f5b6e
AM		 6357 break;
6358 }
6359
50bc7936
AM		 6360 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
6361 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
6362 {
6363 (*_bfd_error_handler)
d003868e
AM		 6364 (_("%B: unexpected reloc type %u in .opd section"),
6365 ibfd, r_type);
50bc7936
AM		 6366 need_edit = FALSE;
6367 break;
6368 }
6369
1e2f5b6e 6370 r_symndx = ELF64_R_SYM (rel->r_info);
411e1bfb
AM		 6371 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
6372 r_symndx, ibfd))
50bc7936 6373 goto error_ret;
1e2f5b6e
AM		 6374
6375 if (sym_sec == NULL || sym_sec->owner == NULL)
6376 {
411e1bfb
AM		 6377 const char *sym_name;
6378 if (h != NULL)
6379 sym_name = h->root.root.string;
6380 else
26c61ae5
L		 6381 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
6382 sym_sec);
411e1bfb 6383
1e2f5b6e 6384 (*_bfd_error_handler)
d003868e
AM		 6385 (_("%B: undefined sym `%s' in .opd section"),
6386 ibfd, sym_name);
b34976b6 6387 need_edit = FALSE;
1e2f5b6e
AM		 6388 break;
6389 }
6390
51020317
AM		 6391 /* opd entries are always for functions defined in the
6392 current input bfd. If the symbol isn't defined in the
6393 input bfd, then we won't be using the function in this
6394 bfd; It must be defined in a linkonce section in another
6395 bfd, or is weak. It's also possible that we are
6396 discarding the function due to a linker script /DISCARD/,
6397 which we test for via the output_section. */
6398 if (sym_sec->owner != ibfd
6399 || sym_sec->output_section == bfd_abs_section_ptr)
b34976b6 6400 need_edit = TRUE;
1e2f5b6e 6401
50bc7936 6402 rel += 2;
3f764659
JJ		 6403 if (rel == relend
6404 || (rel + 1 == relend && rel->r_offset == offset + 16))
6405 {
6406 if (sec->size == offset + 24)
6407 {
6408 need_pad = NULL;
6409 break;
6410 }
6411 if (rel == relend && sec->size == offset + 16)
6412 {
6413 cnt_16b++;
6414 break;
6415 }
6416 goto broken_opd;
6417 }
6418
6419 if (rel->r_offset == offset + 24)
6420 offset += 24;
6421 else if (rel->r_offset != offset + 16)
6422 goto broken_opd;
6423 else if (rel + 1 < relend
6424 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
6425 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
6426 {
6427 offset += 16;
6428 cnt_16b++;
6429 }
6430 else if (rel + 2 < relend
6431 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
6432 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
6433 {
6434 offset += 24;
6435 rel += 1;
6436 }
6437 else
6438 goto broken_opd;
1e2f5b6e
AM		 6439 }
6440
3f764659
JJ		 6441 add_aux_fields = non_overlapping && cnt_16b > 0;
6442
6443 if (need_edit || add_aux_fields)
1e2f5b6e
AM		 6444 {
6445 Elf_Internal_Rela *write_rel;
6446 bfd_byte *rptr, *wptr;
3f764659 6447 bfd_byte *new_contents = NULL;
b34976b6 6448 bfd_boolean skip;
3f764659 6449 long opd_ent_size;
1e2f5b6e
AM		 6450
6451 /* This seems a waste of time as input .opd sections are all
6452 zeros as generated by gcc, but I suppose there's no reason
6453 this will always be so. We might start putting something in
6454 the third word of .opd entries. */
6455 if ((sec->flags & SEC_IN_MEMORY) == 0)
6456 {
eea6121a
AM		 6457 bfd_byte *loc;
6458 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
6cdc0ccc 6459 {
eea6121a
AM		 6460 if (loc != NULL)
6461 free (loc);
50bc7936 6462 error_ret:
6cdc0ccc
AM		 6463 if (local_syms != NULL
6464 && symtab_hdr->contents != (unsigned char *) local_syms)
6465 free (local_syms);
6cdc0ccc
AM		 6466 if (elf_section_data (sec)->relocs != relstart)
6467 free (relstart);
b34976b6 6468 return FALSE;
6cdc0ccc 6469 }
1e2f5b6e
AM		 6470 sec->contents = loc;
6471 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
6472 }
6473
6474 elf_section_data (sec)->relocs = relstart;
6475
3f764659 6476 new_contents = sec->contents;
3f764659
JJ		 6477 if (add_aux_fields)
6478 {
6479 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
6480 if (new_contents == NULL)
6481 return FALSE;
6482 need_pad = FALSE;
3f764659 6483 }
b4f4e59f
AM		 6484 wptr = new_contents;
6485 rptr = sec->contents;
3f764659 6486
1e2f5b6e 6487 write_rel = relstart;
b34976b6 6488 skip = FALSE;
1e2f5b6e 6489 offset = 0;
3f764659 6490 opd_ent_size = 0;
1e2f5b6e
AM		 6491 for (rel = relstart; rel < relend; rel++)
6492 {
50bc7936
AM		 6493 unsigned long r_symndx;
6494 asection *sym_sec;
6495 struct elf_link_hash_entry *h;
6496 Elf_Internal_Sym *sym;
6497
6498 r_symndx = ELF64_R_SYM (rel->r_info);
6499 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
d37c89e5 6500 r_symndx, ibfd))
50bc7936
AM		 6501 goto error_ret;
6502
1e2f5b6e
AM		 6503 if (rel->r_offset == offset)
6504 {
50bc7936 6505 struct ppc_link_hash_entry *fdh = NULL;
3f764659
JJ		 6506
6507 /* See if the .opd entry is full 24 byte or
6508 16 byte (with fd_aux entry overlapped with next
6509 fd_func). */
6510 opd_ent_size = 24;
6511 if ((rel + 2 == relend && sec->size == offset + 16)
6512 || (rel + 3 < relend
6513 && rel[2].r_offset == offset + 16
6514 && rel[3].r_offset == offset + 24
6515 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
6516 && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
6517 opd_ent_size = 16;
6518
4025353c
AM		 6519 if (h != NULL
6520 && h->root.root.string[0] == '.')
c4f68ce3
AM		 6521 {
6522 fdh = get_fdh ((struct ppc_link_hash_entry *) h,
6523 ppc_hash_table (info));
6524 if (fdh != NULL
6525 && fdh->elf.root.type != bfd_link_hash_defined
6526 && fdh->elf.root.type != bfd_link_hash_defweak)
6527 fdh = NULL;
6528 }
1e2f5b6e 6529
51020317
AM		 6530 skip = (sym_sec->owner != ibfd
6531 || sym_sec->output_section == bfd_abs_section_ptr);
a4aa0fb7
AM		 6532 if (skip)
6533 {
4025353c 6534 if (fdh != NULL && sym_sec->owner == ibfd)
a4aa0fb7
AM		 6535 {
6536 /* Arrange for the function descriptor sym
6537 to be dropped. */
d6fe2dc1
AM		 6538 fdh->elf.root.u.def.value = 0;
6539 fdh->elf.root.u.def.section = sym_sec;
a4aa0fb7 6540 }
3f764659 6541 opd_adjust[rel->r_offset / 8] = -1;
a4aa0fb7
AM		 6542 }
6543 else
1e2f5b6e
AM		 6544 {
6545 /* We'll be keeping this opd entry. */
6546
4025353c 6547 if (fdh != NULL)
1e2f5b6e 6548 {
754021d0
AM		 6549 /* Redefine the function descriptor symbol to
6550 this location in the opd section. It is
6551 necessary to update the value here rather
6552 than using an array of adjustments as we do
6553 for local symbols, because various places
6554 in the generic ELF code use the value
6555 stored in u.def.value. */
3f764659 6556 fdh->elf.root.u.def.value = wptr - new_contents;
754021d0 6557 fdh->adjust_done = 1;
1e2f5b6e 6558 }
754021d0
AM		 6559
6560 /* Local syms are a bit tricky. We could
6561 tweak them as they can be cached, but
6562 we'd need to look through the local syms
6563 for the function descriptor sym which we
6564 don't have at the moment. So keep an
6565 array of adjustments. */
3f764659
JJ		 6566 opd_adjust[rel->r_offset / 8]
6567 = (wptr - new_contents) - (rptr - sec->contents);
1e2f5b6e
AM		 6568
6569 if (wptr != rptr)
3f764659
JJ		 6570 memcpy (wptr, rptr, opd_ent_size);
6571 wptr += opd_ent_size;
6572 if (add_aux_fields && opd_ent_size == 16)
6573 {
6574 memset (wptr, '\0', 8);
6575 wptr += 8;
6576 }
1e2f5b6e 6577 }
3f764659
JJ		 6578 rptr += opd_ent_size;
6579 offset += opd_ent_size;
1e2f5b6e
AM		 6580 }
6581
50bc7936
AM		 6582 if (skip)
6583 {
60124e18
AM		 6584 if (!NO_OPD_RELOCS
6585 && !info->relocatable
18d944df
AM		 6586 && !dec_dynrel_count (rel->r_info, sec, info,
6587 NULL, h, sym_sec))
8c1d1bb8 6588 goto error_ret;
50bc7936
AM		 6589 }
6590 else
1e2f5b6e 6591 {
50bc7936
AM		 6592 /* We need to adjust any reloc offsets to point to the
6593 new opd entries. While we're at it, we may as well
6594 remove redundant relocs. */
3f764659 6595 rel->r_offset += opd_adjust[(offset - opd_ent_size) / 8];
1e2f5b6e
AM		 6596 if (write_rel != rel)
6597 memcpy (write_rel, rel, sizeof (*rel));
6598 ++write_rel;
6599 }
6600 }
6601
3f764659 6602 sec->size = wptr - new_contents;
1e2f5b6e 6603 sec->reloc_count = write_rel - relstart;
3f764659
JJ		 6604 if (add_aux_fields)
6605 {
6606 free (sec->contents);
6607 sec->contents = new_contents;
6608 }
6609
cdcf6e38
AM		 6610 /* Fudge the size too, as this is used later in
6611 elf_bfd_final_link if we are emitting relocs. */
6612 elf_section_data (sec)->rel_hdr.sh_size
6613 = sec->reloc_count * elf_section_data (sec)->rel_hdr.sh_entsize;
6614 BFD_ASSERT (elf_section_data (sec)->rel_hdr2 == NULL);
754021d0 6615 some_edited = TRUE;
1e2f5b6e 6616 }
6cdc0ccc 6617 else if (elf_section_data (sec)->relocs != relstart)
1e2f5b6e 6618 free (relstart);
6cdc0ccc 6619
411e1bfb
AM		 6620 if (local_syms != NULL
6621 && symtab_hdr->contents != (unsigned char *) local_syms)
6622 {
6623 if (!info->keep_memory)
6624 free (local_syms);
6625 else
6626 symtab_hdr->contents = (unsigned char *) local_syms;
6627 }
6628 }
6629
754021d0
AM		 6630 if (some_edited)
6631 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
6632
3f764659
JJ		 6633 /* If we are doing a final link and the last .opd entry is just 16 byte
6634 long, add a 8 byte padding after it. */
6635 if (need_pad != NULL && !info->relocatable)
6636 {
6637 bfd_byte *p;
6638
6639 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
6640 {
6641 BFD_ASSERT (need_pad->size > 0);
6642
6643 p = bfd_malloc (need_pad->size + 8);
6644 if (p == NULL)
6645 return FALSE;
699733f6 6646
3f764659
JJ		 6647 if (! bfd_get_section_contents (need_pad->owner, need_pad,
6648 p, 0, need_pad->size))
6649 return FALSE;
6650
6651 need_pad->contents = p;
6652 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
6653 }
6654 else
6655 {
6656 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
6657 if (p == NULL)
6658 return FALSE;
6659
6660 need_pad->contents = p;
6661 }
6662
6663 memset (need_pad->contents + need_pad->size, 0, 8);
6664 need_pad->size += 8;
6665 }
6666
411e1bfb
AM		 6667 return TRUE;
6668}
6669
e1918d23 6670/* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
411e1bfb 6671
e1918d23 6672asection *
4ce794b7 6673ppc64_elf_tls_setup (bfd *obfd, struct bfd_link_info *info)
411e1bfb 6674{
411e1bfb
AM		 6675 struct ppc_link_hash_table *htab;
6676
411e1bfb 6677 htab = ppc_hash_table (info);
a48ebf4d
AM		 6678 if (htab->tls_get_addr != NULL)
6679 {
8387904d 6680 struct ppc_link_hash_entry *h = htab->tls_get_addr;
a48ebf4d 6681
8387904d
AM		 6682 while (h->elf.root.type == bfd_link_hash_indirect
6683 || h->elf.root.type == bfd_link_hash_warning)
6684 h = (struct ppc_link_hash_entry *) h->elf.root.u.i.link;
a48ebf4d
AM		 6685
6686 htab->tls_get_addr = h;
8387904d
AM		 6687
6688 if (htab->tls_get_addr_fd == NULL
6689 && h->oh != NULL
c4f68ce3
AM		 6690 && h->oh->is_func_descriptor
6691 && (h->oh->elf.root.type == bfd_link_hash_defined
6692 || h->oh->elf.root.type == bfd_link_hash_defweak))
8387904d
AM		 6693 htab->tls_get_addr_fd = h->oh;
6694 }
6695
6696 if (htab->tls_get_addr_fd != NULL)
6697 {
6698 struct ppc_link_hash_entry *h = htab->tls_get_addr_fd;
6699
6700 while (h->elf.root.type == bfd_link_hash_indirect
6701 || h->elf.root.type == bfd_link_hash_warning)
6702 h = (struct ppc_link_hash_entry *) h->elf.root.u.i.link;
6703
6704 htab->tls_get_addr_fd = h;
a48ebf4d
AM		 6705 }
6706
e1918d23 6707 return _bfd_elf_tls_setup (obfd, info);
951fd09b 6708}
411e1bfb 6709
951fd09b
AM		 6710/* Run through all the TLS relocs looking for optimization
6711 opportunities. The linker has been hacked (see ppc64elf.em) to do
6712 a preliminary section layout so that we know the TLS segment
6713 offsets. We can't optimize earlier because some optimizations need
6714 to know the tp offset, and we need to optimize before allocating
6715 dynamic relocations. */
6716
6717bfd_boolean
4ce794b7 6718ppc64_elf_tls_optimize (bfd *obfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
951fd09b
AM		 6719{
6720 bfd *ibfd;
6721 asection *sec;
6722 struct ppc_link_hash_table *htab;
6723
1049f94e 6724 if (info->relocatable || info->shared)
411e1bfb
AM		 6725 return TRUE;
6726
951fd09b 6727 htab = ppc_hash_table (info);
411e1bfb
AM		 6728 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6729 {
6730 Elf_Internal_Sym *locsyms = NULL;
30038c59
AM		 6731 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
6732 unsigned char *toc_ref = NULL;
411e1bfb 6733
30038c59
AM		 6734 /* Look at all the sections for this file, with TOC last. */
6735 for (sec = (ibfd->sections == toc && toc && toc->next ? toc->next
6736 : ibfd->sections);
6737 sec != NULL;
6738 sec = (sec == toc ? NULL
6739 : sec->next == NULL ? toc
6740 : sec->next == toc && toc->next ? toc->next
6741 : sec->next))
411e1bfb
AM		 6742 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
6743 {
6744 Elf_Internal_Rela *relstart, *rel, *relend;
6745 int expecting_tls_get_addr;
30038c59 6746 long toc_ref_index = 0;
411e1bfb
AM		 6747
6748 /* Read the relocations. */
4ce794b7 6749 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
45d6a902 6750 info->keep_memory);
411e1bfb
AM		 6751 if (relstart == NULL)
6752 return FALSE;
6753
6754 expecting_tls_get_addr = 0;
6755 relend = relstart + sec->reloc_count;
6756 for (rel = relstart; rel < relend; rel++)
6757 {
6758 enum elf_ppc64_reloc_type r_type;
6759 unsigned long r_symndx;
6760 struct elf_link_hash_entry *h;
6761 Elf_Internal_Sym *sym;
6762 asection *sym_sec;
e7b938ca
AM		 6763 char *tls_mask;
6764 char tls_set, tls_clear, tls_type = 0;
411e1bfb 6765 bfd_vma value;
951fd09b 6766 bfd_boolean ok_tprel, is_local;
411e1bfb
AM		 6767
6768 r_symndx = ELF64_R_SYM (rel->r_info);
e7b938ca 6769 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
411e1bfb
AM		 6770 r_symndx, ibfd))
6771 {
6772 err_free_rel:
6773 if (elf_section_data (sec)->relocs != relstart)
6774 free (relstart);
30038c59
AM		 6775 if (toc_ref != NULL)
6776 free (toc_ref);
411e1bfb
AM		 6777 if (locsyms != NULL
6778 && (elf_tdata (ibfd)->symtab_hdr.contents
6779 != (unsigned char *) locsyms))
6780 free (locsyms);
6781 return FALSE;
6782 }
6783
6784 if (h != NULL)
6785 {
6786 if (h->root.type != bfd_link_hash_defined
6787 && h->root.type != bfd_link_hash_defweak)
6788 continue;
6789 value = h->root.u.def.value;
6790 }
6791 else
4025353c
AM		 6792 /* Symbols referenced by TLS relocs must be of type
6793 STT_TLS. So no need for .opd local sym adjust. */
6794 value = sym->st_value;
951fd09b 6795
411e1bfb 6796 ok_tprel = FALSE;
951fd09b
AM		 6797 is_local = FALSE;
6798 if (h == NULL
f5385ebf 6799 || !h->def_dynamic)
411e1bfb 6800 {
951fd09b 6801 is_local = TRUE;
411e1bfb
AM		 6802 value += sym_sec->output_offset;
6803 value += sym_sec->output_section->vma;
e1918d23 6804 value -= htab->elf.tls_sec->vma;
411e1bfb
AM		 6805 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
6806 < (bfd_vma) 1 << 32);
6807 }
6808
4ce794b7 6809 r_type = ELF64_R_TYPE (rel->r_info);
411e1bfb
AM		 6810 switch (r_type)
6811 {
6812 case R_PPC64_GOT_TLSLD16:
6813 case R_PPC64_GOT_TLSLD16_LO:
6814 case R_PPC64_GOT_TLSLD16_HI:
6815 case R_PPC64_GOT_TLSLD16_HA:
951fd09b
AM		 6816 /* These relocs should never be against a symbol
6817 defined in a shared lib. Leave them alone if
6818 that turns out to be the case. */
e717da7e 6819 ppc64_tlsld_got (ibfd)->refcount -= 1;
951fd09b
AM		 6820 if (!is_local)
6821 continue;
6822
951fd09b
AM		 6823 /* LD -> LE */
6824 tls_set = 0;
6825 tls_clear = TLS_LD;
e7b938ca 6826 tls_type = TLS_TLS | TLS_LD;
411e1bfb
AM		 6827 expecting_tls_get_addr = 1;
6828 break;
6829
6830 case R_PPC64_GOT_TLSGD16:
6831 case R_PPC64_GOT_TLSGD16_LO:
6832 case R_PPC64_GOT_TLSGD16_HI:
6833 case R_PPC64_GOT_TLSGD16_HA:
951fd09b 6834 if (ok_tprel)
411e1bfb
AM		 6835 /* GD -> LE */
6836 tls_set = 0;
6837 else
6838 /* GD -> IE */
951fd09b
AM		 6839 tls_set = TLS_TLS | TLS_TPRELGD;
6840 tls_clear = TLS_GD;
e7b938ca 6841 tls_type = TLS_TLS | TLS_GD;
411e1bfb
AM		 6842 expecting_tls_get_addr = 1;
6843 break;
6844
6845 case R_PPC64_GOT_TPREL16_DS:
6846 case R_PPC64_GOT_TPREL16_LO_DS:
6847 case R_PPC64_GOT_TPREL16_HI:
6848 case R_PPC64_GOT_TPREL16_HA:
6849 expecting_tls_get_addr = 0;
6850 if (ok_tprel)
6851 {
6852 /* IE -> LE */
6853 tls_set = 0;
6854 tls_clear = TLS_TPREL;
e7b938ca 6855 tls_type = TLS_TLS | TLS_TPREL;
411e1bfb
AM		 6856 break;
6857 }
6858 else
6859 continue;
6860
6861 case R_PPC64_REL14:
6862 case R_PPC64_REL14_BRTAKEN:
6863 case R_PPC64_REL14_BRNTAKEN:
6864 case R_PPC64_REL24:
6865 if (h != NULL
8387904d
AM		 6866 && (h == &htab->tls_get_addr->elf
6867 || h == &htab->tls_get_addr_fd->elf))
411e1bfb
AM		 6868 {
6869 if (!expecting_tls_get_addr
6870 && rel != relstart
6871 && ((ELF64_R_TYPE (rel[-1].r_info)
6872 == R_PPC64_TOC16)
6873 || (ELF64_R_TYPE (rel[-1].r_info)
6874 == R_PPC64_TOC16_LO)))
6875 {
6876 /* Check for toc tls entries. */
6877 char *toc_tls;
951fd09b 6878 int retval;
411e1bfb 6879
0d4792f7 6880 retval = get_tls_mask (&toc_tls, NULL, &locsyms,
951fd09b
AM		 6881 rel - 1, ibfd);
6882 if (retval == 0)
411e1bfb 6883 goto err_free_rel;
30038c59
AM		 6884 if (retval > 1 && toc_tls != NULL)
6885 {
6886 expecting_tls_get_addr = 1;
6887 if (toc_ref != NULL)
6888 toc_ref[toc_ref_index] = 1;
6889 }
411e1bfb
AM		 6890 }
6891
6892 if (expecting_tls_get_addr)
6893 {
6894 struct plt_entry *ent;
6895 for (ent = h->plt.plist; ent; ent = ent->next)
6896 if (ent->addend == 0)
6897 {
6898 if (ent->plt.refcount > 0)
6899 ent->plt.refcount -= 1;
6900 break;
6901 }
6902 }
6903 }
6904 expecting_tls_get_addr = 0;
6905 continue;
6906
30038c59
AM		 6907 case R_PPC64_TOC16:
6908 case R_PPC64_TOC16_LO:
6909 case R_PPC64_TLS:
6910 expecting_tls_get_addr = 0;
6911 if (sym_sec == toc && toc != NULL)
6912 {
6913 /* Mark this toc entry as referenced by a TLS
6914 code sequence. We can do that now in the
6915 case of R_PPC64_TLS, and after checking for
6916 tls_get_addr for the TOC16 relocs. */
6917 if (toc_ref == NULL)
6918 {
6919 toc_ref = bfd_zmalloc (toc->size / 8);
6920 if (toc_ref == NULL)
6921 goto err_free_rel;
6922 }
6923 if (h != NULL)
6924 value = h->root.u.def.value;
6925 else
6926 value = sym->st_value;
6927 value += rel->r_addend;
6928 BFD_ASSERT (value < toc->size && value % 8 == 0);
6929 toc_ref_index = value / 8;
6930 if (r_type == R_PPC64_TLS)
6931 toc_ref[toc_ref_index] = 1;
6932 }
6933 continue;
6934
411e1bfb
AM		 6935 case R_PPC64_TPREL64:
6936 expecting_tls_get_addr = 0;
30038c59
AM		 6937 if (sec != toc
6938 || toc_ref == NULL
6939 || !toc_ref[rel->r_offset / 8])
6940 continue;
411e1bfb
AM		 6941 if (ok_tprel)
6942 {
6943 /* IE -> LE */
6944 tls_set = TLS_EXPLICIT;
6945 tls_clear = TLS_TPREL;
6946 break;
6947 }
6948 else
6949 continue;
6950
6951 case R_PPC64_DTPMOD64:
6952 expecting_tls_get_addr = 0;
30038c59
AM		 6953 if (sec != toc
6954 || toc_ref == NULL
6955 || !toc_ref[rel->r_offset / 8])
6956 continue;
951fd09b
AM		 6957 if (rel + 1 < relend
6958 && (rel[1].r_info
6959 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
6960 && rel[1].r_offset == rel->r_offset + 8)
411e1bfb 6961 {
951fd09b 6962 if (ok_tprel)
411e1bfb 6963 /* GD -> LE */
951fd09b 6964 tls_set = TLS_EXPLICIT | TLS_GD;
411e1bfb
AM		 6965 else
6966 /* GD -> IE */
951fd09b
AM		 6967 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
6968 tls_clear = TLS_GD;
411e1bfb
AM		 6969 }
6970 else
6971 {
951fd09b
AM		 6972 if (!is_local)
6973 continue;
6974
6975 /* LD -> LE */
6976 tls_set = TLS_EXPLICIT;
6977 tls_clear = TLS_LD;
411e1bfb
AM		 6978 }
6979 break;
6980
6981 default:
6982 expecting_tls_get_addr = 0;
6983 continue;
6984 }
6985
6986 if ((tls_set & TLS_EXPLICIT) == 0)
6987 {
6988 struct got_entry *ent;
6989
6990 /* Adjust got entry for this reloc. */
6991 if (h != NULL)
6992 ent = h->got.glist;
6993 else
6994 ent = elf_local_got_ents (ibfd)[r_symndx];
6995
6996 for (; ent != NULL; ent = ent->next)
6997 if (ent->addend == rel->r_addend
e717da7e 6998 && ent->owner == ibfd
e7b938ca 6999 && ent->tls_type == tls_type)
411e1bfb
AM		 7000 break;
7001 if (ent == NULL)
7002 abort ();
7003
7004 if (tls_set == 0)
7005 {
7006 /* We managed to get rid of a got entry. */
7007 if (ent->got.refcount > 0)
7008 ent->got.refcount -= 1;
7009 }
411e1bfb 7010 }
8c1d1bb8 7011 else
411e1bfb 7012 {
8c1d1bb8
AM		 7013 /* If we got rid of a DTPMOD/DTPREL reloc pair then
7014 we'll lose one or two dyn relocs. */
7015 if (!dec_dynrel_count (rel->r_info, sec, info,
7016 NULL, h, sym_sec))
7017 return FALSE;
7018
7019 if (tls_set == (TLS_EXPLICIT | TLS_GD))
7020 {
7021 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
7022 NULL, h, sym_sec))
7023 return FALSE;
7024 }
411e1bfb
AM		 7025 }
7026
e7b938ca
AM		 7027 *tls_mask |= tls_set;
7028 *tls_mask &= ~tls_clear;
411e1bfb
AM		 7029 }
7030
7031 if (elf_section_data (sec)->relocs != relstart)
7032 free (relstart);
7033 }
7034
30038c59
AM		 7035 if (toc_ref != NULL)
7036 free (toc_ref);
7037
411e1bfb
AM		 7038 if (locsyms != NULL
7039 && (elf_tdata (ibfd)->symtab_hdr.contents
7040 != (unsigned char *) locsyms))
6cdc0ccc
AM		 7041 {
7042 if (!info->keep_memory)
411e1bfb 7043 free (locsyms);
6cdc0ccc 7044 else
411e1bfb 7045 elf_tdata (ibfd)->symtab_hdr.contents = (unsigned char *) locsyms;
6cdc0ccc 7046 }
1e2f5b6e 7047 }
b34976b6 7048 return TRUE;
1e2f5b6e 7049}
b34976b6 7050
c5614fa4
AM		 7051/* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
7052 the values of any global symbols in a toc section that has been
7053 edited. Globals in toc sections should be a rarity, so this function
7054 sets a flag if any are found in toc sections other than the one just
7055 edited, so that futher hash table traversals can be avoided. */
7056
7057struct adjust_toc_info
7058{
7059 asection *toc;
7060 unsigned long *skip;
7061 bfd_boolean global_toc_syms;
7062};
7063
7064static bfd_boolean
7065adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
7066{
7067 struct ppc_link_hash_entry *eh;
7068 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
7069
7070 if (h->root.type == bfd_link_hash_indirect)
7071 return TRUE;
7072
7073 if (h->root.type == bfd_link_hash_warning)
7074 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7075
7076 if (h->root.type != bfd_link_hash_defined
7077 && h->root.type != bfd_link_hash_defweak)
7078 return TRUE;
7079
7080 eh = (struct ppc_link_hash_entry *) h;
7081 if (eh->adjust_done)
7082 return TRUE;
7083
7084 if (eh->elf.root.u.def.section == toc_inf->toc)
7085 {
7086 unsigned long skip = toc_inf->skip[eh->elf.root.u.def.value >> 3];
7087 if (skip != (unsigned long) -1)
7088 eh->elf.root.u.def.value -= skip;
7089 else
7090 {
7091 (*_bfd_error_handler)
7092 (_("%s defined in removed toc entry"), eh->elf.root.root.string);
7093 eh->elf.root.u.def.section = &bfd_abs_section;
7094 eh->elf.root.u.def.value = 0;
7095 }
7096 eh->adjust_done = 1;
7097 }
7098 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
7099 toc_inf->global_toc_syms = TRUE;
7100
7101 return TRUE;
7102}
7103
7104/* Examine all relocs referencing .toc sections in order to remove
7105 unused .toc entries. */
7106
7107bfd_boolean
7108ppc64_elf_edit_toc (bfd *obfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
7109{
7110 bfd *ibfd;
7111 struct adjust_toc_info toc_inf;
7112
7113 toc_inf.global_toc_syms = TRUE;
7114 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7115 {
7116 asection *toc, *sec;
7117 Elf_Internal_Shdr *symtab_hdr;
7118 Elf_Internal_Sym *local_syms;
7119 struct elf_link_hash_entry **sym_hashes;
92b7a70f 7120 Elf_Internal_Rela *relstart, *rel;
c5614fa4
AM		 7121 unsigned long *skip, *drop;
7122 unsigned char *used;
7123 unsigned char *keep, last, some_unused;
7124
7125 toc = bfd_get_section_by_name (ibfd, ".toc");
7126 if (toc == NULL
92b7a70f 7127 || toc->size == 0
c5614fa4
AM		 7128 || toc->sec_info_type == ELF_INFO_TYPE_JUST_SYMS
7129 || elf_discarded_section (toc))
7130 continue;
7131
7132 local_syms = NULL;
7133 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
7134 sym_hashes = elf_sym_hashes (ibfd);
7135
7136 /* Look at sections dropped from the final link. */
7137 skip = NULL;
7138 relstart = NULL;
7139 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7140 {
7141 if (sec->reloc_count == 0
7142 || !elf_discarded_section (sec)
7143 || get_opd_info (sec)
7144 || (sec->flags & SEC_ALLOC) == 0
7145 || (sec->flags & SEC_DEBUGGING) != 0)
7146 continue;
7147
7148 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
7149 if (relstart == NULL)
7150 goto error_ret;
7151
7152 /* Run through the relocs to see which toc entries might be
7153 unused. */
7154 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7155 {
7156 enum elf_ppc64_reloc_type r_type;
7157 unsigned long r_symndx;
7158 asection *sym_sec;
7159 struct elf_link_hash_entry *h;
7160 Elf_Internal_Sym *sym;
7161 bfd_vma val;
7162
7163 r_type = ELF64_R_TYPE (rel->r_info);
7164 switch (r_type)
7165 {
7166 default:
7167 continue;
7168
7169 case R_PPC64_TOC16:
7170 case R_PPC64_TOC16_LO:
7171 case R_PPC64_TOC16_HI:
7172 case R_PPC64_TOC16_HA:
7173 case R_PPC64_TOC16_DS:
7174 case R_PPC64_TOC16_LO_DS:
7175 break;
7176 }
7177
7178 r_symndx = ELF64_R_SYM (rel->r_info);
7179 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7180 r_symndx, ibfd))
7181 goto error_ret;
7182
7183 if (sym_sec != toc)
7184 continue;
7185
7186 if (h != NULL)
7187 val = h->root.u.def.value;
7188 else
7189 val = sym->st_value;
7190 val += rel->r_addend;
7191
7192 if (val >= toc->size)
7193 continue;
7194
7195 /* Anything in the toc ought to be aligned to 8 bytes.
7196 If not, don't mark as unused. */
7197 if (val & 7)
7198 continue;
7199
7200 if (skip == NULL)
7201 {
7202 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 7) / 8);
7203 if (skip == NULL)
7204 goto error_ret;
7205 }
7206
7207 skip[val >> 3] = 1;
7208 }
7209
7210 if (elf_section_data (sec)->relocs != relstart)
7211 free (relstart);
7212 }
7213
7214 if (skip == NULL)
7215 continue;
7216
7217 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
7218 if (used == NULL)
7219 {
7220 error_ret:
7221 if (local_syms != NULL
7222 && symtab_hdr->contents != (unsigned char *) local_syms)
7223 free (local_syms);
7224 if (sec != NULL
7225 && relstart != NULL
7226 && elf_section_data (sec)->relocs != relstart)
7227 free (relstart);
7228 if (skip != NULL)
7229 free (skip);
7230 return FALSE;
7231 }
7232
30038c59
AM		 7233 /* Now check all kept sections that might reference the toc.
7234 Check the toc itself last. */
7235 for (sec = (ibfd->sections == toc && toc->next ? toc->next
7236 : ibfd->sections);
c5614fa4 7237 sec != NULL;
c5614fa4 7238 sec = (sec == toc ? NULL
c5614fa4 7239 : sec->next == NULL ? toc
30038c59 7240 : sec->next == toc && toc->next ? toc->next
c5614fa4
AM		 7241 : sec->next))
7242 {
7243 int repeat;
7244
7245 if (sec->reloc_count == 0
7246 || elf_discarded_section (sec)
7247 || get_opd_info (sec)
7248 || (sec->flags & SEC_ALLOC) == 0
7249 || (sec->flags & SEC_DEBUGGING) != 0)
7250 continue;
7251
7252 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, TRUE);
7253 if (relstart == NULL)
7254 goto error_ret;
7255
7256 /* Mark toc entries referenced as used. */
7257 repeat = 0;
7258 do
7259 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7260 {
7261 enum elf_ppc64_reloc_type r_type;
7262 unsigned long r_symndx;
7263 asection *sym_sec;
7264 struct elf_link_hash_entry *h;
7265 Elf_Internal_Sym *sym;
7266 bfd_vma val;
7267
7268 r_type = ELF64_R_TYPE (rel->r_info);
7269 switch (r_type)
7270 {
7271 case R_PPC64_TOC16:
7272 case R_PPC64_TOC16_LO:
7273 case R_PPC64_TOC16_HI:
7274 case R_PPC64_TOC16_HA:
7275 case R_PPC64_TOC16_DS:
7276 case R_PPC64_TOC16_LO_DS:
7277 /* In case we're taking addresses of toc entries. */
7278 case R_PPC64_ADDR64:
7279 break;
7280
7281 default:
7282 continue;
7283 }
7284
7285 r_symndx = ELF64_R_SYM (rel->r_info);
7286 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7287 r_symndx, ibfd))
7288 {
7289 free (used);
7290 goto error_ret;
7291 }
7292
7293 if (sym_sec != toc)
7294 continue;
7295
7296 if (h != NULL)
7297 val = h->root.u.def.value;
7298 else
7299 val = sym->st_value;
7300 val += rel->r_addend;
7301
7302 if (val >= toc->size)
7303 continue;
7304
7305 /* For the toc section, we only mark as used if
7306 this entry itself isn't unused. */
7307 if (sec == toc
7308 && !used[val >> 3]
7309 && (used[rel->r_offset >> 3]
7310 || !skip[rel->r_offset >> 3]))
7311 /* Do all the relocs again, to catch reference
7312 chains. */
7313 repeat = 1;
7314
7315 used[val >> 3] = 1;
7316 }
7317 while (repeat);
7318 }
7319
7320 /* Merge the used and skip arrays. Assume that TOC
7321 doublewords not appearing as either used or unused belong
7322 to to an entry more than one doubleword in size. */
7323 for (drop = skip, keep = used, last = 0, some_unused = 0;
7324 drop < skip + (toc->size + 7) / 8;
7325 ++drop, ++keep)
7326 {
7327 if (*keep)
7328 {
7329 *drop = 0;
7330 last = 0;
7331 }
7332 else if (*drop)
7333 {
7334 some_unused = 1;
7335 last = 1;
7336 }
7337 else
7338 *drop = last;
7339 }
7340
7341 free (used);
7342
7343 if (some_unused)
7344 {
7345 bfd_byte *contents, *src;
7346 unsigned long off;
7347
7348 /* Shuffle the toc contents, and at the same time convert the
7349 skip array from booleans into offsets. */
7350 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
7351 goto error_ret;
7352
7353 elf_section_data (toc)->this_hdr.contents = contents;
7354
7355 for (src = contents, off = 0, drop = skip;
7356 src < contents + toc->size;
7357 src += 8, ++drop)
7358 {
7359 if (*drop)
7360 {
7361 *drop = (unsigned long) -1;
7362 off += 8;
7363 }
7364 else if (off != 0)
7365 {
7366 *drop = off;
7367 memcpy (src - off, src, 8);
7368 }
7369 }
7370 toc->rawsize = toc->size;
7371 toc->size = src - contents - off;
7372
92b7a70f
AM		 7373 if (toc->reloc_count != 0)
7374 {
7375 Elf_Internal_Rela *wrel;
7376 bfd_size_type sz;
c5614fa4 7377
92b7a70f
AM		 7378 /* Read toc relocs. */
7379 relstart = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
7380 TRUE);
7381 if (relstart == NULL)
7382 goto error_ret;
7383
7384 /* Remove unused toc relocs, and adjust those we keep. */
7385 wrel = relstart;
7386 for (rel = relstart; rel < relstart + toc->reloc_count; ++rel)
7387 if (skip[rel->r_offset >> 3] != (unsigned long) -1)
7388 {
7389 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
7390 wrel->r_info = rel->r_info;
7391 wrel->r_addend = rel->r_addend;
7392 ++wrel;
7393 }
8c1d1bb8
AM		 7394 else if (!dec_dynrel_count (rel->r_info, toc, info,
7395 &local_syms, NULL, NULL))
7396 goto error_ret;
35090471 7397
92b7a70f
AM		 7398 toc->reloc_count = wrel - relstart;
7399 sz = elf_section_data (toc)->rel_hdr.sh_entsize;
7400 elf_section_data (toc)->rel_hdr.sh_size = toc->reloc_count * sz;
7401 BFD_ASSERT (elf_section_data (toc)->rel_hdr2 == NULL);
7402 }
c5614fa4
AM		 7403
7404 /* Adjust addends for relocs against the toc section sym. */
7405 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7406 {
7407 if (sec->reloc_count == 0
7408 || elf_discarded_section (sec))
7409 continue;
7410
7411 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7412 TRUE);
7413 if (relstart == NULL)
7414 goto error_ret;
7415
7416 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7417 {
7418 enum elf_ppc64_reloc_type r_type;
7419 unsigned long r_symndx;
7420 asection *sym_sec;
7421 struct elf_link_hash_entry *h;
7422 Elf_Internal_Sym *sym;
7423
7424 r_type = ELF64_R_TYPE (rel->r_info);
7425 switch (r_type)
7426 {
7427 default:
7428 continue;
7429
7430 case R_PPC64_TOC16:
7431 case R_PPC64_TOC16_LO:
7432 case R_PPC64_TOC16_HI:
7433 case R_PPC64_TOC16_HA:
7434 case R_PPC64_TOC16_DS:
7435 case R_PPC64_TOC16_LO_DS:
7436 case R_PPC64_ADDR64:
7437 break;
7438 }
7439
7440 r_symndx = ELF64_R_SYM (rel->r_info);
7441 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7442 r_symndx, ibfd))
7443 goto error_ret;
7444
7445 if (sym_sec != toc || h != NULL || sym->st_value != 0)
7446 continue;
7447
7448 rel->r_addend -= skip[rel->r_addend >> 3];
7449 }
7450 }
7451
7452 /* We shouldn't have local or global symbols defined in the TOC,
7453 but handle them anyway. */
7454 if (local_syms != NULL)
7455 {
7456 Elf_Internal_Sym *sym;
7457
7458 for (sym = local_syms;
7459 sym < local_syms + symtab_hdr->sh_info;
7460 ++sym)
7461 if (sym->st_shndx != SHN_UNDEF
7462 && (sym->st_shndx < SHN_LORESERVE
7463 || sym->st_shndx > SHN_HIRESERVE)
7464 && sym->st_value != 0
7465 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
7466 {
7467 if (skip[sym->st_value >> 3] != (unsigned long) -1)
7468 sym->st_value -= skip[sym->st_value >> 3];
7469 else
7470 {
7471 (*_bfd_error_handler)
7472 (_("%s defined in removed toc entry"),
26c61ae5
L		 7473 bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7474 NULL));
c5614fa4
AM		 7475 sym->st_value = 0;
7476 sym->st_shndx = SHN_ABS;
7477 }
7478 symtab_hdr->contents = (unsigned char *) local_syms;
7479 }
7480 }
7481
7482 /* Finally, adjust any global syms defined in the toc. */
7483 if (toc_inf.global_toc_syms)
7484 {
7485 toc_inf.toc = toc;
7486 toc_inf.skip = skip;
7487 toc_inf.global_toc_syms = FALSE;
7488 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
7489 &toc_inf);
7490 }
7491 }
7492
7493 if (local_syms != NULL
7494 && symtab_hdr->contents != (unsigned char *) local_syms)
7495 {
7496 if (!info->keep_memory)
7497 free (local_syms);
7498 else
7499 symtab_hdr->contents = (unsigned char *) local_syms;
7500 }
7501 free (skip);
7502 }
7503
7504 return TRUE;
7505}
7506
65f38f15
AM		 7507/* Allocate space in .plt, .got and associated reloc sections for
7508 dynamic relocs. */
5bd4f169 7509
b34976b6 7510static bfd_boolean
4ce794b7 7511allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
5bd4f169 7512{
65f38f15
AM		 7513 struct bfd_link_info *info;
7514 struct ppc_link_hash_table *htab;
5bd4f169 7515 asection *s;
65f38f15
AM		 7516 struct ppc_link_hash_entry *eh;
7517 struct ppc_dyn_relocs *p;
411e1bfb 7518 struct got_entry *gent;
5bd4f169 7519
e92d460e 7520 if (h->root.type == bfd_link_hash_indirect)
b34976b6 7521 return TRUE;
5bd4f169 7522
e92d460e
AM		 7523 if (h->root.type == bfd_link_hash_warning)
7524 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7525
65f38f15
AM		 7526 info = (struct bfd_link_info *) inf;
7527 htab = ppc_hash_table (info);
5bd4f169 7528
65f38f15 7529 if (htab->elf.dynamic_sections_created
411e1bfb 7530 && h->dynindx != -1
9c7a29a3 7531 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
5bd4f169 7532 {
411e1bfb
AM		 7533 struct plt_entry *pent;
7534 bfd_boolean doneone = FALSE;
7535 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7536 if (pent->plt.refcount > 0)
7537 {
411e1bfb
AM		 7538 /* If this is the first .plt entry, make room for the special
7539 first entry. */
4ce794b7 7540 s = htab->plt;
eea6121a
AM		 7541 if (s->size == 0)
7542 s->size += PLT_INITIAL_ENTRY_SIZE;
411e1bfb 7543
eea6121a 7544 pent->plt.offset = s->size;
411e1bfb
AM		 7545
7546 /* Make room for this entry. */
eea6121a 7547 s->size += PLT_ENTRY_SIZE;
411e1bfb
AM		 7548
7549 /* Make room for the .glink code. */
4ce794b7 7550 s = htab->glink;
eea6121a
AM		 7551 if (s->size == 0)
7552 s->size += GLINK_CALL_STUB_SIZE;
411e1bfb 7553 /* We need bigger stubs past index 32767. */
eea6121a
AM		 7554 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
7555 s->size += 4;
7556 s->size += 2*4;
411e1bfb
AM		 7557
7558 /* We also need to make an entry in the .rela.plt section. */
4ce794b7 7559 s = htab->relplt;
eea6121a 7560 s->size += sizeof (Elf64_External_Rela);
411e1bfb
AM		 7561 doneone = TRUE;
7562 }
7563 else
7564 pent->plt.offset = (bfd_vma) -1;
7565 if (!doneone)
65f38f15 7566 {
411e1bfb 7567 h->plt.plist = NULL;
f5385ebf 7568 h->needs_plt = 0;
65f38f15
AM		 7569 }
7570 }
7571 else
7572 {
411e1bfb 7573 h->plt.plist = NULL;
f5385ebf 7574 h->needs_plt = 0;
65f38f15
AM		 7575 }
7576
951fd09b
AM		 7577 eh = (struct ppc_link_hash_entry *) h;
7578 /* Run through the TLS GD got entries first if we're changing them
7579 to TPREL. */
e7b938ca 7580 if ((eh->tls_mask & TLS_TPRELGD) != 0)
951fd09b
AM		 7581 for (gent = h->got.glist; gent != NULL; gent = gent->next)
7582 if (gent->got.refcount > 0
7583 && (gent->tls_type & TLS_GD) != 0)
7584 {
7585 /* This was a GD entry that has been converted to TPREL. If
7586 there happens to be a TPREL entry we can use that one. */
7587 struct got_entry *ent;
7588 for (ent = h->got.glist; ent != NULL; ent = ent->next)
7589 if (ent->got.refcount > 0
7590 && (ent->tls_type & TLS_TPREL) != 0
e717da7e
AM		 7591 && ent->addend == gent->addend
7592 && ent->owner == gent->owner)
951fd09b
AM		 7593 {
7594 gent->got.refcount = 0;
7595 break;
7596 }
7597
7598 /* If not, then we'll be using our own TPREL entry. */
7599 if (gent->got.refcount != 0)
7600 gent->tls_type = TLS_TLS | TLS_TPREL;
7601 }
7602
411e1bfb
AM		 7603 for (gent = h->got.glist; gent != NULL; gent = gent->next)
7604 if (gent->got.refcount > 0)
7605 {
951fd09b
AM		 7606 bfd_boolean dyn;
7607
411e1bfb 7608 /* Make sure this symbol is output as a dynamic symbol.
951fd09b
AM		 7609 Undefined weak syms won't yet be marked as dynamic,
7610 nor will all TLS symbols. */
411e1bfb 7611 if (h->dynindx == -1
f5385ebf 7612 && !h->forced_local)
411e1bfb 7613 {
c152c796 7614 if (! bfd_elf_link_record_dynamic_symbol (info, h))
411e1bfb
AM		 7615 return FALSE;
7616 }
65f38f15 7617
d881513a 7618 if ((gent->tls_type & TLS_LD) != 0
f5385ebf 7619 && !h->def_dynamic)
411e1bfb 7620 {
e717da7e 7621 gent->got.offset = ppc64_tlsld_got (gent->owner)->offset;
951fd09b 7622 continue;
411e1bfb 7623 }
951fd09b 7624
e717da7e 7625 s = ppc64_elf_tdata (gent->owner)->got;
eea6121a
AM		 7626 gent->got.offset = s->size;
7627 s->size
d881513a 7628 += (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)) ? 16 : 8;
951fd09b 7629 dyn = htab->elf.dynamic_sections_created;
4e795f50
AM		 7630 if ((info->shared
7631 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
7632 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
7633 || h->root.type != bfd_link_hash_undefweak))
eea6121a 7634 ppc64_elf_tdata (gent->owner)->relgot->size
e7b938ca 7635 += (gent->tls_type & eh->tls_mask & TLS_GD
951fd09b
AM		 7636 ? 2 * sizeof (Elf64_External_Rela)
7637 : sizeof (Elf64_External_Rela));
411e1bfb
AM		 7638 }
7639 else
7640 gent->got.offset = (bfd_vma) -1;
65f38f15 7641
65f38f15 7642 if (eh->dyn_relocs == NULL)
b34976b6 7643 return TRUE;
65f38f15
AM		 7644
7645 /* In the shared -Bsymbolic case, discard space allocated for
7646 dynamic pc-relative relocs against symbols which turn out to be
7647 defined in regular objects. For the normal shared case, discard
7648 space for relocs that have become local due to symbol visibility
7649 changes. */
7650
7651 if (info->shared)
7652 {
9c7a29a3
AM		 7653 /* Relocs that use pc_count are those that appear on a call insn,
7654 or certain REL relocs (see MUST_BE_DYN_RELOC) that can be
7655 generated via assembly. We want calls to protected symbols to
7656 resolve directly to the function rather than going via the plt.
7657 If people want function pointer comparisons to work as expected
7658 then they should avoid writing weird assembly. */
09695f56 7659 if (SYMBOL_CALLS_LOCAL (info, h))
65f38f15
AM		 7660 {
7661 struct ppc_dyn_relocs **pp;
7662
7663 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
5bd4f169 7664 {
65f38f15
AM		 7665 p->count -= p->pc_count;
7666 p->pc_count = 0;
7667 if (p->count == 0)
7668 *pp = p->next;
7669 else
7670 pp = &p->next;
5bd4f169 7671 }
65f38f15 7672 }
4e795f50
AM		 7673
7674 /* Also discard relocs on undefined weak syms with non-default
7675 visibility. */
cab87ef9
AM		 7676 if (eh->dyn_relocs != NULL
7677 && h->root.type == bfd_link_hash_undefweak)
dfbb6ac9
AM		 7678 {
7679 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
7680 eh->dyn_relocs = NULL;
7681
7682 /* Make sure this symbol is output as a dynamic symbol.
7683 Undefined weak syms won't yet be marked as dynamic. */
7684 else if (h->dynindx == -1
7685 && !h->forced_local)
7686 {
7687 if (! bfd_elf_link_record_dynamic_symbol (info, h))
7688 return FALSE;
7689 }
7690 }
65f38f15 7691 }
f4656909 7692 else if (ELIMINATE_COPY_RELOCS)
65f38f15
AM		 7693 {
7694 /* For the non-shared case, discard space for relocs against
7695 symbols which turn out to need copy relocs or are not
7696 dynamic. */
7697
f5385ebf
AM		 7698 if (!h->non_got_ref
7699 && h->def_dynamic
7700 && !h->def_regular)
65f38f15
AM		 7701 {
7702 /* Make sure this symbol is output as a dynamic symbol.
7703 Undefined weak syms won't yet be marked as dynamic. */
7704 if (h->dynindx == -1
f5385ebf 7705 && !h->forced_local)
65f38f15 7706 {
c152c796 7707 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 7708 return FALSE;
65f38f15
AM		 7709 }
7710
7711 /* If that succeeded, we know we'll be keeping all the
7712 relocs. */
7713 if (h->dynindx != -1)
7714 goto keep;
7715 }
7716
7717 eh->dyn_relocs = NULL;
7718
ec338859 7719 keep: ;
65f38f15
AM		 7720 }
7721
7722 /* Finally, allocate space. */
7723 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7724 {
7725 asection *sreloc = elf_section_data (p->sec)->sreloc;
eea6121a 7726 sreloc->size += p->count * sizeof (Elf64_External_Rela);
65f38f15
AM		 7727 }
7728
b34976b6 7729 return TRUE;
65f38f15
AM		 7730}
7731
7732/* Find any dynamic relocs that apply to read-only sections. */
7733
b34976b6 7734static bfd_boolean
4ce794b7 7735readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
65f38f15
AM		 7736{
7737 struct ppc_link_hash_entry *eh;
7738 struct ppc_dyn_relocs *p;
7739
e92d460e
AM		 7740 if (h->root.type == bfd_link_hash_warning)
7741 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7742
65f38f15
AM		 7743 eh = (struct ppc_link_hash_entry *) h;
7744 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7745 {
7746 asection *s = p->sec->output_section;
7747
7748 if (s != NULL && (s->flags & SEC_READONLY) != 0)
7749 {
4ce794b7 7750 struct bfd_link_info *info = inf;
65f38f15
AM		 7751
7752 info->flags |= DF_TEXTREL;
7753
7754 /* Not an error, just cut short the traversal. */
b34976b6 7755 return FALSE;
65f38f15
AM		 7756 }
7757 }
b34976b6 7758 return TRUE;
65f38f15
AM		 7759}
7760
7761/* Set the sizes of the dynamic sections. */
7762
b34976b6 7763static bfd_boolean
4ce794b7
AM		 7764ppc64_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
7765 struct bfd_link_info *info)
65f38f15
AM		 7766{
7767 struct ppc_link_hash_table *htab;
7768 bfd *dynobj;
7769 asection *s;
b34976b6 7770 bfd_boolean relocs;
65f38f15
AM		 7771 bfd *ibfd;
7772
7773 htab = ppc_hash_table (info);
7774 dynobj = htab->elf.dynobj;
7775 if (dynobj == NULL)
7776 abort ();
7777
7778 if (htab->elf.dynamic_sections_created)
7779 {
7780 /* Set the contents of the .interp section to the interpreter. */
36af4a4e 7781 if (info->executable)
65f38f15
AM		 7782 {
7783 s = bfd_get_section_by_name (dynobj, ".interp");
7784 if (s == NULL)
7785 abort ();
eea6121a 7786 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
65f38f15
AM		 7787 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
7788 }
7789 }
7790
7791 /* Set up .got offsets for local syms, and space for local dynamic
7792 relocs. */
7793 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7794 {
411e1bfb
AM		 7795 struct got_entry **lgot_ents;
7796 struct got_entry **end_lgot_ents;
e7b938ca 7797 char *lgot_masks;
65f38f15
AM		 7798 bfd_size_type locsymcount;
7799 Elf_Internal_Shdr *symtab_hdr;
7800 asection *srel;
7801
ee75fd95 7802 if (!is_ppc64_elf_target (ibfd->xvec))
65f38f15
AM		 7803 continue;
7804
e717da7e
AM		 7805 if (ppc64_tlsld_got (ibfd)->refcount > 0)
7806 {
7807 s = ppc64_elf_tdata (ibfd)->got;
eea6121a
AM		 7808 ppc64_tlsld_got (ibfd)->offset = s->size;
7809 s->size += 16;
e717da7e
AM		 7810 if (info->shared)
7811 {
7812 srel = ppc64_elf_tdata (ibfd)->relgot;
eea6121a 7813 srel->size += sizeof (Elf64_External_Rela);
e717da7e
AM		 7814 }
7815 }
7816 else
7817 ppc64_tlsld_got (ibfd)->offset = (bfd_vma) -1;
7818
65f38f15
AM		 7819 for (s = ibfd->sections; s != NULL; s = s->next)
7820 {
ec338859 7821 struct ppc_dyn_relocs *p;
65f38f15 7822
6edfbbad 7823 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
65f38f15 7824 {
ec338859
AM		 7825 if (!bfd_is_abs_section (p->sec)
7826 && bfd_is_abs_section (p->sec->output_section))
7827 {
7828 /* Input section has been discarded, either because
7829 it is a copy of a linkonce section or due to
7830 linker script /DISCARD/, so we'll be discarding
7831 the relocs too. */
7832 }
248866a8 7833 else if (p->count != 0)
ec338859
AM		 7834 {
7835 srel = elf_section_data (p->sec)->sreloc;
eea6121a 7836 srel->size += p->count * sizeof (Elf64_External_Rela);
248866a8
AM		 7837 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
7838 info->flags |= DF_TEXTREL;
ec338859 7839 }
65f38f15
AM		 7840 }
7841 }
7842
411e1bfb
AM		 7843 lgot_ents = elf_local_got_ents (ibfd);
7844 if (!lgot_ents)
65f38f15
AM		 7845 continue;
7846
7847 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
7848 locsymcount = symtab_hdr->sh_info;
411e1bfb 7849 end_lgot_ents = lgot_ents + locsymcount;
e7b938ca 7850 lgot_masks = (char *) end_lgot_ents;
e717da7e
AM		 7851 s = ppc64_elf_tdata (ibfd)->got;
7852 srel = ppc64_elf_tdata (ibfd)->relgot;
e7b938ca 7853 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
65f38f15 7854 {
411e1bfb
AM		 7855 struct got_entry *ent;
7856
7857 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
7858 if (ent->got.refcount > 0)
7859 {
e7b938ca 7860 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
411e1bfb 7861 {
e717da7e 7862 if (ppc64_tlsld_got (ibfd)->offset == (bfd_vma) -1)
411e1bfb 7863 {
eea6121a
AM		 7864 ppc64_tlsld_got (ibfd)->offset = s->size;
7865 s->size += 16;
411e1bfb 7866 if (info->shared)
eea6121a 7867 srel->size += sizeof (Elf64_External_Rela);
411e1bfb 7868 }
e717da7e 7869 ent->got.offset = ppc64_tlsld_got (ibfd)->offset;
411e1bfb
AM		 7870 }
7871 else
7872 {
eea6121a 7873 ent->got.offset = s->size;
e7b938ca 7874 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
411e1bfb 7875 {
eea6121a 7876 s->size += 16;
411e1bfb 7877 if (info->shared)
eea6121a 7878 srel->size += 2 * sizeof (Elf64_External_Rela);
411e1bfb
AM		 7879 }
7880 else
7881 {
eea6121a 7882 s->size += 8;
411e1bfb 7883 if (info->shared)
eea6121a 7884 srel->size += sizeof (Elf64_External_Rela);
411e1bfb
AM		 7885 }
7886 }
7887 }
7888 else
7889 ent->got.offset = (bfd_vma) -1;
65f38f15
AM		 7890 }
7891 }
7892
7893 /* Allocate global sym .plt and .got entries, and space for global
7894 sym dynamic relocs. */
4ce794b7 7895 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
65f38f15
AM		 7896
7897 /* We now have determined the sizes of the various dynamic sections.
7898 Allocate memory for them. */
b34976b6 7899 relocs = FALSE;
65f38f15
AM		 7900 for (s = dynobj->sections; s != NULL; s = s->next)
7901 {
7902 if ((s->flags & SEC_LINKER_CREATED) == 0)
7903 continue;
7904
4ce794b7 7905 if (s == htab->brlt || s == htab->relbrlt)
721956f4
AM		 7906 /* These haven't been allocated yet; don't strip. */
7907 continue;
e717da7e
AM		 7908 else if (s == htab->got
7909 || s == htab->plt
c456f082
AM		 7910 || s == htab->glink
7911 || s == htab->dynbss)
65f38f15
AM		 7912 {
7913 /* Strip this section if we don't need it; see the
7914 comment below. */
5bd4f169 7915 }
65f38f15 7916 else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
5bd4f169 7917 {
c456f082 7918 if (s->size != 0)
5bd4f169 7919 {
4ce794b7 7920 if (s != htab->relplt)
b34976b6 7921 relocs = TRUE;
5bd4f169
AM		 7922
7923 /* We use the reloc_count field as a counter if we need
7924 to copy relocs into the output file. */
7925 s->reloc_count = 0;
7926 }
7927 }
65f38f15 7928 else
5bd4f169
AM		 7929 {
7930 /* It's not one of our sections, so don't allocate space. */
7931 continue;
7932 }
7933
eea6121a 7934 if (s->size == 0)
5bd4f169 7935 {
c456f082
AM		 7936 /* If we don't need this section, strip it from the
7937 output file. This is mostly to handle .rela.bss and
7938 .rela.plt. We must create both sections in
7939 create_dynamic_sections, because they must be created
7940 before the linker maps input sections to output
7941 sections. The linker does that before
7942 adjust_dynamic_symbol is called, and it is that
7943 function which decides whether anything needs to go
7944 into these sections. */
8423293d 7945 s->flags |= SEC_EXCLUDE;
5bd4f169
AM		 7946 continue;
7947 }
7948
c456f082 7949 if ((s->flags & SEC_HAS_CONTENTS) == 0)
5f333394
AM		 7950 continue;
7951
65f38f15
AM		 7952 /* Allocate memory for the section contents. We use bfd_zalloc
7953 here in case unused entries are not reclaimed before the
7954 section's contents are written out. This should not happen,
411e1bfb
AM		 7955 but this way if it does we get a R_PPC64_NONE reloc in .rela
7956 sections instead of garbage.
7957 We also rely on the section contents being zero when writing
7958 the GOT. */
eea6121a 7959 s->contents = bfd_zalloc (dynobj, s->size);
65f38f15 7960 if (s->contents == NULL)
b34976b6 7961 return FALSE;
5bd4f169
AM		 7962 }
7963
e717da7e
AM		 7964 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7965 {
ee75fd95 7966 if (!is_ppc64_elf_target (ibfd->xvec))
7b53ace3
AM		 7967 continue;
7968
e717da7e
AM		 7969 s = ppc64_elf_tdata (ibfd)->got;
7970 if (s != NULL && s != htab->got)
7971 {
eea6121a 7972 if (s->size == 0)
8423293d 7973 s->flags |= SEC_EXCLUDE;
e717da7e
AM		 7974 else
7975 {
eea6121a 7976 s->contents = bfd_zalloc (ibfd, s->size);
e717da7e
AM		 7977 if (s->contents == NULL)
7978 return FALSE;
7979 }
7980 }
7981 s = ppc64_elf_tdata (ibfd)->relgot;
7982 if (s != NULL)
7983 {
eea6121a 7984 if (s->size == 0)
8423293d 7985 s->flags |= SEC_EXCLUDE;
e717da7e
AM		 7986 else
7987 {
eea6121a 7988 s->contents = bfd_zalloc (ibfd, s->size);
e717da7e
AM		 7989 if (s->contents == NULL)
7990 return FALSE;
7991 relocs = TRUE;
7992 s->reloc_count = 0;
7993 }
7994 }
7995 }
7996
e86ce104 7997 if (htab->elf.dynamic_sections_created)
5bd4f169
AM		 7998 {
7999 /* Add some entries to the .dynamic section. We fill in the
8000 values later, in ppc64_elf_finish_dynamic_sections, but we
8001 must add the entries now so that we get the correct size for
8002 the .dynamic section. The DT_DEBUG entry is filled in by the
8003 dynamic linker and used by the debugger. */
dc810e39 8004#define add_dynamic_entry(TAG, VAL) \
5a580b3a 8005 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
dc810e39 8006
36af4a4e 8007 if (info->executable)
5bd4f169 8008 {
dc810e39 8009 if (!add_dynamic_entry (DT_DEBUG, 0))
b34976b6 8010 return FALSE;
5bd4f169
AM		 8011 }
8012
eea6121a 8013 if (htab->plt != NULL && htab->plt->size != 0)
5bd4f169 8014 {
dc810e39
AM		 8015 if (!add_dynamic_entry (DT_PLTGOT, 0)
8016 || !add_dynamic_entry (DT_PLTRELSZ, 0)
8017 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
5d1634d7
AM		 8018 || !add_dynamic_entry (DT_JMPREL, 0)
8019 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
b34976b6 8020 return FALSE;
5bd4f169
AM		 8021 }
8022
19397422
AM		 8023 if (NO_OPD_RELOCS)
8024 {
8025 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
8026 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
b34976b6 8027 return FALSE;
19397422
AM		 8028 }
8029
5bd4f169
AM		 8030 if (relocs)
8031 {
dc810e39
AM		 8032 if (!add_dynamic_entry (DT_RELA, 0)
8033 || !add_dynamic_entry (DT_RELASZ, 0)
8034 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
b34976b6 8035 return FALSE;
5bd4f169 8036
65f38f15
AM		 8037 /* If any dynamic relocs apply to a read-only section,
8038 then we need a DT_TEXTREL entry. */
248866a8 8039 if ((info->flags & DF_TEXTREL) == 0)
4ce794b7 8040 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
5bd4f169 8041
65f38f15 8042 if ((info->flags & DF_TEXTREL) != 0)
5bd4f169 8043 {
65f38f15 8044 if (!add_dynamic_entry (DT_TEXTREL, 0))
b34976b6 8045 return FALSE;
5bd4f169 8046 }
5bd4f169 8047 }
5bd4f169 8048 }
65f38f15 8049#undef add_dynamic_entry
5bd4f169 8050
b34976b6 8051 return TRUE;
5bd4f169
AM		 8052}
8053
721956f4 8054/* Determine the type of stub needed, if any, for a call. */
5bd4f169 8055
4ce794b7
AM		 8056static inline enum ppc_stub_type
8057ppc_type_of_stub (asection *input_sec,
8058 const Elf_Internal_Rela *rel,
8059 struct ppc_link_hash_entry **hash,
8060 bfd_vma destination)
5bd4f169 8061{
721956f4
AM		 8062 struct ppc_link_hash_entry *h = *hash;
8063 bfd_vma location;
8064 bfd_vma branch_offset;
8065 bfd_vma max_branch_offset;
4ce794b7 8066 enum elf_ppc64_reloc_type r_type;
5bd4f169 8067
721956f4
AM		 8068 if (h != NULL)
8069 {
7fe2b9a6
AM		 8070 struct ppc_link_hash_entry *fdh = h;
8071 if (fdh->oh != NULL
8072 && fdh->oh->is_func_descriptor)
8073 fdh = fdh->oh;
8387904d 8074
7fe2b9a6 8075 if (fdh->elf.dynindx != -1)
5bd4f169 8076 {
411e1bfb 8077 struct plt_entry *ent;
8387904d 8078
7fe2b9a6 8079 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
411e1bfb
AM		 8080 if (ent->addend == rel->r_addend
8081 && ent->plt.offset != (bfd_vma) -1)
8082 {
7fe2b9a6 8083 *hash = fdh;
411e1bfb
AM		 8084 return ppc_stub_plt_call;
8085 }
5bd4f169
AM		 8086 }
8087
7fe2b9a6
AM		 8088 /* Here, we know we don't have a plt entry. If we don't have a
8089 either a defined function descriptor or a defined entry symbol
8090 in a regular object file, then it is pointless trying to make
8091 any other type of stub. */
8092 if (!((fdh->elf.root.type == bfd_link_hash_defined
8093 || fdh->elf.root.type == bfd_link_hash_defweak)
8094 && fdh->elf.root.u.def.section->output_section != NULL)
8095 && !((h->elf.root.type == bfd_link_hash_defined
8096 || h->elf.root.type == bfd_link_hash_defweak)
8097 && h->elf.root.u.def.section->output_section != NULL))
721956f4 8098 return ppc_stub_none;
5d1634d7 8099 }
5d1634d7 8100
721956f4
AM		 8101 /* Determine where the call point is. */
8102 location = (input_sec->output_offset
8103 + input_sec->output_section->vma
8104 + rel->r_offset);
5d1634d7 8105
721956f4
AM		 8106 branch_offset = destination - location;
8107 r_type = ELF64_R_TYPE (rel->r_info);
5d1634d7 8108
721956f4
AM		 8109 /* Determine if a long branch stub is needed. */
8110 max_branch_offset = 1 << 25;
4ce794b7 8111 if (r_type != R_PPC64_REL24)
721956f4 8112 max_branch_offset = 1 << 15;
5d1634d7 8113
721956f4
AM		 8114 if (branch_offset + max_branch_offset >= 2 * max_branch_offset)
8115 /* We need a stub. Figure out whether a long_branch or plt_branch
8116 is needed later. */
8117 return ppc_stub_long_branch;
5d1634d7 8118
721956f4 8119 return ppc_stub_none;
5d1634d7
AM		 8120}
8121
8122/* Build a .plt call stub. */
8123
4ce794b7
AM		 8124static inline bfd_byte *
8125build_plt_stub (bfd *obfd, bfd_byte *p, int offset)
5d1634d7
AM		 8126{
8127#define PPC_LO(v) ((v) & 0xffff)
8128#define PPC_HI(v) (((v) >> 16) & 0xffff)
8129#define PPC_HA(v) PPC_HI ((v) + 0x8000)
8130
5d1634d7 8131 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
ad8e1ba5 8132 bfd_put_32 (obfd, STD_R2_40R1, p), p += 4;
5d1634d7
AM		 8133 bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p), p += 4;
8134 if (PPC_HA (offset + 8) != PPC_HA (offset))
ad8e1ba5 8135 bfd_put_32 (obfd, ADDIS_R12_R12 | 1, p), p += 4;
5d1634d7
AM		 8136 offset += 8;
8137 bfd_put_32 (obfd, LD_R2_0R12 | PPC_LO (offset), p), p += 4;
8138 if (PPC_HA (offset + 8) != PPC_HA (offset))
ad8e1ba5 8139 bfd_put_32 (obfd, ADDIS_R12_R12 | 1, p), p += 4;
5d1634d7
AM		 8140 offset += 8;
8141 bfd_put_32 (obfd, MTCTR_R11, p), p += 4;
8142 bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p), p += 4;
8143 bfd_put_32 (obfd, BCTR, p), p += 4;
8144 return p;
8145}
8146
b34976b6 8147static bfd_boolean
4ce794b7 8148ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
5d1634d7 8149{
721956f4
AM		 8150 struct ppc_stub_hash_entry *stub_entry;
8151 struct ppc_branch_hash_entry *br_entry;
5d1634d7
AM		 8152 struct bfd_link_info *info;
8153 struct ppc_link_hash_table *htab;
721956f4
AM		 8154 bfd_byte *loc;
8155 bfd_byte *p;
8156 unsigned int indx;
411e1bfb 8157 struct plt_entry *ent;
ee75fd95 8158 bfd_vma dest, off;
721956f4 8159 int size;
5d1634d7 8160
721956f4
AM		 8161 /* Massage our args to the form they really have. */
8162 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
4ce794b7 8163 info = in_arg;
5d1634d7 8164
5d1634d7
AM		 8165 htab = ppc_hash_table (info);
8166
721956f4 8167 /* Make a note of the offset within the stubs for this entry. */
eea6121a 8168 stub_entry->stub_offset = stub_entry->stub_sec->size;
97b639ba 8169 loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
721956f4 8170
4ce794b7 8171 htab->stub_count[stub_entry->stub_type - 1] += 1;
721956f4 8172 switch (stub_entry->stub_type)
5d1634d7 8173 {
721956f4 8174 case ppc_stub_long_branch:
ad8e1ba5 8175 case ppc_stub_long_branch_r2off:
721956f4 8176 /* Branches are relative. This is where we are going to. */
ee75fd95
AM		 8177 off = dest = (stub_entry->target_value
8178 + stub_entry->target_section->output_offset
8179 + stub_entry->target_section->output_section->vma);
5d1634d7 8180
721956f4
AM		 8181 /* And this is where we are coming from. */
8182 off -= (stub_entry->stub_offset
97b639ba
AM		 8183 + stub_entry->stub_sec->output_offset
8184 + stub_entry->stub_sec->output_section->vma);
e86ce104 8185
ad8e1ba5
AM		 8186 if (stub_entry->stub_type != ppc_stub_long_branch_r2off)
8187 size = 4;
8188 else
8189 {
8190 bfd_vma r2off;
8191
8192 r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
8193 - htab->stub_group[stub_entry->id_sec->id].toc_off);
97b639ba 8194 bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
ad8e1ba5 8195 loc += 4;
97b639ba 8196 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
ad8e1ba5 8197 loc += 4;
97b639ba 8198 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
ad8e1ba5
AM		 8199 loc += 4;
8200 off -= 12;
8201 size = 16;
8202 }
97b639ba 8203 bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
ad8e1ba5 8204
5c3dead3
AM		 8205 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
8206 {
8207 (*_bfd_error_handler) (_("long branch stub `%s' offset overflow"),
8208 stub_entry->root.string);
8209 htab->stub_error = TRUE;
8210 return FALSE;
8211 }
ee75fd95
AM		 8212
8213 if (info->emitrelocations)
8214 {
8215 Elf_Internal_Rela *relocs, *r;
8216 struct bfd_elf_section_data *elfsec_data;
8217
8218 elfsec_data = elf_section_data (stub_entry->stub_sec);
8219 relocs = elfsec_data->relocs;
8220 if (relocs == NULL)
8221 {
8222 bfd_size_type relsize;
8223 relsize = stub_entry->stub_sec->reloc_count * sizeof (*relocs);
8224 relocs = bfd_alloc (htab->stub_bfd, relsize);
8225 if (relocs == NULL)
8226 return FALSE;
8227 elfsec_data->relocs = relocs;
8228 elfsec_data->rel_hdr.sh_size = relsize;
8229 elfsec_data->rel_hdr.sh_entsize = 24;
8230 stub_entry->stub_sec->reloc_count = 0;
8231 }
8232 r = relocs + stub_entry->stub_sec->reloc_count;
8233 stub_entry->stub_sec->reloc_count += 1;
8234 r->r_offset = loc - stub_entry->stub_sec->contents;
8235 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
8236 r->r_addend = dest;
8237 if (stub_entry->h != NULL)
8238 {
8239 struct elf_link_hash_entry **hashes;
8240 unsigned long symndx;
8241 struct ppc_link_hash_entry *h;
8242
8243 hashes = elf_sym_hashes (htab->stub_bfd);
8244 if (hashes == NULL)
8245 {
8246 bfd_size_type hsize;
8247
8248 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
8249 hashes = bfd_zalloc (htab->stub_bfd, hsize);
8250 if (hashes == NULL)
8251 return FALSE;
8252 elf_sym_hashes (htab->stub_bfd) = hashes;
8253 htab->stub_globals = 1;
8254 }
8255 symndx = htab->stub_globals++;
8256 h = stub_entry->h;
8257 hashes[symndx] = &h->elf;
8258 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
8259 if (h->oh != NULL && h->oh->is_func)
8260 h = h->oh;
8261 if (h->elf.root.u.def.section != stub_entry->target_section)
8262 /* H is an opd symbol. The addend must be zero. */
8263 r->r_addend = 0;
8264 else
8265 {
8266 off = (h->elf.root.u.def.value
8267 + h->elf.root.u.def.section->output_offset
8268 + h->elf.root.u.def.section->output_section->vma);
8269 r->r_addend -= off;
8270 }
8271 }
8272 }
721956f4 8273 break;
e86ce104 8274
721956f4 8275 case ppc_stub_plt_branch:
ad8e1ba5 8276 case ppc_stub_plt_branch_r2off:
721956f4
AM		 8277 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
8278 stub_entry->root.string + 9,
b34976b6 8279 FALSE, FALSE);
721956f4
AM		 8280 if (br_entry == NULL)
8281 {
8282 (*_bfd_error_handler) (_("can't find branch stub `%s'"),
5c3dead3 8283 stub_entry->root.string);
b34976b6
AM		 8284 htab->stub_error = TRUE;
8285 return FALSE;
721956f4
AM		 8286 }
8287
8288 off = (stub_entry->target_value
8289 + stub_entry->target_section->output_offset
8290 + stub_entry->target_section->output_section->vma);
8291
4ce794b7
AM		 8292 bfd_put_64 (htab->brlt->owner, off,
8293 htab->brlt->contents + br_entry->offset);
721956f4 8294
ee75fd95 8295 if (htab->relbrlt != NULL)
721956f4
AM		 8296 {
8297 /* Create a reloc for the branch lookup table entry. */
8298 Elf_Internal_Rela rela;
ad8e1ba5 8299 bfd_byte *rl;
5d1634d7 8300
721956f4 8301 rela.r_offset = (br_entry->offset
4ce794b7
AM		 8302 + htab->brlt->output_offset
8303 + htab->brlt->output_section->vma);
721956f4
AM		 8304 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
8305 rela.r_addend = off;
8306
4ce794b7
AM		 8307 rl = htab->relbrlt->contents;
8308 rl += htab->relbrlt->reloc_count++ * sizeof (Elf64_External_Rela);
8309 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
721956f4
AM		 8310 }
8311
8312 off = (br_entry->offset
4ce794b7
AM		 8313 + htab->brlt->output_offset
8314 + htab->brlt->output_section->vma
8315 - elf_gp (htab->brlt->output_section->owner)
ad8e1ba5 8316 - htab->stub_group[stub_entry->id_sec->id].toc_off);
721956f4 8317
ad8e1ba5 8318 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
5d1634d7
AM		 8319 {
8320 (*_bfd_error_handler)
e86ce104 8321 (_("linkage table error against `%s'"),
721956f4 8322 stub_entry->root.string);
5d1634d7 8323 bfd_set_error (bfd_error_bad_value);
b34976b6
AM		 8324 htab->stub_error = TRUE;
8325 return FALSE;
5d1634d7 8326 }
41bd81ab 8327
721956f4 8328 indx = off;
ad8e1ba5
AM		 8329 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
8330 {
97b639ba 8331 bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (indx), loc);
ad8e1ba5 8332 loc += 4;
97b639ba 8333 bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (indx), loc);
ad8e1ba5
AM		 8334 size = 16;
8335 }
8336 else
8337 {
8338 bfd_vma r2off;
8339
8340 r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
8341 - htab->stub_group[stub_entry->id_sec->id].toc_off);
97b639ba 8342 bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
ad8e1ba5 8343 loc += 4;
97b639ba 8344 bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (indx), loc);
ad8e1ba5 8345 loc += 4;
97b639ba 8346 bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (indx), loc);
ad8e1ba5 8347 loc += 4;
97b639ba 8348 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
ad8e1ba5 8349 loc += 4;
97b639ba 8350 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
ad8e1ba5
AM		 8351 size = 28;
8352 }
8353 loc += 4;
97b639ba 8354 bfd_put_32 (htab->stub_bfd, MTCTR_R11, loc);
ad8e1ba5 8355 loc += 4;
97b639ba 8356 bfd_put_32 (htab->stub_bfd, BCTR, loc);
721956f4 8357 break;
5d1634d7 8358
721956f4 8359 case ppc_stub_plt_call:
c862ae31
AM		 8360 /* Do the best we can for shared libraries built without
8361 exporting ".foo" for each "foo". This can happen when symbol
8362 versioning scripts strip all bar a subset of symbols. */
8387904d
AM		 8363 if (stub_entry->h->oh != NULL
8364 && stub_entry->h->oh->elf.root.type != bfd_link_hash_defined
34814b9f 8365 && stub_entry->h->oh->elf.root.type != bfd_link_hash_defweak)
c862ae31
AM		 8366 {
8367 /* Point the symbol at the stub. There may be multiple stubs,
8368 we don't really care; The main thing is to make this sym
8f3bab57
AM		 8369 defined somewhere. Maybe defining the symbol in the stub
8370 section is a silly idea. If we didn't do this, htab->top_id
8371 could disappear. */
34814b9f
AM		 8372 stub_entry->h->oh->elf.root.type = bfd_link_hash_defined;
8373 stub_entry->h->oh->elf.root.u.def.section = stub_entry->stub_sec;
8374 stub_entry->h->oh->elf.root.u.def.value = stub_entry->stub_offset;
c862ae31
AM		 8375 }
8376
721956f4 8377 /* Now build the stub. */
411e1bfb
AM		 8378 off = (bfd_vma) -1;
8379 for (ent = stub_entry->h->elf.plt.plist; ent != NULL; ent = ent->next)
8380 if (ent->addend == stub_entry->addend)
8381 {
8382 off = ent->plt.offset;
8383 break;
8384 }
721956f4
AM		 8385 if (off >= (bfd_vma) -2)
8386 abort ();
8387
8388 off &= ~ (bfd_vma) 1;
4ce794b7
AM		 8389 off += (htab->plt->output_offset
8390 + htab->plt->output_section->vma
8391 - elf_gp (htab->plt->output_section->owner)
ad8e1ba5 8392 - htab->stub_group[stub_entry->id_sec->id].toc_off);
721956f4 8393
ad8e1ba5 8394 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
721956f4
AM		 8395 {
8396 (*_bfd_error_handler)
8397 (_("linkage table error against `%s'"),
8398 stub_entry->h->elf.root.root.string);
8399 bfd_set_error (bfd_error_bad_value);
b34976b6
AM		 8400 htab->stub_error = TRUE;
8401 return FALSE;
721956f4
AM		 8402 }
8403
97b639ba 8404 p = build_plt_stub (htab->stub_bfd, loc, off);
721956f4
AM		 8405 size = p - loc;
8406 break;
8407
8408 default:
8409 BFD_FAIL ();
b34976b6 8410 return FALSE;
721956f4
AM		 8411 }
8412
eea6121a 8413 stub_entry->stub_sec->size += size;
97b639ba 8414
ee75fd95 8415 if (htab->emit_stub_syms)
97b639ba
AM		 8416 {
8417 struct elf_link_hash_entry *h;
ee75fd95
AM		 8418 size_t len1, len2;
8419 char *name;
8420 const char *const stub_str[] = { "long_branch",
8421 "long_branch_r2off",
8422 "plt_branch",
8423 "plt_branch_r2off",
8424 "plt_call" };
8425
8426 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
8427 len2 = strlen (stub_entry->root.string);
8428 name = bfd_malloc (len1 + len2 + 2);
8429 if (name == NULL)
8430 return FALSE;
8431 memcpy (name, stub_entry->root.string, 9);
8432 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
8433 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
8434 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
97b639ba
AM		 8435 if (h == NULL)
8436 return FALSE;
8437 if (h->root.type == bfd_link_hash_new)
8438 {
8439 h->root.type = bfd_link_hash_defined;
8440 h->root.u.def.section = stub_entry->stub_sec;
8441 h->root.u.def.value = stub_entry->stub_offset;
f5385ebf
AM		 8442 h->ref_regular = 1;
8443 h->def_regular = 1;
8444 h->ref_regular_nonweak = 1;
8445 h->forced_local = 1;
8446 h->non_elf = 0;
97b639ba
AM		 8447 }
8448 }
8449
b34976b6 8450 return TRUE;
721956f4
AM		 8451}
8452
8453/* As above, but don't actually build the stub. Just bump offset so
8454 we know stub section sizes, and select plt_branch stubs where
8455 long_branch stubs won't do. */
8456
b34976b6 8457static bfd_boolean
4ce794b7 8458ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
721956f4
AM		 8459{
8460 struct ppc_stub_hash_entry *stub_entry;
63bc6f6c 8461 struct bfd_link_info *info;
721956f4
AM		 8462 struct ppc_link_hash_table *htab;
8463 bfd_vma off;
8464 int size;
8465
8466 /* Massage our args to the form they really have. */
8467 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
63bc6f6c
AM		 8468 info = in_arg;
8469
8470 htab = ppc_hash_table (info);
721956f4
AM		 8471
8472 if (stub_entry->stub_type == ppc_stub_plt_call)
8473 {
411e1bfb 8474 struct plt_entry *ent;
58ac9f71 8475 off = (bfd_vma) -1;
411e1bfb
AM		 8476 for (ent = stub_entry->h->elf.plt.plist; ent != NULL; ent = ent->next)
8477 if (ent->addend == stub_entry->addend)
8478 {
8479 off = ent->plt.offset & ~(bfd_vma) 1;
8480 break;
8481 }
58ac9f71 8482 if (off >= (bfd_vma) -2)
411e1bfb 8483 abort ();
4ce794b7
AM		 8484 off += (htab->plt->output_offset
8485 + htab->plt->output_section->vma
8486 - elf_gp (htab->plt->output_section->owner)
ad8e1ba5 8487 - htab->stub_group[stub_entry->id_sec->id].toc_off);
721956f4 8488
ad8e1ba5 8489 size = PLT_CALL_STUB_SIZE;
4ce794b7 8490 if (PPC_HA (off + 16) != PPC_HA (off))
721956f4
AM		 8491 size += 4;
8492 }
8493 else
8494 {
ad8e1ba5
AM		 8495 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
8496 variants. */
721956f4
AM		 8497 off = (stub_entry->target_value
8498 + stub_entry->target_section->output_offset
8499 + stub_entry->target_section->output_section->vma);
eea6121a 8500 off -= (stub_entry->stub_sec->size
721956f4
AM		 8501 + stub_entry->stub_sec->output_offset
8502 + stub_entry->stub_sec->output_section->vma);
8503
ad8e1ba5
AM		 8504 /* Reset the stub type from the plt variant in case we now
8505 can reach with a shorter stub. */
8506 if (stub_entry->stub_type >= ppc_stub_plt_branch)
8507 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
8508
8509 size = 4;
8510 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
8511 {
8512 off -= 12;
8513 size = 16;
8514 }
8515
8516 /* If the branch offset if too big, use a ppc_stub_plt_branch. */
721956f4
AM		 8517 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
8518 {
8519 struct ppc_branch_hash_entry *br_entry;
8520
8521 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
8522 stub_entry->root.string + 9,
b34976b6 8523 TRUE, FALSE);
721956f4
AM		 8524 if (br_entry == NULL)
8525 {
8526 (*_bfd_error_handler) (_("can't build branch stub `%s'"),
5c3dead3 8527 stub_entry->root.string);
b34976b6
AM		 8528 htab->stub_error = TRUE;
8529 return FALSE;
721956f4
AM		 8530 }
8531
8532 if (br_entry->iter != htab->stub_iteration)
8533 {
8534 br_entry->iter = htab->stub_iteration;
eea6121a
AM		 8535 br_entry->offset = htab->brlt->size;
8536 htab->brlt->size += 8;
63bc6f6c 8537
ee75fd95 8538 if (htab->relbrlt != NULL)
eea6121a 8539 htab->relbrlt->size += sizeof (Elf64_External_Rela);
721956f4 8540 }
ad8e1ba5
AM		 8541
8542 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
721956f4 8543 size = 16;
ad8e1ba5
AM		 8544 if (stub_entry->stub_type != ppc_stub_plt_branch)
8545 size = 28;
721956f4 8546 }
ee75fd95
AM		 8547
8548 if (info->emitrelocations
8549 && (stub_entry->stub_type == ppc_stub_long_branch
8550 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
8551 stub_entry->stub_sec->reloc_count += 1;
721956f4
AM		 8552 }
8553
eea6121a 8554 stub_entry->stub_sec->size += size;
b34976b6 8555 return TRUE;
721956f4
AM		 8556}
8557
8558/* Set up various things so that we can make a list of input sections
8559 for each output section included in the link. Returns -1 on error,
cedb70c5 8560 0 when no stubs will be needed, and 1 on success. */
721956f4
AM		 8561
8562int
4c52953f
AM		 8563ppc64_elf_setup_section_lists (bfd *output_bfd,
8564 struct bfd_link_info *info,
8565 int no_multi_toc)
721956f4
AM		 8566{
8567 bfd *input_bfd;
734b6cf9 8568 int top_id, top_index, id;
721956f4 8569 asection *section;
734b6cf9 8570 asection **input_list;
721956f4
AM		 8571 bfd_size_type amt;
8572 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8573
4c52953f
AM		 8574 htab->no_multi_toc = no_multi_toc;
8575
4ce794b7 8576 if (htab->brlt == NULL)
721956f4
AM		 8577 return 0;
8578
1e2f5b6e 8579 /* Find the top input section id. */
3d6f9012 8580 for (input_bfd = info->input_bfds, top_id = 3;
721956f4
AM		 8581 input_bfd != NULL;
8582 input_bfd = input_bfd->link_next)
8583 {
721956f4
AM		 8584 for (section = input_bfd->sections;
8585 section != NULL;
8586 section = section->next)
8587 {
8588 if (top_id < section->id)
8589 top_id = section->id;
8590 }
8591 }
721956f4 8592
8f3bab57 8593 htab->top_id = top_id;
721956f4 8594 amt = sizeof (struct map_stub) * (top_id + 1);
4ce794b7 8595 htab->stub_group = bfd_zmalloc (amt);
721956f4
AM		 8596 if (htab->stub_group == NULL)
8597 return -1;
8598
3d6f9012
AM		 8599 /* Set toc_off for com, und, abs and ind sections. */
8600 for (id = 0; id < 3; id++)
8601 htab->stub_group[id].toc_off = TOC_BASE_OFF;
721956f4 8602
3d6f9012 8603 elf_gp (output_bfd) = htab->toc_curr = ppc64_elf_toc (output_bfd);
734b6cf9
AM		 8604
8605 /* We can't use output_bfd->section_count here to find the top output
8606 section index as some sections may have been removed, and
8423293d 8607 strip_excluded_output_sections doesn't renumber the indices. */
734b6cf9
AM		 8608 for (section = output_bfd->sections, top_index = 0;
8609 section != NULL;
8610 section = section->next)
8611 {
8612 if (top_index < section->index)
8613 top_index = section->index;
8614 }
8615
8616 htab->top_index = top_index;
8617 amt = sizeof (asection *) * (top_index + 1);
4ce794b7 8618 input_list = bfd_zmalloc (amt);
734b6cf9
AM		 8619 htab->input_list = input_list;
8620 if (input_list == NULL)
8621 return -1;
8622
721956f4
AM		 8623 return 1;
8624}
8625
e717da7e
AM		 8626/* The linker repeatedly calls this function for each TOC input section
8627 and linker generated GOT section. Group input bfds such that the toc
8628 within a group is less than 64k in size. Will break with cute linker
8629 scripts that play games with dot in the output toc section. */
ad8e1ba5
AM		 8630
8631void
4ce794b7 8632ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
ad8e1ba5
AM		 8633{
8634 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8635
4c52953f
AM		 8636 if (!htab->no_multi_toc)
8637 {
8638 bfd_vma addr = isec->output_offset + isec->output_section->vma;
8639 bfd_vma off = addr - htab->toc_curr;
8640
8641 if (off + isec->size > 0x10000)
8642 htab->toc_curr = addr;
99877b66 8643
4c52953f
AM		 8644 elf_gp (isec->owner) = (htab->toc_curr
8645 - elf_gp (isec->output_section->owner)
8646 + TOC_BASE_OFF);
8647 }
ad8e1ba5
AM		 8648}
8649
8650/* Called after the last call to the above function. */
8651
8652void
4c52953f 8653ppc64_elf_reinit_toc (bfd *output_bfd, struct bfd_link_info *info)
ad8e1ba5
AM		 8654{
8655 struct ppc_link_hash_table *htab = ppc_hash_table (info);
ad8e1ba5 8656
4c52953f
AM		 8657 htab->multi_toc_needed = htab->toc_curr != elf_gp (output_bfd);
8658
ad8e1ba5
AM		 8659 /* toc_curr tracks the TOC offset used for code sections below in
8660 ppc64_elf_next_input_section. Start off at 0x8000. */
3d6f9012 8661 htab->toc_curr = TOC_BASE_OFF;
ad8e1ba5
AM		 8662}
8663
9b5ecbd0
AM		 8664/* No toc references were found in ISEC. If the code in ISEC makes no
8665 calls, then there's no need to use toc adjusting stubs when branching
8666 into ISEC. Actually, indirect calls from ISEC are OK as they will
4c52953f
AM		 8667 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
8668 needed, and 2 if a cyclical call-graph was found but no other reason
8669 for a stub was detected. If called from the top level, a return of
8670 2 means the same as a return of 0. */
9b5ecbd0
AM		 8671
8672static int
4ce794b7 8673toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
9b5ecbd0 8674{
4c52953f
AM		 8675 Elf_Internal_Rela *relstart, *rel;
8676 Elf_Internal_Sym *local_syms;
9b5ecbd0 8677 int ret;
4c52953f 8678 struct ppc_link_hash_table *htab;
9b5ecbd0 8679
772119ce
AM		 8680 /* We know none of our code bearing sections will need toc stubs. */
8681 if ((isec->flags & SEC_LINKER_CREATED) != 0)
8682 return 0;
8683
eea6121a 8684 if (isec->size == 0)
082c50f8
AM		 8685 return 0;
8686
4c52953f
AM		 8687 if (isec->output_section == NULL)
8688 return 0;
8689
9b5ecbd0
AM		 8690 /* Hack for linux kernel. .fixup contains branches, but only back to
8691 the function that hit an exception. */
4c52953f
AM		 8692 if (strcmp (isec->name, ".fixup") == 0)
8693 return 0;
9b5ecbd0 8694
4c52953f
AM		 8695 if (isec->reloc_count == 0)
8696 return 0;
8697
8698 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
8699 info->keep_memory);
8700 if (relstart == NULL)
8701 return -1;
8702
8703 /* Look for branches to outside of this section. */
8704 local_syms = NULL;
8705 ret = 0;
8706 htab = ppc_hash_table (info);
8707 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
9b5ecbd0 8708 {
4c52953f
AM		 8709 enum elf_ppc64_reloc_type r_type;
8710 unsigned long r_symndx;
8711 struct elf_link_hash_entry *h;
8712 Elf_Internal_Sym *sym;
8713 asection *sym_sec;
8714 long *opd_adjust;
8715 bfd_vma sym_value;
8716 bfd_vma dest;
8717
8718 r_type = ELF64_R_TYPE (rel->r_info);
8719 if (r_type != R_PPC64_REL24
8720 && r_type != R_PPC64_REL14
8721 && r_type != R_PPC64_REL14_BRTAKEN
8722 && r_type != R_PPC64_REL14_BRNTAKEN)
8723 continue;
8724
8725 r_symndx = ELF64_R_SYM (rel->r_info);
8726 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
8727 isec->owner))
9b5ecbd0 8728 {
4c52953f
AM		 8729 ret = -1;
8730 break;
9b5ecbd0 8731 }
9b5ecbd0 8732
2917689a
AM		 8733 /* Calls to dynamic lib functions go through a plt call stub
8734 that uses r2. Branches to undefined symbols might be a call
8735 using old-style dot symbols that can be satisfied by a plt
8736 call into a new-style dynamic library. */
4c52953f 8737 if (sym_sec == NULL)
2917689a
AM		 8738 {
8739 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
8740 if (eh != NULL
8741 && eh->oh != NULL
8742 && eh->oh->elf.plt.plist != NULL)
8743 {
8744 ret = 1;
8745 break;
8746 }
4c52953f 8747
2917689a
AM		 8748 /* Ignore other undefined symbols. */
8749 continue;
8750 }
8751
8752 /* Assume branches to other sections not included in the link need
8753 stubs too, to cover -R and absolute syms. */
4c52953f
AM		 8754 if (sym_sec->output_section == NULL)
8755 {
8756 ret = 1;
8757 break;
8758 }
8759
8760 if (h == NULL)
8761 sym_value = sym->st_value;
8762 else
8763 {
8764 if (h->root.type != bfd_link_hash_defined
8765 && h->root.type != bfd_link_hash_defweak)
8766 abort ();
8767 sym_value = h->root.u.def.value;
8768 }
8769 sym_value += rel->r_addend;
8770
8771 /* If this branch reloc uses an opd sym, find the code section. */
8772 opd_adjust = get_opd_info (sym_sec);
8773 if (opd_adjust != NULL)
8774 {
4c52953f
AM		 8775 if (h == NULL)
8776 {
8777 long adjust;
8778
8779 adjust = opd_adjust[sym->st_value / 8];
8780 if (adjust == -1)
8781 /* Assume deleted functions won't ever be called. */
8782 continue;
8783 sym_value += adjust;
8784 }
8785
8786 dest = opd_entry_value (sym_sec, sym_value, &sym_sec, NULL);
8787 if (dest == (bfd_vma) -1)
8788 continue;
8789 }
8790 else
8791 dest = (sym_value
8792 + sym_sec->output_offset
8793 + sym_sec->output_section->vma);
8794
8795 /* Ignore branch to self. */
8796 if (sym_sec == isec)
8797 continue;
8798
8799 /* If the called function uses the toc, we need a stub. */
8800 if (sym_sec->has_toc_reloc
8801 || sym_sec->makes_toc_func_call)
8802 {
8803 ret = 1;
8804 break;
8805 }
8806
8807 /* Assume any branch that needs a long branch stub might in fact
8808 need a plt_branch stub. A plt_branch stub uses r2. */
8809 else if (dest - (isec->output_offset
8810 + isec->output_section->vma
8811 + rel->r_offset) + (1 << 25) >= (2 << 25))
9b5ecbd0
AM		 8812 {
8813 ret = 1;
8814 break;
8815 }
4c52953f
AM		 8816
8817 /* If calling back to a section in the process of being tested, we
8818 can't say for sure that no toc adjusting stubs are needed, so
8819 don't return zero. */
8820 else if (sym_sec->call_check_in_progress)
8821 ret = 2;
8822
8823 /* Branches to another section that itself doesn't have any TOC
8824 references are OK. Recursively call ourselves to check. */
8825 else if (sym_sec->id <= htab->top_id
8826 && htab->stub_group[sym_sec->id].toc_off == 0)
8827 {
8828 int recur;
8829
8830 /* Mark current section as indeterminate, so that other
8831 sections that call back to current won't be marked as
8832 known. */
8833 isec->call_check_in_progress = 1;
8834 recur = toc_adjusting_stub_needed (info, sym_sec);
8835 isec->call_check_in_progress = 0;
8836
8837 if (recur < 0)
8838 {
8839 /* An error. Exit. */
8840 ret = -1;
8841 break;
8842 }
8843 else if (recur <= 1)
8844 {
8845 /* Known result. Mark as checked and set section flag. */
8846 htab->stub_group[sym_sec->id].toc_off = 1;
8847 if (recur != 0)
8848 {
8849 sym_sec->makes_toc_func_call = 1;
8850 ret = 1;
8851 break;
8852 }
8853 }
8854 else
8855 {
8856 /* Unknown result. Continue checking. */
8857 ret = 2;
8858 }
8859 }
9b5ecbd0
AM		 8860 }
8861
4c52953f
AM		 8862 if (local_syms != NULL
8863 && (elf_tdata (isec->owner)->symtab_hdr.contents
8864 != (unsigned char *) local_syms))
8865 free (local_syms);
8866 if (elf_section_data (isec)->relocs != relstart)
8867 free (relstart);
8868
9b5ecbd0
AM		 8869 return ret;
8870}
8871
721956f4
AM		 8872/* The linker repeatedly calls this function for each input section,
8873 in the order that input sections are linked into output sections.
8874 Build lists of input sections to determine groupings between which
8875 we may insert linker stubs. */
8876
9b5ecbd0 8877bfd_boolean
4ce794b7 8878ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
721956f4
AM		 8879{
8880 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8881
734b6cf9
AM		 8882 if ((isec->output_section->flags & SEC_CODE) != 0
8883 && isec->output_section->index <= htab->top_index)
721956f4 8884 {
734b6cf9 8885 asection **list = htab->input_list + isec->output_section->index;
3d6f9012 8886 /* Steal the link_sec pointer for our list. */
721956f4 8887#define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
3d6f9012
AM		 8888 /* This happens to make the list in reverse order,
8889 which is what we want. */
734b6cf9
AM		 8890 PREV_SEC (isec) = *list;
8891 *list = isec;
721956f4 8892 }
ad8e1ba5 8893
4c52953f 8894 if (htab->multi_toc_needed)
9b5ecbd0 8895 {
4c52953f
AM		 8896 /* If a code section has a function that uses the TOC then we need
8897 to use the right TOC (obviously). Also, make sure that .opd gets
8898 the correct TOC value for R_PPC64_TOC relocs that don't have or
8899 can't find their function symbol (shouldn't ever happen now). */
8900 if (isec->has_toc_reloc || (isec->flags & SEC_CODE) == 0)
8901 {
8902 if (elf_gp (isec->owner) != 0)
8903 htab->toc_curr = elf_gp (isec->owner);
8904 }
8905 else if (htab->stub_group[isec->id].toc_off == 0)
8906 {
8907 int ret = toc_adjusting_stub_needed (info, isec);
8908 if (ret < 0)
8909 return FALSE;
8910 else
8911 isec->makes_toc_func_call = ret & 1;
8912 }
9b5ecbd0 8913 }
ad8e1ba5
AM		 8914
8915 /* Functions that don't use the TOC can belong in any TOC group.
8916 Use the last TOC base. This happens to make _init and _fini
8917 pasting work. */
8918 htab->stub_group[isec->id].toc_off = htab->toc_curr;
9b5ecbd0 8919 return TRUE;
721956f4
AM		 8920}
8921
8922/* See whether we can group stub sections together. Grouping stub
8923 sections may result in fewer stubs. More importantly, we need to
8924 put all .init* and .fini* stubs at the beginning of the .init or
8925 .fini output sections respectively, because glibc splits the
8926 _init and _fini functions into multiple parts. Putting a stub in
8927 the middle of a function is not a good idea. */
8928
8929static void
4ce794b7
AM		 8930group_sections (struct ppc_link_hash_table *htab,
8931 bfd_size_type stub_group_size,
8932 bfd_boolean stubs_always_before_branch)
721956f4 8933{
734b6cf9
AM		 8934 asection **list = htab->input_list + htab->top_index;
8935 do
721956f4 8936 {
734b6cf9
AM		 8937 asection *tail = *list;
8938 while (tail != NULL)
721956f4 8939 {
734b6cf9
AM		 8940 asection *curr;
8941 asection *prev;
8942 bfd_size_type total;
8943 bfd_boolean big_sec;
8944 bfd_vma curr_toc;
8945
8946 curr = tail;
eea6121a 8947 total = tail->size;
5c3dead3
AM		 8948 big_sec = total > stub_group_size;
8949 if (big_sec)
8950 (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
8951 tail->owner, tail);
734b6cf9
AM		 8952 curr_toc = htab->stub_group[tail->id].toc_off;
8953
8954 while ((prev = PREV_SEC (curr)) != NULL
8955 && ((total += curr->output_offset - prev->output_offset)
ad8e1ba5
AM		 8956 < stub_group_size)
8957 && htab->stub_group[prev->id].toc_off == curr_toc)
734b6cf9
AM		 8958 curr = prev;
8959
8960 /* OK, the size from the start of CURR to the end is less
8961 than stub_group_size and thus can be handled by one stub
8962 section. (or the tail section is itself larger than
8963 stub_group_size, in which case we may be toast.) We
8964 should really be keeping track of the total size of stubs
8965 added here, as stubs contribute to the final output
8966 section size. That's a little tricky, and this way will
8967 only break if stubs added make the total size more than
8968 2^25, ie. for the default stub_group_size, if stubs total
8969 more than 2097152 bytes, or nearly 75000 plt call stubs. */
8970 do
721956f4
AM		 8971 {
8972 prev = PREV_SEC (tail);
734b6cf9 8973 /* Set up this stub group. */
721956f4
AM		 8974 htab->stub_group[tail->id].link_sec = curr;
8975 }
734b6cf9
AM		 8976 while (tail != curr && (tail = prev) != NULL);
8977
8978 /* But wait, there's more! Input sections up to stub_group_size
8979 bytes before the stub section can be handled by it too.
8980 Don't do this if we have a really large section after the
8981 stubs, as adding more stubs increases the chance that
8982 branches may not reach into the stub section. */
8983 if (!stubs_always_before_branch && !big_sec)
8984 {
8985 total = 0;
8986 while (prev != NULL
8987 && ((total += tail->output_offset - prev->output_offset)
8988 < stub_group_size)
8989 && htab->stub_group[prev->id].toc_off == curr_toc)
8990 {
8991 tail = prev;
8992 prev = PREV_SEC (tail);
8993 htab->stub_group[tail->id].link_sec = curr;
8994 }
8995 }
8996 tail = prev;
721956f4
AM		 8997 }
8998 }
734b6cf9
AM		 8999 while (list-- != htab->input_list);
9000 free (htab->input_list);
721956f4
AM		 9001#undef PREV_SEC
9002}
9003
721956f4
AM		 9004/* Determine and set the size of the stub section for a final link.
9005
9006 The basic idea here is to examine all the relocations looking for
9007 PC-relative calls to a target that is unreachable with a "bl"
9008 instruction. */
9009
b34976b6 9010bfd_boolean
4ce794b7 9011ppc64_elf_size_stubs (bfd *output_bfd,
4ce794b7
AM		 9012 struct bfd_link_info *info,
9013 bfd_signed_vma group_size,
9014 asection *(*add_stub_section) (const char *, asection *),
9015 void (*layout_sections_again) (void))
721956f4
AM		 9016{
9017 bfd_size_type stub_group_size;
b34976b6 9018 bfd_boolean stubs_always_before_branch;
721956f4
AM		 9019 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9020
9021 /* Stash our params away. */
721956f4
AM		 9022 htab->add_stub_section = add_stub_section;
9023 htab->layout_sections_again = layout_sections_again;
9024 stubs_always_before_branch = group_size < 0;
9025 if (group_size < 0)
9026 stub_group_size = -group_size;
9027 else
9028 stub_group_size = group_size;
9029 if (stub_group_size == 1)
9030 {
9031 /* Default values. */
58ac9f71
AM		 9032 if (stubs_always_before_branch)
9033 {
9034 stub_group_size = 0x1e00000;
9035 if (htab->has_14bit_branch)
9036 stub_group_size = 0x7800;
9037 }
9038 else
9039 {
9040 stub_group_size = 0x1c00000;
9041 if (htab->has_14bit_branch)
9042 stub_group_size = 0x7000;
9043 }
721956f4
AM		 9044 }
9045
9046 group_sections (htab, stub_group_size, stubs_always_before_branch);
9047
721956f4
AM		 9048 while (1)
9049 {
9050 bfd *input_bfd;
9051 unsigned int bfd_indx;
9052 asection *stub_sec;
721956f4
AM		 9053
9054 htab->stub_iteration += 1;
721956f4
AM		 9055
9056 for (input_bfd = info->input_bfds, bfd_indx = 0;
9057 input_bfd != NULL;
9058 input_bfd = input_bfd->link_next, bfd_indx++)
9059 {
9060 Elf_Internal_Shdr *symtab_hdr;
9061 asection *section;
6cdc0ccc 9062 Elf_Internal_Sym *local_syms = NULL;
721956f4 9063
67f93c31
AM		 9064 if (!is_ppc64_elf_target (input_bfd->xvec))
9065 continue;
9066
721956f4
AM		 9067 /* We'll need the symbol table in a second. */
9068 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
9069 if (symtab_hdr->sh_info == 0)
9070 continue;
9071
721956f4
AM		 9072 /* Walk over each section attached to the input bfd. */
9073 for (section = input_bfd->sections;
9074 section != NULL;
9075 section = section->next)
9076 {
721956f4 9077 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
721956f4
AM		 9078
9079 /* If there aren't any relocs, then there's nothing more
9080 to do. */
9081 if ((section->flags & SEC_RELOC) == 0
12c0f757
AM		 9082 || (section->flags & SEC_ALLOC) == 0
9083 || (section->flags & SEC_LOAD) == 0
9084 || (section->flags & SEC_CODE) == 0
721956f4
AM		 9085 || section->reloc_count == 0)
9086 continue;
9087
9088 /* If this section is a link-once section that will be
9089 discarded, then don't create any stubs. */
9090 if (section->output_section == NULL
9091 || section->output_section->owner != output_bfd)
9092 continue;
9093
1e2f5b6e
AM		 9094 /* Get the relocs. */
9095 internal_relocs
4ce794b7 9096 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
45d6a902 9097 info->keep_memory);
721956f4 9098 if (internal_relocs == NULL)
1e2f5b6e 9099 goto error_ret_free_local;
721956f4
AM		 9100
9101 /* Now examine each relocation. */
9102 irela = internal_relocs;
9103 irelaend = irela + section->reloc_count;
9104 for (; irela < irelaend; irela++)
9105 {
4ce794b7
AM		 9106 enum elf_ppc64_reloc_type r_type;
9107 unsigned int r_indx;
721956f4
AM		 9108 enum ppc_stub_type stub_type;
9109 struct ppc_stub_hash_entry *stub_entry;
8387904d 9110 asection *sym_sec, *code_sec;
721956f4
AM		 9111 bfd_vma sym_value;
9112 bfd_vma destination;
8843416a 9113 bfd_boolean ok_dest;
721956f4 9114 struct ppc_link_hash_entry *hash;
8387904d 9115 struct ppc_link_hash_entry *fdh;
411e1bfb
AM		 9116 struct elf_link_hash_entry *h;
9117 Elf_Internal_Sym *sym;
721956f4
AM		 9118 char *stub_name;
9119 const asection *id_sec;
8387904d 9120 long *opd_adjust;
721956f4
AM		 9121
9122 r_type = ELF64_R_TYPE (irela->r_info);
9123 r_indx = ELF64_R_SYM (irela->r_info);
9124
4ce794b7 9125 if (r_type >= R_PPC64_max)
721956f4
AM		 9126 {
9127 bfd_set_error (bfd_error_bad_value);
6cdc0ccc 9128 goto error_ret_free_internal;
721956f4
AM		 9129 }
9130
9131 /* Only look for stubs on branch instructions. */
4ce794b7
AM		 9132 if (r_type != R_PPC64_REL24
9133 && r_type != R_PPC64_REL14
9134 && r_type != R_PPC64_REL14_BRTAKEN
9135 && r_type != R_PPC64_REL14_BRNTAKEN)
721956f4
AM		 9136 continue;
9137
9138 /* Now determine the call target, its name, value,
9139 section. */
411e1bfb
AM		 9140 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9141 r_indx, input_bfd))
9142 goto error_ret_free_internal;
9143 hash = (struct ppc_link_hash_entry *) h;
9144
8843416a 9145 ok_dest = FALSE;
8387904d 9146 fdh = NULL;
7fe2b9a6 9147 sym_value = 0;
411e1bfb 9148 if (hash == NULL)
721956f4 9149 {
411e1bfb 9150 sym_value = sym->st_value;
8843416a 9151 ok_dest = TRUE;
721956f4 9152 }
7fe2b9a6
AM		 9153 else if (hash->elf.root.type == bfd_link_hash_defined
9154 || hash->elf.root.type == bfd_link_hash_defweak)
9155 {
9156 sym_value = hash->elf.root.u.def.value;
9157 if (sym_sec->output_section != NULL)
9158 ok_dest = TRUE;
9159 }
9160 else if (hash->elf.root.type == bfd_link_hash_undefweak
9161 || hash->elf.root.type == bfd_link_hash_undefined)
721956f4 9162 {
99877b66 9163 /* Recognise an old ABI func code entry sym, and
7fe2b9a6
AM		 9164 use the func descriptor sym instead if it is
9165 defined. */
ceb1f1ef 9166 if (hash->elf.root.root.string[0] == '.'
8387904d
AM		 9167 && (fdh = get_fdh (hash, htab)) != NULL)
9168 {
8387904d
AM		 9169 if (fdh->elf.root.type == bfd_link_hash_defined
9170 || fdh->elf.root.type == bfd_link_hash_defweak)
9171 {
9172 sym_sec = fdh->elf.root.u.def.section;
9173 sym_value = fdh->elf.root.u.def.value;
9174 if (sym_sec->output_section != NULL)
9175 ok_dest = TRUE;
9176 }
99877b66
AM		 9177 else
9178 fdh = NULL;
8387904d 9179 }
7fe2b9a6
AM		 9180 }
9181 else
9182 {
9183 bfd_set_error (bfd_error_bad_value);
9184 goto error_ret_free_internal;
721956f4
AM		 9185 }
9186
8843416a
AM		 9187 destination = 0;
9188 if (ok_dest)
9189 {
9190 sym_value += irela->r_addend;
9191 destination = (sym_value
9192 + sym_sec->output_offset
9193 + sym_sec->output_section->vma);
9194 }
9195
8387904d
AM		 9196 code_sec = sym_sec;
9197 opd_adjust = get_opd_info (sym_sec);
9198 if (opd_adjust != NULL)
9199 {
9200 bfd_vma dest;
9201
9202 if (hash == NULL)
9203 {
3f764659 9204 long adjust = opd_adjust[sym_value / 8];
8387904d
AM		 9205 if (adjust == -1)
9206 continue;
9207 sym_value += adjust;
9208 }
9209 dest = opd_entry_value (sym_sec, sym_value,
9210 &code_sec, &sym_value);
9211 if (dest != (bfd_vma) -1)
9212 {
9213 destination = dest;
9214 if (fdh != NULL)
9215 {
9216 /* Fixup old ABI sym to point at code
9217 entry. */
99877b66 9218 hash->elf.root.type = bfd_link_hash_defweak;
8387904d
AM		 9219 hash->elf.root.u.def.section = code_sec;
9220 hash->elf.root.u.def.value = sym_value;
9221 }
9222 }
9223 }
9224
721956f4
AM		 9225 /* Determine what (if any) linker stub is needed. */
9226 stub_type = ppc_type_of_stub (section, irela, &hash,
9227 destination);
ad8e1ba5
AM		 9228
9229 if (stub_type != ppc_stub_plt_call)
9230 {
9231 /* Check whether we need a TOC adjusting stub.
9232 Since the linker pastes together pieces from
9233 different object files when creating the
9234 _init and _fini functions, it may be that a
9235 call to what looks like a local sym is in
9236 fact a call needing a TOC adjustment. */
8387904d
AM		 9237 if (code_sec != NULL
9238 && code_sec->output_section != NULL
9239 && (htab->stub_group[code_sec->id].toc_off
9b5ecbd0 9240 != htab->stub_group[section->id].toc_off)
4c52953f
AM		 9241 && (code_sec->has_toc_reloc
9242 || code_sec->makes_toc_func_call))
ad8e1ba5
AM		 9243 stub_type = ppc_stub_long_branch_r2off;
9244 }
9245
721956f4
AM		 9246 if (stub_type == ppc_stub_none)
9247 continue;
9248
411e1bfb
AM		 9249 /* __tls_get_addr calls might be eliminated. */
9250 if (stub_type != ppc_stub_plt_call
9251 && hash != NULL
8387904d
AM		 9252 && (hash == htab->tls_get_addr
9253 || hash == htab->tls_get_addr_fd)
411e1bfb
AM		 9254 && section->has_tls_reloc
9255 && irela != internal_relocs)
9256 {
9257 /* Get tls info. */
e7b938ca 9258 char *tls_mask;
411e1bfb 9259
0d4792f7 9260 if (!get_tls_mask (&tls_mask, NULL, &local_syms,
411e1bfb
AM		 9261 irela - 1, input_bfd))
9262 goto error_ret_free_internal;
e7b938ca 9263 if (*tls_mask != 0)
411e1bfb
AM		 9264 continue;
9265 }
9266
721956f4
AM		 9267 /* Support for grouping stub sections. */
9268 id_sec = htab->stub_group[section->id].link_sec;
9269
9270 /* Get the name of this stub. */
9271 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
9272 if (!stub_name)
9273 goto error_ret_free_internal;
9274
9275 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
b34976b6 9276 stub_name, FALSE, FALSE);
721956f4
AM		 9277 if (stub_entry != NULL)
9278 {
9279 /* The proper stub has already been created. */
9280 free (stub_name);
9281 continue;
9282 }
9283
9284 stub_entry = ppc_add_stub (stub_name, section, htab);
9285 if (stub_entry == NULL)
9286 {
9287 free (stub_name);
6cdc0ccc
AM		 9288 error_ret_free_internal:
9289 if (elf_section_data (section)->relocs == NULL)
9290 free (internal_relocs);
9291 error_ret_free_local:
9292 if (local_syms != NULL
9293 && (symtab_hdr->contents
9294 != (unsigned char *) local_syms))
9295 free (local_syms);
b34976b6 9296 return FALSE;
721956f4
AM		 9297 }
9298
ad8e1ba5 9299 stub_entry->stub_type = stub_type;
721956f4 9300 stub_entry->target_value = sym_value;
8387904d 9301 stub_entry->target_section = code_sec;
721956f4 9302 stub_entry->h = hash;
411e1bfb 9303 stub_entry->addend = irela->r_addend;
ee75fd95
AM		 9304
9305 if (stub_entry->h != NULL)
9306 htab->stub_globals += 1;
721956f4
AM		 9307 }
9308
9309 /* We're done with the internal relocs, free them. */
6cdc0ccc 9310 if (elf_section_data (section)->relocs != internal_relocs)
1e2f5b6e 9311 free (internal_relocs);
721956f4 9312 }
6cdc0ccc
AM		 9313
9314 if (local_syms != NULL
9315 && symtab_hdr->contents != (unsigned char *) local_syms)
9316 {
9317 if (!info->keep_memory)
9318 free (local_syms);
9319 else
9320 symtab_hdr->contents = (unsigned char *) local_syms;
9321 }
721956f4
AM		 9322 }
9323
5c3dead3 9324 /* We may have added some stubs. Find out the new size of the
721956f4
AM		 9325 stub sections. */
9326 for (stub_sec = htab->stub_bfd->sections;
9327 stub_sec != NULL;
9328 stub_sec = stub_sec->next)
e717da7e 9329 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
ee75fd95 9330 {
5c3dead3 9331 stub_sec->rawsize = stub_sec->size;
ee75fd95
AM		 9332 stub_sec->size = 0;
9333 stub_sec->reloc_count = 0;
9334 }
eea6121a
AM		 9335
9336 htab->brlt->size = 0;
ee75fd95 9337 if (htab->relbrlt != NULL)
eea6121a 9338 htab->relbrlt->size = 0;
721956f4 9339
63bc6f6c 9340 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
721956f4 9341
5c3dead3
AM		 9342 for (stub_sec = htab->stub_bfd->sections;
9343 stub_sec != NULL;
9344 stub_sec = stub_sec->next)
9345 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
9346 && stub_sec->rawsize != stub_sec->size)
9347 break;
9348
9349 /* Exit from this loop when no stubs have been added, and no stubs
9350 have changed size. */
9351 if (stub_sec == NULL)
9352 break;
9353
721956f4
AM		 9354 /* Ask the linker to do its stuff. */
9355 (*htab->layout_sections_again) ();
9356 }
9357
c456f082 9358 /* It would be nice to strip htab->brlt from the output if the
afbe61cf
AM		 9359 section is empty, but it's too late. If we strip sections here,
9360 the dynamic symbol table is corrupted since the section symbol
9361 for the stripped section isn't written. */
721956f4 9362
b34976b6 9363 return TRUE;
721956f4
AM		 9364}
9365
9366/* Called after we have determined section placement. If sections
805fc799 9367 move, we'll be called again. Provide a value for TOCstart. */
721956f4 9368
805fc799 9369bfd_vma
4ce794b7 9370ppc64_elf_toc (bfd *obfd)
721956f4 9371{
805fc799
AM		 9372 asection *s;
9373 bfd_vma TOCstart;
721956f4 9374
805fc799
AM		 9375 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
9376 order. The TOC starts where the first of these sections starts. */
9377 s = bfd_get_section_by_name (obfd, ".got");
9378 if (s == NULL)
9379 s = bfd_get_section_by_name (obfd, ".toc");
9380 if (s == NULL)
9381 s = bfd_get_section_by_name (obfd, ".tocbss");
9382 if (s == NULL)
9383 s = bfd_get_section_by_name (obfd, ".plt");
9384 if (s == NULL)
9385 {
9386 /* This may happen for
9387 o references to TOC base (SYM@toc / TOC[tc0]) without a
9388 .toc directive
9389 o bad linker script
9390 o --gc-sections and empty TOC sections
9391
9392 FIXME: Warn user? */
9393
9394 /* Look for a likely section. We probably won't even be
9395 using TOCstart. */
9396 for (s = obfd->sections; s != NULL; s = s->next)
9397 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY))
9398 == (SEC_ALLOC | SEC_SMALL_DATA))
9399 break;
721956f4 9400 if (s == NULL)
805fc799
AM		 9401 for (s = obfd->sections; s != NULL; s = s->next)
9402 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA))
9403 == (SEC_ALLOC | SEC_SMALL_DATA))
9404 break;
721956f4 9405 if (s == NULL)
805fc799
AM		 9406 for (s = obfd->sections; s != NULL; s = s->next)
9407 if ((s->flags & (SEC_ALLOC | SEC_READONLY)) == SEC_ALLOC)
9408 break;
721956f4 9409 if (s == NULL)
805fc799
AM		 9410 for (s = obfd->sections; s != NULL; s = s->next)
9411 if ((s->flags & SEC_ALLOC) == SEC_ALLOC)
9412 break;
9413 }
721956f4 9414
805fc799
AM		 9415 TOCstart = 0;
9416 if (s != NULL)
9417 TOCstart = s->output_section->vma + s->output_offset;
721956f4 9418
805fc799 9419 return TOCstart;
721956f4
AM		 9420}
9421
9422/* Build all the stubs associated with the current output file.
9423 The stubs are kept in a hash table attached to the main linker
9424 hash table. This function is called via gldelf64ppc_finish. */
9425
b34976b6 9426bfd_boolean
4ce794b7
AM		 9427ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
9428 struct bfd_link_info *info,
9429 char **stats)
5d1634d7
AM		 9430{
9431 struct ppc_link_hash_table *htab = ppc_hash_table (info);
721956f4 9432 asection *stub_sec;
5d1634d7 9433 bfd_byte *p;
e717da7e 9434 int stub_sec_count = 0;
5d1634d7 9435
ad8e1ba5 9436 htab->emit_stub_syms = emit_stub_syms;
eea6121a
AM		 9437
9438 /* Allocate memory to hold the linker stubs. */
721956f4
AM		 9439 for (stub_sec = htab->stub_bfd->sections;
9440 stub_sec != NULL;
9441 stub_sec = stub_sec->next)
eea6121a
AM		 9442 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
9443 && stub_sec->size != 0)
e717da7e 9444 {
eea6121a
AM		 9445 stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
9446 if (stub_sec->contents == NULL)
9447 return FALSE;
9448 /* We want to check that built size is the same as calculated
9449 size. rawsize is a convenient location to use. */
9450 stub_sec->rawsize = stub_sec->size;
9451 stub_sec->size = 0;
e717da7e 9452 }
5d1634d7 9453
4ce794b7 9454 if (htab->plt != NULL)
5d1634d7 9455 {
9f951329 9456 unsigned int indx;
ad8e1ba5 9457 bfd_vma plt0;
9f951329 9458
721956f4 9459 /* Build the .glink plt call stub. */
97b639ba
AM		 9460 if (htab->emit_stub_syms)
9461 {
9462 struct elf_link_hash_entry *h;
9463 h = elf_link_hash_lookup (&htab->elf, "__glink", TRUE, FALSE, FALSE);
9464 if (h == NULL)
9465 return FALSE;
9466 if (h->root.type == bfd_link_hash_new)
9467 {
9468 h->root.type = bfd_link_hash_defined;
9469 h->root.u.def.section = htab->glink;
ee4bf8d2 9470 h->root.u.def.value = 8;
f5385ebf
AM		 9471 h->ref_regular = 1;
9472 h->def_regular = 1;
9473 h->ref_regular_nonweak = 1;
9474 h->forced_local = 1;
9475 h->non_elf = 0;
97b639ba
AM		 9476 }
9477 }
4ce794b7 9478 p = htab->glink->contents;
ee4bf8d2
AM		 9479 plt0 = (htab->plt->output_section->vma
9480 + htab->plt->output_offset
9481 - (htab->glink->output_section->vma
9482 + htab->glink->output_offset
9483 + 16));
9484 bfd_put_64 (htab->glink->owner, plt0, p);
9485 p += 8;
9486 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
ad8e1ba5 9487 p += 4;
ee4bf8d2 9488 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
ad8e1ba5 9489 p += 4;
ee4bf8d2 9490 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
ad8e1ba5 9491 p += 4;
ee4bf8d2 9492 bfd_put_32 (htab->glink->owner, LD_R2_M16R11, p);
ad8e1ba5 9493 p += 4;
ee4bf8d2 9494 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
ad8e1ba5 9495 p += 4;
ee4bf8d2 9496 bfd_put_32 (htab->glink->owner, ADD_R12_R2_R11, p);
ad8e1ba5 9497 p += 4;
ee4bf8d2 9498 bfd_put_32 (htab->glink->owner, LD_R11_0R12, p);
ad8e1ba5 9499 p += 4;
4ce794b7 9500 bfd_put_32 (htab->glink->owner, LD_R2_0R12 | 8, p);
ad8e1ba5 9501 p += 4;
4ce794b7 9502 bfd_put_32 (htab->glink->owner, MTCTR_R11, p);
ad8e1ba5 9503 p += 4;
4ce794b7 9504 bfd_put_32 (htab->glink->owner, LD_R11_0R12 | 16, p);
ad8e1ba5 9505 p += 4;
4ce794b7 9506 bfd_put_32 (htab->glink->owner, BCTR, p);
ad8e1ba5 9507 p += 4;
ee4bf8d2
AM		 9508 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
9509 {
9510 bfd_put_32 (htab->glink->owner, NOP, p);
9511 p += 4;
9512 }
ad8e1ba5 9513
9f951329
AM		 9514 /* Build the .glink lazy link call stubs. */
9515 indx = 0;
eea6121a 9516 while (p < htab->glink->contents + htab->glink->size)
9f951329
AM		 9517 {
9518 if (indx < 0x8000)
9519 {
4ce794b7 9520 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
9f951329
AM		 9521 p += 4;
9522 }
9523 else
9524 {
4ce794b7 9525 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
9f951329 9526 p += 4;
4ce794b7 9527 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx), p);
9f951329
AM		 9528 p += 4;
9529 }
4ce794b7 9530 bfd_put_32 (htab->glink->owner,
ee4bf8d2 9531 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
a16d5acb 9532 indx++;
9f951329
AM		 9533 p += 4;
9534 }
eea6121a 9535 htab->glink->rawsize = p - htab->glink->contents;
5d1634d7 9536 }
5d1634d7 9537
eea6121a 9538 if (htab->brlt->size != 0)
721956f4 9539 {
4ce794b7 9540 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
eea6121a 9541 htab->brlt->size);
4ce794b7 9542 if (htab->brlt->contents == NULL)
b34976b6 9543 return FALSE;
721956f4 9544 }
ee75fd95 9545 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
63bc6f6c
AM		 9546 {
9547 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
eea6121a 9548 htab->relbrlt->size);
63bc6f6c
AM		 9549 if (htab->relbrlt->contents == NULL)
9550 return FALSE;
9551 }
5d1634d7 9552
721956f4
AM		 9553 /* Build the stubs as directed by the stub hash table. */
9554 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
5d1634d7 9555
aa8a7074
AM		 9556 if (htab->relbrlt != NULL)
9557 htab->relbrlt->reloc_count = 0;
9558
721956f4
AM		 9559 for (stub_sec = htab->stub_bfd->sections;
9560 stub_sec != NULL;
9561 stub_sec = stub_sec->next)
e717da7e
AM		 9562 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
9563 {
9564 stub_sec_count += 1;
eea6121a 9565 if (stub_sec->rawsize != stub_sec->size)
e717da7e
AM		 9566 break;
9567 }
5d1634d7 9568
721956f4 9569 if (stub_sec != NULL
eea6121a 9570 || htab->glink->rawsize != htab->glink->size)
5d1634d7 9571 {
b34976b6 9572 htab->stub_error = TRUE;
721956f4 9573 (*_bfd_error_handler) (_("stubs don't match calculated size"));
5d1634d7 9574 }
721956f4 9575
d2a300cf
AM		 9576 if (htab->stub_error)
9577 return FALSE;
9578
9579 if (stats != NULL)
9580 {
9581 *stats = bfd_malloc (500);
9582 if (*stats == NULL)
9583 return FALSE;
9584
ee75fd95 9585 sprintf (*stats, _("linker stubs in %u group%s\n"
d2a300cf
AM		 9586 " branch %lu\n"
9587 " toc adjust %lu\n"
9588 " long branch %lu\n"
9589 " long toc adj %lu\n"
9590 " plt call %lu"),
e717da7e 9591 stub_sec_count,
ee75fd95 9592 stub_sec_count == 1 ? "" : "s",
4ce794b7
AM		 9593 htab->stub_count[ppc_stub_long_branch - 1],
9594 htab->stub_count[ppc_stub_long_branch_r2off - 1],
9595 htab->stub_count[ppc_stub_plt_branch - 1],
9596 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
9597 htab->stub_count[ppc_stub_plt_call - 1]);
d2a300cf
AM		 9598 }
9599 return TRUE;
5bd4f169
AM		 9600}
9601
99877b66
AM		 9602/* This function undoes the changes made by add_symbol_adjust. */
9603
9604static bfd_boolean
9605undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
9606{
9607 struct ppc_link_hash_entry *eh;
9608
9609 if (h->root.type == bfd_link_hash_indirect)
9610 return TRUE;
9611
9612 if (h->root.type == bfd_link_hash_warning)
9613 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9614
9615 eh = (struct ppc_link_hash_entry *) h;
9616 if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
9617 return TRUE;
9618
9619 eh->elf.root.type = bfd_link_hash_undefined;
9620 return TRUE;
9621}
9622
9623void
9624ppc64_elf_restore_symbols (struct bfd_link_info *info)
9625{
9626 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9627 elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
9628}
9629
60124e18
AM		 9630/* What to do when ld finds relocations against symbols defined in
9631 discarded sections. */
9632
9633static unsigned int
9634ppc64_elf_action_discarded (asection *sec)
9635{
9636 if (strcmp (".opd", sec->name) == 0)
9637 return 0;
9638
9639 if (strcmp (".toc", sec->name) == 0)
9640 return 0;
9641
bce50a28
JJ		 9642 if (strcmp (".toc1", sec->name) == 0)
9643 return 0;
9644
60124e18
AM		 9645 return _bfd_elf_default_action_discarded (sec);
9646}
9647
5bd4f169
AM		 9648/* The RELOCATE_SECTION function is called by the ELF backend linker
9649 to handle the relocations for a section.
9650
9651 The relocs are always passed as Rela structures; if the section
9652 actually uses Rel structures, the r_addend field will always be
9653 zero.
9654
9655 This function is responsible for adjust the section contents as
9656 necessary, and (if using Rela relocs and generating a
1049f94e 9657 relocatable output file) adjusting the reloc addend as
5bd4f169
AM		 9658 necessary.
9659
9660 This function does not have to worry about setting the reloc
9661 address or the reloc symbol index.
9662
9663 LOCAL_SYMS is a pointer to the swapped in local symbols.
9664
9665 LOCAL_SECTIONS is an array giving the section in the input file
9666 corresponding to the st_shndx field of each local symbol.
9667
9668 The global hash table entry for the global symbols can be found
9669 via elf_sym_hashes (input_bfd).
9670
1049f94e 9671 When generating relocatable output, this function must handle
5bd4f169
AM		 9672 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
9673 going to be the section symbol corresponding to the output
9674 section, which means that the addend must be adjusted
9675 accordingly. */
9676
b34976b6 9677static bfd_boolean
4ce794b7
AM		 9678ppc64_elf_relocate_section (bfd *output_bfd,
9679 struct bfd_link_info *info,
9680 bfd *input_bfd,
9681 asection *input_section,
9682 bfd_byte *contents,
9683 Elf_Internal_Rela *relocs,
9684 Elf_Internal_Sym *local_syms,
9685 asection **local_sections)
5bd4f169 9686{
65f38f15 9687 struct ppc_link_hash_table *htab;
5bd4f169
AM		 9688 Elf_Internal_Shdr *symtab_hdr;
9689 struct elf_link_hash_entry **sym_hashes;
5bd4f169
AM		 9690 Elf_Internal_Rela *rel;
9691 Elf_Internal_Rela *relend;
411e1bfb
AM		 9692 Elf_Internal_Rela outrel;
9693 bfd_byte *loc;
411e1bfb 9694 struct got_entry **local_got_ents;
5bd4f169 9695 bfd_vma TOCstart;
b34976b6
AM		 9696 bfd_boolean ret = TRUE;
9697 bfd_boolean is_opd;
96e0dda4 9698 /* Disabled until we sort out how ld should choose 'y' vs 'at'. */
b34976b6 9699 bfd_boolean is_power4 = FALSE;
5bd4f169 9700
65f38f15 9701 /* Initialize howto table if needed. */
5bd4f169 9702 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5bd4f169
AM		 9703 ppc_howto_init ();
9704
65f38f15 9705 htab = ppc_hash_table (info);
ee75fd95
AM		 9706
9707 /* Don't relocate stub sections. */
9708 if (input_section->owner == htab->stub_bfd)
9709 return TRUE;
9710
411e1bfb 9711 local_got_ents = elf_local_got_ents (input_bfd);
5bd4f169 9712 TOCstart = elf_gp (output_bfd);
5bd4f169
AM		 9713 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
9714 sym_hashes = elf_sym_hashes (input_bfd);
f0abc2a1 9715 is_opd = ppc64_elf_section_data (input_section)->opd.adjust != NULL;
65f38f15 9716
5bd4f169
AM		 9717 rel = relocs;
9718 relend = relocs + input_section->reloc_count;
9719 for (; rel < relend; rel++)
9720 {
04c9666a 9721 enum elf_ppc64_reloc_type r_type;
4cc603a5 9722 bfd_vma addend, orig_addend;
5bd4f169
AM		 9723 bfd_reloc_status_type r;
9724 Elf_Internal_Sym *sym;
9725 asection *sec;
039b3fef
AM		 9726 struct elf_link_hash_entry *h_elf;
9727 struct ppc_link_hash_entry *h;
9728 struct ppc_link_hash_entry *fdh;
5bd4f169 9729 const char *sym_name;
0d4792f7 9730 unsigned long r_symndx, toc_symndx;
951fd09b 9731 char tls_mask, tls_gd, tls_type;
0d4792f7 9732 char sym_type;
5bd4f169 9733 bfd_vma relocation;
b34976b6
AM		 9734 bfd_boolean unresolved_reloc;
9735 bfd_boolean warned;
50bc7936 9736 unsigned long insn, mask;
721956f4
AM		 9737 struct ppc_stub_hash_entry *stub_entry;
9738 bfd_vma max_br_offset;
9739 bfd_vma from;
5bd4f169 9740
4ce794b7 9741 r_type = ELF64_R_TYPE (rel->r_info);
5bd4f169 9742 r_symndx = ELF64_R_SYM (rel->r_info);
ee87f2da
AM		 9743
9744 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
9745 symbol of the previous ADDR64 reloc. The symbol gives us the
9746 proper TOC base to use. */
9747 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
9748 && rel != relocs
9749 && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
9750 && is_opd)
9751 r_symndx = ELF64_R_SYM (rel[-1].r_info);
9752
4ce794b7
AM		 9753 sym = NULL;
9754 sec = NULL;
039b3fef 9755 h_elf = NULL;
4ce794b7 9756 sym_name = NULL;
b34976b6
AM		 9757 unresolved_reloc = FALSE;
9758 warned = FALSE;
4cc603a5 9759 orig_addend = rel->r_addend;
65f38f15 9760
0b13192e 9761 if (r_symndx < symtab_hdr->sh_info)
5bd4f169
AM		 9762 {
9763 /* It's a local symbol. */
4025353c
AM		 9764 long *opd_adjust;
9765
5bd4f169
AM		 9766 sym = local_syms + r_symndx;
9767 sec = local_sections[r_symndx];
26c61ae5 9768 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
0d4792f7 9769 sym_type = ELF64_ST_TYPE (sym->st_info);
8517fae7 9770 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
4025353c
AM		 9771 opd_adjust = get_opd_info (sec);
9772 if (opd_adjust != NULL)
1e2f5b6e 9773 {
3f764659 9774 long adjust = opd_adjust[(sym->st_value + rel->r_addend) / 8];
4025353c
AM		 9775 if (adjust == -1)
9776 relocation = 0;
9777 else
4cc603a5
AM		 9778 {
9779 /* If this is a relocation against the opd section sym
9780 and we have edited .opd, adjust the reloc addend so
9781 that ld -r and ld --emit-relocs output is correct.
9782 If it is a reloc against some other .opd symbol,
9783 then the symbol value will be adjusted later. */
9784 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
9785 rel->r_addend += adjust;
9786 else
9787 relocation += adjust;
9788 }
1e2f5b6e 9789 }
4cc603a5
AM		 9790 if (info->relocatable)
9791 continue;
5bd4f169
AM		 9792 }
9793 else
9794 {
4cc603a5
AM		 9795 if (info->relocatable)
9796 continue;
b2a8e766
AM		 9797 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
9798 r_symndx, symtab_hdr, sym_hashes,
039b3fef 9799 h_elf, sec, relocation,
b2a8e766 9800 unresolved_reloc, warned);
039b3fef
AM		 9801 sym_name = h_elf->root.root.string;
9802 sym_type = h_elf->type;
5bd4f169 9803 }
039b3fef 9804 h = (struct ppc_link_hash_entry *) h_elf;
5bd4f169 9805
951fd09b
AM		 9806 /* TLS optimizations. Replace instruction sequences and relocs
9807 based on information we collected in tls_optimize. We edit
9808 RELOCS so that --emit-relocs will output something sensible
9809 for the final instruction stream. */
9810 tls_mask = 0;
9811 tls_gd = 0;
0d4792f7 9812 toc_symndx = 0;
d881513a 9813 if (IS_PPC64_TLS_RELOC (r_type))
411e1bfb
AM		 9814 {
9815 if (h != NULL)
039b3fef 9816 tls_mask = h->tls_mask;
411e1bfb
AM		 9817 else if (local_got_ents != NULL)
9818 {
e7b938ca
AM		 9819 char *lgot_masks;
9820 lgot_masks = (char *) (local_got_ents + symtab_hdr->sh_info);
9821 tls_mask = lgot_masks[r_symndx];
411e1bfb 9822 }
0d4792f7
AM		 9823 if (tls_mask == 0 && r_type == R_PPC64_TLS)
9824 {
9825 /* Check for toc tls entries. */
9826 char *toc_tls;
9827
9828 if (!get_tls_mask (&toc_tls, &toc_symndx, &local_syms,
9829 rel, input_bfd))
9830 return FALSE;
9831
9832 if (toc_tls)
9833 tls_mask = *toc_tls;
9834 }
9835 }
9836
9837 /* Check that tls relocs are used with tls syms, and non-tls
9838 relocs are used with non-tls syms. */
9839 if (r_symndx != 0
9840 && r_type != R_PPC64_NONE
9841 && (h == NULL
039b3fef
AM		 9842 || h->elf.root.type == bfd_link_hash_defined
9843 || h->elf.root.type == bfd_link_hash_defweak)
0d4792f7
AM		 9844 && IS_PPC64_TLS_RELOC (r_type) != (sym_type == STT_TLS))
9845 {
9846 if (r_type == R_PPC64_TLS && tls_mask != 0)
9847 /* R_PPC64_TLS is OK against a symbol in the TOC. */
9848 ;
9849 else
9850 (*_bfd_error_handler)
9851 (sym_type == STT_TLS
d003868e
AM		 9852 ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
9853 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s"),
9854 input_bfd,
9855 input_section,
0d4792f7
AM		 9856 (long) rel->r_offset,
9857 ppc64_elf_howto_table[r_type]->name,
9858 sym_name);
411e1bfb
AM		 9859 }
9860
9861 /* Ensure reloc mapping code below stays sane. */
9862 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
9863 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
9864 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
9865 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
9866 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
9867 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
9868 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
9869 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
9870 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
9871 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
9872 abort ();
0d4792f7 9873
411e1bfb
AM		 9874 switch (r_type)
9875 {
9876 default:
411e1bfb
AM		 9877 break;
9878
9879 case R_PPC64_TOC16:
9880 case R_PPC64_TOC16_LO:
9881 case R_PPC64_TOC16_DS:
9882 case R_PPC64_TOC16_LO_DS:
411e1bfb
AM		 9883 {
9884 /* Check for toc tls entries. */
9885 char *toc_tls;
951fd09b 9886 int retval;
411e1bfb 9887
0d4792f7
AM		 9888 retval = get_tls_mask (&toc_tls, &toc_symndx, &local_syms,
9889 rel, input_bfd);
951fd09b 9890 if (retval == 0)
411e1bfb
AM		 9891 return FALSE;
9892
9893 if (toc_tls)
9894 {
951fd09b 9895 tls_mask = *toc_tls;
411e1bfb
AM		 9896 if (r_type == R_PPC64_TOC16_DS
9897 || r_type == R_PPC64_TOC16_LO_DS)
81407a69
AM		 9898 {
9899 if (tls_mask != 0
9900 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
9901 goto toctprel;
9902 }
411e1bfb 9903 else
951fd09b
AM		 9904 {
9905 /* If we found a GD reloc pair, then we might be
9906 doing a GD->IE transition. */
9907 if (retval == 2)
9908 {
9909 tls_gd = TLS_TPRELGD;
9910 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
9911 goto tls_get_addr_check;
9912 }
9913 else if (retval == 3)
9914 {
9915 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
9916 goto tls_get_addr_check;
9917 }
9918 }
411e1bfb
AM		 9919 }
9920 }
9921 break;
9922
9923 case R_PPC64_GOT_TPREL16_DS:
9924 case R_PPC64_GOT_TPREL16_LO_DS:
951fd09b
AM		 9925 if (tls_mask != 0
9926 && (tls_mask & TLS_TPREL) == 0)
411e1bfb 9927 {
81407a69 9928 toctprel:
411e1bfb
AM		 9929 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - 2);
9930 insn &= 31 << 21;
9931 insn |= 0x3c0d0000; /* addis 0,13,0 */
9932 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - 2);
9933 r_type = R_PPC64_TPREL16_HA;
0d4792f7
AM		 9934 if (toc_symndx != 0)
9935 {
9936 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
9937 /* We changed the symbol. Start over in order to
9938 get h, sym, sec etc. right. */
9939 rel--;
9940 continue;
9941 }
9942 else
9943 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
411e1bfb
AM		 9944 }
9945 break;
9946
9947 case R_PPC64_TLS:
951fd09b
AM		 9948 if (tls_mask != 0
9949 && (tls_mask & TLS_TPREL) == 0)
411e1bfb 9950 {
50bc7936 9951 bfd_vma rtra;
411e1bfb 9952 insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
772119ce 9953 if ((insn & ((0x3f << 26) | (31 << 11)))
411e1bfb
AM		 9954 == ((31 << 26) | (13 << 11)))
9955 rtra = insn & ((1 << 26) - (1 << 16));
772119ce 9956 else if ((insn & ((0x3f << 26) | (31 << 16)))
411e1bfb
AM		 9957 == ((31 << 26) | (13 << 16)))
9958 rtra = (insn & (31 << 21)) | ((insn & (31 << 11)) << 5);
9959 else
9960 abort ();
9961 if ((insn & ((1 << 11) - (1 << 1))) == 266 << 1)
9962 /* add -> addi. */
9963 insn = 14 << 26;
9964 else if ((insn & (31 << 1)) == 23 << 1
9965 && ((insn & (31 << 6)) < 14 << 6
9966 || ((insn & (31 << 6)) >= 16 << 6
9967 && (insn & (31 << 6)) < 24 << 6)))
9968 /* load and store indexed -> dform. */
9969 insn = (32 | ((insn >> 6) & 31)) << 26;
9970 else if ((insn & (31 << 1)) == 21 << 1
9971 && (insn & (0x1a << 6)) == 0)
9972 /* ldx, ldux, stdx, stdux -> ld, ldu, std, stdu. */
9973 insn = (((58 | ((insn >> 6) & 4)) << 26)
9974 | ((insn >> 6) & 1));
9975 else if ((insn & (31 << 1)) == 21 << 1
9976 && (insn & ((1 << 11) - (1 << 1))) == 341 << 1)
9977 /* lwax -> lwa. */
9978 insn = (58 << 26) | 2;
9979 else
9980 abort ();
9981 insn |= rtra;
9982 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
411e1bfb
AM		 9983 /* Was PPC64_TLS which sits on insn boundary, now
9984 PPC64_TPREL16_LO which is at insn+2. */
9985 rel->r_offset += 2;
0d4792f7
AM		 9986 r_type = R_PPC64_TPREL16_LO;
9987 if (toc_symndx != 0)
9988 {
9989 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
9990 /* We changed the symbol. Start over in order to
9991 get h, sym, sec etc. right. */
9992 rel--;
9993 continue;
9994 }
9995 else
9996 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
411e1bfb
AM		 9997 }
9998 break;
9999
411e1bfb
AM		 10000 case R_PPC64_GOT_TLSGD16_HI:
10001 case R_PPC64_GOT_TLSGD16_HA:
951fd09b
AM		 10002 tls_gd = TLS_TPRELGD;
10003 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
10004 goto tls_gdld_hi;
10005 break;
10006
411e1bfb
AM		 10007 case R_PPC64_GOT_TLSLD16_HI:
10008 case R_PPC64_GOT_TLSLD16_HA:
951fd09b 10009 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
411e1bfb 10010 {
951fd09b
AM		 10011 tls_gdld_hi:
10012 if ((tls_mask & tls_gd) != 0)
10013 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
10014 + R_PPC64_GOT_TPREL16_DS);
10015 else
411e1bfb 10016 {
951fd09b
AM		 10017 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
10018 rel->r_offset -= 2;
10019 r_type = R_PPC64_NONE;
411e1bfb 10020 }
951fd09b 10021 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
411e1bfb
AM		 10022 }
10023 break;
10024
951fd09b
AM		 10025 case R_PPC64_GOT_TLSGD16:
10026 case R_PPC64_GOT_TLSGD16_LO:
10027 tls_gd = TLS_TPRELGD;
10028 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
10029 goto tls_get_addr_check;
10030 break;
411e1bfb 10031
951fd09b
AM		 10032 case R_PPC64_GOT_TLSLD16:
10033 case R_PPC64_GOT_TLSLD16_LO:
10034 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
10035 {
10036 tls_get_addr_check:
10037 if (rel + 1 < relend)
411e1bfb 10038 {
951fd09b
AM		 10039 enum elf_ppc64_reloc_type r_type2;
10040 unsigned long r_symndx2;
10041 struct elf_link_hash_entry *h2;
10042 bfd_vma insn1, insn2, insn3;
10043 bfd_vma offset;
10044
10045 /* The next instruction should be a call to
10046 __tls_get_addr. Peek at the reloc to be sure. */
4ce794b7 10047 r_type2 = ELF64_R_TYPE (rel[1].r_info);
951fd09b
AM		 10048 r_symndx2 = ELF64_R_SYM (rel[1].r_info);
10049 if (r_symndx2 < symtab_hdr->sh_info
10050 || (r_type2 != R_PPC64_REL14
10051 && r_type2 != R_PPC64_REL14_BRTAKEN
10052 && r_type2 != R_PPC64_REL14_BRNTAKEN
10053 && r_type2 != R_PPC64_REL24))
10054 break;
10055
10056 h2 = sym_hashes[r_symndx2 - symtab_hdr->sh_info];
10057 while (h2->root.type == bfd_link_hash_indirect
10058 || h2->root.type == bfd_link_hash_warning)
10059 h2 = (struct elf_link_hash_entry *) h2->root.u.i.link;
8387904d
AM		 10060 if (h2 == NULL || (h2 != &htab->tls_get_addr->elf
10061 && h2 != &htab->tls_get_addr_fd->elf))
951fd09b
AM		 10062 break;
10063
10064 /* OK, it checks out. Replace the call. */
10065 offset = rel[1].r_offset;
10066 insn1 = bfd_get_32 (output_bfd,
10067 contents + rel->r_offset - 2);
10068 insn3 = bfd_get_32 (output_bfd,
10069 contents + offset + 4);
10070 if ((tls_mask & tls_gd) != 0)
411e1bfb 10071 {
951fd09b
AM		 10072 /* IE */
10073 insn1 &= (1 << 26) - (1 << 2);
10074 insn1 |= 58 << 26; /* ld */
10075 insn2 = 0x7c636a14; /* add 3,3,13 */
10076 rel[1].r_info = ELF64_R_INFO (r_symndx2, R_PPC64_NONE);
10077 if ((tls_mask & TLS_EXPLICIT) == 0)
10078 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
10079 + R_PPC64_GOT_TPREL16_DS);
10080 else
10081 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
10082 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
411e1bfb
AM		 10083 }
10084 else
951fd09b
AM		 10085 {
10086 /* LE */
10087 insn1 = 0x3c6d0000; /* addis 3,13,0 */
10088 insn2 = 0x38630000; /* addi 3,3,0 */
10089 if (tls_gd == 0)
10090 {
10091 /* Was an LD reloc. */
10092 r_symndx = 0;
e1918d23
AM		 10093 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
10094 rel[1].r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
951fd09b 10095 }
0d4792f7
AM		 10096 else if (toc_symndx != 0)
10097 r_symndx = toc_symndx;
951fd09b
AM		 10098 r_type = R_PPC64_TPREL16_HA;
10099 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10100 rel[1].r_info = ELF64_R_INFO (r_symndx,
10101 R_PPC64_TPREL16_LO);
10102 rel[1].r_offset += 2;
10103 }
10104 if (insn3 == NOP
10105 || insn3 == CROR_151515 || insn3 == CROR_313131)
10106 {
10107 insn3 = insn2;
10108 insn2 = NOP;
10109 rel[1].r_offset += 4;
10110 }
10111 bfd_put_32 (output_bfd, insn1, contents + rel->r_offset - 2);
10112 bfd_put_32 (output_bfd, insn2, contents + offset);
10113 bfd_put_32 (output_bfd, insn3, contents + offset + 4);
0d4792f7 10114 if (tls_gd == 0 || toc_symndx != 0)
951fd09b 10115 {
0d4792f7
AM		 10116 /* We changed the symbol. Start over in order
10117 to get h, sym, sec etc. right. */
951fd09b
AM		 10118 rel--;
10119 continue;
10120 }
411e1bfb 10121 }
411e1bfb 10122 }
411e1bfb
AM		 10123 break;
10124
10125 case R_PPC64_DTPMOD64:
951fd09b
AM		 10126 if (rel + 1 < relend
10127 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
10128 && rel[1].r_offset == rel->r_offset + 8)
411e1bfb 10129 {
951fd09b
AM		 10130 if ((tls_mask & TLS_GD) == 0)
10131 {
10132 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
10133 if ((tls_mask & TLS_TPRELGD) != 0)
10134 r_type = R_PPC64_TPREL64;
10135 else
10136 {
4ce794b7 10137 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
951fd09b
AM		 10138 r_type = R_PPC64_NONE;
10139 }
10140 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10141 }
10142 }
10143 else
10144 {
10145 if ((tls_mask & TLS_LD) == 0)
411e1bfb 10146 {
4ce794b7 10147 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
411e1bfb 10148 r_type = R_PPC64_NONE;
951fd09b 10149 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
411e1bfb 10150 }
411e1bfb
AM		 10151 }
10152 break;
10153
10154 case R_PPC64_TPREL64:
951fd09b 10155 if ((tls_mask & TLS_TPREL) == 0)
411e1bfb
AM		 10156 {
10157 r_type = R_PPC64_NONE;
10158 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10159 }
10160 break;
10161 }
10162
10163 /* Handle other relocations that tweak non-addend part of insn. */
86c76c7b 10164 insn = 0;
b25116a9
AM		 10165 max_br_offset = 1 << 25;
10166 addend = rel->r_addend;
65f38f15 10167 switch (r_type)
5bd4f169
AM		 10168 {
10169 default:
65f38f15 10170 break;
5bd4f169 10171
65f38f15
AM		 10172 /* Branch taken prediction relocations. */
10173 case R_PPC64_ADDR14_BRTAKEN:
10174 case R_PPC64_REL14_BRTAKEN:
cedb70c5
KH		 10175 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
10176 /* Fall thru. */
65f38f15 10177
86c76c7b 10178 /* Branch not taken prediction relocations. */
65f38f15
AM		 10179 case R_PPC64_ADDR14_BRNTAKEN:
10180 case R_PPC64_REL14_BRNTAKEN:
411e1bfb
AM		 10181 insn |= bfd_get_32 (output_bfd,
10182 contents + rel->r_offset) & ~(0x01 << 21);
b25116a9 10183 /* Fall thru. */
86c76c7b 10184
b25116a9
AM		 10185 case R_PPC64_REL14:
10186 max_br_offset = 1 << 15;
10187 /* Fall thru. */
5bd4f169 10188
65f38f15 10189 case R_PPC64_REL24:
ad8e1ba5
AM		 10190 /* Calls to functions with a different TOC, such as calls to
10191 shared objects, need to alter the TOC pointer. This is
10192 done using a linkage stub. A REL24 branching to these
10193 linkage stubs needs to be followed by a nop, as the nop
10194 will be replaced with an instruction to restore the TOC
10195 base pointer. */
b25116a9 10196 stub_entry = NULL;
8387904d 10197 fdh = h;
ad8e1ba5 10198 if (((h != NULL
039b3fef
AM		 10199 && (((fdh = h->oh) != NULL
10200 && fdh->elf.plt.plist != NULL)
10201 || (fdh = h)->elf.plt.plist != NULL))
8387904d 10202 || (sec != NULL
ad8e1ba5 10203 && sec->output_section != NULL
b25116a9 10204 && sec->id <= htab->top_id
ad8e1ba5
AM		 10205 && (htab->stub_group[sec->id].toc_off
10206 != htab->stub_group[input_section->id].toc_off)))
721956f4 10207 && (stub_entry = ppc_get_stub_entry (input_section, sec, fdh,
ad8e1ba5
AM		 10208 rel, htab)) != NULL
10209 && (stub_entry->stub_type == ppc_stub_plt_call
10210 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
10211 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
41bd81ab 10212 {
b25116a9 10213 bfd_boolean can_plt_call = FALSE;
721956f4 10214
eea6121a 10215 if (rel->r_offset + 8 <= input_section->size)
41bd81ab 10216 {
b25116a9
AM		 10217 unsigned long nop;
10218 nop = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
10219 if (nop == NOP
10220 || nop == CROR_151515 || nop == CROR_313131)
41bd81ab 10221 {
4ce794b7 10222 bfd_put_32 (input_bfd, LD_R2_40R1,
411e1bfb 10223 contents + rel->r_offset + 4);
b25116a9 10224 can_plt_call = TRUE;
41bd81ab 10225 }
5bd4f169 10226 }
721956f4
AM		 10227
10228 if (!can_plt_call)
10229 {
ad8e1ba5
AM		 10230 if (stub_entry->stub_type == ppc_stub_plt_call)
10231 {
10232 /* If this is a plain branch rather than a branch
4fa1c237
AM		 10233 and link, don't require a nop. However, don't
10234 allow tail calls in a shared library as they
10235 will result in r2 being corrupted. */
b25116a9
AM		 10236 unsigned long br;
10237 br = bfd_get_32 (input_bfd, contents + rel->r_offset);
4fa1c237 10238 if (info->executable && (br & 1) == 0)
b25116a9 10239 can_plt_call = TRUE;
15b552e9
AM		 10240 else
10241 stub_entry = NULL;
ad8e1ba5 10242 }
6ab189d5 10243 else if (h != NULL
039b3fef 10244 && strcmp (h->elf.root.root.string,
6ab189d5
AM		 10245 ".__libc_start_main") == 0)
10246 {
10247 /* Allow crt1 branch to go via a toc adjusting stub. */
b25116a9 10248 can_plt_call = TRUE;
6ab189d5 10249 }
ad8e1ba5
AM		 10250 else
10251 {
10252 if (strcmp (input_section->output_section->name,
10253 ".init") == 0
10254 || strcmp (input_section->output_section->name,
10255 ".fini") == 0)
10256 (*_bfd_error_handler)
d003868e 10257 (_("%B(%A+0x%lx): automatic multiple TOCs "
ad8e1ba5
AM		 10258 "not supported using your crt files; "
10259 "recompile with -mminimal-toc or upgrade gcc"),
d003868e
AM		 10260 input_bfd,
10261 input_section,
ad8e1ba5
AM		 10262 (long) rel->r_offset);
10263 else
10264 (*_bfd_error_handler)
d003868e 10265 (_("%B(%A+0x%lx): sibling call optimization to `%s' "
ad8e1ba5
AM		 10266 "does not allow automatic multiple TOCs; "
10267 "recompile with -mminimal-toc or "
10268 "-fno-optimize-sibling-calls, "
10269 "or make `%s' extern"),
d003868e
AM		 10270 input_bfd,
10271 input_section,
ad8e1ba5
AM		 10272 (long) rel->r_offset,
10273 sym_name,
10274 sym_name);
10275 bfd_set_error (bfd_error_bad_value);
10276 ret = FALSE;
10277 }
721956f4
AM		 10278 }
10279
b25116a9
AM		 10280 if (can_plt_call
10281 && stub_entry->stub_type == ppc_stub_plt_call)
10282 unresolved_reloc = FALSE;
10283 }
10284
8387904d
AM		 10285 if (stub_entry == NULL
10286 && get_opd_info (sec) != NULL)
10287 {
10288 /* The branch destination is the value of the opd entry. */
4cc603a5
AM		 10289 bfd_vma off = (relocation + addend
10290 - sec->output_section->vma
10291 - sec->output_offset);
8387904d
AM		 10292 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL);
10293 if (dest != (bfd_vma) -1)
10294 {
10295 relocation = dest;
10296 addend = 0;
10297 }
10298 }
10299
b25116a9
AM		 10300 /* If the branch is out of reach we ought to have a long
10301 branch stub. */
10302 from = (rel->r_offset
10303 + input_section->output_offset
10304 + input_section->output_section->vma);
10305
10306 if (stub_entry == NULL
4cc603a5 10307 && (relocation + addend - from + max_br_offset
b25116a9
AM		 10308 >= 2 * max_br_offset)
10309 && r_type != R_PPC64_ADDR14_BRTAKEN
10310 && r_type != R_PPC64_ADDR14_BRNTAKEN)
039b3fef
AM		 10311 stub_entry = ppc_get_stub_entry (input_section, sec, h, rel,
10312 htab);
b25116a9
AM		 10313
10314 if (stub_entry != NULL)
10315 {
10316 /* Munge up the value and addend so that we call the stub
10317 rather than the procedure directly. */
10318 relocation = (stub_entry->stub_offset
10319 + stub_entry->stub_sec->output_offset
10320 + stub_entry->stub_sec->output_section->vma);
10321 addend = 0;
10322 }
10323
10324 if (insn != 0)
10325 {
10326 if (is_power4)
721956f4 10327 {
b25116a9
AM		 10328 /* Set 'a' bit. This is 0b00010 in BO field for branch
10329 on CR(BI) insns (BO == 001at or 011at), and 0b01000
10330 for branch on CTR insns (BO == 1a00t or 1a01t). */
10331 if ((insn & (0x14 << 21)) == (0x04 << 21))
10332 insn |= 0x02 << 21;
10333 else if ((insn & (0x14 << 21)) == (0x10 << 21))
10334 insn |= 0x08 << 21;
10335 else
10336 break;
10337 }
10338 else
10339 {
10340 /* Invert 'y' bit if not the default. */
4cc603a5 10341 if ((bfd_signed_vma) (relocation + addend - from) < 0)
b25116a9 10342 insn ^= 0x01 << 21;
721956f4 10343 }
b25116a9
AM		 10344
10345 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
5bd4f169 10346 }
e86ce104 10347
06da1e8e
AM		 10348 /* NOP out calls to undefined weak functions.
10349 We can thus call a weak function without first
10350 checking whether the function is defined. */
b25116a9 10351 else if (h != NULL
039b3fef 10352 && h->elf.root.type == bfd_link_hash_undefweak
b25116a9
AM		 10353 && r_type == R_PPC64_REL24
10354 && relocation == 0
4cc603a5 10355 && addend == 0)
e86ce104 10356 {
06da1e8e
AM		 10357 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
10358 continue;
e86ce104 10359 }
65f38f15
AM		 10360 break;
10361 }
5bd4f169 10362
65f38f15 10363 /* Set `addend'. */
411e1bfb 10364 tls_type = 0;
65f38f15
AM		 10365 switch (r_type)
10366 {
10367 default:
10368 (*_bfd_error_handler)
d003868e
AM		 10369 (_("%B: unknown relocation type %d for symbol %s"),
10370 input_bfd, (int) r_type, sym_name);
5bd4f169 10371
65f38f15 10372 bfd_set_error (bfd_error_bad_value);
b34976b6 10373 ret = FALSE;
65f38f15 10374 continue;
5bd4f169 10375
65f38f15 10376 case R_PPC64_NONE:
411e1bfb 10377 case R_PPC64_TLS:
04c9666a
AM		 10378 case R_PPC64_GNU_VTINHERIT:
10379 case R_PPC64_GNU_VTENTRY:
65f38f15 10380 continue;
5bd4f169
AM		 10381
10382 /* GOT16 relocations. Like an ADDR16 using the symbol's
10383 address in the GOT as relocation value instead of the
411e1bfb 10384 symbol's value itself. Also, create a GOT entry for the
5bd4f169 10385 symbol and put the symbol value there. */
411e1bfb
AM		 10386 case R_PPC64_GOT_TLSGD16:
10387 case R_PPC64_GOT_TLSGD16_LO:
10388 case R_PPC64_GOT_TLSGD16_HI:
10389 case R_PPC64_GOT_TLSGD16_HA:
951fd09b 10390 tls_type = TLS_TLS | TLS_GD;
411e1bfb
AM		 10391 goto dogot;
10392
10393 case R_PPC64_GOT_TLSLD16:
10394 case R_PPC64_GOT_TLSLD16_LO:
10395 case R_PPC64_GOT_TLSLD16_HI:
10396 case R_PPC64_GOT_TLSLD16_HA:
951fd09b 10397 tls_type = TLS_TLS | TLS_LD;
411e1bfb
AM		 10398 goto dogot;
10399
10400 case R_PPC64_GOT_TPREL16_DS:
10401 case R_PPC64_GOT_TPREL16_LO_DS:
10402 case R_PPC64_GOT_TPREL16_HI:
10403 case R_PPC64_GOT_TPREL16_HA:
10404 tls_type = TLS_TLS | TLS_TPREL;
10405 goto dogot;
10406
10407 case R_PPC64_GOT_DTPREL16_DS:
10408 case R_PPC64_GOT_DTPREL16_LO_DS:
10409 case R_PPC64_GOT_DTPREL16_HI:
10410 case R_PPC64_GOT_DTPREL16_HA:
10411 tls_type = TLS_TLS | TLS_DTPREL;
10412 goto dogot;
10413
65f38f15
AM		 10414 case R_PPC64_GOT16:
10415 case R_PPC64_GOT16_LO:
10416 case R_PPC64_GOT16_HI:
10417 case R_PPC64_GOT16_HA:
10418 case R_PPC64_GOT16_DS:
10419 case R_PPC64_GOT16_LO_DS:
411e1bfb 10420 dogot:
5bd4f169
AM		 10421 {
10422 /* Relocation is to the entry for this symbol in the global
10423 offset table. */
e717da7e 10424 asection *got;
d881513a 10425 bfd_vma *offp;
5bd4f169 10426 bfd_vma off;
d881513a 10427 unsigned long indx = 0;
65f38f15 10428
d881513a
AM		 10429 if (tls_type == (TLS_TLS | TLS_LD)
10430 && (h == NULL
f5385ebf 10431 || !h->elf.def_dynamic))
e717da7e 10432 offp = &ppc64_tlsld_got (input_bfd)->offset;
411e1bfb 10433 else
5bd4f169 10434 {
d881513a 10435 struct got_entry *ent;
5bd4f169 10436
d881513a
AM		 10437 if (h != NULL)
10438 {
10439 bfd_boolean dyn = htab->elf.dynamic_sections_created;
039b3fef
AM		 10440 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
10441 &h->elf)
d881513a 10442 || (info->shared
039b3fef 10443 && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
d881513a
AM		 10444 /* This is actually a static link, or it is a
10445 -Bsymbolic link and the symbol is defined
10446 locally, or the symbol was forced to be local
10447 because of a version file. */
10448 ;
10449 else
10450 {
039b3fef 10451 indx = h->elf.dynindx;
d881513a
AM		 10452 unresolved_reloc = FALSE;
10453 }
039b3fef 10454 ent = h->elf.got.glist;
d881513a 10455 }
411e1bfb 10456 else
5bd4f169 10457 {
d881513a
AM		 10458 if (local_got_ents == NULL)
10459 abort ();
10460 ent = local_got_ents[r_symndx];
5bd4f169 10461 }
d881513a
AM		 10462
10463 for (; ent != NULL; ent = ent->next)
4cc603a5 10464 if (ent->addend == orig_addend
e717da7e 10465 && ent->owner == input_bfd
d881513a
AM		 10466 && ent->tls_type == tls_type)
10467 break;
10468 if (ent == NULL)
10469 abort ();
10470 offp = &ent->got.offset;
5bd4f169 10471 }
411e1bfb 10472
e717da7e
AM		 10473 got = ppc64_elf_tdata (input_bfd)->got;
10474 if (got == NULL)
10475 abort ();
10476
411e1bfb
AM		 10477 /* The offset must always be a multiple of 8. We use the
10478 least significant bit to record whether we have already
10479 processed this entry. */
d881513a 10480 off = *offp;
411e1bfb
AM		 10481 if ((off & 1) != 0)
10482 off &= ~1;
5bd4f169
AM		 10483 else
10484 {
411e1bfb
AM		 10485 /* Generate relocs for the dynamic linker, except in
10486 the case of TLSLD where we'll use one entry per
10487 module. */
e717da7e
AM		 10488 asection *relgot = ppc64_elf_tdata (input_bfd)->relgot;
10489
d881513a 10490 *offp = off | 1;
4e795f50
AM		 10491 if ((info->shared || indx != 0)
10492 && (h == NULL
039b3fef
AM		 10493 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
10494 || h->elf.root.type != bfd_link_hash_undefweak))
5bd4f169 10495 {
e717da7e
AM		 10496 outrel.r_offset = (got->output_section->vma
10497 + got->output_offset
411e1bfb 10498 + off);
4cc603a5 10499 outrel.r_addend = addend;
d881513a 10500 if (tls_type & (TLS_LD | TLS_GD))
5bd4f169 10501 {
411e1bfb 10502 outrel.r_addend = 0;
e515b051 10503 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
d881513a
AM		 10504 if (tls_type == (TLS_TLS | TLS_GD))
10505 {
e717da7e
AM		 10506 loc = relgot->contents;
10507 loc += (relgot->reloc_count++
d881513a
AM		 10508 * sizeof (Elf64_External_Rela));
10509 bfd_elf64_swap_reloca_out (output_bfd,
10510 &outrel, loc);
e515b051 10511 outrel.r_offset += 8;
4cc603a5 10512 outrel.r_addend = addend;
d881513a
AM		 10513 outrel.r_info
10514 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
d881513a 10515 }
411e1bfb 10516 }
951fd09b 10517 else if (tls_type == (TLS_TLS | TLS_DTPREL))
411e1bfb 10518 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
951fd09b 10519 else if (tls_type == (TLS_TLS | TLS_TPREL))
411e1bfb
AM		 10520 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
10521 else if (indx == 0)
81407a69
AM		 10522 {
10523 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_RELATIVE);
10524
10525 /* Write the .got section contents for the sake
10526 of prelink. */
e717da7e 10527 loc = got->contents + off;
23fbd6fa
JJ		 10528 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
10529 loc);
81407a69 10530 }
411e1bfb
AM		 10531 else
10532 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
81407a69
AM		 10533
10534 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
e515b051
AM		 10535 {
10536 outrel.r_addend += relocation;
10537 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
e1918d23 10538 outrel.r_addend -= htab->elf.tls_sec->vma;
e515b051 10539 }
e717da7e
AM		 10540 loc = relgot->contents;
10541 loc += (relgot->reloc_count++
411e1bfb
AM		 10542 * sizeof (Elf64_External_Rela));
10543 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
10544 }
10545
ad8e1ba5 10546 /* Init the .got section contents here if we're not
81407a69 10547 emitting a reloc. */
d881513a 10548 else
411e1bfb 10549 {
4cc603a5 10550 relocation += addend;
7b609f53
AM		 10551 if (tls_type == (TLS_TLS | TLS_LD))
10552 relocation = 1;
10553 else if (tls_type != 0)
411e1bfb 10554 {
e1918d23 10555 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
7b609f53 10556 if (tls_type == (TLS_TLS | TLS_TPREL))
411e1bfb 10557 relocation += DTP_OFFSET - TP_OFFSET;
5bd4f169 10558
7b609f53
AM		 10559 if (tls_type == (TLS_TLS | TLS_GD))
10560 {
10561 bfd_put_64 (output_bfd, relocation,
e717da7e 10562 got->contents + off + 8);
7b609f53
AM		 10563 relocation = 1;
10564 }
411e1bfb 10565 }
7b609f53 10566
411e1bfb 10567 bfd_put_64 (output_bfd, relocation,
e717da7e 10568 got->contents + off);
5bd4f169
AM		 10569 }
10570 }
10571
65f38f15
AM		 10572 if (off >= (bfd_vma) -2)
10573 abort ();
10574
e717da7e 10575 relocation = got->output_offset + off;
65f38f15 10576
5bd4f169 10577 /* TOC base (r2) is TOC start plus 0x8000. */
e717da7e 10578 addend = -TOC_BASE_OFF;
5bd4f169 10579 }
65f38f15
AM		 10580 break;
10581
10582 case R_PPC64_PLT16_HA:
10583 case R_PPC64_PLT16_HI:
10584 case R_PPC64_PLT16_LO:
10585 case R_PPC64_PLT32:
10586 case R_PPC64_PLT64:
10587 /* Relocation is to the entry for this symbol in the
10588 procedure linkage table. */
10589
10590 /* Resolve a PLT reloc against a local symbol directly,
10591 without using the procedure linkage table. */
10592 if (h == NULL)
10593 break;
10594
411e1bfb
AM		 10595 /* It's possible that we didn't make a PLT entry for this
10596 symbol. This happens when statically linking PIC code,
10597 or when using -Bsymbolic. Go find a match if there is a
10598 PLT entry. */
4ce794b7 10599 if (htab->plt != NULL)
65f38f15 10600 {
411e1bfb 10601 struct plt_entry *ent;
039b3fef 10602 for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
4cc603a5 10603 if (ent->addend == orig_addend
411e1bfb
AM		 10604 && ent->plt.offset != (bfd_vma) -1)
10605 {
4ce794b7
AM		 10606 relocation = (htab->plt->output_section->vma
10607 + htab->plt->output_offset
411e1bfb
AM		 10608 + ent->plt.offset);
10609 unresolved_reloc = FALSE;
10610 }
65f38f15 10611 }
65f38f15 10612 break;
5bd4f169 10613
0b13192e
AM		 10614 case R_PPC64_TOC:
10615 /* Relocation value is TOC base. */
10616 relocation = TOCstart;
10617 if (r_symndx == 0)
10618 relocation += htab->stub_group[input_section->id].toc_off;
8517fae7
AM		 10619 else if (unresolved_reloc)
10620 ;
10621 else if (sec != NULL && sec->id <= htab->top_id)
0b13192e
AM		 10622 relocation += htab->stub_group[sec->id].toc_off;
10623 else
10624 unresolved_reloc = TRUE;
10625 goto dodyn2;
10626
5bd4f169
AM		 10627 /* TOC16 relocs. We want the offset relative to the TOC base,
10628 which is the address of the start of the TOC plus 0x8000.
10629 The TOC consists of sections .got, .toc, .tocbss, and .plt,
10630 in this order. */
65f38f15
AM		 10631 case R_PPC64_TOC16:
10632 case R_PPC64_TOC16_LO:
10633 case R_PPC64_TOC16_HI:
10634 case R_PPC64_TOC16_DS:
10635 case R_PPC64_TOC16_LO_DS:
10636 case R_PPC64_TOC16_HA:
ad8e1ba5 10637 addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
5bd4f169
AM		 10638 break;
10639
10640 /* Relocate against the beginning of the section. */
65f38f15
AM		 10641 case R_PPC64_SECTOFF:
10642 case R_PPC64_SECTOFF_LO:
10643 case R_PPC64_SECTOFF_HI:
10644 case R_PPC64_SECTOFF_DS:
10645 case R_PPC64_SECTOFF_LO_DS:
10646 case R_PPC64_SECTOFF_HA:
4ce794b7 10647 if (sec != NULL)
65f38f15 10648 addend -= sec->output_section->vma;
5bd4f169
AM		 10649 break;
10650
721956f4
AM		 10651 case R_PPC64_REL14:
10652 case R_PPC64_REL14_BRNTAKEN:
10653 case R_PPC64_REL14_BRTAKEN:
5d1634d7
AM		 10654 case R_PPC64_REL24:
10655 break;
10656
411e1bfb
AM		 10657 case R_PPC64_TPREL16:
10658 case R_PPC64_TPREL16_LO:
10659 case R_PPC64_TPREL16_HI:
10660 case R_PPC64_TPREL16_HA:
10661 case R_PPC64_TPREL16_DS:
10662 case R_PPC64_TPREL16_LO_DS:
10663 case R_PPC64_TPREL16_HIGHER:
10664 case R_PPC64_TPREL16_HIGHERA:
10665 case R_PPC64_TPREL16_HIGHEST:
10666 case R_PPC64_TPREL16_HIGHESTA:
e1918d23 10667 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
411e1bfb
AM		 10668 if (info->shared)
10669 /* The TPREL16 relocs shouldn't really be used in shared
10670 libs as they will result in DT_TEXTREL being set, but
10671 support them anyway. */
10672 goto dodyn;
10673 break;
10674
10675 case R_PPC64_DTPREL16:
10676 case R_PPC64_DTPREL16_LO:
10677 case R_PPC64_DTPREL16_HI:
10678 case R_PPC64_DTPREL16_HA:
10679 case R_PPC64_DTPREL16_DS:
10680 case R_PPC64_DTPREL16_LO_DS:
10681 case R_PPC64_DTPREL16_HIGHER:
10682 case R_PPC64_DTPREL16_HIGHERA:
10683 case R_PPC64_DTPREL16_HIGHEST:
10684 case R_PPC64_DTPREL16_HIGHESTA:
e1918d23 10685 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
411e1bfb
AM		 10686 break;
10687
e515b051
AM		 10688 case R_PPC64_DTPMOD64:
10689 relocation = 1;
10690 addend = 0;
10691 goto dodyn;
10692
411e1bfb 10693 case R_PPC64_TPREL64:
e1918d23 10694 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
411e1bfb
AM		 10695 goto dodyn;
10696
10697 case R_PPC64_DTPREL64:
e1918d23 10698 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
411e1bfb
AM		 10699 /* Fall thru */
10700
65f38f15
AM		 10701 /* Relocations that may need to be propagated if this is a
10702 dynamic object. */
04c9666a 10703 case R_PPC64_REL30:
65f38f15
AM		 10704 case R_PPC64_REL32:
10705 case R_PPC64_REL64:
10706 case R_PPC64_ADDR14:
10707 case R_PPC64_ADDR14_BRNTAKEN:
10708 case R_PPC64_ADDR14_BRTAKEN:
10709 case R_PPC64_ADDR16:
10710 case R_PPC64_ADDR16_DS:
10711 case R_PPC64_ADDR16_HA:
10712 case R_PPC64_ADDR16_HI:
10713 case R_PPC64_ADDR16_HIGHER:
10714 case R_PPC64_ADDR16_HIGHERA:
10715 case R_PPC64_ADDR16_HIGHEST:
10716 case R_PPC64_ADDR16_HIGHESTA:
10717 case R_PPC64_ADDR16_LO:
10718 case R_PPC64_ADDR16_LO_DS:
10719 case R_PPC64_ADDR24:
65f38f15
AM		 10720 case R_PPC64_ADDR32:
10721 case R_PPC64_ADDR64:
10722 case R_PPC64_UADDR16:
10723 case R_PPC64_UADDR32:
10724 case R_PPC64_UADDR64:
ec338859
AM		 10725 /* r_symndx will be zero only for relocs against symbols
10726 from removed linkonce sections, or sections discarded by
10727 a linker script. */
411e1bfb 10728 dodyn:
5d1634d7
AM		 10729 if (r_symndx == 0)
10730 break;
10731 /* Fall thru. */
10732
0b13192e 10733 dodyn2:
5d1634d7 10734 if ((input_section->flags & SEC_ALLOC) == 0)
ec338859
AM		 10735 break;
10736
41bd81ab
AM		 10737 if (NO_OPD_RELOCS && is_opd)
10738 break;
10739
65f38f15 10740 if ((info->shared
4e795f50 10741 && (h == NULL
039b3fef
AM		 10742 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
10743 || h->elf.root.type != bfd_link_hash_undefweak)
411e1bfb 10744 && (MUST_BE_DYN_RELOC (r_type)
039b3fef 10745 || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
f4656909
AM		 10746 || (ELIMINATE_COPY_RELOCS
10747 && !info->shared
65f38f15 10748 && h != NULL
039b3fef 10749 && h->elf.dynindx != -1
f5385ebf
AM		 10750 && !h->elf.non_got_ref
10751 && h->elf.def_dynamic
10752 && !h->elf.def_regular))
65f38f15
AM		 10753 {
10754 Elf_Internal_Rela outrel;
b34976b6 10755 bfd_boolean skip, relocate;
65f38f15 10756 asection *sreloc;
947216bf 10757 bfd_byte *loc;
1cf1f670 10758 bfd_vma out_off;
65f38f15
AM		 10759
10760 /* When generating a dynamic object, these relocations
10761 are copied into the output file to be resolved at run
10762 time. */
10763
b34976b6
AM		 10764 skip = FALSE;
10765 relocate = FALSE;
65f38f15 10766
1cf1f670
AM		 10767 out_off = _bfd_elf_section_offset (output_bfd, info,
10768 input_section, rel->r_offset);
10769 if (out_off == (bfd_vma) -1)
b34976b6 10770 skip = TRUE;
1cf1f670 10771 else if (out_off == (bfd_vma) -2)
b34976b6 10772 skip = TRUE, relocate = TRUE;
1cf1f670
AM		 10773 out_off += (input_section->output_section->vma
10774 + input_section->output_offset);
10775 outrel.r_offset = out_off;
411e1bfb 10776 outrel.r_addend = rel->r_addend;
65f38f15 10777
1cf1f670
AM		 10778 /* Optimize unaligned reloc use. */
10779 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
10780 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
10781 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
10782 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
10783 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
10784 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
10785 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
10786 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
10787 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
10788
65f38f15 10789 if (skip)
0bb2d96a 10790 memset (&outrel, 0, sizeof outrel);
039b3fef 10791 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
0b13192e
AM		 10792 && !is_opd
10793 && r_type != R_PPC64_TOC)
039b3fef 10794 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
65f38f15
AM		 10795 else
10796 {
41bd81ab
AM		 10797 /* This symbol is local, or marked to become local,
10798 or this is an opd section reloc which must point
10799 at a local function. */
65f38f15 10800 outrel.r_addend += relocation;
e86ce104 10801 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
65f38f15 10802 {
3fad3c7c 10803 if (is_opd && h != NULL)
afbe61cf
AM		 10804 {
10805 /* Lie about opd entries. This case occurs
10806 when building shared libraries and we
10807 reference a function in another shared
3fad3c7c
AM		 10808 lib. The same thing happens for a weak
10809 definition in an application that's
10810 overridden by a strong definition in a
10811 shared lib. (I believe this is a generic
10812 bug in binutils handling of weak syms.)
10813 In these cases we won't use the opd
1e2f5b6e 10814 entry in this lib. */
b34976b6 10815 unresolved_reloc = FALSE;
afbe61cf 10816 }
65f38f15 10817 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
81407a69
AM		 10818
10819 /* We need to relocate .opd contents for ld.so.
10820 Prelink also wants simple and consistent rules
10821 for relocs. This make all RELATIVE relocs have
10822 *r_offset equal to r_addend. */
10823 relocate = TRUE;
65f38f15
AM		 10824 }
10825 else
10826 {
10827 long indx = 0;
10828
41bd81ab 10829 if (bfd_is_abs_section (sec))
65f38f15
AM		 10830 ;
10831 else if (sec == NULL || sec->owner == NULL)
10832 {
10833 bfd_set_error (bfd_error_bad_value);
b34976b6 10834 return FALSE;
65f38f15
AM		 10835 }
10836 else
10837 {
10838 asection *osec;
10839
10840 osec = sec->output_section;
10841 indx = elf_section_data (osec)->dynindx;
10842
10843 /* We are turning this relocation into one
10844 against a section symbol, so subtract out
10845 the output section's address but not the
10846 offset of the input section in the output
10847 section. */
10848 outrel.r_addend -= osec->vma;
10849 }
10850
10851 outrel.r_info = ELF64_R_INFO (indx, r_type);
10852 }
10853 }
10854
10855 sreloc = elf_section_data (input_section)->sreloc;
10856 if (sreloc == NULL)
10857 abort ();
10858
dfbb6ac9
AM		 10859 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
10860 >= sreloc->size)
10861 abort ();
947216bf
AM		 10862 loc = sreloc->contents;
10863 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
65f38f15
AM		 10864 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
10865
10866 /* If this reloc is against an external symbol, it will
10867 be computed at runtime, so there's no need to do
81407a69
AM		 10868 anything now. However, for the sake of prelink ensure
10869 that the section contents are a known value. */
65f38f15 10870 if (! relocate)
81407a69
AM		 10871 {
10872 unresolved_reloc = FALSE;
10873 /* The value chosen here is quite arbitrary as ld.so
10874 ignores section contents except for the special
10875 case of .opd where the contents might be accessed
10876 before relocation. Choose zero, as that won't
10877 cause reloc overflow. */
10878 relocation = 0;
10879 addend = 0;
10880 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
10881 to improve backward compatibility with older
10882 versions of ld. */
10883 if (r_type == R_PPC64_ADDR64)
10884 addend = outrel.r_addend;
10885 /* Adjust pc_relative relocs to have zero in *r_offset. */
4ce794b7 10886 else if (ppc64_elf_howto_table[r_type]->pc_relative)
000732f7
AM		 10887 addend = (input_section->output_section->vma
10888 + input_section->output_offset
10889 + rel->r_offset);
81407a69 10890 }
65f38f15 10891 }
5bd4f169
AM		 10892 break;
10893
65f38f15
AM		 10894 case R_PPC64_COPY:
10895 case R_PPC64_GLOB_DAT:
10896 case R_PPC64_JMP_SLOT:
10897 case R_PPC64_RELATIVE:
10898 /* We shouldn't ever see these dynamic relocs in relocatable
10899 files. */
ae9a127f 10900 /* Fall through. */
65f38f15
AM		 10901
10902 case R_PPC64_PLTGOT16:
10903 case R_PPC64_PLTGOT16_DS:
10904 case R_PPC64_PLTGOT16_HA:
10905 case R_PPC64_PLTGOT16_HI:
10906 case R_PPC64_PLTGOT16_LO:
10907 case R_PPC64_PLTGOT16_LO_DS:
10908 case R_PPC64_PLTREL32:
10909 case R_PPC64_PLTREL64:
10910 /* These ones haven't been implemented yet. */
10911
10912 (*_bfd_error_handler)
d003868e
AM		 10913 (_("%B: relocation %s is not supported for symbol %s."),
10914 input_bfd,
4ce794b7 10915 ppc64_elf_howto_table[r_type]->name, sym_name);
5bd4f169
AM		 10916
10917 bfd_set_error (bfd_error_invalid_operation);
b34976b6 10918 ret = FALSE;
5bd4f169 10919 continue;
65f38f15 10920 }
5bd4f169 10921
65f38f15
AM		 10922 /* Do any further special processing. */
10923 switch (r_type)
10924 {
10925 default:
10926 break;
10927
10928 case R_PPC64_ADDR16_HA:
10929 case R_PPC64_ADDR16_HIGHERA:
10930 case R_PPC64_ADDR16_HIGHESTA:
86bbe32f
AM		 10931 case R_PPC64_GOT16_HA:
10932 case R_PPC64_PLTGOT16_HA:
65f38f15
AM		 10933 case R_PPC64_PLT16_HA:
10934 case R_PPC64_TOC16_HA:
10935 case R_PPC64_SECTOFF_HA:
411e1bfb
AM		 10936 case R_PPC64_TPREL16_HA:
10937 case R_PPC64_DTPREL16_HA:
10938 case R_PPC64_GOT_TLSGD16_HA:
10939 case R_PPC64_GOT_TLSLD16_HA:
10940 case R_PPC64_GOT_TPREL16_HA:
10941 case R_PPC64_GOT_DTPREL16_HA:
10942 case R_PPC64_TPREL16_HIGHER:
10943 case R_PPC64_TPREL16_HIGHERA:
10944 case R_PPC64_TPREL16_HIGHEST:
10945 case R_PPC64_TPREL16_HIGHESTA:
10946 case R_PPC64_DTPREL16_HIGHER:
10947 case R_PPC64_DTPREL16_HIGHERA:
10948 case R_PPC64_DTPREL16_HIGHEST:
10949 case R_PPC64_DTPREL16_HIGHESTA:
65f38f15
AM		 10950 /* It's just possible that this symbol is a weak symbol
10951 that's not actually defined anywhere. In that case,
10952 'sec' would be NULL, and we should leave the symbol
10953 alone (it will be set to zero elsewhere in the link). */
10954 if (sec != NULL)
e515b051
AM		 10955 /* Add 0x10000 if sign bit in 0:15 is set.
10956 Bits 0:15 are not used. */
10957 addend += 0x8000;
65f38f15
AM		 10958 break;
10959
10960 case R_PPC64_ADDR16_DS:
10961 case R_PPC64_ADDR16_LO_DS:
10962 case R_PPC64_GOT16_DS:
10963 case R_PPC64_GOT16_LO_DS:
10964 case R_PPC64_PLT16_LO_DS:
10965 case R_PPC64_SECTOFF_DS:
10966 case R_PPC64_SECTOFF_LO_DS:
10967 case R_PPC64_TOC16_DS:
10968 case R_PPC64_TOC16_LO_DS:
10969 case R_PPC64_PLTGOT16_DS:
10970 case R_PPC64_PLTGOT16_LO_DS:
411e1bfb
AM		 10971 case R_PPC64_GOT_TPREL16_DS:
10972 case R_PPC64_GOT_TPREL16_LO_DS:
10973 case R_PPC64_GOT_DTPREL16_DS:
10974 case R_PPC64_GOT_DTPREL16_LO_DS:
10975 case R_PPC64_TPREL16_DS:
10976 case R_PPC64_TPREL16_LO_DS:
10977 case R_PPC64_DTPREL16_DS:
10978 case R_PPC64_DTPREL16_LO_DS:
adadcc0c
AM		 10979 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
10980 mask = 3;
10981 /* If this reloc is against an lq insn, then the value must be
10982 a multiple of 16. This is somewhat of a hack, but the
10983 "correct" way to do this by defining _DQ forms of all the
10984 _DS relocs bloats all reloc switches in this file. It
10985 doesn't seem to make much sense to use any of these relocs
10986 in data, so testing the insn should be safe. */
494dac0c 10987 if ((insn & (0x3f << 26)) == (56u << 26))
adadcc0c
AM		 10988 mask = 15;
10989 if (((relocation + addend) & mask) != 0)
65f38f15
AM		 10990 {
10991 (*_bfd_error_handler)
d003868e
AM		 10992 (_("%B: error: relocation %s not a multiple of %d"),
10993 input_bfd,
4ce794b7 10994 ppc64_elf_howto_table[r_type]->name,
adadcc0c 10995 mask + 1);
65f38f15 10996 bfd_set_error (bfd_error_bad_value);
b34976b6 10997 ret = FALSE;
65f38f15
AM		 10998 continue;
10999 }
11000 break;
5bd4f169
AM		 11001 }
11002
239e1f3a
AM		 11003 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
11004 because such sections are not SEC_ALLOC and thus ld.so will
11005 not process them. */
65f38f15 11006 if (unresolved_reloc
239e1f3a 11007 && !((input_section->flags & SEC_DEBUGGING) != 0
f5385ebf 11008 && h->elf.def_dynamic))
9c07fe7c
AM		 11009 {
11010 (*_bfd_error_handler)
d003868e
AM		 11011 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
11012 input_bfd,
11013 input_section,
9c07fe7c 11014 (long) rel->r_offset,
7b609f53 11015 ppc64_elf_howto_table[(int) r_type]->name,
039b3fef 11016 h->elf.root.root.string);
b34976b6 11017 ret = FALSE;
9c07fe7c 11018 }
5bd4f169 11019
65f38f15 11020 r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
5bd4f169
AM		 11021 input_bfd,
11022 input_section,
11023 contents,
411e1bfb 11024 rel->r_offset,
5bd4f169
AM		 11025 relocation,
11026 addend);
11027
ef60b7ff 11028 if (r != bfd_reloc_ok)
5bd4f169 11029 {
cd27b276
AM		 11030 if (sym_name == NULL)
11031 sym_name = "(null)";
11032 if (r == bfd_reloc_overflow)
5bd4f169 11033 {
cd27b276
AM		 11034 if (warned)
11035 continue;
11036 if (h != NULL
039b3fef 11037 && h->elf.root.type == bfd_link_hash_undefweak
4ce794b7 11038 && ppc64_elf_howto_table[r_type]->pc_relative)
5bd4f169
AM		 11039 {
11040 /* Assume this is a call protected by other code that
11041 detects the symbol is undefined. If this is the case,
11042 we can safely ignore the overflow. If not, the
11043 program is hosed anyway, and a little warning isn't
11044 going to help. */
11045
11046 continue;
11047 }
11048
ef60b7ff 11049 if (!((*info->callbacks->reloc_overflow)
dfeffb9f
L		 11050 (info, (h ? &h->elf.root : NULL), sym_name,
11051 ppc64_elf_howto_table[r_type]->name,
4cc603a5 11052 orig_addend, input_bfd, input_section, rel->r_offset)))
b34976b6 11053 return FALSE;
ef60b7ff
AM		 11054 }
11055 else
11056 {
11057 (*_bfd_error_handler)
d003868e
AM		 11058 (_("%B(%A+0x%lx): %s reloc against `%s': error %d"),
11059 input_bfd,
11060 input_section,
7b609f53 11061 (long) rel->r_offset,
4ce794b7 11062 ppc64_elf_howto_table[r_type]->name,
7b609f53
AM		 11063 sym_name,
11064 (int) r);
b34976b6 11065 ret = FALSE;
ef60b7ff 11066 }
5bd4f169 11067 }
5bd4f169
AM		 11068 }
11069
645ea6a9
AM		 11070 /* If we're emitting relocations, then shortly after this function
11071 returns, reloc offsets and addends for this section will be
11072 adjusted. Worse, reloc symbol indices will be for the output
8860955f
AM		 11073 file rather than the input. Save a copy of the relocs for
11074 opd_entry_value. */
4cc603a5 11075 if (is_opd && (info->emitrelocations || info->relocatable))
8860955f
AM		 11076 {
11077 bfd_size_type amt;
11078 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
11079 rel = bfd_alloc (input_bfd, amt);
11080 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd_relocs == NULL);
11081 ppc64_elf_tdata (input_bfd)->opd_relocs = rel;
11082 if (rel == NULL)
11083 return FALSE;
11084 memcpy (rel, relocs, amt);
11085 }
5bd4f169
AM		 11086 return ret;
11087}
11088
754021d0
AM		 11089/* Adjust the value of any local symbols in opd sections. */
11090
11091static bfd_boolean
11092ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
11093 const char *name ATTRIBUTE_UNUSED,
11094 Elf_Internal_Sym *elfsym,
11095 asection *input_sec,
11096 struct elf_link_hash_entry *h)
11097{
4025353c 11098 long *opd_adjust, adjust;
754021d0
AM		 11099 bfd_vma value;
11100
4025353c
AM		 11101 if (h != NULL)
11102 return TRUE;
11103
11104 opd_adjust = get_opd_info (input_sec);
11105 if (opd_adjust == NULL)
754021d0
AM		 11106 return TRUE;
11107
11108 value = elfsym->st_value - input_sec->output_offset;
11109 if (!info->relocatable)
11110 value -= input_sec->output_section->vma;
11111
3f764659 11112 adjust = opd_adjust[value / 8];
4025353c
AM		 11113 if (adjust == -1)
11114 elfsym->st_value = 0;
11115 else
11116 elfsym->st_value += adjust;
754021d0
AM		 11117 return TRUE;
11118}
11119
5bd4f169
AM		 11120/* Finish up dynamic symbol handling. We set the contents of various
11121 dynamic sections here. */
11122
b34976b6 11123static bfd_boolean
4ce794b7
AM		 11124ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
11125 struct bfd_link_info *info,
11126 struct elf_link_hash_entry *h,
11127 Elf_Internal_Sym *sym)
5bd4f169 11128{
65f38f15 11129 struct ppc_link_hash_table *htab;
8387904d
AM		 11130 struct plt_entry *ent;
11131 Elf_Internal_Rela rela;
11132 bfd_byte *loc;
5bd4f169 11133
65f38f15 11134 htab = ppc_hash_table (info);
5bd4f169 11135
8387904d
AM		 11136 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
11137 if (ent->plt.offset != (bfd_vma) -1)
11138 {
11139 /* This symbol has an entry in the procedure linkage
11140 table. Set it up. */
11141
11142 if (htab->plt == NULL
11143 || htab->relplt == NULL
11144 || htab->glink == NULL)
11145 abort ();
11146
11147 /* Create a JMP_SLOT reloc to inform the dynamic linker to
11148 fill in the PLT entry. */
11149 rela.r_offset = (htab->plt->output_section->vma
11150 + htab->plt->output_offset
11151 + ent->plt.offset);
11152 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
11153 rela.r_addend = ent->addend;
11154
11155 loc = htab->relplt->contents;
11156 loc += ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE
11157 * sizeof (Elf64_External_Rela));
11158 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
11159 }
5bd4f169 11160
f5385ebf 11161 if (h->needs_copy)
5bd4f169 11162 {
5bd4f169 11163 Elf_Internal_Rela rela;
947216bf 11164 bfd_byte *loc;
5bd4f169 11165
65f38f15 11166 /* This symbol needs a copy reloc. Set it up. */
5bd4f169 11167
65f38f15
AM		 11168 if (h->dynindx == -1
11169 || (h->root.type != bfd_link_hash_defined
11170 && h->root.type != bfd_link_hash_defweak)
4ce794b7 11171 || htab->relbss == NULL)
65f38f15 11172 abort ();
5bd4f169
AM		 11173
11174 rela.r_offset = (h->root.u.def.value
11175 + h->root.u.def.section->output_section->vma
11176 + h->root.u.def.section->output_offset);
11177 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
11178 rela.r_addend = 0;
4ce794b7
AM		 11179 loc = htab->relbss->contents;
11180 loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
65f38f15 11181 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
5bd4f169
AM		 11182 }
11183
5bd4f169
AM		 11184 /* Mark some specially defined symbols as absolute. */
11185 if (strcmp (h->root.root.string, "_DYNAMIC") == 0)
11186 sym->st_shndx = SHN_ABS;
11187
b34976b6 11188 return TRUE;
5bd4f169
AM		 11189}
11190
65f38f15
AM		 11191/* Used to decide how to sort relocs in an optimal manner for the
11192 dynamic linker, before writing them out. */
11193
11194static enum elf_reloc_type_class
4ce794b7 11195ppc64_elf_reloc_type_class (const Elf_Internal_Rela *rela)
65f38f15 11196{
04c9666a 11197 enum elf_ppc64_reloc_type r_type;
a33d1f77 11198
4ce794b7 11199 r_type = ELF64_R_TYPE (rela->r_info);
a33d1f77 11200 switch (r_type)
65f38f15
AM		 11201 {
11202 case R_PPC64_RELATIVE:
11203 return reloc_class_relative;
11204 case R_PPC64_JMP_SLOT:
11205 return reloc_class_plt;
11206 case R_PPC64_COPY:
11207 return reloc_class_copy;
11208 default:
11209 return reloc_class_normal;
11210 }
11211}
11212
5bd4f169
AM		 11213/* Finish up the dynamic sections. */
11214
b34976b6 11215static bfd_boolean
4ce794b7
AM		 11216ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
11217 struct bfd_link_info *info)
5bd4f169 11218{
65f38f15
AM		 11219 struct ppc_link_hash_table *htab;
11220 bfd *dynobj;
5bd4f169 11221 asection *sdyn;
5bd4f169 11222
65f38f15
AM		 11223 htab = ppc_hash_table (info);
11224 dynobj = htab->elf.dynobj;
5bd4f169
AM		 11225 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
11226
65f38f15 11227 if (htab->elf.dynamic_sections_created)
5bd4f169 11228 {
5bd4f169
AM		 11229 Elf64_External_Dyn *dyncon, *dynconend;
11230
4ce794b7 11231 if (sdyn == NULL || htab->got == NULL)
65f38f15 11232 abort ();
5bd4f169
AM		 11233
11234 dyncon = (Elf64_External_Dyn *) sdyn->contents;
eea6121a 11235 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
5bd4f169
AM		 11236 for (; dyncon < dynconend; dyncon++)
11237 {
11238 Elf_Internal_Dyn dyn;
19397422 11239 asection *s;
5bd4f169
AM		 11240
11241 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
11242
11243 switch (dyn.d_tag)
11244 {
65f38f15
AM		 11245 default:
11246 continue;
5bd4f169 11247
5d1634d7 11248 case DT_PPC64_GLINK:
4ce794b7 11249 s = htab->glink;
6348e046 11250 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
ad8e1ba5
AM		 11251 /* We stupidly defined DT_PPC64_GLINK to be the start
11252 of glink rather than the first entry point, which is
11253 what ld.so needs, and now have a bigger stub to
11254 support automatic multiple TOCs. */
11255 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 32;
5d1634d7
AM		 11256 break;
11257
19397422
AM		 11258 case DT_PPC64_OPD:
11259 s = bfd_get_section_by_name (output_bfd, ".opd");
6348e046
AM		 11260 if (s == NULL)
11261 continue;
11262 dyn.d_un.d_ptr = s->vma;
19397422
AM		 11263 break;
11264
11265 case DT_PPC64_OPDSZ:
11266 s = bfd_get_section_by_name (output_bfd, ".opd");
6348e046
AM		 11267 if (s == NULL)
11268 continue;
eea6121a 11269 dyn.d_un.d_val = s->size;
19397422
AM		 11270 break;
11271
65f38f15 11272 case DT_PLTGOT:
4ce794b7 11273 s = htab->plt;
6348e046 11274 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
65f38f15
AM		 11275 break;
11276
11277 case DT_JMPREL:
4ce794b7 11278 s = htab->relplt;
6348e046 11279 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
65f38f15 11280 break;
5bd4f169 11281
65f38f15 11282 case DT_PLTRELSZ:
eea6121a 11283 dyn.d_un.d_val = htab->relplt->size;
5d1634d7
AM		 11284 break;
11285
11286 case DT_RELASZ:
11287 /* Don't count procedure linkage table relocs in the
11288 overall reloc count. */
4ce794b7 11289 s = htab->relplt;
6348e046
AM		 11290 if (s == NULL)
11291 continue;
eea6121a 11292 dyn.d_un.d_val -= s->size;
6348e046
AM		 11293 break;
11294
11295 case DT_RELA:
11296 /* We may not be using the standard ELF linker script.
11297 If .rela.plt is the first .rela section, we adjust
11298 DT_RELA to not include it. */
4ce794b7 11299 s = htab->relplt;
6348e046
AM		 11300 if (s == NULL)
11301 continue;
11302 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
11303 continue;
eea6121a 11304 dyn.d_un.d_ptr += s->size;
65f38f15 11305 break;
5bd4f169 11306 }
5bd4f169 11307
65f38f15 11308 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
5bd4f169 11309 }
5bd4f169
AM		 11310 }
11311
eea6121a 11312 if (htab->got != NULL && htab->got->size != 0)
5d1634d7
AM		 11313 {
11314 /* Fill in the first entry in the global offset table.
11315 We use it to hold the link-time TOCbase. */
11316 bfd_put_64 (output_bfd,
60ee0d4a 11317 elf_gp (output_bfd) + TOC_BASE_OFF,
4ce794b7 11318 htab->got->contents);
5d1634d7
AM		 11319
11320 /* Set .got entry size. */
4ce794b7 11321 elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 8;
5d1634d7
AM		 11322 }
11323
eea6121a 11324 if (htab->plt != NULL && htab->plt->size != 0)
5d1634d7
AM		 11325 {
11326 /* Set .plt entry size. */
4ce794b7 11327 elf_section_data (htab->plt->output_section)->this_hdr.sh_entsize
5d1634d7
AM		 11328 = PLT_ENTRY_SIZE;
11329 }
11330
e717da7e 11331 /* We need to handle writing out multiple GOT sections ourselves,
7b53ace3
AM		 11332 since we didn't add them to DYNOBJ. We know dynobj is the first
11333 bfd. */
e717da7e
AM		 11334 while ((dynobj = dynobj->link_next) != NULL)
11335 {
11336 asection *s;
7b53ace3 11337
ee75fd95 11338 if (!is_ppc64_elf_target (dynobj->xvec))
7b53ace3
AM		 11339 continue;
11340
e717da7e
AM		 11341 s = ppc64_elf_tdata (dynobj)->got;
11342 if (s != NULL
eea6121a 11343 && s->size != 0
e717da7e
AM		 11344 && s->output_section != bfd_abs_section_ptr
11345 && !bfd_set_section_contents (output_bfd, s->output_section,
11346 s->contents, s->output_offset,
eea6121a 11347 s->size))
e717da7e
AM		 11348 return FALSE;
11349 s = ppc64_elf_tdata (dynobj)->relgot;
11350 if (s != NULL
eea6121a 11351 && s->size != 0
e717da7e
AM		 11352 && s->output_section != bfd_abs_section_ptr
11353 && !bfd_set_section_contents (output_bfd, s->output_section,
11354 s->contents, s->output_offset,
eea6121a 11355 s->size))
e717da7e
AM		 11356 return FALSE;
11357 }
f6c52c13 11358
b34976b6 11359 return TRUE;
5bd4f169
AM		 11360}
11361
5bd4f169 11362#include "elf64-target.h"
GDB Binutils - Deliverables
This page took 1.130645 seconds and 4 git commands to generate.