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