projects / deliverable / binutils-gdb.git / blob
? search:


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