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