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