]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blobdiff - bfd/elflink.c
* bfd-in.h (STRING_AND_COMMA): New macro. Takes one constant string as its
[thirdparty/binutils-gdb.git] / bfd / elflink.c
index 082b5303021ba472c187b5b7768e6cbce332cbac..9b45578494893503d78635851a22b34b318963d6 100644 (file)
@@ -1,6 +1,6 @@
 /* ELF linking support for BFD.
-   Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
-   Free Software Foundation, Inc.
+   Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+   2005, 2006 Free Software Foundation, Inc.
 
    This file is part of BFD, the Binary File Descriptor library.
 
 #include "elf-bfd.h"
 #include "safe-ctype.h"
 #include "libiberty.h"
+#include "objalloc.h"
+
+/* Define a symbol in a dynamic linkage section.  */
+
+struct elf_link_hash_entry *
+_bfd_elf_define_linkage_sym (bfd *abfd,
+                            struct bfd_link_info *info,
+                            asection *sec,
+                            const char *name)
+{
+  struct elf_link_hash_entry *h;
+  struct bfd_link_hash_entry *bh;
+  const struct elf_backend_data *bed;
+
+  h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, FALSE);
+  if (h != NULL)
+    {
+      /* Zap symbol defined in an as-needed lib that wasn't linked.
+        This is a symptom of a larger problem:  Absolute symbols
+        defined in shared libraries can't be overridden, because we
+        lose the link to the bfd which is via the symbol section.  */
+      h->root.type = bfd_link_hash_new;
+    }
+
+  bh = &h->root;
+  if (!_bfd_generic_link_add_one_symbol (info, abfd, name, BSF_GLOBAL,
+                                        sec, 0, NULL, FALSE,
+                                        get_elf_backend_data (abfd)->collect,
+                                        &bh))
+    return NULL;
+  h = (struct elf_link_hash_entry *) bh;
+  h->def_regular = 1;
+  h->type = STT_OBJECT;
+  h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
+
+  bed = get_elf_backend_data (abfd);
+  (*bed->elf_backend_hide_symbol) (info, h, TRUE);
+  return h;
+}
 
 bfd_boolean
 _bfd_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
@@ -33,7 +72,6 @@ _bfd_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
   flagword flags;
   asection *s;
   struct elf_link_hash_entry *h;
-  struct bfd_link_hash_entry *bh;
   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
   int ptralign;
 
@@ -78,21 +116,10 @@ _bfd_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
         (or .got.plt) section.  We don't do this in the linker script
         because we don't want to define the symbol if we are not creating
         a global offset table.  */
-      bh = NULL;
-      if (!(_bfd_generic_link_add_one_symbol
-           (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
-            0, NULL, FALSE, bed->collect, &bh)))
-       return FALSE;
-      h = (struct elf_link_hash_entry *) bh;
-      h->def_regular = 1;
-      h->type = STT_OBJECT;
-      h->other = STV_HIDDEN;
-
-      if (! info->executable
-         && ! bfd_elf_link_record_dynamic_symbol (info, h))
-       return FALSE;
-
+      h = _bfd_elf_define_linkage_sym (abfd, info, s, "_GLOBAL_OFFSET_TABLE_");
       elf_hash_table (info)->hgot = h;
+      if (h == NULL)
+       return FALSE;
     }
 
   /* The first bit of the global offset table is the header.  */
