Changeset 609 for branches/GNU/src/binutils/bfd/elflink.h

Timestamp:

Aug 16, 2003, 6:59:22 PM (22 years ago)

Author:

bird

Message:

binutils v2.14 - offical sources.

File:

• branches/GNU/src/binutils/bfd/elflink.h (modified) (368 diffs, 1 prop)

branches/GNU/src/binutils/bfd/elflink.h

@@ -1 +1 @@
 /* ELF linker support.
-   Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001
+   Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
    Free Software Foundation, Inc.
 
-This file is part of BFD, the Binary File Descriptor library.
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   This file is part of BFD, the Binary File Descriptor library.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 /* ELF linker code.  */
@@ -26 +26 @@
 struct elf_info_failed
 {
-  boolean failed;
+  bfd_boolean failed;
   struct bfd_link_info *info;
+  struct bfd_elf_version_tree *verdefs;
 };
 
-static boolean elf_link_add_object_symbols
+static bfd_boolean is_global_data_symbol_definition
+  PARAMS ((bfd *, Elf_Internal_Sym *));
+static bfd_boolean elf_link_is_defined_archive_symbol
+  PARAMS ((bfd *, carsym *));
+static bfd_boolean elf_link_add_object_symbols
   PARAMS ((bfd *, struct bfd_link_info *));
-static boolean elf_link_add_archive_symbols
+static bfd_boolean elf_link_add_archive_symbols
   PARAMS ((bfd *, struct bfd_link_info *));
-static boolean elf_merge_symbol
-  PARAMS ((bfd *, struct bfd_link_info *, const char *, Elf_Internal_Sym *,
-           asection **, bfd_vma *, struct elf_link_hash_entry **,
-           boolean *, boolean *, boolean *, boolean));
-static boolean elf_export_symbol
+static bfd_boolean elf_merge_symbol
+  PARAMS ((bfd *, struct bfd_link_info *, const char *,
+           Elf_Internal_Sym *, asection **, bfd_vma *,
+           struct elf_link_hash_entry **, bfd_boolean *, bfd_boolean *,
+           bfd_boolean *, bfd_boolean *, bfd_boolean));
+static bfd_boolean elf_add_default_symbol
+  PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
+           const char *, Elf_Internal_Sym *, asection **, bfd_vma *,
+           bfd_boolean *, bfd_boolean, bfd_boolean));
+static bfd_boolean elf_export_symbol
   PARAMS ((struct elf_link_hash_entry *, PTR));
-static boolean elf_fix_symbol_flags
+static bfd_boolean elf_finalize_dynstr
+  PARAMS ((bfd *, struct bfd_link_info *));
+static bfd_boolean elf_fix_symbol_flags
   PARAMS ((struct elf_link_hash_entry *, struct elf_info_failed *));
-static boolean elf_adjust_dynamic_symbol
+static bfd_boolean elf_adjust_dynamic_symbol
   PARAMS ((struct elf_link_hash_entry *, PTR));
-static boolean elf_link_find_version_dependencies
+static bfd_boolean elf_link_find_version_dependencies
   PARAMS ((struct elf_link_hash_entry *, PTR));
-static boolean elf_link_find_version_dependencies
+static bfd_boolean elf_link_assign_sym_version
   PARAMS ((struct elf_link_hash_entry *, PTR));
-static boolean elf_link_assign_sym_version
+static bfd_boolean elf_collect_hash_codes
   PARAMS ((struct elf_link_hash_entry *, PTR));
-static boolean elf_collect_hash_codes
-  PARAMS ((struct elf_link_hash_entry *, PTR));
-static boolean elf_link_read_relocs_from_section
+static bfd_boolean elf_link_read_relocs_from_section
   PARAMS ((bfd *, Elf_Internal_Shdr *, PTR, Elf_Internal_Rela *));
-static void elf_link_output_relocs
+static size_t compute_bucket_count
+  PARAMS ((struct bfd_link_info *));
+static bfd_boolean elf_link_output_relocs
   PARAMS ((bfd *, asection *, Elf_Internal_Shdr *, Elf_Internal_Rela *));
-static boolean elf_link_size_reloc_section
+static bfd_boolean elf_link_size_reloc_section
   PARAMS ((bfd *, Elf_Internal_Shdr *, asection *));
 static void elf_link_adjust_relocs
   PARAMS ((bfd *, Elf_Internal_Shdr *, unsigned int,
            struct elf_link_hash_entry **));
+static int elf_link_sort_cmp1
+  PARAMS ((const void *, const void *));
+static int elf_link_sort_cmp2
+  PARAMS ((const void *, const void *));
+static size_t elf_link_sort_relocs
+  PARAMS ((bfd *, struct bfd_link_info *, asection **));
+static bfd_boolean elf_section_ignore_discarded_relocs
+  PARAMS ((asection *));
 
 /* Given an ELF BFD, add symbols to the global hash table as
    appropriate.  */
 
-boolean
+bfd_boolean
 elf_bfd_link_add_symbols (abfd, info)
      bfd *abfd;
@@ -78 +98 @@
     default:
       bfd_set_error (bfd_error_wrong_format);
-      return false;
+      return FALSE;
     }
 }
 
 
-/* Return true iff this is a non-common, definition of a non-function symbol.  */
-static boolean
+/* Return TRUE iff this is a non-common, definition of a non-function symbol.  */
+static bfd_boolean
 is_global_data_symbol_definition (abfd, sym)
      bfd * abfd ATTRIBUTE_UNUSED;
@@ -92 +112 @@
   if (ELF_ST_BIND (sym->st_info) != STB_GLOBAL
       && ELF_ST_BIND (sym->st_info) < STB_LOOS)
-    return false;
+    return FALSE;
 
   /* Function symbols do not count.  */
   if (ELF_ST_TYPE (sym->st_info) == STT_FUNC)
-    return false;
+    return FALSE;
 
   /* If the section is undefined, then so is the symbol.  */
   if (sym->st_shndx == SHN_UNDEF)
-    return false;
+    return FALSE;
 
   /* If the symbol is defined in the common section, then
      it is a common definition and so does not count.  */
   if (sym->st_shndx == SHN_COMMON)
-    return false;
+    return FALSE;
 
   /* If the symbol is in a target specific section then we
@@ -117 +137 @@
        Even if this is wrong, at least the linker will behave
        in the same way that it used to do.  */
-    return false;
-
-  return true;
+    return FALSE;
+
+  return TRUE;
 }
 
@@ -125 +145 @@
    whose archive map contains a mention of SYMDEF, and determine if
    the symbol is defined in this element.  */
-static boolean
+static bfd_boolean
 elf_link_is_defined_archive_symbol (abfd, symdef)
      bfd * abfd;
@@ -131 +151 @@
 {
   Elf_Internal_Shdr * hdr;
-  Elf_External_Sym *  esym;
-  Elf_External_Sym *  esymend;
-  Elf_External_Sym *  buf = NULL;
-  size_t symcount;
-  size_t extsymcount;
-  size_t extsymoff;
-  boolean result = false;
+  bfd_size_type symcount;
+  bfd_size_type extsymcount;
+  bfd_size_type extsymoff;
+  Elf_Internal_Sym *isymbuf;
+  Elf_Internal_Sym *isym;
+  Elf_Internal_Sym *isymend;
+  bfd_boolean result;
 
   abfd = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
   if (abfd == (bfd *) NULL)
-    return false;
+    return FALSE;
 
   if (! bfd_check_format (abfd, bfd_object))
-    return false;
+    return FALSE;
 
   /* If we have already included the element containing this symbol in the
@@ -151 +171 @@
      (re)include this element.  */
   if (abfd->archive_pass)
-    return false;
+    return FALSE;
 
   /* Select the appropriate symbol table.  */
@@ -174 +194 @@
     }
 
-  buf = ((Elf_External_Sym *)
-         bfd_malloc (extsymcount * sizeof (Elf_External_Sym)));
-  if (buf == NULL && extsymcount != 0)
-    return false;
-
-  /* Read in the symbol table.
-     FIXME:  This ought to be cached somewhere.  */
-  if (bfd_seek (abfd,
-                hdr->sh_offset + extsymoff * sizeof (Elf_External_Sym),
-                SEEK_SET) != 0
-      || (bfd_read ((PTR) buf, sizeof (Elf_External_Sym), extsymcount, abfd)
-          != extsymcount * sizeof (Elf_External_Sym)))
-    {
-      free (buf);
-      return false;
-    }
+  if (extsymcount == 0)
+    return FALSE;
+
+  /* Read in the symbol table.  */
+  isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
+                                  NULL, NULL, NULL);
+  if (isymbuf == NULL)
+    return FALSE;
 
   /* Scan the symbol table looking for SYMDEF.  */
-  esymend = buf + extsymcount;
-  for (esym = buf;
-       esym < esymend;
-       esym++)
-    {
-      Elf_Internal_Sym sym;
-      const char * name;
-
-      elf_swap_symbol_in (abfd, esym, & sym);
-
-      name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link, sym.st_name);
+  result = FALSE;
+  for (isym = isymbuf, isymend = isymbuf + extsymcount; isym < isymend; isym++)
+    {
+      const char *name;
+
+      name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
+                                              isym->st_name);
       if (name == (const char *) NULL)
         break;
@@ -208 +216 @@
       if (strcmp (name, symdef->name) == 0)
         {
-          result = is_global_data_symbol_definition (abfd, & sym);
+          result = is_global_data_symbol_definition (abfd, isym);
           break;
         }
     }
 
-  free (buf);
+  free (isymbuf);
 
   return result;
@@ -244 +252 @@
    table until nothing further is resolved.  */
 
-static boolean
+static bfd_boolean
 elf_link_add_archive_symbols (abfd, info)
      bfd *abfd;
@@ -250 +258 @@
 {
   symindex c;
-  boolean *defined = NULL;
-  boolean *included = NULL;
+  bfd_boolean *defined = NULL;
+  bfd_boolean *included = NULL;
   carsym *symdefs;
-  boolean loop;
+  bfd_boolean loop;
+  bfd_size_type amt;
 
   if (! bfd_has_map (abfd))
@@ -259 +268 @@
       /* An empty archive is a special case.  */
       if (bfd_openr_next_archived_file (abfd, (bfd *) NULL) == NULL)
-        return true;
+        return TRUE;
       bfd_set_error (bfd_error_no_armap);
-      return false;
+      return FALSE;
     }
 
@@ -269 +278 @@
   c = bfd_ardata (abfd)->symdef_count;
   if (c == 0)
-    return true;
-  defined = (boolean *) bfd_malloc (c * sizeof (boolean));
-  included = (boolean *) bfd_malloc (c * sizeof (boolean));
-  if (defined == (boolean *) NULL || included == (boolean *) NULL)
+    return TRUE;
+  amt = c;
+  amt *= sizeof (bfd_boolean);
+  defined = (bfd_boolean *) bfd_zmalloc (amt);
+  included = (bfd_boolean *) bfd_zmalloc (amt);
+  if (defined == (bfd_boolean *) NULL || included == (bfd_boolean *) NULL)
     goto error_return;
-  memset (defined, 0, c * sizeof (boolean));
-  memset (included, 0, c * sizeof (boolean));
 
   symdefs = bfd_ardata (abfd)->symdefs;
@@ -286 +295 @@
       carsym *symdefend;
 
-      loop = false;
+      loop = FALSE;
       last = -1;
 
@@ -302 +311 @@
           if (symdef->file_offset == last)
             {
-              included[i] = true;
+              included[i] = TRUE;
               continue;
             }
 
           h = elf_link_hash_lookup (elf_hash_table (info), symdef->name,
-                                    false, false, false);
+                                    FALSE, FALSE, FALSE);
 
           if (h == NULL)
             {
               char *p, *copy;
+              size_t len, first;
 
               /* If this is a default version (the name contains @@),
-                 look up the symbol again without the version.  The
-                 effect is that references to the symbol without the
-                 version will be matched by the default symbol in the
-                 archive.  */
+                 look up the symbol again with only one `@' as well
+                 as without the version.  The effect is that references
+                 to the symbol with and without the version will be
+                 matched by the default symbol in the archive.  */
 
               p = strchr (symdef->name, ELF_VER_CHR);
@@ -323 +333 @@
                 continue;
 
-              copy = bfd_alloc (abfd, p - symdef->name + 1);
+              /* First check with only one `@'.  */
+              len = strlen (symdef->name);
+              copy = bfd_alloc (abfd, (bfd_size_type) len);
               if (copy == NULL)
                 goto error_return;
-              memcpy (copy, symdef->name, p - symdef->name);
-              copy[p - symdef->name] = '\0';
+              first = p - symdef->name + 1;
+              memcpy (copy, symdef->name, first);
+              memcpy (copy + first, symdef->name + first + 1, len - first);
 
               h = elf_link_hash_lookup (elf_hash_table (info), copy,
-                                        false, false, false);
+                                        FALSE, FALSE, FALSE);
+
+              if (h == NULL)
+                {
+                  /* We also need to check references to the symbol
+                     without the version.  */
+
+                  copy[first - 1] = '\0';
+                  h = elf_link_hash_lookup (elf_hash_table (info),
+                                            copy, FALSE, FALSE, FALSE);
+                }
 
               bfd_release (abfd, copy);
@@ -358 +381 @@
             {
               if (h->root.type != bfd_link_hash_undefweak)
-                defined[i] = true;
+                defined[i] = TRUE;
               continue;
             }
@@ -396 +419 @@
              does make the code less efficient than it could be.  */
           if (undefs_tail != info->hash->undefs_tail)
-            loop = true;
+            loop = TRUE;
 
           /* Look backward to mark all symbols from this object file
@@ -403 +426 @@
           do
             {
-              included[mark] = true;
+              included[mark] = TRUE;
               if (mark == 0)
                 break;
@@ -420 +443 @@
   free (included);
 
-  return true;
+  return TRUE;
 
  error_return:
-  if (defined != (boolean *) NULL)
+  if (defined != (bfd_boolean *) NULL)
     free (defined);
-  if (included != (boolean *) NULL)
+  if (included != (bfd_boolean *) NULL)
     free (included);
-  return false;
+  return FALSE;
 }
 
@@ -442 +465 @@
    a shared object.  */
 
-static boolean
-elf_merge_symbol (abfd, info, name, sym, psec, pvalue, sym_hash,
+static bfd_boolean
+elf_merge_symbol (abfd, info, name, sym, psec, pvalue, sym_hash, skip,
                   override, type_change_ok, size_change_ok, dt_needed)
      bfd *abfd;
@@ -452 +475 @@
      bfd_vma *pvalue;
      struct elf_link_hash_entry **sym_hash;
-     boolean *override;
-     boolean *type_change_ok;
-     boolean *size_change_ok;
-     boolean dt_needed;
+     bfd_boolean *skip;
+     bfd_boolean *override;
+     bfd_boolean *type_change_ok;
+     bfd_boolean *size_change_ok;
+     bfd_boolean dt_needed;
 {
   asection *sec;
   struct elf_link_hash_entry *h;
+  struct elf_link_hash_entry *flip;
   int bind;
   bfd *oldbfd;
-  boolean newdyn, olddyn, olddef, newdef, newdyncommon, olddyncommon;
-
-  *override = false;
+  bfd_boolean newdyn, olddyn, olddef, newdef, newdyncommon, olddyncommon;
+  bfd_boolean newweakdef, oldweakdef, newweakundef, oldweakundef;
+
+  *skip = FALSE;
+  *override = FALSE;
 
   sec = *psec;
@@ -469 +496 @@
 
   if (! bfd_is_und_section (sec))
-    h = elf_link_hash_lookup (elf_hash_table (info), name, true, false, false);
+    h = elf_link_hash_lookup (elf_hash_table (info), name, TRUE, FALSE, FALSE);
   else
     h = ((struct elf_link_hash_entry *)
-         bfd_wrapped_link_hash_lookup (abfd, info, name, true, false, false));
+         bfd_wrapped_link_hash_lookup (abfd, info, name, TRUE, FALSE, FALSE));
   if (h == NULL)
-    return false;
+    return FALSE;
   *sym_hash = h;
 
@@ -480 +507 @@
      if we are doing an ELF link.  */
   if (info->hash->creator != abfd->xvec)
-    return true;
+    return TRUE;
 
   /* For merging, we only care about real symbols.  */
@@ -495 +522 @@
     {
       h->elf_link_hash_flags &=~ ELF_LINK_NON_ELF;
-      return true;
+      return TRUE;
     }
 
@@ -530 +557 @@
       && ((abfd->flags & DYNAMIC) == 0
           || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0))
-    return true;
+    return TRUE;
 
   /* NEWDYN and OLDDYN indicate whether the new or old symbol,
@@ -536 +563 @@
 
   if ((abfd->flags & DYNAMIC) != 0)
-    newdyn = true;
+    newdyn = TRUE;
   else
-    newdyn = false;
+    newdyn = FALSE;
 
   if (oldbfd != NULL)
@@ -547 +574 @@
 
       /* This code handles the special SHN_MIPS_{TEXT,DATA} section
-         indices used by MIPS ELF.  */
+         indices used by MIPS ELF.  */
       switch (h->root.type)
         {
@@ -565 +592 @@
 
       if (hsec == NULL)
-        olddyn = false;
+        olddyn = FALSE;
       else
         olddyn = (hsec->symbol->flags & BSF_DYNAMIC) != 0;
@@ -574 +601 @@
 
   if (bfd_is_und_section (sec) || bfd_is_com_section (sec))
-    newdef = false;
+    newdef = FALSE;
   else
-    newdef = true;
+    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;
+    olddef = FALSE;
   else
-    olddef = true;
+    olddef = TRUE;
+
+  /* We need to rememeber if a symbol has a definition in a dynamic
+     object or is weak in all dynamic objects. Internal and hidden
+     visibility will make it unavailable to dynamic objects.  */
+  if (newdyn && (h->elf_link_hash_flags & ELF_LINK_DYNAMIC_DEF) == 0)
+    {
+      if (!bfd_is_und_section (sec))
+        h->elf_link_hash_flags |= ELF_LINK_DYNAMIC_DEF;
+      else
+        {
+          /* Check if this symbol is weak in all dynamic objects. If it
+             is the first time we see it in a dynamic object, we mark
+             if it is weak. Otherwise, we clear it.  */
+          if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
+            { 
+              if (bind == STB_WEAK)
+                h->elf_link_hash_flags |= ELF_LINK_DYNAMIC_WEAK;
+            }
+          else if (bind != STB_WEAK)
+            h->elf_link_hash_flags &= ~ELF_LINK_DYNAMIC_WEAK;
+        }
+    }
+
+  /* If the old symbol has non-default visibility, we ignore the new
+     definition from a dynamic object.  */
+  if (newdyn
+      && ELF_ST_VISIBILITY (h->other)
+      && !bfd_is_und_section (sec))
+    {
+      *skip = TRUE;
+      /* Make sure this symbol is dynamic.  */
+      h->elf_link_hash_flags |= ELF_LINK_HASH_REF_DYNAMIC;
+      /* A protected symbol has external availability. Make sure it is
+         recorded as dynamic.
+
+         FIXME: Should we check type and size for protected symbol?  */
+      if (ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
+        return _bfd_elf_link_record_dynamic_symbol (info, h);
+      else
+        return TRUE;
+    }
+  else if (!newdyn
+           && ELF_ST_VISIBILITY (sym->st_other)
+           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0)
+    {
+      /* If the new symbol with non-default visibility comes from a
+         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;
+      h->root.type = bfd_link_hash_new;
+      h->root.u.undef.abfd = NULL;
+      if (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC)
+        {
+          h->elf_link_hash_flags &= ~ELF_LINK_HASH_DEF_DYNAMIC;
+          h->elf_link_hash_flags |= (ELF_LINK_HASH_REF_DYNAMIC
+                                     | ELF_LINK_DYNAMIC_DEF);
+        }
+      /* FIXME: Should we check type and size for protected symbol?  */
+      h->size = 0;
+      h->type = 0;
+      return TRUE;
+    }
+
+  /* We need to treat weak definiton right, depending on if there is a
+     definition from a dynamic object.  */
+  if (bind == STB_WEAK)
+    {
+      if (olddef)
+        {
+           newweakdef = TRUE;
+           newweakundef = FALSE;
+        }
+      else
+        {
+           newweakdef = FALSE;
+           newweakundef = TRUE;
+        }
+    }
+  else
+    newweakdef = newweakundef = FALSE;
+
+  /* If the new weak definition comes from a relocatable file and the
+     old symbol comes from a dynamic object, we treat the new one as
+     strong.  */
+  if (newweakdef && !newdyn && olddyn)
+    newweakdef = FALSE;
+
+  if (h->root.type == bfd_link_hash_defweak)
+    {
+      oldweakdef = TRUE;
+      oldweakundef = FALSE;
+    }
+  else if (h->root.type == bfd_link_hash_undefweak)
+    {
+      oldweakdef = FALSE;
+      oldweakundef = TRUE;
+    }
+  else
+    oldweakdef = oldweakundef = FALSE;
+
+  /* If the old weak definition comes from a relocatable file and the
+     new symbol comes from a dynamic object, we treat the old one as
+     strong.  */
+  if (oldweakdef && !olddyn && newdyn)
+    oldweakdef = FALSE;
 
   /* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old
@@ -613 +746 @@
       && (sec->flags & SEC_LOAD) == 0
       && sym->st_size > 0
-      && bind != STB_WEAK
+      && !newweakdef
+      && !newweakundef
       && ELF_ST_TYPE (sym->st_info) != STT_FUNC)
-    newdyncommon = true;
+    newdyncommon = TRUE;
   else
-    newdyncommon = false;
+    newdyncommon = FALSE;
 
   if (olddyn
@@ -627 +761 @@
       && h->size > 0
       && h->type != STT_FUNC)
-    olddyncommon = true;
+    olddyncommon = TRUE;
   else
-    olddyncommon = false;
+    olddyncommon = FALSE;
 
   /* It's OK to change the type if either the existing symbol or the
@@ -636 +770 @@
      required at the run time.  */
 
-  if ((! dt_needed && h->root.type == bfd_link_hash_defweak)
-      || h->root.type == bfd_link_hash_undefweak
-      || bind == STB_WEAK)
-    *type_change_ok = true;
+  if ((! dt_needed && oldweakdef)
+      || oldweakundef
+      || newweakdef
+      || newweakundef)
+    *type_change_ok = TRUE;
 
   /* It's OK to change the size if either the existing symbol or the
@@ -646 +781 @@
   if (*type_change_ok
       || h->root.type == bfd_link_hash_undefined)
-    *size_change_ok = true;
+    *size_change_ok = TRUE;
 
   /* If both the old and the new symbols look like common symbols in a
@@ -657 +792 @@
     {
       /* Since we think we have two common symbols, issue a multiple
-         common warning if desired.  Note that we only warn if the
-         size is different.  If the size is the same, we simply let
-         the old symbol override the new one as normally happens with
-         symbols defined in dynamic objects.  */
+         common warning if desired.  Note that we only warn if the
+         size is different.  If the size is the same, we simply let
+         the old symbol override the new one as normally happens with
+         symbols defined in dynamic objects.  */
 
       if (! ((*info->callbacks->multiple_common)
              (info, h->root.root.string, oldbfd, bfd_link_hash_common,
               h->size, abfd, bfd_link_hash_common, sym->st_size)))
-        return false;
+        return FALSE;
 
       if (sym->st_size > h->size)
         h->size = sym->st_size;
 
-      *size_change_ok = true;
+      *size_change_ok = TRUE;
     }
 
@@ -696 +831 @@
       && (olddef
           || (h->root.type == bfd_link_hash_common
-              && (bind == STB_WEAK
+              && (newweakdef
+                  || newweakundef
                   || ELF_ST_TYPE (sym->st_info) == STT_FUNC)))
-      && (h->root.type != bfd_link_hash_defweak
+      && (!oldweakdef
           || dt_needed
-          || bind == STB_WEAK))
-    {
-      *override = true;
-      newdef = false;
-      newdyncommon = false;
+          || newweakdef
+          || newweakundef))
+    {
+      *override = TRUE;
+      newdef = FALSE;
+      newdyncommon = FALSE;
 
       *psec = sec = bfd_und_section_ptr;
-      *size_change_ok = true;
+      *size_change_ok = TRUE;
 
       /* If we get here when the old symbol is a common symbol, then
-         we are explicitly letting it override a weak symbol or
-         function in a dynamic object, and we don't want to warn about
-         a type change.  If the old symbol is a defined symbol, a type
-         change warning may still be appropriate.  */
+         we are explicitly letting it override a weak symbol or
+         function in a dynamic object, and we don't want to warn about
+         a type change.  If the old symbol is a defined symbol, a type
+         change warning may still be appropriate.  */
 
       if (h->root.type == bfd_link_hash_common)
-        *type_change_ok = true;
+        *type_change_ok = TRUE;
     }
 
@@ -728 +865 @@
       && h->root.type == bfd_link_hash_common)
     {
-      *override = true;
-      newdef = false;
-      newdyncommon = false;
+      *override = TRUE;
+      newdef = FALSE;
+      newdyncommon = FALSE;
       *pvalue = sym->st_size;
       *psec = sec = bfd_com_section_ptr;
-      *size_change_ok = true;
+      *size_change_ok = TRUE;
     }
 
@@ -749 +886 @@
      override a weak definition in a regular object.  */
 
+  flip = NULL;
   if (! newdyn
       && (newdef
           || (bfd_is_com_section (sec)
-              && (h->root.type == bfd_link_hash_defweak
-                  || h->type == STT_FUNC)))
+              && (oldweakdef || h->type == STT_FUNC)))
       && olddyn
       && olddef
       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
-      && (bind != STB_WEAK
-          || h->root.type == bfd_link_hash_defweak))
+      && ((!newweakdef && !newweakundef) || oldweakdef))
     {
       /* Change the hash table entry to undefined, and let
@@ -766 +902 @@
       h->root.type = bfd_link_hash_undefined;
       h->root.u.undef.abfd = h->root.u.def.section->owner;
-      *size_change_ok = true;
-
-      olddef = false;
-      olddyncommon = false;
+      *size_change_ok = TRUE;
+
+      olddef = FALSE;
+      olddyncommon = FALSE;
 
       /* We again permit a type change when a common symbol may be
-         overriding a function.  */
+         overriding a function.  */
 
       if (bfd_is_com_section (sec))
-        *type_change_ok = true;
-
-      /* This union may have been set to be non-NULL when this symbol
-         was seen in a dynamic object.  We must force the union to be
-         NULL, so that it is correct for a regular symbol.  */
-
-      h->verinfo.vertree = NULL;
-
-      /* In this special case, if H is the target of an indirection,
-         we want the caller to frob with H rather than with the
-         indirect symbol.  That will permit the caller to redefine the
-         target of the indirection, rather than the indirect symbol
-         itself.  FIXME: This will break the -y option if we store a
-         symbol with a different name.  */
-      *sym_hash = h;
+        *type_change_ok = TRUE;
+
+      if ((*sym_hash)->root.type == bfd_link_hash_indirect)
+        flip = *sym_hash;
+      else
+        /* This union may have been set to be non-NULL when this symbol
+           was seen in a dynamic object.  We must force the union to be
+           NULL, so that it is correct for a regular symbol.  */
+        h->verinfo.vertree = NULL;
     }
 
@@ -808 +938 @@
              (info, h->root.root.string, oldbfd, bfd_link_hash_common,
               h->size, abfd, bfd_link_hash_common, sym->st_size)))
-        return false;
+        return FALSE;
 
       /* If the predumed common symbol in the dynamic object is
-         larger, pretend that the new symbol has its size.  */
+         larger, pretend that the new symbol has its size.  */
 
       if (h->size > *pvalue)
@@ -820 +950 @@
          the regular object.  */
 
-      olddef = false;
-      olddyncommon = false;
+      olddef = FALSE;
+      olddyncommon = FALSE;
 
       h->root.type = bfd_link_hash_undefined;
       h->root.u.undef.abfd = h->root.u.def.section->owner;
 
-      *size_change_ok = true;
-      *type_change_ok = true;
-
-      h->verinfo.vertree = NULL;
+      *size_change_ok = TRUE;
+      *type_change_ok = TRUE;
+
+      if ((*sym_hash)->root.type == bfd_link_hash_indirect)
+        flip = *sym_hash;
+      else
+        h->verinfo.vertree = NULL;
+    }
+
+  if (flip != NULL)
+    {
+      /* Handle the case where we had a versioned symbol in a dynamic
+         library and now find a definition in a normal object.  In this
+         case, we make the versioned symbol point to the normal one.  */
+      struct elf_backend_data *bed = get_elf_backend_data (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);
+      flip->root.u.undef.abfd = h->root.u.undef.abfd;
+      if (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC)
+        {
+          h->elf_link_hash_flags &= ~ELF_LINK_HASH_DEF_DYNAMIC;
+          flip->elf_link_hash_flags |= ELF_LINK_HASH_REF_DYNAMIC;
+        }
     }
 
@@ -839 +990 @@
   if (olddef
       && ! dt_needed
-      && h->root.type == bfd_link_hash_defweak
+      && oldweakdef
       && newdef
       && newdyn
-      && bind != STB_WEAK)
+      && !newweakdef
+      && !newweakundef)
     {
       /* To make this work we have to frob the flags so that the rest
-         of the code does not think we are using the regular
-         definition.  */
+         of the code does not think we are using the regular
+         definition.  */
       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
         h->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
@@ -855 +1007 @@
 
       /* If H is the target of an indirection, we want the caller to
-         use H rather than the indirect symbol.  Otherwise if we are
-         defining a new indirect symbol we will wind up attaching it
-         to the entry we are overriding.  */
+         use H rather than the indirect symbol.  Otherwise if we are
+         defining a new indirect symbol we will wind up attaching it
+         to the entry we are overriding.  */
       *sym_hash = h;
     }
@@ -863 +1015 @@
   /* Handle the special case of a non-weak definition in a shared
      object followed by a weak definition in a regular object.  In
-     this case we prefer to definition in the shared object.  To make
+     this case we prefer the definition in the shared object.  To make
      this work we have to tell the caller to not treat the new symbol
      as a definition.  */
   if (olddef
       && olddyn
-      && h->root.type != bfd_link_hash_defweak
+      && !oldweakdef
       && newdef
       && ! newdyn
-      && bind == STB_WEAK)
-    *override = true;
-
-  return true;
+      && (newweakdef || newweakundef))
+    *override = TRUE;
+
+  return TRUE;
 }
 
+/* This function is called to create an indirect symbol from the
+   default for the symbol with the default version if needed. The
+   symbol is described by H, NAME, SYM, PSEC, VALUE, and OVERRIDE.  We
+   set DYNSYM if the new indirect symbol is dynamic. DT_NEEDED
+   indicates if it comes from a DT_NEEDED entry of a shared object.  */
+
+static bfd_boolean
+elf_add_default_symbol (abfd, info, h, name, sym, psec, value,
+                        dynsym, override, dt_needed)
+     bfd *abfd;
+     struct bfd_link_info *info;
+     struct elf_link_hash_entry *h;
+     const char *name;
+     Elf_Internal_Sym *sym;
+     asection **psec;
+     bfd_vma *value;
+     bfd_boolean *dynsym;
+     bfd_boolean override;
+     bfd_boolean dt_needed;
+{
+  bfd_boolean type_change_ok;
+  bfd_boolean size_change_ok;
+  bfd_boolean skip;
+  char *shortname;
+  struct elf_link_hash_entry *hi;
+  struct bfd_link_hash_entry *bh;
+  struct elf_backend_data *bed;
+  bfd_boolean collect;
+  bfd_boolean dynamic;
+  char *p;
+  size_t len, shortlen;
+  asection *sec;
+
+  /* If this symbol has a version, and it is the default version, we
+     create an indirect symbol from the default name to the fully
+     decorated name.  This will cause external references which do not
+     specify a version to be bound to this version of the symbol.  */
+  p = strchr (name, ELF_VER_CHR);
+  if (p == NULL || p[1] != ELF_VER_CHR)
+    return TRUE;
+
+  if (override)
+    {
+      /* We are overridden by an old defition. We need to check if we
+         need to create the indirect symbol from the default name.  */
+      hi = elf_link_hash_lookup (elf_hash_table (info), name, TRUE,
+                                 FALSE, FALSE);
+      BFD_ASSERT (hi != NULL);
+      if (hi == h)
+        return TRUE;
+      while (hi->root.type == bfd_link_hash_indirect
+             || hi->root.type == bfd_link_hash_warning)
+        {
+          hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
+          if (hi == h)
+            return TRUE;
+        }
+    }
+
+  bed = get_elf_backend_data (abfd);
+  collect = bed->collect;
+  dynamic = (abfd->flags & DYNAMIC) != 0;
+
+  shortlen = p - name;
+  shortname = bfd_hash_allocate (&info->hash->table, shortlen + 1);
+  if (shortname == NULL)
+    return FALSE;
+  memcpy (shortname, name, shortlen);
+  shortname[shortlen] = '\0';
+
+  /* We are going to create a new symbol.  Merge it with any existing
+     symbol with this name.  For the purposes of the merge, act as
+     though we were defining the symbol we just defined, although we
+     actually going to define an indirect symbol.  */
+  type_change_ok = FALSE;
+  size_change_ok = FALSE;
+  sec = *psec;
+  if (! elf_merge_symbol (abfd, info, shortname, sym, &sec, value,
+                          &hi, &skip, &override, &type_change_ok,
+                          &size_change_ok, dt_needed))
+    return FALSE;
+
+  if (skip)
+    goto nondefault;
+
+  if (! override)
+    {
+      bh = &hi->root;
+      if (! (_bfd_generic_link_add_one_symbol
+             (info, abfd, shortname, BSF_INDIRECT, bfd_ind_section_ptr,
+              (bfd_vma) 0, name, FALSE, collect, &bh)))
+        return FALSE;
+      hi = (struct elf_link_hash_entry *) bh;
+    }
+  else
+    {
+      /* In this case the symbol named SHORTNAME is overriding the
+         indirect symbol we want to add.  We were planning on making
+         SHORTNAME an indirect symbol referring to NAME.  SHORTNAME
+         is the name without a version.  NAME is the fully versioned
+         name, and it is the default version.
+
+         Overriding means that we already saw a definition for the
+         symbol SHORTNAME in a regular object, and it is overriding
+         the symbol defined in the dynamic object.
+
+         When this happens, we actually want to change NAME, the
+         symbol we just added, to refer to SHORTNAME.  This will cause
+         references to NAME in the shared object to become references
+         to SHORTNAME in the regular object.  This is what we expect
+         when we override a function in a shared object: that the
+         references in the shared object will be mapped to the
+         definition in the regular object.  */
+
+      while (hi->root.type == bfd_link_hash_indirect
+             || hi->root.type == bfd_link_hash_warning)
+        hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
+
+      h->root.type = bfd_link_hash_indirect;
+      h->root.u.i.link = (struct bfd_link_hash_entry *) hi;
+      if (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC)
+        {
+          h->elf_link_hash_flags &=~ ELF_LINK_HASH_DEF_DYNAMIC;
+          hi->elf_link_hash_flags |= ELF_LINK_HASH_REF_DYNAMIC;
+          if (hi->elf_link_hash_flags
+              & (ELF_LINK_HASH_REF_REGULAR
+                 | ELF_LINK_HASH_DEF_REGULAR))
+            {
+              if (! _bfd_elf_link_record_dynamic_symbol (info, hi))
+                return FALSE;
+            }
+        }
+
+      /* Now set HI to H, so that the following code will set the
+         other fields correctly.  */
+      hi = h;
+    }
+
+  /* If there is a duplicate definition somewhere, then HI may not
+     point to an indirect symbol.  We will have reported an error to
+     the user in that case.  */
+
+  if (hi->root.type == bfd_link_hash_indirect)
+    {
+      struct elf_link_hash_entry *ht;
+
+      /* If the symbol became indirect, then we assume that we have
+         not seen a definition before.  */
+      BFD_ASSERT ((hi->elf_link_hash_flags
+                   & (ELF_LINK_HASH_DEF_DYNAMIC
+                      | ELF_LINK_HASH_DEF_REGULAR)) == 0);
+
+      ht = (struct elf_link_hash_entry *) hi->root.u.i.link;
+      (*bed->elf_backend_copy_indirect_symbol) (bed, ht, hi);
+
+      /* See if the new flags lead us to realize that the symbol must
+         be dynamic.  */
+      if (! *dynsym)
+        {
+          if (! dynamic)
+            {
+              if (info->shared
+                  || ((hi->elf_link_hash_flags
+                       & ELF_LINK_HASH_REF_DYNAMIC) != 0))
+                *dynsym = TRUE;
+            }
+          else
+            {
+              if ((hi->elf_link_hash_flags
+                   & ELF_LINK_HASH_REF_REGULAR) != 0)
+                *dynsym = TRUE;
+            }
+        }
+    }
+
+  /* We also need to define an indirection from the nondefault version
+     of the symbol.  */
+
+nondefault:
+  len = strlen (name);
+  shortname = bfd_hash_allocate (&info->hash->table, len);
+  if (shortname == NULL)
+    return FALSE;
+  memcpy (shortname, name, shortlen);
+  memcpy (shortname + shortlen, p + 1, len - shortlen);
+
+  /* Once again, merge with any existing symbol.  */
+  type_change_ok = FALSE;
+  size_change_ok = FALSE;
+  sec = *psec;
+  if (! elf_merge_symbol (abfd, info, shortname, sym, &sec, value,
+                          &hi, &skip, &override, &type_change_ok,
+                          &size_change_ok, dt_needed))
+    return FALSE;
+
+  if (skip)
+    return TRUE;
+
+  if (override)
+    {
+      /* Here SHORTNAME is a versioned name, so we don't expect to see
+         the type of override we do in the case above unless it is
+         overridden by a versioned definiton.  */
+      if (hi->root.type != bfd_link_hash_defined
+          && hi->root.type != bfd_link_hash_defweak)
+        (*_bfd_error_handler)
+          (_("%s: warning: unexpected redefinition of indirect versioned symbol `%s'"),
+           bfd_archive_filename (abfd), shortname);
+    }
+  else
+    {
+      bh = &hi->root;
+      if (! (_bfd_generic_link_add_one_symbol
+             (info, abfd, shortname, BSF_INDIRECT,
+              bfd_ind_section_ptr, (bfd_vma) 0, name, FALSE, collect, &bh)))
+        return FALSE;
+      hi = (struct elf_link_hash_entry *) bh;
+
+      /* If there is a duplicate definition somewhere, then HI may not
+         point to an indirect symbol.  We will have reported an error
+         to the user in that case.  */
+
+      if (hi->root.type == bfd_link_hash_indirect)
+        {
+          /* If the symbol became indirect, then we assume that we have
+             not seen a definition before.  */
+          BFD_ASSERT ((hi->elf_link_hash_flags
+                       & (ELF_LINK_HASH_DEF_DYNAMIC
+                          | ELF_LINK_HASH_DEF_REGULAR)) == 0);
+
+          (*bed->elf_backend_copy_indirect_symbol) (bed, h, hi);
+
+          /* See if the new flags lead us to realize that the symbol
+             must be dynamic.  */
+          if (! *dynsym)
+            {
+              if (! dynamic)
+                {
+                  if (info->shared
+                      || ((hi->elf_link_hash_flags
+                           & ELF_LINK_HASH_REF_DYNAMIC) != 0))
+                    *dynsym = TRUE;
+                }
+              else
+                {
+                  if ((hi->elf_link_hash_flags
+                       & ELF_LINK_HASH_REF_REGULAR) != 0)
+                    *dynsym = TRUE;
+                }
+            }
+        }
+    }
+
+  return TRUE;
+}
+
 /* Add symbols from an ELF object file to the linker hash table.  */
 
