projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* ppc.h (DT_PPC64_GLINK): Define.
[deliverable/binutils-gdb.git] / bfd / elf64-ppc.c
CommitLineData
5bd4f169
AM		 1/* PowerPC64-specific support for 64-bit ELF.
2 Copyright 1999, 2000, 2001 Free Software Foundation, Inc.
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"
31
32#define USE_RELA /* we want RELA relocations, not REL. */
33
34
35static void ppc_howto_init
36 PARAMS ((void));
37static reloc_howto_type *ppc64_elf_reloc_type_lookup
38 PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
39static void ppc64_elf_info_to_howto
40 PARAMS ((bfd *abfd, arelent *cache_ptr, Elf64_Internal_Rela *dst));
41static bfd_reloc_status_type ppc64_elf_addr16_ha_reloc
42 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
43static boolean ppc64_elf_set_private_flags
44 PARAMS ((bfd *, flagword));
5bd4f169
AM		 45static boolean ppc64_elf_merge_private_bfd_data
46 PARAMS ((bfd *, bfd *));
47static boolean ppc64_elf_section_from_shdr
48 PARAMS ((bfd *, Elf64_Internal_Shdr *, char *));
65f38f15
AM		 49static struct bfd_hash_entry *link_hash_newfunc
50 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
51static struct bfd_link_hash_table *ppc64_elf_link_hash_table_create
52 PARAMS ((bfd *));
53static boolean create_got_section
54 PARAMS ((bfd *, struct bfd_link_info *));
5bd4f169
AM		 55static boolean ppc64_elf_create_dynamic_sections
56 PARAMS ((bfd *, struct bfd_link_info *));
65f38f15
AM		 57static void ppc64_elf_copy_indirect_symbol
58 PARAMS ((struct elf_link_hash_entry *, struct elf_link_hash_entry *));
5bd4f169
AM		 59static boolean ppc64_elf_check_relocs
60 PARAMS ((bfd *, struct bfd_link_info *, asection *,
61 const Elf_Internal_Rela *));
62static asection * ppc64_elf_gc_mark_hook
63 PARAMS ((bfd *abfd, struct bfd_link_info *info, Elf_Internal_Rela *rel,
64 struct elf_link_hash_entry *h, Elf_Internal_Sym *sym));
65static boolean ppc64_elf_gc_sweep_hook
66 PARAMS ((bfd *abfd, struct bfd_link_info *info, asection *sec,
67 const Elf_Internal_Rela *relocs));
68static boolean ppc64_elf_adjust_dynamic_symbol
69 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
65f38f15
AM		 70static boolean allocate_dynrelocs
71 PARAMS ((struct elf_link_hash_entry *, PTR));
72static boolean readonly_dynrelocs
5bd4f169 73 PARAMS ((struct elf_link_hash_entry *, PTR));
65f38f15
AM		 74static enum elf_reloc_type_class ppc64_elf_reloc_type_class
75 PARAMS ((const Elf_Internal_Rela *));
5bd4f169
AM		 76static boolean ppc64_elf_size_dynamic_sections
77 PARAMS ((bfd *, struct bfd_link_info *));
78static boolean ppc64_elf_final_link
79 PARAMS ((bfd *, struct bfd_link_info *));
80static boolean ppc64_elf_fake_sections
81 PARAMS ((bfd *, Elf64_Internal_Shdr *, asection *));
82static boolean ppc64_elf_relocate_section
83 PARAMS ((bfd *, struct bfd_link_info *info, bfd *, asection *, bfd_byte *,
84 Elf_Internal_Rela *relocs, Elf_Internal_Sym *local_syms,
85 asection **));
86static boolean ppc64_elf_finish_dynamic_symbol
87 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
88 Elf_Internal_Sym *));
89static boolean ppc64_elf_finish_dynamic_sections
90 PARAMS ((bfd *, struct bfd_link_info *));
91
92
5bd4f169
AM		 93/* Mask to set RA in memory instructions. */
94#define RA_REGISTER_MASK 0x001f0000
95
96/* Value to shift register by to insert RA. */
97#define RA_REGISTER_SHIFT 16
98
99/* The name of the dynamic interpreter. This is put in the .interp
100 section. */
101#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
102
103/* The size in bytes of an entry in the procedure linkage table. */
104#define PLT_ENTRY_SIZE 24
105
106/* The initial size of the plt reserved for the dynamic linker. */
107#define PLT_INITIAL_ENTRY_SIZE 96
108
109/* TOC base pointers offset from start of TOC. */
110#define TOC_BASE_OFF (0x8000)
111
112/* Global linkage stub. The first instruction has its offset patched. */
113/* FIXME: Need traceback table? */
114static const unsigned int ppc64_elf_glink_code[] = {
115 0xe9820000, /* ld %r12,0(%r2) */
116 0xf8410028, /* std %r2,40(%r1) */
117 0xe80c0000, /* ld %r0,0(%r12) */
118 0xe84c0008, /* ld %r2,8(%r12) */
119 0x7c0903a6, /* mtctr %r0 */
120 0x4e800420 /* bctr */
121};
122
123#define PPC64_ELF_GLINK_SIZE \
124 ((sizeof ppc64_elf_glink_code / sizeof ppc64_elf_glink_code[0]) * 4)
125\f
126/* Relocation HOWTO's. */
127static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC_max];
128
129static reloc_howto_type ppc64_elf_howto_raw[] = {
130 /* This reloc does nothing. */
131 HOWTO (R_PPC64_NONE, /* type */
132 0, /* rightshift */
133 2, /* size (0 = byte, 1 = short, 2 = long) */
134 32, /* bitsize */
135 false, /* pc_relative */
136 0, /* bitpos */
137 complain_overflow_bitfield, /* complain_on_overflow */
138 bfd_elf_generic_reloc, /* special_function */
139 "R_PPC64_NONE", /* name */
140 false, /* partial_inplace */
141 0, /* src_mask */
142 0, /* dst_mask */
143 false), /* pcrel_offset */
144
145 /* A standard 32 bit relocation. */
146 HOWTO (R_PPC64_ADDR32, /* type */
147 0, /* rightshift */
148 2, /* size (0 = byte, 1 = short, 2 = long) */
149 32, /* bitsize */
150 false, /* pc_relative */
151 0, /* bitpos */
152 complain_overflow_bitfield, /* complain_on_overflow */
153 bfd_elf_generic_reloc, /* special_function */
154 "R_PPC64_ADDR32", /* name */
155 false, /* partial_inplace */
156 0, /* src_mask */
157 0xffffffff, /* dst_mask */
158 false), /* pcrel_offset */
159
160 /* An absolute 26 bit branch; the lower two bits must be zero.
161 FIXME: we don't check that, we just clear them. */
162 HOWTO (R_PPC64_ADDR24, /* type */
163 0, /* rightshift */
164 2, /* size (0 = byte, 1 = short, 2 = long) */
165 26, /* bitsize */
166 false, /* pc_relative */
167 0, /* bitpos */
168 complain_overflow_bitfield, /* complain_on_overflow */
169 bfd_elf_generic_reloc, /* special_function */
170 "R_PPC64_ADDR24", /* name */
171 false, /* partial_inplace */
172 0, /* src_mask */
173 0x3fffffc, /* dst_mask */
174 false), /* pcrel_offset */
175
176 /* A standard 16 bit relocation. */
177 HOWTO (R_PPC64_ADDR16, /* type */
178 0, /* rightshift */
179 1, /* size (0 = byte, 1 = short, 2 = long) */
180 16, /* bitsize */
181 false, /* pc_relative */
182 0, /* bitpos */
183 complain_overflow_bitfield, /* complain_on_overflow */
184 bfd_elf_generic_reloc, /* special_function */
185 "R_PPC64_ADDR16", /* name */
186 false, /* partial_inplace */
187 0, /* src_mask */
188 0xffff, /* dst_mask */
189 false), /* pcrel_offset */
190
191 /* A 16 bit relocation without overflow. */
192 HOWTO (R_PPC64_ADDR16_LO, /* type */
193 0, /* rightshift */
194 1, /* size (0 = byte, 1 = short, 2 = long) */
195 16, /* bitsize */
196 false, /* pc_relative */
197 0, /* bitpos */
198 complain_overflow_dont,/* complain_on_overflow */
199 bfd_elf_generic_reloc, /* special_function */
200 "R_PPC64_ADDR16_LO", /* name */
201 false, /* partial_inplace */
202 0, /* src_mask */
203 0xffff, /* dst_mask */
204 false), /* pcrel_offset */
205
206 /* Bits 16-31 of an address. */
207 HOWTO (R_PPC64_ADDR16_HI, /* type */
208 16, /* rightshift */
209 1, /* size (0 = byte, 1 = short, 2 = long) */
210 16, /* bitsize */
211 false, /* pc_relative */
212 0, /* bitpos */
213 complain_overflow_dont, /* complain_on_overflow */
214 bfd_elf_generic_reloc, /* special_function */
215 "R_PPC64_ADDR16_HI", /* name */
216 false, /* partial_inplace */
217 0, /* src_mask */
218 0xffff, /* dst_mask */
219 false), /* pcrel_offset */
220
221 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
222 bits, treated as a signed number, is negative. */
223 HOWTO (R_PPC64_ADDR16_HA, /* type */
224 16, /* rightshift */
225 1, /* size (0 = byte, 1 = short, 2 = long) */
226 16, /* bitsize */
227 false, /* pc_relative */
228 0, /* bitpos */
229 complain_overflow_dont, /* complain_on_overflow */
230 ppc64_elf_addr16_ha_reloc, /* special_function */
231 "R_PPC64_ADDR16_HA", /* name */
232 false, /* partial_inplace */
233 0, /* src_mask */
234 0xffff, /* dst_mask */
235 false), /* pcrel_offset */
236
237 /* An absolute 16 bit branch; the lower two bits must be zero.
238 FIXME: we don't check that, we just clear them. */
239 HOWTO (R_PPC64_ADDR14, /* type */
240 0, /* rightshift */
241 2, /* size (0 = byte, 1 = short, 2 = long) */
242 16, /* bitsize */
243 false, /* pc_relative */
244 0, /* bitpos */
245 complain_overflow_bitfield, /* complain_on_overflow */
246 bfd_elf_generic_reloc, /* special_function */
247 "R_PPC64_ADDR14", /* name */
248 false, /* partial_inplace */
249 0, /* src_mask */
250 0xfffc, /* dst_mask */
251 false), /* pcrel_offset */
252
253 /* An absolute 16 bit branch, for which bit 10 should be set to
254 indicate that the branch is expected to be taken. The lower two
255 bits must be zero. */
256 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
257 0, /* rightshift */
258 2, /* size (0 = byte, 1 = short, 2 = long) */
259 16, /* bitsize */
260 false, /* pc_relative */
261 0, /* bitpos */
262 complain_overflow_bitfield, /* complain_on_overflow */
263 bfd_elf_generic_reloc, /* special_function */
264 "R_PPC64_ADDR14_BRTAKEN",/* name */
265 false, /* partial_inplace */
266 0, /* src_mask */
267 0xfffc, /* dst_mask */
268 false), /* pcrel_offset */
269
270 /* An absolute 16 bit branch, for which bit 10 should be set to
271 indicate that the branch is not expected to be taken. The lower
272 two bits must be zero. */
273 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
274 0, /* rightshift */
275 2, /* size (0 = byte, 1 = short, 2 = long) */
276 16, /* bitsize */
277 false, /* pc_relative */
278 0, /* bitpos */
279 complain_overflow_bitfield, /* complain_on_overflow */
280 bfd_elf_generic_reloc, /* special_function */
281 "R_PPC64_ADDR14_BRNTAKEN",/* name */
282 false, /* partial_inplace */
283 0, /* src_mask */
284 0xfffc, /* dst_mask */
285 false), /* pcrel_offset */
286
287 /* A relative 26 bit branch; the lower two bits must be zero. */
288 HOWTO (R_PPC64_REL24, /* type */
289 0, /* rightshift */
290 2, /* size (0 = byte, 1 = short, 2 = long) */
291 26, /* bitsize */
292 true, /* pc_relative */
293 0, /* bitpos */
294 complain_overflow_signed, /* complain_on_overflow */
295 bfd_elf_generic_reloc, /* special_function */
296 "R_PPC64_REL24", /* name */
297 false, /* partial_inplace */
298 0, /* src_mask */
299 0x3fffffc, /* dst_mask */
300 true), /* pcrel_offset */
301
302 /* A relative 16 bit branch; the lower two bits must be zero. */
303 HOWTO (R_PPC64_REL14, /* type */
304 0, /* rightshift */
305 2, /* size (0 = byte, 1 = short, 2 = long) */
306 16, /* bitsize */
307 true, /* pc_relative */
308 0, /* bitpos */
309 complain_overflow_signed, /* complain_on_overflow */
310 bfd_elf_generic_reloc, /* special_function */
311 "R_PPC64_REL14", /* name */
312 false, /* partial_inplace */
313 0, /* src_mask */
314 0xfffc, /* dst_mask */
315 true), /* pcrel_offset */
316
317 /* A relative 16 bit branch. Bit 10 should be set to indicate that
318 the branch is expected to be taken. The lower two bits must be
319 zero. */
320 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
321 0, /* rightshift */
322 2, /* size (0 = byte, 1 = short, 2 = long) */
323 16, /* bitsize */
324 true, /* pc_relative */
325 0, /* bitpos */
326 complain_overflow_signed, /* complain_on_overflow */
327 bfd_elf_generic_reloc, /* special_function */
328 "R_PPC64_REL14_BRTAKEN", /* name */
329 false, /* partial_inplace */
330 0, /* src_mask */
331 0xfffc, /* dst_mask */
332 true), /* pcrel_offset */
333
334 /* A relative 16 bit branch. Bit 10 should be set to indicate that
335 the branch is not expected to be taken. The lower two bits must
336 be zero. */
337 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
338 0, /* rightshift */
339 2, /* size (0 = byte, 1 = short, 2 = long) */
340 16, /* bitsize */
341 true, /* pc_relative */
342 0, /* bitpos */
343 complain_overflow_signed, /* complain_on_overflow */
344 bfd_elf_generic_reloc, /* special_function */
345 "R_PPC64_REL14_BRNTAKEN",/* name */
346 false, /* partial_inplace */
347 0, /* src_mask */
348 0xfffc, /* dst_mask */
349 true), /* pcrel_offset */
350
351 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
352 symbol. */
353 HOWTO (R_PPC64_GOT16, /* type */
354 0, /* rightshift */
355 1, /* size (0 = byte, 1 = short, 2 = long) */
356 16, /* bitsize */
357 false, /* pc_relative */
358 0, /* bitpos */
359 complain_overflow_signed, /* complain_on_overflow */
360 bfd_elf_generic_reloc, /* special_function */
361 "R_PPC64_GOT16", /* name */
362 false, /* partial_inplace */
363 0, /* src_mask */
364 0xffff, /* dst_mask */
365 false), /* pcrel_offset */
366
367 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
368 the symbol. */
369 HOWTO (R_PPC64_GOT16_LO, /* type */
370 0, /* rightshift */
371 1, /* size (0 = byte, 1 = short, 2 = long) */
372 16, /* bitsize */
373 false, /* pc_relative */
374 0, /* bitpos */
375 complain_overflow_dont, /* complain_on_overflow */
376 bfd_elf_generic_reloc, /* special_function */
377 "R_PPC64_GOT16_LO", /* name */
378 false, /* partial_inplace */
379 0, /* src_mask */
380 0xffff, /* dst_mask */
381 false), /* pcrel_offset */
382
383 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
384 the symbol. */
385 HOWTO (R_PPC64_GOT16_HI, /* type */
386 16, /* rightshift */
387 1, /* size (0 = byte, 1 = short, 2 = long) */
388 16, /* bitsize */
389 false, /* pc_relative */
390 0, /* bitpos */
391 complain_overflow_dont,/* complain_on_overflow */
392 bfd_elf_generic_reloc, /* special_function */
393 "R_PPC64_GOT16_HI", /* name */
394 false, /* partial_inplace */
395 0, /* src_mask */
396 0xffff, /* dst_mask */
397 false), /* pcrel_offset */
398
399 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
400 the symbol. */
401 HOWTO (R_PPC64_GOT16_HA, /* type */
402 16, /* rightshift */
403 1, /* size (0 = byte, 1 = short, 2 = long) */
404 16, /* bitsize */
405 false, /* pc_relative */
406 0, /* bitpos */
407 complain_overflow_dont,/* complain_on_overflow */
408 ppc64_elf_addr16_ha_reloc, /* special_function */
409 "R_PPC64_GOT16_HA", /* name */
410 false, /* partial_inplace */
411 0, /* src_mask */
412 0xffff, /* dst_mask */
413 false), /* pcrel_offset */
414
415 /* This is used only by the dynamic linker. The symbol should exist
416 both in the object being run and in some shared library. The
417 dynamic linker copies the data addressed by the symbol from the
418 shared library into the object, because the object being
419 run has to have the data at some particular address. */
420 HOWTO (R_PPC64_COPY, /* type */
421 0, /* rightshift */
422 2, /* size (0 = byte, 1 = short, 2 = long) */
423 32, /* bitsize */
424 false, /* pc_relative */
425 0, /* bitpos */
426 complain_overflow_bitfield, /* complain_on_overflow */
427 bfd_elf_generic_reloc, /* special_function */
428 "R_PPC64_COPY", /* name */
429 false, /* partial_inplace */
430 0, /* src_mask */
431 0, /* dst_mask */
432 false), /* pcrel_offset */
433
434 /* Like R_PPC64_ADDR64, but used when setting global offset table
435 entries. */
436 HOWTO (R_PPC64_GLOB_DAT, /* type */
437 0, /* rightshift */
438 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
439 64, /* bitsize */
440 false, /* pc_relative */
441 0, /* bitpos */
442 complain_overflow_dont, /* complain_on_overflow */
443 bfd_elf_generic_reloc, /* special_function */
444 "R_PPC64_GLOB_DAT", /* name */
445 false, /* partial_inplace */
446 0, /* src_mask */
447 0xffffffffffffffff, /* dst_mask */
448 false), /* pcrel_offset */
449
450 /* Created by the link editor. Marks a procedure linkage table
451 entry for a symbol. */
452 HOWTO (R_PPC64_JMP_SLOT, /* type */
453 0, /* rightshift */
454 0, /* size (0 = byte, 1 = short, 2 = long) */
455 0, /* bitsize */
456 false, /* pc_relative */
457 0, /* bitpos */
458 complain_overflow_dont, /* complain_on_overflow */
459 bfd_elf_generic_reloc, /* special_function */
460 "R_PPC64_JMP_SLOT", /* name */
461 false, /* partial_inplace */
462 0, /* src_mask */
463 0, /* dst_mask */
464 false), /* pcrel_offset */
465
466 /* Used only by the dynamic linker. When the object is run, this
467 doubleword64 is set to the load address of the object, plus the
468 addend. */
469 HOWTO (R_PPC64_RELATIVE, /* type */
470 0, /* rightshift */
471 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
472 64, /* bitsize */
473 false, /* pc_relative */
474 0, /* bitpos */
475 complain_overflow_dont, /* complain_on_overflow */
476 bfd_elf_generic_reloc, /* special_function */
477 "R_PPC64_RELATIVE", /* name */
478 false, /* partial_inplace */
479 0, /* src_mask */
480 0xffffffffffffffff, /* dst_mask */
481 false), /* pcrel_offset */
482
483 /* Like R_PPC64_ADDR32, but may be unaligned. */
484 HOWTO (R_PPC64_UADDR32, /* type */
485 0, /* rightshift */
486 2, /* size (0 = byte, 1 = short, 2 = long) */
487 32, /* bitsize */
488 false, /* pc_relative */
489 0, /* bitpos */
490 complain_overflow_bitfield, /* complain_on_overflow */
491 bfd_elf_generic_reloc, /* special_function */
492 "R_PPC64_UADDR32", /* name */
493 false, /* partial_inplace */
494 0, /* src_mask */
495 0xffffffff, /* dst_mask */
496 false), /* pcrel_offset */
497
498 /* Like R_PPC64_ADDR16, but may be unaligned. */
499 HOWTO (R_PPC64_UADDR16, /* type */
500 0, /* rightshift */
501 1, /* size (0 = byte, 1 = short, 2 = long) */
502 16, /* bitsize */
503 false, /* pc_relative */
504 0, /* bitpos */
505 complain_overflow_bitfield, /* complain_on_overflow */
506 bfd_elf_generic_reloc, /* special_function */
507 "R_PPC64_UADDR16", /* name */
508 false, /* partial_inplace */
509 0, /* src_mask */
510 0xffff, /* dst_mask */
511 false), /* pcrel_offset */
512
513 /* 32-bit PC relative. */
514 HOWTO (R_PPC64_REL32, /* type */
515 0, /* rightshift */
516 2, /* size (0 = byte, 1 = short, 2 = long) */
517 32, /* bitsize */
518 true, /* pc_relative */
519 0, /* bitpos */
520 /* FIXME: Verify. Was complain_overflow_bitfield. */
521 complain_overflow_signed, /* complain_on_overflow */
522 bfd_elf_generic_reloc, /* special_function */
523 "R_PPC64_REL32", /* name */
524 false, /* partial_inplace */
525 0, /* src_mask */
526 0xffffffff, /* dst_mask */
527 true), /* pcrel_offset */
528
529 /* 32-bit relocation to the symbol's procedure linkage table.
530 FIXME: R_PPC64_PLT32 not supported. */
531 HOWTO (R_PPC64_PLT32, /* type */
532 0, /* rightshift */
533 2, /* size (0 = byte, 1 = short, 2 = long) */
534 32, /* bitsize */
535 false, /* pc_relative */
536 0, /* bitpos */
537 complain_overflow_bitfield, /* complain_on_overflow */
538 bfd_elf_generic_reloc, /* special_function */
539 "R_PPC64_PLT32", /* name */
540 false, /* partial_inplace */
541 0, /* src_mask */
542 0, /* dst_mask */
543 false), /* pcrel_offset */
544
545 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
546 FIXME: R_PPC64_PLTREL32 not supported. */
547 HOWTO (R_PPC64_PLTREL32, /* type */
548 0, /* rightshift */
549 2, /* size (0 = byte, 1 = short, 2 = long) */
550 32, /* bitsize */
551 true, /* pc_relative */
552 0, /* bitpos */
553 complain_overflow_signed, /* complain_on_overflow */
554 bfd_elf_generic_reloc, /* special_function */
555 "R_PPC64_PLTREL32", /* name */
556 false, /* partial_inplace */
557 0, /* src_mask */
558 0, /* dst_mask */
559 true), /* pcrel_offset */
560
561 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
562 the symbol. */
563 HOWTO (R_PPC64_PLT16_LO, /* type */
564 0, /* rightshift */
565 1, /* size (0 = byte, 1 = short, 2 = long) */
566 16, /* bitsize */
567 false, /* pc_relative */
568 0, /* bitpos */
569 complain_overflow_dont, /* complain_on_overflow */
570 bfd_elf_generic_reloc, /* special_function */
571 "R_PPC64_PLT16_LO", /* name */
572 false, /* partial_inplace */
573 0, /* src_mask */
574 0xffff, /* dst_mask */
575 false), /* pcrel_offset */
576
577 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
578 the symbol. */
579 HOWTO (R_PPC64_PLT16_HI, /* type */
580 16, /* rightshift */
581 1, /* size (0 = byte, 1 = short, 2 = long) */
582 16, /* bitsize */
583 false, /* pc_relative */
584 0, /* bitpos */
585 complain_overflow_dont, /* complain_on_overflow */
586 bfd_elf_generic_reloc, /* special_function */
587 "R_PPC64_PLT16_HI", /* name */
588 false, /* partial_inplace */
589 0, /* src_mask */
590 0xffff, /* dst_mask */
591 false), /* pcrel_offset */
592
593 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
594 the symbol. */
595 HOWTO (R_PPC64_PLT16_HA, /* type */
596 16, /* rightshift */
597 1, /* size (0 = byte, 1 = short, 2 = long) */
598 16, /* bitsize */
599 false, /* pc_relative */
600 0, /* bitpos */
601 complain_overflow_dont, /* complain_on_overflow */
602 ppc64_elf_addr16_ha_reloc, /* special_function */
603 "R_PPC64_PLT16_HA", /* name */
604 false, /* partial_inplace */
605 0, /* src_mask */
606 0xffff, /* dst_mask */
607 false), /* pcrel_offset */
608
609 /* 32-bit section relative relocation. */
610 /* FIXME: Verify R_PPC64_SECTOFF. Seems strange with size=2 and
611 dst_mask=0. */
612 HOWTO (R_PPC64_SECTOFF, /* type */
613 0, /* rightshift */
614 2, /* size (0 = byte, 1 = short, 2 = long) */
615 32, /* bitsize */
616 true, /* pc_relative */
617 0, /* bitpos */
618 complain_overflow_bitfield, /* complain_on_overflow */
619 bfd_elf_generic_reloc, /* special_function */
620 "R_PPC64_SECTOFF", /* name */
621 false, /* partial_inplace */
622 0, /* src_mask */
623 0, /* dst_mask */
624 true), /* pcrel_offset */
625
626 /* 16-bit lower half section relative relocation. */
627 HOWTO (R_PPC64_SECTOFF_LO, /* type */
628 0, /* rightshift */
629 1, /* size (0 = byte, 1 = short, 2 = long) */
630 16, /* bitsize */
631 false, /* pc_relative */
632 0, /* bitpos */
633 complain_overflow_dont, /* complain_on_overflow */
634 bfd_elf_generic_reloc, /* special_function */
635 "R_PPC64_SECTOFF_LO", /* name */
636 false, /* partial_inplace */
637 0, /* src_mask */
638 0xffff, /* dst_mask */
639 false), /* pcrel_offset */
640
641 /* 16-bit upper half section relative relocation. */
642 HOWTO (R_PPC64_SECTOFF_HI, /* type */
643 16, /* rightshift */
644 1, /* size (0 = byte, 1 = short, 2 = long) */
645 16, /* bitsize */
646 false, /* pc_relative */
647 0, /* bitpos */
648 complain_overflow_dont, /* complain_on_overflow */
649 bfd_elf_generic_reloc, /* special_function */
650 "R_PPC64_SECTOFF_HI", /* name */
651 false, /* partial_inplace */
652 0, /* src_mask */
653 0xffff, /* dst_mask */
654 false), /* pcrel_offset */
655
656 /* 16-bit upper half adjusted section relative relocation. */
657 HOWTO (R_PPC64_SECTOFF_HA, /* type */
658 16, /* rightshift */
659 1, /* size (0 = byte, 1 = short, 2 = long) */
660 16, /* bitsize */
661 false, /* pc_relative */
662 0, /* bitpos */
663 complain_overflow_dont, /* complain_on_overflow */
664 ppc64_elf_addr16_ha_reloc, /* special_function */
665 "R_PPC64_SECTOFF_HA", /* name */
666 false, /* partial_inplace */
667 0, /* src_mask */
668 0xffff, /* dst_mask */
669 false), /* pcrel_offset */
670
671 /* Like R_PPC64_REL24 without touching the two least significant
672 bits. */
673 /* FIXME: Verify R_PPC64_ADDR30. */
674 HOWTO (R_PPC64_ADDR30, /* type */
675 2, /* rightshift */
676 2, /* size (0 = byte, 1 = short, 2 = long) */
677 30, /* bitsize */
678 true, /* pc_relative */
679 0, /* bitpos */
680 complain_overflow_dont, /* complain_on_overflow */
681 bfd_elf_generic_reloc, /* special_function */
682 "R_PPC64_ADDR30", /* name */
683 false, /* partial_inplace */
684 0, /* src_mask */
685 0xfffffffc, /* dst_mask */
686 true), /* pcrel_offset */
687
688 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
689
690 /* A standard 64-bit relocation. */
691 HOWTO (R_PPC64_ADDR64, /* type */
692 0, /* rightshift */
693 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
694 64, /* bitsize */
695 false, /* pc_relative */
696 0, /* bitpos */
697 complain_overflow_dont, /* complain_on_overflow */
698 bfd_elf_generic_reloc, /* special_function */
699 "R_PPC64_ADDR64", /* name */
700 false, /* partial_inplace */
701 0, /* src_mask */
702 0xffffffffffffffff, /* dst_mask */
703 false), /* pcrel_offset */
704
705 /* The bits 32-47 of an address. */
706 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
707 32, /* rightshift */
708 1, /* size (0 = byte, 1 = short, 2 = long) */
709 16, /* bitsize */
710 false, /* pc_relative */
711 0, /* bitpos */
712 complain_overflow_dont, /* complain_on_overflow */
713 bfd_elf_generic_reloc, /* special_function */
714 "R_PPC64_ADDR16_HIGHER", /* name */
715 false, /* partial_inplace */
716 0, /* src_mask */
717 0xffff, /* dst_mask */
718 false), /* pcrel_offset */
719
720 /* The bits 32-47 of an address, plus 1 if the contents of the low
721 16 bits, treated as a signed number, is negative. */
722 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
723 32, /* rightshift */
724 1, /* size (0 = byte, 1 = short, 2 = long) */
725 16, /* bitsize */
726 false, /* pc_relative */
727 0, /* bitpos */
728 complain_overflow_dont, /* complain_on_overflow */
729 ppc64_elf_addr16_ha_reloc, /* special_function */
730 "R_PPC64_ADDR16_HIGHERA", /* name */
731 false, /* partial_inplace */
732 0, /* src_mask */
733 0xffff, /* dst_mask */
734 false), /* pcrel_offset */
735
736 /* The bits 48-63 of an address. */
737 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
738 48, /* rightshift */
739 1, /* size (0 = byte, 1 = short, 2 = long) */
740 16, /* bitsize */
741 false, /* pc_relative */
742 0, /* bitpos */
743 complain_overflow_dont, /* complain_on_overflow */
744 bfd_elf_generic_reloc, /* special_function */
745 "R_PPC64_ADDR16_HIGHEST", /* name */
746 false, /* partial_inplace */
747 0, /* src_mask */
748 0xffff, /* dst_mask */
749 false), /* pcrel_offset */
750
751 /* The bits 48-63 of an address, plus 1 if the contents of the low
752 16 bits, treated as a signed number, is negative. */
753 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
754 48, /* rightshift */
755 1, /* size (0 = byte, 1 = short, 2 = long) */
756 16, /* bitsize */
757 false, /* pc_relative */
758 0, /* bitpos */
759 complain_overflow_dont, /* complain_on_overflow */
760 ppc64_elf_addr16_ha_reloc, /* special_function */
761 "R_PPC64_ADDR16_HIGHESTA", /* name */
762 false, /* partial_inplace */
763 0, /* src_mask */
764 0xffff, /* dst_mask */
765 false), /* pcrel_offset */
766
767 /* Like ADDR64, but may be unaligned. */
768 HOWTO (R_PPC64_UADDR64, /* type */
769 0, /* rightshift */
770 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
771 64, /* bitsize */
772 false, /* pc_relative */
773 0, /* bitpos */
774 complain_overflow_dont, /* complain_on_overflow */
775 bfd_elf_generic_reloc, /* special_function */
776 "R_PPC64_UADDR64", /* name */
777 false, /* partial_inplace */
778 0, /* src_mask */
779 0xffffffffffffffff, /* dst_mask */
780 false), /* pcrel_offset */
781
782 /* 64-bit relative relocation. */
783 HOWTO (R_PPC64_REL64, /* type */
784 0, /* rightshift */
785 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
786 64, /* bitsize */
787 true, /* pc_relative */
788 0, /* bitpos */
789 complain_overflow_dont, /* complain_on_overflow */
790 bfd_elf_generic_reloc, /* special_function */
791 "R_PPC64_REL64", /* name */
792 false, /* partial_inplace */
793 0, /* src_mask */
794 0xffffffffffffffff, /* dst_mask */
795 true), /* pcrel_offset */
796
797 /* 64-bit relocation to the symbol's procedure linkage table. */
798 /* FIXME: R_PPC64_PLT64 not supported. */
799 HOWTO (R_PPC64_PLT64, /* type */
800 0, /* rightshift */
801 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
802 64, /* bitsize */
803 false, /* pc_relative */
804 0, /* bitpos */
805 complain_overflow_dont, /* complain_on_overflow */
806 bfd_elf_generic_reloc, /* special_function */
807 "R_PPC64_PLT64", /* name */
808 false, /* partial_inplace */
809 0, /* src_mask */
810 0, /* dst_mask */
811 false), /* pcrel_offset */
812
813 /* 64-bit PC relative relocation to the symbol's procedure linkage
814 table. */
815 /* FIXME: R_PPC64_PLTREL64 not supported. */
816 HOWTO (R_PPC64_PLTREL64, /* type */
817 0, /* rightshift */
818 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
819 64, /* bitsize */
820 true, /* pc_relative */
821 0, /* bitpos */
822 complain_overflow_dont, /* complain_on_overflow */
823 bfd_elf_generic_reloc, /* special_function */
824 "R_PPC64_PLTREL64", /* name */
825 false, /* partial_inplace */
826 0, /* src_mask */
827 0, /* dst_mask */
828 true), /* pcrel_offset */
829
830 /* 16 bit TOC-relative relocation. */
831
832 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
833 HOWTO (R_PPC64_TOC16, /* type */
834 0, /* rightshift */
835 1, /* size (0 = byte, 1 = short, 2 = long) */
836 16, /* bitsize */
837 false, /* pc_relative */
838 0, /* bitpos */
839 complain_overflow_signed, /* complain_on_overflow */
840 bfd_elf_generic_reloc, /* special_function */
841 "R_PPC64_TOC16", /* name */
842 false, /* partial_inplace */
843 0, /* src_mask */
844 0xffff, /* dst_mask */
845 false), /* pcrel_offset */
846
847 /* 16 bit TOC-relative relocation without overflow. */
848
849 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
850 HOWTO (R_PPC64_TOC16_LO, /* type */
851 0, /* rightshift */
852 1, /* size (0 = byte, 1 = short, 2 = long) */
853 16, /* bitsize */
854 false, /* pc_relative */
855 0, /* bitpos */
856 complain_overflow_dont, /* complain_on_overflow */
857 bfd_elf_generic_reloc, /* special_function */
858 "R_PPC64_TOC16_LO", /* name */
859 false, /* partial_inplace */
860 0, /* src_mask */
861 0xffff, /* dst_mask */
862 false), /* pcrel_offset */
863
864 /* 16 bit TOC-relative relocation, high 16 bits. */
865
866 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
867 HOWTO (R_PPC64_TOC16_HI, /* type */
868 16, /* rightshift */
869 1, /* size (0 = byte, 1 = short, 2 = long) */
870 16, /* bitsize */
871 false, /* pc_relative */
872 0, /* bitpos */
873 complain_overflow_dont, /* complain_on_overflow */
874 bfd_elf_generic_reloc, /* special_function */
875 "R_PPC64_TOC16_HI", /* name */
876 false, /* partial_inplace */
877 0, /* src_mask */
878 0xffff, /* dst_mask */
879 false), /* pcrel_offset */
880
881 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
882 contents of the low 16 bits, treated as a signed number, is
883 negative. */
884
885 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
886 HOWTO (R_PPC64_TOC16_HA, /* type */
887 16, /* rightshift */
888 1, /* size (0 = byte, 1 = short, 2 = long) */
889 16, /* bitsize */
890 false, /* pc_relative */
891 0, /* bitpos */
892 complain_overflow_dont, /* complain_on_overflow */
893 ppc64_elf_addr16_ha_reloc, /* special_function */
894 "R_PPC64_TOC16_HA", /* name */
895 false, /* partial_inplace */
896 0, /* src_mask */
897 0xffff, /* dst_mask */
898 false), /* pcrel_offset */
899
900 /* 64-bit relocation; insert value of TOC base (.TOC.). */
901
902 /* R_PPC64_TOC 51 doubleword64 .TOC. */
903 HOWTO (R_PPC64_TOC, /* type */
904 0, /* rightshift */
905 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
906 64, /* bitsize */
907 false, /* pc_relative */
908 0, /* bitpos */
909 complain_overflow_bitfield, /* complain_on_overflow */
910 bfd_elf_generic_reloc, /* special_function */
911 "R_PPC64_TOC", /* name */
912 false, /* partial_inplace */
913 0, /* src_mask */
914 0xffffffffffffffff, /* dst_mask */
915 false), /* pcrel_offset */
916
917 /* Like R_PPC64_GOT16, but also informs the link editor that the
918 value to relocate may (!) refer to a PLT entry which the link
919 editor (a) may replace with the symbol value. If the link editor
920 is unable to fully resolve the symbol, it may (b) create a PLT
921 entry and store the address to the new PLT entry in the GOT.
922 This permits lazy resolution of function symbols at run time.
923 The link editor may also skip all of this and just (c) emit a
924 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
925 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
926 HOWTO (R_PPC64_PLTGOT16, /* type */
927 0, /* rightshift */
928 1, /* size (0 = byte, 1 = short, 2 = long) */
929 16, /* bitsize */
930 false, /* pc_relative */
931 0, /* bitpos */
932 complain_overflow_signed, /* complain_on_overflow */
933 bfd_elf_generic_reloc, /* special_function */
934 "R_PPC64_PLTGOT16", /* name */
935 false, /* partial_inplace */
936 0, /* src_mask */
937 0xffff, /* dst_mask */
938 false), /* pcrel_offset */
939
940 /* Like R_PPC64_PLTGOT16, but without overflow. */
941 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
942 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
943 0, /* rightshift */
944 1, /* size (0 = byte, 1 = short, 2 = long) */
945 16, /* bitsize */
946 false, /* pc_relative */
947 0, /* bitpos */
948 complain_overflow_dont, /* complain_on_overflow */
949 bfd_elf_generic_reloc, /* special_function */
950 "R_PPC64_PLTGOT16_LO", /* name */
951 false, /* partial_inplace */
952 0, /* src_mask */
953 0xffff, /* dst_mask */
954 false), /* pcrel_offset */
955
956 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
957 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
958 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
959 16, /* rightshift */
960 1, /* size (0 = byte, 1 = short, 2 = long) */
961 16, /* bitsize */
962 false, /* pc_relative */
963 0, /* bitpos */
964 complain_overflow_dont, /* complain_on_overflow */
965 bfd_elf_generic_reloc, /* special_function */
966 "R_PPC64_PLTGOT16_HI", /* name */
967 false, /* partial_inplace */
968 0, /* src_mask */
969 0xffff, /* dst_mask */
970 false), /* pcrel_offset */
971
972 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
973 1 if the contents of the low 16 bits, treated as a signed number,
974 is negative. */
975 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
976 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
977 16, /* rightshift */
978 1, /* size (0 = byte, 1 = short, 2 = long) */
979 16, /* bitsize */
980 false, /* pc_relative */
981 0, /* bitpos */
982 complain_overflow_dont,/* complain_on_overflow */
983 ppc64_elf_addr16_ha_reloc, /* special_function */
984 "R_PPC64_PLTGOT16_HA", /* name */
985 false, /* partial_inplace */
986 0, /* src_mask */
987 0xffff, /* dst_mask */
988 false), /* pcrel_offset */
989
990 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
991 HOWTO (R_PPC64_ADDR16_DS, /* type */
992 0, /* rightshift */
993 1, /* size (0 = byte, 1 = short, 2 = long) */
994 16, /* bitsize */
995 false, /* pc_relative */
996 0, /* bitpos */
997 complain_overflow_bitfield, /* complain_on_overflow */
998 bfd_elf_generic_reloc, /* special_function */
999 "R_PPC64_ADDR16_DS", /* name */
1000 false, /* partial_inplace */
1001 0, /* src_mask */
1002 0xfffc, /* dst_mask */
1003 false), /* pcrel_offset */
1004
1005 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1006 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1007 0, /* rightshift */
1008 1, /* size (0 = byte, 1 = short, 2 = long) */
1009 16, /* bitsize */
1010 false, /* pc_relative */
1011 0, /* bitpos */
1012 complain_overflow_dont,/* complain_on_overflow */
1013 bfd_elf_generic_reloc, /* special_function */
1014 "R_PPC64_ADDR16_LO_DS",/* name */
1015 false, /* partial_inplace */
1016 0, /* src_mask */
1017 0xfffc, /* dst_mask */
1018 false), /* pcrel_offset */
1019
1020 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1021 HOWTO (R_PPC64_GOT16_DS, /* type */
1022 0, /* rightshift */
1023 1, /* size (0 = byte, 1 = short, 2 = long) */
1024 16, /* bitsize */
1025 false, /* pc_relative */
1026 0, /* bitpos */
1027 complain_overflow_signed, /* complain_on_overflow */
1028 bfd_elf_generic_reloc, /* special_function */
1029 "R_PPC64_GOT16_DS", /* name */
1030 false, /* partial_inplace */
1031 0, /* src_mask */
1032 0xfffc, /* dst_mask */
1033 false), /* pcrel_offset */
1034
1035 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1036 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1037 0, /* rightshift */
1038 1, /* size (0 = byte, 1 = short, 2 = long) */
1039 16, /* bitsize */
1040 false, /* pc_relative */
1041 0, /* bitpos */
1042 complain_overflow_dont, /* complain_on_overflow */
1043 bfd_elf_generic_reloc, /* special_function */
1044 "R_PPC64_GOT16_LO_DS", /* name */
1045 false, /* partial_inplace */
1046 0, /* src_mask */
1047 0xfffc, /* dst_mask */
1048 false), /* pcrel_offset */
1049
1050 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1051 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1052 0, /* rightshift */
1053 1, /* size (0 = byte, 1 = short, 2 = long) */
1054 16, /* bitsize */
1055 false, /* pc_relative */
1056 0, /* bitpos */
1057 complain_overflow_dont, /* complain_on_overflow */
1058 bfd_elf_generic_reloc, /* special_function */
1059 "R_PPC64_PLT16_LO_DS", /* name */
1060 false, /* partial_inplace */
1061 0, /* src_mask */
1062 0xfffc, /* dst_mask */
1063 false), /* pcrel_offset */
1064
1065 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1066 /* FIXME: Verify R_PPC64_SECTOFF. Seems strange with size=2 and
1067 dst_mask=0. */
1068 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1069 0, /* rightshift */
1070 2, /* size (0 = byte, 1 = short, 2 = long) */
1071 32, /* bitsize */
1072 true, /* pc_relative */
1073 0, /* bitpos */
1074 complain_overflow_bitfield, /* complain_on_overflow */
1075 bfd_elf_generic_reloc, /* special_function */
1076 "R_PPC64_SECTOFF_DS", /* name */
1077 false, /* partial_inplace */
1078 0, /* src_mask */
1079 0, /* dst_mask */
1080 true), /* pcrel_offset */
1081
1082 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1083 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1084 0, /* rightshift */
1085 1, /* size (0 = byte, 1 = short, 2 = long) */
1086 16, /* bitsize */
1087 false, /* pc_relative */
1088 0, /* bitpos */
1089 complain_overflow_dont, /* complain_on_overflow */
1090 bfd_elf_generic_reloc, /* special_function */
1091 "R_PPC64_SECTOFF_LO_DS",/* name */
1092 false, /* partial_inplace */
1093 0, /* src_mask */
1094 0xfffc, /* dst_mask */
1095 false), /* pcrel_offset */
1096
1097 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1098 HOWTO (R_PPC64_TOC16_DS, /* type */
1099 0, /* rightshift */
1100 1, /* size (0 = byte, 1 = short, 2 = long) */
1101 16, /* bitsize */
1102 false, /* pc_relative */
1103 0, /* bitpos */
1104 complain_overflow_signed, /* complain_on_overflow */
1105 bfd_elf_generic_reloc, /* special_function */
1106 "R_PPC64_TOC16_DS", /* name */
1107 false, /* partial_inplace */
1108 0, /* src_mask */
1109 0xfffc, /* dst_mask */
1110 false), /* pcrel_offset */
1111
1112 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1113 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1114 0, /* rightshift */
1115 1, /* size (0 = byte, 1 = short, 2 = long) */
1116 16, /* bitsize */
1117 false, /* pc_relative */
1118 0, /* bitpos */
1119 complain_overflow_dont, /* complain_on_overflow */
1120 bfd_elf_generic_reloc, /* special_function */
1121 "R_PPC64_TOC16_LO_DS", /* name */
1122 false, /* partial_inplace */
1123 0, /* src_mask */
1124 0xfffc, /* dst_mask */
1125 false), /* pcrel_offset */
1126
1127 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1128 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1129 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1130 0, /* rightshift */
1131 1, /* size (0 = byte, 1 = short, 2 = long) */
1132 16, /* bitsize */
1133 false, /* pc_relative */
1134 0, /* bitpos */
1135 complain_overflow_signed, /* complain_on_overflow */
1136 bfd_elf_generic_reloc, /* special_function */
1137 "R_PPC64_PLTGOT16_DS", /* name */
1138 false, /* partial_inplace */
1139 0, /* src_mask */
1140 0xfffc, /* dst_mask */
1141 false), /* pcrel_offset */
1142
1143 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1144 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1145 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1146 0, /* rightshift */
1147 1, /* size (0 = byte, 1 = short, 2 = long) */
1148 16, /* bitsize */
1149 false, /* pc_relative */
1150 0, /* bitpos */
1151 complain_overflow_dont, /* complain_on_overflow */
1152 bfd_elf_generic_reloc, /* special_function */
1153 "R_PPC64_PLTGOT16_LO_DS",/* name */
1154 false, /* partial_inplace */
1155 0, /* src_mask */
1156 0xfffc, /* dst_mask */
1157 false), /* pcrel_offset */
1158
1159 /* GNU extension to record C++ vtable hierarchy. */
1160 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
1161 0, /* rightshift */
1162 0, /* size (0 = byte, 1 = short, 2 = long) */
1163 0, /* bitsize */
1164 false, /* pc_relative */
1165 0, /* bitpos */
1166 complain_overflow_dont, /* complain_on_overflow */
1167 NULL, /* special_function */
1168 "R_PPC64_GNU_VTINHERIT", /* name */
1169 false, /* partial_inplace */
1170 0, /* src_mask */
1171 0, /* dst_mask */
1172 false), /* pcrel_offset */
1173
1174 /* GNU extension to record C++ vtable member usage. */
1175 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
1176 0, /* rightshift */
1177 0, /* size (0 = byte, 1 = short, 2 = long) */
1178 0, /* bitsize */
1179 false, /* pc_relative */
1180 0, /* bitpos */
1181 complain_overflow_dont, /* complain_on_overflow */
1182 NULL, /* special_function */
1183 "R_PPC64_GNU_VTENTRY", /* name */
1184 false, /* partial_inplace */
1185 0, /* src_mask */
1186 0, /* dst_mask */
1187 false), /* pcrel_offset */
1188};
1189
1190\f
1191/* Initialize the ppc64_elf_howto_table, so that linear accesses can
1192 be done. */
1193
1194static void
1195ppc_howto_init ()
1196{
1197 unsigned int i, type;
1198
1199 for (i = 0;
1200 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
1201 i++)
1202 {
1203 type = ppc64_elf_howto_raw[i].type;
1204 BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
1205 / sizeof (ppc64_elf_howto_table[0])));
1206 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
1207 }
1208}
1209
1210static reloc_howto_type *
1211ppc64_elf_reloc_type_lookup (abfd, code)
1212 bfd *abfd ATTRIBUTE_UNUSED;
1213 bfd_reloc_code_real_type code;
1214{
1215 enum elf_ppc_reloc_type ppc_reloc = R_PPC_NONE;
1216
1217 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
1218 /* Initialize howto table if needed. */
1219 ppc_howto_init ();
1220
1221 switch ((int) code)
1222 {
1223 default:
1224 return (reloc_howto_type *) NULL;
1225
1226 case BFD_RELOC_NONE: ppc_reloc = R_PPC64_NONE;
1227 break;
1228 case BFD_RELOC_32: ppc_reloc = R_PPC64_ADDR32;
1229 break;
1230 case BFD_RELOC_PPC_BA26: ppc_reloc = R_PPC64_ADDR24;
1231 break;
1232 case BFD_RELOC_16: ppc_reloc = R_PPC64_ADDR16;
1233 break;
1234 case BFD_RELOC_LO16: ppc_reloc = R_PPC64_ADDR16_LO;
1235 break;
1236 case BFD_RELOC_HI16: ppc_reloc = R_PPC64_ADDR16_HI;
1237 break;
1238 case BFD_RELOC_HI16_S: ppc_reloc = R_PPC64_ADDR16_HA;
1239 break;
1240 case BFD_RELOC_PPC_BA16: ppc_reloc = R_PPC64_ADDR14;
1241 break;
1242 case BFD_RELOC_PPC_BA16_BRTAKEN: ppc_reloc = R_PPC64_ADDR14_BRTAKEN;
1243 break;
1244 case BFD_RELOC_PPC_BA16_BRNTAKEN: ppc_reloc = R_PPC64_ADDR14_BRNTAKEN;
1245 break;
1246 case BFD_RELOC_PPC_B26: ppc_reloc = R_PPC64_REL24;
1247 break;
1248 case BFD_RELOC_PPC_B16: ppc_reloc = R_PPC64_REL14;
1249 break;
1250 case BFD_RELOC_PPC_B16_BRTAKEN: ppc_reloc = R_PPC64_REL14_BRTAKEN;
1251 break;
1252 case BFD_RELOC_PPC_B16_BRNTAKEN: ppc_reloc = R_PPC64_REL14_BRNTAKEN;
1253 break;
1254 case BFD_RELOC_16_GOTOFF: ppc_reloc = R_PPC64_GOT16;
1255 break;
1256 case BFD_RELOC_LO16_GOTOFF: ppc_reloc = R_PPC64_GOT16_LO;
1257 break;
1258 case BFD_RELOC_HI16_GOTOFF: ppc_reloc = R_PPC64_GOT16_HI;
1259 break;
1260 case BFD_RELOC_HI16_S_GOTOFF: ppc_reloc = R_PPC64_GOT16_HA;
1261 break;
1262 case BFD_RELOC_PPC_COPY: ppc_reloc = R_PPC64_COPY;
1263 break;
1264 case BFD_RELOC_PPC_GLOB_DAT: ppc_reloc = R_PPC64_GLOB_DAT;
1265 break;
1266 case BFD_RELOC_32_PCREL: ppc_reloc = R_PPC64_REL32;
1267 break;
1268 case BFD_RELOC_32_PLTOFF: ppc_reloc = R_PPC64_PLT32;
1269 break;
1270 case BFD_RELOC_32_PLT_PCREL: ppc_reloc = R_PPC64_PLTREL32;
1271 break;
1272 case BFD_RELOC_LO16_PLTOFF: ppc_reloc = R_PPC64_PLT16_LO;
1273 break;
1274 case BFD_RELOC_HI16_PLTOFF: ppc_reloc = R_PPC64_PLT16_HI;
1275 break;
1276 case BFD_RELOC_HI16_S_PLTOFF: ppc_reloc = R_PPC64_PLT16_HA;
1277 break;
1278 case BFD_RELOC_32_BASEREL: ppc_reloc = R_PPC64_SECTOFF;
1279 break;
1280 case BFD_RELOC_LO16_BASEREL: ppc_reloc = R_PPC64_SECTOFF_LO;
1281 break;
1282 case BFD_RELOC_HI16_BASEREL: ppc_reloc = R_PPC64_SECTOFF_HI;
1283 break;
1284 case BFD_RELOC_HI16_S_BASEREL: ppc_reloc = R_PPC64_SECTOFF_HA;
1285 break;
1286 /* FIXME: Is CTOR 32 or 64 bits? Fix md_apply_fix3 in
1287 gas/config/tc-ppc.c too. */
1288 case BFD_RELOC_CTOR: ppc_reloc = R_PPC64_ADDR32;
1289 break;
1290 case BFD_RELOC_64: ppc_reloc = R_PPC64_ADDR64;
1291 break;
1292 case BFD_RELOC_PPC64_HIGHER: ppc_reloc = R_PPC64_ADDR16_HIGHER;
1293 break;
1294 case BFD_RELOC_PPC64_HIGHER_S: ppc_reloc = R_PPC64_ADDR16_HIGHERA;
1295 break;
1296 case BFD_RELOC_PPC64_HIGHEST: ppc_reloc = R_PPC64_ADDR16_HIGHEST;
1297 break;
1298 case BFD_RELOC_PPC64_HIGHEST_S: ppc_reloc = R_PPC64_ADDR16_HIGHESTA;
1299 break;
1300 case BFD_RELOC_64_PCREL: ppc_reloc = R_PPC64_REL64;
1301 break;
1302 case BFD_RELOC_64_PLTOFF: ppc_reloc = R_PPC64_PLT64;
1303 break;
1304 case BFD_RELOC_64_PLT_PCREL: ppc_reloc = R_PPC64_PLTREL64;
1305 break;
1306 case BFD_RELOC_PPC_TOC16: ppc_reloc = R_PPC64_TOC16;
1307 break;
1308 case BFD_RELOC_PPC64_TOC16_LO: ppc_reloc = R_PPC64_TOC16_LO;
1309 break;
1310 case BFD_RELOC_PPC64_TOC16_HI: ppc_reloc = R_PPC64_TOC16_HI;
1311 break;
1312 case BFD_RELOC_PPC64_TOC16_HA: ppc_reloc = R_PPC64_TOC16_HA;
1313 break;
1314 case BFD_RELOC_PPC64_TOC: ppc_reloc = R_PPC64_TOC;
1315 break;
1316 case BFD_RELOC_PPC64_PLTGOT16: ppc_reloc = R_PPC64_PLTGOT16;
1317 break;
1318 case BFD_RELOC_PPC64_PLTGOT16_LO: ppc_reloc = R_PPC64_PLTGOT16_LO;
1319 break;
1320 case BFD_RELOC_PPC64_PLTGOT16_HI: ppc_reloc = R_PPC64_PLTGOT16_HI;
1321 break;
1322 case BFD_RELOC_PPC64_PLTGOT16_HA: ppc_reloc = R_PPC64_PLTGOT16_HA;
1323 break;
1324 case BFD_RELOC_PPC64_ADDR16_DS: ppc_reloc = R_PPC64_ADDR16_DS;
1325 break;
1326 case BFD_RELOC_PPC64_ADDR16_LO_DS: ppc_reloc = R_PPC64_ADDR16_LO_DS;
1327 break;
1328 case BFD_RELOC_PPC64_GOT16_DS: ppc_reloc = R_PPC64_GOT16_DS;
1329 break;
1330 case BFD_RELOC_PPC64_GOT16_LO_DS: ppc_reloc = R_PPC64_GOT16_LO_DS;
1331 break;
1332 case BFD_RELOC_PPC64_PLT16_LO_DS: ppc_reloc = R_PPC64_PLT16_LO_DS;
1333 break;
1334 case BFD_RELOC_PPC64_SECTOFF_DS: ppc_reloc = R_PPC64_SECTOFF_DS;
1335 break;
1336 case BFD_RELOC_PPC64_SECTOFF_LO_DS: ppc_reloc = R_PPC64_SECTOFF_LO_DS;
1337 break;
1338 case BFD_RELOC_PPC64_TOC16_DS: ppc_reloc = R_PPC64_TOC16_DS;
1339 break;
1340 case BFD_RELOC_PPC64_TOC16_LO_DS: ppc_reloc = R_PPC64_TOC16_LO_DS;
1341 break;
1342 case BFD_RELOC_PPC64_PLTGOT16_DS: ppc_reloc = R_PPC64_PLTGOT16_DS;
1343 break;
1344 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: ppc_reloc = R_PPC64_PLTGOT16_LO_DS;
1345 break;
1346 case BFD_RELOC_VTABLE_INHERIT: ppc_reloc = R_PPC64_GNU_VTINHERIT;
1347 break;
1348 case BFD_RELOC_VTABLE_ENTRY: ppc_reloc = R_PPC64_GNU_VTENTRY;
1349 break;
1350 }
1351
1352 return ppc64_elf_howto_table[(int) ppc_reloc];
1353};
1354
1355/* Set the howto pointer for a PowerPC ELF reloc. */
1356
1357static void
1358ppc64_elf_info_to_howto (abfd, cache_ptr, dst)
1359 bfd *abfd ATTRIBUTE_UNUSED;
1360 arelent *cache_ptr;
1361 Elf64_Internal_Rela *dst;
1362{
65f38f15
AM		 1363 unsigned int type;
1364
5bd4f169
AM		 1365 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
1366 /* Initialize howto table if needed. */
1367 ppc_howto_init ();
1368
65f38f15
AM		 1369 type = ELF64_R_TYPE (dst->r_info);
1370 BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
1371 / sizeof (ppc64_elf_howto_table[0])));
1372 cache_ptr->howto = ppc64_elf_howto_table[type];
5bd4f169
AM		 1373}
1374
65f38f15 1375/* Handle the R_PPC_ADDR16_HA and similar relocs. */
5bd4f169
AM		 1376
1377static bfd_reloc_status_type
1378ppc64_elf_addr16_ha_reloc (abfd, reloc_entry, symbol, data, input_section,
1379 output_bfd, error_message)
1380 bfd *abfd ATTRIBUTE_UNUSED;
1381 arelent *reloc_entry;
1382 asymbol *symbol;
1383 PTR data ATTRIBUTE_UNUSED;
1384 asection *input_section;
1385 bfd *output_bfd;
1386 char **error_message ATTRIBUTE_UNUSED;
1387{
1388 bfd_vma relocation;
1389
1390 if (output_bfd != NULL)
1391 {
1392 reloc_entry->address += input_section->output_offset;
1393 return bfd_reloc_ok;
1394 }
1395
1396 if (reloc_entry->address > input_section->_cooked_size)
1397 return bfd_reloc_outofrange;
1398
1399 if (bfd_is_com_section (symbol->section))
1400 relocation = 0;
1401 else
1402 relocation = symbol->value;
1403
1404 relocation += symbol->section->output_section->vma;
1405 relocation += symbol->section->output_offset;
1406 relocation += reloc_entry->addend;
1407
1408 reloc_entry->addend += (relocation & 0x8000) << 1;
1409
1410 return bfd_reloc_continue;
1411}
1412
1413/* Function to set whether a module needs the -mrelocatable bit set. */
1414
1415static boolean
1416ppc64_elf_set_private_flags (abfd, flags)
1417 bfd *abfd;
1418 flagword flags;
1419{
1420 BFD_ASSERT (!elf_flags_init (abfd)
1421 || elf_elfheader (abfd)->e_flags == flags);
1422
1423 elf_elfheader (abfd)->e_flags = flags;
1424 elf_flags_init (abfd) = true;
1425 return true;
1426}
1427
5bd4f169
AM		 1428/* Merge backend specific data from an object file to the output
1429 object file when linking. */
1430static boolean
1431ppc64_elf_merge_private_bfd_data (ibfd, obfd)
1432 bfd *ibfd;
1433 bfd *obfd;
1434{
1435 flagword old_flags;
1436 flagword new_flags;
1437 boolean error;
1438
1439 /* Check if we have the same endianess. */
1440 if (ibfd->xvec->byteorder != obfd->xvec->byteorder
1441 && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
1442 {
1443 const char *msg;
1444
1445 if (bfd_big_endian (ibfd))
1446 msg = _("%s: compiled for a big endian system and target is little endian");
1447 else
1448 msg = _("%s: compiled for a little endian system and target is big endian");
1449
8f615d07 1450 (*_bfd_error_handler) (msg, bfd_archive_filename (ibfd));
5bd4f169
AM		 1451
1452 bfd_set_error (bfd_error_wrong_format);
1453 return false;
1454 }
1455
1456 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1457 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1458 return true;
1459
1460 new_flags = elf_elfheader (ibfd)->e_flags;
1461 old_flags = elf_elfheader (obfd)->e_flags;
1462 if (!elf_flags_init (obfd))
1463 {
1464 /* First call, no flags set. */
1465 elf_flags_init (obfd) = true;
1466 elf_elfheader (obfd)->e_flags = new_flags;
1467 }
1468
1469 else if (new_flags == old_flags)
1470 /* Compatible flags are ok. */
1471 ;
1472
1473 else
1474 {
1475 /* Incompatible flags. Warn about -mrelocatable mismatch.
1476 Allow -mrelocatable-lib to be linked with either. */
1477 error = false;
1478 if ((new_flags & EF_PPC_RELOCATABLE) != 0
1479 && (old_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0)
1480 {
1481 error = true;
1482 (*_bfd_error_handler)
1483 (_("%s: compiled with -mrelocatable and linked with modules compiled normally"),
8f615d07 1484 bfd_archive_filename (ibfd));
5bd4f169
AM		 1485 }
1486 else if ((new_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0
1487 && (old_flags & EF_PPC_RELOCATABLE) != 0)
1488 {
1489 error = true;
1490 (*_bfd_error_handler)
1491 (_("%s: compiled normally and linked with modules compiled with -mrelocatable"),
8f615d07 1492 bfd_archive_filename (ibfd));
5bd4f169
AM		 1493 }
1494
1495 /* The output is -mrelocatable-lib iff both the input files are. */
1496 if (! (new_flags & EF_PPC_RELOCATABLE_LIB))
1497 elf_elfheader (obfd)->e_flags &= ~EF_PPC_RELOCATABLE_LIB;
1498
1499 /* The output is -mrelocatable iff it can't be -mrelocatable-lib,
1500 but each input file is either -mrelocatable or -mrelocatable-lib. */
1501 if (! (elf_elfheader (obfd)->e_flags & EF_PPC_RELOCATABLE_LIB)
1502 && (new_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE))
1503 && (old_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE)))
1504 elf_elfheader (obfd)->e_flags |= EF_PPC_RELOCATABLE;
1505
1506 /* Do not warn about eabi vs. V.4 mismatch, just or in the bit
1507 if any module uses it. */
1508 elf_elfheader (obfd)->e_flags |= (new_flags & EF_PPC_EMB);
1509
1510 new_flags &= ~(EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB);
1511 old_flags &= ~(EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB);
1512
1513 /* Warn about any other mismatches. */
1514 if (new_flags != old_flags)
1515 {
1516 error = true;
1517 (*_bfd_error_handler)
1518 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
8f615d07 1519 bfd_archive_filename (ibfd), (long) new_flags, (long) old_flags);
5bd4f169
AM		 1520 }
1521
1522 if (error)
1523 {
1524 bfd_set_error (bfd_error_bad_value);
1525 return false;
1526 }
1527 }
1528
1529 return true;
1530}
1531
1532/* Handle a PowerPC specific section when reading an object file. This
1533 is called when elfcode.h finds a section with an unknown type. */
1534
1535static boolean
1536ppc64_elf_section_from_shdr (abfd, hdr, name)
1537 bfd *abfd;
1538 Elf64_Internal_Shdr *hdr;
1539 char *name;
1540{
1541 asection *newsect;
1542 flagword flags;
1543
1544 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1545 return false;
1546
1547 newsect = hdr->bfd_section;
1548 flags = bfd_get_section_flags (abfd, newsect);
1549 if (hdr->sh_flags & SHF_EXCLUDE)
1550 flags |= SEC_EXCLUDE;
1551
1552 if (hdr->sh_type == SHT_ORDERED)
1553 flags |= SEC_SORT_ENTRIES;
1554
1555 bfd_set_section_flags (abfd, newsect, flags);
1556 return true;
1557}
1558\f
65f38f15
AM		 1559/* The following functions are specific to the ELF linker, while
1560 functions above are used generally. Those named ppc64_elf_* are
1561 called by the main ELF linker code. They appear in this file more
1562 or less in the order in which they are called. eg.
1563 ppc64_elf_check_relocs is called early in the link process,
1564 ppc64_elf_finish_dynamic_sections is one of the last functions
1565 called. */
1566
1567/* The linker needs to keep track of the number of relocs that it
1568 decides to copy as dynamic relocs in check_relocs for each symbol.
1569 This is so that it can later discard them if they are found to be
1570 unnecessary. We store the information in a field extending the
1571 regular ELF linker hash table. */
1572
1573struct ppc_dyn_relocs
1574{
1575 struct ppc_dyn_relocs *next;
1576
1577 /* The input section of the reloc. */
1578 asection *sec;
1579
1580 /* Total number of relocs copied for the input section. */
1581 bfd_size_type count;
1582
1583 /* Number of pc-relative relocs copied for the input section. */
1584 bfd_size_type pc_count;
1585};
1586
1587/* Of those relocs that might be copied as dynamic relocs, this macro
1588 selects between relative and absolute types. */
1589
1590#define IS_ABSOLUTE_RELOC(RTYPE) \
1591 ((RTYPE) != R_PPC64_REL14 \
1592 && (RTYPE) != R_PPC64_REL14_BRNTAKEN \
1593 && (RTYPE) != R_PPC64_REL14_BRTAKEN \
1594 && (RTYPE) != R_PPC64_REL24 \
1595 && (RTYPE) != R_PPC64_REL32 \
1596 && (RTYPE) != R_PPC64_REL64)
1597
1598/* ppc64 ELF linker hash entry. */
1599
1600struct ppc_link_hash_entry
1601{
1602 struct elf_link_hash_entry elf;
1603
1604 /* Track dynamic relocs copied for this symbol. */
1605 struct ppc_dyn_relocs *dyn_relocs;
1606};
1607
1608/* ppc64 ELF linker hash table. */
1609
1610struct ppc_link_hash_table
1611{
1612 struct elf_link_hash_table elf;
1613
1614 /* Short-cuts to get to dynamic linker sections. */
1615 asection *sgot;
1616 asection *srelgot;
1617 asection *splt;
1618 asection *srelplt;
1619 asection *sdynbss;
1620 asection *srelbss;
1621 asection *sglink;
ec338859
AM		 1622
1623 /* Small local sym to section mapping cache. */
1624 struct sym_sec_cache sym_sec;
65f38f15
AM		 1625};
1626
1627/* Get the ppc64 ELF linker hash table from a link_info structure. */
1628
1629#define ppc_hash_table(p) \
1630 ((struct ppc_link_hash_table *) ((p)->hash))
1631
1632/* Create an entry in a ppc64 ELF linker hash table. */
1633
1634static struct bfd_hash_entry *
1635link_hash_newfunc (entry, table, string)
1636 struct bfd_hash_entry *entry;
1637 struct bfd_hash_table *table;
1638 const char *string;
1639{
1640 /* Allocate the structure if it has not already been allocated by a
1641 subclass. */
1642 if (entry == NULL)
1643 {
1644 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
1645 if (entry == NULL)
1646 return entry;
1647 }
1648
1649 /* Call the allocation method of the superclass. */
1650 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
1651 if (entry != NULL)
1652 {
1653 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
1654
1655 eh->dyn_relocs = NULL;
1656 }
1657
1658 return entry;
1659}
1660
1661/* Create a ppc64 ELF linker hash table. */
1662
1663static struct bfd_link_hash_table *
1664ppc64_elf_link_hash_table_create (abfd)
1665 bfd *abfd;
1666{
1667 struct ppc_link_hash_table *htab;
1668 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
1669
1670 htab = (struct ppc_link_hash_table *) bfd_alloc (abfd, amt);
1671 if (htab == NULL)
1672 return NULL;
1673
1674 if (! _bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc))
1675 {
1676 bfd_release (abfd, htab);
1677 return NULL;
1678 }
1679
1680 htab->sgot = NULL;
1681 htab->srelgot = NULL;
1682 htab->splt = NULL;
1683 htab->srelplt = NULL;
1684 htab->sdynbss = NULL;
1685 htab->srelbss = NULL;
1686 htab->sglink = NULL;
ec338859 1687 htab->sym_sec.abfd = NULL;
65f38f15
AM		 1688
1689 return &htab->elf.root;
1690}
1691
1692/* Create .got and .rela.got sections in DYNOBJ, and set up
1693 shortcuts to them in our hash table. */
1694
1695static boolean
1696create_got_section (dynobj, info)
1697 bfd *dynobj;
1698 struct bfd_link_info *info;
1699{
1700 struct ppc_link_hash_table *htab;
1701
1702 if (! _bfd_elf_create_got_section (dynobj, info))
1703 return false;
1704
1705 htab = ppc_hash_table (info);
1706 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
1707 if (!htab->sgot)
1708 abort ();
1709
1710 htab->srelgot = bfd_make_section (dynobj, ".rela.got");
1711 if (!htab->srelgot
1712 || ! bfd_set_section_flags (dynobj, htab->srelgot,
1713 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
1714 | SEC_IN_MEMORY | SEC_LINKER_CREATED
1715 | SEC_READONLY))
1716 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 3))
1717 return false;
1718 return true;
1719}
5bd4f169
AM		 1720
1721/* Create the .glink section as well as the ordinary dynamic
1722 sections. */
1723
1724static boolean
65f38f15
AM		 1725ppc64_elf_create_dynamic_sections (dynobj, info)
1726 bfd *dynobj;
5bd4f169
AM		 1727 struct bfd_link_info *info;
1728{
65f38f15 1729 struct ppc_link_hash_table *htab;
5bd4f169
AM		 1730 flagword flags;
1731
65f38f15
AM		 1732 htab = ppc_hash_table (info);
1733 if (!htab->sgot && !create_got_section (dynobj, info))
5bd4f169
AM		 1734 return false;
1735
65f38f15 1736 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
5bd4f169 1737 return false;
65f38f15
AM		 1738
1739 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
1740 htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
1741 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
1742 if (!info->shared)
1743 htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
1744
1745 if (!htab->splt || !htab->srelplt || !htab->sdynbss
1746 || (!info->shared && !htab->srelbss))
1747 abort ();
1748
1749 /* Our .plt just contains pointers, no code. */
1750 flags = bfd_get_section_flags (dynobj, htab->splt);
5bd4f169 1751 flags &= ~SEC_CODE;
65f38f15 1752 if (! bfd_set_section_flags (dynobj, htab->splt, flags))
5bd4f169
AM		 1753 return false;
1754
1755 /* Create .glink for global linkage functions. */
1756 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1757 | SEC_LINKER_CREATED);
65f38f15
AM		 1758 htab->sglink = bfd_make_section (dynobj, ".glink");
1759 if (htab->sglink == NULL
1760 || ! bfd_set_section_flags (dynobj, htab->sglink, flags)
1761 || ! bfd_set_section_alignment (dynobj, htab->sglink, 3))
5bd4f169
AM		 1762 return false;
1763
1764 return true;
1765}
1766
65f38f15
AM		 1767/* Copy the extra info we tack onto an elf_link_hash_entry. */
1768
1769static void
1770ppc64_elf_copy_indirect_symbol (dir, ind)
1771 struct elf_link_hash_entry *dir, *ind;
1772{
1773 struct ppc_link_hash_entry *edir, *eind;
1774
1775 edir = (struct ppc_link_hash_entry *) dir;
1776 eind = (struct ppc_link_hash_entry *) ind;
1777
bbd7ec4a 1778 if (eind->dyn_relocs != NULL)
65f38f15 1779 {
bbd7ec4a
AM		 1780 if (edir->dyn_relocs != NULL)
1781 {
1782 struct ppc_dyn_relocs **pp;
1783 struct ppc_dyn_relocs *p;
1784
1e370bd2 1785 if (ind->root.type == bfd_link_hash_indirect)
bbd7ec4a
AM		 1786 abort ();
1787
1788 /* Add reloc counts against the weak sym to the strong sym
1789 list. Merge any entries against the same section. */
1790 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1791 {
1792 struct ppc_dyn_relocs *q;
1793
1794 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1795 if (q->sec == p->sec)
1796 {
1797 q->pc_count += p->pc_count;
1798 q->count += p->count;
1799 *pp = p->next;
1800 break;
1801 }
1802 if (q == NULL)
1803 pp = &p->next;
1804 }
1805 *pp = edir->dyn_relocs;
1806 }
1807
65f38f15
AM		 1808 edir->dyn_relocs = eind->dyn_relocs;
1809 eind->dyn_relocs = NULL;
1810 }
65f38f15
AM		 1811
1812 _bfd_elf_link_hash_copy_indirect (dir, ind);
1813}
1814
5bd4f169 1815/* Look through the relocs for a section during the first phase, and
65f38f15
AM		 1816 calculate needed space in the global offset table, procedure
1817 linkage table, and dynamic reloc sections. */
5bd4f169
AM		 1818
1819static boolean
1820ppc64_elf_check_relocs (abfd, info, sec, relocs)
1821 bfd *abfd;
1822 struct bfd_link_info *info;
1823 asection *sec;
1824 const Elf_Internal_Rela *relocs;
1825{
65f38f15 1826 struct ppc_link_hash_table *htab;
5bd4f169
AM		 1827 Elf_Internal_Shdr *symtab_hdr;
1828 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
1829 const Elf_Internal_Rela *rel;
1830 const Elf_Internal_Rela *rel_end;
5bd4f169 1831 asection *sreloc;
5bd4f169
AM		 1832
1833 if (info->relocateable)
1834 return true;
1835
65f38f15 1836 htab = ppc_hash_table (info);
5bd4f169 1837 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5bd4f169
AM		 1838
1839 sym_hashes = elf_sym_hashes (abfd);
1840 sym_hashes_end = (sym_hashes
1841 + symtab_hdr->sh_size / sizeof (Elf64_External_Sym));
1842 if (!elf_bad_symtab (abfd))
1843 sym_hashes_end -= symtab_hdr->sh_info;
1844
1845 sreloc = NULL;
1846
1847 rel_end = relocs + sec->reloc_count;
1848 for (rel = relocs; rel < rel_end; rel++)
1849 {
1850 unsigned long r_symndx;
1851 struct elf_link_hash_entry *h;
a33d1f77 1852 enum elf_ppc_reloc_type r_type;
5bd4f169
AM		 1853
1854 r_symndx = ELF64_R_SYM (rel->r_info);
1855 if (r_symndx < symtab_hdr->sh_info)
1856 h = NULL;
1857 else
1858 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1859
a33d1f77
AM		 1860 r_type = (enum elf_ppc_reloc_type) ELF64_R_TYPE (rel->r_info);
1861 switch (r_type)
5bd4f169
AM		 1862 {
1863 /* GOT16 relocations */
1864 case R_PPC64_GOT16:
5bd4f169 1865 case R_PPC64_GOT16_DS:
65f38f15
AM		 1866 case R_PPC64_GOT16_HA:
1867 case R_PPC64_GOT16_HI:
1868 case R_PPC64_GOT16_LO:
5bd4f169 1869 case R_PPC64_GOT16_LO_DS:
5bd4f169 1870
65f38f15
AM		 1871 /* This symbol requires a global offset table entry. */
1872 if (htab->sgot == NULL)
5bd4f169 1873 {
65f38f15
AM		 1874 if (htab->elf.dynobj == NULL)
1875 htab->elf.dynobj = abfd;
1876 if (!create_got_section (htab->elf.dynobj, info))
5bd4f169 1877 return false;
5bd4f169
AM		 1878 }
1879
1880 if (h != NULL)
1881 {
65f38f15 1882 h->got.refcount += 1;
5bd4f169
AM		 1883 }
1884 else
1885 {
65f38f15
AM		 1886 bfd_signed_vma *local_got_refcounts;
1887
5bd4f169 1888 /* This is a global offset table entry for a local symbol. */
65f38f15 1889 local_got_refcounts = elf_local_got_refcounts (abfd);
5bd4f169
AM		 1890 if (local_got_refcounts == NULL)
1891 {
dc810e39 1892 bfd_size_type size;
5bd4f169 1893
dc810e39
AM		 1894 size = symtab_hdr->sh_info;
1895 size *= sizeof (bfd_signed_vma);
1896 local_got_refcounts = ((bfd_signed_vma *)
65f38f15 1897 bfd_zalloc (abfd, size));
5bd4f169
AM		 1898 if (local_got_refcounts == NULL)
1899 return false;
1900 elf_local_got_refcounts (abfd) = local_got_refcounts;
5bd4f169 1901 }
65f38f15 1902 local_got_refcounts[r_symndx] += 1;
5bd4f169
AM		 1903 }
1904 break;
1905
5bd4f169 1906 case R_PPC64_PLT16_HA:
65f38f15
AM		 1907 case R_PPC64_PLT16_HI:
1908 case R_PPC64_PLT16_LO:
1909 case R_PPC64_PLT32:
1910 case R_PPC64_PLT64:
5bd4f169
AM		 1911 /* This symbol requires a procedure linkage table entry. We
1912 actually build the entry in adjust_dynamic_symbol,
1913 because this might be a case of linking PIC code without
1914 linking in any dynamic objects, in which case we don't
1915 need to generate a procedure linkage table after all. */
5bd4f169
AM		 1916 if (h == NULL)
1917 {
1918 /* It does not make sense to have a procedure linkage
1919 table entry for a local symbol. */
1920 bfd_set_error (bfd_error_bad_value);
1921 return false;
1922 }
1923
65f38f15
AM		 1924 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
1925 h->plt.refcount += 1;
5bd4f169
AM		 1926 break;
1927
1928 /* The following relocations don't need to propagate the
1929 relocation if linking a shared object since they are
1930 section relative. */
1931 case R_PPC64_SECTOFF:
1932 case R_PPC64_SECTOFF_LO:
1933 case R_PPC64_SECTOFF_HI:
1934 case R_PPC64_SECTOFF_HA:
1935 case R_PPC64_SECTOFF_DS:
1936 case R_PPC64_SECTOFF_LO_DS:
1937 case R_PPC64_TOC16:
1938 case R_PPC64_TOC16_LO:
1939 case R_PPC64_TOC16_HI:
1940 case R_PPC64_TOC16_HA:
1941 case R_PPC64_TOC16_DS:
1942 case R_PPC64_TOC16_LO_DS:
1943 break;
1944
1945 /* This relocation describes the C++ object vtable hierarchy.
1946 Reconstruct it for later use during GC. */
1947 case R_PPC64_GNU_VTINHERIT:
1948 if (!_bfd_elf64_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1949 return false;
1950 break;
1951
1952 /* This relocation describes which C++ vtable entries are actually
1953 used. Record for later use during GC. */
1954 case R_PPC64_GNU_VTENTRY:
1955 if (!_bfd_elf64_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1956 return false;
1957 break;
1958
5bd4f169
AM		 1959 case R_PPC64_REL64:
1960 case R_PPC64_REL32:
1961 case R_PPC64_REL24:
1962 case R_PPC64_REL14:
1963 case R_PPC64_REL14_BRTAKEN:
1964 case R_PPC64_REL14_BRNTAKEN:
65f38f15
AM		 1965 case R_PPC64_ADDR14:
1966 case R_PPC64_ADDR14_BRNTAKEN:
1967 case R_PPC64_ADDR14_BRTAKEN:
1968 case R_PPC64_ADDR16:
1969 case R_PPC64_ADDR16_DS:
1970 case R_PPC64_ADDR16_HA:
1971 case R_PPC64_ADDR16_HI:
1972 case R_PPC64_ADDR16_HIGHER:
1973 case R_PPC64_ADDR16_HIGHERA:
1974 case R_PPC64_ADDR16_HIGHEST:
1975 case R_PPC64_ADDR16_HIGHESTA:
1976 case R_PPC64_ADDR16_LO:
1977 case R_PPC64_ADDR16_LO_DS:
1978 case R_PPC64_ADDR24:
1979 case R_PPC64_ADDR30:
1980 case R_PPC64_ADDR32:
1981 case R_PPC64_ADDR64:
1982 case R_PPC64_UADDR16:
1983 case R_PPC64_UADDR32:
1984 case R_PPC64_UADDR64:
5bd4f169 1985 case R_PPC64_TOC:
65f38f15
AM		 1986 /* If we are creating a shared library, and this is a reloc
1987 against a global symbol, or a non PC relative reloc
1988 against a local symbol, then we need to copy the reloc
1989 into the shared library. However, if we are linking with
1990 -Bsymbolic, we do not need to copy a reloc against a
1991 global symbol which is defined in an object we are
1992 including in the link (i.e., DEF_REGULAR is set). At
1993 this point we have not seen all the input files, so it is
1994 possible that DEF_REGULAR is not set now but will be set
1995 later (it is never cleared). In case of a weak definition,
1996 DEF_REGULAR may be cleared later by a strong definition in
1997 a shared library. We account for that possibility below by
1998 storing information in the relocs_copied field of the hash
1999 table entry. A similar situation occurs when creating
2000 shared libraries and symbol visibility changes render the
2001 symbol local.
2002
2003 If on the other hand, we are creating an executable, we
2004 may need to keep relocations for symbols satisfied by a
2005 dynamic library if we manage to avoid copy relocs for the
2006 symbol. */
2007 if ((info->shared
2008 && (sec->flags & SEC_ALLOC) != 0
a33d1f77 2009 && (IS_ABSOLUTE_RELOC (r_type)
65f38f15
AM		 2010 || (h != NULL
2011 && (! info->symbolic
2012 || h->root.type == bfd_link_hash_defweak
2013 || (h->elf_link_hash_flags
2014 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2015 || (!info->shared
2016 && (sec->flags & SEC_ALLOC) != 0
2017 && h != NULL
2018 && (h->root.type == bfd_link_hash_defweak
2019 || (h->elf_link_hash_flags
2020 & ELF_LINK_HASH_DEF_REGULAR) == 0)))
5bd4f169 2021 {
ec338859
AM		 2022 struct ppc_dyn_relocs *p;
2023 struct ppc_dyn_relocs **head;
2024
65f38f15
AM		 2025 /* We must copy these reloc types into the output file.
2026 Create a reloc section in dynobj and make room for
2027 this reloc. */
5bd4f169
AM		 2028 if (sreloc == NULL)
2029 {
2030 const char *name;
65f38f15 2031 bfd *dynobj;
5bd4f169
AM		 2032
2033 name = (bfd_elf_string_from_elf_section
2034 (abfd,
2035 elf_elfheader (abfd)->e_shstrndx,
2036 elf_section_data (sec)->rel_hdr.sh_name));
2037 if (name == NULL)
2038 return false;
2039
65f38f15
AM		 2040 if (strncmp (name, ".rela", 5) != 0
2041 || strcmp (bfd_get_section_name (abfd, sec),
2042 name + 5) != 0)
2043 {
2044 (*_bfd_error_handler)
2045 (_("%s: bad relocation section name `%s\'"),
2046 bfd_archive_filename (abfd), name);
2047 }
2048
2049 if (htab->elf.dynobj == NULL)
2050 htab->elf.dynobj = abfd;
5bd4f169 2051
65f38f15 2052 dynobj = htab->elf.dynobj;
5bd4f169
AM		 2053 sreloc = bfd_get_section_by_name (dynobj, name);
2054 if (sreloc == NULL)
2055 {
2056 flagword flags;
2057
2058 sreloc = bfd_make_section (dynobj, name);
2059 flags = (SEC_HAS_CONTENTS | SEC_READONLY
2060 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2061 if ((sec->flags & SEC_ALLOC) != 0)
2062 flags |= SEC_ALLOC | SEC_LOAD;
2063 if (sreloc == NULL
2064 || ! bfd_set_section_flags (dynobj, sreloc, flags)
65f38f15 2065 || ! bfd_set_section_alignment (dynobj, sreloc, 3))
5bd4f169
AM		 2066 return false;
2067 }
65f38f15 2068 elf_section_data (sec)->sreloc = sreloc;
5bd4f169
AM		 2069 }
2070
65f38f15
AM		 2071 /* If this is a global symbol, we count the number of
2072 relocations we need for this symbol. */
2073 if (h != NULL)
2074 {
ec338859 2075 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
65f38f15
AM		 2076 }
2077 else
2078 {
ec338859
AM		 2079 /* Track dynamic relocs needed for local syms too.
2080 We really need local syms available to do this
2081 easily. Oh well. */
2082
2083 asection *s;
2084 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
2085 sec, r_symndx);
2086 if (s == NULL)
2087 return false;
2088
2089 head = ((struct ppc_dyn_relocs **)
2090 &elf_section_data (s)->local_dynrel);
65f38f15 2091 }
ec338859
AM		 2092
2093 p = *head;
2094 if (p == NULL || p->sec != sec)
2095 {
2096 p = ((struct ppc_dyn_relocs *)
2097 bfd_alloc (htab->elf.dynobj,
2098 (bfd_size_type) sizeof *p));
2099 if (p == NULL)
2100 return false;
2101 p->next = *head;
2102 *head = p;
2103 p->sec = sec;
2104 p->count = 0;
2105 p->pc_count = 0;
2106 }
2107
2108 p->count += 1;
2109 if (!IS_ABSOLUTE_RELOC (r_type))
2110 p->pc_count += 1;
65f38f15 2111 }
5bd4f169 2112 break;
65f38f15
AM		 2113
2114 default:
5bd4f169
AM		 2115 }
2116 }
2117
2118 return true;
2119}
2120
2121/* Return the section that should be marked against GC for a given
2122 relocation. */
2123
2124static asection *
2125ppc64_elf_gc_mark_hook (abfd, info, rel, h, sym)
2126 bfd *abfd;
2127 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2128 Elf_Internal_Rela *rel;
2129 struct elf_link_hash_entry *h;
2130 Elf_Internal_Sym *sym;
2131{
2132 if (h != NULL)
2133 {
a33d1f77
AM		 2134 enum elf_ppc_reloc_type r_type;
2135
2136 r_type = (enum elf_ppc_reloc_type) ELF64_R_TYPE (rel->r_info);
2137 switch (r_type)
5bd4f169
AM		 2138 {
2139 case R_PPC64_GNU_VTINHERIT:
2140 case R_PPC64_GNU_VTENTRY:
2141 break;
2142
2143 default:
2144 switch (h->root.type)
2145 {
2146 case bfd_link_hash_defined:
2147 case bfd_link_hash_defweak:
2148 return h->root.u.def.section;
2149
2150 case bfd_link_hash_common:
2151 return h->root.u.c.p->section;
2152
2153 default:
2154 break;
2155 }
2156 }
2157 }
2158 else
2159 {
9ad5cbcf 2160 return bfd_section_from_elf_index (abfd, sym->st_shndx);
5bd4f169
AM		 2161 }
2162
2163 return NULL;
2164}
2165
65f38f15
AM		 2166/* Update the .got, .plt. and dynamic reloc reference counts for the
2167 section being removed. */
5bd4f169
AM		 2168
2169static boolean
2170ppc64_elf_gc_sweep_hook (abfd, info, sec, relocs)
2171 bfd *abfd;
2172 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2173 asection *sec;
2174 const Elf_Internal_Rela *relocs;
2175{
2176 Elf_Internal_Shdr *symtab_hdr;
2177 struct elf_link_hash_entry **sym_hashes;
2178 bfd_signed_vma *local_got_refcounts;
2179 const Elf_Internal_Rela *rel, *relend;
5bd4f169 2180
ec338859
AM		 2181 elf_section_data (sec)->local_dynrel = NULL;
2182
5bd4f169
AM		 2183 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2184 sym_hashes = elf_sym_hashes (abfd);
2185 local_got_refcounts = elf_local_got_refcounts (abfd);
2186
2187 relend = relocs + sec->reloc_count;
2188 for (rel = relocs; rel < relend; rel++)
a33d1f77
AM		 2189 {
2190 unsigned long r_symndx;
2191 enum elf_ppc_reloc_type r_type;
2192 struct elf_link_hash_entry *h;
5bd4f169 2193
a33d1f77
AM		 2194 r_symndx = ELF64_R_SYM (rel->r_info);
2195 r_type = (enum elf_ppc_reloc_type) ELF64_R_TYPE (rel->r_info);
2196 switch (r_type)
2197 {
2198 case R_PPC64_GOT16:
2199 case R_PPC64_GOT16_DS:
2200 case R_PPC64_GOT16_HA:
2201 case R_PPC64_GOT16_HI:
2202 case R_PPC64_GOT16_LO:
2203 case R_PPC64_GOT16_LO_DS:
2204 if (r_symndx >= symtab_hdr->sh_info)
2205 {
2206 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2207 if (h->got.refcount > 0)
2208 h->got.refcount--;
2209 }
2210 else
2211 {
2212 if (local_got_refcounts[r_symndx] > 0)
2213 local_got_refcounts[r_symndx]--;
2214 }
2215 break;
65f38f15 2216
a33d1f77
AM		 2217 case R_PPC64_PLT16_HA:
2218 case R_PPC64_PLT16_HI:
2219 case R_PPC64_PLT16_LO:
2220 case R_PPC64_PLT32:
2221 case R_PPC64_PLT64:
2222 if (r_symndx >= symtab_hdr->sh_info)
2223 {
2224 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2225 if (h->plt.refcount > 0)
2226 h->plt.refcount--;
2227 }
2228 break;
65f38f15 2229
a33d1f77
AM		 2230 case R_PPC64_REL14:
2231 case R_PPC64_REL14_BRNTAKEN:
2232 case R_PPC64_REL14_BRTAKEN:
2233 case R_PPC64_REL24:
2234 case R_PPC64_REL32:
2235 case R_PPC64_REL64:
2236 if (r_symndx >= symtab_hdr->sh_info)
2237 {
2238 struct ppc_link_hash_entry *eh;
2239 struct ppc_dyn_relocs **pp;
2240 struct ppc_dyn_relocs *p;
65f38f15 2241
a33d1f77
AM		 2242 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2243 eh = (struct ppc_link_hash_entry *) h;
65f38f15 2244
a33d1f77
AM		 2245 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
2246 if (p->sec == sec)
2247 {
2248 p->pc_count -= 1;
2249 p->count -= 1;
2250 if (p->count == 0)
2251 *pp = p->next;
2252 break;
2253 }
2254 }
2255 break;
65f38f15 2256
a33d1f77
AM		 2257 case R_PPC64_ADDR14:
2258 case R_PPC64_ADDR14_BRNTAKEN:
2259 case R_PPC64_ADDR14_BRTAKEN:
2260 case R_PPC64_ADDR16:
2261 case R_PPC64_ADDR16_DS:
2262 case R_PPC64_ADDR16_HA:
2263 case R_PPC64_ADDR16_HI:
2264 case R_PPC64_ADDR16_HIGHER:
2265 case R_PPC64_ADDR16_HIGHERA:
2266 case R_PPC64_ADDR16_HIGHEST:
2267 case R_PPC64_ADDR16_HIGHESTA:
2268 case R_PPC64_ADDR16_LO:
2269 case R_PPC64_ADDR16_LO_DS:
2270 case R_PPC64_ADDR24:
2271 case R_PPC64_ADDR30:
2272 case R_PPC64_ADDR32:
2273 case R_PPC64_ADDR64:
2274 case R_PPC64_UADDR16:
2275 case R_PPC64_UADDR32:
2276 case R_PPC64_UADDR64:
2277 case R_PPC64_TOC:
2278 if (r_symndx >= symtab_hdr->sh_info)
2279 {
2280 struct ppc_link_hash_entry *eh;
2281 struct ppc_dyn_relocs **pp;
2282 struct ppc_dyn_relocs *p;
65f38f15 2283
a33d1f77
AM		 2284 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2285 eh = (struct ppc_link_hash_entry *) h;
2286
2287 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
2288 if (p->sec == sec)
2289 {
2290 p->count -= 1;
2291 if (p->count == 0)
2292 *pp = p->next;
2293 break;
2294 }
2295 }
2296 break;
5bd4f169 2297
a33d1f77
AM		 2298 default:
2299 break;
2300 }
2301 }
5bd4f169
AM		 2302 return true;
2303}
2304
2305/* Adjust a symbol defined by a dynamic object and referenced by a
2306 regular object. The current definition is in some section of the
2307 dynamic object, but we're not including those sections. We have to
2308 change the definition to something the rest of the link can
2309 understand. */
2310
2311static boolean
2312ppc64_elf_adjust_dynamic_symbol (info, h)
2313 struct bfd_link_info *info;
2314 struct elf_link_hash_entry *h;
2315{
65f38f15
AM		 2316 struct ppc_link_hash_table *htab;
2317 struct ppc_link_hash_entry * eh;
2318 struct ppc_dyn_relocs *p;
5bd4f169
AM		 2319 asection *s;
2320 unsigned int power_of_two;
5bd4f169 2321
65f38f15 2322 htab = ppc_hash_table (info);
5bd4f169 2323
65f38f15
AM		 2324 /* If this is a function, put it in the procedure linkage table. We
2325 will fill in the contents of the procedure linkage table later. */
5bd4f169
AM		 2326 if (h->type == STT_FUNC
2327 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2328 {
65f38f15
AM		 2329 struct elf_link_hash_entry *fdh;
2330
2331 /* If it's a function entry point, the name starts with a dot
2332 unless someone has written some poor assembly code. The ABI
2333 for .plt calls requires that there be a function descriptor
2334 sym which has the name of the function minus the dot. */
2335
2336 if (h->plt.refcount <= 0
2337 || h->root.root.string[0] != '.'
2338 || h->root.root.string[1] == '\0'
2339 || (! info->shared
2340 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
2341 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0))
5bd4f169 2342 {
65f38f15
AM		 2343 /* This case can occur if we saw a PLT reloc in an input
2344 file, but the symbol was never referred to by a dynamic
2345 object, or if all references were garbage collected. In
2346 such a case, we don't actually need to build a procedure
2347 linkage table entry. */
5bd4f169
AM		 2348 h->plt.offset = (bfd_vma) -1;
2349 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2350 return true;
2351 }
2352
65f38f15
AM		 2353 /* Find the corresponding function descriptor symbol. Create it
2354 as undefined if necessary. ppc_elf64_finish_dynamic_symbol
2355 will look it up again and create a JMP_SLOT reloc for it. */
5bd4f169 2356
65f38f15
AM		 2357 fdh = elf_link_hash_lookup (elf_hash_table (info),
2358 h->root.root.string + 1,
2359 false, false, false);
5bd4f169 2360
65f38f15 2361 if (fdh == NULL)
5bd4f169 2362 {
65f38f15
AM		 2363 asymbol *newsym;
2364
2365 /* Create it as undefined. */
2366 newsym = bfd_make_empty_symbol (htab->elf.dynobj);
2367 newsym->name = h->root.root.string + 1;
2368 newsym->section = bfd_und_section_ptr;
2369 newsym->value = 0;
2370 newsym->flags = BSF_DYNAMIC | BSF_OBJECT;
2371
2372 if ( !(_bfd_generic_link_add_one_symbol
2373 (info, htab->elf.dynobj, newsym->name, newsym->flags,
2374 newsym->section, newsym->value, NULL, false, false,
2375 (struct bfd_link_hash_entry **) &fdh)))
5bd4f169 2376 {
65f38f15 2377 return false;
5bd4f169 2378 }
5bd4f169 2379 }
5bd4f169
AM		 2380 return true;
2381 }
bbd7ec4a
AM		 2382 else
2383 h->plt.offset = (bfd_vma) -1;
5bd4f169
AM		 2384
2385 /* If this is a weak symbol, and there is a real definition, the
2386 processor independent code will have arranged for us to see the
2387 real definition first, and we can just use the same value. */
2388 if (h->weakdef != NULL)
2389 {
2390 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2391 || h->weakdef->root.type == bfd_link_hash_defweak);
2392 h->root.u.def.section = h->weakdef->root.u.def.section;
2393 h->root.u.def.value = h->weakdef->root.u.def.value;
0a991dfe 2394 return true;
5bd4f169
AM		 2395 }
2396
2397 /* This is a reference to a symbol defined by a dynamic object which
2398 is not a function. */
2399
2400 /* If we are creating a shared library, we must presume that the
2401 only references to the symbol are via the global offset table.
2402 For such cases we need not do anything here; the relocations will
2403 be handled correctly by relocate_section. */
2404 if (info->shared)
2405 return true;
2406
65f38f15
AM		 2407 /* If there are no references to this symbol that do not use the
2408 GOT, we don't need to generate a copy reloc. */
2409 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
2410 return true;
2411
2412 eh = (struct ppc_link_hash_entry *) h;
2413 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2414 {
2415 s = p->sec->output_section;
2416 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2417 break;
2418 }
2419
2420 /* If we didn't find any dynamic relocs in read-only sections, then
2421 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2422 if (p == NULL)
2423 {
2424 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
2425 return true;
2426 }
2427
5bd4f169
AM		 2428 /* We must allocate the symbol in our .dynbss section, which will
2429 become part of the .bss section of the executable. There will be
2430 an entry for this symbol in the .dynsym section. The dynamic
2431 object will contain position independent code, so all references
2432 from the dynamic object to this symbol will go through the global
2433 offset table. The dynamic linker will use the .dynsym entry to
2434 determine the address it must put in the global offset table, so
2435 both the dynamic object and the regular object will refer to the
2436 same memory location for the variable. */
5bd4f169
AM		 2437
2438 /* We must generate a R_PPC_COPY reloc to tell the dynamic linker to
2439 copy the initial value out of the dynamic object and into the
2440 runtime process image. We need to remember the offset into the
2441 .rela.bss section we are going to use. */
2442 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2443 {
65f38f15 2444 htab->srelbss->_raw_size += sizeof (Elf64_External_Rela);
5bd4f169
AM		 2445 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
2446 }
2447
2448 /* We need to figure out the alignment required for this symbol. I
2449 have no idea how ELF linkers handle this. */
2450 power_of_two = bfd_log2 (h->size);
2451 if (power_of_two > 4)
2452 power_of_two = 4;
2453
2454 /* Apply the required alignment. */
65f38f15
AM		 2455 s = htab->sdynbss;
2456 s->_raw_size = BFD_ALIGN (s->_raw_size, (bfd_size_type) (1 << power_of_two));
2457 if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
5bd4f169 2458 {
65f38f15 2459 if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
5bd4f169
AM		 2460 return false;
2461 }
2462
2463 /* Define the symbol as being at this point in the section. */
2464 h->root.u.def.section = s;
2465 h->root.u.def.value = s->_raw_size;
2466
2467 /* Increment the section size to make room for the symbol. */
2468 s->_raw_size += h->size;
2469
2470 return true;
2471}
2472
65f38f15
AM		 2473/* This is the condition under which ppc64_elf_finish_dynamic_symbol
2474 will be called from elflink.h. If elflink.h doesn't call our
2475 finish_dynamic_symbol routine, we'll need to do something about
2476 initializing any .plt and .got entries in ppc64_elf_relocate_section. */
2477#define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
2478 ((DYN) \
2479 && ((INFO)->shared \
2480 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
2481 && ((H)->dynindx != -1 \
2482 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
5bd4f169 2483
65f38f15
AM		 2484/* Allocate space in .plt, .got and associated reloc sections for
2485 dynamic relocs. */
5bd4f169
AM		 2486
2487static boolean
65f38f15
AM		 2488allocate_dynrelocs (h, inf)
2489 struct elf_link_hash_entry *h;
2490 PTR inf;
5bd4f169 2491{
65f38f15
AM		 2492 struct bfd_link_info *info;
2493 struct ppc_link_hash_table *htab;
5bd4f169 2494 asection *s;
65f38f15
AM		 2495 struct ppc_link_hash_entry *eh;
2496 struct ppc_dyn_relocs *p;
5bd4f169 2497
65f38f15
AM		 2498 if (h->root.type == bfd_link_hash_indirect
2499 || h->root.type == bfd_link_hash_warning)
2500 return true;
5bd4f169 2501
65f38f15
AM		 2502 info = (struct bfd_link_info *) inf;
2503 htab = ppc_hash_table (info);
5bd4f169 2504
65f38f15
AM		 2505 if (htab->elf.dynamic_sections_created
2506 && h->plt.refcount > 0)
5bd4f169 2507 {
65f38f15
AM		 2508 /* Make sure this symbol is output as a dynamic symbol.
2509 Undefined weak syms won't yet be marked as dynamic. */
2510 if (h->dynindx == -1
2511 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
5bd4f169 2512 {
65f38f15
AM		 2513 if (! bfd_elf64_link_record_dynamic_symbol (info, h))
2514 return false;
5bd4f169 2515 }
5bd4f169 2516
65f38f15
AM		 2517 BFD_ASSERT (h->root.root.string[0] == '.'
2518 && h->root.root.string[1] != '\0');
5bd4f169 2519
65f38f15
AM		 2520 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
2521 {
2522 /* Make sure the corresponding function descriptor symbol is
2523 dynamic too. */
2524
2525 if (h->dynindx != -1)
2526 {
2527 struct elf_link_hash_entry *fdh;
5bd4f169 2528
65f38f15
AM		 2529 fdh = elf_link_hash_lookup (elf_hash_table (info),
2530 h->root.root.string + 1,
2531 false, false, false);
5bd4f169 2532
65f38f15
AM		 2533 if (fdh == NULL)
2534 abort ();
5bd4f169 2535
65f38f15
AM		 2536 if (fdh->dynindx == -1
2537 && (fdh->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
2538 {
2539 if (! bfd_elf64_link_record_dynamic_symbol (info, fdh))
2540 return false;
2541 }
2542 }
2543
2544 /* If this is the first .plt entry, make room for the special
2545 first entry. */
2546 s = htab->splt;
5bd4f169 2547 if (s->_raw_size == 0)
65f38f15
AM		 2548 s->_raw_size += PLT_INITIAL_ENTRY_SIZE;
2549
2550 h->plt.offset = s->_raw_size;
2551
2552 /* Make room for this entry. */
2553 s->_raw_size += PLT_ENTRY_SIZE;
2554
2555 /* Point the function at the linkage stub. This works because
2556 the only references to the function code sym are calls.
2557 Function pointer comparisons use the function descriptor. */
2558 s = htab->sglink;
2559 h->root.type = bfd_link_hash_defined;
2560 h->root.u.def.section = s;
2561 h->root.u.def.value = s->_raw_size;
2562 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2563
2564 /* Make room for global linkage code in .glink. */
2565 s->_raw_size += PPC64_ELF_GLINK_SIZE;
2566
2567 /* We also need to make an entry in the .rela.plt section. */
2568 s = htab->srelplt;
2569 s->_raw_size += sizeof (Elf64_External_Rela);
2570 }
2571 else
2572 {
2573 h->plt.offset = (bfd_vma) -1;
2574 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2575 }
2576 }
2577 else
2578 {
2579 h->plt.offset = (bfd_vma) -1;
2580 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2581 }
2582
2583 if (h->got.refcount > 0)
2584 {
2585 boolean dyn;
2586
2587 /* Make sure this symbol is output as a dynamic symbol.
2588 Undefined weak syms won't yet be marked as dynamic. */
2589 if (h->dynindx == -1
2590 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
2591 {
2592 if (! bfd_elf64_link_record_dynamic_symbol (info, h))
2593 return false;
2594 }
2595
2596 s = htab->sgot;
2597 h->got.offset = s->_raw_size;
2598 s->_raw_size += 8;
2599 dyn = htab->elf.dynamic_sections_created;
2600 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h))
2601 htab->srelgot->_raw_size += sizeof (Elf64_External_Rela);
2602 }
2603 else
2604 h->got.offset = (bfd_vma) -1;
2605
2606 eh = (struct ppc_link_hash_entry *) h;
2607 if (eh->dyn_relocs == NULL)
2608 return true;
2609
2610 /* In the shared -Bsymbolic case, discard space allocated for
2611 dynamic pc-relative relocs against symbols which turn out to be
2612 defined in regular objects. For the normal shared case, discard
2613 space for relocs that have become local due to symbol visibility
2614 changes. */
2615
2616 if (info->shared)
2617 {
2618 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
2619 && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
2620 || info->symbolic))
2621 {
2622 struct ppc_dyn_relocs **pp;
2623
2624 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
5bd4f169 2625 {
65f38f15
AM		 2626 p->count -= p->pc_count;
2627 p->pc_count = 0;
2628 if (p->count == 0)
2629 *pp = p->next;
2630 else
2631 pp = &p->next;
5bd4f169 2632 }
65f38f15
AM		 2633 }
2634 }
2635 else
2636 {
2637 /* For the non-shared case, discard space for relocs against
2638 symbols which turn out to need copy relocs or are not
2639 dynamic. */
2640
2641 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
2642 && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2643 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2644 || (htab->elf.dynamic_sections_created
2645 && (h->root.type == bfd_link_hash_undefweak
2646 || h->root.type == bfd_link_hash_undefined))))
2647 {
2648 /* Make sure this symbol is output as a dynamic symbol.
2649 Undefined weak syms won't yet be marked as dynamic. */
2650 if (h->dynindx == -1
2651 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
2652 {
ec338859 2653 if (! bfd_elf64_link_record_dynamic_symbol (info, h))
65f38f15
AM		 2654 return false;
2655 }
2656
2657 /* If that succeeded, we know we'll be keeping all the
2658 relocs. */
2659 if (h->dynindx != -1)
2660 goto keep;
2661 }
2662
2663 eh->dyn_relocs = NULL;
2664
ec338859 2665 keep: ;
65f38f15
AM		 2666 }
2667
2668 /* Finally, allocate space. */
2669 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2670 {
2671 asection *sreloc = elf_section_data (p->sec)->sreloc;
2672 sreloc->_raw_size += p->count * sizeof (Elf64_External_Rela);
2673 }
2674
2675 return true;
2676}
2677
2678/* Find any dynamic relocs that apply to read-only sections. */
2679
2680static boolean
2681readonly_dynrelocs (h, inf)
2682 struct elf_link_hash_entry *h;
2683 PTR inf;
2684{
2685 struct ppc_link_hash_entry *eh;
2686 struct ppc_dyn_relocs *p;
2687
2688 eh = (struct ppc_link_hash_entry *) h;
2689 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2690 {
2691 asection *s = p->sec->output_section;
2692
2693 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2694 {
2695 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2696
2697 info->flags |= DF_TEXTREL;
2698
2699 /* Not an error, just cut short the traversal. */
2700 return false;
2701 }
2702 }
2703 return true;
2704}
2705
2706/* Set the sizes of the dynamic sections. */
2707
2708static boolean
2709ppc64_elf_size_dynamic_sections (output_bfd, info)
2710 bfd *output_bfd ATTRIBUTE_UNUSED;
2711 struct bfd_link_info *info;
2712{
2713 struct ppc_link_hash_table *htab;
2714 bfd *dynobj;
2715 asection *s;
2716 boolean relocs;
2717 bfd *ibfd;
2718
2719 htab = ppc_hash_table (info);
2720 dynobj = htab->elf.dynobj;
2721 if (dynobj == NULL)
2722 abort ();
2723
2724 if (htab->elf.dynamic_sections_created)
2725 {
2726 /* Set the contents of the .interp section to the interpreter. */
2727 if (! info->shared)
2728 {
2729 s = bfd_get_section_by_name (dynobj, ".interp");
2730 if (s == NULL)
2731 abort ();
2732 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
2733 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2734 }
2735 }
2736
2737 /* Set up .got offsets for local syms, and space for local dynamic
2738 relocs. */
2739 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2740 {
2741 bfd_signed_vma *local_got;
2742 bfd_signed_vma *end_local_got;
2743 bfd_size_type locsymcount;
2744 Elf_Internal_Shdr *symtab_hdr;
2745 asection *srel;
2746
2747 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2748 continue;
2749
2750 for (s = ibfd->sections; s != NULL; s = s->next)
2751 {
ec338859 2752 struct ppc_dyn_relocs *p;
65f38f15 2753
ec338859
AM		 2754 for (p = *((struct ppc_dyn_relocs **)
2755 &elf_section_data (s)->local_dynrel);
2756 p != NULL;
2757 p = p->next)
65f38f15 2758 {
ec338859
AM		 2759 if (!bfd_is_abs_section (p->sec)
2760 && bfd_is_abs_section (p->sec->output_section))
2761 {
2762 /* Input section has been discarded, either because
2763 it is a copy of a linkonce section or due to
2764 linker script /DISCARD/, so we'll be discarding
2765 the relocs too. */
2766 }
2767 else
2768 {
2769 srel = elf_section_data (p->sec)->sreloc;
2770 srel->_raw_size += p->count * sizeof (Elf64_External_Rela);
2771 }
65f38f15
AM		 2772 }
2773 }
2774
2775 local_got = elf_local_got_refcounts (ibfd);
2776 if (!local_got)
2777 continue;
2778
2779 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2780 locsymcount = symtab_hdr->sh_info;
2781 end_local_got = local_got + locsymcount;
2782 s = htab->sgot;
2783 srel = htab->srelgot;
2784 for (; local_got < end_local_got; ++local_got)
2785 {
2786 if (*local_got > 0)
5bd4f169 2787 {
65f38f15
AM		 2788 *local_got = s->_raw_size;
2789 s->_raw_size += 8;
2790 if (info->shared)
2791 srel->_raw_size += sizeof (Elf64_External_Rela);
5bd4f169 2792 }
65f38f15
AM		 2793 else
2794 *local_got = (bfd_vma) -1;
2795 }
2796 }
2797
2798 /* Allocate global sym .plt and .got entries, and space for global
2799 sym dynamic relocs. */
2800 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
2801
2802 /* We now have determined the sizes of the various dynamic sections.
2803 Allocate memory for them. */
2804 relocs = false;
2805 for (s = dynobj->sections; s != NULL; s = s->next)
2806 {
2807 if ((s->flags & SEC_LINKER_CREATED) == 0)
2808 continue;
2809
2810 if (s == htab->splt
2811 || s == htab->sgot
2812 || s == htab->sglink)
2813 {
2814 /* Strip this section if we don't need it; see the
2815 comment below. */
5bd4f169 2816 }
65f38f15 2817 else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
5bd4f169
AM		 2818 {
2819 if (s->_raw_size == 0)
2820 {
2821 /* If we don't need this section, strip it from the
2822 output file. This is mostly to handle .rela.bss and
2823 .rela.plt. We must create both sections in
2824 create_dynamic_sections, because they must be created
2825 before the linker maps input sections to output
2826 sections. The linker does that before
2827 adjust_dynamic_symbol is called, and it is that
2828 function which decides whether anything needs to go
2829 into these sections. */
5bd4f169
AM		 2830 }
2831 else
2832 {
65f38f15
AM		 2833 if (s != htab->srelplt)
2834 relocs = true;
5bd4f169
AM		 2835
2836 /* We use the reloc_count field as a counter if we need
2837 to copy relocs into the output file. */
2838 s->reloc_count = 0;
2839 }
2840 }
65f38f15 2841 else
5bd4f169
AM		 2842 {
2843 /* It's not one of our sections, so don't allocate space. */
2844 continue;
2845 }
2846
65f38f15 2847 if (s->_raw_size == 0)
5bd4f169
AM		 2848 {
2849 _bfd_strip_section_from_output (info, s);
2850 continue;
2851 }
2852
65f38f15
AM		 2853 /* Allocate memory for the section contents. We use bfd_zalloc
2854 here in case unused entries are not reclaimed before the
2855 section's contents are written out. This should not happen,
2856 but this way if it does, we get a R_PPC64_NONE reloc instead
2857 of garbage. */
5bd4f169 2858 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
65f38f15 2859 if (s->contents == NULL)
5bd4f169
AM		 2860 return false;
2861 }
2862
2863 if (elf_hash_table (info)->dynamic_sections_created)
2864 {
2865 /* Add some entries to the .dynamic section. We fill in the
2866 values later, in ppc64_elf_finish_dynamic_sections, but we
2867 must add the entries now so that we get the correct size for
2868 the .dynamic section. The DT_DEBUG entry is filled in by the
2869 dynamic linker and used by the debugger. */
dc810e39
AM		 2870#define add_dynamic_entry(TAG, VAL) \
2871 bfd_elf64_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
2872
2873 if (!info->shared)
5bd4f169 2874 {
dc810e39 2875 if (!add_dynamic_entry (DT_DEBUG, 0))
5bd4f169
AM		 2876 return false;
2877 }
2878
65f38f15 2879 if (htab->splt->_raw_size != 0)
5bd4f169 2880 {
dc810e39
AM		 2881 if (!add_dynamic_entry (DT_PLTGOT, 0)
2882 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2883 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2884 || !add_dynamic_entry (DT_JMPREL, 0))
5bd4f169
AM		 2885 return false;
2886 }
2887
2888 if (relocs)
2889 {
dc810e39
AM		 2890 if (!add_dynamic_entry (DT_RELA, 0)
2891 || !add_dynamic_entry (DT_RELASZ, 0)
2892 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
5bd4f169 2893 return false;
5bd4f169 2894
65f38f15
AM		 2895 /* If any dynamic relocs apply to a read-only section,
2896 then we need a DT_TEXTREL entry. */
2897 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, (PTR) info);
5bd4f169 2898
65f38f15 2899 if ((info->flags & DF_TEXTREL) != 0)
5bd4f169 2900 {
65f38f15
AM		 2901 if (!add_dynamic_entry (DT_TEXTREL, 0))
2902 return false;
5bd4f169 2903 }
5bd4f169 2904 }
5bd4f169 2905 }
65f38f15 2906#undef add_dynamic_entry
5bd4f169
AM		 2907
2908 return true;
2909}
2910
2911/* Called after we have seen all the input files/sections, but before
2912 final symbol resolution and section placement has been determined.
2913
2914 We use this hook to provide a value for TOCstart, which we store in
2915 the output bfd elf_gp, then we call the generic ELF final link
2916 routine. */
2917
2918static boolean
2919ppc64_elf_final_link (abfd, info)
2920 bfd *abfd;
2921 struct bfd_link_info *info;
2922{
2923 if (! info->relocateable)
2924 {
2925 asection *s;
2926 bfd_vma TOCstart;
2927
2928 /* The TOC consists of sections .got, .toc, .tocbss, .plt in this
2929 order. The TOC starts where the first of these sections starts. */
2930 s = bfd_get_section_by_name (abfd, ".got");
2931 if (s == NULL)
2932 s = bfd_get_section_by_name (abfd, ".toc");
2933 if (s == NULL)
2934 s = bfd_get_section_by_name (abfd, ".tocbss");
2935 if (s == NULL)
2936 s = bfd_get_section_by_name (abfd, ".plt");
2937 if (s == NULL)
2938 {
2939 /* This may happen for
2940 o references to TOC base (SYM@toc / TOC[tc0]) without a
2941 .toc directive
2942 o bad linker script
2943 o --gc-sections and empty TOC sections
2944
2945 FIXME: Warn user? */
2946
2947 /* Look for a likely section. We probably won't even be
2948 using TOCstart. */
2949 for (s = abfd->sections; s != NULL; s = s->next)
2950 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY))
2951 == (SEC_ALLOC | SEC_SMALL_DATA))
2952 break;
2953 if (s == NULL)
2954 for (s = abfd->sections; s != NULL; s = s->next)
2955 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA))
2956 == (SEC_ALLOC | SEC_SMALL_DATA))
2957 break;
2958 if (s == NULL)
2959 for (s = abfd->sections; s != NULL; s = s->next)
2960 if ((s->flags & (SEC_ALLOC | SEC_READONLY)) == SEC_ALLOC)
2961 break;
2962 if (s == NULL)
2963 for (s = abfd->sections; s != NULL; s = s->next)
2964 if ((s->flags & SEC_ALLOC) == SEC_ALLOC)
2965 break;
2966 }
2967
2968 TOCstart = 0;
2969 if (s != NULL)
2970 TOCstart = s->output_section->vma + s->output_offset;
2971
2972 elf_gp (abfd) = TOCstart;
2973 }
2974
65f38f15
AM		 2975 /* Invoke the regular ELF backend linker to do all the work. */
2976 return bfd_elf64_bfd_final_link (abfd, info);
5bd4f169
AM		 2977}
2978
2979/* Set up any other section flags and such that may be necessary. */
2980
2981static boolean
2982ppc64_elf_fake_sections (abfd, shdr, asect)
2983 bfd *abfd ATTRIBUTE_UNUSED;
2984 Elf64_Internal_Shdr *shdr;
2985 asection *asect;
2986{
2987 if ((asect->flags & SEC_EXCLUDE) != 0)
2988 shdr->sh_flags |= SHF_EXCLUDE;
2989
2990 if ((asect->flags & SEC_SORT_ENTRIES) != 0)
2991 shdr->sh_type = SHT_ORDERED;
2992
2993 return true;
2994}
2995
2996/* The RELOCATE_SECTION function is called by the ELF backend linker
2997 to handle the relocations for a section.
2998
2999 The relocs are always passed as Rela structures; if the section
3000 actually uses Rel structures, the r_addend field will always be
3001 zero.
3002
3003 This function is responsible for adjust the section contents as
3004 necessary, and (if using Rela relocs and generating a
3005 relocateable output file) adjusting the reloc addend as
3006 necessary.
3007
3008 This function does not have to worry about setting the reloc
3009 address or the reloc symbol index.
3010
3011 LOCAL_SYMS is a pointer to the swapped in local symbols.
3012
3013 LOCAL_SECTIONS is an array giving the section in the input file
3014 corresponding to the st_shndx field of each local symbol.
3015
3016 The global hash table entry for the global symbols can be found
3017 via elf_sym_hashes (input_bfd).
3018
3019 When generating relocateable output, this function must handle
3020 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
3021 going to be the section symbol corresponding to the output
3022 section, which means that the addend must be adjusted
3023 accordingly. */
3024
3025static boolean
3026ppc64_elf_relocate_section (output_bfd, info, input_bfd, input_section,
3027 contents, relocs, local_syms, local_sections)
3028 bfd *output_bfd;
3029 struct bfd_link_info *info;
3030 bfd *input_bfd;
3031 asection *input_section;
3032 bfd_byte *contents;
3033 Elf_Internal_Rela *relocs;
3034 Elf_Internal_Sym *local_syms;
3035 asection **local_sections;
3036{
65f38f15 3037 struct ppc_link_hash_table *htab;
5bd4f169
AM		 3038 Elf_Internal_Shdr *symtab_hdr;
3039 struct elf_link_hash_entry **sym_hashes;
5bd4f169
AM		 3040 Elf_Internal_Rela *rel;
3041 Elf_Internal_Rela *relend;
5bd4f169
AM		 3042 bfd_vma *local_got_offsets;
3043 bfd_vma TOCstart;
3044 boolean ret = true;
5bd4f169 3045
65f38f15 3046 /* Initialize howto table if needed. */
5bd4f169 3047 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5bd4f169
AM		 3048 ppc_howto_init ();
3049
65f38f15 3050 htab = ppc_hash_table (info);
5bd4f169 3051 local_got_offsets = elf_local_got_offsets (input_bfd);
5bd4f169 3052 TOCstart = elf_gp (output_bfd);
5bd4f169
AM		 3053 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3054 sym_hashes = elf_sym_hashes (input_bfd);
65f38f15 3055
5bd4f169
AM		 3056 rel = relocs;
3057 relend = relocs + input_section->reloc_count;
3058 for (; rel < relend; rel++)
3059 {
3060 enum elf_ppc_reloc_type r_type;
3061 bfd_vma offset;
3062 bfd_vma addend;
3063 bfd_reloc_status_type r;
3064 Elf_Internal_Sym *sym;
3065 asection *sec;
3066 struct elf_link_hash_entry *h;
3067 const char *sym_name;
5bd4f169
AM		 3068 unsigned long r_symndx;
3069 bfd_vma relocation;
65f38f15 3070 boolean unresolved_reloc;
dc810e39 3071 long insn;
5bd4f169
AM		 3072
3073 r_type = (enum elf_ppc_reloc_type) ELF64_R_TYPE (rel->r_info);
5bd4f169
AM		 3074 r_symndx = ELF64_R_SYM (rel->r_info);
3075
3076 if (info->relocateable)
3077 {
3078 /* This is a relocatable link. We don't have to change
3079 anything, unless the reloc is against a section symbol,
3080 in which case we have to adjust according to where the
3081 section symbol winds up in the output section. */
3082 if (r_symndx < symtab_hdr->sh_info)
3083 {
3084 sym = local_syms + r_symndx;
3085 if ((unsigned) ELF_ST_TYPE (sym->st_info) == STT_SECTION)
3086 {
3087 sec = local_sections[r_symndx];
65f38f15 3088 rel->r_addend += sec->output_offset + sym->st_value;
5bd4f169
AM		 3089 }
3090 }
5bd4f169
AM		 3091 continue;
3092 }
3093
3094 /* This is a final link. */
3095
65f38f15
AM		 3096 offset = rel->r_offset;
3097 addend = rel->r_addend;
3098 r = bfd_reloc_other;
3099 sym = (Elf_Internal_Sym *) 0;
3100 sec = (asection *) 0;
3101 h = (struct elf_link_hash_entry *) 0;
3102 sym_name = (const char *) 0;
3103 unresolved_reloc = false;
3104
5bd4f169
AM		 3105 if (r_type == R_PPC64_TOC)
3106 {
3107 /* Relocation value is TOC base. Symbol is ignored. */
3108 relocation = TOCstart + TOC_BASE_OFF;
3109 }
3110 else if (r_symndx < symtab_hdr->sh_info)
3111 {
3112 /* It's a local symbol. */
3113 sym = local_syms + r_symndx;
3114 sec = local_sections[r_symndx];
3115 sym_name = "<local symbol>";
3116
f8df10f4
JJ		 3117 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
3118 addend = rel->r_addend;
5bd4f169
AM		 3119 }
3120 else
3121 {
3122 /* It's a global symbol. */
3123 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3124 while (h->root.type == bfd_link_hash_indirect
3125 || h->root.type == bfd_link_hash_warning)
3126 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3127 sym_name = h->root.root.string;
65f38f15 3128 relocation = 0;
5bd4f169
AM		 3129 if (h->root.type == bfd_link_hash_defined
3130 || h->root.type == bfd_link_hash_defweak)
3131 {
3132 sec = h->root.u.def.section;
65f38f15
AM		 3133 if (sec->output_section == NULL)
3134 /* Set a flag that will be cleared later if we find a
3135 relocation value for this symbol. output_section
3136 is typically NULL for symbols satisfied by a shared
3137 library. */
3138 unresolved_reloc = true;
5bd4f169
AM		 3139 else
3140 relocation = (h->root.u.def.value
3141 + sec->output_section->vma
3142 + sec->output_offset);
3143 }
3144 else if (h->root.type == bfd_link_hash_undefweak)
65f38f15 3145 ;
671bae9c 3146 else if (info->shared
65f38f15
AM		 3147 && (!info->symbolic || info->allow_shlib_undefined)
3148 && !info->no_undefined
3149 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
3150 ;
5bd4f169
AM		 3151 else
3152 {
3153 if (! ((*info->callbacks->undefined_symbol)
3154 (info, h->root.root.string, input_bfd, input_section,
65f38f15
AM		 3155 offset, (!info->shared
3156 || info->no_undefined
3157 || ELF_ST_VISIBILITY (h->other)))))
5bd4f169
AM		 3158 return false;
3159 relocation = 0;
3160 }
3161 }
3162
65f38f15 3163 /* First handle relocations that tweak non-addend part of insn. */
86c76c7b 3164 insn = 0;
65f38f15 3165 switch (r_type)
5bd4f169
AM		 3166 {
3167 default:
65f38f15 3168 break;
5bd4f169 3169
65f38f15
AM		 3170 /* Branch taken prediction relocations. */
3171 case R_PPC64_ADDR14_BRTAKEN:
3172 case R_PPC64_REL14_BRTAKEN:
86c76c7b
AM		 3173 insn = 0x01 << 21; /* Set 't' bit, lowest bit of BO field. */
3174 /* Fall thru. */
65f38f15 3175
86c76c7b 3176 /* Branch not taken prediction relocations. */
65f38f15
AM		 3177 case R_PPC64_ADDR14_BRNTAKEN:
3178 case R_PPC64_REL14_BRNTAKEN:
86c76c7b
AM		 3179 insn |= bfd_get_32 (output_bfd, contents + offset) & ~(0x01 << 21);
3180 /* Set 'a' bit. This is 0b00010 in BO field for branch on CR(BI)
3181 insns (BO == 001at or 011at), and 0b01000 for branch on CTR
3182 insns (BO == 1a00t or 1a01t). */
3183 if ((insn & (0x14 << 21)) == (0x04 << 21))
3184 insn |= 0x02 << 21;
3185 else if ((insn & (0x14 << 21)) == (0x10 << 21))
3186 insn |= 0x08 << 21;
65f38f15 3187 else
86c76c7b
AM		 3188 break;
3189
65f38f15
AM		 3190 bfd_put_32 (output_bfd, (bfd_vma) insn, contents + offset);
3191 break;
5bd4f169 3192
65f38f15
AM		 3193 case R_PPC64_REL24:
3194 case R_PPC64_ADDR24:
5bd4f169 3195 /* An ADDR24 or REL24 branching to a linkage function may be
65f38f15 3196 followed by a nop that we have to replace with a ld in
5bd4f169
AM		 3197 order to restore the TOC base pointer. Only calls to
3198 shared objects need to alter the TOC base. These are
3199 recognized by their need for a PLT entry. */
3200 if (h != NULL
3201 && (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0
3202 /* Make sure that there really is an instruction after
3203 the branch that we can decode. */
65f38f15 3204 && offset + 8 <= input_section->_cooked_size)
5bd4f169
AM		 3205 {
3206 bfd_byte *pnext;
5bd4f169 3207
65f38f15 3208 pnext = contents + offset + 4;
5bd4f169
AM		 3209 insn = bfd_get_32 (input_bfd, pnext);
3210
3211 if (insn == 0x60000000 /* nop (ori r0,r0,0) */
3212 || insn == 0x4def7b82 /* cror 15,15,15 */
dc810e39 3213 || insn == 0x4ffffb82) /* cror 31,31,31 */
5bd4f169 3214 {
dc810e39
AM		 3215 bfd_put_32 (input_bfd,
3216 (bfd_vma) 0xe8410028, /* ld r2,40(r1) */
3217 pnext);
5bd4f169
AM		 3218 }
3219 }
65f38f15
AM		 3220 break;
3221 }
5bd4f169 3222
65f38f15
AM		 3223 /* Set `addend'. */
3224 switch (r_type)
3225 {
3226 default:
3227 (*_bfd_error_handler)
3228 (_("%s: unknown relocation type %d for symbol %s"),
3229 bfd_archive_filename (input_bfd), (int) r_type, sym_name);
5bd4f169 3230
65f38f15
AM		 3231 bfd_set_error (bfd_error_bad_value);
3232 ret = false;
3233 continue;
5bd4f169 3234
65f38f15
AM		 3235 case R_PPC64_NONE:
3236 case R_PPC_GNU_VTINHERIT:
3237 case R_PPC_GNU_VTENTRY:
3238 continue;
5bd4f169
AM		 3239
3240 /* GOT16 relocations. Like an ADDR16 using the symbol's
3241 address in the GOT as relocation value instead of the
3242 symbols value itself. Also, create a GOT entry for the
3243 symbol and put the symbol value there. */
65f38f15
AM		 3244 case R_PPC64_GOT16:
3245 case R_PPC64_GOT16_LO:
3246 case R_PPC64_GOT16_HI:
3247 case R_PPC64_GOT16_HA:
3248 case R_PPC64_GOT16_DS:
3249 case R_PPC64_GOT16_LO_DS:
5bd4f169
AM		 3250 {
3251 /* Relocation is to the entry for this symbol in the global
3252 offset table. */
3253 bfd_vma off;
65f38f15
AM		 3254
3255 if (htab->sgot == NULL)
3256 abort ();
5bd4f169
AM		 3257
3258 if (h != NULL)
3259 {
65f38f15 3260 boolean dyn;
5bd4f169 3261
65f38f15
AM		 3262 off = h->got.offset;
3263 dyn = htab->elf.dynamic_sections_created;
3264 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
5bd4f169 3265 || (info->shared
65f38f15
AM		 3266 && (info->symbolic
3267 || h->dynindx == -1
3268 || (h->elf_link_hash_flags
3269 & ELF_LINK_FORCED_LOCAL))
5bd4f169
AM		 3270 && (h->elf_link_hash_flags
3271 & ELF_LINK_HASH_DEF_REGULAR)))
3272 {
3273 /* This is actually a static link, or it is a
3274 -Bsymbolic link and the symbol is defined
65f38f15
AM		 3275 locally, or the symbol was forced to be local
3276 because of a version file. We must initialize
3277 this entry in the global offset table. Since the
3278 offset must always be a multiple of 8, we use the
3279 least significant bit to record whether we have
5bd4f169
AM		 3280 initialized it already.
3281
65f38f15 3282 When doing a dynamic link, we create a .rel.got
5bd4f169
AM		 3283 relocation entry to initialize the value. This
3284 is done in the finish_dynamic_symbol routine. */
3285 if ((off & 1) != 0)
3286 off &= ~1;
3287 else
3288 {
3289 bfd_put_64 (output_bfd, relocation,
65f38f15 3290 htab->sgot->contents + off);
5bd4f169
AM		 3291 h->got.offset |= 1;
3292 }
3293 }
65f38f15
AM		 3294 else
3295 unresolved_reloc = false;
5bd4f169
AM		 3296 }
3297 else
3298 {
65f38f15
AM		 3299 if (local_got_offsets == NULL)
3300 abort ();
5bd4f169
AM		 3301
3302 off = local_got_offsets[r_symndx];
3303
65f38f15 3304 /* The offset must always be a multiple of 8. We use
5bd4f169
AM		 3305 the least significant bit to record whether we have
3306 already processed this entry. */
3307 if ((off & 1) != 0)
3308 off &= ~1;
3309 else
3310 {
65f38f15
AM		 3311 bfd_put_64 (output_bfd, relocation,
3312 htab->sgot->contents + off);
5bd4f169
AM		 3313
3314 if (info->shared)
3315 {
5bd4f169 3316 Elf_Internal_Rela outrel;
65f38f15 3317 Elf64_External_Rela *loc;
5bd4f169
AM		 3318
3319 /* We need to generate a R_PPC64_RELATIVE reloc
3320 for the dynamic linker. */
65f38f15
AM		 3321 outrel.r_offset = (htab->sgot->output_section->vma
3322 + htab->sgot->output_offset
5bd4f169
AM		 3323 + off);
3324 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
3325 outrel.r_addend = relocation;
65f38f15
AM		 3326 loc = (Elf64_External_Rela *) htab->srelgot->contents;
3327 loc += htab->srelgot->reloc_count++;
3328 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
5bd4f169
AM		 3329 }
3330
3331 local_got_offsets[r_symndx] |= 1;
3332 }
3333 }
3334
65f38f15
AM		 3335 if (off >= (bfd_vma) -2)
3336 abort ();
3337
3338 relocation = htab->sgot->output_offset + off;
3339
5bd4f169
AM		 3340 /* TOC base (r2) is TOC start plus 0x8000. */
3341 addend -= TOC_BASE_OFF;
5bd4f169 3342 }
65f38f15
AM		 3343 break;
3344
3345 case R_PPC64_PLT16_HA:
3346 case R_PPC64_PLT16_HI:
3347 case R_PPC64_PLT16_LO:
3348 case R_PPC64_PLT32:
3349 case R_PPC64_PLT64:
3350 /* Relocation is to the entry for this symbol in the
3351 procedure linkage table. */
3352
3353 /* Resolve a PLT reloc against a local symbol directly,
3354 without using the procedure linkage table. */
3355 if (h == NULL)
3356 break;
3357
3358 if (h->plt.offset == (bfd_vma) -1
3359 || htab->splt == NULL)
3360 {
3361 /* We didn't make a PLT entry for this symbol. This
3362 happens when statically linking PIC code, or when
3363 using -Bsymbolic. */
3364 break;
3365 }
3366
3367 relocation = (htab->splt->output_section->vma
3368 + htab->splt->output_offset
3369 + h->plt.offset);
3370 unresolved_reloc = false;
3371 break;
5bd4f169
AM		 3372
3373 /* TOC16 relocs. We want the offset relative to the TOC base,
3374 which is the address of the start of the TOC plus 0x8000.
3375 The TOC consists of sections .got, .toc, .tocbss, and .plt,
3376 in this order. */
3377
65f38f15
AM		 3378 case R_PPC64_TOC16:
3379 case R_PPC64_TOC16_LO:
3380 case R_PPC64_TOC16_HI:
3381 case R_PPC64_TOC16_DS:
3382 case R_PPC64_TOC16_LO_DS:
3383 case R_PPC64_TOC16_HA:
5bd4f169 3384 /* Only .got, .toc and *UND* symbols are allowed. */
65f38f15
AM		 3385 BFD_ASSERT (sec != (asection *) 0
3386 && (bfd_is_und_section (sec)
3387 || strcmp (bfd_get_section_name (abfd, sec),
3388 ".toc") == 0
3389 || strcmp (bfd_get_section_name (abfd, sec),
3390 ".got") == 0));
5bd4f169
AM		 3391
3392 addend -= TOCstart + TOC_BASE_OFF;
5bd4f169
AM		 3393 break;
3394
3395 /* Relocate against the beginning of the section. */
65f38f15
AM		 3396 case R_PPC64_SECTOFF:
3397 case R_PPC64_SECTOFF_LO:
3398 case R_PPC64_SECTOFF_HI:
3399 case R_PPC64_SECTOFF_DS:
3400 case R_PPC64_SECTOFF_LO_DS:
3401 case R_PPC64_SECTOFF_HA:
3402 if (sec != (asection *) 0)
3403 addend -= sec->output_section->vma;
5bd4f169
AM		 3404 break;
3405
65f38f15
AM		 3406 /* Relocations that may need to be propagated if this is a
3407 dynamic object. */
3408 case R_PPC64_REL14:
3409 case R_PPC64_REL14_BRNTAKEN:
3410 case R_PPC64_REL14_BRTAKEN:
3411 case R_PPC64_REL24:
3412 case R_PPC64_REL32:
3413 case R_PPC64_REL64:
3414 case R_PPC64_ADDR14:
3415 case R_PPC64_ADDR14_BRNTAKEN:
3416 case R_PPC64_ADDR14_BRTAKEN:
3417 case R_PPC64_ADDR16:
3418 case R_PPC64_ADDR16_DS:
3419 case R_PPC64_ADDR16_HA:
3420 case R_PPC64_ADDR16_HI:
3421 case R_PPC64_ADDR16_HIGHER:
3422 case R_PPC64_ADDR16_HIGHERA:
3423 case R_PPC64_ADDR16_HIGHEST:
3424 case R_PPC64_ADDR16_HIGHESTA:
3425 case R_PPC64_ADDR16_LO:
3426 case R_PPC64_ADDR16_LO_DS:
3427 case R_PPC64_ADDR24:
3428 case R_PPC64_ADDR30:
3429 case R_PPC64_ADDR32:
3430 case R_PPC64_ADDR64:
3431 case R_PPC64_UADDR16:
3432 case R_PPC64_UADDR32:
3433 case R_PPC64_UADDR64:
3434 case R_PPC64_TOC:
ec338859
AM		 3435 /* r_symndx will be zero only for relocs against symbols
3436 from removed linkonce sections, or sections discarded by
3437 a linker script. */
3438 if (r_symndx == 0
3439 || (input_section->flags & SEC_ALLOC) == 0)
3440 break;
3441
65f38f15 3442 if ((info->shared
65f38f15
AM		 3443 && (IS_ABSOLUTE_RELOC (r_type)
3444 || (h != NULL
3445 && h->dynindx != -1
3446 && (! info->symbolic
3447 || (h->elf_link_hash_flags
3448 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
3449 || (!info->shared
65f38f15
AM		 3450 && h != NULL
3451 && h->dynindx != -1
3452 && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
3453 && (((h->elf_link_hash_flags
3454 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
3455 && (h->elf_link_hash_flags
3456 & ELF_LINK_HASH_DEF_REGULAR) == 0)
3457 || h->root.type == bfd_link_hash_undefweak
3458 || h->root.type == bfd_link_hash_undefined)))
3459 {
3460 Elf_Internal_Rela outrel;
3461 boolean skip, relocate;
3462 asection *sreloc;
3463 Elf64_External_Rela *loc;
3464
3465 /* When generating a dynamic object, these relocations
3466 are copied into the output file to be resolved at run
3467 time. */
3468
3469 skip = false;
3470
c629eae0
JJ		 3471 outrel.r_offset =
3472 _bfd_elf_section_offset (output_bfd, info, input_section,
3473 rel->r_offset);
3474 if (outrel.r_offset == (bfd_vma) -1)
3475 skip = true;
65f38f15
AM		 3476
3477 outrel.r_offset += (input_section->output_section->vma
3478 + input_section->output_offset);
3479 outrel.r_addend = addend;
3480
3481 if (skip)
3482 {
3483 relocate = false;
3484 memset (&outrel, 0, sizeof outrel);
3485 }
3486 else if (h != NULL
3487 && h->dynindx != -1
3488 && (!IS_ABSOLUTE_RELOC (r_type)
3489 || !info->shared
3490 || !info->symbolic
3491 || (h->elf_link_hash_flags
3492 & ELF_LINK_HASH_DEF_REGULAR) == 0))
3493 {
3494 relocate = false;
3495 outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
3496 }
3497 else
3498 {
3499 /* This symbol is local, or marked to become local. */
3500 outrel.r_addend += relocation;
3501 relocate = true;
3502 if (r_type == R_PPC64_ADDR64)
3503 {
3504 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
3505 }
3506 else
3507 {
3508 long indx = 0;
3509
3510 if (r_type == R_PPC64_TOC || bfd_is_abs_section (sec))
3511 ;
3512 else if (sec == NULL || sec->owner == NULL)
3513 {
3514 bfd_set_error (bfd_error_bad_value);
3515 return false;
3516 }
3517 else
3518 {
3519 asection *osec;
3520
3521 osec = sec->output_section;
3522 indx = elf_section_data (osec)->dynindx;
3523
3524 /* We are turning this relocation into one
3525 against a section symbol, so subtract out
3526 the output section's address but not the
3527 offset of the input section in the output
3528 section. */
3529 outrel.r_addend -= osec->vma;
3530 }
3531
3532 outrel.r_info = ELF64_R_INFO (indx, r_type);
3533 }
3534 }
3535
3536 sreloc = elf_section_data (input_section)->sreloc;
3537 if (sreloc == NULL)
3538 abort ();
3539
3540 loc = (Elf64_External_Rela *) sreloc->contents;
3541 loc += sreloc->reloc_count++;
3542 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
3543
3544 /* If this reloc is against an external symbol, it will
3545 be computed at runtime, so there's no need to do
3546 anything now. */
3547 if (! relocate)
3548 continue;
3549 }
5bd4f169
AM		 3550 break;
3551
65f38f15
AM		 3552 case R_PPC64_COPY:
3553 case R_PPC64_GLOB_DAT:
3554 case R_PPC64_JMP_SLOT:
3555 case R_PPC64_RELATIVE:
3556 /* We shouldn't ever see these dynamic relocs in relocatable
3557 files. */
3558 /* Fall thru */
3559
3560 case R_PPC64_PLTGOT16:
3561 case R_PPC64_PLTGOT16_DS:
3562 case R_PPC64_PLTGOT16_HA:
3563 case R_PPC64_PLTGOT16_HI:
3564 case R_PPC64_PLTGOT16_LO:
3565 case R_PPC64_PLTGOT16_LO_DS:
3566 case R_PPC64_PLTREL32:
3567 case R_PPC64_PLTREL64:
3568 /* These ones haven't been implemented yet. */
3569
3570 (*_bfd_error_handler)
3571 (_("%s: Relocation %s is not supported for symbol %s."),
3572 bfd_archive_filename (input_bfd),
3573 ppc64_elf_howto_table[(int) r_type]->name, sym_name);
5bd4f169
AM		 3574
3575 bfd_set_error (bfd_error_invalid_operation);
3576 ret = false;
3577 continue;
65f38f15 3578 }
5bd4f169 3579
65f38f15
AM		 3580 /* Do any further special processing. */
3581 switch (r_type)
3582 {
3583 default:
3584 break;
3585
3586 case R_PPC64_ADDR16_HA:
3587 case R_PPC64_ADDR16_HIGHERA:
3588 case R_PPC64_ADDR16_HIGHESTA:
3589 case R_PPC64_PLT16_HA:
3590 case R_PPC64_TOC16_HA:
3591 case R_PPC64_SECTOFF_HA:
3592 /* It's just possible that this symbol is a weak symbol
3593 that's not actually defined anywhere. In that case,
3594 'sec' would be NULL, and we should leave the symbol
3595 alone (it will be set to zero elsewhere in the link). */
3596 if (sec != NULL)
3597 /* Add 0x10000 if sign bit in 0:15 is set. */
3598 addend += ((relocation + addend) & 0x8000) << 1;
3599 break;
3600
3601 case R_PPC64_ADDR16_DS:
3602 case R_PPC64_ADDR16_LO_DS:
3603 case R_PPC64_GOT16_DS:
3604 case R_PPC64_GOT16_LO_DS:
3605 case R_PPC64_PLT16_LO_DS:
3606 case R_PPC64_SECTOFF_DS:
3607 case R_PPC64_SECTOFF_LO_DS:
3608 case R_PPC64_TOC16_DS:
3609 case R_PPC64_TOC16_LO_DS:
3610 case R_PPC64_PLTGOT16_DS:
3611 case R_PPC64_PLTGOT16_LO_DS:
3612 if (((relocation + addend) & 3) != 0)
3613 {
3614 (*_bfd_error_handler)
3615 (_("%s: error: relocation %s not a multiple of 4"),
3616 bfd_archive_filename (input_bfd),
3617 ppc64_elf_howto_table[(int) r_type]->name);
3618 bfd_set_error (bfd_error_bad_value);
3619 ret = false;
3620 continue;
3621 }
3622 break;
5bd4f169
AM		 3623 }
3624
65f38f15
AM		 3625 /* FIXME: Why do we allow debugging sections to escape this error?
3626 More importantly, why do we not emit dynamic relocs above in
3627 debugging sections (which are ! SEC_ALLOC)? If we had
3628 emitted the dynamic reloc, we could remove the fudge here. */
3629 if (unresolved_reloc
3630 && !(info->shared
3631 && (input_section->flags & SEC_DEBUGGING) != 0
3632 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
3633 (*_bfd_error_handler)
3634 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
3635 bfd_archive_filename (input_bfd),
3636 bfd_get_section_name (input_bfd, input_section),
3637 (long) rel->r_offset,
3638 h->root.root.string);
5bd4f169 3639
65f38f15 3640 r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
5bd4f169
AM		 3641 input_bfd,
3642 input_section,
3643 contents,
3644 offset,
3645 relocation,
3646 addend);
3647
3648 if (r == bfd_reloc_ok)
3649 ;
3650 else if (r == bfd_reloc_overflow)
3651 {
3652 const char *name;
3653
3654 if (h != NULL)
3655 {
3656 if (h->root.type == bfd_link_hash_undefweak
65f38f15 3657 && ppc64_elf_howto_table[(int) r_type]->pc_relative)
5bd4f169
AM		 3658 {
3659 /* Assume this is a call protected by other code that
3660 detects the symbol is undefined. If this is the case,
3661 we can safely ignore the overflow. If not, the
3662 program is hosed anyway, and a little warning isn't
3663 going to help. */
3664
3665 continue;
3666 }
3667
3668 name = h->root.root.string;
3669 }
3670 else
3671 {
3672 name = bfd_elf_string_from_elf_section (input_bfd,
3673 symtab_hdr->sh_link,
3674 sym->st_name);
3675 if (name == NULL)
3676 continue;
3677 if (*name == '\0')
3678 name = bfd_section_name (input_bfd, sec);
3679 }
3680
65f38f15
AM		 3681 if (! ((*info->callbacks->reloc_overflow)
3682 (info, name, ppc64_elf_howto_table[(int) r_type]->name,
3683 (bfd_vma) 0, input_bfd, input_section, offset)))
5bd4f169
AM		 3684 return false;
3685 }
3686 else
3687 ret = false;
3688 }
3689
5bd4f169
AM		 3690 return ret;
3691}
3692
3693/* Finish up dynamic symbol handling. We set the contents of various
3694 dynamic sections here. */
3695
3696static boolean
3697ppc64_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
3698 bfd *output_bfd;
3699 struct bfd_link_info *info;
3700 struct elf_link_hash_entry *h;
3701 Elf_Internal_Sym *sym;
3702{
65f38f15 3703 struct ppc_link_hash_table *htab;
5bd4f169
AM		 3704 bfd *dynobj;
3705
65f38f15
AM		 3706 htab = ppc_hash_table (info);
3707 dynobj = htab->elf.dynobj;
5bd4f169
AM		 3708
3709 if (h->plt.offset != (bfd_vma) -1)
3710 {
5bd4f169 3711 struct elf_link_hash_entry *funcdesc_h;
65f38f15
AM		 3712 Elf_Internal_Rela rela;
3713 Elf64_External_Rela *loc;
5bd4f169
AM		 3714
3715 /* This symbol has an entry in the procedure linkage table. Set
3716 it up. */
3717
65f38f15
AM		 3718 if (h->dynindx == -1
3719 || htab->splt == NULL
3720 || htab->srelplt == NULL
3721 || htab->sglink == NULL
3722 || h->root.root.string[0] != '.'
3723 || h->root.root.string[1] == '\0')
3724 abort ();
3725
3726 /* Find its corresponding function descriptor.
3727 ppc64_elf_adjust_dynamic_symbol has already set it up for us. */
5bd4f169 3728
65f38f15
AM		 3729 funcdesc_h = elf_link_hash_lookup (elf_hash_table (info),
3730 h->root.root.string + 1,
3731 false, false, false);
3732
3733 if (funcdesc_h == NULL || funcdesc_h->dynindx == -1)
3734 abort ();
3735
3736 /* Create a JMP_SLOT reloc to inform the dynamic linker to
3737 fill in the PLT entry. */
5bd4f169 3738
65f38f15
AM		 3739 rela.r_offset = (htab->splt->output_section->vma
3740 + htab->splt->output_offset
3741 + h->plt.offset);
3742 rela.r_info = ELF64_R_INFO (funcdesc_h->dynindx, R_PPC64_JMP_SLOT);
3743 rela.r_addend = 0;
3744
3745 loc = (Elf64_External_Rela *) htab->srelplt->contents;
3746 loc += (h->plt.offset - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE;
3747 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
5bd4f169 3748
65f38f15
AM		 3749 /* We need to create a linkage function. */
3750 if (h->root.u.def.section == htab->sglink)
5bd4f169
AM		 3751 {
3752 bfd_byte *p;
3753 bfd_vma pltoff;
3754 const unsigned int *stub;
3755
3756 /* Where to write it. */
3757 p = h->root.u.def.section->contents + h->root.u.def.value;
3758
3759 /* The function descriptor is in the PLT. */
65f38f15
AM		 3760 pltoff = htab->splt->output_section->vma
3761 + htab->splt->output_section->output_offset
5bd4f169
AM		 3762 + h->plt.offset
3763 - elf_gp (output_bfd) - TOC_BASE_OFF;
3764
3765 if (pltoff + 0x8000 > 0xffff)
3766 {
3767 (*_bfd_error_handler)
3768 (_("linkage table overflow against `%s'"),
3769 h->root.root.string);
3770 }
3771
3772 /* Write it out. */
3773 stub = ppc64_elf_glink_code;
3774 bfd_put_32 (output_bfd, *stub | (pltoff & 0xfffc), p);
3775 while (p += 4, ++stub < (ppc64_elf_glink_code
3776 + (sizeof (ppc64_elf_glink_code)
3777 / sizeof (*ppc64_elf_glink_code))));
3778 {
dc810e39 3779 bfd_put_32 (output_bfd, (bfd_vma) *stub, p);
5bd4f169 3780 }
5bd4f169 3781 }
65f38f15
AM		 3782 else
3783 abort ();
5bd4f169
AM		 3784 }
3785
3786 if (h->got.offset != (bfd_vma) -1)
3787 {
5bd4f169 3788 Elf_Internal_Rela rela;
65f38f15 3789 Elf64_External_Rela *loc;
5bd4f169
AM		 3790
3791 /* This symbol has an entry in the global offset table. Set it
3792 up. */
3793
65f38f15
AM		 3794 if (htab->sgot == NULL || htab->srelgot == NULL)
3795 abort ();
5bd4f169 3796
65f38f15
AM		 3797 rela.r_offset = (htab->sgot->output_section->vma
3798 + htab->sgot->output_offset
dc810e39 3799 + (h->got.offset &~ (bfd_vma) 1));
5bd4f169 3800
65f38f15
AM		 3801 /* If this is a static link, or it is a -Bsymbolic link and the
3802 symbol is defined locally or was forced to be local because
3803 of a version file, we just want to emit a RELATIVE reloc.
3804 The entry in the global offset table will already have been
3805 initialized in the relocate_section function. */
5bd4f169 3806 if (info->shared
65f38f15
AM		 3807 && (info->symbolic
3808 || h->dynindx == -1
3809 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
5bd4f169
AM		 3810 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3811 {
65f38f15 3812 BFD_ASSERT((h->got.offset & 1) != 0);
5bd4f169
AM		 3813 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
3814 rela.r_addend = (h->root.u.def.value
3815 + h->root.u.def.section->output_section->vma
3816 + h->root.u.def.section->output_offset);
3817 }
3818 else
3819 {
3820 BFD_ASSERT ((h->got.offset & 1) == 0);
65f38f15
AM		 3821 bfd_put_64 (output_bfd, (bfd_vma) 0,
3822 htab->sgot->contents + h->got.offset);
5bd4f169
AM		 3823 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_GLOB_DAT);
3824 rela.r_addend = 0;
3825 }
3826
65f38f15
AM		 3827 loc = (Elf64_External_Rela *) htab->srelgot->contents;
3828 loc += htab->srelgot->reloc_count++;
3829 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
5bd4f169
AM		 3830 }
3831
3832 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
3833 {
5bd4f169 3834 Elf_Internal_Rela rela;
65f38f15 3835 Elf64_External_Rela *loc;
5bd4f169 3836
65f38f15 3837 /* This symbol needs a copy reloc. Set it up. */
5bd4f169 3838
65f38f15
AM		 3839 if (h->dynindx == -1
3840 || (h->root.type != bfd_link_hash_defined
3841 && h->root.type != bfd_link_hash_defweak)
3842 || htab->srelbss == NULL)
3843 abort ();
5bd4f169
AM		 3844
3845 rela.r_offset = (h->root.u.def.value
3846 + h->root.u.def.section->output_section->vma
3847 + h->root.u.def.section->output_offset);
3848 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
3849 rela.r_addend = 0;
65f38f15
AM		 3850 loc = (Elf64_External_Rela *) htab->srelbss->contents;
3851 loc += htab->srelbss->reloc_count++;
3852 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
5bd4f169
AM		 3853 }
3854
5bd4f169
AM		 3855 /* Mark some specially defined symbols as absolute. */
3856 if (strcmp (h->root.root.string, "_DYNAMIC") == 0)
3857 sym->st_shndx = SHN_ABS;
3858
3859 return true;
3860}
3861
65f38f15
AM		 3862/* Used to decide how to sort relocs in an optimal manner for the
3863 dynamic linker, before writing them out. */
3864
3865static enum elf_reloc_type_class
3866ppc64_elf_reloc_type_class (rela)
3867 const Elf_Internal_Rela *rela;
3868{
a33d1f77
AM		 3869 enum elf_ppc_reloc_type r_type;
3870
3871 r_type = (enum elf_ppc_reloc_type) ELF64_R_TYPE (rela->r_info);
3872 switch (r_type)
65f38f15
AM		 3873 {
3874 case R_PPC64_RELATIVE:
3875 return reloc_class_relative;
3876 case R_PPC64_JMP_SLOT:
3877 return reloc_class_plt;
3878 case R_PPC64_COPY:
3879 return reloc_class_copy;
3880 default:
3881 return reloc_class_normal;
3882 }
3883}
3884
5bd4f169
AM		 3885/* Finish up the dynamic sections. */
3886
3887static boolean
3888ppc64_elf_finish_dynamic_sections (output_bfd, info)
3889 bfd *output_bfd;
3890 struct bfd_link_info *info;
3891{
65f38f15
AM		 3892 struct ppc_link_hash_table *htab;
3893 bfd *dynobj;
5bd4f169 3894 asection *sdyn;
5bd4f169 3895
65f38f15
AM		 3896 htab = ppc_hash_table (info);
3897 dynobj = htab->elf.dynobj;
5bd4f169
AM		 3898 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3899
65f38f15 3900 if (htab->elf.dynamic_sections_created)
5bd4f169 3901 {
5bd4f169
AM		 3902 Elf64_External_Dyn *dyncon, *dynconend;
3903
65f38f15
AM		 3904 if (sdyn == NULL || htab->sgot == NULL)
3905 abort ();
5bd4f169
AM		 3906
3907 dyncon = (Elf64_External_Dyn *) sdyn->contents;
3908 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3909 for (; dyncon < dynconend; dyncon++)
3910 {
3911 Elf_Internal_Dyn dyn;
5bd4f169
AM		 3912
3913 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3914
3915 switch (dyn.d_tag)
3916 {
65f38f15
AM		 3917 default:
3918 continue;
5bd4f169 3919
65f38f15
AM		 3920 case DT_PLTGOT:
3921 dyn.d_un.d_ptr = htab->splt->output_section->vma;
3922 break;
3923
3924 case DT_JMPREL:
3925 dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
3926 break;
5bd4f169 3927
65f38f15
AM		 3928 case DT_PLTRELSZ:
3929 if (htab->srelplt->output_section->_cooked_size != 0)
3930 dyn.d_un.d_val = htab->srelplt->output_section->_cooked_size;
5bd4f169 3931 else
65f38f15
AM		 3932 dyn.d_un.d_val = htab->srelplt->output_section->_raw_size;
3933 break;
5bd4f169 3934 }
5bd4f169 3935
65f38f15 3936 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
5bd4f169 3937 }
5bd4f169
AM		 3938 }
3939
3940 return true;
3941}
3942
3943#define TARGET_LITTLE_SYM bfd_elf64_powerpcle_vec
3944#define TARGET_LITTLE_NAME "elf64-powerpcle"
3945#define TARGET_BIG_SYM bfd_elf64_powerpc_vec
3946#define TARGET_BIG_NAME "elf64-powerpc"
3947#define ELF_ARCH bfd_arch_powerpc
3948#define ELF_MACHINE_CODE EM_PPC64
3949#define ELF_MAXPAGESIZE 0x10000
3950#define elf_info_to_howto ppc64_elf_info_to_howto
3951
3952#ifdef EM_CYGNUS_POWERPC
3953#define ELF_MACHINE_ALT1 EM_CYGNUS_POWERPC
3954#endif
3955
3956#ifdef EM_PPC_OLD
3957#define ELF_MACHINE_ALT2 EM_PPC_OLD
3958#endif
3959
3960#define elf_backend_want_got_sym 0
3961#define elf_backend_want_plt_sym 0
3962#define elf_backend_plt_alignment 3
3963#define elf_backend_plt_not_loaded 1
3964#define elf_backend_got_symbol_offset 0
3965#define elf_backend_got_header_size 0
3966#define elf_backend_can_gc_sections 1
65f38f15 3967#define elf_backend_can_refcount 1
5bd4f169
AM		 3968
3969#define elf_backend_plt_header_size PLT_INITIAL_ENTRY_SIZE
3970
65f38f15
AM		 3971#define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
3972#define bfd_elf64_bfd_set_private_flags ppc64_elf_set_private_flags
65f38f15
AM		 3973#define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
3974#define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
3975#define bfd_elf64_bfd_final_link ppc64_elf_final_link
3976
3977#define elf_backend_section_from_shdr ppc64_elf_section_from_shdr
3978#define elf_backend_create_dynamic_sections ppc64_elf_create_dynamic_sections
3979#define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
3980#define elf_backend_check_relocs ppc64_elf_check_relocs
3981#define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
3982#define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
3983#define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
3984#define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
3985#define elf_backend_fake_sections ppc64_elf_fake_sections
3986#define elf_backend_relocate_section ppc64_elf_relocate_section
3987#define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
3988#define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
3989#define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
5bd4f169
AM		 3990
3991#include "elf64-target.h"
GDB Binutils - Deliverables
This page took 0.31711 seconds and 4 git commands to generate.