]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - bfd/elf64-ppc.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Use current date in ChangeLog entry.
[thirdparty/binutils-gdb.git] / bfd / elf64-ppc.c
CommitLineData
5bd4f169 1/* PowerPC64-specific support for 64-bit ELF.
5d1634d7 2 Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
5bd4f169
AM		 3 Written by Linus Nordberg, Swox AB <info@swox.com>,
4 based on elf32-ppc.c by Ian Lance Taylor.
5
6This file is part of BFD, the Binary File Descriptor library.
7
8This program is free software; you can redistribute it and/or modify
9it under the terms of the GNU General Public License as published by
10the Free Software Foundation; either version 2 of the License, or
11(at your option) any later version.
12
13This program is distributed in the hope that it will be useful,
14but WITHOUT ANY WARRANTY; without even the implied warranty of
15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16GNU General Public License for more details.
17
18You should have received a copy of the GNU General Public License
19along with this program; if not, write to the Free Software
20Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21
22/* This file is based on the 64-bit PowerPC ELF ABI. It is also based
23 on the file elf32-ppc.c. */
24
25#include "bfd.h"
26#include "sysdep.h"
27#include "bfdlink.h"
28#include "libbfd.h"
29#include "elf-bfd.h"
30#include "elf/ppc.h"
5d1634d7 31#include "elf64-ppc.h"
5bd4f169
AM		 32
33#define USE_RELA /* we want RELA relocations, not REL. */
34
35
36static void ppc_howto_init
37 PARAMS ((void));
38static reloc_howto_type *ppc64_elf_reloc_type_lookup
39 PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
40static void ppc64_elf_info_to_howto
41 PARAMS ((bfd *abfd, arelent *cache_ptr, Elf64_Internal_Rela *dst));
805fc799
AM		 42static bfd_reloc_status_type ppc64_elf_ha_reloc
43 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
44static bfd_reloc_status_type ppc64_elf_brtaken_reloc
45 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
46static bfd_reloc_status_type ppc64_elf_sectoff_reloc
47 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
48static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
49 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
50static bfd_reloc_status_type ppc64_elf_toc_reloc
51 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
52static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
53 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
54static bfd_reloc_status_type ppc64_elf_toc64_reloc
55 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
56static bfd_reloc_status_type ppc64_elf_unhandled_reloc
5bd4f169 57 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
7cdc5bba
AM		 58static void ppc64_elf_get_symbol_info
59 PARAMS ((bfd *, asymbol *, symbol_info *));
5bd4f169
AM		 60static boolean ppc64_elf_set_private_flags
61 PARAMS ((bfd *, flagword));
5bd4f169
AM		 62static boolean ppc64_elf_merge_private_bfd_data
63 PARAMS ((bfd *, bfd *));
64static boolean ppc64_elf_section_from_shdr
65 PARAMS ((bfd *, Elf64_Internal_Shdr *, char *));
5bd4f169
AM		 66
67
5bd4f169
AM		 68/* The name of the dynamic interpreter. This is put in the .interp
69 section. */
70#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
71
72/* The size in bytes of an entry in the procedure linkage table. */
73#define PLT_ENTRY_SIZE 24
74
75/* The initial size of the plt reserved for the dynamic linker. */
5d1634d7 76#define PLT_INITIAL_ENTRY_SIZE PLT_ENTRY_SIZE
5bd4f169
AM		 77
78/* TOC base pointers offset from start of TOC. */
79#define TOC_BASE_OFF (0x8000)
80
5d1634d7
AM		 81/* .plt call stub instructions. */
82#define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
83#define STD_R2_40R1 0xf8410028 /* std %r2,40(%r1) */
84#define LD_R11_0R12 0xe96c0000 /* ld %r11,xxx+0@l(%r12) */
85#define LD_R2_0R12 0xe84c0000 /* ld %r2,xxx+8@l(%r12) */
86#define MTCTR_R11 0x7d6903a6 /* mtctr %r11 */
87 /* ld %r11,xxx+16@l(%r12) */
88#define BCTR 0x4e800420 /* bctr */
89
90/* The normal stub is this size. */
91#define PLT_CALL_STUB_SIZE (7*4)
92
93/* But sometimes the .plt entry crosses a 64k boundary, and we need
94 to adjust the high word with this insn. */
95#define ADDIS_R12_R12_1 0x3d8c0001 /* addis %r12,%r12,1 */
5bd4f169 96
5d1634d7
AM		 97/* The .glink fixup call stub is the same as the .plt call stub, but
98 the first instruction restores r2, and the std is omitted. */
99#define LD_R2_40R1 0xe8410028 /* ld %r2,40(%r1) */
100
101/* Always allow this much space. */
102#define GLINK_CALL_STUB_SIZE (8*4)
103
104/* Pad with this. */
105#define NOP 0x60000000
106
721956f4
AM		 107/* Some other nops. */
108#define CROR_151515 0x4def7b82
109#define CROR_313131 0x4ffffb82
110
5d1634d7
AM		 111/* .glink entries for the first 32k functions are two instructions. */
112#define LI_R0_0 0x38000000 /* li %r0,0 */
113#define B_DOT 0x48000000 /* b . */
114
115/* After that, we need two instructions to load the index, followed by
116 a branch. */
117#define LIS_R0_0 0x3c000000 /* lis %r0,0 */
10ed1bba 118#define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
41bd81ab 119
82bd7b59
AM		 120/* Instructions to save and restore floating point regs. */
121#define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
122#define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
123#define BLR 0x4e800020 /* blr */
124
41bd81ab
AM		 125/* Since .opd is an array of descriptors and each entry will end up
126 with identical R_PPC64_RELATIVE relocs, there is really no need to
127 propagate .opd relocs; The dynamic linker should be taught to
19397422
AM		 128 relocate .opd without reloc entries. FIXME: .opd should be trimmed
129 of unused values. */
41bd81ab
AM		 130#ifndef NO_OPD_RELOCS
131#define NO_OPD_RELOCS 0
132#endif
5bd4f169
AM		 133\f
134/* Relocation HOWTO's. */
135static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC_max];
136
137static reloc_howto_type ppc64_elf_howto_raw[] = {
138 /* This reloc does nothing. */
139 HOWTO (R_PPC64_NONE, /* type */
140 0, /* rightshift */
141 2, /* size (0 = byte, 1 = short, 2 = long) */
142 32, /* bitsize */
143 false, /* pc_relative */
144 0, /* bitpos */
145 complain_overflow_bitfield, /* complain_on_overflow */
146 bfd_elf_generic_reloc, /* special_function */
147 "R_PPC64_NONE", /* name */
148 false, /* partial_inplace */
149 0, /* src_mask */
150 0, /* dst_mask */
151 false), /* pcrel_offset */
152
153 /* A standard 32 bit relocation. */
154 HOWTO (R_PPC64_ADDR32, /* type */
155 0, /* rightshift */
156 2, /* size (0 = byte, 1 = short, 2 = long) */
157 32, /* bitsize */
158 false, /* pc_relative */
159 0, /* bitpos */
160 complain_overflow_bitfield, /* complain_on_overflow */
161 bfd_elf_generic_reloc, /* special_function */
162 "R_PPC64_ADDR32", /* name */
163 false, /* partial_inplace */
164 0, /* src_mask */
165 0xffffffff, /* dst_mask */
166 false), /* pcrel_offset */
167
168 /* An absolute 26 bit branch; the lower two bits must be zero.
169 FIXME: we don't check that, we just clear them. */
170 HOWTO (R_PPC64_ADDR24, /* type */
171 0, /* rightshift */
172 2, /* size (0 = byte, 1 = short, 2 = long) */
173 26, /* bitsize */
174 false, /* pc_relative */
175 0, /* bitpos */
176 complain_overflow_bitfield, /* complain_on_overflow */
177 bfd_elf_generic_reloc, /* special_function */
178 "R_PPC64_ADDR24", /* name */
179 false, /* partial_inplace */
180 0, /* src_mask */
181 0x3fffffc, /* dst_mask */
182 false), /* pcrel_offset */
183
184 /* A standard 16 bit relocation. */
185 HOWTO (R_PPC64_ADDR16, /* type */
186 0, /* rightshift */
187 1, /* size (0 = byte, 1 = short, 2 = long) */
188 16, /* bitsize */
189 false, /* pc_relative */
190 0, /* bitpos */
191 complain_overflow_bitfield, /* complain_on_overflow */
192 bfd_elf_generic_reloc, /* special_function */
193 "R_PPC64_ADDR16", /* name */
194 false, /* partial_inplace */
195 0, /* src_mask */
196 0xffff, /* dst_mask */
197 false), /* pcrel_offset */
198
199 /* A 16 bit relocation without overflow. */
200 HOWTO (R_PPC64_ADDR16_LO, /* type */
201 0, /* rightshift */
202 1, /* size (0 = byte, 1 = short, 2 = long) */
203 16, /* bitsize */
204 false, /* pc_relative */
205 0, /* bitpos */
206 complain_overflow_dont,/* complain_on_overflow */
207 bfd_elf_generic_reloc, /* special_function */
208 "R_PPC64_ADDR16_LO", /* name */
209 false, /* partial_inplace */
210 0, /* src_mask */
211 0xffff, /* dst_mask */
212 false), /* pcrel_offset */
213
214 /* Bits 16-31 of an address. */
215 HOWTO (R_PPC64_ADDR16_HI, /* type */
216 16, /* rightshift */
217 1, /* size (0 = byte, 1 = short, 2 = long) */
218 16, /* bitsize */
219 false, /* pc_relative */
220 0, /* bitpos */
221 complain_overflow_dont, /* complain_on_overflow */
222 bfd_elf_generic_reloc, /* special_function */
223 "R_PPC64_ADDR16_HI", /* name */
224 false, /* partial_inplace */
225 0, /* src_mask */
226 0xffff, /* dst_mask */
227 false), /* pcrel_offset */
228
229 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
230 bits, treated as a signed number, is negative. */
231 HOWTO (R_PPC64_ADDR16_HA, /* type */
232 16, /* rightshift */
233 1, /* size (0 = byte, 1 = short, 2 = long) */
234 16, /* bitsize */
235 false, /* pc_relative */
236 0, /* bitpos */
237 complain_overflow_dont, /* complain_on_overflow */
805fc799 238 ppc64_elf_ha_reloc, /* special_function */
5bd4f169
AM		 239 "R_PPC64_ADDR16_HA", /* name */
240 false, /* partial_inplace */
241 0, /* src_mask */
242 0xffff, /* dst_mask */
243 false), /* pcrel_offset */
244
245 /* An absolute 16 bit branch; the lower two bits must be zero.
246 FIXME: we don't check that, we just clear them. */
247 HOWTO (R_PPC64_ADDR14, /* type */
248 0, /* rightshift */
249 2, /* size (0 = byte, 1 = short, 2 = long) */
250 16, /* bitsize */
251 false, /* pc_relative */
252 0, /* bitpos */
253 complain_overflow_bitfield, /* complain_on_overflow */
254 bfd_elf_generic_reloc, /* special_function */
255 "R_PPC64_ADDR14", /* name */
256 false, /* partial_inplace */
257 0, /* src_mask */
258 0xfffc, /* dst_mask */
259 false), /* pcrel_offset */
260
261 /* An absolute 16 bit branch, for which bit 10 should be set to
262 indicate that the branch is expected to be taken. The lower two
263 bits must be zero. */
264 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
265 0, /* rightshift */
266 2, /* size (0 = byte, 1 = short, 2 = long) */
267 16, /* bitsize */
268 false, /* pc_relative */
269 0, /* bitpos */
270 complain_overflow_bitfield, /* complain_on_overflow */
805fc799 271 ppc64_elf_brtaken_reloc, /* special_function */
5bd4f169
AM		 272 "R_PPC64_ADDR14_BRTAKEN",/* name */
273 false, /* partial_inplace */
274 0, /* src_mask */
275 0xfffc, /* dst_mask */
276 false), /* pcrel_offset */
277
278 /* An absolute 16 bit branch, for which bit 10 should be set to
279 indicate that the branch is not expected to be taken. The lower
280 two bits must be zero. */
281 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
282 0, /* rightshift */
283 2, /* size (0 = byte, 1 = short, 2 = long) */
284 16, /* bitsize */
285 false, /* pc_relative */
286 0, /* bitpos */
287 complain_overflow_bitfield, /* complain_on_overflow */
805fc799 288 ppc64_elf_brtaken_reloc, /* special_function */
5bd4f169
AM		 289 "R_PPC64_ADDR14_BRNTAKEN",/* name */
290 false, /* partial_inplace */
291 0, /* src_mask */
292 0xfffc, /* dst_mask */
293 false), /* pcrel_offset */
294
295 /* A relative 26 bit branch; the lower two bits must be zero. */
296 HOWTO (R_PPC64_REL24, /* type */
297 0, /* rightshift */
298 2, /* size (0 = byte, 1 = short, 2 = long) */
299 26, /* bitsize */
300 true, /* pc_relative */
301 0, /* bitpos */
302 complain_overflow_signed, /* complain_on_overflow */
303 bfd_elf_generic_reloc, /* special_function */
304 "R_PPC64_REL24", /* name */
305 false, /* partial_inplace */
306 0, /* src_mask */
307 0x3fffffc, /* dst_mask */
308 true), /* pcrel_offset */
309
310 /* A relative 16 bit branch; the lower two bits must be zero. */
311 HOWTO (R_PPC64_REL14, /* type */
312 0, /* rightshift */
313 2, /* size (0 = byte, 1 = short, 2 = long) */
314 16, /* bitsize */
315 true, /* pc_relative */
316 0, /* bitpos */
317 complain_overflow_signed, /* complain_on_overflow */
318 bfd_elf_generic_reloc, /* special_function */
319 "R_PPC64_REL14", /* name */
320 false, /* partial_inplace */
321 0, /* src_mask */
322 0xfffc, /* dst_mask */
323 true), /* pcrel_offset */
324
325 /* A relative 16 bit branch. Bit 10 should be set to indicate that
326 the branch is expected to be taken. The lower two bits must be
327 zero. */
328 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
329 0, /* rightshift */
330 2, /* size (0 = byte, 1 = short, 2 = long) */
331 16, /* bitsize */
332 true, /* pc_relative */
333 0, /* bitpos */
334 complain_overflow_signed, /* complain_on_overflow */
805fc799 335 ppc64_elf_brtaken_reloc, /* special_function */
5bd4f169
AM		 336 "R_PPC64_REL14_BRTAKEN", /* name */
337 false, /* partial_inplace */
338 0, /* src_mask */
339 0xfffc, /* dst_mask */
340 true), /* pcrel_offset */
341
342 /* A relative 16 bit branch. Bit 10 should be set to indicate that
343 the branch is not expected to be taken. The lower two bits must
344 be zero. */
345 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
346 0, /* rightshift */
347 2, /* size (0 = byte, 1 = short, 2 = long) */
348 16, /* bitsize */
349 true, /* pc_relative */
350 0, /* bitpos */
351 complain_overflow_signed, /* complain_on_overflow */
805fc799 352 ppc64_elf_brtaken_reloc, /* special_function */
5bd4f169
AM		 353 "R_PPC64_REL14_BRNTAKEN",/* name */
354 false, /* partial_inplace */
355 0, /* src_mask */
356 0xfffc, /* dst_mask */
357 true), /* pcrel_offset */
358
359 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
360 symbol. */
361 HOWTO (R_PPC64_GOT16, /* type */
362 0, /* rightshift */
363 1, /* size (0 = byte, 1 = short, 2 = long) */
364 16, /* bitsize */
365 false, /* pc_relative */
366 0, /* bitpos */
367 complain_overflow_signed, /* complain_on_overflow */
805fc799 368 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169
AM		 369 "R_PPC64_GOT16", /* name */
370 false, /* partial_inplace */
371 0, /* src_mask */
372 0xffff, /* dst_mask */
373 false), /* pcrel_offset */
374
375 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
376 the symbol. */
377 HOWTO (R_PPC64_GOT16_LO, /* type */
378 0, /* rightshift */
379 1, /* size (0 = byte, 1 = short, 2 = long) */
380 16, /* bitsize */
381 false, /* pc_relative */
382 0, /* bitpos */
383 complain_overflow_dont, /* complain_on_overflow */
805fc799 384 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169
AM		 385 "R_PPC64_GOT16_LO", /* name */
386 false, /* partial_inplace */
387 0, /* src_mask */
388 0xffff, /* dst_mask */
389 false), /* pcrel_offset */
390
391 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
392 the symbol. */
393 HOWTO (R_PPC64_GOT16_HI, /* type */
394 16, /* rightshift */
395 1, /* size (0 = byte, 1 = short, 2 = long) */
396 16, /* bitsize */
397 false, /* pc_relative */
398 0, /* bitpos */
399 complain_overflow_dont,/* complain_on_overflow */
805fc799 400 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169
AM		 401 "R_PPC64_GOT16_HI", /* name */
402 false, /* partial_inplace */
403 0, /* src_mask */
404 0xffff, /* dst_mask */
405 false), /* pcrel_offset */
406
407 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
408 the symbol. */
409 HOWTO (R_PPC64_GOT16_HA, /* type */
410 16, /* rightshift */
411 1, /* size (0 = byte, 1 = short, 2 = long) */
412 16, /* bitsize */
413 false, /* pc_relative */
414 0, /* bitpos */
415 complain_overflow_dont,/* complain_on_overflow */
805fc799 416 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169
AM		 417 "R_PPC64_GOT16_HA", /* name */
418 false, /* partial_inplace */
419 0, /* src_mask */
420 0xffff, /* dst_mask */
421 false), /* pcrel_offset */
422
423 /* This is used only by the dynamic linker. The symbol should exist
424 both in the object being run and in some shared library. The
425 dynamic linker copies the data addressed by the symbol from the
426 shared library into the object, because the object being
427 run has to have the data at some particular address. */
428 HOWTO (R_PPC64_COPY, /* type */
429 0, /* rightshift */
430 2, /* size (0 = byte, 1 = short, 2 = long) */
431 32, /* bitsize */
432 false, /* pc_relative */
433 0, /* bitpos */
434 complain_overflow_bitfield, /* complain_on_overflow */
805fc799 435 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169
AM		 436 "R_PPC64_COPY", /* name */
437 false, /* partial_inplace */
438 0, /* src_mask */
439 0, /* dst_mask */
440 false), /* pcrel_offset */
441
442 /* Like R_PPC64_ADDR64, but used when setting global offset table
443 entries. */
444 HOWTO (R_PPC64_GLOB_DAT, /* type */
445 0, /* rightshift */
446 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
447 64, /* bitsize */
448 false, /* pc_relative */
449 0, /* bitpos */
450 complain_overflow_dont, /* complain_on_overflow */
805fc799 451 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169
AM		 452 "R_PPC64_GLOB_DAT", /* name */
453 false, /* partial_inplace */
454 0, /* src_mask */
455 0xffffffffffffffff, /* dst_mask */
456 false), /* pcrel_offset */
457
458 /* Created by the link editor. Marks a procedure linkage table
459 entry for a symbol. */
460 HOWTO (R_PPC64_JMP_SLOT, /* type */
461 0, /* rightshift */
462 0, /* size (0 = byte, 1 = short, 2 = long) */
463 0, /* bitsize */
464 false, /* pc_relative */
465 0, /* bitpos */
466 complain_overflow_dont, /* complain_on_overflow */
805fc799 467 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169
AM		 468 "R_PPC64_JMP_SLOT", /* name */
469 false, /* partial_inplace */
470 0, /* src_mask */
471 0, /* dst_mask */
472 false), /* pcrel_offset */
473
474 /* Used only by the dynamic linker. When the object is run, this
475 doubleword64 is set to the load address of the object, plus the
476 addend. */
477 HOWTO (R_PPC64_RELATIVE, /* type */
478 0, /* rightshift */
479 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
480 64, /* bitsize */
8fc39d5d 481 false, /* pc_relative */
5bd4f169
AM		 482 0, /* bitpos */
483 complain_overflow_dont, /* complain_on_overflow */
484 bfd_elf_generic_reloc, /* special_function */
485 "R_PPC64_RELATIVE", /* name */
486 false, /* partial_inplace */
487 0, /* src_mask */
488 0xffffffffffffffff, /* dst_mask */
8fc39d5d 489 false), /* pcrel_offset */
5bd4f169
AM		 490
491 /* Like R_PPC64_ADDR32, but may be unaligned. */
492 HOWTO (R_PPC64_UADDR32, /* type */
493 0, /* rightshift */
494 2, /* size (0 = byte, 1 = short, 2 = long) */
495 32, /* bitsize */
496 false, /* pc_relative */
497 0, /* bitpos */
498 complain_overflow_bitfield, /* complain_on_overflow */
499 bfd_elf_generic_reloc, /* special_function */
500 "R_PPC64_UADDR32", /* name */
501 false, /* partial_inplace */
502 0, /* src_mask */
503 0xffffffff, /* dst_mask */
504 false), /* pcrel_offset */
505
506 /* Like R_PPC64_ADDR16, but may be unaligned. */
507 HOWTO (R_PPC64_UADDR16, /* type */
508 0, /* rightshift */
509 1, /* size (0 = byte, 1 = short, 2 = long) */
510 16, /* bitsize */
511 false, /* pc_relative */
512 0, /* bitpos */
513 complain_overflow_bitfield, /* complain_on_overflow */
514 bfd_elf_generic_reloc, /* special_function */
515 "R_PPC64_UADDR16", /* name */
516 false, /* partial_inplace */
517 0, /* src_mask */
518 0xffff, /* dst_mask */
519 false), /* pcrel_offset */
520
521 /* 32-bit PC relative. */
522 HOWTO (R_PPC64_REL32, /* type */
523 0, /* rightshift */
524 2, /* size (0 = byte, 1 = short, 2 = long) */
525 32, /* bitsize */
526 true, /* pc_relative */
527 0, /* bitpos */
528 /* FIXME: Verify. Was complain_overflow_bitfield. */
529 complain_overflow_signed, /* complain_on_overflow */
530 bfd_elf_generic_reloc, /* special_function */
531 "R_PPC64_REL32", /* name */
532 false, /* partial_inplace */
533 0, /* src_mask */
534 0xffffffff, /* dst_mask */
535 true), /* pcrel_offset */
536
10ed1bba 537 /* 32-bit relocation to the symbol's procedure linkage table. */
5bd4f169
AM		 538 HOWTO (R_PPC64_PLT32, /* type */
539 0, /* rightshift */
540 2, /* size (0 = byte, 1 = short, 2 = long) */
541 32, /* bitsize */
542 false, /* pc_relative */
543 0, /* bitpos */
544 complain_overflow_bitfield, /* complain_on_overflow */
805fc799 545 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169
AM		 546 "R_PPC64_PLT32", /* name */
547 false, /* partial_inplace */
548 0, /* src_mask */
549 0, /* dst_mask */
550 false), /* pcrel_offset */
551
552 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
553 FIXME: R_PPC64_PLTREL32 not supported. */
554 HOWTO (R_PPC64_PLTREL32, /* type */
555 0, /* rightshift */
556 2, /* size (0 = byte, 1 = short, 2 = long) */
557 32, /* bitsize */
558 true, /* pc_relative */
559 0, /* bitpos */
560 complain_overflow_signed, /* complain_on_overflow */
561 bfd_elf_generic_reloc, /* special_function */
562 "R_PPC64_PLTREL32", /* name */
563 false, /* partial_inplace */
564 0, /* src_mask */
565 0, /* dst_mask */
566 true), /* pcrel_offset */
567
568 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
569 the symbol. */
570 HOWTO (R_PPC64_PLT16_LO, /* type */
571 0, /* rightshift */
572 1, /* size (0 = byte, 1 = short, 2 = long) */
573 16, /* bitsize */
574 false, /* pc_relative */
575 0, /* bitpos */
576 complain_overflow_dont, /* complain_on_overflow */
805fc799 577 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169
AM		 578 "R_PPC64_PLT16_LO", /* name */
579 false, /* partial_inplace */
580 0, /* src_mask */
581 0xffff, /* dst_mask */
582 false), /* pcrel_offset */
583
584 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
585 the symbol. */
586 HOWTO (R_PPC64_PLT16_HI, /* type */
587 16, /* rightshift */
588 1, /* size (0 = byte, 1 = short, 2 = long) */
589 16, /* bitsize */
590 false, /* pc_relative */
591 0, /* bitpos */
592 complain_overflow_dont, /* complain_on_overflow */
805fc799 593 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169
AM		 594 "R_PPC64_PLT16_HI", /* name */
595 false, /* partial_inplace */
596 0, /* src_mask */
597 0xffff, /* dst_mask */
598 false), /* pcrel_offset */
599
600 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
601 the symbol. */
602 HOWTO (R_PPC64_PLT16_HA, /* type */
603 16, /* rightshift */
604 1, /* size (0 = byte, 1 = short, 2 = long) */
605 16, /* bitsize */
606 false, /* pc_relative */
607 0, /* bitpos */
608 complain_overflow_dont, /* complain_on_overflow */
805fc799 609 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169
AM		 610 "R_PPC64_PLT16_HA", /* name */
611 false, /* partial_inplace */
612 0, /* src_mask */
613 0xffff, /* dst_mask */
614 false), /* pcrel_offset */
615
c061c2d8 616 /* 16-bit section relative relocation. */
5bd4f169
AM		 617 HOWTO (R_PPC64_SECTOFF, /* type */
618 0, /* rightshift */
c061c2d8
AM		 619 1, /* size (0 = byte, 1 = short, 2 = long) */
620 16, /* bitsize */
805fc799 621 false, /* pc_relative */
5bd4f169
AM		 622 0, /* bitpos */
623 complain_overflow_bitfield, /* complain_on_overflow */
805fc799 624 ppc64_elf_sectoff_reloc, /* special_function */
5bd4f169
AM		 625 "R_PPC64_SECTOFF", /* name */
626 false, /* partial_inplace */
627 0, /* src_mask */
c061c2d8 628 0xffff, /* dst_mask */
805fc799 629 false), /* pcrel_offset */
5bd4f169 630
c061c2d8 631 /* Like R_PPC64_SECTOFF, but no overflow warning. */
5bd4f169
AM		 632 HOWTO (R_PPC64_SECTOFF_LO, /* type */
633 0, /* rightshift */
634 1, /* size (0 = byte, 1 = short, 2 = long) */
635 16, /* bitsize */
636 false, /* pc_relative */
637 0, /* bitpos */
638 complain_overflow_dont, /* complain_on_overflow */
805fc799 639 ppc64_elf_sectoff_reloc, /* special_function */
5bd4f169
AM		 640 "R_PPC64_SECTOFF_LO", /* name */
641 false, /* partial_inplace */
642 0, /* src_mask */
643 0xffff, /* dst_mask */
644 false), /* pcrel_offset */
645
646 /* 16-bit upper half section relative relocation. */
647 HOWTO (R_PPC64_SECTOFF_HI, /* type */
648 16, /* rightshift */
649 1, /* size (0 = byte, 1 = short, 2 = long) */
650 16, /* bitsize */
651 false, /* pc_relative */
652 0, /* bitpos */
653 complain_overflow_dont, /* complain_on_overflow */
805fc799 654 ppc64_elf_sectoff_reloc, /* special_function */
5bd4f169
AM		 655 "R_PPC64_SECTOFF_HI", /* name */
656 false, /* partial_inplace */
657 0, /* src_mask */
658 0xffff, /* dst_mask */
659 false), /* pcrel_offset */
660
661 /* 16-bit upper half adjusted section relative relocation. */
662 HOWTO (R_PPC64_SECTOFF_HA, /* type */
663 16, /* rightshift */
664 1, /* size (0 = byte, 1 = short, 2 = long) */
665 16, /* bitsize */
666 false, /* pc_relative */
667 0, /* bitpos */
668 complain_overflow_dont, /* complain_on_overflow */
805fc799 669 ppc64_elf_sectoff_ha_reloc, /* special_function */
5bd4f169
AM		 670 "R_PPC64_SECTOFF_HA", /* name */
671 false, /* partial_inplace */
672 0, /* src_mask */
673 0xffff, /* dst_mask */
674 false), /* pcrel_offset */
675
676 /* Like R_PPC64_REL24 without touching the two least significant
805fc799 677 bits. Should have been named R_PPC64_REL30! */
5bd4f169
AM		 678 HOWTO (R_PPC64_ADDR30, /* type */
679 2, /* rightshift */
680 2, /* size (0 = byte, 1 = short, 2 = long) */
681 30, /* bitsize */
682 true, /* pc_relative */
683 0, /* bitpos */
684 complain_overflow_dont, /* complain_on_overflow */
685 bfd_elf_generic_reloc, /* special_function */
686 "R_PPC64_ADDR30", /* name */
687 false, /* partial_inplace */
688 0, /* src_mask */
689 0xfffffffc, /* dst_mask */
690 true), /* pcrel_offset */
691
692 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
693
694 /* A standard 64-bit relocation. */
695 HOWTO (R_PPC64_ADDR64, /* type */
696 0, /* rightshift */
697 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
698 64, /* bitsize */
699 false, /* pc_relative */
700 0, /* bitpos */
701 complain_overflow_dont, /* complain_on_overflow */
702 bfd_elf_generic_reloc, /* special_function */
703 "R_PPC64_ADDR64", /* name */
704 false, /* partial_inplace */
705 0, /* src_mask */
706 0xffffffffffffffff, /* dst_mask */
707 false), /* pcrel_offset */
708
709 /* The bits 32-47 of an address. */
710 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
711 32, /* rightshift */
712 1, /* size (0 = byte, 1 = short, 2 = long) */
713 16, /* bitsize */
714 false, /* pc_relative */
715 0, /* bitpos */
716 complain_overflow_dont, /* complain_on_overflow */
717 bfd_elf_generic_reloc, /* special_function */
718 "R_PPC64_ADDR16_HIGHER", /* name */
719 false, /* partial_inplace */
720 0, /* src_mask */
721 0xffff, /* dst_mask */
722 false), /* pcrel_offset */
723
724 /* The bits 32-47 of an address, plus 1 if the contents of the low
725 16 bits, treated as a signed number, is negative. */
726 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
727 32, /* rightshift */
728 1, /* size (0 = byte, 1 = short, 2 = long) */
729 16, /* bitsize */
730 false, /* pc_relative */
731 0, /* bitpos */
732 complain_overflow_dont, /* complain_on_overflow */
805fc799 733 ppc64_elf_ha_reloc, /* special_function */
5bd4f169
AM		 734 "R_PPC64_ADDR16_HIGHERA", /* name */
735 false, /* partial_inplace */
736 0, /* src_mask */
737 0xffff, /* dst_mask */
738 false), /* pcrel_offset */
739
740 /* The bits 48-63 of an address. */
741 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
742 48, /* rightshift */
743 1, /* size (0 = byte, 1 = short, 2 = long) */
744 16, /* bitsize */
745 false, /* pc_relative */
746 0, /* bitpos */
747 complain_overflow_dont, /* complain_on_overflow */
748 bfd_elf_generic_reloc, /* special_function */
749 "R_PPC64_ADDR16_HIGHEST", /* name */
750 false, /* partial_inplace */
751 0, /* src_mask */
752 0xffff, /* dst_mask */
753 false), /* pcrel_offset */
754
755 /* The bits 48-63 of an address, plus 1 if the contents of the low
756 16 bits, treated as a signed number, is negative. */
757 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
758 48, /* rightshift */
759 1, /* size (0 = byte, 1 = short, 2 = long) */
760 16, /* bitsize */
761 false, /* pc_relative */
762 0, /* bitpos */
763 complain_overflow_dont, /* complain_on_overflow */
805fc799 764 ppc64_elf_ha_reloc, /* special_function */
5bd4f169
AM		 765 "R_PPC64_ADDR16_HIGHESTA", /* name */
766 false, /* partial_inplace */
767 0, /* src_mask */
768 0xffff, /* dst_mask */
769 false), /* pcrel_offset */
770
771 /* Like ADDR64, but may be unaligned. */
772 HOWTO (R_PPC64_UADDR64, /* type */
773 0, /* rightshift */
774 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
775 64, /* bitsize */
776 false, /* pc_relative */
777 0, /* bitpos */
778 complain_overflow_dont, /* complain_on_overflow */
779 bfd_elf_generic_reloc, /* special_function */
780 "R_PPC64_UADDR64", /* name */
781 false, /* partial_inplace */
782 0, /* src_mask */
783 0xffffffffffffffff, /* dst_mask */
784 false), /* pcrel_offset */
785
786 /* 64-bit relative relocation. */
787 HOWTO (R_PPC64_REL64, /* type */
788 0, /* rightshift */
789 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
790 64, /* bitsize */
791 true, /* pc_relative */
792 0, /* bitpos */
793 complain_overflow_dont, /* complain_on_overflow */
794 bfd_elf_generic_reloc, /* special_function */
795 "R_PPC64_REL64", /* name */
796 false, /* partial_inplace */
797 0, /* src_mask */
798 0xffffffffffffffff, /* dst_mask */
799 true), /* pcrel_offset */
800
801 /* 64-bit relocation to the symbol's procedure linkage table. */
5bd4f169
AM		 802 HOWTO (R_PPC64_PLT64, /* type */
803 0, /* rightshift */
804 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
805 64, /* bitsize */
806 false, /* pc_relative */
807 0, /* bitpos */
808 complain_overflow_dont, /* complain_on_overflow */
805fc799 809 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169
AM		 810 "R_PPC64_PLT64", /* name */
811 false, /* partial_inplace */
812 0, /* src_mask */
813 0, /* dst_mask */
814 false), /* pcrel_offset */
815
816 /* 64-bit PC relative relocation to the symbol's procedure linkage
817 table. */
818 /* FIXME: R_PPC64_PLTREL64 not supported. */
819 HOWTO (R_PPC64_PLTREL64, /* type */
820 0, /* rightshift */
821 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
822 64, /* bitsize */
823 true, /* pc_relative */
824 0, /* bitpos */
825 complain_overflow_dont, /* complain_on_overflow */
805fc799 826 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169
AM		 827 "R_PPC64_PLTREL64", /* name */
828 false, /* partial_inplace */
829 0, /* src_mask */
830 0, /* dst_mask */
831 true), /* pcrel_offset */
832
833 /* 16 bit TOC-relative relocation. */
834
835 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
836 HOWTO (R_PPC64_TOC16, /* type */
837 0, /* rightshift */
838 1, /* size (0 = byte, 1 = short, 2 = long) */
839 16, /* bitsize */
840 false, /* pc_relative */
841 0, /* bitpos */
842 complain_overflow_signed, /* complain_on_overflow */
805fc799 843 ppc64_elf_toc_reloc, /* special_function */
5bd4f169
AM		 844 "R_PPC64_TOC16", /* name */
845 false, /* partial_inplace */
846 0, /* src_mask */
847 0xffff, /* dst_mask */
848 false), /* pcrel_offset */
849
850 /* 16 bit TOC-relative relocation without overflow. */
851
852 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
853 HOWTO (R_PPC64_TOC16_LO, /* type */
854 0, /* rightshift */
855 1, /* size (0 = byte, 1 = short, 2 = long) */
856 16, /* bitsize */
857 false, /* pc_relative */
858 0, /* bitpos */
859 complain_overflow_dont, /* complain_on_overflow */
805fc799 860 ppc64_elf_toc_reloc, /* special_function */
5bd4f169
AM		 861 "R_PPC64_TOC16_LO", /* name */
862 false, /* partial_inplace */
863 0, /* src_mask */
864 0xffff, /* dst_mask */
865 false), /* pcrel_offset */
866
867 /* 16 bit TOC-relative relocation, high 16 bits. */
868
869 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
870 HOWTO (R_PPC64_TOC16_HI, /* type */
871 16, /* rightshift */
872 1, /* size (0 = byte, 1 = short, 2 = long) */
873 16, /* bitsize */
874 false, /* pc_relative */
875 0, /* bitpos */
876 complain_overflow_dont, /* complain_on_overflow */
805fc799 877 ppc64_elf_toc_reloc, /* special_function */
5bd4f169
AM		 878 "R_PPC64_TOC16_HI", /* name */
879 false, /* partial_inplace */
880 0, /* src_mask */
881 0xffff, /* dst_mask */
882 false), /* pcrel_offset */
883
884 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
885 contents of the low 16 bits, treated as a signed number, is
886 negative. */
887
888 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
889 HOWTO (R_PPC64_TOC16_HA, /* type */
890 16, /* rightshift */
891 1, /* size (0 = byte, 1 = short, 2 = long) */
892 16, /* bitsize */
893 false, /* pc_relative */
894 0, /* bitpos */
895 complain_overflow_dont, /* complain_on_overflow */
805fc799 896 ppc64_elf_toc_ha_reloc, /* special_function */
5bd4f169
AM		 897 "R_PPC64_TOC16_HA", /* name */
898 false, /* partial_inplace */
899 0, /* src_mask */
900 0xffff, /* dst_mask */
901 false), /* pcrel_offset */
902
903 /* 64-bit relocation; insert value of TOC base (.TOC.). */
904
905 /* R_PPC64_TOC 51 doubleword64 .TOC. */
906 HOWTO (R_PPC64_TOC, /* type */
907 0, /* rightshift */
908 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
909 64, /* bitsize */
910 false, /* pc_relative */
911 0, /* bitpos */
912 complain_overflow_bitfield, /* complain_on_overflow */
805fc799 913 ppc64_elf_toc64_reloc, /* special_function */
5bd4f169
AM		 914 "R_PPC64_TOC", /* name */
915 false, /* partial_inplace */
916 0, /* src_mask */
917 0xffffffffffffffff, /* dst_mask */
918 false), /* pcrel_offset */
919
920 /* Like R_PPC64_GOT16, but also informs the link editor that the
921 value to relocate may (!) refer to a PLT entry which the link
922 editor (a) may replace with the symbol value. If the link editor
923 is unable to fully resolve the symbol, it may (b) create a PLT
924 entry and store the address to the new PLT entry in the GOT.
925 This permits lazy resolution of function symbols at run time.
926 The link editor may also skip all of this and just (c) emit a
927 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
928 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
929 HOWTO (R_PPC64_PLTGOT16, /* type */
930 0, /* rightshift */
931 1, /* size (0 = byte, 1 = short, 2 = long) */
932 16, /* bitsize */
933 false, /* pc_relative */
934 0, /* bitpos */
935 complain_overflow_signed, /* complain_on_overflow */
805fc799 936 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169
AM		 937 "R_PPC64_PLTGOT16", /* name */
938 false, /* partial_inplace */
939 0, /* src_mask */
940 0xffff, /* dst_mask */
941 false), /* pcrel_offset */
942
943 /* Like R_PPC64_PLTGOT16, but without overflow. */
944 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
945 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
946 0, /* rightshift */
947 1, /* size (0 = byte, 1 = short, 2 = long) */
948 16, /* bitsize */
949 false, /* pc_relative */
950 0, /* bitpos */
951 complain_overflow_dont, /* complain_on_overflow */
805fc799 952 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169
AM		 953 "R_PPC64_PLTGOT16_LO", /* name */
954 false, /* partial_inplace */
955 0, /* src_mask */
956 0xffff, /* dst_mask */
957 false), /* pcrel_offset */
958
959 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
960 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
961 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
962 16, /* rightshift */
963 1, /* size (0 = byte, 1 = short, 2 = long) */
964 16, /* bitsize */
965 false, /* pc_relative */
966 0, /* bitpos */
967 complain_overflow_dont, /* complain_on_overflow */
805fc799 968 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169
AM		 969 "R_PPC64_PLTGOT16_HI", /* name */
970 false, /* partial_inplace */
971 0, /* src_mask */
972 0xffff, /* dst_mask */
973 false), /* pcrel_offset */
974
975 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
976 1 if the contents of the low 16 bits, treated as a signed number,
977 is negative. */
978 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
979 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
980 16, /* rightshift */
981 1, /* size (0 = byte, 1 = short, 2 = long) */
982 16, /* bitsize */
983 false, /* pc_relative */
984 0, /* bitpos */
985 complain_overflow_dont,/* complain_on_overflow */
805fc799 986 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169
AM		 987 "R_PPC64_PLTGOT16_HA", /* name */
988 false, /* partial_inplace */
989 0, /* src_mask */
990 0xffff, /* dst_mask */
991 false), /* pcrel_offset */
992
993 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
994 HOWTO (R_PPC64_ADDR16_DS, /* type */
995 0, /* rightshift */
996 1, /* size (0 = byte, 1 = short, 2 = long) */
997 16, /* bitsize */
998 false, /* pc_relative */
999 0, /* bitpos */
1000 complain_overflow_bitfield, /* complain_on_overflow */
1001 bfd_elf_generic_reloc, /* special_function */
1002 "R_PPC64_ADDR16_DS", /* name */
1003 false, /* partial_inplace */
1004 0, /* src_mask */
1005 0xfffc, /* dst_mask */
1006 false), /* pcrel_offset */
1007
1008 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1009 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1010 0, /* rightshift */
1011 1, /* size (0 = byte, 1 = short, 2 = long) */
1012 16, /* bitsize */
1013 false, /* pc_relative */
1014 0, /* bitpos */
1015 complain_overflow_dont,/* complain_on_overflow */
1016 bfd_elf_generic_reloc, /* special_function */
1017 "R_PPC64_ADDR16_LO_DS",/* name */
1018 false, /* partial_inplace */
1019 0, /* src_mask */
1020 0xfffc, /* dst_mask */
1021 false), /* pcrel_offset */
1022
1023 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1024 HOWTO (R_PPC64_GOT16_DS, /* type */
1025 0, /* rightshift */
1026 1, /* size (0 = byte, 1 = short, 2 = long) */
1027 16, /* bitsize */
1028 false, /* pc_relative */
1029 0, /* bitpos */
1030 complain_overflow_signed, /* complain_on_overflow */
805fc799 1031 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169
AM		 1032 "R_PPC64_GOT16_DS", /* name */
1033 false, /* partial_inplace */
1034 0, /* src_mask */
1035 0xfffc, /* dst_mask */
1036 false), /* pcrel_offset */
1037
1038 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1039 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1040 0, /* 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 */
805fc799 1046 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169
AM		 1047 "R_PPC64_GOT16_LO_DS", /* name */
1048 false, /* partial_inplace */
1049 0, /* src_mask */
1050 0xfffc, /* dst_mask */
1051 false), /* pcrel_offset */
1052
1053 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1054 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1055 0, /* rightshift */
1056 1, /* size (0 = byte, 1 = short, 2 = long) */
1057 16, /* bitsize */
1058 false, /* pc_relative */
1059 0, /* bitpos */
1060 complain_overflow_dont, /* complain_on_overflow */
805fc799 1061 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169
AM		 1062 "R_PPC64_PLT16_LO_DS", /* name */
1063 false, /* partial_inplace */
1064 0, /* src_mask */
1065 0xfffc, /* dst_mask */
1066 false), /* pcrel_offset */
1067
1068 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
5bd4f169
AM		 1069 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1070 0, /* rightshift */
c061c2d8
AM		 1071 1, /* size (0 = byte, 1 = short, 2 = long) */
1072 16, /* bitsize */
805fc799 1073 false, /* pc_relative */
5bd4f169
AM		 1074 0, /* bitpos */
1075 complain_overflow_bitfield, /* complain_on_overflow */
805fc799 1076 ppc64_elf_sectoff_reloc, /* special_function */
5bd4f169
AM		 1077 "R_PPC64_SECTOFF_DS", /* name */
1078 false, /* partial_inplace */
1079 0, /* src_mask */
c061c2d8 1080 0xfffc, /* dst_mask */
805fc799 1081 false), /* pcrel_offset */
5bd4f169
AM		 1082
1083 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1084 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1085 0, /* rightshift */
1086 1, /* size (0 = byte, 1 = short, 2 = long) */
1087 16, /* bitsize */
1088 false, /* pc_relative */
1089 0, /* bitpos */
1090 complain_overflow_dont, /* complain_on_overflow */
805fc799 1091 ppc64_elf_sectoff_reloc, /* special_function */
5bd4f169
AM		 1092 "R_PPC64_SECTOFF_LO_DS",/* name */
1093 false, /* partial_inplace */
1094 0, /* src_mask */
1095 0xfffc, /* dst_mask */
1096 false), /* pcrel_offset */
1097
1098 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1099 HOWTO (R_PPC64_TOC16_DS, /* type */
1100 0, /* rightshift */
1101 1, /* size (0 = byte, 1 = short, 2 = long) */
1102 16, /* bitsize */
1103 false, /* pc_relative */
1104 0, /* bitpos */
1105 complain_overflow_signed, /* complain_on_overflow */
805fc799 1106 ppc64_elf_toc_reloc, /* special_function */
5bd4f169
AM		 1107 "R_PPC64_TOC16_DS", /* name */
1108 false, /* partial_inplace */
1109 0, /* src_mask */
1110 0xfffc, /* dst_mask */
1111 false), /* pcrel_offset */
1112
1113 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1114 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1115 0, /* rightshift */
1116 1, /* size (0 = byte, 1 = short, 2 = long) */
1117 16, /* bitsize */
1118 false, /* pc_relative */
1119 0, /* bitpos */
1120 complain_overflow_dont, /* complain_on_overflow */
805fc799 1121 ppc64_elf_toc_reloc, /* special_function */
5bd4f169
AM		 1122 "R_PPC64_TOC16_LO_DS", /* name */
1123 false, /* partial_inplace */
1124 0, /* src_mask */
1125 0xfffc, /* dst_mask */
1126 false), /* pcrel_offset */
1127
1128 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1129 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1130 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1131 0, /* rightshift */
1132 1, /* size (0 = byte, 1 = short, 2 = long) */
1133 16, /* bitsize */
1134 false, /* pc_relative */
1135 0, /* bitpos */
1136 complain_overflow_signed, /* complain_on_overflow */
805fc799 1137 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169
AM		 1138 "R_PPC64_PLTGOT16_DS", /* name */
1139 false, /* partial_inplace */
1140 0, /* src_mask */
1141 0xfffc, /* dst_mask */
1142 false), /* pcrel_offset */
1143
1144 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1145 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1146 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1147 0, /* rightshift */
1148 1, /* size (0 = byte, 1 = short, 2 = long) */
1149 16, /* bitsize */
1150 false, /* pc_relative */
1151 0, /* bitpos */
1152 complain_overflow_dont, /* complain_on_overflow */
805fc799 1153 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169
AM		 1154 "R_PPC64_PLTGOT16_LO_DS",/* name */
1155 false, /* partial_inplace */
1156 0, /* src_mask */
1157 0xfffc, /* dst_mask */
1158 false), /* pcrel_offset */
1159
1160 /* GNU extension to record C++ vtable hierarchy. */
1161 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
1162 0, /* rightshift */
1163 0, /* size (0 = byte, 1 = short, 2 = long) */
1164 0, /* bitsize */
1165 false, /* pc_relative */
1166 0, /* bitpos */
1167 complain_overflow_dont, /* complain_on_overflow */
1168 NULL, /* special_function */
1169 "R_PPC64_GNU_VTINHERIT", /* name */
1170 false, /* partial_inplace */
1171 0, /* src_mask */
1172 0, /* dst_mask */
1173 false), /* pcrel_offset */
1174
1175 /* GNU extension to record C++ vtable member usage. */
1176 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
1177 0, /* rightshift */
1178 0, /* size (0 = byte, 1 = short, 2 = long) */
1179 0, /* bitsize */
1180 false, /* pc_relative */
1181 0, /* bitpos */
1182 complain_overflow_dont, /* complain_on_overflow */
1183 NULL, /* special_function */
1184 "R_PPC64_GNU_VTENTRY", /* name */
1185 false, /* partial_inplace */
1186 0, /* src_mask */
1187 0, /* dst_mask */
1188 false), /* pcrel_offset */
1189};
1190
1191\f
1192/* Initialize the ppc64_elf_howto_table, so that linear accesses can
1193 be done. */
1194
1195static void
1196ppc_howto_init ()
1197{
1198 unsigned int i, type;
1199
1200 for (i = 0;
1201 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
1202 i++)
1203 {
1204 type = ppc64_elf_howto_raw[i].type;
1205 BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
1206 / sizeof (ppc64_elf_howto_table[0])));
1207 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
1208 }
1209}
1210
1211static reloc_howto_type *
1212ppc64_elf_reloc_type_lookup (abfd, code)
1213 bfd *abfd ATTRIBUTE_UNUSED;
1214 bfd_reloc_code_real_type code;
1215{
1216 enum elf_ppc_reloc_type ppc_reloc = R_PPC_NONE;
1217
1218 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
1219 /* Initialize howto table if needed. */
1220 ppc_howto_init ();
1221
1222 switch ((int) code)
1223 {
1224 default:
1225 return (reloc_howto_type *) NULL;
1226
1227 case BFD_RELOC_NONE: ppc_reloc = R_PPC64_NONE;
1228 break;
1229 case BFD_RELOC_32: ppc_reloc = R_PPC64_ADDR32;
1230 break;
1231 case BFD_RELOC_PPC_BA26: ppc_reloc = R_PPC64_ADDR24;
1232 break;
1233 case BFD_RELOC_16: ppc_reloc = R_PPC64_ADDR16;
1234 break;
1235 case BFD_RELOC_LO16: ppc_reloc = R_PPC64_ADDR16_LO;
1236 break;
1237 case BFD_RELOC_HI16: ppc_reloc = R_PPC64_ADDR16_HI;
1238 break;
1239 case BFD_RELOC_HI16_S: ppc_reloc = R_PPC64_ADDR16_HA;
1240 break;
1241 case BFD_RELOC_PPC_BA16: ppc_reloc = R_PPC64_ADDR14;
1242 break;
1243 case BFD_RELOC_PPC_BA16_BRTAKEN: ppc_reloc = R_PPC64_ADDR14_BRTAKEN;
1244 break;
1245 case BFD_RELOC_PPC_BA16_BRNTAKEN: ppc_reloc = R_PPC64_ADDR14_BRNTAKEN;
1246 break;
1247 case BFD_RELOC_PPC_B26: ppc_reloc = R_PPC64_REL24;
1248 break;
1249 case BFD_RELOC_PPC_B16: ppc_reloc = R_PPC64_REL14;
1250 break;
1251 case BFD_RELOC_PPC_B16_BRTAKEN: ppc_reloc = R_PPC64_REL14_BRTAKEN;
1252 break;
1253 case BFD_RELOC_PPC_B16_BRNTAKEN: ppc_reloc = R_PPC64_REL14_BRNTAKEN;
1254 break;
1255 case BFD_RELOC_16_GOTOFF: ppc_reloc = R_PPC64_GOT16;
1256 break;
1257 case BFD_RELOC_LO16_GOTOFF: ppc_reloc = R_PPC64_GOT16_LO;
1258 break;
1259 case BFD_RELOC_HI16_GOTOFF: ppc_reloc = R_PPC64_GOT16_HI;
1260 break;
1261 case BFD_RELOC_HI16_S_GOTOFF: ppc_reloc = R_PPC64_GOT16_HA;
1262 break;
1263 case BFD_RELOC_PPC_COPY: ppc_reloc = R_PPC64_COPY;
1264 break;
1265 case BFD_RELOC_PPC_GLOB_DAT: ppc_reloc = R_PPC64_GLOB_DAT;
1266 break;
1267 case BFD_RELOC_32_PCREL: ppc_reloc = R_PPC64_REL32;
1268 break;
1269 case BFD_RELOC_32_PLTOFF: ppc_reloc = R_PPC64_PLT32;
1270 break;
1271 case BFD_RELOC_32_PLT_PCREL: ppc_reloc = R_PPC64_PLTREL32;
1272 break;
1273 case BFD_RELOC_LO16_PLTOFF: ppc_reloc = R_PPC64_PLT16_LO;
1274 break;
1275 case BFD_RELOC_HI16_PLTOFF: ppc_reloc = R_PPC64_PLT16_HI;
1276 break;
1277 case BFD_RELOC_HI16_S_PLTOFF: ppc_reloc = R_PPC64_PLT16_HA;
1278 break;
c061c2d8 1279 case BFD_RELOC_16_BASEREL: ppc_reloc = R_PPC64_SECTOFF;
5bd4f169
AM		 1280 break;
1281 case BFD_RELOC_LO16_BASEREL: ppc_reloc = R_PPC64_SECTOFF_LO;
1282 break;
1283 case BFD_RELOC_HI16_BASEREL: ppc_reloc = R_PPC64_SECTOFF_HI;
1284 break;
1285 case BFD_RELOC_HI16_S_BASEREL: ppc_reloc = R_PPC64_SECTOFF_HA;
1286 break;
10ed1bba 1287 case BFD_RELOC_CTOR: ppc_reloc = R_PPC64_ADDR64;
5bd4f169
AM		 1288 break;
1289 case BFD_RELOC_64: ppc_reloc = R_PPC64_ADDR64;
1290 break;
1291 case BFD_RELOC_PPC64_HIGHER: ppc_reloc = R_PPC64_ADDR16_HIGHER;
1292 break;
1293 case BFD_RELOC_PPC64_HIGHER_S: ppc_reloc = R_PPC64_ADDR16_HIGHERA;
1294 break;
1295 case BFD_RELOC_PPC64_HIGHEST: ppc_reloc = R_PPC64_ADDR16_HIGHEST;
1296 break;
1297 case BFD_RELOC_PPC64_HIGHEST_S: ppc_reloc = R_PPC64_ADDR16_HIGHESTA;
1298 break;
1299 case BFD_RELOC_64_PCREL: ppc_reloc = R_PPC64_REL64;
1300 break;
1301 case BFD_RELOC_64_PLTOFF: ppc_reloc = R_PPC64_PLT64;
1302 break;
1303 case BFD_RELOC_64_PLT_PCREL: ppc_reloc = R_PPC64_PLTREL64;
1304 break;
1305 case BFD_RELOC_PPC_TOC16: ppc_reloc = R_PPC64_TOC16;
1306 break;
1307 case BFD_RELOC_PPC64_TOC16_LO: ppc_reloc = R_PPC64_TOC16_LO;
1308 break;
1309 case BFD_RELOC_PPC64_TOC16_HI: ppc_reloc = R_PPC64_TOC16_HI;
1310 break;
1311 case BFD_RELOC_PPC64_TOC16_HA: ppc_reloc = R_PPC64_TOC16_HA;
1312 break;
1313 case BFD_RELOC_PPC64_TOC: ppc_reloc = R_PPC64_TOC;
1314 break;
1315 case BFD_RELOC_PPC64_PLTGOT16: ppc_reloc = R_PPC64_PLTGOT16;
1316 break;
1317 case BFD_RELOC_PPC64_PLTGOT16_LO: ppc_reloc = R_PPC64_PLTGOT16_LO;
1318 break;
1319 case BFD_RELOC_PPC64_PLTGOT16_HI: ppc_reloc = R_PPC64_PLTGOT16_HI;
1320 break;
1321 case BFD_RELOC_PPC64_PLTGOT16_HA: ppc_reloc = R_PPC64_PLTGOT16_HA;
1322 break;
1323 case BFD_RELOC_PPC64_ADDR16_DS: ppc_reloc = R_PPC64_ADDR16_DS;
1324 break;
1325 case BFD_RELOC_PPC64_ADDR16_LO_DS: ppc_reloc = R_PPC64_ADDR16_LO_DS;
1326 break;
1327 case BFD_RELOC_PPC64_GOT16_DS: ppc_reloc = R_PPC64_GOT16_DS;
1328 break;
1329 case BFD_RELOC_PPC64_GOT16_LO_DS: ppc_reloc = R_PPC64_GOT16_LO_DS;
1330 break;
1331 case BFD_RELOC_PPC64_PLT16_LO_DS: ppc_reloc = R_PPC64_PLT16_LO_DS;
1332 break;
1333 case BFD_RELOC_PPC64_SECTOFF_DS: ppc_reloc = R_PPC64_SECTOFF_DS;
1334 break;
1335 case BFD_RELOC_PPC64_SECTOFF_LO_DS: ppc_reloc = R_PPC64_SECTOFF_LO_DS;
1336 break;
1337 case BFD_RELOC_PPC64_TOC16_DS: ppc_reloc = R_PPC64_TOC16_DS;
1338 break;
1339 case BFD_RELOC_PPC64_TOC16_LO_DS: ppc_reloc = R_PPC64_TOC16_LO_DS;
1340 break;
1341 case BFD_RELOC_PPC64_PLTGOT16_DS: ppc_reloc = R_PPC64_PLTGOT16_DS;
1342 break;
1343 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: ppc_reloc = R_PPC64_PLTGOT16_LO_DS;
1344 break;
1345 case BFD_RELOC_VTABLE_INHERIT: ppc_reloc = R_PPC64_GNU_VTINHERIT;
1346 break;
1347 case BFD_RELOC_VTABLE_ENTRY: ppc_reloc = R_PPC64_GNU_VTENTRY;
1348 break;
1349 }
1350
1351 return ppc64_elf_howto_table[(int) ppc_reloc];
1352};
1353
1354/* Set the howto pointer for a PowerPC ELF reloc. */
1355
1356static void
1357ppc64_elf_info_to_howto (abfd, cache_ptr, dst)
1358 bfd *abfd ATTRIBUTE_UNUSED;
1359 arelent *cache_ptr;
1360 Elf64_Internal_Rela *dst;
1361{
65f38f15
AM		 1362 unsigned int type;
1363
ef60b7ff 1364 /* Initialize howto table if needed. */
5bd4f169 1365 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5bd4f169
AM		 1366 ppc_howto_init ();
1367
65f38f15
AM		 1368 type = ELF64_R_TYPE (dst->r_info);
1369 BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
1370 / sizeof (ppc64_elf_howto_table[0])));
1371 cache_ptr->howto = ppc64_elf_howto_table[type];
5bd4f169
AM		 1372}
1373
65f38f15 1374/* Handle the R_PPC_ADDR16_HA and similar relocs. */
5bd4f169
AM		 1375
1376static bfd_reloc_status_type
805fc799
AM		 1377ppc64_elf_ha_reloc (abfd, reloc_entry, symbol, data,
1378 input_section, output_bfd, error_message)
1379 bfd *abfd;
5bd4f169
AM		 1380 arelent *reloc_entry;
1381 asymbol *symbol;
805fc799 1382 PTR data;
5bd4f169
AM		 1383 asection *input_section;
1384 bfd *output_bfd;
805fc799 1385 char **error_message;
5bd4f169 1386{
805fc799
AM		 1387 /* If this is a relocatable link (output_bfd test tells us), just
1388 call the generic function. Any adjustment will be done at final
1389 link time. */
1390 if (output_bfd != NULL)
1391 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1392 input_section, output_bfd, error_message);
1393
1394 /* Adjust the addend for sign extension of the low 16 bits.
1395 We won't actually be using the low 16 bits, so trashing them
1396 doesn't matter. */
1397 reloc_entry->addend += 0x8000;
1398 return bfd_reloc_continue;
1399}
5bd4f169 1400
805fc799
AM		 1401static bfd_reloc_status_type
1402ppc64_elf_brtaken_reloc (abfd, reloc_entry, symbol, data,
1403 input_section, output_bfd, error_message)
1404 bfd *abfd;
1405 arelent *reloc_entry;
1406 asymbol *symbol;
1407 PTR data;
1408 asection *input_section;
1409 bfd *output_bfd;
1410 char **error_message;
1411{
1412 long insn;
1413 enum elf_ppc_reloc_type r_type;
1414 bfd_size_type octets;
1415 /* Disabled until we sort out how ld should choose 'y' vs 'at'. */
1416 boolean is_power4 = false;
1417
1418 /* If this is a relocatable link (output_bfd test tells us), just
1419 call the generic function. Any adjustment will be done at final
1420 link time. */
5bd4f169 1421 if (output_bfd != NULL)
805fc799
AM		 1422 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1423 input_section, output_bfd, error_message);
1424
1425 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
1426 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
1427 insn &= ~(0x01 << 21);
1428 r_type = (enum elf_ppc_reloc_type) reloc_entry->howto->type;
1429 if (r_type == R_PPC64_ADDR14_BRTAKEN
1430 || r_type == R_PPC64_REL14_BRTAKEN)
1431 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
1432
1433 if (is_power4)
5bd4f169 1434 {
805fc799
AM		 1435 /* Set 'a' bit. This is 0b00010 in BO field for branch
1436 on CR(BI) insns (BO == 001at or 011at), and 0b01000
1437 for branch on CTR insns (BO == 1a00t or 1a01t). */
1438 if ((insn & (0x14 << 21)) == (0x04 << 21))
1439 insn |= 0x02 << 21;
1440 else if ((insn & (0x14 << 21)) == (0x10 << 21))
1441 insn |= 0x08 << 21;
1442 else
1443 return bfd_reloc_continue;
5bd4f169 1444 }
805fc799
AM		 1445 else
1446 {
1447 bfd_vma target = 0;
1448 bfd_vma from;
5bd4f169 1449
805fc799
AM		 1450 if (!bfd_is_com_section (symbol->section))
1451 target = symbol->value;
1452 target += symbol->section->output_section->vma;
1453 target += symbol->section->output_offset;
1454 target += reloc_entry->addend;
5bd4f169 1455
805fc799
AM		 1456 from = (reloc_entry->address
1457 + input_section->output_offset
1458 + input_section->output_section->vma);
5bd4f169 1459
805fc799
AM		 1460 /* Invert 'y' bit if not the default. */
1461 if ((bfd_signed_vma) (target - from) < 0)
1462 insn ^= 0x01 << 21;
1463 }
1464 bfd_put_32 (abfd, (bfd_vma) insn, (bfd_byte *) data + octets);
1465 return bfd_reloc_continue;
1466}
5bd4f169 1467
805fc799
AM		 1468static bfd_reloc_status_type
1469ppc64_elf_sectoff_reloc (abfd, reloc_entry, symbol, data,
1470 input_section, output_bfd, error_message)
1471 bfd *abfd;
1472 arelent *reloc_entry;
1473 asymbol *symbol;
1474 PTR data;
1475 asection *input_section;
1476 bfd *output_bfd;
1477 char **error_message;
1478{
1479 /* If this is a relocatable link (output_bfd test tells us), just
1480 call the generic function. Any adjustment will be done at final
1481 link time. */
1482 if (output_bfd != NULL)
1483 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1484 input_section, output_bfd, error_message);
5bd4f169 1485
805fc799
AM		 1486 /* Subtract the symbol section base address. */
1487 reloc_entry->addend -= symbol->section->output_section->vma;
5bd4f169
AM		 1488 return bfd_reloc_continue;
1489}
1490
805fc799
AM		 1491static bfd_reloc_status_type
1492ppc64_elf_sectoff_ha_reloc (abfd, reloc_entry, symbol, data,
1493 input_section, output_bfd, error_message)
1494 bfd *abfd;
1495 arelent *reloc_entry;
1496 asymbol *symbol;
1497 PTR data;
1498 asection *input_section;
1499 bfd *output_bfd;
1500 char **error_message;
1501{
1502 /* If this is a relocatable link (output_bfd test tells us), just
1503 call the generic function. Any adjustment will be done at final
1504 link time. */
1505 if (output_bfd != NULL)
1506 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1507 input_section, output_bfd, error_message);
1508
1509 /* Subtract the symbol section base address. */
1510 reloc_entry->addend -= symbol->section->output_section->vma;
1511
1512 /* Adjust the addend for sign extension of the low 16 bits. */
1513 reloc_entry->addend += 0x8000;
1514 return bfd_reloc_continue;
1515}
1516
1517static bfd_reloc_status_type
1518ppc64_elf_toc_reloc (abfd, reloc_entry, symbol, data,
1519 input_section, output_bfd, error_message)
1520 bfd *abfd;
1521 arelent *reloc_entry;
1522 asymbol *symbol;
1523 PTR data;
1524 asection *input_section;
1525 bfd *output_bfd;
1526 char **error_message;
1527{
1528 bfd_vma TOCstart;
1529
1530 /* If this is a relocatable link (output_bfd test tells us), just
1531 call the generic function. Any adjustment will be done at final
1532 link time. */
1533 if (output_bfd != NULL)
1534 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1535 input_section, output_bfd, error_message);
1536
1537 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
1538 if (TOCstart == 0)
1539 TOCstart = ppc64_elf_toc (input_section->output_section->owner);
1540
1541 /* Subtract the TOC base address. */
1542 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
1543 return bfd_reloc_continue;
1544}
1545
1546static bfd_reloc_status_type
1547ppc64_elf_toc_ha_reloc (abfd, reloc_entry, symbol, data,
1548 input_section, output_bfd, error_message)
1549 bfd *abfd;
1550 arelent *reloc_entry;
1551 asymbol *symbol;
1552 PTR data;
1553 asection *input_section;
1554 bfd *output_bfd;
1555 char **error_message;
1556{
1557 bfd_vma TOCstart;
1558
1559 /* If this is a relocatable link (output_bfd test tells us), just
1560 call the generic function. Any adjustment will be done at final
1561 link time. */
1562 if (output_bfd != NULL)
1563 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1564 input_section, output_bfd, error_message);
1565
1566 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
1567 if (TOCstart == 0)
1568 TOCstart = ppc64_elf_toc (input_section->output_section->owner);
1569
1570 /* Subtract the TOC base address. */
1571 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
1572
1573 /* Adjust the addend for sign extension of the low 16 bits. */
1574 reloc_entry->addend += 0x8000;
1575 return bfd_reloc_continue;
1576}
1577
1578static bfd_reloc_status_type
1579ppc64_elf_toc64_reloc (abfd, reloc_entry, symbol, data,
1580 input_section, output_bfd, error_message)
1581 bfd *abfd;
1582 arelent *reloc_entry;
1583 asymbol *symbol;
1584 PTR data;
1585 asection *input_section;
1586 bfd *output_bfd;
1587 char **error_message;
1588{
1589 bfd_vma TOCstart;
1590 bfd_size_type octets;
1591
1592 /* If this is a relocatable link (output_bfd test tells us), just
1593 call the generic function. Any adjustment will be done at final
1594 link time. */
1595 if (output_bfd != NULL)
1596 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1597 input_section, output_bfd, error_message);
1598
1599 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
1600 if (TOCstart == 0)
1601 TOCstart = ppc64_elf_toc (input_section->output_section->owner);
1602
1603 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
1604 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
1605 return bfd_reloc_ok;
1606}
1607
1608static bfd_reloc_status_type
1609ppc64_elf_unhandled_reloc (abfd, reloc_entry, symbol, data,
1610 input_section, output_bfd, error_message)
1611 bfd *abfd;
1612 arelent *reloc_entry;
1613 asymbol *symbol;
1614 PTR data;
1615 asection *input_section;
1616 bfd *output_bfd;
1617 char **error_message;
1618{
1619 /* If this is a relocatable link (output_bfd test tells us), just
1620 call the generic function. Any adjustment will be done at final
1621 link time. */
1622 if (output_bfd != NULL)
1623 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1624 input_section, output_bfd, error_message);
1625
1626 if (error_message != NULL)
1627 {
1628 static char buf[60];
1629 sprintf (buf, "generic linker can't handle %s",
1630 reloc_entry->howto->name);
1631 *error_message = buf;
1632 }
1633 return bfd_reloc_dangerous;
1634}
1635
7cdc5bba
AM		 1636/* Return symbol info as per usual for ELF targets, except that
1637 symbols in .opd are given 'd' or 'D' for type. */
1638
1639static void
1640ppc64_elf_get_symbol_info (abfd, symbol, ret)
1641 bfd *abfd;
1642 asymbol *symbol;
1643 symbol_info *ret;
1644{
1645 _bfd_elf_get_symbol_info (abfd, symbol, ret);
1646 if (ret->type == '?'
1647 && (symbol->flags & (BSF_GLOBAL | BSF_LOCAL)) != 0
1648 && strcmp (symbol->section->name, ".opd") == 0)
1649 ret->type = (symbol->flags & BSF_GLOBAL) != 0 ? 'D' : 'd';
1650}
1651
5bd4f169
AM		 1652/* Function to set whether a module needs the -mrelocatable bit set. */
1653
1654static boolean
1655ppc64_elf_set_private_flags (abfd, flags)
1656 bfd *abfd;
1657 flagword flags;
1658{
1659 BFD_ASSERT (!elf_flags_init (abfd)
1660 || elf_elfheader (abfd)->e_flags == flags);
1661
1662 elf_elfheader (abfd)->e_flags = flags;
1663 elf_flags_init (abfd) = true;
1664 return true;
1665}
1666
5bd4f169
AM		 1667/* Merge backend specific data from an object file to the output
1668 object file when linking. */
1669static boolean
1670ppc64_elf_merge_private_bfd_data (ibfd, obfd)
1671 bfd *ibfd;
1672 bfd *obfd;
1673{
1674 flagword old_flags;
1675 flagword new_flags;
1676 boolean error;
1677
1678 /* Check if we have the same endianess. */
1679 if (ibfd->xvec->byteorder != obfd->xvec->byteorder
1680 && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
1681 {
1682 const char *msg;
1683
1684 if (bfd_big_endian (ibfd))
1685 msg = _("%s: compiled for a big endian system and target is little endian");
1686 else
1687 msg = _("%s: compiled for a little endian system and target is big endian");
1688
8f615d07 1689 (*_bfd_error_handler) (msg, bfd_archive_filename (ibfd));
5bd4f169
AM		 1690
1691 bfd_set_error (bfd_error_wrong_format);
1692 return false;
1693 }
1694
1695 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1696 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1697 return true;
1698
1699 new_flags = elf_elfheader (ibfd)->e_flags;
1700 old_flags = elf_elfheader (obfd)->e_flags;
1701 if (!elf_flags_init (obfd))
1702 {
1703 /* First call, no flags set. */
1704 elf_flags_init (obfd) = true;
1705 elf_elfheader (obfd)->e_flags = new_flags;
1706 }
1707
1708 else if (new_flags == old_flags)
1709 /* Compatible flags are ok. */
1710 ;
1711
1712 else
1713 {
1714 /* Incompatible flags. Warn about -mrelocatable mismatch.
1715 Allow -mrelocatable-lib to be linked with either. */
1716 error = false;
1717 if ((new_flags & EF_PPC_RELOCATABLE) != 0
1718 && (old_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0)
1719 {
1720 error = true;
1721 (*_bfd_error_handler)
1722 (_("%s: compiled with -mrelocatable and linked with modules compiled normally"),
8f615d07 1723 bfd_archive_filename (ibfd));
5bd4f169
AM		 1724 }
1725 else if ((new_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0
1726 && (old_flags & EF_PPC_RELOCATABLE) != 0)
1727 {
1728 error = true;
1729 (*_bfd_error_handler)
1730 (_("%s: compiled normally and linked with modules compiled with -mrelocatable"),
8f615d07 1731 bfd_archive_filename (ibfd));
5bd4f169
AM		 1732 }
1733
1734 /* The output is -mrelocatable-lib iff both the input files are. */
1735 if (! (new_flags & EF_PPC_RELOCATABLE_LIB))
1736 elf_elfheader (obfd)->e_flags &= ~EF_PPC_RELOCATABLE_LIB;
1737
1738 /* The output is -mrelocatable iff it can't be -mrelocatable-lib,
1739 but each input file is either -mrelocatable or -mrelocatable-lib. */
1740 if (! (elf_elfheader (obfd)->e_flags & EF_PPC_RELOCATABLE_LIB)
1741 && (new_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE))
1742 && (old_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE)))
1743 elf_elfheader (obfd)->e_flags |= EF_PPC_RELOCATABLE;
1744
1745 /* Do not warn about eabi vs. V.4 mismatch, just or in the bit
1746 if any module uses it. */
1747 elf_elfheader (obfd)->e_flags |= (new_flags & EF_PPC_EMB);
1748
1749 new_flags &= ~(EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB);
1750 old_flags &= ~(EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB);
1751
1752 /* Warn about any other mismatches. */
1753 if (new_flags != old_flags)
1754 {
1755 error = true;
1756 (*_bfd_error_handler)
1757 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
8f615d07 1758 bfd_archive_filename (ibfd), (long) new_flags, (long) old_flags);
5bd4f169
AM		 1759 }
1760
1761 if (error)
1762 {
1763 bfd_set_error (bfd_error_bad_value);
1764 return false;
1765 }
1766 }
1767
1768 return true;
1769}
1770
1771/* Handle a PowerPC specific section when reading an object file. This
1772 is called when elfcode.h finds a section with an unknown type. */
1773
1774static boolean
1775ppc64_elf_section_from_shdr (abfd, hdr, name)
1776 bfd *abfd;
1777 Elf64_Internal_Shdr *hdr;
1778 char *name;
1779{
1780 asection *newsect;
1781 flagword flags;
1782
1783 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1784 return false;
1785
1786 newsect = hdr->bfd_section;
1787 flags = bfd_get_section_flags (abfd, newsect);
1788 if (hdr->sh_flags & SHF_EXCLUDE)
1789 flags |= SEC_EXCLUDE;
1790
1791 if (hdr->sh_type == SHT_ORDERED)
1792 flags |= SEC_SORT_ENTRIES;
1793
1794 bfd_set_section_flags (abfd, newsect, flags);
1795 return true;
1796}
1797\f
65f38f15
AM		 1798/* The following functions are specific to the ELF linker, while
1799 functions above are used generally. Those named ppc64_elf_* are
1800 called by the main ELF linker code. They appear in this file more
1801 or less in the order in which they are called. eg.
1802 ppc64_elf_check_relocs is called early in the link process,
1803 ppc64_elf_finish_dynamic_sections is one of the last functions
e86ce104
AM		 1804 called.
1805
1806 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
1807 functions have both a function code symbol and a function descriptor
1808 symbol. A call to foo in a relocatable object file looks like:
1809
1810 . .text
1811 . x:
1812 . bl .foo
1813 . nop
1814
1815 The function definition in another object file might be:
1816
1817 . .section .opd
1818 . foo: .quad .foo
1819 . .quad .TOC.@tocbase
1820 . .quad 0
1821 .
1822 . .text
1823 . .foo: blr
1824
1825 When the linker resolves the call during a static link, the branch
1826 unsurprisingly just goes to .foo and the .opd information is unused.
1827 If the function definition is in a shared library, things are a little
1828 different: The call goes via a plt call stub, the opd information gets
1829 copied to the plt, and the linker patches the nop.
1830
1831 . x:
1832 . bl .foo_stub
1833 . ld 2,40(1)
1834 .
1835 .
1836 . .foo_stub:
1837 . addis 12,2,Lfoo@toc@ha # in practice, the call stub
1838 . addi 12,12,Lfoo@toc@l # is slightly optimised, but
1839 . std 2,40(1) # this is the general idea
1840 . ld 11,0(12)
1841 . ld 2,8(12)
1842 . mtctr 11
1843 . ld 11,16(12)
1844 . bctr
1845 .
1846 . .section .plt
1847 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
1848
1849 The "reloc ()" notation is supposed to indicate that the linker emits
1850 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
1851 copying.
1852
1853 What are the difficulties here? Well, firstly, the relocations
1854 examined by the linker in check_relocs are against the function code
1855 sym .foo, while the dynamic relocation in the plt is emitted against
1856 the function descriptor symbol, foo. Somewhere along the line, we need
1857 to carefully copy dynamic link information from one symbol to the other.
1858 Secondly, the generic part of the elf linker will make .foo a dynamic
1859 symbol as is normal for most other backends. We need foo dynamic
1860 instead, at least for an application final link. However, when
1861 creating a shared library containing foo, we need to have both symbols
1862 dynamic so that references to .foo are satisfied during the early
1863 stages of linking. Otherwise the linker might decide to pull in a
41bd81ab 1864 definition from some other object, eg. a static library. */
65f38f15
AM		 1865
1866/* The linker needs to keep track of the number of relocs that it
1867 decides to copy as dynamic relocs in check_relocs for each symbol.
1868 This is so that it can later discard them if they are found to be
1869 unnecessary. We store the information in a field extending the
1870 regular ELF linker hash table. */
1871
1872struct ppc_dyn_relocs
1873{
1874 struct ppc_dyn_relocs *next;
1875
1876 /* The input section of the reloc. */
1877 asection *sec;
1878
1879 /* Total number of relocs copied for the input section. */
1880 bfd_size_type count;
1881
1882 /* Number of pc-relative relocs copied for the input section. */
1883 bfd_size_type pc_count;
1884};
1885
1886/* Of those relocs that might be copied as dynamic relocs, this macro
1887 selects between relative and absolute types. */
1888
1889#define IS_ABSOLUTE_RELOC(RTYPE) \
805fc799
AM		 1890 ((RTYPE) != R_PPC64_REL32 \
1891 && (RTYPE) != R_PPC64_REL64 \
1892 && (RTYPE) != R_PPC64_ADDR30)
65f38f15 1893
721956f4
AM		 1894/* Section name for stubs is the associated section name plus this
1895 string. */
1896#define STUB_SUFFIX ".stub"
1897
1898/* Linker stubs.
1899 ppc_stub_long_branch:
1900 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
1901 destination, but a 24 bit branch in a stub section will reach.
1902 . b dest
1903
1904 ppc_stub_plt_branch:
1905 Similar to the above, but a 24 bit branch in the stub section won't
1906 reach its destination.
1907 . addis %r12,%r2,xxx@ha
1908 . ld %r11,xxx@l(%r12)
1909 . mtctr %r11
1910 . bctr
1911
1912 ppc_stub_plt_call:
1913 Used to call a function in a shared library.
1914 . addis %r12,%r2,xxx@ha
1915 . std %r2,40(%r1)
1916 . ld %r11,xxx+0@l(%r12)
1917 . ld %r2,xxx+8@l(%r12)
1918 . mtctr %r11
1919 . ld %r11,xxx+16@l(%r12)
1920 . bctr
1921*/
1922
1923enum ppc_stub_type {
1924 ppc_stub_none,
1925 ppc_stub_long_branch,
1926 ppc_stub_plt_branch,
1927 ppc_stub_plt_call
1928};
1929
1930struct ppc_stub_hash_entry {
1931
1932 /* Base hash table entry structure. */
1933 struct bfd_hash_entry root;
1934
1935 /* The stub section. */
1936 asection *stub_sec;
1937
1938 /* Offset within stub_sec of the beginning of this stub. */
1939 bfd_vma stub_offset;
1940
1941 /* Given the symbol's value and its section we can determine its final
1942 value when building the stubs (so the stub knows where to jump. */
1943 bfd_vma target_value;
1944 asection *target_section;
1945
1946 enum ppc_stub_type stub_type;
1947
1948 /* The symbol table entry, if any, that this was derived from. */
1949 struct ppc_link_hash_entry *h;
1950
1951 /* Where this stub is being called from, or, in the case of combined
1952 stub sections, the first input section in the group. */
1953 asection *id_sec;
1954};
1955
1956struct ppc_branch_hash_entry {
1957
1958 /* Base hash table entry structure. */
1959 struct bfd_hash_entry root;
1960
1961 /* Offset within .branch_lt. */
1962 unsigned int offset;
1963
1964 /* Generation marker. */
1965 unsigned int iter;
1966};
65f38f15
AM		 1967
1968struct ppc_link_hash_entry
1969{
1970 struct elf_link_hash_entry elf;
1971
721956f4
AM		 1972 /* A pointer to the most recently used stub hash entry against this
1973 symbol. */
1974 struct ppc_stub_hash_entry *stub_cache;
1975
65f38f15
AM		 1976 /* Track dynamic relocs copied for this symbol. */
1977 struct ppc_dyn_relocs *dyn_relocs;
e86ce104 1978
721956f4
AM		 1979 /* Link between function code and descriptor symbols. */
1980 struct elf_link_hash_entry *oh;
1981
e86ce104
AM		 1982 /* Flag function code and descriptor symbols. */
1983 unsigned int is_func:1;
1984 unsigned int is_func_descriptor:1;
65f38f15
AM		 1985};
1986
1987/* ppc64 ELF linker hash table. */
1988
1989struct ppc_link_hash_table
1990{
1991 struct elf_link_hash_table elf;
1992
721956f4
AM		 1993 /* The stub hash table. */
1994 struct bfd_hash_table stub_hash_table;
1995
1996 /* Another hash table for plt_branch stubs. */
1997 struct bfd_hash_table branch_hash_table;
1998
1999 /* Linker stub bfd. */
2000 bfd *stub_bfd;
2001
2002 /* Linker call-backs. */
2003 asection * (*add_stub_section) PARAMS ((const char *, asection *));
2004 void (*layout_sections_again) PARAMS ((void));
2005
2006 /* Array to keep track of which stub sections have been created, and
2007 information on stub grouping. */
2008 struct map_stub {
2009 /* This is the section to which stubs in the group will be attached. */
2010 asection *link_sec;
2011 /* The stub section. */
2012 asection *stub_sec;
2013 } *stub_group;
2014
2015 /* Assorted information used by ppc64_elf_size_stubs. */
2016 unsigned int bfd_count;
2017 int top_index;
2018 asection **input_list;
2019 Elf_Internal_Sym **all_local_syms;
2020
65f38f15
AM		 2021 /* Short-cuts to get to dynamic linker sections. */
2022 asection *sgot;
2023 asection *srelgot;
2024 asection *splt;
2025 asection *srelplt;
2026 asection *sdynbss;
2027 asection *srelbss;
2028 asection *sglink;
82bd7b59 2029 asection *sfpr;
721956f4
AM		 2030 asection *sbrlt;
2031 asection *srelbrlt;
ec338859 2032
5d1634d7 2033 /* Set on error. */
721956f4
AM		 2034 unsigned int stub_error;
2035
2036 /* Flag set when small branches are detected. Used to
2037 select suitable defaults for the stub group size. */
2038 unsigned int has_14bit_branch;
2039
805fc799
AM		 2040 /* Set if we detect a reference undefined weak symbol. */
2041 unsigned int have_undefweak;
2042
721956f4
AM		 2043 /* Incremented every time we size stubs. */
2044 unsigned int stub_iteration;
5d1634d7 2045
ec338859
AM		 2046 /* Small local sym to section mapping cache. */
2047 struct sym_sec_cache sym_sec;
65f38f15
AM		 2048};
2049
721956f4
AM		 2050static struct bfd_hash_entry *stub_hash_newfunc
2051 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
2052static struct bfd_hash_entry *branch_hash_newfunc
2053 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
2054static struct bfd_hash_entry *link_hash_newfunc
2055 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
2056static struct bfd_link_hash_table *ppc64_elf_link_hash_table_create
2057 PARAMS ((bfd *));
2058static void ppc64_elf_link_hash_table_free
2059 PARAMS ((struct bfd_link_hash_table *));
2060static char *ppc_stub_name
2061 PARAMS ((const asection *, const asection *,
2062 const struct ppc_link_hash_entry *, const Elf_Internal_Rela *));
2063static struct ppc_stub_hash_entry *ppc_get_stub_entry
2064 PARAMS ((const asection *, const asection *, struct elf_link_hash_entry *,
2065 const Elf_Internal_Rela *, struct ppc_link_hash_table *));
2066static struct ppc_stub_hash_entry *ppc_add_stub
2067 PARAMS ((const char *, asection *, struct ppc_link_hash_table *));
2068static boolean create_linkage_sections
2069 PARAMS ((bfd *, struct bfd_link_info *));
2070static boolean create_got_section
2071 PARAMS ((bfd *, struct bfd_link_info *));
2072static boolean ppc64_elf_create_dynamic_sections
2073 PARAMS ((bfd *, struct bfd_link_info *));
2074static void ppc64_elf_copy_indirect_symbol
2075 PARAMS ((struct elf_link_hash_entry *, struct elf_link_hash_entry *));
2076static boolean ppc64_elf_check_relocs
2077 PARAMS ((bfd *, struct bfd_link_info *, asection *,
2078 const Elf_Internal_Rela *));
2079static asection * ppc64_elf_gc_mark_hook
2080 PARAMS ((bfd *abfd, struct bfd_link_info *info, Elf_Internal_Rela *rel,
2081 struct elf_link_hash_entry *h, Elf_Internal_Sym *sym));
2082static boolean ppc64_elf_gc_sweep_hook
2083 PARAMS ((bfd *abfd, struct bfd_link_info *info, asection *sec,
2084 const Elf_Internal_Rela *relocs));
2085static boolean func_desc_adjust
2086 PARAMS ((struct elf_link_hash_entry *, PTR));
2087static boolean ppc64_elf_func_desc_adjust
2088 PARAMS ((bfd *, struct bfd_link_info *));
2089static boolean ppc64_elf_adjust_dynamic_symbol
2090 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
2091static void ppc64_elf_hide_symbol
2092 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *, boolean));
2093static boolean allocate_dynrelocs
2094 PARAMS ((struct elf_link_hash_entry *, PTR));
2095static boolean readonly_dynrelocs
2096 PARAMS ((struct elf_link_hash_entry *, PTR));
2097static enum elf_reloc_type_class ppc64_elf_reloc_type_class
2098 PARAMS ((const Elf_Internal_Rela *));
2099static boolean ppc64_elf_size_dynamic_sections
2100 PARAMS ((bfd *, struct bfd_link_info *));
2101static INLINE enum ppc_stub_type ppc_type_of_stub
2102 PARAMS ((asection *, const Elf_Internal_Rela *,
2103 struct ppc_link_hash_entry **, bfd_vma));
2104static bfd_byte *build_plt_stub
2105 PARAMS ((bfd *, bfd_byte *, int, int));
2106static boolean ppc_build_one_stub
2107 PARAMS ((struct bfd_hash_entry *, PTR));
2108static boolean ppc_size_one_stub
2109 PARAMS ((struct bfd_hash_entry *, PTR));
2110static void group_sections
2111 PARAMS ((struct ppc_link_hash_table *, bfd_size_type, boolean));
2112static boolean get_local_syms
2113 PARAMS ((bfd *, struct ppc_link_hash_table *));
2114static boolean ppc64_elf_fake_sections
2115 PARAMS ((bfd *, Elf64_Internal_Shdr *, asection *));
2116static boolean ppc64_elf_relocate_section
2117 PARAMS ((bfd *, struct bfd_link_info *info, bfd *, asection *, bfd_byte *,
2118 Elf_Internal_Rela *relocs, Elf_Internal_Sym *local_syms,
2119 asection **));
2120static boolean ppc64_elf_finish_dynamic_symbol
2121 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
2122 Elf_Internal_Sym *));
2123static boolean ppc64_elf_finish_dynamic_sections
2124 PARAMS ((bfd *, struct bfd_link_info *));
2125
65f38f15
AM		 2126/* Get the ppc64 ELF linker hash table from a link_info structure. */
2127
2128#define ppc_hash_table(p) \
2129 ((struct ppc_link_hash_table *) ((p)->hash))
2130
721956f4
AM		 2131#define ppc_stub_hash_lookup(table, string, create, copy) \
2132 ((struct ppc_stub_hash_entry *) \
2133 bfd_hash_lookup ((table), (string), (create), (copy)))
2134
2135#define ppc_branch_hash_lookup(table, string, create, copy) \
2136 ((struct ppc_branch_hash_entry *) \
2137 bfd_hash_lookup ((table), (string), (create), (copy)))
2138
2139/* Create an entry in the stub hash table. */
2140
2141static struct bfd_hash_entry *
2142stub_hash_newfunc (entry, table, string)
2143 struct bfd_hash_entry *entry;
2144 struct bfd_hash_table *table;
2145 const char *string;
2146{
2147 /* Allocate the structure if it has not already been allocated by a
2148 subclass. */
2149 if (entry == NULL)
2150 {
2151 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
2152 if (entry == NULL)
2153 return entry;
2154 }
2155
2156 /* Call the allocation method of the superclass. */
2157 entry = bfd_hash_newfunc (entry, table, string);
2158 if (entry != NULL)
2159 {
2160 struct ppc_stub_hash_entry *eh;
2161
2162 /* Initialize the local fields. */
2163 eh = (struct ppc_stub_hash_entry *) entry;
2164 eh->stub_sec = NULL;
2165 eh->stub_offset = 0;
2166 eh->target_value = 0;
2167 eh->target_section = NULL;
2168 eh->stub_type = ppc_stub_none;
2169 eh->h = NULL;
2170 eh->id_sec = NULL;
2171 }
2172
2173 return entry;
2174}
2175
2176/* Create an entry in the branch hash table. */
2177
2178static struct bfd_hash_entry *
2179branch_hash_newfunc (entry, table, string)
2180 struct bfd_hash_entry *entry;
2181 struct bfd_hash_table *table;
2182 const char *string;
2183{
2184 /* Allocate the structure if it has not already been allocated by a
2185 subclass. */
2186 if (entry == NULL)
2187 {
2188 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
2189 if (entry == NULL)
2190 return entry;
2191 }
2192
2193 /* Call the allocation method of the superclass. */
2194 entry = bfd_hash_newfunc (entry, table, string);
2195 if (entry != NULL)
2196 {
2197 struct ppc_branch_hash_entry *eh;
2198
2199 /* Initialize the local fields. */
2200 eh = (struct ppc_branch_hash_entry *) entry;
2201 eh->offset = 0;
2202 eh->iter = 0;
2203 }
2204
2205 return entry;
2206}
2207
65f38f15
AM		 2208/* Create an entry in a ppc64 ELF linker hash table. */
2209
2210static struct bfd_hash_entry *
2211link_hash_newfunc (entry, table, string)
2212 struct bfd_hash_entry *entry;
2213 struct bfd_hash_table *table;
2214 const char *string;
2215{
2216 /* Allocate the structure if it has not already been allocated by a
2217 subclass. */
2218 if (entry == NULL)
2219 {
2220 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
2221 if (entry == NULL)
2222 return entry;
2223 }
2224
2225 /* Call the allocation method of the superclass. */
2226 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
2227 if (entry != NULL)
2228 {
2229 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
2230
721956f4 2231 eh->stub_cache = NULL;
65f38f15 2232 eh->dyn_relocs = NULL;
721956f4 2233 eh->oh = NULL;
e86ce104
AM		 2234 eh->is_func = 0;
2235 eh->is_func_descriptor = 0;
65f38f15
AM		 2236 }
2237
2238 return entry;
2239}
2240
2241/* Create a ppc64 ELF linker hash table. */
2242
2243static struct bfd_link_hash_table *
2244ppc64_elf_link_hash_table_create (abfd)
2245 bfd *abfd;
2246{
2247 struct ppc_link_hash_table *htab;
2248 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
2249
e2d34d7d 2250 htab = (struct ppc_link_hash_table *) bfd_malloc (amt);
65f38f15
AM		 2251 if (htab == NULL)
2252 return NULL;
2253
2254 if (! _bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc))
2255 {
e2d34d7d 2256 free (htab);
65f38f15
AM		 2257 return NULL;
2258 }
2259
721956f4
AM		 2260 /* Init the stub hash table too. */
2261 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc))
2262 return NULL;
2263
2264 /* And the branch hash table. */
2265 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc))
2266 return NULL;
2267
2268 htab->stub_bfd = NULL;
2269 htab->add_stub_section = NULL;
2270 htab->layout_sections_again = NULL;
2271 htab->stub_group = NULL;
65f38f15
AM		 2272 htab->sgot = NULL;
2273 htab->srelgot = NULL;
2274 htab->splt = NULL;
2275 htab->srelplt = NULL;
2276 htab->sdynbss = NULL;
2277 htab->srelbss = NULL;
2278 htab->sglink = NULL;
82bd7b59 2279 htab->sfpr = NULL;
721956f4
AM		 2280 htab->sbrlt = NULL;
2281 htab->srelbrlt = NULL;
2282 htab->stub_error = 0;
2283 htab->has_14bit_branch = 0;
805fc799 2284 htab->have_undefweak = 0;
721956f4 2285 htab->stub_iteration = 0;
ec338859 2286 htab->sym_sec.abfd = NULL;
65f38f15
AM		 2287
2288 return &htab->elf.root;
2289}
2290
721956f4
AM		 2291/* Free the derived linker hash table. */
2292
2293static void
2294ppc64_elf_link_hash_table_free (hash)
2295 struct bfd_link_hash_table *hash;
2296{
2297 struct ppc_link_hash_table *ret = (struct ppc_link_hash_table *) hash;
2298
2299 bfd_hash_table_free (&ret->stub_hash_table);
2300 bfd_hash_table_free (&ret->branch_hash_table);
2301 _bfd_generic_link_hash_table_free (hash);
2302}
2303
2304/* Build a name for an entry in the stub hash table. */
2305
2306static char *
2307ppc_stub_name (input_section, sym_sec, h, rel)
2308 const asection *input_section;
2309 const asection *sym_sec;
2310 const struct ppc_link_hash_entry *h;
2311 const Elf_Internal_Rela *rel;
2312{
2313 char *stub_name;
2314 bfd_size_type len;
2315
2316 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
2317 offsets from a sym as a branch target? In fact, we could
2318 probably assume the addend is always zero. */
2319 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
2320
2321 if (h)
2322 {
2323 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
2324 stub_name = bfd_malloc (len);
2325 if (stub_name != NULL)
2326 {
2327 sprintf (stub_name, "%08x_%s+%x",
2328 input_section->id & 0xffffffff,
2329 h->elf.root.root.string,
2330 (int) rel->r_addend & 0xffffffff);
2331 }
2332 }
2333 else
2334 {
2335 len = 8 + 1 + 8 + 1 + 8 + 1 + 16 + 1;
2336 stub_name = bfd_malloc (len);
2337 if (stub_name != NULL)
2338 {
2339 sprintf (stub_name, "%08x_%x:%x+%x",
2340 input_section->id & 0xffffffff,
2341 sym_sec->id & 0xffffffff,
2342 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
2343 (int) rel->r_addend & 0xffffffff);
2344 }
2345 }
2346 return stub_name;
2347}
2348
2349/* Look up an entry in the stub hash. Stub entries are cached because
2350 creating the stub name takes a bit of time. */
2351
2352static struct ppc_stub_hash_entry *
2353ppc_get_stub_entry (input_section, sym_sec, hash, rel, htab)
2354 const asection *input_section;
2355 const asection *sym_sec;
2356 struct elf_link_hash_entry *hash;
2357 const Elf_Internal_Rela *rel;
2358 struct ppc_link_hash_table *htab;
2359{
2360 struct ppc_stub_hash_entry *stub_entry;
2361 struct ppc_link_hash_entry *h = (struct ppc_link_hash_entry *) hash;
2362 const asection *id_sec;
2363
2364 /* If this input section is part of a group of sections sharing one
2365 stub section, then use the id of the first section in the group.
2366 Stub names need to include a section id, as there may well be
2367 more than one stub used to reach say, printf, and we need to
2368 distinguish between them. */
2369 id_sec = htab->stub_group[input_section->id].link_sec;
2370
2371 if (h != NULL && h->stub_cache != NULL
2372 && h->stub_cache->h == h
2373 && h->stub_cache->id_sec == id_sec)
2374 {
2375 stub_entry = h->stub_cache;
2376 }
2377 else
2378 {
2379 char *stub_name;
2380
2381 stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
2382 if (stub_name == NULL)
2383 return NULL;
2384
2385 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
2386 stub_name, false, false);
2387 if (h != NULL)
2388 h->stub_cache = stub_entry;
2389
2390 free (stub_name);
2391 }
2392
2393 return stub_entry;
2394}
2395
2396/* Add a new stub entry to the stub hash. Not all fields of the new
2397 stub entry are initialised. */
2398
2399static struct ppc_stub_hash_entry *
2400ppc_add_stub (stub_name, section, htab)
2401 const char *stub_name;
2402 asection *section;
2403 struct ppc_link_hash_table *htab;
2404{
2405 asection *link_sec;
2406 asection *stub_sec;
2407 struct ppc_stub_hash_entry *stub_entry;
2408
2409 link_sec = htab->stub_group[section->id].link_sec;
2410 stub_sec = htab->stub_group[section->id].stub_sec;
2411 if (stub_sec == NULL)
2412 {
2413 stub_sec = htab->stub_group[link_sec->id].stub_sec;
2414 if (stub_sec == NULL)
2415 {
2416 bfd_size_type len;
2417 char *s_name;
2418
2419 len = strlen (link_sec->name) + sizeof (STUB_SUFFIX);
2420 s_name = bfd_alloc (htab->stub_bfd, len);
2421 if (s_name == NULL)
2422 return NULL;
2423
2424 strcpy (s_name, link_sec->name);
2425 strcpy (s_name + len - sizeof (STUB_SUFFIX), STUB_SUFFIX);
2426 stub_sec = (*htab->add_stub_section) (s_name, link_sec);
2427 if (stub_sec == NULL)
2428 return NULL;
2429 htab->stub_group[link_sec->id].stub_sec = stub_sec;
2430 }
2431 htab->stub_group[section->id].stub_sec = stub_sec;
2432 }
2433
2434 /* Enter this entry into the linker stub hash table. */
2435 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
2436 true, false);
2437 if (stub_entry == NULL)
2438 {
2439 (*_bfd_error_handler) (_("%s: cannot create stub entry %s"),
2440 bfd_archive_filename (section->owner),
2441 stub_name);
2442 return NULL;
2443 }
2444
2445 stub_entry->stub_sec = stub_sec;
2446 stub_entry->stub_offset = 0;
2447 stub_entry->id_sec = link_sec;
2448 return stub_entry;
2449}
2450
82bd7b59
AM		 2451/* Create sections for linker generated code. */
2452
2453static boolean
2454create_linkage_sections (dynobj, info)
2455 bfd *dynobj;
2456 struct bfd_link_info *info;
2457{
2458 struct ppc_link_hash_table *htab;
2459 flagword flags;
2460
2461 htab = ppc_hash_table (info);
2462
2463 /* Create .sfpr for code to save and restore fp regs. */
2464 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
2465 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
721956f4 2466 htab->sfpr = bfd_make_section_anyway (dynobj, ".sfpr");
82bd7b59
AM		 2467 if (htab->sfpr == NULL
2468 || ! bfd_set_section_flags (dynobj, htab->sfpr, flags)
2469 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
2470 return false;
2471
721956f4
AM		 2472 /* Create .glink for lazy dynamic linking support. */
2473 htab->sglink = bfd_make_section_anyway (dynobj, ".glink");
82bd7b59
AM		 2474 if (htab->sglink == NULL
2475 || ! bfd_set_section_flags (dynobj, htab->sglink, flags)
2476 || ! bfd_set_section_alignment (dynobj, htab->sglink, 2))
2477 return false;
2478
721956f4
AM		 2479 /* Create .branch_lt for plt_branch stubs. */
2480 flags = (SEC_ALLOC | SEC_LOAD
2481 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2482 htab->sbrlt = bfd_make_section_anyway (dynobj, ".branch_lt");
2483 if (htab->sbrlt == NULL
2484 || ! bfd_set_section_flags (dynobj, htab->sbrlt, flags)
2485 || ! bfd_set_section_alignment (dynobj, htab->sbrlt, 3))
2486 return false;
2487
2488 if (info->shared)
2489 {
2490 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
2491 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2492 htab->srelbrlt = bfd_make_section (dynobj, ".rela.branch_lt");
2493 if (!htab->srelbrlt
2494 || ! bfd_set_section_flags (dynobj, htab->srelbrlt, flags)
2495 || ! bfd_set_section_alignment (dynobj, htab->srelbrlt, 3))
2496 return false;
2497 }
82bd7b59
AM		 2498 return true;
2499}
2500
65f38f15
AM		 2501/* Create .got and .rela.got sections in DYNOBJ, and set up
2502 shortcuts to them in our hash table. */
2503
2504static boolean
2505create_got_section (dynobj, info)
2506 bfd *dynobj;
2507 struct bfd_link_info *info;
2508{
2509 struct ppc_link_hash_table *htab;
2510
2511 if (! _bfd_elf_create_got_section (dynobj, info))
2512 return false;
2513
2514 htab = ppc_hash_table (info);
2515 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
2516 if (!htab->sgot)
2517 abort ();
2518
2519 htab->srelgot = bfd_make_section (dynobj, ".rela.got");
2520 if (!htab->srelgot
2521 || ! bfd_set_section_flags (dynobj, htab->srelgot,
2522 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
2523 | SEC_IN_MEMORY | SEC_LINKER_CREATED
2524 | SEC_READONLY))
2525 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 3))
2526 return false;
2527 return true;
2528}
5bd4f169 2529
82bd7b59 2530/* Create the dynamic sections, and set up shortcuts. */
5bd4f169
AM		 2531
2532static boolean
65f38f15
AM		 2533ppc64_elf_create_dynamic_sections (dynobj, info)
2534 bfd *dynobj;
5bd4f169
AM		 2535 struct bfd_link_info *info;
2536{
65f38f15 2537 struct ppc_link_hash_table *htab;
5bd4f169 2538
65f38f15
AM		 2539 htab = ppc_hash_table (info);
2540 if (!htab->sgot && !create_got_section (dynobj, info))
5bd4f169
AM		 2541 return false;
2542
65f38f15 2543 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
5bd4f169 2544 return false;
65f38f15
AM		 2545
2546 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
2547 htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
2548 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
2549 if (!info->shared)
2550 htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
2551
2552 if (!htab->splt || !htab->srelplt || !htab->sdynbss
2553 || (!info->shared && !htab->srelbss))
2554 abort ();
2555
5bd4f169
AM		 2556 return true;
2557}
2558
65f38f15
AM		 2559/* Copy the extra info we tack onto an elf_link_hash_entry. */
2560
2561static void
2562ppc64_elf_copy_indirect_symbol (dir, ind)
2563 struct elf_link_hash_entry *dir, *ind;
2564{
2565 struct ppc_link_hash_entry *edir, *eind;
2566
2567 edir = (struct ppc_link_hash_entry *) dir;
2568 eind = (struct ppc_link_hash_entry *) ind;
2569
bbd7ec4a 2570 if (eind->dyn_relocs != NULL)
65f38f15 2571 {
bbd7ec4a
AM		 2572 if (edir->dyn_relocs != NULL)
2573 {
2574 struct ppc_dyn_relocs **pp;
2575 struct ppc_dyn_relocs *p;
2576
1e370bd2 2577 if (ind->root.type == bfd_link_hash_indirect)
bbd7ec4a
AM		 2578 abort ();
2579
2580 /* Add reloc counts against the weak sym to the strong sym
2581 list. Merge any entries against the same section. */
2582 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
2583 {
2584 struct ppc_dyn_relocs *q;
2585
2586 for (q = edir->dyn_relocs; q != NULL; q = q->next)
2587 if (q->sec == p->sec)
2588 {
2589 q->pc_count += p->pc_count;
2590 q->count += p->count;
2591 *pp = p->next;
2592 break;
2593 }
2594 if (q == NULL)
2595 pp = &p->next;
2596 }
2597 *pp = edir->dyn_relocs;
2598 }
2599
65f38f15
AM		 2600 edir->dyn_relocs = eind->dyn_relocs;
2601 eind->dyn_relocs = NULL;
2602 }
65f38f15 2603
d1329ca3
AM		 2604 edir->is_func |= eind->is_func;
2605 edir->is_func_descriptor |= eind->is_func_descriptor;
e86ce104 2606
65f38f15
AM		 2607 _bfd_elf_link_hash_copy_indirect (dir, ind);
2608}
2609
5bd4f169 2610/* Look through the relocs for a section during the first phase, and
65f38f15 2611 calculate needed space in the global offset table, procedure
5d1634d7 2612 linkage table, and dynamic reloc sections. */
5bd4f169
AM		 2613
2614static boolean
2615ppc64_elf_check_relocs (abfd, info, sec, relocs)
2616 bfd *abfd;
2617 struct bfd_link_info *info;
2618 asection *sec;
2619 const Elf_Internal_Rela *relocs;
2620{
65f38f15 2621 struct ppc_link_hash_table *htab;
5bd4f169
AM		 2622 Elf_Internal_Shdr *symtab_hdr;
2623 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
2624 const Elf_Internal_Rela *rel;
2625 const Elf_Internal_Rela *rel_end;
5bd4f169 2626 asection *sreloc;
e86ce104 2627 boolean is_opd;
5bd4f169
AM		 2628
2629 if (info->relocateable)
2630 return true;
2631
65f38f15 2632 htab = ppc_hash_table (info);
5bd4f169 2633 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5bd4f169
AM		 2634
2635 sym_hashes = elf_sym_hashes (abfd);
2636 sym_hashes_end = (sym_hashes
2637 + symtab_hdr->sh_size / sizeof (Elf64_External_Sym));
2638 if (!elf_bad_symtab (abfd))
2639 sym_hashes_end -= symtab_hdr->sh_info;
2640
2641 sreloc = NULL;
e86ce104 2642 is_opd = strcmp (bfd_get_section_name (abfd, sec), ".opd") == 0;
5bd4f169 2643
82bd7b59
AM		 2644 if (htab->elf.dynobj == NULL)
2645 htab->elf.dynobj = abfd;
2646 if (htab->sfpr == NULL
2647 && !create_linkage_sections (htab->elf.dynobj, info))
2648 return false;
2649
5bd4f169
AM		 2650 rel_end = relocs + sec->reloc_count;
2651 for (rel = relocs; rel < rel_end; rel++)
2652 {
2653 unsigned long r_symndx;
2654 struct elf_link_hash_entry *h;
a33d1f77 2655 enum elf_ppc_reloc_type r_type;
5bd4f169
AM		 2656
2657 r_symndx = ELF64_R_SYM (rel->r_info);
2658 if (r_symndx < symtab_hdr->sh_info)
2659 h = NULL;
2660 else
2661 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2662
a33d1f77
AM		 2663 r_type = (enum elf_ppc_reloc_type) ELF64_R_TYPE (rel->r_info);
2664 switch (r_type)
5bd4f169
AM		 2665 {
2666 /* GOT16 relocations */
2667 case R_PPC64_GOT16:
5bd4f169 2668 case R_PPC64_GOT16_DS:
65f38f15
AM		 2669 case R_PPC64_GOT16_HA:
2670 case R_PPC64_GOT16_HI:
2671 case R_PPC64_GOT16_LO:
5bd4f169 2672 case R_PPC64_GOT16_LO_DS:
5bd4f169 2673
65f38f15 2674 /* This symbol requires a global offset table entry. */
82bd7b59
AM		 2675 if (htab->sgot == NULL
2676 && !create_got_section (htab->elf.dynobj, info))
2677 return false;
5bd4f169
AM		 2678
2679 if (h != NULL)
2680 {
65f38f15 2681 h->got.refcount += 1;
5bd4f169
AM		 2682 }
2683 else
2684 {
65f38f15
AM		 2685 bfd_signed_vma *local_got_refcounts;
2686
5bd4f169 2687 /* This is a global offset table entry for a local symbol. */
65f38f15 2688 local_got_refcounts = elf_local_got_refcounts (abfd);
5bd4f169
AM		 2689 if (local_got_refcounts == NULL)
2690 {
dc810e39 2691 bfd_size_type size;
5bd4f169 2692
dc810e39
AM		 2693 size = symtab_hdr->sh_info;
2694 size *= sizeof (bfd_signed_vma);
2695 local_got_refcounts = ((bfd_signed_vma *)
65f38f15 2696 bfd_zalloc (abfd, size));
5bd4f169
AM		 2697 if (local_got_refcounts == NULL)
2698 return false;
2699 elf_local_got_refcounts (abfd) = local_got_refcounts;
5bd4f169 2700 }
65f38f15 2701 local_got_refcounts[r_symndx] += 1;
5bd4f169
AM		 2702 }
2703 break;
2704
5bd4f169 2705 case R_PPC64_PLT16_HA:
65f38f15
AM		 2706 case R_PPC64_PLT16_HI:
2707 case R_PPC64_PLT16_LO:
2708 case R_PPC64_PLT32:
2709 case R_PPC64_PLT64:
5bd4f169
AM		 2710 /* This symbol requires a procedure linkage table entry. We
2711 actually build the entry in adjust_dynamic_symbol,
2712 because this might be a case of linking PIC code without
2713 linking in any dynamic objects, in which case we don't
2714 need to generate a procedure linkage table after all. */
5bd4f169
AM		 2715 if (h == NULL)
2716 {
2717 /* It does not make sense to have a procedure linkage
2718 table entry for a local symbol. */
2719 bfd_set_error (bfd_error_bad_value);
2720 return false;
2721 }
2722
65f38f15
AM		 2723 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2724 h->plt.refcount += 1;
e86ce104 2725 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5bd4f169
AM		 2726 break;
2727
2728 /* The following relocations don't need to propagate the
2729 relocation if linking a shared object since they are
2730 section relative. */
2731 case R_PPC64_SECTOFF:
2732 case R_PPC64_SECTOFF_LO:
2733 case R_PPC64_SECTOFF_HI:
2734 case R_PPC64_SECTOFF_HA:
2735 case R_PPC64_SECTOFF_DS:
2736 case R_PPC64_SECTOFF_LO_DS:
2737 case R_PPC64_TOC16:
2738 case R_PPC64_TOC16_LO:
2739 case R_PPC64_TOC16_HI:
2740 case R_PPC64_TOC16_HA:
2741 case R_PPC64_TOC16_DS:
2742 case R_PPC64_TOC16_LO_DS:
2743 break;
2744
2745 /* This relocation describes the C++ object vtable hierarchy.
2746 Reconstruct it for later use during GC. */
2747 case R_PPC64_GNU_VTINHERIT:
2748 if (!_bfd_elf64_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2749 return false;
2750 break;
2751
2752 /* This relocation describes which C++ vtable entries are actually
2753 used. Record for later use during GC. */
2754 case R_PPC64_GNU_VTENTRY:
2755 if (!_bfd_elf64_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2756 return false;
2757 break;
2758
721956f4
AM		 2759 case R_PPC64_REL14:
2760 case R_PPC64_REL14_BRTAKEN:
2761 case R_PPC64_REL14_BRNTAKEN:
2762 htab->has_14bit_branch = 1;
2763 /* Fall through. */
2764
5d1634d7 2765 case R_PPC64_REL24:
e86ce104
AM		 2766 if (h != NULL
2767 && h->root.root.string[0] == '.'
2768 && h->root.root.string[1] != 0)
5d1634d7
AM		 2769 {
2770 /* We may need a .plt entry if the function this reloc
2771 refers to is in a shared lib. */
2772 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2773 h->plt.refcount += 1;
e86ce104 2774 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5d1634d7
AM		 2775 }
2776 break;
2777
e86ce104
AM		 2778 case R_PPC64_ADDR64:
2779 if (is_opd
2780 && h != NULL
2781 && h->root.root.string[0] == '.'
2782 && h->root.root.string[1] != 0)
2783 {
2784 struct elf_link_hash_entry *fdh;
2785
2786 fdh = elf_link_hash_lookup (&htab->elf, h->root.root.string + 1,
2787 false, false, false);
2788 if (fdh != NULL)
2789 {
e86ce104 2790 ((struct ppc_link_hash_entry *) fdh)->is_func_descriptor = 1;
721956f4 2791 ((struct ppc_link_hash_entry *) fdh)->oh = h;
e86ce104 2792 ((struct ppc_link_hash_entry *) h)->is_func = 1;
721956f4 2793 ((struct ppc_link_hash_entry *) h)->oh = fdh;
e86ce104
AM		 2794 }
2795 }
2796 /* Fall through. */
2797
5bd4f169
AM		 2798 case R_PPC64_REL64:
2799 case R_PPC64_REL32:
65f38f15
AM		 2800 case R_PPC64_ADDR14:
2801 case R_PPC64_ADDR14_BRNTAKEN:
2802 case R_PPC64_ADDR14_BRTAKEN:
2803 case R_PPC64_ADDR16:
2804 case R_PPC64_ADDR16_DS:
2805 case R_PPC64_ADDR16_HA:
2806 case R_PPC64_ADDR16_HI:
2807 case R_PPC64_ADDR16_HIGHER:
2808 case R_PPC64_ADDR16_HIGHERA:
2809 case R_PPC64_ADDR16_HIGHEST:
2810 case R_PPC64_ADDR16_HIGHESTA:
2811 case R_PPC64_ADDR16_LO:
2812 case R_PPC64_ADDR16_LO_DS:
2813 case R_PPC64_ADDR24:
2814 case R_PPC64_ADDR30:
2815 case R_PPC64_ADDR32:
65f38f15
AM		 2816 case R_PPC64_UADDR16:
2817 case R_PPC64_UADDR32:
2818 case R_PPC64_UADDR64:
5bd4f169 2819 case R_PPC64_TOC:
41bd81ab
AM		 2820 /* Don't propagate .opd relocs. */
2821 if (NO_OPD_RELOCS && is_opd)
e86ce104 2822 break;
e86ce104 2823
65f38f15
AM		 2824 /* If we are creating a shared library, and this is a reloc
2825 against a global symbol, or a non PC relative reloc
2826 against a local symbol, then we need to copy the reloc
2827 into the shared library. However, if we are linking with
2828 -Bsymbolic, we do not need to copy a reloc against a
2829 global symbol which is defined in an object we are
2830 including in the link (i.e., DEF_REGULAR is set). At
2831 this point we have not seen all the input files, so it is
2832 possible that DEF_REGULAR is not set now but will be set
2833 later (it is never cleared). In case of a weak definition,
2834 DEF_REGULAR may be cleared later by a strong definition in
2835 a shared library. We account for that possibility below by
2836 storing information in the relocs_copied field of the hash
2837 table entry. A similar situation occurs when creating
2838 shared libraries and symbol visibility changes render the
2839 symbol local.
2840
2841 If on the other hand, we are creating an executable, we
2842 may need to keep relocations for symbols satisfied by a
2843 dynamic library if we manage to avoid copy relocs for the
2844 symbol. */
2845 if ((info->shared
2846 && (sec->flags & SEC_ALLOC) != 0
a33d1f77 2847 && (IS_ABSOLUTE_RELOC (r_type)
65f38f15
AM		 2848 || (h != NULL
2849 && (! info->symbolic
2850 || h->root.type == bfd_link_hash_defweak
2851 || (h->elf_link_hash_flags
2852 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2853 || (!info->shared
2854 && (sec->flags & SEC_ALLOC) != 0
2855 && h != NULL
2856 && (h->root.type == bfd_link_hash_defweak
2857 || (h->elf_link_hash_flags
2858 & ELF_LINK_HASH_DEF_REGULAR) == 0)))
5bd4f169 2859 {
ec338859
AM		 2860 struct ppc_dyn_relocs *p;
2861 struct ppc_dyn_relocs **head;
2862
65f38f15
AM		 2863 /* We must copy these reloc types into the output file.
2864 Create a reloc section in dynobj and make room for
2865 this reloc. */
5bd4f169
AM		 2866 if (sreloc == NULL)
2867 {
2868 const char *name;
65f38f15 2869 bfd *dynobj;
5bd4f169
AM		 2870
2871 name = (bfd_elf_string_from_elf_section
2872 (abfd,
2873 elf_elfheader (abfd)->e_shstrndx,
2874 elf_section_data (sec)->rel_hdr.sh_name));
2875 if (name == NULL)
2876 return false;
2877
65f38f15
AM		 2878 if (strncmp (name, ".rela", 5) != 0
2879 || strcmp (bfd_get_section_name (abfd, sec),
2880 name + 5) != 0)
2881 {
2882 (*_bfd_error_handler)
2883 (_("%s: bad relocation section name `%s\'"),
2884 bfd_archive_filename (abfd), name);
5d1634d7 2885 bfd_set_error (bfd_error_bad_value);
65f38f15
AM		 2886 }
2887
65f38f15 2888 dynobj = htab->elf.dynobj;
5bd4f169
AM		 2889 sreloc = bfd_get_section_by_name (dynobj, name);
2890 if (sreloc == NULL)
2891 {
2892 flagword flags;
2893
2894 sreloc = bfd_make_section (dynobj, name);
2895 flags = (SEC_HAS_CONTENTS | SEC_READONLY
2896 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2897 if ((sec->flags & SEC_ALLOC) != 0)
2898 flags |= SEC_ALLOC | SEC_LOAD;
2899 if (sreloc == NULL
2900 || ! bfd_set_section_flags (dynobj, sreloc, flags)
65f38f15 2901 || ! bfd_set_section_alignment (dynobj, sreloc, 3))
5bd4f169
AM		 2902 return false;
2903 }
65f38f15 2904 elf_section_data (sec)->sreloc = sreloc;
5bd4f169
AM		 2905 }
2906
65f38f15
AM		 2907 /* If this is a global symbol, we count the number of
2908 relocations we need for this symbol. */
2909 if (h != NULL)
2910 {
ec338859 2911 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
65f38f15
AM		 2912 }
2913 else
2914 {
ec338859
AM		 2915 /* Track dynamic relocs needed for local syms too.
2916 We really need local syms available to do this
2917 easily. Oh well. */
2918
2919 asection *s;
2920 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
2921 sec, r_symndx);
2922 if (s == NULL)
2923 return false;
2924
2925 head = ((struct ppc_dyn_relocs **)
2926 &elf_section_data (s)->local_dynrel);
65f38f15 2927 }
ec338859
AM		 2928
2929 p = *head;
2930 if (p == NULL || p->sec != sec)
2931 {
2932 p = ((struct ppc_dyn_relocs *)
2933 bfd_alloc (htab->elf.dynobj,
2934 (bfd_size_type) sizeof *p));
2935 if (p == NULL)
2936 return false;
2937 p->next = *head;
2938 *head = p;
2939 p->sec = sec;
2940 p->count = 0;
2941 p->pc_count = 0;
2942 }
2943
2944 p->count += 1;
2945 if (!IS_ABSOLUTE_RELOC (r_type))
2946 p->pc_count += 1;
65f38f15 2947 }
5bd4f169 2948 break;
65f38f15
AM		 2949
2950 default:
96e0dda4 2951 break;
5bd4f169
AM		 2952 }
2953 }
2954
2955 return true;
2956}
2957
2958/* Return the section that should be marked against GC for a given
2959 relocation. */
2960
2961static asection *
2962ppc64_elf_gc_mark_hook (abfd, info, rel, h, sym)
2963 bfd *abfd;
2964 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2965 Elf_Internal_Rela *rel;
2966 struct elf_link_hash_entry *h;
2967 Elf_Internal_Sym *sym;
2968{
2969 if (h != NULL)
2970 {
a33d1f77
AM		 2971 enum elf_ppc_reloc_type r_type;
2972
2973 r_type = (enum elf_ppc_reloc_type) ELF64_R_TYPE (rel->r_info);
2974 switch (r_type)
5bd4f169
AM		 2975 {
2976 case R_PPC64_GNU_VTINHERIT:
2977 case R_PPC64_GNU_VTENTRY:
2978 break;
2979
2980 default:
2981 switch (h->root.type)
2982 {
2983 case bfd_link_hash_defined:
2984 case bfd_link_hash_defweak:
2985 return h->root.u.def.section;
2986
2987 case bfd_link_hash_common:
2988 return h->root.u.c.p->section;
2989
2990 default:
2991 break;
2992 }
2993 }
2994 }
2995 else
2996 {
9ad5cbcf 2997 return bfd_section_from_elf_index (abfd, sym->st_shndx);
5bd4f169
AM		 2998 }
2999
3000 return NULL;
3001}
3002
65f38f15
AM		 3003/* Update the .got, .plt. and dynamic reloc reference counts for the
3004 section being removed. */
5bd4f169
AM		 3005
3006static boolean
3007ppc64_elf_gc_sweep_hook (abfd, info, sec, relocs)
3008 bfd *abfd;
3009 struct bfd_link_info *info ATTRIBUTE_UNUSED;
3010 asection *sec;
3011 const Elf_Internal_Rela *relocs;
3012{
3013 Elf_Internal_Shdr *symtab_hdr;
3014 struct elf_link_hash_entry **sym_hashes;
3015 bfd_signed_vma *local_got_refcounts;
3016 const Elf_Internal_Rela *rel, *relend;
5bd4f169 3017
ec338859
AM		 3018 elf_section_data (sec)->local_dynrel = NULL;
3019
5bd4f169
AM		 3020 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3021 sym_hashes = elf_sym_hashes (abfd);
3022 local_got_refcounts = elf_local_got_refcounts (abfd);
3023
3024 relend = relocs + sec->reloc_count;
3025 for (rel = relocs; rel < relend; rel++)
a33d1f77
AM		 3026 {
3027 unsigned long r_symndx;
3028 enum elf_ppc_reloc_type r_type;
3029 struct elf_link_hash_entry *h;
5bd4f169 3030
a33d1f77
AM		 3031 r_symndx = ELF64_R_SYM (rel->r_info);
3032 r_type = (enum elf_ppc_reloc_type) ELF64_R_TYPE (rel->r_info);
3033 switch (r_type)
3034 {
3035 case R_PPC64_GOT16:
3036 case R_PPC64_GOT16_DS:
3037 case R_PPC64_GOT16_HA:
3038 case R_PPC64_GOT16_HI:
3039 case R_PPC64_GOT16_LO:
3040 case R_PPC64_GOT16_LO_DS:
3041 if (r_symndx >= symtab_hdr->sh_info)
3042 {
3043 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3044 if (h->got.refcount > 0)
3045 h->got.refcount--;
3046 }
3047 else
3048 {
3049 if (local_got_refcounts[r_symndx] > 0)
3050 local_got_refcounts[r_symndx]--;
3051 }
3052 break;
65f38f15 3053
a33d1f77
AM		 3054 case R_PPC64_PLT16_HA:
3055 case R_PPC64_PLT16_HI:
3056 case R_PPC64_PLT16_LO:
3057 case R_PPC64_PLT32:
3058 case R_PPC64_PLT64:
3059 if (r_symndx >= symtab_hdr->sh_info)
3060 {
3061 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3062 if (h->plt.refcount > 0)
3063 h->plt.refcount--;
3064 }
3065 break;
65f38f15 3066
721956f4
AM		 3067 case R_PPC64_REL14:
3068 case R_PPC64_REL14_BRNTAKEN:
3069 case R_PPC64_REL14_BRTAKEN:
5d1634d7
AM		 3070 case R_PPC64_REL24:
3071 if (r_symndx >= symtab_hdr->sh_info)
3072 {
3073 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3074 if (h->plt.refcount > 0)
3075 h->plt.refcount--;
3076 }
e86ce104 3077 break;
5d1634d7 3078
a33d1f77
AM		 3079 case R_PPC64_REL32:
3080 case R_PPC64_REL64:
3081 if (r_symndx >= symtab_hdr->sh_info)
3082 {
3083 struct ppc_link_hash_entry *eh;
3084 struct ppc_dyn_relocs **pp;
3085 struct ppc_dyn_relocs *p;
65f38f15 3086
a33d1f77
AM		 3087 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3088 eh = (struct ppc_link_hash_entry *) h;
65f38f15 3089
a33d1f77
AM		 3090 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
3091 if (p->sec == sec)
3092 {
3093 p->pc_count -= 1;
3094 p->count -= 1;
3095 if (p->count == 0)
3096 *pp = p->next;
3097 break;
3098 }
3099 }
3100 break;
65f38f15 3101
a33d1f77
AM		 3102 case R_PPC64_ADDR14:
3103 case R_PPC64_ADDR14_BRNTAKEN:
3104 case R_PPC64_ADDR14_BRTAKEN:
3105 case R_PPC64_ADDR16:
3106 case R_PPC64_ADDR16_DS:
3107 case R_PPC64_ADDR16_HA:
3108 case R_PPC64_ADDR16_HI:
3109 case R_PPC64_ADDR16_HIGHER:
3110 case R_PPC64_ADDR16_HIGHERA:
3111 case R_PPC64_ADDR16_HIGHEST:
3112 case R_PPC64_ADDR16_HIGHESTA:
3113 case R_PPC64_ADDR16_LO:
3114 case R_PPC64_ADDR16_LO_DS:
3115 case R_PPC64_ADDR24:
3116 case R_PPC64_ADDR30:
3117 case R_PPC64_ADDR32:
3118 case R_PPC64_ADDR64:
3119 case R_PPC64_UADDR16:
3120 case R_PPC64_UADDR32:
3121 case R_PPC64_UADDR64:
3122 case R_PPC64_TOC:
3123 if (r_symndx >= symtab_hdr->sh_info)
3124 {
3125 struct ppc_link_hash_entry *eh;
3126 struct ppc_dyn_relocs **pp;
3127 struct ppc_dyn_relocs *p;
65f38f15 3128
a33d1f77
AM		 3129 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3130 eh = (struct ppc_link_hash_entry *) h;
3131
3132 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
3133 if (p->sec == sec)
3134 {
3135 p->count -= 1;
3136 if (p->count == 0)
3137 *pp = p->next;
3138 break;
3139 }
3140 }
3141 break;
5bd4f169 3142
a33d1f77
AM		 3143 default:
3144 break;
3145 }
3146 }
5bd4f169
AM		 3147 return true;
3148}
3149
e86ce104
AM		 3150/* Called via elf_link_hash_traverse to transfer dynamic linking
3151 information on function code symbol entries to their corresponding
3152 function descriptor symbol entries. */
5bd4f169 3153static boolean
e86ce104 3154func_desc_adjust (h, inf)
5bd4f169 3155 struct elf_link_hash_entry *h;
e86ce104 3156 PTR inf;
5bd4f169 3157{
e86ce104 3158 struct bfd_link_info *info;
65f38f15 3159 struct ppc_link_hash_table *htab;
5bd4f169 3160
e92d460e 3161 if (h->root.type == bfd_link_hash_indirect)
e86ce104
AM		 3162 return true;
3163
e92d460e
AM		 3164 if (h->root.type == bfd_link_hash_warning)
3165 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3166
e86ce104 3167 info = (struct bfd_link_info *) inf;
65f38f15 3168 htab = ppc_hash_table (info);
5bd4f169 3169
e86ce104
AM		 3170 /* If this is a function code symbol, transfer dynamic linking
3171 information to the function descriptor symbol. */
3172 if (!((struct ppc_link_hash_entry *) h)->is_func)
3173 return true;
3174
805fc799
AM		 3175 if (h->root.type == bfd_link_hash_undefweak
3176 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR))
3177 htab->have_undefweak = true;
3178
e86ce104
AM		 3179 if (h->plt.refcount > 0
3180 && h->root.root.string[0] == '.'
3181 && h->root.root.string[1] != '\0')
5bd4f169 3182 {
721956f4 3183 struct elf_link_hash_entry *fdh = ((struct ppc_link_hash_entry *) h)->oh;
e86ce104 3184 boolean force_local;
5bd4f169 3185
648cca2c
AM		 3186 /* Find the corresponding function descriptor symbol. Create it
3187 as undefined if necessary. */
5bd4f169 3188
721956f4
AM		 3189 if (fdh == NULL)
3190 fdh = elf_link_hash_lookup (&htab->elf, h->root.root.string + 1,
3191 false, false, true);
5bd4f169 3192
d926e03d
AM		 3193 if (fdh == NULL
3194 && info->shared
3195 && (h->root.type == bfd_link_hash_undefined
3196 || h->root.type == bfd_link_hash_undefweak))
648cca2c
AM		 3197 {
3198 bfd *abfd;
3199 asymbol *newsym;
3200
d926e03d 3201 abfd = h->root.u.undef.abfd;
648cca2c
AM		 3202 newsym = bfd_make_empty_symbol (abfd);
3203 newsym->name = h->root.root.string + 1;
3204 newsym->section = bfd_und_section_ptr;
3205 newsym->value = 0;
3206 newsym->flags = BSF_OBJECT;
3207 if (h->root.type == bfd_link_hash_undefweak)
3208 newsym->flags |= BSF_WEAK;
3209
3210 if ( !(_bfd_generic_link_add_one_symbol
3211 (info, abfd, newsym->name, newsym->flags,
3212 newsym->section, newsym->value, NULL, false, false,
3213 (struct bfd_link_hash_entry **) &fdh)))
3214 {
3215 return false;
3216 }
d926e03d 3217 fdh->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
648cca2c
AM		 3218 }
3219
e86ce104
AM		 3220 if (fdh != NULL
3221 && (fdh->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0
3222 && (info->shared
3223 || (fdh->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
3224 || (fdh->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0))
3225 {
3226 if (fdh->dynindx == -1)
3227 if (! bfd_elf64_link_record_dynamic_symbol (info, fdh))
3228 return false;
e86ce104
AM		 3229 fdh->elf_link_hash_flags |= (h->elf_link_hash_flags
3230 & (ELF_LINK_HASH_REF_REGULAR
3231 | ELF_LINK_HASH_REF_DYNAMIC
3232 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
3233 | ELF_LINK_NON_GOT_REF));
e1fa50e7
AM		 3234 if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
3235 {
3236 fdh->plt.refcount = h->plt.refcount;
3237 fdh->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
3238 }
e86ce104 3239 ((struct ppc_link_hash_entry *) fdh)->is_func_descriptor = 1;
721956f4 3240 ((struct ppc_link_hash_entry *) fdh)->oh = h;
721956f4 3241 ((struct ppc_link_hash_entry *) h)->oh = fdh;
e86ce104
AM		 3242 }
3243
3244 /* Now that the info is on the function descriptor, clear the
3245 function code sym info. Any function code syms for which we
3246 don't have a definition in a regular file, we force local.
3247 This prevents a shared library from exporting syms that have
3248 been imported from another library. Function code syms that
3249 are really in the library we must leave global to prevent the
e1fa50e7 3250 linker dragging in a definition from a static library. */
ea1e4b0d
AM		 3251 force_local = (info->shared
3252 && ((h->elf_link_hash_flags
3253 & ELF_LINK_HASH_DEF_REGULAR) == 0
3254 || fdh == NULL
3255 || (fdh->elf_link_hash_flags
3256 & ELF_LINK_HASH_DEF_REGULAR) == 0
3257 || (fdh->elf_link_hash_flags
3258 & ELF_LINK_FORCED_LOCAL) != 0));
e86ce104
AM		 3259 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
3260 }
3261
3262 return true;
3263}
40b8271b 3264
82bd7b59
AM		 3265#define MIN_SAVE_FPR 14
3266#define MAX_SAVE_FPR 31
3267
e86ce104 3268/* Called near the start of bfd_elf_size_dynamic_sections. We use
82bd7b59
AM		 3269 this hook to a) provide some gcc support functions, and b) transfer
3270 dynamic linking information gathered so far on function code symbol
3271 entries, to their corresponding function descriptor symbol entries. */
e86ce104
AM		 3272static boolean
3273ppc64_elf_func_desc_adjust (obfd, info)
3274 bfd *obfd ATTRIBUTE_UNUSED;
3275 struct bfd_link_info *info;
3276{
3277 struct ppc_link_hash_table *htab;
82bd7b59
AM		 3278 unsigned int lowest_savef = MAX_SAVE_FPR + 2;
3279 unsigned int lowest_restf = MAX_SAVE_FPR + 2;
3280 unsigned int i;
3281 struct elf_link_hash_entry *h;
721956f4 3282 bfd_byte *p;
82bd7b59 3283 char sym[10];
e86ce104
AM		 3284
3285 htab = ppc_hash_table (info);
82bd7b59
AM		 3286
3287 if (htab->sfpr == NULL)
3288 /* We don't have any relocs. */
3289 return true;
3290
3291 /* First provide any missing ._savef* and ._restf* functions. */
3292 memcpy (sym, "._savef14", 10);
3293 for (i = MIN_SAVE_FPR; i <= MAX_SAVE_FPR; i++)
3294 {
3295 sym[7] = i / 10 + '0';
3296 sym[8] = i % 10 + '0';
3297 h = elf_link_hash_lookup (&htab->elf, sym, false, false, true);
3298 if (h != NULL
3299 && h->root.type == bfd_link_hash_undefined)
3300 {
3301 if (lowest_savef > i)
3302 lowest_savef = i;
3303 h->root.type = bfd_link_hash_defined;
3304 h->root.u.def.section = htab->sfpr;
3305 h->root.u.def.value = (i - lowest_savef) * 4;
3306 h->type = STT_FUNC;
3307 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3308 _bfd_elf_link_hash_hide_symbol (info, h, info->shared);
3309 }
3310 }
3311
3312 memcpy (sym, "._restf14", 10);
3313 for (i = MIN_SAVE_FPR; i <= MAX_SAVE_FPR; i++)
3314 {
3315 sym[7] = i / 10 + '0';
3316 sym[8] = i % 10 + '0';
3317 h = elf_link_hash_lookup (&htab->elf, sym, false, false, true);
3318 if (h != NULL
3319 && h->root.type == bfd_link_hash_undefined)
3320 {
3321 if (lowest_restf > i)
3322 lowest_restf = i;
3323 h->root.type = bfd_link_hash_defined;
3324 h->root.u.def.section = htab->sfpr;
3325 h->root.u.def.value = ((MAX_SAVE_FPR + 2 - lowest_savef) * 4
3326 + (i - lowest_restf) * 4);
3327 h->type = STT_FUNC;
3328 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3329 _bfd_elf_link_hash_hide_symbol (info, h, info->shared);
3330 }
3331 }
3332
805fc799
AM		 3333 elf_link_hash_traverse (&htab->elf, func_desc_adjust, (PTR) info);
3334
82bd7b59
AM		 3335 htab->sfpr->_raw_size = ((MAX_SAVE_FPR + 2 - lowest_savef) * 4
3336 + (MAX_SAVE_FPR + 2 - lowest_restf) * 4);
3337
3338 if (htab->sfpr->_raw_size == 0)
805fc799
AM		 3339 {
3340 if (!htab->have_undefweak)
3341 {
3342 _bfd_strip_section_from_output (info, htab->sfpr);
3343 return true;
3344 }
3345
3346 htab->sfpr->_raw_size = 4;
3347 }
82bd7b59 3348
721956f4
AM		 3349 p = (bfd_byte *) bfd_alloc (htab->elf.dynobj, htab->sfpr->_raw_size);
3350 if (p == NULL)
3351 return false;
3352 htab->sfpr->contents = p;
3353
3354 for (i = lowest_savef; i <= MAX_SAVE_FPR; i++)
3355 {
3356 unsigned int fpr = i << 21;
3357 unsigned int stackoff = (1 << 16) - (MAX_SAVE_FPR + 1 - i) * 8;
3358 bfd_put_32 (htab->elf.dynobj, STFD_FR0_0R1 + fpr + stackoff, p);
3359 p += 4;
3360 }
3361 if (lowest_savef <= MAX_SAVE_FPR)
3362 {
82bd7b59
AM		 3363 bfd_put_32 (htab->elf.dynobj, BLR, p);
3364 p += 4;
721956f4 3365 }
82bd7b59 3366
721956f4
AM		 3367 for (i = lowest_restf; i <= MAX_SAVE_FPR; i++)
3368 {
3369 unsigned int fpr = i << 21;
3370 unsigned int stackoff = (1 << 16) - (MAX_SAVE_FPR + 1 - i) * 8;
3371 bfd_put_32 (htab->elf.dynobj, LFD_FR0_0R1 + fpr + stackoff, p);
82bd7b59
AM		 3372 p += 4;
3373 }
721956f4
AM		 3374 if (lowest_restf <= MAX_SAVE_FPR
3375 || htab->sfpr->_raw_size == 4)
3376 {
3377 bfd_put_32 (htab->elf.dynobj, BLR, p);
3378 }
82bd7b59 3379
e86ce104
AM		 3380 return true;
3381}
3382
3383/* Adjust a symbol defined by a dynamic object and referenced by a
3384 regular object. The current definition is in some section of the
3385 dynamic object, but we're not including those sections. We have to
3386 change the definition to something the rest of the link can
3387 understand. */
3388
3389static boolean
3390ppc64_elf_adjust_dynamic_symbol (info, h)
3391 struct bfd_link_info *info;
3392 struct elf_link_hash_entry *h;
3393{
3394 struct ppc_link_hash_table *htab;
3395 struct ppc_link_hash_entry * eh;
3396 struct ppc_dyn_relocs *p;
3397 asection *s;
3398 unsigned int power_of_two;
3399
3400 htab = ppc_hash_table (info);
3401
3402 /* Deal with function syms. */
3403 if (h->type == STT_FUNC
3404 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
3405 {
3406 /* Clear procedure linkage table information for any symbol that
3407 won't need a .plt entry. */
3408 if (!((struct ppc_link_hash_entry *) h)->is_func_descriptor
3409 || h->plt.refcount <= 0
3410 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
3411 || (! info->shared
3412 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
3413 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0))
40b8271b 3414 {
40b8271b
AM		 3415 h->plt.offset = (bfd_vma) -1;
3416 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
40b8271b 3417 }
5bd4f169
AM		 3418 return true;
3419 }
bbd7ec4a
AM		 3420 else
3421 h->plt.offset = (bfd_vma) -1;
5bd4f169
AM		 3422
3423 /* If this is a weak symbol, and there is a real definition, the
3424 processor independent code will have arranged for us to see the
3425 real definition first, and we can just use the same value. */
3426 if (h->weakdef != NULL)
3427 {
3428 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
3429 || h->weakdef->root.type == bfd_link_hash_defweak);
3430 h->root.u.def.section = h->weakdef->root.u.def.section;
3431 h->root.u.def.value = h->weakdef->root.u.def.value;
0a991dfe 3432 return true;
5bd4f169
AM		 3433 }
3434
3435 /* This is a reference to a symbol defined by a dynamic object which
3436 is not a function. */
3437
3438 /* If we are creating a shared library, we must presume that the
3439 only references to the symbol are via the global offset table.
3440 For such cases we need not do anything here; the relocations will
3441 be handled correctly by relocate_section. */
3442 if (info->shared)
3443 return true;
3444
65f38f15
AM		 3445 /* If there are no references to this symbol that do not use the
3446 GOT, we don't need to generate a copy reloc. */
3447 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
3448 return true;
3449
3450 eh = (struct ppc_link_hash_entry *) h;
3451 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3452 {
3453 s = p->sec->output_section;
3454 if (s != NULL && (s->flags & SEC_READONLY) != 0)
3455 break;
3456 }
3457
3458 /* If we didn't find any dynamic relocs in read-only sections, then
5d1634d7 3459 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
65f38f15
AM		 3460 if (p == NULL)
3461 {
3462 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
3463 return true;
3464 }
3465
5bd4f169
AM		 3466 /* We must allocate the symbol in our .dynbss section, which will
3467 become part of the .bss section of the executable. There will be
3468 an entry for this symbol in the .dynsym section. The dynamic
3469 object will contain position independent code, so all references
3470 from the dynamic object to this symbol will go through the global
3471 offset table. The dynamic linker will use the .dynsym entry to
3472 determine the address it must put in the global offset table, so
3473 both the dynamic object and the regular object will refer to the
3474 same memory location for the variable. */
5bd4f169
AM		 3475
3476 /* We must generate a R_PPC_COPY reloc to tell the dynamic linker to
3477 copy the initial value out of the dynamic object and into the
3478 runtime process image. We need to remember the offset into the
3479 .rela.bss section we are going to use. */
3480 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
3481 {
65f38f15 3482 htab->srelbss->_raw_size += sizeof (Elf64_External_Rela);
5bd4f169
AM		 3483 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
3484 }
3485
3486 /* We need to figure out the alignment required for this symbol. I
3487 have no idea how ELF linkers handle this. */
3488 power_of_two = bfd_log2 (h->size);
3489 if (power_of_two > 4)
3490 power_of_two = 4;
3491
3492 /* Apply the required alignment. */
65f38f15
AM		 3493 s = htab->sdynbss;
3494 s->_raw_size = BFD_ALIGN (s->_raw_size, (bfd_size_type) (1 << power_of_two));
3495 if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
5bd4f169 3496 {
65f38f15 3497 if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
5bd4f169
AM		 3498 return false;
3499 }
3500
3501 /* Define the symbol as being at this point in the section. */
3502 h->root.u.def.section = s;
3503 h->root.u.def.value = s->_raw_size;
3504
3505 /* Increment the section size to make room for the symbol. */
3506 s->_raw_size += h->size;
3507
3508 return true;
3509}
3510
e86ce104
AM		 3511/* If given a function descriptor symbol, hide both the function code
3512 sym and the descriptor. */
3513static void
3514ppc64_elf_hide_symbol (info, h, force_local)
3515 struct bfd_link_info *info;
3516 struct elf_link_hash_entry *h;
3517 boolean force_local;
3518{
3519 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
3520
3521 if (((struct ppc_link_hash_entry *) h)->is_func_descriptor)
3522 {
721956f4 3523 struct elf_link_hash_entry *fh = ((struct ppc_link_hash_entry *) h)->oh;
e86ce104 3524
721956f4 3525 if (fh == NULL)
d1329ca3
AM		 3526 {
3527 const char *p, *q;
3528 struct ppc_link_hash_table *htab;
3529 char save;
3530
3531 /* We aren't supposed to use alloca in BFD because on
3532 systems which do not have alloca the version in libiberty
3533 calls xmalloc, which might cause the program to crash
3534 when it runs out of memory. This function doesn't have a
3535 return status, so there's no way to gracefully return an
3536 error. So cheat. We know that string[-1] can be safely
3537 dereferenced; It's either a string in an ELF string
3538 table, or allocated in an objalloc structure. */
3539
3540 p = h->root.root.string - 1;
3541 save = *p;
3542 *(char *) p = '.';
3543 htab = ppc_hash_table (info);
3544 fh = elf_link_hash_lookup (&htab->elf, p, false, false, false);
3545 *(char *) p = save;
3546
3547 /* Unfortunately, if it so happens that the string we were
3548 looking for was allocated immediately before this string,
3549 then we overwrote the string terminator. That's the only
3550 reason the lookup should fail. */
3551 if (fh == NULL)
3552 {
3553 q = h->root.root.string + strlen (h->root.root.string);
3554 while (q >= h->root.root.string && *q == *p)
3555 --q, --p;
3556 if (q < h->root.root.string && *p == '.')
3557 fh = elf_link_hash_lookup (&htab->elf, p, false, false, false);
3558 }
3559 if (fh != NULL)
3560 {
3561 ((struct ppc_link_hash_entry *) h)->oh = fh;
3562 ((struct ppc_link_hash_entry *) fh)->oh = h;
3563 }
3564 }
e86ce104
AM		 3565 if (fh != NULL)
3566 _bfd_elf_link_hash_hide_symbol (info, fh, force_local);
3567 }
3568}
3569
65f38f15
AM		 3570/* This is the condition under which ppc64_elf_finish_dynamic_symbol
3571 will be called from elflink.h. If elflink.h doesn't call our
3572 finish_dynamic_symbol routine, we'll need to do something about
3573 initializing any .plt and .got entries in ppc64_elf_relocate_section. */
3574#define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
3575 ((DYN) \
3576 && ((INFO)->shared \
3577 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
3578 && ((H)->dynindx != -1 \
3579 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
5bd4f169 3580
65f38f15
AM		 3581/* Allocate space in .plt, .got and associated reloc sections for
3582 dynamic relocs. */
5bd4f169
AM		 3583
3584static boolean
65f38f15
AM		 3585allocate_dynrelocs (h, inf)
3586 struct elf_link_hash_entry *h;
3587 PTR inf;
5bd4f169 3588{
65f38f15
AM		 3589 struct bfd_link_info *info;
3590 struct ppc_link_hash_table *htab;
5bd4f169 3591 asection *s;
65f38f15
AM		 3592 struct ppc_link_hash_entry *eh;
3593 struct ppc_dyn_relocs *p;
5bd4f169 3594
e92d460e 3595 if (h->root.type == bfd_link_hash_indirect)
65f38f15 3596 return true;
5bd4f169 3597
e92d460e
AM		 3598 if (h->root.type == bfd_link_hash_warning)
3599 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3600
65f38f15
AM		 3601 info = (struct bfd_link_info *) inf;
3602 htab = ppc_hash_table (info);
5bd4f169 3603
65f38f15 3604 if (htab->elf.dynamic_sections_created
e86ce104
AM		 3605 && h->plt.refcount > 0
3606 && h->dynindx != -1)
5bd4f169 3607 {
e86ce104 3608 BFD_ASSERT (((struct ppc_link_hash_entry *) h)->is_func_descriptor);
5bd4f169 3609
65f38f15
AM		 3610 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
3611 {
65f38f15
AM		 3612 /* If this is the first .plt entry, make room for the special
3613 first entry. */
3614 s = htab->splt;
5bd4f169 3615 if (s->_raw_size == 0)
65f38f15
AM		 3616 s->_raw_size += PLT_INITIAL_ENTRY_SIZE;
3617
3618 h->plt.offset = s->_raw_size;
3619
3620 /* Make room for this entry. */
3621 s->_raw_size += PLT_ENTRY_SIZE;
3622
721956f4 3623 /* Make room for the .glink code. */
5d1634d7
AM		 3624 s = htab->sglink;
3625 if (s->_raw_size == 0)
3626 s->_raw_size += GLINK_CALL_STUB_SIZE;
3627 /* We need bigger stubs past index 32767. */
3628 if (s->_raw_size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
3629 s->_raw_size += 4;
3630 s->_raw_size += 2*4;
65f38f15
AM		 3631
3632 /* We also need to make an entry in the .rela.plt section. */
3633 s = htab->srelplt;
3634 s->_raw_size += sizeof (Elf64_External_Rela);
3635 }
3636 else
3637 {
3638 h->plt.offset = (bfd_vma) -1;
3639 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
3640 }
3641 }
3642 else
3643 {
3644 h->plt.offset = (bfd_vma) -1;
3645 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
3646 }
3647
3648 if (h->got.refcount > 0)
3649 {
3650 boolean dyn;
3651
3652 /* Make sure this symbol is output as a dynamic symbol.
3653 Undefined weak syms won't yet be marked as dynamic. */
3654 if (h->dynindx == -1
3655 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
3656 {
3657 if (! bfd_elf64_link_record_dynamic_symbol (info, h))
3658 return false;
3659 }
3660
3661 s = htab->sgot;
3662 h->got.offset = s->_raw_size;
3663 s->_raw_size += 8;
3664 dyn = htab->elf.dynamic_sections_created;
3665 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h))
3666 htab->srelgot->_raw_size += sizeof (Elf64_External_Rela);
3667 }
3668 else
3669 h->got.offset = (bfd_vma) -1;
3670
3671 eh = (struct ppc_link_hash_entry *) h;
3672 if (eh->dyn_relocs == NULL)
3673 return true;
3674
3675 /* In the shared -Bsymbolic case, discard space allocated for
3676 dynamic pc-relative relocs against symbols which turn out to be
3677 defined in regular objects. For the normal shared case, discard
3678 space for relocs that have become local due to symbol visibility
3679 changes. */
3680
3681 if (info->shared)
3682 {
3683 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
3684 && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
3685 || info->symbolic))
3686 {
3687 struct ppc_dyn_relocs **pp;
3688
3689 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
5bd4f169 3690 {
65f38f15
AM		 3691 p->count -= p->pc_count;
3692 p->pc_count = 0;
3693 if (p->count == 0)
3694 *pp = p->next;
3695 else
3696 pp = &p->next;
5bd4f169 3697 }
65f38f15
AM		 3698 }
3699 }
3700 else
3701 {
3702 /* For the non-shared case, discard space for relocs against
3703 symbols which turn out to need copy relocs or are not
3704 dynamic. */
3705
3706 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
3707 && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
3708 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3709 || (htab->elf.dynamic_sections_created
3710 && (h->root.type == bfd_link_hash_undefweak
3711 || h->root.type == bfd_link_hash_undefined))))
3712 {
3713 /* Make sure this symbol is output as a dynamic symbol.
3714 Undefined weak syms won't yet be marked as dynamic. */
3715 if (h->dynindx == -1
3716 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
3717 {
ec338859 3718 if (! bfd_elf64_link_record_dynamic_symbol (info, h))
65f38f15
AM		 3719 return false;
3720 }
3721
3722 /* If that succeeded, we know we'll be keeping all the
3723 relocs. */
3724 if (h->dynindx != -1)
3725 goto keep;
3726 }
3727
3728 eh->dyn_relocs = NULL;
3729
ec338859 3730 keep: ;
65f38f15
AM		 3731 }
3732
3733 /* Finally, allocate space. */
3734 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3735 {
3736 asection *sreloc = elf_section_data (p->sec)->sreloc;
3737 sreloc->_raw_size += p->count * sizeof (Elf64_External_Rela);
3738 }
3739
3740 return true;
3741}
3742
3743/* Find any dynamic relocs that apply to read-only sections. */
3744
3745static boolean
3746readonly_dynrelocs (h, inf)
3747 struct elf_link_hash_entry *h;
3748 PTR inf;
3749{
3750 struct ppc_link_hash_entry *eh;
3751 struct ppc_dyn_relocs *p;
3752
e92d460e
AM		 3753 if (h->root.type == bfd_link_hash_warning)
3754 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3755
65f38f15
AM		 3756 eh = (struct ppc_link_hash_entry *) h;
3757 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3758 {
3759 asection *s = p->sec->output_section;
3760
3761 if (s != NULL && (s->flags & SEC_READONLY) != 0)
3762 {
3763 struct bfd_link_info *info = (struct bfd_link_info *) inf;
3764
3765 info->flags |= DF_TEXTREL;
3766
3767 /* Not an error, just cut short the traversal. */
3768 return false;
3769 }
3770 }
3771 return true;
3772}
3773
3774/* Set the sizes of the dynamic sections. */
3775
3776static boolean
3777ppc64_elf_size_dynamic_sections (output_bfd, info)
3778 bfd *output_bfd ATTRIBUTE_UNUSED;
3779 struct bfd_link_info *info;
3780{
3781 struct ppc_link_hash_table *htab;
3782 bfd *dynobj;
3783 asection *s;
3784 boolean relocs;
3785 bfd *ibfd;
3786
3787 htab = ppc_hash_table (info);
3788 dynobj = htab->elf.dynobj;
3789 if (dynobj == NULL)
3790 abort ();
3791
3792 if (htab->elf.dynamic_sections_created)
3793 {
3794 /* Set the contents of the .interp section to the interpreter. */
3795 if (! info->shared)
3796 {
3797 s = bfd_get_section_by_name (dynobj, ".interp");
3798 if (s == NULL)
3799 abort ();
3800 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
3801 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3802 }
3803 }
3804
3805 /* Set up .got offsets for local syms, and space for local dynamic
3806 relocs. */
3807 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3808 {
3809 bfd_signed_vma *local_got;
3810 bfd_signed_vma *end_local_got;
3811 bfd_size_type locsymcount;
3812 Elf_Internal_Shdr *symtab_hdr;
3813 asection *srel;
3814
3815 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
3816 continue;
3817
3818 for (s = ibfd->sections; s != NULL; s = s->next)
3819 {
ec338859 3820 struct ppc_dyn_relocs *p;
65f38f15 3821
ec338859
AM		 3822 for (p = *((struct ppc_dyn_relocs **)
3823 &elf_section_data (s)->local_dynrel);
3824 p != NULL;
3825 p = p->next)
65f38f15 3826 {
ec338859
AM		 3827 if (!bfd_is_abs_section (p->sec)
3828 && bfd_is_abs_section (p->sec->output_section))
3829 {
3830 /* Input section has been discarded, either because
3831 it is a copy of a linkonce section or due to
3832 linker script /DISCARD/, so we'll be discarding
3833 the relocs too. */
3834 }
248866a8 3835 else if (p->count != 0)
ec338859
AM		 3836 {
3837 srel = elf_section_data (p->sec)->sreloc;
3838 srel->_raw_size += p->count * sizeof (Elf64_External_Rela);
248866a8
AM		 3839 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
3840 info->flags |= DF_TEXTREL;
ec338859 3841 }
65f38f15
AM		 3842 }
3843 }
3844
3845 local_got = elf_local_got_refcounts (ibfd);
3846 if (!local_got)
3847 continue;
3848
3849 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
3850 locsymcount = symtab_hdr->sh_info;
3851 end_local_got = local_got + locsymcount;
3852 s = htab->sgot;
3853 srel = htab->srelgot;
3854 for (; local_got < end_local_got; ++local_got)
3855 {
3856 if (*local_got > 0)
5bd4f169 3857 {
65f38f15
AM		 3858 *local_got = s->_raw_size;
3859 s->_raw_size += 8;
3860 if (info->shared)
3861 srel->_raw_size += sizeof (Elf64_External_Rela);
5bd4f169 3862 }
65f38f15
AM		 3863 else
3864 *local_got = (bfd_vma) -1;
3865 }
3866 }
3867
3868 /* Allocate global sym .plt and .got entries, and space for global
3869 sym dynamic relocs. */
3870 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
3871
3872 /* We now have determined the sizes of the various dynamic sections.
3873 Allocate memory for them. */
3874 relocs = false;
3875 for (s = dynobj->sections; s != NULL; s = s->next)
3876 {
3877 if ((s->flags & SEC_LINKER_CREATED) == 0)
3878 continue;
3879
721956f4
AM		 3880 if (s == htab->sbrlt || s == htab->srelbrlt)
3881 /* These haven't been allocated yet; don't strip. */
3882 continue;
3883 else if (s == htab->splt
3884 || s == htab->sgot
3885 || s == htab->sglink)
65f38f15
AM		 3886 {
3887 /* Strip this section if we don't need it; see the
3888 comment below. */
5bd4f169 3889 }
65f38f15 3890 else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
5bd4f169
AM		 3891 {
3892 if (s->_raw_size == 0)
3893 {
3894 /* If we don't need this section, strip it from the
3895 output file. This is mostly to handle .rela.bss and
3896 .rela.plt. We must create both sections in
3897 create_dynamic_sections, because they must be created
3898 before the linker maps input sections to output
3899 sections. The linker does that before
3900 adjust_dynamic_symbol is called, and it is that
3901 function which decides whether anything needs to go
3902 into these sections. */
5bd4f169
AM		 3903 }
3904 else
3905 {
65f38f15
AM		 3906 if (s != htab->srelplt)
3907 relocs = true;
5bd4f169
AM		 3908
3909 /* We use the reloc_count field as a counter if we need
3910 to copy relocs into the output file. */
3911 s->reloc_count = 0;
3912 }
3913 }
65f38f15 3914 else
5bd4f169
AM		 3915 {
3916 /* It's not one of our sections, so don't allocate space. */
3917 continue;
3918 }
3919
65f38f15 3920 if (s->_raw_size == 0)
5bd4f169
AM		 3921 {
3922 _bfd_strip_section_from_output (info, s);
3923 continue;
3924 }
3925
5f333394
AM		 3926 /* .plt is in the bss section. We don't initialise it. */
3927 if ((s->flags & SEC_LOAD) == 0)
3928 continue;
3929
65f38f15
AM		 3930 /* Allocate memory for the section contents. We use bfd_zalloc
3931 here in case unused entries are not reclaimed before the
3932 section's contents are written out. This should not happen,
3933 but this way if it does, we get a R_PPC64_NONE reloc instead
3934 of garbage. */
721956f4 3935 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
65f38f15 3936 if (s->contents == NULL)
5bd4f169
AM		 3937 return false;
3938 }
3939
e86ce104 3940 if (htab->elf.dynamic_sections_created)
5bd4f169
AM		 3941 {
3942 /* Add some entries to the .dynamic section. We fill in the
3943 values later, in ppc64_elf_finish_dynamic_sections, but we
3944 must add the entries now so that we get the correct size for
3945 the .dynamic section. The DT_DEBUG entry is filled in by the
3946 dynamic linker and used by the debugger. */
dc810e39
AM		 3947#define add_dynamic_entry(TAG, VAL) \
3948 bfd_elf64_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
3949
3950 if (!info->shared)
5bd4f169 3951 {
dc810e39 3952 if (!add_dynamic_entry (DT_DEBUG, 0))
5bd4f169
AM		 3953 return false;
3954 }
3955
9c07fe7c 3956 if (htab->splt != NULL && htab->splt->_raw_size != 0)
5bd4f169 3957 {
dc810e39
AM		 3958 if (!add_dynamic_entry (DT_PLTGOT, 0)
3959 || !add_dynamic_entry (DT_PLTRELSZ, 0)
3960 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
5d1634d7
AM		 3961 || !add_dynamic_entry (DT_JMPREL, 0)
3962 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
5bd4f169
AM		 3963 return false;
3964 }
3965
19397422
AM		 3966 if (NO_OPD_RELOCS)
3967 {
3968 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
3969 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
3970 return false;
3971 }
3972
5bd4f169
AM		 3973 if (relocs)
3974 {
dc810e39
AM		 3975 if (!add_dynamic_entry (DT_RELA, 0)
3976 || !add_dynamic_entry (DT_RELASZ, 0)
3977 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
5bd4f169 3978 return false;
5bd4f169 3979
65f38f15
AM		 3980 /* If any dynamic relocs apply to a read-only section,
3981 then we need a DT_TEXTREL entry. */
248866a8
AM		 3982 if ((info->flags & DF_TEXTREL) == 0)
3983 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
3984 (PTR) info);
5bd4f169 3985
65f38f15 3986 if ((info->flags & DF_TEXTREL) != 0)
5bd4f169 3987 {
65f38f15
AM		 3988 if (!add_dynamic_entry (DT_TEXTREL, 0))
3989 return false;
5bd4f169 3990 }
5bd4f169 3991 }
5bd4f169 3992 }
65f38f15 3993#undef add_dynamic_entry
5bd4f169
AM		 3994
3995 return true;
3996}
3997
721956f4 3998/* Determine the type of stub needed, if any, for a call. */
5bd4f169 3999
721956f4
AM		 4000static INLINE enum ppc_stub_type
4001ppc_type_of_stub (input_sec, rel, hash, destination)
4002 asection *input_sec;
4003 const Elf_Internal_Rela *rel;
4004 struct ppc_link_hash_entry **hash;
4005 bfd_vma destination;
5bd4f169 4006{
721956f4
AM		 4007 struct ppc_link_hash_entry *h = *hash;
4008 bfd_vma location;
4009 bfd_vma branch_offset;
4010 bfd_vma max_branch_offset;
4011 unsigned int r_type;
5bd4f169 4012
721956f4
AM		 4013 if (h != NULL)
4014 {
4015 if (h->oh != NULL
4016 && h->oh->plt.offset != (bfd_vma) -1
4017 && h->oh->dynindx != -1)
5bd4f169 4018 {
721956f4
AM		 4019 *hash = (struct ppc_link_hash_entry *) h->oh;
4020 return ppc_stub_plt_call;
5bd4f169
AM		 4021 }
4022
721956f4
AM		 4023 if (h->elf.root.type == bfd_link_hash_undefweak
4024 || h->elf.root.type == bfd_link_hash_undefined)
4025 return ppc_stub_none;
5d1634d7 4026 }
5d1634d7 4027
721956f4
AM		 4028 /* Determine where the call point is. */
4029 location = (input_sec->output_offset
4030 + input_sec->output_section->vma
4031 + rel->r_offset);
5d1634d7 4032
721956f4
AM		 4033 branch_offset = destination - location;
4034 r_type = ELF64_R_TYPE (rel->r_info);
5d1634d7 4035
721956f4
AM		 4036 /* Determine if a long branch stub is needed. */
4037 max_branch_offset = 1 << 25;
4038 if (r_type != (unsigned int) R_PPC64_REL24)
4039 max_branch_offset = 1 << 15;
5d1634d7 4040
721956f4
AM		 4041 if (branch_offset + max_branch_offset >= 2 * max_branch_offset)
4042 /* We need a stub. Figure out whether a long_branch or plt_branch
4043 is needed later. */
4044 return ppc_stub_long_branch;
5d1634d7 4045
721956f4 4046 return ppc_stub_none;
5d1634d7
AM		 4047}
4048
4049/* Build a .plt call stub. */
4050
4051static bfd_byte *
4052build_plt_stub (obfd, p, offset, glink)
4053 bfd *obfd;
4054 bfd_byte *p;
4055 int offset;
4056 int glink;
4057{
4058#define PPC_LO(v) ((v) & 0xffff)
4059#define PPC_HI(v) (((v) >> 16) & 0xffff)
4060#define PPC_HA(v) PPC_HI ((v) + 0x8000)
4061
4062 if (glink)
4063 bfd_put_32 (obfd, LD_R2_40R1, p), p += 4;
4064 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
4065 if (!glink)
4066 bfd_put_32 (obfd, STD_R2_40R1, p), p += 4;
4067 bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p), p += 4;
4068 if (PPC_HA (offset + 8) != PPC_HA (offset))
4069 bfd_put_32 (obfd, ADDIS_R12_R12_1, p), p += 4;
4070 offset += 8;
4071 bfd_put_32 (obfd, LD_R2_0R12 | PPC_LO (offset), p), p += 4;
4072 if (PPC_HA (offset + 8) != PPC_HA (offset))
4073 bfd_put_32 (obfd, ADDIS_R12_R12_1, p), p += 4;
4074 offset += 8;
4075 bfd_put_32 (obfd, MTCTR_R11, p), p += 4;
4076 bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p), p += 4;
4077 bfd_put_32 (obfd, BCTR, p), p += 4;
4078 return p;
4079}
4080
5d1634d7 4081static boolean
721956f4
AM		 4082ppc_build_one_stub (gen_entry, in_arg)
4083 struct bfd_hash_entry *gen_entry;
4084 PTR in_arg;
5d1634d7 4085{
721956f4
AM		 4086 struct ppc_stub_hash_entry *stub_entry;
4087 struct ppc_branch_hash_entry *br_entry;
5d1634d7
AM		 4088 struct bfd_link_info *info;
4089 struct ppc_link_hash_table *htab;
721956f4
AM		 4090 asection *stub_sec;
4091 bfd *stub_bfd;
4092 bfd_byte *loc;
4093 bfd_byte *p;
4094 unsigned int indx;
4095 bfd_vma off;
4096 int size;
5d1634d7 4097
721956f4
AM		 4098 /* Massage our args to the form they really have. */
4099 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
4100 info = (struct bfd_link_info *) in_arg;
5d1634d7 4101
5d1634d7 4102 htab = ppc_hash_table (info);
721956f4 4103 stub_sec = stub_entry->stub_sec;
5d1634d7 4104
721956f4
AM		 4105 /* Make a note of the offset within the stubs for this entry. */
4106 stub_entry->stub_offset = stub_sec->_cooked_size;
4107 loc = stub_sec->contents + stub_entry->stub_offset;
4108
4109 stub_bfd = stub_sec->owner;
4110
4111 switch (stub_entry->stub_type)
5d1634d7 4112 {
721956f4
AM		 4113 case ppc_stub_long_branch:
4114 /* Branches are relative. This is where we are going to. */
4115 off = (stub_entry->target_value
4116 + stub_entry->target_section->output_offset
4117 + stub_entry->target_section->output_section->vma);
5d1634d7 4118
721956f4
AM		 4119 /* And this is where we are coming from. */
4120 off -= (stub_entry->stub_offset
4121 + stub_sec->output_offset
4122 + stub_sec->output_section->vma);
e86ce104 4123
721956f4 4124 BFD_ASSERT (off + (1 << 25) < (bfd_vma) (1 << 26));
e86ce104 4125
721956f4
AM		 4126 bfd_put_32 (stub_bfd, (bfd_vma) B_DOT | (off & 0x3fffffc), loc);
4127 size = 4;
4128 break;
e86ce104 4129
721956f4
AM		 4130 case ppc_stub_plt_branch:
4131 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
4132 stub_entry->root.string + 9,
4133 false, false);
4134 if (br_entry == NULL)
4135 {
4136 (*_bfd_error_handler) (_("can't find branch stub `%s'"),
4137 stub_entry->root.string + 9);
4138 htab->stub_error = true;
4139 return false;
4140 }
4141
4142 off = (stub_entry->target_value
4143 + stub_entry->target_section->output_offset
4144 + stub_entry->target_section->output_section->vma);
4145
4146 bfd_put_64 (htab->sbrlt->owner, off,
4147 htab->sbrlt->contents + br_entry->offset);
4148
4149 if (info->shared)
4150 {
4151 /* Create a reloc for the branch lookup table entry. */
4152 Elf_Internal_Rela rela;
4153 Elf64_External_Rela *r;
5d1634d7 4154
721956f4
AM		 4155 rela.r_offset = (br_entry->offset
4156 + htab->sbrlt->output_offset
4157 + htab->sbrlt->output_section->vma);
4158 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
4159 rela.r_addend = off;
4160
4161 r = (Elf64_External_Rela *) htab->srelbrlt->contents;
4162 r += htab->srelbrlt->reloc_count++;
4163 bfd_elf64_swap_reloca_out (htab->srelbrlt->owner, &rela, r);
4164 }
4165
4166 off = (br_entry->offset
4167 + htab->sbrlt->output_offset
4168 + htab->sbrlt->output_section->vma
4169 - elf_gp (htab->sbrlt->output_section->owner)
4170 - TOC_BASE_OFF);
4171
4172 if (off + 0x80000000 > 0xffffffff || (off & 7) != 0)
5d1634d7
AM		 4173 {
4174 (*_bfd_error_handler)
e86ce104 4175 (_("linkage table error against `%s'"),
721956f4 4176 stub_entry->root.string);
5d1634d7 4177 bfd_set_error (bfd_error_bad_value);
721956f4 4178 htab->stub_error = true;
5d1634d7
AM		 4179 return false;
4180 }
41bd81ab 4181
721956f4
AM		 4182 indx = off;
4183 bfd_put_32 (stub_bfd, (bfd_vma) ADDIS_R12_R2 | PPC_HA (indx), loc);
4184 bfd_put_32 (stub_bfd, (bfd_vma) LD_R11_0R12 | PPC_LO (indx), loc + 4);
4185 bfd_put_32 (stub_bfd, (bfd_vma) MTCTR_R11, loc + 8);
4186 bfd_put_32 (stub_bfd, (bfd_vma) BCTR, loc + 12);
4187 size = 16;
4188 break;
5d1634d7 4189
721956f4 4190 case ppc_stub_plt_call:
5d1634d7 4191 /* Build the .glink lazy link call stub. */
721956f4
AM		 4192 p = htab->sglink->contents + htab->sglink->_cooked_size;
4193 indx = htab->sglink->reloc_count;
5d1634d7
AM		 4194 if (indx < 0x8000)
4195 {
721956f4 4196 bfd_put_32 (htab->sglink->owner, LI_R0_0 | indx, p);
5d1634d7
AM		 4197 p += 4;
4198 }
4199 else
4200 {
721956f4 4201 bfd_put_32 (htab->sglink->owner, LIS_R0_0 | PPC_HI (indx), p);
5d1634d7 4202 p += 4;
721956f4 4203 bfd_put_32 (htab->sglink->owner, ORI_R0_R0_0 | PPC_LO (indx), p);
5d1634d7
AM		 4204 p += 4;
4205 }
721956f4
AM		 4206 bfd_put_32 (htab->sglink->owner,
4207 B_DOT | ((htab->sglink->contents - p) & 0x3fffffc), p);
5d1634d7 4208 p += 4;
721956f4
AM		 4209 htab->sglink->_cooked_size = p - htab->sglink->contents;
4210 htab->sglink->reloc_count += 1;
4211
c862ae31
AM		 4212 /* Do the best we can for shared libraries built without
4213 exporting ".foo" for each "foo". This can happen when symbol
4214 versioning scripts strip all bar a subset of symbols. */
4215 if (stub_entry->h->oh->root.type != bfd_link_hash_defined
4216 && stub_entry->h->oh->root.type != bfd_link_hash_defweak)
4217 {
4218 /* Point the symbol at the stub. There may be multiple stubs,
4219 we don't really care; The main thing is to make this sym
4220 defined somewhere. */
4221 stub_entry->h->oh->root.type = bfd_link_hash_defined;
4222 stub_entry->h->oh->root.u.def.section = stub_entry->stub_sec;
4223 stub_entry->h->oh->root.u.def.value = stub_entry->stub_offset;
4224 }
4225
721956f4
AM		 4226 /* Now build the stub. */
4227 off = stub_entry->h->elf.plt.offset;
4228 if (off >= (bfd_vma) -2)
4229 abort ();
4230
4231 off &= ~ (bfd_vma) 1;
4232 off += (htab->splt->output_offset
4233 + htab->splt->output_section->vma
4234 - elf_gp (htab->splt->output_section->owner)
4235 - TOC_BASE_OFF);
4236
4237 if (off + 0x80000000 > 0xffffffff || (off & 7) != 0)
4238 {
4239 (*_bfd_error_handler)
4240 (_("linkage table error against `%s'"),
4241 stub_entry->h->elf.root.root.string);
4242 bfd_set_error (bfd_error_bad_value);
4243 htab->stub_error = true;
4244 return false;
4245 }
4246
4247 p = build_plt_stub (stub_bfd, loc, (int) off, 0);
4248 size = p - loc;
4249 break;
4250
4251 default:
4252 BFD_FAIL ();
4253 return false;
4254 }
4255
4256 stub_sec->_cooked_size += size;
4257 return true;
4258}
4259
4260/* As above, but don't actually build the stub. Just bump offset so
4261 we know stub section sizes, and select plt_branch stubs where
4262 long_branch stubs won't do. */
4263
4264static boolean
4265ppc_size_one_stub (gen_entry, in_arg)
4266 struct bfd_hash_entry *gen_entry;
4267 PTR in_arg;
4268{
4269 struct ppc_stub_hash_entry *stub_entry;
4270 struct ppc_link_hash_table *htab;
4271 bfd_vma off;
4272 int size;
4273
4274 /* Massage our args to the form they really have. */
4275 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
4276 htab = (struct ppc_link_hash_table *) in_arg;
4277
4278 if (stub_entry->stub_type == ppc_stub_plt_call)
4279 {
4280 off = stub_entry->h->elf.plt.offset & ~(bfd_vma) 1;
4281 off += (htab->splt->output_offset
4282 + htab->splt->output_section->vma
4283 - elf_gp (htab->splt->output_section->owner)
4284 - TOC_BASE_OFF);
4285
4286 size = 28;
4287 if (PPC_HA ((int) off + 16) != PPC_HA ((int) off))
4288 size += 4;
4289 }
4290 else
4291 {
4292 /* ppc_stub_long_branch or ppc_stub_plt_branch. */
4293 stub_entry->stub_type = ppc_stub_long_branch;
4294 size = 4;
4295
4296 off = (stub_entry->target_value
4297 + stub_entry->target_section->output_offset
4298 + stub_entry->target_section->output_section->vma);
4299 off -= (stub_entry->stub_sec->_raw_size
4300 + stub_entry->stub_sec->output_offset
4301 + stub_entry->stub_sec->output_section->vma);
4302
4303 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
4304 {
4305 struct ppc_branch_hash_entry *br_entry;
4306
4307 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
4308 stub_entry->root.string + 9,
4309 true, false);
4310 if (br_entry == NULL)
4311 {
4312 (*_bfd_error_handler) (_("can't build branch stub `%s'"),
4313 stub_entry->root.string + 9);
4314 htab->stub_error = true;
4315 return false;
4316 }
4317
4318 if (br_entry->iter != htab->stub_iteration)
4319 {
4320 br_entry->iter = htab->stub_iteration;
4321 br_entry->offset = htab->sbrlt->_raw_size;
4322 htab->sbrlt->_raw_size += 8;
4323 }
4324 stub_entry->stub_type = ppc_stub_plt_branch;
4325 size = 16;
4326 }
4327 }
4328
4329 stub_entry->stub_sec->_raw_size += size;
4330 return true;
4331}
4332
4333/* Set up various things so that we can make a list of input sections
4334 for each output section included in the link. Returns -1 on error,
4335 0 when no stubs will be needed, and 1 on success. */
4336
4337int
4338ppc64_elf_setup_section_lists (output_bfd, info)
4339 bfd *output_bfd;
4340 struct bfd_link_info *info;
4341{
4342 bfd *input_bfd;
4343 unsigned int bfd_count;
4344 int top_id, top_index;
4345 asection *section;
4346 asection **input_list, **list;
4347 bfd_size_type amt;
4348 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4349
805fc799
AM		 4350 if (htab->elf.root.creator->flavour != bfd_target_elf_flavour
4351 || htab->sbrlt == NULL)
721956f4
AM		 4352 return 0;
4353
4354 /* Count the number of input BFDs and find the top input section id. */
4355 for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
4356 input_bfd != NULL;
4357 input_bfd = input_bfd->link_next)
4358 {
4359 bfd_count += 1;
4360 for (section = input_bfd->sections;
4361 section != NULL;
4362 section = section->next)
4363 {
4364 if (top_id < section->id)
4365 top_id = section->id;
4366 }
4367 }
4368 htab->bfd_count = bfd_count;
4369
4370 amt = sizeof (struct map_stub) * (top_id + 1);
4371 htab->stub_group = (struct map_stub *) bfd_zmalloc (amt);
4372 if (htab->stub_group == NULL)
4373 return -1;
4374
4375 /* We can't use output_bfd->section_count here to find the top output
4376 section index as some sections may have been removed, and
4377 _bfd_strip_section_from_output doesn't renumber the indices. */
4378 for (section = output_bfd->sections, top_index = 0;
4379 section != NULL;
4380 section = section->next)
4381 {
4382 if (top_index < section->index)
4383 top_index = section->index;
4384 }
4385
4386 htab->top_index = top_index;
4387 amt = sizeof (asection *) * (top_index + 1);
4388 input_list = (asection **) bfd_malloc (amt);
4389 htab->input_list = input_list;
4390 if (input_list == NULL)
4391 return -1;
4392
4393 /* For sections we aren't interested in, mark their entries with a
4394 value we can check later. */
4395 list = input_list + top_index;
4396 do
4397 *list = bfd_abs_section_ptr;
4398 while (list-- != input_list);
4399
4400 for (section = output_bfd->sections;
4401 section != NULL;
4402 section = section->next)
4403 {
4404 if ((section->flags & SEC_CODE) != 0)
4405 input_list[section->index] = NULL;
4406 }
4407
4408 return 1;
4409}
4410
4411/* The linker repeatedly calls this function for each input section,
4412 in the order that input sections are linked into output sections.
4413 Build lists of input sections to determine groupings between which
4414 we may insert linker stubs. */
4415
4416void
805fc799 4417ppc64_elf_next_input_section (info, isec)
721956f4
AM		 4418 struct bfd_link_info *info;
4419 asection *isec;
4420{
4421 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4422
805fc799 4423 if (isec->output_section->index <= htab->top_index)
721956f4
AM		 4424 {
4425 asection **list = htab->input_list + isec->output_section->index;
4426 if (*list != bfd_abs_section_ptr)
4427 {
4428 /* Steal the link_sec pointer for our list. */
4429#define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
4430 /* This happens to make the list in reverse order,
4431 which is what we want. */
4432 PREV_SEC (isec) = *list;
4433 *list = isec;
4434 }
4435 }
4436}
4437
4438/* See whether we can group stub sections together. Grouping stub
4439 sections may result in fewer stubs. More importantly, we need to
4440 put all .init* and .fini* stubs at the beginning of the .init or
4441 .fini output sections respectively, because glibc splits the
4442 _init and _fini functions into multiple parts. Putting a stub in
4443 the middle of a function is not a good idea. */
4444
4445static void
4446group_sections (htab, stub_group_size, stubs_always_before_branch)
4447 struct ppc_link_hash_table *htab;
4448 bfd_size_type stub_group_size;
4449 boolean stubs_always_before_branch;
4450{
4451 asection **list = htab->input_list + htab->top_index;
4452 do
4453 {
4454 asection *tail = *list;
4455 if (tail == bfd_abs_section_ptr)
4456 continue;
4457 while (tail != NULL)
4458 {
4459 asection *curr;
4460 asection *prev;
4461 bfd_size_type total;
4462
4463 curr = tail;
4464 if (tail->_cooked_size)
4465 total = tail->_cooked_size;
4466 else
4467 total = tail->_raw_size;
4468 while ((prev = PREV_SEC (curr)) != NULL
4469 && ((total += curr->output_offset - prev->output_offset)
4470 < stub_group_size))
4471 curr = prev;
4472
4473 /* OK, the size from the start of CURR to the end is less
4474 than stub_group_size and thus can be handled by one stub
4475 section. (or the tail section is itself larger than
4476 stub_group_size, in which case we may be toast.) We
4477 should really be keeping track of the total size of stubs
4478 added here, as stubs contribute to the final output
4479 section size. That's a little tricky, and this way will
4480 only break if stubs added make the total size more than
4481 2^25, ie. for the default stub_group_size, if stubs total
4482 more than 2834432 bytes, or over 100000 plt call stubs. */
4483 do
4484 {
4485 prev = PREV_SEC (tail);
4486 /* Set up this stub group. */
4487 htab->stub_group[tail->id].link_sec = curr;
4488 }
4489 while (tail != curr && (tail = prev) != NULL);
4490
4491 /* But wait, there's more! Input sections up to stub_group_size
4492 bytes before the stub section can be handled by it too. */
4493 if (!stubs_always_before_branch)
4494 {
4495 total = 0;
4496 while (prev != NULL
4497 && ((total += tail->output_offset - prev->output_offset)
4498 < stub_group_size))
4499 {
4500 tail = prev;
4501 prev = PREV_SEC (tail);
4502 htab->stub_group[tail->id].link_sec = curr;
4503 }
4504 }
4505 tail = prev;
4506 }
4507 }
4508 while (list-- != htab->input_list);
4509 free (htab->input_list);
4510#undef PREV_SEC
4511}
4512
4513/* Read in all local syms for all input bfds. */
4514
4515static boolean
4516get_local_syms (input_bfd, htab)
4517 bfd *input_bfd;
4518 struct ppc_link_hash_table *htab;
4519{
4520 unsigned int bfd_indx;
4521 Elf_Internal_Sym *local_syms, **all_local_syms;
4522
4523 /* We want to read in symbol extension records only once. To do this
4524 we need to read in the local symbols in parallel and save them for
4525 later use; so hold pointers to the local symbols in an array. */
4526 bfd_size_type amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
4527 all_local_syms = (Elf_Internal_Sym **) bfd_zmalloc (amt);
4528 htab->all_local_syms = all_local_syms;
4529 if (all_local_syms == NULL)
4530 return false;
4531
4532 /* Walk over all the input BFDs, swapping in local symbols.
4533 If we are creating a shared library, create hash entries for the
4534 export stubs. */
4535 for (bfd_indx = 0;
4536 input_bfd != NULL;
4537 input_bfd = input_bfd->link_next, bfd_indx++)
4538 {
4539 Elf_Internal_Shdr *symtab_hdr;
4540 Elf_Internal_Shdr *shndx_hdr;
4541 Elf_Internal_Sym *isym;
4542 Elf64_External_Sym *ext_syms, *esym, *end_sy;
4543 Elf_External_Sym_Shndx *shndx_buf, *shndx;
4544 bfd_size_type sec_size;
4545
4546 /* We'll need the symbol table in a second. */
4547 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4548 if (symtab_hdr->sh_info == 0)
4549 continue;
4550
4551 /* We need an array of the local symbols attached to the input bfd.
4552 Unfortunately, we're going to have to read & swap them in. */
4553 sec_size = symtab_hdr->sh_info;
4554 sec_size *= sizeof (Elf_Internal_Sym);
4555 local_syms = (Elf_Internal_Sym *) bfd_malloc (sec_size);
4556 if (local_syms == NULL)
4557 return false;
4558
4559 all_local_syms[bfd_indx] = local_syms;
4560 sec_size = symtab_hdr->sh_info;
4561 sec_size *= sizeof (Elf64_External_Sym);
4562 ext_syms = (Elf64_External_Sym *) bfd_malloc (sec_size);
4563 if (ext_syms == NULL)
4564 return false;
4565
4566 if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
4567 || bfd_bread ((PTR) ext_syms, sec_size, input_bfd) != sec_size)
4568 {
4569 error_ret_free_ext_syms:
4570 free (ext_syms);
4571 return false;
4572 }
4573
4574 shndx_buf = NULL;
4575 shndx_hdr = &elf_tdata (input_bfd)->symtab_shndx_hdr;
4576 if (shndx_hdr->sh_size != 0)
4577 {
4578 sec_size = symtab_hdr->sh_info;
4579 sec_size *= sizeof (Elf_External_Sym_Shndx);
4580 shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (sec_size);
4581 if (shndx_buf == NULL)
4582 goto error_ret_free_ext_syms;
4583
4584 if (bfd_seek (input_bfd, shndx_hdr->sh_offset, SEEK_SET) != 0
4585 || bfd_bread ((PTR) shndx_buf, sec_size, input_bfd) != sec_size)
4586 {
4587 free (shndx_buf);
4588 goto error_ret_free_ext_syms;
4589 }
4590 }
4591
4592 /* Swap the local symbols in. */
4593 for (esym = ext_syms, end_sy = esym + symtab_hdr->sh_info,
4594 isym = local_syms, shndx = shndx_buf;
4595 esym < end_sy;
4596 esym++, isym++, shndx = (shndx ? shndx + 1 : NULL))
4597 bfd_elf64_swap_symbol_in (input_bfd, esym, shndx, isym);
4598
4599 /* Now we can free the external symbols. */
4600 free (shndx_buf);
4601 free (ext_syms);
5bd4f169 4602 }
721956f4 4603
5d1634d7
AM		 4604 return true;
4605}
5bd4f169 4606
721956f4
AM		 4607/* Determine and set the size of the stub section for a final link.
4608
4609 The basic idea here is to examine all the relocations looking for
4610 PC-relative calls to a target that is unreachable with a "bl"
4611 instruction. */
4612
4613boolean
4614ppc64_elf_size_stubs (output_bfd, stub_bfd, info, group_size,
4615 add_stub_section, layout_sections_again)
4616 bfd *output_bfd;
4617 bfd *stub_bfd;
4618 struct bfd_link_info *info;
4619 bfd_signed_vma group_size;
4620 asection * (*add_stub_section) PARAMS ((const char *, asection *));
4621 void (*layout_sections_again) PARAMS ((void));
4622{
4623 bfd_size_type stub_group_size;
4624 boolean stubs_always_before_branch;
4625 boolean ret = false;
4626 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4627
4628 /* Stash our params away. */
4629 htab->stub_bfd = stub_bfd;
4630 htab->add_stub_section = add_stub_section;
4631 htab->layout_sections_again = layout_sections_again;
4632 stubs_always_before_branch = group_size < 0;
4633 if (group_size < 0)
4634 stub_group_size = -group_size;
4635 else
4636 stub_group_size = group_size;
4637 if (stub_group_size == 1)
4638 {
4639 /* Default values. */
4640 stub_group_size = 30720000;
4641 if (htab->has_14bit_branch)
4642 stub_group_size = 30000;
4643 }
4644
4645 group_sections (htab, stub_group_size, stubs_always_before_branch);
4646
4647 if (! get_local_syms (info->input_bfds, htab))
4648 {
4649 if (htab->all_local_syms)
4650 goto error_ret_free_local;
4651 return false;
4652 }
4653
4654 while (1)
4655 {
4656 bfd *input_bfd;
4657 unsigned int bfd_indx;
4658 asection *stub_sec;
4659 boolean stub_changed;
4660
4661 htab->stub_iteration += 1;
4662 stub_changed = false;
4663
4664 for (input_bfd = info->input_bfds, bfd_indx = 0;
4665 input_bfd != NULL;
4666 input_bfd = input_bfd->link_next, bfd_indx++)
4667 {
4668 Elf_Internal_Shdr *symtab_hdr;
4669 asection *section;
4670 Elf_Internal_Sym *local_syms;
4671
4672 /* We'll need the symbol table in a second. */
4673 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4674 if (symtab_hdr->sh_info == 0)
4675 continue;
4676
4677 local_syms = htab->all_local_syms[bfd_indx];
4678
4679 /* Walk over each section attached to the input bfd. */
4680 for (section = input_bfd->sections;
4681 section != NULL;
4682 section = section->next)
4683 {
4684 Elf_Internal_Shdr *input_rel_hdr;
4685 Elf64_External_Rela *external_relocs, *erelaend, *erela;
4686 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
4687 bfd_size_type amt;
4688
4689 /* If there aren't any relocs, then there's nothing more
4690 to do. */
4691 if ((section->flags & SEC_RELOC) == 0
4692 || section->reloc_count == 0)
4693 continue;
4694
4695 /* If this section is a link-once section that will be
4696 discarded, then don't create any stubs. */
4697 if (section->output_section == NULL
4698 || section->output_section->owner != output_bfd)
4699 continue;
4700
4701 /* Allocate space for the external relocations. */
4702 amt = section->reloc_count;
4703 amt *= sizeof (Elf64_External_Rela);
4704 external_relocs = (Elf64_External_Rela *) bfd_malloc (amt);
4705 if (external_relocs == NULL)
4706 {
4707 goto error_ret_free_local;
4708 }
4709
4710 /* Likewise for the internal relocations. */
4711 amt = section->reloc_count;
4712 amt *= sizeof (Elf_Internal_Rela);
4713 internal_relocs = (Elf_Internal_Rela *) bfd_malloc (amt);
4714 if (internal_relocs == NULL)
4715 {
4716 free (external_relocs);
4717 goto error_ret_free_local;
4718 }
4719
4720 /* Read in the external relocs. */
4721 input_rel_hdr = &elf_section_data (section)->rel_hdr;
4722 if (bfd_seek (input_bfd, input_rel_hdr->sh_offset, SEEK_SET) != 0
4723 || bfd_bread ((PTR) external_relocs,
4724 input_rel_hdr->sh_size,
4725 input_bfd) != input_rel_hdr->sh_size)
4726 {
4727 free (external_relocs);
4728 error_ret_free_internal:
4729 free (internal_relocs);
4730 goto error_ret_free_local;
4731 }
4732
4733 /* Swap in the relocs. */
4734 erela = external_relocs;
4735 erelaend = erela + section->reloc_count;
4736 irela = internal_relocs;
4737 for (; erela < erelaend; erela++, irela++)
4738 bfd_elf64_swap_reloca_in (input_bfd, erela, irela);
4739
4740 /* We're done with the external relocs, free them. */
4741 free (external_relocs);
4742
4743 /* Now examine each relocation. */
4744 irela = internal_relocs;
4745 irelaend = irela + section->reloc_count;
4746 for (; irela < irelaend; irela++)
4747 {
4748 unsigned int r_type, r_indx;
4749 enum ppc_stub_type stub_type;
4750 struct ppc_stub_hash_entry *stub_entry;
4751 asection *sym_sec;
4752 bfd_vma sym_value;
4753 bfd_vma destination;
4754 struct ppc_link_hash_entry *hash;
4755 char *stub_name;
4756 const asection *id_sec;
4757
4758 r_type = ELF64_R_TYPE (irela->r_info);
4759 r_indx = ELF64_R_SYM (irela->r_info);
4760
4761 if (r_type >= (unsigned int) R_PPC_max)
4762 {
4763 bfd_set_error (bfd_error_bad_value);
4764 goto error_ret_free_internal;
4765 }
4766
4767 /* Only look for stubs on branch instructions. */
4768 if (r_type != (unsigned int) R_PPC64_REL24
4769 && r_type != (unsigned int) R_PPC64_REL14
4770 && r_type != (unsigned int) R_PPC64_REL14_BRTAKEN
4771 && r_type != (unsigned int) R_PPC64_REL14_BRNTAKEN)
4772 continue;
4773
4774 /* Now determine the call target, its name, value,
4775 section. */
4776 sym_sec = NULL;
4777 sym_value = 0;
4778 destination = 0;
4779 hash = NULL;
4780 if (r_indx < symtab_hdr->sh_info)
4781 {
4782 /* It's a local symbol. */
4783 Elf_Internal_Sym *sym;
4784 Elf_Internal_Shdr *hdr;
4785
4786 sym = local_syms + r_indx;
4787 hdr = elf_elfsections (input_bfd)[sym->st_shndx];
4788 sym_sec = hdr->bfd_section;
4789 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
4790 sym_value = sym->st_value;
4791 destination = (sym_value + irela->r_addend
4792 + sym_sec->output_offset
4793 + sym_sec->output_section->vma);
4794 }
4795 else
4796 {
4797 /* It's an external symbol. */
4798 int e_indx;
4799
4800 e_indx = r_indx - symtab_hdr->sh_info;
4801 hash = ((struct ppc_link_hash_entry *)
4802 elf_sym_hashes (input_bfd)[e_indx]);
4803
4804 while (hash->elf.root.type == bfd_link_hash_indirect
4805 || hash->elf.root.type == bfd_link_hash_warning)
4806 hash = ((struct ppc_link_hash_entry *)
4807 hash->elf.root.u.i.link);
4808
4809 if (hash->elf.root.type == bfd_link_hash_defined
4810 || hash->elf.root.type == bfd_link_hash_defweak)
4811 {
4812 sym_sec = hash->elf.root.u.def.section;
4813 sym_value = hash->elf.root.u.def.value;
4814 if (sym_sec->output_section != NULL)
4815 destination = (sym_value + irela->r_addend
4816 + sym_sec->output_offset
4817 + sym_sec->output_section->vma);
4818 }
4819 else if (hash->elf.root.type == bfd_link_hash_undefweak)
4820 ;
4821 else if (hash->elf.root.type == bfd_link_hash_undefined)
4822 ;
4823 else
4824 {
4825 bfd_set_error (bfd_error_bad_value);
4826 goto error_ret_free_internal;
4827 }
4828 }
4829
4830 /* Determine what (if any) linker stub is needed. */
4831 stub_type = ppc_type_of_stub (section, irela, &hash,
4832 destination);
4833 if (stub_type == ppc_stub_none)
4834 continue;
4835
4836 /* Support for grouping stub sections. */
4837 id_sec = htab->stub_group[section->id].link_sec;
4838
4839 /* Get the name of this stub. */
4840 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
4841 if (!stub_name)
4842 goto error_ret_free_internal;
4843
4844 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4845 stub_name, false, false);
4846 if (stub_entry != NULL)
4847 {
4848 /* The proper stub has already been created. */
4849 free (stub_name);
4850 continue;
4851 }
4852
4853 stub_entry = ppc_add_stub (stub_name, section, htab);
4854 if (stub_entry == NULL)
4855 {
4856 free (stub_name);
4857 goto error_ret_free_local;
4858 }
4859
4860 stub_entry->target_value = sym_value;
4861 stub_entry->target_section = sym_sec;
4862 stub_entry->stub_type = stub_type;
4863 stub_entry->h = hash;
4864 stub_changed = true;
4865 }
4866
4867 /* We're done with the internal relocs, free them. */
4868 free (internal_relocs);
4869 }
4870 }
4871
4872 if (!stub_changed)
4873 break;
4874
4875 /* OK, we've added some stubs. Find out the new size of the
4876 stub sections. */
4877 for (stub_sec = htab->stub_bfd->sections;
4878 stub_sec != NULL;
4879 stub_sec = stub_sec->next)
4880 {
4881 stub_sec->_raw_size = 0;
4882 stub_sec->_cooked_size = 0;
4883 }
4884 htab->sbrlt->_raw_size = 0;
4885 htab->sbrlt->_cooked_size = 0;
4886
4887 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, htab);
4888
4889 /* Ask the linker to do its stuff. */
4890 (*htab->layout_sections_again) ();
4891 }
4892
afbe61cf
AM		 4893 /* It would be nice to strip .branch_lt from the output if the
4894 section is empty, but it's too late. If we strip sections here,
4895 the dynamic symbol table is corrupted since the section symbol
4896 for the stripped section isn't written. */
721956f4
AM		 4897
4898 ret = true;
4899
4900 error_ret_free_local:
4901 while (htab->bfd_count-- > 0)
4902 if (htab->all_local_syms[htab->bfd_count])
4903 free (htab->all_local_syms[htab->bfd_count]);
4904 free (htab->all_local_syms);
4905
4906 return ret;
4907}
4908
4909/* Called after we have determined section placement. If sections
805fc799 4910 move, we'll be called again. Provide a value for TOCstart. */
721956f4 4911
805fc799
AM		 4912bfd_vma
4913ppc64_elf_toc (obfd)
5d1634d7 4914 bfd *obfd;
721956f4 4915{
805fc799
AM		 4916 asection *s;
4917 bfd_vma TOCstart;
721956f4 4918
805fc799
AM		 4919 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
4920 order. The TOC starts where the first of these sections starts. */
4921 s = bfd_get_section_by_name (obfd, ".got");
4922 if (s == NULL)
4923 s = bfd_get_section_by_name (obfd, ".toc");
4924 if (s == NULL)
4925 s = bfd_get_section_by_name (obfd, ".tocbss");
4926 if (s == NULL)
4927 s = bfd_get_section_by_name (obfd, ".plt");
4928 if (s == NULL)
4929 {
4930 /* This may happen for
4931 o references to TOC base (SYM@toc / TOC[tc0]) without a
4932 .toc directive
4933 o bad linker script
4934 o --gc-sections and empty TOC sections
4935
4936 FIXME: Warn user? */
4937
4938 /* Look for a likely section. We probably won't even be
4939 using TOCstart. */
4940 for (s = obfd->sections; s != NULL; s = s->next)
4941 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY))
4942 == (SEC_ALLOC | SEC_SMALL_DATA))
4943 break;
721956f4 4944 if (s == NULL)
805fc799
AM		 4945 for (s = obfd->sections; s != NULL; s = s->next)
4946 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA))
4947 == (SEC_ALLOC | SEC_SMALL_DATA))
4948 break;
721956f4 4949 if (s == NULL)
805fc799
AM		 4950 for (s = obfd->sections; s != NULL; s = s->next)
4951 if ((s->flags & (SEC_ALLOC | SEC_READONLY)) == SEC_ALLOC)
4952 break;
721956f4 4953 if (s == NULL)
805fc799
AM		 4954 for (s = obfd->sections; s != NULL; s = s->next)
4955 if ((s->flags & SEC_ALLOC) == SEC_ALLOC)
4956 break;
4957 }
721956f4 4958
805fc799
AM		 4959 TOCstart = 0;
4960 if (s != NULL)
4961 TOCstart = s->output_section->vma + s->output_offset;
721956f4 4962
805fc799 4963 return TOCstart;
721956f4
AM		 4964}
4965
4966/* Build all the stubs associated with the current output file.
4967 The stubs are kept in a hash table attached to the main linker
4968 hash table. This function is called via gldelf64ppc_finish. */
4969
4970boolean
4971ppc64_elf_build_stubs (info)
4972 struct bfd_link_info *info;
5d1634d7
AM		 4973{
4974 struct ppc_link_hash_table *htab = ppc_hash_table (info);
721956f4 4975 asection *stub_sec;
5d1634d7
AM		 4976 bfd_vma plt_r2;
4977 bfd_byte *p;
4978
721956f4
AM		 4979 for (stub_sec = htab->stub_bfd->sections;
4980 stub_sec != NULL;
4981 stub_sec = stub_sec->next)
4982 {
4983 bfd_size_type size;
4984
4985 /* Allocate memory to hold the linker stubs. */
4986 size = stub_sec->_raw_size;
4987 if (size != 0)
4988 {
4989 stub_sec->contents = (bfd_byte *) bfd_zalloc (htab->stub_bfd, size);
4990 if (stub_sec->contents == NULL)
4991 return false;
4992 }
4993 stub_sec->_cooked_size = 0;
4994 }
5d1634d7 4995
721956f4 4996 if (htab->splt != NULL)
5d1634d7 4997 {
721956f4
AM		 4998 /* Build the .glink plt call stub. */
4999 plt_r2 = (htab->splt->output_offset
5000 + htab->splt->output_section->vma
5001 - elf_gp (htab->splt->output_section->owner)
5002 - TOC_BASE_OFF);
5003 p = htab->sglink->contents;
5004 p = build_plt_stub (htab->sglink->owner, p, (int) plt_r2, 1);
5005 while (p - htab->sglink->contents < GLINK_CALL_STUB_SIZE)
5006 {
5007 bfd_put_32 (htab->sglink->owner, NOP, p);
5008 p += 4;
5009 }
5010 htab->sglink->_cooked_size = p - htab->sglink->contents;
5011
5012 /* Use reloc_count to count entries. */
5013 htab->sglink->reloc_count = 0;
5d1634d7 5014 }
5d1634d7 5015
721956f4
AM		 5016 if (htab->sbrlt->_raw_size != 0)
5017 {
5018 htab->sbrlt->contents = (bfd_byte *) bfd_zalloc (htab->sbrlt->owner,
5019 htab->sbrlt->_raw_size);
5020 if (htab->sbrlt->contents == NULL)
5021 return false;
5022 }
5d1634d7 5023
721956f4
AM		 5024 /* Build the stubs as directed by the stub hash table. */
5025 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
5d1634d7
AM		 5026 htab->sglink->reloc_count = 0;
5027
721956f4
AM		 5028 for (stub_sec = htab->stub_bfd->sections;
5029 stub_sec != NULL;
5030 stub_sec = stub_sec->next)
5031 {
5032 if (stub_sec->_raw_size != stub_sec->_cooked_size)
5033 break;
5034 }
5d1634d7 5035
721956f4 5036 if (stub_sec != NULL
5d1634d7
AM		 5037 || htab->sglink->_raw_size != htab->sglink->_cooked_size)
5038 {
721956f4
AM		 5039 htab->stub_error = true;
5040 (*_bfd_error_handler) (_("stubs don't match calculated size"));
5d1634d7 5041 }
721956f4
AM		 5042
5043 return !htab->stub_error;
5bd4f169
AM		 5044}
5045
5046/* Set up any other section flags and such that may be necessary. */
5047
5048static boolean
5049ppc64_elf_fake_sections (abfd, shdr, asect)
5050 bfd *abfd ATTRIBUTE_UNUSED;
5051 Elf64_Internal_Shdr *shdr;
5052 asection *asect;
5053{
5054 if ((asect->flags & SEC_EXCLUDE) != 0)
5055 shdr->sh_flags |= SHF_EXCLUDE;
5056
5057 if ((asect->flags & SEC_SORT_ENTRIES) != 0)
5058 shdr->sh_type = SHT_ORDERED;
5059
5060 return true;
5061}
5062
5063/* The RELOCATE_SECTION function is called by the ELF backend linker
5064 to handle the relocations for a section.
5065
5066 The relocs are always passed as Rela structures; if the section
5067 actually uses Rel structures, the r_addend field will always be
5068 zero.
5069
5070 This function is responsible for adjust the section contents as
5071 necessary, and (if using Rela relocs and generating a
5072 relocateable output file) adjusting the reloc addend as
5073 necessary.
5074
5075 This function does not have to worry about setting the reloc
5076 address or the reloc symbol index.
5077
5078 LOCAL_SYMS is a pointer to the swapped in local symbols.
5079
5080 LOCAL_SECTIONS is an array giving the section in the input file
5081 corresponding to the st_shndx field of each local symbol.
5082
5083 The global hash table entry for the global symbols can be found
5084 via elf_sym_hashes (input_bfd).
5085
5086 When generating relocateable output, this function must handle
5087 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
5088 going to be the section symbol corresponding to the output
5089 section, which means that the addend must be adjusted
5090 accordingly. */
5091
5092static boolean
5093ppc64_elf_relocate_section (output_bfd, info, input_bfd, input_section,
5094 contents, relocs, local_syms, local_sections)
5095 bfd *output_bfd;
5096 struct bfd_link_info *info;
5097 bfd *input_bfd;
5098 asection *input_section;
5099 bfd_byte *contents;
5100 Elf_Internal_Rela *relocs;
5101 Elf_Internal_Sym *local_syms;
5102 asection **local_sections;
5103{
65f38f15 5104 struct ppc_link_hash_table *htab;
5bd4f169
AM		 5105 Elf_Internal_Shdr *symtab_hdr;
5106 struct elf_link_hash_entry **sym_hashes;
5bd4f169
AM		 5107 Elf_Internal_Rela *rel;
5108 Elf_Internal_Rela *relend;
5bd4f169
AM		 5109 bfd_vma *local_got_offsets;
5110 bfd_vma TOCstart;
5111 boolean ret = true;
41bd81ab 5112 boolean is_opd;
96e0dda4
AM		 5113 /* Disabled until we sort out how ld should choose 'y' vs 'at'. */
5114 boolean is_power4 = false;
5bd4f169 5115
b491616a
AM		 5116 if (info->relocateable)
5117 return true;
5118
65f38f15 5119 /* Initialize howto table if needed. */
5bd4f169 5120 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5bd4f169
AM		 5121 ppc_howto_init ();
5122
65f38f15 5123 htab = ppc_hash_table (info);
5bd4f169 5124 local_got_offsets = elf_local_got_offsets (input_bfd);
5bd4f169 5125 TOCstart = elf_gp (output_bfd);
5bd4f169
AM		 5126 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5127 sym_hashes = elf_sym_hashes (input_bfd);
41bd81ab 5128 is_opd = strcmp (bfd_get_section_name (abfd, input_section), ".opd") == 0;
65f38f15 5129
5bd4f169
AM		 5130 rel = relocs;
5131 relend = relocs + input_section->reloc_count;
5132 for (; rel < relend; rel++)
5133 {
5134 enum elf_ppc_reloc_type r_type;
5135 bfd_vma offset;
5136 bfd_vma addend;
5137 bfd_reloc_status_type r;
5138 Elf_Internal_Sym *sym;
5139 asection *sec;
5140 struct elf_link_hash_entry *h;
721956f4 5141 struct elf_link_hash_entry *fdh;
5bd4f169 5142 const char *sym_name;
5bd4f169
AM		 5143 unsigned long r_symndx;
5144 bfd_vma relocation;
65f38f15 5145 boolean unresolved_reloc;
ef60b7ff 5146 boolean warned;
dc810e39 5147 long insn;
721956f4
AM		 5148 struct ppc_stub_hash_entry *stub_entry;
5149 bfd_vma max_br_offset;
5150 bfd_vma from;
5bd4f169
AM		 5151
5152 r_type = (enum elf_ppc_reloc_type) ELF64_R_TYPE (rel->r_info);
5bd4f169 5153 r_symndx = ELF64_R_SYM (rel->r_info);
65f38f15
AM		 5154 offset = rel->r_offset;
5155 addend = rel->r_addend;
5156 r = bfd_reloc_other;
5157 sym = (Elf_Internal_Sym *) 0;
5158 sec = (asection *) 0;
5159 h = (struct elf_link_hash_entry *) 0;
5160 sym_name = (const char *) 0;
5161 unresolved_reloc = false;
ef60b7ff 5162 warned = false;
65f38f15 5163
5bd4f169
AM		 5164 if (r_type == R_PPC64_TOC)
5165 {
5166 /* Relocation value is TOC base. Symbol is ignored. */
5167 relocation = TOCstart + TOC_BASE_OFF;
5168 }
5169 else if (r_symndx < symtab_hdr->sh_info)
5170 {
5171 /* It's a local symbol. */
5172 sym = local_syms + r_symndx;
5173 sec = local_sections[r_symndx];
5174 sym_name = "<local symbol>";
5175
f8df10f4 5176 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
f46c2da6
AM		 5177 /* rel may have changed, update our copy of addend. */
5178 addend = rel->r_addend;
5bd4f169
AM		 5179 }
5180 else
5181 {
5182 /* It's a global symbol. */
5183 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5184 while (h->root.type == bfd_link_hash_indirect
5185 || h->root.type == bfd_link_hash_warning)
5186 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5187 sym_name = h->root.root.string;
65f38f15 5188 relocation = 0;
5bd4f169
AM		 5189 if (h->root.type == bfd_link_hash_defined
5190 || h->root.type == bfd_link_hash_defweak)
5191 {
5192 sec = h->root.u.def.section;
65f38f15
AM		 5193 if (sec->output_section == NULL)
5194 /* Set a flag that will be cleared later if we find a
5195 relocation value for this symbol. output_section
5196 is typically NULL for symbols satisfied by a shared
5197 library. */
5198 unresolved_reloc = true;
5bd4f169
AM		 5199 else
5200 relocation = (h->root.u.def.value
5201 + sec->output_section->vma
5202 + sec->output_offset);
5203 }
5204 else if (h->root.type == bfd_link_hash_undefweak)
65f38f15 5205 ;
671bae9c 5206 else if (info->shared
65f38f15
AM		 5207 && (!info->symbolic || info->allow_shlib_undefined)
5208 && !info->no_undefined
5209 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
5210 ;
5bd4f169
AM		 5211 else
5212 {
5213 if (! ((*info->callbacks->undefined_symbol)
5214 (info, h->root.root.string, input_bfd, input_section,
65f38f15
AM		 5215 offset, (!info->shared
5216 || info->no_undefined
5217 || ELF_ST_VISIBILITY (h->other)))))
5bd4f169 5218 return false;
ef60b7ff 5219 warned = true;
5bd4f169
AM		 5220 }
5221 }
5222
65f38f15 5223 /* First handle relocations that tweak non-addend part of insn. */
86c76c7b 5224 insn = 0;
65f38f15 5225 switch (r_type)
5bd4f169
AM		 5226 {
5227 default:
65f38f15 5228 break;
5bd4f169 5229
65f38f15
AM		 5230 /* Branch taken prediction relocations. */
5231 case R_PPC64_ADDR14_BRTAKEN:
5232 case R_PPC64_REL14_BRTAKEN:
96e0dda4 5233 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
86c76c7b 5234 /* Fall thru. */
65f38f15 5235
86c76c7b 5236 /* Branch not taken prediction relocations. */
65f38f15
AM		 5237 case R_PPC64_ADDR14_BRNTAKEN:
5238 case R_PPC64_REL14_BRNTAKEN:
86c76c7b 5239 insn |= bfd_get_32 (output_bfd, contents + offset) & ~(0x01 << 21);
96e0dda4
AM		 5240 if (is_power4)
5241 {
5242 /* Set 'a' bit. This is 0b00010 in BO field for branch
5243 on CR(BI) insns (BO == 001at or 011at), and 0b01000
5244 for branch on CTR insns (BO == 1a00t or 1a01t). */
5245 if ((insn & (0x14 << 21)) == (0x04 << 21))
5246 insn |= 0x02 << 21;
5247 else if ((insn & (0x14 << 21)) == (0x10 << 21))
5248 insn |= 0x08 << 21;
5249 else
5250 break;
5251 }
65f38f15 5252 else
96e0dda4 5253 {
805fc799
AM		 5254 from = (offset
5255 + input_section->output_offset
5256 + input_section->output_section->vma);
5257
96e0dda4 5258 /* Invert 'y' bit if not the default. */
805fc799 5259 if ((bfd_signed_vma) (relocation + addend - from) < 0)
96e0dda4
AM		 5260 insn ^= 0x01 << 21;
5261 }
86c76c7b 5262
65f38f15
AM		 5263 bfd_put_32 (output_bfd, (bfd_vma) insn, contents + offset);
5264 break;
5bd4f169 5265
65f38f15 5266 case R_PPC64_REL24:
721956f4
AM		 5267 /* A REL24 branching to a linkage function is followed by a
5268 nop. We replace the nop with a ld in order to restore
5269 the TOC base pointer. Only calls to shared objects need
5270 to alter the TOC base. These are recognized by their
5271 need for a PLT entry. */
5bd4f169 5272 if (h != NULL
721956f4
AM		 5273 && (fdh = ((struct ppc_link_hash_entry *) h)->oh) != NULL
5274 && fdh->plt.offset != (bfd_vma) -1
5275 && (stub_entry = ppc_get_stub_entry (input_section, sec, fdh,
5276 rel, htab)) != NULL)
41bd81ab 5277 {
721956f4
AM		 5278 boolean can_plt_call = 0;
5279
41bd81ab
AM		 5280 if (offset + 8 <= input_section->_cooked_size)
5281 {
721956f4
AM		 5282 insn = bfd_get_32 (input_bfd, contents + offset + 4);
5283 if (insn == NOP
5284 || insn == CROR_151515 || insn == CROR_313131)
41bd81ab 5285 {
721956f4
AM		 5286 bfd_put_32 (input_bfd, (bfd_vma) LD_R2_40R1,
5287 contents + offset + 4);
5288 can_plt_call = 1;
41bd81ab 5289 }
5bd4f169 5290 }
721956f4
AM		 5291
5292 if (!can_plt_call)
5293 {
5294 /* If this is a plain branch rather than a branch
5295 and link, don't require a nop. */
5296 insn = bfd_get_32 (input_bfd, contents + offset);
5297 if ((insn & 1) == 0)
5298 can_plt_call = 1;
5299 }
5300
5301 if (can_plt_call)
5302 {
5303 relocation = (stub_entry->stub_offset
5304 + stub_entry->stub_sec->output_offset
5305 + stub_entry->stub_sec->output_section->vma);
5306 addend = 0;
5307 unresolved_reloc = false;
5308 }
5bd4f169 5309 }
e86ce104
AM		 5310
5311 if (h != NULL
5312 && h->root.type == bfd_link_hash_undefweak
721956f4
AM		 5313 && relocation == 0
5314 && addend == 0)
e86ce104 5315 {
721956f4
AM		 5316 /* Tweak calls to undefined weak functions to point at a
5317 blr. We can thus call a weak function without first
5318 checking whether the function is defined. We have a
5319 blr at the end of .sfpr. */
805fc799 5320 BFD_ASSERT (htab->sfpr->_raw_size != 0);
721956f4
AM		 5321 relocation = (htab->sfpr->_raw_size - 4
5322 + htab->sfpr->output_offset
5323 + htab->sfpr->output_section->vma);
5324 from = (offset
5325 + input_section->output_offset
5326 + input_section->output_section->vma);
805fc799 5327
721956f4
AM		 5328 /* But let's not be silly about it. If the blr isn't in
5329 reach, just go to the next instruction. */
805fc799
AM		 5330 if (relocation - from + (1 << 25) >= (1 << 26)
5331 || htab->sfpr->_raw_size == 0)
721956f4 5332 relocation = from + 4;
e86ce104 5333 }
65f38f15
AM		 5334 break;
5335 }
5bd4f169 5336
65f38f15
AM		 5337 /* Set `addend'. */
5338 switch (r_type)
5339 {
5340 default:
5341 (*_bfd_error_handler)
5342 (_("%s: unknown relocation type %d for symbol %s"),
5343 bfd_archive_filename (input_bfd), (int) r_type, sym_name);
5bd4f169 5344
65f38f15
AM		 5345 bfd_set_error (bfd_error_bad_value);
5346 ret = false;
5347 continue;
5bd4f169 5348
65f38f15
AM		 5349 case R_PPC64_NONE:
5350 case R_PPC_GNU_VTINHERIT:
5351 case R_PPC_GNU_VTENTRY:
5352 continue;
5bd4f169
AM		 5353
5354 /* GOT16 relocations. Like an ADDR16 using the symbol's
5355 address in the GOT as relocation value instead of the
5356 symbols value itself. Also, create a GOT entry for the
5357 symbol and put the symbol value there. */
65f38f15
AM		 5358 case R_PPC64_GOT16:
5359 case R_PPC64_GOT16_LO:
5360 case R_PPC64_GOT16_HI:
5361 case R_PPC64_GOT16_HA:
5362 case R_PPC64_GOT16_DS:
5363 case R_PPC64_GOT16_LO_DS:
5bd4f169
AM		 5364 {
5365 /* Relocation is to the entry for this symbol in the global
5366 offset table. */
5367 bfd_vma off;
65f38f15
AM		 5368
5369 if (htab->sgot == NULL)
5370 abort ();
5bd4f169
AM		 5371
5372 if (h != NULL)
5373 {
65f38f15 5374 boolean dyn;
5bd4f169 5375
65f38f15
AM		 5376 off = h->got.offset;
5377 dyn = htab->elf.dynamic_sections_created;
5378 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
5bd4f169 5379 || (info->shared
65f38f15
AM		 5380 && (info->symbolic
5381 || h->dynindx == -1
5382 || (h->elf_link_hash_flags
5383 & ELF_LINK_FORCED_LOCAL))
5bd4f169
AM		 5384 && (h->elf_link_hash_flags
5385 & ELF_LINK_HASH_DEF_REGULAR)))
5386 {
5387 /* This is actually a static link, or it is a
5388 -Bsymbolic link and the symbol is defined
65f38f15
AM		 5389 locally, or the symbol was forced to be local
5390 because of a version file. We must initialize
5391 this entry in the global offset table. Since the
5392 offset must always be a multiple of 8, we use the
5393 least significant bit to record whether we have
5bd4f169
AM		 5394 initialized it already.
5395
65f38f15 5396 When doing a dynamic link, we create a .rel.got
5bd4f169
AM		 5397 relocation entry to initialize the value. This
5398 is done in the finish_dynamic_symbol routine. */
5399 if ((off & 1) != 0)
5400 off &= ~1;
5401 else
5402 {
5403 bfd_put_64 (output_bfd, relocation,
65f38f15 5404 htab->sgot->contents + off);
5bd4f169
AM		 5405 h->got.offset |= 1;
5406 }
5407 }
65f38f15
AM		 5408 else
5409 unresolved_reloc = false;
5bd4f169
AM		 5410 }
5411 else
5412 {
65f38f15
AM		 5413 if (local_got_offsets == NULL)
5414 abort ();
5bd4f169
AM		 5415
5416 off = local_got_offsets[r_symndx];
5417
65f38f15 5418 /* The offset must always be a multiple of 8. We use
5bd4f169
AM		 5419 the least significant bit to record whether we have
5420 already processed this entry. */
5421 if ((off & 1) != 0)
5422 off &= ~1;
5423 else
5424 {
65f38f15
AM		 5425 bfd_put_64 (output_bfd, relocation,
5426 htab->sgot->contents + off);
5bd4f169
AM		 5427
5428 if (info->shared)
5429 {
5bd4f169 5430 Elf_Internal_Rela outrel;
65f38f15 5431 Elf64_External_Rela *loc;
5bd4f169
AM		 5432
5433 /* We need to generate a R_PPC64_RELATIVE reloc
5434 for the dynamic linker. */
65f38f15
AM		 5435 outrel.r_offset = (htab->sgot->output_section->vma
5436 + htab->sgot->output_offset
5bd4f169
AM		 5437 + off);
5438 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
5439 outrel.r_addend = relocation;
65f38f15
AM		 5440 loc = (Elf64_External_Rela *) htab->srelgot->contents;
5441 loc += htab->srelgot->reloc_count++;
5442 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
5bd4f169
AM		 5443 }
5444
5445 local_got_offsets[r_symndx] |= 1;
5446 }
5447 }
5448
65f38f15
AM		 5449 if (off >= (bfd_vma) -2)
5450 abort ();
5451
5452 relocation = htab->sgot->output_offset + off;
5453
5bd4f169
AM		 5454 /* TOC base (r2) is TOC start plus 0x8000. */
5455 addend -= TOC_BASE_OFF;
5bd4f169 5456 }
65f38f15
AM		 5457 break;
5458
5459 case R_PPC64_PLT16_HA:
5460 case R_PPC64_PLT16_HI:
5461 case R_PPC64_PLT16_LO:
5462 case R_PPC64_PLT32:
5463 case R_PPC64_PLT64:
5464 /* Relocation is to the entry for this symbol in the
5465 procedure linkage table. */
5466
5467 /* Resolve a PLT reloc against a local symbol directly,
5468 without using the procedure linkage table. */
5469 if (h == NULL)
5470 break;
5471
5472 if (h->plt.offset == (bfd_vma) -1
5473 || htab->splt == NULL)
5474 {
5475 /* We didn't make a PLT entry for this symbol. This
5476 happens when statically linking PIC code, or when
5477 using -Bsymbolic. */
5478 break;
5479 }
5480
5481 relocation = (htab->splt->output_section->vma
5482 + htab->splt->output_offset
5483 + h->plt.offset);
5484 unresolved_reloc = false;
5485 break;
5bd4f169
AM		 5486
5487 /* TOC16 relocs. We want the offset relative to the TOC base,
5488 which is the address of the start of the TOC plus 0x8000.
5489 The TOC consists of sections .got, .toc, .tocbss, and .plt,
5490 in this order. */
65f38f15
AM		 5491 case R_PPC64_TOC16:
5492 case R_PPC64_TOC16_LO:
5493 case R_PPC64_TOC16_HI:
5494 case R_PPC64_TOC16_DS:
5495 case R_PPC64_TOC16_LO_DS:
5496 case R_PPC64_TOC16_HA:
5bd4f169 5497 addend -= TOCstart + TOC_BASE_OFF;
5bd4f169
AM		 5498 break;
5499
5500 /* Relocate against the beginning of the section. */
65f38f15
AM		 5501 case R_PPC64_SECTOFF:
5502 case R_PPC64_SECTOFF_LO:
5503 case R_PPC64_SECTOFF_HI:
5504 case R_PPC64_SECTOFF_DS:
5505 case R_PPC64_SECTOFF_LO_DS:
5506 case R_PPC64_SECTOFF_HA:
5507 if (sec != (asection *) 0)
5508 addend -= sec->output_section->vma;
5bd4f169
AM		 5509 break;
5510
721956f4
AM		 5511 case R_PPC64_REL14:
5512 case R_PPC64_REL14_BRNTAKEN:
5513 case R_PPC64_REL14_BRTAKEN:
5d1634d7
AM		 5514 case R_PPC64_REL24:
5515 break;
5516
65f38f15
AM		 5517 /* Relocations that may need to be propagated if this is a
5518 dynamic object. */
65f38f15
AM		 5519 case R_PPC64_REL32:
5520 case R_PPC64_REL64:
5521 case R_PPC64_ADDR14:
5522 case R_PPC64_ADDR14_BRNTAKEN:
5523 case R_PPC64_ADDR14_BRTAKEN:
5524 case R_PPC64_ADDR16:
5525 case R_PPC64_ADDR16_DS:
5526 case R_PPC64_ADDR16_HA:
5527 case R_PPC64_ADDR16_HI:
5528 case R_PPC64_ADDR16_HIGHER:
5529 case R_PPC64_ADDR16_HIGHERA:
5530 case R_PPC64_ADDR16_HIGHEST:
5531 case R_PPC64_ADDR16_HIGHESTA:
5532 case R_PPC64_ADDR16_LO:
5533 case R_PPC64_ADDR16_LO_DS:
5534 case R_PPC64_ADDR24:
5535 case R_PPC64_ADDR30:
5536 case R_PPC64_ADDR32:
5537 case R_PPC64_ADDR64:
5538 case R_PPC64_UADDR16:
5539 case R_PPC64_UADDR32:
5540 case R_PPC64_UADDR64:
ec338859
AM		 5541 /* r_symndx will be zero only for relocs against symbols
5542 from removed linkonce sections, or sections discarded by
5543 a linker script. */
5d1634d7
AM		 5544 if (r_symndx == 0)
5545 break;
5546 /* Fall thru. */
5547
5548 case R_PPC64_TOC:
5549 if ((input_section->flags & SEC_ALLOC) == 0)
ec338859
AM		 5550 break;
5551
41bd81ab
AM		 5552 if (NO_OPD_RELOCS && is_opd)
5553 break;
5554
65f38f15 5555 if ((info->shared
65f38f15
AM		 5556 && (IS_ABSOLUTE_RELOC (r_type)
5557 || (h != NULL
5558 && h->dynindx != -1
5559 && (! info->symbolic
5560 || (h->elf_link_hash_flags
5561 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
5562 || (!info->shared
65f38f15
AM		 5563 && h != NULL
5564 && h->dynindx != -1
5565 && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
5566 && (((h->elf_link_hash_flags
5567 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
5568 && (h->elf_link_hash_flags
5569 & ELF_LINK_HASH_DEF_REGULAR) == 0)
5570 || h->root.type == bfd_link_hash_undefweak
5571 || h->root.type == bfd_link_hash_undefined)))
5572 {
5573 Elf_Internal_Rela outrel;
5574 boolean skip, relocate;
5575 asection *sreloc;
5576 Elf64_External_Rela *loc;
5577
5578 /* When generating a dynamic object, these relocations
5579 are copied into the output file to be resolved at run
5580 time. */
5581
5582 skip = false;
0bb2d96a 5583 relocate = false;
65f38f15 5584
c629eae0
JJ		 5585 outrel.r_offset =
5586 _bfd_elf_section_offset (output_bfd, info, input_section,
5587 rel->r_offset);
5588 if (outrel.r_offset == (bfd_vma) -1)
5589 skip = true;
0bb2d96a
JJ		 5590 else if (outrel.r_offset == (bfd_vma) -2)
5591 skip = true, relocate = true;
65f38f15
AM		 5592 outrel.r_offset += (input_section->output_section->vma
5593 + input_section->output_offset);
5594 outrel.r_addend = addend;
5595
5596 if (skip)
0bb2d96a 5597 memset (&outrel, 0, sizeof outrel);
65f38f15
AM		 5598 else if (h != NULL
5599 && h->dynindx != -1
41bd81ab 5600 && !is_opd
65f38f15
AM		 5601 && (!IS_ABSOLUTE_RELOC (r_type)
5602 || !info->shared
5603 || !info->symbolic
5604 || (h->elf_link_hash_flags
5605 & ELF_LINK_HASH_DEF_REGULAR) == 0))
0bb2d96a 5606 outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
65f38f15
AM		 5607 else
5608 {
41bd81ab
AM		 5609 /* This symbol is local, or marked to become local,
5610 or this is an opd section reloc which must point
5611 at a local function. */
65f38f15
AM		 5612 outrel.r_addend += relocation;
5613 relocate = true;
e86ce104 5614 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
65f38f15 5615 {
afbe61cf
AM		 5616 if (is_opd && h != NULL && info->shared)
5617 {
5618 /* Lie about opd entries. This case occurs
5619 when building shared libraries and we
5620 reference a function in another shared
5621 lib. In that case we won't use the opd
5622 entry in this lib; We ought to edit the
5623 opd section to remove unused entries. */
5624 unresolved_reloc = false;
5625 }
65f38f15
AM		 5626 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
5627 }
5628 else
5629 {
5630 long indx = 0;
5631
41bd81ab 5632 if (bfd_is_abs_section (sec))
65f38f15
AM		 5633 ;
5634 else if (sec == NULL || sec->owner == NULL)
5635 {
5636 bfd_set_error (bfd_error_bad_value);
5637 return false;
5638 }
5639 else
5640 {
5641 asection *osec;
5642
5643 osec = sec->output_section;
5644 indx = elf_section_data (osec)->dynindx;
5645
5646 /* We are turning this relocation into one
5647 against a section symbol, so subtract out
5648 the output section's address but not the
5649 offset of the input section in the output
5650 section. */
5651 outrel.r_addend -= osec->vma;
5652 }
5653
5654 outrel.r_info = ELF64_R_INFO (indx, r_type);
5655 }
5656 }
5657
5658 sreloc = elf_section_data (input_section)->sreloc;
5659 if (sreloc == NULL)
5660 abort ();
5661
5662 loc = (Elf64_External_Rela *) sreloc->contents;
5663 loc += sreloc->reloc_count++;
5664 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
5665
5666 /* If this reloc is against an external symbol, it will
5667 be computed at runtime, so there's no need to do
5668 anything now. */
5669 if (! relocate)
5670 continue;
5671 }
5bd4f169
AM		 5672 break;
5673
65f38f15
AM		 5674 case R_PPC64_COPY:
5675 case R_PPC64_GLOB_DAT:
5676 case R_PPC64_JMP_SLOT:
5677 case R_PPC64_RELATIVE:
5678 /* We shouldn't ever see these dynamic relocs in relocatable
5679 files. */
5680 /* Fall thru */
5681
5682 case R_PPC64_PLTGOT16:
5683 case R_PPC64_PLTGOT16_DS:
5684 case R_PPC64_PLTGOT16_HA:
5685 case R_PPC64_PLTGOT16_HI:
5686 case R_PPC64_PLTGOT16_LO:
5687 case R_PPC64_PLTGOT16_LO_DS:
5688 case R_PPC64_PLTREL32:
5689 case R_PPC64_PLTREL64:
5690 /* These ones haven't been implemented yet. */
5691
5692 (*_bfd_error_handler)
5693 (_("%s: Relocation %s is not supported for symbol %s."),
5694 bfd_archive_filename (input_bfd),
5695 ppc64_elf_howto_table[(int) r_type]->name, sym_name);
5bd4f169
AM		 5696
5697 bfd_set_error (bfd_error_invalid_operation);
5698 ret = false;
5699 continue;
65f38f15 5700 }
5bd4f169 5701
65f38f15
AM		 5702 /* Do any further special processing. */
5703 switch (r_type)
5704 {
5705 default:
5706 break;
5707
5708 case R_PPC64_ADDR16_HA:
5709 case R_PPC64_ADDR16_HIGHERA:
5710 case R_PPC64_ADDR16_HIGHESTA:
5711 case R_PPC64_PLT16_HA:
5712 case R_PPC64_TOC16_HA:
5713 case R_PPC64_SECTOFF_HA:
5714 /* It's just possible that this symbol is a weak symbol
5715 that's not actually defined anywhere. In that case,
5716 'sec' would be NULL, and we should leave the symbol
5717 alone (it will be set to zero elsewhere in the link). */
5718 if (sec != NULL)
5719 /* Add 0x10000 if sign bit in 0:15 is set. */
5720 addend += ((relocation + addend) & 0x8000) << 1;
5721 break;
5722
5723 case R_PPC64_ADDR16_DS:
5724 case R_PPC64_ADDR16_LO_DS:
5725 case R_PPC64_GOT16_DS:
5726 case R_PPC64_GOT16_LO_DS:
5727 case R_PPC64_PLT16_LO_DS:
5728 case R_PPC64_SECTOFF_DS:
5729 case R_PPC64_SECTOFF_LO_DS:
5730 case R_PPC64_TOC16_DS:
5731 case R_PPC64_TOC16_LO_DS:
5732 case R_PPC64_PLTGOT16_DS:
5733 case R_PPC64_PLTGOT16_LO_DS:
5734 if (((relocation + addend) & 3) != 0)
5735 {
5736 (*_bfd_error_handler)
5737 (_("%s: error: relocation %s not a multiple of 4"),
5738 bfd_archive_filename (input_bfd),
5739 ppc64_elf_howto_table[(int) r_type]->name);
5740 bfd_set_error (bfd_error_bad_value);
5741 ret = false;
5742 continue;
5743 }
5744 break;
721956f4
AM		 5745
5746 case R_PPC64_REL14:
5747 case R_PPC64_REL14_BRNTAKEN:
5748 case R_PPC64_REL14_BRTAKEN:
5749 max_br_offset = 1 << 15;
5750 goto branch_check;
5751
5752 case R_PPC64_REL24:
5753 max_br_offset = 1 << 25;
5754
5755 branch_check:
5756 /* If the branch is out of reach, then redirect the
5757 call to the local stub for this function. */
5758 from = (offset
5759 + input_section->output_offset
5760 + input_section->output_section->vma);
5761 if (relocation + addend - from + max_br_offset >= 2 * max_br_offset
5762 && (stub_entry = ppc_get_stub_entry (input_section, sec, h,
5763 rel, htab)) != NULL)
5764 {
5765 /* Munge up the value and addend so that we call the stub
5766 rather than the procedure directly. */
5767 relocation = (stub_entry->stub_offset
5768 + stub_entry->stub_sec->output_offset
5769 + stub_entry->stub_sec->output_section->vma);
5770 addend = 0;
5771 }
5772 break;
5bd4f169
AM		 5773 }
5774
65f38f15
AM		 5775 /* FIXME: Why do we allow debugging sections to escape this error?
5776 More importantly, why do we not emit dynamic relocs above in
5777 debugging sections (which are ! SEC_ALLOC)? If we had
5778 emitted the dynamic reloc, we could remove the fudge here. */
5779 if (unresolved_reloc
5780 && !(info->shared
5781 && (input_section->flags & SEC_DEBUGGING) != 0
5782 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
9c07fe7c
AM		 5783 {
5784 (*_bfd_error_handler)
5785 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
5786 bfd_archive_filename (input_bfd),
5787 bfd_get_section_name (input_bfd, input_section),
5788 (long) rel->r_offset,
5789 h->root.root.string);
5790 ret = false;
5791 }
5bd4f169 5792
65f38f15 5793 r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
5bd4f169
AM		 5794 input_bfd,
5795 input_section,
5796 contents,
5797 offset,
5798 relocation,
5799 addend);
5800
ef60b7ff 5801 if (r != bfd_reloc_ok)
5bd4f169
AM		 5802 {
5803 const char *name;
5804
5805 if (h != NULL)
5806 {
5807 if (h->root.type == bfd_link_hash_undefweak
65f38f15 5808 && ppc64_elf_howto_table[(int) r_type]->pc_relative)
5bd4f169
AM		 5809 {
5810 /* Assume this is a call protected by other code that
5811 detects the symbol is undefined. If this is the case,
5812 we can safely ignore the overflow. If not, the
5813 program is hosed anyway, and a little warning isn't
5814 going to help. */
5815
5816 continue;
5817 }
5818
5819 name = h->root.root.string;
5820 }
5821 else
5822 {
5823 name = bfd_elf_string_from_elf_section (input_bfd,
5824 symtab_hdr->sh_link,
5825 sym->st_name);
5826 if (name == NULL)
5827 continue;
5828 if (*name == '\0')
5829 name = bfd_section_name (input_bfd, sec);
5830 }
5831
ef60b7ff
AM		 5832 if (r == bfd_reloc_overflow)
5833 {
5834 if (warned)
5835 continue;
5836 if (!((*info->callbacks->reloc_overflow)
5837 (info, name, ppc64_elf_howto_table[(int) r_type]->name,
5838 rel->r_addend, input_bfd, input_section, offset)))
5839 return false;
5840 }
5841 else
5842 {
5843 (*_bfd_error_handler)
5844 (_("%s(%s+0x%lx): reloc against `%s': error %d"),
5845 bfd_archive_filename (input_bfd),
5846 bfd_get_section_name (input_bfd, input_section),
5847 (long) rel->r_offset, name, (int) r);
5848 ret = false;
5849 }
5bd4f169 5850 }
5bd4f169
AM		 5851 }
5852
5bd4f169
AM		 5853 return ret;
5854}
5855
5856/* Finish up dynamic symbol handling. We set the contents of various
5857 dynamic sections here. */
5858
5859static boolean
5860ppc64_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
5861 bfd *output_bfd;
5862 struct bfd_link_info *info;
5863 struct elf_link_hash_entry *h;
5864 Elf_Internal_Sym *sym;
5865{
65f38f15 5866 struct ppc_link_hash_table *htab;
5bd4f169
AM		 5867 bfd *dynobj;
5868
65f38f15
AM		 5869 htab = ppc_hash_table (info);
5870 dynobj = htab->elf.dynobj;
5bd4f169 5871
41bd81ab
AM		 5872 if (h->plt.offset != (bfd_vma) -1
5873 && ((struct ppc_link_hash_entry *) h)->is_func_descriptor)
5bd4f169 5874 {
65f38f15
AM		 5875 Elf_Internal_Rela rela;
5876 Elf64_External_Rela *loc;
5bd4f169
AM		 5877
5878 /* This symbol has an entry in the procedure linkage table. Set
5879 it up. */
5880
5d1634d7 5881 if (htab->splt == NULL
65f38f15 5882 || htab->srelplt == NULL
e86ce104 5883 || htab->sglink == NULL)
65f38f15
AM		 5884 abort ();
5885
65f38f15
AM		 5886 /* Create a JMP_SLOT reloc to inform the dynamic linker to
5887 fill in the PLT entry. */
5bd4f169 5888
65f38f15
AM		 5889 rela.r_offset = (htab->splt->output_section->vma
5890 + htab->splt->output_offset
5891 + h->plt.offset);
e86ce104 5892 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
65f38f15
AM		 5893 rela.r_addend = 0;
5894
5895 loc = (Elf64_External_Rela *) htab->srelplt->contents;
5896 loc += (h->plt.offset - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE;
5897 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
5bd4f169
AM		 5898 }
5899
5900 if (h->got.offset != (bfd_vma) -1)
5901 {
5bd4f169 5902 Elf_Internal_Rela rela;
65f38f15 5903 Elf64_External_Rela *loc;
5bd4f169
AM		 5904
5905 /* This symbol has an entry in the global offset table. Set it
5906 up. */
5907
65f38f15
AM		 5908 if (htab->sgot == NULL || htab->srelgot == NULL)
5909 abort ();
5bd4f169 5910
65f38f15
AM		 5911 rela.r_offset = (htab->sgot->output_section->vma
5912 + htab->sgot->output_offset
dc810e39 5913 + (h->got.offset &~ (bfd_vma) 1));
5bd4f169 5914
65f38f15
AM		 5915 /* If this is a static link, or it is a -Bsymbolic link and the
5916 symbol is defined locally or was forced to be local because
5917 of a version file, we just want to emit a RELATIVE reloc.
5918 The entry in the global offset table will already have been
5919 initialized in the relocate_section function. */
5bd4f169 5920 if (info->shared
65f38f15
AM		 5921 && (info->symbolic
5922 || h->dynindx == -1
5923 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
5bd4f169
AM		 5924 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
5925 {
65f38f15 5926 BFD_ASSERT((h->got.offset & 1) != 0);
5bd4f169
AM		 5927 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
5928 rela.r_addend = (h->root.u.def.value
5929 + h->root.u.def.section->output_section->vma
5930 + h->root.u.def.section->output_offset);
5931 }
5932 else
5933 {
5934 BFD_ASSERT ((h->got.offset & 1) == 0);
65f38f15
AM		 5935 bfd_put_64 (output_bfd, (bfd_vma) 0,
5936 htab->sgot->contents + h->got.offset);
5bd4f169
AM		 5937 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_GLOB_DAT);
5938 rela.r_addend = 0;
5939 }
5940
65f38f15
AM		 5941 loc = (Elf64_External_Rela *) htab->srelgot->contents;
5942 loc += htab->srelgot->reloc_count++;
5943 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
5bd4f169
AM		 5944 }
5945
5946 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
5947 {
5bd4f169 5948 Elf_Internal_Rela rela;
65f38f15 5949 Elf64_External_Rela *loc;
5bd4f169 5950
65f38f15 5951 /* This symbol needs a copy reloc. Set it up. */
5bd4f169 5952
65f38f15
AM		 5953 if (h->dynindx == -1
5954 || (h->root.type != bfd_link_hash_defined
5955 && h->root.type != bfd_link_hash_defweak)
5956 || htab->srelbss == NULL)
5957 abort ();
5bd4f169
AM		 5958
5959 rela.r_offset = (h->root.u.def.value
5960 + h->root.u.def.section->output_section->vma
5961 + h->root.u.def.section->output_offset);
5962 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
5963 rela.r_addend = 0;
65f38f15
AM		 5964 loc = (Elf64_External_Rela *) htab->srelbss->contents;
5965 loc += htab->srelbss->reloc_count++;
5966 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
5bd4f169
AM		 5967 }
5968
5bd4f169
AM		 5969 /* Mark some specially defined symbols as absolute. */
5970 if (strcmp (h->root.root.string, "_DYNAMIC") == 0)
5971 sym->st_shndx = SHN_ABS;
5972
5973 return true;
5974}
5975
65f38f15
AM		 5976/* Used to decide how to sort relocs in an optimal manner for the
5977 dynamic linker, before writing them out. */
5978
5979static enum elf_reloc_type_class
5980ppc64_elf_reloc_type_class (rela)
5981 const Elf_Internal_Rela *rela;
5982{
a33d1f77
AM		 5983 enum elf_ppc_reloc_type r_type;
5984
5985 r_type = (enum elf_ppc_reloc_type) ELF64_R_TYPE (rela->r_info);
5986 switch (r_type)
65f38f15
AM		 5987 {
5988 case R_PPC64_RELATIVE:
5989 return reloc_class_relative;
5990 case R_PPC64_JMP_SLOT:
5991 return reloc_class_plt;
5992 case R_PPC64_COPY:
5993 return reloc_class_copy;
5994 default:
5995 return reloc_class_normal;
5996 }
5997}
5998
5bd4f169
AM		 5999/* Finish up the dynamic sections. */
6000
6001static boolean
6002ppc64_elf_finish_dynamic_sections (output_bfd, info)
6003 bfd *output_bfd;
6004 struct bfd_link_info *info;
6005{
65f38f15
AM		 6006 struct ppc_link_hash_table *htab;
6007 bfd *dynobj;
5bd4f169 6008 asection *sdyn;
5bd4f169 6009
65f38f15
AM		 6010 htab = ppc_hash_table (info);
6011 dynobj = htab->elf.dynobj;
5bd4f169
AM		 6012 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
6013
65f38f15 6014 if (htab->elf.dynamic_sections_created)
5bd4f169 6015 {
5bd4f169
AM		 6016 Elf64_External_Dyn *dyncon, *dynconend;
6017
65f38f15
AM		 6018 if (sdyn == NULL || htab->sgot == NULL)
6019 abort ();
5bd4f169
AM		 6020
6021 dyncon = (Elf64_External_Dyn *) sdyn->contents;
6022 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
6023 for (; dyncon < dynconend; dyncon++)
6024 {
6025 Elf_Internal_Dyn dyn;
19397422 6026 asection *s;
5bd4f169
AM		 6027
6028 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
6029
6030 switch (dyn.d_tag)
6031 {
65f38f15
AM		 6032 default:
6033 continue;
5bd4f169 6034
5d1634d7
AM		 6035 case DT_PPC64_GLINK:
6036 dyn.d_un.d_ptr = (htab->sglink->output_section->vma
6037 + htab->sglink->output_offset);
6038 break;
6039
19397422
AM		 6040 case DT_PPC64_OPD:
6041 s = bfd_get_section_by_name (output_bfd, ".opd");
6042 if (s != NULL)
6043 dyn.d_un.d_ptr = s->vma;
6044 break;
6045
6046 case DT_PPC64_OPDSZ:
6047 s = bfd_get_section_by_name (output_bfd, ".opd");
6048 if (s != NULL)
6049 dyn.d_un.d_val = s->_raw_size;
6050 break;
6051
65f38f15 6052 case DT_PLTGOT:
5d1634d7
AM		 6053 dyn.d_un.d_ptr = (htab->splt->output_section->vma
6054 + htab->splt->output_offset);
65f38f15
AM		 6055 break;
6056
6057 case DT_JMPREL:
5d1634d7
AM		 6058 dyn.d_un.d_ptr = (htab->srelplt->output_section->vma
6059 + htab->srelplt->output_offset);
65f38f15 6060 break;
5bd4f169 6061
65f38f15 6062 case DT_PLTRELSZ:
5d1634d7
AM		 6063 dyn.d_un.d_val = htab->srelplt->_raw_size;
6064 break;
6065
6066 case DT_RELASZ:
6067 /* Don't count procedure linkage table relocs in the
6068 overall reloc count. */
6069 if (htab->srelplt != NULL)
6070 dyn.d_un.d_val -= htab->srelplt->_raw_size;
65f38f15 6071 break;
5bd4f169 6072 }
5bd4f169 6073
65f38f15 6074 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
5bd4f169 6075 }
5bd4f169
AM		 6076 }
6077
5d1634d7
AM		 6078 if (htab->sgot != NULL && htab->sgot->_raw_size != 0)
6079 {
6080 /* Fill in the first entry in the global offset table.
6081 We use it to hold the link-time TOCbase. */
6082 bfd_put_64 (output_bfd,
60ee0d4a 6083 elf_gp (output_bfd) + TOC_BASE_OFF,
5d1634d7
AM		 6084 htab->sgot->contents);
6085
6086 /* Set .got entry size. */
6087 elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize = 8;
6088 }
6089
6090 if (htab->splt != NULL && htab->splt->_raw_size != 0)
6091 {
6092 /* Set .plt entry size. */
6093 elf_section_data (htab->splt->output_section)->this_hdr.sh_entsize
6094 = PLT_ENTRY_SIZE;
6095 }
6096
5bd4f169
AM		 6097 return true;
6098}
6099
6100#define TARGET_LITTLE_SYM bfd_elf64_powerpcle_vec
6101#define TARGET_LITTLE_NAME "elf64-powerpcle"
6102#define TARGET_BIG_SYM bfd_elf64_powerpc_vec
6103#define TARGET_BIG_NAME "elf64-powerpc"
6104#define ELF_ARCH bfd_arch_powerpc
6105#define ELF_MACHINE_CODE EM_PPC64
6106#define ELF_MAXPAGESIZE 0x10000
6107#define elf_info_to_howto ppc64_elf_info_to_howto
6108
6109#ifdef EM_CYGNUS_POWERPC
6110#define ELF_MACHINE_ALT1 EM_CYGNUS_POWERPC
6111#endif
6112
6113#ifdef EM_PPC_OLD
6114#define ELF_MACHINE_ALT2 EM_PPC_OLD
6115#endif
6116
6117#define elf_backend_want_got_sym 0
6118#define elf_backend_want_plt_sym 0
6119#define elf_backend_plt_alignment 3
6120#define elf_backend_plt_not_loaded 1
6121#define elf_backend_got_symbol_offset 0
5d1634d7
AM		 6122#define elf_backend_got_header_size 8
6123#define elf_backend_plt_header_size PLT_INITIAL_ENTRY_SIZE
5bd4f169 6124#define elf_backend_can_gc_sections 1
65f38f15 6125#define elf_backend_can_refcount 1
b491616a 6126#define elf_backend_rela_normal 1
5bd4f169 6127
65f38f15
AM		 6128#define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
6129#define bfd_elf64_bfd_set_private_flags ppc64_elf_set_private_flags
65f38f15
AM		 6130#define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
6131#define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
721956f4 6132#define bfd_elf64_bfd_link_hash_table_free ppc64_elf_link_hash_table_free
7cdc5bba 6133#define bfd_elf64_get_symbol_info ppc64_elf_get_symbol_info
65f38f15
AM		 6134
6135#define elf_backend_section_from_shdr ppc64_elf_section_from_shdr
6136#define elf_backend_create_dynamic_sections ppc64_elf_create_dynamic_sections
6137#define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
6138#define elf_backend_check_relocs ppc64_elf_check_relocs
6139#define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
6140#define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
6141#define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
e86ce104
AM		 6142#define elf_backend_hide_symbol ppc64_elf_hide_symbol
6143#define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
65f38f15
AM		 6144#define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
6145#define elf_backend_fake_sections ppc64_elf_fake_sections
6146#define elf_backend_relocate_section ppc64_elf_relocate_section
6147#define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
6148#define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
6149#define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
5bd4f169
AM		 6150
6151#include "elf64-target.h"
A mirror of the official binutils-gdb repository