-static boolean
+static bfd_boolean
 elf_link_add_object_symbols (abfd, info)
      bfd *abfd;
      struct bfd_link_info *info;
 {
-  boolean (*add_symbol_hook) PARAMS ((bfd *, struct bfd_link_info *,
-                                      const Elf_Internal_Sym *,
-                                      const char **, flagword *,
-                                      asection **, bfd_vma *));
-  boolean (*check_relocs) PARAMS ((bfd *, struct bfd_link_info *,
-                                   asection *, const Elf_Internal_Rela *));
-  boolean collect;
+  bfd_boolean (*add_symbol_hook)
+    PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
+             const char **, flagword *, asection **, bfd_vma *));
+  bfd_boolean (*check_relocs)
+    PARAMS ((bfd *, struct bfd_link_info *, asection *,
+             const Elf_Internal_Rela *));
+  bfd_boolean collect;
   Elf_Internal_Shdr *hdr;
-  size_t symcount;
-  size_t extsymcount;
-  size_t extsymoff;
-  Elf_External_Sym *buf = NULL;
+  bfd_size_type symcount;
+  bfd_size_type extsymcount;
+  bfd_size_type extsymoff;
   struct elf_link_hash_entry **sym_hash;
-  boolean dynamic;
+  bfd_boolean dynamic;
   Elf_External_Versym *extversym = NULL;
   Elf_External_Versym *ever;
-  Elf_External_Dyn *dynbuf = NULL;
   struct elf_link_hash_entry *weaks;
-  Elf_External_Sym *esym;
-  Elf_External_Sym *esymend;
+  struct elf_link_hash_entry **nondeflt_vers = NULL;
+  bfd_size_type nondeflt_vers_cnt = 0;
+  Elf_Internal_Sym *isymbuf = NULL;
+  Elf_Internal_Sym *isym;
+  Elf_Internal_Sym *isymend;
   struct elf_backend_data *bed;
-  boolean dt_needed;
+  bfd_boolean dt_needed;
+  struct elf_link_hash_table * hash_table;
+  bfd_size_type amt;
+
+  hash_table = elf_hash_table (info);
 
   bed = get_elf_backend_data (abfd);
@@ -912 +1325 @@
 
   if ((abfd->flags & DYNAMIC) == 0)
-    dynamic = false;
+    dynamic = FALSE;
   else
     {
-      dynamic = true;
+      dynamic = TRUE;
 
       /* You can't use -r against a dynamic object.  Also, there's no
@@ -960 +1373 @@
                   struct elf_link_hash_entry *h;
 
-                  h = elf_link_hash_lookup (elf_hash_table (info), name,
-                                            false, false, true);
+                  h = elf_link_hash_lookup (hash_table, name,
+                                            FALSE, FALSE, TRUE);
 
                   /* FIXME: What about bfd_link_hash_common?  */
@@ -969 +1382 @@
                     {
                       /* We don't want to issue this warning.  Clobber
-                         the section size so that the warning does not
-                         get copied into the output file.  */
+                         the section size so that the warning does not
+                         get copied into the output file.  */
                       s->_raw_size = 0;
                       continue;
@@ -988 +1401 @@
               if (! (_bfd_generic_link_add_one_symbol
                      (info, abfd, name, BSF_WARNING, s, (bfd_vma) 0, msg,
-                      false, collect, (struct bfd_link_hash_entry **) NULL)))
+                      FALSE, collect, (struct bfd_link_hash_entry **) NULL)))
                 goto error_return;
 
@@ -994 +1407 @@
                 {
                   /* Clobber the section size so that the warning does
-                     not get copied into the output file.  */
+                     not get copied into the output file.  */
                   s->_raw_size = 0;
                 }
@@ -1001 +1414 @@
     }
 
-  /* If this is a dynamic object, we always link against the .dynsym
-     symbol table, not the .symtab symbol table.  The dynamic linker
-     will only see the .dynsym symbol table, so there is no reason to
-     look at .symtab for a dynamic object.  */
-
-  if (! dynamic || elf_dynsymtab (abfd) == 0)
-    hdr = &elf_tdata (abfd)->symtab_hdr;
-  else
-    hdr = &elf_tdata (abfd)->dynsymtab_hdr;
-
-  if (dynamic)
-    {
-      /* Read in any version definitions.  */
-
-      if (! _bfd_elf_slurp_version_tables (abfd))
-        goto error_return;
-
-      /* Read in the symbol versions, but don't bother to convert them
-         to internal format.  */
-      if (elf_dynversym (abfd) != 0)
-        {
-          Elf_Internal_Shdr *versymhdr;
-
-          versymhdr = &elf_tdata (abfd)->dynversym_hdr;
-          extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size);
-          if (extversym == NULL)
-            goto error_return;
-          if (bfd_seek (abfd, versymhdr->sh_offset, SEEK_SET) != 0
-              || (bfd_read ((PTR) extversym, 1, versymhdr->sh_size, abfd)
-                  != versymhdr->sh_size))
-            goto error_return;
-        }
-    }
-
-  symcount = hdr->sh_size / sizeof (Elf_External_Sym);
-
-  /* The sh_info field of the symtab header tells us where the
-     external symbols start.  We don't care about the local symbols at
-     this point.  */
-  if (elf_bad_symtab (abfd))
-    {
-      extsymcount = symcount;
-      extsymoff = 0;
-    }
-  else
-    {
-      extsymcount = symcount - hdr->sh_info;
-      extsymoff = hdr->sh_info;
-    }
-
-  buf = ((Elf_External_Sym *)
-         bfd_malloc (extsymcount * sizeof (Elf_External_Sym)));
-  if (buf == NULL && extsymcount != 0)
-    goto error_return;
-
-  /* We store a pointer to the hash table entry for each external
-     symbol.  */
-  sym_hash = ((struct elf_link_hash_entry **)
-              bfd_alloc (abfd,
-                         extsymcount * sizeof (struct elf_link_hash_entry *)));
-  if (sym_hash == NULL)
-    goto error_return;
-  elf_sym_hashes (abfd) = sym_hash;
-
-  dt_needed = false;
-
+  dt_needed = FALSE;
   if (! dynamic)
     {
       /* If we are creating a shared library, create all the dynamic
-         sections immediately.  We need to attach them to something,
-         so we attach them to this BFD, provided it is the right
-         format.  FIXME: If there are no input BFD's of the same
-         format as the output, we can't make a shared library.  */
+         sections immediately.  We need to attach them to something,
+         so we attach them to this BFD, provided it is the right
+         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
-          && ! elf_hash_table (info)->dynamic_sections_created
+          && is_elf_hash_table (info)
+          && ! hash_table->dynamic_sections_created
           && abfd->xvec == info->hash->creator)
         {
@@ -1082 +1431 @@
         }
     }
+  else if (! is_elf_hash_table (info))
+    goto error_return;
   else
     {
       asection *s;
-      boolean add_needed;
+      bfd_boolean add_needed;
       const char *name;
       bfd_size_type oldsize;
       bfd_size_type strindex;
+      struct bfd_link_needed_list *rpath = NULL, *runpath = NULL;
+
+      /* 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.  */
+      if ((s = abfd->sections) != NULL
+          && s->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
+        goto error_return;
 
       /* Find the name to use in a DT_NEEDED entry that refers to this
@@ -1097 +1456 @@
          elf_dt_name, we don't make a DT_NEEDED entry at all, even if
          there is a DT_SONAME entry.  */
-      add_needed = true;
+      add_needed = TRUE;
       name = bfd_get_filename (abfd);
       if (elf_dt_name (abfd) != NULL)
@@ -1105 +1464 @@
             {
               if (elf_dt_soname (abfd) != NULL)
-                dt_needed = true;
-
-              add_needed = false;
+                dt_needed = TRUE;
+
+              add_needed = FALSE;
             }
         }
@@ -1113 +1472 @@
       if (s != NULL)
         {
+          Elf_External_Dyn *dynbuf = NULL;
           Elf_External_Dyn *extdyn;
           Elf_External_Dyn *extdynend;
           int elfsec;
-          unsigned long link;
-          int rpath;
-          int runpath;
-
-          dynbuf = (Elf_External_Dyn *) bfd_malloc ((size_t) s->_raw_size);
+          unsigned long shlink;
+
+          dynbuf = (Elf_External_Dyn *) bfd_malloc (s->_raw_size);
           if (dynbuf == NULL)
             goto error_return;
@@ -1126 +1484 @@
           if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf,
                                           (file_ptr) 0, s->_raw_size))
-            goto error_return;
+            goto error_free_dyn;
 
           elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
           if (elfsec == -1)
-            goto error_return;
-          link = elf_elfsections (abfd)[elfsec]->sh_link;
-
-          {
-            /* The shared libraries distributed with hpux11 have a bogus
-               sh_link field for the ".dynamic" section.  This code detects
-               when LINK refers to a section that is not a string table and
-               tries to find the string table for the ".dynsym" section
-               instead.  */
-            Elf_Internal_Shdr *hdr = elf_elfsections (abfd)[link];
-            if (hdr->sh_type != SHT_STRTAB)
-              {
-                asection *s = bfd_get_section_by_name (abfd, ".dynsym");
-                int elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
-                if (elfsec == -1)
-                  goto error_return;
-                link = elf_elfsections (abfd)[elfsec]->sh_link;
-              }
-          }
+            goto error_free_dyn;
+          shlink = elf_elfsections (abfd)[elfsec]->sh_link;
 
           extdyn = dynbuf;
           extdynend = extdyn + s->_raw_size / sizeof (Elf_External_Dyn);
-          rpath = 0;
-          runpath = 0;
           for (; extdyn < extdynend; extdyn++)
             {
@@ -1161 +1500 @@
               if (dyn.d_tag == DT_SONAME)
                 {
-                  name = bfd_elf_string_from_elf_section (abfd, link,
-                                                          dyn.d_un.d_val);
+                  unsigned int tagv = dyn.d_un.d_val;
+                  name = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
                   if (name == NULL)
-                    goto error_return;
+                    goto error_free_dyn;
                 }
               if (dyn.d_tag == DT_NEEDED)
@@ -1170 +1509 @@
                   struct bfd_link_needed_list *n, **pn;
                   char *fnm, *anm;
-
-                  n = ((struct bfd_link_needed_list *)
-                       bfd_alloc (abfd, sizeof (struct bfd_link_needed_list)));
-                  fnm = bfd_elf_string_from_elf_section (abfd, link,
-                                                         dyn.d_un.d_val);
+                  unsigned int tagv = dyn.d_un.d_val;
+
+                  amt = sizeof (struct bfd_link_needed_list);
+                  n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
+                  fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
                   if (n == NULL || fnm == NULL)
-                    goto error_return;
-                  anm = bfd_alloc (abfd, strlen (fnm) + 1);
+                    goto error_free_dyn;
+                  amt = strlen (fnm) + 1;
+                  anm = bfd_alloc (abfd, amt);
                   if (anm == NULL)
-                    goto error_return;
-                  strcpy (anm, fnm);
+                    goto error_free_dyn;
+                  memcpy (anm, fnm, (size_t) amt);
                   n->name = anm;
                   n->by = abfd;
                   n->next = NULL;
-                  for (pn = &elf_hash_table (info)->needed;
+                  for (pn = & hash_table->needed;
                        *pn != NULL;
                        pn = &(*pn)->next)
@@ -1194 +1534 @@
                   struct bfd_link_needed_list *n, **pn;
                   char *fnm, *anm;
-
-                  /* When we see DT_RPATH before DT_RUNPATH, we have
-                     to clear runpath.  Do _NOT_ bfd_release, as that
-                     frees all more recently bfd_alloc'd blocks as
-                     well.  */
-                  if (rpath && elf_hash_table (info)->runpath)
-                    elf_hash_table (info)->runpath = NULL;
-
-                  n = ((struct bfd_link_needed_list *)
-                       bfd_alloc (abfd, sizeof (struct bfd_link_needed_list)));
-                  fnm = bfd_elf_string_from_elf_section (abfd, link,
-                                                         dyn.d_un.d_val);
+                  unsigned int tagv = dyn.d_un.d_val;
+
+                  amt = sizeof (struct bfd_link_needed_list);
+                  n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
+                  fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
                   if (n == NULL || fnm == NULL)
-                    goto error_return;
-                  anm = bfd_alloc (abfd, strlen (fnm) + 1);
+                    goto error_free_dyn;
+                  amt = strlen (fnm) + 1;
+                  anm = bfd_alloc (abfd, amt);
                   if (anm == NULL)
-                    goto error_return;
-                  strcpy (anm, fnm);
+                    goto error_free_dyn;
+                  memcpy (anm, fnm, (size_t) amt);
                   n->name = anm;
                   n->by = abfd;
                   n->next = NULL;
-                  for (pn = &elf_hash_table (info)->runpath;
+                  for (pn = & runpath;
                        *pn != NULL;
                        pn = &(*pn)->next)
                     ;
                   *pn = n;
-                  runpath = 1;
-                  rpath = 0;
                 }
               /* Ignore DT_RPATH if we have seen DT_RUNPATH.  */
               if (!runpath && dyn.d_tag == DT_RPATH)
-                {
+                {
                   struct bfd_link_needed_list *n, **pn;
                   char *fnm, *anm;
-
-                  n = ((struct bfd_link_needed_list *)
-                       bfd_alloc (abfd, sizeof (struct bfd_link_needed_list)));
-                  fnm = bfd_elf_string_from_elf_section (abfd, link,
-                                                         dyn.d_un.d_val);
+                  unsigned int tagv = dyn.d_un.d_val;
+
+                  amt = sizeof (struct bfd_link_needed_list);
+                  n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
+                  fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
                   if (n == NULL || fnm == NULL)
-                    goto error_return;
-                  anm = bfd_alloc (abfd, strlen (fnm) + 1);
+                    goto error_free_dyn;
+                  amt = strlen (fnm) + 1;
+                  anm = bfd_alloc (abfd, amt);
                   if (anm == NULL)
-                    goto error_return;
-                  strcpy (anm, fnm);
+                    {
+                    error_free_dyn:
+                      free (dynbuf);
+                      goto error_return;
+                    }
+                  memcpy (anm, fnm, (size_t) amt);
                   n->name = anm;
                   n->by = abfd;
                   n->next = NULL;
-                  for (pn = &elf_hash_table (info)->runpath;
+                  for (pn = & rpath;
                        *pn != NULL;
                        pn = &(*pn)->next)
                     ;
                   *pn = n;
-                  rpath = 1;
                 }
             }
 
           free (dynbuf);
-          dynbuf = NULL;
+        }
+
+      /* DT_RUNPATH overrides DT_RPATH.  Do _NOT_ bfd_release, as that
+         frees all more recently bfd_alloc'd blocks as well.  */
+      if (runpath)
+        rpath = runpath;
+
+      if (rpath)
+        {
+          struct bfd_link_needed_list **pn;
+          for (pn = & hash_table->runpath;
+               *pn != NULL;
+               pn = &(*pn)->next)
+            ;
+          *pn = rpath;
         }
 
@@ -1262 +1612 @@
          still implies that the section takes up space in the output
          file.  */
-      abfd->sections = NULL;
-      abfd->section_count = 0;
+      bfd_section_list_clear (abfd);
 
       /* If this is the first dynamic object found in the link, create
          the special sections required for dynamic linking.  */
-      if (! elf_hash_table (info)->dynamic_sections_created)
-        {
-          if (! elf_link_create_dynamic_sections (abfd, info))
-            goto error_return;
-        }
+      if (! hash_table->dynamic_sections_created)
+        if (! elf_link_create_dynamic_sections (abfd, info))
+          goto error_return;
 
       if (add_needed)
         {
           /* Add a DT_NEEDED entry for this dynamic object.  */
-          oldsize = _bfd_stringtab_size (elf_hash_table (info)->dynstr);
-          strindex = _bfd_stringtab_add (elf_hash_table (info)->dynstr, name,
-                                         true, false);
+          oldsize = _bfd_elf_strtab_size (hash_table->dynstr);
+          strindex = _bfd_elf_strtab_add (hash_table->dynstr, name, FALSE);
           if (strindex == (bfd_size_type) -1)
             goto error_return;
 
-          if (oldsize == _bfd_stringtab_size (elf_hash_table (info)->dynstr))
+          if (oldsize == _bfd_elf_strtab_size (hash_table->dynstr))
             {
               asection *sdyn;
@@ -1292 +1638 @@
                  link, just ignore it.  There is no reason to include
                  a particular dynamic object more than once.  */
-              sdyn = bfd_get_section_by_name (elf_hash_table (info)->dynobj,
-                                              ".dynamic");
+              sdyn = bfd_get_section_by_name (hash_table->dynobj, ".dynamic");
               BFD_ASSERT (sdyn != NULL);
 
@@ -1303 +1648 @@
                   Elf_Internal_Dyn dyn;
 
-                  elf_swap_dyn_in (elf_hash_table (info)->dynobj, dyncon,
-                                   &dyn);
+                  elf_swap_dyn_in (hash_table->dynobj, dyncon, & dyn);
                   if (dyn.d_tag == DT_NEEDED
                       && dyn.d_un.d_val == strindex)
                     {
-                      if (buf != NULL)
-                        free (buf);
-                      if (extversym != NULL)
-                        free (extversym);
-                      return true;
+                      _bfd_elf_strtab_delref (hash_table->dynstr, strindex);
+                      return TRUE;
                     }
                 }
             }
 
-          if (! elf_add_dynamic_entry (info, DT_NEEDED, strindex))
+          if (! elf_add_dynamic_entry (info, (bfd_vma) DT_NEEDED, strindex))
             goto error_return;
         }
 
       /* Save the SONAME, if there is one, because sometimes the
-         linker emulation code will need to know it.  */
+         linker emulation code will need to know it.  */
       if (*name == '\0')
-        name = bfd_get_filename (abfd);
+        name = basename (bfd_get_filename (abfd));
       elf_dt_name (abfd) = name;
     }
 
-  if (bfd_seek (abfd,
-                hdr->sh_offset + extsymoff * sizeof (Elf_External_Sym),
-                SEEK_SET) != 0
-      || (bfd_read ((PTR) buf, sizeof (Elf_External_Sym), extsymcount, abfd)
-          != extsymcount * sizeof (Elf_External_Sym)))
-    goto error_return;
+  /* If this is a dynamic object, we always link against the .dynsym
+     symbol table, not the .symtab symbol table.  The dynamic linker
+     will only see the .dynsym symbol table, so there is no reason to
+     look at .symtab for a dynamic object.  */
+
+  if (! dynamic || elf_dynsymtab (abfd) == 0)
+    hdr = &elf_tdata (abfd)->symtab_hdr;
+  else
+    hdr = &elf_tdata (abfd)->dynsymtab_hdr;
+
+  symcount = hdr->sh_size / sizeof (Elf_External_Sym);
+
+  /* The sh_info field of the symtab header tells us where the
+     external symbols start.  We don't care about the local symbols at
+     this point.  */
+  if (elf_bad_symtab (abfd))
+    {
+      extsymcount = symcount;
+      extsymoff = 0;
+    }
+  else
+    {
+      extsymcount = symcount - hdr->sh_info;
+      extsymoff = hdr->sh_info;
+    }
+
+  sym_hash = NULL;
+  if (extsymcount != 0)
+    {
+      isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
+                                      NULL, NULL, NULL);
+      if (isymbuf == NULL)
+        goto error_return;
+
+      /* We store a pointer to the hash table entry for each external
+         symbol.  */
+      amt = extsymcount * sizeof (struct elf_link_hash_entry *);
+      sym_hash = (struct elf_link_hash_entry **) bfd_alloc (abfd, amt);
+      if (sym_hash == NULL)
+        goto error_free_sym;
+      elf_sym_hashes (abfd) = sym_hash;
+    }
+
+  if (dynamic)
+    {
+      /* Read in any version definitions.  */
+      if (! _bfd_elf_slurp_version_tables (abfd))
+        goto error_free_sym;
+
+      /* Read in the symbol versions, but don't bother to convert them
+         to internal format.  */
+      if (elf_dynversym (abfd) != 0)
+        {
+          Elf_Internal_Shdr *versymhdr;
+
+          versymhdr = &elf_tdata (abfd)->dynversym_hdr;
+          extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size);
+          if (extversym == NULL)
+            goto error_free_sym;
+          amt = versymhdr->sh_size;
+          if (bfd_seek (abfd, versymhdr->sh_offset, SEEK_SET) != 0
+              || bfd_bread ((PTR) extversym, amt, abfd) != amt)
+            goto error_free_vers;
+        }
+    }
 
   weaks = NULL;
 
   ever = extversym != NULL ? extversym + extsymoff : NULL;
-  esymend = buf + extsymcount;
-  for (esym = buf;
-       esym < esymend;
-       esym++, sym_hash++, ever = (ever != NULL ? ever + 1 : NULL))
-    {
-      Elf_Internal_Sym sym;
+  for (isym = isymbuf, isymend = isymbuf + extsymcount;
+       isym < isymend;
+       isym++, sym_hash++, ever = (ever != NULL ? ever + 1 : NULL))
+    {
       int bind;
       bfd_vma value;
@@ -1350 +1748 @@
       const char *name;
       struct elf_link_hash_entry *h;
-      boolean definition;
-      boolean size_change_ok, type_change_ok;
-      boolean new_weakdef;
+      bfd_boolean definition;
+      bfd_boolean size_change_ok;
+      bfd_boolean type_change_ok;
+      bfd_boolean new_weakdef;
+      bfd_boolean override;
       unsigned int old_alignment;
-
-      elf_swap_symbol_in (abfd, esym, &sym);
+      bfd *old_bfd;
+
+      override = FALSE;
 
       flags = BSF_NO_FLAGS;
       sec = NULL;
-      value = sym.st_value;
+      value = isym->st_value;
       *sym_hash = NULL;
 
-      bind = ELF_ST_BIND (sym.st_info);
+      bind = ELF_ST_BIND (isym->st_info);
       if (bind == STB_LOCAL)
         {
@@ -1373 +1774 @@
       else if (bind == STB_GLOBAL)
         {
-          if (sym.st_shndx != SHN_UNDEF
-              && sym.st_shndx != SHN_COMMON)
+          if (isym->st_shndx != SHN_UNDEF
+              && isym->st_shndx != SHN_COMMON)
             flags = BSF_GLOBAL;
         }
@@ -1384 +1785 @@
         }
 
-      if (sym.st_shndx == SHN_UNDEF)
+      if (isym->st_shndx == SHN_UNDEF)
         sec = bfd_und_section_ptr;
-      else if (sym.st_shndx > 0 && sym.st_shndx < SHN_LORESERVE)
-        {
-          sec = section_from_elf_index (abfd, sym.st_shndx);
+      else if (isym->st_shndx < SHN_LORESERVE || isym->st_shndx > SHN_HIRESERVE)
+        {
+          sec = section_from_elf_index (abfd, isym->st_shndx);
           if (sec == NULL)
             sec = bfd_abs_section_ptr;
@@ -1394 +1795 @@
             value -= sec->vma;
         }
-      else if (sym.st_shndx == SHN_ABS)
+      else if (isym->st_shndx == SHN_ABS)
         sec = bfd_abs_section_ptr;
-      else if (sym.st_shndx == SHN_COMMON)
+      else if (isym->st_shndx == SHN_COMMON)
         {
           sec = bfd_com_section_ptr;
           /* What ELF calls the size we call the value.  What ELF
              calls the value we call the alignment.  */
-          value = sym.st_size;
+          value = isym->st_size;
         }
       else
@@ -1408 +1809 @@
         }
 
-      name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link, sym.st_name);
+      name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
+                                              isym->st_name);
       if (name == (const char *) NULL)
-        goto error_return;
-
-      if (add_symbol_hook)
-        {
-          if (! (*add_symbol_hook) (abfd, info, &sym, &name, &flags, &sec,
+        goto error_free_vers;
+
+      if (isym->st_shndx == SHN_COMMON
+          && ELF_ST_TYPE (isym->st_info) == STT_TLS)
+        {
+          asection *tcomm = bfd_get_section_by_name (abfd, ".tcommon");
+
+          if (tcomm == NULL)
+            {
+              tcomm = bfd_make_section (abfd, ".tcommon");
+              if (tcomm == NULL
+                  || !bfd_set_section_flags (abfd, tcomm, (SEC_ALLOC
+                                                           | SEC_IS_COMMON
+                                                           | SEC_LINKER_CREATED
+                                                           | SEC_THREAD_LOCAL)))
+                goto error_free_vers;
+            }
+          sec = tcomm;
+        }
+      else if (add_symbol_hook)
+        {
+          if (! (*add_symbol_hook) (abfd, info, isym, &name, &flags, &sec,
                                     &value))
-            goto error_return;
+            goto error_free_vers;
 
           /* The hook function sets the name to NULL if this symbol
@@ -1428 +1847 @@
         {
           bfd_set_error (bfd_error_bad_value);
-          goto error_return;
+          goto error_free_vers;
         }
 
       if (bfd_is_und_section (sec)
           || bfd_is_com_section (sec))
-        definition = false;
+        definition = FALSE;
       else
-        definition = true;
-
-      size_change_ok = false;
+        definition = TRUE;
+
+      size_change_ok = FALSE;
       type_change_ok = get_elf_backend_data (abfd)->type_change_ok;
       old_alignment = 0;
+      old_bfd = NULL;
+
       if (info->hash->creator->flavour == bfd_target_elf_flavour)
         {
           Elf_Internal_Versym iver;
           unsigned int vernum = 0;
-          boolean override;
+          bfd_boolean skip;
 
           if (ever != NULL)
@@ -1452 +1873 @@
 
               /* If this is a hidden symbol, or if it is not version
-                 1, we append the version name to the symbol name.
-                 However, we do not modify a non-hidden absolute
-                 symbol, because it might be the version symbol
-                 itself.  FIXME: What if it isn't?  */
+                 1, we append the version name to the symbol name.
+                 However, we do not modify a non-hidden absolute
+                 symbol, because it might be the version symbol
+                 itself.  FIXME: What if it isn't?  */
               if ((iver.vs_vers & VERSYM_HIDDEN) != 0
                   || (vernum > 1 && ! bfd_is_abs_section (sec)))
                 {
                   const char *verstr;
-                  int namelen, newlen;
+                  size_t namelen, verlen, newlen;
                   char *newname, *p;
 
-                  if (sym.st_shndx != SHN_UNDEF)
+                  if (isym->st_shndx != SHN_UNDEF)
                     {
                       if (vernum > elf_tdata (abfd)->dynverdef_hdr.sh_info)
@@ -1469 +1890 @@
                           (*_bfd_error_handler)
                             (_("%s: %s: invalid version %u (max %d)"),
-                             bfd_get_filename (abfd), name, vernum,
+                             bfd_archive_filename (abfd), name, vernum,
                              elf_tdata (abfd)->dynverdef_hdr.sh_info);
                           bfd_set_error (bfd_error_bad_value);
-                          goto error_return;
+                          goto error_free_vers;
                         }
                       else if (vernum > 1)
@@ -1510 +1931 @@
                           (*_bfd_error_handler)
                             (_("%s: %s: invalid needed version %d"),
-                             bfd_get_filename (abfd), name, vernum);
+                             bfd_archive_filename (abfd), name, vernum);
                           bfd_set_error (bfd_error_bad_value);
-                          goto error_return;
+                          goto error_free_vers;
                         }
                     }
 
                   namelen = strlen (name);
-                  newlen = namelen + strlen (verstr) + 2;
-                  if ((iver.vs_vers & VERSYM_HIDDEN) == 0)
+                  verlen = strlen (verstr);
+                  newlen = namelen + verlen + 2;
+                  if ((iver.vs_vers & VERSYM_HIDDEN) == 0
+                      && isym->st_shndx != SHN_UNDEF)
                     ++newlen;
 
-                  newname = (char *) bfd_alloc (abfd, newlen);
+                  newname = (char *) bfd_alloc (abfd, (bfd_size_type) newlen);
                   if (newname == NULL)
-                    goto error_return;
-                  strcpy (newname, name);
+                    goto error_free_vers;
+                  memcpy (newname, name, namelen);
                   p = newname + namelen;
                   *p++ = ELF_VER_CHR;
@@ -1531 +1954 @@
                      default version of the symbol.  */
                   if ((iver.vs_vers & VERSYM_HIDDEN) == 0
-                      && sym.st_shndx != SHN_UNDEF)
+                      && isym->st_shndx != SHN_UNDEF)
                     *p++ = ELF_VER_CHR;
-                  strcpy (p, verstr);
+                  memcpy (p, verstr, verlen + 1);
 
                   name = newname;
@@ -1539 +1962 @@
             }
 
-          if (! elf_merge_symbol (abfd, info, name, &sym, &sec, &value,
-                                  sym_hash, &override, &type_change_ok,
-                                  &size_change_ok, dt_needed))
-            goto error_return;
+          if (! elf_merge_symbol (abfd, info, name, isym, &sec, &value,
+                                  sym_hash, &skip, &override,
+                                  &type_change_ok, &size_change_ok,
+                                  dt_needed))
+            goto error_free_vers;
+
+          if (skip)
+            continue;
 
           if (override)
-            definition = false;
+            definition = FALSE;
 
           h = *sym_hash;
@@ -1553 +1980 @@
 
           /* Remember the old alignment if this is a common symbol, so
-             that we don't reduce the alignment later on.  We can't
-             check later, because _bfd_generic_link_add_one_symbol
-             will set a default for the alignment which we want to
-             override.  */
-          if (h->root.type == bfd_link_hash_common)
-            old_alignment = h->root.u.c.p->alignment_power;
+             that we don't reduce the alignment later on.  We can't
+             check later, because _bfd_generic_link_add_one_symbol
+             will set a default for the alignment which we want to
+             override. We also remember the old bfd where the existing
+             definition comes from.  */
+          switch (h->root.type)
+            {
+            default:
+              break;
+
+            case bfd_link_hash_defined:
+            case bfd_link_hash_defweak:
+              old_bfd = h->root.u.def.section->owner;
+              break;
+            
+            case bfd_link_hash_common:
+              old_bfd = h->root.u.c.p->section->owner;
+              old_alignment = h->root.u.c.p->alignment_power;
+              break;
+            }
 
           if (elf_tdata (abfd)->verdef != NULL
@@ -1569 +2010 @@
       if (! (_bfd_generic_link_add_one_symbol
              (info, abfd, name, flags, sec, value, (const char *) NULL,
-              false, collect, (struct bfd_link_hash_entry **) sym_hash)))
-        goto error_return;
+              FALSE, collect, (struct bfd_link_hash_entry **) sym_hash)))
+        goto error_free_vers;
 
       h = *sym_hash;
@@ -1578 +2019 @@
       *sym_hash = h;
 
-      new_weakdef = false;
+      new_weakdef = FALSE;
       if (dynamic
           && definition
           && (flags & BSF_WEAK) != 0
-          && ELF_ST_TYPE (sym.st_info) != STT_FUNC
+          && ELF_ST_TYPE (isym->st_info) != STT_FUNC
           && info->hash->creator->flavour == bfd_target_elf_flavour
           && h->weakdef == NULL)
@@ -1600 +2041 @@
           h->weakdef = weaks;
           weaks = h;
-          new_weakdef = true;
+          new_weakdef = TRUE;
         }
 
       /* Set the alignment of a common symbol.  */
-      if (sym.st_shndx == SHN_COMMON
+      if (isym->st_shndx == SHN_COMMON
           && h->root.type == bfd_link_hash_common)
         {
           unsigned int align;
 
-          align = bfd_log2 (sym.st_value);
+          align = bfd_log2 (isym->st_value);
           if (align > old_alignment
               /* Permit an alignment power of zero if an alignment of one
                  is specified and no other alignments have been specified.  */
-              || (sym.st_value == 1 && old_alignment == 0))
+              || (isym->st_value == 1 && old_alignment == 0))
             h->root.u.c.p->alignment_power = align;
+          else
+            h->root.u.c.p->alignment_power = old_alignment;
         }
 
