Changeset 609 for branches/GNU/src/binutils/bfd/elf64-x86-64.c

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/elf64-x86-64.c (modified) (65 diffs, 1 prop)

branches/GNU/src/binutils/bfd/elf64-x86-64.c

@@ -1 +1 @@
 /* X86-64 specific support for 64-bit ELF
-   Copyright 2000, 2001 Free Software Foundation, Inc.
+   Copyright 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
    Contributed by Jan Hubicka <jh@suse.cz>.
 
-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.  */
 
 #include "bfd.h"
 #include "sysdep.h"
+#include "bfdlink.h"
 #include "libbfd.h"
 #include "elf-bfd.h"
 
 #include "elf/x86-64.h"
-
-/* We use only the RELA entries.  */
-#define USE_RELA
 
 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value.  */
@@ -37 +35 @@
 static reloc_howto_type x86_64_elf_howto_table[] =
 {
-  HOWTO(R_X86_64_NONE, 0, 0, 0, false, 0, complain_overflow_dont,
-        bfd_elf_generic_reloc, "R_X86_64_NONE", false, 0x00000000, 0x00000000,
-        false),
-  HOWTO(R_X86_64_64, 0, 4, 64, false, 0, complain_overflow_bitfield,
-        bfd_elf_generic_reloc, "R_X86_64_64", false, MINUS_ONE, MINUS_ONE,
-        false),
-  HOWTO(R_X86_64_PC32, 0, 4, 32, true, 0, complain_overflow_signed,
-        bfd_elf_generic_reloc, "R_X86_64_PC32", false, 0xffffffff, 0xffffffff,
-        true),
-  HOWTO(R_X86_64_GOT32, 0, 4, 32, false, 0, complain_overflow_signed,
-        bfd_elf_generic_reloc, "R_X86_64_GOT32", false, 0xffffffff, 0xffffffff,
-        false),
-  HOWTO(R_X86_64_PLT32, 0, 4, 32, true, 0, complain_overflow_signed,
-        bfd_elf_generic_reloc, "R_X86_64_PLT32", false, 0xffffffff, 0xffffffff,
-        true),
-  HOWTO(R_X86_64_COPY, 0, 4, 32, false, 0, complain_overflow_bitfield,
-        bfd_elf_generic_reloc, "R_X86_64_COPY", false, 0xffffffff, 0xffffffff,
-        false),
-  HOWTO(R_X86_64_GLOB_DAT, 0, 4, 64, false, 0, complain_overflow_bitfield,
-        bfd_elf_generic_reloc, "R_X86_64_GLOB_DAT", false, MINUS_ONE,
-        MINUS_ONE, false),
-  HOWTO(R_X86_64_JUMP_SLOT, 0, 4, 64, false, 0, complain_overflow_bitfield,
-        bfd_elf_generic_reloc, "R_X86_64_JUMP_SLOT", false, MINUS_ONE,
-        MINUS_ONE, false),
-  HOWTO(R_X86_64_RELATIVE, 0, 4, 64, false, 0, complain_overflow_bitfield,
-        bfd_elf_generic_reloc, "R_X86_64_RELATIVE", false, MINUS_ONE,
-        MINUS_ONE, false),
-  HOWTO(R_X86_64_GOTPCREL, 0, 4, 32, true,0 , complain_overflow_signed,
-        bfd_elf_generic_reloc, "R_X86_64_GOTPCREL", false, 0xffffffff,
-        0xffffffff, true),
-  HOWTO(R_X86_64_32, 0, 4, 32, false, 0, complain_overflow_unsigned,
-        bfd_elf_generic_reloc, "R_X86_64_32", false, 0xffffffff, 0xffffffff,
-        false),
-  HOWTO(R_X86_64_32S, 0, 4, 32, false, 0, complain_overflow_signed,
-        bfd_elf_generic_reloc, "R_X86_64_32S", false, 0xffffffff, 0xffffffff,
-        false),
-  HOWTO(R_X86_64_16, 0, 1, 16, false, 0, complain_overflow_bitfield,
-        bfd_elf_generic_reloc, "R_X86_64_16", false, 0xffff, 0xffff, false),
-  HOWTO(R_X86_64_PC16,0, 1, 16, true, 0, complain_overflow_bitfield,
-        bfd_elf_generic_reloc, "R_X86_64_PC16", false, 0xffff, 0xffff, true),
-  HOWTO(R_X86_64_8, 0, 0, 8, false, 0, complain_overflow_signed,
-        bfd_elf_generic_reloc, "R_X86_64_8", false, 0xff, 0xff, false),
-  HOWTO(R_X86_64_PC8, 0, 0, 8, true, 0, complain_overflow_signed,
-        bfd_elf_generic_reloc, "R_X86_64_PC8", false, 0xff, 0xff, true)
+  HOWTO(R_X86_64_NONE, 0, 0, 0, FALSE, 0, complain_overflow_dont,
+        bfd_elf_generic_reloc, "R_X86_64_NONE", FALSE, 0x00000000, 0x00000000,
+        FALSE),
+  HOWTO(R_X86_64_64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
+        bfd_elf_generic_reloc, "R_X86_64_64", FALSE, MINUS_ONE, MINUS_ONE,
+        FALSE),
+  HOWTO(R_X86_64_PC32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
+        bfd_elf_generic_reloc, "R_X86_64_PC32", FALSE, 0xffffffff, 0xffffffff,
+        TRUE),
+  HOWTO(R_X86_64_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
+        bfd_elf_generic_reloc, "R_X86_64_GOT32", FALSE, 0xffffffff, 0xffffffff,
+        FALSE),
+  HOWTO(R_X86_64_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
+        bfd_elf_generic_reloc, "R_X86_64_PLT32", FALSE, 0xffffffff, 0xffffffff,
+        TRUE),
+  HOWTO(R_X86_64_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
+        bfd_elf_generic_reloc, "R_X86_64_COPY", FALSE, 0xffffffff, 0xffffffff,
+        FALSE),
+  HOWTO(R_X86_64_GLOB_DAT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
+        bfd_elf_generic_reloc, "R_X86_64_GLOB_DAT", FALSE, MINUS_ONE,
+        MINUS_ONE, FALSE),
+  HOWTO(R_X86_64_JUMP_SLOT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
+        bfd_elf_generic_reloc, "R_X86_64_JUMP_SLOT", FALSE, MINUS_ONE,
+        MINUS_ONE, FALSE),
+  HOWTO(R_X86_64_RELATIVE, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
+        bfd_elf_generic_reloc, "R_X86_64_RELATIVE", FALSE, MINUS_ONE,
+        MINUS_ONE, FALSE),
+  HOWTO(R_X86_64_GOTPCREL, 0, 2, 32, TRUE, 0, complain_overflow_signed,
+        bfd_elf_generic_reloc, "R_X86_64_GOTPCREL", FALSE, 0xffffffff,
+        0xffffffff, TRUE),
+  HOWTO(R_X86_64_32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned,
+        bfd_elf_generic_reloc, "R_X86_64_32", FALSE, 0xffffffff, 0xffffffff,
+        FALSE),
+  HOWTO(R_X86_64_32S, 0, 2, 32, FALSE, 0, complain_overflow_signed,
+        bfd_elf_generic_reloc, "R_X86_64_32S", FALSE, 0xffffffff, 0xffffffff,
+        FALSE),
+  HOWTO(R_X86_64_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
+        bfd_elf_generic_reloc, "R_X86_64_16", FALSE, 0xffff, 0xffff, FALSE),
+  HOWTO(R_X86_64_PC16,0, 1, 16, TRUE, 0, complain_overflow_bitfield,
+        bfd_elf_generic_reloc, "R_X86_64_PC16", FALSE, 0xffff, 0xffff, TRUE),
+  HOWTO(R_X86_64_8, 0, 0, 8, FALSE, 0, complain_overflow_signed,
+        bfd_elf_generic_reloc, "R_X86_64_8", FALSE, 0xff, 0xff, FALSE),
+  HOWTO(R_X86_64_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
+        bfd_elf_generic_reloc, "R_X86_64_PC8", FALSE, 0xff, 0xff, TRUE),
+  HOWTO(R_X86_64_DTPMOD64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
+        bfd_elf_generic_reloc, "R_X86_64_DTPMOD64", FALSE, MINUS_ONE,
+        MINUS_ONE, FALSE),
+  HOWTO(R_X86_64_DTPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
+        bfd_elf_generic_reloc, "R_X86_64_DTPOFF64", FALSE, MINUS_ONE,
+        MINUS_ONE, FALSE),
+  HOWTO(R_X86_64_TPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
+        bfd_elf_generic_reloc, "R_X86_64_TPOFF64", FALSE, MINUS_ONE,
+        MINUS_ONE, FALSE),
+  HOWTO(R_X86_64_TLSGD, 0, 2, 32, TRUE, 0, complain_overflow_signed,
+        bfd_elf_generic_reloc, "R_X86_64_TLSGD", FALSE, 0xffffffff,
+        0xffffffff, TRUE),
+  HOWTO(R_X86_64_TLSLD, 0, 2, 32, TRUE, 0, complain_overflow_signed,
+        bfd_elf_generic_reloc, "R_X86_64_TLSLD", FALSE, 0xffffffff,
+        0xffffffff, TRUE),
+  HOWTO(R_X86_64_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
+        bfd_elf_generic_reloc, "R_X86_64_DTPOFF32", FALSE, 0xffffffff,
+        0xffffffff, FALSE),
+  HOWTO(R_X86_64_GOTTPOFF, 0, 2, 32, TRUE, 0, complain_overflow_signed,
+        bfd_elf_generic_reloc, "R_X86_64_GOTTPOFF", FALSE, 0xffffffff,
+        0xffffffff, TRUE),
+  HOWTO(R_X86_64_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
+        bfd_elf_generic_reloc, "R_X86_64_TPOFF32", FALSE, 0xffffffff,
+        0xffffffff, FALSE),
+
+/* GNU extension to record C++ vtable hierarchy.  */
+  HOWTO (R_X86_64_GNU_VTINHERIT, 0, 4, 0, FALSE, 0, complain_overflow_dont,
+         NULL, "R_X86_64_GNU_VTINHERIT", FALSE, 0, 0, FALSE),
+
+/* GNU extension to record C++ vtable member usage.  */
+  HOWTO (R_X86_64_GNU_VTENTRY, 0, 4, 0, FALSE, 0, complain_overflow_dont,
+         _bfd_elf_rel_vtable_reloc_fn, "R_X86_64_GNU_VTENTRY", FALSE, 0, 0,
+         FALSE)
 };
 
@@ -90 +121 @@
 };
 
-static CONST struct elf_reloc_map x86_64_reloc_map[] =
+static const struct elf_reloc_map x86_64_reloc_map[] =
 {
   { BFD_RELOC_NONE,             R_X86_64_NONE, },
@@ -108 +139 @@
   { BFD_RELOC_8,                R_X86_64_8, },
   { BFD_RELOC_8_PCREL,          R_X86_64_PC8, },
+  { BFD_RELOC_X86_64_DTPMOD64,  R_X86_64_DTPMOD64, },
+  { BFD_RELOC_X86_64_DTPOFF64,  R_X86_64_DTPOFF64, },
+  { BFD_RELOC_X86_64_TPOFF64,   R_X86_64_TPOFF64, },
+  { BFD_RELOC_X86_64_TLSGD,     R_X86_64_TLSGD, },
+  { BFD_RELOC_X86_64_TLSLD,     R_X86_64_TLSLD, },
+  { BFD_RELOC_X86_64_DTPOFF32,  R_X86_64_DTPOFF32, },
+  { BFD_RELOC_X86_64_GOTTPOFF,  R_X86_64_GOTTPOFF, },
+  { BFD_RELOC_X86_64_TPOFF32,   R_X86_64_TPOFF32, },
+  { BFD_RELOC_VTABLE_INHERIT,   R_X86_64_GNU_VTINHERIT, },
+  { BFD_RELOC_VTABLE_ENTRY,     R_X86_64_GNU_VTENTRY, },
 };
 
@@ -113 +154 @@
   PARAMS ((bfd *, bfd_reloc_code_real_type));
 static void elf64_x86_64_info_to_howto
-  PARAMS ((bfd *, arelent *, Elf64_Internal_Rela *));
+  PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
+static bfd_boolean elf64_x86_64_grok_prstatus
+  PARAMS ((bfd *, Elf_Internal_Note *));
+static bfd_boolean elf64_x86_64_grok_psinfo
+  PARAMS ((bfd *, Elf_Internal_Note *));
 static struct bfd_link_hash_table *elf64_x86_64_link_hash_table_create
   PARAMS ((bfd *));
-
-static struct bfd_hash_entry *elf64_x86_64_link_hash_newfunc
+static int elf64_x86_64_tls_transition
+  PARAMS ((struct bfd_link_info *, int, int));
+static bfd_boolean elf64_x86_64_mkobject
+  PARAMS((bfd *));
+static bfd_boolean elf64_x86_64_elf_object_p PARAMS ((bfd *abfd));
+static bfd_boolean create_got_section
+  PARAMS((bfd *, struct bfd_link_info *));
+static bfd_boolean elf64_x86_64_create_dynamic_sections
+  PARAMS((bfd *, struct bfd_link_info *));
+static void elf64_x86_64_copy_indirect_symbol
+  PARAMS ((struct elf_backend_data *, struct elf_link_hash_entry *,
+           struct elf_link_hash_entry *));
+static bfd_boolean elf64_x86_64_check_relocs
+  PARAMS ((bfd *, struct bfd_link_info *, asection *sec,
+           const Elf_Internal_Rela *));
+static asection *elf64_x86_64_gc_mark_hook
+  PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
+           struct elf_link_hash_entry *, Elf_Internal_Sym *));
+
+static bfd_boolean elf64_x86_64_gc_sweep_hook
+  PARAMS ((bfd *, struct bfd_link_info *, asection *,
+           const Elf_Internal_Rela *));
+
+static struct bfd_hash_entry *link_hash_newfunc
   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
-static boolean elf64_x86_64_adjust_dynamic_symbol
+static bfd_boolean elf64_x86_64_adjust_dynamic_symbol
   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
 
-static boolean elf64_x86_64_size_dynamic_sections
+static bfd_boolean allocate_dynrelocs
+  PARAMS ((struct elf_link_hash_entry *, PTR));
+static bfd_boolean readonly_dynrelocs
+  PARAMS ((struct elf_link_hash_entry *, PTR));
+static bfd_boolean elf64_x86_64_size_dynamic_sections
   PARAMS ((bfd *, struct bfd_link_info *));
-static boolean elf64_x86_64_relocate_section
+static bfd_vma dtpoff_base
+  PARAMS ((struct bfd_link_info *));
+static bfd_vma tpoff
+  PARAMS ((struct bfd_link_info *, bfd_vma));
+static bfd_boolean elf64_x86_64_relocate_section
   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
          Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
-static boolean elf64_x86_64_finish_dynamic_symbol
+static bfd_boolean elf64_x86_64_finish_dynamic_symbol
   PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
            Elf_Internal_Sym *sym));
-static boolean elf64_x86_64_finish_dynamic_sections
+static bfd_boolean elf64_x86_64_finish_dynamic_sections
   PARAMS ((bfd *, struct bfd_link_info *));
+static enum elf_reloc_type_class elf64_x86_64_reloc_type_class
+  PARAMS ((const Elf_Internal_Rela *));
 
 /* Given a BFD reloc type, return a HOWTO structure.  */
@@ -144 +221 @@
     {
       if (x86_64_reloc_map[i].bfd_reloc_val == code)
-        return &x86_64_elf_howto_table[(int)
-                                       x86_64_reloc_map[i].elf_reloc_val];
+        return &x86_64_elf_howto_table[i];
     }
   return 0;
@@ -156 +232 @@
      bfd *abfd ATTRIBUTE_UNUSED;
      arelent *cache_ptr;
