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