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