-     Elf64_Internal_Rela *dst;
-{
-  unsigned r_type;
+     Elf_Internal_Rela *dst;
+{
+  unsigned r_type, i;
 
   r_type = ELF64_R_TYPE (dst->r_info);
-  BFD_ASSERT (r_type < (unsigned int) R_X86_64_max);
-  cache_ptr->howto = &x86_64_elf_howto_table[r_type];
+  if (r_type < (unsigned int) R_X86_64_GNU_VTINHERIT)
+    {
+      BFD_ASSERT (r_type <= (unsigned int) R_X86_64_TPOFF32);
+      i = r_type;
+    }
+  else
+    {
+      BFD_ASSERT (r_type < (unsigned int) R_X86_64_max);
+      i = r_type - ((unsigned int) R_X86_64_GNU_VTINHERIT - R_X86_64_TPOFF32 - 1);
+    }
+  cache_ptr->howto = &x86_64_elf_howto_table[i];
   BFD_ASSERT (r_type == cache_ptr->howto->type);
 }
 
 
+/* Support for core dump NOTE sections.  */
+static bfd_boolean
+elf64_x86_64_grok_prstatus (abfd, note)
+     bfd *abfd;
+     Elf_Internal_Note *note;
+{
+  int offset;
+  size_t raw_size;
+
+  switch (note->descsz)
+    {
+      default:
+        return FALSE;
+
+      case 336:         /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
+        /* pr_cursig */
+        elf_tdata (abfd)->core_signal
+          = bfd_get_16 (abfd, note->descdata + 12);
+
+        /* pr_pid */
+        elf_tdata (abfd)->core_pid
+          = bfd_get_32 (abfd, note->descdata + 32);
+
+        /* pr_reg */
+        offset = 112;
+        raw_size = 216;
+
+        break;
+    }
+
+  /* Make a ".reg/999" section.  */
+  return _bfd_elfcore_make_pseudosection (abfd, ".reg",
+                                          raw_size, note->descpos + offset);
+}
+
+static bfd_boolean
+elf64_x86_64_grok_psinfo (abfd, note)
+     bfd *abfd;
+     Elf_Internal_Note *note;
+{
+  switch (note->descsz)
+    {
+      default:
+        return FALSE;
+
+      case 136:         /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
+        elf_tdata (abfd)->core_program
+         = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
+        elf_tdata (abfd)->core_command
+         = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
+    }
+
+  /* Note that for some reason, a spurious space is tacked
+     onto the end of the args in some (at least one anyway)
+     implementations, so strip it off if it exists.  */
+
+  {
+    char *command = elf_tdata (abfd)->core_command;
+    int n = strlen (command);
+
+    if (0 < n && command[n - 1] == ' ')
+      command[n - 1] = '\0';
+  }
+
+  return TRUE;
+}
+
+
 /* Functions for the x86-64 ELF linker.  */
 
@@ -173 +326 @@
 
 #define ELF_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
+
+/* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
+   copying dynamic variables from a shared lib into an app's dynbss
+   section, and instead use a dynamic relocation to point into the
+   shared lib.  */
+#define ELIMINATE_COPY_RELOCS 1
 
 /* The size in bytes of an entry in the global offset table.  */
@@ -205 +364 @@
 
 /* The x86-64 linker needs to keep track of the number of relocs that
-   it decides to copy in check_relocs for each symbol.  This is so
-   that it can discard PC relative relocs if it doesn't need them when
-   linking with -Bsymbolic.  We store the information in a field
-   extending the regular ELF linker hash table.  */
-
-/* This structure keeps track of the number of PC relative relocs we
-   have copied for a given symbol.  */
-
-struct elf64_x86_64_pcrel_relocs_copied
+   it decides to copy as dynamic relocs in check_relocs for each symbol.
+   This is so that it can later discard them if they are found to be
+   unnecessary.  We store the information in a field extending the
+   regular ELF linker hash table.  */
+
+struct elf64_x86_64_dyn_relocs
 {
   /* Next section.  */
-  struct elf64_x86_64_pcrel_relocs_copied *next;
-  /* A section in dynobj.  */
-  asection *section;
-  /* Number of relocs copied in this section.  */
+  struct elf64_x86_64_dyn_relocs *next;
+
+  /* The input section of the reloc.  */
+  asection *sec;
+
+  /* Total number of relocs copied for the input section.  */
   bfd_size_type count;
+
+  /* Number of pc-relative relocs copied for the input section.  */
+  bfd_size_type pc_count;
 };
 
@@ -227 +388 @@
 struct elf64_x86_64_link_hash_entry
 {
-  struct elf_link_hash_entry root;
-
-  /* Number of PC relative relocs copied for this symbol.  */
-  struct elf64_x86_64_pcrel_relocs_copied *pcrel_relocs_copied;
+  struct elf_link_hash_entry elf;
+
+  /* Track dynamic relocs copied for this symbol.  */
+  struct elf64_x86_64_dyn_relocs *dyn_relocs;
+
+#define GOT_UNKNOWN     0
+#define GOT_NORMAL      1
+#define GOT_TLS_GD      2
+#define GOT_TLS_IE      3
+  unsigned char tls_type;
 };
 
-/* x86-64  ELF linker hash table.  */
+#define elf64_x86_64_hash_entry(ent) \
+  ((struct elf64_x86_64_link_hash_entry *)(ent))
+
+struct elf64_x86_64_obj_tdata
+{
+  struct elf_obj_tdata root;
+
+  /* tls_type for each local got entry.  */
+  char *local_got_tls_type;
+};
+
+#define elf64_x86_64_tdata(abfd) \
+  ((struct elf64_x86_64_obj_tdata *) (abfd)->tdata.any)
+
+#define elf64_x86_64_local_got_tls_type(abfd) \
+  (elf64_x86_64_tdata (abfd)->local_got_tls_type)
+
+
+/* x86-64 ELF linker hash table.  */
 
 struct elf64_x86_64_link_hash_table
 {
-  struct elf_link_hash_table root;
+  struct elf_link_hash_table elf;
+
+  /* Short-cuts to get to dynamic linker sections.  */
+  asection *sgot;
+  asection *sgotplt;
+  asection *srelgot;
+  asection *splt;
+  asection *srelplt;
+  asection *sdynbss;
+  asection *srelbss;
+
+  union {
+    bfd_signed_vma refcount;
+    bfd_vma offset;
+  } tls_ld_got;
+
+  /* Small local sym to section mapping cache.  */
+  struct sym_sec_cache sym_sec;
 };
-
-/* Declare this now that the above structures are defined.  */
-
-static boolean elf64_x86_64_discard_copies
-  PARAMS ((struct elf64_x86_64_link_hash_entry *, PTR));
-
-/* Traverse an x86-64 ELF linker hash table.  */
-
-#define elf64_x86_64_link_hash_traverse(table, func, info)              \
-  (elf_link_hash_traverse                                               \
-   (&(table)->root,                                                     \
-    (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func),  \
-    (info)))
 
 /* Get the x86-64 ELF linker hash table from a link_info structure.  */
@@ -261 +450 @@
 
 static struct bfd_hash_entry *
-elf64_x86_64_link_hash_newfunc (entry, table, string)
+link_hash_newfunc (entry, table, string)
      struct bfd_hash_entry *entry;
      struct bfd_hash_table *table;
      const char *string;
 {
-  struct elf64_x86_64_link_hash_entry *ret =
-    (struct elf64_x86_64_link_hash_entry *) entry;
-
   /* Allocate the structure if it has not already been allocated by a
-     subclass.  */
-  if (ret == (struct elf64_x86_64_link_hash_entry *) NULL)
-    ret = ((struct elf64_x86_64_link_hash_entry *)
-           bfd_hash_allocate (table,
-                              sizeof (struct elf64_x86_64_link_hash_entry)));
-  if (ret == (struct elf64_x86_64_link_hash_entry *) NULL)
-    return (struct bfd_hash_entry *) ret;
+     subclass.  */
+  if (entry == NULL)
+    {
+      entry = bfd_hash_allocate (table,
+                                 sizeof (struct elf64_x86_64_link_hash_entry));
+      if (entry == NULL)
+        return entry;
+    }
 
   /* Call the allocation method of the superclass.  */
-  ret = ((struct elf64_x86_64_link_hash_entry *)
-         _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
-                                     table, string));
-  if (ret != (struct elf64_x86_64_link_hash_entry *) NULL)
-    {
-      ret->pcrel_relocs_copied = NULL;
-    }
-
-  return (struct bfd_hash_entry *) ret;
+  entry = _bfd_elf_link_hash_newfunc (entry, table, string);
+  if (entry != NULL)
+    {
+      struct elf64_x86_64_link_hash_entry *eh;
+
+      eh = (struct elf64_x86_64_link_hash_entry *) entry;
+      eh->dyn_relocs = NULL;
+      eh->tls_type = GOT_UNKNOWN;
+    }
+
+  return entry;
 }
 
@@ -297 +486 @@
 {
   struct elf64_x86_64_link_hash_table *ret;
-
-  ret = ((struct elf64_x86_64_link_hash_table *)
-         bfd_alloc (abfd, sizeof (struct elf64_x86_64_link_hash_table)));
-  if (ret == (struct elf64_x86_64_link_hash_table *) NULL)
+  bfd_size_type amt = sizeof (struct elf64_x86_64_link_hash_table);
+
+  ret = (struct elf64_x86_64_link_hash_table *) bfd_malloc (amt);
+  if (ret == NULL)
     return NULL;
 
-  if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
-                                       elf64_x86_64_link_hash_newfunc))
-    {
-      bfd_release (abfd, ret);
+  if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc))
+    {
+      free (ret);
       return NULL;
     }
 
-  return &ret->root.root;
+  ret->sgot = NULL;
+  ret->sgotplt = NULL;
+  ret->srelgot = NULL;
+  ret->splt = NULL;
+  ret->srelplt = NULL;
+  ret->sdynbss = NULL;
+  ret->srelbss = NULL;
+  ret->sym_sec.abfd = NULL;
+  ret->tls_ld_got.refcount = 0;
+
+  return &ret->elf.root;
 }
 
-boolean
+/* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
+   shortcuts to them in our hash table.  */
+
+static bfd_boolean
+create_got_section (dynobj, info)
+     bfd *dynobj;
+     struct bfd_link_info *info;
+{
+  struct elf64_x86_64_link_hash_table *htab;
+
+  if (! _bfd_elf_create_got_section (dynobj, info))
+    return FALSE;
+
+  htab = elf64_x86_64_hash_table (info);
+  htab->sgot = bfd_get_section_by_name (dynobj, ".got");
+  htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
+  if (!htab->sgot || !htab->sgotplt)
+    abort ();
+
+  htab->srelgot = bfd_make_section (dynobj, ".rela.got");
+  if (htab->srelgot == NULL
+      || ! bfd_set_section_flags (dynobj, htab->srelgot,
+                                  (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
+                                   | SEC_IN_MEMORY | SEC_LINKER_CREATED
+                                   | SEC_READONLY))
+      || ! bfd_set_section_alignment (dynobj, htab->srelgot, 3))
+    return FALSE;
+  return TRUE;
+}
+
+/* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
+   .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
+   hash table.  */
+
+static bfd_boolean
+elf64_x86_64_create_dynamic_sections (dynobj, info)
+     bfd *dynobj;
+     struct bfd_link_info *info;
+{
+  struct elf64_x86_64_link_hash_table *htab;
+
+  htab = elf64_x86_64_hash_table (info);
+  if (!htab->sgot && !create_got_section (dynobj, info))
+    return FALSE;
+
+  if (!_bfd_elf_create_dynamic_sections (dynobj, info))
+    return FALSE;
+
+  htab->splt = bfd_get_section_by_name (dynobj, ".plt");
+  htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
+  htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
+  if (!info->shared)
+    htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
+
+  if (!htab->splt || !htab->srelplt || !htab->sdynbss
+      || (!info->shared && !htab->srelbss))
+    abort ();
+
+  return TRUE;
+}
+
+/* Copy the extra info we tack onto an elf_link_hash_entry.  */
+
+static void
+elf64_x86_64_copy_indirect_symbol (bed, dir, ind)
+     struct elf_backend_data *bed;
+     struct elf_link_hash_entry *dir, *ind;
+{
+  struct elf64_x86_64_link_hash_entry *edir, *eind;
+
+  edir = (struct elf64_x86_64_link_hash_entry *) dir;
+  eind = (struct elf64_x86_64_link_hash_entry *) ind;
+
+  if (eind->dyn_relocs != NULL)
+    {
+      if (edir->dyn_relocs != NULL)
+        {
+          struct elf64_x86_64_dyn_relocs **pp;
+          struct elf64_x86_64_dyn_relocs *p;
+
+          if (ind->root.type == bfd_link_hash_indirect)
+            abort ();
+
+          /* Add reloc counts against the weak sym to the strong sym
+             list.  Merge any entries against the same section.  */
+          for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
+            {
+              struct elf64_x86_64_dyn_relocs *q;
+
+              for (q = edir->dyn_relocs; q != NULL; q = q->next)
+                if (q->sec == p->sec)
+                  {
+                    q->pc_count += p->pc_count;
+                    q->count += p->count;
+                    *pp = p->next;
+                    break;
+                  }
+              if (q == NULL)
+                pp = &p->next;
+            }
+          *pp = edir->dyn_relocs;
+        }
+
+      edir->dyn_relocs = eind->dyn_relocs;
+      eind->dyn_relocs = NULL;
+    }
+
+  if (ind->root.type == bfd_link_hash_indirect
+      && dir->got.refcount <= 0)
+    {
+      edir->tls_type = eind->tls_type;
+      eind->tls_type = GOT_UNKNOWN;
+    }
+
+  if (ELIMINATE_COPY_RELOCS
+      && ind->root.type != bfd_link_hash_indirect
+      && (dir->elf_link_hash_flags & ELF_LINK_HASH_DYNAMIC_ADJUSTED) != 0)
+    /* If called to transfer flags for a weakdef during processing
+       of elf_adjust_dynamic_symbol, don't copy ELF_LINK_NON_GOT_REF.
+       We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
+    dir->elf_link_hash_flags |=
+      (ind->elf_link_hash_flags & (ELF_LINK_HASH_REF_DYNAMIC
+                                   | ELF_LINK_HASH_REF_REGULAR
+                                   | ELF_LINK_HASH_REF_REGULAR_NONWEAK));
+  else
+    _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
+}
+
+static bfd_boolean
+elf64_x86_64_mkobject (abfd)
+     bfd *abfd;
+{
+  bfd_size_type amt = sizeof (struct elf64_x86_64_obj_tdata);
+  abfd->tdata.any = bfd_zalloc (abfd, amt);
+  if (abfd->tdata.any == NULL)
+    return FALSE;
+  return TRUE;
+}
+
+static bfd_boolean
 elf64_x86_64_elf_object_p (abfd)
-     bfd *abfd;
-{
+  bfd *abfd;
+{
+  /* Allocate our special target data.  */
+  struct elf64_x86_64_obj_tdata *new_tdata;
+  bfd_size_type amt = sizeof (struct elf64_x86_64_obj_tdata);
+  new_tdata = bfd_zalloc (abfd, amt);
+  if (new_tdata == NULL)
+    return FALSE;
+  new_tdata->root = *abfd->tdata.elf_obj_data;
+  abfd->tdata.any = new_tdata;
   /* Set the right machine number for an x86-64 elf64 file.  */
   bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64);
-  return true;
+  return TRUE;
 }
 
+static int
+elf64_x86_64_tls_transition (info, r_type, is_local)
+     struct bfd_link_info *info;
+     int r_type;
+     int is_local;
+{
+  if (info->shared)
+    return r_type;
+
+  switch (r_type)
+    {
+    case R_X86_64_TLSGD:
+    case R_X86_64_GOTTPOFF:
+      if (is_local)
+        return R_X86_64_TPOFF32;
+      return R_X86_64_GOTTPOFF;
+    case R_X86_64_TLSLD:
+      return R_X86_64_TPOFF32;
+    }
+
+   return r_type;
+}
+
 /* Look through the relocs for a section during the first phase, and
-   allocate space in the global offset table or procedure linkage
-   table.  */
-
-static boolean
+   calculate needed space in the global offset table, procedure
+   linkage table, and dynamic reloc sections.  */
+
+static bfd_boolean
 elf64_x86_64_check_relocs (abfd, info, sec, relocs)
      bfd *abfd;
