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