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