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