Merge ^vendor/binutils/dist@214082 into contrib/binutils.

1 files changed, 3684 insertions, 2300 deletions

diff --git a/contrib/binutils/bfd/elf32-ppc.c b/contrib/binutils/bfd/elf32-ppc.c
index 4eb08ad..53d1046 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 ();
-
-	  /* 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;
-
-	      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;
-	}
+/* 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 */
+  };
 
-      edir->dyn_relocs = eind->dyn_relocs;
-      eind->dyn_relocs = NULL;
-    }
+/* 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              */
+  };
 
-  edir->tls_mask |= eind->tls_mask;
+/* For executables, we have some additional relocations in
+   .rela.plt.unloaded, for the kernel loader.  */
+
+/* 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
+
+/* 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.
-
-	     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));
-	    }
-	}
+  length = asec->size;
+  if (length < 20)
+    return;
+
+  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);
-
-      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;
-
-      h->type = STT_OBJECT;
-      lsect->sym_hash = h;
-
-      if (info->shared
-	  && ! bfd_elf_link_record_dynamic_symbol (info, h))
-	return NULL;
+#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;
+
+  /* Size of reserved GOT entries.  */
+  unsigned int got_header_size;
+  /* Non-zero if allocating the header left a gap.  */
+  unsigned int got_gap;
+
+  /* The type of PLT we have chosen to use.  */
+  enum ppc_elf_plt_type plt_type;
+
+  /* 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 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;
+
+  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 we were called to copy over info for a weak sym, that's all.  */
+  if (eind->elf.root.type != bfd_link_hash_indirect)
+    return;
 
-  /* 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;
+  /* 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;
 
-  /* 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;
-
-  if (ELIMINATE_COPY_RELOCS)
+  /* And plt entries.  */
+  if (eind->elf.plt.plist != NULL)
     {
-      struct ppc_elf_dyn_relocs *p;
-      for (p = ppc_elf_hash_entry (h)->dyn_relocs; p != NULL; p = p->next)
+      if (edir->elf.plt.plist != NULL)
 	{
-	  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;
-	}
-    }
-
-  /* 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.
+	  struct plt_entry **entp;
+	  struct plt_entry *ent;
 
-     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.  */
-
-  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;
-
-  if (h->root.type == bfd_link_hash_indirect)
-    return TRUE;
+  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_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
-      && h->plt.refcount > 0)
-    {
-      /* 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;
-	}
-
-      if (info->shared
-	  || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
-	{
-	  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;
-	    }
-
-	  /* 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;
+  return (targ == &bfd_elf32_powerpc_vec
+	  || targ == &bfd_elf32_powerpc_vxworks_vec
+	  || targ == &bfd_elf32_powerpcle_vec);
+}
 
-	  /* 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;
-    }
+/* 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.  */
 
-  eh = (struct ppc_elf_link_hash_entry *) h;
-  if (eh->elf.got.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 (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))
-	    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.  */
+      /* 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)
-    {
-      /* 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))
+      htab = ppc_elf_hash_table (info);
+      if (htab->sbss == NULL)
 	{
-	  struct ppc_elf_dyn_relocs **pp;
+	  flagword flags = SEC_IS_COMMON | SEC_LINKER_CREATED;
 
-	  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;
-	    }
-	}
+	  if (!htab->elf.dynobj)
+	    htab->elf.dynobj = abfd;
 
-      /* 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))
+	  htab->sbss = bfd_make_section_anyway_with_flags (htab->elf.dynobj,
+							   ".sbss",
+							   flags);
+	  if (htab->sbss == NULL)
 	    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;
+
+      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;
+	    }
+	}
+    }
 
-      /* This symbols needs a copy reloc.  Set it up.  */
+  /* 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;
 
-#ifdef DEBUG
-      fprintf (stderr, ", copy");
-#endif
+      if ((s->flags & SEC_LINKER_CREATED) == 0)
+	continue;
 
-      BFD_ASSERT (h->dynindx != -1);
+      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;
 
-      if (h->size <= elf_gp_size (htab->elf.dynobj))
-	s = htab->relsbss;
+	      /* 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;
+
+      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 (sdyn == NULL)
-	bfd_put_32 (output_bfd, 0, contents + 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;
-
-  switch (note->descsz)
-    {
-    default:
-      return FALSE;
-
-    case 268:		/* Linux/PPC.  */
-      /* pr_cursig */
-      elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
+  struct ppc_elf_link_hash_table *htab;
+  struct plt_entry *ent;
+  bfd_boolean doneone;
 
-      /* pr_pid */
-      elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
+#ifdef DEBUG
+  fprintf (stderr, "ppc_elf_finish_dynamic_symbol called for %s",
+	   h->root.root.string);
+#endif
 
-      /* pr_reg */
-      offset = 72;
-      raw_size = 192;
+  htab = ppc_elf_hash_table (info);
+  BFD_ASSERT (htab->elf.dynobj != NULL);
 
-      break;
-    }
+  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;
 