@@ -333 +701 @@
      const Elf_Internal_Rela *relocs;
 {
-  bfd *dynobj;
+  struct elf64_x86_64_link_hash_table *htab;
   Elf_Internal_Shdr *symtab_hdr;
   struct elf_link_hash_entry **sym_hashes;
-  bfd_signed_vma *local_got_refcounts;
   const Elf_Internal_Rela *rel;
   const Elf_Internal_Rela *rel_end;
-  asection *sgot;
-  asection *srelgot;
   asection *sreloc;
 
   if (info->relocateable)
-    return true;
-
-  dynobj = elf_hash_table (info)->dynobj;
+    return TRUE;
+
+  htab = elf64_x86_64_hash_table (info);
   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
   sym_hashes = elf_sym_hashes (abfd);
-  local_got_refcounts = elf_local_got_refcounts (abfd);
-
-  sgot = srelgot = sreloc = NULL;
+
+  sreloc = NULL;
+
   rel_end = relocs + sec->reloc_count;
   for (rel = relocs; rel < rel_end; rel++)
     {
+      unsigned int r_type;
       unsigned long r_symndx;
       struct elf_link_hash_entry *h;
 
       r_symndx = ELF64_R_SYM (rel->r_info);
+      r_type = ELF64_R_TYPE (rel->r_info);
+
+      if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
+        {
+          (*_bfd_error_handler) (_("%s: bad symbol index: %d"),
+                                 bfd_archive_filename (abfd),
+                                 r_symndx);
+          return FALSE;
+        }
+
       if (r_symndx < symtab_hdr->sh_info)
         h = NULL;
@@ -364 +740 @@
         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 
-      /* Some relocs require a global offset table.  */
-      if (dynobj == NULL)
-        {
-          switch (ELF64_R_TYPE (rel->r_info))
-            {
-            case R_X86_64_GOT32:
-            case R_X86_64_GOTPCREL:
-              elf_hash_table (info)->dynobj = dynobj = abfd;
-              if (! _bfd_elf_create_got_section (dynobj, info))
-                return false;
-              break;
-            }
-        }
-
-      switch (ELF64_R_TYPE (rel->r_info))
-        {
+      r_type = elf64_x86_64_tls_transition (info, r_type, h == NULL);
+      switch (r_type)
+        {
+        case R_X86_64_TLSLD:
+          htab->tls_ld_got.refcount += 1;
+          goto create_got;
+
+        case R_X86_64_TPOFF32:
+          if (info->shared)
+            {
+              (*_bfd_error_handler)
+                (_("%s: relocation %s can not be used when making a shared object; recompile with -fPIC"),
+                 bfd_archive_filename (abfd),
+                 x86_64_elf_howto_table[r_type].name);
+              bfd_set_error (bfd_error_bad_value);
+              return FALSE;
+            }
+          break;
+
+        case R_X86_64_GOTTPOFF:
+          if (info->shared)
+            info->flags |= DF_STATIC_TLS;
+          /* Fall through */
+
+        case R_X86_64_GOT32:
         case R_X86_64_GOTPCREL:
-        case R_X86_64_GOT32:
+        case R_X86_64_TLSGD:
           /* This symbol requires a global offset table entry.  */
-
-          if (sgot == NULL)
-            {
-              sgot = bfd_get_section_by_name (dynobj, ".got");
-              BFD_ASSERT (sgot != NULL);
-            }
-
-          if (srelgot == NULL && (h != NULL || info->shared))
-            {
-              srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
-              if (srelgot == NULL)
-                {
-                  srelgot = bfd_make_section (dynobj, ".rela.got");
-                  if (srelgot == NULL
-                      || ! bfd_set_section_flags (dynobj, srelgot,
-                                                  (SEC_ALLOC
-                                                   | SEC_LOAD
-                                                   | SEC_HAS_CONTENTS
-                                                   | SEC_IN_MEMORY
-                                                   | SEC_LINKER_CREATED
-                                                   | SEC_READONLY))
-                      || ! bfd_set_section_alignment (dynobj, srelgot, 3))
-                    return false;
-                }
-            }
-
-          if (h != NULL)
-            {
-              if (h->got.refcount == -1)
-                {
-                  h->got.refcount = 1;
-
-                  /* Make sure this symbol is output as a dynamic symbol.  */
-                  if (h->dynindx == -1)
-                    {
-                      if (! bfd_elf64_link_record_dynamic_symbol (info, h))
-                        return false;
-                    }
-
-                  sgot->_raw_size += GOT_ENTRY_SIZE;
-                  srelgot->_raw_size += sizeof (Elf64_External_Rela);
-                }
-              else
+          {
+            int tls_type, old_tls_type;
+
+            switch (r_type)
+              {
+              default: tls_type = GOT_NORMAL; break;
+              case R_X86_64_TLSGD: tls_type = GOT_TLS_GD; break;
+              case R_X86_64_GOTTPOFF: tls_type = GOT_TLS_IE; break;
+              }
+
+            if (h != NULL)
+              {
                 h->got.refcount += 1;
-            }
-          else
-            {
-              /* This is a global offset table entry for a local symbol.  */
-              if (local_got_refcounts == NULL)
-                {
-                  size_t size;
-
-                  size = symtab_hdr->sh_info * sizeof (bfd_signed_vma);
-                  local_got_refcounts = ((bfd_signed_vma *)
-                                         bfd_alloc (abfd, size));
-                  if (local_got_refcounts == NULL)
-                    return false;
-                  elf_local_got_refcounts (abfd) = local_got_refcounts;
-                  memset (local_got_refcounts, -1, size);
-                }
-              if (local_got_refcounts[r_symndx] == -1)
-                {
-                  local_got_refcounts[r_symndx] = 1;
-
-                  sgot->_raw_size += GOT_ENTRY_SIZE;
-                  if (info->shared)
-                    {
-                      /* If we are generating a shared object, we need to
-                         output a R_X86_64_RELATIVE reloc so that the dynamic
-                         linker can adjust this GOT entry.  */
-                      srelgot->_raw_size += sizeof (Elf64_External_Rela);
-                    }
-                }
-              else
+                old_tls_type = elf64_x86_64_hash_entry (h)->tls_type;
+              }
+            else
+              {
+                bfd_signed_vma *local_got_refcounts;
+
+                /* This is a global offset table entry for a local symbol.  */
+                local_got_refcounts = elf_local_got_refcounts (abfd);
+                if (local_got_refcounts == NULL)
+                  {
+                    bfd_size_type size;
+
+                    size = symtab_hdr->sh_info;
+                    size *= sizeof (bfd_signed_vma) + sizeof (char);
+                    local_got_refcounts = ((bfd_signed_vma *)
+                                           bfd_zalloc (abfd, size));
+                    if (local_got_refcounts == NULL)
+                      return FALSE;
+                    elf_local_got_refcounts (abfd) = local_got_refcounts;
+                    elf64_x86_64_local_got_tls_type (abfd)
+                      = (char *) (local_got_refcounts + symtab_hdr->sh_info);
+                  }
                 local_got_refcounts[r_symndx] += 1;
+                old_tls_type
+                  = elf64_x86_64_local_got_tls_type (abfd) [r_symndx];
+              }
+
+            /* If a TLS symbol is accessed using IE at least once,
+               there is no point to use dynamic model for it.  */
+            if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
+                && (old_tls_type != GOT_TLS_GD || tls_type != GOT_TLS_IE))
+              {
+                if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
+                  tls_type = old_tls_type;
+                else
+                  {
+                    (*_bfd_error_handler)
+                      (_("%s: %s' accessed both as normal and thread local symbol"),
+                       bfd_archive_filename (abfd),
+                       h ? h->root.root.string : "<local>");
+                    return FALSE;
+                  }
+              }
+
+            if (old_tls_type != tls_type)
+              {
+                if (h != NULL)
+                  elf64_x86_64_hash_entry (h)->tls_type = tls_type;
+                else
+                  elf64_x86_64_local_got_tls_type (abfd) [r_symndx] = tls_type;
+              }
+          }
+          /* Fall through */
+
+          //case R_X86_64_GOTPCREL:
+        create_got:
+          if (htab->sgot == NULL)
+            {
+              if (htab->elf.dynobj == NULL)
+                htab->elf.dynobj = abfd;
+              if (!create_got_section (htab->elf.dynobj, info))
+                return FALSE;
             }
           break;
@@ -475 +860 @@
 
           h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
-          if (h->plt.refcount == -1)
-            h->plt.refcount = 1;
-          else
-            h->plt.refcount += 1;
+          h->plt.refcount += 1;
           break;
 
@@ -484 +866 @@
         case R_X86_64_16:
         case R_X86_64_32:
+        case R_X86_64_32S:
+          /* Let's help debug shared library creation.  These relocs
+             cannot be used in shared libs.  Don't error out for
+             sections we don't care about, such as debug sections or
+             non-constant sections.  */
+          if (info->shared
+              && (sec->flags & SEC_ALLOC) != 0
+              && (sec->flags & SEC_READONLY) != 0)
+            {
+              (*_bfd_error_handler)
+                (_("%s: relocation %s can not be used when making a shared object; recompile with -fPIC"),
+                 bfd_archive_filename (abfd),
+                 x86_64_elf_howto_table[r_type].name);
+              bfd_set_error (bfd_error_bad_value);
+              return FALSE;
+            }
+          /* Fall through.  */
+
+        case R_X86_64_PC8:
+        case R_X86_64_PC16:
+        case R_X86_64_PC32:
         case R_X86_64_64:
-        case R_X86_64_32S:
-        case R_X86_64_PC32:
-          if (h != NULL)
-            h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
+          if (h != NULL && !info->shared)
+            {
+              /* If this reloc is in a read-only section, we might
+                 need a copy reloc.  We can't check reliably at this
+                 stage whether the section is read-only, as input
+                 sections have not yet been mapped to output sections.
+                 Tentatively set the flag for now, and correct in
+                 adjust_dynamic_symbol.  */
+              h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
+
+              /* We may need a .plt entry if the function this reloc
+                 refers to is in a shared lib.  */
+              h->plt.refcount += 1;
+            }
 
           /* If we are creating a shared library, and this is a reloc
@@ -499 +912 @@
              this point we have not seen all the input files, so it is
              possible that DEF_REGULAR is not set now but will be set
-             later (it is never cleared).  We account for that
-             possibility below by storing information in the
-             pcrel_relocs_copied field of the hash table entry.
-             A similar situation occurs when creating shared libraries
-             and symbol visibility changes render the symbol local.  */
-          if (info->shared
-              && (sec->flags & SEC_ALLOC) != 0
-              && (((ELF64_R_TYPE (rel->r_info) != R_X86_64_PC8)
-                  && (ELF64_R_TYPE (rel->r_info) != R_X86_64_PC16)
-                  && (ELF64_R_TYPE (rel->r_info) != R_X86_64_PC32))
-                  || (h != NULL
-                      && (! info->symbolic
-                          || (h->elf_link_hash_flags
-                              & ELF_LINK_HASH_DEF_REGULAR) == 0))))
-            {
-              /* When creating a shared object, we must copy these
-                 reloc types into the output file.  We create a reloc
-                 section in dynobj and make room for this reloc.  */
+             later (it is never cleared).  In case of a weak definition,
+             DEF_REGULAR may be cleared later by a strong definition in
+             a shared library.  We account for that possibility below by
+             storing information in the relocs_copied field of the hash
+             table entry.  A similar situation occurs when creating
+             shared libraries and symbol visibility changes render the
+             symbol local.
+
+             If on the other hand, we are creating an executable, we
+             may need to keep relocations for symbols satisfied by a
+             dynamic library if we manage to avoid copy relocs for the
+             symbol.  */
+          if ((info->shared
+               && (sec->flags & SEC_ALLOC) != 0
+               && (((r_type != R_X86_64_PC8)
+                    && (r_type != R_X86_64_PC16)
+                    && (r_type != R_X86_64_PC32))
+                   || (h != NULL
+                       && (! info->symbolic
+                           || h->root.type == bfd_link_hash_defweak
+                           || (h->elf_link_hash_flags
+                               & ELF_LINK_HASH_DEF_REGULAR) == 0))))
+              || (ELIMINATE_COPY_RELOCS
+                  && !info->shared
+                  && (sec->flags & SEC_ALLOC) != 0
+                  && h != NULL
+                  && (h->root.type == bfd_link_hash_defweak
+                      || (h->elf_link_hash_flags
+                          & ELF_LINK_HASH_DEF_REGULAR) == 0)))
+            {
+              struct elf64_x86_64_dyn_relocs *p;
+              struct elf64_x86_64_dyn_relocs **head;
+
+              /* We must copy these reloc types into the output file.
+                 Create a reloc section in dynobj and make room for
+                 this reloc.  */
               if (sreloc == NULL)
                 {
                   const char *name;
+                  bfd *dynobj;
 
                   name = (bfd_elf_string_from_elf_section
@@ -526 +958 @@
                            elf_section_data (sec)->rel_hdr.sh_name));
                   if (name == NULL)
-                    return false;
-
-                  BFD_ASSERT (strncmp (name, ".rela", 5) == 0
-                              && strcmp (bfd_get_section_name (abfd, sec),
-                                         name + 5) == 0);
+                    return FALSE;
+
+                  if (strncmp (name, ".rela", 5) != 0
+                      || strcmp (bfd_get_section_name (abfd, sec),
+                                 name + 5) != 0)
+                    {
+                      (*_bfd_error_handler)
+                        (_("%s: bad relocation section name `%s\'"),
+                         bfd_archive_filename (abfd), name);
+                    }
+
+                  if (htab->elf.dynobj == NULL)
+                    htab->elf.dynobj = abfd;
+
+                  dynobj = htab->elf.dynobj;
 
                   sreloc = bfd_get_section_by_name (dynobj, name);
@@ -545 +987 @@
                           || ! bfd_set_section_flags (dynobj, sreloc, flags)
                           || ! bfd_set_section_alignment (dynobj, sreloc, 3))
-                        return false;
+                        return FALSE;
                     }
+                  elf_section_data (sec)->sreloc = sreloc;
                 }
 
-              sreloc->_raw_size += sizeof (Elf64_External_Rela);
-
-              /* If this is a global symbol, we count the number of PC
-                 relative relocations we have entered for this symbol,
-                 so that we can discard them later as necessary.  Note
-                 that this function is only called if we are using an
-                 elf64_x86_64 linker hash table, which means that h is
-                 really a pointer to an elf64_x86_64_link_hash_entry.  */
-              if (h != NULL
-                  && ((ELF64_R_TYPE (rel->r_info) == R_X86_64_PC8)
-                      || (ELF64_R_TYPE (rel->r_info) == R_X86_64_PC16)
-                      || (ELF64_R_TYPE (rel->r_info) == R_X86_64_PC32)))
+              /* If this is a global symbol, we count the number of
+                 relocations we need for this symbol.  */
+              if (h != NULL)
                 {
-                  struct elf64_x86_64_link_hash_entry *eh;
-                  struct elf64_x86_64_pcrel_relocs_copied *p;
-
-                  eh = (struct elf64_x86_64_link_hash_entry *) h;
-
-                  for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
-                    if (p->section == sreloc)
-                      break;
-
+                  head = &((struct elf64_x86_64_link_hash_entry *) h)->dyn_relocs;
+                }
+              else
+                {
+                  /* Track dynamic relocs needed for local syms too.
+                     We really need local syms available to do this
+                     easily.  Oh well.  */
+
+                  asection *s;
+                  s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
+                                                 sec, r_symndx);
+                  if (s == NULL)
+                    return FALSE;
+
+                  head = ((struct elf64_x86_64_dyn_relocs **)
+                          &elf_section_data (s)->local_dynrel);
+                }
+
+              p = *head;
+              if (p == NULL || p->sec != sec)
+                {
+                  bfd_size_type amt = sizeof *p;
+                  p = ((struct elf64_x86_64_dyn_relocs *)
+                       bfd_alloc (htab->elf.dynobj, amt));
                   if (p == NULL)
-                    {
-                      p = ((struct elf64_x86_64_pcrel_relocs_copied *)
-                           bfd_alloc (dynobj, sizeof *p));
-                      if (p == NULL)
-                        return false;
-                      p->next = eh->pcrel_relocs_copied;
-                      eh->pcrel_relocs_copied = p;
-                      p->section = sreloc;
-                      p->count = 0;
-                    }
-
-                  ++p->count;
+                    return FALSE;
+                  p->next = *head;
+                  *head = p;
+                  p->sec = sec;
+                  p->count = 0;
+                  p->pc_count = 0;
                 }
+
+              p->count += 1;
+              if (r_type == R_X86_64_PC8
+                  || r_type == R_X86_64_PC16
+                  || r_type == R_X86_64_PC32)
+                p->pc_count += 1;
             }
           break;
-        }
-    }
-
-  return true;
+
+          /* This relocation describes the C++ object vtable hierarchy.
+             Reconstruct it for later use during GC.  */
+        case R_X86_64_GNU_VTINHERIT:
+          if (!_bfd_elf64_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
+            return FALSE;
+          break;
+
+          /* This relocation describes which C++ vtable entries are actually
+             used.  Record for later use during GC.  */
+        case R_X86_64_GNU_VTENTRY:
+          if (!_bfd_elf64_gc_record_vtentry (abfd, sec, h, rel->r_addend))
+            return FALSE;
+          break;
+
+        default:
+          break;
+        }
+    }
+
+  return TRUE;
 }
 
@@ -597 +1063 @@
 
 static asection *
-elf64_x86_64_gc_mark_hook (abfd, info, rel, h, sym)
-     bfd *abfd;
+elf64_x86_64_gc_mark_hook (sec, info, rel, h, sym)
+     asection *sec;
      struct bfd_link_info *info ATTRIBUTE_UNUSED;
-     Elf_Internal_Rela *rel ATTRIBUTE_UNUSED;
+     Elf_Internal_Rela *rel;
      struct elf_link_hash_entry *h;
      Elf_Internal_Sym *sym;