@@ -1620 +2063 @@
         {
           int old_flags;
-          boolean dynsym;
+          bfd_boolean dynsym;
           int new_flag;
 
+          /* Check the alignment when a common symbol is involved. This
+             can change when a common symbol is overriden by a normal
+             definition or a common symbol is ignored due to the old
+             normal definition. We need to make sure the maximum
+             alignment is maintained.  */
+          if ((old_alignment || isym->st_shndx == SHN_COMMON)
+              && h->root.type != bfd_link_hash_common)
+            {
+              unsigned int common_align;
+              unsigned int normal_align;
+              unsigned int symbol_align;
+              bfd *normal_bfd;
+              bfd *common_bfd;
+
+              symbol_align = ffs (h->root.u.def.value) - 1;
+              if ((h->root.u.def.section->owner->flags & DYNAMIC) == 0)
+                {
+                  normal_align = h->root.u.def.section->alignment_power;
+                  if (normal_align > symbol_align)
+                    normal_align = symbol_align;
+                }
+              else
+                normal_align = symbol_align;
+
+              if (old_alignment)
+                {
+                  common_align = old_alignment;
+                  common_bfd = old_bfd;
+                  normal_bfd = abfd;
+                }
+              else
+                {
+                  common_align = bfd_log2 (isym->st_value);
+                  common_bfd = abfd;
+                  normal_bfd = old_bfd;
+                }
+
+              if (normal_align < common_align)
+                (*_bfd_error_handler)
+                  (_("Warning: alignment %u of symbol `%s' in %s is smaller than %u in %s"),
+                   1 << normal_align,
+                   name,
+                   bfd_archive_filename (normal_bfd),
+                   1 << common_align,
+                   bfd_archive_filename (common_bfd));
+            }
+
           /* Remember the symbol size and type.  */
-          if (sym.st_size != 0
+          if (isym->st_size != 0
               && (definition || h->size == 0))
             {
-              if (h->size != 0 && h->size != sym.st_size && ! size_change_ok)
+              if (h->size != 0 && h->size != isym->st_size && ! size_change_ok)
                 (*_bfd_error_handler)
-                  (_("Warning: size of symbol `%s' changed from %lu to %lu in %s"),
-                   name, (unsigned long) h->size, (unsigned long) sym.st_size,
-                   bfd_get_filename (abfd));
-
-              h->size = sym.st_size;
+                  (_("Warning: size of symbol `%s' changed from %lu in %s to %lu in %s"),
+                   name, (unsigned long) h->size,
+                   bfd_archive_filename (old_bfd),
+                   (unsigned long) isym->st_size,
+                   bfd_archive_filename (abfd));
+
+              h->size = isym->st_size;
             }
 
           /* If this is a common symbol, then we always want H->SIZE
-             to be the size of the common symbol.  The code just above
-             won't fix the size if a common symbol becomes larger.  We
-             don't warn about a size change here, because that is
-             covered by --warn-common.  */
+             to be the size of the common symbol.  The code just above
+             won't fix the size if a common symbol becomes larger.  We
+             don't warn about a size change here, because that is
+             covered by --warn-common.  */
           if (h->root.type == bfd_link_hash_common)
             h->size = h->root.u.c.size;
 
-          if (ELF_ST_TYPE (sym.st_info) != STT_NOTYPE
+          if (ELF_ST_TYPE (isym->st_info) != STT_NOTYPE
               && (definition || h->type == STT_NOTYPE))
             {
               if (h->type != STT_NOTYPE
-                  && h->type != ELF_ST_TYPE (sym.st_info)
+                  && h->type != ELF_ST_TYPE (isym->st_info)
                   && ! type_change_ok)
                 (*_bfd_error_handler)
                   (_("Warning: type of symbol `%s' changed from %d to %d in %s"),
-                   name, h->type, ELF_ST_TYPE (sym.st_info),
-                   bfd_get_filename (abfd));
-
-              h->type = ELF_ST_TYPE (sym.st_info);
+                   name, h->type, ELF_ST_TYPE (isym->st_info),
+                   bfd_archive_filename (abfd));
+
+              h->type = ELF_ST_TYPE (isym->st_info);
             }
 
-          /* If st_other has a processor-specific meaning, specific code
-             might be needed here.  */
-          if (sym.st_other != 0)
+          /* If st_other has a processor-specific meaning, specific
+             code might be needed here. We never merge the visibility
+             attribute with the one from a dynamic object.  */
+          if (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);
+
               /* Combine visibilities, using the most constraining one.  */
-              unsigned char hvis   = ELF_ST_VISIBILITY (h->other);
-              unsigned char symvis = ELF_ST_VISIBILITY (sym.st_other);
-
-              if (symvis && (hvis > symvis || hvis == 0))
-                h->other = sym.st_other;
-
-              /* If neither has visibility, use the st_other of the
-                 definition.  This is an arbitrary choice, since the
-                 other bits have no general meaning.  */
-              if (!symvis && !hvis
-                  && (definition || h->other == 0))
-                h->other = sym.st_other;
+              hvis   = ELF_ST_VISIBILITY (h->other);
+              symvis = ELF_ST_VISIBILITY (isym->st_other);
+              if (! hvis)
+                nvis = symvis;
+              else if (! symvis)
+                nvis = hvis;
+              else
+                nvis = hvis < symvis ? hvis : symvis;
+
+              h->other = other | nvis;
             }
 
@@ -1683 +2180 @@
              object and a shared object.  */
           old_flags = h->elf_link_hash_flags;
-          dynsym = false;
+          dynsym = FALSE;
           if (! dynamic)
             {
@@ -1697 +2194 @@
                   || (old_flags & (ELF_LINK_HASH_DEF_DYNAMIC
                                    | ELF_LINK_HASH_REF_DYNAMIC)) != 0)
-                dynsym = true;
+                dynsym = TRUE;
             }
           else
@@ -1710 +2207 @@
                       && ! new_weakdef
                       && h->weakdef->dynindx != -1))
-                dynsym = true;
+                dynsym = TRUE;
             }
 
           h->elf_link_hash_flags |= new_flag;
 
-          /* If this symbol has a version, and it is the default
-             version, we create an indirect symbol from the default
-             name to the fully decorated name.  This will cause
-             external references which do not specify a version to be
-             bound to this version of the symbol.  */
+          /* Check to see if we need to add an indirect symbol for
+             the default name.  */
           if (definition || h->root.type == bfd_link_hash_common)
+            if (! elf_add_default_symbol (abfd, info, h, name, isym,
+                                          &sec, &value, &dynsym,
+                                          override, dt_needed))
+              goto error_free_vers;
+
+          if (definition && !dynamic)
             {
-              char *p;
-
-              p = strchr (name, ELF_VER_CHR);
-              if (p != NULL && p[1] == ELF_VER_CHR)
+              char *p = strchr (name, ELF_VER_CHR);
+              if (p != NULL && p[1] != ELF_VER_CHR)
                 {
-                  char *shortname;
-                  struct elf_link_hash_entry *hi;
-                  boolean override;
-
-                  shortname = bfd_hash_allocate (&info->hash->table,
-                                                 p - name + 1);
-                  if (shortname == NULL)
-                    goto error_return;
-                  strncpy (shortname, name, p - name);
-                  shortname[p - name] = '\0';
-
-                  /* We are going to create a new symbol.  Merge it
-                     with any existing symbol with this name.  For the
-                     purposes of the merge, act as though we were
-                     defining the symbol we just defined, although we
-                     actually going to define an indirect symbol.  */
-                  type_change_ok = false;
-                  size_change_ok = false;
-                  if (! elf_merge_symbol (abfd, info, shortname, &sym, &sec,
-                                          &value, &hi, &override,
-                                          &type_change_ok,
-                                          &size_change_ok, dt_needed))
-                    goto error_return;
-
-                  if (! override)
+                  /* Queue non-default versions so that .symver x, x@FOO
+                     aliases can be checked.  */
+                  if (! nondeflt_vers)
                     {
-                      if (! (_bfd_generic_link_add_one_symbol
-                             (info, abfd, shortname, BSF_INDIRECT,
-                              bfd_ind_section_ptr, (bfd_vma) 0, name, false,
-                              collect, (struct bfd_link_hash_entry **) &hi)))
-                        goto error_return;
+                      amt = (isymend - isym + 1)
+                            * sizeof (struct elf_link_hash_entry *);
+                      nondeflt_vers = bfd_malloc (amt);
                     }
-                  else
-                    {
-                      /* In this case the symbol named SHORTNAME is
-                         overriding the indirect symbol we want to
-                         add.  We were planning on making SHORTNAME an
-                         indirect symbol referring to NAME.  SHORTNAME
-                         is the name without a version.  NAME is the
-                         fully versioned name, and it is the default
-                         version.
-
-                         Overriding means that we already saw a
-                         definition for the symbol SHORTNAME in a
-                         regular object, and it is overriding the
-                         symbol defined in the dynamic object.
-
-                         When this happens, we actually want to change
-                         NAME, the symbol we just added, to refer to
-                         SHORTNAME.  This will cause references to
-                         NAME in the shared object to become
-                         references to SHORTNAME in the regular
-                         object.  This is what we expect when we
-                         override a function in a shared object: that
-                         the references in the shared object will be
-                         mapped to the definition in the regular
-                         object.  */
-
-                      while (hi->root.type == bfd_link_hash_indirect
-                             || hi->root.type == bfd_link_hash_warning)
-                        hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
-
-                      h->root.type = bfd_link_hash_indirect;
-                      h->root.u.i.link = (struct bfd_link_hash_entry *) hi;
-                      if (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC)
-                        {
-                          h->elf_link_hash_flags &=~ ELF_LINK_HASH_DEF_DYNAMIC;
-                          hi->elf_link_hash_flags |= ELF_LINK_HASH_REF_DYNAMIC;
-                          if (hi->elf_link_hash_flags
-                              & (ELF_LINK_HASH_REF_REGULAR
-                                 | ELF_LINK_HASH_DEF_REGULAR))
-                            {
-                              if (! _bfd_elf_link_record_dynamic_symbol (info,
-                                                                         hi))
-                                goto error_return;
-                            }
-                        }
-
-                      /* Now set HI to H, so that the following code
-                         will set the other fields correctly.  */
-                      hi = h;
-                    }
-
-                  /* If there is a duplicate definition somewhere,
-                     then HI may not point to an indirect symbol.  We
-                     will have reported an error to the user in that
-                     case.  */
-
-                  if (hi->root.type == bfd_link_hash_indirect)
-                    {
-                      struct elf_link_hash_entry *ht;
-
-                      /* If the symbol became indirect, then we assume
-                         that we have not seen a definition before.  */
-                      BFD_ASSERT ((hi->elf_link_hash_flags
-                                   & (ELF_LINK_HASH_DEF_DYNAMIC
-                                      | ELF_LINK_HASH_DEF_REGULAR))
-                                  == 0);
-
-                      ht = (struct elf_link_hash_entry *) hi->root.u.i.link;
-                      (*bed->elf_backend_copy_indirect_symbol) (ht, hi);
-
-                      /* See if the new flags lead us to realize that
-                         the symbol must be dynamic.  */
-                      if (! dynsym)
-                        {
-                          if (! dynamic)
-                            {
-                              if (info->shared
-                                  || ((hi->elf_link_hash_flags
-                                       & ELF_LINK_HASH_REF_DYNAMIC)
-                                      != 0))
-                                dynsym = true;
-                            }
-                          else
-                            {
-                              if ((hi->elf_link_hash_flags
-                                   & ELF_LINK_HASH_REF_REGULAR) != 0)
-                                dynsym = true;
-                            }
-                        }
-                    }
-
-                  /* We also need to define an indirection from the
-                     nondefault version of the symbol.  */
-
-                  shortname = bfd_hash_allocate (&info->hash->table,
-                                                 strlen (name));
-                  if (shortname == NULL)
-                    goto error_return;
-                  strncpy (shortname, name, p - name);
-                  strcpy (shortname + (p - name), p + 1);
-
-                  /* Once again, merge with any existing symbol.  */
-                  type_change_ok = false;
-                  size_change_ok = false;
-                  if (! elf_merge_symbol (abfd, info, shortname, &sym, &sec,
-                                          &value, &hi, &override,
-                                          &type_change_ok,
-                                          &size_change_ok, dt_needed))
-                    goto error_return;
-
-                  if (override)
-                    {
-                      /* Here SHORTNAME is a versioned name, so we
-                         don't expect to see the type of override we
-                         do in the case above.  */
-                      (*_bfd_error_handler)
-                        (_("%s: warning: unexpected redefinition of `%s'"),
-                         bfd_get_filename (abfd), shortname);
-                    }
-                  else
-                    {
-                      if (! (_bfd_generic_link_add_one_symbol
-                             (info, abfd, shortname, BSF_INDIRECT,
-                              bfd_ind_section_ptr, (bfd_vma) 0, name, false,
-                              collect, (struct bfd_link_hash_entry **) &hi)))
-                        goto error_return;
-
-                      /* If there is a duplicate definition somewhere,
-                         then HI may not point to an indirect symbol.
-                         We will have reported an error to the user in
-                         that case.  */
-
-                      if (hi->root.type == bfd_link_hash_indirect)
-                        {
-                          /* If the symbol became indirect, then we
-                             assume that we have not seen a definition
-                             before.  */
-                          BFD_ASSERT ((hi->elf_link_hash_flags
-                                       & (ELF_LINK_HASH_DEF_DYNAMIC
-                                          | ELF_LINK_HASH_DEF_REGULAR))
-                                      == 0);
-
-                          (*bed->elf_backend_copy_indirect_symbol) (h, hi);
-
-                          /* See if the new flags lead us to realize
-                             that the symbol must be dynamic.  */
-                          if (! dynsym)
-                            {
-                              if (! dynamic)
-                                {
-                                  if (info->shared
-                                      || ((hi->elf_link_hash_flags
-                                           & ELF_LINK_HASH_REF_DYNAMIC)
-                                          != 0))
-                                    dynsym = true;
-                                }
-                              else
-                                {
-                                  if ((hi->elf_link_hash_flags
-                                       & ELF_LINK_HASH_REF_REGULAR) != 0)
-                                    dynsym = true;
-                                }
-                            }
-                        }
-                    }
+                  nondeflt_vers [nondeflt_vers_cnt++] = h;
                 }
             }
@@ -1930 +2240 @@
             {
               if (! _bfd_elf_link_record_dynamic_symbol (info, h))
-                goto error_return;
+                goto error_free_vers;
               if (h->weakdef != NULL
                   && ! new_weakdef
                   && h->weakdef->dynindx == -1)
                 {
-                  if (! _bfd_elf_link_record_dynamic_symbol (info,
-                                                             h->weakdef))
-                    goto error_return;
+                  if (! _bfd_elf_link_record_dynamic_symbol (info, h->weakdef))
+                    goto error_free_vers;
                 }
             }
@@ -1948 +2257 @@
               case STV_INTERNAL:
               case STV_HIDDEN:
-                h->elf_link_hash_flags |= ELF_LINK_FORCED_LOCAL;
-                (*bed->elf_backend_hide_symbol) (info, h);
+                (*bed->elf_backend_hide_symbol) (info, h, TRUE);
                 break;
               }
@@ -1960 +2268 @@
               bfd_size_type strindex;
 
+              if (! is_elf_hash_table (info))
+                goto error_free_vers;
+
               /* The symbol from a DT_NEEDED object is referenced from
-                 the regular object to create a dynamic executable. We
+                 the regular object to create a dynamic executable. We
                  have to make sure there is a DT_NEEDED entry for it.  */
 
-              dt_needed = false;
-              oldsize = _bfd_stringtab_size (elf_hash_table (info)->dynstr);
-              strindex = _bfd_stringtab_add (elf_hash_table (info)->dynstr,
-                                             elf_dt_soname (abfd),
-                                             true, false);
+              dt_needed = FALSE;
+              oldsize = _bfd_elf_strtab_size (hash_table->dynstr);
+              strindex = _bfd_elf_strtab_add (hash_table->dynstr,
+                                              elf_dt_soname (abfd), FALSE);
               if (strindex == (bfd_size_type) -1)
-                goto error_return;
-
-              if (oldsize
-                  == _bfd_stringtab_size (elf_hash_table (info)->dynstr))
+                goto error_free_vers;
+
+              if (oldsize == _bfd_elf_strtab_size (hash_table->dynstr))
                 {
                   asection *sdyn;
                   Elf_External_Dyn *dyncon, *dynconend;
 
-                  sdyn = bfd_get_section_by_name (elf_hash_table (info)->dynobj,
+                  sdyn = bfd_get_section_by_name (hash_table->dynobj,
                                                   ".dynamic");
                   BFD_ASSERT (sdyn != NULL);
@@ -1989 +2298 @@
                       Elf_Internal_Dyn dyn;
 
-                      elf_swap_dyn_in (elf_hash_table (info)->dynobj,
+                      elf_swap_dyn_in (hash_table->dynobj,
                                        dyncon, &dyn);
                       BFD_ASSERT (dyn.d_tag != DT_NEEDED ||
@@ -1996 +2305 @@
                 }
 
-              if (! elf_add_dynamic_entry (info, DT_NEEDED, strindex))
-                goto error_return;
+              if (! elf_add_dynamic_entry (info, (bfd_vma) DT_NEEDED, strindex))
+                goto error_free_vers;
             }
         }
     }
+
+  /* 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)
+    {
+      bfd_size_type cnt, symidx;
+
+      for (cnt = 0; cnt < nondeflt_vers_cnt; ++cnt)
+        {
+          struct elf_link_hash_entry *h = nondeflt_vers[cnt], *hi;
+          char *shortname, *p;
+
+          p = strchr (h->root.root.string, ELF_VER_CHR);
+          if (p == NULL
+              || (h->root.type != bfd_link_hash_defined
+                  && h->root.type != bfd_link_hash_defweak))
+            continue;
+
+          amt = p - h->root.root.string;
+          shortname = bfd_malloc (amt + 1);
+          memcpy (shortname, h->root.root.string, amt);
+          shortname[amt] = '\0';
+
+          hi = (struct elf_link_hash_entry *)
+               bfd_link_hash_lookup (info->hash, shortname,
+                                     FALSE, FALSE, FALSE);
+          if (hi != NULL
+              && hi->root.type == h->root.type
+              && hi->root.u.def.value == h->root.u.def.value
+              && hi->root.u.def.section == h->root.u.def.section)
+            {
+              (*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);
+              sym_hash = elf_sym_hashes (abfd);
+              if (sym_hash)
+                for (symidx = 0; symidx < extsymcount; ++symidx)
+                  if (sym_hash[symidx] == hi)
+                    {
+                      sym_hash[symidx] = h;
+                      break;
+                    }
+            }
+          free (shortname);
+        }
+      free (nondeflt_vers);
+      nondeflt_vers = NULL;
+    }
+
+  if (extversym != NULL)
+    {
+      free (extversym);
+      extversym = NULL;
+    }
+
+  if (isymbuf != NULL)
+    free (isymbuf);
+  isymbuf = NULL;
 
   /* Now set the weakdefs field correctly for all the weak defined
@@ -2059 +2427 @@
 
               /* If the real definition is in the list of dynamic
-                 symbols, make sure the weak definition is put there
-                 as well.  If we don't do this, then the dynamic
-                 loader might not merge the entries for the real
-                 definition and the weak definition.  */
+                 symbols, make sure the weak definition is put there
+                 as well.  If we don't do this, then the dynamic
+                 loader might not merge the entries for the real
+                 definition and the weak definition.  */
               if (h->dynindx != -1
                   && hlook->dynindx == -1)
@@ -2069 +2437 @@
                     goto error_return;
                 }
-
               break;
             }
         }
-    }
-
-  if (buf != NULL)
-    {
-      free (buf);
-      buf = NULL;
-    }
-
-  if (extversym != NULL)
-    {
-      free (extversym);
-      extversym = NULL;
     }
 
@@ -2114 +2469 @@
         {
           Elf_Internal_Rela *internal_relocs;
-          boolean ok;
+          bfd_boolean ok;
 
           if ((o->flags & SEC_RELOC) == 0
@@ -2132 +2487 @@
           ok = (*check_relocs) (abfd, info, o, internal_relocs);
 
-          if (! info->keep_memory)
+          if (elf_section_data (o)->relocs != internal_relocs)
             free (internal_relocs);
 
@@ -2140 +2495 @@
     }
 
-  /* If this is a non-traditional, non-relocateable link, try to
-     optimize the handling of the .stab/.stabstr sections.  */
+  /* If this is a non-traditional link, try to optimize the handling
+     of the .stab/.stabstr sections.  */
   if (! dynamic
-      && ! info->relocateable
       && ! info->traditional_format
       && info->hash->creator->flavour == bfd_target_elf_flavour
+      && is_elf_hash_table (info)
       && (info->strip != strip_all && info->strip != strip_debugger))
     {
@@ -2151 +2506 @@
 
       stab = bfd_get_section_by_name (abfd, ".stab");
-      if (stab != NULL)
+      if (stab != NULL
+          && (stab->flags & SEC_MERGE) == 0
+          && !bfd_is_abs_section (stab->output_section))
         {
           stabstr = bfd_get_section_by_name (abfd, ".stabstr");
@@ -2161 +2518 @@
               secdata = elf_section_data (stab);
               if (! _bfd_link_section_stabs (abfd,
-                                             &elf_hash_table (info)->stab_info,
+                                             & hash_table->stab_info,
                                              stab, stabstr,
-                                             &secdata->stab_info))
+                                             &secdata->sec_info))
                 goto error_return;
+              if (secdata->sec_info)
+                stab->sec_info_type = ELF_INFO_TYPE_STABS;
             }
         }
     }
 
-  return true;
-
- error_return:
-  if (buf != NULL)
-    free (buf);
-  if (dynbuf != NULL)
-    free (dynbuf);
+  if (! info->relocateable && ! dynamic
+      && is_elf_hash_table (info))
+    {
+      asection *s;
+
+      for (s = abfd->sections; s != NULL; s = s->next)
+        if ((s->flags & SEC_MERGE) != 0
+            && !bfd_is_abs_section (s->output_section))
+          {
+            struct bfd_elf_section_data *secdata;
+
+            secdata = elf_section_data (s);
+            if (! _bfd_merge_section (abfd,
+                                      & hash_table->merge_info,
+                                      s, &secdata->sec_info))
+              goto error_return;
+            else if (secdata->sec_info)
+              s->sec_info_type = ELF_INFO_TYPE_MERGE;
+          }
+    }
+
+  if (is_elf_hash_table (info))
+    {
+      /* Add this bfd to the loaded list.  */
+      struct elf_link_loaded_list *n;
+
+      n = ((struct elf_link_loaded_list *)
+           bfd_alloc (abfd, sizeof (struct elf_link_loaded_list)));
+      if (n == NULL)
+        goto error_return;
+      n->abfd = abfd;
+      n->next = hash_table->loaded;
+      hash_table->loaded = n;
+    }
+
+  return TRUE;
+
+ error_free_vers:
+  if (nondeflt_vers != NULL)
+    free (nondeflt_vers);
   if (extversym != NULL)
     free (extversym);
-  return false;
+ error_free_sym:
+  if (isymbuf != NULL)
+    free (isymbuf);
+ error_return:
+  return FALSE;
 }
 
@@ -2188 +2584 @@
    actual contents and size of these sections later.  */
 
-boolean
+bfd_boolean
 elf_link_create_dynamic_sections (abfd, info)
      bfd *abfd;
@@ -2196 +2592 @@
   register asection *s;
   struct elf_link_hash_entry *h;
+  struct bfd_link_hash_entry *bh;
   struct elf_backend_data *bed;
 
+  if (! is_elf_hash_table (info))
+    return FALSE;
+
   if (elf_hash_table (info)->dynamic_sections_created)
-    return true;
+    return TRUE;
 
   /* Make sure that all dynamic sections use the same input BFD.  */
@@ -2219 +2619 @@
       if (s == NULL
           || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY))
-        return false;
+        return FALSE;
+    }
+
+  if (! info->traditional_format
+      && info->hash->creator->flavour == bfd_target_elf_flavour)
+    {
+      s = bfd_make_section (abfd, ".eh_frame_hdr");
+      if (s == NULL
+          || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
+          || ! bfd_set_section_alignment (abfd, s, 2))
+        return FALSE;
+      elf_hash_table (info)->eh_info.hdr_sec = s;
     }
 
@@ -2228 +2639 @@
       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
       || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
-    return false;
+    return FALSE;
 
   s = bfd_make_section (abfd, ".gnu.version");
@@ -2234 +2645 @@
       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
       || ! bfd_set_section_alignment (abfd, s, 1))
-    return false;
+    return FALSE;
 
   s = bfd_make_section (abfd, ".gnu.version_r");
@@ -2240 +2651 @@
       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
       || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
-    return false;
+    return FALSE;
 
   s = bfd_make_section (abfd, ".dynsym");
@@ -2246 +2657 @@
       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
       || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
-    return false;
+    return FALSE;
 
   s = bfd_make_section (abfd, ".dynstr");
   if (s == NULL
       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY))
-    return false;
+    return FALSE;
 
   /* Create a strtab to hold the dynamic symbol names.  */
   if (elf_hash_table (info)->dynstr == NULL)
     {
-      elf_hash_table (info)->dynstr = elf_stringtab_init ();
+      elf_hash_table (info)->dynstr = _bfd_elf_strtab_init ();
       if (elf_hash_table (info)->dynstr == NULL)
-        return false;
+        return FALSE;
     }
 
@@ -2265 +2676 @@
       || ! bfd_set_section_flags (abfd, s, flags)
       || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
-    return false;
+    return FALSE;
 
   /* The special symbol _DYNAMIC is always set to the start of the
@@ -2275 +2686 @@
      is no .dynamic section, since on some ELF platforms the start up
      code examines it to decide how to initialize the process.  */
-  h = NULL;
+  bh = NULL;
   if (! (_bfd_generic_link_add_one_symbol
          (info, abfd, "_DYNAMIC", BSF_GLOBAL, s, (bfd_vma) 0,
-          (const char *) NULL, false, get_elf_backend_data (abfd)->collect,
-          (struct bfd_link_hash_entry **) &h)))
-    return false;
+          (const char *) 0, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
+    return FALSE;
+  h = (struct elf_link_hash_entry *) bh;
   h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
   h->type = STT_OBJECT;
@@ -2286 +2697 @@
   if (info->shared
       && ! _bfd_elf_link_record_dynamic_symbol (info, h))
-    return false;
+    return FALSE;
 
   bed = get_elf_backend_data (abfd);
@@ -2294 +2705 @@
       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
       || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
-    return false;
+    return FALSE;
   elf_section_data (s)->this_hdr.sh_entsize = bed->s->sizeof_hash_entry;
 
@@ -2301 +2712 @@
      the .got and .plt sections.  */
   if (! (*bed->elf_backend_create_dynamic_sections) (abfd, info))
-    return false;
-
-  elf_hash_table (info)->dynamic_sections_created = true;
-
-  return true;
+    return FALSE;
+
+  elf_hash_table (info)->dynamic_sections_created = TRUE;
+
+  return TRUE;
 }
 
 /* Add an entry to the .dynamic table.  */
 
-boolean
+bfd_boolean
 elf_add_dynamic_entry (info, tag, val)
      struct bfd_link_info *info;
@@ -2319 +2730 @@
   bfd *dynobj;
   asection *s;
-  size_t newsize;
+  bfd_size_type newsize;
   bfd_byte *newcontents;
+
+  if (! is_elf_hash_table (info))
+    return FALSE;
 
   dynobj = elf_hash_table (info)->dynobj;
@@ -2330 +2744 @@
   newcontents = (bfd_byte *) bfd_realloc (s->contents, newsize);
   if (newcontents == NULL)
-    return false;
+    return FALSE;
 
   dyn.d_tag = tag;
@@ -2340 +2754 @@
   s->contents = newcontents;
 
-  return true;
-}
-
-/* Record a new local dynamic symbol.  */
-
-boolean
-elf_link_record_local_dynamic_symbol (info, input_bfd, input_indx)
-     struct bfd_link_info *info;
-     bfd *input_bfd;
-     long input_indx;
-{
-  struct elf_link_local_dynamic_entry *entry;
-  struct elf_link_hash_table *eht;
-  struct bfd_strtab_hash *dynstr;
-  Elf_External_Sym esym;
-  unsigned long dynstr_index;
-  char *name;
-
-  /* See if the entry exists already.  */
-  for (entry = elf_hash_table (info)->dynlocal; entry ; entry = entry->next)
-    if (entry->input_bfd == input_bfd && entry->input_indx == input_indx)
-      return true;
-
-  entry = (struct elf_link_local_dynamic_entry *)
-    bfd_alloc (input_bfd, sizeof (*entry));
-  if (entry == NULL)
-    return false;
-
-  /* Go find the symbol, so that we can find it's name.  */
-  if (bfd_seek (input_bfd,
-                (elf_tdata (input_bfd)->symtab_hdr.sh_offset
-                 + input_indx * sizeof (Elf_External_Sym)),
-                SEEK_SET) != 0
-      || (bfd_read (&esym, sizeof (Elf_External_Sym), 1, input_bfd)
-          != sizeof (Elf_External_Sym)))
-    return false;
-  elf_swap_symbol_in (input_bfd, &esym, &entry->isym);
-
-  name = (bfd_elf_string_from_elf_section
-          (input_bfd, elf_tdata (input_bfd)->symtab_hdr.sh_link,
-           entry->isym.st_name));
-
-  dynstr = elf_hash_table (info)->dynstr;
-  if (dynstr == NULL)
-    {
-      /* Create a strtab to hold the dynamic symbol names.  */
-      elf_hash_table (info)->dynstr = dynstr = _bfd_elf_stringtab_init ();
-      if (dynstr == NULL)
-        return false;
-    }
-
-  dynstr_index = _bfd_stringtab_add (dynstr, name, true, false);
-  if (dynstr_index == (unsigned long) -1)
-    return false;
-  entry->isym.st_name = dynstr_index;
-
-  eht = elf_hash_table (info);
-
-  entry->next = eht->dynlocal;
-  eht->dynlocal = entry;
-  entry->input_bfd = input_bfd;
-  entry->input_indx = input_indx;
-  eht->dynsymcount++;
-
-  /* Whatever binding the symbol had before, it's now local.  */
-  entry->isym.st_info
-    = ELF_ST_INFO (STB_LOCAL, ELF_ST_TYPE (entry->isym.st_info));
-
-  /* The dynindx will be set at the end of size_dynamic_sections.  */
-
-  return true;
+  return TRUE;
 }
 
@@ -2421 +2765 @@
    relocations should be stored.
 
-   Returns false if something goes wrong.  */
-
-static boolean
+   Returns FALSE if something goes wrong.  */
+
+static bfd_boolean
 elf_link_read_relocs_from_section (abfd, shdr, external_relocs,
                                    internal_relocs)
@@ -2432 +2776 @@
 {
   struct elf_backend_data *bed;
+  void (*swap_in) PARAMS ((bfd *, const bfd_byte *, Elf_Internal_Rela *));
+  const bfd_byte *erela;
+  const bfd_byte *erelaend;
+  Elf_Internal_Rela *irela;
 
   /* If there aren't any relocations, that's OK.  */
   if (!shdr)
-    return true;
+    return TRUE;
 
   /* Position ourselves at the start of the section.  */
   if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0)
-    return false;
+    return FALSE;
 
   /* Read the relocations.  */
-  if (bfd_read (external_relocs, 1, shdr->sh_size, abfd)
-      != shdr->sh_size)
-    return false;
+  if (bfd_bread (external_relocs, shdr->sh_size, abfd) != shdr->sh_size)
+    return FALSE;
 
   bed = get_elf_backend_data (abfd);
@@ -2450 +2797 @@
   /* Convert the external relocations to the internal format.  */
   if (shdr->sh_entsize == sizeof (Elf_External_Rel))
-    {
-      Elf_External_Rel *erel;
-      Elf_External_Rel *erelend;
-      Elf_Internal_Rela *irela;
-      Elf_Internal_Rel *irel;
-
-      erel = (Elf_External_Rel *) external_relocs;
-      erelend = erel + NUM_SHDR_ENTRIES (shdr);
-      irela = internal_relocs;
-      irel = bfd_alloc (abfd, (bed->s->int_rels_per_ext_rel
-                               * sizeof (Elf_Internal_Rel)));
-      for (; erel < erelend; erel++, irela += bed->s->int_rels_per_ext_rel)
-        {
-          unsigned int i;
-
-          if (bed->s->swap_reloc_in)
-            (*bed->s->swap_reloc_in) (abfd, (bfd_byte *) erel, irel);
-          else
-            elf_swap_reloc_in (abfd, erel, irel);
-
-          for (i = 0; i < bed->s->int_rels_per_ext_rel; ++i)
-            {
-              irela[i].r_offset = irel[i].r_offset;
-              irela[i].r_info = irel[i].r_info;
-              irela[i].r_addend = 0;
-            }
-        }
-    }
+    swap_in = bed->s->swap_reloc_in;
+  else if (shdr->sh_entsize == sizeof (Elf_External_Rela))
+    swap_in = bed->s->swap_reloca_in;
   else
     {
-      Elf_External_Rela *erela;
-      Elf_External_Rela *erelaend;
-      Elf_Internal_Rela *irela;
-
-      BFD_ASSERT (shdr->sh_entsize == sizeof (Elf_External_Rela));
-
-      erela = (Elf_External_Rela *) external_relocs;
-      erelaend = erela + NUM_SHDR_ENTRIES (shdr);
-      irela = internal_relocs;
-      for (; erela < erelaend; erela++, irela += bed->s->int_rels_per_ext_rel)
-        {
-          if (bed->s->swap_reloca_in)
-            (*bed->s->swap_reloca_in) (abfd, (bfd_byte *) erela, irela);
-          else
-            elf_swap_reloca_in (abfd, erela, irela);
-        }
-    }
-
-  return true;
+      bfd_set_error (bfd_error_wrong_format);
+      return FALSE;
+    }
+
+  erela = external_relocs;
+  erelaend = erela + NUM_SHDR_ENTRIES (shdr) * shdr->sh_entsize;
+  irela = internal_relocs;
+  while (erela < erelaend)
+    {
+      (*swap_in) (abfd, erela, irela);
+      irela += bed->s->int_rels_per_ext_rel;
+      erela += shdr->sh_entsize;
+    }
+
+  return TRUE;
 }
 
@@ -2518 +2836 @@
      PTR external_relocs;
      Elf_Internal_Rela *internal_relocs;
-     boolean keep_memory;
+     bfd_boolean keep_memory;
 {
   Elf_Internal_Shdr *rel_hdr;
@@ -2535 +2853 @@
   if (internal_relocs == NULL)
     {
-      size_t size;
-
-      size = (o->reloc_count * bed->s->int_rels_per_ext_rel
-              * sizeof (Elf_Internal_Rela));
+      bfd_size_type size;
+
+      size = o->reloc_count;
+      size *= bed->s->int_rels_per_ext_rel * sizeof (Elf_Internal_Rela);
       if (keep_memory)
         internal_relocs = (Elf_Internal_Rela *) bfd_alloc (abfd, size);
@@ -2549 +2867 @@
   if (external_relocs == NULL)
     {
-      size_t size = (size_t) rel_hdr->sh_size;
+      bfd_size_type size = rel_hdr->sh_size;
 
       if (elf_section_data (o)->rel_hdr2)
-        size += (size_t) elf_section_data (o)->rel_hdr2->sh_size;
+        size += elf_section_data (o)->rel_hdr2->sh_size;
       alloc1 = (PTR) bfd_malloc (size);
       if (alloc1 == NULL)
@@ -2595 +2913 @@
    this in case some dynamic object refers to this symbol.  */
 
-/*ARGSUSED*/
-boolean
+bfd_boolean
 NAME(bfd_elf,record_link_assignment) (output_bfd, info, name, provide)
      bfd *output_bfd ATTRIBUTE_UNUSED;
      struct bfd_link_info *info;
      const char *name;
-     boolean provide;
+     bfd_boolean provide;
 {
   struct elf_link_hash_entry *h;
 
   if (info->hash->creator->flavour != bfd_target_elf_flavour)
-    return true;
-
-  h = elf_link_hash_lookup (elf_hash_table (info), name, true, true, false);
+    return TRUE;
+
+  h = elf_link_hash_lookup (elf_hash_table (info), name, TRUE, TRUE, FALSE);
   if (h == NULL)
-    return false;
+    return FALSE;
 
   if (h->root.type == bfd_link_hash_new)
-    h->elf_link_hash_flags &=~ ELF_LINK_NON_ELF;
+    h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
 
   /* If this symbol is being provided by the linker script, and it is
@@ -2635 +2952 @@
   h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
 
-  /* When possible, keep the original type of the symbol */
-  if (h->type == STT_NOTYPE)
-    h->type = STT_OBJECT;
-
   if (((h->elf_link_hash_flags & (ELF_LINK_HASH_DEF_DYNAMIC
                                   | ELF_LINK_HASH_REF_DYNAMIC)) != 0
@@ -2645 +2958 @@
     {
       if (! _bfd_elf_link_record_dynamic_symbol (info, h))
-        return false;
+        return FALSE;
 
       /* If this is a weak defined symbol, and we know a corresponding
@@ -2654 +2967 @@
         {
           if (! _bfd_elf_link_record_dynamic_symbol (info, h->weakdef))
-            return false;
-        }
-    }
-
-  return true;
+            return FALSE;
+        }
+    }
+
+  return TRUE;
 }
 
@@ -2673 +2986 @@
   /* Version tree.  */
   struct bfd_elf_version_tree *verdefs;
-  /* Whether we are exporting all dynamic symbols.  */
-  boolean export_dynamic;
   /* Whether we had a failure.  */
-  boolean failed;
+  bfd_boolean failed;
 };
 
@@ -2691 +3002 @@
   unsigned int vers;
   /* Whether we had a failure.  */
-  boolean failed;
+  bfd_boolean failed;
 };
 
@@ -2723 +3034 @@
   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.  */
-  hashcodes = (unsigned long int *) bfd_malloc (dynsymcount
-                                                * sizeof (unsigned long int));
+  amt = dynsymcount;
+  amt *= sizeof (unsigned long int);
+  hashcodes = (unsigned long int *) bfd_malloc (amt);
   if (hashcodes == NULL)
     return 0;
@@ -2737 +3050 @@
                           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.  */
+  /* 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 == true)
+  if (info->optimize)
     {
       unsigned long int nsyms = hashcodesp - hashcodes;
@@ -2759 +3072 @@
       /* Create array where we count the collisions in.  We must use bfd_malloc
          since the size could be large.  */
-      counts = (unsigned long int *) bfd_malloc (maxsize
-                                                 * sizeof (unsigned long int));
+      amt = maxsize;
+      amt *= sizeof (unsigned long int);
+      counts = (unsigned long int *) bfd_malloc (amt);
       if (counts == NULL)
         {
@@ -2854 +3168 @@
    addresses of the various sections.  */
 
-boolean
+bfd_boolean
 NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
-                                     export_dynamic, filter_shlib,
+                                     filter_shlib,
                                      auxiliary_filters, info, sinterpptr,
                                      verdefs)
@@ -2862 +3176 @@
      const char *soname;
      const char *rpath;
-     boolean export_dynamic;
      const char *filter_shlib;
      const char * const *auxiliary_filters;
@@ -2879 +3192 @@
 
   if (info->hash->creator->flavour != bfd_target_elf_flavour)
-    return true;
+    return TRUE;
+
+  if (! is_elf_hash_table (info))
+    return TRUE;
+
+  /* Any syms created from now on start with -1 in
+     got.refcount/offset and plt.refcount/offset.  */
+  elf_hash_table (info)->init_refcount = elf_hash_table (info)->init_offset;
 
   /* The backend may have to create some sections regardless of whether
@@ -2886 +3206 @@
   if (bed->elf_backend_always_size_sections
       && ! (*bed->elf_backend_always_size_sections) (output_bfd, info))
-    return false;
+    return FALSE;
 
   dynobj = elf_hash_table (info)->dynobj;
@@ -2893 +3213 @@
      do here.  */
   if (dynobj == NULL)
-    return true;
+    return TRUE;
+
+  if (! _bfd_elf_maybe_strip_eh_frame_hdr (info))
+    return FALSE;
 
   if (elf_hash_table (info)->dynamic_sections_created)
@@ -2900 +3223 @@
       struct elf_link_hash_entry *h;
       asection *dynstr;
+      struct bfd_elf_version_tree *t;
+      struct bfd_elf_version_expr *d;
+      bfd_boolean all_defined;
 
       *sinterpptr = bfd_get_section_by_name (dynobj, ".interp");
@@ -2906 +3232 @@
       if (soname != NULL)
         {
-          soname_indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr,
-                                            soname, true, true);
+          soname_indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
+                                             soname, TRUE);
           if (soname_indx == (bfd_size_type) -1
-              || ! elf_add_dynamic_entry (info, DT_SONAME, soname_indx))
-            return false;
+              || ! elf_add_dynamic_entry (info, (bfd_vma) DT_SONAME,
+                                          soname_indx))
+            return FALSE;
         }
 
       if (info->symbolic)
         {
-          if (! elf_add_dynamic_entry (info, DT_SYMBOLIC, 0))
-            return false;
+          if (! elf_add_dynamic_entry (info, (bfd_vma) DT_SYMBOLIC,
+                                       (bfd_vma) 0))
+            return FALSE;
           info->flags |= DF_SYMBOLIC;
         }
@@ -2924 +3252 @@
           bfd_size_type indx;
 
-          indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr, rpath,
-                                     true, true);
+          indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, rpath,
+                                      TRUE);
+          if (info->new_dtags)
+            _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr, indx);
           if (indx == (bfd_size_type) -1
-              || ! elf_add_dynamic_entry (info, DT_RPATH, indx)
+              || ! elf_add_dynamic_entry (info, (bfd_vma) DT_RPATH, indx)
               || (info->new_dtags
-                  && ! elf_add_dynamic_entry (info, DT_RUNPATH, indx)))
-            return false;
+                  && ! elf_add_dynamic_entry (info, (bfd_vma) DT_RUNPATH,
+                                              indx)))
+            return FALSE;
         }
 
