projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* ppc64.h: Add R_PPC64_JMP_IREL, R_PPC64_REL16, R_PPC64_REL16_LO,
[deliverable/binutils-gdb.git] / bfd / elf64-ppc.c
CommitLineData
5bd4f169 1/* PowerPC64-specific support for 64-bit ELF.
3a71aa26
AM		 2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
3 2009 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
cd123cb7 12 the Free Software Foundation; either version 3 of the License, or
ae9a127f 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
cd123cb7 24
4ce794b7
AM		 25/* The 64-bit PowerPC ELF ABI may be found at
26 http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
27 http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html */
5bd4f169 28
3db64b00 29#include "sysdep.h"
183e98be 30#include <stdarg.h>
5bd4f169 31#include "bfd.h"
5bd4f169
AM		 32#include "bfdlink.h"
33#include "libbfd.h"
34#include "elf-bfd.h"
04c9666a 35#include "elf/ppc64.h"
5d1634d7 36#include "elf64-ppc.h"
5bd4f169 37
805fc799 38static bfd_reloc_status_type ppc64_elf_ha_reloc
4ce794b7 39 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
2441e016
AM		 40static bfd_reloc_status_type ppc64_elf_branch_reloc
41 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
805fc799 42static bfd_reloc_status_type ppc64_elf_brtaken_reloc
4ce794b7 43 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
805fc799 44static bfd_reloc_status_type ppc64_elf_sectoff_reloc
4ce794b7 45 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
805fc799 46static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
4ce794b7 47 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
805fc799 48static bfd_reloc_status_type ppc64_elf_toc_reloc
4ce794b7 49 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
805fc799 50static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
4ce794b7 51 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
805fc799 52static bfd_reloc_status_type ppc64_elf_toc64_reloc
4ce794b7 53 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
805fc799 54static bfd_reloc_status_type ppc64_elf_unhandled_reloc
4ce794b7 55 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
2441e016
AM		 56static bfd_vma opd_entry_value
57 (asection *, bfd_vma, asection **, bfd_vma *);
5bd4f169 58
ad8e1ba5
AM		 59#define TARGET_LITTLE_SYM bfd_elf64_powerpcle_vec
60#define TARGET_LITTLE_NAME "elf64-powerpcle"
61#define TARGET_BIG_SYM bfd_elf64_powerpc_vec
62#define TARGET_BIG_NAME "elf64-powerpc"
63#define ELF_ARCH bfd_arch_powerpc
64#define ELF_MACHINE_CODE EM_PPC64
65#define ELF_MAXPAGESIZE 0x10000
24718e3b 66#define ELF_COMMONPAGESIZE 0x1000
ad8e1ba5
AM		 67#define elf_info_to_howto ppc64_elf_info_to_howto
68
69#define elf_backend_want_got_sym 0
70#define elf_backend_want_plt_sym 0
71#define elf_backend_plt_alignment 3
72#define elf_backend_plt_not_loaded 1
ad8e1ba5 73#define elf_backend_got_header_size 8
ad8e1ba5
AM		 74#define elf_backend_can_gc_sections 1
75#define elf_backend_can_refcount 1
76#define elf_backend_rela_normal 1
6bfdb61b 77#define elf_backend_default_execstack 0
ad8e1ba5 78
e717da7e 79#define bfd_elf64_mkobject ppc64_elf_mkobject
ad8e1ba5 80#define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
157090f7 81#define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
ad8e1ba5
AM		 82#define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
83#define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
84#define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
85#define bfd_elf64_bfd_link_hash_table_free ppc64_elf_link_hash_table_free
90e3cdf2 86#define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
ad8e1ba5
AM		 87
88#define elf_backend_object_p ppc64_elf_object_p
d37c89e5
AM		 89#define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
90#define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
183e98be 91#define elf_backend_write_core_note ppc64_elf_write_core_note
ad8e1ba5
AM		 92#define elf_backend_create_dynamic_sections ppc64_elf_create_dynamic_sections
93#define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
555cd476 94#define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
7d9616d7 95#define elf_backend_check_directives ppc64_elf_process_dot_syms
97fed1c9 96#define elf_backend_as_needed_cleanup ppc64_elf_as_needed_cleanup
8387904d 97#define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
ad8e1ba5 98#define elf_backend_check_relocs ppc64_elf_check_relocs
74f0fb50 99#define elf_backend_gc_keep ppc64_elf_gc_keep
64d03ab5 100#define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
ad8e1ba5
AM		 101#define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
102#define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
103#define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
104#define elf_backend_hide_symbol ppc64_elf_hide_symbol
105#define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
106#define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
74541ad4 107#define elf_backend_init_index_section _bfd_elf_init_2_index_sections
60124e18 108#define elf_backend_action_discarded ppc64_elf_action_discarded
ad8e1ba5
AM		 109#define elf_backend_relocate_section ppc64_elf_relocate_section
110#define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
111#define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
112#define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
754021d0 113#define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
29ef7005 114#define elf_backend_special_sections ppc64_elf_special_sections
e054468f 115#define elf_backend_post_process_headers _bfd_elf_set_osabi
ad8e1ba5 116
5bd4f169
AM		 117/* The name of the dynamic interpreter. This is put in the .interp
118 section. */
119#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
120
121/* The size in bytes of an entry in the procedure linkage table. */
122#define PLT_ENTRY_SIZE 24
123
124/* The initial size of the plt reserved for the dynamic linker. */
5d1634d7 125#define PLT_INITIAL_ENTRY_SIZE PLT_ENTRY_SIZE
5bd4f169
AM		 126
127/* TOC base pointers offset from start of TOC. */
411e1bfb
AM		 128#define TOC_BASE_OFF 0x8000
129
130/* Offset of tp and dtp pointers from start of TLS block. */
131#define TP_OFFSET 0x7000
132#define DTP_OFFSET 0x8000
5bd4f169 133
ad8e1ba5
AM		 134/* .plt call stub instructions. The normal stub is like this, but
135 sometimes the .plt entry crosses a 64k boundary and we need to
ac2df442 136 insert an addi to adjust r12. */
ad8e1ba5 137#define PLT_CALL_STUB_SIZE (7*4)
5d1634d7
AM		 138#define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
139#define STD_R2_40R1 0xf8410028 /* std %r2,40(%r1) */
140#define LD_R11_0R12 0xe96c0000 /* ld %r11,xxx+0@l(%r12) */
5d1634d7 141#define MTCTR_R11 0x7d6903a6 /* mtctr %r11 */
ac2df442 142#define LD_R2_0R12 0xe84c0000 /* ld %r2,xxx+8@l(%r12) */
5d1634d7
AM		 143 /* ld %r11,xxx+16@l(%r12) */
144#define BCTR 0x4e800420 /* bctr */
145
5d1634d7 146
ee4bf8d2 147#define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,off@ha */
ac2df442 148#define ADDI_R12_R12 0x398c0000 /* addi %r12,%r12,off@l */
ad8e1ba5
AM		 149#define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
150#define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
151
ac2df442
AM		 152#define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
153#define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
154
ad8e1ba5
AM		 155#define LD_R2_40R1 0xe8410028 /* ld %r2,40(%r1) */
156
ee4bf8d2 157/* glink call stub instructions. We enter with the index in R0. */
ad8e1ba5 158#define GLINK_CALL_STUB_SIZE (16*4)
ee4bf8d2
AM		 159 /* 0: */
160 /* .quad plt0-1f */
161 /* __glink: */
162#define MFLR_R12 0x7d8802a6 /* mflr %12 */
163#define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
164 /* 1: */
165#define MFLR_R11 0x7d6802a6 /* mflr %11 */
166#define LD_R2_M16R11 0xe84bfff0 /* ld %2,(0b-1b)(%11) */
167#define MTLR_R12 0x7d8803a6 /* mtlr %12 */
168#define ADD_R12_R2_R11 0x7d825a14 /* add %12,%2,%11 */
169 /* ld %11,0(%12) */
170 /* ld %2,8(%12) */
171 /* mtctr %11 */
172 /* ld %11,16(%12) */
173 /* bctr */
5d1634d7
AM		 174
175/* Pad with this. */
176#define NOP 0x60000000
177
721956f4
AM		 178/* Some other nops. */
179#define CROR_151515 0x4def7b82
180#define CROR_313131 0x4ffffb82
181
cedb70c5 182/* .glink entries for the first 32k functions are two instructions. */
5d1634d7
AM		 183#define LI_R0_0 0x38000000 /* li %r0,0 */
184#define B_DOT 0x48000000 /* b . */
185
186/* After that, we need two instructions to load the index, followed by
187 a branch. */
188#define LIS_R0_0 0x3c000000 /* lis %r0,0 */
10ed1bba 189#define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
41bd81ab 190
deb0e272
AM		 191/* Instructions used by the save and restore reg functions. */
192#define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
193#define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
194#define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
195#define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
82bd7b59
AM		 196#define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
197#define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
deb0e272
AM		 198#define LI_R12_0 0x39800000 /* li %r12,0 */
199#define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
200#define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
201#define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
82bd7b59
AM		 202#define BLR 0x4e800020 /* blr */
203
41bd81ab
AM		 204/* Since .opd is an array of descriptors and each entry will end up
205 with identical R_PPC64_RELATIVE relocs, there is really no need to
206 propagate .opd relocs; The dynamic linker should be taught to
1e2f5b6e 207 relocate .opd without reloc entries. */
41bd81ab
AM		 208#ifndef NO_OPD_RELOCS
209#define NO_OPD_RELOCS 0
210#endif
5bd4f169 211\f
f5e87a1d 212#define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
b34976b6 213
5bd4f169 214/* Relocation HOWTO's. */
04c9666a 215static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
5bd4f169
AM		 216
217static reloc_howto_type ppc64_elf_howto_raw[] = {
218 /* This reloc does nothing. */
219 HOWTO (R_PPC64_NONE, /* type */
220 0, /* rightshift */
411e1bfb
AM		 221 2, /* size (0 = byte, 1 = short, 2 = long) */
222 32, /* bitsize */
b34976b6 223 FALSE, /* pc_relative */
5bd4f169 224 0, /* bitpos */
f5e87a1d 225 complain_overflow_dont, /* complain_on_overflow */
5bd4f169
AM		 226 bfd_elf_generic_reloc, /* special_function */
227 "R_PPC64_NONE", /* name */
b34976b6 228 FALSE, /* partial_inplace */
d006db6c 229 0, /* src_mask */
5bd4f169 230 0, /* dst_mask */
b34976b6 231 FALSE), /* pcrel_offset */
5bd4f169
AM		 232
233 /* A standard 32 bit relocation. */
234 HOWTO (R_PPC64_ADDR32, /* type */
235 0, /* rightshift */
236 2, /* size (0 = byte, 1 = short, 2 = long) */
237 32, /* bitsize */
b34976b6 238 FALSE, /* pc_relative */
5bd4f169
AM		 239 0, /* bitpos */
240 complain_overflow_bitfield, /* complain_on_overflow */
241 bfd_elf_generic_reloc, /* special_function */
242 "R_PPC64_ADDR32", /* name */
b34976b6 243 FALSE, /* partial_inplace */
5bd4f169
AM		 244 0, /* src_mask */
245 0xffffffff, /* dst_mask */
b34976b6 246 FALSE), /* pcrel_offset */
5bd4f169
AM		 247
248 /* An absolute 26 bit branch; the lower two bits must be zero.
249 FIXME: we don't check that, we just clear them. */
250 HOWTO (R_PPC64_ADDR24, /* type */
251 0, /* rightshift */
252 2, /* size (0 = byte, 1 = short, 2 = long) */
253 26, /* bitsize */
b34976b6 254 FALSE, /* pc_relative */
5bd4f169
AM		 255 0, /* bitpos */
256 complain_overflow_bitfield, /* complain_on_overflow */
257 bfd_elf_generic_reloc, /* special_function */
258 "R_PPC64_ADDR24", /* name */
b34976b6 259 FALSE, /* partial_inplace */
d006db6c 260 0, /* src_mask */
f5e87a1d 261 0x03fffffc, /* dst_mask */
b34976b6 262 FALSE), /* pcrel_offset */
5bd4f169
AM		 263
264 /* A standard 16 bit relocation. */
265 HOWTO (R_PPC64_ADDR16, /* type */
266 0, /* rightshift */
267 1, /* size (0 = byte, 1 = short, 2 = long) */
268 16, /* bitsize */
b34976b6 269 FALSE, /* pc_relative */
5bd4f169
AM		 270 0, /* bitpos */
271 complain_overflow_bitfield, /* complain_on_overflow */
272 bfd_elf_generic_reloc, /* special_function */
273 "R_PPC64_ADDR16", /* name */
b34976b6 274 FALSE, /* partial_inplace */
5bd4f169
AM		 275 0, /* src_mask */
276 0xffff, /* dst_mask */
b34976b6 277 FALSE), /* pcrel_offset */
5bd4f169
AM		 278
279 /* A 16 bit relocation without overflow. */
280 HOWTO (R_PPC64_ADDR16_LO, /* type */
281 0, /* rightshift */
282 1, /* size (0 = byte, 1 = short, 2 = long) */
283 16, /* bitsize */
b34976b6 284 FALSE, /* pc_relative */
5bd4f169
AM		 285 0, /* bitpos */
286 complain_overflow_dont,/* complain_on_overflow */
287 bfd_elf_generic_reloc, /* special_function */
288 "R_PPC64_ADDR16_LO", /* name */
b34976b6 289 FALSE, /* partial_inplace */
5bd4f169
AM		 290 0, /* src_mask */
291 0xffff, /* dst_mask */
b34976b6 292 FALSE), /* pcrel_offset */
5bd4f169
AM		 293
294 /* Bits 16-31 of an address. */
295 HOWTO (R_PPC64_ADDR16_HI, /* type */
296 16, /* rightshift */
297 1, /* size (0 = byte, 1 = short, 2 = long) */
298 16, /* bitsize */
b34976b6 299 FALSE, /* pc_relative */
5bd4f169
AM		 300 0, /* bitpos */
301 complain_overflow_dont, /* complain_on_overflow */
302 bfd_elf_generic_reloc, /* special_function */
303 "R_PPC64_ADDR16_HI", /* name */
b34976b6 304 FALSE, /* partial_inplace */
5bd4f169
AM		 305 0, /* src_mask */
306 0xffff, /* dst_mask */
b34976b6 307 FALSE), /* pcrel_offset */
5bd4f169
AM		 308
309 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
310 bits, treated as a signed number, is negative. */
311 HOWTO (R_PPC64_ADDR16_HA, /* type */
312 16, /* rightshift */
313 1, /* size (0 = byte, 1 = short, 2 = long) */
314 16, /* bitsize */
b34976b6 315 FALSE, /* pc_relative */
5bd4f169
AM		 316 0, /* bitpos */
317 complain_overflow_dont, /* complain_on_overflow */
805fc799 318 ppc64_elf_ha_reloc, /* special_function */
5bd4f169 319 "R_PPC64_ADDR16_HA", /* name */
b34976b6 320 FALSE, /* partial_inplace */
5bd4f169
AM		 321 0, /* src_mask */
322 0xffff, /* dst_mask */
b34976b6 323 FALSE), /* pcrel_offset */
5bd4f169
AM		 324
325 /* An absolute 16 bit branch; the lower two bits must be zero.
326 FIXME: we don't check that, we just clear them. */
327 HOWTO (R_PPC64_ADDR14, /* type */
328 0, /* rightshift */
329 2, /* size (0 = byte, 1 = short, 2 = long) */
330 16, /* bitsize */
b34976b6 331 FALSE, /* pc_relative */
5bd4f169
AM		 332 0, /* bitpos */
333 complain_overflow_bitfield, /* complain_on_overflow */
2441e016 334 ppc64_elf_branch_reloc, /* special_function */
5bd4f169 335 "R_PPC64_ADDR14", /* name */
b34976b6 336 FALSE, /* partial_inplace */
d006db6c 337 0, /* src_mask */
f5e87a1d 338 0x0000fffc, /* dst_mask */
b34976b6 339 FALSE), /* pcrel_offset */
5bd4f169
AM		 340
341 /* An absolute 16 bit branch, for which bit 10 should be set to
342 indicate that the branch is expected to be taken. The lower two
343 bits must be zero. */
344 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
345 0, /* rightshift */
346 2, /* size (0 = byte, 1 = short, 2 = long) */
347 16, /* bitsize */
b34976b6 348 FALSE, /* pc_relative */
5bd4f169
AM		 349 0, /* bitpos */
350 complain_overflow_bitfield, /* complain_on_overflow */
805fc799 351 ppc64_elf_brtaken_reloc, /* special_function */
5bd4f169 352 "R_PPC64_ADDR14_BRTAKEN",/* name */
b34976b6 353 FALSE, /* partial_inplace */
d006db6c 354 0, /* src_mask */
f5e87a1d 355 0x0000fffc, /* dst_mask */
b34976b6 356 FALSE), /* pcrel_offset */
5bd4f169
AM		 357
358 /* An absolute 16 bit branch, for which bit 10 should be set to
359 indicate that the branch is not expected to be taken. The lower
360 two bits must be zero. */
361 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
362 0, /* rightshift */
363 2, /* size (0 = byte, 1 = short, 2 = long) */
364 16, /* bitsize */
b34976b6 365 FALSE, /* pc_relative */
5bd4f169
AM		 366 0, /* bitpos */
367 complain_overflow_bitfield, /* complain_on_overflow */
805fc799 368 ppc64_elf_brtaken_reloc, /* special_function */
5bd4f169 369 "R_PPC64_ADDR14_BRNTAKEN",/* name */
b34976b6 370 FALSE, /* partial_inplace */
d006db6c 371 0, /* src_mask */
f5e87a1d 372 0x0000fffc, /* dst_mask */
b34976b6 373 FALSE), /* pcrel_offset */
5bd4f169
AM		 374
375 /* A relative 26 bit branch; the lower two bits must be zero. */
376 HOWTO (R_PPC64_REL24, /* type */
377 0, /* rightshift */
378 2, /* size (0 = byte, 1 = short, 2 = long) */
379 26, /* bitsize */
b34976b6 380 TRUE, /* pc_relative */
5bd4f169
AM		 381 0, /* bitpos */
382 complain_overflow_signed, /* complain_on_overflow */
2441e016 383 ppc64_elf_branch_reloc, /* special_function */
5bd4f169 384 "R_PPC64_REL24", /* name */
b34976b6 385 FALSE, /* partial_inplace */
d006db6c 386 0, /* src_mask */
f5e87a1d 387 0x03fffffc, /* dst_mask */
b34976b6 388 TRUE), /* pcrel_offset */
5bd4f169
AM		 389
390 /* A relative 16 bit branch; the lower two bits must be zero. */
391 HOWTO (R_PPC64_REL14, /* type */
392 0, /* rightshift */
393 2, /* size (0 = byte, 1 = short, 2 = long) */
394 16, /* bitsize */
b34976b6 395 TRUE, /* pc_relative */
5bd4f169
AM		 396 0, /* bitpos */
397 complain_overflow_signed, /* complain_on_overflow */
2441e016 398 ppc64_elf_branch_reloc, /* special_function */
5bd4f169 399 "R_PPC64_REL14", /* name */
b34976b6 400 FALSE, /* partial_inplace */
d006db6c 401 0, /* src_mask */
f5e87a1d 402 0x0000fffc, /* dst_mask */
b34976b6 403 TRUE), /* pcrel_offset */
5bd4f169
AM		 404
405 /* A relative 16 bit branch. Bit 10 should be set to indicate that
406 the branch is expected to be taken. The lower two bits must be
407 zero. */
408 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
409 0, /* rightshift */
410 2, /* size (0 = byte, 1 = short, 2 = long) */
411 16, /* bitsize */
b34976b6 412 TRUE, /* pc_relative */
5bd4f169
AM		 413 0, /* bitpos */
414 complain_overflow_signed, /* complain_on_overflow */
805fc799 415 ppc64_elf_brtaken_reloc, /* special_function */
5bd4f169 416 "R_PPC64_REL14_BRTAKEN", /* name */
b34976b6 417 FALSE, /* partial_inplace */
d006db6c 418 0, /* src_mask */
f5e87a1d 419 0x0000fffc, /* dst_mask */
b34976b6 420 TRUE), /* pcrel_offset */
5bd4f169
AM		 421
422 /* A relative 16 bit branch. Bit 10 should be set to indicate that
423 the branch is not expected to be taken. The lower two bits must
424 be zero. */
425 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
426 0, /* rightshift */
427 2, /* size (0 = byte, 1 = short, 2 = long) */
428 16, /* bitsize */
b34976b6 429 TRUE, /* pc_relative */
5bd4f169
AM		 430 0, /* bitpos */
431 complain_overflow_signed, /* complain_on_overflow */
805fc799 432 ppc64_elf_brtaken_reloc, /* special_function */
5bd4f169 433 "R_PPC64_REL14_BRNTAKEN",/* name */
b34976b6 434 FALSE, /* partial_inplace */
d006db6c 435 0, /* src_mask */
f5e87a1d 436 0x0000fffc, /* dst_mask */
b34976b6 437 TRUE), /* pcrel_offset */
5bd4f169
AM		 438
439 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
440 symbol. */
441 HOWTO (R_PPC64_GOT16, /* type */
442 0, /* rightshift */
443 1, /* size (0 = byte, 1 = short, 2 = long) */
444 16, /* bitsize */
b34976b6 445 FALSE, /* pc_relative */
5bd4f169
AM		 446 0, /* bitpos */
447 complain_overflow_signed, /* complain_on_overflow */
805fc799 448 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 449 "R_PPC64_GOT16", /* name */
b34976b6 450 FALSE, /* partial_inplace */
5bd4f169
AM		 451 0, /* src_mask */
452 0xffff, /* dst_mask */
b34976b6 453 FALSE), /* pcrel_offset */
5bd4f169
AM		 454
455 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
456 the symbol. */
457 HOWTO (R_PPC64_GOT16_LO, /* type */
458 0, /* rightshift */
459 1, /* size (0 = byte, 1 = short, 2 = long) */
460 16, /* bitsize */
b34976b6 461 FALSE, /* pc_relative */
5bd4f169
AM		 462 0, /* bitpos */
463 complain_overflow_dont, /* complain_on_overflow */
805fc799 464 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 465 "R_PPC64_GOT16_LO", /* name */
b34976b6 466 FALSE, /* partial_inplace */
5bd4f169
AM		 467 0, /* src_mask */
468 0xffff, /* dst_mask */
b34976b6 469 FALSE), /* pcrel_offset */
5bd4f169
AM		 470
471 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
472 the symbol. */
473 HOWTO (R_PPC64_GOT16_HI, /* type */
474 16, /* rightshift */
475 1, /* size (0 = byte, 1 = short, 2 = long) */
476 16, /* bitsize */
b34976b6 477 FALSE, /* pc_relative */
5bd4f169
AM		 478 0, /* bitpos */
479 complain_overflow_dont,/* complain_on_overflow */
805fc799 480 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 481 "R_PPC64_GOT16_HI", /* name */
b34976b6 482 FALSE, /* partial_inplace */
5bd4f169
AM		 483 0, /* src_mask */
484 0xffff, /* dst_mask */
b34976b6 485 FALSE), /* pcrel_offset */
5bd4f169
AM		 486
487 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
488 the symbol. */
489 HOWTO (R_PPC64_GOT16_HA, /* type */
490 16, /* rightshift */
491 1, /* size (0 = byte, 1 = short, 2 = long) */
492 16, /* bitsize */
b34976b6 493 FALSE, /* pc_relative */
5bd4f169
AM		 494 0, /* bitpos */
495 complain_overflow_dont,/* complain_on_overflow */
805fc799 496 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 497 "R_PPC64_GOT16_HA", /* name */
b34976b6 498 FALSE, /* partial_inplace */
5bd4f169
AM		 499 0, /* src_mask */
500 0xffff, /* dst_mask */
b34976b6 501 FALSE), /* pcrel_offset */
5bd4f169
AM		 502
503 /* This is used only by the dynamic linker. The symbol should exist
504 both in the object being run and in some shared library. The
505 dynamic linker copies the data addressed by the symbol from the
506 shared library into the object, because the object being
507 run has to have the data at some particular address. */
508 HOWTO (R_PPC64_COPY, /* type */
509 0, /* rightshift */
f5e87a1d
AM		 510 0, /* this one is variable size */
511 0, /* bitsize */
b34976b6 512 FALSE, /* pc_relative */
5bd4f169 513 0, /* bitpos */
f5e87a1d
AM		 514 complain_overflow_dont, /* complain_on_overflow */
515 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 516 "R_PPC64_COPY", /* name */
b34976b6 517 FALSE, /* partial_inplace */
5bd4f169
AM		 518 0, /* src_mask */
519 0, /* dst_mask */
b34976b6 520 FALSE), /* pcrel_offset */
5bd4f169
AM		 521
522 /* Like R_PPC64_ADDR64, but used when setting global offset table
523 entries. */
524 HOWTO (R_PPC64_GLOB_DAT, /* type */
525 0, /* rightshift */
526 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
527 64, /* bitsize */
b34976b6 528 FALSE, /* pc_relative */
5bd4f169
AM		 529 0, /* bitpos */
530 complain_overflow_dont, /* complain_on_overflow */
805fc799 531 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 532 "R_PPC64_GLOB_DAT", /* name */
b34976b6 533 FALSE, /* partial_inplace */
5bd4f169 534 0, /* src_mask */
f5e87a1d 535 ONES (64), /* dst_mask */
b34976b6 536 FALSE), /* pcrel_offset */
5bd4f169
AM		 537
538 /* Created by the link editor. Marks a procedure linkage table
539 entry for a symbol. */
540 HOWTO (R_PPC64_JMP_SLOT, /* type */
541 0, /* rightshift */
542 0, /* size (0 = byte, 1 = short, 2 = long) */
543 0, /* bitsize */
b34976b6 544 FALSE, /* pc_relative */
5bd4f169
AM		 545 0, /* bitpos */
546 complain_overflow_dont, /* complain_on_overflow */
805fc799 547 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 548 "R_PPC64_JMP_SLOT", /* name */
b34976b6 549 FALSE, /* partial_inplace */
5bd4f169
AM		 550 0, /* src_mask */
551 0, /* dst_mask */
b34976b6 552 FALSE), /* pcrel_offset */
5bd4f169
AM		 553
554 /* Used only by the dynamic linker. When the object is run, this
555 doubleword64 is set to the load address of the object, plus the
556 addend. */
557 HOWTO (R_PPC64_RELATIVE, /* type */
558 0, /* rightshift */
559 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
560 64, /* bitsize */
b34976b6 561 FALSE, /* pc_relative */
5bd4f169
AM		 562 0, /* bitpos */
563 complain_overflow_dont, /* complain_on_overflow */
564 bfd_elf_generic_reloc, /* special_function */
565 "R_PPC64_RELATIVE", /* name */
b34976b6 566 FALSE, /* partial_inplace */
5bd4f169 567 0, /* src_mask */
f5e87a1d 568 ONES (64), /* dst_mask */
b34976b6 569 FALSE), /* pcrel_offset */
5bd4f169
AM		 570
571 /* Like R_PPC64_ADDR32, but may be unaligned. */
572 HOWTO (R_PPC64_UADDR32, /* type */
573 0, /* rightshift */
574 2, /* size (0 = byte, 1 = short, 2 = long) */
575 32, /* bitsize */
b34976b6 576 FALSE, /* pc_relative */
5bd4f169
AM		 577 0, /* bitpos */
578 complain_overflow_bitfield, /* complain_on_overflow */
579 bfd_elf_generic_reloc, /* special_function */
580 "R_PPC64_UADDR32", /* name */
b34976b6 581 FALSE, /* partial_inplace */
5bd4f169
AM		 582 0, /* src_mask */
583 0xffffffff, /* dst_mask */
b34976b6 584 FALSE), /* pcrel_offset */
5bd4f169
AM		 585
586 /* Like R_PPC64_ADDR16, but may be unaligned. */
587 HOWTO (R_PPC64_UADDR16, /* type */
588 0, /* rightshift */
589 1, /* size (0 = byte, 1 = short, 2 = long) */
590 16, /* bitsize */
b34976b6 591 FALSE, /* pc_relative */
5bd4f169
AM		 592 0, /* bitpos */
593 complain_overflow_bitfield, /* complain_on_overflow */
594 bfd_elf_generic_reloc, /* special_function */
595 "R_PPC64_UADDR16", /* name */
b34976b6 596 FALSE, /* partial_inplace */
5bd4f169
AM		 597 0, /* src_mask */
598 0xffff, /* dst_mask */
b34976b6 599 FALSE), /* pcrel_offset */
5bd4f169
AM		 600
601 /* 32-bit PC relative. */
602 HOWTO (R_PPC64_REL32, /* type */
603 0, /* rightshift */
604 2, /* size (0 = byte, 1 = short, 2 = long) */
605 32, /* bitsize */
b34976b6 606 TRUE, /* pc_relative */
5bd4f169 607 0, /* bitpos */
cedb70c5 608 /* FIXME: Verify. Was complain_overflow_bitfield. */
5bd4f169
AM		 609 complain_overflow_signed, /* complain_on_overflow */
610 bfd_elf_generic_reloc, /* special_function */
611 "R_PPC64_REL32", /* name */
b34976b6 612 FALSE, /* partial_inplace */
5bd4f169
AM		 613 0, /* src_mask */
614 0xffffffff, /* dst_mask */
b34976b6 615 TRUE), /* pcrel_offset */
5bd4f169 616
10ed1bba 617 /* 32-bit relocation to the symbol's procedure linkage table. */
5bd4f169
AM		 618 HOWTO (R_PPC64_PLT32, /* type */
619 0, /* rightshift */
620 2, /* size (0 = byte, 1 = short, 2 = long) */
621 32, /* bitsize */
b34976b6 622 FALSE, /* pc_relative */
5bd4f169
AM		 623 0, /* bitpos */
624 complain_overflow_bitfield, /* complain_on_overflow */
805fc799 625 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 626 "R_PPC64_PLT32", /* name */
b34976b6 627 FALSE, /* partial_inplace */
5bd4f169 628 0, /* src_mask */
f5e87a1d 629 0xffffffff, /* dst_mask */
b34976b6 630 FALSE), /* pcrel_offset */
5bd4f169
AM		 631
632 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
633 FIXME: R_PPC64_PLTREL32 not supported. */
634 HOWTO (R_PPC64_PLTREL32, /* type */
635 0, /* rightshift */
636 2, /* size (0 = byte, 1 = short, 2 = long) */
637 32, /* bitsize */
b34976b6 638 TRUE, /* pc_relative */
5bd4f169
AM		 639 0, /* bitpos */
640 complain_overflow_signed, /* complain_on_overflow */
641 bfd_elf_generic_reloc, /* special_function */
642 "R_PPC64_PLTREL32", /* name */
b34976b6 643 FALSE, /* partial_inplace */
5bd4f169 644 0, /* src_mask */
f5e87a1d 645 0xffffffff, /* dst_mask */
b34976b6 646 TRUE), /* pcrel_offset */
5bd4f169
AM		 647
648 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
649 the symbol. */
650 HOWTO (R_PPC64_PLT16_LO, /* type */
651 0, /* rightshift */
652 1, /* size (0 = byte, 1 = short, 2 = long) */
653 16, /* bitsize */
b34976b6 654 FALSE, /* pc_relative */
5bd4f169
AM		 655 0, /* bitpos */
656 complain_overflow_dont, /* complain_on_overflow */
805fc799 657 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 658 "R_PPC64_PLT16_LO", /* name */
b34976b6 659 FALSE, /* partial_inplace */
5bd4f169
AM		 660 0, /* src_mask */
661 0xffff, /* dst_mask */
b34976b6 662 FALSE), /* pcrel_offset */
5bd4f169
AM		 663
664 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
665 the symbol. */
666 HOWTO (R_PPC64_PLT16_HI, /* type */
667 16, /* rightshift */
668 1, /* size (0 = byte, 1 = short, 2 = long) */
669 16, /* bitsize */
b34976b6 670 FALSE, /* pc_relative */
5bd4f169
AM		 671 0, /* bitpos */
672 complain_overflow_dont, /* complain_on_overflow */
805fc799 673 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 674 "R_PPC64_PLT16_HI", /* name */
b34976b6 675 FALSE, /* partial_inplace */
5bd4f169
AM		 676 0, /* src_mask */
677 0xffff, /* dst_mask */
b34976b6 678 FALSE), /* pcrel_offset */
5bd4f169
AM		 679
680 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
681 the symbol. */
682 HOWTO (R_PPC64_PLT16_HA, /* type */
683 16, /* rightshift */
684 1, /* size (0 = byte, 1 = short, 2 = long) */
685 16, /* bitsize */
b34976b6 686 FALSE, /* pc_relative */
5bd4f169
AM		 687 0, /* bitpos */
688 complain_overflow_dont, /* complain_on_overflow */
805fc799 689 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 690 "R_PPC64_PLT16_HA", /* name */
b34976b6 691 FALSE, /* partial_inplace */
5bd4f169
AM		 692 0, /* src_mask */
693 0xffff, /* dst_mask */
b34976b6 694 FALSE), /* pcrel_offset */
5bd4f169 695
c061c2d8 696 /* 16-bit section relative relocation. */
5bd4f169
AM		 697 HOWTO (R_PPC64_SECTOFF, /* type */
698 0, /* rightshift */
c061c2d8
AM		 699 1, /* size (0 = byte, 1 = short, 2 = long) */
700 16, /* bitsize */
b34976b6 701 FALSE, /* pc_relative */
5bd4f169
AM		 702 0, /* bitpos */
703 complain_overflow_bitfield, /* complain_on_overflow */
805fc799 704 ppc64_elf_sectoff_reloc, /* special_function */
5bd4f169 705 "R_PPC64_SECTOFF", /* name */
b34976b6 706 FALSE, /* partial_inplace */
5bd4f169 707 0, /* src_mask */
c061c2d8 708 0xffff, /* dst_mask */
b34976b6 709 FALSE), /* pcrel_offset */
5bd4f169 710
c061c2d8 711 /* Like R_PPC64_SECTOFF, but no overflow warning. */
5bd4f169
AM		 712 HOWTO (R_PPC64_SECTOFF_LO, /* type */
713 0, /* rightshift */
714 1, /* size (0 = byte, 1 = short, 2 = long) */
715 16, /* bitsize */
b34976b6 716 FALSE, /* pc_relative */
5bd4f169
AM		 717 0, /* bitpos */
718 complain_overflow_dont, /* complain_on_overflow */
805fc799 719 ppc64_elf_sectoff_reloc, /* special_function */
5bd4f169 720 "R_PPC64_SECTOFF_LO", /* name */
b34976b6 721 FALSE, /* partial_inplace */
5bd4f169
AM		 722 0, /* src_mask */
723 0xffff, /* dst_mask */
b34976b6 724 FALSE), /* pcrel_offset */
5bd4f169
AM		 725
726 /* 16-bit upper half section relative relocation. */
727 HOWTO (R_PPC64_SECTOFF_HI, /* type */
728 16, /* rightshift */
729 1, /* size (0 = byte, 1 = short, 2 = long) */
730 16, /* bitsize */
b34976b6 731 FALSE, /* pc_relative */
5bd4f169
AM		 732 0, /* bitpos */
733 complain_overflow_dont, /* complain_on_overflow */
805fc799 734 ppc64_elf_sectoff_reloc, /* special_function */
5bd4f169 735 "R_PPC64_SECTOFF_HI", /* name */
b34976b6 736 FALSE, /* partial_inplace */
5bd4f169
AM		 737 0, /* src_mask */
738 0xffff, /* dst_mask */
b34976b6 739 FALSE), /* pcrel_offset */
5bd4f169
AM		 740
741 /* 16-bit upper half adjusted section relative relocation. */
742 HOWTO (R_PPC64_SECTOFF_HA, /* type */
743 16, /* rightshift */
744 1, /* size (0 = byte, 1 = short, 2 = long) */
745 16, /* bitsize */
b34976b6 746 FALSE, /* pc_relative */
5bd4f169
AM		 747 0, /* bitpos */
748 complain_overflow_dont, /* complain_on_overflow */
805fc799 749 ppc64_elf_sectoff_ha_reloc, /* special_function */
5bd4f169 750 "R_PPC64_SECTOFF_HA", /* name */
b34976b6 751 FALSE, /* partial_inplace */
5bd4f169
AM		 752 0, /* src_mask */
753 0xffff, /* dst_mask */
b34976b6 754 FALSE), /* pcrel_offset */
5bd4f169 755
04c9666a
AM		 756 /* Like R_PPC64_REL24 without touching the two least significant bits. */
757 HOWTO (R_PPC64_REL30, /* type */
5bd4f169
AM		 758 2, /* rightshift */
759 2, /* size (0 = byte, 1 = short, 2 = long) */
760 30, /* bitsize */
b34976b6 761 TRUE, /* pc_relative */
5bd4f169
AM		 762 0, /* bitpos */
763 complain_overflow_dont, /* complain_on_overflow */
764 bfd_elf_generic_reloc, /* special_function */
04c9666a 765 "R_PPC64_REL30", /* name */
b34976b6 766 FALSE, /* partial_inplace */
d006db6c 767 0, /* src_mask */
5bd4f169 768 0xfffffffc, /* dst_mask */
b34976b6 769 TRUE), /* pcrel_offset */
5bd4f169
AM		 770
771 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
772
773 /* A standard 64-bit relocation. */
774 HOWTO (R_PPC64_ADDR64, /* type */
775 0, /* rightshift */
776 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
777 64, /* bitsize */
b34976b6 778 FALSE, /* pc_relative */
5bd4f169
AM		 779 0, /* bitpos */
780 complain_overflow_dont, /* complain_on_overflow */
781 bfd_elf_generic_reloc, /* special_function */
782 "R_PPC64_ADDR64", /* name */
b34976b6 783 FALSE, /* partial_inplace */
5bd4f169 784 0, /* src_mask */
f5e87a1d 785 ONES (64), /* dst_mask */
b34976b6 786 FALSE), /* pcrel_offset */
5bd4f169
AM		 787
788 /* The bits 32-47 of an address. */
789 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
790 32, /* rightshift */
791 1, /* size (0 = byte, 1 = short, 2 = long) */
792 16, /* bitsize */
b34976b6 793 FALSE, /* pc_relative */
5bd4f169
AM		 794 0, /* bitpos */
795 complain_overflow_dont, /* complain_on_overflow */
796 bfd_elf_generic_reloc, /* special_function */
797 "R_PPC64_ADDR16_HIGHER", /* name */
b34976b6 798 FALSE, /* partial_inplace */
5bd4f169
AM		 799 0, /* src_mask */
800 0xffff, /* dst_mask */
b34976b6 801 FALSE), /* pcrel_offset */
5bd4f169
AM		 802
803 /* The bits 32-47 of an address, plus 1 if the contents of the low
804 16 bits, treated as a signed number, is negative. */
805 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
806 32, /* rightshift */
807 1, /* size (0 = byte, 1 = short, 2 = long) */
808 16, /* bitsize */
b34976b6 809 FALSE, /* pc_relative */
5bd4f169
AM		 810 0, /* bitpos */
811 complain_overflow_dont, /* complain_on_overflow */
805fc799 812 ppc64_elf_ha_reloc, /* special_function */
5bd4f169 813 "R_PPC64_ADDR16_HIGHERA", /* name */
b34976b6 814 FALSE, /* partial_inplace */
5bd4f169
AM		 815 0, /* src_mask */
816 0xffff, /* dst_mask */
b34976b6 817 FALSE), /* pcrel_offset */
5bd4f169
AM		 818
819 /* The bits 48-63 of an address. */
820 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
821 48, /* rightshift */
822 1, /* size (0 = byte, 1 = short, 2 = long) */
823 16, /* bitsize */
b34976b6 824 FALSE, /* pc_relative */
5bd4f169
AM		 825 0, /* bitpos */
826 complain_overflow_dont, /* complain_on_overflow */
827 bfd_elf_generic_reloc, /* special_function */
828 "R_PPC64_ADDR16_HIGHEST", /* name */
b34976b6 829 FALSE, /* partial_inplace */
5bd4f169
AM		 830 0, /* src_mask */
831 0xffff, /* dst_mask */
b34976b6 832 FALSE), /* pcrel_offset */
5bd4f169
AM		 833
834 /* The bits 48-63 of an address, plus 1 if the contents of the low
835 16 bits, treated as a signed number, is negative. */
836 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
837 48, /* rightshift */
838 1, /* size (0 = byte, 1 = short, 2 = long) */
839 16, /* bitsize */
b34976b6 840 FALSE, /* pc_relative */
5bd4f169
AM		 841 0, /* bitpos */
842 complain_overflow_dont, /* complain_on_overflow */
805fc799 843 ppc64_elf_ha_reloc, /* special_function */
5bd4f169 844 "R_PPC64_ADDR16_HIGHESTA", /* name */
b34976b6 845 FALSE, /* partial_inplace */
5bd4f169
AM		 846 0, /* src_mask */
847 0xffff, /* dst_mask */
b34976b6 848 FALSE), /* pcrel_offset */
5bd4f169
AM		 849
850 /* Like ADDR64, but may be unaligned. */
851 HOWTO (R_PPC64_UADDR64, /* type */
852 0, /* rightshift */
853 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
854 64, /* bitsize */
b34976b6 855 FALSE, /* pc_relative */
5bd4f169
AM		 856 0, /* bitpos */
857 complain_overflow_dont, /* complain_on_overflow */
858 bfd_elf_generic_reloc, /* special_function */
859 "R_PPC64_UADDR64", /* name */
b34976b6 860 FALSE, /* partial_inplace */
5bd4f169 861 0, /* src_mask */
f5e87a1d 862 ONES (64), /* dst_mask */
b34976b6 863 FALSE), /* pcrel_offset */
5bd4f169
AM		 864
865 /* 64-bit relative relocation. */
866 HOWTO (R_PPC64_REL64, /* type */
867 0, /* rightshift */
868 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
869 64, /* bitsize */
b34976b6 870 TRUE, /* pc_relative */
5bd4f169
AM		 871 0, /* bitpos */
872 complain_overflow_dont, /* complain_on_overflow */
873 bfd_elf_generic_reloc, /* special_function */
874 "R_PPC64_REL64", /* name */
b34976b6 875 FALSE, /* partial_inplace */
5bd4f169 876 0, /* src_mask */
f5e87a1d 877 ONES (64), /* dst_mask */
b34976b6 878 TRUE), /* pcrel_offset */
5bd4f169 879
cedb70c5 880 /* 64-bit relocation to the symbol's procedure linkage table. */
5bd4f169
AM		 881 HOWTO (R_PPC64_PLT64, /* type */
882 0, /* rightshift */
883 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
884 64, /* bitsize */
b34976b6 885 FALSE, /* pc_relative */
5bd4f169
AM		 886 0, /* bitpos */
887 complain_overflow_dont, /* complain_on_overflow */
805fc799 888 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 889 "R_PPC64_PLT64", /* name */
b34976b6 890 FALSE, /* partial_inplace */
5bd4f169 891 0, /* src_mask */
f5e87a1d 892 ONES (64), /* dst_mask */
b34976b6 893 FALSE), /* pcrel_offset */
5bd4f169
AM		 894
895 /* 64-bit PC relative relocation to the symbol's procedure linkage
896 table. */
897 /* FIXME: R_PPC64_PLTREL64 not supported. */
898 HOWTO (R_PPC64_PLTREL64, /* type */
899 0, /* rightshift */
900 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
901 64, /* bitsize */
b34976b6 902 TRUE, /* pc_relative */
5bd4f169
AM		 903 0, /* bitpos */
904 complain_overflow_dont, /* complain_on_overflow */
805fc799 905 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 906 "R_PPC64_PLTREL64", /* name */
b34976b6 907 FALSE, /* partial_inplace */
5bd4f169 908 0, /* src_mask */
f5e87a1d 909 ONES (64), /* dst_mask */
b34976b6 910 TRUE), /* pcrel_offset */
5bd4f169
AM		 911
912 /* 16 bit TOC-relative relocation. */
913
914 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
915 HOWTO (R_PPC64_TOC16, /* type */
916 0, /* rightshift */
917 1, /* size (0 = byte, 1 = short, 2 = long) */
918 16, /* bitsize */
b34976b6 919 FALSE, /* pc_relative */
5bd4f169
AM		 920 0, /* bitpos */
921 complain_overflow_signed, /* complain_on_overflow */
805fc799 922 ppc64_elf_toc_reloc, /* special_function */
5bd4f169 923 "R_PPC64_TOC16", /* name */
b34976b6 924 FALSE, /* partial_inplace */
5bd4f169
AM		 925 0, /* src_mask */
926 0xffff, /* dst_mask */
b34976b6 927 FALSE), /* pcrel_offset */
5bd4f169
AM		 928
929 /* 16 bit TOC-relative relocation without overflow. */
930
931 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
932 HOWTO (R_PPC64_TOC16_LO, /* type */
933 0, /* rightshift */
934 1, /* size (0 = byte, 1 = short, 2 = long) */
935 16, /* bitsize */
b34976b6 936 FALSE, /* pc_relative */
5bd4f169
AM		 937 0, /* bitpos */
938 complain_overflow_dont, /* complain_on_overflow */
805fc799 939 ppc64_elf_toc_reloc, /* special_function */
5bd4f169 940 "R_PPC64_TOC16_LO", /* name */
b34976b6 941 FALSE, /* partial_inplace */
5bd4f169
AM		 942 0, /* src_mask */
943 0xffff, /* dst_mask */
b34976b6 944 FALSE), /* pcrel_offset */
5bd4f169
AM		 945
946 /* 16 bit TOC-relative relocation, high 16 bits. */
947
948 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
949 HOWTO (R_PPC64_TOC16_HI, /* type */
950 16, /* rightshift */
951 1, /* size (0 = byte, 1 = short, 2 = long) */
952 16, /* bitsize */
b34976b6 953 FALSE, /* pc_relative */
5bd4f169
AM		 954 0, /* bitpos */
955 complain_overflow_dont, /* complain_on_overflow */
805fc799 956 ppc64_elf_toc_reloc, /* special_function */
5bd4f169 957 "R_PPC64_TOC16_HI", /* name */
b34976b6 958 FALSE, /* partial_inplace */
5bd4f169
AM		 959 0, /* src_mask */
960 0xffff, /* dst_mask */
b34976b6 961 FALSE), /* pcrel_offset */
5bd4f169
AM		 962
963 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
964 contents of the low 16 bits, treated as a signed number, is
965 negative. */
966
967 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
968 HOWTO (R_PPC64_TOC16_HA, /* type */
969 16, /* rightshift */
970 1, /* size (0 = byte, 1 = short, 2 = long) */
971 16, /* bitsize */
b34976b6 972 FALSE, /* pc_relative */
5bd4f169
AM		 973 0, /* bitpos */
974 complain_overflow_dont, /* complain_on_overflow */
805fc799 975 ppc64_elf_toc_ha_reloc, /* special_function */
5bd4f169 976 "R_PPC64_TOC16_HA", /* name */
b34976b6 977 FALSE, /* partial_inplace */
5bd4f169
AM		 978 0, /* src_mask */
979 0xffff, /* dst_mask */
b34976b6 980 FALSE), /* pcrel_offset */
5bd4f169
AM		 981
982 /* 64-bit relocation; insert value of TOC base (.TOC.). */
983
984 /* R_PPC64_TOC 51 doubleword64 .TOC. */
985 HOWTO (R_PPC64_TOC, /* type */
986 0, /* rightshift */
987 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
988 64, /* bitsize */
b34976b6 989 FALSE, /* pc_relative */
5bd4f169
AM		 990 0, /* bitpos */
991 complain_overflow_bitfield, /* complain_on_overflow */
805fc799 992 ppc64_elf_toc64_reloc, /* special_function */
5bd4f169 993 "R_PPC64_TOC", /* name */
b34976b6 994 FALSE, /* partial_inplace */
5bd4f169 995 0, /* src_mask */
f5e87a1d 996 ONES (64), /* dst_mask */
b34976b6 997 FALSE), /* pcrel_offset */
5bd4f169
AM		 998
999 /* Like R_PPC64_GOT16, but also informs the link editor that the
1000 value to relocate may (!) refer to a PLT entry which the link
1001 editor (a) may replace with the symbol value. If the link editor
1002 is unable to fully resolve the symbol, it may (b) create a PLT
1003 entry and store the address to the new PLT entry in the GOT.
1004 This permits lazy resolution of function symbols at run time.
1005 The link editor may also skip all of this and just (c) emit a
1006 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1007 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1008 HOWTO (R_PPC64_PLTGOT16, /* type */
1009 0, /* rightshift */
1010 1, /* size (0 = byte, 1 = short, 2 = long) */
1011 16, /* bitsize */
b34976b6 1012 FALSE, /* pc_relative */
5bd4f169
AM		 1013 0, /* bitpos */
1014 complain_overflow_signed, /* complain_on_overflow */
805fc799 1015 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb
AM		 1016 "R_PPC64_PLTGOT16", /* name */
1017 FALSE, /* partial_inplace */
1018 0, /* src_mask */
1019 0xffff, /* dst_mask */
1020 FALSE), /* pcrel_offset */
1021
1022 /* Like R_PPC64_PLTGOT16, but without overflow. */
1023 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1024 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1025 0, /* rightshift */
1026 1, /* size (0 = byte, 1 = short, 2 = long) */
1027 16, /* bitsize */
1028 FALSE, /* pc_relative */
1029 0, /* bitpos */
1030 complain_overflow_dont, /* complain_on_overflow */
1031 ppc64_elf_unhandled_reloc, /* special_function */
1032 "R_PPC64_PLTGOT16_LO", /* name */
1033 FALSE, /* partial_inplace */
1034 0, /* src_mask */
1035 0xffff, /* dst_mask */
1036 FALSE), /* pcrel_offset */
1037
1038 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1039 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1040 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1041 16, /* rightshift */
1042 1, /* size (0 = byte, 1 = short, 2 = long) */
1043 16, /* bitsize */
1044 FALSE, /* pc_relative */
1045 0, /* bitpos */
1046 complain_overflow_dont, /* complain_on_overflow */
1047 ppc64_elf_unhandled_reloc, /* special_function */
1048 "R_PPC64_PLTGOT16_HI", /* name */
1049 FALSE, /* partial_inplace */
1050 0, /* src_mask */
1051 0xffff, /* dst_mask */
1052 FALSE), /* pcrel_offset */
1053
1054 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1055 1 if the contents of the low 16 bits, treated as a signed number,
1056 is negative. */
1057 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1058 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1059 16, /* rightshift */
1060 1, /* size (0 = byte, 1 = short, 2 = long) */
1061 16, /* bitsize */
1062 FALSE, /* pc_relative */
1063 0, /* bitpos */
1064 complain_overflow_dont,/* complain_on_overflow */
1065 ppc64_elf_unhandled_reloc, /* special_function */
1066 "R_PPC64_PLTGOT16_HA", /* name */
1067 FALSE, /* partial_inplace */
1068 0, /* src_mask */
1069 0xffff, /* dst_mask */
1070 FALSE), /* pcrel_offset */
1071
1072 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1073 HOWTO (R_PPC64_ADDR16_DS, /* type */
1074 0, /* rightshift */
1075 1, /* size (0 = byte, 1 = short, 2 = long) */
1076 16, /* bitsize */
1077 FALSE, /* pc_relative */
1078 0, /* bitpos */
1079 complain_overflow_bitfield, /* complain_on_overflow */
1080 bfd_elf_generic_reloc, /* special_function */
1081 "R_PPC64_ADDR16_DS", /* name */
1082 FALSE, /* partial_inplace */
1083 0, /* src_mask */
1084 0xfffc, /* dst_mask */
1085 FALSE), /* pcrel_offset */
1086
1087 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1088 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1089 0, /* rightshift */
1090 1, /* size (0 = byte, 1 = short, 2 = long) */
1091 16, /* bitsize */
1092 FALSE, /* pc_relative */
1093 0, /* bitpos */
1094 complain_overflow_dont,/* complain_on_overflow */
1095 bfd_elf_generic_reloc, /* special_function */
1096 "R_PPC64_ADDR16_LO_DS",/* name */
1097 FALSE, /* partial_inplace */
1098 0, /* src_mask */
1099 0xfffc, /* dst_mask */
1100 FALSE), /* pcrel_offset */
1101
1102 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1103 HOWTO (R_PPC64_GOT16_DS, /* type */
1104 0, /* rightshift */
1105 1, /* size (0 = byte, 1 = short, 2 = long) */
1106 16, /* bitsize */
1107 FALSE, /* pc_relative */
1108 0, /* bitpos */
1109 complain_overflow_signed, /* complain_on_overflow */
1110 ppc64_elf_unhandled_reloc, /* special_function */
1111 "R_PPC64_GOT16_DS", /* name */
1112 FALSE, /* partial_inplace */
1113 0, /* src_mask */
1114 0xfffc, /* dst_mask */
1115 FALSE), /* pcrel_offset */
1116
1117 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1118 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1119 0, /* rightshift */
1120 1, /* size (0 = byte, 1 = short, 2 = long) */
1121 16, /* bitsize */
1122 FALSE, /* pc_relative */
1123 0, /* bitpos */
1124 complain_overflow_dont, /* complain_on_overflow */
1125 ppc64_elf_unhandled_reloc, /* special_function */
1126 "R_PPC64_GOT16_LO_DS", /* name */
1127 FALSE, /* partial_inplace */
1128 0, /* src_mask */
1129 0xfffc, /* dst_mask */
1130 FALSE), /* pcrel_offset */
1131
1132 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1133 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1134 0, /* rightshift */
1135 1, /* size (0 = byte, 1 = short, 2 = long) */
1136 16, /* bitsize */
1137 FALSE, /* pc_relative */
1138 0, /* bitpos */
1139 complain_overflow_dont, /* complain_on_overflow */
1140 ppc64_elf_unhandled_reloc, /* special_function */
1141 "R_PPC64_PLT16_LO_DS", /* name */
1142 FALSE, /* partial_inplace */
1143 0, /* src_mask */
1144 0xfffc, /* dst_mask */
1145 FALSE), /* pcrel_offset */
1146
1147 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1148 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1149 0, /* rightshift */
1150 1, /* size (0 = byte, 1 = short, 2 = long) */
1151 16, /* bitsize */
1152 FALSE, /* pc_relative */
1153 0, /* bitpos */
1154 complain_overflow_bitfield, /* complain_on_overflow */
1155 ppc64_elf_sectoff_reloc, /* special_function */
1156 "R_PPC64_SECTOFF_DS", /* name */
1157 FALSE, /* partial_inplace */
1158 0, /* src_mask */
1159 0xfffc, /* dst_mask */
1160 FALSE), /* pcrel_offset */
1161
1162 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1163 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1164 0, /* rightshift */
1165 1, /* size (0 = byte, 1 = short, 2 = long) */
1166 16, /* bitsize */
1167 FALSE, /* pc_relative */
1168 0, /* bitpos */
1169 complain_overflow_dont, /* complain_on_overflow */
1170 ppc64_elf_sectoff_reloc, /* special_function */
1171 "R_PPC64_SECTOFF_LO_DS",/* name */
1172 FALSE, /* partial_inplace */
1173 0, /* src_mask */
1174 0xfffc, /* dst_mask */
1175 FALSE), /* pcrel_offset */
1176
1177 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1178 HOWTO (R_PPC64_TOC16_DS, /* type */
1179 0, /* rightshift */
1180 1, /* size (0 = byte, 1 = short, 2 = long) */
1181 16, /* bitsize */
1182 FALSE, /* pc_relative */
1183 0, /* bitpos */
1184 complain_overflow_signed, /* complain_on_overflow */
1185 ppc64_elf_toc_reloc, /* special_function */
1186 "R_PPC64_TOC16_DS", /* name */
1187 FALSE, /* partial_inplace */
1188 0, /* src_mask */
1189 0xfffc, /* dst_mask */
1190 FALSE), /* pcrel_offset */
1191
1192 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1193 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1194 0, /* rightshift */
1195 1, /* size (0 = byte, 1 = short, 2 = long) */
1196 16, /* bitsize */
1197 FALSE, /* pc_relative */
1198 0, /* bitpos */
1199 complain_overflow_dont, /* complain_on_overflow */
1200 ppc64_elf_toc_reloc, /* special_function */
1201 "R_PPC64_TOC16_LO_DS", /* name */
1202 FALSE, /* partial_inplace */
1203 0, /* src_mask */
1204 0xfffc, /* dst_mask */
1205 FALSE), /* pcrel_offset */
1206
1207 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1208 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
6bfdb61b 1209 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
411e1bfb
AM		 1210 0, /* rightshift */
1211 1, /* size (0 = byte, 1 = short, 2 = long) */
1212 16, /* bitsize */
1213 FALSE, /* pc_relative */
1214 0, /* bitpos */
1215 complain_overflow_signed, /* complain_on_overflow */
1216 ppc64_elf_unhandled_reloc, /* special_function */
1217 "R_PPC64_PLTGOT16_DS", /* name */
1218 FALSE, /* partial_inplace */
1219 0, /* src_mask */
1220 0xfffc, /* dst_mask */
1221 FALSE), /* pcrel_offset */
1222
1223 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1224 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1225 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1226 0, /* rightshift */
1227 1, /* size (0 = byte, 1 = short, 2 = long) */
1228 16, /* bitsize */
1229 FALSE, /* pc_relative */
1230 0, /* bitpos */
1231 complain_overflow_dont, /* complain_on_overflow */
1232 ppc64_elf_unhandled_reloc, /* special_function */
1233 "R_PPC64_PLTGOT16_LO_DS",/* name */
1234 FALSE, /* partial_inplace */
1235 0, /* src_mask */
1236 0xfffc, /* dst_mask */
1237 FALSE), /* pcrel_offset */
1238
727fc41e 1239 /* Marker relocs for TLS. */
411e1bfb
AM		 1240 HOWTO (R_PPC64_TLS,
1241 0, /* rightshift */
1242 2, /* size (0 = byte, 1 = short, 2 = long) */
1243 32, /* bitsize */
1244 FALSE, /* pc_relative */
1245 0, /* bitpos */
1246 complain_overflow_dont, /* complain_on_overflow */
1247 bfd_elf_generic_reloc, /* special_function */
1248 "R_PPC64_TLS", /* name */
1249 FALSE, /* partial_inplace */
1250 0, /* src_mask */
1251 0, /* dst_mask */
1252 FALSE), /* pcrel_offset */
1253
727fc41e
AM		 1254 HOWTO (R_PPC64_TLSGD,
1255 0, /* rightshift */
1256 2, /* size (0 = byte, 1 = short, 2 = long) */
1257 32, /* bitsize */
1258 FALSE, /* pc_relative */
1259 0, /* bitpos */
1260 complain_overflow_dont, /* complain_on_overflow */
1261 bfd_elf_generic_reloc, /* special_function */
1262 "R_PPC64_TLSGD", /* name */
1263 FALSE, /* partial_inplace */
1264 0, /* src_mask */
1265 0, /* dst_mask */
1266 FALSE), /* pcrel_offset */
1267
1268 HOWTO (R_PPC64_TLSLD,
1269 0, /* rightshift */
1270 2, /* size (0 = byte, 1 = short, 2 = long) */
1271 32, /* bitsize */
1272 FALSE, /* pc_relative */
1273 0, /* bitpos */
1274 complain_overflow_dont, /* complain_on_overflow */
1275 bfd_elf_generic_reloc, /* special_function */
1276 "R_PPC64_TLSLD", /* name */
1277 FALSE, /* partial_inplace */
1278 0, /* src_mask */
1279 0, /* dst_mask */
1280 FALSE), /* pcrel_offset */
1281
411e1bfb
AM		 1282 /* Computes the load module index of the load module that contains the
1283 definition of its TLS sym. */
1284 HOWTO (R_PPC64_DTPMOD64,
1285 0, /* rightshift */
1286 4, /* size (0 = byte, 1 = short, 2 = long) */
1287 64, /* bitsize */
1288 FALSE, /* pc_relative */
1289 0, /* bitpos */
1290 complain_overflow_dont, /* complain_on_overflow */
1291 ppc64_elf_unhandled_reloc, /* special_function */
1292 "R_PPC64_DTPMOD64", /* name */
1293 FALSE, /* partial_inplace */
1294 0, /* src_mask */
1295 ONES (64), /* dst_mask */
1296 FALSE), /* pcrel_offset */
1297
1298 /* Computes a dtv-relative displacement, the difference between the value
1299 of sym+add and the base address of the thread-local storage block that
1300 contains the definition of sym, minus 0x8000. */
1301 HOWTO (R_PPC64_DTPREL64,
1302 0, /* rightshift */
1303 4, /* size (0 = byte, 1 = short, 2 = long) */
1304 64, /* bitsize */
1305 FALSE, /* pc_relative */
1306 0, /* bitpos */
1307 complain_overflow_dont, /* complain_on_overflow */
1308 ppc64_elf_unhandled_reloc, /* special_function */
1309 "R_PPC64_DTPREL64", /* name */
1310 FALSE, /* partial_inplace */
1311 0, /* src_mask */
1312 ONES (64), /* dst_mask */
1313 FALSE), /* pcrel_offset */
1314
1315 /* A 16 bit dtprel reloc. */
1316 HOWTO (R_PPC64_DTPREL16,
1317 0, /* rightshift */
1318 1, /* size (0 = byte, 1 = short, 2 = long) */
1319 16, /* bitsize */
1320 FALSE, /* pc_relative */
1321 0, /* bitpos */
1322 complain_overflow_signed, /* complain_on_overflow */
1323 ppc64_elf_unhandled_reloc, /* special_function */
1324 "R_PPC64_DTPREL16", /* name */
1325 FALSE, /* partial_inplace */
1326 0, /* src_mask */
1327 0xffff, /* dst_mask */
1328 FALSE), /* pcrel_offset */
1329
1330 /* Like DTPREL16, but no overflow. */
1331 HOWTO (R_PPC64_DTPREL16_LO,
1332 0, /* rightshift */
1333 1, /* size (0 = byte, 1 = short, 2 = long) */
1334 16, /* bitsize */
1335 FALSE, /* pc_relative */
1336 0, /* bitpos */
1337 complain_overflow_dont, /* complain_on_overflow */
1338 ppc64_elf_unhandled_reloc, /* special_function */
1339 "R_PPC64_DTPREL16_LO", /* name */
1340 FALSE, /* partial_inplace */
1341 0, /* src_mask */
1342 0xffff, /* dst_mask */
1343 FALSE), /* pcrel_offset */
1344
1345 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1346 HOWTO (R_PPC64_DTPREL16_HI,
1347 16, /* rightshift */
1348 1, /* size (0 = byte, 1 = short, 2 = long) */
1349 16, /* bitsize */
1350 FALSE, /* pc_relative */
1351 0, /* bitpos */
1352 complain_overflow_dont, /* complain_on_overflow */
1353 ppc64_elf_unhandled_reloc, /* special_function */
1354 "R_PPC64_DTPREL16_HI", /* name */
1355 FALSE, /* partial_inplace */
1356 0, /* src_mask */
1357 0xffff, /* dst_mask */
1358 FALSE), /* pcrel_offset */
1359
1360 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1361 HOWTO (R_PPC64_DTPREL16_HA,
1362 16, /* rightshift */
1363 1, /* size (0 = byte, 1 = short, 2 = long) */
1364 16, /* bitsize */
1365 FALSE, /* pc_relative */
1366 0, /* bitpos */
1367 complain_overflow_dont, /* complain_on_overflow */
1368 ppc64_elf_unhandled_reloc, /* special_function */
1369 "R_PPC64_DTPREL16_HA", /* name */
1370 FALSE, /* partial_inplace */
1371 0, /* src_mask */
1372 0xffff, /* dst_mask */
1373 FALSE), /* pcrel_offset */
1374
1375 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1376 HOWTO (R_PPC64_DTPREL16_HIGHER,
1377 32, /* rightshift */
1378 1, /* size (0 = byte, 1 = short, 2 = long) */
1379 16, /* bitsize */
1380 FALSE, /* pc_relative */
1381 0, /* bitpos */
1382 complain_overflow_dont, /* complain_on_overflow */
1383 ppc64_elf_unhandled_reloc, /* special_function */
1384 "R_PPC64_DTPREL16_HIGHER", /* name */
1385 FALSE, /* partial_inplace */
1386 0, /* src_mask */
1387 0xffff, /* dst_mask */
1388 FALSE), /* pcrel_offset */
1389
1390 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1391 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1392 32, /* rightshift */
1393 1, /* size (0 = byte, 1 = short, 2 = long) */
1394 16, /* bitsize */
1395 FALSE, /* pc_relative */
1396 0, /* bitpos */
1397 complain_overflow_dont, /* complain_on_overflow */
1398 ppc64_elf_unhandled_reloc, /* special_function */
1399 "R_PPC64_DTPREL16_HIGHERA", /* name */
1400 FALSE, /* partial_inplace */
1401 0, /* src_mask */
1402 0xffff, /* dst_mask */
1403 FALSE), /* pcrel_offset */
1404
1405 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1406 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1407 48, /* rightshift */
1408 1, /* size (0 = byte, 1 = short, 2 = long) */
1409 16, /* bitsize */
1410 FALSE, /* pc_relative */
1411 0, /* bitpos */
1412 complain_overflow_dont, /* complain_on_overflow */
1413 ppc64_elf_unhandled_reloc, /* special_function */
1414 "R_PPC64_DTPREL16_HIGHEST", /* name */
1415 FALSE, /* partial_inplace */
1416 0, /* src_mask */
1417 0xffff, /* dst_mask */
1418 FALSE), /* pcrel_offset */
1419
1420 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1421 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1422 48, /* rightshift */
1423 1, /* size (0 = byte, 1 = short, 2 = long) */
1424 16, /* bitsize */
1425 FALSE, /* pc_relative */
1426 0, /* bitpos */
1427 complain_overflow_dont, /* complain_on_overflow */
1428 ppc64_elf_unhandled_reloc, /* special_function */
1429 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1430 FALSE, /* partial_inplace */
1431 0, /* src_mask */
1432 0xffff, /* dst_mask */
1433 FALSE), /* pcrel_offset */
1434
1435 /* Like DTPREL16, but for insns with a DS field. */
1436 HOWTO (R_PPC64_DTPREL16_DS,
1437 0, /* rightshift */
1438 1, /* size (0 = byte, 1 = short, 2 = long) */
1439 16, /* bitsize */
1440 FALSE, /* pc_relative */
1441 0, /* bitpos */
1442 complain_overflow_signed, /* complain_on_overflow */
1443 ppc64_elf_unhandled_reloc, /* special_function */
1444 "R_PPC64_DTPREL16_DS", /* name */
1445 FALSE, /* partial_inplace */
1446 0, /* src_mask */
1447 0xfffc, /* dst_mask */
1448 FALSE), /* pcrel_offset */
1449
1450 /* Like DTPREL16_DS, but no overflow. */
1451 HOWTO (R_PPC64_DTPREL16_LO_DS,
1452 0, /* rightshift */
1453 1, /* size (0 = byte, 1 = short, 2 = long) */
1454 16, /* bitsize */
1455 FALSE, /* pc_relative */
1456 0, /* bitpos */
1457 complain_overflow_dont, /* complain_on_overflow */
1458 ppc64_elf_unhandled_reloc, /* special_function */
1459 "R_PPC64_DTPREL16_LO_DS", /* name */
1460 FALSE, /* partial_inplace */
1461 0, /* src_mask */
1462 0xfffc, /* dst_mask */
1463 FALSE), /* pcrel_offset */
1464
1465 /* Computes a tp-relative displacement, the difference between the value of
1466 sym+add and the value of the thread pointer (r13). */
1467 HOWTO (R_PPC64_TPREL64,
1468 0, /* rightshift */
1469 4, /* size (0 = byte, 1 = short, 2 = long) */
1470 64, /* bitsize */
1471 FALSE, /* pc_relative */
1472 0, /* bitpos */
1473 complain_overflow_dont, /* complain_on_overflow */
1474 ppc64_elf_unhandled_reloc, /* special_function */
1475 "R_PPC64_TPREL64", /* name */
1476 FALSE, /* partial_inplace */
1477 0, /* src_mask */
1478 ONES (64), /* dst_mask */
1479 FALSE), /* pcrel_offset */
1480
1481 /* A 16 bit tprel reloc. */
1482 HOWTO (R_PPC64_TPREL16,
1483 0, /* rightshift */
1484 1, /* size (0 = byte, 1 = short, 2 = long) */
1485 16, /* bitsize */
1486 FALSE, /* pc_relative */
1487 0, /* bitpos */
1488 complain_overflow_signed, /* complain_on_overflow */
1489 ppc64_elf_unhandled_reloc, /* special_function */
1490 "R_PPC64_TPREL16", /* name */
1491 FALSE, /* partial_inplace */
1492 0, /* src_mask */
1493 0xffff, /* dst_mask */
1494 FALSE), /* pcrel_offset */
1495
1496 /* Like TPREL16, but no overflow. */
1497 HOWTO (R_PPC64_TPREL16_LO,
1498 0, /* rightshift */
1499 1, /* size (0 = byte, 1 = short, 2 = long) */
1500 16, /* bitsize */
1501 FALSE, /* pc_relative */
1502 0, /* bitpos */
1503 complain_overflow_dont, /* complain_on_overflow */
1504 ppc64_elf_unhandled_reloc, /* special_function */
1505 "R_PPC64_TPREL16_LO", /* name */
1506 FALSE, /* partial_inplace */
1507 0, /* src_mask */
1508 0xffff, /* dst_mask */
1509 FALSE), /* pcrel_offset */
1510
1511 /* Like TPREL16_LO, but next higher group of 16 bits. */
1512 HOWTO (R_PPC64_TPREL16_HI,
1513 16, /* rightshift */
1514 1, /* size (0 = byte, 1 = short, 2 = long) */
1515 16, /* bitsize */
1516 FALSE, /* pc_relative */
1517 0, /* bitpos */
1518 complain_overflow_dont, /* complain_on_overflow */
1519 ppc64_elf_unhandled_reloc, /* special_function */
1520 "R_PPC64_TPREL16_HI", /* name */
1521 FALSE, /* partial_inplace */
1522 0, /* src_mask */
1523 0xffff, /* dst_mask */
1524 FALSE), /* pcrel_offset */
1525
1526 /* Like TPREL16_HI, but adjust for low 16 bits. */
1527 HOWTO (R_PPC64_TPREL16_HA,
1528 16, /* rightshift */
1529 1, /* size (0 = byte, 1 = short, 2 = long) */
1530 16, /* bitsize */
1531 FALSE, /* pc_relative */
1532 0, /* bitpos */
1533 complain_overflow_dont, /* complain_on_overflow */
1534 ppc64_elf_unhandled_reloc, /* special_function */
1535 "R_PPC64_TPREL16_HA", /* name */
1536 FALSE, /* partial_inplace */
1537 0, /* src_mask */
1538 0xffff, /* dst_mask */
1539 FALSE), /* pcrel_offset */
1540
1541 /* Like TPREL16_HI, but next higher group of 16 bits. */
1542 HOWTO (R_PPC64_TPREL16_HIGHER,
1543 32, /* rightshift */
1544 1, /* size (0 = byte, 1 = short, 2 = long) */
1545 16, /* bitsize */
1546 FALSE, /* pc_relative */
1547 0, /* bitpos */
1548 complain_overflow_dont, /* complain_on_overflow */
1549 ppc64_elf_unhandled_reloc, /* special_function */
1550 "R_PPC64_TPREL16_HIGHER", /* name */
1551 FALSE, /* partial_inplace */
1552 0, /* src_mask */
1553 0xffff, /* dst_mask */
1554 FALSE), /* pcrel_offset */
1555
1556 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1557 HOWTO (R_PPC64_TPREL16_HIGHERA,
1558 32, /* rightshift */
1559 1, /* size (0 = byte, 1 = short, 2 = long) */
1560 16, /* bitsize */
1561 FALSE, /* pc_relative */
1562 0, /* bitpos */
1563 complain_overflow_dont, /* complain_on_overflow */
1564 ppc64_elf_unhandled_reloc, /* special_function */
1565 "R_PPC64_TPREL16_HIGHERA", /* name */
1566 FALSE, /* partial_inplace */
1567 0, /* src_mask */
1568 0xffff, /* dst_mask */
1569 FALSE), /* pcrel_offset */
1570
1571 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1572 HOWTO (R_PPC64_TPREL16_HIGHEST,
1573 48, /* rightshift */
1574 1, /* size (0 = byte, 1 = short, 2 = long) */
1575 16, /* bitsize */
1576 FALSE, /* pc_relative */
1577 0, /* bitpos */
1578 complain_overflow_dont, /* complain_on_overflow */
1579 ppc64_elf_unhandled_reloc, /* special_function */
1580 "R_PPC64_TPREL16_HIGHEST", /* name */
1581 FALSE, /* partial_inplace */
1582 0, /* src_mask */
1583 0xffff, /* dst_mask */
1584 FALSE), /* pcrel_offset */
1585
1586 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1587 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1588 48, /* rightshift */
1589 1, /* size (0 = byte, 1 = short, 2 = long) */
1590 16, /* bitsize */
1591 FALSE, /* pc_relative */
1592 0, /* bitpos */
1593 complain_overflow_dont, /* complain_on_overflow */
1594 ppc64_elf_unhandled_reloc, /* special_function */
1595 "R_PPC64_TPREL16_HIGHESTA", /* name */
1596 FALSE, /* partial_inplace */
1597 0, /* src_mask */
1598 0xffff, /* dst_mask */
1599 FALSE), /* pcrel_offset */
1600
1601 /* Like TPREL16, but for insns with a DS field. */
1602 HOWTO (R_PPC64_TPREL16_DS,
1603 0, /* rightshift */
1604 1, /* size (0 = byte, 1 = short, 2 = long) */
1605 16, /* bitsize */
1606 FALSE, /* pc_relative */
1607 0, /* bitpos */
1608 complain_overflow_signed, /* complain_on_overflow */
1609 ppc64_elf_unhandled_reloc, /* special_function */
1610 "R_PPC64_TPREL16_DS", /* name */
1611 FALSE, /* partial_inplace */
1612 0, /* src_mask */
1613 0xfffc, /* dst_mask */
1614 FALSE), /* pcrel_offset */
1615
1616 /* Like TPREL16_DS, but no overflow. */
1617 HOWTO (R_PPC64_TPREL16_LO_DS,
1618 0, /* rightshift */
1619 1, /* size (0 = byte, 1 = short, 2 = long) */
1620 16, /* bitsize */
1621 FALSE, /* pc_relative */
1622 0, /* bitpos */
1623 complain_overflow_dont, /* complain_on_overflow */
1624 ppc64_elf_unhandled_reloc, /* special_function */
1625 "R_PPC64_TPREL16_LO_DS", /* name */
1626 FALSE, /* partial_inplace */
1627 0, /* src_mask */
1628 0xfffc, /* dst_mask */
1629 FALSE), /* pcrel_offset */
1630
1631 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1632 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1633 to the first entry relative to the TOC base (r2). */
1634 HOWTO (R_PPC64_GOT_TLSGD16,
1635 0, /* rightshift */
1636 1, /* size (0 = byte, 1 = short, 2 = long) */
1637 16, /* bitsize */
1638 FALSE, /* pc_relative */
1639 0, /* bitpos */
1640 complain_overflow_signed, /* complain_on_overflow */
1641 ppc64_elf_unhandled_reloc, /* special_function */
1642 "R_PPC64_GOT_TLSGD16", /* name */
b34976b6 1643 FALSE, /* partial_inplace */
5bd4f169
AM		 1644 0, /* src_mask */
1645 0xffff, /* dst_mask */
b34976b6 1646 FALSE), /* pcrel_offset */
5bd4f169 1647
411e1bfb
AM		 1648 /* Like GOT_TLSGD16, but no overflow. */
1649 HOWTO (R_PPC64_GOT_TLSGD16_LO,
5bd4f169
AM		 1650 0, /* rightshift */
1651 1, /* size (0 = byte, 1 = short, 2 = long) */
1652 16, /* bitsize */
b34976b6 1653 FALSE, /* pc_relative */
5bd4f169
AM		 1654 0, /* bitpos */
1655 complain_overflow_dont, /* complain_on_overflow */
805fc799 1656 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1657 "R_PPC64_GOT_TLSGD16_LO", /* name */
b34976b6 1658 FALSE, /* partial_inplace */
5bd4f169
AM		 1659 0, /* src_mask */
1660 0xffff, /* dst_mask */
b34976b6 1661 FALSE), /* pcrel_offset */
5bd4f169 1662
411e1bfb
AM		 1663 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1664 HOWTO (R_PPC64_GOT_TLSGD16_HI,
5bd4f169
AM		 1665 16, /* rightshift */
1666 1, /* size (0 = byte, 1 = short, 2 = long) */
1667 16, /* bitsize */
b34976b6 1668 FALSE, /* pc_relative */
5bd4f169
AM		 1669 0, /* bitpos */
1670 complain_overflow_dont, /* complain_on_overflow */
805fc799 1671 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1672 "R_PPC64_GOT_TLSGD16_HI", /* name */
b34976b6 1673 FALSE, /* partial_inplace */
5bd4f169
AM		 1674 0, /* src_mask */
1675 0xffff, /* dst_mask */
b34976b6 1676 FALSE), /* pcrel_offset */
5bd4f169 1677
411e1bfb
AM		 1678 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1679 HOWTO (R_PPC64_GOT_TLSGD16_HA,
5bd4f169
AM		 1680 16, /* rightshift */
1681 1, /* size (0 = byte, 1 = short, 2 = long) */
1682 16, /* bitsize */
b34976b6 1683 FALSE, /* pc_relative */
5bd4f169 1684 0, /* bitpos */
411e1bfb 1685 complain_overflow_dont, /* complain_on_overflow */
805fc799 1686 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1687 "R_PPC64_GOT_TLSGD16_HA", /* name */
b34976b6 1688 FALSE, /* partial_inplace */
5bd4f169
AM		 1689 0, /* src_mask */
1690 0xffff, /* dst_mask */
b34976b6 1691 FALSE), /* pcrel_offset */
5bd4f169 1692
411e1bfb
AM		 1693 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1694 with values (sym+add)@dtpmod and zero, and computes the offset to the
1695 first entry relative to the TOC base (r2). */
1696 HOWTO (R_PPC64_GOT_TLSLD16,
5bd4f169
AM		 1697 0, /* rightshift */
1698 1, /* size (0 = byte, 1 = short, 2 = long) */
1699 16, /* bitsize */
b34976b6 1700 FALSE, /* pc_relative */
5bd4f169 1701 0, /* bitpos */
411e1bfb
AM		 1702 complain_overflow_signed, /* complain_on_overflow */
1703 ppc64_elf_unhandled_reloc, /* special_function */
1704 "R_PPC64_GOT_TLSLD16", /* name */
b34976b6 1705 FALSE, /* partial_inplace */
d006db6c 1706 0, /* src_mask */
411e1bfb 1707 0xffff, /* dst_mask */
b34976b6 1708 FALSE), /* pcrel_offset */
5bd4f169 1709
411e1bfb
AM		 1710 /* Like GOT_TLSLD16, but no overflow. */
1711 HOWTO (R_PPC64_GOT_TLSLD16_LO,
5bd4f169
AM		 1712 0, /* rightshift */
1713 1, /* size (0 = byte, 1 = short, 2 = long) */
1714 16, /* bitsize */
b34976b6 1715 FALSE, /* pc_relative */
5bd4f169 1716 0, /* bitpos */
411e1bfb
AM		 1717 complain_overflow_dont, /* complain_on_overflow */
1718 ppc64_elf_unhandled_reloc, /* special_function */
1719 "R_PPC64_GOT_TLSLD16_LO", /* name */
b34976b6 1720 FALSE, /* partial_inplace */
d006db6c 1721 0, /* src_mask */
411e1bfb 1722 0xffff, /* dst_mask */
b34976b6 1723 FALSE), /* pcrel_offset */
5bd4f169 1724
411e1bfb
AM		 1725 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1726 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1727 16, /* rightshift */
5bd4f169
AM		 1728 1, /* size (0 = byte, 1 = short, 2 = long) */
1729 16, /* bitsize */
b34976b6 1730 FALSE, /* pc_relative */
5bd4f169 1731 0, /* bitpos */
411e1bfb 1732 complain_overflow_dont, /* complain_on_overflow */
805fc799 1733 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1734 "R_PPC64_GOT_TLSLD16_HI", /* name */
b34976b6 1735 FALSE, /* partial_inplace */
d006db6c 1736 0, /* src_mask */
411e1bfb 1737 0xffff, /* dst_mask */
b34976b6 1738 FALSE), /* pcrel_offset */
5bd4f169 1739
411e1bfb
AM		 1740 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1741 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1742 16, /* rightshift */
5bd4f169
AM		 1743 1, /* size (0 = byte, 1 = short, 2 = long) */
1744 16, /* bitsize */
b34976b6 1745 FALSE, /* pc_relative */
5bd4f169
AM		 1746 0, /* bitpos */
1747 complain_overflow_dont, /* complain_on_overflow */
805fc799 1748 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1749 "R_PPC64_GOT_TLSLD16_HA", /* name */
b34976b6 1750 FALSE, /* partial_inplace */
d006db6c 1751 0, /* src_mask */
411e1bfb 1752 0xffff, /* dst_mask */
b34976b6 1753 FALSE), /* pcrel_offset */
5bd4f169 1754
411e1bfb
AM		 1755 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1756 the offset to the entry relative to the TOC base (r2). */
1757 HOWTO (R_PPC64_GOT_DTPREL16_DS,
5bd4f169
AM		 1758 0, /* rightshift */
1759 1, /* size (0 = byte, 1 = short, 2 = long) */
1760 16, /* bitsize */
b34976b6 1761 FALSE, /* pc_relative */
5bd4f169 1762 0, /* bitpos */
411e1bfb 1763 complain_overflow_signed, /* complain_on_overflow */
805fc799 1764 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1765 "R_PPC64_GOT_DTPREL16_DS", /* name */
b34976b6 1766 FALSE, /* partial_inplace */
d006db6c 1767 0, /* src_mask */
5bd4f169 1768 0xfffc, /* dst_mask */
b34976b6 1769 FALSE), /* pcrel_offset */
5bd4f169 1770
411e1bfb
AM		 1771 /* Like GOT_DTPREL16_DS, but no overflow. */
1772 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
5bd4f169 1773 0, /* rightshift */
c061c2d8
AM		 1774 1, /* size (0 = byte, 1 = short, 2 = long) */
1775 16, /* bitsize */
b34976b6 1776 FALSE, /* pc_relative */
5bd4f169 1777 0, /* bitpos */
411e1bfb
AM		 1778 complain_overflow_dont, /* complain_on_overflow */
1779 ppc64_elf_unhandled_reloc, /* special_function */
1780 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
b34976b6 1781 FALSE, /* partial_inplace */
d006db6c 1782 0, /* src_mask */
c061c2d8 1783 0xfffc, /* dst_mask */
b34976b6 1784 FALSE), /* pcrel_offset */
5bd4f169 1785
411e1bfb
AM		 1786 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1787 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1788 16, /* rightshift */
5bd4f169
AM		 1789 1, /* size (0 = byte, 1 = short, 2 = long) */
1790 16, /* bitsize */
b34976b6 1791 FALSE, /* pc_relative */
5bd4f169
AM		 1792 0, /* bitpos */
1793 complain_overflow_dont, /* complain_on_overflow */
411e1bfb
AM		 1794 ppc64_elf_unhandled_reloc, /* special_function */
1795 "R_PPC64_GOT_DTPREL16_HI", /* name */
b34976b6 1796 FALSE, /* partial_inplace */
d006db6c 1797 0, /* src_mask */
411e1bfb 1798 0xffff, /* dst_mask */
b34976b6 1799 FALSE), /* pcrel_offset */
5bd4f169 1800
411e1bfb
AM		 1801 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1802 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1803 16, /* rightshift */
1804 1, /* size (0 = byte, 1 = short, 2 = long) */
1805 16, /* bitsize */
1806 FALSE, /* pc_relative */
1807 0, /* bitpos */
1808 complain_overflow_dont, /* complain_on_overflow */
1809 ppc64_elf_unhandled_reloc, /* special_function */
1810 "R_PPC64_GOT_DTPREL16_HA", /* name */
1811 FALSE, /* partial_inplace */
1812 0, /* src_mask */
1813 0xffff, /* dst_mask */
1814 FALSE), /* pcrel_offset */
1815
1816 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1817 offset to the entry relative to the TOC base (r2). */
1818 HOWTO (R_PPC64_GOT_TPREL16_DS,
5bd4f169
AM		 1819 0, /* rightshift */
1820 1, /* size (0 = byte, 1 = short, 2 = long) */
1821 16, /* bitsize */
b34976b6 1822 FALSE, /* pc_relative */
5bd4f169
AM		 1823 0, /* bitpos */
1824 complain_overflow_signed, /* complain_on_overflow */
411e1bfb
AM		 1825 ppc64_elf_unhandled_reloc, /* special_function */
1826 "R_PPC64_GOT_TPREL16_DS", /* name */
b34976b6 1827 FALSE, /* partial_inplace */
d006db6c 1828 0, /* src_mask */
ad8e1ba5 1829 0xfffc, /* dst_mask */
b34976b6 1830 FALSE), /* pcrel_offset */
5bd4f169 1831
411e1bfb
AM		 1832 /* Like GOT_TPREL16_DS, but no overflow. */
1833 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
5bd4f169
AM		 1834 0, /* rightshift */
1835 1, /* size (0 = byte, 1 = short, 2 = long) */
1836 16, /* bitsize */
b34976b6 1837 FALSE, /* pc_relative */
5bd4f169
AM		 1838 0, /* bitpos */
1839 complain_overflow_dont, /* complain_on_overflow */
411e1bfb
AM		 1840 ppc64_elf_unhandled_reloc, /* special_function */
1841 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
b34976b6 1842 FALSE, /* partial_inplace */
d006db6c 1843 0, /* src_mask */
ad8e1ba5 1844 0xfffc, /* dst_mask */
b34976b6 1845 FALSE), /* pcrel_offset */
5bd4f169 1846
411e1bfb
AM		 1847 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1848 HOWTO (R_PPC64_GOT_TPREL16_HI,
1849 16, /* rightshift */
5bd4f169
AM		 1850 1, /* size (0 = byte, 1 = short, 2 = long) */
1851 16, /* bitsize */
b34976b6 1852 FALSE, /* pc_relative */
5bd4f169 1853 0, /* bitpos */
411e1bfb 1854 complain_overflow_dont, /* complain_on_overflow */
805fc799 1855 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1856 "R_PPC64_GOT_TPREL16_HI", /* name */
b34976b6 1857 FALSE, /* partial_inplace */
d006db6c 1858 0, /* src_mask */
411e1bfb 1859 0xffff, /* dst_mask */
b34976b6 1860 FALSE), /* pcrel_offset */
5bd4f169 1861
411e1bfb
AM		 1862 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1863 HOWTO (R_PPC64_GOT_TPREL16_HA,
1864 16, /* rightshift */
5bd4f169
AM		 1865 1, /* size (0 = byte, 1 = short, 2 = long) */
1866 16, /* bitsize */
b34976b6 1867 FALSE, /* pc_relative */
5bd4f169
AM		 1868 0, /* bitpos */
1869 complain_overflow_dont, /* complain_on_overflow */
805fc799 1870 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1871 "R_PPC64_GOT_TPREL16_HA", /* name */
b34976b6 1872 FALSE, /* partial_inplace */
d006db6c 1873 0, /* src_mask */
411e1bfb 1874 0xffff, /* dst_mask */
b34976b6 1875 FALSE), /* pcrel_offset */
5bd4f169 1876
e054468f
AM		 1877 HOWTO (R_PPC64_IRELATIVE, /* type */
1878 0, /* rightshift */
1879 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1880 64, /* bitsize */
1881 FALSE, /* pc_relative */
1882 0, /* bitpos */
1883 complain_overflow_dont, /* complain_on_overflow */
1884 bfd_elf_generic_reloc, /* special_function */
1885 "R_PPC64_IRELATIVE", /* name */
1886 FALSE, /* partial_inplace */
1887 0, /* src_mask */
1888 ONES (64), /* dst_mask */
1889 FALSE), /* pcrel_offset */
1890
5bd4f169
AM		 1891 /* GNU extension to record C++ vtable hierarchy. */
1892 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
1893 0, /* rightshift */
1894 0, /* size (0 = byte, 1 = short, 2 = long) */
1895 0, /* bitsize */
b34976b6 1896 FALSE, /* pc_relative */
5bd4f169
AM		 1897 0, /* bitpos */
1898 complain_overflow_dont, /* complain_on_overflow */
1899 NULL, /* special_function */
1900 "R_PPC64_GNU_VTINHERIT", /* name */
b34976b6 1901 FALSE, /* partial_inplace */
5bd4f169
AM		 1902 0, /* src_mask */
1903 0, /* dst_mask */
b34976b6 1904 FALSE), /* pcrel_offset */
5bd4f169
AM		 1905
1906 /* GNU extension to record C++ vtable member usage. */
1907 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
1908 0, /* rightshift */
1909 0, /* size (0 = byte, 1 = short, 2 = long) */
1910 0, /* bitsize */
b34976b6 1911 FALSE, /* pc_relative */
5bd4f169
AM		 1912 0, /* bitpos */
1913 complain_overflow_dont, /* complain_on_overflow */
1914 NULL, /* special_function */
1915 "R_PPC64_GNU_VTENTRY", /* name */
b34976b6 1916 FALSE, /* partial_inplace */
5bd4f169
AM		 1917 0, /* src_mask */
1918 0, /* dst_mask */
b34976b6 1919 FALSE), /* pcrel_offset */
5bd4f169
AM		 1920};
1921
1922\f
1923/* Initialize the ppc64_elf_howto_table, so that linear accesses can
1924 be done. */
1925
1926static void
4ce794b7 1927ppc_howto_init (void)
5bd4f169
AM		 1928{
1929 unsigned int i, type;
1930
1931 for (i = 0;
1932 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
1933 i++)
1934 {
1935 type = ppc64_elf_howto_raw[i].type;
1936 BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
1937 / sizeof (ppc64_elf_howto_table[0])));
1938 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
1939 }
1940}
1941
1942static reloc_howto_type *
4ce794b7
AM		 1943ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1944 bfd_reloc_code_real_type code)
5bd4f169 1945{
411e1bfb 1946 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
5bd4f169
AM		 1947
1948 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
1949 /* Initialize howto table if needed. */
1950 ppc_howto_init ();
1951
4ce794b7 1952 switch (code)
5bd4f169
AM		 1953 {
1954 default:
4ce794b7 1955 return NULL;
5bd4f169 1956
411e1bfb
AM		 1957 case BFD_RELOC_NONE: r = R_PPC64_NONE;
1958 break;
1959 case BFD_RELOC_32: r = R_PPC64_ADDR32;
1960 break;
1961 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
1962 break;
1963 case BFD_RELOC_16: r = R_PPC64_ADDR16;
1964 break;
1965 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
1966 break;
1967 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
1968 break;
1969 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
5bd4f169 1970 break;
411e1bfb 1971 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
5bd4f169 1972 break;
411e1bfb 1973 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
5bd4f169 1974 break;
411e1bfb 1975 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
5bd4f169 1976 break;
411e1bfb 1977 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
5bd4f169 1978 break;
411e1bfb 1979 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
5bd4f169 1980 break;
411e1bfb 1981 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
5bd4f169 1982 break;
411e1bfb 1983 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
5bd4f169 1984 break;
411e1bfb 1985 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
5bd4f169 1986 break;
411e1bfb 1987 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
5bd4f169 1988 break;
411e1bfb 1989 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
5bd4f169 1990 break;
411e1bfb 1991 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
5bd4f169 1992 break;
411e1bfb 1993 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
5bd4f169 1994 break;
411e1bfb 1995 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
5bd4f169 1996 break;
411e1bfb 1997 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
5bd4f169 1998 break;
411e1bfb 1999 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
5bd4f169 2000 break;
411e1bfb 2001 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
5bd4f169 2002 break;
411e1bfb 2003 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
5bd4f169 2004 break;
411e1bfb 2005 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
5bd4f169 2006 break;
411e1bfb 2007 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
5bd4f169 2008 break;
411e1bfb 2009 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
5bd4f169 2010 break;
411e1bfb 2011 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
5bd4f169 2012 break;
411e1bfb 2013 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
5bd4f169 2014 break;
411e1bfb 2015 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
5bd4f169 2016 break;
411e1bfb 2017 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
5bd4f169 2018 break;
411e1bfb 2019 case BFD_RELOC_64: r = R_PPC64_ADDR64;
5bd4f169 2020 break;
411e1bfb 2021 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
5bd4f169 2022 break;
411e1bfb 2023 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
5bd4f169 2024 break;
411e1bfb 2025 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
5bd4f169 2026 break;
411e1bfb 2027 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
5bd4f169 2028 break;
411e1bfb 2029 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
5bd4f169 2030 break;
411e1bfb 2031 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
5bd4f169 2032 break;
411e1bfb 2033 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
5bd4f169 2034 break;
411e1bfb 2035 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
5bd4f169 2036 break;
411e1bfb 2037 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
5bd4f169 2038 break;
411e1bfb 2039 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
5bd4f169 2040 break;
411e1bfb 2041 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
5bd4f169 2042 break;
411e1bfb 2043 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
5bd4f169 2044 break;
411e1bfb 2045 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
5bd4f169 2046 break;
411e1bfb 2047 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
5bd4f169 2048 break;
411e1bfb 2049 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
5bd4f169 2050 break;
411e1bfb 2051 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
5bd4f169 2052 break;
411e1bfb 2053 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
5bd4f169 2054 break;
411e1bfb 2055 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
5bd4f169 2056 break;
411e1bfb 2057 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
5bd4f169 2058 break;
411e1bfb 2059 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
5bd4f169 2060 break;
411e1bfb 2061 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
5bd4f169 2062 break;
411e1bfb 2063 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
5bd4f169 2064 break;
411e1bfb 2065 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
5bd4f169 2066 break;
411e1bfb 2067 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
5bd4f169 2068 break;
411e1bfb 2069 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
5bd4f169 2070 break;
411e1bfb 2071 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
5bd4f169 2072 break;
411e1bfb 2073 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
5bd4f169 2074 break;
411e1bfb 2075 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
5bd4f169 2076 break;
727fc41e
AM		 2077 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
2078 break;
2079 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
2080 break;
411e1bfb 2081 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
5bd4f169 2082 break;
411e1bfb 2083 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
5bd4f169 2084 break;
411e1bfb 2085 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
5bd4f169 2086 break;
411e1bfb 2087 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
5bd4f169 2088 break;
411e1bfb 2089 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
5bd4f169 2090 break;
411e1bfb 2091 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
5bd4f169 2092 break;
411e1bfb
AM		 2093 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2094 break;
2095 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2096 break;
2097 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2098 break;
2099 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2100 break;
2101 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2102 break;
2103 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2104 break;
2105 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2106 break;
2107 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2108 break;
2109 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2110 break;
2111 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2112 break;
2113 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2114 break;
2115 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2116 break;
2117 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2118 break;
2119 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2120 break;
2121 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2122 break;
2123 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2124 break;
2125 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2126 break;
2127 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2128 break;
2129 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2130 break;
2131 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2132 break;
2133 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2134 break;
2135 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2136 break;
2137 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2138 break;
2139 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2140 break;
2141 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2142 break;
2143 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2144 break;
2145 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2146 break;
2147 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2148 break;
2149 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2150 break;
2151 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2152 break;
2153 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2154 break;
2155 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2156 break;
2157 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2158 break;
2159 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2160 break;
2161 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
5bd4f169
AM		 2162 break;
2163 }
2164
4ce794b7 2165 return ppc64_elf_howto_table[r];
5bd4f169
AM		 2166};
2167
157090f7
AM		 2168static reloc_howto_type *
2169ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2170 const char *r_name)
2171{
2172 unsigned int i;
2173
2174 for (i = 0;
2175 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2176 i++)
2177 if (ppc64_elf_howto_raw[i].name != NULL
2178 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2179 return &ppc64_elf_howto_raw[i];
2180
2181 return NULL;
2182}
2183
5bd4f169
AM		 2184/* Set the howto pointer for a PowerPC ELF reloc. */
2185
2186static void
4ce794b7
AM		 2187ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2188 Elf_Internal_Rela *dst)
5bd4f169 2189{
65f38f15
AM		 2190 unsigned int type;
2191
ef60b7ff 2192 /* Initialize howto table if needed. */
5bd4f169 2193 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5bd4f169
AM		 2194 ppc_howto_init ();
2195
65f38f15 2196 type = ELF64_R_TYPE (dst->r_info);
d0fb9a8d
JJ		 2197 if (type >= (sizeof (ppc64_elf_howto_table)
2198 / sizeof (ppc64_elf_howto_table[0])))
2199 {
2200 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
3ec2b351
NC		 2201 abfd, (int) type);
2202 type = R_PPC64_NONE;
d0fb9a8d 2203 }
65f38f15 2204 cache_ptr->howto = ppc64_elf_howto_table[type];
5bd4f169
AM		 2205}
2206
04c9666a 2207/* Handle the R_PPC64_ADDR16_HA and similar relocs. */
5bd4f169
AM		 2208
2209static bfd_reloc_status_type
4ce794b7
AM		 2210ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2211 void *data, asection *input_section,
2212 bfd *output_bfd, char **error_message)
5bd4f169 2213{
805fc799
AM		 2214 /* If this is a relocatable link (output_bfd test tells us), just
2215 call the generic function. Any adjustment will be done at final
2216 link time. */
2217 if (output_bfd != NULL)
cedb70c5 2218 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2219 input_section, output_bfd, error_message);
2220
2221 /* Adjust the addend for sign extension of the low 16 bits.
2222 We won't actually be using the low 16 bits, so trashing them
2223 doesn't matter. */
2224 reloc_entry->addend += 0x8000;
2225 return bfd_reloc_continue;
2226}
5bd4f169 2227
2441e016
AM		 2228static bfd_reloc_status_type
2229ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2230 void *data, asection *input_section,
2231 bfd *output_bfd, char **error_message)
2232{
2233 if (output_bfd != NULL)
2234 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2235 input_section, output_bfd, error_message);
2236
699733f6
AM		 2237 if (strcmp (symbol->section->name, ".opd") == 0
2238 && (symbol->section->owner->flags & DYNAMIC) == 0)
2441e016
AM		 2239 {
2240 bfd_vma dest = opd_entry_value (symbol->section,
2241 symbol->value + reloc_entry->addend,
2242 NULL, NULL);
2243 if (dest != (bfd_vma) -1)
2244 reloc_entry->addend = dest - (symbol->value
2245 + symbol->section->output_section->vma
2246 + symbol->section->output_offset);
2247 }
2248 return bfd_reloc_continue;
2249}
2250
805fc799 2251static bfd_reloc_status_type
4ce794b7
AM		 2252ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2253 void *data, asection *input_section,
2254 bfd *output_bfd, char **error_message)
805fc799
AM		 2255{
2256 long insn;
04c9666a 2257 enum elf_ppc64_reloc_type r_type;
805fc799
AM		 2258 bfd_size_type octets;
2259 /* Disabled until we sort out how ld should choose 'y' vs 'at'. */
b34976b6 2260 bfd_boolean is_power4 = FALSE;
805fc799
AM		 2261
2262 /* If this is a relocatable link (output_bfd test tells us), just
2263 call the generic function. Any adjustment will be done at final
2264 link time. */
5bd4f169 2265 if (output_bfd != NULL)
cedb70c5 2266 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2267 input_section, output_bfd, error_message);
2268
2269 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2270 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2271 insn &= ~(0x01 << 21);
4ce794b7 2272 r_type = reloc_entry->howto->type;
805fc799
AM		 2273 if (r_type == R_PPC64_ADDR14_BRTAKEN
2274 || r_type == R_PPC64_REL14_BRTAKEN)
cedb70c5 2275 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
805fc799
AM		 2276
2277 if (is_power4)
5bd4f169 2278 {
805fc799
AM		 2279 /* Set 'a' bit. This is 0b00010 in BO field for branch
2280 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2281 for branch on CTR insns (BO == 1a00t or 1a01t). */
2282 if ((insn & (0x14 << 21)) == (0x04 << 21))
2283 insn |= 0x02 << 21;
2284 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2285 insn |= 0x08 << 21;
2286 else
2441e016 2287 goto out;
5bd4f169 2288 }
805fc799
AM		 2289 else
2290 {
2291 bfd_vma target = 0;
2292 bfd_vma from;
5bd4f169 2293
805fc799
AM		 2294 if (!bfd_is_com_section (symbol->section))
2295 target = symbol->value;
2296 target += symbol->section->output_section->vma;
2297 target += symbol->section->output_offset;
2298 target += reloc_entry->addend;
5bd4f169 2299
805fc799
AM		 2300 from = (reloc_entry->address
2301 + input_section->output_offset
2302 + input_section->output_section->vma);
5bd4f169 2303
805fc799
AM		 2304 /* Invert 'y' bit if not the default. */
2305 if ((bfd_signed_vma) (target - from) < 0)
2306 insn ^= 0x01 << 21;
2307 }
4ce794b7 2308 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2441e016
AM		 2309 out:
2310 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2311 input_section, output_bfd, error_message);
805fc799 2312}
5bd4f169 2313
805fc799 2314static bfd_reloc_status_type
4ce794b7
AM		 2315ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2316 void *data, asection *input_section,
2317 bfd *output_bfd, char **error_message)
805fc799
AM		 2318{
2319 /* If this is a relocatable link (output_bfd test tells us), just
2320 call the generic function. Any adjustment will be done at final
2321 link time. */
2322 if (output_bfd != NULL)
cedb70c5 2323 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799 2324 input_section, output_bfd, error_message);
5bd4f169 2325
805fc799
AM		 2326 /* Subtract the symbol section base address. */
2327 reloc_entry->addend -= symbol->section->output_section->vma;
5bd4f169
AM		 2328 return bfd_reloc_continue;
2329}
2330
805fc799 2331static bfd_reloc_status_type
4ce794b7
AM		 2332ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2333 void *data, asection *input_section,
2334 bfd *output_bfd, char **error_message)
805fc799
AM		 2335{
2336 /* If this is a relocatable link (output_bfd test tells us), just
2337 call the generic function. Any adjustment will be done at final
2338 link time. */
2339 if (output_bfd != NULL)
cedb70c5 2340 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2341 input_section, output_bfd, error_message);
2342
2343 /* Subtract the symbol section base address. */
2344 reloc_entry->addend -= symbol->section->output_section->vma;
2345
2346 /* Adjust the addend for sign extension of the low 16 bits. */
2347 reloc_entry->addend += 0x8000;
2348 return bfd_reloc_continue;
2349}
2350
2351static bfd_reloc_status_type
4ce794b7
AM		 2352ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2353 void *data, asection *input_section,
2354 bfd *output_bfd, char **error_message)
805fc799
AM		 2355{
2356 bfd_vma TOCstart;
2357
2358 /* If this is a relocatable link (output_bfd test tells us), just
2359 call the generic function. Any adjustment will be done at final
2360 link time. */
2361 if (output_bfd != NULL)
cedb70c5 2362 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2363 input_section, output_bfd, error_message);
2364
2365 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2366 if (TOCstart == 0)
2367 TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2368
2369 /* Subtract the TOC base address. */
2370 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2371 return bfd_reloc_continue;
2372}
2373
2374static bfd_reloc_status_type
4ce794b7
AM		 2375ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2376 void *data, asection *input_section,
2377 bfd *output_bfd, char **error_message)
805fc799
AM		 2378{
2379 bfd_vma TOCstart;
2380
2381 /* If this is a relocatable link (output_bfd test tells us), just
2382 call the generic function. Any adjustment will be done at final
2383 link time. */
2384 if (output_bfd != NULL)
cedb70c5 2385 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2386 input_section, output_bfd, error_message);
2387
2388 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2389 if (TOCstart == 0)
2390 TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2391
2392 /* Subtract the TOC base address. */
2393 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2394
2395 /* Adjust the addend for sign extension of the low 16 bits. */
2396 reloc_entry->addend += 0x8000;
2397 return bfd_reloc_continue;
2398}
2399
2400static bfd_reloc_status_type
4ce794b7
AM		 2401ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2402 void *data, asection *input_section,
2403 bfd *output_bfd, char **error_message)
805fc799
AM		 2404{
2405 bfd_vma TOCstart;
2406 bfd_size_type octets;
2407
2408 /* If this is a relocatable link (output_bfd test tells us), just
2409 call the generic function. Any adjustment will be done at final
2410 link time. */
2411 if (output_bfd != NULL)
cedb70c5 2412 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2413 input_section, output_bfd, error_message);
2414
2415 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2416 if (TOCstart == 0)
2417 TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2418
2419 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2420 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2421 return bfd_reloc_ok;
2422}
2423
2424static bfd_reloc_status_type
4ce794b7
AM		 2425ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2426 void *data, asection *input_section,
2427 bfd *output_bfd, char **error_message)
805fc799
AM		 2428{
2429 /* If this is a relocatable link (output_bfd test tells us), just
2430 call the generic function. Any adjustment will be done at final
2431 link time. */
2432 if (output_bfd != NULL)
cedb70c5 2433 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2434 input_section, output_bfd, error_message);
2435
2436 if (error_message != NULL)
2437 {
2438 static char buf[60];
2439 sprintf (buf, "generic linker can't handle %s",
2440 reloc_entry->howto->name);
2441 *error_message = buf;
2442 }
2443 return bfd_reloc_dangerous;
2444}
2445
e717da7e
AM		 2446struct ppc64_elf_obj_tdata
2447{
2448 struct elf_obj_tdata elf;
2449
2450 /* Shortcuts to dynamic linker sections. */
2451 asection *got;
2452 asection *relgot;
2453
b3fac117
AM		 2454 /* Used during garbage collection. We attach global symbols defined
2455 on removed .opd entries to this section so that the sym is removed. */
2456 asection *deleted_section;
81688140 2457
e717da7e
AM		 2458 /* TLS local dynamic got entry handling. Suppose for multiple GOT
2459 sections means we potentially need one of these for each input bfd. */
2460 union {
2461 bfd_signed_vma refcount;
2462 bfd_vma offset;
2463 } tlsld_got;
8860955f
AM		 2464
2465 /* A copy of relocs before they are modified for --emit-relocs. */
2466 Elf_Internal_Rela *opd_relocs;
e717da7e
AM		 2467};
2468
2469#define ppc64_elf_tdata(bfd) \
2470 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2471
2472#define ppc64_tlsld_got(bfd) \
2473 (&ppc64_elf_tdata (bfd)->tlsld_got)
2474
0c8d6e5c
AM		 2475#define is_ppc64_elf(bfd) \
2476 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2477 && elf_object_id (bfd) == PPC64_ELF_TDATA)
2478
e717da7e
AM		 2479/* Override the generic function because we store some extras. */
2480
2481static bfd_boolean
2482ppc64_elf_mkobject (bfd *abfd)
2483{
0ffa91dd
NC		 2484 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2485 PPC64_ELF_TDATA);
e717da7e
AM		 2486}
2487
feee612b
AM		 2488/* Fix bad default arch selected for a 64 bit input bfd when the
2489 default is 32 bit. */
2490
b34976b6 2491static bfd_boolean
4ce794b7 2492ppc64_elf_object_p (bfd *abfd)
feee612b
AM		 2493{
2494 if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2495 {
2496 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2497
2498 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2499 {
2500 /* Relies on arch after 32 bit default being 64 bit default. */
2501 abfd->arch_info = abfd->arch_info->next;
2502 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2503 }
2504 }
b34976b6 2505 return TRUE;
feee612b
AM		 2506}
2507
d37c89e5
AM		 2508/* Support for core dump NOTE sections. */
2509
2510static bfd_boolean
2511ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2512{
eea6121a 2513 size_t offset, size;
d37c89e5
AM		 2514
2515 if (note->descsz != 504)
2516 return FALSE;
2517
2518 /* pr_cursig */
2519 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
2520
2521 /* pr_pid */
2522 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 32);
2523
2524 /* pr_reg */
2525 offset = 112;
eea6121a 2526 size = 384;
d37c89e5
AM		 2527
2528 /* Make a ".reg/999" section. */
2529 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
eea6121a 2530 size, note->descpos + offset);
d37c89e5
AM		 2531}
2532
2533static bfd_boolean
2534ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2535{
2536 if (note->descsz != 136)
2537 return FALSE;
2538
2539 elf_tdata (abfd)->core_program
2540 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2541 elf_tdata (abfd)->core_command
2542 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2543
2544 return TRUE;
2545}
2546
183e98be
AM		 2547static char *
2548ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2549 ...)
2550{
2551 switch (note_type)
2552 {
2553 default:
2554 return NULL;
2555
2556 case NT_PRPSINFO:
2557 {
2558 char data[136];
2559 va_list ap;
2560
2561 va_start (ap, note_type);
2562 memset (data, 0, 40);
2563 strncpy (data + 40, va_arg (ap, const char *), 16);
2564 strncpy (data + 56, va_arg (ap, const char *), 80);
2565 va_end (ap);
2566 return elfcore_write_note (abfd, buf, bufsiz,
2567 "CORE", note_type, data, sizeof (data));
2568 }
2569
2570 case NT_PRSTATUS:
2571 {
2572 char data[504];
2573 va_list ap;
2574 long pid;
2575 int cursig;
2576 const void *greg;
2577
2578 va_start (ap, note_type);
2579 memset (data, 0, 112);
2580 pid = va_arg (ap, long);
2581 bfd_put_32 (abfd, pid, data + 32);
2582 cursig = va_arg (ap, int);
2583 bfd_put_16 (abfd, cursig, data + 12);
2584 greg = va_arg (ap, const void *);
2585 memcpy (data + 112, greg, 384);
2586 memset (data + 496, 0, 8);
2587 va_end (ap);
2588 return elfcore_write_note (abfd, buf, bufsiz,
2589 "CORE", note_type, data, sizeof (data));
2590 }
2591 }
2592}
2593
5bd4f169
AM		 2594/* Merge backend specific data from an object file to the output
2595 object file when linking. */
2f6d9989 2596
b34976b6 2597static bfd_boolean
4ce794b7 2598ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5bd4f169 2599{
5bd4f169
AM		 2600 /* Check if we have the same endianess. */
2601 if (ibfd->xvec->byteorder != obfd->xvec->byteorder
87e226ce 2602 && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
5bd4f169
AM		 2603 && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
2604 {
2605 const char *msg;
2606
2607 if (bfd_big_endian (ibfd))
d003868e 2608 msg = _("%B: compiled for a big endian system "
4ce794b7 2609 "and target is little endian");
5bd4f169 2610 else
d003868e 2611 msg = _("%B: compiled for a little endian system "
4ce794b7 2612 "and target is big endian");
5bd4f169 2613
d003868e 2614 (*_bfd_error_handler) (msg, ibfd);
5bd4f169
AM		 2615
2616 bfd_set_error (bfd_error_wrong_format);
b34976b6 2617 return FALSE;
5bd4f169
AM		 2618 }
2619
b34976b6 2620 return TRUE;
5bd4f169 2621}
f0abc2a1 2622
5d35169e
AM		 2623/* Add extra PPC sections. */
2624
b35d266b 2625static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
7f4d3958 2626{
0112cd26
NC		 2627 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
2628 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2629 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2630 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2631 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2632 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2633 { NULL, 0, 0, 0, 0 }
5d35169e
AM		 2634};
2635
7c8fe5c4
AM		 2636enum _ppc64_sec_type {
2637 sec_normal = 0,
2638 sec_opd = 1,
2639 sec_toc = 2
2640};
2641
f0abc2a1
AM		 2642struct _ppc64_elf_section_data
2643{
2644 struct bfd_elf_section_data elf;
411e1bfb 2645
f0abc2a1
AM		 2646 union
2647 {
74f0fb50
AM		 2648 /* An array with one entry for each opd function descriptor. */
2649 struct _opd_sec_data
2650 {
2651 /* Points to the function code section for local opd entries. */
2652 asection **func_sec;
2653
2654 /* After editing .opd, adjust references to opd local syms. */
2655 long *adjust;
2656 } opd;
7c8fe5c4 2657
3a71aa26
AM		 2658 /* An array for toc sections, indexed by offset/8. */
2659 struct _toc_sec_data
2660 {
2661 /* Specifies the relocation symbol index used at a given toc offset. */
2662 unsigned *symndx;
2663
2664 /* And the relocation addend. */
2665 bfd_vma *add;
2666 } toc;
7c8fe5c4
AM		 2667 } u;
2668
2669 enum _ppc64_sec_type sec_type:2;
411e1bfb 2670
7c8fe5c4
AM		 2671 /* Flag set when small branches are detected. Used to
2672 select suitable defaults for the stub group size. */
2673 unsigned int has_14bit_branch:1;
f0abc2a1
AM		 2674};
2675
2676#define ppc64_elf_section_data(sec) \
411e1bfb 2677 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
f0abc2a1
AM		 2678
2679static bfd_boolean
4ce794b7 2680ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
f0abc2a1 2681{
f592407e
AM		 2682 if (!sec->used_by_bfd)
2683 {
2684 struct _ppc64_elf_section_data *sdata;
2685 bfd_size_type amt = sizeof (*sdata);
f0abc2a1 2686
f592407e
AM		 2687 sdata = bfd_zalloc (abfd, amt);
2688 if (sdata == NULL)
2689 return FALSE;
2690 sec->used_by_bfd = sdata;
2691 }
f0abc2a1
AM		 2692
2693 return _bfd_elf_new_section_hook (abfd, sec);
2694}
4025353c 2695
74f0fb50 2696static struct _opd_sec_data *
4025353c
AM		 2697get_opd_info (asection * sec)
2698{
2699 if (sec != NULL
2700 && ppc64_elf_section_data (sec) != NULL
7c8fe5c4 2701 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
74f0fb50 2702 return &ppc64_elf_section_data (sec)->u.opd;
4025353c
AM		 2703 return NULL;
2704}
90e3cdf2
JJ		 2705\f
2706/* Parameters for the qsort hook. */
90e3cdf2
JJ		 2707static bfd_boolean synthetic_relocatable;
2708
699733f6 2709/* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
90e3cdf2
JJ		 2710
2711static int
2712compare_symbols (const void *ap, const void *bp)
2713{
2714 const asymbol *a = * (const asymbol **) ap;
2715 const asymbol *b = * (const asymbol **) bp;
2716
699733f6
AM		 2717 /* Section symbols first. */
2718 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
90e3cdf2 2719 return -1;
699733f6 2720 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
90e3cdf2
JJ		 2721 return 1;
2722
699733f6 2723 /* then .opd symbols. */
ffcfec52
AM		 2724 if (strcmp (a->section->name, ".opd") == 0
2725 && strcmp (b->section->name, ".opd") != 0)
90e3cdf2 2726 return -1;
ffcfec52
AM		 2727 if (strcmp (a->section->name, ".opd") != 0
2728 && strcmp (b->section->name, ".opd") == 0)
90e3cdf2
JJ		 2729 return 1;
2730
699733f6 2731 /* then other code symbols. */
90e3cdf2
JJ		 2732 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2733 == (SEC_CODE | SEC_ALLOC)
2734 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2735 != (SEC_CODE | SEC_ALLOC))
2736 return -1;
2737
2738 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2739 != (SEC_CODE | SEC_ALLOC)
2740 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2741 == (SEC_CODE | SEC_ALLOC))
2742 return 1;
2743
2744 if (synthetic_relocatable)
2745 {
2746 if (a->section->id < b->section->id)
2747 return -1;
2748
2749 if (a->section->id > b->section->id)
2750 return 1;
2751 }
2752
2753 if (a->value + a->section->vma < b->value + b->section->vma)
2754 return -1;
2755
2756 if (a->value + a->section->vma > b->value + b->section->vma)
2757 return 1;
2758
4d35a0aa
AM		 2759 /* For syms with the same value, prefer strong dynamic global function
2760 syms over other syms. */
2761 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
2762 return -1;
2763
2764 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
2765 return 1;
2766
2767 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
2768 return -1;
2769
2770 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
2771 return 1;
2772
2773 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
2774 return -1;
2775
2776 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
2777 return 1;
2778
2779 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
2780 return -1;
2781
2782 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
2783 return 1;
2784
90e3cdf2
JJ		 2785 return 0;
2786}
2787
699733f6 2788/* Search SYMS for a symbol of the given VALUE. */
90e3cdf2 2789
699733f6
AM		 2790static asymbol *
2791sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
90e3cdf2 2792{
699733f6 2793 long mid;
90e3cdf2 2794
699733f6
AM		 2795 if (id == -1)
2796 {
2797 while (lo < hi)
2798 {
2799 mid = (lo + hi) >> 1;
2800 if (syms[mid]->value + syms[mid]->section->vma < value)
2801 lo = mid + 1;
2802 else if (syms[mid]->value + syms[mid]->section->vma > value)
2803 hi = mid;
2804 else
2805 return syms[mid];
2806 }
2807 }
2808 else
2809 {
2810 while (lo < hi)
2811 {
2812 mid = (lo + hi) >> 1;
2813 if (syms[mid]->section->id < id)
2814 lo = mid + 1;
2815 else if (syms[mid]->section->id > id)
2816 hi = mid;
2817 else if (syms[mid]->value < value)
2818 lo = mid + 1;
2819 else if (syms[mid]->value > value)
2820 hi = mid;
2821 else
2822 return syms[mid];
2823 }
2824 }
2825 return NULL;
90e3cdf2
JJ		 2826}
2827
468392fb
AM		 2828static bfd_boolean
2829section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
2830{
2831 bfd_vma vma = *(bfd_vma *) ptr;
2832 return ((section->flags & SEC_ALLOC) != 0
2833 && section->vma <= vma
2834 && vma < section->vma + section->size);
2835}
2836
699733f6 2837/* Create synthetic symbols, effectively restoring "dot-symbol" function
468392fb 2838 entry syms. Also generate @plt symbols for the glink branch table. */
90e3cdf2
JJ		 2839
2840static long
a7535cf3
AM		 2841ppc64_elf_get_synthetic_symtab (bfd *abfd,
2842 long static_count, asymbol **static_syms,
2843 long dyn_count, asymbol **dyn_syms,
c9727e01 2844 asymbol **ret)
90e3cdf2
JJ		 2845{
2846 asymbol *s;
699733f6
AM		 2847 long i;
2848 long count;
90e3cdf2 2849 char *names;
a7535cf3 2850 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
699733f6 2851 asection *opd;
90e3cdf2 2852 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
a7535cf3 2853 asymbol **syms;
90e3cdf2
JJ		 2854
2855 *ret = NULL;
2856
2857 opd = bfd_get_section_by_name (abfd, ".opd");
2858 if (opd == NULL)
2859 return 0;
2860
a7535cf3 2861 symcount = static_count;
c9727e01 2862 if (!relocatable)
a7535cf3 2863 symcount += dyn_count;
90e3cdf2 2864 if (symcount == 0)
c9727e01 2865 return 0;
90e3cdf2 2866
a7535cf3
AM		 2867 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
2868 if (syms == NULL)
7356fed5 2869 return -1;
a7535cf3
AM		 2870
2871 if (!relocatable && static_count != 0 && dyn_count != 0)
2872 {
2873 /* Use both symbol tables. */
2874 memcpy (syms, static_syms, static_count * sizeof (*syms));
2875 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
2876 }
2877 else if (!relocatable && static_count == 0)
2878 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
2879 else
2880 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
2881
90e3cdf2 2882 synthetic_relocatable = relocatable;
595da8c5 2883 qsort (syms, symcount, sizeof (*syms), compare_symbols);
90e3cdf2 2884
c9727e01
AM		 2885 if (!relocatable && symcount > 1)
2886 {
2887 long j;
2888 /* Trim duplicate syms, since we may have merged the normal and
2889 dynamic symbols. Actually, we only care about syms that have
3b36f7e6 2890 different values, so trim any with the same value. */
c9727e01
AM		 2891 for (i = 1, j = 1; i < symcount; ++i)
2892 if (syms[i - 1]->value + syms[i - 1]->section->vma
2893 != syms[i]->value + syms[i]->section->vma)
2894 syms[j++] = syms[i];
2895 symcount = j;
2896 }
2897
699733f6 2898 i = 0;
ffcfec52 2899 if (strcmp (syms[i]->section->name, ".opd") == 0)
699733f6
AM		 2900 ++i;
2901 codesecsym = i;
90e3cdf2 2902
699733f6
AM		 2903 for (; i < symcount; ++i)
2904 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2905 != (SEC_CODE | SEC_ALLOC))
2906 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
2907 break;
2908 codesecsymend = i;
90e3cdf2 2909
699733f6
AM		 2910 for (; i < symcount; ++i)
2911 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
2912 break;
2913 secsymend = i;
90e3cdf2 2914
699733f6 2915 for (; i < symcount; ++i)
ffcfec52 2916 if (strcmp (syms[i]->section->name, ".opd") != 0)
699733f6
AM		 2917 break;
2918 opdsymend = i;
90e3cdf2 2919
699733f6
AM		 2920 for (; i < symcount; ++i)
2921 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2922 != (SEC_CODE | SEC_ALLOC))
2923 break;
2924 symcount = i;
2925
c9727e01 2926 count = 0;
90e3cdf2 2927
699733f6 2928 if (relocatable)
90e3cdf2 2929 {
699733f6
AM		 2930 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
2931 arelent *r;
2932 size_t size;
2933 long relcount;
90e3cdf2 2934
468392fb
AM		 2935 if (opdsymend == secsymend)
2936 goto done;
2937
699733f6 2938 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
90e3cdf2 2939 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
7356fed5 2940 if (relcount == 0)
c9727e01 2941 goto done;
90e3cdf2 2942
7356fed5
AM		 2943 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
2944 {
2945 count = -1;
2946 goto done;
2947 }
2948
699733f6 2949 size = 0;
595da8c5 2950 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
699733f6
AM		 2951 {
2952 asymbol *sym;
90e3cdf2 2953
595da8c5 2954 while (r < opd->relocation + relcount
699733f6
AM		 2955 && r->address < syms[i]->value + opd->vma)
2956 ++r;
90e3cdf2 2957
595da8c5 2958 if (r == opd->relocation + relcount)
699733f6 2959 break;
90e3cdf2 2960
699733f6
AM		 2961 if (r->address != syms[i]->value + opd->vma)
2962 continue;
90e3cdf2 2963
699733f6
AM		 2964 if (r->howto->type != R_PPC64_ADDR64)
2965 continue;
90e3cdf2 2966
699733f6
AM		 2967 sym = *r->sym_ptr_ptr;
2968 if (!sym_exists_at (syms, opdsymend, symcount,
2969 sym->section->id, sym->value + r->addend))
2970 {
2971 ++count;
2972 size += sizeof (asymbol);
2973 size += strlen (syms[i]->name) + 2;
2974 }
2975 }
90e3cdf2 2976
699733f6
AM		 2977 s = *ret = bfd_malloc (size);
2978 if (s == NULL)
2979 {
7356fed5 2980 count = -1;
c9727e01 2981 goto done;
699733f6 2982 }
90e3cdf2 2983
699733f6 2984 names = (char *) (s + count);
90e3cdf2 2985
595da8c5 2986 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
90e3cdf2 2987 {
699733f6 2988 asymbol *sym;
90e3cdf2 2989
595da8c5 2990 while (r < opd->relocation + relcount
699733f6
AM		 2991 && r->address < syms[i]->value + opd->vma)
2992 ++r;
90e3cdf2 2993
595da8c5 2994 if (r == opd->relocation + relcount)
699733f6
AM		 2995 break;
2996
2997 if (r->address != syms[i]->value + opd->vma)
2998 continue;
2999
3000 if (r->howto->type != R_PPC64_ADDR64)
3001 continue;
90e3cdf2 3002
699733f6
AM		 3003 sym = *r->sym_ptr_ptr;
3004 if (!sym_exists_at (syms, opdsymend, symcount,
3005 sym->section->id, sym->value + r->addend))
3006 {
3007 size_t len;
3008
3009 *s = *syms[i];
6ba2a415 3010 s->flags |= BSF_SYNTHETIC;
699733f6
AM		 3011 s->section = sym->section;
3012 s->value = sym->value + r->addend;
3013 s->name = names;
3014 *names++ = '.';
3015 len = strlen (syms[i]->name);
3016 memcpy (names, syms[i]->name, len + 1);
3017 names += len + 1;
6f610d07
UW		 3018 /* Have udata.p point back to the original symbol this
3019 synthetic symbol was derived from. */
3020 s->udata.p = syms[i];
699733f6
AM		 3021 s++;
3022 }
3023 }
3024 }
3025 else
90e3cdf2 3026 {
468392fb 3027 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
699733f6
AM		 3028 bfd_byte *contents;
3029 size_t size;
468392fb
AM		 3030 long plt_count = 0;
3031 bfd_vma glink_vma = 0, resolv_vma = 0;
3032 asection *dynamic, *glink = NULL, *relplt = NULL;
3033 arelent *p;
90e3cdf2 3034
699733f6
AM		 3035 if (!bfd_malloc_and_get_section (abfd, opd, &contents))
3036 {
3037 if (contents)
c9727e01
AM		 3038 {
3039 free_contents_and_exit:
3040 free (contents);
3041 }
7356fed5 3042 count = -1;
c9727e01 3043 goto done;
699733f6 3044 }
90e3cdf2 3045
699733f6
AM		 3046 size = 0;
3047 for (i = secsymend; i < opdsymend; ++i)
3048 {
3049 bfd_vma ent;
90e3cdf2 3050
5ef11c02
AM		 3051 /* Ignore bogus symbols. */
3052 if (syms[i]->value > opd->size - 8)
3053 continue;
3054
699733f6
AM		 3055 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3056 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3057 {
3058 ++count;
3059 size += sizeof (asymbol);
3060 size += strlen (syms[i]->name) + 2;
3061 }
3062 }
90e3cdf2 3063
468392fb 3064 /* Get start of .glink stubs from DT_PPC64_GLINK. */
066ee829
AM		 3065 if (dyn_count != 0
3066 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
468392fb
AM		 3067 {
3068 bfd_byte *dynbuf, *extdyn, *extdynend;
3069 size_t extdynsize;
3070 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3071
3072 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3073 goto free_contents_and_exit;
3074
3075 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3076 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3077
3078 extdyn = dynbuf;
3079 extdynend = extdyn + dynamic->size;
3080 for (; extdyn < extdynend; extdyn += extdynsize)
3081 {
3082 Elf_Internal_Dyn dyn;
3083 (*swap_dyn_in) (abfd, extdyn, &dyn);
3084
3085 if (dyn.d_tag == DT_NULL)
3086 break;
3087
3088 if (dyn.d_tag == DT_PPC64_GLINK)
3089 {
3090 /* The first glink stub starts at offset 32; see comment in
3091 ppc64_elf_finish_dynamic_sections. */
3092 glink_vma = dyn.d_un.d_val + 32;
3093 /* The .glink section usually does not survive the final
3094 link; search for the section (usually .text) where the
3095 glink stubs now reside. */
3096 glink = bfd_sections_find_if (abfd, section_covers_vma,
3097 &glink_vma);
3098 break;
3099 }
3100 }
3101
3102 free (dynbuf);
3103 }
3104
3105 if (glink != NULL)
3106 {
3107 /* Determine __glink trampoline by reading the relative branch
3108 from the first glink stub. */
3109 bfd_byte buf[4];
3110 if (bfd_get_section_contents (abfd, glink, buf,
3111 glink_vma + 4 - glink->vma, 4))
3112 {
3113 unsigned int insn = bfd_get_32 (abfd, buf);
3114 insn ^= B_DOT;
3115 if ((insn & ~0x3fffffc) == 0)
3116 resolv_vma = glink_vma + 4 + (insn ^ 0x2000000) - 0x2000000;
3117 }
3118
3119 if (resolv_vma)
3120 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
468392fb 3121
066ee829
AM		 3122 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3123 if (relplt != NULL)
3124 {
3125 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3126 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3127 goto free_contents_and_exit;
468392fb 3128
066ee829
AM		 3129 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3130 size += plt_count * sizeof (asymbol);
468392fb 3131
066ee829
AM		 3132 p = relplt->relocation;
3133 for (i = 0; i < plt_count; i++, p++)
e054468f
AM		 3134 {
3135 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3136 if (p->addend != 0)
3137 size += sizeof ("+0x") - 1 + 16;
3138 }
066ee829 3139 }
468392fb
AM		 3140 }
3141
699733f6
AM		 3142 s = *ret = bfd_malloc (size);
3143 if (s == NULL)
7356fed5 3144 goto free_contents_and_exit;
90e3cdf2 3145
468392fb 3146 names = (char *) (s + count + plt_count + (resolv_vma != 0));
90e3cdf2 3147
699733f6 3148 for (i = secsymend; i < opdsymend; ++i)
90e3cdf2 3149 {
699733f6 3150 bfd_vma ent;
90e3cdf2 3151
5ef11c02
AM		 3152 if (syms[i]->value > opd->size - 8)
3153 continue;
3154
699733f6
AM		 3155 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3156 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
90e3cdf2 3157 {
c9727e01 3158 long lo, hi;
699733f6 3159 size_t len;
c9727e01 3160 asection *sec = abfd->sections;
90e3cdf2 3161
699733f6
AM		 3162 *s = *syms[i];
3163 lo = codesecsym;
3164 hi = codesecsymend;
3165 while (lo < hi)
3166 {
c9727e01 3167 long mid = (lo + hi) >> 1;
699733f6
AM		 3168 if (syms[mid]->section->vma < ent)
3169 lo = mid + 1;
3170 else if (syms[mid]->section->vma > ent)
3171 hi = mid;
3172 else
c9727e01
AM		 3173 {
3174 sec = syms[mid]->section;
3175 break;
3176 }
699733f6
AM		 3177 }
3178
c9727e01 3179 if (lo >= hi && lo > codesecsym)
699733f6 3180 sec = syms[lo - 1]->section;
699733f6
AM		 3181
3182 for (; sec != NULL; sec = sec->next)
3183 {
3184 if (sec->vma > ent)
3185 break;
3186 if ((sec->flags & SEC_ALLOC) == 0
3187 || (sec->flags & SEC_LOAD) == 0)
3188 break;
3189 if ((sec->flags & SEC_CODE) != 0)
3190 s->section = sec;
3191 }
6ba2a415 3192 s->flags |= BSF_SYNTHETIC;
699733f6
AM		 3193 s->value = ent - s->section->vma;
3194 s->name = names;
3195 *names++ = '.';
3196 len = strlen (syms[i]->name);
3197 memcpy (names, syms[i]->name, len + 1);
3198 names += len + 1;
6f610d07
UW		 3199 /* Have udata.p point back to the original symbol this
3200 synthetic symbol was derived from. */
3201 s->udata.p = syms[i];
699733f6 3202 s++;
90e3cdf2 3203 }
90e3cdf2 3204 }
699733f6 3205 free (contents);
468392fb
AM		 3206
3207 if (glink != NULL && relplt != NULL)
3208 {
3209 if (resolv_vma)
3210 {
3211 /* Add a symbol for the main glink trampoline. */
86a4952b 3212 memset (s, 0, sizeof *s);
468392fb 3213 s->the_bfd = abfd;
6ba2a415 3214 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
468392fb
AM		 3215 s->section = glink;
3216 s->value = resolv_vma - glink->vma;
3217 s->name = names;
3218 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3219 names += sizeof ("__glink_PLTresolve");
3220 s++;
3221 count++;
3222 }
3223
3224 /* FIXME: It would be very much nicer to put sym@plt on the
3225 stub rather than on the glink branch table entry. The
3226 objdump disassembler would then use a sensible symbol
3227 name on plt calls. The difficulty in doing so is
3228 a) finding the stubs, and,
3229 b) matching stubs against plt entries, and,
3230 c) there can be multiple stubs for a given plt entry.
3231
3232 Solving (a) could be done by code scanning, but older
3233 ppc64 binaries used different stubs to current code.
3234 (b) is the tricky one since you need to known the toc
3235 pointer for at least one function that uses a pic stub to
3236 be able to calculate the plt address referenced.
3237 (c) means gdb would need to set multiple breakpoints (or
3238 find the glink branch itself) when setting breakpoints
3239 for pending shared library loads. */
3240 p = relplt->relocation;
3241 for (i = 0; i < plt_count; i++, p++)
3242 {
3243 size_t len;
3244
3245 *s = **p->sym_ptr_ptr;
3246 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3247 we are defining a symbol, ensure one of them is set. */
3248 if ((s->flags & BSF_LOCAL) == 0)
3249 s->flags |= BSF_GLOBAL;
6ba2a415 3250 s->flags |= BSF_SYNTHETIC;
468392fb
AM		 3251 s->section = glink;
3252 s->value = glink_vma - glink->vma;
3253 s->name = names;
3254 s->udata.p = NULL;
3255 len = strlen ((*p->sym_ptr_ptr)->name);
3256 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3257 names += len;
e054468f
AM		 3258 if (p->addend != 0)
3259 {
3260 memcpy (names, "+0x", sizeof ("+0x") - 1);
3261 names += sizeof ("+0x") - 1;
3262 bfd_sprintf_vma (abfd, names, p->addend);
3263 names += strlen (names);
3264 }
468392fb
AM		 3265 memcpy (names, "@plt", sizeof ("@plt"));
3266 names += sizeof ("@plt");
3267 s++;
3268 glink_vma += 8;
3269 if (i >= 0x8000)
3270 glink_vma += 4;
3271 }
3272 count += plt_count;
3273 }
90e3cdf2
JJ		 3274 }
3275
c9727e01 3276 done:
a7535cf3 3277 free (syms);
90e3cdf2
JJ		 3278 return count;
3279}
5bd4f169 3280\f
65f38f15
AM		 3281/* The following functions are specific to the ELF linker, while
3282 functions above are used generally. Those named ppc64_elf_* are
3283 called by the main ELF linker code. They appear in this file more
3284 or less in the order in which they are called. eg.
3285 ppc64_elf_check_relocs is called early in the link process,
3286 ppc64_elf_finish_dynamic_sections is one of the last functions
e86ce104
AM		 3287 called.
3288
3289 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3290 functions have both a function code symbol and a function descriptor
3291 symbol. A call to foo in a relocatable object file looks like:
3292
3293 . .text
3294 . x:
3295 . bl .foo
3296 . nop
3297
3298 The function definition in another object file might be:
3299
3300 . .section .opd
3301 . foo: .quad .foo
3302 . .quad .TOC.@tocbase
3303 . .quad 0
3304 .
3305 . .text
3306 . .foo: blr
3307
3308 When the linker resolves the call during a static link, the branch
3309 unsurprisingly just goes to .foo and the .opd information is unused.
3310 If the function definition is in a shared library, things are a little
3311 different: The call goes via a plt call stub, the opd information gets
3312 copied to the plt, and the linker patches the nop.
3313
3314 . x:
3315 . bl .foo_stub
3316 . ld 2,40(1)
3317 .
3318 .
3319 . .foo_stub:
3320 . addis 12,2,Lfoo@toc@ha # in practice, the call stub
411e1bfb 3321 . addi 12,12,Lfoo@toc@l # is slightly optimized, but
e86ce104
AM		 3322 . std 2,40(1) # this is the general idea
3323 . ld 11,0(12)
3324 . ld 2,8(12)
3325 . mtctr 11
3326 . ld 11,16(12)
3327 . bctr
3328 .
3329 . .section .plt
3330 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3331
3332 The "reloc ()" notation is supposed to indicate that the linker emits
3333 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3334 copying.
3335
3336 What are the difficulties here? Well, firstly, the relocations
3337 examined by the linker in check_relocs are against the function code
3338 sym .foo, while the dynamic relocation in the plt is emitted against
3339 the function descriptor symbol, foo. Somewhere along the line, we need
3340 to carefully copy dynamic link information from one symbol to the other.
3341 Secondly, the generic part of the elf linker will make .foo a dynamic
3342 symbol as is normal for most other backends. We need foo dynamic
3343 instead, at least for an application final link. However, when
3344 creating a shared library containing foo, we need to have both symbols
3345 dynamic so that references to .foo are satisfied during the early
3346 stages of linking. Otherwise the linker might decide to pull in a
8387904d
AM		 3347 definition from some other object, eg. a static library.
3348
3349 Update: As of August 2004, we support a new convention. Function
3350 calls may use the function descriptor symbol, ie. "bl foo". This
3351 behaves exactly as "bl .foo". */
65f38f15
AM		 3352
3353/* The linker needs to keep track of the number of relocs that it
3354 decides to copy as dynamic relocs in check_relocs for each symbol.
3355 This is so that it can later discard them if they are found to be
3356 unnecessary. We store the information in a field extending the
3357 regular ELF linker hash table. */
3358
3359struct ppc_dyn_relocs
3360{
3361 struct ppc_dyn_relocs *next;
3362
3363 /* The input section of the reloc. */
3364 asection *sec;
3365
3366 /* Total number of relocs copied for the input section. */
3367 bfd_size_type count;
3368
3369 /* Number of pc-relative relocs copied for the input section. */
3370 bfd_size_type pc_count;
3371};
3372
411e1bfb
AM		 3373/* Track GOT entries needed for a given symbol. We might need more
3374 than one got entry per symbol. */
3375struct got_entry
3376{
3377 struct got_entry *next;
3378
e7b938ca 3379 /* The symbol addend that we'll be placing in the GOT. */
411e1bfb
AM		 3380 bfd_vma addend;
3381
e717da7e
AM		 3382 /* Unlike other ELF targets, we use separate GOT entries for the same
3383 symbol referenced from different input files. This is to support
3384 automatic multiple TOC/GOT sections, where the TOC base can vary
102890f0
AM		 3385 from one input file to another. FIXME: After group_sections we
3386 ought to merge entries within the group.
e717da7e
AM		 3387
3388 Point to the BFD owning this GOT entry. */
3389 bfd *owner;
3390
3391 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
3392 TLS_TPREL or TLS_DTPREL for tls entries. */
3393 char tls_type;
3394
e7b938ca 3395 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
411e1bfb
AM		 3396 union
3397 {
3398 bfd_signed_vma refcount;
3399 bfd_vma offset;
3400 } got;
411e1bfb
AM		 3401};
3402
3403/* The same for PLT. */
3404struct plt_entry
3405{
3406 struct plt_entry *next;
3407
3408 bfd_vma addend;
3409
3410 union
3411 {
3412 bfd_signed_vma refcount;
3413 bfd_vma offset;
3414 } plt;
3415};
3416
1d483afe 3417/* Of those relocs that might be copied as dynamic relocs, this function
58ac9f71
AM		 3418 selects those that must be copied when linking a shared library,
3419 even when the symbol is local. */
65f38f15 3420
1d483afe
AM		 3421static int
3422must_be_dyn_reloc (struct bfd_link_info *info,
3423 enum elf_ppc64_reloc_type r_type)
3424{
3425 switch (r_type)
3426 {
3427 default:
3428 return 1;
3429
3430 case R_PPC64_REL32:
3431 case R_PPC64_REL64:
3432 case R_PPC64_REL30:
3433 return 0;
3434
3435 case R_PPC64_TPREL16:
3436 case R_PPC64_TPREL16_LO:
3437 case R_PPC64_TPREL16_HI:
3438 case R_PPC64_TPREL16_HA:
3439 case R_PPC64_TPREL16_DS:
3440 case R_PPC64_TPREL16_LO_DS:
3441 case R_PPC64_TPREL16_HIGHER:
3442 case R_PPC64_TPREL16_HIGHERA:
3443 case R_PPC64_TPREL16_HIGHEST:
3444 case R_PPC64_TPREL16_HIGHESTA:
3445 case R_PPC64_TPREL64:
3446 return !info->executable;
3447 }
3448}
65f38f15 3449
f4656909
AM		 3450/* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3451 copying dynamic variables from a shared lib into an app's dynbss
3452 section, and instead use a dynamic relocation to point into the
5d35169e
AM		 3453 shared lib. With code that gcc generates, it's vital that this be
3454 enabled; In the PowerPC64 ABI, the address of a function is actually
3455 the address of a function descriptor, which resides in the .opd
3456 section. gcc uses the descriptor directly rather than going via the
3457 GOT as some other ABI's do, which means that initialized function
3458 pointers must reference the descriptor. Thus, a function pointer
3459 initialized to the address of a function in a shared library will
3460 either require a copy reloc, or a dynamic reloc. Using a copy reloc
4cc11e76 3461 redefines the function descriptor symbol to point to the copy. This
5d35169e
AM		 3462 presents a problem as a plt entry for that function is also
3463 initialized from the function descriptor symbol and the copy reloc
3464 may not be initialized first. */
a23b6845 3465#define ELIMINATE_COPY_RELOCS 1
f4656909 3466
721956f4
AM		 3467/* Section name for stubs is the associated section name plus this
3468 string. */
3469#define STUB_SUFFIX ".stub"
3470
3471/* Linker stubs.
3472 ppc_stub_long_branch:
3473 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3474 destination, but a 24 bit branch in a stub section will reach.
3475 . b dest
3476
3477 ppc_stub_plt_branch:
3478 Similar to the above, but a 24 bit branch in the stub section won't
3479 reach its destination.
87e226ce
AM		 3480 . addis %r12,%r2,xxx@toc@ha
3481 . ld %r11,xxx@toc@l(%r12)
721956f4
AM		 3482 . mtctr %r11
3483 . bctr
3484
3485 ppc_stub_plt_call:
2c66dc6c
AM		 3486 Used to call a function in a shared library. If it so happens that
3487 the plt entry referenced crosses a 64k boundary, then an extra
ac2df442 3488 "addi %r12,%r12,xxx@toc@l" will be inserted before the "mtctr".
87e226ce 3489 . addis %r12,%r2,xxx@toc@ha
721956f4 3490 . std %r2,40(%r1)
87e226ce 3491 . ld %r11,xxx+0@toc@l(%r12)
721956f4 3492 . mtctr %r11
ac2df442 3493 . ld %r2,xxx+8@toc@l(%r12)
87e226ce 3494 . ld %r11,xxx+16@toc@l(%r12)
721956f4 3495 . bctr
ad8e1ba5
AM		 3496
3497 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3498 code to adjust the value and save r2 to support multiple toc sections.
3499 A ppc_stub_long_branch with an r2 offset looks like:
3500 . std %r2,40(%r1)
3501 . addis %r2,%r2,off@ha
3502 . addi %r2,%r2,off@l
3503 . b dest
3504
3505 A ppc_stub_plt_branch with an r2 offset looks like:
3506 . std %r2,40(%r1)
3507 . addis %r12,%r2,xxx@toc@ha
3508 . ld %r11,xxx@toc@l(%r12)
3509 . addis %r2,%r2,off@ha
3510 . addi %r2,%r2,off@l
3511 . mtctr %r11
3512 . bctr
ac2df442
AM		 3513
3514 In cases where the "addis" instruction would add zero, the "addis" is
3515 omitted and following instructions modified slightly in some cases.
721956f4
AM		 3516*/
3517
3518enum ppc_stub_type {
3519 ppc_stub_none,
3520 ppc_stub_long_branch,
ad8e1ba5 3521 ppc_stub_long_branch_r2off,
721956f4 3522 ppc_stub_plt_branch,
ad8e1ba5 3523 ppc_stub_plt_branch_r2off,
721956f4
AM		 3524 ppc_stub_plt_call
3525};
3526
3527struct ppc_stub_hash_entry {
3528
3529 /* Base hash table entry structure. */
3530 struct bfd_hash_entry root;
3531
ad8e1ba5
AM		 3532 enum ppc_stub_type stub_type;
3533
721956f4
AM		 3534 /* The stub section. */
3535 asection *stub_sec;
3536
3537 /* Offset within stub_sec of the beginning of this stub. */
3538 bfd_vma stub_offset;
3539
3540 /* Given the symbol's value and its section we can determine its final
3541 value when building the stubs (so the stub knows where to jump. */
3542 bfd_vma target_value;
3543 asection *target_section;
3544
721956f4
AM		 3545 /* The symbol table entry, if any, that this was derived from. */
3546 struct ppc_link_hash_entry *h;
e054468f 3547 struct plt_entry *plt_ent;
721956f4 3548
411e1bfb
AM		 3549 /* And the reloc addend that this was derived from. */
3550 bfd_vma addend;
3551
721956f4
AM		 3552 /* Where this stub is being called from, or, in the case of combined
3553 stub sections, the first input section in the group. */
3554 asection *id_sec;
3555};
3556
3557struct ppc_branch_hash_entry {
3558
3559 /* Base hash table entry structure. */
3560 struct bfd_hash_entry root;
3561
c456f082 3562 /* Offset within branch lookup table. */
721956f4
AM		 3563 unsigned int offset;
3564
3565 /* Generation marker. */
3566 unsigned int iter;
3567};
65f38f15
AM		 3568
3569struct ppc_link_hash_entry
3570{
3571 struct elf_link_hash_entry elf;
3572
b3fac117
AM		 3573 union {
3574 /* A pointer to the most recently used stub hash entry against this
3575 symbol. */
3576 struct ppc_stub_hash_entry *stub_cache;
3577
3578 /* A pointer to the next symbol starting with a '.' */
3579 struct ppc_link_hash_entry *next_dot_sym;
3580 } u;
721956f4 3581
65f38f15
AM		 3582 /* Track dynamic relocs copied for this symbol. */
3583 struct ppc_dyn_relocs *dyn_relocs;
e86ce104 3584
721956f4 3585 /* Link between function code and descriptor symbols. */
34814b9f 3586 struct ppc_link_hash_entry *oh;
721956f4 3587
e86ce104
AM		 3588 /* Flag function code and descriptor symbols. */
3589 unsigned int is_func:1;
3590 unsigned int is_func_descriptor:1;
908b32fc 3591 unsigned int fake:1;
411e1bfb 3592
c5614fa4
AM		 3593 /* Whether global opd/toc sym has been adjusted or not.
3594 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3595 should be set for all globals defined in any opd/toc section. */
754021d0
AM		 3596 unsigned int adjust_done:1;
3597
99877b66
AM		 3598 /* Set if we twiddled this symbol to weak at some stage. */
3599 unsigned int was_undefined:1;
3600
411e1bfb 3601 /* Contexts in which symbol is used in the GOT (or TOC).
e7b938ca
AM		 3602 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3603 corresponding relocs are encountered during check_relocs.
3604 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3605 indicate the corresponding GOT entry type is not needed.
3606 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3607 a TPREL one. We use a separate flag rather than setting TPREL
3608 just for convenience in distinguishing the two cases. */
3609#define TLS_GD 1 /* GD reloc. */
3610#define TLS_LD 2 /* LD reloc. */
3611#define TLS_TPREL 4 /* TPREL reloc, => IE. */
3612#define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
3613#define TLS_TLS 16 /* Any TLS reloc. */
3614#define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
3615#define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
e054468f 3616#define PLT_IFUNC 128 /* STT_GNU_IFUNC. */
e7b938ca 3617 char tls_mask;
65f38f15
AM		 3618};
3619
3620/* ppc64 ELF linker hash table. */
3621
3622struct ppc_link_hash_table
3623{
3624 struct elf_link_hash_table elf;
3625
721956f4
AM		 3626 /* The stub hash table. */
3627 struct bfd_hash_table stub_hash_table;
3628
3629 /* Another hash table for plt_branch stubs. */
3630 struct bfd_hash_table branch_hash_table;
3631
3632 /* Linker stub bfd. */
3633 bfd *stub_bfd;
3634
3635 /* Linker call-backs. */
4ce794b7
AM		 3636 asection * (*add_stub_section) (const char *, asection *);
3637 void (*layout_sections_again) (void);
721956f4
AM		 3638
3639 /* Array to keep track of which stub sections have been created, and
3640 information on stub grouping. */
3641 struct map_stub {
3642 /* This is the section to which stubs in the group will be attached. */
3643 asection *link_sec;
3644 /* The stub section. */
3645 asection *stub_sec;
ad8e1ba5
AM		 3646 /* Along with elf_gp, specifies the TOC pointer used in this group. */
3647 bfd_vma toc_off;
721956f4
AM		 3648 } *stub_group;
3649
ad8e1ba5
AM		 3650 /* Temp used when calculating TOC pointers. */
3651 bfd_vma toc_curr;
3652
8f3bab57
AM		 3653 /* Highest input section id. */
3654 int top_id;
3655
734b6cf9
AM		 3656 /* Highest output section index. */
3657 int top_index;
3658
b3fac117
AM		 3659 /* Used when adding symbols. */
3660 struct ppc_link_hash_entry *dot_syms;
3661
734b6cf9
AM		 3662 /* List of input sections for each output section. */
3663 asection **input_list;
721956f4 3664
65f38f15 3665 /* Short-cuts to get to dynamic linker sections. */
4ce794b7 3666 asection *got;
4ce794b7
AM		 3667 asection *plt;
3668 asection *relplt;
e054468f
AM		 3669 asection *iplt;
3670 asection *reliplt;
4ce794b7
AM		 3671 asection *dynbss;
3672 asection *relbss;
3673 asection *glink;
82bd7b59 3674 asection *sfpr;
4ce794b7
AM		 3675 asection *brlt;
3676 asection *relbrlt;
ec338859 3677
8387904d
AM		 3678 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
3679 struct ppc_link_hash_entry *tls_get_addr;
3680 struct ppc_link_hash_entry *tls_get_addr_fd;
411e1bfb 3681
9b5ecbd0
AM		 3682 /* Statistics. */
3683 unsigned long stub_count[ppc_stub_plt_call];
3684
ee75fd95
AM		 3685 /* Number of stubs against global syms. */
3686 unsigned long stub_globals;
3687
ad8e1ba5 3688 /* Set if we should emit symbols for stubs. */
99877b66 3689 unsigned int emit_stub_syms:1;
ad8e1ba5 3690
4c52953f
AM		 3691 /* Support for multiple toc sections. */
3692 unsigned int no_multi_toc:1;
3693 unsigned int multi_toc_needed:1;
3694
5d1634d7 3695 /* Set on error. */
99877b66 3696 unsigned int stub_error:1;
721956f4 3697
7d9616d7 3698 /* Temp used by ppc64_elf_process_dot_syms. */
99877b66 3699 unsigned int twiddled_syms:1;
721956f4
AM		 3700
3701 /* Incremented every time we size stubs. */
3702 unsigned int stub_iteration;
5d1634d7 3703
87d72d41
AM		 3704 /* Small local sym cache. */
3705 struct sym_cache sym_cache;
65f38f15
AM		 3706};
3707
4c52953f
AM		 3708/* Rename some of the generic section flags to better document how they
3709 are used here. */
3710#define has_toc_reloc has_gp_reloc
3711#define makes_toc_func_call need_finalize_relax
3712#define call_check_in_progress reloc_done
3713
65f38f15
AM		 3714/* Get the ppc64 ELF linker hash table from a link_info structure. */
3715
3716#define ppc_hash_table(p) \
3717 ((struct ppc_link_hash_table *) ((p)->hash))
3718
721956f4
AM		 3719#define ppc_stub_hash_lookup(table, string, create, copy) \
3720 ((struct ppc_stub_hash_entry *) \
3721 bfd_hash_lookup ((table), (string), (create), (copy)))
3722
3723#define ppc_branch_hash_lookup(table, string, create, copy) \
3724 ((struct ppc_branch_hash_entry *) \
3725 bfd_hash_lookup ((table), (string), (create), (copy)))
3726
3727/* Create an entry in the stub hash table. */
3728
3729static struct bfd_hash_entry *
4ce794b7
AM		 3730stub_hash_newfunc (struct bfd_hash_entry *entry,
3731 struct bfd_hash_table *table,
3732 const char *string)
721956f4
AM		 3733{
3734 /* Allocate the structure if it has not already been allocated by a
3735 subclass. */
3736 if (entry == NULL)
3737 {
3738 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
3739 if (entry == NULL)
3740 return entry;
3741 }
3742
3743 /* Call the allocation method of the superclass. */
3744 entry = bfd_hash_newfunc (entry, table, string);
3745 if (entry != NULL)
3746 {
3747 struct ppc_stub_hash_entry *eh;
3748
3749 /* Initialize the local fields. */
3750 eh = (struct ppc_stub_hash_entry *) entry;
ad8e1ba5 3751 eh->stub_type = ppc_stub_none;
721956f4
AM		 3752 eh->stub_sec = NULL;
3753 eh->stub_offset = 0;
3754 eh->target_value = 0;
3755 eh->target_section = NULL;
721956f4
AM		 3756 eh->h = NULL;
3757 eh->id_sec = NULL;
3758 }
3759
3760 return entry;
3761}
3762
3763/* Create an entry in the branch hash table. */
3764
3765static struct bfd_hash_entry *
4ce794b7
AM		 3766branch_hash_newfunc (struct bfd_hash_entry *entry,
3767 struct bfd_hash_table *table,
3768 const char *string)
721956f4
AM		 3769{
3770 /* Allocate the structure if it has not already been allocated by a
3771 subclass. */
3772 if (entry == NULL)
3773 {
3774 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
3775 if (entry == NULL)
3776 return entry;
3777 }
3778
3779 /* Call the allocation method of the superclass. */
3780 entry = bfd_hash_newfunc (entry, table, string);
3781 if (entry != NULL)
3782 {
3783 struct ppc_branch_hash_entry *eh;
3784
3785 /* Initialize the local fields. */
3786 eh = (struct ppc_branch_hash_entry *) entry;
3787 eh->offset = 0;
3788 eh->iter = 0;
3789 }
3790
3791 return entry;
3792}
3793
65f38f15
AM		 3794/* Create an entry in a ppc64 ELF linker hash table. */
3795
3796static struct bfd_hash_entry *
4ce794b7
AM		 3797link_hash_newfunc (struct bfd_hash_entry *entry,
3798 struct bfd_hash_table *table,
3799 const char *string)
65f38f15
AM		 3800{
3801 /* Allocate the structure if it has not already been allocated by a
3802 subclass. */
3803 if (entry == NULL)
3804 {
3805 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
3806 if (entry == NULL)
3807 return entry;
3808 }
3809
3810 /* Call the allocation method of the superclass. */
3811 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
3812 if (entry != NULL)
3813 {
3814 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
3815
b3fac117 3816 memset (&eh->u.stub_cache, 0,
908b32fc 3817 (sizeof (struct ppc_link_hash_entry)
b3fac117
AM		 3818 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
3819
3820 /* When making function calls, old ABI code references function entry
3821 points (dot symbols), while new ABI code references the function
3822 descriptor symbol. We need to make any combination of reference and
3823 definition work together, without breaking archive linking.
3824
3825 For a defined function "foo" and an undefined call to "bar":
3826 An old object defines "foo" and ".foo", references ".bar" (possibly
3827 "bar" too).
3828 A new object defines "foo" and references "bar".
3829
3830 A new object thus has no problem with its undefined symbols being
3831 satisfied by definitions in an old object. On the other hand, the
3832 old object won't have ".bar" satisfied by a new object.
3833
3834 Keep a list of newly added dot-symbols. */
3835
3836 if (string[0] == '.')
3837 {
3838 struct ppc_link_hash_table *htab;
3839
3840 htab = (struct ppc_link_hash_table *) table;
3841 eh->u.next_dot_sym = htab->dot_syms;
3842 htab->dot_syms = eh;
3843 }
65f38f15
AM		 3844 }
3845
3846 return entry;
3847}
3848
3849/* Create a ppc64 ELF linker hash table. */
3850
3851static struct bfd_link_hash_table *
4ce794b7 3852ppc64_elf_link_hash_table_create (bfd *abfd)
65f38f15
AM		 3853{
3854 struct ppc_link_hash_table *htab;
3855 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
3856
4ce794b7 3857 htab = bfd_zmalloc (amt);
65f38f15
AM		 3858 if (htab == NULL)
3859 return NULL;
3860
66eb6687
AM		 3861 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
3862 sizeof (struct ppc_link_hash_entry)))
65f38f15 3863 {
e2d34d7d 3864 free (htab);
65f38f15
AM		 3865 return NULL;
3866 }
3867
721956f4 3868 /* Init the stub hash table too. */
66eb6687
AM		 3869 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
3870 sizeof (struct ppc_stub_hash_entry)))
721956f4
AM		 3871 return NULL;
3872
3873 /* And the branch hash table. */
66eb6687
AM		 3874 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
3875 sizeof (struct ppc_branch_hash_entry)))
721956f4
AM		 3876 return NULL;
3877
3254fd24
AM		 3878 /* Initializing two fields of the union is just cosmetic. We really
3879 only care about glist, but when compiled on a 32-bit host the
3880 bfd_vma fields are larger. Setting the bfd_vma to zero makes
3881 debugger inspection of these fields look nicer. */
a6aa5195
AM		 3882 htab->elf.init_got_refcount.refcount = 0;
3883 htab->elf.init_got_refcount.glist = NULL;
3884 htab->elf.init_plt_refcount.refcount = 0;
3885 htab->elf.init_plt_refcount.glist = NULL;
3886 htab->elf.init_got_offset.offset = 0;
3887 htab->elf.init_got_offset.glist = NULL;
3888 htab->elf.init_plt_offset.offset = 0;
3889 htab->elf.init_plt_offset.glist = NULL;
3254fd24 3890
65f38f15
AM		 3891 return &htab->elf.root;
3892}
3893
721956f4
AM		 3894/* Free the derived linker hash table. */
3895
3896static void
4ce794b7 3897ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
721956f4
AM		 3898{
3899 struct ppc_link_hash_table *ret = (struct ppc_link_hash_table *) hash;
3900
3901 bfd_hash_table_free (&ret->stub_hash_table);
3902 bfd_hash_table_free (&ret->branch_hash_table);
3903 _bfd_generic_link_hash_table_free (hash);
3904}
3905
e717da7e
AM		 3906/* Satisfy the ELF linker by filling in some fields in our fake bfd. */
3907
3908void
3909ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
3910{
3911 struct ppc_link_hash_table *htab;
3912
3913 elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
3914
3915/* Always hook our dynamic sections into the first bfd, which is the
3916 linker created stub bfd. This ensures that the GOT header is at
3917 the start of the output TOC section. */
3918 htab = ppc_hash_table (info);
3919 htab->stub_bfd = abfd;
3920 htab->elf.dynobj = abfd;
3921}
3922
721956f4
AM		 3923/* Build a name for an entry in the stub hash table. */
3924
3925static char *
4ce794b7
AM		 3926ppc_stub_name (const asection *input_section,
3927 const asection *sym_sec,
3928 const struct ppc_link_hash_entry *h,
3929 const Elf_Internal_Rela *rel)
721956f4
AM		 3930{
3931 char *stub_name;
3932 bfd_size_type len;
3933
3934 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
3935 offsets from a sym as a branch target? In fact, we could
3936 probably assume the addend is always zero. */
3937 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
3938
3939 if (h)
3940 {
3941 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
3942 stub_name = bfd_malloc (len);
46de2a7c
AM		 3943 if (stub_name == NULL)
3944 return stub_name;
3945
3946 sprintf (stub_name, "%08x.%s+%x",
3947 input_section->id & 0xffffffff,
3948 h->elf.root.root.string,
3949 (int) rel->r_addend & 0xffffffff);
721956f4
AM		 3950 }
3951 else
3952 {
ad8e1ba5 3953 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
721956f4 3954 stub_name = bfd_malloc (len);
46de2a7c
AM		 3955 if (stub_name == NULL)
3956 return stub_name;
3957
3958 sprintf (stub_name, "%08x.%x:%x+%x",
3959 input_section->id & 0xffffffff,
3960 sym_sec->id & 0xffffffff,
3961 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
3962 (int) rel->r_addend & 0xffffffff);
721956f4 3963 }
ee75fd95
AM		 3964 if (stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
3965 stub_name[len - 2] = 0;
721956f4
AM		 3966 return stub_name;
3967}
3968
3969/* Look up an entry in the stub hash. Stub entries are cached because
3970 creating the stub name takes a bit of time. */
3971
3972static struct ppc_stub_hash_entry *
4ce794b7
AM		 3973ppc_get_stub_entry (const asection *input_section,
3974 const asection *sym_sec,
039b3fef 3975 struct ppc_link_hash_entry *h,
4ce794b7
AM		 3976 const Elf_Internal_Rela *rel,
3977 struct ppc_link_hash_table *htab)
721956f4
AM		 3978{
3979 struct ppc_stub_hash_entry *stub_entry;
721956f4
AM		 3980 const asection *id_sec;
3981
3982 /* If this input section is part of a group of sections sharing one
3983 stub section, then use the id of the first section in the group.
3984 Stub names need to include a section id, as there may well be
3985 more than one stub used to reach say, printf, and we need to
3986 distinguish between them. */
3987 id_sec = htab->stub_group[input_section->id].link_sec;
3988
b3fac117
AM		 3989 if (h != NULL && h->u.stub_cache != NULL
3990 && h->u.stub_cache->h == h
3991 && h->u.stub_cache->id_sec == id_sec)
721956f4 3992 {
b3fac117 3993 stub_entry = h->u.stub_cache;
721956f4
AM		 3994 }
3995 else
3996 {
3997 char *stub_name;
3998
3999 stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4000 if (stub_name == NULL)
4001 return NULL;
4002
4003 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
b34976b6 4004 stub_name, FALSE, FALSE);
721956f4 4005 if (h != NULL)
b3fac117 4006 h->u.stub_cache = stub_entry;
721956f4
AM		 4007
4008 free (stub_name);
4009 }
4010
4011 return stub_entry;
4012}
4013
4014/* Add a new stub entry to the stub hash. Not all fields of the new
4015 stub entry are initialised. */
4016
4017static struct ppc_stub_hash_entry *
4ce794b7
AM		 4018ppc_add_stub (const char *stub_name,
4019 asection *section,
4020 struct ppc_link_hash_table *htab)
721956f4
AM		 4021{
4022 asection *link_sec;
4023 asection *stub_sec;
4024 struct ppc_stub_hash_entry *stub_entry;
4025
4026 link_sec = htab->stub_group[section->id].link_sec;
4027 stub_sec = htab->stub_group[section->id].stub_sec;
4028 if (stub_sec == NULL)
4029 {
4030 stub_sec = htab->stub_group[link_sec->id].stub_sec;
4031 if (stub_sec == NULL)
4032 {
d4c88bbb 4033 size_t namelen;
721956f4
AM		 4034 bfd_size_type len;
4035 char *s_name;
4036
d4c88bbb
AM		 4037 namelen = strlen (link_sec->name);
4038 len = namelen + sizeof (STUB_SUFFIX);
721956f4
AM		 4039 s_name = bfd_alloc (htab->stub_bfd, len);
4040 if (s_name == NULL)
4041 return NULL;
4042
d4c88bbb
AM		 4043 memcpy (s_name, link_sec->name, namelen);
4044 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
721956f4
AM		 4045 stub_sec = (*htab->add_stub_section) (s_name, link_sec);
4046 if (stub_sec == NULL)
4047 return NULL;
4048 htab->stub_group[link_sec->id].stub_sec = stub_sec;
4049 }
4050 htab->stub_group[section->id].stub_sec = stub_sec;
4051 }
4052
4053 /* Enter this entry into the linker stub hash table. */
4054 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
b34976b6 4055 TRUE, FALSE);
721956f4
AM		 4056 if (stub_entry == NULL)
4057 {
d003868e
AM		 4058 (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
4059 section->owner, stub_name);
721956f4
AM		 4060 return NULL;
4061 }
4062
4063 stub_entry->stub_sec = stub_sec;
4064 stub_entry->stub_offset = 0;
4065 stub_entry->id_sec = link_sec;
4066 return stub_entry;
4067}
4068
82bd7b59
AM		 4069/* Create sections for linker generated code. */
4070
b34976b6 4071static bfd_boolean
4ce794b7 4072create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
82bd7b59
AM		 4073{
4074 struct ppc_link_hash_table *htab;
4075 flagword flags;
4076
4077 htab = ppc_hash_table (info);
4078
4079 /* Create .sfpr for code to save and restore fp regs. */
4080 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4081 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3496cb2a
L		 4082 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4083 flags);
82bd7b59 4084 if (htab->sfpr == NULL
82bd7b59 4085 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
b34976b6 4086 return FALSE;
82bd7b59 4087
721956f4 4088 /* Create .glink for lazy dynamic linking support. */
3496cb2a
L		 4089 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4090 flags);
4ce794b7 4091 if (htab->glink == NULL
ee4bf8d2 4092 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
b34976b6 4093 return FALSE;
82bd7b59 4094
e054468f
AM		 4095 flags = SEC_ALLOC | SEC_LINKER_CREATED;
4096 htab->iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4097 if (htab->iplt == NULL
4098 || ! bfd_set_section_alignment (dynobj, htab->iplt, 3))
4099 return FALSE;
4100
4101 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4102 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4103 htab->reliplt = bfd_make_section_anyway_with_flags (dynobj,
4104 ".rela.iplt",
4105 flags);
4106 if (htab->reliplt == NULL
4107 || ! bfd_set_section_alignment (dynobj, htab->reliplt, 3))
4108 return FALSE;
4109
c456f082 4110 /* Create branch lookup table for plt_branch stubs. */
e4e0193e
AM		 4111 flags = (SEC_ALLOC | SEC_LOAD
4112 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4113 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4114 flags);
4ce794b7 4115 if (htab->brlt == NULL
4ce794b7 4116 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
b34976b6 4117 return FALSE;
721956f4 4118
e4e0193e 4119 if (!info->shared)
c456f082
AM		 4120 return TRUE;
4121
e4e0193e
AM		 4122 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4123 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4124 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4125 ".rela.branch_lt",
4126 flags);
e054468f 4127 if (htab->relbrlt == NULL
c456f082
AM		 4128 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4129 return FALSE;
4130
b34976b6 4131 return TRUE;
82bd7b59
AM		 4132}
4133
e717da7e
AM		 4134/* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4135 not already done. */
65f38f15 4136
b34976b6 4137static bfd_boolean
e717da7e 4138create_got_section (bfd *abfd, struct bfd_link_info *info)
65f38f15 4139{
e717da7e
AM		 4140 asection *got, *relgot;
4141 flagword flags;
4142 struct ppc_link_hash_table *htab = ppc_hash_table (info);
65f38f15 4143
0c8d6e5c 4144 if (!is_ppc64_elf (abfd))
0ffa91dd
NC		 4145 return FALSE;
4146
4ce794b7 4147 if (!htab->got)
e717da7e
AM		 4148 {
4149 if (! _bfd_elf_create_got_section (htab->elf.dynobj, info))
4150 return FALSE;
4151
4152 htab->got = bfd_get_section_by_name (htab->elf.dynobj, ".got");
4153 if (!htab->got)
4154 abort ();
4155 }
4156
4157 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4158 | SEC_LINKER_CREATED);
4159
c456f082 4160 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
e717da7e 4161 if (!got
e717da7e
AM		 4162 || !bfd_set_section_alignment (abfd, got, 3))
4163 return FALSE;
65f38f15 4164
c456f082
AM		 4165 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4166 flags | SEC_READONLY);
e717da7e 4167 if (!relgot
e717da7e 4168 || ! bfd_set_section_alignment (abfd, relgot, 3))
b34976b6 4169 return FALSE;
e717da7e
AM		 4170
4171 ppc64_elf_tdata (abfd)->got = got;
4172 ppc64_elf_tdata (abfd)->relgot = relgot;
b34976b6 4173 return TRUE;
65f38f15 4174}
5bd4f169 4175
82bd7b59 4176/* Create the dynamic sections, and set up shortcuts. */
5bd4f169 4177
b34976b6 4178static bfd_boolean
4ce794b7 4179ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
5bd4f169 4180{
65f38f15 4181 struct ppc_link_hash_table *htab;
5bd4f169 4182
65f38f15 4183 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
b34976b6 4184 return FALSE;
65f38f15 4185
e717da7e
AM		 4186 htab = ppc_hash_table (info);
4187 if (!htab->got)
4188 htab->got = bfd_get_section_by_name (dynobj, ".got");
4ce794b7
AM		 4189 htab->plt = bfd_get_section_by_name (dynobj, ".plt");
4190 htab->relplt = bfd_get_section_by_name (dynobj, ".rela.plt");
4191 htab->dynbss = bfd_get_section_by_name (dynobj, ".dynbss");
65f38f15 4192 if (!info->shared)
4ce794b7 4193 htab->relbss = bfd_get_section_by_name (dynobj, ".rela.bss");
65f38f15 4194
e717da7e 4195 if (!htab->got || !htab->plt || !htab->relplt || !htab->dynbss
4ce794b7 4196 || (!info->shared && !htab->relbss))
65f38f15
AM		 4197 abort ();
4198
b34976b6 4199 return TRUE;
5bd4f169
AM		 4200}
4201
40d16e0b
AM		 4202/* Merge PLT info on FROM with that on TO. */
4203
4204static void
4205move_plt_plist (struct ppc_link_hash_entry *from,
4206 struct ppc_link_hash_entry *to)
4207{
4208 if (from->elf.plt.plist != NULL)
4209 {
4210 if (to->elf.plt.plist != NULL)
4211 {
4212 struct plt_entry **entp;
4213 struct plt_entry *ent;
4214
4215 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4216 {
4217 struct plt_entry *dent;
4218
4219 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4220 if (dent->addend == ent->addend)
4221 {
4222 dent->plt.refcount += ent->plt.refcount;
4223 *entp = ent->next;
4224 break;
4225 }
4226 if (dent == NULL)
4227 entp = &ent->next;
4228 }
4229 *entp = to->elf.plt.plist;
4230 }
4231
4232 to->elf.plt.plist = from->elf.plt.plist;
4233 from->elf.plt.plist = NULL;
4234 }
4235}
4236
65f38f15
AM		 4237/* Copy the extra info we tack onto an elf_link_hash_entry. */
4238
4239static void
fcfa13d2
AM		 4240ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4241 struct elf_link_hash_entry *dir,
4242 struct elf_link_hash_entry *ind)
65f38f15
AM		 4243{
4244 struct ppc_link_hash_entry *edir, *eind;
4245
4246 edir = (struct ppc_link_hash_entry *) dir;
4247 eind = (struct ppc_link_hash_entry *) ind;
4248
411e1bfb 4249 /* Copy over any dynamic relocs we may have on the indirect sym. */
bbd7ec4a 4250 if (eind->dyn_relocs != NULL)
65f38f15 4251 {
bbd7ec4a
AM		 4252 if (edir->dyn_relocs != NULL)
4253 {
4254 struct ppc_dyn_relocs **pp;
4255 struct ppc_dyn_relocs *p;
4256
fcfa13d2 4257 /* Add reloc counts against the indirect sym to the direct sym
bbd7ec4a
AM		 4258 list. Merge any entries against the same section. */
4259 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4260 {
4261 struct ppc_dyn_relocs *q;
4262
4263 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4264 if (q->sec == p->sec)
4265 {
4266 q->pc_count += p->pc_count;
4267 q->count += p->count;
4268 *pp = p->next;
4269 break;
4270 }
4271 if (q == NULL)
4272 pp = &p->next;
4273 }
4274 *pp = edir->dyn_relocs;
4275 }
4276
65f38f15
AM		 4277 edir->dyn_relocs = eind->dyn_relocs;
4278 eind->dyn_relocs = NULL;
4279 }
65f38f15 4280
6349e628
AM		 4281 edir->is_func |= eind->is_func;
4282 edir->is_func_descriptor |= eind->is_func_descriptor;
58ac9f71 4283 edir->tls_mask |= eind->tls_mask;
6349e628 4284
81848ca0 4285 /* If called to transfer flags for a weakdef during processing
f5385ebf 4286 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
81848ca0 4287 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
f5385ebf
AM		 4288 if (!(ELIMINATE_COPY_RELOCS
4289 && eind->elf.root.type != bfd_link_hash_indirect
4290 && edir->elf.dynamic_adjusted))
4291 edir->elf.non_got_ref |= eind->elf.non_got_ref;
81848ca0 4292
f5385ebf
AM		 4293 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4294 edir->elf.ref_regular |= eind->elf.ref_regular;
4295 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4296 edir->elf.needs_plt |= eind->elf.needs_plt;
6349e628
AM		 4297
4298 /* If we were called to copy over info for a weak sym, that's all. */
4299 if (eind->elf.root.type != bfd_link_hash_indirect)
4300 return;
4301
81848ca0
AM		 4302 /* Copy over got entries that we may have already seen to the
4303 symbol which just became indirect. */
411e1bfb
AM		 4304 if (eind->elf.got.glist != NULL)
4305 {
4306 if (edir->elf.got.glist != NULL)
4307 {
4308 struct got_entry **entp;
4309 struct got_entry *ent;
4310
4311 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4312 {
4313 struct got_entry *dent;
4314
4315 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4316 if (dent->addend == ent->addend
e717da7e 4317 && dent->owner == ent->owner
411e1bfb
AM		 4318 && dent->tls_type == ent->tls_type)
4319 {
4320 dent->got.refcount += ent->got.refcount;
4321 *entp = ent->next;
4322 break;
4323 }
4324 if (dent == NULL)
4325 entp = &ent->next;
4326 }
4327 *entp = edir->elf.got.glist;
4328 }
4329
4330 edir->elf.got.glist = eind->elf.got.glist;
4331 eind->elf.got.glist = NULL;
4332 }
4333
4334 /* And plt entries. */
40d16e0b 4335 move_plt_plist (eind, edir);
411e1bfb 4336
fcfa13d2 4337 if (eind->elf.dynindx != -1)
411e1bfb 4338 {
fcfa13d2
AM		 4339 if (edir->elf.dynindx != -1)
4340 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4341 edir->elf.dynstr_index);
411e1bfb
AM		 4342 edir->elf.dynindx = eind->elf.dynindx;
4343 edir->elf.dynstr_index = eind->elf.dynstr_index;
4344 eind->elf.dynindx = -1;
4345 eind->elf.dynstr_index = 0;
4346 }
411e1bfb
AM		 4347}
4348
8387904d
AM		 4349/* Find the function descriptor hash entry from the given function code
4350 hash entry FH. Link the entries via their OH fields. */
4351
4352static struct ppc_link_hash_entry *
4353get_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4354{
4355 struct ppc_link_hash_entry *fdh = fh->oh;
4356
4357 if (fdh == NULL)
4358 {
4359 const char *fd_name = fh->elf.root.root.string + 1;
4360
4361 fdh = (struct ppc_link_hash_entry *)
4362 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4363 if (fdh != NULL)
4364 {
4365 fdh->is_func_descriptor = 1;
4366 fdh->oh = fh;
4367 fh->is_func = 1;
4368 fh->oh = fdh;
4369 }
4370 }
4371
4372 return fdh;
4373}
4374
bb700d78
AM		 4375/* Make a fake function descriptor sym for the code sym FH. */
4376
4377static struct ppc_link_hash_entry *
4378make_fdh (struct bfd_link_info *info,
908b32fc 4379 struct ppc_link_hash_entry *fh)
bb700d78
AM		 4380{
4381 bfd *abfd;
4382 asymbol *newsym;
4383 struct bfd_link_hash_entry *bh;
4384 struct ppc_link_hash_entry *fdh;
4385
4386 abfd = fh->elf.root.u.undef.abfd;
4387 newsym = bfd_make_empty_symbol (abfd);
4388 newsym->name = fh->elf.root.root.string + 1;
4389 newsym->section = bfd_und_section_ptr;
4390 newsym->value = 0;
908b32fc 4391 newsym->flags = BSF_WEAK;
bb700d78
AM		 4392
4393 bh = NULL;
4394 if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4395 newsym->flags, newsym->section,
4396 newsym->value, NULL, FALSE, FALSE,
4397 &bh))
4398 return NULL;
4399
4400 fdh = (struct ppc_link_hash_entry *) bh;
4401 fdh->elf.non_elf = 0;
908b32fc
AM		 4402 fdh->fake = 1;
4403 fdh->is_func_descriptor = 1;
4404 fdh->oh = fh;
4405 fh->is_func = 1;
4406 fh->oh = fdh;
bb700d78
AM		 4407 return fdh;
4408}
4409
8387904d
AM		 4410/* Fix function descriptor symbols defined in .opd sections to be
4411 function type. */
555cd476
AM		 4412
4413static bfd_boolean
b3fac117 4414ppc64_elf_add_symbol_hook (bfd *ibfd ATTRIBUTE_UNUSED,
e054468f 4415 struct bfd_link_info *info,
555cd476 4416 Elf_Internal_Sym *isym,
b3fac117 4417 const char **name ATTRIBUTE_UNUSED,
555cd476
AM		 4418 flagword *flags ATTRIBUTE_UNUSED,
4419 asection **sec,
4420 bfd_vma *value ATTRIBUTE_UNUSED)
4421{
e054468f
AM		 4422 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4423 elf_tdata (info->output_bfd)->has_ifunc_symbols = TRUE;
4424 else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4425 ;
4426 else if (*sec != NULL
4427 && strcmp (bfd_get_section_name (ibfd, *sec), ".opd") == 0)
555cd476 4428 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
433817dd 4429
555cd476
AM		 4430 return TRUE;
4431}
4432
8387904d 4433/* This function makes an old ABI object reference to ".bar" cause the
908b32fc
AM		 4434 inclusion of a new ABI object archive that defines "bar".
4435 NAME is a symbol defined in an archive. Return a symbol in the hash
4436 table that might be satisfied by the archive symbols. */
8387904d
AM		 4437
4438static struct elf_link_hash_entry *
4439ppc64_elf_archive_symbol_lookup (bfd *abfd,
4440 struct bfd_link_info *info,
4441 const char *name)
4442{
4443 struct elf_link_hash_entry *h;
4444 char *dot_name;
4445 size_t len;
4446
4447 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
908b32fc
AM		 4448 if (h != NULL
4449 /* Don't return this sym if it is a fake function descriptor
4450 created by add_symbol_adjust. */
4451 && !(h->root.type == bfd_link_hash_undefweak
4452 && ((struct ppc_link_hash_entry *) h)->fake))
8387904d
AM		 4453 return h;
4454
4455 if (name[0] == '.')
4456 return h;
4457
4458 len = strlen (name);
4459 dot_name = bfd_alloc (abfd, len + 2);
4460 if (dot_name == NULL)
4461 return (struct elf_link_hash_entry *) 0 - 1;
4462 dot_name[0] = '.';
4463 memcpy (dot_name + 1, name, len + 1);
4464 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4465 bfd_release (abfd, dot_name);
4466 return h;
4467}
4468
4469/* This function satisfies all old ABI object references to ".bar" if a
99877b66
AM		 4470 new ABI object defines "bar". Well, at least, undefined dot symbols
4471 are made weak. This stops later archive searches from including an
4472 object if we already have a function descriptor definition. It also
35b0ce59
AM		 4473 prevents the linker complaining about undefined symbols.
4474 We also check and correct mismatched symbol visibility here. The
4475 most restrictive visibility of the function descriptor and the
4476 function entry symbol is used. */
8387904d
AM		 4477
4478static bfd_boolean
b3fac117 4479add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
8387904d 4480{
8387904d
AM		 4481 struct ppc_link_hash_table *htab;
4482 struct ppc_link_hash_entry *fdh;
4483
b3fac117 4484 if (eh->elf.root.type == bfd_link_hash_indirect)
8387904d
AM		 4485 return TRUE;
4486
b3fac117
AM		 4487 if (eh->elf.root.type == bfd_link_hash_warning)
4488 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
8387904d 4489
b3fac117
AM		 4490 if (eh->elf.root.root.string[0] != '.')
4491 abort ();
8387904d 4492
b3fac117 4493 htab = ppc_hash_table (info);
99877b66 4494 fdh = get_fdh (eh, htab);
bb700d78 4495 if (fdh == NULL
b3fac117 4496 && !info->relocatable
bb700d78
AM		 4497 && (eh->elf.root.type == bfd_link_hash_undefined
4498 || eh->elf.root.type == bfd_link_hash_undefweak)
4499 && eh->elf.ref_regular)
4500 {
4501 /* Make an undefweak function descriptor sym, which is enough to
4502 pull in an --as-needed shared lib, but won't cause link
4503 errors. Archives are handled elsewhere. */
b3fac117 4504 fdh = make_fdh (info, eh);
bb700d78 4505 if (fdh == NULL)
b3fac117 4506 return FALSE;
bb700d78
AM		 4507 else
4508 fdh->elf.ref_regular = 1;
4509 }
e87d886e 4510 else if (fdh != NULL)
8387904d 4511 {
35b0ce59
AM		 4512 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4513 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4514 if (entry_vis < descr_vis)
4515 fdh->elf.other += entry_vis - descr_vis;
4516 else if (entry_vis > descr_vis)
4517 eh->elf.other += descr_vis - entry_vis;
4518
e87d886e
AM		 4519 if ((fdh->elf.root.type == bfd_link_hash_defined
4520 || fdh->elf.root.type == bfd_link_hash_defweak)
4521 && eh->elf.root.type == bfd_link_hash_undefined)
35b0ce59
AM		 4522 {
4523 eh->elf.root.type = bfd_link_hash_undefweak;
4524 eh->was_undefined = 1;
4525 htab->twiddled_syms = 1;
4526 }
8387904d 4527 }
99877b66 4528
8387904d
AM		 4529 return TRUE;
4530}
4531
b3fac117
AM		 4532/* Process list of dot-symbols we made in link_hash_newfunc. */
4533
8387904d 4534static bfd_boolean
7d9616d7 4535ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
8387904d 4536{
99877b66 4537 struct ppc_link_hash_table *htab;
b3fac117 4538 struct ppc_link_hash_entry **p, *eh;
433817dd 4539
99877b66 4540 htab = ppc_hash_table (info);
0c8d6e5c 4541 if (!is_ppc64_elf (info->output_bfd))
35b0ce59
AM		 4542 return TRUE;
4543
0c8d6e5c 4544 if (is_ppc64_elf (ibfd))
b3fac117
AM		 4545 {
4546 p = &htab->dot_syms;
4547 while ((eh = *p) != NULL)
4548 {
4549 *p = NULL;
4550 if (!add_symbol_adjust (eh, info))
4551 return FALSE;
4552 p = &eh->u.next_dot_sym;
4553 }
4554 }
4555
4556 /* Clear the list for non-ppc64 input files. */
4557 p = &htab->dot_syms;
4558 while ((eh = *p) != NULL)
4559 {
4560 *p = NULL;
4561 p = &eh->u.next_dot_sym;
4562 }
99877b66
AM		 4563
4564 /* We need to fix the undefs list for any syms we have twiddled to
4565 undef_weak. */
4566 if (htab->twiddled_syms)
4567 {
77cfaee6 4568 bfd_link_repair_undef_list (&htab->elf.root);
99877b66
AM		 4569 htab->twiddled_syms = 0;
4570 }
b3fac117 4571 return TRUE;
8387904d
AM		 4572}
4573
97fed1c9
JJ		 4574/* Undo hash table changes when an --as-needed input file is determined
4575 not to be needed. */
4576
4577static bfd_boolean
4578ppc64_elf_as_needed_cleanup (bfd *ibfd ATTRIBUTE_UNUSED,
4579 struct bfd_link_info *info)
4580{
4581 ppc_hash_table (info)->dot_syms = NULL;
4582 return TRUE;
4583}
4584
e054468f 4585static struct plt_entry **
4ce794b7
AM		 4586update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
4587 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
411e1bfb
AM		 4588{
4589 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
e054468f 4590 struct plt_entry **local_plt;
e7b938ca 4591 char *local_got_tls_masks;
411e1bfb
AM		 4592
4593 if (local_got_ents == NULL)
4594 {
4595 bfd_size_type size = symtab_hdr->sh_info;
4596
e054468f
AM		 4597 size *= (sizeof (*local_got_ents)
4598 + sizeof (*local_plt)
4599 + sizeof (*local_got_tls_masks));
4ce794b7 4600 local_got_ents = bfd_zalloc (abfd, size);
411e1bfb 4601 if (local_got_ents == NULL)
e054468f 4602 return NULL;
411e1bfb
AM		 4603 elf_local_got_ents (abfd) = local_got_ents;
4604 }
4605
e054468f 4606 if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
411e1bfb
AM		 4607 {
4608 struct got_entry *ent;
4609
4610 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
e717da7e
AM		 4611 if (ent->addend == r_addend
4612 && ent->owner == abfd
4613 && ent->tls_type == tls_type)
411e1bfb
AM		 4614 break;
4615 if (ent == NULL)
4616 {
4617 bfd_size_type amt = sizeof (*ent);
4ce794b7 4618 ent = bfd_alloc (abfd, amt);
411e1bfb
AM		 4619 if (ent == NULL)
4620 return FALSE;
4621 ent->next = local_got_ents[r_symndx];
4622 ent->addend = r_addend;
e717da7e 4623 ent->owner = abfd;
411e1bfb
AM		 4624 ent->tls_type = tls_type;
4625 ent->got.refcount = 0;
4626 local_got_ents[r_symndx] = ent;
4627 }
4628 ent->got.refcount += 1;
4629 }
4630
e054468f
AM		 4631 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
4632 local_got_tls_masks = (char *) (local_plt + symtab_hdr->sh_info);
e7b938ca 4633 local_got_tls_masks[r_symndx] |= tls_type;
e054468f
AM		 4634
4635 return local_plt + r_symndx;
65f38f15
AM		 4636}
4637
411e1bfb 4638static bfd_boolean
e054468f 4639update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
1e2f5b6e 4640{
411e1bfb 4641 struct plt_entry *ent;
1e2f5b6e 4642
e054468f 4643 for (ent = *plist; ent != NULL; ent = ent->next)
411e1bfb
AM		 4644 if (ent->addend == addend)
4645 break;
4646 if (ent == NULL)
1e2f5b6e 4647 {
411e1bfb 4648 bfd_size_type amt = sizeof (*ent);
4ce794b7 4649 ent = bfd_alloc (abfd, amt);
411e1bfb
AM		 4650 if (ent == NULL)
4651 return FALSE;
e054468f 4652 ent->next = *plist;
411e1bfb
AM		 4653 ent->addend = addend;
4654 ent->plt.refcount = 0;
e054468f 4655 *plist = ent;
1e2f5b6e 4656 }
411e1bfb 4657 ent->plt.refcount += 1;
b34976b6 4658 return TRUE;
1e2f5b6e
AM		 4659}
4660
e054468f
AM		 4661static bfd_boolean
4662is_branch_reloc (enum elf_ppc64_reloc_type r_type)
4663{
4664 return (r_type == R_PPC64_REL24
4665 || r_type == R_PPC64_REL14
4666 || r_type == R_PPC64_REL14_BRTAKEN
4667 || r_type == R_PPC64_REL14_BRNTAKEN
4668 || r_type == R_PPC64_ADDR24
4669 || r_type == R_PPC64_ADDR14
4670 || r_type == R_PPC64_ADDR14_BRTAKEN
4671 || r_type == R_PPC64_ADDR14_BRNTAKEN);
4672}
4673
5bd4f169 4674/* Look through the relocs for a section during the first phase, and
65f38f15 4675 calculate needed space in the global offset table, procedure
5d1634d7 4676 linkage table, and dynamic reloc sections. */
5bd4f169 4677
b34976b6 4678static bfd_boolean
4ce794b7
AM		 4679ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
4680 asection *sec, const Elf_Internal_Rela *relocs)
5bd4f169 4681{
65f38f15 4682 struct ppc_link_hash_table *htab;
5bd4f169
AM		 4683 Elf_Internal_Shdr *symtab_hdr;
4684 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
4685 const Elf_Internal_Rela *rel;
4686 const Elf_Internal_Rela *rel_end;
5bd4f169 4687 asection *sreloc;
1e2f5b6e 4688 asection **opd_sym_map;
3a71aa26 4689 struct elf_link_hash_entry *tga, *dottga;
5bd4f169 4690
1049f94e 4691 if (info->relocatable)
b34976b6 4692 return TRUE;
5bd4f169 4693
680a3378
AM		 4694 /* Don't do anything special with non-loaded, non-alloced sections.
4695 In particular, any relocs in such sections should not affect GOT
4696 and PLT reference counting (ie. we don't allow them to create GOT
4697 or PLT entries), there's no possibility or desire to optimize TLS
4698 relocs, and there's not much point in propagating relocs to shared
4699 libs that the dynamic linker won't relocate. */
4700 if ((sec->flags & SEC_ALLOC) == 0)
4701 return TRUE;
4702
0c8d6e5c 4703 BFD_ASSERT (is_ppc64_elf (abfd));
0ffa91dd 4704
65f38f15 4705 htab = ppc_hash_table (info);
3a71aa26
AM		 4706 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
4707 FALSE, FALSE, TRUE);
4708 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
4709 FALSE, FALSE, TRUE);
0ffa91dd 4710 symtab_hdr = &elf_symtab_hdr (abfd);
5bd4f169
AM		 4711
4712 sym_hashes = elf_sym_hashes (abfd);
4713 sym_hashes_end = (sym_hashes
1e2f5b6e
AM		 4714 + symtab_hdr->sh_size / sizeof (Elf64_External_Sym)
4715 - symtab_hdr->sh_info);
5bd4f169
AM		 4716
4717 sreloc = NULL;
1e2f5b6e
AM		 4718 opd_sym_map = NULL;
4719 if (strcmp (bfd_get_section_name (abfd, sec), ".opd") == 0)
4720 {
4721 /* Garbage collection needs some extra help with .opd sections.
4722 We don't want to necessarily keep everything referenced by
4723 relocs in .opd, as that would keep all functions. Instead,
4724 if we reference an .opd symbol (a function descriptor), we
4725 want to keep the function code symbol's section. This is
4726 easy for global symbols, but for local syms we need to keep
74f0fb50 4727 information about the associated function section. */
1e2f5b6e
AM		 4728 bfd_size_type amt;
4729
74f0fb50 4730 amt = sec->size * sizeof (*opd_sym_map) / 8;
4ce794b7 4731 opd_sym_map = bfd_zalloc (abfd, amt);
1e2f5b6e 4732 if (opd_sym_map == NULL)
b34976b6 4733 return FALSE;
74f0fb50 4734 ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
7c8fe5c4
AM		 4735 BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
4736 ppc64_elf_section_data (sec)->sec_type = sec_opd;
1e2f5b6e 4737 }
5bd4f169 4738
82bd7b59
AM		 4739 if (htab->sfpr == NULL
4740 && !create_linkage_sections (htab->elf.dynobj, info))
b34976b6 4741 return FALSE;
82bd7b59 4742
5bd4f169
AM		 4743 rel_end = relocs + sec->reloc_count;
4744 for (rel = relocs; rel < rel_end; rel++)
4745 {
4746 unsigned long r_symndx;
4747 struct elf_link_hash_entry *h;
04c9666a 4748 enum elf_ppc64_reloc_type r_type;
727fc41e 4749 int tls_type;
7c8fe5c4 4750 struct _ppc64_elf_section_data *ppc64_sec;
e054468f 4751 struct plt_entry **ifunc;
5bd4f169
AM		 4752
4753 r_symndx = ELF64_R_SYM (rel->r_info);
4754 if (r_symndx < symtab_hdr->sh_info)
4755 h = NULL;
4756 else
973a3492
L		 4757 {
4758 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4759 while (h->root.type == bfd_link_hash_indirect
4760 || h->root.type == bfd_link_hash_warning)
4761 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4762 }
5bd4f169 4763
727fc41e 4764 tls_type = 0;
e054468f 4765 ifunc = NULL;
4ce794b7 4766 r_type = ELF64_R_TYPE (rel->r_info);
e054468f
AM		 4767 if (is_branch_reloc (r_type))
4768 {
4769 if (h != NULL && (h == tga || h == dottga))
4770 {
4771 if (rel != relocs
4772 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
4773 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
4774 /* We have a new-style __tls_get_addr call with a marker
4775 reloc. */
4776 ;
4777 else
4778 /* Mark this section as having an old-style call. */
4779 sec->has_tls_get_addr_call = 1;
4780 }
727fc41e 4781
e054468f
AM		 4782 /* STT_GNU_IFUNC symbols must have a PLT entry. */
4783 if (h != NULL)
4784 {
4785 if (h->type == STT_GNU_IFUNC)
4786 {
4787 h->needs_plt = 1;
4788 ifunc = &h->plt.plist;
4789 }
4790 }
4791 else
4792 {
4793 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
4794 abfd, r_symndx);
4795 if (isym == NULL)
4796 return FALSE;
4797
4798 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4799 {
4800 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
4801 rel->r_addend, PLT_IFUNC);
4802 if (ifunc == NULL)
4803 return FALSE;
4804 }
4805 }
4806 if (ifunc != NULL
4807 && !update_plt_info (abfd, ifunc, rel->r_addend))
4808 return FALSE;
4809 }
727fc41e 4810
a33d1f77 4811 switch (r_type)
5bd4f169 4812 {
727fc41e
AM		 4813 case R_PPC64_TLSGD:
4814 case R_PPC64_TLSLD:
4815 /* These special tls relocs tie a call to __tls_get_addr with
4816 its parameter symbol. */
4817 break;
4818
411e1bfb
AM		 4819 case R_PPC64_GOT_TLSLD16:
4820 case R_PPC64_GOT_TLSLD16_LO:
4821 case R_PPC64_GOT_TLSLD16_HI:
4822 case R_PPC64_GOT_TLSLD16_HA:
951fd09b 4823 tls_type = TLS_TLS | TLS_LD;
411e1bfb
AM		 4824 goto dogottls;
4825
4826 case R_PPC64_GOT_TLSGD16:
4827 case R_PPC64_GOT_TLSGD16_LO:
4828 case R_PPC64_GOT_TLSGD16_HI:
4829 case R_PPC64_GOT_TLSGD16_HA:
951fd09b 4830 tls_type = TLS_TLS | TLS_GD;
411e1bfb
AM		 4831 goto dogottls;
4832
4833 case R_PPC64_GOT_TPREL16_DS:
4834 case R_PPC64_GOT_TPREL16_LO_DS:
4835 case R_PPC64_GOT_TPREL16_HI:
4836 case R_PPC64_GOT_TPREL16_HA:
1d483afe 4837 if (!info->executable)
411e1bfb
AM		 4838 info->flags |= DF_STATIC_TLS;
4839 tls_type = TLS_TLS | TLS_TPREL;
4840 goto dogottls;
4841
4842 case R_PPC64_GOT_DTPREL16_DS:
4843 case R_PPC64_GOT_DTPREL16_LO_DS:
4844 case R_PPC64_GOT_DTPREL16_HI:
4845 case R_PPC64_GOT_DTPREL16_HA:
4846 tls_type = TLS_TLS | TLS_DTPREL;
4847 dogottls:
4848 sec->has_tls_reloc = 1;
4849 /* Fall thru */
4850
5bd4f169 4851 case R_PPC64_GOT16:
5bd4f169 4852 case R_PPC64_GOT16_DS:
65f38f15
AM		 4853 case R_PPC64_GOT16_HA:
4854 case R_PPC64_GOT16_HI:
4855 case R_PPC64_GOT16_LO:
5bd4f169 4856 case R_PPC64_GOT16_LO_DS:
65f38f15 4857 /* This symbol requires a global offset table entry. */
4c52953f 4858 sec->has_toc_reloc = 1;
e717da7e
AM		 4859 if (ppc64_elf_tdata (abfd)->got == NULL
4860 && !create_got_section (abfd, info))
b34976b6 4861 return FALSE;
5bd4f169
AM		 4862
4863 if (h != NULL)
4864 {
411e1bfb
AM		 4865 struct ppc_link_hash_entry *eh;
4866 struct got_entry *ent;
65f38f15 4867
411e1bfb
AM		 4868 eh = (struct ppc_link_hash_entry *) h;
4869 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
4870 if (ent->addend == rel->r_addend
e717da7e 4871 && ent->owner == abfd
411e1bfb
AM		 4872 && ent->tls_type == tls_type)
4873 break;
4874 if (ent == NULL)
5bd4f169 4875 {
411e1bfb 4876 bfd_size_type amt = sizeof (*ent);
4ce794b7 4877 ent = bfd_alloc (abfd, amt);
411e1bfb 4878 if (ent == NULL)
b34976b6 4879 return FALSE;
411e1bfb
AM		 4880 ent->next = eh->elf.got.glist;
4881 ent->addend = rel->r_addend;
e717da7e 4882 ent->owner = abfd;
411e1bfb
AM		 4883 ent->tls_type = tls_type;
4884 ent->got.refcount = 0;
4885 eh->elf.got.glist = ent;
5bd4f169 4886 }
411e1bfb 4887 ent->got.refcount += 1;
e7b938ca 4888 eh->tls_mask |= tls_type;
5bd4f169 4889 }
411e1bfb
AM		 4890 else
4891 /* This is a global offset table entry for a local symbol. */
4892 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
4893 rel->r_addend, tls_type))
4894 return FALSE;
5bd4f169
AM		 4895 break;
4896
5bd4f169 4897 case R_PPC64_PLT16_HA:
65f38f15
AM		 4898 case R_PPC64_PLT16_HI:
4899 case R_PPC64_PLT16_LO:
4900 case R_PPC64_PLT32:
4901 case R_PPC64_PLT64:
5bd4f169 4902 /* This symbol requires a procedure linkage table entry. We
3fad3c7c
AM		 4903 actually build the entry in adjust_dynamic_symbol,
4904 because this might be a case of linking PIC code without
4905 linking in any dynamic objects, in which case we don't
4906 need to generate a procedure linkage table after all. */
5bd4f169
AM		 4907 if (h == NULL)
4908 {
4909 /* It does not make sense to have a procedure linkage
3fad3c7c 4910 table entry for a local symbol. */
5bd4f169 4911 bfd_set_error (bfd_error_bad_value);
b34976b6 4912 return FALSE;
5bd4f169 4913 }
411e1bfb 4914 else
e054468f
AM		 4915 {
4916 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
4917 return FALSE;
4918 h->needs_plt = 1;
4919 if (h->root.root.string[0] == '.'
4920 && h->root.root.string[1] != '\0')
4921 ((struct ppc_link_hash_entry *) h)->is_func = 1;
4922 }
5bd4f169
AM		 4923 break;
4924
4925 /* The following relocations don't need to propagate the
4926 relocation if linking a shared object since they are
4927 section relative. */
4928 case R_PPC64_SECTOFF:
4929 case R_PPC64_SECTOFF_LO:
4930 case R_PPC64_SECTOFF_HI:
4931 case R_PPC64_SECTOFF_HA:
4932 case R_PPC64_SECTOFF_DS:
4933 case R_PPC64_SECTOFF_LO_DS:
411e1bfb
AM		 4934 case R_PPC64_DTPREL16:
4935 case R_PPC64_DTPREL16_LO:
4936 case R_PPC64_DTPREL16_HI:
4937 case R_PPC64_DTPREL16_HA:
4938 case R_PPC64_DTPREL16_DS:
4939 case R_PPC64_DTPREL16_LO_DS:
4940 case R_PPC64_DTPREL16_HIGHER:
4941 case R_PPC64_DTPREL16_HIGHERA:
4942 case R_PPC64_DTPREL16_HIGHEST:
4943 case R_PPC64_DTPREL16_HIGHESTA:
5bd4f169
AM		 4944 break;
4945
ad8e1ba5
AM		 4946 /* Nor do these. */
4947 case R_PPC64_TOC16:
4948 case R_PPC64_TOC16_LO:
4949 case R_PPC64_TOC16_HI:
4950 case R_PPC64_TOC16_HA:
4951 case R_PPC64_TOC16_DS:
4952 case R_PPC64_TOC16_LO_DS:
4c52953f 4953 sec->has_toc_reloc = 1;
ad8e1ba5
AM		 4954 break;
4955
5bd4f169
AM		 4956 /* This relocation describes the C++ object vtable hierarchy.
4957 Reconstruct it for later use during GC. */
4958 case R_PPC64_GNU_VTINHERIT:
c152c796 4959 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
b34976b6 4960 return FALSE;
5bd4f169
AM		 4961 break;
4962
4963 /* This relocation describes which C++ vtable entries are actually
4964 used. Record for later use during GC. */
4965 case R_PPC64_GNU_VTENTRY:
d17e0c6e
JB		 4966 BFD_ASSERT (h != NULL);
4967 if (h != NULL
4968 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
b34976b6 4969 return FALSE;
5bd4f169
AM		 4970 break;
4971
721956f4
AM		 4972 case R_PPC64_REL14:
4973 case R_PPC64_REL14_BRTAKEN:
4974 case R_PPC64_REL14_BRNTAKEN:
220c76dd
AM		 4975 {
4976 asection *dest = NULL;
4977
4978 /* Heuristic: If jumping outside our section, chances are
4979 we are going to need a stub. */
4980 if (h != NULL)
4981 {
4982 /* If the sym is weak it may be overridden later, so
4983 don't assume we know where a weak sym lives. */
4984 if (h->root.type == bfd_link_hash_defined)
4985 dest = h->root.u.def.section;
4986 }
4987 else
87d72d41
AM		 4988 {
4989 Elf_Internal_Sym *isym;
4990
4991 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
4992 abfd, r_symndx);
4993 if (isym == NULL)
4994 return FALSE;
4995
4996 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
4997 }
4998
220c76dd 4999 if (dest != sec)
7c8fe5c4 5000 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
220c76dd 5001 }
721956f4
AM		 5002 /* Fall through. */
5003
5d1634d7 5004 case R_PPC64_REL24:
e054468f 5005 if (h != NULL && ifunc == NULL)
5d1634d7
AM		 5006 {
5007 /* We may need a .plt entry if the function this reloc
5008 refers to is in a shared lib. */
e054468f 5009 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
411e1bfb 5010 return FALSE;
e054468f
AM		 5011 h->needs_plt = 1;
5012 if (h->root.root.string[0] == '.'
5013 && h->root.root.string[1] != '\0')
5014 ((struct ppc_link_hash_entry *) h)->is_func = 1;
3a71aa26 5015 if (h == tga || h == dottga)
411e1bfb 5016 sec->has_tls_reloc = 1;
411e1bfb
AM		 5017 }
5018 break;
5019
5020 case R_PPC64_TPREL64:
5021 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
1d483afe 5022 if (!info->executable)
411e1bfb
AM		 5023 info->flags |= DF_STATIC_TLS;
5024 goto dotlstoc;
5025
5026 case R_PPC64_DTPMOD64:
5027 if (rel + 1 < rel_end
5028 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5029 && rel[1].r_offset == rel->r_offset + 8)
951fd09b 5030 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
411e1bfb 5031 else
951fd09b 5032 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
411e1bfb
AM		 5033 goto dotlstoc;
5034
5035 case R_PPC64_DTPREL64:
5036 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5037 if (rel != relocs
5038 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5039 && rel[-1].r_offset == rel->r_offset - 8)
5040 /* This is the second reloc of a dtpmod, dtprel pair.
5041 Don't mark with TLS_DTPREL. */
5042 goto dodyn;
5043
5044 dotlstoc:
5045 sec->has_tls_reloc = 1;
5046 if (h != NULL)
5047 {
5048 struct ppc_link_hash_entry *eh;
5049 eh = (struct ppc_link_hash_entry *) h;
e7b938ca 5050 eh->tls_mask |= tls_type;
411e1bfb
AM		 5051 }
5052 else
5053 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5054 rel->r_addend, tls_type))
5055 return FALSE;
5056
7c8fe5c4
AM		 5057 ppc64_sec = ppc64_elf_section_data (sec);
5058 if (ppc64_sec->sec_type != sec_toc)
411e1bfb 5059 {
3a71aa26
AM		 5060 bfd_size_type amt;
5061
e7b938ca 5062 /* One extra to simplify get_tls_mask. */
3a71aa26
AM		 5063 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5064 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5065 if (ppc64_sec->u.toc.symndx == NULL)
5066 return FALSE;
5067 amt = sec->size * sizeof (bfd_vma) / 8;
5068 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5069 if (ppc64_sec->u.toc.add == NULL)
411e1bfb 5070 return FALSE;
7c8fe5c4
AM		 5071 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5072 ppc64_sec->sec_type = sec_toc;
411e1bfb
AM		 5073 }
5074 BFD_ASSERT (rel->r_offset % 8 == 0);
3a71aa26
AM		 5075 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5076 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
951fd09b
AM		 5077
5078 /* Mark the second slot of a GD or LD entry.
5079 -1 to indicate GD and -2 to indicate LD. */
5080 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
3a71aa26 5081 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
951fd09b 5082 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
3a71aa26 5083 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
411e1bfb
AM		 5084 goto dodyn;
5085
5086 case R_PPC64_TPREL16:
5087 case R_PPC64_TPREL16_LO:
5088 case R_PPC64_TPREL16_HI:
5089 case R_PPC64_TPREL16_HA:
5090 case R_PPC64_TPREL16_DS:
5091 case R_PPC64_TPREL16_LO_DS:
5092 case R_PPC64_TPREL16_HIGHER:
5093 case R_PPC64_TPREL16_HIGHERA:
5094 case R_PPC64_TPREL16_HIGHEST:
5095 case R_PPC64_TPREL16_HIGHESTA:
5096 if (info->shared)
5097 {
1d483afe
AM		 5098 if (!info->executable)
5099 info->flags |= DF_STATIC_TLS;
411e1bfb 5100 goto dodyn;
5d1634d7
AM		 5101 }
5102 break;
5103
e86ce104 5104 case R_PPC64_ADDR64:
1e2f5b6e 5105 if (opd_sym_map != NULL
1e2f5b6e 5106 && rel + 1 < rel_end
4ce794b7 5107 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
1e2f5b6e 5108 {
8387904d
AM		 5109 if (h != NULL)
5110 {
5111 if (h->root.root.string[0] == '.'
5112 && h->root.root.string[1] != 0
5113 && get_fdh ((struct ppc_link_hash_entry *) h, htab))
5114 ;
5115 else
5116 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5117 }
5118 else
5119 {
5120 asection *s;
87d72d41 5121 Elf_Internal_Sym *isym;
1e2f5b6e 5122
87d72d41
AM		 5123 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5124 abfd, r_symndx);
5125 if (isym == NULL)
8387904d 5126 return FALSE;
87d72d41
AM		 5127
5128 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5129 if (s != NULL && s != sec)
3f764659 5130 opd_sym_map[rel->r_offset / 8] = s;
8387904d 5131 }
1e2f5b6e 5132 }
e86ce104
AM		 5133 /* Fall through. */
5134
04c9666a 5135 case R_PPC64_REL30:
5bd4f169 5136 case R_PPC64_REL32:
04c9666a 5137 case R_PPC64_REL64:
65f38f15
AM		 5138 case R_PPC64_ADDR14:
5139 case R_PPC64_ADDR14_BRNTAKEN:
5140 case R_PPC64_ADDR14_BRTAKEN:
5141 case R_PPC64_ADDR16:
5142 case R_PPC64_ADDR16_DS:
5143 case R_PPC64_ADDR16_HA:
5144 case R_PPC64_ADDR16_HI:
5145 case R_PPC64_ADDR16_HIGHER:
5146 case R_PPC64_ADDR16_HIGHERA:
5147 case R_PPC64_ADDR16_HIGHEST:
5148 case R_PPC64_ADDR16_HIGHESTA:
5149 case R_PPC64_ADDR16_LO:
5150 case R_PPC64_ADDR16_LO_DS:
5151 case R_PPC64_ADDR24:
65f38f15 5152 case R_PPC64_ADDR32:
65f38f15
AM		 5153 case R_PPC64_UADDR16:
5154 case R_PPC64_UADDR32:
5155 case R_PPC64_UADDR64:
5bd4f169 5156 case R_PPC64_TOC:
81848ca0
AM		 5157 if (h != NULL && !info->shared)
5158 /* We may need a copy reloc. */
f5385ebf 5159 h->non_got_ref = 1;
81848ca0 5160
41bd81ab 5161 /* Don't propagate .opd relocs. */
1e2f5b6e 5162 if (NO_OPD_RELOCS && opd_sym_map != NULL)
e86ce104 5163 break;
e86ce104 5164
65f38f15
AM		 5165 /* If we are creating a shared library, and this is a reloc
5166 against a global symbol, or a non PC relative reloc
5167 against a local symbol, then we need to copy the reloc
5168 into the shared library. However, if we are linking with
5169 -Bsymbolic, we do not need to copy a reloc against a
5170 global symbol which is defined in an object we are
5171 including in the link (i.e., DEF_REGULAR is set). At
5172 this point we have not seen all the input files, so it is
5173 possible that DEF_REGULAR is not set now but will be set
5174 later (it is never cleared). In case of a weak definition,
5175 DEF_REGULAR may be cleared later by a strong definition in
5176 a shared library. We account for that possibility below by
f4656909 5177 storing information in the dyn_relocs field of the hash
65f38f15
AM		 5178 table entry. A similar situation occurs when creating
5179 shared libraries and symbol visibility changes render the
5180 symbol local.
5181
5182 If on the other hand, we are creating an executable, we
5183 may need to keep relocations for symbols satisfied by a
5184 dynamic library if we manage to avoid copy relocs for the
5185 symbol. */
411e1bfb 5186 dodyn:
65f38f15 5187 if ((info->shared
1d483afe 5188 && (must_be_dyn_reloc (info, r_type)
65f38f15
AM		 5189 || (h != NULL
5190 && (! info->symbolic
5191 || h->root.type == bfd_link_hash_defweak
f5385ebf 5192 || !h->def_regular))))
f4656909
AM		 5193 || (ELIMINATE_COPY_RELOCS
5194 && !info->shared
65f38f15
AM		 5195 && h != NULL
5196 && (h->root.type == bfd_link_hash_defweak
f5385ebf 5197 || !h->def_regular)))
5bd4f169 5198 {
ec338859
AM		 5199 struct ppc_dyn_relocs *p;
5200 struct ppc_dyn_relocs **head;
5201
65f38f15
AM		 5202 /* We must copy these reloc types into the output file.
5203 Create a reloc section in dynobj and make room for
5204 this reloc. */
5bd4f169
AM		 5205 if (sreloc == NULL)
5206 {
83bac4b0
NC		 5207 sreloc = _bfd_elf_make_dynamic_reloc_section
5208 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
65f38f15 5209
5bd4f169 5210 if (sreloc == NULL)
83bac4b0 5211 return FALSE;
5bd4f169
AM		 5212 }
5213
65f38f15
AM		 5214 /* If this is a global symbol, we count the number of
5215 relocations we need for this symbol. */
5216 if (h != NULL)
5217 {
ec338859 5218 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
65f38f15
AM		 5219 }
5220 else
5221 {
ec338859
AM		 5222 /* Track dynamic relocs needed for local syms too.
5223 We really need local syms available to do this
5224 easily. Oh well. */
ec338859 5225 asection *s;
6edfbbad 5226 void *vpp;
87d72d41 5227 Elf_Internal_Sym *isym;
6edfbbad 5228
87d72d41
AM		 5229 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5230 abfd, r_symndx);
5231 if (isym == NULL)
b34976b6 5232 return FALSE;
ec338859 5233
87d72d41
AM		 5234 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5235 if (s == NULL)
5236 s = sec;
5237
6edfbbad
DJ		 5238 vpp = &elf_section_data (s)->local_dynrel;
5239 head = (struct ppc_dyn_relocs **) vpp;
65f38f15 5240 }
ec338859
AM		 5241
5242 p = *head;
5243 if (p == NULL || p->sec != sec)
5244 {
4ce794b7 5245 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
ec338859 5246 if (p == NULL)
b34976b6 5247 return FALSE;
ec338859
AM		 5248 p->next = *head;
5249 *head = p;
5250 p->sec = sec;
5251 p->count = 0;
5252 p->pc_count = 0;
5253 }
5254
5255 p->count += 1;
1d483afe 5256 if (!must_be_dyn_reloc (info, r_type))
ec338859 5257 p->pc_count += 1;
65f38f15 5258 }
5bd4f169 5259 break;
65f38f15
AM		 5260
5261 default:
96e0dda4 5262 break;
5bd4f169
AM		 5263 }
5264 }
5265
b34976b6 5266 return TRUE;
5bd4f169
AM		 5267}
5268
8387904d
AM		 5269/* OFFSET in OPD_SEC specifies a function descriptor. Return the address
5270 of the code entry point, and its section. */
5271
5272static bfd_vma
5273opd_entry_value (asection *opd_sec,
5274 bfd_vma offset,
5275 asection **code_sec,
5276 bfd_vma *code_off)
5277{
5278 bfd *opd_bfd = opd_sec->owner;
8860955f 5279 Elf_Internal_Rela *relocs;
8387904d 5280 Elf_Internal_Rela *lo, *hi, *look;
645ea6a9 5281 bfd_vma val;
8387904d 5282
4b85d634
AM		 5283 /* No relocs implies we are linking a --just-symbols object. */
5284 if (opd_sec->reloc_count == 0)
5285 {
5286 bfd_vma val;
5287
5288 if (!bfd_get_section_contents (opd_bfd, opd_sec, &val, offset, 8))
5289 return (bfd_vma) -1;
3b36f7e6 5290
4b85d634
AM		 5291 if (code_sec != NULL)
5292 {
5293 asection *sec, *likely = NULL;
5294 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5295 if (sec->vma <= val
5296 && (sec->flags & SEC_LOAD) != 0
5297 && (sec->flags & SEC_ALLOC) != 0)
5298 likely = sec;
5299 if (likely != NULL)
5300 {
5301 *code_sec = likely;
5302 if (code_off != NULL)
5303 *code_off = val - likely->vma;
5304 }
5305 }
5306 return val;
5307 }
5308
0c8d6e5c 5309 BFD_ASSERT (is_ppc64_elf (opd_bfd));
0ffa91dd 5310
8860955f
AM		 5311 relocs = ppc64_elf_tdata (opd_bfd)->opd_relocs;
5312 if (relocs == NULL)
5313 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
645ea6a9 5314
8387904d 5315 /* Go find the opd reloc at the sym address. */
8860955f 5316 lo = relocs;
8387904d
AM		 5317 BFD_ASSERT (lo != NULL);
5318 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
645ea6a9 5319 val = (bfd_vma) -1;
8387904d
AM		 5320 while (lo < hi)
5321 {
5322 look = lo + (hi - lo) / 2;
5323 if (look->r_offset < offset)
5324 lo = look + 1;
5325 else if (look->r_offset > offset)
5326 hi = look;
5327 else
5328 {
0ffa91dd
NC		 5329 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5330
8387904d
AM		 5331 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5332 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5333 {
5334 unsigned long symndx = ELF64_R_SYM (look->r_info);
8387904d
AM		 5335 asection *sec;
5336
5337 if (symndx < symtab_hdr->sh_info)
5338 {
5339 Elf_Internal_Sym *sym;
5340
5341 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5342 if (sym == NULL)
5343 {
5344 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
5345 symtab_hdr->sh_info,
5346 0, NULL, NULL, NULL);
5347 if (sym == NULL)
645ea6a9 5348 break;
8387904d
AM		 5349 symtab_hdr->contents = (bfd_byte *) sym;
5350 }
5351
5352 sym += symndx;
5353 val = sym->st_value;
cb33740c 5354 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
8387904d
AM		 5355 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5356 }
5357 else
5358 {
5359 struct elf_link_hash_entry **sym_hashes;
5360 struct elf_link_hash_entry *rh;
5361
5362 sym_hashes = elf_sym_hashes (opd_bfd);
5363 rh = sym_hashes[symndx - symtab_hdr->sh_info];
5364 while (rh->root.type == bfd_link_hash_indirect
5365 || rh->root.type == bfd_link_hash_warning)
5366 rh = ((struct elf_link_hash_entry *) rh->root.u.i.link);
5367 BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5368 || rh->root.type == bfd_link_hash_defweak);
5369 val = rh->root.u.def.value;
5370 sec = rh->root.u.def.section;
5371 }
5372 val += look->r_addend;
5373 if (code_off != NULL)
5374 *code_off = val;
5375 if (code_sec != NULL)
5376 *code_sec = sec;
5377 if (sec != NULL && sec->output_section != NULL)
5378 val += sec->output_section->vma + sec->output_offset;
8387904d
AM		 5379 }
5380 break;
5381 }
5382 }
645ea6a9 5383
645ea6a9 5384 return val;
8387904d
AM		 5385}
5386
74f0fb50
AM		 5387/* Mark all our entry sym sections, both opd and code section. */
5388
5389static void
5390ppc64_elf_gc_keep (struct bfd_link_info *info)
5391{
5392 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5393 struct bfd_sym_chain *sym;
5394
5395 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
5396 {
5397 struct ppc_link_hash_entry *eh;
5398 asection *sec;
5399
5400 eh = (struct ppc_link_hash_entry *)
5401 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, FALSE);
5402 if (eh == NULL)
5403 continue;
5404 if (eh->elf.root.type != bfd_link_hash_defined
5405 && eh->elf.root.type != bfd_link_hash_defweak)
5406 continue;
5407
5408 if (eh->is_func_descriptor
5409 && (eh->oh->elf.root.type == bfd_link_hash_defined
5410 || eh->oh->elf.root.type == bfd_link_hash_defweak))
5411 {
5412 sec = eh->oh->elf.root.u.def.section;
5413 sec->flags |= SEC_KEEP;
5414 }
5415 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5416 && opd_entry_value (eh->elf.root.u.def.section,
5417 eh->elf.root.u.def.value,
5418 &sec, NULL) != (bfd_vma) -1)
5419 sec->flags |= SEC_KEEP;
5420
5421 sec = eh->elf.root.u.def.section;
5422 sec->flags |= SEC_KEEP;
5423 }
5424}
5425
64d03ab5
AM		 5426/* Mark sections containing dynamically referenced symbols. When
5427 building shared libraries, we must assume that any visible symbol is
5428 referenced. */
5429
5430static bfd_boolean
5431ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
5432{
5433 struct bfd_link_info *info = (struct bfd_link_info *) inf;
5434 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
5435
5436 if (eh->elf.root.type == bfd_link_hash_warning)
5437 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5438
5439 /* Dynamic linking info is on the func descriptor sym. */
5440 if (eh->oh != NULL
5441 && eh->oh->is_func_descriptor
5442 && (eh->oh->elf.root.type == bfd_link_hash_defined
5443 || eh->oh->elf.root.type == bfd_link_hash_defweak))
5444 eh = eh->oh;
5445
5446 if ((eh->elf.root.type == bfd_link_hash_defined
5447 || eh->elf.root.type == bfd_link_hash_defweak)
5448 && (eh->elf.ref_dynamic
5449 || (!info->executable
5450 && eh->elf.def_regular
5451 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
5452 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN)))
5453 {
5454 asection *code_sec;
5455
5456 eh->elf.root.u.def.section->flags |= SEC_KEEP;
5457
5458 /* Function descriptor syms cause the associated
5459 function code sym section to be marked. */
5460 if (eh->is_func_descriptor
5461 && (eh->oh->elf.root.type == bfd_link_hash_defined
5462 || eh->oh->elf.root.type == bfd_link_hash_defweak))
5463 eh->oh->elf.root.u.def.section->flags |= SEC_KEEP;
5464 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5465 && opd_entry_value (eh->elf.root.u.def.section,
5466 eh->elf.root.u.def.value,
5467 &code_sec, NULL) != (bfd_vma) -1)
5468 code_sec->flags |= SEC_KEEP;
5469 }
5470
5471 return TRUE;
5472}
5473
5bd4f169
AM		 5474/* Return the section that should be marked against GC for a given
5475 relocation. */
5476
5477static asection *
4ce794b7 5478ppc64_elf_gc_mark_hook (asection *sec,
74f0fb50 5479 struct bfd_link_info *info ATTRIBUTE_UNUSED,
4ce794b7
AM		 5480 Elf_Internal_Rela *rel,
5481 struct elf_link_hash_entry *h,
5482 Elf_Internal_Sym *sym)
5bd4f169 5483{
ccfa59ea
AM		 5484 asection *rsec;
5485
ccfa59ea
AM		 5486 /* Syms return NULL if we're marking .opd, so we avoid marking all
5487 function sections, as all functions are referenced in .opd. */
5488 rsec = NULL;
5489 if (get_opd_info (sec) != NULL)
5490 return rsec;
1e2f5b6e 5491
5bd4f169
AM		 5492 if (h != NULL)
5493 {
04c9666a 5494 enum elf_ppc64_reloc_type r_type;
ccfa59ea 5495 struct ppc_link_hash_entry *eh;
a33d1f77 5496
4ce794b7 5497 r_type = ELF64_R_TYPE (rel->r_info);
a33d1f77 5498 switch (r_type)
5bd4f169
AM		 5499 {
5500 case R_PPC64_GNU_VTINHERIT:
5501 case R_PPC64_GNU_VTENTRY:
5502 break;
5503
5504 default:
5505 switch (h->root.type)
5506 {
5507 case bfd_link_hash_defined:
5508 case bfd_link_hash_defweak:
ccfa59ea 5509 eh = (struct ppc_link_hash_entry *) h;
c4f68ce3
AM		 5510 if (eh->oh != NULL
5511 && eh->oh->is_func_descriptor
5512 && (eh->oh->elf.root.type == bfd_link_hash_defined
5513 || eh->oh->elf.root.type == bfd_link_hash_defweak))
ccfa59ea 5514 eh = eh->oh;
1e2f5b6e
AM		 5515
5516 /* Function descriptor syms cause the associated
5517 function code sym section to be marked. */
c4f68ce3
AM		 5518 if (eh->is_func_descriptor
5519 && (eh->oh->elf.root.type == bfd_link_hash_defined
5520 || eh->oh->elf.root.type == bfd_link_hash_defweak))
ccfa59ea
AM		 5521 {
5522 /* They also mark their opd section. */
74f0fb50 5523 eh->elf.root.u.def.section->gc_mark = 1;
ccfa59ea
AM		 5524
5525 rsec = eh->oh->elf.root.u.def.section;
5526 }
8387904d
AM		 5527 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5528 && opd_entry_value (eh->elf.root.u.def.section,
5529 eh->elf.root.u.def.value,
5530 &rsec, NULL) != (bfd_vma) -1)
74f0fb50 5531 eh->elf.root.u.def.section->gc_mark = 1;
ccfa59ea 5532 else
1e2f5b6e
AM		 5533 rsec = h->root.u.def.section;
5534 break;
5bd4f169
AM		 5535
5536 case bfd_link_hash_common:
1e2f5b6e
AM		 5537 rsec = h->root.u.c.p->section;
5538 break;
5bd4f169
AM		 5539
5540 default:
5541 break;
5542 }
5543 }
5544 }
5545 else
5546 {
74f0fb50 5547 struct _opd_sec_data *opd;
1e2f5b6e
AM		 5548
5549 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
74f0fb50
AM		 5550 opd = get_opd_info (rsec);
5551 if (opd != NULL && opd->func_sec != NULL)
ccfa59ea 5552 {
74f0fb50 5553 rsec->gc_mark = 1;
ccfa59ea 5554
74f0fb50 5555 rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
ccfa59ea 5556 }
5bd4f169
AM		 5557 }
5558
1e2f5b6e 5559 return rsec;
5bd4f169
AM		 5560}
5561
65f38f15
AM		 5562/* Update the .got, .plt. and dynamic reloc reference counts for the
5563 section being removed. */
5bd4f169 5564
b34976b6 5565static bfd_boolean
4ce794b7
AM		 5566ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
5567 asection *sec, const Elf_Internal_Rela *relocs)
5bd4f169 5568{
411e1bfb 5569 struct ppc_link_hash_table *htab;
5bd4f169
AM		 5570 Elf_Internal_Shdr *symtab_hdr;
5571 struct elf_link_hash_entry **sym_hashes;
411e1bfb 5572 struct got_entry **local_got_ents;
5bd4f169 5573 const Elf_Internal_Rela *rel, *relend;
5bd4f169 5574
7dda2462
TG		 5575 if (info->relocatable)
5576 return TRUE;
5577
680a3378
AM		 5578 if ((sec->flags & SEC_ALLOC) == 0)
5579 return TRUE;
5580
ec338859
AM		 5581 elf_section_data (sec)->local_dynrel = NULL;
5582
411e1bfb 5583 htab = ppc_hash_table (info);
0ffa91dd 5584 symtab_hdr = &elf_symtab_hdr (abfd);
5bd4f169 5585 sym_hashes = elf_sym_hashes (abfd);
411e1bfb 5586 local_got_ents = elf_local_got_ents (abfd);
5bd4f169
AM		 5587
5588 relend = relocs + sec->reloc_count;
5589 for (rel = relocs; rel < relend; rel++)
a33d1f77
AM		 5590 {
5591 unsigned long r_symndx;
04c9666a 5592 enum elf_ppc64_reloc_type r_type;
58ac9f71 5593 struct elf_link_hash_entry *h = NULL;
411e1bfb 5594 char tls_type = 0;
5bd4f169 5595
a33d1f77 5596 r_symndx = ELF64_R_SYM (rel->r_info);
4ce794b7 5597 r_type = ELF64_R_TYPE (rel->r_info);
58ac9f71
AM		 5598 if (r_symndx >= symtab_hdr->sh_info)
5599 {
5600 struct ppc_link_hash_entry *eh;
5601 struct ppc_dyn_relocs **pp;
5602 struct ppc_dyn_relocs *p;
5603
5604 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3eb128b2
AM		 5605 while (h->root.type == bfd_link_hash_indirect
5606 || h->root.type == bfd_link_hash_warning)
5607 h = (struct elf_link_hash_entry *) h->root.u.i.link;
58ac9f71
AM		 5608 eh = (struct ppc_link_hash_entry *) h;
5609
5610 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
5611 if (p->sec == sec)
5612 {
5613 /* Everything must go for SEC. */
5614 *pp = p->next;
5615 break;
5616 }
5617 }
5618
e054468f
AM		 5619 if (is_branch_reloc (r_type))
5620 {
5621 struct plt_entry **ifunc = NULL;
5622 if (h != NULL)
5623 {
5624 if (h->type == STT_GNU_IFUNC)
5625 ifunc = &h->plt.plist;
5626 }
5627 else if (local_got_ents != NULL)
5628 {
5629 struct plt_entry **local_plt = (struct plt_entry **)
5630 (local_got_ents + symtab_hdr->sh_info);
5631 char *local_got_tls_masks = (char *)
5632 (local_plt + symtab_hdr->sh_info);
5633 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
5634 ifunc = local_plt + r_symndx;
5635 }
5636 if (ifunc != NULL)
5637 {
5638 struct plt_entry *ent;
5639
5640 for (ent = *ifunc; ent != NULL; ent = ent->next)
5641 if (ent->addend == rel->r_addend)
5642 break;
5643 if (ent == NULL)
5644 abort ();
5645 if (ent->plt.refcount > 0)
5646 ent->plt.refcount -= 1;
5647 continue;
5648 }
5649 }
5650
a33d1f77
AM		 5651 switch (r_type)
5652 {
411e1bfb
AM		 5653 case R_PPC64_GOT_TLSLD16:
5654 case R_PPC64_GOT_TLSLD16_LO:
5655 case R_PPC64_GOT_TLSLD16_HI:
5656 case R_PPC64_GOT_TLSLD16_HA:
951fd09b 5657 tls_type = TLS_TLS | TLS_LD;
411e1bfb
AM		 5658 goto dogot;
5659
5660 case R_PPC64_GOT_TLSGD16:
5661 case R_PPC64_GOT_TLSGD16_LO:
5662 case R_PPC64_GOT_TLSGD16_HI:
5663 case R_PPC64_GOT_TLSGD16_HA:
951fd09b 5664 tls_type = TLS_TLS | TLS_GD;
411e1bfb
AM		 5665 goto dogot;
5666
5667 case R_PPC64_GOT_TPREL16_DS:
5668 case R_PPC64_GOT_TPREL16_LO_DS:
5669 case R_PPC64_GOT_TPREL16_HI:
5670 case R_PPC64_GOT_TPREL16_HA:
5671 tls_type = TLS_TLS | TLS_TPREL;
5672 goto dogot;
5673
5674 case R_PPC64_GOT_DTPREL16_DS:
5675 case R_PPC64_GOT_DTPREL16_LO_DS:
5676 case R_PPC64_GOT_DTPREL16_HI:
5677 case R_PPC64_GOT_DTPREL16_HA:
5678 tls_type = TLS_TLS | TLS_DTPREL;
5679 goto dogot;
5680
a33d1f77
AM		 5681 case R_PPC64_GOT16:
5682 case R_PPC64_GOT16_DS:
5683 case R_PPC64_GOT16_HA:
5684 case R_PPC64_GOT16_HI:
5685 case R_PPC64_GOT16_LO:
5686 case R_PPC64_GOT16_LO_DS:
411e1bfb
AM		 5687 dogot:
5688 {
5689 struct got_entry *ent;
5690
58ac9f71
AM		 5691 if (h != NULL)
5692 ent = h->got.glist;
411e1bfb
AM		 5693 else
5694 ent = local_got_ents[r_symndx];
5695
5696 for (; ent != NULL; ent = ent->next)
5697 if (ent->addend == rel->r_addend
e717da7e 5698 && ent->owner == abfd
411e1bfb
AM		 5699 && ent->tls_type == tls_type)
5700 break;
5701 if (ent == NULL)
5702 abort ();
5703 if (ent->got.refcount > 0)
5704 ent->got.refcount -= 1;
5705 }
a33d1f77 5706 break;
65f38f15 5707
a33d1f77
AM		 5708 case R_PPC64_PLT16_HA:
5709 case R_PPC64_PLT16_HI:
5710 case R_PPC64_PLT16_LO:
5711 case R_PPC64_PLT32:
5712 case R_PPC64_PLT64:
721956f4
AM		 5713 case R_PPC64_REL14:
5714 case R_PPC64_REL14_BRNTAKEN:
5715 case R_PPC64_REL14_BRTAKEN:
5d1634d7 5716 case R_PPC64_REL24:
58ac9f71 5717 if (h != NULL)
5d1634d7 5718 {
411e1bfb
AM		 5719 struct plt_entry *ent;
5720
411e1bfb
AM		 5721 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5722 if (ent->addend == rel->r_addend)
5723 break;
5724 if (ent == NULL)
5725 abort ();
5726 if (ent->plt.refcount > 0)
5727 ent->plt.refcount -= 1;
5d1634d7 5728 }
e86ce104 5729 break;
5d1634d7 5730
a33d1f77
AM		 5731 default:
5732 break;
5733 }
5734 }
b34976b6 5735 return TRUE;
5bd4f169
AM		 5736}
5737
deb0e272
AM		 5738/* The maximum size of .sfpr. */
5739#define SFPR_MAX (218*4)
5740
5741struct sfpr_def_parms
5742{
699733f6
AM		 5743 const char name[12];
5744 unsigned char lo, hi;
deb0e272
AM		 5745 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
5746 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
5747};
5748
5749/* Auto-generate _save*, _rest* functions in .sfpr. */
5750
5751static unsigned int
5752sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
5753{
5754 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5755 unsigned int i;
5756 size_t len = strlen (parm->name);
5757 bfd_boolean writing = FALSE;
699733f6 5758 char sym[16];
deb0e272
AM		 5759
5760 memcpy (sym, parm->name, len);
5761 sym[len + 2] = 0;
5762
5763 for (i = parm->lo; i <= parm->hi; i++)
5764 {
5765 struct elf_link_hash_entry *h;
5766
5767 sym[len + 0] = i / 10 + '0';
5768 sym[len + 1] = i % 10 + '0';
5769 h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
5770 if (h != NULL
f5385ebf 5771 && !h->def_regular)
deb0e272
AM		 5772 {
5773 h->root.type = bfd_link_hash_defined;
5774 h->root.u.def.section = htab->sfpr;
5775 h->root.u.def.value = htab->sfpr->size;
5776 h->type = STT_FUNC;
f5385ebf 5777 h->def_regular = 1;
deb0e272
AM		 5778 _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
5779 writing = TRUE;
5780 if (htab->sfpr->contents == NULL)
5781 {
5782 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
5783 if (htab->sfpr->contents == NULL)
5784 return FALSE;
5785 }
5786 }
5787 if (writing)
5788 {
5789 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
5790 if (i != parm->hi)
5791 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
5792 else
5793 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
5794 htab->sfpr->size = p - htab->sfpr->contents;
5795 }
5796 }
5797
5798 return TRUE;
5799}
5800
5801static bfd_byte *
5802savegpr0 (bfd *abfd, bfd_byte *p, int r)
5803{
5804 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5805 return p + 4;
5806}
5807
5808static bfd_byte *
5809savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
5810{
5811 p = savegpr0 (abfd, p, r);
5812 bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
5813 p = p + 4;
5814 bfd_put_32 (abfd, BLR, p);
5815 return p + 4;
5816}
5817
5818static bfd_byte *
5819restgpr0 (bfd *abfd, bfd_byte *p, int r)
5820{
5821 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5822 return p + 4;
5823}
5824
5825static bfd_byte *
5826restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
5827{
5828 bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
5829 p = p + 4;
5830 p = restgpr0 (abfd, p, r);
5831 bfd_put_32 (abfd, MTLR_R0, p);
5832 p = p + 4;
5833 if (r == 29)
5834 {
5835 p = restgpr0 (abfd, p, 30);
5836 p = restgpr0 (abfd, p, 31);
5837 }
5838 bfd_put_32 (abfd, BLR, p);
5839 return p + 4;
5840}
5841
5842static bfd_byte *
5843savegpr1 (bfd *abfd, bfd_byte *p, int r)
5844{
5845 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5846 return p + 4;
5847}
5848
5849static bfd_byte *
5850savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
5851{
5852 p = savegpr1 (abfd, p, r);
5853 bfd_put_32 (abfd, BLR, p);
5854 return p + 4;
5855}
5856
5857static bfd_byte *
5858restgpr1 (bfd *abfd, bfd_byte *p, int r)
5859{
5860 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5861 return p + 4;
5862}
5863
5864static bfd_byte *
5865restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
5866{
5867 p = restgpr1 (abfd, p, r);
5868 bfd_put_32 (abfd, BLR, p);
5869 return p + 4;
5870}
5871
5872static bfd_byte *
5873savefpr (bfd *abfd, bfd_byte *p, int r)
5874{
5875 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5876 return p + 4;
5877}
5878
5879static bfd_byte *
5880savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
5881{
5882 p = savefpr (abfd, p, r);
5883 bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
5884 p = p + 4;
5885 bfd_put_32 (abfd, BLR, p);
5886 return p + 4;
5887}
5888
5889static bfd_byte *
5890restfpr (bfd *abfd, bfd_byte *p, int r)
5891{
5892 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5893 return p + 4;
5894}
5895
5896static bfd_byte *
5897restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
5898{
5899 bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
5900 p = p + 4;
5901 p = restfpr (abfd, p, r);
5902 bfd_put_32 (abfd, MTLR_R0, p);
5903 p = p + 4;
5904 if (r == 29)
5905 {
5906 p = restfpr (abfd, p, 30);
5907 p = restfpr (abfd, p, 31);
5908 }
5909 bfd_put_32 (abfd, BLR, p);
5910 return p + 4;
5911}
5912
5913static bfd_byte *
5914savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
5915{
5916 p = savefpr (abfd, p, r);
5917 bfd_put_32 (abfd, BLR, p);
5918 return p + 4;
5919}
5920
5921static bfd_byte *
5922restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
5923{
5924 p = restfpr (abfd, p, r);
5925 bfd_put_32 (abfd, BLR, p);
5926 return p + 4;
5927}
5928
5929static bfd_byte *
5930savevr (bfd *abfd, bfd_byte *p, int r)
5931{
5932 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
5933 p = p + 4;
5934 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
5935 return p + 4;
5936}
5937
5938static bfd_byte *
5939savevr_tail (bfd *abfd, bfd_byte *p, int r)
5940{
5941 p = savevr (abfd, p, r);
5942 bfd_put_32 (abfd, BLR, p);
5943 return p + 4;
5944}
5945
5946static bfd_byte *
5947restvr (bfd *abfd, bfd_byte *p, int r)
5948{
5949 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
5950 p = p + 4;
5951 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
5952 return p + 4;
5953}
5954
5955static bfd_byte *
5956restvr_tail (bfd *abfd, bfd_byte *p, int r)
5957{
5958 p = restvr (abfd, p, r);
5959 bfd_put_32 (abfd, BLR, p);
5960 return p + 4;
5961}
5962
e86ce104
AM		 5963/* Called via elf_link_hash_traverse to transfer dynamic linking
5964 information on function code symbol entries to their corresponding
5965 function descriptor symbol entries. */
deb0e272 5966
b34976b6 5967static bfd_boolean
4ce794b7 5968func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
5bd4f169 5969{
e86ce104 5970 struct bfd_link_info *info;
65f38f15 5971 struct ppc_link_hash_table *htab;
411e1bfb 5972 struct plt_entry *ent;
50bc7936
AM		 5973 struct ppc_link_hash_entry *fh;
5974 struct ppc_link_hash_entry *fdh;
5975 bfd_boolean force_local;
5bd4f169 5976
50bc7936
AM		 5977 fh = (struct ppc_link_hash_entry *) h;
5978 if (fh->elf.root.type == bfd_link_hash_indirect)
b34976b6 5979 return TRUE;
e86ce104 5980
50bc7936
AM		 5981 if (fh->elf.root.type == bfd_link_hash_warning)
5982 fh = (struct ppc_link_hash_entry *) fh->elf.root.u.i.link;
e92d460e 5983
4ce794b7 5984 info = inf;
65f38f15 5985 htab = ppc_hash_table (info);
5bd4f169 5986
c09bdfe5
AM		 5987 /* Resolve undefined references to dot-symbols as the value
5988 in the function descriptor, if we have one in a regular object.
5989 This is to satisfy cases like ".quad .foo". Calls to functions
5990 in dynamic objects are handled elsewhere. */
5991 if (fh->elf.root.type == bfd_link_hash_undefweak
5992 && fh->was_undefined
5993 && (fh->oh->elf.root.type == bfd_link_hash_defined
5994 || fh->oh->elf.root.type == bfd_link_hash_defweak)
5995 && get_opd_info (fh->oh->elf.root.u.def.section) != NULL
5996 && opd_entry_value (fh->oh->elf.root.u.def.section,
5997 fh->oh->elf.root.u.def.value,
5998 &fh->elf.root.u.def.section,
5999 &fh->elf.root.u.def.value) != (bfd_vma) -1)
6000 {
6001 fh->elf.root.type = fh->oh->elf.root.type;
f5385ebf 6002 fh->elf.forced_local = 1;
2b953679
AM		 6003 fh->elf.def_regular = fh->oh->elf.def_regular;
6004 fh->elf.def_dynamic = fh->oh->elf.def_dynamic;
c09bdfe5
AM		 6005 }
6006
e86ce104
AM		 6007 /* If this is a function code symbol, transfer dynamic linking
6008 information to the function descriptor symbol. */
50bc7936 6009 if (!fh->is_func)
b34976b6 6010 return TRUE;
e86ce104 6011
50bc7936 6012 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
411e1bfb
AM		 6013 if (ent->plt.refcount > 0)
6014 break;
50bc7936
AM		 6015 if (ent == NULL
6016 || fh->elf.root.root.string[0] != '.'
6017 || fh->elf.root.root.string[1] == '\0')
6018 return TRUE;
5bd4f169 6019
50bc7936
AM		 6020 /* Find the corresponding function descriptor symbol. Create it
6021 as undefined if necessary. */
5bd4f169 6022
50bc7936
AM		 6023 fdh = get_fdh (fh, htab);
6024 if (fdh != NULL)
6025 while (fdh->elf.root.type == bfd_link_hash_indirect
6026 || fdh->elf.root.type == bfd_link_hash_warning)
6027 fdh = (struct ppc_link_hash_entry *) fdh->elf.root.u.i.link;
5bd4f169 6028
50bc7936 6029 if (fdh == NULL
df131623 6030 && !info->executable
50bc7936
AM		 6031 && (fh->elf.root.type == bfd_link_hash_undefined
6032 || fh->elf.root.type == bfd_link_hash_undefweak))
6033 {
908b32fc 6034 fdh = make_fdh (info, fh);
bb700d78
AM		 6035 if (fdh == NULL)
6036 return FALSE;
50bc7936 6037 }
648cca2c 6038
908b32fc 6039 /* Fake function descriptors are made undefweak. If the function
433817dd
AM		 6040 code symbol is strong undefined, make the fake sym the same.
6041 If the function code symbol is defined, then force the fake
6042 descriptor local; We can't support overriding of symbols in a
6043 shared library on a fake descriptor. */
908b32fc
AM		 6044
6045 if (fdh != NULL
6046 && fdh->fake
433817dd 6047 && fdh->elf.root.type == bfd_link_hash_undefweak)
908b32fc 6048 {
433817dd
AM		 6049 if (fh->elf.root.type == bfd_link_hash_undefined)
6050 {
6051 fdh->elf.root.type = bfd_link_hash_undefined;
6052 bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6053 }
6054 else if (fh->elf.root.type == bfd_link_hash_defined
6055 || fh->elf.root.type == bfd_link_hash_defweak)
6056 {
6057 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6058 }
908b32fc
AM		 6059 }
6060
50bc7936 6061 if (fdh != NULL
f5385ebf 6062 && !fdh->elf.forced_local
df131623 6063 && (!info->executable
f5385ebf
AM		 6064 || fdh->elf.def_dynamic
6065 || fdh->elf.ref_dynamic
50bc7936
AM		 6066 || (fdh->elf.root.type == bfd_link_hash_undefweak
6067 && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6068 {
6069 if (fdh->elf.dynindx == -1)
c152c796 6070 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
50bc7936 6071 return FALSE;
f5385ebf
AM		 6072 fdh->elf.ref_regular |= fh->elf.ref_regular;
6073 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6074 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6075 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
50bc7936 6076 if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
e86ce104 6077 {
40d16e0b 6078 move_plt_plist (fh, fdh);
f5385ebf 6079 fdh->elf.needs_plt = 1;
e86ce104 6080 }
50bc7936 6081 fdh->is_func_descriptor = 1;
34814b9f
AM		 6082 fdh->oh = fh;
6083 fh->oh = fdh;
e86ce104
AM		 6084 }
6085
50bc7936
AM		 6086 /* Now that the info is on the function descriptor, clear the
6087 function code sym info. Any function code syms for which we
6088 don't have a definition in a regular file, we force local.
6089 This prevents a shared library from exporting syms that have
6090 been imported from another library. Function code syms that
6091 are really in the library we must leave global to prevent the
6092 linker dragging in a definition from a static library. */
93f3fa99
AM		 6093 force_local = (!fh->elf.def_regular
6094 || fdh == NULL
6095 || !fdh->elf.def_regular
6096 || fdh->elf.forced_local);
50bc7936
AM		 6097 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6098
b34976b6 6099 return TRUE;
e86ce104 6100}
40b8271b 6101
e86ce104 6102/* Called near the start of bfd_elf_size_dynamic_sections. We use
82bd7b59
AM		 6103 this hook to a) provide some gcc support functions, and b) transfer
6104 dynamic linking information gathered so far on function code symbol
6105 entries, to their corresponding function descriptor symbol entries. */
deb0e272 6106
b34976b6 6107static bfd_boolean
4ce794b7
AM		 6108ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6109 struct bfd_link_info *info)
e86ce104
AM		 6110{
6111 struct ppc_link_hash_table *htab;
82bd7b59 6112 unsigned int i;
deb0e272
AM		 6113 const struct sfpr_def_parms funcs[] =
6114 {
6115 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6116 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6117 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6118 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6119 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6120 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6121 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6122 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6123 { "._savef", 14, 31, savefpr, savefpr1_tail },
6124 { "._restf", 14, 31, restfpr, restfpr1_tail },
6125 { "_savevr_", 20, 31, savevr, savevr_tail },
6126 { "_restvr_", 20, 31, restvr, restvr_tail }
6127 };
e86ce104
AM		 6128
6129 htab = ppc_hash_table (info);
82bd7b59
AM		 6130 if (htab->sfpr == NULL)
6131 /* We don't have any relocs. */
b34976b6 6132 return TRUE;
82bd7b59 6133
deb0e272
AM		 6134 /* Provide any missing _save* and _rest* functions. */
6135 htab->sfpr->size = 0;
6136 for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6137 if (!sfpr_define (info, &funcs[i]))
6138 return FALSE;
82bd7b59 6139
4ce794b7 6140 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
805fc799 6141
eea6121a 6142 if (htab->sfpr->size == 0)
8423293d 6143 htab->sfpr->flags |= SEC_EXCLUDE;
82bd7b59 6144
b34976b6 6145 return TRUE;
e86ce104
AM		 6146}
6147
6148/* Adjust a symbol defined by a dynamic object and referenced by a
6149 regular object. The current definition is in some section of the
6150 dynamic object, but we're not including those sections. We have to
6151 change the definition to something the rest of the link can
6152 understand. */
6153
b34976b6 6154static bfd_boolean
4ce794b7
AM		 6155ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6156 struct elf_link_hash_entry *h)
e86ce104
AM		 6157{
6158 struct ppc_link_hash_table *htab;
e86ce104 6159 asection *s;
e86ce104
AM		 6160
6161 htab = ppc_hash_table (info);
6162
6163 /* Deal with function syms. */
6164 if (h->type == STT_FUNC
e054468f 6165 || h->type == STT_GNU_IFUNC
f5385ebf 6166 || h->needs_plt)
e86ce104
AM		 6167 {
6168 /* Clear procedure linkage table information for any symbol that
6169 won't need a .plt entry. */
411e1bfb
AM		 6170 struct plt_entry *ent;
6171 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6172 if (ent->plt.refcount > 0)
6173 break;
8387904d 6174 if (ent == NULL
e054468f
AM		 6175 || (h->type != STT_GNU_IFUNC
6176 && (SYMBOL_CALLS_LOCAL (info, h)
6177 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6178 && h->root.type == bfd_link_hash_undefweak))))
40b8271b 6179 {
411e1bfb 6180 h->plt.plist = NULL;
f5385ebf 6181 h->needs_plt = 0;
40b8271b 6182 }
5bd4f169 6183 }
bbd7ec4a 6184 else
411e1bfb 6185 h->plt.plist = NULL;
5bd4f169
AM		 6186
6187 /* If this is a weak symbol, and there is a real definition, the
6188 processor independent code will have arranged for us to see the
6189 real definition first, and we can just use the same value. */
f6e332e6 6190 if (h->u.weakdef != NULL)
5bd4f169 6191 {
f6e332e6
AM		 6192 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6193 || h->u.weakdef->root.type == bfd_link_hash_defweak);
6194 h->root.u.def.section = h->u.weakdef->root.u.def.section;
6195 h->root.u.def.value = h->u.weakdef->root.u.def.value;
a23b6845 6196 if (ELIMINATE_COPY_RELOCS)
f6e332e6 6197 h->non_got_ref = h->u.weakdef->non_got_ref;
b34976b6 6198 return TRUE;
5bd4f169
AM		 6199 }
6200
5bd4f169
AM		 6201 /* If we are creating a shared library, we must presume that the
6202 only references to the symbol are via the global offset table.
6203 For such cases we need not do anything here; the relocations will
6204 be handled correctly by relocate_section. */
6205 if (info->shared)
b34976b6 6206 return TRUE;
5bd4f169 6207
65f38f15
AM		 6208 /* If there are no references to this symbol that do not use the
6209 GOT, we don't need to generate a copy reloc. */
f5385ebf 6210 if (!h->non_got_ref)
b34976b6 6211 return TRUE;
65f38f15 6212
b186458a
JJ		 6213 /* Don't generate a copy reloc for symbols defined in the executable. */
6214 if (!h->def_dynamic || !h->ref_regular || h->def_regular)
6215 return TRUE;
6216
f4656909 6217 if (ELIMINATE_COPY_RELOCS)
65f38f15 6218 {
f4656909
AM		 6219 struct ppc_link_hash_entry * eh;
6220 struct ppc_dyn_relocs *p;
65f38f15 6221
f4656909
AM		 6222 eh = (struct ppc_link_hash_entry *) h;
6223 for (p = eh->dyn_relocs; p != NULL; p = p->next)
6224 {
6225 s = p->sec->output_section;
6226 if (s != NULL && (s->flags & SEC_READONLY) != 0)
6227 break;
6228 }
6229
6230 /* If we didn't find any dynamic relocs in read-only sections, then
6231 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
6232 if (p == NULL)
6233 {
f5385ebf 6234 h->non_got_ref = 0;
f4656909
AM		 6235 return TRUE;
6236 }
65f38f15
AM		 6237 }
6238
5d35169e 6239 if (h->plt.plist != NULL)
97b639ba
AM		 6240 {
6241 /* We should never get here, but unfortunately there are versions
6242 of gcc out there that improperly (for this ABI) put initialized
6243 function pointers, vtable refs and suchlike in read-only
6244 sections. Allow them to proceed, but warn that this might
6245 break at runtime. */
6246 (*_bfd_error_handler)
6247 (_("copy reloc against `%s' requires lazy plt linking; "
6248 "avoid setting LD_BIND_NOW=1 or upgrade gcc"),
6249 h->root.root.string);
6250 }
5d35169e
AM		 6251
6252 /* This is a reference to a symbol defined by a dynamic object which
6253 is not a function. */
6254
909272ee
AM		 6255 if (h->size == 0)
6256 {
6257 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
6258 h->root.root.string);
6259 return TRUE;
6260 }
6261
5bd4f169
AM		 6262 /* We must allocate the symbol in our .dynbss section, which will
6263 become part of the .bss section of the executable. There will be
6264 an entry for this symbol in the .dynsym section. The dynamic
6265 object will contain position independent code, so all references
6266 from the dynamic object to this symbol will go through the global
6267 offset table. The dynamic linker will use the .dynsym entry to
6268 determine the address it must put in the global offset table, so
6269 both the dynamic object and the regular object will refer to the
6270 same memory location for the variable. */
5bd4f169 6271
04c9666a
AM		 6272 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
6273 to copy the initial value out of the dynamic object and into the
5bd4f169
AM		 6274 runtime process image. We need to remember the offset into the
6275 .rela.bss section we are going to use. */
6276 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
6277 {
eea6121a 6278 htab->relbss->size += sizeof (Elf64_External_Rela);
f5385ebf 6279 h->needs_copy = 1;
5bd4f169
AM		 6280 }
6281
4ce794b7 6282 s = htab->dynbss;
5bd4f169 6283
027297b7 6284 return _bfd_elf_adjust_dynamic_copy (h, s);
5bd4f169
AM		 6285}
6286
e86ce104
AM		 6287/* If given a function descriptor symbol, hide both the function code
6288 sym and the descriptor. */
6289static void
4ce794b7
AM		 6290ppc64_elf_hide_symbol (struct bfd_link_info *info,
6291 struct elf_link_hash_entry *h,
6292 bfd_boolean force_local)
e86ce104 6293{
34814b9f 6294 struct ppc_link_hash_entry *eh;
e86ce104
AM		 6295 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
6296
34814b9f
AM		 6297 eh = (struct ppc_link_hash_entry *) h;
6298 if (eh->is_func_descriptor)
e86ce104 6299 {
34814b9f 6300 struct ppc_link_hash_entry *fh = eh->oh;
e86ce104 6301
721956f4 6302 if (fh == NULL)
d1329ca3
AM		 6303 {
6304 const char *p, *q;
6305 struct ppc_link_hash_table *htab;
6306 char save;
6307
6308 /* We aren't supposed to use alloca in BFD because on
6309 systems which do not have alloca the version in libiberty
6310 calls xmalloc, which might cause the program to crash
6311 when it runs out of memory. This function doesn't have a
6312 return status, so there's no way to gracefully return an
6313 error. So cheat. We know that string[-1] can be safely
34814b9f
AM		 6314 accessed; It's either a string in an ELF string table,
6315 or allocated in an objalloc structure. */
d1329ca3 6316
34814b9f 6317 p = eh->elf.root.root.string - 1;
d1329ca3
AM		 6318 save = *p;
6319 *(char *) p = '.';
6320 htab = ppc_hash_table (info);
34814b9f
AM		 6321 fh = (struct ppc_link_hash_entry *)
6322 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
d1329ca3
AM		 6323 *(char *) p = save;
6324
6325 /* Unfortunately, if it so happens that the string we were
6326 looking for was allocated immediately before this string,
6327 then we overwrote the string terminator. That's the only
6328 reason the lookup should fail. */
6329 if (fh == NULL)
6330 {
34814b9f
AM		 6331 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
6332 while (q >= eh->elf.root.root.string && *q == *p)
d1329ca3 6333 --q, --p;
34814b9f
AM		 6334 if (q < eh->elf.root.root.string && *p == '.')
6335 fh = (struct ppc_link_hash_entry *)
6336 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
d1329ca3
AM		 6337 }
6338 if (fh != NULL)
6339 {
34814b9f
AM		 6340 eh->oh = fh;
6341 fh->oh = eh;
d1329ca3
AM		 6342 }
6343 }
e86ce104 6344 if (fh != NULL)
34814b9f 6345 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
e86ce104
AM		 6346 }
6347}
6348
411e1bfb 6349static bfd_boolean
8843416a
AM		 6350get_sym_h (struct elf_link_hash_entry **hp,
6351 Elf_Internal_Sym **symp,
6352 asection **symsecp,
6353 char **tls_maskp,
6354 Elf_Internal_Sym **locsymsp,
6355 unsigned long r_symndx,
6356 bfd *ibfd)
411e1bfb 6357{
0ffa91dd 6358 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
411e1bfb
AM		 6359
6360 if (r_symndx >= symtab_hdr->sh_info)
6361 {
6362 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
6363 struct elf_link_hash_entry *h;
6364
6365 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6366 while (h->root.type == bfd_link_hash_indirect
6367 || h->root.type == bfd_link_hash_warning)
6368 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6369
6370 if (hp != NULL)
6371 *hp = h;
6372
6373 if (symp != NULL)
6374 *symp = NULL;
6375
6376 if (symsecp != NULL)
6377 {
6378 asection *symsec = NULL;
6379 if (h->root.type == bfd_link_hash_defined
6380 || h->root.type == bfd_link_hash_defweak)
6381 symsec = h->root.u.def.section;
6382 *symsecp = symsec;
6383 }
6384
e7b938ca 6385 if (tls_maskp != NULL)
411e1bfb
AM		 6386 {
6387 struct ppc_link_hash_entry *eh;
6388
6389 eh = (struct ppc_link_hash_entry *) h;
e7b938ca 6390 *tls_maskp = &eh->tls_mask;
411e1bfb
AM		 6391 }
6392 }
6393 else
6394 {
6395 Elf_Internal_Sym *sym;
6396 Elf_Internal_Sym *locsyms = *locsymsp;
6397
6398 if (locsyms == NULL)
6399 {
6400 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
6401 if (locsyms == NULL)
6402 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
6403 symtab_hdr->sh_info,
6404 0, NULL, NULL, NULL);
6405 if (locsyms == NULL)
6406 return FALSE;
6407 *locsymsp = locsyms;
6408 }
6409 sym = locsyms + r_symndx;
6410
6411 if (hp != NULL)
6412 *hp = NULL;
6413
6414 if (symp != NULL)
6415 *symp = sym;
6416
6417 if (symsecp != NULL)
cb33740c 6418 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
411e1bfb 6419
e7b938ca 6420 if (tls_maskp != NULL)
411e1bfb
AM		 6421 {
6422 struct got_entry **lgot_ents;
e7b938ca 6423 char *tls_mask;
411e1bfb 6424
e7b938ca 6425 tls_mask = NULL;
411e1bfb
AM		 6426 lgot_ents = elf_local_got_ents (ibfd);
6427 if (lgot_ents != NULL)
6428 {
e054468f
AM		 6429 struct plt_entry **local_plt = (struct plt_entry **)
6430 (lgot_ents + symtab_hdr->sh_info);
6431 char *lgot_masks = (char *)
6432 (local_plt + symtab_hdr->sh_info);
e7b938ca 6433 tls_mask = &lgot_masks[r_symndx];
411e1bfb 6434 }
e7b938ca 6435 *tls_maskp = tls_mask;
411e1bfb
AM		 6436 }
6437 }
6438 return TRUE;
6439}
6440
e7b938ca 6441/* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
951fd09b 6442 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
ad8e1ba5 6443 type suitable for optimization, and 1 otherwise. */
951fd09b
AM		 6444
6445static int
3a71aa26
AM		 6446get_tls_mask (char **tls_maskp,
6447 unsigned long *toc_symndx,
6448 bfd_vma *toc_addend,
0d4792f7 6449 Elf_Internal_Sym **locsymsp,
3a71aa26
AM		 6450 const Elf_Internal_Rela *rel,
6451 bfd *ibfd)
411e1bfb
AM		 6452{
6453 unsigned long r_symndx;
0d4792f7 6454 int next_r;
411e1bfb
AM		 6455 struct elf_link_hash_entry *h;
6456 Elf_Internal_Sym *sym;
6457 asection *sec;
6458 bfd_vma off;
6459
6460 r_symndx = ELF64_R_SYM (rel->r_info);
e7b938ca 6461 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
951fd09b 6462 return 0;
411e1bfb 6463
e7b938ca 6464 if ((*tls_maskp != NULL && **tls_maskp != 0)
411e1bfb 6465 || sec == NULL
7c8fe5c4 6466 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
951fd09b 6467 return 1;
411e1bfb
AM		 6468
6469 /* Look inside a TOC section too. */
6470 if (h != NULL)
6471 {
6472 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
6473 off = h->root.u.def.value;
6474 }
6475 else
6476 off = sym->st_value;
6477 off += rel->r_addend;
6478 BFD_ASSERT (off % 8 == 0);
3a71aa26
AM		 6479 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
6480 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
0d4792f7
AM		 6481 if (toc_symndx != NULL)
6482 *toc_symndx = r_symndx;
3a71aa26
AM		 6483 if (toc_addend != NULL)
6484 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
6485 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6486 return 0;
0d4792f7
AM		 6487 if ((h == NULL
6488 || ((h->root.type == bfd_link_hash_defined
6489 || h->root.type == bfd_link_hash_defweak)
f5385ebf 6490 && !h->def_dynamic))
0d4792f7
AM		 6491 && (next_r == -1 || next_r == -2))
6492 return 1 - next_r;
951fd09b 6493 return 1;
411e1bfb
AM		 6494}
6495
754021d0 6496/* Adjust all global syms defined in opd sections. In gcc generated
8387904d 6497 code for the old ABI, these will already have been done. */
754021d0
AM		 6498
6499static bfd_boolean
6500adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
6501{
6502 struct ppc_link_hash_entry *eh;
6503 asection *sym_sec;
74f0fb50 6504 struct _opd_sec_data *opd;
754021d0
AM		 6505
6506 if (h->root.type == bfd_link_hash_indirect)
6507 return TRUE;
6508
6509 if (h->root.type == bfd_link_hash_warning)
6510 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6511
6512 if (h->root.type != bfd_link_hash_defined
6513 && h->root.type != bfd_link_hash_defweak)
6514 return TRUE;
6515
6516 eh = (struct ppc_link_hash_entry *) h;
6517 if (eh->adjust_done)
6518 return TRUE;
6519
6520 sym_sec = eh->elf.root.u.def.section;
74f0fb50
AM		 6521 opd = get_opd_info (sym_sec);
6522 if (opd != NULL && opd->adjust != NULL)
754021d0 6523 {
74f0fb50 6524 long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
4025353c
AM		 6525 if (adjust == -1)
6526 {
6527 /* This entry has been deleted. */
b3fac117 6528 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
81688140
AM		 6529 if (dsec == NULL)
6530 {
6531 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
6532 if (elf_discarded_section (dsec))
6533 {
b3fac117 6534 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
81688140
AM		 6535 break;
6536 }
6537 }
4025353c 6538 eh->elf.root.u.def.value = 0;
81688140 6539 eh->elf.root.u.def.section = dsec;
4025353c
AM		 6540 }
6541 else
6542 eh->elf.root.u.def.value += adjust;
754021d0
AM		 6543 eh->adjust_done = 1;
6544 }
6545 return TRUE;
6546}
6547
8c1d1bb8
AM		 6548/* Handles decrementing dynamic reloc counts for the reloc specified by
6549 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM_SEC
6550 have already been determined. */
6551
6552static bfd_boolean
6553dec_dynrel_count (bfd_vma r_info,
6554 asection *sec,
6555 struct bfd_link_info *info,
6556 Elf_Internal_Sym **local_syms,
6557 struct elf_link_hash_entry *h,
6558 asection *sym_sec)
6559{
6560 enum elf_ppc64_reloc_type r_type;
6561 struct ppc_dyn_relocs *p;
6562 struct ppc_dyn_relocs **pp;
6563
6564 /* Can this reloc be dynamic? This switch, and later tests here
6565 should be kept in sync with the code in check_relocs. */
6566 r_type = ELF64_R_TYPE (r_info);
6567 switch (r_type)
6568 {
6569 default:
6570 return TRUE;
6571
6572 case R_PPC64_TPREL16:
6573 case R_PPC64_TPREL16_LO:
6574 case R_PPC64_TPREL16_HI:
6575 case R_PPC64_TPREL16_HA:
6576 case R_PPC64_TPREL16_DS:
6577 case R_PPC64_TPREL16_LO_DS:
6578 case R_PPC64_TPREL16_HIGHER:
6579 case R_PPC64_TPREL16_HIGHERA:
6580 case R_PPC64_TPREL16_HIGHEST:
6581 case R_PPC64_TPREL16_HIGHESTA:
6582 if (!info->shared)
6583 return TRUE;
6584
6585 case R_PPC64_TPREL64:
6586 case R_PPC64_DTPMOD64:
6587 case R_PPC64_DTPREL64:
6588 case R_PPC64_ADDR64:
6589 case R_PPC64_REL30:
6590 case R_PPC64_REL32:
6591 case R_PPC64_REL64:
6592 case R_PPC64_ADDR14:
6593 case R_PPC64_ADDR14_BRNTAKEN:
6594 case R_PPC64_ADDR14_BRTAKEN:
6595 case R_PPC64_ADDR16:
6596 case R_PPC64_ADDR16_DS:
6597 case R_PPC64_ADDR16_HA:
6598 case R_PPC64_ADDR16_HI:
6599 case R_PPC64_ADDR16_HIGHER:
6600 case R_PPC64_ADDR16_HIGHERA:
6601 case R_PPC64_ADDR16_HIGHEST:
6602 case R_PPC64_ADDR16_HIGHESTA:
6603 case R_PPC64_ADDR16_LO:
6604 case R_PPC64_ADDR16_LO_DS:
6605 case R_PPC64_ADDR24:
6606 case R_PPC64_ADDR32:
6607 case R_PPC64_UADDR16:
6608 case R_PPC64_UADDR32:
6609 case R_PPC64_UADDR64:
6610 case R_PPC64_TOC:
6611 break;
6612 }
6613
6614 if (local_syms != NULL)
6615 {
6616 unsigned long r_symndx;
6617 Elf_Internal_Sym *sym;
6618 bfd *ibfd = sec->owner;
6619
6620 r_symndx = ELF64_R_SYM (r_info);
6621 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
6622 return FALSE;
6623 }
6624
6625 if ((info->shared
1d483afe 6626 && (must_be_dyn_reloc (info, r_type)
8c1d1bb8
AM		 6627 || (h != NULL
6628 && (!info->symbolic
6629 || h->root.type == bfd_link_hash_defweak
6630 || !h->def_regular))))
6631 || (ELIMINATE_COPY_RELOCS
6632 && !info->shared
6633 && h != NULL
6634 && (h->root.type == bfd_link_hash_defweak
6635 || !h->def_regular)))
6636 ;
6637 else
6638 return TRUE;
6639
6640 if (h != NULL)
6641 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
8c1d1bb8 6642 else
6edfbbad 6643 {
60124e18
AM		 6644 if (sym_sec != NULL)
6645 {
6646 void *vpp = &elf_section_data (sym_sec)->local_dynrel;
6647 pp = (struct ppc_dyn_relocs **) vpp;
6648 }
6649 else
6650 {
6651 void *vpp = &elf_section_data (sec)->local_dynrel;
6652 pp = (struct ppc_dyn_relocs **) vpp;
6653 }
6654
6655 /* elf_gc_sweep may have already removed all dyn relocs associated
6656 with local syms for a given section. Don't report a dynreloc
6657 miscount. */
6658 if (*pp == NULL)
6659 return TRUE;
6edfbbad 6660 }
8c1d1bb8
AM		 6661
6662 while ((p = *pp) != NULL)
6663 {
6664 if (p->sec == sec)
6665 {
1d483afe 6666 if (!must_be_dyn_reloc (info, r_type))
8c1d1bb8
AM		 6667 p->pc_count -= 1;
6668 p->count -= 1;
6669 if (p->count == 0)
6670 *pp = p->next;
6671 return TRUE;
6672 }
6673 pp = &p->next;
6674 }
6675
6676 (*_bfd_error_handler) (_("dynreloc miscount for %B, section %A"),
6677 sec->owner, sec);
6678 bfd_set_error (bfd_error_bad_value);
6679 return FALSE;
6680}
6681
754021d0
AM		 6682/* Remove unused Official Procedure Descriptor entries. Currently we
6683 only remove those associated with functions in discarded link-once
6684 sections, or weakly defined functions that have been overridden. It
6685 would be possible to remove many more entries for statically linked
6686 applications. */
6687
b34976b6 6688bfd_boolean
3f764659
JJ		 6689ppc64_elf_edit_opd (bfd *obfd, struct bfd_link_info *info,
6690 bfd_boolean non_overlapping)
1e2f5b6e
AM		 6691{
6692 bfd *ibfd;
754021d0 6693 bfd_boolean some_edited = FALSE;
3f764659 6694 asection *need_pad = NULL;
1e2f5b6e 6695
411e1bfb 6696 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1e2f5b6e
AM		 6697 {
6698 asection *sec;
6699 Elf_Internal_Rela *relstart, *rel, *relend;
6700 Elf_Internal_Shdr *symtab_hdr;
6cdc0ccc 6701 Elf_Internal_Sym *local_syms;
1e2f5b6e
AM		 6702 struct elf_link_hash_entry **sym_hashes;
6703 bfd_vma offset;
74f0fb50 6704 struct _opd_sec_data *opd;
3f764659
JJ		 6705 bfd_boolean need_edit, add_aux_fields;
6706 bfd_size_type cnt_16b = 0;
1e2f5b6e
AM		 6707
6708 sec = bfd_get_section_by_name (ibfd, ".opd");
46de2a7c 6709 if (sec == NULL || sec->size == 0)
1e2f5b6e
AM		 6710 continue;
6711
4b85d634
AM		 6712 if (sec->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
6713 continue;
6714
1e2f5b6e
AM		 6715 if (sec->output_section == bfd_abs_section_ptr)
6716 continue;
6717
6718 /* Look through the section relocs. */
6719 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
6720 continue;
6721
6cdc0ccc 6722 local_syms = NULL;
0ffa91dd 6723 symtab_hdr = &elf_symtab_hdr (ibfd);
1e2f5b6e
AM		 6724 sym_hashes = elf_sym_hashes (ibfd);
6725
6726 /* Read the relocations. */
4ce794b7 6727 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
45d6a902 6728 info->keep_memory);
1e2f5b6e 6729 if (relstart == NULL)
b34976b6 6730 return FALSE;
1e2f5b6e
AM		 6731
6732 /* First run through the relocs to check they are sane, and to
6733 determine whether we need to edit this opd section. */
b34976b6 6734 need_edit = FALSE;
3f764659 6735 need_pad = sec;
1e2f5b6e
AM		 6736 offset = 0;
6737 relend = relstart + sec->reloc_count;
50bc7936 6738 for (rel = relstart; rel < relend; )
1e2f5b6e 6739 {
04c9666a 6740 enum elf_ppc64_reloc_type r_type;
1e2f5b6e
AM		 6741 unsigned long r_symndx;
6742 asection *sym_sec;
6743 struct elf_link_hash_entry *h;
6744 Elf_Internal_Sym *sym;
6745
3f764659 6746 /* .opd contains a regular array of 16 or 24 byte entries. We're
1e2f5b6e
AM		 6747 only interested in the reloc pointing to a function entry
6748 point. */
50bc7936
AM		 6749 if (rel->r_offset != offset
6750 || rel + 1 >= relend
6751 || (rel + 1)->r_offset != offset + 8)
1e2f5b6e
AM		 6752 {
6753 /* If someone messes with .opd alignment then after a
6754 "ld -r" we might have padding in the middle of .opd.
6755 Also, there's nothing to prevent someone putting
6756 something silly in .opd with the assembler. No .opd
b34976b6 6757 optimization for them! */
3f764659 6758 broken_opd:
1e2f5b6e 6759 (*_bfd_error_handler)
d003868e 6760 (_("%B: .opd is not a regular array of opd entries"), ibfd);
b34976b6 6761 need_edit = FALSE;
1e2f5b6e
AM		 6762 break;
6763 }
6764
50bc7936
AM		 6765 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
6766 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
6767 {
6768 (*_bfd_error_handler)
d003868e
AM		 6769 (_("%B: unexpected reloc type %u in .opd section"),
6770 ibfd, r_type);
50bc7936
AM		 6771 need_edit = FALSE;
6772 break;
6773 }
6774
1e2f5b6e 6775 r_symndx = ELF64_R_SYM (rel->r_info);
411e1bfb
AM		 6776 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
6777 r_symndx, ibfd))
50bc7936 6778 goto error_ret;
1e2f5b6e
AM		 6779
6780 if (sym_sec == NULL || sym_sec->owner == NULL)
6781 {
411e1bfb
AM		 6782 const char *sym_name;
6783 if (h != NULL)
6784 sym_name = h->root.root.string;
6785 else
26c61ae5
L		 6786 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
6787 sym_sec);
411e1bfb 6788
1e2f5b6e 6789 (*_bfd_error_handler)
d003868e
AM		 6790 (_("%B: undefined sym `%s' in .opd section"),
6791 ibfd, sym_name);
b34976b6 6792 need_edit = FALSE;
1e2f5b6e
AM		 6793 break;
6794 }
6795
51020317
AM		 6796 /* opd entries are always for functions defined in the
6797 current input bfd. If the symbol isn't defined in the
6798 input bfd, then we won't be using the function in this
6799 bfd; It must be defined in a linkonce section in another
6800 bfd, or is weak. It's also possible that we are
6801 discarding the function due to a linker script /DISCARD/,
6802 which we test for via the output_section. */
6803 if (sym_sec->owner != ibfd
6804 || sym_sec->output_section == bfd_abs_section_ptr)
b34976b6 6805 need_edit = TRUE;
1e2f5b6e 6806
50bc7936 6807 rel += 2;
3f764659
JJ		 6808 if (rel == relend
6809 || (rel + 1 == relend && rel->r_offset == offset + 16))
6810 {
6811 if (sec->size == offset + 24)
6812 {
6813 need_pad = NULL;
6814 break;
6815 }
6816 if (rel == relend && sec->size == offset + 16)
6817 {
6818 cnt_16b++;
6819 break;
6820 }
6821 goto broken_opd;
6822 }
6823
6824 if (rel->r_offset == offset + 24)
6825 offset += 24;
6826 else if (rel->r_offset != offset + 16)
6827 goto broken_opd;
6828 else if (rel + 1 < relend
6829 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
6830 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
6831 {
6832 offset += 16;
6833 cnt_16b++;
6834 }
6835 else if (rel + 2 < relend
6836 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
6837 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
6838 {
6839 offset += 24;
6840 rel += 1;
6841 }
6842 else
6843 goto broken_opd;
1e2f5b6e
AM		 6844 }
6845
3f764659
JJ		 6846 add_aux_fields = non_overlapping && cnt_16b > 0;
6847
6848 if (need_edit || add_aux_fields)
1e2f5b6e
AM		 6849 {
6850 Elf_Internal_Rela *write_rel;
6851 bfd_byte *rptr, *wptr;
983bddc8 6852 bfd_byte *new_contents;
b34976b6 6853 bfd_boolean skip;
3f764659 6854 long opd_ent_size;
74f0fb50
AM		 6855 bfd_size_type amt;
6856
983bddc8 6857 new_contents = NULL;
74f0fb50
AM		 6858 amt = sec->size * sizeof (long) / 8;
6859 opd = &ppc64_elf_section_data (sec)->u.opd;
6860 opd->adjust = bfd_zalloc (obfd, amt);
6861 if (opd->adjust == NULL)
6862 return FALSE;
6863 ppc64_elf_section_data (sec)->sec_type = sec_opd;
1e2f5b6e
AM		 6864
6865 /* This seems a waste of time as input .opd sections are all
6866 zeros as generated by gcc, but I suppose there's no reason
6867 this will always be so. We might start putting something in
6868 the third word of .opd entries. */
6869 if ((sec->flags & SEC_IN_MEMORY) == 0)
6870 {
eea6121a
AM		 6871 bfd_byte *loc;
6872 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
6cdc0ccc 6873 {
eea6121a
AM		 6874 if (loc != NULL)
6875 free (loc);
50bc7936 6876 error_ret:
6cdc0ccc
AM		 6877 if (local_syms != NULL
6878 && symtab_hdr->contents != (unsigned char *) local_syms)
6879 free (local_syms);
6cdc0ccc
AM		 6880 if (elf_section_data (sec)->relocs != relstart)
6881 free (relstart);
b34976b6 6882 return FALSE;
6cdc0ccc 6883 }
1e2f5b6e
AM		 6884 sec->contents = loc;
6885 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
6886 }
6887
6888 elf_section_data (sec)->relocs = relstart;
6889
3f764659 6890 new_contents = sec->contents;
3f764659
JJ		 6891 if (add_aux_fields)
6892 {
6893 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
6894 if (new_contents == NULL)
6895 return FALSE;
6896 need_pad = FALSE;
3f764659 6897 }
b4f4e59f
AM		 6898 wptr = new_contents;
6899 rptr = sec->contents;
3f764659 6900
1e2f5b6e 6901 write_rel = relstart;
b34976b6 6902 skip = FALSE;
1e2f5b6e 6903 offset = 0;
3f764659 6904 opd_ent_size = 0;
1e2f5b6e
AM		 6905 for (rel = relstart; rel < relend; rel++)
6906 {
50bc7936
AM		 6907 unsigned long r_symndx;
6908 asection *sym_sec;
6909 struct elf_link_hash_entry *h;
6910 Elf_Internal_Sym *sym;
6911
6912 r_symndx = ELF64_R_SYM (rel->r_info);
6913 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
d37c89e5 6914 r_symndx, ibfd))
50bc7936
AM		 6915 goto error_ret;
6916
1e2f5b6e
AM		 6917 if (rel->r_offset == offset)
6918 {
50bc7936 6919 struct ppc_link_hash_entry *fdh = NULL;
3f764659
JJ		 6920
6921 /* See if the .opd entry is full 24 byte or
6922 16 byte (with fd_aux entry overlapped with next
6923 fd_func). */
6924 opd_ent_size = 24;
6925 if ((rel + 2 == relend && sec->size == offset + 16)
6926 || (rel + 3 < relend
6927 && rel[2].r_offset == offset + 16
6928 && rel[3].r_offset == offset + 24
6929 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
6930 && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
6931 opd_ent_size = 16;
6932
4025353c
AM		 6933 if (h != NULL
6934 && h->root.root.string[0] == '.')
c4f68ce3
AM		 6935 {
6936 fdh = get_fdh ((struct ppc_link_hash_entry *) h,
6937 ppc_hash_table (info));
6938 if (fdh != NULL
6939 && fdh->elf.root.type != bfd_link_hash_defined
6940 && fdh->elf.root.type != bfd_link_hash_defweak)
6941 fdh = NULL;
6942 }
1e2f5b6e 6943
51020317
AM		 6944 skip = (sym_sec->owner != ibfd
6945 || sym_sec->output_section == bfd_abs_section_ptr);
a4aa0fb7
AM		 6946 if (skip)
6947 {
4025353c 6948 if (fdh != NULL && sym_sec->owner == ibfd)
a4aa0fb7
AM		 6949 {
6950 /* Arrange for the function descriptor sym
6951 to be dropped. */
d6fe2dc1
AM		 6952 fdh->elf.root.u.def.value = 0;
6953 fdh->elf.root.u.def.section = sym_sec;
a4aa0fb7 6954 }
74f0fb50 6955 opd->adjust[rel->r_offset / 8] = -1;
a4aa0fb7
AM		 6956 }
6957 else
1e2f5b6e
AM		 6958 {
6959 /* We'll be keeping this opd entry. */
6960
4025353c 6961 if (fdh != NULL)
1e2f5b6e 6962 {
754021d0
AM		 6963 /* Redefine the function descriptor symbol to
6964 this location in the opd section. It is
6965 necessary to update the value here rather
6966 than using an array of adjustments as we do
6967 for local symbols, because various places
6968 in the generic ELF code use the value
6969 stored in u.def.value. */
3f764659 6970 fdh->elf.root.u.def.value = wptr - new_contents;
754021d0 6971 fdh->adjust_done = 1;
1e2f5b6e 6972 }
754021d0
AM		 6973
6974 /* Local syms are a bit tricky. We could
6975 tweak them as they can be cached, but
6976 we'd need to look through the local syms
6977 for the function descriptor sym which we
6978 don't have at the moment. So keep an
6979 array of adjustments. */
74f0fb50 6980 opd->adjust[rel->r_offset / 8]
3f764659 6981 = (wptr - new_contents) - (rptr - sec->contents);
1e2f5b6e
AM		 6982
6983 if (wptr != rptr)
3f764659
JJ		 6984 memcpy (wptr, rptr, opd_ent_size);
6985 wptr += opd_ent_size;
6986 if (add_aux_fields && opd_ent_size == 16)
6987 {
6988 memset (wptr, '\0', 8);
6989 wptr += 8;
6990 }
1e2f5b6e 6991 }
3f764659
JJ		 6992 rptr += opd_ent_size;
6993 offset += opd_ent_size;
1e2f5b6e
AM		 6994 }
6995
50bc7936
AM		 6996 if (skip)
6997 {
60124e18
AM		 6998 if (!NO_OPD_RELOCS
6999 && !info->relocatable
18d944df
AM		 7000 && !dec_dynrel_count (rel->r_info, sec, info,
7001 NULL, h, sym_sec))
8c1d1bb8 7002 goto error_ret;
50bc7936
AM		 7003 }
7004 else
1e2f5b6e 7005 {
50bc7936
AM		 7006 /* We need to adjust any reloc offsets to point to the
7007 new opd entries. While we're at it, we may as well
7008 remove redundant relocs. */
74f0fb50 7009 rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
1e2f5b6e
AM		 7010 if (write_rel != rel)
7011 memcpy (write_rel, rel, sizeof (*rel));
7012 ++write_rel;
7013 }
7014 }
7015
3f764659 7016 sec->size = wptr - new_contents;
1e2f5b6e 7017 sec->reloc_count = write_rel - relstart;
3f764659
JJ		 7018 if (add_aux_fields)
7019 {
7020 free (sec->contents);
7021 sec->contents = new_contents;
7022 }
7023
05bf9422 7024 /* Fudge the header size too, as this is used later in
cdcf6e38
AM		 7025 elf_bfd_final_link if we are emitting relocs. */
7026 elf_section_data (sec)->rel_hdr.sh_size
7027 = sec->reloc_count * elf_section_data (sec)->rel_hdr.sh_entsize;
7028 BFD_ASSERT (elf_section_data (sec)->rel_hdr2 == NULL);
754021d0 7029 some_edited = TRUE;
1e2f5b6e 7030 }
6cdc0ccc 7031 else if (elf_section_data (sec)->relocs != relstart)
1e2f5b6e 7032 free (relstart);
6cdc0ccc 7033
411e1bfb
AM		 7034 if (local_syms != NULL
7035 && symtab_hdr->contents != (unsigned char *) local_syms)
7036 {
7037 if (!info->keep_memory)
7038 free (local_syms);
7039 else
7040 symtab_hdr->contents = (unsigned char *) local_syms;
7041 }
7042 }
7043
754021d0
AM		 7044 if (some_edited)
7045 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7046
3f764659
JJ		 7047 /* If we are doing a final link and the last .opd entry is just 16 byte
7048 long, add a 8 byte padding after it. */
7049 if (need_pad != NULL && !info->relocatable)
7050 {
7051 bfd_byte *p;
7052
7053 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7054 {
7055 BFD_ASSERT (need_pad->size > 0);
7056
7057 p = bfd_malloc (need_pad->size + 8);
7058 if (p == NULL)
7059 return FALSE;
699733f6 7060
3f764659
JJ		 7061 if (! bfd_get_section_contents (need_pad->owner, need_pad,
7062 p, 0, need_pad->size))
7063 return FALSE;
7064
7065 need_pad->contents = p;
7066 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7067 }
7068 else
7069 {
7070 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7071 if (p == NULL)
7072 return FALSE;
7073
7074 need_pad->contents = p;
7075 }
7076
7077 memset (need_pad->contents + need_pad->size, 0, 8);
7078 need_pad->size += 8;
7079 }
7080
411e1bfb
AM		 7081 return TRUE;
7082}
7083
e1918d23 7084/* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
411e1bfb 7085
e1918d23 7086asection *
4ce794b7 7087ppc64_elf_tls_setup (bfd *obfd, struct bfd_link_info *info)
411e1bfb 7088{
411e1bfb
AM		 7089 struct ppc_link_hash_table *htab;
7090
411e1bfb 7091 htab = ppc_hash_table (info);
3a71aa26
AM		 7092 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7093 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7094 FALSE, FALSE, TRUE));
7095 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7096 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7097 FALSE, FALSE, TRUE));
7098 return _bfd_elf_tls_setup (obfd, info);
7099}
8387904d 7100
3a71aa26
AM		 7101/* Return TRUE iff REL is a branch reloc with a global symbol matching
7102 HASH1 or HASH2. */
8387904d 7103
3a71aa26
AM		 7104static bfd_boolean
7105branch_reloc_hash_match (const bfd *ibfd,
7106 const Elf_Internal_Rela *rel,
7107 const struct ppc_link_hash_entry *hash1,
7108 const struct ppc_link_hash_entry *hash2)
7109{
7110 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7111 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
7112 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
7113
e054468f 7114 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8387904d 7115 {
3a71aa26
AM		 7116 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7117 struct elf_link_hash_entry *h;
8387904d 7118
3a71aa26
AM		 7119 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7120 while (h->root.type == bfd_link_hash_indirect
7121 || h->root.type == bfd_link_hash_warning)
7122 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7123 if (h == &hash1->elf || h == &hash2->elf)
7124 return TRUE;
a48ebf4d 7125 }
3a71aa26 7126 return FALSE;
951fd09b 7127}
411e1bfb 7128
951fd09b
AM		 7129/* Run through all the TLS relocs looking for optimization
7130 opportunities. The linker has been hacked (see ppc64elf.em) to do
7131 a preliminary section layout so that we know the TLS segment
7132 offsets. We can't optimize earlier because some optimizations need
7133 to know the tp offset, and we need to optimize before allocating
7134 dynamic relocations. */
7135
7136bfd_boolean
4ce794b7 7137ppc64_elf_tls_optimize (bfd *obfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
951fd09b
AM		 7138{
7139 bfd *ibfd;
7140 asection *sec;
7141 struct ppc_link_hash_table *htab;
102890f0 7142 int pass;
951fd09b 7143
1d483afe 7144 if (info->relocatable || !info->executable)
411e1bfb
AM		 7145 return TRUE;
7146
951fd09b 7147 htab = ppc_hash_table (info);
411e1bfb
AM		 7148 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7149 {
7150 Elf_Internal_Sym *locsyms = NULL;
30038c59
AM		 7151 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
7152 unsigned char *toc_ref = NULL;
411e1bfb 7153
102890f0
AM		 7154 /* Look at all the sections for this file. Make two passes over
7155 the relocs. On the first pass, mark toc entries involved
7156 with tls relocs, and check that tls relocs involved in
7157 setting up a tls_get_addr call are indeed followed by such a
7158 call. If they are not, exclude them from the optimizations
7159 done on the second pass. */
7160 for (pass = 0; pass < 2; ++pass)
7161 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7162 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
7163 {
7164 Elf_Internal_Rela *relstart, *rel, *relend;
411e1bfb 7165
102890f0
AM		 7166 /* Read the relocations. */
7167 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7168 info->keep_memory);
7169 if (relstart == NULL)
7170 return FALSE;
411e1bfb 7171
102890f0
AM		 7172 relend = relstart + sec->reloc_count;
7173 for (rel = relstart; rel < relend; rel++)
7174 {
7175 enum elf_ppc64_reloc_type r_type;
7176 unsigned long r_symndx;
7177 struct elf_link_hash_entry *h;
7178 Elf_Internal_Sym *sym;
7179 asection *sym_sec;
7180 char *tls_mask;
7181 char tls_set, tls_clear, tls_type = 0;
7182 bfd_vma value;
7183 bfd_boolean ok_tprel, is_local;
7184 long toc_ref_index = 0;
7185 int expecting_tls_get_addr = 0;
411e1bfb 7186
102890f0
AM		 7187 r_symndx = ELF64_R_SYM (rel->r_info);
7188 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
7189 r_symndx, ibfd))
7190 {
7191 err_free_rel:
7192 if (elf_section_data (sec)->relocs != relstart)
7193 free (relstart);
7194 if (toc_ref != NULL)
7195 free (toc_ref);
7196 if (locsyms != NULL
0ffa91dd 7197 && (elf_symtab_hdr (ibfd).contents
102890f0
AM		 7198 != (unsigned char *) locsyms))
7199 free (locsyms);
7200 return FALSE;
7201 }
411e1bfb 7202
102890f0
AM		 7203 if (h != NULL)
7204 {
7205 if (h->root.type != bfd_link_hash_defined
7206 && h->root.type != bfd_link_hash_defweak)
7207 continue;
7208 value = h->root.u.def.value;
7209 }
7210 else
7211 /* Symbols referenced by TLS relocs must be of type
7212 STT_TLS. So no need for .opd local sym adjust. */
7213 value = sym->st_value;
7214
7215 ok_tprel = FALSE;
7216 is_local = FALSE;
7217 if (h == NULL
7218 || !h->def_dynamic)
7219 {
7220 is_local = TRUE;
7221 value += sym_sec->output_offset;
7222 value += sym_sec->output_section->vma;
7223 value -= htab->elf.tls_sec->vma;
7224 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
7225 < (bfd_vma) 1 << 32);
7226 }
951fd09b 7227
102890f0
AM		 7228 r_type = ELF64_R_TYPE (rel->r_info);
7229 switch (r_type)
7230 {
7231 case R_PPC64_GOT_TLSLD16:
7232 case R_PPC64_GOT_TLSLD16_LO:
7233 expecting_tls_get_addr = 1;
7234 /* Fall thru */
7235
7236 case R_PPC64_GOT_TLSLD16_HI:
7237 case R_PPC64_GOT_TLSLD16_HA:
7238 /* These relocs should never be against a symbol
7239 defined in a shared lib. Leave them alone if
7240 that turns out to be the case. */
7241 if (!is_local)
7242 continue;
411e1bfb 7243
102890f0 7244 /* LD -> LE */
411e1bfb 7245 tls_set = 0;
102890f0
AM		 7246 tls_clear = TLS_LD;
7247 tls_type = TLS_TLS | TLS_LD;
7248 break;
411e1bfb 7249
102890f0
AM		 7250 case R_PPC64_GOT_TLSGD16:
7251 case R_PPC64_GOT_TLSGD16_LO:
7252 expecting_tls_get_addr = 1;
7253 /* Fall thru */
7254
7255 case R_PPC64_GOT_TLSGD16_HI:
7256 case R_PPC64_GOT_TLSGD16_HA:
7257 if (ok_tprel)
7258 /* GD -> LE */
411e1bfb 7259 tls_set = 0;
102890f0
AM		 7260 else
7261 /* GD -> IE */
7262 tls_set = TLS_TLS | TLS_TPRELGD;
7263 tls_clear = TLS_GD;
7264 tls_type = TLS_TLS | TLS_GD;
7265 break;
7266
7267 case R_PPC64_GOT_TPREL16_DS:
7268 case R_PPC64_GOT_TPREL16_LO_DS:
7269 case R_PPC64_GOT_TPREL16_HI:
7270 case R_PPC64_GOT_TPREL16_HA:
7271 if (ok_tprel)
7272 {
7273 /* IE -> LE */
7274 tls_set = 0;
7275 tls_clear = TLS_TPREL;
7276 tls_type = TLS_TLS | TLS_TPREL;
7277 break;
7278 }
411e1bfb
AM		 7279 continue;
7280
102890f0
AM		 7281 case R_PPC64_TOC16:
7282 case R_PPC64_TOC16_LO:
7283 case R_PPC64_TLS:
727fc41e
AM		 7284 case R_PPC64_TLSGD:
7285 case R_PPC64_TLSLD:
102890f0
AM		 7286 if (sym_sec == NULL || sym_sec != toc)
7287 continue;
7288
7289 /* Mark this toc entry as referenced by a TLS
7290 code sequence. We can do that now in the
7291 case of R_PPC64_TLS, and after checking for
7292 tls_get_addr for the TOC16 relocs. */
7293 if (toc_ref == NULL)
7294 {
7295 toc_ref = bfd_zmalloc (toc->size / 8);
7296 if (toc_ref == NULL)
7297 goto err_free_rel;
7298 }
7299 if (h != NULL)
7300 value = h->root.u.def.value;
7301 else
7302 value = sym->st_value;
7303 value += rel->r_addend;
7304 BFD_ASSERT (value < toc->size && value % 8 == 0);
7305 toc_ref_index = value / 8;
727fc41e
AM		 7306 if (r_type == R_PPC64_TLS
7307 || r_type == R_PPC64_TLSGD
7308 || r_type == R_PPC64_TLSLD)
102890f0
AM		 7309 {
7310 toc_ref[toc_ref_index] = 1;
7311 continue;
7312 }
7313
7314 if (pass != 0 && toc_ref[toc_ref_index] == 0)
7315 continue;
7316
7317 tls_set = 0;
7318 tls_clear = 0;
7319 expecting_tls_get_addr = 2;
7320 break;
7321
7322 case R_PPC64_TPREL64:
7323 if (pass == 0
7324 || sec != toc
7325 || toc_ref == NULL
7326 || !toc_ref[rel->r_offset / 8])
7327 continue;
7328 if (ok_tprel)
7329 {
7330 /* IE -> LE */
7331 tls_set = TLS_EXPLICIT;
7332 tls_clear = TLS_TPREL;
7333 break;
7334 }
7335 continue;
7336
7337 case R_PPC64_DTPMOD64:
7338 if (pass == 0
7339 || sec != toc
7340 || toc_ref == NULL
7341 || !toc_ref[rel->r_offset / 8])
7342 continue;
7343 if (rel + 1 < relend
7344 && (rel[1].r_info
7345 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
7346 && rel[1].r_offset == rel->r_offset + 8)
7347 {
7348 if (ok_tprel)
7349 /* GD -> LE */
7350 tls_set = TLS_EXPLICIT | TLS_GD;
7351 else
7352 /* GD -> IE */
7353 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
7354 tls_clear = TLS_GD;
7355 }
7356 else
7357 {
7358 if (!is_local)
7359 continue;
7360
7361 /* LD -> LE */
7362 tls_set = TLS_EXPLICIT;
7363 tls_clear = TLS_LD;
7364 }
7365 break;
7366
7367 default:
7368 continue;
7369 }
7370
7371 if (pass == 0)
7372 {
727fc41e
AM		 7373 if (!expecting_tls_get_addr
7374 || !sec->has_tls_get_addr_call)
102890f0
AM		 7375 continue;
7376
3a71aa26
AM		 7377 if (rel + 1 < relend
7378 && branch_reloc_hash_match (ibfd, rel + 1,
7379 htab->tls_get_addr,
7380 htab->tls_get_addr_fd))
102890f0 7381 {
3a71aa26 7382 if (expecting_tls_get_addr == 2)
102890f0 7383 {
3a71aa26
AM		 7384 /* Check for toc tls entries. */
7385 char *toc_tls;
7386 int retval;
7387
7388 retval = get_tls_mask (&toc_tls, NULL, NULL,
7389 &locsyms,
7390 rel, ibfd);
7391 if (retval == 0)
7392 goto err_free_rel;
7393 if (retval > 1 && toc_tls != NULL)
7394 toc_ref[toc_ref_index] = 1;
102890f0 7395 }
3a71aa26 7396 continue;
102890f0
AM		 7397 }
7398
7399 if (expecting_tls_get_addr != 1)
7400 continue;
7401
7402 /* Uh oh, we didn't find the expected call. We
7403 could just mark this symbol to exclude it
7404 from tls optimization but it's safer to skip
7405 the entire section. */
7406 sec->has_tls_reloc = 0;
7407 break;
7408 }
7409
85f7a9cb 7410 if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
102890f0
AM		 7411 {
7412 struct plt_entry *ent;
7413 for (ent = htab->tls_get_addr->elf.plt.plist;
7414 ent != NULL;
7415 ent = ent->next)
7416 if (ent->addend == 0)
411e1bfb 7417 {
102890f0 7418 if (ent->plt.refcount > 0)
30038c59 7419 {
102890f0
AM		 7420 ent->plt.refcount -= 1;
7421 expecting_tls_get_addr = 0;
30038c59 7422 }
102890f0 7423 break;
411e1bfb 7424 }
102890f0 7425 }
411e1bfb 7426
85f7a9cb 7427 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
102890f0
AM		 7428 {
7429 struct plt_entry *ent;
7430 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
7431 ent != NULL;
7432 ent = ent->next)
7433 if (ent->addend == 0)
411e1bfb 7434 {
102890f0
AM		 7435 if (ent->plt.refcount > 0)
7436 ent->plt.refcount -= 1;
7437 break;
411e1bfb 7438 }
102890f0 7439 }
411e1bfb 7440
102890f0 7441 if (tls_clear == 0)
30038c59
AM		 7442 continue;
7443
102890f0
AM		 7444 if ((tls_set & TLS_EXPLICIT) == 0)
7445 {
7446 struct got_entry *ent;
411e1bfb 7447
102890f0
AM		 7448 /* Adjust got entry for this reloc. */
7449 if (h != NULL)
7450 ent = h->got.glist;
7451 else
7452 ent = elf_local_got_ents (ibfd)[r_symndx];
411e1bfb 7453
102890f0
AM		 7454 for (; ent != NULL; ent = ent->next)
7455 if (ent->addend == rel->r_addend
7456 && ent->owner == ibfd
7457 && ent->tls_type == tls_type)
7458 break;
7459 if (ent == NULL)
7460 abort ();
411e1bfb 7461
102890f0
AM		 7462 if (tls_set == 0)
7463 {
7464 /* We managed to get rid of a got entry. */
7465 if (ent->got.refcount > 0)
7466 ent->got.refcount -= 1;
7467 }
7468 }
7469 else
7470 {
7471 /* If we got rid of a DTPMOD/DTPREL reloc pair then
7472 we'll lose one or two dyn relocs. */
7473 if (!dec_dynrel_count (rel->r_info, sec, info,
7474 NULL, h, sym_sec))
7475 return FALSE;
411e1bfb 7476
102890f0
AM		 7477 if (tls_set == (TLS_EXPLICIT | TLS_GD))
7478 {
7479 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
7480 NULL, h, sym_sec))
7481 return FALSE;
7482 }
7483 }
411e1bfb 7484
102890f0
AM		 7485 *tls_mask |= tls_set;
7486 *tls_mask &= ~tls_clear;
7487 }
8c1d1bb8 7488
102890f0
AM		 7489 if (elf_section_data (sec)->relocs != relstart)
7490 free (relstart);
7491 }
411e1bfb 7492
727fc41e
AM		 7493 if (toc_ref != NULL)
7494 free (toc_ref);
411e1bfb 7495
727fc41e
AM		 7496 if (locsyms != NULL
7497 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
7498 {
7499 if (!info->keep_memory)
7500 free (locsyms);
7501 else
7502 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
7503 }
7504 }
b34976b6 7505 return TRUE;
1e2f5b6e 7506}
b34976b6 7507
c5614fa4
AM		 7508/* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
7509 the values of any global symbols in a toc section that has been
7510 edited. Globals in toc sections should be a rarity, so this function
7511 sets a flag if any are found in toc sections other than the one just
7512 edited, so that futher hash table traversals can be avoided. */
7513
7514struct adjust_toc_info
7515{
7516 asection *toc;
7517 unsigned long *skip;
7518 bfd_boolean global_toc_syms;
7519};
7520
7521static bfd_boolean
7522adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
7523{
7524 struct ppc_link_hash_entry *eh;
7525 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
7526
7527 if (h->root.type == bfd_link_hash_indirect)
7528 return TRUE;
7529
7530 if (h->root.type == bfd_link_hash_warning)
7531 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7532
7533 if (h->root.type != bfd_link_hash_defined
7534 && h->root.type != bfd_link_hash_defweak)
7535 return TRUE;
7536
7537 eh = (struct ppc_link_hash_entry *) h;
7538 if (eh->adjust_done)
7539 return TRUE;
7540
7541 if (eh->elf.root.u.def.section == toc_inf->toc)
7542 {
7543 unsigned long skip = toc_inf->skip[eh->elf.root.u.def.value >> 3];
7544 if (skip != (unsigned long) -1)
7545 eh->elf.root.u.def.value -= skip;
7546 else
7547 {
7548 (*_bfd_error_handler)
7549 (_("%s defined in removed toc entry"), eh->elf.root.root.string);
7550 eh->elf.root.u.def.section = &bfd_abs_section;
7551 eh->elf.root.u.def.value = 0;
7552 }
7553 eh->adjust_done = 1;
7554 }
7555 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
7556 toc_inf->global_toc_syms = TRUE;
7557
7558 return TRUE;
7559}
7560
7561/* Examine all relocs referencing .toc sections in order to remove
7562 unused .toc entries. */
7563
7564bfd_boolean
7565ppc64_elf_edit_toc (bfd *obfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
7566{
7567 bfd *ibfd;
7568 struct adjust_toc_info toc_inf;
7569
7570 toc_inf.global_toc_syms = TRUE;
7571 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7572 {
7573 asection *toc, *sec;
7574 Elf_Internal_Shdr *symtab_hdr;
7575 Elf_Internal_Sym *local_syms;
7576 struct elf_link_hash_entry **sym_hashes;
92b7a70f 7577 Elf_Internal_Rela *relstart, *rel;
c5614fa4
AM		 7578 unsigned long *skip, *drop;
7579 unsigned char *used;
7580 unsigned char *keep, last, some_unused;
7581
7582 toc = bfd_get_section_by_name (ibfd, ".toc");
7583 if (toc == NULL
92b7a70f 7584 || toc->size == 0
c5614fa4
AM		 7585 || toc->sec_info_type == ELF_INFO_TYPE_JUST_SYMS
7586 || elf_discarded_section (toc))
7587 continue;
7588
7589 local_syms = NULL;
0ffa91dd 7590 symtab_hdr = &elf_symtab_hdr (ibfd);
c5614fa4
AM		 7591 sym_hashes = elf_sym_hashes (ibfd);
7592
7593 /* Look at sections dropped from the final link. */
7594 skip = NULL;
7595 relstart = NULL;
7596 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7597 {
7598 if (sec->reloc_count == 0
7599 || !elf_discarded_section (sec)
7600 || get_opd_info (sec)
7601 || (sec->flags & SEC_ALLOC) == 0
7602 || (sec->flags & SEC_DEBUGGING) != 0)
7603 continue;
7604
7605 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
7606 if (relstart == NULL)
7607 goto error_ret;
7608
7609 /* Run through the relocs to see which toc entries might be
7610 unused. */
7611 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7612 {
7613 enum elf_ppc64_reloc_type r_type;
7614 unsigned long r_symndx;
7615 asection *sym_sec;
7616 struct elf_link_hash_entry *h;
7617 Elf_Internal_Sym *sym;
7618 bfd_vma val;
7619
7620 r_type = ELF64_R_TYPE (rel->r_info);
7621 switch (r_type)
7622 {
7623 default:
7624 continue;
7625
7626 case R_PPC64_TOC16:
7627 case R_PPC64_TOC16_LO:
7628 case R_PPC64_TOC16_HI:
7629 case R_PPC64_TOC16_HA:
7630 case R_PPC64_TOC16_DS:
7631 case R_PPC64_TOC16_LO_DS:
7632 break;
7633 }
7634
7635 r_symndx = ELF64_R_SYM (rel->r_info);
7636 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7637 r_symndx, ibfd))
7638 goto error_ret;
7639
7640 if (sym_sec != toc)
7641 continue;
7642
7643 if (h != NULL)
7644 val = h->root.u.def.value;
7645 else
7646 val = sym->st_value;
7647 val += rel->r_addend;
7648
7649 if (val >= toc->size)
7650 continue;
7651
7652 /* Anything in the toc ought to be aligned to 8 bytes.
7653 If not, don't mark as unused. */
7654 if (val & 7)
7655 continue;
7656
7657 if (skip == NULL)
7658 {
7659 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 7) / 8);
7660 if (skip == NULL)
7661 goto error_ret;
7662 }
7663
7664 skip[val >> 3] = 1;
7665 }
7666
7667 if (elf_section_data (sec)->relocs != relstart)
7668 free (relstart);
7669 }
7670
7671 if (skip == NULL)
7672 continue;
7673
7674 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
7675 if (used == NULL)
7676 {
7677 error_ret:
7678 if (local_syms != NULL
7679 && symtab_hdr->contents != (unsigned char *) local_syms)
7680 free (local_syms);
7681 if (sec != NULL
7682 && relstart != NULL
7683 && elf_section_data (sec)->relocs != relstart)
7684 free (relstart);
7685 if (skip != NULL)
7686 free (skip);
7687 return FALSE;
7688 }
7689
30038c59
AM		 7690 /* Now check all kept sections that might reference the toc.
7691 Check the toc itself last. */
7692 for (sec = (ibfd->sections == toc && toc->next ? toc->next
7693 : ibfd->sections);
c5614fa4 7694 sec != NULL;
c5614fa4 7695 sec = (sec == toc ? NULL
c5614fa4 7696 : sec->next == NULL ? toc
30038c59 7697 : sec->next == toc && toc->next ? toc->next
c5614fa4
AM		 7698 : sec->next))
7699 {
7700 int repeat;
7701
7702 if (sec->reloc_count == 0
7703 || elf_discarded_section (sec)
7704 || get_opd_info (sec)
7705 || (sec->flags & SEC_ALLOC) == 0
7706 || (sec->flags & SEC_DEBUGGING) != 0)
7707 continue;
7708
7709 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, TRUE);
7710 if (relstart == NULL)
7711 goto error_ret;
7712
7713 /* Mark toc entries referenced as used. */
7714 repeat = 0;
7715 do
7716 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7717 {
7718 enum elf_ppc64_reloc_type r_type;
7719 unsigned long r_symndx;
7720 asection *sym_sec;
7721 struct elf_link_hash_entry *h;
7722 Elf_Internal_Sym *sym;
7723 bfd_vma val;
7724
7725 r_type = ELF64_R_TYPE (rel->r_info);
7726 switch (r_type)
7727 {
7728 case R_PPC64_TOC16:
7729 case R_PPC64_TOC16_LO:
7730 case R_PPC64_TOC16_HI:
7731 case R_PPC64_TOC16_HA:
7732 case R_PPC64_TOC16_DS:
7733 case R_PPC64_TOC16_LO_DS:
7734 /* In case we're taking addresses of toc entries. */
7735 case R_PPC64_ADDR64:
7736 break;
7737
7738 default:
7739 continue;
7740 }
7741
7742 r_symndx = ELF64_R_SYM (rel->r_info);
7743 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7744 r_symndx, ibfd))
7745 {
7746 free (used);
7747 goto error_ret;
7748 }
7749
7750 if (sym_sec != toc)
7751 continue;
7752
7753 if (h != NULL)
7754 val = h->root.u.def.value;
7755 else
7756 val = sym->st_value;
7757 val += rel->r_addend;
7758
7759 if (val >= toc->size)
7760 continue;
7761
7762 /* For the toc section, we only mark as used if
7763 this entry itself isn't unused. */
7764 if (sec == toc
7765 && !used[val >> 3]
7766 && (used[rel->r_offset >> 3]
7767 || !skip[rel->r_offset >> 3]))
7768 /* Do all the relocs again, to catch reference
7769 chains. */
7770 repeat = 1;
7771
7772 used[val >> 3] = 1;
7773 }
7774 while (repeat);
7775 }
7776
7777 /* Merge the used and skip arrays. Assume that TOC
7778 doublewords not appearing as either used or unused belong
7779 to to an entry more than one doubleword in size. */
7780 for (drop = skip, keep = used, last = 0, some_unused = 0;
7781 drop < skip + (toc->size + 7) / 8;
7782 ++drop, ++keep)
7783 {
7784 if (*keep)
7785 {
7786 *drop = 0;
7787 last = 0;
7788 }
7789 else if (*drop)
7790 {
7791 some_unused = 1;
7792 last = 1;
7793 }
7794 else
7795 *drop = last;
7796 }
7797
7798 free (used);
7799
7800 if (some_unused)
7801 {
7802 bfd_byte *contents, *src;
7803 unsigned long off;
7804
7805 /* Shuffle the toc contents, and at the same time convert the
7806 skip array from booleans into offsets. */
7807 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
7808 goto error_ret;
7809
7810 elf_section_data (toc)->this_hdr.contents = contents;
7811
7812 for (src = contents, off = 0, drop = skip;
7813 src < contents + toc->size;
7814 src += 8, ++drop)
7815 {
7816 if (*drop)
7817 {
7818 *drop = (unsigned long) -1;
7819 off += 8;
7820 }
7821 else if (off != 0)
7822 {
7823 *drop = off;
7824 memcpy (src - off, src, 8);
7825 }
7826 }
7827 toc->rawsize = toc->size;
7828 toc->size = src - contents - off;
7829
92b7a70f
AM		 7830 if (toc->reloc_count != 0)
7831 {
7832 Elf_Internal_Rela *wrel;
7833 bfd_size_type sz;
c5614fa4 7834
92b7a70f
AM		 7835 /* Read toc relocs. */
7836 relstart = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
7837 TRUE);
7838 if (relstart == NULL)
7839 goto error_ret;
7840
7841 /* Remove unused toc relocs, and adjust those we keep. */
7842 wrel = relstart;
7843 for (rel = relstart; rel < relstart + toc->reloc_count; ++rel)
7844 if (skip[rel->r_offset >> 3] != (unsigned long) -1)
7845 {
7846 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
7847 wrel->r_info = rel->r_info;
7848 wrel->r_addend = rel->r_addend;
7849 ++wrel;
7850 }
8c1d1bb8
AM		 7851 else if (!dec_dynrel_count (rel->r_info, toc, info,
7852 &local_syms, NULL, NULL))
7853 goto error_ret;
35090471 7854
92b7a70f
AM		 7855 toc->reloc_count = wrel - relstart;
7856 sz = elf_section_data (toc)->rel_hdr.sh_entsize;
7857 elf_section_data (toc)->rel_hdr.sh_size = toc->reloc_count * sz;
7858 BFD_ASSERT (elf_section_data (toc)->rel_hdr2 == NULL);
7859 }
c5614fa4
AM		 7860
7861 /* Adjust addends for relocs against the toc section sym. */
7862 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7863 {
7864 if (sec->reloc_count == 0
7865 || elf_discarded_section (sec))
7866 continue;
7867
7868 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7869 TRUE);
7870 if (relstart == NULL)
7871 goto error_ret;
7872
7873 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7874 {
7875 enum elf_ppc64_reloc_type r_type;
7876 unsigned long r_symndx;
7877 asection *sym_sec;
7878 struct elf_link_hash_entry *h;
7879 Elf_Internal_Sym *sym;
7880
7881 r_type = ELF64_R_TYPE (rel->r_info);
7882 switch (r_type)
7883 {
7884 default:
7885 continue;
7886
7887 case R_PPC64_TOC16:
7888 case R_PPC64_TOC16_LO:
7889 case R_PPC64_TOC16_HI:
7890 case R_PPC64_TOC16_HA:
7891 case R_PPC64_TOC16_DS:
7892 case R_PPC64_TOC16_LO_DS:
7893 case R_PPC64_ADDR64:
7894 break;
7895 }
7896
7897 r_symndx = ELF64_R_SYM (rel->r_info);
7898 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7899 r_symndx, ibfd))
7900 goto error_ret;
7901
7902 if (sym_sec != toc || h != NULL || sym->st_value != 0)
7903 continue;
7904
7905 rel->r_addend -= skip[rel->r_addend >> 3];
7906 }
7907 }
7908
7909 /* We shouldn't have local or global symbols defined in the TOC,
7910 but handle them anyway. */
7911 if (local_syms != NULL)
7912 {
7913 Elf_Internal_Sym *sym;
7914
7915 for (sym = local_syms;
7916 sym < local_syms + symtab_hdr->sh_info;
7917 ++sym)
cb33740c 7918 if (sym->st_value != 0
c5614fa4
AM		 7919 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
7920 {
7921 if (skip[sym->st_value >> 3] != (unsigned long) -1)
7922 sym->st_value -= skip[sym->st_value >> 3];
7923 else
7924 {
7925 (*_bfd_error_handler)
7926 (_("%s defined in removed toc entry"),
26c61ae5
L		 7927 bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7928 NULL));
c5614fa4
AM		 7929 sym->st_value = 0;
7930 sym->st_shndx = SHN_ABS;
7931 }
7932 symtab_hdr->contents = (unsigned char *) local_syms;
7933 }
7934 }
7935
7936 /* Finally, adjust any global syms defined in the toc. */
7937 if (toc_inf.global_toc_syms)
7938 {
7939 toc_inf.toc = toc;
7940 toc_inf.skip = skip;
7941 toc_inf.global_toc_syms = FALSE;
7942 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
7943 &toc_inf);
7944 }
7945 }
7946
7947 if (local_syms != NULL
7948 && symtab_hdr->contents != (unsigned char *) local_syms)
7949 {
7950 if (!info->keep_memory)
7951 free (local_syms);
7952 else
7953 symtab_hdr->contents = (unsigned char *) local_syms;
7954 }
7955 free (skip);
7956 }
7957
7958 return TRUE;
7959}
7960
65f38f15
AM		 7961/* Allocate space in .plt, .got and associated reloc sections for
7962 dynamic relocs. */
5bd4f169 7963
b34976b6 7964static bfd_boolean
4ce794b7 7965allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
5bd4f169 7966{
65f38f15
AM		 7967 struct bfd_link_info *info;
7968 struct ppc_link_hash_table *htab;
5bd4f169 7969 asection *s;
65f38f15
AM		 7970 struct ppc_link_hash_entry *eh;
7971 struct ppc_dyn_relocs *p;
411e1bfb 7972 struct got_entry *gent;
5bd4f169 7973
e92d460e 7974 if (h->root.type == bfd_link_hash_indirect)
b34976b6 7975 return TRUE;
5bd4f169 7976
e92d460e
AM		 7977 if (h->root.type == bfd_link_hash_warning)
7978 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7979
65f38f15
AM		 7980 info = (struct bfd_link_info *) inf;
7981 htab = ppc_hash_table (info);
5bd4f169 7982
e054468f
AM		 7983 if ((htab->elf.dynamic_sections_created
7984 && h->dynindx != -1
7985 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
7986 || h->type == STT_GNU_IFUNC)
5bd4f169 7987 {
411e1bfb
AM		 7988 struct plt_entry *pent;
7989 bfd_boolean doneone = FALSE;
7990 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7991 if (pent->plt.refcount > 0)
7992 {
e054468f
AM		 7993 if (!htab->elf.dynamic_sections_created)
7994 {
7995 s = htab->iplt;
7996 pent->plt.offset = s->size;
7997 s->size += PLT_ENTRY_SIZE;
7998 s = htab->reliplt;
7999 }
8000 else
8001 {
8002 /* If this is the first .plt entry, make room for the special
8003 first entry. */
8004 s = htab->plt;
8005 if (s->size == 0)
8006 s->size += PLT_INITIAL_ENTRY_SIZE;
8007
8008 pent->plt.offset = s->size;
8009
8010 /* Make room for this entry. */
8011 s->size += PLT_ENTRY_SIZE;
8012
8013 /* Make room for the .glink code. */
8014 s = htab->glink;
8015 if (s->size == 0)
8016 s->size += GLINK_CALL_STUB_SIZE;
8017 /* We need bigger stubs past index 32767. */
8018 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
8019 s->size += 4;
8020 s->size += 2*4;
8021
8022 /* We also need to make an entry in the .rela.plt section. */
8023 s = htab->relplt;
8024 }
eea6121a 8025 s->size += sizeof (Elf64_External_Rela);
411e1bfb
AM		 8026 doneone = TRUE;
8027 }
8028 else
8029 pent->plt.offset = (bfd_vma) -1;
8030 if (!doneone)
65f38f15 8031 {
411e1bfb 8032 h->plt.plist = NULL;
f5385ebf 8033 h->needs_plt = 0;
65f38f15
AM		 8034 }
8035 }
8036 else
8037 {
411e1bfb 8038 h->plt.plist = NULL;
f5385ebf 8039 h->needs_plt = 0;
65f38f15
AM		 8040 }
8041
951fd09b
AM		 8042 eh = (struct ppc_link_hash_entry *) h;
8043 /* Run through the TLS GD got entries first if we're changing them
8044 to TPREL. */
e7b938ca 8045 if ((eh->tls_mask & TLS_TPRELGD) != 0)
951fd09b
AM		 8046 for (gent = h->got.glist; gent != NULL; gent = gent->next)
8047 if (gent->got.refcount > 0
8048 && (gent->tls_type & TLS_GD) != 0)
8049 {
8050 /* This was a GD entry that has been converted to TPREL. If
8051 there happens to be a TPREL entry we can use that one. */
8052 struct got_entry *ent;
8053 for (ent = h->got.glist; ent != NULL; ent = ent->next)
8054 if (ent->got.refcount > 0
8055 && (ent->tls_type & TLS_TPREL) != 0
e717da7e
AM		 8056 && ent->addend == gent->addend
8057 && ent->owner == gent->owner)
951fd09b
AM		 8058 {
8059 gent->got.refcount = 0;
8060 break;
8061 }
8062
8063 /* If not, then we'll be using our own TPREL entry. */
8064 if (gent->got.refcount != 0)
8065 gent->tls_type = TLS_TLS | TLS_TPREL;
8066 }
8067
411e1bfb
AM		 8068 for (gent = h->got.glist; gent != NULL; gent = gent->next)
8069 if (gent->got.refcount > 0)
8070 {
951fd09b
AM		 8071 bfd_boolean dyn;
8072
411e1bfb 8073 /* Make sure this symbol is output as a dynamic symbol.
951fd09b
AM		 8074 Undefined weak syms won't yet be marked as dynamic,
8075 nor will all TLS symbols. */
411e1bfb 8076 if (h->dynindx == -1
b099ab9f
AM		 8077 && !h->forced_local
8078 && htab->elf.dynamic_sections_created)
411e1bfb 8079 {
c152c796 8080 if (! bfd_elf_link_record_dynamic_symbol (info, h))
411e1bfb
AM		 8081 return FALSE;
8082 }
65f38f15 8083
d881513a 8084 if ((gent->tls_type & TLS_LD) != 0
f5385ebf 8085 && !h->def_dynamic)
411e1bfb 8086 {
102890f0
AM		 8087 ppc64_tlsld_got (gent->owner)->refcount += 1;
8088 gent->got.offset = (bfd_vma) -1;
951fd09b 8089 continue;
411e1bfb 8090 }
951fd09b 8091
0c8d6e5c 8092 if (!is_ppc64_elf (gent->owner))
0ffa91dd
NC		 8093 continue;
8094
e717da7e 8095 s = ppc64_elf_tdata (gent->owner)->got;
eea6121a
AM		 8096 gent->got.offset = s->size;
8097 s->size
d881513a 8098 += (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)) ? 16 : 8;
951fd09b 8099 dyn = htab->elf.dynamic_sections_created;
4e795f50
AM		 8100 if ((info->shared
8101 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
8102 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
8103 || h->root.type != bfd_link_hash_undefweak))
eea6121a 8104 ppc64_elf_tdata (gent->owner)->relgot->size
e7b938ca 8105 += (gent->tls_type & eh->tls_mask & TLS_GD
951fd09b
AM		 8106 ? 2 * sizeof (Elf64_External_Rela)
8107 : sizeof (Elf64_External_Rela));
411e1bfb
AM		 8108 }
8109 else
8110 gent->got.offset = (bfd_vma) -1;
65f38f15 8111
b099ab9f
AM		 8112 if (eh->dyn_relocs == NULL
8113 || !htab->elf.dynamic_sections_created)
b34976b6 8114 return TRUE;
65f38f15
AM		 8115
8116 /* In the shared -Bsymbolic case, discard space allocated for
8117 dynamic pc-relative relocs against symbols which turn out to be
8118 defined in regular objects. For the normal shared case, discard
8119 space for relocs that have become local due to symbol visibility
8120 changes. */
8121
8122 if (info->shared)
8123 {
9c7a29a3 8124 /* Relocs that use pc_count are those that appear on a call insn,
1d483afe 8125 or certain REL relocs (see must_be_dyn_reloc) that can be
9c7a29a3
AM		 8126 generated via assembly. We want calls to protected symbols to
8127 resolve directly to the function rather than going via the plt.
8128 If people want function pointer comparisons to work as expected
8129 then they should avoid writing weird assembly. */
09695f56 8130 if (SYMBOL_CALLS_LOCAL (info, h))
65f38f15
AM		 8131 {
8132 struct ppc_dyn_relocs **pp;
8133
8134 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
5bd4f169 8135 {
65f38f15
AM		 8136 p->count -= p->pc_count;
8137 p->pc_count = 0;
8138 if (p->count == 0)
8139 *pp = p->next;
8140 else
8141 pp = &p->next;
5bd4f169 8142 }
65f38f15 8143 }
4e795f50
AM		 8144
8145 /* Also discard relocs on undefined weak syms with non-default
8146 visibility. */
cab87ef9
AM		 8147 if (eh->dyn_relocs != NULL
8148 && h->root.type == bfd_link_hash_undefweak)
dfbb6ac9
AM		 8149 {
8150 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
8151 eh->dyn_relocs = NULL;
8152
8153 /* Make sure this symbol is output as a dynamic symbol.
8154 Undefined weak syms won't yet be marked as dynamic. */
8155 else if (h->dynindx == -1
8156 && !h->forced_local)
8157 {
8158 if (! bfd_elf_link_record_dynamic_symbol (info, h))
8159 return FALSE;
8160 }
8161 }
65f38f15 8162 }
f4656909 8163 else if (ELIMINATE_COPY_RELOCS)
65f38f15
AM		 8164 {
8165 /* For the non-shared case, discard space for relocs against
8166 symbols which turn out to need copy relocs or are not
8167 dynamic. */
8168
f5385ebf 8169 if (!h->non_got_ref
f5385ebf 8170 && !h->def_regular)
65f38f15
AM		 8171 {
8172 /* Make sure this symbol is output as a dynamic symbol.
8173 Undefined weak syms won't yet be marked as dynamic. */
8174 if (h->dynindx == -1
f5385ebf 8175 && !h->forced_local)
65f38f15 8176 {
c152c796 8177 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 8178 return FALSE;
65f38f15
AM		 8179 }
8180
8181 /* If that succeeded, we know we'll be keeping all the
8182 relocs. */
8183 if (h->dynindx != -1)
8184 goto keep;
8185 }
8186
8187 eh->dyn_relocs = NULL;
8188
ec338859 8189 keep: ;
65f38f15
AM		 8190 }
8191
8192 /* Finally, allocate space. */
8193 for (p = eh->dyn_relocs; p != NULL; p = p->next)
8194 {
8195 asection *sreloc = elf_section_data (p->sec)->sreloc;
eea6121a 8196 sreloc->size += p->count * sizeof (Elf64_External_Rela);
65f38f15
AM		 8197 }
8198
b34976b6 8199 return TRUE;
65f38f15
AM		 8200}
8201
8202/* Find any dynamic relocs that apply to read-only sections. */
8203
b34976b6 8204static bfd_boolean
4ce794b7 8205readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
65f38f15
AM		 8206{
8207 struct ppc_link_hash_entry *eh;
8208 struct ppc_dyn_relocs *p;
8209
e92d460e
AM		 8210 if (h->root.type == bfd_link_hash_warning)
8211 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8212
65f38f15
AM		 8213 eh = (struct ppc_link_hash_entry *) h;
8214 for (p = eh->dyn_relocs; p != NULL; p = p->next)
8215 {
8216 asection *s = p->sec->output_section;
8217
8218 if (s != NULL && (s->flags & SEC_READONLY) != 0)
8219 {
4ce794b7 8220 struct bfd_link_info *info = inf;
65f38f15
AM		 8221
8222 info->flags |= DF_TEXTREL;
8223
8224 /* Not an error, just cut short the traversal. */
b34976b6 8225 return FALSE;
65f38f15
AM		 8226 }
8227 }
b34976b6 8228 return TRUE;
65f38f15
AM		 8229}
8230
8231/* Set the sizes of the dynamic sections. */
8232
b34976b6 8233static bfd_boolean
4ce794b7
AM		 8234ppc64_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
8235 struct bfd_link_info *info)
65f38f15
AM		 8236{
8237 struct ppc_link_hash_table *htab;
8238 bfd *dynobj;
8239 asection *s;
b34976b6 8240 bfd_boolean relocs;
65f38f15
AM		 8241 bfd *ibfd;
8242
8243 htab = ppc_hash_table (info);
8244 dynobj = htab->elf.dynobj;
8245 if (dynobj == NULL)
8246 abort ();
8247
8248 if (htab->elf.dynamic_sections_created)
8249 {
8250 /* Set the contents of the .interp section to the interpreter. */
36af4a4e 8251 if (info->executable)
65f38f15
AM		 8252 {
8253 s = bfd_get_section_by_name (dynobj, ".interp");
8254 if (s == NULL)
8255 abort ();
eea6121a 8256 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
65f38f15
AM		 8257 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
8258 }
8259 }
8260
8261 /* Set up .got offsets for local syms, and space for local dynamic
8262 relocs. */
8263 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8264 {
411e1bfb
AM		 8265 struct got_entry **lgot_ents;
8266 struct got_entry **end_lgot_ents;
e054468f
AM		 8267 struct plt_entry **local_plt;
8268 struct plt_entry **end_local_plt;
e7b938ca 8269 char *lgot_masks;
65f38f15
AM		 8270 bfd_size_type locsymcount;
8271 Elf_Internal_Shdr *symtab_hdr;
8272 asection *srel;
8273
0c8d6e5c 8274 if (!is_ppc64_elf (ibfd))
65f38f15
AM		 8275 continue;
8276
8277 for (s = ibfd->sections; s != NULL; s = s->next)
8278 {
ec338859 8279 struct ppc_dyn_relocs *p;
65f38f15 8280
6edfbbad 8281 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
65f38f15 8282 {
ec338859
AM		 8283 if (!bfd_is_abs_section (p->sec)
8284 && bfd_is_abs_section (p->sec->output_section))
8285 {
8286 /* Input section has been discarded, either because
8287 it is a copy of a linkonce section or due to
8288 linker script /DISCARD/, so we'll be discarding
8289 the relocs too. */
8290 }
248866a8 8291 else if (p->count != 0)
ec338859
AM		 8292 {
8293 srel = elf_section_data (p->sec)->sreloc;
eea6121a 8294 srel->size += p->count * sizeof (Elf64_External_Rela);
248866a8
AM		 8295 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
8296 info->flags |= DF_TEXTREL;
ec338859 8297 }
65f38f15
AM		 8298 }
8299 }
8300
411e1bfb
AM		 8301 lgot_ents = elf_local_got_ents (ibfd);
8302 if (!lgot_ents)
65f38f15
AM		 8303 continue;
8304
0ffa91dd 8305 symtab_hdr = &elf_symtab_hdr (ibfd);
65f38f15 8306 locsymcount = symtab_hdr->sh_info;
411e1bfb 8307 end_lgot_ents = lgot_ents + locsymcount;
e054468f
AM		 8308 local_plt = (struct plt_entry **) end_lgot_ents;
8309 end_local_plt = local_plt + locsymcount;
8310 lgot_masks = (char *) end_local_plt;
e717da7e
AM		 8311 s = ppc64_elf_tdata (ibfd)->got;
8312 srel = ppc64_elf_tdata (ibfd)->relgot;
e7b938ca 8313 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
65f38f15 8314 {
411e1bfb
AM		 8315 struct got_entry *ent;
8316
8317 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
8318 if (ent->got.refcount > 0)
8319 {
e7b938ca 8320 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
411e1bfb 8321 {
102890f0
AM		 8322 ppc64_tlsld_got (ibfd)->refcount += 1;
8323 ent->got.offset = (bfd_vma) -1;
411e1bfb
AM		 8324 }
8325 else
8326 {
eea6121a 8327 ent->got.offset = s->size;
e7b938ca 8328 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
411e1bfb 8329 {
eea6121a 8330 s->size += 16;
411e1bfb 8331 if (info->shared)
eea6121a 8332 srel->size += 2 * sizeof (Elf64_External_Rela);
411e1bfb
AM		 8333 }
8334 else
8335 {
eea6121a 8336 s->size += 8;
411e1bfb 8337 if (info->shared)
eea6121a 8338 srel->size += sizeof (Elf64_External_Rela);
411e1bfb
AM		 8339 }
8340 }
8341 }
8342 else
8343 ent->got.offset = (bfd_vma) -1;
65f38f15 8344 }
e054468f
AM		 8345
8346 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
8347 for (; local_plt < end_local_plt; ++local_plt)
8348 {
8349 struct plt_entry *ent;
8350
8351 for (ent = *local_plt; ent != NULL; ent = ent->next)
8352 if (ent->plt.refcount > 0)
8353 {
8354 asection *s = htab->iplt;
8355
8356 ent->plt.offset = s->size;
8357 s->size += PLT_ENTRY_SIZE;
8358
8359 htab->reliplt += sizeof (Elf64_External_Rela);
8360 }
8361 else
8362 ent->plt.offset = (bfd_vma) -1;
8363 }
65f38f15
AM		 8364 }
8365
8366 /* Allocate global sym .plt and .got entries, and space for global
8367 sym dynamic relocs. */
4ce794b7 8368 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
65f38f15 8369
102890f0
AM		 8370 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8371 {
0c8d6e5c 8372 if (!is_ppc64_elf (ibfd))
102890f0
AM		 8373 continue;
8374
8375 if (ppc64_tlsld_got (ibfd)->refcount > 0)
8376 {
8377 s = ppc64_elf_tdata (ibfd)->got;
8378 ppc64_tlsld_got (ibfd)->offset = s->size;
8379 s->size += 16;
8380 if (info->shared)
8381 {
8382 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
8383 srel->size += sizeof (Elf64_External_Rela);
8384 }
8385 }
8386 else
8387 ppc64_tlsld_got (ibfd)->offset = (bfd_vma) -1;
8388 }
8389
65f38f15
AM		 8390 /* We now have determined the sizes of the various dynamic sections.
8391 Allocate memory for them. */
b34976b6 8392 relocs = FALSE;
65f38f15
AM		 8393 for (s = dynobj->sections; s != NULL; s = s->next)
8394 {
8395 if ((s->flags & SEC_LINKER_CREATED) == 0)
8396 continue;
8397
4ce794b7 8398 if (s == htab->brlt || s == htab->relbrlt)
721956f4
AM		 8399 /* These haven't been allocated yet; don't strip. */
8400 continue;
e717da7e
AM		 8401 else if (s == htab->got
8402 || s == htab->plt
e054468f 8403 || s == htab->iplt
c456f082
AM		 8404 || s == htab->glink
8405 || s == htab->dynbss)
65f38f15
AM		 8406 {
8407 /* Strip this section if we don't need it; see the
8408 comment below. */
5bd4f169 8409 }
0112cd26 8410 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
5bd4f169 8411 {
c456f082 8412 if (s->size != 0)
5bd4f169 8413 {
4ce794b7 8414 if (s != htab->relplt)
b34976b6 8415 relocs = TRUE;
5bd4f169
AM		 8416
8417 /* We use the reloc_count field as a counter if we need
8418 to copy relocs into the output file. */
8419 s->reloc_count = 0;
8420 }
8421 }
65f38f15 8422 else
5bd4f169
AM		 8423 {
8424 /* It's not one of our sections, so don't allocate space. */
8425 continue;
8426 }
8427
eea6121a 8428 if (s->size == 0)
5bd4f169 8429 {
c456f082
AM		 8430 /* If we don't need this section, strip it from the
8431 output file. This is mostly to handle .rela.bss and
8432 .rela.plt. We must create both sections in
8433 create_dynamic_sections, because they must be created
8434 before the linker maps input sections to output
8435 sections. The linker does that before
8436 adjust_dynamic_symbol is called, and it is that
8437 function which decides whether anything needs to go
8438 into these sections. */
8423293d 8439 s->flags |= SEC_EXCLUDE;
5bd4f169
AM		 8440 continue;
8441 }
8442
c456f082 8443 if ((s->flags & SEC_HAS_CONTENTS) == 0)
5f333394
AM		 8444 continue;
8445
65f38f15
AM		 8446 /* Allocate memory for the section contents. We use bfd_zalloc
8447 here in case unused entries are not reclaimed before the
8448 section's contents are written out. This should not happen,
411e1bfb
AM		 8449 but this way if it does we get a R_PPC64_NONE reloc in .rela
8450 sections instead of garbage.
8451 We also rely on the section contents being zero when writing
8452 the GOT. */
eea6121a 8453 s->contents = bfd_zalloc (dynobj, s->size);
65f38f15 8454 if (s->contents == NULL)
b34976b6 8455 return FALSE;
5bd4f169
AM		 8456 }
8457
e717da7e
AM		 8458 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8459 {
0c8d6e5c 8460 if (!is_ppc64_elf (ibfd))
7b53ace3
AM		 8461 continue;
8462
e717da7e
AM		 8463 s = ppc64_elf_tdata (ibfd)->got;
8464 if (s != NULL && s != htab->got)
8465 {
eea6121a 8466 if (s->size == 0)
8423293d 8467 s->flags |= SEC_EXCLUDE;
e717da7e
AM		 8468 else
8469 {
eea6121a 8470 s->contents = bfd_zalloc (ibfd, s->size);
e717da7e
AM		 8471 if (s->contents == NULL)
8472 return FALSE;
8473 }
8474 }
8475 s = ppc64_elf_tdata (ibfd)->relgot;
8476 if (s != NULL)
8477 {
eea6121a 8478 if (s->size == 0)
8423293d 8479 s->flags |= SEC_EXCLUDE;
e717da7e
AM		 8480 else
8481 {
eea6121a 8482 s->contents = bfd_zalloc (ibfd, s->size);
e717da7e
AM		 8483 if (s->contents == NULL)
8484 return FALSE;
8485 relocs = TRUE;
8486 s->reloc_count = 0;
8487 }
8488 }
8489 }
8490
e86ce104 8491 if (htab->elf.dynamic_sections_created)
5bd4f169
AM		 8492 {
8493 /* Add some entries to the .dynamic section. We fill in the
8494 values later, in ppc64_elf_finish_dynamic_sections, but we
8495 must add the entries now so that we get the correct size for
8496 the .dynamic section. The DT_DEBUG entry is filled in by the
8497 dynamic linker and used by the debugger. */
dc810e39 8498#define add_dynamic_entry(TAG, VAL) \
5a580b3a 8499 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
dc810e39 8500
36af4a4e 8501 if (info->executable)
5bd4f169 8502 {
dc810e39 8503 if (!add_dynamic_entry (DT_DEBUG, 0))
b34976b6 8504 return FALSE;
5bd4f169
AM		 8505 }
8506
eea6121a 8507 if (htab->plt != NULL && htab->plt->size != 0)
5bd4f169 8508 {
dc810e39
AM		 8509 if (!add_dynamic_entry (DT_PLTGOT, 0)
8510 || !add_dynamic_entry (DT_PLTRELSZ, 0)
8511 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
5d1634d7
AM		 8512 || !add_dynamic_entry (DT_JMPREL, 0)
8513 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
b34976b6 8514 return FALSE;
5bd4f169
AM		 8515 }
8516
19397422
AM		 8517 if (NO_OPD_RELOCS)
8518 {
8519 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
8520 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
b34976b6 8521 return FALSE;
19397422
AM		 8522 }
8523
5bd4f169
AM		 8524 if (relocs)
8525 {
dc810e39
AM		 8526 if (!add_dynamic_entry (DT_RELA, 0)
8527 || !add_dynamic_entry (DT_RELASZ, 0)
8528 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
b34976b6 8529 return FALSE;
5bd4f169 8530
65f38f15
AM		 8531 /* If any dynamic relocs apply to a read-only section,
8532 then we need a DT_TEXTREL entry. */
248866a8 8533 if ((info->flags & DF_TEXTREL) == 0)
4ce794b7 8534 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
5bd4f169 8535
65f38f15 8536 if ((info->flags & DF_TEXTREL) != 0)
5bd4f169 8537 {
65f38f15 8538 if (!add_dynamic_entry (DT_TEXTREL, 0))
b34976b6 8539 return FALSE;
5bd4f169 8540 }
5bd4f169 8541 }
5bd4f169 8542 }
65f38f15 8543#undef add_dynamic_entry
5bd4f169 8544
b34976b6 8545 return TRUE;
5bd4f169
AM		 8546}
8547
721956f4 8548/* Determine the type of stub needed, if any, for a call. */
5bd4f169 8549
4ce794b7
AM		 8550static inline enum ppc_stub_type
8551ppc_type_of_stub (asection *input_sec,
8552 const Elf_Internal_Rela *rel,
8553 struct ppc_link_hash_entry **hash,
e054468f 8554 struct plt_entry **plt_ent,
4ce794b7 8555 bfd_vma destination)
5bd4f169 8556{
721956f4
AM		 8557 struct ppc_link_hash_entry *h = *hash;
8558 bfd_vma location;
8559 bfd_vma branch_offset;
8560 bfd_vma max_branch_offset;
4ce794b7 8561 enum elf_ppc64_reloc_type r_type;
5bd4f169 8562
721956f4
AM		 8563 if (h != NULL)
8564 {
e054468f 8565 struct plt_entry *ent;
7fe2b9a6
AM		 8566 struct ppc_link_hash_entry *fdh = h;
8567 if (fdh->oh != NULL
8568 && fdh->oh->is_func_descriptor)
8569 fdh = fdh->oh;
8387904d 8570
e054468f
AM		 8571 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
8572 if (ent->addend == rel->r_addend
8573 && ent->plt.offset != (bfd_vma) -1)
8574 {
8575 *hash = fdh;
8576 *plt_ent = ent;
8577 return ppc_stub_plt_call;
8578 }
5bd4f169 8579
7fe2b9a6
AM		 8580 /* Here, we know we don't have a plt entry. If we don't have a
8581 either a defined function descriptor or a defined entry symbol
8582 in a regular object file, then it is pointless trying to make
8583 any other type of stub. */
8584 if (!((fdh->elf.root.type == bfd_link_hash_defined
8585 || fdh->elf.root.type == bfd_link_hash_defweak)
8586 && fdh->elf.root.u.def.section->output_section != NULL)
8587 && !((h->elf.root.type == bfd_link_hash_defined
8588 || h->elf.root.type == bfd_link_hash_defweak)
8589 && h->elf.root.u.def.section->output_section != NULL))
721956f4 8590 return ppc_stub_none;
5d1634d7 8591 }
e054468f
AM		 8592 else if (elf_local_got_ents (input_sec->owner) != NULL)
8593 {
8594 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
8595 struct plt_entry **local_plt = (struct plt_entry **)
8596 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
8597 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
8598
8599 if (local_plt[r_symndx] != NULL)
8600 {
8601 struct plt_entry *ent;
8602
8603 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
8604 if (ent->addend == rel->r_addend
8605 && ent->plt.offset != (bfd_vma) -1)
8606 {
8607 *plt_ent = ent;
8608 return ppc_stub_plt_call;
8609 }
8610 }
8611 }
5d1634d7 8612
721956f4
AM		 8613 /* Determine where the call point is. */
8614 location = (input_sec->output_offset
8615 + input_sec->output_section->vma
8616 + rel->r_offset);
5d1634d7 8617
721956f4
AM		 8618 branch_offset = destination - location;
8619 r_type = ELF64_R_TYPE (rel->r_info);
5d1634d7 8620
721956f4
AM		 8621 /* Determine if a long branch stub is needed. */
8622 max_branch_offset = 1 << 25;
4ce794b7 8623 if (r_type != R_PPC64_REL24)
721956f4 8624 max_branch_offset = 1 << 15;
5d1634d7 8625
721956f4
AM		 8626 if (branch_offset + max_branch_offset >= 2 * max_branch_offset)
8627 /* We need a stub. Figure out whether a long_branch or plt_branch
8628 is needed later. */
8629 return ppc_stub_long_branch;
5d1634d7 8630
721956f4 8631 return ppc_stub_none;
5d1634d7
AM		 8632}
8633
8634/* Build a .plt call stub. */
8635
4ce794b7 8636static inline bfd_byte *
176a0d42 8637build_plt_stub (bfd *obfd, bfd_byte *p, int offset, Elf_Internal_Rela *r)
5d1634d7
AM		 8638{
8639#define PPC_LO(v) ((v) & 0xffff)
8640#define PPC_HI(v) (((v) >> 16) & 0xffff)
8641#define PPC_HA(v) PPC_HI ((v) + 0x8000)
8642
ac2df442
AM		 8643 if (PPC_HA (offset) != 0)
8644 {
176a0d42
AM		 8645 if (r != NULL)
8646 {
8647 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
8648 r[1].r_offset = r[0].r_offset + 8;
8649 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
8650 r[1].r_addend = r[0].r_addend;
8651 if (PPC_HA (offset + 16) != PPC_HA (offset))
8652 {
8653 r[2].r_offset = r[1].r_offset + 4;
8654 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
8655 r[2].r_addend = r[0].r_addend;
8656 }
8657 else
8658 {
8659 r[2].r_offset = r[1].r_offset + 8;
8660 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
8661 r[2].r_addend = r[0].r_addend + 8;
8662 r[3].r_offset = r[2].r_offset + 4;
8663 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
8664 r[3].r_addend = r[0].r_addend + 16;
8665 }
8666 }
ac2df442
AM		 8667 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
8668 bfd_put_32 (obfd, STD_R2_40R1, p), p += 4;
8669 bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p), p += 4;
8670 if (PPC_HA (offset + 16) != PPC_HA (offset))
8671 {
8672 bfd_put_32 (obfd, ADDI_R12_R12 | PPC_LO (offset), p), p += 4;
8673 offset = 0;
8674 }
8675 bfd_put_32 (obfd, MTCTR_R11, p), p += 4;
8676 bfd_put_32 (obfd, LD_R2_0R12 | PPC_LO (offset + 8), p), p += 4;
8677 bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset + 16), p), p += 4;
8678 bfd_put_32 (obfd, BCTR, p), p += 4;
8679 }
8680 else
8681 {
176a0d42
AM		 8682 if (r != NULL)
8683 {
8684 r[0].r_offset += 4;
8685 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
8686 if (PPC_HA (offset + 16) != PPC_HA (offset))
8687 {
8688 r[1].r_offset = r[0].r_offset + 4;
8689 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
8690 r[1].r_addend = r[0].r_addend;
8691 }
8692 else
8693 {
8694 r[1].r_offset = r[0].r_offset + 8;
8695 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
8696 r[1].r_addend = r[0].r_addend + 16;
8697 r[2].r_offset = r[1].r_offset + 4;
8698 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
8699 r[2].r_addend = r[0].r_addend + 8;
8700 }
8701 }
ac2df442
AM		 8702 bfd_put_32 (obfd, STD_R2_40R1, p), p += 4;
8703 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset), p), p += 4;
8704 if (PPC_HA (offset + 16) != PPC_HA (offset))
8705 {
8706 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
8707 offset = 0;
8708 }
8709 bfd_put_32 (obfd, MTCTR_R11, p), p += 4;
8710 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
8711 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
8712 bfd_put_32 (obfd, BCTR, p), p += 4;
8713 }
5d1634d7
AM		 8714 return p;
8715}
8716
176a0d42
AM		 8717static Elf_Internal_Rela *
8718get_relocs (asection *sec, int count)
8719{
8720 Elf_Internal_Rela *relocs;
8721 struct bfd_elf_section_data *elfsec_data;
8722
8723 elfsec_data = elf_section_data (sec);
8724 relocs = elfsec_data->relocs;
8725 if (relocs == NULL)
8726 {
8727 bfd_size_type relsize;
8728 relsize = sec->reloc_count * sizeof (*relocs);
8729 relocs = bfd_alloc (sec->owner, relsize);
8730 if (relocs == NULL)
8731 return NULL;
8732 elfsec_data->relocs = relocs;
8733 elfsec_data->rel_hdr.sh_size = (sec->reloc_count
8734 * sizeof (Elf64_External_Rela));
8735 elfsec_data->rel_hdr.sh_entsize = sizeof (Elf64_External_Rela);
8736 sec->reloc_count = 0;
8737 }
8738 relocs += sec->reloc_count;
8739 sec->reloc_count += count;
8740 return relocs;
8741}
8742
b34976b6 8743static bfd_boolean
4ce794b7 8744ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
5d1634d7 8745{
721956f4
AM		 8746 struct ppc_stub_hash_entry *stub_entry;
8747 struct ppc_branch_hash_entry *br_entry;
5d1634d7
AM		 8748 struct bfd_link_info *info;
8749 struct ppc_link_hash_table *htab;
721956f4
AM		 8750 bfd_byte *loc;
8751 bfd_byte *p;
ee75fd95 8752 bfd_vma dest, off;
721956f4 8753 int size;
176a0d42 8754 Elf_Internal_Rela *r;
e054468f 8755 asection *plt;
5d1634d7 8756
721956f4
AM		 8757 /* Massage our args to the form they really have. */
8758 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
4ce794b7 8759 info = in_arg;
5d1634d7 8760
5d1634d7
AM		 8761 htab = ppc_hash_table (info);
8762
721956f4 8763 /* Make a note of the offset within the stubs for this entry. */
eea6121a 8764 stub_entry->stub_offset = stub_entry->stub_sec->size;
97b639ba 8765 loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
721956f4 8766
4ce794b7 8767 htab->stub_count[stub_entry->stub_type - 1] += 1;
721956f4 8768 switch (stub_entry->stub_type)
5d1634d7 8769 {
721956f4 8770 case ppc_stub_long_branch:
ad8e1ba5 8771 case ppc_stub_long_branch_r2off:
721956f4 8772 /* Branches are relative. This is where we are going to. */
ee75fd95
AM		 8773 off = dest = (stub_entry->target_value
8774 + stub_entry->target_section->output_offset
8775 + stub_entry->target_section->output_section->vma);
5d1634d7 8776
721956f4
AM		 8777 /* And this is where we are coming from. */
8778 off -= (stub_entry->stub_offset
97b639ba
AM		 8779 + stub_entry->stub_sec->output_offset
8780 + stub_entry->stub_sec->output_section->vma);
e86ce104 8781
ac2df442
AM		 8782 size = 4;
8783 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
ad8e1ba5
AM		 8784 {
8785 bfd_vma r2off;
8786
8787 r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
8788 - htab->stub_group[stub_entry->id_sec->id].toc_off);
97b639ba 8789 bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
ad8e1ba5 8790 loc += 4;
ac2df442
AM		 8791 size = 12;
8792 if (PPC_HA (r2off) != 0)
8793 {
8794 size = 16;
8795 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
8796 loc += 4;
8797 }
97b639ba 8798 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
ad8e1ba5 8799 loc += 4;
ac2df442 8800 off -= size - 4;
ad8e1ba5 8801 }
97b639ba 8802 bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
ad8e1ba5 8803
5c3dead3
AM		 8804 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
8805 {
8806 (*_bfd_error_handler) (_("long branch stub `%s' offset overflow"),
8807 stub_entry->root.string);
8808 htab->stub_error = TRUE;
8809 return FALSE;
8810 }
ee75fd95
AM		 8811
8812 if (info->emitrelocations)
8813 {
176a0d42
AM		 8814 r = get_relocs (stub_entry->stub_sec, 1);
8815 if (r == NULL)
8816 return FALSE;
ee75fd95
AM		 8817 r->r_offset = loc - stub_entry->stub_sec->contents;
8818 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
8819 r->r_addend = dest;
8820 if (stub_entry->h != NULL)
8821 {
8822 struct elf_link_hash_entry **hashes;
8823 unsigned long symndx;
8824 struct ppc_link_hash_entry *h;
8825
8826 hashes = elf_sym_hashes (htab->stub_bfd);
8827 if (hashes == NULL)
8828 {
8829 bfd_size_type hsize;
8830
8831 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
8832 hashes = bfd_zalloc (htab->stub_bfd, hsize);
8833 if (hashes == NULL)
8834 return FALSE;
8835 elf_sym_hashes (htab->stub_bfd) = hashes;
8836 htab->stub_globals = 1;
8837 }
8838 symndx = htab->stub_globals++;
8839 h = stub_entry->h;
8840 hashes[symndx] = &h->elf;
8841 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
8842 if (h->oh != NULL && h->oh->is_func)
8843 h = h->oh;
8844 if (h->elf.root.u.def.section != stub_entry->target_section)
8845 /* H is an opd symbol. The addend must be zero. */
8846 r->r_addend = 0;
8847 else
8848 {
8849 off = (h->elf.root.u.def.value
8850 + h->elf.root.u.def.section->output_offset
8851 + h->elf.root.u.def.section->output_section->vma);
8852 r->r_addend -= off;
8853 }
8854 }
8855 }
721956f4 8856 break;
e86ce104 8857
721956f4 8858 case ppc_stub_plt_branch:
ad8e1ba5 8859 case ppc_stub_plt_branch_r2off:
721956f4
AM		 8860 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
8861 stub_entry->root.string + 9,
b34976b6 8862 FALSE, FALSE);
721956f4
AM		 8863 if (br_entry == NULL)
8864 {
8865 (*_bfd_error_handler) (_("can't find branch stub `%s'"),
5c3dead3 8866 stub_entry->root.string);
b34976b6
AM		 8867 htab->stub_error = TRUE;
8868 return FALSE;
721956f4
AM		 8869 }
8870
176a0d42
AM		 8871 dest = (stub_entry->target_value
8872 + stub_entry->target_section->output_offset
8873 + stub_entry->target_section->output_section->vma);
721956f4 8874
176a0d42 8875 bfd_put_64 (htab->brlt->owner, dest,
4ce794b7 8876 htab->brlt->contents + br_entry->offset);
721956f4 8877
f94498ff 8878 if (br_entry->iter == htab->stub_iteration)
721956f4 8879 {
f94498ff 8880 br_entry->iter = 0;
84f5d08e 8881
f94498ff 8882 if (htab->relbrlt != NULL)
84f5d08e 8883 {
f94498ff
AM		 8884 /* Create a reloc for the branch lookup table entry. */
8885 Elf_Internal_Rela rela;
8886 bfd_byte *rl;
8887
8888 rela.r_offset = (br_entry->offset
8889 + htab->brlt->output_offset
8890 + htab->brlt->output_section->vma);
8891 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
176a0d42 8892 rela.r_addend = dest;
f94498ff
AM		 8893
8894 rl = htab->relbrlt->contents;
8895 rl += (htab->relbrlt->reloc_count++
8896 * sizeof (Elf64_External_Rela));
8897 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
8898 }
8899 else if (info->emitrelocations)
8900 {
176a0d42
AM		 8901 r = get_relocs (htab->brlt, 1);
8902 if (r == NULL)
8903 return FALSE;
8904 /* brlt, being SEC_LINKER_CREATED does not go through the
8905 normal reloc processing. Symbols and offsets are not
8906 translated from input file to output file form, so
8907 set up the offset per the output file. */
f94498ff
AM		 8908 r->r_offset = (br_entry->offset
8909 + htab->brlt->output_offset
8910 + htab->brlt->output_section->vma);
8911 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
176a0d42 8912 r->r_addend = dest;
84f5d08e 8913 }
84f5d08e 8914 }
721956f4 8915
176a0d42
AM		 8916 dest = (br_entry->offset
8917 + htab->brlt->output_offset
8918 + htab->brlt->output_section->vma);
8919
8920 off = (dest
4ce794b7 8921 - elf_gp (htab->brlt->output_section->owner)
ad8e1ba5 8922 - htab->stub_group[stub_entry->id_sec->id].toc_off);
721956f4 8923
ad8e1ba5 8924 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
5d1634d7
AM		 8925 {
8926 (*_bfd_error_handler)
e86ce104 8927 (_("linkage table error against `%s'"),
721956f4 8928 stub_entry->root.string);
5d1634d7 8929 bfd_set_error (bfd_error_bad_value);
b34976b6
AM		 8930 htab->stub_error = TRUE;
8931 return FALSE;
5d1634d7 8932 }
41bd81ab 8933
176a0d42
AM		 8934 if (info->emitrelocations)
8935 {
8936 r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
8937 if (r == NULL)
8938 return FALSE;
8939 r[0].r_offset = loc - stub_entry->stub_sec->contents;
7cfbafbc
AM		 8940 if (bfd_big_endian (info->output_bfd))
8941 r[0].r_offset += 2;
176a0d42
AM		 8942 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
8943 r[0].r_offset += 4;
8944 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
8945 r[0].r_addend = dest;
8946 if (PPC_HA (off) != 0)
8947 {
8948 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
8949 r[1].r_offset = r[0].r_offset + 4;
8950 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
8951 r[1].r_addend = r[0].r_addend;
8952 }
8953 }
8954
ad8e1ba5
AM		 8955 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
8956 {
176a0d42 8957 if (PPC_HA (off) != 0)
ac2df442
AM		 8958 {
8959 size = 16;
176a0d42 8960 bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
ac2df442 8961 loc += 4;
176a0d42 8962 bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
ac2df442
AM		 8963 }
8964 else
8965 {
8966 size = 12;
176a0d42 8967 bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
ac2df442 8968 }
ad8e1ba5
AM		 8969 }
8970 else
8971 {
8972 bfd_vma r2off;
8973
8974 r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
8975 - htab->stub_group[stub_entry->id_sec->id].toc_off);
97b639ba 8976 bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
ad8e1ba5 8977 loc += 4;
ac2df442 8978 size = 20;
176a0d42 8979 if (PPC_HA (off) != 0)
ac2df442
AM		 8980 {
8981 size += 4;
176a0d42 8982 bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
ac2df442 8983 loc += 4;
176a0d42 8984 bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
ac2df442
AM		 8985 loc += 4;
8986 }
8987 else
8988 {
176a0d42 8989 bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
ac2df442
AM		 8990 loc += 4;
8991 }
8992
8993 if (PPC_HA (r2off) != 0)
8994 {
8995 size += 4;
8996 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
8997 loc += 4;
8998 }
97b639ba 8999 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
ad8e1ba5
AM		 9000 }
9001 loc += 4;
97b639ba 9002 bfd_put_32 (htab->stub_bfd, MTCTR_R11, loc);
ad8e1ba5 9003 loc += 4;
97b639ba 9004 bfd_put_32 (htab->stub_bfd, BCTR, loc);
721956f4 9005 break;
5d1634d7 9006
721956f4 9007 case ppc_stub_plt_call:
c862ae31
AM		 9008 /* Do the best we can for shared libraries built without
9009 exporting ".foo" for each "foo". This can happen when symbol
9010 versioning scripts strip all bar a subset of symbols. */
e054468f
AM		 9011 if (stub_entry->h != NULL
9012 && stub_entry->h->oh != NULL
8387904d 9013 && stub_entry->h->oh->elf.root.type != bfd_link_hash_defined
34814b9f 9014 && stub_entry->h->oh->elf.root.type != bfd_link_hash_defweak)
c862ae31
AM		 9015 {
9016 /* Point the symbol at the stub. There may be multiple stubs,
9017 we don't really care; The main thing is to make this sym
8f3bab57
AM		 9018 defined somewhere. Maybe defining the symbol in the stub
9019 section is a silly idea. If we didn't do this, htab->top_id
9020 could disappear. */
34814b9f
AM		 9021 stub_entry->h->oh->elf.root.type = bfd_link_hash_defined;
9022 stub_entry->h->oh->elf.root.u.def.section = stub_entry->stub_sec;
9023 stub_entry->h->oh->elf.root.u.def.value = stub_entry->stub_offset;
c862ae31
AM		 9024 }
9025
721956f4 9026 /* Now build the stub. */
e054468f 9027 dest = stub_entry->plt_ent->plt.offset & ~1;
176a0d42 9028 if (dest >= (bfd_vma) -2)
721956f4
AM		 9029 abort ();
9030
e054468f
AM		 9031 plt = htab->plt;
9032 if (!htab->elf.dynamic_sections_created)
9033 plt = htab->iplt;
9034
9035 dest += plt->output_offset + plt->output_section->vma;
9036
9037 if (stub_entry->h == NULL
9038 && (stub_entry->plt_ent->plt.offset & 1) == 0)
9039 {
9040 Elf_Internal_Rela rela;
9041 bfd_byte *rl;
9042
9043 rela.r_offset = dest;
9044 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
9045 rela.r_addend = (stub_entry->target_value
9046 + stub_entry->target_section->output_offset
9047 + stub_entry->target_section->output_section->vma);
9048
9049 if (!htab->elf.dynamic_sections_created)
9050 rl = (htab->reliplt->contents
9051 + (stub_entry->plt_ent->plt.offset
9052 / (PLT_ENTRY_SIZE / sizeof (Elf64_External_Rela))));
9053 else
9054 rl = (htab->relplt->contents
9055 + ((stub_entry->plt_ent->plt.offset - PLT_INITIAL_ENTRY_SIZE)
9056 / (PLT_ENTRY_SIZE / sizeof (Elf64_External_Rela))));
9057 bfd_elf32_swap_reloca_out (info->output_bfd, &rela, rl);
9058 stub_entry->plt_ent->plt.offset |= 1;
9059 }
176a0d42
AM		 9060
9061 off = (dest
e054468f 9062 - elf_gp (plt->output_section->owner)
176a0d42 9063 - htab->stub_group[stub_entry->id_sec->id].toc_off);
721956f4 9064
ad8e1ba5 9065 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
721956f4
AM		 9066 {
9067 (*_bfd_error_handler)
9068 (_("linkage table error against `%s'"),
e054468f
AM		 9069 stub_entry->h != NULL
9070 ? stub_entry->h->elf.root.root.string
9071 : "<local sym>");
721956f4 9072 bfd_set_error (bfd_error_bad_value);
b34976b6
AM		 9073 htab->stub_error = TRUE;
9074 return FALSE;
721956f4
AM		 9075 }
9076
176a0d42
AM		 9077 r = NULL;
9078 if (info->emitrelocations)
9079 {
9080 r = get_relocs (stub_entry->stub_sec,
9081 (2 + (PPC_HA (off) != 0)
9082 + (PPC_HA (off + 16) == PPC_HA (off))));
9083 if (r == NULL)
9084 return FALSE;
9085 r[0].r_offset = loc - stub_entry->stub_sec->contents;
7cfbafbc
AM		 9086 if (bfd_big_endian (info->output_bfd))
9087 r[0].r_offset += 2;
176a0d42
AM		 9088 r[0].r_addend = dest;
9089 }
9090 p = build_plt_stub (htab->stub_bfd, loc, off, r);
721956f4
AM		 9091 size = p - loc;
9092 break;
9093
9094 default:
9095 BFD_FAIL ();
b34976b6 9096 return FALSE;
721956f4
AM		 9097 }
9098
eea6121a 9099 stub_entry->stub_sec->size += size;
97b639ba 9100
ee75fd95 9101 if (htab->emit_stub_syms)
97b639ba
AM		 9102 {
9103 struct elf_link_hash_entry *h;
ee75fd95
AM		 9104 size_t len1, len2;
9105 char *name;
9106 const char *const stub_str[] = { "long_branch",
9107 "long_branch_r2off",
9108 "plt_branch",
9109 "plt_branch_r2off",
9110 "plt_call" };
9111
9112 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
9113 len2 = strlen (stub_entry->root.string);
9114 name = bfd_malloc (len1 + len2 + 2);
9115 if (name == NULL)
9116 return FALSE;
9117 memcpy (name, stub_entry->root.string, 9);
9118 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
9119 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
9120 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
97b639ba
AM		 9121 if (h == NULL)
9122 return FALSE;
9123 if (h->root.type == bfd_link_hash_new)
9124 {
9125 h->root.type = bfd_link_hash_defined;
9126 h->root.u.def.section = stub_entry->stub_sec;
9127 h->root.u.def.value = stub_entry->stub_offset;
f5385ebf
AM		 9128 h->ref_regular = 1;
9129 h->def_regular = 1;
9130 h->ref_regular_nonweak = 1;
9131 h->forced_local = 1;
9132 h->non_elf = 0;
97b639ba
AM		 9133 }
9134 }
9135
b34976b6 9136 return TRUE;
721956f4
AM		 9137}
9138
9139/* As above, but don't actually build the stub. Just bump offset so
9140 we know stub section sizes, and select plt_branch stubs where
9141 long_branch stubs won't do. */
9142
b34976b6 9143static bfd_boolean
4ce794b7 9144ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
721956f4
AM		 9145{
9146 struct ppc_stub_hash_entry *stub_entry;
63bc6f6c 9147 struct bfd_link_info *info;
721956f4
AM		 9148 struct ppc_link_hash_table *htab;
9149 bfd_vma off;
9150 int size;
9151
9152 /* Massage our args to the form they really have. */
9153 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
63bc6f6c
AM		 9154 info = in_arg;
9155
9156 htab = ppc_hash_table (info);
721956f4
AM		 9157
9158 if (stub_entry->stub_type == ppc_stub_plt_call)
9159 {
e054468f
AM		 9160 asection *plt;
9161 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
58ac9f71 9162 if (off >= (bfd_vma) -2)
411e1bfb 9163 abort ();
e054468f
AM		 9164 plt = htab->plt;
9165 if (!htab->elf.dynamic_sections_created)
9166 plt = htab->iplt;
9167 off += (plt->output_offset
9168 + plt->output_section->vma
9169 - elf_gp (plt->output_section->owner)
ad8e1ba5 9170 - htab->stub_group[stub_entry->id_sec->id].toc_off);
721956f4 9171
ad8e1ba5 9172 size = PLT_CALL_STUB_SIZE;
ac2df442
AM		 9173 if (PPC_HA (off) == 0)
9174 size -= 4;
4ce794b7 9175 if (PPC_HA (off + 16) != PPC_HA (off))
721956f4 9176 size += 4;
176a0d42
AM		 9177 if (info->emitrelocations)
9178 {
9179 stub_entry->stub_sec->reloc_count
9180 += 2 + (PPC_HA (off) != 0) + (PPC_HA (off + 16) == PPC_HA (off));
9181 stub_entry->stub_sec->flags |= SEC_RELOC;
9182 }
721956f4
AM		 9183 }
9184 else
9185 {
ad8e1ba5
AM		 9186 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
9187 variants. */
ac2df442
AM		 9188 bfd_vma r2off = 0;
9189
721956f4
AM		 9190 off = (stub_entry->target_value
9191 + stub_entry->target_section->output_offset
9192 + stub_entry->target_section->output_section->vma);
eea6121a 9193 off -= (stub_entry->stub_sec->size
721956f4
AM		 9194 + stub_entry->stub_sec->output_offset
9195 + stub_entry->stub_sec->output_section->vma);
9196
ad8e1ba5
AM		 9197 /* Reset the stub type from the plt variant in case we now
9198 can reach with a shorter stub. */
9199 if (stub_entry->stub_type >= ppc_stub_plt_branch)
9200 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
9201
9202 size = 4;
9203 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
9204 {
ac2df442
AM		 9205 r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
9206 - htab->stub_group[stub_entry->id_sec->id].toc_off);
9207 size = 12;
9208 if (PPC_HA (r2off) != 0)
9209 size = 16;
9210 off -= size - 4;
ad8e1ba5
AM		 9211 }
9212
9213 /* If the branch offset if too big, use a ppc_stub_plt_branch. */
721956f4
AM		 9214 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
9215 {
9216 struct ppc_branch_hash_entry *br_entry;
9217
9218 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
9219 stub_entry->root.string + 9,
b34976b6 9220 TRUE, FALSE);
721956f4
AM		 9221 if (br_entry == NULL)
9222 {
9223 (*_bfd_error_handler) (_("can't build branch stub `%s'"),
5c3dead3 9224 stub_entry->root.string);
b34976b6
AM		 9225 htab->stub_error = TRUE;
9226 return FALSE;
721956f4
AM		 9227 }
9228
9229 if (br_entry->iter != htab->stub_iteration)
9230 {
9231 br_entry->iter = htab->stub_iteration;
eea6121a
AM		 9232 br_entry->offset = htab->brlt->size;
9233 htab->brlt->size += 8;
63bc6f6c 9234
ee75fd95 9235 if (htab->relbrlt != NULL)
eea6121a 9236 htab->relbrlt->size += sizeof (Elf64_External_Rela);
84f5d08e
AM		 9237 else if (info->emitrelocations)
9238 {
9239 htab->brlt->reloc_count += 1;
9240 htab->brlt->flags |= SEC_RELOC;
9241 }
721956f4 9242 }
ad8e1ba5
AM		 9243
9244 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
ac2df442
AM		 9245 off = (br_entry->offset
9246 + htab->brlt->output_offset
9247 + htab->brlt->output_section->vma
9248 - elf_gp (htab->brlt->output_section->owner)
9249 - htab->stub_group[stub_entry->id_sec->id].toc_off);
9250
176a0d42
AM		 9251 if (info->emitrelocations)
9252 {
9253 stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
9254 stub_entry->stub_sec->flags |= SEC_RELOC;
9255 }
9256
ac2df442
AM		 9257 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
9258 {
9259 size = 12;
176a0d42 9260 if (PPC_HA (off) != 0)
ac2df442
AM		 9261 size = 16;
9262 }
9263 else
9264 {
9265 size = 20;
176a0d42 9266 if (PPC_HA (off) != 0)
ac2df442
AM		 9267 size += 4;
9268
9269 if (PPC_HA (r2off) != 0)
9270 size += 4;
9271 }
721956f4 9272 }
84f5d08e
AM		 9273 else if (info->emitrelocations)
9274 {
9275 stub_entry->stub_sec->reloc_count += 1;
9276 stub_entry->stub_sec->flags |= SEC_RELOC;
9277 }
721956f4
AM		 9278 }
9279
eea6121a 9280 stub_entry->stub_sec->size += size;
b34976b6 9281 return TRUE;
721956f4
AM		 9282}
9283
9284/* Set up various things so that we can make a list of input sections
9285 for each output section included in the link. Returns -1 on error,
cedb70c5 9286 0 when no stubs will be needed, and 1 on success. */
721956f4
AM		 9287
9288int
4c52953f
AM		 9289ppc64_elf_setup_section_lists (bfd *output_bfd,
9290 struct bfd_link_info *info,
9291 int no_multi_toc)
721956f4
AM		 9292{
9293 bfd *input_bfd;
734b6cf9 9294 int top_id, top_index, id;
721956f4 9295 asection *section;
734b6cf9 9296 asection **input_list;
721956f4
AM		 9297 bfd_size_type amt;
9298 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9299
4c52953f
AM		 9300 htab->no_multi_toc = no_multi_toc;
9301
4ce794b7 9302 if (htab->brlt == NULL)
721956f4
AM		 9303 return 0;
9304
1e2f5b6e 9305 /* Find the top input section id. */
3d6f9012 9306 for (input_bfd = info->input_bfds, top_id = 3;
721956f4
AM		 9307 input_bfd != NULL;
9308 input_bfd = input_bfd->link_next)
9309 {
721956f4
AM		 9310 for (section = input_bfd->sections;
9311 section != NULL;
9312 section = section->next)
9313 {
9314 if (top_id < section->id)
9315 top_id = section->id;
9316 }
9317 }
721956f4 9318
8f3bab57 9319 htab->top_id = top_id;
721956f4 9320 amt = sizeof (struct map_stub) * (top_id + 1);
4ce794b7 9321 htab->stub_group = bfd_zmalloc (amt);
721956f4
AM		 9322 if (htab->stub_group == NULL)
9323 return -1;
9324
3d6f9012
AM		 9325 /* Set toc_off for com, und, abs and ind sections. */
9326 for (id = 0; id < 3; id++)
9327 htab->stub_group[id].toc_off = TOC_BASE_OFF;
721956f4 9328
3d6f9012 9329 elf_gp (output_bfd) = htab->toc_curr = ppc64_elf_toc (output_bfd);
734b6cf9
AM		 9330
9331 /* We can't use output_bfd->section_count here to find the top output
9332 section index as some sections may have been removed, and
8423293d 9333 strip_excluded_output_sections doesn't renumber the indices. */
734b6cf9
AM		 9334 for (section = output_bfd->sections, top_index = 0;
9335 section != NULL;
9336 section = section->next)
9337 {
9338 if (top_index < section->index)
9339 top_index = section->index;
9340 }
9341
9342 htab->top_index = top_index;
9343 amt = sizeof (asection *) * (top_index + 1);
4ce794b7 9344 input_list = bfd_zmalloc (amt);
734b6cf9
AM		 9345 htab->input_list = input_list;
9346 if (input_list == NULL)
9347 return -1;
9348
721956f4
AM		 9349 return 1;
9350}
9351
e717da7e
AM		 9352/* The linker repeatedly calls this function for each TOC input section
9353 and linker generated GOT section. Group input bfds such that the toc
9354 within a group is less than 64k in size. Will break with cute linker
9355 scripts that play games with dot in the output toc section. */
ad8e1ba5
AM		 9356
9357void
4ce794b7 9358ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
ad8e1ba5
AM		 9359{
9360 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9361
4c52953f
AM		 9362 if (!htab->no_multi_toc)
9363 {
9364 bfd_vma addr = isec->output_offset + isec->output_section->vma;
9365 bfd_vma off = addr - htab->toc_curr;
9366
9367 if (off + isec->size > 0x10000)
9368 htab->toc_curr = addr;
99877b66 9369
4c52953f
AM		 9370 elf_gp (isec->owner) = (htab->toc_curr
9371 - elf_gp (isec->output_section->owner)
9372 + TOC_BASE_OFF);
9373 }
ad8e1ba5
AM		 9374}
9375
9376/* Called after the last call to the above function. */
9377
9378void
4c52953f 9379ppc64_elf_reinit_toc (bfd *output_bfd, struct bfd_link_info *info)
ad8e1ba5
AM		 9380{
9381 struct ppc_link_hash_table *htab = ppc_hash_table (info);
ad8e1ba5 9382
4c52953f
AM		 9383 htab->multi_toc_needed = htab->toc_curr != elf_gp (output_bfd);
9384
ad8e1ba5
AM		 9385 /* toc_curr tracks the TOC offset used for code sections below in
9386 ppc64_elf_next_input_section. Start off at 0x8000. */
3d6f9012 9387 htab->toc_curr = TOC_BASE_OFF;
ad8e1ba5
AM		 9388}
9389
9b5ecbd0
AM		 9390/* No toc references were found in ISEC. If the code in ISEC makes no
9391 calls, then there's no need to use toc adjusting stubs when branching
9392 into ISEC. Actually, indirect calls from ISEC are OK as they will
4c52953f
AM		 9393 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
9394 needed, and 2 if a cyclical call-graph was found but no other reason
9395 for a stub was detected. If called from the top level, a return of
9396 2 means the same as a return of 0. */
9b5ecbd0
AM		 9397
9398static int
4ce794b7 9399toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
9b5ecbd0 9400{
4c52953f
AM		 9401 Elf_Internal_Rela *relstart, *rel;
9402 Elf_Internal_Sym *local_syms;
9b5ecbd0 9403 int ret;
4c52953f 9404 struct ppc_link_hash_table *htab;
9b5ecbd0 9405
772119ce
AM		 9406 /* We know none of our code bearing sections will need toc stubs. */
9407 if ((isec->flags & SEC_LINKER_CREATED) != 0)
9408 return 0;
9409
eea6121a 9410 if (isec->size == 0)
082c50f8
AM		 9411 return 0;
9412
4c52953f
AM		 9413 if (isec->output_section == NULL)
9414 return 0;
9415
4c52953f
AM		 9416 if (isec->reloc_count == 0)
9417 return 0;
9418
9419 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
9420 info->keep_memory);
9421 if (relstart == NULL)
9422 return -1;
9423
9424 /* Look for branches to outside of this section. */
9425 local_syms = NULL;
9426 ret = 0;
9427 htab = ppc_hash_table (info);
9428 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
9b5ecbd0 9429 {
4c52953f
AM		 9430 enum elf_ppc64_reloc_type r_type;
9431 unsigned long r_symndx;
9432 struct elf_link_hash_entry *h;
90aecf7a 9433 struct ppc_link_hash_entry *eh;
4c52953f
AM		 9434 Elf_Internal_Sym *sym;
9435 asection *sym_sec;
74f0fb50 9436 struct _opd_sec_data *opd;
4c52953f
AM		 9437 bfd_vma sym_value;
9438 bfd_vma dest;
9439
9440 r_type = ELF64_R_TYPE (rel->r_info);
9441 if (r_type != R_PPC64_REL24
9442 && r_type != R_PPC64_REL14
9443 && r_type != R_PPC64_REL14_BRTAKEN
9444 && r_type != R_PPC64_REL14_BRNTAKEN)
9445 continue;
9446
9447 r_symndx = ELF64_R_SYM (rel->r_info);
9448 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
9449 isec->owner))
9b5ecbd0 9450 {
4c52953f
AM		 9451 ret = -1;
9452 break;
9b5ecbd0 9453 }
9b5ecbd0 9454
2917689a 9455 /* Calls to dynamic lib functions go through a plt call stub
90aecf7a
AM		 9456 that uses r2. */
9457 eh = (struct ppc_link_hash_entry *) h;
9458 if (eh != NULL
9459 && (eh->elf.plt.plist != NULL
9460 || (eh->oh != NULL
9461 && eh->oh->elf.plt.plist != NULL)))
2917689a 9462 {
90aecf7a
AM		 9463 ret = 1;
9464 break;
2917689a
AM		 9465 }
9466
90aecf7a
AM		 9467 if (sym_sec == NULL)
9468 /* Ignore other undefined symbols. */
9469 continue;
9470
2917689a
AM		 9471 /* Assume branches to other sections not included in the link need
9472 stubs too, to cover -R and absolute syms. */
4c52953f
AM		 9473 if (sym_sec->output_section == NULL)
9474 {
9475 ret = 1;
9476 break;
9477 }
9478
9479 if (h == NULL)
9480 sym_value = sym->st_value;
9481 else
9482 {
9483 if (h->root.type != bfd_link_hash_defined
9484 && h->root.type != bfd_link_hash_defweak)
9485 abort ();
9486 sym_value = h->root.u.def.value;
9487 }
9488 sym_value += rel->r_addend;
9489
9490 /* If this branch reloc uses an opd sym, find the code section. */
74f0fb50
AM		 9491 opd = get_opd_info (sym_sec);
9492 if (opd != NULL)
4c52953f 9493 {
74f0fb50 9494 if (h == NULL && opd->adjust != NULL)
4c52953f
AM		 9495 {
9496 long adjust;
9497
74f0fb50 9498 adjust = opd->adjust[sym->st_value / 8];
4c52953f
AM		 9499 if (adjust == -1)
9500 /* Assume deleted functions won't ever be called. */
9501 continue;
9502 sym_value += adjust;
9503 }
9504
9505 dest = opd_entry_value (sym_sec, sym_value, &sym_sec, NULL);
9506 if (dest == (bfd_vma) -1)
9507 continue;
9508 }
9509 else
9510 dest = (sym_value
9511 + sym_sec->output_offset
9512 + sym_sec->output_section->vma);
9513
9514 /* Ignore branch to self. */
9515 if (sym_sec == isec)
9516 continue;
9517
9518 /* If the called function uses the toc, we need a stub. */
9519 if (sym_sec->has_toc_reloc
9520 || sym_sec->makes_toc_func_call)
9521 {
9522 ret = 1;
9523 break;
9524 }
9525
9526 /* Assume any branch that needs a long branch stub might in fact
9527 need a plt_branch stub. A plt_branch stub uses r2. */
9528 else if (dest - (isec->output_offset
9529 + isec->output_section->vma
9530 + rel->r_offset) + (1 << 25) >= (2 << 25))
9b5ecbd0
AM		 9531 {
9532 ret = 1;
9533 break;
9534 }
4c52953f
AM		 9535
9536 /* If calling back to a section in the process of being tested, we
9537 can't say for sure that no toc adjusting stubs are needed, so
9538 don't return zero. */
9539 else if (sym_sec->call_check_in_progress)
9540 ret = 2;
9541
9542 /* Branches to another section that itself doesn't have any TOC
9543 references are OK. Recursively call ourselves to check. */
9544 else if (sym_sec->id <= htab->top_id
9545 && htab->stub_group[sym_sec->id].toc_off == 0)
9546 {
9547 int recur;
9548
9549 /* Mark current section as indeterminate, so that other
9550 sections that call back to current won't be marked as
9551 known. */
9552 isec->call_check_in_progress = 1;
9553 recur = toc_adjusting_stub_needed (info, sym_sec);
9554 isec->call_check_in_progress = 0;
9555
9556 if (recur < 0)
9557 {
9558 /* An error. Exit. */
9559 ret = -1;
9560 break;
9561 }
9562 else if (recur <= 1)
9563 {
9564 /* Known result. Mark as checked and set section flag. */
9565 htab->stub_group[sym_sec->id].toc_off = 1;
9566 if (recur != 0)
9567 {
9568 sym_sec->makes_toc_func_call = 1;
9569 ret = 1;
9570 break;
9571 }
9572 }
9573 else
9574 {
9575 /* Unknown result. Continue checking. */
9576 ret = 2;
9577 }
9578 }
9b5ecbd0
AM		 9579 }
9580
4c52953f 9581 if (local_syms != NULL
0ffa91dd 9582 && (elf_symtab_hdr (isec->owner).contents != (unsigned char *) local_syms))
4c52953f
AM		 9583 free (local_syms);
9584 if (elf_section_data (isec)->relocs != relstart)
9585 free (relstart);
9586
9b5ecbd0
AM		 9587 return ret;
9588}
9589
721956f4
AM		 9590/* The linker repeatedly calls this function for each input section,
9591 in the order that input sections are linked into output sections.
9592 Build lists of input sections to determine groupings between which
9593 we may insert linker stubs. */
9594
9b5ecbd0 9595bfd_boolean
4ce794b7 9596ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
721956f4
AM		 9597{
9598 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9599
734b6cf9
AM		 9600 if ((isec->output_section->flags & SEC_CODE) != 0
9601 && isec->output_section->index <= htab->top_index)
721956f4 9602 {
734b6cf9 9603 asection **list = htab->input_list + isec->output_section->index;
3d6f9012 9604 /* Steal the link_sec pointer for our list. */
721956f4 9605#define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
3d6f9012
AM		 9606 /* This happens to make the list in reverse order,
9607 which is what we want. */
734b6cf9
AM		 9608 PREV_SEC (isec) = *list;
9609 *list = isec;
721956f4 9610 }
ad8e1ba5 9611
4c52953f 9612 if (htab->multi_toc_needed)
9b5ecbd0 9613 {
4c52953f
AM		 9614 /* If a code section has a function that uses the TOC then we need
9615 to use the right TOC (obviously). Also, make sure that .opd gets
9616 the correct TOC value for R_PPC64_TOC relocs that don't have or
f94498ff
AM		 9617 can't find their function symbol (shouldn't ever happen now).
9618 Also specially treat .fixup for the linux kernel. .fixup
9619 contains branches, but only back to the function that hit an
9620 exception. */
9621 if (isec->has_toc_reloc
9622 || (isec->flags & SEC_CODE) == 0
9623 || strcmp (isec->name, ".fixup") == 0)
4c52953f
AM		 9624 {
9625 if (elf_gp (isec->owner) != 0)
9626 htab->toc_curr = elf_gp (isec->owner);
9627 }
9628 else if (htab->stub_group[isec->id].toc_off == 0)
9629 {
9630 int ret = toc_adjusting_stub_needed (info, isec);
9631 if (ret < 0)
9632 return FALSE;
9633 else
9634 isec->makes_toc_func_call = ret & 1;
9635 }
9b5ecbd0 9636 }
ad8e1ba5
AM		 9637
9638 /* Functions that don't use the TOC can belong in any TOC group.
9639 Use the last TOC base. This happens to make _init and _fini
9640 pasting work. */
9641 htab->stub_group[isec->id].toc_off = htab->toc_curr;
9b5ecbd0 9642 return TRUE;
721956f4
AM		 9643}
9644
9645/* See whether we can group stub sections together. Grouping stub
9646 sections may result in fewer stubs. More importantly, we need to
9647 put all .init* and .fini* stubs at the beginning of the .init or
9648 .fini output sections respectively, because glibc splits the
9649 _init and _fini functions into multiple parts. Putting a stub in
9650 the middle of a function is not a good idea. */
9651
9652static void
4ce794b7
AM		 9653group_sections (struct ppc_link_hash_table *htab,
9654 bfd_size_type stub_group_size,
9655 bfd_boolean stubs_always_before_branch)
721956f4 9656{
7c8fe5c4
AM		 9657 asection **list;
9658 bfd_size_type stub14_group_size;
9659 bfd_boolean suppress_size_errors;
9660
9661 suppress_size_errors = FALSE;
9662 stub14_group_size = stub_group_size;
9663 if (stub_group_size == 1)
9664 {
9665 /* Default values. */
9666 if (stubs_always_before_branch)
9667 {
9668 stub_group_size = 0x1e00000;
9669 stub14_group_size = 0x7800;
9670 }
9671 else
9672 {
9673 stub_group_size = 0x1c00000;
9674 stub14_group_size = 0x7000;
9675 }
9676 suppress_size_errors = TRUE;
9677 }
9678
9679 list = htab->input_list + htab->top_index;
734b6cf9 9680 do
721956f4 9681 {
734b6cf9
AM		 9682 asection *tail = *list;
9683 while (tail != NULL)
721956f4 9684 {
734b6cf9
AM		 9685 asection *curr;
9686 asection *prev;
9687 bfd_size_type total;
9688 bfd_boolean big_sec;
9689 bfd_vma curr_toc;
9690
9691 curr = tail;
eea6121a 9692 total = tail->size;
7c8fe5c4
AM		 9693 big_sec = total > (ppc64_elf_section_data (tail)->has_14bit_branch
9694 ? stub14_group_size : stub_group_size);
9695 if (big_sec && !suppress_size_errors)
5c3dead3
AM		 9696 (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
9697 tail->owner, tail);
734b6cf9
AM		 9698 curr_toc = htab->stub_group[tail->id].toc_off;
9699
9700 while ((prev = PREV_SEC (curr)) != NULL
9701 && ((total += curr->output_offset - prev->output_offset)
7c8fe5c4
AM		 9702 < (ppc64_elf_section_data (prev)->has_14bit_branch
9703 ? stub14_group_size : stub_group_size))
ad8e1ba5 9704 && htab->stub_group[prev->id].toc_off == curr_toc)
734b6cf9
AM		 9705 curr = prev;
9706
9707 /* OK, the size from the start of CURR to the end is less
9708 than stub_group_size and thus can be handled by one stub
9709 section. (or the tail section is itself larger than
9710 stub_group_size, in which case we may be toast.) We
9711 should really be keeping track of the total size of stubs
9712 added here, as stubs contribute to the final output
9713 section size. That's a little tricky, and this way will
9714 only break if stubs added make the total size more than
9715 2^25, ie. for the default stub_group_size, if stubs total
9716 more than 2097152 bytes, or nearly 75000 plt call stubs. */
9717 do
721956f4
AM		 9718 {
9719 prev = PREV_SEC (tail);
734b6cf9 9720 /* Set up this stub group. */
721956f4
AM		 9721 htab->stub_group[tail->id].link_sec = curr;
9722 }
734b6cf9
AM		 9723 while (tail != curr && (tail = prev) != NULL);
9724
9725 /* But wait, there's more! Input sections up to stub_group_size
9726 bytes before the stub section can be handled by it too.
9727 Don't do this if we have a really large section after the
9728 stubs, as adding more stubs increases the chance that
9729 branches may not reach into the stub section. */
9730 if (!stubs_always_before_branch && !big_sec)
9731 {
9732 total = 0;
9733 while (prev != NULL
9734 && ((total += tail->output_offset - prev->output_offset)
7c8fe5c4
AM		 9735 < (ppc64_elf_section_data (prev)->has_14bit_branch
9736 ? stub14_group_size : stub_group_size))
734b6cf9
AM		 9737 && htab->stub_group[prev->id].toc_off == curr_toc)
9738 {
9739 tail = prev;
9740 prev = PREV_SEC (tail);
9741 htab->stub_group[tail->id].link_sec = curr;
9742 }
9743 }
9744 tail = prev;
721956f4
AM		 9745 }
9746 }
734b6cf9
AM		 9747 while (list-- != htab->input_list);
9748 free (htab->input_list);
721956f4
AM		 9749#undef PREV_SEC
9750}
9751
721956f4
AM		 9752/* Determine and set the size of the stub section for a final link.
9753
9754 The basic idea here is to examine all the relocations looking for
9755 PC-relative calls to a target that is unreachable with a "bl"
9756 instruction. */
9757
b34976b6 9758bfd_boolean
4ce794b7 9759ppc64_elf_size_stubs (bfd *output_bfd,
4ce794b7
AM		 9760 struct bfd_link_info *info,
9761 bfd_signed_vma group_size,
9762 asection *(*add_stub_section) (const char *, asection *),
9763 void (*layout_sections_again) (void))
721956f4
AM		 9764{
9765 bfd_size_type stub_group_size;
b34976b6 9766 bfd_boolean stubs_always_before_branch;
721956f4
AM		 9767 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9768
9769 /* Stash our params away. */
721956f4
AM		 9770 htab->add_stub_section = add_stub_section;
9771 htab->layout_sections_again = layout_sections_again;
9772 stubs_always_before_branch = group_size < 0;
9773 if (group_size < 0)
9774 stub_group_size = -group_size;
9775 else
9776 stub_group_size = group_size;
721956f4
AM		 9777
9778 group_sections (htab, stub_group_size, stubs_always_before_branch);
9779
721956f4
AM		 9780 while (1)
9781 {
9782 bfd *input_bfd;
9783 unsigned int bfd_indx;
9784 asection *stub_sec;
721956f4
AM		 9785
9786 htab->stub_iteration += 1;
721956f4
AM		 9787
9788 for (input_bfd = info->input_bfds, bfd_indx = 0;
9789 input_bfd != NULL;
9790 input_bfd = input_bfd->link_next, bfd_indx++)
9791 {
9792 Elf_Internal_Shdr *symtab_hdr;
9793 asection *section;
6cdc0ccc 9794 Elf_Internal_Sym *local_syms = NULL;
721956f4 9795
0c8d6e5c 9796 if (!is_ppc64_elf (input_bfd))
67f93c31
AM		 9797 continue;
9798
721956f4 9799 /* We'll need the symbol table in a second. */
0ffa91dd 9800 symtab_hdr = &elf_symtab_hdr (input_bfd);
721956f4
AM		 9801 if (symtab_hdr->sh_info == 0)
9802 continue;
9803
721956f4
AM		 9804 /* Walk over each section attached to the input bfd. */
9805 for (section = input_bfd->sections;
9806 section != NULL;
9807 section = section->next)
9808 {
721956f4 9809 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
721956f4
AM		 9810
9811 /* If there aren't any relocs, then there's nothing more
9812 to do. */
9813 if ((section->flags & SEC_RELOC) == 0
12c0f757
AM		 9814 || (section->flags & SEC_ALLOC) == 0
9815 || (section->flags & SEC_LOAD) == 0
9816 || (section->flags & SEC_CODE) == 0
721956f4
AM		 9817 || section->reloc_count == 0)
9818 continue;
9819
9820 /* If this section is a link-once section that will be
9821 discarded, then don't create any stubs. */
9822 if (section->output_section == NULL
9823 || section->output_section->owner != output_bfd)
9824 continue;
9825
1e2f5b6e
AM		 9826 /* Get the relocs. */
9827 internal_relocs
4ce794b7 9828 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
45d6a902 9829 info->keep_memory);
721956f4 9830 if (internal_relocs == NULL)
1e2f5b6e 9831 goto error_ret_free_local;
721956f4
AM		 9832
9833 /* Now examine each relocation. */
9834 irela = internal_relocs;
9835 irelaend = irela + section->reloc_count;
9836 for (; irela < irelaend; irela++)
9837 {
4ce794b7
AM		 9838 enum elf_ppc64_reloc_type r_type;
9839 unsigned int r_indx;
721956f4
AM		 9840 enum ppc_stub_type stub_type;
9841 struct ppc_stub_hash_entry *stub_entry;
8387904d 9842 asection *sym_sec, *code_sec;
e054468f 9843 bfd_vma sym_value, code_value;
721956f4 9844 bfd_vma destination;
8843416a 9845 bfd_boolean ok_dest;
721956f4 9846 struct ppc_link_hash_entry *hash;
8387904d 9847 struct ppc_link_hash_entry *fdh;
411e1bfb
AM		 9848 struct elf_link_hash_entry *h;
9849 Elf_Internal_Sym *sym;
721956f4
AM		 9850 char *stub_name;
9851 const asection *id_sec;
74f0fb50 9852 struct _opd_sec_data *opd;
e054468f 9853 struct plt_entry *plt_ent;
721956f4
AM		 9854
9855 r_type = ELF64_R_TYPE (irela->r_info);
9856 r_indx = ELF64_R_SYM (irela->r_info);
9857
4ce794b7 9858 if (r_type >= R_PPC64_max)
721956f4
AM		 9859 {
9860 bfd_set_error (bfd_error_bad_value);
6cdc0ccc 9861 goto error_ret_free_internal;
721956f4
AM		 9862 }
9863
9864 /* Only look for stubs on branch instructions. */
4ce794b7
AM		 9865 if (r_type != R_PPC64_REL24
9866 && r_type != R_PPC64_REL14
9867 && r_type != R_PPC64_REL14_BRTAKEN
9868 && r_type != R_PPC64_REL14_BRNTAKEN)
721956f4
AM		 9869 continue;
9870
9871 /* Now determine the call target, its name, value,
9872 section. */
411e1bfb
AM		 9873 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9874 r_indx, input_bfd))
9875 goto error_ret_free_internal;
9876 hash = (struct ppc_link_hash_entry *) h;
9877
8843416a 9878 ok_dest = FALSE;
8387904d 9879 fdh = NULL;
7fe2b9a6 9880 sym_value = 0;
411e1bfb 9881 if (hash == NULL)
721956f4 9882 {
411e1bfb 9883 sym_value = sym->st_value;
8843416a 9884 ok_dest = TRUE;
721956f4 9885 }
7fe2b9a6
AM		 9886 else if (hash->elf.root.type == bfd_link_hash_defined
9887 || hash->elf.root.type == bfd_link_hash_defweak)
9888 {
9889 sym_value = hash->elf.root.u.def.value;
9890 if (sym_sec->output_section != NULL)
9891 ok_dest = TRUE;
9892 }
9893 else if (hash->elf.root.type == bfd_link_hash_undefweak
9894 || hash->elf.root.type == bfd_link_hash_undefined)
721956f4 9895 {
99877b66 9896 /* Recognise an old ABI func code entry sym, and
7fe2b9a6
AM		 9897 use the func descriptor sym instead if it is
9898 defined. */
ceb1f1ef 9899 if (hash->elf.root.root.string[0] == '.'
8387904d
AM		 9900 && (fdh = get_fdh (hash, htab)) != NULL)
9901 {
8387904d
AM		 9902 if (fdh->elf.root.type == bfd_link_hash_defined
9903 || fdh->elf.root.type == bfd_link_hash_defweak)
9904 {
9905 sym_sec = fdh->elf.root.u.def.section;
9906 sym_value = fdh->elf.root.u.def.value;
9907 if (sym_sec->output_section != NULL)
9908 ok_dest = TRUE;
9909 }
99877b66
AM		 9910 else
9911 fdh = NULL;
8387904d 9912 }
7fe2b9a6
AM		 9913 }
9914 else
9915 {
9916 bfd_set_error (bfd_error_bad_value);
9917 goto error_ret_free_internal;
721956f4
AM		 9918 }
9919
8843416a
AM		 9920 destination = 0;
9921 if (ok_dest)
9922 {
9923 sym_value += irela->r_addend;
9924 destination = (sym_value
9925 + sym_sec->output_offset
9926 + sym_sec->output_section->vma);
9927 }
9928
8387904d 9929 code_sec = sym_sec;
e054468f 9930 code_value = sym_value;
74f0fb50
AM		 9931 opd = get_opd_info (sym_sec);
9932 if (opd != NULL)
8387904d
AM		 9933 {
9934 bfd_vma dest;
9935
74f0fb50 9936 if (hash == NULL && opd->adjust != NULL)
8387904d 9937 {
74f0fb50 9938 long adjust = opd->adjust[sym_value / 8];
8387904d
AM		 9939 if (adjust == -1)
9940 continue;
e054468f 9941 code_value += adjust;
8387904d
AM		 9942 sym_value += adjust;
9943 }
9944 dest = opd_entry_value (sym_sec, sym_value,
e054468f 9945 &code_sec, &code_value);
8387904d
AM		 9946 if (dest != (bfd_vma) -1)
9947 {
9948 destination = dest;
9949 if (fdh != NULL)
9950 {
9951 /* Fixup old ABI sym to point at code
9952 entry. */
99877b66 9953 hash->elf.root.type = bfd_link_hash_defweak;
8387904d 9954 hash->elf.root.u.def.section = code_sec;
e054468f 9955 hash->elf.root.u.def.value = code_value;
8387904d
AM		 9956 }
9957 }
9958 }
9959
721956f4 9960 /* Determine what (if any) linker stub is needed. */
e054468f 9961 plt_ent = NULL;
721956f4 9962 stub_type = ppc_type_of_stub (section, irela, &hash,
e054468f 9963 &plt_ent, destination);
ad8e1ba5
AM		 9964
9965 if (stub_type != ppc_stub_plt_call)
9966 {
9967 /* Check whether we need a TOC adjusting stub.
9968 Since the linker pastes together pieces from
9969 different object files when creating the
9970 _init and _fini functions, it may be that a
9971 call to what looks like a local sym is in
9972 fact a call needing a TOC adjustment. */
8387904d
AM		 9973 if (code_sec != NULL
9974 && code_sec->output_section != NULL
9975 && (htab->stub_group[code_sec->id].toc_off
9b5ecbd0 9976 != htab->stub_group[section->id].toc_off)
4c52953f
AM		 9977 && (code_sec->has_toc_reloc
9978 || code_sec->makes_toc_func_call))
ad8e1ba5
AM		 9979 stub_type = ppc_stub_long_branch_r2off;
9980 }
9981
721956f4
AM		 9982 if (stub_type == ppc_stub_none)
9983 continue;
9984
411e1bfb
AM		 9985 /* __tls_get_addr calls might be eliminated. */
9986 if (stub_type != ppc_stub_plt_call
9987 && hash != NULL
8387904d
AM		 9988 && (hash == htab->tls_get_addr
9989 || hash == htab->tls_get_addr_fd)
411e1bfb
AM		 9990 && section->has_tls_reloc
9991 && irela != internal_relocs)
9992 {
9993 /* Get tls info. */
e7b938ca 9994 char *tls_mask;
411e1bfb 9995
3a71aa26 9996 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
411e1bfb
AM		 9997 irela - 1, input_bfd))
9998 goto error_ret_free_internal;
e7b938ca 9999 if (*tls_mask != 0)
411e1bfb
AM		 10000 continue;
10001 }
10002
721956f4
AM		 10003 /* Support for grouping stub sections. */
10004 id_sec = htab->stub_group[section->id].link_sec;
10005
10006 /* Get the name of this stub. */
10007 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
10008 if (!stub_name)
10009 goto error_ret_free_internal;
10010
10011 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
b34976b6 10012 stub_name, FALSE, FALSE);
721956f4
AM		 10013 if (stub_entry != NULL)
10014 {
10015 /* The proper stub has already been created. */
10016 free (stub_name);
10017 continue;
10018 }
10019
10020 stub_entry = ppc_add_stub (stub_name, section, htab);
10021 if (stub_entry == NULL)
10022 {
10023 free (stub_name);
6cdc0ccc
AM		 10024 error_ret_free_internal:
10025 if (elf_section_data (section)->relocs == NULL)
10026 free (internal_relocs);
10027 error_ret_free_local:
10028 if (local_syms != NULL
10029 && (symtab_hdr->contents
10030 != (unsigned char *) local_syms))
10031 free (local_syms);
b34976b6 10032 return FALSE;
721956f4
AM		 10033 }
10034
ad8e1ba5 10035 stub_entry->stub_type = stub_type;
e054468f
AM		 10036 if (stub_type != ppc_stub_plt_call)
10037 {
10038 stub_entry->target_value = code_value;
10039 stub_entry->target_section = code_sec;
10040 }
10041 else
10042 {
10043 stub_entry->target_value = sym_value;
10044 stub_entry->target_section = sym_sec;
10045 }
721956f4 10046 stub_entry->h = hash;
e054468f 10047 stub_entry->plt_ent = plt_ent;
411e1bfb 10048 stub_entry->addend = irela->r_addend;
ee75fd95
AM		 10049
10050 if (stub_entry->h != NULL)
10051 htab->stub_globals += 1;
721956f4
AM		 10052 }
10053
10054 /* We're done with the internal relocs, free them. */
6cdc0ccc 10055 if (elf_section_data (section)->relocs != internal_relocs)
1e2f5b6e 10056 free (internal_relocs);
721956f4 10057 }
6cdc0ccc
AM		 10058
10059 if (local_syms != NULL
10060 && symtab_hdr->contents != (unsigned char *) local_syms)
10061 {
10062 if (!info->keep_memory)
10063 free (local_syms);
10064 else
10065 symtab_hdr->contents = (unsigned char *) local_syms;
10066 }
721956f4
AM		 10067 }
10068
5c3dead3 10069 /* We may have added some stubs. Find out the new size of the
721956f4
AM		 10070 stub sections. */
10071 for (stub_sec = htab->stub_bfd->sections;
10072 stub_sec != NULL;
10073 stub_sec = stub_sec->next)
e717da7e 10074 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
ee75fd95 10075 {
5c3dead3 10076 stub_sec->rawsize = stub_sec->size;
ee75fd95
AM		 10077 stub_sec->size = 0;
10078 stub_sec->reloc_count = 0;
84f5d08e 10079 stub_sec->flags &= ~SEC_RELOC;
ee75fd95 10080 }
eea6121a
AM		 10081
10082 htab->brlt->size = 0;
84f5d08e
AM		 10083 htab->brlt->reloc_count = 0;
10084 htab->brlt->flags &= ~SEC_RELOC;
ee75fd95 10085 if (htab->relbrlt != NULL)
eea6121a 10086 htab->relbrlt->size = 0;
721956f4 10087
63bc6f6c 10088 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
721956f4 10089
176a0d42
AM		 10090 if (info->emitrelocations
10091 && htab->glink != NULL && htab->glink->size != 0)
10092 {
10093 htab->glink->reloc_count = 1;
10094 htab->glink->flags |= SEC_RELOC;
10095 }
10096
5c3dead3
AM		 10097 for (stub_sec = htab->stub_bfd->sections;
10098 stub_sec != NULL;
10099 stub_sec = stub_sec->next)
10100 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
10101 && stub_sec->rawsize != stub_sec->size)
10102 break;
10103
10104 /* Exit from this loop when no stubs have been added, and no stubs
10105 have changed size. */
10106 if (stub_sec == NULL)
10107 break;
10108
721956f4
AM		 10109 /* Ask the linker to do its stuff. */
10110 (*htab->layout_sections_again) ();
10111 }
10112
c456f082 10113 /* It would be nice to strip htab->brlt from the output if the
afbe61cf
AM		 10114 section is empty, but it's too late. If we strip sections here,
10115 the dynamic symbol table is corrupted since the section symbol
10116 for the stripped section isn't written. */
721956f4 10117
b34976b6 10118 return TRUE;
721956f4
AM		 10119}
10120
10121/* Called after we have determined section placement. If sections
805fc799 10122 move, we'll be called again. Provide a value for TOCstart. */
721956f4 10123
805fc799 10124bfd_vma
4ce794b7 10125ppc64_elf_toc (bfd *obfd)
721956f4 10126{
805fc799
AM		 10127 asection *s;
10128 bfd_vma TOCstart;
721956f4 10129
805fc799
AM		 10130 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
10131 order. The TOC starts where the first of these sections starts. */
10132 s = bfd_get_section_by_name (obfd, ".got");
e054468f 10133 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
805fc799 10134 s = bfd_get_section_by_name (obfd, ".toc");
e054468f 10135 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
805fc799 10136 s = bfd_get_section_by_name (obfd, ".tocbss");
e054468f 10137 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
805fc799 10138 s = bfd_get_section_by_name (obfd, ".plt");
e054468f 10139 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
805fc799
AM		 10140 {
10141 /* This may happen for
10142 o references to TOC base (SYM@toc / TOC[tc0]) without a
10143 .toc directive
10144 o bad linker script
10145 o --gc-sections and empty TOC sections
10146
10147 FIXME: Warn user? */
10148
10149 /* Look for a likely section. We probably won't even be
10150 using TOCstart. */
10151 for (s = obfd->sections; s != NULL; s = s->next)
e054468f
AM		 10152 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
10153 | SEC_EXCLUDE))
805fc799
AM		 10154 == (SEC_ALLOC | SEC_SMALL_DATA))
10155 break;
721956f4 10156 if (s == NULL)
805fc799 10157 for (s = obfd->sections; s != NULL; s = s->next)
e054468f 10158 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
805fc799
AM		 10159 == (SEC_ALLOC | SEC_SMALL_DATA))
10160 break;
721956f4 10161 if (s == NULL)
805fc799 10162 for (s = obfd->sections; s != NULL; s = s->next)
e054468f
AM		 10163 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
10164 == SEC_ALLOC)
805fc799 10165 break;
721956f4 10166 if (s == NULL)
805fc799 10167 for (s = obfd->sections; s != NULL; s = s->next)
e054468f 10168 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
805fc799
AM		 10169 break;
10170 }
721956f4 10171
805fc799
AM		 10172 TOCstart = 0;
10173 if (s != NULL)
10174 TOCstart = s->output_section->vma + s->output_offset;
721956f4 10175
805fc799 10176 return TOCstart;
721956f4
AM		 10177}
10178
10179/* Build all the stubs associated with the current output file.
10180 The stubs are kept in a hash table attached to the main linker
10181 hash table. This function is called via gldelf64ppc_finish. */
10182
b34976b6 10183bfd_boolean
4ce794b7
AM		 10184ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
10185 struct bfd_link_info *info,
10186 char **stats)
5d1634d7
AM		 10187{
10188 struct ppc_link_hash_table *htab = ppc_hash_table (info);
721956f4 10189 asection *stub_sec;
5d1634d7 10190 bfd_byte *p;
e717da7e 10191 int stub_sec_count = 0;
5d1634d7 10192
ad8e1ba5 10193 htab->emit_stub_syms = emit_stub_syms;
eea6121a
AM		 10194
10195 /* Allocate memory to hold the linker stubs. */
721956f4
AM		 10196 for (stub_sec = htab->stub_bfd->sections;
10197 stub_sec != NULL;
10198 stub_sec = stub_sec->next)
eea6121a
AM		 10199 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
10200 && stub_sec->size != 0)
e717da7e 10201 {
eea6121a
AM		 10202 stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
10203 if (stub_sec->contents == NULL)
10204 return FALSE;
10205 /* We want to check that built size is the same as calculated
10206 size. rawsize is a convenient location to use. */
10207 stub_sec->rawsize = stub_sec->size;
10208 stub_sec->size = 0;
e717da7e 10209 }
5d1634d7 10210
23eb7e01 10211 if (htab->glink != NULL && htab->glink->size != 0)
5d1634d7 10212 {
9f951329 10213 unsigned int indx;
ad8e1ba5 10214 bfd_vma plt0;
9f951329 10215
721956f4 10216 /* Build the .glink plt call stub. */
97b639ba
AM		 10217 if (htab->emit_stub_syms)
10218 {
10219 struct elf_link_hash_entry *h;
468392fb
AM		 10220 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
10221 TRUE, FALSE, FALSE);
97b639ba
AM		 10222 if (h == NULL)
10223 return FALSE;
10224 if (h->root.type == bfd_link_hash_new)
10225 {
10226 h->root.type = bfd_link_hash_defined;
10227 h->root.u.def.section = htab->glink;
ee4bf8d2 10228 h->root.u.def.value = 8;
f5385ebf
AM		 10229 h->ref_regular = 1;
10230 h->def_regular = 1;
10231 h->ref_regular_nonweak = 1;
10232 h->forced_local = 1;
10233 h->non_elf = 0;
97b639ba
AM		 10234 }
10235 }
176a0d42
AM		 10236 plt0 = htab->plt->output_section->vma + htab->plt->output_offset - 16;
10237 if (info->emitrelocations)
10238 {
10239 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
10240 if (r == NULL)
10241 return FALSE;
10242 r->r_offset = (htab->glink->output_offset
10243 + htab->glink->output_section->vma);
10244 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
10245 r->r_addend = plt0;
10246 }
4ce794b7 10247 p = htab->glink->contents;
176a0d42 10248 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
ee4bf8d2
AM		 10249 bfd_put_64 (htab->glink->owner, plt0, p);
10250 p += 8;
10251 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
ad8e1ba5 10252 p += 4;
ee4bf8d2 10253 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
ad8e1ba5 10254 p += 4;
ee4bf8d2 10255 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
ad8e1ba5 10256 p += 4;
ee4bf8d2 10257 bfd_put_32 (htab->glink->owner, LD_R2_M16R11, p);
ad8e1ba5 10258 p += 4;
ee4bf8d2 10259 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
ad8e1ba5 10260 p += 4;
ee4bf8d2 10261 bfd_put_32 (htab->glink->owner, ADD_R12_R2_R11, p);
ad8e1ba5 10262 p += 4;
ee4bf8d2 10263 bfd_put_32 (htab->glink->owner, LD_R11_0R12, p);
ad8e1ba5 10264 p += 4;
4ce794b7 10265 bfd_put_32 (htab->glink->owner, LD_R2_0R12 | 8, p);
ad8e1ba5 10266 p += 4;
4ce794b7 10267 bfd_put_32 (htab->glink->owner, MTCTR_R11, p);
ad8e1ba5 10268 p += 4;
4ce794b7 10269 bfd_put_32 (htab->glink->owner, LD_R11_0R12 | 16, p);
ad8e1ba5 10270 p += 4;
4ce794b7 10271 bfd_put_32 (htab->glink->owner, BCTR, p);
ad8e1ba5 10272 p += 4;
ee4bf8d2
AM		 10273 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
10274 {
10275 bfd_put_32 (htab->glink->owner, NOP, p);
10276 p += 4;
10277 }
ad8e1ba5 10278
9f951329
AM		 10279 /* Build the .glink lazy link call stubs. */
10280 indx = 0;
eea6121a 10281 while (p < htab->glink->contents + htab->glink->size)
9f951329
AM		 10282 {
10283 if (indx < 0x8000)
10284 {
4ce794b7 10285 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
9f951329
AM		 10286 p += 4;
10287 }
10288 else
10289 {
4ce794b7 10290 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
9f951329 10291 p += 4;
4ce794b7 10292 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx), p);
9f951329
AM		 10293 p += 4;
10294 }
4ce794b7 10295 bfd_put_32 (htab->glink->owner,
ee4bf8d2 10296 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
a16d5acb 10297 indx++;
9f951329
AM		 10298 p += 4;
10299 }
eea6121a 10300 htab->glink->rawsize = p - htab->glink->contents;
5d1634d7 10301 }
5d1634d7 10302
eea6121a 10303 if (htab->brlt->size != 0)
721956f4 10304 {
4ce794b7 10305 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
eea6121a 10306 htab->brlt->size);
4ce794b7 10307 if (htab->brlt->contents == NULL)
b34976b6 10308 return FALSE;
721956f4 10309 }
ee75fd95 10310 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
63bc6f6c
AM		 10311 {
10312 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
eea6121a 10313 htab->relbrlt->size);
63bc6f6c
AM		 10314 if (htab->relbrlt->contents == NULL)
10315 return FALSE;
10316 }
5d1634d7 10317
721956f4
AM		 10318 /* Build the stubs as directed by the stub hash table. */
10319 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
5d1634d7 10320
aa8a7074
AM		 10321 if (htab->relbrlt != NULL)
10322 htab->relbrlt->reloc_count = 0;
10323
721956f4
AM		 10324 for (stub_sec = htab->stub_bfd->sections;
10325 stub_sec != NULL;
10326 stub_sec = stub_sec->next)
e717da7e
AM		 10327 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
10328 {
10329 stub_sec_count += 1;
eea6121a 10330 if (stub_sec->rawsize != stub_sec->size)
e717da7e
AM		 10331 break;
10332 }
5d1634d7 10333
721956f4 10334 if (stub_sec != NULL
eea6121a 10335 || htab->glink->rawsize != htab->glink->size)
5d1634d7 10336 {
b34976b6 10337 htab->stub_error = TRUE;
721956f4 10338 (*_bfd_error_handler) (_("stubs don't match calculated size"));
5d1634d7 10339 }
721956f4 10340
d2a300cf
AM		 10341 if (htab->stub_error)
10342 return FALSE;
10343
10344 if (stats != NULL)
10345 {
10346 *stats = bfd_malloc (500);
10347 if (*stats == NULL)
10348 return FALSE;
10349
ee75fd95 10350 sprintf (*stats, _("linker stubs in %u group%s\n"
d2a300cf
AM		 10351 " branch %lu\n"
10352 " toc adjust %lu\n"
10353 " long branch %lu\n"
10354 " long toc adj %lu\n"
10355 " plt call %lu"),
e717da7e 10356 stub_sec_count,
ee75fd95 10357 stub_sec_count == 1 ? "" : "s",
4ce794b7
AM		 10358 htab->stub_count[ppc_stub_long_branch - 1],
10359 htab->stub_count[ppc_stub_long_branch_r2off - 1],
10360 htab->stub_count[ppc_stub_plt_branch - 1],
10361 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
10362 htab->stub_count[ppc_stub_plt_call - 1]);
d2a300cf
AM		 10363 }
10364 return TRUE;
5bd4f169
AM		 10365}
10366
99877b66
AM		 10367/* This function undoes the changes made by add_symbol_adjust. */
10368
10369static bfd_boolean
10370undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
10371{
10372 struct ppc_link_hash_entry *eh;
10373
10374 if (h->root.type == bfd_link_hash_indirect)
10375 return TRUE;
10376
10377 if (h->root.type == bfd_link_hash_warning)
10378 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10379
10380 eh = (struct ppc_link_hash_entry *) h;
10381 if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
10382 return TRUE;
10383
10384 eh->elf.root.type = bfd_link_hash_undefined;
10385 return TRUE;
10386}
10387
10388void
10389ppc64_elf_restore_symbols (struct bfd_link_info *info)
10390{
10391 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10392 elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
10393}
10394
60124e18
AM		 10395/* What to do when ld finds relocations against symbols defined in
10396 discarded sections. */
10397
10398static unsigned int
10399ppc64_elf_action_discarded (asection *sec)
10400{
10401 if (strcmp (".opd", sec->name) == 0)
10402 return 0;
10403
10404 if (strcmp (".toc", sec->name) == 0)
10405 return 0;
10406
bce50a28
JJ		 10407 if (strcmp (".toc1", sec->name) == 0)
10408 return 0;
10409
60124e18
AM		 10410 return _bfd_elf_default_action_discarded (sec);
10411}
10412
5bd4f169
AM		 10413/* The RELOCATE_SECTION function is called by the ELF backend linker
10414 to handle the relocations for a section.
10415
10416 The relocs are always passed as Rela structures; if the section
10417 actually uses Rel structures, the r_addend field will always be
10418 zero.
10419
10420 This function is responsible for adjust the section contents as
10421 necessary, and (if using Rela relocs and generating a
1049f94e 10422 relocatable output file) adjusting the reloc addend as
5bd4f169
AM		 10423 necessary.
10424
10425 This function does not have to worry about setting the reloc
10426 address or the reloc symbol index.
10427
10428 LOCAL_SYMS is a pointer to the swapped in local symbols.
10429
10430 LOCAL_SECTIONS is an array giving the section in the input file
10431 corresponding to the st_shndx field of each local symbol.
10432
10433 The global hash table entry for the global symbols can be found
10434 via elf_sym_hashes (input_bfd).
10435
1049f94e 10436 When generating relocatable output, this function must handle
5bd4f169
AM		 10437 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
10438 going to be the section symbol corresponding to the output
10439 section, which means that the addend must be adjusted
10440 accordingly. */
10441
b34976b6 10442static bfd_boolean
4ce794b7
AM		 10443ppc64_elf_relocate_section (bfd *output_bfd,
10444 struct bfd_link_info *info,
10445 bfd *input_bfd,
10446 asection *input_section,
10447 bfd_byte *contents,
10448 Elf_Internal_Rela *relocs,
10449 Elf_Internal_Sym *local_syms,
10450 asection **local_sections)
5bd4f169 10451{
65f38f15 10452 struct ppc_link_hash_table *htab;
5bd4f169
AM		 10453 Elf_Internal_Shdr *symtab_hdr;
10454 struct elf_link_hash_entry **sym_hashes;
5bd4f169
AM		 10455 Elf_Internal_Rela *rel;
10456 Elf_Internal_Rela *relend;
411e1bfb
AM		 10457 Elf_Internal_Rela outrel;
10458 bfd_byte *loc;
411e1bfb 10459 struct got_entry **local_got_ents;
5bd4f169 10460 bfd_vma TOCstart;
b34976b6
AM		 10461 bfd_boolean ret = TRUE;
10462 bfd_boolean is_opd;
96e0dda4 10463 /* Disabled until we sort out how ld should choose 'y' vs 'at'. */
b34976b6 10464 bfd_boolean is_power4 = FALSE;
4fe5ca5b 10465 bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
5bd4f169 10466
65f38f15 10467 /* Initialize howto table if needed. */
5bd4f169 10468 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5bd4f169
AM		 10469 ppc_howto_init ();
10470
65f38f15 10471 htab = ppc_hash_table (info);
ee75fd95
AM		 10472
10473 /* Don't relocate stub sections. */
10474 if (input_section->owner == htab->stub_bfd)
10475 return TRUE;
10476
0c8d6e5c 10477 BFD_ASSERT (is_ppc64_elf (input_bfd));
0ffa91dd 10478
411e1bfb 10479 local_got_ents = elf_local_got_ents (input_bfd);
5bd4f169 10480 TOCstart = elf_gp (output_bfd);
0ffa91dd 10481 symtab_hdr = &elf_symtab_hdr (input_bfd);
5bd4f169 10482 sym_hashes = elf_sym_hashes (input_bfd);
7c8fe5c4 10483 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
65f38f15 10484
5bd4f169
AM		 10485 rel = relocs;
10486 relend = relocs + input_section->reloc_count;
10487 for (; rel < relend; rel++)
10488 {
04c9666a 10489 enum elf_ppc64_reloc_type r_type;
4cc603a5 10490 bfd_vma addend, orig_addend;
5bd4f169
AM		 10491 bfd_reloc_status_type r;
10492 Elf_Internal_Sym *sym;
10493 asection *sec;
039b3fef
AM		 10494 struct elf_link_hash_entry *h_elf;
10495 struct ppc_link_hash_entry *h;
10496 struct ppc_link_hash_entry *fdh;
5bd4f169 10497 const char *sym_name;
0d4792f7 10498 unsigned long r_symndx, toc_symndx;
3a71aa26 10499 bfd_vma toc_addend;
951fd09b 10500 char tls_mask, tls_gd, tls_type;
0d4792f7 10501 char sym_type;
5bd4f169 10502 bfd_vma relocation;
b34976b6
AM		 10503 bfd_boolean unresolved_reloc;
10504 bfd_boolean warned;
50bc7936 10505 unsigned long insn, mask;
721956f4
AM		 10506 struct ppc_stub_hash_entry *stub_entry;
10507 bfd_vma max_br_offset;
10508 bfd_vma from;
5bd4f169 10509
4ce794b7 10510 r_type = ELF64_R_TYPE (rel->r_info);
5bd4f169 10511 r_symndx = ELF64_R_SYM (rel->r_info);
ee87f2da
AM		 10512
10513 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
10514 symbol of the previous ADDR64 reloc. The symbol gives us the
10515 proper TOC base to use. */
10516 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
10517 && rel != relocs
10518 && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
10519 && is_opd)
10520 r_symndx = ELF64_R_SYM (rel[-1].r_info);
10521
4ce794b7
AM		 10522 sym = NULL;
10523 sec = NULL;
039b3fef 10524 h_elf = NULL;
4ce794b7 10525 sym_name = NULL;
b34976b6
AM		 10526 unresolved_reloc = FALSE;
10527 warned = FALSE;
4cc603a5 10528 orig_addend = rel->r_addend;
65f38f15 10529
0b13192e 10530 if (r_symndx < symtab_hdr->sh_info)
5bd4f169
AM		 10531 {
10532 /* It's a local symbol. */
74f0fb50 10533 struct _opd_sec_data *opd;
4025353c 10534
5bd4f169
AM		 10535 sym = local_syms + r_symndx;
10536 sec = local_sections[r_symndx];
26c61ae5 10537 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
0d4792f7 10538 sym_type = ELF64_ST_TYPE (sym->st_info);
8517fae7 10539 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
74f0fb50
AM		 10540 opd = get_opd_info (sec);
10541 if (opd != NULL && opd->adjust != NULL)
1e2f5b6e 10542 {
74f0fb50 10543 long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
4025353c
AM		 10544 if (adjust == -1)
10545 relocation = 0;
10546 else
4cc603a5
AM		 10547 {
10548 /* If this is a relocation against the opd section sym
10549 and we have edited .opd, adjust the reloc addend so
10550 that ld -r and ld --emit-relocs output is correct.
10551 If it is a reloc against some other .opd symbol,
10552 then the symbol value will be adjusted later. */
10553 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
10554 rel->r_addend += adjust;
10555 else
10556 relocation += adjust;
10557 }
1e2f5b6e 10558 }
5bd4f169
AM		 10559 }
10560 else
10561 {
b2a8e766
AM		 10562 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
10563 r_symndx, symtab_hdr, sym_hashes,
039b3fef 10564 h_elf, sec, relocation,
b2a8e766 10565 unresolved_reloc, warned);
039b3fef
AM		 10566 sym_name = h_elf->root.root.string;
10567 sym_type = h_elf->type;
5bd4f169 10568 }
039b3fef 10569 h = (struct ppc_link_hash_entry *) h_elf;
5bd4f169 10570
ab96bf03
AM		 10571 if (sec != NULL && elf_discarded_section (sec))
10572 {
10573 /* For relocs against symbols from removed linkonce sections,
10574 or sections discarded by a linker script, we just want the
10575 section contents zeroed. Avoid any special processing. */
10576 _bfd_clear_contents (ppc64_elf_howto_table[r_type], input_bfd,
10577 contents + rel->r_offset);
10578 rel->r_info = 0;
10579 rel->r_addend = 0;
10580 continue;
10581 }
10582
10583 if (info->relocatable)
10584 continue;
10585
951fd09b
AM		 10586 /* TLS optimizations. Replace instruction sequences and relocs
10587 based on information we collected in tls_optimize. We edit
10588 RELOCS so that --emit-relocs will output something sensible
10589 for the final instruction stream. */
10590 tls_mask = 0;
10591 tls_gd = 0;
0d4792f7 10592 toc_symndx = 0;
727fc41e
AM		 10593 if (h != NULL)
10594 tls_mask = h->tls_mask;
10595 else if (local_got_ents != NULL)
411e1bfb 10596 {
e054468f
AM		 10597 struct plt_entry **local_plt = (struct plt_entry **)
10598 (local_got_ents + symtab_hdr->sh_info);
10599 char *lgot_masks = (char *)
10600 (local_plt + symtab_hdr->sh_info);
727fc41e
AM		 10601 tls_mask = lgot_masks[r_symndx];
10602 }
10603 if (tls_mask == 0
10604 && (r_type == R_PPC64_TLS
10605 || r_type == R_PPC64_TLSGD
10606 || r_type == R_PPC64_TLSLD))
10607 {
10608 /* Check for toc tls entries. */
10609 char *toc_tls;
0d4792f7 10610
727fc41e
AM		 10611 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
10612 &local_syms, rel, input_bfd))
10613 return FALSE;
0d4792f7 10614
727fc41e
AM		 10615 if (toc_tls)
10616 tls_mask = *toc_tls;
0d4792f7
AM		 10617 }
10618
10619 /* Check that tls relocs are used with tls syms, and non-tls
10620 relocs are used with non-tls syms. */
10621 if (r_symndx != 0
10622 && r_type != R_PPC64_NONE
10623 && (h == NULL
039b3fef
AM		 10624 || h->elf.root.type == bfd_link_hash_defined
10625 || h->elf.root.type == bfd_link_hash_defweak)
1d483afe
AM		 10626 && (IS_PPC64_TLS_RELOC (r_type)
10627 != (sym_type == STT_TLS
10628 || (sym_type == STT_SECTION
10629 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
0d4792f7 10630 {
727fc41e
AM		 10631 if (tls_mask != 0
10632 && (r_type == R_PPC64_TLS
10633 || r_type == R_PPC64_TLSGD
10634 || r_type == R_PPC64_TLSLD))
0d4792f7
AM		 10635 /* R_PPC64_TLS is OK against a symbol in the TOC. */
10636 ;
10637 else
10638 (*_bfd_error_handler)
1d483afe 10639 (!IS_PPC64_TLS_RELOC (r_type)
d003868e
AM		 10640 ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
10641 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s"),
10642 input_bfd,
10643 input_section,
0d4792f7
AM		 10644 (long) rel->r_offset,
10645 ppc64_elf_howto_table[r_type]->name,
10646 sym_name);
411e1bfb
AM		 10647 }
10648
10649 /* Ensure reloc mapping code below stays sane. */
10650 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
10651 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
10652 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
10653 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
10654 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
10655 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
10656 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
10657 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
10658 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
10659 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
10660 abort ();
0d4792f7 10661
411e1bfb
AM		 10662 switch (r_type)
10663 {
10664 default:
411e1bfb
AM		 10665 break;
10666
10667 case R_PPC64_TOC16:
10668 case R_PPC64_TOC16_LO:
10669 case R_PPC64_TOC16_DS:
10670 case R_PPC64_TOC16_LO_DS:
411e1bfb
AM		 10671 {
10672 /* Check for toc tls entries. */
10673 char *toc_tls;
951fd09b 10674 int retval;
411e1bfb 10675
3a71aa26
AM		 10676 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
10677 &local_syms, rel, input_bfd);
951fd09b 10678 if (retval == 0)
411e1bfb
AM		 10679 return FALSE;
10680
10681 if (toc_tls)
10682 {
951fd09b 10683 tls_mask = *toc_tls;
411e1bfb
AM		 10684 if (r_type == R_PPC64_TOC16_DS
10685 || r_type == R_PPC64_TOC16_LO_DS)
81407a69
AM		 10686 {
10687 if (tls_mask != 0
10688 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
10689 goto toctprel;
10690 }
411e1bfb 10691 else
951fd09b
AM		 10692 {
10693 /* If we found a GD reloc pair, then we might be
10694 doing a GD->IE transition. */
10695 if (retval == 2)
10696 {
10697 tls_gd = TLS_TPRELGD;
10698 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
102890f0 10699 goto tls_ldgd_opt;
951fd09b
AM		 10700 }
10701 else if (retval == 3)
10702 {
10703 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
102890f0 10704 goto tls_ldgd_opt;
951fd09b
AM		 10705 }
10706 }
411e1bfb
AM		 10707 }
10708 }
10709 break;
10710
10711 case R_PPC64_GOT_TPREL16_DS:
10712 case R_PPC64_GOT_TPREL16_LO_DS:
951fd09b
AM		 10713 if (tls_mask != 0
10714 && (tls_mask & TLS_TPREL) == 0)
411e1bfb 10715 {
81407a69 10716 toctprel:
4fe5ca5b 10717 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
411e1bfb
AM		 10718 insn &= 31 << 21;
10719 insn |= 0x3c0d0000; /* addis 0,13,0 */
4fe5ca5b 10720 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
411e1bfb 10721 r_type = R_PPC64_TPREL16_HA;
0d4792f7
AM		 10722 if (toc_symndx != 0)
10723 {
10724 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
3a71aa26 10725 rel->r_addend = toc_addend;
0d4792f7
AM		 10726 /* We changed the symbol. Start over in order to
10727 get h, sym, sec etc. right. */
10728 rel--;
10729 continue;
10730 }
10731 else
10732 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
411e1bfb
AM		 10733 }
10734 break;
10735
10736 case R_PPC64_TLS:
951fd09b
AM		 10737 if (tls_mask != 0
10738 && (tls_mask & TLS_TPREL) == 0)
411e1bfb 10739 {
50bc7936 10740 bfd_vma rtra;
411e1bfb 10741 insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
772119ce 10742 if ((insn & ((0x3f << 26) | (31 << 11)))
411e1bfb
AM		 10743 == ((31 << 26) | (13 << 11)))
10744 rtra = insn & ((1 << 26) - (1 << 16));
772119ce 10745 else if ((insn & ((0x3f << 26) | (31 << 16)))
411e1bfb
AM		 10746 == ((31 << 26) | (13 << 16)))
10747 rtra = (insn & (31 << 21)) | ((insn & (31 << 11)) << 5);
10748 else
10749 abort ();
10750 if ((insn & ((1 << 11) - (1 << 1))) == 266 << 1)
10751 /* add -> addi. */
10752 insn = 14 << 26;
10753 else if ((insn & (31 << 1)) == 23 << 1
10754 && ((insn & (31 << 6)) < 14 << 6
10755 || ((insn & (31 << 6)) >= 16 << 6
10756 && (insn & (31 << 6)) < 24 << 6)))
10757 /* load and store indexed -> dform. */
10758 insn = (32 | ((insn >> 6) & 31)) << 26;
10759 else if ((insn & (31 << 1)) == 21 << 1
10760 && (insn & (0x1a << 6)) == 0)
10761 /* ldx, ldux, stdx, stdux -> ld, ldu, std, stdu. */
10762 insn = (((58 | ((insn >> 6) & 4)) << 26)
10763 | ((insn >> 6) & 1));
10764 else if ((insn & (31 << 1)) == 21 << 1
10765 && (insn & ((1 << 11) - (1 << 1))) == 341 << 1)
10766 /* lwax -> lwa. */
10767 insn = (58 << 26) | 2;
10768 else
10769 abort ();
10770 insn |= rtra;
10771 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
411e1bfb 10772 /* Was PPC64_TLS which sits on insn boundary, now
4fe5ca5b
GM		 10773 PPC64_TPREL16_LO which is at low-order half-word. */
10774 rel->r_offset += d_offset;
0d4792f7
AM		 10775 r_type = R_PPC64_TPREL16_LO;
10776 if (toc_symndx != 0)
10777 {
10778 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
3a71aa26 10779 rel->r_addend = toc_addend;
0d4792f7
AM		 10780 /* We changed the symbol. Start over in order to
10781 get h, sym, sec etc. right. */
10782 rel--;
10783 continue;
10784 }
10785 else
10786 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
411e1bfb
AM		 10787 }
10788 break;
10789
411e1bfb
AM		 10790 case R_PPC64_GOT_TLSGD16_HI:
10791 case R_PPC64_GOT_TLSGD16_HA:
951fd09b
AM		 10792 tls_gd = TLS_TPRELGD;
10793 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
10794 goto tls_gdld_hi;
10795 break;
10796
411e1bfb
AM		 10797 case R_PPC64_GOT_TLSLD16_HI:
10798 case R_PPC64_GOT_TLSLD16_HA:
951fd09b 10799 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
411e1bfb 10800 {
951fd09b
AM		 10801 tls_gdld_hi:
10802 if ((tls_mask & tls_gd) != 0)
10803 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
10804 + R_PPC64_GOT_TPREL16_DS);
10805 else
411e1bfb 10806 {
951fd09b 10807 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
4fe5ca5b 10808 rel->r_offset -= d_offset;
951fd09b 10809 r_type = R_PPC64_NONE;
411e1bfb 10810 }
951fd09b 10811 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
411e1bfb
AM		 10812 }
10813 break;
10814
951fd09b
AM		 10815 case R_PPC64_GOT_TLSGD16:
10816 case R_PPC64_GOT_TLSGD16_LO:
10817 tls_gd = TLS_TPRELGD;
10818 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
102890f0 10819 goto tls_ldgd_opt;
951fd09b 10820 break;
411e1bfb 10821
951fd09b
AM		 10822 case R_PPC64_GOT_TLSLD16:
10823 case R_PPC64_GOT_TLSLD16_LO:
10824 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
10825 {
3a71aa26 10826 unsigned int insn1, insn2, insn3;
102890f0
AM		 10827 bfd_vma offset;
10828
10829 tls_ldgd_opt:
727fc41e
AM		 10830 offset = (bfd_vma) -1;
10831 /* If not using the newer R_PPC64_TLSGD/LD to mark
10832 __tls_get_addr calls, we must trust that the call
10833 stays with its arg setup insns, ie. that the next
10834 reloc is the __tls_get_addr call associated with
10835 the current reloc. Edit both insns. */
10836 if (input_section->has_tls_get_addr_call
10837 && rel + 1 < relend
10838 && branch_reloc_hash_match (input_bfd, rel + 1,
10839 htab->tls_get_addr,
10840 htab->tls_get_addr_fd))
10841 offset = rel[1].r_offset;
102890f0 10842 if ((tls_mask & tls_gd) != 0)
411e1bfb 10843 {
102890f0 10844 /* IE */
3a71aa26
AM		 10845 insn1 = bfd_get_32 (output_bfd,
10846 contents + rel->r_offset - d_offset);
102890f0
AM		 10847 insn1 &= (1 << 26) - (1 << 2);
10848 insn1 |= 58 << 26; /* ld */
10849 insn2 = 0x7c636a14; /* add 3,3,13 */
727fc41e
AM		 10850 if (offset != (bfd_vma) -1)
10851 rel[1].r_info = ELF64_R_INFO (ELF64_R_SYM (rel[1].r_info),
10852 R_PPC64_NONE);
102890f0
AM		 10853 if ((tls_mask & TLS_EXPLICIT) == 0)
10854 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
10855 + R_PPC64_GOT_TPREL16_DS);
411e1bfb 10856 else
102890f0
AM		 10857 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
10858 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10859 }
10860 else
10861 {
10862 /* LE */
10863 insn1 = 0x3c6d0000; /* addis 3,13,0 */
10864 insn2 = 0x38630000; /* addi 3,3,0 */
10865 if (tls_gd == 0)
951fd09b 10866 {
102890f0 10867 /* Was an LD reloc. */
1d483afe
AM		 10868 if (toc_symndx)
10869 sec = local_sections[toc_symndx];
10870 for (r_symndx = 0;
10871 r_symndx < symtab_hdr->sh_info;
10872 r_symndx++)
10873 if (local_sections[r_symndx] == sec)
10874 break;
10875 if (r_symndx >= symtab_hdr->sh_info)
10876 r_symndx = 0;
102890f0 10877 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
1d483afe
AM		 10878 if (r_symndx != 0)
10879 rel->r_addend -= (local_syms[r_symndx].st_value
10880 + sec->output_offset
10881 + sec->output_section->vma);
951fd09b 10882 }
102890f0 10883 else if (toc_symndx != 0)
3a71aa26
AM		 10884 {
10885 r_symndx = toc_symndx;
10886 rel->r_addend = toc_addend;
10887 }
102890f0
AM		 10888 r_type = R_PPC64_TPREL16_HA;
10889 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
727fc41e
AM		 10890 if (offset != (bfd_vma) -1)
10891 {
10892 rel[1].r_info = ELF64_R_INFO (r_symndx,
10893 R_PPC64_TPREL16_LO);
10894 rel[1].r_offset = offset + d_offset;
10895 rel[1].r_addend = rel->r_addend;
10896 }
102890f0 10897 }
3a71aa26
AM		 10898 bfd_put_32 (output_bfd, insn1,
10899 contents + rel->r_offset - d_offset);
727fc41e
AM		 10900 if (offset != (bfd_vma) -1)
10901 {
10902 insn3 = bfd_get_32 (output_bfd,
10903 contents + offset + 4);
10904 if (insn3 == NOP
10905 || insn3 == CROR_151515 || insn3 == CROR_313131)
10906 {
10907 rel[1].r_offset += 4;
10908 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
10909 insn2 = NOP;
10910 }
10911 bfd_put_32 (output_bfd, insn2, contents + offset);
10912 }
10913 if ((tls_mask & tls_gd) == 0
10914 && (tls_gd == 0 || toc_symndx != 0))
10915 {
10916 /* We changed the symbol. Start over in order
10917 to get h, sym, sec etc. right. */
10918 rel--;
10919 continue;
10920 }
10921 }
10922 break;
10923
10924 case R_PPC64_TLSGD:
10925 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
10926 {
10927 unsigned int insn2, insn3;
10928 bfd_vma offset = rel->r_offset;
10929
10930 if ((tls_mask & TLS_TPRELGD) != 0)
10931 {
10932 /* IE */
10933 r_type = R_PPC64_NONE;
10934 insn2 = 0x7c636a14; /* add 3,3,13 */
10935 }
10936 else
10937 {
10938 /* LE */
10939 if (toc_symndx != 0)
10940 {
10941 r_symndx = toc_symndx;
10942 rel->r_addend = toc_addend;
10943 }
10944 r_type = R_PPC64_TPREL16_LO;
10945 rel->r_offset = offset + d_offset;
10946 insn2 = 0x38630000; /* addi 3,3,0 */
10947 }
10948 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10949 /* Zap the reloc on the _tls_get_addr call too. */
10950 BFD_ASSERT (offset == rel[1].r_offset);
10951 rel[1].r_info = ELF64_R_INFO (ELF64_R_SYM (rel[1].r_info),
10952 R_PPC64_NONE);
3a71aa26
AM		 10953 insn3 = bfd_get_32 (output_bfd,
10954 contents + offset + 4);
102890f0
AM		 10955 if (insn3 == NOP
10956 || insn3 == CROR_151515 || insn3 == CROR_313131)
10957 {
727fc41e 10958 rel->r_offset += 4;
3a71aa26
AM		 10959 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
10960 insn2 = NOP;
102890f0 10961 }
102890f0 10962 bfd_put_32 (output_bfd, insn2, contents + offset);
727fc41e 10963 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
102890f0 10964 {
102890f0
AM		 10965 rel--;
10966 continue;
411e1bfb 10967 }
411e1bfb 10968 }
411e1bfb
AM		 10969 break;
10970
727fc41e
AM		 10971 case R_PPC64_TLSLD:
10972 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
10973 {
10974 unsigned int insn2, insn3;
10975 bfd_vma offset = rel->r_offset;
10976
10977 if (toc_symndx)
10978 sec = local_sections[toc_symndx];
10979 for (r_symndx = 0;
10980 r_symndx < symtab_hdr->sh_info;
10981 r_symndx++)
10982 if (local_sections[r_symndx] == sec)
10983 break;
10984 if (r_symndx >= symtab_hdr->sh_info)
10985 r_symndx = 0;
10986 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
10987 if (r_symndx != 0)
10988 rel->r_addend -= (local_syms[r_symndx].st_value
10989 + sec->output_offset
10990 + sec->output_section->vma);
10991
10992 r_type = R_PPC64_TPREL16_LO;
10993 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10994 rel->r_offset = offset + d_offset;
10995 /* Zap the reloc on the _tls_get_addr call too. */
10996 BFD_ASSERT (offset == rel[1].r_offset);
10997 rel[1].r_info = ELF64_R_INFO (ELF64_R_SYM (rel[1].r_info),
10998 R_PPC64_NONE);
10999 insn2 = 0x38630000; /* addi 3,3,0 */
11000 insn3 = bfd_get_32 (output_bfd,
11001 contents + offset + 4);
11002 if (insn3 == NOP
11003 || insn3 == CROR_151515 || insn3 == CROR_313131)
11004 {
11005 rel->r_offset += 4;
11006 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
11007 insn2 = NOP;
11008 }
11009 bfd_put_32 (output_bfd, insn2, contents + offset);
11010 rel--;
11011 continue;
11012 }
11013 break;
11014
411e1bfb 11015 case R_PPC64_DTPMOD64:
951fd09b
AM		 11016 if (rel + 1 < relend
11017 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
11018 && rel[1].r_offset == rel->r_offset + 8)
411e1bfb 11019 {
951fd09b
AM		 11020 if ((tls_mask & TLS_GD) == 0)
11021 {
11022 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
11023 if ((tls_mask & TLS_TPRELGD) != 0)
11024 r_type = R_PPC64_TPREL64;
11025 else
11026 {
4ce794b7 11027 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
951fd09b
AM		 11028 r_type = R_PPC64_NONE;
11029 }
11030 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11031 }
11032 }
11033 else
11034 {
11035 if ((tls_mask & TLS_LD) == 0)
411e1bfb 11036 {
4ce794b7 11037 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
411e1bfb 11038 r_type = R_PPC64_NONE;
951fd09b 11039 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
411e1bfb 11040 }
411e1bfb
AM		 11041 }
11042 break;
11043
11044 case R_PPC64_TPREL64:
951fd09b 11045 if ((tls_mask & TLS_TPREL) == 0)
411e1bfb
AM		 11046 {
11047 r_type = R_PPC64_NONE;
11048 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11049 }
11050 break;
11051 }
11052
11053 /* Handle other relocations that tweak non-addend part of insn. */
86c76c7b 11054 insn = 0;
b25116a9
AM		 11055 max_br_offset = 1 << 25;
11056 addend = rel->r_addend;
65f38f15 11057 switch (r_type)
5bd4f169
AM		 11058 {
11059 default:
65f38f15 11060 break;
5bd4f169 11061
65f38f15
AM		 11062 /* Branch taken prediction relocations. */
11063 case R_PPC64_ADDR14_BRTAKEN:
11064 case R_PPC64_REL14_BRTAKEN:
cedb70c5
KH		 11065 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
11066 /* Fall thru. */
65f38f15 11067
86c76c7b 11068 /* Branch not taken prediction relocations. */
65f38f15
AM		 11069 case R_PPC64_ADDR14_BRNTAKEN:
11070 case R_PPC64_REL14_BRNTAKEN:
411e1bfb
AM		 11071 insn |= bfd_get_32 (output_bfd,
11072 contents + rel->r_offset) & ~(0x01 << 21);
b25116a9 11073 /* Fall thru. */
86c76c7b 11074
b25116a9
AM		 11075 case R_PPC64_REL14:
11076 max_br_offset = 1 << 15;
11077 /* Fall thru. */
5bd4f169 11078
65f38f15 11079 case R_PPC64_REL24:
ad8e1ba5
AM		 11080 /* Calls to functions with a different TOC, such as calls to
11081 shared objects, need to alter the TOC pointer. This is
11082 done using a linkage stub. A REL24 branching to these
11083 linkage stubs needs to be followed by a nop, as the nop
11084 will be replaced with an instruction to restore the TOC
11085 base pointer. */
b25116a9 11086 stub_entry = NULL;
8387904d 11087 fdh = h;
ad8e1ba5 11088 if (((h != NULL
039b3fef
AM		 11089 && (((fdh = h->oh) != NULL
11090 && fdh->elf.plt.plist != NULL)
11091 || (fdh = h)->elf.plt.plist != NULL))
8387904d 11092 || (sec != NULL
ad8e1ba5 11093 && sec->output_section != NULL
b25116a9 11094 && sec->id <= htab->top_id
ad8e1ba5
AM		 11095 && (htab->stub_group[sec->id].toc_off
11096 != htab->stub_group[input_section->id].toc_off)))
721956f4 11097 && (stub_entry = ppc_get_stub_entry (input_section, sec, fdh,
ad8e1ba5
AM		 11098 rel, htab)) != NULL
11099 && (stub_entry->stub_type == ppc_stub_plt_call
11100 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
11101 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
41bd81ab 11102 {
b25116a9 11103 bfd_boolean can_plt_call = FALSE;
721956f4 11104
eea6121a 11105 if (rel->r_offset + 8 <= input_section->size)
41bd81ab 11106 {
b25116a9
AM		 11107 unsigned long nop;
11108 nop = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
11109 if (nop == NOP
11110 || nop == CROR_151515 || nop == CROR_313131)
41bd81ab 11111 {
4ce794b7 11112 bfd_put_32 (input_bfd, LD_R2_40R1,
411e1bfb 11113 contents + rel->r_offset + 4);
b25116a9 11114 can_plt_call = TRUE;
41bd81ab 11115 }
5bd4f169 11116 }
721956f4
AM		 11117
11118 if (!can_plt_call)
11119 {
ad8e1ba5
AM		 11120 if (stub_entry->stub_type == ppc_stub_plt_call)
11121 {
11122 /* If this is a plain branch rather than a branch
4fa1c237
AM		 11123 and link, don't require a nop. However, don't
11124 allow tail calls in a shared library as they
11125 will result in r2 being corrupted. */
b25116a9
AM		 11126 unsigned long br;
11127 br = bfd_get_32 (input_bfd, contents + rel->r_offset);
4fa1c237 11128 if (info->executable && (br & 1) == 0)
b25116a9 11129 can_plt_call = TRUE;
15b552e9
AM		 11130 else
11131 stub_entry = NULL;
ad8e1ba5 11132 }
6ab189d5 11133 else if (h != NULL
039b3fef 11134 && strcmp (h->elf.root.root.string,
6ab189d5
AM		 11135 ".__libc_start_main") == 0)
11136 {
11137 /* Allow crt1 branch to go via a toc adjusting stub. */
b25116a9 11138 can_plt_call = TRUE;
6ab189d5 11139 }
ad8e1ba5
AM		 11140 else
11141 {
11142 if (strcmp (input_section->output_section->name,
11143 ".init") == 0
11144 || strcmp (input_section->output_section->name,
11145 ".fini") == 0)
11146 (*_bfd_error_handler)
d003868e 11147 (_("%B(%A+0x%lx): automatic multiple TOCs "
ad8e1ba5
AM		 11148 "not supported using your crt files; "
11149 "recompile with -mminimal-toc or upgrade gcc"),
d003868e
AM		 11150 input_bfd,
11151 input_section,
ad8e1ba5
AM		 11152 (long) rel->r_offset);
11153 else
11154 (*_bfd_error_handler)
d003868e 11155 (_("%B(%A+0x%lx): sibling call optimization to `%s' "
ad8e1ba5
AM		 11156 "does not allow automatic multiple TOCs; "
11157 "recompile with -mminimal-toc or "
11158 "-fno-optimize-sibling-calls, "
11159 "or make `%s' extern"),
d003868e
AM		 11160 input_bfd,
11161 input_section,
ad8e1ba5
AM		 11162 (long) rel->r_offset,
11163 sym_name,
11164 sym_name);
11165 bfd_set_error (bfd_error_bad_value);
11166 ret = FALSE;
11167 }
721956f4
AM		 11168 }
11169
b25116a9
AM		 11170 if (can_plt_call
11171 && stub_entry->stub_type == ppc_stub_plt_call)
11172 unresolved_reloc = FALSE;
11173 }
11174
8387904d
AM		 11175 if (stub_entry == NULL
11176 && get_opd_info (sec) != NULL)
11177 {
11178 /* The branch destination is the value of the opd entry. */
4cc603a5
AM		 11179 bfd_vma off = (relocation + addend
11180 - sec->output_section->vma
11181 - sec->output_offset);
8387904d
AM		 11182 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL);
11183 if (dest != (bfd_vma) -1)
11184 {
11185 relocation = dest;
11186 addend = 0;
11187 }
11188 }
11189
b25116a9
AM		 11190 /* If the branch is out of reach we ought to have a long
11191 branch stub. */
11192 from = (rel->r_offset
11193 + input_section->output_offset
11194 + input_section->output_section->vma);
11195
11196 if (stub_entry == NULL
4cc603a5 11197 && (relocation + addend - from + max_br_offset
b25116a9
AM		 11198 >= 2 * max_br_offset)
11199 && r_type != R_PPC64_ADDR14_BRTAKEN
11200 && r_type != R_PPC64_ADDR14_BRNTAKEN)
039b3fef
AM		 11201 stub_entry = ppc_get_stub_entry (input_section, sec, h, rel,
11202 htab);
b25116a9
AM		 11203
11204 if (stub_entry != NULL)
11205 {
11206 /* Munge up the value and addend so that we call the stub
11207 rather than the procedure directly. */
11208 relocation = (stub_entry->stub_offset
11209 + stub_entry->stub_sec->output_offset
11210 + stub_entry->stub_sec->output_section->vma);
11211 addend = 0;
11212 }
11213
11214 if (insn != 0)
11215 {
11216 if (is_power4)
721956f4 11217 {
b25116a9
AM		 11218 /* Set 'a' bit. This is 0b00010 in BO field for branch
11219 on CR(BI) insns (BO == 001at or 011at), and 0b01000
11220 for branch on CTR insns (BO == 1a00t or 1a01t). */
11221 if ((insn & (0x14 << 21)) == (0x04 << 21))
11222 insn |= 0x02 << 21;
11223 else if ((insn & (0x14 << 21)) == (0x10 << 21))
11224 insn |= 0x08 << 21;
11225 else
11226 break;
11227 }
11228 else
11229 {
11230 /* Invert 'y' bit if not the default. */
4cc603a5 11231 if ((bfd_signed_vma) (relocation + addend - from) < 0)
b25116a9 11232 insn ^= 0x01 << 21;
721956f4 11233 }
b25116a9
AM		 11234
11235 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
5bd4f169 11236 }
e86ce104 11237
06da1e8e
AM		 11238 /* NOP out calls to undefined weak functions.
11239 We can thus call a weak function without first
11240 checking whether the function is defined. */
b25116a9 11241 else if (h != NULL
039b3fef 11242 && h->elf.root.type == bfd_link_hash_undefweak
b25116a9
AM		 11243 && r_type == R_PPC64_REL24
11244 && relocation == 0
4cc603a5 11245 && addend == 0)
e86ce104 11246 {
06da1e8e
AM		 11247 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
11248 continue;
e86ce104 11249 }
65f38f15
AM		 11250 break;
11251 }
5bd4f169 11252
65f38f15 11253 /* Set `addend'. */
411e1bfb 11254 tls_type = 0;
65f38f15
AM		 11255 switch (r_type)
11256 {
11257 default:
11258 (*_bfd_error_handler)
d003868e
AM		 11259 (_("%B: unknown relocation type %d for symbol %s"),
11260 input_bfd, (int) r_type, sym_name);
5bd4f169 11261
65f38f15 11262 bfd_set_error (bfd_error_bad_value);
b34976b6 11263 ret = FALSE;
65f38f15 11264 continue;
5bd4f169 11265
65f38f15 11266 case R_PPC64_NONE:
411e1bfb 11267 case R_PPC64_TLS:
727fc41e
AM		 11268 case R_PPC64_TLSGD:
11269 case R_PPC64_TLSLD:
04c9666a
AM		 11270 case R_PPC64_GNU_VTINHERIT:
11271 case R_PPC64_GNU_VTENTRY:
65f38f15 11272 continue;
5bd4f169
AM		 11273
11274 /* GOT16 relocations. Like an ADDR16 using the symbol's
11275 address in the GOT as relocation value instead of the
411e1bfb 11276 symbol's value itself. Also, create a GOT entry for the
5bd4f169 11277 symbol and put the symbol value there. */
411e1bfb
AM		 11278 case R_PPC64_GOT_TLSGD16:
11279 case R_PPC64_GOT_TLSGD16_LO:
11280 case R_PPC64_GOT_TLSGD16_HI:
11281 case R_PPC64_GOT_TLSGD16_HA:
951fd09b 11282 tls_type = TLS_TLS | TLS_GD;
411e1bfb
AM		 11283 goto dogot;
11284
11285 case R_PPC64_GOT_TLSLD16:
11286 case R_PPC64_GOT_TLSLD16_LO:
11287 case R_PPC64_GOT_TLSLD16_HI:
11288 case R_PPC64_GOT_TLSLD16_HA:
951fd09b 11289 tls_type = TLS_TLS | TLS_LD;
411e1bfb
AM		 11290 goto dogot;
11291
11292 case R_PPC64_GOT_TPREL16_DS:
11293 case R_PPC64_GOT_TPREL16_LO_DS:
11294 case R_PPC64_GOT_TPREL16_HI:
11295 case R_PPC64_GOT_TPREL16_HA:
11296 tls_type = TLS_TLS | TLS_TPREL;
11297 goto dogot;
11298
11299 case R_PPC64_GOT_DTPREL16_DS:
11300 case R_PPC64_GOT_DTPREL16_LO_DS:
11301 case R_PPC64_GOT_DTPREL16_HI:
11302 case R_PPC64_GOT_DTPREL16_HA:
11303 tls_type = TLS_TLS | TLS_DTPREL;
11304 goto dogot;
11305
65f38f15
AM		 11306 case R_PPC64_GOT16:
11307 case R_PPC64_GOT16_LO:
11308 case R_PPC64_GOT16_HI:
11309 case R_PPC64_GOT16_HA:
11310 case R_PPC64_GOT16_DS:
11311 case R_PPC64_GOT16_LO_DS:
411e1bfb 11312 dogot:
5bd4f169
AM		 11313 {
11314 /* Relocation is to the entry for this symbol in the global
11315 offset table. */
e717da7e 11316 asection *got;
d881513a 11317 bfd_vma *offp;
5bd4f169 11318 bfd_vma off;
d881513a 11319 unsigned long indx = 0;
65f38f15 11320
d881513a
AM		 11321 if (tls_type == (TLS_TLS | TLS_LD)
11322 && (h == NULL
f5385ebf 11323 || !h->elf.def_dynamic))
e717da7e 11324 offp = &ppc64_tlsld_got (input_bfd)->offset;
411e1bfb 11325 else
5bd4f169 11326 {
d881513a 11327 struct got_entry *ent;
5bd4f169 11328
d881513a
AM		 11329 if (h != NULL)
11330 {
11331 bfd_boolean dyn = htab->elf.dynamic_sections_created;
039b3fef
AM		 11332 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
11333 &h->elf)
d881513a 11334 || (info->shared
039b3fef 11335 && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
d881513a
AM		 11336 /* This is actually a static link, or it is a
11337 -Bsymbolic link and the symbol is defined
11338 locally, or the symbol was forced to be local
11339 because of a version file. */
11340 ;
11341 else
11342 {
039b3fef 11343 indx = h->elf.dynindx;
d881513a
AM		 11344 unresolved_reloc = FALSE;
11345 }
039b3fef 11346 ent = h->elf.got.glist;
d881513a 11347 }
411e1bfb 11348 else
5bd4f169 11349 {
d881513a
AM		 11350 if (local_got_ents == NULL)
11351 abort ();
11352 ent = local_got_ents[r_symndx];
5bd4f169 11353 }
d881513a
AM		 11354
11355 for (; ent != NULL; ent = ent->next)
4cc603a5 11356 if (ent->addend == orig_addend
e717da7e 11357 && ent->owner == input_bfd
d881513a
AM		 11358 && ent->tls_type == tls_type)
11359 break;
11360 if (ent == NULL)
11361 abort ();
11362 offp = &ent->got.offset;
5bd4f169 11363 }
411e1bfb 11364
e717da7e
AM		 11365 got = ppc64_elf_tdata (input_bfd)->got;
11366 if (got == NULL)
11367 abort ();
11368
411e1bfb
AM		 11369 /* The offset must always be a multiple of 8. We use the
11370 least significant bit to record whether we have already
11371 processed this entry. */
d881513a 11372 off = *offp;
411e1bfb
AM		 11373 if ((off & 1) != 0)
11374 off &= ~1;
5bd4f169
AM		 11375 else
11376 {
411e1bfb
AM		 11377 /* Generate relocs for the dynamic linker, except in
11378 the case of TLSLD where we'll use one entry per
11379 module. */
e717da7e
AM		 11380 asection *relgot = ppc64_elf_tdata (input_bfd)->relgot;
11381
d881513a 11382 *offp = off | 1;
4e795f50 11383 if ((info->shared || indx != 0)
3a71aa26
AM		 11384 && (offp == &ppc64_tlsld_got (input_bfd)->offset
11385 || h == NULL
039b3fef
AM		 11386 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
11387 || h->elf.root.type != bfd_link_hash_undefweak))
5bd4f169 11388 {
e717da7e
AM		 11389 outrel.r_offset = (got->output_section->vma
11390 + got->output_offset
411e1bfb 11391 + off);
4cc603a5 11392 outrel.r_addend = addend;
d881513a 11393 if (tls_type & (TLS_LD | TLS_GD))
5bd4f169 11394 {
411e1bfb 11395 outrel.r_addend = 0;
e515b051 11396 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
d881513a
AM		 11397 if (tls_type == (TLS_TLS | TLS_GD))
11398 {
e717da7e
AM		 11399 loc = relgot->contents;
11400 loc += (relgot->reloc_count++
d881513a
AM		 11401 * sizeof (Elf64_External_Rela));
11402 bfd_elf64_swap_reloca_out (output_bfd,
11403 &outrel, loc);
e515b051 11404 outrel.r_offset += 8;
4cc603a5 11405 outrel.r_addend = addend;
d881513a
AM		 11406 outrel.r_info
11407 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
d881513a 11408 }
411e1bfb 11409 }
951fd09b 11410 else if (tls_type == (TLS_TLS | TLS_DTPREL))
411e1bfb 11411 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
951fd09b 11412 else if (tls_type == (TLS_TLS | TLS_TPREL))
411e1bfb
AM		 11413 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
11414 else if (indx == 0)
81407a69
AM		 11415 {
11416 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_RELATIVE);
11417
11418 /* Write the .got section contents for the sake
11419 of prelink. */
e717da7e 11420 loc = got->contents + off;
23fbd6fa
JJ		 11421 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
11422 loc);
81407a69 11423 }
411e1bfb
AM		 11424 else
11425 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
81407a69
AM		 11426
11427 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
e515b051
AM		 11428 {
11429 outrel.r_addend += relocation;
11430 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
e1918d23 11431 outrel.r_addend -= htab->elf.tls_sec->vma;
e515b051 11432 }
e717da7e
AM		 11433 loc = relgot->contents;
11434 loc += (relgot->reloc_count++
411e1bfb
AM		 11435 * sizeof (Elf64_External_Rela));
11436 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
11437 }
11438
ad8e1ba5 11439 /* Init the .got section contents here if we're not
81407a69 11440 emitting a reloc. */
d881513a 11441 else
411e1bfb 11442 {
4cc603a5 11443 relocation += addend;
7b609f53
AM		 11444 if (tls_type == (TLS_TLS | TLS_LD))
11445 relocation = 1;
11446 else if (tls_type != 0)
411e1bfb 11447 {
e1918d23 11448 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
7b609f53 11449 if (tls_type == (TLS_TLS | TLS_TPREL))
411e1bfb 11450 relocation += DTP_OFFSET - TP_OFFSET;
5bd4f169 11451
7b609f53
AM		 11452 if (tls_type == (TLS_TLS | TLS_GD))
11453 {
11454 bfd_put_64 (output_bfd, relocation,
e717da7e 11455 got->contents + off + 8);
7b609f53
AM		 11456 relocation = 1;
11457 }
411e1bfb 11458 }
7b609f53 11459
411e1bfb 11460 bfd_put_64 (output_bfd, relocation,
e717da7e 11461 got->contents + off);
5bd4f169
AM		 11462 }
11463 }
11464
65f38f15
AM		 11465 if (off >= (bfd_vma) -2)
11466 abort ();
11467
e717da7e 11468 relocation = got->output_offset + off;
65f38f15 11469
5bd4f169 11470 /* TOC base (r2) is TOC start plus 0x8000. */
e717da7e 11471 addend = -TOC_BASE_OFF;
5bd4f169 11472 }
65f38f15
AM		 11473 break;
11474
11475 case R_PPC64_PLT16_HA:
11476 case R_PPC64_PLT16_HI:
11477 case R_PPC64_PLT16_LO:
11478 case R_PPC64_PLT32:
11479 case R_PPC64_PLT64:
11480 /* Relocation is to the entry for this symbol in the
11481 procedure linkage table. */
11482
11483 /* Resolve a PLT reloc against a local symbol directly,
11484 without using the procedure linkage table. */
11485 if (h == NULL)
11486 break;
11487
411e1bfb
AM		 11488 /* It's possible that we didn't make a PLT entry for this
11489 symbol. This happens when statically linking PIC code,
11490 or when using -Bsymbolic. Go find a match if there is a
11491 PLT entry. */
4ce794b7 11492 if (htab->plt != NULL)
65f38f15 11493 {
411e1bfb 11494 struct plt_entry *ent;
039b3fef 11495 for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
4cc603a5 11496 if (ent->addend == orig_addend
411e1bfb
AM		 11497 && ent->plt.offset != (bfd_vma) -1)
11498 {
4ce794b7
AM		 11499 relocation = (htab->plt->output_section->vma
11500 + htab->plt->output_offset
411e1bfb
AM		 11501 + ent->plt.offset);
11502 unresolved_reloc = FALSE;
11503 }
65f38f15 11504 }
65f38f15 11505 break;
5bd4f169 11506
0b13192e
AM		 11507 case R_PPC64_TOC:
11508 /* Relocation value is TOC base. */
11509 relocation = TOCstart;
11510 if (r_symndx == 0)
11511 relocation += htab->stub_group[input_section->id].toc_off;
8517fae7
AM		 11512 else if (unresolved_reloc)
11513 ;
11514 else if (sec != NULL && sec->id <= htab->top_id)
0b13192e
AM		 11515 relocation += htab->stub_group[sec->id].toc_off;
11516 else
11517 unresolved_reloc = TRUE;
ab96bf03 11518 goto dodyn;
0b13192e 11519
5bd4f169
AM		 11520 /* TOC16 relocs. We want the offset relative to the TOC base,
11521 which is the address of the start of the TOC plus 0x8000.
11522 The TOC consists of sections .got, .toc, .tocbss, and .plt,
11523 in this order. */
65f38f15
AM		 11524 case R_PPC64_TOC16:
11525 case R_PPC64_TOC16_LO:
11526 case R_PPC64_TOC16_HI:
11527 case R_PPC64_TOC16_DS:
11528 case R_PPC64_TOC16_LO_DS:
11529 case R_PPC64_TOC16_HA:
ad8e1ba5 11530 addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
5bd4f169
AM		 11531 break;
11532
11533 /* Relocate against the beginning of the section. */
65f38f15
AM		 11534 case R_PPC64_SECTOFF:
11535 case R_PPC64_SECTOFF_LO:
11536 case R_PPC64_SECTOFF_HI:
11537 case R_PPC64_SECTOFF_DS:
11538 case R_PPC64_SECTOFF_LO_DS:
11539 case R_PPC64_SECTOFF_HA:
4ce794b7 11540 if (sec != NULL)
65f38f15 11541 addend -= sec->output_section->vma;
5bd4f169
AM		 11542 break;
11543
721956f4
AM		 11544 case R_PPC64_REL14:
11545 case R_PPC64_REL14_BRNTAKEN:
11546 case R_PPC64_REL14_BRTAKEN:
5d1634d7
AM		 11547 case R_PPC64_REL24:
11548 break;
11549
411e1bfb
AM		 11550 case R_PPC64_TPREL16:
11551 case R_PPC64_TPREL16_LO:
11552 case R_PPC64_TPREL16_HI:
11553 case R_PPC64_TPREL16_HA:
11554 case R_PPC64_TPREL16_DS:
11555 case R_PPC64_TPREL16_LO_DS:
11556 case R_PPC64_TPREL16_HIGHER:
11557 case R_PPC64_TPREL16_HIGHERA:
11558 case R_PPC64_TPREL16_HIGHEST:
11559 case R_PPC64_TPREL16_HIGHESTA:
e1918d23 11560 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
411e1bfb
AM		 11561 if (info->shared)
11562 /* The TPREL16 relocs shouldn't really be used in shared
11563 libs as they will result in DT_TEXTREL being set, but
11564 support them anyway. */
11565 goto dodyn;
11566 break;
11567
11568 case R_PPC64_DTPREL16:
11569 case R_PPC64_DTPREL16_LO:
11570 case R_PPC64_DTPREL16_HI:
11571 case R_PPC64_DTPREL16_HA:
11572 case R_PPC64_DTPREL16_DS:
11573 case R_PPC64_DTPREL16_LO_DS:
11574 case R_PPC64_DTPREL16_HIGHER:
11575 case R_PPC64_DTPREL16_HIGHERA:
11576 case R_PPC64_DTPREL16_HIGHEST:
11577 case R_PPC64_DTPREL16_HIGHESTA:
e1918d23 11578 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
411e1bfb
AM		 11579 break;
11580
e515b051
AM		 11581 case R_PPC64_DTPMOD64:
11582 relocation = 1;
11583 addend = 0;
11584 goto dodyn;
11585
411e1bfb 11586 case R_PPC64_TPREL64:
e1918d23 11587 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
411e1bfb
AM		 11588 goto dodyn;
11589
11590 case R_PPC64_DTPREL64:
e1918d23 11591 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
411e1bfb
AM		 11592 /* Fall thru */
11593
65f38f15
AM		 11594 /* Relocations that may need to be propagated if this is a
11595 dynamic object. */
04c9666a 11596 case R_PPC64_REL30:
65f38f15
AM		 11597 case R_PPC64_REL32:
11598 case R_PPC64_REL64:
11599 case R_PPC64_ADDR14:
11600 case R_PPC64_ADDR14_BRNTAKEN:
11601 case R_PPC64_ADDR14_BRTAKEN:
11602 case R_PPC64_ADDR16:
11603 case R_PPC64_ADDR16_DS:
11604 case R_PPC64_ADDR16_HA:
11605 case R_PPC64_ADDR16_HI:
11606 case R_PPC64_ADDR16_HIGHER:
11607 case R_PPC64_ADDR16_HIGHERA:
11608 case R_PPC64_ADDR16_HIGHEST:
11609 case R_PPC64_ADDR16_HIGHESTA:
11610 case R_PPC64_ADDR16_LO:
11611 case R_PPC64_ADDR16_LO_DS:
11612 case R_PPC64_ADDR24:
65f38f15
AM		 11613 case R_PPC64_ADDR32:
11614 case R_PPC64_ADDR64:
11615 case R_PPC64_UADDR16:
11616 case R_PPC64_UADDR32:
11617 case R_PPC64_UADDR64:
411e1bfb 11618 dodyn:
5d1634d7 11619 if ((input_section->flags & SEC_ALLOC) == 0)
ec338859
AM		 11620 break;
11621
41bd81ab
AM		 11622 if (NO_OPD_RELOCS && is_opd)
11623 break;
11624
65f38f15 11625 if ((info->shared
4e795f50 11626 && (h == NULL
039b3fef
AM		 11627 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
11628 || h->elf.root.type != bfd_link_hash_undefweak)
1d483afe 11629 && (must_be_dyn_reloc (info, r_type)
039b3fef 11630 || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
f4656909
AM		 11631 || (ELIMINATE_COPY_RELOCS
11632 && !info->shared
65f38f15 11633 && h != NULL
039b3fef 11634 && h->elf.dynindx != -1
f5385ebf 11635 && !h->elf.non_got_ref
f5385ebf 11636 && !h->elf.def_regular))
65f38f15
AM		 11637 {
11638 Elf_Internal_Rela outrel;
b34976b6 11639 bfd_boolean skip, relocate;
65f38f15 11640 asection *sreloc;
947216bf 11641 bfd_byte *loc;
1cf1f670 11642 bfd_vma out_off;
65f38f15
AM		 11643
11644 /* When generating a dynamic object, these relocations
11645 are copied into the output file to be resolved at run
11646 time. */
11647
b34976b6
AM		 11648 skip = FALSE;
11649 relocate = FALSE;
65f38f15 11650
1cf1f670
AM		 11651 out_off = _bfd_elf_section_offset (output_bfd, info,
11652 input_section, rel->r_offset);
11653 if (out_off == (bfd_vma) -1)
b34976b6 11654 skip = TRUE;
1cf1f670 11655 else if (out_off == (bfd_vma) -2)
b34976b6 11656 skip = TRUE, relocate = TRUE;
1cf1f670
AM		 11657 out_off += (input_section->output_section->vma
11658 + input_section->output_offset);
11659 outrel.r_offset = out_off;
411e1bfb 11660 outrel.r_addend = rel->r_addend;
65f38f15 11661
1cf1f670
AM		 11662 /* Optimize unaligned reloc use. */
11663 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
11664 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
11665 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
11666 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
11667 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
11668 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
11669 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
11670 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
11671 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
11672
65f38f15 11673 if (skip)
0bb2d96a 11674 memset (&outrel, 0, sizeof outrel);
039b3fef 11675 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
0b13192e
AM		 11676 && !is_opd
11677 && r_type != R_PPC64_TOC)
039b3fef 11678 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
65f38f15
AM		 11679 else
11680 {
41bd81ab
AM		 11681 /* This symbol is local, or marked to become local,
11682 or this is an opd section reloc which must point
11683 at a local function. */
65f38f15 11684 outrel.r_addend += relocation;
e86ce104 11685 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
65f38f15 11686 {
3fad3c7c 11687 if (is_opd && h != NULL)
afbe61cf
AM		 11688 {
11689 /* Lie about opd entries. This case occurs
11690 when building shared libraries and we
11691 reference a function in another shared
3fad3c7c
AM		 11692 lib. The same thing happens for a weak
11693 definition in an application that's
11694 overridden by a strong definition in a
11695 shared lib. (I believe this is a generic
11696 bug in binutils handling of weak syms.)
11697 In these cases we won't use the opd
1e2f5b6e 11698 entry in this lib. */
b34976b6 11699 unresolved_reloc = FALSE;
afbe61cf 11700 }
65f38f15 11701 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
81407a69
AM		 11702
11703 /* We need to relocate .opd contents for ld.so.
11704 Prelink also wants simple and consistent rules
11705 for relocs. This make all RELATIVE relocs have
11706 *r_offset equal to r_addend. */
11707 relocate = TRUE;
65f38f15
AM		 11708 }
11709 else
11710 {
11711 long indx = 0;
11712
1d483afe 11713 if (r_symndx == 0 || bfd_is_abs_section (sec))
65f38f15
AM		 11714 ;
11715 else if (sec == NULL || sec->owner == NULL)
11716 {
11717 bfd_set_error (bfd_error_bad_value);
b34976b6 11718 return FALSE;
65f38f15
AM		 11719 }
11720 else
11721 {
11722 asection *osec;
11723
11724 osec = sec->output_section;
11725 indx = elf_section_data (osec)->dynindx;
11726
74541ad4
AM		 11727 if (indx == 0)
11728 {
11729 if ((osec->flags & SEC_READONLY) == 0
11730 && htab->elf.data_index_section != NULL)
11731 osec = htab->elf.data_index_section;
11732 else
11733 osec = htab->elf.text_index_section;
11734 indx = elf_section_data (osec)->dynindx;
11735 }
11736 BFD_ASSERT (indx != 0);
11737
65f38f15
AM		 11738 /* We are turning this relocation into one
11739 against a section symbol, so subtract out
11740 the output section's address but not the
11741 offset of the input section in the output
11742 section. */
11743 outrel.r_addend -= osec->vma;
11744 }
11745
11746 outrel.r_info = ELF64_R_INFO (indx, r_type);
11747 }
11748 }
11749
11750 sreloc = elf_section_data (input_section)->sreloc;
11751 if (sreloc == NULL)
11752 abort ();
11753
dfbb6ac9
AM		 11754 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
11755 >= sreloc->size)
11756 abort ();
947216bf
AM		 11757 loc = sreloc->contents;
11758 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
65f38f15
AM		 11759 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
11760
11761 /* If this reloc is against an external symbol, it will
11762 be computed at runtime, so there's no need to do
81407a69
AM		 11763 anything now. However, for the sake of prelink ensure
11764 that the section contents are a known value. */
65f38f15 11765 if (! relocate)
81407a69
AM		 11766 {
11767 unresolved_reloc = FALSE;
11768 /* The value chosen here is quite arbitrary as ld.so
11769 ignores section contents except for the special
11770 case of .opd where the contents might be accessed
11771 before relocation. Choose zero, as that won't
11772 cause reloc overflow. */
11773 relocation = 0;
11774 addend = 0;
11775 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
11776 to improve backward compatibility with older
11777 versions of ld. */
11778 if (r_type == R_PPC64_ADDR64)
11779 addend = outrel.r_addend;
11780 /* Adjust pc_relative relocs to have zero in *r_offset. */
4ce794b7 11781 else if (ppc64_elf_howto_table[r_type]->pc_relative)
000732f7
AM		 11782 addend = (input_section->output_section->vma
11783 + input_section->output_offset
11784 + rel->r_offset);
81407a69 11785 }
65f38f15 11786 }
5bd4f169
AM		 11787 break;
11788
65f38f15
AM		 11789 case R_PPC64_COPY:
11790 case R_PPC64_GLOB_DAT:
11791 case R_PPC64_JMP_SLOT:
11792 case R_PPC64_RELATIVE:
11793 /* We shouldn't ever see these dynamic relocs in relocatable
11794 files. */
ae9a127f 11795 /* Fall through. */
65f38f15
AM		 11796
11797 case R_PPC64_PLTGOT16:
11798 case R_PPC64_PLTGOT16_DS:
11799 case R_PPC64_PLTGOT16_HA:
11800 case R_PPC64_PLTGOT16_HI:
11801 case R_PPC64_PLTGOT16_LO:
11802 case R_PPC64_PLTGOT16_LO_DS:
11803 case R_PPC64_PLTREL32:
11804 case R_PPC64_PLTREL64:
11805 /* These ones haven't been implemented yet. */
11806
11807 (*_bfd_error_handler)
d003868e
AM		 11808 (_("%B: relocation %s is not supported for symbol %s."),
11809 input_bfd,
4ce794b7 11810 ppc64_elf_howto_table[r_type]->name, sym_name);
5bd4f169
AM		 11811
11812 bfd_set_error (bfd_error_invalid_operation);
b34976b6 11813 ret = FALSE;
5bd4f169 11814 continue;
65f38f15 11815 }
5bd4f169 11816
65f38f15
AM		 11817 /* Do any further special processing. */
11818 switch (r_type)
11819 {
11820 default:
11821 break;
11822
11823 case R_PPC64_ADDR16_HA:
11824 case R_PPC64_ADDR16_HIGHERA:
11825 case R_PPC64_ADDR16_HIGHESTA:
65f38f15
AM		 11826 case R_PPC64_TOC16_HA:
11827 case R_PPC64_SECTOFF_HA:
411e1bfb
AM		 11828 case R_PPC64_TPREL16_HA:
11829 case R_PPC64_DTPREL16_HA:
411e1bfb
AM		 11830 case R_PPC64_TPREL16_HIGHER:
11831 case R_PPC64_TPREL16_HIGHERA:
11832 case R_PPC64_TPREL16_HIGHEST:
11833 case R_PPC64_TPREL16_HIGHESTA:
11834 case R_PPC64_DTPREL16_HIGHER:
11835 case R_PPC64_DTPREL16_HIGHERA:
11836 case R_PPC64_DTPREL16_HIGHEST:
11837 case R_PPC64_DTPREL16_HIGHESTA:
65f38f15
AM		 11838 /* It's just possible that this symbol is a weak symbol
11839 that's not actually defined anywhere. In that case,
11840 'sec' would be NULL, and we should leave the symbol
11841 alone (it will be set to zero elsewhere in the link). */
5c5f6e17
AM		 11842 if (sec == NULL)
11843 break;
11844 /* Fall thru */
11845
11846 case R_PPC64_GOT16_HA:
11847 case R_PPC64_PLTGOT16_HA:
11848 case R_PPC64_PLT16_HA:
11849 case R_PPC64_GOT_TLSGD16_HA:
11850 case R_PPC64_GOT_TLSLD16_HA:
11851 case R_PPC64_GOT_TPREL16_HA:
11852 case R_PPC64_GOT_DTPREL16_HA:
11853 /* Add 0x10000 if sign bit in 0:15 is set.
11854 Bits 0:15 are not used. */
11855 addend += 0x8000;
65f38f15
AM		 11856 break;
11857
11858 case R_PPC64_ADDR16_DS:
11859 case R_PPC64_ADDR16_LO_DS:
11860 case R_PPC64_GOT16_DS:
11861 case R_PPC64_GOT16_LO_DS:
11862 case R_PPC64_PLT16_LO_DS:
11863 case R_PPC64_SECTOFF_DS:
11864 case R_PPC64_SECTOFF_LO_DS:
11865 case R_PPC64_TOC16_DS:
11866 case R_PPC64_TOC16_LO_DS:
11867 case R_PPC64_PLTGOT16_DS:
11868 case R_PPC64_PLTGOT16_LO_DS:
411e1bfb
AM		 11869 case R_PPC64_GOT_TPREL16_DS:
11870 case R_PPC64_GOT_TPREL16_LO_DS:
11871 case R_PPC64_GOT_DTPREL16_DS:
11872 case R_PPC64_GOT_DTPREL16_LO_DS:
11873 case R_PPC64_TPREL16_DS:
11874 case R_PPC64_TPREL16_LO_DS:
11875 case R_PPC64_DTPREL16_DS:
11876 case R_PPC64_DTPREL16_LO_DS:
adadcc0c
AM		 11877 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
11878 mask = 3;
11879 /* If this reloc is against an lq insn, then the value must be
11880 a multiple of 16. This is somewhat of a hack, but the
11881 "correct" way to do this by defining _DQ forms of all the
11882 _DS relocs bloats all reloc switches in this file. It
11883 doesn't seem to make much sense to use any of these relocs
11884 in data, so testing the insn should be safe. */
494dac0c 11885 if ((insn & (0x3f << 26)) == (56u << 26))
adadcc0c
AM		 11886 mask = 15;
11887 if (((relocation + addend) & mask) != 0)
65f38f15
AM		 11888 {
11889 (*_bfd_error_handler)
d003868e
AM		 11890 (_("%B: error: relocation %s not a multiple of %d"),
11891 input_bfd,
4ce794b7 11892 ppc64_elf_howto_table[r_type]->name,
adadcc0c 11893 mask + 1);
65f38f15 11894 bfd_set_error (bfd_error_bad_value);
b34976b6 11895 ret = FALSE;
65f38f15
AM		 11896 continue;
11897 }
11898 break;
5bd4f169
AM		 11899 }
11900
239e1f3a
AM		 11901 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
11902 because such sections are not SEC_ALLOC and thus ld.so will
11903 not process them. */
65f38f15 11904 if (unresolved_reloc
239e1f3a 11905 && !((input_section->flags & SEC_DEBUGGING) != 0
f5385ebf 11906 && h->elf.def_dynamic))
9c07fe7c
AM		 11907 {
11908 (*_bfd_error_handler)
d003868e
AM		 11909 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
11910 input_bfd,
11911 input_section,
9c07fe7c 11912 (long) rel->r_offset,
7b609f53 11913 ppc64_elf_howto_table[(int) r_type]->name,
039b3fef 11914 h->elf.root.root.string);
b34976b6 11915 ret = FALSE;
9c07fe7c 11916 }
5bd4f169 11917
65f38f15 11918 r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
5bd4f169
AM		 11919 input_bfd,
11920 input_section,
11921 contents,
411e1bfb 11922 rel->r_offset,
5bd4f169
AM		 11923 relocation,
11924 addend);
11925
ef60b7ff 11926 if (r != bfd_reloc_ok)
5bd4f169 11927 {
cd27b276
AM		 11928 if (sym_name == NULL)
11929 sym_name = "(null)";
11930 if (r == bfd_reloc_overflow)
5bd4f169 11931 {
cd27b276
AM		 11932 if (warned)
11933 continue;
11934 if (h != NULL
039b3fef 11935 && h->elf.root.type == bfd_link_hash_undefweak
4ce794b7 11936 && ppc64_elf_howto_table[r_type]->pc_relative)
5bd4f169
AM		 11937 {
11938 /* Assume this is a call protected by other code that
11939 detects the symbol is undefined. If this is the case,
11940 we can safely ignore the overflow. If not, the
11941 program is hosed anyway, and a little warning isn't
11942 going to help. */
11943
11944 continue;
11945 }
11946
ef60b7ff 11947 if (!((*info->callbacks->reloc_overflow)
dfeffb9f
L		 11948 (info, (h ? &h->elf.root : NULL), sym_name,
11949 ppc64_elf_howto_table[r_type]->name,
4cc603a5 11950 orig_addend, input_bfd, input_section, rel->r_offset)))
b34976b6 11951 return FALSE;
ef60b7ff
AM		 11952 }
11953 else
11954 {
11955 (*_bfd_error_handler)
d003868e
AM		 11956 (_("%B(%A+0x%lx): %s reloc against `%s': error %d"),
11957 input_bfd,
11958 input_section,
7b609f53 11959 (long) rel->r_offset,
4ce794b7 11960 ppc64_elf_howto_table[r_type]->name,
7b609f53
AM		 11961 sym_name,
11962 (int) r);
b34976b6 11963 ret = FALSE;
ef60b7ff 11964 }
5bd4f169 11965 }
5bd4f169
AM		 11966 }
11967
645ea6a9
AM		 11968 /* If we're emitting relocations, then shortly after this function
11969 returns, reloc offsets and addends for this section will be
11970 adjusted. Worse, reloc symbol indices will be for the output
8860955f
AM		 11971 file rather than the input. Save a copy of the relocs for
11972 opd_entry_value. */
4cc603a5 11973 if (is_opd && (info->emitrelocations || info->relocatable))
8860955f
AM		 11974 {
11975 bfd_size_type amt;
11976 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
11977 rel = bfd_alloc (input_bfd, amt);
11978 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd_relocs == NULL);
11979 ppc64_elf_tdata (input_bfd)->opd_relocs = rel;
11980 if (rel == NULL)
11981 return FALSE;
11982 memcpy (rel, relocs, amt);
11983 }
5bd4f169
AM		 11984 return ret;
11985}
11986
754021d0
AM		 11987/* Adjust the value of any local symbols in opd sections. */
11988
6e0b88f1 11989static int
754021d0
AM		 11990ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
11991 const char *name ATTRIBUTE_UNUSED,
11992 Elf_Internal_Sym *elfsym,
11993 asection *input_sec,
11994 struct elf_link_hash_entry *h)
11995{
74f0fb50
AM		 11996 struct _opd_sec_data *opd;
11997 long adjust;
754021d0
AM		 11998 bfd_vma value;
11999
4025353c 12000 if (h != NULL)
6e0b88f1 12001 return 1;
4025353c 12002
74f0fb50
AM		 12003 opd = get_opd_info (input_sec);
12004 if (opd == NULL || opd->adjust == NULL)
6e0b88f1 12005 return 1;
754021d0
AM		 12006
12007 value = elfsym->st_value - input_sec->output_offset;
12008 if (!info->relocatable)
12009 value -= input_sec->output_section->vma;
12010
74f0fb50 12011 adjust = opd->adjust[value / 8];
4025353c 12012 if (adjust == -1)
6e0b88f1
AM		 12013 return 2;
12014
12015 elfsym->st_value += adjust;
12016 return 1;
754021d0
AM		 12017}
12018
5bd4f169
AM		 12019/* Finish up dynamic symbol handling. We set the contents of various
12020 dynamic sections here. */
12021
b34976b6 12022static bfd_boolean
4ce794b7
AM		 12023ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
12024 struct bfd_link_info *info,
12025 struct elf_link_hash_entry *h,
12026 Elf_Internal_Sym *sym)
5bd4f169 12027{
65f38f15 12028 struct ppc_link_hash_table *htab;
8387904d
AM		 12029 struct plt_entry *ent;
12030 Elf_Internal_Rela rela;
12031 bfd_byte *loc;
5bd4f169 12032
65f38f15 12033 htab = ppc_hash_table (info);
5bd4f169 12034
8387904d
AM		 12035 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
12036 if (ent->plt.offset != (bfd_vma) -1)
12037 {
12038 /* This symbol has an entry in the procedure linkage
12039 table. Set it up. */
e054468f
AM		 12040 asection *plt = htab->plt;
12041 if (!htab->elf.dynamic_sections_created)
12042 plt = htab->iplt;
8387904d 12043
e054468f
AM		 12044 rela.r_offset = (plt->output_section->vma
12045 + plt->output_offset
8387904d 12046 + ent->plt.offset);
8387904d 12047
e054468f
AM		 12048 if (!htab->elf.dynamic_sections_created
12049 || h->dynindx == -1)
12050 {
12051 BFD_ASSERT (h->type == STT_GNU_IFUNC
12052 && h->def_regular
12053 && (h->root.type == bfd_link_hash_defined
12054 || h->root.type == bfd_link_hash_defweak));
12055 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
12056 rela.r_addend = (h->root.u.def.value
12057 + h->root.u.def.section->output_offset
12058 + h->root.u.def.section->output_section->vma
12059 + ent->addend);
12060 }
12061 else
12062 {
12063 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
12064 rela.r_addend = ent->addend;
12065 }
12066
12067 if (!htab->elf.dynamic_sections_created)
12068 loc = (htab->reliplt->contents
12069 + (ent->plt.offset
12070 / (PLT_ENTRY_SIZE / sizeof (Elf64_External_Rela))));
12071 else
12072 loc = (htab->relplt->contents
12073 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE)
12074 / (PLT_ENTRY_SIZE / sizeof (Elf64_External_Rela))));
8387904d
AM		 12075 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
12076 }
5bd4f169 12077
f5385ebf 12078 if (h->needs_copy)
5bd4f169 12079 {
5bd4f169 12080 Elf_Internal_Rela rela;
947216bf 12081 bfd_byte *loc;
5bd4f169 12082
65f38f15 12083 /* This symbol needs a copy reloc. Set it up. */
5bd4f169 12084
65f38f15
AM		 12085 if (h->dynindx == -1
12086 || (h->root.type != bfd_link_hash_defined
12087 && h->root.type != bfd_link_hash_defweak)
4ce794b7 12088 || htab->relbss == NULL)
65f38f15 12089 abort ();
5bd4f169
AM		 12090
12091 rela.r_offset = (h->root.u.def.value
12092 + h->root.u.def.section->output_section->vma
12093 + h->root.u.def.section->output_offset);
12094 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
12095 rela.r_addend = 0;
4ce794b7
AM		 12096 loc = htab->relbss->contents;
12097 loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
65f38f15 12098 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
5bd4f169
AM		 12099 }
12100
5bd4f169
AM		 12101 /* Mark some specially defined symbols as absolute. */
12102 if (strcmp (h->root.root.string, "_DYNAMIC") == 0)
12103 sym->st_shndx = SHN_ABS;
12104
b34976b6 12105 return TRUE;
5bd4f169
AM		 12106}
12107
65f38f15
AM		 12108/* Used to decide how to sort relocs in an optimal manner for the
12109 dynamic linker, before writing them out. */
12110
12111static enum elf_reloc_type_class
4ce794b7 12112ppc64_elf_reloc_type_class (const Elf_Internal_Rela *rela)
65f38f15 12113{
04c9666a 12114 enum elf_ppc64_reloc_type r_type;
a33d1f77 12115
4ce794b7 12116 r_type = ELF64_R_TYPE (rela->r_info);
a33d1f77 12117 switch (r_type)
65f38f15
AM		 12118 {
12119 case R_PPC64_RELATIVE:
12120 return reloc_class_relative;
12121 case R_PPC64_JMP_SLOT:
12122 return reloc_class_plt;
12123 case R_PPC64_COPY:
12124 return reloc_class_copy;
12125 default:
12126 return reloc_class_normal;
12127 }
12128}
12129
5bd4f169
AM		 12130/* Finish up the dynamic sections. */
12131
b34976b6 12132static bfd_boolean
4ce794b7
AM		 12133ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
12134 struct bfd_link_info *info)
5bd4f169 12135{
65f38f15
AM		 12136 struct ppc_link_hash_table *htab;
12137 bfd *dynobj;
5bd4f169 12138 asection *sdyn;
5bd4f169 12139
65f38f15
AM		 12140 htab = ppc_hash_table (info);
12141 dynobj = htab->elf.dynobj;
5bd4f169
AM		 12142 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
12143
65f38f15 12144 if (htab->elf.dynamic_sections_created)
5bd4f169 12145 {
5bd4f169
AM		 12146 Elf64_External_Dyn *dyncon, *dynconend;
12147
4ce794b7 12148 if (sdyn == NULL || htab->got == NULL)
65f38f15 12149 abort ();
5bd4f169
AM		 12150
12151 dyncon = (Elf64_External_Dyn *) sdyn->contents;
eea6121a 12152 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
5bd4f169
AM		 12153 for (; dyncon < dynconend; dyncon++)
12154 {
12155 Elf_Internal_Dyn dyn;
19397422 12156 asection *s;
5bd4f169
AM		 12157
12158 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
12159
12160 switch (dyn.d_tag)
12161 {
65f38f15
AM		 12162 default:
12163 continue;
5bd4f169 12164
5d1634d7 12165 case DT_PPC64_GLINK:
4ce794b7 12166 s = htab->glink;
6348e046 12167 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
ad8e1ba5
AM		 12168 /* We stupidly defined DT_PPC64_GLINK to be the start
12169 of glink rather than the first entry point, which is
12170 what ld.so needs, and now have a bigger stub to
12171 support automatic multiple TOCs. */
12172 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 32;
5d1634d7
AM		 12173 break;
12174
19397422
AM		 12175 case DT_PPC64_OPD:
12176 s = bfd_get_section_by_name (output_bfd, ".opd");
6348e046
AM		 12177 if (s == NULL)
12178 continue;
12179 dyn.d_un.d_ptr = s->vma;
19397422
AM		 12180 break;
12181
12182 case DT_PPC64_OPDSZ:
12183 s = bfd_get_section_by_name (output_bfd, ".opd");
6348e046
AM		 12184 if (s == NULL)
12185 continue;
eea6121a 12186 dyn.d_un.d_val = s->size;
19397422
AM		 12187 break;
12188
65f38f15 12189 case DT_PLTGOT:
4ce794b7 12190 s = htab->plt;
6348e046 12191 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
65f38f15
AM		 12192 break;
12193
12194 case DT_JMPREL:
4ce794b7 12195 s = htab->relplt;
6348e046 12196 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
65f38f15 12197 break;
5bd4f169 12198
65f38f15 12199 case DT_PLTRELSZ:
eea6121a 12200 dyn.d_un.d_val = htab->relplt->size;
5d1634d7
AM		 12201 break;
12202
12203 case DT_RELASZ:
12204 /* Don't count procedure linkage table relocs in the
12205 overall reloc count. */
4ce794b7 12206 s = htab->relplt;
6348e046
AM		 12207 if (s == NULL)
12208 continue;
eea6121a 12209 dyn.d_un.d_val -= s->size;
6348e046
AM		 12210 break;
12211
12212 case DT_RELA:
12213 /* We may not be using the standard ELF linker script.
12214 If .rela.plt is the first .rela section, we adjust
12215 DT_RELA to not include it. */
4ce794b7 12216 s = htab->relplt;
6348e046
AM		 12217 if (s == NULL)
12218 continue;
12219 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
12220 continue;
eea6121a 12221 dyn.d_un.d_ptr += s->size;
65f38f15 12222 break;
5bd4f169 12223 }
5bd4f169 12224
65f38f15 12225 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
5bd4f169 12226 }
5bd4f169
AM		 12227 }
12228
eea6121a 12229 if (htab->got != NULL && htab->got->size != 0)
5d1634d7
AM		 12230 {
12231 /* Fill in the first entry in the global offset table.
12232 We use it to hold the link-time TOCbase. */
12233 bfd_put_64 (output_bfd,
60ee0d4a 12234 elf_gp (output_bfd) + TOC_BASE_OFF,
4ce794b7 12235 htab->got->contents);
5d1634d7
AM		 12236
12237 /* Set .got entry size. */
4ce794b7 12238 elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 8;
5d1634d7
AM		 12239 }
12240
eea6121a 12241 if (htab->plt != NULL && htab->plt->size != 0)
5d1634d7
AM		 12242 {
12243 /* Set .plt entry size. */
4ce794b7 12244 elf_section_data (htab->plt->output_section)->this_hdr.sh_entsize
5d1634d7
AM		 12245 = PLT_ENTRY_SIZE;
12246 }
12247
84f5d08e
AM		 12248 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
12249 brlt ourselves if emitrelocations. */
12250 if (htab->brlt != NULL
12251 && htab->brlt->reloc_count != 0
12252 && !_bfd_elf_link_output_relocs (output_bfd,
12253 htab->brlt,
12254 &elf_section_data (htab->brlt)->rel_hdr,
12255 elf_section_data (htab->brlt)->relocs,
12256 NULL))
12257 return FALSE;
12258
176a0d42
AM		 12259 if (htab->glink != NULL
12260 && htab->glink->reloc_count != 0
12261 && !_bfd_elf_link_output_relocs (output_bfd,
12262 htab->glink,
12263 &elf_section_data (htab->glink)->rel_hdr,
12264 elf_section_data (htab->glink)->relocs,
12265 NULL))
12266 return FALSE;
12267
e717da7e 12268 /* We need to handle writing out multiple GOT sections ourselves,
7b53ace3
AM		 12269 since we didn't add them to DYNOBJ. We know dynobj is the first
12270 bfd. */
e717da7e
AM		 12271 while ((dynobj = dynobj->link_next) != NULL)
12272 {
12273 asection *s;
7b53ace3 12274
0c8d6e5c 12275 if (!is_ppc64_elf (dynobj))
7b53ace3
AM		 12276 continue;
12277
e717da7e
AM		 12278 s = ppc64_elf_tdata (dynobj)->got;
12279 if (s != NULL
eea6121a 12280 && s->size != 0
e717da7e
AM		 12281 && s->output_section != bfd_abs_section_ptr
12282 && !bfd_set_section_contents (output_bfd, s->output_section,
12283 s->contents, s->output_offset,
eea6121a 12284 s->size))
e717da7e
AM		 12285 return FALSE;
12286 s = ppc64_elf_tdata (dynobj)->relgot;
12287 if (s != NULL
eea6121a 12288 && s->size != 0
e717da7e
AM		 12289 && s->output_section != bfd_abs_section_ptr
12290 && !bfd_set_section_contents (output_bfd, s->output_section,
12291 s->contents, s->output_offset,
eea6121a 12292 s->size))
e717da7e
AM		 12293 return FALSE;
12294 }
f6c52c13 12295
b34976b6 12296 return TRUE;
5bd4f169
AM		 12297}
12298
5bd4f169 12299#include "elf64-target.h"
GDB Binutils - Deliverables
This page took 1.956141 seconds and 4 git commands to generate.