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