projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
*** empty log message ***
[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 bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
9735
9736 /* Initialize howto table if needed. */
9737 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9738 ppc_howto_init ();
9739
9740 htab = ppc_hash_table (info);
9741
9742 /* Don't relocate stub sections. */
9743 if (input_section->owner == htab->stub_bfd)
9744 return TRUE;
9745
9746 local_got_ents = elf_local_got_ents (input_bfd);
9747 TOCstart = elf_gp (output_bfd);
9748 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
9749 sym_hashes = elf_sym_hashes (input_bfd);
9750 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
9751
9752 rel = relocs;
9753 relend = relocs + input_section->reloc_count;
9754 for (; rel < relend; rel++)
9755 {
9756 enum elf_ppc64_reloc_type r_type;
9757 bfd_vma addend, orig_addend;
9758 bfd_reloc_status_type r;
9759 Elf_Internal_Sym *sym;
9760 asection *sec;
9761 struct elf_link_hash_entry *h_elf;
9762 struct ppc_link_hash_entry *h;
9763 struct ppc_link_hash_entry *fdh;
9764 const char *sym_name;
9765 unsigned long r_symndx, toc_symndx;
9766 char tls_mask, tls_gd, tls_type;
9767 char sym_type;
9768 bfd_vma relocation;
9769 bfd_boolean unresolved_reloc;
9770 bfd_boolean warned;
9771 unsigned long insn, mask;
9772 struct ppc_stub_hash_entry *stub_entry;
9773 bfd_vma max_br_offset;
9774 bfd_vma from;
9775
9776 r_type = ELF64_R_TYPE (rel->r_info);
9777 r_symndx = ELF64_R_SYM (rel->r_info);
9778
9779 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
9780 symbol of the previous ADDR64 reloc. The symbol gives us the
9781 proper TOC base to use. */
9782 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
9783 && rel != relocs
9784 && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
9785 && is_opd)
9786 r_symndx = ELF64_R_SYM (rel[-1].r_info);
9787
9788 sym = NULL;
9789 sec = NULL;
9790 h_elf = NULL;
9791 sym_name = NULL;
9792 unresolved_reloc = FALSE;
9793 warned = FALSE;
9794 orig_addend = rel->r_addend;
9795
9796 if (r_symndx < symtab_hdr->sh_info)
9797 {
9798 /* It's a local symbol. */
9799 long *opd_adjust;
9800
9801 sym = local_syms + r_symndx;
9802 sec = local_sections[r_symndx];
9803 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
9804 sym_type = ELF64_ST_TYPE (sym->st_info);
9805 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
9806 opd_adjust = get_opd_info (sec);
9807 if (opd_adjust != NULL)
9808 {
9809 long adjust = opd_adjust[(sym->st_value + rel->r_addend) / 8];
9810 if (adjust == -1)
9811 relocation = 0;
9812 else
9813 {
9814 /* If this is a relocation against the opd section sym
9815 and we have edited .opd, adjust the reloc addend so
9816 that ld -r and ld --emit-relocs output is correct.
9817 If it is a reloc against some other .opd symbol,
9818 then the symbol value will be adjusted later. */
9819 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
9820 rel->r_addend += adjust;
9821 else
9822 relocation += adjust;
9823 }
9824 }
9825 if (info->relocatable)
9826 continue;
9827 }
9828 else
9829 {
9830 if (info->relocatable)
9831 continue;
9832 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
9833 r_symndx, symtab_hdr, sym_hashes,
9834 h_elf, sec, relocation,
9835 unresolved_reloc, warned);
9836 sym_name = h_elf->root.root.string;
9837 sym_type = h_elf->type;
9838 }
9839 h = (struct ppc_link_hash_entry *) h_elf;
9840
9841 /* TLS optimizations. Replace instruction sequences and relocs
9842 based on information we collected in tls_optimize. We edit
9843 RELOCS so that --emit-relocs will output something sensible
9844 for the final instruction stream. */
9845 tls_mask = 0;
9846 tls_gd = 0;
9847 toc_symndx = 0;
9848 if (IS_PPC64_TLS_RELOC (r_type))
9849 {
9850 if (h != NULL)
9851 tls_mask = h->tls_mask;
9852 else if (local_got_ents != NULL)
9853 {
9854 char *lgot_masks;
9855 lgot_masks = (char *) (local_got_ents + symtab_hdr->sh_info);
9856 tls_mask = lgot_masks[r_symndx];
9857 }
9858 if (tls_mask == 0 && r_type == R_PPC64_TLS)
9859 {
9860 /* Check for toc tls entries. */
9861 char *toc_tls;
9862
9863 if (!get_tls_mask (&toc_tls, &toc_symndx, &local_syms,
9864 rel, input_bfd))
9865 return FALSE;
9866
9867 if (toc_tls)
9868 tls_mask = *toc_tls;
9869 }
9870 }
9871
9872 /* Check that tls relocs are used with tls syms, and non-tls
9873 relocs are used with non-tls syms. */
9874 if (r_symndx != 0
9875 && r_type != R_PPC64_NONE
9876 && (h == NULL
9877 || h->elf.root.type == bfd_link_hash_defined
9878 || h->elf.root.type == bfd_link_hash_defweak)
9879 && IS_PPC64_TLS_RELOC (r_type) != (sym_type == STT_TLS))
9880 {
9881 if (r_type == R_PPC64_TLS && tls_mask != 0)
9882 /* R_PPC64_TLS is OK against a symbol in the TOC. */
9883 ;
9884 else
9885 (*_bfd_error_handler)
9886 (sym_type == STT_TLS
9887 ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
9888 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s"),
9889 input_bfd,
9890 input_section,
9891 (long) rel->r_offset,
9892 ppc64_elf_howto_table[r_type]->name,
9893 sym_name);
9894 }
9895
9896 /* Ensure reloc mapping code below stays sane. */
9897 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
9898 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
9899 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
9900 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
9901 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
9902 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
9903 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
9904 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
9905 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
9906 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
9907 abort ();
9908
9909 switch (r_type)
9910 {
9911 default:
9912 break;
9913
9914 case R_PPC64_TOC16:
9915 case R_PPC64_TOC16_LO:
9916 case R_PPC64_TOC16_DS:
9917 case R_PPC64_TOC16_LO_DS:
9918 {
9919 /* Check for toc tls entries. */
9920 char *toc_tls;
9921 int retval;
9922
9923 retval = get_tls_mask (&toc_tls, &toc_symndx, &local_syms,
9924 rel, input_bfd);
9925 if (retval == 0)
9926 return FALSE;
9927
9928 if (toc_tls)
9929 {
9930 tls_mask = *toc_tls;
9931 if (r_type == R_PPC64_TOC16_DS
9932 || r_type == R_PPC64_TOC16_LO_DS)
9933 {
9934 if (tls_mask != 0
9935 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
9936 goto toctprel;
9937 }
9938 else
9939 {
9940 /* If we found a GD reloc pair, then we might be
9941 doing a GD->IE transition. */
9942 if (retval == 2)
9943 {
9944 tls_gd = TLS_TPRELGD;
9945 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
9946 goto tls_get_addr_check;
9947 }
9948 else if (retval == 3)
9949 {
9950 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
9951 goto tls_get_addr_check;
9952 }
9953 }
9954 }
9955 }
9956 break;
9957
9958 case R_PPC64_GOT_TPREL16_DS:
9959 case R_PPC64_GOT_TPREL16_LO_DS:
9960 if (tls_mask != 0
9961 && (tls_mask & TLS_TPREL) == 0)
9962 {
9963 toctprel:
9964 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
9965 insn &= 31 << 21;
9966 insn |= 0x3c0d0000; /* addis 0,13,0 */
9967 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
9968 r_type = R_PPC64_TPREL16_HA;
9969 if (toc_symndx != 0)
9970 {
9971 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
9972 /* We changed the symbol. Start over in order to
9973 get h, sym, sec etc. right. */
9974 rel--;
9975 continue;
9976 }
9977 else
9978 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
9979 }
9980 break;
9981
9982 case R_PPC64_TLS:
9983 if (tls_mask != 0
9984 && (tls_mask & TLS_TPREL) == 0)
9985 {
9986 bfd_vma rtra;
9987 insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
9988 if ((insn & ((0x3f << 26) | (31 << 11)))
9989 == ((31 << 26) | (13 << 11)))
9990 rtra = insn & ((1 << 26) - (1 << 16));
9991 else if ((insn & ((0x3f << 26) | (31 << 16)))
9992 == ((31 << 26) | (13 << 16)))
9993 rtra = (insn & (31 << 21)) | ((insn & (31 << 11)) << 5);
9994 else
9995 abort ();
9996 if ((insn & ((1 << 11) - (1 << 1))) == 266 << 1)
9997 /* add -> addi. */
9998 insn = 14 << 26;
9999 else if ((insn & (31 << 1)) == 23 << 1
10000 && ((insn & (31 << 6)) < 14 << 6
10001 || ((insn & (31 << 6)) >= 16 << 6
10002 && (insn & (31 << 6)) < 24 << 6)))
10003 /* load and store indexed -> dform. */
10004 insn = (32 | ((insn >> 6) & 31)) << 26;
10005 else if ((insn & (31 << 1)) == 21 << 1
10006 && (insn & (0x1a << 6)) == 0)
10007 /* ldx, ldux, stdx, stdux -> ld, ldu, std, stdu. */
10008 insn = (((58 | ((insn >> 6) & 4)) << 26)
10009 | ((insn >> 6) & 1));
10010 else if ((insn & (31 << 1)) == 21 << 1
10011 && (insn & ((1 << 11) - (1 << 1))) == 341 << 1)
10012 /* lwax -> lwa. */
10013 insn = (58 << 26) | 2;
10014 else
10015 abort ();
10016 insn |= rtra;
10017 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
10018 /* Was PPC64_TLS which sits on insn boundary, now
10019 PPC64_TPREL16_LO which is at low-order half-word. */
10020 rel->r_offset += d_offset;
10021 r_type = R_PPC64_TPREL16_LO;
10022 if (toc_symndx != 0)
10023 {
10024 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
10025 /* We changed the symbol. Start over in order to
10026 get h, sym, sec etc. right. */
10027 rel--;
10028 continue;
10029 }
10030 else
10031 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10032 }
10033 break;
10034
10035 case R_PPC64_GOT_TLSGD16_HI:
10036 case R_PPC64_GOT_TLSGD16_HA:
10037 tls_gd = TLS_TPRELGD;
10038 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
10039 goto tls_gdld_hi;
10040 break;
10041
10042 case R_PPC64_GOT_TLSLD16_HI:
10043 case R_PPC64_GOT_TLSLD16_HA:
10044 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
10045 {
10046 tls_gdld_hi:
10047 if ((tls_mask & tls_gd) != 0)
10048 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
10049 + R_PPC64_GOT_TPREL16_DS);
10050 else
10051 {
10052 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
10053 rel->r_offset -= d_offset;
10054 r_type = R_PPC64_NONE;
10055 }
10056 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10057 }
10058 break;
10059
10060 case R_PPC64_GOT_TLSGD16:
10061 case R_PPC64_GOT_TLSGD16_LO:
10062 tls_gd = TLS_TPRELGD;
10063 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
10064 goto tls_get_addr_check;
10065 break;
10066
10067 case R_PPC64_GOT_TLSLD16:
10068 case R_PPC64_GOT_TLSLD16_LO:
10069 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
10070 {
10071 tls_get_addr_check:
10072 if (rel + 1 < relend)
10073 {
10074 enum elf_ppc64_reloc_type r_type2;
10075 unsigned long r_symndx2;
10076 struct elf_link_hash_entry *h2;
10077 bfd_vma insn1, insn2, insn3;
10078 bfd_vma offset;
10079
10080 /* The next instruction should be a call to
10081 __tls_get_addr. Peek at the reloc to be sure. */
10082 r_type2 = ELF64_R_TYPE (rel[1].r_info);
10083 r_symndx2 = ELF64_R_SYM (rel[1].r_info);
10084 if (r_symndx2 < symtab_hdr->sh_info
10085 || (r_type2 != R_PPC64_REL14
10086 && r_type2 != R_PPC64_REL14_BRTAKEN
10087 && r_type2 != R_PPC64_REL14_BRNTAKEN
10088 && r_type2 != R_PPC64_REL24))
10089 break;
10090
10091 h2 = sym_hashes[r_symndx2 - symtab_hdr->sh_info];
10092 while (h2->root.type == bfd_link_hash_indirect
10093 || h2->root.type == bfd_link_hash_warning)
10094 h2 = (struct elf_link_hash_entry *) h2->root.u.i.link;
10095 if (h2 == NULL || (h2 != &htab->tls_get_addr->elf
10096 && h2 != &htab->tls_get_addr_fd->elf))
10097 break;
10098
10099 /* OK, it checks out. Replace the call. */
10100 offset = rel[1].r_offset;
10101 insn1 = bfd_get_32 (output_bfd,
10102 contents + rel->r_offset - d_offset);
10103 insn3 = bfd_get_32 (output_bfd,
10104 contents + offset + 4);
10105 if ((tls_mask & tls_gd) != 0)
10106 {
10107 /* IE */
10108 insn1 &= (1 << 26) - (1 << 2);
10109 insn1 |= 58 << 26; /* ld */
10110 insn2 = 0x7c636a14; /* add 3,3,13 */
10111 rel[1].r_info = ELF64_R_INFO (r_symndx2, R_PPC64_NONE);
10112 if ((tls_mask & TLS_EXPLICIT) == 0)
10113 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
10114 + R_PPC64_GOT_TPREL16_DS);
10115 else
10116 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
10117 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10118 }
10119 else
10120 {
10121 /* LE */
10122 insn1 = 0x3c6d0000; /* addis 3,13,0 */
10123 insn2 = 0x38630000; /* addi 3,3,0 */
10124 if (tls_gd == 0)
10125 {
10126 /* Was an LD reloc. */
10127 r_symndx = 0;
10128 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
10129 rel[1].r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
10130 }
10131 else if (toc_symndx != 0)
10132 r_symndx = toc_symndx;
10133 r_type = R_PPC64_TPREL16_HA;
10134 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10135 rel[1].r_info = ELF64_R_INFO (r_symndx,
10136 R_PPC64_TPREL16_LO);
10137 rel[1].r_offset += d_offset;
10138 }
10139 if (insn3 == NOP
10140 || insn3 == CROR_151515 || insn3 == CROR_313131)
10141 {
10142 insn3 = insn2;
10143 insn2 = NOP;
10144 rel[1].r_offset += 4;
10145 }
10146 bfd_put_32 (output_bfd, insn1, contents + rel->r_offset - d_offset);
10147 bfd_put_32 (output_bfd, insn2, contents + offset);
10148 bfd_put_32 (output_bfd, insn3, contents + offset + 4);
10149 if (tls_gd == 0 || toc_symndx != 0)
10150 {
10151 /* We changed the symbol. Start over in order
10152 to get h, sym, sec etc. right. */
10153 rel--;
10154 continue;
10155 }
10156 }
10157 }
10158 break;
10159
10160 case R_PPC64_DTPMOD64:
10161 if (rel + 1 < relend
10162 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
10163 && rel[1].r_offset == rel->r_offset + 8)
10164 {
10165 if ((tls_mask & TLS_GD) == 0)
10166 {
10167 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
10168 if ((tls_mask & TLS_TPRELGD) != 0)
10169 r_type = R_PPC64_TPREL64;
10170 else
10171 {
10172 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
10173 r_type = R_PPC64_NONE;
10174 }
10175 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10176 }
10177 }
10178 else
10179 {
10180 if ((tls_mask & TLS_LD) == 0)
10181 {
10182 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
10183 r_type = R_PPC64_NONE;
10184 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10185 }
10186 }
10187 break;
10188
10189 case R_PPC64_TPREL64:
10190 if ((tls_mask & TLS_TPREL) == 0)
10191 {
10192 r_type = R_PPC64_NONE;
10193 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10194 }
10195 break;
10196 }
10197
10198 /* Handle other relocations that tweak non-addend part of insn. */
10199 insn = 0;
10200 max_br_offset = 1 << 25;
10201 addend = rel->r_addend;
10202 switch (r_type)
10203 {
10204 default:
10205 break;
10206
10207 /* Branch taken prediction relocations. */
10208 case R_PPC64_ADDR14_BRTAKEN:
10209 case R_PPC64_REL14_BRTAKEN:
10210 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
10211 /* Fall thru. */
10212
10213 /* Branch not taken prediction relocations. */
10214 case R_PPC64_ADDR14_BRNTAKEN:
10215 case R_PPC64_REL14_BRNTAKEN:
10216 insn |= bfd_get_32 (output_bfd,
10217 contents + rel->r_offset) & ~(0x01 << 21);
10218 /* Fall thru. */
10219
10220 case R_PPC64_REL14:
10221 max_br_offset = 1 << 15;
10222 /* Fall thru. */
10223
10224 case R_PPC64_REL24:
10225 /* Calls to functions with a different TOC, such as calls to
10226 shared objects, need to alter the TOC pointer. This is
10227 done using a linkage stub. A REL24 branching to these
10228 linkage stubs needs to be followed by a nop, as the nop
10229 will be replaced with an instruction to restore the TOC
10230 base pointer. */
10231 stub_entry = NULL;
10232 fdh = h;
10233 if (((h != NULL
10234 && (((fdh = h->oh) != NULL
10235 && fdh->elf.plt.plist != NULL)
10236 || (fdh = h)->elf.plt.plist != NULL))
10237 || (sec != NULL
10238 && sec->output_section != NULL
10239 && sec->id <= htab->top_id
10240 && (htab->stub_group[sec->id].toc_off
10241 != htab->stub_group[input_section->id].toc_off)))
10242 && (stub_entry = ppc_get_stub_entry (input_section, sec, fdh,
10243 rel, htab)) != NULL
10244 && (stub_entry->stub_type == ppc_stub_plt_call
10245 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
10246 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
10247 {
10248 bfd_boolean can_plt_call = FALSE;
10249
10250 if (rel->r_offset + 8 <= input_section->size)
10251 {
10252 unsigned long nop;
10253 nop = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
10254 if (nop == NOP
10255 || nop == CROR_151515 || nop == CROR_313131)
10256 {
10257 bfd_put_32 (input_bfd, LD_R2_40R1,
10258 contents + rel->r_offset + 4);
10259 can_plt_call = TRUE;
10260 }
10261 }
10262
10263 if (!can_plt_call)
10264 {
10265 if (stub_entry->stub_type == ppc_stub_plt_call)
10266 {
10267 /* If this is a plain branch rather than a branch
10268 and link, don't require a nop. However, don't
10269 allow tail calls in a shared library as they
10270 will result in r2 being corrupted. */
10271 unsigned long br;
10272 br = bfd_get_32 (input_bfd, contents + rel->r_offset);
10273 if (info->executable && (br & 1) == 0)
10274 can_plt_call = TRUE;
10275 else
10276 stub_entry = NULL;
10277 }
10278 else if (h != NULL
10279 && strcmp (h->elf.root.root.string,
10280 ".__libc_start_main") == 0)
10281 {
10282 /* Allow crt1 branch to go via a toc adjusting stub. */
10283 can_plt_call = TRUE;
10284 }
10285 else
10286 {
10287 if (strcmp (input_section->output_section->name,
10288 ".init") == 0
10289 || strcmp (input_section->output_section->name,
10290 ".fini") == 0)
10291 (*_bfd_error_handler)
10292 (_("%B(%A+0x%lx): automatic multiple TOCs "
10293 "not supported using your crt files; "
10294 "recompile with -mminimal-toc or upgrade gcc"),
10295 input_bfd,
10296 input_section,
10297 (long) rel->r_offset);
10298 else
10299 (*_bfd_error_handler)
10300 (_("%B(%A+0x%lx): sibling call optimization to `%s' "
10301 "does not allow automatic multiple TOCs; "
10302 "recompile with -mminimal-toc or "
10303 "-fno-optimize-sibling-calls, "
10304 "or make `%s' extern"),
10305 input_bfd,
10306 input_section,
10307 (long) rel->r_offset,
10308 sym_name,
10309 sym_name);
10310 bfd_set_error (bfd_error_bad_value);
10311 ret = FALSE;
10312 }
10313 }
10314
10315 if (can_plt_call
10316 && stub_entry->stub_type == ppc_stub_plt_call)
10317 unresolved_reloc = FALSE;
10318 }
10319
10320 if (stub_entry == NULL
10321 && get_opd_info (sec) != NULL)
10322 {
10323 /* The branch destination is the value of the opd entry. */
10324 bfd_vma off = (relocation + addend
10325 - sec->output_section->vma
10326 - sec->output_offset);
10327 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL);
10328 if (dest != (bfd_vma) -1)
10329 {
10330 relocation = dest;
10331 addend = 0;
10332 }
10333 }
10334
10335 /* If the branch is out of reach we ought to have a long
10336 branch stub. */
10337 from = (rel->r_offset
10338 + input_section->output_offset
10339 + input_section->output_section->vma);
10340
10341 if (stub_entry == NULL
10342 && (relocation + addend - from + max_br_offset
10343 >= 2 * max_br_offset)
10344 && r_type != R_PPC64_ADDR14_BRTAKEN
10345 && r_type != R_PPC64_ADDR14_BRNTAKEN)
10346 stub_entry = ppc_get_stub_entry (input_section, sec, h, rel,
10347 htab);
10348
10349 if (stub_entry != NULL)
10350 {
10351 /* Munge up the value and addend so that we call the stub
10352 rather than the procedure directly. */
10353 relocation = (stub_entry->stub_offset
10354 + stub_entry->stub_sec->output_offset
10355 + stub_entry->stub_sec->output_section->vma);
10356 addend = 0;
10357 }
10358
10359 if (insn != 0)
10360 {
10361 if (is_power4)
10362 {
10363 /* Set 'a' bit. This is 0b00010 in BO field for branch
10364 on CR(BI) insns (BO == 001at or 011at), and 0b01000
10365 for branch on CTR insns (BO == 1a00t or 1a01t). */
10366 if ((insn & (0x14 << 21)) == (0x04 << 21))
10367 insn |= 0x02 << 21;
10368 else if ((insn & (0x14 << 21)) == (0x10 << 21))
10369 insn |= 0x08 << 21;
10370 else
10371 break;
10372 }
10373 else
10374 {
10375 /* Invert 'y' bit if not the default. */
10376 if ((bfd_signed_vma) (relocation + addend - from) < 0)
10377 insn ^= 0x01 << 21;
10378 }
10379
10380 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
10381 }
10382
10383 /* NOP out calls to undefined weak functions.
10384 We can thus call a weak function without first
10385 checking whether the function is defined. */
10386 else if (h != NULL
10387 && h->elf.root.type == bfd_link_hash_undefweak
10388 && r_type == R_PPC64_REL24
10389 && relocation == 0
10390 && addend == 0)
10391 {
10392 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
10393 continue;
10394 }
10395 break;
10396 }
10397
10398 /* Set `addend'. */
10399 tls_type = 0;
10400 switch (r_type)
10401 {
10402 default:
10403 (*_bfd_error_handler)
10404 (_("%B: unknown relocation type %d for symbol %s"),
10405 input_bfd, (int) r_type, sym_name);
10406
10407 bfd_set_error (bfd_error_bad_value);
10408 ret = FALSE;
10409 continue;
10410
10411 case R_PPC64_NONE:
10412 case R_PPC64_TLS:
10413 case R_PPC64_GNU_VTINHERIT:
10414 case R_PPC64_GNU_VTENTRY:
10415 continue;
10416
10417 /* GOT16 relocations. Like an ADDR16 using the symbol's
10418 address in the GOT as relocation value instead of the
10419 symbol's value itself. Also, create a GOT entry for the
10420 symbol and put the symbol value there. */
10421 case R_PPC64_GOT_TLSGD16:
10422 case R_PPC64_GOT_TLSGD16_LO:
10423 case R_PPC64_GOT_TLSGD16_HI:
10424 case R_PPC64_GOT_TLSGD16_HA:
10425 tls_type = TLS_TLS | TLS_GD;
10426 goto dogot;
10427
10428 case R_PPC64_GOT_TLSLD16:
10429 case R_PPC64_GOT_TLSLD16_LO:
10430 case R_PPC64_GOT_TLSLD16_HI:
10431 case R_PPC64_GOT_TLSLD16_HA:
10432 tls_type = TLS_TLS | TLS_LD;
10433 goto dogot;
10434
10435 case R_PPC64_GOT_TPREL16_DS:
10436 case R_PPC64_GOT_TPREL16_LO_DS:
10437 case R_PPC64_GOT_TPREL16_HI:
10438 case R_PPC64_GOT_TPREL16_HA:
10439 tls_type = TLS_TLS | TLS_TPREL;
10440 goto dogot;
10441
10442 case R_PPC64_GOT_DTPREL16_DS:
10443 case R_PPC64_GOT_DTPREL16_LO_DS:
10444 case R_PPC64_GOT_DTPREL16_HI:
10445 case R_PPC64_GOT_DTPREL16_HA:
10446 tls_type = TLS_TLS | TLS_DTPREL;
10447 goto dogot;
10448
10449 case R_PPC64_GOT16:
10450 case R_PPC64_GOT16_LO:
10451 case R_PPC64_GOT16_HI:
10452 case R_PPC64_GOT16_HA:
10453 case R_PPC64_GOT16_DS:
10454 case R_PPC64_GOT16_LO_DS:
10455 dogot:
10456 {
10457 /* Relocation is to the entry for this symbol in the global
10458 offset table. */
10459 asection *got;
10460 bfd_vma *offp;
10461 bfd_vma off;
10462 unsigned long indx = 0;
10463
10464 if (tls_type == (TLS_TLS | TLS_LD)
10465 && (h == NULL
10466 || !h->elf.def_dynamic))
10467 offp = &ppc64_tlsld_got (input_bfd)->offset;
10468 else
10469 {
10470 struct got_entry *ent;
10471
10472 if (h != NULL)
10473 {
10474 bfd_boolean dyn = htab->elf.dynamic_sections_created;
10475 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
10476 &h->elf)
10477 || (info->shared
10478 && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
10479 /* This is actually a static link, or it is a
10480 -Bsymbolic link and the symbol is defined
10481 locally, or the symbol was forced to be local
10482 because of a version file. */
10483 ;
10484 else
10485 {
10486 indx = h->elf.dynindx;
10487 unresolved_reloc = FALSE;
10488 }
10489 ent = h->elf.got.glist;
10490 }
10491 else
10492 {
10493 if (local_got_ents == NULL)
10494 abort ();
10495 ent = local_got_ents[r_symndx];
10496 }
10497
10498 for (; ent != NULL; ent = ent->next)
10499 if (ent->addend == orig_addend
10500 && ent->owner == input_bfd
10501 && ent->tls_type == tls_type)
10502 break;
10503 if (ent == NULL)
10504 abort ();
10505 offp = &ent->got.offset;
10506 }
10507
10508 got = ppc64_elf_tdata (input_bfd)->got;
10509 if (got == NULL)
10510 abort ();
10511
10512 /* The offset must always be a multiple of 8. We use the
10513 least significant bit to record whether we have already
10514 processed this entry. */
10515 off = *offp;
10516 if ((off & 1) != 0)
10517 off &= ~1;
10518 else
10519 {
10520 /* Generate relocs for the dynamic linker, except in
10521 the case of TLSLD where we'll use one entry per
10522 module. */
10523 asection *relgot = ppc64_elf_tdata (input_bfd)->relgot;
10524
10525 *offp = off | 1;
10526 if ((info->shared || indx != 0)
10527 && (h == NULL
10528 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
10529 || h->elf.root.type != bfd_link_hash_undefweak))
10530 {
10531 outrel.r_offset = (got->output_section->vma
10532 + got->output_offset
10533 + off);
10534 outrel.r_addend = addend;
10535 if (tls_type & (TLS_LD | TLS_GD))
10536 {
10537 outrel.r_addend = 0;
10538 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
10539 if (tls_type == (TLS_TLS | TLS_GD))
10540 {
10541 loc = relgot->contents;
10542 loc += (relgot->reloc_count++
10543 * sizeof (Elf64_External_Rela));
10544 bfd_elf64_swap_reloca_out (output_bfd,
10545 &outrel, loc);
10546 outrel.r_offset += 8;
10547 outrel.r_addend = addend;
10548 outrel.r_info
10549 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
10550 }
10551 }
10552 else if (tls_type == (TLS_TLS | TLS_DTPREL))
10553 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
10554 else if (tls_type == (TLS_TLS | TLS_TPREL))
10555 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
10556 else if (indx == 0)
10557 {
10558 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_RELATIVE);
10559
10560 /* Write the .got section contents for the sake
10561 of prelink. */
10562 loc = got->contents + off;
10563 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
10564 loc);
10565 }
10566 else
10567 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
10568
10569 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
10570 {
10571 outrel.r_addend += relocation;
10572 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
10573 outrel.r_addend -= htab->elf.tls_sec->vma;
10574 }
10575 loc = relgot->contents;
10576 loc += (relgot->reloc_count++
10577 * sizeof (Elf64_External_Rela));
10578 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
10579 }
10580
10581 /* Init the .got section contents here if we're not
10582 emitting a reloc. */
10583 else
10584 {
10585 relocation += addend;
10586 if (tls_type == (TLS_TLS | TLS_LD))
10587 relocation = 1;
10588 else if (tls_type != 0)
10589 {
10590 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
10591 if (tls_type == (TLS_TLS | TLS_TPREL))
10592 relocation += DTP_OFFSET - TP_OFFSET;
10593
10594 if (tls_type == (TLS_TLS | TLS_GD))
10595 {
10596 bfd_put_64 (output_bfd, relocation,
10597 got->contents + off + 8);
10598 relocation = 1;
10599 }
10600 }
10601
10602 bfd_put_64 (output_bfd, relocation,
10603 got->contents + off);
10604 }
10605 }
10606
10607 if (off >= (bfd_vma) -2)
10608 abort ();
10609
10610 relocation = got->output_offset + off;
10611
10612 /* TOC base (r2) is TOC start plus 0x8000. */
10613 addend = -TOC_BASE_OFF;
10614 }
10615 break;
10616
10617 case R_PPC64_PLT16_HA:
10618 case R_PPC64_PLT16_HI:
10619 case R_PPC64_PLT16_LO:
10620 case R_PPC64_PLT32:
10621 case R_PPC64_PLT64:
10622 /* Relocation is to the entry for this symbol in the
10623 procedure linkage table. */
10624
10625 /* Resolve a PLT reloc against a local symbol directly,
10626 without using the procedure linkage table. */
10627 if (h == NULL)
10628 break;
10629
10630 /* It's possible that we didn't make a PLT entry for this
10631 symbol. This happens when statically linking PIC code,
10632 or when using -Bsymbolic. Go find a match if there is a
10633 PLT entry. */
10634 if (htab->plt != NULL)
10635 {
10636 struct plt_entry *ent;
10637 for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
10638 if (ent->addend == orig_addend
10639 && ent->plt.offset != (bfd_vma) -1)
10640 {
10641 relocation = (htab->plt->output_section->vma
10642 + htab->plt->output_offset
10643 + ent->plt.offset);
10644 unresolved_reloc = FALSE;
10645 }
10646 }
10647 break;
10648
10649 case R_PPC64_TOC:
10650 /* Relocation value is TOC base. */
10651 relocation = TOCstart;
10652 if (r_symndx == 0)
10653 relocation += htab->stub_group[input_section->id].toc_off;
10654 else if (unresolved_reloc)
10655 ;
10656 else if (sec != NULL && sec->id <= htab->top_id)
10657 relocation += htab->stub_group[sec->id].toc_off;
10658 else
10659 unresolved_reloc = TRUE;
10660 goto dodyn2;
10661
10662 /* TOC16 relocs. We want the offset relative to the TOC base,
10663 which is the address of the start of the TOC plus 0x8000.
10664 The TOC consists of sections .got, .toc, .tocbss, and .plt,
10665 in this order. */
10666 case R_PPC64_TOC16:
10667 case R_PPC64_TOC16_LO:
10668 case R_PPC64_TOC16_HI:
10669 case R_PPC64_TOC16_DS:
10670 case R_PPC64_TOC16_LO_DS:
10671 case R_PPC64_TOC16_HA:
10672 addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
10673 break;
10674
10675 /* Relocate against the beginning of the section. */
10676 case R_PPC64_SECTOFF:
10677 case R_PPC64_SECTOFF_LO:
10678 case R_PPC64_SECTOFF_HI:
10679 case R_PPC64_SECTOFF_DS:
10680 case R_PPC64_SECTOFF_LO_DS:
10681 case R_PPC64_SECTOFF_HA:
10682 if (sec != NULL)
10683 addend -= sec->output_section->vma;
10684 break;
10685
10686 case R_PPC64_REL14:
10687 case R_PPC64_REL14_BRNTAKEN:
10688 case R_PPC64_REL14_BRTAKEN:
10689 case R_PPC64_REL24:
10690 break;
10691
10692 case R_PPC64_TPREL16:
10693 case R_PPC64_TPREL16_LO:
10694 case R_PPC64_TPREL16_HI:
10695 case R_PPC64_TPREL16_HA:
10696 case R_PPC64_TPREL16_DS:
10697 case R_PPC64_TPREL16_LO_DS:
10698 case R_PPC64_TPREL16_HIGHER:
10699 case R_PPC64_TPREL16_HIGHERA:
10700 case R_PPC64_TPREL16_HIGHEST:
10701 case R_PPC64_TPREL16_HIGHESTA:
10702 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
10703 if (info->shared)
10704 /* The TPREL16 relocs shouldn't really be used in shared
10705 libs as they will result in DT_TEXTREL being set, but
10706 support them anyway. */
10707 goto dodyn;
10708 break;
10709
10710 case R_PPC64_DTPREL16:
10711 case R_PPC64_DTPREL16_LO:
10712 case R_PPC64_DTPREL16_HI:
10713 case R_PPC64_DTPREL16_HA:
10714 case R_PPC64_DTPREL16_DS:
10715 case R_PPC64_DTPREL16_LO_DS:
10716 case R_PPC64_DTPREL16_HIGHER:
10717 case R_PPC64_DTPREL16_HIGHERA:
10718 case R_PPC64_DTPREL16_HIGHEST:
10719 case R_PPC64_DTPREL16_HIGHESTA:
10720 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
10721 break;
10722
10723 case R_PPC64_DTPMOD64:
10724 relocation = 1;
10725 addend = 0;
10726 goto dodyn;
10727
10728 case R_PPC64_TPREL64:
10729 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
10730 goto dodyn;
10731
10732 case R_PPC64_DTPREL64:
10733 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
10734 /* Fall thru */
10735
10736 /* Relocations that may need to be propagated if this is a
10737 dynamic object. */
10738 case R_PPC64_REL30:
10739 case R_PPC64_REL32:
10740 case R_PPC64_REL64:
10741 case R_PPC64_ADDR14:
10742 case R_PPC64_ADDR14_BRNTAKEN:
10743 case R_PPC64_ADDR14_BRTAKEN:
10744 case R_PPC64_ADDR16:
10745 case R_PPC64_ADDR16_DS:
10746 case R_PPC64_ADDR16_HA:
10747 case R_PPC64_ADDR16_HI:
10748 case R_PPC64_ADDR16_HIGHER:
10749 case R_PPC64_ADDR16_HIGHERA:
10750 case R_PPC64_ADDR16_HIGHEST:
10751 case R_PPC64_ADDR16_HIGHESTA:
10752 case R_PPC64_ADDR16_LO:
10753 case R_PPC64_ADDR16_LO_DS:
10754 case R_PPC64_ADDR24:
10755 case R_PPC64_ADDR32:
10756 case R_PPC64_ADDR64:
10757 case R_PPC64_UADDR16:
10758 case R_PPC64_UADDR32:
10759 case R_PPC64_UADDR64:
10760 /* r_symndx will be zero only for relocs against symbols
10761 from removed linkonce sections, or sections discarded by
10762 a linker script. */
10763 dodyn:
10764 if (r_symndx == 0)
10765 {
10766 _bfd_clear_contents (ppc64_elf_howto_table[r_type], input_bfd,
10767 contents + rel->r_offset);
10768 break;
10769 }
10770 /* Fall thru. */
10771
10772 dodyn2:
10773 if ((input_section->flags & SEC_ALLOC) == 0)
10774 break;
10775
10776 if (NO_OPD_RELOCS && is_opd)
10777 break;
10778
10779 if ((info->shared
10780 && (h == NULL
10781 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
10782 || h->elf.root.type != bfd_link_hash_undefweak)
10783 && (MUST_BE_DYN_RELOC (r_type)
10784 || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
10785 || (ELIMINATE_COPY_RELOCS
10786 && !info->shared
10787 && h != NULL
10788 && h->elf.dynindx != -1
10789 && !h->elf.non_got_ref
10790 && h->elf.def_dynamic
10791 && !h->elf.def_regular))
10792 {
10793 Elf_Internal_Rela outrel;
10794 bfd_boolean skip, relocate;
10795 asection *sreloc;
10796 bfd_byte *loc;
10797 bfd_vma out_off;
10798
10799 /* When generating a dynamic object, these relocations
10800 are copied into the output file to be resolved at run
10801 time. */
10802
10803 skip = FALSE;
10804 relocate = FALSE;
10805
10806 out_off = _bfd_elf_section_offset (output_bfd, info,
10807 input_section, rel->r_offset);
10808 if (out_off == (bfd_vma) -1)
10809 skip = TRUE;
10810 else if (out_off == (bfd_vma) -2)
10811 skip = TRUE, relocate = TRUE;
10812 out_off += (input_section->output_section->vma
10813 + input_section->output_offset);
10814 outrel.r_offset = out_off;
10815 outrel.r_addend = rel->r_addend;
10816
10817 /* Optimize unaligned reloc use. */
10818 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
10819 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
10820 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
10821 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
10822 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
10823 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
10824 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
10825 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
10826 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
10827
10828 if (skip)
10829 memset (&outrel, 0, sizeof outrel);
10830 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
10831 && !is_opd
10832 && r_type != R_PPC64_TOC)
10833 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
10834 else
10835 {
10836 /* This symbol is local, or marked to become local,
10837 or this is an opd section reloc which must point
10838 at a local function. */
10839 outrel.r_addend += relocation;
10840 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
10841 {
10842 if (is_opd && h != NULL)
10843 {
10844 /* Lie about opd entries. This case occurs
10845 when building shared libraries and we
10846 reference a function in another shared
10847 lib. The same thing happens for a weak
10848 definition in an application that's
10849 overridden by a strong definition in a
10850 shared lib. (I believe this is a generic
10851 bug in binutils handling of weak syms.)
10852 In these cases we won't use the opd
10853 entry in this lib. */
10854 unresolved_reloc = FALSE;
10855 }
10856 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10857
10858 /* We need to relocate .opd contents for ld.so.
10859 Prelink also wants simple and consistent rules
10860 for relocs. This make all RELATIVE relocs have
10861 *r_offset equal to r_addend. */
10862 relocate = TRUE;
10863 }
10864 else
10865 {
10866 long indx = 0;
10867
10868 if (bfd_is_abs_section (sec))
10869 ;
10870 else if (sec == NULL || sec->owner == NULL)
10871 {
10872 bfd_set_error (bfd_error_bad_value);
10873 return FALSE;
10874 }
10875 else
10876 {
10877 asection *osec;
10878
10879 osec = sec->output_section;
10880 indx = elf_section_data (osec)->dynindx;
10881
10882 if (indx == 0)
10883 {
10884 if ((osec->flags & SEC_READONLY) == 0
10885 && htab->elf.data_index_section != NULL)
10886 osec = htab->elf.data_index_section;
10887 else
10888 osec = htab->elf.text_index_section;
10889 indx = elf_section_data (osec)->dynindx;
10890 }
10891 BFD_ASSERT (indx != 0);
10892
10893 /* We are turning this relocation into one
10894 against a section symbol, so subtract out
10895 the output section's address but not the
10896 offset of the input section in the output
10897 section. */
10898 outrel.r_addend -= osec->vma;
10899 }
10900
10901 outrel.r_info = ELF64_R_INFO (indx, r_type);
10902 }
10903 }
10904
10905 sreloc = elf_section_data (input_section)->sreloc;
10906 if (sreloc == NULL)
10907 abort ();
10908
10909 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
10910 >= sreloc->size)
10911 abort ();
10912 loc = sreloc->contents;
10913 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
10914 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
10915
10916 /* If this reloc is against an external symbol, it will
10917 be computed at runtime, so there's no need to do
10918 anything now. However, for the sake of prelink ensure
10919 that the section contents are a known value. */
10920 if (! relocate)
10921 {
10922 unresolved_reloc = FALSE;
10923 /* The value chosen here is quite arbitrary as ld.so
10924 ignores section contents except for the special
10925 case of .opd where the contents might be accessed
10926 before relocation. Choose zero, as that won't
10927 cause reloc overflow. */
10928 relocation = 0;
10929 addend = 0;
10930 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
10931 to improve backward compatibility with older
10932 versions of ld. */
10933 if (r_type == R_PPC64_ADDR64)
10934 addend = outrel.r_addend;
10935 /* Adjust pc_relative relocs to have zero in *r_offset. */
10936 else if (ppc64_elf_howto_table[r_type]->pc_relative)
10937 addend = (input_section->output_section->vma
10938 + input_section->output_offset
10939 + rel->r_offset);
10940 }
10941 }
10942 break;
10943
10944 case R_PPC64_COPY:
10945 case R_PPC64_GLOB_DAT:
10946 case R_PPC64_JMP_SLOT:
10947 case R_PPC64_RELATIVE:
10948 /* We shouldn't ever see these dynamic relocs in relocatable
10949 files. */
10950 /* Fall through. */
10951
10952 case R_PPC64_PLTGOT16:
10953 case R_PPC64_PLTGOT16_DS:
10954 case R_PPC64_PLTGOT16_HA:
10955 case R_PPC64_PLTGOT16_HI:
10956 case R_PPC64_PLTGOT16_LO:
10957 case R_PPC64_PLTGOT16_LO_DS:
10958 case R_PPC64_PLTREL32:
10959 case R_PPC64_PLTREL64:
10960 /* These ones haven't been implemented yet. */
10961
10962 (*_bfd_error_handler)
10963 (_("%B: relocation %s is not supported for symbol %s."),
10964 input_bfd,
10965 ppc64_elf_howto_table[r_type]->name, sym_name);
10966
10967 bfd_set_error (bfd_error_invalid_operation);
10968 ret = FALSE;
10969 continue;
10970 }
10971
10972 /* Do any further special processing. */
10973 switch (r_type)
10974 {
10975 default:
10976 break;
10977
10978 case R_PPC64_ADDR16_HA:
10979 case R_PPC64_ADDR16_HIGHERA:
10980 case R_PPC64_ADDR16_HIGHESTA:
10981 case R_PPC64_TOC16_HA:
10982 case R_PPC64_SECTOFF_HA:
10983 case R_PPC64_TPREL16_HA:
10984 case R_PPC64_DTPREL16_HA:
10985 case R_PPC64_TPREL16_HIGHER:
10986 case R_PPC64_TPREL16_HIGHERA:
10987 case R_PPC64_TPREL16_HIGHEST:
10988 case R_PPC64_TPREL16_HIGHESTA:
10989 case R_PPC64_DTPREL16_HIGHER:
10990 case R_PPC64_DTPREL16_HIGHERA:
10991 case R_PPC64_DTPREL16_HIGHEST:
10992 case R_PPC64_DTPREL16_HIGHESTA:
10993 /* It's just possible that this symbol is a weak symbol
10994 that's not actually defined anywhere. In that case,
10995 'sec' would be NULL, and we should leave the symbol
10996 alone (it will be set to zero elsewhere in the link). */
10997 if (sec == NULL)
10998 break;
10999 /* Fall thru */
11000
11001 case R_PPC64_GOT16_HA:
11002 case R_PPC64_PLTGOT16_HA:
11003 case R_PPC64_PLT16_HA:
11004 case R_PPC64_GOT_TLSGD16_HA:
11005 case R_PPC64_GOT_TLSLD16_HA:
11006 case R_PPC64_GOT_TPREL16_HA:
11007 case R_PPC64_GOT_DTPREL16_HA:
11008 /* Add 0x10000 if sign bit in 0:15 is set.
11009 Bits 0:15 are not used. */
11010 addend += 0x8000;
11011 break;
11012
11013 case R_PPC64_ADDR16_DS:
11014 case R_PPC64_ADDR16_LO_DS:
11015 case R_PPC64_GOT16_DS:
11016 case R_PPC64_GOT16_LO_DS:
11017 case R_PPC64_PLT16_LO_DS:
11018 case R_PPC64_SECTOFF_DS:
11019 case R_PPC64_SECTOFF_LO_DS:
11020 case R_PPC64_TOC16_DS:
11021 case R_PPC64_TOC16_LO_DS:
11022 case R_PPC64_PLTGOT16_DS:
11023 case R_PPC64_PLTGOT16_LO_DS:
11024 case R_PPC64_GOT_TPREL16_DS:
11025 case R_PPC64_GOT_TPREL16_LO_DS:
11026 case R_PPC64_GOT_DTPREL16_DS:
11027 case R_PPC64_GOT_DTPREL16_LO_DS:
11028 case R_PPC64_TPREL16_DS:
11029 case R_PPC64_TPREL16_LO_DS:
11030 case R_PPC64_DTPREL16_DS:
11031 case R_PPC64_DTPREL16_LO_DS:
11032 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
11033 mask = 3;
11034 /* If this reloc is against an lq insn, then the value must be
11035 a multiple of 16. This is somewhat of a hack, but the
11036 "correct" way to do this by defining _DQ forms of all the
11037 _DS relocs bloats all reloc switches in this file. It
11038 doesn't seem to make much sense to use any of these relocs
11039 in data, so testing the insn should be safe. */
11040 if ((insn & (0x3f << 26)) == (56u << 26))
11041 mask = 15;
11042 if (((relocation + addend) & mask) != 0)
11043 {
11044 (*_bfd_error_handler)
11045 (_("%B: error: relocation %s not a multiple of %d"),
11046 input_bfd,
11047 ppc64_elf_howto_table[r_type]->name,
11048 mask + 1);
11049 bfd_set_error (bfd_error_bad_value);
11050 ret = FALSE;
11051 continue;
11052 }
11053 break;
11054 }
11055
11056 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
11057 because such sections are not SEC_ALLOC and thus ld.so will
11058 not process them. */
11059 if (unresolved_reloc
11060 && !((input_section->flags & SEC_DEBUGGING) != 0
11061 && h->elf.def_dynamic))
11062 {
11063 (*_bfd_error_handler)
11064 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
11065 input_bfd,
11066 input_section,
11067 (long) rel->r_offset,
11068 ppc64_elf_howto_table[(int) r_type]->name,
11069 h->elf.root.root.string);
11070 ret = FALSE;
11071 }
11072
11073 r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
11074 input_bfd,
11075 input_section,
11076 contents,
11077 rel->r_offset,
11078 relocation,
11079 addend);
11080
11081 if (r != bfd_reloc_ok)
11082 {
11083 if (sym_name == NULL)
11084 sym_name = "(null)";
11085 if (r == bfd_reloc_overflow)
11086 {
11087 if (warned)
11088 continue;
11089 if (h != NULL
11090 && h->elf.root.type == bfd_link_hash_undefweak
11091 && ppc64_elf_howto_table[r_type]->pc_relative)
11092 {
11093 /* Assume this is a call protected by other code that
11094 detects the symbol is undefined. If this is the case,
11095 we can safely ignore the overflow. If not, the
11096 program is hosed anyway, and a little warning isn't
11097 going to help. */
11098
11099 continue;
11100 }
11101
11102 if (!((*info->callbacks->reloc_overflow)
11103 (info, (h ? &h->elf.root : NULL), sym_name,
11104 ppc64_elf_howto_table[r_type]->name,
11105 orig_addend, input_bfd, input_section, rel->r_offset)))
11106 return FALSE;
11107 }
11108 else
11109 {
11110 (*_bfd_error_handler)
11111 (_("%B(%A+0x%lx): %s reloc against `%s': error %d"),
11112 input_bfd,
11113 input_section,
11114 (long) rel->r_offset,
11115 ppc64_elf_howto_table[r_type]->name,
11116 sym_name,
11117 (int) r);
11118 ret = FALSE;
11119 }
11120 }
11121 }
11122
11123 /* If we're emitting relocations, then shortly after this function
11124 returns, reloc offsets and addends for this section will be
11125 adjusted. Worse, reloc symbol indices will be for the output
11126 file rather than the input. Save a copy of the relocs for
11127 opd_entry_value. */
11128 if (is_opd && (info->emitrelocations || info->relocatable))
11129 {
11130 bfd_size_type amt;
11131 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
11132 rel = bfd_alloc (input_bfd, amt);
11133 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd_relocs == NULL);
11134 ppc64_elf_tdata (input_bfd)->opd_relocs = rel;
11135 if (rel == NULL)
11136 return FALSE;
11137 memcpy (rel, relocs, amt);
11138 }
11139 return ret;
11140 }
11141
11142 /* Adjust the value of any local symbols in opd sections. */
11143
11144 static bfd_boolean
11145 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
11146 const char *name ATTRIBUTE_UNUSED,
11147 Elf_Internal_Sym *elfsym,
11148 asection *input_sec,
11149 struct elf_link_hash_entry *h)
11150 {
11151 long *opd_adjust, adjust;
11152 bfd_vma value;
11153
11154 if (h != NULL)
11155 return TRUE;
11156
11157 opd_adjust = get_opd_info (input_sec);
11158 if (opd_adjust == NULL)
11159 return TRUE;
11160
11161 value = elfsym->st_value - input_sec->output_offset;
11162 if (!info->relocatable)
11163 value -= input_sec->output_section->vma;
11164
11165 adjust = opd_adjust[value / 8];
11166 if (adjust == -1)
11167 elfsym->st_value = 0;
11168 else
11169 elfsym->st_value += adjust;
11170 return TRUE;
11171 }
11172
11173 /* Finish up dynamic symbol handling. We set the contents of various
11174 dynamic sections here. */
11175
11176 static bfd_boolean
11177 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
11178 struct bfd_link_info *info,
11179 struct elf_link_hash_entry *h,
11180 Elf_Internal_Sym *sym)
11181 {
11182 struct ppc_link_hash_table *htab;
11183 struct plt_entry *ent;
11184 Elf_Internal_Rela rela;
11185 bfd_byte *loc;
11186
11187 htab = ppc_hash_table (info);
11188
11189 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
11190 if (ent->plt.offset != (bfd_vma) -1)
11191 {
11192 /* This symbol has an entry in the procedure linkage
11193 table. Set it up. */
11194
11195 if (htab->plt == NULL
11196 || htab->relplt == NULL
11197 || htab->glink == NULL)
11198 abort ();
11199
11200 /* Create a JMP_SLOT reloc to inform the dynamic linker to
11201 fill in the PLT entry. */
11202 rela.r_offset = (htab->plt->output_section->vma
11203 + htab->plt->output_offset
11204 + ent->plt.offset);
11205 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
11206 rela.r_addend = ent->addend;
11207
11208 loc = htab->relplt->contents;
11209 loc += ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE
11210 * sizeof (Elf64_External_Rela));
11211 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
11212 }
11213
11214 if (h->needs_copy)
11215 {
11216 Elf_Internal_Rela rela;
11217 bfd_byte *loc;
11218
11219 /* This symbol needs a copy reloc. Set it up. */
11220
11221 if (h->dynindx == -1
11222 || (h->root.type != bfd_link_hash_defined
11223 && h->root.type != bfd_link_hash_defweak)
11224 || htab->relbss == NULL)
11225 abort ();
11226
11227 rela.r_offset = (h->root.u.def.value
11228 + h->root.u.def.section->output_section->vma
11229 + h->root.u.def.section->output_offset);
11230 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
11231 rela.r_addend = 0;
11232 loc = htab->relbss->contents;
11233 loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
11234 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
11235 }
11236
11237 /* Mark some specially defined symbols as absolute. */
11238 if (strcmp (h->root.root.string, "_DYNAMIC") == 0)
11239 sym->st_shndx = SHN_ABS;
11240
11241 return TRUE;
11242 }
11243
11244 /* Used to decide how to sort relocs in an optimal manner for the
11245 dynamic linker, before writing them out. */
11246
11247 static enum elf_reloc_type_class
11248 ppc64_elf_reloc_type_class (const Elf_Internal_Rela *rela)
11249 {
11250 enum elf_ppc64_reloc_type r_type;
11251
11252 r_type = ELF64_R_TYPE (rela->r_info);
11253 switch (r_type)
11254 {
11255 case R_PPC64_RELATIVE:
11256 return reloc_class_relative;
11257 case R_PPC64_JMP_SLOT:
11258 return reloc_class_plt;
11259 case R_PPC64_COPY:
11260 return reloc_class_copy;
11261 default:
11262 return reloc_class_normal;
11263 }
11264 }
11265
11266 /* Finish up the dynamic sections. */
11267
11268 static bfd_boolean
11269 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
11270 struct bfd_link_info *info)
11271 {
11272 struct ppc_link_hash_table *htab;
11273 bfd *dynobj;
11274 asection *sdyn;
11275
11276 htab = ppc_hash_table (info);
11277 dynobj = htab->elf.dynobj;
11278 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
11279
11280 if (htab->elf.dynamic_sections_created)
11281 {
11282 Elf64_External_Dyn *dyncon, *dynconend;
11283
11284 if (sdyn == NULL || htab->got == NULL)
11285 abort ();
11286
11287 dyncon = (Elf64_External_Dyn *) sdyn->contents;
11288 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
11289 for (; dyncon < dynconend; dyncon++)
11290 {
11291 Elf_Internal_Dyn dyn;
11292 asection *s;
11293
11294 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
11295
11296 switch (dyn.d_tag)
11297 {
11298 default:
11299 continue;
11300
11301 case DT_PPC64_GLINK:
11302 s = htab->glink;
11303 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
11304 /* We stupidly defined DT_PPC64_GLINK to be the start
11305 of glink rather than the first entry point, which is
11306 what ld.so needs, and now have a bigger stub to
11307 support automatic multiple TOCs. */
11308 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 32;
11309 break;
11310
11311 case DT_PPC64_OPD:
11312 s = bfd_get_section_by_name (output_bfd, ".opd");
11313 if (s == NULL)
11314 continue;
11315 dyn.d_un.d_ptr = s->vma;
11316 break;
11317
11318 case DT_PPC64_OPDSZ:
11319 s = bfd_get_section_by_name (output_bfd, ".opd");
11320 if (s == NULL)
11321 continue;
11322 dyn.d_un.d_val = s->size;
11323 break;
11324
11325 case DT_PLTGOT:
11326 s = htab->plt;
11327 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
11328 break;
11329
11330 case DT_JMPREL:
11331 s = htab->relplt;
11332 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
11333 break;
11334
11335 case DT_PLTRELSZ:
11336 dyn.d_un.d_val = htab->relplt->size;
11337 break;
11338
11339 case DT_RELASZ:
11340 /* Don't count procedure linkage table relocs in the
11341 overall reloc count. */
11342 s = htab->relplt;
11343 if (s == NULL)
11344 continue;
11345 dyn.d_un.d_val -= s->size;
11346 break;
11347
11348 case DT_RELA:
11349 /* We may not be using the standard ELF linker script.
11350 If .rela.plt is the first .rela section, we adjust
11351 DT_RELA to not include it. */
11352 s = htab->relplt;
11353 if (s == NULL)
11354 continue;
11355 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
11356 continue;
11357 dyn.d_un.d_ptr += s->size;
11358 break;
11359 }
11360
11361 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
11362 }
11363 }
11364
11365 if (htab->got != NULL && htab->got->size != 0)
11366 {
11367 /* Fill in the first entry in the global offset table.
11368 We use it to hold the link-time TOCbase. */
11369 bfd_put_64 (output_bfd,
11370 elf_gp (output_bfd) + TOC_BASE_OFF,
11371 htab->got->contents);
11372
11373 /* Set .got entry size. */
11374 elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 8;
11375 }
11376
11377 if (htab->plt != NULL && htab->plt->size != 0)
11378 {
11379 /* Set .plt entry size. */
11380 elf_section_data (htab->plt->output_section)->this_hdr.sh_entsize
11381 = PLT_ENTRY_SIZE;
11382 }
11383
11384 /* We need to handle writing out multiple GOT sections ourselves,
11385 since we didn't add them to DYNOBJ. We know dynobj is the first
11386 bfd. */
11387 while ((dynobj = dynobj->link_next) != NULL)
11388 {
11389 asection *s;
11390
11391 if (!is_ppc64_elf_target (dynobj->xvec))
11392 continue;
11393
11394 s = ppc64_elf_tdata (dynobj)->got;
11395 if (s != NULL
11396 && s->size != 0
11397 && s->output_section != bfd_abs_section_ptr
11398 && !bfd_set_section_contents (output_bfd, s->output_section,
11399 s->contents, s->output_offset,
11400 s->size))
11401 return FALSE;
11402 s = ppc64_elf_tdata (dynobj)->relgot;
11403 if (s != NULL
11404 && s->size != 0
11405 && s->output_section != bfd_abs_section_ptr
11406 && !bfd_set_section_contents (output_bfd, s->output_section,
11407 s->contents, s->output_offset,
11408 s->size))
11409 return FALSE;
11410 }
11411
11412 return TRUE;
11413 }
11414
11415 #include "elf64-target.h"
GDB Binutils - Deliverables
This page took 0.311425 seconds and 4 git commands to generate.