@@ -132,8 +159,6 @@ _bfd_elf_link_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
 {
   flagword flags;
   register asection *s;
-  struct elf_link_hash_entry *h;
-  struct bfd_link_hash_entry *bh;
   const struct elf_backend_data *bed;
 
   if (! is_elf_hash_table (info->hash))
@@ -212,35 +237,33 @@ _bfd_elf_link_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
      section.  We don't want to define it if there is no .dynamic
      section, since on some ELF platforms the start up code examines it
      to decide how to initialize the process.  */
-  h = elf_link_hash_lookup (elf_hash_table (info), "_DYNAMIC",
-                           FALSE, FALSE, FALSE);
-  if (h != NULL)
-    {
-      /* Zap symbol defined in an as-needed lib that wasn't linked.
-        This is a symptom of a larger problem:  Absolute symbols
-        defined in shared libraries can't be overridden, because we
-        lose the link to the bfd which is via the symbol section.  */
-      h->root.type = bfd_link_hash_new;
-    }
-  bh = &h->root;
-  if (! (_bfd_generic_link_add_one_symbol
-        (info, abfd, "_DYNAMIC", BSF_GLOBAL, s, 0, NULL, FALSE,
-         get_elf_backend_data (abfd)->collect, &bh)))
+  if (!_bfd_elf_define_linkage_sym (abfd, info, s, "_DYNAMIC"))
     return FALSE;
-  h = (struct elf_link_hash_entry *) bh;
-  h->def_regular = 1;
-  h->type = STT_OBJECT;
 
-  if (! info->executable
-      && ! bfd_elf_link_record_dynamic_symbol (info, h))
-    return FALSE;
+  if (info->emit_hash)
+    {
+      s = bfd_make_section_with_flags (abfd, ".hash", flags | SEC_READONLY);
+      if (s == NULL
+         || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
+       return FALSE;
+      elf_section_data (s)->this_hdr.sh_entsize = bed->s->sizeof_hash_entry;
+    }
 
-  s = bfd_make_section_with_flags (abfd, ".hash",
-                                  flags | SEC_READONLY);
-  if (s == NULL
-      || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
-    return FALSE;
-  elf_section_data (s)->this_hdr.sh_entsize = bed->s->sizeof_hash_entry;
+  if (info->emit_gnu_hash)
+    {
+      s = bfd_make_section_with_flags (abfd, ".gnu.hash",
+                                      flags | SEC_READONLY);
+      if (s == NULL
+         || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
+       return FALSE;
+      /* For 64-bit ELF, .gnu.hash is a non-uniform entity size section:
+        4 32-bit words followed by variable count of 64-bit words, then
+        variable count of 32-bit words.  */
+      if (bed->s->arch_size == 64)
+       elf_section_data (s)->this_hdr.sh_entsize = 0;
+      else
+       elf_section_data (s)->this_hdr.sh_entsize = 4;
+    }
 
   /* Let the backend create the rest of the sections.  This lets the
      backend set the right flags.  The backend will normally create
@@ -259,6 +282,7 @@ bfd_boolean
 _bfd_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
 {
   flagword flags, pltflags;
+  struct elf_link_hash_entry *h;
   asection *s;
   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
 
@@ -282,23 +306,14 @@ _bfd_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
     return FALSE;
 
+  /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
+     .plt section.  */
   if (bed->want_plt_sym)
     {
-      /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
-        .plt section.  */
-      struct elf_link_hash_entry *h;
-      struct bfd_link_hash_entry *bh = NULL;
-
-      if (! (_bfd_generic_link_add_one_symbol
-            (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s, 0, NULL,
-             FALSE, get_elf_backend_data (abfd)->collect, &bh)))
-       return FALSE;
-      h = (struct elf_link_hash_entry *) bh;
-      h->def_regular = 1;
-      h->type = STT_OBJECT;
-
-      if (! info->executable
-         && ! bfd_elf_link_record_dynamic_symbol (info, h))
+      h = _bfd_elf_define_linkage_sym (abfd, info, s,
+                                      "_PROCEDURE_LINKAGE_TABLE_");
+      elf_hash_table (info)->hplt = h;
+      if (h == NULL)
        return FALSE;
     }
 
@@ -429,13 +444,30 @@ bfd_elf_link_record_dynamic_symbol (struct bfd_link_info *info,
   return TRUE;
 }
 \f
+/* Mark a symbol dynamic.  */
+
+void
+bfd_elf_link_mark_dynamic_symbol (struct bfd_link_info *info,
+                                 struct elf_link_hash_entry *h)
+{
+  struct bfd_elf_dynamic_list *d = info->dynamic;
+
+  if (d == NULL || info->relocatable)
+    return;
+
+  if ((*d->match) (&d->head, NULL, h->root.root.string))
+    h->dynamic = 1;
+}
+
 /* Record an assignment to a symbol made by a linker script.  We need
    this in case some dynamic object refers to this symbol.  */
 
 bfd_boolean
-bfd_elf_record_link_assignment (struct bfd_link_info *info,
+bfd_elf_record_link_assignment (bfd *output_bfd,
+                               struct bfd_link_info *info,
                                const char *name,
-                               bfd_boolean provide)
+                               bfd_boolean provide,
+                               bfd_boolean hidden)
 {
   struct elf_link_hash_entry *h;
   struct elf_link_hash_table *htab;
@@ -460,7 +492,10 @@ bfd_elf_record_link_assignment (struct bfd_link_info *info,
     }
 
   if (h->root.type == bfd_link_hash_new)
-    h->non_elf = 0;
+    {
+      bfd_elf_link_mark_dynamic_symbol (info, h);
+      h->non_elf = 0;
+    }
 
   /* If this symbol is being provided by the linker script, and it is
      currently defined by a dynamic object, but not by a regular
@@ -482,6 +517,14 @@ bfd_elf_record_link_assignment (struct bfd_link_info *info,
 
   h->def_regular = 1;
 
+  if (provide && hidden)
+    {
+      const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
+
+      h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
+      (*bed->elf_backend_hide_symbol) (info, h, TRUE);
+    }
+
   /* STV_HIDDEN and STV_INTERNAL symbols must be STB_LOCAL in shared objects
      and executables.  */
   if (!info->relocatable
@@ -744,7 +787,8 @@ _bfd_elf_link_renumber_dynsyms (bfd *output_bfd,
   if (dynsymcount != 0)
     ++dynsymcount;
 
-  return elf_hash_table (info)->dynsymcount = dynsymcount;
+  elf_hash_table (info)->dynsymcount = dynsymcount;
+  return dynsymcount;
 }
 
 /* This function is called when we want to define a new symbol.  It
@@ -814,6 +858,7 @@ _bfd_elf_merge_symbol (bfd *abfd,
 
   if (h->root.type == bfd_link_hash_new)
     {
+      bfd_elf_link_mark_dynamic_symbol (info, h);
       h->non_elf = 0;
       return TRUE;
     }
@@ -860,59 +905,52 @@ _bfd_elf_merge_symbol (bfd *abfd,
   /* NEWDYN and OLDDYN indicate whether the new or old symbol,
      respectively, is from a dynamic object.  */
 
-  if ((abfd->flags & DYNAMIC) != 0)
-    newdyn = TRUE;
-  else
-    newdyn = FALSE;
+  newdyn = (abfd->flags & DYNAMIC) != 0;
 
+  olddyn = FALSE;
   if (oldbfd != NULL)
     olddyn = (oldbfd->flags & DYNAMIC) != 0;
-  else
+  else if (oldsec != NULL)
     {
-      asection *hsec;
-
-      /* This code handles the special SHN_MIPS_{TEXT,DATA} section
+      /* This handles the special SHN_MIPS_{TEXT,DATA} section
         indices used by MIPS ELF.  */
-      switch (h->root.type)
-       {
-       default:
-         hsec = NULL;
-         break;
-
-       case bfd_link_hash_defined:
-       case bfd_link_hash_defweak:
-         hsec = h->root.u.def.section;
-         break;
-
-       case bfd_link_hash_common:
-         hsec = h->root.u.c.p->section;
-         break;
-       }
-
-      if (hsec == NULL)
-       olddyn = FALSE;
-      else
-       olddyn = (hsec->symbol->flags & BSF_DYNAMIC) != 0;
+      olddyn = (oldsec->symbol->flags & BSF_DYNAMIC) != 0;
     }
 
   /* NEWDEF and OLDDEF indicate whether the new or old symbol,
      respectively, appear to be a definition rather than reference.  */
 
-  if (bfd_is_und_section (sec) || bfd_is_com_section (sec))
-    newdef = FALSE;
-  else
-    newdef = TRUE;
-
-  if (h->root.type == bfd_link_hash_undefined
-      || h->root.type == bfd_link_hash_undefweak
-      || h->root.type == bfd_link_hash_common)
-    olddef = FALSE;
-  else
-    olddef = TRUE;
+  newdef = !bfd_is_und_section (sec) && !bfd_is_com_section (sec);
+
+  olddef = (h->root.type != bfd_link_hash_undefined
+           && h->root.type != bfd_link_hash_undefweak
+           && h->root.type != bfd_link_hash_common);
+
+  /* When we try to create a default indirect symbol from the dynamic
+     definition with the default version, we skip it if its type and
+     the type of existing regular definition mismatch.  We only do it
+     if the existing regular definition won't be dynamic.  */
+  if (pold_alignment == NULL
+      && !info->shared
+      && !info->export_dynamic
+      && !h->ref_dynamic
+      && newdyn
+      && newdef
+      && !olddyn
+      && (olddef || h->root.type == bfd_link_hash_common)
+      && ELF_ST_TYPE (sym->st_info) != h->type
+      && ELF_ST_TYPE (sym->st_info) != STT_NOTYPE
+      && h->type != STT_NOTYPE)
+    {
+      *skip = TRUE;
+      return TRUE;
+    }
 
-  /* Check TLS symbol.  */
+  /* Check TLS symbol.  We don't check undefined symbol introduced by
+     "ld -u".  */
   if ((ELF_ST_TYPE (sym->st_info) == STT_TLS || h->type == STT_TLS)
-      && ELF_ST_TYPE (sym->st_info) != h->type)
+      && ELF_ST_TYPE (sym->st_info) != h->type
+      && oldbfd != NULL)
     {
       bfd *ntbfd, *tbfd;
       bfd_boolean ntdef, tdef;
@@ -1006,7 +1044,41 @@ _bfd_elf_merge_symbol (bfd *abfd,
         relocatable file and the old definition comes from a dynamic
         object, we remove the old definition.  */
       if ((*sym_hash)->root.type == bfd_link_hash_indirect)
-       h = *sym_hash;
+       {
+         /* Handle the case where the old dynamic definition is
+            default versioned.  We need to copy the symbol info from
+            the symbol with default version to the normal one if it
+            was referenced before.  */
+         if (h->ref_regular)
+           {
+             const struct elf_backend_data *bed
+               = get_elf_backend_data (abfd);
+             struct elf_link_hash_entry *vh = *sym_hash;
+             vh->root.type = h->root.type;
+             h->root.type = bfd_link_hash_indirect;
+             (*bed->elf_backend_copy_indirect_symbol) (info, vh, h);
+             /* Protected symbols will override the dynamic definition
+                with default version.  */
+             if (ELF_ST_VISIBILITY (sym->st_other) == STV_PROTECTED)
+               {
+                 h->root.u.i.link = (struct bfd_link_hash_entry *) vh;
+                 vh->dynamic_def = 1;
+                 vh->ref_dynamic = 1;
+               }
+             else
+               {
+                 h->root.type = vh->root.type;
+                 vh->ref_dynamic = 0;
+                 /* We have to hide it here since it was made dynamic
+                    global with extra bits when the symbol info was
+                    copied from the old dynamic definition.  */
+                 (*bed->elf_backend_hide_symbol) (info, vh, TRUE);
+               }
+             h = vh;
+           }
+         else
+           h = *sym_hash;
+       }
 
       if ((h->root.u.undef.next || info->hash->undefs_tail == &h->root)
          && bfd_is_und_section (sec))
@@ -1318,7 +1390,7 @@ _bfd_elf_merge_symbol (bfd *abfd,
       flip->root.type = h->root.type;
       h->root.type = bfd_link_hash_indirect;
       h->root.u.i.link = (struct bfd_link_hash_entry *) flip;
-      (*bed->elf_backend_copy_indirect_symbol) (bed, flip, h);
+      (*bed->elf_backend_copy_indirect_symbol) (info, flip, h);
       flip->root.u.undef.abfd = h->root.u.undef.abfd;
       if (h->def_dynamic)
        {
@@ -1472,7 +1544,7 @@ _bfd_elf_add_default_symbol (bfd *abfd,
       struct elf_link_hash_entry *ht;
 
       ht = (struct elf_link_hash_entry *) hi->root.u.i.link;
-      (*bed->elf_backend_copy_indirect_symbol) (bed, ht, hi);
+      (*bed->elf_backend_copy_indirect_symbol) (info, ht, hi);
 
       /* See if the new flags lead us to realize that the symbol must
         be dynamic.  */
@@ -1541,7 +1613,7 @@ nondefault:
 
       if (hi->root.type == bfd_link_hash_indirect)
        {
-         (*bed->elf_backend_copy_indirect_symbol) (bed, h, hi);
+         (*bed->elf_backend_copy_indirect_symbol) (info, h, hi);
 
          /* See if the new flags lead us to realize that the symbol
             must be dynamic.  */
@@ -1573,6 +1645,10 @@ _bfd_elf_export_symbol (struct elf_link_hash_entry *h, void *data)
 {
   struct elf_info_failed *eif = data;
 
+  /* Ignore this if we won't export it.  */
+  if (!eif->info->export_dynamic && !h->dynamic)
+    return TRUE;
+
   /* Ignore indirect symbols.  These are added by the versioning code.  */
   if (h->root.type == bfd_link_hash_indirect)
     return TRUE;
@@ -2212,6 +2288,20 @@ _bfd_elf_link_output_relocs (bfd *output_bfd,
   return TRUE;
 }
 \f
+/* Make weak undefined symbols in PIE dynamic.  */
+
+bfd_boolean
+_bfd_elf_link_hash_fixup_symbol (struct bfd_link_info *info,
+                                struct elf_link_hash_entry *h)
+{
+  if (info->pie
+      && h->dynindx == -1
+      && h->root.type == bfd_link_hash_undefweak)
+    return bfd_elf_link_record_dynamic_symbol (info, h);
+
+  return TRUE;
+}
+
 /* Fix up the flags for a symbol.  This handles various cases which
    can only be fixed after all the input files are seen.  This is
    currently called by both adjust_dynamic_symbol and
@@ -2222,6 +2312,8 @@ bfd_boolean
 _bfd_elf_fix_symbol_flags (struct elf_link_hash_entry *h,
                           struct elf_info_failed *eif)
 {
+  const struct elf_backend_data *bed = NULL;
+
   /* If this symbol was mentioned in a non-ELF file, try to set
      DEF_REGULAR and REF_REGULAR correctly.  This is the only way to
      permit a non-ELF file to correctly refer to a symbol defined in
@@ -2280,6 +2372,15 @@ _bfd_elf_fix_symbol_flags (struct elf_link_hash_entry *h,
        h->def_regular = 1;
     }
 
+  /* Backend specific symbol fixup.  */
+  if (elf_hash_table (eif->info)->dynobj)
+    {
+      bed = get_elf_backend_data (elf_hash_table (eif->info)->dynobj);
+      if (bed->elf_backend_fixup_symbol
+         && !(*bed->elf_backend_fixup_symbol) (eif->info, h))
+       return FALSE;
+    }
+
   /* If this is a final link, and the symbol was defined as a common
      symbol in a regular object file, and there was no definition in
      any dynamic object, then the linker will have allocated space for
@@ -2301,15 +2402,12 @@ _bfd_elf_fix_symbol_flags (struct elf_link_hash_entry *h,
   if (h->needs_plt
       && eif->info->shared
       && is_elf_hash_table (eif->info->hash)
-      && (eif->info->symbolic
+      && (SYMBOLIC_BIND (eif->info, h)
          || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
       && h->def_regular)
     {
-      const struct elf_backend_data *bed;
       bfd_boolean force_local;
 
-      bed = get_elf_backend_data (elf_hash_table (eif->info)->dynobj);
-
       force_local = (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
                     || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN);
       (*bed->elf_backend_hide_symbol) (eif->info, h, force_local);
@@ -2348,12 +2446,8 @@ _bfd_elf_fix_symbol_flags (struct elf_link_hash_entry *h,
       if (weakdef->def_regular)
        h->u.weakdef = NULL;
       else
-       {
-         const struct elf_backend_data *bed;
-
-         bed = get_elf_backend_data (elf_hash_table (eif->info)->dynobj);
-         (*bed->elf_backend_copy_indirect_symbol) (bed, weakdef, h);
-       }
+       (*bed->elf_backend_copy_indirect_symbol) (eif->info, weakdef,
+                                                 h);
     }
 
   return TRUE;
@@ -2537,7 +2631,7 @@ _bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry *h,
 
   /* Identify the cases where name binding rules say that a
      visible symbol resolves locally.  */
-  binding_stays_local_p = info->executable || info->symbolic;
+  binding_stays_local_p = info->executable || SYMBOLIC_BIND (info, h);
 
   switch (ELF_ST_VISIBILITY (h->other))
     {
@@ -2600,7 +2694,7 @@ _bfd_elf_symbol_refs_local_p (struct elf_link_hash_entry *h,
   /* At this point, we know the symbol is defined and dynamic.  In an
      executable it must resolve locally, likewise when building symbolic
      shared libraries.  */
-  if (info->executable || info->symbolic)
+  if (info->executable || SYMBOLIC_BIND (info, h))
     return TRUE;
 
   /* Now deal with defined dynamic symbols in shared libraries.  Ones
@@ -2791,10 +2885,6 @@ _bfd_elf_add_dynamic_entry (struct bfd_link_info *info,
   if (! is_elf_hash_table (hash_table))
     return FALSE;
 
-  if (info->warn_shared_textrel && info->shared && tag == DT_TEXTREL)
-    _bfd_error_handler
-      (_("warning: creating a DT_TEXTREL in a shared object."));
-
   bed = get_elf_backend_data (hash_table->dynobj);
   s = bfd_get_section_by_name (hash_table->dynobj, ".dynamic");
   BFD_ASSERT (s != NULL);
@@ -2877,98 +2967,6 @@ elf_add_dt_needed_tag (bfd *abfd,
   return 0;
 }
 
-/* Called via elf_link_hash_traverse, elf_smash_syms sets all symbols
-   belonging to NOT_NEEDED to bfd_link_hash_new.  We know there are no
-   references from regular objects to these symbols.
-
-   ??? Should we do something about references from other dynamic
-   obects?  If not, we potentially lose some warnings about undefined
-   symbols.  But how can we recover the initial undefined / undefweak
-   state?  */
-
-struct elf_smash_syms_data
-{
-  bfd *not_needed;
-  struct elf_link_hash_table *htab;
-  bfd_boolean twiddled;
-};
-
-static bfd_boolean
-elf_smash_syms (struct elf_link_hash_entry *h, void *data)
-{
-  struct elf_smash_syms_data *inf = (struct elf_smash_syms_data *) data;
-  struct bfd_link_hash_entry *bh;
-
-  switch (h->root.type)
-    {
-    default:
-    case bfd_link_hash_new:
-      return TRUE;
-
-    case bfd_link_hash_undefined:
-      if (h->root.u.undef.abfd != inf->not_needed)
-       return TRUE;
-      if (h->root.u.undef.weak != NULL
-         && h->root.u.undef.weak != inf->not_needed)
-       {
-         /* Symbol was undefweak in u.undef.weak bfd, and has become
-            undefined in as-needed lib.  Restore weak.  */
-         h->root.type = bfd_link_hash_undefweak;
-         h->root.u.undef.abfd = h->root.u.undef.weak;
-         if (h->root.u.undef.next != NULL
-             || inf->htab->root.undefs_tail == &h->root)
-           inf->twiddled = TRUE;
-         return TRUE;
-       }
-      break;
-
-    case bfd_link_hash_undefweak:
-      if (h->root.u.undef.abfd != inf->not_needed)
-       return TRUE;
-      break;
-
-    case bfd_link_hash_defined:
-    case bfd_link_hash_defweak:
-      if (h->root.u.def.section->owner != inf->not_needed)
-       return TRUE;
-      break;
-
-    case bfd_link_hash_common:
-      if (h->root.u.c.p->section->owner != inf->not_needed)
-       return TRUE;
-      break;
-
-    case bfd_link_hash_warning:
-    case bfd_link_hash_indirect:
-      elf_smash_syms ((struct elf_link_hash_entry *) h->root.u.i.link, data);
-      if (h->root.u.i.link->type != bfd_link_hash_new)
-       return TRUE;
-      if (h->root.u.i.link->u.undef.abfd != inf->not_needed)
-       return TRUE;
-      break;
-    }
-
-  /* There is no way we can undo symbol table state from defined or
-     defweak back to undefined.  */
-  if (h->ref_regular)
-    abort ();
-
-  /* Set sym back to newly created state, but keep undef.next if it is
-     being used as a list pointer.  */
-  bh = h->root.u.undef.next;
-  if (bh == &h->root)
-    bh = NULL;
-  if (bh != NULL || inf->htab->root.undefs_tail == &h->root)
-    inf->twiddled = TRUE;
-  (*inf->htab->root.table.newfunc) (&h->root.root,
-                                   &inf->htab->root.table,
-                                   h->root.root.string);
-  h->root.u.undef.next = bh;
-  h->root.u.undef.abfd = inf->not_needed;
-  h->non_elf = 0;
-  return TRUE;
-}
-
 /* Sort symbol by value and section.  */
 static int
 elf_sort_symbol (const void *arg1, const void *arg2)
@@ -3138,14 +3136,6 @@ elf_finalize_dynstr (bfd *output_bfd, struct bfd_link_info *info)
 static bfd_boolean
 elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
 {
-  bfd_boolean (*add_symbol_hook)
-    (bfd *, struct bfd_link_info *, Elf_Internal_Sym *,
-     const char **, flagword *, asection **, bfd_vma *);
-  bfd_boolean (*check_relocs)
-    (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
-  bfd_boolean (*check_directives)
-    (bfd *, struct bfd_link_info *);
-  bfd_boolean collect;
   Elf_Internal_Shdr *hdr;
   bfd_size_type symcount;
   bfd_size_type extsymcount;
@@ -3162,14 +3152,23 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
   Elf_Internal_Sym *isymend;
   const struct elf_backend_data *bed;
   bfd_boolean add_needed;
-  struct elf_link_hash_table * hash_table;
+  struct elf_link_hash_table *htab;
   bfd_size_type amt;
+  void *alloc_mark = NULL;
+  struct bfd_hash_entry **old_table = NULL;
+  unsigned int old_size = 0;
+  unsigned int old_count = 0;
+  void *old_tab = NULL;
+  void *old_hash;
+  void *old_ent;
+  struct bfd_link_hash_entry *old_undefs = NULL;
+  struct bfd_link_hash_entry *old_undefs_tail = NULL;
+  long old_dynsymcount = 0;
+  size_t tabsize = 0;
+  size_t hashsize = 0;
 
-  hash_table = elf_hash_table (info);
-
+  htab = elf_hash_table (info);
   bed = get_elf_backend_data (abfd);
-  add_symbol_hook = bed->elf_add_symbol_hook;
-  collect = bed->collect;
 
   if ((abfd->flags & DYNAMIC) == 0)
     dynamic = FALSE;
@@ -3181,8 +3180,8 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
         hope of using a dynamic object which does not exactly match
         the format of the output file.  */
       if (info->relocatable
-         || !is_elf_hash_table (hash_table)
-         || hash_table->root.creator != abfd->xvec)
+         || !is_elf_hash_table (htab)
+         || htab->root.creator != abfd->xvec)
        {
          if (info->relocatable)
            bfd_set_error (bfd_error_invalid_operation);
@@ -3205,7 +3204,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
          const char *name;
 
          name = bfd_get_section_name (abfd, s);
-         if (strncmp (name, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0)
+         if (CONST_STRNEQ (name, ".gnu.warning."))
            {
              char *msg;
              bfd_size_type sz;
@@ -3225,8 +3224,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
                {
                  struct elf_link_hash_entry *h;
 
-                 h = elf_link_hash_lookup (hash_table, name,
-                                           FALSE, FALSE, TRUE);
+                 h = elf_link_hash_lookup (htab, name, FALSE, FALSE, TRUE);
 
                  /* FIXME: What about bfd_link_hash_common?  */
                  if (h != NULL
@@ -3253,7 +3251,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
 
              if (! (_bfd_generic_link_add_one_symbol
                     (info, abfd, name, BSF_WARNING, s, 0, msg,
-                     FALSE, collect, NULL)))
+                     FALSE, bed->collect, NULL)))
                goto error_return;
 
              if (! info->relocatable)
@@ -3279,15 +3277,15 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
         format.  FIXME: If there are no input BFD's of the same
         format as the output, we can't make a shared library.  */
       if (info->shared
-         && is_elf_hash_table (hash_table)
-         && hash_table->root.creator == abfd->xvec
-         && ! hash_table->dynamic_sections_created)
+         && is_elf_hash_table (htab)
+         && htab->root.creator == abfd->xvec
+         && !htab->dynamic_sections_created)
        {
          if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
            goto error_return;
        }
     }
-  else if (!is_elf_hash_table (hash_table))
+  else if (!is_elf_hash_table (htab))
     goto error_return;
   else
     {
@@ -3297,11 +3295,10 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
       int ret;
 
       /* ld --just-symbols and dynamic objects don't mix very well.
-        Test for --just-symbols by looking at info set up by
-        _bfd_elf_link_just_syms.  */
+        ld shouldn't allow it.  */
       if ((s = abfd->sections) != NULL
          && s->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
-       goto error_return;
+       abort ();
 
       /* If this dynamic lib was specified on the command line with
         --as-needed in effect, then we don't want to add a DT_NEEDED
@@ -3363,9 +3360,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
                  n->name = anm;
                  n->by = abfd;
                  n->next = NULL;
-                 for (pn = & hash_table->needed;
-                      *pn != NULL;
-                      pn = &(*pn)->next)
+                 for (pn = &htab->needed; *pn != NULL; pn = &(*pn)->next)
                    ;
                  *pn = n;
                }
@@ -3437,9 +3432,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
       if (rpath)
        {
          struct bfd_link_needed_list **pn;
-         for (pn = & hash_table->runpath;
-              *pn != NULL;
-              pn = &(*pn)->next)
+         for (pn = &htab->runpath; *pn != NULL; pn = &(*pn)->next)
            ;
          *pn = rpath;
        }
@@ -3547,8 +3540,80 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
        }
     }
 
-  weaks = NULL;
+  /* If we are loading an as-needed shared lib, save the symbol table
+     state before we start adding symbols.  If the lib turns out
+     to be unneeded, restore the state.  */
+  if ((elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0)
+    {
+      unsigned int i;
+      size_t entsize;
+
+      for (entsize = 0, i = 0; i < htab->root.table.size; i++)
+       {
+         struct bfd_hash_entry *p;
+         struct elf_link_hash_entry *h;
 
+         for (p = htab->root.table.table[i]; p != NULL; p = p->next)
+           {
+             h = (struct elf_link_hash_entry *) p;
+             entsize += htab->root.table.entsize;
+             if (h->root.type == bfd_link_hash_warning)
+               entsize += htab->root.table.entsize;
+           }
+       }
+
+      tabsize = htab->root.table.size * sizeof (struct bfd_hash_entry *);
+      hashsize = extsymcount * sizeof (struct elf_link_hash_entry *);
+      old_tab = bfd_malloc (tabsize + entsize + hashsize);
+      if (old_tab == NULL)
+       goto error_free_vers;
+
+      /* Remember the current objalloc pointer, so that all mem for
+        symbols added can later be reclaimed.  */
+      alloc_mark = bfd_hash_allocate (&htab->root.table, 1);
+      if (alloc_mark == NULL)
+       goto error_free_vers;
+
+      /* Make a special call to the linker "notice" function to
+        tell it that we are about to handle an as-needed lib.  */
+      if (!(*info->callbacks->notice) (info, NULL, abfd, NULL,
+                                      notice_as_needed))
+       return FALSE;
+
+
+      /* Clone the symbol table and sym hashes.  Remember some
+        pointers into the symbol table, and dynamic symbol count.  */
+      old_hash = (char *) old_tab + tabsize;
+      old_ent = (char *) old_hash + hashsize;
+      memcpy (old_tab, htab->root.table.table, tabsize);
+      memcpy (old_hash, sym_hash, hashsize);
+      old_undefs = htab->root.undefs;
+      old_undefs_tail = htab->root.undefs_tail;
+      old_table = htab->root.table.table;
+      old_size = htab->root.table.size;
+      old_count = htab->root.table.count;
+      old_dynsymcount = htab->dynsymcount;
+
+      for (i = 0; i < htab->root.table.size; i++)
+       {
+         struct bfd_hash_entry *p;
+         struct elf_link_hash_entry *h;
+
+         for (p = htab->root.table.table[i]; p != NULL; p = p->next)
+           {
+             memcpy (old_ent, p, htab->root.table.entsize);
+             old_ent = (char *) old_ent + htab->root.table.entsize;
+             h = (struct elf_link_hash_entry *) p;
+             if (h->root.type == bfd_link_hash_warning)
+               {
+                 memcpy (old_ent, h->root.u.i.link, htab->root.table.entsize);
+                 old_ent = (char *) old_ent + htab->root.table.entsize;
+               }
+           }
+       }
+    }
+
+  weaks = NULL;
   ever = extversym != NULL ? extversym + extsymoff : NULL;
   for (isym = isymbuf, isymend = isymbuf + extsymcount;
        isym < isymend;
@@ -3600,7 +3665,8 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
 
       if (isym->st_shndx == SHN_UNDEF)
        sec = bfd_und_section_ptr;
-      else if (isym->st_shndx < SHN_LORESERVE || isym->st_shndx > SHN_HIRESERVE)
+      else if (isym->st_shndx < SHN_LORESERVE
+              || isym->st_shndx > SHN_HIRESERVE)
        {
          sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
          if (sec == NULL)
@@ -3611,8 +3677,8 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
                 default visibility.  */
              sec = bfd_und_section_ptr;
              isym->st_shndx = SHN_UNDEF;
-             isym->st_other = STV_DEFAULT
-                              | (isym->st_other & ~ ELF_ST_VISIBILITY(-1));
+             isym->st_other = (STV_DEFAULT
+                               | (isym->st_other & ~ ELF_ST_VISIBILITY (-1)));
            }
          else if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
            value -= sec->vma;
@@ -3637,7 +3703,8 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
        goto error_free_vers;
 
       if (isym->st_shndx == SHN_COMMON
-         && ELF_ST_TYPE (isym->st_info) == STT_TLS)
+         && ELF_ST_TYPE (isym->st_info) == STT_TLS
+         && !info->relocatable)
        {
          asection *tcomm = bfd_get_section_by_name (abfd, ".tcommon");
 
@@ -3653,10 +3720,10 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
            }
          sec = tcomm;
        }
-      else if (add_symbol_hook)
+      else if (bed->elf_add_symbol_hook)
        {
-         if (! (*add_symbol_hook) (abfd, info, isym, &name, &flags, &sec,
-                                   &value))
+         if (! (*bed->elf_add_symbol_hook) (abfd, info, isym, &name, &flags,
+                                            &sec, &value))
            goto error_free_vers;
 
          /* The hook function sets the name to NULL if this symbol
@@ -3679,12 +3746,12 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
        definition = TRUE;
 
       size_change_ok = FALSE;
-      type_change_ok = get_elf_backend_data (abfd)->type_change_ok;
+      type_change_ok = bed->type_change_ok;
       old_alignment = 0;
       old_bfd = NULL;
       new_sec = sec;
 
-      if (is_elf_hash_table (hash_table))
+      if (is_elf_hash_table (htab))
        {
          Elf_Internal_Versym iver;
          unsigned int vernum = 0;
@@ -3779,7 +3846,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
                  && isym->st_shndx != SHN_UNDEF)
                ++newlen;
 
-             newname = bfd_alloc (abfd, newlen);
+             newname = bfd_hash_allocate (&htab->root.table, newlen);
              if (newname == NULL)
                goto error_free_vers;
              memcpy (newname, name, namelen);
@@ -3843,7 +3910,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
        }
 
       if (! (_bfd_generic_link_add_one_symbol
-            (info, abfd, name, flags, sec, value, NULL, FALSE, collect,
+            (info, abfd, name, flags, sec, value, NULL, FALSE, bed->collect,
              (struct bfd_link_hash_entry **) sym_hash)))
        goto error_free_vers;
 
@@ -3858,7 +3925,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
          && definition
          && (flags & BSF_WEAK) != 0
          && ELF_ST_TYPE (isym->st_info) != STT_FUNC
-         && is_elf_hash_table (hash_table)
+         && is_elf_hash_table (htab)
          && h->u.weakdef == NULL)
        {
          /* Keep a list of all weak defined non function symbols from
@@ -3901,7 +3968,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
            h->root.u.c.p->alignment_power = old_alignment;
        }
 
-      if (is_elf_hash_table (hash_table))
+      if (is_elf_hash_table (htab))
        {
          bfd_boolean dynsym;
 
@@ -3944,11 +4011,21 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
                }
 
              if (normal_align < common_align)
-               (*_bfd_error_handler)
-                 (_("Warning: alignment %u of symbol `%s' in %B"
-                    " is smaller than %u in %B"),
-                  normal_bfd, common_bfd,
-                  1 << normal_align, name, 1 << common_align);
+               {
+                 /* PR binutils/2735 */
+                 if (normal_bfd == NULL)
+                   (*_bfd_error_handler)
+                     (_("Warning: alignment %u of common symbol `%s' in %B"
+                        " is greater than the alignment (%u) of its section %A"),
+                      common_bfd, h->root.u.def.section,
+                      1 << common_align, name, 1 << normal_align);
+                 else
+                   (*_bfd_error_handler)
+                     (_("Warning: alignment %u of symbol `%s' in %B"
+                        " is smaller than %u in %B"),
+                      normal_bfd, common_bfd,
+                      1 << normal_align, name, 1 << common_align);
+               }
            }
 
          /* Remember the symbol size and type.  */
@@ -4001,15 +4078,16 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
              && (abfd->no_export
                  || (abfd->my_archive && abfd->my_archive->no_export))
              && ELF_ST_VISIBILITY (isym->st_other) != STV_INTERNAL)
-           isym->st_other = STV_HIDDEN | (isym->st_other & ~ ELF_ST_VISIBILITY (-1));
+           isym->st_other = (STV_HIDDEN
+                             | (isym->st_other & ~ELF_ST_VISIBILITY (-1)));
 
-         if (isym->st_other != 0 && !dynamic)
+         if (ELF_ST_VISIBILITY (isym->st_other) != 0 && !dynamic)
            {
              unsigned char hvis, symvis, other, nvis;
 
-             /* Take the balance of OTHER from the definition.  */
-             other = (definition ? isym->st_other : h->other);
-             other &= ~ ELF_ST_VISIBILITY (-1);
+             /* Only merge the visibility. Leave the remainder of the
+                st_other field to elf_backend_merge_symbol_attribute.  */
+             other = h->other & ~ELF_ST_VISIBILITY (-1);
 
              /* Combine visibilities, using the most constraining one.  */
              hvis   = ELF_ST_VISIBILITY (h->other);
@@ -4074,13 +4152,13 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
                {
                  /* Queue non-default versions so that .symver x, x@FOO
                     aliases can be checked.  */
-                 if (! nondeflt_vers)
+                 if (!nondeflt_vers)
                    {
-                     amt = (isymend - isym + 1)
-                           * sizeof (struct elf_link_hash_entry *);
+                     amt = ((isymend - isym + 1)
+                            * sizeof (struct elf_link_hash_entry *));
                      nondeflt_vers = bfd_malloc (amt);
                    }
-                 nondeflt_vers [nondeflt_vers_cnt++] = h;
+                 nondeflt_vers[nondeflt_vers_cnt++] = h;
                }
            }
 
@@ -4092,7 +4170,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
                  && ! new_weakdef
                  && h->u.weakdef->dynindx == -1)
                {
-                 if (! bfd_elf_link_record_dynamic_symbol (info, h->u.weakdef))
+                 if (!bfd_elf_link_record_dynamic_symbol (info, h->u.weakdef))
                    goto error_free_vers;
                }
            }
@@ -4142,6 +4220,80 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
        }
     }
 
+  if (extversym != NULL)
+    {
+      free (extversym);
+      extversym = NULL;
+    }
+
+  if (isymbuf != NULL)
+    {
+      free (isymbuf);
+      isymbuf = NULL;
+    }
+
+  if ((elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0)
+    {
+      unsigned int i;
+
+      /* Restore the symbol table.  */
+      old_hash = (char *) old_tab + tabsize;
+      old_ent = (char *) old_hash + hashsize;
+      sym_hash = elf_sym_hashes (abfd);
+      htab->root.table.table = old_table;
+      htab->root.table.size = old_size;
+      htab->root.table.count = old_count;
+      memcpy (htab->root.table.table, old_tab, tabsize);
+      memcpy (sym_hash, old_hash, hashsize);
+      htab->root.undefs = old_undefs;
+      htab->root.undefs_tail = old_undefs_tail;
+      for (i = 0; i < htab->root.table.size; i++)
+       {
+         struct bfd_hash_entry *p;
+         struct elf_link_hash_entry *h;
+
+         for (p = htab->root.table.table[i]; p != NULL; p = p->next)
+           {
+             h = (struct elf_link_hash_entry *) p;
+             if (h->root.type == bfd_link_hash_warning)
+               h = (struct elf_link_hash_entry *) h->root.u.i.link;
+             if (h->dynindx >= old_dynsymcount)
+               _bfd_elf_strtab_delref (htab->dynstr, h->dynstr_index);
+
+             memcpy (p, old_ent, htab->root.table.entsize);
+             old_ent = (char *) old_ent + htab->root.table.entsize;
+             h = (struct elf_link_hash_entry *) p;
+             if (h->root.type == bfd_link_hash_warning)
+               {
+                 memcpy (h->root.u.i.link, old_ent, htab->root.table.entsize);
+                 old_ent = (char *) old_ent + htab->root.table.entsize;
+               }
+           }
+       }
+
+      /* Make a special call to the linker "notice" function to
+        tell it that symbols added for crefs may need to be removed.  */
+      if (!(*info->callbacks->notice) (info, NULL, abfd, NULL,
+                                      notice_not_needed))
+       return FALSE;
+
+      free (old_tab);
+      objalloc_free_block ((struct objalloc *) htab->root.table.memory,
+                          alloc_mark);
+      if (nondeflt_vers != NULL)
+       free (nondeflt_vers);
+      return TRUE;
+    }
+
+  if (old_tab != NULL)
+    {
+      if (!(*info->callbacks->notice) (info, NULL, abfd, NULL,
+                                      notice_needed))
+       return FALSE;
+      free (old_tab);
+      old_tab = NULL;
+    }
+
   /* Now that all the symbols from this input file are created, handle
      .symver foo, foo@BAR such that any relocs against foo become foo@BAR.  */
   if (nondeflt_vers != NULL)
@@ -4165,7 +4317,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
          shortname[amt] = '\0';
 
          hi = (struct elf_link_hash_entry *)
-              bfd_link_hash_lookup (&hash_table->root, shortname,
+              bfd_link_hash_lookup (&htab->root, shortname,
                                     FALSE, FALSE, FALSE);
          if (hi != NULL
              && hi->root.type == h->root.type
@@ -4175,7 +4327,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
              (*bed->elf_backend_hide_symbol) (info, hi, TRUE);
              hi->root.type = bfd_link_hash_indirect;
              hi->root.u.i.link = (struct bfd_link_hash_entry *) h;
-             (*bed->elf_backend_copy_indirect_symbol) (bed, h, hi);
+             (*bed->elf_backend_copy_indirect_symbol) (info, h, hi);
              sym_hash = elf_sym_hashes (abfd);
              if (sym_hash)
                for (symidx = 0; symidx < extsymcount; ++symidx)
@@ -4191,31 +4343,6 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
       nondeflt_vers = NULL;
     }
 
-  if (extversym != NULL)
-    {
-      free (extversym);
-      extversym = NULL;
-    }
-
-  if (isymbuf != NULL)
-    free (isymbuf);
-  isymbuf = NULL;
-
-  if (!add_needed
-      && (elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0)
-    {
-      /* Remove symbols defined in an as-needed shared lib that wasn't
-        needed.  */
-      struct elf_smash_syms_data inf;
-      inf.not_needed = abfd;
-      inf.htab = hash_table;
-      inf.twiddled = FALSE;
-      elf_link_hash_traverse (hash_table, elf_smash_syms, &inf);
-      if (inf.twiddled)
-       bfd_link_repair_undef_list (&hash_table->root);
-      weaks = NULL;
-    }
-
   /* Now set the weakdefs field correctly for all the weak defined
      symbols we found.  The only way to do this is to search all the
      symbols.  Since we only need the information for non functions in
@@ -4355,9 +4482,8 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
       free (sorted_sym_hash);
     }
 
-  check_directives = get_elf_backend_data (abfd)->check_directives;
-  if (check_directives)
-    check_directives (abfd, info);
+  if (bed->check_directives)
+    (*bed->check_directives) (abfd, info);
 
   /* If this object is the same format as the output object, and it is
      not a shared library, then let the backend look through the
@@ -4376,11 +4502,10 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
 
      I have no idea how to handle linking PIC code into a file of a
      different format.  It probably can't be done.  */
-  check_relocs = get_elf_backend_data (abfd)->check_relocs;
   if (! dynamic
-      && is_elf_hash_table (hash_table)
-      && hash_table->root.creator == abfd->xvec
-      && check_relocs != NULL)
+      && is_elf_hash_table (htab)
+      && htab->root.creator == abfd->xvec
+      && bed->check_relocs != NULL)
     {
       asection *o;
 
@@ -4401,7 +4526,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
          if (internal_relocs == NULL)
            goto error_return;
 
-         ok = (*check_relocs) (abfd, info, o, internal_relocs);
+         ok = (*bed->check_relocs) (abfd, info, o, internal_relocs);
 
          if (elf_section_data (o)->relocs != internal_relocs)
            free (internal_relocs);
@@ -4415,7 +4540,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
      of the .stab/.stabstr sections.  */
   if (! dynamic
       && ! info->traditional_format
-      && is_elf_hash_table (hash_table)
+      && is_elf_hash_table (htab)
       && (info->strip != strip_all && info->strip != strip_debugger))
     {
       asection *stabstr;
@@ -4427,7 +4552,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
          asection *stab;
 
          for (stab = abfd->sections; stab; stab = stab->next)
-           if (strncmp (".stab", stab->name, 5) == 0
+           if (CONST_STRNEQ (stab->name, ".stab")
                && (!stab->name[5] ||
                    (stab->name[5] == '.' && ISDIGIT (stab->name[6])))
                && (stab->flags & SEC_MERGE) == 0
@@ -4436,10 +4561,8 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
                struct bfd_elf_section_data *secdata;
 
                secdata = elf_section_data (stab);
-               if (! _bfd_link_section_stabs (abfd,
-                                              &hash_table->stab_info,
-                                              stab, stabstr,
-                                              &secdata->sec_info,
+               if (! _bfd_link_section_stabs (abfd, &htab->stab_info, stab,
+                                              stabstr, &secdata->sec_info,
                                               &string_offset))
                  goto error_return;
                if (secdata->sec_info)
@@ -4448,7 +4571,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
        }
     }
 
-  if (is_elf_hash_table (hash_table) && add_needed)
+  if (is_elf_hash_table (htab) && add_needed)
     {
       /* Add this bfd to the loaded list.  */
       struct elf_link_loaded_list *n;
@@ -4457,13 +4580,15 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
       if (n == NULL)
        goto error_return;
       n->abfd = abfd;
-      n->next = hash_table->loaded;
-      hash_table->loaded = n;
+      n->next = htab->loaded;
+      htab->loaded = n;
     }
 
   return TRUE;
 
  error_free_vers:
+  if (old_tab != NULL)
+    free (old_tab);
   if (nondeflt_vers != NULL)
     free (nondeflt_vers);
   if (extversym != NULL)
@@ -4736,9 +4861,74 @@ bfd_elf_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
    all hash value of the exported symbols in an array.  */
 
 static bfd_boolean
-elf_collect_hash_codes (struct elf_link_hash_entry *h, void *data)
+elf_collect_hash_codes (struct elf_link_hash_entry *h, void *data)
+{
+  unsigned long **valuep = data;
+  const char *name;
+  char *p;
+  unsigned long ha;
+  char *alc = NULL;
+
+  if (h->root.type == bfd_link_hash_warning)
+    h = (struct elf_link_hash_entry *) h->root.u.i.link;
+
+  /* Ignore indirect symbols.  These are added by the versioning code.  */
+  if (h->dynindx == -1)
+    return TRUE;
+
+  name = h->root.root.string;
+  p = strchr (name, ELF_VER_CHR);
+  if (p != NULL)
+    {
+      alc = bfd_malloc (p - name + 1);
+      memcpy (alc, name, p - name);
+      alc[p - name] = '\0';
+      name = alc;
+    }
+
+  /* Compute the hash value.  */
+  ha = bfd_elf_hash (name);
+
+  /* Store the found hash value in the array given as the argument.  */
+  *(*valuep)++ = ha;
+
+  /* And store it in the struct so that we can put it in the hash table
+     later.  */
+  h->u.elf_hash_value = ha;
+
+  if (alc != NULL)
+    free (alc);
+
+  return TRUE;
+}
+
+struct collect_gnu_hash_codes
+{
+  bfd *output_bfd;
+  const struct elf_backend_data *bed;
+  unsigned long int nsyms;
+  unsigned long int maskbits;
+  unsigned long int *hashcodes;
+  unsigned long int *hashval;
+  unsigned long int *indx;
+  unsigned long int *counts;
+  bfd_vma *bitmask;
+  bfd_byte *contents;
+  long int min_dynindx;
+  unsigned long int bucketcount;
+  unsigned long int symindx;
+  long int local_indx;
+  long int shift1, shift2;
+  unsigned long int mask;
+};
+
+/* This function will be called though elf_link_hash_traverse to store
+   all hash value of the exported symbols in an array.  */
+
+static bfd_boolean
+elf_collect_gnu_hash_codes (struct elf_link_hash_entry *h, void *data)
 {
-  unsigned long **valuep = data;
+  struct collect_gnu_hash_codes *s = data;
   const char *name;
   char *p;
   unsigned long ha;
@@ -4751,6 +4941,10 @@ elf_collect_hash_codes (struct elf_link_hash_entry *h, void *data)
   if (h->dynindx == -1)
     return TRUE;
 
+  /* Ignore also local symbols and undefined symbols.  */
+  if (! (*s->bed->elf_hash_symbol) (h))
+    return TRUE;
+
   name = h->root.root.string;
   p = strchr (name, ELF_VER_CHR);
   if (p != NULL)
@@ -4762,14 +4956,15 @@ elf_collect_hash_codes (struct elf_link_hash_entry *h, void *data)
     }
 
   /* Compute the hash value.  */
-  ha = bfd_elf_hash (name);
-
-  /* Store the found hash value in the array given as the argument.  */
-  *(*valuep)++ = ha;
+  ha = bfd_elf_gnu_hash (name);
 
-  /* And store it in the struct so that we can put it in the hash table
-     later.  */
-  h->u.elf_hash_value = ha;
+  /* Store the found hash value in the array for compute_bucket_count,
+     and also for .dynsym reordering purposes.  */
+  s->hashcodes[s->nsyms] = ha;
+  s->hashval[h->dynindx] = ha;
+  ++s->nsyms;
+  if (s->min_dynindx < 0 || s->min_dynindx > h->dynindx)
+    s->min_dynindx = h->dynindx;
 
   if (alc != NULL)
     free (alc);
@@ -4777,6 +4972,61 @@ elf_collect_hash_codes (struct elf_link_hash_entry *h, void *data)
   return TRUE;
 }
 
+/* This function will be called though elf_link_hash_traverse to do
+   final dynaminc symbol renumbering.  */
+
+static bfd_boolean
+elf_renumber_gnu_hash_syms (struct elf_link_hash_entry *h, void *data)
+{
+  struct collect_gnu_hash_codes *s = data;
+  unsigned long int bucket;
+  unsigned long int val;
+
+  if (h->root.type == bfd_link_hash_warning)
+    h = (struct elf_link_hash_entry *) h->root.u.i.link;
+
+  /* Ignore indirect symbols.  */
+  if (h->dynindx == -1)
+    return TRUE;
+
+  /* Ignore also local symbols and undefined symbols.  */
+  if (! (*s->bed->elf_hash_symbol) (h))
+    {
+      if (h->dynindx >= s->min_dynindx)
+       h->dynindx = s->local_indx++;
+      return TRUE;
+    }
+
+  bucket = s->hashval[h->dynindx] % s->bucketcount;
+  val = (s->hashval[h->dynindx] >> s->shift1)
+       & ((s->maskbits >> s->shift1) - 1);
+  s->bitmask[val] |= ((bfd_vma) 1) << (s->hashval[h->dynindx] & s->mask);
+  s->bitmask[val]
+    |= ((bfd_vma) 1) << ((s->hashval[h->dynindx] >> s->shift2) & s->mask);
+  val = s->hashval[h->dynindx] & ~(unsigned long int) 1;
+  if (s->counts[bucket] == 1)
+    /* Last element terminates the chain.  */
+    val |= 1;
+  bfd_put_32 (s->output_bfd, val,
+             s->contents + (s->indx[bucket] - s->symindx) * 4);
+  --s->counts[bucket];
+  h->dynindx = s->indx[bucket]++;
+  return TRUE;
+}
+
+/* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
+
+bfd_boolean
+_bfd_elf_hash_symbol (struct elf_link_hash_entry *h)
+{
+  return !(h->forced_local
+          || h->root.type == bfd_link_hash_undefined
+          || h->root.type == bfd_link_hash_undefweak
+          || ((h->root.type == bfd_link_hash_defined
+               || h->root.type == bfd_link_hash_defweak)
+              && h->root.u.def.section->output_section == NULL));
+}
+
 /* Array used to determine the number of hash table buckets to use
    based on the number of symbols there are.  If there are fewer than
    3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
@@ -4798,42 +5048,26 @@ static const size_t elf_buckets[] =
    Therefore the result is always a good payoff between few collisions
    (= short chain lengths) and table size.  */
 static size_t
-compute_bucket_count (struct bfd_link_info *info)
+compute_bucket_count (struct bfd_link_info *info, unsigned long int *hashcodes,
+                     unsigned long int nsyms, int gnu_hash)
 {
   size_t dynsymcount = elf_hash_table (info)->dynsymcount;
   size_t best_size = 0;
-  unsigned long int *hashcodes;
-  unsigned long int *hashcodesp;
   unsigned long int i;
   bfd_size_type amt;
 
-  /* Compute the hash values for all exported symbols.  At the same
-     time store the values in an array so that we could use them for
-     optimizations.  */
-  amt = dynsymcount;
-  amt *= sizeof (unsigned long int);
-  hashcodes = bfd_malloc (amt);
-  if (hashcodes == NULL)
-    return 0;
-  hashcodesp = hashcodes;
-
-  /* Put all hash values in HASHCODES.  */
-  elf_link_hash_traverse (elf_hash_table (info),
-                         elf_collect_hash_codes, &hashcodesp);
-
   /* We have a problem here.  The following code to optimize the table
      size requires an integer type with more the 32 bits.  If
      BFD_HOST_U_64_BIT is set we know about such a type.  */
 #ifdef BFD_HOST_U_64_BIT
   if (info->optimize)
     {
-      unsigned long int nsyms = hashcodesp - hashcodes;
       size_t minsize;
       size_t maxsize;
       BFD_HOST_U_64_BIT best_chlen = ~((BFD_HOST_U_64_BIT) 0);
-      unsigned long int *counts ;
       bfd *dynobj = elf_hash_table (info)->dynobj;
       const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
+      unsigned long int *counts;
 
       /* Possible optimization parameters: if we have NSYMS symbols we say
         that the hashing table must at least have NSYMS/4 and at most
@@ -4842,6 +5076,13 @@ compute_bucket_count (struct bfd_link_info *info)
       if (minsize == 0)
        minsize = 1;
       best_size = maxsize = nsyms * 2;
+      if (gnu_hash)
+       {
+         if (minsize < 2)
+           minsize = 2;
+         if ((best_size & 31) == 0)
+           ++best_size;
+       }
 
       /* Create array where we count the collisions in.  We must use bfd_malloc
         since the size could be large.  */
@@ -4849,10 +5090,7 @@ compute_bucket_count (struct bfd_link_info *info)
       amt *= sizeof (unsigned long int);
       counts = bfd_malloc (amt);
       if (counts == NULL)
-       {
-         free (hashcodes);
-         return 0;
-       }
+       return 0;
 
       /* Compute the "optimal" size for the hash table.  The criteria is a
         minimal chain length.  The minor criteria is (of course) the size
@@ -4864,6 +5102,9 @@ compute_bucket_count (struct bfd_link_info *info)
          unsigned long int j;
          unsigned long int fact;
 
+         if (gnu_hash && (i & 31) == 0)
+           continue;
+
          memset (counts, '\0', i * sizeof (unsigned long int));
 
          /* Determine how often each hash bucket is used.  */
@@ -4879,9 +5120,9 @@ compute_bucket_count (struct bfd_link_info *info)
 #  define BFD_TARGET_PAGESIZE  (4096)
 # endif
 
-         /* We in any case need 2 + NSYMS entries for the size values and
-            the chains.  */
-         max = (2 + nsyms) * (bed->s->arch_size / 8);
+         /* We in any case need 2 + DYNSYMCOUNT entries for the size values
+            and the chains.  */
+         max = (2 + dynsymcount) * bed->s->sizeof_hash_entry;
 
 # if 1
          /* Variant 1: optimize for short chains.  We add the squares
@@ -4891,7 +5132,7 @@ compute_bucket_count (struct bfd_link_info *info)
            max += counts[j] * counts[j];
 
          /* This adds penalties for the overall size of the table.  */
-         fact = i / (BFD_TARGET_PAGESIZE / (bed->s->arch_size / 8)) + 1;
+         fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1;
          max *= fact * fact;
 # else
          /* Variant 2: Optimize a lot more for small table.  Here we
@@ -4902,7 +5143,7 @@ compute_bucket_count (struct bfd_link_info *info)
 
          /* The overall size of the table is considered, but not as
             strong as in variant 1, where it is squared.  */
-         fact = i / (BFD_TARGET_PAGESIZE / (bed->s->arch_size / 8)) + 1;
+         fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1;
          max *= fact;
 # endif
 
@@ -4925,14 +5166,13 @@ compute_bucket_count (struct bfd_link_info *info)
       for (i = 0; elf_buckets[i] != 0; i++)
        {
          best_size = elf_buckets[i];
-         if (dynsymcount < elf_buckets[i + 1])
+         if (nsyms < elf_buckets[i + 1])
            break;
        }
+      if (gnu_hash && best_size < 2)
+       best_size = 2;
     }
 
-  /* Free the arrays we needed.  */
-  free (hashcodes);
-
   return best_size;
 }
 
@@ -5032,6 +5272,7 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
       asection *dynstr;
       struct bfd_elf_version_tree *t;
       struct bfd_elf_version_expr *d;
+      asection *s;
       bfd_boolean all_defined;
 
       *sinterpptr = bfd_get_section_by_name (dynobj, ".interp");
@@ -5104,7 +5345,8 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
 
       /* If we are supposed to export all symbols into the dynamic symbol
         table (this is not the normal case), then do so.  */
-      if (info->export_dynamic)
+      if (info->export_dynamic
+         || (info->executable && info->dynamic))
        {
          elf_link_hash_traverse (elf_hash_table (info),
                                  _bfd_elf_export_symbol,
@@ -5235,7 +5477,8 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
            return FALSE;
        }
 
-      if (bfd_get_section_by_name (output_bfd, ".preinit_array") != NULL)
+      s = bfd_get_section_by_name (output_bfd, ".preinit_array");
+      if (s != NULL && s->linker_has_input)
        {
          /* DT_PREINIT_ARRAY is not allowed in shared library.  */
          if (! info->executable)
@@ -5263,13 +5506,15 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
              || !_bfd_elf_add_dynamic_entry (info, DT_PREINIT_ARRAYSZ, 0))
            return FALSE;
        }
-      if (bfd_get_section_by_name (output_bfd, ".init_array") != NULL)
+      s = bfd_get_section_by_name (output_bfd, ".init_array");
+      if (s != NULL && s->linker_has_input)
        {
          if (!_bfd_elf_add_dynamic_entry (info, DT_INIT_ARRAY, 0)
              || !_bfd_elf_add_dynamic_entry (info, DT_INIT_ARRAYSZ, 0))
            return FALSE;
        }
-      if (bfd_get_section_by_name (output_bfd, ".fini_array") != NULL)
+      s = bfd_get_section_by_name (output_bfd, ".fini_array");
+      if (s != NULL && s->linker_has_input)
        {
          if (!_bfd_elf_add_dynamic_entry (info, DT_FINI_ARRAY, 0)
              || !_bfd_elf_add_dynamic_entry (info, DT_FINI_ARRAYSZ, 0))
@@ -5286,7 +5531,10 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
          bfd_size_type strsize;
 
          strsize = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
-         if (!_bfd_elf_add_dynamic_entry (info, DT_HASH, 0)
+         if ((info->emit_hash
+              && !_bfd_elf_add_dynamic_entry (info, DT_HASH, 0))
+             || (info->emit_gnu_hash
+                 && !_bfd_elf_add_dynamic_entry (info, DT_GNU_HASH, 0))
              || !_bfd_elf_add_dynamic_entry (info, DT_STRTAB, 0)
              || !_bfd_elf_add_dynamic_entry (info, DT_SYMTAB, 0)
              || !_bfd_elf_add_dynamic_entry (info, DT_STRSZ, strsize)
@@ -5688,8 +5936,6 @@ bfd_elf_size_dynsym_hash_dynstr (bfd *output_bfd, struct bfd_link_info *info)
       asection *s;
       bfd_size_type dynsymcount;
       unsigned long section_sym_count;
-      size_t bucketcount = 0;
-      size_t hash_entry_size;
       unsigned int dtagcount;
 
       dynobj = elf_hash_table (info)->dynobj;
@@ -5740,23 +5986,215 @@ bfd_elf_size_dynsym_hash_dynstr (bfd *output_bfd, struct bfd_link_info *info)
          memset (s->contents, 0, section_sym_count * bed->s->sizeof_sym);
        }
 
+      elf_hash_table (info)->bucketcount = 0;
+
       /* Compute the size of the hashing table.  As a side effect this
         computes the hash values for all the names we export.  */
-      bucketcount = compute_bucket_count (info);
+      if (info->emit_hash)
+       {
+         unsigned long int *hashcodes;
+         unsigned long int *hashcodesp;
+         bfd_size_type amt;
+         unsigned long int nsyms;
+         size_t bucketcount;
+         size_t hash_entry_size;
+
+         /* Compute the hash values for all exported symbols.  At the same
+            time store the values in an array so that we could use them for
+            optimizations.  */
+         amt = dynsymcount * sizeof (unsigned long int);
+         hashcodes = bfd_malloc (amt);
+         if (hashcodes == NULL)
+           return FALSE;
+         hashcodesp = hashcodes;
 
-      s = bfd_get_section_by_name (dynobj, ".hash");
-      BFD_ASSERT (s != NULL);
-      hash_entry_size = elf_section_data (s)->this_hdr.sh_entsize;
-      s->size = ((2 + bucketcount + dynsymcount) * hash_entry_size);
-      s->contents = bfd_zalloc (output_bfd, s->size);
-      if (s->contents == NULL)
-       return FALSE;
+         /* Put all hash values in HASHCODES.  */
+         elf_link_hash_traverse (elf_hash_table (info),
+                                 elf_collect_hash_codes, &hashcodesp);
+
+         nsyms = hashcodesp - hashcodes;
+         bucketcount
+           = compute_bucket_count (info, hashcodes, nsyms, 0);
+         free (hashcodes);
+
+         if (bucketcount == 0)
+           return FALSE;
+
+         elf_hash_table (info)->bucketcount = bucketcount;
+
+         s = bfd_get_section_by_name (dynobj, ".hash");
+         BFD_ASSERT (s != NULL);
+         hash_entry_size = elf_section_data (s)->this_hdr.sh_entsize;
+         s->size = ((2 + bucketcount + dynsymcount) * hash_entry_size);
+         s->contents = bfd_zalloc (output_bfd, s->size);
+         if (s->contents == NULL)
+           return FALSE;
+
+         bfd_put (8 * hash_entry_size, output_bfd, bucketcount, s->contents);
+         bfd_put (8 * hash_entry_size, output_bfd, dynsymcount,
+                  s->contents + hash_entry_size);
+       }
+
+      if (info->emit_gnu_hash)
+       {
+         size_t i, cnt;
+         unsigned char *contents;
+         struct collect_gnu_hash_codes cinfo;
+         bfd_size_type amt;
+         size_t bucketcount;
+
+         memset (&cinfo, 0, sizeof (cinfo));
+
+         /* Compute the hash values for all exported symbols.  At the same
+            time store the values in an array so that we could use them for
+            optimizations.  */
+         amt = dynsymcount * 2 * sizeof (unsigned long int);
+         cinfo.hashcodes = bfd_malloc (amt);
+         if (cinfo.hashcodes == NULL)
+           return FALSE;
+
+         cinfo.hashval = cinfo.hashcodes + dynsymcount;
+         cinfo.min_dynindx = -1;
+         cinfo.output_bfd = output_bfd;
+         cinfo.bed = bed;
+
+         /* Put all hash values in HASHCODES.  */
+         elf_link_hash_traverse (elf_hash_table (info),
+                                 elf_collect_gnu_hash_codes, &cinfo);
+
+         bucketcount
+           = compute_bucket_count (info, cinfo.hashcodes, cinfo.nsyms, 1);
+
+         if (bucketcount == 0)
+           {
+             free (cinfo.hashcodes);
+             return FALSE;
+           }
+
+         s = bfd_get_section_by_name (dynobj, ".gnu.hash");
+         BFD_ASSERT (s != NULL);
+
+         if (cinfo.nsyms == 0)
+           {
+             /* Empty .gnu.hash section is special.  */
+             BFD_ASSERT (cinfo.min_dynindx == -1);
+             free (cinfo.hashcodes);
+             s->size = 5 * 4 + bed->s->arch_size / 8;
+             contents = bfd_zalloc (output_bfd, s->size);
+             if (contents == NULL)
+               return FALSE;
+             s->contents = contents;
+             /* 1 empty bucket.  */
+             bfd_put_32 (output_bfd, 1, contents);
+             /* SYMIDX above the special symbol 0.  */
+             bfd_put_32 (output_bfd, 1, contents + 4);
+             /* Just one word for bitmask.  */
+             bfd_put_32 (output_bfd, 1, contents + 8);
+             /* Only hash fn bloom filter.  */
+             bfd_put_32 (output_bfd, 0, contents + 12);
+             /* No hashes are valid - empty bitmask.  */
+             bfd_put (bed->s->arch_size, output_bfd, 0, contents + 16);
+             /* No hashes in the only bucket.  */
+             bfd_put_32 (output_bfd, 0,
+                         contents + 16 + bed->s->arch_size / 8);
+           }
+         else
+           {
+             unsigned long int maskwords, maskbitslog2;
+             BFD_ASSERT (cinfo.min_dynindx != -1);
+
+             maskbitslog2 = bfd_log2 (cinfo.nsyms) + 1;
+             if (maskbitslog2 < 3)
+               maskbitslog2 = 5;
+             else if ((1 << (maskbitslog2 - 2)) & cinfo.nsyms)
+               maskbitslog2 = maskbitslog2 + 3;
+             else
+               maskbitslog2 = maskbitslog2 + 2;
+             if (bed->s->arch_size == 64)
+               {
+                 if (maskbitslog2 == 5)
+                   maskbitslog2 = 6;
+                 cinfo.shift1 = 6;
+               }
+             else
+               cinfo.shift1 = 5;
+             cinfo.mask = (1 << cinfo.shift1) - 1;
+             cinfo.shift2 = maskbitslog2;
+             cinfo.maskbits = 1 << maskbitslog2;
+             maskwords = 1 << (maskbitslog2 - cinfo.shift1);
+             amt = bucketcount * sizeof (unsigned long int) * 2;
+             amt += maskwords * sizeof (bfd_vma);
+             cinfo.bitmask = bfd_malloc (amt);
+             if (cinfo.bitmask == NULL)
+               {
+                 free (cinfo.hashcodes);
+                 return FALSE;
+               }
+
+             cinfo.counts = (void *) (cinfo.bitmask + maskwords);
+             cinfo.indx = cinfo.counts + bucketcount;
+             cinfo.symindx = dynsymcount - cinfo.nsyms;
+             memset (cinfo.bitmask, 0, maskwords * sizeof (bfd_vma));
+
+             /* Determine how often each hash bucket is used.  */
+             memset (cinfo.counts, 0, bucketcount * sizeof (cinfo.counts[0]));
+             for (i = 0; i < cinfo.nsyms; ++i)
+               ++cinfo.counts[cinfo.hashcodes[i] % bucketcount];
+
+             for (i = 0, cnt = cinfo.symindx; i < bucketcount; ++i)
+               if (cinfo.counts[i] != 0)
+                 {
+                   cinfo.indx[i] = cnt;
+                   cnt += cinfo.counts[i];
+                 }
+             BFD_ASSERT (cnt == dynsymcount);
+             cinfo.bucketcount = bucketcount;
+             cinfo.local_indx = cinfo.min_dynindx;
+
+             s->size = (4 + bucketcount + cinfo.nsyms) * 4;
+             s->size += cinfo.maskbits / 8;
+             contents = bfd_zalloc (output_bfd, s->size);
+             if (contents == NULL)
+               {
+                 free (cinfo.bitmask);
+                 free (cinfo.hashcodes);
+                 return FALSE;
+               }
+
+             s->contents = contents;
+             bfd_put_32 (output_bfd, bucketcount, contents);
+             bfd_put_32 (output_bfd, cinfo.symindx, contents + 4);
+             bfd_put_32 (output_bfd, maskwords, contents + 8);
+             bfd_put_32 (output_bfd, cinfo.shift2, contents + 12);
+             contents += 16 + cinfo.maskbits / 8;
+
+             for (i = 0; i < bucketcount; ++i)
+               {
+                 if (cinfo.counts[i] == 0)
+                   bfd_put_32 (output_bfd, 0, contents);
+                 else
+                   bfd_put_32 (output_bfd, cinfo.indx[i], contents);
+                 contents += 4;
+               }
+
+             cinfo.contents = contents;
 
-      bfd_put (8 * hash_entry_size, output_bfd, bucketcount, s->contents);
-      bfd_put (8 * hash_entry_size, output_bfd, dynsymcount,
-              s->contents + hash_entry_size);
+             /* Renumber dynamic symbols, populate .gnu.hash section.  */
+             elf_link_hash_traverse (elf_hash_table (info),
+                                     elf_renumber_gnu_hash_syms, &cinfo);
+
+             contents = s->contents + 16;
+             for (i = 0; i < maskwords; ++i)
+               {
+                 bfd_put (bed->s->arch_size, output_bfd, cinfo.bitmask[i],
+                          contents);
+                 contents += bed->s->arch_size / 8;
+               }
 
-      elf_hash_table (info)->bucketcount = bucketcount;
+             free (cinfo.bitmask);
+             free (cinfo.hashcodes);
+           }
+       }
 
       s = bfd_get_section_by_name (dynobj, ".dynstr");
       BFD_ASSERT (s != NULL);
@@ -6182,6 +6620,24 @@ elf_link_output_sym (struct elf_final_link_info *finfo,
   return TRUE;
 }
 
+/* Return TRUE if the dynamic symbol SYM in ABFD is supported.  */
+
+static bfd_boolean
+check_dynsym (bfd *abfd, Elf_Internal_Sym *sym)
+{
+  if (sym->st_shndx > SHN_HIRESERVE)
+    {
+      /* The gABI doesn't support dynamic symbols in output sections
+         beyond 64k.  */
+      (*_bfd_error_handler)
+       (_("%B: Too many sections: %d (>= %d)"),
+        abfd, bfd_count_sections (abfd), SHN_LORESERVE);
+      bfd_set_error (bfd_error_nonrepresentable_section);
+      return FALSE;
+    }
+  return TRUE;
+}
+
 /* For DSOs loaded in via a DT_NEEDED entry, emulate ld.so in
    allowing an unsatisfied unversioned symbol in the DSO to match a
    versioned symbol that would normally require an explicit version.
@@ -6368,22 +6824,32 @@ elf_link_output_extsym (struct elf_link_hash_entry *h, void *data)
 
   bed = get_elf_backend_data (finfo->output_bfd);
 
-  /* If we have an undefined symbol reference here then it must have
-     come from a shared library that is being linked in.  (Undefined
-     references in regular files have already been handled).  If we
-     are reporting errors for this situation then do so now.  */
-  if (h->root.type == bfd_link_hash_undefined
-      && h->ref_dynamic
-      && !h->ref_regular
-      && ! elf_link_check_versioned_symbol (finfo->info, bed, h)
-      && finfo->info->unresolved_syms_in_shared_libs != RM_IGNORE)
+  if (h->root.type == bfd_link_hash_undefined)
     {
-      if (! ((*finfo->info->callbacks->undefined_symbol)
-            (finfo->info, h->root.root.string, h->root.u.undef.abfd,
-             NULL, 0, finfo->info->unresolved_syms_in_shared_libs == RM_GENERATE_ERROR)))
+      /* If we have an undefined symbol reference here then it must have
+        come from a shared library that is being linked in.  (Undefined
+        references in regular files have already been handled).  */
+      bfd_boolean ignore_undef = FALSE;
+
+      /* Some symbols may be special in that the fact that they're
+        undefined can be safely ignored - let backend determine that.  */
+      if (bed->elf_backend_ignore_undef_symbol)
+       ignore_undef = bed->elf_backend_ignore_undef_symbol (h);
+
+      /* If we are reporting errors for this situation then do so now.  */
+      if (ignore_undef == FALSE
+         && h->ref_dynamic
+         && ! h->ref_regular
+         && ! elf_link_check_versioned_symbol (finfo->info, bed, h)
+         && finfo->info->unresolved_syms_in_shared_libs != RM_IGNORE)
        {
-         eoinfo->failed = TRUE;
-         return FALSE;
+         if (! (finfo->info->callbacks->undefined_symbol
+                (finfo->info, h->root.root.string, h->root.u.undef.abfd,
+                 NULL, 0, finfo->info->unresolved_syms_in_shared_libs == RM_GENERATE_ERROR)))
+           {
+             eoinfo->failed = TRUE;
+             return FALSE;
+           }
        }
     }
 
@@ -6595,28 +7061,38 @@ elf_link_output_extsym (struct elf_link_hash_entry *h, void *data)
   if (h->dynindx != -1
       && elf_hash_table (finfo->info)->dynamic_sections_created)
     {
-      size_t bucketcount;
-      size_t bucket;
-      size_t hash_entry_size;
-      bfd_byte *bucketpos;
-      bfd_vma chain;
       bfd_byte *esym;
 
       sym.st_name = h->dynstr_index;
       esym = finfo->dynsym_sec->contents + h->dynindx * bed->s->sizeof_sym;
+      if (! check_dynsym (finfo->output_bfd, &sym))
+       {
+         eoinfo->failed = TRUE;
+         return FALSE;
+       }
       bed->s->swap_symbol_out (finfo->output_bfd, &sym, esym, 0);
 
-      bucketcount = elf_hash_table (finfo->info)->bucketcount;
-      bucket = h->u.elf_hash_value % bucketcount;
-      hash_entry_size
-       = elf_section_data (finfo->hash_sec)->this_hdr.sh_entsize;
-      bucketpos = ((bfd_byte *) finfo->hash_sec->contents
-                  + (bucket + 2) * hash_entry_size);
-      chain = bfd_get (8 * hash_entry_size, finfo->output_bfd, bucketpos);
-      bfd_put (8 * hash_entry_size, finfo->output_bfd, h->dynindx, bucketpos);
-      bfd_put (8 * hash_entry_size, finfo->output_bfd, chain,
-              ((bfd_byte *) finfo->hash_sec->contents
-               + (bucketcount + 2 + h->dynindx) * hash_entry_size));
+      if (finfo->hash_sec != NULL)
+       {
+         size_t hash_entry_size;
+         bfd_byte *bucketpos;
+         bfd_vma chain;
+         size_t bucketcount;
+         size_t bucket;
+
+         bucketcount = elf_hash_table (finfo->info)->bucketcount;
+         bucket = h->u.elf_hash_value % bucketcount;
+
+         hash_entry_size
+           = elf_section_data (finfo->hash_sec)->this_hdr.sh_entsize;
+         bucketpos = ((bfd_byte *) finfo->hash_sec->contents
+                      + (bucket + 2) * hash_entry_size);
+         chain = bfd_get (8 * hash_entry_size, finfo->output_bfd, bucketpos);
+         bfd_put (8 * hash_entry_size, finfo->output_bfd, h->dynindx, bucketpos);
+         bfd_put (8 * hash_entry_size, finfo->output_bfd, chain,
+                  ((bfd_byte *) finfo->hash_sec->contents
+                   + (bucketcount + 2 + h->dynindx) * hash_entry_size));
+       }
 
       if (finfo->symver_sec != NULL && finfo->symver_sec->contents != NULL)
        {
@@ -6727,6 +7203,7 @@ match_group_member (asection *sec, asection *group)
       if (bfd_elf_match_symbols_in_sections (s, sec))
        return s;
 
+      s = elf_next_in_group (s);
       if (s == first)
        break;
     }
@@ -6859,8 +7336,10 @@ elf_link_input_bfd (struct elf_final_link_info *finfo, bfd *input_bfd)
        isec = bfd_com_section_ptr;
       else
        {
-         /* Who knows?  */
-         isec = NULL;
+         /* Don't attempt to output symbols with st_shnx in the
+            reserved range other than SHN_ABS and SHN_COMMON.  */
+         *ppsection = NULL;
+         continue;
        }
 
       *ppsection = isec;
@@ -6891,20 +7370,12 @@ elf_link_input_bfd (struct elf_final_link_info *finfo, bfd *input_bfd)
        continue;
 
       /* If this symbol is defined in a section which we are
-        discarding, we don't need to keep it, but note that
-        linker_mark is only reliable for sections that have contents.
-        For the benefit of the MIPS ELF linker, we check SEC_EXCLUDE
-        as well as linker_mark.  */
-      if ((isym->st_shndx < SHN_LORESERVE || isym->st_shndx > SHN_HIRESERVE)
+        discarding, we don't need to keep it.  */
+      if (isym->st_shndx != SHN_UNDEF
+         && (isym->st_shndx < SHN_LORESERVE || isym->st_shndx > SHN_HIRESERVE)
          && (isec == NULL
-             || (! isec->linker_mark && (isec->flags & SEC_HAS_CONTENTS) != 0)
-             || (! finfo->info->relocatable
-                 && (isec->flags & SEC_EXCLUDE) != 0)))
-       continue;
-
-      /* If the section is not in the output BFD's section list, it is not
-        being output.  */
-      if (bfd_section_removed_from_list (output_bfd, isec->output_section))
+             || bfd_section_removed_from_list (output_bfd,
+                                               isec->output_section)))
        continue;
 
       /* Get the name of the symbol.  */
@@ -7025,8 +7496,7 @@ elf_link_input_bfd (struct elf_final_link_info *finfo, bfd *input_bfd)
             from discarded sections and section symbols from
             removed link-once sections.  Complain about relocs
             against discarded sections.  Zero relocs against removed
-            link-once sections.  Preserve debug information as much
-            as we can.  */
+            link-once sections.  */
          if (!elf_section_ignore_discarded_relocs (o))
            {
              Elf_Internal_Rela *rel, *relend;
@@ -7098,16 +7568,11 @@ elf_link_input_bfd (struct elf_final_link_info *finfo, bfd *input_bfd)
                           sym_name, o, input_bfd, sec, sec->owner);
 
                      /* Try to do the best we can to support buggy old
-                        versions of gcc.  If we've warned, or this is
-                        debugging info, pretend that the symbol is
+                        versions of gcc.  Pretend that the symbol is
                         really defined in the kept linkonce section.
                         FIXME: This is quite broken.  Modifying the
                         symbol here means we will be changing all later
-                        uses of the symbol, not just in this section.
-                        The only thing that makes this half reasonable
-                        is that we warn in non-debug sections, and
-                        debug sections tend to come after other
-                        sections.  */
+                        uses of the symbol, not just in this section.  */
                      if (action & PRETEND)
                        {
                          asection *kept;
@@ -7207,7 +7672,7 @@ elf_link_input_bfd (struct elf_final_link_info *finfo, bfd *input_bfd)
                      /* This is a reloc for a deleted entry or somesuch.
                         Turn it into an R_*_NONE reloc, at the same
                         offset as the last reloc.  elf_eh_frame.c and
-                        elf_bfd_discard_info rely on reloc offsets
+                        bfd_elf_discard_info rely on reloc offsets
                         being ordered.  */
                      irela->r_offset = last_offset;
                      irela->r_info = 0;
@@ -7432,7 +7897,7 @@ elf_link_input_bfd (struct elf_final_link_info *finfo, bfd *input_bfd)
 }
 
 /* Generate a reloc when linking an ELF file.  This is a reloc
-   requested by the linker, and does come from any input file.  This
+   requested by the linker, and does not come from any input file.  This
    is used to build constructor and destructor tables when linking
    with -Ur.  */
 
@@ -7614,7 +8079,7 @@ elf_get_linked_section_vma (struct bfd_link_order *p)
   elfsec = elf_shdrp[elfsec]->sh_link;
   /* PR 290:
      The Intel C compiler generates SHT_IA_64_UNWIND with
-     SHF_LINK_ORDER.  But it doesn't set theh sh_link or
+     SHF_LINK_ORDER.  But it doesn't set the sh_link or
      sh_info fields.  Hence we could get the situation
      where elfsec is 0.  */
   if (elfsec == 0)
@@ -7665,43 +8130,57 @@ elf_fixup_link_order (bfd *abfd, asection *o)
   struct bfd_link_order *p;
   bfd *sub;
   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
-  int elfsec;
+  unsigned elfsec;
   struct bfd_link_order **sections;
-  asection *s;
+  asection *s, *other_sec, *linkorder_sec;
   bfd_vma offset;
 
+  other_sec = NULL;
+  linkorder_sec = NULL;
   seen_other = 0;
   seen_linkorder = 0;
   for (p = o->map_head.link_order; p != NULL; p = p->next)
     {
-      if (p->type == bfd_indirect_link_order
-         && (bfd_get_flavour ((sub = p->u.indirect.section->owner))
-             == bfd_target_elf_flavour)
-         && elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass)
+      if (p->type == bfd_indirect_link_order)
        {
          s = p->u.indirect.section;
-         elfsec = _bfd_elf_section_from_bfd_section (sub, s);
-         if (elfsec != -1
+         sub = s->owner;
+         if (bfd_get_flavour (sub) == bfd_target_elf_flavour
+             && elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass
+             && (elfsec = _bfd_elf_section_from_bfd_section (sub, s))
+             && elfsec < elf_numsections (sub)
              && elf_elfsections (sub)[elfsec]->sh_flags & SHF_LINK_ORDER)
-           seen_linkorder++;
+           {
+             seen_linkorder++;
+             linkorder_sec = s;
+           }
          else
-           seen_other++;
+           {
+             seen_other++;
+             other_sec = s;
+           }
        }
       else
        seen_other++;
+
+      if (seen_other && seen_linkorder)
+       {
+         if (other_sec && linkorder_sec)
+           (*_bfd_error_handler) (_("%A has both ordered [`%A' in %B] and unordered [`%A' in %B] sections"),
+                                  o, linkorder_sec,
+                                  linkorder_sec->owner, other_sec,
+                                  other_sec->owner);
+         else
+           (*_bfd_error_handler) (_("%A has both ordered and unordered sections"),
+                                  o);
+         bfd_set_error (bfd_error_bad_value);
+         return FALSE;
+       }
     }
 
   if (!seen_linkorder)
     return TRUE;
 
-  if (seen_other && seen_linkorder)
-    {
-      (*_bfd_error_handler) (_("%A has both ordered and unordered sections"),
-                            o);
-      bfd_set_error (bfd_error_bad_value);
-      return FALSE;
-    }
-
   sections = (struct bfd_link_order **)
     xmalloc (seen_linkorder * sizeof (struct bfd_link_order *));
   seen_linkorder = 0;
@@ -7769,8 +8248,7 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
   dynobj = elf_hash_table (info)->dynobj;
 
   emit_relocs = (info->relocatable
-                || info->emitrelocations
-                || bed->elf_backend_emit_relocs);
+                || info->emitrelocations);
 
   finfo.info = info;
   finfo.output_bfd = abfd;
@@ -7788,7 +8266,7 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
     {
       finfo.dynsym_sec = bfd_get_section_by_name (dynobj, ".dynsym");
       finfo.hash_sec = bfd_get_section_by_name (dynobj, ".hash");
-      BFD_ASSERT (finfo.dynsym_sec != NULL && finfo.hash_sec != NULL);
+      BFD_ASSERT (finfo.dynsym_sec != NULL);
       finfo.symver_sec = bfd_get_section_by_name (dynobj, ".gnu.version");
       /* Note that it is OK if symver_sec is NULL.  */
     }
@@ -8072,18 +8550,19 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
       elfsym.st_size = 0;
       elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
       elfsym.st_other = 0;
+      elfsym.st_value = 0;
       for (i = 1; i < elf_numsections (abfd); i++)
        {
          o = bfd_section_from_elf_index (abfd, i);
          if (o != NULL)
-           o->target_index = bfd_get_symcount (abfd);
-         elfsym.st_shndx = i;
-         if (info->relocatable || o == NULL)
-           elfsym.st_value = 0;
-         else
-           elfsym.st_value = o->vma;
-         if (! elf_link_output_sym (&finfo, NULL, &elfsym, o, NULL))
-           goto error_return;
+           {
+             o->target_index = bfd_get_symcount (abfd);
+             elfsym.st_shndx = i;
+             if (!info->relocatable)
+               elfsym.st_value = o->vma;
+             if (!elf_link_output_sym (&finfo, NULL, &elfsym, o, NULL))
+               goto error_return;
+           }
          if (i == SHN_LORESERVE - 1)
            i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
        }
@@ -8154,15 +8633,14 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
           sec && (sec->flags & SEC_THREAD_LOCAL);
           sec = sec->next)
        {
-         bfd_vma size = sec->size;
+         bfd_size_type size = sec->size;
 
-         if (size == 0 && (sec->flags & SEC_HAS_CONTENTS) == 0)
+         if (size == 0
+             && (sec->flags & SEC_HAS_CONTENTS) == 0)
            {
-             struct bfd_link_order *o;
-
-             for (o = sec->map_head.link_order; o != NULL; o = o->next)
-               if (size < o->offset + o->size)
-                 size = o->offset + o->size;
+             struct bfd_link_order *o = sec->map_tail.link_order;
+             if (o != NULL)
+               size = o->offset + o->size;
            }
          end = sec->vma + size;
        }
@@ -8244,6 +8722,19 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
   if (eoinfo.failed)
     return FALSE;
 
+  /* If backend needs to output some local symbols not present in the hash
+     table, do it now.  */
+  if (bed->elf_backend_output_arch_local_syms)
+    {
+      typedef bfd_boolean (*out_sym_func)
+       (void *, const char *, Elf_Internal_Sym *, asection *,
+        struct elf_link_hash_entry *);
+
+      if (! ((*bed->elf_backend_output_arch_local_syms)
+            (abfd, info, &finfo, (out_sym_func) elf_link_output_sym)))
+       return FALSE;
+    }
+
   /* That wrote out all the local symbols.  Finish up the symbol table
      with the global symbols. Even if we want to strip everything we
      can, we still need to deal with those global symbols that got
@@ -8281,6 +8772,8 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
              indx = elf_section_data (s)->this_idx;
              BFD_ASSERT (indx > 0);
              sym.st_shndx = indx;
+             if (! check_dynsym (abfd, &sym))
+               return FALSE;
              sym.st_value = s->vma;
              dest = dynsym + dynindx * bed->s->sizeof_sym;
              if (last_local < dynindx)
@@ -8315,6 +8808,8 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
 
                  sym.st_shndx =
                    elf_section_data (s->output_section)->this_idx;
+                 if (! check_dynsym (abfd, &sym))
+                   return FALSE;
                  sym.st_value = (s->output_section->vma
                                  + s->output_offset
                                  + e->isym.st_value);
@@ -8531,6 +9026,9 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
            case DT_HASH:
              name = ".hash";
              goto get_vma;
+           case DT_GNU_HASH:
+             name = ".gnu.hash";
+             goto get_vma;
            case DT_STRTAB:
              name = ".dynstr";
              goto get_vma;
@@ -8595,6 +9093,32 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
       if (! (*bed->elf_backend_finish_dynamic_sections) (abfd, info))
        goto error_return;
 
+      /* Check for DT_TEXTREL (late, in case the backend removes it).  */
+      if (info->warn_shared_textrel && info->shared)
+       {
+         bfd_byte *dyncon, *dynconend;
+
+         /* Fix up .dynamic entries.  */
+         o = bfd_get_section_by_name (dynobj, ".dynamic");
+         BFD_ASSERT (o != NULL);
+
+         dyncon = o->contents;
+         dynconend = o->contents + o->size;
+         for (; dyncon < dynconend; dyncon += bed->s->sizeof_dyn)
+           {
+             Elf_Internal_Dyn dyn;
+
+             bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
+
+             if (dyn.d_tag == DT_TEXTREL)
+               {
+                 _bfd_error_handler
+                   (_("warning: creating a DT_TEXTREL in a shared object."));
+                 break;
+               }
+           }
+       }
+
       for (o = dynobj->sections; o != NULL; o = o->next)
        {
          if ((o->flags & SEC_HAS_CONTENTS) == 0
@@ -8856,19 +9380,27 @@ _bfd_elf_gc_mark (struct bfd_link_info *info,
 
 /* Sweep symbols in swept sections.  Called via elf_link_hash_traverse.  */
 
-static bfd_boolean
-elf_gc_sweep_symbol (struct elf_link_hash_entry *h, void *idxptr)
+struct elf_gc_sweep_symbol_info
 {
-  int *idx = idxptr;
+  struct bfd_link_info *info;
+  void (*hide_symbol) (struct bfd_link_info *, struct elf_link_hash_entry *,
+                      bfd_boolean);
+};
 
+static bfd_boolean
+elf_gc_sweep_symbol (struct elf_link_hash_entry *h, void *data)
+{
   if (h->root.type == bfd_link_hash_warning)
     h = (struct elf_link_hash_entry *) h->root.u.i.link;
 
-  if (h->dynindx != -1
-      && ((h->root.type != bfd_link_hash_defined
-          && h->root.type != bfd_link_hash_defweak)
-         || h->root.u.def.section->gc_mark))
-    h->dynindx = (*idx)++;
+  if ((h->root.type == bfd_link_hash_defined
+       || h->root.type == bfd_link_hash_defweak)
+      && !h->root.u.def.section->gc_mark
+      && !(h->root.u.def.section->owner->flags & DYNAMIC))
+    {
+      struct elf_gc_sweep_symbol_info *inf = data;
+      (*inf->hide_symbol) (inf->info, h, TRUE);
+    }
 
   return TRUE;
 }
@@ -8879,9 +9411,13 @@ typedef bfd_boolean (*gc_sweep_hook_fn)
   (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
 
 static bfd_boolean
-elf_gc_sweep (struct bfd_link_info *info, gc_sweep_hook_fn gc_sweep_hook)
+elf_gc_sweep (bfd *abfd, struct bfd_link_info *info)
 {
   bfd *sub;
+  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  gc_sweep_hook_fn gc_sweep_hook = bed->gc_sweep_hook;
+  unsigned long section_sym_count;
+  struct elf_gc_sweep_symbol_info sweep_info;
 
   for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
     {
@@ -8894,7 +9430,7 @@ elf_gc_sweep (struct bfd_link_info *info, gc_sweep_hook_fn gc_sweep_hook)
        {
          /* Keep debug and special sections.  */
          if ((o->flags & (SEC_DEBUGGING | SEC_LINKER_CREATED)) != 0
-             || (o->flags & (SEC_ALLOC | SEC_LOAD)) == 0)
+             || (o->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) == 0)
            o->gc_mark = 1;
 
          if (o->gc_mark)
@@ -8908,6 +9444,9 @@ elf_gc_sweep (struct bfd_link_info *info, gc_sweep_hook_fn gc_sweep_hook)
             to remove a section from the output.  */
          o->flags |= SEC_EXCLUDE;
 
+         if (info->print_gc_sections == TRUE)
+           _bfd_error_handler (_("Removing unused section '%s' in file '%B'"), sub, o->name);
+
          /* But we also have to update some of the relocation
             info we collected before.  */
          if (gc_sweep_hook
@@ -8938,20 +9477,12 @@ elf_gc_sweep (struct bfd_link_info *info, gc_sweep_hook_fn gc_sweep_hook)
   /* Remove the symbols that were in the swept sections from the dynamic
      symbol table.  GCFIXME: Anyone know how to get them out of the
      static symbol table as well?  */
-  {
-    int i = 0;
-
-    elf_link_hash_traverse (elf_hash_table (info), elf_gc_sweep_symbol, &i);
-
-    /* There is an unused NULL entry at the head of the table which
-       we must account for in our count.  Unless there weren't any
-       symbols, which means we'll have no table at all.  */
-    if (i != 0)
-      ++i;
-
-    elf_hash_table (info)->dynsymcount = i;
-  }
+  sweep_info.info = info;
+  sweep_info.hide_symbol = bed->elf_backend_hide_symbol;
+  elf_link_hash_traverse (elf_hash_table (info), elf_gc_sweep_symbol,
+                         &sweep_info);
 
+  _bfd_elf_link_renumber_dynsyms (abfd, info, &section_sym_count);
   return TRUE;
 }
 
@@ -9070,8 +9601,8 @@ elf_gc_smash_unused_vtentry_relocs (struct elf_link_hash_entry *h, void *okp)
    building shared libraries, we must assume that any visible symbol is
    referenced.  */
 
-static bfd_boolean
-elf_gc_mark_dynamic_ref_symbol (struct elf_link_hash_entry *h, void *inf)
+bfd_boolean
+bfd_elf_gc_mark_dynamic_ref_symbol (struct elf_link_hash_entry *h, void *inf)
 {
   struct bfd_link_info *info = (struct bfd_link_info *) inf;
 
@@ -9081,7 +9612,7 @@ elf_gc_mark_dynamic_ref_symbol (struct elf_link_hash_entry *h, void *inf)
   if ((h->root.type == bfd_link_hash_defined
        || h->root.type == bfd_link_hash_defweak)
       && (h->ref_dynamic
-         || (info->shared
+         || (!info->executable
              && h->def_regular
              && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
              && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN)))
@@ -9100,8 +9631,9 @@ bfd_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
   asection * (*gc_mark_hook)
     (asection *, struct bfd_link_info *, Elf_Internal_Rela *,
      struct elf_link_hash_entry *h, Elf_Internal_Sym *);
+  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
 
-  if (!get_elf_backend_data (abfd)->can_gc_sections
+  if (!bed->can_gc_sections
       || info->relocatable
       || info->emitrelocations
       || !is_elf_hash_table (info->hash))
@@ -9127,11 +9659,11 @@ bfd_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
   /* Mark dynamically referenced symbols.  */
   if (elf_hash_table (info)->dynamic_sections_created)
     elf_link_hash_traverse (elf_hash_table (info),
-                           elf_gc_mark_dynamic_ref_symbol,
+                           bed->gc_mark_dynamic_ref,
                            info);
 
   /* Grovel through relocs to find out who stays ...  */
-  gc_mark_hook = get_elf_backend_data (abfd)->gc_mark_hook;
+  gc_mark_hook = bed->gc_mark_hook;
   for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
     {
       asection *o;
@@ -9155,14 +9687,14 @@ bfd_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
 
       /* Keep .gcc_except_table.* if the associated .text.* is
         marked.  This isn't very nice, but the proper solution,
-        splitting .eh_frame up and using comdat doesn't pan out 
+        splitting .eh_frame up and using comdat doesn't pan out
         easily due to needing special relocs to handle the
         difference of two symbols in separate sections.
         Don't keep code sections referenced by .eh_frame.  */
       for (o = sub->sections; o != NULL; o = o->next)
        if (!o->gc_mark && o->gc_mark_from_eh && (o->flags & SEC_CODE) == 0)
          {
-           if (strncmp (o->name, ".gcc_except_table.", 18) == 0)
+           if (CONST_STRNEQ (o->name, ".gcc_except_table."))
              {
                unsigned long len;
                char *fn_name;
@@ -9172,7 +9704,7 @@ bfd_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
                fn_name = bfd_malloc (len + 6);
                if (fn_name == NULL)
                  return FALSE;
-               memcpy (fn_name, ".text.", 6);
+               memcpy (fn_name, STRING_COMMA_LEN (".text."));
                memcpy (fn_name + 6, o->name + 18, len);
                fn_text = bfd_get_section_by_name (sub, fn_name);
                free (fn_name);
@@ -9188,10 +9720,7 @@ bfd_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
     }
 
   /* ... and mark SEC_EXCLUDE for those that go.  */
-  if (!elf_gc_sweep (info, get_elf_backend_data (abfd)->gc_sweep_hook))
-    return FALSE;
-
-  return TRUE;
+  return elf_gc_sweep (abfd, info);
 }
 \f
 /* Called from check_relocs to record the existence of a VTINHERIT reloc.  */
@@ -9695,7 +10224,7 @@ _bfd_elf_section_already_linked (bfd *abfd, struct bfd_section * sec)
 
   name = bfd_get_section_name (abfd, sec);
 
-  if (strncmp (name, ".gnu.linkonce.", sizeof (".gnu.linkonce.") - 1) == 0
+  if (CONST_STRNEQ (name, ".gnu.linkonce.")
       && (p = strchr (name + sizeof (".gnu.linkonce.") - 1, '.')) != NULL)
     p++;
   else
@@ -9841,88 +10370,6 @@ _bfd_elf_section_already_linked (bfd *abfd, struct bfd_section * sec)
   bfd_section_already_linked_table_insert (already_linked_list, sec);
 }
 
-static void
-bfd_elf_set_symbol (struct elf_link_hash_entry *h, bfd_vma val,
-                   struct bfd_section *s)
-{
-  h->root.type = bfd_link_hash_defined;
-  h->root.u.def.section = s ? s : bfd_abs_section_ptr;
-  h->root.u.def.value = val;
-  h->def_regular = 1;
-  h->type = STT_OBJECT;
-  h->other = STV_HIDDEN | (h->other & ~ ELF_ST_VISIBILITY (-1));
-  h->forced_local = 1;
-}
-
-/* Set NAME to VAL if the symbol exists and is not defined in a regular
-   object file.  If S is NULL it is an absolute symbol, otherwise it is
-   relative to that section.  */
-
-void
-_bfd_elf_provide_symbol (struct bfd_link_info *info, const char *name,
-                        bfd_vma val, struct bfd_section *s)
-{
-  struct elf_link_hash_entry *h;
-
-  bfd_elf_record_link_assignment (info, name, TRUE);
-
-  h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, FALSE);
-  if (h != NULL
-      && !(h->root.type == bfd_link_hash_defined
-          && h->root.u.def.section != NULL
-          && h->root.u.def.section != h->root.u.def.section->output_section))
-    bfd_elf_set_symbol (h, val, s);
-}
-
-/* Set START and END to boundaries of SEC if they exist and are not
-   defined in regular object files.  */
-
-void
-_bfd_elf_provide_section_bound_symbols (struct bfd_link_info *info,
-                                       asection *sec,
-                                       const char *start,
-                                       const char *end)
-{
-  bfd_vma val = 0;
-  _bfd_elf_provide_symbol (info, start, val, sec);
-  if (sec != NULL)
-    val = sec->size;
-  _bfd_elf_provide_symbol (info, end, val, sec);
-}
-
-/* Convert symbols in excluded output sections to absolute.  */
-
-static bfd_boolean
-fix_syms (struct bfd_link_hash_entry *h, void *data)
-{
-  bfd *obfd = (bfd *) data;
-
-  if (h->type == bfd_link_hash_warning)
-    h = h->u.i.link;
-
-  if (h->type == bfd_link_hash_defined
-      || h->type == bfd_link_hash_defweak)
-    {
-      asection *s = h->u.def.section;
-      if (s != NULL
-         && s->output_section != NULL
-         && (s->output_section->flags & SEC_EXCLUDE) != 0
-         && bfd_section_removed_from_list (obfd, s->output_section))
-       {
-         h->u.def.value += s->output_offset + s->output_section->vma;
-         h->u.def.section = bfd_abs_section_ptr;
-       }
-    }
-
-  return TRUE;
-}
-
-void
-_bfd_elf_fix_excluded_sec_syms (bfd *obfd, struct bfd_link_info *info)
-{
-  bfd_link_hash_traverse (info->hash, fix_syms, obfd);
-}
-
 bfd_boolean
 _bfd_elf_common_definition (Elf_Internal_Sym *sym)
 {