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