@@ -606 +1072 @@
   if (h != NULL)
     {
-      switch (h->root.type)
-        {
-        case bfd_link_hash_defined:
-        case bfd_link_hash_defweak:
-          return h->root.u.def.section;
-
-        case bfd_link_hash_common:
-          return h->root.u.c.p->section;
+      switch (ELF64_R_TYPE (rel->r_info))
+        {
+        case R_X86_64_GNU_VTINHERIT:
+        case R_X86_64_GNU_VTENTRY:
+          break;
 
         default:
-          break;
+          switch (h->root.type)
+            {
+            case bfd_link_hash_defined:
+            case bfd_link_hash_defweak:
+              return h->root.u.def.section;
+
+            case bfd_link_hash_common:
+              return h->root.u.c.p->section;
+
+            default:
+              break;
+            }
         }
     }
   else
-    {
-      if (!(elf_bad_symtab (abfd)
-            && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
-          && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
-                && sym->st_shndx != SHN_COMMON))
-        {
-          return bfd_section_from_elf_index (abfd, sym->st_shndx);
-        }
-    }
+    return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
 
   return NULL;
@@ -635 +1101 @@
 /* Update the got entry reference counts for the section being removed.  */
 
-static boolean
+static bfd_boolean
 elf64_x86_64_gc_sweep_hook (abfd, info, sec, relocs)
      bfd *abfd;
-     struct bfd_link_info *info ATTRIBUTE_UNUSED;
+     struct bfd_link_info *info;
      asection *sec;
      const Elf_Internal_Rela *relocs;
@@ -646 +1112 @@
   bfd_signed_vma *local_got_refcounts;
   const Elf_Internal_Rela *rel, *relend;
-  unsigned long r_symndx;
-  struct elf_link_hash_entry *h;
-  bfd *dynobj;
-  asection *sgot;
-  asection *srelgot;
+
+  elf_section_data (sec)->local_dynrel = NULL;
 
   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
@@ -656 +1119 @@
   local_got_refcounts = elf_local_got_refcounts (abfd);
 
-  dynobj = elf_hash_table (info)->dynobj;
-  if (dynobj == NULL)
-    return true;
-
-  sgot = bfd_get_section_by_name (dynobj, ".got");
-  srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
-
   relend = relocs + sec->reloc_count;
   for (rel = relocs; rel < relend; rel++)
-    switch (ELF64_R_TYPE (rel->r_info))
-      {
-      case R_X86_64_GOT32:
-      case R_X86_64_GOTPCREL:
-        r_symndx = ELF64_R_SYM (rel->r_info);
-        if (r_symndx >= symtab_hdr->sh_info)
-          {
-            h = sym_hashes[r_symndx - symtab_hdr->sh_info];
-            if (h->got.refcount > 0)
+    {
+      unsigned long r_symndx;
+      unsigned int r_type;
+      struct elf_link_hash_entry *h = NULL;
+
+      r_symndx = ELF64_R_SYM (rel->r_info);
+      if (r_symndx >= symtab_hdr->sh_info)
+        {
+          struct elf64_x86_64_link_hash_entry *eh;
+          struct elf64_x86_64_dyn_relocs **pp;
+          struct elf64_x86_64_dyn_relocs *p;
+
+          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
+          eh = (struct elf64_x86_64_link_hash_entry *) h;
+
+          for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
+            if (p->sec == sec)
               {
+                /* Everything must go for SEC.  */
+                *pp = p->next;
+                break;
+              }
+        }
+
+      r_type = ELF64_R_TYPE (rel->r_info);
+      r_type = elf64_x86_64_tls_transition (info, r_type, h != NULL);
+      switch (r_type)
+        {
+        case R_X86_64_TLSLD:
+          if (elf64_x86_64_hash_table (info)->tls_ld_got.refcount > 0)
+            elf64_x86_64_hash_table (info)->tls_ld_got.refcount -= 1;
+          break;
+
+        case R_X86_64_TLSGD:
+        case R_X86_64_GOTTPOFF:
+        case R_X86_64_GOT32:
+        case R_X86_64_GOTPCREL:
+          if (h != NULL)
+            {
+              if (h->got.refcount > 0)
                 h->got.refcount -= 1;
-                if (h->got.refcount == 0)
-                  {
-                    sgot->_raw_size -= GOT_ENTRY_SIZE;
-                    srelgot->_raw_size -= sizeof (Elf64_External_Rela);
-                  }
-              }
-          }
-        else if (local_got_refcounts != NULL)
-          {
-            if (local_got_refcounts[r_symndx] > 0)
-              {
+            }
+          else if (local_got_refcounts != NULL)
+            {
+              if (local_got_refcounts[r_symndx] > 0)
                 local_got_refcounts[r_symndx] -= 1;
-                if (local_got_refcounts[r_symndx] == 0)
-                  {
-                    sgot->_raw_size -= GOT_ENTRY_SIZE;
-                    if (info->shared)
-                      srelgot->_raw_size -= sizeof (Elf64_External_Rela);
-                  }
-              }
-          }
-        break;
-
-      case R_X86_64_PLT32:
-        r_symndx = ELF64_R_SYM (rel->r_info);
-        if (r_symndx >= symtab_hdr->sh_info)
-          {
-            h = sym_hashes[r_symndx - symtab_hdr->sh_info];
-            if (h->plt.refcount > 0)
-              h->plt.refcount -= 1;
-          }
-        break;
-
-      default:
-        break;
-      }
-
-  return true;
+            }
+          break;
+
+        case R_X86_64_8:
+        case R_X86_64_16:
+        case R_X86_64_32:
+        case R_X86_64_64:
+        case R_X86_64_32S:
+        case R_X86_64_PC8:
+        case R_X86_64_PC16:
+        case R_X86_64_PC32:
+          if (info->shared)
+            break;
+          /* Fall thru */
+
+        case R_X86_64_PLT32:
+          if (h != NULL)
+            {
+              if (h->plt.refcount > 0)
+                h->plt.refcount -= 1;
+            }
+          break;
+
+        default:
+          break;
+        }
+    }
+
+  return TRUE;
 }
 
@@ -721 +1204 @@
    understand.  */
 
-static boolean
+static bfd_boolean
 elf64_x86_64_adjust_dynamic_symbol (info, h)
      struct bfd_link_info *info;
      struct elf_link_hash_entry *h;
 {
-  bfd *dynobj;
+  struct elf64_x86_64_link_hash_table *htab;
   asection *s;
   unsigned int power_of_two;
-
-  dynobj = elf_hash_table (info)->dynobj;
-
-  /* Make sure we know what is going on here.  */
-  BFD_ASSERT (dynobj != NULL
-              && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
-                  || h->weakdef != NULL
-                  || ((h->elf_link_hash_flags
-                       & ELF_LINK_HASH_DEF_DYNAMIC) != 0
-                      && (h->elf_link_hash_flags
-                          & ELF_LINK_HASH_REF_REGULAR) != 0
-                      && (h->elf_link_hash_flags
-                          & ELF_LINK_HASH_DEF_REGULAR) == 0)));
 
   /* If this is a function, put it in the procedure linkage table.  We
@@ -749 +1219 @@
       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
     {
-      if ((! info->shared
-           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
-           && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
-          || (info->shared && h->plt.refcount <= 0))
+      if (h->plt.refcount <= 0
+          || (! info->shared
+              && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
+              && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0
+              && h->root.type != bfd_link_hash_undefweak
+              && h->root.type != bfd_link_hash_undefined))
         {
           /* This case can occur if we saw a PLT32 reloc in an input
@@ -761 +1233 @@
           h->plt.offset = (bfd_vma) -1;
           h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
-          return true;
-        }
-
-      /* Make sure this symbol is output as a dynamic symbol.  */
-      if (h->dynindx == -1)
-        {
-          if (! bfd_elf64_link_record_dynamic_symbol (info, h))
-            return false;
-        }
-
-      s = bfd_get_section_by_name (dynobj, ".plt");
-      BFD_ASSERT (s != NULL);
-
-      /* If this is the first .plt entry, make room for the special
-         first entry.  */
-      if (s->_raw_size == 0)
-        s->_raw_size = PLT_ENTRY_SIZE;
-
-      /* If this symbol is not defined in a regular file, and we are
-         not generating a shared library, then set the symbol to this
-         location in the .plt.  This is required to make function
-         pointers compare as equal between the normal executable and
-         the shared library.  */
-      if (! info->shared
-          && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
-        {
-          h->root.u.def.section = s;
-          h->root.u.def.value = s->_raw_size;
-        }
-
-      h->plt.offset = s->_raw_size;
-
-      /* Make room for this entry.  */
-      s->_raw_size += PLT_ENTRY_SIZE;
-
-      /* We also need to make an entry in the .got.plt section, which
-         will be placed in the .got section by the linker script.  */
-      s = bfd_get_section_by_name (dynobj, ".got.plt");
-      BFD_ASSERT (s != NULL);
-      s->_raw_size += GOT_ENTRY_SIZE;
-
-      /* We also need to make an entry in the .rela.plt section.  */
-      s = bfd_get_section_by_name (dynobj, ".rela.plt");
-      BFD_ASSERT (s != NULL);
-      s->_raw_size += sizeof (Elf64_External_Rela);
-
-      return true;
-    }
+        }
+
+      return TRUE;
+    }
+  else
+    /* It's possible that we incorrectly decided a .plt reloc was
+       needed for an R_X86_64_PC32 reloc to a non-function sym in
+       check_relocs.  We can't decide accurately between function and
+       non-function syms in check-relocs;  Objects loaded later in
+       the link may change h->type.  So fix it now.  */
+    h->plt.offset = (bfd_vma) -1;
 
   /* If this is a weak symbol, and there is a real definition, the
@@ -819 +1254 @@
       h->root.u.def.section = h->weakdef->root.u.def.section;
       h->root.u.def.value = h->weakdef->root.u.def.value;
-      return true;
+      if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
+        h->elf_link_hash_flags
+          = ((h->elf_link_hash_flags & ~ELF_LINK_NON_GOT_REF)
+             | (h->weakdef->elf_link_hash_flags & ELF_LINK_NON_GOT_REF));
+      return TRUE;
     }
 
@@ -830 +1269 @@
      be handled correctly by relocate_section.  */
   if (info->shared)
-    return true;
+    return TRUE;
 
   /* If there are no references to this symbol that do not use the
      GOT, we don't need to generate a copy reloc.  */
   if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
-    return true;
+    return TRUE;
+
+  /* If -z nocopyreloc was given, we won't generate them either.  */
+  if (info->nocopyreloc)
+    {
+      h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
+      return TRUE;
+    }
+
+  if (ELIMINATE_COPY_RELOCS)
+    {
+      struct elf64_x86_64_link_hash_entry * eh;
+      struct elf64_x86_64_dyn_relocs *p;
+
+      eh = (struct elf64_x86_64_link_hash_entry *) h;
+      for (p = eh->dyn_relocs; p != NULL; p = p->next)
+        {
+          s = p->sec->output_section;
+          if (s != NULL && (s->flags & SEC_READONLY) != 0)
+            break;
+        }
+
+      /* If we didn't find any dynamic relocs in read-only sections, then
+         we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
+      if (p == NULL)
+        {
+          h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
+          return TRUE;
+        }
+    }
 
   /* We must allocate the symbol in our .dynbss section, which will
@@ -847 +1315 @@
      same memory location for the variable.  */
 
-  s = bfd_get_section_by_name (dynobj, ".dynbss");
-  BFD_ASSERT (s != NULL);
+  htab = elf64_x86_64_hash_table (info);
 
   /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
      to copy the initial value out of the dynamic object and into the
-     runtime process image.  We need to remember the offset into the
-     .rela.bss section we are going to use.  */
+     runtime process image.  */
   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
     {
-      asection *srel;
-
-      srel = bfd_get_section_by_name (dynobj, ".rela.bss");
-      BFD_ASSERT (srel != NULL);
-      srel->_raw_size += sizeof (Elf64_External_Rela);
+      htab->srelbss->_raw_size += sizeof (Elf64_External_Rela);
       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
     }
@@ -874 +1336 @@
 
   /* Apply the required alignment.  */
+  s = htab->sdynbss;
   s->_raw_size = BFD_ALIGN (s->_raw_size, (bfd_size_type) (1 << power_of_two));
-  if (power_of_two > bfd_get_section_alignment (dynobj, s))
-    {
-      if (! bfd_set_section_alignment (dynobj, s, power_of_two))
-        return false;
+  if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
+    {
+      if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
+        return FALSE;
     }
 
@@ -888 +1351 @@
   s->_raw_size += h->size;
 
-  return true;
+  return TRUE;
 }
 
+/* This is the condition under which elf64_x86_64_finish_dynamic_symbol
+   will be called from elflink.h.  If elflink.h doesn't call our
+   finish_dynamic_symbol routine, we'll need to do something about
+   initializing any .plt and .got entries in elf64_x86_64_relocate_section.  */
+#define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
+  ((DYN)                                                                \
+   && ((INFO)->shared                                                   \
+       || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)      \
+   && ((H)->dynindx != -1                                               \
+       || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
+
+/* Allocate space in .plt, .got and associated reloc sections for
+   dynamic relocs.  */
+
+static bfd_boolean
+allocate_dynrelocs (h, inf)
+     struct elf_link_hash_entry *h;
+     PTR inf;
+{
+  struct bfd_link_info *info;
+  struct elf64_x86_64_link_hash_table *htab;
+  struct elf64_x86_64_link_hash_entry *eh;
+  struct elf64_x86_64_dyn_relocs *p;
+
+  if (h->root.type == bfd_link_hash_indirect)
+    return TRUE;
+
+  if (h->root.type == bfd_link_hash_warning)
+    h = (struct elf_link_hash_entry *) h->root.u.i.link;
+
+  info = (struct bfd_link_info *) inf;
+  htab = elf64_x86_64_hash_table (info);
+
+  if (htab->elf.dynamic_sections_created
+      && h->plt.refcount > 0)
+    {
+      /* Make sure this symbol is output as a dynamic symbol.
+         Undefined weak syms won't yet be marked as dynamic.  */
+      if (h->dynindx == -1
+          && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
+        {
+          if (! bfd_elf64_link_record_dynamic_symbol (info, h))
+            return FALSE;
+        }
+
+      if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
+        {
+          asection *s = htab->splt;
+
+          /* If this is the first .plt entry, make room for the special
+             first entry.  */
+          if (s->_raw_size == 0)
+            s->_raw_size += PLT_ENTRY_SIZE;
+
+          h->plt.offset = s->_raw_size;
+
+          /* If this symbol is not defined in a regular file, and we are
+             not generating a shared library, then set the symbol to this
+             location in the .plt.  This is required to make function
+             pointers compare as equal between the normal executable and
+             the shared library.  */
+          if (! info->shared
+              && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
+            {
+              h->root.u.def.section = s;
+              h->root.u.def.value = h->plt.offset;
+            }
+
+          /* Make room for this entry.  */
+          s->_raw_size += PLT_ENTRY_SIZE;
+
+          /* We also need to make an entry in the .got.plt section, which
+             will be placed in the .got section by the linker script.  */
+          htab->sgotplt->_raw_size += GOT_ENTRY_SIZE;
+
+          /* We also need to make an entry in the .rela.plt section.  */
+          htab->srelplt->_raw_size += sizeof (Elf64_External_Rela);
+        }
+      else
+        {
+          h->plt.offset = (bfd_vma) -1;
+          h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
+        }
+    }
+  else
+    {
+      h->plt.offset = (bfd_vma) -1;
+      h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
+    }
+
+  /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
+     make it a R_X86_64_TPOFF32 requiring no GOT entry.  */
+  if (h->got.refcount > 0
+      && !info->shared
+      && h->dynindx == -1
+      && elf64_x86_64_hash_entry (h)->tls_type == GOT_TLS_IE)
+    h->got.offset = (bfd_vma) -1;
+  else if (h->got.refcount > 0)
+    {
+      asection *s;
+      bfd_boolean dyn;
+      int tls_type = elf64_x86_64_hash_entry (h)->tls_type;
+
+      /* Make sure this symbol is output as a dynamic symbol.
+         Undefined weak syms won't yet be marked as dynamic.  */
+      if (h->dynindx == -1
+          && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
+        {
+          if (! bfd_elf64_link_record_dynamic_symbol (info, h))
+            return FALSE;
+        }
+
+      s = htab->sgot;
+      h->got.offset = s->_raw_size;
+      s->_raw_size += GOT_ENTRY_SIZE;
+      /* R_X86_64_TLSGD needs 2 consecutive GOT slots.  */
+      if (tls_type == GOT_TLS_GD)
+        s->_raw_size += GOT_ENTRY_SIZE;
+      dyn = htab->elf.dynamic_sections_created;
+      /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
+         and two if global.
+         R_X86_64_GOTTPOFF needs one dynamic relocation.  */
+      if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
+          || tls_type == GOT_TLS_IE)
+        htab->srelgot->_raw_size += sizeof (Elf64_External_Rela);
+      else if (tls_type == GOT_TLS_GD)
+        htab->srelgot->_raw_size += 2 * sizeof (Elf64_External_Rela);
+      else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h))
+        htab->srelgot->_raw_size += sizeof (Elf64_External_Rela);
+    }
+  else
+    h->got.offset = (bfd_vma) -1;
+
+  eh = (struct elf64_x86_64_link_hash_entry *) h;
+  if (eh->dyn_relocs == NULL)
+    return TRUE;
+
+  /* In the shared -Bsymbolic case, discard space allocated for
+     dynamic pc-relative relocs against symbols which turn out to be
+     defined in regular objects.  For the normal shared case, discard
+     space for pc-relative relocs that have become local due to symbol
+     visibility changes.  */
+
+  if (info->shared)
+    {
+      if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
+          && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
+              || info->symbolic))
+        {
+          struct elf64_x86_64_dyn_relocs **pp;
+
+          for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
+            {
+              p->count -= p->pc_count;
+              p->pc_count = 0;
+              if (p->count == 0)
+                *pp = p->next;
+              else
+                pp = &p->next;
+            }
+        }
+    }
+  else if (ELIMINATE_COPY_RELOCS)
+    {
+      /* For the non-shared case, discard space for relocs against
+         symbols which turn out to need copy relocs or are not
+         dynamic.  */
+
+      if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
+          && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
+               && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
+              || (htab->elf.dynamic_sections_created
+                  && (h->root.type == bfd_link_hash_undefweak
+                      || h->root.type == bfd_link_hash_undefined))))
+        {
+          /* Make sure this symbol is output as a dynamic symbol.
+             Undefined weak syms won't yet be marked as dynamic.  */
+          if (h->dynindx == -1
+              && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
+            {
+              if (! bfd_elf64_link_record_dynamic_symbol (info, h))
+                return FALSE;
+            }
+
+          /* If that succeeded, we know we'll be keeping all the
+             relocs.  */
+          if (h->dynindx != -1)
+            goto keep;
+        }
+
+      eh->dyn_relocs = NULL;
+
+    keep: ;
+    }
+
+  /* Finally, allocate space.  */
+  for (p = eh->dyn_relocs; p != NULL; p = p->next)
+    {
+      asection *sreloc = elf_section_data (p->sec)->sreloc;
+      sreloc->_raw_size += p->count * sizeof (Elf64_External_Rela);
+    }
+
+  return TRUE;
+}
+
+/* Find any dynamic relocs that apply to read-only sections.  */
+
+static bfd_boolean
+readonly_dynrelocs (h, inf)
+     struct elf_link_hash_entry *h;
+     PTR inf;
+{
+  struct elf64_x86_64_link_hash_entry *eh;
+  struct elf64_x86_64_dyn_relocs *p;
+
+  if (h->root.type == bfd_link_hash_warning)
+    h = (struct elf_link_hash_entry *) h->root.u.i.link;
+
+  eh = (struct elf64_x86_64_link_hash_entry *) h;
+  for (p = eh->dyn_relocs; p != NULL; p = p->next)
+    {
+      asection *s = p->sec->output_section;
+
+      if (s != NULL && (s->flags & SEC_READONLY) != 0)
+        {
+          struct bfd_link_info *info = (struct bfd_link_info *) inf;
+
+          info->flags |= DF_TEXTREL;
+
+          /* Not an error, just cut short the traversal.  */
+          return FALSE;
+        }
+    }
+  return TRUE;
+}
+
 /* Set the sizes of the dynamic sections.  */
 
