* elf32-ppc.c: Divide file into general and linker specific

	functions.  Sort linker functions into roughly the order in which
	they are called by the ELF linker code.

2 files changed, 2070 insertions, 2061 deletions

diff --git a/bfd/ChangeLog b/bfd/ChangeLog
index 51592c9..24d8c9f 100644
--- a/bfd/ChangeLog
+++ b/bfd/ChangeLog
@@ -1,5 +1,11 @@
 2005-03-16  Alan Modra  <amodra@bigpond.net.au>
 
+	* elf32-ppc.c: Divide file into general and linker specific
+	functions.  Sort linker functions into roughly the order in which
+	they are called by the ELF linker code.
+
+2005-03-16  Alan Modra  <amodra@bigpond.net.au>
+
 	* elf32-ppc.c (ppc_elf_create_linker_section): Set SEC_LINKER_CREATED
 	on section.  Correct comment, and add FIXME.
 	(ppc_elf_additional_program_headers): Don't bump header count for
diff --git a/bfd/elf32-ppc.c b/bfd/elf32-ppc.c
index 0866e46..5b32f14 100644
--- a/bfd/elf32-ppc.c
+++ b/bfd/elf32-ppc.c
@@ -68,280 +68,6 @@ static bfd_reloc_status_type ppc_elf_unhandled_reloc
 /* 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;
-    }
-
-  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;
-
-  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;
-	}
-
-      edir->dyn_relocs = eind->dyn_relocs;
-      eind->dyn_relocs = NULL;
-    }
-
-  edir->tls_mask |= eind->tls_mask;
-
-  if (ELIMINATE_COPY_RELOCS
-      && ind->root.type != bfd_link_hash_indirect
-      && dir->dynamic_adjusted)
-    {
-      /* 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.  */
-      dir->ref_dynamic |= ind->ref_dynamic;
-      dir->ref_regular |= ind->ref_regular;
-      dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
-      dir->needs_plt |= ind->needs_plt;
-    }
-  else
-    _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
-}
 
 static reloc_howto_type *ppc_elf_howto_table[R_PPC_max];
 
@@ -1597,416 +1323,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;
-
-  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;
-
-  ppc_info = ppc_elf_hash_table (link_info);
-  irelend = internal_relocs + isec->reloc_count;
-
-  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;
-      unsigned char sym_type;
-
-      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;
-	  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;
-
-	  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;
-
-	  sym_type = h->type;
-	}
-
-      /* 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;
-	}
-      else
-	toff += irel->r_addend;
-
-      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;
-	    }
-
-	  if (R_PPC_RELAX32_PLT - R_PPC_RELAX32
-	      != R_PPC_RELAX32PC_PLT - R_PPC_RELAX32PC)
-	    abort ();
-	  if (tsec == ppc_info->plt)
-	    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;
-	}
-    }
-
-  /* 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->size = (isec->size + 3) & (bfd_vma) -4;
-      /* Branch around the trampolines.  */
-      val = trampoff - isec->size + 0x48000000;
-      dest = contents + isec->size;
-      isec->size = trampoff;
-      bfd_put_32 (abfd, val, dest);
-      dest += 4;
-
-      if (link_info->shared)
-	{
-	  stub = shared_stub_entry;
-	  size = ARRAY_SIZE (shared_stub_entry);
-	}
-      else
-	{
-	  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)
@@ -2184,6 +1501,65 @@ ppc_elf_unhandled_reloc (bfd *abfd,
     }
   return bfd_reloc_dangerous;
 }
+
+/* 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;
+}
 
 /* Fix bad default arch selected for a 32 bit input bfd when the
    default is 64 bit.  */
@@ -2309,7 +1685,80 @@ ppc_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
 
   return TRUE;
 }
-
+
+/* Support for core dump NOTE sections.  */
+
+static bfd_boolean
+ppc_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
+{
+  int offset;
+  unsigned int 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);
+
+      /* pr_pid */
+      elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
+
+      /* pr_reg */
+      offset = 72;
+      size = 192;
+
+      break;
+    }
+
+  /* Make a ".reg/999" section.  */
+  return _bfd_elfcore_make_pseudosection (abfd, ".reg",
+					  size, note->descpos + offset);
+}
+
+static bfd_boolean
+ppc_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
+{
+  switch (note->descsz)
+    {
+    default:
+      return FALSE;
+
+    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);
+    }
+
+  /* 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.  */
+
+  {
+    char *command = elf_tdata (abfd)->core_command;
+    int n = strlen (command);
+
+    if (0 < n && command[n - 1] == ' ')
+      command[n - 1] = '\0';
+  }
+
+  return TRUE;
+}
+
+/* Return address for Ith PLT stub in section PLT, for relocation REL
+   or (bfd_vma) -1 if it should not be included.  */
+
+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.  */
 
@@ -2333,7 +1782,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
@@ -2349,389 +1798,487 @@ 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;
 }
+
+/* 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 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 }
+};
 
-/* Allocate a pointer to live in a linker created section.  */
+/* Very simple linked list structure for recording apuinfo values.  */
+typedef struct apuinfo_list
+{
+  struct apuinfo_list *next;
+  unsigned long value;
+}
+apuinfo_list;
 
-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)
+static apuinfo_list *head;
+
+
+static void
+apuinfo_list_init (void)
 {
-  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;
+  head = NULL;
+}
 
