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