-static boolean
+static bfd_boolean
 elf64_x86_64_size_dynamic_sections (output_bfd, info)
-     bfd *output_bfd;
+     bfd *output_bfd ATTRIBUTE_UNUSED;
      struct bfd_link_info *info;
 {
+  struct elf64_x86_64_link_hash_table *htab;
   bfd *dynobj;
   asection *s;
-  boolean plt;
-  boolean relocs;
-  boolean reltext;
-
-  dynobj = elf_hash_table (info)->dynobj;
-  BFD_ASSERT (dynobj != NULL);
-
-  if (elf_hash_table (info)->dynamic_sections_created)
+  bfd_boolean relocs;
+  bfd *ibfd;
+
+  htab = elf64_x86_64_hash_table (info);
+  dynobj = htab->elf.dynobj;
+  if (dynobj == NULL)
+    abort ();
+
+  if (htab->elf.dynamic_sections_created)
     {
       /* Set the contents of the .interp section to the interpreter.  */
@@ -913 +1614 @@
         {
           s = bfd_get_section_by_name (dynobj, ".interp");
-          BFD_ASSERT (s != NULL);
+          if (s == NULL)
+            abort ();
           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
         }
     }
+
+  /* Set up .got offsets for local syms, and space for local dynamic
+     relocs.  */
+  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
+    {
+      bfd_signed_vma *local_got;
+      bfd_signed_vma *end_local_got;
+      char *local_tls_type;
+      bfd_size_type locsymcount;
+      Elf_Internal_Shdr *symtab_hdr;
+      asection *srel;
+
+      if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
+        continue;
+
+      for (s = ibfd->sections; s != NULL; s = s->next)
+        {
+          struct elf64_x86_64_dyn_relocs *p;
+
+          for (p = *((struct elf64_x86_64_dyn_relocs **)
+                     &elf_section_data (s)->local_dynrel);
+               p != NULL;
+               p = p->next)
+            {
+              if (!bfd_is_abs_section (p->sec)
+                  && bfd_is_abs_section (p->sec->output_section))
+                {
+                  /* Input section has been discarded, either because
+                     it is a copy of a linkonce section or due to
+                     linker script /DISCARD/, so we'll be discarding
+                     the relocs too.  */
+                }
+              else if (p->count != 0)
+                {
+                  srel = elf_section_data (p->sec)->sreloc;
+                  srel->_raw_size += p->count * sizeof (Elf64_External_Rela);
+                  if ((p->sec->output_section->flags & SEC_READONLY) != 0)
+                    info->flags |= DF_TEXTREL;
+
+                }
+            }
+        }
+
+      local_got = elf_local_got_refcounts (ibfd);
+      if (!local_got)
+        continue;
+
+      symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
+      locsymcount = symtab_hdr->sh_info;
+      end_local_got = local_got + locsymcount;
+      local_tls_type = elf64_x86_64_local_got_tls_type (ibfd);
+      s = htab->sgot;
+      srel = htab->srelgot;
+      for (; local_got < end_local_got; ++local_got, ++local_tls_type)
+        {
+          if (*local_got > 0)
+            {
+              *local_got = s->_raw_size;
+              s->_raw_size += GOT_ENTRY_SIZE;
+              if (*local_tls_type == GOT_TLS_GD)
+                s->_raw_size += GOT_ENTRY_SIZE;
+              if (info->shared
+                  || *local_tls_type == GOT_TLS_GD
+                  || *local_tls_type == GOT_TLS_IE)
+                srel->_raw_size += sizeof (Elf64_External_Rela);
+            }
+          else
+            *local_got = (bfd_vma) -1;
+        }
+    }
+
+  if (htab->tls_ld_got.refcount > 0)
+    {
+      /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
+         relocs.  */
+      htab->tls_ld_got.offset = htab->sgot->_raw_size;
+      htab->sgot->_raw_size += 2 * GOT_ENTRY_SIZE;
+      htab->srelgot->_raw_size += sizeof (Elf64_External_Rela);
+    }
   else
-    {
-      /* We may have created entries in the .rela.got section.
-         However, if we are not creating the dynamic sections, we will
-         not actually use these entries.  Reset the size of .rela.got,
-         which will cause it to get stripped from the output file
-         below.  */
-      s = bfd_get_section_by_name (dynobj, ".rela.got");
-      if (s != NULL)
-        s->_raw_size = 0;
-    }
-
-  /* If this is a -Bsymbolic shared link, then we need to discard all
-     PC relative relocs against symbols defined in a regular object.
-     We allocated space for them in the check_relocs routine, but we
-     will not fill them in in the relocate_section routine.  */
-  if (info->shared)
-    elf64_x86_64_link_hash_traverse (elf64_x86_64_hash_table (info),
-                                     elf64_x86_64_discard_copies,
-                                     (PTR) info);
-
-  /* The check_relocs and adjust_dynamic_symbol entry points have
-     determined the sizes of the various dynamic sections.  Allocate
-     memory for them.  */
-  plt = relocs = reltext = false;
+    htab->tls_ld_got.offset = -1;
+
+  /* Allocate global sym .plt and .got entries, and space for global
+     sym dynamic relocs.  */
+  elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
+
+  /* We now have determined the sizes of the various dynamic sections.
+     Allocate memory for them.  */
+  relocs = FALSE;
   for (s = dynobj->sections; s != NULL; s = s->next)
     {
-      const char *name;
-      boolean strip;
-
       if ((s->flags & SEC_LINKER_CREATED) == 0)
         continue;
 
-      /* It's OK to base decisions on the section name, because none
-         of the dynobj section names depend upon the input files.  */
-      name = bfd_get_section_name (dynobj, s);
-
-      strip = false;
-      if (strcmp (name, ".plt") == 0)
-        {
-          if (s->_raw_size == 0)
-            {
-              /* Strip this section if we don't need it; see the
-                 comment below.  */
-              strip = true;
-            }
-          else
-            {
-              /* Remember whether there is a PLT.  */
-              plt = true;
-            }
-        }
-      else if (strncmp (name, ".rela", 5) == 0)
-        {
-          if (s->_raw_size == 0)
-            {
-              /* If we don't need this section, strip it from the
-                 output file.  This is mostly to handle .rela.bss and
-                 .rela.plt.  We must create both sections in
-                 create_dynamic_sections, because they must be created
-                 before the linker maps input sections to output
-                 sections.  The linker does that before
-                 adjust_dynamic_symbol is called, and it is that
-                 function which decides whether anything needs to go
-                 into these sections.  */
-              strip = true;
-            }
-          else
-            {
-              asection *target;
-
-              /* Remember whether there are any reloc sections other
-                 than .rela.plt.  */
-              if (strcmp (name, ".rela.plt") != 0)
-                {
-                  const char *outname;
-
-                  relocs = true;
-
-                  /* If this relocation section applies to a read only
-                     section, then we probably need a DT_TEXTREL
-                     entry.  The entries in the .rela.plt section
-                     really apply to the .got section, which we
-                     created ourselves and so know is not readonly.  */
-                  outname = bfd_get_section_name (output_bfd,
-                                                  s->output_section);
-                  target = bfd_get_section_by_name (output_bfd, outname + 5);
-                  if (target != NULL
-                      && (target->flags & SEC_READONLY) != 0
-                      && (target->flags & SEC_ALLOC) != 0)
-                    reltext = true;
-                }
-
-              /* We use the reloc_count field as a counter if we need
-                 to copy relocs into the output file.  */
-              s->reloc_count = 0;
-            }
-        }
-      else if (strncmp (name, ".got", 4) != 0)
+      if (s == htab->splt
+          || s == htab->sgot
+          || s == htab->sgotplt)
+        {
+          /* Strip this section if we don't need it; see the
+             comment below.  */
+        }
+      else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
+        {
+          if (s->_raw_size != 0 && s != htab->srelplt)
+            relocs = TRUE;
+
+          /* We use the reloc_count field as a counter if we need
+             to copy relocs into the output file.  */
+          s->reloc_count = 0;
+        }
+      else
         {
           /* It's not one of our sections, so don't allocate space.  */
@@ -1022 +1736 @@
         }
 
-      if (strip)
-        {
+      if (s->_raw_size == 0)
+        {
+          /* If we don't need this section, strip it from the
+             output file.  This is mostly to handle .rela.bss and
+             .rela.plt.  We must create both sections in
+             create_dynamic_sections, because they must be created
+             before the linker maps input sections to output
+             sections.  The linker does that before
+             adjust_dynamic_symbol is called, and it is that
+             function which decides whether anything needs to go
+             into these sections.  */
+
           _bfd_strip_section_from_output (info, s);
           continue;
@@ -1034 +1758 @@
          of garbage.  */
       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
-      if (s->contents == NULL && s->_raw_size != 0)
-        return false;
-    }
-
-  if (elf_hash_table (info)->dynamic_sections_created)
+      if (s->contents == NULL)
+        return FALSE;
+    }
+
+  if (htab->elf.dynamic_sections_created)
     {
       /* Add some entries to the .dynamic section.  We fill in the
@@ -1045 +1769 @@
          the .dynamic section.  The DT_DEBUG entry is filled in by the
          dynamic linker and used by the debugger.  */
+#define add_dynamic_entry(TAG, VAL) \
+  bfd_elf64_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
+
       if (! info->shared)
         {
-          if (! bfd_elf64_add_dynamic_entry (info, DT_DEBUG, 0))
-            return false;
-        }
-
-      if (plt)
-        {
-          if (! bfd_elf64_add_dynamic_entry (info, DT_PLTGOT, 0)
-              || ! bfd_elf64_add_dynamic_entry (info, DT_PLTRELSZ, 0)
-              || ! bfd_elf64_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
-              || ! bfd_elf64_add_dynamic_entry (info, DT_JMPREL, 0))
-            return false;
+          if (!add_dynamic_entry (DT_DEBUG, 0))
+            return FALSE;
+        }
+
+      if (htab->splt->_raw_size != 0)
+        {
+          if (!add_dynamic_entry (DT_PLTGOT, 0)
+              || !add_dynamic_entry (DT_PLTRELSZ, 0)
+              || !add_dynamic_entry (DT_PLTREL, DT_RELA)
+              || !add_dynamic_entry (DT_JMPREL, 0))
+            return FALSE;
         }
 
       if (relocs)
         {
-          if (! bfd_elf64_add_dynamic_entry (info, DT_RELA, 0)
-              || ! bfd_elf64_add_dynamic_entry (info, DT_RELASZ, 0)
-              || ! bfd_elf64_add_dynamic_entry (info, DT_RELAENT,
-                                                sizeof (Elf64_External_Rela)))
-            return false;
-        }
-
-      if (reltext)
-        {
-          if (! bfd_elf64_add_dynamic_entry (info, DT_TEXTREL, 0))
-            return false;
-          info->flags |= DF_TEXTREL;
-        }
-    }
-
-  return true;
+          if (!add_dynamic_entry (DT_RELA, 0)
+              || !add_dynamic_entry (DT_RELASZ, 0)
+              || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
+            return FALSE;
+
+          /* If any dynamic relocs apply to a read-only section,
+             then we need a DT_TEXTREL entry.  */
+          if ((info->flags & DF_TEXTREL) == 0)
+            elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
+                                    (PTR) info);
+
+          if ((info->flags & DF_TEXTREL) != 0)
+            {
+              if (!add_dynamic_entry (DT_TEXTREL, 0))
+                return FALSE;
+            }
+        }
+    }
+#undef add_dynamic_entry
+
+  return TRUE;
 }
 