@@ -2937 +3268 @@
           bfd_size_type indx;
 
-          indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr,
-                                     filter_shlib, true, true);
+          indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
+                                      filter_shlib, TRUE);
           if (indx == (bfd_size_type) -1
-              || ! elf_add_dynamic_entry (info, DT_FILTER, indx))
-            return false;
+              || ! elf_add_dynamic_entry (info, (bfd_vma) DT_FILTER, indx))
+            return FALSE;
         }
 
@@ -2952 +3283 @@
               bfd_size_type indx;
 
-              indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr,
-                                         *p, true, true);
+              indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
+                                          *p, TRUE);
               if (indx == (bfd_size_type) -1
-                  || ! elf_add_dynamic_entry (info, DT_AUXILIARY, indx))
-                return false;
+                  || ! elf_add_dynamic_entry (info, (bfd_vma) DT_AUXILIARY,
+                                              indx))
+                return FALSE;
             }
         }
 
       eif.info = info;
-      eif.failed = false;
+      eif.verdefs = verdefs;
+      eif.failed = FALSE;
 
       /* If we are supposed to export all symbols into the dynamic symbol
-         table (this is not the normal case), then do so.  */
-      if (export_dynamic)
+         table (this is not the normal case), then do so.  */
+      if (info->export_dynamic)
         {
           elf_link_hash_traverse (elf_hash_table (info), elf_export_symbol,
-                                  (PTR) &eif);
+                                  (PTR) &eif);
           if (eif.failed)
-            return false;
-        }
+            return FALSE;
+        }
+
+      /* Make all global versions with definiton.  */
+      for (t = verdefs; t != NULL; t = t->next)
+        for (d = t->globals; d != NULL; d = d->next)
+          if (!d->symver && strchr (d->pattern, '*') == NULL)
+            {
+              const char *verstr, *name;
+              size_t namelen, verlen, newlen;
+              char *newname, *p;
+              struct elf_link_hash_entry *newh;
+
+              name = d->pattern;
+              namelen = strlen (name);
+              verstr = t->name;
+              verlen = strlen (verstr);
+              newlen = namelen + verlen + 3;
+
+              newname = (char *) bfd_malloc ((bfd_size_type) newlen);
+              if (newname == NULL)
+                return FALSE;
+              memcpy (newname, name, namelen);
+
+              /* Check the hidden versioned definition.  */
+              p = newname + namelen;
+              *p++ = ELF_VER_CHR;
+              memcpy (p, verstr, verlen + 1);
+              newh = elf_link_hash_lookup (elf_hash_table (info),
+                                           newname, FALSE, FALSE,
+                                           FALSE);
+              if (newh == NULL
+                  || (newh->root.type != bfd_link_hash_defined
+                      && newh->root.type != bfd_link_hash_defweak))
+                {
+                  /* Check the default versioned definition.  */
+                  *p++ = ELF_VER_CHR;
+                  memcpy (p, verstr, verlen + 1);
+                  newh = elf_link_hash_lookup (elf_hash_table (info),
+                                               newname, FALSE, FALSE,
+                                               FALSE);
+                }
+              free (newname);
+
+              /* Mark this version if there is a definition and it is
+                 not defined in a shared object.  */
+              if (newh != NULL
+                  && ((newh->elf_link_hash_flags
+                       & ELF_LINK_HASH_DEF_DYNAMIC) == 0)
+                  && (newh->root.type == bfd_link_hash_defined
+                      || newh->root.type == bfd_link_hash_defweak))
+                d->symver = 1;
+            }
 
       /* Attach all the symbols to their version information.  */
@@ -2977 +3361 @@
       asvinfo.info = info;
       asvinfo.verdefs = verdefs;
-      asvinfo.export_dynamic = export_dynamic;
-      asvinfo.failed = false;
+      asvinfo.failed = FALSE;
 
       elf_link_hash_traverse (elf_hash_table (info),
@@ -2984 +3367 @@
                               (PTR) &asvinfo);
       if (asvinfo.failed)
-        return false;
+        return FALSE;
+
+      if (!info->allow_undefined_version)
+        {
+          /* Check if all global versions have a definiton.  */
+          all_defined = TRUE;
+          for (t = verdefs; t != NULL; t = t->next)
+            for (d = t->globals; d != NULL; d = d->next)
+              if (!d->symver && !d->script
+                  && strchr (d->pattern, '*') == NULL)
+                {
+                  (*_bfd_error_handler)
+                    (_("%s: undefined version: %s"),
+                     d->pattern, t->name);
+                  all_defined = FALSE;
+                }
+
+          if (!all_defined)
+            {
+              bfd_set_error (bfd_error_bad_value);
+              return FALSE;
+            }
+        }
 
       /* Find all symbols which were defined in a dynamic object and make
@@ -2992 +3397 @@
                               (PTR) &eif);
       if (eif.failed)
-        return false;
+        return FALSE;
 
       /* Add some entries to the .dynamic section.  We fill in some of the
@@ -3002 +3407 @@
       h = (info->init_function
            ? elf_link_hash_lookup (elf_hash_table (info),
-                                   info->init_function, false,
-                                   false, false)
+                                   info->init_function, FALSE,
+                                   FALSE, FALSE)
            : NULL);
       if (h != NULL
@@ -3009 +3414 @@
                                         | ELF_LINK_HASH_DEF_REGULAR)) != 0)
         {
-          if (! elf_add_dynamic_entry (info, DT_INIT, 0))
-            return false;
+          if (! elf_add_dynamic_entry (info, (bfd_vma) DT_INIT, (bfd_vma) 0))
+            return FALSE;
         }
       h = (info->fini_function
            ? elf_link_hash_lookup (elf_hash_table (info),
-                                   info->fini_function, false,
-                                   false, false)
+                                   info->fini_function, FALSE,
+                                   FALSE, FALSE)
            : NULL);
       if (h != NULL
@@ -3021 +3426 @@
                                         | ELF_LINK_HASH_DEF_REGULAR)) != 0)
         {
-          if (! elf_add_dynamic_entry (info, DT_FINI, 0))
-            return false;
+          if (! elf_add_dynamic_entry (info, (bfd_vma) DT_FINI, (bfd_vma) 0))
+            return FALSE;
+        }
+
+      if (bfd_get_section_by_name (output_bfd, ".preinit_array") != NULL)
+        {
+          /* DT_PREINIT_ARRAY is not allowed in shared library.  */
+          if (info->shared)
+            {
+              bfd *sub;
+              asection *o;
+
+              for (sub = info->input_bfds; sub != NULL;
+                   sub = sub->link_next)
+                for (o = sub->sections; o != NULL; o = o->next)
+                  if (elf_section_data (o)->this_hdr.sh_type
+                      == SHT_PREINIT_ARRAY)
+                    {
+                      (*_bfd_error_handler)
+                        (_("%s: .preinit_array section is not allowed in DSO"),
+                         bfd_archive_filename (sub));
+                      break;
+                    }
+
+              bfd_set_error (bfd_error_nonrepresentable_section);
+              return FALSE;
+            }
+
+          if (!elf_add_dynamic_entry (info, (bfd_vma) DT_PREINIT_ARRAY,
+                                      (bfd_vma) 0)
+              || !elf_add_dynamic_entry (info, (bfd_vma) DT_PREINIT_ARRAYSZ,
+                                         (bfd_vma) 0))
+            return FALSE;
+        }
+      if (bfd_get_section_by_name (output_bfd, ".init_array") != NULL)
+        {
+          if (!elf_add_dynamic_entry (info, (bfd_vma) DT_INIT_ARRAY,
+                                      (bfd_vma) 0)
+              || !elf_add_dynamic_entry (info, (bfd_vma) DT_INIT_ARRAYSZ,
+                                         (bfd_vma) 0))
+            return FALSE;
+        }
+      if (bfd_get_section_by_name (output_bfd, ".fini_array") != NULL)
+        {
+          if (!elf_add_dynamic_entry (info, (bfd_vma) DT_FINI_ARRAY,
+                                      (bfd_vma) 0)
+              || !elf_add_dynamic_entry (info, (bfd_vma) DT_FINI_ARRAYSZ,
+                                         (bfd_vma) 0))
+            return FALSE;
         }
 
@@ -3034 +3486 @@
           bfd_size_type strsize;
 
-          strsize = _bfd_stringtab_size (elf_hash_table (info)->dynstr);
-          if (! elf_add_dynamic_entry (info, DT_HASH, 0)
-              || ! elf_add_dynamic_entry (info, DT_STRTAB, 0)
-              || ! elf_add_dynamic_entry (info, DT_SYMTAB, 0)
-              || ! elf_add_dynamic_entry (info, DT_STRSZ, strsize)
-              || ! elf_add_dynamic_entry (info, DT_SYMENT,
-                                          sizeof (Elf_External_Sym)))
-            return false;
+          strsize = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
+          if (! elf_add_dynamic_entry (info, (bfd_vma) DT_HASH, (bfd_vma) 0)
+              || ! elf_add_dynamic_entry (info, (bfd_vma) DT_STRTAB, (bfd_vma) 0)
+              || ! elf_add_dynamic_entry (info, (bfd_vma) DT_SYMTAB, (bfd_vma) 0)
+              || ! elf_add_dynamic_entry (info, (bfd_vma) DT_STRSZ, strsize)
+              || ! elf_add_dynamic_entry (info, (bfd_vma) DT_SYMENT,
+                                          (bfd_vma) sizeof (Elf_External_Sym)))
+            return FALSE;
         }
     }
@@ -3049 +3501 @@
   if (bed->elf_backend_size_dynamic_sections
       && ! (*bed->elf_backend_size_dynamic_sections) (output_bfd, info))
-    return false;
+    return FALSE;
 
   if (elf_hash_table (info)->dynamic_sections_created)
     {
-      size_t dynsymcount;
+      bfd_size_type dynsymcount;
       asection *s;
       size_t bucketcount = 0;
       size_t hash_entry_size;
+      unsigned int dtagcount;
 
       /* Set up the version definition section.  */
@@ -3063 +3516 @@
 
       /* We may have created additional version definitions if we are
-         just linking a regular application.  */
+         just linking a regular application.  */
       verdefs = asvinfo.verdefs;
+
+      /* Skip anonymous version tag.  */
+      if (verdefs != NULL && verdefs->vernum == 0)
+        verdefs = verdefs->next;
 
       if (verdefs == NULL)
@@ -3100 +3557 @@
           s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
           if (s->contents == NULL && s->_raw_size != 0)
-            return false;
+            return FALSE;
 
           /* Fill in the version definition section.  */
@@ -3116 +3573 @@
           if (soname_indx != (bfd_size_type) -1)
             {
+              _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
+                                      soname_indx);
               def.vd_hash = bfd_elf_hash (soname);
               defaux.vda_name = soname_indx;
@@ -3124 +3583 @@
               bfd_size_type indx;
 
-              name = output_bfd->filename;
+              name = basename (output_bfd->filename);
               def.vd_hash = bfd_elf_hash (name);
-              indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr,
-                                            name, true, false);
+              indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
+                                          name, FALSE);
               if (indx == (bfd_size_type) -1)
-                return false;
+                return FALSE;
               defaux.vda_name = indx;
             }
@@ -3135 +3594 @@
 
           _bfd_elf_swap_verdef_out (output_bfd, &def,
-                                    (Elf_External_Verdef *)p);
+                                    (Elf_External_Verdef *) p);
           p += sizeof (Elf_External_Verdef);
           _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
@@ -3146 +3605 @@
               struct bfd_elf_version_deps *n;
               struct elf_link_hash_entry *h;
+              struct bfd_link_hash_entry *bh;
 
               cdeps = 0;
@@ -3152 +3612 @@
 
               /* Add a symbol representing this version.  */
-              h = NULL;
+              bh = NULL;
               if (! (_bfd_generic_link_add_one_symbol
                      (info, dynobj, t->name, BSF_GLOBAL, bfd_abs_section_ptr,
-                      (bfd_vma) 0, (const char *) NULL, false,
-                      get_elf_backend_data (dynobj)->collect,
-                      (struct bfd_link_hash_entry **) &h)))
-                return false;
+                      (bfd_vma) 0, (const char *) NULL, FALSE,
+                      get_elf_backend_data (dynobj)->collect, &bh)))
+                return FALSE;
+              h = (struct elf_link_hash_entry *) bh;
               h->elf_link_hash_flags &= ~ ELF_LINK_NON_ELF;
               h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
@@ -3165 +3625 @@
 
               if (! _bfd_elf_link_record_dynamic_symbol (info, h))
-                return false;
+                return FALSE;
 
               def.vd_version = VER_DEF_CURRENT;
@@ -3186 +3646 @@
 
               defaux.vda_name = h->dynstr_index;
+              _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
+                                      h->dynstr_index);
               if (t->deps == NULL)
                 defaux.vda_next = 0;
@@ -3205 +3667 @@
                     }
                   else
-                    defaux.vda_name = n->version_needed->name_indx;
+                    {
+                      defaux.vda_name = n->version_needed->name_indx;
+                      _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
+                                              defaux.vda_name);
+                    }
                   if (n->next == NULL)
                     defaux.vda_next = 0;
@@ -3217 +3683 @@
             }
 
-          if (! elf_add_dynamic_entry (info, DT_VERDEF, 0)
-              || ! elf_add_dynamic_entry (info, DT_VERDEFNUM, cdefs))
-            return false;
+          if (! elf_add_dynamic_entry (info, (bfd_vma) DT_VERDEF, (bfd_vma) 0)
+              || ! elf_add_dynamic_entry (info, (bfd_vma) DT_VERDEFNUM,
+                                          (bfd_vma) cdefs))
+            return FALSE;
 
           elf_tdata (output_bfd)->cverdefs = cdefs;
         }
 
-      if (info->new_dtags && info->flags)
-        {
-          if (! elf_add_dynamic_entry (info, DT_FLAGS, info->flags))
-            return false;
+      if ((info->new_dtags && info->flags) || (info->flags & DF_STATIC_TLS))
+        {
+          if (! elf_add_dynamic_entry (info, (bfd_vma) DT_FLAGS, info->flags))
+            return FALSE;
         }
 
@@ -3236 +3703 @@
                                 | DF_1_NODELETE
                                 | DF_1_NOOPEN);
-          if (! elf_add_dynamic_entry (info, DT_FLAGS_1, info->flags_1))
-            return false;
+          if (! elf_add_dynamic_entry (info, (bfd_vma) DT_FLAGS_1,
+                                       info->flags_1))
+            return FALSE;
         }
 
@@ -3252 +3720 @@
         if (sinfo.vers == 0)
           sinfo.vers = 1;
-        sinfo.failed = false;
+        sinfo.failed = FALSE;
 
         elf_link_hash_traverse (elf_hash_table (info),
@@ -3283 +3751 @@
 
             s->_raw_size = size;
-            s->contents = (bfd_byte *) bfd_alloc (output_bfd, size);
+            s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
             if (s->contents == NULL)
-              return false;
+              return FALSE;
 
             p = s->contents;
@@ -3302 +3770 @@
                 t->vn_version = VER_NEED_CURRENT;
                 t->vn_cnt = caux;
-                if (elf_dt_name (t->vn_bfd) != NULL)
-                  indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr,
-                                             elf_dt_name (t->vn_bfd),
-                                             true, false);
-                else
-                  indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr,
-                                             t->vn_bfd->filename, true, false);
+                indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
+                                            elf_dt_name (t->vn_bfd) != NULL
+                                            ? elf_dt_name (t->vn_bfd)
+                                            : basename (t->vn_bfd->filename),
+                                            FALSE);
                 if (indx == (bfd_size_type) -1)
-                  return false;
+                  return FALSE;
                 t->vn_file = indx;
                 t->vn_aux = sizeof (Elf_External_Verneed);
@@ -3326 +3792 @@
                   {
                     a->vna_hash = bfd_elf_hash (a->vna_nodename);
-                    indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr,
-                                               a->vna_nodename, true, false);
+                    indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
+                                                a->vna_nodename, FALSE);
                     if (indx == (bfd_size_type) -1)
-                      return false;
+                      return FALSE;
                     a->vna_name = indx;
                     if (a->vna_nextptr == NULL)
@@ -3342 +3808 @@
               }
 
-            if (! elf_add_dynamic_entry (info, DT_VERNEED, 0)
-                || ! elf_add_dynamic_entry (info, DT_VERNEEDNUM, crefs))
-              return false;
+            if (! elf_add_dynamic_entry (info, (bfd_vma) DT_VERNEED,
+                                         (bfd_vma) 0)
+                || ! elf_add_dynamic_entry (info, (bfd_vma) DT_VERNEEDNUM,
+                                            (bfd_vma) crefs))
+              return FALSE;
 
             elf_tdata (output_bfd)->cverrefs = crefs;
@@ -3373 +3841 @@
           s->contents = (bfd_byte *) bfd_zalloc (output_bfd, s->_raw_size);
           if (s->contents == NULL)
-            return false;
-
-          if (! elf_add_dynamic_entry (info, DT_VERSYM, 0))
-            return false;
+            return FALSE;
+
+          if (! elf_add_dynamic_entry (info, (bfd_vma) DT_VERSYM, (bfd_vma) 0))
+            return FALSE;
         }
 
@@ -3390 +3858 @@
       s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
       if (s->contents == NULL && s->_raw_size != 0)
-        return false;
+        return FALSE;
 
       if (dynsymcount != 0)
@@ -3403 +3871 @@
           isym.st_other = 0;
           isym.st_shndx = 0;
-          elf_swap_symbol_out (output_bfd, &isym,
-                               (PTR) (Elf_External_Sym *) s->contents);
+          elf_swap_symbol_out (output_bfd, &isym, (PTR) s->contents, (PTR) 0);
         }
 
@@ -3415 +3882 @@
       hash_entry_size = elf_section_data (s)->this_hdr.sh_entsize;
       s->_raw_size = ((2 + bucketcount + dynsymcount) * hash_entry_size);
-      s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
+      s->contents = (bfd_byte *) bfd_zalloc (output_bfd, s->_raw_size);
       if (s->contents == NULL)
-        return false;
-      memset (s->contents, 0, (size_t) s->_raw_size);
-
-      bfd_put (8 * hash_entry_size, output_bfd, bucketcount, s->contents);
-      bfd_put (8 * hash_entry_size, output_bfd, dynsymcount,
+        return FALSE;
+
+      bfd_put (8 * hash_entry_size, output_bfd, (bfd_vma) bucketcount,
+               s->contents);
+      bfd_put (8 * hash_entry_size, output_bfd, (bfd_vma) dynsymcount,
                s->contents + hash_entry_size);
 
@@ -3428 +3895 @@
       s = bfd_get_section_by_name (dynobj, ".dynstr");
       BFD_ASSERT (s != NULL);
-      s->_raw_size = _bfd_stringtab_size (elf_hash_table (info)->dynstr);
-
-      if (! elf_add_dynamic_entry (info, DT_NULL, 0))
-        return false;
-    }
-
-  return true;
+
+      elf_finalize_dynstr (output_bfd, info);
+
+      s->_raw_size = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
+
+      for (dtagcount = 0; dtagcount <= info->spare_dynamic_tags; ++dtagcount)
+        if (! elf_add_dynamic_entry (info, (bfd_vma) DT_NULL, (bfd_vma) 0))
+          return FALSE;
+    }
+
+  return TRUE;
 }
 
+
+/* This function is used to adjust offsets into .dynstr for
+   dynamic symbols.  This is called via elf_link_hash_traverse.  */
+
+static bfd_boolean elf_adjust_dynstr_offsets
+  PARAMS ((struct elf_link_hash_entry *, PTR));
+
+static bfd_boolean
+elf_adjust_dynstr_offsets (h, data)
+     struct elf_link_hash_entry *h;
+     PTR data;
+{
+  struct elf_strtab_hash *dynstr = (struct elf_strtab_hash *) 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->dynstr_index = _bfd_elf_strtab_offset (dynstr, h->dynstr_index);
+  return TRUE;
+}
+
+/* Assign string offsets in .dynstr, update all structures referencing
+   them.  */
+
+static bfd_boolean
+elf_finalize_dynstr (output_bfd, info)
+     bfd *output_bfd;
+     struct bfd_link_info *info;
+{
+  struct elf_link_local_dynamic_entry *entry;
+  struct elf_strtab_hash *dynstr = elf_hash_table (info)->dynstr;
+  bfd *dynobj = elf_hash_table (info)->dynobj;
+  asection *sdyn;
+  bfd_size_type size;
+  Elf_External_Dyn *dyncon, *dynconend;
+
+  _bfd_elf_strtab_finalize (dynstr);
+  size = _bfd_elf_strtab_size (dynstr);
+
+  /* Update all .dynamic entries referencing .dynstr strings.  */
+  sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
+  BFD_ASSERT (sdyn != NULL);
+
+  dyncon = (Elf_External_Dyn *) sdyn->contents;
+  dynconend = (Elf_External_Dyn *) (sdyn->contents +
+                                    sdyn->_raw_size);
+  for (; dyncon < dynconend; dyncon++)
+    {
+      Elf_Internal_Dyn dyn;
+
+      elf_swap_dyn_in (dynobj, dyncon, & dyn);
+      switch (dyn.d_tag)
+        {
+        case DT_STRSZ:
+          dyn.d_un.d_val = size;
+          elf_swap_dyn_out (dynobj, & dyn, dyncon);
+          break;
+        case DT_NEEDED:
+        case DT_SONAME:
+        case DT_RPATH:
+        case DT_RUNPATH:
+        case DT_FILTER:
+        case DT_AUXILIARY:
+          dyn.d_un.d_val = _bfd_elf_strtab_offset (dynstr, dyn.d_un.d_val);
+          elf_swap_dyn_out (dynobj, & dyn, dyncon);
+          break;
+        default:
+          break;
+        }
+    }
+
+  /* Now update local dynamic symbols.  */
+  for (entry = elf_hash_table (info)->dynlocal; entry ; entry = entry->next)
+    entry->isym.st_name = _bfd_elf_strtab_offset (dynstr,
+                                                  entry->isym.st_name);
+
+  /* And the rest of dynamic symbols.  */
+  elf_link_hash_traverse (elf_hash_table (info),
+                          elf_adjust_dynstr_offsets, dynstr);
+
+  /* Adjust version definitions.  */
+  if (elf_tdata (output_bfd)->cverdefs)
+    {
+      asection *s;
+      bfd_byte *p;
+      bfd_size_type i;
+      Elf_Internal_Verdef def;
+      Elf_Internal_Verdaux defaux;
+
+      s = bfd_get_section_by_name (dynobj, ".gnu.version_d");
+      p = (bfd_byte *) s->contents;
+      do
+        {
+          _bfd_elf_swap_verdef_in (output_bfd, (Elf_External_Verdef *) p,
+                                   &def);
+          p += sizeof (Elf_External_Verdef);
+          for (i = 0; i < def.vd_cnt; ++i)
+            {
+              _bfd_elf_swap_verdaux_in (output_bfd,
+                                        (Elf_External_Verdaux *) p, &defaux);
+              defaux.vda_name = _bfd_elf_strtab_offset (dynstr,
+                                                        defaux.vda_name);
+              _bfd_elf_swap_verdaux_out (output_bfd,
+                                         &defaux, (Elf_External_Verdaux *) p);
+              p += sizeof (Elf_External_Verdaux);
+            }
+        }
+      while (def.vd_next);
+    }
+
+  /* Adjust version references.  */
+  if (elf_tdata (output_bfd)->verref)
+    {
+      asection *s;
+      bfd_byte *p;
+      bfd_size_type i;
+      Elf_Internal_Verneed need;
+      Elf_Internal_Vernaux needaux;
+
+      s = bfd_get_section_by_name (dynobj, ".gnu.version_r");
+      p = (bfd_byte *) s->contents;
+      do
+        {
+          _bfd_elf_swap_verneed_in (output_bfd, (Elf_External_Verneed *) p,
+                                    &need);
+          need.vn_file = _bfd_elf_strtab_offset (dynstr, need.vn_file);
+          _bfd_elf_swap_verneed_out (output_bfd, &need,
+                                     (Elf_External_Verneed *) p);
+          p += sizeof (Elf_External_Verneed);
+          for (i = 0; i < need.vn_cnt; ++i)
+            {
+              _bfd_elf_swap_vernaux_in (output_bfd,
+                                        (Elf_External_Vernaux *) p, &needaux);
+              needaux.vna_name = _bfd_elf_strtab_offset (dynstr,
+                                                         needaux.vna_name);
+              _bfd_elf_swap_vernaux_out (output_bfd,
+                                         &needaux,
+                                         (Elf_External_Vernaux *) p);
+              p += sizeof (Elf_External_Vernaux);
+            }
+        }
+      while (need.vn_next);
+    }
+
+  return TRUE;
+}
 
 /* Fix up the flags for a symbol.  This handles various cases which
@@ -3444 +4062 @@
    the face of future changes.  */
 
-static boolean
+static bfd_boolean
 elf_fix_symbol_flags (h, eif)
      struct elf_link_hash_entry *h;
@@ -3479 +4097 @@
           if (! _bfd_elf_link_record_dynamic_symbol (eif->info, h))
             {
-              eif->failed = true;
-              return false;
+              eif->failed = TRUE;
+              return FALSE;
             }
         }
@@ -3487 +4105 @@
     {
       /* Unfortunately, ELF_LINK_NON_ELF is only correct if the symbol
-         was first seen in a non-ELF file.  Fortunately, if the symbol
-         was first seen in an ELF file, we're probably OK unless the
-         symbol was defined in a non-ELF file.  Catch that case here.
-         FIXME: We're still in trouble if the symbol was first seen in
-         a dynamic object, and then later in a non-ELF regular object.  */
+         was first seen in a non-ELF file.  Fortunately, if the symbol
+         was first seen in an ELF file, we're probably OK unless the
+         symbol was defined in a non-ELF file.  Catch that case here.
+         FIXME: We're still in trouble if the symbol was first seen in
+         a dynamic object, and then later in a non-ELF regular object.  */
       if ((h->root.type == bfd_link_hash_defined
            || h->root.type == bfd_link_hash_defweak)
@@ -3526 +4144 @@
   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0
       && eif->info->shared
+      && is_elf_hash_table (eif->info)
       && (eif->info->symbolic
           || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
@@ -3532 +4151 @@
     {
       struct elf_backend_data *bed;
+      bfd_boolean force_local;
+
       bed = get_elf_backend_data (elf_hash_table (eif->info)->dynobj);
-      if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
-          || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
-        h->elf_link_hash_flags |= ELF_LINK_FORCED_LOCAL;
-      (*bed->elf_backend_hide_symbol) (eif->info, h);
+
+      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);
     }
 
@@ -3546 +4167 @@
       struct elf_link_hash_entry *weakdef;
 
+      weakdef = h->weakdef;
+      if (h->root.type == bfd_link_hash_indirect)
+        h = (struct elf_link_hash_entry *) h->root.u.i.link;
+
       BFD_ASSERT (h->root.type == bfd_link_hash_defined
                   || h->root.type == bfd_link_hash_defweak);
-      weakdef = h->weakdef;
       BFD_ASSERT (weakdef->root.type == bfd_link_hash_defined
                   || weakdef->root.type == bfd_link_hash_defweak);
@@ -3559 +4183 @@
         h->weakdef = NULL;
       else
-        weakdef->elf_link_hash_flags |=
-          (h->elf_link_hash_flags
-           & (ELF_LINK_HASH_REF_REGULAR
-              | ELF_LINK_HASH_REF_REGULAR_NONWEAK
-              | ELF_LINK_NON_GOT_REF));
-    }
-
-  return true;
+        {
+          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);
+        }
+    }
+
+  return TRUE;
 }
 
@@ -3573 +4198 @@
    recursively.  */
 
-static boolean
+static bfd_boolean
 elf_adjust_dynamic_symbol (h, data)
      struct elf_link_hash_entry *h;
@@ -3582 +4207 @@
   struct elf_backend_data *bed;
 
+  if (! is_elf_hash_table (eif->info))
+    return FALSE;
+
+  if (h->root.type == bfd_link_hash_warning)
+    {
+      h->plt = elf_hash_table (eif->info)->init_offset;
+      h->got = elf_hash_table (eif->info)->init_offset;
+
+      /* When warning symbols are created, they **replace** the "real"
+         entry in the hash table, thus we never get to see the real
+         symbol in a hash traversal.  So look at it now.  */
+      h = (struct elf_link_hash_entry *) h->root.u.i.link;
+    }
+
   /* Ignore indirect symbols.  These are added by the versioning code.  */
   if (h->root.type == bfd_link_hash_indirect)
-    return true;
+    return TRUE;
 
   /* Fix the symbol flags.  */
   if (! elf_fix_symbol_flags (h, eif))
-    return false;
+    return FALSE;
 
   /* If this symbol does not require a PLT entry, and it is not
@@ -3603 +4242 @@
               && (h->weakdef == NULL || h->weakdef->dynindx == -1))))
     {
-      h->plt.offset = (bfd_vma) -1;
-      return true;
+      h->plt = elf_hash_table (eif->info)->init_offset;
+      return TRUE;
     }
 
@@ -3610 +4249 @@
      can happen via a recursive call.  */
   if ((h->elf_link_hash_flags & ELF_LINK_HASH_DYNAMIC_ADJUSTED) != 0)
-    return true;
+    return TRUE;
 
   /* Don't look at this symbol again.  Note that we must set this
@@ -3655 +4294 @@
 
       if (! elf_adjust_dynamic_symbol (h->weakdef, (PTR) eif))
-        return false;
+        return FALSE;
     }
 
@@ -3668 +4307 @@
     (*_bfd_error_handler)
       (_("warning: type and size of dynamic symbol `%s' are not defined"),
-         h->root.root.string);
+       h->root.root.string);
 
   dynobj = elf_hash_table (eif->info)->dynobj;
@@ -3674 +4313 @@
   if (! (*bed->elf_backend_adjust_dynamic_symbol) (eif->info, h))
     {
-      eif->failed = true;
-      return false;
-    }
-
-  return true;
+      eif->failed = TRUE;
+      return FALSE;
+    }
+
+  return TRUE;
 }
 
@@ -3685 +4324 @@
    symbol table.  It is called via elf_link_hash_traverse.  */
 
-static boolean
+static bfd_boolean
 elf_export_symbol (h, data)
      struct elf_link_hash_entry *h;
@@ -3694 +4333 @@
   /* Ignore indirect symbols.  These are added by the versioning code.  */
   if (h->root.type == bfd_link_hash_indirect)
-    return true;
+    return TRUE;
+
+  if (h->root.type == bfd_link_hash_warning)
+    h = (struct elf_link_hash_entry *) h->root.u.i.link;
 
   if (h->dynindx == -1
@@ -3700 +4342 @@
           & (ELF_LINK_HASH_DEF_REGULAR | ELF_LINK_HASH_REF_REGULAR)) != 0)
     {
-      if (! _bfd_elf_link_record_dynamic_symbol (eif->info, h))
-        {
-          eif->failed = true;
-          return false;
-        }
-    }
-
-  return true;
+      struct bfd_elf_version_tree *t;
+      struct bfd_elf_version_expr *d;
+
+      for (t = eif->verdefs; t != NULL; t = t->next)
+        {
+          if (t->globals != NULL)
+            {
+              for (d = t->globals; d != NULL; d = d->next)
+                {
+                  if ((*d->match) (d, h->root.root.string))
+                    goto doit;
+                }
+            }
+
+          if (t->locals != NULL)
+            {
+              for (d = t->locals ; d != NULL; d = d->next)
+                {
+                  if ((*d->match) (d, h->root.root.string))
+                    return TRUE;
+                }
+            }
+        }
+
+      if (!eif->verdefs)
+        {
+        doit:
+          if (! _bfd_elf_link_record_dynamic_symbol (eif->info, h))
+            {
+              eif->failed = TRUE;
+              return FALSE;
+            }
+        }
+    }
+
+  return TRUE;
 }
 
@@ -3716 +4386 @@
    This function is called via elf_link_hash_traverse.  */
 
-static boolean
+static bfd_boolean
 elf_link_find_version_dependencies (h, data)
      struct elf_link_hash_entry *h;
@@ -3724 +4394 @@
   Elf_Internal_Verneed *t;
   Elf_Internal_Vernaux *a;
+  bfd_size_type amt;
+
+  if (h->root.type == bfd_link_hash_warning)
+    h = (struct elf_link_hash_entry *) h->root.u.i.link;
 
   /* We only care about symbols defined in shared objects with version
@@ -3731 +4405 @@
       || h->dynindx == -1
       || h->verinfo.verdef == NULL)
-    return true;
+    return TRUE;
 
   /* See if we already know about this version.  */
@@ -3741 +4415 @@
       for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
         if (a->vna_nodename == h->verinfo.verdef->vd_nodename)
-          return true;
+          return TRUE;
 
       break;
