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