-/* This function is called via elf64_x86_64_link_hash_traverse if we are
-   creating a shared object.  In the -Bsymbolic case, it discards the
-   space allocated to copy PC relative relocs against symbols which
-   are defined in regular objects.  For the normal non-symbolic case,
-   we also discard space for relocs that have become local due to
-   symbol visibility changes.  We allocated space for them in the
-   check_relocs routine, but we won't fill them in in the
-   relocate_section routine.  */
-
-static boolean
-elf64_x86_64_discard_copies (h, inf)
-     struct elf64_x86_64_link_hash_entry *h;
-     PTR inf;
-{
-  struct elf64_x86_64_pcrel_relocs_copied *s;
-  struct bfd_link_info *info = (struct bfd_link_info *) inf;
-
-  /* If a symbol has been forced local or we have found a regular
-     definition for the symbolic link case, then we won't be needing
-     any relocs.  */
-  if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
-      && ((h->root.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
-          || info->symbolic))
-    {
-      for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
-        s->section->_raw_size -= s->count * sizeof (Elf64_External_Rela);
-    }
-
-  return true;
+/* Return the base VMA address which should be subtracted from real addresses
+   when resolving @dtpoff relocation.
+   This is PT_TLS segment p_vaddr.  */
+
+static bfd_vma
+dtpoff_base (info)
+     struct bfd_link_info *info;
+{
+  /* If tls_segment is NULL, we should have signalled an error already.  */
+  if (elf_hash_table (info)->tls_segment == NULL)
+    return 0;
+  return elf_hash_table (info)->tls_segment->start;
 }
 
+/* Return the relocation value for @tpoff relocation
+   if STT_TLS virtual address is ADDRESS.  */
+
+static bfd_vma
+tpoff (info, address)
+     struct bfd_link_info *info;
+     bfd_vma address;
+{
+  struct elf_link_tls_segment *tls_segment
+    = elf_hash_table (info)->tls_segment;
+
+  /* If tls_segment is NULL, we should have signalled an error already.  */
+  if (tls_segment == NULL)
+    return 0;
+  return address - align_power (tls_segment->size, tls_segment->align)
+         - tls_segment->start;
+}
+
 /* Relocate an x86_64 ELF section.  */
 
-static boolean
+static bfd_boolean
 elf64_x86_64_relocate_section (output_bfd, info, input_bfd, input_section,
                                contents, relocs, local_syms, local_sections)
@@ -1125 +1858 @@
      asection **local_sections;
 {
-  bfd *dynobj;
+  struct elf64_x86_64_link_hash_table *htab;
   Elf_Internal_Shdr *symtab_hdr;
   struct elf_link_hash_entry **sym_hashes;
   bfd_vma *local_got_offsets;
-  asection *sgot;
-  asection *splt;
-  asection *sreloc;
-  Elf_Internal_Rela *rela;
+  Elf_Internal_Rela *rel;
   Elf_Internal_Rela *relend;
 
-  dynobj = elf_hash_table (info)->dynobj;
+  if (info->relocateable)
+    return TRUE;
+
+  htab = elf64_x86_64_hash_table (info);
   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
   sym_hashes = elf_sym_hashes (input_bfd);
   local_got_offsets = elf_local_got_offsets (input_bfd);
 
-  sreloc = splt = sgot = NULL;
-  if (dynobj != NULL)
-    {
-      splt = bfd_get_section_by_name (dynobj, ".plt");
-      sgot = bfd_get_section_by_name (dynobj, ".got");
-    }
-
-  rela = relocs;
+  rel = relocs;
   relend = relocs + input_section->reloc_count;
-  for (; rela < relend; rela++)
-    {
-      int r_type;
+  for (; rel < relend; rel++)
+    {
+      unsigned int r_type;
       reloc_howto_type *howto;
       unsigned long r_symndx;
@@ -1157 +1883 @@
       Elf_Internal_Sym *sym;
       asection *sec;
+      bfd_vma off;
       bfd_vma relocation;
+      bfd_boolean unresolved_reloc;
       bfd_reloc_status_type r;
-      unsigned int indx;
-
-      r_type = ELF64_R_TYPE (rela->r_info);
-
-      if ((indx = (unsigned) r_type) >= R_X86_64_max)
+      int tls_type;
+
+      r_type = ELF64_R_TYPE (rel->r_info);
+      if (r_type == (int) R_X86_64_GNU_VTINHERIT
+          || r_type == (int) R_X86_64_GNU_VTENTRY)
+        continue;
+
+      if (r_type >= R_X86_64_max)
         {
           bfd_set_error (bfd_error_bad_value);
-          return false;
-        }
-      howto = x86_64_elf_howto_table + indx;
-
-      r_symndx = ELF64_R_SYM (rela->r_info);
-
-      if (info->relocateable)
-        {
-          /* This is a relocateable link.  We don't have to change
-             anything, unless the reloc is against a section symbol,
-             in which case we have to adjust according to where the
-             section symbol winds up in the output section.  */
-          if (r_symndx < symtab_hdr->sh_info)
-            {
-              sym = local_syms + r_symndx;
-              if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
-                {
-                  sec = local_sections[r_symndx];
-                  rela->r_addend += sec->output_offset + sym->st_value;
-                }
-            }
-
-          continue;
-        }
-
-      /* This is a final link.  */
+          return FALSE;
+        }
+
+      howto = x86_64_elf_howto_table + r_type;
+      r_symndx = ELF64_R_SYM (rel->r_info);
       h = NULL;
       sym = NULL;
       sec = NULL;
+      unresolved_reloc = FALSE;
       if (r_symndx < symtab_hdr->sh_info)
         {
           sym = local_syms + r_symndx;
           sec = local_sections[r_symndx];
-          relocation = (sec->output_section->vma
-                        + sec->output_offset
-                        + sym->st_value);
+
+          relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
         }
       else
@@ -1209 +1919 @@
                  || 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;
-              if ((r_type == R_X86_64_PLT32
-                   && splt != NULL
-                   && h->plt.offset != (bfd_vma) -1)
-                  || ((r_type == R_X86_64_GOT32 || r_type == R_X86_64_GOTPCREL)
-                      && elf_hash_table (info)->dynamic_sections_created
-                      && (!info->shared
-                          || (! info->symbolic && h->dynindx != -1)
-                          || (h->elf_link_hash_flags
-                              & ELF_LINK_HASH_DEF_REGULAR) == 0))
-                  || (info->shared
-                      && ((! info->symbolic && h->dynindx != -1)
-                          || (h->elf_link_hash_flags
-                              & ELF_LINK_HASH_DEF_REGULAR) == 0)
-                      && (r_type == R_X86_64_8
-                          || r_type == R_X86_64_16
-                          || r_type == R_X86_64_32
-                          || r_type == R_X86_64_64
-                          || r_type == R_X86_64_PC8
-                          || r_type == R_X86_64_PC16
-                          || r_type == R_X86_64_PC32)
-                      && ((input_section->flags & SEC_ALLOC) != 0
-                          /* DWARF will emit R_X86_64_32 relocations in its
-                             sections against symbols defined externally
-                             in shared libraries.  We can't do anything
-                             with them here.  */
-                          || ((input_section->flags & SEC_DEBUGGING) != 0
-                              && (h->elf_link_hash_flags
-                                  & ELF_LINK_HASH_DEF_DYNAMIC) != 0))))
+              if (sec->output_section == NULL)
                 {
-                  /* In these cases, we don't need the relocation
-                     value.  We check specially because in some
-                     obscure cases sec->output_section will be NULL.  */
-                  relocation = 0;
-                }
-              else if (sec->output_section == NULL)
-                {
-                  (*_bfd_error_handler)
-                    (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
-                     bfd_get_filename (input_bfd), h->root.root.string,
-                     bfd_get_section_name (input_bfd, input_section));
+                  /* Set a flag that will be cleared later if we find a
+                     relocation value for this symbol.  output_section
+                     is typically NULL for symbols satisfied by a shared
+                     library.  */
+                  unresolved_reloc = TRUE;
                   relocation = 0;
                 }
@@ -1262 +1940 @@
           else if (h->root.type == bfd_link_hash_undefweak)
             relocation = 0;
-          else if (info->shared && !info->symbolic && !info->no_undefined
+          else if (info->shared
+                   && !info->no_undefined
                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
             relocation = 0;
@@ -1269 +1948 @@
               if (! ((*info->callbacks->undefined_symbol)
                      (info, h->root.root.string, input_bfd,
-                      input_section, rela->r_offset,
+                      input_section, rel->r_offset,
                       (!info->shared || info->no_undefined
                        || ELF_ST_VISIBILITY (h->other)))))
-                return false;
+                return FALSE;
               relocation = 0;
             }
         }
-
       /* When generating a shared object, the relocations handled here are
          copied into the output file to be resolved at run time.  */
@@ -1286 +1964 @@
         case R_X86_64_GOTPCREL:
           /* Use global offset table as symbol value.  */
-          BFD_ASSERT (sgot != NULL);
+          if (htab->sgot == NULL)
+            abort ();
 
           if (h != NULL)
             {
-              bfd_vma off = h->got.offset;
-              BFD_ASSERT (off != (bfd_vma) -1);
-
-              if (! elf_hash_table (info)->dynamic_sections_created
+              bfd_boolean dyn;
+
+              off = h->got.offset;
+              dyn = htab->elf.dynamic_sections_created;
+
+              if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
                   || (info->shared
-                      && (info->symbolic || h->dynindx == -1)
+                      && (info->symbolic
+                          || h->dynindx == -1
+                          || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
                       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
                 {
@@ -1314 +1997 @@
                     {
                       bfd_put_64 (output_bfd, relocation,
-                                  sgot->contents + off);
+                                  htab->sgot->contents + off);
                       h->got.offset |= 1;
                     }
                 }
-              if (r_type == R_X86_64_GOTPCREL)
-                relocation = sgot->output_section->vma + sgot->output_offset + off;
               else
-                relocation = sgot->output_offset + off;
+                unresolved_reloc = FALSE;
             }
           else
             {
-              bfd_vma off;
-
-              BFD_ASSERT (local_got_offsets != NULL
-                          && local_got_offsets[r_symndx] != (bfd_vma) -1);
+              if (local_got_offsets == NULL)
+                abort ();
 
               off = local_got_offsets[r_symndx];
@@ -1339 +2018 @@
               else
                 {
-                  bfd_put_64 (output_bfd, relocation, sgot->contents + off);
+                  bfd_put_64 (output_bfd, relocation,
+                              htab->sgot->contents + off);
 
                   if (info->shared)
                     {
-                      asection *srelgot;
+                      asection *s;
                       Elf_Internal_Rela outrel;
+                      bfd_byte *loc;
 
                       /* We need to generate a R_X86_64_RELATIVE reloc
                          for the dynamic linker.  */
-                      srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
-                      BFD_ASSERT (srelgot != NULL);
-
-                      outrel.r_offset = (sgot->output_section->vma
-                                         + sgot->output_offset
+                      s = htab->srelgot;
+                      if (s == NULL)
+                        abort ();
+
+                      outrel.r_offset = (htab->sgot->output_section->vma
+                                         + htab->sgot->output_offset
                                          + off);
                       outrel.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
                       outrel.r_addend = relocation;
-                      bfd_elf64_swap_reloca_out (output_bfd, &outrel,
-                                                 (((Elf64_External_Rela *)
-                                                   srelgot->contents)
-                                                  + srelgot->reloc_count));
-                      ++srelgot->reloc_count;
+                      loc = s->contents;
+                      loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
+                      bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
                     }
 
                   local_got_offsets[r_symndx] |= 1;
                 }
-
-              if (r_type == R_X86_64_GOTPCREL)
-                relocation = sgot->output_section->vma + sgot->output_offset + off;
-              else
-                relocation = sgot->output_offset + off;
-            }
+            }
+
+          if (off >= (bfd_vma) -2)
+            abort ();
+
+          relocation = htab->sgot->output_offset + off;
+          if (r_type == R_X86_64_GOTPCREL)
+            relocation += htab->sgot->output_section->vma;
 
           break;
@@ -1383 +2065 @@
             break;
 
-          if (h->plt.offset == (bfd_vma) -1 || splt == NULL)
+          if (h->plt.offset == (bfd_vma) -1
+              || htab->splt == NULL)
             {
               /* We didn't make a PLT entry for this symbol.  This
@@ -1391 +2074 @@
             }
 
-          relocation = (splt->output_section->vma
-                        + splt->output_offset
+          relocation = (htab->splt->output_section->vma
+                        + htab->splt->output_offset
                         + h->plt.offset);
+          unresolved_reloc = FALSE;
           break;
 
@@ -1399 +2083 @@
         case R_X86_64_PC16:
         case R_X86_64_PC32:
-          if (h == NULL)
-            break;
-          /* Fall through.  */
         case R_X86_64_8:
         case R_X86_64_16:
@@ -1408 +2089 @@
           /* FIXME: The ABI says the linker should make sure the value is
              the same when it's zeroextended to 64 bit.  */
-          if (info->shared
-              && (input_section->flags & SEC_ALLOC) != 0
-              && ((r_type != R_X86_64_PC8
-                   && r_type != R_X86_64_PC16
-                   && r_type != R_X86_64_PC32)
-                  || (! info->symbolic
-                      || (h->elf_link_hash_flags
-                          & ELF_LINK_HASH_DEF_REGULAR) == 0)))
-
+
+          /* r_symndx will be zero only for relocs against symbols
+             from removed linkonce sections, or sections discarded by
+             a linker script.  */
+          if (r_symndx == 0
+              || (input_section->flags & SEC_ALLOC) == 0)
+            break;
+
+          if ((info->shared
+               && ((r_type != R_X86_64_PC8
+                    && r_type != R_X86_64_PC16
+                    && r_type != R_X86_64_PC32)
+                   || (h != NULL
+                       && h->dynindx != -1
+                       && (! info->symbolic
+                           || (h->elf_link_hash_flags
+                               & ELF_LINK_HASH_DEF_REGULAR) == 0))))
+              || (ELIMINATE_COPY_RELOCS
+                  && !info->shared
+                  && h != NULL
+                  && h->dynindx != -1
+                  && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
+                  && (((h->elf_link_hash_flags
+                        & ELF_LINK_HASH_DEF_DYNAMIC) != 0
+                       && (h->elf_link_hash_flags
+                           & ELF_LINK_HASH_DEF_REGULAR) == 0)
+                      || h->root.type == bfd_link_hash_undefweak
+                      || h->root.type == bfd_link_hash_undefined)))
             {
               Elf_Internal_Rela outrel;
-              boolean skip, relocate;
+              bfd_byte *loc;
+              bfd_boolean skip, relocate;
+              asection *sreloc;
 
               /* When generating a shared object, these relocations
                  are copied into the output file to be resolved at run
                  time.  */
-
-              if (sreloc == NULL)
-                {
-                  const char *name;
-
-                  name = (bfd_elf_string_from_elf_section
-                          (input_bfd,
-                           elf_elfheader (input_bfd)->e_shstrndx,
-                           elf_section_data (input_section)->rel_hdr.sh_name));
-                  if (name == NULL)
-                    return false;
-
-                  BFD_ASSERT (strncmp (name, ".rela", 5) == 0
-                              && strcmp (bfd_get_section_name (input_bfd,
-                                                               input_section),
-                                         name + 5) == 0);
-
-                  sreloc = bfd_get_section_by_name (dynobj, name);
-                  BFD_ASSERT (sreloc != NULL);
-                }
-
-              skip = false;
-
-              if (elf_section_data (input_section)->stab_info == NULL)
-                outrel.r_offset = rela->r_offset;
-              else
-                {
-                  bfd_vma off;
-
-                  off = (_bfd_stab_section_offset
-                         (output_bfd, &elf_hash_table (info)->stab_info,
-                          input_section,
-                          &elf_section_data (input_section)->stab_info,
-                          rela->r_offset));
-                  if (off == (bfd_vma) -1)
-                    skip = true;
-                  outrel.r_offset = off;
-                }
+              skip = FALSE;
+              relocate = FALSE;
+
+              outrel.r_offset =
+                _bfd_elf_section_offset (output_bfd, info, input_section,
+                                         rel->r_offset);
+              if (outrel.r_offset == (bfd_vma) -1)
+                skip = TRUE;
+              else if (outrel.r_offset == (bfd_vma) -2)
+                skip = TRUE, relocate = TRUE;
 
               outrel.r_offset += (input_section->output_section->vma
@@ -1467 +2141 @@
 
               if (skip)
-                {
-                  memset (&outrel, 0, sizeof outrel);
-                  relocate = false;
-                }
+                memset (&outrel, 0, sizeof outrel);
+
               /* h->dynindx may be -1 if this symbol was marked to
                  become local.  */
               else if (h != NULL
-                       && ((! info->symbolic && h->dynindx != -1)
+                       && h->dynindx != -1
+                       && (r_type == R_X86_64_PC8
+                           || r_type == R_X86_64_PC16
+                           || r_type == R_X86_64_PC32
+                           || !info->shared
+                           || !info->symbolic
                            || (h->elf_link_hash_flags
                                & ELF_LINK_HASH_DEF_REGULAR) == 0))
                 {
-                  BFD_ASSERT (h->dynindx != -1);
-                  relocate = false;
                   outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
-                  outrel.r_addend = relocation + rela->r_addend;
+                  outrel.r_addend = rel->r_addend;
                 }
               else
                 {
+                  /* This symbol is local, or marked to become local.  */
                   if (r_type == R_X86_64_64)
                     {
-                      relocate = true;
+                      relocate = TRUE;
                       outrel.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
-                      outrel.r_addend = relocation + rela->r_addend;
+                      outrel.r_addend = relocation + rel->r_addend;
                     }
                   else
                     {
-                      long indx;
+                      long sindx;
 
                       if (h == NULL)
@@ -1505 +2181 @@
                         }
                       if (sec != NULL && bfd_is_abs_section (sec))
-                        indx = 0;
+                        sindx = 0;
                       else if (sec == NULL || sec->owner == NULL)
                         {
                           bfd_set_error (bfd_error_bad_value);
-                          return false;
+                          return FALSE;
                         }
                       else
@@ -1516 +2192 @@
 
                           osec = sec->output_section;
-                          indx = elf_section_data (osec)->dynindx;
-                          BFD_ASSERT (indx > 0);
+                          sindx = elf_section_data (osec)->dynindx;
+                          BFD_ASSERT (sindx > 0);
                         }
 
-                      relocate = false;
-                      outrel.r_info = ELF64_R_INFO (indx, r_type);
-                      outrel.r_addend = relocation + rela->r_addend;
-                    }
-
+                      outrel.r_info = ELF64_R_INFO (sindx, r_type);
+                      outrel.r_addend = relocation + rel->r_addend;
+                    }
                 }
 
-              bfd_elf64_swap_reloca_out (output_bfd, &outrel,
-                                        (((Elf64_External_Rela *)
-                                          sreloc->contents)
-                                         + sreloc->reloc_count));
-              ++sreloc->reloc_count;
+              sreloc = elf_section_data (input_section)->sreloc;
+              if (sreloc == NULL)
+                abort ();
+
+              loc = sreloc->contents;
+              loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
+              bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
 
               /* If this reloc is against an external symbol, we do
@@ -1543 +2219 @@
           break;
 
+        case R_X86_64_TLSGD:
+        case R_X86_64_GOTTPOFF:
+          r_type = elf64_x86_64_tls_transition (info, r_type, h == NULL);
+          tls_type = GOT_UNKNOWN;
+          if (h == NULL && local_got_offsets)
+            tls_type = elf64_x86_64_local_got_tls_type (input_bfd) [r_symndx];
+          else if (h != NULL)
+            {
+              tls_type = elf64_x86_64_hash_entry (h)->tls_type;
+              if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
+                r_type = R_X86_64_TPOFF32;
+            }
+          if (r_type == R_X86_64_TLSGD)
+            {
+              if (tls_type == GOT_TLS_IE)
+                r_type = R_X86_64_GOTTPOFF;
+            }
+
+          if (r_type == R_X86_64_TPOFF32)
+            {
+              BFD_ASSERT (! unresolved_reloc);
+              if (ELF64_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
+                {
+                  unsigned int i;
+                  static unsigned char tlsgd[8]
+                    = { 0x66, 0x48, 0x8d, 0x3d, 0x66, 0x66, 0x48, 0xe8 };
+
+                  /* GD->LE transition.
+                     .byte 0x66; leaq foo@tlsgd(%rip), %rdi
+                     .word 0x6666; rex64; call __tls_get_addr@plt
+                     Change it into:
+                     movq %fs:0, %rax
+                     leaq foo@tpoff(%rax), %rax */
+                  BFD_ASSERT (rel->r_offset >= 4);
+                  for (i = 0; i < 4; i++)
+                    BFD_ASSERT (bfd_get_8 (input_bfd,
+                                           contents + rel->r_offset - 4 + i)
+                                == tlsgd[i]);
+                  BFD_ASSERT (rel->r_offset + 12 <= input_section->_raw_size);
+                  for (i = 0; i < 4; i++)
+                    BFD_ASSERT (bfd_get_8 (input_bfd,
+                                           contents + rel->r_offset + 4 + i)
+                                == tlsgd[i+4]);
+                  BFD_ASSERT (rel + 1 < relend);
+                  BFD_ASSERT (ELF64_R_TYPE (rel[1].r_info) == R_X86_64_PLT32);
+                  memcpy (contents + rel->r_offset - 4,
+                          "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
+                          16);
+                  bfd_put_32 (output_bfd, tpoff (info, relocation),
+                              contents + rel->r_offset + 8);
+                  /* Skip R_X86_64_PLT32.  */
+                  rel++;
+                  continue;
+                }
+              else
+                {
+                  unsigned int val, type, reg;
+
+                  /* IE->LE transition:
+                     Originally it can be one of:
+                     movq foo@gottpoff(%rip), %reg
+                     addq foo@gottpoff(%rip), %reg
+                     We change it into:
+                     movq $foo, %reg
+                     leaq foo(%reg), %reg
+                     addq $foo, %reg.  */
+                  BFD_ASSERT (rel->r_offset >= 3);
+                  val = bfd_get_8 (input_bfd, contents + rel->r_offset - 3);
+                  BFD_ASSERT (val == 0x48 || val == 0x4c);
+                  type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
+                  BFD_ASSERT (type == 0x8b || type == 0x03);
+                  reg = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
+                  BFD_ASSERT ((reg & 0xc7) == 5);
+                  reg >>= 3;
+                  BFD_ASSERT (rel->r_offset + 4 <= input_section->_raw_size);
+                  if (type == 0x8b)
+                    {
+                      /* movq */
+                      if (val == 0x4c)
+                        bfd_put_8 (output_bfd, 0x49,
+                                   contents + rel->r_offset - 3);
+                      bfd_put_8 (output_bfd, 0xc7,
+                                 contents + rel->r_offset - 2);
+                      bfd_put_8 (output_bfd, 0xc0 | reg,
+                                 contents + rel->r_offset - 1);
+                    }
+                  else if (reg == 4)
+                    {
+                      /* addq -> addq - addressing with %rsp/%r12 is
+                         special  */
+                      if (val == 0x4c)
+                        bfd_put_8 (output_bfd, 0x49,
+                                   contents + rel->r_offset - 3);
+                      bfd_put_8 (output_bfd, 0x81,
+                                 contents + rel->r_offset - 2);
+                      bfd_put_8 (output_bfd, 0xc0 | reg,
+                                 contents + rel->r_offset - 1);
+                    }
+                  else
+                    {
+                      /* addq -> leaq */
+                      if (val == 0x4c)
+                        bfd_put_8 (output_bfd, 0x4d,
+                                   contents + rel->r_offset - 3);
+                      bfd_put_8 (output_bfd, 0x8d,
+                                 contents + rel->r_offset - 2);
+                      bfd_put_8 (output_bfd, 0x80 | reg | (reg << 3),
+                                 contents + rel->r_offset - 1);
+                    }
+                  bfd_put_32 (output_bfd, tpoff (info, relocation),
+                              contents + rel->r_offset);
+                  continue;
+                }
+            }
+
+          if (htab->sgot == NULL)
+            abort ();
+
+          if (h != NULL)
+            off = h->got.offset;
+          else
+            {
+              if (local_got_offsets == NULL)
+                abort ();
+
+              off = local_got_offsets[r_symndx];
+            }
+
+          if ((off & 1) != 0)
+            off &= ~1;
+          else
+            {
+              Elf_Internal_Rela outrel;
+              bfd_byte *loc;
+              int dr_type, indx;
+
+              if (htab->srelgot == NULL)
+                abort ();
+
+              outrel.r_offset = (htab->sgot->output_section->vma
+                                 + htab->sgot->output_offset + off);
+
+              indx = h && h->dynindx != -1 ? h->dynindx : 0;
+              if (r_type == R_X86_64_TLSGD)
+                dr_type = R_X86_64_DTPMOD64;
+              else
+                dr_type = R_X86_64_TPOFF64;
+
+              bfd_put_64 (output_bfd, 0, htab->sgot->contents + off);
+              outrel.r_addend = 0;
+              if (dr_type == R_X86_64_TPOFF64 && indx == 0)
+                outrel.r_addend = relocation - dtpoff_base (info);
+              outrel.r_info = ELF64_R_INFO (indx, dr_type);
+
+              loc = htab->srelgot->contents;
+              loc += htab->srelgot->reloc_count++ * sizeof (Elf64_External_Rela);
+              bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
+
+              if (r_type == R_X86_64_TLSGD)
+                {
+                  if (indx == 0)
+                    {
+                      BFD_ASSERT (! unresolved_reloc);
+                      bfd_put_64 (output_bfd,
+                                  relocation - dtpoff_base (info),
+                                  htab->sgot->contents + off + GOT_ENTRY_SIZE);
+                    }
+                  else
+                    {
+                      bfd_put_64 (output_bfd, 0,
+                                  htab->sgot->contents + off + GOT_ENTRY_SIZE);
+                      outrel.r_info = ELF64_R_INFO (indx,
+                                                    R_X86_64_DTPOFF64);
+                      outrel.r_offset += GOT_ENTRY_SIZE;
+                      htab->srelgot->reloc_count++;
+                      loc += sizeof (Elf64_External_Rela);
+                      bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
+                    }
+                }
+
+              if (h != NULL)
+                h->got.offset |= 1;
+              else
+                local_got_offsets[r_symndx] |= 1;
+            }
+
+          if (off >= (bfd_vma) -2)
+            abort ();
+          if (r_type == ELF64_R_TYPE (rel->r_info))
+            {
+              relocation = htab->sgot->output_section->vma
+                           + htab->sgot->output_offset + off;
+              unresolved_reloc = FALSE;
+            }
+          else
+            {
+              unsigned int i;
+              static unsigned char tlsgd[8]
+                = { 0x66, 0x48, 0x8d, 0x3d, 0x66, 0x66, 0x48, 0xe8 };
+
+              /* GD->IE transition.
+                 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
+                 .word 0x6666; rex64; call __tls_get_addr@plt
+                 Change it into:
+                 movq %fs:0, %rax
+                 addq foo@gottpoff(%rip), %rax */
+              BFD_ASSERT (rel->r_offset >= 4);
+              for (i = 0; i < 4; i++)
+                BFD_ASSERT (bfd_get_8 (input_bfd,
+                                       contents + rel->r_offset - 4 + i)
+                            == tlsgd[i]);
+              BFD_ASSERT (rel->r_offset + 12 <= input_section->_raw_size);
+              for (i = 0; i < 4; i++)
+                BFD_ASSERT (bfd_get_8 (input_bfd,
+                                       contents + rel->r_offset + 4 + i)
+                            == tlsgd[i+4]);
+              BFD_ASSERT (rel + 1 < relend);
+              BFD_ASSERT (ELF64_R_TYPE (rel[1].r_info) == R_X86_64_PLT32);
+              memcpy (contents + rel->r_offset - 4,
+                      "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
+                      16);
+
+              relocation = (htab->sgot->output_section->vma
+                            + htab->sgot->output_offset + off
+                            - rel->r_offset
+                            - input_section->output_section->vma
+                            - input_section->output_offset
+                            - 12);
+              bfd_put_32 (output_bfd, relocation,
+                          contents + rel->r_offset + 8);
+              /* Skip R_X86_64_PLT32.  */
+              rel++;
+              continue;
+            }
+          break;
+
+        case R_X86_64_TLSLD:
+          if (! info->shared)
+            {
+              /* LD->LE transition:
+                 Ensure it is:
+                 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr@plt.
+                 We change it into:
+                 .word 0x6666; .byte 0x66; movl %fs:0, %rax.  */
+              BFD_ASSERT (rel->r_offset >= 3);
+              BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 3)
+                          == 0x48);
+              BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 2)
+                          == 0x8d);
+              BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 1)
+                          == 0x3d);
+              BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
+              BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
+                          == 0xe8);
+              BFD_ASSERT (rel + 1 < relend);
+              BFD_ASSERT (ELF64_R_TYPE (rel[1].r_info) == R_X86_64_PLT32);
+              memcpy (contents + rel->r_offset - 3,
+                      "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
+              /* Skip R_X86_64_PLT32.  */
+              rel++;
+              continue;
+            }
+
+          if (htab->sgot == NULL)
+            abort ();
+
+          off = htab->tls_ld_got.offset;
+          if (off & 1)
+            off &= ~1;
+          else
+            {
+              Elf_Internal_Rela outrel;
+              bfd_byte *loc;
+
+              if (htab->srelgot == NULL)
+                abort ();
+
+              outrel.r_offset = (htab->sgot->output_section->vma
+                                 + htab->sgot->output_offset + off);
+
+              bfd_put_64 (output_bfd, 0,
+                          htab->sgot->contents + off);
+              bfd_put_64 (output_bfd, 0,
+                          htab->sgot->contents + off + GOT_ENTRY_SIZE);
+              outrel.r_info = ELF64_R_INFO (0, R_X86_64_DTPMOD64);
+              outrel.r_addend = 0;
+              loc = htab->srelgot->contents;
+              loc += htab->srelgot->reloc_count++ * sizeof (Elf64_External_Rela);
+              bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
+              htab->tls_ld_got.offset |= 1;
+            }
+          relocation = htab->sgot->output_section->vma
+                       + htab->sgot->output_offset + off;
+          unresolved_reloc = FALSE;
+          break;
+
+        case R_X86_64_DTPOFF32:
+          if (info->shared || (input_section->flags & SEC_CODE) == 0)
+            relocation -= dtpoff_base (info);
+          else
+            relocation = tpoff (info, relocation);
+          break;
+
+        case R_X86_64_TPOFF32:
+          BFD_ASSERT (! info->shared);
+          relocation = tpoff (info, relocation);
+          break;
+
         default:
           break;
         }
 
