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