@@ -3750 +4424 @@
   if (t == NULL)
     {
-      t = (Elf_Internal_Verneed *) bfd_zalloc (rinfo->output_bfd, sizeof *t);
+      amt = sizeof *t;
+      t = (Elf_Internal_Verneed *) bfd_zalloc (rinfo->output_bfd, amt);
       if (t == NULL)
         {
-          rinfo->failed = true;
-          return false;
+          rinfo->failed = TRUE;
+          return FALSE;
         }
 
@@ -3762 +4437 @@
     }
 
-  a = (Elf_Internal_Vernaux *) bfd_zalloc (rinfo->output_bfd, sizeof *a);
+  amt = sizeof *a;
+  a = (Elf_Internal_Vernaux *) bfd_zalloc (rinfo->output_bfd, amt);
 
   /* Note that we are copying a string pointer here, and testing it
@@ -3780 +4456 @@
   t->vn_auxptr = a;
 
-  return true;
+  return TRUE;
 }
 
@@ -3788 +4464 @@
    local.  This function is called via elf_link_hash_traverse.  */
 
-static boolean
+static bfd_boolean
 elf_link_assign_sym_version (h, data)
      struct elf_link_hash_entry *h;
      PTR data;
 {
-  struct elf_assign_sym_version_info *sinfo =
-    (struct elf_assign_sym_version_info *) data;
-  struct bfd_link_info *info = sinfo->info;
+  struct elf_assign_sym_version_info *sinfo;
+  struct bfd_link_info *info;
   struct elf_backend_data *bed;
   struct elf_info_failed eif;
   char *p;
+  bfd_size_type amt;
+
+  sinfo = (struct elf_assign_sym_version_info *) data;
+  info = sinfo->info;
+
+  if (h->root.type == bfd_link_hash_warning)
+    h = (struct elf_link_hash_entry *) h->root.u.i.link;
 
   /* Fix the symbol flags.  */
-  eif.failed = false;
+  eif.failed = FALSE;
   eif.info = info;
   if (! elf_fix_symbol_flags (h, &eif))
     {
       if (eif.failed)
-        sinfo->failed = true;
-      return false;
+        sinfo->failed = TRUE;
+      return FALSE;
     }
 
@@ -3813 +4495 @@
      objects.  */
   if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
-    return true;
+    return TRUE;
 
   bed = get_elf_backend_data (sinfo->output_bfd);
@@ -3820 +4502 @@
     {
       struct bfd_elf_version_tree *t;
-      boolean hidden;
-
-      hidden = true;
+      bfd_boolean hidden;
+
+      hidden = TRUE;
 
       /* There are two consecutive ELF_VER_CHR characters if this is
-         not a hidden symbol.  */
+         not a hidden symbol.  */
       ++p;
       if (*p == ELF_VER_CHR)
         {
-          hidden = false;
+          hidden = FALSE;
           ++p;
         }
@@ -3838 +4520 @@
           if (hidden)
             h->elf_link_hash_flags |= ELF_LINK_HIDDEN;
-          return true;
+          return TRUE;
         }
 
@@ -3846 +4528 @@
           if (strcmp (t->name, p) == 0)
             {
-              int len;
+              size_t len;
               char *alc;
               struct bfd_elf_version_expr *d;
 
               len = p - h->root.root.string;
-              alc = bfd_alloc (sinfo->output_bfd, len);
+              alc = bfd_malloc ((bfd_size_type) len);
               if (alc == NULL)
-                return false;
-              strncpy (alc, h->root.root.string, len - 1);
+                return FALSE;
+              memcpy (alc, h->root.root.string, len - 1);
               alc[len - 1] = '\0';
               if (alc[len - 2] == ELF_VER_CHR)
-                alc[len - 2] = '\0';
+                alc[len - 2] = '\0';
 
               h->verinfo.vertree = t;
-              t->used = true;
+              t->used = TRUE;
               d = NULL;
 
@@ -3871 +4553 @@
 
               /* See if there is anything to force this symbol to
-                 local scope.  */
+                 local scope.  */
               if (d == NULL && t->locals != NULL)
                 {
@@ -3880 +4562 @@
                           if (h->dynindx != -1
                               && info->shared
-                              && ! sinfo->export_dynamic)
+                              && ! info->export_dynamic)
                             {
-                              h->elf_link_hash_flags |= ELF_LINK_FORCED_LOCAL;
-                              (*bed->elf_backend_hide_symbol) (info, h);
-                              /* FIXME: The name of the symbol has
-                                 already been recorded in the dynamic
-                                 string table section.  */
+                              (*bed->elf_backend_hide_symbol) (info, h, TRUE);
                             }
 
@@ -3894 +4572 @@
                 }
 
-              bfd_release (sinfo->output_bfd, alc);
+              free (alc);
               break;
             }
@@ -3900 +4578 @@
 
       /* If we are building an application, we need to create a
-         version node for this version.  */
+         version node for this version.  */
       if (t == NULL && ! info->shared)
         {
@@ -3907 +4585 @@
 
           /* If we aren't going to export this symbol, we don't need
-             to worry about it.  */
+             to worry about it.  */
           if (h->dynindx == -1)
-            return true;
-
+            return TRUE;
+
+          amt = sizeof *t;
           t = ((struct bfd_elf_version_tree *)
-               bfd_alloc (sinfo->output_bfd, sizeof *t));
+               bfd_alloc (sinfo->output_bfd, amt));
           if (t == NULL)
             {
-              sinfo->failed = true;
-              return false;
+              sinfo->failed = TRUE;
+              return FALSE;
             }
 
@@ -3925 +4604 @@
           t->deps = NULL;
           t->name_indx = (unsigned int) -1;
-          t->used = true;
+          t->used = TRUE;
 
           version_index = 1;
+          /* Don't count anonymous version tag.  */
+          if (sinfo->verdefs != NULL && sinfo->verdefs->vernum == 0)
+            version_index = 0;
           for (pp = &sinfo->verdefs; *pp != NULL; pp = &(*pp)->next)
             ++version_index;
@@ -3939 +4621 @@
         {
           /* We could not find the version for a symbol when
-             generating a shared archive.  Return an error.  */
+             generating a shared archive.  Return an error.  */
           (*_bfd_error_handler)
             (_("%s: undefined versioned symbol name %s"),
              bfd_get_filename (sinfo->output_bfd), h->root.root.string);
           bfd_set_error (bfd_error_bad_value);
-          sinfo->failed = true;
-          return false;
+          sinfo->failed = TRUE;
+          return FALSE;
         }
 
@@ -3957 +4639 @@
     {
       struct bfd_elf_version_tree *t;
-      struct bfd_elf_version_tree *deflt;
+      struct bfd_elf_version_tree *local_ver;
       struct bfd_elf_version_expr *d;
 
       /* See if can find what version this symbol is in.  If the
-         symbol is supposed to be local, then don't actually register
-         it.  */
-      deflt = NULL;
+         symbol is supposed to be local, then don't actually register
+         it.  */
+      local_ver = NULL;
       for (t = sinfo->verdefs; t != NULL; t = t->next)
         {
           if (t->globals != NULL)
             {
+              bfd_boolean matched;
+
+              matched = FALSE;
               for (d = t->globals; d != NULL; d = d->next)
                 {
                   if ((*d->match) (d, h->root.root.string))
                     {
-                      h->verinfo.vertree = t;
-                      break;
+                      if (d->symver)
+                        matched = TRUE;
+                      else
+                        {
+                          /* There is a version without definition.  Make
+                             the symbol the default definition for this
+                             version.  */
+                          h->verinfo.vertree = t;
+                          local_ver = NULL;
+                          d->script = 1;
+                          break;
+                        }
                     }
                 }
@@ -3979 +4674 @@
               if (d != NULL)
                 break;
+              else if (matched)
+                /* There is no undefined version for this symbol. Hide the
+                   default one.  */
+                (*bed->elf_backend_hide_symbol) (info, h, TRUE);
             }
 
@@ -3985 +4684 @@
               for (d = t->locals; d != NULL; d = d->next)
                 {
+                  /* If the match is "*", keep looking for a more
+                     explicit, perhaps even global, match.  */
                   if (d->pattern[0] == '*' && d->pattern[1] == '\0')
-                    deflt = t;
+                    local_ver = t;
                   else if ((*d->match) (d, h->root.root.string))
                     {
-                      h->verinfo.vertree = t;
-                      if (h->dynindx != -1
-                          && info->shared
-                          && ! sinfo->export_dynamic)
-                        {
-                          h->elf_link_hash_flags |= ELF_LINK_FORCED_LOCAL;
-                          (*bed->elf_backend_hide_symbol) (info, h);
-                          /* FIXME: The name of the symbol has already
-                             been recorded in the dynamic string table
-                             section.  */
-                        }
+                      local_ver = t;
                       break;
                     }
@@ -4009 +4700 @@
         }
 
-      if (deflt != NULL && h->verinfo.vertree == NULL)
-        {
-          h->verinfo.vertree = deflt;
+      if (local_ver != NULL)
+        {
+          h->verinfo.vertree = local_ver;
           if (h->dynindx != -1
               && info->shared
-              && ! sinfo->export_dynamic)
+              && ! info->export_dynamic)
             {
-              h->elf_link_hash_flags |= ELF_LINK_FORCED_LOCAL;
-              (*bed->elf_backend_hide_symbol) (info, h);
-              /* FIXME: The name of the symbol has already been
-                 recorded in the dynamic string table section.  */
+              (*bed->elf_backend_hide_symbol) (info, h, TRUE);
             }
         }
     }
 
-  return true;
+  return TRUE;
 }
 
@@ -4046 +4734 @@
   /* symbol version section (.gnu.version).  */
   asection *symver_sec;
+  /* first SHF_TLS section (if any).  */
+  asection *first_tls_sec;
   /* Buffer large enough to hold contents of any section.  */
   bfd_byte *contents;
@@ -4055 +4745 @@
      BFD.  */
   Elf_External_Sym *external_syms;
+  /* And a buffer for symbol section indices.  */
+  Elf_External_Sym_Shndx *locsym_shndx;
   /* Buffer large enough to hold internal local symbols of any input
      BFD.  */
@@ -4066 +4758 @@
   /* Buffer to hold swapped out symbols.  */
   Elf_External_Sym *symbuf;
+  /* And one for symbol section indices.  */
+  Elf_External_Sym_Shndx *symshndxbuf;
   /* Number of swapped out symbols in buffer.  */
   size_t symbuf_count;
   /* Number of symbols which fit in symbuf.  */
   size_t symbuf_size;
+  /* And same for symshndxbuf.  */
+  size_t shndxbuf_size;
 };
 
-static boolean elf_link_output_sym
+static bfd_boolean elf_link_output_sym
   PARAMS ((struct elf_final_link_info *, const char *,
            Elf_Internal_Sym *, asection *));
-static boolean elf_link_flush_output_syms
+static bfd_boolean elf_link_flush_output_syms
   PARAMS ((struct elf_final_link_info *));
-static boolean elf_link_output_extsym
+static bfd_boolean elf_link_output_extsym
   PARAMS ((struct elf_link_hash_entry *, PTR));
-static boolean elf_link_input_bfd
+static bfd_boolean elf_link_sec_merge_syms
+  PARAMS ((struct elf_link_hash_entry *, PTR));
+static bfd_boolean elf_link_check_versioned_symbol
+  PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
+static bfd_boolean elf_link_input_bfd
   PARAMS ((struct elf_final_link_info *, bfd *));
-static boolean elf_reloc_link_order
+static bfd_boolean elf_reloc_link_order
   PARAMS ((bfd *, struct bfd_link_info *, asection *,
            struct bfd_link_order *));
@@ -4089 +4789 @@
 struct elf_outext_info
 {
-  boolean failed;
-  boolean localsyms;
+  bfd_boolean failed;
+  bfd_boolean localsyms;
   struct elf_final_link_info *finfo;
 };
@@ -4097 +4797 @@
    section header for a section containing relocations for O.  */
 
-static boolean
+static bfd_boolean
 elf_link_size_reloc_section (abfd, rel_hdr, o)
      bfd *abfd;
@@ -4103 +4803 @@
      asection *o;
 {
-  unsigned reloc_count;
+  bfd_size_type reloc_count;
+  bfd_size_type num_rel_hashes;
 
   /* Figure out how many relocations there will be.  */
@@ -4110 +4811 @@
   else
     reloc_count = elf_section_data (o)->rel_count2;
+
+  num_rel_hashes = o->reloc_count;
+  if (num_rel_hashes < reloc_count)
+    num_rel_hashes = reloc_count;
 
   /* That allows us to calculate the size of the section.  */
@@ -4120 +4825 @@
   rel_hdr->contents = (PTR) bfd_zalloc (abfd, rel_hdr->sh_size);
   if (rel_hdr->contents == NULL && rel_hdr->sh_size != 0)
-    return false;
+    return FALSE;
 
   /* We only allocate one set of hash entries, so we only do it the
      first time we are called.  */
-  if (elf_section_data (o)->rel_hashes == NULL)
+  if (elf_section_data (o)->rel_hashes == NULL
+      && num_rel_hashes)
     {
       struct elf_link_hash_entry **p;
 
       p = ((struct elf_link_hash_entry **)
-           bfd_zmalloc (o->reloc_count
+           bfd_zmalloc (num_rel_hashes
                         * sizeof (struct elf_link_hash_entry *)));
-      if (p == NULL && o->reloc_count != 0)
-        return false;
+      if (p == NULL)
+        return FALSE;
 
       elf_section_data (o)->rel_hashes = p;
     }
 
-  return true;
+  return TRUE;
 }
 
@@ -4154 +4860 @@
   unsigned int i;
   struct elf_backend_data *bed = get_elf_backend_data (abfd);
-  Elf_Internal_Rel *irel;
-  Elf_Internal_Rela *irela;
-
-  irel = (Elf_Internal_Rel *) bfd_zmalloc (sizeof (Elf_Internal_Rel)
-                                           * bed->s->int_rels_per_ext_rel);
-  if (irel == NULL)
-    {
-      (*_bfd_error_handler) (_("Error: out of memory"));
-      abort ();
-    }
-
-  irela = (Elf_Internal_Rela *) bfd_zmalloc (sizeof (Elf_Internal_Rela)
-                                             * bed->s->int_rels_per_ext_rel);
-  if (irela == NULL)
-    {
-      (*_bfd_error_handler) (_("Error: out of memory"));
-      abort ();
-    }
-
-  for (i = 0; i < count; i++, rel_hash++)
-    {
+  bfd_byte *erela;
+  void (*swap_in) PARAMS ((bfd *, const bfd_byte *, Elf_Internal_Rela *));
+  void (*swap_out) PARAMS ((bfd *, const Elf_Internal_Rela *, bfd_byte *));
+
+  if (rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
+    {
+      swap_in = bed->s->swap_reloc_in;
+      swap_out = bed->s->swap_reloc_out;
+    }
+  else if (rel_hdr->sh_entsize == sizeof (Elf_External_Rela))
+    {
+      swap_in = bed->s->swap_reloca_in;
+      swap_out = bed->s->swap_reloca_out;
+    }
+  else
+    abort ();
+
+  if (bed->s->int_rels_per_ext_rel > MAX_INT_RELS_PER_EXT_REL)
+    abort ();
+
+  erela = rel_hdr->contents;
+  for (i = 0; i < count; i++, rel_hash++, erela += rel_hdr->sh_entsize)
+    {
+      Elf_Internal_Rela irela[MAX_INT_RELS_PER_EXT_REL];
+      unsigned int j;
+
       if (*rel_hash == NULL)
         continue;
@@ -4180 +4891 @@
       BFD_ASSERT ((*rel_hash)->indx >= 0);
 
-      if (rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
-        {
-          Elf_External_Rel *erel;
-          unsigned int j;
-
-          erel = (Elf_External_Rel *) rel_hdr->contents + i;
-          if (bed->s->swap_reloc_in)
-            (*bed->s->swap_reloc_in) (abfd, (bfd_byte *) erel, irel);
-          else
-            elf_swap_reloc_in (abfd, erel, irel);
-
-          for (j = 0; j < bed->s->int_rels_per_ext_rel; j++)
-            irel[j].r_info = ELF_R_INFO ((*rel_hash)->indx,
-                                         ELF_R_TYPE (irel[j].r_info));
-
-          if (bed->s->swap_reloc_out)
-            (*bed->s->swap_reloc_out) (abfd, irel, (bfd_byte *) erel);
-          else
-            elf_swap_reloc_out (abfd, irel, erel);
-        }
-      else
-        {
-          Elf_External_Rela *erela;
-          unsigned int j;
-
-          BFD_ASSERT (rel_hdr->sh_entsize
-                      == sizeof (Elf_External_Rela));
-
-          erela = (Elf_External_Rela *) rel_hdr->contents + i;
-          if (bed->s->swap_reloca_in)
-            (*bed->s->swap_reloca_in) (abfd, (bfd_byte *) erela, irela);
-          else
-            elf_swap_reloca_in (abfd, erela, irela);
-
-          for (j = 0; j < bed->s->int_rels_per_ext_rel; j++)
-            irela[j].r_info = ELF_R_INFO ((*rel_hash)->indx,
-                                       ELF_R_TYPE (irela[j].r_info));
-
-          if (bed->s->swap_reloca_out)
-            (*bed->s->swap_reloca_out) (abfd, irela, (bfd_byte *) erela);
-          else
-            elf_swap_reloca_out (abfd, irela, erela);
-        }
-    }
-
-  free (irel);
-  free (irela);
+      (*swap_in) (abfd, erela, irela);
+      for (j = 0; j < bed->s->int_rels_per_ext_rel; j++)
+        irela[j].r_info = ELF_R_INFO ((*rel_hash)->indx,
+                                      ELF_R_TYPE (irela[j].r_info));
+      (*swap_out) (abfd, irela, erela);
+    }
 }
 
+struct elf_link_sort_rela
+{
+  bfd_vma offset;
+  enum elf_reloc_type_class type;
+  /* We use this as an array of size int_rels_per_ext_rel.  */
+  Elf_Internal_Rela rela[1];
+};
+
+static int
+elf_link_sort_cmp1 (A, B)
+     const PTR A;
+     const PTR B;
+{
+  struct elf_link_sort_rela *a = (struct elf_link_sort_rela *) A;
+  struct elf_link_sort_rela *b = (struct elf_link_sort_rela *) B;
+  int relativea, relativeb;
+
+  relativea = a->type == reloc_class_relative;
+  relativeb = b->type == reloc_class_relative;
+
+  if (relativea < relativeb)
+    return 1;
+  if (relativea > relativeb)
+    return -1;
+  if (ELF_R_SYM (a->rela->r_info) < ELF_R_SYM (b->rela->r_info))
+    return -1;
+  if (ELF_R_SYM (a->rela->r_info) > ELF_R_SYM (b->rela->r_info))
+    return 1;
+  if (a->rela->r_offset < b->rela->r_offset)
+    return -1;
+  if (a->rela->r_offset > b->rela->r_offset)
+    return 1;
+  return 0;
+}
+
+static int
+elf_link_sort_cmp2 (A, B)
+     const PTR A;
+     const PTR B;
+{
+  struct elf_link_sort_rela *a = (struct elf_link_sort_rela *) A;
+  struct elf_link_sort_rela *b = (struct elf_link_sort_rela *) B;
+  int copya, copyb;
+
+  if (a->offset < b->offset)
+    return -1;
+  if (a->offset > b->offset)
+    return 1;
+  copya = (a->type == reloc_class_copy) * 2 + (a->type == reloc_class_plt);
+  copyb = (b->type == reloc_class_copy) * 2 + (b->type == reloc_class_plt);
+  if (copya < copyb)
+    return -1;
+  if (copya > copyb)
+    return 1;
+  if (a->rela->r_offset < b->rela->r_offset)
+    return -1;
+  if (a->rela->r_offset > b->rela->r_offset)
+    return 1;
+  return 0;
+}
+
+static size_t
+elf_link_sort_relocs (abfd, info, psec)
+     bfd *abfd;
+     struct bfd_link_info *info;
+     asection **psec;
+{
+  bfd *dynobj = elf_hash_table (info)->dynobj;
+  asection *reldyn, *o;
+  bfd_size_type count, size;
+  size_t i, ret, sort_elt, ext_size;
+  bfd_byte *sort, *s_non_relative, *p;
+  struct elf_link_sort_rela *sq;
+  struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  int i2e = bed->s->int_rels_per_ext_rel;
+  void (*swap_in) PARAMS ((bfd *, const bfd_byte *, Elf_Internal_Rela *));
+  void (*swap_out) PARAMS ((bfd *, const Elf_Internal_Rela *, bfd_byte *));
+
+  reldyn = bfd_get_section_by_name (abfd, ".rela.dyn");
+  if (reldyn == NULL || reldyn->_raw_size == 0)
+    {
+      reldyn = bfd_get_section_by_name (abfd, ".rel.dyn");
+      if (reldyn == NULL || reldyn->_raw_size == 0)
+        return 0;
+      ext_size = sizeof (Elf_External_Rel);
+      swap_in = bed->s->swap_reloc_in;
+      swap_out = bed->s->swap_reloc_out;
+    }
+  else
+    {
+      ext_size = sizeof (Elf_External_Rela);
+      swap_in = bed->s->swap_reloca_in;
+      swap_out = bed->s->swap_reloca_out;
+    }
+  count = reldyn->_raw_size / ext_size;
+
+  size = 0;
+  for (o = dynobj->sections; o != NULL; o = o->next)
+    if ((o->flags & (SEC_HAS_CONTENTS|SEC_LINKER_CREATED))
+        == (SEC_HAS_CONTENTS|SEC_LINKER_CREATED)
+        && o->output_section == reldyn)
+      size += o->_raw_size;
+
+  if (size != reldyn->_raw_size)
+    return 0;
+
+  sort_elt = (sizeof (struct elf_link_sort_rela)
+              + (i2e - 1) * sizeof (Elf_Internal_Rela));
+  sort = bfd_zmalloc (sort_elt * count);
+  if (sort == NULL)
+    {
+      (*info->callbacks->warning)
+        (info, _("Not enough memory to sort relocations"), 0, abfd, 0,
+         (bfd_vma) 0);
+      return 0;
+    }
+
+  for (o = dynobj->sections; o != NULL; o = o->next)
+    if ((o->flags & (SEC_HAS_CONTENTS|SEC_LINKER_CREATED))
+        == (SEC_HAS_CONTENTS|SEC_LINKER_CREATED)
+        && o->output_section == reldyn)
+      {
+        bfd_byte *erel, *erelend;
+
+        erel = o->contents;
+        erelend = o->contents + o->_raw_size;
+        p = sort + o->output_offset / ext_size * sort_elt;
+        while (erel < erelend)
+          {
+            struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
+            (*swap_in) (abfd, erel, s->rela);
+            s->type = (*bed->elf_backend_reloc_type_class) (s->rela);
+            p += sort_elt;
+            erel += ext_size;
+          }
+      }
+
+  qsort (sort, (size_t) count, sort_elt, elf_link_sort_cmp1);
+
+  for (i = 0, p = sort; i < count; i++, p += sort_elt)
+    {
+      struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
+      if (s->type != reloc_class_relative)
+        break;
+    }
+  ret = i;
+  s_non_relative = p;
+
+  sq = (struct elf_link_sort_rela *) s_non_relative;
+  for (; i < count; i++, p += sort_elt)
+    {
+      struct elf_link_sort_rela *sp = (struct elf_link_sort_rela *) p;
+      if (ELF_R_SYM (sp->rela->r_info) != ELF_R_SYM (sq->rela->r_info))
+        sq = sp;
+      sp->offset = sq->rela->r_offset;
+    }
+
+  qsort (s_non_relative, (size_t) count - ret, sort_elt, elf_link_sort_cmp2);
+
+  for (o = dynobj->sections; o != NULL; o = o->next)
+    if ((o->flags & (SEC_HAS_CONTENTS|SEC_LINKER_CREATED))
+        == (SEC_HAS_CONTENTS|SEC_LINKER_CREATED)
+        && o->output_section == reldyn)
+      {
+        bfd_byte *erel, *erelend;
+
+        erel = o->contents;
+        erelend = o->contents + o->_raw_size;
+        p = sort + o->output_offset / ext_size * sort_elt;
+        while (erel < erelend)
+          {
+            struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
+            (*swap_out) (abfd, s->rela, erel);
+            p += sort_elt;
+            erel += ext_size;
+          }
+      }
+
+  free (sort);
+  *psec = reldyn;
+  return ret;
+}
+
 /* Do the final step of an ELF link.  */
 
-boolean
+bfd_boolean
 elf_bfd_final_link (abfd, info)
      bfd *abfd;
      struct bfd_link_info *info;
 {
-  boolean dynamic;
+  bfd_boolean dynamic;
+  bfd_boolean emit_relocs;
   bfd *dynobj;
   struct elf_final_link_info finfo;
@@ -4242 +5096 @@
   register struct bfd_link_order *p;
   register bfd *sub;
-  size_t max_contents_size;
-  size_t max_external_reloc_size;
-  size_t max_internal_reloc_count;
-  size_t max_sym_count;
+  bfd_size_type max_contents_size;
+  bfd_size_type max_external_reloc_size;
+  bfd_size_type max_internal_reloc_count;
+  bfd_size_type max_sym_count;
+  bfd_size_type max_sym_shndx_count;
   file_ptr off;
   Elf_Internal_Sym elfsym;
   unsigned int i;
   Elf_Internal_Shdr *symtab_hdr;
+  Elf_Internal_Shdr *symtab_shndx_hdr;
   Elf_Internal_Shdr *symstrtab_hdr;
   struct elf_backend_data *bed = get_elf_backend_data (abfd);
   struct elf_outext_info eoinfo;
+  bfd_boolean merged;
+  size_t relativecount = 0;
+  asection *reldyn = 0;
+  bfd_size_type amt;
+
+  if (! is_elf_hash_table (info))
+    return FALSE;
 
   if (info->shared)
@@ -4259 +5122 @@
   dynamic = elf_hash_table (info)->dynamic_sections_created;
   dynobj = elf_hash_table (info)->dynobj;
+
+  emit_relocs = (info->relocateable
+                 || info->emitrelocations
+                 || bed->elf_backend_emit_relocs);
 
   finfo.info = info;
@@ -4264 +5131 @@
   finfo.symstrtab = elf_stringtab_init ();
   if (finfo.symstrtab == NULL)
-    return false;
+    return FALSE;
 
   if (! dynamic)
@@ -4285 +5152 @@
   finfo.internal_relocs = NULL;
   finfo.external_syms = NULL;
+  finfo.locsym_shndx = NULL;
   finfo.internal_syms = NULL;
   finfo.indices = NULL;
   finfo.sections = NULL;
   finfo.symbuf = NULL;
+  finfo.symshndxbuf = NULL;
   finfo.symbuf_count = 0;
+  finfo.shndxbuf_size = 0;
+  finfo.first_tls_sec = NULL;
+  for (o = abfd->sections; o != (asection *) NULL; o = o->next)
+    if ((o->flags & SEC_THREAD_LOCAL) != 0
+        && (o->flags & SEC_LOAD) != 0)
+      {
+        finfo.first_tls_sec = o;
+        break;
+      }
 
   /* Count up the number of relocations we will output for each output
@@ -4298 +5176 @@
   max_internal_reloc_count = 0;
   max_sym_count = 0;
+  max_sym_shndx_count = 0;
+  merged = FALSE;
   for (o = abfd->sections; o != (asection *) NULL; o = o->next)
     {
+      struct bfd_elf_section_data *esdo = elf_section_data (o);
       o->reloc_count = 0;
 
       for (p = o->link_order_head; p != NULL; p = p->next)
         {
+          unsigned int reloc_count = 0;
+          struct bfd_elf_section_data *esdi = NULL;
+          unsigned int *rel_count1;
+
           if (p->type == bfd_section_reloc_link_order
               || p->type == bfd_symbol_reloc_link_order)
-            ++o->reloc_count;
+            reloc_count = 1;
           else if (p->type == bfd_indirect_link_order)
             {
@@ -4312 +5197 @@
 
               sec = p->u.indirect.section;
+              esdi = elf_section_data (sec);
 
               /* Mark all sections which are to be included in the
@@ -4317 +5203 @@
                  to do this so that we can identify any sections which
                  the linker has decided to not include.  */
-              sec->linker_mark = true;
+              sec->linker_mark = TRUE;
+
+              if (sec->flags & SEC_MERGE)
+                merged = TRUE;
 
               if (info->relocateable || info->emitrelocations)
-                o->reloc_count += sec->reloc_count;
+                reloc_count = sec->reloc_count;
+              else if (bed->elf_backend_count_relocs)
+                {
+                  Elf_Internal_Rela * relocs;
+
+                  relocs = (NAME(_bfd_elf,link_read_relocs)
+                            (abfd, sec, (PTR) NULL,
+                             (Elf_Internal_Rela *) NULL, info->keep_memory));
+
+                  reloc_count = (*bed->elf_backend_count_relocs) (sec, relocs);
+
+                  if (elf_section_data (o)->relocs != relocs)
+                    free (relocs);
+                }
 
               if (sec->_raw_size > max_contents_size)
@@ -4342 +5244 @@
                   if (sym_count > max_sym_count)
                     max_sym_count = sym_count;
+
+                  if (sym_count > max_sym_shndx_count
+                      && elf_symtab_shndx (sec->owner) != 0)
+                    max_sym_shndx_count = sym_count;
 
                   if ((sec->flags & SEC_RELOC) != 0)
@@ -4355 +5261 @@
                 }
             }
+
+          if (reloc_count == 0)
+            continue;
+
+          o->reloc_count += reloc_count;
+
+          /* MIPS may have a mix of REL and RELA relocs on sections.
+             To support this curious ABI we keep reloc counts in
+             elf_section_data too.  We must be careful to add the
+             relocations from the input section to the right output
+             count.  FIXME: Get rid of one count.  We have
+             o->reloc_count == esdo->rel_count + esdo->rel_count2.  */
+          rel_count1 = &esdo->rel_count;
+          if (esdi != NULL)
+            {
+              bfd_boolean same_size;
+              bfd_size_type entsize1;
+
+              entsize1 = esdi->rel_hdr.sh_entsize;
+              BFD_ASSERT (entsize1 == sizeof (Elf_External_Rel)
+                          || entsize1 == sizeof (Elf_External_Rela));
+              same_size = (!o->use_rela_p
+                           == (entsize1 == sizeof (Elf_External_Rel)));
+
+              if (!same_size)
+                rel_count1 = &esdo->rel_count2;
+
+              if (esdi->rel_hdr2 != NULL)
+                {
+                  bfd_size_type entsize2 = esdi->rel_hdr2->sh_entsize;
+                  unsigned int alt_count;
+                  unsigned int *rel_count2;
+
+                  BFD_ASSERT (entsize2 != entsize1
+                              && (entsize2 == sizeof (Elf_External_Rel)
+                                  || entsize2 == sizeof (Elf_External_Rela)));
+
+                  rel_count2 = &esdo->rel_count2;
+                  if (!same_size)
+                    rel_count2 = &esdo->rel_count;
+
+                  /* The following is probably too simplistic if the
+                     backend counts output relocs unusually.  */
+                  BFD_ASSERT (bed->elf_backend_count_relocs == NULL);
+                  alt_count = NUM_SHDR_ENTRIES (esdi->rel_hdr2);
+                  *rel_count2 += alt_count;
+                  reloc_count -= alt_count;
+                }
+            }
+          *rel_count1 += reloc_count;
         }
 
@@ -4376 +5332 @@
     }
 
+  if (! info->relocateable && merged)
+    elf_link_hash_traverse (elf_hash_table (info),
+                            elf_link_sec_merge_syms, (PTR) abfd);
+
   /* Figure out the file positions for everything but the symbol table
      and the relocs.  We set symcount to force assign_section_numbers
@@ -4383 +5343 @@
   if (! _bfd_elf_compute_section_file_positions (abfd, info))
     goto error_return;
-
-  /* Figure out how many relocations we will have in each section.
-     Just using RELOC_COUNT isn't good enough since that doesn't
-     maintain a separate value for REL vs. RELA relocations.  */
-  if (info->relocateable || info->emitrelocations)
-    for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
-      for (o = sub->sections; o != NULL; o = o->next)
-        {
-          asection *output_section;
-
-          if (! o->linker_mark)
-            {
-              /* This section was omitted from the link.  */
-              continue;
-            }
-
-          output_section = o->output_section;
-
-          if (output_section != NULL
-              && (o->flags & SEC_RELOC) != 0)
-            {
-              struct bfd_elf_section_data *esdi
-                = elf_section_data (o);
-              struct bfd_elf_section_data *esdo
-                = elf_section_data (output_section);
-              unsigned int *rel_count;
-              unsigned int *rel_count2;
-
-              /* We must be careful to add the relocation froms the
-                 input section to the right output count.  */
-              if (esdi->rel_hdr.sh_entsize == esdo->rel_hdr.sh_entsize)
-                {
-                  rel_count = &esdo->rel_count;
-                  rel_count2 = &esdo->rel_count2;
-                }
-              else
-                {
-                  rel_count = &esdo->rel_count2;
-                  rel_count2 = &esdo->rel_count;
-                }
-
-              *rel_count += NUM_SHDR_ENTRIES (& esdi->rel_hdr);
-              if (esdi->rel_hdr2)
-                *rel_count2 += NUM_SHDR_ENTRIES (esdi->rel_hdr2);
-            }
-        }
 
   /* That created the reloc sections.  Set their sizes, and assign
@@ -4464 +5378 @@
   /* sh_name is set in prep_headers.  */
   symtab_hdr->sh_type = SHT_SYMTAB;
-  symtab_hdr->sh_flags = 0;
-  symtab_hdr->sh_addr = 0;
-  symtab_hdr->sh_size = 0;
+  /* sh_flags, sh_addr and sh_size all start off zero.  */
   symtab_hdr->sh_entsize = sizeof (Elf_External_Sym);
   /* sh_link is set in assign_section_numbers.  */
@@ -4474 +5386 @@
 
   off = elf_tdata (abfd)->next_file_pos;
-  off = _bfd_elf_assign_file_position_for_section (symtab_hdr, off, true);
+  off = _bfd_elf_assign_file_position_for_section (symtab_hdr, off, TRUE);
 
   /* Note that at this point elf_tdata (abfd)->next_file_pos is
@@ -4486 +5398 @@
   else
     finfo.symbuf_size = max_sym_count;
-  finfo.symbuf = ((Elf_External_Sym *)
-                  bfd_malloc (finfo.symbuf_size * sizeof (Elf_External_Sym)));
+  amt = finfo.symbuf_size;
+  amt *= sizeof (Elf_External_Sym);
+  finfo.symbuf = (Elf_External_Sym *) bfd_malloc (amt);
   if (finfo.symbuf == NULL)
     goto error_return;
+  if (elf_numsections (abfd) > SHN_LORESERVE)
+    {
+      /* Wild guess at number of output symbols.  realloc'd as needed.  */
+      amt = 2 * max_sym_count + elf_numsections (abfd) + 1000;
+      finfo.shndxbuf_size = amt;
+      amt *= sizeof (Elf_External_Sym_Shndx);
+      finfo.symshndxbuf = (Elf_External_Sym_Shndx *) bfd_zmalloc (amt);
+      if (finfo.symshndxbuf == NULL)
+        goto error_return;
+    }
 
   /* Start writing out the symbol table.  The first symbol is always a
      dummy symbol.  */
-  if (info->strip != strip_all || info->relocateable || info->emitrelocations)
+  if (info->strip != strip_all
+      || emit_relocs)
     {
       elfsym.st_value = 0;
@@ -4526 +5450 @@
      index field of the section, so that we can find it again when
      outputting relocs.  */
-  if (info->strip != strip_all || info->relocateable || info->emitrelocations)
+  if (info->strip != strip_all
+      || emit_relocs)
     {
       elfsym.st_size = 0;
       elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
       elfsym.st_other = 0;
-      for (i = 1; i < elf_elfheader (abfd)->e_shnum; i++)
+      for (i = 1; i < elf_numsections (abfd); i++)
         {
           o = section_from_elf_index (abfd, i);
@@ -4544 +5469 @@
                                      &elfsym, o))
             goto error_return;
+          if (i == SHN_LORESERVE - 1)
+            i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
         }
     }
@@ -4549 +5476 @@
   /* Allocate some memory to hold information read in from the input
      files.  */
