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