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