-  BFD_ASSERT (lsect != NULL);
+static void
+apuinfo_list_add (unsigned long value)
+{
+  apuinfo_list *entry = head;
 
-  /* Is this a global symbol?  */
-  if (h != NULL)
+  while (entry != NULL)
     {
-      struct ppc_elf_link_hash_entry *eh;
+      if (entry->value == value)
+	return;
+      entry = entry->next;
+    }
 
-      /* 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;
+  entry = bfd_malloc (sizeof (* entry));
+  if (entry == NULL)
+    return;
 
-      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;
-	}
+  entry->value = value;
+  entry->next  = head;
+  head = entry;
+}
 
-      if (lsect->rel_section)
-	lsect->rel_section->size += sizeof (Elf32_External_Rela);
-    }
-  else
+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;
 
-      /* 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;
+  if (link_info == NULL)
+    return;
 
-      ptr_linker_section_ptr = &ptr[r_symndx];
+  /* Scan the input bfds, looking for apuinfo sections.  */
+  num_input_sections = 0;
+  output_section_size = 0;
 
-      if (info->shared)
+  for (ibfd = link_info->input_bfds; ibfd; ibfd = ibfd->link_next)
+    {
+      asec = bfd_get_section_by_name (ibfd, APUINFO_SECTION_NAME);
+      if (asec)
 	{
-	  /* 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->size += sizeof (Elf32_External_Rela);
+	  ++ num_input_sections;
+	  output_section_size += asec->size;
 	}
     }
 
-  /* 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);
+  /* We need at least one input sections
+     in order to make merging worthwhile.  */
+  if (num_input_sections < 1)
+    return;
 
-  if (!linker_section_ptr)
-    return FALSE;
+  /* Just make sure that the output section exists as well.  */
+  asec = bfd_get_section_by_name (abfd, APUINFO_SECTION_NAME);
+  if (asec == NULL)
+    return;
 
-  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;
+  /* Allocate a buffer for the contents of the input sections.  */
+  buffer = bfd_malloc (output_section_size);
+  if (buffer == NULL)
+    return;
 
-  linker_section_ptr->offset = lsect->section->size;
-  lsect->section->size += 4;
+  offset = 0;
+  apuinfo_list_init ();
 
-#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
+  /* Read in the input sections contents.  */
+  for (ibfd = link_info->input_bfds; ibfd; ibfd = ibfd->link_next)
+    {
+      unsigned long datum;
+      char *ptr;
 
-  return TRUE;
-}
-
-#define bfd_put_ptr(BFD, VAL, ADDR) bfd_put_32 (BFD, VAL, ADDR)
+      asec = bfd_get_section_by_name (ibfd, APUINFO_SECTION_NAME);
+      if (asec == NULL)
+	continue;
 
-/* Fill in the address for a pointer generated in a linker section.  */
+      length = asec->size;
+      if (length < 24)
+	{
+	  error_message = _("corrupt or empty %s section in %B");
+	  goto fail;
+	}
 
-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)
-{
-  elf_linker_section_pointers_t *linker_section_ptr;
+      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;
+	}
 
-  BFD_ASSERT (lsect != NULL);
+      /* Process the contents of the section.  */
+      ptr = buffer + offset;
+      error_message = _("corrupt %s section in %B");
 
-  if (h != NULL)
-    {
-      /* Handle global symbol.  */
-      struct ppc_elf_link_hash_entry *eh;
+      /* 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;
 
-      eh = (struct ppc_elf_link_hash_entry *) h;
-      linker_section_ptr
-	= elf_find_pointer_linker_section (eh->linker_section_pointer,
-					   rel->r_addend,
-					   lsect);
+      datum = bfd_get_32 (ibfd, ptr + 8);
+      if (datum != 0x2)
+	goto fail;
 
-      BFD_ASSERT (linker_section_ptr != NULL);
+      if (strcmp (ptr + 12, APUINFO_LABEL) != 0)
+	goto fail;
 
-      if (! elf_hash_table (info)->dynamic_sections_created
-	  || (info->shared
-	      && info->symbolic
-	      && h->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.
+      /* Get the number of bytes used for apuinfo entries.  */
+      datum = bfd_get_32 (ibfd, ptr + 4);
+      if (datum + 20 != length)
+	goto fail;
 
-	     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));
-	    }
-	}
+      /* 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;
     }
-  else
-    {
-      /* 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_ASSERT (linker_section_ptr != NULL);
+  error_message = NULL;
 
-      /* 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);
+  /* Compute the size of the output section.  */
+  num_entries = apuinfo_list_length ();
+  output_section_size = 20 + num_entries * 4;
 
-	  if (info->shared)
-	    {
-	      /* We need to generate a relative reloc for the dynamic
-		 linker.  */
+  asec = bfd_get_section_by_name (abfd, APUINFO_SECTION_NAME);
 
-	      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;
+  if (! bfd_set_section_size (abfd, asec, output_section_size))
+    ibfd = abfd,
+      error_message = _("warning: unable to set size of %s section in %B");
 
-	      BFD_ASSERT (srel != NULL);
+ fail:
+  free (buffer);
 
-	      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);
-	    }
-	}
+  if (error_message)
+    (*_bfd_error_handler) (error_message, ibfd, APUINFO_SECTION_NAME);
+}
+
+/* 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;
+
+  if (apuinfo_list_length () == 0)
+    return;
+
+  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;
     }
 
-  relocation = (lsect->section->output_offset
-		+ linker_section_ptr->offset
-		- lsect->sym_offset);
+  /* 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);
 
-#ifdef DEBUG
-  fprintf (stderr,
-	   "Finish pointer in linker section %s, offset = %ld (0x%lx)\n",
-	   lsect->name, (long) relocation, (long) relocation);
-#endif
+  length = 20;
+  for (i = 0; i < num_entries; i++)
+    {
+      bfd_put_32 (abfd, apuinfo_list_element (i), buffer + length);
+      length += 4;
+    }
 
-  /* Subtract out the addend, because it will get added back in by the normal
-     processing.  */
-  return relocation - linker_section_ptr->addend;
+  if (length != asec->size)
+    (*_bfd_error_handler) (_("failed to compute new APUinfo section."));
+
+  if (! bfd_set_section_contents (abfd, asec, buffer, (file_ptr) 0, length))
+    (*_bfd_error_handler) (_("failed to install new APUinfo section."));
+
+  free (buffer);
+
+  apuinfo_list_finish ();
 }
 
-/* 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)
+/* 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.  */
+
+/* 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
 {
-  elf_linker_section_t *lsect;
-  struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
-  asection *s, *sym_sec;
-  bfd_size_type amt;
-  flagword flags;
-  const char *name;
-  const char *rel_name;
-  const char *sym_name;
-  bfd_vma sym_offset;
+  struct ppc_elf_dyn_relocs *next;
 
-  /* The linker creates these sections so it has somewhere to attach
-     their respective symbols.  Startup code (crt1.o) uses these symbols
-     to initialize a register pointing to the section.  If the output
-     sections corresponding to these input sections were empty it would
-     be OK to set the symbol to 0 (or any random number), because the
-     associated register should never be used.
-     FIXME: Setting a symbol this way is silly.  The symbols ought to 
-     be set the same way other backends set gp.  */
-  flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
-	   | SEC_LINKER_CREATED);
-  sym_offset = 32768;
+  /* The input section of the reloc.  */
+  asection *sec;
 
