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