projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Add s390 target
[deliverable/binutils-gdb.git] / bfd / elf32-ppc.c
1 /* PowerPC-specific support for 32-bit ELF
2 Copyright 1994, 95, 96, 97, 98, 1999 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 2 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 Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20
21 /* This file is based on a preliminary PowerPC ELF ABI. The
22 information may not match the final PowerPC ELF ABI. It includes
23 suggestions from the in-progress Embedded PowerPC ABI, and that
24 information may also not match. */
25
26 #include "bfd.h"
27 #include "sysdep.h"
28 #include "bfdlink.h"
29 #include "libbfd.h"
30 #include "elf-bfd.h"
31 #include "elf/ppc.h"
32
33 #define USE_RELA /* we want RELA relocations, not REL */
34
35 static reloc_howto_type *ppc_elf_reloc_type_lookup
36 PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
37 static void ppc_elf_info_to_howto
38 PARAMS ((bfd *abfd, arelent *cache_ptr, Elf32_Internal_Rela *dst));
39 static void ppc_elf_howto_init PARAMS ((void));
40 static bfd_reloc_status_type ppc_elf_addr16_ha_reloc
41 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
42 static boolean ppc_elf_set_private_flags PARAMS ((bfd *, flagword));
43 static boolean ppc_elf_copy_private_bfd_data PARAMS ((bfd *, bfd *));
44 static boolean ppc_elf_merge_private_bfd_data PARAMS ((bfd *, bfd *));
45
46 static int ppc_elf_additional_program_headers PARAMS ((bfd *));
47 static boolean ppc_elf_modify_segment_map PARAMS ((bfd *));
48
49 static boolean ppc_elf_create_dynamic_sections
50 PARAMS ((bfd *, struct bfd_link_info *));
51
52 static boolean ppc_elf_section_from_shdr PARAMS ((bfd *,
53 Elf32_Internal_Shdr *,
54 char *));
55 static boolean ppc_elf_fake_sections
56 PARAMS ((bfd *, Elf32_Internal_Shdr *, asection *));
57
58 static elf_linker_section_t *ppc_elf_create_linker_section
59 PARAMS ((bfd *abfd,
60 struct bfd_link_info *info,
61 enum elf_linker_section_enum));
62
63 static boolean ppc_elf_check_relocs PARAMS ((bfd *,
64 struct bfd_link_info *,
65 asection *,
66 const Elf_Internal_Rela *));
67
68 static asection * ppc_elf_gc_mark_hook PARAMS ((bfd *abfd,
69 struct bfd_link_info *info,
70 Elf_Internal_Rela *rel,
71 struct elf_link_hash_entry *h,
72 Elf_Internal_Sym *sym));
73
74 static boolean ppc_elf_gc_sweep_hook PARAMS ((bfd *abfd,
75 struct bfd_link_info *info,
76 asection *sec,
77 const Elf_Internal_Rela *relocs));
78
79 static boolean ppc_elf_adjust_dynamic_symbol PARAMS ((struct bfd_link_info *,
80 struct elf_link_hash_entry *));
81
82 static boolean ppc_elf_size_dynamic_sections PARAMS ((bfd *, struct bfd_link_info *));
83
84 static boolean ppc_elf_relocate_section PARAMS ((bfd *,
85 struct bfd_link_info *info,
86 bfd *,
87 asection *,
88 bfd_byte *,
89 Elf_Internal_Rela *relocs,
90 Elf_Internal_Sym *local_syms,
91 asection **));
92
93 static boolean ppc_elf_add_symbol_hook PARAMS ((bfd *,
94 struct bfd_link_info *,
95 const Elf_Internal_Sym *,
96 const char **,
97 flagword *,
98 asection **,
99 bfd_vma *));
100
101 static boolean ppc_elf_finish_dynamic_symbol PARAMS ((bfd *,
102 struct bfd_link_info *,
103 struct elf_link_hash_entry *,
104 Elf_Internal_Sym *));
105
106 static boolean ppc_elf_finish_dynamic_sections PARAMS ((bfd *, struct bfd_link_info *));
107
108 #define BRANCH_PREDICT_BIT 0x200000 /* branch prediction bit for branch taken relocs */
109 #define RA_REGISTER_MASK 0x001f0000 /* mask to set RA in memory instructions */
110 #define RA_REGISTER_SHIFT 16 /* value to shift register by to insert RA */
111
112 /* The name of the dynamic interpreter. This is put in the .interp
113 section. */
114
115 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
116
117 /* The size in bytes of an entry in the procedure linkage table. */
118 #define PLT_ENTRY_SIZE 12
119 /* The initial size of the plt reserved for the dynamic linker. */
120 #define PLT_INITIAL_ENTRY_SIZE 72
121 /* The size of the gap between entries in the PLT. */
122 #define PLT_SLOT_SIZE 8
123 /* The number of single-slot PLT entries (the rest use two slots). */
124 #define PLT_NUM_SINGLE_ENTRIES 8192
125
126 /* Will references to this symbol always reference the symbol
127 in this object? */
128 #define SYMBOL_REFERENCES_LOCAL(INFO, H) \
129 ((! INFO->shared \
130 || INFO->symbolic \
131 || H->dynindx == -1 \
132 || ELF_ST_VISIBILITY (H->other) == STV_INTERNAL \
133 || ELF_ST_VISIBILITY (H->other) == STV_HIDDEN) \
134 && (H->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
135
136 /* Will _calls_ to this symbol always call the version in this object? */
137 #define SYMBOL_CALLS_LOCAL(INFO, H) \
138 ((! INFO->shared \
139 || INFO->symbolic \
140 || H->dynindx == -1 \
141 || ELF_ST_VISIBILITY (H->other) != STV_DEFAULT) \
142 && (H->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
143 \f
144 static reloc_howto_type *ppc_elf_howto_table[(int) R_PPC_max];
145
146 static reloc_howto_type ppc_elf_howto_raw[] = {
147 /* This reloc does nothing. */
148 HOWTO (R_PPC_NONE, /* type */
149 0, /* rightshift */
150 2, /* size (0 = byte, 1 = short, 2 = long) */
151 32, /* bitsize */
152 false, /* pc_relative */
153 0, /* bitpos */
154 complain_overflow_bitfield, /* complain_on_overflow */
155 bfd_elf_generic_reloc, /* special_function */
156 "R_PPC_NONE", /* name */
157 false, /* partial_inplace */
158 0, /* src_mask */
159 0, /* dst_mask */
160 false), /* pcrel_offset */
161
162 /* A standard 32 bit relocation. */
163 HOWTO (R_PPC_ADDR32, /* type */
164 0, /* rightshift */
165 2, /* size (0 = byte, 1 = short, 2 = long) */
166 32, /* bitsize */
167 false, /* pc_relative */
168 0, /* bitpos */
169 complain_overflow_bitfield, /* complain_on_overflow */
170 bfd_elf_generic_reloc, /* special_function */
171 "R_PPC_ADDR32", /* name */
172 false, /* partial_inplace */
173 0, /* src_mask */
174 0xffffffff, /* dst_mask */
175 false), /* pcrel_offset */
176
177 /* An absolute 26 bit branch; the lower two bits must be zero.
178 FIXME: we don't check that, we just clear them. */
179 HOWTO (R_PPC_ADDR24, /* type */
180 0, /* rightshift */
181 2, /* size (0 = byte, 1 = short, 2 = long) */
182 26, /* bitsize */
183 false, /* pc_relative */
184 0, /* bitpos */
185 complain_overflow_bitfield, /* complain_on_overflow */
186 bfd_elf_generic_reloc, /* special_function */
187 "R_PPC_ADDR24", /* name */
188 false, /* partial_inplace */
189 0, /* src_mask */
190 0x3fffffc, /* dst_mask */
191 false), /* pcrel_offset */
192
193 /* A standard 16 bit relocation. */
194 HOWTO (R_PPC_ADDR16, /* type */
195 0, /* rightshift */
196 1, /* size (0 = byte, 1 = short, 2 = long) */
197 16, /* bitsize */
198 false, /* pc_relative */
199 0, /* bitpos */
200 complain_overflow_bitfield, /* complain_on_overflow */
201 bfd_elf_generic_reloc, /* special_function */
202 "R_PPC_ADDR16", /* name */
203 false, /* partial_inplace */
204 0, /* src_mask */
205 0xffff, /* dst_mask */
206 false), /* pcrel_offset */
207
208 /* A 16 bit relocation without overflow. */
209 HOWTO (R_PPC_ADDR16_LO, /* type */
210 0, /* rightshift */
211 1, /* size (0 = byte, 1 = short, 2 = long) */
212 16, /* bitsize */
213 false, /* pc_relative */
214 0, /* bitpos */
215 complain_overflow_dont,/* complain_on_overflow */
216 bfd_elf_generic_reloc, /* special_function */
217 "R_PPC_ADDR16_LO", /* name */
218 false, /* partial_inplace */
219 0, /* src_mask */
220 0xffff, /* dst_mask */
221 false), /* pcrel_offset */
222
223 /* The high order 16 bits of an address. */
224 HOWTO (R_PPC_ADDR16_HI, /* type */
225 16, /* rightshift */
226 1, /* size (0 = byte, 1 = short, 2 = long) */
227 16, /* bitsize */
228 false, /* pc_relative */
229 0, /* bitpos */
230 complain_overflow_dont, /* complain_on_overflow */
231 bfd_elf_generic_reloc, /* special_function */
232 "R_PPC_ADDR16_HI", /* name */
233 false, /* partial_inplace */
234 0, /* src_mask */
235 0xffff, /* dst_mask */
236 false), /* pcrel_offset */
237
238 /* The high order 16 bits of an address, plus 1 if the contents of
239 the low 16 bits, treated as a signed number, is negative. */
240 HOWTO (R_PPC_ADDR16_HA, /* type */
241 16, /* rightshift */
242 1, /* size (0 = byte, 1 = short, 2 = long) */
243 16, /* bitsize */
244 false, /* pc_relative */
245 0, /* bitpos */
246 complain_overflow_dont, /* complain_on_overflow */
247 ppc_elf_addr16_ha_reloc, /* special_function */
248 "R_PPC_ADDR16_HA", /* name */
249 false, /* partial_inplace */
250 0, /* src_mask */
251 0xffff, /* dst_mask */
252 false), /* pcrel_offset */
253
254 /* An absolute 16 bit branch; the lower two bits must be zero.
255 FIXME: we don't check that, we just clear them. */
256 HOWTO (R_PPC_ADDR14, /* type */
257 0, /* rightshift */
258 2, /* size (0 = byte, 1 = short, 2 = long) */
259 16, /* bitsize */
260 false, /* pc_relative */
261 0, /* bitpos */
262 complain_overflow_bitfield, /* complain_on_overflow */
263 bfd_elf_generic_reloc, /* special_function */
264 "R_PPC_ADDR14", /* name */
265 false, /* partial_inplace */
266 0, /* src_mask */
267 0xfffc, /* dst_mask */
268 false), /* pcrel_offset */
269
270 /* An absolute 16 bit branch, for which bit 10 should be set to
271 indicate that the branch is expected to be taken. The lower two
272 bits must be zero. */
273 HOWTO (R_PPC_ADDR14_BRTAKEN, /* type */
274 0, /* rightshift */
275 2, /* size (0 = byte, 1 = short, 2 = long) */
276 16, /* bitsize */
277 false, /* pc_relative */
278 0, /* bitpos */
279 complain_overflow_bitfield, /* complain_on_overflow */
280 bfd_elf_generic_reloc, /* special_function */
281 "R_PPC_ADDR14_BRTAKEN",/* name */
282 false, /* partial_inplace */
283 0, /* src_mask */
284 0xfffc, /* dst_mask */
285 false), /* pcrel_offset */
286
287 /* An absolute 16 bit branch, for which bit 10 should be set to
288 indicate that the branch is not expected to be taken. The lower
289 two bits must be zero. */
290 HOWTO (R_PPC_ADDR14_BRNTAKEN, /* type */
291 0, /* rightshift */
292 2, /* size (0 = byte, 1 = short, 2 = long) */
293 16, /* bitsize */
294 false, /* pc_relative */
295 0, /* bitpos */
296 complain_overflow_bitfield, /* complain_on_overflow */
297 bfd_elf_generic_reloc, /* special_function */
298 "R_PPC_ADDR14_BRNTAKEN",/* name */
299 false, /* partial_inplace */
300 0, /* src_mask */
301 0xfffc, /* dst_mask */
302 false), /* pcrel_offset */
303
304 /* A relative 26 bit branch; the lower two bits must be zero. */
305 HOWTO (R_PPC_REL24, /* type */
306 0, /* rightshift */
307 2, /* size (0 = byte, 1 = short, 2 = long) */
308 26, /* bitsize */
309 true, /* pc_relative */
310 0, /* bitpos */
311 complain_overflow_signed, /* complain_on_overflow */
312 bfd_elf_generic_reloc, /* special_function */
313 "R_PPC_REL24", /* name */
314 false, /* partial_inplace */
315 0, /* src_mask */
316 0x3fffffc, /* dst_mask */
317 true), /* pcrel_offset */
318
319 /* A relative 16 bit branch; the lower two bits must be zero. */
320 HOWTO (R_PPC_REL14, /* type */
321 0, /* rightshift */
322 2, /* size (0 = byte, 1 = short, 2 = long) */
323 16, /* bitsize */
324 true, /* pc_relative */
325 0, /* bitpos */
326 complain_overflow_signed, /* complain_on_overflow */
327 bfd_elf_generic_reloc, /* special_function */
328 "R_PPC_REL14", /* name */
329 false, /* partial_inplace */
330 0, /* src_mask */
331 0xfffc, /* dst_mask */
332 true), /* pcrel_offset */
333
334 /* A relative 16 bit branch. Bit 10 should be set to indicate that
335 the branch is expected to be taken. The lower two bits must be
336 zero. */
337 HOWTO (R_PPC_REL14_BRTAKEN, /* type */
338 0, /* rightshift */
339 2, /* size (0 = byte, 1 = short, 2 = long) */
340 16, /* bitsize */
341 true, /* pc_relative */
342 0, /* bitpos */
343 complain_overflow_signed, /* complain_on_overflow */
344 bfd_elf_generic_reloc, /* special_function */
345 "R_PPC_REL14_BRTAKEN", /* name */
346 false, /* partial_inplace */
347 0, /* src_mask */
348 0xfffc, /* dst_mask */
349 true), /* pcrel_offset */
350
351 /* A relative 16 bit branch. Bit 10 should be set to indicate that
352 the branch is not expected to be taken. The lower two bits must
353 be zero. */
354 HOWTO (R_PPC_REL14_BRNTAKEN, /* type */
355 0, /* rightshift */
356 2, /* size (0 = byte, 1 = short, 2 = long) */
357 16, /* bitsize */
358 true, /* pc_relative */
359 0, /* bitpos */
360 complain_overflow_signed, /* complain_on_overflow */
361 bfd_elf_generic_reloc, /* special_function */
362 "R_PPC_REL14_BRNTAKEN",/* name */
363 false, /* partial_inplace */
364 0, /* src_mask */
365 0xfffc, /* dst_mask */
366 true), /* pcrel_offset */
367
368 /* Like R_PPC_ADDR16, but referring to the GOT table entry for the
369 symbol. */
370 HOWTO (R_PPC_GOT16, /* type */
371 0, /* rightshift */
372 1, /* size (0 = byte, 1 = short, 2 = long) */
373 16, /* bitsize */
374 false, /* pc_relative */
375 0, /* bitpos */
376 complain_overflow_signed, /* complain_on_overflow */
377 bfd_elf_generic_reloc, /* special_function */
378 "R_PPC_GOT16", /* name */
379 false, /* partial_inplace */
380 0, /* src_mask */
381 0xffff, /* dst_mask */
382 false), /* pcrel_offset */
383
384 /* Like R_PPC_ADDR16_LO, but referring to the GOT table entry for
385 the symbol. */
386 HOWTO (R_PPC_GOT16_LO, /* type */
387 0, /* rightshift */
388 1, /* size (0 = byte, 1 = short, 2 = long) */
389 16, /* bitsize */
390 false, /* pc_relative */
391 0, /* bitpos */
392 complain_overflow_dont, /* complain_on_overflow */
393 bfd_elf_generic_reloc, /* special_function */
394 "R_PPC_GOT16_LO", /* name */
395 false, /* partial_inplace */
396 0, /* src_mask */
397 0xffff, /* dst_mask */
398 false), /* pcrel_offset */
399
400 /* Like R_PPC_ADDR16_HI, but referring to the GOT table entry for
401 the symbol. */
402 HOWTO (R_PPC_GOT16_HI, /* type */
403 16, /* rightshift */
404 1, /* size (0 = byte, 1 = short, 2 = long) */
405 16, /* bitsize */
406 false, /* pc_relative */
407 0, /* bitpos */
408 complain_overflow_bitfield, /* complain_on_overflow */
409 bfd_elf_generic_reloc, /* special_function */
410 "R_PPC_GOT16_HI", /* name */
411 false, /* partial_inplace */
412 0, /* src_mask */
413 0xffff, /* dst_mask */
414 false), /* pcrel_offset */
415
416 /* Like R_PPC_ADDR16_HA, but referring to the GOT table entry for
417 the symbol. */
418 HOWTO (R_PPC_GOT16_HA, /* type */
419 16, /* rightshift */
420 1, /* size (0 = byte, 1 = short, 2 = long) */
421 16, /* bitsize */
422 false, /* pc_relative */
423 0, /* bitpos */
424 complain_overflow_bitfield, /* complain_on_overflow */
425 ppc_elf_addr16_ha_reloc, /* special_function */
426 "R_PPC_GOT16_HA", /* name */
427 false, /* partial_inplace */
428 0, /* src_mask */
429 0xffff, /* dst_mask */
430 false), /* pcrel_offset */
431
432 /* Like R_PPC_REL24, but referring to the procedure linkage table
433 entry for the symbol. */
434 HOWTO (R_PPC_PLTREL24, /* type */
435 0, /* rightshift */
436 2, /* size (0 = byte, 1 = short, 2 = long) */
437 26, /* bitsize */
438 true, /* pc_relative */
439 0, /* bitpos */
440 complain_overflow_signed, /* complain_on_overflow */
441 bfd_elf_generic_reloc, /* special_function */
442 "R_PPC_PLTREL24", /* name */
443 false, /* partial_inplace */
444 0, /* src_mask */
445 0x3fffffc, /* dst_mask */
446 true), /* pcrel_offset */
447
448 /* This is used only by the dynamic linker. The symbol should exist
449 both in the object being run and in some shared library. The
450 dynamic linker copies the data addressed by the symbol from the
451 shared library into the object, because the object being
452 run has to have the data at some particular address. */
453 HOWTO (R_PPC_COPY, /* type */
454 0, /* rightshift */
455 2, /* size (0 = byte, 1 = short, 2 = long) */
456 32, /* bitsize */
457 false, /* pc_relative */
458 0, /* bitpos */
459 complain_overflow_bitfield, /* complain_on_overflow */
460 bfd_elf_generic_reloc, /* special_function */
461 "R_PPC_COPY", /* name */
462 false, /* partial_inplace */
463 0, /* src_mask */
464 0, /* dst_mask */
465 false), /* pcrel_offset */
466
467 /* Like R_PPC_ADDR32, but used when setting global offset table
468 entries. */
469 HOWTO (R_PPC_GLOB_DAT, /* type */
470 0, /* rightshift */
471 2, /* size (0 = byte, 1 = short, 2 = long) */
472 32, /* bitsize */
473 false, /* pc_relative */
474 0, /* bitpos */
475 complain_overflow_bitfield, /* complain_on_overflow */
476 bfd_elf_generic_reloc, /* special_function */
477 "R_PPC_GLOB_DAT", /* name */
478 false, /* partial_inplace */
479 0, /* src_mask */
480 0xffffffff, /* dst_mask */
481 false), /* pcrel_offset */
482
483 /* Marks a procedure linkage table entry for a symbol. */
484 HOWTO (R_PPC_JMP_SLOT, /* type */
485 0, /* rightshift */
486 2, /* size (0 = byte, 1 = short, 2 = long) */
487 32, /* bitsize */
488 false, /* pc_relative */
489 0, /* bitpos */
490 complain_overflow_bitfield, /* complain_on_overflow */
491 bfd_elf_generic_reloc, /* special_function */
492 "R_PPC_JMP_SLOT", /* name */
493 false, /* partial_inplace */
494 0, /* src_mask */
495 0, /* dst_mask */
496 false), /* pcrel_offset */
497
498 /* Used only by the dynamic linker. When the object is run, this
499 longword is set to the load address of the object, plus the
500 addend. */
501 HOWTO (R_PPC_RELATIVE, /* type */
502 0, /* rightshift */
503 2, /* size (0 = byte, 1 = short, 2 = long) */
504 32, /* bitsize */
505 false, /* pc_relative */
506 0, /* bitpos */
507 complain_overflow_bitfield, /* complain_on_overflow */
508 bfd_elf_generic_reloc, /* special_function */
509 "R_PPC_RELATIVE", /* name */
510 false, /* partial_inplace */
511 0, /* src_mask */
512 0xffffffff, /* dst_mask */
513 false), /* pcrel_offset */
514
515 /* Like R_PPC_REL24, but uses the value of the symbol within the
516 object rather than the final value. Normally used for
517 _GLOBAL_OFFSET_TABLE_. */
518 HOWTO (R_PPC_LOCAL24PC, /* type */
519 0, /* rightshift */
520 2, /* size (0 = byte, 1 = short, 2 = long) */
521 26, /* bitsize */
522 true, /* pc_relative */
523 0, /* bitpos */
524 complain_overflow_signed, /* complain_on_overflow */
525 bfd_elf_generic_reloc, /* special_function */
526 "R_PPC_LOCAL24PC", /* name */
527 false, /* partial_inplace */
528 0, /* src_mask */
529 0x3fffffc, /* dst_mask */
530 true), /* pcrel_offset */
531
532 /* Like R_PPC_ADDR32, but may be unaligned. */
533 HOWTO (R_PPC_UADDR32, /* type */
534 0, /* rightshift */
535 2, /* size (0 = byte, 1 = short, 2 = long) */
536 32, /* bitsize */
537 false, /* pc_relative */
538 0, /* bitpos */
539 complain_overflow_bitfield, /* complain_on_overflow */
540 bfd_elf_generic_reloc, /* special_function */
541 "R_PPC_UADDR32", /* name */
542 false, /* partial_inplace */
543 0, /* src_mask */
544 0xffffffff, /* dst_mask */
545 false), /* pcrel_offset */
546
547 /* Like R_PPC_ADDR16, but may be unaligned. */
548 HOWTO (R_PPC_UADDR16, /* type */
549 0, /* rightshift */
550 1, /* size (0 = byte, 1 = short, 2 = long) */
551 16, /* bitsize */
552 false, /* pc_relative */
553 0, /* bitpos */
554 complain_overflow_bitfield, /* complain_on_overflow */
555 bfd_elf_generic_reloc, /* special_function */
556 "R_PPC_UADDR16", /* name */
557 false, /* partial_inplace */
558 0, /* src_mask */
559 0xffff, /* dst_mask */
560 false), /* pcrel_offset */
561
562 /* 32-bit PC relative */
563 HOWTO (R_PPC_REL32, /* type */
564 0, /* rightshift */
565 2, /* size (0 = byte, 1 = short, 2 = long) */
566 32, /* bitsize */
567 true, /* pc_relative */
568 0, /* bitpos */
569 complain_overflow_bitfield, /* complain_on_overflow */
570 bfd_elf_generic_reloc, /* special_function */
571 "R_PPC_REL32", /* name */
572 false, /* partial_inplace */
573 0, /* src_mask */
574 0xffffffff, /* dst_mask */
575 true), /* pcrel_offset */
576
577 /* 32-bit relocation to the symbol's procedure linkage table.
578 FIXME: not supported. */
579 HOWTO (R_PPC_PLT32, /* type */
580 0, /* rightshift */
581 2, /* size (0 = byte, 1 = short, 2 = long) */
582 32, /* bitsize */
583 false, /* pc_relative */
584 0, /* bitpos */
585 complain_overflow_bitfield, /* complain_on_overflow */
586 bfd_elf_generic_reloc, /* special_function */
587 "R_PPC_PLT32", /* name */
588 false, /* partial_inplace */
589 0, /* src_mask */
590 0, /* dst_mask */
591 false), /* pcrel_offset */
592
593 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
594 FIXME: not supported. */
595 HOWTO (R_PPC_PLTREL32, /* type */
596 0, /* rightshift */
597 2, /* size (0 = byte, 1 = short, 2 = long) */
598 32, /* bitsize */
599 true, /* pc_relative */
600 0, /* bitpos */
601 complain_overflow_bitfield, /* complain_on_overflow */
602 bfd_elf_generic_reloc, /* special_function */
603 "R_PPC_PLTREL32", /* name */
604 false, /* partial_inplace */
605 0, /* src_mask */
606 0, /* dst_mask */
607 true), /* pcrel_offset */
608
609 /* Like R_PPC_ADDR16_LO, but referring to the PLT table entry for
610 the symbol. */
611 HOWTO (R_PPC_PLT16_LO, /* type */
612 0, /* rightshift */
613 1, /* size (0 = byte, 1 = short, 2 = long) */
614 16, /* bitsize */
615 false, /* pc_relative */
616 0, /* bitpos */
617 complain_overflow_dont, /* complain_on_overflow */
618 bfd_elf_generic_reloc, /* special_function */
619 "R_PPC_PLT16_LO", /* name */
620 false, /* partial_inplace */
621 0, /* src_mask */
622 0xffff, /* dst_mask */
623 false), /* pcrel_offset */
624
625 /* Like R_PPC_ADDR16_HI, but referring to the PLT table entry for
626 the symbol. */
627 HOWTO (R_PPC_PLT16_HI, /* type */
628 16, /* rightshift */
629 1, /* size (0 = byte, 1 = short, 2 = long) */
630 16, /* bitsize */
631 false, /* pc_relative */
632 0, /* bitpos */
633 complain_overflow_bitfield, /* complain_on_overflow */
634 bfd_elf_generic_reloc, /* special_function */
635 "R_PPC_PLT16_HI", /* name */
636 false, /* partial_inplace */
637 0, /* src_mask */
638 0xffff, /* dst_mask */
639 false), /* pcrel_offset */
640
641 /* Like R_PPC_ADDR16_HA, but referring to the PLT table entry for
642 the symbol. */
643 HOWTO (R_PPC_PLT16_HA, /* type */
644 16, /* rightshift */
645 1, /* size (0 = byte, 1 = short, 2 = long) */
646 16, /* bitsize */
647 false, /* pc_relative */
648 0, /* bitpos */
649 complain_overflow_bitfield, /* complain_on_overflow */
650 ppc_elf_addr16_ha_reloc, /* special_function */
651 "R_PPC_PLT16_HA", /* name */
652 false, /* partial_inplace */
653 0, /* src_mask */
654 0xffff, /* dst_mask */
655 false), /* pcrel_offset */
656
657 /* A sign-extended 16 bit value relative to _SDA_BASE_, for use with
658 small data items. */
659 HOWTO (R_PPC_SDAREL16, /* type */
660 0, /* rightshift */
661 1, /* size (0 = byte, 1 = short, 2 = long) */
662 16, /* bitsize */
663 false, /* pc_relative */
664 0, /* bitpos */
665 complain_overflow_signed, /* complain_on_overflow */
666 bfd_elf_generic_reloc, /* special_function */
667 "R_PPC_SDAREL16", /* name */
668 false, /* partial_inplace */
669 0, /* src_mask */
670 0xffff, /* dst_mask */
671 false), /* pcrel_offset */
672
673 /* 32-bit section relative relocation. */
674 HOWTO (R_PPC_SECTOFF, /* type */
675 0, /* rightshift */
676 2, /* size (0 = byte, 1 = short, 2 = long) */
677 32, /* bitsize */
678 true, /* pc_relative */
679 0, /* bitpos */
680 complain_overflow_bitfield, /* complain_on_overflow */
681 bfd_elf_generic_reloc, /* special_function */
682 "R_PPC_SECTOFF", /* name */
683 false, /* partial_inplace */
684 0, /* src_mask */
685 0, /* dst_mask */
686 true), /* pcrel_offset */
687
688 /* 16-bit lower half section relative relocation. */
689 HOWTO (R_PPC_SECTOFF_LO, /* type */
690 0, /* rightshift */
691 1, /* size (0 = byte, 1 = short, 2 = long) */
692 16, /* bitsize */
693 false, /* pc_relative */
694 0, /* bitpos */
695 complain_overflow_dont, /* complain_on_overflow */
696 bfd_elf_generic_reloc, /* special_function */
697 "R_PPC_SECTOFF_LO", /* name */
698 false, /* partial_inplace */
699 0, /* src_mask */
700 0xffff, /* dst_mask */
701 false), /* pcrel_offset */
702
703 /* 16-bit upper half section relative relocation. */
704 HOWTO (R_PPC_SECTOFF_HI, /* type */
705 16, /* rightshift */
706 1, /* size (0 = byte, 1 = short, 2 = long) */
707 16, /* bitsize */
708 false, /* pc_relative */
709 0, /* bitpos */
710 complain_overflow_bitfield, /* complain_on_overflow */
711 bfd_elf_generic_reloc, /* special_function */
712 "R_PPC_SECTOFF_HI", /* name */
713 false, /* partial_inplace */
714 0, /* src_mask */
715 0xffff, /* dst_mask */
716 false), /* pcrel_offset */
717
718 /* 16-bit upper half adjusted section relative relocation. */
719 HOWTO (R_PPC_SECTOFF_HA, /* type */
720 16, /* rightshift */
721 1, /* size (0 = byte, 1 = short, 2 = long) */
722 16, /* bitsize */
723 false, /* pc_relative */
724 0, /* bitpos */
725 complain_overflow_bitfield, /* complain_on_overflow */
726 ppc_elf_addr16_ha_reloc, /* special_function */
727 "R_PPC_SECTOFF_HA", /* name */
728 false, /* partial_inplace */
729 0, /* src_mask */
730 0xffff, /* dst_mask */
731 false), /* pcrel_offset */
732
733 /* The remaining relocs are from the Embedded ELF ABI, and are not
734 in the SVR4 ELF ABI. */
735
736 /* 32 bit value resulting from the addend minus the symbol */
737 HOWTO (R_PPC_EMB_NADDR32, /* type */
738 0, /* rightshift */
739 2, /* size (0 = byte, 1 = short, 2 = long) */
740 32, /* bitsize */
741 false, /* pc_relative */
742 0, /* bitpos */
743 complain_overflow_bitfield, /* complain_on_overflow */
744 bfd_elf_generic_reloc, /* special_function */
745 "R_PPC_EMB_NADDR32", /* name */
746 false, /* partial_inplace */
747 0, /* src_mask */
748 0xffffffff, /* dst_mask */
749 false), /* pcrel_offset */
750
751 /* 16 bit value resulting from the addend minus the symbol */
752 HOWTO (R_PPC_EMB_NADDR16, /* type */
753 0, /* rightshift */
754 1, /* size (0 = byte, 1 = short, 2 = long) */
755 16, /* bitsize */
756 false, /* pc_relative */
757 0, /* bitpos */
758 complain_overflow_bitfield, /* complain_on_overflow */
759 bfd_elf_generic_reloc, /* special_function */
760 "R_PPC_EMB_NADDR16", /* name */
761 false, /* partial_inplace */
762 0, /* src_mask */
763 0xffff, /* dst_mask */
764 false), /* pcrel_offset */
765
766 /* 16 bit value resulting from the addend minus the symbol */
767 HOWTO (R_PPC_EMB_NADDR16_LO, /* type */
768 0, /* rightshift */
769 1, /* size (0 = byte, 1 = short, 2 = long) */
770 16, /* bitsize */
771 false, /* pc_relative */
772 0, /* bitpos */
773 complain_overflow_dont,/* complain_on_overflow */
774 bfd_elf_generic_reloc, /* special_function */
775 "R_PPC_EMB_ADDR16_LO", /* name */
776 false, /* partial_inplace */
777 0, /* src_mask */
778 0xffff, /* dst_mask */
779 false), /* pcrel_offset */
780
781 /* The high order 16 bits of the addend minus the symbol */
782 HOWTO (R_PPC_EMB_NADDR16_HI, /* type */
783 16, /* rightshift */
784 1, /* size (0 = byte, 1 = short, 2 = long) */
785 16, /* bitsize */
786 false, /* pc_relative */
787 0, /* bitpos */
788 complain_overflow_dont, /* complain_on_overflow */
789 bfd_elf_generic_reloc, /* special_function */
790 "R_PPC_EMB_NADDR16_HI", /* name */
791 false, /* partial_inplace */
792 0, /* src_mask */
793 0xffff, /* dst_mask */
794 false), /* pcrel_offset */
795
796 /* The high order 16 bits of the result of the addend minus the address,
797 plus 1 if the contents of the low 16 bits, treated as a signed number,
798 is negative. */
799 HOWTO (R_PPC_EMB_NADDR16_HA, /* type */
800 16, /* rightshift */
801 1, /* size (0 = byte, 1 = short, 2 = long) */
802 16, /* bitsize */
803 false, /* pc_relative */
804 0, /* bitpos */
805 complain_overflow_dont, /* complain_on_overflow */
806 ppc_elf_addr16_ha_reloc, /* special_function */
807 "R_PPC_EMB_NADDR16_HA", /* name */
808 false, /* partial_inplace */
809 0, /* src_mask */
810 0xffff, /* dst_mask */
811 false), /* pcrel_offset */
812
813 /* 16 bit value resulting from allocating a 4 byte word to hold an
814 address in the .sdata section, and returning the offset from
815 _SDA_BASE_ for that relocation */
816 HOWTO (R_PPC_EMB_SDAI16, /* type */
817 0, /* rightshift */
818 1, /* size (0 = byte, 1 = short, 2 = long) */
819 16, /* bitsize */
820 false, /* pc_relative */
821 0, /* bitpos */
822 complain_overflow_bitfield, /* complain_on_overflow */
823 bfd_elf_generic_reloc, /* special_function */
824 "R_PPC_EMB_SDAI16", /* name */
825 false, /* partial_inplace */
826 0, /* src_mask */
827 0xffff, /* dst_mask */
828 false), /* pcrel_offset */
829
830 /* 16 bit value resulting from allocating a 4 byte word to hold an
831 address in the .sdata2 section, and returning the offset from
832 _SDA2_BASE_ for that relocation */
833 HOWTO (R_PPC_EMB_SDA2I16, /* type */
834 0, /* rightshift */
835 1, /* size (0 = byte, 1 = short, 2 = long) */
836 16, /* bitsize */
837 false, /* pc_relative */
838 0, /* bitpos */
839 complain_overflow_bitfield, /* complain_on_overflow */
840 bfd_elf_generic_reloc, /* special_function */
841 "R_PPC_EMB_SDA2I16", /* name */
842 false, /* partial_inplace */
843 0, /* src_mask */
844 0xffff, /* dst_mask */
845 false), /* pcrel_offset */
846
847 /* A sign-extended 16 bit value relative to _SDA2_BASE_, for use with
848 small data items. */
849 HOWTO (R_PPC_EMB_SDA2REL, /* type */
850 0, /* rightshift */
851 1, /* size (0 = byte, 1 = short, 2 = long) */
852 16, /* bitsize */
853 false, /* pc_relative */
854 0, /* bitpos */
855 complain_overflow_signed, /* complain_on_overflow */
856 bfd_elf_generic_reloc, /* special_function */
857 "R_PPC_EMB_SDA2REL", /* name */
858 false, /* partial_inplace */
859 0, /* src_mask */
860 0xffff, /* dst_mask */
861 false), /* pcrel_offset */
862
863 /* Relocate against either _SDA_BASE_ or _SDA2_BASE_, filling in the 16 bit
864 signed offset from the appropriate base, and filling in the register
865 field with the appropriate register (0, 2, or 13). */
866 HOWTO (R_PPC_EMB_SDA21, /* type */
867 0, /* rightshift */
868 2, /* size (0 = byte, 1 = short, 2 = long) */
869 16, /* bitsize */
870 false, /* pc_relative */
871 0, /* bitpos */
872 complain_overflow_signed, /* complain_on_overflow */
873 bfd_elf_generic_reloc, /* special_function */
874 "R_PPC_EMB_SDA21", /* name */
875 false, /* partial_inplace */
876 0, /* src_mask */
877 0xffff, /* dst_mask */
878 false), /* pcrel_offset */
879
880 /* Relocation not handled: R_PPC_EMB_MRKREF */
881 /* Relocation not handled: R_PPC_EMB_RELSEC16 */
882 /* Relocation not handled: R_PPC_EMB_RELST_LO */
883 /* Relocation not handled: R_PPC_EMB_RELST_HI */
884 /* Relocation not handled: R_PPC_EMB_RELST_HA */
885 /* Relocation not handled: R_PPC_EMB_BIT_FLD */
886
887 /* PC relative relocation against either _SDA_BASE_ or _SDA2_BASE_, filling
888 in the 16 bit signed offset from the appropriate base, and filling in the
889 register field with the appropriate register (0, 2, or 13). */
890 HOWTO (R_PPC_EMB_RELSDA, /* type */
891 0, /* rightshift */
892 1, /* size (0 = byte, 1 = short, 2 = long) */
893 16, /* bitsize */
894 true, /* pc_relative */
895 0, /* bitpos */
896 complain_overflow_signed, /* complain_on_overflow */
897 bfd_elf_generic_reloc, /* special_function */
898 "R_PPC_EMB_RELSDA", /* name */
899 false, /* partial_inplace */
900 0, /* src_mask */
901 0xffff, /* dst_mask */
902 false), /* pcrel_offset */
903
904 /* GNU extension to record C++ vtable hierarchy */
905 HOWTO (R_PPC_GNU_VTINHERIT, /* type */
906 0, /* rightshift */
907 0, /* size (0 = byte, 1 = short, 2 = long) */
908 0, /* bitsize */
909 false, /* pc_relative */
910 0, /* bitpos */
911 complain_overflow_dont, /* complain_on_overflow */
912 NULL, /* special_function */
913 "R_PPC_GNU_VTINHERIT", /* name */
914 false, /* partial_inplace */
915 0, /* src_mask */
916 0, /* dst_mask */
917 false), /* pcrel_offset */
918
919 /* GNU extension to record C++ vtable member usage */
920 HOWTO (R_PPC_GNU_VTENTRY, /* type */
921 0, /* rightshift */
922 0, /* size (0 = byte, 1 = short, 2 = long) */
923 0, /* bitsize */
924 false, /* pc_relative */
925 0, /* bitpos */
926 complain_overflow_dont, /* complain_on_overflow */
927 NULL, /* special_function */
928 "R_PPC_GNU_VTENTRY", /* name */
929 false, /* partial_inplace */
930 0, /* src_mask */
931 0, /* dst_mask */
932 false), /* pcrel_offset */
933
934 /* Phony reloc to handle AIX style TOC entries */
935 HOWTO (R_PPC_TOC16, /* type */
936 0, /* rightshift */
937 1, /* size (0 = byte, 1 = short, 2 = long) */
938 16, /* bitsize */
939 false, /* pc_relative */
940 0, /* bitpos */
941 complain_overflow_signed, /* complain_on_overflow */
942 bfd_elf_generic_reloc, /* special_function */
943 "R_PPC_TOC16", /* name */
944 false, /* partial_inplace */
945 0, /* src_mask */
946 0xffff, /* dst_mask */
947 false), /* pcrel_offset */
948 };
949 \f
950 /* Initialize the ppc_elf_howto_table, so that linear accesses can be done. */
951
952 static void
953 ppc_elf_howto_init ()
954 {
955 unsigned int i, type;
956
957 for (i = 0; i < sizeof (ppc_elf_howto_raw) / sizeof (ppc_elf_howto_raw[0]); i++)
958 {
959 type = ppc_elf_howto_raw[i].type;
960 BFD_ASSERT (type < sizeof (ppc_elf_howto_table) / sizeof (ppc_elf_howto_table[0]));
961 ppc_elf_howto_table[type] = &ppc_elf_howto_raw[i];
962 }
963 }
964 \f
965 /* This function handles relaxing for the PPC with option --mpc860c0[=<n>].
966
967 The MPC860, revision C0 or earlier contains a bug in the die.
968 If all of the following conditions are true, the next instruction
969 to be executed *may* be treated as a no-op.
970 1/ A forward branch is executed.
971 2/ The branch is predicted as not taken.
972 3/ The branch is taken.
973 4/ The branch is located in the last 5 words of a page.
974 (The EOP limit is 5 by default but may be specified as any value from 1-10.)
975
976 Our software solution is to detect these problematic branches in a
977 linker pass and modify them as follows:
978 1/ Unconditional branches - Since these are always predicted taken,
979 there is no problem and no action is required.
980 2/ Conditional backward branches - No problem, no action required.
981 3/ Conditional forward branches - Ensure that the "inverse prediction
982 bit" is set (ensure it is predicted taken).
983 4/ Conditional register branches - Ensure that the "y bit" is set
984 (ensure it is predicted taken).
985 */
986
987 /* Sort sections by address. */
988
989 static int
990 ppc_elf_sort_rela (arg1, arg2)
991 const void *arg1;
992 const void *arg2;
993 {
994 const Elf_Internal_Rela **rela1 = (const Elf_Internal_Rela**) arg1;
995 const Elf_Internal_Rela **rela2 = (const Elf_Internal_Rela**) arg2;
996
997 /* Sort by offset. */
998 return ((*rela1)->r_offset - (*rela2)->r_offset);
999 }
1000
1001 static boolean
1002 ppc_elf_relax_section (abfd, isec, link_info, again)
1003 bfd *abfd;
1004 asection *isec;
1005 struct bfd_link_info *link_info;
1006 boolean *again;
1007 {
1008 #define PAGESIZE 0x1000
1009
1010 bfd_byte *contents = NULL;
1011 bfd_byte *free_contents = NULL;
1012 Elf_Internal_Rela *internal_relocs = NULL;
1013 Elf_Internal_Rela *free_relocs = NULL;
1014 Elf_Internal_Rela **rela_comb = NULL;
1015 int comb_curr, comb_count;
1016
1017 /* We never have to do this more than once per input section. */
1018 *again = false;
1019
1020 /* If needed, initialize this section's cooked size. */
1021 if (isec->_cooked_size == 0)
1022 isec->_cooked_size = isec->_raw_size;
1023
1024 /* We're only interested in text sections which overlap the
1025 troublesome area at the end of a page. */
1026 if (link_info->mpc860c0 && (isec->flags & SEC_CODE) && isec->_cooked_size)
1027 {
1028 bfd_vma dot, end_page, end_section;
1029 boolean section_modified;
1030
1031 /* Get the section contents. */
1032 /* Get cached copy if it exists. */
1033 if (elf_section_data (isec)->this_hdr.contents != NULL)
1034 contents = elf_section_data (isec)->this_hdr.contents;
1035 else
1036 {
1037 /* Go get them off disk. */
1038 contents = (bfd_byte *) bfd_malloc (isec->_raw_size);
1039 if (contents == NULL)
1040 goto error_return;
1041 free_contents = contents;
1042
1043 if (! bfd_get_section_contents (abfd, isec, contents,
1044 (file_ptr) 0, isec->_raw_size))
1045 goto error_return;
1046 }
1047
1048 comb_curr = 0;
1049 comb_count = 0;
1050 if (isec->reloc_count)
1051 {
1052 unsigned n;
1053
1054 /* Get a copy of the native relocations. */
1055 internal_relocs = _bfd_elf32_link_read_relocs (
1056 abfd, isec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1057 link_info->keep_memory);
1058 if (internal_relocs == NULL)
1059 goto error_return;
1060 if (! link_info->keep_memory)
1061 free_relocs = internal_relocs;
1062
1063 /* Setup a faster access method for the reloc info we need. */
1064 rela_comb = (Elf_Internal_Rela**)
1065 bfd_malloc (isec->reloc_count*sizeof (Elf_Internal_Rela*));
1066 if (rela_comb == NULL)
1067 goto error_return;
1068 for (n = 0; n < isec->reloc_count; ++n)
1069 {
1070 long r_type;
1071
1072 r_type = ELF32_R_TYPE (internal_relocs[n].r_info);
1073 if (r_type < 0 || r_type >= (int) R_PPC_max)
1074 goto error_return;
1075
1076 /* Prologue constants are sometimes present in the ".text"
1077 sections and they can be identified by their associated relocation.
1078 We don't want to process those words and some others which
1079 can also be identified by their relocations. However, not all
1080 conditional branches will have a relocation so we will
1081 only ignore words that 1) have a reloc, and 2) the reloc
1082 is not applicable to a conditional branch.
1083 The array rela_comb is built here for use in the EOP scan loop. */
1084 switch (r_type)
1085 {
1086 case R_PPC_ADDR14_BRNTAKEN: /* absolute, predicted not taken */
1087 case R_PPC_REL14: /* relative cond. br. */
1088 case R_PPC_REL14_BRNTAKEN: /* rel. cond. br., predicted not taken */
1089 /* We should check the instruction. */
1090 break;
1091 default:
1092 /* The word is not a conditional branch - ignore it. */
1093 rela_comb[comb_count++] = &internal_relocs[n];
1094 break;
1095 }
1096 }
1097 if (comb_count > 1)
1098 qsort (rela_comb, (size_t) comb_count, sizeof (int), ppc_elf_sort_rela);
1099 }
1100
1101 /* Enumerate each EOP region that overlaps this section. */
1102 end_section = isec->vma + isec->_cooked_size;
1103 dot = end_page = (isec->vma | (PAGESIZE - 1)) + 1;
1104 dot -= link_info->mpc860c0;
1105 section_modified = false;
1106 if (dot < isec->vma) /* Increment the start position if this section */
1107 dot = isec->vma; /* begins in the middle of its first EOP region. */
1108 for (;
1109 dot < end_section;
1110 dot += PAGESIZE, end_page += PAGESIZE)
1111 {
1112
1113 /* Check each word in this EOP region. */
1114 for (; dot < end_page; dot += 4)
1115 {
1116 bfd_vma isec_offset;
1117 unsigned long insn;
1118 boolean skip, modified;
1119
1120 /* Don't process this word if there is a relocation for it and
1121 the relocation indicates the word is not a conditional branch. */
1122 skip = false;
1123 isec_offset = dot - isec->vma;
1124 for (; comb_curr<comb_count; ++comb_curr)
1125 {
1126 bfd_vma r_offset;
1127
1128 r_offset = rela_comb[comb_curr]->r_offset;
1129 if (r_offset >= isec_offset)
1130 {
1131 if (r_offset == isec_offset) skip = true;
1132 break;
1133 }
1134 }
1135 if (skip) continue;
1136
1137 /* Check the current word for a problematic conditional branch. */
1138 #define BO0(insn) ((insn) & 0x02000000)
1139 #define BO2(insn) ((insn) & 0x00800000)
1140 #define BO4(insn) ((insn) & 0x00200000)
1141 insn = (unsigned long) bfd_get_32 (abfd, contents + isec_offset);
1142 modified = false;
1143 if ((insn & 0xFc000000) == 0x40000000)
1144 {
1145 /* Instruction is BCx */
1146 if ((!BO0(insn) || !BO2(insn)) && !BO4(insn))
1147 {
1148 bfd_vma target;
1149 /* This branch is predicted as "normal".
1150 If this is a forward branch, it is problematic. */
1151
1152 target = insn & 0x0000Fffc; /*extract*/
1153 target = (target ^ 0x8000) - 0x8000; /*sign extend*/
1154 if ((insn & 0x00000002) == 0)
1155 target += dot; /*convert to abs*/
1156 if (target > dot)
1157 {
1158 insn |= 0x00200000; /* set the prediction bit */
1159 modified = true;
1160 }
1161 }
1162 }
1163 else if ((insn & 0xFc00Fffe) == 0x4c000420)
1164 {
1165 /* Instruction is BCCTRx */
1166 if ((!BO0(insn) || !BO2(insn)) && !BO4(insn))
1167 {
1168 /* This branch is predicted as not-taken.
1169 If this is a forward branch, it is problematic.
1170 Since we can't tell statically if it will branch forward,
1171 always set the prediction bit. */
1172 insn |= 0x00200000; /* set the prediction bit */
1173 modified = true;
1174 }
1175 }
1176 else if ((insn & 0xFc00Fffe) == 0x4c000020)
1177 {
1178 /* Instruction is BCLRx */
1179 if ((!BO0(insn) || !BO2(insn)) && !BO4(insn))
1180 {
1181 /* This branch is predicted as not-taken.
1182 If this is a forward branch, it is problematic.
1183 Since we can't tell statically if it will branch forward,
1184 always set the prediction bit. */
1185 insn |= 0x00200000; /* set the prediction bit */
1186 modified = true;
1187 }
1188 }
1189 #undef BO0
1190 #undef BO2
1191 #undef BO4
1192 if (modified)
1193 {
1194 bfd_put_32 (abfd, insn, contents + isec_offset);
1195 section_modified = true;
1196 }
1197 }
1198 }
1199 if (section_modified)
1200 {
1201 elf_section_data (isec)->this_hdr.contents = contents;
1202 free_contents = NULL;
1203 }
1204 }
1205
1206 if (rela_comb != NULL)
1207 {
1208 free (rela_comb);
1209 rela_comb = NULL;
1210 }
1211
1212 if (free_relocs != NULL)
1213 {
1214 free (free_relocs);
1215 free_relocs = NULL;
1216 }
1217
1218 if (free_contents != NULL)
1219 {
1220 if (! link_info->keep_memory)
1221 free (free_contents);
1222 else
1223 {
1224 /* Cache the section contents for elf_link_input_bfd. */
1225 elf_section_data (isec)->this_hdr.contents = contents;
1226 }
1227 free_contents = NULL;
1228 }
1229
1230 return true;
1231
1232 error_return:
1233 if (rela_comb != NULL)
1234 free (rela_comb);
1235 if (free_relocs != NULL)
1236 free (free_relocs);
1237 if (free_contents != NULL)
1238 free (free_contents);
1239 return false;
1240 }
1241 \f
1242 static reloc_howto_type *
1243 ppc_elf_reloc_type_lookup (abfd, code)
1244 bfd *abfd ATTRIBUTE_UNUSED;
1245 bfd_reloc_code_real_type code;
1246 {
1247 enum elf_ppc_reloc_type ppc_reloc = R_PPC_NONE;
1248
1249 if (!ppc_elf_howto_table[R_PPC_ADDR32])
1250 /* Initialize howto table if needed. */
1251 ppc_elf_howto_init ();
1252
1253 switch ((int) code)
1254 {
1255 default:
1256 return (reloc_howto_type *) NULL;
1257
1258 case BFD_RELOC_NONE: ppc_reloc = R_PPC_NONE; break;
1259 case BFD_RELOC_32: ppc_reloc = R_PPC_ADDR32; break;
1260 case BFD_RELOC_PPC_BA26: ppc_reloc = R_PPC_ADDR24; break;
1261 case BFD_RELOC_16: ppc_reloc = R_PPC_ADDR16; break;
1262 case BFD_RELOC_LO16: ppc_reloc = R_PPC_ADDR16_LO; break;
1263 case BFD_RELOC_HI16: ppc_reloc = R_PPC_ADDR16_HI; break;
1264 case BFD_RELOC_HI16_S: ppc_reloc = R_PPC_ADDR16_HA; break;
1265 case BFD_RELOC_PPC_BA16: ppc_reloc = R_PPC_ADDR14; break;
1266 case BFD_RELOC_PPC_BA16_BRTAKEN: ppc_reloc = R_PPC_ADDR14_BRTAKEN; break;
1267 case BFD_RELOC_PPC_BA16_BRNTAKEN: ppc_reloc = R_PPC_ADDR14_BRNTAKEN; break;
1268 case BFD_RELOC_PPC_B26: ppc_reloc = R_PPC_REL24; break;
1269 case BFD_RELOC_PPC_B16: ppc_reloc = R_PPC_REL14; break;
1270 case BFD_RELOC_PPC_B16_BRTAKEN: ppc_reloc = R_PPC_REL14_BRTAKEN; break;
1271 case BFD_RELOC_PPC_B16_BRNTAKEN: ppc_reloc = R_PPC_REL14_BRNTAKEN; break;
1272 case BFD_RELOC_16_GOTOFF: ppc_reloc = R_PPC_GOT16; break;
1273 case BFD_RELOC_LO16_GOTOFF: ppc_reloc = R_PPC_GOT16_LO; break;
1274 case BFD_RELOC_HI16_GOTOFF: ppc_reloc = R_PPC_GOT16_HI; break;
1275 case BFD_RELOC_HI16_S_GOTOFF: ppc_reloc = R_PPC_GOT16_HA; break;
1276 case BFD_RELOC_24_PLT_PCREL: ppc_reloc = R_PPC_PLTREL24; break;
1277 case BFD_RELOC_PPC_COPY: ppc_reloc = R_PPC_COPY; break;
1278 case BFD_RELOC_PPC_GLOB_DAT: ppc_reloc = R_PPC_GLOB_DAT; break;
1279 case BFD_RELOC_PPC_LOCAL24PC: ppc_reloc = R_PPC_LOCAL24PC; break;
1280 case BFD_RELOC_32_PCREL: ppc_reloc = R_PPC_REL32; break;
1281 case BFD_RELOC_32_PLTOFF: ppc_reloc = R_PPC_PLT32; break;
1282 case BFD_RELOC_32_PLT_PCREL: ppc_reloc = R_PPC_PLTREL32; break;
1283 case BFD_RELOC_LO16_PLTOFF: ppc_reloc = R_PPC_PLT16_LO; break;
1284 case BFD_RELOC_HI16_PLTOFF: ppc_reloc = R_PPC_PLT16_HI; break;
1285 case BFD_RELOC_HI16_S_PLTOFF: ppc_reloc = R_PPC_PLT16_HA; break;
1286 case BFD_RELOC_GPREL16: ppc_reloc = R_PPC_SDAREL16; break;
1287 case BFD_RELOC_32_BASEREL: ppc_reloc = R_PPC_SECTOFF; break;
1288 case BFD_RELOC_LO16_BASEREL: ppc_reloc = R_PPC_SECTOFF_LO; break;
1289 case BFD_RELOC_HI16_BASEREL: ppc_reloc = R_PPC_SECTOFF_HI; break;
1290 case BFD_RELOC_HI16_S_BASEREL: ppc_reloc = R_PPC_SECTOFF_HA; break;
1291 case BFD_RELOC_CTOR: ppc_reloc = R_PPC_ADDR32; break;
1292 case BFD_RELOC_PPC_TOC16: ppc_reloc = R_PPC_TOC16; break;
1293 case BFD_RELOC_PPC_EMB_NADDR32: ppc_reloc = R_PPC_EMB_NADDR32; break;
1294 case BFD_RELOC_PPC_EMB_NADDR16: ppc_reloc = R_PPC_EMB_NADDR16; break;
1295 case BFD_RELOC_PPC_EMB_NADDR16_LO: ppc_reloc = R_PPC_EMB_NADDR16_LO; break;
1296 case BFD_RELOC_PPC_EMB_NADDR16_HI: ppc_reloc = R_PPC_EMB_NADDR16_HI; break;
1297 case BFD_RELOC_PPC_EMB_NADDR16_HA: ppc_reloc = R_PPC_EMB_NADDR16_HA; break;
1298 case BFD_RELOC_PPC_EMB_SDAI16: ppc_reloc = R_PPC_EMB_SDAI16; break;
1299 case BFD_RELOC_PPC_EMB_SDA2I16: ppc_reloc = R_PPC_EMB_SDA2I16; break;
1300 case BFD_RELOC_PPC_EMB_SDA2REL: ppc_reloc = R_PPC_EMB_SDA2REL; break;
1301 case BFD_RELOC_PPC_EMB_SDA21: ppc_reloc = R_PPC_EMB_SDA21; break;
1302 case BFD_RELOC_PPC_EMB_MRKREF: ppc_reloc = R_PPC_EMB_MRKREF; break;
1303 case BFD_RELOC_PPC_EMB_RELSEC16: ppc_reloc = R_PPC_EMB_RELSEC16; break;
1304 case BFD_RELOC_PPC_EMB_RELST_LO: ppc_reloc = R_PPC_EMB_RELST_LO; break;
1305 case BFD_RELOC_PPC_EMB_RELST_HI: ppc_reloc = R_PPC_EMB_RELST_HI; break;
1306 case BFD_RELOC_PPC_EMB_RELST_HA: ppc_reloc = R_PPC_EMB_RELST_HA; break;
1307 case BFD_RELOC_PPC_EMB_BIT_FLD: ppc_reloc = R_PPC_EMB_BIT_FLD; break;
1308 case BFD_RELOC_PPC_EMB_RELSDA: ppc_reloc = R_PPC_EMB_RELSDA; break;
1309 case BFD_RELOC_VTABLE_INHERIT: ppc_reloc = R_PPC_GNU_VTINHERIT; break;
1310 case BFD_RELOC_VTABLE_ENTRY: ppc_reloc = R_PPC_GNU_VTENTRY; break;
1311 }
1312
1313 return ppc_elf_howto_table[(int) ppc_reloc];
1314 };
1315
1316 /* Set the howto pointer for a PowerPC ELF reloc. */
1317
1318 static void
1319 ppc_elf_info_to_howto (abfd, cache_ptr, dst)
1320 bfd *abfd ATTRIBUTE_UNUSED;
1321 arelent *cache_ptr;
1322 Elf32_Internal_Rela *dst;
1323 {
1324 if (!ppc_elf_howto_table[R_PPC_ADDR32])
1325 /* Initialize howto table if needed. */
1326 ppc_elf_howto_init ();
1327
1328 BFD_ASSERT (ELF32_R_TYPE (dst->r_info) < (unsigned int) R_PPC_max);
1329 cache_ptr->howto = ppc_elf_howto_table[ELF32_R_TYPE (dst->r_info)];
1330 }
1331
1332 /* Handle the R_PPC_ADDR16_HA reloc. */
1333
1334 static bfd_reloc_status_type
1335 ppc_elf_addr16_ha_reloc (abfd, reloc_entry, symbol, data, input_section,
1336 output_bfd, error_message)
1337 bfd *abfd ATTRIBUTE_UNUSED;
1338 arelent *reloc_entry;
1339 asymbol *symbol;
1340 PTR data ATTRIBUTE_UNUSED;
1341 asection *input_section;
1342 bfd *output_bfd;
1343 char **error_message ATTRIBUTE_UNUSED;
1344 {
1345 bfd_vma relocation;
1346
1347 if (output_bfd != NULL)
1348 {
1349 reloc_entry->address += input_section->output_offset;
1350 return bfd_reloc_ok;
1351 }
1352
1353 if (reloc_entry->address > input_section->_cooked_size)
1354 return bfd_reloc_outofrange;
1355
1356 if (bfd_is_com_section (symbol->section))
1357 relocation = 0;
1358 else
1359 relocation = symbol->value;
1360
1361 relocation += symbol->section->output_section->vma;
1362 relocation += symbol->section->output_offset;
1363 relocation += reloc_entry->addend;
1364
1365 reloc_entry->addend += (relocation & 0x8000) << 1;
1366
1367 return bfd_reloc_continue;
1368 }
1369
1370 /* Function to set whether a module needs the -mrelocatable bit set. */
1371
1372 static boolean
1373 ppc_elf_set_private_flags (abfd, flags)
1374 bfd *abfd;
1375 flagword flags;
1376 {
1377 BFD_ASSERT (!elf_flags_init (abfd)
1378 || elf_elfheader (abfd)->e_flags == flags);
1379
1380 elf_elfheader (abfd)->e_flags = flags;
1381 elf_flags_init (abfd) = true;
1382 return true;
1383 }
1384
1385 /* Copy backend specific data from one object module to another */
1386 static boolean
1387 ppc_elf_copy_private_bfd_data (ibfd, obfd)
1388 bfd *ibfd;
1389 bfd *obfd;
1390 {
1391 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1392 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1393 return true;
1394
1395 BFD_ASSERT (!elf_flags_init (obfd)
1396 || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
1397
1398 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
1399 elf_flags_init (obfd) = true;
1400 return true;
1401 }
1402
1403 /* Merge backend specific data from an object file to the output
1404 object file when linking */
1405 static boolean
1406 ppc_elf_merge_private_bfd_data (ibfd, obfd)
1407 bfd *ibfd;
1408 bfd *obfd;
1409 {
1410 flagword old_flags;
1411 flagword new_flags;
1412 boolean error;
1413
1414 /* Check if we have the same endianess */
1415 if (_bfd_generic_verify_endian_match (ibfd, obfd) == false)
1416 return false;
1417
1418 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1419 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1420 return true;
1421
1422 new_flags = elf_elfheader (ibfd)->e_flags;
1423 old_flags = elf_elfheader (obfd)->e_flags;
1424 if (!elf_flags_init (obfd)) /* First call, no flags set */
1425 {
1426 elf_flags_init (obfd) = true;
1427 elf_elfheader (obfd)->e_flags = new_flags;
1428 }
1429
1430 else if (new_flags == old_flags) /* Compatible flags are ok */
1431 ;
1432
1433 else /* Incompatible flags */
1434 {
1435 /* Warn about -mrelocatable mismatch. Allow -mrelocatable-lib to be linked
1436 with either. */
1437 error = false;
1438 if ((new_flags & EF_PPC_RELOCATABLE) != 0
1439 && (old_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0)
1440 {
1441 error = true;
1442 (*_bfd_error_handler)
1443 (_("%s: compiled with -mrelocatable and linked with modules compiled normally"),
1444 bfd_get_filename (ibfd));
1445 }
1446 else if ((new_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0
1447 && (old_flags & EF_PPC_RELOCATABLE) != 0)
1448 {
1449 error = true;
1450 (*_bfd_error_handler)
1451 (_("%s: compiled normally and linked with modules compiled with -mrelocatable"),
1452 bfd_get_filename (ibfd));
1453 }
1454
1455 /* The output is -mrelocatable-lib iff both the input files are. */
1456 if (! (new_flags & EF_PPC_RELOCATABLE_LIB))
1457 elf_elfheader (obfd)->e_flags &= ~EF_PPC_RELOCATABLE_LIB;
1458
1459 /* The output is -mrelocatable iff it can't be -mrelocatable-lib,
1460 but each input file is either -mrelocatable or -mrelocatable-lib. */
1461 if (! (elf_elfheader (obfd)->e_flags & EF_PPC_RELOCATABLE_LIB)
1462 && (new_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE))
1463 && (old_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE)))
1464 elf_elfheader (obfd)->e_flags |= EF_PPC_RELOCATABLE;
1465
1466 /* Do not warn about eabi vs. V.4 mismatch, just or in the bit if any module uses it */
1467 elf_elfheader (obfd)->e_flags |= (new_flags & EF_PPC_EMB);
1468
1469 new_flags &= ~ (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB);
1470 old_flags &= ~ (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB);
1471
1472 /* Warn about any other mismatches */
1473 if (new_flags != old_flags)
1474 {
1475 error = true;
1476 (*_bfd_error_handler)
1477 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
1478 bfd_get_filename (ibfd), (long) new_flags, (long) old_flags);
1479 }
1480
1481 if (error)
1482 {
1483 bfd_set_error (bfd_error_bad_value);
1484 return false;
1485 }
1486 }
1487
1488 return true;
1489 }
1490 \f
1491 /* Handle a PowerPC specific section when reading an object file. This
1492 is called when elfcode.h finds a section with an unknown type. */
1493
1494 static boolean
1495 ppc_elf_section_from_shdr (abfd, hdr, name)
1496 bfd *abfd;
1497 Elf32_Internal_Shdr *hdr;
1498 char *name;
1499 {
1500 asection *newsect;
1501 flagword flags;
1502
1503 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1504 return false;
1505
1506 newsect = hdr->bfd_section;
1507 flags = bfd_get_section_flags (abfd, newsect);
1508 if (hdr->sh_flags & SHF_EXCLUDE)
1509 flags |= SEC_EXCLUDE;
1510
1511 if (hdr->sh_type == SHT_ORDERED)
1512 flags |= SEC_SORT_ENTRIES;
1513
1514 bfd_set_section_flags (abfd, newsect, flags);
1515 return true;
1516 }
1517 \f
1518 /* Set up any other section flags and such that may be necessary. */
1519
1520 static boolean
1521 ppc_elf_fake_sections (abfd, shdr, asect)
1522 bfd *abfd ATTRIBUTE_UNUSED;
1523 Elf32_Internal_Shdr *shdr;
1524 asection *asect;
1525 {
1526 if ((asect->flags & SEC_EXCLUDE) != 0)
1527 shdr->sh_flags |= SHF_EXCLUDE;
1528
1529 if ((asect->flags & SEC_SORT_ENTRIES) != 0)
1530 shdr->sh_type = SHT_ORDERED;
1531
1532 return true;
1533 }
1534 \f
1535 /* Create a special linker section */
1536 static elf_linker_section_t *
1537 ppc_elf_create_linker_section (abfd, info, which)
1538 bfd *abfd;
1539 struct bfd_link_info *info;
1540 enum elf_linker_section_enum which;
1541 {
1542 bfd *dynobj = elf_hash_table (info)->dynobj;
1543 elf_linker_section_t *lsect;
1544
1545 /* Record the first bfd section that needs the special section */
1546 if (!dynobj)
1547 dynobj = elf_hash_table (info)->dynobj = abfd;
1548
1549 /* If this is the first time, create the section */
1550 lsect = elf_linker_section (dynobj, which);
1551 if (!lsect)
1552 {
1553 elf_linker_section_t defaults;
1554 static elf_linker_section_t zero_section;
1555
1556 defaults = zero_section;
1557 defaults.which = which;
1558 defaults.hole_written_p = false;
1559 defaults.alignment = 2;
1560
1561 /* Both of these sections are (technically) created by the user
1562 putting data in them, so they shouldn't be marked
1563 SEC_LINKER_CREATED.
1564
1565 The linker creates them so it has somewhere to attach their
1566 respective symbols. In fact, if they were empty it would
1567 be OK to leave the symbol set to 0 (or any random number), because
1568 the appropriate register should never be used. */
1569 defaults.flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
1570 | SEC_IN_MEMORY);
1571
1572 switch (which)
1573 {
1574 default:
1575 (*_bfd_error_handler) (_("%s: Unknown special linker type %d"),
1576 bfd_get_filename (abfd),
1577 (int) which);
1578
1579 bfd_set_error (bfd_error_bad_value);
1580 return (elf_linker_section_t *) 0;
1581
1582 case LINKER_SECTION_SDATA: /* .sdata/.sbss section */
1583 defaults.name = ".sdata";
1584 defaults.rel_name = ".rela.sdata";
1585 defaults.bss_name = ".sbss";
1586 defaults.sym_name = "_SDA_BASE_";
1587 defaults.sym_offset = 32768;
1588 break;
1589
1590 case LINKER_SECTION_SDATA2: /* .sdata2/.sbss2 section */
1591 defaults.name = ".sdata2";
1592 defaults.rel_name = ".rela.sdata2";
1593 defaults.bss_name = ".sbss2";
1594 defaults.sym_name = "_SDA2_BASE_";
1595 defaults.sym_offset = 32768;
1596 defaults.flags |= SEC_READONLY;
1597 break;
1598 }
1599
1600 lsect = _bfd_elf_create_linker_section (abfd, info, which, &defaults);
1601 }
1602
1603 return lsect;
1604 }
1605 \f
1606 /* If we have a non-zero sized .sbss2 or .PPC.EMB.sbss0 sections, we
1607 need to bump up the number of section headers. */
1608
1609 static int
1610 ppc_elf_additional_program_headers (abfd)
1611 bfd *abfd;
1612 {
1613 asection *s;
1614 int ret;
1615
1616 ret = 0;
1617
1618 s = bfd_get_section_by_name (abfd, ".interp");
1619 if (s != NULL)
1620 ++ret;
1621
1622 s = bfd_get_section_by_name (abfd, ".sbss2");
1623 if (s != NULL && (s->flags & SEC_LOAD) != 0 && s->_raw_size > 0)
1624 ++ret;
1625
1626 s = bfd_get_section_by_name (abfd, ".PPC.EMB.sbss0");
1627 if (s != NULL && (s->flags & SEC_LOAD) != 0 && s->_raw_size > 0)
1628 ++ret;
1629
1630 return ret;
1631 }
1632
1633 /* Modify the segment map if needed. */
1634
1635 static boolean
1636 ppc_elf_modify_segment_map (abfd)
1637 bfd *abfd ATTRIBUTE_UNUSED;
1638 {
1639 return true;
1640 }
1641 \f
1642 /* We have to create .dynsbss and .rela.sbss here so that they get mapped
1643 to output sections (just like _bfd_elf_create_dynamic_sections has
1644 to create .dynbss and .rela.bss). */
1645
1646 static boolean
1647 ppc_elf_create_dynamic_sections (abfd, info)
1648 bfd *abfd;
1649 struct bfd_link_info *info;
1650 {
1651 register asection *s;
1652 flagword flags;
1653
1654 if (!_bfd_elf_create_dynamic_sections (abfd, info))
1655 return false;
1656
1657 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1658 | SEC_LINKER_CREATED);
1659
1660 s = bfd_make_section (abfd, ".dynsbss");
1661 if (s == NULL
1662 || ! bfd_set_section_flags (abfd, s, SEC_ALLOC))
1663 return false;
1664
1665 if (! info->shared)
1666 {
1667 s = bfd_make_section (abfd, ".rela.sbss");
1668 if (s == NULL
1669 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
1670 || ! bfd_set_section_alignment (abfd, s, 2))
1671 return false;
1672 }
1673 return true;
1674 }
1675
1676 /* Adjust a symbol defined by a dynamic object and referenced by a
1677 regular object. The current definition is in some section of the
1678 dynamic object, but we're not including those sections. We have to
1679 change the definition to something the rest of the link can
1680 understand. */
1681
1682 static boolean
1683 ppc_elf_adjust_dynamic_symbol (info, h)
1684 struct bfd_link_info *info;
1685 struct elf_link_hash_entry *h;
1686 {
1687 bfd *dynobj = elf_hash_table (info)->dynobj;
1688 asection *s;
1689 unsigned int power_of_two;
1690 bfd_vma plt_offset;
1691
1692 #ifdef DEBUG
1693 fprintf (stderr, "ppc_elf_adjust_dynamic_symbol called for %s\n", h->root.root.string);
1694 #endif
1695
1696 /* Make sure we know what is going on here. */
1697 BFD_ASSERT (dynobj != NULL
1698 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
1699 || h->weakdef != NULL
1700 || ((h->elf_link_hash_flags
1701 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1702 && (h->elf_link_hash_flags
1703 & ELF_LINK_HASH_REF_REGULAR) != 0
1704 && (h->elf_link_hash_flags
1705 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
1706
1707 /* If this is a function, put it in the procedure linkage table. We
1708 will fill in the contents of the procedure linkage table later,
1709 when we know the address of the .got section. */
1710 if (h->type == STT_FUNC
1711 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
1712 {
1713 if (! elf_hash_table (info)->dynamic_sections_created
1714 || SYMBOL_CALLS_LOCAL (info, h)
1715 || (info->shared && h->plt.refcount <= 0))
1716 {
1717 /* A PLT entry is not required/allowed when:
1718
1719 1. We are not using ld.so; because then the PLT entry
1720 can't be set up, so we can't use one.
1721
1722 2. We know for certain that a call to this symbol
1723 will go to this object.
1724
1725 3. GC has rendered the entry unused.
1726 Note, however, that in an executable all references to the
1727 symbol go to the PLT, so we can't turn it off in that case.
1728 ??? The correct thing to do here is to reference count
1729 all uses of the symbol, not just those to the GOT or PLT. */
1730 h->plt.offset = (bfd_vma) -1;
1731 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1732 return true;
1733 }
1734
1735 /* Make sure this symbol is output as a dynamic symbol. */
1736 if (h->dynindx == -1)
1737 {
1738 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1739 return false;
1740 }
1741 BFD_ASSERT (h->dynindx != -1);
1742
1743 s = bfd_get_section_by_name (dynobj, ".plt");
1744 BFD_ASSERT (s != NULL);
1745
1746 /* If this is the first .plt entry, make room for the special
1747 first entry. */
1748 if (s->_raw_size == 0)
1749 s->_raw_size += PLT_INITIAL_ENTRY_SIZE;
1750
1751 /* The PowerPC PLT is actually composed of two parts, the first part
1752 is 2 words (for a load and a jump), and then there is a remaining
1753 word available at the end. */
1754 plt_offset = (PLT_INITIAL_ENTRY_SIZE
1755 + (PLT_SLOT_SIZE
1756 * ((s->_raw_size - PLT_INITIAL_ENTRY_SIZE)
1757 / PLT_ENTRY_SIZE)));
1758
1759 /* If this symbol is not defined in a regular file, and we are
1760 not generating a shared library, then set the symbol to this
1761 location in the .plt. This is required to make function
1762 pointers compare as equal between the normal executable and
1763 the shared library. */
1764 if (! info->shared
1765 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1766 {
1767 h->root.u.def.section = s;
1768 h->root.u.def.value = plt_offset;
1769 }
1770
1771 h->plt.offset = plt_offset;
1772
1773 /* Make room for this entry. After the 8192nd entry, room
1774 for two entries is allocated. */
1775 if ((s->_raw_size - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE
1776 >= PLT_NUM_SINGLE_ENTRIES)
1777 s->_raw_size += 2 * PLT_ENTRY_SIZE;
1778 else
1779 s->_raw_size += PLT_ENTRY_SIZE;
1780
1781 /* We also need to make an entry in the .rela.plt section. */
1782 s = bfd_get_section_by_name (dynobj, ".rela.plt");
1783 BFD_ASSERT (s != NULL);
1784 s->_raw_size += sizeof (Elf32_External_Rela);
1785
1786 return true;
1787 }
1788
1789 /* If this is a weak symbol, and there is a real definition, the
1790 processor independent code will have arranged for us to see the
1791 real definition first, and we can just use the same value. */
1792 if (h->weakdef != NULL)
1793 {
1794 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1795 || h->weakdef->root.type == bfd_link_hash_defweak);
1796 h->root.u.def.section = h->weakdef->root.u.def.section;
1797 h->root.u.def.value = h->weakdef->root.u.def.value;
1798 return true;
1799 }
1800
1801 /* This is a reference to a symbol defined by a dynamic object which
1802 is not a function. */
1803
1804 /* If we are creating a shared library, we must presume that the
1805 only references to the symbol are via the global offset table.
1806 For such cases we need not do anything here; the relocations will
1807 be handled correctly by relocate_section. */
1808 if (info->shared)
1809 return true;
1810
1811 /* We must allocate the symbol in our .dynbss section, which will
1812 become part of the .bss section of the executable. There will be
1813 an entry for this symbol in the .dynsym section. The dynamic
1814 object will contain position independent code, so all references
1815 from the dynamic object to this symbol will go through the global
1816 offset table. The dynamic linker will use the .dynsym entry to
1817 determine the address it must put in the global offset table, so
1818 both the dynamic object and the regular object will refer to the
1819 same memory location for the variable.
1820
1821 Of course, if the symbol is sufficiently small, we must instead
1822 allocate it in .sbss. FIXME: It would be better to do this if and
1823 only if there were actually SDAREL relocs for that symbol. */
1824
1825 if (h->size <= elf_gp_size (dynobj))
1826 s = bfd_get_section_by_name (dynobj, ".dynsbss");
1827 else
1828 s = bfd_get_section_by_name (dynobj, ".dynbss");
1829 BFD_ASSERT (s != NULL);
1830
1831 /* We must generate a R_PPC_COPY reloc to tell the dynamic linker to
1832 copy the initial value out of the dynamic object and into the
1833 runtime process image. We need to remember the offset into the
1834 .rela.bss section we are going to use. */
1835 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1836 {
1837 asection *srel;
1838
1839 if (h->size <= elf_gp_size (dynobj))
1840 srel = bfd_get_section_by_name (dynobj, ".rela.sbss");
1841 else
1842 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
1843 BFD_ASSERT (srel != NULL);
1844 srel->_raw_size += sizeof (Elf32_External_Rela);
1845 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1846 }
1847
1848 /* We need to figure out the alignment required for this symbol. I
1849 have no idea how ELF linkers handle this. */
1850 power_of_two = bfd_log2 (h->size);
1851 if (power_of_two > 4)
1852 power_of_two = 4;
1853
1854 /* Apply the required alignment. */
1855 s->_raw_size = BFD_ALIGN (s->_raw_size,
1856 (bfd_size_type) (1 << power_of_two));
1857 if (power_of_two > bfd_get_section_alignment (dynobj, s))
1858 {
1859 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
1860 return false;
1861 }
1862
1863 /* Define the symbol as being at this point in the section. */
1864 h->root.u.def.section = s;
1865 h->root.u.def.value = s->_raw_size;
1866
1867 /* Increment the section size to make room for the symbol. */
1868 s->_raw_size += h->size;
1869
1870 return true;
1871 }
1872 \f
1873 /* Set the sizes of the dynamic sections. */
1874
1875 static boolean
1876 ppc_elf_size_dynamic_sections (output_bfd, info)
1877 bfd *output_bfd;
1878 struct bfd_link_info *info;
1879 {
1880 bfd *dynobj;
1881 asection *s;
1882 boolean plt;
1883 boolean relocs;
1884 boolean reltext;
1885
1886 #ifdef DEBUG
1887 fprintf (stderr, "ppc_elf_size_dynamic_sections called\n");
1888 #endif
1889
1890 dynobj = elf_hash_table (info)->dynobj;
1891 BFD_ASSERT (dynobj != NULL);
1892
1893 if (elf_hash_table (info)->dynamic_sections_created)
1894 {
1895 /* Set the contents of the .interp section to the interpreter. */
1896 if (! info->shared)
1897 {
1898 s = bfd_get_section_by_name (dynobj, ".interp");
1899 BFD_ASSERT (s != NULL);
1900 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1901 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1902 }
1903 }
1904 else
1905 {
1906 /* We may have created entries in the .rela.got, .rela.sdata, and
1907 .rela.sdata2 sections. However, if we are not creating the
1908 dynamic sections, we will not actually use these entries. Reset
1909 the size of .rela.got, et al, which will cause it to get
1910 stripped from the output file below. */
1911 static char *rela_sections[] = { ".rela.got", ".rela.sdata",
1912 ".rela.sdata2", ".rela.sbss",
1913 (char *) 0 };
1914 char **p;
1915
1916 for (p = rela_sections; *p != (char *) 0; p++)
1917 {
1918 s = bfd_get_section_by_name (dynobj, *p);
1919 if (s != NULL)
1920 s->_raw_size = 0;
1921 }
1922 }
1923
1924 /* The check_relocs and adjust_dynamic_symbol entry points have
1925 determined the sizes of the various dynamic sections. Allocate
1926 memory for them. */
1927 plt = false;
1928 relocs = false;
1929 reltext = false;
1930 for (s = dynobj->sections; s != NULL; s = s->next)
1931 {
1932 const char *name;
1933 boolean strip;
1934
1935 if ((s->flags & SEC_LINKER_CREATED) == 0)
1936 continue;
1937
1938 /* It's OK to base decisions on the section name, because none
1939 of the dynobj section names depend upon the input files. */
1940 name = bfd_get_section_name (dynobj, s);
1941
1942 strip = false;
1943
1944 if (strcmp (name, ".plt") == 0)
1945 {
1946 if (s->_raw_size == 0)
1947 {
1948 /* Strip this section if we don't need it; see the
1949 comment below. */
1950 strip = true;
1951 }
1952 else
1953 {
1954 /* Remember whether there is a PLT. */
1955 plt = true;
1956 }
1957 }
1958 else if (strncmp (name, ".rela", 5) == 0)
1959 {
1960 if (s->_raw_size == 0)
1961 {
1962 /* If we don't need this section, strip it from the
1963 output file. This is mostly to handle .rela.bss and
1964 .rela.plt. We must create both sections in
1965 create_dynamic_sections, because they must be created
1966 before the linker maps input sections to output
1967 sections. The linker does that before
1968 adjust_dynamic_symbol is called, and it is that
1969 function which decides whether anything needs to go
1970 into these sections. */
1971 strip = true;
1972 }
1973 else
1974 {
1975 asection *target;
1976 const char *outname;
1977
1978 /* Remember whether there are any relocation sections. */
1979 relocs = true;
1980
1981 /* If this relocation section applies to a read only
1982 section, then we probably need a DT_TEXTREL entry. */
1983 outname = bfd_get_section_name (output_bfd,
1984 s->output_section);
1985 target = bfd_get_section_by_name (output_bfd, outname + 5);
1986 if (target != NULL
1987 && (target->flags & SEC_READONLY) != 0
1988 && (target->flags & SEC_ALLOC) != 0)
1989 reltext = true;
1990
1991 /* We use the reloc_count field as a counter if we need
1992 to copy relocs into the output file. */
1993 s->reloc_count = 0;
1994 }
1995 }
1996 else if (strcmp (name, ".got") != 0
1997 && strcmp (name, ".sdata") != 0
1998 && strcmp (name, ".sdata2") != 0)
1999 {
2000 /* It's not one of our sections, so don't allocate space. */
2001 continue;
2002 }
2003
2004 if (strip)
2005 {
2006 _bfd_strip_section_from_output (info, s);
2007 continue;
2008 }
2009
2010 /* Allocate memory for the section contents. */
2011 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
2012 if (s->contents == NULL && s->_raw_size != 0)
2013 return false;
2014 }
2015
2016 if (elf_hash_table (info)->dynamic_sections_created)
2017 {
2018 /* Add some entries to the .dynamic section. We fill in the
2019 values later, in ppc_elf_finish_dynamic_sections, but we
2020 must add the entries now so that we get the correct size for
2021 the .dynamic section. The DT_DEBUG entry is filled in by the
2022 dynamic linker and used by the debugger. */
2023 if (! info->shared)
2024 {
2025 if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
2026 return false;
2027 }
2028
2029 if (plt)
2030 {
2031 if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
2032 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
2033 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
2034 || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
2035 return false;
2036 }
2037
2038 if (relocs)
2039 {
2040 if (! bfd_elf32_add_dynamic_entry (info, DT_RELA, 0)
2041 || ! bfd_elf32_add_dynamic_entry (info, DT_RELASZ, 0)
2042 || ! bfd_elf32_add_dynamic_entry (info, DT_RELAENT,
2043 sizeof (Elf32_External_Rela)))
2044 return false;
2045 }
2046
2047 if (reltext)
2048 {
2049 if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
2050 return false;
2051 info->flags |= DF_TEXTREL;
2052 }
2053 }
2054
2055 return true;
2056 }
2057 \f
2058 /* Look through the relocs for a section during the first phase, and
2059 allocate space in the global offset table or procedure linkage
2060 table. */
2061
2062 static boolean
2063 ppc_elf_check_relocs (abfd, info, sec, relocs)
2064 bfd *abfd;
2065 struct bfd_link_info *info;
2066 asection *sec;
2067 const Elf_Internal_Rela *relocs;
2068 {
2069 bfd *dynobj;
2070 Elf_Internal_Shdr *symtab_hdr;
2071 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
2072 const Elf_Internal_Rela *rel;
2073 const Elf_Internal_Rela *rel_end;
2074 bfd_signed_vma *local_got_refcounts;
2075 elf_linker_section_t *sdata;
2076 elf_linker_section_t *sdata2;
2077 asection *sreloc;
2078 asection *sgot = NULL;
2079 asection *srelgot = NULL;
2080
2081 if (info->relocateable)
2082 return true;
2083
2084 #ifdef DEBUG
2085 fprintf (stderr, "ppc_elf_check_relocs called for section %s in %s\n",
2086 bfd_get_section_name (abfd, sec),
2087 bfd_get_filename (abfd));
2088 #endif
2089
2090 /* Create the linker generated sections all the time so that the
2091 special symbols are created. */
2092
2093 if ((sdata = elf_linker_section (abfd, LINKER_SECTION_SDATA)) == NULL)
2094 {
2095 sdata = ppc_elf_create_linker_section (abfd, info, LINKER_SECTION_SDATA);
2096 if (!sdata)
2097 return false;
2098 }
2099
2100 if ((sdata2 = elf_linker_section (abfd, LINKER_SECTION_SDATA2)) == NULL)
2101 {
2102 sdata2 = ppc_elf_create_linker_section (abfd, info, LINKER_SECTION_SDATA2);
2103 if (!sdata2)
2104 return false;
2105 }
2106
2107 dynobj = elf_hash_table (info)->dynobj;
2108 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2109 local_got_refcounts = elf_local_got_refcounts (abfd);
2110
2111 sym_hashes = elf_sym_hashes (abfd);
2112 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
2113 if (!elf_bad_symtab (abfd))
2114 sym_hashes_end -= symtab_hdr->sh_info;
2115
2116 sreloc = NULL;
2117
2118 rel_end = relocs + sec->reloc_count;
2119 for (rel = relocs; rel < rel_end; rel++)
2120 {
2121 unsigned long r_symndx;
2122 struct elf_link_hash_entry *h;
2123
2124 r_symndx = ELF32_R_SYM (rel->r_info);
2125 if (r_symndx < symtab_hdr->sh_info)
2126 h = NULL;
2127 else
2128 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2129
2130 /* If a relocation refers to _GLOBAL_OFFSET_TABLE_, create the .got.
2131 This shows up in particular in an R_PPC_ADDR32 in the eabi
2132 startup code. */
2133 if (h && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2134 {
2135 if (sgot == NULL)
2136 {
2137 if (dynobj == NULL)
2138 elf_hash_table (info)->dynobj = dynobj = abfd;
2139 if (! _bfd_elf_create_got_section (dynobj, info))
2140 return false;
2141 sgot = bfd_get_section_by_name (dynobj, ".got");
2142 BFD_ASSERT (sgot != NULL);
2143 }
2144 }
2145
2146 switch (ELF32_R_TYPE (rel->r_info))
2147 {
2148 /* GOT16 relocations */
2149 case R_PPC_GOT16:
2150 case R_PPC_GOT16_LO:
2151 case R_PPC_GOT16_HI:
2152 case R_PPC_GOT16_HA:
2153 /* This symbol requires a global offset table entry. */
2154
2155 if (sgot == NULL)
2156 {
2157 if (dynobj == NULL)
2158 elf_hash_table (info)->dynobj = dynobj = abfd;
2159 if (! _bfd_elf_create_got_section (dynobj, info))
2160 return false;
2161 sgot = bfd_get_section_by_name (dynobj, ".got");
2162 BFD_ASSERT (sgot != NULL);
2163 }
2164
2165 if (srelgot == NULL
2166 && (h != NULL || info->shared))
2167 {
2168 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2169 if (srelgot == NULL)
2170 {
2171 srelgot = bfd_make_section (dynobj, ".rela.got");
2172 if (srelgot == NULL
2173 || ! bfd_set_section_flags (dynobj, srelgot,
2174 (SEC_ALLOC
2175 | SEC_LOAD
2176 | SEC_HAS_CONTENTS
2177 | SEC_IN_MEMORY
2178 | SEC_LINKER_CREATED
2179 | SEC_READONLY))
2180 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
2181 return false;
2182 }
2183 }
2184
2185 if (h != NULL)
2186 {
2187 if (h->got.refcount == -1)
2188 {
2189 /* Make sure this symbol is output as a dynamic symbol. */
2190 if (h->dynindx == -1)
2191 if (!bfd_elf32_link_record_dynamic_symbol (info, h))
2192 return false;
2193
2194 /* Allocate space in the .got. */
2195 sgot->_raw_size += 4;
2196 /* Allocate relocation space. */
2197 srelgot->_raw_size += sizeof (Elf32_External_Rela);
2198
2199 h->got.refcount = 1;
2200 }
2201 else
2202 h->got.refcount++;
2203 }
2204 else
2205 {
2206 /* This is a global offset table entry for a local symbol. */
2207 if (local_got_refcounts == NULL)
2208 {
2209 size_t size;
2210
2211 size = symtab_hdr->sh_info * sizeof (bfd_signed_vma);
2212 local_got_refcounts = (bfd_signed_vma *)
2213 bfd_alloc (abfd, size);
2214 if (local_got_refcounts == NULL)
2215 return false;
2216 elf_local_got_refcounts (abfd) = local_got_refcounts;
2217 memset (local_got_refcounts, -1, size);
2218 }
2219 if (local_got_refcounts[r_symndx] == -1)
2220 {
2221 sgot->_raw_size += 4;
2222
2223 /* If we are generating a shared object, we need to
2224 output a R_PPC_RELATIVE reloc so that the
2225 dynamic linker can adjust this GOT entry. */
2226 if (info->shared)
2227 srelgot->_raw_size += sizeof (Elf32_External_Rela);
2228
2229 local_got_refcounts[r_symndx] = 1;
2230 }
2231 else
2232 local_got_refcounts[r_symndx]++;
2233 }
2234 break;
2235
2236 /* Indirect .sdata relocation */
2237 case R_PPC_EMB_SDAI16:
2238 if (info->shared)
2239 {
2240 ((*_bfd_error_handler)
2241 (_("%s: relocation %s cannot be used when making a shared object"),
2242 bfd_get_filename (abfd), "R_PPC_EMB_SDAI16"));
2243 return false;
2244 }
2245
2246 if (srelgot == NULL && (h != NULL || info->shared))
2247 {
2248 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2249 if (srelgot == NULL)
2250 {
2251 srelgot = bfd_make_section (dynobj, ".rela.got");
2252 if (srelgot == NULL
2253 || ! bfd_set_section_flags (dynobj, srelgot,
2254 (SEC_ALLOC
2255 | SEC_LOAD
2256 | SEC_HAS_CONTENTS
2257 | SEC_IN_MEMORY
2258 | SEC_LINKER_CREATED
2259 | SEC_READONLY))
2260 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
2261 return false;
2262 }
2263 }
2264
2265 if (!bfd_elf32_create_pointer_linker_section (abfd, info, sdata, h, rel))
2266 return false;
2267
2268 break;
2269
2270 /* Indirect .sdata2 relocation */
2271 case R_PPC_EMB_SDA2I16:
2272 if (info->shared)
2273 {
2274 ((*_bfd_error_handler)
2275 (_("%s: relocation %s cannot be used when making a shared object"),
2276 bfd_get_filename (abfd), "R_PPC_EMB_SDA2I16"));
2277 return false;
2278 }
2279
2280 if (srelgot == NULL && (h != NULL || info->shared))
2281 {
2282 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2283 if (srelgot == NULL)
2284 {
2285 srelgot = bfd_make_section (dynobj, ".rela.got");
2286 if (srelgot == NULL
2287 || ! bfd_set_section_flags (dynobj, srelgot,
2288 (SEC_ALLOC
2289 | SEC_LOAD
2290 | SEC_HAS_CONTENTS
2291 | SEC_IN_MEMORY
2292 | SEC_LINKER_CREATED
2293 | SEC_READONLY))
2294 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
2295 return false;
2296 }
2297 }
2298
2299 if (!bfd_elf32_create_pointer_linker_section (abfd, info, sdata2, h, rel))
2300 return false;
2301
2302 break;
2303
2304 case R_PPC_SDAREL16:
2305 case R_PPC_EMB_SDA2REL:
2306 case R_PPC_EMB_SDA21:
2307 if (info->shared)
2308 {
2309 ((*_bfd_error_handler)
2310 (_("%s: relocation %s cannot be used when making a shared object"),
2311 bfd_get_filename (abfd),
2312 ppc_elf_howto_table[(int) ELF32_R_TYPE (rel->r_info)]->name));
2313 return false;
2314 }
2315 break;
2316
2317 case R_PPC_PLT32:
2318 case R_PPC_PLTREL24:
2319 case R_PPC_PLT16_LO:
2320 case R_PPC_PLT16_HI:
2321 case R_PPC_PLT16_HA:
2322 #ifdef DEBUG
2323 fprintf (stderr, "Reloc requires a PLT entry\n");
2324 #endif
2325 /* This symbol requires a procedure linkage table entry. We
2326 actually build the entry in adjust_dynamic_symbol,
2327 because this might be a case of linking PIC code without
2328 linking in any dynamic objects, in which case we don't
2329 need to generate a procedure linkage table after all. */
2330
2331 if (h == NULL)
2332 {
2333 /* It does not make sense to have a procedure linkage
2334 table entry for a local symbol. */
2335 bfd_set_error (bfd_error_bad_value);
2336 return false;
2337 }
2338
2339 /* Make sure this symbol is output as a dynamic symbol. */
2340 if (h->dynindx == -1)
2341 {
2342 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2343 return false;
2344 }
2345 if (h->plt.refcount == -1)
2346 {
2347 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2348 h->plt.refcount = 1;
2349 }
2350 else
2351 h->plt.refcount++;
2352 break;
2353
2354 /* The following relocations don't need to propagate the
2355 relocation if linking a shared object since they are
2356 section relative. */
2357 case R_PPC_SECTOFF:
2358 case R_PPC_SECTOFF_LO:
2359 case R_PPC_SECTOFF_HI:
2360 case R_PPC_SECTOFF_HA:
2361 break;
2362
2363 /* This refers only to functions defined in the shared library */
2364 case R_PPC_LOCAL24PC:
2365 break;
2366
2367 /* This relocation describes the C++ object vtable hierarchy.
2368 Reconstruct it for later use during GC. */
2369 case R_PPC_GNU_VTINHERIT:
2370 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2371 return false;
2372 break;
2373
2374 /* This relocation describes which C++ vtable entries are actually
2375 used. Record for later use during GC. */
2376 case R_PPC_GNU_VTENTRY:
2377 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2378 return false;
2379 break;
2380
2381 /* When creating a shared object, we must copy these
2382 relocs into the output file. We create a reloc
2383 section in dynobj and make room for the reloc. */
2384 case R_PPC_REL24:
2385 case R_PPC_REL14:
2386 case R_PPC_REL14_BRTAKEN:
2387 case R_PPC_REL14_BRNTAKEN:
2388 case R_PPC_REL32:
2389 if (h == NULL
2390 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
2391 || SYMBOL_REFERENCES_LOCAL (info, h))
2392 break;
2393 /* fall through */
2394
2395 default:
2396 if (info->shared)
2397 {
2398 #ifdef DEBUG
2399 fprintf (stderr, "ppc_elf_check_relocs need to create relocation for %s\n",
2400 (h && h->root.root.string) ? h->root.root.string : "<unknown>");
2401 #endif
2402 if (sreloc == NULL)
2403 {
2404 const char *name;
2405
2406 name = (bfd_elf_string_from_elf_section
2407 (abfd,
2408 elf_elfheader (abfd)->e_shstrndx,
2409 elf_section_data (sec)->rel_hdr.sh_name));
2410 if (name == NULL)
2411 return false;
2412
2413 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
2414 && strcmp (bfd_get_section_name (abfd, sec),
2415 name + 5) == 0);
2416
2417 sreloc = bfd_get_section_by_name (dynobj, name);
2418 if (sreloc == NULL)
2419 {
2420 flagword flags;
2421
2422 sreloc = bfd_make_section (dynobj, name);
2423 flags = (SEC_HAS_CONTENTS | SEC_READONLY
2424 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2425 if ((sec->flags & SEC_ALLOC) != 0)
2426 flags |= SEC_ALLOC | SEC_LOAD;
2427 if (sreloc == NULL
2428 || ! bfd_set_section_flags (dynobj, sreloc, flags)
2429 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
2430 return false;
2431 }
2432 }
2433
2434 sreloc->_raw_size += sizeof (Elf32_External_Rela);
2435
2436 /* FIXME: We should here do what the m68k and i386
2437 backends do: if the reloc is pc-relative, record it
2438 in case it turns out that the reloc is unnecessary
2439 because the symbol is forced local by versioning or
2440 we are linking with -Bdynamic. Fortunately this
2441 case is not frequent. */
2442 }
2443
2444 break;
2445 }
2446 }
2447
2448 return true;
2449 }
2450
2451 /* Return the section that should be marked against GC for a given
2452 relocation. */
2453
2454 static asection *
2455 ppc_elf_gc_mark_hook (abfd, info, rel, h, sym)
2456 bfd *abfd;
2457 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2458 Elf_Internal_Rela *rel;
2459 struct elf_link_hash_entry *h;
2460 Elf_Internal_Sym *sym;
2461 {
2462 if (h != NULL)
2463 {
2464 switch (ELF32_R_TYPE (rel->r_info))
2465 {
2466 case R_PPC_GNU_VTINHERIT:
2467 case R_PPC_GNU_VTENTRY:
2468 break;
2469
2470 default:
2471 switch (h->root.type)
2472 {
2473 case bfd_link_hash_defined:
2474 case bfd_link_hash_defweak:
2475 return h->root.u.def.section;
2476
2477 case bfd_link_hash_common:
2478 return h->root.u.c.p->section;
2479
2480 default:
2481 break;
2482 }
2483 }
2484 }
2485 else
2486 {
2487 if (!(elf_bad_symtab (abfd)
2488 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
2489 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
2490 && sym->st_shndx != SHN_COMMON))
2491 {
2492 return bfd_section_from_elf_index (abfd, sym->st_shndx);
2493 }
2494 }
2495
2496 return NULL;
2497 }
2498
2499 /* Update the got entry reference counts for the section being removed. */
2500
2501 static boolean
2502 ppc_elf_gc_sweep_hook (abfd, info, sec, relocs)
2503 bfd *abfd;
2504 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2505 asection *sec;
2506 const Elf_Internal_Rela *relocs;
2507 {
2508 Elf_Internal_Shdr *symtab_hdr;
2509 struct elf_link_hash_entry **sym_hashes;
2510 bfd_signed_vma *local_got_refcounts;
2511 const Elf_Internal_Rela *rel, *relend;
2512 unsigned long r_symndx;
2513 struct elf_link_hash_entry *h;
2514
2515 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2516 sym_hashes = elf_sym_hashes (abfd);
2517 local_got_refcounts = elf_local_got_refcounts (abfd);
2518
2519 relend = relocs + sec->reloc_count;
2520 for (rel = relocs; rel < relend; rel++)
2521 switch (ELF32_R_TYPE (rel->r_info))
2522 {
2523 case R_PPC_GOT16:
2524 case R_PPC_GOT16_LO:
2525 case R_PPC_GOT16_HI:
2526 case R_PPC_GOT16_HA:
2527 r_symndx = ELF32_R_SYM (rel->r_info);
2528 if (r_symndx >= symtab_hdr->sh_info)
2529 {
2530 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2531 if (h->got.refcount > 0)
2532 h->got.refcount--;
2533 }
2534 else if (local_got_refcounts != NULL)
2535 {
2536 if (local_got_refcounts[r_symndx] > 0)
2537 local_got_refcounts[r_symndx]--;
2538 }
2539 break;
2540
2541 case R_PPC_PLT32:
2542 case R_PPC_PLTREL24:
2543 case R_PPC_PLT16_LO:
2544 case R_PPC_PLT16_HI:
2545 case R_PPC_PLT16_HA:
2546 r_symndx = ELF32_R_SYM (rel->r_info);
2547 if (r_symndx >= symtab_hdr->sh_info)
2548 {
2549 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2550 if (h->plt.refcount > 0)
2551 h->plt.refcount--;
2552 }
2553 break;
2554
2555 default:
2556 break;
2557 }
2558
2559 return true;
2560 }
2561 \f
2562 /* Hook called by the linker routine which adds symbols from an object
2563 file. We use it to put .comm items in .sbss, and not .bss. */
2564
2565 static boolean
2566 ppc_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
2567 bfd *abfd;
2568 struct bfd_link_info *info;
2569 const Elf_Internal_Sym *sym;
2570 const char **namep ATTRIBUTE_UNUSED;
2571 flagword *flagsp ATTRIBUTE_UNUSED;
2572 asection **secp;
2573 bfd_vma *valp;
2574 {
2575 if (sym->st_shndx == SHN_COMMON
2576 && !info->relocateable
2577 && sym->st_size <= (bfd_vma) bfd_get_gp_size (abfd))
2578 {
2579 /* Common symbols less than or equal to -G nn bytes are automatically
2580 put into .sdata. */
2581 elf_linker_section_t *sdata
2582 = ppc_elf_create_linker_section (abfd, info, LINKER_SECTION_SDATA);
2583
2584 if (!sdata->bss_section)
2585 {
2586 /* We don't go through bfd_make_section, because we don't
2587 want to attach this common section to DYNOBJ. The linker
2588 will move the symbols to the appropriate output section
2589 when it defines common symbols. */
2590 sdata->bss_section = ((asection *)
2591 bfd_zalloc (abfd, sizeof (asection)));
2592 if (sdata->bss_section == NULL)
2593 return false;
2594 sdata->bss_section->name = sdata->bss_name;
2595 sdata->bss_section->flags = SEC_IS_COMMON;
2596 sdata->bss_section->output_section = sdata->bss_section;
2597 sdata->bss_section->symbol =
2598 (asymbol *) bfd_zalloc (abfd, sizeof (asymbol));
2599 sdata->bss_section->symbol_ptr_ptr =
2600 (asymbol **) bfd_zalloc (abfd, sizeof (asymbol *));
2601 if (sdata->bss_section->symbol == NULL
2602 || sdata->bss_section->symbol_ptr_ptr == NULL)
2603 return false;
2604 sdata->bss_section->symbol->name = sdata->bss_name;
2605 sdata->bss_section->symbol->flags = BSF_SECTION_SYM;
2606 sdata->bss_section->symbol->section = sdata->bss_section;
2607 *sdata->bss_section->symbol_ptr_ptr = sdata->bss_section->symbol;
2608 }
2609
2610 *secp = sdata->bss_section;
2611 *valp = sym->st_size;
2612 }
2613
2614 return true;
2615 }
2616 \f
2617 /* Finish up dynamic symbol handling. We set the contents of various
2618 dynamic sections here. */
2619
2620 static boolean
2621 ppc_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
2622 bfd *output_bfd;
2623 struct bfd_link_info *info;
2624 struct elf_link_hash_entry *h;
2625 Elf_Internal_Sym *sym;
2626 {
2627 bfd *dynobj;
2628
2629 #ifdef DEBUG
2630 fprintf (stderr, "ppc_elf_finish_dynamic_symbol called for %s",
2631 h->root.root.string);
2632 #endif
2633
2634 dynobj = elf_hash_table (info)->dynobj;
2635 BFD_ASSERT (dynobj != NULL);
2636
2637 if (h->plt.offset != (bfd_vma) -1)
2638 {
2639 asection *splt;
2640 asection *srela;
2641 Elf_Internal_Rela rela;
2642 bfd_vma reloc_index;
2643
2644 #ifdef DEBUG
2645 fprintf (stderr, ", plt_offset = %d", h->plt.offset);
2646 #endif
2647
2648 /* This symbol has an entry in the procedure linkage table. Set
2649 it up. */
2650
2651 BFD_ASSERT (h->dynindx != -1);
2652
2653 splt = bfd_get_section_by_name (dynobj, ".plt");
2654 srela = bfd_get_section_by_name (dynobj, ".rela.plt");
2655 BFD_ASSERT (splt != NULL && srela != NULL);
2656
2657 /* We don't need to fill in the .plt. The ppc dynamic linker
2658 will fill it in. */
2659
2660 /* Fill in the entry in the .rela.plt section. */
2661 rela.r_offset = (splt->output_section->vma
2662 + splt->output_offset
2663 + h->plt.offset);
2664 rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_JMP_SLOT);
2665 rela.r_addend = 0;
2666
2667 reloc_index = (h->plt.offset - PLT_INITIAL_ENTRY_SIZE) / PLT_SLOT_SIZE;
2668 if (reloc_index > PLT_NUM_SINGLE_ENTRIES)
2669 reloc_index -= (reloc_index - PLT_NUM_SINGLE_ENTRIES) / 2;
2670 bfd_elf32_swap_reloca_out (output_bfd, &rela,
2671 ((Elf32_External_Rela *) srela->contents
2672 + reloc_index));
2673
2674 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2675 {
2676 /* Mark the symbol as undefined, rather than as defined in
2677 the .plt section. Leave the value alone. */
2678 sym->st_shndx = SHN_UNDEF;
2679 /* If the symbol is weak, we do need to clear the value.
2680 Otherwise, the PLT entry would provide a definition for
2681 the symbol even if the symbol wasn't defined anywhere,
2682 and so the symbol would never be NULL. */
2683 if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
2684 == 0)
2685 sym->st_value = 0;
2686 }
2687 }
2688
2689 if (h->got.offset != (bfd_vma) -1)
2690 {
2691 asection *sgot;
2692 asection *srela;
2693 Elf_Internal_Rela rela;
2694
2695 /* This symbol has an entry in the global offset table. Set it
2696 up. */
2697
2698 sgot = bfd_get_section_by_name (dynobj, ".got");
2699 srela = bfd_get_section_by_name (dynobj, ".rela.got");
2700 BFD_ASSERT (sgot != NULL && srela != NULL);
2701
2702 rela.r_offset = (sgot->output_section->vma
2703 + sgot->output_offset
2704 + (h->got.offset &~ 1));
2705
2706 /* If this is a -Bsymbolic link, and the symbol is defined
2707 locally, we just want to emit a RELATIVE reloc. The entry in
2708 the global offset table will already have been initialized in
2709 the relocate_section function. */
2710 if (info->shared
2711 && SYMBOL_REFERENCES_LOCAL (info, h))
2712 {
2713 rela.r_info = ELF32_R_INFO (0, R_PPC_RELATIVE);
2714 rela.r_addend = (h->root.u.def.value
2715 + h->root.u.def.section->output_section->vma
2716 + h->root.u.def.section->output_offset);
2717 }
2718 else
2719 {
2720 BFD_ASSERT ((h->got.offset & 1) == 0);
2721 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
2722 rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_GLOB_DAT);
2723 rela.r_addend = 0;
2724 }
2725
2726 bfd_elf32_swap_reloca_out (output_bfd, &rela,
2727 ((Elf32_External_Rela *) srela->contents
2728 + srela->reloc_count));
2729 ++srela->reloc_count;
2730 }
2731
2732 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
2733 {
2734 asection *s;
2735 Elf_Internal_Rela rela;
2736
2737 /* This symbols needs a copy reloc. Set it up. */
2738
2739 #ifdef DEBUG
2740 fprintf (stderr, ", copy");
2741 #endif
2742
2743 BFD_ASSERT (h->dynindx != -1);
2744
2745 if (h->size <= elf_gp_size (dynobj))
2746 s = bfd_get_section_by_name (h->root.u.def.section->owner,
2747 ".rela.sbss");
2748 else
2749 s = bfd_get_section_by_name (h->root.u.def.section->owner,
2750 ".rela.bss");
2751 BFD_ASSERT (s != NULL);
2752
2753 rela.r_offset = (h->root.u.def.value
2754 + h->root.u.def.section->output_section->vma
2755 + h->root.u.def.section->output_offset);
2756 rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_COPY);
2757 rela.r_addend = 0;
2758 bfd_elf32_swap_reloca_out (output_bfd, &rela,
2759 ((Elf32_External_Rela *) s->contents
2760 + s->reloc_count));
2761 ++s->reloc_count;
2762 }
2763
2764 #ifdef DEBUG
2765 fprintf (stderr, "\n");
2766 #endif
2767
2768 /* Mark some specially defined symbols as absolute. */
2769 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2770 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
2771 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
2772 sym->st_shndx = SHN_ABS;
2773
2774 return true;
2775 }
2776 \f
2777 /* Finish up the dynamic sections. */
2778
2779 static boolean
2780 ppc_elf_finish_dynamic_sections (output_bfd, info)
2781 bfd *output_bfd;
2782 struct bfd_link_info *info;
2783 {
2784 asection *sdyn;
2785 bfd *dynobj = elf_hash_table (info)->dynobj;
2786 asection *sgot = bfd_get_section_by_name (dynobj, ".got");
2787
2788 #ifdef DEBUG
2789 fprintf (stderr, "ppc_elf_finish_dynamic_sections called\n");
2790 #endif
2791
2792 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2793
2794 if (elf_hash_table (info)->dynamic_sections_created)
2795 {
2796 asection *splt;
2797 Elf32_External_Dyn *dyncon, *dynconend;
2798
2799 splt = bfd_get_section_by_name (dynobj, ".plt");
2800 BFD_ASSERT (splt != NULL && sdyn != NULL);
2801
2802 dyncon = (Elf32_External_Dyn *) sdyn->contents;
2803 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
2804 for (; dyncon < dynconend; dyncon++)
2805 {
2806 Elf_Internal_Dyn dyn;
2807 const char *name;
2808 boolean size;
2809
2810 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2811
2812 switch (dyn.d_tag)
2813 {
2814 case DT_PLTGOT: name = ".plt"; size = false; break;
2815 case DT_PLTRELSZ: name = ".rela.plt"; size = true; break;
2816 case DT_JMPREL: name = ".rela.plt"; size = false; break;
2817 default: name = NULL; size = false; break;
2818 }
2819
2820 if (name != NULL)
2821 {
2822 asection *s;
2823
2824 s = bfd_get_section_by_name (output_bfd, name);
2825 if (s == NULL)
2826 dyn.d_un.d_val = 0;
2827 else
2828 {
2829 if (! size)
2830 dyn.d_un.d_ptr = s->vma;
2831 else
2832 {
2833 if (s->_cooked_size != 0)
2834 dyn.d_un.d_val = s->_cooked_size;
2835 else
2836 dyn.d_un.d_val = s->_raw_size;
2837 }
2838 }
2839 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2840 }
2841 }
2842 }
2843
2844 /* Add a blrl instruction at _GLOBAL_OFFSET_TABLE_-4 so that a function can
2845 easily find the address of the _GLOBAL_OFFSET_TABLE_. */
2846 if (sgot)
2847 {
2848 unsigned char *contents = sgot->contents;
2849 bfd_put_32 (output_bfd, 0x4e800021 /* blrl */, contents);
2850
2851 if (sdyn == NULL)
2852 bfd_put_32 (output_bfd, (bfd_vma) 0, contents+4);
2853 else
2854 bfd_put_32 (output_bfd,
2855 sdyn->output_section->vma + sdyn->output_offset,
2856 contents+4);
2857
2858 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
2859 }
2860
2861 return true;
2862 }
2863 \f
2864 /* The RELOCATE_SECTION function is called by the ELF backend linker
2865 to handle the relocations for a section.
2866
2867 The relocs are always passed as Rela structures; if the section
2868 actually uses Rel structures, the r_addend field will always be
2869 zero.
2870
2871 This function is responsible for adjust the section contents as
2872 necessary, and (if using Rela relocs and generating a
2873 relocateable output file) adjusting the reloc addend as
2874 necessary.
2875
2876 This function does not have to worry about setting the reloc
2877 address or the reloc symbol index.
2878
2879 LOCAL_SYMS is a pointer to the swapped in local symbols.
2880
2881 LOCAL_SECTIONS is an array giving the section in the input file
2882 corresponding to the st_shndx field of each local symbol.
2883
2884 The global hash table entry for the global symbols can be found
2885 via elf_sym_hashes (input_bfd).
2886
2887 When generating relocateable output, this function must handle
2888 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
2889 going to be the section symbol corresponding to the output
2890 section, which means that the addend must be adjusted
2891 accordingly. */
2892
2893 static boolean
2894 ppc_elf_relocate_section (output_bfd, info, input_bfd, input_section,
2895 contents, relocs, local_syms, local_sections)
2896 bfd *output_bfd;
2897 struct bfd_link_info *info;
2898 bfd *input_bfd;
2899 asection *input_section;
2900 bfd_byte *contents;
2901 Elf_Internal_Rela *relocs;
2902 Elf_Internal_Sym *local_syms;
2903 asection **local_sections;
2904 {
2905 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2906 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
2907 bfd *dynobj = elf_hash_table (info)->dynobj;
2908 elf_linker_section_t *sdata = (dynobj) ? elf_linker_section (dynobj, LINKER_SECTION_SDATA) : NULL;
2909 elf_linker_section_t *sdata2 = (dynobj) ? elf_linker_section (dynobj, LINKER_SECTION_SDATA2) : NULL;
2910 Elf_Internal_Rela *rel = relocs;
2911 Elf_Internal_Rela *relend = relocs + input_section->reloc_count;
2912 asection *sreloc = NULL;
2913 asection *splt;
2914 asection *sgot;
2915 bfd_vma *local_got_offsets;
2916 boolean ret = true;
2917 long insn;
2918
2919 #ifdef DEBUG
2920 fprintf (stderr, "ppc_elf_relocate_section called for %s section %s, %ld relocations%s\n",
2921 bfd_get_filename (input_bfd),
2922 bfd_section_name(input_bfd, input_section),
2923 (long) input_section->reloc_count,
2924 (info->relocateable) ? " (relocatable)" : "");
2925 #endif
2926
2927 if (!ppc_elf_howto_table[R_PPC_ADDR32])
2928 /* Initialize howto table if needed. */
2929 ppc_elf_howto_init ();
2930
2931 local_got_offsets = elf_local_got_offsets (input_bfd);
2932
2933 splt = sgot = NULL;
2934 if (dynobj != NULL)
2935 {
2936 splt = bfd_get_section_by_name (dynobj, ".plt");
2937 sgot = bfd_get_section_by_name (dynobj, ".got");
2938 }
2939
2940 for (; rel < relend; rel++)
2941 {
2942 enum elf_ppc_reloc_type r_type = (enum elf_ppc_reloc_type)ELF32_R_TYPE (rel->r_info);
2943 bfd_vma offset = rel->r_offset;
2944 bfd_vma addend = rel->r_addend;
2945 bfd_reloc_status_type r = bfd_reloc_other;
2946 Elf_Internal_Sym *sym = (Elf_Internal_Sym *) 0;
2947 asection *sec = (asection *) 0;
2948 struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) 0;
2949 const char *sym_name = (const char *) 0;
2950 reloc_howto_type *howto;
2951 unsigned long r_symndx;
2952 bfd_vma relocation;
2953 int will_become_local;
2954
2955 /* Unknown relocation handling */
2956 if ((unsigned) r_type >= (unsigned) R_PPC_max
2957 || !ppc_elf_howto_table[(int) r_type])
2958 {
2959 (*_bfd_error_handler) (_("%s: unknown relocation type %d"),
2960 bfd_get_filename (input_bfd),
2961 (int) r_type);
2962
2963 bfd_set_error (bfd_error_bad_value);
2964 ret = false;
2965 continue;
2966 }
2967
2968 howto = ppc_elf_howto_table[(int) r_type];
2969 r_symndx = ELF32_R_SYM (rel->r_info);
2970
2971 if (info->relocateable)
2972 {
2973 /* This is a relocateable link. We don't have to change
2974 anything, unless the reloc is against a section symbol,
2975 in which case we have to adjust according to where the
2976 section symbol winds up in the output section. */
2977 if (r_symndx < symtab_hdr->sh_info)
2978 {
2979 sym = local_syms + r_symndx;
2980 if ((unsigned) ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2981 {
2982 sec = local_sections[r_symndx];
2983 addend = rel->r_addend += sec->output_offset + sym->st_value;
2984 }
2985 }
2986
2987 #ifdef DEBUG
2988 fprintf (stderr, "\ttype = %s (%d), symbol index = %ld, offset = %ld, addend = %ld\n",
2989 howto->name,
2990 (int) r_type,
2991 r_symndx,
2992 (long) offset,
2993 (long) addend);
2994 #endif
2995 continue;
2996 }
2997
2998 /* This is a final link. */
2999 if (r_symndx < symtab_hdr->sh_info)
3000 {
3001 sym = local_syms + r_symndx;
3002 sec = local_sections[r_symndx];
3003 sym_name = "<local symbol>";
3004
3005 relocation = (sec->output_section->vma
3006 + sec->output_offset
3007 + sym->st_value);
3008 /* Relocs to local symbols are always resolved. */
3009 will_become_local = 1;
3010 }
3011 else
3012 {
3013 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3014 while (h->root.type == bfd_link_hash_indirect
3015 || h->root.type == bfd_link_hash_warning)
3016 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3017 sym_name = h->root.root.string;
3018
3019 /* Can this relocation be resolved immediately? */
3020 will_become_local = SYMBOL_REFERENCES_LOCAL (info, h);
3021
3022 if (h->root.type == bfd_link_hash_defined
3023 || h->root.type == bfd_link_hash_defweak)
3024 {
3025 sec = h->root.u.def.section;
3026 if (((r_type == R_PPC_PLT32
3027 || r_type == R_PPC_PLTREL24)
3028 && splt != NULL
3029 && h->plt.offset != (bfd_vma) -1)
3030 || (r_type == R_PPC_LOCAL24PC
3031 && sec->output_section == NULL)
3032 || ((r_type == R_PPC_GOT16
3033 || r_type == R_PPC_GOT16_LO
3034 || r_type == R_PPC_GOT16_HI
3035 || r_type == R_PPC_GOT16_HA)
3036 && elf_hash_table (info)->dynamic_sections_created
3037 && (! info->shared || ! will_become_local))
3038 || (info->shared
3039 && ! will_become_local
3040 && ((input_section->flags & SEC_ALLOC) != 0
3041 /* Testing SEC_DEBUGGING here may be wrong.
3042 It's here to avoid a crash when
3043 generating a shared library with DWARF
3044 debugging information. */
3045 || ((input_section->flags & SEC_DEBUGGING) != 0
3046 && (h->elf_link_hash_flags
3047 & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
3048 && (r_type == R_PPC_ADDR32
3049 || r_type == R_PPC_ADDR24
3050 || r_type == R_PPC_ADDR16
3051 || r_type == R_PPC_ADDR16_LO
3052 || r_type == R_PPC_ADDR16_HI
3053 || r_type == R_PPC_ADDR16_HA
3054 || r_type == R_PPC_ADDR14
3055 || r_type == R_PPC_ADDR14_BRTAKEN
3056 || r_type == R_PPC_ADDR14_BRNTAKEN
3057 || r_type == R_PPC_COPY
3058 || r_type == R_PPC_GLOB_DAT
3059 || r_type == R_PPC_JMP_SLOT
3060 || r_type == R_PPC_UADDR32
3061 || r_type == R_PPC_UADDR16
3062 || r_type == R_PPC_SDAREL16
3063 || r_type == R_PPC_EMB_NADDR32
3064 || r_type == R_PPC_EMB_NADDR16
3065 || r_type == R_PPC_EMB_NADDR16_LO
3066 || r_type == R_PPC_EMB_NADDR16_HI
3067 || r_type == R_PPC_EMB_NADDR16_HA
3068 || r_type == R_PPC_EMB_SDAI16
3069 || r_type == R_PPC_EMB_SDA2I16
3070 || r_type == R_PPC_EMB_SDA2REL
3071 || r_type == R_PPC_EMB_SDA21
3072 || r_type == R_PPC_EMB_MRKREF
3073 || r_type == R_PPC_EMB_BIT_FLD
3074 || r_type == R_PPC_EMB_RELSDA
3075 || ((r_type == R_PPC_REL24
3076 || r_type == R_PPC_REL32
3077 || r_type == R_PPC_REL14
3078 || r_type == R_PPC_REL14_BRTAKEN
3079 || r_type == R_PPC_REL14_BRNTAKEN
3080 || r_type == R_PPC_RELATIVE)
3081 && strcmp (h->root.root.string,
3082 "_GLOBAL_OFFSET_TABLE_") != 0))))
3083 {
3084 /* In these cases, we don't need the relocation
3085 value. We check specially because in some
3086 obscure cases sec->output_section will be NULL. */
3087 relocation = 0;
3088 }
3089 else if (sec->output_section == NULL)
3090 {
3091 (*_bfd_error_handler)
3092 (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
3093 bfd_get_filename (input_bfd), h->root.root.string,
3094 bfd_get_section_name (input_bfd, input_section));
3095 relocation = 0;
3096 }
3097 else
3098 relocation = (h->root.u.def.value
3099 + sec->output_section->vma
3100 + sec->output_offset);
3101 }
3102 else if (h->root.type == bfd_link_hash_undefweak)
3103 relocation = 0;
3104 else if (info->shared && !info->symbolic && !info->no_undefined
3105 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
3106 relocation = 0;
3107 else
3108 {
3109 if (! (*info->callbacks->undefined_symbol) (info,
3110 h->root.root.string,
3111 input_bfd,
3112 input_section,
3113 rel->r_offset,
3114 (!info->shared
3115 || info->no_undefined
3116 || ELF_ST_VISIBILITY (h->other))))
3117 return false;
3118 relocation = 0;
3119 }
3120 }
3121
3122 switch ((int) r_type)
3123 {
3124 default:
3125 (*_bfd_error_handler) (_("%s: unknown relocation type %d for symbol %s"),
3126 bfd_get_filename (input_bfd),
3127 (int) r_type, sym_name);
3128
3129 bfd_set_error (bfd_error_bad_value);
3130 ret = false;
3131 continue;
3132
3133 /* Relocations that need no special processing. */
3134 case (int) R_PPC_LOCAL24PC:
3135 /* It makes no sense to point a local relocation
3136 at a symbol not in this object. */
3137 if (h != NULL
3138 && (h->root.type == bfd_link_hash_defined
3139 || h->root.type == bfd_link_hash_defweak)
3140 && sec->output_section == NULL)
3141 {
3142 if (! (*info->callbacks->undefined_symbol) (info,
3143 h->root.root.string,
3144 input_bfd,
3145 input_section,
3146 rel->r_offset,
3147 true))
3148 return false;
3149 continue;
3150 }
3151 break;
3152
3153 /* Relocations that may need to be propagated if this is a shared
3154 object. */
3155 case (int) R_PPC_REL24:
3156 case (int) R_PPC_REL32:
3157 case (int) R_PPC_REL14:
3158 /* If these relocations are not to a named symbol, they can be
3159 handled right here, no need to bother the dynamic linker. */
3160 if (h == NULL
3161 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3162 || SYMBOL_REFERENCES_LOCAL (info, h))
3163 break;
3164 /* fall through */
3165
3166 /* Relocations that always need to be propagated if this is a shared
3167 object. */
3168 case (int) R_PPC_NONE:
3169 case (int) R_PPC_ADDR32:
3170 case (int) R_PPC_ADDR24:
3171 case (int) R_PPC_ADDR16:
3172 case (int) R_PPC_ADDR16_LO:
3173 case (int) R_PPC_ADDR16_HI:
3174 case (int) R_PPC_ADDR16_HA:
3175 case (int) R_PPC_ADDR14:
3176 case (int) R_PPC_UADDR32:
3177 case (int) R_PPC_UADDR16:
3178 if (info->shared)
3179 {
3180 Elf_Internal_Rela outrel;
3181 boolean skip;
3182
3183 #ifdef DEBUG
3184 fprintf (stderr, "ppc_elf_relocate_section need to create relocation for %s\n",
3185 (h && h->root.root.string) ? h->root.root.string : "<unknown>");
3186 #endif
3187
3188 /* When generating a shared object, these relocations
3189 are copied into the output file to be resolved at run
3190 time. */
3191
3192 if (sreloc == NULL)
3193 {
3194 const char *name;
3195
3196 name = (bfd_elf_string_from_elf_section
3197 (input_bfd,
3198 elf_elfheader (input_bfd)->e_shstrndx,
3199 elf_section_data (input_section)->rel_hdr.sh_name));
3200 if (name == NULL)
3201 return false;
3202
3203 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
3204 && strcmp (bfd_get_section_name (input_bfd,
3205 input_section),
3206 name + 5) == 0);
3207
3208 sreloc = bfd_get_section_by_name (dynobj, name);
3209 BFD_ASSERT (sreloc != NULL);
3210 }
3211
3212 skip = false;
3213
3214 if (elf_section_data (input_section)->stab_info == NULL)
3215 outrel.r_offset = rel->r_offset;
3216 else
3217 {
3218 bfd_vma off;
3219
3220 off = (_bfd_stab_section_offset
3221 (output_bfd, &elf_hash_table (info)->stab_info,
3222 input_section,
3223 &elf_section_data (input_section)->stab_info,
3224 rel->r_offset));
3225 if (off == (bfd_vma) -1)
3226 skip = true;
3227 outrel.r_offset = off;
3228 }
3229
3230 outrel.r_offset += (input_section->output_section->vma
3231 + input_section->output_offset);
3232
3233 if (skip)
3234 memset (&outrel, 0, sizeof outrel);
3235 /* h->dynindx may be -1 if this symbol was marked to
3236 become local. */
3237 else if (! will_become_local)
3238 {
3239 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
3240 outrel.r_addend = rel->r_addend;
3241 }
3242 else
3243 {
3244 if (r_type == R_PPC_ADDR32)
3245 {
3246 outrel.r_info = ELF32_R_INFO (0, R_PPC_RELATIVE);
3247 outrel.r_addend = relocation + rel->r_addend;
3248 }
3249 else
3250 {
3251 long indx;
3252
3253 if (h == NULL)
3254 sec = local_sections[r_symndx];
3255 else
3256 {
3257 BFD_ASSERT (h->root.type == bfd_link_hash_defined
3258 || (h->root.type
3259 == bfd_link_hash_defweak));
3260 sec = h->root.u.def.section;
3261 }
3262 if (sec != NULL && bfd_is_abs_section (sec))
3263 indx = 0;
3264 else if (sec == NULL || sec->owner == NULL)
3265 {
3266 bfd_set_error (bfd_error_bad_value);
3267 return false;
3268 }
3269 else
3270 {
3271 asection *osec;
3272
3273 osec = sec->output_section;
3274 indx = elf_section_data (osec)->dynindx;
3275 BFD_ASSERT (indx > 0);
3276 #ifdef DEBUG
3277 if (indx <= 0)
3278 {
3279 printf ("indx=%d section=%s flags=%08x name=%s\n",
3280 indx, osec->name, osec->flags,
3281 h->root.root.string);
3282 }
3283 #endif
3284 }
3285
3286 outrel.r_info = ELF32_R_INFO (indx, r_type);
3287 outrel.r_addend = relocation + rel->r_addend;
3288 }
3289 }
3290
3291 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
3292 (((Elf32_External_Rela *)
3293 sreloc->contents)
3294 + sreloc->reloc_count));
3295 ++sreloc->reloc_count;
3296
3297 /* This reloc will be computed at runtime, so there's no
3298 need to do anything now, unless this is a RELATIVE
3299 reloc in an unallocated section. */
3300 if (skip
3301 || (input_section->flags & SEC_ALLOC) != 0
3302 || ELF32_R_TYPE (outrel.r_info) != R_PPC_RELATIVE)
3303 continue;
3304 }
3305
3306 /* Arithmetic adjust relocations that aren't going into a
3307 shared object. */
3308 if (r_type == R_PPC_ADDR16_HA
3309 /* It's just possible that this symbol is a weak symbol
3310 that's not actually defined anywhere. In that case,
3311 'sec' would be NULL, and we should leave the symbol
3312 alone (it will be set to zero elsewhere in the link). */
3313 && sec != NULL)
3314 {
3315 addend += ((relocation + addend) & 0x8000) << 1;
3316 }
3317 break;
3318
3319 /* branch taken prediction relocations */
3320 case (int) R_PPC_ADDR14_BRTAKEN:
3321 case (int) R_PPC_REL14_BRTAKEN:
3322 insn = bfd_get_32 (output_bfd, contents + offset);
3323 if ((relocation - offset) & 0x8000)
3324 insn &= ~BRANCH_PREDICT_BIT;
3325 else
3326 insn |= BRANCH_PREDICT_BIT;
3327 bfd_put_32 (output_bfd, insn, contents + offset);
3328 break;
3329
3330 /* branch not taken predicition relocations */
3331 case (int) R_PPC_ADDR14_BRNTAKEN:
3332 case (int) R_PPC_REL14_BRNTAKEN:
3333 insn = bfd_get_32 (output_bfd, contents + offset);
3334 if ((relocation - offset) & 0x8000)
3335 insn |= BRANCH_PREDICT_BIT;
3336 else
3337 insn &= ~BRANCH_PREDICT_BIT;
3338 bfd_put_32 (output_bfd, insn, contents + offset);
3339 break;
3340
3341 /* GOT16 relocations */
3342 case (int) R_PPC_GOT16:
3343 case (int) R_PPC_GOT16_LO:
3344 case (int) R_PPC_GOT16_HI:
3345 case (int) R_PPC_GOT16_HA:
3346 /* Relocation is to the entry for this symbol in the global
3347 offset table. */
3348 BFD_ASSERT (sgot != NULL);
3349
3350 if (h != NULL)
3351 {
3352 bfd_vma off;
3353
3354 off = h->got.offset;
3355 BFD_ASSERT (off != (bfd_vma) -1);
3356
3357 if (! elf_hash_table (info)->dynamic_sections_created
3358 || (info->shared
3359 && SYMBOL_REFERENCES_LOCAL (info, h)))
3360 {
3361 /* This is actually a static link, or it is a
3362 -Bsymbolic link and the symbol is defined
3363 locally. We must initialize this entry in the
3364 global offset table. Since the offset must
3365 always be a multiple of 4, we use the least
3366 significant bit to record whether we have
3367 initialized it already.
3368
3369 When doing a dynamic link, we create a .rela.got
3370 relocation entry to initialize the value. This
3371 is done in the finish_dynamic_symbol routine. */
3372 if ((off & 1) != 0)
3373 off &= ~1;
3374 else
3375 {
3376 bfd_put_32 (output_bfd, relocation,
3377 sgot->contents + off);
3378 h->got.offset |= 1;
3379 }
3380 }
3381
3382 relocation = sgot->output_offset + off - 4;
3383 }
3384 else
3385 {
3386 bfd_vma off;
3387
3388 BFD_ASSERT (local_got_offsets != NULL
3389 && local_got_offsets[r_symndx] != (bfd_vma) -1);
3390
3391 off = local_got_offsets[r_symndx];
3392
3393 /* The offset must always be a multiple of 4. We use
3394 the least significant bit to record whether we have
3395 already processed this entry. */
3396 if ((off & 1) != 0)
3397 off &= ~1;
3398 else
3399 {
3400 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
3401
3402 if (info->shared)
3403 {
3404 asection *srelgot;
3405 Elf_Internal_Rela outrel;
3406
3407 /* We need to generate a R_PPC_RELATIVE reloc
3408 for the dynamic linker. */
3409 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3410 BFD_ASSERT (srelgot != NULL);
3411
3412 outrel.r_offset = (sgot->output_section->vma
3413 + sgot->output_offset
3414 + off);
3415 outrel.r_info = ELF32_R_INFO (0, R_PPC_RELATIVE);
3416 outrel.r_addend = relocation;
3417 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
3418 (((Elf32_External_Rela *)
3419 srelgot->contents)
3420 + srelgot->reloc_count));
3421 ++srelgot->reloc_count;
3422 }
3423
3424 local_got_offsets[r_symndx] |= 1;
3425 }
3426
3427 relocation = sgot->output_offset + off - 4;
3428 }
3429 break;
3430
3431 /* Indirect .sdata relocation */
3432 case (int) R_PPC_EMB_SDAI16:
3433 BFD_ASSERT (sdata != NULL);
3434 relocation = bfd_elf32_finish_pointer_linker_section (output_bfd, input_bfd, info,
3435 sdata, h, relocation, rel,
3436 R_PPC_RELATIVE);
3437 break;
3438
3439 /* Indirect .sdata2 relocation */
3440 case (int) R_PPC_EMB_SDA2I16:
3441 BFD_ASSERT (sdata2 != NULL);
3442 relocation = bfd_elf32_finish_pointer_linker_section (output_bfd, input_bfd, info,
3443 sdata2, h, relocation, rel,
3444 R_PPC_RELATIVE);
3445 break;
3446
3447 /* Handle the TOC16 reloc. We want to use the offset within the .got
3448 section, not the actual VMA. This is appropriate when generating
3449 an embedded ELF object, for which the .got section acts like the
3450 AIX .toc section. */
3451 case (int) R_PPC_TOC16: /* phony GOT16 relocations */
3452 BFD_ASSERT (sec != (asection *) 0);
3453 BFD_ASSERT (bfd_is_und_section (sec)
3454 || strcmp (bfd_get_section_name (abfd, sec), ".got") == 0
3455 || strcmp (bfd_get_section_name (abfd, sec), ".cgot") == 0)
3456
3457 addend -= sec->output_section->vma + sec->output_offset + 0x8000;
3458 break;
3459
3460 case (int) R_PPC_PLTREL24:
3461 /* Relocation is to the entry for this symbol in the
3462 procedure linkage table. */
3463 BFD_ASSERT (h != NULL);
3464
3465 if (h->plt.offset == (bfd_vma) -1
3466 || splt == NULL)
3467 {
3468 /* We didn't make a PLT entry for this symbol. This
3469 happens when statically linking PIC code, or when
3470 using -Bsymbolic. */
3471 break;
3472 }
3473
3474 relocation = (splt->output_section->vma
3475 + splt->output_offset
3476 + h->plt.offset);
3477 break;
3478
3479 /* relocate against _SDA_BASE_ */
3480 case (int) R_PPC_SDAREL16:
3481 {
3482 const char *name;
3483
3484 BFD_ASSERT (sec != (asection *) 0);
3485 name = bfd_get_section_name (abfd, sec->output_section);
3486 if (strcmp (name, ".sdata") != 0
3487 && strcmp (name, ".sbss") != 0)
3488 {
3489 (*_bfd_error_handler) (_("%s: The target (%s) of a %s relocation is in the wrong output section (%s)"),
3490 bfd_get_filename (input_bfd),
3491 sym_name,
3492 ppc_elf_howto_table[(int) r_type]->name,
3493 name);
3494 }
3495 addend -= (sdata->sym_hash->root.u.def.value
3496 + sdata->sym_hash->root.u.def.section->output_section->vma
3497 + sdata->sym_hash->root.u.def.section->output_offset);
3498 }
3499 break;
3500
3501 /* relocate against _SDA2_BASE_ */
3502 case (int) R_PPC_EMB_SDA2REL:
3503 {
3504 const char *name;
3505
3506 BFD_ASSERT (sec != (asection *) 0);
3507 name = bfd_get_section_name (abfd, sec->output_section);
3508 if (strcmp (name, ".sdata2") != 0 && strcmp (name, ".sbss2") != 0)
3509 {
3510 (*_bfd_error_handler) (_("%s: The target (%s) of a %s relocation is in the wrong output section (%s)"),
3511 bfd_get_filename (input_bfd),
3512 sym_name,
3513 ppc_elf_howto_table[(int) r_type]->name,
3514 name);
3515
3516 bfd_set_error (bfd_error_bad_value);
3517 ret = false;
3518 continue;
3519 }
3520 addend -= (sdata2->sym_hash->root.u.def.value
3521 + sdata2->sym_hash->root.u.def.section->output_section->vma
3522 + sdata2->sym_hash->root.u.def.section->output_offset);
3523 }
3524 break;
3525
3526 /* relocate against either _SDA_BASE_, _SDA2_BASE_, or 0 */
3527 case (int) R_PPC_EMB_SDA21:
3528 case (int) R_PPC_EMB_RELSDA:
3529 {
3530 const char *name;
3531 int reg;
3532
3533 BFD_ASSERT (sec != (asection *) 0);
3534 name = bfd_get_section_name (abfd, sec->output_section);
3535 if (strcmp (name, ".sdata") == 0 || strcmp (name, ".sbss") == 0)
3536 {
3537 reg = 13;
3538 addend -= (sdata->sym_hash->root.u.def.value
3539 + sdata->sym_hash->root.u.def.section->output_section->vma
3540 + sdata->sym_hash->root.u.def.section->output_offset);
3541 }
3542
3543 else if (strcmp (name, ".sdata2") == 0
3544 || strcmp (name, ".sbss2") == 0)
3545 {
3546 reg = 2;
3547 addend -= (sdata2->sym_hash->root.u.def.value
3548 + sdata2->sym_hash->root.u.def.section->output_section->vma
3549 + sdata2->sym_hash->root.u.def.section->output_offset);
3550 }
3551
3552 else if (strcmp (name, ".PPC.EMB.sdata0") == 0
3553 || strcmp (name, ".PPC.EMB.sbss0") == 0)
3554 {
3555 reg = 0;
3556 }
3557
3558 else
3559 {
3560 (*_bfd_error_handler) (_("%s: The target (%s) of a %s relocation is in the wrong output section (%s)"),
3561 bfd_get_filename (input_bfd),
3562 sym_name,
3563 ppc_elf_howto_table[(int) r_type]->name,
3564 name);
3565
3566 bfd_set_error (bfd_error_bad_value);
3567 ret = false;
3568 continue;
3569 }
3570
3571 if (r_type == R_PPC_EMB_SDA21)
3572 { /* fill in register field */
3573 insn = bfd_get_32 (output_bfd, contents + offset);
3574 insn = (insn & ~RA_REGISTER_MASK) | (reg << RA_REGISTER_SHIFT);
3575 bfd_put_32 (output_bfd, insn, contents + offset);
3576 }
3577 }
3578 break;
3579
3580 /* Relocate against the beginning of the section */
3581 case (int) R_PPC_SECTOFF:
3582 case (int) R_PPC_SECTOFF_LO:
3583 case (int) R_PPC_SECTOFF_HI:
3584 BFD_ASSERT (sec != (asection *) 0);
3585 addend -= sec->output_section->vma;
3586 break;
3587
3588 case (int) R_PPC_SECTOFF_HA:
3589 BFD_ASSERT (sec != (asection *) 0);
3590 addend -= sec->output_section->vma;
3591 addend += ((relocation + addend) & 0x8000) << 1;
3592 break;
3593
3594 /* Negative relocations */
3595 case (int) R_PPC_EMB_NADDR32:
3596 case (int) R_PPC_EMB_NADDR16:
3597 case (int) R_PPC_EMB_NADDR16_LO:
3598 case (int) R_PPC_EMB_NADDR16_HI:
3599 addend -= 2 * relocation;
3600 break;
3601
3602 case (int) R_PPC_EMB_NADDR16_HA:
3603 addend -= 2 * relocation;
3604 addend += ((relocation + addend) & 0x8000) << 1;
3605 break;
3606
3607 /* NOP relocation that prevents garbage collecting linkers from omitting a
3608 reference. */
3609 case (int) R_PPC_EMB_MRKREF:
3610 continue;
3611
3612 case (int) R_PPC_COPY:
3613 case (int) R_PPC_GLOB_DAT:
3614 case (int) R_PPC_JMP_SLOT:
3615 case (int) R_PPC_RELATIVE:
3616 case (int) R_PPC_PLT32:
3617 case (int) R_PPC_PLTREL32:
3618 case (int) R_PPC_PLT16_LO:
3619 case (int) R_PPC_PLT16_HI:
3620 case (int) R_PPC_PLT16_HA:
3621 case (int) R_PPC_EMB_RELSEC16:
3622 case (int) R_PPC_EMB_RELST_LO:
3623 case (int) R_PPC_EMB_RELST_HI:
3624 case (int) R_PPC_EMB_RELST_HA:
3625 case (int) R_PPC_EMB_BIT_FLD:
3626 (*_bfd_error_handler) (_("%s: Relocation %s is not yet supported for symbol %s."),
3627 bfd_get_filename (input_bfd),
3628 ppc_elf_howto_table[(int) r_type]->name,
3629 sym_name);
3630
3631 bfd_set_error (bfd_error_invalid_operation);
3632 ret = false;
3633 continue;
3634
3635 case (int) R_PPC_GNU_VTINHERIT:
3636 case (int) R_PPC_GNU_VTENTRY:
3637 /* These are no-ops in the end. */
3638 continue;
3639 }
3640
3641 #ifdef DEBUG
3642 fprintf (stderr, "\ttype = %s (%d), name = %s, symbol index = %ld, offset = %ld, addend = %ld\n",
3643 howto->name,
3644 (int) r_type,
3645 sym_name,
3646 r_symndx,
3647 (long) offset,
3648 (long) addend);
3649 #endif
3650
3651 r = _bfd_final_link_relocate (howto,
3652 input_bfd,
3653 input_section,
3654 contents,
3655 offset,
3656 relocation,
3657 addend);
3658
3659 if (r == bfd_reloc_ok)
3660 ;
3661 else if (r == bfd_reloc_overflow)
3662 {
3663 const char *name;
3664
3665 if (h != NULL)
3666 {
3667 if (h->root.type == bfd_link_hash_undefweak
3668 && howto->pc_relative)
3669 {
3670 /* Assume this is a call protected by other code that
3671 detect the symbol is undefined. If this is the case,
3672 we can safely ignore the overflow. If not, the
3673 program is hosed anyway, and a little warning isn't
3674 going to help. */
3675
3676 continue;
3677 }
3678
3679 name = h->root.root.string;
3680 }
3681 else
3682 {
3683 name = bfd_elf_string_from_elf_section (input_bfd,
3684 symtab_hdr->sh_link,
3685 sym->st_name);
3686 if (name == NULL)
3687 continue;
3688 if (*name == '\0')
3689 name = bfd_section_name (input_bfd, sec);
3690 }
3691
3692 if (! (*info->callbacks->reloc_overflow) (info,
3693 name,
3694 howto->name,
3695 (bfd_vma) 0,
3696 input_bfd,
3697 input_section,
3698 offset))
3699 return false;
3700 }
3701 else
3702 ret = false;
3703 }
3704
3705 #ifdef DEBUG
3706 fprintf (stderr, "\n");
3707 #endif
3708
3709 return ret;
3710 }
3711 \f
3712 #define TARGET_LITTLE_SYM bfd_elf32_powerpcle_vec
3713 #define TARGET_LITTLE_NAME "elf32-powerpcle"
3714 #define TARGET_BIG_SYM bfd_elf32_powerpc_vec
3715 #define TARGET_BIG_NAME "elf32-powerpc"
3716 #define ELF_ARCH bfd_arch_powerpc
3717 #define ELF_MACHINE_CODE EM_PPC
3718 #define ELF_MAXPAGESIZE 0x10000
3719 #define elf_info_to_howto ppc_elf_info_to_howto
3720
3721 #ifdef EM_CYGNUS_POWERPC
3722 #define ELF_MACHINE_ALT1 EM_CYGNUS_POWERPC
3723 #endif
3724
3725 #ifdef EM_PPC_OLD
3726 #define ELF_MACHINE_ALT2 EM_PPC_OLD
3727 #endif
3728
3729 #define elf_backend_plt_not_loaded 1
3730 #define elf_backend_got_symbol_offset 4
3731 #define elf_backend_can_gc_sections 1
3732 #define elf_backend_got_header_size 12
3733 #define elf_backend_plt_header_size PLT_INITIAL_ENTRY_SIZE
3734
3735 #define bfd_elf32_bfd_copy_private_bfd_data ppc_elf_copy_private_bfd_data
3736 #define bfd_elf32_bfd_merge_private_bfd_data ppc_elf_merge_private_bfd_data
3737 #define bfd_elf32_bfd_relax_section ppc_elf_relax_section
3738 #define bfd_elf32_bfd_reloc_type_lookup ppc_elf_reloc_type_lookup
3739 #define bfd_elf32_bfd_set_private_flags ppc_elf_set_private_flags
3740 #define bfd_elf32_bfd_final_link _bfd_elf32_gc_common_final_link
3741
3742 #define elf_backend_gc_mark_hook ppc_elf_gc_mark_hook
3743 #define elf_backend_gc_sweep_hook ppc_elf_gc_sweep_hook
3744 #define elf_backend_section_from_shdr ppc_elf_section_from_shdr
3745 #define elf_backend_relocate_section ppc_elf_relocate_section
3746 #define elf_backend_create_dynamic_sections ppc_elf_create_dynamic_sections
3747 #define elf_backend_check_relocs ppc_elf_check_relocs
3748 #define elf_backend_adjust_dynamic_symbol ppc_elf_adjust_dynamic_symbol
3749 #define elf_backend_add_symbol_hook ppc_elf_add_symbol_hook
3750 #define elf_backend_size_dynamic_sections ppc_elf_size_dynamic_sections
3751 #define elf_backend_finish_dynamic_symbol ppc_elf_finish_dynamic_symbol
3752 #define elf_backend_finish_dynamic_sections ppc_elf_finish_dynamic_sections
3753 #define elf_backend_fake_sections ppc_elf_fake_sections
3754 #define elf_backend_additional_program_headers ppc_elf_additional_program_headers
3755 #define elf_backend_modify_segment_map ppc_elf_modify_segment_map
3756
3757 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.118022 seconds and 4 git commands to generate.