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