?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* elf32-cris.c (cris_elf_grok_prstatus): New function.
[binutils.git] / bfd / elf64-ppc.c
blob418b38684e627ff9bc15bf5fb5099f2cee3c0181
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
1644 /* Get the ppc64 ELF linker hash table from a link_info structure. */
1645
1646 #define ppc_hash_table(p) \
1647 ((struct ppc_link_hash_table *) ((p)->hash))
1648
1649 /* Create an entry in a ppc64 ELF linker hash table. */
1650
1651 static struct bfd_hash_entry *
1652 link_hash_newfunc (entry, table, string)
1653 struct bfd_hash_entry *entry;
1654 struct bfd_hash_table *table;
1655 const char *string;
1656 {
1657 /* Allocate the structure if it has not already been allocated by a
1658 subclass. */
1659 if (entry == NULL)
1660 {
1661 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
1662 if (entry == NULL)
1663 return entry;
1664 }
1665
1666 /* Call the allocation method of the superclass. */
1667 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
1668 if (entry != NULL)
1669 {
1670 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
1671
1672 eh->dyn_relocs = NULL;
1673 }
1674
1675 return entry;
1676 }
1677
1678 /* Create a ppc64 ELF linker hash table. */
1679
1680 static struct bfd_link_hash_table *
1681 ppc64_elf_link_hash_table_create (abfd)
1682 bfd *abfd;
1683 {
1684 struct ppc_link_hash_table *htab;
1685 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
1686
1687 htab = (struct ppc_link_hash_table *) bfd_alloc (abfd, amt);
1688 if (htab == NULL)
1689 return NULL;
1690
1691 if (! _bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc))
1692 {
1693 bfd_release (abfd, htab);
1694 return NULL;
1695 }
1696
1697 htab->sgot = NULL;
1698 htab->srelgot = NULL;
1699 htab->splt = NULL;
1700 htab->srelplt = NULL;
1701 htab->sdynbss = NULL;
1702 htab->srelbss = NULL;
1703 htab->sglink = NULL;
1704
1705 return &htab->elf.root;
1706 }
1707
1708 /* Create .got and .rela.got sections in DYNOBJ, and set up
1709 shortcuts to them in our hash table. */
1710
1711 static boolean
1712 create_got_section (dynobj, info)
1713 bfd *dynobj;
1714 struct bfd_link_info *info;
1715 {
1716 struct ppc_link_hash_table *htab;
1717
1718 if (! _bfd_elf_create_got_section (dynobj, info))
1719 return false;
1720
1721 htab = ppc_hash_table (info);
1722 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
1723 if (!htab->sgot)
1724 abort ();
1725
1726 htab->srelgot = bfd_make_section (dynobj, ".rela.got");
1727 if (!htab->srelgot
1728 || ! bfd_set_section_flags (dynobj, htab->srelgot,
1729 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
1730 | SEC_IN_MEMORY | SEC_LINKER_CREATED
1731 | SEC_READONLY))
1732 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 3))
1733 return false;
1734 return true;
1735 }
1736
1737 /* Create the .glink section as well as the ordinary dynamic
1738 sections. */
1739
1740 static boolean
1741 ppc64_elf_create_dynamic_sections (dynobj, info)
1742 bfd *dynobj;
1743 struct bfd_link_info *info;
1744 {
1745 struct ppc_link_hash_table *htab;
1746 flagword flags;
1747
1748 htab = ppc_hash_table (info);
1749 if (!htab->sgot && !create_got_section (dynobj, info))
1750 return false;
1751
1752 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
1753 return false;
1754
1755 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
1756 htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
1757 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
1758 if (!info->shared)
1759 htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
1760
1761 if (!htab->splt || !htab->srelplt || !htab->sdynbss
1762 || (!info->shared && !htab->srelbss))
1763 abort ();
1764
1765 /* Our .plt just contains pointers, no code. */
1766 flags = bfd_get_section_flags (dynobj, htab->splt);
1767 flags &= ~SEC_CODE;
1768 if (! bfd_set_section_flags (dynobj, htab->splt, flags))
1769 return false;
1770
1771 /* Create .glink for global linkage functions. */
1772 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1773 | SEC_LINKER_CREATED);
1774 htab->sglink = bfd_make_section (dynobj, ".glink");
1775 if (htab->sglink == NULL
1776 || ! bfd_set_section_flags (dynobj, htab->sglink, flags)
1777 || ! bfd_set_section_alignment (dynobj, htab->sglink, 3))
1778 return false;
1779
1780 return true;
1781 }
1782
1783 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1784
1785 static void
1786 ppc64_elf_copy_indirect_symbol (dir, ind)
1787 struct elf_link_hash_entry *dir, *ind;
1788 {
1789 struct ppc_link_hash_entry *edir, *eind;
1790
1791 edir = (struct ppc_link_hash_entry *) dir;
1792 eind = (struct ppc_link_hash_entry *) ind;
1793
1794 if (eind->dyn_relocs != NULL)
1795 {
1796 if (edir->dyn_relocs != NULL)
1797 {
1798 struct ppc_dyn_relocs **pp;
1799 struct ppc_dyn_relocs *p;
1800
1801 if (ind->root.type == bfd_link_hash_indirect)
1802 abort ();
1803
1804 /* Add reloc counts against the weak sym to the strong sym
1805 list. Merge any entries against the same section. */
1806 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1807 {
1808 struct ppc_dyn_relocs *q;
1809
1810 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1811 if (q->sec == p->sec)
1812 {
1813 q->pc_count += p->pc_count;
1814 q->count += p->count;
1815 *pp = p->next;
1816 break;
1817 }
1818 if (q == NULL)
1819 pp = &p->next;
1820 }
1821 *pp = edir->dyn_relocs;
1822 }
1823
1824 edir->dyn_relocs = eind->dyn_relocs;
1825 eind->dyn_relocs = NULL;
1826 }
1827
1828 _bfd_elf_link_hash_copy_indirect (dir, ind);
1829 }
1830
1831 /* Look through the relocs for a section during the first phase, and
1832 calculate needed space in the global offset table, procedure
1833 linkage table, and dynamic reloc sections. */
1834
1835 static boolean
1836 ppc64_elf_check_relocs (abfd, info, sec, relocs)
1837 bfd *abfd;
1838 struct bfd_link_info *info;
1839 asection *sec;
1840 const Elf_Internal_Rela *relocs;
1841 {
1842 struct ppc_link_hash_table *htab;
1843 Elf_Internal_Shdr *symtab_hdr;
1844 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
1845 const Elf_Internal_Rela *rel;
1846 const Elf_Internal_Rela *rel_end;
1847 asection *sreloc;
1848
1849 if (info->relocateable)
1850 return true;
1851
1852 htab = ppc_hash_table (info);
1853 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1854
1855 sym_hashes = elf_sym_hashes (abfd);
1856 sym_hashes_end = (sym_hashes
1857 + symtab_hdr->sh_size / sizeof (Elf64_External_Sym));
1858 if (!elf_bad_symtab (abfd))
1859 sym_hashes_end -= symtab_hdr->sh_info;
1860
1861 sreloc = NULL;
1862
1863 rel_end = relocs + sec->reloc_count;
1864 for (rel = relocs; rel < rel_end; rel++)
1865 {
1866 unsigned long r_symndx;
1867 struct elf_link_hash_entry *h;
1868 enum elf_ppc_reloc_type r_type;
1869
1870 r_symndx = ELF64_R_SYM (rel->r_info);
1871 if (r_symndx < symtab_hdr->sh_info)
1872 h = NULL;
1873 else
1874 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1875
1876 r_type = (enum elf_ppc_reloc_type) ELF64_R_TYPE (rel->r_info);
1877 switch (r_type)
1878 {
1879 /* GOT16 relocations */
1880 case R_PPC64_GOT16:
1881 case R_PPC64_GOT16_DS:
1882 case R_PPC64_GOT16_HA:
1883 case R_PPC64_GOT16_HI:
1884 case R_PPC64_GOT16_LO:
1885 case R_PPC64_GOT16_LO_DS:
1886
1887 /* This symbol requires a global offset table entry. */
1888 if (htab->sgot == NULL)
1889 {
1890 if (htab->elf.dynobj == NULL)
1891 htab->elf.dynobj = abfd;
1892 if (!create_got_section (htab->elf.dynobj, info))
1893 return false;
1894 }
1895
1896 if (h != NULL)
1897 {
1898 h->got.refcount += 1;
1899 }
1900 else
1901 {
1902 bfd_signed_vma *local_got_refcounts;
1903
1904 /* This is a global offset table entry for a local symbol. */
1905 local_got_refcounts = elf_local_got_refcounts (abfd);
1906 if (local_got_refcounts == NULL)
1907 {
1908 bfd_size_type size;
1909
1910 size = symtab_hdr->sh_info;
1911 size *= sizeof (bfd_signed_vma);
1912 local_got_refcounts = ((bfd_signed_vma *)
1913 bfd_zalloc (abfd, size));
1914 if (local_got_refcounts == NULL)
1915 return false;
1916 elf_local_got_refcounts (abfd) = local_got_refcounts;
1917 }
1918 local_got_refcounts[r_symndx] += 1;
1919 }
1920 break;
1921
1922 case R_PPC64_PLT16_HA:
1923 case R_PPC64_PLT16_HI:
1924 case R_PPC64_PLT16_LO:
1925 case R_PPC64_PLT32:
1926 case R_PPC64_PLT64:
1927 /* This symbol requires a procedure linkage table entry. We
1928 actually build the entry in adjust_dynamic_symbol,
1929 because this might be a case of linking PIC code without
1930 linking in any dynamic objects, in which case we don't
1931 need to generate a procedure linkage table after all. */
1932 if (h == NULL)
1933 {
1934 /* It does not make sense to have a procedure linkage
1935 table entry for a local symbol. */
1936 bfd_set_error (bfd_error_bad_value);
1937 return false;
1938 }
1939
1940 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
1941 h->plt.refcount += 1;
1942 break;
1943
1944 /* The following relocations don't need to propagate the
1945 relocation if linking a shared object since they are
1946 section relative. */
1947 case R_PPC64_SECTOFF:
1948 case R_PPC64_SECTOFF_LO:
1949 case R_PPC64_SECTOFF_HI:
1950 case R_PPC64_SECTOFF_HA:
1951 case R_PPC64_SECTOFF_DS:
1952 case R_PPC64_SECTOFF_LO_DS:
1953 case R_PPC64_TOC16:
1954 case R_PPC64_TOC16_LO:
1955 case R_PPC64_TOC16_HI:
1956 case R_PPC64_TOC16_HA:
1957 case R_PPC64_TOC16_DS:
1958 case R_PPC64_TOC16_LO_DS:
1959 break;
1960
1961 /* This relocation describes the C++ object vtable hierarchy.
1962 Reconstruct it for later use during GC. */
1963 case R_PPC64_GNU_VTINHERIT:
1964 if (!_bfd_elf64_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1965 return false;
1966 break;
1967
1968 /* This relocation describes which C++ vtable entries are actually
1969 used. Record for later use during GC. */
1970 case R_PPC64_GNU_VTENTRY:
1971 if (!_bfd_elf64_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1972 return false;
1973 break;
1974
1975 case R_PPC64_REL64:
1976 case R_PPC64_REL32:
1977 case R_PPC64_REL24:
1978 case R_PPC64_REL14:
1979 case R_PPC64_REL14_BRTAKEN:
1980 case R_PPC64_REL14_BRNTAKEN:
1981 case R_PPC64_ADDR14:
1982 case R_PPC64_ADDR14_BRNTAKEN:
1983 case R_PPC64_ADDR14_BRTAKEN:
1984 case R_PPC64_ADDR16:
1985 case R_PPC64_ADDR16_DS:
1986 case R_PPC64_ADDR16_HA:
1987 case R_PPC64_ADDR16_HI:
1988 case R_PPC64_ADDR16_HIGHER:
1989 case R_PPC64_ADDR16_HIGHERA:
1990 case R_PPC64_ADDR16_HIGHEST:
1991 case R_PPC64_ADDR16_HIGHESTA:
1992 case R_PPC64_ADDR16_LO:
1993 case R_PPC64_ADDR16_LO_DS:
1994 case R_PPC64_ADDR24:
1995 case R_PPC64_ADDR30:
1996 case R_PPC64_ADDR32:
1997 case R_PPC64_ADDR64:
1998 case R_PPC64_UADDR16:
1999 case R_PPC64_UADDR32:
2000 case R_PPC64_UADDR64:
2001 case R_PPC64_TOC:
2002 /* If we are creating a shared library, and this is a reloc
2003 against a global symbol, or a non PC relative reloc
2004 against a local symbol, then we need to copy the reloc
2005 into the shared library. However, if we are linking with
2006 -Bsymbolic, we do not need to copy a reloc against a
2007 global symbol which is defined in an object we are
2008 including in the link (i.e., DEF_REGULAR is set). At
2009 this point we have not seen all the input files, so it is
2010 possible that DEF_REGULAR is not set now but will be set
2011 later (it is never cleared). In case of a weak definition,
2012 DEF_REGULAR may be cleared later by a strong definition in
2013 a shared library. We account for that possibility below by
2014 storing information in the relocs_copied field of the hash
2015 table entry. A similar situation occurs when creating
2016 shared libraries and symbol visibility changes render the
2017 symbol local.
2018
2019 If on the other hand, we are creating an executable, we
2020 may need to keep relocations for symbols satisfied by a
2021 dynamic library if we manage to avoid copy relocs for the
2022 symbol. */
2023 if ((info->shared
2024 && (sec->flags & SEC_ALLOC) != 0
2025 && (IS_ABSOLUTE_RELOC (r_type)
2026 || (h != NULL
2027 && (! info->symbolic
2028 || h->root.type == bfd_link_hash_defweak
2029 || (h->elf_link_hash_flags
2030 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2031 || (!info->shared
2032 && (sec->flags & SEC_ALLOC) != 0
2033 && h != NULL
2034 && (h->root.type == bfd_link_hash_defweak
2035 || (h->elf_link_hash_flags
2036 & ELF_LINK_HASH_DEF_REGULAR) == 0)))
2037 {
2038 /* We must copy these reloc types into the output file.
2039 Create a reloc section in dynobj and make room for
2040 this reloc. */
2041 if (sreloc == NULL)
2042 {
2043 const char *name;
2044 bfd *dynobj;
2045
2046 name = (bfd_elf_string_from_elf_section
2047 (abfd,
2048 elf_elfheader (abfd)->e_shstrndx,
2049 elf_section_data (sec)->rel_hdr.sh_name));
2050 if (name == NULL)
2051 return false;
2052
2053 if (strncmp (name, ".rela", 5) != 0
2054 || strcmp (bfd_get_section_name (abfd, sec),
2055 name + 5) != 0)
2056 {
2057 (*_bfd_error_handler)
2058 (_("%s: bad relocation section name `%s\'"),
2059 bfd_archive_filename (abfd), name);
2060 }
2061
2062 if (htab->elf.dynobj == NULL)
2063 htab->elf.dynobj = abfd;
2064
2065 dynobj = htab->elf.dynobj;
2066 sreloc = bfd_get_section_by_name (dynobj, name);
2067 if (sreloc == NULL)
2068 {
2069 flagword flags;
2070
2071 sreloc = bfd_make_section (dynobj, name);
2072 flags = (SEC_HAS_CONTENTS | SEC_READONLY
2073 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2074 if ((sec->flags & SEC_ALLOC) != 0)
2075 flags |= SEC_ALLOC | SEC_LOAD;
2076 if (sreloc == NULL
2077 || ! bfd_set_section_flags (dynobj, sreloc, flags)
2078 || ! bfd_set_section_alignment (dynobj, sreloc, 3))
2079 return false;
2080 }
2081 elf_section_data (sec)->sreloc = sreloc;
2082 }
2083
2084 /* If this is a global symbol, we count the number of
2085 relocations we need for this symbol. */
2086 if (h != NULL)
2087 {
2088 struct ppc_link_hash_entry *eh;
2089 struct ppc_dyn_relocs *p;
2090
2091 eh = (struct ppc_link_hash_entry *) h;
2092 p = eh->dyn_relocs;
2093
2094 if (p == NULL || p->sec != sec)
2095 {
2096 p = ((struct ppc_dyn_relocs *)
2097 bfd_alloc (htab->elf.dynobj,
2098 (bfd_size_type) sizeof *p));
2099 if (p == NULL)
2100 return false;
2101 p->next = eh->dyn_relocs;
2102 eh->dyn_relocs = p;
2103 p->sec = sec;
2104 p->count = 0;
2105 p->pc_count = 0;
2106 }
2107
2108 p->count += 1;
2109 if (!IS_ABSOLUTE_RELOC (r_type))
2110 p->pc_count += 1;
2111 }
2112 else
2113 {
2114 /* Track dynamic relocs needed for local syms too. */
2115 elf_section_data (sec)->local_dynrel += 1;
2116 }
2117 }
2118 break;
2119
2120 default:
2121 }
2122 }
2123
2124 return true;
2125 }
2126
2127 /* Return the section that should be marked against GC for a given
2128 relocation. */
2129
2130 static asection *
2131 ppc64_elf_gc_mark_hook (abfd, info, rel, h, sym)
2132 bfd *abfd;
2133 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2134 Elf_Internal_Rela *rel;
2135 struct elf_link_hash_entry *h;
2136 Elf_Internal_Sym *sym;
2137 {
2138 if (h != NULL)
2139 {
2140 enum elf_ppc_reloc_type r_type;
2141
2142 r_type = (enum elf_ppc_reloc_type) ELF64_R_TYPE (rel->r_info);
2143 switch (r_type)
2144 {
2145 case R_PPC64_GNU_VTINHERIT:
2146 case R_PPC64_GNU_VTENTRY:
2147 break;
2148
2149 default:
2150 switch (h->root.type)
2151 {
2152 case bfd_link_hash_defined:
2153 case bfd_link_hash_defweak:
2154 return h->root.u.def.section;
2155
2156 case bfd_link_hash_common:
2157 return h->root.u.c.p->section;
2158
2159 default:
2160 break;
2161 }
2162 }
2163 }
2164 else
2165 {
2166 if (! (elf_bad_symtab (abfd)
2167 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
2168 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
2169 && sym->st_shndx != SHN_COMMON))
2170 {
2171 return bfd_section_from_elf_index (abfd, sym->st_shndx);
2172 }
2173 }
2174
2175 return NULL;
2176 }
2177
2178 /* Update the .got, .plt. and dynamic reloc reference counts for the
2179 section being removed. */
2180
2181 static boolean
2182 ppc64_elf_gc_sweep_hook (abfd, info, sec, relocs)
2183 bfd *abfd;
2184 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2185 asection *sec;
2186 const Elf_Internal_Rela *relocs;
2187 {
2188 Elf_Internal_Shdr *symtab_hdr;
2189 struct elf_link_hash_entry **sym_hashes;
2190 bfd_signed_vma *local_got_refcounts;
2191 const Elf_Internal_Rela *rel, *relend;
2192
2193 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2194 sym_hashes = elf_sym_hashes (abfd);
2195 local_got_refcounts = elf_local_got_refcounts (abfd);
2196
2197 relend = relocs + sec->reloc_count;
2198 for (rel = relocs; rel < relend; rel++)
2199 {
2200 unsigned long r_symndx;
2201 enum elf_ppc_reloc_type r_type;
2202 struct elf_link_hash_entry *h;
2203
2204 r_symndx = ELF64_R_SYM (rel->r_info);
2205 r_type = (enum elf_ppc_reloc_type) ELF64_R_TYPE (rel->r_info);
2206 switch (r_type)
2207 {
2208 case R_PPC64_GOT16:
2209 case R_PPC64_GOT16_DS:
2210 case R_PPC64_GOT16_HA:
2211 case R_PPC64_GOT16_HI:
2212 case R_PPC64_GOT16_LO:
2213 case R_PPC64_GOT16_LO_DS:
2214 if (r_symndx >= symtab_hdr->sh_info)
2215 {
2216 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2217 if (h->got.refcount > 0)
2218 h->got.refcount--;
2219 }
2220 else
2221 {
2222 if (local_got_refcounts[r_symndx] > 0)
2223 local_got_refcounts[r_symndx]--;
2224 }
2225 break;
2226
2227 case R_PPC64_PLT16_HA:
2228 case R_PPC64_PLT16_HI:
2229 case R_PPC64_PLT16_LO:
2230 case R_PPC64_PLT32:
2231 case R_PPC64_PLT64:
2232 if (r_symndx >= symtab_hdr->sh_info)
2233 {
2234 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2235 if (h->plt.refcount > 0)
2236 h->plt.refcount--;
2237 }
2238 break;
2239
2240 case R_PPC64_REL14:
2241 case R_PPC64_REL14_BRNTAKEN:
2242 case R_PPC64_REL14_BRTAKEN:
2243 case R_PPC64_REL24:
2244 case R_PPC64_REL32:
2245 case R_PPC64_REL64:
2246 if (r_symndx >= symtab_hdr->sh_info)
2247 {
2248 struct ppc_link_hash_entry *eh;
2249 struct ppc_dyn_relocs **pp;
2250 struct ppc_dyn_relocs *p;
2251
2252 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2253 eh = (struct ppc_link_hash_entry *) h;
2254
2255 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
2256 if (p->sec == sec)
2257 {
2258 p->pc_count -= 1;
2259 p->count -= 1;
2260 if (p->count == 0)
2261 *pp = p->next;
2262 break;
2263 }
2264 }
2265 break;
2266
2267 case R_PPC64_ADDR14:
2268 case R_PPC64_ADDR14_BRNTAKEN:
2269 case R_PPC64_ADDR14_BRTAKEN:
2270 case R_PPC64_ADDR16:
2271 case R_PPC64_ADDR16_DS:
2272 case R_PPC64_ADDR16_HA:
2273 case R_PPC64_ADDR16_HI:
2274 case R_PPC64_ADDR16_HIGHER:
2275 case R_PPC64_ADDR16_HIGHERA:
2276 case R_PPC64_ADDR16_HIGHEST:
2277 case R_PPC64_ADDR16_HIGHESTA:
2278 case R_PPC64_ADDR16_LO:
2279 case R_PPC64_ADDR16_LO_DS:
2280 case R_PPC64_ADDR24:
2281 case R_PPC64_ADDR30:
2282 case R_PPC64_ADDR32:
2283 case R_PPC64_ADDR64:
2284 case R_PPC64_UADDR16:
2285 case R_PPC64_UADDR32:
2286 case R_PPC64_UADDR64:
2287 case R_PPC64_TOC:
2288 if (r_symndx >= symtab_hdr->sh_info)
2289 {
2290 struct ppc_link_hash_entry *eh;
2291 struct ppc_dyn_relocs **pp;
2292 struct ppc_dyn_relocs *p;
2293
2294 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2295 eh = (struct ppc_link_hash_entry *) h;
2296
2297 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
2298 if (p->sec == sec)
2299 {
2300 p->count -= 1;
2301 if (p->count == 0)
2302 *pp = p->next;
2303 break;
2304 }
2305 }
2306 break;
2307
2308 default:
2309 break;
2310 }
2311 }
2312 return true;
2313 }
2314
2315 /* Adjust a symbol defined by a dynamic object and referenced by a
2316 regular object. The current definition is in some section of the
2317 dynamic object, but we're not including those sections. We have to
2318 change the definition to something the rest of the link can
2319 understand. */
2320
2321 static boolean
2322 ppc64_elf_adjust_dynamic_symbol (info, h)
2323 struct bfd_link_info *info;
2324 struct elf_link_hash_entry *h;
2325 {
2326 struct ppc_link_hash_table *htab;
2327 struct ppc_link_hash_entry * eh;
2328 struct ppc_dyn_relocs *p;
2329 asection *s;
2330 unsigned int power_of_two;
2331
2332 htab = ppc_hash_table (info);
2333
2334 /* If this is a function, put it in the procedure linkage table. We
2335 will fill in the contents of the procedure linkage table later. */
2336 if (h->type == STT_FUNC
2337 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2338 {
2339 struct elf_link_hash_entry *fdh;
2340
2341 /* If it's a function entry point, the name starts with a dot
2342 unless someone has written some poor assembly code. The ABI
2343 for .plt calls requires that there be a function descriptor
2344 sym which has the name of the function minus the dot. */
2345
2346 if (h->plt.refcount <= 0
2347 || h->root.root.string[0] != '.'
2348 || h->root.root.string[1] == '\0'
2349 || (! info->shared
2350 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
2351 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0))
2352 {
2353 /* This case can occur if we saw a PLT reloc in an input
2354 file, but the symbol was never referred to by a dynamic
2355 object, or if all references were garbage collected. In
2356 such a case, we don't actually need to build a procedure
2357 linkage table entry. */
2358 h->plt.offset = (bfd_vma) -1;
2359 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2360 return true;
2361 }
2362
2363 /* Find the corresponding function descriptor symbol. Create it
2364 as undefined if necessary. ppc_elf64_finish_dynamic_symbol
2365 will look it up again and create a JMP_SLOT reloc for it. */
2366
2367 fdh = elf_link_hash_lookup (elf_hash_table (info),
2368 h->root.root.string + 1,
2369 false, false, false);
2370
2371 if (fdh == NULL)
2372 {
2373 asymbol *newsym;
2374
2375 /* Create it as undefined. */
2376 newsym = bfd_make_empty_symbol (htab->elf.dynobj);
2377 newsym->name = h->root.root.string + 1;
2378 newsym->section = bfd_und_section_ptr;
2379 newsym->value = 0;
2380 newsym->flags = BSF_DYNAMIC | BSF_OBJECT;
2381
2382 if ( !(_bfd_generic_link_add_one_symbol
2383 (info, htab->elf.dynobj, newsym->name, newsym->flags,
2384 newsym->section, newsym->value, NULL, false, false,
2385 (struct bfd_link_hash_entry **) &fdh)))
2386 {
2387 return false;
2388 }
2389 }
2390 return true;
2391 }
2392 else
2393 h->plt.offset = (bfd_vma) -1;
2394
2395 /* If this is a weak symbol, and there is a real definition, the
2396 processor independent code will have arranged for us to see the
2397 real definition first, and we can just use the same value. */
2398 if (h->weakdef != NULL)
2399 {
2400 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2401 || h->weakdef->root.type == bfd_link_hash_defweak);
2402 h->root.u.def.section = h->weakdef->root.u.def.section;
2403 h->root.u.def.value = h->weakdef->root.u.def.value;
2404 return true;
2405 }
2406
2407 /* This is a reference to a symbol defined by a dynamic object which
2408 is not a function. */
2409
2410 /* If we are creating a shared library, we must presume that the
2411 only references to the symbol are via the global offset table.
2412 For such cases we need not do anything here; the relocations will
2413 be handled correctly by relocate_section. */
2414 if (info->shared)
2415 return true;
2416
2417 /* If there are no references to this symbol that do not use the
2418 GOT, we don't need to generate a copy reloc. */
2419 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
2420 return true;
2421
2422 eh = (struct ppc_link_hash_entry *) h;
2423 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2424 {
2425 s = p->sec->output_section;
2426 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2427 break;
2428 }
2429
2430 /* If we didn't find any dynamic relocs in read-only sections, then
2431 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2432 if (p == NULL)
2433 {
2434 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
2435 return true;
2436 }
2437
2438 /* We must allocate the symbol in our .dynbss section, which will
2439 become part of the .bss section of the executable. There will be
2440 an entry for this symbol in the .dynsym section. The dynamic
2441 object will contain position independent code, so all references
2442 from the dynamic object to this symbol will go through the global
2443 offset table. The dynamic linker will use the .dynsym entry to
2444 determine the address it must put in the global offset table, so
2445 both the dynamic object and the regular object will refer to the
2446 same memory location for the variable. */
2447
2448 /* We must generate a R_PPC_COPY reloc to tell the dynamic linker to
2449 copy the initial value out of the dynamic object and into the
2450 runtime process image. We need to remember the offset into the
2451 .rela.bss section we are going to use. */
2452 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2453 {
2454 htab->srelbss->_raw_size += sizeof (Elf64_External_Rela);
2455 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
2456 }
2457
2458 /* We need to figure out the alignment required for this symbol. I
2459 have no idea how ELF linkers handle this. */
2460 power_of_two = bfd_log2 (h->size);
2461 if (power_of_two > 4)
2462 power_of_two = 4;
2463
2464 /* Apply the required alignment. */
2465 s = htab->sdynbss;
2466 s->_raw_size = BFD_ALIGN (s->_raw_size, (bfd_size_type) (1 << power_of_two));
2467 if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
2468 {
2469 if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
2470 return false;
2471 }
2472
2473 /* Define the symbol as being at this point in the section. */
2474 h->root.u.def.section = s;
2475 h->root.u.def.value = s->_raw_size;
2476
2477 /* Increment the section size to make room for the symbol. */
2478 s->_raw_size += h->size;
2479
2480 return true;
2481 }
2482
2483 /* This is the condition under which ppc64_elf_finish_dynamic_symbol
2484 will be called from elflink.h. If elflink.h doesn't call our
2485 finish_dynamic_symbol routine, we'll need to do something about
2486 initializing any .plt and .got entries in ppc64_elf_relocate_section. */
2487 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
2488 ((DYN) \
2489 && ((INFO)->shared \
2490 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
2491 && ((H)->dynindx != -1 \
2492 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
2493
2494 /* Allocate space in .plt, .got and associated reloc sections for
2495 dynamic relocs. */
2496
2497 static boolean
2498 allocate_dynrelocs (h, inf)
2499 struct elf_link_hash_entry *h;
2500 PTR inf;
2501 {
2502 struct bfd_link_info *info;
2503 struct ppc_link_hash_table *htab;
2504 asection *s;
2505 struct ppc_link_hash_entry *eh;
2506 struct ppc_dyn_relocs *p;
2507
2508 if (h->root.type == bfd_link_hash_indirect
2509 || h->root.type == bfd_link_hash_warning)
2510 return true;
2511
2512 info = (struct bfd_link_info *) inf;
2513 htab = ppc_hash_table (info);
2514
2515 if (htab->elf.dynamic_sections_created
2516 && h->plt.refcount > 0)
2517 {
2518 /* Make sure this symbol is output as a dynamic symbol.
2519 Undefined weak syms won't yet be marked as dynamic. */
2520 if (h->dynindx == -1
2521 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
2522 {
2523 if (! bfd_elf64_link_record_dynamic_symbol (info, h))
2524 return false;
2525 }
2526
2527 BFD_ASSERT (h->root.root.string[0] == '.'
2528 && h->root.root.string[1] != '\0');
2529
2530 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
2531 {
2532 /* Make sure the corresponding function descriptor symbol is
2533 dynamic too. */
2534
2535 if (h->dynindx != -1)
2536 {
2537 struct elf_link_hash_entry *fdh;
2538
2539 fdh = elf_link_hash_lookup (elf_hash_table (info),
2540 h->root.root.string + 1,
2541 false, false, false);
2542
2543 if (fdh == NULL)
2544 abort ();
2545
2546 if (fdh->dynindx == -1
2547 && (fdh->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
2548 {
2549 if (! bfd_elf64_link_record_dynamic_symbol (info, fdh))
2550 return false;
2551 }
2552 }
2553
2554 /* If this is the first .plt entry, make room for the special
2555 first entry. */
2556 s = htab->splt;
2557 if (s->_raw_size == 0)
2558 s->_raw_size += PLT_INITIAL_ENTRY_SIZE;
2559
2560 h->plt.offset = s->_raw_size;
2561
2562 /* Make room for this entry. */
2563 s->_raw_size += PLT_ENTRY_SIZE;
2564
2565 /* Point the function at the linkage stub. This works because
2566 the only references to the function code sym are calls.
2567 Function pointer comparisons use the function descriptor. */
2568 s = htab->sglink;
2569 h->root.type = bfd_link_hash_defined;
2570 h->root.u.def.section = s;
2571 h->root.u.def.value = s->_raw_size;
2572 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2573
2574 /* Make room for global linkage code in .glink. */
2575 s->_raw_size += PPC64_ELF_GLINK_SIZE;
2576
2577 /* We also need to make an entry in the .rela.plt section. */
2578 s = htab->srelplt;
2579 s->_raw_size += sizeof (Elf64_External_Rela);
2580 }
2581 else
2582 {
2583 h->plt.offset = (bfd_vma) -1;
2584 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2585 }
2586 }
2587 else
2588 {
2589 h->plt.offset = (bfd_vma) -1;
2590 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2591 }
2592
2593 if (h->got.refcount > 0)
2594 {
2595 boolean dyn;
2596
2597 /* Make sure this symbol is output as a dynamic symbol.
2598 Undefined weak syms won't yet be marked as dynamic. */
2599 if (h->dynindx == -1
2600 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
2601 {
2602 if (! bfd_elf64_link_record_dynamic_symbol (info, h))
2603 return false;
2604 }
2605
2606 s = htab->sgot;
2607 h->got.offset = s->_raw_size;
2608 s->_raw_size += 8;
2609 dyn = htab->elf.dynamic_sections_created;
2610 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h))
2611 htab->srelgot->_raw_size += sizeof (Elf64_External_Rela);
2612 }
2613 else
2614 h->got.offset = (bfd_vma) -1;
2615
2616 eh = (struct ppc_link_hash_entry *) h;
2617 if (eh->dyn_relocs == NULL)
2618 return true;
2619
2620 /* In the shared -Bsymbolic case, discard space allocated for
2621 dynamic pc-relative relocs against symbols which turn out to be
2622 defined in regular objects. For the normal shared case, discard
2623 space for relocs that have become local due to symbol visibility
2624 changes. */
2625
2626 if (info->shared)
2627 {
2628 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
2629 && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
2630 || info->symbolic))
2631 {
2632 struct ppc_dyn_relocs **pp;
2633
2634 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2635 {
2636 p->count -= p->pc_count;
2637 p->pc_count = 0;
2638 if (p->count == 0)
2639 *pp = p->next;
2640 else
2641 pp = &p->next;
2642 }
2643 }
2644 }
2645 else
2646 {
2647 /* For the non-shared case, discard space for relocs against
2648 symbols which turn out to need copy relocs or are not
2649 dynamic. */
2650
2651 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
2652 && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2653 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2654 || (htab->elf.dynamic_sections_created
2655 && (h->root.type == bfd_link_hash_undefweak
2656 || h->root.type == bfd_link_hash_undefined))))
2657 {
2658 /* Make sure this symbol is output as a dynamic symbol.
2659 Undefined weak syms won't yet be marked as dynamic. */
2660 if (h->dynindx == -1
2661 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
2662 {
2663 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2664 return false;
2665 }
2666
2667 /* If that succeeded, we know we'll be keeping all the
2668 relocs. */
2669 if (h->dynindx != -1)
2670 goto keep;
2671 }
2672
2673 eh->dyn_relocs = NULL;
2674
2675 keep:
2676 }
2677
2678 /* Finally, allocate space. */
2679 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2680 {
2681 asection *sreloc = elf_section_data (p->sec)->sreloc;
2682 sreloc->_raw_size += p->count * sizeof (Elf64_External_Rela);
2683 }
2684
2685 return true;
2686 }
2687
2688 /* Find any dynamic relocs that apply to read-only sections. */
2689
2690 static boolean
2691 readonly_dynrelocs (h, inf)
2692 struct elf_link_hash_entry *h;
2693 PTR inf;
2694 {
2695 struct ppc_link_hash_entry *eh;
2696 struct ppc_dyn_relocs *p;
2697
2698 eh = (struct ppc_link_hash_entry *) h;
2699 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2700 {
2701 asection *s = p->sec->output_section;
2702
2703 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2704 {
2705 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2706
2707 info->flags |= DF_TEXTREL;
2708
2709 /* Not an error, just cut short the traversal. */
2710 return false;
2711 }
2712 }
2713 return true;
2714 }
2715
2716 /* Set the sizes of the dynamic sections. */
2717
2718 static boolean
2719 ppc64_elf_size_dynamic_sections (output_bfd, info)
2720 bfd *output_bfd ATTRIBUTE_UNUSED;
2721 struct bfd_link_info *info;
2722 {
2723 struct ppc_link_hash_table *htab;
2724 bfd *dynobj;
2725 asection *s;
2726 boolean relocs;
2727 bfd *ibfd;
2728
2729 htab = ppc_hash_table (info);
2730 dynobj = htab->elf.dynobj;
2731 if (dynobj == NULL)
2732 abort ();
2733
2734 if (htab->elf.dynamic_sections_created)
2735 {
2736 /* Set the contents of the .interp section to the interpreter. */
2737 if (! info->shared)
2738 {
2739 s = bfd_get_section_by_name (dynobj, ".interp");
2740 if (s == NULL)
2741 abort ();
2742 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
2743 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2744 }
2745 }
2746
2747 /* Set up .got offsets for local syms, and space for local dynamic
2748 relocs. */
2749 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2750 {
2751 bfd_signed_vma *local_got;
2752 bfd_signed_vma *end_local_got;
2753 bfd_size_type locsymcount;
2754 Elf_Internal_Shdr *symtab_hdr;
2755 asection *srel;
2756
2757 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2758 continue;
2759
2760 for (s = ibfd->sections; s != NULL; s = s->next)
2761 {
2762 bfd_size_type count = elf_section_data (s)->local_dynrel;
2763
2764 if (count != 0)
2765 {
2766 srel = elf_section_data (s)->sreloc;
2767 srel->_raw_size += count * sizeof (Elf64_External_Rela);
2768 }
2769 }
2770
2771 local_got = elf_local_got_refcounts (ibfd);
2772 if (!local_got)
2773 continue;
2774
2775 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2776 locsymcount = symtab_hdr->sh_info;
2777 end_local_got = local_got + locsymcount;
2778 s = htab->sgot;
2779 srel = htab->srelgot;
2780 for (; local_got < end_local_got; ++local_got)
2781 {
2782 if (*local_got > 0)
2783 {
2784 *local_got = s->_raw_size;
2785 s->_raw_size += 8;
2786 if (info->shared)
2787 srel->_raw_size += sizeof (Elf64_External_Rela);
2788 }
2789 else
2790 *local_got = (bfd_vma) -1;
2791 }
2792 }
2793
2794 /* Allocate global sym .plt and .got entries, and space for global
2795 sym dynamic relocs. */
2796 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
2797
2798 /* We now have determined the sizes of the various dynamic sections.
2799 Allocate memory for them. */
2800 relocs = false;
2801 for (s = dynobj->sections; s != NULL; s = s->next)
2802 {
2803 if ((s->flags & SEC_LINKER_CREATED) == 0)
2804 continue;
2805
2806 if (s == htab->splt
2807 || s == htab->sgot
2808 || s == htab->sglink)
2809 {
2810 /* Strip this section if we don't need it; see the
2811 comment below. */
2812 }
2813 else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
2814 {
2815 if (s->_raw_size == 0)
2816 {
2817 /* If we don't need this section, strip it from the
2818 output file. This is mostly to handle .rela.bss and
2819 .rela.plt. We must create both sections in
2820 create_dynamic_sections, because they must be created
2821 before the linker maps input sections to output
2822 sections. The linker does that before
2823 adjust_dynamic_symbol is called, and it is that
2824 function which decides whether anything needs to go
2825 into these sections. */
2826 }
2827 else
2828 {
2829 if (s != htab->srelplt)
2830 relocs = true;
2831
2832 /* We use the reloc_count field as a counter if we need
2833 to copy relocs into the output file. */
2834 s->reloc_count = 0;
2835 }
2836 }
2837 else
2838 {
2839 /* It's not one of our sections, so don't allocate space. */
2840 continue;
2841 }
2842
2843 if (s->_raw_size == 0)
2844 {
2845 _bfd_strip_section_from_output (info, s);
2846 continue;
2847 }
2848
2849 /* Allocate memory for the section contents. We use bfd_zalloc
2850 here in case unused entries are not reclaimed before the
2851 section's contents are written out. This should not happen,
2852 but this way if it does, we get a R_PPC64_NONE reloc instead
2853 of garbage. */
2854 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
2855 if (s->contents == NULL)
2856 return false;
2857 }
2858
2859 if (elf_hash_table (info)->dynamic_sections_created)
2860 {
2861 /* Add some entries to the .dynamic section. We fill in the
2862 values later, in ppc64_elf_finish_dynamic_sections, but we
2863 must add the entries now so that we get the correct size for
2864 the .dynamic section. The DT_DEBUG entry is filled in by the
2865 dynamic linker and used by the debugger. */
2866 #define add_dynamic_entry(TAG, VAL) \
2867 bfd_elf64_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
2868
2869 if (!info->shared)
2870 {
2871 if (!add_dynamic_entry (DT_DEBUG, 0))
2872 return false;
2873 }
2874
2875 if (htab->splt->_raw_size != 0)
2876 {
2877 if (!add_dynamic_entry (DT_PLTGOT, 0)
2878 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2879 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2880 || !add_dynamic_entry (DT_JMPREL, 0))
2881 return false;
2882 }
2883
2884 if (relocs)
2885 {
2886 if (!add_dynamic_entry (DT_RELA, 0)
2887 || !add_dynamic_entry (DT_RELASZ, 0)
2888 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
2889 return false;
2890
2891 /* If any dynamic relocs apply to a read-only section,
2892 then we need a DT_TEXTREL entry. */
2893 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, (PTR) info);
2894
2895 if ((info->flags & DF_TEXTREL) != 0)
2896 {
2897 if (!add_dynamic_entry (DT_TEXTREL, 0))
2898 return false;
2899 }
2900 }
2901 }
2902 #undef add_dynamic_entry
2903
2904 return true;
2905 }
2906
2907 /* Called after we have seen all the input files/sections, but before
2908 final symbol resolution and section placement has been determined.
2909
2910 We use this hook to provide a value for TOCstart, which we store in
2911 the output bfd elf_gp, then we call the generic ELF final link
2912 routine. */
2913
2914 static boolean
2915 ppc64_elf_final_link (abfd, info)
2916 bfd *abfd;
2917 struct bfd_link_info *info;
2918 {
2919 if (! info->relocateable)
2920 {
2921 asection *s;
2922 bfd_vma TOCstart;
2923
2924 /* The TOC consists of sections .got, .toc, .tocbss, .plt in this
2925 order. The TOC starts where the first of these sections starts. */
2926 s = bfd_get_section_by_name (abfd, ".got");
2927 if (s == NULL)
2928 s = bfd_get_section_by_name (abfd, ".toc");
2929 if (s == NULL)
2930 s = bfd_get_section_by_name (abfd, ".tocbss");
2931 if (s == NULL)
2932 s = bfd_get_section_by_name (abfd, ".plt");
2933 if (s == NULL)
2934 {
2935 /* This may happen for
2936 o references to TOC base (SYM@toc / TOC[tc0]) without a
2937 .toc directive
2938 o bad linker script
2939 o --gc-sections and empty TOC sections
2940
2941 FIXME: Warn user? */
2942
2943 /* Look for a likely section. We probably won't even be
2944 using TOCstart. */
2945 for (s = abfd->sections; s != NULL; s = s->next)
2946 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY))
2947 == (SEC_ALLOC | SEC_SMALL_DATA))
2948 break;
2949 if (s == NULL)
2950 for (s = abfd->sections; s != NULL; s = s->next)
2951 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA))
2952 == (SEC_ALLOC | SEC_SMALL_DATA))
2953 break;
2954 if (s == NULL)
2955 for (s = abfd->sections; s != NULL; s = s->next)
2956 if ((s->flags & (SEC_ALLOC | SEC_READONLY)) == SEC_ALLOC)
2957 break;
2958 if (s == NULL)
2959 for (s = abfd->sections; s != NULL; s = s->next)
2960 if ((s->flags & SEC_ALLOC) == SEC_ALLOC)
2961 break;
2962 }
2963
2964 TOCstart = 0;
2965 if (s != NULL)
2966 TOCstart = s->output_section->vma + s->output_offset;
2967
2968 elf_gp (abfd) = TOCstart;
2969 }
2970
2971 /* Invoke the regular ELF backend linker to do all the work. */
2972 return bfd_elf64_bfd_final_link (abfd, info);
2973 }
2974
2975 /* Set up any other section flags and such that may be necessary. */
2976
2977 static boolean
2978 ppc64_elf_fake_sections (abfd, shdr, asect)
2979 bfd *abfd ATTRIBUTE_UNUSED;
2980 Elf64_Internal_Shdr *shdr;
2981 asection *asect;
2982 {
2983 if ((asect->flags & SEC_EXCLUDE) != 0)
2984 shdr->sh_flags |= SHF_EXCLUDE;
2985
2986 if ((asect->flags & SEC_SORT_ENTRIES) != 0)
2987 shdr->sh_type = SHT_ORDERED;
2988
2989 return true;
2990 }
2991
2992 /* The RELOCATE_SECTION function is called by the ELF backend linker
2993 to handle the relocations for a section.
2994
2995 The relocs are always passed as Rela structures; if the section
2996 actually uses Rel structures, the r_addend field will always be
2997 zero.
2998
2999 This function is responsible for adjust the section contents as
3000 necessary, and (if using Rela relocs and generating a
3001 relocateable output file) adjusting the reloc addend as
3002 necessary.
3003
3004 This function does not have to worry about setting the reloc
3005 address or the reloc symbol index.
3006
3007 LOCAL_SYMS is a pointer to the swapped in local symbols.
3008
3009 LOCAL_SECTIONS is an array giving the section in the input file
3010 corresponding to the st_shndx field of each local symbol.
3011
3012 The global hash table entry for the global symbols can be found
3013 via elf_sym_hashes (input_bfd).
3014
3015 When generating relocateable output, this function must handle
3016 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
3017 going to be the section symbol corresponding to the output
3018 section, which means that the addend must be adjusted
3019 accordingly. */
3020
3021 static boolean
3022 ppc64_elf_relocate_section (output_bfd, info, input_bfd, input_section,
3023 contents, relocs, local_syms, local_sections)
3024 bfd *output_bfd;
3025 struct bfd_link_info *info;
3026 bfd *input_bfd;
3027 asection *input_section;
3028 bfd_byte *contents;
3029 Elf_Internal_Rela *relocs;
3030 Elf_Internal_Sym *local_syms;
3031 asection **local_sections;
3032 {
3033 struct ppc_link_hash_table *htab;
3034 Elf_Internal_Shdr *symtab_hdr;
3035 struct elf_link_hash_entry **sym_hashes;
3036 Elf_Internal_Rela *rel;
3037 Elf_Internal_Rela *relend;
3038 bfd_vma *local_got_offsets;
3039 bfd_vma TOCstart;
3040 boolean ret = true;
3041
3042 /* Initialize howto table if needed. */
3043 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
3044 ppc_howto_init ();
3045
3046 htab = ppc_hash_table (info);
3047 local_got_offsets = elf_local_got_offsets (input_bfd);
3048 TOCstart = elf_gp (output_bfd);
3049 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3050 sym_hashes = elf_sym_hashes (input_bfd);
3051
3052 rel = relocs;
3053 relend = relocs + input_section->reloc_count;
3054 for (; rel < relend; rel++)
3055 {
3056 enum elf_ppc_reloc_type r_type;
3057 bfd_vma offset;
3058 bfd_vma addend;
3059 bfd_reloc_status_type r;
3060 Elf_Internal_Sym *sym;
3061 asection *sec;
3062 struct elf_link_hash_entry *h;
3063 const char *sym_name;
3064 unsigned long r_symndx;
3065 bfd_vma relocation;
3066 boolean unresolved_reloc;
3067 long insn;
3068
3069 r_type = (enum elf_ppc_reloc_type) ELF64_R_TYPE (rel->r_info);
3070 r_symndx = ELF64_R_SYM (rel->r_info);
3071
3072 if (info->relocateable)
3073 {
3074 /* This is a relocatable link. We don't have to change
3075 anything, unless the reloc is against a section symbol,
3076 in which case we have to adjust according to where the
3077 section symbol winds up in the output section. */
3078 if (r_symndx < symtab_hdr->sh_info)
3079 {
3080 sym = local_syms + r_symndx;
3081 if ((unsigned) ELF_ST_TYPE (sym->st_info) == STT_SECTION)
3082 {
3083 sec = local_sections[r_symndx];
3084 rel->r_addend += sec->output_offset + sym->st_value;
3085 }
3086 }
3087 continue;
3088 }
3089
3090 /* This is a final link. */
3091
3092 offset = rel->r_offset;
3093 addend = rel->r_addend;
3094 r = bfd_reloc_other;
3095 sym = (Elf_Internal_Sym *) 0;
3096 sec = (asection *) 0;
3097 h = (struct elf_link_hash_entry *) 0;
3098 sym_name = (const char *) 0;
3099 unresolved_reloc = false;
3100
3101 if (r_type == R_PPC64_TOC)
3102 {
3103 /* Relocation value is TOC base. Symbol is ignored. */
3104 relocation = TOCstart + TOC_BASE_OFF;
3105 }
3106 else if (r_symndx < symtab_hdr->sh_info)
3107 {
3108 /* It's a local symbol. */
3109 sym = local_syms + r_symndx;
3110 sec = local_sections[r_symndx];
3111 sym_name = "<local symbol>";
3112
3113 relocation = (sec->output_section->vma
3114 + sec->output_offset
3115 + sym->st_value);
3116 }
3117 else
3118 {
3119 /* It's a global symbol. */
3120 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3121 while (h->root.type == bfd_link_hash_indirect
3122 || h->root.type == bfd_link_hash_warning)
3123 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3124 sym_name = h->root.root.string;
3125 relocation = 0;
3126 if (h->root.type == bfd_link_hash_defined
3127 || h->root.type == bfd_link_hash_defweak)
3128 {
3129 sec = h->root.u.def.section;
3130 if (sec->output_section == NULL)
3131 /* Set a flag that will be cleared later if we find a
3132 relocation value for this symbol. output_section
3133 is typically NULL for symbols satisfied by a shared
3134 library. */
3135 unresolved_reloc = true;
3136 else
3137 relocation = (h->root.u.def.value
3138 + sec->output_section->vma
3139 + sec->output_offset);
3140 }
3141 else if (h->root.type == bfd_link_hash_undefweak)
3142 ;
3143 else if (info->shared
3144 && (!info->symbolic || info->allow_shlib_undefined)
3145 && !info->no_undefined
3146 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
3147 ;
3148 else
3149 {
3150 if (! ((*info->callbacks->undefined_symbol)
3151 (info, h->root.root.string, input_bfd, input_section,
3152 offset, (!info->shared
3153 || info->no_undefined
3154 || ELF_ST_VISIBILITY (h->other)))))
3155 return false;
3156 relocation = 0;
3157 }
3158 }
3159
3160 /* First handle relocations that tweak non-addend part of insn. */
3161 insn = 0;
3162 switch (r_type)
3163 {
3164 default:
3165 break;
3166
3167 /* Branch taken prediction relocations. */
3168 case R_PPC64_ADDR14_BRTAKEN:
3169 case R_PPC64_REL14_BRTAKEN:
3170 insn = 0x01 << 21; /* Set 't' bit, lowest bit of BO field. */
3171 /* Fall thru. */
3172
3173 /* Branch not taken prediction relocations. */
3174 case R_PPC64_ADDR14_BRNTAKEN:
3175 case R_PPC64_REL14_BRNTAKEN:
3176 insn |= bfd_get_32 (output_bfd, contents + offset) & ~(0x01 << 21);
3177 /* Set 'a' bit. This is 0b00010 in BO field for branch on CR(BI)
3178 insns (BO == 001at or 011at), and 0b01000 for branch on CTR
3179 insns (BO == 1a00t or 1a01t). */
3180 if ((insn & (0x14 << 21)) == (0x04 << 21))
3181 insn |= 0x02 << 21;
3182 else if ((insn & (0x14 << 21)) == (0x10 << 21))
3183 insn |= 0x08 << 21;
3184 else
3185 break;
3186
3187 bfd_put_32 (output_bfd, (bfd_vma) insn, contents + offset);
3188 break;
3189
3190 case R_PPC64_REL24:
3191 case R_PPC64_ADDR24:
3192 /* An ADDR24 or REL24 branching to a linkage function may be
3193 followed by a nop that we have to replace with a ld in
3194 order to restore the TOC base pointer. Only calls to
3195 shared objects need to alter the TOC base. These are
3196 recognized by their need for a PLT entry. */
3197 if (h != NULL
3198 && (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0
3199 /* Make sure that there really is an instruction after
3200 the branch that we can decode. */
3201 && offset + 8 <= input_section->_cooked_size)
3202 {
3203 bfd_byte *pnext;
3204
3205 pnext = contents + offset + 4;
3206 insn = bfd_get_32 (input_bfd, pnext);
3207
3208 if (insn == 0x60000000 /* nop (ori r0,r0,0) */
3209 || insn == 0x4def7b82 /* cror 15,15,15 */
3210 || insn == 0x4ffffb82) /* cror 31,31,31 */
3211 {
3212 bfd_put_32 (input_bfd,
3213 (bfd_vma) 0xe8410028, /* ld r2,40(r1) */
3214 pnext);
3215 }
3216 }
3217 break;
3218 }
3219
3220 /* Set `addend'. */
3221 switch (r_type)
3222 {
3223 default:
3224 (*_bfd_error_handler)
3225 (_("%s: unknown relocation type %d for symbol %s"),
3226 bfd_archive_filename (input_bfd), (int) r_type, sym_name);
3227
3228 bfd_set_error (bfd_error_bad_value);
3229 ret = false;
3230 continue;
3231
3232 case R_PPC64_NONE:
3233 case R_PPC_GNU_VTINHERIT:
3234 case R_PPC_GNU_VTENTRY:
3235 continue;
3236
3237 /* GOT16 relocations. Like an ADDR16 using the symbol's
3238 address in the GOT as relocation value instead of the
3239 symbols value itself. Also, create a GOT entry for the
3240 symbol and put the symbol value there. */
3241 case R_PPC64_GOT16:
3242 case R_PPC64_GOT16_LO:
3243 case R_PPC64_GOT16_HI:
3244 case R_PPC64_GOT16_HA:
3245 case R_PPC64_GOT16_DS:
3246 case R_PPC64_GOT16_LO_DS:
3247 {
3248 /* Relocation is to the entry for this symbol in the global
3249 offset table. */
3250 bfd_vma off;
3251
3252 if (htab->sgot == NULL)
3253 abort ();
3254
3255 if (h != NULL)
3256 {
3257 boolean dyn;
3258
3259 off = h->got.offset;
3260 dyn = htab->elf.dynamic_sections_created;
3261 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
3262 || (info->shared
3263 && (info->symbolic
3264 || h->dynindx == -1
3265 || (h->elf_link_hash_flags
3266 & ELF_LINK_FORCED_LOCAL))
3267 && (h->elf_link_hash_flags
3268 & ELF_LINK_HASH_DEF_REGULAR)))
3269 {
3270 /* This is actually a static link, or it is a
3271 -Bsymbolic link and the symbol is defined
3272 locally, or the symbol was forced to be local
3273 because of a version file. We must initialize
3274 this entry in the global offset table. Since the
3275 offset must always be a multiple of 8, we use the
3276 least significant bit to record whether we have
3277 initialized it already.
3278
3279 When doing a dynamic link, we create a .rel.got
3280 relocation entry to initialize the value. This
3281 is done in the finish_dynamic_symbol routine. */
3282 if ((off & 1) != 0)
3283 off &= ~1;
3284 else
3285 {
3286 bfd_put_64 (output_bfd, relocation,
3287 htab->sgot->contents + off);
3288 h->got.offset |= 1;
3289 }
3290 }
3291 else
3292 unresolved_reloc = false;
3293 }
3294 else
3295 {
3296 if (local_got_offsets == NULL)
3297 abort ();
3298
3299 off = local_got_offsets[r_symndx];
3300
3301 /* The offset must always be a multiple of 8. We use
3302 the least significant bit to record whether we have
3303 already processed this entry. */
3304 if ((off & 1) != 0)
3305 off &= ~1;
3306 else
3307 {
3308 bfd_put_64 (output_bfd, relocation,
3309 htab->sgot->contents + off);
3310
3311 if (info->shared)
3312 {
3313 Elf_Internal_Rela outrel;
3314 Elf64_External_Rela *loc;
3315
3316 /* We need to generate a R_PPC64_RELATIVE reloc
3317 for the dynamic linker. */
3318 outrel.r_offset = (htab->sgot->output_section->vma
3319 + htab->sgot->output_offset
3320 + off);
3321 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
3322 outrel.r_addend = relocation;
3323 loc = (Elf64_External_Rela *) htab->srelgot->contents;
3324 loc += htab->srelgot->reloc_count++;
3325 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
3326 }
3327
3328 local_got_offsets[r_symndx] |= 1;
3329 }
3330 }
3331
3332 if (off >= (bfd_vma) -2)
3333 abort ();
3334
3335 relocation = htab->sgot->output_offset + off;
3336
3337 /* TOC base (r2) is TOC start plus 0x8000. */
3338 addend -= TOC_BASE_OFF;
3339 }
3340 break;
3341
3342 case R_PPC64_PLT16_HA:
3343 case R_PPC64_PLT16_HI:
3344 case R_PPC64_PLT16_LO:
3345 case R_PPC64_PLT32:
3346 case R_PPC64_PLT64:
3347 /* Relocation is to the entry for this symbol in the
3348 procedure linkage table. */
3349
3350 /* Resolve a PLT reloc against a local symbol directly,
3351 without using the procedure linkage table. */
3352 if (h == NULL)
3353 break;
3354
3355 if (h->plt.offset == (bfd_vma) -1
3356 || htab->splt == NULL)
3357 {
3358 /* We didn't make a PLT entry for this symbol. This
3359 happens when statically linking PIC code, or when
3360 using -Bsymbolic. */
3361 break;
3362 }
3363
3364 relocation = (htab->splt->output_section->vma
3365 + htab->splt->output_offset
3366 + h->plt.offset);
3367 unresolved_reloc = false;
3368 break;
3369
3370 /* TOC16 relocs. We want the offset relative to the TOC base,
3371 which is the address of the start of the TOC plus 0x8000.
3372 The TOC consists of sections .got, .toc, .tocbss, and .plt,
3373 in this order. */
3374
3375 case R_PPC64_TOC16:
3376 case R_PPC64_TOC16_LO:
3377 case R_PPC64_TOC16_HI:
3378 case R_PPC64_TOC16_DS:
3379 case R_PPC64_TOC16_LO_DS:
3380 case R_PPC64_TOC16_HA:
3381 /* Only .got, .toc and *UND* symbols are allowed. */
3382 BFD_ASSERT (sec != (asection *) 0
3383 && (bfd_is_und_section (sec)
3384 || strcmp (bfd_get_section_name (abfd, sec),
3385 ".toc") == 0
3386 || strcmp (bfd_get_section_name (abfd, sec),
3387 ".got") == 0));
3388
3389 addend -= TOCstart + TOC_BASE_OFF;
3390 break;
3391
3392 /* Relocate against the beginning of the section. */
3393 case R_PPC64_SECTOFF:
3394 case R_PPC64_SECTOFF_LO:
3395 case R_PPC64_SECTOFF_HI:
3396 case R_PPC64_SECTOFF_DS:
3397 case R_PPC64_SECTOFF_LO_DS:
3398 case R_PPC64_SECTOFF_HA:
3399 if (sec != (asection *) 0)
3400 addend -= sec->output_section->vma;
3401 break;
3402
3403 /* Relocations that may need to be propagated if this is a
3404 dynamic object. */
3405 case R_PPC64_REL14:
3406 case R_PPC64_REL14_BRNTAKEN:
3407 case R_PPC64_REL14_BRTAKEN:
3408 case R_PPC64_REL24:
3409 case R_PPC64_REL32:
3410 case R_PPC64_REL64:
3411 case R_PPC64_ADDR14:
3412 case R_PPC64_ADDR14_BRNTAKEN:
3413 case R_PPC64_ADDR14_BRTAKEN:
3414 case R_PPC64_ADDR16:
3415 case R_PPC64_ADDR16_DS:
3416 case R_PPC64_ADDR16_HA:
3417 case R_PPC64_ADDR16_HI:
3418 case R_PPC64_ADDR16_HIGHER:
3419 case R_PPC64_ADDR16_HIGHERA:
3420 case R_PPC64_ADDR16_HIGHEST:
3421 case R_PPC64_ADDR16_HIGHESTA:
3422 case R_PPC64_ADDR16_LO:
3423 case R_PPC64_ADDR16_LO_DS:
3424 case R_PPC64_ADDR24:
3425 case R_PPC64_ADDR30:
3426 case R_PPC64_ADDR32:
3427 case R_PPC64_ADDR64:
3428 case R_PPC64_UADDR16:
3429 case R_PPC64_UADDR32:
3430 case R_PPC64_UADDR64:
3431 case R_PPC64_TOC:
3432 if ((info->shared
3433 && (input_section->flags & SEC_ALLOC) != 0
3434 && (IS_ABSOLUTE_RELOC (r_type)
3435 || (h != NULL
3436 && h->dynindx != -1
3437 && (! info->symbolic
3438 || (h->elf_link_hash_flags
3439 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
3440 || (!info->shared
3441 && (input_section->flags & SEC_ALLOC) != 0
3442 && h != NULL
3443 && h->dynindx != -1
3444 && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
3445 && (((h->elf_link_hash_flags
3446 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
3447 && (h->elf_link_hash_flags
3448 & ELF_LINK_HASH_DEF_REGULAR) == 0)
3449 || h->root.type == bfd_link_hash_undefweak
3450 || h->root.type == bfd_link_hash_undefined)))
3451 {
3452 Elf_Internal_Rela outrel;
3453 boolean skip, relocate;
3454 asection *sreloc;
3455 Elf64_External_Rela *loc;
3456
3457 /* When generating a dynamic object, these relocations
3458 are copied into the output file to be resolved at run
3459 time. */
3460
3461 skip = false;
3462
3463 if (elf_section_data (input_section)->stab_info == NULL)
3464 outrel.r_offset = offset;
3465 else
3466 {
3467 bfd_vma off;
3468
3469 off = (_bfd_stab_section_offset
3470 (output_bfd, htab->elf.stab_info, input_section,
3471 &elf_section_data (input_section)->stab_info,
3472 offset));
3473 if (off == (bfd_vma) -1)
3474 skip = true;
3475 outrel.r_offset = off;
3476 }
3477
3478 outrel.r_offset += (input_section->output_section->vma
3479 + input_section->output_offset);
3480 outrel.r_addend = addend;
3481
3482 if (skip)
3483 {
3484 relocate = false;
3485 memset (&outrel, 0, sizeof outrel);
3486 }
3487 else if (h != NULL
3488 && h->dynindx != -1
3489 && (!IS_ABSOLUTE_RELOC (r_type)
3490 || !info->shared
3491 || !info->symbolic
3492 || (h->elf_link_hash_flags
3493 & ELF_LINK_HASH_DEF_REGULAR) == 0))
3494 {
3495 relocate = false;
3496 outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
3497 }
3498 else
3499 {
3500 /* This symbol is local, or marked to become local. */
3501 outrel.r_addend += relocation;
3502 relocate = true;
3503 if (r_type == R_PPC64_ADDR64)
3504 {
3505 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
3506 }
3507 else
3508 {
3509 long indx = 0;
3510
3511 if (r_type == R_PPC64_TOC || bfd_is_abs_section (sec))
3512 ;
3513 else if (sec == NULL || sec->owner == NULL)
3514 {
3515 bfd_set_error (bfd_error_bad_value);
3516 return false;
3517 }
3518 else
3519 {
3520 asection *osec;
3521
3522 osec = sec->output_section;
3523 indx = elf_section_data (osec)->dynindx;
3524
3525 /* We are turning this relocation into one
3526 against a section symbol, so subtract out
3527 the output section's address but not the
3528 offset of the input section in the output
3529 section. */
3530 outrel.r_addend -= osec->vma;
3531 }
3532
3533 outrel.r_info = ELF64_R_INFO (indx, r_type);
3534 }
3535 }
3536
3537 sreloc = elf_section_data (input_section)->sreloc;
3538 if (sreloc == NULL)
3539 abort ();
3540
3541 loc = (Elf64_External_Rela *) sreloc->contents;
3542 loc += sreloc->reloc_count++;
3543 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
3544
3545 /* If this reloc is against an external symbol, it will
3546 be computed at runtime, so there's no need to do
3547 anything now. */
3548 if (! relocate)
3549 continue;
3550 }
3551 break;
3552
3553 case R_PPC64_COPY:
3554 case R_PPC64_GLOB_DAT:
3555 case R_PPC64_JMP_SLOT:
3556 case R_PPC64_RELATIVE:
3557 /* We shouldn't ever see these dynamic relocs in relocatable
3558 files. */
3559 /* Fall thru */
3560
3561 case R_PPC64_PLTGOT16:
3562 case R_PPC64_PLTGOT16_DS:
3563 case R_PPC64_PLTGOT16_HA:
3564 case R_PPC64_PLTGOT16_HI:
3565 case R_PPC64_PLTGOT16_LO:
3566 case R_PPC64_PLTGOT16_LO_DS:
3567 case R_PPC64_PLTREL32:
3568 case R_PPC64_PLTREL64:
3569 /* These ones haven't been implemented yet. */
3570
3571 (*_bfd_error_handler)
3572 (_("%s: Relocation %s is not supported for symbol %s."),
3573 bfd_archive_filename (input_bfd),
3574 ppc64_elf_howto_table[(int) r_type]->name, sym_name);
3575
3576 bfd_set_error (bfd_error_invalid_operation);
3577 ret = false;
3578 continue;
3579 }
3580
3581 /* Do any further special processing. */
3582 switch (r_type)
3583 {
3584 default:
3585 break;
3586
3587 case R_PPC64_ADDR16_HA:
3588 case R_PPC64_ADDR16_HIGHERA:
3589 case R_PPC64_ADDR16_HIGHESTA:
3590 case R_PPC64_PLT16_HA:
3591 case R_PPC64_TOC16_HA:
3592 case R_PPC64_SECTOFF_HA:
3593 /* It's just possible that this symbol is a weak symbol
3594 that's not actually defined anywhere. In that case,
3595 'sec' would be NULL, and we should leave the symbol
3596 alone (it will be set to zero elsewhere in the link). */
3597 if (sec != NULL)
3598 /* Add 0x10000 if sign bit in 0:15 is set. */
3599 addend += ((relocation + addend) & 0x8000) << 1;
3600 break;
3601
3602 case R_PPC64_ADDR16_DS:
3603 case R_PPC64_ADDR16_LO_DS:
3604 case R_PPC64_GOT16_DS:
3605 case R_PPC64_GOT16_LO_DS:
3606 case R_PPC64_PLT16_LO_DS:
3607 case R_PPC64_SECTOFF_DS:
3608 case R_PPC64_SECTOFF_LO_DS:
3609 case R_PPC64_TOC16_DS:
3610 case R_PPC64_TOC16_LO_DS:
3611 case R_PPC64_PLTGOT16_DS:
3612 case R_PPC64_PLTGOT16_LO_DS:
3613 if (((relocation + addend) & 3) != 0)
3614 {
3615 (*_bfd_error_handler)
3616 (_("%s: error: relocation %s not a multiple of 4"),
3617 bfd_archive_filename (input_bfd),
3618 ppc64_elf_howto_table[(int) r_type]->name);
3619 bfd_set_error (bfd_error_bad_value);
3620 ret = false;
3621 continue;
3622 }
3623 break;
3624 }
3625
3626 /* FIXME: Why do we allow debugging sections to escape this error?
3627 More importantly, why do we not emit dynamic relocs above in
3628 debugging sections (which are ! SEC_ALLOC)? If we had
3629 emitted the dynamic reloc, we could remove the fudge here. */
3630 if (unresolved_reloc
3631 && !(info->shared
3632 && (input_section->flags & SEC_DEBUGGING) != 0
3633 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
3634 (*_bfd_error_handler)
3635 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
3636 bfd_archive_filename (input_bfd),
3637 bfd_get_section_name (input_bfd, input_section),
3638 (long) rel->r_offset,
3639 h->root.root.string);
3640
3641 r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
3642 input_bfd,
3643 input_section,
3644 contents,
3645 offset,
3646 relocation,
3647 addend);
3648
3649 if (r == bfd_reloc_ok)
3650 ;
3651 else if (r == bfd_reloc_overflow)
3652 {
3653 const char *name;
3654
3655 if (h != NULL)
3656 {
3657 if (h->root.type == bfd_link_hash_undefweak
3658 && ppc64_elf_howto_table[(int) r_type]->pc_relative)
3659 {
3660 /* Assume this is a call protected by other code that
3661 detects the symbol is undefined. If this is the case,
3662 we can safely ignore the overflow. If not, the
3663 program is hosed anyway, and a little warning isn't
3664 going to help. */
3665
3666 continue;
3667 }
3668
3669 name = h->root.root.string;
3670 }
3671 else
3672 {
3673 name = bfd_elf_string_from_elf_section (input_bfd,
3674 symtab_hdr->sh_link,
3675 sym->st_name);
3676 if (name == NULL)
3677 continue;
3678 if (*name == '\0')
3679 name = bfd_section_name (input_bfd, sec);
3680 }
3681
3682 if (! ((*info->callbacks->reloc_overflow)
3683 (info, name, ppc64_elf_howto_table[(int) r_type]->name,
3684 (bfd_vma) 0, input_bfd, input_section, offset)))
3685 return false;
3686 }
3687 else
3688 ret = false;
3689 }
3690
3691 return ret;
3692 }
3693
3694 /* Finish up dynamic symbol handling. We set the contents of various
3695 dynamic sections here. */
3696
3697 static boolean
3698 ppc64_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
3699 bfd *output_bfd;
3700 struct bfd_link_info *info;
3701 struct elf_link_hash_entry *h;
3702 Elf_Internal_Sym *sym;
3703 {
3704 struct ppc_link_hash_table *htab;
3705 bfd *dynobj;
3706
3707 htab = ppc_hash_table (info);
3708 dynobj = htab->elf.dynobj;
3709
3710 if (h->plt.offset != (bfd_vma) -1)
3711 {
3712 struct elf_link_hash_entry *funcdesc_h;
3713 Elf_Internal_Rela rela;
3714 Elf64_External_Rela *loc;
3715
3716 /* This symbol has an entry in the procedure linkage table. Set
3717 it up. */
3718
3719 if (h->dynindx == -1
3720 || htab->splt == NULL
3721 || htab->srelplt == NULL
3722 || htab->sglink == NULL
3723 || h->root.root.string[0] != '.'
3724 || h->root.root.string[1] == '\0')
3725 abort ();
3726
3727 /* Find its corresponding function descriptor.
3728 ppc64_elf_adjust_dynamic_symbol has already set it up for us. */
3729
3730 funcdesc_h = elf_link_hash_lookup (elf_hash_table (info),
3731 h->root.root.string + 1,
3732 false, false, false);
3733
3734 if (funcdesc_h == NULL || funcdesc_h->dynindx == -1)
3735 abort ();
3736
3737 /* Create a JMP_SLOT reloc to inform the dynamic linker to
3738 fill in the PLT entry. */
3739
3740 rela.r_offset = (htab->splt->output_section->vma
3741 + htab->splt->output_offset
3742 + h->plt.offset);
3743 rela.r_info = ELF64_R_INFO (funcdesc_h->dynindx, R_PPC64_JMP_SLOT);
3744 rela.r_addend = 0;
3745
3746 loc = (Elf64_External_Rela *) htab->srelplt->contents;
3747 loc += (h->plt.offset - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE;
3748 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3749
3750 /* We need to create a linkage function. */
3751 if (h->root.u.def.section == htab->sglink)
3752 {
3753 bfd_byte *p;
3754 bfd_vma pltoff;
3755 const unsigned int *stub;
3756
3757 /* Where to write it. */
3758 p = h->root.u.def.section->contents + h->root.u.def.value;
3759
3760 /* The function descriptor is in the PLT. */
3761 pltoff = htab->splt->output_section->vma
3762 + htab->splt->output_section->output_offset
3763 + h->plt.offset
3764 - elf_gp (output_bfd) - TOC_BASE_OFF;
3765
3766 if (pltoff + 0x8000 > 0xffff)
3767 {
3768 (*_bfd_error_handler)
3769 (_("linkage table overflow against `%s'"),
3770 h->root.root.string);
3771 }
3772
3773 /* Write it out. */
3774 stub = ppc64_elf_glink_code;
3775 bfd_put_32 (output_bfd, *stub | (pltoff & 0xfffc), p);
3776 while (p += 4, ++stub < (ppc64_elf_glink_code
3777 + (sizeof (ppc64_elf_glink_code)
3778 / sizeof (*ppc64_elf_glink_code))));
3779 {
3780 bfd_put_32 (output_bfd, (bfd_vma) *stub, p);
3781 }
3782 }
3783 else
3784 abort ();
3785 }
3786
3787 if (h->got.offset != (bfd_vma) -1)
3788 {
3789 Elf_Internal_Rela rela;
3790 Elf64_External_Rela *loc;
3791
3792 /* This symbol has an entry in the global offset table. Set it
3793 up. */
3794
3795 if (htab->sgot == NULL || htab->srelgot == NULL)
3796 abort ();
3797
3798 rela.r_offset = (htab->sgot->output_section->vma
3799 + htab->sgot->output_offset
3800 + (h->got.offset &~ (bfd_vma) 1));
3801
3802 /* If this is a static link, or it is a -Bsymbolic link and the
3803 symbol is defined locally or was forced to be local because
3804 of a version file, we just want to emit a RELATIVE reloc.
3805 The entry in the global offset table will already have been
3806 initialized in the relocate_section function. */
3807 if (info->shared
3808 && (info->symbolic
3809 || h->dynindx == -1
3810 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
3811 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3812 {
3813 BFD_ASSERT((h->got.offset & 1) != 0);
3814 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
3815 rela.r_addend = (h->root.u.def.value
3816 + h->root.u.def.section->output_section->vma
3817 + h->root.u.def.section->output_offset);
3818 }
3819 else
3820 {
3821 BFD_ASSERT ((h->got.offset & 1) == 0);
3822 bfd_put_64 (output_bfd, (bfd_vma) 0,
3823 htab->sgot->contents + h->got.offset);
3824 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_GLOB_DAT);
3825 rela.r_addend = 0;
3826 }
3827
3828 loc = (Elf64_External_Rela *) htab->srelgot->contents;
3829 loc += htab->srelgot->reloc_count++;
3830 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3831 }
3832
3833 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
3834 {
3835 Elf_Internal_Rela rela;
3836 Elf64_External_Rela *loc;
3837
3838 /* This symbol needs a copy reloc. Set it up. */
3839
3840 if (h->dynindx == -1
3841 || (h->root.type != bfd_link_hash_defined
3842 && h->root.type != bfd_link_hash_defweak)
3843 || htab->srelbss == NULL)
3844 abort ();
3845
3846 rela.r_offset = (h->root.u.def.value
3847 + h->root.u.def.section->output_section->vma
3848 + h->root.u.def.section->output_offset);
3849 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
3850 rela.r_addend = 0;
3851 loc = (Elf64_External_Rela *) htab->srelbss->contents;
3852 loc += htab->srelbss->reloc_count++;
3853 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3854 }
3855
3856 /* Mark some specially defined symbols as absolute. */
3857 if (strcmp (h->root.root.string, "_DYNAMIC") == 0)
3858 sym->st_shndx = SHN_ABS;
3859
3860 return true;
3861 }
3862
3863 /* Used to decide how to sort relocs in an optimal manner for the
3864 dynamic linker, before writing them out. */
3865
3866 static enum elf_reloc_type_class
3867 ppc64_elf_reloc_type_class (rela)
3868 const Elf_Internal_Rela *rela;
3869 {
3870 enum elf_ppc_reloc_type r_type;
3871
3872 r_type = (enum elf_ppc_reloc_type) ELF64_R_TYPE (rela->r_info);
3873 switch (r_type)
3874 {
3875 case R_PPC64_RELATIVE:
3876 return reloc_class_relative;
3877 case R_PPC64_JMP_SLOT:
3878 return reloc_class_plt;
3879 case R_PPC64_COPY:
3880 return reloc_class_copy;
3881 default:
3882 return reloc_class_normal;
3883 }
3884 }
3885
3886 /* Finish up the dynamic sections. */
3887
3888 static boolean
3889 ppc64_elf_finish_dynamic_sections (output_bfd, info)
3890 bfd *output_bfd;
3891 struct bfd_link_info *info;
3892 {
3893 struct ppc_link_hash_table *htab;
3894 bfd *dynobj;
3895 asection *sdyn;
3896
3897 htab = ppc_hash_table (info);
3898 dynobj = htab->elf.dynobj;
3899 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3900
3901 if (htab->elf.dynamic_sections_created)
3902 {
3903 Elf64_External_Dyn *dyncon, *dynconend;
3904
3905 if (sdyn == NULL || htab->sgot == NULL)
3906 abort ();
3907
3908 dyncon = (Elf64_External_Dyn *) sdyn->contents;
3909 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3910 for (; dyncon < dynconend; dyncon++)
3911 {
3912 Elf_Internal_Dyn dyn;
3913
3914 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3915
3916 switch (dyn.d_tag)
3917 {
3918 default:
3919 continue;
3920
3921 case DT_PLTGOT:
3922 dyn.d_un.d_ptr = htab->splt->output_section->vma;
3923 break;
3924
3925 case DT_JMPREL:
3926 dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
3927 break;
3928
3929 case DT_PLTRELSZ:
3930 if (htab->srelplt->output_section->_cooked_size != 0)
3931 dyn.d_un.d_val = htab->srelplt->output_section->_cooked_size;
3932 else
3933 dyn.d_un.d_val = htab->srelplt->output_section->_raw_size;
3934 break;
3935 }
3936
3937 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3938 }
3939 }
3940
3941 return true;
3942 }
3943
3944 #define TARGET_LITTLE_SYM bfd_elf64_powerpcle_vec
3945 #define TARGET_LITTLE_NAME "elf64-powerpcle"
3946 #define TARGET_BIG_SYM bfd_elf64_powerpc_vec
3947 #define TARGET_BIG_NAME "elf64-powerpc"
3948 #define ELF_ARCH bfd_arch_powerpc
3949 #define ELF_MACHINE_CODE EM_PPC64
3950 #define ELF_MAXPAGESIZE 0x10000
3951 #define elf_info_to_howto ppc64_elf_info_to_howto
3952
3953 #ifdef EM_CYGNUS_POWERPC
3954 #define ELF_MACHINE_ALT1 EM_CYGNUS_POWERPC
3955 #endif
3956
3957 #ifdef EM_PPC_OLD
3958 #define ELF_MACHINE_ALT2 EM_PPC_OLD
3959 #endif
3960
3961 #define elf_backend_want_got_sym 0
3962 #define elf_backend_want_plt_sym 0
3963 #define elf_backend_plt_alignment 3
3964 #define elf_backend_plt_not_loaded 1
3965 #define elf_backend_got_symbol_offset 0
3966 #define elf_backend_got_header_size 0
3967 #define elf_backend_can_gc_sections 1
3968 #define elf_backend_can_refcount 1
3969
3970 #define elf_backend_plt_header_size PLT_INITIAL_ENTRY_SIZE
3971
3972 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
3973 #define bfd_elf64_bfd_set_private_flags ppc64_elf_set_private_flags
3974 #define bfd_elf64_bfd_copy_private_bfd_data ppc64_elf_copy_private_bfd_data
3975 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
3976 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
3977 #define bfd_elf64_bfd_final_link ppc64_elf_final_link
3978
3979 #define elf_backend_section_from_shdr ppc64_elf_section_from_shdr
3980 #define elf_backend_create_dynamic_sections ppc64_elf_create_dynamic_sections
3981 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
3982 #define elf_backend_check_relocs ppc64_elf_check_relocs
3983 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
3984 #define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
3985 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
3986 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
3987 #define elf_backend_fake_sections ppc64_elf_fake_sections
3988 #define elf_backend_relocate_section ppc64_elf_relocate_section
3989 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
3990 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
3991 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
3992
3993 #include "elf64-target.h"
git-cvsimport of binutils cvsroot