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