-  /* Make a ".reg/999" section.  */
-  return _bfd_elfcore_make_pseudosection (abfd, ".reg",
-					  raw_size, note->descpos + offset);
-}
+	    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;
+	      }
 
-static bfd_boolean
-ppc_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
-{
-  switch (note->descsz)
-    {
-    default:
-      return FALSE;
+	    /* 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;
 
-    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);
-    }
+		/* Use the right PLT. */
+		plt_entry = info->shared ? ppc_elf_vxworks_pic_plt_entry
+			    : ppc_elf_vxworks_plt_entry;
 
-  /* 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.  */
+		/* Fill in the .plt on VxWorks.  */
+		if (info->shared)
+		  {
+		    bfd_vma got_offset_hi = (got_offset >> 16)
+					    + ((got_offset & 0x8000) >> 15);
+
+		    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);
+
+		    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);
+
+		/* 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);
+
+		/* 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);
+
+		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);
+
+		    /* 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);
+
+		    /* 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);
+		  }
 
-    if (0 < n && command[n - 1] == ' ')
-      command[n - 1] = '\0';
-  }
+		/* 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);
 
-  return TRUE;
-}
-
-/* Very simple linked list structure for recording apuinfo values.  */
-typedef struct apuinfo_list
-{
-  struct apuinfo_list *next;
-  unsigned long value;
-}
-apuinfo_list;
+	      }
+	    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);
+		  }
+	      }
 
-static apuinfo_list *head;
+	    /* 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;
 
+	    loc = (htab->relplt->contents
+		   + reloc_index * sizeof (Elf32_External_Rela));
+	    bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
 
-static void
-apuinfo_list_init (void)
-{
-  head = NULL;
-}
+	    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;
+	  }
 
-static void
-apuinfo_list_add (unsigned long value)
-{
-  apuinfo_list *entry = head;
+	if (htab->plt_type == PLT_NEW)
+	  {
+	    bfd_vma plt;
+	    unsigned char *p;
 
-  while (entry != NULL)
-    {
-      if (entry->value == value)
-	return;
-      entry = entry->next;
-    }
+	    plt = (ent->plt.offset
+		   + htab->plt->output_section->vma
+		   + htab->plt->output_offset);
+	    p = (unsigned char *) htab->glink->contents + ent->glink_offset;
 
-  entry = bfd_malloc (sizeof (* entry));
-  if (entry == NULL)
-    return;
+	    if (info->shared || info->pie)
+	      {
+		bfd_vma got = 0;
 
-  entry->value = value;
-  entry->next  = head;
-  head = entry;
-}
+		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 unsigned
-apuinfo_list_length (void)
-{
-  apuinfo_list *entry;
-  unsigned long count;
+		plt -= got;
 
-  for (entry = head, count = 0;
-       entry;
-       entry = entry->next)
-    ++ count;
+		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;
+      }
 
-  return count;
-}
+  if (h->needs_copy)
+    {
+      asection *s;
+      Elf_Internal_Rela rela;
+      bfd_byte *loc;
 
-static inline unsigned long
-apuinfo_list_element (unsigned long number)
-{
-  apuinfo_list * entry;
+      /* This symbols needs a copy reloc.  Set it up.  */
 