-  finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
-  finfo.external_relocs = (PTR) bfd_malloc (max_external_reloc_size);
-  finfo.internal_relocs = ((Elf_Internal_Rela *)
-                           bfd_malloc (max_internal_reloc_count
-                                       * sizeof (Elf_Internal_Rela)
-                                       * bed->s->int_rels_per_ext_rel));
-  finfo.external_syms = ((Elf_External_Sym *)
-                         bfd_malloc (max_sym_count
-                                     * sizeof (Elf_External_Sym)));
-  finfo.internal_syms = ((Elf_Internal_Sym *)
-                         bfd_malloc (max_sym_count
-                                     * sizeof (Elf_Internal_Sym)));
-  finfo.indices = (long *) bfd_malloc (max_sym_count * sizeof (long));
-  finfo.sections = ((asection **)
-                    bfd_malloc (max_sym_count * sizeof (asection *)));
-  if ((finfo.contents == NULL && max_contents_size != 0)
-      || (finfo.external_relocs == NULL && max_external_reloc_size != 0)
-      || (finfo.internal_relocs == NULL && max_internal_reloc_count != 0)
-      || (finfo.external_syms == NULL && max_sym_count != 0)
-      || (finfo.internal_syms == NULL && max_sym_count != 0)
-      || (finfo.indices == NULL && max_sym_count != 0)
-      || (finfo.sections == NULL && max_sym_count != 0))
-    goto error_return;
+  if (max_contents_size != 0)
+    {
+      finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
+      if (finfo.contents == NULL)
+        goto error_return;
+    }
+
+  if (max_external_reloc_size != 0)
+    {
+      finfo.external_relocs = (PTR) bfd_malloc (max_external_reloc_size);
+      if (finfo.external_relocs == NULL)
+        goto error_return;
+    }
+
+  if (max_internal_reloc_count != 0)
+    {
+      amt = max_internal_reloc_count * bed->s->int_rels_per_ext_rel;
+      amt *= sizeof (Elf_Internal_Rela);
+      finfo.internal_relocs = (Elf_Internal_Rela *) bfd_malloc (amt);
+      if (finfo.internal_relocs == NULL)
+        goto error_return;
+    }
+
+  if (max_sym_count != 0)
+    {
+      amt = max_sym_count * sizeof (Elf_External_Sym);
+      finfo.external_syms = (Elf_External_Sym *) bfd_malloc (amt);
+      if (finfo.external_syms == NULL)
+        goto error_return;
+
+      amt = max_sym_count * sizeof (Elf_Internal_Sym);
+      finfo.internal_syms = (Elf_Internal_Sym *) bfd_malloc (amt);
+      if (finfo.internal_syms == NULL)
+        goto error_return;
+
+      amt = max_sym_count * sizeof (long);
+      finfo.indices = (long *) bfd_malloc (amt);
+      if (finfo.indices == NULL)
+        goto error_return;
+
+      amt = max_sym_count * sizeof (asection *);
+      finfo.sections = (asection **) bfd_malloc (amt);
+      if (finfo.sections == NULL)
+        goto error_return;
+    }
+
+  if (max_sym_shndx_count != 0)
+    {
+      amt = max_sym_shndx_count * sizeof (Elf_External_Sym_Shndx);
+      finfo.locsym_shndx = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
+      if (finfo.locsym_shndx == NULL)
+        goto error_return;
+    }
+
+  if (finfo.first_tls_sec)
+    {
+      unsigned int align = 0;
+      bfd_vma base = finfo.first_tls_sec->vma, end = 0;
+      asection *sec;
+
+      for (sec = finfo.first_tls_sec;
+           sec && (sec->flags & SEC_THREAD_LOCAL);
+           sec = sec->next)
+        {
+          bfd_vma size = sec->_raw_size;
+
+          if (bfd_get_section_alignment (abfd, sec) > align)
+            align = bfd_get_section_alignment (abfd, sec);
+          if (sec->_raw_size == 0 && (sec->flags & SEC_HAS_CONTENTS) == 0)
+            {
+              struct bfd_link_order *o;
+
+              size = 0;
+              for (o = sec->link_order_head; o != NULL; o = o->next)
+                if (size < o->offset + o->size)
+                  size = o->offset + o->size;
+            }
+          end = sec->vma + size;
+        }
+      elf_hash_table (info)->tls_segment
+        = bfd_zalloc (abfd, sizeof (struct elf_link_tls_segment));
+      if (elf_hash_table (info)->tls_segment == NULL)
+        goto error_return;
+      elf_hash_table (info)->tls_segment->start = base;
+      elf_hash_table (info)->tls_segment->size = end - base;
+      elf_hash_table (info)->tls_segment->align = align;
+    }
 
   /* Since ELF permits relocations to be against local symbols, we
@@ -4594 +5585 @@
 
   for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
-    sub->output_has_begun = false;
+    sub->output_has_begun = FALSE;
   for (o = abfd->sections; o != NULL; o = o->next)
     {
@@ -4600 +5591 @@
         {
           if (p->type == bfd_indirect_link_order
-              && (bfd_get_flavour (p->u.indirect.section->owner)
-                  == bfd_target_elf_flavour))
+              && (bfd_get_flavour ((sub = p->u.indirect.section->owner))
+                  == bfd_target_elf_flavour)
+              && elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass)
             {
-              sub = p->u.indirect.section->owner;
               if (! sub->output_has_begun)
                 {
                   if (! elf_link_input_bfd (&finfo, sub))
                     goto error_return;
-                  sub->output_has_begun = true;
+                  sub->output_has_begun = TRUE;
                 }
             }
@@ -4625 +5616 @@
     }
 
+  /* Output any global symbols that got converted to local in a
+     version script or due to symbol visibility.  We do this in a
+     separate step since ELF requires all local symbols to appear
+     prior to any global symbols.  FIXME: We should only do this if
+     some global symbols were, in fact, converted to become local.
+     FIXME: Will this work correctly with the Irix 5 linker?  */
+  eoinfo.failed = FALSE;
+  eoinfo.finfo = &finfo;
+  eoinfo.localsyms = TRUE;
+  elf_link_hash_traverse (elf_hash_table (info), elf_link_output_extsym,
+                          (PTR) &eoinfo);
+  if (eoinfo.failed)
+    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
@@ -4630 +5635 @@
      converted to local in a version script.  */
 
-  if (info->shared)
-    {
-      /* Output any global symbols that got converted to local in a
-         version script.  We do this in a separate step since ELF
-         requires all local symbols to appear prior to any global
-         symbols.  FIXME: We should only do this if some global
-         symbols were, in fact, converted to become local.  FIXME:
-         Will this work correctly with the Irix 5 linker?  */
-      eoinfo.failed = false;
-      eoinfo.finfo = &finfo;
-      eoinfo.localsyms = true;
-      elf_link_hash_traverse (elf_hash_table (info), elf_link_output_extsym,
-                              (PTR) &eoinfo);
-      if (eoinfo.failed)
-        return false;
-    }
-
   /* The sh_info field records the index of the first non local symbol.  */
   symtab_hdr->sh_info = bfd_get_symcount (abfd);
@@ -4655 +5643 @@
       Elf_Internal_Sym sym;
       Elf_External_Sym *dynsym =
-        (Elf_External_Sym *)finfo.dynsym_sec->contents;
+        (Elf_External_Sym *) finfo.dynsym_sec->contents;
       long last_local = 0;
 
@@ -4671 +5659 @@
             {
               int indx;
+              Elf_External_Sym *dest;
+
               indx = elf_section_data (s)->this_idx;
               BFD_ASSERT (indx > 0);
               sym.st_shndx = indx;
               sym.st_value = s->vma;
-
-              elf_swap_symbol_out (abfd, &sym,
-                                   dynsym + elf_section_data (s)->dynindx);
+              dest = dynsym + elf_section_data (s)->dynindx;
+              elf_swap_symbol_out (abfd, &sym, (PTR) dest, (PTR) 0);
             }
 
@@ -4690 +5679 @@
             {
               asection *s;
+              Elf_External_Sym *dest;
 
               sym.st_size = e->isym.st_size;
@@ -4696 +5686 @@
               /* Copy the internal symbol as is.
                  Note that we saved a word of storage and overwrote
-                 the original st_name with the dynstr_index.  */
-              sym = e->isym;
-
-              if (e->isym.st_shndx > 0 && e->isym.st_shndx < SHN_LORESERVE)
+                 the original st_name with the dynstr_index.  */
+              sym = e->isym;
+
+              if (e->isym.st_shndx != SHN_UNDEF
+                  && (e->isym.st_shndx < SHN_LORESERVE
+                      || e->isym.st_shndx > SHN_HIRESERVE))
                 {
                   s = bfd_section_from_elf_index (e->input_bfd,
@@ -4714 +5706 @@
                 last_local = e->dynindx;
 
-              elf_swap_symbol_out (abfd, &sym, dynsym + e->dynindx);
+              dest = dynsym + e->dynindx;
+              elf_swap_symbol_out (abfd, &sym, (PTR) dest, (PTR) 0);
             }
         }
@@ -4723 +5716 @@
 
   /* We get the global symbols from the hash table.  */
-  eoinfo.failed = false;
-  eoinfo.localsyms = false;
+  eoinfo.failed = FALSE;
+  eoinfo.localsyms = FALSE;
   eoinfo.finfo = &finfo;
   elf_link_hash_traverse (elf_hash_table (info), elf_link_output_extsym,
                           (PTR) &eoinfo);
   if (eoinfo.failed)
-    return false;
+    return FALSE;
 
   /* If backend needs to output some symbols not present in the hash
@@ -4735 +5728 @@
   if (bed->elf_backend_output_arch_syms)
     {
-      if (! (*bed->elf_backend_output_arch_syms)
-              (abfd, info, (PTR) &finfo,
-               (boolean (*) PARAMS ((PTR, const char *,
-                            Elf_Internal_Sym *, asection *)))
-               elf_link_output_sym))
-        return false;
+      typedef bfd_boolean (*out_sym_func)
+        PARAMS ((PTR, const char *, Elf_Internal_Sym *, asection *));
+
+      if (! ((*bed->elf_backend_output_arch_syms)
+             (abfd, info, (PTR) &finfo, (out_sym_func) elf_link_output_sym)))
+        return FALSE;
     }
 
   /* Flush all symbols to the file.  */
   if (! elf_link_flush_output_syms (&finfo))
-    return false;
+    return FALSE;
 
   /* Now we know the size of the symtab section.  */
   off += symtab_hdr->sh_size;
+
+  symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
+  if (symtab_shndx_hdr->sh_name != 0)
+    {
+      symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
+      symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
+      symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
+      amt = bfd_get_symcount (abfd) * sizeof (Elf_External_Sym_Shndx);
+      symtab_shndx_hdr->sh_size = amt;
+
+      off = _bfd_elf_assign_file_position_for_section (symtab_shndx_hdr,
+                                                       off, TRUE);
+
+      if (bfd_seek (abfd, symtab_shndx_hdr->sh_offset, SEEK_SET) != 0
+          || (bfd_bwrite ((PTR) finfo.symshndxbuf, amt, abfd) != amt))
+        return FALSE;
+    }
+
 
   /* Finish up and write out the symbol string table (.strtab)
@@ -4764 +5775 @@
   symstrtab_hdr->sh_addralign = 1;
 
-  off = _bfd_elf_assign_file_position_for_section (symstrtab_hdr, off, true);
+  off = _bfd_elf_assign_file_position_for_section (symstrtab_hdr, off, TRUE);
   elf_tdata (abfd)->next_file_pos = off;
 
@@ -4771 +5782 @@
       if (bfd_seek (abfd, symstrtab_hdr->sh_offset, SEEK_SET) != 0
           || ! _bfd_stringtab_emit (abfd, finfo.symstrtab))
-        return false;
+        return FALSE;
     }
 
@@ -4794 +5805 @@
     }
 
+  if (dynamic && info->combreloc && dynobj != NULL)
+    relativecount = elf_link_sort_relocs (abfd, info, &reldyn);
+
   /* If we are linking against a dynamic object, or generating a
      shared library, finish up the dynamic linking information.  */
@@ -4817 +5831 @@
             {
             default:
+              break;
+            case DT_NULL:
+              if (relativecount > 0 && dyncon + 1 < dynconend)
+                {
+                  switch (elf_section_data (reldyn)->this_hdr.sh_type)
+                    {
+                    case SHT_REL: dyn.d_tag = DT_RELCOUNT; break;
+                    case SHT_RELA: dyn.d_tag = DT_RELACOUNT; break;
+                    default: break;
+                    }
+                  if (dyn.d_tag != DT_NULL)
+                    {
+                      dyn.d_un.d_val = relativecount;
+                      elf_swap_dyn_out (dynobj, &dyn, dyncon);
+                      relativecount = 0;
+                    }
+                }
               break;
             case DT_INIT:
@@ -4828 +5859 @@
 
                 h = elf_link_hash_lookup (elf_hash_table (info), name,
-                                          false, false, true);
+                                          FALSE, FALSE, TRUE);
                 if (h != NULL
                     && (h->root.type == bfd_link_hash_defined
@@ -4849 +5880 @@
               }
               break;
+
+            case DT_PREINIT_ARRAYSZ:
+              name = ".preinit_array";
+              goto get_size;
+            case DT_INIT_ARRAYSZ:
+              name = ".init_array";
+              goto get_size;
+            case DT_FINI_ARRAYSZ:
+              name = ".fini_array";
+            get_size:
+              o = bfd_get_section_by_name (abfd, name);
+              if (o == NULL)
+                {
+                  (*_bfd_error_handler)
+                    (_("%s: could not find output section %s"),
+                     bfd_get_filename (abfd), name);
+                  goto error_return;
+                }
+              if (o->_raw_size == 0)
+                (*_bfd_error_handler)
+                  (_("warning: %s section has zero size"), name);
+              dyn.d_un.d_val = o->_raw_size;
+              elf_swap_dyn_out (dynobj, &dyn, dyncon);
+              break;
+
+            case DT_PREINIT_ARRAY:
+              name = ".preinit_array";
+              goto get_vma;
+            case DT_INIT_ARRAY:
+              name = ".init_array";
+              goto get_vma;
+            case DT_FINI_ARRAY:
+              name = ".fini_array";
+              goto get_vma;
 
             case DT_HASH:
@@ -4869 +5934 @@
             get_vma:
               o = bfd_get_section_by_name (abfd, name);
-              BFD_ASSERT (o != NULL);
+              if (o == NULL)
+                {
+                  (*_bfd_error_handler)
+                    (_("%s: could not find output section %s"),
+                     bfd_get_filename (abfd), name);
+                  goto error_return;
+                }
               dyn.d_un.d_ptr = o->vma;
               elf_swap_dyn_out (dynobj, &dyn, dyncon);
@@ -4883 +5954 @@
                 type = SHT_RELA;
               dyn.d_un.d_val = 0;
-              for (i = 1; i < elf_elfheader (abfd)->e_shnum; i++)
+              for (i = 1; i < elf_numsections (abfd); i++)
                 {
                   Elf_Internal_Shdr *hdr;
@@ -4922 +5993 @@
             {
               /* At this point, we are only interested in sections
-                 created by elf_link_create_dynamic_sections.  */
+                 created by elf_link_create_dynamic_sections.  */
               continue;
             }
@@ -4930 +6001 @@
             {
               if (! bfd_set_section_contents (abfd, o->output_section,
-                                              o->contents, o->output_offset,
+                                              o->contents,
+                                              (file_ptr) o->output_offset,
                                               o->_raw_size))
                 goto error_return;
@@ -4936 +6008 @@
           else
             {
-              file_ptr off;
-
               /* The contents of the .dynstr section are actually in a
-                 stringtab.  */
+                 stringtab.  */
               off = elf_section_data (o->output_section)->this_hdr.sh_offset;
               if (bfd_seek (abfd, off, SEEK_SET) != 0
-                  || ! _bfd_stringtab_emit (abfd,
-                                            elf_hash_table (info)->dynstr))
+                  || ! _bfd_elf_strtab_emit (abfd,
+                                             elf_hash_table (info)->dynstr))
                 goto error_return;
             }
@@ -4949 +6019 @@
     }
 
+  if (info->relocateable)
+    {
+      bfd_boolean failed = FALSE;
+
+      bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
+      if (failed)
+        goto error_return;
+    }
+
   /* If we have optimized stabs strings, output them.  */
   if (elf_hash_table (info)->stab_info != NULL)
     {
       if (! _bfd_write_stab_strings (abfd, &elf_hash_table (info)->stab_info))
+        goto error_return;
+    }
+
+  if (info->eh_frame_hdr)
+    {
+      if (! _bfd_elf_write_section_eh_frame_hdr (abfd, info))
         goto error_return;
     }
@@ -4966 +6051 @@
   if (finfo.external_syms != NULL)
     free (finfo.external_syms);
+  if (finfo.locsym_shndx != NULL)
+    free (finfo.locsym_shndx);
   if (finfo.internal_syms != NULL)
     free (finfo.internal_syms);
@@ -4974 +6061 @@
   if (finfo.symbuf != NULL)
     free (finfo.symbuf);
+  if (finfo.symshndxbuf != NULL)
+    free (finfo.symshndxbuf);
   for (o = abfd->sections; o != NULL; o = o->next)
     {
@@ -4981 +6070 @@
     }
 
-  elf_tdata (abfd)->linker = true;
-
-  return true;
+  elf_tdata (abfd)->linker = TRUE;
+
+  return TRUE;
 
  error_return:
@@ -4996 +6085 @@
   if (finfo.external_syms != NULL)
     free (finfo.external_syms);
+  if (finfo.locsym_shndx != NULL)
+    free (finfo.locsym_shndx);
   if (finfo.internal_syms != NULL)
     free (finfo.internal_syms);
@@ -5004 +6095 @@
   if (finfo.symbuf != NULL)
     free (finfo.symbuf);
+  if (finfo.symshndxbuf != NULL)
+    free (finfo.symshndxbuf);
   for (o = abfd->sections; o != NULL; o = o->next)
     {
@@ -5011 +6104 @@
     }
 
-  return false;
+  return FALSE;
 }
 
 /* Add a symbol to the output symbol table.  */
 
-static boolean
+static bfd_boolean
 elf_link_output_sym (finfo, name, elfsym, input_sec)
      struct elf_final_link_info *finfo;
@@ -5023 +6116 @@
      asection *input_sec;
 {
-  boolean (*output_symbol_hook) PARAMS ((bfd *,
-                                         struct bfd_link_info *info,
-                                         const char *,
-                                         Elf_Internal_Sym *,
-                                         asection *));
+  Elf_External_Sym *dest;
+  Elf_External_Sym_Shndx *destshndx;
+  bfd_boolean (*output_symbol_hook)
+    PARAMS ((bfd *, struct bfd_link_info *info, const char *,
+             Elf_Internal_Sym *, asection *));
 
   output_symbol_hook = get_elf_backend_data (finfo->output_bfd)->
@@ -5035 +6128 @@
       if (! ((*output_symbol_hook)
              (finfo->output_bfd, finfo->info, name, elfsym, input_sec)))
-        return false;
+        return FALSE;
     }
 
@@ -5045 +6138 @@
     {
       elfsym->st_name = (unsigned long) _bfd_stringtab_add (finfo->symstrtab,
-                                                            name, true,
-                                                            false);
+                                                            name, TRUE, FALSE);
       if (elfsym->st_name == (unsigned long) -1)
-        return false;
+        return FALSE;
     }
 
@@ -5054 +6146 @@
     {
       if (! elf_link_flush_output_syms (finfo))
-        return false;
-    }
-
-  elf_swap_symbol_out (finfo->output_bfd, elfsym,
-                       (PTR) (finfo->symbuf + finfo->symbuf_count));
-  ++finfo->symbuf_count;
-
-  ++ bfd_get_symcount (finfo->output_bfd);
-
-  return true;
+        return FALSE;
+    }
+
+  dest = finfo->symbuf + finfo->symbuf_count;
+  destshndx = finfo->symshndxbuf;
+  if (destshndx != NULL)
+    {
+      if (bfd_get_symcount (finfo->output_bfd) >= finfo->shndxbuf_size)
+        {
+          bfd_size_type amt;
+
+          amt = finfo->shndxbuf_size * sizeof (Elf_External_Sym_Shndx);
+          finfo->symshndxbuf = destshndx = bfd_realloc (destshndx, amt * 2);
+          if (destshndx == NULL)
+            return FALSE;
+          memset ((char *) destshndx + amt, 0, amt);
+          finfo->shndxbuf_size *= 2;
+        }
+      destshndx += bfd_get_symcount (finfo->output_bfd);
+    }
+
+  elf_swap_symbol_out (finfo->output_bfd, elfsym, (PTR) dest, (PTR) destshndx);
+  finfo->symbuf_count += 1;
+  bfd_get_symcount (finfo->output_bfd) += 1;
+
+  return TRUE;
 }
 
 /* Flush the output symbols to the file.  */
 
-static boolean
+static bfd_boolean
 elf_link_flush_output_syms (finfo)
      struct elf_final_link_info *finfo;
@@ -5074 +6182 @@
   if (finfo->symbuf_count > 0)
     {
-      Elf_Internal_Shdr *symtab;
-
-      symtab = &elf_tdata (finfo->output_bfd)->symtab_hdr;
-
-      if (bfd_seek (finfo->output_bfd, symtab->sh_offset + symtab->sh_size,
-                    SEEK_SET) != 0
-          || (bfd_write ((PTR) finfo->symbuf, finfo->symbuf_count,
-                         sizeof (Elf_External_Sym), finfo->output_bfd)
-              != finfo->symbuf_count * sizeof (Elf_External_Sym)))
-        return false;
-
-      symtab->sh_size += finfo->symbuf_count * sizeof (Elf_External_Sym);
-
+      Elf_Internal_Shdr *hdr;
+      file_ptr pos;
+      bfd_size_type amt;
+
+      hdr = &elf_tdata (finfo->output_bfd)->symtab_hdr;
+      pos = hdr->sh_offset + hdr->sh_size;
+      amt = finfo->symbuf_count * sizeof (Elf_External_Sym);
+      if (bfd_seek (finfo->output_bfd, pos, SEEK_SET) != 0
+          || bfd_bwrite ((PTR) finfo->symbuf, amt, finfo->output_bfd) != amt)
+        return FALSE;
+
+      hdr->sh_size += amt;
       finfo->symbuf_count = 0;
     }
 
-  return true;
+  return TRUE;
+}
+
+/* Adjust all external symbols pointing into SEC_MERGE sections
+   to reflect the object merging within the sections.  */
+
+static bfd_boolean
+elf_link_sec_merge_syms (h, data)
+     struct elf_link_hash_entry *h;
+     PTR data;
+{
+  asection *sec;
+
+  if (h->root.type == bfd_link_hash_warning)
+    h = (struct elf_link_hash_entry *) h->root.u.i.link;
+
+  if ((h->root.type == bfd_link_hash_defined
+       || h->root.type == bfd_link_hash_defweak)
+      && ((sec = h->root.u.def.section)->flags & SEC_MERGE)
+      && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
+    {
+      bfd *output_bfd = (bfd *) data;
+
+      h->root.u.def.value =
+        _bfd_merged_section_offset (output_bfd,
+                                    &h->root.u.def.section,
+                                    elf_section_data (sec)->sec_info,
+                                    h->root.u.def.value, (bfd_vma) 0);
+    }
+
+  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.
+   We also handle the case that a DSO references a hidden symbol
+   which may be satisfied by a versioned symbol in another DSO.  */
+
+static bfd_boolean
+elf_link_check_versioned_symbol (info, h)
+     struct bfd_link_info *info;
+     struct elf_link_hash_entry *h;
+{
+  bfd *abfd;
+  struct elf_link_loaded_list *loaded;
+
+  if (info->hash->creator->flavour != bfd_target_elf_flavour)
+    return FALSE;
+
+  switch (h->root.type)
+    {
+    default:
+      abfd = NULL;
+      break;
+
+    case bfd_link_hash_undefined:
+    case bfd_link_hash_undefweak:
+      abfd = h->root.u.undef.abfd;
+      if ((abfd->flags & DYNAMIC) == 0 || elf_dt_soname (abfd) == NULL)
+        return FALSE;
+      break;
+
+    case bfd_link_hash_defined:
+    case bfd_link_hash_defweak:
+      abfd = h->root.u.def.section->owner;
+      break;
+
+    case bfd_link_hash_common:
+      abfd = h->root.u.c.p->section->owner;
+      break;
+    }
+  BFD_ASSERT (abfd != NULL);
+
+  for (loaded = elf_hash_table (info)->loaded;
+       loaded != NULL;
+       loaded = loaded->next)
+    {
+      bfd *input;
+      Elf_Internal_Shdr *hdr;
+      bfd_size_type symcount;
+      bfd_size_type extsymcount;
+      bfd_size_type extsymoff;
+      Elf_Internal_Shdr *versymhdr;
+      Elf_Internal_Sym *isym;
+      Elf_Internal_Sym *isymend;
+      Elf_Internal_Sym *isymbuf;
+      Elf_External_Versym *ever;
+      Elf_External_Versym *extversym;
+
+      input = loaded->abfd;
+
+      /* We check each DSO for a possible hidden versioned definition.  */
+      if (input == abfd
+          || (input->flags & DYNAMIC) == 0
+          || elf_dynversym (input) == 0)
+        continue;
+
+      hdr = &elf_tdata (input)->dynsymtab_hdr;
+
+      symcount = hdr->sh_size / sizeof (Elf_External_Sym);
+      if (elf_bad_symtab (input))
+        {
+          extsymcount = symcount;
+          extsymoff = 0;
+        }
+      else
+        {
+          extsymcount = symcount - hdr->sh_info;
+          extsymoff = hdr->sh_info;
+        }
+
+      if (extsymcount == 0)
+        continue;
+
+      isymbuf = bfd_elf_get_elf_syms (input, hdr, extsymcount, extsymoff,
+                                      NULL, NULL, NULL);
+      if (isymbuf == NULL)
+        return FALSE;
+
+      /* Read in any version definitions.  */
+      versymhdr = &elf_tdata (input)->dynversym_hdr;
+      extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size);
+      if (extversym == NULL)
+        goto error_ret;
+
+      if (bfd_seek (input, versymhdr->sh_offset, SEEK_SET) != 0
+          || (bfd_bread ((PTR) extversym, versymhdr->sh_size, input)
+              != versymhdr->sh_size))
+        {
+          free (extversym);
+        error_ret:
+          free (isymbuf);
+          return FALSE;
+        }
+
+      ever = extversym + extsymoff;
+      isymend = isymbuf + extsymcount;
+      for (isym = isymbuf; isym < isymend; isym++, ever++)
+        {
+          const char *name;
+          Elf_Internal_Versym iver;
+
+          if (ELF_ST_BIND (isym->st_info) == STB_LOCAL
+              || isym->st_shndx == SHN_UNDEF)
+            continue;
+
+          name = bfd_elf_string_from_elf_section (input,
+                                                  hdr->sh_link,
+                                                  isym->st_name);
+          if (strcmp (name, h->root.root.string) != 0)
+            continue;
+
+          _bfd_elf_swap_versym_in (input, ever, &iver);
+
+          if ((iver.vs_vers & VERSYM_HIDDEN) == 0)
+            {
+              /* If we have a non-hidden versioned sym, then it should
+                 have provided a definition for the undefined sym.  */
+              abort ();
+            }
+
+          if ((iver.vs_vers & VERSYM_VERSION) == 2)
+            {
+              /* This is the oldest (default) sym.  We can use it.  */
+              free (extversym);
+              free (isymbuf);
+              return TRUE;
+            }
+        }
+
+      free (extversym);
+      free (isymbuf);
+    }
+
+  return FALSE;
 }
 
@@ -5100 +6382 @@
    global symbols.  */
 
-static boolean
+static bfd_boolean
 elf_link_output_extsym (h, data)
      struct elf_link_hash_entry *h;
@@ -5107 +6389 @@
   struct elf_outext_info *eoinfo = (struct elf_outext_info *) data;
   struct elf_final_link_info *finfo = eoinfo->finfo;
-  boolean strip;
+  bfd_boolean strip;
   Elf_Internal_Sym sym;
   asection *input_sec;
 
+  if (h->root.type == bfd_link_hash_warning)
+    {
+      h = (struct elf_link_hash_entry *) h->root.u.i.link;
+      if (h->root.type == bfd_link_hash_new)
+        return TRUE;
+    }
+
   /* Decide whether to output this symbol in this pass.  */
   if (eoinfo->localsyms)
     {
       if ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
-        return true;
+        return TRUE;
     }
   else
     {
       if ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)
-        return true;
+        return TRUE;
     }
 
@@ -5131 +6420 @@
      warnings for them.  */
   if (! finfo->info->relocateable
-      && ! finfo->info->allow_shlib_undefined
-      && ! (finfo->info->shared
-            && !finfo->info->no_undefined)
+      && (! finfo->info->shared || ! finfo->info->allow_shlib_undefined)
       && h->root.type == bfd_link_hash_undefined
       && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0
-      && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
+      && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0
+      && ! elf_link_check_versioned_symbol (finfo->info, h))
     {
       if (! ((*finfo->info->callbacks->undefined_symbol)
              (finfo->info, h->root.root.string, h->root.u.undef.abfd,
-              (asection *) NULL, 0, true)))
-        {
-          eoinfo->failed = true;
-          return false;
-        }
+              (asection *) NULL, (bfd_vma) 0, TRUE)))
+        {
+          eoinfo->failed = TRUE;
+          return FALSE;
+        }
+    }
+
+  /* We should also warn if a forced local symbol is referenced from
+     shared libraries.  */
+  if (! finfo->info->relocateable
+      && (! finfo->info->shared || ! finfo->info->allow_shlib_undefined)
+      && (h->elf_link_hash_flags
+          & (ELF_LINK_FORCED_LOCAL | ELF_LINK_HASH_REF_DYNAMIC
+             | ELF_LINK_DYNAMIC_DEF | ELF_LINK_DYNAMIC_WEAK))
+         == (ELF_LINK_FORCED_LOCAL | ELF_LINK_HASH_REF_DYNAMIC)
+      && ! elf_link_check_versioned_symbol (finfo->info, h))
+    {
+      (*_bfd_error_handler)
+        (_("%s: %s symbol `%s' in %s is referenced by DSO"),
+         bfd_get_filename (finfo->output_bfd),
+         ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
+         ? "internal"
+         : ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
+           ? "hidden" : "local",
+         h->root.root.string,
+         bfd_archive_filename (h->root.u.def.section->owner));
+      eoinfo->failed = TRUE;
+      return FALSE;
     }
 
@@ -5152 +6463 @@
      output it.  */
   if (h->indx == -2)
-    strip = false;
+    strip = FALSE;
   else if (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
             || (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
            && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
            && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
-    strip = true;
-  else if (finfo->info->strip == strip_all
-           || (finfo->info->strip == strip_some
-               && bfd_hash_lookup (finfo->info->keep_hash,
-                                   h->root.root.string,
-                                   false, false) == NULL))
-    strip = true;
+    strip = TRUE;
+  else if (finfo->info->strip == strip_all)
+    strip = TRUE;
+  else if (finfo->info->strip == strip_some
+           && bfd_hash_lookup (finfo->info->keep_hash,
+                               h->root.root.string, FALSE, FALSE) == NULL)
+    strip = TRUE;
+  else if (finfo->info->strip_discarded
+           && (h->root.type == bfd_link_hash_defined
+               || h->root.type == bfd_link_hash_defweak)
+           && elf_discarded_section (h->root.u.def.section))
+    strip = TRUE;
   else
-    strip = false;
+    strip = FALSE;
 
   /* If we're stripping it, and it's not a dynamic symbol, there's
@@ -5172 +6488 @@
       && h->dynindx == -1
       && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
-    return true;
+    return TRUE;
 
   sym.st_value = 0;
@@ -5189 +6505 @@
     default:
     case bfd_link_hash_new:
+    case bfd_link_hash_warning:
       abort ();
-      return false;
+      return FALSE;
 
     case bfd_link_hash_undefined:
-      input_sec = bfd_und_section_ptr;
-      sym.st_shndx = SHN_UNDEF;
-      break;
-
     case bfd_link_hash_undefweak:
       input_sec = bfd_und_section_ptr;
@@ -5211 +6524 @@
               _bfd_elf_section_from_bfd_section (finfo->output_bfd,
                                                  input_sec->output_section);
-            if (sym.st_shndx == (unsigned short) -1)
+            if (sym.st_shndx == SHN_BAD)
               {
                 (*_bfd_error_handler)
@@ -5218 +6531 @@
                    input_sec->output_section->name,
                    input_sec->name);
-                eoinfo->failed = true;
-                return false;
+                eoinfo->failed = TRUE;
+                return FALSE;
               }
 
@@ -5227 +6540 @@
             sym.st_value = h->root.u.def.value + input_sec->output_offset;
             if (! finfo->info->relocateable)
-              sym.st_value += input_sec->output_section->vma;
+              {
+                sym.st_value += input_sec->output_section->vma;
+                if (h->type == STT_TLS)
+                  {
+                    /* STT_TLS symbols are relative to PT_TLS segment
+                       base.  */
+                    BFD_ASSERT (finfo->first_tls_sec != NULL);
+                    sym.st_value -= finfo->first_tls_sec->vma;
+                  }
+              }
           }
         else
@@ -5247 +6569 @@
     case bfd_link_hash_indirect:
       /* These symbols are created by symbol versioning.  They point
-         to the decorated version of the name.  For example, if the
-         symbol foo@@GNU_1.2 is the default, which should be used when
-         foo is used with no version, then we add an indirect symbol
-         foo which points to foo@@GNU_1.2.  We ignore these symbols,
-         since the indirected symbol is already in the hash table.  */
-      return true;
-
-    case bfd_link_hash_warning:
-      /* We can't represent these symbols in ELF, although a warning
-         symbol may have come from a .gnu.warning.SYMBOL section.  We
-         just put the target symbol in the hash table.  If the target
-         symbol does not really exist, don't do anything.  */
-      if (h->root.u.i.link->type == bfd_link_hash_new)
-        return true;
-      return (elf_link_output_extsym
-              ((struct elf_link_hash_entry *) h->root.u.i.link, data));
+         to the decorated version of the name.  For example, if the
+         symbol foo@@GNU_1.2 is the default, which should be used when
+         foo is used with no version, then we add an indirect symbol
+         foo which points to foo@@GNU_1.2.  We ignore these symbols,
+         since the indirected symbol is already in the hash table.  */
+      return TRUE;
     }
 
   /* Give the processor backend a chance to tweak the symbol value,
      and also to finish up anything that needs to be done for this
-     symbol.  */
+     symbol.  FIXME: Not calling elf_backend_finish_dynamic_symbol for
+     forced local syms when non-shared is due to a historical quirk.  */
   if ((h->dynindx != -1
        || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)
+      && (finfo->info->shared
+          || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
       && elf_hash_table (finfo->info)->dynamic_sections_created)
     {
@@ -5278 +6593 @@
              (finfo->output_bfd, finfo->info, h, &sym)))
         {
-          eoinfo->failed = true;
-          return false;
+          eoinfo->failed = TRUE;
+          return FALSE;
         }
     }
@@ -5291 +6606 @@
   if (sym.st_shndx == SHN_UNDEF
       && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) != 0
-      && (ELF_ST_BIND(sym.st_info) == STB_GLOBAL
-          || ELF_ST_BIND(sym.st_info) == STB_WEAK))
+      && (ELF_ST_BIND (sym.st_info) == STB_GLOBAL
+          || ELF_ST_BIND (sym.st_info) == STB_WEAK))
     {
       int bindtype;
@@ -5303 +6618 @@
     }
 