-  switch (which)
-    {
-    default:
-      abort ();
-      return NULL;
+  /* Total number of relocs copied for the input section.  */
+  bfd_size_type count;
 
-    case LINKER_SECTION_SDATA:	/* .sdata/.sbss section */
-      name	= ".sdata";
-      rel_name	= ".rela.sdata";
-      sym_name	= "_SDA_BASE_";
-      break;
+  /* Number of pc-relative relocs copied for the input section.  */
+  bfd_size_type pc_count;
+};
 
-    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.  */
-  sym_sec = 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;
-      if (sym_sec == NULL)
-	sym_sec = s;
-    }
-  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->size = align_power (s->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->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;
+#define ppc_elf_hash_entry(ent) ((struct ppc_elf_link_hash_entry *) (ent))
 
-#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);
+/* PPC ELF linker hash table.  */
 
-      if ((bh == NULL || bh->type == bfd_link_hash_undefined)
-	  && !(_bfd_generic_link_add_one_symbol
-	       (info, abfd, sym_name, BSF_GLOBAL, sym_sec, sym_offset, NULL,
-		FALSE, get_elf_backend_data (abfd)->collect, &bh)))
-	return NULL;
-      h = (struct elf_link_hash_entry *) bh;
+struct ppc_elf_link_hash_table
+{
+  struct elf_link_hash_table elf;
 
-      h->type = STT_OBJECT;
-      lsect->sym_hash = h;
+  /* 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;
 
-      if (info->shared
-	  && ! bfd_elf_link_record_dynamic_symbol (info, h))
-	return NULL;
+  /* 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;
     }
 
-  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 .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)
+/* 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 = 0;
+  struct ppc_elf_link_hash_table *ret;
 
-  s = bfd_get_section_by_name (abfd, ".sbss2");
-  if (s != NULL && (s->flags & SEC_ALLOC) != 0)
-    ++ret;
+  ret = bfd_zmalloc (sizeof (struct ppc_elf_link_hash_table));
+  if (ret == NULL)
+    return NULL;
 
-  s = bfd_get_section_by_name (abfd, ".PPC.EMB.sbss0");
-  if (s != NULL && (s->flags & SEC_ALLOC) != 0)
-    ++ret;
+  if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd,
+				       ppc_elf_link_hash_newfunc))
+    {
+      free (ret);
+      return NULL;
+    }
 
-  return ret;
+  return &ret->elf.root;
 }
-
+
 /* The powerpc .got has a blrl instruction in it.  Mark it executable.  */
 
 static bfd_boolean
@@ -2814,687 +2361,359 @@ ppc_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
   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 (const struct elf_backend_data *bed,
+			      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->needs_plt
-		  || h->u.weakdef != NULL
-		  || (h->def_dynamic
-		      && h->ref_regular
-		      && !h->def_regular)));
+  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->needs_plt)
+  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:
+	  struct ppc_elf_dyn_relocs **pp;
+	  struct ppc_elf_dyn_relocs *p;
 
-	     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.
+	  if (ind->root.type == bfd_link_hash_indirect)
+	    abort ();
 
-	     2. GC has rendered the entry unused.
+	  /* 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;
 
-	     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->needs_plt = 0;
+	      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->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;
+      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.  */
-
-  /* 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;
+  edir->tls_mask |= eind->tls_mask;
 
-  if (ELIMINATE_COPY_RELOCS)
+  if (ELIMINATE_COPY_RELOCS
+      && ind->root.type != bfd_link_hash_indirect
+      && dir->dynamic_adjusted)
     {
-      struct ppc_elf_dyn_relocs *p;
-      for (p = ppc_elf_hash_entry (h)->dyn_relocs; p != NULL; p = p->next)
-	{
-	  s = p->sec->output_section;
-	  if (s != NULL && (s->flags & SEC_READONLY) != 0)
-	    break;
-	}
-
-      /* If we didn't find any dynamic relocs in read-only sections, then
-	 we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
-      if (p == NULL)
-	{
-	  h->non_got_ref = 0;
-	  return TRUE;
-	}
+      /* If called to transfer flags for a weakdef during processing
+	 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
+	 We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
+      dir->ref_dynamic |= ind->ref_dynamic;
+      dir->ref_regular |= ind->ref_regular;
+      dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
+      dir->needs_plt |= ind->needs_plt;
     }
-
-  /* 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 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);
+    _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
+}
 
-  /* 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)
+/* 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.  */
+
+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)
+      && (info->hash->creator == abfd->xvec
+	  || info->hash->creator == abfd->xvec->alternative_target))
     {
-      asection *srel;
+      /* Common symbols less than or equal to -G nn bytes are automatically
+	 put into .sbss.  */
+      struct ppc_elf_link_hash_table *htab;
 
-      if (h->size <= elf_gp_size (htab->elf.dynobj))
-	srel = htab->relsbss;
-      else
-	srel = htab->relbss;
-      BFD_ASSERT (srel != NULL);
-      srel->size += sizeof (Elf32_External_Rela);
-      h->needs_copy = 1;
-    }
+      htab = ppc_elf_hash_table (info);
+      if (htab->sbss == NULL)
+	{
+	  flagword flags = SEC_IS_COMMON;
 
-  /* 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;
+	  htab->sbss = bfd_make_section_anyway (abfd, ".sbss");
+	  if (htab->sbss == NULL
+	      || ! bfd_set_section_flags (abfd, htab->sbss, flags))
+	    return FALSE;
+	}
 
-  /* 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;
+      *secp = htab->sbss;
+      *valp = sym->st_size;
     }
 
-  /* 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;
 }
 
-/* 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.  */
-
-static bfd_boolean
-allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
+/* Enumeration to specify the special section.  */
+enum elf_linker_section_enum
 {
-  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;
+  LINKER_SECTION_SDATA,
+  LINKER_SECTION_SDATA2
+};
 
-  if (h->root.type == bfd_link_hash_indirect)
-    return TRUE;
+/* 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)
+{
+  elf_linker_section_t *lsect;
+  struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
+  asection *s, *sym_sec;
+  bfd_size_type amt;
+  flagword flags;
+  const char *name;
+  const char *rel_name;
+  const char *sym_name;
+  bfd_vma sym_offset;
 
-  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;
+  /* The linker creates these sections so it has somewhere to attach
+     their respective symbols.  Startup code (crt1.o) uses these symbols
+     to initialize a register pointing to the section.  If the output
+     sections corresponding to these input sections were empty it would
+     be OK to set the symbol to 0 (or any random number), because the
+     associated register should never be used.
+     FIXME: Setting a symbol this way is silly.  The symbols ought to 
+     be set the same way other backends set gp.  */
+  flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
+	   | SEC_LINKER_CREATED);
+  sym_offset = 32768;
 