-  for (entry = head;
-       entry && number --;
-       entry = entry->next)
-    ;
+#ifdef DEBUG
+      fprintf (stderr, ", copy");
+#endif
 
-  return entry ? entry->value : 0;
-}
+      BFD_ASSERT (h->dynindx != -1);
 
-static void
-apuinfo_list_finish (void)
-{
-  apuinfo_list *entry;
+      if (ppc_elf_hash_entry (h)->has_sda_refs)
+	s = htab->relsbss;
+      else
+	s = htab->relbss;
+      BFD_ASSERT (s != NULL);
 
-  for (entry = head; entry;)
-    {
-      apuinfo_list *next = entry->next;
-      free (entry);
-      entry = next;
+      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);
     }
 
-  head = NULL;
-}
-
-#define APUINFO_SECTION_NAME	".PPC.EMB.apuinfo"
-#define APUINFO_LABEL		"APUinfo"
+#ifdef DEBUG
+  fprintf (stderr, "\n");
+#endif
 
-/* Scan the input BFDs and create a linked list of
-   the APUinfo values that will need to be emitted.  */
+  /* 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;
 
-static void
-ppc_elf_begin_write_processing (bfd *abfd, struct bfd_link_info *link_info)
+  return TRUE;
+}
+
+static enum elf_reloc_type_class
+ppc_elf_reloc_type_class (const Elf_Internal_Rela *rela)
 {
-  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)
+  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;
-
-  asec = bfd_get_section_by_name (abfd, APUINFO_SECTION_NAME);
-
-  if (! bfd_set_section_size (abfd, asec, output_section_size))
-    ibfd = abfd,
-      error_message = _("warning: unable to set size of %s section in %s");
-
- fail:
-  free (buffer);
-
-  if (error_message)
-    (*_bfd_error_handler) (error_message, APUINFO_SECTION_NAME,
-			   bfd_archive_filename (ibfd));
-}
-
-
-/* Prevent the output section from accumulating the input sections'
-   contents.  We have already stored this in our linked list structure.  */
-
-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);
-}
-
-
-/* Finally we can generate the output section.  */
-
-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;
-
-  asec = bfd_get_section_by_name (abfd, APUINFO_SECTION_NAME);
-  if (asec == NULL)
-    return;
+  /* 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;
 
-  if (apuinfo_list_length () == 0)
-    return;
+      p += htab->elf.hgot->root.u.def.value;
+      if (htab->plt_type == PLT_OLD)
+	bfd_put_32 (output_bfd, 0x4e800021 /* blrl */, p - 4);
 
-  length = asec->_raw_size;
-  if (length < 20)
-    return;
+      val = 0;
+      if (sdyn != NULL)
+	val = sdyn->output_section->vma + sdyn->output_offset;
+      bfd_put_32 (output_bfd, val, p);
 
-  buffer = bfd_malloc (length);
-  if (buffer == NULL)
-    {
-      (*_bfd_error_handler)
-	(_("failed to allocate space for new APUinfo section."));
-      return;
+      elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 4;
     }
 
-  /* 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);
-
-  length = 20;
-  for (i = 0; i < num_entries; i++)
+  /* Fill in the first entry in the VxWorks procedure linkage table.  */
+  if (splt && splt->size > 0)
     {
-      bfd_put_32 (abfd, apuinfo_list_element (i), buffer + length);
-      length += 4;
+      /* 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);
+
+	  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);
+
+      if (! info->shared)
+	{
+	  Elf_Internal_Rela rela;
+	  bfd_byte *loc;
+
+	  loc = htab->srelplt2->contents;
+
+	  /* 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);
+
+	  /* 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;
+
+	      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);
+
+	      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);
+
+	      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);
+	    }
+	}
     }
 
-  if (length != asec->_raw_size)
-    (*_bfd_error_handler) (_("failed to compute new APUinfo section."));
+  if (htab->glink != NULL && htab->glink->contents != NULL)
+    {
+      unsigned char *p;
+      unsigned char *endp;
+      bfd_vma res0;
+      unsigned int i;
+
+      /*
+       * 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
+	};
+
+      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 (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);
+
+	  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);
+	    }
+	}
+    }
 
-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 }
-};
+  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"