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