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