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