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