* elf32-i386.c (elf_i386_discard_copies): Rename to

	discard_copies, and use elf_link_hash_entry arg rather than
	elf_i386_link_hash_entry.
	(elf_i386_link_hash_traverse): Delete.
	(elf_i386_size_dynamic_sections): Adjust call to discard_copies.
	Tidy sizing of dynamic sections.
	(elf_i386_check_relocs <R_386_32, R_386_PC32>): Reference count
	possible .plt entries.
	(elf_i386_gc_sweep_hook): Likewise.
	(elf_i386_adjust_dynamic_symbol): Discard .plt entries for
	everything with plt.refcount <= 0.

	* elf32-i386.c (elf_i386_check_relocs): Don't allocate .got and
	.relgot space here.
	(elf_i386_gc_sweep_hook): ..and no need to deallocate here..
	(elf32_hppa_adjust_dynamic_symbol): ..and don't allocate .plt and
	.rel.plt here..
	(allocate_plt_and_got): ..instead do it all here.  New function.
	(elf_i386_size_dynamic_sections): Allocate local .got space and
	call allocate_plt_and_got.  No need to zap .relgot if not dynamic.
	(bfd_elf32_bfd_final_link): Delete.  (ie. use regular final link
	rather than gc variety).
	(WILL_CALL_FINISH_DYNAMIC_SYMBOL): Define.
	(elf_i386_relocate_section): Use it here and correct handling of
	R_386_GOT32.  Provide section and offset for "unresolvable
	relocation" error message.
	(elf_i386_finish_dynamic_symbol): Correct handling of R_386_GOT32.

	* elf32-i386.c (struct elf_i386_link_hash_table): Add sgot,
	sgotplt, srelgot, splt, srelplt, sdynbss, srelbss fields.
	(elf_i386_link_hash_table_create): Init them.
	(create_got_section): New function.
	(elf_i386_create_dynamic_sections): New function.
	(elf_backend_create_dynamic_sections): Set to above.
	(elf_i386_check_relocs): Use shortcuts from hash table rather than
	calling bfd_get_section_by_name.
	(elf_i386_gc_sweep_hook): Likewise.
	(elf_i386_adjust_dynamic_symbol): Likewise.
	(elf_i386_size_dynamic_sections): Likewise.
	(elf_i386_relocate_section): Likewise.
	(elf_i386_finish_dynamic_sections): Likewise.

2 files changed, 470 insertions, 345 deletions

diff --git a/bfd/ChangeLog b/bfd/ChangeLog
index 4dfc95d..ba76be3 100644
--- a/bfd/ChangeLog
+++ b/bfd/ChangeLog
@@ -1,5 +1,47 @@
 2001-06-05  Alan Modra  <amodra@bigpond.net.au>
 
+	* elf32-i386.c (elf_i386_discard_copies): Rename to
+	discard_copies, and use elf_link_hash_entry arg rather than
+	elf_i386_link_hash_entry.
+	(elf_i386_link_hash_traverse): Delete.
+	(elf_i386_size_dynamic_sections): Adjust call to discard_copies.
+	Tidy sizing of dynamic sections.
+	(elf_i386_check_relocs <R_386_32, R_386_PC32>): Reference count
+	possible .plt entries.
+	(elf_i386_gc_sweep_hook): Likewise.
+	(elf_i386_adjust_dynamic_symbol): Discard .plt entries for
+	everything with plt.refcount <= 0.
+
+	* elf32-i386.c (elf_i386_check_relocs): Don't allocate .got and
+	.relgot space here.
+	(elf_i386_gc_sweep_hook): ..and no need to deallocate here..
+	(elf32_hppa_adjust_dynamic_symbol): ..and don't allocate .plt and
+	.rel.plt here..
+	(allocate_plt_and_got): ..instead do it all here.  New function.
+	(elf_i386_size_dynamic_sections): Allocate local .got space and
+	call allocate_plt_and_got.  No need to zap .relgot if not dynamic.
+	(bfd_elf32_bfd_final_link): Delete.  (ie. use regular final link
+	rather than gc variety).
+	(WILL_CALL_FINISH_DYNAMIC_SYMBOL): Define.
+	(elf_i386_relocate_section): Use it here and correct handling of
+	R_386_GOT32.  Provide section and offset for "unresolvable
+	relocation" error message.
+	(elf_i386_finish_dynamic_symbol): Correct handling of R_386_GOT32.
+
+	* elf32-i386.c (struct elf_i386_link_hash_table): Add sgot,
+	sgotplt, srelgot, splt, srelplt, sdynbss, srelbss fields.
+	(elf_i386_link_hash_table_create): Init them.
+	(create_got_section): New function.
+	(elf_i386_create_dynamic_sections): New function.
+	(elf_backend_create_dynamic_sections): Set to above.
+	(elf_i386_check_relocs): Use shortcuts from hash table rather than
+	calling bfd_get_section_by_name.
+	(elf_i386_gc_sweep_hook): Likewise.
+	(elf_i386_adjust_dynamic_symbol): Likewise.
+	(elf_i386_size_dynamic_sections): Likewise.
+	(elf_i386_relocate_section): Likewise.
+	(elf_i386_finish_dynamic_sections): Likewise.
+
 	* elf32-hppa.c (allocate_plt_and_got): Skip indirect and warning syms.
 
 2001-06-02  H.J. Lu  <hjl@gnu.org>
diff --git a/bfd/elf32-i386.c b/bfd/elf32-i386.c
index f43adcd..b79eb0d 100644
--- a/bfd/elf32-i386.c
+++ b/bfd/elf32-i386.c
@@ -35,13 +35,20 @@ static struct bfd_hash_entry *elf_i386_link_hash_newfunc
   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
 static struct bfd_link_hash_table *elf_i386_link_hash_table_create
   PARAMS ((bfd *));
+static boolean create_got_section PARAMS((bfd *, struct bfd_link_info *));
+static boolean elf_i386_create_dynamic_sections
+  PARAMS((bfd *, struct bfd_link_info *));
 static boolean elf_i386_check_relocs
   PARAMS ((bfd *, struct bfd_link_info *, asection *,
 	   const Elf_Internal_Rela *));
 static boolean elf_i386_adjust_dynamic_symbol
   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
+static boolean allocate_plt_and_got
+  PARAMS ((struct elf_link_hash_entry *, PTR));
 static boolean elf_i386_size_dynamic_sections
   PARAMS ((bfd *, struct bfd_link_info *));
+static boolean discard_copies
+  PARAMS ((struct elf_link_hash_entry *, PTR));
 static boolean elf_i386_relocate_section
   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
 	   Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
@@ -385,20 +392,16 @@ struct elf_i386_link_hash_entry
 struct elf_i386_link_hash_table
 {
   struct elf_link_hash_table root;
-};
-
-/* Declare this now that the above structures are defined.  */
-
-static boolean elf_i386_discard_copies
-  PARAMS ((struct elf_i386_link_hash_entry *, PTR));
-
-/* Traverse an i386 ELF linker hash table.  */
 
