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