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