-  /* If a symbol is not defined locally, we clear the visibility
-     field.  */
-  if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
-    sym.st_other ^= ELF_ST_VISIBILITY(sym.st_other);
+  /* If a non-weak symbol with non-default visibility is not defined
+     locally, it is a fatal error.  */
+  if (! finfo->info->relocateable
+      && ELF_ST_VISIBILITY (sym.st_other)
+      && ELF_ST_BIND (sym.st_info) != STB_WEAK
+      && h->root.type == bfd_link_hash_undefined
+      && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
+    {
+      (*_bfd_error_handler)
+        (_("%s: %s symbol `%s' isn't defined"),
+          bfd_get_filename (finfo->output_bfd),
+          ELF_ST_VISIBILITY (sym.st_other) == STV_PROTECTED
+          ? "protected"
+          : ELF_ST_VISIBILITY (sym.st_other) == STV_INTERNAL
+            ? "internal" : "hidden",
+          h->root.root.string);
+      eoinfo->failed = TRUE;
+      return FALSE;
+    }
 
   /* If this symbol should be put in the .dynsym section, then put it
-     there now.  We have already know the symbol index.  We also fill
-     in the entry in the .hash section.  */
+     there now.  We already know the symbol index.  We also fill in
+     the entry in the .hash section.  */
   if (h->dynindx != -1
       && elf_hash_table (finfo->info)->dynamic_sections_created)
@@ -5319 +6649 @@
       bfd_byte *bucketpos;
       bfd_vma chain;
+      Elf_External_Sym *esym;
 
       sym.st_name = h->dynstr_index;
-
-      elf_swap_symbol_out (finfo->output_bfd, &sym,
-                           (PTR) (((Elf_External_Sym *)
-                                   finfo->dynsym_sec->contents)
-                                  + h->dynindx));
+      esym = (Elf_External_Sym *) finfo->dynsym_sec->contents + h->dynindx;
+      elf_swap_symbol_out (finfo->output_bfd, &sym, (PTR) esym, (PTR) 0);
 
       bucketcount = elf_hash_table (finfo->info)->bucketcount;
@@ -5334 +6662 @@
                    + (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, (bfd_vma) h->dynindx,
+               bucketpos);
       bfd_put (8 * hash_entry_size, finfo->output_bfd, chain,
                ((bfd_byte *) finfo->hash_sec->contents
@@ -5342 +6671 @@
         {
           Elf_Internal_Versym iversym;
+          Elf_External_Versym *eversym;
 
           if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
@@ -5361 +6691 @@
             iversym.vs_vers |= VERSYM_HIDDEN;
 
-          _bfd_elf_swap_versym_out (finfo->output_bfd, &iversym,
-                                    (((Elf_External_Versym *)
-                                      finfo->symver_sec->contents)
-                                     + h->dynindx));
+          eversym = (Elf_External_Versym *) finfo->symver_sec->contents;
+          eversym += h->dynindx;
+          _bfd_elf_swap_versym_out (finfo->output_bfd, &iversym, eversym);
         }
     }
@@ -5370 +6699 @@
   /* If we're stripping it, then it was just a dynamic symbol, and
      there's nothing else to do.  */
-  if (strip)
-    return true;
+  if (strip || (input_sec->flags & SEC_EXCLUDE) != 0)
+    return TRUE;
 
   h->indx = bfd_get_symcount (finfo->output_bfd);
@@ -5377 +6706 @@
   if (! elf_link_output_sym (finfo, h->root.root.string, &sym, input_sec))
     {
-      eoinfo->failed = true;
-      return false;
-    }
-
-  return true;
+      eoinfo->failed = TRUE;
+      return FALSE;
+    }
+
+  return TRUE;
 }
 
@@ -5388 +6717 @@
    OUTPUT_BFD.  */
 
-static void
+static bfd_boolean
 elf_link_output_relocs (output_bfd, input_section, input_rel_hdr,
                         internal_relocs)
@@ -5398 +6727 @@
   Elf_Internal_Rela *irela;
   Elf_Internal_Rela *irelaend;
+  bfd_byte *erel;
   Elf_Internal_Shdr *output_rel_hdr;
   asection *output_section;
   unsigned int *rel_countp = NULL;
   struct elf_backend_data *bed;
+  void (*swap_out) PARAMS ((bfd *, const Elf_Internal_Rela *, bfd_byte *));
 
   output_section = input_section->output_section;
@@ -5419 +6750 @@
       rel_countp = &elf_section_data (output_section)->rel_count2;
     }
-
-  BFD_ASSERT (output_rel_hdr != NULL);
+  else
+    {
+      (*_bfd_error_handler)
+        (_("%s: relocation size mismatch in %s section %s"),
+         bfd_get_filename (output_bfd),
+         bfd_archive_filename (input_section->owner),
+         input_section->name);
+      bfd_set_error (bfd_error_wrong_object_format);
+      return FALSE;
+    }
 
   bed = get_elf_backend_data (output_bfd);
+  if (input_rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
+    swap_out = bed->s->swap_reloc_out;
+  else if (input_rel_hdr->sh_entsize == sizeof (Elf_External_Rela))
+    swap_out = bed->s->swap_reloca_out;
+  else
+    abort ();
+
+  erel = output_rel_hdr->contents;
+  erel += *rel_countp * input_rel_hdr->sh_entsize;
   irela = internal_relocs;
-  irelaend = irela + NUM_SHDR_ENTRIES (input_rel_hdr)
-                     * bed->s->int_rels_per_ext_rel;
-
-  if (input_rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
-    {
-      Elf_External_Rel *erel;
-      Elf_Internal_Rel *irel;
-      
-      irel = (Elf_Internal_Rel *) bfd_zmalloc (bed->s->int_rels_per_ext_rel
-                                               * sizeof (Elf_Internal_Rel));
-      if (irel == NULL)
-        {
-          (*_bfd_error_handler) (_("Error: out of memory"));
-          abort ();
-        }
-
-      erel = ((Elf_External_Rel *) output_rel_hdr->contents + *rel_countp);
-      for (; irela < irelaend; irela += bed->s->int_rels_per_ext_rel, erel++)
-        {
-          unsigned int i;
-          
-          for (i = 0; i < bed->s->int_rels_per_ext_rel; i++)
-            {
-              irel[i].r_offset = irela[i].r_offset;
-              irel[i].r_info = irela[i].r_info;
-              BFD_ASSERT (irela[i].r_addend == 0);
-            }
-
-          if (bed->s->swap_reloc_out)
-            (*bed->s->swap_reloc_out) (output_bfd, irel, (PTR) erel);
-          else
-            elf_swap_reloc_out (output_bfd, irel, erel);
-        }
-
-      free (irel);
-    }
-  else
-    {
-      Elf_External_Rela *erela;
-
-      BFD_ASSERT (input_rel_hdr->sh_entsize == sizeof (Elf_External_Rela));
-
-      erela = ((Elf_External_Rela *) output_rel_hdr->contents + *rel_countp);
-      for (; irela < irelaend; irela += bed->s->int_rels_per_ext_rel, erela++)
-        if (bed->s->swap_reloca_out)
-          (*bed->s->swap_reloca_out) (output_bfd, irela, (PTR) erela);
-        else
-          elf_swap_reloca_out (output_bfd, irela, erela);
+  irelaend = irela + (NUM_SHDR_ENTRIES (input_rel_hdr)
+                      * bed->s->int_rels_per_ext_rel);
+  while (irela < irelaend)
+    {
+      (*swap_out) (output_bfd, irela, erel);
+      irela += bed->s->int_rels_per_ext_rel;
+      erel += input_rel_hdr->sh_entsize;
     }
 
@@ -5477 +6784 @@
      relocations.  */
   *rel_countp += NUM_SHDR_ENTRIES (input_rel_hdr);
+
+  return TRUE;
 }
 
@@ -5484 +6793 @@
    don't have to keep them in memory.  */
 
-static boolean
+static bfd_boolean
 elf_link_input_bfd (finfo, input_bfd)
      struct elf_final_link_info *finfo;
      bfd *input_bfd;
 {
-  boolean (*relocate_section) PARAMS ((bfd *, struct bfd_link_info *,
-                                       bfd *, asection *, bfd_byte *,
-                                       Elf_Internal_Rela *,
-                                       Elf_Internal_Sym *, asection **));
+  bfd_boolean (*relocate_section)
+    PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
+             Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
   bfd *output_bfd;
   Elf_Internal_Shdr *symtab_hdr;
   size_t locsymcount;
   size_t extsymoff;
-  Elf_External_Sym *external_syms;
-  Elf_External_Sym *esym;
-  Elf_External_Sym *esymend;
+  Elf_Internal_Sym *isymbuf;
   Elf_Internal_Sym *isym;
+  Elf_Internal_Sym *isymend;
   long *pindex;
   asection **ppsection;
   asection *o;
   struct elf_backend_data *bed;
+  bfd_boolean emit_relocs;
+  struct elf_link_hash_entry **sym_hashes;
 
   output_bfd = finfo->output_bfd;
@@ -5514 +6823 @@
      contents.  */
   if ((input_bfd->flags & DYNAMIC) != 0)
-    return true;
+    return TRUE;
+
+  emit_relocs = (finfo->info->relocateable
+                 || finfo->info->emitrelocations
+                 || bed->elf_backend_emit_relocs);
 
   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
@@ -5529 +6842 @@
 
   /* Read the local symbols.  */
-  if (symtab_hdr->contents != NULL)
-    external_syms = (Elf_External_Sym *) symtab_hdr->contents;
-  else if (locsymcount == 0)
-    external_syms = NULL;
-  else
-    {
-      external_syms = finfo->external_syms;
-      if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
-          || (bfd_read (external_syms, sizeof (Elf_External_Sym),
-                        locsymcount, input_bfd)
-              != locsymcount * sizeof (Elf_External_Sym)))
-        return false;
-    }
-
-  /* Swap in the local symbols and write out the ones which we know
-     are going into the output file.  */
-  esym = external_syms;
-  esymend = esym + locsymcount;
-  isym = finfo->internal_syms;
-  pindex = finfo->indices;
-  ppsection = finfo->sections;
-  for (; esym < esymend; esym++, isym++, pindex++, ppsection++)
+  isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
+  if (isymbuf == NULL && locsymcount != 0)
+    {
+      isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
+                                      finfo->internal_syms,
+                                      finfo->external_syms,
+                                      finfo->locsym_shndx);
+      if (isymbuf == NULL)
+        return FALSE;
+    }
+
+  /* Find local symbol sections and adjust values of symbols in
+     SEC_MERGE sections.  Write out those local symbols we know are
+     going into the output file.  */
+  isymend = isymbuf + locsymcount;
+  for (isym = isymbuf, pindex = finfo->indices, ppsection = finfo->sections;
+       isym < isymend;
+       isym++, pindex++, ppsection++)
     {
       asection *isec;
@@ -5556 +6865 @@
       Elf_Internal_Sym osym;
 
-      elf_swap_symbol_in (input_bfd, esym, isym);
       *pindex = -1;
 
@@ -5568 +6876 @@
         }
 
-      name = NULL;
       if (isym->st_shndx == SHN_UNDEF)
-        {
-          isec = bfd_und_section_ptr;
-          name = isec->name;
-        }
-      else if (isym->st_shndx > 0 && isym->st_shndx < SHN_LORESERVE)
-        isec = section_from_elf_index (input_bfd, isym->st_shndx);
+        isec = bfd_und_section_ptr;
+      else if (isym->st_shndx < SHN_LORESERVE
+               || isym->st_shndx > SHN_HIRESERVE)
+        {
+          isec = section_from_elf_index (input_bfd, isym->st_shndx);
+          if (isec
+              && isec->sec_info_type == ELF_INFO_TYPE_MERGE
+              && ELF_ST_TYPE (isym->st_info) != STT_SECTION)
+            isym->st_value =
+              _bfd_merged_section_offset (output_bfd, &isec,
+                                          elf_section_data (isec)->sec_info,
+                                          isym->st_value, (bfd_vma) 0);
+        }
       else if (isym->st_shndx == SHN_ABS)
-        {
-          isec = bfd_abs_section_ptr;
-          name = isec->name;
-        }
+        isec = bfd_abs_section_ptr;
       else if (isym->st_shndx == SHN_COMMON)
-        {
-          isec = bfd_com_section_ptr;
-          name = isec->name;
-        }
+        isec = bfd_com_section_ptr;
       else
         {
@@ -5595 +6903 @@
 
       /* Don't output the first, undefined, symbol.  */
-      if (esym == external_syms)
+      if (ppsection == finfo->sections)
         continue;
 
       if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
         {
-          asection *ksec;
-
-          /* Save away all section symbol values.  */
-          if (isec != NULL)
-            {
-              if (name)
-                {
-                  if (isec->symbol->value != isym->st_value)
-                    (*_bfd_error_handler)
-                      (_("%s: invalid section symbol index 0x%x (%s) ingored"),
-                       bfd_get_filename (input_bfd), isym->st_shndx,
-                       name);
-                  continue;
-                }
-              isec->symbol->value = isym->st_value;
-            }
-
-          /* If this is a discarded link-once section symbol, update
-             it's value to that of the kept section symbol.  The
-             linker will keep the first of any matching link-once
-             sections, so we should have already seen it's section
-             symbol.  I trust no-one will have the bright idea of
-             re-ordering the bfd list...  */
-          if (isec != NULL
-              && (bfd_get_section_flags (input_bfd, isec) & SEC_LINK_ONCE) != 0
-              && (ksec = isec->kept_section) != NULL)
-            {
-              isym->st_value = ksec->symbol->value;
-
-              /* That put the value right, but the section info is all
-                 wrong.  I hope this works.  */
-              isec->output_offset = ksec->output_offset;
-              isec->output_section = ksec->output_section;
-            }
-
           /* We never output section symbols.  Instead, we use the
              section symbol of the corresponding section in the output
@@ -5655 +6928 @@
 
       /* 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 > 0
-          && isym->st_shndx < SHN_LORESERVE
+         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)
           && isec != NULL
           && ((! isec->linker_mark && (isec->flags & SEC_HAS_CONTENTS) != 0)
@@ -5671 +6943 @@
                                               isym->st_name);
       if (name == NULL)
-        return false;
+        return FALSE;
 
       /* See if we are discarding symbols with this name.  */
       if ((finfo->info->strip == strip_some
-           && (bfd_hash_lookup (finfo->info->keep_hash, name, false, false)
+           && (bfd_hash_lookup (finfo->info->keep_hash, name, FALSE, FALSE)
                == NULL))
-          || (finfo->info->discard == discard_l
+          || (((finfo->info->discard == discard_sec_merge
+                && (isec->flags & SEC_MERGE) && ! finfo->info->relocateable)
+               || finfo->info->discard == discard_l)
               && bfd_is_local_label_name (input_bfd, name)))
         continue;
@@ -5688 +6962 @@
       osym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
                                                          isec->output_section);
-      if (osym.st_shndx == (unsigned short) -1)
-        return false;
+      if (osym.st_shndx == SHN_BAD)
+        return FALSE;
 
       *pindex = bfd_get_symcount (output_bfd);
@@ -5702 +6976 @@
       osym.st_value += isec->output_offset;
       if (! finfo->info->relocateable)
-        osym.st_value += isec->output_section->vma;
+        {
+          osym.st_value += isec->output_section->vma;
+          if (ELF_ST_TYPE (osym.st_info) == STT_TLS)
+            {
+              /* STT_TLS symbols are relative to PT_TLS segment base.  */
+              BFD_ASSERT (finfo->first_tls_sec != NULL);
+              osym.st_value -= finfo->first_tls_sec->vma;
+            }
+        }
 
       if (! elf_link_output_sym (finfo, name, &osym, isec))
-        return false;
+        return FALSE;
     }
 
   /* Relocate the contents of each section.  */
+  sym_hashes = elf_sym_hashes (input_bfd);
   for (o = input_bfd->sections; o != NULL; o = o->next)
     {
@@ -5731 +7014 @@
 
       /* Get the contents of the section.  They have been cached by a
-         relaxation routine.  Note that o is a section in an input
-         file, so the contents field will not have been set by any of
-         the routines which work on output files.  */
+         relaxation routine.  Note that o is a section in an input
+         file, so the contents field will not have been set by any of
+         the routines which work on output files.  */
       if (elf_section_data (o)->this_hdr.contents != NULL)
         contents = elf_section_data (o)->this_hdr.contents;
@@ -5741 +7024 @@
           if (! bfd_get_section_contents (input_bfd, o, contents,
                                           (file_ptr) 0, o->_raw_size))
-            return false;
+            return FALSE;
         }
 
@@ -5751 +7034 @@
           internal_relocs = (NAME(_bfd_elf,link_read_relocs)
                              (input_bfd, o, finfo->external_relocs,
-                              finfo->internal_relocs, false));
+                              finfo->internal_relocs, FALSE));
           if (internal_relocs == NULL
               && o->reloc_count > 0)
-            return false;
+            return FALSE;
+
+          /* Run through the relocs looking for any against symbols
+             from discarded sections and section symbols from
+             removed link-once sections.  Complain about relocs
+             against discarded sections.  Zero relocs against removed
+             link-once sections.  */
+          if (!finfo->info->relocateable
+              && !elf_section_ignore_discarded_relocs (o))
+            {
+              Elf_Internal_Rela *rel, *relend;
+
+              rel = internal_relocs;
+              relend = rel + o->reloc_count * bed->s->int_rels_per_ext_rel;
+              for ( ; rel < relend; rel++)
+                {
+                  unsigned long r_symndx = ELF_R_SYM (rel->r_info);
+
+                  if (r_symndx >= locsymcount
+                      || (elf_bad_symtab (input_bfd)
+                          && finfo->sections[r_symndx] == NULL))
+                    {
+                      struct elf_link_hash_entry *h;
+
+                      h = sym_hashes[r_symndx - extsymoff];
+                      while (h->root.type == bfd_link_hash_indirect
+                             || h->root.type == bfd_link_hash_warning)
+                        h = (struct elf_link_hash_entry *) h->root.u.i.link;
+
+                      /* Complain if the definition comes from a
+                         discarded section.  */
+                      if ((h->root.type == bfd_link_hash_defined
+                           || h->root.type == bfd_link_hash_defweak)
+                          && elf_discarded_section (h->root.u.def.section))
+                        {
+                          if ((o->flags & SEC_DEBUGGING) != 0)
+                            {
+                              BFD_ASSERT (r_symndx != 0);
+                              memset (rel, 0, sizeof (*rel));
+                            }
+                          else
+                            {
+                              if (! ((*finfo->info->callbacks->undefined_symbol)
+                                     (finfo->info, h->root.root.string,
+                                      input_bfd, o, rel->r_offset,
+                                      TRUE)))
+                                return FALSE;
+                            }
+                        }
+                    }
+                  else
+                    {
+                      asection *sec = finfo->sections[r_symndx];
+
+                      if (sec != NULL && elf_discarded_section (sec))
+                        {
+                          if ((o->flags & SEC_DEBUGGING) != 0
+                              || (sec->flags & SEC_LINK_ONCE) != 0)
+                            {
+                              BFD_ASSERT (r_symndx != 0);
+                              rel->r_info
+                                = ELF_R_INFO (0, ELF_R_TYPE (rel->r_info));
+                              rel->r_addend = 0;
+                            }
+                          else
+                            {
+                              bfd_boolean ok;
+                              const char *msg
+                                = _("local symbols in discarded section %s");
+                              bfd_size_type amt
+                                = strlen (sec->name) + strlen (msg) - 1;
+                              char *buf = (char *) bfd_malloc (amt);
+
+                              if (buf != NULL)
+                                sprintf (buf, msg, sec->name);
+                              else
+                                buf = (char *) sec->name;
+                              ok = (*finfo->info->callbacks
+                                    ->undefined_symbol) (finfo->info, buf,
+                                                         input_bfd, o,
+                                                         rel->r_offset,
+                                                         TRUE);
+                              if (buf != sec->name)
+                                free (buf);
+                              if (!ok)
+                                return FALSE;
+                            }
+                        }
+                    }
+                }
+            }
 
           /* Relocate the section by invoking a back end routine.
@@ -5779 +7152 @@
                                      input_bfd, o, contents,
                                      internal_relocs,
-                                     finfo->internal_syms,
+                                     isymbuf,
                                      finfo->sections))
-            return false;
-
-          if (finfo->info->relocateable || finfo->info->emitrelocations)
+            return FALSE;
+
+          if (emit_relocs)
             {
               Elf_Internal_Rela *irela;
               Elf_Internal_Rela *irelaend;
+              bfd_vma last_offset;
               struct elf_link_hash_entry **rel_hash;
-              Elf_Internal_Shdr *input_rel_hdr;
+              Elf_Internal_Shdr *input_rel_hdr, *input_rel_hdr2;
               unsigned int next_erel;
+              bfd_boolean (*reloc_emitter)
+                PARAMS ((bfd *, asection *, Elf_Internal_Shdr *,
+                         Elf_Internal_Rela *));
+              bfd_boolean rela_normal;
+
+              input_rel_hdr = &elf_section_data (o)->rel_hdr;
+              rela_normal = (bed->rela_normal
+                             && (input_rel_hdr->sh_entsize
+                                 == sizeof (Elf_External_Rela)));
 
               /* Adjust the reloc addresses and symbol indices.  */
 
               irela = internal_relocs;
-              irelaend = irela
-                         + o->reloc_count * bed->s->int_rels_per_ext_rel;
+              irelaend = irela + o->reloc_count * bed->s->int_rels_per_ext_rel;
               rel_hash = (elf_section_data (o->output_section)->rel_hashes
                           + elf_section_data (o->output_section)->rel_count
                           + elf_section_data (o->output_section)->rel_count2);
+              last_offset = o->output_offset;
+              if (!finfo->info->relocateable)
+                last_offset += o->output_section->vma;
               for (next_erel = 0; irela < irelaend; irela++, next_erel++)
                 {
                   unsigned long r_symndx;
-                  Elf_Internal_Sym *isym;
                   asection *sec;
+                  Elf_Internal_Sym sym;
 
                   if (next_erel == bed->s->int_rels_per_ext_rel)
@@ -5811 +7196 @@
                     }
 
+                  irela->r_offset = _bfd_elf_section_offset (output_bfd,
+                                                             finfo->info, o,
+                                                             irela->r_offset);
+                  if (irela->r_offset >= (bfd_vma) -2)
+                    {
+                      /* 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
+                         being ordered.  */
+                      irela->r_offset = last_offset;
+                      irela->r_info = 0;
+                      irela->r_addend = 0;
+                      continue;
+                    }
+
                   irela->r_offset += o->output_offset;
 
                   /* Relocs in an executable have to be virtual addresses.  */
-                  if (finfo->info->emitrelocations)
+                  if (!finfo->info->relocateable)
                     irela->r_offset += o->output_section->vma;
 
+                  last_offset = irela->r_offset;
+
                   r_symndx = ELF_R_SYM (irela->r_info);
-
-                  if (r_symndx == 0)
+                  if (r_symndx == STN_UNDEF)
                     continue;
 
@@ -5856 +7258 @@
 
                   *rel_hash = NULL;
-                  isym = finfo->internal_syms + r_symndx;
+                  sym = isymbuf[r_symndx];
                   sec = finfo->sections[r_symndx];
-                  if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
+                  if (ELF_ST_TYPE (sym.st_info) == STT_SECTION)
                     {
                       /* I suppose the backend ought to fill in the
@@ -5865 +7267 @@
                          discarded a section, the output_section will
                          be the absolute section.  */
-                      if (sec != NULL
-                          && (bfd_is_abs_section (sec)
-                              || (sec->output_section != NULL
-                                  && bfd_is_abs_section (sec->output_section))))
+                      if (bfd_is_abs_section (sec)
+                          || (sec != NULL
+                              && bfd_is_abs_section (sec->output_section)))
                         r_symndx = 0;
                       else if (sec == NULL || sec->owner == NULL)
                         {
                           bfd_set_error (bfd_error_bad_value);
-                          return false;
+                          return FALSE;
                         }
                       else
@@ -5880 +7281 @@
                           BFD_ASSERT (r_symndx != 0);
                         }
+
+                      /* Adjust the addend according to where the
+                         section winds up in the output section.  */
+                      if (rela_normal)
+                        irela->r_addend += sec->output_offset;
                     }
                   else
@@ -5885 +7291 @@
                       if (finfo->indices[r_symndx] == -1)
                         {
-                          unsigned long link;
+                          unsigned long shlink;
                           const char *name;
                           asection *osec;
@@ -5893 +7299 @@
                               /* You can't do ld -r -s.  */
                               bfd_set_error (bfd_error_invalid_operation);
-                              return false;
+                              return FALSE;
                             }
 
@@ -5899 +7305 @@
                              since it is needed by a reloc, we
                              must output it now.  */
-                          link = symtab_hdr->sh_link;
-                          name = bfd_elf_string_from_elf_section (input_bfd,
-                                                                  link,
-                                                                  isym->st_name);
+                          shlink = symtab_hdr->sh_link;
+                          name = (bfd_elf_string_from_elf_section
+                                  (input_bfd, shlink, sym.st_name));
                           if (name == NULL)
-                            return false;
+                            return FALSE;
 
                           osec = sec->output_section;
-                          isym->st_shndx =
+                          sym.st_shndx =
                             _bfd_elf_section_from_bfd_section (output_bfd,
                                                                osec);
-                          if (isym->st_shndx == (unsigned short) -1)
-                            return false;
-
-                          isym->st_value += sec->output_offset;
+                          if (sym.st_shndx == SHN_BAD)
+                            return FALSE;
+
+                          sym.st_value += sec->output_offset;
                           if (! finfo->info->relocateable)
-                            isym->st_value += osec->vma;
-
-                          finfo->indices[r_symndx] = bfd_get_symcount (output_bfd);
-
-                          if (! elf_link_output_sym (finfo, name, isym, sec))
-                            return false;
+                            {
+                              sym.st_value += osec->vma;
+                              if (ELF_ST_TYPE (sym.st_info) == STT_TLS)
+                                {
+                                  /* STT_TLS symbols are relative to PT_TLS
+                                     segment base.  */
+                                  BFD_ASSERT (finfo->first_tls_sec != NULL);
+                                  sym.st_value -= finfo->first_tls_sec->vma;
+                                }
+                            }
+
+                          finfo->indices[r_symndx]
+                            = bfd_get_symcount (output_bfd);
+
+                          if (! elf_link_output_sym (finfo, name, &sym, sec))
+                            return FALSE;
                         }
 
@@ -5931 +7346 @@
 
               /* Swap out the relocs.  */
-              input_rel_hdr = &elf_section_data (o)->rel_hdr;
-              elf_link_output_relocs (output_bfd, o,
-                                      input_rel_hdr,
-                                      internal_relocs);
-              internal_relocs += NUM_SHDR_ENTRIES (input_rel_hdr)
-                                 * bed->s->int_rels_per_ext_rel;
-              input_rel_hdr = elf_section_data (o)->rel_hdr2;
-              if (input_rel_hdr)
-                elf_link_output_relocs (output_bfd, o,
-                                        input_rel_hdr,
-                                        internal_relocs);
+              if (bed->elf_backend_emit_relocs
+                  && !(finfo->info->relocateable
+                       || finfo->info->emitrelocations))
+                reloc_emitter = bed->elf_backend_emit_relocs;
+              else
+                reloc_emitter = elf_link_output_relocs;
+
+              if (input_rel_hdr->sh_size != 0
+                  && ! (*reloc_emitter) (output_bfd, o, input_rel_hdr,
+                                         internal_relocs))
+                return FALSE;
+
+              input_rel_hdr2 = elf_section_data (o)->rel_hdr2;
+              if (input_rel_hdr2 && input_rel_hdr2->sh_size != 0)
+                {
+                  internal_relocs += (NUM_SHDR_ENTRIES (input_rel_hdr)
+                                      * bed->s->int_rels_per_ext_rel);
+                  if (! (*reloc_emitter) (output_bfd, o, input_rel_hdr2,
+                                          internal_relocs))
+                    return FALSE;
+                }
             }
         }
 
       /* Write out the modified section contents.  */
-      if (elf_section_data (o)->stab_info == NULL)
-        {
-          if (! (o->flags & SEC_EXCLUDE) &&
-              ! bfd_set_section_contents (output_bfd, o->output_section,
-                                          contents, o->output_offset,
-                                          (o->_cooked_size != 0
-                                           ? o->_cooked_size
-                                           : o->_raw_size)))
-            return false;
-        }
-      else
-        {
+      if (bed->elf_backend_write_section
+          && (*bed->elf_backend_write_section) (output_bfd, o, contents))
+        {
+          /* Section written out.  */
+        }
+      else switch (o->sec_info_type)
+        {
+        case ELF_INFO_TYPE_STABS:
           if (! (_bfd_write_section_stabs
-                 (output_bfd, &elf_hash_table (finfo->info)->stab_info,
-                  o, &elf_section_data (o)->stab_info, contents)))
-            return false;
-        }
-    }
-
-  return true;
+                 (output_bfd,
+                  &elf_hash_table (finfo->info)->stab_info,
+                  o, &elf_section_data (o)->sec_info, contents)))
+            return FALSE;
+          break;
+        case ELF_INFO_TYPE_MERGE:
+          if (! _bfd_write_merged_section (output_bfd, o,
+                                           elf_section_data (o)->sec_info))
+            return FALSE;
+          break;
+        case ELF_INFO_TYPE_EH_FRAME:
+          {
+            if (! _bfd_elf_write_section_eh_frame (output_bfd, finfo->info,
+                                                   o, contents))
+              return FALSE;
+          }
+          break;
+        default:
+          {
+            bfd_size_type sec_size;
+
+            sec_size = (o->_cooked_size != 0 ? o->_cooked_size : o->_raw_size);
+            if (! (o->flags & SEC_EXCLUDE)
+                && ! bfd_set_section_contents (output_bfd, o->output_section,
+                                               contents,
+                                               (file_ptr) o->output_offset,
+                                               sec_size))
+              return FALSE;
+          }
+          break;
+        }
+    }
+
+  return TRUE;
 }
 
@@ -5973 +7421 @@
    with -Ur.  */
 
-static boolean
+static bfd_boolean
 elf_reloc_link_order (output_bfd, info, output_section, link_order)
      bfd *output_bfd;
@@ -5987 +7435 @@
   Elf_Internal_Shdr *rel_hdr;
   struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
+  Elf_Internal_Rela irel[MAX_INT_RELS_PER_EXT_REL];
+  bfd_byte *erel;
+  unsigned int i;
 
   howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
@@ -5992 +7443 @@
     {
       bfd_set_error (bfd_error_bad_value);
-      return false;
+      return FALSE;
     }
 
@@ -6012 +7463 @@
 
       /* Treat a reloc against a defined symbol as though it were
-         actually against the section.  */
+         actually against the section.  */
       h = ((struct elf_link_hash_entry *)
            bfd_wrapped_link_hash_lookup (output_bfd, info,
                                          link_order->u.reloc.p->u.name,
-                                         false, false, true));
+                                         FALSE, FALSE, TRUE));
       if (h != NULL
           && (h->root.type == bfd_link_hash_defined
@@ -6027 +7478 @@
           *rel_hash_ptr = NULL;
           /* It seems that we ought to add the symbol value to the
-             addend here, but in practice it has already been added
-             because it was passed to constructor_callback.  */
+             addend here, but in practice it has already been added
+             because it was passed to constructor_callback.  */
           addend += section->output_section->vma + section->output_offset;
         }
@@ -6044 +7495 @@
                  (info, link_order->u.reloc.p->u.name, (bfd *) NULL,
                   (asection *) NULL, (bfd_vma) 0)))
-            return false;
+            return FALSE;
           indx = 0;
         }
@@ -6056 +7507 @@
       bfd_reloc_status_type rstat;
       bfd_byte *buf;
-      boolean ok;
+      bfd_boolean ok;
+      const char *sym_name;
 
       size = bfd_get_reloc_size (howto);
       buf = (bfd_byte *) bfd_zmalloc (size);
       if (buf == (bfd_byte *) NULL)
