projects / deliverable / binutils-gdb.git / blob
? search:


eb07b1fb7c7bf19690c32dc2cf6326a313f846a0
[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, 2011 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_TARGET_ID PPC64_ELF_DATA
65 #define ELF_MACHINE_CODE EM_PPC64
66 #define ELF_MAXPAGESIZE 0x10000
67 #define ELF_COMMONPAGESIZE 0x1000
68 #define elf_info_to_howto ppc64_elf_info_to_howto
69
70 #define elf_backend_want_got_sym 0
71 #define elf_backend_want_plt_sym 0
72 #define elf_backend_plt_alignment 3
73 #define elf_backend_plt_not_loaded 1
74 #define elf_backend_got_header_size 8
75 #define elf_backend_can_gc_sections 1
76 #define elf_backend_can_refcount 1
77 #define elf_backend_rela_normal 1
78 #define elf_backend_default_execstack 0
79
80 #define bfd_elf64_mkobject ppc64_elf_mkobject
81 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
82 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
83 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
84 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
85 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
86 #define bfd_elf64_bfd_link_hash_table_free ppc64_elf_link_hash_table_free
87 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
88 #define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
89
90 #define elf_backend_object_p ppc64_elf_object_p
91 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
92 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
93 #define elf_backend_write_core_note ppc64_elf_write_core_note
94 #define elf_backend_create_dynamic_sections ppc64_elf_create_dynamic_sections
95 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
96 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
97 #define elf_backend_check_directives ppc64_elf_process_dot_syms
98 #define elf_backend_as_needed_cleanup ppc64_elf_as_needed_cleanup
99 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
100 #define elf_backend_check_relocs ppc64_elf_check_relocs
101 #define elf_backend_gc_keep ppc64_elf_gc_keep
102 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
103 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
104 #define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
105 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
106 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
107 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
108 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
109 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
110 #define elf_backend_action_discarded ppc64_elf_action_discarded
111 #define elf_backend_relocate_section ppc64_elf_relocate_section
112 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
113 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
114 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
115 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
116 #define elf_backend_special_sections ppc64_elf_special_sections
117 #define elf_backend_post_process_headers _bfd_elf_set_osabi
118
119 /* The name of the dynamic interpreter. This is put in the .interp
120 section. */
121 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
122
123 /* The size in bytes of an entry in the procedure linkage table. */
124 #define PLT_ENTRY_SIZE 24
125
126 /* The initial size of the plt reserved for the dynamic linker. */
127 #define PLT_INITIAL_ENTRY_SIZE PLT_ENTRY_SIZE
128
129 /* TOC base pointers offset from start of TOC. */
130 #define TOC_BASE_OFF 0x8000
131
132 /* Offset of tp and dtp pointers from start of TLS block. */
133 #define TP_OFFSET 0x7000
134 #define DTP_OFFSET 0x8000
135
136 /* .plt call stub instructions. The normal stub is like this, but
137 sometimes the .plt entry crosses a 64k boundary and we need to
138 insert an addi to adjust r12. */
139 #define PLT_CALL_STUB_SIZE (7*4)
140 #define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
141 #define STD_R2_40R1 0xf8410028 /* std %r2,40(%r1) */
142 #define LD_R11_0R12 0xe96c0000 /* ld %r11,xxx+0@l(%r12) */
143 #define MTCTR_R11 0x7d6903a6 /* mtctr %r11 */
144 #define LD_R2_0R12 0xe84c0000 /* ld %r2,xxx+8@l(%r12) */
145 /* ld %r11,xxx+16@l(%r12) */
146 #define BCTR 0x4e800420 /* bctr */
147
148
149 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,off@ha */
150 #define ADDI_R12_R12 0x398c0000 /* addi %r12,%r12,off@l */
151 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
152 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
153
154 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
155 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
156
157 #define LD_R2_40R1 0xe8410028 /* ld %r2,40(%r1) */
158
159 /* glink call stub instructions. We enter with the index in R0. */
160 #define GLINK_CALL_STUB_SIZE (16*4)
161 /* 0: */
162 /* .quad plt0-1f */
163 /* __glink: */
164 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
165 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
166 /* 1: */
167 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
168 #define LD_R2_M16R11 0xe84bfff0 /* ld %2,(0b-1b)(%11) */
169 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
170 #define ADD_R12_R2_R11 0x7d825a14 /* add %12,%2,%11 */
171 /* ld %11,0(%12) */
172 /* ld %2,8(%12) */
173 /* mtctr %11 */
174 /* ld %11,16(%12) */
175 /* bctr */
176
177 /* Pad with this. */
178 #define NOP 0x60000000
179
180 /* Some other nops. */
181 #define CROR_151515 0x4def7b82
182 #define CROR_313131 0x4ffffb82
183
184 /* .glink entries for the first 32k functions are two instructions. */
185 #define LI_R0_0 0x38000000 /* li %r0,0 */
186 #define B_DOT 0x48000000 /* b . */
187
188 /* After that, we need two instructions to load the index, followed by
189 a branch. */
190 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
191 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
192
193 /* Instructions used by the save and restore reg functions. */
194 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
195 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
196 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
197 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
198 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
199 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
200 #define LI_R12_0 0x39800000 /* li %r12,0 */
201 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
202 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
203 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
204 #define BLR 0x4e800020 /* blr */
205
206 /* Since .opd is an array of descriptors and each entry will end up
207 with identical R_PPC64_RELATIVE relocs, there is really no need to
208 propagate .opd relocs; The dynamic linker should be taught to
209 relocate .opd without reloc entries. */
210 #ifndef NO_OPD_RELOCS
211 #define NO_OPD_RELOCS 0
212 #endif
213 \f
214 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
215
216 /* Relocation HOWTO's. */
217 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
218
219 static reloc_howto_type ppc64_elf_howto_raw[] = {
220 /* This reloc does nothing. */
221 HOWTO (R_PPC64_NONE, /* type */
222 0, /* rightshift */
223 2, /* size (0 = byte, 1 = short, 2 = long) */
224 32, /* bitsize */
225 FALSE, /* pc_relative */
226 0, /* bitpos */
227 complain_overflow_dont, /* complain_on_overflow */
228 bfd_elf_generic_reloc, /* special_function */
229 "R_PPC64_NONE", /* name */
230 FALSE, /* partial_inplace */
231 0, /* src_mask */
232 0, /* dst_mask */
233 FALSE), /* pcrel_offset */
234
235 /* A standard 32 bit relocation. */
236 HOWTO (R_PPC64_ADDR32, /* type */
237 0, /* rightshift */
238 2, /* size (0 = byte, 1 = short, 2 = long) */
239 32, /* bitsize */
240 FALSE, /* pc_relative */
241 0, /* bitpos */
242 complain_overflow_bitfield, /* complain_on_overflow */
243 bfd_elf_generic_reloc, /* special_function */
244 "R_PPC64_ADDR32", /* name */
245 FALSE, /* partial_inplace */
246 0, /* src_mask */
247 0xffffffff, /* dst_mask */
248 FALSE), /* pcrel_offset */
249
250 /* An absolute 26 bit branch; the lower two bits must be zero.
251 FIXME: we don't check that, we just clear them. */
252 HOWTO (R_PPC64_ADDR24, /* type */
253 0, /* rightshift */
254 2, /* size (0 = byte, 1 = short, 2 = long) */
255 26, /* bitsize */
256 FALSE, /* pc_relative */
257 0, /* bitpos */
258 complain_overflow_bitfield, /* complain_on_overflow */
259 bfd_elf_generic_reloc, /* special_function */
260 "R_PPC64_ADDR24", /* name */
261 FALSE, /* partial_inplace */
262 0, /* src_mask */
263 0x03fffffc, /* dst_mask */
264 FALSE), /* pcrel_offset */
265
266 /* A standard 16 bit relocation. */
267 HOWTO (R_PPC64_ADDR16, /* type */
268 0, /* rightshift */
269 1, /* size (0 = byte, 1 = short, 2 = long) */
270 16, /* bitsize */
271 FALSE, /* pc_relative */
272 0, /* bitpos */
273 complain_overflow_bitfield, /* complain_on_overflow */
274 bfd_elf_generic_reloc, /* special_function */
275 "R_PPC64_ADDR16", /* name */
276 FALSE, /* partial_inplace */
277 0, /* src_mask */
278 0xffff, /* dst_mask */
279 FALSE), /* pcrel_offset */
280
281 /* A 16 bit relocation without overflow. */
282 HOWTO (R_PPC64_ADDR16_LO, /* type */
283 0, /* rightshift */
284 1, /* size (0 = byte, 1 = short, 2 = long) */
285 16, /* bitsize */
286 FALSE, /* pc_relative */
287 0, /* bitpos */
288 complain_overflow_dont,/* complain_on_overflow */
289 bfd_elf_generic_reloc, /* special_function */
290 "R_PPC64_ADDR16_LO", /* name */
291 FALSE, /* partial_inplace */
292 0, /* src_mask */
293 0xffff, /* dst_mask */
294 FALSE), /* pcrel_offset */
295
296 /* Bits 16-31 of an address. */
297 HOWTO (R_PPC64_ADDR16_HI, /* type */
298 16, /* rightshift */
299 1, /* size (0 = byte, 1 = short, 2 = long) */
300 16, /* bitsize */
301 FALSE, /* pc_relative */
302 0, /* bitpos */
303 complain_overflow_dont, /* complain_on_overflow */
304 bfd_elf_generic_reloc, /* special_function */
305 "R_PPC64_ADDR16_HI", /* name */
306 FALSE, /* partial_inplace */
307 0, /* src_mask */
308 0xffff, /* dst_mask */
309 FALSE), /* pcrel_offset */
310
311 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
312 bits, treated as a signed number, is negative. */
313 HOWTO (R_PPC64_ADDR16_HA, /* type */
314 16, /* rightshift */
315 1, /* size (0 = byte, 1 = short, 2 = long) */
316 16, /* bitsize */
317 FALSE, /* pc_relative */
318 0, /* bitpos */
319 complain_overflow_dont, /* complain_on_overflow */
320 ppc64_elf_ha_reloc, /* special_function */
321 "R_PPC64_ADDR16_HA", /* name */
322 FALSE, /* partial_inplace */
323 0, /* src_mask */
324 0xffff, /* dst_mask */
325 FALSE), /* pcrel_offset */
326
327 /* An absolute 16 bit branch; the lower two bits must be zero.
328 FIXME: we don't check that, we just clear them. */
329 HOWTO (R_PPC64_ADDR14, /* type */
330 0, /* rightshift */
331 2, /* size (0 = byte, 1 = short, 2 = long) */
332 16, /* bitsize */
333 FALSE, /* pc_relative */
334 0, /* bitpos */
335 complain_overflow_bitfield, /* complain_on_overflow */
336 ppc64_elf_branch_reloc, /* special_function */
337 "R_PPC64_ADDR14", /* name */
338 FALSE, /* partial_inplace */
339 0, /* src_mask */
340 0x0000fffc, /* dst_mask */
341 FALSE), /* pcrel_offset */
342
343 /* An absolute 16 bit branch, for which bit 10 should be set to
344 indicate that the branch is expected to be taken. The lower two
345 bits must be zero. */
346 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
347 0, /* rightshift */
348 2, /* size (0 = byte, 1 = short, 2 = long) */
349 16, /* bitsize */
350 FALSE, /* pc_relative */
351 0, /* bitpos */
352 complain_overflow_bitfield, /* complain_on_overflow */
353 ppc64_elf_brtaken_reloc, /* special_function */
354 "R_PPC64_ADDR14_BRTAKEN",/* name */
355 FALSE, /* partial_inplace */
356 0, /* src_mask */
357 0x0000fffc, /* dst_mask */
358 FALSE), /* pcrel_offset */
359
360 /* An absolute 16 bit branch, for which bit 10 should be set to
361 indicate that the branch is not expected to be taken. The lower
362 two bits must be zero. */
363 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
364 0, /* rightshift */
365 2, /* size (0 = byte, 1 = short, 2 = long) */
366 16, /* bitsize */
367 FALSE, /* pc_relative */
368 0, /* bitpos */
369 complain_overflow_bitfield, /* complain_on_overflow */
370 ppc64_elf_brtaken_reloc, /* special_function */
371 "R_PPC64_ADDR14_BRNTAKEN",/* name */
372 FALSE, /* partial_inplace */
373 0, /* src_mask */
374 0x0000fffc, /* dst_mask */
375 FALSE), /* pcrel_offset */
376
377 /* A relative 26 bit branch; the lower two bits must be zero. */
378 HOWTO (R_PPC64_REL24, /* type */
379 0, /* rightshift */
380 2, /* size (0 = byte, 1 = short, 2 = long) */
381 26, /* bitsize */
382 TRUE, /* pc_relative */
383 0, /* bitpos */
384 complain_overflow_signed, /* complain_on_overflow */
385 ppc64_elf_branch_reloc, /* special_function */
386 "R_PPC64_REL24", /* name */
387 FALSE, /* partial_inplace */
388 0, /* src_mask */
389 0x03fffffc, /* dst_mask */
390 TRUE), /* pcrel_offset */
391
392 /* A relative 16 bit branch; the lower two bits must be zero. */
393 HOWTO (R_PPC64_REL14, /* type */
394 0, /* rightshift */
395 2, /* size (0 = byte, 1 = short, 2 = long) */
396 16, /* bitsize */
397 TRUE, /* pc_relative */
398 0, /* bitpos */
399 complain_overflow_signed, /* complain_on_overflow */
400 ppc64_elf_branch_reloc, /* special_function */
401 "R_PPC64_REL14", /* name */
402 FALSE, /* partial_inplace */
403 0, /* src_mask */
404 0x0000fffc, /* dst_mask */
405 TRUE), /* pcrel_offset */
406
407 /* A relative 16 bit branch. Bit 10 should be set to indicate that
408 the branch is expected to be taken. The lower two bits must be
409 zero. */
410 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
411 0, /* rightshift */
412 2, /* size (0 = byte, 1 = short, 2 = long) */
413 16, /* bitsize */
414 TRUE, /* pc_relative */
415 0, /* bitpos */
416 complain_overflow_signed, /* complain_on_overflow */
417 ppc64_elf_brtaken_reloc, /* special_function */
418 "R_PPC64_REL14_BRTAKEN", /* name */
419 FALSE, /* partial_inplace */
420 0, /* src_mask */
421 0x0000fffc, /* dst_mask */
422 TRUE), /* pcrel_offset */
423
424 /* A relative 16 bit branch. Bit 10 should be set to indicate that
425 the branch is not expected to be taken. The lower two bits must
426 be zero. */
427 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
428 0, /* rightshift */
429 2, /* size (0 = byte, 1 = short, 2 = long) */
430 16, /* bitsize */
431 TRUE, /* pc_relative */
432 0, /* bitpos */
433 complain_overflow_signed, /* complain_on_overflow */
434 ppc64_elf_brtaken_reloc, /* special_function */
435 "R_PPC64_REL14_BRNTAKEN",/* name */
436 FALSE, /* partial_inplace */
437 0, /* src_mask */
438 0x0000fffc, /* dst_mask */
439 TRUE), /* pcrel_offset */
440
441 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
442 symbol. */
443 HOWTO (R_PPC64_GOT16, /* type */
444 0, /* rightshift */
445 1, /* size (0 = byte, 1 = short, 2 = long) */
446 16, /* bitsize */
447 FALSE, /* pc_relative */
448 0, /* bitpos */
449 complain_overflow_signed, /* complain_on_overflow */
450 ppc64_elf_unhandled_reloc, /* special_function */
451 "R_PPC64_GOT16", /* name */
452 FALSE, /* partial_inplace */
453 0, /* src_mask */
454 0xffff, /* dst_mask */
455 FALSE), /* pcrel_offset */
456
457 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
458 the symbol. */
459 HOWTO (R_PPC64_GOT16_LO, /* type */
460 0, /* rightshift */
461 1, /* size (0 = byte, 1 = short, 2 = long) */
462 16, /* bitsize */
463 FALSE, /* pc_relative */
464 0, /* bitpos */
465 complain_overflow_dont, /* complain_on_overflow */
466 ppc64_elf_unhandled_reloc, /* special_function */
467 "R_PPC64_GOT16_LO", /* name */
468 FALSE, /* partial_inplace */
469 0, /* src_mask */
470 0xffff, /* dst_mask */
471 FALSE), /* pcrel_offset */
472
473 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
474 the symbol. */
475 HOWTO (R_PPC64_GOT16_HI, /* type */
476 16, /* rightshift */
477 1, /* size (0 = byte, 1 = short, 2 = long) */
478 16, /* bitsize */
479 FALSE, /* pc_relative */
480 0, /* bitpos */
481 complain_overflow_dont,/* complain_on_overflow */
482 ppc64_elf_unhandled_reloc, /* special_function */
483 "R_PPC64_GOT16_HI", /* name */
484 FALSE, /* partial_inplace */
485 0, /* src_mask */
486 0xffff, /* dst_mask */
487 FALSE), /* pcrel_offset */
488
489 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
490 the symbol. */
491 HOWTO (R_PPC64_GOT16_HA, /* type */
492 16, /* rightshift */
493 1, /* size (0 = byte, 1 = short, 2 = long) */
494 16, /* bitsize */
495 FALSE, /* pc_relative */
496 0, /* bitpos */
497 complain_overflow_dont,/* complain_on_overflow */
498 ppc64_elf_unhandled_reloc, /* special_function */
499 "R_PPC64_GOT16_HA", /* name */
500 FALSE, /* partial_inplace */
501 0, /* src_mask */
502 0xffff, /* dst_mask */
503 FALSE), /* pcrel_offset */
504
505 /* This is used only by the dynamic linker. The symbol should exist
506 both in the object being run and in some shared library. The
507 dynamic linker copies the data addressed by the symbol from the
508 shared library into the object, because the object being
509 run has to have the data at some particular address. */
510 HOWTO (R_PPC64_COPY, /* type */
511 0, /* rightshift */
512 0, /* this one is variable size */
513 0, /* bitsize */
514 FALSE, /* pc_relative */
515 0, /* bitpos */
516 complain_overflow_dont, /* complain_on_overflow */
517 ppc64_elf_unhandled_reloc, /* special_function */
518 "R_PPC64_COPY", /* name */
519 FALSE, /* partial_inplace */
520 0, /* src_mask */
521 0, /* dst_mask */
522 FALSE), /* pcrel_offset */
523
524 /* Like R_PPC64_ADDR64, but used when setting global offset table
525 entries. */
526 HOWTO (R_PPC64_GLOB_DAT, /* type */
527 0, /* rightshift */
528 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
529 64, /* bitsize */
530 FALSE, /* pc_relative */
531 0, /* bitpos */
532 complain_overflow_dont, /* complain_on_overflow */
533 ppc64_elf_unhandled_reloc, /* special_function */
534 "R_PPC64_GLOB_DAT", /* name */
535 FALSE, /* partial_inplace */
536 0, /* src_mask */
537 ONES (64), /* dst_mask */
538 FALSE), /* pcrel_offset */
539
540 /* Created by the link editor. Marks a procedure linkage table
541 entry for a symbol. */
542 HOWTO (R_PPC64_JMP_SLOT, /* type */
543 0, /* rightshift */
544 0, /* size (0 = byte, 1 = short, 2 = long) */
545 0, /* bitsize */
546 FALSE, /* pc_relative */
547 0, /* bitpos */
548 complain_overflow_dont, /* complain_on_overflow */
549 ppc64_elf_unhandled_reloc, /* special_function */
550 "R_PPC64_JMP_SLOT", /* name */
551 FALSE, /* partial_inplace */
552 0, /* src_mask */
553 0, /* dst_mask */
554 FALSE), /* pcrel_offset */
555
556 /* Used only by the dynamic linker. When the object is run, this
557 doubleword64 is set to the load address of the object, plus the
558 addend. */
559 HOWTO (R_PPC64_RELATIVE, /* type */
560 0, /* rightshift */
561 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
562 64, /* bitsize */
563 FALSE, /* pc_relative */
564 0, /* bitpos */
565 complain_overflow_dont, /* complain_on_overflow */
566 bfd_elf_generic_reloc, /* special_function */
567 "R_PPC64_RELATIVE", /* name */
568 FALSE, /* partial_inplace */
569 0, /* src_mask */
570 ONES (64), /* dst_mask */
571 FALSE), /* pcrel_offset */
572
573 /* Like R_PPC64_ADDR32, but may be unaligned. */
574 HOWTO (R_PPC64_UADDR32, /* type */
575 0, /* rightshift */
576 2, /* size (0 = byte, 1 = short, 2 = long) */
577 32, /* bitsize */
578 FALSE, /* pc_relative */
579 0, /* bitpos */
580 complain_overflow_bitfield, /* complain_on_overflow */
581 bfd_elf_generic_reloc, /* special_function */
582 "R_PPC64_UADDR32", /* name */
583 FALSE, /* partial_inplace */
584 0, /* src_mask */
585 0xffffffff, /* dst_mask */
586 FALSE), /* pcrel_offset */
587
588 /* Like R_PPC64_ADDR16, but may be unaligned. */
589 HOWTO (R_PPC64_UADDR16, /* type */
590 0, /* rightshift */
591 1, /* size (0 = byte, 1 = short, 2 = long) */
592 16, /* bitsize */
593 FALSE, /* pc_relative */
594 0, /* bitpos */
595 complain_overflow_bitfield, /* complain_on_overflow */
596 bfd_elf_generic_reloc, /* special_function */
597 "R_PPC64_UADDR16", /* name */
598 FALSE, /* partial_inplace */
599 0, /* src_mask */
600 0xffff, /* dst_mask */
601 FALSE), /* pcrel_offset */
602
603 /* 32-bit PC relative. */
604 HOWTO (R_PPC64_REL32, /* type */
605 0, /* rightshift */
606 2, /* size (0 = byte, 1 = short, 2 = long) */
607 32, /* bitsize */
608 TRUE, /* pc_relative */
609 0, /* bitpos */
610 /* FIXME: Verify. Was complain_overflow_bitfield. */
611 complain_overflow_signed, /* complain_on_overflow */
612 bfd_elf_generic_reloc, /* special_function */
613 "R_PPC64_REL32", /* name */
614 FALSE, /* partial_inplace */
615 0, /* src_mask */
616 0xffffffff, /* dst_mask */
617 TRUE), /* pcrel_offset */
618
619 /* 32-bit relocation to the symbol's procedure linkage table. */
620 HOWTO (R_PPC64_PLT32, /* type */
621 0, /* rightshift */
622 2, /* size (0 = byte, 1 = short, 2 = long) */
623 32, /* bitsize */
624 FALSE, /* pc_relative */
625 0, /* bitpos */
626 complain_overflow_bitfield, /* complain_on_overflow */
627 ppc64_elf_unhandled_reloc, /* special_function */
628 "R_PPC64_PLT32", /* name */
629 FALSE, /* partial_inplace */
630 0, /* src_mask */
631 0xffffffff, /* dst_mask */
632 FALSE), /* pcrel_offset */
633
634 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
635 FIXME: R_PPC64_PLTREL32 not supported. */
636 HOWTO (R_PPC64_PLTREL32, /* type */
637 0, /* rightshift */
638 2, /* size (0 = byte, 1 = short, 2 = long) */
639 32, /* bitsize */
640 TRUE, /* pc_relative */
641 0, /* bitpos */
642 complain_overflow_signed, /* complain_on_overflow */
643 bfd_elf_generic_reloc, /* special_function */
644 "R_PPC64_PLTREL32", /* name */
645 FALSE, /* partial_inplace */
646 0, /* src_mask */
647 0xffffffff, /* dst_mask */
648 TRUE), /* pcrel_offset */
649
650 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
651 the symbol. */
652 HOWTO (R_PPC64_PLT16_LO, /* type */
653 0, /* rightshift */
654 1, /* size (0 = byte, 1 = short, 2 = long) */
655 16, /* bitsize */
656 FALSE, /* pc_relative */
657 0, /* bitpos */
658 complain_overflow_dont, /* complain_on_overflow */
659 ppc64_elf_unhandled_reloc, /* special_function */
660 "R_PPC64_PLT16_LO", /* name */
661 FALSE, /* partial_inplace */
662 0, /* src_mask */
663 0xffff, /* dst_mask */
664 FALSE), /* pcrel_offset */
665
666 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
667 the symbol. */
668 HOWTO (R_PPC64_PLT16_HI, /* type */
669 16, /* rightshift */
670 1, /* size (0 = byte, 1 = short, 2 = long) */
671 16, /* bitsize */
672 FALSE, /* pc_relative */
673 0, /* bitpos */
674 complain_overflow_dont, /* complain_on_overflow */
675 ppc64_elf_unhandled_reloc, /* special_function */
676 "R_PPC64_PLT16_HI", /* name */
677 FALSE, /* partial_inplace */
678 0, /* src_mask */
679 0xffff, /* dst_mask */
680 FALSE), /* pcrel_offset */
681
682 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
683 the symbol. */
684 HOWTO (R_PPC64_PLT16_HA, /* type */
685 16, /* rightshift */
686 1, /* size (0 = byte, 1 = short, 2 = long) */
687 16, /* bitsize */
688 FALSE, /* pc_relative */
689 0, /* bitpos */
690 complain_overflow_dont, /* complain_on_overflow */
691 ppc64_elf_unhandled_reloc, /* special_function */
692 "R_PPC64_PLT16_HA", /* name */
693 FALSE, /* partial_inplace */
694 0, /* src_mask */
695 0xffff, /* dst_mask */
696 FALSE), /* pcrel_offset */
697
698 /* 16-bit section relative relocation. */
699 HOWTO (R_PPC64_SECTOFF, /* type */
700 0, /* rightshift */
701 1, /* size (0 = byte, 1 = short, 2 = long) */
702 16, /* bitsize */
703 FALSE, /* pc_relative */
704 0, /* bitpos */
705 complain_overflow_bitfield, /* complain_on_overflow */
706 ppc64_elf_sectoff_reloc, /* special_function */
707 "R_PPC64_SECTOFF", /* name */
708 FALSE, /* partial_inplace */
709 0, /* src_mask */
710 0xffff, /* dst_mask */
711 FALSE), /* pcrel_offset */
712
713 /* Like R_PPC64_SECTOFF, but no overflow warning. */
714 HOWTO (R_PPC64_SECTOFF_LO, /* type */
715 0, /* rightshift */
716 1, /* size (0 = byte, 1 = short, 2 = long) */
717 16, /* bitsize */
718 FALSE, /* pc_relative */
719 0, /* bitpos */
720 complain_overflow_dont, /* complain_on_overflow */
721 ppc64_elf_sectoff_reloc, /* special_function */
722 "R_PPC64_SECTOFF_LO", /* name */
723 FALSE, /* partial_inplace */
724 0, /* src_mask */
725 0xffff, /* dst_mask */
726 FALSE), /* pcrel_offset */
727
728 /* 16-bit upper half section relative relocation. */
729 HOWTO (R_PPC64_SECTOFF_HI, /* type */
730 16, /* rightshift */
731 1, /* size (0 = byte, 1 = short, 2 = long) */
732 16, /* bitsize */
733 FALSE, /* pc_relative */
734 0, /* bitpos */
735 complain_overflow_dont, /* complain_on_overflow */
736 ppc64_elf_sectoff_reloc, /* special_function */
737 "R_PPC64_SECTOFF_HI", /* name */
738 FALSE, /* partial_inplace */
739 0, /* src_mask */
740 0xffff, /* dst_mask */
741 FALSE), /* pcrel_offset */
742
743 /* 16-bit upper half adjusted section relative relocation. */
744 HOWTO (R_PPC64_SECTOFF_HA, /* type */
745 16, /* rightshift */
746 1, /* size (0 = byte, 1 = short, 2 = long) */
747 16, /* bitsize */
748 FALSE, /* pc_relative */
749 0, /* bitpos */
750 complain_overflow_dont, /* complain_on_overflow */
751 ppc64_elf_sectoff_ha_reloc, /* special_function */
752 "R_PPC64_SECTOFF_HA", /* name */
753 FALSE, /* partial_inplace */
754 0, /* src_mask */
755 0xffff, /* dst_mask */
756 FALSE), /* pcrel_offset */
757
758 /* Like R_PPC64_REL24 without touching the two least significant bits. */
759 HOWTO (R_PPC64_REL30, /* type */
760 2, /* rightshift */
761 2, /* size (0 = byte, 1 = short, 2 = long) */
762 30, /* bitsize */
763 TRUE, /* pc_relative */
764 0, /* bitpos */
765 complain_overflow_dont, /* complain_on_overflow */
766 bfd_elf_generic_reloc, /* special_function */
767 "R_PPC64_REL30", /* name */
768 FALSE, /* partial_inplace */
769 0, /* src_mask */
770 0xfffffffc, /* dst_mask */
771 TRUE), /* pcrel_offset */
772
773 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
774
775 /* A standard 64-bit relocation. */
776 HOWTO (R_PPC64_ADDR64, /* type */
777 0, /* rightshift */
778 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
779 64, /* bitsize */
780 FALSE, /* pc_relative */
781 0, /* bitpos */
782 complain_overflow_dont, /* complain_on_overflow */
783 bfd_elf_generic_reloc, /* special_function */
784 "R_PPC64_ADDR64", /* name */
785 FALSE, /* partial_inplace */
786 0, /* src_mask */
787 ONES (64), /* dst_mask */
788 FALSE), /* pcrel_offset */
789
790 /* The bits 32-47 of an address. */
791 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
792 32, /* rightshift */
793 1, /* size (0 = byte, 1 = short, 2 = long) */
794 16, /* bitsize */
795 FALSE, /* pc_relative */
796 0, /* bitpos */
797 complain_overflow_dont, /* complain_on_overflow */
798 bfd_elf_generic_reloc, /* special_function */
799 "R_PPC64_ADDR16_HIGHER", /* name */
800 FALSE, /* partial_inplace */
801 0, /* src_mask */
802 0xffff, /* dst_mask */
803 FALSE), /* pcrel_offset */
804
805 /* The bits 32-47 of an address, plus 1 if the contents of the low
806 16 bits, treated as a signed number, is negative. */
807 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
808 32, /* rightshift */
809 1, /* size (0 = byte, 1 = short, 2 = long) */
810 16, /* bitsize */
811 FALSE, /* pc_relative */
812 0, /* bitpos */
813 complain_overflow_dont, /* complain_on_overflow */
814 ppc64_elf_ha_reloc, /* special_function */
815 "R_PPC64_ADDR16_HIGHERA", /* name */
816 FALSE, /* partial_inplace */
817 0, /* src_mask */
818 0xffff, /* dst_mask */
819 FALSE), /* pcrel_offset */
820
821 /* The bits 48-63 of an address. */
822 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
823 48, /* rightshift */
824 1, /* size (0 = byte, 1 = short, 2 = long) */
825 16, /* bitsize */
826 FALSE, /* pc_relative */
827 0, /* bitpos */
828 complain_overflow_dont, /* complain_on_overflow */
829 bfd_elf_generic_reloc, /* special_function */
830 "R_PPC64_ADDR16_HIGHEST", /* name */
831 FALSE, /* partial_inplace */
832 0, /* src_mask */
833 0xffff, /* dst_mask */
834 FALSE), /* pcrel_offset */
835
836 /* The bits 48-63 of an address, plus 1 if the contents of the low
837 16 bits, treated as a signed number, is negative. */
838 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
839 48, /* rightshift */
840 1, /* size (0 = byte, 1 = short, 2 = long) */
841 16, /* bitsize */
842 FALSE, /* pc_relative */
843 0, /* bitpos */
844 complain_overflow_dont, /* complain_on_overflow */
845 ppc64_elf_ha_reloc, /* special_function */
846 "R_PPC64_ADDR16_HIGHESTA", /* name */
847 FALSE, /* partial_inplace */
848 0, /* src_mask */
849 0xffff, /* dst_mask */
850 FALSE), /* pcrel_offset */
851
852 /* Like ADDR64, but may be unaligned. */
853 HOWTO (R_PPC64_UADDR64, /* type */
854 0, /* rightshift */
855 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
856 64, /* bitsize */
857 FALSE, /* pc_relative */
858 0, /* bitpos */
859 complain_overflow_dont, /* complain_on_overflow */
860 bfd_elf_generic_reloc, /* special_function */
861 "R_PPC64_UADDR64", /* name */
862 FALSE, /* partial_inplace */
863 0, /* src_mask */
864 ONES (64), /* dst_mask */
865 FALSE), /* pcrel_offset */
866
867 /* 64-bit relative relocation. */
868 HOWTO (R_PPC64_REL64, /* type */
869 0, /* rightshift */
870 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
871 64, /* bitsize */
872 TRUE, /* pc_relative */
873 0, /* bitpos */
874 complain_overflow_dont, /* complain_on_overflow */
875 bfd_elf_generic_reloc, /* special_function */
876 "R_PPC64_REL64", /* name */
877 FALSE, /* partial_inplace */
878 0, /* src_mask */
879 ONES (64), /* dst_mask */
880 TRUE), /* pcrel_offset */
881
882 /* 64-bit relocation to the symbol's procedure linkage table. */
883 HOWTO (R_PPC64_PLT64, /* type */
884 0, /* rightshift */
885 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
886 64, /* bitsize */
887 FALSE, /* pc_relative */
888 0, /* bitpos */
889 complain_overflow_dont, /* complain_on_overflow */
890 ppc64_elf_unhandled_reloc, /* special_function */
891 "R_PPC64_PLT64", /* name */
892 FALSE, /* partial_inplace */
893 0, /* src_mask */
894 ONES (64), /* dst_mask */
895 FALSE), /* pcrel_offset */
896
897 /* 64-bit PC relative relocation to the symbol's procedure linkage
898 table. */
899 /* FIXME: R_PPC64_PLTREL64 not supported. */
900 HOWTO (R_PPC64_PLTREL64, /* type */
901 0, /* rightshift */
902 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
903 64, /* bitsize */
904 TRUE, /* pc_relative */
905 0, /* bitpos */
906 complain_overflow_dont, /* complain_on_overflow */
907 ppc64_elf_unhandled_reloc, /* special_function */
908 "R_PPC64_PLTREL64", /* name */
909 FALSE, /* partial_inplace */
910 0, /* src_mask */
911 ONES (64), /* dst_mask */
912 TRUE), /* pcrel_offset */
913
914 /* 16 bit TOC-relative relocation. */
915
916 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
917 HOWTO (R_PPC64_TOC16, /* type */
918 0, /* rightshift */
919 1, /* size (0 = byte, 1 = short, 2 = long) */
920 16, /* bitsize */
921 FALSE, /* pc_relative */
922 0, /* bitpos */
923 complain_overflow_signed, /* complain_on_overflow */
924 ppc64_elf_toc_reloc, /* special_function */
925 "R_PPC64_TOC16", /* name */
926 FALSE, /* partial_inplace */
927 0, /* src_mask */
928 0xffff, /* dst_mask */
929 FALSE), /* pcrel_offset */
930
931 /* 16 bit TOC-relative relocation without overflow. */
932
933 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
934 HOWTO (R_PPC64_TOC16_LO, /* type */
935 0, /* rightshift */
936 1, /* size (0 = byte, 1 = short, 2 = long) */
937 16, /* bitsize */
938 FALSE, /* pc_relative */
939 0, /* bitpos */
940 complain_overflow_dont, /* complain_on_overflow */
941 ppc64_elf_toc_reloc, /* special_function */
942 "R_PPC64_TOC16_LO", /* name */
943 FALSE, /* partial_inplace */
944 0, /* src_mask */
945 0xffff, /* dst_mask */
946 FALSE), /* pcrel_offset */
947
948 /* 16 bit TOC-relative relocation, high 16 bits. */
949
950 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
951 HOWTO (R_PPC64_TOC16_HI, /* type */
952 16, /* rightshift */
953 1, /* size (0 = byte, 1 = short, 2 = long) */
954 16, /* bitsize */
955 FALSE, /* pc_relative */
956 0, /* bitpos */
957 complain_overflow_dont, /* complain_on_overflow */
958 ppc64_elf_toc_reloc, /* special_function */
959 "R_PPC64_TOC16_HI", /* name */
960 FALSE, /* partial_inplace */
961 0, /* src_mask */
962 0xffff, /* dst_mask */
963 FALSE), /* pcrel_offset */
964
965 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
966 contents of the low 16 bits, treated as a signed number, is
967 negative. */
968
969 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
970 HOWTO (R_PPC64_TOC16_HA, /* type */
971 16, /* rightshift */
972 1, /* size (0 = byte, 1 = short, 2 = long) */
973 16, /* bitsize */
974 FALSE, /* pc_relative */
975 0, /* bitpos */
976 complain_overflow_dont, /* complain_on_overflow */
977 ppc64_elf_toc_ha_reloc, /* special_function */
978 "R_PPC64_TOC16_HA", /* name */
979 FALSE, /* partial_inplace */
980 0, /* src_mask */
981 0xffff, /* dst_mask */
982 FALSE), /* pcrel_offset */
983
984 /* 64-bit relocation; insert value of TOC base (.TOC.). */
985
986 /* R_PPC64_TOC 51 doubleword64 .TOC. */
987 HOWTO (R_PPC64_TOC, /* type */
988 0, /* rightshift */
989 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
990 64, /* bitsize */
991 FALSE, /* pc_relative */
992 0, /* bitpos */
993 complain_overflow_bitfield, /* complain_on_overflow */
994 ppc64_elf_toc64_reloc, /* special_function */
995 "R_PPC64_TOC", /* name */
996 FALSE, /* partial_inplace */
997 0, /* src_mask */
998 ONES (64), /* dst_mask */
999 FALSE), /* pcrel_offset */
1000
1001 /* Like R_PPC64_GOT16, but also informs the link editor that the
1002 value to relocate may (!) refer to a PLT entry which the link
1003 editor (a) may replace with the symbol value. If the link editor
1004 is unable to fully resolve the symbol, it may (b) create a PLT
1005 entry and store the address to the new PLT entry in the GOT.
1006 This permits lazy resolution of function symbols at run time.
1007 The link editor may also skip all of this and just (c) emit a
1008 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1009 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1010 HOWTO (R_PPC64_PLTGOT16, /* type */
1011 0, /* rightshift */
1012 1, /* size (0 = byte, 1 = short, 2 = long) */
1013 16, /* bitsize */
1014 FALSE, /* pc_relative */
1015 0, /* bitpos */
1016 complain_overflow_signed, /* complain_on_overflow */
1017 ppc64_elf_unhandled_reloc, /* special_function */
1018 "R_PPC64_PLTGOT16", /* name */
1019 FALSE, /* partial_inplace */
1020 0, /* src_mask */
1021 0xffff, /* dst_mask */
1022 FALSE), /* pcrel_offset */
1023
1024 /* Like R_PPC64_PLTGOT16, but without overflow. */
1025 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1026 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1027 0, /* rightshift */
1028 1, /* size (0 = byte, 1 = short, 2 = long) */
1029 16, /* bitsize */
1030 FALSE, /* pc_relative */
1031 0, /* bitpos */
1032 complain_overflow_dont, /* complain_on_overflow */
1033 ppc64_elf_unhandled_reloc, /* special_function */
1034 "R_PPC64_PLTGOT16_LO", /* name */
1035 FALSE, /* partial_inplace */
1036 0, /* src_mask */
1037 0xffff, /* dst_mask */
1038 FALSE), /* pcrel_offset */
1039
1040 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1041 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1042 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1043 16, /* rightshift */
1044 1, /* size (0 = byte, 1 = short, 2 = long) */
1045 16, /* bitsize */
1046 FALSE, /* pc_relative */
1047 0, /* bitpos */
1048 complain_overflow_dont, /* complain_on_overflow */
1049 ppc64_elf_unhandled_reloc, /* special_function */
1050 "R_PPC64_PLTGOT16_HI", /* name */
1051 FALSE, /* partial_inplace */
1052 0, /* src_mask */
1053 0xffff, /* dst_mask */
1054 FALSE), /* pcrel_offset */
1055
1056 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1057 1 if the contents of the low 16 bits, treated as a signed number,
1058 is negative. */
1059 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1060 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1061 16, /* rightshift */
1062 1, /* size (0 = byte, 1 = short, 2 = long) */
1063 16, /* bitsize */
1064 FALSE, /* pc_relative */
1065 0, /* bitpos */
1066 complain_overflow_dont,/* complain_on_overflow */
1067 ppc64_elf_unhandled_reloc, /* special_function */
1068 "R_PPC64_PLTGOT16_HA", /* name */
1069 FALSE, /* partial_inplace */
1070 0, /* src_mask */
1071 0xffff, /* dst_mask */
1072 FALSE), /* pcrel_offset */
1073
1074 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1075 HOWTO (R_PPC64_ADDR16_DS, /* type */
1076 0, /* rightshift */
1077 1, /* size (0 = byte, 1 = short, 2 = long) */
1078 16, /* bitsize */
1079 FALSE, /* pc_relative */
1080 0, /* bitpos */
1081 complain_overflow_bitfield, /* complain_on_overflow */
1082 bfd_elf_generic_reloc, /* special_function */
1083 "R_PPC64_ADDR16_DS", /* name */
1084 FALSE, /* partial_inplace */
1085 0, /* src_mask */
1086 0xfffc, /* dst_mask */
1087 FALSE), /* pcrel_offset */
1088
1089 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1090 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1091 0, /* rightshift */
1092 1, /* size (0 = byte, 1 = short, 2 = long) */
1093 16, /* bitsize */
1094 FALSE, /* pc_relative */
1095 0, /* bitpos */
1096 complain_overflow_dont,/* complain_on_overflow */
1097 bfd_elf_generic_reloc, /* special_function */
1098 "R_PPC64_ADDR16_LO_DS",/* name */
1099 FALSE, /* partial_inplace */
1100 0, /* src_mask */
1101 0xfffc, /* dst_mask */
1102 FALSE), /* pcrel_offset */
1103
1104 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1105 HOWTO (R_PPC64_GOT16_DS, /* type */
1106 0, /* rightshift */
1107 1, /* size (0 = byte, 1 = short, 2 = long) */
1108 16, /* bitsize */
1109 FALSE, /* pc_relative */
1110 0, /* bitpos */
1111 complain_overflow_signed, /* complain_on_overflow */
1112 ppc64_elf_unhandled_reloc, /* special_function */
1113 "R_PPC64_GOT16_DS", /* name */
1114 FALSE, /* partial_inplace */
1115 0, /* src_mask */
1116 0xfffc, /* dst_mask */
1117 FALSE), /* pcrel_offset */
1118
1119 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1120 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1121 0, /* rightshift */
1122 1, /* size (0 = byte, 1 = short, 2 = long) */
1123 16, /* bitsize */
1124 FALSE, /* pc_relative */
1125 0, /* bitpos */
1126 complain_overflow_dont, /* complain_on_overflow */
1127 ppc64_elf_unhandled_reloc, /* special_function */
1128 "R_PPC64_GOT16_LO_DS", /* name */
1129 FALSE, /* partial_inplace */
1130 0, /* src_mask */
1131 0xfffc, /* dst_mask */
1132 FALSE), /* pcrel_offset */
1133
1134 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1135 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1136 0, /* rightshift */
1137 1, /* size (0 = byte, 1 = short, 2 = long) */
1138 16, /* bitsize */
1139 FALSE, /* pc_relative */
1140 0, /* bitpos */
1141 complain_overflow_dont, /* complain_on_overflow */
1142 ppc64_elf_unhandled_reloc, /* special_function */
1143 "R_PPC64_PLT16_LO_DS", /* name */
1144 FALSE, /* partial_inplace */
1145 0, /* src_mask */
1146 0xfffc, /* dst_mask */
1147 FALSE), /* pcrel_offset */
1148
1149 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1150 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1151 0, /* rightshift */
1152 1, /* size (0 = byte, 1 = short, 2 = long) */
1153 16, /* bitsize */
1154 FALSE, /* pc_relative */
1155 0, /* bitpos */
1156 complain_overflow_bitfield, /* complain_on_overflow */
1157 ppc64_elf_sectoff_reloc, /* special_function */
1158 "R_PPC64_SECTOFF_DS", /* name */
1159 FALSE, /* partial_inplace */
1160 0, /* src_mask */
1161 0xfffc, /* dst_mask */
1162 FALSE), /* pcrel_offset */
1163
1164 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1165 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1166 0, /* rightshift */
1167 1, /* size (0 = byte, 1 = short, 2 = long) */
1168 16, /* bitsize */
1169 FALSE, /* pc_relative */
1170 0, /* bitpos */
1171 complain_overflow_dont, /* complain_on_overflow */
1172 ppc64_elf_sectoff_reloc, /* special_function */
1173 "R_PPC64_SECTOFF_LO_DS",/* name */
1174 FALSE, /* partial_inplace */
1175 0, /* src_mask */
1176 0xfffc, /* dst_mask */
1177 FALSE), /* pcrel_offset */
1178
1179 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1180 HOWTO (R_PPC64_TOC16_DS, /* type */
1181 0, /* rightshift */
1182 1, /* size (0 = byte, 1 = short, 2 = long) */
1183 16, /* bitsize */
1184 FALSE, /* pc_relative */
1185 0, /* bitpos */
1186 complain_overflow_signed, /* complain_on_overflow */
1187 ppc64_elf_toc_reloc, /* special_function */
1188 "R_PPC64_TOC16_DS", /* name */
1189 FALSE, /* partial_inplace */
1190 0, /* src_mask */
1191 0xfffc, /* dst_mask */
1192 FALSE), /* pcrel_offset */
1193
1194 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1195 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1196 0, /* rightshift */
1197 1, /* size (0 = byte, 1 = short, 2 = long) */
1198 16, /* bitsize */
1199 FALSE, /* pc_relative */
1200 0, /* bitpos */
1201 complain_overflow_dont, /* complain_on_overflow */
1202 ppc64_elf_toc_reloc, /* special_function */
1203 "R_PPC64_TOC16_LO_DS", /* name */
1204 FALSE, /* partial_inplace */
1205 0, /* src_mask */
1206 0xfffc, /* dst_mask */
1207 FALSE), /* pcrel_offset */
1208
1209 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1210 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1211 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1212 0, /* rightshift */
1213 1, /* size (0 = byte, 1 = short, 2 = long) */
1214 16, /* bitsize */
1215 FALSE, /* pc_relative */
1216 0, /* bitpos */
1217 complain_overflow_signed, /* complain_on_overflow */
1218 ppc64_elf_unhandled_reloc, /* special_function */
1219 "R_PPC64_PLTGOT16_DS", /* name */
1220 FALSE, /* partial_inplace */
1221 0, /* src_mask */
1222 0xfffc, /* dst_mask */
1223 FALSE), /* pcrel_offset */
1224
1225 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1226 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1227 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1228 0, /* rightshift */
1229 1, /* size (0 = byte, 1 = short, 2 = long) */
1230 16, /* bitsize */
1231 FALSE, /* pc_relative */
1232 0, /* bitpos */
1233 complain_overflow_dont, /* complain_on_overflow */
1234 ppc64_elf_unhandled_reloc, /* special_function */
1235 "R_PPC64_PLTGOT16_LO_DS",/* name */
1236 FALSE, /* partial_inplace */
1237 0, /* src_mask */
1238 0xfffc, /* dst_mask */
1239 FALSE), /* pcrel_offset */
1240
1241 /* Marker relocs for TLS. */
1242 HOWTO (R_PPC64_TLS,
1243 0, /* rightshift */
1244 2, /* size (0 = byte, 1 = short, 2 = long) */
1245 32, /* bitsize */
1246 FALSE, /* pc_relative */
1247 0, /* bitpos */
1248 complain_overflow_dont, /* complain_on_overflow */
1249 bfd_elf_generic_reloc, /* special_function */
1250 "R_PPC64_TLS", /* name */
1251 FALSE, /* partial_inplace */
1252 0, /* src_mask */
1253 0, /* dst_mask */
1254 FALSE), /* pcrel_offset */
1255
1256 HOWTO (R_PPC64_TLSGD,
1257 0, /* rightshift */
1258 2, /* size (0 = byte, 1 = short, 2 = long) */
1259 32, /* bitsize */
1260 FALSE, /* pc_relative */
1261 0, /* bitpos */
1262 complain_overflow_dont, /* complain_on_overflow */
1263 bfd_elf_generic_reloc, /* special_function */
1264 "R_PPC64_TLSGD", /* name */
1265 FALSE, /* partial_inplace */
1266 0, /* src_mask */
1267 0, /* dst_mask */
1268 FALSE), /* pcrel_offset */
1269
1270 HOWTO (R_PPC64_TLSLD,
1271 0, /* rightshift */
1272 2, /* size (0 = byte, 1 = short, 2 = long) */
1273 32, /* bitsize */
1274 FALSE, /* pc_relative */
1275 0, /* bitpos */
1276 complain_overflow_dont, /* complain_on_overflow */
1277 bfd_elf_generic_reloc, /* special_function */
1278 "R_PPC64_TLSLD", /* name */
1279 FALSE, /* partial_inplace */
1280 0, /* src_mask */
1281 0, /* dst_mask */
1282 FALSE), /* pcrel_offset */
1283
1284 /* Computes the load module index of the load module that contains the
1285 definition of its TLS sym. */
1286 HOWTO (R_PPC64_DTPMOD64,
1287 0, /* rightshift */
1288 4, /* size (0 = byte, 1 = short, 2 = long) */
1289 64, /* bitsize */
1290 FALSE, /* pc_relative */
1291 0, /* bitpos */
1292 complain_overflow_dont, /* complain_on_overflow */
1293 ppc64_elf_unhandled_reloc, /* special_function */
1294 "R_PPC64_DTPMOD64", /* name */
1295 FALSE, /* partial_inplace */
1296 0, /* src_mask */
1297 ONES (64), /* dst_mask */
1298 FALSE), /* pcrel_offset */
1299
1300 /* Computes a dtv-relative displacement, the difference between the value
1301 of sym+add and the base address of the thread-local storage block that
1302 contains the definition of sym, minus 0x8000. */
1303 HOWTO (R_PPC64_DTPREL64,
1304 0, /* rightshift */
1305 4, /* size (0 = byte, 1 = short, 2 = long) */
1306 64, /* bitsize */
1307 FALSE, /* pc_relative */
1308 0, /* bitpos */
1309 complain_overflow_dont, /* complain_on_overflow */
1310 ppc64_elf_unhandled_reloc, /* special_function */
1311 "R_PPC64_DTPREL64", /* name */
1312 FALSE, /* partial_inplace */
1313 0, /* src_mask */
1314 ONES (64), /* dst_mask */
1315 FALSE), /* pcrel_offset */
1316
1317 /* A 16 bit dtprel reloc. */
1318 HOWTO (R_PPC64_DTPREL16,
1319 0, /* rightshift */
1320 1, /* size (0 = byte, 1 = short, 2 = long) */
1321 16, /* bitsize */
1322 FALSE, /* pc_relative */
1323 0, /* bitpos */
1324 complain_overflow_signed, /* complain_on_overflow */
1325 ppc64_elf_unhandled_reloc, /* special_function */
1326 "R_PPC64_DTPREL16", /* name */
1327 FALSE, /* partial_inplace */
1328 0, /* src_mask */
1329 0xffff, /* dst_mask */
1330 FALSE), /* pcrel_offset */
1331
1332 /* Like DTPREL16, but no overflow. */
1333 HOWTO (R_PPC64_DTPREL16_LO,
1334 0, /* rightshift */
1335 1, /* size (0 = byte, 1 = short, 2 = long) */
1336 16, /* bitsize */
1337 FALSE, /* pc_relative */
1338 0, /* bitpos */
1339 complain_overflow_dont, /* complain_on_overflow */
1340 ppc64_elf_unhandled_reloc, /* special_function */
1341 "R_PPC64_DTPREL16_LO", /* name */
1342 FALSE, /* partial_inplace */
1343 0, /* src_mask */
1344 0xffff, /* dst_mask */
1345 FALSE), /* pcrel_offset */
1346
1347 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1348 HOWTO (R_PPC64_DTPREL16_HI,
1349 16, /* rightshift */
1350 1, /* size (0 = byte, 1 = short, 2 = long) */
1351 16, /* bitsize */
1352 FALSE, /* pc_relative */
1353 0, /* bitpos */
1354 complain_overflow_dont, /* complain_on_overflow */
1355 ppc64_elf_unhandled_reloc, /* special_function */
1356 "R_PPC64_DTPREL16_HI", /* name */
1357 FALSE, /* partial_inplace */
1358 0, /* src_mask */
1359 0xffff, /* dst_mask */
1360 FALSE), /* pcrel_offset */
1361
1362 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1363 HOWTO (R_PPC64_DTPREL16_HA,
1364 16, /* rightshift */
1365 1, /* size (0 = byte, 1 = short, 2 = long) */
1366 16, /* bitsize */
1367 FALSE, /* pc_relative */
1368 0, /* bitpos */
1369 complain_overflow_dont, /* complain_on_overflow */
1370 ppc64_elf_unhandled_reloc, /* special_function */
1371 "R_PPC64_DTPREL16_HA", /* name */
1372 FALSE, /* partial_inplace */
1373 0, /* src_mask */
1374 0xffff, /* dst_mask */
1375 FALSE), /* pcrel_offset */
1376
1377 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1378 HOWTO (R_PPC64_DTPREL16_HIGHER,
1379 32, /* rightshift */
1380 1, /* size (0 = byte, 1 = short, 2 = long) */
1381 16, /* bitsize */
1382 FALSE, /* pc_relative */
1383 0, /* bitpos */
1384 complain_overflow_dont, /* complain_on_overflow */
1385 ppc64_elf_unhandled_reloc, /* special_function */
1386 "R_PPC64_DTPREL16_HIGHER", /* name */
1387 FALSE, /* partial_inplace */
1388 0, /* src_mask */
1389 0xffff, /* dst_mask */
1390 FALSE), /* pcrel_offset */
1391
1392 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1393 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1394 32, /* rightshift */
1395 1, /* size (0 = byte, 1 = short, 2 = long) */
1396 16, /* bitsize */
1397 FALSE, /* pc_relative */
1398 0, /* bitpos */
1399 complain_overflow_dont, /* complain_on_overflow */
1400 ppc64_elf_unhandled_reloc, /* special_function */
1401 "R_PPC64_DTPREL16_HIGHERA", /* name */
1402 FALSE, /* partial_inplace */
1403 0, /* src_mask */
1404 0xffff, /* dst_mask */
1405 FALSE), /* pcrel_offset */
1406
1407 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1408 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1409 48, /* rightshift */
1410 1, /* size (0 = byte, 1 = short, 2 = long) */
1411 16, /* bitsize */
1412 FALSE, /* pc_relative */
1413 0, /* bitpos */
1414 complain_overflow_dont, /* complain_on_overflow */
1415 ppc64_elf_unhandled_reloc, /* special_function */
1416 "R_PPC64_DTPREL16_HIGHEST", /* name */
1417 FALSE, /* partial_inplace */
1418 0, /* src_mask */
1419 0xffff, /* dst_mask */
1420 FALSE), /* pcrel_offset */
1421
1422 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1423 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1424 48, /* rightshift */
1425 1, /* size (0 = byte, 1 = short, 2 = long) */
1426 16, /* bitsize */
1427 FALSE, /* pc_relative */
1428 0, /* bitpos */
1429 complain_overflow_dont, /* complain_on_overflow */
1430 ppc64_elf_unhandled_reloc, /* special_function */
1431 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1432 FALSE, /* partial_inplace */
1433 0, /* src_mask */
1434 0xffff, /* dst_mask */
1435 FALSE), /* pcrel_offset */
1436
1437 /* Like DTPREL16, but for insns with a DS field. */
1438 HOWTO (R_PPC64_DTPREL16_DS,
1439 0, /* rightshift */
1440 1, /* size (0 = byte, 1 = short, 2 = long) */
1441 16, /* bitsize */
1442 FALSE, /* pc_relative */
1443 0, /* bitpos */
1444 complain_overflow_signed, /* complain_on_overflow */
1445 ppc64_elf_unhandled_reloc, /* special_function */
1446 "R_PPC64_DTPREL16_DS", /* name */
1447 FALSE, /* partial_inplace */
1448 0, /* src_mask */
1449 0xfffc, /* dst_mask */
1450 FALSE), /* pcrel_offset */
1451
1452 /* Like DTPREL16_DS, but no overflow. */
1453 HOWTO (R_PPC64_DTPREL16_LO_DS,
1454 0, /* rightshift */
1455 1, /* size (0 = byte, 1 = short, 2 = long) */
1456 16, /* bitsize */
1457 FALSE, /* pc_relative */
1458 0, /* bitpos */
1459 complain_overflow_dont, /* complain_on_overflow */
1460 ppc64_elf_unhandled_reloc, /* special_function */
1461 "R_PPC64_DTPREL16_LO_DS", /* name */
1462 FALSE, /* partial_inplace */
1463 0, /* src_mask */
1464 0xfffc, /* dst_mask */
1465 FALSE), /* pcrel_offset */
1466
1467 /* Computes a tp-relative displacement, the difference between the value of
1468 sym+add and the value of the thread pointer (r13). */
1469 HOWTO (R_PPC64_TPREL64,
1470 0, /* rightshift */
1471 4, /* size (0 = byte, 1 = short, 2 = long) */
1472 64, /* bitsize */
1473 FALSE, /* pc_relative */
1474 0, /* bitpos */
1475 complain_overflow_dont, /* complain_on_overflow */
1476 ppc64_elf_unhandled_reloc, /* special_function */
1477 "R_PPC64_TPREL64", /* name */
1478 FALSE, /* partial_inplace */
1479 0, /* src_mask */
1480 ONES (64), /* dst_mask */
1481 FALSE), /* pcrel_offset */
1482
1483 /* A 16 bit tprel reloc. */
1484 HOWTO (R_PPC64_TPREL16,
1485 0, /* rightshift */
1486 1, /* size (0 = byte, 1 = short, 2 = long) */
1487 16, /* bitsize */
1488 FALSE, /* pc_relative */
1489 0, /* bitpos */
1490 complain_overflow_signed, /* complain_on_overflow */
1491 ppc64_elf_unhandled_reloc, /* special_function */
1492 "R_PPC64_TPREL16", /* name */
1493 FALSE, /* partial_inplace */
1494 0, /* src_mask */
1495 0xffff, /* dst_mask */
1496 FALSE), /* pcrel_offset */
1497
1498 /* Like TPREL16, but no overflow. */
1499 HOWTO (R_PPC64_TPREL16_LO,
1500 0, /* rightshift */
1501 1, /* size (0 = byte, 1 = short, 2 = long) */
1502 16, /* bitsize */
1503 FALSE, /* pc_relative */
1504 0, /* bitpos */
1505 complain_overflow_dont, /* complain_on_overflow */
1506 ppc64_elf_unhandled_reloc, /* special_function */
1507 "R_PPC64_TPREL16_LO", /* name */
1508 FALSE, /* partial_inplace */
1509 0, /* src_mask */
1510 0xffff, /* dst_mask */
1511 FALSE), /* pcrel_offset */
1512
1513 /* Like TPREL16_LO, but next higher group of 16 bits. */
1514 HOWTO (R_PPC64_TPREL16_HI,
1515 16, /* rightshift */
1516 1, /* size (0 = byte, 1 = short, 2 = long) */
1517 16, /* bitsize */
1518 FALSE, /* pc_relative */
1519 0, /* bitpos */
1520 complain_overflow_dont, /* complain_on_overflow */
1521 ppc64_elf_unhandled_reloc, /* special_function */
1522 "R_PPC64_TPREL16_HI", /* name */
1523 FALSE, /* partial_inplace */
1524 0, /* src_mask */
1525 0xffff, /* dst_mask */
1526 FALSE), /* pcrel_offset */
1527
1528 /* Like TPREL16_HI, but adjust for low 16 bits. */
1529 HOWTO (R_PPC64_TPREL16_HA,
1530 16, /* rightshift */
1531 1, /* size (0 = byte, 1 = short, 2 = long) */
1532 16, /* bitsize */
1533 FALSE, /* pc_relative */
1534 0, /* bitpos */
1535 complain_overflow_dont, /* complain_on_overflow */
1536 ppc64_elf_unhandled_reloc, /* special_function */
1537 "R_PPC64_TPREL16_HA", /* name */
1538 FALSE, /* partial_inplace */
1539 0, /* src_mask */
1540 0xffff, /* dst_mask */
1541 FALSE), /* pcrel_offset */
1542
1543 /* Like TPREL16_HI, but next higher group of 16 bits. */
1544 HOWTO (R_PPC64_TPREL16_HIGHER,
1545 32, /* rightshift */
1546 1, /* size (0 = byte, 1 = short, 2 = long) */
1547 16, /* bitsize */
1548 FALSE, /* pc_relative */
1549 0, /* bitpos */
1550 complain_overflow_dont, /* complain_on_overflow */
1551 ppc64_elf_unhandled_reloc, /* special_function */
1552 "R_PPC64_TPREL16_HIGHER", /* name */
1553 FALSE, /* partial_inplace */
1554 0, /* src_mask */
1555 0xffff, /* dst_mask */
1556 FALSE), /* pcrel_offset */
1557
1558 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1559 HOWTO (R_PPC64_TPREL16_HIGHERA,
1560 32, /* rightshift */
1561 1, /* size (0 = byte, 1 = short, 2 = long) */
1562 16, /* bitsize */
1563 FALSE, /* pc_relative */
1564 0, /* bitpos */
1565 complain_overflow_dont, /* complain_on_overflow */
1566 ppc64_elf_unhandled_reloc, /* special_function */
1567 "R_PPC64_TPREL16_HIGHERA", /* name */
1568 FALSE, /* partial_inplace */
1569 0, /* src_mask */
1570 0xffff, /* dst_mask */
1571 FALSE), /* pcrel_offset */
1572
1573 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1574 HOWTO (R_PPC64_TPREL16_HIGHEST,
1575 48, /* rightshift */
1576 1, /* size (0 = byte, 1 = short, 2 = long) */
1577 16, /* bitsize */
1578 FALSE, /* pc_relative */
1579 0, /* bitpos */
1580 complain_overflow_dont, /* complain_on_overflow */
1581 ppc64_elf_unhandled_reloc, /* special_function */
1582 "R_PPC64_TPREL16_HIGHEST", /* name */
1583 FALSE, /* partial_inplace */
1584 0, /* src_mask */
1585 0xffff, /* dst_mask */
1586 FALSE), /* pcrel_offset */
1587
1588 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1589 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1590 48, /* rightshift */
1591 1, /* size (0 = byte, 1 = short, 2 = long) */
1592 16, /* bitsize */
1593 FALSE, /* pc_relative */
1594 0, /* bitpos */
1595 complain_overflow_dont, /* complain_on_overflow */
1596 ppc64_elf_unhandled_reloc, /* special_function */
1597 "R_PPC64_TPREL16_HIGHESTA", /* name */
1598 FALSE, /* partial_inplace */
1599 0, /* src_mask */
1600 0xffff, /* dst_mask */
1601 FALSE), /* pcrel_offset */
1602
1603 /* Like TPREL16, but for insns with a DS field. */
1604 HOWTO (R_PPC64_TPREL16_DS,
1605 0, /* rightshift */
1606 1, /* size (0 = byte, 1 = short, 2 = long) */
1607 16, /* bitsize */
1608 FALSE, /* pc_relative */
1609 0, /* bitpos */
1610 complain_overflow_signed, /* complain_on_overflow */
1611 ppc64_elf_unhandled_reloc, /* special_function */
1612 "R_PPC64_TPREL16_DS", /* name */
1613 FALSE, /* partial_inplace */
1614 0, /* src_mask */
1615 0xfffc, /* dst_mask */
1616 FALSE), /* pcrel_offset */
1617
1618 /* Like TPREL16_DS, but no overflow. */
1619 HOWTO (R_PPC64_TPREL16_LO_DS,
1620 0, /* rightshift */
1621 1, /* size (0 = byte, 1 = short, 2 = long) */
1622 16, /* bitsize */
1623 FALSE, /* pc_relative */
1624 0, /* bitpos */
1625 complain_overflow_dont, /* complain_on_overflow */
1626 ppc64_elf_unhandled_reloc, /* special_function */
1627 "R_PPC64_TPREL16_LO_DS", /* name */
1628 FALSE, /* partial_inplace */
1629 0, /* src_mask */
1630 0xfffc, /* dst_mask */
1631 FALSE), /* pcrel_offset */
1632
1633 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1634 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1635 to the first entry relative to the TOC base (r2). */
1636 HOWTO (R_PPC64_GOT_TLSGD16,
1637 0, /* rightshift */
1638 1, /* size (0 = byte, 1 = short, 2 = long) */
1639 16, /* bitsize */
1640 FALSE, /* pc_relative */
1641 0, /* bitpos */
1642 complain_overflow_signed, /* complain_on_overflow */
1643 ppc64_elf_unhandled_reloc, /* special_function */
1644 "R_PPC64_GOT_TLSGD16", /* name */
1645 FALSE, /* partial_inplace */
1646 0, /* src_mask */
1647 0xffff, /* dst_mask */
1648 FALSE), /* pcrel_offset */
1649
1650 /* Like GOT_TLSGD16, but no overflow. */
1651 HOWTO (R_PPC64_GOT_TLSGD16_LO,
1652 0, /* rightshift */
1653 1, /* size (0 = byte, 1 = short, 2 = long) */
1654 16, /* bitsize */
1655 FALSE, /* pc_relative */
1656 0, /* bitpos */
1657 complain_overflow_dont, /* complain_on_overflow */
1658 ppc64_elf_unhandled_reloc, /* special_function */
1659 "R_PPC64_GOT_TLSGD16_LO", /* name */
1660 FALSE, /* partial_inplace */
1661 0, /* src_mask */
1662 0xffff, /* dst_mask */
1663 FALSE), /* pcrel_offset */
1664
1665 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1666 HOWTO (R_PPC64_GOT_TLSGD16_HI,
1667 16, /* rightshift */
1668 1, /* size (0 = byte, 1 = short, 2 = long) */
1669 16, /* bitsize */
1670 FALSE, /* pc_relative */
1671 0, /* bitpos */
1672 complain_overflow_dont, /* complain_on_overflow */
1673 ppc64_elf_unhandled_reloc, /* special_function */
1674 "R_PPC64_GOT_TLSGD16_HI", /* name */
1675 FALSE, /* partial_inplace */
1676 0, /* src_mask */
1677 0xffff, /* dst_mask */
1678 FALSE), /* pcrel_offset */
1679
1680 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1681 HOWTO (R_PPC64_GOT_TLSGD16_HA,
1682 16, /* rightshift */
1683 1, /* size (0 = byte, 1 = short, 2 = long) */
1684 16, /* bitsize */
1685 FALSE, /* pc_relative */
1686 0, /* bitpos */
1687 complain_overflow_dont, /* complain_on_overflow */
1688 ppc64_elf_unhandled_reloc, /* special_function */
1689 "R_PPC64_GOT_TLSGD16_HA", /* name */
1690 FALSE, /* partial_inplace */
1691 0, /* src_mask */
1692 0xffff, /* dst_mask */
1693 FALSE), /* pcrel_offset */
1694
1695 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1696 with values (sym+add)@dtpmod and zero, and computes the offset to the
1697 first entry relative to the TOC base (r2). */
1698 HOWTO (R_PPC64_GOT_TLSLD16,
1699 0, /* rightshift */
1700 1, /* size (0 = byte, 1 = short, 2 = long) */
1701 16, /* bitsize */
1702 FALSE, /* pc_relative */
1703 0, /* bitpos */
1704 complain_overflow_signed, /* complain_on_overflow */
1705 ppc64_elf_unhandled_reloc, /* special_function */
1706 "R_PPC64_GOT_TLSLD16", /* name */
1707 FALSE, /* partial_inplace */
1708 0, /* src_mask */
1709 0xffff, /* dst_mask */
1710 FALSE), /* pcrel_offset */
1711
1712 /* Like GOT_TLSLD16, but no overflow. */
1713 HOWTO (R_PPC64_GOT_TLSLD16_LO,
1714 0, /* rightshift */
1715 1, /* size (0 = byte, 1 = short, 2 = long) */
1716 16, /* bitsize */
1717 FALSE, /* pc_relative */
1718 0, /* bitpos */
1719 complain_overflow_dont, /* complain_on_overflow */
1720 ppc64_elf_unhandled_reloc, /* special_function */
1721 "R_PPC64_GOT_TLSLD16_LO", /* name */
1722 FALSE, /* partial_inplace */
1723 0, /* src_mask */
1724 0xffff, /* dst_mask */
1725 FALSE), /* pcrel_offset */
1726
1727 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1728 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1729 16, /* rightshift */
1730 1, /* size (0 = byte, 1 = short, 2 = long) */
1731 16, /* bitsize */
1732 FALSE, /* pc_relative */
1733 0, /* bitpos */
1734 complain_overflow_dont, /* complain_on_overflow */
1735 ppc64_elf_unhandled_reloc, /* special_function */
1736 "R_PPC64_GOT_TLSLD16_HI", /* name */
1737 FALSE, /* partial_inplace */
1738 0, /* src_mask */
1739 0xffff, /* dst_mask */
1740 FALSE), /* pcrel_offset */
1741
1742 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1743 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1744 16, /* rightshift */
1745 1, /* size (0 = byte, 1 = short, 2 = long) */
1746 16, /* bitsize */
1747 FALSE, /* pc_relative */
1748 0, /* bitpos */
1749 complain_overflow_dont, /* complain_on_overflow */
1750 ppc64_elf_unhandled_reloc, /* special_function */
1751 "R_PPC64_GOT_TLSLD16_HA", /* name */
1752 FALSE, /* partial_inplace */
1753 0, /* src_mask */
1754 0xffff, /* dst_mask */
1755 FALSE), /* pcrel_offset */
1756
1757 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1758 the offset to the entry relative to the TOC base (r2). */
1759 HOWTO (R_PPC64_GOT_DTPREL16_DS,
1760 0, /* rightshift */
1761 1, /* size (0 = byte, 1 = short, 2 = long) */
1762 16, /* bitsize */
1763 FALSE, /* pc_relative */
1764 0, /* bitpos */
1765 complain_overflow_signed, /* complain_on_overflow */
1766 ppc64_elf_unhandled_reloc, /* special_function */
1767 "R_PPC64_GOT_DTPREL16_DS", /* name */
1768 FALSE, /* partial_inplace */
1769 0, /* src_mask */
1770 0xfffc, /* dst_mask */
1771 FALSE), /* pcrel_offset */
1772
1773 /* Like GOT_DTPREL16_DS, but no overflow. */
1774 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1775 0, /* rightshift */
1776 1, /* size (0 = byte, 1 = short, 2 = long) */
1777 16, /* bitsize */
1778 FALSE, /* pc_relative */
1779 0, /* bitpos */
1780 complain_overflow_dont, /* complain_on_overflow */
1781 ppc64_elf_unhandled_reloc, /* special_function */
1782 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1783 FALSE, /* partial_inplace */
1784 0, /* src_mask */
1785 0xfffc, /* dst_mask */
1786 FALSE), /* pcrel_offset */
1787
1788 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1789 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1790 16, /* rightshift */
1791 1, /* size (0 = byte, 1 = short, 2 = long) */
1792 16, /* bitsize */
1793 FALSE, /* pc_relative */
1794 0, /* bitpos */
1795 complain_overflow_dont, /* complain_on_overflow */
1796 ppc64_elf_unhandled_reloc, /* special_function */
1797 "R_PPC64_GOT_DTPREL16_HI", /* name */
1798 FALSE, /* partial_inplace */
1799 0, /* src_mask */
1800 0xffff, /* dst_mask */
1801 FALSE), /* pcrel_offset */
1802
1803 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1804 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1805 16, /* rightshift */
1806 1, /* size (0 = byte, 1 = short, 2 = long) */
1807 16, /* bitsize */
1808 FALSE, /* pc_relative */
1809 0, /* bitpos */
1810 complain_overflow_dont, /* complain_on_overflow */
1811 ppc64_elf_unhandled_reloc, /* special_function */
1812 "R_PPC64_GOT_DTPREL16_HA", /* name */
1813 FALSE, /* partial_inplace */
1814 0, /* src_mask */
1815 0xffff, /* dst_mask */
1816 FALSE), /* pcrel_offset */
1817
1818 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1819 offset to the entry relative to the TOC base (r2). */
1820 HOWTO (R_PPC64_GOT_TPREL16_DS,
1821 0, /* rightshift */
1822 1, /* size (0 = byte, 1 = short, 2 = long) */
1823 16, /* bitsize */
1824 FALSE, /* pc_relative */
1825 0, /* bitpos */
1826 complain_overflow_signed, /* complain_on_overflow */
1827 ppc64_elf_unhandled_reloc, /* special_function */
1828 "R_PPC64_GOT_TPREL16_DS", /* name */
1829 FALSE, /* partial_inplace */
1830 0, /* src_mask */
1831 0xfffc, /* dst_mask */
1832 FALSE), /* pcrel_offset */
1833
1834 /* Like GOT_TPREL16_DS, but no overflow. */
1835 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1836 0, /* rightshift */
1837 1, /* size (0 = byte, 1 = short, 2 = long) */
1838 16, /* bitsize */
1839 FALSE, /* pc_relative */
1840 0, /* bitpos */
1841 complain_overflow_dont, /* complain_on_overflow */
1842 ppc64_elf_unhandled_reloc, /* special_function */
1843 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1844 FALSE, /* partial_inplace */
1845 0, /* src_mask */
1846 0xfffc, /* dst_mask */
1847 FALSE), /* pcrel_offset */
1848
1849 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1850 HOWTO (R_PPC64_GOT_TPREL16_HI,
1851 16, /* rightshift */
1852 1, /* size (0 = byte, 1 = short, 2 = long) */
1853 16, /* bitsize */
1854 FALSE, /* pc_relative */
1855 0, /* bitpos */
1856 complain_overflow_dont, /* complain_on_overflow */
1857 ppc64_elf_unhandled_reloc, /* special_function */
1858 "R_PPC64_GOT_TPREL16_HI", /* name */
1859 FALSE, /* partial_inplace */
1860 0, /* src_mask */
1861 0xffff, /* dst_mask */
1862 FALSE), /* pcrel_offset */
1863
1864 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1865 HOWTO (R_PPC64_GOT_TPREL16_HA,
1866 16, /* rightshift */
1867 1, /* size (0 = byte, 1 = short, 2 = long) */
1868 16, /* bitsize */
1869 FALSE, /* pc_relative */
1870 0, /* bitpos */
1871 complain_overflow_dont, /* complain_on_overflow */
1872 ppc64_elf_unhandled_reloc, /* special_function */
1873 "R_PPC64_GOT_TPREL16_HA", /* name */
1874 FALSE, /* partial_inplace */
1875 0, /* src_mask */
1876 0xffff, /* dst_mask */
1877 FALSE), /* pcrel_offset */
1878
1879 HOWTO (R_PPC64_JMP_IREL, /* type */
1880 0, /* rightshift */
1881 0, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1882 0, /* bitsize */
1883 FALSE, /* pc_relative */
1884 0, /* bitpos */
1885 complain_overflow_dont, /* complain_on_overflow */
1886 ppc64_elf_unhandled_reloc, /* special_function */
1887 "R_PPC64_JMP_IREL", /* name */
1888 FALSE, /* partial_inplace */
1889 0, /* src_mask */
1890 0, /* dst_mask */
1891 FALSE), /* pcrel_offset */
1892
1893 HOWTO (R_PPC64_IRELATIVE, /* type */
1894 0, /* rightshift */
1895 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1896 64, /* bitsize */
1897 FALSE, /* pc_relative */
1898 0, /* bitpos */
1899 complain_overflow_dont, /* complain_on_overflow */
1900 bfd_elf_generic_reloc, /* special_function */
1901 "R_PPC64_IRELATIVE", /* name */
1902 FALSE, /* partial_inplace */
1903 0, /* src_mask */
1904 ONES (64), /* dst_mask */
1905 FALSE), /* pcrel_offset */
1906
1907 /* A 16 bit relative relocation. */
1908 HOWTO (R_PPC64_REL16, /* type */
1909 0, /* rightshift */
1910 1, /* size (0 = byte, 1 = short, 2 = long) */
1911 16, /* bitsize */
1912 TRUE, /* pc_relative */
1913 0, /* bitpos */
1914 complain_overflow_bitfield, /* complain_on_overflow */
1915 bfd_elf_generic_reloc, /* special_function */
1916 "R_PPC64_REL16", /* name */
1917 FALSE, /* partial_inplace */
1918 0, /* src_mask */
1919 0xffff, /* dst_mask */
1920 TRUE), /* pcrel_offset */
1921
1922 /* A 16 bit relative relocation without overflow. */
1923 HOWTO (R_PPC64_REL16_LO, /* type */
1924 0, /* rightshift */
1925 1, /* size (0 = byte, 1 = short, 2 = long) */
1926 16, /* bitsize */
1927 TRUE, /* pc_relative */
1928 0, /* bitpos */
1929 complain_overflow_dont,/* complain_on_overflow */
1930 bfd_elf_generic_reloc, /* special_function */
1931 "R_PPC64_REL16_LO", /* name */
1932 FALSE, /* partial_inplace */
1933 0, /* src_mask */
1934 0xffff, /* dst_mask */
1935 TRUE), /* pcrel_offset */
1936
1937 /* The high order 16 bits of a relative address. */
1938 HOWTO (R_PPC64_REL16_HI, /* type */
1939 16, /* rightshift */
1940 1, /* size (0 = byte, 1 = short, 2 = long) */
1941 16, /* bitsize */
1942 TRUE, /* pc_relative */
1943 0, /* bitpos */
1944 complain_overflow_dont, /* complain_on_overflow */
1945 bfd_elf_generic_reloc, /* special_function */
1946 "R_PPC64_REL16_HI", /* name */
1947 FALSE, /* partial_inplace */
1948 0, /* src_mask */
1949 0xffff, /* dst_mask */
1950 TRUE), /* pcrel_offset */
1951
1952 /* The high order 16 bits of a relative address, plus 1 if the contents of
1953 the low 16 bits, treated as a signed number, is negative. */
1954 HOWTO (R_PPC64_REL16_HA, /* type */
1955 16, /* rightshift */
1956 1, /* size (0 = byte, 1 = short, 2 = long) */
1957 16, /* bitsize */
1958 TRUE, /* pc_relative */
1959 0, /* bitpos */
1960 complain_overflow_dont, /* complain_on_overflow */
1961 ppc64_elf_ha_reloc, /* special_function */
1962 "R_PPC64_REL16_HA", /* name */
1963 FALSE, /* partial_inplace */
1964 0, /* src_mask */
1965 0xffff, /* dst_mask */
1966 TRUE), /* pcrel_offset */
1967
1968 /* GNU extension to record C++ vtable hierarchy. */
1969 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
1970 0, /* rightshift */
1971 0, /* size (0 = byte, 1 = short, 2 = long) */
1972 0, /* bitsize */
1973 FALSE, /* pc_relative */
1974 0, /* bitpos */
1975 complain_overflow_dont, /* complain_on_overflow */
1976 NULL, /* special_function */
1977 "R_PPC64_GNU_VTINHERIT", /* name */
1978 FALSE, /* partial_inplace */
1979 0, /* src_mask */
1980 0, /* dst_mask */
1981 FALSE), /* pcrel_offset */
1982
1983 /* GNU extension to record C++ vtable member usage. */
1984 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
1985 0, /* rightshift */
1986 0, /* size (0 = byte, 1 = short, 2 = long) */
1987 0, /* bitsize */
1988 FALSE, /* pc_relative */
1989 0, /* bitpos */
1990 complain_overflow_dont, /* complain_on_overflow */
1991 NULL, /* special_function */
1992 "R_PPC64_GNU_VTENTRY", /* name */
1993 FALSE, /* partial_inplace */
1994 0, /* src_mask */
1995 0, /* dst_mask */
1996 FALSE), /* pcrel_offset */
1997 };
1998
1999 \f
2000 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2001 be done. */
2002
2003 static void
2004 ppc_howto_init (void)
2005 {
2006 unsigned int i, type;
2007
2008 for (i = 0;
2009 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2010 i++)
2011 {
2012 type = ppc64_elf_howto_raw[i].type;
2013 BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2014 / sizeof (ppc64_elf_howto_table[0])));
2015 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2016 }
2017 }
2018
2019 static reloc_howto_type *
2020 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2021 bfd_reloc_code_real_type code)
2022 {
2023 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2024
2025 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2026 /* Initialize howto table if needed. */
2027 ppc_howto_init ();
2028
2029 switch (code)
2030 {
2031 default:
2032 return NULL;
2033
2034 case BFD_RELOC_NONE: r = R_PPC64_NONE;
2035 break;
2036 case BFD_RELOC_32: r = R_PPC64_ADDR32;
2037 break;
2038 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
2039 break;
2040 case BFD_RELOC_16: r = R_PPC64_ADDR16;
2041 break;
2042 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
2043 break;
2044 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
2045 break;
2046 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
2047 break;
2048 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
2049 break;
2050 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
2051 break;
2052 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
2053 break;
2054 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
2055 break;
2056 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
2057 break;
2058 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
2059 break;
2060 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
2061 break;
2062 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
2063 break;
2064 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
2065 break;
2066 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
2067 break;
2068 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
2069 break;
2070 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
2071 break;
2072 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
2073 break;
2074 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
2075 break;
2076 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
2077 break;
2078 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
2079 break;
2080 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
2081 break;
2082 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
2083 break;
2084 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
2085 break;
2086 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
2087 break;
2088 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
2089 break;
2090 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
2091 break;
2092 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
2093 break;
2094 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
2095 break;
2096 case BFD_RELOC_64: r = R_PPC64_ADDR64;
2097 break;
2098 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
2099 break;
2100 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
2101 break;
2102 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
2103 break;
2104 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
2105 break;
2106 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
2107 break;
2108 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
2109 break;
2110 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
2111 break;
2112 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
2113 break;
2114 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
2115 break;
2116 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
2117 break;
2118 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
2119 break;
2120 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
2121 break;
2122 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
2123 break;
2124 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
2125 break;
2126 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
2127 break;
2128 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
2129 break;
2130 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
2131 break;
2132 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
2133 break;
2134 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
2135 break;
2136 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
2137 break;
2138 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
2139 break;
2140 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
2141 break;
2142 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
2143 break;
2144 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
2145 break;
2146 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
2147 break;
2148 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
2149 break;
2150 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
2151 break;
2152 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
2153 break;
2154 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
2155 break;
2156 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
2157 break;
2158 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
2159 break;
2160 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
2161 break;
2162 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
2163 break;
2164 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
2165 break;
2166 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
2167 break;
2168 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
2169 break;
2170 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2171 break;
2172 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2173 break;
2174 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2175 break;
2176 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2177 break;
2178 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2179 break;
2180 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2181 break;
2182 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2183 break;
2184 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2185 break;
2186 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2187 break;
2188 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2189 break;
2190 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2191 break;
2192 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2193 break;
2194 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2195 break;
2196 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2197 break;
2198 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2199 break;
2200 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2201 break;
2202 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2203 break;
2204 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2205 break;
2206 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2207 break;
2208 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2209 break;
2210 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2211 break;
2212 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2213 break;
2214 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2215 break;
2216 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2217 break;
2218 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2219 break;
2220 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2221 break;
2222 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2223 break;
2224 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2225 break;
2226 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2227 break;
2228 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2229 break;
2230 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2231 break;
2232 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2233 break;
2234 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2235 break;
2236 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16;
2237 break;
2238 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO;
2239 break;
2240 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI;
2241 break;
2242 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA;
2243 break;
2244 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2245 break;
2246 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
2247 break;
2248 }
2249
2250 return ppc64_elf_howto_table[r];
2251 };
2252
2253 static reloc_howto_type *
2254 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2255 const char *r_name)
2256 {
2257 unsigned int i;
2258
2259 for (i = 0;
2260 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2261 i++)
2262 if (ppc64_elf_howto_raw[i].name != NULL
2263 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2264 return &ppc64_elf_howto_raw[i];
2265
2266 return NULL;
2267 }
2268
2269 /* Set the howto pointer for a PowerPC ELF reloc. */
2270
2271 static void
2272 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2273 Elf_Internal_Rela *dst)
2274 {
2275 unsigned int type;
2276
2277 /* Initialize howto table if needed. */
2278 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2279 ppc_howto_init ();
2280
2281 type = ELF64_R_TYPE (dst->r_info);
2282 if (type >= (sizeof (ppc64_elf_howto_table)
2283 / sizeof (ppc64_elf_howto_table[0])))
2284 {
2285 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2286 abfd, (int) type);
2287 type = R_PPC64_NONE;
2288 }
2289 cache_ptr->howto = ppc64_elf_howto_table[type];
2290 }
2291
2292 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
2293
2294 static bfd_reloc_status_type
2295 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2296 void *data, asection *input_section,
2297 bfd *output_bfd, char **error_message)
2298 {
2299 /* If this is a relocatable link (output_bfd test tells us), just
2300 call the generic function. Any adjustment will be done at final
2301 link time. */
2302 if (output_bfd != NULL)
2303 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2304 input_section, output_bfd, error_message);
2305
2306 /* Adjust the addend for sign extension of the low 16 bits.
2307 We won't actually be using the low 16 bits, so trashing them
2308 doesn't matter. */
2309 reloc_entry->addend += 0x8000;
2310 return bfd_reloc_continue;
2311 }
2312
2313 static bfd_reloc_status_type
2314 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2315 void *data, asection *input_section,
2316 bfd *output_bfd, char **error_message)
2317 {
2318 if (output_bfd != NULL)
2319 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2320 input_section, output_bfd, error_message);
2321
2322 if (strcmp (symbol->section->name, ".opd") == 0
2323 && (symbol->section->owner->flags & DYNAMIC) == 0)
2324 {
2325 bfd_vma dest = opd_entry_value (symbol->section,
2326 symbol->value + reloc_entry->addend,
2327 NULL, NULL);
2328 if (dest != (bfd_vma) -1)
2329 reloc_entry->addend = dest - (symbol->value
2330 + symbol->section->output_section->vma
2331 + symbol->section->output_offset);
2332 }
2333 return bfd_reloc_continue;
2334 }
2335
2336 static bfd_reloc_status_type
2337 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2338 void *data, asection *input_section,
2339 bfd *output_bfd, char **error_message)
2340 {
2341 long insn;
2342 enum elf_ppc64_reloc_type r_type;
2343 bfd_size_type octets;
2344 /* Disabled until we sort out how ld should choose 'y' vs 'at'. */
2345 bfd_boolean is_power4 = FALSE;
2346
2347 /* If this is a relocatable link (output_bfd test tells us), just
2348 call the generic function. Any adjustment will be done at final
2349 link time. */
2350 if (output_bfd != NULL)
2351 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2352 input_section, output_bfd, error_message);
2353
2354 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2355 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2356 insn &= ~(0x01 << 21);
2357 r_type = reloc_entry->howto->type;
2358 if (r_type == R_PPC64_ADDR14_BRTAKEN
2359 || r_type == R_PPC64_REL14_BRTAKEN)
2360 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
2361
2362 if (is_power4)
2363 {
2364 /* Set 'a' bit. This is 0b00010 in BO field for branch
2365 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2366 for branch on CTR insns (BO == 1a00t or 1a01t). */
2367 if ((insn & (0x14 << 21)) == (0x04 << 21))
2368 insn |= 0x02 << 21;
2369 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2370 insn |= 0x08 << 21;
2371 else
2372 goto out;
2373 }
2374 else
2375 {
2376 bfd_vma target = 0;
2377 bfd_vma from;
2378
2379 if (!bfd_is_com_section (symbol->section))
2380 target = symbol->value;
2381 target += symbol->section->output_section->vma;
2382 target += symbol->section->output_offset;
2383 target += reloc_entry->addend;
2384
2385 from = (reloc_entry->address
2386 + input_section->output_offset
2387 + input_section->output_section->vma);
2388
2389 /* Invert 'y' bit if not the default. */
2390 if ((bfd_signed_vma) (target - from) < 0)
2391 insn ^= 0x01 << 21;
2392 }
2393 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2394 out:
2395 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2396 input_section, output_bfd, error_message);
2397 }
2398
2399 static bfd_reloc_status_type
2400 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2401 void *data, asection *input_section,
2402 bfd *output_bfd, char **error_message)
2403 {
2404 /* If this is a relocatable link (output_bfd test tells us), just
2405 call the generic function. Any adjustment will be done at final
2406 link time. */
2407 if (output_bfd != NULL)
2408 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2409 input_section, output_bfd, error_message);
2410
2411 /* Subtract the symbol section base address. */
2412 reloc_entry->addend -= symbol->section->output_section->vma;
2413 return bfd_reloc_continue;
2414 }
2415
2416 static bfd_reloc_status_type
2417 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2418 void *data, asection *input_section,
2419 bfd *output_bfd, char **error_message)
2420 {
2421 /* If this is a relocatable link (output_bfd test tells us), just
2422 call the generic function. Any adjustment will be done at final
2423 link time. */
2424 if (output_bfd != NULL)
2425 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2426 input_section, output_bfd, error_message);
2427
2428 /* Subtract the symbol section base address. */
2429 reloc_entry->addend -= symbol->section->output_section->vma;
2430
2431 /* Adjust the addend for sign extension of the low 16 bits. */
2432 reloc_entry->addend += 0x8000;
2433 return bfd_reloc_continue;
2434 }
2435
2436 static bfd_reloc_status_type
2437 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2438 void *data, asection *input_section,
2439 bfd *output_bfd, char **error_message)
2440 {
2441 bfd_vma TOCstart;
2442
2443 /* If this is a relocatable link (output_bfd test tells us), just
2444 call the generic function. Any adjustment will be done at final
2445 link time. */
2446 if (output_bfd != NULL)
2447 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2448 input_section, output_bfd, error_message);
2449
2450 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2451 if (TOCstart == 0)
2452 TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2453
2454 /* Subtract the TOC base address. */
2455 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2456 return bfd_reloc_continue;
2457 }
2458
2459 static bfd_reloc_status_type
2460 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2461 void *data, asection *input_section,
2462 bfd *output_bfd, char **error_message)
2463 {
2464 bfd_vma TOCstart;
2465
2466 /* If this is a relocatable link (output_bfd test tells us), just
2467 call the generic function. Any adjustment will be done at final
2468 link time. */
2469 if (output_bfd != NULL)
2470 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2471 input_section, output_bfd, error_message);
2472
2473 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2474 if (TOCstart == 0)
2475 TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2476
2477 /* Subtract the TOC base address. */
2478 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2479
2480 /* Adjust the addend for sign extension of the low 16 bits. */
2481 reloc_entry->addend += 0x8000;
2482 return bfd_reloc_continue;
2483 }
2484
2485 static bfd_reloc_status_type
2486 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2487 void *data, asection *input_section,
2488 bfd *output_bfd, char **error_message)
2489 {
2490 bfd_vma TOCstart;
2491 bfd_size_type octets;
2492
2493 /* If this is a relocatable link (output_bfd test tells us), just
2494 call the generic function. Any adjustment will be done at final
2495 link time. */
2496 if (output_bfd != NULL)
2497 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2498 input_section, output_bfd, error_message);
2499
2500 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2501 if (TOCstart == 0)
2502 TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2503
2504 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2505 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2506 return bfd_reloc_ok;
2507 }
2508
2509 static bfd_reloc_status_type
2510 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2511 void *data, asection *input_section,
2512 bfd *output_bfd, char **error_message)
2513 {
2514 /* If this is a relocatable link (output_bfd test tells us), just
2515 call the generic function. Any adjustment will be done at final
2516 link time. */
2517 if (output_bfd != NULL)
2518 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2519 input_section, output_bfd, error_message);
2520
2521 if (error_message != NULL)
2522 {
2523 static char buf[60];
2524 sprintf (buf, "generic linker can't handle %s",
2525 reloc_entry->howto->name);
2526 *error_message = buf;
2527 }
2528 return bfd_reloc_dangerous;
2529 }
2530
2531 /* Track GOT entries needed for a given symbol. We might need more
2532 than one got entry per symbol. */
2533 struct got_entry
2534 {
2535 struct got_entry *next;
2536
2537 /* The symbol addend that we'll be placing in the GOT. */
2538 bfd_vma addend;
2539
2540 /* Unlike other ELF targets, we use separate GOT entries for the same
2541 symbol referenced from different input files. This is to support
2542 automatic multiple TOC/GOT sections, where the TOC base can vary
2543 from one input file to another. After partitioning into TOC groups
2544 we merge entries within the group.
2545
2546 Point to the BFD owning this GOT entry. */
2547 bfd *owner;
2548
2549 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2550 TLS_TPREL or TLS_DTPREL for tls entries. */
2551 unsigned char tls_type;
2552
2553 /* Non-zero if got.ent points to real entry. */
2554 unsigned char is_indirect;
2555
2556 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
2557 union
2558 {
2559 bfd_signed_vma refcount;
2560 bfd_vma offset;
2561 struct got_entry *ent;
2562 } got;
2563 };
2564
2565 /* The same for PLT. */
2566 struct plt_entry
2567 {
2568 struct plt_entry *next;
2569
2570 bfd_vma addend;
2571
2572 union
2573 {
2574 bfd_signed_vma refcount;
2575 bfd_vma offset;
2576 } plt;
2577 };
2578
2579 struct ppc64_elf_obj_tdata
2580 {
2581 struct elf_obj_tdata elf;
2582
2583 /* Shortcuts to dynamic linker sections. */
2584 asection *got;
2585 asection *relgot;
2586
2587 /* Used during garbage collection. We attach global symbols defined
2588 on removed .opd entries to this section so that the sym is removed. */
2589 asection *deleted_section;
2590
2591 /* TLS local dynamic got entry handling. Support for multiple GOT
2592 sections means we potentially need one of these for each input bfd. */
2593 struct got_entry tlsld_got;
2594
2595 /* A copy of relocs before they are modified for --emit-relocs. */
2596 Elf_Internal_Rela *opd_relocs;
2597
2598 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2599 the reloc to be in the range -32768 to 32767. */
2600 unsigned int has_small_toc_reloc;
2601 };
2602
2603 #define ppc64_elf_tdata(bfd) \
2604 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2605
2606 #define ppc64_tlsld_got(bfd) \
2607 (&ppc64_elf_tdata (bfd)->tlsld_got)
2608
2609 #define is_ppc64_elf(bfd) \
2610 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2611 && elf_object_id (bfd) == PPC64_ELF_DATA)
2612
2613 /* Override the generic function because we store some extras. */
2614
2615 static bfd_boolean
2616 ppc64_elf_mkobject (bfd *abfd)
2617 {
2618 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2619 PPC64_ELF_DATA);
2620 }
2621
2622 /* Fix bad default arch selected for a 64 bit input bfd when the
2623 default is 32 bit. */
2624
2625 static bfd_boolean
2626 ppc64_elf_object_p (bfd *abfd)
2627 {
2628 if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2629 {
2630 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2631
2632 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2633 {
2634 /* Relies on arch after 32 bit default being 64 bit default. */
2635 abfd->arch_info = abfd->arch_info->next;
2636 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2637 }
2638 }
2639 return TRUE;
2640 }
2641
2642 /* Support for core dump NOTE sections. */
2643
2644 static bfd_boolean
2645 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2646 {
2647 size_t offset, size;
2648
2649 if (note->descsz != 504)
2650 return FALSE;
2651
2652 /* pr_cursig */
2653 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
2654
2655 /* pr_pid */
2656 elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 32);
2657
2658 /* pr_reg */
2659 offset = 112;
2660 size = 384;
2661
2662 /* Make a ".reg/999" section. */
2663 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2664 size, note->descpos + offset);
2665 }
2666
2667 static bfd_boolean
2668 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2669 {
2670 if (note->descsz != 136)
2671 return FALSE;
2672
2673 elf_tdata (abfd)->core_program
2674 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2675 elf_tdata (abfd)->core_command
2676 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2677
2678 return TRUE;
2679 }
2680
2681 static char *
2682 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2683 ...)
2684 {
2685 switch (note_type)
2686 {
2687 default:
2688 return NULL;
2689
2690 case NT_PRPSINFO:
2691 {
2692 char data[136];
2693 va_list ap;
2694
2695 va_start (ap, note_type);
2696 memset (data, 0, 40);
2697 strncpy (data + 40, va_arg (ap, const char *), 16);
2698 strncpy (data + 56, va_arg (ap, const char *), 80);
2699 va_end (ap);
2700 return elfcore_write_note (abfd, buf, bufsiz,
2701 "CORE", note_type, data, sizeof (data));
2702 }
2703
2704 case NT_PRSTATUS:
2705 {
2706 char data[504];
2707 va_list ap;
2708 long pid;
2709 int cursig;
2710 const void *greg;
2711
2712 va_start (ap, note_type);
2713 memset (data, 0, 112);
2714 pid = va_arg (ap, long);
2715 bfd_put_32 (abfd, pid, data + 32);
2716 cursig = va_arg (ap, int);
2717 bfd_put_16 (abfd, cursig, data + 12);
2718 greg = va_arg (ap, const void *);
2719 memcpy (data + 112, greg, 384);
2720 memset (data + 496, 0, 8);
2721 va_end (ap);
2722 return elfcore_write_note (abfd, buf, bufsiz,
2723 "CORE", note_type, data, sizeof (data));
2724 }
2725 }
2726 }
2727
2728 /* Merge backend specific data from an object file to the output
2729 object file when linking. */
2730
2731 static bfd_boolean
2732 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
2733 {
2734 /* Check if we have the same endianess. */
2735 if (ibfd->xvec->byteorder != obfd->xvec->byteorder
2736 && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
2737 && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
2738 {
2739 const char *msg;
2740
2741 if (bfd_big_endian (ibfd))
2742 msg = _("%B: compiled for a big endian system "
2743 "and target is little endian");
2744 else
2745 msg = _("%B: compiled for a little endian system "
2746 "and target is big endian");
2747
2748 (*_bfd_error_handler) (msg, ibfd);
2749
2750 bfd_set_error (bfd_error_wrong_format);
2751 return FALSE;
2752 }
2753
2754 return TRUE;
2755 }
2756
2757 /* Add extra PPC sections. */
2758
2759 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2760 {
2761 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
2762 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2763 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2764 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2765 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2766 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2767 { NULL, 0, 0, 0, 0 }
2768 };
2769
2770 enum _ppc64_sec_type {
2771 sec_normal = 0,
2772 sec_opd = 1,
2773 sec_toc = 2
2774 };
2775
2776 struct _ppc64_elf_section_data
2777 {
2778 struct bfd_elf_section_data elf;
2779
2780 union
2781 {
2782 /* An array with one entry for each opd function descriptor. */
2783 struct _opd_sec_data
2784 {
2785 /* Points to the function code section for local opd entries. */
2786 asection **func_sec;
2787
2788 /* After editing .opd, adjust references to opd local syms. */
2789 long *adjust;
2790 } opd;
2791
2792 /* An array for toc sections, indexed by offset/8. */
2793 struct _toc_sec_data
2794 {
2795 /* Specifies the relocation symbol index used at a given toc offset. */
2796 unsigned *symndx;
2797
2798 /* And the relocation addend. */
2799 bfd_vma *add;
2800 } toc;
2801 } u;
2802
2803 enum _ppc64_sec_type sec_type:2;
2804
2805 /* Flag set when small branches are detected. Used to
2806 select suitable defaults for the stub group size. */
2807 unsigned int has_14bit_branch:1;
2808 };
2809
2810 #define ppc64_elf_section_data(sec) \
2811 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2812
2813 static bfd_boolean
2814 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2815 {
2816 if (!sec->used_by_bfd)
2817 {
2818 struct _ppc64_elf_section_data *sdata;
2819 bfd_size_type amt = sizeof (*sdata);
2820
2821 sdata = bfd_zalloc (abfd, amt);
2822 if (sdata == NULL)
2823 return FALSE;
2824 sec->used_by_bfd = sdata;
2825 }
2826
2827 return _bfd_elf_new_section_hook (abfd, sec);
2828 }
2829
2830 static struct _opd_sec_data *
2831 get_opd_info (asection * sec)
2832 {
2833 if (sec != NULL
2834 && ppc64_elf_section_data (sec) != NULL
2835 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2836 return &ppc64_elf_section_data (sec)->u.opd;
2837 return NULL;
2838 }
2839 \f
2840 /* Parameters for the qsort hook. */
2841 static bfd_boolean synthetic_relocatable;
2842
2843 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
2844
2845 static int
2846 compare_symbols (const void *ap, const void *bp)
2847 {
2848 const asymbol *a = * (const asymbol **) ap;
2849 const asymbol *b = * (const asymbol **) bp;
2850
2851 /* Section symbols first. */
2852 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2853 return -1;
2854 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2855 return 1;
2856
2857 /* then .opd symbols. */
2858 if (strcmp (a->section->name, ".opd") == 0
2859 && strcmp (b->section->name, ".opd") != 0)
2860 return -1;
2861 if (strcmp (a->section->name, ".opd") != 0
2862 && strcmp (b->section->name, ".opd") == 0)
2863 return 1;
2864
2865 /* then other code symbols. */
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 ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2873 != (SEC_CODE | SEC_ALLOC)
2874 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2875 == (SEC_CODE | SEC_ALLOC))
2876 return 1;
2877
2878 if (synthetic_relocatable)
2879 {
2880 if (a->section->id < b->section->id)
2881 return -1;
2882
2883 if (a->section->id > b->section->id)
2884 return 1;
2885 }
2886
2887 if (a->value + a->section->vma < b->value + b->section->vma)
2888 return -1;
2889
2890 if (a->value + a->section->vma > b->value + b->section->vma)
2891 return 1;
2892
2893 /* For syms with the same value, prefer strong dynamic global function
2894 syms over other syms. */
2895 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
2896 return -1;
2897
2898 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
2899 return 1;
2900
2901 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
2902 return -1;
2903
2904 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
2905 return 1;
2906
2907 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
2908 return -1;
2909
2910 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
2911 return 1;
2912
2913 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
2914 return -1;
2915
2916 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
2917 return 1;
2918
2919 return 0;
2920 }
2921
2922 /* Search SYMS for a symbol of the given VALUE. */
2923
2924 static asymbol *
2925 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
2926 {
2927 long mid;
2928
2929 if (id == -1)
2930 {
2931 while (lo < hi)
2932 {
2933 mid = (lo + hi) >> 1;
2934 if (syms[mid]->value + syms[mid]->section->vma < value)
2935 lo = mid + 1;
2936 else if (syms[mid]->value + syms[mid]->section->vma > value)
2937 hi = mid;
2938 else
2939 return syms[mid];
2940 }
2941 }
2942 else
2943 {
2944 while (lo < hi)
2945 {
2946 mid = (lo + hi) >> 1;
2947 if (syms[mid]->section->id < id)
2948 lo = mid + 1;
2949 else if (syms[mid]->section->id > id)
2950 hi = mid;
2951 else if (syms[mid]->value < value)
2952 lo = mid + 1;
2953 else if (syms[mid]->value > value)
2954 hi = mid;
2955 else
2956 return syms[mid];
2957 }
2958 }
2959 return NULL;
2960 }
2961
2962 static bfd_boolean
2963 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
2964 {
2965 bfd_vma vma = *(bfd_vma *) ptr;
2966 return ((section->flags & SEC_ALLOC) != 0
2967 && section->vma <= vma
2968 && vma < section->vma + section->size);
2969 }
2970
2971 /* Create synthetic symbols, effectively restoring "dot-symbol" function
2972 entry syms. Also generate @plt symbols for the glink branch table. */
2973
2974 static long
2975 ppc64_elf_get_synthetic_symtab (bfd *abfd,
2976 long static_count, asymbol **static_syms,
2977 long dyn_count, asymbol **dyn_syms,
2978 asymbol **ret)
2979 {
2980 asymbol *s;
2981 long i;
2982 long count;
2983 char *names;
2984 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
2985 asection *opd;
2986 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2987 asymbol **syms;
2988
2989 *ret = NULL;
2990
2991 opd = bfd_get_section_by_name (abfd, ".opd");
2992 if (opd == NULL)
2993 return 0;
2994
2995 symcount = static_count;
2996 if (!relocatable)
2997 symcount += dyn_count;
2998 if (symcount == 0)
2999 return 0;
3000
3001 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3002 if (syms == NULL)
3003 return -1;
3004
3005 if (!relocatable && static_count != 0 && dyn_count != 0)
3006 {
3007 /* Use both symbol tables. */
3008 memcpy (syms, static_syms, static_count * sizeof (*syms));
3009 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3010 }
3011 else if (!relocatable && static_count == 0)
3012 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3013 else
3014 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3015
3016 synthetic_relocatable = relocatable;
3017 qsort (syms, symcount, sizeof (*syms), compare_symbols);
3018
3019 if (!relocatable && symcount > 1)
3020 {
3021 long j;
3022 /* Trim duplicate syms, since we may have merged the normal and
3023 dynamic symbols. Actually, we only care about syms that have
3024 different values, so trim any with the same value. */
3025 for (i = 1, j = 1; i < symcount; ++i)
3026 if (syms[i - 1]->value + syms[i - 1]->section->vma
3027 != syms[i]->value + syms[i]->section->vma)
3028 syms[j++] = syms[i];
3029 symcount = j;
3030 }
3031
3032 i = 0;
3033 if (strcmp (syms[i]->section->name, ".opd") == 0)
3034 ++i;
3035 codesecsym = i;
3036
3037 for (; i < symcount; ++i)
3038 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3039 != (SEC_CODE | SEC_ALLOC))
3040 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3041 break;
3042 codesecsymend = i;
3043
3044 for (; i < symcount; ++i)
3045 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3046 break;
3047 secsymend = i;
3048
3049 for (; i < symcount; ++i)
3050 if (strcmp (syms[i]->section->name, ".opd") != 0)
3051 break;
3052 opdsymend = i;
3053
3054 for (; i < symcount; ++i)
3055 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3056 != (SEC_CODE | SEC_ALLOC))
3057 break;
3058 symcount = i;
3059
3060 count = 0;
3061
3062 if (relocatable)
3063 {
3064 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3065 arelent *r;
3066 size_t size;
3067 long relcount;
3068
3069 if (opdsymend == secsymend)
3070 goto done;
3071
3072 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3073 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3074 if (relcount == 0)
3075 goto done;
3076
3077 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3078 {
3079 count = -1;
3080 goto done;
3081 }
3082
3083 size = 0;
3084 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3085 {
3086 asymbol *sym;
3087
3088 while (r < opd->relocation + relcount
3089 && r->address < syms[i]->value + opd->vma)
3090 ++r;
3091
3092 if (r == opd->relocation + relcount)
3093 break;
3094
3095 if (r->address != syms[i]->value + opd->vma)
3096 continue;
3097
3098 if (r->howto->type != R_PPC64_ADDR64)
3099 continue;
3100
3101 sym = *r->sym_ptr_ptr;
3102 if (!sym_exists_at (syms, opdsymend, symcount,
3103 sym->section->id, sym->value + r->addend))
3104 {
3105 ++count;
3106 size += sizeof (asymbol);
3107 size += strlen (syms[i]->name) + 2;
3108 }
3109 }
3110
3111 s = *ret = bfd_malloc (size);
3112 if (s == NULL)
3113 {
3114 count = -1;
3115 goto done;
3116 }
3117
3118 names = (char *) (s + count);
3119
3120 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3121 {
3122 asymbol *sym;
3123
3124 while (r < opd->relocation + relcount
3125 && r->address < syms[i]->value + opd->vma)
3126 ++r;
3127
3128 if (r == opd->relocation + relcount)
3129 break;
3130
3131 if (r->address != syms[i]->value + opd->vma)
3132 continue;
3133
3134 if (r->howto->type != R_PPC64_ADDR64)
3135 continue;
3136
3137 sym = *r->sym_ptr_ptr;
3138 if (!sym_exists_at (syms, opdsymend, symcount,
3139 sym->section->id, sym->value + r->addend))
3140 {
3141 size_t len;
3142
3143 *s = *syms[i];
3144 s->flags |= BSF_SYNTHETIC;
3145 s->section = sym->section;
3146 s->value = sym->value + r->addend;
3147 s->name = names;
3148 *names++ = '.';
3149 len = strlen (syms[i]->name);
3150 memcpy (names, syms[i]->name, len + 1);
3151 names += len + 1;
3152 /* Have udata.p point back to the original symbol this
3153 synthetic symbol was derived from. */
3154 s->udata.p = syms[i];
3155 s++;
3156 }
3157 }
3158 }
3159 else
3160 {
3161 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3162 bfd_byte *contents;
3163 size_t size;
3164 long plt_count = 0;
3165 bfd_vma glink_vma = 0, resolv_vma = 0;
3166 asection *dynamic, *glink = NULL, *relplt = NULL;
3167 arelent *p;
3168
3169 if (!bfd_malloc_and_get_section (abfd, opd, &contents))
3170 {
3171 if (contents)
3172 {
3173 free_contents_and_exit:
3174 free (contents);
3175 }
3176 count = -1;
3177 goto done;
3178 }
3179
3180 size = 0;
3181 for (i = secsymend; i < opdsymend; ++i)
3182 {
3183 bfd_vma ent;
3184
3185 /* Ignore bogus symbols. */
3186 if (syms[i]->value > opd->size - 8)
3187 continue;
3188
3189 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3190 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3191 {
3192 ++count;
3193 size += sizeof (asymbol);
3194 size += strlen (syms[i]->name) + 2;
3195 }
3196 }
3197
3198 /* Get start of .glink stubs from DT_PPC64_GLINK. */
3199 if (dyn_count != 0
3200 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3201 {
3202 bfd_byte *dynbuf, *extdyn, *extdynend;
3203 size_t extdynsize;
3204 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3205
3206 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3207 goto free_contents_and_exit;
3208
3209 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3210 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3211
3212 extdyn = dynbuf;
3213 extdynend = extdyn + dynamic->size;
3214 for (; extdyn < extdynend; extdyn += extdynsize)
3215 {
3216 Elf_Internal_Dyn dyn;
3217 (*swap_dyn_in) (abfd, extdyn, &dyn);
3218
3219 if (dyn.d_tag == DT_NULL)
3220 break;
3221
3222 if (dyn.d_tag == DT_PPC64_GLINK)
3223 {
3224 /* The first glink stub starts at offset 32; see comment in
3225 ppc64_elf_finish_dynamic_sections. */
3226 glink_vma = dyn.d_un.d_val + 32;
3227 /* The .glink section usually does not survive the final
3228 link; search for the section (usually .text) where the
3229 glink stubs now reside. */
3230 glink = bfd_sections_find_if (abfd, section_covers_vma,
3231 &glink_vma);
3232 break;
3233 }
3234 }
3235
3236 free (dynbuf);
3237 }
3238
3239 if (glink != NULL)
3240 {
3241 /* Determine __glink trampoline by reading the relative branch
3242 from the first glink stub. */
3243 bfd_byte buf[4];
3244 if (bfd_get_section_contents (abfd, glink, buf,
3245 glink_vma + 4 - glink->vma, 4))
3246 {
3247 unsigned int insn = bfd_get_32 (abfd, buf);
3248 insn ^= B_DOT;
3249 if ((insn & ~0x3fffffc) == 0)
3250 resolv_vma = glink_vma + 4 + (insn ^ 0x2000000) - 0x2000000;
3251 }
3252
3253 if (resolv_vma)
3254 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3255
3256 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3257 if (relplt != NULL)
3258 {
3259 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3260 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3261 goto free_contents_and_exit;
3262
3263 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3264 size += plt_count * sizeof (asymbol);
3265
3266 p = relplt->relocation;
3267 for (i = 0; i < plt_count; i++, p++)
3268 {
3269 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3270 if (p->addend != 0)
3271 size += sizeof ("+0x") - 1 + 16;
3272 }
3273 }
3274 }
3275
3276 s = *ret = bfd_malloc (size);
3277 if (s == NULL)
3278 goto free_contents_and_exit;
3279
3280 names = (char *) (s + count + plt_count + (resolv_vma != 0));
3281
3282 for (i = secsymend; i < opdsymend; ++i)
3283 {
3284 bfd_vma ent;
3285
3286 if (syms[i]->value > opd->size - 8)
3287 continue;
3288
3289 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3290 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3291 {
3292 long lo, hi;
3293 size_t len;
3294 asection *sec = abfd->sections;
3295
3296 *s = *syms[i];
3297 lo = codesecsym;
3298 hi = codesecsymend;
3299 while (lo < hi)
3300 {
3301 long mid = (lo + hi) >> 1;
3302 if (syms[mid]->section->vma < ent)
3303 lo = mid + 1;
3304 else if (syms[mid]->section->vma > ent)
3305 hi = mid;
3306 else
3307 {
3308 sec = syms[mid]->section;
3309 break;
3310 }
3311 }
3312
3313 if (lo >= hi && lo > codesecsym)
3314 sec = syms[lo - 1]->section;
3315
3316 for (; sec != NULL; sec = sec->next)
3317 {
3318 if (sec->vma > ent)
3319 break;
3320 if ((sec->flags & SEC_ALLOC) == 0
3321 || (sec->flags & SEC_LOAD) == 0)
3322 break;
3323 if ((sec->flags & SEC_CODE) != 0)
3324 s->section = sec;
3325 }
3326 s->flags |= BSF_SYNTHETIC;
3327 s->value = ent - s->section->vma;
3328 s->name = names;
3329 *names++ = '.';
3330 len = strlen (syms[i]->name);
3331 memcpy (names, syms[i]->name, len + 1);
3332 names += len + 1;
3333 /* Have udata.p point back to the original symbol this
3334 synthetic symbol was derived from. */
3335 s->udata.p = syms[i];
3336 s++;
3337 }
3338 }
3339 free (contents);
3340
3341 if (glink != NULL && relplt != NULL)
3342 {
3343 if (resolv_vma)
3344 {
3345 /* Add a symbol for the main glink trampoline. */
3346 memset (s, 0, sizeof *s);
3347 s->the_bfd = abfd;
3348 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3349 s->section = glink;
3350 s->value = resolv_vma - glink->vma;
3351 s->name = names;
3352 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3353 names += sizeof ("__glink_PLTresolve");
3354 s++;
3355 count++;
3356 }
3357
3358 /* FIXME: It would be very much nicer to put sym@plt on the
3359 stub rather than on the glink branch table entry. The
3360 objdump disassembler would then use a sensible symbol
3361 name on plt calls. The difficulty in doing so is
3362 a) finding the stubs, and,
3363 b) matching stubs against plt entries, and,
3364 c) there can be multiple stubs for a given plt entry.
3365
3366 Solving (a) could be done by code scanning, but older
3367 ppc64 binaries used different stubs to current code.
3368 (b) is the tricky one since you need to known the toc
3369 pointer for at least one function that uses a pic stub to
3370 be able to calculate the plt address referenced.
3371 (c) means gdb would need to set multiple breakpoints (or
3372 find the glink branch itself) when setting breakpoints
3373 for pending shared library loads. */
3374 p = relplt->relocation;
3375 for (i = 0; i < plt_count; i++, p++)
3376 {
3377 size_t len;
3378
3379 *s = **p->sym_ptr_ptr;
3380 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3381 we are defining a symbol, ensure one of them is set. */
3382 if ((s->flags & BSF_LOCAL) == 0)
3383 s->flags |= BSF_GLOBAL;
3384 s->flags |= BSF_SYNTHETIC;
3385 s->section = glink;
3386 s->value = glink_vma - glink->vma;
3387 s->name = names;
3388 s->udata.p = NULL;
3389 len = strlen ((*p->sym_ptr_ptr)->name);
3390 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3391 names += len;
3392 if (p->addend != 0)
3393 {
3394 memcpy (names, "+0x", sizeof ("+0x") - 1);
3395 names += sizeof ("+0x") - 1;
3396 bfd_sprintf_vma (abfd, names, p->addend);
3397 names += strlen (names);
3398 }
3399 memcpy (names, "@plt", sizeof ("@plt"));
3400 names += sizeof ("@plt");
3401 s++;
3402 glink_vma += 8;
3403 if (i >= 0x8000)
3404 glink_vma += 4;
3405 }
3406 count += plt_count;
3407 }
3408 }
3409
3410 done:
3411 free (syms);
3412 return count;
3413 }
3414 \f
3415 /* The following functions are specific to the ELF linker, while
3416 functions above are used generally. Those named ppc64_elf_* are
3417 called by the main ELF linker code. They appear in this file more
3418 or less in the order in which they are called. eg.
3419 ppc64_elf_check_relocs is called early in the link process,
3420 ppc64_elf_finish_dynamic_sections is one of the last functions
3421 called.
3422
3423 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3424 functions have both a function code symbol and a function descriptor
3425 symbol. A call to foo in a relocatable object file looks like:
3426
3427 . .text
3428 . x:
3429 . bl .foo
3430 . nop
3431
3432 The function definition in another object file might be:
3433
3434 . .section .opd
3435 . foo: .quad .foo
3436 . .quad .TOC.@tocbase
3437 . .quad 0
3438 .
3439 . .text
3440 . .foo: blr
3441
3442 When the linker resolves the call during a static link, the branch
3443 unsurprisingly just goes to .foo and the .opd information is unused.
3444 If the function definition is in a shared library, things are a little
3445 different: The call goes via a plt call stub, the opd information gets
3446 copied to the plt, and the linker patches the nop.
3447
3448 . x:
3449 . bl .foo_stub
3450 . ld 2,40(1)
3451 .
3452 .
3453 . .foo_stub:
3454 . addis 12,2,Lfoo@toc@ha # in practice, the call stub
3455 . addi 12,12,Lfoo@toc@l # is slightly optimized, but
3456 . std 2,40(1) # this is the general idea
3457 . ld 11,0(12)
3458 . ld 2,8(12)
3459 . mtctr 11
3460 . ld 11,16(12)
3461 . bctr
3462 .
3463 . .section .plt
3464 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3465
3466 The "reloc ()" notation is supposed to indicate that the linker emits
3467 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3468 copying.
3469
3470 What are the difficulties here? Well, firstly, the relocations
3471 examined by the linker in check_relocs are against the function code
3472 sym .foo, while the dynamic relocation in the plt is emitted against
3473 the function descriptor symbol, foo. Somewhere along the line, we need
3474 to carefully copy dynamic link information from one symbol to the other.
3475 Secondly, the generic part of the elf linker will make .foo a dynamic
3476 symbol as is normal for most other backends. We need foo dynamic
3477 instead, at least for an application final link. However, when
3478 creating a shared library containing foo, we need to have both symbols
3479 dynamic so that references to .foo are satisfied during the early
3480 stages of linking. Otherwise the linker might decide to pull in a
3481 definition from some other object, eg. a static library.
3482
3483 Update: As of August 2004, we support a new convention. Function
3484 calls may use the function descriptor symbol, ie. "bl foo". This
3485 behaves exactly as "bl .foo". */
3486
3487 /* The linker needs to keep track of the number of relocs that it
3488 decides to copy as dynamic relocs in check_relocs for each symbol.
3489 This is so that it can later discard them if they are found to be
3490 unnecessary. We store the information in a field extending the
3491 regular ELF linker hash table. */
3492
3493 struct ppc_dyn_relocs
3494 {
3495 struct ppc_dyn_relocs *next;
3496
3497 /* The input section of the reloc. */
3498 asection *sec;
3499
3500 /* Total number of relocs copied for the input section. */
3501 bfd_size_type count;
3502
3503 /* Number of pc-relative relocs copied for the input section. */
3504 bfd_size_type pc_count;
3505 };
3506
3507 /* Of those relocs that might be copied as dynamic relocs, this function
3508 selects those that must be copied when linking a shared library,
3509 even when the symbol is local. */
3510
3511 static int
3512 must_be_dyn_reloc (struct bfd_link_info *info,
3513 enum elf_ppc64_reloc_type r_type)
3514 {
3515 switch (r_type)
3516 {
3517 default:
3518 return 1;
3519
3520 case R_PPC64_REL32:
3521 case R_PPC64_REL64:
3522 case R_PPC64_REL30:
3523 return 0;
3524
3525 case R_PPC64_TPREL16:
3526 case R_PPC64_TPREL16_LO:
3527 case R_PPC64_TPREL16_HI:
3528 case R_PPC64_TPREL16_HA:
3529 case R_PPC64_TPREL16_DS:
3530 case R_PPC64_TPREL16_LO_DS:
3531 case R_PPC64_TPREL16_HIGHER:
3532 case R_PPC64_TPREL16_HIGHERA:
3533 case R_PPC64_TPREL16_HIGHEST:
3534 case R_PPC64_TPREL16_HIGHESTA:
3535 case R_PPC64_TPREL64:
3536 return !info->executable;
3537 }
3538 }
3539
3540 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3541 copying dynamic variables from a shared lib into an app's dynbss
3542 section, and instead use a dynamic relocation to point into the
3543 shared lib. With code that gcc generates, it's vital that this be
3544 enabled; In the PowerPC64 ABI, the address of a function is actually
3545 the address of a function descriptor, which resides in the .opd
3546 section. gcc uses the descriptor directly rather than going via the
3547 GOT as some other ABI's do, which means that initialized function
3548 pointers must reference the descriptor. Thus, a function pointer
3549 initialized to the address of a function in a shared library will
3550 either require a copy reloc, or a dynamic reloc. Using a copy reloc
3551 redefines the function descriptor symbol to point to the copy. This
3552 presents a problem as a plt entry for that function is also
3553 initialized from the function descriptor symbol and the copy reloc
3554 may not be initialized first. */
3555 #define ELIMINATE_COPY_RELOCS 1
3556
3557 /* Section name for stubs is the associated section name plus this
3558 string. */
3559 #define STUB_SUFFIX ".stub"
3560
3561 /* Linker stubs.
3562 ppc_stub_long_branch:
3563 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3564 destination, but a 24 bit branch in a stub section will reach.
3565 . b dest
3566
3567 ppc_stub_plt_branch:
3568 Similar to the above, but a 24 bit branch in the stub section won't
3569 reach its destination.
3570 . addis %r12,%r2,xxx@toc@ha
3571 . ld %r11,xxx@toc@l(%r12)
3572 . mtctr %r11
3573 . bctr
3574
3575 ppc_stub_plt_call:
3576 Used to call a function in a shared library. If it so happens that
3577 the plt entry referenced crosses a 64k boundary, then an extra
3578 "addi %r12,%r12,xxx@toc@l" will be inserted before the "mtctr".
3579 . addis %r12,%r2,xxx@toc@ha
3580 . std %r2,40(%r1)
3581 . ld %r11,xxx+0@toc@l(%r12)
3582 . mtctr %r11
3583 . ld %r2,xxx+8@toc@l(%r12)
3584 . ld %r11,xxx+16@toc@l(%r12)
3585 . bctr
3586
3587 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3588 code to adjust the value and save r2 to support multiple toc sections.
3589 A ppc_stub_long_branch with an r2 offset looks like:
3590 . std %r2,40(%r1)
3591 . addis %r2,%r2,off@ha
3592 . addi %r2,%r2,off@l
3593 . b dest
3594
3595 A ppc_stub_plt_branch with an r2 offset looks like:
3596 . std %r2,40(%r1)
3597 . addis %r12,%r2,xxx@toc@ha
3598 . ld %r11,xxx@toc@l(%r12)
3599 . addis %r2,%r2,off@ha
3600 . addi %r2,%r2,off@l
3601 . mtctr %r11
3602 . bctr
3603
3604 In cases where the "addis" instruction would add zero, the "addis" is
3605 omitted and following instructions modified slightly in some cases.
3606 */
3607
3608 enum ppc_stub_type {
3609 ppc_stub_none,
3610 ppc_stub_long_branch,
3611 ppc_stub_long_branch_r2off,
3612 ppc_stub_plt_branch,
3613 ppc_stub_plt_branch_r2off,
3614 ppc_stub_plt_call
3615 };
3616
3617 struct ppc_stub_hash_entry {
3618
3619 /* Base hash table entry structure. */
3620 struct bfd_hash_entry root;
3621
3622 enum ppc_stub_type stub_type;
3623
3624 /* The stub section. */
3625 asection *stub_sec;
3626
3627 /* Offset within stub_sec of the beginning of this stub. */
3628 bfd_vma stub_offset;
3629
3630 /* Given the symbol's value and its section we can determine its final
3631 value when building the stubs (so the stub knows where to jump. */
3632 bfd_vma target_value;
3633 asection *target_section;
3634
3635 /* The symbol table entry, if any, that this was derived from. */
3636 struct ppc_link_hash_entry *h;
3637 struct plt_entry *plt_ent;
3638
3639 /* And the reloc addend that this was derived from. */
3640 bfd_vma addend;
3641
3642 /* Where this stub is being called from, or, in the case of combined
3643 stub sections, the first input section in the group. */
3644 asection *id_sec;
3645 };
3646
3647 struct ppc_branch_hash_entry {
3648
3649 /* Base hash table entry structure. */
3650 struct bfd_hash_entry root;
3651
3652 /* Offset within branch lookup table. */
3653 unsigned int offset;
3654
3655 /* Generation marker. */
3656 unsigned int iter;
3657 };
3658
3659 struct ppc_link_hash_entry
3660 {
3661 struct elf_link_hash_entry elf;
3662
3663 union {
3664 /* A pointer to the most recently used stub hash entry against this
3665 symbol. */
3666 struct ppc_stub_hash_entry *stub_cache;
3667
3668 /* A pointer to the next symbol starting with a '.' */
3669 struct ppc_link_hash_entry *next_dot_sym;
3670 } u;
3671
3672 /* Track dynamic relocs copied for this symbol. */
3673 struct ppc_dyn_relocs *dyn_relocs;
3674
3675 /* Link between function code and descriptor symbols. */
3676 struct ppc_link_hash_entry *oh;
3677
3678 /* Flag function code and descriptor symbols. */
3679 unsigned int is_func:1;
3680 unsigned int is_func_descriptor:1;
3681 unsigned int fake:1;
3682
3683 /* Whether global opd/toc sym has been adjusted or not.
3684 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3685 should be set for all globals defined in any opd/toc section. */
3686 unsigned int adjust_done:1;
3687
3688 /* Set if we twiddled this symbol to weak at some stage. */
3689 unsigned int was_undefined:1;
3690
3691 /* Contexts in which symbol is used in the GOT (or TOC).
3692 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3693 corresponding relocs are encountered during check_relocs.
3694 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3695 indicate the corresponding GOT entry type is not needed.
3696 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3697 a TPREL one. We use a separate flag rather than setting TPREL
3698 just for convenience in distinguishing the two cases. */
3699 #define TLS_GD 1 /* GD reloc. */
3700 #define TLS_LD 2 /* LD reloc. */
3701 #define TLS_TPREL 4 /* TPREL reloc, => IE. */
3702 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
3703 #define TLS_TLS 16 /* Any TLS reloc. */
3704 #define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
3705 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
3706 #define PLT_IFUNC 128 /* STT_GNU_IFUNC. */
3707 unsigned char tls_mask;
3708 };
3709
3710 /* ppc64 ELF linker hash table. */
3711
3712 struct ppc_link_hash_table
3713 {
3714 struct elf_link_hash_table elf;
3715
3716 /* The stub hash table. */
3717 struct bfd_hash_table stub_hash_table;
3718
3719 /* Another hash table for plt_branch stubs. */
3720 struct bfd_hash_table branch_hash_table;
3721
3722 /* Linker stub bfd. */
3723 bfd *stub_bfd;
3724
3725 /* Linker call-backs. */
3726 asection * (*add_stub_section) (const char *, asection *);
3727 void (*layout_sections_again) (void);
3728
3729 /* Array to keep track of which stub sections have been created, and
3730 information on stub grouping. */
3731 struct map_stub {
3732 /* This is the section to which stubs in the group will be attached. */
3733 asection *link_sec;
3734 /* The stub section. */
3735 asection *stub_sec;
3736 /* Along with elf_gp, specifies the TOC pointer used in this group. */
3737 bfd_vma toc_off;
3738 } *stub_group;
3739
3740 /* Temp used when calculating TOC pointers. */
3741 bfd_vma toc_curr;
3742 bfd *toc_bfd;
3743 asection *toc_first_sec;
3744
3745 /* Highest input section id. */
3746 int top_id;
3747
3748 /* Highest output section index. */
3749 int top_index;
3750
3751 /* Used when adding symbols. */
3752 struct ppc_link_hash_entry *dot_syms;
3753
3754 /* List of input sections for each output section. */
3755 asection **input_list;
3756
3757 /* Short-cuts to get to dynamic linker sections. */
3758 asection *got;
3759 asection *plt;
3760 asection *relplt;
3761 asection *iplt;
3762 asection *reliplt;
3763 asection *dynbss;
3764 asection *relbss;
3765 asection *glink;
3766 asection *sfpr;
3767 asection *brlt;
3768 asection *relbrlt;
3769
3770 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
3771 struct ppc_link_hash_entry *tls_get_addr;
3772 struct ppc_link_hash_entry *tls_get_addr_fd;
3773
3774 /* The size of reliplt used by got entry relocs. */
3775 bfd_size_type got_reli_size;
3776
3777 /* Statistics. */
3778 unsigned long stub_count[ppc_stub_plt_call];
3779
3780 /* Number of stubs against global syms. */
3781 unsigned long stub_globals;
3782
3783 /* Set if we should emit symbols for stubs. */
3784 unsigned int emit_stub_syms:1;
3785
3786 /* Set if __tls_get_addr optimization should not be done. */
3787 unsigned int no_tls_get_addr_opt:1;
3788
3789 /* Support for multiple toc sections. */
3790 unsigned int do_multi_toc:1;
3791 unsigned int multi_toc_needed:1;
3792 unsigned int second_toc_pass:1;
3793 unsigned int do_toc_opt:1;
3794
3795 /* Set on error. */
3796 unsigned int stub_error:1;
3797
3798 /* Temp used by ppc64_elf_process_dot_syms. */
3799 unsigned int twiddled_syms:1;
3800
3801 /* Incremented every time we size stubs. */
3802 unsigned int stub_iteration;
3803
3804 /* Small local sym cache. */
3805 struct sym_cache sym_cache;
3806 };
3807
3808 /* Rename some of the generic section flags to better document how they
3809 are used here. */
3810
3811 /* Nonzero if this section has TLS related relocations. */
3812 #define has_tls_reloc sec_flg0
3813
3814 /* Nonzero if this section has a call to __tls_get_addr. */
3815 #define has_tls_get_addr_call sec_flg1
3816
3817 /* Nonzero if this section has any toc or got relocs. */
3818 #define has_toc_reloc sec_flg2
3819
3820 /* Nonzero if this section has a call to another section that uses
3821 the toc or got. */
3822 #define makes_toc_func_call sec_flg3
3823
3824 /* Recursion protection when determining above flag. */
3825 #define call_check_in_progress sec_flg4
3826 #define call_check_done sec_flg5
3827
3828 /* Get the ppc64 ELF linker hash table from a link_info structure. */
3829
3830 #define ppc_hash_table(p) \
3831 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3832 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3833
3834 #define ppc_stub_hash_lookup(table, string, create, copy) \
3835 ((struct ppc_stub_hash_entry *) \
3836 bfd_hash_lookup ((table), (string), (create), (copy)))
3837
3838 #define ppc_branch_hash_lookup(table, string, create, copy) \
3839 ((struct ppc_branch_hash_entry *) \
3840 bfd_hash_lookup ((table), (string), (create), (copy)))
3841
3842 /* Create an entry in the stub hash table. */
3843
3844 static struct bfd_hash_entry *
3845 stub_hash_newfunc (struct bfd_hash_entry *entry,
3846 struct bfd_hash_table *table,
3847 const char *string)
3848 {
3849 /* Allocate the structure if it has not already been allocated by a
3850 subclass. */
3851 if (entry == NULL)
3852 {
3853 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
3854 if (entry == NULL)
3855 return entry;
3856 }
3857
3858 /* Call the allocation method of the superclass. */
3859 entry = bfd_hash_newfunc (entry, table, string);
3860 if (entry != NULL)
3861 {
3862 struct ppc_stub_hash_entry *eh;
3863
3864 /* Initialize the local fields. */
3865 eh = (struct ppc_stub_hash_entry *) entry;
3866 eh->stub_type = ppc_stub_none;
3867 eh->stub_sec = NULL;
3868 eh->stub_offset = 0;
3869 eh->target_value = 0;
3870 eh->target_section = NULL;
3871 eh->h = NULL;
3872 eh->id_sec = NULL;
3873 }
3874
3875 return entry;
3876 }
3877
3878 /* Create an entry in the branch hash table. */
3879
3880 static struct bfd_hash_entry *
3881 branch_hash_newfunc (struct bfd_hash_entry *entry,
3882 struct bfd_hash_table *table,
3883 const char *string)
3884 {
3885 /* Allocate the structure if it has not already been allocated by a
3886 subclass. */
3887 if (entry == NULL)
3888 {
3889 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
3890 if (entry == NULL)
3891 return entry;
3892 }
3893
3894 /* Call the allocation method of the superclass. */
3895 entry = bfd_hash_newfunc (entry, table, string);
3896 if (entry != NULL)
3897 {
3898 struct ppc_branch_hash_entry *eh;
3899
3900 /* Initialize the local fields. */
3901 eh = (struct ppc_branch_hash_entry *) entry;
3902 eh->offset = 0;
3903 eh->iter = 0;
3904 }
3905
3906 return entry;
3907 }
3908
3909 /* Create an entry in a ppc64 ELF linker hash table. */
3910
3911 static struct bfd_hash_entry *
3912 link_hash_newfunc (struct bfd_hash_entry *entry,
3913 struct bfd_hash_table *table,
3914 const char *string)
3915 {
3916 /* Allocate the structure if it has not already been allocated by a
3917 subclass. */
3918 if (entry == NULL)
3919 {
3920 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
3921 if (entry == NULL)
3922 return entry;
3923 }
3924
3925 /* Call the allocation method of the superclass. */
3926 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
3927 if (entry != NULL)
3928 {
3929 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
3930
3931 memset (&eh->u.stub_cache, 0,
3932 (sizeof (struct ppc_link_hash_entry)
3933 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
3934
3935 /* When making function calls, old ABI code references function entry
3936 points (dot symbols), while new ABI code references the function
3937 descriptor symbol. We need to make any combination of reference and
3938 definition work together, without breaking archive linking.
3939
3940 For a defined function "foo" and an undefined call to "bar":
3941 An old object defines "foo" and ".foo", references ".bar" (possibly
3942 "bar" too).
3943 A new object defines "foo" and references "bar".
3944
3945 A new object thus has no problem with its undefined symbols being
3946 satisfied by definitions in an old object. On the other hand, the
3947 old object won't have ".bar" satisfied by a new object.
3948
3949 Keep a list of newly added dot-symbols. */
3950
3951 if (string[0] == '.')
3952 {
3953 struct ppc_link_hash_table *htab;
3954
3955 htab = (struct ppc_link_hash_table *) table;
3956 eh->u.next_dot_sym = htab->dot_syms;
3957 htab->dot_syms = eh;
3958 }
3959 }
3960
3961 return entry;
3962 }
3963
3964 /* Create a ppc64 ELF linker hash table. */
3965
3966 static struct bfd_link_hash_table *
3967 ppc64_elf_link_hash_table_create (bfd *abfd)
3968 {
3969 struct ppc_link_hash_table *htab;
3970 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
3971
3972 htab = bfd_zmalloc (amt);
3973 if (htab == NULL)
3974 return NULL;
3975
3976 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
3977 sizeof (struct ppc_link_hash_entry),
3978 PPC64_ELF_DATA))
3979 {
3980 free (htab);
3981 return NULL;
3982 }
3983
3984 /* Init the stub hash table too. */
3985 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
3986 sizeof (struct ppc_stub_hash_entry)))
3987 return NULL;
3988
3989 /* And the branch hash table. */
3990 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
3991 sizeof (struct ppc_branch_hash_entry)))
3992 return NULL;
3993
3994 /* Initializing two fields of the union is just cosmetic. We really
3995 only care about glist, but when compiled on a 32-bit host the
3996 bfd_vma fields are larger. Setting the bfd_vma to zero makes
3997 debugger inspection of these fields look nicer. */
3998 htab->elf.init_got_refcount.refcount = 0;
3999 htab->elf.init_got_refcount.glist = NULL;
4000 htab->elf.init_plt_refcount.refcount = 0;
4001 htab->elf.init_plt_refcount.glist = NULL;
4002 htab->elf.init_got_offset.offset = 0;
4003 htab->elf.init_got_offset.glist = NULL;
4004 htab->elf.init_plt_offset.offset = 0;
4005 htab->elf.init_plt_offset.glist = NULL;
4006
4007 return &htab->elf.root;
4008 }
4009
4010 /* Free the derived linker hash table. */
4011
4012 static void
4013 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
4014 {
4015 struct ppc_link_hash_table *ret = (struct ppc_link_hash_table *) hash;
4016
4017 bfd_hash_table_free (&ret->stub_hash_table);
4018 bfd_hash_table_free (&ret->branch_hash_table);
4019 _bfd_generic_link_hash_table_free (hash);
4020 }
4021
4022 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4023
4024 void
4025 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
4026 {
4027 struct ppc_link_hash_table *htab;
4028
4029 elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
4030
4031 /* Always hook our dynamic sections into the first bfd, which is the
4032 linker created stub bfd. This ensures that the GOT header is at
4033 the start of the output TOC section. */
4034 htab = ppc_hash_table (info);
4035 if (htab == NULL)
4036 return;
4037 htab->stub_bfd = abfd;
4038 htab->elf.dynobj = abfd;
4039 }
4040
4041 /* Build a name for an entry in the stub hash table. */
4042
4043 static char *
4044 ppc_stub_name (const asection *input_section,
4045 const asection *sym_sec,
4046 const struct ppc_link_hash_entry *h,
4047 const Elf_Internal_Rela *rel)
4048 {
4049 char *stub_name;
4050 bfd_size_type len;
4051
4052 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4053 offsets from a sym as a branch target? In fact, we could
4054 probably assume the addend is always zero. */
4055 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4056
4057 if (h)
4058 {
4059 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4060 stub_name = bfd_malloc (len);
4061 if (stub_name == NULL)
4062 return stub_name;
4063
4064 sprintf (stub_name, "%08x.%s+%x",
4065 input_section->id & 0xffffffff,
4066 h->elf.root.root.string,
4067 (int) rel->r_addend & 0xffffffff);
4068 }
4069 else
4070 {
4071 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4072 stub_name = bfd_malloc (len);
4073 if (stub_name == NULL)
4074 return stub_name;
4075
4076 sprintf (stub_name, "%08x.%x:%x+%x",
4077 input_section->id & 0xffffffff,
4078 sym_sec->id & 0xffffffff,
4079 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4080 (int) rel->r_addend & 0xffffffff);
4081 }
4082 if (stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4083 stub_name[len - 2] = 0;
4084 return stub_name;
4085 }
4086
4087 /* Look up an entry in the stub hash. Stub entries are cached because
4088 creating the stub name takes a bit of time. */
4089
4090 static struct ppc_stub_hash_entry *
4091 ppc_get_stub_entry (const asection *input_section,
4092 const asection *sym_sec,
4093 struct ppc_link_hash_entry *h,
4094 const Elf_Internal_Rela *rel,
4095 struct ppc_link_hash_table *htab)
4096 {
4097 struct ppc_stub_hash_entry *stub_entry;
4098 const asection *id_sec;
4099
4100 /* If this input section is part of a group of sections sharing one
4101 stub section, then use the id of the first section in the group.
4102 Stub names need to include a section id, as there may well be
4103 more than one stub used to reach say, printf, and we need to
4104 distinguish between them. */
4105 id_sec = htab->stub_group[input_section->id].link_sec;
4106
4107 if (h != NULL && h->u.stub_cache != NULL
4108 && h->u.stub_cache->h == h
4109 && h->u.stub_cache->id_sec == id_sec)
4110 {
4111 stub_entry = h->u.stub_cache;
4112 }
4113 else
4114 {
4115 char *stub_name;
4116
4117 stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4118 if (stub_name == NULL)
4119 return NULL;
4120
4121 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4122 stub_name, FALSE, FALSE);
4123 if (h != NULL)
4124 h->u.stub_cache = stub_entry;
4125
4126 free (stub_name);
4127 }
4128
4129 return stub_entry;
4130 }
4131
4132 /* Add a new stub entry to the stub hash. Not all fields of the new
4133 stub entry are initialised. */
4134
4135 static struct ppc_stub_hash_entry *
4136 ppc_add_stub (const char *stub_name,
4137 asection *section,
4138 struct ppc_link_hash_table *htab)
4139 {
4140 asection *link_sec;
4141 asection *stub_sec;
4142 struct ppc_stub_hash_entry *stub_entry;
4143
4144 link_sec = htab->stub_group[section->id].link_sec;
4145 stub_sec = htab->stub_group[section->id].stub_sec;
4146 if (stub_sec == NULL)
4147 {
4148 stub_sec = htab->stub_group[link_sec->id].stub_sec;
4149 if (stub_sec == NULL)
4150 {
4151 size_t namelen;
4152 bfd_size_type len;
4153 char *s_name;
4154
4155 namelen = strlen (link_sec->name);
4156 len = namelen + sizeof (STUB_SUFFIX);
4157 s_name = bfd_alloc (htab->stub_bfd, len);
4158 if (s_name == NULL)
4159 return NULL;
4160
4161 memcpy (s_name, link_sec->name, namelen);
4162 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4163 stub_sec = (*htab->add_stub_section) (s_name, link_sec);
4164 if (stub_sec == NULL)
4165 return NULL;
4166 htab->stub_group[link_sec->id].stub_sec = stub_sec;
4167 }
4168 htab->stub_group[section->id].stub_sec = stub_sec;
4169 }
4170
4171 /* Enter this entry into the linker stub hash table. */
4172 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4173 TRUE, FALSE);
4174 if (stub_entry == NULL)
4175 {
4176 (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
4177 section->owner, stub_name);
4178 return NULL;
4179 }
4180
4181 stub_entry->stub_sec = stub_sec;
4182 stub_entry->stub_offset = 0;
4183 stub_entry->id_sec = link_sec;
4184 return stub_entry;
4185 }
4186
4187 /* Create sections for linker generated code. */
4188
4189 static bfd_boolean
4190 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4191 {
4192 struct ppc_link_hash_table *htab;
4193 flagword flags;
4194
4195 htab = ppc_hash_table (info);
4196 if (htab == NULL)
4197 return FALSE;
4198
4199 /* Create .sfpr for code to save and restore fp regs. */
4200 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4201 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4202 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4203 flags);
4204 if (htab->sfpr == NULL
4205 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4206 return FALSE;
4207
4208 /* Create .glink for lazy dynamic linking support. */
4209 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4210 flags);
4211 if (htab->glink == NULL
4212 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4213 return FALSE;
4214
4215 flags = SEC_ALLOC | SEC_LINKER_CREATED;
4216 htab->iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4217 if (htab->iplt == NULL
4218 || ! bfd_set_section_alignment (dynobj, htab->iplt, 3))
4219 return FALSE;
4220
4221 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4222 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4223 htab->reliplt = bfd_make_section_anyway_with_flags (dynobj,
4224 ".rela.iplt",
4225 flags);
4226 if (htab->reliplt == NULL
4227 || ! bfd_set_section_alignment (dynobj, htab->reliplt, 3))
4228 return FALSE;
4229
4230 /* Create branch lookup table for plt_branch stubs. */
4231 flags = (SEC_ALLOC | SEC_LOAD
4232 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4233 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4234 flags);
4235 if (htab->brlt == NULL
4236 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4237 return FALSE;
4238
4239 if (!info->shared)
4240 return TRUE;
4241
4242 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4243 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4244 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4245 ".rela.branch_lt",
4246 flags);
4247 if (htab->relbrlt == NULL
4248 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4249 return FALSE;
4250
4251 return TRUE;
4252 }
4253
4254 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4255 not already done. */
4256
4257 static bfd_boolean
4258 create_got_section (bfd *abfd, struct bfd_link_info *info)
4259 {
4260 asection *got, *relgot;
4261 flagword flags;
4262 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4263
4264 if (!is_ppc64_elf (abfd))
4265 return FALSE;
4266 if (htab == NULL)
4267 return FALSE;
4268
4269 if (!htab->got)
4270 {
4271 if (! _bfd_elf_create_got_section (htab->elf.dynobj, info))
4272 return FALSE;
4273
4274 htab->got = bfd_get_section_by_name (htab->elf.dynobj, ".got");
4275 if (!htab->got)
4276 abort ();
4277 }
4278
4279 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4280 | SEC_LINKER_CREATED);
4281
4282 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4283 if (!got
4284 || !bfd_set_section_alignment (abfd, got, 3))
4285 return FALSE;
4286
4287 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4288 flags | SEC_READONLY);
4289 if (!relgot
4290 || ! bfd_set_section_alignment (abfd, relgot, 3))
4291 return FALSE;
4292
4293 ppc64_elf_tdata (abfd)->got = got;
4294 ppc64_elf_tdata (abfd)->relgot = relgot;
4295 return TRUE;
4296 }
4297
4298 /* Create the dynamic sections, and set up shortcuts. */
4299
4300 static bfd_boolean
4301 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4302 {
4303 struct ppc_link_hash_table *htab;
4304
4305 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4306 return FALSE;
4307
4308 htab = ppc_hash_table (info);
4309 if (htab == NULL)
4310 return FALSE;
4311
4312 if (!htab->got)
4313 htab->got = bfd_get_section_by_name (dynobj, ".got");
4314 htab->plt = bfd_get_section_by_name (dynobj, ".plt");
4315 htab->relplt = bfd_get_section_by_name (dynobj, ".rela.plt");
4316 htab->dynbss = bfd_get_section_by_name (dynobj, ".dynbss");
4317 if (!info->shared)
4318 htab->relbss = bfd_get_section_by_name (dynobj, ".rela.bss");
4319
4320 if (!htab->got || !htab->plt || !htab->relplt || !htab->dynbss
4321 || (!info->shared && !htab->relbss))
4322 abort ();
4323
4324 return TRUE;
4325 }
4326
4327 /* Follow indirect and warning symbol links. */
4328
4329 static inline struct bfd_link_hash_entry *
4330 follow_link (struct bfd_link_hash_entry *h)
4331 {
4332 while (h->type == bfd_link_hash_indirect
4333 || h->type == bfd_link_hash_warning)
4334 h = h->u.i.link;
4335 return h;
4336 }
4337
4338 static inline struct elf_link_hash_entry *
4339 elf_follow_link (struct elf_link_hash_entry *h)
4340 {
4341 return (struct elf_link_hash_entry *) follow_link (&h->root);
4342 }
4343
4344 static inline struct ppc_link_hash_entry *
4345 ppc_follow_link (struct ppc_link_hash_entry *h)
4346 {
4347 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4348 }
4349
4350 /* Merge PLT info on FROM with that on TO. */
4351
4352 static void
4353 move_plt_plist (struct ppc_link_hash_entry *from,
4354 struct ppc_link_hash_entry *to)
4355 {
4356 if (from->elf.plt.plist != NULL)
4357 {
4358 if (to->elf.plt.plist != NULL)
4359 {
4360 struct plt_entry **entp;
4361 struct plt_entry *ent;
4362
4363 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4364 {
4365 struct plt_entry *dent;
4366
4367 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4368 if (dent->addend == ent->addend)
4369 {
4370 dent->plt.refcount += ent->plt.refcount;
4371 *entp = ent->next;
4372 break;
4373 }
4374 if (dent == NULL)
4375 entp = &ent->next;
4376 }
4377 *entp = to->elf.plt.plist;
4378 }
4379
4380 to->elf.plt.plist = from->elf.plt.plist;
4381 from->elf.plt.plist = NULL;
4382 }
4383 }
4384
4385 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4386
4387 static void
4388 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4389 struct elf_link_hash_entry *dir,
4390 struct elf_link_hash_entry *ind)
4391 {
4392 struct ppc_link_hash_entry *edir, *eind;
4393
4394 edir = (struct ppc_link_hash_entry *) dir;
4395 eind = (struct ppc_link_hash_entry *) ind;
4396
4397 /* Copy over any dynamic relocs we may have on the indirect sym. */
4398 if (eind->dyn_relocs != NULL)
4399 {
4400 if (edir->dyn_relocs != NULL)
4401 {
4402 struct ppc_dyn_relocs **pp;
4403 struct ppc_dyn_relocs *p;
4404
4405 /* Add reloc counts against the indirect sym to the direct sym
4406 list. Merge any entries against the same section. */
4407 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4408 {
4409 struct ppc_dyn_relocs *q;
4410
4411 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4412 if (q->sec == p->sec)
4413 {
4414 q->pc_count += p->pc_count;
4415 q->count += p->count;
4416 *pp = p->next;
4417 break;
4418 }
4419 if (q == NULL)
4420 pp = &p->next;
4421 }
4422 *pp = edir->dyn_relocs;
4423 }
4424
4425 edir->dyn_relocs = eind->dyn_relocs;
4426 eind->dyn_relocs = NULL;
4427 }
4428
4429 edir->is_func |= eind->is_func;
4430 edir->is_func_descriptor |= eind->is_func_descriptor;
4431 edir->tls_mask |= eind->tls_mask;
4432 if (eind->oh != NULL)
4433 edir->oh = ppc_follow_link (eind->oh);
4434
4435 /* If called to transfer flags for a weakdef during processing
4436 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4437 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
4438 if (!(ELIMINATE_COPY_RELOCS
4439 && eind->elf.root.type != bfd_link_hash_indirect
4440 && edir->elf.dynamic_adjusted))
4441 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4442
4443 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4444 edir->elf.ref_regular |= eind->elf.ref_regular;
4445 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4446 edir->elf.needs_plt |= eind->elf.needs_plt;
4447
4448 /* If we were called to copy over info for a weak sym, that's all. */
4449 if (eind->elf.root.type != bfd_link_hash_indirect)
4450 return;
4451
4452 /* Copy over got entries that we may have already seen to the
4453 symbol which just became indirect. */
4454 if (eind->elf.got.glist != NULL)
4455 {
4456 if (edir->elf.got.glist != NULL)
4457 {
4458 struct got_entry **entp;
4459 struct got_entry *ent;
4460
4461 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4462 {
4463 struct got_entry *dent;
4464
4465 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4466 if (dent->addend == ent->addend
4467 && dent->owner == ent->owner
4468 && dent->tls_type == ent->tls_type)
4469 {
4470 dent->got.refcount += ent->got.refcount;
4471 *entp = ent->next;
4472 break;
4473 }
4474 if (dent == NULL)
4475 entp = &ent->next;
4476 }
4477 *entp = edir->elf.got.glist;
4478 }
4479
4480 edir->elf.got.glist = eind->elf.got.glist;
4481 eind->elf.got.glist = NULL;
4482 }
4483
4484 /* And plt entries. */
4485 move_plt_plist (eind, edir);
4486
4487 if (eind->elf.dynindx != -1)
4488 {
4489 if (edir->elf.dynindx != -1)
4490 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4491 edir->elf.dynstr_index);
4492 edir->elf.dynindx = eind->elf.dynindx;
4493 edir->elf.dynstr_index = eind->elf.dynstr_index;
4494 eind->elf.dynindx = -1;
4495 eind->elf.dynstr_index = 0;
4496 }
4497 }
4498
4499 /* Find the function descriptor hash entry from the given function code
4500 hash entry FH. Link the entries via their OH fields. */
4501
4502 static struct ppc_link_hash_entry *
4503 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4504 {
4505 struct ppc_link_hash_entry *fdh = fh->oh;
4506
4507 if (fdh == NULL)
4508 {
4509 const char *fd_name = fh->elf.root.root.string + 1;
4510
4511 fdh = (struct ppc_link_hash_entry *)
4512 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4513 if (fdh == NULL)
4514 return fdh;
4515
4516 fdh->is_func_descriptor = 1;
4517 fdh->oh = fh;
4518 fh->is_func = 1;
4519 fh->oh = fdh;
4520 }
4521
4522 return ppc_follow_link (fdh);
4523 }
4524
4525 /* Make a fake function descriptor sym for the code sym FH. */
4526
4527 static struct ppc_link_hash_entry *
4528 make_fdh (struct bfd_link_info *info,
4529 struct ppc_link_hash_entry *fh)
4530 {
4531 bfd *abfd;
4532 asymbol *newsym;
4533 struct bfd_link_hash_entry *bh;
4534 struct ppc_link_hash_entry *fdh;
4535
4536 abfd = fh->elf.root.u.undef.abfd;
4537 newsym = bfd_make_empty_symbol (abfd);
4538 newsym->name = fh->elf.root.root.string + 1;
4539 newsym->section = bfd_und_section_ptr;
4540 newsym->value = 0;
4541 newsym->flags = BSF_WEAK;
4542
4543 bh = NULL;
4544 if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4545 newsym->flags, newsym->section,
4546 newsym->value, NULL, FALSE, FALSE,
4547 &bh))
4548 return NULL;
4549
4550 fdh = (struct ppc_link_hash_entry *) bh;
4551 fdh->elf.non_elf = 0;
4552 fdh->fake = 1;
4553 fdh->is_func_descriptor = 1;
4554 fdh->oh = fh;
4555 fh->is_func = 1;
4556 fh->oh = fdh;
4557 return fdh;
4558 }
4559
4560 /* Fix function descriptor symbols defined in .opd sections to be
4561 function type. */
4562
4563 static bfd_boolean
4564 ppc64_elf_add_symbol_hook (bfd *ibfd,
4565 struct bfd_link_info *info,
4566 Elf_Internal_Sym *isym,
4567 const char **name ATTRIBUTE_UNUSED,
4568 flagword *flags ATTRIBUTE_UNUSED,
4569 asection **sec,
4570 bfd_vma *value ATTRIBUTE_UNUSED)
4571 {
4572 if ((ibfd->flags & DYNAMIC) == 0
4573 && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4574 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4575
4576 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4577 {
4578 if ((ibfd->flags & DYNAMIC) == 0)
4579 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4580 }
4581 else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4582 ;
4583 else if (*sec != NULL
4584 && strcmp ((*sec)->name, ".opd") == 0)
4585 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4586
4587 return TRUE;
4588 }
4589
4590 /* This function makes an old ABI object reference to ".bar" cause the
4591 inclusion of a new ABI object archive that defines "bar".
4592 NAME is a symbol defined in an archive. Return a symbol in the hash
4593 table that might be satisfied by the archive symbols. */
4594
4595 static struct elf_link_hash_entry *
4596 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4597 struct bfd_link_info *info,
4598 const char *name)
4599 {
4600 struct elf_link_hash_entry *h;
4601 char *dot_name;
4602 size_t len;
4603
4604 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4605 if (h != NULL
4606 /* Don't return this sym if it is a fake function descriptor
4607 created by add_symbol_adjust. */
4608 && !(h->root.type == bfd_link_hash_undefweak
4609 && ((struct ppc_link_hash_entry *) h)->fake))
4610 return h;
4611
4612 if (name[0] == '.')
4613 return h;
4614
4615 len = strlen (name);
4616 dot_name = bfd_alloc (abfd, len + 2);
4617 if (dot_name == NULL)
4618 return (struct elf_link_hash_entry *) 0 - 1;
4619 dot_name[0] = '.';
4620 memcpy (dot_name + 1, name, len + 1);
4621 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4622 bfd_release (abfd, dot_name);
4623 return h;
4624 }
4625
4626 /* This function satisfies all old ABI object references to ".bar" if a
4627 new ABI object defines "bar". Well, at least, undefined dot symbols
4628 are made weak. This stops later archive searches from including an
4629 object if we already have a function descriptor definition. It also
4630 prevents the linker complaining about undefined symbols.
4631 We also check and correct mismatched symbol visibility here. The
4632 most restrictive visibility of the function descriptor and the
4633 function entry symbol is used. */
4634
4635 static bfd_boolean
4636 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4637 {
4638 struct ppc_link_hash_table *htab;
4639 struct ppc_link_hash_entry *fdh;
4640
4641 if (eh->elf.root.type == bfd_link_hash_indirect)
4642 return TRUE;
4643
4644 if (eh->elf.root.type == bfd_link_hash_warning)
4645 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4646
4647 if (eh->elf.root.root.string[0] != '.')
4648 abort ();
4649
4650 htab = ppc_hash_table (info);
4651 if (htab == NULL)
4652 return FALSE;
4653
4654 fdh = lookup_fdh (eh, htab);
4655 if (fdh == NULL)
4656 {
4657 if (!info->relocatable
4658 && (eh->elf.root.type == bfd_link_hash_undefined
4659 || eh->elf.root.type == bfd_link_hash_undefweak)
4660 && eh->elf.ref_regular)
4661 {
4662 /* Make an undefweak function descriptor sym, which is enough to
4663 pull in an --as-needed shared lib, but won't cause link
4664 errors. Archives are handled elsewhere. */
4665 fdh = make_fdh (info, eh);
4666 if (fdh == NULL)
4667 return FALSE;
4668 fdh->elf.ref_regular = 1;
4669 }
4670 }
4671 else
4672 {
4673 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4674 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4675 if (entry_vis < descr_vis)
4676 fdh->elf.other += entry_vis - descr_vis;
4677 else if (entry_vis > descr_vis)
4678 eh->elf.other += descr_vis - entry_vis;
4679
4680 if ((fdh->elf.root.type == bfd_link_hash_defined
4681 || fdh->elf.root.type == bfd_link_hash_defweak)
4682 && eh->elf.root.type == bfd_link_hash_undefined)
4683 {
4684 eh->elf.root.type = bfd_link_hash_undefweak;
4685 eh->was_undefined = 1;
4686 htab->twiddled_syms = 1;
4687 }
4688 }
4689
4690 return TRUE;
4691 }
4692
4693 /* Process list of dot-symbols we made in link_hash_newfunc. */
4694
4695 static bfd_boolean
4696 ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
4697 {
4698 struct ppc_link_hash_table *htab;
4699 struct ppc_link_hash_entry **p, *eh;
4700
4701 if (!is_ppc64_elf (info->output_bfd))
4702 return TRUE;
4703 htab = ppc_hash_table (info);
4704 if (htab == NULL)
4705 return FALSE;
4706
4707 if (is_ppc64_elf (ibfd))
4708 {
4709 p = &htab->dot_syms;
4710 while ((eh = *p) != NULL)
4711 {
4712 *p = NULL;
4713 if (!add_symbol_adjust (eh, info))
4714 return FALSE;
4715 p = &eh->u.next_dot_sym;
4716 }
4717 }
4718
4719 /* Clear the list for non-ppc64 input files. */
4720 p = &htab->dot_syms;
4721 while ((eh = *p) != NULL)
4722 {
4723 *p = NULL;
4724 p = &eh->u.next_dot_sym;
4725 }
4726
4727 /* We need to fix the undefs list for any syms we have twiddled to
4728 undef_weak. */
4729 if (htab->twiddled_syms)
4730 {
4731 bfd_link_repair_undef_list (&htab->elf.root);
4732 htab->twiddled_syms = 0;
4733 }
4734 return TRUE;
4735 }
4736
4737 /* Undo hash table changes when an --as-needed input file is determined
4738 not to be needed. */
4739
4740 static bfd_boolean
4741 ppc64_elf_as_needed_cleanup (bfd *ibfd ATTRIBUTE_UNUSED,
4742 struct bfd_link_info *info)
4743 {
4744 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4745
4746 if (htab == NULL)
4747 return FALSE;
4748
4749 htab->dot_syms = NULL;
4750 return TRUE;
4751 }
4752
4753 /* If --just-symbols against a final linked binary, then assume we need
4754 toc adjusting stubs when calling functions defined there. */
4755
4756 static void
4757 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
4758 {
4759 if ((sec->flags & SEC_CODE) != 0
4760 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
4761 && is_ppc64_elf (sec->owner))
4762 {
4763 asection *got = bfd_get_section_by_name (sec->owner, ".got");
4764 if (got != NULL
4765 && got->size >= elf_backend_got_header_size
4766 && bfd_get_section_by_name (sec->owner, ".opd") != NULL)
4767 sec->has_toc_reloc = 1;
4768 }
4769 _bfd_elf_link_just_syms (sec, info);
4770 }
4771
4772 static struct plt_entry **
4773 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
4774 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
4775 {
4776 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
4777 struct plt_entry **local_plt;
4778 unsigned char *local_got_tls_masks;
4779
4780 if (local_got_ents == NULL)
4781 {
4782 bfd_size_type size = symtab_hdr->sh_info;
4783
4784 size *= (sizeof (*local_got_ents)
4785 + sizeof (*local_plt)
4786 + sizeof (*local_got_tls_masks));
4787 local_got_ents = bfd_zalloc (abfd, size);
4788 if (local_got_ents == NULL)
4789 return NULL;
4790 elf_local_got_ents (abfd) = local_got_ents;
4791 }
4792
4793 if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
4794 {
4795 struct got_entry *ent;
4796
4797 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
4798 if (ent->addend == r_addend
4799 && ent->owner == abfd
4800 && ent->tls_type == tls_type)
4801 break;
4802 if (ent == NULL)
4803 {
4804 bfd_size_type amt = sizeof (*ent);
4805 ent = bfd_alloc (abfd, amt);
4806 if (ent == NULL)
4807 return FALSE;
4808 ent->next = local_got_ents[r_symndx];
4809 ent->addend = r_addend;
4810 ent->owner = abfd;
4811 ent->tls_type = tls_type;
4812 ent->is_indirect = FALSE;
4813 ent->got.refcount = 0;
4814 local_got_ents[r_symndx] = ent;
4815 }
4816 ent->got.refcount += 1;
4817 }
4818
4819 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
4820 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
4821 local_got_tls_masks[r_symndx] |= tls_type;
4822
4823 return local_plt + r_symndx;
4824 }
4825
4826 static bfd_boolean
4827 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
4828 {
4829 struct plt_entry *ent;
4830
4831 for (ent = *plist; ent != NULL; ent = ent->next)
4832 if (ent->addend == addend)
4833 break;
4834 if (ent == NULL)
4835 {
4836 bfd_size_type amt = sizeof (*ent);
4837 ent = bfd_alloc (abfd, amt);
4838 if (ent == NULL)
4839 return FALSE;
4840 ent->next = *plist;
4841 ent->addend = addend;
4842 ent->plt.refcount = 0;
4843 *plist = ent;
4844 }
4845 ent->plt.refcount += 1;
4846 return TRUE;
4847 }
4848
4849 static bfd_boolean
4850 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
4851 {
4852 return (r_type == R_PPC64_REL24
4853 || r_type == R_PPC64_REL14
4854 || r_type == R_PPC64_REL14_BRTAKEN
4855 || r_type == R_PPC64_REL14_BRNTAKEN
4856 || r_type == R_PPC64_ADDR24
4857 || r_type == R_PPC64_ADDR14
4858 || r_type == R_PPC64_ADDR14_BRTAKEN
4859 || r_type == R_PPC64_ADDR14_BRNTAKEN);
4860 }
4861
4862 /* Look through the relocs for a section during the first phase, and
4863 calculate needed space in the global offset table, procedure
4864 linkage table, and dynamic reloc sections. */
4865
4866 static bfd_boolean
4867 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
4868 asection *sec, const Elf_Internal_Rela *relocs)
4869 {
4870 struct ppc_link_hash_table *htab;
4871 Elf_Internal_Shdr *symtab_hdr;
4872 struct elf_link_hash_entry **sym_hashes;
4873 const Elf_Internal_Rela *rel;
4874 const Elf_Internal_Rela *rel_end;
4875 asection *sreloc;
4876 asection **opd_sym_map;
4877 struct elf_link_hash_entry *tga, *dottga;
4878
4879 if (info->relocatable)
4880 return TRUE;
4881
4882 /* Don't do anything special with non-loaded, non-alloced sections.
4883 In particular, any relocs in such sections should not affect GOT
4884 and PLT reference counting (ie. we don't allow them to create GOT
4885 or PLT entries), there's no possibility or desire to optimize TLS
4886 relocs, and there's not much point in propagating relocs to shared
4887 libs that the dynamic linker won't relocate. */
4888 if ((sec->flags & SEC_ALLOC) == 0)
4889 return TRUE;
4890
4891 BFD_ASSERT (is_ppc64_elf (abfd));
4892
4893 htab = ppc_hash_table (info);
4894 if (htab == NULL)
4895 return FALSE;
4896
4897 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
4898 FALSE, FALSE, TRUE);
4899 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
4900 FALSE, FALSE, TRUE);
4901 symtab_hdr = &elf_symtab_hdr (abfd);
4902 sym_hashes = elf_sym_hashes (abfd);
4903 sreloc = NULL;
4904 opd_sym_map = NULL;
4905 if (strcmp (sec->name, ".opd") == 0)
4906 {
4907 /* Garbage collection needs some extra help with .opd sections.
4908 We don't want to necessarily keep everything referenced by
4909 relocs in .opd, as that would keep all functions. Instead,
4910 if we reference an .opd symbol (a function descriptor), we
4911 want to keep the function code symbol's section. This is
4912 easy for global symbols, but for local syms we need to keep
4913 information about the associated function section. */
4914 bfd_size_type amt;
4915
4916 amt = sec->size * sizeof (*opd_sym_map) / 8;
4917 opd_sym_map = bfd_zalloc (abfd, amt);
4918 if (opd_sym_map == NULL)
4919 return FALSE;
4920 ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
4921 BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
4922 ppc64_elf_section_data (sec)->sec_type = sec_opd;
4923 }
4924
4925 if (htab->sfpr == NULL
4926 && !create_linkage_sections (htab->elf.dynobj, info))
4927 return FALSE;
4928
4929 rel_end = relocs + sec->reloc_count;
4930 for (rel = relocs; rel < rel_end; rel++)
4931 {
4932 unsigned long r_symndx;
4933 struct elf_link_hash_entry *h;
4934 enum elf_ppc64_reloc_type r_type;
4935 int tls_type;
4936 struct _ppc64_elf_section_data *ppc64_sec;
4937 struct plt_entry **ifunc;
4938
4939 r_symndx = ELF64_R_SYM (rel->r_info);
4940 if (r_symndx < symtab_hdr->sh_info)
4941 h = NULL;
4942 else
4943 {
4944 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4945 h = elf_follow_link (h);
4946 }
4947
4948 tls_type = 0;
4949 ifunc = NULL;
4950 if (h != NULL)
4951 {
4952 if (h->type == STT_GNU_IFUNC)
4953 {
4954 h->needs_plt = 1;
4955 ifunc = &h->plt.plist;
4956 }
4957 }
4958 else
4959 {
4960 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
4961 abfd, r_symndx);
4962 if (isym == NULL)
4963 return FALSE;
4964
4965 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4966 {
4967 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
4968 rel->r_addend, PLT_IFUNC);
4969 if (ifunc == NULL)
4970 return FALSE;
4971 }
4972 }
4973 r_type = ELF64_R_TYPE (rel->r_info);
4974 if (is_branch_reloc (r_type))
4975 {
4976 if (h != NULL && (h == tga || h == dottga))
4977 {
4978 if (rel != relocs
4979 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
4980 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
4981 /* We have a new-style __tls_get_addr call with a marker
4982 reloc. */
4983 ;
4984 else
4985 /* Mark this section as having an old-style call. */
4986 sec->has_tls_get_addr_call = 1;
4987 }
4988
4989 /* STT_GNU_IFUNC symbols must have a PLT entry. */
4990 if (ifunc != NULL
4991 && !update_plt_info (abfd, ifunc, rel->r_addend))
4992 return FALSE;
4993 }
4994
4995 switch (r_type)
4996 {
4997 case R_PPC64_TLSGD:
4998 case R_PPC64_TLSLD:
4999 /* These special tls relocs tie a call to __tls_get_addr with
5000 its parameter symbol. */
5001 break;
5002
5003 case R_PPC64_GOT_TLSLD16:
5004 case R_PPC64_GOT_TLSLD16_LO:
5005 case R_PPC64_GOT_TLSLD16_HI:
5006 case R_PPC64_GOT_TLSLD16_HA:
5007 tls_type = TLS_TLS | TLS_LD;
5008 goto dogottls;
5009
5010 case R_PPC64_GOT_TLSGD16:
5011 case R_PPC64_GOT_TLSGD16_LO:
5012 case R_PPC64_GOT_TLSGD16_HI:
5013 case R_PPC64_GOT_TLSGD16_HA:
5014 tls_type = TLS_TLS | TLS_GD;
5015 goto dogottls;
5016
5017 case R_PPC64_GOT_TPREL16_DS:
5018 case R_PPC64_GOT_TPREL16_LO_DS:
5019 case R_PPC64_GOT_TPREL16_HI:
5020 case R_PPC64_GOT_TPREL16_HA:
5021 if (!info->executable)
5022 info->flags |= DF_STATIC_TLS;
5023 tls_type = TLS_TLS | TLS_TPREL;
5024 goto dogottls;
5025
5026 case R_PPC64_GOT_DTPREL16_DS:
5027 case R_PPC64_GOT_DTPREL16_LO_DS:
5028 case R_PPC64_GOT_DTPREL16_HI:
5029 case R_PPC64_GOT_DTPREL16_HA:
5030 tls_type = TLS_TLS | TLS_DTPREL;
5031 dogottls:
5032 sec->has_tls_reloc = 1;
5033 /* Fall thru */
5034
5035 case R_PPC64_GOT16:
5036 case R_PPC64_GOT16_DS:
5037 case R_PPC64_GOT16_HA:
5038 case R_PPC64_GOT16_HI:
5039 case R_PPC64_GOT16_LO:
5040 case R_PPC64_GOT16_LO_DS:
5041 /* This symbol requires a global offset table entry. */
5042 sec->has_toc_reloc = 1;
5043 if (r_type == R_PPC64_GOT_TLSLD16
5044 || r_type == R_PPC64_GOT_TLSGD16
5045 || r_type == R_PPC64_GOT_TPREL16_DS
5046 || r_type == R_PPC64_GOT_DTPREL16_DS
5047 || r_type == R_PPC64_GOT16
5048 || r_type == R_PPC64_GOT16_DS)
5049 {
5050 htab->do_multi_toc = 1;
5051 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5052 }
5053
5054 if (ppc64_elf_tdata (abfd)->got == NULL
5055 && !create_got_section (abfd, info))
5056 return FALSE;
5057
5058 if (h != NULL)
5059 {
5060 struct ppc_link_hash_entry *eh;
5061 struct got_entry *ent;
5062
5063 eh = (struct ppc_link_hash_entry *) h;
5064 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5065 if (ent->addend == rel->r_addend
5066 && ent->owner == abfd
5067 && ent->tls_type == tls_type)
5068 break;
5069 if (ent == NULL)
5070 {
5071 bfd_size_type amt = sizeof (*ent);
5072 ent = bfd_alloc (abfd, amt);
5073 if (ent == NULL)
5074 return FALSE;
5075 ent->next = eh->elf.got.glist;
5076 ent->addend = rel->r_addend;
5077 ent->owner = abfd;
5078 ent->tls_type = tls_type;
5079 ent->is_indirect = FALSE;
5080 ent->got.refcount = 0;
5081 eh->elf.got.glist = ent;
5082 }
5083 ent->got.refcount += 1;
5084 eh->tls_mask |= tls_type;
5085 }
5086 else
5087 /* This is a global offset table entry for a local symbol. */
5088 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5089 rel->r_addend, tls_type))
5090 return FALSE;
5091 break;
5092
5093 case R_PPC64_PLT16_HA:
5094 case R_PPC64_PLT16_HI:
5095 case R_PPC64_PLT16_LO:
5096 case R_PPC64_PLT32:
5097 case R_PPC64_PLT64:
5098 /* This symbol requires a procedure linkage table entry. We
5099 actually build the entry in adjust_dynamic_symbol,
5100 because this might be a case of linking PIC code without
5101 linking in any dynamic objects, in which case we don't
5102 need to generate a procedure linkage table after all. */
5103 if (h == NULL)
5104 {
5105 /* It does not make sense to have a procedure linkage
5106 table entry for a local symbol. */
5107 bfd_set_error (bfd_error_bad_value);
5108 return FALSE;
5109 }
5110 else
5111 {
5112 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5113 return FALSE;
5114 h->needs_plt = 1;
5115 if (h->root.root.string[0] == '.'
5116 && h->root.root.string[1] != '\0')
5117 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5118 }
5119 break;
5120
5121 /* The following relocations don't need to propagate the
5122 relocation if linking a shared object since they are
5123 section relative. */
5124 case R_PPC64_SECTOFF:
5125 case R_PPC64_SECTOFF_LO:
5126 case R_PPC64_SECTOFF_HI:
5127 case R_PPC64_SECTOFF_HA:
5128 case R_PPC64_SECTOFF_DS:
5129 case R_PPC64_SECTOFF_LO_DS:
5130 case R_PPC64_DTPREL16:
5131 case R_PPC64_DTPREL16_LO:
5132 case R_PPC64_DTPREL16_HI:
5133 case R_PPC64_DTPREL16_HA:
5134 case R_PPC64_DTPREL16_DS:
5135 case R_PPC64_DTPREL16_LO_DS:
5136 case R_PPC64_DTPREL16_HIGHER:
5137 case R_PPC64_DTPREL16_HIGHERA:
5138 case R_PPC64_DTPREL16_HIGHEST:
5139 case R_PPC64_DTPREL16_HIGHESTA:
5140 break;
5141
5142 /* Nor do these. */
5143 case R_PPC64_REL16:
5144 case R_PPC64_REL16_LO:
5145 case R_PPC64_REL16_HI:
5146 case R_PPC64_REL16_HA:
5147 break;
5148
5149 case R_PPC64_TOC16:
5150 case R_PPC64_TOC16_DS:
5151 htab->do_multi_toc = 1;
5152 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5153 case R_PPC64_TOC16_LO:
5154 case R_PPC64_TOC16_HI:
5155 case R_PPC64_TOC16_HA:
5156 case R_PPC64_TOC16_LO_DS:
5157 sec->has_toc_reloc = 1;
5158 break;
5159
5160 /* This relocation describes the C++ object vtable hierarchy.
5161 Reconstruct it for later use during GC. */
5162 case R_PPC64_GNU_VTINHERIT:
5163 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5164 return FALSE;
5165 break;
5166
5167 /* This relocation describes which C++ vtable entries are actually
5168 used. Record for later use during GC. */
5169 case R_PPC64_GNU_VTENTRY:
5170 BFD_ASSERT (h != NULL);
5171 if (h != NULL
5172 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5173 return FALSE;
5174 break;
5175
5176 case R_PPC64_REL14:
5177 case R_PPC64_REL14_BRTAKEN:
5178 case R_PPC64_REL14_BRNTAKEN:
5179 {
5180 asection *dest = NULL;
5181
5182 /* Heuristic: If jumping outside our section, chances are
5183 we are going to need a stub. */
5184 if (h != NULL)
5185 {
5186 /* If the sym is weak it may be overridden later, so
5187 don't assume we know where a weak sym lives. */
5188 if (h->root.type == bfd_link_hash_defined)
5189 dest = h->root.u.def.section;
5190 }
5191 else
5192 {
5193 Elf_Internal_Sym *isym;
5194
5195 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5196 abfd, r_symndx);
5197 if (isym == NULL)
5198 return FALSE;
5199
5200 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5201 }
5202
5203 if (dest != sec)
5204 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5205 }
5206 /* Fall through. */
5207
5208 case R_PPC64_REL24:
5209 if (h != NULL && ifunc == NULL)
5210 {
5211 /* We may need a .plt entry if the function this reloc
5212 refers to is in a shared lib. */
5213 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5214 return FALSE;
5215 h->needs_plt = 1;
5216 if (h->root.root.string[0] == '.'
5217 && h->root.root.string[1] != '\0')
5218 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5219 if (h == tga || h == dottga)
5220 sec->has_tls_reloc = 1;
5221 }
5222 break;
5223
5224 case R_PPC64_TPREL64:
5225 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5226 if (!info->executable)
5227 info->flags |= DF_STATIC_TLS;
5228 goto dotlstoc;
5229
5230 case R_PPC64_DTPMOD64:
5231 if (rel + 1 < rel_end
5232 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5233 && rel[1].r_offset == rel->r_offset + 8)
5234 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5235 else
5236 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5237 goto dotlstoc;
5238
5239 case R_PPC64_DTPREL64:
5240 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5241 if (rel != relocs
5242 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5243 && rel[-1].r_offset == rel->r_offset - 8)
5244 /* This is the second reloc of a dtpmod, dtprel pair.
5245 Don't mark with TLS_DTPREL. */
5246 goto dodyn;
5247
5248 dotlstoc:
5249 sec->has_tls_reloc = 1;
5250 if (h != NULL)
5251 {
5252 struct ppc_link_hash_entry *eh;
5253 eh = (struct ppc_link_hash_entry *) h;
5254 eh->tls_mask |= tls_type;
5255 }
5256 else
5257 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5258 rel->r_addend, tls_type))
5259 return FALSE;
5260
5261 ppc64_sec = ppc64_elf_section_data (sec);
5262 if (ppc64_sec->sec_type != sec_toc)
5263 {
5264 bfd_size_type amt;
5265
5266 /* One extra to simplify get_tls_mask. */
5267 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5268 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5269 if (ppc64_sec->u.toc.symndx == NULL)
5270 return FALSE;
5271 amt = sec->size * sizeof (bfd_vma) / 8;
5272 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5273 if (ppc64_sec->u.toc.add == NULL)
5274 return FALSE;
5275 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5276 ppc64_sec->sec_type = sec_toc;
5277 }
5278 BFD_ASSERT (rel->r_offset % 8 == 0);
5279 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5280 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5281
5282 /* Mark the second slot of a GD or LD entry.
5283 -1 to indicate GD and -2 to indicate LD. */
5284 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5285 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5286 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5287 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5288 goto dodyn;
5289
5290 case R_PPC64_TPREL16:
5291 case R_PPC64_TPREL16_LO:
5292 case R_PPC64_TPREL16_HI:
5293 case R_PPC64_TPREL16_HA:
5294 case R_PPC64_TPREL16_DS:
5295 case R_PPC64_TPREL16_LO_DS:
5296 case R_PPC64_TPREL16_HIGHER:
5297 case R_PPC64_TPREL16_HIGHERA:
5298 case R_PPC64_TPREL16_HIGHEST:
5299 case R_PPC64_TPREL16_HIGHESTA:
5300 if (info->shared)
5301 {
5302 if (!info->executable)
5303 info->flags |= DF_STATIC_TLS;
5304 goto dodyn;
5305 }
5306 break;
5307
5308 case R_PPC64_ADDR64:
5309 if (opd_sym_map != NULL
5310 && rel + 1 < rel_end
5311 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5312 {
5313 if (h != NULL)
5314 {
5315 if (h->root.root.string[0] == '.'
5316 && h->root.root.string[1] != 0
5317 && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5318 ;
5319 else
5320 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5321 }
5322 else
5323 {
5324 asection *s;
5325 Elf_Internal_Sym *isym;
5326
5327 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5328 abfd, r_symndx);
5329 if (isym == NULL)
5330 return FALSE;
5331
5332 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5333 if (s != NULL && s != sec)
5334 opd_sym_map[rel->r_offset / 8] = s;
5335 }
5336 }
5337 /* Fall through. */
5338
5339 case R_PPC64_REL30:
5340 case R_PPC64_REL32:
5341 case R_PPC64_REL64:
5342 case R_PPC64_ADDR14:
5343 case R_PPC64_ADDR14_BRNTAKEN:
5344 case R_PPC64_ADDR14_BRTAKEN:
5345 case R_PPC64_ADDR16:
5346 case R_PPC64_ADDR16_DS:
5347 case R_PPC64_ADDR16_HA:
5348 case R_PPC64_ADDR16_HI:
5349 case R_PPC64_ADDR16_HIGHER:
5350 case R_PPC64_ADDR16_HIGHERA:
5351 case R_PPC64_ADDR16_HIGHEST:
5352 case R_PPC64_ADDR16_HIGHESTA:
5353 case R_PPC64_ADDR16_LO:
5354 case R_PPC64_ADDR16_LO_DS:
5355 case R_PPC64_ADDR24:
5356 case R_PPC64_ADDR32:
5357 case R_PPC64_UADDR16:
5358 case R_PPC64_UADDR32:
5359 case R_PPC64_UADDR64:
5360 case R_PPC64_TOC:
5361 if (h != NULL && !info->shared)
5362 /* We may need a copy reloc. */
5363 h->non_got_ref = 1;
5364
5365 /* Don't propagate .opd relocs. */
5366 if (NO_OPD_RELOCS && opd_sym_map != NULL)
5367 break;
5368
5369 /* If we are creating a shared library, and this is a reloc
5370 against a global symbol, or a non PC relative reloc
5371 against a local symbol, then we need to copy the reloc
5372 into the shared library. However, if we are linking with
5373 -Bsymbolic, we do not need to copy a reloc against a
5374 global symbol which is defined in an object we are
5375 including in the link (i.e., DEF_REGULAR is set). At
5376 this point we have not seen all the input files, so it is
5377 possible that DEF_REGULAR is not set now but will be set
5378 later (it is never cleared). In case of a weak definition,
5379 DEF_REGULAR may be cleared later by a strong definition in
5380 a shared library. We account for that possibility below by
5381 storing information in the dyn_relocs field of the hash
5382 table entry. A similar situation occurs when creating
5383 shared libraries and symbol visibility changes render the
5384 symbol local.
5385
5386 If on the other hand, we are creating an executable, we
5387 may need to keep relocations for symbols satisfied by a
5388 dynamic library if we manage to avoid copy relocs for the
5389 symbol. */
5390 dodyn:
5391 if ((info->shared
5392 && (must_be_dyn_reloc (info, r_type)
5393 || (h != NULL
5394 && (! info->symbolic
5395 || h->root.type == bfd_link_hash_defweak
5396 || !h->def_regular))))
5397 || (ELIMINATE_COPY_RELOCS
5398 && !info->shared
5399 && h != NULL
5400 && (h->root.type == bfd_link_hash_defweak
5401 || !h->def_regular))
5402 || (!info->shared
5403 && ifunc != NULL))
5404 {
5405 struct ppc_dyn_relocs *p;
5406 struct ppc_dyn_relocs **head;
5407
5408 /* We must copy these reloc types into the output file.
5409 Create a reloc section in dynobj and make room for
5410 this reloc. */
5411 if (sreloc == NULL)
5412 {
5413 sreloc = _bfd_elf_make_dynamic_reloc_section
5414 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5415
5416 if (sreloc == NULL)
5417 return FALSE;
5418 }
5419
5420 /* If this is a global symbol, we count the number of
5421 relocations we need for this symbol. */
5422 if (h != NULL)
5423 {
5424 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5425 }
5426 else
5427 {
5428 /* Track dynamic relocs needed for local syms too.
5429 We really need local syms available to do this
5430 easily. Oh well. */
5431 asection *s;
5432 void *vpp;
5433 Elf_Internal_Sym *isym;
5434
5435 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5436 abfd, r_symndx);
5437 if (isym == NULL)
5438 return FALSE;
5439
5440 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5441 if (s == NULL)
5442 s = sec;
5443
5444 vpp = &elf_section_data (s)->local_dynrel;
5445 head = (struct ppc_dyn_relocs **) vpp;
5446 }
5447
5448 p = *head;
5449 if (p == NULL || p->sec != sec)
5450 {
5451 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5452 if (p == NULL)
5453 return FALSE;
5454 p->next = *head;
5455 *head = p;
5456 p->sec = sec;
5457 p->count = 0;
5458 p->pc_count = 0;
5459 }
5460
5461 p->count += 1;
5462 if (!must_be_dyn_reloc (info, r_type))
5463 p->pc_count += 1;
5464 }
5465 break;
5466
5467 default:
5468 break;
5469 }
5470 }
5471
5472 return TRUE;
5473 }
5474
5475 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
5476 of the code entry point, and its section. */
5477
5478 static bfd_vma
5479 opd_entry_value (asection *opd_sec,
5480 bfd_vma offset,
5481 asection **code_sec,
5482 bfd_vma *code_off)
5483 {
5484 bfd *opd_bfd = opd_sec->owner;
5485 Elf_Internal_Rela *relocs;
5486 Elf_Internal_Rela *lo, *hi, *look;
5487 bfd_vma val;
5488
5489 /* No relocs implies we are linking a --just-symbols object. */
5490 if (opd_sec->reloc_count == 0)
5491 {
5492 char buf[8];
5493
5494 if (!bfd_get_section_contents (opd_bfd, opd_sec, buf, offset, 8))
5495 return (bfd_vma) -1;
5496
5497 val = bfd_get_64 (opd_bfd, buf);
5498 if (code_sec != NULL)
5499 {
5500 asection *sec, *likely = NULL;
5501 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5502 if (sec->vma <= val
5503 && (sec->flags & SEC_LOAD) != 0
5504 && (sec->flags & SEC_ALLOC) != 0)
5505 likely = sec;
5506 if (likely != NULL)
5507 {
5508 *code_sec = likely;
5509 if (code_off != NULL)
5510 *code_off = val - likely->vma;
5511 }
5512 }
5513 return val;
5514 }
5515
5516 BFD_ASSERT (is_ppc64_elf (opd_bfd));
5517
5518 relocs = ppc64_elf_tdata (opd_bfd)->opd_relocs;
5519 if (relocs == NULL)
5520 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5521
5522 /* Go find the opd reloc at the sym address. */
5523 lo = relocs;
5524 BFD_ASSERT (lo != NULL);
5525 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5526 val = (bfd_vma) -1;
5527 while (lo < hi)
5528 {
5529 look = lo + (hi - lo) / 2;
5530 if (look->r_offset < offset)
5531 lo = look + 1;
5532 else if (look->r_offset > offset)
5533 hi = look;
5534 else
5535 {
5536 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5537
5538 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5539 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5540 {
5541 unsigned long symndx = ELF64_R_SYM (look->r_info);
5542 asection *sec;
5543
5544 if (symndx < symtab_hdr->sh_info)
5545 {
5546 Elf_Internal_Sym *sym;
5547
5548 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5549 if (sym == NULL)
5550 {
5551 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
5552 symtab_hdr->sh_info,
5553 0, NULL, NULL, NULL);
5554 if (sym == NULL)
5555 break;
5556 symtab_hdr->contents = (bfd_byte *) sym;
5557 }
5558
5559 sym += symndx;
5560 val = sym->st_value;
5561 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5562 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5563 }
5564 else
5565 {
5566 struct elf_link_hash_entry **sym_hashes;
5567 struct elf_link_hash_entry *rh;
5568
5569 sym_hashes = elf_sym_hashes (opd_bfd);
5570 rh = sym_hashes[symndx - symtab_hdr->sh_info];
5571 rh = elf_follow_link (rh);
5572 BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5573 || rh->root.type == bfd_link_hash_defweak);
5574 val = rh->root.u.def.value;
5575 sec = rh->root.u.def.section;
5576 }
5577 val += look->r_addend;
5578 if (code_off != NULL)
5579 *code_off = val;
5580 if (code_sec != NULL)
5581 *code_sec = sec;
5582 if (sec != NULL && sec->output_section != NULL)
5583 val += sec->output_section->vma + sec->output_offset;
5584 }
5585 break;
5586 }
5587 }
5588
5589 return val;
5590 }
5591
5592 /* Return true if symbol is defined in a regular object file. */
5593
5594 static bfd_boolean
5595 is_static_defined (struct elf_link_hash_entry *h)
5596 {
5597 return ((h->root.type == bfd_link_hash_defined
5598 || h->root.type == bfd_link_hash_defweak)
5599 && h->root.u.def.section != NULL
5600 && h->root.u.def.section->output_section != NULL);
5601 }
5602
5603 /* If FDH is a function descriptor symbol, return the associated code
5604 entry symbol if it is defined. Return NULL otherwise. */
5605
5606 static struct ppc_link_hash_entry *
5607 defined_code_entry (struct ppc_link_hash_entry *fdh)
5608 {
5609 if (fdh->is_func_descriptor)
5610 {
5611 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
5612 if (fh->elf.root.type == bfd_link_hash_defined
5613 || fh->elf.root.type == bfd_link_hash_defweak)
5614 return fh;
5615 }
5616 return NULL;
5617 }
5618
5619 /* If FH is a function code entry symbol, return the associated
5620 function descriptor symbol if it is defined. Return NULL otherwise. */
5621
5622 static struct ppc_link_hash_entry *
5623 defined_func_desc (struct ppc_link_hash_entry *fh)
5624 {
5625 if (fh->oh != NULL
5626 && fh->oh->is_func_descriptor)
5627 {
5628 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
5629 if (fdh->elf.root.type == bfd_link_hash_defined
5630 || fdh->elf.root.type == bfd_link_hash_defweak)
5631 return fdh;
5632 }
5633 return NULL;
5634 }
5635
5636 /* Mark all our entry sym sections, both opd and code section. */
5637
5638 static void
5639 ppc64_elf_gc_keep (struct bfd_link_info *info)
5640 {
5641 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5642 struct bfd_sym_chain *sym;
5643
5644 if (htab == NULL)
5645 return;
5646
5647 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
5648 {
5649 struct ppc_link_hash_entry *eh, *fh;
5650 asection *sec;
5651
5652 eh = (struct ppc_link_hash_entry *)
5653 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
5654 if (eh == NULL)
5655 continue;
5656 if (eh->elf.root.type != bfd_link_hash_defined
5657 && eh->elf.root.type != bfd_link_hash_defweak)
5658 continue;
5659
5660 fh = defined_code_entry (eh);
5661 if (fh != NULL)
5662 {
5663 sec = fh->elf.root.u.def.section;
5664 sec->flags |= SEC_KEEP;
5665 }
5666 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5667 && opd_entry_value (eh->elf.root.u.def.section,
5668 eh->elf.root.u.def.value,
5669 &sec, NULL) != (bfd_vma) -1)
5670 sec->flags |= SEC_KEEP;
5671
5672 sec = eh->elf.root.u.def.section;
5673 sec->flags |= SEC_KEEP;
5674 }
5675 }
5676
5677 /* Mark sections containing dynamically referenced symbols. When
5678 building shared libraries, we must assume that any visible symbol is
5679 referenced. */
5680
5681 static bfd_boolean
5682 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
5683 {
5684 struct bfd_link_info *info = (struct bfd_link_info *) inf;
5685 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
5686 struct ppc_link_hash_entry *fdh;
5687
5688 if (eh->elf.root.type == bfd_link_hash_warning)
5689 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5690
5691 /* Dynamic linking info is on the func descriptor sym. */
5692 fdh = defined_func_desc (eh);
5693 if (fdh != NULL)
5694 eh = fdh;
5695
5696 if ((eh->elf.root.type == bfd_link_hash_defined
5697 || eh->elf.root.type == bfd_link_hash_defweak)
5698 && (eh->elf.ref_dynamic
5699 || (!info->executable
5700 && eh->elf.def_regular
5701 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
5702 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN)))
5703 {
5704 asection *code_sec;
5705 struct ppc_link_hash_entry *fh;
5706
5707 eh->elf.root.u.def.section->flags |= SEC_KEEP;
5708
5709 /* Function descriptor syms cause the associated
5710 function code sym section to be marked. */
5711 fh = defined_code_entry (eh);
5712 if (fh != NULL)
5713 {
5714 code_sec = fh->elf.root.u.def.section;
5715 code_sec->flags |= SEC_KEEP;
5716 }
5717 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5718 && opd_entry_value (eh->elf.root.u.def.section,
5719 eh->elf.root.u.def.value,
5720 &code_sec, NULL) != (bfd_vma) -1)
5721 code_sec->flags |= SEC_KEEP;
5722 }
5723
5724 return TRUE;
5725 }
5726
5727 /* Return the section that should be marked against GC for a given
5728 relocation. */
5729
5730 static asection *
5731 ppc64_elf_gc_mark_hook (asection *sec,
5732 struct bfd_link_info *info,
5733 Elf_Internal_Rela *rel,
5734 struct elf_link_hash_entry *h,
5735 Elf_Internal_Sym *sym)
5736 {
5737 asection *rsec;
5738
5739 /* Syms return NULL if we're marking .opd, so we avoid marking all
5740 function sections, as all functions are referenced in .opd. */
5741 rsec = NULL;
5742 if (get_opd_info (sec) != NULL)
5743 return rsec;
5744
5745 if (h != NULL)
5746 {
5747 enum elf_ppc64_reloc_type r_type;
5748 struct ppc_link_hash_entry *eh, *fh, *fdh;
5749
5750 r_type = ELF64_R_TYPE (rel->r_info);
5751 switch (r_type)
5752 {
5753 case R_PPC64_GNU_VTINHERIT:
5754 case R_PPC64_GNU_VTENTRY:
5755 break;
5756
5757 default:
5758 switch (h->root.type)
5759 {
5760 case bfd_link_hash_defined:
5761 case bfd_link_hash_defweak:
5762 eh = (struct ppc_link_hash_entry *) h;
5763 fdh = defined_func_desc (eh);
5764 if (fdh != NULL)
5765 eh = fdh;
5766
5767 /* Function descriptor syms cause the associated
5768 function code sym section to be marked. */
5769 fh = defined_code_entry (eh);
5770 if (fh != NULL)
5771 {
5772 /* They also mark their opd section. */
5773 eh->elf.root.u.def.section->gc_mark = 1;
5774
5775 rsec = fh->elf.root.u.def.section;
5776 }
5777 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5778 && opd_entry_value (eh->elf.root.u.def.section,
5779 eh->elf.root.u.def.value,
5780 &rsec, NULL) != (bfd_vma) -1)
5781 eh->elf.root.u.def.section->gc_mark = 1;
5782 else
5783 rsec = h->root.u.def.section;
5784 break;
5785
5786 case bfd_link_hash_common:
5787 rsec = h->root.u.c.p->section;
5788 break;
5789
5790 default:
5791 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
5792 }
5793 }
5794 }
5795 else
5796 {
5797 struct _opd_sec_data *opd;
5798
5799 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
5800 opd = get_opd_info (rsec);
5801 if (opd != NULL && opd->func_sec != NULL)
5802 {
5803 rsec->gc_mark = 1;
5804
5805 rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
5806 }
5807 }
5808
5809 return rsec;
5810 }
5811
5812 /* Update the .got, .plt. and dynamic reloc reference counts for the
5813 section being removed. */
5814
5815 static bfd_boolean
5816 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
5817 asection *sec, const Elf_Internal_Rela *relocs)
5818 {
5819 struct ppc_link_hash_table *htab;
5820 Elf_Internal_Shdr *symtab_hdr;
5821 struct elf_link_hash_entry **sym_hashes;
5822 struct got_entry **local_got_ents;
5823 const Elf_Internal_Rela *rel, *relend;
5824
5825 if (info->relocatable)
5826 return TRUE;
5827
5828 if ((sec->flags & SEC_ALLOC) == 0)
5829 return TRUE;
5830
5831 elf_section_data (sec)->local_dynrel = NULL;
5832
5833 htab = ppc_hash_table (info);
5834 if (htab == NULL)
5835 return FALSE;
5836
5837 symtab_hdr = &elf_symtab_hdr (abfd);
5838 sym_hashes = elf_sym_hashes (abfd);
5839 local_got_ents = elf_local_got_ents (abfd);
5840
5841 relend = relocs + sec->reloc_count;
5842 for (rel = relocs; rel < relend; rel++)
5843 {
5844 unsigned long r_symndx;
5845 enum elf_ppc64_reloc_type r_type;
5846 struct elf_link_hash_entry *h = NULL;
5847 unsigned char tls_type = 0;
5848
5849 r_symndx = ELF64_R_SYM (rel->r_info);
5850 r_type = ELF64_R_TYPE (rel->r_info);
5851 if (r_symndx >= symtab_hdr->sh_info)
5852 {
5853 struct ppc_link_hash_entry *eh;
5854 struct ppc_dyn_relocs **pp;
5855 struct ppc_dyn_relocs *p;
5856
5857 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5858 h = elf_follow_link (h);
5859 eh = (struct ppc_link_hash_entry *) h;
5860
5861 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
5862 if (p->sec == sec)
5863 {
5864 /* Everything must go for SEC. */
5865 *pp = p->next;
5866 break;
5867 }
5868 }
5869
5870 if (is_branch_reloc (r_type))
5871 {
5872 struct plt_entry **ifunc = NULL;
5873 if (h != NULL)
5874 {
5875 if (h->type == STT_GNU_IFUNC)
5876 ifunc = &h->plt.plist;
5877 }
5878 else if (local_got_ents != NULL)
5879 {
5880 struct plt_entry **local_plt = (struct plt_entry **)
5881 (local_got_ents + symtab_hdr->sh_info);
5882 unsigned char *local_got_tls_masks = (unsigned char *)
5883 (local_plt + symtab_hdr->sh_info);
5884 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
5885 ifunc = local_plt + r_symndx;
5886 }
5887 if (ifunc != NULL)
5888 {
5889 struct plt_entry *ent;
5890
5891 for (ent = *ifunc; ent != NULL; ent = ent->next)
5892 if (ent->addend == rel->r_addend)
5893 break;
5894 if (ent == NULL)
5895 abort ();
5896 if (ent->plt.refcount > 0)
5897 ent->plt.refcount -= 1;
5898 continue;
5899 }
5900 }
5901
5902 switch (r_type)
5903 {
5904 case R_PPC64_GOT_TLSLD16:
5905 case R_PPC64_GOT_TLSLD16_LO:
5906 case R_PPC64_GOT_TLSLD16_HI:
5907 case R_PPC64_GOT_TLSLD16_HA:
5908 tls_type = TLS_TLS | TLS_LD;
5909 goto dogot;
5910
5911 case R_PPC64_GOT_TLSGD16:
5912 case R_PPC64_GOT_TLSGD16_LO:
5913 case R_PPC64_GOT_TLSGD16_HI:
5914 case R_PPC64_GOT_TLSGD16_HA:
5915 tls_type = TLS_TLS | TLS_GD;
5916 goto dogot;
5917
5918 case R_PPC64_GOT_TPREL16_DS:
5919 case R_PPC64_GOT_TPREL16_LO_DS:
5920 case R_PPC64_GOT_TPREL16_HI:
5921 case R_PPC64_GOT_TPREL16_HA:
5922 tls_type = TLS_TLS | TLS_TPREL;
5923 goto dogot;
5924
5925 case R_PPC64_GOT_DTPREL16_DS:
5926 case R_PPC64_GOT_DTPREL16_LO_DS:
5927 case R_PPC64_GOT_DTPREL16_HI:
5928 case R_PPC64_GOT_DTPREL16_HA:
5929 tls_type = TLS_TLS | TLS_DTPREL;
5930 goto dogot;
5931
5932 case R_PPC64_GOT16:
5933 case R_PPC64_GOT16_DS:
5934 case R_PPC64_GOT16_HA:
5935 case R_PPC64_GOT16_HI:
5936 case R_PPC64_GOT16_LO:
5937 case R_PPC64_GOT16_LO_DS:
5938 dogot:
5939 {
5940 struct got_entry *ent;
5941
5942 if (h != NULL)
5943 ent = h->got.glist;
5944 else
5945 ent = local_got_ents[r_symndx];
5946
5947 for (; ent != NULL; ent = ent->next)
5948 if (ent->addend == rel->r_addend
5949 && ent->owner == abfd
5950 && ent->tls_type == tls_type)
5951 break;
5952 if (ent == NULL)
5953 abort ();
5954 if (ent->got.refcount > 0)
5955 ent->got.refcount -= 1;
5956 }
5957 break;
5958
5959 case R_PPC64_PLT16_HA:
5960 case R_PPC64_PLT16_HI:
5961 case R_PPC64_PLT16_LO:
5962 case R_PPC64_PLT32:
5963 case R_PPC64_PLT64:
5964 case R_PPC64_REL14:
5965 case R_PPC64_REL14_BRNTAKEN:
5966 case R_PPC64_REL14_BRTAKEN:
5967 case R_PPC64_REL24:
5968 if (h != NULL)
5969 {
5970 struct plt_entry *ent;
5971
5972 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5973 if (ent->addend == rel->r_addend)
5974 break;
5975 if (ent != NULL && ent->plt.refcount > 0)
5976 ent->plt.refcount -= 1;
5977 }
5978 break;
5979
5980 default:
5981 break;
5982 }
5983 }
5984 return TRUE;
5985 }
5986
5987 /* The maximum size of .sfpr. */
5988 #define SFPR_MAX (218*4)
5989
5990 struct sfpr_def_parms
5991 {
5992 const char name[12];
5993 unsigned char lo, hi;
5994 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
5995 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
5996 };
5997
5998 /* Auto-generate _save*, _rest* functions in .sfpr. */
5999
6000 static bfd_boolean
6001 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6002 {
6003 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6004 unsigned int i;
6005 size_t len = strlen (parm->name);
6006 bfd_boolean writing = FALSE;
6007 char sym[16];
6008
6009 if (htab == NULL)
6010 return FALSE;
6011
6012 memcpy (sym, parm->name, len);
6013 sym[len + 2] = 0;
6014
6015 for (i = parm->lo; i <= parm->hi; i++)
6016 {
6017 struct elf_link_hash_entry *h;
6018
6019 sym[len + 0] = i / 10 + '0';
6020 sym[len + 1] = i % 10 + '0';
6021 h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6022 if (h != NULL
6023 && !h->def_regular)
6024 {
6025 h->root.type = bfd_link_hash_defined;
6026 h->root.u.def.section = htab->sfpr;
6027 h->root.u.def.value = htab->sfpr->size;
6028 h->type = STT_FUNC;
6029 h->def_regular = 1;
6030 _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6031 writing = TRUE;
6032 if (htab->sfpr->contents == NULL)
6033 {
6034 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6035 if (htab->sfpr->contents == NULL)
6036 return FALSE;
6037 }
6038 }
6039 if (writing)
6040 {
6041 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6042 if (i != parm->hi)
6043 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6044 else
6045 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6046 htab->sfpr->size = p - htab->sfpr->contents;
6047 }
6048 }
6049
6050 return TRUE;
6051 }
6052
6053 static bfd_byte *
6054 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6055 {
6056 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6057 return p + 4;
6058 }
6059
6060 static bfd_byte *
6061 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6062 {
6063 p = savegpr0 (abfd, p, r);
6064 bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6065 p = p + 4;
6066 bfd_put_32 (abfd, BLR, p);
6067 return p + 4;
6068 }
6069
6070 static bfd_byte *
6071 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6072 {
6073 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6074 return p + 4;
6075 }
6076
6077 static bfd_byte *
6078 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6079 {
6080 bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6081 p = p + 4;
6082 p = restgpr0 (abfd, p, r);
6083 bfd_put_32 (abfd, MTLR_R0, p);
6084 p = p + 4;
6085 if (r == 29)
6086 {
6087 p = restgpr0 (abfd, p, 30);
6088 p = restgpr0 (abfd, p, 31);
6089 }
6090 bfd_put_32 (abfd, BLR, p);
6091 return p + 4;
6092 }
6093
6094 static bfd_byte *
6095 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6096 {
6097 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6098 return p + 4;
6099 }
6100
6101 static bfd_byte *
6102 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6103 {
6104 p = savegpr1 (abfd, p, r);
6105 bfd_put_32 (abfd, BLR, p);
6106 return p + 4;
6107 }
6108
6109 static bfd_byte *
6110 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6111 {
6112 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6113 return p + 4;
6114 }
6115
6116 static bfd_byte *
6117 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6118 {
6119 p = restgpr1 (abfd, p, r);
6120 bfd_put_32 (abfd, BLR, p);
6121 return p + 4;
6122 }
6123
6124 static bfd_byte *
6125 savefpr (bfd *abfd, bfd_byte *p, int r)
6126 {
6127 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6128 return p + 4;
6129 }
6130
6131 static bfd_byte *
6132 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6133 {
6134 p = savefpr (abfd, p, r);
6135 bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6136 p = p + 4;
6137 bfd_put_32 (abfd, BLR, p);
6138 return p + 4;
6139 }
6140
6141 static bfd_byte *
6142 restfpr (bfd *abfd, bfd_byte *p, int r)
6143 {
6144 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6145 return p + 4;
6146 }
6147
6148 static bfd_byte *
6149 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6150 {
6151 bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6152 p = p + 4;
6153 p = restfpr (abfd, p, r);
6154 bfd_put_32 (abfd, MTLR_R0, p);
6155 p = p + 4;
6156 if (r == 29)
6157 {
6158 p = restfpr (abfd, p, 30);
6159 p = restfpr (abfd, p, 31);
6160 }
6161 bfd_put_32 (abfd, BLR, p);
6162 return p + 4;
6163 }
6164
6165 static bfd_byte *
6166 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6167 {
6168 p = savefpr (abfd, p, r);
6169 bfd_put_32 (abfd, BLR, p);
6170 return p + 4;
6171 }
6172
6173 static bfd_byte *
6174 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6175 {
6176 p = restfpr (abfd, p, r);
6177 bfd_put_32 (abfd, BLR, p);
6178 return p + 4;
6179 }
6180
6181 static bfd_byte *
6182 savevr (bfd *abfd, bfd_byte *p, int r)
6183 {
6184 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6185 p = p + 4;
6186 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6187 return p + 4;
6188 }
6189
6190 static bfd_byte *
6191 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6192 {
6193 p = savevr (abfd, p, r);
6194 bfd_put_32 (abfd, BLR, p);
6195 return p + 4;
6196 }
6197
6198 static bfd_byte *
6199 restvr (bfd *abfd, bfd_byte *p, int r)
6200 {
6201 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6202 p = p + 4;
6203 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6204 return p + 4;
6205 }
6206
6207 static bfd_byte *
6208 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6209 {
6210 p = restvr (abfd, p, r);
6211 bfd_put_32 (abfd, BLR, p);
6212 return p + 4;
6213 }
6214
6215 /* Called via elf_link_hash_traverse to transfer dynamic linking
6216 information on function code symbol entries to their corresponding
6217 function descriptor symbol entries. */
6218
6219 static bfd_boolean
6220 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6221 {
6222 struct bfd_link_info *info;
6223 struct ppc_link_hash_table *htab;
6224 struct plt_entry *ent;
6225 struct ppc_link_hash_entry *fh;
6226 struct ppc_link_hash_entry *fdh;
6227 bfd_boolean force_local;
6228
6229 fh = (struct ppc_link_hash_entry *) h;
6230 if (fh->elf.root.type == bfd_link_hash_indirect)
6231 return TRUE;
6232
6233 if (fh->elf.root.type == bfd_link_hash_warning)
6234 fh = (struct ppc_link_hash_entry *) fh->elf.root.u.i.link;
6235
6236 info = inf;
6237 htab = ppc_hash_table (info);
6238 if (htab == NULL)
6239 return FALSE;
6240
6241 /* Resolve undefined references to dot-symbols as the value
6242 in the function descriptor, if we have one in a regular object.
6243 This is to satisfy cases like ".quad .foo". Calls to functions
6244 in dynamic objects are handled elsewhere. */
6245 if (fh->elf.root.type == bfd_link_hash_undefweak
6246 && fh->was_undefined
6247 && (fdh = defined_func_desc (fh)) != NULL
6248 && get_opd_info (fdh->elf.root.u.def.section) != NULL
6249 && opd_entry_value (fdh->elf.root.u.def.section,
6250 fdh->elf.root.u.def.value,
6251 &fh->elf.root.u.def.section,
6252 &fh->elf.root.u.def.value) != (bfd_vma) -1)
6253 {
6254 fh->elf.root.type = fdh->elf.root.type;
6255 fh->elf.forced_local = 1;
6256 fh->elf.def_regular = fdh->elf.def_regular;
6257 fh->elf.def_dynamic = fdh->elf.def_dynamic;
6258 }
6259
6260 /* If this is a function code symbol, transfer dynamic linking
6261 information to the function descriptor symbol. */
6262 if (!fh->is_func)
6263 return TRUE;
6264
6265 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6266 if (ent->plt.refcount > 0)
6267 break;
6268 if (ent == NULL
6269 || fh->elf.root.root.string[0] != '.'
6270 || fh->elf.root.root.string[1] == '\0')
6271 return TRUE;
6272
6273 /* Find the corresponding function descriptor symbol. Create it
6274 as undefined if necessary. */
6275
6276 fdh = lookup_fdh (fh, htab);
6277 if (fdh == NULL
6278 && !info->executable
6279 && (fh->elf.root.type == bfd_link_hash_undefined
6280 || fh->elf.root.type == bfd_link_hash_undefweak))
6281 {
6282 fdh = make_fdh (info, fh);
6283 if (fdh == NULL)
6284 return FALSE;
6285 }
6286
6287 /* Fake function descriptors are made undefweak. If the function
6288 code symbol is strong undefined, make the fake sym the same.
6289 If the function code symbol is defined, then force the fake
6290 descriptor local; We can't support overriding of symbols in a
6291 shared library on a fake descriptor. */
6292
6293 if (fdh != NULL
6294 && fdh->fake
6295 && fdh->elf.root.type == bfd_link_hash_undefweak)
6296 {
6297 if (fh->elf.root.type == bfd_link_hash_undefined)
6298 {
6299 fdh->elf.root.type = bfd_link_hash_undefined;
6300 bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6301 }
6302 else if (fh->elf.root.type == bfd_link_hash_defined
6303 || fh->elf.root.type == bfd_link_hash_defweak)
6304 {
6305 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6306 }
6307 }
6308
6309 if (fdh != NULL
6310 && !fdh->elf.forced_local
6311 && (!info->executable
6312 || fdh->elf.def_dynamic
6313 || fdh->elf.ref_dynamic
6314 || (fdh->elf.root.type == bfd_link_hash_undefweak
6315 && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6316 {
6317 if (fdh->elf.dynindx == -1)
6318 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6319 return FALSE;
6320 fdh->elf.ref_regular |= fh->elf.ref_regular;
6321 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6322 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6323 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6324 if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6325 {
6326 move_plt_plist (fh, fdh);
6327 fdh->elf.needs_plt = 1;
6328 }
6329 fdh->is_func_descriptor = 1;
6330 fdh->oh = fh;
6331 fh->oh = fdh;
6332 }
6333
6334 /* Now that the info is on the function descriptor, clear the
6335 function code sym info. Any function code syms for which we
6336 don't have a definition in a regular file, we force local.
6337 This prevents a shared library from exporting syms that have
6338 been imported from another library. Function code syms that
6339 are really in the library we must leave global to prevent the
6340 linker dragging in a definition from a static library. */
6341 force_local = (!fh->elf.def_regular
6342 || fdh == NULL
6343 || !fdh->elf.def_regular
6344 || fdh->elf.forced_local);
6345 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6346
6347 return TRUE;
6348 }
6349
6350 /* Called near the start of bfd_elf_size_dynamic_sections. We use
6351 this hook to a) provide some gcc support functions, and b) transfer
6352 dynamic linking information gathered so far on function code symbol
6353 entries, to their corresponding function descriptor symbol entries. */
6354
6355 static bfd_boolean
6356 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6357 struct bfd_link_info *info)
6358 {
6359 struct ppc_link_hash_table *htab;
6360 unsigned int i;
6361 const struct sfpr_def_parms funcs[] =
6362 {
6363 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6364 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6365 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6366 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6367 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6368 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6369 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6370 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6371 { "._savef", 14, 31, savefpr, savefpr1_tail },
6372 { "._restf", 14, 31, restfpr, restfpr1_tail },
6373 { "_savevr_", 20, 31, savevr, savevr_tail },
6374 { "_restvr_", 20, 31, restvr, restvr_tail }
6375 };
6376
6377 htab = ppc_hash_table (info);
6378 if (htab == NULL)
6379 return FALSE;
6380
6381 if (htab->sfpr == NULL)
6382 /* We don't have any relocs. */
6383 return TRUE;
6384
6385 /* Provide any missing _save* and _rest* functions. */
6386 htab->sfpr->size = 0;
6387 for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6388 if (!sfpr_define (info, &funcs[i]))
6389 return FALSE;
6390
6391 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6392
6393 if (htab->sfpr->size == 0)
6394 htab->sfpr->flags |= SEC_EXCLUDE;
6395
6396 return TRUE;
6397 }
6398
6399 /* Adjust a symbol defined by a dynamic object and referenced by a
6400 regular object. The current definition is in some section of the
6401 dynamic object, but we're not including those sections. We have to
6402 change the definition to something the rest of the link can
6403 understand. */
6404
6405 static bfd_boolean
6406 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6407 struct elf_link_hash_entry *h)
6408 {
6409 struct ppc_link_hash_table *htab;
6410 asection *s;
6411
6412 htab = ppc_hash_table (info);
6413 if (htab == NULL)
6414 return FALSE;
6415
6416 /* Deal with function syms. */
6417 if (h->type == STT_FUNC
6418 || h->type == STT_GNU_IFUNC
6419 || h->needs_plt)
6420 {
6421 /* Clear procedure linkage table information for any symbol that
6422 won't need a .plt entry. */
6423 struct plt_entry *ent;
6424 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6425 if (ent->plt.refcount > 0)
6426 break;
6427 if (ent == NULL
6428 || (h->type != STT_GNU_IFUNC
6429 && (SYMBOL_CALLS_LOCAL (info, h)
6430 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6431 && h->root.type == bfd_link_hash_undefweak))))
6432 {
6433 h->plt.plist = NULL;
6434 h->needs_plt = 0;
6435 }
6436 }
6437 else
6438 h->plt.plist = NULL;
6439
6440 /* If this is a weak symbol, and there is a real definition, the
6441 processor independent code will have arranged for us to see the
6442 real definition first, and we can just use the same value. */
6443 if (h->u.weakdef != NULL)
6444 {
6445 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6446 || h->u.weakdef->root.type == bfd_link_hash_defweak);
6447 h->root.u.def.section = h->u.weakdef->root.u.def.section;
6448 h->root.u.def.value = h->u.weakdef->root.u.def.value;
6449 if (ELIMINATE_COPY_RELOCS)
6450 h->non_got_ref = h->u.weakdef->non_got_ref;
6451 return TRUE;
6452 }
6453
6454 /* If we are creating a shared library, we must presume that the
6455 only references to the symbol are via the global offset table.
6456 For such cases we need not do anything here; the relocations will
6457 be handled correctly by relocate_section. */
6458 if (info->shared)
6459 return TRUE;
6460
6461 /* If there are no references to this symbol that do not use the
6462 GOT, we don't need to generate a copy reloc. */
6463 if (!h->non_got_ref)
6464 return TRUE;
6465
6466 /* Don't generate a copy reloc for symbols defined in the executable. */
6467 if (!h->def_dynamic || !h->ref_regular || h->def_regular)
6468 return TRUE;
6469
6470 if (ELIMINATE_COPY_RELOCS)
6471 {
6472 struct ppc_link_hash_entry * eh;
6473 struct ppc_dyn_relocs *p;
6474
6475 eh = (struct ppc_link_hash_entry *) h;
6476 for (p = eh->dyn_relocs; p != NULL; p = p->next)
6477 {
6478 s = p->sec->output_section;
6479 if (s != NULL && (s->flags & SEC_READONLY) != 0)
6480 break;
6481 }
6482
6483 /* If we didn't find any dynamic relocs in read-only sections, then
6484 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
6485 if (p == NULL)
6486 {
6487 h->non_got_ref = 0;
6488 return TRUE;
6489 }
6490 }
6491
6492 if (h->plt.plist != NULL)
6493 {
6494 /* We should never get here, but unfortunately there are versions
6495 of gcc out there that improperly (for this ABI) put initialized
6496 function pointers, vtable refs and suchlike in read-only
6497 sections. Allow them to proceed, but warn that this might
6498 break at runtime. */
6499 (*_bfd_error_handler)
6500 (_("copy reloc against `%s' requires lazy plt linking; "
6501 "avoid setting LD_BIND_NOW=1 or upgrade gcc"),
6502 h->root.root.string);
6503 }
6504
6505 /* This is a reference to a symbol defined by a dynamic object which
6506 is not a function. */
6507
6508 if (h->size == 0)
6509 {
6510 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
6511 h->root.root.string);
6512 return TRUE;
6513 }
6514
6515 /* We must allocate the symbol in our .dynbss section, which will
6516 become part of the .bss section of the executable. There will be
6517 an entry for this symbol in the .dynsym section. The dynamic
6518 object will contain position independent code, so all references
6519 from the dynamic object to this symbol will go through the global
6520 offset table. The dynamic linker will use the .dynsym entry to
6521 determine the address it must put in the global offset table, so
6522 both the dynamic object and the regular object will refer to the
6523 same memory location for the variable. */
6524
6525 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
6526 to copy the initial value out of the dynamic object and into the
6527 runtime process image. We need to remember the offset into the
6528 .rela.bss section we are going to use. */
6529 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
6530 {
6531 htab->relbss->size += sizeof (Elf64_External_Rela);
6532 h->needs_copy = 1;
6533 }
6534
6535 s = htab->dynbss;
6536
6537 return _bfd_elf_adjust_dynamic_copy (h, s);
6538 }
6539
6540 /* If given a function descriptor symbol, hide both the function code
6541 sym and the descriptor. */
6542 static void
6543 ppc64_elf_hide_symbol (struct bfd_link_info *info,
6544 struct elf_link_hash_entry *h,
6545 bfd_boolean force_local)
6546 {
6547 struct ppc_link_hash_entry *eh;
6548 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
6549
6550 eh = (struct ppc_link_hash_entry *) h;
6551 if (eh->is_func_descriptor)
6552 {
6553 struct ppc_link_hash_entry *fh = eh->oh;
6554
6555 if (fh == NULL)
6556 {
6557 const char *p, *q;
6558 struct ppc_link_hash_table *htab;
6559 char save;
6560
6561 /* We aren't supposed to use alloca in BFD because on
6562 systems which do not have alloca the version in libiberty
6563 calls xmalloc, which might cause the program to crash
6564 when it runs out of memory. This function doesn't have a
6565 return status, so there's no way to gracefully return an
6566 error. So cheat. We know that string[-1] can be safely
6567 accessed; It's either a string in an ELF string table,
6568 or allocated in an objalloc structure. */
6569
6570 p = eh->elf.root.root.string - 1;
6571 save = *p;
6572 *(char *) p = '.';
6573 htab = ppc_hash_table (info);
6574 if (htab == NULL)
6575 return;
6576
6577 fh = (struct ppc_link_hash_entry *)
6578 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6579 *(char *) p = save;
6580
6581 /* Unfortunately, if it so happens that the string we were
6582 looking for was allocated immediately before this string,
6583 then we overwrote the string terminator. That's the only
6584 reason the lookup should fail. */
6585 if (fh == NULL)
6586 {
6587 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
6588 while (q >= eh->elf.root.root.string && *q == *p)
6589 --q, --p;
6590 if (q < eh->elf.root.root.string && *p == '.')
6591 fh = (struct ppc_link_hash_entry *)
6592 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6593 }
6594 if (fh != NULL)
6595 {
6596 eh->oh = fh;
6597 fh->oh = eh;
6598 }
6599 }
6600 if (fh != NULL)
6601 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6602 }
6603 }
6604
6605 static bfd_boolean
6606 get_sym_h (struct elf_link_hash_entry **hp,
6607 Elf_Internal_Sym **symp,
6608 asection **symsecp,
6609 unsigned char **tls_maskp,
6610 Elf_Internal_Sym **locsymsp,
6611 unsigned long r_symndx,
6612 bfd *ibfd)
6613 {
6614 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
6615
6616 if (r_symndx >= symtab_hdr->sh_info)
6617 {
6618 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
6619 struct elf_link_hash_entry *h;
6620
6621 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6622 h = elf_follow_link (h);
6623
6624 if (hp != NULL)
6625 *hp = h;
6626
6627 if (symp != NULL)
6628 *symp = NULL;
6629
6630 if (symsecp != NULL)
6631 {
6632 asection *symsec = NULL;
6633 if (h->root.type == bfd_link_hash_defined
6634 || h->root.type == bfd_link_hash_defweak)
6635 symsec = h->root.u.def.section;
6636 *symsecp = symsec;
6637 }
6638
6639 if (tls_maskp != NULL)
6640 {
6641 struct ppc_link_hash_entry *eh;
6642
6643 eh = (struct ppc_link_hash_entry *) h;
6644 *tls_maskp = &eh->tls_mask;
6645 }
6646 }
6647 else
6648 {
6649 Elf_Internal_Sym *sym;
6650 Elf_Internal_Sym *locsyms = *locsymsp;
6651
6652 if (locsyms == NULL)
6653 {
6654 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
6655 if (locsyms == NULL)
6656 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
6657 symtab_hdr->sh_info,
6658 0, NULL, NULL, NULL);
6659 if (locsyms == NULL)
6660 return FALSE;
6661 *locsymsp = locsyms;
6662 }
6663 sym = locsyms + r_symndx;
6664
6665 if (hp != NULL)
6666 *hp = NULL;
6667
6668 if (symp != NULL)
6669 *symp = sym;
6670
6671 if (symsecp != NULL)
6672 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
6673
6674 if (tls_maskp != NULL)
6675 {
6676 struct got_entry **lgot_ents;
6677 unsigned char *tls_mask;
6678
6679 tls_mask = NULL;
6680 lgot_ents = elf_local_got_ents (ibfd);
6681 if (lgot_ents != NULL)
6682 {
6683 struct plt_entry **local_plt = (struct plt_entry **)
6684 (lgot_ents + symtab_hdr->sh_info);
6685 unsigned char *lgot_masks = (unsigned char *)
6686 (local_plt + symtab_hdr->sh_info);
6687 tls_mask = &lgot_masks[r_symndx];
6688 }
6689 *tls_maskp = tls_mask;
6690 }
6691 }
6692 return TRUE;
6693 }
6694
6695 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
6696 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
6697 type suitable for optimization, and 1 otherwise. */
6698
6699 static int
6700 get_tls_mask (unsigned char **tls_maskp,
6701 unsigned long *toc_symndx,
6702 bfd_vma *toc_addend,
6703 Elf_Internal_Sym **locsymsp,
6704 const Elf_Internal_Rela *rel,
6705 bfd *ibfd)
6706 {
6707 unsigned long r_symndx;
6708 int next_r;
6709 struct elf_link_hash_entry *h;
6710 Elf_Internal_Sym *sym;
6711 asection *sec;
6712 bfd_vma off;
6713
6714 r_symndx = ELF64_R_SYM (rel->r_info);
6715 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6716 return 0;
6717
6718 if ((*tls_maskp != NULL && **tls_maskp != 0)
6719 || sec == NULL
6720 || ppc64_elf_section_data (sec) == NULL
6721 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
6722 return 1;
6723
6724 /* Look inside a TOC section too. */
6725 if (h != NULL)
6726 {
6727 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
6728 off = h->root.u.def.value;
6729 }
6730 else
6731 off = sym->st_value;
6732 off += rel->r_addend;
6733 BFD_ASSERT (off % 8 == 0);
6734 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
6735 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
6736 if (toc_symndx != NULL)
6737 *toc_symndx = r_symndx;
6738 if (toc_addend != NULL)
6739 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
6740 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6741 return 0;
6742 if ((h == NULL || is_static_defined (h))
6743 && (next_r == -1 || next_r == -2))
6744 return 1 - next_r;
6745 return 1;
6746 }
6747
6748 /* Adjust all global syms defined in opd sections. In gcc generated
6749 code for the old ABI, these will already have been done. */
6750
6751 static bfd_boolean
6752 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
6753 {
6754 struct ppc_link_hash_entry *eh;
6755 asection *sym_sec;
6756 struct _opd_sec_data *opd;
6757
6758 if (h->root.type == bfd_link_hash_indirect)
6759 return TRUE;
6760
6761 if (h->root.type == bfd_link_hash_warning)
6762 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6763
6764 if (h->root.type != bfd_link_hash_defined
6765 && h->root.type != bfd_link_hash_defweak)
6766 return TRUE;
6767
6768 eh = (struct ppc_link_hash_entry *) h;
6769 if (eh->adjust_done)
6770 return TRUE;
6771
6772 sym_sec = eh->elf.root.u.def.section;
6773 opd = get_opd_info (sym_sec);
6774 if (opd != NULL && opd->adjust != NULL)
6775 {
6776 long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
6777 if (adjust == -1)
6778 {
6779 /* This entry has been deleted. */
6780 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
6781 if (dsec == NULL)
6782 {
6783 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
6784 if (elf_discarded_section (dsec))
6785 {
6786 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
6787 break;
6788 }
6789 }
6790 eh->elf.root.u.def.value = 0;
6791 eh->elf.root.u.def.section = dsec;
6792 }
6793 else
6794 eh->elf.root.u.def.value += adjust;
6795 eh->adjust_done = 1;
6796 }
6797 return TRUE;
6798 }
6799
6800 /* Handles decrementing dynamic reloc counts for the reloc specified by
6801 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM_SEC
6802 have already been determined. */
6803
6804 static bfd_boolean
6805 dec_dynrel_count (bfd_vma r_info,
6806 asection *sec,
6807 struct bfd_link_info *info,
6808 Elf_Internal_Sym **local_syms,
6809 struct elf_link_hash_entry *h,
6810 asection *sym_sec)
6811 {
6812 enum elf_ppc64_reloc_type r_type;
6813 struct ppc_dyn_relocs *p;
6814 struct ppc_dyn_relocs **pp;
6815
6816 /* Can this reloc be dynamic? This switch, and later tests here
6817 should be kept in sync with the code in check_relocs. */
6818 r_type = ELF64_R_TYPE (r_info);
6819 switch (r_type)
6820 {
6821 default:
6822 return TRUE;
6823
6824 case R_PPC64_TPREL16:
6825 case R_PPC64_TPREL16_LO:
6826 case R_PPC64_TPREL16_HI:
6827 case R_PPC64_TPREL16_HA:
6828 case R_PPC64_TPREL16_DS:
6829 case R_PPC64_TPREL16_LO_DS:
6830 case R_PPC64_TPREL16_HIGHER:
6831 case R_PPC64_TPREL16_HIGHERA:
6832 case R_PPC64_TPREL16_HIGHEST:
6833 case R_PPC64_TPREL16_HIGHESTA:
6834 if (!info->shared)
6835 return TRUE;
6836
6837 case R_PPC64_TPREL64:
6838 case R_PPC64_DTPMOD64:
6839 case R_PPC64_DTPREL64:
6840 case R_PPC64_ADDR64:
6841 case R_PPC64_REL30:
6842 case R_PPC64_REL32:
6843 case R_PPC64_REL64:
6844 case R_PPC64_ADDR14:
6845 case R_PPC64_ADDR14_BRNTAKEN:
6846 case R_PPC64_ADDR14_BRTAKEN:
6847 case R_PPC64_ADDR16:
6848 case R_PPC64_ADDR16_DS:
6849 case R_PPC64_ADDR16_HA:
6850 case R_PPC64_ADDR16_HI:
6851 case R_PPC64_ADDR16_HIGHER:
6852 case R_PPC64_ADDR16_HIGHERA:
6853 case R_PPC64_ADDR16_HIGHEST:
6854 case R_PPC64_ADDR16_HIGHESTA:
6855 case R_PPC64_ADDR16_LO:
6856 case R_PPC64_ADDR16_LO_DS:
6857 case R_PPC64_ADDR24:
6858 case R_PPC64_ADDR32:
6859 case R_PPC64_UADDR16:
6860 case R_PPC64_UADDR32:
6861 case R_PPC64_UADDR64:
6862 case R_PPC64_TOC:
6863 break;
6864 }
6865
6866 if (local_syms != NULL)
6867 {
6868 unsigned long r_symndx;
6869 Elf_Internal_Sym *sym;
6870 bfd *ibfd = sec->owner;
6871
6872 r_symndx = ELF64_R_SYM (r_info);
6873 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
6874 return FALSE;
6875 }
6876
6877 if ((info->shared
6878 && (must_be_dyn_reloc (info, r_type)
6879 || (h != NULL
6880 && (!info->symbolic
6881 || h->root.type == bfd_link_hash_defweak
6882 || !h->def_regular))))
6883 || (ELIMINATE_COPY_RELOCS
6884 && !info->shared
6885 && h != NULL
6886 && (h->root.type == bfd_link_hash_defweak
6887 || !h->def_regular)))
6888 ;
6889 else
6890 return TRUE;
6891
6892 if (h != NULL)
6893 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
6894 else
6895 {
6896 if (sym_sec != NULL)
6897 {
6898 void *vpp = &elf_section_data (sym_sec)->local_dynrel;
6899 pp = (struct ppc_dyn_relocs **) vpp;
6900 }
6901 else
6902 {
6903 void *vpp = &elf_section_data (sec)->local_dynrel;
6904 pp = (struct ppc_dyn_relocs **) vpp;
6905 }
6906
6907 /* elf_gc_sweep may have already removed all dyn relocs associated
6908 with local syms for a given section. Don't report a dynreloc
6909 miscount. */
6910 if (*pp == NULL)
6911 return TRUE;
6912 }
6913
6914 while ((p = *pp) != NULL)
6915 {
6916 if (p->sec == sec)
6917 {
6918 if (!must_be_dyn_reloc (info, r_type))
6919 p->pc_count -= 1;
6920 p->count -= 1;
6921 if (p->count == 0)
6922 *pp = p->next;
6923 return TRUE;
6924 }
6925 pp = &p->next;
6926 }
6927
6928 (*_bfd_error_handler) (_("dynreloc miscount for %B, section %A"),
6929 sec->owner, sec);
6930 bfd_set_error (bfd_error_bad_value);
6931 return FALSE;
6932 }
6933
6934 /* Remove unused Official Procedure Descriptor entries. Currently we
6935 only remove those associated with functions in discarded link-once
6936 sections, or weakly defined functions that have been overridden. It
6937 would be possible to remove many more entries for statically linked
6938 applications. */
6939
6940 bfd_boolean
6941 ppc64_elf_edit_opd (struct bfd_link_info *info, bfd_boolean non_overlapping)
6942 {
6943 bfd *ibfd;
6944 bfd_boolean some_edited = FALSE;
6945 asection *need_pad = NULL;
6946
6947 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6948 {
6949 asection *sec;
6950 Elf_Internal_Rela *relstart, *rel, *relend;
6951 Elf_Internal_Shdr *symtab_hdr;
6952 Elf_Internal_Sym *local_syms;
6953 bfd_vma offset;
6954 struct _opd_sec_data *opd;
6955 bfd_boolean need_edit, add_aux_fields;
6956 bfd_size_type cnt_16b = 0;
6957
6958 if (!is_ppc64_elf (ibfd))
6959 continue;
6960
6961 sec = bfd_get_section_by_name (ibfd, ".opd");
6962 if (sec == NULL || sec->size == 0)
6963 continue;
6964
6965 if (sec->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
6966 continue;
6967
6968 if (sec->output_section == bfd_abs_section_ptr)
6969 continue;
6970
6971 /* Look through the section relocs. */
6972 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
6973 continue;
6974
6975 local_syms = NULL;
6976 symtab_hdr = &elf_symtab_hdr (ibfd);
6977
6978 /* Read the relocations. */
6979 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
6980 info->keep_memory);
6981 if (relstart == NULL)
6982 return FALSE;
6983
6984 /* First run through the relocs to check they are sane, and to
6985 determine whether we need to edit this opd section. */
6986 need_edit = FALSE;
6987 need_pad = sec;
6988 offset = 0;
6989 relend = relstart + sec->reloc_count;
6990 for (rel = relstart; rel < relend; )
6991 {
6992 enum elf_ppc64_reloc_type r_type;
6993 unsigned long r_symndx;
6994 asection *sym_sec;
6995 struct elf_link_hash_entry *h;
6996 Elf_Internal_Sym *sym;
6997
6998 /* .opd contains a regular array of 16 or 24 byte entries. We're
6999 only interested in the reloc pointing to a function entry
7000 point. */
7001 if (rel->r_offset != offset
7002 || rel + 1 >= relend
7003 || (rel + 1)->r_offset != offset + 8)
7004 {
7005 /* If someone messes with .opd alignment then after a
7006 "ld -r" we might have padding in the middle of .opd.
7007 Also, there's nothing to prevent someone putting
7008 something silly in .opd with the assembler. No .opd
7009 optimization for them! */
7010 broken_opd:
7011 (*_bfd_error_handler)
7012 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7013 need_edit = FALSE;
7014 break;
7015 }
7016
7017 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7018 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7019 {
7020 (*_bfd_error_handler)
7021 (_("%B: unexpected reloc type %u in .opd section"),
7022 ibfd, r_type);
7023 need_edit = FALSE;
7024 break;
7025 }
7026
7027 r_symndx = ELF64_R_SYM (rel->r_info);
7028 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7029 r_symndx, ibfd))
7030 goto error_ret;
7031
7032 if (sym_sec == NULL || sym_sec->owner == NULL)
7033 {
7034 const char *sym_name;
7035 if (h != NULL)
7036 sym_name = h->root.root.string;
7037 else
7038 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7039 sym_sec);
7040
7041 (*_bfd_error_handler)
7042 (_("%B: undefined sym `%s' in .opd section"),
7043 ibfd, sym_name);
7044 need_edit = FALSE;
7045 break;
7046 }
7047
7048 /* opd entries are always for functions defined in the
7049 current input bfd. If the symbol isn't defined in the
7050 input bfd, then we won't be using the function in this
7051 bfd; It must be defined in a linkonce section in another
7052 bfd, or is weak. It's also possible that we are
7053 discarding the function due to a linker script /DISCARD/,
7054 which we test for via the output_section. */
7055 if (sym_sec->owner != ibfd
7056 || sym_sec->output_section == bfd_abs_section_ptr)
7057 need_edit = TRUE;
7058
7059 rel += 2;
7060 if (rel == relend
7061 || (rel + 1 == relend && rel->r_offset == offset + 16))
7062 {
7063 if (sec->size == offset + 24)
7064 {
7065 need_pad = NULL;
7066 break;
7067 }
7068 if (rel == relend && sec->size == offset + 16)
7069 {
7070 cnt_16b++;
7071 break;
7072 }
7073 goto broken_opd;
7074 }
7075
7076 if (rel->r_offset == offset + 24)
7077 offset += 24;
7078 else if (rel->r_offset != offset + 16)
7079 goto broken_opd;
7080 else if (rel + 1 < relend
7081 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7082 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7083 {
7084 offset += 16;
7085 cnt_16b++;
7086 }
7087 else if (rel + 2 < relend
7088 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7089 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7090 {
7091 offset += 24;
7092 rel += 1;
7093 }
7094 else
7095 goto broken_opd;
7096 }
7097
7098 add_aux_fields = non_overlapping && cnt_16b > 0;
7099
7100 if (need_edit || add_aux_fields)
7101 {
7102 Elf_Internal_Rela *write_rel;
7103 Elf_Internal_Shdr *rel_hdr;
7104 bfd_byte *rptr, *wptr;
7105 bfd_byte *new_contents;
7106 bfd_boolean skip;
7107 long opd_ent_size;
7108 bfd_size_type amt;
7109
7110 new_contents = NULL;
7111 amt = sec->size * sizeof (long) / 8;
7112 opd = &ppc64_elf_section_data (sec)->u.opd;
7113 opd->adjust = bfd_zalloc (sec->owner, amt);
7114 if (opd->adjust == NULL)
7115 return FALSE;
7116 ppc64_elf_section_data (sec)->sec_type = sec_opd;
7117
7118 /* This seems a waste of time as input .opd sections are all
7119 zeros as generated by gcc, but I suppose there's no reason
7120 this will always be so. We might start putting something in
7121 the third word of .opd entries. */
7122 if ((sec->flags & SEC_IN_MEMORY) == 0)
7123 {
7124 bfd_byte *loc;
7125 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7126 {
7127 if (loc != NULL)
7128 free (loc);
7129 error_ret:
7130 if (local_syms != NULL
7131 && symtab_hdr->contents != (unsigned char *) local_syms)
7132 free (local_syms);
7133 if (elf_section_data (sec)->relocs != relstart)
7134 free (relstart);
7135 return FALSE;
7136 }
7137 sec->contents = loc;
7138 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7139 }
7140
7141 elf_section_data (sec)->relocs = relstart;
7142
7143 new_contents = sec->contents;
7144 if (add_aux_fields)
7145 {
7146 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7147 if (new_contents == NULL)
7148 return FALSE;
7149 need_pad = FALSE;
7150 }
7151 wptr = new_contents;
7152 rptr = sec->contents;
7153
7154 write_rel = relstart;
7155 skip = FALSE;
7156 offset = 0;
7157 opd_ent_size = 0;
7158 for (rel = relstart; rel < relend; rel++)
7159 {
7160 unsigned long r_symndx;
7161 asection *sym_sec;
7162 struct elf_link_hash_entry *h;
7163 Elf_Internal_Sym *sym;
7164
7165 r_symndx = ELF64_R_SYM (rel->r_info);
7166 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7167 r_symndx, ibfd))
7168 goto error_ret;
7169
7170 if (rel->r_offset == offset)
7171 {
7172 struct ppc_link_hash_entry *fdh = NULL;
7173
7174 /* See if the .opd entry is full 24 byte or
7175 16 byte (with fd_aux entry overlapped with next
7176 fd_func). */
7177 opd_ent_size = 24;
7178 if ((rel + 2 == relend && sec->size == offset + 16)
7179 || (rel + 3 < relend
7180 && rel[2].r_offset == offset + 16
7181 && rel[3].r_offset == offset + 24
7182 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7183 && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7184 opd_ent_size = 16;
7185
7186 if (h != NULL
7187 && h->root.root.string[0] == '.')
7188 {
7189 struct ppc_link_hash_table *htab;
7190
7191 htab = ppc_hash_table (info);
7192 if (htab != NULL)
7193 fdh = lookup_fdh ((struct ppc_link_hash_entry *) h,
7194 htab);
7195 if (fdh != NULL
7196 && fdh->elf.root.type != bfd_link_hash_defined
7197 && fdh->elf.root.type != bfd_link_hash_defweak)
7198 fdh = NULL;
7199 }
7200
7201 skip = (sym_sec->owner != ibfd
7202 || sym_sec->output_section == bfd_abs_section_ptr);
7203 if (skip)
7204 {
7205 if (fdh != NULL && sym_sec->owner == ibfd)
7206 {
7207 /* Arrange for the function descriptor sym
7208 to be dropped. */
7209 fdh->elf.root.u.def.value = 0;
7210 fdh->elf.root.u.def.section = sym_sec;
7211 }
7212 opd->adjust[rel->r_offset / 8] = -1;
7213 }
7214 else
7215 {
7216 /* We'll be keeping this opd entry. */
7217
7218 if (fdh != NULL)
7219 {
7220 /* Redefine the function descriptor symbol to
7221 this location in the opd section. It is
7222 necessary to update the value here rather
7223 than using an array of adjustments as we do
7224 for local symbols, because various places
7225 in the generic ELF code use the value
7226 stored in u.def.value. */
7227 fdh->elf.root.u.def.value = wptr - new_contents;
7228 fdh->adjust_done = 1;
7229 }
7230
7231 /* Local syms are a bit tricky. We could
7232 tweak them as they can be cached, but
7233 we'd need to look through the local syms
7234 for the function descriptor sym which we
7235 don't have at the moment. So keep an
7236 array of adjustments. */
7237 opd->adjust[rel->r_offset / 8]
7238 = (wptr - new_contents) - (rptr - sec->contents);
7239
7240 if (wptr != rptr)
7241 memcpy (wptr, rptr, opd_ent_size);
7242 wptr += opd_ent_size;
7243 if (add_aux_fields && opd_ent_size == 16)
7244 {
7245 memset (wptr, '\0', 8);
7246 wptr += 8;
7247 }
7248 }
7249 rptr += opd_ent_size;
7250 offset += opd_ent_size;
7251 }
7252
7253 if (skip)
7254 {
7255 if (!NO_OPD_RELOCS
7256 && !info->relocatable
7257 && !dec_dynrel_count (rel->r_info, sec, info,
7258 NULL, h, sym_sec))
7259 goto error_ret;
7260 }
7261 else
7262 {
7263 /* We need to adjust any reloc offsets to point to the
7264 new opd entries. While we're at it, we may as well
7265 remove redundant relocs. */
7266 rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7267 if (write_rel != rel)
7268 memcpy (write_rel, rel, sizeof (*rel));
7269 ++write_rel;
7270 }
7271 }
7272
7273 sec->size = wptr - new_contents;
7274 sec->reloc_count = write_rel - relstart;
7275 if (add_aux_fields)
7276 {
7277 free (sec->contents);
7278 sec->contents = new_contents;
7279 }
7280
7281 /* Fudge the header size too, as this is used later in
7282 elf_bfd_final_link if we are emitting relocs. */
7283 rel_hdr = _bfd_elf_single_rel_hdr (sec);
7284 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7285 some_edited = TRUE;
7286 }
7287 else if (elf_section_data (sec)->relocs != relstart)
7288 free (relstart);
7289
7290 if (local_syms != NULL
7291 && symtab_hdr->contents != (unsigned char *) local_syms)
7292 {
7293 if (!info->keep_memory)
7294 free (local_syms);
7295 else
7296 symtab_hdr->contents = (unsigned char *) local_syms;
7297 }
7298 }
7299
7300 if (some_edited)
7301 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7302
7303 /* If we are doing a final link and the last .opd entry is just 16 byte
7304 long, add a 8 byte padding after it. */
7305 if (need_pad != NULL && !info->relocatable)
7306 {
7307 bfd_byte *p;
7308
7309 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7310 {
7311 BFD_ASSERT (need_pad->size > 0);
7312
7313 p = bfd_malloc (need_pad->size + 8);
7314 if (p == NULL)
7315 return FALSE;
7316
7317 if (! bfd_get_section_contents (need_pad->owner, need_pad,
7318 p, 0, need_pad->size))
7319 return FALSE;
7320
7321 need_pad->contents = p;
7322 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7323 }
7324 else
7325 {
7326 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7327 if (p == NULL)
7328 return FALSE;
7329
7330 need_pad->contents = p;
7331 }
7332
7333 memset (need_pad->contents + need_pad->size, 0, 8);
7334 need_pad->size += 8;
7335 }
7336
7337 return TRUE;
7338 }
7339
7340 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
7341
7342 asection *
7343 ppc64_elf_tls_setup (struct bfd_link_info *info,
7344 int no_tls_get_addr_opt,
7345 int *no_multi_toc)
7346 {
7347 struct ppc_link_hash_table *htab;
7348
7349 htab = ppc_hash_table (info);
7350 if (htab == NULL)
7351 return NULL;
7352
7353 if (*no_multi_toc)
7354 htab->do_multi_toc = 0;
7355 else if (!htab->do_multi_toc)
7356 *no_multi_toc = 1;
7357
7358 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7359 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7360 FALSE, FALSE, TRUE));
7361 /* Move dynamic linking info to the function descriptor sym. */
7362 if (htab->tls_get_addr != NULL)
7363 func_desc_adjust (&htab->tls_get_addr->elf, info);
7364 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7365 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7366 FALSE, FALSE, TRUE));
7367 if (!no_tls_get_addr_opt)
7368 {
7369 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7370
7371 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7372 FALSE, FALSE, TRUE);
7373 if (opt != NULL)
7374 func_desc_adjust (opt, info);
7375 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7376 FALSE, FALSE, TRUE);
7377 if (opt_fd != NULL
7378 && (opt_fd->root.type == bfd_link_hash_defined
7379 || opt_fd->root.type == bfd_link_hash_defweak))
7380 {
7381 /* If glibc supports an optimized __tls_get_addr call stub,
7382 signalled by the presence of __tls_get_addr_opt, and we'll
7383 be calling __tls_get_addr via a plt call stub, then
7384 make __tls_get_addr point to __tls_get_addr_opt. */
7385 tga_fd = &htab->tls_get_addr_fd->elf;
7386 if (htab->elf.dynamic_sections_created
7387 && tga_fd != NULL
7388 && (tga_fd->type == STT_FUNC
7389 || tga_fd->needs_plt)
7390 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7391 || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
7392 && tga_fd->root.type == bfd_link_hash_undefweak)))
7393 {
7394 struct plt_entry *ent;
7395
7396 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7397 if (ent->plt.refcount > 0)
7398 break;
7399 if (ent != NULL)
7400 {
7401 tga_fd->root.type = bfd_link_hash_indirect;
7402 tga_fd->root.u.i.link = &opt_fd->root;
7403 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7404 if (opt_fd->dynindx != -1)
7405 {
7406 /* Use __tls_get_addr_opt in dynamic relocations. */
7407 opt_fd->dynindx = -1;
7408 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7409 opt_fd->dynstr_index);
7410 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
7411 return NULL;
7412 }
7413 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
7414 tga = &htab->tls_get_addr->elf;
7415 if (opt != NULL && tga != NULL)
7416 {
7417 tga->root.type = bfd_link_hash_indirect;
7418 tga->root.u.i.link = &opt->root;
7419 ppc64_elf_copy_indirect_symbol (info, opt, tga);
7420 _bfd_elf_link_hash_hide_symbol (info, opt,
7421 tga->forced_local);
7422 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
7423 }
7424 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
7425 htab->tls_get_addr_fd->is_func_descriptor = 1;
7426 if (htab->tls_get_addr != NULL)
7427 {
7428 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
7429 htab->tls_get_addr->is_func = 1;
7430 }
7431 }
7432 }
7433 }
7434 else
7435 no_tls_get_addr_opt = TRUE;
7436 }
7437 htab->no_tls_get_addr_opt = no_tls_get_addr_opt;
7438 return _bfd_elf_tls_setup (info->output_bfd, info);
7439 }
7440
7441 /* Return TRUE iff REL is a branch reloc with a global symbol matching
7442 HASH1 or HASH2. */
7443
7444 static bfd_boolean
7445 branch_reloc_hash_match (const bfd *ibfd,
7446 const Elf_Internal_Rela *rel,
7447 const struct ppc_link_hash_entry *hash1,
7448 const struct ppc_link_hash_entry *hash2)
7449 {
7450 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7451 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
7452 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
7453
7454 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
7455 {
7456 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7457 struct elf_link_hash_entry *h;
7458
7459 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7460 h = elf_follow_link (h);
7461 if (h == &hash1->elf || h == &hash2->elf)
7462 return TRUE;
7463 }
7464 return FALSE;
7465 }
7466
7467 /* Run through all the TLS relocs looking for optimization
7468 opportunities. The linker has been hacked (see ppc64elf.em) to do
7469 a preliminary section layout so that we know the TLS segment
7470 offsets. We can't optimize earlier because some optimizations need
7471 to know the tp offset, and we need to optimize before allocating
7472 dynamic relocations. */
7473
7474 bfd_boolean
7475 ppc64_elf_tls_optimize (struct bfd_link_info *info)
7476 {
7477 bfd *ibfd;
7478 asection *sec;
7479 struct ppc_link_hash_table *htab;
7480 unsigned char *toc_ref;
7481 int pass;
7482
7483 if (info->relocatable || !info->executable)
7484 return TRUE;
7485
7486 htab = ppc_hash_table (info);
7487 if (htab == NULL)
7488 return FALSE;
7489
7490 /* Make two passes over the relocs. On the first pass, mark toc
7491 entries involved with tls relocs, and check that tls relocs
7492 involved in setting up a tls_get_addr call are indeed followed by
7493 such a call. If they are not, we can't do any tls optimization.
7494 On the second pass twiddle tls_mask flags to notify
7495 relocate_section that optimization can be done, and adjust got
7496 and plt refcounts. */
7497 toc_ref = NULL;
7498 for (pass = 0; pass < 2; ++pass)
7499 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7500 {
7501 Elf_Internal_Sym *locsyms = NULL;
7502 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
7503
7504 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7505 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
7506 {
7507 Elf_Internal_Rela *relstart, *rel, *relend;
7508 bfd_boolean found_tls_get_addr_arg = 0;
7509
7510 /* Read the relocations. */
7511 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7512 info->keep_memory);
7513 if (relstart == NULL)
7514 return FALSE;
7515
7516 relend = relstart + sec->reloc_count;
7517 for (rel = relstart; rel < relend; rel++)
7518 {
7519 enum elf_ppc64_reloc_type r_type;
7520 unsigned long r_symndx;
7521 struct elf_link_hash_entry *h;
7522 Elf_Internal_Sym *sym;
7523 asection *sym_sec;
7524 unsigned char *tls_mask;
7525 unsigned char tls_set, tls_clear, tls_type = 0;
7526 bfd_vma value;
7527 bfd_boolean ok_tprel, is_local;
7528 long toc_ref_index = 0;
7529 int expecting_tls_get_addr = 0;
7530 bfd_boolean ret = FALSE;
7531
7532 r_symndx = ELF64_R_SYM (rel->r_info);
7533 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
7534 r_symndx, ibfd))
7535 {
7536 err_free_rel:
7537 if (elf_section_data (sec)->relocs != relstart)
7538 free (relstart);
7539 if (toc_ref != NULL)
7540 free (toc_ref);
7541 if (locsyms != NULL
7542 && (elf_symtab_hdr (ibfd).contents
7543 != (unsigned char *) locsyms))
7544 free (locsyms);
7545 return ret;
7546 }
7547
7548 if (h != NULL)
7549 {
7550 if (h->root.type == bfd_link_hash_defined
7551 || h->root.type == bfd_link_hash_defweak)
7552 value = h->root.u.def.value;
7553 else if (h->root.type == bfd_link_hash_undefweak)
7554 value = 0;
7555 else
7556 {
7557 found_tls_get_addr_arg = 0;
7558 continue;
7559 }
7560 }
7561 else
7562 /* Symbols referenced by TLS relocs must be of type
7563 STT_TLS. So no need for .opd local sym adjust. */
7564 value = sym->st_value;
7565
7566 ok_tprel = FALSE;
7567 is_local = FALSE;
7568 if (h == NULL
7569 || !h->def_dynamic)
7570 {
7571 is_local = TRUE;
7572 if (h != NULL
7573 && h->root.type == bfd_link_hash_undefweak)
7574 ok_tprel = TRUE;
7575 else
7576 {
7577 value += sym_sec->output_offset;
7578 value += sym_sec->output_section->vma;
7579 value -= htab->elf.tls_sec->vma;
7580 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
7581 < (bfd_vma) 1 << 32);
7582 }
7583 }
7584
7585 r_type = ELF64_R_TYPE (rel->r_info);
7586 /* If this section has old-style __tls_get_addr calls
7587 without marker relocs, then check that each
7588 __tls_get_addr call reloc is preceded by a reloc
7589 that conceivably belongs to the __tls_get_addr arg
7590 setup insn. If we don't find matching arg setup
7591 relocs, don't do any tls optimization. */
7592 if (pass == 0
7593 && sec->has_tls_get_addr_call
7594 && h != NULL
7595 && (h == &htab->tls_get_addr->elf
7596 || h == &htab->tls_get_addr_fd->elf)
7597 && !found_tls_get_addr_arg
7598 && is_branch_reloc (r_type))
7599 {
7600 info->callbacks->minfo (_("%C __tls_get_addr lost arg, "
7601 "TLS optimization disabled\n"),
7602 ibfd, sec, rel->r_offset);
7603 ret = TRUE;
7604 goto err_free_rel;
7605 }
7606
7607 found_tls_get_addr_arg = 0;
7608 switch (r_type)
7609 {
7610 case R_PPC64_GOT_TLSLD16:
7611 case R_PPC64_GOT_TLSLD16_LO:
7612 expecting_tls_get_addr = 1;
7613 found_tls_get_addr_arg = 1;
7614 /* Fall thru */
7615
7616 case R_PPC64_GOT_TLSLD16_HI:
7617 case R_PPC64_GOT_TLSLD16_HA:
7618 /* These relocs should never be against a symbol
7619 defined in a shared lib. Leave them alone if
7620 that turns out to be the case. */
7621 if (!is_local)
7622 continue;
7623
7624 /* LD -> LE */
7625 tls_set = 0;
7626 tls_clear = TLS_LD;
7627 tls_type = TLS_TLS | TLS_LD;
7628 break;
7629
7630 case R_PPC64_GOT_TLSGD16:
7631 case R_PPC64_GOT_TLSGD16_LO:
7632 expecting_tls_get_addr = 1;
7633 found_tls_get_addr_arg = 1;
7634 /* Fall thru */
7635
7636 case R_PPC64_GOT_TLSGD16_HI:
7637 case R_PPC64_GOT_TLSGD16_HA:
7638 if (ok_tprel)
7639 /* GD -> LE */
7640 tls_set = 0;
7641 else
7642 /* GD -> IE */
7643 tls_set = TLS_TLS | TLS_TPRELGD;
7644 tls_clear = TLS_GD;
7645 tls_type = TLS_TLS | TLS_GD;
7646 break;
7647
7648 case R_PPC64_GOT_TPREL16_DS:
7649 case R_PPC64_GOT_TPREL16_LO_DS:
7650 case R_PPC64_GOT_TPREL16_HI:
7651 case R_PPC64_GOT_TPREL16_HA:
7652 if (ok_tprel)
7653 {
7654 /* IE -> LE */
7655 tls_set = 0;
7656 tls_clear = TLS_TPREL;
7657 tls_type = TLS_TLS | TLS_TPREL;
7658 break;
7659 }
7660 continue;
7661
7662 case R_PPC64_TLSGD:
7663 case R_PPC64_TLSLD:
7664 found_tls_get_addr_arg = 1;
7665 /* Fall thru */
7666
7667 case R_PPC64_TLS:
7668 case R_PPC64_TOC16:
7669 case R_PPC64_TOC16_LO:
7670 if (sym_sec == NULL || sym_sec != toc)
7671 continue;
7672
7673 /* Mark this toc entry as referenced by a TLS
7674 code sequence. We can do that now in the
7675 case of R_PPC64_TLS, and after checking for
7676 tls_get_addr for the TOC16 relocs. */
7677 if (toc_ref == NULL)
7678 toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
7679 if (toc_ref == NULL)
7680 goto err_free_rel;
7681
7682 if (h != NULL)
7683 value = h->root.u.def.value;
7684 else
7685 value = sym->st_value;
7686 value += rel->r_addend;
7687 BFD_ASSERT (value < toc->size && value % 8 == 0);
7688 toc_ref_index = (value + toc->output_offset) / 8;
7689 if (r_type == R_PPC64_TLS
7690 || r_type == R_PPC64_TLSGD
7691 || r_type == R_PPC64_TLSLD)
7692 {
7693 toc_ref[toc_ref_index] = 1;
7694 continue;
7695 }
7696
7697 if (pass != 0 && toc_ref[toc_ref_index] == 0)
7698 continue;
7699
7700 tls_set = 0;
7701 tls_clear = 0;
7702 expecting_tls_get_addr = 2;
7703 break;
7704
7705 case R_PPC64_TPREL64:
7706 if (pass == 0
7707 || sec != toc
7708 || toc_ref == NULL
7709 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
7710 continue;
7711 if (ok_tprel)
7712 {
7713 /* IE -> LE */
7714 tls_set = TLS_EXPLICIT;
7715 tls_clear = TLS_TPREL;
7716 break;
7717 }
7718 continue;
7719
7720 case R_PPC64_DTPMOD64:
7721 if (pass == 0
7722 || sec != toc
7723 || toc_ref == NULL
7724 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
7725 continue;
7726 if (rel + 1 < relend
7727 && (rel[1].r_info
7728 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
7729 && rel[1].r_offset == rel->r_offset + 8)
7730 {
7731 if (ok_tprel)
7732 /* GD -> LE */
7733 tls_set = TLS_EXPLICIT | TLS_GD;
7734 else
7735 /* GD -> IE */
7736 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
7737 tls_clear = TLS_GD;
7738 }
7739 else
7740 {
7741 if (!is_local)
7742 continue;
7743
7744 /* LD -> LE */
7745 tls_set = TLS_EXPLICIT;
7746 tls_clear = TLS_LD;
7747 }
7748 break;
7749
7750 default:
7751 continue;
7752 }
7753
7754 if (pass == 0)
7755 {
7756 if (!expecting_tls_get_addr
7757 || !sec->has_tls_get_addr_call)
7758 continue;
7759
7760 if (rel + 1 < relend
7761 && branch_reloc_hash_match (ibfd, rel + 1,
7762 htab->tls_get_addr,
7763 htab->tls_get_addr_fd))
7764 {
7765 if (expecting_tls_get_addr == 2)
7766 {
7767 /* Check for toc tls entries. */
7768 unsigned char *toc_tls;
7769 int retval;
7770
7771 retval = get_tls_mask (&toc_tls, NULL, NULL,
7772 &locsyms,
7773 rel, ibfd);
7774 if (retval == 0)
7775 goto err_free_rel;
7776 if (toc_tls != NULL)
7777 {
7778 if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
7779 found_tls_get_addr_arg = 1;
7780 if (retval > 1)
7781 toc_ref[toc_ref_index] = 1;
7782 }
7783 }
7784 continue;
7785 }
7786
7787 if (expecting_tls_get_addr != 1)
7788 continue;
7789
7790 /* Uh oh, we didn't find the expected call. We
7791 could just mark this symbol to exclude it
7792 from tls optimization but it's safer to skip
7793 the entire optimization. */
7794 info->callbacks->minfo (_("%C arg lost __tls_get_addr, "
7795 "TLS optimization disabled\n"),
7796 ibfd, sec, rel->r_offset);
7797 ret = TRUE;
7798 goto err_free_rel;
7799 }
7800
7801 if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
7802 {
7803 struct plt_entry *ent;
7804 for (ent = htab->tls_get_addr->elf.plt.plist;
7805 ent != NULL;
7806 ent = ent->next)
7807 if (ent->addend == 0)
7808 {
7809 if (ent->plt.refcount > 0)
7810 {
7811 ent->plt.refcount -= 1;
7812 expecting_tls_get_addr = 0;
7813 }
7814 break;
7815 }
7816 }
7817
7818 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
7819 {
7820 struct plt_entry *ent;
7821 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
7822 ent != NULL;
7823 ent = ent->next)
7824 if (ent->addend == 0)
7825 {
7826 if (ent->plt.refcount > 0)
7827 ent->plt.refcount -= 1;
7828 break;
7829 }
7830 }
7831
7832 if (tls_clear == 0)
7833 continue;
7834
7835 if ((tls_set & TLS_EXPLICIT) == 0)
7836 {
7837 struct got_entry *ent;
7838
7839 /* Adjust got entry for this reloc. */
7840 if (h != NULL)
7841 ent = h->got.glist;
7842 else
7843 ent = elf_local_got_ents (ibfd)[r_symndx];
7844
7845 for (; ent != NULL; ent = ent->next)
7846 if (ent->addend == rel->r_addend
7847 && ent->owner == ibfd
7848 && ent->tls_type == tls_type)
7849 break;
7850 if (ent == NULL)
7851 abort ();
7852
7853 if (tls_set == 0)
7854 {
7855 /* We managed to get rid of a got entry. */
7856 if (ent->got.refcount > 0)
7857 ent->got.refcount -= 1;
7858 }
7859 }
7860 else
7861 {
7862 /* If we got rid of a DTPMOD/DTPREL reloc pair then
7863 we'll lose one or two dyn relocs. */
7864 if (!dec_dynrel_count (rel->r_info, sec, info,
7865 NULL, h, sym_sec))
7866 return FALSE;
7867
7868 if (tls_set == (TLS_EXPLICIT | TLS_GD))
7869 {
7870 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
7871 NULL, h, sym_sec))
7872 return FALSE;
7873 }
7874 }
7875
7876 *tls_mask |= tls_set;
7877 *tls_mask &= ~tls_clear;
7878 }
7879
7880 if (elf_section_data (sec)->relocs != relstart)
7881 free (relstart);
7882 }
7883
7884 if (locsyms != NULL
7885 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
7886 {
7887 if (!info->keep_memory)
7888 free (locsyms);
7889 else
7890 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
7891 }
7892 }
7893
7894 if (toc_ref != NULL)
7895 free (toc_ref);
7896 return TRUE;
7897 }
7898
7899 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
7900 the values of any global symbols in a toc section that has been
7901 edited. Globals in toc sections should be a rarity, so this function
7902 sets a flag if any are found in toc sections other than the one just
7903 edited, so that futher hash table traversals can be avoided. */
7904
7905 struct adjust_toc_info
7906 {
7907 asection *toc;
7908 unsigned long *skip;
7909 bfd_boolean global_toc_syms;
7910 };
7911
7912 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
7913
7914 static bfd_boolean
7915 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
7916 {
7917 struct ppc_link_hash_entry *eh;
7918 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
7919 unsigned long i;
7920
7921 if (h->root.type == bfd_link_hash_indirect)
7922 return TRUE;
7923
7924 if (h->root.type == bfd_link_hash_warning)
7925 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7926
7927 if (h->root.type != bfd_link_hash_defined
7928 && h->root.type != bfd_link_hash_defweak)
7929 return TRUE;
7930
7931 eh = (struct ppc_link_hash_entry *) h;
7932 if (eh->adjust_done)
7933 return TRUE;
7934
7935 if (eh->elf.root.u.def.section == toc_inf->toc)
7936 {
7937 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
7938 i = toc_inf->toc->rawsize >> 3;
7939 else
7940 i = eh->elf.root.u.def.value >> 3;
7941
7942 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
7943 {
7944 (*_bfd_error_handler)
7945 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
7946 do
7947 ++i;
7948 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
7949 eh->elf.root.u.def.value = (bfd_vma) i << 3;
7950 }
7951
7952 eh->elf.root.u.def.value -= toc_inf->skip[i];
7953 eh->adjust_done = 1;
7954 }
7955 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
7956 toc_inf->global_toc_syms = TRUE;
7957
7958 return TRUE;
7959 }
7960
7961 /* Examine all relocs referencing .toc sections in order to remove
7962 unused .toc entries. */
7963
7964 bfd_boolean
7965 ppc64_elf_edit_toc (struct bfd_link_info *info)
7966 {
7967 bfd *ibfd;
7968 struct adjust_toc_info toc_inf;
7969 struct ppc_link_hash_table *htab = ppc_hash_table (info);
7970
7971 htab->do_toc_opt = 1;
7972 toc_inf.global_toc_syms = TRUE;
7973 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7974 {
7975 asection *toc, *sec;
7976 Elf_Internal_Shdr *symtab_hdr;
7977 Elf_Internal_Sym *local_syms;
7978 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
7979 unsigned long *skip, *drop;
7980 unsigned char *used;
7981 unsigned char *keep, last, some_unused;
7982
7983 if (!is_ppc64_elf (ibfd))
7984 continue;
7985
7986 toc = bfd_get_section_by_name (ibfd, ".toc");
7987 if (toc == NULL
7988 || toc->size == 0
7989 || toc->sec_info_type == ELF_INFO_TYPE_JUST_SYMS
7990 || elf_discarded_section (toc))
7991 continue;
7992
7993 toc_relocs = NULL;
7994 local_syms = NULL;
7995 symtab_hdr = &elf_symtab_hdr (ibfd);
7996
7997 /* Look at sections dropped from the final link. */
7998 skip = NULL;
7999 relstart = NULL;
8000 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8001 {
8002 if (sec->reloc_count == 0
8003 || !elf_discarded_section (sec)
8004 || get_opd_info (sec)
8005 || (sec->flags & SEC_ALLOC) == 0
8006 || (sec->flags & SEC_DEBUGGING) != 0)
8007 continue;
8008
8009 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8010 if (relstart == NULL)
8011 goto error_ret;
8012
8013 /* Run through the relocs to see which toc entries might be
8014 unused. */
8015 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8016 {
8017 enum elf_ppc64_reloc_type r_type;
8018 unsigned long r_symndx;
8019 asection *sym_sec;
8020 struct elf_link_hash_entry *h;
8021 Elf_Internal_Sym *sym;
8022 bfd_vma val;
8023
8024 r_type = ELF64_R_TYPE (rel->r_info);
8025 switch (r_type)
8026 {
8027 default:
8028 continue;
8029
8030 case R_PPC64_TOC16:
8031 case R_PPC64_TOC16_LO:
8032 case R_PPC64_TOC16_HI:
8033 case R_PPC64_TOC16_HA:
8034 case R_PPC64_TOC16_DS:
8035 case R_PPC64_TOC16_LO_DS:
8036 break;
8037 }
8038
8039 r_symndx = ELF64_R_SYM (rel->r_info);
8040 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8041 r_symndx, ibfd))
8042 goto error_ret;
8043
8044 if (sym_sec != toc)
8045 continue;
8046
8047 if (h != NULL)
8048 val = h->root.u.def.value;
8049 else
8050 val = sym->st_value;
8051 val += rel->r_addend;
8052
8053 if (val >= toc->size)
8054 continue;
8055
8056 /* Anything in the toc ought to be aligned to 8 bytes.
8057 If not, don't mark as unused. */
8058 if (val & 7)
8059 continue;
8060
8061 if (skip == NULL)
8062 {
8063 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8064 if (skip == NULL)
8065 goto error_ret;
8066 }
8067
8068 skip[val >> 3] = ref_from_discarded;
8069 }
8070
8071 if (elf_section_data (sec)->relocs != relstart)
8072 free (relstart);
8073 }
8074
8075 /* For largetoc loads of address constants, we can convert
8076 . addis rx,2,addr@got@ha
8077 . ld ry,addr@got@l(rx)
8078 to
8079 . addis rx,2,addr@toc@ha
8080 . addi ry,rx,addr@toc@l
8081 when addr is within 2G of the toc pointer. This then means
8082 that the word storing "addr" in the toc is no longer needed. */
8083
8084 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8085 && toc->output_section->rawsize < (bfd_vma) 1 << 31
8086 && toc->reloc_count != 0)
8087 {
8088 /* Read toc relocs. */
8089 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8090 info->keep_memory);
8091 if (toc_relocs == NULL)
8092 goto error_ret;
8093
8094 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8095 {
8096 enum elf_ppc64_reloc_type r_type;
8097 unsigned long r_symndx;
8098 asection *sym_sec;
8099 struct elf_link_hash_entry *h;
8100 Elf_Internal_Sym *sym;
8101 bfd_vma val, addr;
8102
8103 r_type = ELF64_R_TYPE (rel->r_info);
8104 if (r_type != R_PPC64_ADDR64)
8105 continue;
8106
8107 r_symndx = ELF64_R_SYM (rel->r_info);
8108 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8109 r_symndx, ibfd))
8110 goto error_ret;
8111
8112 if (sym_sec == NULL
8113 || elf_discarded_section (sym_sec))
8114 continue;
8115
8116 if (!SYMBOL_CALLS_LOCAL (info, h))
8117 continue;
8118
8119 if (h != NULL)
8120 {
8121 if (h->type == STT_GNU_IFUNC)
8122 continue;
8123 val = h->root.u.def.value;
8124 }
8125 else
8126 {
8127 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8128 continue;
8129 val = sym->st_value;
8130 }
8131 val += rel->r_addend;
8132 val += sym_sec->output_section->vma + sym_sec->output_offset;
8133
8134 /* We don't yet know the exact toc pointer value, but we
8135 know it will be somewhere in the toc section. Don't
8136 optimize if the difference from any possible toc
8137 pointer is outside [ff..f80008000, 7fff7fff]. */
8138 addr = toc->output_section->vma + TOC_BASE_OFF;
8139 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8140 continue;
8141
8142 addr = toc->output_section->vma + toc->output_section->rawsize;
8143 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8144 continue;
8145
8146 if (skip == NULL)
8147 {
8148 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8149 if (skip == NULL)
8150 goto error_ret;
8151 }
8152
8153 skip[rel->r_offset >> 3]
8154 |= can_optimize | ((rel - toc_relocs) << 2);
8155 }
8156 }
8157
8158 if (skip == NULL)
8159 continue;
8160
8161 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8162 if (used == NULL)
8163 {
8164 error_ret:
8165 if (local_syms != NULL
8166 && symtab_hdr->contents != (unsigned char *) local_syms)
8167 free (local_syms);
8168 if (sec != NULL
8169 && relstart != NULL
8170 && elf_section_data (sec)->relocs != relstart)
8171 free (relstart);
8172 if (toc_relocs != NULL
8173 && elf_section_data (toc)->relocs != toc_relocs)
8174 free (toc_relocs);
8175 if (skip != NULL)
8176 free (skip);
8177 return FALSE;
8178 }
8179
8180 /* Now check all kept sections that might reference the toc.
8181 Check the toc itself last. */
8182 for (sec = (ibfd->sections == toc && toc->next ? toc->next
8183 : ibfd->sections);
8184 sec != NULL;
8185 sec = (sec == toc ? NULL
8186 : sec->next == NULL ? toc
8187 : sec->next == toc && toc->next ? toc->next
8188 : sec->next))
8189 {
8190 int repeat;
8191
8192 if (sec->reloc_count == 0
8193 || elf_discarded_section (sec)
8194 || get_opd_info (sec)
8195 || (sec->flags & SEC_ALLOC) == 0
8196 || (sec->flags & SEC_DEBUGGING) != 0)
8197 continue;
8198
8199 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8200 info->keep_memory);
8201 if (relstart == NULL)
8202 goto error_ret;
8203
8204 /* Mark toc entries referenced as used. */
8205 repeat = 0;
8206 do
8207 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8208 {
8209 enum elf_ppc64_reloc_type r_type;
8210 unsigned long r_symndx;
8211 asection *sym_sec;
8212 struct elf_link_hash_entry *h;
8213 Elf_Internal_Sym *sym;
8214 bfd_vma val;
8215
8216 r_type = ELF64_R_TYPE (rel->r_info);
8217 switch (r_type)
8218 {
8219 case R_PPC64_TOC16:
8220 case R_PPC64_TOC16_LO:
8221 case R_PPC64_TOC16_HI:
8222 case R_PPC64_TOC16_HA:
8223 case R_PPC64_TOC16_DS:
8224 case R_PPC64_TOC16_LO_DS:
8225 /* In case we're taking addresses of toc entries. */
8226 case R_PPC64_ADDR64:
8227 break;
8228
8229 default:
8230 continue;
8231 }
8232
8233 r_symndx = ELF64_R_SYM (rel->r_info);
8234 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8235 r_symndx, ibfd))
8236 {
8237 free (used);
8238 goto error_ret;
8239 }
8240
8241 if (sym_sec != toc)
8242 continue;
8243
8244 if (h != NULL)
8245 val = h->root.u.def.value;
8246 else
8247 val = sym->st_value;
8248 val += rel->r_addend;
8249
8250 if (val >= toc->size)
8251 continue;
8252
8253 if ((skip[val >> 3] & can_optimize) != 0)
8254 {
8255 bfd_vma off;
8256 unsigned char opc;
8257
8258 switch (r_type)
8259 {
8260 case R_PPC64_TOC16_HA:
8261 break;
8262
8263 case R_PPC64_TOC16_LO_DS:
8264 off = rel->r_offset + (bfd_big_endian (ibfd) ? -2 : 3);
8265 if (!bfd_get_section_contents (ibfd, sec, &opc, off, 1))
8266 return FALSE;
8267 if ((opc & (0x3f << 2)) == (58u << 2))
8268 break;
8269 /* Fall thru */
8270
8271 default:
8272 /* Wrong sort of reloc, or not a ld. We may
8273 as well clear ref_from_discarded too. */
8274 skip[val >> 3] = 0;
8275 }
8276 }
8277
8278 /* For the toc section, we only mark as used if
8279 this entry itself isn't unused. */
8280 if (sec == toc
8281 && !used[val >> 3]
8282 && (used[rel->r_offset >> 3]
8283 || !(skip[rel->r_offset >> 3] & ref_from_discarded)))
8284 /* Do all the relocs again, to catch reference
8285 chains. */
8286 repeat = 1;
8287
8288 used[val >> 3] = 1;
8289 }
8290 while (repeat);
8291
8292 if (elf_section_data (sec)->relocs != relstart)
8293 free (relstart);
8294 }
8295
8296 /* Merge the used and skip arrays. Assume that TOC
8297 doublewords not appearing as either used or unused belong
8298 to to an entry more than one doubleword in size. */
8299 for (drop = skip, keep = used, last = 0, some_unused = 0;
8300 drop < skip + (toc->size + 7) / 8;
8301 ++drop, ++keep)
8302 {
8303 if (*keep)
8304 {
8305 *drop &= ~ref_from_discarded;
8306 if ((*drop & can_optimize) != 0)
8307 some_unused = 1;
8308 last = 0;
8309 }
8310 else if (*drop)
8311 {
8312 some_unused = 1;
8313 last = ref_from_discarded;
8314 }
8315 else
8316 *drop = last;
8317 }
8318
8319 free (used);
8320
8321 if (some_unused)
8322 {
8323 bfd_byte *contents, *src;
8324 unsigned long off;
8325 Elf_Internal_Sym *sym;
8326 bfd_boolean local_toc_syms = FALSE;
8327
8328 /* Shuffle the toc contents, and at the same time convert the
8329 skip array from booleans into offsets. */
8330 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
8331 goto error_ret;
8332
8333 elf_section_data (toc)->this_hdr.contents = contents;
8334
8335 for (src = contents, off = 0, drop = skip;
8336 src < contents + toc->size;
8337 src += 8, ++drop)
8338 {
8339 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
8340 off += 8;
8341 else if (off != 0)
8342 {
8343 *drop = off;
8344 memcpy (src - off, src, 8);
8345 }
8346 }
8347 *drop = off;
8348 toc->rawsize = toc->size;
8349 toc->size = src - contents - off;
8350
8351 /* Adjust addends for relocs against the toc section sym,
8352 and optimize any accesses we can. */
8353 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8354 {
8355 if (sec->reloc_count == 0
8356 || elf_discarded_section (sec))
8357 continue;
8358
8359 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8360 info->keep_memory);
8361 if (relstart == NULL)
8362 goto error_ret;
8363
8364 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8365 {
8366 enum elf_ppc64_reloc_type r_type;
8367 unsigned long r_symndx;
8368 asection *sym_sec;
8369 struct elf_link_hash_entry *h;
8370 bfd_vma val;
8371
8372 r_type = ELF64_R_TYPE (rel->r_info);
8373 switch (r_type)
8374 {
8375 default:
8376 continue;
8377
8378 case R_PPC64_TOC16:
8379 case R_PPC64_TOC16_LO:
8380 case R_PPC64_TOC16_HI:
8381 case R_PPC64_TOC16_HA:
8382 case R_PPC64_TOC16_DS:
8383 case R_PPC64_TOC16_LO_DS:
8384 case R_PPC64_ADDR64:
8385 break;
8386 }
8387
8388 r_symndx = ELF64_R_SYM (rel->r_info);
8389 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8390 r_symndx, ibfd))
8391 goto error_ret;
8392
8393 if (sym_sec != toc)
8394 continue;
8395
8396 if (h != NULL)
8397 val = h->root.u.def.value;
8398 else
8399 {
8400 val = sym->st_value;
8401 if (val != 0)
8402 local_toc_syms = TRUE;
8403 }
8404
8405 val += rel->r_addend;
8406
8407 if (val > toc->rawsize)
8408 val = toc->rawsize;
8409 else if ((skip[val >> 3] & ref_from_discarded) != 0)
8410 continue;
8411 else if ((skip[val >> 3] & can_optimize) != 0)
8412 {
8413 Elf_Internal_Rela *tocrel
8414 = toc_relocs + (skip[val >> 3] >> 2);
8415 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
8416
8417 switch (r_type)
8418 {
8419 case R_PPC64_TOC16_HA:
8420 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
8421 break;
8422
8423 case R_PPC64_TOC16_LO_DS:
8424 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
8425 break;
8426
8427 default:
8428 abort ();
8429 }
8430 rel->r_addend = tocrel->r_addend;
8431 elf_section_data (sec)->relocs = relstart;
8432 continue;
8433 }
8434
8435 if (h != NULL || sym->st_value != 0)
8436 continue;
8437
8438 rel->r_addend -= skip[val >> 3];
8439 elf_section_data (sec)->relocs = relstart;
8440 }
8441
8442 if (elf_section_data (sec)->relocs != relstart)
8443 free (relstart);
8444 }
8445
8446 /* We shouldn't have local or global symbols defined in the TOC,
8447 but handle them anyway. */
8448 if (local_syms != NULL)
8449 for (sym = local_syms;
8450 sym < local_syms + symtab_hdr->sh_info;
8451 ++sym)
8452 if (sym->st_value != 0
8453 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
8454 {
8455 unsigned long i;
8456
8457 if (sym->st_value > toc->rawsize)
8458 i = toc->rawsize >> 3;
8459 else
8460 i = sym->st_value >> 3;
8461
8462 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
8463 {
8464 if (local_toc_syms)
8465 (*_bfd_error_handler)
8466 (_("%s defined on removed toc entry"),
8467 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
8468 do
8469 ++i;
8470 while ((skip[i] & (ref_from_discarded | can_optimize)));
8471 sym->st_value = (bfd_vma) i << 3;
8472 }
8473
8474 sym->st_value -= skip[i];
8475 symtab_hdr->contents = (unsigned char *) local_syms;
8476 }
8477
8478 /* Adjust any global syms defined in this toc input section. */
8479 if (toc_inf.global_toc_syms)
8480 {
8481 toc_inf.toc = toc;
8482 toc_inf.skip = skip;
8483 toc_inf.global_toc_syms = FALSE;
8484 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
8485 &toc_inf);
8486 }
8487
8488 if (toc->reloc_count != 0)
8489 {
8490 Elf_Internal_Shdr *rel_hdr;
8491 Elf_Internal_Rela *wrel;
8492 bfd_size_type sz;
8493
8494 /* Remove unused toc relocs, and adjust those we keep. */
8495 if (toc_relocs == NULL)
8496 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8497 info->keep_memory);
8498 if (toc_relocs == NULL)
8499 goto error_ret;
8500
8501 wrel = toc_relocs;
8502 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8503 if ((skip[rel->r_offset >> 3]
8504 & (ref_from_discarded | can_optimize)) == 0)
8505 {
8506 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
8507 wrel->r_info = rel->r_info;
8508 wrel->r_addend = rel->r_addend;
8509 ++wrel;
8510 }
8511 else if (!dec_dynrel_count (rel->r_info, toc, info,
8512 &local_syms, NULL, NULL))
8513 goto error_ret;
8514
8515 elf_section_data (toc)->relocs = toc_relocs;
8516 toc->reloc_count = wrel - toc_relocs;
8517 rel_hdr = _bfd_elf_single_rel_hdr (toc);
8518 sz = rel_hdr->sh_entsize;
8519 rel_hdr->sh_size = toc->reloc_count * sz;
8520 }
8521 }
8522 else if (toc_relocs != NULL
8523 && elf_section_data (toc)->relocs != toc_relocs)
8524 free (toc_relocs);
8525
8526 if (local_syms != NULL
8527 && symtab_hdr->contents != (unsigned char *) local_syms)
8528 {
8529 if (!info->keep_memory)
8530 free (local_syms);
8531 else
8532 symtab_hdr->contents = (unsigned char *) local_syms;
8533 }
8534 free (skip);
8535 }
8536
8537 return TRUE;
8538 }
8539
8540 /* Return true iff input section I references the TOC using
8541 instructions limited to +/-32k offsets. */
8542
8543 bfd_boolean
8544 ppc64_elf_has_small_toc_reloc (asection *i)
8545 {
8546 return (is_ppc64_elf (i->owner)
8547 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
8548 }
8549
8550 /* Allocate space for one GOT entry. */
8551
8552 static void
8553 allocate_got (struct elf_link_hash_entry *h,
8554 struct bfd_link_info *info,
8555 struct got_entry *gent)
8556 {
8557 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8558 bfd_boolean dyn;
8559 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
8560 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
8561 ? 16 : 8);
8562 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
8563 ? 2 : 1) * sizeof (Elf64_External_Rela);
8564 asection *got = ppc64_elf_tdata (gent->owner)->got;
8565
8566 gent->got.offset = got->size;
8567 got->size += entsize;
8568
8569 dyn = htab->elf.dynamic_sections_created;
8570 if ((info->shared
8571 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
8572 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
8573 || h->root.type != bfd_link_hash_undefweak))
8574 {
8575 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
8576 relgot->size += rentsize;
8577 }
8578 else if (h->type == STT_GNU_IFUNC)
8579 {
8580 asection *relgot = htab->reliplt;
8581 relgot->size += rentsize;
8582 htab->got_reli_size += rentsize;
8583 }
8584 }
8585
8586 /* This function merges got entries in the same toc group. */
8587
8588 static void
8589 merge_got_entries (struct got_entry **pent)
8590 {
8591 struct got_entry *ent, *ent2;
8592
8593 for (ent = *pent; ent != NULL; ent = ent->next)
8594 if (!ent->is_indirect)
8595 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
8596 if (!ent2->is_indirect
8597 && ent2->addend == ent->addend
8598 && ent2->tls_type == ent->tls_type
8599 && elf_gp (ent2->owner) == elf_gp (ent->owner))
8600 {
8601 ent2->is_indirect = TRUE;
8602 ent2->got.ent = ent;
8603 }
8604 }
8605
8606 /* Allocate space in .plt, .got and associated reloc sections for
8607 dynamic relocs. */
8608
8609 static bfd_boolean
8610 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
8611 {
8612 struct bfd_link_info *info;
8613 struct ppc_link_hash_table *htab;
8614 asection *s;
8615 struct ppc_link_hash_entry *eh;
8616 struct ppc_dyn_relocs *p;
8617 struct got_entry **pgent, *gent;
8618
8619 if (h->root.type == bfd_link_hash_indirect)
8620 return TRUE;
8621
8622 if (h->root.type == bfd_link_hash_warning)
8623 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8624
8625 info = (struct bfd_link_info *) inf;
8626 htab = ppc_hash_table (info);
8627 if (htab == NULL)
8628 return FALSE;
8629
8630 if ((htab->elf.dynamic_sections_created
8631 && h->dynindx != -1
8632 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
8633 || h->type == STT_GNU_IFUNC)
8634 {
8635 struct plt_entry *pent;
8636 bfd_boolean doneone = FALSE;
8637 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
8638 if (pent->plt.refcount > 0)
8639 {
8640 if (!htab->elf.dynamic_sections_created
8641 || h->dynindx == -1)
8642 {
8643 s = htab->iplt;
8644 pent->plt.offset = s->size;
8645 s->size += PLT_ENTRY_SIZE;
8646 s = htab->reliplt;
8647 }
8648 else
8649 {
8650 /* If this is the first .plt entry, make room for the special
8651 first entry. */
8652 s = htab->plt;
8653 if (s->size == 0)
8654 s->size += PLT_INITIAL_ENTRY_SIZE;
8655
8656 pent->plt.offset = s->size;
8657
8658 /* Make room for this entry. */
8659 s->size += PLT_ENTRY_SIZE;
8660
8661 /* Make room for the .glink code. */
8662 s = htab->glink;
8663 if (s->size == 0)
8664 s->size += GLINK_CALL_STUB_SIZE;
8665 /* We need bigger stubs past index 32767. */
8666 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
8667 s->size += 4;
8668 s->size += 2*4;
8669
8670 /* We also need to make an entry in the .rela.plt section. */
8671 s = htab->relplt;
8672 }
8673 s->size += sizeof (Elf64_External_Rela);
8674 doneone = TRUE;
8675 }
8676 else
8677 pent->plt.offset = (bfd_vma) -1;
8678 if (!doneone)
8679 {
8680 h->plt.plist = NULL;
8681 h->needs_plt = 0;
8682 }
8683 }
8684 else
8685 {
8686 h->plt.plist = NULL;
8687 h->needs_plt = 0;
8688 }
8689
8690 eh = (struct ppc_link_hash_entry *) h;
8691 /* Run through the TLS GD got entries first if we're changing them
8692 to TPREL. */
8693 if ((eh->tls_mask & TLS_TPRELGD) != 0)
8694 for (gent = h->got.glist; gent != NULL; gent = gent->next)
8695 if (gent->got.refcount > 0
8696 && (gent->tls_type & TLS_GD) != 0)
8697 {
8698 /* This was a GD entry that has been converted to TPREL. If
8699 there happens to be a TPREL entry we can use that one. */
8700 struct got_entry *ent;
8701 for (ent = h->got.glist; ent != NULL; ent = ent->next)
8702 if (ent->got.refcount > 0
8703 && (ent->tls_type & TLS_TPREL) != 0
8704 && ent->addend == gent->addend
8705 && ent->owner == gent->owner)
8706 {
8707 gent->got.refcount = 0;
8708 break;
8709 }
8710
8711 /* If not, then we'll be using our own TPREL entry. */
8712 if (gent->got.refcount != 0)
8713 gent->tls_type = TLS_TLS | TLS_TPREL;
8714 }
8715
8716 /* Remove any list entry that won't generate a word in the GOT before
8717 we call merge_got_entries. Otherwise we risk merging to empty
8718 entries. */
8719 pgent = &h->got.glist;
8720 while ((gent = *pgent) != NULL)
8721 if (gent->got.refcount > 0)
8722 {
8723 if ((gent->tls_type & TLS_LD) != 0
8724 && !h->def_dynamic)
8725 {
8726 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
8727 *pgent = gent->next;
8728 }
8729 else
8730 pgent = &gent->next;
8731 }
8732 else
8733 *pgent = gent->next;
8734
8735 if (!htab->do_multi_toc)
8736 merge_got_entries (&h->got.glist);
8737
8738 for (gent = h->got.glist; gent != NULL; gent = gent->next)
8739 if (!gent->is_indirect)
8740 {
8741 /* Make sure this symbol is output as a dynamic symbol.
8742 Undefined weak syms won't yet be marked as dynamic,
8743 nor will all TLS symbols. */
8744 if (h->dynindx == -1
8745 && !h->forced_local
8746 && h->type != STT_GNU_IFUNC
8747 && htab->elf.dynamic_sections_created)
8748 {
8749 if (! bfd_elf_link_record_dynamic_symbol (info, h))
8750 return FALSE;
8751 }
8752
8753 if (!is_ppc64_elf (gent->owner))
8754 abort ();
8755
8756 allocate_got (h, info, gent);
8757 }
8758
8759 if (eh->dyn_relocs == NULL
8760 || (!htab->elf.dynamic_sections_created
8761 && h->type != STT_GNU_IFUNC))
8762 return TRUE;
8763
8764 /* In the shared -Bsymbolic case, discard space allocated for
8765 dynamic pc-relative relocs against symbols which turn out to be
8766 defined in regular objects. For the normal shared case, discard
8767 space for relocs that have become local due to symbol visibility
8768 changes. */
8769
8770 if (info->shared)
8771 {
8772 /* Relocs that use pc_count are those that appear on a call insn,
8773 or certain REL relocs (see must_be_dyn_reloc) that can be
8774 generated via assembly. We want calls to protected symbols to
8775 resolve directly to the function rather than going via the plt.
8776 If people want function pointer comparisons to work as expected
8777 then they should avoid writing weird assembly. */
8778 if (SYMBOL_CALLS_LOCAL (info, h))
8779 {
8780 struct ppc_dyn_relocs **pp;
8781
8782 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
8783 {
8784 p->count -= p->pc_count;
8785 p->pc_count = 0;
8786 if (p->count == 0)
8787 *pp = p->next;
8788 else
8789 pp = &p->next;
8790 }
8791 }
8792
8793 /* Also discard relocs on undefined weak syms with non-default
8794 visibility. */
8795 if (eh->dyn_relocs != NULL
8796 && h->root.type == bfd_link_hash_undefweak)
8797 {
8798 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
8799 eh->dyn_relocs = NULL;
8800
8801 /* Make sure this symbol is output as a dynamic symbol.
8802 Undefined weak syms won't yet be marked as dynamic. */
8803 else if (h->dynindx == -1
8804 && !h->forced_local)
8805 {
8806 if (! bfd_elf_link_record_dynamic_symbol (info, h))
8807 return FALSE;
8808 }
8809 }
8810 }
8811 else if (h->type == STT_GNU_IFUNC)
8812 {
8813 if (!h->non_got_ref)
8814 eh->dyn_relocs = NULL;
8815 }
8816 else if (ELIMINATE_COPY_RELOCS)
8817 {
8818 /* For the non-shared case, discard space for relocs against
8819 symbols which turn out to need copy relocs or are not
8820 dynamic. */
8821
8822 if (!h->non_got_ref
8823 && !h->def_regular)
8824 {
8825 /* Make sure this symbol is output as a dynamic symbol.
8826 Undefined weak syms won't yet be marked as dynamic. */
8827 if (h->dynindx == -1
8828 && !h->forced_local)
8829 {
8830 if (! bfd_elf_link_record_dynamic_symbol (info, h))
8831 return FALSE;
8832 }
8833
8834 /* If that succeeded, we know we'll be keeping all the
8835 relocs. */
8836 if (h->dynindx != -1)
8837 goto keep;
8838 }
8839
8840 eh->dyn_relocs = NULL;
8841
8842 keep: ;
8843 }
8844
8845 /* Finally, allocate space. */
8846 for (p = eh->dyn_relocs; p != NULL; p = p->next)
8847 {
8848 asection *sreloc = elf_section_data (p->sec)->sreloc;
8849 if (!htab->elf.dynamic_sections_created)
8850 sreloc = htab->reliplt;
8851 sreloc->size += p->count * sizeof (Elf64_External_Rela);
8852 }
8853
8854 return TRUE;
8855 }
8856
8857 /* Find any dynamic relocs that apply to read-only sections. */
8858
8859 static bfd_boolean
8860 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
8861 {
8862 struct ppc_link_hash_entry *eh;
8863 struct ppc_dyn_relocs *p;
8864
8865 if (h->root.type == bfd_link_hash_warning)
8866 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8867
8868 eh = (struct ppc_link_hash_entry *) h;
8869 for (p = eh->dyn_relocs; p != NULL; p = p->next)
8870 {
8871 asection *s = p->sec->output_section;
8872
8873 if (s != NULL && (s->flags & SEC_READONLY) != 0)
8874 {
8875 struct bfd_link_info *info = inf;
8876
8877 info->flags |= DF_TEXTREL;
8878
8879 /* Not an error, just cut short the traversal. */
8880 return FALSE;
8881 }
8882 }
8883 return TRUE;
8884 }
8885
8886 /* Set the sizes of the dynamic sections. */
8887
8888 static bfd_boolean
8889 ppc64_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
8890 struct bfd_link_info *info)
8891 {
8892 struct ppc_link_hash_table *htab;
8893 bfd *dynobj;
8894 asection *s;
8895 bfd_boolean relocs;
8896 bfd *ibfd;
8897 struct got_entry *first_tlsld;
8898
8899 htab = ppc_hash_table (info);
8900 if (htab == NULL)
8901 return FALSE;
8902
8903 dynobj = htab->elf.dynobj;
8904 if (dynobj == NULL)
8905 abort ();
8906
8907 if (htab->elf.dynamic_sections_created)
8908 {
8909 /* Set the contents of the .interp section to the interpreter. */
8910 if (info->executable)
8911 {
8912 s = bfd_get_section_by_name (dynobj, ".interp");
8913 if (s == NULL)
8914 abort ();
8915 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
8916 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
8917 }
8918 }
8919
8920 /* Set up .got offsets for local syms, and space for local dynamic
8921 relocs. */
8922 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8923 {
8924 struct got_entry **lgot_ents;
8925 struct got_entry **end_lgot_ents;
8926 struct plt_entry **local_plt;
8927 struct plt_entry **end_local_plt;
8928 unsigned char *lgot_masks;
8929 bfd_size_type locsymcount;
8930 Elf_Internal_Shdr *symtab_hdr;
8931 asection *srel;
8932
8933 if (!is_ppc64_elf (ibfd))
8934 continue;
8935
8936 for (s = ibfd->sections; s != NULL; s = s->next)
8937 {
8938 struct ppc_dyn_relocs *p;
8939
8940 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
8941 {
8942 if (!bfd_is_abs_section (p->sec)
8943 && bfd_is_abs_section (p->sec->output_section))
8944 {
8945 /* Input section has been discarded, either because
8946 it is a copy of a linkonce section or due to
8947 linker script /DISCARD/, so we'll be discarding
8948 the relocs too. */
8949 }
8950 else if (p->count != 0)
8951 {
8952 srel = elf_section_data (p->sec)->sreloc;
8953 if (!htab->elf.dynamic_sections_created)
8954 srel = htab->reliplt;
8955 srel->size += p->count * sizeof (Elf64_External_Rela);
8956 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
8957 info->flags |= DF_TEXTREL;
8958 }
8959 }
8960 }
8961
8962 lgot_ents = elf_local_got_ents (ibfd);
8963 if (!lgot_ents)
8964 continue;
8965
8966 symtab_hdr = &elf_symtab_hdr (ibfd);
8967 locsymcount = symtab_hdr->sh_info;
8968 end_lgot_ents = lgot_ents + locsymcount;
8969 local_plt = (struct plt_entry **) end_lgot_ents;
8970 end_local_plt = local_plt + locsymcount;
8971 lgot_masks = (unsigned char *) end_local_plt;
8972 s = ppc64_elf_tdata (ibfd)->got;
8973 srel = ppc64_elf_tdata (ibfd)->relgot;
8974 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
8975 {
8976 struct got_entry **pent, *ent;
8977
8978 pent = lgot_ents;
8979 while ((ent = *pent) != NULL)
8980 if (ent->got.refcount > 0)
8981 {
8982 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
8983 {
8984 ppc64_tlsld_got (ibfd)->got.refcount += 1;
8985 *pent = ent->next;
8986 }
8987 else
8988 {
8989 unsigned int num = 1;
8990 ent->got.offset = s->size;
8991 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
8992 num = 2;
8993 s->size += num * 8;
8994 if (info->shared)
8995 srel->size += num * sizeof (Elf64_External_Rela);
8996 else if ((*lgot_masks & PLT_IFUNC) != 0)
8997 {
8998 htab->reliplt->size
8999 += num * sizeof (Elf64_External_Rela);
9000 htab->got_reli_size
9001 += num * sizeof (Elf64_External_Rela);
9002 }
9003 pent = &ent->next;
9004 }
9005 }
9006 else
9007 *pent = ent->next;
9008 }
9009
9010 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
9011 for (; local_plt < end_local_plt; ++local_plt)
9012 {
9013 struct plt_entry *ent;
9014
9015 for (ent = *local_plt; ent != NULL; ent = ent->next)
9016 if (ent->plt.refcount > 0)
9017 {
9018 s = htab->iplt;
9019 ent->plt.offset = s->size;
9020 s->size += PLT_ENTRY_SIZE;
9021
9022 htab->reliplt->size += sizeof (Elf64_External_Rela);
9023 }
9024 else
9025 ent->plt.offset = (bfd_vma) -1;
9026 }
9027 }
9028
9029 /* Allocate global sym .plt and .got entries, and space for global
9030 sym dynamic relocs. */
9031 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9032
9033 first_tlsld = NULL;
9034 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9035 {
9036 struct got_entry *ent;
9037
9038 if (!is_ppc64_elf (ibfd))
9039 continue;
9040
9041 ent = ppc64_tlsld_got (ibfd);
9042 if (ent->got.refcount > 0)
9043 {
9044 if (!htab->do_multi_toc && first_tlsld != NULL)
9045 {
9046 ent->is_indirect = TRUE;
9047 ent->got.ent = first_tlsld;
9048 }
9049 else
9050 {
9051 if (first_tlsld == NULL)
9052 first_tlsld = ent;
9053 s = ppc64_elf_tdata (ibfd)->got;
9054 ent->got.offset = s->size;
9055 ent->owner = ibfd;
9056 s->size += 16;
9057 if (info->shared)
9058 {
9059 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9060 srel->size += sizeof (Elf64_External_Rela);
9061 }
9062 }
9063 }
9064 else
9065 ent->got.offset = (bfd_vma) -1;
9066 }
9067
9068 /* We now have determined the sizes of the various dynamic sections.
9069 Allocate memory for them. */
9070 relocs = FALSE;
9071 for (s = dynobj->sections; s != NULL; s = s->next)
9072 {
9073 if ((s->flags & SEC_LINKER_CREATED) == 0)
9074 continue;
9075
9076 if (s == htab->brlt || s == htab->relbrlt)
9077 /* These haven't been allocated yet; don't strip. */
9078 continue;
9079 else if (s == htab->got
9080 || s == htab->plt
9081 || s == htab->iplt
9082 || s == htab->glink
9083 || s == htab->dynbss)
9084 {
9085 /* Strip this section if we don't need it; see the
9086 comment below. */
9087 }
9088 else if (CONST_STRNEQ (s->name, ".rela"))
9089 {
9090 if (s->size != 0)
9091 {
9092 if (s != htab->relplt)
9093 relocs = TRUE;
9094
9095 /* We use the reloc_count field as a counter if we need
9096 to copy relocs into the output file. */
9097 s->reloc_count = 0;
9098 }
9099 }
9100 else
9101 {
9102 /* It's not one of our sections, so don't allocate space. */
9103 continue;
9104 }
9105
9106 if (s->size == 0)
9107 {
9108 /* If we don't need this section, strip it from the
9109 output file. This is mostly to handle .rela.bss and
9110 .rela.plt. We must create both sections in
9111 create_dynamic_sections, because they must be created
9112 before the linker maps input sections to output
9113 sections. The linker does that before
9114 adjust_dynamic_symbol is called, and it is that
9115 function which decides whether anything needs to go
9116 into these sections. */
9117 s->flags |= SEC_EXCLUDE;
9118 continue;
9119 }
9120
9121 if ((s->flags & SEC_HAS_CONTENTS) == 0)
9122 continue;
9123
9124 /* Allocate memory for the section contents. We use bfd_zalloc
9125 here in case unused entries are not reclaimed before the
9126 section's contents are written out. This should not happen,
9127 but this way if it does we get a R_PPC64_NONE reloc in .rela
9128 sections instead of garbage.
9129 We also rely on the section contents being zero when writing
9130 the GOT. */
9131 s->contents = bfd_zalloc (dynobj, s->size);
9132 if (s->contents == NULL)
9133 return FALSE;
9134 }
9135
9136 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9137 {
9138 if (!is_ppc64_elf (ibfd))
9139 continue;
9140
9141 s = ppc64_elf_tdata (ibfd)->got;
9142 if (s != NULL && s != htab->got)
9143 {
9144 if (s->size == 0)
9145 s->flags |= SEC_EXCLUDE;
9146 else
9147 {
9148 s->contents = bfd_zalloc (ibfd, s->size);
9149 if (s->contents == NULL)
9150 return FALSE;
9151 }
9152 }
9153 s = ppc64_elf_tdata (ibfd)->relgot;
9154 if (s != NULL)
9155 {
9156 if (s->size == 0)
9157 s->flags |= SEC_EXCLUDE;
9158 else
9159 {
9160 s->contents = bfd_zalloc (ibfd, s->size);
9161 if (s->contents == NULL)
9162 return FALSE;
9163 relocs = TRUE;
9164 s->reloc_count = 0;
9165 }
9166 }
9167 }
9168
9169 if (htab->elf.dynamic_sections_created)
9170 {
9171 /* Add some entries to the .dynamic section. We fill in the
9172 values later, in ppc64_elf_finish_dynamic_sections, but we
9173 must add the entries now so that we get the correct size for
9174 the .dynamic section. The DT_DEBUG entry is filled in by the
9175 dynamic linker and used by the debugger. */
9176 #define add_dynamic_entry(TAG, VAL) \
9177 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9178
9179 if (info->executable)
9180 {
9181 if (!add_dynamic_entry (DT_DEBUG, 0))
9182 return FALSE;
9183 }
9184
9185 if (htab->plt != NULL && htab->plt->size != 0)
9186 {
9187 if (!add_dynamic_entry (DT_PLTGOT, 0)
9188 || !add_dynamic_entry (DT_PLTRELSZ, 0)
9189 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9190 || !add_dynamic_entry (DT_JMPREL, 0)
9191 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9192 return FALSE;
9193 }
9194
9195 if (NO_OPD_RELOCS)
9196 {
9197 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9198 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9199 return FALSE;
9200 }
9201
9202 if (!htab->no_tls_get_addr_opt
9203 && htab->tls_get_addr_fd != NULL
9204 && htab->tls_get_addr_fd->elf.plt.plist != NULL
9205 && !add_dynamic_entry (DT_PPC64_TLSOPT, 0))
9206 return FALSE;
9207
9208 if (relocs)
9209 {
9210 if (!add_dynamic_entry (DT_RELA, 0)
9211 || !add_dynamic_entry (DT_RELASZ, 0)
9212 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9213 return FALSE;
9214
9215 /* If any dynamic relocs apply to a read-only section,
9216 then we need a DT_TEXTREL entry. */
9217 if ((info->flags & DF_TEXTREL) == 0)
9218 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
9219
9220 if ((info->flags & DF_TEXTREL) != 0)
9221 {
9222 if (!add_dynamic_entry (DT_TEXTREL, 0))
9223 return FALSE;
9224 }
9225 }
9226 }
9227 #undef add_dynamic_entry
9228
9229 return TRUE;
9230 }
9231
9232 /* Determine the type of stub needed, if any, for a call. */
9233
9234 static inline enum ppc_stub_type
9235 ppc_type_of_stub (asection *input_sec,
9236 const Elf_Internal_Rela *rel,
9237 struct ppc_link_hash_entry **hash,
9238 struct plt_entry **plt_ent,
9239 bfd_vma destination)
9240 {
9241 struct ppc_link_hash_entry *h = *hash;
9242 bfd_vma location;
9243 bfd_vma branch_offset;
9244 bfd_vma max_branch_offset;
9245 enum elf_ppc64_reloc_type r_type;
9246
9247 if (h != NULL)
9248 {
9249 struct plt_entry *ent;
9250 struct ppc_link_hash_entry *fdh = h;
9251 if (h->oh != NULL
9252 && h->oh->is_func_descriptor)
9253 {
9254 fdh = ppc_follow_link (h->oh);
9255 *hash = fdh;
9256 }
9257
9258 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
9259 if (ent->addend == rel->r_addend
9260 && ent->plt.offset != (bfd_vma) -1)
9261 {
9262 *plt_ent = ent;
9263 return ppc_stub_plt_call;
9264 }
9265
9266 /* Here, we know we don't have a plt entry. If we don't have a
9267 either a defined function descriptor or a defined entry symbol
9268 in a regular object file, then it is pointless trying to make
9269 any other type of stub. */
9270 if (!is_static_defined (&fdh->elf)
9271 && !is_static_defined (&h->elf))
9272 return ppc_stub_none;
9273 }
9274 else if (elf_local_got_ents (input_sec->owner) != NULL)
9275 {
9276 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
9277 struct plt_entry **local_plt = (struct plt_entry **)
9278 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
9279 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
9280
9281 if (local_plt[r_symndx] != NULL)
9282 {
9283 struct plt_entry *ent;
9284
9285 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
9286 if (ent->addend == rel->r_addend
9287 && ent->plt.offset != (bfd_vma) -1)
9288 {
9289 *plt_ent = ent;
9290 return ppc_stub_plt_call;
9291 }
9292 }
9293 }
9294
9295 /* Determine where the call point is. */
9296 location = (input_sec->output_offset
9297 + input_sec->output_section->vma
9298 + rel->r_offset);
9299
9300 branch_offset = destination - location;
9301 r_type = ELF64_R_TYPE (rel->r_info);
9302
9303 /* Determine if a long branch stub is needed. */
9304 max_branch_offset = 1 << 25;
9305 if (r_type != R_PPC64_REL24)
9306 max_branch_offset = 1 << 15;
9307
9308 if (branch_offset + max_branch_offset >= 2 * max_branch_offset)
9309 /* We need a stub. Figure out whether a long_branch or plt_branch
9310 is needed later. */
9311 return ppc_stub_long_branch;
9312
9313 return ppc_stub_none;
9314 }
9315
9316 /* Build a .plt call stub. */
9317
9318 static inline bfd_byte *
9319 build_plt_stub (bfd *obfd, bfd_byte *p, int offset, Elf_Internal_Rela *r)
9320 {
9321 #define PPC_LO(v) ((v) & 0xffff)
9322 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9323 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9324
9325 if (PPC_HA (offset) != 0)
9326 {
9327 if (r != NULL)
9328 {
9329 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
9330 r[1].r_offset = r[0].r_offset + 8;
9331 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9332 r[1].r_addend = r[0].r_addend;
9333 if (PPC_HA (offset + 16) != PPC_HA (offset))
9334 {
9335 r[2].r_offset = r[1].r_offset + 4;
9336 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
9337 r[2].r_addend = r[0].r_addend;
9338 }
9339 else
9340 {
9341 r[2].r_offset = r[1].r_offset + 8;
9342 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9343 r[2].r_addend = r[0].r_addend + 8;
9344 r[3].r_offset = r[2].r_offset + 4;
9345 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9346 r[3].r_addend = r[0].r_addend + 16;
9347 }
9348 }
9349 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
9350 bfd_put_32 (obfd, STD_R2_40R1, p), p += 4;
9351 bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p), p += 4;
9352 if (PPC_HA (offset + 16) != PPC_HA (offset))
9353 {
9354 bfd_put_32 (obfd, ADDI_R12_R12 | PPC_LO (offset), p), p += 4;
9355 offset = 0;
9356 }
9357 bfd_put_32 (obfd, MTCTR_R11, p), p += 4;
9358 bfd_put_32 (obfd, LD_R2_0R12 | PPC_LO (offset + 8), p), p += 4;
9359 bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset + 16), p), p += 4;
9360 bfd_put_32 (obfd, BCTR, p), p += 4;
9361 }
9362 else
9363 {
9364 if (r != NULL)
9365 {
9366 r[0].r_offset += 4;
9367 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9368 if (PPC_HA (offset + 16) != PPC_HA (offset))
9369 {
9370 r[1].r_offset = r[0].r_offset + 4;
9371 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
9372 r[1].r_addend = r[0].r_addend;
9373 }
9374 else
9375 {
9376 r[1].r_offset = r[0].r_offset + 8;
9377 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9378 r[1].r_addend = r[0].r_addend + 16;
9379 r[2].r_offset = r[1].r_offset + 4;
9380 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9381 r[2].r_addend = r[0].r_addend + 8;
9382 }
9383 }
9384 bfd_put_32 (obfd, STD_R2_40R1, p), p += 4;
9385 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset), p), p += 4;
9386 if (PPC_HA (offset + 16) != PPC_HA (offset))
9387 {
9388 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
9389 offset = 0;
9390 }
9391 bfd_put_32 (obfd, MTCTR_R11, p), p += 4;
9392 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
9393 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
9394 bfd_put_32 (obfd, BCTR, p), p += 4;
9395 }
9396 return p;
9397 }
9398
9399 /* Build a special .plt call stub for __tls_get_addr. */
9400
9401 #define LD_R11_0R3 0xe9630000
9402 #define LD_R12_0R3 0xe9830000
9403 #define MR_R0_R3 0x7c601b78
9404 #define CMPDI_R11_0 0x2c2b0000
9405 #define ADD_R3_R12_R13 0x7c6c6a14
9406 #define BEQLR 0x4d820020
9407 #define MR_R3_R0 0x7c030378
9408 #define MFLR_R11 0x7d6802a6
9409 #define STD_R11_0R1 0xf9610000
9410 #define BCTRL 0x4e800421
9411 #define LD_R11_0R1 0xe9610000
9412 #define LD_R2_0R1 0xe8410000
9413 #define MTLR_R11 0x7d6803a6
9414
9415 static inline bfd_byte *
9416 build_tls_get_addr_stub (bfd *obfd, bfd_byte *p, int offset,
9417 Elf_Internal_Rela *r)
9418 {
9419 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
9420 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
9421 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
9422 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
9423 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
9424 bfd_put_32 (obfd, BEQLR, p), p += 4;
9425 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
9426 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
9427 bfd_put_32 (obfd, STD_R11_0R1 + 32, p), p += 4;
9428
9429 if (r != NULL)
9430 r[0].r_offset += 9 * 4;
9431 p = build_plt_stub (obfd, p, offset, r);
9432 bfd_put_32 (obfd, BCTRL, p - 4);
9433
9434 bfd_put_32 (obfd, LD_R11_0R1 + 32, p), p += 4;
9435 bfd_put_32 (obfd, LD_R2_0R1 + 40, p), p += 4;
9436 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
9437 bfd_put_32 (obfd, BLR, p), p += 4;
9438
9439 return p;
9440 }
9441
9442 static Elf_Internal_Rela *
9443 get_relocs (asection *sec, int count)
9444 {
9445 Elf_Internal_Rela *relocs;
9446 struct bfd_elf_section_data *elfsec_data;
9447
9448 elfsec_data = elf_section_data (sec);
9449 relocs = elfsec_data->relocs;
9450 if (relocs == NULL)
9451 {
9452 bfd_size_type relsize;
9453 relsize = sec->reloc_count * sizeof (*relocs);
9454 relocs = bfd_alloc (sec->owner, relsize);
9455 if (relocs == NULL)
9456 return NULL;
9457 elfsec_data->relocs = relocs;
9458 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
9459 sizeof (Elf_Internal_Shdr));
9460 if (elfsec_data->rela.hdr == NULL)
9461 return NULL;
9462 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
9463 * sizeof (Elf64_External_Rela));
9464 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
9465 sec->reloc_count = 0;
9466 }
9467 relocs += sec->reloc_count;
9468 sec->reloc_count += count;
9469 return relocs;
9470 }
9471
9472 static bfd_vma
9473 get_r2off (struct ppc_link_hash_table *htab,
9474 struct ppc_stub_hash_entry *stub_entry)
9475 {
9476 bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
9477
9478 if (r2off == 0)
9479 {
9480 /* Support linking -R objects. Get the toc pointer from the
9481 opd entry. */
9482 char buf[8];
9483 asection *opd = stub_entry->h->elf.root.u.def.section;
9484 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
9485
9486 if (strcmp (opd->name, ".opd") != 0
9487 || opd->reloc_count != 0)
9488 {
9489 (*_bfd_error_handler) (_("cannot find opd entry toc for %s"),
9490 stub_entry->h->elf.root.root.string);
9491 bfd_set_error (bfd_error_bad_value);
9492 return 0;
9493 }
9494 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
9495 return 0;
9496 r2off = bfd_get_64 (opd->owner, buf);
9497 r2off -= elf_gp (stub_entry->id_sec->output_section->owner);
9498 }
9499 r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
9500 return r2off;
9501 }
9502
9503 static bfd_boolean
9504 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
9505 {
9506 struct ppc_stub_hash_entry *stub_entry;
9507 struct ppc_branch_hash_entry *br_entry;
9508 struct bfd_link_info *info;
9509 struct ppc_link_hash_table *htab;
9510 bfd_byte *loc;
9511 bfd_byte *p;
9512 bfd_vma dest, off;
9513 int size;
9514 Elf_Internal_Rela *r;
9515 asection *plt;
9516
9517 /* Massage our args to the form they really have. */
9518 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
9519 info = in_arg;
9520
9521 htab = ppc_hash_table (info);
9522 if (htab == NULL)
9523 return FALSE;
9524
9525 /* Make a note of the offset within the stubs for this entry. */
9526 stub_entry->stub_offset = stub_entry->stub_sec->size;
9527 loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
9528
9529 htab->stub_count[stub_entry->stub_type - 1] += 1;
9530 switch (stub_entry->stub_type)
9531 {
9532 case ppc_stub_long_branch:
9533 case ppc_stub_long_branch_r2off:
9534 /* Branches are relative. This is where we are going to. */
9535 off = dest = (stub_entry->target_value
9536 + stub_entry->target_section->output_offset
9537 + stub_entry->target_section->output_section->vma);
9538
9539 /* And this is where we are coming from. */
9540 off -= (stub_entry->stub_offset
9541 + stub_entry->stub_sec->output_offset
9542 + stub_entry->stub_sec->output_section->vma);
9543
9544 size = 4;
9545 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
9546 {
9547 bfd_vma r2off = get_r2off (htab, stub_entry);
9548
9549 if (r2off == 0)
9550 {
9551 htab->stub_error = TRUE;
9552 return FALSE;
9553 }
9554 bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
9555 loc += 4;
9556 size = 12;
9557 if (PPC_HA (r2off) != 0)
9558 {
9559 size = 16;
9560 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
9561 loc += 4;
9562 }
9563 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
9564 loc += 4;
9565 off -= size - 4;
9566 }
9567 bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
9568
9569 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
9570 {
9571 (*_bfd_error_handler) (_("long branch stub `%s' offset overflow"),
9572 stub_entry->root.string);
9573 htab->stub_error = TRUE;
9574 return FALSE;
9575 }
9576
9577 if (info->emitrelocations)
9578 {
9579 r = get_relocs (stub_entry->stub_sec, 1);
9580 if (r == NULL)
9581 return FALSE;
9582 r->r_offset = loc - stub_entry->stub_sec->contents;
9583 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
9584 r->r_addend = dest;
9585 if (stub_entry->h != NULL)
9586 {
9587 struct elf_link_hash_entry **hashes;
9588 unsigned long symndx;
9589 struct ppc_link_hash_entry *h;
9590
9591 hashes = elf_sym_hashes (htab->stub_bfd);
9592 if (hashes == NULL)
9593 {
9594 bfd_size_type hsize;
9595
9596 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
9597 hashes = bfd_zalloc (htab->stub_bfd, hsize);
9598 if (hashes == NULL)
9599 return FALSE;
9600 elf_sym_hashes (htab->stub_bfd) = hashes;
9601 htab->stub_globals = 1;
9602 }
9603 symndx = htab->stub_globals++;
9604 h = stub_entry->h;
9605 hashes[symndx] = &h->elf;
9606 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
9607 if (h->oh != NULL && h->oh->is_func)
9608 h = ppc_follow_link (h->oh);
9609 if (h->elf.root.u.def.section != stub_entry->target_section)
9610 /* H is an opd symbol. The addend must be zero. */
9611 r->r_addend = 0;
9612 else
9613 {
9614 off = (h->elf.root.u.def.value
9615 + h->elf.root.u.def.section->output_offset
9616 + h->elf.root.u.def.section->output_section->vma);
9617 r->r_addend -= off;
9618 }
9619 }
9620 }
9621 break;
9622
9623 case ppc_stub_plt_branch:
9624 case ppc_stub_plt_branch_r2off:
9625 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
9626 stub_entry->root.string + 9,
9627 FALSE, FALSE);
9628 if (br_entry == NULL)
9629 {
9630 (*_bfd_error_handler) (_("can't find branch stub `%s'"),
9631 stub_entry->root.string);
9632 htab->stub_error = TRUE;
9633 return FALSE;
9634 }
9635
9636 dest = (stub_entry->target_value
9637 + stub_entry->target_section->output_offset
9638 + stub_entry->target_section->output_section->vma);
9639
9640 bfd_put_64 (htab->brlt->owner, dest,
9641 htab->brlt->contents + br_entry->offset);
9642
9643 if (br_entry->iter == htab->stub_iteration)
9644 {
9645 br_entry->iter = 0;
9646
9647 if (htab->relbrlt != NULL)
9648 {
9649 /* Create a reloc for the branch lookup table entry. */
9650 Elf_Internal_Rela rela;
9651 bfd_byte *rl;
9652
9653 rela.r_offset = (br_entry->offset
9654 + htab->brlt->output_offset
9655 + htab->brlt->output_section->vma);
9656 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
9657 rela.r_addend = dest;
9658
9659 rl = htab->relbrlt->contents;
9660 rl += (htab->relbrlt->reloc_count++
9661 * sizeof (Elf64_External_Rela));
9662 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
9663 }
9664 else if (info->emitrelocations)
9665 {
9666 r = get_relocs (htab->brlt, 1);
9667 if (r == NULL)
9668 return FALSE;
9669 /* brlt, being SEC_LINKER_CREATED does not go through the
9670 normal reloc processing. Symbols and offsets are not
9671 translated from input file to output file form, so
9672 set up the offset per the output file. */
9673 r->r_offset = (br_entry->offset
9674 + htab->brlt->output_offset
9675 + htab->brlt->output_section->vma);
9676 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
9677 r->r_addend = dest;
9678 }
9679 }
9680
9681 dest = (br_entry->offset
9682 + htab->brlt->output_offset
9683 + htab->brlt->output_section->vma);
9684
9685 off = (dest
9686 - elf_gp (htab->brlt->output_section->owner)
9687 - htab->stub_group[stub_entry->id_sec->id].toc_off);
9688
9689 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
9690 {
9691 (*_bfd_error_handler)
9692 (_("linkage table error against `%s'"),
9693 stub_entry->root.string);
9694 bfd_set_error (bfd_error_bad_value);
9695 htab->stub_error = TRUE;
9696 return FALSE;
9697 }
9698
9699 if (info->emitrelocations)
9700 {
9701 r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
9702 if (r == NULL)
9703 return FALSE;
9704 r[0].r_offset = loc - stub_entry->stub_sec->contents;
9705 if (bfd_big_endian (info->output_bfd))
9706 r[0].r_offset += 2;
9707 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
9708 r[0].r_offset += 4;
9709 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9710 r[0].r_addend = dest;
9711 if (PPC_HA (off) != 0)
9712 {
9713 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
9714 r[1].r_offset = r[0].r_offset + 4;
9715 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9716 r[1].r_addend = r[0].r_addend;
9717 }
9718 }
9719
9720 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
9721 {
9722 if (PPC_HA (off) != 0)
9723 {
9724 size = 16;
9725 bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
9726 loc += 4;
9727 bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
9728 }
9729 else
9730 {
9731 size = 12;
9732 bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
9733 }
9734 }
9735 else
9736 {
9737 bfd_vma r2off = get_r2off (htab, stub_entry);
9738
9739 if (r2off == 0)
9740 {
9741 htab->stub_error = TRUE;
9742 return FALSE;
9743 }
9744
9745 bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
9746 loc += 4;
9747 size = 20;
9748 if (PPC_HA (off) != 0)
9749 {
9750 size += 4;
9751 bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
9752 loc += 4;
9753 bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
9754 loc += 4;
9755 }
9756 else
9757 {
9758 bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
9759 loc += 4;
9760 }
9761
9762 if (PPC_HA (r2off) != 0)
9763 {
9764 size += 4;
9765 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
9766 loc += 4;
9767 }
9768 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
9769 }
9770 loc += 4;
9771 bfd_put_32 (htab->stub_bfd, MTCTR_R11, loc);
9772 loc += 4;
9773 bfd_put_32 (htab->stub_bfd, BCTR, loc);
9774 break;
9775
9776 case ppc_stub_plt_call:
9777 if (stub_entry->h != NULL
9778 && stub_entry->h->is_func_descriptor
9779 && stub_entry->h->oh != NULL)
9780 {
9781 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
9782
9783 /* If the old-ABI "dot-symbol" is undefined make it weak so
9784 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
9785 FIXME: We used to define the symbol on one of the call
9786 stubs instead, which is why we test symbol section id
9787 against htab->top_id in various places. Likely all
9788 these checks could now disappear. */
9789 if (fh->elf.root.type == bfd_link_hash_undefined)
9790 fh->elf.root.type = bfd_link_hash_undefweak;
9791 }
9792
9793 /* Now build the stub. */
9794 dest = stub_entry->plt_ent->plt.offset & ~1;
9795 if (dest >= (bfd_vma) -2)
9796 abort ();
9797
9798 plt = htab->plt;
9799 if (!htab->elf.dynamic_sections_created
9800 || stub_entry->h == NULL
9801 || stub_entry->h->elf.dynindx == -1)
9802 plt = htab->iplt;
9803
9804 dest += plt->output_offset + plt->output_section->vma;
9805
9806 if (stub_entry->h == NULL
9807 && (stub_entry->plt_ent->plt.offset & 1) == 0)
9808 {
9809 Elf_Internal_Rela rela;
9810 bfd_byte *rl;
9811
9812 rela.r_offset = dest;
9813 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
9814 rela.r_addend = (stub_entry->target_value
9815 + stub_entry->target_section->output_offset
9816 + stub_entry->target_section->output_section->vma);
9817
9818 rl = (htab->reliplt->contents
9819 + (htab->reliplt->reloc_count++
9820 * sizeof (Elf64_External_Rela)));
9821 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
9822 stub_entry->plt_ent->plt.offset |= 1;
9823 }
9824
9825 off = (dest
9826 - elf_gp (plt->output_section->owner)
9827 - htab->stub_group[stub_entry->id_sec->id].toc_off);
9828
9829 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
9830 {
9831 (*_bfd_error_handler)
9832 (_("linkage table error against `%s'"),
9833 stub_entry->h != NULL
9834 ? stub_entry->h->elf.root.root.string
9835 : "<local sym>");
9836 bfd_set_error (bfd_error_bad_value);
9837 htab->stub_error = TRUE;
9838 return FALSE;
9839 }
9840
9841 r = NULL;
9842 if (info->emitrelocations)
9843 {
9844 r = get_relocs (stub_entry->stub_sec,
9845 (2 + (PPC_HA (off) != 0)
9846 + (PPC_HA (off + 16) == PPC_HA (off))));
9847 if (r == NULL)
9848 return FALSE;
9849 r[0].r_offset = loc - stub_entry->stub_sec->contents;
9850 if (bfd_big_endian (info->output_bfd))
9851 r[0].r_offset += 2;
9852 r[0].r_addend = dest;
9853 }
9854 if (stub_entry->h != NULL
9855 && (stub_entry->h == htab->tls_get_addr_fd
9856 || stub_entry->h == htab->tls_get_addr)
9857 && !htab->no_tls_get_addr_opt)
9858 p = build_tls_get_addr_stub (htab->stub_bfd, loc, off, r);
9859 else
9860 p = build_plt_stub (htab->stub_bfd, loc, off, r);
9861 size = p - loc;
9862 break;
9863
9864 default:
9865 BFD_FAIL ();
9866 return FALSE;
9867 }
9868
9869 stub_entry->stub_sec->size += size;
9870
9871 if (htab->emit_stub_syms)
9872 {
9873 struct elf_link_hash_entry *h;
9874 size_t len1, len2;
9875 char *name;
9876 const char *const stub_str[] = { "long_branch",
9877 "long_branch_r2off",
9878 "plt_branch",
9879 "plt_branch_r2off",
9880 "plt_call" };
9881
9882 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
9883 len2 = strlen (stub_entry->root.string);
9884 name = bfd_malloc (len1 + len2 + 2);
9885 if (name == NULL)
9886 return FALSE;
9887 memcpy (name, stub_entry->root.string, 9);
9888 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
9889 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
9890 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
9891 if (h == NULL)
9892 return FALSE;
9893 if (h->root.type == bfd_link_hash_new)
9894 {
9895 h->root.type = bfd_link_hash_defined;
9896 h->root.u.def.section = stub_entry->stub_sec;
9897 h->root.u.def.value = stub_entry->stub_offset;
9898 h->ref_regular = 1;
9899 h->def_regular = 1;
9900 h->ref_regular_nonweak = 1;
9901 h->forced_local = 1;
9902 h->non_elf = 0;
9903 }
9904 }
9905
9906 return TRUE;
9907 }
9908
9909 /* As above, but don't actually build the stub. Just bump offset so
9910 we know stub section sizes, and select plt_branch stubs where
9911 long_branch stubs won't do. */
9912
9913 static bfd_boolean
9914 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
9915 {
9916 struct ppc_stub_hash_entry *stub_entry;
9917 struct bfd_link_info *info;
9918 struct ppc_link_hash_table *htab;
9919 bfd_vma off;
9920 int size;
9921
9922 /* Massage our args to the form they really have. */
9923 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
9924 info = in_arg;
9925
9926 htab = ppc_hash_table (info);
9927 if (htab == NULL)
9928 return FALSE;
9929
9930 if (stub_entry->stub_type == ppc_stub_plt_call)
9931 {
9932 asection *plt;
9933 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
9934 if (off >= (bfd_vma) -2)
9935 abort ();
9936 plt = htab->plt;
9937 if (!htab->elf.dynamic_sections_created
9938 || stub_entry->h == NULL
9939 || stub_entry->h->elf.dynindx == -1)
9940 plt = htab->iplt;
9941 off += (plt->output_offset
9942 + plt->output_section->vma
9943 - elf_gp (plt->output_section->owner)
9944 - htab->stub_group[stub_entry->id_sec->id].toc_off);
9945
9946 size = PLT_CALL_STUB_SIZE;
9947 if (PPC_HA (off) == 0)
9948 size -= 4;
9949 if (PPC_HA (off + 16) != PPC_HA (off))
9950 size += 4;
9951 if (stub_entry->h != NULL
9952 && (stub_entry->h == htab->tls_get_addr_fd
9953 || stub_entry->h == htab->tls_get_addr)
9954 && !htab->no_tls_get_addr_opt)
9955 size += 13 * 4;
9956 if (info->emitrelocations)
9957 {
9958 stub_entry->stub_sec->reloc_count
9959 += 2 + (PPC_HA (off) != 0) + (PPC_HA (off + 16) == PPC_HA (off));
9960 stub_entry->stub_sec->flags |= SEC_RELOC;
9961 }
9962 }
9963 else
9964 {
9965 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
9966 variants. */
9967 bfd_vma r2off = 0;
9968
9969 off = (stub_entry->target_value
9970 + stub_entry->target_section->output_offset
9971 + stub_entry->target_section->output_section->vma);
9972 off -= (stub_entry->stub_sec->size
9973 + stub_entry->stub_sec->output_offset
9974 + stub_entry->stub_sec->output_section->vma);
9975
9976 /* Reset the stub type from the plt variant in case we now
9977 can reach with a shorter stub. */
9978 if (stub_entry->stub_type >= ppc_stub_plt_branch)
9979 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
9980
9981 size = 4;
9982 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
9983 {
9984 r2off = get_r2off (htab, stub_entry);
9985 if (r2off == 0)
9986 {
9987 htab->stub_error = TRUE;
9988 return FALSE;
9989 }
9990 size = 12;
9991 if (PPC_HA (r2off) != 0)
9992 size = 16;
9993 off -= size - 4;
9994 }
9995
9996 /* If the branch offset if too big, use a ppc_stub_plt_branch. */
9997 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
9998 {
9999 struct ppc_branch_hash_entry *br_entry;
10000
10001 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10002 stub_entry->root.string + 9,
10003 TRUE, FALSE);
10004 if (br_entry == NULL)
10005 {
10006 (*_bfd_error_handler) (_("can't build branch stub `%s'"),
10007 stub_entry->root.string);
10008 htab->stub_error = TRUE;
10009 return FALSE;
10010 }
10011
10012 if (br_entry->iter != htab->stub_iteration)
10013 {
10014 br_entry->iter = htab->stub_iteration;
10015 br_entry->offset = htab->brlt->size;
10016 htab->brlt->size += 8;
10017
10018 if (htab->relbrlt != NULL)
10019 htab->relbrlt->size += sizeof (Elf64_External_Rela);
10020 else if (info->emitrelocations)
10021 {
10022 htab->brlt->reloc_count += 1;
10023 htab->brlt->flags |= SEC_RELOC;
10024 }
10025 }
10026
10027 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
10028 off = (br_entry->offset
10029 + htab->brlt->output_offset
10030 + htab->brlt->output_section->vma
10031 - elf_gp (htab->brlt->output_section->owner)
10032 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10033
10034 if (info->emitrelocations)
10035 {
10036 stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
10037 stub_entry->stub_sec->flags |= SEC_RELOC;
10038 }
10039
10040 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10041 {
10042 size = 12;
10043 if (PPC_HA (off) != 0)
10044 size = 16;
10045 }
10046 else
10047 {
10048 size = 20;
10049 if (PPC_HA (off) != 0)
10050 size += 4;
10051
10052 if (PPC_HA (r2off) != 0)
10053 size += 4;
10054 }
10055 }
10056 else if (info->emitrelocations)
10057 {
10058 stub_entry->stub_sec->reloc_count += 1;
10059 stub_entry->stub_sec->flags |= SEC_RELOC;
10060 }
10061 }
10062
10063 stub_entry->stub_sec->size += size;
10064 return TRUE;
10065 }
10066
10067 /* Set up various things so that we can make a list of input sections
10068 for each output section included in the link. Returns -1 on error,
10069 0 when no stubs will be needed, and 1 on success. */
10070
10071 int
10072 ppc64_elf_setup_section_lists
10073 (struct bfd_link_info *info,
10074 asection *(*add_stub_section) (const char *, asection *),
10075 void (*layout_sections_again) (void))
10076 {
10077 bfd *input_bfd;
10078 int top_id, top_index, id;
10079 asection *section;
10080 asection **input_list;
10081 bfd_size_type amt;
10082 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10083
10084 if (htab == NULL)
10085 return -1;
10086 /* Stash our params away. */
10087 htab->add_stub_section = add_stub_section;
10088 htab->layout_sections_again = layout_sections_again;
10089
10090 if (htab->brlt == NULL)
10091 return 0;
10092
10093 /* Find the top input section id. */
10094 for (input_bfd = info->input_bfds, top_id = 3;
10095 input_bfd != NULL;
10096 input_bfd = input_bfd->link_next)
10097 {
10098 for (section = input_bfd->sections;
10099 section != NULL;
10100 section = section->next)
10101 {
10102 if (top_id < section->id)
10103 top_id = section->id;
10104 }
10105 }
10106
10107 htab->top_id = top_id;
10108 amt = sizeof (struct map_stub) * (top_id + 1);
10109 htab->stub_group = bfd_zmalloc (amt);
10110 if (htab->stub_group == NULL)
10111 return -1;
10112
10113 /* Set toc_off for com, und, abs and ind sections. */
10114 for (id = 0; id < 3; id++)
10115 htab->stub_group[id].toc_off = TOC_BASE_OFF;
10116
10117 /* We can't use output_bfd->section_count here to find the top output
10118 section index as some sections may have been removed, and
10119 strip_excluded_output_sections doesn't renumber the indices. */
10120 for (section = info->output_bfd->sections, top_index = 0;
10121 section != NULL;
10122 section = section->next)
10123 {
10124 if (top_index < section->index)
10125 top_index = section->index;
10126 }
10127
10128 htab->top_index = top_index;
10129 amt = sizeof (asection *) * (top_index + 1);
10130 input_list = bfd_zmalloc (amt);
10131 htab->input_list = input_list;
10132 if (input_list == NULL)
10133 return -1;
10134
10135 return 1;
10136 }
10137
10138 /* Set up for first pass at multitoc partitioning. */
10139
10140 void
10141 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
10142 {
10143 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10144
10145 elf_gp (info->output_bfd) = ppc64_elf_toc (info->output_bfd);
10146 htab->toc_curr = elf_gp (info->output_bfd);
10147 htab->toc_bfd = NULL;
10148 htab->toc_first_sec = NULL;
10149 }
10150
10151 /* The linker repeatedly calls this function for each TOC input section
10152 and linker generated GOT section. Group input bfds such that the toc
10153 within a group is less than 64k in size. */
10154
10155 bfd_boolean
10156 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
10157 {
10158 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10159 bfd_vma addr, off, limit;
10160
10161 if (htab == NULL)
10162 return FALSE;
10163
10164 if (!htab->second_toc_pass)
10165 {
10166 /* Keep track of the first .toc or .got section for this input bfd. */
10167 if (htab->toc_bfd != isec->owner)
10168 {
10169 htab->toc_bfd = isec->owner;
10170 htab->toc_first_sec = isec;
10171 }
10172
10173 addr = isec->output_offset + isec->output_section->vma;
10174 off = addr - htab->toc_curr;
10175 limit = 0x80008000;
10176 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
10177 limit = 0x10000;
10178 if (off + isec->size > limit)
10179 {
10180 addr = (htab->toc_first_sec->output_offset
10181 + htab->toc_first_sec->output_section->vma);
10182 htab->toc_curr = addr;
10183 }
10184
10185 /* toc_curr is the base address of this toc group. Set elf_gp
10186 for the input section to be the offset relative to the
10187 output toc base plus 0x8000. Making the input elf_gp an
10188 offset allows us to move the toc as a whole without
10189 recalculating input elf_gp. */
10190 off = htab->toc_curr - elf_gp (isec->output_section->owner);
10191 off += TOC_BASE_OFF;
10192
10193 /* Die if someone uses a linker script that doesn't keep input
10194 file .toc and .got together. */
10195 if (elf_gp (isec->owner) != 0
10196 && elf_gp (isec->owner) != off)
10197 return FALSE;
10198
10199 elf_gp (isec->owner) = off;
10200 return TRUE;
10201 }
10202
10203 /* During the second pass toc_first_sec points to the start of
10204 a toc group, and toc_curr is used to track the old elf_gp.
10205 We use toc_bfd to ensure we only look at each bfd once. */
10206 if (htab->toc_bfd == isec->owner)
10207 return TRUE;
10208 htab->toc_bfd = isec->owner;
10209
10210 if (htab->toc_first_sec == NULL
10211 || htab->toc_curr != elf_gp (isec->owner))
10212 {
10213 htab->toc_curr = elf_gp (isec->owner);
10214 htab->toc_first_sec = isec;
10215 }
10216 addr = (htab->toc_first_sec->output_offset
10217 + htab->toc_first_sec->output_section->vma);
10218 off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
10219 elf_gp (isec->owner) = off;
10220
10221 return TRUE;
10222 }
10223
10224 /* Called via elf_link_hash_traverse to merge GOT entries for global
10225 symbol H. */
10226
10227 static bfd_boolean
10228 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
10229 {
10230 if (h->root.type == bfd_link_hash_indirect)
10231 return TRUE;
10232
10233 if (h->root.type == bfd_link_hash_warning)
10234 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10235
10236 merge_got_entries (&h->got.glist);
10237
10238 return TRUE;
10239 }
10240
10241 /* Called via elf_link_hash_traverse to allocate GOT entries for global
10242 symbol H. */
10243
10244 static bfd_boolean
10245 reallocate_got (struct elf_link_hash_entry *h, void *inf)
10246 {
10247 struct got_entry *gent;
10248
10249 if (h->root.type == bfd_link_hash_indirect)
10250 return TRUE;
10251
10252 if (h->root.type == bfd_link_hash_warning)
10253 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10254
10255 for (gent = h->got.glist; gent != NULL; gent = gent->next)
10256 if (!gent->is_indirect)
10257 allocate_got (h, (struct bfd_link_info *) inf, gent);
10258 return TRUE;
10259 }
10260
10261 /* Called on the first multitoc pass after the last call to
10262 ppc64_elf_next_toc_section. This function removes duplicate GOT
10263 entries. */
10264
10265 bfd_boolean
10266 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
10267 {
10268 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10269 struct bfd *ibfd, *ibfd2;
10270 bfd_boolean done_something;
10271
10272 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
10273
10274 if (!htab->do_multi_toc)
10275 return FALSE;
10276
10277 /* Merge global sym got entries within a toc group. */
10278 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
10279
10280 /* And tlsld_got. */
10281 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10282 {
10283 struct got_entry *ent, *ent2;
10284
10285 if (!is_ppc64_elf (ibfd))
10286 continue;
10287
10288 ent = ppc64_tlsld_got (ibfd);
10289 if (!ent->is_indirect
10290 && ent->got.offset != (bfd_vma) -1)
10291 {
10292 for (ibfd2 = ibfd->link_next; ibfd2 != NULL; ibfd2 = ibfd2->link_next)
10293 {
10294 if (!is_ppc64_elf (ibfd2))
10295 continue;
10296
10297 ent2 = ppc64_tlsld_got (ibfd2);
10298 if (!ent2->is_indirect
10299 && ent2->got.offset != (bfd_vma) -1
10300 && elf_gp (ibfd2) == elf_gp (ibfd))
10301 {
10302 ent2->is_indirect = TRUE;
10303 ent2->got.ent = ent;
10304 }
10305 }
10306 }
10307 }
10308
10309 /* Zap sizes of got sections. */
10310 htab->reliplt->rawsize = htab->reliplt->size;
10311 htab->reliplt->size -= htab->got_reli_size;
10312 htab->got_reli_size = 0;
10313
10314 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10315 {
10316 asection *got, *relgot;
10317
10318 if (!is_ppc64_elf (ibfd))
10319 continue;
10320
10321 got = ppc64_elf_tdata (ibfd)->got;
10322 if (got != NULL)
10323 {
10324 got->rawsize = got->size;
10325 got->size = 0;
10326 relgot = ppc64_elf_tdata (ibfd)->relgot;
10327 relgot->rawsize = relgot->size;
10328 relgot->size = 0;
10329 }
10330 }
10331
10332 /* Now reallocate the got, local syms first. We don't need to
10333 allocate section contents again since we never increase size. */
10334 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10335 {
10336 struct got_entry **lgot_ents;
10337 struct got_entry **end_lgot_ents;
10338 struct plt_entry **local_plt;
10339 struct plt_entry **end_local_plt;
10340 unsigned char *lgot_masks;
10341 bfd_size_type locsymcount;
10342 Elf_Internal_Shdr *symtab_hdr;
10343 asection *s, *srel;
10344
10345 if (!is_ppc64_elf (ibfd))
10346 continue;
10347
10348 lgot_ents = elf_local_got_ents (ibfd);
10349 if (!lgot_ents)
10350 continue;
10351
10352 symtab_hdr = &elf_symtab_hdr (ibfd);
10353 locsymcount = symtab_hdr->sh_info;
10354 end_lgot_ents = lgot_ents + locsymcount;
10355 local_plt = (struct plt_entry **) end_lgot_ents;
10356 end_local_plt = local_plt + locsymcount;
10357 lgot_masks = (unsigned char *) end_local_plt;
10358 s = ppc64_elf_tdata (ibfd)->got;
10359 srel = ppc64_elf_tdata (ibfd)->relgot;
10360 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10361 {
10362 struct got_entry *ent;
10363
10364 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
10365 {
10366 unsigned int num = 1;
10367 ent->got.offset = s->size;
10368 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10369 num = 2;
10370 s->size += num * 8;
10371 if (info->shared)
10372 srel->size += num * sizeof (Elf64_External_Rela);
10373 else if ((*lgot_masks & PLT_IFUNC) != 0)
10374 {
10375 htab->reliplt->size
10376 += num * sizeof (Elf64_External_Rela);
10377 htab->got_reli_size
10378 += num * sizeof (Elf64_External_Rela);
10379 }
10380 }
10381 }
10382 }
10383
10384 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
10385
10386 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10387 {
10388 struct got_entry *ent;
10389
10390 if (!is_ppc64_elf (ibfd))
10391 continue;
10392
10393 ent = ppc64_tlsld_got (ibfd);
10394 if (!ent->is_indirect
10395 && ent->got.offset != (bfd_vma) -1)
10396 {
10397 asection *s = ppc64_elf_tdata (ibfd)->got;
10398 ent->got.offset = s->size;
10399 s->size += 16;
10400 if (info->shared)
10401 {
10402 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10403 srel->size += sizeof (Elf64_External_Rela);
10404 }
10405 }
10406 }
10407
10408 done_something = htab->reliplt->rawsize != htab->reliplt->size;
10409 if (!done_something)
10410 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10411 {
10412 asection *got;
10413
10414 if (!is_ppc64_elf (ibfd))
10415 continue;
10416
10417 got = ppc64_elf_tdata (ibfd)->got;
10418 if (got != NULL)
10419 {
10420 done_something = got->rawsize != got->size;
10421 if (done_something)
10422 break;
10423 }
10424 }
10425
10426 if (done_something)
10427 (*htab->layout_sections_again) ();
10428
10429 /* Set up for second pass over toc sections to recalculate elf_gp
10430 on input sections. */
10431 htab->toc_bfd = NULL;
10432 htab->toc_first_sec = NULL;
10433 htab->second_toc_pass = TRUE;
10434 return done_something;
10435 }
10436
10437 /* Called after second pass of multitoc partitioning. */
10438
10439 void
10440 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
10441 {
10442 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10443
10444 /* After the second pass, toc_curr tracks the TOC offset used
10445 for code sections below in ppc64_elf_next_input_section. */
10446 htab->toc_curr = TOC_BASE_OFF;
10447 }
10448
10449 /* No toc references were found in ISEC. If the code in ISEC makes no
10450 calls, then there's no need to use toc adjusting stubs when branching
10451 into ISEC. Actually, indirect calls from ISEC are OK as they will
10452 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
10453 needed, and 2 if a cyclical call-graph was found but no other reason
10454 for a stub was detected. If called from the top level, a return of
10455 2 means the same as a return of 0. */
10456
10457 static int
10458 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
10459 {
10460 int ret;
10461
10462 /* Mark this section as checked. */
10463 isec->call_check_done = 1;
10464
10465 /* We know none of our code bearing sections will need toc stubs. */
10466 if ((isec->flags & SEC_LINKER_CREATED) != 0)
10467 return 0;
10468
10469 if (isec->size == 0)
10470 return 0;
10471
10472 if (isec->output_section == NULL)
10473 return 0;
10474
10475 ret = 0;
10476 if (isec->reloc_count != 0)
10477 {
10478 Elf_Internal_Rela *relstart, *rel;
10479 Elf_Internal_Sym *local_syms;
10480 struct ppc_link_hash_table *htab;
10481
10482 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
10483 info->keep_memory);
10484 if (relstart == NULL)
10485 return -1;
10486
10487 /* Look for branches to outside of this section. */
10488 local_syms = NULL;
10489 htab = ppc_hash_table (info);
10490 if (htab == NULL)
10491 return -1;
10492
10493 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
10494 {
10495 enum elf_ppc64_reloc_type r_type;
10496 unsigned long r_symndx;
10497 struct elf_link_hash_entry *h;
10498 struct ppc_link_hash_entry *eh;
10499 Elf_Internal_Sym *sym;
10500 asection *sym_sec;
10501 struct _opd_sec_data *opd;
10502 bfd_vma sym_value;
10503 bfd_vma dest;
10504
10505 r_type = ELF64_R_TYPE (rel->r_info);
10506 if (r_type != R_PPC64_REL24
10507 && r_type != R_PPC64_REL14
10508 && r_type != R_PPC64_REL14_BRTAKEN
10509 && r_type != R_PPC64_REL14_BRNTAKEN)
10510 continue;
10511
10512 r_symndx = ELF64_R_SYM (rel->r_info);
10513 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
10514 isec->owner))
10515 {
10516 ret = -1;
10517 break;
10518 }
10519
10520 /* Calls to dynamic lib functions go through a plt call stub
10521 that uses r2. */
10522 eh = (struct ppc_link_hash_entry *) h;
10523 if (eh != NULL
10524 && (eh->elf.plt.plist != NULL
10525 || (eh->oh != NULL
10526 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
10527 {
10528 ret = 1;
10529 break;
10530 }
10531
10532 if (sym_sec == NULL)
10533 /* Ignore other undefined symbols. */
10534 continue;
10535
10536 /* Assume branches to other sections not included in the
10537 link need stubs too, to cover -R and absolute syms. */
10538 if (sym_sec->output_section == NULL)
10539 {
10540 ret = 1;
10541 break;
10542 }
10543
10544 if (h == NULL)
10545 sym_value = sym->st_value;
10546 else
10547 {
10548 if (h->root.type != bfd_link_hash_defined
10549 && h->root.type != bfd_link_hash_defweak)
10550 abort ();
10551 sym_value = h->root.u.def.value;
10552 }
10553 sym_value += rel->r_addend;
10554
10555 /* If this branch reloc uses an opd sym, find the code section. */
10556 opd = get_opd_info (sym_sec);
10557 if (opd != NULL)
10558 {
10559 if (h == NULL && opd->adjust != NULL)
10560 {
10561 long adjust;
10562
10563 adjust = opd->adjust[sym->st_value / 8];
10564 if (adjust == -1)
10565 /* Assume deleted functions won't ever be called. */
10566 continue;
10567 sym_value += adjust;
10568 }
10569
10570 dest = opd_entry_value (sym_sec, sym_value, &sym_sec, NULL);
10571 if (dest == (bfd_vma) -1)
10572 continue;
10573 }
10574 else
10575 dest = (sym_value
10576 + sym_sec->output_offset
10577 + sym_sec->output_section->vma);
10578
10579 /* Ignore branch to self. */
10580 if (sym_sec == isec)
10581 continue;
10582
10583 /* If the called function uses the toc, we need a stub. */
10584 if (sym_sec->has_toc_reloc
10585 || sym_sec->makes_toc_func_call)
10586 {
10587 ret = 1;
10588 break;
10589 }
10590
10591 /* Assume any branch that needs a long branch stub might in fact
10592 need a plt_branch stub. A plt_branch stub uses r2. */
10593 else if (dest - (isec->output_offset
10594 + isec->output_section->vma
10595 + rel->r_offset) + (1 << 25) >= (2 << 25))
10596 {
10597 ret = 1;
10598 break;
10599 }
10600
10601 /* If calling back to a section in the process of being
10602 tested, we can't say for sure that no toc adjusting stubs
10603 are needed, so don't return zero. */
10604 else if (sym_sec->call_check_in_progress)
10605 ret = 2;
10606
10607 /* Branches to another section that itself doesn't have any TOC
10608 references are OK. Recursively call ourselves to check. */
10609 else if (!sym_sec->call_check_done)
10610 {
10611 int recur;
10612
10613 /* Mark current section as indeterminate, so that other
10614 sections that call back to current won't be marked as
10615 known. */
10616 isec->call_check_in_progress = 1;
10617 recur = toc_adjusting_stub_needed (info, sym_sec);
10618 isec->call_check_in_progress = 0;
10619
10620 if (recur != 0)
10621 {
10622 ret = recur;
10623 if (recur != 2)
10624 break;
10625 }
10626 }
10627 }
10628
10629 if (local_syms != NULL
10630 && (elf_symtab_hdr (isec->owner).contents
10631 != (unsigned char *) local_syms))
10632 free (local_syms);
10633 if (elf_section_data (isec)->relocs != relstart)
10634 free (relstart);
10635 }
10636
10637 if ((ret & 1) == 0
10638 && isec->map_head.s != NULL
10639 && (strcmp (isec->output_section->name, ".init") == 0
10640 || strcmp (isec->output_section->name, ".fini") == 0))
10641 {
10642 if (isec->map_head.s->has_toc_reloc
10643 || isec->map_head.s->makes_toc_func_call)
10644 ret = 1;
10645 else if (!isec->map_head.s->call_check_done)
10646 {
10647 int recur;
10648 isec->call_check_in_progress = 1;
10649 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
10650 isec->call_check_in_progress = 0;
10651 if (recur != 0)
10652 ret = recur;
10653 }
10654 }
10655
10656 if (ret == 1)
10657 isec->makes_toc_func_call = 1;
10658
10659 return ret;
10660 }
10661
10662 /* The linker repeatedly calls this function for each input section,
10663 in the order that input sections are linked into output sections.
10664 Build lists of input sections to determine groupings between which
10665 we may insert linker stubs. */
10666
10667 bfd_boolean
10668 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
10669 {
10670 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10671
10672 if (htab == NULL)
10673 return FALSE;
10674
10675 if ((isec->output_section->flags & SEC_CODE) != 0
10676 && isec->output_section->index <= htab->top_index)
10677 {
10678 asection **list = htab->input_list + isec->output_section->index;
10679 /* Steal the link_sec pointer for our list. */
10680 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
10681 /* This happens to make the list in reverse order,
10682 which is what we want. */
10683 PREV_SEC (isec) = *list;
10684 *list = isec;
10685 }
10686
10687 if (htab->multi_toc_needed)
10688 {
10689 /* If a code section has a function that uses the TOC then we need
10690 to use the right TOC (obviously). Also, make sure that .opd gets
10691 the correct TOC value for R_PPC64_TOC relocs that don't have or
10692 can't find their function symbol (shouldn't ever happen now).
10693 Also specially treat .fixup for the linux kernel. .fixup
10694 contains branches, but only back to the function that hit an
10695 exception. */
10696 if (isec->has_toc_reloc
10697 || (isec->flags & SEC_CODE) == 0
10698 || strcmp (isec->name, ".fixup") == 0)
10699 {
10700 if (elf_gp (isec->owner) != 0)
10701 htab->toc_curr = elf_gp (isec->owner);
10702 }
10703 else
10704 {
10705 if (!isec->call_check_done
10706 && toc_adjusting_stub_needed (info, isec) < 0)
10707 return FALSE;
10708 /* If we make a local call from this section, ie. a branch
10709 without a following nop, then we have no place to put a
10710 toc restoring insn. We must use the same toc group as
10711 the callee.
10712 Testing makes_toc_func_call actually tests for *any*
10713 calls to functions that need a good toc pointer. A more
10714 precise test would be better, as this one will set
10715 incorrect values for pasted .init/.fini fragments.
10716 (Fixed later in check_pasted_section.) */
10717 if (isec->makes_toc_func_call
10718 && elf_gp (isec->owner) != 0)
10719 htab->toc_curr = elf_gp (isec->owner);
10720 }
10721 }
10722
10723 /* Functions that don't use the TOC can belong in any TOC group.
10724 Use the last TOC base. */
10725 htab->stub_group[isec->id].toc_off = htab->toc_curr;
10726 return TRUE;
10727 }
10728
10729 /* Check that all .init and .fini sections use the same toc, if they
10730 have toc relocs. */
10731
10732 static bfd_boolean
10733 check_pasted_section (struct bfd_link_info *info, const char *name)
10734 {
10735 asection *o = bfd_get_section_by_name (info->output_bfd, name);
10736
10737 if (o != NULL)
10738 {
10739 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10740 bfd_vma toc_off = 0;
10741 asection *i;
10742
10743 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
10744 if (i->has_toc_reloc)
10745 {
10746 if (toc_off == 0)
10747 toc_off = htab->stub_group[i->id].toc_off;
10748 else if (toc_off != htab->stub_group[i->id].toc_off)
10749 return FALSE;
10750 }
10751
10752 if (toc_off == 0)
10753 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
10754 if (i->makes_toc_func_call)
10755 {
10756 toc_off = htab->stub_group[i->id].toc_off;
10757 break;
10758 }
10759
10760 /* Make sure the whole pasted function uses the same toc offset. */
10761 if (toc_off != 0)
10762 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
10763 htab->stub_group[i->id].toc_off = toc_off;
10764 }
10765 return TRUE;
10766 }
10767
10768 bfd_boolean
10769 ppc64_elf_check_init_fini (struct bfd_link_info *info)
10770 {
10771 return (check_pasted_section (info, ".init")
10772 & check_pasted_section (info, ".fini"));
10773 }
10774
10775 /* See whether we can group stub sections together. Grouping stub
10776 sections may result in fewer stubs. More importantly, we need to
10777 put all .init* and .fini* stubs at the beginning of the .init or
10778 .fini output sections respectively, because glibc splits the
10779 _init and _fini functions into multiple parts. Putting a stub in
10780 the middle of a function is not a good idea. */
10781
10782 static void
10783 group_sections (struct ppc_link_hash_table *htab,
10784 bfd_size_type stub_group_size,
10785 bfd_boolean stubs_always_before_branch)
10786 {
10787 asection **list;
10788 bfd_size_type stub14_group_size;
10789 bfd_boolean suppress_size_errors;
10790
10791 suppress_size_errors = FALSE;
10792 stub14_group_size = stub_group_size;
10793 if (stub_group_size == 1)
10794 {
10795 /* Default values. */
10796 if (stubs_always_before_branch)
10797 {
10798 stub_group_size = 0x1e00000;
10799 stub14_group_size = 0x7800;
10800 }
10801 else
10802 {
10803 stub_group_size = 0x1c00000;
10804 stub14_group_size = 0x7000;
10805 }
10806 suppress_size_errors = TRUE;
10807 }
10808
10809 list = htab->input_list + htab->top_index;
10810 do
10811 {
10812 asection *tail = *list;
10813 while (tail != NULL)
10814 {
10815 asection *curr;
10816 asection *prev;
10817 bfd_size_type total;
10818 bfd_boolean big_sec;
10819 bfd_vma curr_toc;
10820
10821 curr = tail;
10822 total = tail->size;
10823 big_sec = total > (ppc64_elf_section_data (tail) != NULL
10824 && ppc64_elf_section_data (tail)->has_14bit_branch
10825 ? stub14_group_size : stub_group_size);
10826 if (big_sec && !suppress_size_errors)
10827 (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
10828 tail->owner, tail);
10829 curr_toc = htab->stub_group[tail->id].toc_off;
10830
10831 while ((prev = PREV_SEC (curr)) != NULL
10832 && ((total += curr->output_offset - prev->output_offset)
10833 < (ppc64_elf_section_data (prev) != NULL
10834 && ppc64_elf_section_data (prev)->has_14bit_branch
10835 ? stub14_group_size : stub_group_size))
10836 && htab->stub_group[prev->id].toc_off == curr_toc)
10837 curr = prev;
10838
10839 /* OK, the size from the start of CURR to the end is less
10840 than stub_group_size and thus can be handled by one stub
10841 section. (or the tail section is itself larger than
10842 stub_group_size, in which case we may be toast.) We
10843 should really be keeping track of the total size of stubs
10844 added here, as stubs contribute to the final output
10845 section size. That's a little tricky, and this way will
10846 only break if stubs added make the total size more than
10847 2^25, ie. for the default stub_group_size, if stubs total
10848 more than 2097152 bytes, or nearly 75000 plt call stubs. */
10849 do
10850 {
10851 prev = PREV_SEC (tail);
10852 /* Set up this stub group. */
10853 htab->stub_group[tail->id].link_sec = curr;
10854 }
10855 while (tail != curr && (tail = prev) != NULL);
10856
10857 /* But wait, there's more! Input sections up to stub_group_size
10858 bytes before the stub section can be handled by it too.
10859 Don't do this if we have a really large section after the
10860 stubs, as adding more stubs increases the chance that
10861 branches may not reach into the stub section. */
10862 if (!stubs_always_before_branch && !big_sec)
10863 {
10864 total = 0;
10865 while (prev != NULL
10866 && ((total += tail->output_offset - prev->output_offset)
10867 < (ppc64_elf_section_data (prev) != NULL
10868 && ppc64_elf_section_data (prev)->has_14bit_branch
10869 ? stub14_group_size : stub_group_size))
10870 && htab->stub_group[prev->id].toc_off == curr_toc)
10871 {
10872 tail = prev;
10873 prev = PREV_SEC (tail);
10874 htab->stub_group[tail->id].link_sec = curr;
10875 }
10876 }
10877 tail = prev;
10878 }
10879 }
10880 while (list-- != htab->input_list);
10881 free (htab->input_list);
10882 #undef PREV_SEC
10883 }
10884
10885 /* Determine and set the size of the stub section for a final link.
10886
10887 The basic idea here is to examine all the relocations looking for
10888 PC-relative calls to a target that is unreachable with a "bl"
10889 instruction. */
10890
10891 bfd_boolean
10892 ppc64_elf_size_stubs (struct bfd_link_info *info, bfd_signed_vma group_size)
10893 {
10894 bfd_size_type stub_group_size;
10895 bfd_boolean stubs_always_before_branch;
10896 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10897
10898 if (htab == NULL)
10899 return FALSE;
10900
10901 stubs_always_before_branch = group_size < 0;
10902 if (group_size < 0)
10903 stub_group_size = -group_size;
10904 else
10905 stub_group_size = group_size;
10906
10907 group_sections (htab, stub_group_size, stubs_always_before_branch);
10908
10909 while (1)
10910 {
10911 bfd *input_bfd;
10912 unsigned int bfd_indx;
10913 asection *stub_sec;
10914
10915 htab->stub_iteration += 1;
10916
10917 for (input_bfd = info->input_bfds, bfd_indx = 0;
10918 input_bfd != NULL;
10919 input_bfd = input_bfd->link_next, bfd_indx++)
10920 {
10921 Elf_Internal_Shdr *symtab_hdr;
10922 asection *section;
10923 Elf_Internal_Sym *local_syms = NULL;
10924
10925 if (!is_ppc64_elf (input_bfd))
10926 continue;
10927
10928 /* We'll need the symbol table in a second. */
10929 symtab_hdr = &elf_symtab_hdr (input_bfd);
10930 if (symtab_hdr->sh_info == 0)
10931 continue;
10932
10933 /* Walk over each section attached to the input bfd. */
10934 for (section = input_bfd->sections;
10935 section != NULL;
10936 section = section->next)
10937 {
10938 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
10939
10940 /* If there aren't any relocs, then there's nothing more
10941 to do. */
10942 if ((section->flags & SEC_RELOC) == 0
10943 || (section->flags & SEC_ALLOC) == 0
10944 || (section->flags & SEC_LOAD) == 0
10945 || (section->flags & SEC_CODE) == 0
10946 || section->reloc_count == 0)
10947 continue;
10948
10949 /* If this section is a link-once section that will be
10950 discarded, then don't create any stubs. */
10951 if (section->output_section == NULL
10952 || section->output_section->owner != info->output_bfd)
10953 continue;
10954
10955 /* Get the relocs. */
10956 internal_relocs
10957 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
10958 info->keep_memory);
10959 if (internal_relocs == NULL)
10960 goto error_ret_free_local;
10961
10962 /* Now examine each relocation. */
10963 irela = internal_relocs;
10964 irelaend = irela + section->reloc_count;
10965 for (; irela < irelaend; irela++)
10966 {
10967 enum elf_ppc64_reloc_type r_type;
10968 unsigned int r_indx;
10969 enum ppc_stub_type stub_type;
10970 struct ppc_stub_hash_entry *stub_entry;
10971 asection *sym_sec, *code_sec;
10972 bfd_vma sym_value, code_value;
10973 bfd_vma destination;
10974 bfd_boolean ok_dest;
10975 struct ppc_link_hash_entry *hash;
10976 struct ppc_link_hash_entry *fdh;
10977 struct elf_link_hash_entry *h;
10978 Elf_Internal_Sym *sym;
10979 char *stub_name;
10980 const asection *id_sec;
10981 struct _opd_sec_data *opd;
10982 struct plt_entry *plt_ent;
10983
10984 r_type = ELF64_R_TYPE (irela->r_info);
10985 r_indx = ELF64_R_SYM (irela->r_info);
10986
10987 if (r_type >= R_PPC64_max)
10988 {
10989 bfd_set_error (bfd_error_bad_value);
10990 goto error_ret_free_internal;
10991 }
10992
10993 /* Only look for stubs on branch instructions. */
10994 if (r_type != R_PPC64_REL24
10995 && r_type != R_PPC64_REL14
10996 && r_type != R_PPC64_REL14_BRTAKEN
10997 && r_type != R_PPC64_REL14_BRNTAKEN)
10998 continue;
10999
11000 /* Now determine the call target, its name, value,
11001 section. */
11002 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
11003 r_indx, input_bfd))
11004 goto error_ret_free_internal;
11005 hash = (struct ppc_link_hash_entry *) h;
11006
11007 ok_dest = FALSE;
11008 fdh = NULL;
11009 sym_value = 0;
11010 if (hash == NULL)
11011 {
11012 sym_value = sym->st_value;
11013 ok_dest = TRUE;
11014 }
11015 else if (hash->elf.root.type == bfd_link_hash_defined
11016 || hash->elf.root.type == bfd_link_hash_defweak)
11017 {
11018 sym_value = hash->elf.root.u.def.value;
11019 if (sym_sec->output_section != NULL)
11020 ok_dest = TRUE;
11021 }
11022 else if (hash->elf.root.type == bfd_link_hash_undefweak
11023 || hash->elf.root.type == bfd_link_hash_undefined)
11024 {
11025 /* Recognise an old ABI func code entry sym, and
11026 use the func descriptor sym instead if it is
11027 defined. */
11028 if (hash->elf.root.root.string[0] == '.'
11029 && (fdh = lookup_fdh (hash, htab)) != NULL)
11030 {
11031 if (fdh->elf.root.type == bfd_link_hash_defined
11032 || fdh->elf.root.type == bfd_link_hash_defweak)
11033 {
11034 sym_sec = fdh->elf.root.u.def.section;
11035 sym_value = fdh->elf.root.u.def.value;
11036 if (sym_sec->output_section != NULL)
11037 ok_dest = TRUE;
11038 }
11039 else
11040 fdh = NULL;
11041 }
11042 }
11043 else
11044 {
11045 bfd_set_error (bfd_error_bad_value);
11046 goto error_ret_free_internal;
11047 }
11048
11049 destination = 0;
11050 if (ok_dest)
11051 {
11052 sym_value += irela->r_addend;
11053 destination = (sym_value
11054 + sym_sec->output_offset
11055 + sym_sec->output_section->vma);
11056 }
11057
11058 code_sec = sym_sec;
11059 code_value = sym_value;
11060 opd = get_opd_info (sym_sec);
11061 if (opd != NULL)
11062 {
11063 bfd_vma dest;
11064
11065 if (hash == NULL && opd->adjust != NULL)
11066 {
11067 long adjust = opd->adjust[sym_value / 8];
11068 if (adjust == -1)
11069 continue;
11070 code_value += adjust;
11071 sym_value += adjust;
11072 }
11073 dest = opd_entry_value (sym_sec, sym_value,
11074 &code_sec, &code_value);
11075 if (dest != (bfd_vma) -1)
11076 {
11077 destination = dest;
11078 if (fdh != NULL)
11079 {
11080 /* Fixup old ABI sym to point at code
11081 entry. */
11082 hash->elf.root.type = bfd_link_hash_defweak;
11083 hash->elf.root.u.def.section = code_sec;
11084 hash->elf.root.u.def.value = code_value;
11085 }
11086 }
11087 }
11088
11089 /* Determine what (if any) linker stub is needed. */
11090 plt_ent = NULL;
11091 stub_type = ppc_type_of_stub (section, irela, &hash,
11092 &plt_ent, destination);
11093
11094 if (stub_type != ppc_stub_plt_call)
11095 {
11096 /* Check whether we need a TOC adjusting stub.
11097 Since the linker pastes together pieces from
11098 different object files when creating the
11099 _init and _fini functions, it may be that a
11100 call to what looks like a local sym is in
11101 fact a call needing a TOC adjustment. */
11102 if (code_sec != NULL
11103 && code_sec->output_section != NULL
11104 && (htab->stub_group[code_sec->id].toc_off
11105 != htab->stub_group[section->id].toc_off)
11106 && (code_sec->has_toc_reloc
11107 || code_sec->makes_toc_func_call))
11108 stub_type = ppc_stub_long_branch_r2off;
11109 }
11110
11111 if (stub_type == ppc_stub_none)
11112 continue;
11113
11114 /* __tls_get_addr calls might be eliminated. */
11115 if (stub_type != ppc_stub_plt_call
11116 && hash != NULL
11117 && (hash == htab->tls_get_addr
11118 || hash == htab->tls_get_addr_fd)
11119 && section->has_tls_reloc
11120 && irela != internal_relocs)
11121 {
11122 /* Get tls info. */
11123 unsigned char *tls_mask;
11124
11125 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
11126 irela - 1, input_bfd))
11127 goto error_ret_free_internal;
11128 if (*tls_mask != 0)
11129 continue;
11130 }
11131
11132 /* Support for grouping stub sections. */
11133 id_sec = htab->stub_group[section->id].link_sec;
11134
11135 /* Get the name of this stub. */
11136 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
11137 if (!stub_name)
11138 goto error_ret_free_internal;
11139
11140 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
11141 stub_name, FALSE, FALSE);
11142 if (stub_entry != NULL)
11143 {
11144 /* The proper stub has already been created. */
11145 free (stub_name);
11146 continue;
11147 }
11148
11149 stub_entry = ppc_add_stub (stub_name, section, htab);
11150 if (stub_entry == NULL)
11151 {
11152 free (stub_name);
11153 error_ret_free_internal:
11154 if (elf_section_data (section)->relocs == NULL)
11155 free (internal_relocs);
11156 error_ret_free_local:
11157 if (local_syms != NULL
11158 && (symtab_hdr->contents
11159 != (unsigned char *) local_syms))
11160 free (local_syms);
11161 return FALSE;
11162 }
11163
11164 stub_entry->stub_type = stub_type;
11165 if (stub_type != ppc_stub_plt_call)
11166 {
11167 stub_entry->target_value = code_value;
11168 stub_entry->target_section = code_sec;
11169 }
11170 else
11171 {
11172 stub_entry->target_value = sym_value;
11173 stub_entry->target_section = sym_sec;
11174 }
11175 stub_entry->h = hash;
11176 stub_entry->plt_ent = plt_ent;
11177 stub_entry->addend = irela->r_addend;
11178
11179 if (stub_entry->h != NULL)
11180 htab->stub_globals += 1;
11181 }
11182
11183 /* We're done with the internal relocs, free them. */
11184 if (elf_section_data (section)->relocs != internal_relocs)
11185 free (internal_relocs);
11186 }
11187
11188 if (local_syms != NULL
11189 && symtab_hdr->contents != (unsigned char *) local_syms)
11190 {
11191 if (!info->keep_memory)
11192 free (local_syms);
11193 else
11194 symtab_hdr->contents = (unsigned char *) local_syms;
11195 }
11196 }
11197
11198 /* We may have added some stubs. Find out the new size of the
11199 stub sections. */
11200 for (stub_sec = htab->stub_bfd->sections;
11201 stub_sec != NULL;
11202 stub_sec = stub_sec->next)
11203 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11204 {
11205 stub_sec->rawsize = stub_sec->size;
11206 stub_sec->size = 0;
11207 stub_sec->reloc_count = 0;
11208 stub_sec->flags &= ~SEC_RELOC;
11209 }
11210
11211 htab->brlt->size = 0;
11212 htab->brlt->reloc_count = 0;
11213 htab->brlt->flags &= ~SEC_RELOC;
11214 if (htab->relbrlt != NULL)
11215 htab->relbrlt->size = 0;
11216
11217 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
11218
11219 if (info->emitrelocations
11220 && htab->glink != NULL && htab->glink->size != 0)
11221 {
11222 htab->glink->reloc_count = 1;
11223 htab->glink->flags |= SEC_RELOC;
11224 }
11225
11226 for (stub_sec = htab->stub_bfd->sections;
11227 stub_sec != NULL;
11228 stub_sec = stub_sec->next)
11229 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
11230 && stub_sec->rawsize != stub_sec->size)
11231 break;
11232
11233 /* Exit from this loop when no stubs have been added, and no stubs
11234 have changed size. */
11235 if (stub_sec == NULL)
11236 break;
11237
11238 /* Ask the linker to do its stuff. */
11239 (*htab->layout_sections_again) ();
11240 }
11241
11242 /* It would be nice to strip htab->brlt from the output if the
11243 section is empty, but it's too late. If we strip sections here,
11244 the dynamic symbol table is corrupted since the section symbol
11245 for the stripped section isn't written. */
11246
11247 return TRUE;
11248 }
11249
11250 /* Called after we have determined section placement. If sections
11251 move, we'll be called again. Provide a value for TOCstart. */
11252
11253 bfd_vma
11254 ppc64_elf_toc (bfd *obfd)
11255 {
11256 asection *s;
11257 bfd_vma TOCstart;
11258
11259 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
11260 order. The TOC starts where the first of these sections starts. */
11261 s = bfd_get_section_by_name (obfd, ".got");
11262 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11263 s = bfd_get_section_by_name (obfd, ".toc");
11264 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11265 s = bfd_get_section_by_name (obfd, ".tocbss");
11266 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11267 s = bfd_get_section_by_name (obfd, ".plt");
11268 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11269 {
11270 /* This may happen for
11271 o references to TOC base (SYM@toc / TOC[tc0]) without a
11272 .toc directive
11273 o bad linker script
11274 o --gc-sections and empty TOC sections
11275
11276 FIXME: Warn user? */
11277
11278 /* Look for a likely section. We probably won't even be
11279 using TOCstart. */
11280 for (s = obfd->sections; s != NULL; s = s->next)
11281 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
11282 | SEC_EXCLUDE))
11283 == (SEC_ALLOC | SEC_SMALL_DATA))
11284 break;
11285 if (s == NULL)
11286 for (s = obfd->sections; s != NULL; s = s->next)
11287 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
11288 == (SEC_ALLOC | SEC_SMALL_DATA))
11289 break;
11290 if (s == NULL)
11291 for (s = obfd->sections; s != NULL; s = s->next)
11292 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
11293 == SEC_ALLOC)
11294 break;
11295 if (s == NULL)
11296 for (s = obfd->sections; s != NULL; s = s->next)
11297 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
11298 break;
11299 }
11300
11301 TOCstart = 0;
11302 if (s != NULL)
11303 TOCstart = s->output_section->vma + s->output_offset;
11304
11305 return TOCstart;
11306 }
11307
11308 /* Build all the stubs associated with the current output file.
11309 The stubs are kept in a hash table attached to the main linker
11310 hash table. This function is called via gldelf64ppc_finish. */
11311
11312 bfd_boolean
11313 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
11314 struct bfd_link_info *info,
11315 char **stats)
11316 {
11317 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11318 asection *stub_sec;
11319 bfd_byte *p;
11320 int stub_sec_count = 0;
11321
11322 if (htab == NULL)
11323 return FALSE;
11324
11325 htab->emit_stub_syms = emit_stub_syms;
11326
11327 /* Allocate memory to hold the linker stubs. */
11328 for (stub_sec = htab->stub_bfd->sections;
11329 stub_sec != NULL;
11330 stub_sec = stub_sec->next)
11331 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
11332 && stub_sec->size != 0)
11333 {
11334 stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
11335 if (stub_sec->contents == NULL)
11336 return FALSE;
11337 /* We want to check that built size is the same as calculated
11338 size. rawsize is a convenient location to use. */
11339 stub_sec->rawsize = stub_sec->size;
11340 stub_sec->size = 0;
11341 }
11342
11343 if (htab->glink != NULL && htab->glink->size != 0)
11344 {
11345 unsigned int indx;
11346 bfd_vma plt0;
11347
11348 /* Build the .glink plt call stub. */
11349 if (htab->emit_stub_syms)
11350 {
11351 struct elf_link_hash_entry *h;
11352 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
11353 TRUE, FALSE, FALSE);
11354 if (h == NULL)
11355 return FALSE;
11356 if (h->root.type == bfd_link_hash_new)
11357 {
11358 h->root.type = bfd_link_hash_defined;
11359 h->root.u.def.section = htab->glink;
11360 h->root.u.def.value = 8;
11361 h->ref_regular = 1;
11362 h->def_regular = 1;
11363 h->ref_regular_nonweak = 1;
11364 h->forced_local = 1;
11365 h->non_elf = 0;
11366 }
11367 }
11368 plt0 = htab->plt->output_section->vma + htab->plt->output_offset - 16;
11369 if (info->emitrelocations)
11370 {
11371 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
11372 if (r == NULL)
11373 return FALSE;
11374 r->r_offset = (htab->glink->output_offset
11375 + htab->glink->output_section->vma);
11376 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
11377 r->r_addend = plt0;
11378 }
11379 p = htab->glink->contents;
11380 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
11381 bfd_put_64 (htab->glink->owner, plt0, p);
11382 p += 8;
11383 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
11384 p += 4;
11385 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
11386 p += 4;
11387 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
11388 p += 4;
11389 bfd_put_32 (htab->glink->owner, LD_R2_M16R11, p);
11390 p += 4;
11391 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
11392 p += 4;
11393 bfd_put_32 (htab->glink->owner, ADD_R12_R2_R11, p);
11394 p += 4;
11395 bfd_put_32 (htab->glink->owner, LD_R11_0R12, p);
11396 p += 4;
11397 bfd_put_32 (htab->glink->owner, LD_R2_0R12 | 8, p);
11398 p += 4;
11399 bfd_put_32 (htab->glink->owner, MTCTR_R11, p);
11400 p += 4;
11401 bfd_put_32 (htab->glink->owner, LD_R11_0R12 | 16, p);
11402 p += 4;
11403 bfd_put_32 (htab->glink->owner, BCTR, p);
11404 p += 4;
11405 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
11406 {
11407 bfd_put_32 (htab->glink->owner, NOP, p);
11408 p += 4;
11409 }
11410
11411 /* Build the .glink lazy link call stubs. */
11412 indx = 0;
11413 while (p < htab->glink->contents + htab->glink->size)
11414 {
11415 if (indx < 0x8000)
11416 {
11417 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
11418 p += 4;
11419 }
11420 else
11421 {
11422 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
11423 p += 4;
11424 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx), p);
11425 p += 4;
11426 }
11427 bfd_put_32 (htab->glink->owner,
11428 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
11429 indx++;
11430 p += 4;
11431 }
11432 htab->glink->rawsize = p - htab->glink->contents;
11433 }
11434
11435 if (htab->brlt->size != 0)
11436 {
11437 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
11438 htab->brlt->size);
11439 if (htab->brlt->contents == NULL)
11440 return FALSE;
11441 }
11442 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
11443 {
11444 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
11445 htab->relbrlt->size);
11446 if (htab->relbrlt->contents == NULL)
11447 return FALSE;
11448 }
11449
11450 /* Build the stubs as directed by the stub hash table. */
11451 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
11452
11453 if (htab->relbrlt != NULL)
11454 htab->relbrlt->reloc_count = 0;
11455
11456 for (stub_sec = htab->stub_bfd->sections;
11457 stub_sec != NULL;
11458 stub_sec = stub_sec->next)
11459 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11460 {
11461 stub_sec_count += 1;
11462 if (stub_sec->rawsize != stub_sec->size)
11463 break;
11464 }
11465
11466 if (stub_sec != NULL
11467 || htab->glink->rawsize != htab->glink->size)
11468 {
11469 htab->stub_error = TRUE;
11470 (*_bfd_error_handler) (_("stubs don't match calculated size"));
11471 }
11472
11473 if (htab->stub_error)
11474 return FALSE;
11475
11476 if (stats != NULL)
11477 {
11478 *stats = bfd_malloc (500);
11479 if (*stats == NULL)
11480 return FALSE;
11481
11482 sprintf (*stats, _("linker stubs in %u group%s\n"
11483 " branch %lu\n"
11484 " toc adjust %lu\n"
11485 " long branch %lu\n"
11486 " long toc adj %lu\n"
11487 " plt call %lu"),
11488 stub_sec_count,
11489 stub_sec_count == 1 ? "" : "s",
11490 htab->stub_count[ppc_stub_long_branch - 1],
11491 htab->stub_count[ppc_stub_long_branch_r2off - 1],
11492 htab->stub_count[ppc_stub_plt_branch - 1],
11493 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
11494 htab->stub_count[ppc_stub_plt_call - 1]);
11495 }
11496 return TRUE;
11497 }
11498
11499 /* This function undoes the changes made by add_symbol_adjust. */
11500
11501 static bfd_boolean
11502 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11503 {
11504 struct ppc_link_hash_entry *eh;
11505
11506 if (h->root.type == bfd_link_hash_indirect)
11507 return TRUE;
11508
11509 if (h->root.type == bfd_link_hash_warning)
11510 h = (struct elf_link_hash_entry *) h->root.u.i.link;
11511
11512 eh = (struct ppc_link_hash_entry *) h;
11513 if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
11514 return TRUE;
11515
11516 eh->elf.root.type = bfd_link_hash_undefined;
11517 return TRUE;
11518 }
11519
11520 void
11521 ppc64_elf_restore_symbols (struct bfd_link_info *info)
11522 {
11523 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11524
11525 if (htab != NULL)
11526 elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
11527 }
11528
11529 /* What to do when ld finds relocations against symbols defined in
11530 discarded sections. */
11531
11532 static unsigned int
11533 ppc64_elf_action_discarded (asection *sec)
11534 {
11535 if (strcmp (".opd", sec->name) == 0)
11536 return 0;
11537
11538 if (strcmp (".toc", sec->name) == 0)
11539 return 0;
11540
11541 if (strcmp (".toc1", sec->name) == 0)
11542 return 0;
11543
11544 return _bfd_elf_default_action_discarded (sec);
11545 }
11546
11547 /* REL points to a low-part reloc on a largetoc instruction sequence.
11548 Find the matching high-part reloc instruction and verify that it
11549 is addis REG,x,imm. If so, set *REG to x and return a pointer to
11550 the high-part reloc. */
11551
11552 static const Elf_Internal_Rela *
11553 ha_reloc_match (const Elf_Internal_Rela *relocs,
11554 const Elf_Internal_Rela *rel,
11555 unsigned int *reg,
11556 bfd_boolean match_addend,
11557 const bfd *input_bfd,
11558 const bfd_byte *contents)
11559 {
11560 enum elf_ppc64_reloc_type r_type, r_type_ha;
11561 bfd_vma r_info_ha, r_addend;
11562
11563 r_type = ELF64_R_TYPE (rel->r_info);
11564 switch (r_type)
11565 {
11566 case R_PPC64_GOT_TLSLD16_LO:
11567 case R_PPC64_GOT_TLSGD16_LO:
11568 case R_PPC64_GOT_TPREL16_LO_DS:
11569 case R_PPC64_GOT_DTPREL16_LO_DS:
11570 case R_PPC64_GOT16_LO:
11571 case R_PPC64_TOC16_LO:
11572 r_type_ha = r_type + 2;
11573 break;
11574 case R_PPC64_GOT16_LO_DS:
11575 r_type_ha = R_PPC64_GOT16_HA;
11576 break;
11577 case R_PPC64_TOC16_LO_DS:
11578 r_type_ha = R_PPC64_TOC16_HA;
11579 break;
11580 default:
11581 abort ();
11582 }
11583 r_info_ha = ELF64_R_INFO (ELF64_R_SYM (rel->r_info), r_type_ha);
11584 r_addend = rel->r_addend;
11585
11586 while (--rel >= relocs)
11587 if (rel->r_info == r_info_ha
11588 && (!match_addend
11589 || rel->r_addend == r_addend))
11590 {
11591 const bfd_byte *p = contents + (rel->r_offset & ~3);
11592 unsigned int insn = bfd_get_32 (input_bfd, p);
11593 if ((insn & (0x3f << 26)) == (15u << 26) /* addis rt,x,imm */
11594 && (insn & (0x1f << 21)) == (*reg << 21))
11595 {
11596 *reg = (insn >> 16) & 0x1f;
11597 return rel;
11598 }
11599 break;
11600 }
11601 return NULL;
11602 }
11603
11604 /* The RELOCATE_SECTION function is called by the ELF backend linker
11605 to handle the relocations for a section.
11606
11607 The relocs are always passed as Rela structures; if the section
11608 actually uses Rel structures, the r_addend field will always be
11609 zero.
11610
11611 This function is responsible for adjust the section contents as
11612 necessary, and (if using Rela relocs and generating a
11613 relocatable output file) adjusting the reloc addend as
11614 necessary.
11615
11616 This function does not have to worry about setting the reloc
11617 address or the reloc symbol index.
11618
11619 LOCAL_SYMS is a pointer to the swapped in local symbols.
11620
11621 LOCAL_SECTIONS is an array giving the section in the input file
11622 corresponding to the st_shndx field of each local symbol.
11623
11624 The global hash table entry for the global symbols can be found
11625 via elf_sym_hashes (input_bfd).
11626
11627 When generating relocatable output, this function must handle
11628 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
11629 going to be the section symbol corresponding to the output
11630 section, which means that the addend must be adjusted
11631 accordingly. */
11632
11633 static bfd_boolean
11634 ppc64_elf_relocate_section (bfd *output_bfd,
11635 struct bfd_link_info *info,
11636 bfd *input_bfd,
11637 asection *input_section,
11638 bfd_byte *contents,
11639 Elf_Internal_Rela *relocs,
11640 Elf_Internal_Sym *local_syms,
11641 asection **local_sections)
11642 {
11643 struct ppc_link_hash_table *htab;
11644 Elf_Internal_Shdr *symtab_hdr;
11645 struct elf_link_hash_entry **sym_hashes;
11646 Elf_Internal_Rela *rel;
11647 Elf_Internal_Rela *relend;
11648 Elf_Internal_Rela outrel;
11649 bfd_byte *loc;
11650 struct got_entry **local_got_ents;
11651 unsigned char *ha_opt;
11652 bfd_vma TOCstart;
11653 bfd_boolean no_ha_opt;
11654 bfd_boolean ret = TRUE;
11655 bfd_boolean is_opd;
11656 /* Disabled until we sort out how ld should choose 'y' vs 'at'. */
11657 bfd_boolean is_power4 = FALSE;
11658 bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
11659
11660 /* Initialize howto table if needed. */
11661 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
11662 ppc_howto_init ();
11663
11664 htab = ppc_hash_table (info);
11665 if (htab == NULL)
11666 return FALSE;
11667
11668 /* Don't relocate stub sections. */
11669 if (input_section->owner == htab->stub_bfd)
11670 return TRUE;
11671
11672 BFD_ASSERT (is_ppc64_elf (input_bfd));
11673
11674 local_got_ents = elf_local_got_ents (input_bfd);
11675 TOCstart = elf_gp (output_bfd);
11676 symtab_hdr = &elf_symtab_hdr (input_bfd);
11677 sym_hashes = elf_sym_hashes (input_bfd);
11678 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
11679 ha_opt = NULL;
11680 no_ha_opt = FALSE;
11681
11682 rel = relocs;
11683 relend = relocs + input_section->reloc_count;
11684 for (; rel < relend; rel++)
11685 {
11686 enum elf_ppc64_reloc_type r_type;
11687 bfd_vma addend, orig_addend;
11688 bfd_reloc_status_type r;
11689 Elf_Internal_Sym *sym;
11690 asection *sec;
11691 struct elf_link_hash_entry *h_elf;
11692 struct ppc_link_hash_entry *h;
11693 struct ppc_link_hash_entry *fdh;
11694 const char *sym_name;
11695 unsigned long r_symndx, toc_symndx;
11696 bfd_vma toc_addend;
11697 unsigned char tls_mask, tls_gd, tls_type;
11698 unsigned char sym_type;
11699 bfd_vma relocation;
11700 bfd_boolean unresolved_reloc;
11701 bfd_boolean warned;
11702 unsigned int insn;
11703 unsigned int mask;
11704 struct ppc_stub_hash_entry *stub_entry;
11705 bfd_vma max_br_offset;
11706 bfd_vma from;
11707
11708 r_type = ELF64_R_TYPE (rel->r_info);
11709 r_symndx = ELF64_R_SYM (rel->r_info);
11710
11711 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
11712 symbol of the previous ADDR64 reloc. The symbol gives us the
11713 proper TOC base to use. */
11714 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
11715 && rel != relocs
11716 && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
11717 && is_opd)
11718 r_symndx = ELF64_R_SYM (rel[-1].r_info);
11719
11720 sym = NULL;
11721 sec = NULL;
11722 h_elf = NULL;
11723 sym_name = NULL;
11724 unresolved_reloc = FALSE;
11725 warned = FALSE;
11726 orig_addend = rel->r_addend;
11727
11728 if (r_symndx < symtab_hdr->sh_info)
11729 {
11730 /* It's a local symbol. */
11731 struct _opd_sec_data *opd;
11732
11733 sym = local_syms + r_symndx;
11734 sec = local_sections[r_symndx];
11735 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
11736 sym_type = ELF64_ST_TYPE (sym->st_info);
11737 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
11738 opd = get_opd_info (sec);
11739 if (opd != NULL && opd->adjust != NULL)
11740 {
11741 long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
11742 if (adjust == -1)
11743 relocation = 0;
11744 else
11745 {
11746 /* If this is a relocation against the opd section sym
11747 and we have edited .opd, adjust the reloc addend so
11748 that ld -r and ld --emit-relocs output is correct.
11749 If it is a reloc against some other .opd symbol,
11750 then the symbol value will be adjusted later. */
11751 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
11752 rel->r_addend += adjust;
11753 else
11754 relocation += adjust;
11755 }
11756 }
11757 }
11758 else
11759 {
11760 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
11761 r_symndx, symtab_hdr, sym_hashes,
11762 h_elf, sec, relocation,
11763 unresolved_reloc, warned);
11764 sym_name = h_elf->root.root.string;
11765 sym_type = h_elf->type;
11766 }
11767 h = (struct ppc_link_hash_entry *) h_elf;
11768
11769 if (sec != NULL && elf_discarded_section (sec))
11770 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
11771 rel, relend,
11772 ppc64_elf_howto_table[r_type],
11773 contents);
11774
11775 if (info->relocatable)
11776 continue;
11777
11778 /* TLS optimizations. Replace instruction sequences and relocs
11779 based on information we collected in tls_optimize. We edit
11780 RELOCS so that --emit-relocs will output something sensible
11781 for the final instruction stream. */
11782 tls_mask = 0;
11783 tls_gd = 0;
11784 toc_symndx = 0;
11785 if (h != NULL)
11786 tls_mask = h->tls_mask;
11787 else if (local_got_ents != NULL)
11788 {
11789 struct plt_entry **local_plt = (struct plt_entry **)
11790 (local_got_ents + symtab_hdr->sh_info);
11791 unsigned char *lgot_masks = (unsigned char *)
11792 (local_plt + symtab_hdr->sh_info);
11793 tls_mask = lgot_masks[r_symndx];
11794 }
11795 if (tls_mask == 0
11796 && (r_type == R_PPC64_TLS
11797 || r_type == R_PPC64_TLSGD
11798 || r_type == R_PPC64_TLSLD))
11799 {
11800 /* Check for toc tls entries. */
11801 unsigned char *toc_tls;
11802
11803 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
11804 &local_syms, rel, input_bfd))
11805 return FALSE;
11806
11807 if (toc_tls)
11808 tls_mask = *toc_tls;
11809 }
11810
11811 /* Check that tls relocs are used with tls syms, and non-tls
11812 relocs are used with non-tls syms. */
11813 if (r_symndx != STN_UNDEF
11814 && r_type != R_PPC64_NONE
11815 && (h == NULL
11816 || h->elf.root.type == bfd_link_hash_defined
11817 || h->elf.root.type == bfd_link_hash_defweak)
11818 && (IS_PPC64_TLS_RELOC (r_type)
11819 != (sym_type == STT_TLS
11820 || (sym_type == STT_SECTION
11821 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
11822 {
11823 if (tls_mask != 0
11824 && (r_type == R_PPC64_TLS
11825 || r_type == R_PPC64_TLSGD
11826 || r_type == R_PPC64_TLSLD))
11827 /* R_PPC64_TLS is OK against a symbol in the TOC. */
11828 ;
11829 else
11830 (*_bfd_error_handler)
11831 (!IS_PPC64_TLS_RELOC (r_type)
11832 ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
11833 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s"),
11834 input_bfd,
11835 input_section,
11836 (long) rel->r_offset,
11837 ppc64_elf_howto_table[r_type]->name,
11838 sym_name);
11839 }
11840
11841 /* Ensure reloc mapping code below stays sane. */
11842 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
11843 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
11844 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
11845 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
11846 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
11847 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
11848 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
11849 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
11850 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
11851 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
11852 abort ();
11853
11854 switch (r_type)
11855 {
11856 default:
11857 break;
11858
11859 case R_PPC64_LO_DS_OPT:
11860 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
11861 if ((insn & (0x3f << 26)) != 58u << 26)
11862 abort ();
11863 insn += (14u << 26) - (58u << 26);
11864 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
11865 r_type = R_PPC64_TOC16_LO;
11866 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11867 break;
11868
11869 case R_PPC64_TOC16:
11870 case R_PPC64_TOC16_LO:
11871 case R_PPC64_TOC16_DS:
11872 case R_PPC64_TOC16_LO_DS:
11873 {
11874 /* Check for toc tls entries. */
11875 unsigned char *toc_tls;
11876 int retval;
11877
11878 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
11879 &local_syms, rel, input_bfd);
11880 if (retval == 0)
11881 return FALSE;
11882
11883 if (toc_tls)
11884 {
11885 tls_mask = *toc_tls;
11886 if (r_type == R_PPC64_TOC16_DS
11887 || r_type == R_PPC64_TOC16_LO_DS)
11888 {
11889 if (tls_mask != 0
11890 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
11891 goto toctprel;
11892 }
11893 else
11894 {
11895 /* If we found a GD reloc pair, then we might be
11896 doing a GD->IE transition. */
11897 if (retval == 2)
11898 {
11899 tls_gd = TLS_TPRELGD;
11900 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
11901 goto tls_ldgd_opt;
11902 }
11903 else if (retval == 3)
11904 {
11905 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
11906 goto tls_ldgd_opt;
11907 }
11908 }
11909 }
11910 }
11911 break;
11912
11913 case R_PPC64_GOT_TPREL16_HI:
11914 case R_PPC64_GOT_TPREL16_HA:
11915 if (tls_mask != 0
11916 && (tls_mask & TLS_TPREL) == 0)
11917 {
11918 rel->r_offset -= d_offset;
11919 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
11920 r_type = R_PPC64_NONE;
11921 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11922 }
11923 break;
11924
11925 case R_PPC64_GOT_TPREL16_DS:
11926 case R_PPC64_GOT_TPREL16_LO_DS:
11927 if (tls_mask != 0
11928 && (tls_mask & TLS_TPREL) == 0)
11929 {
11930 toctprel:
11931 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
11932 insn &= 31 << 21;
11933 insn |= 0x3c0d0000; /* addis 0,13,0 */
11934 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
11935 r_type = R_PPC64_TPREL16_HA;
11936 if (toc_symndx != 0)
11937 {
11938 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
11939 rel->r_addend = toc_addend;
11940 /* We changed the symbol. Start over in order to
11941 get h, sym, sec etc. right. */
11942 rel--;
11943 continue;
11944 }
11945 else
11946 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11947 }
11948 break;
11949
11950 case R_PPC64_TLS:
11951 if (tls_mask != 0
11952 && (tls_mask & TLS_TPREL) == 0)
11953 {
11954 insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
11955 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
11956 if (insn == 0)
11957 abort ();
11958 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
11959 /* Was PPC64_TLS which sits on insn boundary, now
11960 PPC64_TPREL16_LO which is at low-order half-word. */
11961 rel->r_offset += d_offset;
11962 r_type = R_PPC64_TPREL16_LO;
11963 if (toc_symndx != 0)
11964 {
11965 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
11966 rel->r_addend = toc_addend;
11967 /* We changed the symbol. Start over in order to
11968 get h, sym, sec etc. right. */
11969 rel--;
11970 continue;
11971 }
11972 else
11973 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11974 }
11975 break;
11976
11977 case R_PPC64_GOT_TLSGD16_HI:
11978 case R_PPC64_GOT_TLSGD16_HA:
11979 tls_gd = TLS_TPRELGD;
11980 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
11981 goto tls_gdld_hi;
11982 break;
11983
11984 case R_PPC64_GOT_TLSLD16_HI:
11985 case R_PPC64_GOT_TLSLD16_HA:
11986 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
11987 {
11988 tls_gdld_hi:
11989 if ((tls_mask & tls_gd) != 0)
11990 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
11991 + R_PPC64_GOT_TPREL16_DS);
11992 else
11993 {
11994 rel->r_offset -= d_offset;
11995 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
11996 r_type = R_PPC64_NONE;
11997 }
11998 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11999 }
12000 break;
12001
12002 case R_PPC64_GOT_TLSGD16:
12003 case R_PPC64_GOT_TLSGD16_LO:
12004 tls_gd = TLS_TPRELGD;
12005 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12006 goto tls_ldgd_opt;
12007 break;
12008
12009 case R_PPC64_GOT_TLSLD16:
12010 case R_PPC64_GOT_TLSLD16_LO:
12011 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12012 {
12013 unsigned int insn1, insn2, insn3;
12014 bfd_vma offset;
12015
12016 tls_ldgd_opt:
12017 offset = (bfd_vma) -1;
12018 /* If not using the newer R_PPC64_TLSGD/LD to mark
12019 __tls_get_addr calls, we must trust that the call
12020 stays with its arg setup insns, ie. that the next
12021 reloc is the __tls_get_addr call associated with
12022 the current reloc. Edit both insns. */
12023 if (input_section->has_tls_get_addr_call
12024 && rel + 1 < relend
12025 && branch_reloc_hash_match (input_bfd, rel + 1,
12026 htab->tls_get_addr,
12027 htab->tls_get_addr_fd))
12028 offset = rel[1].r_offset;
12029 if ((tls_mask & tls_gd) != 0)
12030 {
12031 /* IE */
12032 insn1 = bfd_get_32 (output_bfd,
12033 contents + rel->r_offset - d_offset);
12034 insn1 &= (1 << 26) - (1 << 2);
12035 insn1 |= 58 << 26; /* ld */
12036 insn2 = 0x7c636a14; /* add 3,3,13 */
12037 if (offset != (bfd_vma) -1)
12038 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
12039 if ((tls_mask & TLS_EXPLICIT) == 0)
12040 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
12041 + R_PPC64_GOT_TPREL16_DS);
12042 else
12043 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
12044 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12045 }
12046 else
12047 {
12048 /* LE */
12049 insn1 = 0x3c6d0000; /* addis 3,13,0 */
12050 insn2 = 0x38630000; /* addi 3,3,0 */
12051 if (tls_gd == 0)
12052 {
12053 /* Was an LD reloc. */
12054 if (toc_symndx)
12055 sec = local_sections[toc_symndx];
12056 for (r_symndx = 0;
12057 r_symndx < symtab_hdr->sh_info;
12058 r_symndx++)
12059 if (local_sections[r_symndx] == sec)
12060 break;
12061 if (r_symndx >= symtab_hdr->sh_info)
12062 r_symndx = STN_UNDEF;
12063 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
12064 if (r_symndx != STN_UNDEF)
12065 rel->r_addend -= (local_syms[r_symndx].st_value
12066 + sec->output_offset
12067 + sec->output_section->vma);
12068 }
12069 else if (toc_symndx != 0)
12070 {
12071 r_symndx = toc_symndx;
12072 rel->r_addend = toc_addend;
12073 }
12074 r_type = R_PPC64_TPREL16_HA;
12075 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12076 if (offset != (bfd_vma) -1)
12077 {
12078 rel[1].r_info = ELF64_R_INFO (r_symndx,
12079 R_PPC64_TPREL16_LO);
12080 rel[1].r_offset = offset + d_offset;
12081 rel[1].r_addend = rel->r_addend;
12082 }
12083 }
12084 bfd_put_32 (output_bfd, insn1,
12085 contents + rel->r_offset - d_offset);
12086 if (offset != (bfd_vma) -1)
12087 {
12088 insn3 = bfd_get_32 (output_bfd,
12089 contents + offset + 4);
12090 if (insn3 == NOP
12091 || insn3 == CROR_151515 || insn3 == CROR_313131)
12092 {
12093 rel[1].r_offset += 4;
12094 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
12095 insn2 = NOP;
12096 }
12097 bfd_put_32 (output_bfd, insn2, contents + offset);
12098 }
12099 if ((tls_mask & tls_gd) == 0
12100 && (tls_gd == 0 || toc_symndx != 0))
12101 {
12102 /* We changed the symbol. Start over in order
12103 to get h, sym, sec etc. right. */
12104 rel--;
12105 continue;
12106 }
12107 }
12108 break;
12109
12110 case R_PPC64_TLSGD:
12111 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12112 {
12113 unsigned int insn2, insn3;
12114 bfd_vma offset = rel->r_offset;
12115
12116 if ((tls_mask & TLS_TPRELGD) != 0)
12117 {
12118 /* IE */
12119 r_type = R_PPC64_NONE;
12120 insn2 = 0x7c636a14; /* add 3,3,13 */
12121 }
12122 else
12123 {
12124 /* LE */
12125 if (toc_symndx != 0)
12126 {
12127 r_symndx = toc_symndx;
12128 rel->r_addend = toc_addend;
12129 }
12130 r_type = R_PPC64_TPREL16_LO;
12131 rel->r_offset = offset + d_offset;
12132 insn2 = 0x38630000; /* addi 3,3,0 */
12133 }
12134 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12135 /* Zap the reloc on the _tls_get_addr call too. */
12136 BFD_ASSERT (offset == rel[1].r_offset);
12137 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
12138 insn3 = bfd_get_32 (output_bfd,
12139 contents + offset + 4);
12140 if (insn3 == NOP
12141 || insn3 == CROR_151515 || insn3 == CROR_313131)
12142 {
12143 rel->r_offset += 4;
12144 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
12145 insn2 = NOP;
12146 }
12147 bfd_put_32 (output_bfd, insn2, contents + offset);
12148 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
12149 {
12150 rel--;
12151 continue;
12152 }
12153 }
12154 break;
12155
12156 case R_PPC64_TLSLD:
12157 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12158 {
12159 unsigned int insn2, insn3;
12160 bfd_vma offset = rel->r_offset;
12161
12162 if (toc_symndx)
12163 sec = local_sections[toc_symndx];
12164 for (r_symndx = 0;
12165 r_symndx < symtab_hdr->sh_info;
12166 r_symndx++)
12167 if (local_sections[r_symndx] == sec)
12168 break;
12169 if (r_symndx >= symtab_hdr->sh_info)
12170 r_symndx = STN_UNDEF;
12171 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
12172 if (r_symndx != STN_UNDEF)
12173 rel->r_addend -= (local_syms[r_symndx].st_value
12174 + sec->output_offset
12175 + sec->output_section->vma);
12176
12177 r_type = R_PPC64_TPREL16_LO;
12178 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12179 rel->r_offset = offset + d_offset;
12180 /* Zap the reloc on the _tls_get_addr call too. */
12181 BFD_ASSERT (offset == rel[1].r_offset);
12182 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
12183 insn2 = 0x38630000; /* addi 3,3,0 */
12184 insn3 = bfd_get_32 (output_bfd,
12185 contents + offset + 4);
12186 if (insn3 == NOP
12187 || insn3 == CROR_151515 || insn3 == CROR_313131)
12188 {
12189 rel->r_offset += 4;
12190 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
12191 insn2 = NOP;
12192 }
12193 bfd_put_32 (output_bfd, insn2, contents + offset);
12194 rel--;
12195 continue;
12196 }
12197 break;
12198
12199 case R_PPC64_DTPMOD64:
12200 if (rel + 1 < relend
12201 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
12202 && rel[1].r_offset == rel->r_offset + 8)
12203 {
12204 if ((tls_mask & TLS_GD) == 0)
12205 {
12206 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
12207 if ((tls_mask & TLS_TPRELGD) != 0)
12208 r_type = R_PPC64_TPREL64;
12209 else
12210 {
12211 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
12212 r_type = R_PPC64_NONE;
12213 }
12214 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12215 }
12216 }
12217 else
12218 {
12219 if ((tls_mask & TLS_LD) == 0)
12220 {
12221 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
12222 r_type = R_PPC64_NONE;
12223 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12224 }
12225 }
12226 break;
12227
12228 case R_PPC64_TPREL64:
12229 if ((tls_mask & TLS_TPREL) == 0)
12230 {
12231 r_type = R_PPC64_NONE;
12232 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12233 }
12234 break;
12235 }
12236
12237 /* Handle other relocations that tweak non-addend part of insn. */
12238 insn = 0;
12239 max_br_offset = 1 << 25;
12240 addend = rel->r_addend;
12241 switch (r_type)
12242 {
12243 default:
12244 break;
12245
12246 /* Branch taken prediction relocations. */
12247 case R_PPC64_ADDR14_BRTAKEN:
12248 case R_PPC64_REL14_BRTAKEN:
12249 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
12250 /* Fall thru. */
12251
12252 /* Branch not taken prediction relocations. */
12253 case R_PPC64_ADDR14_BRNTAKEN:
12254 case R_PPC64_REL14_BRNTAKEN:
12255 insn |= bfd_get_32 (output_bfd,
12256 contents + rel->r_offset) & ~(0x01 << 21);
12257 /* Fall thru. */
12258
12259 case R_PPC64_REL14:
12260 max_br_offset = 1 << 15;
12261 /* Fall thru. */
12262
12263 case R_PPC64_REL24:
12264 /* Calls to functions with a different TOC, such as calls to
12265 shared objects, need to alter the TOC pointer. This is
12266 done using a linkage stub. A REL24 branching to these
12267 linkage stubs needs to be followed by a nop, as the nop
12268 will be replaced with an instruction to restore the TOC
12269 base pointer. */
12270 fdh = h;
12271 if (h != NULL
12272 && h->oh != NULL
12273 && h->oh->is_func_descriptor)
12274 fdh = ppc_follow_link (h->oh);
12275 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, rel, htab);
12276 if (stub_entry != NULL
12277 && (stub_entry->stub_type == ppc_stub_plt_call
12278 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
12279 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
12280 {
12281 bfd_boolean can_plt_call = FALSE;
12282
12283 if (rel->r_offset + 8 <= input_section->size)
12284 {
12285 unsigned long nop;
12286 nop = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
12287 if (nop == NOP
12288 || nop == CROR_151515 || nop == CROR_313131)
12289 {
12290 if (h != NULL
12291 && (h == htab->tls_get_addr_fd
12292 || h == htab->tls_get_addr)
12293 && !htab->no_tls_get_addr_opt)
12294 {
12295 /* Special stub used, leave nop alone. */
12296 }
12297 else
12298 bfd_put_32 (input_bfd, LD_R2_40R1,
12299 contents + rel->r_offset + 4);
12300 can_plt_call = TRUE;
12301 }
12302 }
12303
12304 if (!can_plt_call)
12305 {
12306 if (stub_entry->stub_type == ppc_stub_plt_call)
12307 {
12308 /* If this is a plain branch rather than a branch
12309 and link, don't require a nop. However, don't
12310 allow tail calls in a shared library as they
12311 will result in r2 being corrupted. */
12312 unsigned long br;
12313 br = bfd_get_32 (input_bfd, contents + rel->r_offset);
12314 if (info->executable && (br & 1) == 0)
12315 can_plt_call = TRUE;
12316 else
12317 stub_entry = NULL;
12318 }
12319 else if (h != NULL
12320 && strcmp (h->elf.root.root.string,
12321 ".__libc_start_main") == 0)
12322 {
12323 /* Allow crt1 branch to go via a toc adjusting stub. */
12324 can_plt_call = TRUE;
12325 }
12326 else
12327 {
12328 if (strcmp (input_section->output_section->name,
12329 ".init") == 0
12330 || strcmp (input_section->output_section->name,
12331 ".fini") == 0)
12332 (*_bfd_error_handler)
12333 (_("%B(%A+0x%lx): automatic multiple TOCs "
12334 "not supported using your crt files; "
12335 "recompile with -mminimal-toc or upgrade gcc"),
12336 input_bfd,
12337 input_section,
12338 (long) rel->r_offset);
12339 else
12340 (*_bfd_error_handler)
12341 (_("%B(%A+0x%lx): sibling call optimization to `%s' "
12342 "does not allow automatic multiple TOCs; "
12343 "recompile with -mminimal-toc or "
12344 "-fno-optimize-sibling-calls, "
12345 "or make `%s' extern"),
12346 input_bfd,
12347 input_section,
12348 (long) rel->r_offset,
12349 sym_name,
12350 sym_name);
12351 bfd_set_error (bfd_error_bad_value);
12352 ret = FALSE;
12353 }
12354 }
12355
12356 if (can_plt_call
12357 && stub_entry->stub_type == ppc_stub_plt_call)
12358 unresolved_reloc = FALSE;
12359 }
12360
12361 if ((stub_entry == NULL
12362 || stub_entry->stub_type == ppc_stub_long_branch
12363 || stub_entry->stub_type == ppc_stub_plt_branch)
12364 && get_opd_info (sec) != NULL)
12365 {
12366 /* The branch destination is the value of the opd entry. */
12367 bfd_vma off = (relocation + addend
12368 - sec->output_section->vma
12369 - sec->output_offset);
12370 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL);
12371 if (dest != (bfd_vma) -1)
12372 {
12373 relocation = dest;
12374 addend = 0;
12375 }
12376 }
12377
12378 /* If the branch is out of reach we ought to have a long
12379 branch stub. */
12380 from = (rel->r_offset
12381 + input_section->output_offset
12382 + input_section->output_section->vma);
12383
12384 if (stub_entry != NULL
12385 && (stub_entry->stub_type == ppc_stub_long_branch
12386 || stub_entry->stub_type == ppc_stub_plt_branch)
12387 && (r_type == R_PPC64_ADDR14_BRTAKEN
12388 || r_type == R_PPC64_ADDR14_BRNTAKEN
12389 || (relocation + addend - from + max_br_offset
12390 < 2 * max_br_offset)))
12391 /* Don't use the stub if this branch is in range. */
12392 stub_entry = NULL;
12393
12394 if (stub_entry != NULL)
12395 {
12396 /* Munge up the value and addend so that we call the stub
12397 rather than the procedure directly. */
12398 relocation = (stub_entry->stub_offset
12399 + stub_entry->stub_sec->output_offset
12400 + stub_entry->stub_sec->output_section->vma);
12401 addend = 0;
12402 }
12403
12404 if (insn != 0)
12405 {
12406 if (is_power4)
12407 {
12408 /* Set 'a' bit. This is 0b00010 in BO field for branch
12409 on CR(BI) insns (BO == 001at or 011at), and 0b01000
12410 for branch on CTR insns (BO == 1a00t or 1a01t). */
12411 if ((insn & (0x14 << 21)) == (0x04 << 21))
12412 insn |= 0x02 << 21;
12413 else if ((insn & (0x14 << 21)) == (0x10 << 21))
12414 insn |= 0x08 << 21;
12415 else
12416 break;
12417 }
12418 else
12419 {
12420 /* Invert 'y' bit if not the default. */
12421 if ((bfd_signed_vma) (relocation + addend - from) < 0)
12422 insn ^= 0x01 << 21;
12423 }
12424
12425 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
12426 }
12427
12428 /* NOP out calls to undefined weak functions.
12429 We can thus call a weak function without first
12430 checking whether the function is defined. */
12431 else if (h != NULL
12432 && h->elf.root.type == bfd_link_hash_undefweak
12433 && h->elf.dynindx == -1
12434 && r_type == R_PPC64_REL24
12435 && relocation == 0
12436 && addend == 0)
12437 {
12438 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
12439 continue;
12440 }
12441 break;
12442 }
12443
12444 /* Set `addend'. */
12445 tls_type = 0;
12446 switch (r_type)
12447 {
12448 default:
12449 (*_bfd_error_handler)
12450 (_("%B: unknown relocation type %d for symbol %s"),
12451 input_bfd, (int) r_type, sym_name);
12452
12453 bfd_set_error (bfd_error_bad_value);
12454 ret = FALSE;
12455 continue;
12456
12457 case R_PPC64_NONE:
12458 case R_PPC64_TLS:
12459 case R_PPC64_TLSGD:
12460 case R_PPC64_TLSLD:
12461 case R_PPC64_GNU_VTINHERIT:
12462 case R_PPC64_GNU_VTENTRY:
12463 continue;
12464
12465 /* GOT16 relocations. Like an ADDR16 using the symbol's
12466 address in the GOT as relocation value instead of the
12467 symbol's value itself. Also, create a GOT entry for the
12468 symbol and put the symbol value there. */
12469 case R_PPC64_GOT_TLSGD16:
12470 case R_PPC64_GOT_TLSGD16_LO:
12471 case R_PPC64_GOT_TLSGD16_HI:
12472 case R_PPC64_GOT_TLSGD16_HA:
12473 tls_type = TLS_TLS | TLS_GD;
12474 goto dogot;
12475
12476 case R_PPC64_GOT_TLSLD16:
12477 case R_PPC64_GOT_TLSLD16_LO:
12478 case R_PPC64_GOT_TLSLD16_HI:
12479 case R_PPC64_GOT_TLSLD16_HA:
12480 tls_type = TLS_TLS | TLS_LD;
12481 goto dogot;
12482
12483 case R_PPC64_GOT_TPREL16_DS:
12484 case R_PPC64_GOT_TPREL16_LO_DS:
12485 case R_PPC64_GOT_TPREL16_HI:
12486 case R_PPC64_GOT_TPREL16_HA:
12487 tls_type = TLS_TLS | TLS_TPREL;
12488 goto dogot;
12489
12490 case R_PPC64_GOT_DTPREL16_DS:
12491 case R_PPC64_GOT_DTPREL16_LO_DS:
12492 case R_PPC64_GOT_DTPREL16_HI:
12493 case R_PPC64_GOT_DTPREL16_HA:
12494 tls_type = TLS_TLS | TLS_DTPREL;
12495 goto dogot;
12496
12497 case R_PPC64_GOT16:
12498 case R_PPC64_GOT16_LO:
12499 case R_PPC64_GOT16_HI:
12500 case R_PPC64_GOT16_HA:
12501 case R_PPC64_GOT16_DS:
12502 case R_PPC64_GOT16_LO_DS:
12503 dogot:
12504 {
12505 /* Relocation is to the entry for this symbol in the global
12506 offset table. */
12507 asection *got;
12508 bfd_vma *offp;
12509 bfd_vma off;
12510 unsigned long indx = 0;
12511 struct got_entry *ent;
12512
12513 if (tls_type == (TLS_TLS | TLS_LD)
12514 && (h == NULL
12515 || !h->elf.def_dynamic))
12516 ent = ppc64_tlsld_got (input_bfd);
12517 else
12518 {
12519
12520 if (h != NULL)
12521 {
12522 bfd_boolean dyn = htab->elf.dynamic_sections_created;
12523 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
12524 &h->elf)
12525 || (info->shared
12526 && SYMBOL_CALLS_LOCAL (info, &h->elf)))
12527 /* This is actually a static link, or it is a
12528 -Bsymbolic link and the symbol is defined
12529 locally, or the symbol was forced to be local
12530 because of a version file. */
12531 ;
12532 else
12533 {
12534 indx = h->elf.dynindx;
12535 unresolved_reloc = FALSE;
12536 }
12537 ent = h->elf.got.glist;
12538 }
12539 else
12540 {
12541 if (local_got_ents == NULL)
12542 abort ();
12543 ent = local_got_ents[r_symndx];
12544 }
12545
12546 for (; ent != NULL; ent = ent->next)
12547 if (ent->addend == orig_addend
12548 && ent->owner == input_bfd
12549 && ent->tls_type == tls_type)
12550 break;
12551 }
12552
12553 if (ent == NULL)
12554 abort ();
12555 if (ent->is_indirect)
12556 ent = ent->got.ent;
12557 offp = &ent->got.offset;
12558 got = ppc64_elf_tdata (ent->owner)->got;
12559 if (got == NULL)
12560 abort ();
12561
12562 /* The offset must always be a multiple of 8. We use the
12563 least significant bit to record whether we have already
12564 processed this entry. */
12565 off = *offp;
12566 if ((off & 1) != 0)
12567 off &= ~1;
12568 else
12569 {
12570 /* Generate relocs for the dynamic linker, except in
12571 the case of TLSLD where we'll use one entry per
12572 module. */
12573 asection *relgot;
12574 bfd_boolean ifunc;
12575
12576 *offp = off | 1;
12577 relgot = NULL;
12578 ifunc = (h != NULL
12579 ? h->elf.type == STT_GNU_IFUNC
12580 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
12581 if ((info->shared || indx != 0)
12582 && (h == NULL
12583 || (tls_type == (TLS_TLS | TLS_LD)
12584 && !h->elf.def_dynamic)
12585 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
12586 || h->elf.root.type != bfd_link_hash_undefweak))
12587 relgot = ppc64_elf_tdata (ent->owner)->relgot;
12588 else if (ifunc)
12589 relgot = htab->reliplt;
12590 if (relgot != NULL)
12591 {
12592 outrel.r_offset = (got->output_section->vma
12593 + got->output_offset
12594 + off);
12595 outrel.r_addend = addend;
12596 if (tls_type & (TLS_LD | TLS_GD))
12597 {
12598 outrel.r_addend = 0;
12599 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
12600 if (tls_type == (TLS_TLS | TLS_GD))
12601 {
12602 loc = relgot->contents;
12603 loc += (relgot->reloc_count++
12604 * sizeof (Elf64_External_Rela));
12605 bfd_elf64_swap_reloca_out (output_bfd,
12606 &outrel, loc);
12607 outrel.r_offset += 8;
12608 outrel.r_addend = addend;
12609 outrel.r_info
12610 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
12611 }
12612 }
12613 else if (tls_type == (TLS_TLS | TLS_DTPREL))
12614 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
12615 else if (tls_type == (TLS_TLS | TLS_TPREL))
12616 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
12617 else if (indx != 0)
12618 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
12619 else
12620 {
12621 if (ifunc)
12622 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
12623 else
12624 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
12625
12626 /* Write the .got section contents for the sake
12627 of prelink. */
12628 loc = got->contents + off;
12629 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
12630 loc);
12631 }
12632
12633 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
12634 {
12635 outrel.r_addend += relocation;
12636 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
12637 outrel.r_addend -= htab->elf.tls_sec->vma;
12638 }
12639 loc = relgot->contents;
12640 loc += (relgot->reloc_count++
12641 * sizeof (Elf64_External_Rela));
12642 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
12643 }
12644
12645 /* Init the .got section contents here if we're not
12646 emitting a reloc. */
12647 else
12648 {
12649 relocation += addend;
12650 if (tls_type == (TLS_TLS | TLS_LD))
12651 relocation = 1;
12652 else if (tls_type != 0)
12653 {
12654 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
12655 if (tls_type == (TLS_TLS | TLS_TPREL))
12656 relocation += DTP_OFFSET - TP_OFFSET;
12657
12658 if (tls_type == (TLS_TLS | TLS_GD))
12659 {
12660 bfd_put_64 (output_bfd, relocation,
12661 got->contents + off + 8);
12662 relocation = 1;
12663 }
12664 }
12665
12666 bfd_put_64 (output_bfd, relocation,
12667 got->contents + off);
12668 }
12669 }
12670
12671 if (off >= (bfd_vma) -2)
12672 abort ();
12673
12674 relocation = got->output_section->vma + got->output_offset + off;
12675 addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
12676 }
12677 break;
12678
12679 case R_PPC64_PLT16_HA:
12680 case R_PPC64_PLT16_HI:
12681 case R_PPC64_PLT16_LO:
12682 case R_PPC64_PLT32:
12683 case R_PPC64_PLT64:
12684 /* Relocation is to the entry for this symbol in the
12685 procedure linkage table. */
12686
12687 /* Resolve a PLT reloc against a local symbol directly,
12688 without using the procedure linkage table. */
12689 if (h == NULL)
12690 break;
12691
12692 /* It's possible that we didn't make a PLT entry for this
12693 symbol. This happens when statically linking PIC code,
12694 or when using -Bsymbolic. Go find a match if there is a
12695 PLT entry. */
12696 if (htab->plt != NULL)
12697 {
12698 struct plt_entry *ent;
12699 for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
12700 if (ent->addend == orig_addend
12701 && ent->plt.offset != (bfd_vma) -1)
12702 {
12703 relocation = (htab->plt->output_section->vma
12704 + htab->plt->output_offset
12705 + ent->plt.offset);
12706 unresolved_reloc = FALSE;
12707 }
12708 }
12709 break;
12710
12711 case R_PPC64_TOC:
12712 /* Relocation value is TOC base. */
12713 relocation = TOCstart;
12714 if (r_symndx == STN_UNDEF)
12715 relocation += htab->stub_group[input_section->id].toc_off;
12716 else if (unresolved_reloc)
12717 ;
12718 else if (sec != NULL && sec->id <= htab->top_id)
12719 relocation += htab->stub_group[sec->id].toc_off;
12720 else
12721 unresolved_reloc = TRUE;
12722 goto dodyn;
12723
12724 /* TOC16 relocs. We want the offset relative to the TOC base,
12725 which is the address of the start of the TOC plus 0x8000.
12726 The TOC consists of sections .got, .toc, .tocbss, and .plt,
12727 in this order. */
12728 case R_PPC64_TOC16:
12729 case R_PPC64_TOC16_LO:
12730 case R_PPC64_TOC16_HI:
12731 case R_PPC64_TOC16_DS:
12732 case R_PPC64_TOC16_LO_DS:
12733 case R_PPC64_TOC16_HA:
12734 addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
12735 break;
12736
12737 /* Relocate against the beginning of the section. */
12738 case R_PPC64_SECTOFF:
12739 case R_PPC64_SECTOFF_LO:
12740 case R_PPC64_SECTOFF_HI:
12741 case R_PPC64_SECTOFF_DS:
12742 case R_PPC64_SECTOFF_LO_DS:
12743 case R_PPC64_SECTOFF_HA:
12744 if (sec != NULL)
12745 addend -= sec->output_section->vma;
12746 break;
12747
12748 case R_PPC64_REL16:
12749 case R_PPC64_REL16_LO:
12750 case R_PPC64_REL16_HI:
12751 case R_PPC64_REL16_HA:
12752 break;
12753
12754 case R_PPC64_REL14:
12755 case R_PPC64_REL14_BRNTAKEN:
12756 case R_PPC64_REL14_BRTAKEN:
12757 case R_PPC64_REL24:
12758 break;
12759
12760 case R_PPC64_TPREL16:
12761 case R_PPC64_TPREL16_LO:
12762 case R_PPC64_TPREL16_HI:
12763 case R_PPC64_TPREL16_HA:
12764 case R_PPC64_TPREL16_DS:
12765 case R_PPC64_TPREL16_LO_DS:
12766 case R_PPC64_TPREL16_HIGHER:
12767 case R_PPC64_TPREL16_HIGHERA:
12768 case R_PPC64_TPREL16_HIGHEST:
12769 case R_PPC64_TPREL16_HIGHESTA:
12770 if (h != NULL
12771 && h->elf.root.type == bfd_link_hash_undefweak
12772 && h->elf.dynindx == -1)
12773 {
12774 /* Make this relocation against an undefined weak symbol
12775 resolve to zero. This is really just a tweak, since
12776 code using weak externs ought to check that they are
12777 defined before using them. */
12778 bfd_byte *p = contents + rel->r_offset - d_offset;
12779
12780 insn = bfd_get_32 (output_bfd, p);
12781 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
12782 if (insn != 0)
12783 bfd_put_32 (output_bfd, insn, p);
12784 break;
12785 }
12786 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
12787 if (info->shared)
12788 /* The TPREL16 relocs shouldn't really be used in shared
12789 libs as they will result in DT_TEXTREL being set, but
12790 support them anyway. */
12791 goto dodyn;
12792 break;
12793
12794 case R_PPC64_DTPREL16:
12795 case R_PPC64_DTPREL16_LO:
12796 case R_PPC64_DTPREL16_HI:
12797 case R_PPC64_DTPREL16_HA:
12798 case R_PPC64_DTPREL16_DS:
12799 case R_PPC64_DTPREL16_LO_DS:
12800 case R_PPC64_DTPREL16_HIGHER:
12801 case R_PPC64_DTPREL16_HIGHERA:
12802 case R_PPC64_DTPREL16_HIGHEST:
12803 case R_PPC64_DTPREL16_HIGHESTA:
12804 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
12805 break;
12806
12807 case R_PPC64_DTPMOD64:
12808 relocation = 1;
12809 addend = 0;
12810 goto dodyn;
12811
12812 case R_PPC64_TPREL64:
12813 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
12814 goto dodyn;
12815
12816 case R_PPC64_DTPREL64:
12817 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
12818 /* Fall thru */
12819
12820 /* Relocations that may need to be propagated if this is a
12821 dynamic object. */
12822 case R_PPC64_REL30:
12823 case R_PPC64_REL32:
12824 case R_PPC64_REL64:
12825 case R_PPC64_ADDR14:
12826 case R_PPC64_ADDR14_BRNTAKEN:
12827 case R_PPC64_ADDR14_BRTAKEN:
12828 case R_PPC64_ADDR16:
12829 case R_PPC64_ADDR16_DS:
12830 case R_PPC64_ADDR16_HA:
12831 case R_PPC64_ADDR16_HI:
12832 case R_PPC64_ADDR16_HIGHER:
12833 case R_PPC64_ADDR16_HIGHERA:
12834 case R_PPC64_ADDR16_HIGHEST:
12835 case R_PPC64_ADDR16_HIGHESTA:
12836 case R_PPC64_ADDR16_LO:
12837 case R_PPC64_ADDR16_LO_DS:
12838 case R_PPC64_ADDR24:
12839 case R_PPC64_ADDR32:
12840 case R_PPC64_ADDR64:
12841 case R_PPC64_UADDR16:
12842 case R_PPC64_UADDR32:
12843 case R_PPC64_UADDR64:
12844 dodyn:
12845 if ((input_section->flags & SEC_ALLOC) == 0)
12846 break;
12847
12848 if (NO_OPD_RELOCS && is_opd)
12849 break;
12850
12851 if ((info->shared
12852 && (h == NULL
12853 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
12854 || h->elf.root.type != bfd_link_hash_undefweak)
12855 && (must_be_dyn_reloc (info, r_type)
12856 || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
12857 || (ELIMINATE_COPY_RELOCS
12858 && !info->shared
12859 && h != NULL
12860 && h->elf.dynindx != -1
12861 && !h->elf.non_got_ref
12862 && !h->elf.def_regular)
12863 || (!info->shared
12864 && (h != NULL
12865 ? h->elf.type == STT_GNU_IFUNC
12866 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
12867 {
12868 bfd_boolean skip, relocate;
12869 asection *sreloc;
12870 bfd_vma out_off;
12871
12872 /* When generating a dynamic object, these relocations
12873 are copied into the output file to be resolved at run
12874 time. */
12875
12876 skip = FALSE;
12877 relocate = FALSE;
12878
12879 out_off = _bfd_elf_section_offset (output_bfd, info,
12880 input_section, rel->r_offset);
12881 if (out_off == (bfd_vma) -1)
12882 skip = TRUE;
12883 else if (out_off == (bfd_vma) -2)
12884 skip = TRUE, relocate = TRUE;
12885 out_off += (input_section->output_section->vma
12886 + input_section->output_offset);
12887 outrel.r_offset = out_off;
12888 outrel.r_addend = rel->r_addend;
12889
12890 /* Optimize unaligned reloc use. */
12891 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
12892 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
12893 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
12894 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
12895 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
12896 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
12897 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
12898 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
12899 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
12900
12901 if (skip)
12902 memset (&outrel, 0, sizeof outrel);
12903 else if (!SYMBOL_CALLS_LOCAL (info, &h->elf)
12904 && !is_opd
12905 && r_type != R_PPC64_TOC)
12906 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
12907 else
12908 {
12909 /* This symbol is local, or marked to become local,
12910 or this is an opd section reloc which must point
12911 at a local function. */
12912 outrel.r_addend += relocation;
12913 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
12914 {
12915 if (is_opd && h != NULL)
12916 {
12917 /* Lie about opd entries. This case occurs
12918 when building shared libraries and we
12919 reference a function in another shared
12920 lib. The same thing happens for a weak
12921 definition in an application that's
12922 overridden by a strong definition in a
12923 shared lib. (I believe this is a generic
12924 bug in binutils handling of weak syms.)
12925 In these cases we won't use the opd
12926 entry in this lib. */
12927 unresolved_reloc = FALSE;
12928 }
12929 if (!is_opd
12930 && r_type == R_PPC64_ADDR64
12931 && (h != NULL
12932 ? h->elf.type == STT_GNU_IFUNC
12933 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
12934 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
12935 else
12936 {
12937 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
12938
12939 /* We need to relocate .opd contents for ld.so.
12940 Prelink also wants simple and consistent rules
12941 for relocs. This make all RELATIVE relocs have
12942 *r_offset equal to r_addend. */
12943 relocate = TRUE;
12944 }
12945 }
12946 else
12947 {
12948 long indx = 0;
12949
12950 if (h != NULL
12951 ? h->elf.type == STT_GNU_IFUNC
12952 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
12953 {
12954 (*_bfd_error_handler)
12955 (_("%B(%A+0x%lx): relocation %s for indirect "
12956 "function %s unsupported"),
12957 input_bfd,
12958 input_section,
12959 (long) rel->r_offset,
12960 ppc64_elf_howto_table[r_type]->name,
12961 sym_name);
12962 ret = FALSE;
12963 }
12964 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
12965 ;
12966 else if (sec == NULL || sec->owner == NULL)
12967 {
12968 bfd_set_error (bfd_error_bad_value);
12969 return FALSE;
12970 }
12971 else
12972 {
12973 asection *osec;
12974
12975 osec = sec->output_section;
12976 indx = elf_section_data (osec)->dynindx;
12977
12978 if (indx == 0)
12979 {
12980 if ((osec->flags & SEC_READONLY) == 0
12981 && htab->elf.data_index_section != NULL)
12982 osec = htab->elf.data_index_section;
12983 else
12984 osec = htab->elf.text_index_section;
12985 indx = elf_section_data (osec)->dynindx;
12986 }
12987 BFD_ASSERT (indx != 0);
12988
12989 /* We are turning this relocation into one
12990 against a section symbol, so subtract out
12991 the output section's address but not the
12992 offset of the input section in the output
12993 section. */
12994 outrel.r_addend -= osec->vma;
12995 }
12996
12997 outrel.r_info = ELF64_R_INFO (indx, r_type);
12998 }
12999 }
13000
13001 sreloc = elf_section_data (input_section)->sreloc;
13002 if (!htab->elf.dynamic_sections_created)
13003 sreloc = htab->reliplt;
13004 if (sreloc == NULL)
13005 abort ();
13006
13007 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
13008 >= sreloc->size)
13009 abort ();
13010 loc = sreloc->contents;
13011 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
13012 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
13013
13014 /* If this reloc is against an external symbol, it will
13015 be computed at runtime, so there's no need to do
13016 anything now. However, for the sake of prelink ensure
13017 that the section contents are a known value. */
13018 if (! relocate)
13019 {
13020 unresolved_reloc = FALSE;
13021 /* The value chosen here is quite arbitrary as ld.so
13022 ignores section contents except for the special
13023 case of .opd where the contents might be accessed
13024 before relocation. Choose zero, as that won't
13025 cause reloc overflow. */
13026 relocation = 0;
13027 addend = 0;
13028 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
13029 to improve backward compatibility with older
13030 versions of ld. */
13031 if (r_type == R_PPC64_ADDR64)
13032 addend = outrel.r_addend;
13033 /* Adjust pc_relative relocs to have zero in *r_offset. */
13034 else if (ppc64_elf_howto_table[r_type]->pc_relative)
13035 addend = (input_section->output_section->vma
13036 + input_section->output_offset
13037 + rel->r_offset);
13038 }
13039 }
13040 break;
13041
13042 case R_PPC64_COPY:
13043 case R_PPC64_GLOB_DAT:
13044 case R_PPC64_JMP_SLOT:
13045 case R_PPC64_JMP_IREL:
13046 case R_PPC64_RELATIVE:
13047 /* We shouldn't ever see these dynamic relocs in relocatable
13048 files. */
13049 /* Fall through. */
13050
13051 case R_PPC64_PLTGOT16:
13052 case R_PPC64_PLTGOT16_DS:
13053 case R_PPC64_PLTGOT16_HA:
13054 case R_PPC64_PLTGOT16_HI:
13055 case R_PPC64_PLTGOT16_LO:
13056 case R_PPC64_PLTGOT16_LO_DS:
13057 case R_PPC64_PLTREL32:
13058 case R_PPC64_PLTREL64:
13059 /* These ones haven't been implemented yet. */
13060
13061 (*_bfd_error_handler)
13062 (_("%B: relocation %s is not supported for symbol %s."),
13063 input_bfd,
13064 ppc64_elf_howto_table[r_type]->name, sym_name);
13065
13066 bfd_set_error (bfd_error_invalid_operation);
13067 ret = FALSE;
13068 continue;
13069 }
13070
13071 /* Multi-instruction sequences that access the TOC can be
13072 optimized, eg. addis ra,r2,0; addi rb,ra,x;
13073 to nop; addi rb,r2,x; */
13074 switch (r_type)
13075 {
13076 default:
13077 break;
13078
13079 case R_PPC64_GOT_TLSLD16_HI:
13080 case R_PPC64_GOT_TLSGD16_HI:
13081 case R_PPC64_GOT_TPREL16_HI:
13082 case R_PPC64_GOT_DTPREL16_HI:
13083 case R_PPC64_GOT16_HI:
13084 case R_PPC64_TOC16_HI:
13085 /* These relocs would only be useful if building up an
13086 offset to later add to r2, perhaps in an indexed
13087 addressing mode instruction. Don't try to optimize.
13088 Unfortunately, the possibility of someone building up an
13089 offset like this or even with the HA relocs, means that
13090 we need to check the high insn when optimizing the low
13091 insn. */
13092 break;
13093
13094 case R_PPC64_GOT_TLSLD16_HA:
13095 case R_PPC64_GOT_TLSGD16_HA:
13096 case R_PPC64_GOT_TPREL16_HA:
13097 case R_PPC64_GOT_DTPREL16_HA:
13098 case R_PPC64_GOT16_HA:
13099 case R_PPC64_TOC16_HA:
13100 /* nop is done later. */
13101 break;
13102
13103 case R_PPC64_GOT_TLSLD16_LO:
13104 case R_PPC64_GOT_TLSGD16_LO:
13105 case R_PPC64_GOT_TPREL16_LO_DS:
13106 case R_PPC64_GOT_DTPREL16_LO_DS:
13107 case R_PPC64_GOT16_LO:
13108 case R_PPC64_GOT16_LO_DS:
13109 case R_PPC64_TOC16_LO:
13110 case R_PPC64_TOC16_LO_DS:
13111 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000)
13112 {
13113 bfd_byte *p = contents + (rel->r_offset & ~3);
13114 insn = bfd_get_32 (input_bfd, p);
13115 if ((insn & (0x3f << 26)) == 14u << 26 /* addi */
13116 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
13117 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
13118 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
13119 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
13120 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
13121 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
13122 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
13123 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
13124 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
13125 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
13126 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
13127 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
13128 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
13129 || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
13130 && (insn & 3) != 1)
13131 || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
13132 && ((insn & 3) == 0 || (insn & 3) == 3)))
13133 {
13134 unsigned int reg = (insn >> 16) & 0x1f;
13135 const Elf_Internal_Rela *ha;
13136 bfd_boolean match_addend;
13137
13138 match_addend = (sym != NULL
13139 && ELF_ST_TYPE (sym->st_info) == STT_SECTION);
13140 ha = ha_reloc_match (relocs, rel, &reg, match_addend,
13141 input_bfd, contents);
13142 if (ha != NULL)
13143 {
13144 insn &= ~(0x1f << 16);
13145 insn |= reg << 16;
13146 bfd_put_32 (input_bfd, insn, p);
13147 if (ha_opt == NULL)
13148 {
13149 ha_opt = bfd_zmalloc (input_section->reloc_count);
13150 if (ha_opt == NULL)
13151 return FALSE;
13152 }
13153 ha_opt[ha - relocs] = 1;
13154 }
13155 else
13156 /* If we don't find a matching high part insn,
13157 something is fishy. Refuse to nop any high
13158 part insn in this section. */
13159 no_ha_opt = TRUE;
13160 }
13161 }
13162 break;
13163 }
13164
13165 /* Do any further special processing. */
13166 switch (r_type)
13167 {
13168 default:
13169 break;
13170
13171 case R_PPC64_ADDR16_HA:
13172 case R_PPC64_REL16_HA:
13173 case R_PPC64_ADDR16_HIGHERA:
13174 case R_PPC64_ADDR16_HIGHESTA:
13175 case R_PPC64_TOC16_HA:
13176 case R_PPC64_SECTOFF_HA:
13177 case R_PPC64_TPREL16_HA:
13178 case R_PPC64_DTPREL16_HA:
13179 case R_PPC64_TPREL16_HIGHER:
13180 case R_PPC64_TPREL16_HIGHERA:
13181 case R_PPC64_TPREL16_HIGHEST:
13182 case R_PPC64_TPREL16_HIGHESTA:
13183 case R_PPC64_DTPREL16_HIGHER:
13184 case R_PPC64_DTPREL16_HIGHERA:
13185 case R_PPC64_DTPREL16_HIGHEST:
13186 case R_PPC64_DTPREL16_HIGHESTA:
13187 /* It's just possible that this symbol is a weak symbol
13188 that's not actually defined anywhere. In that case,
13189 'sec' would be NULL, and we should leave the symbol
13190 alone (it will be set to zero elsewhere in the link). */
13191 if (sec == NULL)
13192 break;
13193 /* Fall thru */
13194
13195 case R_PPC64_GOT16_HA:
13196 case R_PPC64_PLTGOT16_HA:
13197 case R_PPC64_PLT16_HA:
13198 case R_PPC64_GOT_TLSGD16_HA:
13199 case R_PPC64_GOT_TLSLD16_HA:
13200 case R_PPC64_GOT_TPREL16_HA:
13201 case R_PPC64_GOT_DTPREL16_HA:
13202 /* Add 0x10000 if sign bit in 0:15 is set.
13203 Bits 0:15 are not used. */
13204 addend += 0x8000;
13205 break;
13206
13207 case R_PPC64_ADDR16_DS:
13208 case R_PPC64_ADDR16_LO_DS:
13209 case R_PPC64_GOT16_DS:
13210 case R_PPC64_GOT16_LO_DS:
13211 case R_PPC64_PLT16_LO_DS:
13212 case R_PPC64_SECTOFF_DS:
13213 case R_PPC64_SECTOFF_LO_DS:
13214 case R_PPC64_TOC16_DS:
13215 case R_PPC64_TOC16_LO_DS:
13216 case R_PPC64_PLTGOT16_DS:
13217 case R_PPC64_PLTGOT16_LO_DS:
13218 case R_PPC64_GOT_TPREL16_DS:
13219 case R_PPC64_GOT_TPREL16_LO_DS:
13220 case R_PPC64_GOT_DTPREL16_DS:
13221 case R_PPC64_GOT_DTPREL16_LO_DS:
13222 case R_PPC64_TPREL16_DS:
13223 case R_PPC64_TPREL16_LO_DS:
13224 case R_PPC64_DTPREL16_DS:
13225 case R_PPC64_DTPREL16_LO_DS:
13226 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
13227 mask = 3;
13228 /* If this reloc is against an lq insn, then the value must be
13229 a multiple of 16. This is somewhat of a hack, but the
13230 "correct" way to do this by defining _DQ forms of all the
13231 _DS relocs bloats all reloc switches in this file. It
13232 doesn't seem to make much sense to use any of these relocs
13233 in data, so testing the insn should be safe. */
13234 if ((insn & (0x3f << 26)) == (56u << 26))
13235 mask = 15;
13236 if (((relocation + addend) & mask) != 0)
13237 {
13238 (*_bfd_error_handler)
13239 (_("%B(%A+0x%lx): error: %s not a multiple of %u"),
13240 input_bfd, input_section, (long) rel->r_offset,
13241 ppc64_elf_howto_table[r_type]->name,
13242 mask + 1);
13243 bfd_set_error (bfd_error_bad_value);
13244 ret = FALSE;
13245 continue;
13246 }
13247 break;
13248 }
13249
13250 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
13251 because such sections are not SEC_ALLOC and thus ld.so will
13252 not process them. */
13253 if (unresolved_reloc
13254 && !((input_section->flags & SEC_DEBUGGING) != 0
13255 && h->elf.def_dynamic))
13256 {
13257 (*_bfd_error_handler)
13258 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
13259 input_bfd,
13260 input_section,
13261 (long) rel->r_offset,
13262 ppc64_elf_howto_table[(int) r_type]->name,
13263 h->elf.root.root.string);
13264 ret = FALSE;
13265 }
13266
13267 r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
13268 input_bfd,
13269 input_section,
13270 contents,
13271 rel->r_offset,
13272 relocation,
13273 addend);
13274
13275 if (r != bfd_reloc_ok)
13276 {
13277 if (sym_name == NULL)
13278 sym_name = "(null)";
13279 if (r == bfd_reloc_overflow)
13280 {
13281 if (warned)
13282 continue;
13283 if (h != NULL
13284 && h->elf.root.type == bfd_link_hash_undefweak
13285 && ppc64_elf_howto_table[r_type]->pc_relative)
13286 {
13287 /* Assume this is a call protected by other code that
13288 detects the symbol is undefined. If this is the case,
13289 we can safely ignore the overflow. If not, the
13290 program is hosed anyway, and a little warning isn't
13291 going to help. */
13292
13293 continue;
13294 }
13295
13296 if (!((*info->callbacks->reloc_overflow)
13297 (info, (h ? &h->elf.root : NULL), sym_name,
13298 ppc64_elf_howto_table[r_type]->name,
13299 orig_addend, input_bfd, input_section, rel->r_offset)))
13300 return FALSE;
13301 }
13302 else
13303 {
13304 (*_bfd_error_handler)
13305 (_("%B(%A+0x%lx): %s reloc against `%s': error %d"),
13306 input_bfd,
13307 input_section,
13308 (long) rel->r_offset,
13309 ppc64_elf_howto_table[r_type]->name,
13310 sym_name,
13311 (int) r);
13312 ret = FALSE;
13313 }
13314 }
13315 }
13316
13317 if (ha_opt != NULL)
13318 {
13319 if (!no_ha_opt)
13320 {
13321 unsigned char *opt = ha_opt;
13322 rel = relocs;
13323 relend = relocs + input_section->reloc_count;
13324 for (; rel < relend; opt++, rel++)
13325 if (*opt != 0)
13326 {
13327 bfd_byte *p = contents + (rel->r_offset & ~3);
13328 bfd_put_32 (input_bfd, NOP, p);
13329 }
13330 }
13331 free (ha_opt);
13332 }
13333
13334 /* If we're emitting relocations, then shortly after this function
13335 returns, reloc offsets and addends for this section will be
13336 adjusted. Worse, reloc symbol indices will be for the output
13337 file rather than the input. Save a copy of the relocs for
13338 opd_entry_value. */
13339 if (is_opd && (info->emitrelocations || info->relocatable))
13340 {
13341 bfd_size_type amt;
13342 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
13343 rel = bfd_alloc (input_bfd, amt);
13344 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd_relocs == NULL);
13345 ppc64_elf_tdata (input_bfd)->opd_relocs = rel;
13346 if (rel == NULL)
13347 return FALSE;
13348 memcpy (rel, relocs, amt);
13349 }
13350 return ret;
13351 }
13352
13353 /* Adjust the value of any local symbols in opd sections. */
13354
13355 static int
13356 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
13357 const char *name ATTRIBUTE_UNUSED,
13358 Elf_Internal_Sym *elfsym,
13359 asection *input_sec,
13360 struct elf_link_hash_entry *h)
13361 {
13362 struct _opd_sec_data *opd;
13363 long adjust;
13364 bfd_vma value;
13365
13366 if (h != NULL)
13367 return 1;
13368
13369 opd = get_opd_info (input_sec);
13370 if (opd == NULL || opd->adjust == NULL)
13371 return 1;
13372
13373 value = elfsym->st_value - input_sec->output_offset;
13374 if (!info->relocatable)
13375 value -= input_sec->output_section->vma;
13376
13377 adjust = opd->adjust[value / 8];
13378 if (adjust == -1)
13379 return 2;
13380
13381 elfsym->st_value += adjust;
13382 return 1;
13383 }
13384
13385 /* Finish up dynamic symbol handling. We set the contents of various
13386 dynamic sections here. */
13387
13388 static bfd_boolean
13389 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
13390 struct bfd_link_info *info,
13391 struct elf_link_hash_entry *h,
13392 Elf_Internal_Sym *sym)
13393 {
13394 struct ppc_link_hash_table *htab;
13395 struct plt_entry *ent;
13396 Elf_Internal_Rela rela;
13397 bfd_byte *loc;
13398
13399 htab = ppc_hash_table (info);
13400 if (htab == NULL)
13401 return FALSE;
13402
13403 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13404 if (ent->plt.offset != (bfd_vma) -1)
13405 {
13406 /* This symbol has an entry in the procedure linkage
13407 table. Set it up. */
13408 if (!htab->elf.dynamic_sections_created
13409 || h->dynindx == -1)
13410 {
13411 BFD_ASSERT (h->type == STT_GNU_IFUNC
13412 && h->def_regular
13413 && (h->root.type == bfd_link_hash_defined
13414 || h->root.type == bfd_link_hash_defweak));
13415 rela.r_offset = (htab->iplt->output_section->vma
13416 + htab->iplt->output_offset
13417 + ent->plt.offset);
13418 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
13419 rela.r_addend = (h->root.u.def.value
13420 + h->root.u.def.section->output_offset
13421 + h->root.u.def.section->output_section->vma
13422 + ent->addend);
13423 loc = (htab->reliplt->contents
13424 + (htab->reliplt->reloc_count++
13425 * sizeof (Elf64_External_Rela)));
13426 }
13427 else
13428 {
13429 rela.r_offset = (htab->plt->output_section->vma
13430 + htab->plt->output_offset
13431 + ent->plt.offset);
13432 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
13433 rela.r_addend = ent->addend;
13434 loc = (htab->relplt->contents
13435 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE)
13436 / (PLT_ENTRY_SIZE / sizeof (Elf64_External_Rela))));
13437 }
13438 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
13439 }
13440
13441 if (h->needs_copy)
13442 {
13443 /* This symbol needs a copy reloc. Set it up. */
13444
13445 if (h->dynindx == -1
13446 || (h->root.type != bfd_link_hash_defined
13447 && h->root.type != bfd_link_hash_defweak)
13448 || htab->relbss == NULL)
13449 abort ();
13450
13451 rela.r_offset = (h->root.u.def.value
13452 + h->root.u.def.section->output_section->vma
13453 + h->root.u.def.section->output_offset);
13454 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
13455 rela.r_addend = 0;
13456 loc = htab->relbss->contents;
13457 loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
13458 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
13459 }
13460
13461 /* Mark some specially defined symbols as absolute. */
13462 if (strcmp (h->root.root.string, "_DYNAMIC") == 0)
13463 sym->st_shndx = SHN_ABS;
13464
13465 return TRUE;
13466 }
13467
13468 /* Used to decide how to sort relocs in an optimal manner for the
13469 dynamic linker, before writing them out. */
13470
13471 static enum elf_reloc_type_class
13472 ppc64_elf_reloc_type_class (const Elf_Internal_Rela *rela)
13473 {
13474 enum elf_ppc64_reloc_type r_type;
13475
13476 r_type = ELF64_R_TYPE (rela->r_info);
13477 switch (r_type)
13478 {
13479 case R_PPC64_RELATIVE:
13480 return reloc_class_relative;
13481 case R_PPC64_JMP_SLOT:
13482 return reloc_class_plt;
13483 case R_PPC64_COPY:
13484 return reloc_class_copy;
13485 default:
13486 return reloc_class_normal;
13487 }
13488 }
13489
13490 /* Finish up the dynamic sections. */
13491
13492 static bfd_boolean
13493 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
13494 struct bfd_link_info *info)
13495 {
13496 struct ppc_link_hash_table *htab;
13497 bfd *dynobj;
13498 asection *sdyn;
13499
13500 htab = ppc_hash_table (info);
13501 if (htab == NULL)
13502 return FALSE;
13503
13504 dynobj = htab->elf.dynobj;
13505 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
13506
13507 if (htab->elf.dynamic_sections_created)
13508 {
13509 Elf64_External_Dyn *dyncon, *dynconend;
13510
13511 if (sdyn == NULL || htab->got == NULL)
13512 abort ();
13513
13514 dyncon = (Elf64_External_Dyn *) sdyn->contents;
13515 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
13516 for (; dyncon < dynconend; dyncon++)
13517 {
13518 Elf_Internal_Dyn dyn;
13519 asection *s;
13520
13521 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
13522
13523 switch (dyn.d_tag)
13524 {
13525 default:
13526 continue;
13527
13528 case DT_PPC64_GLINK:
13529 s = htab->glink;
13530 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
13531 /* We stupidly defined DT_PPC64_GLINK to be the start
13532 of glink rather than the first entry point, which is
13533 what ld.so needs, and now have a bigger stub to
13534 support automatic multiple TOCs. */
13535 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 32;
13536 break;
13537
13538 case DT_PPC64_OPD:
13539 s = bfd_get_section_by_name (output_bfd, ".opd");
13540 if (s == NULL)
13541 continue;
13542 dyn.d_un.d_ptr = s->vma;
13543 break;
13544
13545 case DT_PPC64_OPDSZ:
13546 s = bfd_get_section_by_name (output_bfd, ".opd");
13547 if (s == NULL)
13548 continue;
13549 dyn.d_un.d_val = s->size;
13550 break;
13551
13552 case DT_PLTGOT:
13553 s = htab->plt;
13554 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
13555 break;
13556
13557 case DT_JMPREL:
13558 s = htab->relplt;
13559 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
13560 break;
13561
13562 case DT_PLTRELSZ:
13563 dyn.d_un.d_val = htab->relplt->size;
13564 break;
13565
13566 case DT_RELASZ:
13567 /* Don't count procedure linkage table relocs in the
13568 overall reloc count. */
13569 s = htab->relplt;
13570 if (s == NULL)
13571 continue;
13572 dyn.d_un.d_val -= s->size;
13573 break;
13574
13575 case DT_RELA:
13576 /* We may not be using the standard ELF linker script.
13577 If .rela.plt is the first .rela section, we adjust
13578 DT_RELA to not include it. */
13579 s = htab->relplt;
13580 if (s == NULL)
13581 continue;
13582 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
13583 continue;
13584 dyn.d_un.d_ptr += s->size;
13585 break;
13586 }
13587
13588 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
13589 }
13590 }
13591
13592 if (htab->got != NULL && htab->got->size != 0)
13593 {
13594 /* Fill in the first entry in the global offset table.
13595 We use it to hold the link-time TOCbase. */
13596 bfd_put_64 (output_bfd,
13597 elf_gp (output_bfd) + TOC_BASE_OFF,
13598 htab->got->contents);
13599
13600 /* Set .got entry size. */
13601 elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 8;
13602 }
13603
13604 if (htab->plt != NULL && htab->plt->size != 0)
13605 {
13606 /* Set .plt entry size. */
13607 elf_section_data (htab->plt->output_section)->this_hdr.sh_entsize
13608 = PLT_ENTRY_SIZE;
13609 }
13610
13611 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
13612 brlt ourselves if emitrelocations. */
13613 if (htab->brlt != NULL
13614 && htab->brlt->reloc_count != 0
13615 && !_bfd_elf_link_output_relocs (output_bfd,
13616 htab->brlt,
13617 elf_section_data (htab->brlt)->rela.hdr,
13618 elf_section_data (htab->brlt)->relocs,
13619 NULL))
13620 return FALSE;
13621
13622 if (htab->glink != NULL
13623 && htab->glink->reloc_count != 0
13624 && !_bfd_elf_link_output_relocs (output_bfd,
13625 htab->glink,
13626 elf_section_data (htab->glink)->rela.hdr,
13627 elf_section_data (htab->glink)->relocs,
13628 NULL))
13629 return FALSE;
13630
13631 /* We need to handle writing out multiple GOT sections ourselves,
13632 since we didn't add them to DYNOBJ. We know dynobj is the first
13633 bfd. */
13634 while ((dynobj = dynobj->link_next) != NULL)
13635 {
13636 asection *s;
13637
13638 if (!is_ppc64_elf (dynobj))
13639 continue;
13640
13641 s = ppc64_elf_tdata (dynobj)->got;
13642 if (s != NULL
13643 && s->size != 0
13644 && s->output_section != bfd_abs_section_ptr
13645 && !bfd_set_section_contents (output_bfd, s->output_section,
13646 s->contents, s->output_offset,
13647 s->size))
13648 return FALSE;
13649 s = ppc64_elf_tdata (dynobj)->relgot;
13650 if (s != NULL
13651 && s->size != 0
13652 && s->output_section != bfd_abs_section_ptr
13653 && !bfd_set_section_contents (output_bfd, s->output_section,
13654 s->contents, s->output_offset,
13655 s->size))
13656 return FALSE;
13657 }
13658
13659 return TRUE;
13660 }
13661
13662 #include "elf64-target.h"
GDB Binutils - Deliverables
This page took 0.382549 seconds and 3 git commands to generate.