-  htab = ppc_elf_hash_table (info);
-  if (htab->elf.dynamic_sections_created
-      && h->plt.refcount > 0)
+  switch (which)
     {
-      /* 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;
+    default:
+      abort ();
+      return NULL;
 
-	  /* If this is the first .plt entry, make room for the special
-	     first entry.  */
-	  if (s->size == 0)
-	    s->size += PLT_INITIAL_ENTRY_SIZE;
+    case LINKER_SECTION_SDATA:	/* .sdata/.sbss section */
+      name	= ".sdata";
+      rel_name	= ".rela.sdata";
+      sym_name	= "_SDA_BASE_";
+      break;
 
-	  /* 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->size - PLT_INITIAL_ENTRY_SIZE)
-				 / PLT_ENTRY_SIZE)));
+    case LINKER_SECTION_SDATA2:	/* .sdata2/.sbss2 section */
+      name	= ".sdata2";
+      rel_name	= ".rela.sdata2";
+      sym_name	= "_SDA2_BASE_";
+      flags    |= SEC_READONLY;
+      break;
+    }
 
-	  /* 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 = h->plt.offset;
-	    }
+  /* Record the first bfd that needs the special sections.  */
+  if (!htab->elf.dynobj)
+    htab->elf.dynobj = abfd;
 
-	  /* Make room for this entry.  After the 8192nd entry, room
-	     for two entries is allocated.  */
-	  s->size += PLT_ENTRY_SIZE;
-	  if ((s->size - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE
-	      > PLT_NUM_SINGLE_ENTRIES)
-	    s->size += PLT_ENTRY_SIZE;
+  amt = sizeof (elf_linker_section_t);
+  lsect = bfd_zalloc (htab->elf.dynobj, amt);
 
-	  /* We also need to make an entry in the .rela.plt section.  */
-	  htab->relplt->size += sizeof (Elf32_External_Rela);
-	}
-      else
-	{
-	  h->plt.offset = (bfd_vma) -1;
-	  h->needs_plt = 0;
-	}
-    }
-  else
-    {
-      h->plt.offset = (bfd_vma) -1;
-      h->needs_plt = 0;
-    }
+  lsect->sym_offset = sym_offset;
 
-  eh = (struct ppc_elf_link_hash_entry *) h;
-  if (eh->elf.got.refcount > 0)
+  /* See if the sections already exist.  */
+  sym_sec = s = bfd_get_section_by_name (htab->elf.dynobj, name);
+  if (s == NULL || (s->flags & flags) != flags)
     {
-      /* 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;
-	  eh->elf.got.offset = htab->got->size;
-	  if ((eh->tls_mask & TLS_TLS) != 0)
-	    {
-	      if ((eh->tls_mask & TLS_LD) != 0)
-		htab->got->size += 8;
-	      if ((eh->tls_mask & TLS_GD) != 0)
-		htab->got->size += 8;
-	      if ((eh->tls_mask & (TLS_TPREL | TLS_TPRELGD)) != 0)
-		htab->got->size += 4;
-	      if ((eh->tls_mask & TLS_DTPREL) != 0)
-		htab->got->size += 4;
-	    }
-	  else
-	    htab->got->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->size
-		+= ((htab->got->size - eh->elf.got.offset) / 4
-		    * sizeof (Elf32_External_Rela));
-	      /* Except LD only needs one.  */
-	      if ((eh->tls_mask & TLS_LD) != 0)
-		htab->relgot->size -= sizeof (Elf32_External_Rela);
-	    }
-	}
+      s = bfd_make_section_anyway (htab->elf.dynobj, name);
+      if (s == NULL
+	  || !bfd_set_section_flags (htab->elf.dynobj, s, flags))
+	return NULL;
+      if (sym_sec == NULL)
+	sym_sec = s;
     }
-  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.  */
+  lsect->section = s;
 
-  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;
+  if (bfd_get_section_alignment (htab->elf.dynobj, s) < 2
+      && !bfd_set_section_alignment (htab->elf.dynobj, s, 2))
+    return NULL;
 
-	  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;
-	    }
-	}
+  s->size = align_power (s->size, 2);
 
-      /* 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;
+#ifdef DEBUG
+  fprintf (stderr, "Creating section %s, current size = %ld\n",
+	   name, (long) s->size);
+#endif
 
-      /* 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->forced_local)
-	{
-	  if (! bfd_elf_link_record_dynamic_symbol (info, h))
-	    return FALSE;
-	}
-    }
-  else if (ELIMINATE_COPY_RELOCS)
+  if (sym_name)
     {
-      /* For the non-shared case, discard space for relocs against
-	 symbols which turn out to need copy relocs or are not
-	 dynamic.  */
+      struct elf_link_hash_entry *h;
+      struct bfd_link_hash_entry *bh;
 
-      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;
-	    }
+#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 that succeeded, we know we'll be keeping all the
-	     relocs.  */
-	  if (h->dynindx != -1)
-	    goto keep;
-	}
+      if ((bh == NULL || bh->type == bfd_link_hash_undefined)
+	  && !(_bfd_generic_link_add_one_symbol
+	       (info, abfd, sym_name, BSF_GLOBAL, sym_sec, sym_offset, NULL,
+		FALSE, get_elf_backend_data (abfd)->collect, &bh)))
+	return NULL;
+      h = (struct elf_link_hash_entry *) bh;
 
-      eh->dyn_relocs = NULL;
+      h->type = STT_OBJECT;
+      lsect->sym_hash = h;
 
-    keep: ;
+      if (info->shared
+	  && ! bfd_elf_link_record_dynamic_symbol (info, h))
+	return NULL;
     }
 
-  /* Finally, allocate space.  */
-  for (p = eh->dyn_relocs; p != NULL; p = p->next)
+  if (info->shared)
     {
-      asection *sreloc = elf_section_data (p->sec)->sreloc;
-      sreloc->size += p->count * sizeof (Elf32_External_Rela);
+      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;
     }
 