-        return false;
-      rstat = _bfd_relocate_contents (howto, output_bfd, addend, buf);
+        return FALSE;
+      rstat = _bfd_relocate_contents (howto, output_bfd, (bfd_vma) addend, buf);
       switch (rstat)
         {
         case bfd_reloc_ok:
           break;
+
         default:
         case bfd_reloc_outofrange:
           abort ();
+
         case bfd_reloc_overflow:
+          if (link_order->type == bfd_section_reloc_link_order)
+            sym_name = bfd_section_name (output_bfd,
+                                         link_order->u.reloc.p->u.section);
+          else
+            sym_name = link_order->u.reloc.p->u.name;
           if (! ((*info->callbacks->reloc_overflow)
-                 (info,
-                  (link_order->type == bfd_section_reloc_link_order
-                   ? bfd_section_name (output_bfd,
-                                       link_order->u.reloc.p->u.section)
-                   : link_order->u.reloc.p->u.name),
-                  howto->name, addend, (bfd *) NULL, (asection *) NULL,
-                  (bfd_vma) 0)))
+                 (info, sym_name, howto->name, addend,
+                  (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
             {
               free (buf);
-              return false;
+              return FALSE;
             }
           break;
@@ -6089 +7543 @@
       free (buf);
       if (! ok)
-        return false;
+        return FALSE;
     }
 
@@ -6099 +7553 @@
     offset += output_section->vma;
 
+  for (i = 0; i < bed->s->int_rels_per_ext_rel; i++)
+    {
+      irel[i].r_offset = offset;
+      irel[i].r_info = 0;
+      irel[i].r_addend = 0;
+    }
+  irel[0].r_info = ELF_R_INFO (indx, howto->type);
+
   rel_hdr = &elf_section_data (output_section)->rel_hdr;
-
+  erel = rel_hdr->contents;
   if (rel_hdr->sh_type == SHT_REL)
     {
-      Elf_Internal_Rel *irel;
-      Elf_External_Rel *erel;
-      unsigned int i;
-      
-      irel = (Elf_Internal_Rel *) bfd_zmalloc (bed->s->int_rels_per_ext_rel
-                                               * sizeof (Elf_Internal_Rel));
-      if (irel == NULL)
-        return false;
-      
-      for (i = 0; i < bed->s->int_rels_per_ext_rel; i++)
-        irel[i].r_offset = offset;
-      irel[0].r_info = ELF_R_INFO (indx, howto->type);
-
-      erel = ((Elf_External_Rel *) rel_hdr->contents
-              + elf_section_data (output_section)->rel_count);
-
-      if (bed->s->swap_reloc_out)
-        (*bed->s->swap_reloc_out) (output_bfd, irel, (bfd_byte *) erel);
-      else
-        elf_swap_reloc_out (output_bfd, irel, erel);
-
-      free (irel);
+      erel += (elf_section_data (output_section)->rel_count
+               * sizeof (Elf_External_Rel));
+      (*bed->s->swap_reloc_out) (output_bfd, irel, erel);
     }
   else
     {
-      Elf_Internal_Rela *irela;
-      Elf_External_Rela *erela;
-      unsigned int i;
-      
-      irela = (Elf_Internal_Rela *) bfd_zmalloc (bed->s->int_rels_per_ext_rel
-                                                 * sizeof (Elf_Internal_Rela));
-      if (irela == NULL)
-        return false;
-
-      for (i = 0; i < bed->s->int_rels_per_ext_rel; i++)
-        irela[i].r_offset = offset;
-      irela[0].r_info = ELF_R_INFO (indx, howto->type);
-      irela[0].r_addend = addend;
-
-      erela = ((Elf_External_Rela *) rel_hdr->contents
-               + elf_section_data (output_section)->rel_count);
-
-      if (bed->s->swap_reloca_out)
-        (*bed->s->swap_reloca_out) (output_bfd, irela, (bfd_byte *) erela);
-      else
-        elf_swap_reloca_out (output_bfd, irela, erela);
+      irel[0].r_addend = addend;
+      erel += (elf_section_data (output_section)->rel_count
+               * sizeof (Elf_External_Rela));
+      (*bed->s->swap_reloca_out) (output_bfd, irel, erel);
     }
 
   ++elf_section_data (output_section)->rel_count;
 
-  return true;
+  return TRUE;
 }
 
@@ -6159 +7585 @@
 /* Allocate a pointer to live in a linker created section.  */
 
-boolean
+bfd_boolean
 elf_create_pointer_linker_section (abfd, info, lsect, h, rel)
      bfd *abfd;
@@ -6169 +7595 @@
   elf_linker_section_pointers_t **ptr_linker_section_ptr = NULL;
   elf_linker_section_pointers_t *linker_section_ptr;
-  unsigned long r_symndx = ELF_R_SYM (rel->r_info);;
+  unsigned long r_symndx = ELF_R_SYM (rel->r_info);
+  bfd_size_type amt;
 
   BFD_ASSERT (lsect != NULL);
 
-  /* Is this a global symbol? */
+  /* Is this a global symbol?  */
   if (h != NULL)
     {
-      /* Has this symbol already been allocated, if so, our work is done */
+      /* Has this symbol already been allocated?  If so, our work is done.  */
       if (_bfd_elf_find_pointer_linker_section (h->linker_section_pointer,
                                                 rel->r_addend,
                                                 lsect->which))
-        return true;
+        return TRUE;
 
       ptr_linker_section_ptr = &h->linker_section_pointer;
@@ -6187 +7614 @@
         {
           if (! elf_link_record_dynamic_symbol (info, h))
-            return false;
+            return FALSE;
         }
 
@@ -6193 +7620 @@
         lsect->rel_section->_raw_size += sizeof (Elf_External_Rela);
     }
-
-  else  /* Allocation of a pointer to a local symbol */
-    {
+  else
+    {
+      /* Allocation of a pointer to a local symbol.  */
       elf_linker_section_pointers_t **ptr = elf_local_ptr_offsets (abfd);
 
-      /* Allocate a table to hold the local symbols if first time */
+      /* Allocate a table to hold the local symbols if first time.  */
       if (!ptr)
         {
@@ -6204 +7631 @@
           register unsigned int i;
 
-          ptr = (elf_linker_section_pointers_t **)
-            bfd_alloc (abfd, num_symbols * sizeof (elf_linker_section_pointers_t *));
+          amt = num_symbols;
+          amt *= sizeof (elf_linker_section_pointers_t *);
+          ptr = (elf_linker_section_pointers_t **) bfd_alloc (abfd, amt);
 
           if (!ptr)
-            return false;
+            return FALSE;
 
           elf_local_ptr_offsets (abfd) = ptr;
           for (i = 0; i < num_symbols; i++)
-            ptr[i] = (elf_linker_section_pointers_t *)0;
-        }
-
-      /* Has this symbol already been allocated, if so, our work is done */
+            ptr[i] = (elf_linker_section_pointers_t *) 0;
+        }
+
+      /* Has this symbol already been allocated?  If so, our work is done.  */
       if (_bfd_elf_find_pointer_linker_section (ptr[r_symndx],
                                                 rel->r_addend,
                                                 lsect->which))
-        return true;
+        return TRUE;
 
       ptr_linker_section_ptr = &ptr[r_symndx];
@@ -6233 +7661 @@
     }
 
-  /* Allocate space for a pointer in the linker section, and allocate a new pointer record
-     from internal memory.  */
+  /* Allocate space for a pointer in the linker section, and allocate
+     a new pointer record from internal memory.  */
   BFD_ASSERT (ptr_linker_section_ptr != NULL);
-  linker_section_ptr = (elf_linker_section_pointers_t *)
-    bfd_alloc (abfd, sizeof (elf_linker_section_pointers_t));
+  amt = sizeof (elf_linker_section_pointers_t);
+  linker_section_ptr = (elf_linker_section_pointers_t *) bfd_alloc (abfd, amt);
 
   if (!linker_section_ptr)
-    return false;
+    return FALSE;
 
   linker_section_ptr->next = *ptr_linker_section_ptr;
   linker_section_ptr->addend = rel->r_addend;
   linker_section_ptr->which = lsect->which;
-  linker_section_ptr->written_address_p = false;
+  linker_section_ptr->written_address_p = FALSE;
   *ptr_linker_section_ptr = linker_section_ptr;
 
@@ -6251 +7679 @@
   if (lsect->hole_size && lsect->hole_offset < lsect->max_hole_offset)
     {
-      linker_section_ptr->offset = lsect->section->_raw_size - lsect->hole_size + (ARCH_SIZE / 8);
+      linker_section_ptr->offset = (lsect->section->_raw_size
+                                    - lsect->hole_size + (ARCH_SIZE / 8));
       lsect->hole_offset += ARCH_SIZE / 8;
       lsect->sym_offset  += ARCH_SIZE / 8;
-      if (lsect->sym_hash)      /* Bump up symbol value if needed */
-        {
+      if (lsect->sym_hash)
+        {
+          /* Bump up symbol value if needed.  */
           lsect->sym_hash->root.u.def.value += ARCH_SIZE / 8;
 #ifdef DEBUG
           fprintf (stderr, "Bump up %s by %ld, current value = %ld\n",
                    lsect->sym_hash->root.root.string,
-                   (long)ARCH_SIZE / 8,
-                   (long)lsect->sym_hash->root.u.def.value);
+                   (long) ARCH_SIZE / 8,
+                   (long) lsect->sym_hash->root.u.def.value);
 #endif
         }
@@ -6272 +7702 @@
 
 #ifdef DEBUG
-  fprintf (stderr, "Create pointer in linker section %s, offset = %ld, section size = %ld\n",
-           lsect->name, (long)linker_section_ptr->offset, (long)lsect->section->_raw_size);
+  fprintf (stderr,
+           "Create pointer in linker section %s, offset = %ld, section size = %ld\n",
+           lsect->name, (long) linker_section_ptr->offset,
+           (long) lsect->section->_raw_size);
 #endif
 
-  return true;
+  return TRUE;
 }
 
@@ -6290 +7722 @@
 
 bfd_vma
-elf_finish_pointer_linker_section (output_bfd, input_bfd, info, lsect, h, relocation, rel, relative_reloc)
+elf_finish_pointer_linker_section (output_bfd, input_bfd, info, lsect, h,
+                                   relocation, rel, relative_reloc)
      bfd *output_bfd;
      bfd *input_bfd;
@@ -6304 +7737 @@
   BFD_ASSERT (lsect != NULL);
 
-  if (h != NULL)                /* global symbol */
-    {
-      linker_section_ptr = _bfd_elf_find_pointer_linker_section (h->linker_section_pointer,
-                                                                 rel->r_addend,
-                                                                 lsect->which);
+  if (h != NULL)
+    {
+      /* Handle global symbol.  */
+      linker_section_ptr = (_bfd_elf_find_pointer_linker_section
+                            (h->linker_section_pointer,
+                             rel->r_addend,
+                             lsect->which));
 
       BFD_ASSERT (linker_section_ptr != NULL);
@@ -6327 +7762 @@
           if (!linker_section_ptr->written_address_p)
             {
-              linker_section_ptr->written_address_p = true;
-              bfd_put_ptr (output_bfd, relocation + linker_section_ptr->addend,
-                          lsect->section->contents + linker_section_ptr->offset);
+              linker_section_ptr->written_address_p = TRUE;
+              bfd_put_ptr (output_bfd,
+                           relocation + linker_section_ptr->addend,
+                           (lsect->section->contents
+                            + linker_section_ptr->offset));
             }
         }
     }
-  else                          /* local symbol */
-    {
+  else
+    {
+      /* Handle local symbol.  */
       unsigned long r_symndx = ELF_R_SYM (rel->r_info);
       BFD_ASSERT (elf_local_ptr_offsets (input_bfd) != NULL);
       BFD_ASSERT (elf_local_ptr_offsets (input_bfd)[r_symndx] != NULL);
-      linker_section_ptr = _bfd_elf_find_pointer_linker_section (elf_local_ptr_offsets (input_bfd)[r_symndx],
-                                                                 rel->r_addend,
-                                                                 lsect->which);
+      linker_section_ptr = (_bfd_elf_find_pointer_linker_section
+                            (elf_local_ptr_offsets (input_bfd)[r_symndx],
+                             rel->r_addend,
+                             lsect->which));
 
       BFD_ASSERT (linker_section_ptr != NULL);
 
-      /* Write out pointer if it hasn't been rewritten out before */
+      /* Write out pointer if it hasn't been rewritten out before.  */
       if (!linker_section_ptr->written_address_p)
         {
-          linker_section_ptr->written_address_p = true;
+          linker_section_ptr->written_address_p = TRUE;
           bfd_put_ptr (output_bfd, relocation + linker_section_ptr->addend,
                        lsect->section->contents + linker_section_ptr->offset);
@@ -6354 +7793 @@
             {
               asection *srel = lsect->rel_section;
-              Elf_Internal_Rela *outrel;
+              Elf_Internal_Rela outrel[MAX_INT_RELS_PER_EXT_REL];
+              bfd_byte *erel;
               struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
               unsigned int i;
 
-              outrel = (Elf_Internal_Rela *) bfd_zmalloc (sizeof (Elf_Internal_Rela)
-                                                          * bed->s->int_rels_per_ext_rel);
-              if (outrel == NULL)
+              /* We need to generate a relative reloc for the dynamic
+                 linker.  */
+              if (!srel)
                 {
-                  (*_bfd_error_handler) (_("Error: out of memory"));
-                  return 0;
+                  srel = bfd_get_section_by_name (elf_hash_table (info)->dynobj,
+                                                  lsect->rel_name);
+                  lsect->rel_section = srel;
                 }
 
-              /* We need to generate a relative reloc for the dynamic linker.  */
-              if (!srel)
-                lsect->rel_section = srel = bfd_get_section_by_name (elf_hash_table (info)->dynobj,
-                                                                     lsect->rel_name);
-
               BFD_ASSERT (srel != NULL);
 
               for (i = 0; i < bed->s->int_rels_per_ext_rel; i++)
-                outrel[i].r_offset = (lsect->section->output_section->vma
-                                      + lsect->section->output_offset
-                                      + linker_section_ptr->offset);
+                {
+                  outrel[i].r_offset = (lsect->section->output_section->vma
+                                        + lsect->section->output_offset
+                                        + linker_section_ptr->offset);
+                  outrel[i].r_info = 0;
+                  outrel[i].r_addend = 0;
+                }
               outrel[0].r_info = ELF_R_INFO (0, relative_reloc);
-              outrel[0].r_addend = 0;
-              elf_swap_reloca_out (output_bfd, outrel,
-                                   (((Elf_External_Rela *)
-                                     lsect->section->contents)
-                                    + elf_section_data (lsect->section)->rel_count));
-              ++elf_section_data (lsect->section)->rel_count;
-              
-              free (outrel);
+              erel = lsect->section->contents;
+              erel += (elf_section_data (lsect->section)->rel_count++
+                       * sizeof (Elf_External_Rela));
+              elf_swap_reloca_out (output_bfd, outrel, erel);
             }
         }
@@ -6396 +7832 @@
 
 #ifdef DEBUG
-  fprintf (stderr, "Finish pointer in linker section %s, offset = %ld (0x%lx)\n",
-           lsect->name, (long)relocation, (long)relocation);
+  fprintf (stderr,
+           "Finish pointer in linker section %s, offset = %ld (0x%lx)\n",
+           lsect->name, (long) relocation, (long) relocation);
 #endif
 
@@ -6408 +7845 @@
 /* Garbage collect unused sections.  */
 
-static boolean elf_gc_mark
-  PARAMS ((struct bfd_link_info *info, asection *sec,
-           asection * (*gc_mark_hook)
-             PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Rela *,
-                      struct elf_link_hash_entry *, Elf_Internal_Sym *))));
-
-static boolean elf_gc_sweep
-  PARAMS ((struct bfd_link_info *info,
-           boolean (*gc_sweep_hook)
-             PARAMS ((bfd *abfd, struct bfd_link_info *info, asection *o,
-                      const Elf_Internal_Rela *relocs))));
-
-static boolean elf_gc_sweep_symbol
-  PARAMS ((struct elf_link_hash_entry *h, PTR idxptr));
-
-static boolean elf_gc_allocate_got_offsets
-  PARAMS ((struct elf_link_hash_entry *h, PTR offarg));
-
-static boolean elf_gc_propagate_vtable_entries_used
-  PARAMS ((struct elf_link_hash_entry *h, PTR dummy));
-
-static boolean elf_gc_smash_unused_vtentry_relocs
-  PARAMS ((struct elf_link_hash_entry *h, PTR dummy));
+static bfd_boolean elf_gc_mark
+  PARAMS ((struct bfd_link_info *, asection *,
+           asection * (*) (asection *, struct bfd_link_info *,
+                           Elf_Internal_Rela *, struct elf_link_hash_entry *,
+                           Elf_Internal_Sym *)));
+
+static bfd_boolean elf_gc_sweep
+  PARAMS ((struct bfd_link_info *,
+           bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *,
+                            const Elf_Internal_Rela *)));
+
+static bfd_boolean elf_gc_sweep_symbol
+  PARAMS ((struct elf_link_hash_entry *, PTR));
+
+static bfd_boolean elf_gc_allocate_got_offsets
+  PARAMS ((struct elf_link_hash_entry *, PTR));
+
+static bfd_boolean elf_gc_propagate_vtable_entries_used
+  PARAMS ((struct elf_link_hash_entry *, PTR));
+
+static bfd_boolean elf_gc_smash_unused_vtentry_relocs
+  PARAMS ((struct elf_link_hash_entry *, PTR));
 
 /* The mark phase of garbage collection.  For a given section, mark
-   it, and all the sections which define symbols to which it refers.  */
-
-static boolean
+   it and any sections in this section's group, and all the sections
+   which define symbols to which it refers.  */
+
+typedef asection * (*gc_mark_hook_fn)
+  PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
+           struct elf_link_hash_entry *, Elf_Internal_Sym *));
+
+static bfd_boolean
 elf_gc_mark (info, sec, gc_mark_hook)
      struct bfd_link_info *info;
      asection *sec;
-     asection * (*gc_mark_hook)
-       PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Rela *,
-                struct elf_link_hash_entry *, Elf_Internal_Sym *));
+     gc_mark_hook_fn gc_mark_hook;
 {
-  boolean ret = true;
+  bfd_boolean ret;
+  asection *group_sec;
 
   sec->gc_mark = 1;
 
+  /* Mark all the sections in the group.  */
+  group_sec = elf_section_data (sec)->next_in_group;
+  if (group_sec && !group_sec->gc_mark)
+    if (!elf_gc_mark (info, group_sec, gc_mark_hook))
+      return FALSE;
+
   /* Look through the section relocs.  */
-
+  ret = TRUE;
   if ((sec->flags & SEC_RELOC) != 0 && sec->reloc_count > 0)
     {
@@ -6456 +7902 @@
       size_t nlocsyms;
       size_t extsymoff;
-      Elf_External_Sym *locsyms, *freesyms = NULL;
       bfd *input_bfd = sec->owner;
       struct elf_backend_data *bed = get_elf_backend_data (input_bfd);
-
-      /* GCFIXME: how to arrange so that relocs and symbols are not
-         reread continually?  */
+      Elf_Internal_Sym *isym = NULL;
 
       symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
@@ -6470 +7913 @@
         {
           nlocsyms = symtab_hdr->sh_size / sizeof (Elf_External_Sym);
-          extsymoff = 0;
+          extsymoff = 0;
         }
       else
         extsymoff = nlocsyms = symtab_hdr->sh_info;
-      if (symtab_hdr->contents)
-        locsyms = (Elf_External_Sym *) symtab_hdr->contents;
-      else if (nlocsyms == 0)
-        locsyms = NULL;
-      else
-        {
-          locsyms = freesyms =
-            bfd_malloc (nlocsyms * sizeof (Elf_External_Sym));
-          if (freesyms == NULL
-              || bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
-              || (bfd_read (locsyms, sizeof (Elf_External_Sym),
-                            nlocsyms, input_bfd)
-                  != nlocsyms * sizeof (Elf_External_Sym)))
-            {
-              ret = false;
-              goto out1;
-            }
+
+      isym = (Elf_Internal_Sym *) symtab_hdr->contents;
+      if (isym == NULL && nlocsyms != 0)
+        {
+          isym = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, nlocsyms, 0,
+                                       NULL, NULL, NULL);
+          if (isym == NULL)
+            return FALSE;
         }
 
       /* Read the relocations.  */
       relstart = (NAME(_bfd_elf,link_read_relocs)
-                  (sec->owner, sec, NULL, (Elf_Internal_Rela *) NULL,
+                  (input_bfd, sec, NULL, (Elf_Internal_Rela *) NULL,
                    info->keep_memory));
       if (relstart == NULL)
         {
-          ret = false;
+          ret = FALSE;
           goto out1;
         }
@@ -6509 +7943 @@
           asection *rsec;
           struct elf_link_hash_entry *h;
-          Elf_Internal_Sym s;
 
           r_symndx = ELF_R_SYM (rel->r_info);
@@ -6515 +7948 @@
             continue;
 
-          if (elf_bad_symtab (sec->owner))
-            {
-              elf_swap_symbol_in (input_bfd, &locsyms[r_symndx], &s);
-              if (ELF_ST_BIND (s.st_info) == STB_LOCAL)
-                rsec = (*gc_mark_hook) (sec->owner, info, rel, NULL, &s);
-              else
-                {
-                  h = sym_hashes[r_symndx - extsymoff];
-                  rsec = (*gc_mark_hook) (sec->owner, info, rel, h, NULL);
-                }
-            }
-          else if (r_symndx >= nlocsyms)
+          if (r_symndx >= nlocsyms
+              || ELF_ST_BIND (isym[r_symndx].st_info) != STB_LOCAL)
             {
               h = sym_hashes[r_symndx - extsymoff];
-              rsec = (*gc_mark_hook) (sec->owner, info, rel, h, NULL);
+              rsec = (*gc_mark_hook) (sec, info, rel, h, NULL);
             }
           else
             {
-              elf_swap_symbol_in (input_bfd, &locsyms[r_symndx], &s);
-              rsec = (*gc_mark_hook) (sec->owner, info, rel, NULL, &s);
+              rsec = (*gc_mark_hook) (sec, info, rel, NULL, &isym[r_symndx]);
             }
 
           if (rsec && !rsec->gc_mark)
-            if (!elf_gc_mark (info, rsec, gc_mark_hook))
-              {
-                ret = false;
-                goto out2;
-              }
+            {
+              if (bfd_get_flavour (rsec->owner) != bfd_target_elf_flavour)
+                rsec->gc_mark = 1;
+              else if (!elf_gc_mark (info, rsec, gc_mark_hook))
+                {
+                  ret = FALSE;
+                  goto out2;
+                }
+            }
         }
 
     out2:
-      if (!info->keep_memory)
+      if (elf_section_data (sec)->relocs != relstart)
         free (relstart);
     out1:
-      if (freesyms)
-        free (freesyms);
+      if (isym != NULL && symtab_hdr->contents != (unsigned char *) isym)
+        {
+          if (! info->keep_memory)
+            free (isym);
+          else
+            symtab_hdr->contents = (unsigned char *) isym;
+        }
     }
 
@@ -6558 +7989 @@
 /* The sweep phase of garbage collection.  Remove all garbage sections.  */
 
-static boolean
+typedef bfd_boolean (*gc_sweep_hook_fn)
+  PARAMS ((bfd *, struct bfd_link_info *, asection *,
+           const Elf_Internal_Rela *));
+
+static bfd_boolean
 elf_gc_sweep (info, gc_sweep_hook)
      struct bfd_link_info *info;
-     boolean (*gc_sweep_hook)
-       PARAMS ((bfd *abfd, struct bfd_link_info *info, asection *o,
-                const Elf_Internal_Rela *relocs));
+     gc_sweep_hook_fn gc_sweep_hook;
 {
   bfd *sub;
@@ -6598 +8031 @@
             {
               Elf_Internal_Rela *internal_relocs;
-              boolean r;
+              bfd_boolean r;
 
               internal_relocs = (NAME(_bfd_elf,link_read_relocs)
                                  (o->owner, o, NULL, NULL, info->keep_memory));
               if (internal_relocs == NULL)
-                return false;
+                return FALSE;
 
               r = (*gc_sweep_hook) (o->owner, info, o, internal_relocs);
 
-              if (!info->keep_memory)
+              if (elf_section_data (o)->relocs != internal_relocs)
                 free (internal_relocs);
 
               if (!r)
-                return false;
+                return FALSE;
             }
         }
@@ -6629 +8062 @@
   }
 
-  return true;
+  return TRUE;
 }
 
 /* Sweep symbols in swept sections.  Called via elf_link_hash_traverse.  */
 
-static boolean
+static bfd_boolean
 elf_gc_sweep_symbol (h, idxptr)
      struct elf_link_hash_entry *h;
@@ -6641 +8074 @@
   int *idx = (int *) idxptr;
 
+  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
@@ -6647 +8083 @@
     h->dynindx = (*idx)++;
 
-  return true;
+  return TRUE;
 }
 
@@ -6653 +8089 @@
    elf_link_hash_traverse.  */
 
-static boolean
+static bfd_boolean
 elf_gc_propagate_vtable_entries_used (h, okp)
      struct elf_link_hash_entry *h;
      PTR okp;
 {
+  if (h->root.type == bfd_link_hash_warning)
+    h = (struct elf_link_hash_entry *) h->root.u.i.link;
+
   /* Those that are not vtables.  */
   if (h->vtable_parent == NULL)
-    return true;
+    return TRUE;
 
   /* Those vtables that do not have parents, we cannot merge.  */
   if (h->vtable_parent == (struct elf_link_hash_entry *) -1)
-    return true;
+    return TRUE;
 
   /* If we've already been done, exit.  */
   if (h->vtable_entries_used && h->vtable_entries_used[-1])
-    return true;
+    return TRUE;
 
   /* Make sure the parent's table is up to date.  */
@@ -6683 +8122 @@
     {
       size_t n;
-      boolean *cu, *pu;
+      bfd_boolean *cu, *pu;
 
       /* Or the parent's entries into ours.  */
       cu = h->vtable_entries_used;
-      cu[-1] = true;
+      cu[-1] = TRUE;
       pu = h->vtable_parent->vtable_entries_used;
       if (pu != NULL)
         {
-          n = h->vtable_parent->vtable_entries_size / FILE_ALIGN;
-          while (--n != 0)
+          asection *sec = h->root.u.def.section;
+          struct elf_backend_data *bed = get_elf_backend_data (sec->owner);
+          int file_align = bed->s->file_align;
+
+          n = h->vtable_parent->vtable_entries_size / file_align;
+          while (n--)
             {
-              if (*pu) *cu = true;
-              pu++, cu++;
+              if (*pu)
+                *cu = TRUE;
+              pu++;
+              cu++;
             }
         }
     }
 
-  return true;
+  return TRUE;
 }
 
-static boolean
+static bfd_boolean
 elf_gc_smash_unused_vtentry_relocs (h, okp)
      struct elf_link_hash_entry *h;
@@ -6712 +8157 @@
   Elf_Internal_Rela *relstart, *relend, *rel;
   struct elf_backend_data *bed;
+  int file_align;
+
+  if (h->root.type == bfd_link_hash_warning)
+    h = (struct elf_link_hash_entry *) h->root.u.i.link;
 
   /* Take care of both those symbols that do not describe vtables as
      well as those that are not loaded.  */
   if (h->vtable_parent == NULL)
-    return true;
+    return TRUE;
 
   BFD_ASSERT (h->root.type == bfd_link_hash_defined
@@ -6726 +8175 @@
 
   relstart = (NAME(_bfd_elf,link_read_relocs)
-              (sec->owner, sec, NULL, (Elf_Internal_Rela *) NULL, true));
+              (sec->owner, sec, NULL, (Elf_Internal_Rela *) NULL, TRUE));
   if (!relstart)
-    return *(boolean *)okp = false;
+    return *(bfd_boolean *) okp = FALSE;
   bed = get_elf_backend_data (sec->owner);
+  file_align = bed->s->file_align;
+
   relend = relstart + sec->reloc_count * bed->s->int_rels_per_ext_rel;
 
@@ -6739 +8190 @@
             && (rel->r_offset - hstart) < h->vtable_entries_size)
           {
-            bfd_vma entry = (rel->r_offset - hstart) / FILE_ALIGN;
+            bfd_vma entry = (rel->r_offset - hstart) / file_align;
             if (h->vtable_entries_used[entry])
               continue;
@@ -6747 +8198 @@
       }
 
-  return true;
+  return TRUE;
 }
 
 /* Do mark and sweep of unused sections.  */
 
-boolean
+bfd_boolean
 elf_gc_sections (abfd, info)
      bfd *abfd;
      struct bfd_link_info *info;
 {
-  boolean ok = true;
+  bfd_boolean ok = TRUE;
   bfd *sub;
   asection * (*gc_mark_hook)
-    PARAMS ((bfd *abfd, struct bfd_link_info *, Elf_Internal_Rela *,
-             struct elf_link_hash_entry *h, Elf_Internal_Sym *));
+    PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
+             struct elf_link_hash_entry *h, Elf_Internal_Sym *));
 
   if (!get_elf_backend_data (abfd)->can_gc_sections
       || info->relocateable || info->emitrelocations
       || elf_hash_table (info)->dynamic_sections_created)
-    return true;
+    return TRUE;
 
   /* Apply transitive closure to the vtable entry usage info.  */
@@ -6773 +8224 @@
                           (PTR) &ok);
   if (!ok)
-    return false;
+    return FALSE;
 
   /* Kill the vtable relocations that were not used.  */
@@ -6780 +8231 @@
                           (PTR) &ok);
   if (!ok)
-    return false;
+    return FALSE;
 
   /* Grovel through relocs to find out who stays ...  */
@@ -6795 +8246 @@
         {
           if (o->flags & SEC_KEEP)
-            if (!elf_gc_mark (info, o, gc_mark_hook))
-              return false;
+            if (!elf_gc_mark (info, o, gc_mark_hook))
+              return FALSE;
         }
     }
 
   /* ... 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;
+  if (!elf_gc_sweep (info, get_elf_backend_data (abfd)->gc_sweep_hook))
+    return FALSE;
+
+  return TRUE;
 }
 
@@ -6810 +8261 @@
 /* Called from check_relocs to record the existance of a VTINHERIT reloc.  */
 
-boolean
+bfd_boolean
 elf_gc_record_vtinherit (abfd, sec, h, offset)
      bfd *abfd;
@@ -6844 +8295 @@
 
   (*_bfd_error_handler) ("%s: %s+%lu: No symbol found for INHERIT",
-                         bfd_get_filename (abfd), sec->name,
-                         (unsigned long)offset);
+                         bfd_archive_filename (abfd), sec->name,
+                         (unsigned long) offset);
   bfd_set_error (bfd_error_invalid_operation);
-  return false;
-
-win:
+  return FALSE;
+
+ win:
   if (!h)
     {
@@ -6862 +8313 @@
     child->vtable_parent = h;
 
-  return true;
+  return TRUE;
 }
 
 /* Called from check_relocs to record the existance of a VTENTRY reloc.  */
 
-boolean
+bfd_boolean
 elf_gc_record_vtentry (abfd, sec, h, addend)
      bfd *abfd ATTRIBUTE_UNUSED;
@@ -6874 +8325 @@
      bfd_vma addend;
 {
+  struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  int file_align = bed->s->file_align;
+
   if (addend >= h->vtable_entries_size)
     {
       size_t size, bytes;
-      boolean *ptr = h->vtable_entries_used;
+      bfd_boolean *ptr = h->vtable_entries_used;
 
       /* While the symbol is undefined, we have to be prepared to handle
@@ -6896 +8350 @@
       /* Allocate one extra entry for use as a "done" flag for the
          consolidation pass.  */
-      bytes = (size / FILE_ALIGN + 1) * sizeof (boolean);
+      bytes = (size / file_align + 1) * sizeof (bfd_boolean);
 
       if (ptr)
         {
-          ptr = bfd_realloc (ptr - 1, bytes);
+          ptr = bfd_realloc (ptr - 1, (bfd_size_type) bytes);
 
           if (ptr != NULL)
@@ -6906 +8360 @@
               size_t oldbytes;
 
-              oldbytes = (h->vtable_entries_size/FILE_ALIGN + 1) * sizeof (boolean);
-              memset (((char *)ptr) + oldbytes, 0, bytes - oldbytes);
+              oldbytes = ((h->vtable_entries_size / file_align + 1)
+                          * sizeof (bfd_boolean));
+              memset (((char *) ptr) + oldbytes, 0, bytes - oldbytes);
             }
         }
       else
-        ptr = bfd_zmalloc (bytes);
+        ptr = bfd_zmalloc ((bfd_size_type) bytes);
 
       if (ptr == NULL)
-        return false;
+        return FALSE;
 
       /* And arrange for that done flag to be at index -1.  */
@@ -6921 +8376 @@
     }
 
-  h->vtable_entries_used[addend / FILE_ALIGN] = true;
-
-  return true;
+  h->vtable_entries_used[addend / file_align] = TRUE;
+
+  return TRUE;
 }
 
@@ -6929 +8384 @@
    we're done.  Should be called from final_link.  */
 
-boolean
+bfd_boolean
 elf_gc_common_finalize_got_offsets (abfd, info)
      bfd *abfd;
@@ -6982 +8437 @@
                           elf_gc_allocate_got_offsets,
                           (PTR) &gotoff);
-  return true;
+  return TRUE;
 }
 
@@ -6988 +8443 @@
    to real got offsets.  */
 
-static boolean
+static bfd_boolean
 elf_gc_allocate_got_offsets (h, offarg)
      struct elf_link_hash_entry *h;
@@ -6995 +8450 @@
   bfd_vma *off = (bfd_vma *) offarg;
 
+  if (h->root.type == bfd_link_hash_warning)
+    h = (struct elf_link_hash_entry *) h->root.u.i.link;
+
   if (h->got.refcount > 0)
     {
@@ -7003 +8461 @@
     h->got.offset = (bfd_vma) -1;
 
-  return true;
+  return TRUE;
 }
 
@@ -7009 +8467 @@
    got entry reference counting is enabled.  */
 
-boolean
+bfd_boolean
 elf_gc_common_final_link (abfd, info)
      bfd *abfd;
@@ -7015 +8473 @@
 {
   if (!elf_gc_common_finalize_got_offsets (abfd, info))
-    return false;
+    return FALSE;
 
   /* Invoke the regular ELF backend linker to do all the work.  */
@@ -7024 +8482 @@
    all hash value of the exported symbols in an array.  */
 
-static boolean
+static bfd_boolean
 elf_collect_hash_codes (h, data)
      struct elf_link_hash_entry *h;
@@ -7035 +8493 @@
   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;
+    return TRUE;
 
   name = h->root.root.string;
@@ -7043 +8504 @@
   if (p != NULL)
     {
-      alc = bfd_malloc (p - name + 1);
-      memcpy (alc, name, p - name);
+      alc = bfd_malloc ((bfd_size_type) (p - name + 1));
+      memcpy (alc, name, (size_t) (p - name));
       alc[p - name] = '\0';
       name = alc;
@@ -7062 +8523 @@
     free (alc);
 
-  return true;
+  return TRUE;
 }
+
+bfd_boolean
+elf_reloc_symbol_deleted_p (offset, cookie)
+     bfd_vma offset;
+     PTR cookie;
+{
+  struct elf_reloc_cookie *rcookie = (struct elf_reloc_cookie *) cookie;
+
+  if (rcookie->bad_symtab)
+    rcookie->rel = rcookie->rels;
+
+  for (; rcookie->rel < rcookie->relend; rcookie->rel++)
+    {
+      unsigned long r_symndx;
+
+      if (! rcookie->bad_symtab)
+        if (rcookie->rel->r_offset > offset)
+          return FALSE;
+      if (rcookie->rel->r_offset != offset)
+        continue;
+
+      r_symndx = ELF_R_SYM (rcookie->rel->r_info);
+      if (r_symndx == SHN_UNDEF)
+        return TRUE;
+
+      if (r_symndx >= rcookie->locsymcount
+          || ELF_ST_BIND (rcookie->locsyms[r_symndx].st_info) != STB_LOCAL)
+        {
+          struct elf_link_hash_entry *h;
+
+          h = rcookie->sym_hashes[r_symndx - rcookie->extsymoff];
+
+          while (h->root.type == bfd_link_hash_indirect
+                 || h->root.type == bfd_link_hash_warning)
+            h = (struct elf_link_hash_entry *) h->root.u.i.link;
+
+          if ((h->root.type == bfd_link_hash_defined
+               || h->root.type == bfd_link_hash_defweak)
+              && elf_discarded_section (h->root.u.def.section))
+            return TRUE;
+          else
+            return FALSE;
+        }
+      else
+        {
+          /* It's not a relocation against a global symbol,
+             but it could be a relocation against a local
+             symbol for a discarded section.  */
+          asection *isec;
+          Elf_Internal_Sym *isym;
+
+          /* Need to: get the symbol; get the section.  */
+          isym = &rcookie->locsyms[r_symndx];
+          if (isym->st_shndx < SHN_LORESERVE || isym->st_shndx > SHN_HIRESERVE)
+            {
+              isec = section_from_elf_index (rcookie->abfd, isym->st_shndx);
+              if (isec != NULL && elf_discarded_section (isec))
+                return TRUE;
+            }
+        }
+      return FALSE;
+    }
+  return FALSE;
+}
+
+/* Discard unneeded references to discarded sections.
+   Returns TRUE if any section's size was changed.  */
+/* This function assumes that the relocations are in sorted order,
+   which is true for all known assemblers.  */
+
+bfd_boolean
+elf_bfd_discard_info (output_bfd, info)
+     bfd *output_bfd;
+     struct bfd_link_info *info;
+{
+  struct elf_reloc_cookie cookie;
+  asection *stab, *eh;
+  Elf_Internal_Shdr *symtab_hdr;
+  struct elf_backend_data *bed;
+  bfd *abfd;
+  unsigned int count;
+  bfd_boolean ret = FALSE;
+
+  if (info->traditional_format
+      || info->hash->creator->flavour != bfd_target_elf_flavour
+      || ! is_elf_hash_table (info))
+    return FALSE;
+
+  for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
+    {
+      if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
+        continue;
+
+      bed = get_elf_backend_data (abfd);
+
+      if ((abfd->flags & DYNAMIC) != 0)
+        continue;
+
+      eh = bfd_get_section_by_name (abfd, ".eh_frame");
+      if (info->relocateable
+          || (eh != NULL
+              && (eh->_raw_size == 0
+                  || bfd_is_abs_section (eh->output_section))))
+        eh = NULL;
+
+      stab = bfd_get_section_by_name (abfd, ".stab");
+      if (stab != NULL
+          && (stab->_raw_size == 0
+              || bfd_is_abs_section (stab->output_section)
+              || stab->sec_info_type != ELF_INFO_TYPE_STABS))
+        stab = NULL;
+
+      if (stab == NULL
+          && eh == NULL
+          && bed->elf_backend_discard_info == NULL)
+        continue;
+
+      symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+      cookie.abfd = abfd;
+      cookie.sym_hashes = elf_sym_hashes (abfd);
+      cookie.bad_symtab = elf_bad_symtab (abfd);
+      if (cookie.bad_symtab)
+        {
+          cookie.locsymcount = symtab_hdr->sh_size / sizeof (Elf_External_Sym);
+          cookie.extsymoff = 0;
+        }
+      else
+        {
+          cookie.locsymcount = symtab_hdr->sh_info;
+          cookie.extsymoff = symtab_hdr->sh_info;
+        }
+
+      cookie.locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
+      if (cookie.locsyms == NULL && cookie.locsymcount != 0)
+        {
+          cookie.locsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr,
+                                                 cookie.locsymcount, 0,
+                                                 NULL, NULL, NULL);
+          if (cookie.locsyms == NULL)
+            return FALSE;
+        }
+
+      if (stab != NULL)
+        {
+          cookie.rels = NULL;
+          count = stab->reloc_count;
+          if (count != 0)
+            cookie.rels = (NAME(_bfd_elf,link_read_relocs)
+                           (abfd, stab, (PTR) NULL, (Elf_Internal_Rela *) NULL,
+                            info->keep_memory));
+          if (cookie.rels != NULL)
+            {
+              cookie.rel = cookie.rels;
+              cookie.relend = cookie.rels;
+              cookie.relend += count * bed->s->int_rels_per_ext_rel;
+              if (_bfd_discard_section_stabs (abfd, stab,
+                                              elf_section_data (stab)->sec_info,
+                                              elf_reloc_symbol_deleted_p,
+                                              &cookie))
+                ret = TRUE;
+              if (elf_section_data (stab)->relocs != cookie.rels)
+                free (cookie.rels);
+            }
+        }
+
+      if (eh != NULL)
+        {
+          cookie.rels = NULL;
+          count = eh->reloc_count;
+          if (count != 0)
+            cookie.rels = (NAME(_bfd_elf,link_read_relocs)
+                           (abfd, eh, (PTR) NULL, (Elf_Internal_Rela *) NULL,
+                            info->keep_memory));
+          cookie.rel = cookie.rels;
+          cookie.relend = cookie.rels;
+          if (cookie.rels != NULL)
+            cookie.relend += count * bed->s->int_rels_per_ext_rel;
+
+          if (_bfd_elf_discard_section_eh_frame (abfd, info, eh,
+                                                 elf_reloc_symbol_deleted_p,
+                                                 &cookie))
+            ret = TRUE;
+
+          if (cookie.rels != NULL
+              && elf_section_data (eh)->relocs != cookie.rels)
+            free (cookie.rels);
+        }
+
+      if (bed->elf_backend_discard_info != NULL
+          && (*bed->elf_backend_discard_info) (abfd, &cookie, info))
+        ret = TRUE;
+
+      if (cookie.locsyms != NULL
+          && symtab_hdr->contents != (unsigned char *) cookie.locsyms)
+        {
+          if (! info->keep_memory)
+            free (cookie.locsyms);
+          else
+            symtab_hdr->contents = (unsigned char *) cookie.locsyms;
+        }
+    }
+
+  if (info->eh_frame_hdr
+      && !info->relocateable
+      && _bfd_elf_discard_section_eh_frame_hdr (output_bfd, info))
+    ret = TRUE;
+
+  return ret;
+}
+
+static bfd_boolean
+elf_section_ignore_discarded_relocs (sec)
+     asection *sec;
+{
+  struct elf_backend_data *bed;
+
+  switch (sec->sec_info_type)
+    {
+    case ELF_INFO_TYPE_STABS:
+    case ELF_INFO_TYPE_EH_FRAME:
+      return TRUE;
+    default:
+      break;
+    }
+
+  bed = get_elf_backend_data (sec->owner);
+  if (bed->elf_backend_ignore_discarded_relocs != NULL
+      && (*bed->elf_backend_ignore_discarded_relocs) (sec))
+    return TRUE;
+
+  return FALSE;
+}