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