projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* elf32-ppc.c (ppc_elf_relocate_section): Don't look for a nop after
[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 #include "elf32-ppc.h"
34
35 /* RELA relocations are used here. */
36
37 static struct bfd_hash_entry *ppc_elf_link_hash_newfunc
38 PARAMS ((struct bfd_hash_entry *entry, struct bfd_hash_table *table,
39 const char *string));
40 static struct bfd_link_hash_table *ppc_elf_link_hash_table_create
41 PARAMS ((bfd *abfd));
42 static void ppc_elf_copy_indirect_symbol
43 PARAMS ((struct elf_backend_data *bed, struct elf_link_hash_entry *dir,
44 struct elf_link_hash_entry *ind));
45 static reloc_howto_type *ppc_elf_reloc_type_lookup
46 PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
47 static void ppc_elf_info_to_howto
48 PARAMS ((bfd *abfd, arelent *cache_ptr, Elf_Internal_Rela *dst));
49 static void ppc_elf_howto_init
50 PARAMS ((void));
51 static int ppc_elf_sort_rela
52 PARAMS ((const PTR, const PTR));
53 static bfd_boolean ppc_elf_relax_section
54 PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *));
55 static bfd_reloc_status_type ppc_elf_addr16_ha_reloc
56 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
57 static bfd_reloc_status_type ppc_elf_unhandled_reloc
58 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
59 static bfd_boolean ppc_elf_object_p
60 PARAMS ((bfd *));
61 static bfd_boolean ppc_elf_set_private_flags
62 PARAMS ((bfd *, flagword));
63 static bfd_boolean ppc_elf_merge_private_bfd_data
64 PARAMS ((bfd *, bfd *));
65 static int ppc_elf_additional_program_headers
66 PARAMS ((bfd *));
67 static bfd_boolean ppc_elf_modify_segment_map
68 PARAMS ((bfd *));
69 static bfd_boolean ppc_elf_create_got
70 PARAMS ((bfd *, struct bfd_link_info *));
71 static bfd_boolean ppc_elf_create_dynamic_sections
72 PARAMS ((bfd *, struct bfd_link_info *));
73 static bfd_boolean ppc_elf_section_from_shdr
74 PARAMS ((bfd *, Elf_Internal_Shdr *, const char *));
75 static bfd_boolean ppc_elf_fake_sections
76 PARAMS ((bfd *, Elf_Internal_Shdr *, asection *));
77 static elf_linker_section_t *ppc_elf_create_linker_section
78 PARAMS ((bfd *abfd, struct bfd_link_info *info,
79 enum elf_linker_section_enum));
80 static bfd_boolean update_local_sym_info
81 PARAMS ((bfd *, Elf_Internal_Shdr *, unsigned long, int));
82 static void bad_shared_reloc
83 PARAMS ((bfd *, enum elf_ppc_reloc_type));
84 static bfd_boolean ppc_elf_check_relocs
85 PARAMS ((bfd *, struct bfd_link_info *, asection *,
86 const Elf_Internal_Rela *));
87 static asection *ppc_elf_gc_mark_hook
88 PARAMS ((asection *sec, struct bfd_link_info *info, Elf_Internal_Rela *rel,
89 struct elf_link_hash_entry *h, Elf_Internal_Sym *sym));
90 static bfd_boolean ppc_elf_gc_sweep_hook
91 PARAMS ((bfd *abfd, struct bfd_link_info *info, asection *sec,
92 const Elf_Internal_Rela *relocs));
93 static bfd_boolean ppc_elf_adjust_dynamic_symbol
94 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
95 static bfd_boolean allocate_dynrelocs
96 PARAMS ((struct elf_link_hash_entry *, PTR));
97 static bfd_boolean readonly_dynrelocs
98 PARAMS ((struct elf_link_hash_entry *, PTR));
99 static bfd_boolean ppc_elf_size_dynamic_sections
100 PARAMS ((bfd *, struct bfd_link_info *));
101 static bfd_boolean ppc_elf_relocate_section
102 PARAMS ((bfd *, struct bfd_link_info *info, bfd *, asection *, bfd_byte *,
103 Elf_Internal_Rela *relocs, Elf_Internal_Sym *local_syms,
104 asection **));
105 static bfd_boolean ppc_elf_add_symbol_hook
106 PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
107 const char **, flagword *, asection **, bfd_vma *));
108 static bfd_boolean ppc_elf_finish_dynamic_symbol
109 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
110 Elf_Internal_Sym *));
111 static bfd_boolean ppc_elf_finish_dynamic_sections
112 PARAMS ((bfd *, struct bfd_link_info *));
113 static enum elf_reloc_type_class ppc_elf_reloc_type_class
114 PARAMS ((const Elf_Internal_Rela *));
115 static bfd_boolean ppc_elf_grok_prstatus
116 PARAMS ((bfd *abfd, Elf_Internal_Note *note));
117 static bfd_boolean ppc_elf_grok_psinfo
118 PARAMS ((bfd *abfd, Elf_Internal_Note *note));
119
120 /* Branch prediction bit for branch taken relocs. */
121 #define BRANCH_PREDICT_BIT 0x200000
122 /* Mask to set RA in memory instructions. */
123 #define RA_REGISTER_MASK 0x001f0000
124 /* Value to shift register by to insert RA. */
125 #define RA_REGISTER_SHIFT 16
126
127 /* The name of the dynamic interpreter. This is put in the .interp
128 section. */
129 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
130
131 /* The size in bytes of an entry in the procedure linkage table. */
132 #define PLT_ENTRY_SIZE 12
133 /* The initial size of the plt reserved for the dynamic linker. */
134 #define PLT_INITIAL_ENTRY_SIZE 72
135 /* The size of the gap between entries in the PLT. */
136 #define PLT_SLOT_SIZE 8
137 /* The number of single-slot PLT entries (the rest use two slots). */
138 #define PLT_NUM_SINGLE_ENTRIES 8192
139
140 /* Some nop instructions. */
141 #define NOP 0x60000000
142 #define CROR_151515 0x4def7b82
143 #define CROR_313131 0x4ffffb82
144
145 /* Offset of tp and dtp pointers from start of TLS block. */
146 #define TP_OFFSET 0x7000
147 #define DTP_OFFSET 0x8000
148
149 /* Will references to this symbol always reference the symbol
150 in this object? */
151 #define SYMBOL_REFERENCES_LOCAL(INFO, H) \
152 ((! INFO->shared \
153 || INFO->symbolic \
154 || H->dynindx == -1 \
155 || ELF_ST_VISIBILITY (H->other) == STV_INTERNAL \
156 || ELF_ST_VISIBILITY (H->other) == STV_HIDDEN) \
157 && (H->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
158
159 /* Will _calls_ to this symbol always call the version in this object? */
160 #define SYMBOL_CALLS_LOCAL(INFO, H) \
161 ((! INFO->shared \
162 || INFO->symbolic \
163 || H->dynindx == -1 \
164 || ELF_ST_VISIBILITY (H->other) != STV_DEFAULT) \
165 && (H->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
166 \f
167 /* The PPC linker needs to keep track of the number of relocs that it
168 decides to copy as dynamic relocs in check_relocs for each symbol.
169 This is so that it can later discard them if they are found to be
170 unnecessary. We store the information in a field extending the
171 regular ELF linker hash table. */
172
173 struct ppc_elf_dyn_relocs
174 {
175 struct ppc_elf_dyn_relocs *next;
176
177 /* The input section of the reloc. */
178 asection *sec;
179
180 /* Total number of relocs copied for the input section. */
181 bfd_size_type count;
182
183 /* Number of pc-relative relocs copied for the input section. */
184 bfd_size_type pc_count;
185 };
186
187 /* PPC ELF linker hash entry. */
188
189 struct ppc_elf_link_hash_entry
190 {
191 struct elf_link_hash_entry elf;
192
193 /* Track dynamic relocs copied for this symbol. */
194 struct ppc_elf_dyn_relocs *dyn_relocs;
195
196 /* Contexts in which symbol is used in the GOT (or TOC).
197 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
198 corresponding relocs are encountered during check_relocs.
199 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
200 indicate the corresponding GOT entry type is not needed. */
201 #define TLS_GD 1 /* GD reloc. */
202 #define TLS_LD 2 /* LD reloc. */
203 #define TLS_TPREL 4 /* TPREL reloc, => IE. */
204 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
205 #define TLS_TLS 16 /* Any TLS reloc. */
206 #define TLS_TPRELGD 32 /* TPREL reloc resulting from GD->IE. */
207 char tls_mask;
208 };
209
210 #define ppc_elf_hash_entry(ent) ((struct ppc_elf_link_hash_entry *) (ent))
211
212 /* PPC ELF linker hash table. */
213
214 struct ppc_elf_link_hash_table
215 {
216 struct elf_link_hash_table elf;
217
218 /* Short-cuts to get to dynamic linker sections. */
219 asection *got;
220 asection *relgot;
221 asection *plt;
222 asection *relplt;
223 asection *dynbss;
224 asection *relbss;
225 asection *dynsbss;
226 asection *relsbss;
227 elf_linker_section_t *sdata;
228 elf_linker_section_t *sdata2;
229
230 /* Short-cut to first output tls section. */
231 asection *tls_sec;
232
233 /* Shortcut to .__tls_get_addr. */
234 struct elf_link_hash_entry *tls_get_addr;
235
236 /* TLS local dynamic got entry handling. */
237 union {
238 bfd_signed_vma refcount;
239 bfd_vma offset;
240 } tlsld_got;
241
242 /* Small local sym to section mapping cache. */
243 struct sym_sec_cache sym_sec;
244 };
245
246 /* Get the PPC ELF linker hash table from a link_info structure. */
247
248 #define ppc_elf_hash_table(p) \
249 ((struct ppc_elf_link_hash_table *) (p)->hash)
250
251 /* Create an entry in a PPC ELF linker hash table. */
252
253 static struct bfd_hash_entry *
254 ppc_elf_link_hash_newfunc (entry, table, string)
255 struct bfd_hash_entry *entry;
256 struct bfd_hash_table *table;
257 const char *string;
258 {
259 /* Allocate the structure if it has not already been allocated by a
260 subclass. */
261 if (entry == NULL)
262 {
263 entry = bfd_hash_allocate (table,
264 sizeof (struct ppc_elf_link_hash_entry));
265 if (entry == NULL)
266 return entry;
267 }
268
269 /* Call the allocation method of the superclass. */
270 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
271 if (entry != NULL)
272 {
273 ppc_elf_hash_entry (entry)->dyn_relocs = NULL;
274 ppc_elf_hash_entry (entry)->tls_mask = 0;
275 }
276
277 return entry;
278 }
279
280 /* Create a PPC ELF linker hash table. */
281
282 static struct bfd_link_hash_table *
283 ppc_elf_link_hash_table_create (abfd)
284 bfd *abfd;
285 {
286 struct ppc_elf_link_hash_table *ret;
287
288 ret = ((struct ppc_elf_link_hash_table *)
289 bfd_malloc (sizeof (struct ppc_elf_link_hash_table)));
290 if (ret == NULL)
291 return NULL;
292
293 if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd,
294 ppc_elf_link_hash_newfunc))
295 {
296 free (ret);
297 return NULL;
298 }
299
300 ret->got = NULL;
301 ret->relgot = NULL;
302 ret->plt = NULL;
303 ret->relplt = NULL;
304 ret->dynbss = NULL;
305 ret->relbss = NULL;
306 ret->dynsbss = NULL;
307 ret->relsbss = NULL;
308 ret->sdata = NULL;
309 ret->sdata2 = NULL;
310 ret->tls_sec = NULL;
311 ret->tls_get_addr = NULL;
312 ret->tlsld_got.refcount = 0;
313 ret->sym_sec.abfd = NULL;
314
315 return &ret->elf.root;
316 }
317
318 /* Copy the extra info we tack onto an elf_link_hash_entry. */
319
320 static void
321 ppc_elf_copy_indirect_symbol (bed, dir, ind)
322 struct elf_backend_data *bed;
323 struct elf_link_hash_entry *dir, *ind;
324 {
325 struct ppc_elf_link_hash_entry *edir, *eind;
326
327 edir = (struct ppc_elf_link_hash_entry *) dir;
328 eind = (struct ppc_elf_link_hash_entry *) ind;
329
330 if (eind->dyn_relocs != NULL)
331 {
332 if (edir->dyn_relocs != NULL)
333 {
334 struct ppc_elf_dyn_relocs **pp;
335 struct ppc_elf_dyn_relocs *p;
336
337 if (ind->root.type == bfd_link_hash_indirect)
338 abort ();
339
340 /* Add reloc counts against the weak sym to the strong sym
341 list. Merge any entries against the same section. */
342 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
343 {
344 struct ppc_elf_dyn_relocs *q;
345
346 for (q = edir->dyn_relocs; q != NULL; q = q->next)
347 if (q->sec == p->sec)
348 {
349 q->pc_count += p->pc_count;
350 q->count += p->count;
351 *pp = p->next;
352 break;
353 }
354 if (q == NULL)
355 pp = &p->next;
356 }
357 *pp = edir->dyn_relocs;
358 }
359
360 edir->dyn_relocs = eind->dyn_relocs;
361 eind->dyn_relocs = NULL;
362 }
363
364 edir->tls_mask |= eind->tls_mask;
365
366 _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
367 }
368 \f
369 static reloc_howto_type *ppc_elf_howto_table[(int) R_PPC_max];
370
371 static reloc_howto_type ppc_elf_howto_raw[] = {
372 /* This reloc does nothing. */
373 HOWTO (R_PPC_NONE, /* type */
374 0, /* rightshift */
375 2, /* size (0 = byte, 1 = short, 2 = long) */
376 32, /* bitsize */
377 FALSE, /* pc_relative */
378 0, /* bitpos */
379 complain_overflow_bitfield, /* complain_on_overflow */
380 bfd_elf_generic_reloc, /* special_function */
381 "R_PPC_NONE", /* name */
382 FALSE, /* partial_inplace */
383 0, /* src_mask */
384 0, /* dst_mask */
385 FALSE), /* pcrel_offset */
386
387 /* A standard 32 bit relocation. */
388 HOWTO (R_PPC_ADDR32, /* type */
389 0, /* rightshift */
390 2, /* size (0 = byte, 1 = short, 2 = long) */
391 32, /* bitsize */
392 FALSE, /* pc_relative */
393 0, /* bitpos */
394 complain_overflow_bitfield, /* complain_on_overflow */
395 bfd_elf_generic_reloc, /* special_function */
396 "R_PPC_ADDR32", /* name */
397 FALSE, /* partial_inplace */
398 0, /* src_mask */
399 0xffffffff, /* dst_mask */
400 FALSE), /* pcrel_offset */
401
402 /* An absolute 26 bit branch; the lower two bits must be zero.
403 FIXME: we don't check that, we just clear them. */
404 HOWTO (R_PPC_ADDR24, /* type */
405 0, /* rightshift */
406 2, /* size (0 = byte, 1 = short, 2 = long) */
407 26, /* 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_ADDR24", /* name */
413 FALSE, /* partial_inplace */
414 0, /* src_mask */
415 0x3fffffc, /* dst_mask */
416 FALSE), /* pcrel_offset */
417
418 /* A standard 16 bit relocation. */
419 HOWTO (R_PPC_ADDR16, /* type */
420 0, /* rightshift */
421 1, /* size (0 = byte, 1 = short, 2 = long) */
422 16, /* bitsize */
423 FALSE, /* pc_relative */
424 0, /* bitpos */
425 complain_overflow_bitfield, /* complain_on_overflow */
426 bfd_elf_generic_reloc, /* special_function */
427 "R_PPC_ADDR16", /* name */
428 FALSE, /* partial_inplace */
429 0, /* src_mask */
430 0xffff, /* dst_mask */
431 FALSE), /* pcrel_offset */
432
433 /* A 16 bit relocation without overflow. */
434 HOWTO (R_PPC_ADDR16_LO, /* type */
435 0, /* rightshift */
436 1, /* size (0 = byte, 1 = short, 2 = long) */
437 16, /* bitsize */
438 FALSE, /* pc_relative */
439 0, /* bitpos */
440 complain_overflow_dont,/* complain_on_overflow */
441 bfd_elf_generic_reloc, /* special_function */
442 "R_PPC_ADDR16_LO", /* name */
443 FALSE, /* partial_inplace */
444 0, /* src_mask */
445 0xffff, /* dst_mask */
446 FALSE), /* pcrel_offset */
447
448 /* The high order 16 bits of an address. */
449 HOWTO (R_PPC_ADDR16_HI, /* type */
450 16, /* rightshift */
451 1, /* size (0 = byte, 1 = short, 2 = long) */
452 16, /* bitsize */
453 FALSE, /* pc_relative */
454 0, /* bitpos */
455 complain_overflow_dont, /* complain_on_overflow */
456 bfd_elf_generic_reloc, /* special_function */
457 "R_PPC_ADDR16_HI", /* name */
458 FALSE, /* partial_inplace */
459 0, /* src_mask */
460 0xffff, /* dst_mask */
461 FALSE), /* pcrel_offset */
462
463 /* The high order 16 bits of an address, plus 1 if the contents of
464 the low 16 bits, treated as a signed number, is negative. */
465 HOWTO (R_PPC_ADDR16_HA, /* type */
466 16, /* rightshift */
467 1, /* size (0 = byte, 1 = short, 2 = long) */
468 16, /* bitsize */
469 FALSE, /* pc_relative */
470 0, /* bitpos */
471 complain_overflow_dont, /* complain_on_overflow */
472 ppc_elf_addr16_ha_reloc, /* special_function */
473 "R_PPC_ADDR16_HA", /* name */
474 FALSE, /* partial_inplace */
475 0, /* src_mask */
476 0xffff, /* dst_mask */
477 FALSE), /* pcrel_offset */
478
479 /* An absolute 16 bit branch; the lower two bits must be zero.
480 FIXME: we don't check that, we just clear them. */
481 HOWTO (R_PPC_ADDR14, /* type */
482 0, /* rightshift */
483 2, /* size (0 = byte, 1 = short, 2 = long) */
484 16, /* bitsize */
485 FALSE, /* pc_relative */
486 0, /* bitpos */
487 complain_overflow_bitfield, /* complain_on_overflow */
488 bfd_elf_generic_reloc, /* special_function */
489 "R_PPC_ADDR14", /* name */
490 FALSE, /* partial_inplace */
491 0, /* src_mask */
492 0xfffc, /* dst_mask */
493 FALSE), /* pcrel_offset */
494
495 /* An absolute 16 bit branch, for which bit 10 should be set to
496 indicate that the branch is expected to be taken. The lower two
497 bits must be zero. */
498 HOWTO (R_PPC_ADDR14_BRTAKEN, /* type */
499 0, /* rightshift */
500 2, /* size (0 = byte, 1 = short, 2 = long) */
501 16, /* bitsize */
502 FALSE, /* pc_relative */
503 0, /* bitpos */
504 complain_overflow_bitfield, /* complain_on_overflow */
505 bfd_elf_generic_reloc, /* special_function */
506 "R_PPC_ADDR14_BRTAKEN",/* name */
507 FALSE, /* partial_inplace */
508 0, /* src_mask */
509 0xfffc, /* dst_mask */
510 FALSE), /* pcrel_offset */
511
512 /* An absolute 16 bit branch, for which bit 10 should be set to
513 indicate that the branch is not expected to be taken. The lower
514 two bits must be zero. */
515 HOWTO (R_PPC_ADDR14_BRNTAKEN, /* type */
516 0, /* rightshift */
517 2, /* size (0 = byte, 1 = short, 2 = long) */
518 16, /* bitsize */
519 FALSE, /* pc_relative */
520 0, /* bitpos */
521 complain_overflow_bitfield, /* complain_on_overflow */
522 bfd_elf_generic_reloc, /* special_function */
523 "R_PPC_ADDR14_BRNTAKEN",/* name */
524 FALSE, /* partial_inplace */
525 0, /* src_mask */
526 0xfffc, /* dst_mask */
527 FALSE), /* pcrel_offset */
528
529 /* A relative 26 bit branch; the lower two bits must be zero. */
530 HOWTO (R_PPC_REL24, /* type */
531 0, /* rightshift */
532 2, /* size (0 = byte, 1 = short, 2 = long) */
533 26, /* bitsize */
534 TRUE, /* pc_relative */
535 0, /* bitpos */
536 complain_overflow_signed, /* complain_on_overflow */
537 bfd_elf_generic_reloc, /* special_function */
538 "R_PPC_REL24", /* name */
539 FALSE, /* partial_inplace */
540 0, /* src_mask */
541 0x3fffffc, /* dst_mask */
542 TRUE), /* pcrel_offset */
543
544 /* A relative 16 bit branch; the lower two bits must be zero. */
545 HOWTO (R_PPC_REL14, /* type */
546 0, /* rightshift */
547 2, /* size (0 = byte, 1 = short, 2 = long) */
548 16, /* bitsize */
549 TRUE, /* pc_relative */
550 0, /* bitpos */
551 complain_overflow_signed, /* complain_on_overflow */
552 bfd_elf_generic_reloc, /* special_function */
553 "R_PPC_REL14", /* name */
554 FALSE, /* partial_inplace */
555 0, /* src_mask */
556 0xfffc, /* dst_mask */
557 TRUE), /* pcrel_offset */
558
559 /* A relative 16 bit branch. Bit 10 should be set to indicate that
560 the branch is expected to be taken. The lower two bits must be
561 zero. */
562 HOWTO (R_PPC_REL14_BRTAKEN, /* type */
563 0, /* rightshift */
564 2, /* size (0 = byte, 1 = short, 2 = long) */
565 16, /* bitsize */
566 TRUE, /* pc_relative */
567 0, /* bitpos */
568 complain_overflow_signed, /* complain_on_overflow */
569 bfd_elf_generic_reloc, /* special_function */
570 "R_PPC_REL14_BRTAKEN", /* name */
571 FALSE, /* partial_inplace */
572 0, /* src_mask */
573 0xfffc, /* dst_mask */
574 TRUE), /* pcrel_offset */
575
576 /* A relative 16 bit branch. Bit 10 should be set to indicate that
577 the branch is not expected to be taken. The lower two bits must
578 be zero. */
579 HOWTO (R_PPC_REL14_BRNTAKEN, /* type */
580 0, /* rightshift */
581 2, /* size (0 = byte, 1 = short, 2 = long) */
582 16, /* bitsize */
583 TRUE, /* pc_relative */
584 0, /* bitpos */
585 complain_overflow_signed, /* complain_on_overflow */
586 bfd_elf_generic_reloc, /* special_function */
587 "R_PPC_REL14_BRNTAKEN",/* name */
588 FALSE, /* partial_inplace */
589 0, /* src_mask */
590 0xfffc, /* dst_mask */
591 TRUE), /* pcrel_offset */
592
593 /* Like R_PPC_ADDR16, but referring to the GOT table entry for the
594 symbol. */
595 HOWTO (R_PPC_GOT16, /* type */
596 0, /* rightshift */
597 1, /* size (0 = byte, 1 = short, 2 = long) */
598 16, /* bitsize */
599 FALSE, /* pc_relative */
600 0, /* bitpos */
601 complain_overflow_signed, /* complain_on_overflow */
602 bfd_elf_generic_reloc, /* special_function */
603 "R_PPC_GOT16", /* name */
604 FALSE, /* partial_inplace */
605 0, /* src_mask */
606 0xffff, /* dst_mask */
607 FALSE), /* pcrel_offset */
608
609 /* Like R_PPC_ADDR16_LO, but referring to the GOT table entry for
610 the symbol. */
611 HOWTO (R_PPC_GOT16_LO, /* type */
612 0, /* rightshift */
613 1, /* size (0 = byte, 1 = short, 2 = long) */
614 16, /* bitsize */
615 FALSE, /* pc_relative */
616 0, /* bitpos */
617 complain_overflow_dont, /* complain_on_overflow */
618 bfd_elf_generic_reloc, /* special_function */
619 "R_PPC_GOT16_LO", /* name */
620 FALSE, /* partial_inplace */
621 0, /* src_mask */
622 0xffff, /* dst_mask */
623 FALSE), /* pcrel_offset */
624
625 /* Like R_PPC_ADDR16_HI, but referring to the GOT table entry for
626 the symbol. */
627 HOWTO (R_PPC_GOT16_HI, /* type */
628 16, /* rightshift */
629 1, /* size (0 = byte, 1 = short, 2 = long) */
630 16, /* bitsize */
631 FALSE, /* pc_relative */
632 0, /* bitpos */
633 complain_overflow_bitfield, /* complain_on_overflow */
634 bfd_elf_generic_reloc, /* special_function */
635 "R_PPC_GOT16_HI", /* name */
636 FALSE, /* partial_inplace */
637 0, /* src_mask */
638 0xffff, /* dst_mask */
639 FALSE), /* pcrel_offset */
640
641 /* Like R_PPC_ADDR16_HA, but referring to the GOT table entry for
642 the symbol. */
643 HOWTO (R_PPC_GOT16_HA, /* type */
644 16, /* rightshift */
645 1, /* size (0 = byte, 1 = short, 2 = long) */
646 16, /* bitsize */
647 FALSE, /* pc_relative */
648 0, /* bitpos */
649 complain_overflow_bitfield, /* complain_on_overflow */
650 ppc_elf_addr16_ha_reloc, /* special_function */
651 "R_PPC_GOT16_HA", /* name */
652 FALSE, /* partial_inplace */
653 0, /* src_mask */
654 0xffff, /* dst_mask */
655 FALSE), /* pcrel_offset */
656
657 /* Like R_PPC_REL24, but referring to the procedure linkage table
658 entry for the symbol. */
659 HOWTO (R_PPC_PLTREL24, /* type */
660 0, /* rightshift */
661 2, /* size (0 = byte, 1 = short, 2 = long) */
662 26, /* bitsize */
663 TRUE, /* pc_relative */
664 0, /* bitpos */
665 complain_overflow_signed, /* complain_on_overflow */
666 bfd_elf_generic_reloc, /* special_function */
667 "R_PPC_PLTREL24", /* name */
668 FALSE, /* partial_inplace */
669 0, /* src_mask */
670 0x3fffffc, /* dst_mask */
671 TRUE), /* pcrel_offset */
672
673 /* This is used only by the dynamic linker. The symbol should exist
674 both in the object being run and in some shared library. The
675 dynamic linker copies the data addressed by the symbol from the
676 shared library into the object, because the object being
677 run has to have the data at some particular address. */
678 HOWTO (R_PPC_COPY, /* type */
679 0, /* rightshift */
680 2, /* size (0 = byte, 1 = short, 2 = long) */
681 32, /* bitsize */
682 FALSE, /* pc_relative */
683 0, /* bitpos */
684 complain_overflow_bitfield, /* complain_on_overflow */
685 bfd_elf_generic_reloc, /* special_function */
686 "R_PPC_COPY", /* name */
687 FALSE, /* partial_inplace */
688 0, /* src_mask */
689 0, /* dst_mask */
690 FALSE), /* pcrel_offset */
691
692 /* Like R_PPC_ADDR32, but used when setting global offset table
693 entries. */
694 HOWTO (R_PPC_GLOB_DAT, /* type */
695 0, /* rightshift */
696 2, /* size (0 = byte, 1 = short, 2 = long) */
697 32, /* bitsize */
698 FALSE, /* pc_relative */
699 0, /* bitpos */
700 complain_overflow_bitfield, /* complain_on_overflow */
701 bfd_elf_generic_reloc, /* special_function */
702 "R_PPC_GLOB_DAT", /* name */
703 FALSE, /* partial_inplace */
704 0, /* src_mask */
705 0xffffffff, /* dst_mask */
706 FALSE), /* pcrel_offset */
707
708 /* Marks a procedure linkage table entry for a symbol. */
709 HOWTO (R_PPC_JMP_SLOT, /* type */
710 0, /* rightshift */
711 2, /* size (0 = byte, 1 = short, 2 = long) */
712 32, /* bitsize */
713 FALSE, /* pc_relative */
714 0, /* bitpos */
715 complain_overflow_bitfield, /* complain_on_overflow */
716 bfd_elf_generic_reloc, /* special_function */
717 "R_PPC_JMP_SLOT", /* name */
718 FALSE, /* partial_inplace */
719 0, /* src_mask */
720 0, /* dst_mask */
721 FALSE), /* pcrel_offset */
722
723 /* Used only by the dynamic linker. When the object is run, this
724 longword is set to the load address of the object, plus the
725 addend. */
726 HOWTO (R_PPC_RELATIVE, /* type */
727 0, /* rightshift */
728 2, /* size (0 = byte, 1 = short, 2 = long) */
729 32, /* bitsize */
730 FALSE, /* pc_relative */
731 0, /* bitpos */
732 complain_overflow_bitfield, /* complain_on_overflow */
733 bfd_elf_generic_reloc, /* special_function */
734 "R_PPC_RELATIVE", /* name */
735 FALSE, /* partial_inplace */
736 0, /* src_mask */
737 0xffffffff, /* dst_mask */
738 FALSE), /* pcrel_offset */
739
740 /* Like R_PPC_REL24, but uses the value of the symbol within the
741 object rather than the final value. Normally used for
742 _GLOBAL_OFFSET_TABLE_. */
743 HOWTO (R_PPC_LOCAL24PC, /* type */
744 0, /* rightshift */
745 2, /* size (0 = byte, 1 = short, 2 = long) */
746 26, /* bitsize */
747 TRUE, /* pc_relative */
748 0, /* bitpos */
749 complain_overflow_signed, /* complain_on_overflow */
750 bfd_elf_generic_reloc, /* special_function */
751 "R_PPC_LOCAL24PC", /* name */
752 FALSE, /* partial_inplace */
753 0, /* src_mask */
754 0x3fffffc, /* dst_mask */
755 TRUE), /* pcrel_offset */
756
757 /* Like R_PPC_ADDR32, but may be unaligned. */
758 HOWTO (R_PPC_UADDR32, /* type */
759 0, /* rightshift */
760 2, /* size (0 = byte, 1 = short, 2 = long) */
761 32, /* bitsize */
762 FALSE, /* pc_relative */
763 0, /* bitpos */
764 complain_overflow_bitfield, /* complain_on_overflow */
765 bfd_elf_generic_reloc, /* special_function */
766 "R_PPC_UADDR32", /* name */
767 FALSE, /* partial_inplace */
768 0, /* src_mask */
769 0xffffffff, /* dst_mask */
770 FALSE), /* pcrel_offset */
771
772 /* Like R_PPC_ADDR16, but may be unaligned. */
773 HOWTO (R_PPC_UADDR16, /* type */
774 0, /* rightshift */
775 1, /* size (0 = byte, 1 = short, 2 = long) */
776 16, /* bitsize */
777 FALSE, /* pc_relative */
778 0, /* bitpos */
779 complain_overflow_bitfield, /* complain_on_overflow */
780 bfd_elf_generic_reloc, /* special_function */
781 "R_PPC_UADDR16", /* name */
782 FALSE, /* partial_inplace */
783 0, /* src_mask */
784 0xffff, /* dst_mask */
785 FALSE), /* pcrel_offset */
786
787 /* 32-bit PC relative */
788 HOWTO (R_PPC_REL32, /* type */
789 0, /* rightshift */
790 2, /* size (0 = byte, 1 = short, 2 = long) */
791 32, /* bitsize */
792 TRUE, /* pc_relative */
793 0, /* bitpos */
794 complain_overflow_bitfield, /* complain_on_overflow */
795 bfd_elf_generic_reloc, /* special_function */
796 "R_PPC_REL32", /* name */
797 FALSE, /* partial_inplace */
798 0, /* src_mask */
799 0xffffffff, /* dst_mask */
800 TRUE), /* pcrel_offset */
801
802 /* 32-bit relocation to the symbol's procedure linkage table.
803 FIXME: not supported. */
804 HOWTO (R_PPC_PLT32, /* type */
805 0, /* rightshift */
806 2, /* size (0 = byte, 1 = short, 2 = long) */
807 32, /* bitsize */
808 FALSE, /* pc_relative */
809 0, /* bitpos */
810 complain_overflow_bitfield, /* complain_on_overflow */
811 bfd_elf_generic_reloc, /* special_function */
812 "R_PPC_PLT32", /* name */
813 FALSE, /* partial_inplace */
814 0, /* src_mask */
815 0, /* dst_mask */
816 FALSE), /* pcrel_offset */
817
818 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
819 FIXME: not supported. */
820 HOWTO (R_PPC_PLTREL32, /* type */
821 0, /* rightshift */
822 2, /* size (0 = byte, 1 = short, 2 = long) */
823 32, /* bitsize */
824 TRUE, /* pc_relative */
825 0, /* bitpos */
826 complain_overflow_bitfield, /* complain_on_overflow */
827 bfd_elf_generic_reloc, /* special_function */
828 "R_PPC_PLTREL32", /* name */
829 FALSE, /* partial_inplace */
830 0, /* src_mask */
831 0, /* dst_mask */
832 TRUE), /* pcrel_offset */
833
834 /* Like R_PPC_ADDR16_LO, but referring to the PLT table entry for
835 the symbol. */
836 HOWTO (R_PPC_PLT16_LO, /* type */
837 0, /* rightshift */
838 1, /* size (0 = byte, 1 = short, 2 = long) */
839 16, /* bitsize */
840 FALSE, /* pc_relative */
841 0, /* bitpos */
842 complain_overflow_dont, /* complain_on_overflow */
843 bfd_elf_generic_reloc, /* special_function */
844 "R_PPC_PLT16_LO", /* name */
845 FALSE, /* partial_inplace */
846 0, /* src_mask */
847 0xffff, /* dst_mask */
848 FALSE), /* pcrel_offset */
849
850 /* Like R_PPC_ADDR16_HI, but referring to the PLT table entry for
851 the symbol. */
852 HOWTO (R_PPC_PLT16_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_PLT16_HI", /* name */
861 FALSE, /* partial_inplace */
862 0, /* src_mask */
863 0xffff, /* dst_mask */
864 FALSE), /* pcrel_offset */
865
866 /* Like R_PPC_ADDR16_HA, but referring to the PLT table entry for
867 the symbol. */
868 HOWTO (R_PPC_PLT16_HA, /* type */
869 16, /* rightshift */
870 1, /* size (0 = byte, 1 = short, 2 = long) */
871 16, /* bitsize */
872 FALSE, /* pc_relative */
873 0, /* bitpos */
874 complain_overflow_bitfield, /* complain_on_overflow */
875 ppc_elf_addr16_ha_reloc, /* special_function */
876 "R_PPC_PLT16_HA", /* name */
877 FALSE, /* partial_inplace */
878 0, /* src_mask */
879 0xffff, /* dst_mask */
880 FALSE), /* pcrel_offset */
881
882 /* A sign-extended 16 bit value relative to _SDA_BASE_, for use with
883 small data items. */
884 HOWTO (R_PPC_SDAREL16, /* type */
885 0, /* rightshift */
886 1, /* size (0 = byte, 1 = short, 2 = long) */
887 16, /* bitsize */
888 FALSE, /* pc_relative */
889 0, /* bitpos */
890 complain_overflow_signed, /* complain_on_overflow */
891 bfd_elf_generic_reloc, /* special_function */
892 "R_PPC_SDAREL16", /* name */
893 FALSE, /* partial_inplace */
894 0, /* src_mask */
895 0xffff, /* dst_mask */
896 FALSE), /* pcrel_offset */
897
898 /* 16-bit section relative relocation. */
899 HOWTO (R_PPC_SECTOFF, /* type */
900 0, /* rightshift */
901 1, /* size (0 = byte, 1 = short, 2 = long) */
902 16, /* bitsize */
903 FALSE, /* pc_relative */
904 0, /* bitpos */
905 complain_overflow_bitfield, /* complain_on_overflow */
906 bfd_elf_generic_reloc, /* special_function */
907 "R_PPC_SECTOFF", /* name */
908 FALSE, /* partial_inplace */
909 0, /* src_mask */
910 0xffff, /* dst_mask */
911 FALSE), /* pcrel_offset */
912
913 /* 16-bit lower half section relative relocation. */
914 HOWTO (R_PPC_SECTOFF_LO, /* type */
915 0, /* rightshift */
916 1, /* size (0 = byte, 1 = short, 2 = long) */
917 16, /* bitsize */
918 FALSE, /* pc_relative */
919 0, /* bitpos */
920 complain_overflow_dont, /* complain_on_overflow */
921 bfd_elf_generic_reloc, /* special_function */
922 "R_PPC_SECTOFF_LO", /* name */
923 FALSE, /* partial_inplace */
924 0, /* src_mask */
925 0xffff, /* dst_mask */
926 FALSE), /* pcrel_offset */
927
928 /* 16-bit upper half section relative relocation. */
929 HOWTO (R_PPC_SECTOFF_HI, /* type */
930 16, /* rightshift */
931 1, /* size (0 = byte, 1 = short, 2 = long) */
932 16, /* bitsize */
933 FALSE, /* pc_relative */
934 0, /* bitpos */
935 complain_overflow_bitfield, /* complain_on_overflow */
936 bfd_elf_generic_reloc, /* special_function */
937 "R_PPC_SECTOFF_HI", /* name */
938 FALSE, /* partial_inplace */
939 0, /* src_mask */
940 0xffff, /* dst_mask */
941 FALSE), /* pcrel_offset */
942
943 /* 16-bit upper half adjusted section relative relocation. */
944 HOWTO (R_PPC_SECTOFF_HA, /* type */
945 16, /* rightshift */
946 1, /* size (0 = byte, 1 = short, 2 = long) */
947 16, /* bitsize */
948 FALSE, /* pc_relative */
949 0, /* bitpos */
950 complain_overflow_bitfield, /* complain_on_overflow */
951 ppc_elf_addr16_ha_reloc, /* special_function */
952 "R_PPC_SECTOFF_HA", /* name */
953 FALSE, /* partial_inplace */
954 0, /* src_mask */
955 0xffff, /* dst_mask */
956 FALSE), /* pcrel_offset */
957
958 /* Marker reloc for TLS. */
959 HOWTO (R_PPC_TLS,
960 0, /* rightshift */
961 2, /* size (0 = byte, 1 = short, 2 = long) */
962 32, /* bitsize */
963 FALSE, /* pc_relative */
964 0, /* bitpos */
965 complain_overflow_dont, /* complain_on_overflow */
966 bfd_elf_generic_reloc, /* special_function */
967 "R_PPC_TLS", /* name */
968 FALSE, /* partial_inplace */
969 0, /* src_mask */
970 0, /* dst_mask */
971 FALSE), /* pcrel_offset */
972
973 /* Computes the load module index of the load module that contains the
974 definition of its TLS sym. */
975 HOWTO (R_PPC_DTPMOD32,
976 0, /* rightshift */
977 2, /* size (0 = byte, 1 = short, 2 = long) */
978 32, /* bitsize */
979 FALSE, /* pc_relative */
980 0, /* bitpos */
981 complain_overflow_dont, /* complain_on_overflow */
982 ppc_elf_unhandled_reloc, /* special_function */
983 "R_PPC_DTPMOD32", /* name */
984 FALSE, /* partial_inplace */
985 0, /* src_mask */
986 0xffffffff, /* dst_mask */
987 FALSE), /* pcrel_offset */
988
989 /* Computes a dtv-relative displacement, the difference between the value
990 of sym+add and the base address of the thread-local storage block that
991 contains the definition of sym, minus 0x8000. */
992 HOWTO (R_PPC_DTPREL32,
993 0, /* rightshift */
994 2, /* size (0 = byte, 1 = short, 2 = long) */
995 32, /* bitsize */
996 FALSE, /* pc_relative */
997 0, /* bitpos */
998 complain_overflow_dont, /* complain_on_overflow */
999 ppc_elf_unhandled_reloc, /* special_function */
1000 "R_PPC_DTPREL32", /* name */
1001 FALSE, /* partial_inplace */
1002 0, /* src_mask */
1003 0xffffffff, /* dst_mask */
1004 FALSE), /* pcrel_offset */
1005
1006 /* A 16 bit dtprel reloc. */
1007 HOWTO (R_PPC_DTPREL16,
1008 0, /* rightshift */
1009 1, /* size (0 = byte, 1 = short, 2 = long) */
1010 16, /* bitsize */
1011 FALSE, /* pc_relative */
1012 0, /* bitpos */
1013 complain_overflow_signed, /* complain_on_overflow */
1014 ppc_elf_unhandled_reloc, /* special_function */
1015 "R_PPC_DTPREL16", /* name */
1016 FALSE, /* partial_inplace */
1017 0, /* src_mask */
1018 0xffff, /* dst_mask */
1019 FALSE), /* pcrel_offset */
1020
1021 /* Like DTPREL16, but no overflow. */
1022 HOWTO (R_PPC_DTPREL16_LO,
1023 0, /* rightshift */
1024 1, /* size (0 = byte, 1 = short, 2 = long) */
1025 16, /* bitsize */
1026 FALSE, /* pc_relative */
1027 0, /* bitpos */
1028 complain_overflow_dont, /* complain_on_overflow */
1029 ppc_elf_unhandled_reloc, /* special_function */
1030 "R_PPC_DTPREL16_LO", /* name */
1031 FALSE, /* partial_inplace */
1032 0, /* src_mask */
1033 0xffff, /* dst_mask */
1034 FALSE), /* pcrel_offset */
1035
1036 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1037 HOWTO (R_PPC_DTPREL16_HI,
1038 16, /* rightshift */
1039 1, /* size (0 = byte, 1 = short, 2 = long) */
1040 16, /* bitsize */
1041 FALSE, /* pc_relative */
1042 0, /* bitpos */
1043 complain_overflow_dont, /* complain_on_overflow */
1044 ppc_elf_unhandled_reloc, /* special_function */
1045 "R_PPC_DTPREL16_HI", /* name */
1046 FALSE, /* partial_inplace */
1047 0, /* src_mask */
1048 0xffff, /* dst_mask */
1049 FALSE), /* pcrel_offset */
1050
1051 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1052 HOWTO (R_PPC_DTPREL16_HA,
1053 16, /* rightshift */
1054 1, /* size (0 = byte, 1 = short, 2 = long) */
1055 16, /* bitsize */
1056 FALSE, /* pc_relative */
1057 0, /* bitpos */
1058 complain_overflow_dont, /* complain_on_overflow */
1059 ppc_elf_unhandled_reloc, /* special_function */
1060 "R_PPC_DTPREL16_HA", /* name */
1061 FALSE, /* partial_inplace */
1062 0, /* src_mask */
1063 0xffff, /* dst_mask */
1064 FALSE), /* pcrel_offset */
1065
1066 /* Computes a tp-relative displacement, the difference between the value of
1067 sym+add and the value of the thread pointer (r13). */
1068 HOWTO (R_PPC_TPREL32,
1069 0, /* rightshift */
1070 2, /* size (0 = byte, 1 = short, 2 = long) */
1071 32, /* bitsize */
1072 FALSE, /* pc_relative */
1073 0, /* bitpos */
1074 complain_overflow_dont, /* complain_on_overflow */
1075 ppc_elf_unhandled_reloc, /* special_function */
1076 "R_PPC_TPREL32", /* name */
1077 FALSE, /* partial_inplace */
1078 0, /* src_mask */
1079 0xffffffff, /* dst_mask */
1080 FALSE), /* pcrel_offset */
1081
1082 /* A 16 bit tprel reloc. */
1083 HOWTO (R_PPC_TPREL16,
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 ppc_elf_unhandled_reloc, /* special_function */
1091 "R_PPC_TPREL16", /* name */
1092 FALSE, /* partial_inplace */
1093 0, /* src_mask */
1094 0xffff, /* dst_mask */
1095 FALSE), /* pcrel_offset */
1096
1097 /* Like TPREL16, but no overflow. */
1098 HOWTO (R_PPC_TPREL16_LO,
1099 0, /* rightshift */
1100 1, /* size (0 = byte, 1 = short, 2 = long) */
1101 16, /* bitsize */
1102 FALSE, /* pc_relative */
1103 0, /* bitpos */
1104 complain_overflow_dont, /* complain_on_overflow */
1105 ppc_elf_unhandled_reloc, /* special_function */
1106 "R_PPC_TPREL16_LO", /* name */
1107 FALSE, /* partial_inplace */
1108 0, /* src_mask */
1109 0xffff, /* dst_mask */
1110 FALSE), /* pcrel_offset */
1111
1112 /* Like TPREL16_LO, but next higher group of 16 bits. */
1113 HOWTO (R_PPC_TPREL16_HI,
1114 16, /* rightshift */
1115 1, /* size (0 = byte, 1 = short, 2 = long) */
1116 16, /* bitsize */
1117 FALSE, /* pc_relative */
1118 0, /* bitpos */
1119 complain_overflow_dont, /* complain_on_overflow */
1120 ppc_elf_unhandled_reloc, /* special_function */
1121 "R_PPC_TPREL16_HI", /* name */
1122 FALSE, /* partial_inplace */
1123 0, /* src_mask */
1124 0xffff, /* dst_mask */
1125 FALSE), /* pcrel_offset */
1126
1127 /* Like TPREL16_HI, but adjust for low 16 bits. */
1128 HOWTO (R_PPC_TPREL16_HA,
1129 16, /* rightshift */
1130 1, /* size (0 = byte, 1 = short, 2 = long) */
1131 16, /* bitsize */
1132 FALSE, /* pc_relative */
1133 0, /* bitpos */
1134 complain_overflow_dont, /* complain_on_overflow */
1135 ppc_elf_unhandled_reloc, /* special_function */
1136 "R_PPC_TPREL16_HA", /* name */
1137 FALSE, /* partial_inplace */
1138 0, /* src_mask */
1139 0xffff, /* dst_mask */
1140 FALSE), /* pcrel_offset */
1141
1142 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1143 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1144 to the first entry. */
1145 HOWTO (R_PPC_GOT_TLSGD16,
1146 0, /* rightshift */
1147 1, /* size (0 = byte, 1 = short, 2 = long) */
1148 16, /* bitsize */
1149 FALSE, /* pc_relative */
1150 0, /* bitpos */
1151 complain_overflow_signed, /* complain_on_overflow */
1152 ppc_elf_unhandled_reloc, /* special_function */
1153 "R_PPC_GOT_TLSGD16", /* name */
1154 FALSE, /* partial_inplace */
1155 0, /* src_mask */
1156 0xffff, /* dst_mask */
1157 FALSE), /* pcrel_offset */
1158
1159 /* Like GOT_TLSGD16, but no overflow. */
1160 HOWTO (R_PPC_GOT_TLSGD16_LO,
1161 0, /* rightshift */
1162 1, /* size (0 = byte, 1 = short, 2 = long) */
1163 16, /* bitsize */
1164 FALSE, /* pc_relative */
1165 0, /* bitpos */
1166 complain_overflow_dont, /* complain_on_overflow */
1167 ppc_elf_unhandled_reloc, /* special_function */
1168 "R_PPC_GOT_TLSGD16_LO", /* name */
1169 FALSE, /* partial_inplace */
1170 0, /* src_mask */
1171 0xffff, /* dst_mask */
1172 FALSE), /* pcrel_offset */
1173
1174 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1175 HOWTO (R_PPC_GOT_TLSGD16_HI,
1176 16, /* rightshift */
1177 1, /* size (0 = byte, 1 = short, 2 = long) */
1178 16, /* bitsize */
1179 FALSE, /* pc_relative */
1180 0, /* bitpos */
1181 complain_overflow_dont, /* complain_on_overflow */
1182 ppc_elf_unhandled_reloc, /* special_function */
1183 "R_PPC_GOT_TLSGD16_HI", /* name */
1184 FALSE, /* partial_inplace */
1185 0, /* src_mask */
1186 0xffff, /* dst_mask */
1187 FALSE), /* pcrel_offset */
1188
1189 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1190 HOWTO (R_PPC_GOT_TLSGD16_HA,
1191 16, /* rightshift */
1192 1, /* size (0 = byte, 1 = short, 2 = long) */
1193 16, /* bitsize */
1194 FALSE, /* pc_relative */
1195 0, /* bitpos */
1196 complain_overflow_dont, /* complain_on_overflow */
1197 ppc_elf_unhandled_reloc, /* special_function */
1198 "R_PPC_GOT_TLSGD16_HA", /* name */
1199 FALSE, /* partial_inplace */
1200 0, /* src_mask */
1201 0xffff, /* dst_mask */
1202 FALSE), /* pcrel_offset */
1203
1204 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1205 with values (sym+add)@dtpmod and zero, and computes the offset to the
1206 first entry. */
1207 HOWTO (R_PPC_GOT_TLSLD16,
1208 0, /* rightshift */
1209 1, /* size (0 = byte, 1 = short, 2 = long) */
1210 16, /* bitsize */
1211 FALSE, /* pc_relative */
1212 0, /* bitpos */
1213 complain_overflow_signed, /* complain_on_overflow */
1214 ppc_elf_unhandled_reloc, /* special_function */
1215 "R_PPC_GOT_TLSLD16", /* name */
1216 FALSE, /* partial_inplace */
1217 0, /* src_mask */
1218 0xffff, /* dst_mask */
1219 FALSE), /* pcrel_offset */
1220
1221 /* Like GOT_TLSLD16, but no overflow. */
1222 HOWTO (R_PPC_GOT_TLSLD16_LO,
1223 0, /* rightshift */
1224 1, /* size (0 = byte, 1 = short, 2 = long) */
1225 16, /* bitsize */
1226 FALSE, /* pc_relative */
1227 0, /* bitpos */
1228 complain_overflow_dont, /* complain_on_overflow */
1229 ppc_elf_unhandled_reloc, /* special_function */
1230 "R_PPC_GOT_TLSLD16_LO", /* name */
1231 FALSE, /* partial_inplace */
1232 0, /* src_mask */
1233 0xffff, /* dst_mask */
1234 FALSE), /* pcrel_offset */
1235
1236 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1237 HOWTO (R_PPC_GOT_TLSLD16_HI,
1238 16, /* rightshift */
1239 1, /* size (0 = byte, 1 = short, 2 = long) */
1240 16, /* bitsize */
1241 FALSE, /* pc_relative */
1242 0, /* bitpos */
1243 complain_overflow_dont, /* complain_on_overflow */
1244 ppc_elf_unhandled_reloc, /* special_function */
1245 "R_PPC_GOT_TLSLD16_HI", /* name */
1246 FALSE, /* partial_inplace */
1247 0, /* src_mask */
1248 0xffff, /* dst_mask */
1249 FALSE), /* pcrel_offset */
1250
1251 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1252 HOWTO (R_PPC_GOT_TLSLD16_HA,
1253 16, /* rightshift */
1254 1, /* size (0 = byte, 1 = short, 2 = long) */
1255 16, /* bitsize */
1256 FALSE, /* pc_relative */
1257 0, /* bitpos */
1258 complain_overflow_dont, /* complain_on_overflow */
1259 ppc_elf_unhandled_reloc, /* special_function */
1260 "R_PPC_GOT_TLSLD16_HA", /* name */
1261 FALSE, /* partial_inplace */
1262 0, /* src_mask */
1263 0xffff, /* dst_mask */
1264 FALSE), /* pcrel_offset */
1265
1266 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1267 the offset to the entry. */
1268 HOWTO (R_PPC_GOT_DTPREL16,
1269 0, /* rightshift */
1270 1, /* size (0 = byte, 1 = short, 2 = long) */
1271 16, /* bitsize */
1272 FALSE, /* pc_relative */
1273 0, /* bitpos */
1274 complain_overflow_signed, /* complain_on_overflow */
1275 ppc_elf_unhandled_reloc, /* special_function */
1276 "R_PPC_GOT_DTPREL16", /* name */
1277 FALSE, /* partial_inplace */
1278 0, /* src_mask */
1279 0xffff, /* dst_mask */
1280 FALSE), /* pcrel_offset */
1281
1282 /* Like GOT_DTPREL16, but no overflow. */
1283 HOWTO (R_PPC_GOT_DTPREL16_LO,
1284 0, /* rightshift */
1285 1, /* size (0 = byte, 1 = short, 2 = long) */
1286 16, /* bitsize */
1287 FALSE, /* pc_relative */
1288 0, /* bitpos */
1289 complain_overflow_dont, /* complain_on_overflow */
1290 ppc_elf_unhandled_reloc, /* special_function */
1291 "R_PPC_GOT_DTPREL16_LO", /* name */
1292 FALSE, /* partial_inplace */
1293 0, /* src_mask */
1294 0xffff, /* dst_mask */
1295 FALSE), /* pcrel_offset */
1296
1297 /* Like GOT_DTPREL16_LO, but next higher group of 16 bits. */
1298 HOWTO (R_PPC_GOT_DTPREL16_HI,
1299 16, /* rightshift */
1300 1, /* size (0 = byte, 1 = short, 2 = long) */
1301 16, /* bitsize */
1302 FALSE, /* pc_relative */
1303 0, /* bitpos */
1304 complain_overflow_dont, /* complain_on_overflow */
1305 ppc_elf_unhandled_reloc, /* special_function */
1306 "R_PPC_GOT_DTPREL16_HI", /* name */
1307 FALSE, /* partial_inplace */
1308 0, /* src_mask */
1309 0xffff, /* dst_mask */
1310 FALSE), /* pcrel_offset */
1311
1312 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1313 HOWTO (R_PPC_GOT_DTPREL16_HA,
1314 16, /* rightshift */
1315 1, /* size (0 = byte, 1 = short, 2 = long) */
1316 16, /* bitsize */
1317 FALSE, /* pc_relative */
1318 0, /* bitpos */
1319 complain_overflow_dont, /* complain_on_overflow */
1320 ppc_elf_unhandled_reloc, /* special_function */
1321 "R_PPC_GOT_DTPREL16_HA", /* name */
1322 FALSE, /* partial_inplace */
1323 0, /* src_mask */
1324 0xffff, /* dst_mask */
1325 FALSE), /* pcrel_offset */
1326
1327 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1328 offset to the entry. */
1329 HOWTO (R_PPC_GOT_TPREL16,
1330 0, /* rightshift */
1331 1, /* size (0 = byte, 1 = short, 2 = long) */
1332 16, /* bitsize */
1333 FALSE, /* pc_relative */
1334 0, /* bitpos */
1335 complain_overflow_signed, /* complain_on_overflow */
1336 ppc_elf_unhandled_reloc, /* special_function */
1337 "R_PPC_GOT_TPREL16", /* name */
1338 FALSE, /* partial_inplace */
1339 0, /* src_mask */
1340 0xffff, /* dst_mask */
1341 FALSE), /* pcrel_offset */
1342
1343 /* Like GOT_TPREL16, but no overflow. */
1344 HOWTO (R_PPC_GOT_TPREL16_LO,
1345 0, /* rightshift */
1346 1, /* size (0 = byte, 1 = short, 2 = long) */
1347 16, /* bitsize */
1348 FALSE, /* pc_relative */
1349 0, /* bitpos */
1350 complain_overflow_dont, /* complain_on_overflow */
1351 ppc_elf_unhandled_reloc, /* special_function */
1352 "R_PPC_GOT_TPREL16_LO", /* name */
1353 FALSE, /* partial_inplace */
1354 0, /* src_mask */
1355 0xffff, /* dst_mask */
1356 FALSE), /* pcrel_offset */
1357
1358 /* Like GOT_TPREL16_LO, but next higher group of 16 bits. */
1359 HOWTO (R_PPC_GOT_TPREL16_HI,
1360 16, /* rightshift */
1361 1, /* size (0 = byte, 1 = short, 2 = long) */
1362 16, /* bitsize */
1363 FALSE, /* pc_relative */
1364 0, /* bitpos */
1365 complain_overflow_dont, /* complain_on_overflow */
1366 ppc_elf_unhandled_reloc, /* special_function */
1367 "R_PPC_GOT_TPREL16_HI", /* name */
1368 FALSE, /* partial_inplace */
1369 0, /* src_mask */
1370 0xffff, /* dst_mask */
1371 FALSE), /* pcrel_offset */
1372
1373 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1374 HOWTO (R_PPC_GOT_TPREL16_HA,
1375 16, /* rightshift */
1376 1, /* size (0 = byte, 1 = short, 2 = long) */
1377 16, /* bitsize */
1378 FALSE, /* pc_relative */
1379 0, /* bitpos */
1380 complain_overflow_dont, /* complain_on_overflow */
1381 ppc_elf_unhandled_reloc, /* special_function */
1382 "R_PPC_GOT_TPREL16_HA", /* name */
1383 FALSE, /* partial_inplace */
1384 0, /* src_mask */
1385 0xffff, /* dst_mask */
1386 FALSE), /* pcrel_offset */
1387
1388 /* The remaining relocs are from the Embedded ELF ABI, and are not
1389 in the SVR4 ELF ABI. */
1390
1391 /* 32 bit value resulting from the addend minus the symbol. */
1392 HOWTO (R_PPC_EMB_NADDR32, /* type */
1393 0, /* rightshift */
1394 2, /* size (0 = byte, 1 = short, 2 = long) */
1395 32, /* bitsize */
1396 FALSE, /* pc_relative */
1397 0, /* bitpos */
1398 complain_overflow_bitfield, /* complain_on_overflow */
1399 bfd_elf_generic_reloc, /* special_function */
1400 "R_PPC_EMB_NADDR32", /* name */
1401 FALSE, /* partial_inplace */
1402 0, /* src_mask */
1403 0xffffffff, /* dst_mask */
1404 FALSE), /* pcrel_offset */
1405
1406 /* 16 bit value resulting from the addend minus the symbol. */
1407 HOWTO (R_PPC_EMB_NADDR16, /* type */
1408 0, /* rightshift */
1409 1, /* size (0 = byte, 1 = short, 2 = long) */
1410 16, /* bitsize */
1411 FALSE, /* pc_relative */
1412 0, /* bitpos */
1413 complain_overflow_bitfield, /* complain_on_overflow */
1414 bfd_elf_generic_reloc, /* special_function */
1415 "R_PPC_EMB_NADDR16", /* name */
1416 FALSE, /* partial_inplace */
1417 0, /* src_mask */
1418 0xffff, /* dst_mask */
1419 FALSE), /* pcrel_offset */
1420
1421 /* 16 bit value resulting from the addend minus the symbol. */
1422 HOWTO (R_PPC_EMB_NADDR16_LO, /* type */
1423 0, /* rightshift */
1424 1, /* size (0 = byte, 1 = short, 2 = long) */
1425 16, /* bitsize */
1426 FALSE, /* pc_relative */
1427 0, /* bitpos */
1428 complain_overflow_dont,/* complain_on_overflow */
1429 bfd_elf_generic_reloc, /* special_function */
1430 "R_PPC_EMB_ADDR16_LO", /* name */
1431 FALSE, /* partial_inplace */
1432 0, /* src_mask */
1433 0xffff, /* dst_mask */
1434 FALSE), /* pcrel_offset */
1435
1436 /* The high order 16 bits of the addend minus the symbol. */
1437 HOWTO (R_PPC_EMB_NADDR16_HI, /* type */
1438 16, /* rightshift */
1439 1, /* size (0 = byte, 1 = short, 2 = long) */
1440 16, /* bitsize */
1441 FALSE, /* pc_relative */
1442 0, /* bitpos */
1443 complain_overflow_dont, /* complain_on_overflow */
1444 bfd_elf_generic_reloc, /* special_function */
1445 "R_PPC_EMB_NADDR16_HI", /* name */
1446 FALSE, /* partial_inplace */
1447 0, /* src_mask */
1448 0xffff, /* dst_mask */
1449 FALSE), /* pcrel_offset */
1450
1451 /* The high order 16 bits of the result of the addend minus the address,
1452 plus 1 if the contents of the low 16 bits, treated as a signed number,
1453 is negative. */
1454 HOWTO (R_PPC_EMB_NADDR16_HA, /* type */
1455 16, /* rightshift */
1456 1, /* size (0 = byte, 1 = short, 2 = long) */
1457 16, /* bitsize */
1458 FALSE, /* pc_relative */
1459 0, /* bitpos */
1460 complain_overflow_dont, /* complain_on_overflow */
1461 ppc_elf_addr16_ha_reloc, /* special_function */
1462 "R_PPC_EMB_NADDR16_HA", /* name */
1463 FALSE, /* partial_inplace */
1464 0, /* src_mask */
1465 0xffff, /* dst_mask */
1466 FALSE), /* pcrel_offset */
1467
1468 /* 16 bit value resulting from allocating a 4 byte word to hold an
1469 address in the .sdata section, and returning the offset from
1470 _SDA_BASE_ for that relocation. */
1471 HOWTO (R_PPC_EMB_SDAI16, /* type */
1472 0, /* rightshift */
1473 1, /* size (0 = byte, 1 = short, 2 = long) */
1474 16, /* bitsize */
1475 FALSE, /* pc_relative */
1476 0, /* bitpos */
1477 complain_overflow_bitfield, /* complain_on_overflow */
1478 bfd_elf_generic_reloc, /* special_function */
1479 "R_PPC_EMB_SDAI16", /* name */
1480 FALSE, /* partial_inplace */
1481 0, /* src_mask */
1482 0xffff, /* dst_mask */
1483 FALSE), /* pcrel_offset */
1484
1485 /* 16 bit value resulting from allocating a 4 byte word to hold an
1486 address in the .sdata2 section, and returning the offset from
1487 _SDA2_BASE_ for that relocation. */
1488 HOWTO (R_PPC_EMB_SDA2I16, /* type */
1489 0, /* rightshift */
1490 1, /* size (0 = byte, 1 = short, 2 = long) */
1491 16, /* bitsize */
1492 FALSE, /* pc_relative */
1493 0, /* bitpos */
1494 complain_overflow_bitfield, /* complain_on_overflow */
1495 bfd_elf_generic_reloc, /* special_function */
1496 "R_PPC_EMB_SDA2I16", /* name */
1497 FALSE, /* partial_inplace */
1498 0, /* src_mask */
1499 0xffff, /* dst_mask */
1500 FALSE), /* pcrel_offset */
1501
1502 /* A sign-extended 16 bit value relative to _SDA2_BASE_, for use with
1503 small data items. */
1504 HOWTO (R_PPC_EMB_SDA2REL, /* type */
1505 0, /* rightshift */
1506 1, /* size (0 = byte, 1 = short, 2 = long) */
1507 16, /* bitsize */
1508 FALSE, /* pc_relative */
1509 0, /* bitpos */
1510 complain_overflow_signed, /* complain_on_overflow */
1511 bfd_elf_generic_reloc, /* special_function */
1512 "R_PPC_EMB_SDA2REL", /* name */
1513 FALSE, /* partial_inplace */
1514 0, /* src_mask */
1515 0xffff, /* dst_mask */
1516 FALSE), /* pcrel_offset */
1517
1518 /* Relocate against either _SDA_BASE_ or _SDA2_BASE_, filling in the 16 bit
1519 signed offset from the appropriate base, and filling in the register
1520 field with the appropriate register (0, 2, or 13). */
1521 HOWTO (R_PPC_EMB_SDA21, /* type */
1522 0, /* rightshift */
1523 2, /* size (0 = byte, 1 = short, 2 = long) */
1524 16, /* bitsize */
1525 FALSE, /* pc_relative */
1526 0, /* bitpos */
1527 complain_overflow_signed, /* complain_on_overflow */
1528 bfd_elf_generic_reloc, /* special_function */
1529 "R_PPC_EMB_SDA21", /* name */
1530 FALSE, /* partial_inplace */
1531 0, /* src_mask */
1532 0xffff, /* dst_mask */
1533 FALSE), /* pcrel_offset */
1534
1535 /* Relocation not handled: R_PPC_EMB_MRKREF */
1536 /* Relocation not handled: R_PPC_EMB_RELSEC16 */
1537 /* Relocation not handled: R_PPC_EMB_RELST_LO */
1538 /* Relocation not handled: R_PPC_EMB_RELST_HI */
1539 /* Relocation not handled: R_PPC_EMB_RELST_HA */
1540 /* Relocation not handled: R_PPC_EMB_BIT_FLD */
1541
1542 /* PC relative relocation against either _SDA_BASE_ or _SDA2_BASE_, filling
1543 in the 16 bit signed offset from the appropriate base, and filling in the
1544 register field with the appropriate register (0, 2, or 13). */
1545 HOWTO (R_PPC_EMB_RELSDA, /* type */
1546 0, /* rightshift */
1547 1, /* size (0 = byte, 1 = short, 2 = long) */
1548 16, /* bitsize */
1549 TRUE, /* pc_relative */
1550 0, /* bitpos */
1551 complain_overflow_signed, /* complain_on_overflow */
1552 bfd_elf_generic_reloc, /* special_function */
1553 "R_PPC_EMB_RELSDA", /* name */
1554 FALSE, /* partial_inplace */
1555 0, /* src_mask */
1556 0xffff, /* dst_mask */
1557 FALSE), /* pcrel_offset */
1558
1559 /* GNU extension to record C++ vtable hierarchy. */
1560 HOWTO (R_PPC_GNU_VTINHERIT, /* type */
1561 0, /* rightshift */
1562 0, /* size (0 = byte, 1 = short, 2 = long) */
1563 0, /* bitsize */
1564 FALSE, /* pc_relative */
1565 0, /* bitpos */
1566 complain_overflow_dont, /* complain_on_overflow */
1567 NULL, /* special_function */
1568 "R_PPC_GNU_VTINHERIT", /* name */
1569 FALSE, /* partial_inplace */
1570 0, /* src_mask */
1571 0, /* dst_mask */
1572 FALSE), /* pcrel_offset */
1573
1574 /* GNU extension to record C++ vtable member usage. */
1575 HOWTO (R_PPC_GNU_VTENTRY, /* type */
1576 0, /* rightshift */
1577 0, /* size (0 = byte, 1 = short, 2 = long) */
1578 0, /* bitsize */
1579 FALSE, /* pc_relative */
1580 0, /* bitpos */
1581 complain_overflow_dont, /* complain_on_overflow */
1582 NULL, /* special_function */
1583 "R_PPC_GNU_VTENTRY", /* name */
1584 FALSE, /* partial_inplace */
1585 0, /* src_mask */
1586 0, /* dst_mask */
1587 FALSE), /* pcrel_offset */
1588
1589 /* Phony reloc to handle AIX style TOC entries. */
1590 HOWTO (R_PPC_TOC16, /* type */
1591 0, /* rightshift */
1592 1, /* size (0 = byte, 1 = short, 2 = long) */
1593 16, /* bitsize */
1594 FALSE, /* pc_relative */
1595 0, /* bitpos */
1596 complain_overflow_signed, /* complain_on_overflow */
1597 bfd_elf_generic_reloc, /* special_function */
1598 "R_PPC_TOC16", /* name */
1599 FALSE, /* partial_inplace */
1600 0, /* src_mask */
1601 0xffff, /* dst_mask */
1602 FALSE), /* pcrel_offset */
1603 };
1604 \f
1605 /* Initialize the ppc_elf_howto_table, so that linear accesses can be done. */
1606
1607 static void
1608 ppc_elf_howto_init ()
1609 {
1610 unsigned int i, type;
1611
1612 for (i = 0; i < sizeof (ppc_elf_howto_raw) / sizeof (ppc_elf_howto_raw[0]); i++)
1613 {
1614 type = ppc_elf_howto_raw[i].type;
1615 BFD_ASSERT (type < sizeof (ppc_elf_howto_table) / sizeof (ppc_elf_howto_table[0]));
1616 ppc_elf_howto_table[type] = &ppc_elf_howto_raw[i];
1617 }
1618 }
1619 \f
1620 /* This function handles relaxing for the PPC with option --mpc860c0[=<n>].
1621
1622 The MPC860, revision C0 or earlier contains a bug in the die.
1623 If all of the following conditions are true, the next instruction
1624 to be executed *may* be treated as a no-op.
1625 1/ A forward branch is executed.
1626 2/ The branch is predicted as not taken.
1627 3/ The branch is taken.
1628 4/ The branch is located in the last 5 words of a page.
1629 (The EOP limit is 5 by default but may be specified as any value from 1-10.)
1630
1631 Our software solution is to detect these problematic branches in a
1632 linker pass and modify them as follows:
1633 1/ Unconditional branches - Since these are always predicted taken,
1634 there is no problem and no action is required.
1635 2/ Conditional backward branches - No problem, no action required.
1636 3/ Conditional forward branches - Ensure that the "inverse prediction
1637 bit" is set (ensure it is predicted taken).
1638 4/ Conditional register branches - Ensure that the "y bit" is set
1639 (ensure it is predicted taken). */
1640
1641 /* Sort sections by address. */
1642
1643 static int
1644 ppc_elf_sort_rela (arg1, arg2)
1645 const PTR arg1;
1646 const PTR arg2;
1647 {
1648 const Elf_Internal_Rela **rela1 = (const Elf_Internal_Rela**) arg1;
1649 const Elf_Internal_Rela **rela2 = (const Elf_Internal_Rela**) arg2;
1650
1651 /* Sort by offset. */
1652 return ((*rela1)->r_offset - (*rela2)->r_offset);
1653 }
1654
1655 static bfd_boolean
1656 ppc_elf_relax_section (abfd, isec, link_info, again)
1657 bfd *abfd;
1658 asection *isec;
1659 struct bfd_link_info *link_info;
1660 bfd_boolean *again;
1661 {
1662 #define PAGESIZE 0x1000
1663
1664 bfd_byte *contents = NULL;
1665 bfd_byte *free_contents = NULL;
1666 Elf_Internal_Rela *internal_relocs = NULL;
1667 Elf_Internal_Rela *free_relocs = NULL;
1668 Elf_Internal_Rela **rela_comb = NULL;
1669 int comb_curr, comb_count;
1670
1671 /* We never have to do this more than once per input section. */
1672 *again = FALSE;
1673
1674 /* If needed, initialize this section's cooked size. */
1675 if (isec->_cooked_size == 0)
1676 isec->_cooked_size = isec->_raw_size;
1677
1678 /* We're only interested in text sections which overlap the
1679 troublesome area at the end of a page. */
1680 if (link_info->mpc860c0 && (isec->flags & SEC_CODE) && isec->_cooked_size)
1681 {
1682 bfd_vma dot, end_page, end_section;
1683 bfd_boolean section_modified;
1684
1685 /* Get the section contents. */
1686 /* Get cached copy if it exists. */
1687 if (elf_section_data (isec)->this_hdr.contents != NULL)
1688 contents = elf_section_data (isec)->this_hdr.contents;
1689 else
1690 {
1691 /* Go get them off disk. */
1692 contents = (bfd_byte *) bfd_malloc (isec->_raw_size);
1693 if (contents == NULL)
1694 goto error_return;
1695 free_contents = contents;
1696
1697 if (! bfd_get_section_contents (abfd, isec, contents,
1698 (file_ptr) 0, isec->_raw_size))
1699 goto error_return;
1700 }
1701
1702 comb_curr = 0;
1703 comb_count = 0;
1704 if (isec->reloc_count)
1705 {
1706 unsigned n;
1707 bfd_size_type amt;
1708
1709 /* Get a copy of the native relocations. */
1710 internal_relocs
1711 = _bfd_elf32_link_read_relocs (abfd, isec, (PTR) NULL,
1712 (Elf_Internal_Rela *) NULL,
1713 link_info->keep_memory);
1714 if (internal_relocs == NULL)
1715 goto error_return;
1716 if (! link_info->keep_memory)
1717 free_relocs = internal_relocs;
1718
1719 /* Setup a faster access method for the reloc info we need. */
1720 amt = isec->reloc_count;
1721 amt *= sizeof (Elf_Internal_Rela*);
1722 rela_comb = (Elf_Internal_Rela**) bfd_malloc (amt);
1723 if (rela_comb == NULL)
1724 goto error_return;
1725 for (n = 0; n < isec->reloc_count; ++n)
1726 {
1727 long r_type;
1728
1729 r_type = ELF32_R_TYPE (internal_relocs[n].r_info);
1730 if (r_type < 0 || r_type >= (int) R_PPC_max)
1731 goto error_return;
1732
1733 /* Prologue constants are sometimes present in the ".text"
1734 sections and they can be identified by their associated
1735 relocation. We don't want to process those words and
1736 some others which can also be identified by their
1737 relocations. However, not all conditional branches will
1738 have a relocation so we will only ignore words that
1739 1) have a reloc, and 2) the reloc is not applicable to a
1740 conditional branch. The array rela_comb is built here
1741 for use in the EOP scan loop. */
1742 switch (r_type)
1743 {
1744 case R_PPC_ADDR14_BRNTAKEN:
1745 case R_PPC_REL14:
1746 case R_PPC_REL14_BRNTAKEN:
1747 /* We should check the instruction. */
1748 break;
1749 default:
1750 /* The word is not a conditional branch - ignore it. */
1751 rela_comb[comb_count++] = &internal_relocs[n];
1752 break;
1753 }
1754 }
1755 if (comb_count > 1)
1756 qsort (rela_comb, (size_t) comb_count, sizeof (int),
1757 ppc_elf_sort_rela);
1758 }
1759
1760 /* Enumerate each EOP region that overlaps this section. */
1761 end_section = isec->vma + isec->_cooked_size;
1762 dot = end_page = (isec->vma | (PAGESIZE - 1)) + 1;
1763 dot -= link_info->mpc860c0;
1764 section_modified = FALSE;
1765 /* Increment the start position if this section begins in the
1766 middle of its first EOP region. */
1767 if (dot < isec->vma)
1768 dot = isec->vma;
1769 for (;
1770 dot < end_section;
1771 dot += PAGESIZE, end_page += PAGESIZE)
1772 {
1773 /* Check each word in this EOP region. */
1774 for (; dot < end_page; dot += 4)
1775 {
1776 bfd_vma isec_offset;
1777 unsigned long insn;
1778 bfd_boolean skip, modified;
1779
1780 /* Don't process this word if there is a relocation for it
1781 and the relocation indicates the word is not a
1782 conditional branch. */
1783 skip = FALSE;
1784 isec_offset = dot - isec->vma;
1785 for (; comb_curr<comb_count; ++comb_curr)
1786 {
1787 bfd_vma r_offset;
1788
1789 r_offset = rela_comb[comb_curr]->r_offset;
1790 if (r_offset >= isec_offset)
1791 {
1792 if (r_offset == isec_offset) skip = TRUE;
1793 break;
1794 }
1795 }
1796 if (skip) continue;
1797
1798 /* Check the current word for a problematic conditional
1799 branch. */
1800 #define BO0(insn) ((insn) & 0x02000000)
1801 #define BO2(insn) ((insn) & 0x00800000)
1802 #define BO4(insn) ((insn) & 0x00200000)
1803 insn = (unsigned long) bfd_get_32 (abfd, contents + isec_offset);
1804 modified = FALSE;
1805 if ((insn & 0xFc000000) == 0x40000000)
1806 {
1807 /* Instruction is BCx */
1808 if ((!BO0(insn) || !BO2(insn)) && !BO4(insn))
1809 {
1810 bfd_vma target;
1811
1812 /* This branch is predicted as "normal".
1813 If this is a forward branch, it is problematic. */
1814 target = insn & 0x0000Fffc;
1815 target = (target ^ 0x8000) - 0x8000;
1816 if ((insn & 0x00000002) == 0)
1817 /* Convert to abs. */
1818 target += dot;
1819 if (target > dot)
1820 {
1821 /* Set the prediction bit. */
1822 insn |= 0x00200000;
1823 modified = TRUE;
1824 }
1825 }
1826 }
1827 else if ((insn & 0xFc00Fffe) == 0x4c000420)
1828 {
1829 /* Instruction is BCCTRx. */
1830 if ((!BO0(insn) || !BO2(insn)) && !BO4(insn))
1831 {
1832 /* This branch is predicted as not-taken.
1833 If this is a forward branch, it is problematic.
1834 Since we can't tell statically if it will branch
1835 forward, always set the prediction bit. */
1836 insn |= 0x00200000;
1837 modified = TRUE;
1838 }
1839 }
1840 else if ((insn & 0xFc00Fffe) == 0x4c000020)
1841 {
1842 /* Instruction is BCLRx */
1843 if ((!BO0(insn) || !BO2(insn)) && !BO4(insn))
1844 {
1845 /* This branch is predicted as not-taken.
1846 If this is a forward branch, it is problematic.
1847 Since we can't tell statically if it will branch
1848 forward, always set the prediction bit. */
1849 insn |= 0x00200000;
1850 modified = TRUE;
1851 }
1852 }
1853 #undef BO0
1854 #undef BO2
1855 #undef BO4
1856 if (modified)
1857 {
1858 bfd_put_32 (abfd, (bfd_vma) insn, contents + isec_offset);
1859 section_modified = TRUE;
1860 }
1861 }
1862 }
1863 if (section_modified)
1864 {
1865 elf_section_data (isec)->this_hdr.contents = contents;
1866 free_contents = NULL;
1867 }
1868 }
1869
1870 if (rela_comb != NULL)
1871 {
1872 free (rela_comb);
1873 rela_comb = NULL;
1874 }
1875
1876 if (free_relocs != NULL)
1877 {
1878 free (free_relocs);
1879 free_relocs = NULL;
1880 }
1881
1882 if (free_contents != NULL)
1883 {
1884 if (! link_info->keep_memory)
1885 free (free_contents);
1886 else
1887 {
1888 /* Cache the section contents for elf_link_input_bfd. */
1889 elf_section_data (isec)->this_hdr.contents = contents;
1890 }
1891 free_contents = NULL;
1892 }
1893
1894 return TRUE;
1895
1896 error_return:
1897 if (rela_comb != NULL)
1898 free (rela_comb);
1899 if (free_relocs != NULL)
1900 free (free_relocs);
1901 if (free_contents != NULL)
1902 free (free_contents);
1903 return FALSE;
1904 }
1905 \f
1906 static reloc_howto_type *
1907 ppc_elf_reloc_type_lookup (abfd, code)
1908 bfd *abfd ATTRIBUTE_UNUSED;
1909 bfd_reloc_code_real_type code;
1910 {
1911 enum elf_ppc_reloc_type r;
1912
1913 if (!ppc_elf_howto_table[R_PPC_ADDR32])
1914 /* Initialize howto table if needed. */
1915 ppc_elf_howto_init ();
1916
1917 switch ((int) code)
1918 {
1919 default:
1920 return (reloc_howto_type *) NULL;
1921
1922 case BFD_RELOC_NONE: r = R_PPC_NONE; break;
1923 case BFD_RELOC_32: r = R_PPC_ADDR32; break;
1924 case BFD_RELOC_PPC_BA26: r = R_PPC_ADDR24; break;
1925 case BFD_RELOC_16: r = R_PPC_ADDR16; break;
1926 case BFD_RELOC_LO16: r = R_PPC_ADDR16_LO; break;
1927 case BFD_RELOC_HI16: r = R_PPC_ADDR16_HI; break;
1928 case BFD_RELOC_HI16_S: r = R_PPC_ADDR16_HA; break;
1929 case BFD_RELOC_PPC_BA16: r = R_PPC_ADDR14; break;
1930 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC_ADDR14_BRTAKEN; break;
1931 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC_ADDR14_BRNTAKEN; break;
1932 case BFD_RELOC_PPC_B26: r = R_PPC_REL24; break;
1933 case BFD_RELOC_PPC_B16: r = R_PPC_REL14; break;
1934 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC_REL14_BRTAKEN; break;
1935 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC_REL14_BRNTAKEN; break;
1936 case BFD_RELOC_16_GOTOFF: r = R_PPC_GOT16; break;
1937 case BFD_RELOC_LO16_GOTOFF: r = R_PPC_GOT16_LO; break;
1938 case BFD_RELOC_HI16_GOTOFF: r = R_PPC_GOT16_HI; break;
1939 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC_GOT16_HA; break;
1940 case BFD_RELOC_24_PLT_PCREL: r = R_PPC_PLTREL24; break;
1941 case BFD_RELOC_PPC_COPY: r = R_PPC_COPY; break;
1942 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC_GLOB_DAT; break;
1943 case BFD_RELOC_PPC_LOCAL24PC: r = R_PPC_LOCAL24PC; break;
1944 case BFD_RELOC_32_PCREL: r = R_PPC_REL32; break;
1945 case BFD_RELOC_32_PLTOFF: r = R_PPC_PLT32; break;
1946 case BFD_RELOC_32_PLT_PCREL: r = R_PPC_PLTREL32; break;
1947 case BFD_RELOC_LO16_PLTOFF: r = R_PPC_PLT16_LO; break;
1948 case BFD_RELOC_HI16_PLTOFF: r = R_PPC_PLT16_HI; break;
1949 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC_PLT16_HA; break;
1950 case BFD_RELOC_GPREL16: r = R_PPC_SDAREL16; break;
1951 case BFD_RELOC_16_BASEREL: r = R_PPC_SECTOFF; break;
1952 case BFD_RELOC_LO16_BASEREL: r = R_PPC_SECTOFF_LO; break;
1953 case BFD_RELOC_HI16_BASEREL: r = R_PPC_SECTOFF_HI; break;
1954 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC_SECTOFF_HA; break;
1955 case BFD_RELOC_CTOR: r = R_PPC_ADDR32; break;
1956 case BFD_RELOC_PPC_TOC16: r = R_PPC_TOC16; break;
1957 case BFD_RELOC_PPC_TLS: r = R_PPC_TLS; break;
1958 case BFD_RELOC_PPC_DTPMOD: r = R_PPC_DTPMOD32; break;
1959 case BFD_RELOC_PPC_TPREL16: r = R_PPC_TPREL16; break;
1960 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC_TPREL16_LO; break;
1961 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC_TPREL16_HI; break;
1962 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC_TPREL16_HA; break;
1963 case BFD_RELOC_PPC_TPREL: r = R_PPC_TPREL32; break;
1964 case BFD_RELOC_PPC_DTPREL16: r = R_PPC_DTPREL16; break;
1965 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC_DTPREL16_LO; break;
1966 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC_DTPREL16_HI; break;
1967 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC_DTPREL16_HA; break;
1968 case BFD_RELOC_PPC_DTPREL: r = R_PPC_DTPREL32; break;
1969 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC_GOT_TLSGD16; break;
1970 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC_GOT_TLSGD16_LO; break;
1971 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC_GOT_TLSGD16_HI; break;
1972 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC_GOT_TLSGD16_HA; break;
1973 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC_GOT_TLSLD16; break;
1974 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC_GOT_TLSLD16_LO; break;
1975 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC_GOT_TLSLD16_HI; break;
1976 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC_GOT_TLSLD16_HA; break;
1977 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC_GOT_TPREL16; break;
1978 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC_GOT_TPREL16_LO; break;
1979 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC_GOT_TPREL16_HI; break;
1980 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC_GOT_TPREL16_HA; break;
1981 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC_GOT_DTPREL16; break;
1982 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC_GOT_DTPREL16_LO; break;
1983 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC_GOT_DTPREL16_HI; break;
1984 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC_GOT_DTPREL16_HA; break;
1985 case BFD_RELOC_PPC_EMB_NADDR32: r = R_PPC_EMB_NADDR32; break;
1986 case BFD_RELOC_PPC_EMB_NADDR16: r = R_PPC_EMB_NADDR16; break;
1987 case BFD_RELOC_PPC_EMB_NADDR16_LO: r = R_PPC_EMB_NADDR16_LO; break;
1988 case BFD_RELOC_PPC_EMB_NADDR16_HI: r = R_PPC_EMB_NADDR16_HI; break;
1989 case BFD_RELOC_PPC_EMB_NADDR16_HA: r = R_PPC_EMB_NADDR16_HA; break;
1990 case BFD_RELOC_PPC_EMB_SDAI16: r = R_PPC_EMB_SDAI16; break;
1991 case BFD_RELOC_PPC_EMB_SDA2I16: r = R_PPC_EMB_SDA2I16; break;
1992 case BFD_RELOC_PPC_EMB_SDA2REL: r = R_PPC_EMB_SDA2REL; break;
1993 case BFD_RELOC_PPC_EMB_SDA21: r = R_PPC_EMB_SDA21; break;
1994 case BFD_RELOC_PPC_EMB_MRKREF: r = R_PPC_EMB_MRKREF; break;
1995 case BFD_RELOC_PPC_EMB_RELSEC16: r = R_PPC_EMB_RELSEC16; break;
1996 case BFD_RELOC_PPC_EMB_RELST_LO: r = R_PPC_EMB_RELST_LO; break;
1997 case BFD_RELOC_PPC_EMB_RELST_HI: r = R_PPC_EMB_RELST_HI; break;
1998 case BFD_RELOC_PPC_EMB_RELST_HA: r = R_PPC_EMB_RELST_HA; break;
1999 case BFD_RELOC_PPC_EMB_BIT_FLD: r = R_PPC_EMB_BIT_FLD; break;
2000 case BFD_RELOC_PPC_EMB_RELSDA: r = R_PPC_EMB_RELSDA; break;
2001 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC_GNU_VTINHERIT; break;
2002 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC_GNU_VTENTRY; break;
2003 }
2004
2005 return ppc_elf_howto_table[(int) r];
2006 };
2007
2008 /* Set the howto pointer for a PowerPC ELF reloc. */
2009
2010 static void
2011 ppc_elf_info_to_howto (abfd, cache_ptr, dst)
2012 bfd *abfd ATTRIBUTE_UNUSED;
2013 arelent *cache_ptr;
2014 Elf_Internal_Rela *dst;
2015 {
2016 if (!ppc_elf_howto_table[R_PPC_ADDR32])
2017 /* Initialize howto table if needed. */
2018 ppc_elf_howto_init ();
2019
2020 BFD_ASSERT (ELF32_R_TYPE (dst->r_info) < (unsigned int) R_PPC_max);
2021 cache_ptr->howto = ppc_elf_howto_table[ELF32_R_TYPE (dst->r_info)];
2022 }
2023
2024 /* Handle the R_PPC_ADDR16_HA reloc. */
2025
2026 static bfd_reloc_status_type
2027 ppc_elf_addr16_ha_reloc (abfd, reloc_entry, symbol, data, input_section,
2028 output_bfd, error_message)
2029 bfd *abfd ATTRIBUTE_UNUSED;
2030 arelent *reloc_entry;
2031 asymbol *symbol;
2032 PTR data ATTRIBUTE_UNUSED;
2033 asection *input_section;
2034 bfd *output_bfd;
2035 char **error_message ATTRIBUTE_UNUSED;
2036 {
2037 bfd_vma relocation;
2038
2039 if (output_bfd != NULL)
2040 {
2041 reloc_entry->address += input_section->output_offset;
2042 return bfd_reloc_ok;
2043 }
2044
2045 if (reloc_entry->address > input_section->_cooked_size)
2046 return bfd_reloc_outofrange;
2047
2048 if (bfd_is_com_section (symbol->section))
2049 relocation = 0;
2050 else
2051 relocation = symbol->value;
2052
2053 relocation += symbol->section->output_section->vma;
2054 relocation += symbol->section->output_offset;
2055 relocation += reloc_entry->addend;
2056
2057 reloc_entry->addend += (relocation & 0x8000) << 1;
2058
2059 return bfd_reloc_continue;
2060 }
2061
2062 static bfd_reloc_status_type
2063 ppc_elf_unhandled_reloc (abfd, reloc_entry, symbol, data,
2064 input_section, output_bfd, error_message)
2065 bfd *abfd;
2066 arelent *reloc_entry;
2067 asymbol *symbol;
2068 PTR data;
2069 asection *input_section;
2070 bfd *output_bfd;
2071 char **error_message;
2072 {
2073 /* If this is a relocatable link (output_bfd test tells us), just
2074 call the generic function. Any adjustment will be done at final
2075 link time. */
2076 if (output_bfd != NULL)
2077 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2078 input_section, output_bfd, error_message);
2079
2080 if (error_message != NULL)
2081 {
2082 static char buf[60];
2083 sprintf (buf, "generic linker can't handle %s",
2084 reloc_entry->howto->name);
2085 *error_message = buf;
2086 }
2087 return bfd_reloc_dangerous;
2088 }
2089
2090 /* Fix bad default arch selected for a 32 bit input bfd when the
2091 default is 64 bit. */
2092
2093 static bfd_boolean
2094 ppc_elf_object_p (abfd)
2095 bfd *abfd;
2096 {
2097 if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 64)
2098 {
2099 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2100
2101 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS32)
2102 {
2103 /* Relies on arch after 64 bit default being 32 bit default. */
2104 abfd->arch_info = abfd->arch_info->next;
2105 BFD_ASSERT (abfd->arch_info->bits_per_word == 32);
2106 }
2107 }
2108 return TRUE;
2109 }
2110
2111 /* Function to set whether a module needs the -mrelocatable bit set. */
2112
2113 static bfd_boolean
2114 ppc_elf_set_private_flags (abfd, flags)
2115 bfd *abfd;
2116 flagword flags;
2117 {
2118 BFD_ASSERT (!elf_flags_init (abfd)
2119 || elf_elfheader (abfd)->e_flags == flags);
2120
2121 elf_elfheader (abfd)->e_flags = flags;
2122 elf_flags_init (abfd) = TRUE;
2123 return TRUE;
2124 }
2125
2126 /* Merge backend specific data from an object file to the output
2127 object file when linking. */
2128
2129 static bfd_boolean
2130 ppc_elf_merge_private_bfd_data (ibfd, obfd)
2131 bfd *ibfd;
2132 bfd *obfd;
2133 {
2134 flagword old_flags;
2135 flagword new_flags;
2136 bfd_boolean error;
2137
2138 /* Check if we have the same endianess. */
2139 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
2140 return FALSE;
2141
2142 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2143 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2144 return TRUE;
2145
2146 new_flags = elf_elfheader (ibfd)->e_flags;
2147 old_flags = elf_elfheader (obfd)->e_flags;
2148 if (!elf_flags_init (obfd))
2149 {
2150 /* First call, no flags set. */
2151 elf_flags_init (obfd) = TRUE;
2152 elf_elfheader (obfd)->e_flags = new_flags;
2153 }
2154
2155 /* Compatible flags are ok. */
2156 else if (new_flags == old_flags)
2157 ;
2158
2159 /* Incompatible flags. */
2160 else
2161 {
2162 /* Warn about -mrelocatable mismatch. Allow -mrelocatable-lib
2163 to be linked with either. */
2164 error = FALSE;
2165 if ((new_flags & EF_PPC_RELOCATABLE) != 0
2166 && (old_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0)
2167 {
2168 error = TRUE;
2169 (*_bfd_error_handler)
2170 (_("%s: compiled with -mrelocatable and linked with modules compiled normally"),
2171 bfd_archive_filename (ibfd));
2172 }
2173 else if ((new_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0
2174 && (old_flags & EF_PPC_RELOCATABLE) != 0)
2175 {
2176 error = TRUE;
2177 (*_bfd_error_handler)
2178 (_("%s: compiled normally and linked with modules compiled with -mrelocatable"),
2179 bfd_archive_filename (ibfd));
2180 }
2181
2182 /* The output is -mrelocatable-lib iff both the input files are. */
2183 if (! (new_flags & EF_PPC_RELOCATABLE_LIB))
2184 elf_elfheader (obfd)->e_flags &= ~EF_PPC_RELOCATABLE_LIB;
2185
2186 /* The output is -mrelocatable iff it can't be -mrelocatable-lib,
2187 but each input file is either -mrelocatable or -mrelocatable-lib. */
2188 if (! (elf_elfheader (obfd)->e_flags & EF_PPC_RELOCATABLE_LIB)
2189 && (new_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE))
2190 && (old_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE)))
2191 elf_elfheader (obfd)->e_flags |= EF_PPC_RELOCATABLE;
2192
2193 /* Do not warn about eabi vs. V.4 mismatch, just or in the bit if
2194 any module uses it. */
2195 elf_elfheader (obfd)->e_flags |= (new_flags & EF_PPC_EMB);
2196
2197 new_flags &= ~(EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB);
2198 old_flags &= ~(EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB);
2199
2200 /* Warn about any other mismatches. */
2201 if (new_flags != old_flags)
2202 {
2203 error = TRUE;
2204 (*_bfd_error_handler)
2205 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
2206 bfd_archive_filename (ibfd), (long) new_flags, (long) old_flags);
2207 }
2208
2209 if (error)
2210 {
2211 bfd_set_error (bfd_error_bad_value);
2212 return FALSE;
2213 }
2214 }
2215
2216 return TRUE;
2217 }
2218 \f
2219 /* Handle a PowerPC specific section when reading an object file. This
2220 is called when elfcode.h finds a section with an unknown type. */
2221
2222 static bfd_boolean
2223 ppc_elf_section_from_shdr (abfd, hdr, name)
2224 bfd *abfd;
2225 Elf_Internal_Shdr *hdr;
2226 const char *name;
2227 {
2228 asection *newsect;
2229 flagword flags;
2230
2231 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
2232 return FALSE;
2233
2234 newsect = hdr->bfd_section;
2235 flags = bfd_get_section_flags (abfd, newsect);
2236 if (hdr->sh_flags & SHF_EXCLUDE)
2237 flags |= SEC_EXCLUDE;
2238
2239 if (hdr->sh_type == SHT_ORDERED)
2240 flags |= SEC_SORT_ENTRIES;
2241
2242 bfd_set_section_flags (abfd, newsect, flags);
2243 return TRUE;
2244 }
2245 \f
2246 /* Set up any other section flags and such that may be necessary. */
2247
2248 static bfd_boolean
2249 ppc_elf_fake_sections (abfd, shdr, asect)
2250 bfd *abfd ATTRIBUTE_UNUSED;
2251 Elf_Internal_Shdr *shdr;
2252 asection *asect;
2253 {
2254 if ((asect->flags & SEC_EXCLUDE) != 0)
2255 shdr->sh_flags |= SHF_EXCLUDE;
2256
2257 if ((asect->flags & SEC_SORT_ENTRIES) != 0)
2258 shdr->sh_type = SHT_ORDERED;
2259
2260 return TRUE;
2261 }
2262 \f
2263 /* Create a special linker section */
2264 static elf_linker_section_t *
2265 ppc_elf_create_linker_section (abfd, info, which)
2266 bfd *abfd;
2267 struct bfd_link_info *info;
2268 enum elf_linker_section_enum which;
2269 {
2270 bfd *dynobj = elf_hash_table (info)->dynobj;
2271 elf_linker_section_t *lsect;
2272
2273 /* Record the first bfd section that needs the special section. */
2274 if (!dynobj)
2275 dynobj = elf_hash_table (info)->dynobj = abfd;
2276
2277 /* If this is the first time, create the section. */
2278 lsect = elf_linker_section (dynobj, which);
2279 if (!lsect)
2280 {
2281 elf_linker_section_t defaults;
2282 static elf_linker_section_t zero_section;
2283
2284 defaults = zero_section;
2285 defaults.which = which;
2286 defaults.hole_written_p = FALSE;
2287 defaults.alignment = 2;
2288
2289 /* Both of these sections are (technically) created by the user
2290 putting data in them, so they shouldn't be marked
2291 SEC_LINKER_CREATED.
2292
2293 The linker creates them so it has somewhere to attach their
2294 respective symbols. In fact, if they were empty it would
2295 be OK to leave the symbol set to 0 (or any random number), because
2296 the appropriate register should never be used. */
2297 defaults.flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
2298 | SEC_IN_MEMORY);
2299
2300 switch (which)
2301 {
2302 default:
2303 (*_bfd_error_handler) (_("%s: unknown special linker type %d"),
2304 bfd_get_filename (abfd),
2305 (int) which);
2306
2307 bfd_set_error (bfd_error_bad_value);
2308 return (elf_linker_section_t *) 0;
2309
2310 case LINKER_SECTION_SDATA: /* .sdata/.sbss section */
2311 defaults.name = ".sdata";
2312 defaults.rel_name = ".rela.sdata";
2313 defaults.bss_name = ".sbss";
2314 defaults.sym_name = "_SDA_BASE_";
2315 defaults.sym_offset = 32768;
2316 break;
2317
2318 case LINKER_SECTION_SDATA2: /* .sdata2/.sbss2 section */
2319 defaults.name = ".sdata2";
2320 defaults.rel_name = ".rela.sdata2";
2321 defaults.bss_name = ".sbss2";
2322 defaults.sym_name = "_SDA2_BASE_";
2323 defaults.sym_offset = 32768;
2324 defaults.flags |= SEC_READONLY;
2325 break;
2326 }
2327
2328 lsect = _bfd_elf_create_linker_section (abfd, info, which, &defaults);
2329 }
2330
2331 return lsect;
2332 }
2333 \f
2334 /* If we have a non-zero sized .sbss2 or .PPC.EMB.sbss0 sections, we
2335 need to bump up the number of section headers. */
2336
2337 static int
2338 ppc_elf_additional_program_headers (abfd)
2339 bfd *abfd;
2340 {
2341 asection *s;
2342 int ret;
2343
2344 ret = 0;
2345
2346 s = bfd_get_section_by_name (abfd, ".interp");
2347 if (s != NULL)
2348 ++ret;
2349
2350 s = bfd_get_section_by_name (abfd, ".sbss2");
2351 if (s != NULL && (s->flags & SEC_LOAD) != 0 && s->_raw_size > 0)
2352 ++ret;
2353
2354 s = bfd_get_section_by_name (abfd, ".PPC.EMB.sbss0");
2355 if (s != NULL && (s->flags & SEC_LOAD) != 0 && s->_raw_size > 0)
2356 ++ret;
2357
2358 return ret;
2359 }
2360
2361 /* Modify the segment map if needed. */
2362
2363 static bfd_boolean
2364 ppc_elf_modify_segment_map (abfd)
2365 bfd *abfd ATTRIBUTE_UNUSED;
2366 {
2367 return TRUE;
2368 }
2369 \f
2370 /* The powerpc .got has a blrl instruction in it. Mark it executable. */
2371
2372 static bfd_boolean
2373 ppc_elf_create_got (abfd, info)
2374 bfd *abfd;
2375 struct bfd_link_info *info;
2376 {
2377 struct ppc_elf_link_hash_table *htab;
2378 asection *s;
2379 flagword flags;
2380
2381 if (!_bfd_elf_create_got_section (abfd, info))
2382 return FALSE;
2383
2384 htab = ppc_elf_hash_table (info);
2385 htab->got = s = bfd_get_section_by_name (abfd, ".got");
2386 if (s == NULL)
2387 abort ();
2388
2389 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2390 | SEC_LINKER_CREATED);
2391 if (!bfd_set_section_flags (abfd, s, flags))
2392 return FALSE;
2393
2394 htab->relgot = bfd_make_section (abfd, ".rela.got");
2395 if (!htab->relgot
2396 || ! bfd_set_section_flags (abfd, htab->relgot,
2397 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
2398 | SEC_IN_MEMORY | SEC_LINKER_CREATED
2399 | SEC_READONLY))
2400 || ! bfd_set_section_alignment (abfd, htab->relgot, 2))
2401 return FALSE;
2402
2403 return TRUE;
2404 }
2405
2406 /* We have to create .dynsbss and .rela.sbss here so that they get mapped
2407 to output sections (just like _bfd_elf_create_dynamic_sections has
2408 to create .dynbss and .rela.bss). */
2409
2410 static bfd_boolean
2411 ppc_elf_create_dynamic_sections (abfd, info)
2412 bfd *abfd;
2413 struct bfd_link_info *info;
2414 {
2415 struct ppc_elf_link_hash_table *htab;
2416 asection *s;
2417 flagword flags;
2418
2419 if (!ppc_elf_create_got (abfd, info))
2420 return FALSE;
2421
2422 if (!_bfd_elf_create_dynamic_sections (abfd, info))
2423 return FALSE;
2424
2425 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2426 | SEC_LINKER_CREATED);
2427
2428 htab = ppc_elf_hash_table (info);
2429 htab->dynbss = bfd_get_section_by_name (abfd, ".dynbss");
2430 htab->dynsbss = s = bfd_make_section (abfd, ".dynsbss");
2431 if (s == NULL
2432 || ! bfd_set_section_flags (abfd, s, SEC_ALLOC))
2433 return FALSE;
2434
2435 if (! info->shared)
2436 {
2437 htab->relbss = bfd_get_section_by_name (abfd, ".rela.bss");
2438 htab->relsbss = s = bfd_make_section (abfd, ".rela.sbss");
2439 if (s == NULL
2440 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
2441 || ! bfd_set_section_alignment (abfd, s, 2))
2442 return FALSE;
2443 }
2444
2445 htab->relplt = bfd_get_section_by_name (abfd, ".rela.plt");
2446 htab->plt = s = bfd_get_section_by_name (abfd, ".plt");
2447 if (s == NULL)
2448 abort ();
2449
2450 flags = SEC_ALLOC | SEC_CODE | SEC_IN_MEMORY | SEC_LINKER_CREATED;
2451 return bfd_set_section_flags (abfd, s, flags);
2452 }
2453
2454 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
2455 copying dynamic variables from a shared lib into an app's dynbss
2456 section, and instead use a dynamic relocation to point into the
2457 shared lib. */
2458 #define ELIMINATE_COPY_RELOCS 1
2459
2460 /* Adjust a symbol defined by a dynamic object and referenced by a
2461 regular object. The current definition is in some section of the
2462 dynamic object, but we're not including those sections. We have to
2463 change the definition to something the rest of the link can
2464 understand. */
2465
2466 static bfd_boolean
2467 ppc_elf_adjust_dynamic_symbol (info, h)
2468 struct bfd_link_info *info;
2469 struct elf_link_hash_entry *h;
2470 {
2471 struct ppc_elf_link_hash_table *htab;
2472 asection *s;
2473 unsigned int power_of_two;
2474
2475 #ifdef DEBUG
2476 fprintf (stderr, "ppc_elf_adjust_dynamic_symbol called for %s\n",
2477 h->root.root.string);
2478 #endif
2479
2480 /* Make sure we know what is going on here. */
2481 htab = ppc_elf_hash_table (info);
2482 BFD_ASSERT (htab->elf.dynobj != NULL
2483 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
2484 || h->weakdef != NULL
2485 || ((h->elf_link_hash_flags
2486 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2487 && (h->elf_link_hash_flags
2488 & ELF_LINK_HASH_REF_REGULAR) != 0
2489 && (h->elf_link_hash_flags
2490 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
2491
2492 /* Deal with function syms. */
2493 if (h->type == STT_FUNC
2494 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2495 {
2496 /* Clear procedure linkage table information for any symbol that
2497 won't need a .plt entry. */
2498 if (! htab->elf.dynamic_sections_created
2499 || SYMBOL_CALLS_LOCAL (info, h)
2500 || h->plt.refcount <= 0)
2501 {
2502 /* A PLT entry is not required/allowed when:
2503
2504 1. We are not using ld.so; because then the PLT entry
2505 can't be set up, so we can't use one.
2506
2507 2. We know for certain that a call to this symbol
2508 will go to this object.
2509
2510 3. GC has rendered the entry unused. */
2511 h->plt.offset = (bfd_vma) -1;
2512 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2513 }
2514 return TRUE;
2515 }
2516 else
2517 h->plt.offset = (bfd_vma) -1;
2518
2519 /* If this is a weak symbol, and there is a real definition, the
2520 processor independent code will have arranged for us to see the
2521 real definition first, and we can just use the same value. */
2522 if (h->weakdef != NULL)
2523 {
2524 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2525 || h->weakdef->root.type == bfd_link_hash_defweak);
2526 h->root.u.def.section = h->weakdef->root.u.def.section;
2527 h->root.u.def.value = h->weakdef->root.u.def.value;
2528 if (ELIMINATE_COPY_RELOCS)
2529 h->elf_link_hash_flags
2530 = ((h->elf_link_hash_flags & ~ELF_LINK_NON_GOT_REF)
2531 | (h->weakdef->elf_link_hash_flags & ELF_LINK_NON_GOT_REF));
2532 return TRUE;
2533 }
2534
2535 /* This is a reference to a symbol defined by a dynamic object which
2536 is not a function. */
2537
2538 /* If we are creating a shared library, we must presume that the
2539 only references to the symbol are via the global offset table.
2540 For such cases we need not do anything here; the relocations will
2541 be handled correctly by relocate_section. */
2542 if (info->shared)
2543 return TRUE;
2544
2545 /* If there are no references to this symbol that do not use the
2546 GOT, we don't need to generate a copy reloc. */
2547 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
2548 return TRUE;
2549
2550 if (ELIMINATE_COPY_RELOCS)
2551 {
2552 struct ppc_elf_dyn_relocs *p;
2553 for (p = ppc_elf_hash_entry (h)->dyn_relocs; p != NULL; p = p->next)
2554 {
2555 s = p->sec->output_section;
2556 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2557 break;
2558 }
2559
2560 /* If we didn't find any dynamic relocs in read-only sections, then
2561 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2562 if (p == NULL)
2563 {
2564 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
2565 return TRUE;
2566 }
2567 }
2568
2569 /* We must allocate the symbol in our .dynbss section, which will
2570 become part of the .bss section of the executable. There will be
2571 an entry for this symbol in the .dynsym section. The dynamic
2572 object will contain position independent code, so all references
2573 from the dynamic object to this symbol will go through the global
2574 offset table. The dynamic linker will use the .dynsym entry to
2575 determine the address it must put in the global offset table, so
2576 both the dynamic object and the regular object will refer to the
2577 same memory location for the variable.
2578
2579 Of course, if the symbol is sufficiently small, we must instead
2580 allocate it in .sbss. FIXME: It would be better to do this if and
2581 only if there were actually SDAREL relocs for that symbol. */
2582
2583 if (h->size <= elf_gp_size (htab->elf.dynobj))
2584 s = htab->dynsbss;
2585 else
2586 s = htab->dynbss;
2587 BFD_ASSERT (s != NULL);
2588
2589 /* We must generate a R_PPC_COPY reloc to tell the dynamic linker to
2590 copy the initial value out of the dynamic object and into the
2591 runtime process image. We need to remember the offset into the
2592 .rela.bss section we are going to use. */
2593 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2594 {
2595 asection *srel;
2596
2597 if (h->size <= elf_gp_size (htab->elf.dynobj))
2598 srel = htab->relsbss;
2599 else
2600 srel = htab->relbss;
2601 BFD_ASSERT (srel != NULL);
2602 srel->_raw_size += sizeof (Elf32_External_Rela);
2603 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
2604 }
2605
2606 /* We need to figure out the alignment required for this symbol. I
2607 have no idea how ELF linkers handle this. */
2608 power_of_two = bfd_log2 (h->size);
2609 if (power_of_two > 4)
2610 power_of_two = 4;
2611
2612 /* Apply the required alignment. */
2613 s->_raw_size = BFD_ALIGN (s->_raw_size,
2614 (bfd_size_type) (1 << power_of_two));
2615 if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
2616 {
2617 if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
2618 return FALSE;
2619 }
2620
2621 /* Define the symbol as being at this point in the section. */
2622 h->root.u.def.section = s;
2623 h->root.u.def.value = s->_raw_size;
2624
2625 /* Increment the section size to make room for the symbol. */
2626 s->_raw_size += h->size;
2627
2628 return TRUE;
2629 }
2630 \f
2631 /* This is the condition under which finish_dynamic_symbol will be
2632 called from elflink.h. If elflink.h doesn't call our
2633 finish_dynamic_symbol routine, we'll need to do something about
2634 initializing any .plt and .got entries in relocate_section. */
2635 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, SHARED, H) \
2636 ((DYN) \
2637 && ((SHARED) \
2638 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
2639 && ((H)->dynindx != -1 \
2640 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
2641
2642 /* Of those relocs that might be copied as dynamic relocs, this macro
2643 selects those that must be copied when linking a shared library,
2644 even when the symbol is local. */
2645
2646 #define MUST_BE_DYN_RELOC(RTYPE) \
2647 ((RTYPE) != R_PPC_REL24 \
2648 && (RTYPE) != R_PPC_REL14 \
2649 && (RTYPE) != R_PPC_REL14_BRTAKEN \
2650 && (RTYPE) != R_PPC_REL14_BRNTAKEN \
2651 && (RTYPE) != R_PPC_REL32)
2652
2653 /* Allocate space in associated reloc sections for dynamic relocs. */
2654
2655 static bfd_boolean
2656 allocate_dynrelocs (h, inf)
2657 struct elf_link_hash_entry *h;
2658 PTR inf;
2659 {
2660 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2661 struct ppc_elf_link_hash_entry *eh;
2662 struct ppc_elf_link_hash_table *htab;
2663 struct ppc_elf_dyn_relocs *p;
2664
2665 if (h->root.type == bfd_link_hash_indirect)
2666 return TRUE;
2667
2668 if (h->root.type == bfd_link_hash_warning)
2669 /* When warning symbols are created, they **replace** the "real"
2670 entry in the hash table, thus we never get to see the real
2671 symbol in a hash traversal. So look at it now. */
2672 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2673
2674 htab = ppc_elf_hash_table (info);
2675 if (htab->elf.dynamic_sections_created
2676 && h->plt.refcount > 0)
2677 {
2678 /* Make sure this symbol is output as a dynamic symbol. */
2679 if (h->dynindx == -1
2680 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
2681 {
2682 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2683 return FALSE;
2684 }
2685
2686 if (info->shared
2687 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
2688 {
2689 asection *s = htab->plt;
2690
2691 /* If this is the first .plt entry, make room for the special
2692 first entry. */
2693 if (s->_raw_size == 0)
2694 s->_raw_size += PLT_INITIAL_ENTRY_SIZE;
2695
2696 /* The PowerPC PLT is actually composed of two parts, the
2697 first part is 2 words (for a load and a jump), and then
2698 there is a remaining word available at the end. */
2699 h->plt.offset = (PLT_INITIAL_ENTRY_SIZE
2700 + (PLT_SLOT_SIZE
2701 * ((s->_raw_size - PLT_INITIAL_ENTRY_SIZE)
2702 / PLT_ENTRY_SIZE)));
2703
2704 /* If this symbol is not defined in a regular file, and we
2705 are not generating a shared library, then set the symbol
2706 to this location in the .plt. This is required to make
2707 function pointers compare as equal between the normal
2708 executable and the shared library. */
2709 if (! info->shared
2710 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2711 {
2712 h->root.u.def.section = s;
2713 h->root.u.def.value = h->plt.offset;
2714 }
2715
2716 /* Make room for this entry. After the 8192nd entry, room
2717 for two entries is allocated. */
2718 s->_raw_size += PLT_ENTRY_SIZE;
2719 if ((s->_raw_size - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE
2720 >= PLT_NUM_SINGLE_ENTRIES)
2721 s->_raw_size += PLT_ENTRY_SIZE;
2722
2723 /* We also need to make an entry in the .rela.plt section. */
2724 htab->relplt->_raw_size += sizeof (Elf32_External_Rela);
2725 }
2726 else
2727 {
2728 h->plt.offset = (bfd_vma) -1;
2729 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2730 }
2731 }
2732 else
2733 {
2734 h->plt.offset = (bfd_vma) -1;
2735 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2736 }
2737
2738 eh = (struct ppc_elf_link_hash_entry *) h;
2739 if (eh->elf.got.refcount > 0)
2740 {
2741 /* Make sure this symbol is output as a dynamic symbol. */
2742 if (eh->elf.dynindx == -1
2743 && (eh->elf.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
2744 {
2745 if (!bfd_elf32_link_record_dynamic_symbol (info, &eh->elf))
2746 return FALSE;
2747 }
2748
2749 if (eh->tls_mask == (TLS_TLS | TLS_LD)
2750 && !(eh->elf.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC))
2751 /* If just an LD reloc, we'll just use htab->tlsld_got.offset. */
2752 eh->elf.got.offset = (bfd_vma) -1;
2753 else
2754 {
2755 bfd_boolean dyn;
2756 eh->elf.got.offset = htab->got->_raw_size;
2757 if ((eh->tls_mask & TLS_TLS) != 0)
2758 {
2759 if ((eh->tls_mask & TLS_LD) != 0)
2760 htab->got->_raw_size += 8;
2761 if ((eh->tls_mask & TLS_GD) != 0)
2762 htab->got->_raw_size += 8;
2763 if ((eh->tls_mask & (TLS_TPREL | TLS_TPRELGD)) != 0)
2764 htab->got->_raw_size += 4;
2765 if ((eh->tls_mask & TLS_DTPREL) != 0)
2766 htab->got->_raw_size += 4;
2767 }
2768 else
2769 htab->got->_raw_size += 4;
2770 dyn = htab->elf.dynamic_sections_created;
2771 if (info->shared
2772 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, &eh->elf))
2773 {
2774 /* All the entries we allocated need relocs. */
2775 htab->relgot->_raw_size
2776 += ((htab->got->_raw_size - eh->elf.got.offset) / 4
2777 * sizeof (Elf32_External_Rela));
2778 /* Except LD only needs one. */
2779 if ((eh->tls_mask & TLS_LD) != 0)
2780 htab->relgot->_raw_size -= sizeof (Elf32_External_Rela);
2781 }
2782 }
2783 }
2784 else
2785 eh->elf.got.offset = (bfd_vma) -1;
2786
2787 if (eh->dyn_relocs == NULL)
2788 return TRUE;
2789
2790 /* In the shared -Bsymbolic case, discard space allocated for
2791 dynamic pc-relative relocs against symbols which turn out to be
2792 defined in regular objects. For the normal shared case, discard
2793 space for relocs that have become local due to symbol visibility
2794 changes. */
2795 if (info->shared)
2796 {
2797 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
2798 && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
2799 || info->symbolic))
2800 {
2801 struct ppc_elf_dyn_relocs **pp;
2802
2803 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2804 {
2805 p->count -= p->pc_count;
2806 p->pc_count = 0;
2807 if (p->count == 0)
2808 *pp = p->next;
2809 else
2810 pp = &p->next;
2811 }
2812 }
2813 }
2814 else if (ELIMINATE_COPY_RELOCS)
2815 {
2816 /* For the non-shared case, discard space for relocs against
2817 symbols which turn out to need copy relocs or are not
2818 dynamic. */
2819
2820 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
2821 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2822 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2823 {
2824 /* Make sure this symbol is output as a dynamic symbol.
2825 Undefined weak syms won't yet be marked as dynamic. */
2826 if (h->dynindx == -1
2827 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
2828 {
2829 if (! bfd_elf64_link_record_dynamic_symbol (info, h))
2830 return FALSE;
2831 }
2832
2833 /* If that succeeded, we know we'll be keeping all the
2834 relocs. */
2835 if (h->dynindx != -1)
2836 goto keep;
2837 }
2838
2839 eh->dyn_relocs = NULL;
2840
2841 keep: ;
2842 }
2843
2844 /* Finally, allocate space. */
2845 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2846 {
2847 asection *sreloc = elf_section_data (p->sec)->sreloc;
2848 sreloc->_raw_size += p->count * sizeof (Elf32_External_Rela);
2849 }
2850
2851 return TRUE;
2852 }
2853
2854 /* Find any dynamic relocs that apply to read-only sections. */
2855
2856 static bfd_boolean
2857 readonly_dynrelocs (h, info)
2858 struct elf_link_hash_entry *h;
2859 PTR info;
2860 {
2861 struct ppc_elf_dyn_relocs *p;
2862
2863 if (h->root.type == bfd_link_hash_indirect)
2864 return TRUE;
2865
2866 if (h->root.type == bfd_link_hash_warning)
2867 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2868
2869 for (p = ppc_elf_hash_entry (h)->dyn_relocs; p != NULL; p = p->next)
2870 {
2871 asection *s = p->sec->output_section;
2872
2873 if (s != NULL
2874 && ((s->flags & (SEC_READONLY | SEC_ALLOC))
2875 == (SEC_READONLY | SEC_ALLOC)))
2876 {
2877 ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
2878
2879 /* Not an error, just cut short the traversal. */
2880 return FALSE;
2881 }
2882 }
2883 return TRUE;
2884 }
2885
2886 /* Set the sizes of the dynamic sections. */
2887
2888 static bfd_boolean
2889 ppc_elf_size_dynamic_sections (output_bfd, info)
2890 bfd *output_bfd ATTRIBUTE_UNUSED;
2891 struct bfd_link_info *info;
2892 {
2893 struct ppc_elf_link_hash_table *htab;
2894 asection *s;
2895 bfd_boolean relocs;
2896 bfd *ibfd;
2897
2898 #ifdef DEBUG
2899 fprintf (stderr, "ppc_elf_size_dynamic_sections called\n");
2900 #endif
2901
2902 htab = ppc_elf_hash_table (info);
2903 BFD_ASSERT (htab->elf.dynobj != NULL);
2904
2905 if (elf_hash_table (info)->dynamic_sections_created)
2906 {
2907 /* Set the contents of the .interp section to the interpreter. */
2908 if (! info->shared)
2909 {
2910 s = bfd_get_section_by_name (htab->elf.dynobj, ".interp");
2911 BFD_ASSERT (s != NULL);
2912 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
2913 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2914 }
2915 }
2916
2917 if (htab->tlsld_got.refcount > 0)
2918 {
2919 htab->tlsld_got.offset = htab->got->_raw_size;
2920 htab->got->_raw_size += 8;
2921 if (info->shared)
2922 htab->relgot->_raw_size += sizeof (Elf32_External_Rela);
2923 }
2924 else
2925 htab->tlsld_got.offset = (bfd_vma) -1;
2926
2927 /* Set up .got offsets for local syms, and space for local dynamic
2928 relocs. */
2929 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2930 {
2931 bfd_signed_vma *local_got;
2932 bfd_signed_vma *end_local_got;
2933 char *lgot_masks;
2934 bfd_size_type locsymcount;
2935 Elf_Internal_Shdr *symtab_hdr;
2936 asection *srel;
2937
2938 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2939 continue;
2940
2941 for (s = ibfd->sections; s != NULL; s = s->next)
2942 {
2943 struct ppc_elf_dyn_relocs *p;
2944
2945 for (p = ((struct ppc_elf_dyn_relocs *)
2946 elf_section_data (s)->local_dynrel);
2947 p != NULL;
2948 p = p->next)
2949 {
2950 if (!bfd_is_abs_section (p->sec)
2951 && bfd_is_abs_section (p->sec->output_section))
2952 {
2953 /* Input section has been discarded, either because
2954 it is a copy of a linkonce section or due to
2955 linker script /DISCARD/, so we'll be discarding
2956 the relocs too. */
2957 }
2958 else if (p->count != 0)
2959 {
2960 elf_section_data (p->sec)->sreloc->_raw_size
2961 += p->count * sizeof (Elf32_External_Rela);
2962 if ((p->sec->output_section->flags
2963 & (SEC_READONLY | SEC_ALLOC))
2964 == (SEC_READONLY | SEC_ALLOC))
2965 info->flags |= DF_TEXTREL;
2966 }
2967 }
2968 }
2969
2970 local_got = elf_local_got_refcounts (ibfd);
2971 if (!local_got)
2972 continue;
2973
2974 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2975 locsymcount = symtab_hdr->sh_info;
2976 end_local_got = local_got + locsymcount;
2977 lgot_masks = (char *) end_local_got;
2978 s = htab->got;
2979 srel = htab->relgot;
2980 for (; local_got < end_local_got; ++local_got, ++lgot_masks)
2981 if (*local_got > 0)
2982 {
2983 if (*lgot_masks == (TLS_TLS | TLS_LD))
2984 {
2985 /* If just an LD reloc, we'll just use
2986 htab->tlsld_got.offset. */
2987 if (htab->tlsld_got.offset == (bfd_vma) -1)
2988 {
2989 htab->tlsld_got.offset = s->_raw_size;
2990 s->_raw_size += 8;
2991 if (info->shared)
2992 srel->_raw_size += sizeof (Elf32_External_Rela);
2993 }
2994 *local_got = (bfd_vma) -1;
2995 }
2996 else
2997 {
2998 *local_got = s->_raw_size;
2999 if ((*lgot_masks & TLS_TLS) != 0)
3000 {
3001 if ((*lgot_masks & TLS_GD) != 0)
3002 s->_raw_size += 8;
3003 if ((*lgot_masks & (TLS_TPREL | TLS_TPRELGD)) != 0)
3004 s->_raw_size += 4;
3005 if ((*lgot_masks & TLS_DTPREL) != 0)
3006 s->_raw_size += 4;
3007 }
3008 else
3009 s->_raw_size += 4;
3010 if (info->shared)
3011 srel->_raw_size += ((s->_raw_size - *local_got) / 4
3012 * sizeof (Elf32_External_Rela));
3013 }
3014 }
3015 else
3016 *local_got = (bfd_vma) -1;
3017 }
3018
3019 /* Allocate space for global sym dynamic relocs. */
3020 elf_link_hash_traverse (elf_hash_table (info), allocate_dynrelocs, info);
3021
3022 /* We've now determined the sizes of the various dynamic sections.
3023 Allocate memory for them. */
3024 relocs = FALSE;
3025 for (s = htab->elf.dynobj->sections; s != NULL; s = s->next)
3026 {
3027 if ((s->flags & SEC_LINKER_CREATED) == 0)
3028 continue;
3029
3030 if (s == htab->plt
3031 || s == htab->got
3032 || (htab->sdata != NULL && s == htab->sdata->section)
3033 || (htab->sdata2 != NULL && s == htab->sdata2->section))
3034 {
3035 /* Strip this section if we don't need it; see the
3036 comment below. */
3037 }
3038 else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
3039 {
3040 if (s->_raw_size == 0)
3041 {
3042 /* If we don't need this section, strip it from the
3043 output file. This is mostly to handle .rela.bss and
3044 .rela.plt. We must create both sections in
3045 create_dynamic_sections, because they must be created
3046 before the linker maps input sections to output
3047 sections. The linker does that before
3048 adjust_dynamic_symbol is called, and it is that
3049 function which decides whether anything needs to go
3050 into these sections. */
3051 }
3052 else
3053 {
3054 /* Remember whether there are any relocation sections. */
3055 relocs = TRUE;
3056
3057 /* We use the reloc_count field as a counter if we need
3058 to copy relocs into the output file. */
3059 s->reloc_count = 0;
3060 }
3061 }
3062 else
3063 {
3064 /* It's not one of our sections, so don't allocate space. */
3065 continue;
3066 }
3067
3068 if (s->_raw_size == 0)
3069 {
3070 _bfd_strip_section_from_output (info, s);
3071 continue;
3072 }
3073
3074 /* Allocate memory for the section contents. */
3075 s->contents = (bfd_byte *) bfd_zalloc (htab->elf.dynobj, s->_raw_size);
3076 if (s->contents == NULL)
3077 return FALSE;
3078 }
3079
3080 if (htab->elf.dynamic_sections_created)
3081 {
3082 /* Add some entries to the .dynamic section. We fill in the
3083 values later, in ppc_elf_finish_dynamic_sections, but we
3084 must add the entries now so that we get the correct size for
3085 the .dynamic section. The DT_DEBUG entry is filled in by the
3086 dynamic linker and used by the debugger. */
3087 #define add_dynamic_entry(TAG, VAL) \
3088 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
3089
3090 if (!info->shared)
3091 {
3092 if (!add_dynamic_entry (DT_DEBUG, 0))
3093 return FALSE;
3094 }
3095
3096 if (htab->plt != NULL && htab->plt->_raw_size != 0)
3097 {
3098 if (!add_dynamic_entry (DT_PLTGOT, 0)
3099 || !add_dynamic_entry (DT_PLTRELSZ, 0)
3100 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3101 || !add_dynamic_entry (DT_JMPREL, 0))
3102 return FALSE;
3103 }
3104
3105 if (relocs)
3106 {
3107 if (!add_dynamic_entry (DT_RELA, 0)
3108 || !add_dynamic_entry (DT_RELASZ, 0)
3109 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
3110 return FALSE;
3111 }
3112
3113 /* If any dynamic relocs apply to a read-only section, then we
3114 need a DT_TEXTREL entry. */
3115 if ((info->flags & DF_TEXTREL) == 0)
3116 elf_link_hash_traverse (elf_hash_table (info), readonly_dynrelocs,
3117 (PTR) info);
3118
3119 if ((info->flags & DF_TEXTREL) != 0)
3120 {
3121 if (!add_dynamic_entry (DT_TEXTREL, 0))
3122 return FALSE;
3123 }
3124 }
3125 #undef add_dynamic_entry
3126
3127 return TRUE;
3128 }
3129 \f
3130 static bfd_boolean
3131 update_local_sym_info (abfd, symtab_hdr, r_symndx, tls_type)
3132 bfd *abfd;
3133 Elf_Internal_Shdr *symtab_hdr;
3134 unsigned long r_symndx;
3135 int tls_type;
3136 {
3137 bfd_signed_vma *local_got_refcounts = elf_local_got_refcounts (abfd);
3138 char *local_got_tls_masks;
3139
3140 if (local_got_refcounts == NULL)
3141 {
3142 bfd_size_type size = symtab_hdr->sh_info;
3143
3144 size *= sizeof (*local_got_refcounts) + sizeof (*local_got_tls_masks);
3145 local_got_refcounts = (bfd_signed_vma *) bfd_zalloc (abfd, size);
3146 if (local_got_refcounts == NULL)
3147 return FALSE;
3148 elf_local_got_refcounts (abfd) = local_got_refcounts;
3149 }
3150
3151 local_got_refcounts[r_symndx] += 1;
3152 local_got_tls_masks = (char *) (local_got_refcounts + symtab_hdr->sh_info);
3153 local_got_tls_masks[r_symndx] |= tls_type;
3154 return TRUE;
3155 }
3156
3157 static void
3158 bad_shared_reloc (abfd, r_type)
3159 bfd *abfd;
3160 enum elf_ppc_reloc_type r_type;
3161 {
3162 (*_bfd_error_handler)
3163 (_("%s: relocation %s cannot be used when making a shared object"),
3164 bfd_archive_filename (abfd),
3165 ppc_elf_howto_table[(int) r_type]->name);
3166 bfd_set_error (bfd_error_bad_value);
3167 }
3168
3169 /* Look through the relocs for a section during the first phase, and
3170 allocate space in the global offset table or procedure linkage
3171 table. */
3172
3173 static bfd_boolean
3174 ppc_elf_check_relocs (abfd, info, sec, relocs)
3175 bfd *abfd;
3176 struct bfd_link_info *info;
3177 asection *sec;
3178 const Elf_Internal_Rela *relocs;
3179 {
3180 struct ppc_elf_link_hash_table *htab;
3181 Elf_Internal_Shdr *symtab_hdr;
3182 struct elf_link_hash_entry **sym_hashes;
3183 const Elf_Internal_Rela *rel;
3184 const Elf_Internal_Rela *rel_end;
3185 asection *sreloc;
3186
3187 if (info->relocateable)
3188 return TRUE;
3189
3190 #ifdef DEBUG
3191 fprintf (stderr, "ppc_elf_check_relocs called for section %s in %s\n",
3192 bfd_get_section_name (abfd, sec),
3193 bfd_archive_filename (abfd));
3194 #endif
3195
3196 /* Create the linker generated sections all the time so that the
3197 special symbols are created. */
3198
3199 htab = ppc_elf_hash_table (info);
3200 if (htab->sdata == NULL)
3201 {
3202 htab->sdata = elf_linker_section (abfd, LINKER_SECTION_SDATA);
3203 if (htab->sdata == NULL)
3204 htab->sdata = ppc_elf_create_linker_section (abfd, info,
3205 LINKER_SECTION_SDATA);
3206 if (htab->sdata == NULL)
3207 return FALSE;
3208 }
3209
3210 if (htab->sdata2 == NULL)
3211 {
3212 htab->sdata2 = elf_linker_section (abfd, LINKER_SECTION_SDATA2);
3213 if (htab->sdata2 == NULL)
3214 htab->sdata2 = ppc_elf_create_linker_section (abfd, info,
3215 LINKER_SECTION_SDATA2);
3216 if (htab->sdata2 == NULL)
3217 return FALSE;
3218 }
3219
3220 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3221 sym_hashes = elf_sym_hashes (abfd);
3222 sreloc = NULL;
3223
3224 rel_end = relocs + sec->reloc_count;
3225 for (rel = relocs; rel < rel_end; rel++)
3226 {
3227 unsigned long r_symndx;
3228 enum elf_ppc_reloc_type r_type;
3229 struct elf_link_hash_entry *h;
3230 int tls_type = 0;
3231
3232 r_symndx = ELF32_R_SYM (rel->r_info);
3233 if (r_symndx < symtab_hdr->sh_info)
3234 h = NULL;
3235 else
3236 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3237
3238 /* If a relocation refers to _GLOBAL_OFFSET_TABLE_, create the .got.
3239 This shows up in particular in an R_PPC_ADDR32 in the eabi
3240 startup code. */
3241 if (h && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3242 {
3243 if (htab->got == NULL)
3244 {
3245 if (htab->elf.dynobj == NULL)
3246 htab->elf.dynobj = abfd;
3247 if (!ppc_elf_create_got (htab->elf.dynobj, info))
3248 return FALSE;
3249 }
3250 }
3251
3252 r_type = (enum elf_ppc_reloc_type) ELF32_R_TYPE (rel->r_info);
3253 switch (r_type)
3254 {
3255 case R_PPC_GOT_TLSLD16:
3256 case R_PPC_GOT_TLSLD16_LO:
3257 case R_PPC_GOT_TLSLD16_HI:
3258 case R_PPC_GOT_TLSLD16_HA:
3259 htab->tlsld_got.refcount += 1;
3260 tls_type = TLS_TLS | TLS_LD;
3261 goto dogottls;
3262
3263 case R_PPC_GOT_TLSGD16:
3264 case R_PPC_GOT_TLSGD16_LO:
3265 case R_PPC_GOT_TLSGD16_HI:
3266 case R_PPC_GOT_TLSGD16_HA:
3267 tls_type = TLS_TLS | TLS_GD;
3268 goto dogottls;
3269
3270 case R_PPC_GOT_TPREL16:
3271 case R_PPC_GOT_TPREL16_LO:
3272 case R_PPC_GOT_TPREL16_HI:
3273 case R_PPC_GOT_TPREL16_HA:
3274 if (info->shared)
3275 info->flags |= DF_STATIC_TLS;
3276 tls_type = TLS_TLS | TLS_TPREL;
3277 goto dogottls;
3278
3279 case R_PPC_GOT_DTPREL16:
3280 case R_PPC_GOT_DTPREL16_LO:
3281 case R_PPC_GOT_DTPREL16_HI:
3282 case R_PPC_GOT_DTPREL16_HA:
3283 tls_type = TLS_TLS | TLS_DTPREL;
3284 dogottls:
3285 sec->has_tls_reloc = 1;
3286 /* Fall thru */
3287
3288 /* GOT16 relocations */
3289 case R_PPC_GOT16:
3290 case R_PPC_GOT16_LO:
3291 case R_PPC_GOT16_HI:
3292 case R_PPC_GOT16_HA:
3293 /* This symbol requires a global offset table entry. */
3294 if (htab->got == NULL)
3295 {
3296 if (htab->elf.dynobj == NULL)
3297 htab->elf.dynobj = abfd;
3298 if (!ppc_elf_create_got (htab->elf.dynobj, info))
3299 return FALSE;
3300 }
3301 if (h != NULL)
3302 {
3303 h->got.refcount += 1;
3304 ppc_elf_hash_entry (h)->tls_mask |= tls_type;
3305 }
3306 else
3307 /* This is a global offset table entry for a local symbol. */
3308 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx, tls_type))
3309 return FALSE;
3310 break;
3311
3312 /* Indirect .sdata relocation. */
3313 case R_PPC_EMB_SDAI16:
3314 if (info->shared)
3315 {
3316 bad_shared_reloc (abfd, r_type);
3317 return FALSE;
3318 }
3319 if (!bfd_elf32_create_pointer_linker_section (abfd, info,
3320 htab->sdata, h, rel))
3321 return FALSE;
3322 break;
3323
3324 /* Indirect .sdata2 relocation. */
3325 case R_PPC_EMB_SDA2I16:
3326 if (info->shared)
3327 {
3328 bad_shared_reloc (abfd, r_type);
3329 return FALSE;
3330 }
3331 if (!bfd_elf32_create_pointer_linker_section (abfd, info,
3332 htab->sdata2, h, rel))
3333 return FALSE;
3334 break;
3335
3336 case R_PPC_SDAREL16:
3337 case R_PPC_EMB_SDA2REL:
3338 case R_PPC_EMB_SDA21:
3339 case R_PPC_EMB_RELSDA:
3340 case R_PPC_EMB_NADDR32:
3341 case R_PPC_EMB_NADDR16:
3342 case R_PPC_EMB_NADDR16_LO:
3343 case R_PPC_EMB_NADDR16_HI:
3344 case R_PPC_EMB_NADDR16_HA:
3345 if (info->shared)
3346 {
3347 bad_shared_reloc (abfd, r_type);
3348 return FALSE;
3349 }
3350 break;
3351
3352 case R_PPC_PLT32:
3353 case R_PPC_PLTREL24:
3354 case R_PPC_PLTREL32:
3355 case R_PPC_PLT16_LO:
3356 case R_PPC_PLT16_HI:
3357 case R_PPC_PLT16_HA:
3358 #ifdef DEBUG
3359 fprintf (stderr, "Reloc requires a PLT entry\n");
3360 #endif
3361 /* This symbol requires a procedure linkage table entry. We
3362 actually build the entry in finish_dynamic_symbol,
3363 because this might be a case of linking PIC code without
3364 linking in any dynamic objects, in which case we don't
3365 need to generate a procedure linkage table after all. */
3366
3367 if (h == NULL)
3368 {
3369 /* It does not make sense to have a procedure linkage
3370 table entry for a local symbol. */
3371 bfd_set_error (bfd_error_bad_value);
3372 return FALSE;
3373 }
3374
3375 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
3376 h->plt.refcount++;
3377 break;
3378
3379 /* The following relocations don't need to propagate the
3380 relocation if linking a shared object since they are
3381 section relative. */
3382 case R_PPC_SECTOFF:
3383 case R_PPC_SECTOFF_LO:
3384 case R_PPC_SECTOFF_HI:
3385 case R_PPC_SECTOFF_HA:
3386 case R_PPC_DTPREL16:
3387 case R_PPC_DTPREL16_LO:
3388 case R_PPC_DTPREL16_HI:
3389 case R_PPC_DTPREL16_HA:
3390 case R_PPC_TOC16:
3391 break;
3392
3393 /* This are just markers. */
3394 case R_PPC_TLS:
3395 case R_PPC_EMB_MRKREF:
3396 case R_PPC_NONE:
3397 case R_PPC_max:
3398 break;
3399
3400 /* These should only appear in dynamic objects. */
3401 case R_PPC_COPY:
3402 case R_PPC_GLOB_DAT:
3403 case R_PPC_JMP_SLOT:
3404 case R_PPC_RELATIVE:
3405 break;
3406
3407 /* These aren't handled yet. We'll report an error later. */
3408 case R_PPC_ADDR30:
3409 case R_PPC_EMB_RELSEC16:
3410 case R_PPC_EMB_RELST_LO:
3411 case R_PPC_EMB_RELST_HI:
3412 case R_PPC_EMB_RELST_HA:
3413 case R_PPC_EMB_BIT_FLD:
3414 break;
3415
3416 /* This refers only to functions defined in the shared library. */
3417 case R_PPC_LOCAL24PC:
3418 break;
3419
3420 /* This relocation describes the C++ object vtable hierarchy.
3421 Reconstruct it for later use during GC. */
3422 case R_PPC_GNU_VTINHERIT:
3423 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
3424 return FALSE;
3425 break;
3426
3427 /* This relocation describes which C++ vtable entries are actually
3428 used. Record for later use during GC. */
3429 case R_PPC_GNU_VTENTRY:
3430 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
3431 return FALSE;
3432 break;
3433
3434 /* We shouldn't really be seeing these. */
3435 case R_PPC_TPREL32:
3436 if (info->shared)
3437 info->flags |= DF_STATIC_TLS;
3438 goto dodyn;
3439
3440 /* Nor these. */
3441 case R_PPC_DTPMOD32:
3442 case R_PPC_DTPREL32:
3443 goto dodyn;
3444
3445 case R_PPC_TPREL16:
3446 case R_PPC_TPREL16_LO:
3447 case R_PPC_TPREL16_HI:
3448 case R_PPC_TPREL16_HA:
3449 if (info->shared)
3450 info->flags |= DF_STATIC_TLS;
3451 goto dodyn;
3452
3453 /* When creating a shared object, we must copy these
3454 relocs into the output file. We create a reloc
3455 section in dynobj and make room for the reloc. */
3456 case R_PPC_REL24:
3457 case R_PPC_REL14:
3458 case R_PPC_REL14_BRTAKEN:
3459 case R_PPC_REL14_BRNTAKEN:
3460 case R_PPC_REL32:
3461 if (h == NULL
3462 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3463 || SYMBOL_REFERENCES_LOCAL (info, h))
3464 break;
3465 /* fall through */
3466
3467 case R_PPC_ADDR32:
3468 case R_PPC_ADDR24:
3469 case R_PPC_ADDR16:
3470 case R_PPC_ADDR16_LO:
3471 case R_PPC_ADDR16_HI:
3472 case R_PPC_ADDR16_HA:
3473 case R_PPC_ADDR14:
3474 case R_PPC_ADDR14_BRTAKEN:
3475 case R_PPC_ADDR14_BRNTAKEN:
3476 case R_PPC_UADDR32:
3477 case R_PPC_UADDR16:
3478 if (h != NULL && !info->shared)
3479 {
3480 /* We may need a plt entry if the symbol turns out to be
3481 a function defined in a dynamic object. */
3482 h->plt.refcount++;
3483
3484 /* We may need a copy reloc too. */
3485 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
3486 }
3487
3488 dodyn:
3489 /* If we are creating a shared library, and this is a reloc
3490 against a global symbol, or a non PC relative reloc
3491 against a local symbol, then we need to copy the reloc
3492 into the shared library. However, if we are linking with
3493 -Bsymbolic, we do not need to copy a reloc against a
3494 global symbol which is defined in an object we are
3495 including in the link (i.e., DEF_REGULAR is set). At
3496 this point we have not seen all the input files, so it is
3497 possible that DEF_REGULAR is not set now but will be set
3498 later (it is never cleared). In case of a weak definition,
3499 DEF_REGULAR may be cleared later by a strong definition in
3500 a shared library. We account for that possibility below by
3501 storing information in the dyn_relocs field of the hash
3502 table entry. A similar situation occurs when creating
3503 shared libraries and symbol visibility changes render the
3504 symbol local.
3505
3506 If on the other hand, we are creating an executable, we
3507 may need to keep relocations for symbols satisfied by a
3508 dynamic library if we manage to avoid copy relocs for the
3509 symbol. */
3510 if ((info->shared
3511 && (MUST_BE_DYN_RELOC (r_type)
3512 || (h != NULL
3513 && (! info->symbolic
3514 || h->root.type == bfd_link_hash_defweak
3515 || (h->elf_link_hash_flags
3516 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
3517 || (ELIMINATE_COPY_RELOCS
3518 && !info->shared
3519 && (sec->flags & SEC_ALLOC) != 0
3520 && h != NULL
3521 && (h->root.type == bfd_link_hash_defweak
3522 || (h->elf_link_hash_flags
3523 & ELF_LINK_HASH_DEF_REGULAR) == 0)))
3524 {
3525 struct ppc_elf_dyn_relocs *p;
3526 struct ppc_elf_dyn_relocs **head;
3527
3528 #ifdef DEBUG
3529 fprintf (stderr, "ppc_elf_check_relocs need to create relocation for %s\n",
3530 (h && h->root.root.string
3531 ? h->root.root.string : "<unknown>"));
3532 #endif
3533 if (sreloc == NULL)
3534 {
3535 const char *name;
3536
3537 name = (bfd_elf_string_from_elf_section
3538 (abfd,
3539 elf_elfheader (abfd)->e_shstrndx,
3540 elf_section_data (sec)->rel_hdr.sh_name));
3541 if (name == NULL)
3542 return FALSE;
3543
3544 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
3545 && strcmp (bfd_get_section_name (abfd, sec),
3546 name + 5) == 0);
3547
3548 sreloc = bfd_get_section_by_name (htab->elf.dynobj, name);
3549 if (sreloc == NULL)
3550 {
3551 flagword flags;
3552
3553 sreloc = bfd_make_section (htab->elf.dynobj, name);
3554 flags = (SEC_HAS_CONTENTS | SEC_READONLY
3555 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3556 if ((sec->flags & SEC_ALLOC) != 0)
3557 flags |= SEC_ALLOC | SEC_LOAD;
3558 if (sreloc == NULL
3559 || ! bfd_set_section_flags (htab->elf.dynobj,
3560 sreloc, flags)
3561 || ! bfd_set_section_alignment (htab->elf.dynobj,
3562 sreloc, 2))
3563 return FALSE;
3564 }
3565 elf_section_data (sec)->sreloc = sreloc;
3566 }
3567
3568 /* If this is a global symbol, we count the number of
3569 relocations we need for this symbol. */
3570 if (h != NULL)
3571 {
3572 head = &ppc_elf_hash_entry (h)->dyn_relocs;
3573 }
3574 else
3575 {
3576 /* Track dynamic relocs needed for local syms too.
3577 We really need local syms available to do this
3578 easily. Oh well. */
3579
3580 asection *s;
3581 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
3582 sec, r_symndx);
3583 if (s == NULL)
3584 return FALSE;
3585
3586 head = ((struct ppc_elf_dyn_relocs **)
3587 &elf_section_data (s)->local_dynrel);
3588 }
3589
3590 p = *head;
3591 if (p == NULL || p->sec != sec)
3592 {
3593 p = ((struct ppc_elf_dyn_relocs *)
3594 bfd_alloc (htab->elf.dynobj, sizeof *p));
3595 if (p == NULL)
3596 return FALSE;
3597 p->next = *head;
3598 *head = p;
3599 p->sec = sec;
3600 p->count = 0;
3601 p->pc_count = 0;
3602 }
3603
3604 p->count += 1;
3605 if (!MUST_BE_DYN_RELOC (r_type))
3606 p->pc_count += 1;
3607 }
3608
3609 break;
3610 }
3611 }
3612
3613 return TRUE;
3614 }
3615
3616 /* Return the section that should be marked against GC for a given
3617 relocation. */
3618
3619 static asection *
3620 ppc_elf_gc_mark_hook (sec, info, rel, h, sym)
3621 asection *sec;
3622 struct bfd_link_info *info ATTRIBUTE_UNUSED;
3623 Elf_Internal_Rela *rel;
3624 struct elf_link_hash_entry *h;
3625 Elf_Internal_Sym *sym;
3626 {
3627 if (h != NULL)
3628 {
3629 switch (ELF32_R_TYPE (rel->r_info))
3630 {
3631 case R_PPC_GNU_VTINHERIT:
3632 case R_PPC_GNU_VTENTRY:
3633 break;
3634
3635 default:
3636 switch (h->root.type)
3637 {
3638 case bfd_link_hash_defined:
3639 case bfd_link_hash_defweak:
3640 return h->root.u.def.section;
3641
3642 case bfd_link_hash_common:
3643 return h->root.u.c.p->section;
3644
3645 default:
3646 break;
3647 }
3648 }
3649 }
3650 else
3651 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
3652
3653 return NULL;
3654 }
3655
3656 /* Update the got, plt and dynamic reloc reference counts for the
3657 section being removed. */
3658
3659 static bfd_boolean
3660 ppc_elf_gc_sweep_hook (abfd, info, sec, relocs)
3661 bfd *abfd;
3662 struct bfd_link_info *info;
3663 asection *sec;
3664 const Elf_Internal_Rela *relocs;
3665 {
3666 struct ppc_elf_link_hash_table *htab;
3667 Elf_Internal_Shdr *symtab_hdr;
3668 struct elf_link_hash_entry **sym_hashes;
3669 bfd_signed_vma *local_got_refcounts;
3670 const Elf_Internal_Rela *rel, *relend;
3671
3672 elf_section_data (sec)->local_dynrel = NULL;
3673
3674 htab = ppc_elf_hash_table (info);
3675 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3676 sym_hashes = elf_sym_hashes (abfd);
3677 local_got_refcounts = elf_local_got_refcounts (abfd);
3678
3679 relend = relocs + sec->reloc_count;
3680 for (rel = relocs; rel < relend; rel++)
3681 {
3682 unsigned long r_symndx;
3683 enum elf_ppc_reloc_type r_type;
3684 struct elf_link_hash_entry *h = NULL;
3685
3686 r_symndx = ELF32_R_SYM (rel->r_info);
3687 if (r_symndx >= symtab_hdr->sh_info)
3688 {
3689 struct ppc_elf_dyn_relocs **pp, *p;
3690 struct ppc_elf_link_hash_entry *eh;
3691
3692 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3693 eh = (struct ppc_elf_link_hash_entry *) h;
3694
3695 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
3696 if (p->sec == sec)
3697 {
3698 /* Everything must go for SEC. */
3699 *pp = p->next;
3700 break;
3701 }
3702 }
3703
3704 r_type = (enum elf_ppc_reloc_type) ELF32_R_TYPE (rel->r_info);
3705 switch (r_type)
3706 {
3707 case R_PPC_GOT_TLSLD16:
3708 case R_PPC_GOT_TLSLD16_LO:
3709 case R_PPC_GOT_TLSLD16_HI:
3710 case R_PPC_GOT_TLSLD16_HA:
3711 htab->tlsld_got.refcount -= 1;
3712 /* Fall thru */
3713
3714 case R_PPC_GOT_TLSGD16:
3715 case R_PPC_GOT_TLSGD16_LO:
3716 case R_PPC_GOT_TLSGD16_HI:
3717 case R_PPC_GOT_TLSGD16_HA:
3718 case R_PPC_GOT_TPREL16:
3719 case R_PPC_GOT_TPREL16_LO:
3720 case R_PPC_GOT_TPREL16_HI:
3721 case R_PPC_GOT_TPREL16_HA:
3722 case R_PPC_GOT_DTPREL16:
3723 case R_PPC_GOT_DTPREL16_LO:
3724 case R_PPC_GOT_DTPREL16_HI:
3725 case R_PPC_GOT_DTPREL16_HA:
3726 case R_PPC_GOT16:
3727 case R_PPC_GOT16_LO:
3728 case R_PPC_GOT16_HI:
3729 case R_PPC_GOT16_HA:
3730 if (h != NULL)
3731 {
3732 if (h->got.refcount > 0)
3733 h->got.refcount--;
3734 }
3735 else if (local_got_refcounts != NULL)
3736 {
3737 if (local_got_refcounts[r_symndx] > 0)
3738 local_got_refcounts[r_symndx]--;
3739 }
3740 break;
3741
3742 case R_PPC_REL24:
3743 case R_PPC_REL14:
3744 case R_PPC_REL14_BRTAKEN:
3745 case R_PPC_REL14_BRNTAKEN:
3746 case R_PPC_REL32:
3747 if (h == NULL
3748 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3749 || SYMBOL_REFERENCES_LOCAL (info, h))
3750 break;
3751 /* Fall thru */
3752
3753 case R_PPC_ADDR32:
3754 case R_PPC_ADDR24:
3755 case R_PPC_ADDR16:
3756 case R_PPC_ADDR16_LO:
3757 case R_PPC_ADDR16_HI:
3758 case R_PPC_ADDR16_HA:
3759 case R_PPC_ADDR14:
3760 case R_PPC_ADDR14_BRTAKEN:
3761 case R_PPC_ADDR14_BRNTAKEN:
3762 case R_PPC_UADDR32:
3763 case R_PPC_UADDR16:
3764 case R_PPC_PLT32:
3765 case R_PPC_PLTREL24:
3766 case R_PPC_PLT16_LO:
3767 case R_PPC_PLT16_HI:
3768 case R_PPC_PLT16_HA:
3769 if (h != NULL)
3770 {
3771 if (h->plt.refcount > 0)
3772 h->plt.refcount--;
3773 }
3774 break;
3775
3776 default:
3777 break;
3778 }
3779 }
3780 return TRUE;
3781 }
3782
3783 /* Set htab->tls_sec and htab->tls_get_addr. */
3784
3785 bfd_boolean
3786 ppc_elf_tls_setup (obfd, info)
3787 bfd *obfd;
3788 struct bfd_link_info *info;
3789 {
3790 asection *tls;
3791 struct ppc_elf_link_hash_table *htab;
3792
3793 htab = ppc_elf_hash_table (info);
3794 htab->tls_get_addr = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
3795 FALSE, FALSE, TRUE);
3796
3797 for (tls = obfd->sections; tls != NULL; tls = tls->next)
3798 if ((tls->flags & (SEC_THREAD_LOCAL | SEC_LOAD))
3799 == (SEC_THREAD_LOCAL | SEC_LOAD))
3800 break;
3801 htab->tls_sec = tls;
3802
3803 return tls != NULL;
3804 }
3805
3806 /* Run through all the TLS relocs looking for optimization
3807 opportunities. */
3808
3809 bfd_boolean
3810 ppc_elf_tls_optimize (obfd, info)
3811 bfd *obfd ATTRIBUTE_UNUSED;
3812 struct bfd_link_info *info;
3813 {
3814 bfd *ibfd;
3815 asection *sec;
3816 struct ppc_elf_link_hash_table *htab;
3817
3818 if (info->relocateable || info->shared)
3819 return TRUE;
3820
3821 htab = ppc_elf_hash_table (info);
3822 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3823 {
3824 Elf_Internal_Sym *locsyms = NULL;
3825 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
3826
3827 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
3828 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
3829 {
3830 Elf_Internal_Rela *relstart, *rel, *relend;
3831 int expecting_tls_get_addr;
3832
3833 /* Read the relocations. */
3834 relstart = _bfd_elf32_link_read_relocs (ibfd, sec, (PTR) NULL,
3835 (Elf_Internal_Rela *) NULL,
3836 info->keep_memory);
3837 if (relstart == NULL)
3838 return FALSE;
3839
3840 expecting_tls_get_addr = 0;
3841 relend = relstart + sec->reloc_count;
3842 for (rel = relstart; rel < relend; rel++)
3843 {
3844 enum elf_ppc_reloc_type r_type;
3845 unsigned long r_symndx;
3846 struct elf_link_hash_entry *h = NULL;
3847 char *tls_mask;
3848 char tls_set, tls_clear;
3849 bfd_boolean is_local;
3850
3851 r_symndx = ELF32_R_SYM (rel->r_info);
3852 if (r_symndx >= symtab_hdr->sh_info)
3853 {
3854 struct elf_link_hash_entry **sym_hashes;
3855
3856 sym_hashes = elf_sym_hashes (ibfd);
3857 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3858 while (h->root.type == bfd_link_hash_indirect
3859 || h->root.type == bfd_link_hash_warning)
3860 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3861 }
3862
3863 is_local = FALSE;
3864 if (h == NULL
3865 || !(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC))
3866 is_local = TRUE;
3867
3868 r_type = (enum elf_ppc_reloc_type) ELF32_R_TYPE (rel->r_info);
3869 switch (r_type)
3870 {
3871 case R_PPC_GOT_TLSLD16:
3872 case R_PPC_GOT_TLSLD16_LO:
3873 case R_PPC_GOT_TLSLD16_HI:
3874 case R_PPC_GOT_TLSLD16_HA:
3875 /* These relocs should never be against a symbol
3876 defined in a shared lib. Leave them alone if
3877 that turns out to be the case. */
3878 expecting_tls_get_addr = 0;
3879 htab->tlsld_got.refcount -= 1;
3880 if (!is_local)
3881 continue;
3882
3883 /* LD -> LE */
3884 tls_set = 0;
3885 tls_clear = TLS_LD;
3886 expecting_tls_get_addr = 1;
3887 break;
3888
3889 case R_PPC_GOT_TLSGD16:
3890 case R_PPC_GOT_TLSGD16_LO:
3891 case R_PPC_GOT_TLSGD16_HI:
3892 case R_PPC_GOT_TLSGD16_HA:
3893 if (is_local)
3894 /* GD -> LE */
3895 tls_set = 0;
3896 else
3897 /* GD -> IE */
3898 tls_set = TLS_TLS | TLS_TPRELGD;
3899 tls_clear = TLS_GD;
3900 expecting_tls_get_addr = 1;
3901 break;
3902
3903 case R_PPC_GOT_TPREL16:
3904 case R_PPC_GOT_TPREL16_LO:
3905 case R_PPC_GOT_TPREL16_HI:
3906 case R_PPC_GOT_TPREL16_HA:
3907 expecting_tls_get_addr = 0;
3908 if (is_local)
3909 {
3910 /* IE -> LE */
3911 tls_set = 0;
3912 tls_clear = TLS_TPREL;
3913 break;
3914 }
3915 else
3916 continue;
3917
3918 case R_PPC_REL14:
3919 case R_PPC_REL14_BRTAKEN:
3920 case R_PPC_REL14_BRNTAKEN:
3921 case R_PPC_REL24:
3922 if (expecting_tls_get_addr
3923 && h != NULL
3924 && h == htab->tls_get_addr)
3925 {
3926 if (h->plt.refcount > 0)
3927 h->plt.refcount -= 1;
3928 }
3929 expecting_tls_get_addr = 0;
3930 continue;
3931
3932 default:
3933 expecting_tls_get_addr = 0;
3934 continue;
3935 }
3936
3937 if (h != NULL)
3938 {
3939 if (tls_set == 0)
3940 {
3941 /* We managed to get rid of a got entry. */
3942 if (h->got.refcount > 0)
3943 h->got.refcount -= 1;
3944 }
3945 tls_mask = &ppc_elf_hash_entry (h)->tls_mask;
3946 }
3947 else
3948 {
3949 Elf_Internal_Sym *sym;
3950 bfd_signed_vma *lgot_refs;
3951 char *lgot_masks;
3952
3953 if (locsyms == NULL)
3954 {
3955 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
3956 if (locsyms == NULL)
3957 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
3958 symtab_hdr->sh_info,
3959 0, NULL, NULL, NULL);
3960 if (locsyms == NULL)
3961 {
3962 if (elf_section_data (sec)->relocs != relstart)
3963 free (relstart);
3964 return FALSE;
3965 }
3966 }
3967 sym = locsyms + r_symndx;
3968 lgot_refs = elf_local_got_refcounts (ibfd);
3969 if (lgot_refs == NULL)
3970 abort ();
3971 if (tls_set == 0)
3972 {
3973 /* We managed to get rid of a got entry. */
3974 if (lgot_refs[r_symndx] > 0)
3975 lgot_refs[r_symndx] -= 1;
3976 }
3977 lgot_masks = (char *) (lgot_refs + symtab_hdr->sh_info);
3978 tls_mask = &lgot_masks[r_symndx];
3979 }
3980
3981 *tls_mask |= tls_set;
3982 *tls_mask &= ~tls_clear;
3983 }
3984
3985 if (elf_section_data (sec)->relocs != relstart)
3986 free (relstart);
3987 }
3988
3989 if (locsyms != NULL
3990 && (symtab_hdr->contents != (unsigned char *) locsyms))
3991 {
3992 if (!info->keep_memory)
3993 free (locsyms);
3994 else
3995 symtab_hdr->contents = (unsigned char *) locsyms;
3996 }
3997 }
3998 return TRUE;
3999 }
4000 \f
4001 /* Hook called by the linker routine which adds symbols from an object
4002 file. We use it to put .comm items in .sbss, and not .bss. */
4003
4004 static bfd_boolean
4005 ppc_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
4006 bfd *abfd;
4007 struct bfd_link_info *info;
4008 const Elf_Internal_Sym *sym;
4009 const char **namep ATTRIBUTE_UNUSED;
4010 flagword *flagsp ATTRIBUTE_UNUSED;
4011 asection **secp;
4012 bfd_vma *valp;
4013 {
4014 if (sym->st_shndx == SHN_COMMON
4015 && !info->relocateable
4016 && sym->st_size <= elf_gp_size (abfd)
4017 && info->hash->creator->flavour == bfd_target_elf_flavour)
4018 {
4019 /* Common symbols less than or equal to -G nn bytes are automatically
4020 put into .sdata. */
4021 elf_linker_section_t *sdata
4022 = ppc_elf_create_linker_section (abfd, info, LINKER_SECTION_SDATA);
4023
4024 if (!sdata->bss_section)
4025 {
4026 bfd_size_type amt;
4027
4028 /* We don't go through bfd_make_section, because we don't
4029 want to attach this common section to DYNOBJ. The linker
4030 will move the symbols to the appropriate output section
4031 when it defines common symbols. */
4032 amt = sizeof (asection);
4033 sdata->bss_section = (asection *) bfd_zalloc (abfd, amt);
4034 if (sdata->bss_section == NULL)
4035 return FALSE;
4036 sdata->bss_section->name = sdata->bss_name;
4037 sdata->bss_section->flags = SEC_IS_COMMON;
4038 sdata->bss_section->output_section = sdata->bss_section;
4039 amt = sizeof (asymbol);
4040 sdata->bss_section->symbol = (asymbol *) bfd_zalloc (abfd, amt);
4041 amt = sizeof (asymbol *);
4042 sdata->bss_section->symbol_ptr_ptr =
4043 (asymbol **) bfd_zalloc (abfd, amt);
4044 if (sdata->bss_section->symbol == NULL
4045 || sdata->bss_section->symbol_ptr_ptr == NULL)
4046 return FALSE;
4047 sdata->bss_section->symbol->name = sdata->bss_name;
4048 sdata->bss_section->symbol->flags = BSF_SECTION_SYM;
4049 sdata->bss_section->symbol->section = sdata->bss_section;
4050 *sdata->bss_section->symbol_ptr_ptr = sdata->bss_section->symbol;
4051 }
4052
4053 *secp = sdata->bss_section;
4054 *valp = sym->st_size;
4055 }
4056
4057 return TRUE;
4058 }
4059 \f
4060 /* Finish up dynamic symbol handling. We set the contents of various
4061 dynamic sections here. */
4062
4063 static bfd_boolean
4064 ppc_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
4065 bfd *output_bfd;
4066 struct bfd_link_info *info;
4067 struct elf_link_hash_entry *h;
4068 Elf_Internal_Sym *sym;
4069 {
4070 struct ppc_elf_link_hash_table *htab;
4071
4072 #ifdef DEBUG
4073 fprintf (stderr, "ppc_elf_finish_dynamic_symbol called for %s",
4074 h->root.root.string);
4075 #endif
4076
4077 htab = ppc_elf_hash_table (info);
4078 BFD_ASSERT (htab->elf.dynobj != NULL);
4079
4080 if (h->plt.offset != (bfd_vma) -1)
4081 {
4082 Elf_Internal_Rela rela;
4083 bfd_byte *loc;
4084 bfd_vma reloc_index;
4085
4086 #ifdef DEBUG
4087 fprintf (stderr, ", plt_offset = %d", h->plt.offset);
4088 #endif
4089
4090 /* This symbol has an entry in the procedure linkage table. Set
4091 it up. */
4092
4093 BFD_ASSERT (h->dynindx != -1);
4094 BFD_ASSERT (htab->plt != NULL && htab->relplt != NULL);
4095
4096 /* We don't need to fill in the .plt. The ppc dynamic linker
4097 will fill it in. */
4098
4099 /* Fill in the entry in the .rela.plt section. */
4100 rela.r_offset = (htab->plt->output_section->vma
4101 + htab->plt->output_offset
4102 + h->plt.offset);
4103 rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_JMP_SLOT);
4104 rela.r_addend = 0;
4105
4106 reloc_index = (h->plt.offset - PLT_INITIAL_ENTRY_SIZE) / PLT_SLOT_SIZE;
4107 if (reloc_index > PLT_NUM_SINGLE_ENTRIES)
4108 reloc_index -= (reloc_index - PLT_NUM_SINGLE_ENTRIES) / 2;
4109 loc = (htab->relplt->contents
4110 + reloc_index * sizeof (Elf32_External_Rela));
4111 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4112
4113 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
4114 {
4115 /* Mark the symbol as undefined, rather than as defined in
4116 the .plt section. Leave the value alone. */
4117 sym->st_shndx = SHN_UNDEF;
4118 /* If the symbol is weak, we do need to clear the value.
4119 Otherwise, the PLT entry would provide a definition for
4120 the symbol even if the symbol wasn't defined anywhere,
4121 and so the symbol would never be NULL. */
4122 if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
4123 == 0)
4124 sym->st_value = 0;
4125 }
4126 }
4127
4128 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
4129 {
4130 asection *s;
4131 Elf_Internal_Rela rela;
4132 bfd_byte *loc;
4133
4134 /* This symbols needs a copy reloc. Set it up. */
4135
4136 #ifdef DEBUG
4137 fprintf (stderr, ", copy");
4138 #endif
4139
4140 BFD_ASSERT (h->dynindx != -1);
4141
4142 if (h->size <= elf_gp_size (htab->elf.dynobj))
4143 s = htab->relsbss;
4144 else
4145 s = htab->relbss;
4146 BFD_ASSERT (s != NULL);
4147
4148 rela.r_offset = (h->root.u.def.value
4149 + h->root.u.def.section->output_section->vma
4150 + h->root.u.def.section->output_offset);
4151 rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_COPY);
4152 rela.r_addend = 0;
4153 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
4154 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4155 }
4156
4157 #ifdef DEBUG
4158 fprintf (stderr, "\n");
4159 #endif
4160
4161 /* Mark some specially defined symbols as absolute. */
4162 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
4163 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
4164 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
4165 sym->st_shndx = SHN_ABS;
4166
4167 return TRUE;
4168 }
4169 \f
4170 /* Finish up the dynamic sections. */
4171
4172 static bfd_boolean
4173 ppc_elf_finish_dynamic_sections (output_bfd, info)
4174 bfd *output_bfd;
4175 struct bfd_link_info *info;
4176 {
4177 asection *sdyn;
4178 struct ppc_elf_link_hash_table *htab;
4179
4180 #ifdef DEBUG
4181 fprintf (stderr, "ppc_elf_finish_dynamic_sections called\n");
4182 #endif
4183
4184 htab = ppc_elf_hash_table (info);
4185 sdyn = bfd_get_section_by_name (htab->elf.dynobj, ".dynamic");
4186
4187 if (htab->elf.dynamic_sections_created)
4188 {
4189 Elf32_External_Dyn *dyncon, *dynconend;
4190
4191 BFD_ASSERT (htab->plt != NULL && sdyn != NULL);
4192
4193 dyncon = (Elf32_External_Dyn *) sdyn->contents;
4194 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
4195 for (; dyncon < dynconend; dyncon++)
4196 {
4197 Elf_Internal_Dyn dyn;
4198 asection *s;
4199
4200 bfd_elf32_swap_dyn_in (htab->elf.dynobj, dyncon, &dyn);
4201
4202 switch (dyn.d_tag)
4203 {
4204 case DT_PLTGOT:
4205 s = htab->plt;
4206 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
4207 break;
4208
4209 case DT_PLTRELSZ:
4210 dyn.d_un.d_val = htab->relplt->_raw_size;
4211 break;
4212
4213 case DT_JMPREL:
4214 s = htab->relplt;
4215 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
4216 break;
4217
4218 default:
4219 continue;
4220 }
4221
4222 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4223 }
4224 }
4225
4226 /* Add a blrl instruction at _GLOBAL_OFFSET_TABLE_-4 so that a function can
4227 easily find the address of the _GLOBAL_OFFSET_TABLE_. */
4228 if (htab->got)
4229 {
4230 unsigned char *contents = htab->got->contents;
4231 bfd_put_32 (output_bfd, (bfd_vma) 0x4e800021 /* blrl */, contents);
4232
4233 if (sdyn == NULL)
4234 bfd_put_32 (output_bfd, (bfd_vma) 0, contents + 4);
4235 else
4236 bfd_put_32 (output_bfd,
4237 sdyn->output_section->vma + sdyn->output_offset,
4238 contents + 4);
4239
4240 elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 4;
4241 }
4242
4243 return TRUE;
4244 }
4245 \f
4246 /* The RELOCATE_SECTION function is called by the ELF backend linker
4247 to handle the relocations for a section.
4248
4249 The relocs are always passed as Rela structures; if the section
4250 actually uses Rel structures, the r_addend field will always be
4251 zero.
4252
4253 This function is responsible for adjust the section contents as
4254 necessary, and (if using Rela relocs and generating a
4255 relocateable output file) adjusting the reloc addend as
4256 necessary.
4257
4258 This function does not have to worry about setting the reloc
4259 address or the reloc symbol index.
4260
4261 LOCAL_SYMS is a pointer to the swapped in local symbols.
4262
4263 LOCAL_SECTIONS is an array giving the section in the input file
4264 corresponding to the st_shndx field of each local symbol.
4265
4266 The global hash table entry for the global symbols can be found
4267 via elf_sym_hashes (input_bfd).
4268
4269 When generating relocateable output, this function must handle
4270 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
4271 going to be the section symbol corresponding to the output
4272 section, which means that the addend must be adjusted
4273 accordingly. */
4274
4275 static bfd_boolean
4276 ppc_elf_relocate_section (output_bfd, info, input_bfd, input_section,
4277 contents, relocs, local_syms, local_sections)
4278 bfd *output_bfd;
4279 struct bfd_link_info *info;
4280 bfd *input_bfd;
4281 asection *input_section;
4282 bfd_byte *contents;
4283 Elf_Internal_Rela *relocs;
4284 Elf_Internal_Sym *local_syms;
4285 asection **local_sections;
4286 {
4287 Elf_Internal_Shdr *symtab_hdr;
4288 struct elf_link_hash_entry **sym_hashes;
4289 struct ppc_elf_link_hash_table *htab;
4290 Elf_Internal_Rela *rel;
4291 Elf_Internal_Rela *relend;
4292 Elf_Internal_Rela outrel;
4293 bfd_byte *loc;
4294 asection *sreloc = NULL;
4295 bfd_vma *local_got_offsets;
4296 bfd_boolean ret = TRUE;
4297
4298 #ifdef DEBUG
4299 fprintf (stderr, "ppc_elf_relocate_section called for %s section %s, %ld relocations%s\n",
4300 bfd_archive_filename (input_bfd),
4301 bfd_section_name(input_bfd, input_section),
4302 (long) input_section->reloc_count,
4303 (info->relocateable) ? " (relocatable)" : "");
4304 #endif
4305
4306 if (info->relocateable)
4307 return TRUE;
4308
4309 if (!ppc_elf_howto_table[R_PPC_ADDR32])
4310 /* Initialize howto table if needed. */
4311 ppc_elf_howto_init ();
4312
4313 htab = ppc_elf_hash_table (info);
4314 local_got_offsets = elf_local_got_offsets (input_bfd);
4315 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4316 sym_hashes = elf_sym_hashes (input_bfd);
4317 rel = relocs;
4318 relend = relocs + input_section->reloc_count;
4319 for (; rel < relend; rel++)
4320 {
4321 enum elf_ppc_reloc_type r_type;
4322 bfd_vma addend;
4323 bfd_reloc_status_type r;
4324 Elf_Internal_Sym *sym;
4325 asection *sec;
4326 struct elf_link_hash_entry *h;
4327 const char *sym_name;
4328 reloc_howto_type *howto;
4329 unsigned long r_symndx;
4330 bfd_vma relocation;
4331 bfd_vma branch_bit, insn, from;
4332 bfd_boolean unresolved_reloc;
4333 bfd_boolean warned;
4334 unsigned int tls_type, tls_mask, tls_gd;
4335
4336 r_type = (enum elf_ppc_reloc_type)ELF32_R_TYPE (rel->r_info);
4337 sym = (Elf_Internal_Sym *) 0;
4338 sec = (asection *) 0;
4339 h = (struct elf_link_hash_entry *) 0;
4340 unresolved_reloc = FALSE;
4341 warned = FALSE;
4342 r_symndx = ELF32_R_SYM (rel->r_info);
4343 if (r_symndx < symtab_hdr->sh_info)
4344 {
4345 sym = local_syms + r_symndx;
4346 sec = local_sections[r_symndx];
4347 sym_name = bfd_elf_local_sym_name (input_bfd, sym);
4348
4349 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
4350 }
4351 else
4352 {
4353 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4354 while (h->root.type == bfd_link_hash_indirect
4355 || h->root.type == bfd_link_hash_warning)
4356 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4357 sym_name = h->root.root.string;
4358
4359 relocation = 0;
4360 if (h->root.type == bfd_link_hash_defined
4361 || h->root.type == bfd_link_hash_defweak)
4362 {
4363 sec = h->root.u.def.section;
4364 /* Set a flag that will be cleared later if we find a
4365 relocation value for this symbol. output_section
4366 is typically NULL for symbols satisfied by a shared
4367 library. */
4368 if (sec->output_section == NULL)
4369 unresolved_reloc = TRUE;
4370 else
4371 relocation = (h->root.u.def.value
4372 + sec->output_section->vma
4373 + sec->output_offset);
4374 }
4375 else if (h->root.type == bfd_link_hash_undefweak)
4376 ;
4377 else if (info->shared
4378 && !info->no_undefined
4379 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
4380 ;
4381 else
4382 {
4383 if (! ((*info->callbacks->undefined_symbol)
4384 (info, h->root.root.string, input_bfd, input_section,
4385 rel->r_offset, (!info->shared
4386 || info->no_undefined
4387 || ELF_ST_VISIBILITY (h->other)))))
4388 return FALSE;
4389 warned = TRUE;
4390 }
4391 }
4392
4393 /* TLS optimizations. Replace instruction sequences and relocs
4394 based on information we collected in tls_optimize. We edit
4395 RELOCS so that --emit-relocs will output something sensible
4396 for the final instruction stream. */
4397 tls_mask = 0;
4398 tls_gd = 0;
4399 if (IS_PPC_TLS_RELOC (r_type))
4400 {
4401 if (h != NULL)
4402 tls_mask = ((struct ppc_elf_link_hash_entry *) h)->tls_mask;
4403 else if (local_got_offsets != NULL)
4404 {
4405 char *lgot_masks;
4406 lgot_masks = (char *) (local_got_offsets + symtab_hdr->sh_info);
4407 tls_mask = lgot_masks[r_symndx];
4408 }
4409 }
4410
4411 /* Ensure reloc mapping code below stays sane. */
4412 if ((R_PPC_GOT_TLSLD16 & 3) != (R_PPC_GOT_TLSGD16 & 3)
4413 || (R_PPC_GOT_TLSLD16_LO & 3) != (R_PPC_GOT_TLSGD16_LO & 3)
4414 || (R_PPC_GOT_TLSLD16_HI & 3) != (R_PPC_GOT_TLSGD16_HI & 3)
4415 || (R_PPC_GOT_TLSLD16_HA & 3) != (R_PPC_GOT_TLSGD16_HA & 3)
4416 || (R_PPC_GOT_TLSLD16 & 3) != (R_PPC_GOT_TPREL16 & 3)
4417 || (R_PPC_GOT_TLSLD16_LO & 3) != (R_PPC_GOT_TPREL16_LO & 3)
4418 || (R_PPC_GOT_TLSLD16_HI & 3) != (R_PPC_GOT_TPREL16_HI & 3)
4419 || (R_PPC_GOT_TLSLD16_HA & 3) != (R_PPC_GOT_TPREL16_HA & 3))
4420 abort ();
4421 switch (r_type)
4422 {
4423 default:
4424 break;
4425
4426 case R_PPC_GOT_TPREL16:
4427 case R_PPC_GOT_TPREL16_LO:
4428 if (tls_mask != 0
4429 && (tls_mask & TLS_TPREL) == 0)
4430 {
4431 bfd_vma insn;
4432 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - 2);
4433 insn &= 31 << 21;
4434 insn |= 0x3c020000; /* addis 0,2,0 */
4435 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - 2);
4436 r_type = R_PPC_TPREL16_HA;
4437 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
4438 }
4439 break;
4440
4441 case R_PPC_TLS:
4442 if (tls_mask != 0
4443 && (tls_mask & TLS_TPREL) == 0)
4444 {
4445 bfd_vma insn, rtra;
4446 insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
4447 if ((insn & ((31 << 26) | (31 << 11)))
4448 == ((31 << 26) | (2 << 11)))
4449 rtra = insn & ((1 << 26) - (1 << 16));
4450 else if ((insn & ((31 << 26) | (31 << 16)))
4451 == ((31 << 26) | (2 << 16)))
4452 rtra = (insn & (31 << 21)) | ((insn & (31 << 11)) << 5);
4453 else
4454 abort ();
4455 if ((insn & ((1 << 11) - (1 << 1))) == 266 << 1)
4456 /* add -> addi. */
4457 insn = 14 << 26;
4458 else if ((insn & (31 << 1)) == 23 << 1
4459 && ((insn & (31 << 6)) < 14 << 6
4460 || ((insn & (31 << 6)) >= 16 << 6
4461 && (insn & (31 << 6)) < 24 << 6)))
4462 /* load and store indexed -> dform. */
4463 insn = (32 | ((insn >> 6) & 31)) << 26;
4464 else if ((insn & (31 << 1)) == 21 << 1
4465 && (insn & (0x1a << 6)) == 0)
4466 /* ldx, ldux, stdx, stdux -> ld, ldu, std, stdu. */
4467 insn = (((58 | ((insn >> 6) & 4)) << 26)
4468 | ((insn >> 6) & 1));
4469 else if ((insn & (31 << 1)) == 21 << 1
4470 && (insn & ((1 << 11) - (1 << 1))) == 341 << 1)
4471 /* lwax -> lwa. */
4472 insn = (58 << 26) | 2;
4473 else
4474 abort ();
4475 insn |= rtra;
4476 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
4477 r_type = R_PPC_TPREL16_LO;
4478 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
4479 /* Was PPC_TLS which sits on insn boundary, now
4480 PPC_TPREL16_LO which is at insn+2. */
4481 rel->r_offset += 2;
4482 }
4483 break;
4484
4485 case R_PPC_GOT_TLSGD16_HI:
4486 case R_PPC_GOT_TLSGD16_HA:
4487 tls_gd = TLS_TPRELGD;
4488 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
4489 goto tls_gdld_hi;
4490 break;
4491
4492 case R_PPC_GOT_TLSLD16_HI:
4493 case R_PPC_GOT_TLSLD16_HA:
4494 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
4495 {
4496 tls_gdld_hi:
4497 if ((tls_mask & tls_gd) != 0)
4498 r_type = (((r_type - (R_PPC_GOT_TLSGD16 & 3)) & 3)
4499 + R_PPC_GOT_TPREL16);
4500 else
4501 {
4502 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
4503 rel->r_offset -= 2;
4504 r_type = R_PPC_NONE;
4505 }
4506 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
4507 }
4508 break;
4509
4510 case R_PPC_GOT_TLSGD16:
4511 case R_PPC_GOT_TLSGD16_LO:
4512 tls_gd = TLS_TPRELGD;
4513 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
4514 goto tls_get_addr_check;
4515 break;
4516
4517 case R_PPC_GOT_TLSLD16:
4518 case R_PPC_GOT_TLSLD16_LO:
4519 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
4520 {
4521 tls_get_addr_check:
4522 if (rel + 1 < relend)
4523 {
4524 enum elf_ppc_reloc_type r_type2;
4525 unsigned long r_symndx2;
4526 struct elf_link_hash_entry *h2;
4527 bfd_vma insn1, insn2;
4528 bfd_vma offset;
4529
4530 /* The next instruction should be a call to
4531 __tls_get_addr. Peek at the reloc to be sure. */
4532 r_type2
4533 = (enum elf_ppc_reloc_type) ELF32_R_TYPE (rel[1].r_info);
4534 r_symndx2 = ELF32_R_SYM (rel[1].r_info);
4535 if (r_symndx2 < symtab_hdr->sh_info
4536 || (r_type2 != R_PPC_REL14
4537 && r_type2 != R_PPC_REL14_BRTAKEN
4538 && r_type2 != R_PPC_REL14_BRNTAKEN
4539 && r_type2 != R_PPC_REL24
4540 && r_type2 != R_PPC_PLTREL24))
4541 break;
4542
4543 h2 = sym_hashes[r_symndx2 - symtab_hdr->sh_info];
4544 while (h2->root.type == bfd_link_hash_indirect
4545 || h2->root.type == bfd_link_hash_warning)
4546 h2 = (struct elf_link_hash_entry *) h2->root.u.i.link;
4547 if (h2 == NULL || h2 != htab->tls_get_addr)
4548 break;
4549
4550 /* OK, it checks out. Replace the call. */
4551 offset = rel[1].r_offset;
4552 insn1 = bfd_get_32 (output_bfd,
4553 contents + rel->r_offset - 2);
4554 if ((tls_mask & tls_gd) != 0)
4555 {
4556 /* IE */
4557 insn1 &= (1 << 26) - 1;
4558 insn1 |= 32 << 26; /* lwz */
4559 insn2 = 0x7c631214; /* add 3,3,2 */
4560 rel[1].r_info = ELF32_R_INFO (r_symndx2, R_PPC_NONE);
4561 r_type = (((r_type - (R_PPC_GOT_TLSGD16 & 3)) & 3)
4562 + R_PPC_GOT_TPREL16);
4563 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
4564 }
4565 else
4566 {
4567 /* LE */
4568 insn1 = 0x3c620000; /* addis 3,2,0 */
4569 insn2 = 0x38630000; /* addi 3,3,0 */
4570 if (tls_gd == 0)
4571 {
4572 /* Was an LD reloc. */
4573 r_symndx = 0;
4574 rel->r_addend = htab->tls_sec->vma + DTP_OFFSET;
4575 rel[1].r_addend = htab->tls_sec->vma + DTP_OFFSET;
4576 }
4577 r_type = R_PPC_TPREL16_HA;
4578 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
4579 rel[1].r_info = ELF32_R_INFO (r_symndx,
4580 R_PPC_TPREL16_LO);
4581 rel[1].r_offset += 2;
4582 }
4583 bfd_put_32 (output_bfd, insn1, contents + rel->r_offset - 2);
4584 bfd_put_32 (output_bfd, insn2, contents + offset);
4585 if (tls_gd == 0)
4586 {
4587 /* We changed the symbol on an LD reloc. Start over
4588 in order to get h, sym, sec etc. right. */
4589 rel--;
4590 continue;
4591 }
4592 }
4593 }
4594 break;
4595 }
4596
4597 /* Handle other relocations that tweak non-addend part of insn. */
4598 branch_bit = 0;
4599 switch (r_type)
4600 {
4601 default:
4602 break;
4603
4604 /* Branch taken prediction relocations. */
4605 case R_PPC_ADDR14_BRTAKEN:
4606 case R_PPC_REL14_BRTAKEN:
4607 branch_bit = BRANCH_PREDICT_BIT;
4608 /* Fall thru */
4609
4610 /* Branch not taken predicition relocations. */
4611 case R_PPC_ADDR14_BRNTAKEN:
4612 case R_PPC_REL14_BRNTAKEN:
4613 insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
4614 insn &= ~BRANCH_PREDICT_BIT;
4615 insn |= branch_bit;
4616
4617 from = (rel->r_offset
4618 + input_section->output_offset
4619 + input_section->output_section->vma);
4620
4621 /* Invert 'y' bit if not the default. */
4622 if ((bfd_signed_vma) (relocation + rel->r_addend - from) < 0)
4623 insn ^= BRANCH_PREDICT_BIT;
4624
4625 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
4626 break;
4627 }
4628
4629 addend = rel->r_addend;
4630 tls_type = 0;
4631 howto = NULL;
4632 if ((unsigned) r_type < (unsigned) R_PPC_max)
4633 howto = ppc_elf_howto_table[(int) r_type];
4634 switch (r_type)
4635 {
4636 default:
4637 (*_bfd_error_handler)
4638 (_("%s: unknown relocation type %d for symbol %s"),
4639 bfd_archive_filename (input_bfd), (int) r_type, sym_name);
4640
4641 bfd_set_error (bfd_error_bad_value);
4642 ret = FALSE;
4643 continue;
4644
4645 case R_PPC_NONE:
4646 case R_PPC_TLS:
4647 case R_PPC_EMB_MRKREF:
4648 case R_PPC_GNU_VTINHERIT:
4649 case R_PPC_GNU_VTENTRY:
4650 continue;
4651
4652 /* GOT16 relocations. Like an ADDR16 using the symbol's
4653 address in the GOT as relocation value instead of the
4654 symbol's value itself. Also, create a GOT entry for the
4655 symbol and put the symbol value there. */
4656 case R_PPC_GOT_TLSGD16:
4657 case R_PPC_GOT_TLSGD16_LO:
4658 case R_PPC_GOT_TLSGD16_HI:
4659 case R_PPC_GOT_TLSGD16_HA:
4660 tls_type = TLS_TLS | TLS_GD;
4661 goto dogot;
4662
4663 case R_PPC_GOT_TLSLD16:
4664 case R_PPC_GOT_TLSLD16_LO:
4665 case R_PPC_GOT_TLSLD16_HI:
4666 case R_PPC_GOT_TLSLD16_HA:
4667 tls_type = TLS_TLS | TLS_LD;
4668 goto dogot;
4669
4670 case R_PPC_GOT_TPREL16:
4671 case R_PPC_GOT_TPREL16_LO:
4672 case R_PPC_GOT_TPREL16_HI:
4673 case R_PPC_GOT_TPREL16_HA:
4674 tls_type = TLS_TLS | TLS_TPREL;
4675 goto dogot;
4676
4677 case R_PPC_GOT_DTPREL16:
4678 case R_PPC_GOT_DTPREL16_LO:
4679 case R_PPC_GOT_DTPREL16_HI:
4680 case R_PPC_GOT_DTPREL16_HA:
4681 tls_type = TLS_TLS | TLS_DTPREL;
4682 goto dogot;
4683
4684 case R_PPC_GOT16:
4685 case R_PPC_GOT16_LO:
4686 case R_PPC_GOT16_HI:
4687 case R_PPC_GOT16_HA:
4688 dogot:
4689 {
4690 /* Relocation is to the entry for this symbol in the global
4691 offset table. */
4692 bfd_vma off;
4693 bfd_vma *offp;
4694 unsigned long indx;
4695
4696 if (htab->got == NULL)
4697 abort ();
4698
4699 indx = 0;
4700 if (tls_type == (TLS_TLS | TLS_LD)
4701 && (h == NULL
4702 || !(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC)))
4703 offp = &htab->tlsld_got.offset;
4704 else if (h != NULL)
4705 {
4706 bfd_boolean dyn;
4707 dyn = htab->elf.dynamic_sections_created;
4708 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
4709 || (info->shared
4710 && SYMBOL_REFERENCES_LOCAL (info, h)))
4711 /* This is actually a static link, or it is a
4712 -Bsymbolic link and the symbol is defined
4713 locally, or the symbol was forced to be local
4714 because of a version file. */
4715 ;
4716 else
4717 {
4718 indx = h->dynindx;
4719 unresolved_reloc = FALSE;
4720 }
4721 offp = &h->got.offset;
4722 }
4723 else
4724 {
4725 if (local_got_offsets == NULL)
4726 abort ();
4727 offp = &local_got_offsets[r_symndx];
4728 }
4729
4730 /* The offset must always be a multiple of 4. We use the
4731 least significant bit to record whether we have already
4732 processed this entry. */
4733 off = *offp;
4734 if ((off & 1) != 0)
4735 off &= ~1;
4736 else
4737 {
4738 unsigned int tls_m = (tls_mask
4739 & (TLS_LD | TLS_GD | TLS_DTPREL
4740 | TLS_TPREL | TLS_TPRELGD));
4741
4742 if (offp == &htab->tlsld_got.offset)
4743 tls_m = TLS_LD;
4744 else if (h == NULL
4745 || !(h->elf_link_hash_flags
4746 & ELF_LINK_HASH_DEF_DYNAMIC))
4747 tls_m &= ~TLS_LD;
4748
4749 /* We might have multiple got entries for this sym.
4750 Initialize them all. */
4751 do
4752 {
4753 int tls_ty = 0;
4754
4755 if ((tls_m & TLS_LD) != 0)
4756 {
4757 tls_ty = TLS_TLS | TLS_LD;
4758 tls_m &= ~TLS_LD;
4759 }
4760 else if ((tls_m & TLS_GD) != 0)
4761 {
4762 tls_ty = TLS_TLS | TLS_GD;
4763 tls_m &= ~TLS_GD;
4764 }
4765 else if ((tls_m & TLS_DTPREL) != 0)
4766 {
4767 tls_ty = TLS_TLS | TLS_DTPREL;
4768 tls_m &= ~TLS_DTPREL;
4769 }
4770 else if ((tls_m & (TLS_TPREL | TLS_TPRELGD)) != 0)
4771 {
4772 tls_ty = TLS_TLS | TLS_TPREL;
4773 tls_m = 0;
4774 }
4775
4776 /* Generate relocs for the dynamic linker. */
4777 if (info->shared || indx != 0)
4778 {
4779 outrel.r_offset = (htab->got->output_section->vma
4780 + htab->got->output_offset
4781 + off);
4782 if (tls_ty & (TLS_LD | TLS_GD))
4783 {
4784 outrel.r_info = ELF32_R_INFO (indx, R_PPC_DTPMOD32);
4785 outrel.r_addend = 0;
4786 if (tls_ty == (TLS_TLS | TLS_GD))
4787 {
4788 loc = htab->relgot->contents;
4789 loc += (htab->relgot->reloc_count++
4790 * sizeof (Elf32_External_Rela));
4791 bfd_elf32_swap_reloca_out (output_bfd,
4792 &outrel, loc);
4793 outrel.r_info
4794 = ELF32_R_INFO (indx, R_PPC_DTPREL32);
4795 outrel.r_offset += 4;
4796 }
4797 }
4798 else if (tls_ty == (TLS_TLS | TLS_DTPREL))
4799 outrel.r_info = ELF32_R_INFO (indx, R_PPC_DTPREL32);
4800 else if (tls_ty == (TLS_TLS | TLS_TPREL))
4801 outrel.r_info = ELF32_R_INFO (indx, R_PPC_TPREL32);
4802 else if (indx == 0)
4803 outrel.r_info = ELF32_R_INFO (indx, R_PPC_RELATIVE);
4804 else
4805 outrel.r_info = ELF32_R_INFO (indx, R_PPC_GLOB_DAT);
4806 outrel.r_addend = 0;
4807 if (indx == 0)
4808 outrel.r_addend += relocation;
4809 loc = htab->relgot->contents;
4810 loc += (htab->relgot->reloc_count++
4811 * sizeof (Elf32_External_Rela));
4812 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4813 }
4814
4815 /* Init the .got section contents if we're not
4816 emitting a reloc. */
4817 else
4818 {
4819 bfd_vma value = relocation;
4820
4821 if (tls_ty == (TLS_TLS | TLS_LD))
4822 value = 1;
4823 else if (tls_ty != 0)
4824 {
4825 value -= htab->tls_sec->vma + DTP_OFFSET;
4826 if (tls_ty == (TLS_TLS | TLS_TPREL))
4827 value += DTP_OFFSET - TP_OFFSET;
4828
4829 if (tls_ty == (TLS_TLS | TLS_GD))
4830 {
4831 bfd_put_32 (output_bfd, value,
4832 htab->got->contents + off + 4);
4833 value = 1;
4834 }
4835 }
4836 bfd_put_32 (output_bfd, value,
4837 htab->got->contents + off);
4838 }
4839
4840 off += 4;
4841 if (tls_ty & (TLS_LD | TLS_GD))
4842 off += 4;
4843 }
4844 while (tls_m != 0);
4845
4846 off = *offp;
4847 *offp = off | 1;
4848 }
4849
4850 if (off >= (bfd_vma) -2)
4851 abort ();
4852
4853 if ((tls_type & TLS_TLS) != 0)
4854 {
4855 if (tls_type != (TLS_TLS | TLS_LD))
4856 {
4857 if ((tls_mask & TLS_LD) != 0
4858 && !(h == NULL
4859 || !(h->elf_link_hash_flags
4860 & ELF_LINK_HASH_DEF_DYNAMIC)))
4861 off += 8;
4862 if (tls_type != (TLS_TLS | TLS_GD))
4863 {
4864 if ((tls_mask & TLS_GD) != 0)
4865 off += 8;
4866 if (tls_type != (TLS_TLS | TLS_DTPREL))
4867 {
4868 if ((tls_mask & TLS_DTPREL) != 0)
4869 off += 4;
4870 }
4871 }
4872 }
4873 }
4874
4875 relocation = htab->got->output_offset + off - 4;
4876
4877 /* Addends on got relocations don't make much sense.
4878 x+off@got is actually x@got+off, and since the got is
4879 generated by a hash table traversal, the value in the
4880 got at entry m+n bears little relation to the entry m. */
4881 if (addend != 0)
4882 (*_bfd_error_handler)
4883 (_("%s(%s+0x%lx): non-zero addend on %s reloc against `%s'"),
4884 bfd_archive_filename (input_bfd),
4885 bfd_get_section_name (input_bfd, input_section),
4886 (long) rel->r_offset,
4887 howto->name,
4888 sym_name);
4889 }
4890 break;
4891
4892 /* Relocations that need no special processing. */
4893 case R_PPC_LOCAL24PC:
4894 /* It makes no sense to point a local relocation
4895 at a symbol not in this object. */
4896 if (unresolved_reloc)
4897 {
4898 if (! (*info->callbacks->undefined_symbol) (info,
4899 h->root.root.string,
4900 input_bfd,
4901 input_section,
4902 rel->r_offset,
4903 TRUE))
4904 return FALSE;
4905 continue;
4906 }
4907 break;
4908
4909 case R_PPC_DTPREL16:
4910 case R_PPC_DTPREL16_LO:
4911 case R_PPC_DTPREL16_HI:
4912 case R_PPC_DTPREL16_HA:
4913 addend -= htab->tls_sec->vma + DTP_OFFSET;
4914 break;
4915
4916 /* Relocations that may need to be propagated if this is a shared
4917 object. */
4918 case R_PPC_TPREL16:
4919 case R_PPC_TPREL16_LO:
4920 case R_PPC_TPREL16_HI:
4921 case R_PPC_TPREL16_HA:
4922 addend -= htab->tls_sec->vma + TP_OFFSET;
4923 /* The TPREL16 relocs shouldn't really be used in shared
4924 libs as they will result in DT_TEXTREL being set, but
4925 support them anyway. */
4926 goto dodyn;
4927
4928 case R_PPC_TPREL32:
4929 addend -= htab->tls_sec->vma + TP_OFFSET;
4930 goto dodyn;
4931
4932 case R_PPC_DTPREL32:
4933 addend -= htab->tls_sec->vma + DTP_OFFSET;
4934 goto dodyn;
4935
4936 case R_PPC_REL24:
4937 case R_PPC_REL32:
4938 case R_PPC_REL14:
4939 case R_PPC_REL14_BRTAKEN:
4940 case R_PPC_REL14_BRNTAKEN:
4941 /* If these relocations are not to a named symbol, they can be
4942 handled right here, no need to bother the dynamic linker. */
4943 if (h == NULL
4944 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
4945 || SYMBOL_REFERENCES_LOCAL (info, h))
4946 break;
4947 /* fall through */
4948
4949 /* Relocations that always need to be propagated if this is a shared
4950 object. */
4951 case R_PPC_ADDR32:
4952 case R_PPC_ADDR24:
4953 case R_PPC_ADDR16:
4954 case R_PPC_ADDR16_LO:
4955 case R_PPC_ADDR16_HI:
4956 case R_PPC_ADDR16_HA:
4957 case R_PPC_ADDR14:
4958 case R_PPC_ADDR14_BRTAKEN:
4959 case R_PPC_ADDR14_BRNTAKEN:
4960 case R_PPC_UADDR32:
4961 case R_PPC_UADDR16:
4962 case R_PPC_DTPMOD32:
4963 /* r_symndx will be zero only for relocs against symbols
4964 from removed linkonce sections, or sections discarded by
4965 a linker script. */
4966 dodyn:
4967 if (r_symndx == 0)
4968 break;
4969 /* Fall thru. */
4970
4971 if ((info->shared
4972 && (MUST_BE_DYN_RELOC (r_type)
4973 || (h != NULL
4974 && h->dynindx != -1
4975 && (!info->symbolic
4976 || (h->elf_link_hash_flags
4977 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
4978 || (ELIMINATE_COPY_RELOCS
4979 && !info->shared
4980 && (input_section->flags & SEC_ALLOC) != 0
4981 && h != NULL
4982 && h->dynindx != -1
4983 && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
4984 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
4985 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0))
4986 {
4987 int skip;
4988
4989 #ifdef DEBUG
4990 fprintf (stderr, "ppc_elf_relocate_section need to create relocation for %s\n",
4991 (h && h->root.root.string
4992 ? h->root.root.string : "<unknown>"));
4993 #endif
4994
4995 /* When generating a shared object, these relocations
4996 are copied into the output file to be resolved at run
4997 time. */
4998 if (sreloc == NULL)
4999 {
5000 const char *name;
5001
5002 name = (bfd_elf_string_from_elf_section
5003 (input_bfd,
5004 elf_elfheader (input_bfd)->e_shstrndx,
5005 elf_section_data (input_section)->rel_hdr.sh_name));
5006 if (name == NULL)
5007 return FALSE;
5008
5009 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
5010 && strcmp (bfd_get_section_name (input_bfd,
5011 input_section),
5012 name + 5) == 0);
5013
5014 sreloc = bfd_get_section_by_name (htab->elf.dynobj, name);
5015 BFD_ASSERT (sreloc != NULL);
5016 }
5017
5018 skip = 0;
5019
5020 outrel.r_offset =
5021 _bfd_elf_section_offset (output_bfd, info, input_section,
5022 rel->r_offset);
5023 if (outrel.r_offset == (bfd_vma) -1
5024 || outrel.r_offset == (bfd_vma) -2)
5025 skip = (int) outrel.r_offset;
5026 outrel.r_offset += (input_section->output_section->vma
5027 + input_section->output_offset);
5028
5029 if (skip)
5030 memset (&outrel, 0, sizeof outrel);
5031 else if (h != NULL
5032 && !SYMBOL_REFERENCES_LOCAL (info, h))
5033 {
5034 unresolved_reloc = FALSE;
5035 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
5036 outrel.r_addend = rel->r_addend;
5037 }
5038 else
5039 {
5040 outrel.r_addend = relocation + rel->r_addend;
5041
5042 if (r_type == R_PPC_ADDR32)
5043 outrel.r_info = ELF32_R_INFO (0, R_PPC_RELATIVE);
5044 else
5045 {
5046 long indx;
5047
5048 if (bfd_is_abs_section (sec))
5049 indx = 0;
5050 else if (sec == NULL || sec->owner == NULL)
5051 {
5052 bfd_set_error (bfd_error_bad_value);
5053 return FALSE;
5054 }
5055 else
5056 {
5057 asection *osec;
5058
5059 /* We are turning this relocation into one
5060 against a section symbol. It would be
5061 proper to subtract the symbol's value,
5062 osec->vma, from the emitted reloc addend,
5063 but ld.so expects buggy relocs. */
5064 osec = sec->output_section;
5065 indx = elf_section_data (osec)->dynindx;
5066 BFD_ASSERT (indx > 0);
5067 #ifdef DEBUG
5068 if (indx <= 0)
5069 {
5070 printf ("indx=%d section=%s flags=%08x name=%s\n",
5071 indx, osec->name, osec->flags,
5072 h->root.root.string);
5073 }
5074 #endif
5075 }
5076
5077 outrel.r_info = ELF32_R_INFO (indx, r_type);
5078 }
5079 }
5080
5081 loc = sreloc->contents;
5082 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
5083 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5084
5085 if (skip == -1)
5086 continue;
5087
5088 /* This reloc will be computed at runtime. We clear the memory
5089 so that it contains predictable value. */
5090 if (! skip
5091 && ((input_section->flags & SEC_ALLOC) != 0
5092 || ELF32_R_TYPE (outrel.r_info) != R_PPC_RELATIVE))
5093 {
5094 relocation = howto->pc_relative ? outrel.r_offset : 0;
5095 addend = 0;
5096 break;
5097 }
5098 }
5099 break;
5100
5101 /* Indirect .sdata relocation. */
5102 case R_PPC_EMB_SDAI16:
5103 BFD_ASSERT (htab->sdata != NULL);
5104 relocation
5105 = bfd_elf32_finish_pointer_linker_section (output_bfd, input_bfd,
5106 info, htab->sdata, h,
5107 relocation, rel,
5108 R_PPC_RELATIVE);
5109 break;
5110
5111 /* Indirect .sdata2 relocation. */
5112 case R_PPC_EMB_SDA2I16:
5113 BFD_ASSERT (htab->sdata2 != NULL);
5114 relocation
5115 = bfd_elf32_finish_pointer_linker_section (output_bfd, input_bfd,
5116 info, htab->sdata2, h,
5117 relocation, rel,
5118 R_PPC_RELATIVE);
5119 break;
5120
5121 /* Handle the TOC16 reloc. We want to use the offset within the .got
5122 section, not the actual VMA. This is appropriate when generating
5123 an embedded ELF object, for which the .got section acts like the
5124 AIX .toc section. */
5125 case R_PPC_TOC16: /* phony GOT16 relocations */
5126 BFD_ASSERT (sec != (asection *) 0);
5127 BFD_ASSERT (bfd_is_und_section (sec)
5128 || strcmp (bfd_get_section_name (abfd, sec), ".got") == 0
5129 || strcmp (bfd_get_section_name (abfd, sec), ".cgot") == 0)
5130
5131 addend -= sec->output_section->vma + sec->output_offset + 0x8000;
5132 break;
5133
5134 case R_PPC_PLTREL24:
5135 /* Relocation is to the entry for this symbol in the
5136 procedure linkage table. */
5137 BFD_ASSERT (h != NULL);
5138
5139 if (h->plt.offset == (bfd_vma) -1
5140 || htab->plt == NULL)
5141 {
5142 /* We didn't make a PLT entry for this symbol. This
5143 happens when statically linking PIC code, or when
5144 using -Bsymbolic. */
5145 break;
5146 }
5147
5148 unresolved_reloc = FALSE;
5149 relocation = (htab->plt->output_section->vma
5150 + htab->plt->output_offset
5151 + h->plt.offset);
5152 break;
5153
5154 /* Relocate against _SDA_BASE_. */
5155 case R_PPC_SDAREL16:
5156 {
5157 const char *name;
5158 const struct elf_link_hash_entry *sh;
5159
5160 BFD_ASSERT (sec != (asection *) 0);
5161 name = bfd_get_section_name (abfd, sec->output_section);
5162 if (! ((strncmp (name, ".sdata", 6) == 0
5163 && (name[6] == 0 || name[6] == '.'))
5164 || (strncmp (name, ".sbss", 5) == 0
5165 && (name[5] == 0 || name[5] == '.'))))
5166 {
5167 (*_bfd_error_handler) (_("%s: the target (%s) of a %s relocation is in the wrong output section (%s)"),
5168 bfd_archive_filename (input_bfd),
5169 sym_name,
5170 howto->name,
5171 name);
5172 }
5173 sh = htab->sdata->sym_hash;
5174 addend -= (sh->root.u.def.value
5175 + sh->root.u.def.section->output_section->vma
5176 + sh->root.u.def.section->output_offset);
5177 }
5178 break;
5179
5180 /* Relocate against _SDA2_BASE_. */
5181 case R_PPC_EMB_SDA2REL:
5182 {
5183 const char *name;
5184 const struct elf_link_hash_entry *sh;
5185
5186 BFD_ASSERT (sec != (asection *) 0);
5187 name = bfd_get_section_name (abfd, sec->output_section);
5188 if (! (strncmp (name, ".sdata2", 7) == 0
5189 || strncmp (name, ".sbss2", 6) == 0))
5190 {
5191 (*_bfd_error_handler) (_("%s: the target (%s) of a %s relocation is in the wrong output section (%s)"),
5192 bfd_archive_filename (input_bfd),
5193 sym_name,
5194 howto->name,
5195 name);
5196
5197 bfd_set_error (bfd_error_bad_value);
5198 ret = FALSE;
5199 continue;
5200 }
5201 sh = htab->sdata2->sym_hash;
5202 addend -= (sh->root.u.def.value
5203 + sh->root.u.def.section->output_section->vma
5204 + sh->root.u.def.section->output_offset);
5205 }
5206 break;
5207
5208 /* Relocate against either _SDA_BASE_, _SDA2_BASE_, or 0. */
5209 case R_PPC_EMB_SDA21:
5210 case R_PPC_EMB_RELSDA:
5211 {
5212 const char *name;
5213 const struct elf_link_hash_entry *sh;
5214 int reg;
5215
5216 BFD_ASSERT (sec != (asection *) 0);
5217 name = bfd_get_section_name (abfd, sec->output_section);
5218 if (((strncmp (name, ".sdata", 6) == 0
5219 && (name[6] == 0 || name[6] == '.'))
5220 || (strncmp (name, ".sbss", 5) == 0
5221 && (name[5] == 0 || name[5] == '.'))))
5222 {
5223 reg = 13;
5224 sh = htab->sdata->sym_hash;
5225 addend -= (sh->root.u.def.value
5226 + sh->root.u.def.section->output_section->vma
5227 + sh->root.u.def.section->output_offset);
5228 }
5229
5230 else if (strncmp (name, ".sdata2", 7) == 0
5231 || strncmp (name, ".sbss2", 6) == 0)
5232 {
5233 reg = 2;
5234 sh = htab->sdata2->sym_hash;
5235 addend -= (sh->root.u.def.value
5236 + sh->root.u.def.section->output_section->vma
5237 + sh->root.u.def.section->output_offset);
5238 }
5239
5240 else if (strcmp (name, ".PPC.EMB.sdata0") == 0
5241 || strcmp (name, ".PPC.EMB.sbss0") == 0)
5242 {
5243 reg = 0;
5244 }
5245
5246 else
5247 {
5248 (*_bfd_error_handler) (_("%s: the target (%s) of a %s relocation is in the wrong output section (%s)"),
5249 bfd_archive_filename (input_bfd),
5250 sym_name,
5251 howto->name,
5252 name);
5253
5254 bfd_set_error (bfd_error_bad_value);
5255 ret = FALSE;
5256 continue;
5257 }
5258
5259 if (r_type == R_PPC_EMB_SDA21)
5260 { /* fill in register field */
5261 insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
5262 insn = (insn & ~RA_REGISTER_MASK) | (reg << RA_REGISTER_SHIFT);
5263 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
5264 }
5265 }
5266 break;
5267
5268 /* Relocate against the beginning of the section. */
5269 case R_PPC_SECTOFF:
5270 case R_PPC_SECTOFF_LO:
5271 case R_PPC_SECTOFF_HI:
5272 case R_PPC_SECTOFF_HA:
5273 BFD_ASSERT (sec != (asection *) 0);
5274 addend -= sec->output_section->vma;
5275 break;
5276
5277 /* Negative relocations. */
5278 case R_PPC_EMB_NADDR32:
5279 case R_PPC_EMB_NADDR16:
5280 case R_PPC_EMB_NADDR16_LO:
5281 case R_PPC_EMB_NADDR16_HI:
5282 case R_PPC_EMB_NADDR16_HA:
5283 addend -= 2 * relocation;
5284 break;
5285
5286 case R_PPC_COPY:
5287 case R_PPC_GLOB_DAT:
5288 case R_PPC_JMP_SLOT:
5289 case R_PPC_RELATIVE:
5290 case R_PPC_PLT32:
5291 case R_PPC_PLTREL32:
5292 case R_PPC_PLT16_LO:
5293 case R_PPC_PLT16_HI:
5294 case R_PPC_PLT16_HA:
5295 case R_PPC_ADDR30:
5296 case R_PPC_EMB_RELSEC16:
5297 case R_PPC_EMB_RELST_LO:
5298 case R_PPC_EMB_RELST_HI:
5299 case R_PPC_EMB_RELST_HA:
5300 case R_PPC_EMB_BIT_FLD:
5301 (*_bfd_error_handler)
5302 (_("%s: relocation %s is not yet supported for symbol %s."),
5303 bfd_archive_filename (input_bfd),
5304 howto->name,
5305 sym_name);
5306
5307 bfd_set_error (bfd_error_invalid_operation);
5308 ret = FALSE;
5309 continue;
5310 }
5311
5312 /* Do any further special processing. */
5313 switch (r_type)
5314 {
5315 default:
5316 break;
5317
5318 case R_PPC_ADDR16_HA:
5319 case R_PPC_GOT16_HA:
5320 case R_PPC_PLT16_HA:
5321 case R_PPC_SECTOFF_HA:
5322 case R_PPC_TPREL16_HA:
5323 case R_PPC_DTPREL16_HA:
5324 case R_PPC_GOT_TLSGD16_HA:
5325 case R_PPC_GOT_TLSLD16_HA:
5326 case R_PPC_GOT_TPREL16_HA:
5327 case R_PPC_GOT_DTPREL16_HA:
5328 case R_PPC_EMB_NADDR16_HA:
5329 case R_PPC_EMB_RELST_HA:
5330 /* It's just possible that this symbol is a weak symbol
5331 that's not actually defined anywhere. In that case,
5332 'sec' would be NULL, and we should leave the symbol
5333 alone (it will be set to zero elsewhere in the link). */
5334 if (sec != NULL)
5335 /* Add 0x10000 if sign bit in 0:15 is set. */
5336 addend += ((relocation + addend) & 0x8000) << 1;
5337 break;
5338 }
5339
5340 #ifdef DEBUG
5341 fprintf (stderr, "\ttype = %s (%d), name = %s, symbol index = %ld, offset = %ld, addend = %ld\n",
5342 howto->name,
5343 (int) r_type,
5344 sym_name,
5345 r_symndx,
5346 (long) rel->r_offset,
5347 (long) addend);
5348 #endif
5349
5350 if (unresolved_reloc
5351 && !((input_section->flags & SEC_DEBUGGING) != 0
5352 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
5353 {
5354 (*_bfd_error_handler)
5355 (_("%s(%s+0x%lx): unresolvable %s relocation against symbol `%s'"),
5356 bfd_archive_filename (input_bfd),
5357 bfd_get_section_name (input_bfd, input_section),
5358 (long) rel->r_offset,
5359 howto->name,
5360 sym_name);
5361 ret = FALSE;
5362 }
5363
5364 r = _bfd_final_link_relocate (howto,
5365 input_bfd,
5366 input_section,
5367 contents,
5368 rel->r_offset,
5369 relocation,
5370 addend);
5371
5372 if (r != bfd_reloc_ok)
5373 {
5374 if (sym_name == NULL)
5375 sym_name = "(null)";
5376 if (r == bfd_reloc_overflow)
5377 {
5378 if (warned)
5379 continue;
5380 if (h != NULL
5381 && h->root.type == bfd_link_hash_undefweak
5382 && howto->pc_relative)
5383 {
5384 /* Assume this is a call protected by other code that
5385 detect the symbol is undefined. If this is the case,
5386 we can safely ignore the overflow. If not, the
5387 program is hosed anyway, and a little warning isn't
5388 going to help. */
5389
5390 continue;
5391 }
5392
5393 if (! (*info->callbacks->reloc_overflow) (info,
5394 sym_name,
5395 howto->name,
5396 rel->r_addend,
5397 input_bfd,
5398 input_section,
5399 rel->r_offset))
5400 return FALSE;
5401 }
5402 else
5403 {
5404 (*_bfd_error_handler)
5405 (_("%s(%s+0x%lx): %s reloc against `%s': error %d"),
5406 bfd_archive_filename (input_bfd),
5407 bfd_get_section_name (input_bfd, input_section),
5408 (long) rel->r_offset, howto->name, sym_name, (int) r);
5409 ret = FALSE;
5410 }
5411 }
5412 }
5413
5414 #ifdef DEBUG
5415 fprintf (stderr, "\n");
5416 #endif
5417
5418 return ret;
5419 }
5420
5421 static enum elf_reloc_type_class
5422 ppc_elf_reloc_type_class (rela)
5423 const Elf_Internal_Rela *rela;
5424 {
5425 switch ((int) ELF32_R_TYPE (rela->r_info))
5426 {
5427 case R_PPC_RELATIVE:
5428 return reloc_class_relative;
5429 case R_PPC_REL24:
5430 case R_PPC_ADDR24:
5431 case R_PPC_JMP_SLOT:
5432 return reloc_class_plt;
5433 case R_PPC_COPY:
5434 return reloc_class_copy;
5435 default:
5436 return reloc_class_normal;
5437 }
5438 }
5439 \f
5440 /* Support for core dump NOTE sections. */
5441
5442 static bfd_boolean
5443 ppc_elf_grok_prstatus (abfd, note)
5444 bfd *abfd;
5445 Elf_Internal_Note *note;
5446 {
5447 int offset;
5448 unsigned int raw_size;
5449
5450 switch (note->descsz)
5451 {
5452 default:
5453 return FALSE;
5454
5455 case 268: /* Linux/PPC. */
5456 /* pr_cursig */
5457 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
5458
5459 /* pr_pid */
5460 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
5461
5462 /* pr_reg */
5463 offset = 72;
5464 raw_size = 192;
5465
5466 break;
5467 }
5468
5469 /* Make a ".reg/999" section. */
5470 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
5471 raw_size, note->descpos + offset);
5472 }
5473
5474 static bfd_boolean
5475 ppc_elf_grok_psinfo (abfd, note)
5476 bfd *abfd;
5477 Elf_Internal_Note *note;
5478 {
5479 switch (note->descsz)
5480 {
5481 default:
5482 return FALSE;
5483
5484 case 128: /* Linux/PPC elf_prpsinfo. */
5485 elf_tdata (abfd)->core_program
5486 = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16);
5487 elf_tdata (abfd)->core_command
5488 = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80);
5489 }
5490
5491 /* Note that for some reason, a spurious space is tacked
5492 onto the end of the args in some (at least one anyway)
5493 implementations, so strip it off if it exists. */
5494
5495 {
5496 char *command = elf_tdata (abfd)->core_command;
5497 int n = strlen (command);
5498
5499 if (0 < n && command[n - 1] == ' ')
5500 command[n - 1] = '\0';
5501 }
5502
5503 return TRUE;
5504 }
5505 \f
5506 /* Very simple linked list structure for recording apuinfo values. */
5507 typedef struct apuinfo_list
5508 {
5509 struct apuinfo_list *next;
5510 unsigned long value;
5511 }
5512 apuinfo_list;
5513
5514 static apuinfo_list * head;
5515
5516 static void apuinfo_list_init PARAMS ((void));
5517 static void apuinfo_list_add PARAMS ((unsigned long));
5518 static unsigned apuinfo_list_length PARAMS ((void));
5519 static unsigned long apuinfo_list_element PARAMS ((unsigned long));
5520 static void apuinfo_list_finish PARAMS ((void));
5521
5522 extern void ppc_elf_begin_write_processing
5523 PARAMS ((bfd *, struct bfd_link_info *));
5524 extern void ppc_elf_final_write_processing
5525 PARAMS ((bfd *, bfd_boolean));
5526 extern bfd_boolean ppc_elf_write_section
5527 PARAMS ((bfd *, asection *, bfd_byte *));
5528
5529
5530 static void
5531 apuinfo_list_init PARAMS ((void))
5532 {
5533 head = NULL;
5534 }
5535
5536 static void
5537 apuinfo_list_add (value)
5538 unsigned long value;
5539 {
5540 apuinfo_list *entry = head;
5541
5542 while (entry != NULL)
5543 {
5544 if (entry->value == value)
5545 return;
5546 entry = entry->next;
5547 }
5548
5549 entry = bfd_malloc (sizeof (* entry));
5550 if (entry == NULL)
5551 return;
5552
5553 entry->value = value;
5554 entry->next = head;
5555 head = entry;
5556 }
5557
5558 static unsigned
5559 apuinfo_list_length PARAMS ((void))
5560 {
5561 apuinfo_list *entry;
5562 unsigned long count;
5563
5564 for (entry = head, count = 0;
5565 entry;
5566 entry = entry->next)
5567 ++ count;
5568
5569 return count;
5570 }
5571
5572 static inline unsigned long
5573 apuinfo_list_element (number)
5574 unsigned long number;
5575 {
5576 apuinfo_list * entry;
5577
5578 for (entry = head;
5579 entry && number --;
5580 entry = entry->next)
5581 ;
5582
5583 return entry ? entry->value : 0;
5584 }
5585
5586 static void
5587 apuinfo_list_finish PARAMS ((void))
5588 {
5589 apuinfo_list *entry;
5590
5591 for (entry = head; entry;)
5592 {
5593 apuinfo_list *next = entry->next;
5594 free (entry);
5595 entry = next;
5596 }
5597
5598 head = NULL;
5599 }
5600
5601 #define APUINFO_SECTION_NAME ".PPC.EMB.apuinfo"
5602 #define APUINFO_LABEL "APUinfo"
5603
5604 /* Scan the input BFDs and create a linked list of
5605 the APUinfo values that will need to be emitted. */
5606
5607 void
5608 ppc_elf_begin_write_processing (abfd, link_info)
5609 bfd *abfd;
5610 struct bfd_link_info *link_info;
5611 {
5612 bfd *ibfd;
5613 asection *asec;
5614 char *buffer;
5615 unsigned num_input_sections;
5616 bfd_size_type output_section_size;
5617 unsigned i;
5618 unsigned num_entries;
5619 unsigned long offset;
5620 unsigned long length;
5621 const char *error_message = NULL;
5622
5623 if (link_info == NULL)
5624 return;
5625
5626 /* Scan the input bfds, looking for apuinfo sections. */
5627 num_input_sections = 0;
5628 output_section_size = 0;
5629
5630 for (ibfd = link_info->input_bfds; ibfd; ibfd = ibfd->link_next)
5631 {
5632 asec = bfd_get_section_by_name (ibfd, APUINFO_SECTION_NAME);
5633 if (asec)
5634 {
5635 ++ num_input_sections;
5636 output_section_size += asec->_raw_size;
5637 }
5638 }
5639
5640 /* We need at least one input sections
5641 in order to make merging worthwhile. */
5642 if (num_input_sections < 1)
5643 return;
5644
5645 /* Just make sure that the output section exists as well. */
5646 asec = bfd_get_section_by_name (abfd, APUINFO_SECTION_NAME);
5647 if (asec == NULL)
5648 return;
5649
5650 /* Allocate a buffer for the contents of the input sections. */
5651 buffer = bfd_malloc (output_section_size);
5652 if (buffer == NULL)
5653 return;
5654
5655 offset = 0;
5656 apuinfo_list_init ();
5657
5658 /* Read in the input sections contents. */
5659 for (ibfd = link_info->input_bfds; ibfd; ibfd = ibfd->link_next)
5660 {
5661 unsigned long datum;
5662 char *ptr;
5663
5664 asec = bfd_get_section_by_name (ibfd, APUINFO_SECTION_NAME);
5665 if (asec == NULL)
5666 continue;
5667
5668 length = asec->_raw_size;
5669 if (length < 24)
5670 {
5671 error_message = _("corrupt or empty %s section in %s");
5672 goto fail;
5673 }
5674
5675 if (bfd_seek (ibfd, asec->filepos, SEEK_SET) != 0
5676 || (bfd_bread (buffer + offset, length, ibfd) != length))
5677 {
5678 error_message = _("unable to read in %s section from %s");
5679 goto fail;
5680 }
5681
5682 /* Process the contents of the section. */
5683 ptr = buffer + offset;
5684 error_message = _("corrupt %s section in %s");
5685
5686 /* Verify the contents of the header. Note - we have to
5687 extract the values this way in order to allow for a
5688 host whose endian-ness is different from the target. */
5689 datum = bfd_get_32 (ibfd, ptr);
5690 if (datum != sizeof APUINFO_LABEL)
5691 goto fail;
5692
5693 datum = bfd_get_32 (ibfd, ptr + 8);
5694 if (datum != 0x2)
5695 goto fail;
5696
5697 if (strcmp (ptr + 12, APUINFO_LABEL) != 0)
5698 goto fail;
5699
5700 /* Get the number of apuinfo entries. */
5701 datum = bfd_get_32 (ibfd, ptr + 4);
5702 if ((datum * 4 + 20) != length)
5703 goto fail;
5704
5705 /* Make sure that we do not run off the end of the section. */
5706 if (offset + length > output_section_size)
5707 goto fail;
5708
5709 /* Scan the apuinfo section, building a list of apuinfo numbers. */
5710 for (i = 0; i < datum; i++)
5711 apuinfo_list_add (bfd_get_32 (ibfd, ptr + 20 + (i * 4)));
5712
5713 /* Update the offset. */
5714 offset += length;
5715 }
5716
5717 error_message = NULL;
5718
5719 /* Compute the size of the output section. */
5720 num_entries = apuinfo_list_length ();
5721 output_section_size = 20 + num_entries * 4;
5722
5723 asec = bfd_get_section_by_name (abfd, APUINFO_SECTION_NAME);
5724
5725 if (! bfd_set_section_size (abfd, asec, output_section_size))
5726 ibfd = abfd,
5727 error_message = _("warning: unable to set size of %s section in %s");
5728
5729 fail:
5730 free (buffer);
5731
5732 if (error_message)
5733 (*_bfd_error_handler) (error_message, APUINFO_SECTION_NAME,
5734 bfd_archive_filename (ibfd));
5735 }
5736
5737
5738 /* Prevent the output section from accumulating the input sections'
5739 contents. We have already stored this in our linked list structure. */
5740
5741 bfd_boolean
5742 ppc_elf_write_section (abfd, asec, contents)
5743 bfd *abfd ATTRIBUTE_UNUSED;
5744 asection *asec;
5745 bfd_byte *contents ATTRIBUTE_UNUSED;
5746 {
5747 return (apuinfo_list_length ()
5748 && strcmp (asec->name, APUINFO_SECTION_NAME) == 0);
5749 }
5750
5751
5752 /* Finally we can generate the output section. */
5753
5754 void
5755 ppc_elf_final_write_processing (abfd, linker)
5756 bfd *abfd;
5757 bfd_boolean linker ATTRIBUTE_UNUSED;
5758 {
5759 bfd_byte *buffer;
5760 asection *asec;
5761 unsigned i;
5762 unsigned num_entries;
5763 bfd_size_type length;
5764
5765 asec = bfd_get_section_by_name (abfd, APUINFO_SECTION_NAME);
5766 if (asec == NULL)
5767 return;
5768
5769 if (apuinfo_list_length () == 0)
5770 return;
5771
5772 length = asec->_raw_size;
5773 if (length < 20)
5774 return;
5775
5776 buffer = bfd_malloc (length);
5777 if (buffer == NULL)
5778 {
5779 (*_bfd_error_handler)
5780 (_("failed to allocate space for new APUinfo section."));
5781 return;
5782 }
5783
5784 /* Create the apuinfo header. */
5785 num_entries = apuinfo_list_length ();
5786 bfd_put_32 (abfd, sizeof APUINFO_LABEL, buffer);
5787 bfd_put_32 (abfd, num_entries, buffer + 4);
5788 bfd_put_32 (abfd, 0x2, buffer + 8);
5789 strcpy (buffer + 12, APUINFO_LABEL);
5790
5791 length = 20;
5792 for (i = 0; i < num_entries; i++)
5793 {
5794 bfd_put_32 (abfd, apuinfo_list_element (i), buffer + length);
5795 length += 4;
5796 }
5797
5798 if (length != asec->_raw_size)
5799 (*_bfd_error_handler) (_("failed to compute new APUinfo section."));
5800
5801 if (! bfd_set_section_contents (abfd, asec, buffer, (file_ptr) 0, length))
5802 (*_bfd_error_handler) (_("failed to install new APUinfo section."));
5803
5804 free (buffer);
5805
5806 apuinfo_list_finish ();
5807 }
5808 \f
5809 #define TARGET_LITTLE_SYM bfd_elf32_powerpcle_vec
5810 #define TARGET_LITTLE_NAME "elf32-powerpcle"
5811 #define TARGET_BIG_SYM bfd_elf32_powerpc_vec
5812 #define TARGET_BIG_NAME "elf32-powerpc"
5813 #define ELF_ARCH bfd_arch_powerpc
5814 #define ELF_MACHINE_CODE EM_PPC
5815 #define ELF_MAXPAGESIZE 0x10000
5816 #define elf_info_to_howto ppc_elf_info_to_howto
5817
5818 #ifdef EM_CYGNUS_POWERPC
5819 #define ELF_MACHINE_ALT1 EM_CYGNUS_POWERPC
5820 #endif
5821
5822 #ifdef EM_PPC_OLD
5823 #define ELF_MACHINE_ALT2 EM_PPC_OLD
5824 #endif
5825
5826 #define elf_backend_plt_not_loaded 1
5827 #define elf_backend_got_symbol_offset 4
5828 #define elf_backend_can_gc_sections 1
5829 #define elf_backend_can_refcount 1
5830 #define elf_backend_got_header_size 12
5831 #define elf_backend_plt_header_size PLT_INITIAL_ENTRY_SIZE
5832 #define elf_backend_rela_normal 1
5833
5834 #define bfd_elf32_bfd_merge_private_bfd_data ppc_elf_merge_private_bfd_data
5835 #define bfd_elf32_bfd_relax_section ppc_elf_relax_section
5836 #define bfd_elf32_bfd_reloc_type_lookup ppc_elf_reloc_type_lookup
5837 #define bfd_elf32_bfd_set_private_flags ppc_elf_set_private_flags
5838 #define bfd_elf32_bfd_link_hash_table_create ppc_elf_link_hash_table_create
5839
5840 #define elf_backend_object_p ppc_elf_object_p
5841 #define elf_backend_gc_mark_hook ppc_elf_gc_mark_hook
5842 #define elf_backend_gc_sweep_hook ppc_elf_gc_sweep_hook
5843 #define elf_backend_section_from_shdr ppc_elf_section_from_shdr
5844 #define elf_backend_relocate_section ppc_elf_relocate_section
5845 #define elf_backend_create_dynamic_sections ppc_elf_create_dynamic_sections
5846 #define elf_backend_check_relocs ppc_elf_check_relocs
5847 #define elf_backend_copy_indirect_symbol ppc_elf_copy_indirect_symbol
5848 #define elf_backend_adjust_dynamic_symbol ppc_elf_adjust_dynamic_symbol
5849 #define elf_backend_add_symbol_hook ppc_elf_add_symbol_hook
5850 #define elf_backend_size_dynamic_sections ppc_elf_size_dynamic_sections
5851 #define elf_backend_finish_dynamic_symbol ppc_elf_finish_dynamic_symbol
5852 #define elf_backend_finish_dynamic_sections ppc_elf_finish_dynamic_sections
5853 #define elf_backend_fake_sections ppc_elf_fake_sections
5854 #define elf_backend_additional_program_headers ppc_elf_additional_program_headers
5855 #define elf_backend_modify_segment_map ppc_elf_modify_segment_map
5856 #define elf_backend_grok_prstatus ppc_elf_grok_prstatus
5857 #define elf_backend_grok_psinfo ppc_elf_grok_psinfo
5858 #define elf_backend_reloc_type_class ppc_elf_reloc_type_class
5859 #define elf_backend_begin_write_processing ppc_elf_begin_write_processing
5860 #define elf_backend_final_write_processing ppc_elf_final_write_processing
5861 #define elf_backend_write_section ppc_elf_write_section
5862
5863 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.1455 seconds and 5 git commands to generate.