-  return TRUE;
+  return lsect;
 }
 
-/* Find any dynamic relocs that apply to read-only sections.  */
+/* Find a linker generated pointer with a given addend and type.  */
 
-static bfd_boolean
-readonly_dynrelocs (struct elf_link_hash_entry *h, void *info)
+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)
 {
-  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;
+  for ( ; linker_pointers != NULL; linker_pointers = linker_pointers->next)
+    if (lsect == linker_pointers->lsect && addend == linker_pointers->addend)
+      return linker_pointers;
 
-	  /* Not an error, just cut short the traversal.  */
-	  return FALSE;
-	}
-    }
-  return TRUE;
+  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,
+				   struct bfd_link_info *info,
+				   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)
+      struct ppc_elf_link_hash_entry *eh;
+
+      /* 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;
+      /* Make sure this symbol is output as a dynamic symbol.  */
+      if (h->dynindx == -1)
 	{
-	  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;
+	  if (! bfd_elf_link_record_dynamic_symbol (info, h))
+	    return FALSE;
 	}
-    }
 
-  if (htab->tlsld_got.refcount > 0)
-    {
-      htab->tlsld_got.offset = htab->got->size;
-      htab->got->size += 8;
-      if (info->shared)
-	htab->relgot->size += sizeof (Elf32_External_Rela);
+      if (lsect->rel_section)
+	lsect->rel_section->size += sizeof (Elf32_External_Rela);
     }
   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->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->size;
-		    s->size += 8;
-		    if (info->shared)
-		      srel->size += sizeof (Elf32_External_Rela);
-		  }
-		*local_got = (bfd_vma) -1;
-	      }
-	    else
-	      {
-		*local_got = s->size;
-		if ((*lgot_masks & TLS_TLS) != 0)
-		  {
-		    if ((*lgot_masks & TLS_GD) != 0)
-		      s->size += 8;
-		    if ((*lgot_masks & (TLS_TPREL | TLS_TPRELGD)) != 0)
-		      s->size += 4;
-		    if ((*lgot_masks & TLS_DTPREL) != 0)
-		      s->size += 4;
-		  }
-		else
-		  s->size += 4;
-		if (info->shared)
-		  srel->size += ((s->size - *local_got) / 4
-				 * sizeof (Elf32_External_Rela));
-	      }
-	  }
-	else
-	  *local_got = (bfd_vma) -1;
-    }
+	  unsigned int num_symbols = elf_tdata (abfd)->symtab_hdr.sh_info;
 
-  /* Allocate space for global sym dynamic relocs.  */
-  elf_link_hash_traverse (elf_hash_table (info), allocate_dynrelocs, info);
+	  amt = num_symbols;
+	  amt *= sizeof (elf_linker_section_pointers_t *);
+	  ptr = bfd_zalloc (abfd, amt);
 
-  /* 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;
+	  if (!ptr)
+	    return FALSE;
 
-      if (s == htab->plt
-	  || s == htab->got)
-	{
-	  /* Strip this section if we don't need it; see the
-	     comment below.  */
-	}
-      else if ((htab->sdata != NULL && s == htab->sdata->section)
-	       || (htab->sdata2 != NULL && s == htab->sdata2->section))
-	{
-	  if (s->size == 0)
-	    /* Don't strip these sections.  We need them because they
-	       define _SDA_BASE_ and _SDA2_BASE_.  crt1.o makes a
-	       reference to _SDA_BASE_ to set up r13.  */
-	    continue;
+	  elf_local_ptr_offsets (abfd) = ptr;
 	}
-      else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
-	{
-	  if (s->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;
 
-	      /* 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;
-	}
+      /* 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;
 
-      if (s->size == 0)
+      ptr_linker_section_ptr = &ptr[r_symndx];
+
+      if (info->shared)
 	{
-	  _bfd_strip_section_from_output (info, s);
-	  continue;
+	  /* 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->size += sizeof (Elf32_External_Rela);
 	}
-
-      /* Allocate memory for the section contents.  */
-      s->contents = bfd_zalloc (htab->elf.dynobj, s->size);
-      if (s->contents == NULL)
-	return FALSE;
     }
 
-  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->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;
+  linker_section_ptr->written_address_p = FALSE;
+  *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,
@@ -3978,7 +3197,7 @@ ppc_elf_check_relocs (bfd *abfd,
 
   return TRUE;
 }
-
+
 /* Return the section that should be marked against GC for a given
    relocation.  */
 
@@ -4145,7 +3364,7 @@ ppc_elf_gc_sweep_hook (bfd *abfd,
     }
   return TRUE;
 }
-
+
 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
 
 asection *
@@ -4353,229 +3572,1204 @@ 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.  */
+      if (h->plt.refcount <= 0
+	  || 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.offset = (bfd_vma) -1;
+	  h->needs_plt = 0;
+	}
+      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->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 (ELIMINATE_COPY_RELOCS)
+    {
+      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 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->non_got_ref = 0;
+	  return TRUE;
 	}
+    }
 
-      *secp = htab->sbss;
-      *valp = sym->st_size;
+  /* 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 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);
+
+  /* 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 (h->size <= elf_gp_size (htab->elf.dynobj))
+	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.  */
+/* Allocate space in associated reloc sections for dynamic relocs.  */
 
 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)
+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;
 
-#ifdef DEBUG
-  fprintf (stderr, "ppc_elf_finish_dynamic_symbol called for %s",
-	   h->root.root.string);
-#endif
+  if (h->root.type == bfd_link_hash_indirect)
+    return TRUE;
 
-  htab = ppc_elf_hash_table (info);
-  BFD_ASSERT (htab->elf.dynobj != NULL);
+  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;
 
