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