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