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