+      /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
+         because such sections are not SEC_ALLOC and thus ld.so will
+         not process them.  */
+      if (unresolved_reloc
+          && !((input_section->flags & SEC_DEBUGGING) != 0
+               && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
+        (*_bfd_error_handler)
+          (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
+           bfd_archive_filename (input_bfd),
+           bfd_get_section_name (input_bfd, input_section),
+           (long) rel->r_offset,
+           h->root.root.string);
+
       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
-                                    contents, rela->r_offset,
-                                    relocation, rela->r_addend);
+                                    contents, rel->r_offset,
+                                    relocation, rel->r_addend);
 
       if (r != bfd_reloc_ok)
         {
-          switch (r)
-            {
-            default:
-            case bfd_reloc_outofrange:
-              abort ();
-            case bfd_reloc_overflow:
-              {
-                const char *name;
-
-                if (h != NULL)
-                  name = h->root.root.string;
-                else
-                  {
-                    name = bfd_elf_string_from_elf_section (input_bfd,
-                                                            symtab_hdr->sh_link,
-                                                            sym->st_name);
-                    if (name == NULL)
-                      return false;
-                    if (*name == '\0')
-                      name = bfd_section_name (input_bfd, sec);
-                  }
-                if (! ((*info->callbacks->reloc_overflow)
-                       (info, name, howto->name, (bfd_vma) 0,
-                        input_bfd, input_section, rela->r_offset)))
-                  return false;
-              }
-              break;
-            }
-        }
-    }
-
-  return true;
+          const char *name;
+
+          if (h != NULL)
+            name = h->root.root.string;
+          else
+            {
+              name = bfd_elf_string_from_elf_section (input_bfd,
+                                                      symtab_hdr->sh_link,
+                                                      sym->st_name);
+              if (name == NULL)
+                return FALSE;
+              if (*name == '\0')
+                name = bfd_section_name (input_bfd, sec);
+            }
+
+          if (r == bfd_reloc_overflow)
+            {
+
+              if (! ((*info->callbacks->reloc_overflow)
+                     (info, name, howto->name, (bfd_vma) 0,
+                      input_bfd, input_section, rel->r_offset)))
+                return FALSE;
+            }
+          else
+            {
+              (*_bfd_error_handler)
+                (_("%s(%s+0x%lx): reloc against `%s': error %d"),
+                 bfd_archive_filename (input_bfd),
+                 bfd_get_section_name (input_bfd, input_section),
+                 (long) rel->r_offset, name, (int) r);
+              return FALSE;
+            }
+        }
+    }
+
+  return TRUE;
 }
 
@@ -1590 +2591 @@
    dynamic sections here.  */
 
-static boolean
+static bfd_boolean
 elf64_x86_64_finish_dynamic_symbol (output_bfd, info, h, sym)
      bfd *output_bfd;