-  if (h->plt.offset != (bfd_vma) -1)
+  htab = ppc_elf_hash_table (info);
+  if (htab->elf.dynamic_sections_created
+      && h->plt.refcount > 0)
     {
-      Elf_Internal_Rela rela;
-      bfd_byte *loc;
-      bfd_vma reloc_index;
+      /* 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;
+	}
 
-#ifdef DEBUG
-      fprintf (stderr, ", plt_offset = %d", h->plt.offset);
-#endif
+      if (info->shared
+	  || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
+	{
+	  asection *s = htab->plt;
 
-      /* This symbol has an entry in the procedure linkage table.  Set
-	 it up.  */
+	  /* If this is the first .plt entry, make room for the special
+	     first entry.  */
+	  if (s->size == 0)
+	    s->size += PLT_INITIAL_ENTRY_SIZE;
 
-      BFD_ASSERT (h->dynindx != -1);
-      BFD_ASSERT (htab->plt != NULL && htab->relplt != NULL);
+	  /* 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->size - PLT_INITIAL_ENTRY_SIZE)
+				 / PLT_ENTRY_SIZE)));
 
-      /* We don't need to fill in the .plt.  The ppc dynamic linker
-	 will fill it in.  */
+	  /* 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 = h->plt.offset;
+	    }
 
-      /* 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;
+	  /* Make room for this entry.  After the 8192nd entry, room
+	     for two entries is allocated.  */
+	  s->size += PLT_ENTRY_SIZE;
+	  if ((s->size - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE
+	      > PLT_NUM_SINGLE_ENTRIES)
+	    s->size += PLT_ENTRY_SIZE;
 
-      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);
+	  /* We also need to make an entry in the .rela.plt section.  */
+	  htab->relplt->size += sizeof (Elf32_External_Rela);
+	}
+      else
+	{
+	  h->plt.offset = (bfd_vma) -1;
+	  h->needs_plt = 0;
+	}
+    }
+  else
+    {
+      h->plt.offset = (bfd_vma) -1;
+      h->needs_plt = 0;
+    }
 
-      if (!h->def_regular)
+  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)
 	{
-	  /* 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;
+	  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;
+	  eh->elf.got.offset = htab->got->size;
+	  if ((eh->tls_mask & TLS_TLS) != 0)
+	    {
+	      if ((eh->tls_mask & TLS_LD) != 0)
+		htab->got->size += 8;
+	      if ((eh->tls_mask & TLS_GD) != 0)
+		htab->got->size += 8;
+	      if ((eh->tls_mask & (TLS_TPREL | TLS_TPRELGD)) != 0)
+		htab->got->size += 4;
+	      if ((eh->tls_mask & TLS_DTPREL) != 0)
+		htab->got->size += 4;
+	    }
+	  else
+	    htab->got->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->size
+		+= ((htab->got->size - eh->elf.got.offset) / 4
+		    * sizeof (Elf32_External_Rela));
+	      /* Except LD only needs one.  */
+	      if ((eh->tls_mask & TLS_LD) != 0)
+		htab->relgot->size -= sizeof (Elf32_External_Rela);
+	    }
 	}
     }
+  else
+    eh->elf.got.offset = (bfd_vma) -1;
 
-  if (h->needs_copy)
+  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)
     {
-      asection *s;
-      Elf_Internal_Rela rela;
-      bfd_byte *loc;
+      /* 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;
 
-      /* This symbols needs a copy reloc.  Set it up.  */
+	  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;
+	    }
+	}
 
-#ifdef DEBUG
-      fprintf (stderr, ", copy");
-#endif
+      /* 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;
 
-      BFD_ASSERT (h->dynindx != -1);
+      /* 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->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->size <= elf_gp_size (htab->elf.dynobj))
-	s = htab->relsbss;
-      else
-	s = htab->relbss;
-      BFD_ASSERT (s != NULL);
+      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;
+	    }
 
-      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 that succeeded, we know we'll be keeping all the
+	     relocs.  */
+	  if (h->dynindx != -1)
+	    goto keep;
+	}
+
+      eh->dyn_relocs = NULL;
+
+    keep: ;
     }
 
-#ifdef DEBUG
-  fprintf (stderr, "\n");
-#endif
+  /* 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);
+    }
 
-  /* 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;
+  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;
 }
-
-/* Finish up the dynamic sections.  */
+
+/* Set the sizes of the dynamic sections.  */
 
 static bfd_boolean
