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