@@ -1597 +2598 @@
      Elf_Internal_Sym *sym;
 {
-  bfd *dynobj;
-
-  dynobj = elf_hash_table (info)->dynobj;
+  struct elf64_x86_64_link_hash_table *htab;
+
+  htab = elf64_x86_64_hash_table (info);
 
   if (h->plt.offset != (bfd_vma) -1)
     {
-      asection *splt;
-      asection *sgot;
-      asection *srela;
       bfd_vma plt_index;
       bfd_vma got_offset;
       Elf_Internal_Rela rela;
+      bfd_byte *loc;
 
       /* This symbol has an entry in the procedure linkage table.  Set
          it up.  */
-
-      BFD_ASSERT (h->dynindx != -1);
-
-      splt = bfd_get_section_by_name (dynobj, ".plt");
-      sgot = bfd_get_section_by_name (dynobj, ".got.plt");
-      srela = bfd_get_section_by_name (dynobj, ".rela.plt");
-      BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
+      if (h->dynindx == -1
+          || htab->splt == NULL
+          || htab->sgotplt == NULL
+          || htab->srelplt == NULL)
+        abort ();
 
       /* Get the index in the procedure linkage table which
@@ -1632 +2629 @@
 
       /* Fill in the entry in the procedure linkage table.  */
-      memcpy (splt->contents + h->plt.offset, elf64_x86_64_plt_entry,
+      memcpy (htab->splt->contents + h->plt.offset, elf64_x86_64_plt_entry,
               PLT_ENTRY_SIZE);
 
@@ -1641 +2638 @@
          instruction uses 6 bytes, subtract this value.  */
       bfd_put_32 (output_bfd,
-                      (sgot->output_section->vma
-                       + sgot->output_offset
+                      (htab->sgotplt->output_section->vma
+                       + htab->sgotplt->output_offset
                        + got_offset
-                       - splt->output_section->vma
-                       - splt->output_offset
+                       - htab->splt->output_section->vma
+                       - htab->splt->output_offset
                        - h->plt.offset
                        - 6),
-                  splt->contents + h->plt.offset + 2);
+                  htab->splt->contents + h->plt.offset + 2);
       /* Put relocation index.  */
       bfd_put_32 (output_bfd, plt_index,
-                  splt->contents + h->plt.offset + 7);
+                  htab->splt->contents + h->plt.offset + 7);
       /* Put offset for jmp .PLT0.  */
       bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
-                  splt->contents + h->plt.offset + 12);
+                  htab->splt->contents + h->plt.offset + 12);
 
       /* Fill in the entry in the global offset table, initially this
          points to the pushq instruction in the PLT which is at offset 6.  */
-      bfd_put_64 (output_bfd, (splt->output_section->vma + splt->output_offset
+      bfd_put_64 (output_bfd, (htab->splt->output_section->vma
+                               + htab->splt->output_offset
                                + h->plt.offset + 6),
-                  sgot->contents + got_offset);
+                  htab->sgotplt->contents + got_offset);
 
       /* Fill in the entry in the .rela.plt section.  */
-      rela.r_offset = (sgot->output_section->vma
-                       + sgot->output_offset
+      rela.r_offset = (htab->sgotplt->output_section->vma
+                       + htab->sgotplt->output_offset
                        + got_offset);
       rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_JUMP_SLOT);
       rela.r_addend = 0;
-      bfd_elf64_swap_reloca_out (output_bfd, &rela,
-                                 ((Elf64_External_Rela *) srela->contents
-                                  + plt_index));
+      loc = htab->srelplt->contents + plt_index * sizeof (Elf64_External_Rela);
+      bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
 
       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
         {
           /* Mark the symbol as undefined, rather than as defined in
-             the .plt section.  Leave the value alone.  */
+             the .plt section.  Leave the value alone.  This is a clue
+             for the dynamic linker, to make function pointer
+             comparisons work between an application and shared
+             library.  */
           sym->st_shndx = SHN_UNDEF;
-          /* If the symbol is weak, we do need to clear the value.
-             Otherwise, the PLT entry would provide a definition for
-             the symbol even if the symbol wasn't defined anywhere,
-             and so the symbol would never be NULL.  */
-          if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
-              == 0)
-            sym->st_value = 0;
-        }
-    }
-
-  if (h->got.offset != (bfd_vma) -1)
-    {
-      asection *sgot;
-      asection *srela;
+        }
+    }
+
+  if (h->got.offset != (bfd_vma) -1
+      && elf64_x86_64_hash_entry (h)->tls_type != GOT_TLS_GD
+      && elf64_x86_64_hash_entry (h)->tls_type != GOT_TLS_IE)
+    {
       Elf_Internal_Rela rela;
+      bfd_byte *loc;
 
       /* This symbol has an entry in the global offset table.  Set it
-         up.  */
-
-      sgot = bfd_get_section_by_name (dynobj, ".got");
-      srela = bfd_get_section_by_name (dynobj, ".rela.got");
-      BFD_ASSERT (sgot != NULL && srela != NULL);
-
-      rela.r_offset = (sgot->output_section->vma
-                       + sgot->output_offset
-                       + (h->got.offset &~ 1));
+         up.  */
+      if (htab->sgot == NULL || htab->srelgot == NULL)
+        abort ();
+
+      rela.r_offset = (htab->sgot->output_section->vma
+                       + htab->sgot->output_offset
+                       + (h->got.offset &~ (bfd_vma) 1));
 
       /* If this is a static link, or it is a -Bsymbolic link and the
@@ -1709 +2701 @@
          The entry in the global offset table will already have been
          initialized in the relocate_section function.  */
-      if (! elf_hash_table (info)->dynamic_sections_created
-          || (info->shared
-              && (info->symbolic || h->dynindx == -1)
-              && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
+      if (info->shared
+          && (info->symbolic
+              || h->dynindx == -1
+              || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
+          && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
         {
           BFD_ASSERT((h->got.offset & 1) != 0);
@@ -1723 +2716 @@
         {
           BFD_ASSERT((h->got.offset & 1) == 0);
-          bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
+          bfd_put_64 (output_bfd, (bfd_vma) 0,
+                      htab->sgot->contents + h->got.offset);
           rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_GLOB_DAT);
           rela.r_addend = 0;
         }
 
-      bfd_elf64_swap_reloca_out (output_bfd, &rela,
-                                 ((Elf64_External_Rela *) srela->contents
-                                  + srela->reloc_count));
-      ++srela->reloc_count;
+      loc = htab->srelgot->contents;
+      loc += htab->srelgot->reloc_count++ * sizeof (Elf64_External_Rela);
+      bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
     }
 
   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
     {
-      asection *s;
       Elf_Internal_Rela rela;
+      bfd_byte *loc;
 
       /* This symbol needs a copy reloc.  Set it up.  */
 
-      BFD_ASSERT (h->dynindx != -1
-                  && (h->root.type == bfd_link_hash_defined
-                      || h->root.type == bfd_link_hash_defweak));
-
-      s = bfd_get_section_by_name (h->root.u.def.section->owner,
-                                   ".rela.bss");
-      BFD_ASSERT (s != NULL);
+      if (h->dynindx == -1
+          || (h->root.type != bfd_link_hash_defined
+              && h->root.type != bfd_link_hash_defweak)
+          || htab->srelbss == NULL)
+        abort ();
 
       rela.r_offset = (h->root.u.def.value
@@ -1754 +2745 @@
       rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_COPY);
       rela.r_addend = 0;
-      bfd_elf64_swap_reloca_out (output_bfd, &rela,
-                                 ((Elf64_External_Rela *) s->contents
-                                  + s->reloc_count));
-      ++s->reloc_count;
+      loc = htab->srelbss->contents;
+      loc += htab->srelbss->reloc_count++ * sizeof (Elf64_External_Rela);
+      bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
     }
 
@@ -1765 +2755 @@
     sym->st_shndx = SHN_ABS;
 
-  return true;
+  return TRUE;
 }
 
+/* Used to decide how to sort relocs in an optimal manner for the
+   dynamic linker, before writing them out.  */
+
+static enum elf_reloc_type_class
+elf64_x86_64_reloc_type_class (rela)
+     const Elf_Internal_Rela *rela;
+{
+  switch ((int) ELF64_R_TYPE (rela->r_info))
+    {
+    case R_X86_64_RELATIVE:
+      return reloc_class_relative;
+    case R_X86_64_JUMP_SLOT:
+      return reloc_class_plt;
+    case R_X86_64_COPY:
+      return reloc_class_copy;
+    default:
+      return reloc_class_normal;
+    }
+}
+
 /* Finish up the dynamic sections.  */
 
-static boolean
+static bfd_boolean
 elf64_x86_64_finish_dynamic_sections (output_bfd, info)
      bfd *output_bfd;
      struct bfd_link_info *info;
 {
+  struct elf64_x86_64_link_hash_table *htab;
   bfd *dynobj;
   asection *sdyn;
-  asection *sgot;
-
-  dynobj = elf_hash_table (info)->dynobj;
-
-  sgot = bfd_get_section_by_name (dynobj, ".got.plt");
-  BFD_ASSERT (sgot != NULL);
+
+  htab = elf64_x86_64_hash_table (info);
+  dynobj = htab->elf.dynobj;
   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
 
-  if (elf_hash_table (info)->dynamic_sections_created)
-    {
-      asection *splt;
+  if (htab->elf.dynamic_sections_created)
+    {
       Elf64_External_Dyn *dyncon, *dynconend;
 
-      BFD_ASSERT (sdyn != NULL);
+      if (sdyn == NULL || htab->sgot == NULL)
+        abort ();
 
       dyncon = (Elf64_External_Dyn *) sdyn->contents;
@@ -1797 +2805 @@
         {
           Elf_Internal_Dyn dyn;
-          const char *name;
           asection *s;
 
@@ -1808 +2815 @@
 
             case DT_PLTGOT:
-              name = ".got";
-              goto get_vma;
+              dyn.d_un.d_ptr = htab->sgot->output_section->vma;
+              break;
 
             case DT_JMPREL:
-              name = ".rela.plt";
-
-            get_vma:
-              s = bfd_get_section_by_name (output_bfd, name);
-              BFD_ASSERT (s != NULL);
-              dyn.d_un.d_ptr = s->vma;
+              dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
               break;
 
+            case DT_PLTRELSZ:
+              s = htab->srelplt->output_section;
+              if (s->_cooked_size != 0)
+                dyn.d_un.d_val = s->_cooked_size;
+              else
+                dyn.d_un.d_val = s->_raw_size;
+              break;
+
             case DT_RELASZ:
-              /* FIXME: This comment and code is from elf64-alpha.c:  */
-              /* My interpretation of the TIS v1.1 ELF document indicates
-                 that RELASZ should not include JMPREL.  This is not what
-                 the rest of the BFD does.  It is, however, what the
-                 glibc ld.so wants.  Do this fixup here until we found
-                 out who is right.  */
-              s = bfd_get_section_by_name (output_bfd, ".rela.plt");
-              if (s)
+              /* The procedure linkage table relocs (DT_JMPREL) should
+                 not be included in the overall relocs (DT_RELA).
+                 Therefore, we override the DT_RELASZ entry here to
+                 make it not include the JMPREL relocs.  Since the
+                 linker script arranges for .rela.plt to follow all
+                 other relocation sections, we don't have to worry
+                 about changing the DT_RELA entry.  */
+              if (htab->srelplt != NULL)
                 {
-                  /* Subtract JMPREL size from RELASZ.  */
-                  dyn.d_un.d_val -=
-                    (s->_cooked_size ? s->_cooked_size : s->_raw_size);
+                  s = htab->srelplt->output_section;
+                  if (s->_cooked_size != 0)
+                    dyn.d_un.d_val -= s->_cooked_size;
+                  else
+                    dyn.d_un.d_val -= s->_raw_size;
                 }
               break;
-
-            case DT_PLTRELSZ:
-              s = bfd_get_section_by_name (output_bfd, ".rela.plt");
-              BFD_ASSERT (s != NULL);
-              dyn.d_un.d_val =
-                (s->_cooked_size != 0 ? s->_cooked_size : s->_raw_size);
-              break;
-            }
+            }
+
           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
         }
 
-      /* Initialize the contents of the .plt section.  */
-      splt = bfd_get_section_by_name (dynobj, ".plt");
-      BFD_ASSERT (splt != NULL);
-      if (splt->_raw_size > 0)
+      /* Fill in the special first entry in the procedure linkage table.  */
+      if (htab->splt && htab->splt->_raw_size > 0)
         {
           /* Fill in the first entry in the procedure linkage table.  */
-          memcpy (splt->contents, elf64_x86_64_plt0_entry, PLT_ENTRY_SIZE);
+          memcpy (htab->splt->contents, elf64_x86_64_plt0_entry,
+                  PLT_ENTRY_SIZE);
           /* Add offset for pushq GOT+8(%rip), since the instruction
              uses 6 bytes subtract this value.  */
           bfd_put_32 (output_bfd,
-                      (sgot->output_section->vma
-                       + sgot->output_offset
+                      (htab->sgotplt->output_section->vma
+                       + htab->sgotplt->output_offset
                        + 8
-                       - splt->output_section->vma
-                       - splt->output_offset
+                       - htab->splt->output_section->vma
+                       - htab->splt->output_offset
                        - 6),
-                      splt->contents + 2);
+                      htab->splt->contents + 2);
           /* Add offset for jmp *GOT+16(%rip). The 12 is the offset to
              the end of the instruction.  */
           bfd_put_32 (output_bfd,
-                      (sgot->output_section->vma
-                       + sgot->output_offset
+                      (htab->sgotplt->output_section->vma
+                       + htab->sgotplt->output_offset
                        + 16
-                       - splt->output_section->vma
-                       - splt->output_offset
+                       - htab->splt->output_section->vma
+                       - htab->splt->output_offset
                        - 12),
-                      splt->contents + 8);
-
-        }
-
-      elf_section_data (splt->output_section)->this_hdr.sh_entsize =
-        PLT_ENTRY_SIZE;
-    }
-
-  /* Set the first entry in the global offset table to the address of
-     the dynamic section.  */
-  if (sgot->_raw_size > 0)
-    {
-      if (sdyn == NULL)
-        bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents);
-      else
-        bfd_put_64 (output_bfd,
-                    sdyn->output_section->vma + sdyn->output_offset,
-                    sgot->contents);
-      /* Write GOT[1] and GOT[2], needed for the dynamic linker.  */
-      bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + GOT_ENTRY_SIZE);
-      bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + GOT_ENTRY_SIZE*2);
-    }
-
-  elf_section_data (sgot->output_section)->this_hdr.sh_entsize =
-    GOT_ENTRY_SIZE;
-
-  return true;
+                      htab->splt->contents + 8);
+
+          elf_section_data (htab->splt->output_section)->this_hdr.sh_entsize =
+            PLT_ENTRY_SIZE;
+        }
+    }
+
+  if (htab->sgotplt)
+    {
+      /* Fill in the first three entries in the global offset table.  */
+      if (htab->sgotplt->_raw_size > 0)
+        {
+          /* Set the first entry in the global offset table to the address of
+             the dynamic section.  */
+          if (sdyn == NULL)
+            bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents);
+          else
+            bfd_put_64 (output_bfd,
+                        sdyn->output_section->vma + sdyn->output_offset,
+                        htab->sgotplt->contents);
+          /* Write GOT[1] and GOT[2], needed for the dynamic linker.  */
+          bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + GOT_ENTRY_SIZE);
+          bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + GOT_ENTRY_SIZE*2);
+        }
+
+      elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize =
+        GOT_ENTRY_SIZE;
+    }
+
+  return TRUE;
 }
 
@@ -1909 +2917 @@
 
 #define elf_backend_can_gc_sections         1
+#define elf_backend_can_refcount            1
 #define elf_backend_want_got_plt            1
 #define elf_backend_plt_readonly            1
@@ -1914 +2923 @@
 #define elf_backend_got_header_size         (GOT_ENTRY_SIZE*3)
 #define elf_backend_plt_header_size         PLT_ENTRY_SIZE
+#define elf_backend_rela_normal             1
 
 #define elf_info_to_howto                   elf64_x86_64_info_to_howto
 
-#define bfd_elf64_bfd_final_link            _bfd_elf64_gc_common_final_link
 #define bfd_elf64_bfd_link_hash_table_create \
   elf64_x86_64_link_hash_table_create
@@ -1924 +2933 @@
 #define elf_backend_adjust_dynamic_symbol   elf64_x86_64_adjust_dynamic_symbol
 #define elf_backend_check_relocs            elf64_x86_64_check_relocs
-#define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
-#define elf_backend_finish_dynamic_sections \
-  elf64_x86_64_finish_dynamic_sections
+#define elf_backend_copy_indirect_symbol    elf64_x86_64_copy_indirect_symbol
+#define elf_backend_create_dynamic_sections elf64_x86_64_create_dynamic_sections
+#define elf_backend_finish_dynamic_sections elf64_x86_64_finish_dynamic_sections
 #define elf_backend_finish_dynamic_symbol   elf64_x86_64_finish_dynamic_symbol
 #define elf_backend_gc_mark_hook            elf64_x86_64_gc_mark_hook
 #define elf_backend_gc_sweep_hook           elf64_x86_64_gc_sweep_hook
+#define elf_backend_grok_prstatus           elf64_x86_64_grok_prstatus
+#define elf_backend_grok_psinfo             elf64_x86_64_grok_psinfo
+#define elf_backend_reloc_type_class        elf64_x86_64_reloc_type_class
 #define elf_backend_relocate_section        elf64_x86_64_relocate_section
 #define elf_backend_size_dynamic_sections   elf64_x86_64_size_dynamic_sections
 #define elf_backend_object_p                elf64_x86_64_elf_object_p
+#define bfd_elf64_mkobject                  elf64_x86_64_mkobject
 
 #include "elf64-target.h"