-ppc_elf_finish_dynamic_sections (bfd *output_bfd,
-				 struct bfd_link_info *info)
+ppc_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
+			       struct bfd_link_info *info)
 {
-  asection *sdyn;
   struct ppc_elf_link_hash_table *htab;
+  asection *s;
+  bfd_boolean relocs;
+  bfd *ibfd;
 
 #ifdef DEBUG
-  fprintf (stderr, "ppc_elf_finish_dynamic_sections called\n");
+  fprintf (stderr, "ppc_elf_size_dynamic_sections called\n");
 #endif
 
   htab = ppc_elf_hash_table (info);
-  sdyn = bfd_get_section_by_name (htab->elf.dynobj, ".dynamic");
+  BFD_ASSERT (htab->elf.dynobj != NULL);
+
+  if (elf_hash_table (info)->dynamic_sections_created)
+    {
+      /* 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;
+	}
+    }
+
+  if (htab->tlsld_got.refcount > 0)
+    {
+      htab->tlsld_got.offset = htab->got->size;
+      htab->got->size += 8;
+      if (info->shared)
+	htab->relgot->size += sizeof (Elf32_External_Rela);
+    }
+  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;
+
+      for (s = ibfd->sections; s != NULL; s = s->next)
+	{
+	  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->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->size;
+		    s->size += 8;
+		    if (info->shared)
+		      srel->size += sizeof (Elf32_External_Rela);
+		  }
+		*local_got = (bfd_vma) -1;
+	      }
+	    else
+	      {
+		*local_got = s->size;
+		if ((*lgot_masks & TLS_TLS) != 0)
+		  {
+		    if ((*lgot_masks & TLS_GD) != 0)
+		      s->size += 8;
+		    if ((*lgot_masks & (TLS_TPREL | TLS_TPRELGD)) != 0)
+		      s->size += 4;
+		    if ((*lgot_masks & TLS_DTPREL) != 0)
+		      s->size += 4;
+		  }
+		else
+		  s->size += 4;
+		if (info->shared)
+		  srel->size += ((s->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);
+
+  /* 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;
+
+      if (s == htab->plt
+	  || s == htab->got)
+	{
+	  /* Strip this section if we don't need it; see the
+	     comment below.  */
+	}
+      else if ((htab->sdata != NULL && s == htab->sdata->section)
+	       || (htab->sdata2 != NULL && s == htab->sdata2->section))
+	{
+	  if (s->size == 0)
+	    /* Don't strip these sections.  We need them because they
+	       define _SDA_BASE_ and _SDA2_BASE_.  crt1.o makes a
+	       reference to _SDA_BASE_ to set up r13.  */
+	    continue;
+	}
+      else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
+	{
+	  if (s->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;
+
+	      /* 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;
+	}
+
+      if (s->size == 0)
+	{
+	  _bfd_strip_section_from_output (info, s);
+	  continue;
+	}
+
+      /* Allocate memory for the section contents.  */
+      s->contents = bfd_zalloc (htab->elf.dynobj, s->size);
+      if (s->contents == NULL)
+	return FALSE;
+    }
 
   if (htab->elf.dynamic_sections_created)
     {
-      Elf32_External_Dyn *dyncon, *dynconend;
+      /* 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)
 
-      BFD_ASSERT (htab->plt != NULL && sdyn != NULL);
+      if (info->executable)
+	{
+	  if (!add_dynamic_entry (DT_DEBUG, 0))
+	    return FALSE;
+	}
 
-      dyncon = (Elf32_External_Dyn *) sdyn->contents;
-      dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
-      for (; dyncon < dynconend; dyncon++)
+      if (htab->plt != NULL && htab->plt->size != 0)
 	{
-	  Elf_Internal_Dyn dyn;
-	  asection *s;
+	  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;
+	}
 
-	  bfd_elf32_swap_dyn_in (htab->elf.dynobj, dyncon, &dyn);
+      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;
+	}
 
-	  switch (dyn.d_tag)
+      /* 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;
+}
+
+#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;
+
+  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;
+
+  ppc_info = ppc_elf_hash_table (link_info);
+  irelend = internal_relocs + isec->reloc_count;
+
+  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;
+      unsigned char sym_type;
+
+      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)
 	    {
-	    case DT_PLTGOT:
-	      s = htab->plt;
-	      dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
-	      break;
+	      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);
 
-	    case DT_PLTRELSZ:
-	      dyn.d_un.d_val = htab->relplt->size;
-	      break;
+	  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;
 
-	    case DT_JMPREL:
-	      s = htab->relplt;
-	      dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
-	      break;
+	  indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
+	  h = elf_sym_hashes (abfd)[indx];
 
-	    default:
-	      continue;
+	  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;
 
-	  bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
+	  sym_type = h->type;
+	}
+
+      /* 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;
+	}
+      else
+	toff += irel->r_addend;
+
+      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;
+	    }
+
+	  if (R_PPC_RELAX32_PLT - R_PPC_RELAX32
+	      != R_PPC_RELAX32PC_PLT - R_PPC_RELAX32PC)
+	    abort ();
+	  if (tsec == ppc_info->plt)
+	    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;
 
-      if (sdyn == NULL)
-	bfd_put_32 (output_bfd, 0, contents + 4);
+      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 (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;
 }
 
+#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.  */
+
+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)
+{
+  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;
+      linker_section_ptr
+	= elf_find_pointer_linker_section (eh->linker_section_pointer,
+					   rel->r_addend,
+					   lsect);
+
+      BFD_ASSERT (linker_section_ptr != NULL);
+
+      if (! elf_hash_table (info)->dynamic_sections_created
+	  || (info->shared
+	      && info->symbolic
+	      && h->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));
+	    }
+	}
+    }
+  else
+    {
+      /* 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_ASSERT (linker_section_ptr != NULL);
+
+      /* 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 (info->shared)
+	    {
+	      /* We need to generate a relative reloc for the dynamic
+		 linker.  */
+
+	      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;
+
+	      BFD_ASSERT (srel != NULL);
+
+	      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);
+	    }
+	}
+    }
+
+  relocation = (lsect->section->output_offset
+		+ linker_section_ptr->offset
+		- lsect->sym_offset);
+
+#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.
 
@@ -5769,398 +5963,207 @@ 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.  */
+/* 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 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);
-
-      /* pr_pid */
-      elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
-
-      /* pr_reg */
-      offset = 72;
-      size = 192;
+  struct ppc_elf_link_hash_table *htab;
 
-      break;
-    }
+#ifdef DEBUG
+  fprintf (stderr, "ppc_elf_finish_dynamic_symbol called for %s",
+	   h->root.root.string);
+#endif
 
-  /* Make a ".reg/999" section.  */
-  return _bfd_elfcore_make_pseudosection (abfd, ".reg",
-					  size, note->descpos + offset);
-}
+  htab = ppc_elf_hash_table (info);
+  BFD_ASSERT (htab->elf.dynobj != NULL);
 
-static bfd_boolean
-ppc_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
-{
-  switch (note->descsz)
+  if (h->plt.offset != (bfd_vma) -1)
     {
-    default:
-      return FALSE;
-
-    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);
-    }
-
-  /* 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.  */
+      Elf_Internal_Rela rela;
+      bfd_byte *loc;
+      bfd_vma reloc_index;
 
-  {
-    char *command = elf_tdata (abfd)->core_command;
-    int n = strlen (command);
+#ifdef DEBUG
+      fprintf (stderr, ", plt_offset = %d", h->plt.offset);
+#endif
 
-    if (0 < n && command[n - 1] == ' ')
-      command[n - 1] = '\0';
-  }
+      /* This symbol has an entry in the procedure linkage table.  Set
+	 it up.  */
 
-  return TRUE;
-}
-
-/* Very simple linked list structure for recording apuinfo values.  */
-typedef struct apuinfo_list
-{
-  struct apuinfo_list *next;
-  unsigned long value;
-}
-apuinfo_list;
+      BFD_ASSERT (h->dynindx != -1);
+      BFD_ASSERT (htab->plt != NULL && htab->relplt != NULL);
 
-static apuinfo_list *head;
+      /* We don't need to fill in the .plt.  The ppc dynamic linker
+	 will fill it in.  */
 
+      /* 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;
 
-static void
-apuinfo_list_init (void)
-{
-  head = NULL;
-}
+      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);
 
-static void
-apuinfo_list_add (unsigned long value)
-{
-  apuinfo_list *entry = head;
+      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;
+	}
+    }
 
-  while (entry != NULL)
+  if (h->needs_copy)
     {
-      if (entry->value == value)
-	return;
-      entry = entry->next;
-    }
+      asection *s;
+      Elf_Internal_Rela rela;
+      bfd_byte *loc;
 
-  entry = bfd_malloc (sizeof (* entry));
-  if (entry == NULL)
-    return;
+      /* This symbols needs a copy reloc.  Set it up.  */
 
