diff options
| author | Dimitry Andric <dim@FreeBSD.org> | 2010-10-21 19:11:14 +0000 |
|---|---|---|
| committer | Dimitry Andric <dim@FreeBSD.org> | 2010-10-21 19:11:14 +0000 |
| commit | dfd2f2d4bbb5f23cd14bca63b73779ffbac5c0f5 (patch) | |
| tree | 506464413c40d2c6a4a46d04892a9415cb886522 /contrib/binutils/bfd/elf32-ppc.c | |
| parent | ae36f9474fd730d29afb8b25c92dba33dedf7480 (diff) | |
| parent | 7a815afd9b5121ee0f65dc1e1de1c0de6de97679 (diff) | |
Notes
Diffstat (limited to 'contrib/binutils/bfd/elf32-ppc.c')
| -rw-r--r-- | contrib/binutils/bfd/elf32-ppc.c | 5940 |
1 files changed, 3662 insertions, 2278 deletions
diff --git a/contrib/binutils/bfd/elf32-ppc.c b/contrib/binutils/bfd/elf32-ppc.c index 4eb08ad3e6738..53d1046bb8cbf 100644 --- a/contrib/binutils/bfd/elf32-ppc.c +++ b/contrib/binutils/bfd/elf32-ppc.c @@ -1,6 +1,6 @@ /* PowerPC-specific support for 32-bit ELF Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, - 2004 Free Software Foundation, Inc. + 2004, 2005, 2006 Free Software Foundation, Inc. Written by Ian Lance Taylor, Cygnus Support. This file is part of BFD, the Binary File Descriptor library. @@ -17,8 +17,8 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the - Free Software Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ + Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor, + Boston, MA 02110-1301, USA. */ /* This file is based on a preliminary PowerPC ELF ABI. The information may not match the final PowerPC ELF ABI. It includes @@ -32,6 +32,7 @@ #include "elf-bfd.h" #include "elf/ppc.h" #include "elf32-ppc.h" +#include "elf-vxworks.h" /* RELA relocations are used here. */ @@ -51,296 +52,109 @@ static bfd_reloc_status_type ppc_elf_unhandled_reloc section. */ #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1" -/* The size in bytes of an entry in the procedure linkage table. */ -#define PLT_ENTRY_SIZE 12 -/* The initial size of the plt reserved for the dynamic linker. */ -#define PLT_INITIAL_ENTRY_SIZE 72 -/* The size of the gap between entries in the PLT. */ -#define PLT_SLOT_SIZE 8 +/* For old-style PLT. */ /* The number of single-slot PLT entries (the rest use two slots). */ #define PLT_NUM_SINGLE_ENTRIES 8192 -/* Some nop instructions. */ -#define NOP 0x60000000 -#define CROR_151515 0x4def7b82 -#define CROR_313131 0x4ffffb82 - -/* Offset of tp and dtp pointers from start of TLS block. */ -#define TP_OFFSET 0x7000 -#define DTP_OFFSET 0x8000 - - -/* Enumeration to specify the special section. */ -enum elf_linker_section_enum -{ - LINKER_SECTION_SDATA, - LINKER_SECTION_SDATA2 -}; - -/* Sections created by the linker. */ - -typedef struct elf_linker_section -{ - /* pointer to the section */ - asection *section; - /* pointer to the relocations needed for this section */ - asection *rel_section; - /* pointer to the created symbol hash value */ - struct elf_link_hash_entry *sym_hash; - /* offset of symbol from beginning of section */ - bfd_vma sym_offset; -} elf_linker_section_t; - -/* Linked list of allocated pointer entries. This hangs off of the - symbol lists, and provides allows us to return different pointers, - based on different addend's. */ - -typedef struct elf_linker_section_pointers -{ - /* next allocated pointer for this symbol */ - struct elf_linker_section_pointers *next; - /* offset of pointer from beginning of section */ - bfd_vma offset; - /* addend used */ - bfd_vma addend; - /* which linker section this is */ - elf_linker_section_t *lsect; - /* whether address was written yet */ - bfd_boolean written_address_p; -} elf_linker_section_pointers_t; - -struct ppc_elf_obj_tdata -{ - struct elf_obj_tdata elf; - - /* A mapping from local symbols to offsets into the various linker - sections added. This is index by the symbol index. */ - elf_linker_section_pointers_t **linker_section_pointers; -}; - -#define ppc_elf_tdata(bfd) \ - ((struct ppc_elf_obj_tdata *) (bfd)->tdata.any) - -#define elf_local_ptr_offsets(bfd) \ - (ppc_elf_tdata (bfd)->linker_section_pointers) - -/* Override the generic function because we store some extras. */ - -static bfd_boolean -ppc_elf_mkobject (bfd *abfd) -{ - bfd_size_type amt = sizeof (struct ppc_elf_obj_tdata); - abfd->tdata.any = bfd_zalloc (abfd, amt); - if (abfd->tdata.any == NULL) - return FALSE; - return TRUE; -} - -/* The PPC linker needs to keep track of the number of relocs that it - decides to copy as dynamic relocs in check_relocs for each symbol. - This is so that it can later discard them if they are found to be - unnecessary. We store the information in a field extending the - regular ELF linker hash table. */ - -struct ppc_elf_dyn_relocs -{ - struct ppc_elf_dyn_relocs *next; - - /* The input section of the reloc. */ - asection *sec; - - /* Total number of relocs copied for the input section. */ - bfd_size_type count; - - /* Number of pc-relative relocs copied for the input section. */ - bfd_size_type pc_count; -}; - -/* PPC ELF linker hash entry. */ - -struct ppc_elf_link_hash_entry -{ - struct elf_link_hash_entry elf; - - /* If this symbol is used in the linker created sections, the processor - specific backend uses this field to map the field into the offset - from the beginning of the section. */ - elf_linker_section_pointers_t *linker_section_pointer; - - /* Track dynamic relocs copied for this symbol. */ - struct ppc_elf_dyn_relocs *dyn_relocs; - - /* Contexts in which symbol is used in the GOT (or TOC). - TLS_GD .. TLS_TLS bits are or'd into the mask as the - corresponding relocs are encountered during check_relocs. - tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to - indicate the corresponding GOT entry type is not needed. */ -#define TLS_GD 1 /* GD reloc. */ -#define TLS_LD 2 /* LD reloc. */ -#define TLS_TPREL 4 /* TPREL reloc, => IE. */ -#define TLS_DTPREL 8 /* DTPREL reloc, => LD. */ -#define TLS_TLS 16 /* Any TLS reloc. */ -#define TLS_TPRELGD 32 /* TPREL reloc resulting from GD->IE. */ - char tls_mask; -}; - -#define ppc_elf_hash_entry(ent) ((struct ppc_elf_link_hash_entry *) (ent)) - -/* PPC ELF linker hash table. */ - -struct ppc_elf_link_hash_table -{ - struct elf_link_hash_table elf; - - /* Short-cuts to get to dynamic linker sections. */ - asection *got; - asection *relgot; - asection *plt; - asection *relplt; - asection *dynbss; - asection *relbss; - asection *dynsbss; - asection *relsbss; - elf_linker_section_t *sdata; - elf_linker_section_t *sdata2; - asection *sbss; - - /* Shortcut to .__tls_get_addr. */ - struct elf_link_hash_entry *tls_get_addr; - - /* TLS local dynamic got entry handling. */ - union { - bfd_signed_vma refcount; - bfd_vma offset; - } tlsld_got; - - /* Small local sym to section mapping cache. */ - struct sym_sec_cache sym_sec; -}; - -/* Get the PPC ELF linker hash table from a link_info structure. */ - -#define ppc_elf_hash_table(p) \ - ((struct ppc_elf_link_hash_table *) (p)->hash) - -/* Create an entry in a PPC ELF linker hash table. */ - -static struct bfd_hash_entry * -ppc_elf_link_hash_newfunc (struct bfd_hash_entry *entry, - struct bfd_hash_table *table, - const char *string) -{ - /* Allocate the structure if it has not already been allocated by a - subclass. */ - if (entry == NULL) - { - entry = bfd_hash_allocate (table, - sizeof (struct ppc_elf_link_hash_entry)); - if (entry == NULL) - return entry; - } - - /* Call the allocation method of the superclass. */ - entry = _bfd_elf_link_hash_newfunc (entry, table, string); - if (entry != NULL) - { - ppc_elf_hash_entry (entry)->linker_section_pointer = NULL; - ppc_elf_hash_entry (entry)->dyn_relocs = NULL; - ppc_elf_hash_entry (entry)->tls_mask = 0; - } +/* For new-style .glink and .plt. */ +#define GLINK_PLTRESOLVE 16*4 +#define GLINK_ENTRY_SIZE 4*4 - return entry; -} - -/* Create a PPC ELF linker hash table. */ - -static struct bfd_link_hash_table * -ppc_elf_link_hash_table_create (bfd *abfd) -{ - struct ppc_elf_link_hash_table *ret; +/* VxWorks uses its own plt layout, filled in by the static linker. */ - ret = bfd_zmalloc (sizeof (struct ppc_elf_link_hash_table)); - if (ret == NULL) - return NULL; - - if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd, - ppc_elf_link_hash_newfunc)) - { - free (ret); - return NULL; - } - - return &ret->elf.root; -} - -/* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid - copying dynamic variables from a shared lib into an app's dynbss - section, and instead use a dynamic relocation to point into the - shared lib. */ -#define ELIMINATE_COPY_RELOCS 1 - -/* Copy the extra info we tack onto an elf_link_hash_entry. */ - -static void -ppc_elf_copy_indirect_symbol (const struct elf_backend_data *bed, - struct elf_link_hash_entry *dir, - struct elf_link_hash_entry *ind) -{ - struct ppc_elf_link_hash_entry *edir, *eind; - - edir = (struct ppc_elf_link_hash_entry *) dir; - eind = (struct ppc_elf_link_hash_entry *) ind; - - if (eind->dyn_relocs != NULL) - { - if (edir->dyn_relocs != NULL) - { - struct ppc_elf_dyn_relocs **pp; - struct ppc_elf_dyn_relocs *p; - - if (ind->root.type == bfd_link_hash_indirect) - abort (); +/* The standard VxWorks PLT entry. */ +#define VXWORKS_PLT_ENTRY_SIZE 32 +static const bfd_vma ppc_elf_vxworks_plt_entry + [VXWORKS_PLT_ENTRY_SIZE / 4] = + { + 0x3d800000, /* lis r12,0 */ + 0x818c0000, /* lwz r12,0(r12) */ + 0x7d8903a6, /* mtctr r12 */ + 0x4e800420, /* bctr */ + 0x39600000, /* li r11,0 */ + 0x48000000, /* b 14 <.PLT0resolve+0x4> */ + 0x60000000, /* nop */ + 0x60000000, /* nop */ + }; +static const bfd_vma ppc_elf_vxworks_pic_plt_entry + [VXWORKS_PLT_ENTRY_SIZE / 4] = + { + 0x3d9e0000, /* addis r12,r30,0 */ + 0x818c0000, /* lwz r12,0(r12) */ + 0x7d8903a6, /* mtctr r12 */ + 0x4e800420, /* bctr */ + 0x39600000, /* li r11,0 */ + 0x48000000, /* b 14 <.PLT0resolve+0x4> 14: R_PPC_REL24 .PLTresolve */ + 0x60000000, /* nop */ + 0x60000000, /* nop */ + }; - /* Add reloc counts against the weak sym to the strong sym - list. Merge any entries against the same section. */ - for (pp = &eind->dyn_relocs; (p = *pp) != NULL; ) - { - struct ppc_elf_dyn_relocs *q; +/* The initial VxWorks PLT entry. */ +#define VXWORKS_PLT_INITIAL_ENTRY_SIZE 32 +static const bfd_vma ppc_elf_vxworks_plt0_entry + [VXWORKS_PLT_INITIAL_ENTRY_SIZE / 4] = + { + 0x3d800000, /* lis r12,0 */ + 0x398c0000, /* addi r12,r12,0 */ + 0x800c0008, /* lwz r0,8(r12) */ + 0x7c0903a6, /* mtctr r0 */ + 0x818c0004, /* lwz r12,4(r12) */ + 0x4e800420, /* bctr */ + 0x60000000, /* nop */ + 0x60000000, /* nop */ + }; +static const bfd_vma ppc_elf_vxworks_pic_plt0_entry + [VXWORKS_PLT_INITIAL_ENTRY_SIZE / 4] = + { + 0x819e0008, /* lwz r12,8(r30) */ + 0x7d8903a6, /* mtctr r12 */ + 0x819e0004, /* lwz r12,4(r30) */ + 0x4e800420, /* bctr */ + 0x60000000, /* nop */ + 0x60000000, /* nop */ + 0x60000000, /* nop */ + 0x60000000, /* nop */ + }; - for (q = edir->dyn_relocs; q != NULL; q = q->next) - if (q->sec == p->sec) - { - q->pc_count += p->pc_count; - q->count += p->count; - *pp = p->next; - break; - } - if (q == NULL) - pp = &p->next; - } - *pp = edir->dyn_relocs; - } +/* For executables, we have some additional relocations in + .rela.plt.unloaded, for the kernel loader. */ - edir->dyn_relocs = eind->dyn_relocs; - eind->dyn_relocs = NULL; - } +/* The number of non-JMP_SLOT relocations per PLT0 slot. */ +#define VXWORKS_PLT_NON_JMP_SLOT_RELOCS 3 +/* The number of relocations in the PLTResolve slot. */ +#define VXWORKS_PLTRESOLVE_RELOCS 2 +/* The number of relocations in the PLTResolve slot when when creating + a shared library. */ +#define VXWORKS_PLTRESOLVE_RELOCS_SHLIB 0 - edir->tls_mask |= eind->tls_mask; +/* Some instructions. */ +#define ADDIS_11_11 0x3d6b0000 +#define ADDIS_11_30 0x3d7e0000 +#define ADDIS_12_12 0x3d8c0000 +#define ADDI_11_11 0x396b0000 +#define ADD_0_11_11 0x7c0b5a14 +#define ADD_11_0_11 0x7d605a14 +#define B 0x48000000 +#define BCL_20_31 0x429f0005 +#define BCTR 0x4e800420 +#define LIS_11 0x3d600000 +#define LIS_12 0x3d800000 +#define LWZU_0_12 0x840c0000 +#define LWZ_0_12 0x800c0000 +#define LWZ_11_11 0x816b0000 +#define LWZ_11_30 0x817e0000 +#define LWZ_12_12 0x818c0000 +#define MFLR_0 0x7c0802a6 +#define MFLR_12 0x7d8802a6 +#define MTCTR_0 0x7c0903a6 +#define MTCTR_11 0x7d6903a6 +#define MTLR_0 0x7c0803a6 +#define NOP 0x60000000 +#define SUB_11_11_12 0x7d6c5850 - if (ELIMINATE_COPY_RELOCS - && ind->root.type != bfd_link_hash_indirect - && (dir->elf_link_hash_flags & ELF_LINK_HASH_DYNAMIC_ADJUSTED) != 0) - /* If called to transfer flags for a weakdef during processing - of elf_adjust_dynamic_symbol, don't copy ELF_LINK_NON_GOT_REF. - We clear it ourselves for ELIMINATE_COPY_RELOCS. */ - dir->elf_link_hash_flags |= - (ind->elf_link_hash_flags & (ELF_LINK_HASH_REF_DYNAMIC - | ELF_LINK_HASH_REF_REGULAR - | ELF_LINK_HASH_REF_REGULAR_NONWEAK - | ELF_LINK_HASH_NEEDS_PLT)); - else - _bfd_elf_link_hash_copy_indirect (bed, dir, ind); -} +/* Offset of tp and dtp pointers from start of TLS block. */ +#define TP_OFFSET 0x7000 +#define DTP_OFFSET 0x8000 static reloc_howto_type *ppc_elf_howto_table[R_PPC_max]; @@ -1532,34 +1346,66 @@ static reloc_howto_type ppc_elf_howto_raw[] = { 0xffff, /* dst_mask */ FALSE), /* pcrel_offset */ - /* Phony relocs to handle branch stubs. */ - HOWTO (R_PPC_RELAX32, /* type */ + /* A 16 bit relative relocation. */ + HOWTO (R_PPC_REL16, /* type */ 0, /* rightshift */ - 0, /* size */ - 0, /* bitsize */ - FALSE, /* pc_relative */ + 1, /* size (0 = byte, 1 = short, 2 = long) */ + 16, /* bitsize */ + TRUE, /* pc_relative */ 0, /* bitpos */ - complain_overflow_dont, /* complain_on_overflow */ + complain_overflow_bitfield, /* complain_on_overflow */ bfd_elf_generic_reloc, /* special_function */ - "R_PPC_RELAX32", /* name */ + "R_PPC_REL16", /* name */ FALSE, /* partial_inplace */ 0, /* src_mask */ - 0, /* dst_mask */ - FALSE), /* pcrel_offset */ + 0xffff, /* dst_mask */ + TRUE), /* pcrel_offset */ - HOWTO (R_PPC_RELAX32PC, /* type */ + /* A 16 bit relative relocation without overflow. */ + HOWTO (R_PPC_REL16_LO, /* type */ 0, /* rightshift */ - 0, /* size */ - 0, /* bitsize */ - FALSE, /* pc_relative */ + 1, /* size (0 = byte, 1 = short, 2 = long) */ + 16, /* bitsize */ + TRUE, /* pc_relative */ + 0, /* bitpos */ + complain_overflow_dont,/* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_PPC_REL16_LO", /* name */ + FALSE, /* partial_inplace */ + 0, /* src_mask */ + 0xffff, /* dst_mask */ + TRUE), /* pcrel_offset */ + + /* The high order 16 bits of a relative address. */ + HOWTO (R_PPC_REL16_HI, /* type */ + 16, /* rightshift */ + 1, /* size (0 = byte, 1 = short, 2 = long) */ + 16, /* bitsize */ + TRUE, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont, /* complain_on_overflow */ bfd_elf_generic_reloc, /* special_function */ - "R_PPC_RELAX32PC", /* name */ + "R_PPC_REL16_HI", /* name */ FALSE, /* partial_inplace */ 0, /* src_mask */ - 0, /* dst_mask */ - FALSE), /* pcrel_offset */ + 0xffff, /* dst_mask */ + TRUE), /* pcrel_offset */ + + /* The high order 16 bits of a relative address, plus 1 if the contents of + the low 16 bits, treated as a signed number, is negative. */ + HOWTO (R_PPC_REL16_HA, /* type */ + 16, /* rightshift */ + 1, /* size (0 = byte, 1 = short, 2 = long) */ + 16, /* bitsize */ + TRUE, /* pc_relative */ + 0, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + ppc_elf_addr16_ha_reloc, /* special_function */ + "R_PPC_REL16_HA", /* name */ + FALSE, /* partial_inplace */ + 0, /* src_mask */ + 0xffff, /* dst_mask */ + TRUE), /* pcrel_offset */ /* GNU extension to record C++ vtable hierarchy. */ HOWTO (R_PPC_GNU_VTINHERIT, /* type */ @@ -1625,381 +1471,7 @@ ppc_elf_howto_init (void) ppc_elf_howto_table[type] = &ppc_elf_howto_raw[i]; } } - -#define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0])) - -static const int shared_stub_entry[] = - { - 0x7c0802a6, /* mflr 0 */ - 0x429f0005, /* bcl 20, 31, .Lxxx */ - 0x7d6802a6, /* mflr 11 */ - 0x3d6b0000, /* addis 11, 11, (xxx-.Lxxx)@ha */ - 0x396b0018, /* addi 11, 11, (xxx-.Lxxx)@l */ - 0x7c0803a6, /* mtlr 0 */ - 0x7d6903a6, /* mtctr 11 */ - 0x4e800420, /* bctr */ - }; - -static const int stub_entry[] = - { - 0x3d600000, /* lis 11,xxx@ha */ - 0x396b0000, /* addi 11,11,xxx@l */ - 0x7d6903a6, /* mtctr 11 */ - 0x4e800420, /* bctr */ - }; - - -static bfd_boolean -ppc_elf_relax_section (bfd *abfd, - asection *isec, - struct bfd_link_info *link_info, - bfd_boolean *again) -{ - struct one_fixup - { - struct one_fixup *next; - asection *tsec; - bfd_vma toff; - bfd_vma trampoff; - }; - - Elf_Internal_Shdr *symtab_hdr; - bfd_byte *contents = NULL; - Elf_Internal_Sym *isymbuf = NULL; - Elf_Internal_Rela *internal_relocs = NULL; - Elf_Internal_Rela *irel, *irelend; - struct one_fixup *fixups = NULL; - bfd_boolean changed; - struct ppc_elf_link_hash_table *ppc_info; - bfd_size_type trampoff; - - *again = FALSE; - - /* Nothing to do if there are no relocations. */ - if ((isec->flags & SEC_RELOC) == 0 || isec->reloc_count == 0) - return TRUE; - - /* If needed, initialize this section's cooked size. */ - if (isec->_cooked_size == 0) - isec->_cooked_size = isec->_raw_size; - - trampoff = (isec->_cooked_size + 3) & (bfd_vma) -4; - /* Space for a branch around any trampolines. */ - trampoff += 4; - - symtab_hdr = &elf_tdata (abfd)->symtab_hdr; - - /* Get a copy of the native relocations. */ - internal_relocs = _bfd_elf_link_read_relocs (abfd, isec, NULL, NULL, - link_info->keep_memory); - if (internal_relocs == NULL) - goto error_return; - - ppc_info = ppc_elf_hash_table (link_info); - irelend = internal_relocs + isec->reloc_count; - - /* Get the section contents. */ - /* Get cached copy if it exists. */ - if (elf_section_data (isec)->this_hdr.contents != NULL) - contents = elf_section_data (isec)->this_hdr.contents; - else - { - /* Go get them off disk. */ - contents = bfd_malloc (isec->_raw_size); - if (contents == NULL) - goto error_return; - - if (!bfd_get_section_contents (abfd, isec, contents, 0, isec->_raw_size)) - goto error_return; - } - - for (irel = internal_relocs; irel < irelend; irel++) - { - unsigned long r_type = ELF32_R_TYPE (irel->r_info); - bfd_vma symaddr, reladdr, toff, roff; - asection *tsec; - struct one_fixup *f; - size_t insn_offset = 0; - bfd_vma max_branch_offset, val; - bfd_byte *hit_addr; - unsigned long t0; - - switch (r_type) - { - case R_PPC_REL24: - case R_PPC_LOCAL24PC: - case R_PPC_PLTREL24: - max_branch_offset = 1 << 25; - break; - - case R_PPC_REL14: - case R_PPC_REL14_BRTAKEN: - case R_PPC_REL14_BRNTAKEN: - max_branch_offset = 1 << 15; - break; - - default: - continue; - } - - /* Get the value of the symbol referred to by the reloc. */ - if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) - { - /* A local symbol. */ - Elf_Internal_Sym *isym; - /* Read this BFD's local symbols. */ - if (isymbuf == NULL) - { - isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; - if (isymbuf == NULL) - isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, - symtab_hdr->sh_info, 0, - NULL, NULL, NULL); - if (isymbuf == 0) - goto error_return; - } - isym = isymbuf + ELF32_R_SYM (irel->r_info); - if (isym->st_shndx == SHN_UNDEF) - continue; /* We can't do anything with undefined symbols. */ - else if (isym->st_shndx == SHN_ABS) - tsec = bfd_abs_section_ptr; - else if (isym->st_shndx == SHN_COMMON) - tsec = bfd_com_section_ptr; - else - tsec = bfd_section_from_elf_index (abfd, isym->st_shndx); - - toff = isym->st_value; - } - else - { - /* Global symbol handling. */ - unsigned long indx; - struct elf_link_hash_entry *h; - - indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info; - h = elf_sym_hashes (abfd)[indx]; - - while (h->root.type == bfd_link_hash_indirect - || h->root.type == bfd_link_hash_warning) - h = (struct elf_link_hash_entry *) h->root.u.i.link; - - if (r_type == R_PPC_PLTREL24 - && ppc_info->plt != NULL - && h->plt.offset != (bfd_vma) -1) - { - tsec = ppc_info->plt; - toff = h->plt.offset; - } - else if (h->root.type == bfd_link_hash_defined - || h->root.type == bfd_link_hash_defweak) - { - tsec = h->root.u.def.section; - toff = h->root.u.def.value; - } - else - continue; - } - - /* If the branch and target are in the same section, you have - no hope of adding stubs. We'll error out later should the - branch overflow. */ - if (tsec == isec) - continue; - - toff += irel->r_addend; - if (tsec->sec_info_type == ELF_INFO_TYPE_MERGE) - toff = _bfd_merged_section_offset (abfd, &tsec, - elf_section_data (tsec)->sec_info, - toff, 0); - - symaddr = tsec->output_section->vma + tsec->output_offset + toff; - - roff = irel->r_offset; - reladdr = isec->output_section->vma + isec->output_offset + roff; - - /* If the branch is in range, no need to do anything. */ - if (symaddr - reladdr + max_branch_offset < 2 * max_branch_offset) - continue; - - /* Look for an existing fixup to this address. */ - for (f = fixups; f ; f = f->next) - if (f->tsec == tsec && f->toff == toff) - break; - - if (f == NULL) - { - size_t size; - unsigned long stub_rtype; - - val = trampoff - roff; - if (val >= max_branch_offset) - /* Oh dear, we can't reach a trampoline. Don't try to add - one. We'll report an error later. */ - continue; - - if (link_info->shared) - { - size = 4 * ARRAY_SIZE (shared_stub_entry); - insn_offset = 12; - stub_rtype = R_PPC_RELAX32PC; - } - else - { - size = 4 * ARRAY_SIZE (stub_entry); - insn_offset = 0; - stub_rtype = R_PPC_RELAX32; - } - - /* Hijack the old relocation. Since we need two - relocations for this use a "composite" reloc. */ - irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), - stub_rtype); - irel->r_offset = trampoff + insn_offset; - - /* Record the fixup so we don't do it again this section. */ - f = bfd_malloc (sizeof (*f)); - f->next = fixups; - f->tsec = tsec; - f->toff = toff; - f->trampoff = trampoff; - fixups = f; - - trampoff += size; - } - else - { - val = f->trampoff - roff; - if (val >= max_branch_offset) - continue; - - /* Nop out the reloc, since we're finalizing things here. */ - irel->r_info = ELF32_R_INFO (0, R_PPC_NONE); - } - - /* Fix up the existing branch to hit the trampoline. */ - hit_addr = contents + roff; - switch (r_type) - { - case R_PPC_REL24: - case R_PPC_LOCAL24PC: - case R_PPC_PLTREL24: - t0 = bfd_get_32 (abfd, hit_addr); - t0 &= ~0x3fffffc; - t0 |= val & 0x3fffffc; - bfd_put_32 (abfd, t0, hit_addr); - break; - - case R_PPC_REL14: - case R_PPC_REL14_BRTAKEN: - case R_PPC_REL14_BRNTAKEN: - t0 = bfd_get_32 (abfd, hit_addr); - t0 &= ~0xfffc; - t0 |= val & 0xfffc; - bfd_put_32 (abfd, t0, hit_addr); - break; - } - } - - /* Write out the trampolines. */ - changed = fixups != NULL; - if (fixups != NULL) - { - const int *stub; - bfd_byte *dest; - bfd_vma val; - int i, size; - - do - { - struct one_fixup *f = fixups; - fixups = fixups->next; - free (f); - } - while (fixups); - - contents = bfd_realloc (contents, trampoff); - if (contents == NULL) - goto error_return; - - isec->_cooked_size = (isec->_cooked_size + 3) & (bfd_vma) -4; - /* Branch around the trampolines. */ - val = trampoff - isec->_cooked_size + 0x48000000; - dest = contents + isec->_cooked_size; - isec->_cooked_size = trampoff; - bfd_put_32 (abfd, val, dest); - dest += 4; - - if (link_info->shared) - { - stub = shared_stub_entry; - size = ARRAY_SIZE (shared_stub_entry); - } - else - { - stub = stub_entry; - size = ARRAY_SIZE (stub_entry); - } - - i = 0; - while (dest < contents + trampoff) - { - bfd_put_32 (abfd, stub[i], dest); - i++; - if (i == size) - i = 0; - dest += 4; - } - BFD_ASSERT (i == 0); - } - - if (isymbuf != NULL - && symtab_hdr->contents != (unsigned char *) isymbuf) - { - if (! link_info->keep_memory) - free (isymbuf); - else - { - /* Cache the symbols for elf_link_input_bfd. */ - symtab_hdr->contents = (unsigned char *) isymbuf; - } - } - - if (contents != NULL - && elf_section_data (isec)->this_hdr.contents != contents) - { - if (!changed && !link_info->keep_memory) - free (contents); - else - { - /* Cache the section contents for elf_link_input_bfd. */ - elf_section_data (isec)->this_hdr.contents = contents; - } - } - - if (elf_section_data (isec)->relocs != internal_relocs) - { - if (!changed) - free (internal_relocs); - else - elf_section_data (isec)->relocs = internal_relocs; - } - - *again = changed; - return TRUE; - - error_return: - if (isymbuf != NULL && (unsigned char *) isymbuf != symtab_hdr->contents) - free (isymbuf); - if (contents != NULL - && elf_section_data (isec)->this_hdr.contents != contents) - free (contents); - if (internal_relocs != NULL - && elf_section_data (isec)->relocs != internal_relocs) - free (internal_relocs); - return FALSE; -} - static reloc_howto_type * ppc_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, bfd_reloc_code_real_type code) @@ -2094,6 +1566,10 @@ ppc_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, case BFD_RELOC_PPC_EMB_RELST_HA: r = R_PPC_EMB_RELST_HA; break; case BFD_RELOC_PPC_EMB_BIT_FLD: r = R_PPC_EMB_BIT_FLD; break; case BFD_RELOC_PPC_EMB_RELSDA: r = R_PPC_EMB_RELSDA; break; + case BFD_RELOC_16_PCREL: r = R_PPC_REL16; break; + case BFD_RELOC_LO16_PCREL: r = R_PPC_REL16_LO; break; + case BFD_RELOC_HI16_PCREL: r = R_PPC_REL16_HI; break; + case BFD_RELOC_HI16_S_PCREL: r = R_PPC_REL16_HA; break; case BFD_RELOC_VTABLE_INHERIT: r = R_PPC_GNU_VTINHERIT; break; case BFD_RELOC_VTABLE_ENTRY: r = R_PPC_GNU_VTENTRY; break; } @@ -2116,7 +1592,7 @@ ppc_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, cache_ptr->howto = ppc_elf_howto_table[ELF32_R_TYPE (dst->r_info)]; } -/* Handle the R_PPC_ADDR16_HA reloc. */ +/* Handle the R_PPC_ADDR16_HA and R_PPC_REL16_HA relocs. */ static bfd_reloc_status_type ppc_elf_addr16_ha_reloc (bfd *abfd ATTRIBUTE_UNUSED, @@ -2135,7 +1611,7 @@ ppc_elf_addr16_ha_reloc (bfd *abfd ATTRIBUTE_UNUSED, return bfd_reloc_ok; } - if (reloc_entry->address > input_section->_cooked_size) + if (reloc_entry->address > bfd_get_section_limit (abfd, input_section)) return bfd_reloc_outofrange; if (bfd_is_com_section (symbol->section)) @@ -2146,6 +1622,8 @@ ppc_elf_addr16_ha_reloc (bfd *abfd ATTRIBUTE_UNUSED, relocation += symbol->section->output_section->vma; relocation += symbol->section->output_offset; relocation += reloc_entry->addend; + if (reloc_entry->howto->pc_relative) + relocation -= reloc_entry->address; reloc_entry->addend += (relocation & 0x8000) << 1; @@ -2177,6 +1655,65 @@ ppc_elf_unhandled_reloc (bfd *abfd, } return bfd_reloc_dangerous; } + +/* Sections created by the linker. */ + +typedef struct elf_linker_section +{ + /* Pointer to the bfd section. */ + asection *section; + /* Section name. */ + const char *name; + /* Associated bss section name. */ + const char *bss_name; + /* Associated symbol name. */ + const char *sym_name; + /* Associated symbol. */ + struct elf_link_hash_entry *sym; +} elf_linker_section_t; + +/* Linked list of allocated pointer entries. This hangs off of the + symbol lists, and provides allows us to return different pointers, + based on different addend's. */ + +typedef struct elf_linker_section_pointers +{ + /* next allocated pointer for this symbol */ + struct elf_linker_section_pointers *next; + /* offset of pointer from beginning of section */ + bfd_vma offset; + /* addend used */ + bfd_vma addend; + /* which linker section this is */ + elf_linker_section_t *lsect; +} elf_linker_section_pointers_t; + +struct ppc_elf_obj_tdata +{ + struct elf_obj_tdata elf; + + /* A mapping from local symbols to offsets into the various linker + sections added. This is index by the symbol index. */ + elf_linker_section_pointers_t **linker_section_pointers; +}; + +#define ppc_elf_tdata(bfd) \ + ((struct ppc_elf_obj_tdata *) (bfd)->tdata.any) + +#define elf_local_ptr_offsets(bfd) \ + (ppc_elf_tdata (bfd)->linker_section_pointers) + +/* Override the generic function because we store some extras. */ + +static bfd_boolean +ppc_elf_mkobject (bfd *abfd) +{ + bfd_size_type amt = sizeof (struct ppc_elf_obj_tdata); + abfd->tdata.any = bfd_zalloc (abfd, amt); + if (abfd->tdata.any == NULL) + return FALSE; + return TRUE; +} /* Fix bad default arch selected for a 32 bit input bfd when the default is 64 bit. */ @@ -2211,110 +1748,93 @@ ppc_elf_set_private_flags (bfd *abfd, flagword flags) return TRUE; } -/* Merge backend specific data from an object file to the output - object file when linking. */ +/* Support for core dump NOTE sections. */ static bfd_boolean -ppc_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd) +ppc_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note) { - flagword old_flags; - flagword new_flags; - bfd_boolean error; + int offset; + unsigned int size; - /* Check if we have the same endianess. */ - if (! _bfd_generic_verify_endian_match (ibfd, obfd)) - return FALSE; + switch (note->descsz) + { + default: + return FALSE; - if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour - || bfd_get_flavour (obfd) != bfd_target_elf_flavour) - return TRUE; + case 268: /* Linux/PPC. */ + /* pr_cursig */ + elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12); - new_flags = elf_elfheader (ibfd)->e_flags; - old_flags = elf_elfheader (obfd)->e_flags; - if (!elf_flags_init (obfd)) - { - /* First call, no flags set. */ - elf_flags_init (obfd) = TRUE; - elf_elfheader (obfd)->e_flags = new_flags; + /* pr_pid */ + elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24); + + /* pr_reg */ + offset = 72; + size = 192; + + break; } - /* Compatible flags are ok. */ - else if (new_flags == old_flags) - ; + /* Make a ".reg/999" section. */ + return _bfd_elfcore_make_pseudosection (abfd, ".reg", + size, note->descpos + offset); +} - /* Incompatible flags. */ - else +static bfd_boolean +ppc_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) +{ + switch (note->descsz) { - /* Warn about -mrelocatable mismatch. Allow -mrelocatable-lib - to be linked with either. */ - error = FALSE; - if ((new_flags & EF_PPC_RELOCATABLE) != 0 - && (old_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0) - { - error = TRUE; - (*_bfd_error_handler) - (_("%s: compiled with -mrelocatable and linked with " - "modules compiled normally"), - bfd_archive_filename (ibfd)); - } - else if ((new_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0 - && (old_flags & EF_PPC_RELOCATABLE) != 0) - { - error = TRUE; - (*_bfd_error_handler) - (_("%s: compiled normally and linked with " - "modules compiled with -mrelocatable"), - bfd_archive_filename (ibfd)); - } + default: + return FALSE; - /* The output is -mrelocatable-lib iff both the input files are. */ - if (! (new_flags & EF_PPC_RELOCATABLE_LIB)) - elf_elfheader (obfd)->e_flags &= ~EF_PPC_RELOCATABLE_LIB; + case 128: /* Linux/PPC elf_prpsinfo. */ + elf_tdata (abfd)->core_program + = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16); + elf_tdata (abfd)->core_command + = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80); + } - /* The output is -mrelocatable iff it can't be -mrelocatable-lib, - but each input file is either -mrelocatable or -mrelocatable-lib. */ - if (! (elf_elfheader (obfd)->e_flags & EF_PPC_RELOCATABLE_LIB) - && (new_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE)) - && (old_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE))) - elf_elfheader (obfd)->e_flags |= EF_PPC_RELOCATABLE; + /* Note that for some reason, a spurious space is tacked + onto the end of the args in some (at least one anyway) + implementations, so strip it off if it exists. */ - /* Do not warn about eabi vs. V.4 mismatch, just or in the bit if - any module uses it. */ - elf_elfheader (obfd)->e_flags |= (new_flags & EF_PPC_EMB); + { + char *command = elf_tdata (abfd)->core_command; + int n = strlen (command); - new_flags &= ~(EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB); - old_flags &= ~(EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB); + if (0 < n && command[n - 1] == ' ') + command[n - 1] = '\0'; + } - /* Warn about any other mismatches. */ - if (new_flags != old_flags) - { - error = TRUE; - (*_bfd_error_handler) - (_("%s: uses different e_flags (0x%lx) fields " - "than previous modules (0x%lx)"), - bfd_archive_filename (ibfd), (long) new_flags, (long) old_flags); - } + return TRUE; +} - if (error) - { - bfd_set_error (bfd_error_bad_value); - return FALSE; - } - } +/* Return address for Ith PLT stub in section PLT, for relocation REL + or (bfd_vma) -1 if it should not be included. */ - return TRUE; +static bfd_vma +ppc_elf_plt_sym_val (bfd_vma i ATTRIBUTE_UNUSED, + const asection *plt ATTRIBUTE_UNUSED, + const arelent *rel) +{ + return rel->address; } - + /* Handle a PowerPC specific section when reading an object file. This - is called when elfcode.h finds a section with an unknown type. */ + is called when bfd_section_from_shdr finds a section with an unknown + type. */ static bfd_boolean -ppc_elf_section_from_shdr (bfd *abfd, Elf_Internal_Shdr *hdr, const char *name) +ppc_elf_section_from_shdr (bfd *abfd, + Elf_Internal_Shdr *hdr, + const char *name, + int shindex) { asection *newsect; flagword flags; - if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name)) + if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex)) return FALSE; newsect = hdr->bfd_section; @@ -2328,7 +1848,7 @@ ppc_elf_section_from_shdr (bfd *abfd, Elf_Internal_Shdr *hdr, const char *name) bfd_set_section_flags (abfd, newsect, flags); return TRUE; } - + /* Set up any other section flags and such that may be necessary. */ static bfd_boolean @@ -2336,7 +1856,7 @@ ppc_elf_fake_sections (bfd *abfd ATTRIBUTE_UNUSED, Elf_Internal_Shdr *shdr, asection *asect) { - if ((asect->flags & SEC_EXCLUDE) != 0) + if ((asect->flags & (SEC_GROUP | SEC_EXCLUDE)) == SEC_EXCLUDE) shdr->sh_flags |= SHF_EXCLUDE; if ((asect->flags & SEC_SORT_ENTRIES) != 0) @@ -2344,402 +1864,603 @@ ppc_elf_fake_sections (bfd *abfd ATTRIBUTE_UNUSED, return TRUE; } - -/* Find a linker generated pointer with a given addend and type. */ -static elf_linker_section_pointers_t * -elf_find_pointer_linker_section - (elf_linker_section_pointers_t *linker_pointers, - bfd_vma addend, - elf_linker_section_t *lsect) +/* If we have .sbss2 or .PPC.EMB.sbss0 output sections, we + need to bump up the number of section headers. */ + +static int +ppc_elf_additional_program_headers (bfd *abfd) { - for ( ; linker_pointers != NULL; linker_pointers = linker_pointers->next) - if (lsect == linker_pointers->lsect && addend == linker_pointers->addend) - return linker_pointers; + asection *s; + int ret = 0; - return NULL; + s = bfd_get_section_by_name (abfd, ".sbss2"); + if (s != NULL && (s->flags & SEC_ALLOC) != 0) + ++ret; + + s = bfd_get_section_by_name (abfd, ".PPC.EMB.sbss0"); + if (s != NULL && (s->flags & SEC_ALLOC) != 0) + ++ret; + + return ret; } - -/* Allocate a pointer to live in a linker created section. */ -static bfd_boolean -elf_create_pointer_linker_section (bfd *abfd, - struct bfd_link_info *info, - elf_linker_section_t *lsect, - struct elf_link_hash_entry *h, - const Elf_Internal_Rela *rel) +/* Add extra PPC sections -- Note, for now, make .sbss2 and + .PPC.EMB.sbss0 a normal section, and not a bss section so + that the linker doesn't crater when trying to make more than + 2 sections. */ + +static const struct bfd_elf_special_section ppc_elf_special_sections[] = { - elf_linker_section_pointers_t **ptr_linker_section_ptr = NULL; - elf_linker_section_pointers_t *linker_section_ptr; - unsigned long r_symndx = ELF32_R_SYM (rel->r_info); - bfd_size_type amt; + { ".plt", 4, 0, SHT_NOBITS, SHF_ALLOC + SHF_EXECINSTR }, + { ".sbss", 5, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE }, + { ".sbss2", 6, -2, SHT_PROGBITS, SHF_ALLOC }, + { ".sdata", 6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE }, + { ".sdata2", 7, -2, SHT_PROGBITS, SHF_ALLOC }, + { ".tags", 5, 0, SHT_ORDERED, SHF_ALLOC }, + { ".PPC.EMB.apuinfo", 16, 0, SHT_NOTE, 0 }, + { ".PPC.EMB.sbss0", 14, 0, SHT_PROGBITS, SHF_ALLOC }, + { ".PPC.EMB.sdata0", 15, 0, SHT_PROGBITS, SHF_ALLOC }, + { NULL, 0, 0, 0, 0 } +}; - BFD_ASSERT (lsect != NULL); +/* This is what we want for new plt/got. */ +static struct bfd_elf_special_section ppc_alt_plt = + { ".plt", 4, 0, SHT_PROGBITS, SHF_ALLOC }; - /* Is this a global symbol? */ - if (h != NULL) +static const struct bfd_elf_special_section * +ppc_elf_get_sec_type_attr (bfd *abfd ATTRIBUTE_UNUSED, asection *sec) +{ + const struct bfd_elf_special_section *ssect; + + /* See if this is one of the special sections. */ + if (sec->name == NULL) + return NULL; + + ssect = _bfd_elf_get_special_section (sec->name, ppc_elf_special_sections, + sec->use_rela_p); + if (ssect != NULL) { - struct ppc_elf_link_hash_entry *eh; + if (ssect == ppc_elf_special_sections && (sec->flags & SEC_LOAD) != 0) + ssect = &ppc_alt_plt; + return ssect; + } - /* Has this symbol already been allocated? If so, our work is done. */ - eh = (struct ppc_elf_link_hash_entry *) h; - if (elf_find_pointer_linker_section (eh->linker_section_pointer, - rel->r_addend, - lsect)) - return TRUE; + return _bfd_elf_get_sec_type_attr (abfd, sec); +} + +/* Very simple linked list structure for recording apuinfo values. */ +typedef struct apuinfo_list +{ + struct apuinfo_list *next; + unsigned long value; +} +apuinfo_list; - ptr_linker_section_ptr = &eh->linker_section_pointer; - /* Make sure this symbol is output as a dynamic symbol. */ - if (h->dynindx == -1) - { - if (! bfd_elf_link_record_dynamic_symbol (info, h)) - return FALSE; - } +static apuinfo_list *head; + + +static void +apuinfo_list_init (void) +{ + head = NULL; +} - if (lsect->rel_section) - lsect->rel_section->_raw_size += sizeof (Elf32_External_Rela); +static void +apuinfo_list_add (unsigned long value) +{ + apuinfo_list *entry = head; + + while (entry != NULL) + { + if (entry->value == value) + return; + entry = entry->next; } - else + + entry = bfd_malloc (sizeof (* entry)); + if (entry == NULL) + return; + + entry->value = value; + entry->next = head; + head = entry; +} + +static unsigned +apuinfo_list_length (void) +{ + apuinfo_list *entry; + unsigned long count; + + for (entry = head, count = 0; + entry; + entry = entry->next) + ++ count; + + return count; +} + +static inline unsigned long +apuinfo_list_element (unsigned long number) +{ + apuinfo_list * entry; + + for (entry = head; + entry && number --; + entry = entry->next) + ; + + return entry ? entry->value : 0; +} + +static void +apuinfo_list_finish (void) +{ + apuinfo_list *entry; + + for (entry = head; entry;) { - /* Allocation of a pointer to a local symbol. */ - elf_linker_section_pointers_t **ptr = elf_local_ptr_offsets (abfd); + apuinfo_list *next = entry->next; + free (entry); + entry = next; + } - /* Allocate a table to hold the local symbols if first time. */ - if (!ptr) - { - unsigned int num_symbols = elf_tdata (abfd)->symtab_hdr.sh_info; + head = NULL; +} - amt = num_symbols; - amt *= sizeof (elf_linker_section_pointers_t *); - ptr = bfd_zalloc (abfd, amt); +#define APUINFO_SECTION_NAME ".PPC.EMB.apuinfo" +#define APUINFO_LABEL "APUinfo" - if (!ptr) - return FALSE; +/* Scan the input BFDs and create a linked list of + the APUinfo values that will need to be emitted. */ - elf_local_ptr_offsets (abfd) = ptr; +static void +ppc_elf_begin_write_processing (bfd *abfd, struct bfd_link_info *link_info) +{ + bfd *ibfd; + asection *asec; + char *buffer; + unsigned num_input_sections; + bfd_size_type output_section_size; + unsigned i; + unsigned num_entries; + unsigned long offset; + unsigned long length; + const char *error_message = NULL; + + if (link_info == NULL) + return; + + /* Scan the input bfds, looking for apuinfo sections. */ + num_input_sections = 0; + output_section_size = 0; + + for (ibfd = link_info->input_bfds; ibfd; ibfd = ibfd->link_next) + { + asec = bfd_get_section_by_name (ibfd, APUINFO_SECTION_NAME); + if (asec) + { + ++ num_input_sections; + output_section_size += asec->size; } + } - /* Has this symbol already been allocated? If so, our work is done. */ - if (elf_find_pointer_linker_section (ptr[r_symndx], - rel->r_addend, - lsect)) - return TRUE; + /* We need at least one input sections + in order to make merging worthwhile. */ + if (num_input_sections < 1) + return; - ptr_linker_section_ptr = &ptr[r_symndx]; + /* Just make sure that the output section exists as well. */ + asec = bfd_get_section_by_name (abfd, APUINFO_SECTION_NAME); + if (asec == NULL) + return; - if (info->shared) + /* Allocate a buffer for the contents of the input sections. */ + buffer = bfd_malloc (output_section_size); + if (buffer == NULL) + return; + + offset = 0; + apuinfo_list_init (); + + /* Read in the input sections contents. */ + for (ibfd = link_info->input_bfds; ibfd; ibfd = ibfd->link_next) + { + unsigned long datum; + char *ptr; + + asec = bfd_get_section_by_name (ibfd, APUINFO_SECTION_NAME); + if (asec == NULL) + continue; + + length = asec->size; + if (length < 24) { - /* If we are generating a shared object, we need to - output a R_<xxx>_RELATIVE reloc so that the - dynamic linker can adjust this GOT entry. */ - BFD_ASSERT (lsect->rel_section != NULL); - lsect->rel_section->_raw_size += sizeof (Elf32_External_Rela); + error_message = _("corrupt or empty %s section in %B"); + goto fail; } + + if (bfd_seek (ibfd, asec->filepos, SEEK_SET) != 0 + || (bfd_bread (buffer + offset, length, ibfd) != length)) + { + error_message = _("unable to read in %s section from %B"); + goto fail; + } + + /* Process the contents of the section. */ + ptr = buffer + offset; + error_message = _("corrupt %s section in %B"); + + /* Verify the contents of the header. Note - we have to + extract the values this way in order to allow for a + host whose endian-ness is different from the target. */ + datum = bfd_get_32 (ibfd, ptr); + if (datum != sizeof APUINFO_LABEL) + goto fail; + + datum = bfd_get_32 (ibfd, ptr + 8); + if (datum != 0x2) + goto fail; + + if (strcmp (ptr + 12, APUINFO_LABEL) != 0) + goto fail; + + /* Get the number of bytes used for apuinfo entries. */ + datum = bfd_get_32 (ibfd, ptr + 4); + if (datum + 20 != length) + goto fail; + + /* Make sure that we do not run off the end of the section. */ + if (offset + length > output_section_size) + goto fail; + + /* Scan the apuinfo section, building a list of apuinfo numbers. */ + for (i = 0; i < datum; i += 4) + apuinfo_list_add (bfd_get_32 (ibfd, ptr + 20 + i)); + + /* Update the offset. */ + offset += length; } - /* Allocate space for a pointer in the linker section, and allocate - a new pointer record from internal memory. */ - BFD_ASSERT (ptr_linker_section_ptr != NULL); - amt = sizeof (elf_linker_section_pointers_t); - linker_section_ptr = bfd_alloc (abfd, amt); + error_message = NULL; - if (!linker_section_ptr) - return FALSE; + /* Compute the size of the output section. */ + num_entries = apuinfo_list_length (); + output_section_size = 20 + num_entries * 4; - linker_section_ptr->next = *ptr_linker_section_ptr; - linker_section_ptr->addend = rel->r_addend; - linker_section_ptr->lsect = lsect; - linker_section_ptr->written_address_p = FALSE; - *ptr_linker_section_ptr = linker_section_ptr; + asec = bfd_get_section_by_name (abfd, APUINFO_SECTION_NAME); - linker_section_ptr->offset = lsect->section->_raw_size; - lsect->section->_raw_size += 4; + if (! bfd_set_section_size (abfd, asec, output_section_size)) + ibfd = abfd, + error_message = _("warning: unable to set size of %s section in %B"); -#ifdef DEBUG - fprintf (stderr, - "Create pointer in linker section %s, offset = %ld, section size = %ld\n", - lsect->name, (long) linker_section_ptr->offset, - (long) lsect->section->_raw_size); -#endif + fail: + free (buffer); - return TRUE; + if (error_message) + (*_bfd_error_handler) (error_message, ibfd, APUINFO_SECTION_NAME); } - -#define bfd_put_ptr(BFD, VAL, ADDR) bfd_put_32 (BFD, VAL, ADDR) -/* Fill in the address for a pointer generated in a linker section. */ +/* Prevent the output section from accumulating the input sections' + contents. We have already stored this in our linked list structure. */ -static bfd_vma -elf_finish_pointer_linker_section (bfd *output_bfd, - bfd *input_bfd, - struct bfd_link_info *info, - elf_linker_section_t *lsect, - struct elf_link_hash_entry *h, - bfd_vma relocation, - const Elf_Internal_Rela *rel, - int relative_reloc) +static bfd_boolean +ppc_elf_write_section (bfd *abfd ATTRIBUTE_UNUSED, + asection *asec, + bfd_byte *contents ATTRIBUTE_UNUSED) { - elf_linker_section_pointers_t *linker_section_ptr; + return (apuinfo_list_length () + && strcmp (asec->name, APUINFO_SECTION_NAME) == 0); +} - BFD_ASSERT (lsect != NULL); +/* Finally we can generate the output section. */ - if (h != NULL) - { - /* Handle global symbol. */ - struct ppc_elf_link_hash_entry *eh; +static void +ppc_elf_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED) +{ + bfd_byte *buffer; + asection *asec; + unsigned i; + unsigned num_entries; + bfd_size_type length; - eh = (struct ppc_elf_link_hash_entry *) h; - linker_section_ptr - = elf_find_pointer_linker_section (eh->linker_section_pointer, - rel->r_addend, - lsect); + asec = bfd_get_section_by_name (abfd, APUINFO_SECTION_NAME); + if (asec == NULL) + return; - BFD_ASSERT (linker_section_ptr != NULL); + if (apuinfo_list_length () == 0) + return; - if (! elf_hash_table (info)->dynamic_sections_created - || (info->shared - && info->symbolic - && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))) - { - /* This is actually a static link, or it is a - -Bsymbolic link and the symbol is defined - locally. We must initialize this entry in the - global section. + length = asec->size; + if (length < 20) + return; - When doing a dynamic link, we create a .rela.<xxx> - relocation entry to initialize the value. This - is done in the finish_dynamic_symbol routine. */ - if (!linker_section_ptr->written_address_p) - { - linker_section_ptr->written_address_p = TRUE; - bfd_put_ptr (output_bfd, - relocation + linker_section_ptr->addend, - (lsect->section->contents - + linker_section_ptr->offset)); - } - } + buffer = bfd_malloc (length); + if (buffer == NULL) + { + (*_bfd_error_handler) + (_("failed to allocate space for new APUinfo section.")); + return; } - else + + /* Create the apuinfo header. */ + num_entries = apuinfo_list_length (); + bfd_put_32 (abfd, sizeof APUINFO_LABEL, buffer); + bfd_put_32 (abfd, num_entries * 4, buffer + 4); + bfd_put_32 (abfd, 0x2, buffer + 8); + strcpy ((char *) buffer + 12, APUINFO_LABEL); + + length = 20; + for (i = 0; i < num_entries; i++) { - /* Handle local symbol. */ - unsigned long r_symndx = ELF32_R_SYM (rel->r_info); - BFD_ASSERT (elf_local_ptr_offsets (input_bfd) != NULL); - BFD_ASSERT (elf_local_ptr_offsets (input_bfd)[r_symndx] != NULL); - linker_section_ptr = (elf_find_pointer_linker_section - (elf_local_ptr_offsets (input_bfd)[r_symndx], - rel->r_addend, - lsect)); + bfd_put_32 (abfd, apuinfo_list_element (i), buffer + length); + length += 4; + } - BFD_ASSERT (linker_section_ptr != NULL); + if (length != asec->size) + (*_bfd_error_handler) (_("failed to compute new APUinfo section.")); - /* Write out pointer if it hasn't been rewritten out before. */ - if (!linker_section_ptr->written_address_p) - { - linker_section_ptr->written_address_p = TRUE; - bfd_put_ptr (output_bfd, relocation + linker_section_ptr->addend, - lsect->section->contents + linker_section_ptr->offset); + if (! bfd_set_section_contents (abfd, asec, buffer, (file_ptr) 0, length)) + (*_bfd_error_handler) (_("failed to install new APUinfo section.")); - if (info->shared) - { - /* We need to generate a relative reloc for the dynamic - linker. */ + free (buffer); - asection *srel = lsect->rel_section; - Elf_Internal_Rela outrel[MAX_INT_RELS_PER_EXT_REL]; - bfd_byte *erel; - const struct elf_backend_data *bed; - unsigned int i; + apuinfo_list_finish (); +} + +/* The following functions are specific to the ELF linker, while + functions above are used generally. They appear in this file more + or less in the order in which they are called. eg. + ppc_elf_check_relocs is called early in the link process, + ppc_elf_finish_dynamic_sections is one of the last functions + called. */ - BFD_ASSERT (srel != NULL); +/* The PPC linker needs to keep track of the number of relocs that it + decides to copy as dynamic relocs in check_relocs for each symbol. + This is so that it can later discard them if they are found to be + unnecessary. We store the information in a field extending the + regular ELF linker hash table. */ - bed = get_elf_backend_data (output_bfd); - for (i = 0; i < bed->s->int_rels_per_ext_rel; i++) - { - outrel[i].r_offset = (lsect->section->output_section->vma - + lsect->section->output_offset - + linker_section_ptr->offset); - outrel[i].r_info = 0; - outrel[i].r_addend = 0; - } - outrel[0].r_info = ELF32_R_INFO (0, relative_reloc); - erel = lsect->section->contents; - erel += (elf_section_data (lsect->section)->rel_count++ - * sizeof (Elf32_External_Rela)); - bfd_elf32_swap_reloca_out (output_bfd, outrel, erel); - } - } - } +struct ppc_elf_dyn_relocs +{ + struct ppc_elf_dyn_relocs *next; - relocation = (lsect->section->output_offset - + linker_section_ptr->offset - - lsect->sym_offset); + /* The input section of the reloc. */ + asection *sec; -#ifdef DEBUG - fprintf (stderr, - "Finish pointer in linker section %s, offset = %ld (0x%lx)\n", - lsect->name, (long) relocation, (long) relocation); -#endif + /* Total number of relocs copied for the input section. */ + bfd_size_type count; - /* Subtract out the addend, because it will get added back in by the normal - processing. */ - return relocation - linker_section_ptr->addend; -} - -/* Create a special linker section */ -static elf_linker_section_t * -ppc_elf_create_linker_section (bfd *abfd, - struct bfd_link_info *info, - enum elf_linker_section_enum which) + /* Number of pc-relative relocs copied for the input section. */ + bfd_size_type pc_count; +}; + +/* Track PLT entries needed for a given symbol. We might need more + than one glink entry per symbol. */ +struct plt_entry { - elf_linker_section_t *lsect; - struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info); - asection *s; - bfd_size_type amt; - flagword flags; - const char *name; - const char *rel_name; - const char *sym_name; - bfd_vma sym_offset; + struct plt_entry *next; - /* Both of these sections are (technically) created by the user - putting data in them, so they shouldn't be marked - SEC_LINKER_CREATED. + /* -fPIC uses multiple GOT sections, one per file, called ".got2". + This field stores the offset into .got2 used to initialise the + GOT pointer reg. It will always be at least 32768 (and for + current gcc this is the only offset used). */ + bfd_vma addend; - The linker creates them so it has somewhere to attach their - respective symbols. In fact, if they were empty it would - be OK to leave the symbol set to 0 (or any random number), because - the appropriate register should never be used. */ - flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY; - sym_offset = 32768; + /* The .got2 section. */ + asection *sec; - switch (which) + /* PLT refcount or offset. */ + union { - default: - abort (); - return NULL; + bfd_signed_vma refcount; + bfd_vma offset; + } plt; - case LINKER_SECTION_SDATA: /* .sdata/.sbss section */ - name = ".sdata"; - rel_name = ".rela.sdata"; - sym_name = "_SDA_BASE_"; - break; + /* .glink stub offset. */ + bfd_vma glink_offset; +}; - case LINKER_SECTION_SDATA2: /* .sdata2/.sbss2 section */ - name = ".sdata2"; - rel_name = ".rela.sdata2"; - sym_name = "_SDA2_BASE_"; - flags |= SEC_READONLY; - break; - } +/* Of those relocs that might be copied as dynamic relocs, this macro + selects those that must be copied when linking a shared library, + even when the symbol is local. */ - /* Record the first bfd that needs the special sections. */ - if (!htab->elf.dynobj) - htab->elf.dynobj = abfd; +#define MUST_BE_DYN_RELOC(RTYPE) \ + ((RTYPE) != R_PPC_REL24 \ + && (RTYPE) != R_PPC_REL14 \ + && (RTYPE) != R_PPC_REL14_BRTAKEN \ + && (RTYPE) != R_PPC_REL14_BRNTAKEN \ + && (RTYPE) != R_PPC_REL32) - amt = sizeof (elf_linker_section_t); - lsect = bfd_zalloc (htab->elf.dynobj, amt); +/* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid + copying dynamic variables from a shared lib into an app's dynbss + section, and instead use a dynamic relocation to point into the + shared lib. */ +#define ELIMINATE_COPY_RELOCS 1 - lsect->sym_offset = sym_offset; +/* PPC ELF linker hash entry. */ - /* See if the sections already exist. */ - s = bfd_get_section_by_name (htab->elf.dynobj, name); - if (s == NULL || (s->flags & flags) != flags) - { - s = bfd_make_section_anyway (htab->elf.dynobj, name); - if (s == NULL - || !bfd_set_section_flags (htab->elf.dynobj, s, flags)) - return NULL; - } - lsect->section = s; +struct ppc_elf_link_hash_entry +{ + struct elf_link_hash_entry elf; - if (bfd_get_section_alignment (htab->elf.dynobj, s) < 2 - && !bfd_set_section_alignment (htab->elf.dynobj, s, 2)) - return NULL; + /* If this symbol is used in the linker created sections, the processor + specific backend uses this field to map the field into the offset + from the beginning of the section. */ + elf_linker_section_pointers_t *linker_section_pointer; - s->_raw_size = align_power (s->_raw_size, 2); + /* Track dynamic relocs copied for this symbol. */ + struct ppc_elf_dyn_relocs *dyn_relocs; -#ifdef DEBUG - fprintf (stderr, "Creating section %s, current size = %ld\n", - name, (long) s->_raw_size); -#endif + /* Contexts in which symbol is used in the GOT (or TOC). + TLS_GD .. TLS_TLS bits are or'd into the mask as the + corresponding relocs are encountered during check_relocs. + tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to + indicate the corresponding GOT entry type is not needed. */ +#define TLS_GD 1 /* GD reloc. */ +#define TLS_LD 2 /* LD reloc. */ +#define TLS_TPREL 4 /* TPREL reloc, => IE. */ +#define TLS_DTPREL 8 /* DTPREL reloc, => LD. */ +#define TLS_TLS 16 /* Any TLS reloc. */ +#define TLS_TPRELGD 32 /* TPREL reloc resulting from GD->IE. */ + char tls_mask; - if (sym_name) - { - struct elf_link_hash_entry *h; - struct bfd_link_hash_entry *bh; + /* Nonzero if we have seen a small data relocation referring to this + symbol. */ + unsigned char has_sda_refs; +}; -#ifdef DEBUG - fprintf (stderr, "Adding %s to section %s\n", sym_name, name); -#endif - bh = bfd_link_hash_lookup (info->hash, sym_name, - FALSE, FALSE, FALSE); +#define ppc_elf_hash_entry(ent) ((struct ppc_elf_link_hash_entry *) (ent)) + +enum ppc_elf_plt_type { + PLT_UNSET, + PLT_OLD, + PLT_NEW, + PLT_VXWORKS +}; + +/* PPC ELF linker hash table. */ + +struct ppc_elf_link_hash_table +{ + struct elf_link_hash_table elf; + + /* Short-cuts to get to dynamic linker sections. */ + asection *got; + asection *relgot; + asection *glink; + asection *plt; + asection *relplt; + asection *dynbss; + asection *relbss; + asection *dynsbss; + asection *relsbss; + elf_linker_section_t sdata[2]; + asection *sbss; + + /* Shortcut to .__tls_get_addr. */ + struct elf_link_hash_entry *tls_get_addr; + + /* TLS local dynamic got entry handling. */ + union { + bfd_signed_vma refcount; + bfd_vma offset; + } tlsld_got; + + /* Offset of PltResolve function in glink. */ + bfd_vma glink_pltresolve; - if ((bh == NULL || bh->type == bfd_link_hash_undefined) - && !(_bfd_generic_link_add_one_symbol - (info, abfd, sym_name, BSF_GLOBAL, s, sym_offset, NULL, - FALSE, get_elf_backend_data (abfd)->collect, &bh))) - return NULL; - h = (struct elf_link_hash_entry *) bh; + /* Size of reserved GOT entries. */ + unsigned int got_header_size; + /* Non-zero if allocating the header left a gap. */ + unsigned int got_gap; - h->type = STT_OBJECT; - lsect->sym_hash = h; + /* The type of PLT we have chosen to use. */ + enum ppc_elf_plt_type plt_type; - if (info->shared - && ! bfd_elf_link_record_dynamic_symbol (info, h)) - return NULL; + /* Whether we can use the new PLT layout. */ + unsigned int can_use_new_plt:1; + + /* Set if we should emit symbols for stubs. */ + unsigned int emit_stub_syms:1; + + /* Small local sym to section mapping cache. */ + struct sym_sec_cache sym_sec; + + /* The (unloaded but important) .rela.plt.unloaded on VxWorks. */ + asection *srelplt2; + + /* The .got.plt section (VxWorks only)*/ + asection *sgotplt; + + /* True if the target system is VxWorks. */ + int is_vxworks; + + /* The size of PLT entries. */ + int plt_entry_size; + /* The distance between adjacent PLT slots. */ + int plt_slot_size; + /* The size of the first PLT entry. */ + int plt_initial_entry_size; +}; + +/* Get the PPC ELF linker hash table from a link_info structure. */ + +#define ppc_elf_hash_table(p) \ + ((struct ppc_elf_link_hash_table *) (p)->hash) + +/* Create an entry in a PPC ELF linker hash table. */ + +static struct bfd_hash_entry * +ppc_elf_link_hash_newfunc (struct bfd_hash_entry *entry, + struct bfd_hash_table *table, + const char *string) +{ + /* Allocate the structure if it has not already been allocated by a + subclass. */ + if (entry == NULL) + { + entry = bfd_hash_allocate (table, + sizeof (struct ppc_elf_link_hash_entry)); + if (entry == NULL) + return entry; } - if (info->shared) + /* Call the allocation method of the superclass. */ + entry = _bfd_elf_link_hash_newfunc (entry, table, string); + if (entry != NULL) { - s = bfd_make_section_anyway (htab->elf.dynobj, rel_name); - lsect->rel_section = s; - flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY - | SEC_LINKER_CREATED | SEC_READONLY); - if (s == NULL - || ! bfd_set_section_flags (htab->elf.dynobj, s, flags) - || ! bfd_set_section_alignment (htab->elf.dynobj, s, 2)) - return NULL; + ppc_elf_hash_entry (entry)->linker_section_pointer = NULL; + ppc_elf_hash_entry (entry)->dyn_relocs = NULL; + ppc_elf_hash_entry (entry)->tls_mask = 0; } - return lsect; + return entry; } - -/* If we have a non-zero sized .sbss2 or .PPC.EMB.sbss0 sections, we - need to bump up the number of section headers. */ -static int -ppc_elf_additional_program_headers (bfd *abfd) +/* Create a PPC ELF linker hash table. */ + +static struct bfd_link_hash_table * +ppc_elf_link_hash_table_create (bfd *abfd) { - asection *s; - int ret; + struct ppc_elf_link_hash_table *ret; - ret = 0; + ret = bfd_zmalloc (sizeof (struct ppc_elf_link_hash_table)); + if (ret == NULL) + return NULL; - s = bfd_get_section_by_name (abfd, ".interp"); - if (s != NULL) - ++ret; + if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, + ppc_elf_link_hash_newfunc, + sizeof (struct ppc_elf_link_hash_entry))) + { + free (ret); + return NULL; + } - s = bfd_get_section_by_name (abfd, ".sbss2"); - if (s != NULL && (s->flags & SEC_LOAD) != 0 && s->_raw_size > 0) - ++ret; + ret->elf.init_plt_refcount.refcount = 0; + ret->elf.init_plt_refcount.glist = NULL; + ret->elf.init_plt_offset.offset = 0; + ret->elf.init_plt_offset.glist = NULL; - s = bfd_get_section_by_name (abfd, ".PPC.EMB.sbss0"); - if (s != NULL && (s->flags & SEC_LOAD) != 0 && s->_raw_size > 0) - ++ret; + ret->sdata[0].name = ".sdata"; + ret->sdata[0].sym_name = "_SDA_BASE_"; + ret->sdata[0].bss_name = ".sbss"; - return ret; -} + ret->sdata[1].name = ".sdata2"; + ret->sdata[1].sym_name = "_SDA2_BASE_"; + ret->sdata[1].bss_name = ".sbss2"; -/* Modify the segment map if needed. */ + ret->plt_entry_size = 12; + ret->plt_slot_size = 8; + ret->plt_initial_entry_size = 72; + + ret->is_vxworks = 0; -static bfd_boolean -ppc_elf_modify_segment_map (bfd *abfd ATTRIBUTE_UNUSED, - struct bfd_link_info *info ATTRIBUTE_UNUSED) -{ - return TRUE; + return &ret->elf.root; } - -/* The powerpc .got has a blrl instruction in it. Mark it executable. */ + +/* Create .got and the related sections. */ static bfd_boolean ppc_elf_create_got (bfd *abfd, struct bfd_link_info *info) @@ -2756,17 +2477,26 @@ ppc_elf_create_got (bfd *abfd, struct bfd_link_info *info) if (s == NULL) abort (); - flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS | SEC_IN_MEMORY - | SEC_LINKER_CREATED); - if (!bfd_set_section_flags (abfd, s, flags)) - return FALSE; + if (htab->is_vxworks) + { + htab->sgotplt = bfd_get_section_by_name (abfd, ".got.plt"); + if (!htab->sgotplt) + abort (); + } + else + { + /* The powerpc .got has a blrl instruction in it. Mark it + executable. */ + flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS + | SEC_IN_MEMORY | SEC_LINKER_CREATED); + if (!bfd_set_section_flags (abfd, s, flags)) + return FALSE; + } - htab->relgot = bfd_make_section (abfd, ".rela.got"); + flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY + | SEC_LINKER_CREATED | SEC_READONLY); + htab->relgot = bfd_make_section_with_flags (abfd, ".rela.got", flags); if (!htab->relgot - || ! bfd_set_section_flags (abfd, htab->relgot, - (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS - | SEC_IN_MEMORY | SEC_LINKER_CREATED - | SEC_READONLY)) || ! bfd_set_section_alignment (abfd, htab->relgot, 2)) return FALSE; @@ -2793,714 +2523,357 @@ ppc_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info) if (!_bfd_elf_create_dynamic_sections (abfd, info)) return FALSE; - flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY - | SEC_LINKER_CREATED); + flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS + | SEC_IN_MEMORY | SEC_LINKER_CREATED); - htab->dynbss = bfd_get_section_by_name (abfd, ".dynbss"); - htab->dynsbss = s = bfd_make_section (abfd, ".dynsbss"); + s = bfd_make_section_anyway_with_flags (abfd, ".glink", flags | SEC_CODE); + htab->glink = s; if (s == NULL - || ! bfd_set_section_flags (abfd, s, SEC_ALLOC)) + || !bfd_set_section_alignment (abfd, s, 4)) + return FALSE; + + htab->dynbss = bfd_get_section_by_name (abfd, ".dynbss"); + s = bfd_make_section_with_flags (abfd, ".dynsbss", + SEC_ALLOC | SEC_LINKER_CREATED); + htab->dynsbss = s; + if (s == NULL) return FALSE; if (! info->shared) { htab->relbss = bfd_get_section_by_name (abfd, ".rela.bss"); - htab->relsbss = s = bfd_make_section (abfd, ".rela.sbss"); + s = bfd_make_section_with_flags (abfd, ".rela.sbss", flags); + htab->relsbss = s; if (s == NULL - || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY) || ! bfd_set_section_alignment (abfd, s, 2)) return FALSE; } + if (htab->is_vxworks + && !elf_vxworks_create_dynamic_sections (abfd, info, &htab->srelplt2)) + return FALSE; + htab->relplt = bfd_get_section_by_name (abfd, ".rela.plt"); htab->plt = s = bfd_get_section_by_name (abfd, ".plt"); if (s == NULL) abort (); - flags = SEC_ALLOC | SEC_CODE | SEC_IN_MEMORY | SEC_LINKER_CREATED; + flags = SEC_ALLOC | SEC_CODE | SEC_LINKER_CREATED; + if (htab->plt_type == PLT_VXWORKS) + /* The VxWorks PLT is a loaded section with contents. */ + flags |= SEC_HAS_CONTENTS | SEC_LOAD | SEC_READONLY; return bfd_set_section_flags (abfd, s, flags); } -/* Adjust a symbol defined by a dynamic object and referenced by a - regular object. The current definition is in some section of the - dynamic object, but we're not including those sections. We have to - change the definition to something the rest of the link can - understand. */ +/* Copy the extra info we tack onto an elf_link_hash_entry. */ -static bfd_boolean -ppc_elf_adjust_dynamic_symbol (struct bfd_link_info *info, - struct elf_link_hash_entry *h) +static void +ppc_elf_copy_indirect_symbol (struct bfd_link_info *info, + struct elf_link_hash_entry *dir, + struct elf_link_hash_entry *ind) { - struct ppc_elf_link_hash_table *htab; - asection *s; - unsigned int power_of_two; - -#ifdef DEBUG - fprintf (stderr, "ppc_elf_adjust_dynamic_symbol called for %s\n", - h->root.root.string); -#endif + struct ppc_elf_link_hash_entry *edir, *eind; - /* Make sure we know what is going on here. */ - htab = ppc_elf_hash_table (info); - BFD_ASSERT (htab->elf.dynobj != NULL - && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) - || h->weakdef != NULL - || ((h->elf_link_hash_flags - & ELF_LINK_HASH_DEF_DYNAMIC) != 0 - && (h->elf_link_hash_flags - & ELF_LINK_HASH_REF_REGULAR) != 0 - && (h->elf_link_hash_flags - & ELF_LINK_HASH_DEF_REGULAR) == 0))); + edir = (struct ppc_elf_link_hash_entry *) dir; + eind = (struct ppc_elf_link_hash_entry *) ind; - /* Deal with function syms. */ - if (h->type == STT_FUNC - || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0) + if (eind->dyn_relocs != NULL) { - /* Clear procedure linkage table information for any symbol that - won't need a .plt entry. */ - if (h->plt.refcount <= 0 - || SYMBOL_CALLS_LOCAL (info, h) - || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT - && h->root.type == bfd_link_hash_undefweak)) + if (edir->dyn_relocs != NULL) { - /* A PLT entry is not required/allowed when: - - 1. We are not using ld.so; because then the PLT entry - can't be set up, so we can't use one. In this case, - ppc_elf_adjust_dynamic_symbol won't even be called. + struct ppc_elf_dyn_relocs **pp; + struct ppc_elf_dyn_relocs *p; - 2. GC has rendered the entry unused. + /* Add reloc counts against the indirect sym to the direct sym + list. Merge any entries against the same section. */ + for (pp = &eind->dyn_relocs; (p = *pp) != NULL; ) + { + struct ppc_elf_dyn_relocs *q; - 3. We know for certain that a call to this symbol - will go to this object, or will remain undefined. */ - h->plt.offset = (bfd_vma) -1; - h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT; + for (q = edir->dyn_relocs; q != NULL; q = q->next) + if (q->sec == p->sec) + { + q->pc_count += p->pc_count; + q->count += p->count; + *pp = p->next; + break; + } + if (q == NULL) + pp = &p->next; + } + *pp = edir->dyn_relocs; } - return TRUE; - } - else - h->plt.offset = (bfd_vma) -1; - /* If this is a weak symbol, and there is a real definition, the - processor independent code will have arranged for us to see the - real definition first, and we can just use the same value. */ - if (h->weakdef != NULL) - { - BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined - || h->weakdef->root.type == bfd_link_hash_defweak); - h->root.u.def.section = h->weakdef->root.u.def.section; - h->root.u.def.value = h->weakdef->root.u.def.value; - if (ELIMINATE_COPY_RELOCS) - h->elf_link_hash_flags - = ((h->elf_link_hash_flags & ~ELF_LINK_NON_GOT_REF) - | (h->weakdef->elf_link_hash_flags & ELF_LINK_NON_GOT_REF)); - return TRUE; + edir->dyn_relocs = eind->dyn_relocs; + eind->dyn_relocs = NULL; } - /* This is a reference to a symbol defined by a dynamic object which - is not a function. */ + edir->tls_mask |= eind->tls_mask; + edir->has_sda_refs |= eind->has_sda_refs; - /* If we are creating a shared library, we must presume that the - only references to the symbol are via the global offset table. - For such cases we need not do anything here; the relocations will - be handled correctly by relocate_section. */ - if (info->shared) - return TRUE; + /* If called to transfer flags for a weakdef during processing + of elf_adjust_dynamic_symbol, don't copy non_got_ref. + We clear it ourselves for ELIMINATE_COPY_RELOCS. */ + if (!(ELIMINATE_COPY_RELOCS + && eind->elf.root.type != bfd_link_hash_indirect + && edir->elf.dynamic_adjusted)) + edir->elf.non_got_ref |= eind->elf.non_got_ref; - /* If there are no references to this symbol that do not use the - GOT, we don't need to generate a copy reloc. */ - if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0) - return TRUE; + edir->elf.ref_dynamic |= eind->elf.ref_dynamic; + edir->elf.ref_regular |= eind->elf.ref_regular; + edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak; + edir->elf.needs_plt |= eind->elf.needs_plt; - if (ELIMINATE_COPY_RELOCS) - { - struct ppc_elf_dyn_relocs *p; - for (p = ppc_elf_hash_entry (h)->dyn_relocs; p != NULL; p = p->next) - { - s = p->sec->output_section; - if (s != NULL && (s->flags & SEC_READONLY) != 0) - break; - } - - /* If we didn't find any dynamic relocs in read-only sections, then - we'll be keeping the dynamic relocs and avoiding the copy reloc. */ - if (p == NULL) - { - h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF; - return TRUE; - } - } + /* If we were called to copy over info for a weak sym, that's all. */ + if (eind->elf.root.type != bfd_link_hash_indirect) + return; - /* We must allocate the symbol in our .dynbss section, which will - become part of the .bss section of the executable. There will be - an entry for this symbol in the .dynsym section. The dynamic - object will contain position independent code, so all references - from the dynamic object to this symbol will go through the global - offset table. The dynamic linker will use the .dynsym entry to - determine the address it must put in the global offset table, so - both the dynamic object and the regular object will refer to the - same memory location for the variable. + /* Copy over the GOT refcount entries that we may have already seen to + the symbol which just became indirect. */ + edir->elf.got.refcount += eind->elf.got.refcount; + eind->elf.got.refcount = 0; - Of course, if the symbol is sufficiently small, we must instead - allocate it in .sbss. FIXME: It would be better to do this if and - only if there were actually SDAREL relocs for that symbol. */ + /* And plt entries. */ + if (eind->elf.plt.plist != NULL) + { + if (edir->elf.plt.plist != NULL) + { + struct plt_entry **entp; + struct plt_entry *ent; - if (h->size <= elf_gp_size (htab->elf.dynobj)) - s = htab->dynsbss; - else - s = htab->dynbss; - BFD_ASSERT (s != NULL); + for (entp = &eind->elf.plt.plist; (ent = *entp) != NULL; ) + { + struct plt_entry *dent; - /* We must generate a R_PPC_COPY reloc to tell the dynamic linker to - copy the initial value out of the dynamic object and into the - runtime process image. We need to remember the offset into the - .rela.bss section we are going to use. */ - if ((h->root.u.def.section->flags & SEC_ALLOC) != 0) - { - asection *srel; + for (dent = edir->elf.plt.plist; dent != NULL; dent = dent->next) + if (dent->sec == ent->sec && dent->addend == ent->addend) + { + dent->plt.refcount += ent->plt.refcount; + *entp = ent->next; + break; + } + if (dent == NULL) + entp = &ent->next; + } + *entp = edir->elf.plt.plist; + } - if (h->size <= elf_gp_size (htab->elf.dynobj)) - srel = htab->relsbss; - else - srel = htab->relbss; - BFD_ASSERT (srel != NULL); - srel->_raw_size += sizeof (Elf32_External_Rela); - h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY; + edir->elf.plt.plist = eind->elf.plt.plist; + eind->elf.plt.plist = NULL; } - /* We need to figure out the alignment required for this symbol. I - have no idea how ELF linkers handle this. */ - power_of_two = bfd_log2 (h->size); - if (power_of_two > 4) - power_of_two = 4; - - /* Apply the required alignment. */ - s->_raw_size = BFD_ALIGN (s->_raw_size, - (bfd_size_type) (1 << power_of_two)); - if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s)) + if (eind->elf.dynindx != -1) { - if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two)) - return FALSE; + if (edir->elf.dynindx != -1) + _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr, + edir->elf.dynstr_index); + edir->elf.dynindx = eind->elf.dynindx; + edir->elf.dynstr_index = eind->elf.dynstr_index; + eind->elf.dynindx = -1; + eind->elf.dynstr_index = 0; } - - /* Define the symbol as being at this point in the section. */ - h->root.u.def.section = s; - h->root.u.def.value = s->_raw_size; - - /* Increment the section size to make room for the symbol. */ - s->_raw_size += h->size; - - return TRUE; } - -/* Of those relocs that might be copied as dynamic relocs, this macro - selects those that must be copied when linking a shared library, - even when the symbol is local. */ -#define MUST_BE_DYN_RELOC(RTYPE) \ - ((RTYPE) != R_PPC_REL24 \ - && (RTYPE) != R_PPC_REL14 \ - && (RTYPE) != R_PPC_REL14_BRTAKEN \ - && (RTYPE) != R_PPC_REL14_BRNTAKEN \ - && (RTYPE) != R_PPC_REL32) - -/* Allocate space in associated reloc sections for dynamic relocs. */ +/* Return 1 if target is one of ours. */ static bfd_boolean -allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf) +is_ppc_elf_target (const struct bfd_target *targ) { - struct bfd_link_info *info = inf; - struct ppc_elf_link_hash_entry *eh; - struct ppc_elf_link_hash_table *htab; - struct ppc_elf_dyn_relocs *p; + extern const bfd_target bfd_elf32_powerpc_vec; + extern const bfd_target bfd_elf32_powerpc_vxworks_vec; + extern const bfd_target bfd_elf32_powerpcle_vec; - if (h->root.type == bfd_link_hash_indirect) - return TRUE; + return (targ == &bfd_elf32_powerpc_vec + || targ == &bfd_elf32_powerpc_vxworks_vec + || targ == &bfd_elf32_powerpcle_vec); +} - if (h->root.type == bfd_link_hash_warning) - /* When warning symbols are created, they **replace** the "real" - entry in the hash table, thus we never get to see the real - symbol in a hash traversal. So look at it now. */ - h = (struct elf_link_hash_entry *) h->root.u.i.link; +/* Hook called by the linker routine which adds symbols from an object + file. We use it to put .comm items in .sbss, and not .bss. */ - htab = ppc_elf_hash_table (info); - if (htab->elf.dynamic_sections_created - && h->plt.refcount > 0) +static bfd_boolean +ppc_elf_add_symbol_hook (bfd *abfd, + struct bfd_link_info *info, + Elf_Internal_Sym *sym, + const char **namep ATTRIBUTE_UNUSED, + flagword *flagsp ATTRIBUTE_UNUSED, + asection **secp, + bfd_vma *valp) +{ + if (sym->st_shndx == SHN_COMMON + && !info->relocatable + && sym->st_size <= elf_gp_size (abfd) + && is_ppc_elf_target (info->hash->creator)) { - /* Make sure this symbol is output as a dynamic symbol. */ - if (h->dynindx == -1 - && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) - { - if (! bfd_elf_link_record_dynamic_symbol (info, h)) - return FALSE; - } + /* Common symbols less than or equal to -G nn bytes are automatically + put into .sbss. */ + struct ppc_elf_link_hash_table *htab; - if (info->shared - || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h)) + htab = ppc_elf_hash_table (info); + if (htab->sbss == NULL) { - asection *s = htab->plt; - - /* If this is the first .plt entry, make room for the special - first entry. */ - if (s->_raw_size == 0) - s->_raw_size += PLT_INITIAL_ENTRY_SIZE; - - /* The PowerPC PLT is actually composed of two parts, the - first part is 2 words (for a load and a jump), and then - there is a remaining word available at the end. */ - h->plt.offset = (PLT_INITIAL_ENTRY_SIZE - + (PLT_SLOT_SIZE - * ((s->_raw_size - PLT_INITIAL_ENTRY_SIZE) - / PLT_ENTRY_SIZE))); - - /* If this symbol is not defined in a regular file, and we - are not generating a shared library, then set the symbol - to this location in the .plt. This is required to make - function pointers compare as equal between the normal - executable and the shared library. */ - if (! info->shared - && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) - { - h->root.u.def.section = s; - h->root.u.def.value = h->plt.offset; - } + flagword flags = SEC_IS_COMMON | SEC_LINKER_CREATED; - /* Make room for this entry. After the 8192nd entry, room - for two entries is allocated. */ - s->_raw_size += PLT_ENTRY_SIZE; - if ((s->_raw_size - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE - > PLT_NUM_SINGLE_ENTRIES) - s->_raw_size += PLT_ENTRY_SIZE; - - /* We also need to make an entry in the .rela.plt section. */ - htab->relplt->_raw_size += sizeof (Elf32_External_Rela); - } - else - { - h->plt.offset = (bfd_vma) -1; - h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT; - } - } - else - { - h->plt.offset = (bfd_vma) -1; - h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT; - } + if (!htab->elf.dynobj) + htab->elf.dynobj = abfd; - eh = (struct ppc_elf_link_hash_entry *) h; - if (eh->elf.got.refcount > 0) - { - /* Make sure this symbol is output as a dynamic symbol. */ - if (eh->elf.dynindx == -1 - && (eh->elf.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) - { - if (!bfd_elf_link_record_dynamic_symbol (info, &eh->elf)) + htab->sbss = bfd_make_section_anyway_with_flags (htab->elf.dynobj, + ".sbss", + flags); + if (htab->sbss == NULL) return FALSE; } - if (eh->tls_mask == (TLS_TLS | TLS_LD) - && !(eh->elf.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC)) - /* If just an LD reloc, we'll just use htab->tlsld_got.offset. */ - eh->elf.got.offset = (bfd_vma) -1; - else - { - bfd_boolean dyn; - eh->elf.got.offset = htab->got->_raw_size; - if ((eh->tls_mask & TLS_TLS) != 0) - { - if ((eh->tls_mask & TLS_LD) != 0) - htab->got->_raw_size += 8; - if ((eh->tls_mask & TLS_GD) != 0) - htab->got->_raw_size += 8; - if ((eh->tls_mask & (TLS_TPREL | TLS_TPRELGD)) != 0) - htab->got->_raw_size += 4; - if ((eh->tls_mask & TLS_DTPREL) != 0) - htab->got->_raw_size += 4; - } - else - htab->got->_raw_size += 4; - dyn = htab->elf.dynamic_sections_created; - if ((info->shared - || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, &eh->elf)) - && (ELF_ST_VISIBILITY (eh->elf.other) == STV_DEFAULT - || eh->elf.root.type != bfd_link_hash_undefweak)) - { - /* All the entries we allocated need relocs. */ - htab->relgot->_raw_size - += ((htab->got->_raw_size - eh->elf.got.offset) / 4 - * sizeof (Elf32_External_Rela)); - /* Except LD only needs one. */ - if ((eh->tls_mask & TLS_LD) != 0) - htab->relgot->_raw_size -= sizeof (Elf32_External_Rela); - } - } - } - else - eh->elf.got.offset = (bfd_vma) -1; - - if (eh->dyn_relocs == NULL) - return TRUE; - - /* In the shared -Bsymbolic case, discard space allocated for - dynamic pc-relative relocs against symbols which turn out to be - defined in regular objects. For the normal shared case, discard - space for relocs that have become local due to symbol visibility - changes. */ - - if (info->shared) - { - /* Relocs that use pc_count are those that appear on a call insn, - or certain REL relocs (see MUST_BE_DYN_RELOC) that can be - generated via assembly. We want calls to protected symbols to - resolve directly to the function rather than going via the plt. - If people want function pointer comparisons to work as expected - then they should avoid writing weird assembly. */ - if (SYMBOL_CALLS_LOCAL (info, h)) - { - struct ppc_elf_dyn_relocs **pp; - - for (pp = &eh->dyn_relocs; (p = *pp) != NULL; ) - { - p->count -= p->pc_count; - p->pc_count = 0; - if (p->count == 0) - *pp = p->next; - else - pp = &p->next; - } - } - - /* Also discard relocs on undefined weak syms with non-default - visibility. */ - if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT - && h->root.type == bfd_link_hash_undefweak) - eh->dyn_relocs = NULL; - - /* Make sure undefined weak symbols are output as a dynamic symbol - in PIEs. */ - if (info->pie - && eh->dyn_relocs != NULL - && h->dynindx == -1 - && h->root.type == bfd_link_hash_undefweak - && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) - { - if (! bfd_elf_link_record_dynamic_symbol (info, h)) - return FALSE; - } - } - else if (ELIMINATE_COPY_RELOCS) - { - /* For the non-shared case, discard space for relocs against - symbols which turn out to need copy relocs or are not - dynamic. */ - - if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0 - && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0 - && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) - { - /* Make sure this symbol is output as a dynamic symbol. - Undefined weak syms won't yet be marked as dynamic. */ - if (h->dynindx == -1 - && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) - { - if (! bfd_elf_link_record_dynamic_symbol (info, h)) - return FALSE; - } - - /* If that succeeded, we know we'll be keeping all the - relocs. */ - if (h->dynindx != -1) - goto keep; - } - - eh->dyn_relocs = NULL; - - keep: ; - } - - /* Finally, allocate space. */ - for (p = eh->dyn_relocs; p != NULL; p = p->next) - { - asection *sreloc = elf_section_data (p->sec)->sreloc; - sreloc->_raw_size += p->count * sizeof (Elf32_External_Rela); + *secp = htab->sbss; + *valp = sym->st_size; } return TRUE; } + +static bfd_boolean +create_sdata_sym (struct ppc_elf_link_hash_table *htab, + elf_linker_section_t *lsect) +{ + lsect->sym = elf_link_hash_lookup (&htab->elf, lsect->sym_name, + TRUE, FALSE, TRUE); + if (lsect->sym == NULL) + return FALSE; + if (lsect->sym->root.type == bfd_link_hash_new) + lsect->sym->non_elf = 0; + lsect->sym->ref_regular = 1; + return TRUE; +} -/* Find any dynamic relocs that apply to read-only sections. */ +/* Create a special linker section. */ static bfd_boolean -readonly_dynrelocs (struct elf_link_hash_entry *h, void *info) +ppc_elf_create_linker_section (bfd *abfd, + struct bfd_link_info *info, + flagword flags, + elf_linker_section_t *lsect) { - struct ppc_elf_dyn_relocs *p; + struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info); + asection *s; - if (h->root.type == bfd_link_hash_indirect) - return TRUE; + flags |= (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY + | SEC_LINKER_CREATED); - if (h->root.type == bfd_link_hash_warning) - h = (struct elf_link_hash_entry *) h->root.u.i.link; + /* Record the first bfd that needs the special sections. */ + if (!htab->elf.dynobj) + htab->elf.dynobj = abfd; - for (p = ppc_elf_hash_entry (h)->dyn_relocs; p != NULL; p = p->next) - { - asection *s = p->sec->output_section; + s = bfd_make_section_anyway_with_flags (htab->elf.dynobj, + lsect->name, + flags); + if (s == NULL + || !bfd_set_section_alignment (htab->elf.dynobj, s, 2)) + return FALSE; + lsect->section = s; - if (s != NULL - && ((s->flags & (SEC_READONLY | SEC_ALLOC)) - == (SEC_READONLY | SEC_ALLOC))) - { - ((struct bfd_link_info *) info)->flags |= DF_TEXTREL; + return create_sdata_sym (htab, lsect); +} - /* Not an error, just cut short the traversal. */ - return FALSE; - } - } - return TRUE; +/* Find a linker generated pointer with a given addend and type. */ + +static elf_linker_section_pointers_t * +elf_find_pointer_linker_section + (elf_linker_section_pointers_t *linker_pointers, + bfd_vma addend, + elf_linker_section_t *lsect) +{ + for ( ; linker_pointers != NULL; linker_pointers = linker_pointers->next) + if (lsect == linker_pointers->lsect && addend == linker_pointers->addend) + return linker_pointers; + + return NULL; } -/* Set the sizes of the dynamic sections. */ +/* Allocate a pointer to live in a linker created section. */ static bfd_boolean -ppc_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, - struct bfd_link_info *info) +elf_create_pointer_linker_section (bfd *abfd, + elf_linker_section_t *lsect, + struct elf_link_hash_entry *h, + const Elf_Internal_Rela *rel) { - struct ppc_elf_link_hash_table *htab; - asection *s; - bfd_boolean relocs; - bfd *ibfd; - -#ifdef DEBUG - fprintf (stderr, "ppc_elf_size_dynamic_sections called\n"); -#endif + elf_linker_section_pointers_t **ptr_linker_section_ptr = NULL; + elf_linker_section_pointers_t *linker_section_ptr; + unsigned long r_symndx = ELF32_R_SYM (rel->r_info); + bfd_size_type amt; - htab = ppc_elf_hash_table (info); - BFD_ASSERT (htab->elf.dynobj != NULL); + BFD_ASSERT (lsect != NULL); - if (elf_hash_table (info)->dynamic_sections_created) + /* Is this a global symbol? */ + if (h != NULL) { - /* Set the contents of the .interp section to the interpreter. */ - if (info->executable) - { - s = bfd_get_section_by_name (htab->elf.dynobj, ".interp"); - BFD_ASSERT (s != NULL); - s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER; - s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; - } - } + struct ppc_elf_link_hash_entry *eh; - if (htab->tlsld_got.refcount > 0) - { - htab->tlsld_got.offset = htab->got->_raw_size; - htab->got->_raw_size += 8; - if (info->shared) - htab->relgot->_raw_size += sizeof (Elf32_External_Rela); + /* Has this symbol already been allocated? If so, our work is done. */ + eh = (struct ppc_elf_link_hash_entry *) h; + if (elf_find_pointer_linker_section (eh->linker_section_pointer, + rel->r_addend, + lsect)) + return TRUE; + + ptr_linker_section_ptr = &eh->linker_section_pointer; } else - htab->tlsld_got.offset = (bfd_vma) -1; - - /* Set up .got offsets for local syms, and space for local dynamic - relocs. */ - for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next) { - bfd_signed_vma *local_got; - bfd_signed_vma *end_local_got; - char *lgot_masks; - bfd_size_type locsymcount; - Elf_Internal_Shdr *symtab_hdr; - asection *srel; - - if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour) - continue; + /* Allocation of a pointer to a local symbol. */ + elf_linker_section_pointers_t **ptr = elf_local_ptr_offsets (abfd); - for (s = ibfd->sections; s != NULL; s = s->next) + /* Allocate a table to hold the local symbols if first time. */ + if (!ptr) { - struct ppc_elf_dyn_relocs *p; - - for (p = ((struct ppc_elf_dyn_relocs *) - elf_section_data (s)->local_dynrel); - p != NULL; - p = p->next) - { - if (!bfd_is_abs_section (p->sec) - && bfd_is_abs_section (p->sec->output_section)) - { - /* Input section has been discarded, either because - it is a copy of a linkonce section or due to - linker script /DISCARD/, so we'll be discarding - the relocs too. */ - } - else if (p->count != 0) - { - elf_section_data (p->sec)->sreloc->_raw_size - += p->count * sizeof (Elf32_External_Rela); - if ((p->sec->output_section->flags - & (SEC_READONLY | SEC_ALLOC)) - == (SEC_READONLY | SEC_ALLOC)) - info->flags |= DF_TEXTREL; - } - } - } - - local_got = elf_local_got_refcounts (ibfd); - if (!local_got) - continue; - - symtab_hdr = &elf_tdata (ibfd)->symtab_hdr; - locsymcount = symtab_hdr->sh_info; - end_local_got = local_got + locsymcount; - lgot_masks = (char *) end_local_got; - s = htab->got; - srel = htab->relgot; - for (; local_got < end_local_got; ++local_got, ++lgot_masks) - if (*local_got > 0) - { - if (*lgot_masks == (TLS_TLS | TLS_LD)) - { - /* If just an LD reloc, we'll just use - htab->tlsld_got.offset. */ - if (htab->tlsld_got.offset == (bfd_vma) -1) - { - htab->tlsld_got.offset = s->_raw_size; - s->_raw_size += 8; - if (info->shared) - srel->_raw_size += sizeof (Elf32_External_Rela); - } - *local_got = (bfd_vma) -1; - } - else - { - *local_got = s->_raw_size; - if ((*lgot_masks & TLS_TLS) != 0) - { - if ((*lgot_masks & TLS_GD) != 0) - s->_raw_size += 8; - if ((*lgot_masks & (TLS_TPREL | TLS_TPRELGD)) != 0) - s->_raw_size += 4; - if ((*lgot_masks & TLS_DTPREL) != 0) - s->_raw_size += 4; - } - else - s->_raw_size += 4; - if (info->shared) - srel->_raw_size += ((s->_raw_size - *local_got) / 4 - * sizeof (Elf32_External_Rela)); - } - } - else - *local_got = (bfd_vma) -1; - } - - /* Allocate space for global sym dynamic relocs. */ - elf_link_hash_traverse (elf_hash_table (info), allocate_dynrelocs, info); + unsigned int num_symbols = elf_tdata (abfd)->symtab_hdr.sh_info; - /* We've now determined the sizes of the various dynamic sections. - Allocate memory for them. */ - relocs = FALSE; - for (s = htab->elf.dynobj->sections; s != NULL; s = s->next) - { - if ((s->flags & SEC_LINKER_CREATED) == 0) - continue; + amt = num_symbols; + amt *= sizeof (elf_linker_section_pointers_t *); + ptr = bfd_zalloc (abfd, amt); - if (s == htab->plt - || s == htab->got - || (htab->sdata != NULL && s == htab->sdata->section) - || (htab->sdata2 != NULL && s == htab->sdata2->section)) - { - /* Strip this section if we don't need it; see the - comment below. */ - } - else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0) - { - if (s->_raw_size == 0) - { - /* If we don't need this section, strip it from the - output file. This is mostly to handle .rela.bss and - .rela.plt. We must create both sections in - create_dynamic_sections, because they must be created - before the linker maps input sections to output - sections. The linker does that before - adjust_dynamic_symbol is called, and it is that - function which decides whether anything needs to go - into these sections. */ - } - else - { - /* Remember whether there are any relocation sections. */ - relocs = TRUE; + if (!ptr) + return FALSE; - /* We use the reloc_count field as a counter if we need - to copy relocs into the output file. */ - s->reloc_count = 0; - } - } - else - { - /* It's not one of our sections, so don't allocate space. */ - continue; + elf_local_ptr_offsets (abfd) = ptr; } - if (s->_raw_size == 0) - { - _bfd_strip_section_from_output (info, s); - continue; - } + /* Has this symbol already been allocated? If so, our work is done. */ + if (elf_find_pointer_linker_section (ptr[r_symndx], + rel->r_addend, + lsect)) + return TRUE; - /* Allocate memory for the section contents. */ - s->contents = bfd_zalloc (htab->elf.dynobj, s->_raw_size); - if (s->contents == NULL) - return FALSE; + ptr_linker_section_ptr = &ptr[r_symndx]; } - if (htab->elf.dynamic_sections_created) - { - /* Add some entries to the .dynamic section. We fill in the - values later, in ppc_elf_finish_dynamic_sections, but we - must add the entries now so that we get the correct size for - the .dynamic section. The DT_DEBUG entry is filled in by the - dynamic linker and used by the debugger. */ -#define add_dynamic_entry(TAG, VAL) \ - _bfd_elf_add_dynamic_entry (info, TAG, VAL) - - if (info->executable) - { - if (!add_dynamic_entry (DT_DEBUG, 0)) - return FALSE; - } + /* Allocate space for a pointer in the linker section, and allocate + a new pointer record from internal memory. */ + BFD_ASSERT (ptr_linker_section_ptr != NULL); + amt = sizeof (elf_linker_section_pointers_t); + linker_section_ptr = bfd_alloc (abfd, amt); - if (htab->plt != NULL && htab->plt->_raw_size != 0) - { - if (!add_dynamic_entry (DT_PLTGOT, 0) - || !add_dynamic_entry (DT_PLTRELSZ, 0) - || !add_dynamic_entry (DT_PLTREL, DT_RELA) - || !add_dynamic_entry (DT_JMPREL, 0)) - return FALSE; - } + if (!linker_section_ptr) + return FALSE; - if (relocs) - { - if (!add_dynamic_entry (DT_RELA, 0) - || !add_dynamic_entry (DT_RELASZ, 0) - || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela))) - return FALSE; - } + linker_section_ptr->next = *ptr_linker_section_ptr; + linker_section_ptr->addend = rel->r_addend; + linker_section_ptr->lsect = lsect; + *ptr_linker_section_ptr = linker_section_ptr; - /* If any dynamic relocs apply to a read-only section, then we - need a DT_TEXTREL entry. */ - if ((info->flags & DF_TEXTREL) == 0) - elf_link_hash_traverse (elf_hash_table (info), readonly_dynrelocs, - info); + linker_section_ptr->offset = lsect->section->size; + lsect->section->size += 4; - if ((info->flags & DF_TEXTREL) != 0) - { - if (!add_dynamic_entry (DT_TEXTREL, 0)) - return FALSE; - } - } -#undef add_dynamic_entry +#ifdef DEBUG + fprintf (stderr, + "Create pointer in linker section %s, offset = %ld, section size = %ld\n", + lsect->name, (long) linker_section_ptr->offset, + (long) lsect->section->size); +#endif return TRUE; } - + static bfd_boolean update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr, @@ -3527,12 +2900,52 @@ update_local_sym_info (bfd *abfd, return TRUE; } +static bfd_boolean +update_plt_info (bfd *abfd, struct elf_link_hash_entry *h, + asection *sec, bfd_vma addend) +{ + struct plt_entry *ent; + + if (addend < 32768) + sec = NULL; + for (ent = h->plt.plist; ent != NULL; ent = ent->next) + if (ent->sec == sec && ent->addend == addend) + break; + if (ent == NULL) + { + bfd_size_type amt = sizeof (*ent); + ent = bfd_alloc (abfd, amt); + if (ent == NULL) + return FALSE; + ent->next = h->plt.plist; + ent->sec = sec; + ent->addend = addend; + ent->plt.refcount = 0; + h->plt.plist = ent; + } + ent->plt.refcount += 1; + return TRUE; +} + +static struct plt_entry * +find_plt_ent (struct elf_link_hash_entry *h, asection *sec, bfd_vma addend) +{ + struct plt_entry *ent; + + if (addend < 32768) + sec = NULL; + for (ent = h->plt.plist; ent != NULL; ent = ent->next) + if (ent->sec == sec && ent->addend == addend) + break; + return ent; +} + static void bad_shared_reloc (bfd *abfd, enum elf_ppc_reloc_type r_type) { (*_bfd_error_handler) - (_("%s: relocation %s cannot be used when making a shared object"), - bfd_archive_filename (abfd), + (_("%B: relocation %s cannot be used when making a shared object"), + abfd, ppc_elf_howto_table[r_type]->name); bfd_set_error (bfd_error_bad_value); } @@ -3552,42 +2965,33 @@ ppc_elf_check_relocs (bfd *abfd, struct elf_link_hash_entry **sym_hashes; const Elf_Internal_Rela *rel; const Elf_Internal_Rela *rel_end; - asection *sreloc; + asection *got2, *sreloc; if (info->relocatable) return TRUE; + /* Don't do anything special with non-loaded, non-alloced sections. + In particular, any relocs in such sections should not affect GOT + and PLT reference counting (ie. we don't allow them to create GOT + or PLT entries), there's no possibility or desire to optimize TLS + relocs, and there's not much point in propagating relocs to shared + libs that the dynamic linker won't relocate. */ + if ((sec->flags & SEC_ALLOC) == 0) + return TRUE; + #ifdef DEBUG - fprintf (stderr, "ppc_elf_check_relocs called for section %s in %s\n", - bfd_get_section_name (abfd, sec), - bfd_archive_filename (abfd)); + _bfd_error_handler ("ppc_elf_check_relocs called for section %A in %B", + sec, abfd); #endif /* Initialize howto table if not already done. */ if (!ppc_elf_howto_table[R_PPC_ADDR32]) ppc_elf_howto_init (); - /* Create the linker generated sections all the time so that the - special symbols are created. */ htab = ppc_elf_hash_table (info); - if (htab->sdata == NULL) - { - htab->sdata = ppc_elf_create_linker_section (abfd, info, - LINKER_SECTION_SDATA); - if (htab->sdata == NULL) - return FALSE; - } - - if (htab->sdata2 == NULL) - { - htab->sdata2 = ppc_elf_create_linker_section (abfd, info, - LINKER_SECTION_SDATA2); - if (htab->sdata2 == NULL) - return FALSE; - } - symtab_hdr = &elf_tdata (abfd)->symtab_hdr; sym_hashes = elf_sym_hashes (abfd); + got2 = bfd_get_section_by_name (abfd, ".got2"); sreloc = NULL; rel_end = relocs + sec->reloc_count; @@ -3602,20 +3006,25 @@ ppc_elf_check_relocs (bfd *abfd, if (r_symndx < symtab_hdr->sh_info) h = NULL; else - h = sym_hashes[r_symndx - symtab_hdr->sh_info]; + { + h = sym_hashes[r_symndx - symtab_hdr->sh_info]; + while (h->root.type == bfd_link_hash_indirect + || h->root.type == bfd_link_hash_warning) + h = (struct elf_link_hash_entry *) h->root.u.i.link; + } /* If a relocation refers to _GLOBAL_OFFSET_TABLE_, create the .got. This shows up in particular in an R_PPC_ADDR32 in the eabi startup code. */ - if (h && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) + if (h != NULL + && htab->got == NULL + && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) { - if (htab->got == NULL) - { - if (htab->elf.dynobj == NULL) - htab->elf.dynobj = abfd; - if (!ppc_elf_create_got (htab->elf.dynobj, info)) - return FALSE; - } + if (htab->elf.dynobj == NULL) + htab->elf.dynobj = abfd; + if (!ppc_elf_create_got (htab->elf.dynobj, info)) + return FALSE; + BFD_ASSERT (h == htab->elf.hgot); } r_type = ELF32_R_TYPE (rel->r_info); @@ -3685,9 +3094,18 @@ ppc_elf_check_relocs (bfd *abfd, bad_shared_reloc (abfd, r_type); return FALSE; } - if (!elf_create_pointer_linker_section (abfd, info, - htab->sdata, h, rel)) + if (htab->sdata[0].section == NULL + && !ppc_elf_create_linker_section (abfd, info, 0, + &htab->sdata[0])) return FALSE; + if (!elf_create_pointer_linker_section (abfd, &htab->sdata[0], + h, rel)) + return FALSE; + if (h != NULL) + { + ppc_elf_hash_entry (h)->has_sda_refs = TRUE; + h->non_got_ref = TRUE; + } break; /* Indirect .sdata2 relocation. */ @@ -3697,15 +3115,72 @@ ppc_elf_check_relocs (bfd *abfd, bad_shared_reloc (abfd, r_type); return FALSE; } - if (!elf_create_pointer_linker_section (abfd, info, - htab->sdata2, h, rel)) + if (htab->sdata[1].section == NULL + && !ppc_elf_create_linker_section (abfd, info, SEC_READONLY, + &htab->sdata[1])) return FALSE; + if (!elf_create_pointer_linker_section (abfd, &htab->sdata[1], + h, rel)) + return FALSE; + if (h != NULL) + { + ppc_elf_hash_entry (h)->has_sda_refs = TRUE; + h->non_got_ref = TRUE; + } break; case R_PPC_SDAREL16: + if (info->shared) + { + bad_shared_reloc (abfd, r_type); + return FALSE; + } + if (htab->sdata[0].sym == NULL + && !create_sdata_sym (htab, &htab->sdata[0])) + return FALSE; + if (h != NULL) + { + ppc_elf_hash_entry (h)->has_sda_refs = TRUE; + h->non_got_ref = TRUE; + } + break; + case R_PPC_EMB_SDA2REL: + if (info->shared) + { + bad_shared_reloc (abfd, r_type); + return FALSE; + } + if (htab->sdata[1].sym == NULL + && !create_sdata_sym (htab, &htab->sdata[1])) + return FALSE; + if (h != NULL) + { + ppc_elf_hash_entry (h)->has_sda_refs = TRUE; + h->non_got_ref = TRUE; + } + break; + case R_PPC_EMB_SDA21: case R_PPC_EMB_RELSDA: + if (info->shared) + { + bad_shared_reloc (abfd, r_type); + return FALSE; + } + if (htab->sdata[0].sym == NULL + && !create_sdata_sym (htab, &htab->sdata[0])) + return FALSE; + if (htab->sdata[1].sym == NULL + && !create_sdata_sym (htab, &htab->sdata[1])) + return FALSE; + if (h != NULL) + { + ppc_elf_hash_entry (h)->has_sda_refs = TRUE; + h->non_got_ref = TRUE; + } + break; + case R_PPC_EMB_NADDR32: case R_PPC_EMB_NADDR16: case R_PPC_EMB_NADDR16_LO: @@ -3716,6 +3191,8 @@ ppc_elf_check_relocs (bfd *abfd, bad_shared_reloc (abfd, r_type); return FALSE; } + if (h != NULL) + h->non_got_ref = TRUE; break; case R_PPC_PLT32: @@ -3737,18 +3214,23 @@ ppc_elf_check_relocs (bfd *abfd, { /* It does not make sense to have a procedure linkage table entry for a local symbol. */ - (*_bfd_error_handler) (_("%s(%s+0x%lx): %s reloc against " + (*_bfd_error_handler) (_("%B(%A+0x%lx): %s reloc against " "local symbol"), - bfd_archive_filename (abfd), - sec->name, + abfd, + sec, (long) rel->r_offset, ppc_elf_howto_table[r_type]->name); bfd_set_error (bfd_error_bad_value); return FALSE; } + else + { + bfd_vma addend = r_type == R_PPC_PLTREL24 ? rel->r_addend : 0; - h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT; - h->plt.refcount++; + h->needs_plt = 1; + if (!update_plt_info (abfd, h, got2, addend)) + return FALSE; + } break; /* The following relocations don't need to propagate the @@ -3765,7 +3247,14 @@ ppc_elf_check_relocs (bfd *abfd, case R_PPC_TOC16: break; - /* This are just markers. */ + case R_PPC_REL16: + case R_PPC_REL16_LO: + case R_PPC_REL16_HI: + case R_PPC_REL16_HA: + htab->can_use_new_plt = 1; + break; + + /* These are just markers. */ case R_PPC_TLS: case R_PPC_EMB_MRKREF: case R_PPC_NONE: @@ -3790,6 +3279,8 @@ ppc_elf_check_relocs (bfd *abfd, /* This refers only to functions defined in the shared library. */ case R_PPC_LOCAL24PC: + if (h && h == htab->elf.hgot && htab->plt_type == PLT_UNSET) + htab->plt_type = PLT_OLD; break; /* This relocation describes the C++ object vtable hierarchy. @@ -3825,17 +3316,42 @@ ppc_elf_check_relocs (bfd *abfd, info->flags |= DF_STATIC_TLS; goto dodyn; - /* When creating a shared object, we must copy these - relocs into the output file. We create a reloc - section in dynobj and make room for the reloc. */ + case R_PPC_REL32: + if (h == NULL + && got2 != NULL + && (sec->flags & SEC_CODE) != 0 + && (info->shared || info->pie) + && htab->plt_type == PLT_UNSET) + { + /* Old -fPIC gcc code has .long LCTOC1-LCFx just before + the start of a function, which assembles to a REL32 + reference to .got2. If we detect one of these, then + force the old PLT layout because the linker cannot + reliably deduce the GOT pointer value needed for + PLT call stubs. */ + asection *s; + + s = bfd_section_from_r_symndx (abfd, &htab->sym_sec, sec, + r_symndx); + if (s == got2) + htab->plt_type = PLT_OLD; + } + if (h == NULL || h == htab->elf.hgot) + break; + goto dodyn1; + case R_PPC_REL24: case R_PPC_REL14: case R_PPC_REL14_BRTAKEN: case R_PPC_REL14_BRNTAKEN: - case R_PPC_REL32: - if (h == NULL - || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) + if (h == NULL) break; + if (h == htab->elf.hgot) + { + if (htab->plt_type == PLT_UNSET) + htab->plt_type = PLT_OLD; + break; + } /* fall through */ case R_PPC_ADDR32: @@ -3849,14 +3365,16 @@ ppc_elf_check_relocs (bfd *abfd, case R_PPC_ADDR14_BRNTAKEN: case R_PPC_UADDR32: case R_PPC_UADDR16: + dodyn1: if (h != NULL && !info->shared) { /* We may need a plt entry if the symbol turns out to be a function defined in a dynamic object. */ - h->plt.refcount++; + if (!update_plt_info (abfd, h, NULL, 0)) + return FALSE; /* We may need a copy reloc too. */ - h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF; + h->non_got_ref = 1; } dodyn: @@ -3886,15 +3404,12 @@ ppc_elf_check_relocs (bfd *abfd, || (h != NULL && (! info->symbolic || h->root.type == bfd_link_hash_defweak - || (h->elf_link_hash_flags - & ELF_LINK_HASH_DEF_REGULAR) == 0)))) + || !h->def_regular)))) || (ELIMINATE_COPY_RELOCS && !info->shared - && (sec->flags & SEC_ALLOC) != 0 && h != NULL && (h->root.type == bfd_link_hash_defweak - || (h->elf_link_hash_flags - & ELF_LINK_HASH_DEF_REGULAR) == 0))) + || !h->def_regular))) { struct ppc_elf_dyn_relocs *p; struct ppc_elf_dyn_relocs **head; @@ -3921,19 +3436,20 @@ ppc_elf_check_relocs (bfd *abfd, && strcmp (bfd_get_section_name (abfd, sec), name + 5) == 0); + if (htab->elf.dynobj == NULL) + htab->elf.dynobj = abfd; sreloc = bfd_get_section_by_name (htab->elf.dynobj, name); if (sreloc == NULL) { flagword flags; - sreloc = bfd_make_section (htab->elf.dynobj, name); flags = (SEC_HAS_CONTENTS | SEC_READONLY - | SEC_IN_MEMORY | SEC_LINKER_CREATED); - if ((sec->flags & SEC_ALLOC) != 0) - flags |= SEC_ALLOC | SEC_LOAD; + | SEC_IN_MEMORY | SEC_LINKER_CREATED + | SEC_ALLOC | SEC_LOAD); + sreloc = bfd_make_section_with_flags (htab->elf.dynobj, + name, + flags); if (sreloc == NULL - || ! bfd_set_section_flags (htab->elf.dynobj, - sreloc, flags) || ! bfd_set_section_alignment (htab->elf.dynobj, sreloc, 2)) return FALSE; @@ -3954,13 +3470,15 @@ ppc_elf_check_relocs (bfd *abfd, easily. Oh well. */ asection *s; + void *vpp; + s = bfd_section_from_r_symndx (abfd, &htab->sym_sec, sec, r_symndx); if (s == NULL) return FALSE; - head = ((struct ppc_elf_dyn_relocs **) - &elf_section_data (s)->local_dynrel); + vpp = &elf_section_data (s)->local_dynrel; + head = (struct ppc_elf_dyn_relocs **) vpp; } p = *head; @@ -3987,7 +3505,145 @@ ppc_elf_check_relocs (bfd *abfd, return TRUE; } + +/* Merge backend specific data from an object file to the output + object file when linking. */ + +static bfd_boolean +ppc_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd) +{ + flagword old_flags; + flagword new_flags; + bfd_boolean error; + + if (!is_ppc_elf_target (ibfd->xvec) + || !is_ppc_elf_target (obfd->xvec)) + return TRUE; + + /* Check if we have the same endianess. */ + if (! _bfd_generic_verify_endian_match (ibfd, obfd)) + return FALSE; + + new_flags = elf_elfheader (ibfd)->e_flags; + old_flags = elf_elfheader (obfd)->e_flags; + if (!elf_flags_init (obfd)) + { + /* First call, no flags set. */ + elf_flags_init (obfd) = TRUE; + elf_elfheader (obfd)->e_flags = new_flags; + } + + /* Compatible flags are ok. */ + else if (new_flags == old_flags) + ; + + /* Incompatible flags. */ + else + { + /* Warn about -mrelocatable mismatch. Allow -mrelocatable-lib + to be linked with either. */ + error = FALSE; + if ((new_flags & EF_PPC_RELOCATABLE) != 0 + && (old_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0) + { + error = TRUE; + (*_bfd_error_handler) + (_("%B: compiled with -mrelocatable and linked with " + "modules compiled normally"), ibfd); + } + else if ((new_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0 + && (old_flags & EF_PPC_RELOCATABLE) != 0) + { + error = TRUE; + (*_bfd_error_handler) + (_("%B: compiled normally and linked with " + "modules compiled with -mrelocatable"), ibfd); + } + + /* The output is -mrelocatable-lib iff both the input files are. */ + if (! (new_flags & EF_PPC_RELOCATABLE_LIB)) + elf_elfheader (obfd)->e_flags &= ~EF_PPC_RELOCATABLE_LIB; + + /* The output is -mrelocatable iff it can't be -mrelocatable-lib, + but each input file is either -mrelocatable or -mrelocatable-lib. */ + if (! (elf_elfheader (obfd)->e_flags & EF_PPC_RELOCATABLE_LIB) + && (new_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE)) + && (old_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE))) + elf_elfheader (obfd)->e_flags |= EF_PPC_RELOCATABLE; + + /* Do not warn about eabi vs. V.4 mismatch, just or in the bit if + any module uses it. */ + elf_elfheader (obfd)->e_flags |= (new_flags & EF_PPC_EMB); + + new_flags &= ~(EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB); + old_flags &= ~(EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB); + + /* Warn about any other mismatches. */ + if (new_flags != old_flags) + { + error = TRUE; + (*_bfd_error_handler) + (_("%B: uses different e_flags (0x%lx) fields " + "than previous modules (0x%lx)"), + ibfd, (long) new_flags, (long) old_flags); + } + + if (error) + { + bfd_set_error (bfd_error_bad_value); + return FALSE; + } + } + + return TRUE; +} + +/* Choose which PLT scheme to use, and set .plt flags appropriately. + Returns -1 on error, 0 for old PLT, 1 for new PLT. */ +int +ppc_elf_select_plt_layout (bfd *output_bfd ATTRIBUTE_UNUSED, + struct bfd_link_info *info, + int force_old_plt, + int emit_stub_syms) +{ + struct ppc_elf_link_hash_table *htab; + flagword flags; + + htab = ppc_elf_hash_table (info); + + if (htab->plt_type == PLT_UNSET) + htab->plt_type = (force_old_plt || !htab->can_use_new_plt + ? PLT_OLD : PLT_NEW); + + htab->emit_stub_syms = emit_stub_syms; + + BFD_ASSERT (htab->plt_type != PLT_VXWORKS); + if (htab->plt_type == PLT_NEW) + { + flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS + | SEC_IN_MEMORY | SEC_LINKER_CREATED); + + /* The new PLT is a loaded section. */ + if (htab->plt != NULL + && !bfd_set_section_flags (htab->elf.dynobj, htab->plt, flags)) + return -1; + + /* The new GOT is not executable. */ + if (htab->got != NULL + && !bfd_set_section_flags (htab->elf.dynobj, htab->got, flags)) + return -1; + } + else + { + /* Stop an unused .glink section from affecting .text alignment. */ + if (htab->glink != NULL + && !bfd_set_section_alignment (htab->elf.dynobj, htab->glink, 0)) + return -1; + } + return htab->plt_type == PLT_NEW; +} + /* Return the section that should be marked against GC for a given relocation. */ @@ -4041,6 +3697,10 @@ ppc_elf_gc_sweep_hook (bfd *abfd, struct elf_link_hash_entry **sym_hashes; bfd_signed_vma *local_got_refcounts; const Elf_Internal_Rela *rel, *relend; + asection *got2; + + if ((sec->flags & SEC_ALLOC) == 0) + return TRUE; elf_section_data (sec)->local_dynrel = NULL; @@ -4048,6 +3708,7 @@ ppc_elf_gc_sweep_hook (bfd *abfd, symtab_hdr = &elf_tdata (abfd)->symtab_hdr; sym_hashes = elf_sym_hashes (abfd); local_got_refcounts = elf_local_got_refcounts (abfd); + got2 = bfd_get_section_by_name (abfd, ".got2"); relend = relocs + sec->reloc_count; for (rel = relocs; rel < relend; rel++) @@ -4063,6 +3724,9 @@ ppc_elf_gc_sweep_hook (bfd *abfd, struct ppc_elf_link_hash_entry *eh; h = sym_hashes[r_symndx - symtab_hdr->sh_info]; + while (h->root.type == bfd_link_hash_indirect + || h->root.type == bfd_link_hash_warning) + h = (struct elf_link_hash_entry *) h->root.u.i.link; eh = (struct ppc_elf_link_hash_entry *) h; for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next) @@ -4117,8 +3781,7 @@ ppc_elf_gc_sweep_hook (bfd *abfd, case R_PPC_REL14_BRTAKEN: case R_PPC_REL14_BRNTAKEN: case R_PPC_REL32: - if (h == NULL - || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) + if (h == NULL || h == htab->elf.hgot) break; /* Fall thru */ @@ -4133,15 +3796,21 @@ ppc_elf_gc_sweep_hook (bfd *abfd, case R_PPC_ADDR14_BRNTAKEN: case R_PPC_UADDR32: case R_PPC_UADDR16: + if (info->shared) + break; + case R_PPC_PLT32: case R_PPC_PLTREL24: + case R_PPC_PLTREL32: case R_PPC_PLT16_LO: case R_PPC_PLT16_HI: case R_PPC_PLT16_HA: if (h != NULL) { - if (h->plt.refcount > 0) - h->plt.refcount--; + bfd_vma addend = r_type == R_PPC_PLTREL24 ? rel->r_addend : 0; + struct plt_entry *ent = find_plt_ent (h, got2, addend); + if (ent->plt.refcount > 0) + ent->plt.refcount -= 1; } break; @@ -4151,7 +3820,7 @@ ppc_elf_gc_sweep_hook (bfd *abfd, } return TRUE; } - + /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */ asection * @@ -4160,9 +3829,16 @@ ppc_elf_tls_setup (bfd *obfd, struct bfd_link_info *info) struct ppc_elf_link_hash_table *htab; htab = ppc_elf_hash_table (info); + if (htab->plt_type == PLT_NEW + && htab->plt != NULL + && htab->plt->output_section != NULL) + { + elf_section_type (htab->plt->output_section) = SHT_PROGBITS; + elf_section_flags (htab->plt->output_section) = SHF_ALLOC + SHF_WRITE; + } + htab->tls_get_addr = elf_link_hash_lookup (&htab->elf, "__tls_get_addr", FALSE, FALSE, TRUE); - return _bfd_elf_tls_setup (obfd, info); } @@ -4223,7 +3899,7 @@ ppc_elf_tls_optimize (bfd *obfd ATTRIBUTE_UNUSED, is_local = FALSE; if (h == NULL - || !(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC)) + || !h->def_dynamic) is_local = TRUE; r_type = ELF32_R_TYPE (rel->r_info); @@ -4284,8 +3960,9 @@ ppc_elf_tls_optimize (bfd *obfd ATTRIBUTE_UNUSED, && h != NULL && h == htab->tls_get_addr) { - if (h->plt.refcount > 0) - h->plt.refcount -= 1; + struct plt_entry *ent = find_plt_ent (h, NULL, 0); + if (ent != NULL && ent->plt.refcount > 0) + ent->plt.refcount -= 1; } expecting_tls_get_addr = 0; continue; @@ -4359,230 +4036,1439 @@ ppc_elf_tls_optimize (bfd *obfd ATTRIBUTE_UNUSED, return TRUE; } -/* Hook called by the linker routine which adds symbols from an object - file. We use it to put .comm items in .sbss, and not .bss. */ +/* Adjust a symbol defined by a dynamic object and referenced by a + regular object. The current definition is in some section of the + dynamic object, but we're not including those sections. We have to + change the definition to something the rest of the link can + understand. */ static bfd_boolean -ppc_elf_add_symbol_hook (bfd *abfd, - struct bfd_link_info *info, - Elf_Internal_Sym *sym, - const char **namep ATTRIBUTE_UNUSED, - flagword *flagsp ATTRIBUTE_UNUSED, - asection **secp, - bfd_vma *valp) +ppc_elf_adjust_dynamic_symbol (struct bfd_link_info *info, + struct elf_link_hash_entry *h) { - if (sym->st_shndx == SHN_COMMON - && !info->relocatable - && sym->st_size <= elf_gp_size (abfd) - && (info->hash->creator == abfd->xvec - || info->hash->creator == abfd->xvec->alternative_target)) + struct ppc_elf_link_hash_table *htab; + asection *s; + unsigned int power_of_two; + +#ifdef DEBUG + fprintf (stderr, "ppc_elf_adjust_dynamic_symbol called for %s\n", + h->root.root.string); +#endif + + /* Make sure we know what is going on here. */ + htab = ppc_elf_hash_table (info); + BFD_ASSERT (htab->elf.dynobj != NULL + && (h->needs_plt + || h->u.weakdef != NULL + || (h->def_dynamic + && h->ref_regular + && !h->def_regular))); + + /* Deal with function syms. */ + if (h->type == STT_FUNC + || h->needs_plt) { - /* Common symbols less than or equal to -G nn bytes are automatically - put into .sbss. */ - struct ppc_elf_link_hash_table *htab; + /* Clear procedure linkage table information for any symbol that + won't need a .plt entry. */ + struct plt_entry *ent; + for (ent = h->plt.plist; ent != NULL; ent = ent->next) + if (ent->plt.refcount > 0) + break; + if (ent == NULL + || SYMBOL_CALLS_LOCAL (info, h) + || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT + && h->root.type == bfd_link_hash_undefweak)) + { + /* A PLT entry is not required/allowed when: - htab = ppc_elf_hash_table (info); - if (htab->sbss == NULL) + 1. We are not using ld.so; because then the PLT entry + can't be set up, so we can't use one. In this case, + ppc_elf_adjust_dynamic_symbol won't even be called. + + 2. GC has rendered the entry unused. + + 3. We know for certain that a call to this symbol + will go to this object, or will remain undefined. */ + h->plt.plist = NULL; + h->needs_plt = 0; + } + return TRUE; + } + else + h->plt.plist = NULL; + + /* If this is a weak symbol, and there is a real definition, the + processor independent code will have arranged for us to see the + real definition first, and we can just use the same value. */ + if (h->u.weakdef != NULL) + { + BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined + || h->u.weakdef->root.type == bfd_link_hash_defweak); + h->root.u.def.section = h->u.weakdef->root.u.def.section; + h->root.u.def.value = h->u.weakdef->root.u.def.value; + if (ELIMINATE_COPY_RELOCS) + h->non_got_ref = h->u.weakdef->non_got_ref; + return TRUE; + } + + /* This is a reference to a symbol defined by a dynamic object which + is not a function. */ + + /* If we are creating a shared library, we must presume that the + only references to the symbol are via the global offset table. + For such cases we need not do anything here; the relocations will + be handled correctly by relocate_section. */ + if (info->shared) + return TRUE; + + /* If there are no references to this symbol that do not use the + GOT, we don't need to generate a copy reloc. */ + if (!h->non_got_ref) + return TRUE; + + /* If we didn't find any dynamic relocs in read-only sections, then we'll + be keeping the dynamic relocs and avoiding the copy reloc. We can't + do this if there are any small data relocations. */ + if (ELIMINATE_COPY_RELOCS + && !ppc_elf_hash_entry (h)->has_sda_refs) + { + struct ppc_elf_dyn_relocs *p; + for (p = ppc_elf_hash_entry (h)->dyn_relocs; p != NULL; p = p->next) { - flagword flags = SEC_IS_COMMON; + s = p->sec->output_section; + if (s != NULL && (s->flags & SEC_READONLY) != 0) + break; + } - htab->sbss = bfd_make_section_anyway (abfd, ".sbss"); - if (htab->sbss == NULL - || ! bfd_set_section_flags (abfd, htab->sbss, flags)) - return FALSE; + if (p == NULL) + { + h->non_got_ref = 0; + return TRUE; } + } - *secp = htab->sbss; - *valp = sym->st_size; + if (h->size == 0) + { + (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"), + h->root.root.string); + return TRUE; } + /* We must allocate the symbol in our .dynbss section, which will + become part of the .bss section of the executable. There will be + an entry for this symbol in the .dynsym section. The dynamic + object will contain position independent code, so all references + from the dynamic object to this symbol will go through the global + offset table. The dynamic linker will use the .dynsym entry to + determine the address it must put in the global offset table, so + both the dynamic object and the regular object will refer to the + same memory location for the variable. + + Of course, if the symbol is referenced using SDAREL relocs, we + must instead allocate it in .sbss. */ + + if (ppc_elf_hash_entry (h)->has_sda_refs) + s = htab->dynsbss; + else + s = htab->dynbss; + BFD_ASSERT (s != NULL); + + /* We must generate a R_PPC_COPY reloc to tell the dynamic linker to + copy the initial value out of the dynamic object and into the + runtime process image. We need to remember the offset into the + .rela.bss section we are going to use. */ + if ((h->root.u.def.section->flags & SEC_ALLOC) != 0) + { + asection *srel; + + if (ppc_elf_hash_entry (h)->has_sda_refs) + srel = htab->relsbss; + else + srel = htab->relbss; + BFD_ASSERT (srel != NULL); + srel->size += sizeof (Elf32_External_Rela); + h->needs_copy = 1; + } + + /* We need to figure out the alignment required for this symbol. I + have no idea how ELF linkers handle this. */ + power_of_two = bfd_log2 (h->size); + if (power_of_two > 4) + power_of_two = 4; + + /* Apply the required alignment. */ + s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two)); + if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s)) + { + if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two)) + return FALSE; + } + + /* Define the symbol as being at this point in the section. */ + h->root.u.def.section = s; + h->root.u.def.value = s->size; + + /* Increment the section size to make room for the symbol. */ + s->size += h->size; + return TRUE; } -/* Finish up dynamic symbol handling. We set the contents of various - dynamic sections here. */ +/* Generate a symbol to mark plt call stubs. For non-PIC code the sym is + xxxxxxxx.plt_call32.<callee> where xxxxxxxx is a hex number, usually 0, + specifying the addend on the plt relocation. For -fpic code, the sym + is xxxxxxxx.plt_pic32.<callee>, and for -fPIC + xxxxxxxx.got2.plt_pic32.<callee>. */ static bfd_boolean -ppc_elf_finish_dynamic_symbol (bfd *output_bfd, - struct bfd_link_info *info, - struct elf_link_hash_entry *h, - Elf_Internal_Sym *sym) +add_stub_sym (struct plt_entry *ent, + struct elf_link_hash_entry *h, + struct bfd_link_info *info) { + struct elf_link_hash_entry *sh; + size_t len1, len2, len3; + char *name; + const char *stub; + struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info); + + if (info->shared || info->pie) + stub = ".plt_pic32."; + else + stub = ".plt_call32."; + + len1 = strlen (h->root.root.string); + len2 = strlen (stub); + len3 = 0; + if (ent->sec) + len3 = strlen (ent->sec->name); + name = bfd_malloc (len1 + len2 + len3 + 9); + if (name == NULL) + return FALSE; + sprintf (name, "%08x", (unsigned) ent->addend & 0xffffffff); + if (ent->sec) + memcpy (name + 8, ent->sec->name, len3); + memcpy (name + 8 + len3, stub, len2); + memcpy (name + 8 + len3 + len2, h->root.root.string, len1 + 1); + sh = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE); + if (sh == NULL) + return FALSE; + if (sh->root.type == bfd_link_hash_new) + { + sh->root.type = bfd_link_hash_defined; + sh->root.u.def.section = htab->glink; + sh->root.u.def.value = ent->glink_offset; + sh->ref_regular = 1; + sh->def_regular = 1; + sh->ref_regular_nonweak = 1; + sh->forced_local = 1; + sh->non_elf = 0; + } + return TRUE; +} + +/* Allocate NEED contiguous space in .got, and return the offset. + Handles allocation of the got header when crossing 32k. */ + +static bfd_vma +allocate_got (struct ppc_elf_link_hash_table *htab, unsigned int need) +{ + bfd_vma where; + unsigned int max_before_header; + + if (htab->plt_type == PLT_VXWORKS) + { + where = htab->got->size; + htab->got->size += need; + } + else + { + max_before_header = htab->plt_type == PLT_NEW ? 32768 : 32764; + if (need <= htab->got_gap) + { + where = max_before_header - htab->got_gap; + htab->got_gap -= need; + } + else + { + if (htab->got->size + need > max_before_header + && htab->got->size <= max_before_header) + { + htab->got_gap = max_before_header - htab->got->size; + htab->got->size = max_before_header + htab->got_header_size; + } + where = htab->got->size; + htab->got->size += need; + } + } + return where; +} + +/* Allocate space in associated reloc sections for dynamic relocs. */ + +static bfd_boolean +allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf) +{ + struct bfd_link_info *info = inf; + struct ppc_elf_link_hash_entry *eh; struct ppc_elf_link_hash_table *htab; + struct ppc_elf_dyn_relocs *p; + + if (h->root.type == bfd_link_hash_indirect) + return TRUE; + + if (h->root.type == bfd_link_hash_warning) + /* When warning symbols are created, they **replace** the "real" + entry in the hash table, thus we never get to see the real + symbol in a hash traversal. So look at it now. */ + h = (struct elf_link_hash_entry *) h->root.u.i.link; + + htab = ppc_elf_hash_table (info); + if (htab->elf.dynamic_sections_created) + { + struct plt_entry *ent; + bfd_boolean doneone = FALSE; + bfd_vma plt_offset = 0, glink_offset = 0; + + for (ent = h->plt.plist; ent != NULL; ent = ent->next) + if (ent->plt.refcount > 0) + { + /* Make sure this symbol is output as a dynamic symbol. */ + if (h->dynindx == -1 + && !h->forced_local) + { + if (! bfd_elf_link_record_dynamic_symbol (info, h)) + return FALSE; + } + + if (info->shared + || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h)) + { + asection *s = htab->plt; + + if (htab->plt_type == PLT_NEW) + { + if (!doneone) + { + plt_offset = s->size; + s->size += 4; + } + ent->plt.offset = plt_offset; + + s = htab->glink; + if (!doneone || info->shared || info->pie) + { + glink_offset = s->size; + s->size += GLINK_ENTRY_SIZE; + } + if (!doneone + && !info->shared + && !h->def_regular) + { + h->root.u.def.section = s; + h->root.u.def.value = glink_offset; + } + ent->glink_offset = glink_offset; + + if (htab->emit_stub_syms + && !add_stub_sym (ent, h, info)) + return FALSE; + } + else + { + if (!doneone) + { + /* If this is the first .plt entry, make room + for the special first entry. */ + if (s->size == 0) + s->size += htab->plt_initial_entry_size; + + /* The PowerPC PLT is actually composed of two + parts, the first part is 2 words (for a load + and a jump), and then there is a remaining + word available at the end. */ + plt_offset = (htab->plt_initial_entry_size + + (htab->plt_slot_size + * ((s->size + - htab->plt_initial_entry_size) + / htab->plt_entry_size))); + + /* If this symbol is not defined in a regular + file, and we are not generating a shared + library, then set the symbol to this location + in the .plt. This is required to make + function pointers compare as equal between + the normal executable and the shared library. */ + if (! info->shared + && !h->def_regular) + { + h->root.u.def.section = s; + h->root.u.def.value = plt_offset; + } + + /* Make room for this entry. */ + s->size += htab->plt_entry_size; + /* After the 8192nd entry, room for two entries + is allocated. */ + if (htab->plt_type == PLT_OLD + && (s->size - htab->plt_initial_entry_size) + / htab->plt_entry_size + > PLT_NUM_SINGLE_ENTRIES) + s->size += htab->plt_entry_size; + } + ent->plt.offset = plt_offset; + } + + /* We also need to make an entry in the .rela.plt section. */ + if (!doneone) + { + htab->relplt->size += sizeof (Elf32_External_Rela); + + if (htab->plt_type == PLT_VXWORKS) + { + /* Allocate space for the unloaded relocations. */ + if (!info->shared) + { + if (ent->plt.offset + == (bfd_vma) htab->plt_initial_entry_size) + { + htab->srelplt2->size + += sizeof (Elf32_External_Rela) + * VXWORKS_PLTRESOLVE_RELOCS; + } + + htab->srelplt2->size + += sizeof (Elf32_External_Rela) + * VXWORKS_PLT_NON_JMP_SLOT_RELOCS; + } + + /* Every PLT entry has an associated GOT entry in + .got.plt. */ + htab->sgotplt->size += 4; + } + doneone = TRUE; + } + } + else + ent->plt.offset = (bfd_vma) -1; + + if (!doneone) + { + h->plt.plist = NULL; + h->needs_plt = 0; + } + } + } + else + { + h->plt.plist = NULL; + h->needs_plt = 0; + } + + eh = (struct ppc_elf_link_hash_entry *) h; + if (eh->elf.got.refcount > 0) + { + /* Make sure this symbol is output as a dynamic symbol. */ + if (eh->elf.dynindx == -1 + && !eh->elf.forced_local) + { + if (!bfd_elf_link_record_dynamic_symbol (info, &eh->elf)) + return FALSE; + } + + if (eh->tls_mask == (TLS_TLS | TLS_LD) + && !eh->elf.def_dynamic) + /* If just an LD reloc, we'll just use htab->tlsld_got.offset. */ + eh->elf.got.offset = (bfd_vma) -1; + else + { + bfd_boolean dyn; + unsigned int need = 0; + if ((eh->tls_mask & TLS_TLS) != 0) + { + if ((eh->tls_mask & TLS_LD) != 0) + need += 8; + if ((eh->tls_mask & TLS_GD) != 0) + need += 8; + if ((eh->tls_mask & (TLS_TPREL | TLS_TPRELGD)) != 0) + need += 4; + if ((eh->tls_mask & TLS_DTPREL) != 0) + need += 4; + } + else + need += 4; + eh->elf.got.offset = allocate_got (htab, need); + dyn = htab->elf.dynamic_sections_created; + if ((info->shared + || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, &eh->elf)) + && (ELF_ST_VISIBILITY (eh->elf.other) == STV_DEFAULT + || eh->elf.root.type != bfd_link_hash_undefweak)) + { + /* All the entries we allocated need relocs. + Except LD only needs one. */ + if ((eh->tls_mask & TLS_LD) != 0) + need -= 4; + htab->relgot->size += need * (sizeof (Elf32_External_Rela) / 4); + } + } + } + else + eh->elf.got.offset = (bfd_vma) -1; + + if (eh->dyn_relocs == NULL) + return TRUE; + + /* In the shared -Bsymbolic case, discard space allocated for + dynamic pc-relative relocs against symbols which turn out to be + defined in regular objects. For the normal shared case, discard + space for relocs that have become local due to symbol visibility + changes. */ + + if (info->shared) + { + /* Relocs that use pc_count are those that appear on a call insn, + or certain REL relocs (see MUST_BE_DYN_RELOC) that can be + generated via assembly. We want calls to protected symbols to + resolve directly to the function rather than going via the plt. + If people want function pointer comparisons to work as expected + then they should avoid writing weird assembly. */ + if (SYMBOL_CALLS_LOCAL (info, h)) + { + struct ppc_elf_dyn_relocs **pp; + + for (pp = &eh->dyn_relocs; (p = *pp) != NULL; ) + { + p->count -= p->pc_count; + p->pc_count = 0; + if (p->count == 0) + *pp = p->next; + else + pp = &p->next; + } + } + + /* Also discard relocs on undefined weak syms with non-default + visibility. */ + if (eh->dyn_relocs != NULL + && h->root.type == bfd_link_hash_undefweak) + { + if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT) + eh->dyn_relocs = NULL; + + /* Make sure undefined weak symbols are output as a dynamic + symbol in PIEs. */ + else if (h->dynindx == -1 + && !h->forced_local) + { + if (! bfd_elf_link_record_dynamic_symbol (info, h)) + return FALSE; + } + } + } + else if (ELIMINATE_COPY_RELOCS) + { + /* For the non-shared case, discard space for relocs against + symbols which turn out to need copy relocs or are not + dynamic. */ + + if (!h->non_got_ref + && h->def_dynamic + && !h->def_regular) + { + /* Make sure this symbol is output as a dynamic symbol. + Undefined weak syms won't yet be marked as dynamic. */ + if (h->dynindx == -1 + && !h->forced_local) + { + if (! bfd_elf_link_record_dynamic_symbol (info, h)) + return FALSE; + } + + /* If that succeeded, we know we'll be keeping all the + relocs. */ + if (h->dynindx != -1) + goto keep; + } + + eh->dyn_relocs = NULL; + + keep: ; + } + + /* Finally, allocate space. */ + for (p = eh->dyn_relocs; p != NULL; p = p->next) + { + asection *sreloc = elf_section_data (p->sec)->sreloc; + sreloc->size += p->count * sizeof (Elf32_External_Rela); + } + + return TRUE; +} + +/* Find any dynamic relocs that apply to read-only sections. */ + +static bfd_boolean +readonly_dynrelocs (struct elf_link_hash_entry *h, void *info) +{ + struct ppc_elf_dyn_relocs *p; + + if (h->root.type == bfd_link_hash_indirect) + return TRUE; + + if (h->root.type == bfd_link_hash_warning) + h = (struct elf_link_hash_entry *) h->root.u.i.link; + + for (p = ppc_elf_hash_entry (h)->dyn_relocs; p != NULL; p = p->next) + { + asection *s = p->sec->output_section; + + if (s != NULL + && ((s->flags & (SEC_READONLY | SEC_ALLOC)) + == (SEC_READONLY | SEC_ALLOC))) + { + ((struct bfd_link_info *) info)->flags |= DF_TEXTREL; + + /* Not an error, just cut short the traversal. */ + return FALSE; + } + } + return TRUE; +} + +/* Set the sizes of the dynamic sections. */ + +static bfd_boolean +ppc_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, + struct bfd_link_info *info) +{ + struct ppc_elf_link_hash_table *htab; + asection *s; + bfd_boolean relocs; + bfd *ibfd; #ifdef DEBUG - fprintf (stderr, "ppc_elf_finish_dynamic_symbol called for %s", - h->root.root.string); + fprintf (stderr, "ppc_elf_size_dynamic_sections called\n"); #endif htab = ppc_elf_hash_table (info); BFD_ASSERT (htab->elf.dynobj != NULL); - if (h->plt.offset != (bfd_vma) -1) + if (elf_hash_table (info)->dynamic_sections_created) { - Elf_Internal_Rela rela; - bfd_byte *loc; - bfd_vma reloc_index; + /* Set the contents of the .interp section to the interpreter. */ + if (info->executable) + { + s = bfd_get_section_by_name (htab->elf.dynobj, ".interp"); + BFD_ASSERT (s != NULL); + s->size = sizeof ELF_DYNAMIC_INTERPRETER; + s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; + } + } -#ifdef DEBUG - fprintf (stderr, ", plt_offset = %d", h->plt.offset); -#endif + if (htab->plt_type == PLT_OLD) + htab->got_header_size = 16; + else if (htab->plt_type == PLT_NEW) + htab->got_header_size = 12; - /* This symbol has an entry in the procedure linkage table. Set - it up. */ + /* Set up .got offsets for local syms, and space for local dynamic + relocs. */ + for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next) + { + bfd_signed_vma *local_got; + bfd_signed_vma *end_local_got; + char *lgot_masks; + bfd_size_type locsymcount; + Elf_Internal_Shdr *symtab_hdr; - BFD_ASSERT (h->dynindx != -1); - BFD_ASSERT (htab->plt != NULL && htab->relplt != NULL); + if (!is_ppc_elf_target (ibfd->xvec)) + continue; - /* We don't need to fill in the .plt. The ppc dynamic linker - will fill it in. */ + for (s = ibfd->sections; s != NULL; s = s->next) + { + struct ppc_elf_dyn_relocs *p; - /* Fill in the entry in the .rela.plt section. */ - rela.r_offset = (htab->plt->output_section->vma - + htab->plt->output_offset - + h->plt.offset); - rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_JMP_SLOT); - rela.r_addend = 0; + for (p = ((struct ppc_elf_dyn_relocs *) + elf_section_data (s)->local_dynrel); + p != NULL; + p = p->next) + { + if (!bfd_is_abs_section (p->sec) + && bfd_is_abs_section (p->sec->output_section)) + { + /* Input section has been discarded, either because + it is a copy of a linkonce section or due to + linker script /DISCARD/, so we'll be discarding + the relocs too. */ + } + else if (p->count != 0) + { + elf_section_data (p->sec)->sreloc->size + += p->count * sizeof (Elf32_External_Rela); + if ((p->sec->output_section->flags + & (SEC_READONLY | SEC_ALLOC)) + == (SEC_READONLY | SEC_ALLOC)) + info->flags |= DF_TEXTREL; + } + } + } - reloc_index = (h->plt.offset - PLT_INITIAL_ENTRY_SIZE) / PLT_SLOT_SIZE; - if (reloc_index > PLT_NUM_SINGLE_ENTRIES) - reloc_index -= (reloc_index - PLT_NUM_SINGLE_ENTRIES) / 2; - loc = (htab->relplt->contents - + reloc_index * sizeof (Elf32_External_Rela)); - bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); + local_got = elf_local_got_refcounts (ibfd); + if (!local_got) + continue; - if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) + symtab_hdr = &elf_tdata (ibfd)->symtab_hdr; + locsymcount = symtab_hdr->sh_info; + end_local_got = local_got + locsymcount; + lgot_masks = (char *) end_local_got; + for (; local_got < end_local_got; ++local_got, ++lgot_masks) + if (*local_got > 0) + { + if (*lgot_masks == (TLS_TLS | TLS_LD)) + { + /* If just an LD reloc, we'll just use + htab->tlsld_got.offset. */ + htab->tlsld_got.refcount += 1; + *local_got = (bfd_vma) -1; + } + else + { + unsigned int need = 0; + if ((*lgot_masks & TLS_TLS) != 0) + { + if ((*lgot_masks & TLS_GD) != 0) + need += 8; + if ((*lgot_masks & (TLS_TPREL | TLS_TPRELGD)) != 0) + need += 4; + if ((*lgot_masks & TLS_DTPREL) != 0) + need += 4; + } + else + need += 4; + *local_got = allocate_got (htab, need); + if (info->shared) + htab->relgot->size += (need + * (sizeof (Elf32_External_Rela) / 4)); + } + } + else + *local_got = (bfd_vma) -1; + } + + if (htab->tlsld_got.refcount > 0) + { + htab->tlsld_got.offset = allocate_got (htab, 8); + if (info->shared) + htab->relgot->size += sizeof (Elf32_External_Rela); + } + else + htab->tlsld_got.offset = (bfd_vma) -1; + + /* Allocate space for global sym dynamic relocs. */ + elf_link_hash_traverse (elf_hash_table (info), allocate_dynrelocs, info); + + if (htab->got != NULL && htab->plt_type != PLT_VXWORKS) + { + unsigned int g_o_t = 32768; + + /* If we haven't allocated the header, do so now. When we get here, + for old plt/got the got size will be 0 to 32764 (not allocated), + or 32780 to 65536 (header allocated). For new plt/got, the + corresponding ranges are 0 to 32768 and 32780 to 65536. */ + if (htab->got->size <= 32768) { - /* Mark the symbol as undefined, rather than as defined in - the .plt section. Leave the value alone. */ - sym->st_shndx = SHN_UNDEF; - /* If the symbol is weak, we do need to clear the value. - Otherwise, the PLT entry would provide a definition for - the symbol even if the symbol wasn't defined anywhere, - and so the symbol would never be NULL. */ - if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK) - == 0) - sym->st_value = 0; + g_o_t = htab->got->size; + if (htab->plt_type == PLT_OLD) + g_o_t += 4; + htab->got->size += htab->got_header_size; } + + htab->elf.hgot->root.u.def.value = g_o_t; } - if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0) + if (htab->glink != NULL && htab->glink->size != 0) { - asection *s; - Elf_Internal_Rela rela; - bfd_byte *loc; + htab->glink_pltresolve = htab->glink->size; + /* Space for the branch table. */ + htab->glink->size += htab->glink->size / (GLINK_ENTRY_SIZE / 4) - 4; + /* Pad out to align the start of PLTresolve. */ + htab->glink->size += -htab->glink->size & 15; + htab->glink->size += GLINK_PLTRESOLVE; - /* This symbols needs a copy reloc. Set it up. */ + if (htab->emit_stub_syms) + { + struct elf_link_hash_entry *sh; + sh = elf_link_hash_lookup (&htab->elf, "__glink", + TRUE, FALSE, FALSE); + if (sh == NULL) + return FALSE; + if (sh->root.type == bfd_link_hash_new) + { + sh->root.type = bfd_link_hash_defined; + sh->root.u.def.section = htab->glink; + sh->root.u.def.value = htab->glink_pltresolve; + sh->ref_regular = 1; + sh->def_regular = 1; + sh->ref_regular_nonweak = 1; + sh->forced_local = 1; + sh->non_elf = 0; + } + sh = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve", + TRUE, FALSE, FALSE); + if (sh == NULL) + return FALSE; + if (sh->root.type == bfd_link_hash_new) + { + sh->root.type = bfd_link_hash_defined; + sh->root.u.def.section = htab->glink; + sh->root.u.def.value = htab->glink->size - GLINK_PLTRESOLVE; + sh->ref_regular = 1; + sh->def_regular = 1; + sh->ref_regular_nonweak = 1; + sh->forced_local = 1; + sh->non_elf = 0; + } + } + } -#ifdef DEBUG - fprintf (stderr, ", copy"); -#endif + /* We've now determined the sizes of the various dynamic sections. + Allocate memory for them. */ + relocs = FALSE; + for (s = htab->elf.dynobj->sections; s != NULL; s = s->next) + { + bfd_boolean strip_section = TRUE; - BFD_ASSERT (h->dynindx != -1); + if ((s->flags & SEC_LINKER_CREATED) == 0) + continue; - if (h->size <= elf_gp_size (htab->elf.dynobj)) - s = htab->relsbss; + if (s == htab->plt + || s == htab->glink + || s == htab->got + || s == htab->sgotplt + || s == htab->sbss + || s == htab->dynbss + || s == htab->dynsbss) + { + /* We'd like to strip these sections if they aren't needed, but if + we've exported dynamic symbols from them we must leave them. + It's too late to tell BFD to get rid of the symbols. */ + if ((s == htab->plt || s == htab->got) && htab->elf.hplt != NULL) + strip_section = FALSE; + /* Strip this section if we don't need it; see the + comment below. */ + } + else if (s == htab->sdata[0].section + || s == htab->sdata[1].section) + { + /* Strip these too. */ + } + else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0) + { + if (s->size != 0) + { + /* Remember whether there are any relocation sections. */ + relocs = TRUE; + + /* We use the reloc_count field as a counter if we need + to copy relocs into the output file. */ + s->reloc_count = 0; + } + } else - s = htab->relbss; - BFD_ASSERT (s != NULL); + { + /* It's not one of our sections, so don't allocate space. */ + continue; + } - rela.r_offset = (h->root.u.def.value - + h->root.u.def.section->output_section->vma - + h->root.u.def.section->output_offset); - rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_COPY); - rela.r_addend = 0; - loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela); - bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); + if (s->size == 0 && strip_section) + { + /* If we don't need this section, strip it from the + output file. This is mostly to handle .rela.bss and + .rela.plt. We must create both sections in + create_dynamic_sections, because they must be created + before the linker maps input sections to output + sections. The linker does that before + adjust_dynamic_symbol is called, and it is that + function which decides whether anything needs to go + into these sections. */ + s->flags |= SEC_EXCLUDE; + continue; + } + + if ((s->flags & SEC_HAS_CONTENTS) == 0) + continue; + + /* Allocate memory for the section contents. */ + s->contents = bfd_zalloc (htab->elf.dynobj, s->size); + if (s->contents == NULL) + return FALSE; } -#ifdef DEBUG - fprintf (stderr, "\n"); -#endif + if (htab->elf.dynamic_sections_created) + { + /* Add some entries to the .dynamic section. We fill in the + values later, in ppc_elf_finish_dynamic_sections, but we + must add the entries now so that we get the correct size for + the .dynamic section. The DT_DEBUG entry is filled in by the + dynamic linker and used by the debugger. */ +#define add_dynamic_entry(TAG, VAL) \ + _bfd_elf_add_dynamic_entry (info, TAG, VAL) - /* Mark some specially defined symbols as absolute. */ - if (strcmp (h->root.root.string, "_DYNAMIC") == 0 - || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0 - || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0) - sym->st_shndx = SHN_ABS; + if (info->executable) + { + if (!add_dynamic_entry (DT_DEBUG, 0)) + return FALSE; + } + + if (htab->plt != NULL && htab->plt->size != 0) + { + if (!add_dynamic_entry (DT_PLTGOT, 0) + || !add_dynamic_entry (DT_PLTRELSZ, 0) + || !add_dynamic_entry (DT_PLTREL, DT_RELA) + || !add_dynamic_entry (DT_JMPREL, 0)) + return FALSE; + } + + if (htab->glink != NULL && htab->glink->size != 0) + { + if (!add_dynamic_entry (DT_PPC_GOT, 0)) + return FALSE; + } + + if (relocs) + { + if (!add_dynamic_entry (DT_RELA, 0) + || !add_dynamic_entry (DT_RELASZ, 0) + || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela))) + return FALSE; + } + + /* If any dynamic relocs apply to a read-only section, then we + need a DT_TEXTREL entry. */ + if ((info->flags & DF_TEXTREL) == 0) + elf_link_hash_traverse (elf_hash_table (info), readonly_dynrelocs, + info); + + if ((info->flags & DF_TEXTREL) != 0) + { + if (!add_dynamic_entry (DT_TEXTREL, 0)) + return FALSE; + } + } +#undef add_dynamic_entry return TRUE; } -/* Finish up the dynamic sections. */ +#define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0])) + +static const int shared_stub_entry[] = + { + 0x7c0802a6, /* mflr 0 */ + 0x429f0005, /* bcl 20, 31, .Lxxx */ + 0x7d6802a6, /* mflr 11 */ + 0x3d6b0000, /* addis 11, 11, (xxx-.Lxxx)@ha */ + 0x396b0018, /* addi 11, 11, (xxx-.Lxxx)@l */ + 0x7c0803a6, /* mtlr 0 */ + 0x7d6903a6, /* mtctr 11 */ + 0x4e800420, /* bctr */ + }; + +static const int stub_entry[] = + { + 0x3d600000, /* lis 11,xxx@ha */ + 0x396b0000, /* addi 11,11,xxx@l */ + 0x7d6903a6, /* mtctr 11 */ + 0x4e800420, /* bctr */ + }; static bfd_boolean -ppc_elf_finish_dynamic_sections (bfd *output_bfd, - struct bfd_link_info *info) +ppc_elf_relax_section (bfd *abfd, + asection *isec, + struct bfd_link_info *link_info, + bfd_boolean *again) { - asection *sdyn; + struct one_fixup + { + struct one_fixup *next; + asection *tsec; + bfd_vma toff; + bfd_vma trampoff; + }; + + Elf_Internal_Shdr *symtab_hdr; + bfd_byte *contents = NULL; + Elf_Internal_Sym *isymbuf = NULL; + Elf_Internal_Rela *internal_relocs = NULL; + Elf_Internal_Rela *irel, *irelend; + struct one_fixup *fixups = NULL; + bfd_boolean changed; struct ppc_elf_link_hash_table *htab; + bfd_size_type trampoff; + asection *got2; -#ifdef DEBUG - fprintf (stderr, "ppc_elf_finish_dynamic_sections called\n"); -#endif + *again = FALSE; - htab = ppc_elf_hash_table (info); - sdyn = bfd_get_section_by_name (htab->elf.dynobj, ".dynamic"); + /* Nothing to do if there are no relocations, and no need to do + anything with non-alloc sections. */ + if ((isec->flags & SEC_ALLOC) == 0 + || (isec->flags & SEC_RELOC) == 0 + || isec->reloc_count == 0) + return TRUE; - if (htab->elf.dynamic_sections_created) + trampoff = (isec->size + 3) & (bfd_vma) -4; + /* Space for a branch around any trampolines. */ + trampoff += 4; + + symtab_hdr = &elf_tdata (abfd)->symtab_hdr; + + /* Get a copy of the native relocations. */ + internal_relocs = _bfd_elf_link_read_relocs (abfd, isec, NULL, NULL, + link_info->keep_memory); + if (internal_relocs == NULL) + goto error_return; + + htab = ppc_elf_hash_table (link_info); + got2 = bfd_get_section_by_name (abfd, ".got2"); + + irelend = internal_relocs + isec->reloc_count; + for (irel = internal_relocs; irel < irelend; irel++) { - Elf32_External_Dyn *dyncon, *dynconend; + unsigned long r_type = ELF32_R_TYPE (irel->r_info); + bfd_vma symaddr, reladdr, toff, roff; + asection *tsec; + struct one_fixup *f; + size_t insn_offset = 0; + bfd_vma max_branch_offset, val; + bfd_byte *hit_addr; + unsigned long t0; + unsigned char sym_type; - BFD_ASSERT (htab->plt != NULL && sdyn != NULL); + switch (r_type) + { + case R_PPC_REL24: + case R_PPC_LOCAL24PC: + case R_PPC_PLTREL24: + max_branch_offset = 1 << 25; + break; - dyncon = (Elf32_External_Dyn *) sdyn->contents; - dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size); - for (; dyncon < dynconend; dyncon++) + case R_PPC_REL14: + case R_PPC_REL14_BRTAKEN: + case R_PPC_REL14_BRNTAKEN: + max_branch_offset = 1 << 15; + break; + + default: + continue; + } + + /* Get the value of the symbol referred to by the reloc. */ + if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) { - Elf_Internal_Dyn dyn; - asection *s; + /* A local symbol. */ + Elf_Internal_Sym *isym; - bfd_elf32_swap_dyn_in (htab->elf.dynobj, dyncon, &dyn); + /* Read this BFD's local symbols. */ + if (isymbuf == NULL) + { + isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; + if (isymbuf == NULL) + isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, + symtab_hdr->sh_info, 0, + NULL, NULL, NULL); + if (isymbuf == 0) + goto error_return; + } + isym = isymbuf + ELF32_R_SYM (irel->r_info); + if (isym->st_shndx == SHN_UNDEF) + continue; /* We can't do anything with undefined symbols. */ + else if (isym->st_shndx == SHN_ABS) + tsec = bfd_abs_section_ptr; + else if (isym->st_shndx == SHN_COMMON) + tsec = bfd_com_section_ptr; + else + tsec = bfd_section_from_elf_index (abfd, isym->st_shndx); - switch (dyn.d_tag) + toff = isym->st_value; + sym_type = ELF_ST_TYPE (isym->st_info); + } + else + { + /* Global symbol handling. */ + unsigned long indx; + struct elf_link_hash_entry *h; + + indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info; + h = elf_sym_hashes (abfd)[indx]; + + while (h->root.type == bfd_link_hash_indirect + || h->root.type == bfd_link_hash_warning) + h = (struct elf_link_hash_entry *) h->root.u.i.link; + + tsec = NULL; + toff = 0; + if (r_type == R_PPC_PLTREL24 + && htab->plt != NULL) { - case DT_PLTGOT: - s = htab->plt; - dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; - break; + struct plt_entry *ent = find_plt_ent (h, got2, irel->r_addend); - case DT_PLTRELSZ: - dyn.d_un.d_val = htab->relplt->_raw_size; - break; + if (ent != NULL) + { + if (htab->plt_type == PLT_NEW) + { + tsec = htab->glink; + toff = ent->glink_offset; + } + else + { + tsec = htab->plt; + toff = ent->plt.offset; + } + } + } + if (tsec != NULL) + ; + else if (h->root.type == bfd_link_hash_defined + || h->root.type == bfd_link_hash_defweak) + { + tsec = h->root.u.def.section; + toff = h->root.u.def.value; + } + else + continue; - case DT_JMPREL: - s = htab->relplt; - dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; - break; + sym_type = h->type; + } - default: - continue; + /* If the branch and target are in the same section, you have + no hope of adding stubs. We'll error out later should the + branch overflow. */ + if (tsec == isec) + continue; + + /* There probably isn't any reason to handle symbols in + SEC_MERGE sections; SEC_MERGE doesn't seem a likely + attribute for a code section, and we are only looking at + branches. However, implement it correctly here as a + reference for other target relax_section functions. */ + if (0 && tsec->sec_info_type == ELF_INFO_TYPE_MERGE) + { + /* At this stage in linking, no SEC_MERGE symbol has been + adjusted, so all references to such symbols need to be + passed through _bfd_merged_section_offset. (Later, in + relocate_section, all SEC_MERGE symbols *except* for + section symbols have been adjusted.) + + gas may reduce relocations against symbols in SEC_MERGE + sections to a relocation against the section symbol when + the original addend was zero. When the reloc is against + a section symbol we should include the addend in the + offset passed to _bfd_merged_section_offset, since the + location of interest is the original symbol. On the + other hand, an access to "sym+addend" where "sym" is not + a section symbol should not include the addend; Such an + access is presumed to be an offset from "sym"; The + location of interest is just "sym". */ + if (sym_type == STT_SECTION) + toff += irel->r_addend; + + toff = _bfd_merged_section_offset (abfd, &tsec, + elf_section_data (tsec)->sec_info, + toff); + + if (sym_type != STT_SECTION) + toff += irel->r_addend; + } + /* PLTREL24 addends are special. */ + else if (r_type != R_PPC_PLTREL24) + toff += irel->r_addend; + + /* Attempted -shared link of non-pic code loses. */ + if (tsec->output_section == NULL) + continue; + + symaddr = tsec->output_section->vma + tsec->output_offset + toff; + + roff = irel->r_offset; + reladdr = isec->output_section->vma + isec->output_offset + roff; + + /* If the branch is in range, no need to do anything. */ + if (symaddr - reladdr + max_branch_offset < 2 * max_branch_offset) + continue; + + /* Look for an existing fixup to this address. */ + for (f = fixups; f ; f = f->next) + if (f->tsec == tsec && f->toff == toff) + break; + + if (f == NULL) + { + size_t size; + unsigned long stub_rtype; + + val = trampoff - roff; + if (val >= max_branch_offset) + /* Oh dear, we can't reach a trampoline. Don't try to add + one. We'll report an error later. */ + continue; + + if (link_info->shared) + { + size = 4 * ARRAY_SIZE (shared_stub_entry); + insn_offset = 12; + stub_rtype = R_PPC_RELAX32PC; + } + else + { + size = 4 * ARRAY_SIZE (stub_entry); + insn_offset = 0; + stub_rtype = R_PPC_RELAX32; } - bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); + if (R_PPC_RELAX32_PLT - R_PPC_RELAX32 + != R_PPC_RELAX32PC_PLT - R_PPC_RELAX32PC) + abort (); + if (tsec == htab->plt + || tsec == htab->glink) + stub_rtype += R_PPC_RELAX32_PLT - R_PPC_RELAX32; + + /* Hijack the old relocation. Since we need two + relocations for this use a "composite" reloc. */ + irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), + stub_rtype); + irel->r_offset = trampoff + insn_offset; + + /* Record the fixup so we don't do it again this section. */ + f = bfd_malloc (sizeof (*f)); + f->next = fixups; + f->tsec = tsec; + f->toff = toff; + f->trampoff = trampoff; + fixups = f; + + trampoff += size; + } + else + { + val = f->trampoff - roff; + if (val >= max_branch_offset) + continue; + + /* Nop out the reloc, since we're finalizing things here. */ + irel->r_info = ELF32_R_INFO (0, R_PPC_NONE); + } + + /* Get the section contents. */ + if (contents == NULL) + { + /* Get cached copy if it exists. */ + if (elf_section_data (isec)->this_hdr.contents != NULL) + contents = elf_section_data (isec)->this_hdr.contents; + else + { + /* Go get them off disk. */ + if (!bfd_malloc_and_get_section (abfd, isec, &contents)) + goto error_return; + } + } + + /* Fix up the existing branch to hit the trampoline. */ + hit_addr = contents + roff; + switch (r_type) + { + case R_PPC_REL24: + case R_PPC_LOCAL24PC: + case R_PPC_PLTREL24: + t0 = bfd_get_32 (abfd, hit_addr); + t0 &= ~0x3fffffc; + t0 |= val & 0x3fffffc; + bfd_put_32 (abfd, t0, hit_addr); + break; + + case R_PPC_REL14: + case R_PPC_REL14_BRTAKEN: + case R_PPC_REL14_BRNTAKEN: + t0 = bfd_get_32 (abfd, hit_addr); + t0 &= ~0xfffc; + t0 |= val & 0xfffc; + bfd_put_32 (abfd, t0, hit_addr); + break; } } - /* Add a blrl instruction at _GLOBAL_OFFSET_TABLE_-4 so that a function can - easily find the address of the _GLOBAL_OFFSET_TABLE_. */ - if (htab->got) + /* Write out the trampolines. */ + changed = fixups != NULL; + if (fixups != NULL) { - unsigned char *contents = htab->got->contents; - bfd_put_32 (output_bfd, 0x4e800021 /* blrl */, contents); + const int *stub; + bfd_byte *dest; + bfd_vma val; + int i, size; + + do + { + struct one_fixup *f = fixups; + fixups = fixups->next; + free (f); + } + while (fixups); + + contents = bfd_realloc (contents, trampoff); + if (contents == NULL) + goto error_return; - if (sdyn == NULL) - bfd_put_32 (output_bfd, 0, contents + 4); + isec->size = (isec->size + 3) & (bfd_vma) -4; + /* Branch around the trampolines. */ + val = trampoff - isec->size + 0x48000000; + dest = contents + isec->size; + isec->size = trampoff; + bfd_put_32 (abfd, val, dest); + dest += 4; + + if (link_info->shared) + { + stub = shared_stub_entry; + size = ARRAY_SIZE (shared_stub_entry); + } else - bfd_put_32 (output_bfd, - sdyn->output_section->vma + sdyn->output_offset, - contents + 4); + { + stub = stub_entry; + size = ARRAY_SIZE (stub_entry); + } - elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 4; + i = 0; + while (dest < contents + trampoff) + { + bfd_put_32 (abfd, stub[i], dest); + i++; + if (i == size) + i = 0; + dest += 4; + } + BFD_ASSERT (i == 0); + } + + if (isymbuf != NULL + && symtab_hdr->contents != (unsigned char *) isymbuf) + { + if (! link_info->keep_memory) + free (isymbuf); + else + { + /* Cache the symbols for elf_link_input_bfd. */ + symtab_hdr->contents = (unsigned char *) isymbuf; + } } + if (contents != NULL + && elf_section_data (isec)->this_hdr.contents != contents) + { + if (!changed && !link_info->keep_memory) + free (contents); + else + { + /* Cache the section contents for elf_link_input_bfd. */ + elf_section_data (isec)->this_hdr.contents = contents; + } + } + + if (elf_section_data (isec)->relocs != internal_relocs) + { + if (!changed) + free (internal_relocs); + else + elf_section_data (isec)->relocs = internal_relocs; + } + + *again = changed; return TRUE; + + error_return: + if (isymbuf != NULL && (unsigned char *) isymbuf != symtab_hdr->contents) + free (isymbuf); + if (contents != NULL + && elf_section_data (isec)->this_hdr.contents != contents) + free (contents); + if (internal_relocs != NULL + && elf_section_data (isec)->relocs != internal_relocs) + free (internal_relocs); + return FALSE; } +/* What to do when ld finds relocations against symbols defined in + discarded sections. */ + +static unsigned int +ppc_elf_action_discarded (asection *sec) +{ + if (strcmp (".fixup", sec->name) == 0) + return 0; + + if (strcmp (".got2", sec->name) == 0) + return 0; + + return _bfd_elf_default_action_discarded (sec); +} + +/* Fill in the address for a pointer generated in a linker section. */ + +static bfd_vma +elf_finish_pointer_linker_section (bfd *input_bfd, + elf_linker_section_t *lsect, + struct elf_link_hash_entry *h, + bfd_vma relocation, + const Elf_Internal_Rela *rel) +{ + elf_linker_section_pointers_t *linker_section_ptr; + + BFD_ASSERT (lsect != NULL); + + if (h != NULL) + { + /* Handle global symbol. */ + struct ppc_elf_link_hash_entry *eh; + + eh = (struct ppc_elf_link_hash_entry *) h; + BFD_ASSERT (eh->elf.def_regular); + linker_section_ptr = eh->linker_section_pointer; + } + else + { + /* Handle local symbol. */ + unsigned long r_symndx = ELF32_R_SYM (rel->r_info); + + BFD_ASSERT (elf_local_ptr_offsets (input_bfd) != NULL); + linker_section_ptr = elf_local_ptr_offsets (input_bfd)[r_symndx]; + } + + linker_section_ptr = elf_find_pointer_linker_section (linker_section_ptr, + rel->r_addend, + lsect); + BFD_ASSERT (linker_section_ptr != NULL); + + /* Offset will always be a multiple of four, so use the bottom bit + as a "written" flag. */ + if ((linker_section_ptr->offset & 1) == 0) + { + bfd_put_32 (lsect->section->owner, + relocation + linker_section_ptr->addend, + lsect->section->contents + linker_section_ptr->offset); + linker_section_ptr->offset += 1; + } + + relocation = (lsect->section->output_offset + + linker_section_ptr->offset - 1 + - 0x8000); + +#ifdef DEBUG + fprintf (stderr, + "Finish pointer in linker section %s, offset = %ld (0x%lx)\n", + lsect->name, (long) relocation, (long) relocation); +#endif + + /* Subtract out the addend, because it will get added back in by the normal + processing. */ + return relocation - linker_section_ptr->addend; +} + /* The RELOCATE_SECTION function is called by the ELF backend linker to handle the relocations for a section. @@ -4629,21 +5515,42 @@ ppc_elf_relocate_section (bfd *output_bfd, Elf_Internal_Rela *relend; Elf_Internal_Rela outrel; bfd_byte *loc; - asection *sreloc = NULL; + asection *got2, *sreloc = NULL; bfd_vma *local_got_offsets; bfd_boolean ret = TRUE; #ifdef DEBUG - fprintf (stderr, "ppc_elf_relocate_section called for %s section %s, " - "%ld relocations%s\n", - bfd_archive_filename (input_bfd), - bfd_section_name(input_bfd, input_section), - (long) input_section->reloc_count, - (info->relocatable) ? " (relocatable)" : ""); + _bfd_error_handler ("ppc_elf_relocate_section called for %B section %A, " + "%ld relocations%s", + input_bfd, input_section, + (long) input_section->reloc_count, + (info->relocatable) ? " (relocatable)" : ""); #endif + got2 = bfd_get_section_by_name (input_bfd, ".got2"); + if (info->relocatable) - return TRUE; + { + if (got2 == NULL) + return TRUE; + + rel = relocs; + relend = relocs + input_section->reloc_count; + for (; rel < relend; rel++) + { + enum elf_ppc_reloc_type r_type; + + r_type = ELF32_R_TYPE (rel->r_info); + if (r_type == R_PPC_PLTREL24 + && rel->r_addend >= 32768) + { + /* R_PPC_PLTREL24 is rather special. If non-zero, the + addend specifies the GOT pointer offset within .got2. */ + rel->r_addend += got2->output_offset; + } + } + return TRUE; + } /* Initialize howto table if not already done. */ if (!ppc_elf_howto_table[R_PPC_ADDR32]) @@ -4684,7 +5591,7 @@ ppc_elf_relocate_section (bfd *output_bfd, { sym = local_syms + r_symndx; sec = local_sections[r_symndx]; - sym_name = bfd_elf_local_sym_name (input_bfd, sym); + sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec); relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); } @@ -4865,6 +5772,7 @@ ppc_elf_relocate_section (bfd *output_bfd, insn1 |= 32 << 26; /* lwz */ insn2 = 0x7c631214; /* add 3,3,2 */ rel[1].r_info = ELF32_R_INFO (r_symndx2, R_PPC_NONE); + rel[1].r_addend = 0; r_type = (((r_type - (R_PPC_GOT_TLSGD16 & 3)) & 3) + R_PPC_GOT_TPREL16); rel->r_info = ELF32_R_INFO (r_symndx, r_type); @@ -4879,13 +5787,13 @@ ppc_elf_relocate_section (bfd *output_bfd, /* Was an LD reloc. */ r_symndx = 0; rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET; - rel[1].r_addend = htab->elf.tls_sec->vma + DTP_OFFSET; } r_type = R_PPC_TPREL16_HA; rel->r_info = ELF32_R_INFO (r_symndx, r_type); rel[1].r_info = ELF32_R_INFO (r_symndx, R_PPC_TPREL16_LO); rel[1].r_offset += 2; + rel[1].r_addend = rel->r_addend; } bfd_put_32 (output_bfd, insn1, contents + rel->r_offset - 2); bfd_put_32 (output_bfd, insn2, contents + offset); @@ -4942,8 +5850,8 @@ ppc_elf_relocate_section (bfd *output_bfd, { default: (*_bfd_error_handler) - (_("%s: unknown relocation type %d for symbol %s"), - bfd_archive_filename (input_bfd), (int) r_type, sym_name); + (_("%B: unknown relocation type %d for symbol %s"), + input_bfd, (int) r_type, sym_name); bfd_set_error (bfd_error_bad_value); ret = FALSE; @@ -5006,7 +5914,7 @@ ppc_elf_relocate_section (bfd *output_bfd, indx = 0; if (tls_type == (TLS_TLS | TLS_LD) && (h == NULL - || !(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC))) + || !h->def_dynamic)) offp = &htab->tlsld_got.offset; else if (h != NULL) { @@ -5049,8 +5957,7 @@ ppc_elf_relocate_section (bfd *output_bfd, if (offp == &htab->tlsld_got.offset) tls_m = TLS_LD; else if (h == NULL - || !(h->elf_link_hash_flags - & ELF_LINK_HASH_DEF_DYNAMIC)) + || !h->def_dynamic) tls_m &= ~TLS_LD; /* We might have multiple got entries for this sym. @@ -5169,8 +6076,7 @@ ppc_elf_relocate_section (bfd *output_bfd, { if ((tls_mask & TLS_LD) != 0 && !(h == NULL - || !(h->elf_link_hash_flags - & ELF_LINK_HASH_DEF_DYNAMIC))) + || !h->def_dynamic)) off += 8; if (tls_type != (TLS_TLS | TLS_GD)) { @@ -5185,7 +6091,8 @@ ppc_elf_relocate_section (bfd *output_bfd, } } - relocation = htab->got->output_offset + off - 4; + relocation = htab->got->output_offset + off; + relocation -= htab->elf.hgot->root.u.def.value; /* Addends on got relocations don't make much sense. x+off@got is actually x@got+off, and since the got is @@ -5193,9 +6100,9 @@ ppc_elf_relocate_section (bfd *output_bfd, got at entry m+n bears little relation to the entry m. */ if (addend != 0) (*_bfd_error_handler) - (_("%s(%s+0x%lx): non-zero addend on %s reloc against `%s'"), - bfd_archive_filename (input_bfd), - bfd_get_section_name (input_bfd, input_section), + (_("%B(%A+0x%lx): non-zero addend on %s reloc against `%s'"), + input_bfd, + input_section, (long) rel->r_offset, howto->name, sym_name); @@ -5251,6 +6158,12 @@ ppc_elf_relocate_section (bfd *output_bfd, addend = 0; goto dodyn; + case R_PPC_REL16: + case R_PPC_REL16_LO: + case R_PPC_REL16_HI: + case R_PPC_REL16_HA: + break; + case R_PPC_REL24: case R_PPC_REL32: case R_PPC_REL14: @@ -5259,7 +6172,7 @@ ppc_elf_relocate_section (bfd *output_bfd, /* If these relocations are not to a named symbol, they can be handled right here, no need to bother the dynamic linker. */ if (SYMBOL_REFERENCES_LOCAL (info, h) - || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) + || h == htab->elf.hgot) break; /* fall through */ @@ -5284,6 +6197,10 @@ ppc_elf_relocate_section (bfd *output_bfd, break; /* Fall thru. */ + if ((input_section->flags & SEC_ALLOC) == 0) + break; + /* Fall thru. */ + if ((info->shared && (h == NULL || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT @@ -5292,12 +6209,11 @@ ppc_elf_relocate_section (bfd *output_bfd, || !SYMBOL_CALLS_LOCAL (info, h))) || (ELIMINATE_COPY_RELOCS && !info->shared - && (input_section->flags & SEC_ALLOC) != 0 && h != NULL && h->dynindx != -1 - && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0 - && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0 - && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)) + && !h->non_got_ref + && h->def_dynamic + && !h->def_regular)) { int skip; @@ -5411,12 +6327,33 @@ ppc_elf_relocate_section (bfd *output_bfd, } break; + case R_PPC_RELAX32PC_PLT: + case R_PPC_RELAX32_PLT: + { + struct plt_entry *ent = find_plt_ent (h, got2, addend); + + if (htab->plt_type == PLT_NEW) + relocation = (htab->glink->output_section->vma + + htab->glink->output_offset + + ent->glink_offset); + else + relocation = (htab->plt->output_section->vma + + htab->plt->output_offset + + ent->plt.offset); + addend = 0; + } + if (r_type == R_PPC_RELAX32_PLT) + goto relax32; + /* Fall thru */ + case R_PPC_RELAX32PC: relocation -= (input_section->output_section->vma + input_section->output_offset + rel->r_offset - 4); /* Fall thru */ + case R_PPC_RELAX32: + relax32: { unsigned long t0; unsigned long t1; @@ -5441,20 +6378,18 @@ ppc_elf_relocate_section (bfd *output_bfd, /* Indirect .sdata relocation. */ case R_PPC_EMB_SDAI16: - BFD_ASSERT (htab->sdata != NULL); + BFD_ASSERT (htab->sdata[0].section != NULL); relocation - = elf_finish_pointer_linker_section (output_bfd, input_bfd, info, - htab->sdata, h, relocation, - rel, R_PPC_RELATIVE); + = elf_finish_pointer_linker_section (input_bfd, &htab->sdata[0], + h, relocation, rel); break; /* Indirect .sdata2 relocation. */ case R_PPC_EMB_SDA2I16: - BFD_ASSERT (htab->sdata2 != NULL); + BFD_ASSERT (htab->sdata[1].section != NULL); relocation - = elf_finish_pointer_linker_section (output_bfd, input_bfd, info, - htab->sdata2, h, relocation, - rel, R_PPC_RELATIVE); + = elf_finish_pointer_linker_section (input_bfd, &htab->sdata[1], + h, relocation, rel); break; /* Handle the TOC16 reloc. We want to use the offset within the .got @@ -5465,7 +6400,7 @@ ppc_elf_relocate_section (bfd *output_bfd, BFD_ASSERT (sec != NULL); BFD_ASSERT (bfd_is_und_section (sec) || strcmp (bfd_get_section_name (abfd, sec), ".got") == 0 - || strcmp (bfd_get_section_name (abfd, sec), ".cgot") == 0) + || strcmp (bfd_get_section_name (abfd, sec), ".cgot") == 0); addend -= sec->output_section->vma + sec->output_offset + 0x8000; break; @@ -5473,28 +6408,36 @@ ppc_elf_relocate_section (bfd *output_bfd, case R_PPC_PLTREL24: /* Relocation is to the entry for this symbol in the procedure linkage table. */ - BFD_ASSERT (h != NULL); + { + struct plt_entry *ent = find_plt_ent (h, got2, addend); - if (h->plt.offset == (bfd_vma) -1 - || htab->plt == NULL) - { - /* We didn't make a PLT entry for this symbol. This - happens when statically linking PIC code, or when - using -Bsymbolic. */ - break; - } + addend = 0; + if (ent == NULL + || htab->plt == NULL) + { + /* We didn't make a PLT entry for this symbol. This + happens when statically linking PIC code, or when + using -Bsymbolic. */ + break; + } - unresolved_reloc = FALSE; - relocation = (htab->plt->output_section->vma - + htab->plt->output_offset - + h->plt.offset); + unresolved_reloc = FALSE; + if (htab->plt_type == PLT_NEW) + relocation = (htab->glink->output_section->vma + + htab->glink->output_offset + + ent->glink_offset); + else + relocation = (htab->plt->output_section->vma + + htab->plt->output_offset + + ent->plt.offset); + } break; /* Relocate against _SDA_BASE_. */ case R_PPC_SDAREL16: { const char *name; - const struct elf_link_hash_entry *sh; + struct elf_link_hash_entry *sh; BFD_ASSERT (sec != NULL); name = bfd_get_section_name (abfd, sec->output_section); @@ -5504,17 +6447,17 @@ ppc_elf_relocate_section (bfd *output_bfd, && (name[5] == 0 || name[5] == '.')))) { (*_bfd_error_handler) - (_("%s: the target (%s) of a %s relocation is " + (_("%B: the target (%s) of a %s relocation is " "in the wrong output section (%s)"), - bfd_archive_filename (input_bfd), + input_bfd, sym_name, howto->name, name); } - sh = htab->sdata->sym_hash; + sh = htab->sdata[0].sym; addend -= (sh->root.u.def.value - + sh->root.u.def.section->output_section->vma - + sh->root.u.def.section->output_offset); + + sh->root.u.def.section->output_offset + + sh->root.u.def.section->output_section->vma); } break; @@ -5522,7 +6465,7 @@ ppc_elf_relocate_section (bfd *output_bfd, case R_PPC_EMB_SDA2REL: { const char *name; - const struct elf_link_hash_entry *sh; + struct elf_link_hash_entry *sh; BFD_ASSERT (sec != NULL); name = bfd_get_section_name (abfd, sec->output_section); @@ -5530,9 +6473,9 @@ ppc_elf_relocate_section (bfd *output_bfd, || strncmp (name, ".sbss2", 6) == 0)) { (*_bfd_error_handler) - (_("%s: the target (%s) of a %s relocation is " + (_("%B: the target (%s) of a %s relocation is " "in the wrong output section (%s)"), - bfd_archive_filename (input_bfd), + input_bfd, sym_name, howto->name, name); @@ -5541,10 +6484,10 @@ ppc_elf_relocate_section (bfd *output_bfd, ret = FALSE; continue; } - sh = htab->sdata2->sym_hash; + sh = htab->sdata[1].sym; addend -= (sh->root.u.def.value - + sh->root.u.def.section->output_section->vma - + sh->root.u.def.section->output_offset); + + sh->root.u.def.section->output_offset + + sh->root.u.def.section->output_section->vma); } break; @@ -5553,8 +6496,8 @@ ppc_elf_relocate_section (bfd *output_bfd, case R_PPC_EMB_RELSDA: { const char *name; - const struct elf_link_hash_entry *sh; int reg; + struct elf_link_hash_entry *sh; BFD_ASSERT (sec != NULL); name = bfd_get_section_name (abfd, sec->output_section); @@ -5564,20 +6507,20 @@ ppc_elf_relocate_section (bfd *output_bfd, && (name[5] == 0 || name[5] == '.')))) { reg = 13; - sh = htab->sdata->sym_hash; + sh = htab->sdata[0].sym; addend -= (sh->root.u.def.value - + sh->root.u.def.section->output_section->vma - + sh->root.u.def.section->output_offset); + + sh->root.u.def.section->output_offset + + sh->root.u.def.section->output_section->vma); } else if (strncmp (name, ".sdata2", 7) == 0 || strncmp (name, ".sbss2", 6) == 0) { reg = 2; - sh = htab->sdata2->sym_hash; + sh = htab->sdata[1].sym; addend -= (sh->root.u.def.value - + sh->root.u.def.section->output_section->vma - + sh->root.u.def.section->output_offset); + + sh->root.u.def.section->output_offset + + sh->root.u.def.section->output_section->vma); } else if (strcmp (name, ".PPC.EMB.sdata0") == 0 @@ -5589,9 +6532,9 @@ ppc_elf_relocate_section (bfd *output_bfd, else { (*_bfd_error_handler) - (_("%s: the target (%s) of a %s relocation is " + (_("%B: the target (%s) of a %s relocation is " "in the wrong output section (%s)"), - bfd_archive_filename (input_bfd), + input_bfd, sym_name, howto->name, name); @@ -5644,8 +6587,8 @@ ppc_elf_relocate_section (bfd *output_bfd, case R_PPC_EMB_RELST_HA: case R_PPC_EMB_BIT_FLD: (*_bfd_error_handler) - (_("%s: relocation %s is not yet supported for symbol %s."), - bfd_archive_filename (input_bfd), + (_("%B: relocation %s is not yet supported for symbol %s."), + input_bfd, howto->name, sym_name); @@ -5661,6 +6604,7 @@ ppc_elf_relocate_section (bfd *output_bfd, break; case R_PPC_ADDR16_HA: + case R_PPC_REL16_HA: case R_PPC_GOT16_HA: case R_PPC_PLT16_HA: case R_PPC_SECTOFF_HA: @@ -5696,12 +6640,12 @@ ppc_elf_relocate_section (bfd *output_bfd, if (unresolved_reloc && !((input_section->flags & SEC_DEBUGGING) != 0 - && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0)) + && h->def_dynamic)) { (*_bfd_error_handler) - (_("%s(%s+0x%lx): unresolvable %s relocation against symbol `%s'"), - bfd_archive_filename (input_bfd), - bfd_get_section_name (input_bfd, input_section), + (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"), + input_bfd, + input_section, (long) rel->r_offset, howto->name, sym_name); @@ -5718,8 +6662,6 @@ ppc_elf_relocate_section (bfd *output_bfd, if (r != bfd_reloc_ok) { - if (sym_name == NULL) - sym_name = "(null)"; if (r == bfd_reloc_overflow) { if (warned) @@ -5738,6 +6680,7 @@ ppc_elf_relocate_section (bfd *output_bfd, } if (! (*info->callbacks->reloc_overflow) (info, + (h ? &h->root : NULL), sym_name, howto->name, rel->r_addend, @@ -5749,9 +6692,8 @@ ppc_elf_relocate_section (bfd *output_bfd, else { (*_bfd_error_handler) - (_("%s(%s+0x%lx): %s reloc against `%s': error %d"), - bfd_archive_filename (input_bfd), - bfd_get_section_name (input_bfd, input_section), + (_("%B(%A+0x%lx): %s reloc against `%s': error %d"), + input_bfd, input_section, (long) rel->r_offset, howto->name, sym_name, (int) r); ret = FALSE; } @@ -5764,388 +6706,723 @@ ppc_elf_relocate_section (bfd *output_bfd, return ret; } - -static enum elf_reloc_type_class -ppc_elf_reloc_type_class (const Elf_Internal_Rela *rela) -{ - switch (ELF32_R_TYPE (rela->r_info)) - { - case R_PPC_RELATIVE: - return reloc_class_relative; - case R_PPC_REL24: - case R_PPC_ADDR24: - case R_PPC_JMP_SLOT: - return reloc_class_plt; - case R_PPC_COPY: - return reloc_class_copy; - default: - return reloc_class_normal; - } -} -/* Support for core dump NOTE sections. */ +#define PPC_LO(v) ((v) & 0xffff) +#define PPC_HI(v) (((v) >> 16) & 0xffff) +#define PPC_HA(v) PPC_HI ((v) + 0x8000) + +/* Finish up dynamic symbol handling. We set the contents of various + dynamic sections here. */ static bfd_boolean -ppc_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note) +ppc_elf_finish_dynamic_symbol (bfd *output_bfd, + struct bfd_link_info *info, + struct elf_link_hash_entry *h, + Elf_Internal_Sym *sym) { - int offset; - unsigned int raw_size; + struct ppc_elf_link_hash_table *htab; + struct plt_entry *ent; + bfd_boolean doneone; - switch (note->descsz) - { - default: - return FALSE; +#ifdef DEBUG + fprintf (stderr, "ppc_elf_finish_dynamic_symbol called for %s", + h->root.root.string); +#endif - case 268: /* Linux/PPC. */ - /* pr_cursig */ - elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12); + htab = ppc_elf_hash_table (info); + BFD_ASSERT (htab->elf.dynobj != NULL); - /* pr_pid */ - elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24); + doneone = FALSE; + for (ent = h->plt.plist; ent != NULL; ent = ent->next) + if (ent->plt.offset != (bfd_vma) -1) + { + if (!doneone) + { + Elf_Internal_Rela rela; + bfd_byte *loc; + bfd_vma reloc_index; - /* pr_reg */ - offset = 72; - raw_size = 192; + if (htab->plt_type == PLT_NEW) + reloc_index = ent->plt.offset / 4; + else + { + reloc_index = ((ent->plt.offset - htab->plt_initial_entry_size) + / htab->plt_slot_size); + if (reloc_index > PLT_NUM_SINGLE_ENTRIES + && htab->plt_type == PLT_OLD) + reloc_index -= (reloc_index - PLT_NUM_SINGLE_ENTRIES) / 2; + } - break; - } + /* This symbol has an entry in the procedure linkage table. + Set it up. */ + if (htab->plt_type == PLT_VXWORKS) + { + bfd_vma got_offset; + const bfd_vma *plt_entry; + + /* The first three entries in .got.plt are reserved. */ + got_offset = (reloc_index + 3) * 4; - /* Make a ".reg/999" section. */ - return _bfd_elfcore_make_pseudosection (abfd, ".reg", - raw_size, note->descpos + offset); -} + /* Use the right PLT. */ + plt_entry = info->shared ? ppc_elf_vxworks_pic_plt_entry + : ppc_elf_vxworks_plt_entry; -static bfd_boolean -ppc_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) -{ - switch (note->descsz) - { - default: - return FALSE; + /* Fill in the .plt on VxWorks. */ + if (info->shared) + { + bfd_vma got_offset_hi = (got_offset >> 16) + + ((got_offset & 0x8000) >> 15); - case 128: /* Linux/PPC elf_prpsinfo. */ - elf_tdata (abfd)->core_program - = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16); - elf_tdata (abfd)->core_command - = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80); - } + bfd_put_32 (output_bfd, + plt_entry[0] | (got_offset_hi & 0xffff), + htab->plt->contents + ent->plt.offset + 0); + bfd_put_32 (output_bfd, + plt_entry[1] | (got_offset & 0xffff), + htab->plt->contents + ent->plt.offset + 4); + } + else + { + bfd_vma got_loc + = (got_offset + + htab->elf.hgot->root.u.def.value + + htab->elf.hgot->root.u.def.section->output_offset + + htab->elf.hgot->root.u.def.section->output_section->vma); + bfd_vma got_loc_hi = (got_loc >> 16) + + ((got_loc & 0x8000) >> 15); - /* Note that for some reason, a spurious space is tacked - onto the end of the args in some (at least one anyway) - implementations, so strip it off if it exists. */ + bfd_put_32 (output_bfd, + plt_entry[0] | (got_loc_hi & 0xffff), + htab->plt->contents + ent->plt.offset + 0); + bfd_put_32 (output_bfd, + plt_entry[1] | (got_loc & 0xffff), + htab->plt->contents + ent->plt.offset + 4); + } - { - char *command = elf_tdata (abfd)->core_command; - int n = strlen (command); + bfd_put_32 (output_bfd, plt_entry[2], + htab->plt->contents + ent->plt.offset + 8); + bfd_put_32 (output_bfd, plt_entry[3], + htab->plt->contents + ent->plt.offset + 12); - if (0 < n && command[n - 1] == ' ') - command[n - 1] = '\0'; - } + /* This instruction is an immediate load. The value loaded is + the byte offset of the R_PPC_JMP_SLOT relocation from the + start of the .rela.plt section. The value is stored in the + low-order 16 bits of the load instruction. */ + /* NOTE: It appears that this is now an index rather than a + prescaled offset. */ + bfd_put_32 (output_bfd, + plt_entry[4] | reloc_index, + htab->plt->contents + ent->plt.offset + 16); + /* This instruction is a PC-relative branch whose target is + the start of the PLT section. The address of this branch + instruction is 20 bytes beyond the start of this PLT entry. + The address is encoded in bits 6-29, inclusive. The value + stored is right-shifted by two bits, permitting a 26-bit + offset. */ + bfd_put_32 (output_bfd, + (plt_entry[5] + | (-(ent->plt.offset + 20) & 0x03fffffc)), + htab->plt->contents + ent->plt.offset + 20); + bfd_put_32 (output_bfd, plt_entry[6], + htab->plt->contents + ent->plt.offset + 24); + bfd_put_32 (output_bfd, plt_entry[7], + htab->plt->contents + ent->plt.offset + 28); - return TRUE; -} - -/* Very simple linked list structure for recording apuinfo values. */ -typedef struct apuinfo_list -{ - struct apuinfo_list *next; - unsigned long value; -} -apuinfo_list; + /* Fill in the GOT entry corresponding to this PLT slot with + the address immediately after the the "bctr" instruction + in this PLT entry. */ + bfd_put_32 (output_bfd, (htab->plt->output_section->vma + + htab->plt->output_offset + + ent->plt.offset + 16), + htab->sgotplt->contents + got_offset); -static apuinfo_list *head; + if (!info->shared) + { + /* Fill in a couple of entries in .rela.plt.unloaded. */ + loc = htab->srelplt2->contents + + ((VXWORKS_PLTRESOLVE_RELOCS + reloc_index + * VXWORKS_PLT_NON_JMP_SLOT_RELOCS) + * sizeof (Elf32_External_Rela)); + /* Provide the @ha relocation for the first instruction. */ + rela.r_offset = (htab->plt->output_section->vma + + htab->plt->output_offset + + ent->plt.offset + 2); + rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, + R_PPC_ADDR16_HA); + rela.r_addend = got_offset; + bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); + loc += sizeof (Elf32_External_Rela); -static void -apuinfo_list_init (void) -{ - head = NULL; -} + /* Provide the @l relocation for the second instruction. */ + rela.r_offset = (htab->plt->output_section->vma + + htab->plt->output_offset + + ent->plt.offset + 6); + rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, + R_PPC_ADDR16_LO); + rela.r_addend = got_offset; + bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); + loc += sizeof (Elf32_External_Rela); -static void -apuinfo_list_add (unsigned long value) -{ - apuinfo_list *entry = head; + /* Provide a relocation for the GOT entry corresponding to this + PLT slot. Point it at the middle of the .plt entry. */ + rela.r_offset = (htab->sgotplt->output_section->vma + + htab->sgotplt->output_offset + + got_offset); + rela.r_info = ELF32_R_INFO (htab->elf.hplt->indx, + R_PPC_ADDR32); + rela.r_addend = ent->plt.offset + 16; + bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); + } - while (entry != NULL) - { - if (entry->value == value) - return; - entry = entry->next; - } + /* VxWorks uses non-standard semantics for R_PPC_JMP_SLOT. + In particular, the offset for the relocation is not the + address of the PLT entry for this function, as specified + by the ABI. Instead, the offset is set to the address of + the GOT slot for this function. See EABI 4.4.4.1. */ + rela.r_offset = (htab->sgotplt->output_section->vma + + htab->sgotplt->output_offset + + got_offset); - entry = bfd_malloc (sizeof (* entry)); - if (entry == NULL) - return; + } + else + { + rela.r_offset = (htab->plt->output_section->vma + + htab->plt->output_offset + + ent->plt.offset); + if (htab->plt_type == PLT_OLD) + { + /* We don't need to fill in the .plt. The ppc dynamic + linker will fill it in. */ + } + else + { + bfd_vma val = (htab->glink_pltresolve + ent->plt.offset + + htab->glink->output_section->vma + + htab->glink->output_offset); + bfd_put_32 (output_bfd, val, + htab->plt->contents + ent->plt.offset); + } + } - entry->value = value; - entry->next = head; - head = entry; -} + /* Fill in the entry in the .rela.plt section. */ + rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_JMP_SLOT); + rela.r_addend = 0; -static unsigned -apuinfo_list_length (void) -{ - apuinfo_list *entry; - unsigned long count; + loc = (htab->relplt->contents + + reloc_index * sizeof (Elf32_External_Rela)); + bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); - for (entry = head, count = 0; - entry; - entry = entry->next) - ++ count; + if (!h->def_regular) + { + /* Mark the symbol as undefined, rather than as defined in + the .plt section. Leave the value alone. */ + sym->st_shndx = SHN_UNDEF; + /* If the symbol is weak, we do need to clear the value. + Otherwise, the PLT entry would provide a definition for + the symbol even if the symbol wasn't defined anywhere, + and so the symbol would never be NULL. */ + if (!h->ref_regular_nonweak) + sym->st_value = 0; + } + doneone = TRUE; + } - return count; -} + if (htab->plt_type == PLT_NEW) + { + bfd_vma plt; + unsigned char *p; -static inline unsigned long -apuinfo_list_element (unsigned long number) -{ - apuinfo_list * entry; + plt = (ent->plt.offset + + htab->plt->output_section->vma + + htab->plt->output_offset); + p = (unsigned char *) htab->glink->contents + ent->glink_offset; - for (entry = head; - entry && number --; - entry = entry->next) - ; + if (info->shared || info->pie) + { + bfd_vma got = 0; - return entry ? entry->value : 0; -} + if (ent->addend >= 32768) + got = (ent->addend + + ent->sec->output_section->vma + + ent->sec->output_offset); + else if (htab->elf.hgot != NULL) + got = (htab->elf.hgot->root.u.def.value + + htab->elf.hgot->root.u.def.section->output_section->vma + + htab->elf.hgot->root.u.def.section->output_offset); -static void -apuinfo_list_finish (void) -{ - apuinfo_list *entry; + plt -= got; - for (entry = head; entry;) + if (plt + 0x8000 < 0x10000) + { + bfd_put_32 (output_bfd, LWZ_11_30 + PPC_LO (plt), p); + p += 4; + bfd_put_32 (output_bfd, MTCTR_11, p); + p += 4; + bfd_put_32 (output_bfd, BCTR, p); + p += 4; + bfd_put_32 (output_bfd, NOP, p); + p += 4; + } + else + { + bfd_put_32 (output_bfd, ADDIS_11_30 + PPC_HA (plt), p); + p += 4; + bfd_put_32 (output_bfd, LWZ_11_11 + PPC_LO (plt), p); + p += 4; + bfd_put_32 (output_bfd, MTCTR_11, p); + p += 4; + bfd_put_32 (output_bfd, BCTR, p); + p += 4; + } + } + else + { + bfd_put_32 (output_bfd, LIS_11 + PPC_HA (plt), p); + p += 4; + bfd_put_32 (output_bfd, LWZ_11_11 + PPC_LO (plt), p); + p += 4; + bfd_put_32 (output_bfd, MTCTR_11, p); + p += 4; + bfd_put_32 (output_bfd, BCTR, p); + p += 4; + + /* We only need one non-PIC glink stub. */ + break; + } + } + else + break; + } + + if (h->needs_copy) { - apuinfo_list *next = entry->next; - free (entry); - entry = next; - } + asection *s; + Elf_Internal_Rela rela; + bfd_byte *loc; - head = NULL; -} + /* This symbols needs a copy reloc. Set it up. */ -#define APUINFO_SECTION_NAME ".PPC.EMB.apuinfo" -#define APUINFO_LABEL "APUinfo" +#ifdef DEBUG + fprintf (stderr, ", copy"); +#endif -/* Scan the input BFDs and create a linked list of - the APUinfo values that will need to be emitted. */ + BFD_ASSERT (h->dynindx != -1); -static void -ppc_elf_begin_write_processing (bfd *abfd, struct bfd_link_info *link_info) -{ - bfd *ibfd; - asection *asec; - char *buffer; - unsigned num_input_sections; - bfd_size_type output_section_size; - unsigned i; - unsigned num_entries; - unsigned long offset; - unsigned long length; - const char *error_message = NULL; + if (ppc_elf_hash_entry (h)->has_sda_refs) + s = htab->relsbss; + else + s = htab->relbss; + BFD_ASSERT (s != NULL); - if (link_info == NULL) - return; + rela.r_offset = (h->root.u.def.value + + h->root.u.def.section->output_section->vma + + h->root.u.def.section->output_offset); + rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_COPY); + rela.r_addend = 0; + loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela); + bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); + } - /* Scan the input bfds, looking for apuinfo sections. */ - num_input_sections = 0; - output_section_size = 0; +#ifdef DEBUG + fprintf (stderr, "\n"); +#endif - for (ibfd = link_info->input_bfds; ibfd; ibfd = ibfd->link_next) + /* Mark some specially defined symbols as absolute. */ + if (strcmp (h->root.root.string, "_DYNAMIC") == 0 + || (!htab->is_vxworks + && (h == htab->elf.hgot + || strcmp (h->root.root.string, + "_PROCEDURE_LINKAGE_TABLE_") == 0))) + sym->st_shndx = SHN_ABS; + + return TRUE; +} + +static enum elf_reloc_type_class +ppc_elf_reloc_type_class (const Elf_Internal_Rela *rela) +{ + switch (ELF32_R_TYPE (rela->r_info)) { - asec = bfd_get_section_by_name (ibfd, APUINFO_SECTION_NAME); - if (asec) - { - ++ num_input_sections; - output_section_size += asec->_raw_size; - } + case R_PPC_RELATIVE: + return reloc_class_relative; + case R_PPC_REL24: + case R_PPC_ADDR24: + case R_PPC_JMP_SLOT: + return reloc_class_plt; + case R_PPC_COPY: + return reloc_class_copy; + default: + return reloc_class_normal; } +} + +/* Finish up the dynamic sections. */ - /* We need at least one input sections - in order to make merging worthwhile. */ - if (num_input_sections < 1) - return; +static bfd_boolean +ppc_elf_finish_dynamic_sections (bfd *output_bfd, + struct bfd_link_info *info) +{ + asection *sdyn; + asection *splt; + struct ppc_elf_link_hash_table *htab; + bfd_vma got; + bfd * dynobj; - /* Just make sure that the output section exists as well. */ - asec = bfd_get_section_by_name (abfd, APUINFO_SECTION_NAME); - if (asec == NULL) - return; +#ifdef DEBUG + fprintf (stderr, "ppc_elf_finish_dynamic_sections called\n"); +#endif - /* Allocate a buffer for the contents of the input sections. */ - buffer = bfd_malloc (output_section_size); - if (buffer == NULL) - return; + htab = ppc_elf_hash_table (info); + dynobj = elf_hash_table (info)->dynobj; + sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); + if (htab->is_vxworks) + splt = bfd_get_section_by_name (dynobj, ".plt"); + else + splt = NULL; - offset = 0; - apuinfo_list_init (); + got = 0; + if (htab->elf.hgot != NULL) + got = (htab->elf.hgot->root.u.def.value + + htab->elf.hgot->root.u.def.section->output_section->vma + + htab->elf.hgot->root.u.def.section->output_offset); - /* Read in the input sections contents. */ - for (ibfd = link_info->input_bfds; ibfd; ibfd = ibfd->link_next) + if (htab->elf.dynamic_sections_created) { - unsigned long datum; - char *ptr; - - asec = bfd_get_section_by_name (ibfd, APUINFO_SECTION_NAME); - if (asec == NULL) - continue; + Elf32_External_Dyn *dyncon, *dynconend; - length = asec->_raw_size; - if (length < 24) - { - error_message = _("corrupt or empty %s section in %s"); - goto fail; - } + BFD_ASSERT (htab->plt != NULL && sdyn != NULL); - if (bfd_seek (ibfd, asec->filepos, SEEK_SET) != 0 - || (bfd_bread (buffer + offset, length, ibfd) != length)) + dyncon = (Elf32_External_Dyn *) sdyn->contents; + dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size); + for (; dyncon < dynconend; dyncon++) { - error_message = _("unable to read in %s section from %s"); - goto fail; - } + Elf_Internal_Dyn dyn; + asection *s; - /* Process the contents of the section. */ - ptr = buffer + offset; - error_message = _("corrupt %s section in %s"); + bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); - /* Verify the contents of the header. Note - we have to - extract the values this way in order to allow for a - host whose endian-ness is different from the target. */ - datum = bfd_get_32 (ibfd, ptr); - if (datum != sizeof APUINFO_LABEL) - goto fail; + switch (dyn.d_tag) + { + case DT_PLTGOT: + if (htab->is_vxworks) + s = htab->sgotplt; + else + s = htab->plt; + dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; + break; - datum = bfd_get_32 (ibfd, ptr + 8); - if (datum != 0x2) - goto fail; + case DT_PLTRELSZ: + dyn.d_un.d_val = htab->relplt->size; + break; - if (strcmp (ptr + 12, APUINFO_LABEL) != 0) - goto fail; + case DT_JMPREL: + s = htab->relplt; + dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; + break; - /* Get the number of bytes used for apuinfo entries. */ - datum = bfd_get_32 (ibfd, ptr + 4); - if (datum + 20 != length) - goto fail; + case DT_PPC_GOT: + dyn.d_un.d_ptr = got; + break; - /* Make sure that we do not run off the end of the section. */ - if (offset + length > output_section_size) - goto fail; + case DT_RELASZ: + if (htab->is_vxworks) + { + if (htab->relplt) + dyn.d_un.d_ptr -= htab->relplt->size; + break; + } + continue; - /* Scan the apuinfo section, building a list of apuinfo numbers. */ - for (i = 0; i < datum; i += 4) - apuinfo_list_add (bfd_get_32 (ibfd, ptr + 20 + i)); + default: + continue; + } - /* Update the offset. */ - offset += length; + bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); + } } - error_message = NULL; - - /* Compute the size of the output section. */ - num_entries = apuinfo_list_length (); - output_section_size = 20 + num_entries * 4; + /* Add a blrl instruction at _GLOBAL_OFFSET_TABLE_-4 so that a function can + easily find the address of the _GLOBAL_OFFSET_TABLE_. */ + if (htab->got != NULL) + { + unsigned char *p = htab->got->contents; + bfd_vma val; - asec = bfd_get_section_by_name (abfd, APUINFO_SECTION_NAME); + p += htab->elf.hgot->root.u.def.value; + if (htab->plt_type == PLT_OLD) + bfd_put_32 (output_bfd, 0x4e800021 /* blrl */, p - 4); - if (! bfd_set_section_size (abfd, asec, output_section_size)) - ibfd = abfd, - error_message = _("warning: unable to set size of %s section in %s"); + val = 0; + if (sdyn != NULL) + val = sdyn->output_section->vma + sdyn->output_offset; + bfd_put_32 (output_bfd, val, p); - fail: - free (buffer); + elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 4; + } - if (error_message) - (*_bfd_error_handler) (error_message, APUINFO_SECTION_NAME, - bfd_archive_filename (ibfd)); -} + /* Fill in the first entry in the VxWorks procedure linkage table. */ + if (splt && splt->size > 0) + { + /* Use the right PLT. */ + static const bfd_vma *plt_entry = NULL; + plt_entry = info->shared ? + ppc_elf_vxworks_pic_plt0_entry : ppc_elf_vxworks_plt0_entry; + if (!info->shared) + { + bfd_vma got_value = + (htab->elf.hgot->root.u.def.section->output_section->vma + + htab->elf.hgot->root.u.def.section->output_offset + + htab->elf.hgot->root.u.def.value); + bfd_vma got_hi = (got_value >> 16) + ((got_value & 0x8000) >> 15); -/* Prevent the output section from accumulating the input sections' - contents. We have already stored this in our linked list structure. */ + bfd_put_32 (output_bfd, plt_entry[0] | (got_hi & 0xffff), + splt->contents + 0); + bfd_put_32 (output_bfd, plt_entry[1] | (got_value & 0xffff), + splt->contents + 4); + } + else + { + bfd_put_32 (output_bfd, plt_entry[0], splt->contents + 0); + bfd_put_32 (output_bfd, plt_entry[1], splt->contents + 4); + } + bfd_put_32 (output_bfd, plt_entry[2], splt->contents + 8); + bfd_put_32 (output_bfd, plt_entry[3], splt->contents + 12); + bfd_put_32 (output_bfd, plt_entry[4], splt->contents + 16); + bfd_put_32 (output_bfd, plt_entry[5], splt->contents + 20); + bfd_put_32 (output_bfd, plt_entry[6], splt->contents + 24); + bfd_put_32 (output_bfd, plt_entry[7], splt->contents + 28); -static bfd_boolean -ppc_elf_write_section (bfd *abfd ATTRIBUTE_UNUSED, - asection *asec, - bfd_byte *contents ATTRIBUTE_UNUSED) -{ - return (apuinfo_list_length () - && strcmp (asec->name, APUINFO_SECTION_NAME) == 0); -} + if (! info->shared) + { + Elf_Internal_Rela rela; + bfd_byte *loc; + loc = htab->srelplt2->contents; -/* Finally we can generate the output section. */ + /* Output the @ha relocation for the first instruction. */ + rela.r_offset = (htab->plt->output_section->vma + + htab->plt->output_offset + + 2); + rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_HA); + rela.r_addend = 0; + bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); + loc += sizeof (Elf32_External_Rela); + + /* Output the @l relocation for the second instruction. */ + rela.r_offset = (htab->plt->output_section->vma + + htab->plt->output_offset + + 6); + rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_LO); + rela.r_addend = 0; + bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); + loc += sizeof (Elf32_External_Rela); -static void -ppc_elf_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED) -{ - bfd_byte *buffer; - asection *asec; - unsigned i; - unsigned num_entries; - bfd_size_type length; + /* Fix up the remaining relocations. They may have the wrong + symbol index for _G_O_T_ or _P_L_T_ depending on the order + in which symbols were output. */ + while (loc < htab->srelplt2->contents + htab->srelplt2->size) + { + Elf_Internal_Rela rel; - asec = bfd_get_section_by_name (abfd, APUINFO_SECTION_NAME); - if (asec == NULL) - return; + bfd_elf32_swap_reloc_in (output_bfd, loc, &rel); + rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_HA); + bfd_elf32_swap_reloc_out (output_bfd, &rel, loc); + loc += sizeof (Elf32_External_Rela); - if (apuinfo_list_length () == 0) - return; + bfd_elf32_swap_reloc_in (output_bfd, loc, &rel); + rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_LO); + bfd_elf32_swap_reloc_out (output_bfd, &rel, loc); + loc += sizeof (Elf32_External_Rela); - length = asec->_raw_size; - if (length < 20) - return; + bfd_elf32_swap_reloc_in (output_bfd, loc, &rel); + rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_PPC_ADDR32); + bfd_elf32_swap_reloc_out (output_bfd, &rel, loc); + loc += sizeof (Elf32_External_Rela); + } + } + } - buffer = bfd_malloc (length); - if (buffer == NULL) + if (htab->glink != NULL && htab->glink->contents != NULL) { - (*_bfd_error_handler) - (_("failed to allocate space for new APUinfo section.")); - return; - } + unsigned char *p; + unsigned char *endp; + bfd_vma res0; + unsigned int i; - /* Create the apuinfo header. */ - num_entries = apuinfo_list_length (); - bfd_put_32 (abfd, sizeof APUINFO_LABEL, buffer); - bfd_put_32 (abfd, num_entries * 4, buffer + 4); - bfd_put_32 (abfd, 0x2, buffer + 8); - strcpy (buffer + 12, APUINFO_LABEL); + /* + * PIC glink code is the following: + * + * # ith PLT code stub. + * addis 11,30,(plt+(i-1)*4-got)@ha + * lwz 11,(plt+(i-1)*4-got)@l(11) + * mtctr 11 + * bctr + * + * # A table of branches, one for each plt entry. + * # The idea is that the plt call stub loads ctr (and r11) with these + * # addresses, so (r11 - res_0) gives the plt index * 4. + * res_0: b PLTresolve + * res_1: b PLTresolve + * . + * # Some number of entries towards the end can be nops + * res_n_m3: nop + * res_n_m2: nop + * res_n_m1: + * + * PLTresolve: + * addis 11,11,(1f-res_0)@ha + * mflr 0 + * bcl 20,31,1f + * 1: addi 11,11,(1b-res_0)@l + * mflr 12 + * mtlr 0 + * sub 11,11,12 # r11 = index * 4 + * addis 12,12,(got+4-1b)@ha + * lwz 0,(got+4-1b)@l(12) # got[1] address of dl_runtime_resolve + * lwz 12,(got+8-1b)@l(12) # got[2] contains the map address + * mtctr 0 + * add 0,11,11 + * add 11,0,11 # r11 = index * 12 = reloc offset. + * bctr + */ + static const unsigned int pic_plt_resolve[] = + { + ADDIS_11_11, + MFLR_0, + BCL_20_31, + ADDI_11_11, + MFLR_12, + MTLR_0, + SUB_11_11_12, + ADDIS_12_12, + LWZ_0_12, + LWZ_12_12, + MTCTR_0, + ADD_0_11_11, + ADD_11_0_11, + BCTR, + NOP, + NOP + }; - length = 20; - for (i = 0; i < num_entries; i++) - { - bfd_put_32 (abfd, apuinfo_list_element (i), buffer + length); - length += 4; - } + static const unsigned int plt_resolve[] = + { + LIS_12, + ADDIS_11_11, + LWZ_0_12, + ADDI_11_11, + MTCTR_0, + ADD_0_11_11, + LWZ_12_12, + ADD_11_0_11, + BCTR, + NOP, + NOP, + NOP, + NOP, + NOP, + NOP, + NOP + }; - if (length != asec->_raw_size) - (*_bfd_error_handler) (_("failed to compute new APUinfo section.")); + if (ARRAY_SIZE (pic_plt_resolve) != GLINK_PLTRESOLVE / 4) + abort (); + if (ARRAY_SIZE (plt_resolve) != GLINK_PLTRESOLVE / 4) + abort (); - if (! bfd_set_section_contents (abfd, asec, buffer, (file_ptr) 0, length)) - (*_bfd_error_handler) (_("failed to install new APUinfo section.")); + /* Build the branch table, one for each plt entry (less one), + and perhaps some padding. */ + p = htab->glink->contents; + p += htab->glink_pltresolve; + endp = htab->glink->contents; + endp += htab->glink->size - GLINK_PLTRESOLVE; + while (p < endp - 8 * 4) + { + bfd_put_32 (output_bfd, B + endp - p, p); + p += 4; + } + while (p < endp) + { + bfd_put_32 (output_bfd, NOP, p); + p += 4; + } - free (buffer); + res0 = (htab->glink_pltresolve + + htab->glink->output_section->vma + + htab->glink->output_offset); - apuinfo_list_finish (); -} + /* Last comes the PLTresolve stub. */ + if (info->shared || info->pie) + { + bfd_vma bcl; -/* Add extra PPC sections -- Note, for now, make .sbss2 and - .PPC.EMB.sbss0 a normal section, and not a bss section so - that the linker doesn't crater when trying to make more than - 2 sections. */ + for (i = 0; i < ARRAY_SIZE (pic_plt_resolve); i++) + { + bfd_put_32 (output_bfd, pic_plt_resolve[i], p); + p += 4; + } + p -= 4 * ARRAY_SIZE (pic_plt_resolve); -static struct bfd_elf_special_section const ppc_elf_special_sections[]= -{ - { ".tags", 5, 0, SHT_ORDERED, SHF_ALLOC }, - { ".sdata", 6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE }, - { ".sbss", 5, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE }, - { ".sdata2", 7, -2, SHT_PROGBITS, SHF_ALLOC }, - { ".sbss2", 6, -2, SHT_PROGBITS, SHF_ALLOC }, - { ".PPC.EMB.apuinfo", 16, 0, SHT_NOTE, 0 }, - { ".PPC.EMB.sdata0", 15, 0, SHT_PROGBITS, SHF_ALLOC }, - { ".PPC.EMB.sbss0", 14, 0, SHT_PROGBITS, SHF_ALLOC }, - { ".plt", 4, 0, SHT_NOBITS, SHF_ALLOC + SHF_EXECINSTR }, - { NULL, 0, 0, 0, 0 } -}; + bcl = (htab->glink->size - GLINK_PLTRESOLVE + 3*4 + + htab->glink->output_section->vma + + htab->glink->output_offset); + + bfd_put_32 (output_bfd, + ADDIS_11_11 + PPC_HA (bcl - res0), p + 0*4); + bfd_put_32 (output_bfd, + ADDI_11_11 + PPC_LO (bcl - res0), p + 3*4); + bfd_put_32 (output_bfd, + ADDIS_12_12 + PPC_HA (got + 4 - bcl), p + 7*4); + if (PPC_HA (got + 4 - bcl) == PPC_HA (got + 8 - bcl)) + { + bfd_put_32 (output_bfd, + LWZ_0_12 + PPC_LO (got + 4 - bcl), p + 8*4); + bfd_put_32 (output_bfd, + LWZ_12_12 + PPC_LO (got + 8 - bcl), p + 9*4); + } + else + { + bfd_put_32 (output_bfd, + LWZU_0_12 + PPC_LO (got + 4 - bcl), p + 8*4); + bfd_put_32 (output_bfd, + LWZ_12_12 + 4, p + 9*4); + } + } + else + { + for (i = 0; i < ARRAY_SIZE (plt_resolve); i++) + { + bfd_put_32 (output_bfd, plt_resolve[i], p); + p += 4; + } + p -= 4 * ARRAY_SIZE (plt_resolve); + + bfd_put_32 (output_bfd, + LIS_12 + PPC_HA (got + 4), p + 0*4); + bfd_put_32 (output_bfd, + ADDIS_11_11 + PPC_HA (-res0), p + 1*4); + bfd_put_32 (output_bfd, + ADDI_11_11 + PPC_LO (-res0), p + 3*4); + if (PPC_HA (got + 4) == PPC_HA (got + 8)) + { + bfd_put_32 (output_bfd, + LWZ_0_12 + PPC_LO (got + 4), p + 2*4); + bfd_put_32 (output_bfd, + LWZ_12_12 + PPC_LO (got + 8), p + 6*4); + } + else + { + bfd_put_32 (output_bfd, + LWZU_0_12 + PPC_LO (got + 4), p + 2*4); + bfd_put_32 (output_bfd, + LWZ_12_12 + 4, p + 6*4); + } + } + } + + return TRUE; +} #define TARGET_LITTLE_SYM bfd_elf32_powerpcle_vec #define TARGET_LITTLE_NAME "elf32-powerpcle" @@ -6158,6 +7435,7 @@ static struct bfd_elf_special_section const ppc_elf_special_sections[]= #else #define ELF_MAXPAGESIZE 0x10000 #endif +#define ELF_MINPAGESIZE 0x1000 #define elf_info_to_howto ppc_elf_info_to_howto #ifdef EM_CYGNUS_POWERPC @@ -6169,10 +7447,8 @@ static struct bfd_elf_special_section const ppc_elf_special_sections[]= #endif #define elf_backend_plt_not_loaded 1 -#define elf_backend_got_symbol_offset 4 #define elf_backend_can_gc_sections 1 #define elf_backend_can_refcount 1 -#define elf_backend_got_header_size 12 #define elf_backend_rela_normal 1 #define bfd_elf32_mkobject ppc_elf_mkobject @@ -6197,13 +7473,121 @@ static struct bfd_elf_special_section const ppc_elf_special_sections[]= #define elf_backend_finish_dynamic_sections ppc_elf_finish_dynamic_sections #define elf_backend_fake_sections ppc_elf_fake_sections #define elf_backend_additional_program_headers ppc_elf_additional_program_headers -#define elf_backend_modify_segment_map ppc_elf_modify_segment_map #define elf_backend_grok_prstatus ppc_elf_grok_prstatus #define elf_backend_grok_psinfo ppc_elf_grok_psinfo #define elf_backend_reloc_type_class ppc_elf_reloc_type_class #define elf_backend_begin_write_processing ppc_elf_begin_write_processing #define elf_backend_final_write_processing ppc_elf_final_write_processing #define elf_backend_write_section ppc_elf_write_section -#define elf_backend_special_sections ppc_elf_special_sections +#define elf_backend_get_sec_type_attr ppc_elf_get_sec_type_attr +#define elf_backend_plt_sym_val ppc_elf_plt_sym_val +#define elf_backend_action_discarded ppc_elf_action_discarded + +#include "elf32-target.h" + +/* VxWorks Target */ + +#undef TARGET_LITTLE_SYM +#undef TARGET_LITTLE_NAME + +#undef TARGET_BIG_SYM +#define TARGET_BIG_SYM bfd_elf32_powerpc_vxworks_vec +#undef TARGET_BIG_NAME +#define TARGET_BIG_NAME "elf32-powerpc-vxworks" + +/* VxWorks uses the elf default section flags for .plt. */ +static const struct bfd_elf_special_section * +ppc_elf_vxworks_get_sec_type_attr (bfd *abfd ATTRIBUTE_UNUSED, asection *sec) +{ + if (sec->name == NULL) + return NULL; + + if (strcmp (sec->name, ".plt") == 0) + return _bfd_elf_get_sec_type_attr (abfd, sec); + + return ppc_elf_get_sec_type_attr (abfd, sec); +} + +/* Like ppc_elf_link_hash_table_create, but overrides + appropriately for VxWorks. */ +static struct bfd_link_hash_table * +ppc_elf_vxworks_link_hash_table_create (bfd *abfd) +{ + struct bfd_link_hash_table *ret; + + ret = ppc_elf_link_hash_table_create (abfd); + if (ret) + { + struct ppc_elf_link_hash_table *htab + = (struct ppc_elf_link_hash_table *)ret; + htab->is_vxworks = 1; + htab->plt_type = PLT_VXWORKS; + htab->plt_entry_size = VXWORKS_PLT_ENTRY_SIZE; + htab->plt_slot_size = VXWORKS_PLT_ENTRY_SIZE; + htab->plt_initial_entry_size = VXWORKS_PLT_INITIAL_ENTRY_SIZE; + } + return ret; +} + +/* Tweak magic VxWorks symbols as they are loaded. */ +static bfd_boolean +ppc_elf_vxworks_add_symbol_hook (bfd *abfd, + struct bfd_link_info *info, + Elf_Internal_Sym *sym, + const char **namep ATTRIBUTE_UNUSED, + flagword *flagsp ATTRIBUTE_UNUSED, + asection **secp, + bfd_vma *valp) +{ + if (!elf_vxworks_add_symbol_hook(abfd, info, sym,namep, flagsp, secp, + valp)) + return FALSE; + + return ppc_elf_add_symbol_hook(abfd, info, sym,namep, flagsp, secp, valp); +} + +static void +ppc_elf_vxworks_final_write_processing (bfd *abfd, bfd_boolean linker) +{ + ppc_elf_final_write_processing(abfd, linker); + elf_vxworks_final_write_processing(abfd, linker); +} + +/* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so + define it. */ +#undef elf_backend_want_plt_sym +#define elf_backend_want_plt_sym 1 +#undef elf_backend_want_got_plt +#define elf_backend_want_got_plt 1 +#undef elf_backend_got_symbol_offset +#define elf_backend_got_symbol_offset 0 +#undef elf_backend_plt_not_loaded +#define elf_backend_plt_not_loaded 0 +#undef elf_backend_plt_readonly +#define elf_backend_plt_readonly 1 +#undef elf_backend_got_header_size +#define elf_backend_got_header_size 12 + +#undef bfd_elf32_bfd_link_hash_table_create +#define bfd_elf32_bfd_link_hash_table_create \ + ppc_elf_vxworks_link_hash_table_create +#undef elf_backend_add_symbol_hook +#define elf_backend_add_symbol_hook \ + ppc_elf_vxworks_add_symbol_hook +#undef elf_backend_link_output_symbol_hook +#define elf_backend_link_output_symbol_hook \ + elf_vxworks_link_output_symbol_hook +#undef elf_backend_final_write_processing +#define elf_backend_final_write_processing \ + ppc_elf_vxworks_final_write_processing +#undef elf_backend_get_sec_type_attr +#define elf_backend_get_sec_type_attr \ + ppc_elf_vxworks_get_sec_type_attr +#undef elf_backend_emit_relocs +#define elf_backend_emit_relocs \ + elf_vxworks_emit_relocs + +#undef elf32_bed +#define elf32_bed ppc_elf_vxworks_bed #include "elf32-target.h" |