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