-  entry->value = value;
-  entry->next  = head;
-  head = entry;
-}
+#ifdef DEBUG
+      fprintf (stderr, ", copy");
+#endif
 
-static unsigned
-apuinfo_list_length (void)
-{
-  apuinfo_list *entry;
-  unsigned long count;
+      BFD_ASSERT (h->dynindx != -1);
 
-  for (entry = head, count = 0;
-       entry;
-       entry = entry->next)
-    ++ count;
+      if (h->size <= elf_gp_size (htab->elf.dynobj))
+	s = htab->relsbss;
+      else
+	s = htab->relbss;
+      BFD_ASSERT (s != NULL);
 
-  return count;
-}
+      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);
+    }
 
-static inline unsigned long
-apuinfo_list_element (unsigned long number)
-{
-  apuinfo_list * entry;
+#ifdef DEBUG
+  fprintf (stderr, "\n");
+#endif
 
-  for (entry = head;
-       entry && number --;
-       entry = entry->next)
-    ;
+  /* 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;
 
-  return entry ? entry->value : 0;
+  return TRUE;
 }
-
-static void
-apuinfo_list_finish (void)
+
+static enum elf_reloc_type_class
+ppc_elf_reloc_type_class (const Elf_Internal_Rela *rela)
 {
-  apuinfo_list *entry;
-
-  for (entry = head; entry;)
+  switch (ELF32_R_TYPE (rela->r_info))
     {
-      apuinfo_list *next = entry->next;
-      free (entry);
-      entry = next;
+    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;
     }
-
-  head = NULL;
 }
+
+/* Finish up the dynamic sections.  */
 
-#define APUINFO_SECTION_NAME	".PPC.EMB.apuinfo"
-#define APUINFO_LABEL		"APUinfo"
-
-/* Scan the input BFDs and create a linked list of
-   the APUinfo values that will need to be emitted.  */
-
-static void
-ppc_elf_begin_write_processing (bfd *abfd, struct bfd_link_info *link_info)
+static bfd_boolean
+ppc_elf_finish_dynamic_sections (bfd *output_bfd,
+				 struct bfd_link_info *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;
-	}
-    }
-
-  /* We need at least one input sections
-     in order to make merging worthwhile.  */
-  if (num_input_sections < 1)
-    return;
-
-  /* Just make sure that the output section exists as well.  */
-  asec = bfd_get_section_by_name (abfd, APUINFO_SECTION_NAME);
-  if (asec == NULL)
-    return;
+  asection *sdyn;
+  struct ppc_elf_link_hash_table *htab;
 
-  /* Allocate a buffer for the contents of the input sections.  */
-  buffer = bfd_malloc (output_section_size);
-  if (buffer == NULL)
-    return;
+#ifdef DEBUG
+  fprintf (stderr, "ppc_elf_finish_dynamic_sections called\n");
+#endif
 
-  offset = 0;
-  apuinfo_list_init ();
+  htab = ppc_elf_hash_table (info);
+  sdyn = bfd_get_section_by_name (htab->elf.dynobj, ".dynamic");
 
-  /* 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->size;
-      if (length < 24)
-	{
-	  error_message = _("corrupt or empty %s section in %B");
-	  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 %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;
+	  Elf_Internal_Dyn dyn;
+	  asection *s;
 
-      datum = bfd_get_32 (ibfd, ptr + 8);
-      if (datum != 0x2)
-	goto fail;
+	  bfd_elf32_swap_dyn_in (htab->elf.dynobj, dyncon, &dyn);
 
-      if (strcmp (ptr + 12, APUINFO_LABEL) != 0)
-	goto fail;
+	  switch (dyn.d_tag)
+	    {
+	    case DT_PLTGOT:
+	      s = htab->plt;
+	      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_PLTRELSZ:
+	      dyn.d_un.d_val = htab->relplt->size;
+	      break;
 
-      /* Make sure that we do not run off the end of the section.  */
-      if (offset + length > output_section_size)
-	goto fail;
+	    case DT_JMPREL:
+	      s = htab->relplt;
+	      dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
+	      break;
 
-      /* 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 %B");
-
- fail:
-  free (buffer);
-
-  if (error_message)
-    (*_bfd_error_handler) (error_message, ibfd, APUINFO_SECTION_NAME);
-}
-
-
-/* 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;
-
-  if (apuinfo_list_length () == 0)
-    return;
-
-  length = asec->size;
-  if (length < 20)
-    return;
-
-  buffer = bfd_malloc (length);
-  if (buffer == NULL)
+  /* 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)
     {
-      (*_bfd_error_handler)
-	(_("failed to allocate space for new APUinfo section."));
-      return;
-    }
+      unsigned char *contents = htab->got->contents;
+      bfd_put_32 (output_bfd, 0x4e800021 /* blrl */, contents);
 
-  /* 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);
+      if (sdyn == NULL)
+	bfd_put_32 (output_bfd, 0, contents + 4);
+      else
+	bfd_put_32 (output_bfd,
+		    sdyn->output_section->vma + sdyn->output_offset,
+		    contents + 4);
 
-  length = 20;
-  for (i = 0; i < num_entries; i++)
-    {
-      bfd_put_32 (abfd, apuinfo_list_element (i), buffer + length);
-      length += 4;
+      elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 4;
     }
 
-  if (length != asec->size)
-    (*_bfd_error_handler) (_("failed to compute new APUinfo section."));
-
-  if (! bfd_set_section_contents (abfd, asec, buffer, (file_ptr) 0, length))
-    (*_bfd_error_handler) (_("failed to install new APUinfo section."));
-
-  free (buffer);
-
-  apuinfo_list_finish ();
-}
-
-/* Return address for Ith PLT stub in section PLT, for relocation REL
-   or (bfd_vma) -1 if it should not be included.  */
-
-static bfd_vma
-ppc_elf_plt_sym_val (bfd_vma i ATTRIBUTE_UNUSED,
-		     const asection *plt ATTRIBUTE_UNUSED,
-		     const arelent *rel)
-{
-  return rel->address;
+  return TRUE;
 }
-
-/* 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 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 }
-};
 
 #define TARGET_LITTLE_SYM	bfd_elf32_powerpcle_vec
 #define TARGET_LITTLE_NAME	"elf32-powerpcle"