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