-#define elf_i386_link_hash_traverse(table, func, info)			\
-  (elf_link_hash_traverse						\
-   (&(table)->root,							\
-    (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func),	\
-    (info)))
+  /* Short-cuts to get to dynamic linker sections.  */
+  asection *sgot;
+  asection *sgotplt;
+  asection *srelgot;
+  asection *splt;
+  asection *srelplt;
+  asection *sdynbss;
+  asection *srelbss;
+};
 
 /* Get the i386 ELF linker hash table from a link_info structure.  */
 
@@ -457,9 +460,78 @@ elf_i386_link_hash_table_create (abfd)
       return NULL;
     }
 
+  ret->sgot = NULL;
+  ret->sgotplt = NULL;
+  ret->srelgot = NULL;
+  ret->splt = NULL;
+  ret->srelplt = NULL;
+  ret->sdynbss = NULL;
+  ret->srelbss = NULL;
+
   return &ret->root.root;
 }
 
+/* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
+   shortcuts to them in our hash table.  */
+
+static boolean
+create_got_section (dynobj, info)
+     bfd *dynobj;
+     struct bfd_link_info *info;
+{
+  struct elf_i386_link_hash_table *htab;
+
+  if (! _bfd_elf_create_got_section (dynobj, info))
+    return false;
+
+  htab = elf_i386_hash_table (info);
+  htab->sgot = bfd_get_section_by_name (dynobj, ".got");
+  htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
+  if (!htab->sgot || !htab->sgotplt)
+    abort ();
+
+  htab->srelgot = bfd_make_section (dynobj, ".rel.got");
+  if (htab->srelgot == NULL
+      || ! bfd_set_section_flags (dynobj, htab->srelgot,
+				  (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
+				   | SEC_IN_MEMORY | SEC_LINKER_CREATED
+				   | SEC_READONLY))
+      || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
+    return false;
+  return true;
+}
+
+/* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
+   .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
+   hash table.  */
+
+static boolean
+elf_i386_create_dynamic_sections (dynobj, info)
+     bfd *dynobj;
+     struct bfd_link_info *info;
+{
+  struct elf_i386_link_hash_table *htab;
+
+  htab = elf_i386_hash_table (info);
+  if (!htab->sgot && !create_got_section (dynobj, info))
+    return false;
+
+  if (!_bfd_elf_create_dynamic_sections (dynobj, info))
+    return false;
+
+  htab->splt = bfd_get_section_by_name (dynobj, ".plt");
+  htab->srelplt = bfd_get_section_by_name (dynobj, ".rel.plt");
+  htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
+  if (!info->shared)
+    htab->srelbss = bfd_get_section_by_name (dynobj, ".rel.bss");
+
+  if (!htab->splt || !htab->srelplt || !htab->sdynbss
+      || (!info->shared && !htab->srelbss))
+    abort ();
+
+  return true;
+}
+
 /* Look through the relocs for a section during the first phase, and
    allocate space in the global offset table or procedure linkage
    table.  */
@@ -471,26 +543,24 @@ elf_i386_check_relocs (abfd, info, sec, relocs)
      asection *sec;
      const Elf_Internal_Rela *relocs;
 {
+  struct elf_i386_link_hash_table *htab;
   bfd *dynobj;
   Elf_Internal_Shdr *symtab_hdr;
   struct elf_link_hash_entry **sym_hashes;
   bfd_signed_vma *local_got_refcounts;
   const Elf_Internal_Rela *rel;
   const Elf_Internal_Rela *rel_end;
-  asection *sgot;
-  asection *srelgot;
   asection *sreloc;
 
   if (info->relocateable)
     return true;
 
-  dynobj = elf_hash_table (info)->dynobj;
+  htab = elf_i386_hash_table (info);
+  dynobj = htab->root.dynobj;
   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
   sym_hashes = elf_sym_hashes (abfd);
   local_got_refcounts = elf_local_got_refcounts (abfd);
 
-  sgot = NULL;
-  srelgot = NULL;
   sreloc = NULL;
 
   rel_end = relocs + sec->reloc_count;
@@ -529,7 +599,7 @@ elf_i386_check_relocs (abfd, info, sec, relocs)
 	    case R_386_GOTOFF:
 	    case R_386_GOTPC:
 	      elf_hash_table (info)->dynobj = dynobj = abfd;
-	      if (! _bfd_elf_create_got_section (dynobj, info))
+	      if (!create_got_section (dynobj, info))
 		return false;
 	      break;
 
@@ -542,48 +612,17 @@ elf_i386_check_relocs (abfd, info, sec, relocs)
 	{
 	case R_386_GOT32:
 	  /* This symbol requires a global offset table entry.  */
-
-	  if (sgot == NULL)
-	    {
-	      sgot = bfd_get_section_by_name (dynobj, ".got");
-	      BFD_ASSERT (sgot != NULL);
-	    }
-
-	  if (srelgot == NULL
-	      && (h != NULL || info->shared))
-	    {
-	      srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
-	      if (srelgot == NULL)
-		{
-		  srelgot = bfd_make_section (dynobj, ".rel.got");
-		  if (srelgot == NULL
-		      || ! bfd_set_section_flags (dynobj, srelgot,
-						  (SEC_ALLOC
-						   | SEC_LOAD
-						   | SEC_HAS_CONTENTS
-						   | SEC_IN_MEMORY
-						   | SEC_LINKER_CREATED
-						   | SEC_READONLY))
-		      || ! bfd_set_section_alignment (dynobj, srelgot, 2))
-		    return false;
-		}
-	    }
-
 	  if (h != NULL)
 	    {
 	      if (h->got.refcount == -1)
 		{
-		  h->got.refcount = 1;
-
 		  /* Make sure this symbol is output as a dynamic symbol.  */
 		  if (h->dynindx == -1)
 		    {
 		      if (! bfd_elf32_link_record_dynamic_symbol (info, h))
 			return false;
 		    }
-
-		  sgot->_raw_size += 4;
-		  srelgot->_raw_size += sizeof (Elf32_External_Rel);
+		  h->got.refcount = 1;
 		}
 	      else
 		h->got.refcount += 1;
@@ -604,18 +643,7 @@ elf_i386_check_relocs (abfd, info, sec, relocs)
 		  memset (local_got_refcounts, -1, size);
 		}
 	      if (local_got_refcounts[r_symndx] == -1)
-		{
-		  local_got_refcounts[r_symndx] = 1;
-
-		  sgot->_raw_size += 4;
-		  if (info->shared)
-		    {
-		      /* If we are generating a shared object, we need to
-			 output a R_386_RELATIVE reloc so that the dynamic
-			 linker can adjust this GOT entry.  */
-		      srelgot->_raw_size += sizeof (Elf32_External_Rel);
-		    }
-		}
+		local_got_refcounts[r_symndx] = 1;
 	      else
 		local_got_refcounts[r_symndx] += 1;
 	    }
@@ -636,8 +664,8 @@ elf_i386_check_relocs (abfd, info, sec, relocs)
 
 	  if (h->plt.refcount == -1)
 	    {
-	      h->plt.refcount = 1;
 	      h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
+	      h->plt.refcount = 1;
 	    }
 	  else
 	    h->plt.refcount += 1;
@@ -646,7 +674,19 @@ elf_i386_check_relocs (abfd, info, sec, relocs)
 	case R_386_32:
 	case R_386_PC32:
 	  if (h != NULL)
-	    h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
+	    {
+	      h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
+
+	      if (!info->shared)
+		{
+		  /* We may need a .plt entry if the function this
+		     reloc refers to is in a shared lib.  */
+		  if (h->plt.refcount == -1)
+		    h->plt.refcount = 1;
+		  else
+		    h->plt.refcount += 1;
+		}
+	    }
 
 	  /* If we are creating a shared library, and this is a reloc
 	     against a global symbol, or a non PC relative reloc
@@ -832,7 +872,7 @@ elf_i386_gc_mark_hook (abfd, info, rel, h, sym)
 static boolean
 elf_i386_gc_sweep_hook (abfd, info, sec, relocs)
      bfd *abfd;
-     struct bfd_link_info *info ATTRIBUTE_UNUSED;
+     struct bfd_link_info *info;
      asection *sec;
      const Elf_Internal_Rela *relocs;
 {
@@ -843,19 +883,14 @@ elf_i386_gc_sweep_hook (abfd, info, sec, relocs)
   unsigned long r_symndx;
   struct elf_link_hash_entry *h;
   bfd *dynobj;
-  asection *sgot;
-  asection *srelgot;
-
-  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
-  sym_hashes = elf_sym_hashes (abfd);
-  local_got_refcounts = elf_local_got_refcounts (abfd);
 
   dynobj = elf_hash_table (info)->dynobj;
   if (dynobj == NULL)
     return true;
 
-  sgot = bfd_get_section_by_name (dynobj, ".got");
-  srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
+  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+  sym_hashes = elf_sym_hashes (abfd);
+  local_got_refcounts = elf_local_got_refcounts (abfd);
 
   relend = relocs + sec->reloc_count;
   for (rel = relocs; rel < relend; rel++)
@@ -869,30 +904,21 @@ elf_i386_gc_sweep_hook (abfd, info, sec, relocs)
 	  {
 	    h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 	    if (h->got.refcount > 0)
-	      {
-		h->got.refcount -= 1;
-		if (h->got.refcount == 0)
-		  {
-		    sgot->_raw_size -= 4;
-		    srelgot->_raw_size -= sizeof (Elf32_External_Rel);
-		  }
-	      }
+	      h->got.refcount -= 1;
 	  }
 	else if (local_got_refcounts != NULL)
 	  {
 	    if (local_got_refcounts[r_symndx] > 0)
-	      {
-		local_got_refcounts[r_symndx] -= 1;
-		if (local_got_refcounts[r_symndx] == 0)
-		  {
-		    sgot->_raw_size -= 4;
-		    if (info->shared)
-		      srelgot->_raw_size -= sizeof (Elf32_External_Rel);
-		  }
-	      }
+	      local_got_refcounts[r_symndx] -= 1;
 	  }
 	break;
 
+      case R_386_32:
+      case R_386_PC32:
+	if (info->shared)
+	  break;
+	/* Fall through.  */
+
       case R_386_PLT32:
 	r_symndx = ELF32_R_SYM (rel->r_info);
 	if (r_symndx >= symtab_hdr->sh_info)
@@ -921,11 +947,13 @@ elf_i386_adjust_dynamic_symbol (info, h)
      struct bfd_link_info *info;
      struct elf_link_hash_entry *h;
 {
+  struct elf_i386_link_hash_table *htab;
   bfd *dynobj;
   asection *s;
   unsigned int power_of_two;
 
-  dynobj = elf_hash_table (info)->dynobj;
+  htab = elf_i386_hash_table (info);
+  dynobj = htab->root.dynobj;
 
   /* Make sure we know what is going on here.  */
   BFD_ASSERT (dynobj != NULL
@@ -944,17 +972,17 @@ elf_i386_adjust_dynamic_symbol (info, h)
   if (h->type == STT_FUNC
       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
     {
-      if ((! info->shared
-	   && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
-	   && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
-	  || (info->shared && h->plt.refcount <= 0))
+      if (h->plt.refcount <= 0
+	  || (! info->shared
+	      && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
+	      && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0))
 	{
 	  /* This case can occur if we saw a PLT32 reloc in an input
 	     file, but the symbol was never referred to by a dynamic
 	     object, or if all references were garbage collected.  In
 	     such a case, we don't actually need to build a procedure
 	     linkage table, and we can just do a PC32 reloc instead.  */
-	  h->plt.offset = (bfd_vma) -1;
+	  h->plt.refcount = (bfd_vma) -1;
 	  h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
 	  return true;
 	}
@@ -966,44 +994,15 @@ elf_i386_adjust_dynamic_symbol (info, h)
 	    return false;
 	}
 
-      s = bfd_get_section_by_name (dynobj, ".plt");
-      BFD_ASSERT (s != NULL);
-
-      /* If this is the first .plt entry, make room for the special
-	 first entry.  */
-      if (s->_raw_size == 0)
-	s->_raw_size += PLT_ENTRY_SIZE;
-
-      /* If this symbol is not defined in a regular file, and we are
-	 not generating a shared library, then set the symbol to this
-	 location in the .plt.  This is required to make function
-	 pointers compare as equal between the normal executable and
-	 the shared library.  */
-      if (! info->shared
-	  && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
-	{
-	  h->root.u.def.section = s;
-	  h->root.u.def.value = s->_raw_size;
-	}
-
-      h->plt.offset = s->_raw_size;
-
-      /* Make room for this entry.  */
-      s->_raw_size += PLT_ENTRY_SIZE;
-
-      /* We also need to make an entry in the .got.plt section, which
-	 will be placed in the .got section by the linker script.  */
-      s = bfd_get_section_by_name (dynobj, ".got.plt");
-      BFD_ASSERT (s != NULL);
-      s->_raw_size += 4;
-
-      /* We also need to make an entry in the .rel.plt section.  */
-      s = bfd_get_section_by_name (dynobj, ".rel.plt");
-      BFD_ASSERT (s != NULL);
-      s->_raw_size += sizeof (Elf32_External_Rel);
-
       return true;
     }
+  else
+    /* It's possible that we incorrectly decided a .plt reloc was
+       needed for an R_386_PC32 reloc to a non-function sym in
+       check_relocs.  We can't decide accurately between function and
+       non-function syms in check-relocs;  Objects loaded later in
+       the link may change h->type.  So fix it now.  */
+    h->plt.refcount = (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
@@ -1042,7 +1041,7 @@ elf_i386_adjust_dynamic_symbol (info, h)
      both the dynamic object and the regular object will refer to the
      same memory location for the variable.  */
 
-  s = bfd_get_section_by_name (dynobj, ".dynbss");
+  s = htab->sdynbss;
   BFD_ASSERT (s != NULL);
 
   /* We must generate a R_386_COPY reloc to tell the dynamic linker to
@@ -1053,7 +1052,7 @@ elf_i386_adjust_dynamic_symbol (info, h)
     {
       asection *srel;
 
-      srel = bfd_get_section_by_name (dynobj, ".rel.bss");
+      srel = htab->srelbss;
       BFD_ASSERT (srel != NULL);
       srel->_raw_size += sizeof (Elf32_External_Rel);
       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
@@ -1084,6 +1083,101 @@ elf_i386_adjust_dynamic_symbol (info, h)
   return true;
 }
 
+/* This is the condition under which elf_i386_finish_dynamic_symbol
+   will be called from elflink.h.  If elflink.h doesn't call our
+   finish_dynamic_symbol routine, we'll need to do something about
+   initializing any .plt and .got entries in elf_i386_relocate_section.  */
+#define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
+  ((DYN)								\
+   && ((INFO)->shared							\
+       || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)	\
+   && ((H)->dynindx != -1						\
+       || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
+
+/* Allocate space in .plt, .got and associated reloc sections for
+   global syms.  */
+
+static boolean
+allocate_plt_and_got (h, inf)
+     struct elf_link_hash_entry *h;
+     PTR inf;
+{
+  struct bfd_link_info *info;
+  struct elf_i386_link_hash_table *htab;
+  asection *s;
+
+  if (h->root.type == bfd_link_hash_indirect
+      || h->root.type == bfd_link_hash_warning)
+    return true;
+
+  info = (struct bfd_link_info *) inf;
+  htab = elf_i386_hash_table (info);
+
+  if (htab->root.dynamic_sections_created
+      && h->plt.refcount > 0)
+    {
+      s = htab->splt;
+      BFD_ASSERT (s != NULL);
+
+      /* If this is the first .plt entry, make room for the special
+	 first entry.  */
+      if (s->_raw_size == 0)
+	s->_raw_size += PLT_ENTRY_SIZE;
+
+      h->plt.offset = s->_raw_size;
+
+      /* If this symbol is not defined in a regular file, and we are
+	 not generating a shared library, then set the symbol to this
+	 location in the .plt.  This is required to make function
+	 pointers compare as equal between the normal executable and
+	 the shared library.  */
+      if (! info->shared
+	  && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
+	{
+	  h->root.u.def.section = s;
+	  h->root.u.def.value = h->plt.offset;
+	}
+
+      /* Make room for this entry.  */
+      s->_raw_size += PLT_ENTRY_SIZE;
+
+      /* We also need to make an entry in the .got.plt section, which
+	 will be placed in the .got section by the linker script.  */
+      s = htab->sgotplt;
+      BFD_ASSERT (s != NULL);
+      s->_raw_size += 4;
+
+      if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
+	{
+	  /* We also need to make an entry in the .rel.plt section.  */
+	  s = htab->srelplt;
+	  BFD_ASSERT (s != NULL);
+	  s->_raw_size += sizeof (Elf32_External_Rel);
+	}
+    }
+  else
+    {
+      h->plt.offset = (bfd_vma) -1;
+      h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
+    }
+
+  if (h->got.refcount > 0)
+    {
+      boolean dyn;
+
+      s = htab->sgot;
+      h->got.offset = s->_raw_size;
+      s->_raw_size += 4;
+      dyn = htab->root.dynamic_sections_created;
+      if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h))
+	htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
+    }
+  else
+    h->got.offset = (bfd_vma) -1;
+
+  return true;
+}
+
 /* Set the sizes of the dynamic sections.  */
 
 static boolean
@@ -1091,17 +1185,20 @@ elf_i386_size_dynamic_sections (output_bfd, info)
      bfd *output_bfd;
      struct bfd_link_info *info;
 {
+  struct elf_i386_link_hash_table *htab;
   bfd *dynobj;
   asection *s;
-  boolean plt;
   boolean relocs;
   boolean reltext;
 
-  dynobj = elf_hash_table (info)->dynobj;
+  htab = elf_i386_hash_table (info);
+  dynobj = htab->root.dynobj;
   BFD_ASSERT (dynobj != NULL);
 
-  if (elf_hash_table (info)->dynamic_sections_created)
+  if (htab->root.dynamic_sections_created)
     {
+      bfd *i;
+
       /* Set the contents of the .interp section to the interpreter.  */
       if (! info->shared)
 	{
@@ -1110,63 +1207,75 @@ elf_i386_size_dynamic_sections (output_bfd, info)
 	  s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
 	  s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
 	}
+
+      /* Set up .got offsets for local syms.  */
+      for (i = info->input_bfds; i; i = i->link_next)
+	{
+	  bfd_signed_vma *local_got;
+	  bfd_signed_vma *end_local_got;
+	  bfd_size_type locsymcount;
+	  Elf_Internal_Shdr *symtab_hdr;
+	  asection *srel;
+
+	  if (bfd_get_flavour (i) != bfd_target_elf_flavour)
+	    continue;
+
+	  local_got = elf_local_got_refcounts (i);
+	  if (!local_got)
+	    continue;
+
+	  symtab_hdr = &elf_tdata (i)->symtab_hdr;
+	  locsymcount = symtab_hdr->sh_info;
+	  end_local_got = local_got + locsymcount;
+	  s = htab->sgot;
+	  srel = htab->srelgot;
+	  for (; local_got < end_local_got; ++local_got)
+	    {
+	      if (*local_got > 0)
+		{
+		  *local_got = s->_raw_size;
+		  s->_raw_size += 4;
+		  if (info->shared)
+		    srel->_raw_size += sizeof (Elf32_External_Rel);
+		}
+	      else
+		*local_got = (bfd_vma) -1;
+	    }
+	}
     }
-  else
-    {
-      /* We may have created entries in the .rel.got section.
-         However, if we are not creating the dynamic sections, we will
-         not actually use these entries.  Reset the size of .rel.got,
-         which will cause it to get stripped from the output file
-         below.  */
-      s = bfd_get_section_by_name (dynobj, ".rel.got");
-      if (s != NULL)
-	s->_raw_size = 0;
-    }
+
+  /* Allocate global sym .plt and .got entries.  */
+  elf_link_hash_traverse (&htab->root,
+			  allocate_plt_and_got,
+			  (PTR) info);
 
   /* If this is a -Bsymbolic shared link, then we need to discard all
      PC relative relocs against symbols defined in a regular object.
      We allocated space for them in the check_relocs routine, but we
      will not fill them in in the relocate_section routine.  */
   if (info->shared)
-    elf_i386_link_hash_traverse (elf_i386_hash_table (info),
-				 elf_i386_discard_copies,
-				 (PTR) info);
+    elf_link_hash_traverse (&htab->root,
+			    discard_copies,
+			    (PTR) info);
 
   /* The check_relocs and adjust_dynamic_symbol entry points have
      determined the sizes of the various dynamic sections.  Allocate
      memory for them.  */
-  plt = false;
   relocs = false;
   reltext = false;
   for (s = dynobj->sections; s != NULL; s = s->next)
     {
-      const char *name;
-      boolean strip;
-
       if ((s->flags & SEC_LINKER_CREATED) == 0)
 	continue;
 
-      /* It's OK to base decisions on the section name, because none
-	 of the dynobj section names depend upon the input files.  */
-      name = bfd_get_section_name (dynobj, s);
-
-      strip = false;
-
-      if (strcmp (name, ".plt") == 0)
+      if (s == htab->splt
+	  || s == htab->sgot
+	  || s == htab->sgotplt)
 	{
-	  if (s->_raw_size == 0)
-	    {
-	      /* Strip this section if we don't need it; see the
-                 comment below.  */
-	      strip = true;
-	    }
-	  else
-	    {
-	      /* Remember whether there is a PLT.  */
-	      plt = true;
-	    }
+	  /* Strip this section if we don't need it; see the
+	     comment below.  */
 	}
-      else if (strncmp (name, ".rel", 4) == 0)
+      else if (strncmp (bfd_get_section_name (dynobj, s), ".rel", 4) == 0)
 	{
 	  if (s->_raw_size == 0)
 	    {
@@ -1179,7 +1288,6 @@ elf_i386_size_dynamic_sections (output_bfd, info)
 		 adjust_dynamic_symbol is called, and it is that
 		 function which decides whether anything needs to go
 		 into these sections.  */
-	      strip = true;
 	    }
 	  else
 	    {
@@ -1187,7 +1295,7 @@ elf_i386_size_dynamic_sections (output_bfd, info)
 
 	      /* Remember whether there are any reloc sections other
                  than .rel.plt.  */
-	      if (strcmp (name, ".rel.plt") != 0)
+	      if (s != htab->srelplt)
 		{
 		  const char *outname;
 
@@ -1212,13 +1320,13 @@ elf_i386_size_dynamic_sections (output_bfd, info)
 	      s->reloc_count = 0;
 	    }
 	}
-      else if (strncmp (name, ".got", 4) != 0)
+      else
 	{
 	  /* It's not one of our sections, so don't allocate space.  */
 	  continue;
 	}
 
-      if (strip)
+      if (s->_raw_size == 0)
 	{
 	  _bfd_strip_section_from_output (info, s);
 	  continue;
@@ -1230,11 +1338,11 @@ elf_i386_size_dynamic_sections (output_bfd, info)
 	 but this way if it does, we get a R_386_NONE reloc instead
 	 of garbage.  */
       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
-      if (s->contents == NULL && s->_raw_size != 0)
+      if (s->contents == NULL)
 	return false;
     }
 
-  if (elf_hash_table (info)->dynamic_sections_created)
+  if (htab->root.dynamic_sections_created)
     {
       /* Add some entries to the .dynamic section.  We fill in the
 	 values later, in elf_i386_finish_dynamic_sections, but we
@@ -1247,7 +1355,7 @@ elf_i386_size_dynamic_sections (output_bfd, info)
 	    return false;
 	}
 
-      if (plt)
+      if (htab->splt->_raw_size != 0)
 	{
 	  if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
 	      || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
@@ -1276,7 +1384,7 @@ elf_i386_size_dynamic_sections (output_bfd, info)
   return true;
 }
 
-/* This function is called via elf_i386_link_hash_traverse if we are
+/* This function is called via elf_link_hash_traverse if we are
    creating a shared object.  In the -Bsymbolic case, it discards the
    space allocated to copy PC relative relocs against symbols which
    are defined in regular objects.  For the normal non-symbolic case,
@@ -1286,21 +1394,25 @@ elf_i386_size_dynamic_sections (output_bfd, info)
    relocate_section routine.  */
 
 static boolean
-elf_i386_discard_copies (h, inf)
-     struct elf_i386_link_hash_entry *h;
+discard_copies (h, inf)
+     struct elf_link_hash_entry *h;
      PTR inf;
 {
   struct elf_i386_pcrel_relocs_copied *s;
-  struct bfd_link_info *info = (struct bfd_link_info *) inf;
+  struct bfd_link_info *info;
+  struct elf_i386_link_hash_entry *eh;
+
+  info = (struct bfd_link_info *) inf;
+  eh = (struct elf_i386_link_hash_entry *) h;
 
   /* If a symbol has been forced local or we have found a regular
      definition for the symbolic link case, then we won't be needing
      any relocs.  */
-  if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
-      && ((h->root.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
+  if ((eh->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
+      && ((eh->root.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
 	  || info->symbolic))
     {
-      for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
+      for (s = eh->pcrel_relocs_copied; s != NULL; s = s->next)
 	s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel);
     }
 
@@ -1321,30 +1433,22 @@ elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
      Elf_Internal_Sym *local_syms;
      asection **local_sections;
 {
+  struct elf_i386_link_hash_table *htab;
   bfd *dynobj;
   Elf_Internal_Shdr *symtab_hdr;
   struct elf_link_hash_entry **sym_hashes;
   bfd_vma *local_got_offsets;
-  asection *sgot;
-  asection *splt;
   asection *sreloc;
   Elf_Internal_Rela *rel;
   Elf_Internal_Rela *relend;
 
-  dynobj = elf_hash_table (info)->dynobj;
+  htab = elf_i386_hash_table (info);
+  dynobj = htab->root.dynobj;
   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
   sym_hashes = elf_sym_hashes (input_bfd);
   local_got_offsets = elf_local_got_offsets (input_bfd);
 
   sreloc = NULL;
-  splt = NULL;
-  sgot = NULL;
-  if (dynobj != NULL)
-    {
-      splt = bfd_get_section_by_name (dynobj, ".plt");
-      sgot = bfd_get_section_by_name (dynobj, ".got");
-    }
-
   rel = relocs;
   relend = relocs + input_section->reloc_count;
   for (; rel < relend; rel++)
@@ -1416,20 +1520,25 @@ elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
 	  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;
+	  relocation = 0;
 	  if (h->root.type == bfd_link_hash_defined
 	      || h->root.type == bfd_link_hash_defweak)
 	    {
 	      sec = h->root.u.def.section;
 	      if (r_type == R_386_GOTPC
 		  || (r_type == R_386_PLT32
-		      && splt != NULL
+		      && htab->splt != NULL
 		      && h->plt.offset != (bfd_vma) -1)
 		  || (r_type == R_386_GOT32
-		      && elf_hash_table (info)->dynamic_sections_created
-		      && (! info->shared
-			  || (! info->symbolic && h->dynindx != -1)
-			  || (h->elf_link_hash_flags
-			      & ELF_LINK_HASH_DEF_REGULAR) == 0))
+		      && (WILL_CALL_FINISH_DYNAMIC_SYMBOL
+			  (htab->root.dynamic_sections_created, info, h))
+		      && !(info->shared
+			   && (info->symbolic
+			       || h->dynindx == -1
+			       || (h->elf_link_hash_flags
+				   & ELF_LINK_FORCED_LOCAL))
+			   && (h->elf_link_hash_flags
+			       & ELF_LINK_HASH_DEF_REGULAR)))
 		  || (info->shared
 		      && ((! info->symbolic && h->dynindx != -1)
 			  || (h->elf_link_hash_flags
@@ -1444,31 +1553,28 @@ elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
 			  || ((input_section->flags & SEC_DEBUGGING) != 0
 			      && (h->elf_link_hash_flags
 				  & ELF_LINK_HASH_DEF_DYNAMIC) != 0))))
-		{
-		  /* In these cases, we don't need the relocation
-                     value.  We check specially because in some
-                     obscure cases sec->output_section will be NULL.  */
-		  relocation = 0;
-		}
+		/* In these cases, we don't need the relocation
+		   value.  We check specially because in some
+		   obscure cases sec->output_section will be NULL.  */
+		;
 	      else if (sec->output_section == NULL)
-		{
-		  (*_bfd_error_handler)
-		    (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
-		     bfd_get_filename (input_bfd), h->root.root.string,
-		     bfd_get_section_name (input_bfd, input_section));
-		  relocation = 0;
-		}
+		(*_bfd_error_handler)
+		  (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
+		   bfd_get_filename (input_bfd),
+		   bfd_get_section_name (input_bfd, input_section),
+		   (long) rel->r_offset,
+		   h->root.root.string);
 	      else
 		relocation = (h->root.u.def.value
 			      + sec->output_section->vma
 			      + sec->output_offset);
 	    }
 	  else if (h->root.type == bfd_link_hash_undefweak)
-	    relocation = 0;
+	    ;
 	  else if (info->shared && !info->symbolic
 		   && !info->no_undefined
 		   && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
-	    relocation = 0;
+	    ;
 	  else
 	    {
 	      if (! ((*info->callbacks->undefined_symbol)
@@ -1477,7 +1583,6 @@ elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
 		      (!info->shared || info->no_undefined
 		       || ELF_ST_VISIBILITY (h->other)))))
 		return false;
-	      relocation = 0;
 	    }
 	}
 
@@ -1486,18 +1591,22 @@ elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
 	case R_386_GOT32:
 	  /* Relocation is to the entry for this symbol in the global
 	     offset table.  */
-	  BFD_ASSERT (sgot != NULL);
+	  BFD_ASSERT (htab->sgot != NULL);
 
 	  if (h != NULL)
 	    {
 	      bfd_vma off;
+	      boolean dyn;
 
 	      off = h->got.offset;
 	      BFD_ASSERT (off != (bfd_vma) -1);
 
-	      if (! elf_hash_table (info)->dynamic_sections_created
+	      dyn = htab->root.dynamic_sections_created;
+	      if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
 		  || (info->shared
-		      && (info->symbolic || h->dynindx == -1)
+		      && (info->symbolic
+			  || h->dynindx == -1
+			  || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
 		      && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
 		{
 		  /* This is actually a static link, or it is a
@@ -1517,12 +1626,12 @@ elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
 		  else
 		    {
 		      bfd_put_32 (output_bfd, relocation,
-				  sgot->contents + off);
+				  htab->sgot->contents + off);
 		      h->got.offset |= 1;
 		    }
 		}
 
-	      relocation = sgot->output_offset + off;
+	      relocation = htab->sgot->output_offset + off;
 	    }
 	  else
 	    {
@@ -1540,18 +1649,19 @@ elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
 		off &= ~1;
 	      else
 		{
-		  bfd_put_32 (output_bfd, relocation, sgot->contents + off);
+		  bfd_put_32 (output_bfd, relocation,
+			      htab->sgot->contents + off);
 
 		  if (info->shared)
 		    {
 		      asection *srelgot;
 		      Elf_Internal_Rel outrel;
 
-		      srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
+		      srelgot = htab->srelgot;
 		      BFD_ASSERT (srelgot != NULL);
 
-		      outrel.r_offset = (sgot->output_section->vma
-					 + sgot->output_offset
+		      outrel.r_offset = (htab->sgot->output_section->vma
+					 + htab->sgot->output_offset
 					 + off);
 		      outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
 		      bfd_elf32_swap_reloc_out (output_bfd, &outrel,
@@ -1564,7 +1674,7 @@ elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
 		  local_got_offsets[r_symndx] |= 1;
 		}
 
-	      relocation = sgot->output_offset + off;
+	      relocation = htab->sgot->output_offset + off;
 	    }
 
 	  break;
@@ -1573,32 +1683,18 @@ elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
 	  /* Relocation is relative to the start of the global offset
 	     table.  */
 
-	  if (sgot == NULL)
-	    {
-	      sgot = bfd_get_section_by_name (dynobj, ".got");
-	      BFD_ASSERT (sgot != NULL);
-	    }
-
 	  /* Note that sgot->output_offset is not involved in this
 	     calculation.  We always want the start of .got.  If we
 	     defined _GLOBAL_OFFSET_TABLE in a different way, as is
 	     permitted by the ABI, we might have to change this
 	     calculation.  */
-	  relocation -= sgot->output_section->vma;
+	  relocation -= htab->sgot->output_section->vma;
 
 	  break;
 
 	case R_386_GOTPC:
 	  /* Use global offset table as symbol value.  */
-
-	  if (sgot == NULL)
-	    {
-	      sgot = bfd_get_section_by_name (dynobj, ".got");
-	      BFD_ASSERT (sgot != NULL);
-	    }
-
-	  relocation = sgot->output_section->vma;
-
+	  relocation = htab->sgot->output_section->vma;
 	  break;
 
 	case R_386_PLT32:
@@ -1611,7 +1707,7 @@ elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
 	    break;
 
 	  if (h->plt.offset == (bfd_vma) -1
-	      || splt == NULL)
+	      || htab->splt == NULL)
 	    {
 	      /* We didn't make a PLT entry for this symbol.  This
                  happens when statically linking PIC code, or when
@@ -1619,8 +1715,8 @@ elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
 	      break;
 	    }
 
-	  relocation = (splt->output_section->vma
-			+ splt->output_offset
+	  relocation = (htab->splt->output_section->vma
+			+ htab->splt->output_offset
 			+ h->plt.offset);
 
 	  break;
@@ -1797,15 +1893,14 @@ elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
      struct elf_link_hash_entry *h;
      Elf_Internal_Sym *sym;
 {
+  struct elf_i386_link_hash_table *htab;
   bfd *dynobj;
 
-  dynobj = elf_hash_table (info)->dynobj;
+  htab = elf_i386_hash_table (info);
+  dynobj = htab->root.dynobj;
 
   if (h->plt.offset != (bfd_vma) -1)
     {
-      asection *splt;
-      asection *sgot;
-      asection *srel;
       bfd_vma plt_index;
       bfd_vma got_offset;
       Elf_Internal_Rel rel;
@@ -1813,12 +1908,10 @@ elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
       /* This symbol has an entry in the procedure linkage table.  Set
 	 it up.  */
 
-      BFD_ASSERT (h->dynindx != -1);
-
-      splt = bfd_get_section_by_name (dynobj, ".plt");
-      sgot = bfd_get_section_by_name (dynobj, ".got.plt");
-      srel = bfd_get_section_by_name (dynobj, ".rel.plt");
-      BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
+      BFD_ASSERT (h->dynindx != -1
+		  && htab->splt != NULL
+		  && htab->sgotplt != NULL
+		  && htab->srelplt != NULL);
 
       /* Get the index in the procedure linkage table which
 	 corresponds to this symbol.  This is the index of this symbol
@@ -1834,42 +1927,42 @@ elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
       /* Fill in the entry in the procedure linkage table.  */
       if (! info->shared)
 	{
-	  memcpy (splt->contents + h->plt.offset, elf_i386_plt_entry,
+	  memcpy (htab->splt->contents + h->plt.offset, elf_i386_plt_entry,
 		  PLT_ENTRY_SIZE);
 	  bfd_put_32 (output_bfd,
-		      (sgot->output_section->vma
-		       + sgot->output_offset
+		      (htab->sgotplt->output_section->vma
+		       + htab->sgotplt->output_offset
 		       + got_offset),
-		      splt->contents + h->plt.offset + 2);
+		      htab->splt->contents + h->plt.offset + 2);
 	}
       else
 	{
-	  memcpy (splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
+	  memcpy (htab->splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
 		  PLT_ENTRY_SIZE);
 	  bfd_put_32 (output_bfd, got_offset,
-		      splt->contents + h->plt.offset + 2);
+		      htab->splt->contents + h->plt.offset + 2);
 	}
 
       bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
-		  splt->contents + h->plt.offset + 7);
+		  htab->splt->contents + h->plt.offset + 7);
       bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
-		  splt->contents + h->plt.offset + 12);
+		  htab->splt->contents + h->plt.offset + 12);
 
       /* Fill in the entry in the global offset table.  */
       bfd_put_32 (output_bfd,
-		  (splt->output_section->vma
-		   + splt->output_offset
+		  (htab->splt->output_section->vma
+		   + htab->splt->output_offset
 		   + h->plt.offset
 		   + 6),
-		  sgot->contents + got_offset);
+		  htab->sgotplt->contents + got_offset);
 
       /* Fill in the entry in the .rel.plt section.  */
-      rel.r_offset = (sgot->output_section->vma
-		      + sgot->output_offset
+      rel.r_offset = (htab->sgotplt->output_section->vma
+		      + htab->sgotplt->output_offset
 		      + got_offset);
       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
       bfd_elf32_swap_reloc_out (output_bfd, &rel,
-				((Elf32_External_Rel *) srel->contents
+				((Elf32_External_Rel *) htab->srelplt->contents
 				 + plt_index));
 
       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
@@ -1882,19 +1975,15 @@ elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
 
   if (h->got.offset != (bfd_vma) -1)
     {
-      asection *sgot;
-      asection *srel;
       Elf_Internal_Rel rel;
 
       /* This symbol has an entry in the global offset table.  Set it
 	 up.  */
 
-      sgot = bfd_get_section_by_name (dynobj, ".got");
-      srel = bfd_get_section_by_name (dynobj, ".rel.got");
-      BFD_ASSERT (sgot != NULL && srel != NULL);
+      BFD_ASSERT (htab->sgot != NULL && htab->srelgot != NULL);
 
-      rel.r_offset = (sgot->output_section->vma
-		      + sgot->output_offset
+      rel.r_offset = (htab->sgot->output_section->vma
+		      + htab->sgot->output_offset
 		      + (h->got.offset &~ 1));
 
       /* If this is a static link, or it is a -Bsymbolic link and the
@@ -1902,49 +1991,48 @@ elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
 	 of a version file, we just want to emit a RELATIVE reloc.
 	 The entry in the global offset table will already have been
 	 initialized in the relocate_section function.  */
-      if (! elf_hash_table (info)->dynamic_sections_created
-	  || (info->shared
-	      && (info->symbolic || h->dynindx == -1)
-	      && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
+      if (info->shared
+	  && (info->symbolic
+	      || h->dynindx == -1
+	      || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
+	  && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
 	{
+	  BFD_ASSERT((h->got.offset & 1) != 0);
 	  rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
 	}
       else
 	{
 	  BFD_ASSERT((h->got.offset & 1) == 0);
-	  bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
+	  bfd_put_32 (output_bfd, (bfd_vma) 0,
+		      htab->sgot->contents + h->got.offset);
 	  rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
 	}
 
       bfd_elf32_swap_reloc_out (output_bfd, &rel,
-				((Elf32_External_Rel *) srel->contents
-				 + srel->reloc_count));
-      ++srel->reloc_count;
+				((Elf32_External_Rel *) htab->srelgot->contents
+				 + htab->srelgot->reloc_count));
+      ++htab->srelgot->reloc_count;
     }
 
   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
     {
-      asection *s;
       Elf_Internal_Rel rel;
 
       /* This symbol needs a copy reloc.  Set it up.  */
 
       BFD_ASSERT (h->dynindx != -1
 		  && (h->root.type == bfd_link_hash_defined
-		      || h->root.type == bfd_link_hash_defweak));
-
-      s = bfd_get_section_by_name (h->root.u.def.section->owner,
-				   ".rel.bss");
-      BFD_ASSERT (s != NULL);
+		      || h->root.type == bfd_link_hash_defweak)
+		  && htab->srelbss != NULL);
 
       rel.r_offset = (h->root.u.def.value
 		      + h->root.u.def.section->output_section->vma
 		      + h->root.u.def.section->output_offset);
       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
       bfd_elf32_swap_reloc_out (output_bfd, &rel,
-				((Elf32_External_Rel *) s->contents
-				 + s->reloc_count));
-      ++s->reloc_count;
+				((Elf32_External_Rel *) htab->srelbss->contents
+				 + htab->srelbss->reloc_count));
+      ++htab->srelbss->reloc_count;
     }
 
   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
@@ -1962,19 +2050,18 @@ elf_i386_finish_dynamic_sections (output_bfd, info)
      bfd *output_bfd;
      struct bfd_link_info *info;
 {
+  struct elf_i386_link_hash_table *htab;
   bfd *dynobj;
-  asection *sgot;
   asection *sdyn;
 
-  dynobj = elf_hash_table (info)->dynobj;
+  htab = elf_i386_hash_table (info);
+  dynobj = htab->root.dynobj;
 
-  sgot = bfd_get_section_by_name (dynobj, ".got.plt");
-  BFD_ASSERT (sgot != NULL);
+  BFD_ASSERT (htab->sgot != NULL);
   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
 
-  if (elf_hash_table (info)->dynamic_sections_created)
+  if (htab->root.dynamic_sections_created)
     {
-      asection *splt;
       Elf32_External_Dyn *dyncon, *dynconend;
 
       BFD_ASSERT (sdyn != NULL);
@@ -1984,8 +2071,6 @@ elf_i386_finish_dynamic_sections (output_bfd, info)
       for (; dyncon < dynconend; dyncon++)
 	{
 	  Elf_Internal_Dyn dyn;
-	  const char *name;
-	  asection *s;
 
 	  bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
 
@@ -1995,24 +2080,20 @@ elf_i386_finish_dynamic_sections (output_bfd, info)
 	      break;
 
 	    case DT_PLTGOT:
-	      name = ".got";
-	      goto get_vma;
+	      dyn.d_un.d_ptr = htab->sgot->output_section->vma;
+	      bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
+	      break;
+
 	    case DT_JMPREL:
-	      name = ".rel.plt";
-	    get_vma:
-	      s = bfd_get_section_by_name (output_bfd, name);
-	      BFD_ASSERT (s != NULL);
-	      dyn.d_un.d_ptr = s->vma;
+	      dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
 	      bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
 	      break;
 
 	    case DT_PLTRELSZ:
-	      s = bfd_get_section_by_name (output_bfd, ".rel.plt");
-	      BFD_ASSERT (s != NULL);
-	      if (s->_cooked_size != 0)
-		dyn.d_un.d_val = s->_cooked_size;
+	      if (htab->srelplt->output_section->_cooked_size != 0)
+		dyn.d_un.d_val = htab->srelplt->output_section->_cooked_size;
 	      else
-		dyn.d_un.d_val = s->_raw_size;
+		dyn.d_un.d_val = htab->srelplt->output_section->_raw_size;
 	      bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
 	      break;
 
@@ -2026,13 +2107,12 @@ elf_i386_finish_dynamic_sections (output_bfd, info)
 		 the linker script arranges for .rel.plt to follow all
 		 other relocation sections, we don't have to worry
 		 about changing the DT_REL entry.  */
-	      s = bfd_get_section_by_name (output_bfd, ".rel.plt");
-	      if (s != NULL)
+	      if (htab->srelplt != NULL)
 		{
-		  if (s->_cooked_size != 0)
-		    dyn.d_un.d_val -= s->_cooked_size;
+		  if (htab->srelplt->output_section->_cooked_size != 0)
+		    dyn.d_un.d_val -= htab->srelplt->output_section->_cooked_size;
 		  else
-		    dyn.d_un.d_val -= s->_raw_size;
+		    dyn.d_un.d_val -= htab->srelplt->output_section->_raw_size;
 		}
 	      bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
 	      break;
@@ -2040,42 +2120,46 @@ elf_i386_finish_dynamic_sections (output_bfd, info)
 	}
 
       /* Fill in the first entry in the procedure linkage table.  */
-      splt = bfd_get_section_by_name (dynobj, ".plt");
-      if (splt && splt->_raw_size > 0)
+      if (htab->splt && htab->splt->_raw_size > 0)
 	{
 	  if (info->shared)
-	    memcpy (splt->contents, elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
+	    memcpy (htab->splt->contents,
+		    elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
 	  else
 	    {
-	      memcpy (splt->contents, elf_i386_plt0_entry, PLT_ENTRY_SIZE);
+	      memcpy (htab->splt->contents,
+		      elf_i386_plt0_entry, PLT_ENTRY_SIZE);
 	      bfd_put_32 (output_bfd,
-			  sgot->output_section->vma + sgot->output_offset + 4,
-			  splt->contents + 2);
+			  (htab->sgotplt->output_section->vma
+			   + htab->sgotplt->output_offset
+			   + 4),
+			  htab->splt->contents + 2);
 	      bfd_put_32 (output_bfd,
-			  sgot->output_section->vma + sgot->output_offset + 8,
-			  splt->contents + 8);
+			  (htab->sgotplt->output_section->vma
+			   + htab->sgotplt->output_offset
+			   + 8),
+			  htab->splt->contents + 8);
 	    }
 
 	  /* UnixWare sets the entsize of .plt to 4, although that doesn't
 	     really seem like the right value.  */
-	  elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
+	  elf_section_data (htab->splt->output_section)
+	    ->this_hdr.sh_entsize = 4;
 	}
     }
 
   /* Fill in the first three entries in the global offset table.  */
-  if (sgot->_raw_size > 0)
+  if (htab->sgotplt->_raw_size > 0)
     {
-      if (sdyn == NULL)
-	bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
-      else
-	bfd_put_32 (output_bfd,
-		    sdyn->output_section->vma + sdyn->output_offset,
-		    sgot->contents);
-      bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
-      bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
+      bfd_put_32 (output_bfd,
+		  (sdyn == NULL ? (bfd_vma) 0
+		   : sdyn->output_section->vma + sdyn->output_offset),
+		  htab->sgotplt->contents);
+      bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 4);
+      bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 8);
     }
 
-  elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
+  elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 4;
 
   return true;
 }
@@ -2134,14 +2218,13 @@ elf_i386_fake_sections (abfd, hdr, sec)
 #define elf_info_to_howto		      elf_i386_info_to_howto
 #define elf_info_to_howto_rel		      elf_i386_info_to_howto_rel
 
-#define bfd_elf32_bfd_final_link	      _bfd_elf32_gc_common_final_link
 #define bfd_elf32_bfd_is_local_label_name     elf_i386_is_local_label_name
 #define bfd_elf32_bfd_link_hash_table_create  elf_i386_link_hash_table_create
 #define bfd_elf32_bfd_reloc_type_lookup	      elf_i386_reloc_type_lookup
 
 #define elf_backend_adjust_dynamic_symbol     elf_i386_adjust_dynamic_symbol
 #define elf_backend_check_relocs	      elf_i386_check_relocs
-#define elf_backend_create_dynamic_sections   _bfd_elf_create_dynamic_sections
+#define elf_backend_create_dynamic_sections   elf_i386_create_dynamic_sections
 #define elf_backend_finish_dynamic_sections   elf_i386_finish_dynamic_sections
 #define elf_backend_finish_dynamic_symbol     elf_i386_finish_dynamic_symbol
 #define elf_backend_gc_mark_hook	      elf_i386_gc_mark_hook