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