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