Changeset 609 for branches/GNU/src/binutils/bfd/elf64-alpha.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-alpha.c (modified) (179 diffs, 1 prop)

branches/GNU/src/binutils/bfd/elf64-alpha.c

@@ -1 +1 @@
 /* Alpha specific support for 64-bit ELF
-   Copyright 1996, 1997, 1998, 1999, 2000, 2001
+   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
    Free Software Foundation, Inc.
    Contributed by Richard Henderson <rth@tamu.edu>.
 
-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.  */
 
 /* We need a published ABI spec for this.  Until one comes out, don't
@@ -49 +49 @@
 
 static int alpha_elf_dynamic_symbol_p
-  PARAMS((struct elf_link_hash_entry *, struct bfd_link_info *));
+  PARAMS ((struct elf_link_hash_entry *, struct bfd_link_info *));
 static struct bfd_hash_entry * elf64_alpha_link_hash_newfunc
-  PARAMS((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
+  PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
 static struct bfd_link_hash_table * elf64_alpha_bfd_link_hash_table_create
-  PARAMS((bfd *));
+  PARAMS ((bfd *));
 
 static bfd_reloc_status_type elf64_alpha_reloc_nil
-  PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
+  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 static bfd_reloc_status_type elf64_alpha_reloc_bad
-  PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
+  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 static bfd_reloc_status_type elf64_alpha_do_reloc_gpdisp
-  PARAMS((bfd *, bfd_vma, bfd_byte *, bfd_byte *));
+  PARAMS ((bfd *, bfd_vma, bfd_byte *, bfd_byte *));
 static bfd_reloc_status_type elf64_alpha_reloc_gpdisp
-  PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
+  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 
 static reloc_howto_type * elf64_alpha_bfd_reloc_type_lookup
-  PARAMS((bfd *, bfd_reloc_code_real_type));
+  PARAMS ((bfd *, bfd_reloc_code_real_type));
 static void elf64_alpha_info_to_howto
-  PARAMS((bfd *, arelent *, Elf64_Internal_Rela *));
-
-static boolean elf64_alpha_mkobject
-  PARAMS((bfd *));
-static boolean elf64_alpha_object_p
-  PARAMS((bfd *));
-static boolean elf64_alpha_section_from_shdr
-  PARAMS((bfd *, Elf64_Internal_Shdr *, char *));
-static boolean elf64_alpha_fake_sections
-  PARAMS((bfd *, Elf64_Internal_Shdr *, asection *));
-static boolean elf64_alpha_create_got_section
-  PARAMS((bfd *, struct bfd_link_info *));
-static boolean elf64_alpha_create_dynamic_sections
-  PARAMS((bfd *, struct bfd_link_info *));
-
-static boolean elf64_alpha_read_ecoff_info
-  PARAMS((bfd *, asection *, struct ecoff_debug_info *));
-static boolean elf64_alpha_is_local_label_name
-  PARAMS((bfd *, const char *));
-static boolean elf64_alpha_find_nearest_line
-  PARAMS((bfd *, asection *, asymbol **, bfd_vma, const char **,
-          const char **, unsigned int *));
+  PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
+
+static bfd_boolean elf64_alpha_mkobject
+  PARAMS ((bfd *));
+static bfd_boolean elf64_alpha_object_p
+  PARAMS ((bfd *));
+static bfd_boolean elf64_alpha_section_from_shdr
+  PARAMS ((bfd *, Elf_Internal_Shdr *, const char *));
+static bfd_boolean elf64_alpha_section_flags
+  PARAMS ((flagword *, Elf_Internal_Shdr *));
+static bfd_boolean elf64_alpha_fake_sections
+  PARAMS ((bfd *, Elf_Internal_Shdr *, asection *));
+static bfd_boolean elf64_alpha_create_got_section
+  PARAMS ((bfd *, struct bfd_link_info *));
+static bfd_boolean elf64_alpha_create_dynamic_sections
+  PARAMS ((bfd *, struct bfd_link_info *));
+
+static bfd_boolean elf64_alpha_read_ecoff_info
+  PARAMS ((bfd *, asection *, struct ecoff_debug_info *));
+static bfd_boolean elf64_alpha_is_local_label_name
+  PARAMS ((bfd *, const char *));
+static bfd_boolean elf64_alpha_find_nearest_line
+  PARAMS ((bfd *, asection *, asymbol **, bfd_vma, const char **,
+           const char **, unsigned int *));
 
 #if defined(__STDC__) || defined(ALMOST_STDC)
@@ -94 +96 @@
 #endif
 
-static boolean elf64_alpha_output_extsym
-  PARAMS((struct alpha_elf_link_hash_entry *, PTR));
-
-static boolean elf64_alpha_can_merge_gots
-  PARAMS((bfd *, bfd *));
+static bfd_boolean elf64_alpha_output_extsym
+  PARAMS ((struct alpha_elf_link_hash_entry *, PTR));
+
+static bfd_boolean elf64_alpha_can_merge_gots
+  PARAMS ((bfd *, bfd *));
 static void elf64_alpha_merge_gots
-  PARAMS((bfd *, bfd *));
-static boolean elf64_alpha_calc_got_offsets_for_symbol
+  PARAMS ((bfd *, bfd *));
+static bfd_boolean elf64_alpha_calc_got_offsets_for_symbol
   PARAMS ((struct alpha_elf_link_hash_entry *, PTR));
-static void elf64_alpha_calc_got_offsets PARAMS ((struct bfd_link_info *));
-static boolean elf64_alpha_size_got_sections
+static void elf64_alpha_calc_got_offsets
+  PARAMS ((struct bfd_link_info *));
+static bfd_boolean elf64_alpha_size_got_sections
+  PARAMS ((struct bfd_link_info *));
+static bfd_boolean elf64_alpha_size_plt_section
+  PARAMS ((struct bfd_link_info *));
+static bfd_boolean elf64_alpha_size_plt_section_1
+  PARAMS ((struct alpha_elf_link_hash_entry *, PTR));
+static bfd_boolean elf64_alpha_always_size_sections
   PARAMS ((bfd *, struct bfd_link_info *));
-static boolean elf64_alpha_always_size_sections
-  PARAMS ((bfd *, struct bfd_link_info *));
-static boolean elf64_alpha_calc_dynrel_sizes
+static int alpha_dynamic_entries_for_reloc
+  PARAMS ((int, int, int));
+static bfd_boolean elf64_alpha_calc_dynrel_sizes
   PARAMS ((struct alpha_elf_link_hash_entry *, struct bfd_link_info *));
-static boolean elf64_alpha_add_symbol_hook
+static bfd_boolean elf64_alpha_size_rela_got_section
+  PARAMS ((struct bfd_link_info *));
+static bfd_boolean elf64_alpha_size_rela_got_1
+  PARAMS ((struct alpha_elf_link_hash_entry *, struct bfd_link_info *));
+static bfd_boolean elf64_alpha_add_symbol_hook
   PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
            const char **, flagword *, asection **, bfd_vma *));
-static boolean elf64_alpha_check_relocs
-  PARAMS((bfd *, struct bfd_link_info *, asection *sec,
+static struct alpha_elf_got_entry *get_got_entry
+  PARAMS ((bfd *, struct alpha_elf_link_hash_entry *, unsigned long,
+           unsigned long, bfd_vma));
+static bfd_boolean elf64_alpha_check_relocs
+  PARAMS ((bfd *, struct bfd_link_info *, asection *sec,
           const Elf_Internal_Rela *));
-static boolean elf64_alpha_adjust_dynamic_symbol
-  PARAMS((struct bfd_link_info *, struct elf_link_hash_entry *));
-static boolean elf64_alpha_size_dynamic_sections
-  PARAMS((bfd *, struct bfd_link_info *));
-static boolean elf64_alpha_relocate_section
-  PARAMS((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
+static bfd_boolean elf64_alpha_adjust_dynamic_symbol
+  PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
+static bfd_boolean elf64_alpha_size_dynamic_sections
+  PARAMS ((bfd *, struct bfd_link_info *));
+static void elf64_alpha_emit_dynrel
+  PARAMS ((bfd *, struct bfd_link_info *, asection *, asection *,
+           bfd_vma, long, long, bfd_vma));
+static bfd_boolean elf64_alpha_relocate_section_r
+  PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
+           Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
+static bfd_boolean elf64_alpha_relocate_section
+  PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
           Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
-static boolean elf64_alpha_finish_dynamic_symbol
-  PARAMS((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
-          Elf_Internal_Sym *));
-static boolean elf64_alpha_finish_dynamic_sections
-  PARAMS((bfd *, struct bfd_link_info *));
-static boolean elf64_alpha_final_link
-  PARAMS((bfd *, struct bfd_link_info *));
-static boolean elf64_alpha_merge_ind_symbols
-  PARAMS((struct alpha_elf_link_hash_entry *, PTR));
+static bfd_boolean elf64_alpha_finish_dynamic_symbol
+  PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
+           Elf_Internal_Sym *));
+static bfd_boolean elf64_alpha_finish_dynamic_sections
+  PARAMS ((bfd *, struct bfd_link_info *));
+static bfd_boolean elf64_alpha_final_link
+  PARAMS ((bfd *, struct bfd_link_info *));
+static bfd_boolean elf64_alpha_merge_ind_symbols
+  PARAMS ((struct alpha_elf_link_hash_entry *, PTR));
 static Elf_Internal_Rela * elf64_alpha_find_reloc_at_ofs
   PARAMS ((Elf_Internal_Rela *, Elf_Internal_Rela *, bfd_vma, int));
+static enum elf_reloc_type_class elf64_alpha_reloc_type_class
+  PARAMS ((const Elf_Internal_Rela *));
 
 
@@ -146 +170 @@
   int flags;
 
-  /* Contexts (LITUSE) in which a literal was referenced.  */
-#define ALPHA_ELF_LINK_HASH_LU_ADDR 0x01
-#define ALPHA_ELF_LINK_HASH_LU_MEM  0x02
-#define ALPHA_ELF_LINK_HASH_LU_BYTE 0x04
-#define ALPHA_ELF_LINK_HASH_LU_FUNC 0x08
+  /* Contexts in which a literal was referenced.  */
+#define ALPHA_ELF_LINK_HASH_LU_ADDR     0x01
+#define ALPHA_ELF_LINK_HASH_LU_MEM      0x02
+#define ALPHA_ELF_LINK_HASH_LU_BYTE     0x04
+#define ALPHA_ELF_LINK_HASH_LU_JSR      0x08
+#define ALPHA_ELF_LINK_HASH_LU_TLSGD    0x10
+#define ALPHA_ELF_LINK_HASH_LU_TLSLDM   0x20
+#define ALPHA_ELF_LINK_HASH_LU_FUNC     0x38
+#define ALPHA_ELF_LINK_HASH_TLS_IE      0x40
+#define ALPHA_ELF_LINK_HASH_PLT_LOC     0x80
+
+  /* Used to undo the localization of a plt symbol.  */
+  asection *plt_old_section;
+  bfd_vma plt_old_value;
 
   /* Used to implement multiple .got subsections.  */
@@ -157 +190 @@
     struct alpha_elf_got_entry *next;
 
-    /* which .got subsection?  */
+    /* Which .got subsection?  */
     bfd *gotobj;
 
-    /* the addend in effect for this entry.  */
+    /* The addend in effect for this entry.  */
     bfd_vma addend;
 
-    /* the .got offset for this entry.  */
+    /* The .got offset for this entry.  */
     int got_offset;
 
-    int flags;
-
-    /* An additional flag.  */
-#define ALPHA_ELF_GOT_ENTRY_RELOCS_DONE 0x10
-
+    /* How many references to this entry?  */
     int use_count;
+
+    /* The relocation type of this entry.  */
+    unsigned char reloc_type;
+
+    /* How a LITERAL is used.  */
+    unsigned char flags;
+
+    /* Have we initialized the dynamic relocation for this entry?  */
+    unsigned char reloc_done;
+
+    /* Have we adjusted this entry for SEC_MERGE?  */
+    unsigned char reloc_xlated;
   } *got_entries;
 
-  /* used to count non-got, non-plt relocations for delayed sizing
+  /* Used to count non-got, non-plt relocations for delayed sizing
      of relocation sections.  */
   struct alpha_elf_reloc_entry
@@ -180 +221 @@
     struct alpha_elf_reloc_entry *next;
 
-    /* which .reloc section? */
+    /* Which .reloc section? */
     asection *srel;
 
-    /* what kind of relocation? */
-    unsigned long rtype;
-
-    /* how many did we find?  */
+    /* What kind of relocation? */
+    unsigned int rtype;
+
+    /* Is this against read-only section? */
+    unsigned int reltext : 1;
+
+    /* How many did we find?  */
     unsigned long count;
   } *reloc_entries;
@@ -214 +258 @@
   (elf_link_hash_traverse                                               \
    (&(table)->root,                                                     \
-    (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func),  \
+    (bfd_boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
     (info)))
 
@@ -235 +279 @@
 {
   if (h == NULL)
-    return false;
+    return FALSE;
 
   while (h->root.type == bfd_link_hash_indirect
@@ -242 +286 @@
 
   if (h->dynindx == -1)
-    return false;
+    return FALSE;
 
   if (h->root.type == bfd_link_hash_undefweak
       || h->root.type == bfd_link_hash_defweak)
-    return true;
+    return TRUE;
 
   switch (ELF_ST_VISIBILITY (h->other))
@@ -254 +298 @@
     case STV_HIDDEN:
     case STV_INTERNAL:
-      return false;
+      return FALSE;
     case STV_PROTECTED:
       if (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)
-        return false;
+        return FALSE;
       break;
     }
@@ -263 +307 @@
   if ((info->shared && !info->symbolic)
       || ((h->elf_link_hash_flags
-           & (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR))
+           & (ELF_LINK_HASH_DEF_DYNAMIC
+              | ELF_LINK_HASH_DEF_REGULAR
+              | ELF_LINK_HASH_REF_REGULAR))
           == (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR)))
-    return true;
-
-  return false;
+    return TRUE;
+
+  return FALSE;
 }
 
@@ -316 +362 @@
 {
   struct alpha_elf_link_hash_table *ret;
-
-  ret = ((struct alpha_elf_link_hash_table *)
-         bfd_zalloc (abfd, sizeof (struct alpha_elf_link_hash_table)));
+  bfd_size_type amt = sizeof (struct alpha_elf_link_hash_table);
+
+  ret = (struct alpha_elf_link_hash_table *) bfd_zmalloc (amt);
   if (ret == (struct alpha_elf_link_hash_table *) NULL)
     return NULL;
@@ -325 +371 @@
                                        elf64_alpha_link_hash_newfunc))
     {
-      bfd_release (abfd, ret);
+      free (ret);
       return NULL;
     }
@@ -356 +402 @@
   asection *got;
 
-  /* For every got, this is it's total number of *entries*.  */
-  int total_got_entries;
-
-  /* For every got, this is the sum of the number of *entries* required
+  /* For every got, this is it's total number of words.  */
+  int total_got_size;
+
+  /* For every got, this is the sum of the number of words required
      to hold all of the member object's local got.  */
-  int n_local_got_entries;
+  int local_got_size;
 };
 
@@ -367 +413 @@
   ((struct alpha_elf_obj_tdata *) (abfd)->tdata.any)
 
-static boolean
+static bfd_boolean
 elf64_alpha_mkobject (abfd)
      bfd *abfd;
 {
-  abfd->tdata.any = bfd_zalloc (abfd, sizeof (struct alpha_elf_obj_tdata));
+  bfd_size_type amt = sizeof (struct alpha_elf_obj_tdata);
+  abfd->tdata.any = bfd_zalloc (abfd, amt);
   if (abfd->tdata.any == NULL)
-    return false;
-  return true;
+    return FALSE;
+  return TRUE;
 }
 
-static boolean
+static bfd_boolean
 elf64_alpha_object_p (abfd)
      bfd *abfd;
@@ -383 +430 @@
   /* Allocate our special target data.  */
   struct alpha_elf_obj_tdata *new_tdata;
-  new_tdata = bfd_zalloc (abfd, sizeof (struct alpha_elf_obj_tdata));
+  bfd_size_type amt = sizeof (struct alpha_elf_obj_tdata);
+  new_tdata = bfd_zalloc (abfd, amt);
   if (new_tdata == NULL)
-    return false;
+    return FALSE;
   new_tdata->root = *abfd->tdata.elf_obj_data;
   abfd->tdata.any = new_tdata;
@@ -397 +445 @@
    from smaller values.  Start with zero, widen, *then* decrement.  */
 #define MINUS_ONE       (((bfd_vma)0) - 1)
+
+#define SKIP_HOWTO(N) \
+  HOWTO(N, 0, 0, 0, 0, 0, 0, elf64_alpha_reloc_bad, 0, 0, 0, 0, 0)
 
 static reloc_howto_type elf64_alpha_howto_table[] =
@@ -404 +455 @@
          0,                     /* size (0 = byte, 1 = short, 2 = long) */
          8,                     /* bitsize */
-         true,                  /* pc_relative */
+         TRUE,                  /* pc_relative */
          0,                     /* bitpos */
          complain_overflow_dont, /* complain_on_overflow */
          elf64_alpha_reloc_nil, /* special_function */
          "NONE",                /* name */
-         false,                 /* partial_inplace */
+         FALSE,                 /* partial_inplace */
          0,                     /* src_mask */
          0,                     /* dst_mask */
-         true),                 /* pcrel_offset */
+         TRUE),                 /* pcrel_offset */
 
   /* A 32 bit reference to a symbol.  */
@@ -419 +470 @@
          2,                     /* size (0 = byte, 1 = short, 2 = long) */
          32,                    /* bitsize */
-         false,                 /* pc_relative */
+         FALSE,                 /* pc_relative */
          0,                     /* bitpos */
          complain_overflow_bitfield, /* complain_on_overflow */
          0,                     /* special_function */
          "REFLONG",             /* name */
-         false,                 /* partial_inplace */
+         FALSE,                 /* partial_inplace */
          0xffffffff,            /* src_mask */
          0xffffffff,            /* dst_mask */
-         false),                /* pcrel_offset */
+         FALSE),                /* pcrel_offset */
 
   /* A 64 bit reference to a symbol.  */
@@ -434 +485 @@
          4,                     /* size (0 = byte, 1 = short, 2 = long) */
          64,                    /* bitsize */
-         false,                 /* pc_relative */
+         FALSE,                 /* pc_relative */
          0,                     /* bitpos */
          complain_overflow_bitfield, /* complain_on_overflow */
          0,                     /* special_function */
          "REFQUAD",             /* name */
-         false,                 /* partial_inplace */
+         FALSE,                 /* partial_inplace */
          MINUS_ONE,             /* src_mask */
          MINUS_ONE,             /* dst_mask */
-         false),                /* pcrel_offset */
+         FALSE),                /* pcrel_offset */
 
   /* A 32 bit GP relative offset.  This is just like REFLONG except
@@ -451 +502 @@
          2,                     /* size (0 = byte, 1 = short, 2 = long) */
          32,                    /* bitsize */
-         false,                 /* pc_relative */
+         FALSE,                 /* pc_relative */
          0,                     /* bitpos */
          complain_overflow_bitfield, /* complain_on_overflow */
          0,                     /* special_function */
          "GPREL32",             /* name */
-         false,                 /* partial_inplace */
+         FALSE,                 /* partial_inplace */
          0xffffffff,            /* src_mask */
          0xffffffff,            /* dst_mask */
-         false),                /* pcrel_offset */
+         FALSE),                /* pcrel_offset */
 
   /* Used for an instruction that refers to memory off the GP register.  */
   HOWTO (R_ALPHA_LITERAL,       /* type */
          0,                     /* rightshift */
-         2,                     /* size (0 = byte, 1 = short, 2 = long) */
+         1,                     /* size (0 = byte, 1 = short, 2 = long) */
          16,                    /* bitsize */
-         false,                 /* pc_relative */
+         FALSE,                 /* pc_relative */
          0,                     /* bitpos */
          complain_overflow_signed, /* complain_on_overflow */
          0,                     /* special_function */
          "ELF_LITERAL",         /* name */
-         false,                 /* partial_inplace */
+         FALSE,                 /* partial_inplace */
          0xffff,                /* src_mask */
          0xffff,                /* dst_mask */
-         false),                /* pcrel_offset */
+         FALSE),                /* pcrel_offset */
 
   /* This reloc only appears immediately following an ELF_LITERAL reloc.
@@ -485 +536 @@
   HOWTO (R_ALPHA_LITUSE,        /* type */
          0,                     /* rightshift */
-         2,                     /* size (0 = byte, 1 = short, 2 = long) */
+         1,                     /* size (0 = byte, 1 = short, 2 = long) */
          32,                    /* bitsize */
-         false,                 /* pc_relative */
+         FALSE,                 /* pc_relative */
          0,                     /* bitpos */
          complain_overflow_dont, /* complain_on_overflow */
          elf64_alpha_reloc_nil, /* special_function */
          "LITUSE",              /* name */
-         false,                 /* partial_inplace */
+         FALSE,                 /* partial_inplace */
          0,                     /* src_mask */
          0,                     /* dst_mask */
-         false),                /* pcrel_offset */
+         FALSE),                /* pcrel_offset */
 
   /* Load the gp register.  This is always used for a ldah instruction
@@ -517 +568 @@
          2,                     /* size (0 = byte, 1 = short, 2 = long) */
          16,                    /* bitsize */
-         false,                 /* pc_relative */
+         FALSE,                 /* pc_relative */
          0,                     /* bitpos */
          complain_overflow_dont, /* complain_on_overflow */
          elf64_alpha_reloc_gpdisp, /* special_function */
          "GPDISP",              /* name */
-         false,                 /* partial_inplace */
+         FALSE,                 /* partial_inplace */
          0xffff,                /* src_mask */
          0xffff,                /* dst_mask */
-         true),                 /* pcrel_offset */
+         TRUE),                 /* pcrel_offset */
 
   /* A 21 bit branch.  */
@@ -532 +583 @@
          2,                     /* size (0 = byte, 1 = short, 2 = long) */
          21,                    /* bitsize */
-         true,                  /* pc_relative */
+         TRUE,                  /* pc_relative */
          0,                     /* bitpos */
          complain_overflow_signed, /* complain_on_overflow */
          0,                     /* special_function */
          "BRADDR",              /* name */
-         false,                 /* partial_inplace */
+         FALSE,                 /* partial_inplace */
          0x1fffff,              /* src_mask */
          0x1fffff,              /* dst_mask */
-         true),                 /* pcrel_offset */
+         TRUE),                 /* pcrel_offset */
 
   /* A hint for a jump to a register.  */
   HOWTO (R_ALPHA_HINT,          /* type */
          2,                     /* rightshift */
-         2,                     /* size (0 = byte, 1 = short, 2 = long) */
+         1,                     /* size (0 = byte, 1 = short, 2 = long) */
          14,                    /* bitsize */
-         true,                  /* pc_relative */
+         TRUE,                  /* pc_relative */
          0,                     /* bitpos */
          complain_overflow_dont, /* complain_on_overflow */
          0,                     /* special_function */
          "HINT",                /* name */
-         false,                 /* partial_inplace */
+         FALSE,                 /* partial_inplace */
          0x3fff,                /* src_mask */
          0x3fff,                /* dst_mask */
-         true),                 /* pcrel_offset */
+         TRUE),                 /* pcrel_offset */
 
   /* 16 bit PC relative offset.  */
@@ -562 +613 @@
          1,                     /* size (0 = byte, 1 = short, 2 = long) */
          16,                    /* bitsize */
-         true,                  /* pc_relative */
+         TRUE,                  /* pc_relative */
          0,                     /* bitpos */
          complain_overflow_signed, /* complain_on_overflow */
          0,                     /* special_function */
          "SREL16",              /* name */
-         false,                 /* partial_inplace */
+         FALSE,                 /* partial_inplace */
          0xffff,                /* src_mask */
          0xffff,                /* dst_mask */
-         true),                 /* pcrel_offset */
+         TRUE),                 /* pcrel_offset */
 
   /* 32 bit PC relative offset.  */
@@ -577 +628 @@
          2,                     /* size (0 = byte, 1 = short, 2 = long) */
          32,                    /* bitsize */
-         true,                  /* pc_relative */
+         TRUE,                  /* pc_relative */
          0,                     /* bitpos */
          complain_overflow_signed, /* complain_on_overflow */
          0,                     /* special_function */
          "SREL32",              /* name */
-         false,                 /* partial_inplace */
+         FALSE,                 /* partial_inplace */
          0xffffffff,            /* src_mask */
          0xffffffff,            /* dst_mask */
-         true),                 /* pcrel_offset */
+         TRUE),                 /* pcrel_offset */
 
   /* A 64 bit PC relative offset.  */
@@ -592 +643 @@
          4,                     /* size (0 = byte, 1 = short, 2 = long) */
          64,                    /* bitsize */
-         true,                  /* pc_relative */
+         TRUE,                  /* pc_relative */
          0,                     /* bitpos */
          complain_overflow_signed, /* complain_on_overflow */
          0,                     /* special_function */
          "SREL64",              /* name */
-         false,                 /* partial_inplace */
+         FALSE,                 /* partial_inplace */
          MINUS_ONE,             /* src_mask */
          MINUS_ONE,             /* dst_mask */
-         true),                 /* pcrel_offset */
-
-  /* Push a value on the reloc evaluation stack.  */
-  /* Not implemented -- it's dumb.  */
-  HOWTO (R_ALPHA_OP_PUSH,       /* type */
-         0,                     /* rightshift */
-         0,                     /* size (0 = byte, 1 = short, 2 = long) */
-         0,                     /* bitsize */
-         false,                 /* pc_relative */
-         0,                     /* bitpos */
-         complain_overflow_dont, /* complain_on_overflow */
-         elf64_alpha_reloc_bad, /* special_function */
-         "OP_PUSH",             /* name */
-         false,                 /* partial_inplace */
-         0,                     /* src_mask */
-         0,                     /* dst_mask */
-         false),                /* pcrel_offset */
-
-  /* Store the value from the stack at the given address.  Store it in
-     a bitfield of size r_size starting at bit position r_offset.  */
-  /* Not implemented -- it's dumb.  */
-  HOWTO (R_ALPHA_OP_STORE,      /* type */
-         0,                     /* rightshift */
-         4,                     /* size (0 = byte, 1 = short, 2 = long) */
-         64,                    /* bitsize */
-         false,                 /* pc_relative */
-         0,                     /* bitpos */
-         complain_overflow_dont, /* complain_on_overflow */
-         elf64_alpha_reloc_bad, /* special_function */
-         "OP_STORE",            /* name */
-         false,                 /* partial_inplace */
-         0,                     /* src_mask */
-         MINUS_ONE,             /* dst_mask */
-         false),                /* pcrel_offset */
-
-  /* Subtract the reloc address from the value on the top of the
-     relocation stack.  */
-  /* Not implemented -- it's dumb.  */
-  HOWTO (R_ALPHA_OP_PSUB,       /* type */
-         0,                     /* rightshift */
-         0,                     /* size (0 = byte, 1 = short, 2 = long) */
-         0,                     /* bitsize */
-         false,                 /* pc_relative */
-         0,                     /* bitpos */
-         complain_overflow_dont, /* complain_on_overflow */
-         elf64_alpha_reloc_bad, /* special_function */
-         "OP_PSUB",             /* name */
-         false,                 /* partial_inplace */
-         0,                     /* src_mask */
-         0,                     /* dst_mask */
-         false),                /* pcrel_offset */
-
-  /* Shift the value on the top of the relocation stack right by the
-     given value.  */
-  /* Not implemented -- it's dumb.  */
-  HOWTO (R_ALPHA_OP_PRSHIFT,    /* type */
-         0,                     /* rightshift */
-         0,                     /* size (0 = byte, 1 = short, 2 = long) */
-         0,                     /* bitsize */
-         false,                 /* pc_relative */
-         0,                     /* bitpos */
-         complain_overflow_dont, /* complain_on_overflow */
-         elf64_alpha_reloc_bad, /* special_function */
-         "OP_PRSHIFT",          /* name */
-         false,                 /* partial_inplace */
-         0,                     /* src_mask */
-         0,                     /* dst_mask */
-         false),                /* pcrel_offset */
-
-  /* Change the value of GP used by +r_addend until the next GPVALUE or the
-     end of the input bfd.  */
-  /* Not implemented -- it's dumb.  */
-  HOWTO (R_ALPHA_GPVALUE,
-         0,                     /* rightshift */
-         0,                     /* size (0 = byte, 1 = short, 2 = long) */
-         0,                     /* bitsize */
-         false,                 /* pc_relative */
-         0,                     /* bitpos */
-         complain_overflow_dont, /* complain_on_overflow */
-         elf64_alpha_reloc_bad, /* special_function */
-         "GPVALUE",             /* name */
-         false,                 /* partial_inplace */
-         0,                     /* src_mask */
-         0,                     /* dst_mask */
-         false),                /* pcrel_offset */
+         TRUE),                 /* pcrel_offset */
+
+  /* Skip 12 - 16; deprecated ECOFF relocs.  */
+  SKIP_HOWTO (12),
+  SKIP_HOWTO (13),
+  SKIP_HOWTO (14),
+  SKIP_HOWTO (15),
+  SKIP_HOWTO (16),
 
   /* The high 16 bits of the displacement from GP to the target.  */
   HOWTO (R_ALPHA_GPRELHIGH,
          0,                     /* rightshift */
-         2,                     /* size (0 = byte, 1 = short, 2 = long) */
+         1,                     /* size (0 = byte, 1 = short, 2 = long) */
          16,                    /* bitsize */
-         false,                 /* pc_relative */
+         FALSE,                 /* pc_relative */
          0,                     /* bitpos */
          complain_overflow_signed, /* complain_on_overflow */
-         elf64_alpha_reloc_bad, /* special_function */
+         0,                     /* special_function */
          "GPRELHIGH",           /* name */
-         false,                 /* partial_inplace */
+         FALSE,                 /* partial_inplace */
          0xffff,                /* src_mask */
          0xffff,                /* dst_mask */
-         false),                /* pcrel_offset */
+         FALSE),                /* pcrel_offset */
 
   /* The low 16 bits of the displacement from GP to the target.  */
   HOWTO (R_ALPHA_GPRELLOW,
          0,                     /* rightshift */
-         2,                     /* size (0 = byte, 1 = short, 2 = long) */
+         1,                     /* size (0 = byte, 1 = short, 2 = long) */
          16,                    /* bitsize */
-         false,                 /* pc_relative */
+         FALSE,                 /* pc_relative */
          0,                     /* bitpos */
          complain_overflow_dont, /* complain_on_overflow */
-         elf64_alpha_reloc_bad, /* special_function */
+         0,                     /* special_function */
          "GPRELLOW",            /* name */
-         false,                 /* partial_inplace */
+         FALSE,                 /* partial_inplace */
          0xffff,                /* src_mask */
          0xffff,                /* dst_mask */
-         false),                /* pcrel_offset */
+         FALSE),                /* pcrel_offset */
 
   /* A 16-bit displacement from the GP to the target.  */
-  /* XXX: Not implemented.  */
-  HOWTO (R_ALPHA_IMMED_GP_16,
+  HOWTO (R_ALPHA_GPREL16,
          0,                     /* rightshift */
-         2,                     /* size (0 = byte, 1 = short, 2 = long) */
+         1,                     /* size (0 = byte, 1 = short, 2 = long) */
          16,                    /* bitsize */
-         false,                 /* pc_relative */
+         FALSE,                 /* pc_relative */
          0,                     /* bitpos */
          complain_overflow_signed, /* complain_on_overflow */
          0,                     /* special_function */
-         "IMMED_GP_16",         /* name */
-         false,                 /* partial_inplace */
+         "GPREL16",             /* name */
+         FALSE,                 /* partial_inplace */
          0xffff,                /* src_mask */
          0xffff,                /* dst_mask */
-         false),                /* pcrel_offset */
-
-  /* The high bits of a 32-bit displacement from the GP to the target; the
-     low bits are supplied in the subsequent R_ALPHA_IMMED_LO32 relocs.  */
-  /* XXX: Not implemented.  */
-  HOWTO (R_ALPHA_IMMED_GP_HI32,
-         0,                     /* rightshift */
-         0,                     /* size (0 = byte, 1 = short, 2 = long) */
-         0,                     /* bitsize */
-         false,                 /* pc_relative */
-         0,                     /* bitpos */
-         complain_overflow_dont, /* complain_on_overflow */
-         elf64_alpha_reloc_bad, /* special_function */
-         "IMMED_GP_HI32",               /* name */
-         false,                 /* partial_inplace */
-         0,                     /* src_mask */
-         0,                     /* dst_mask */
-         false),                /* pcrel_offset */
-
-  /* The high bits of a 32-bit displacement to the starting address of the
-     current section (the relocation target is ignored); the low bits are
-     supplied in the subsequent R_ALPHA_IMMED_LO32 relocs.  */
-  /* XXX: Not implemented.  */
-  HOWTO (R_ALPHA_IMMED_SCN_HI32,
-         0,                     /* rightshift */
-         0,                     /* size (0 = byte, 1 = short, 2 = long) */
-         0,                     /* bitsize */
-         false,                 /* pc_relative */
-         0,                     /* bitpos */
-         complain_overflow_dont, /* complain_on_overflow */
-         elf64_alpha_reloc_bad, /* special_function */
-         "IMMED_SCN_HI32",              /* name */
-         false,                 /* partial_inplace */
-         0,                     /* src_mask */
-         0,                     /* dst_mask */
-         false),                /* pcrel_offset */
-
-  /* The high bits of a 32-bit displacement from the previous br, bsr, jsr
-     or jmp insn (as tagged by a BRADDR or HINT reloc) to the target; the
-     low bits are supplied by subsequent R_ALPHA_IMMED_LO32 relocs.  */
-  /* XXX: Not implemented.  */
-  HOWTO (R_ALPHA_IMMED_BR_HI32,
-         0,                     /* rightshift */
-         0,                     /* size (0 = byte, 1 = short, 2 = long) */
-         0,                     /* bitsize */
-         false,                 /* pc_relative */
-         0,                     /* bitpos */
-         complain_overflow_dont, /* complain_on_overflow */
-         elf64_alpha_reloc_bad, /* special_function */
-         "IMMED_BR_HI32",               /* name */
-         false,                 /* partial_inplace */
-         0,                     /* src_mask */
-         0,                     /* dst_mask */
-         false),                /* pcrel_offset */
-
-  /* The low 16 bits of a displacement calculated in a previous HI32 reloc.  */
-  /* XXX: Not implemented.  */
-  HOWTO (R_ALPHA_IMMED_LO32,
-         0,                     /* rightshift */
-         0,                     /* size (0 = byte, 1 = short, 2 = long) */
-         0,                     /* bitsize */
-         false,                 /* pc_relative */
-         0,                     /* bitpos */
-         complain_overflow_dont, /* complain_on_overflow */
-         elf64_alpha_reloc_bad, /* special_function */
-         "IMMED_LO32",          /* name */
-         false,                 /* partial_inplace */
-         0,                     /* src_mask */
-         0,                     /* dst_mask */
-         false),                /* pcrel_offset */
+         FALSE),                /* pcrel_offset */
+
+  /* Skip 20 - 23; deprecated ECOFF relocs.  */
+  SKIP_HOWTO (20),
+  SKIP_HOWTO (21),
+  SKIP_HOWTO (22),
+  SKIP_HOWTO (23),
 
   /* Misc ELF relocations.  */
@@ -811 +721 @@
          0,
          0,
-         false,
+         FALSE,
          0,
          complain_overflow_dont,
          bfd_elf_generic_reloc,
          "COPY",
-         false,
+         FALSE,
          0,
          0,
-         true),
+         TRUE),
 
   /* A dynamic relocation for a .got entry.  */
@@ -826 +736 @@
          0,
          0,
-         false,
+         FALSE,
          0,
          complain_overflow_dont,
          bfd_elf_generic_reloc,
          "GLOB_DAT",
-         false,
+         FALSE,
          0,
          0,
-         true),
+         TRUE),
 
   /* A dynamic relocation for a .plt entry.  */
@@ -841 +751 @@
          0,
          0,
-         false,
+         FALSE,
          0,
          complain_overflow_dont,
          bfd_elf_generic_reloc,
          "JMP_SLOT",
-         false,
+         FALSE,
          0,
          0,
-         true),
+         TRUE),
 
   /* A dynamic relocation to add the base of the DSO to a 64-bit field.  */
@@ -856 +766 @@
          0,
          0,
-         false,
+         FALSE,
          0,
          complain_overflow_dont,
          bfd_elf_generic_reloc,
          "RELATIVE",
-         false,
+         FALSE,
          0,
          0,
-         true)
+         TRUE),
+
+  /* A 21 bit branch that adjusts for gp loads.  */
+  HOWTO (R_ALPHA_BRSGP,         /* type */
+         2,                     /* rightshift */
+         2,                     /* size (0 = byte, 1 = short, 2 = long) */
+         21,                    /* bitsize */
+         TRUE,                  /* pc_relative */
+         0,                     /* bitpos */
+         complain_overflow_signed, /* complain_on_overflow */
+         0,                     /* special_function */
+         "BRSGP",               /* name */
+         FALSE,                 /* partial_inplace */
+         0x1fffff,              /* src_mask */
+         0x1fffff,              /* dst_mask */
+         TRUE),                 /* pcrel_offset */
+
+  /* Creates a tls_index for the symbol in the got.  */
+  HOWTO (R_ALPHA_TLSGD,         /* type */
+         0,                     /* rightshift */
+         1,                     /* size (0 = byte, 1 = short, 2 = long) */
+         16,                    /* bitsize */
+         FALSE,                 /* pc_relative */
+         0,                     /* bitpos */
+         complain_overflow_signed, /* complain_on_overflow */
+         0,                     /* special_function */
+         "TLSGD",               /* name */
+         FALSE,                 /* partial_inplace */
+         0xffff,                /* src_mask */
+         0xffff,                /* dst_mask */
+         FALSE),                /* pcrel_offset */
+
+  /* Creates a tls_index for the (current) module in the got.  */
+  HOWTO (R_ALPHA_TLSLDM,        /* type */
+         0,                     /* rightshift */
+         1,                     /* size (0 = byte, 1 = short, 2 = long) */
+         16,                    /* bitsize */
+         FALSE,                 /* pc_relative */
+         0,                     /* bitpos */
+         complain_overflow_signed, /* complain_on_overflow */
+         0,                     /* special_function */
+         "TLSLDM",              /* name */
+         FALSE,                 /* partial_inplace */
+         0xffff,                /* src_mask */
+         0xffff,                /* dst_mask */
+         FALSE),                /* pcrel_offset */
+
+  /* A dynamic relocation for a DTP module entry.  */
+  HOWTO (R_ALPHA_DTPMOD64,      /* type */
+         0,                     /* rightshift */
+         4,                     /* size (0 = byte, 1 = short, 2 = long) */
+         64,                    /* bitsize */
+         FALSE,                 /* pc_relative */
+         0,                     /* bitpos */
+         complain_overflow_bitfield, /* complain_on_overflow */
+         0,                     /* special_function */
+         "DTPMOD64",            /* name */
+         FALSE,                 /* partial_inplace */
+         MINUS_ONE,             /* src_mask */
+         MINUS_ONE,             /* dst_mask */
+         FALSE),                /* pcrel_offset */
+
+  /* Creates a 64-bit offset in the got for the displacement
+     from DTP to the target.  */
+  HOWTO (R_ALPHA_GOTDTPREL,     /* type */
+         0,                     /* rightshift */
+         1,                     /* size (0 = byte, 1 = short, 2 = long) */
+         16,                    /* bitsize */
+         FALSE,                 /* pc_relative */
+         0,                     /* bitpos */
+         complain_overflow_signed, /* complain_on_overflow */
+         0,                     /* special_function */
+         "GOTDTPREL",           /* name */
+         FALSE,                 /* partial_inplace */
+         0xffff,                /* src_mask */
+         0xffff,                /* dst_mask */
+         FALSE),                /* pcrel_offset */
+
+  /* A dynamic relocation for a displacement from DTP to the target.  */
+  HOWTO (R_ALPHA_DTPREL64,      /* type */
+         0,                     /* rightshift */
+         4,                     /* size (0 = byte, 1 = short, 2 = long) */
+         64,                    /* bitsize */
+         FALSE,                 /* pc_relative */
+         0,                     /* bitpos */
+         complain_overflow_bitfield, /* complain_on_overflow */
+         0,                     /* special_function */
+         "DTPREL64",            /* name */
+         FALSE,                 /* partial_inplace */
+         MINUS_ONE,             /* src_mask */
+         MINUS_ONE,             /* dst_mask */
+         FALSE),                /* pcrel_offset */
+
+  /* The high 16 bits of the displacement from DTP to the target.  */
+  HOWTO (R_ALPHA_DTPRELHI,      /* type */
+         0,                     /* rightshift */
+         1,                     /* size (0 = byte, 1 = short, 2 = long) */
+         16,                    /* bitsize */
+         FALSE,                 /* pc_relative */
+         0,                     /* bitpos */
+         complain_overflow_signed, /* complain_on_overflow */
+         0,                     /* special_function */
+         "DTPRELHI",            /* name */
+         FALSE,                 /* partial_inplace */
+         0xffff,                /* src_mask */
+         0xffff,                /* dst_mask */
+         FALSE),                /* pcrel_offset */
+
+  /* The low 16 bits of the displacement from DTP to the target.  */
+  HOWTO (R_ALPHA_DTPRELLO,      /* type */
+         0,                     /* rightshift */
+         1,                     /* size (0 = byte, 1 = short, 2 = long) */
+         16,                    /* bitsize */
+         FALSE,                 /* pc_relative */
+         0,                     /* bitpos */
+         complain_overflow_dont, /* complain_on_overflow */
+         0,                     /* special_function */
+         "DTPRELLO",            /* name */
+         FALSE,                 /* partial_inplace */
+         0xffff,                /* src_mask */
+         0xffff,                /* dst_mask */
+         FALSE),                /* pcrel_offset */
+
+  /* A 16-bit displacement from DTP to the target.  */
+  HOWTO (R_ALPHA_DTPREL16,      /* type */
+         0,                     /* rightshift */
+         1,                     /* size (0 = byte, 1 = short, 2 = long) */
+         16,                    /* bitsize */
+         FALSE,                 /* pc_relative */
+         0,                     /* bitpos */
+         complain_overflow_signed, /* complain_on_overflow */
+         0,                     /* special_function */
+         "DTPREL16",            /* name */
+         FALSE,                 /* partial_inplace */
+         0xffff,                /* src_mask */
+         0xffff,                /* dst_mask */
+         FALSE),                /* pcrel_offset */
+
+  /* Creates a 64-bit offset in the got for the displacement
+     from TP to the target.  */
+  HOWTO (R_ALPHA_GOTTPREL,      /* type */
+         0,                     /* rightshift */
+         1,                     /* size (0 = byte, 1 = short, 2 = long) */
+         16,                    /* bitsize */
+         FALSE,                 /* pc_relative */
+         0,                     /* bitpos */
+         complain_overflow_signed, /* complain_on_overflow */
+         0,                     /* special_function */
+         "GOTTPREL",            /* name */
+         FALSE,                 /* partial_inplace */
+         0xffff,                /* src_mask */
+         0xffff,                /* dst_mask */
+         FALSE),                /* pcrel_offset */
+
+  /* A dynamic relocation for a displacement from TP to the target.  */
+  HOWTO (R_ALPHA_TPREL64,       /* type */
+         0,                     /* rightshift */
+         4,                     /* size (0 = byte, 1 = short, 2 = long) */
+         64,                    /* bitsize */
+         FALSE,                 /* pc_relative */
+         0,                     /* bitpos */
+         complain_overflow_bitfield, /* complain_on_overflow */
+         0,                     /* special_function */
+         "TPREL64",             /* name */
+         FALSE,                 /* partial_inplace */
+         MINUS_ONE,             /* src_mask */
+         MINUS_ONE,             /* dst_mask */
+         FALSE),                /* pcrel_offset */
+
+  /* The high 16 bits of the displacement from TP to the target.  */
+  HOWTO (R_ALPHA_TPRELHI,       /* type */
+         0,                     /* rightshift */
+         1,                     /* size (0 = byte, 1 = short, 2 = long) */
+         16,                    /* bitsize */
+         FALSE,                 /* pc_relative */
+         0,                     /* bitpos */
+         complain_overflow_signed, /* complain_on_overflow */
+         0,                     /* special_function */
+         "TPRELHI",             /* name */
+         FALSE,                 /* partial_inplace */
+         0xffff,                /* src_mask */
+         0xffff,                /* dst_mask */
+         FALSE),                /* pcrel_offset */
+
+  /* The low 16 bits of the displacement from TP to the target.  */
+  HOWTO (R_ALPHA_TPRELLO,       /* type */
+         0,                     /* rightshift */
+         1,                     /* size (0 = byte, 1 = short, 2 = long) */
+         16,                    /* bitsize */
+         FALSE,                 /* pc_relative */
+         0,                     /* bitpos */
+         complain_overflow_dont, /* complain_on_overflow */
+         0,                     /* special_function */
+         "TPRELLO",             /* name */
+         FALSE,                 /* partial_inplace */
+         0xffff,                /* src_mask */
+         0xffff,                /* dst_mask */
+         FALSE),                /* pcrel_offset */
+
+  /* A 16-bit displacement from TP to the target.  */
+  HOWTO (R_ALPHA_TPREL16,       /* type */
+         0,                     /* rightshift */
+         1,                     /* size (0 = byte, 1 = short, 2 = long) */
+         16,                    /* bitsize */
+         FALSE,                 /* pc_relative */
+         0,                     /* bitpos */
+         complain_overflow_signed, /* complain_on_overflow */
+         0,                     /* special_function */
+         "TPREL16",             /* name */
+         FALSE,                 /* partial_inplace */
+         0xffff,                /* src_mask */
+         0xffff,                /* dst_mask */
+         FALSE),                /* pcrel_offset */
 };
 
@@ -938 +1060 @@
   i_lda = (i_lda & 0xffff0000) | (gpdisp & 0xffff);
 
-  bfd_put_32 (abfd, i_ldah, p_ldah);
-  bfd_put_32 (abfd, i_lda, p_lda);
+  bfd_put_32 (abfd, (bfd_vma) i_ldah, p_ldah);
+  bfd_put_32 (abfd, (bfd_vma) i_lda, p_lda);
 
   return ret;
@@ -1002 +1124 @@
 static const struct elf_reloc_map elf64_alpha_reloc_map[] =
 {
-  {BFD_RELOC_NONE,              R_ALPHA_NONE},
-  {BFD_RELOC_32,                R_ALPHA_REFLONG},
-  {BFD_RELOC_64,                R_ALPHA_REFQUAD},
-  {BFD_RELOC_CTOR,              R_ALPHA_REFQUAD},
-  {BFD_RELOC_GPREL32,           R_ALPHA_GPREL32},
-  {BFD_RELOC_ALPHA_ELF_LITERAL, R_ALPHA_LITERAL},
-  {BFD_RELOC_ALPHA_LITUSE,      R_ALPHA_LITUSE},
-  {BFD_RELOC_ALPHA_GPDISP,      R_ALPHA_GPDISP},
-  {BFD_RELOC_23_PCREL_S2,       R_ALPHA_BRADDR},
-  {BFD_RELOC_ALPHA_HINT,        R_ALPHA_HINT},
-  {BFD_RELOC_16_PCREL,          R_ALPHA_SREL16},
-  {BFD_RELOC_32_PCREL,          R_ALPHA_SREL32},
-  {BFD_RELOC_64_PCREL,          R_ALPHA_SREL64},
-
-/* The BFD_RELOC_ALPHA_USER_* relocations are used by the assembler to process
-   the explicit !<reloc>!sequence relocations, and are mapped into the normal
-   relocations at the end of processing.  */
-  {BFD_RELOC_ALPHA_USER_LITERAL,        R_ALPHA_LITERAL},
-  {BFD_RELOC_ALPHA_USER_LITUSE_BASE,    R_ALPHA_LITUSE},
-  {BFD_RELOC_ALPHA_USER_LITUSE_BYTOFF,  R_ALPHA_LITUSE},
-  {BFD_RELOC_ALPHA_USER_LITUSE_JSR,     R_ALPHA_LITUSE},
-  {BFD_RELOC_ALPHA_USER_GPDISP,         R_ALPHA_GPDISP},
-  {BFD_RELOC_ALPHA_USER_GPRELHIGH,      R_ALPHA_GPRELHIGH},
-  {BFD_RELOC_ALPHA_USER_GPRELLOW,       R_ALPHA_GPRELLOW},
+  {BFD_RELOC_NONE,                      R_ALPHA_NONE},
+  {BFD_RELOC_32,                        R_ALPHA_REFLONG},
+  {BFD_RELOC_64,                        R_ALPHA_REFQUAD},
+  {BFD_RELOC_CTOR,                      R_ALPHA_REFQUAD},
+  {BFD_RELOC_GPREL32,                   R_ALPHA_GPREL32},
+  {BFD_RELOC_ALPHA_ELF_LITERAL,         R_ALPHA_LITERAL},
+  {BFD_RELOC_ALPHA_LITUSE,              R_ALPHA_LITUSE},
+  {BFD_RELOC_ALPHA_GPDISP,              R_ALPHA_GPDISP},
+  {BFD_RELOC_23_PCREL_S2,               R_ALPHA_BRADDR},
+  {BFD_RELOC_ALPHA_HINT,                R_ALPHA_HINT},
+  {BFD_RELOC_16_PCREL,                  R_ALPHA_SREL16},
+  {BFD_RELOC_32_PCREL,                  R_ALPHA_SREL32},
+  {BFD_RELOC_64_PCREL,                  R_ALPHA_SREL64},
+  {BFD_RELOC_ALPHA_GPREL_HI16,          R_ALPHA_GPRELHIGH},
+  {BFD_RELOC_ALPHA_GPREL_LO16,          R_ALPHA_GPRELLOW},
+  {BFD_RELOC_GPREL16,                   R_ALPHA_GPREL16},
+  {BFD_RELOC_ALPHA_BRSGP,               R_ALPHA_BRSGP},
+  {BFD_RELOC_ALPHA_TLSGD,               R_ALPHA_TLSGD},
+  {BFD_RELOC_ALPHA_TLSLDM,              R_ALPHA_TLSLDM},
+  {BFD_RELOC_ALPHA_DTPMOD64,            R_ALPHA_DTPMOD64},
+  {BFD_RELOC_ALPHA_GOTDTPREL16,         R_ALPHA_GOTDTPREL},
+  {BFD_RELOC_ALPHA_DTPREL64,            R_ALPHA_DTPREL64},
+  {BFD_RELOC_ALPHA_DTPREL_HI16,         R_ALPHA_DTPRELHI},
+  {BFD_RELOC_ALPHA_DTPREL_LO16,         R_ALPHA_DTPRELLO},
+  {BFD_RELOC_ALPHA_DTPREL16,            R_ALPHA_DTPREL16},
+  {BFD_RELOC_ALPHA_GOTTPREL16,          R_ALPHA_GOTTPREL},
+  {BFD_RELOC_ALPHA_TPREL64,             R_ALPHA_TPREL64},
+  {BFD_RELOC_ALPHA_TPREL_HI16,          R_ALPHA_TPRELHI},
+  {BFD_RELOC_ALPHA_TPREL_LO16,          R_ALPHA_TPRELLO},
+  {BFD_RELOC_ALPHA_TPREL16,             R_ALPHA_TPREL16},
 };
 
@@ -1052 +1180 @@
      bfd *abfd ATTRIBUTE_UNUSED;
      arelent *cache_ptr;
-     Elf64_Internal_Rela *dst;
+     Elf_Internal_Rela *dst;
 {
   unsigned r_type;
@@ -1060 +1188 @@
   cache_ptr->howto = &elf64_alpha_howto_table[r_type];
 }
+
+/* These two relocations create a two-word entry in the got.  */
+#define alpha_got_entry_size(r_type) \
+  (r_type == R_ALPHA_TLSGD || r_type == R_ALPHA_TLSLDM ? 16 : 8)
+
+/* This is PT_TLS segment p_vaddr.  */
+#define alpha_get_dtprel_base(tlss) \
+  ((tlss)->start)
+
+/* Main program TLS (whose template starts at PT_TLS p_vaddr)
+   is assigned offset round(16, PT_TLS p_align).  */
+#define alpha_get_tprel_base(tlss) \
+  ((tlss)->start - align_power ((bfd_vma) 16, (tlss)->align))
 
 
@@ -1082 +1223 @@
 #define OP_BR           0x30
 #define OP_BSR          0x34
-#define INSN_UNOP       0x2fe00000
+#define INSN_UNOP       0x2ffe0000
+#define INSN_ADDQ       0x40000400
+#define INSN_RDUNIQ     0x0000009e
 
 struct alpha_relax_info
@@ -1089 +1232 @@
   asection *sec;
   bfd_byte *contents;
+  Elf_Internal_Shdr *symtab_hdr;
   Elf_Internal_Rela *relocs, *relend;
   struct bfd_link_info *link_info;
-  boolean changed_contents;
-  boolean changed_relocs;
+  struct elf_link_tls_segment *tls_segment;
   bfd_vma gp;
   bfd *gotobj;
   asection *tsec;
   struct alpha_elf_link_hash_entry *h;
+  struct alpha_elf_got_entry **first_gotent;
   struct alpha_elf_got_entry *gotent;
+  bfd_boolean changed_contents;
+  bfd_boolean changed_relocs;
   unsigned char other;
 };
 
-static Elf_Internal_Rela * elf64_alpha_relax_with_lituse
-  PARAMS((struct alpha_relax_info *info, bfd_vma symval,
-          Elf_Internal_Rela *irel, Elf_Internal_Rela *irelend));
-
-static boolean elf64_alpha_relax_without_lituse
+static bfd_boolean elf64_alpha_relax_with_lituse
   PARAMS((struct alpha_relax_info *info, bfd_vma symval,
           Elf_Internal_Rela *irel));
-
 static bfd_vma elf64_alpha_relax_opt_call
   PARAMS((struct alpha_relax_info *info, bfd_vma symval));
-
-static boolean elf64_alpha_relax_section
+static bfd_boolean elf64_alpha_relax_got_load
+  PARAMS((struct alpha_relax_info *info, bfd_vma symval,
+          Elf_Internal_Rela *irel, unsigned long));
+static bfd_boolean elf64_alpha_relax_gprelhilo
+  PARAMS((struct alpha_relax_info *info, bfd_vma symval,
+          Elf_Internal_Rela *irel, bfd_boolean));
+static bfd_boolean elf64_alpha_relax_tls_get_addr
+  PARAMS((struct alpha_relax_info *info, bfd_vma symval,
+          Elf_Internal_Rela *irel, bfd_boolean));
+static struct elf_link_tls_segment *elf64_alpha_relax_find_tls_segment
+  PARAMS((struct alpha_relax_info *, struct elf_link_tls_segment *));
+static bfd_boolean elf64_alpha_relax_section
   PARAMS((bfd *abfd, asection *sec, struct bfd_link_info *link_info,
-          boolean *again));
+          bfd_boolean *again));
 
 static Elf_Internal_Rela *
@@ -1124 +1275 @@
   while (rel < relend)
     {
-      if (rel->r_offset == offset && ELF64_R_TYPE (rel->r_info) == type)
+      if (rel->r_offset == offset
+          && ELF64_R_TYPE (rel->r_info) == (unsigned int) type)
         return rel;
       ++rel;
@@ -1131 +1283 @@
 }
 
-static Elf_Internal_Rela *
-elf64_alpha_relax_with_lituse (info, symval, irel, irelend)
+static bfd_boolean
+elf64_alpha_relax_with_lituse (info, symval, irel)
      struct alpha_relax_info *info;
      bfd_vma symval;
-     Elf_Internal_Rela *irel, *irelend;
-{
-  Elf_Internal_Rela *urel;
+     Elf_Internal_Rela *irel;
+{
+  Elf_Internal_Rela *urel, *irelend = info->relend;
   int flags, count, i;
   bfd_signed_vma disp;
-  boolean fits16;
-  boolean fits32;
-  boolean lit_reused = false;
-  boolean all_optimized = true;
+  bfd_boolean fits16;
+  bfd_boolean fits32;
+  bfd_boolean lit_reused = FALSE;
+  bfd_boolean all_optimized = TRUE;
   unsigned int lit_insn;
 
@@ -1151 +1303 @@
       ((*_bfd_error_handler)
        ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
-        bfd_get_filename (info->abfd), info->sec->name,
-        (unsigned long)irel->r_offset));
-      return irel;
-    }
+        bfd_archive_filename (info->abfd), info->sec->name,
+        (unsigned long) irel->r_offset));
+      return TRUE;
+    }
+
+  /* Can't relax dynamic symbols.  */
+  if (alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info))
+    return TRUE;
 
   /* Summarize how this particular LITERAL is used.  */
@@ -1161 +1317 @@
       if (ELF64_R_TYPE (urel->r_info) != R_ALPHA_LITUSE)
         break;
-      if (urel->r_addend >= 0 && urel->r_addend <= 3)
+      if (urel->r_addend <= 3)
         flags |= 1 << urel->r_addend;
     }
@@ -1178 +1334 @@
       switch (urel->r_addend)
         {
-        default: /* 0 = ADDRESS FORMAT */
+        case LITUSE_ALPHA_ADDR:
+        default:
           /* This type is really just a placeholder to note that all
              uses cannot be optimized, but to still allow some.  */
-          all_optimized = false;
+          all_optimized = FALSE;
           break;
 
-        case 1: /* MEM FORMAT */
+        case LITUSE_ALPHA_BASE:
           /* We can always optimize 16-bit displacements.  */
 
@@ -1191 +1348 @@
              displacement from GP.  */
           insn_disp = insn & 0x0000ffff;
-          if (insn_disp & 0x00008000)
-            insn_disp |= 0xffff0000;  /* Negative: sign-extend.  */
+          if (insn_disp & 0x8000)
+            insn_disp |= ~0xffff;  /* Negative: sign-extend.  */
 
           xdisp = disp + insn_disp;
-          fits16 = (xdisp >= - (bfd_signed_vma) 0x00008000 && xdisp < 0x00008000);
-          fits32 = (xdisp >= - (bfd_signed_vma) 0x80000000 && xdisp < 0x7fff8000);
+          fits16 = (xdisp >= - (bfd_signed_vma) 0x8000 && xdisp < 0x8000);
+          fits32 = (xdisp >= - (bfd_signed_vma) 0x80000000
+                    && xdisp < 0x7fff8000);
 
           if (fits16)
@@ -1204 +1362 @@
               insn = (insn & 0xffe0ffff) | (lit_insn & 0x001f0000);
               urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
-                                           R_ALPHA_GPRELLOW);
+                                           R_ALPHA_GPREL16);
               urel->r_addend = irel->r_addend;
-              info->changed_relocs = true;
-
-              bfd_put_32 (info->abfd, insn, info->contents + urel->r_offset);
-              info->changed_contents = true;
+              info->changed_relocs = TRUE;
+
+              bfd_put_32 (info->abfd, (bfd_vma) insn,
+                          info->contents + urel->r_offset);
+              info->changed_contents = TRUE;
             }
 
@@ -1220 +1379 @@
                                            R_ALPHA_GPRELHIGH);
               lit_insn = (OP_LDAH << 26) | (lit_insn & 0x03ff0000);
-              bfd_put_32 (info->abfd, lit_insn,
+              bfd_put_32 (info->abfd, (bfd_vma) lit_insn,
                           info->contents + irel->r_offset);
-              lit_reused = true;
-              info->changed_contents = true;
+              lit_reused = TRUE;
+              info->changed_contents = TRUE;
 
               urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
                                            R_ALPHA_GPRELLOW);
               urel->r_addend = irel->r_addend;
-              info->changed_relocs = true;
+              info->changed_relocs = TRUE;
             }
           else
-            all_optimized = false;
+            all_optimized = FALSE;
           break;
 
-        case 2: /* BYTE OFFSET FORMAT */
+        case LITUSE_ALPHA_BYTOFF:
           /* We can always optimize byte instructions.  */
 
@@ -1240 +1399 @@
              literal dest reg is indeed Rb in the byte insn.  */
 
-          insn = (insn & ~0x001ff000) | ((symval & 7) << 13) | 0x1000;
+          insn &= ~ (unsigned) 0x001ff000;
+          insn |= ((symval & 7) << 13) | 0x1000;
 
           urel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
           urel->r_addend = 0;
-          info->changed_relocs = true;
-
-          bfd_put_32 (info->abfd, insn, info->contents + urel->r_offset);
-          info->changed_contents = true;
+          info->changed_relocs = TRUE;
+
+          bfd_put_32 (info->abfd, (bfd_vma) insn,
+                      info->contents + urel->r_offset);
+          info->changed_contents = TRUE;
           break;
 
-        case 3: /* CALL FORMAT */
+        case LITUSE_ALPHA_JSR:
+        case LITUSE_ALPHA_TLSGD:
+        case LITUSE_ALPHA_TLSLDM:
           {
+            bfd_vma optdest, org;
+            bfd_signed_vma odisp;
+
             /* If not zero, place to jump without needing pv.  */
-            bfd_vma optdest = elf64_alpha_relax_opt_call (info, symval);
-            bfd_vma org = (info->sec->output_section->vma
-                           + info->sec->output_offset
-                           + urel->r_offset + 4);
-            bfd_signed_vma odisp;
-
+            optdest = elf64_alpha_relax_opt_call (info, symval);
+            org = (info->sec->output_section->vma
+                   + info->sec->output_offset
+                   + urel->r_offset + 4);
             odisp = (optdest ? optdest : symval) - org;
+
             if (odisp >= -0x400000 && odisp < 0x400000)
               {
@@ -1277 +1442 @@
                   urel->r_addend += optdest - symval;
                 else
-                  all_optimized = false;
-
-                bfd_put_32 (info->abfd, insn, info->contents + urel->r_offset);
+                  all_optimized = FALSE;
+
+                bfd_put_32 (info->abfd, (bfd_vma) insn,
+                            info->contents + urel->r_offset);
 
                 /* Kill any HINT reloc that might exist for this insn.  */
@@ -1288 +1454 @@
                   xrel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
 
-                info->changed_contents = true;
-                info->changed_relocs = true;
+                info->changed_contents = TRUE;
+                info->changed_relocs = TRUE;
               }
             else
-              all_optimized = false;
-
-            /* ??? If target gp == current gp we can eliminate the gp reload.
-               This does depend on every place a gp could be reloaded will
-               be, which currently happens for all code produced by gcc, but
-               not necessarily by hand-coded assembly, or if sibling calls
-               are enabled in gcc.
-
-               Perhaps conditionalize this on a flag being set in the target
-               object file's header, and have gcc set it?  */
+              all_optimized = FALSE;
+
+            /* Even if the target is not in range for a direct branch,
+               if we share a GP, we can eliminate the gp reload.  */
+            if (optdest)
+              {
+                Elf_Internal_Rela *gpdisp
+                  = (elf64_alpha_find_reloc_at_ofs
+                     (info->relocs, irelend, urel->r_offset + 4,
+                      R_ALPHA_GPDISP));
+                if (gpdisp)
+                  {
+                    bfd_byte *p_ldah = info->contents + gpdisp->r_offset;
+                    bfd_byte *p_lda = p_ldah + gpdisp->r_addend;
+                    unsigned int ldah = bfd_get_32 (info->abfd, p_ldah);
+                    unsigned int lda = bfd_get_32 (info->abfd, p_lda);
+
+                    /* Verify that the instruction is "ldah $29,0($26)".
+                       Consider a function that ends in a noreturn call,
+                       and that the next function begins with an ldgp,
+                       and that by accident there is no padding between.
+                       In that case the insn would use $27 as the base.  */
+                    if (ldah == 0x27ba0000 && lda == 0x23bd0000)
+                      {
+                        bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, p_ldah);
+                        bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, p_lda);
+
+                        gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
+                        info->changed_contents = TRUE;
+                        info->changed_relocs = TRUE;
+                      }
+                  }
+              }
           }
           break;
@@ -1311 +1500 @@
   if (all_optimized)
     {
-      info->gotent->use_count -= 1;
-      alpha_elf_tdata (info->gotent->gotobj)->total_got_entries -= 1;
-      if (!info->h)
-        alpha_elf_tdata (info->gotent->gotobj)->n_local_got_entries -= 1;
+      if (--info->gotent->use_count == 0)
+        {
+          int sz = alpha_got_entry_size (R_ALPHA_LITERAL);
+          alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
+          if (!info->h)
+            alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
+        }
 
       /* If the literal instruction is no longer needed (it may have been
-         reused.  We can eliminate it.
-         ??? For now, I don't want to deal with compacting the section,
+         reused.  We can eliminate it.  */
+      /* ??? For now, I don't want to deal with compacting the section,
          so just nop it out.  */
       if (!lit_reused)
         {
           irel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
-          info->changed_relocs = true;
-
-          bfd_put_32 (info->abfd, INSN_UNOP, info->contents + irel->r_offset);
-          info->changed_contents = true;
-        }
-    }
-
-  return irel + count;
+          info->changed_relocs = TRUE;
+
+          bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP,
+                      info->contents + irel->r_offset);
+          info->changed_contents = TRUE;
+        }
+    }
+
+  return TRUE;
 }
 
@@ -1405 +1598 @@
 }
 
-static boolean
-elf64_alpha_relax_without_lituse (info, symval, irel)
+static bfd_boolean
+elf64_alpha_relax_got_load (info, symval, irel, r_type)
      struct alpha_relax_info *info;
      bfd_vma symval;
      Elf_Internal_Rela *irel;
+     unsigned long r_type;
 {
   unsigned int insn;
@@ -1419 +1613 @@
   if (insn >> 26 != OP_LDQ)
     {
+      reloc_howto_type *howto = elf64_alpha_howto_table + r_type;
       ((*_bfd_error_handler)
-       ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
-        bfd_get_filename (info->abfd), info->sec->name,
-        (unsigned long) irel->r_offset));
-      return true;
-    }
-
-  /* So we aren't told much.  Do what we can with the address load and
-     fake the rest.  All of the optimizations here require that the
-     offset from the GP fit in 16 bits.  */
-
-  disp = symval - info->gp;
+       ("%s: %s+0x%lx: warning: %s relocation against unexpected insn",
+        bfd_archive_filename (info->abfd), info->sec->name,
+        (unsigned long) irel->r_offset, howto->name));
+      return TRUE;
+    }
+
+  /* Can't relax dynamic symbols.  */
+  if (alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info))
+    return TRUE;
+
+  /* Can't use local-exec relocations in shared libraries.  */
+  if (r_type == R_ALPHA_GOTTPREL && info->link_info->shared)
+    return TRUE;
+
+  if (r_type == R_ALPHA_LITERAL)
+    disp = symval - info->gp;
+  else
+    {
+      bfd_vma dtp_base, tp_base;
+
+      BFD_ASSERT (info->tls_segment != NULL);
+      dtp_base = alpha_get_dtprel_base (info->tls_segment);
+      tp_base = alpha_get_tprel_base (info->tls_segment);
+      disp = symval - (r_type == R_ALPHA_GOTDTPREL ? dtp_base : tp_base);
+    }
+
   if (disp < -0x8000 || disp >= 0x8000)
-    return true;
-
-  /* On the LITERAL instruction itself, consider exchanging
-     `ldq R,X(gp)' for `lda R,Y(gp)'.  */
-
-  insn = (OP_LDA << 26) | (insn & 0x03ff0000);
-  bfd_put_32 (info->abfd, insn, info->contents + irel->r_offset);
-  info->changed_contents = true;
-
-  irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), R_ALPHA_GPRELLOW);
-  info->changed_relocs = true;
+    return TRUE;
+
+  /* Exchange LDQ for LDA.  In the case of the TLS relocs, we're loading
+     a constant, so force the base register to be $31.  */
+  if (r_type == R_ALPHA_LITERAL)
+    insn = (OP_LDA << 26) | (insn & 0x03ff0000);
+  else
+    insn = (OP_LDA << 26) | (insn & (31 << 21)) | (31 << 16);
+  bfd_put_32 (info->abfd, (bfd_vma) insn, info->contents + irel->r_offset);
+  info->changed_contents = TRUE;
 
   /* Reduce the use count on this got entry by one, possibly
      eliminating it.  */
-  info->gotent->use_count -= 1;
-  alpha_elf_tdata (info->gotent->gotobj)->total_got_entries -= 1;
-  if (!info->h)
-    alpha_elf_tdata (info->gotent->gotobj)->n_local_got_entries -= 1;
+  if (--info->gotent->use_count == 0)
+    {
+      int sz = alpha_got_entry_size (r_type);
+      alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
+      if (!info->h)
+        alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
+    }
+
+  /* Smash the existing GOT relocation for its 16-bit immediate pair.  */
+  switch (r_type)
+    {
+    case R_ALPHA_LITERAL:
+      r_type = R_ALPHA_GPREL16;
+      break;
+    case R_ALPHA_GOTDTPREL:
+      r_type = R_ALPHA_DTPREL16;
+      break;
+    case R_ALPHA_GOTTPREL:
+      r_type = R_ALPHA_TPREL16;
+      break;
+    default:
+      BFD_ASSERT (0);
+      return FALSE;
+    }
+
+  irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), r_type);
+  info->changed_relocs = TRUE;
 
   /* ??? Search forward through this basic block looking for insns
@@ -1464 +1696 @@
      which gives one pause.  */
 
-  return true;
+  return TRUE;
 }
 
-static boolean
+static bfd_boolean
+elf64_alpha_relax_gprelhilo (info, symval, irel, hi)
+     struct alpha_relax_info *info;
+     bfd_vma symval;
+     Elf_Internal_Rela *irel;
+     bfd_boolean hi;
+{
+  unsigned int insn;
+  bfd_signed_vma disp;
+  bfd_byte *pos = info->contents + irel->r_offset;
+
+  /* ??? This assumes that the compiler doesn't render
+
+        array[i]
+     as
+        ldah    t, array(gp)    !gprelhigh
+        s8addl  i, t, t
+        ldq     r, array(t)     !gprellow
+
+     which would indeed be the most efficient way to implement this.  */
+
+  return TRUE;
+
+  disp = symval - info->gp;
+  if (disp < -0x8000 || disp >= 0x8000)
+    return TRUE;
+
+  if (hi)
+    {
+      /* Nop out the high instruction.  */
+
+      bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos);
+      info->changed_contents = TRUE;
+
+      irel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
+      irel->r_addend = 0;
+      info->changed_relocs = TRUE;
+    }
+  else
+    {
+      /* Adjust the low instruction to reference GP directly.  */
+
+      insn = bfd_get_32 (info->abfd, pos);
+      insn = (insn & 0xffe00000) | (29 << 16);
+      bfd_put_32 (info->abfd, (bfd_vma) insn, pos);
+      info->changed_contents = TRUE;
+
+      irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
+                                   R_ALPHA_GPREL16);
+      info->changed_relocs = TRUE;
+    }
+
+  return TRUE;
+}
+
+static bfd_boolean
+elf64_alpha_relax_tls_get_addr (info, symval, irel, is_gd)
+     struct alpha_relax_info *info;
+     bfd_vma symval;
+     Elf_Internal_Rela *irel;
+     bfd_boolean is_gd;
+{
+  bfd_byte *pos[5];
+  unsigned int insn;
+  Elf_Internal_Rela *gpdisp, *hint;
+  bfd_boolean dynamic, use_gottprel, pos1_unusable;
+  unsigned long new_symndx;
+
+  dynamic = alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info);
+
+  /* If a TLS symbol is accessed using IE at least once, there is no point
+     to use dynamic model for it.  */
+  if (is_gd && info->h && (info->h->flags & ALPHA_ELF_LINK_HASH_TLS_IE))
+    ;
+
+  /* If the symbol is local, and we've already committed to DF_STATIC_TLS,
+     then we might as well relax to IE.  */
+  else if (info->link_info->shared && !dynamic
+           && (info->link_info->flags & DF_STATIC_TLS))
+    ;
+
+  /* Otherwise we must be building an executable to do anything.  */
+  else if (info->link_info->shared)
+    return TRUE;
+
+  /* The TLSGD/TLSLDM relocation must be followed by a LITERAL and
+     the matching LITUSE_TLS relocations.  */
+  if (irel + 2 >= info->relend)
+    return TRUE;
+  if (ELF64_R_TYPE (irel[1].r_info) != R_ALPHA_LITERAL
+      || ELF64_R_TYPE (irel[2].r_info) != R_ALPHA_LITUSE
+      || irel[2].r_addend != (is_gd ? LITUSE_ALPHA_TLSGD : LITUSE_ALPHA_TLSLDM))
+    return TRUE;
+
+  /* There must be a GPDISP relocation positioned immediately after the
+     LITUSE relocation.  */
+  gpdisp = elf64_alpha_find_reloc_at_ofs (info->relocs, info->relend,
+                                          irel[2].r_offset + 4, R_ALPHA_GPDISP);
+  if (!gpdisp)
+    return TRUE;
+
+  pos[0] = info->contents + irel[0].r_offset;
+  pos[1] = info->contents + irel[1].r_offset;
+  pos[2] = info->contents + irel[2].r_offset;
+  pos[3] = info->contents + gpdisp->r_offset;
+  pos[4] = pos[3] + gpdisp->r_addend;
+  pos1_unusable = FALSE;
+
+  /* Generally, the positions are not allowed to be out of order, lest the
+     modified insn sequence have different register lifetimes.  We can make
+     an exception when pos 1 is adjacent to pos 0.  */
+  if (pos[1] + 4 == pos[0])
+    {
+      bfd_byte *tmp = pos[0];
+      pos[0] = pos[1];
+      pos[1] = tmp;
+    }
+  else if (pos[1] < pos[0])
+    pos1_unusable = TRUE;
+  if (pos[1] >= pos[2] || pos[2] >= pos[3])
+    return TRUE;
+
+  /* Reduce the use count on the LITERAL relocation.  Do this before we
+     smash the symndx when we adjust the relocations below.  */
+  {
+    struct alpha_elf_got_entry *lit_gotent;
+    struct alpha_elf_link_hash_entry *lit_h;
+    unsigned long indx;
+
+    BFD_ASSERT (ELF64_R_SYM (irel[1].r_info) >= info->symtab_hdr->sh_info);
+    indx = ELF64_R_SYM (irel[1].r_info) - info->symtab_hdr->sh_info;
+    lit_h = alpha_elf_sym_hashes (info->abfd)[indx];
+
+    while (lit_h->root.root.type == bfd_link_hash_indirect
+           || lit_h->root.root.type == bfd_link_hash_warning)
+      lit_h = (struct alpha_elf_link_hash_entry *) lit_h->root.root.u.i.link;
+
+    for (lit_gotent = lit_h->got_entries; lit_gotent ;
+         lit_gotent = lit_gotent->next)
+      if (lit_gotent->gotobj == info->gotobj
+          && lit_gotent->reloc_type == R_ALPHA_LITERAL
+          && lit_gotent->addend == irel[1].r_addend)
+        break;
+    BFD_ASSERT (lit_gotent);
+
+    if (--lit_gotent->use_count == 0)
+      {
+        int sz = alpha_got_entry_size (R_ALPHA_LITERAL);
+        alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
+      }
+  }
+
+  /* Change
+
+        lda     $16,x($gp)              !tlsgd!1
+        ldq     $27,__tls_get_addr($gp) !literal!1
+        jsr     $26,($27)__tls_get_addr !lituse_tlsgd!1
+        ldah    $29,0($26)              !gpdisp!2
+        lda     $29,0($29)              !gpdisp!2
+     to
+        ldq     $16,x($gp)              !gottprel
+        unop
+        call_pal rduniq
+        addq    $16,$0,$0
+        unop
+     or the first pair to
+        lda     $16,x($gp)              !tprel
+        unop
+     or
+        ldah    $16,x($gp)              !tprelhi
+        lda     $16,x($16)              !tprello
+
+     as appropriate.  */
+
+  use_gottprel = FALSE;
+  new_symndx = is_gd ? ELF64_R_SYM (irel->r_info) : 0;
+  switch (!dynamic && !info->link_info->shared)
+    {
+    case 1:
+      {
+        bfd_vma tp_base;
+        bfd_signed_vma disp;
+
+        BFD_ASSERT (info->tls_segment != NULL);
+        tp_base = alpha_get_tprel_base (info->tls_segment);
+        disp = symval - tp_base;
+
+        if (disp >= -0x8000 && disp < 0x8000)
+          {
+            insn = (OP_LDA << 26) | (16 << 21) | (31 << 16);
+            bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
+            bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[1]);
+
+            irel[0].r_offset = pos[0] - info->contents;
+            irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPREL16);
+            irel[1].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
+            break;
+          }
+        else if (disp >= -(bfd_signed_vma) 0x80000000
+                 && disp < (bfd_signed_vma) 0x7fff8000
+                 && !pos1_unusable)
+          {
+            insn = (OP_LDAH << 26) | (16 << 21) | (31 << 16);
+            bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
+            insn = (OP_LDA << 26) | (16 << 21) | (16 << 16);
+            bfd_put_32 (info->abfd, (bfd_vma) insn, pos[1]);
+
+            irel[0].r_offset = pos[0] - info->contents;
+            irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPRELHI);
+            irel[1].r_offset = pos[1] - info->contents;
+            irel[1].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPRELLO);
+            break;
+          }
+      }
+      /* FALLTHRU */
+
+    default:
+      use_gottprel = TRUE;
+
+      insn = (OP_LDQ << 26) | (16 << 21) | (29 << 16);
+      bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
+      bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[1]);
+
+      irel[0].r_offset = pos[0] - info->contents;
+      irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_GOTTPREL);
+      irel[1].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
+      break;
+    }
+
+  bfd_put_32 (info->abfd, (bfd_vma) INSN_RDUNIQ, pos[2]);
+
+  insn = INSN_ADDQ | (16 << 21) | (0 << 16) | (0 << 0);
+  bfd_put_32 (info->abfd, (bfd_vma) insn, pos[3]);
+
+  bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[4]);
+
+  irel[2].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
+  gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
+
+  hint = elf64_alpha_find_reloc_at_ofs (info->relocs, info->relend,
+                                        irel[2].r_offset, R_ALPHA_HINT);
+  if (hint)
+    hint->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
+
+  info->changed_contents = TRUE;
+  info->changed_relocs = TRUE;
+
+  /* Reduce the use count on the TLSGD/TLSLDM relocation.  */
+  if (--info->gotent->use_count == 0)
+    {
+      int sz = alpha_got_entry_size (info->gotent->reloc_type);
+      alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
+      if (!info->h)
+        alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
+    }
+
+  /* If we've switched to a GOTTPREL relocation, increment the reference
+     count on that got entry.  */
+  if (use_gottprel)
+    {
+      struct alpha_elf_got_entry *tprel_gotent;
+
+      for (tprel_gotent = *info->first_gotent; tprel_gotent ;
+           tprel_gotent = tprel_gotent->next)
+        if (tprel_gotent->gotobj == info->gotobj
+            && tprel_gotent->reloc_type == R_ALPHA_GOTTPREL
+            && tprel_gotent->addend == irel->r_addend)
+          break;
+      if (tprel_gotent)
+        tprel_gotent->use_count++;
+      else
+        {
+          if (info->gotent->use_count == 0)
+            tprel_gotent = info->gotent;
+          else
+            {
+              tprel_gotent = (struct alpha_elf_got_entry *)
+                bfd_alloc (info->abfd, sizeof (struct alpha_elf_got_entry));
+              if (!tprel_gotent)
+                return FALSE;
+
+              tprel_gotent->next = *info->first_gotent;
+              *info->first_gotent = tprel_gotent;
+
+              tprel_gotent->gotobj = info->gotobj;
+              tprel_gotent->addend = irel->r_addend;
+              tprel_gotent->got_offset = -1;
+              tprel_gotent->reloc_done = 0;
+              tprel_gotent->reloc_xlated = 0;
+            }
+
+          tprel_gotent->use_count = 1;
+          tprel_gotent->reloc_type = R_ALPHA_GOTTPREL;
+        }
+    }
+
+  return TRUE;
+}
+
+static struct elf_link_tls_segment *
+elf64_alpha_relax_find_tls_segment (info, seg)
+     struct alpha_relax_info *info;
+     struct elf_link_tls_segment *seg;
+{
+  bfd *output_bfd = info->sec->output_section->owner;
+  asection *o;
+  unsigned int align;
+  bfd_vma base, end;
+
+  for (o = output_bfd->sections; o ; o = o->next)
+    if ((o->flags & SEC_THREAD_LOCAL) != 0
+        && (o->flags & SEC_LOAD) != 0)
+      break;
+  if (!o)
+    return NULL;
+
+  base = o->vma;
+  align = 0;
+
+  do
+    {
+      bfd_vma size;
+
+      if (bfd_get_section_alignment (output_bfd, o) > align)
+        align = bfd_get_section_alignment (output_bfd, o);
+
+      size = o->_raw_size;
+      if (size == 0 && (o->flags & SEC_HAS_CONTENTS) == 0)
+        {
+          struct bfd_link_order *lo;
+          for (lo = o->link_order_head; lo ; lo = lo->next)
+            if (size < lo->offset + lo->size)
+              size = lo->offset + lo->size;
+        }
+      end = o->vma + size;
+      o = o->next;
+    }
+  while (o && (o->flags & SEC_THREAD_LOCAL));
+
+  seg->start = base;
+  seg->size = end - base;
+  seg->align = align;
+
+  return seg;
+}
+
+static bfd_boolean
 elf64_alpha_relax_section (abfd, sec, link_info, again)
      bfd *abfd;
      asection *sec;
      struct bfd_link_info *link_info;
-     boolean *again;
+     bfd_boolean *again;
 {
   Elf_Internal_Shdr *symtab_hdr;
   Elf_Internal_Rela *internal_relocs;
-  Elf_Internal_Rela *free_relocs = NULL;
   Elf_Internal_Rela *irel, *irelend;
-  bfd_byte *free_contents = NULL;
-  Elf64_External_Sym *extsyms = NULL;
-  Elf64_External_Sym *free_extsyms = NULL;
+  Elf_Internal_Sym *isymbuf = NULL;
   struct alpha_elf_got_entry **local_got_entries;
   struct alpha_relax_info info;
+  struct elf_link_tls_segment tls_segment;
 
   /* We are not currently changing any sizes, so only one pass.  */
-  *again = false;
+  *again = FALSE;
 
   if (link_info->relocateable
       || (sec->flags & SEC_RELOC) == 0
       || sec->reloc_count == 0)
-    return true;
+    return TRUE;
 
   /* If this is the first time we have been called for this section,
@@ -1505 +2081 @@
                       link_info->keep_memory));
   if (internal_relocs == NULL)
-    goto error_return;
-  if (! link_info->keep_memory)
-    free_relocs = internal_relocs;
+    return FALSE;
 
   memset(&info, 0, sizeof (info));
@@ -1513 +2087 @@
   info.sec = sec;
   info.link_info = link_info;
+  info.symtab_hdr = symtab_hdr;
   info.relocs = internal_relocs;
   info.relend = irelend = internal_relocs + sec->reloc_count;
 
-  /* Find the GP for this object.  */
+  /* Find the GP for this object.  Do not store the result back via
+     _bfd_set_gp_value, since this could change again before final.  */
   info.gotobj = alpha_elf_tdata (abfd)->gotobj;
   if (info.gotobj)
     {
       asection *sgot = alpha_elf_tdata (info.gotobj)->got;
-      info.gp = _bfd_get_gp_value (info.gotobj);
-      if (info.gp == 0)
-        {
-          info.gp = (sgot->output_section->vma
-                     + sgot->output_offset
-                     + 0x8000);
-          _bfd_set_gp_value (info.gotobj, info.gp);
-        }
-    }
+      info.gp = (sgot->output_section->vma
+                 + sgot->output_offset
+                 + 0x8000);
+    }
+
+  /* Get the section contents.  */
+  if (elf_section_data (sec)->this_hdr.contents != NULL)
+    info.contents = elf_section_data (sec)->this_hdr.contents;
+  else
+    {
+      info.contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
+      if (info.contents == NULL)
+        goto error_return;
+
+      if (! bfd_get_section_contents (abfd, sec, info.contents,
+                                      (file_ptr) 0, sec->_raw_size))
+        goto error_return;
+    }
+
+  /* Compute the TLS segment information.  The version normally found in
+     elf_hash_table (link_info)->tls_segment isn't built until final_link.
+     ??? Probably should look into extracting this into a common function.  */
+  info.tls_segment = elf64_alpha_relax_find_tls_segment (&info, &tls_segment);
 
   for (irel = internal_relocs; irel < irelend; irel++)
     {
       bfd_vma symval;
-      Elf_Internal_Sym isym;
       struct alpha_elf_got_entry *gotent;
-
-      if (ELF64_R_TYPE (irel->r_info) != (int) R_ALPHA_LITERAL)
-        continue;
-
-      /* Get the section contents.  */
-      if (info.contents == NULL)
-        {
-          if (elf_section_data (sec)->this_hdr.contents != NULL)
-            info.contents = elf_section_data (sec)->this_hdr.contents;
+      unsigned long r_type = ELF64_R_TYPE (irel->r_info);
+      unsigned long r_symndx = ELF64_R_SYM (irel->r_info);
+
+      /* Early exit for unhandled or unrelaxable relocations.  */
+      switch (r_type)
+        {
+        case R_ALPHA_LITERAL:
+        case R_ALPHA_GPRELHIGH:
+        case R_ALPHA_GPRELLOW:
+        case R_ALPHA_GOTDTPREL:
+        case R_ALPHA_GOTTPREL:
+        case R_ALPHA_TLSGD:
+          break;
+
+        case R_ALPHA_TLSLDM:
+          /* The symbol for a TLSLDM reloc is ignored.  Collapse the
+             reloc to the 0 symbol so that they all match.  */
+          r_symndx = 0;
+          break;
+
+        default:
+          continue;
+        }
+
+      /* Get the value of the symbol referred to by the reloc.  */
+      if (r_symndx < symtab_hdr->sh_info)
+        {
+          /* A local symbol.  */
+          Elf_Internal_Sym *isym;
+
+          /* Read this BFD's local symbols.  */
+          if (isymbuf == NULL)
+            {
+              isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
+              if (isymbuf == NULL)
+                isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
+                                                symtab_hdr->sh_info, 0,
+                                                NULL, NULL, NULL);
+              if (isymbuf == NULL)
+                goto error_return;
+            }
+
+          isym = isymbuf + r_symndx;
+
+          /* Given the symbol for a TLSLDM reloc is ignored, this also
+             means forcing the symbol value to the tp base.  */
+          if (r_type == R_ALPHA_TLSLDM)
+            {
+              info.tsec = bfd_abs_section_ptr;
+              symval = alpha_get_tprel_base (info.tls_segment);
+            }
           else
             {
-              info.contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
-              if (info.contents == NULL)
-                goto error_return;
-              free_contents = info.contents;
-
-              if (! bfd_get_section_contents (abfd, sec, info.contents,
-                                              (file_ptr) 0, sec->_raw_size))
-                goto error_return;
+              symval = isym->st_value;
+              if (isym->st_shndx == SHN_UNDEF)
+                continue;
+              else if (isym->st_shndx == SHN_ABS)
+                info.tsec = bfd_abs_section_ptr;
+              else if (isym->st_shndx == SHN_COMMON)
+                info.tsec = bfd_com_section_ptr;
+              else
+                info.tsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
             }
-        }
-
-      /* Read this BFD's symbols if we haven't done so already.  */
-      if (extsyms == NULL)
-        {
-          if (symtab_hdr->contents != NULL)
-            extsyms = (Elf64_External_Sym *) symtab_hdr->contents;
+
+          info.h = NULL;
+          info.other = isym->st_other;
+          if (local_got_entries)
+            info.first_gotent = &local_got_entries[r_symndx];
           else
             {
-              extsyms = ((Elf64_External_Sym *)
-                         bfd_malloc (symtab_hdr->sh_size));
-              if (extsyms == NULL)
-                goto error_return;
-              free_extsyms = extsyms;
-              if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
-                  || (bfd_read (extsyms, 1, symtab_hdr->sh_size, abfd)
-                      != symtab_hdr->sh_size))
-                goto error_return;
+              info.first_gotent = &info.gotent;
+              info.gotent = NULL;
             }
-        }
-
-      /* Get the value of the symbol referred to by the reloc.  */
-      if (ELF64_R_SYM (irel->r_info) < symtab_hdr->sh_info)
-        {
-          /* A local symbol.  */
-          bfd_elf64_swap_symbol_in (abfd,
-                                    extsyms + ELF64_R_SYM (irel->r_info),
-                                    &isym);
-          if (isym.st_shndx == SHN_UNDEF)
-            info.tsec = bfd_und_section_ptr;
-          else if (isym.st_shndx > 0 && isym.st_shndx < SHN_LORESERVE)
-            info.tsec = bfd_section_from_elf_index (abfd, isym.st_shndx);
-          else if (isym.st_shndx == SHN_ABS)
-            info.tsec = bfd_abs_section_ptr;
-          else if (isym.st_shndx == SHN_COMMON)
-            info.tsec = bfd_com_section_ptr;
-          else
-            continue;   /* who knows.  */
-
-          info.h = NULL;
-          info.other = isym.st_other;
-          gotent = local_got_entries[ELF64_R_SYM(irel->r_info)];
-          symval = isym.st_value;
         }
       else
@@ -1605 +2204 @@
           struct alpha_elf_link_hash_entry *h;
 
-          indx = ELF64_R_SYM (irel->r_info) - symtab_hdr->sh_info;
+          indx = r_symndx - symtab_hdr->sh_info;
           h = alpha_elf_sym_hashes (abfd)[indx];
           BFD_ASSERT (h != NULL);
@@ -1613 +2212 @@
             h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
 
-          /* We can't do anthing with undefined or dynamic symbols.  */
-          if (h->root.root.type == bfd_link_hash_undefined
-              || h->root.root.type == bfd_link_hash_undefweak
-              || alpha_elf_dynamic_symbol_p (&h->root, link_info))
+          /* If the symbol is undefined, we can't do anything with it.  */
+          if (h->root.root.type == bfd_link_hash_undefweak
+              || h->root.root.type == bfd_link_hash_undefined)
             continue;
 
+          /* If the symbol isn't defined in the current module, again
+             we can't do anything.  */
+          if (!(h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
+            {
+              /* Except for TLSGD relocs, which can sometimes be
+                 relaxed to GOTTPREL relocs.  */
+              if (r_type != R_ALPHA_TLSGD)
+                continue;
+              info.tsec = bfd_abs_section_ptr;
+              symval = 0;
+            }
+          else
+            {
+              info.tsec = h->root.root.u.def.section;
+              symval = h->root.root.u.def.value;
+            }
+
           info.h = h;
-          info.gotent = gotent;
-          info.tsec = h->root.root.u.def.section;
           info.other = h->root.other;
-          gotent = h->got_entries;
-          symval = h->root.root.u.def.value;
+          info.first_gotent = &h->got_entries;
         }
 
       /* Search for the got entry to be used by this relocation.  */
-      while (gotent->gotobj != info.gotobj || gotent->addend != irel->r_addend)
-        gotent = gotent->next;
+      for (gotent = *info.first_gotent; gotent ; gotent = gotent->next)
+        if (gotent->gotobj == info.gotobj
+            && gotent->reloc_type == r_type
+            && gotent->addend == irel->r_addend)
+          break;
       info.gotent = gotent;
 
@@ -1635 +2250 @@
       symval += irel->r_addend;
 
-      BFD_ASSERT(info.gotent != NULL);
-
-      /* If there exist LITUSE relocations immediately following, this
-         opens up all sorts of interesting optimizations, because we
-         now know every location that this address load is used.  */
-
-      if (irel+1 < irelend && ELF64_R_TYPE (irel[1].r_info) == R_ALPHA_LITUSE)
-        {
-          irel = elf64_alpha_relax_with_lituse (&info, symval, irel, irelend);
-          if (irel == NULL)
+      switch (r_type)
+        {
+        case R_ALPHA_LITERAL:
+          BFD_ASSERT(info.gotent != NULL);
+
+          /* If there exist LITUSE relocations immediately following, this
+             opens up all sorts of interesting optimizations, because we
+             now know every location that this address load is used.  */
+          if (irel+1 < irelend
+              && ELF64_R_TYPE (irel[1].r_info) == R_ALPHA_LITUSE)
+            {
+              if (!elf64_alpha_relax_with_lituse (&info, symval, irel))
+                goto error_return;
+            }
+          else
+            {
+              if (!elf64_alpha_relax_got_load (&info, symval, irel, r_type))
+                goto error_return;
+            }
+          break;
+
+        case R_ALPHA_GPRELHIGH:
+        case R_ALPHA_GPRELLOW:
+          if (!elf64_alpha_relax_gprelhilo (&info, symval, irel,
+                                            r_type == R_ALPHA_GPRELHIGH))
             goto error_return;
-        }
+          break;
+
+        case R_ALPHA_GOTDTPREL:
+        case R_ALPHA_GOTTPREL:
+          BFD_ASSERT(info.gotent != NULL);
+          if (!elf64_alpha_relax_got_load (&info, symval, irel, r_type))
+            goto error_return;
+          break;
+
+        case R_ALPHA_TLSGD:
+        case R_ALPHA_TLSLDM:
+          BFD_ASSERT(info.gotent != NULL);
+          if (!elf64_alpha_relax_tls_get_addr (&info, symval, irel,
+                                               r_type == R_ALPHA_TLSGD))
+            goto error_return;
+          break;
+        }
+    }
+
+  if (!elf64_alpha_size_plt_section (link_info))
+    return FALSE;
+  if (!elf64_alpha_size_got_sections (link_info))
+    return FALSE;
+  if (!elf64_alpha_size_rela_got_section (link_info))
+    return FALSE;
+
+  if (isymbuf != NULL
+      && symtab_hdr->contents != (unsigned char *) isymbuf)
+    {
+      if (!link_info->keep_memory)
+        free (isymbuf);
       else
         {
-          if (!elf64_alpha_relax_without_lituse (&info, symval, irel))
-            goto error_return;
-        }
-    }
-
-  if (!elf64_alpha_size_got_sections (abfd, link_info))
-    return false;
-
-  if (info.changed_relocs)
-    {
-      elf_section_data (sec)->relocs = internal_relocs;
-    }
-  else if (free_relocs != NULL)
-    {
-      free (free_relocs);
-    }
-
-  if (info.changed_contents)
-    {
-      elf_section_data (sec)->this_hdr.contents = info.contents;
-    }
-  else if (free_contents != NULL)
-    {
-      if (! link_info->keep_memory)
-        free (free_contents);
+          /* Cache the symbols for elf_link_input_bfd.  */
+          symtab_hdr->contents = (unsigned char *) isymbuf;
+        }
+    }
+
+  if (info.contents != NULL
+      && elf_section_data (sec)->this_hdr.contents != info.contents)
+    {
+      if (!info.changed_contents && !link_info->keep_memory)
+        free (info.contents);
       else
         {
@@ -1681 +2326 @@
     }
 
-  if (free_extsyms != NULL)
-    {
-      if (! link_info->keep_memory)
-        free (free_extsyms);
+  if (elf_section_data (sec)->relocs != internal_relocs)
+    {
+      if (!info.changed_relocs)
+        free (internal_relocs);
       else
-        {
-          /* Cache the symbols for elf_link_input_bfd.  */
-          symtab_hdr->contents = extsyms;
-        }
+        elf_section_data (sec)->relocs = internal_relocs;
     }
 
   *again = info.changed_contents || info.changed_relocs;
 
-  return true;
+  return TRUE;
 
  error_return:
-  if (free_relocs != NULL)
-    free (free_relocs);
-  if (free_contents != NULL)
-    free (free_contents);
-  if (free_extsyms != NULL)
-    free (free_extsyms);
-  return false;
+  if (isymbuf != NULL
+      && symtab_hdr->contents != (unsigned char *) isymbuf)
+    free (isymbuf);
+  if (info.contents != NULL
+      && elf_section_data (sec)->this_hdr.contents != info.contents)
+    free (info.contents);
+  if (internal_relocs != NULL
+      && elf_section_data (sec)->relocs != internal_relocs)
+    free (internal_relocs);
+  return FALSE;
 }
 
@@ -1709 +2354 @@
 /* PLT/GOT Stuff */
 #define PLT_HEADER_SIZE 32
-#define PLT_HEADER_WORD1        0xc3600000      /* br   $27,.+4     */
-#define PLT_HEADER_WORD2        0xa77b000c      /* ldq  $27,12($27) */
-#define PLT_HEADER_WORD3        0x47ff041f      /* nop              */
-#define PLT_HEADER_WORD4        0x6b7b0000      /* jmp  $27,($27)   */
+#define PLT_HEADER_WORD1        (bfd_vma) 0xc3600000    /* br   $27,.+4     */
+#define PLT_HEADER_WORD2        (bfd_vma) 0xa77b000c    /* ldq  $27,12($27) */
+#define PLT_HEADER_WORD3        (bfd_vma) 0x47ff041f    /* nop              */
+#define PLT_HEADER_WORD4        (bfd_vma) 0x6b7b0000    /* jmp  $27,($27)   */
 
 #define PLT_ENTRY_SIZE 12
@@ -1719 +2364 @@
 #define PLT_ENTRY_WORD3         0
 
-#define MAX_GOT_ENTRIES         (64*1024 / 8)
+#define MAX_GOT_SIZE            (64*1024)
 
 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so"
@@ -1729 +2374 @@
    how to.  */
 
-static boolean
+static bfd_boolean
 elf64_alpha_section_from_shdr (abfd, hdr, name)
      bfd *abfd;
-     Elf64_Internal_Shdr *hdr;
-     char *name;
+     Elf_Internal_Shdr *hdr;
+     const char *name;
 {
   asection *newsect;
@@ -1746 +2391 @@
     case SHT_ALPHA_DEBUG:
       if (strcmp (name, ".mdebug") != 0)
-        return false;
+        return FALSE;
       break;
-#ifdef ERIC_neverdef
-    case SHT_ALPHA_REGINFO:
-      if (strcmp (name, ".reginfo") != 0
-          || hdr->sh_size != sizeof (Elf64_External_RegInfo))
-        return false;
-      break;
-#endif
     default:
-      return false;
+      return FALSE;
     }
 
   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
-    return false;
+    return FALSE;
   newsect = hdr->bfd_section;
 
@@ -1768 +2406 @@
                                    (bfd_get_section_flags (abfd, newsect)
                                     | SEC_DEBUGGING)))
-        return false;
-    }
-
-#ifdef ERIC_neverdef
-  /* For a .reginfo section, set the gp value in the tdata information
-     from the contents of this section.  We need the gp value while
-     processing relocs, so we just get it now.  */
-  if (hdr->sh_type == SHT_ALPHA_REGINFO)
-    {
-      Elf64_External_RegInfo ext;
-      Elf64_RegInfo s;
-
-      if (! bfd_get_section_contents (abfd, newsect, (PTR) &ext,
-                                      (file_ptr) 0, sizeof ext))
-        return false;
-      bfd_alpha_elf64_swap_reginfo_in (abfd, &ext, &s);
-      elf_gp (abfd) = s.ri_gp_value;
-    }
-#endif
-
-  return true;
+        return FALSE;
+    }
+
+  return TRUE;
+}
+
+/* Convert Alpha specific section flags to bfd internal section flags.  */
+
+static bfd_boolean
+elf64_alpha_section_flags (flags, hdr)
+     flagword *flags;
+     Elf_Internal_Shdr *hdr;
+{
+  if (hdr->sh_flags & SHF_ALPHA_GPREL)
+    *flags |= SEC_SMALL_DATA;
+
+  return TRUE;
 }
 
@@ -1794 +2428 @@
    section name, which is a hack, but ought to work.  */
 
-static boolean
+static bfd_boolean
 elf64_alpha_fake_sections (abfd, hdr, sec)
      bfd *abfd;
-     Elf64_Internal_Shdr *hdr;
+     Elf_Internal_Shdr *hdr;
      asection *sec;
 {
@@ -1814 +2448 @@
         hdr->sh_entsize = 1;
     }
-#ifdef ERIC_neverdef
-  else if (strcmp (name, ".reginfo") == 0)
-    {
-      hdr->sh_type = SHT_ALPHA_REGINFO;
-      /* In a shared object on Irix 5.3, the .reginfo section has an
-         entsize of 0x18.  FIXME: Does this matter?  */
-      if ((abfd->flags & DYNAMIC) != 0)
-        hdr->sh_entsize = sizeof (Elf64_External_RegInfo);
-      else
-        hdr->sh_entsize = 1;
-
-      /* Force the section size to the correct value, even if the
-         linker thinks it is larger.  The link routine below will only
-         write out this much data for .reginfo.  */
-      hdr->sh_size = sec->_raw_size = sizeof (Elf64_External_RegInfo);
-    }
-  else if (strcmp (name, ".hash") == 0
-           || strcmp (name, ".dynamic") == 0
-           || strcmp (name, ".dynstr") == 0)
-    {
-      hdr->sh_entsize = 0;
-      hdr->sh_info = SIZEOF_ALPHA_DYNSYM_SECNAMES;
-    }
-#endif
-  else if (strcmp (name, ".sdata") == 0
+  else if ((sec->flags & SEC_SMALL_DATA)
+           || strcmp (name, ".sdata") == 0
            || strcmp (name, ".sbss") == 0
            || strcmp (name, ".lit4") == 0
@@ -1844 +2455 @@
     hdr->sh_flags |= SHF_ALPHA_GPREL;
 
-  return true;
+  return TRUE;
 }
 
@@ -1850 +2461 @@
    file.  We use it to put .comm items in .sbss, and not .bss.  */
 
-static boolean
+static bfd_boolean
 elf64_alpha_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
      bfd *abfd;
@@ -1862 +2473 @@
   if (sym->st_shndx == SHN_COMMON
       && !info->relocateable
-      && sym->st_size <= bfd_get_gp_size (abfd))
+      && sym->st_size <= elf_gp_size (abfd))
     {
       /* Common symbols less than or equal to -G nn bytes are
@@ -1876 +2487 @@
                                                        | SEC_IS_COMMON
                                                        | SEC_LINKER_CREATED)))
-            return false;
+            return FALSE;
         }
 
@@ -1883 +2494 @@
     }
 
-  return true;
+  return TRUE;
 }
 
 /* Create the .got section.  */
 
-static boolean
+static bfd_boolean
 elf64_alpha_create_got_section(abfd, info)
      bfd *abfd;
@@ -1896 +2507 @@
 
   if (bfd_get_section_by_name (abfd, ".got"))
-    return true;
+    return TRUE;
 
   s = bfd_make_section (abfd, ".got");
@@ -1905 +2516 @@
                                            | SEC_LINKER_CREATED))
       || !bfd_set_section_alignment (abfd, s, 3))
-    return false;
+    return FALSE;
 
   alpha_elf_tdata (abfd)->got = s;
 
-  return true;
+  return TRUE;
 }
 
 /* Create all the dynamic sections.  */
 
-static boolean
+static bfd_boolean
 elf64_alpha_create_dynamic_sections (abfd, info)
      bfd *abfd;
@@ -1921 +2532 @@
   asection *s;
   struct elf_link_hash_entry *h;
+  struct bfd_link_hash_entry *bh;
 
   /* We need to create .plt, .rela.plt, .got, and .rela.got sections.  */
@@ -1932 +2544 @@
                                             | SEC_CODE))
       || ! bfd_set_section_alignment (abfd, s, 3))
-    return false;
+    return FALSE;
 
   /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
      .plt section.  */
-  h = NULL;
+  bh = NULL;
   if (! (_bfd_generic_link_add_one_symbol
          (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
-          (bfd_vma) 0, (const char *) NULL, false,
-          get_elf_backend_data (abfd)->collect,
-          (struct bfd_link_hash_entry **) &h)))
-    return false;
+          (bfd_vma) 0, (const char *) NULL, FALSE,
+          get_elf_backend_data (abfd)->collect, &bh)))
+    return FALSE;
+  h = (struct elf_link_hash_entry *) bh;
   h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
   h->type = STT_OBJECT;
@@ -1948 +2560 @@
   if (info->shared
       && ! _bfd_elf_link_record_dynamic_symbol (info, h))
-    return false;
+    return FALSE;
 
   s = bfd_make_section (abfd, ".rela.plt");
@@ -1958 +2570 @@
                                            | SEC_READONLY))
       || ! bfd_set_section_alignment (abfd, s, 3))
-    return false;
+    return FALSE;
 
   /* We may or may not have created a .got section for this object, but
@@ -1964 +2576 @@
 
   if (!elf64_alpha_create_got_section (abfd, info))
-    return false;
+    return FALSE;
 
   s = bfd_make_section(abfd, ".rela.got");
@@ -1974 +2586 @@
                                            | SEC_READONLY))
       || !bfd_set_section_alignment (abfd, s, 3))
-    return false;
+    return FALSE;
 
   /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
@@ -1980 +2592 @@
      because we don't want to define the symbol if we are not creating
      a global offset table.  */
-  h = NULL;
+  bh = NULL;
   if (!(_bfd_generic_link_add_one_symbol
         (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL,
          alpha_elf_tdata(abfd)->got, (bfd_vma) 0, (const char *) NULL,
-         false, get_elf_backend_data (abfd)->collect,
-         (struct bfd_link_hash_entry **) &h)))
-    return false;
+         FALSE, get_elf_backend_data (abfd)->collect, &bh)))
+    return FALSE;
+  h = (struct elf_link_hash_entry *) bh;
   h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
   h->type = STT_OBJECT;
@@ -1992 +2604 @@
   if (info->shared
       && ! _bfd_elf_link_record_dynamic_symbol (info, h))
-    return false;
+    return FALSE;
 
   elf_hash_table (info)->hgot = h;
 
-  return true;
+  return TRUE;
 }
 
@@ -2003 +2615 @@
    ecoff_debug_info structure.  */
 
-static boolean
+static bfd_boolean
 elf64_alpha_read_ecoff_info (abfd, section, debug)
      bfd *abfd;
@@ -2016 +2628 @@
   memset (debug, 0, sizeof (*debug));
 
-  ext_hdr = (char *) bfd_malloc ((size_t) swap->external_hdr_size);
+  ext_hdr = (char *) bfd_malloc (swap->external_hdr_size);
   if (ext_hdr == NULL && swap->external_hdr_size != 0)
     goto error_return;
 
-  if (bfd_get_section_contents (abfd, section, ext_hdr, (file_ptr) 0,
-                                swap->external_hdr_size)
-      == false)
+  if (! bfd_get_section_contents (abfd, section, ext_hdr, (file_ptr) 0,
+                                  swap->external_hdr_size))
     goto error_return;
 
@@ -2035 +2646 @@
   else                                                                  \
     {                                                                   \
-      debug->ptr = (type) bfd_malloc ((size_t) (size * symhdr->count)); \
+      bfd_size_type amt = (bfd_size_type) size * symhdr->count;         \
+      debug->ptr = (type) bfd_malloc (amt);                             \
       if (debug->ptr == NULL)                                           \
         goto error_return;                                              \
       if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0     \
-          || (bfd_read (debug->ptr, size, symhdr->count,                \
-                        abfd) != size * symhdr->count))                 \
+          || bfd_bread (debug->ptr, amt, abfd) != amt)                  \
         goto error_return;                                              \
     }
@@ -2061 +2672 @@
   debug->adjust = NULL;
 
-  return true;
+  return TRUE;
 
  error_return:
@@ -2088 +2699 @@
   if (debug->external_ext != NULL)
     free (debug->external_ext);
-  return false;
+  return FALSE;
 }
 
 /* Alpha ELF local labels start with '$'.  */
 
-static boolean
+static bfd_boolean
 elf64_alpha_is_local_label_name (abfd, name)
      bfd *abfd ATTRIBUTE_UNUSED;
@@ -2112 +2723 @@
 };
 
-static boolean
+static bfd_boolean
 elf64_alpha_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
                                functionname_ptr, line_ptr)
@@ -2129 +2740 @@
                                      line_ptr, 0,
                                      &elf_tdata (abfd)->dwarf2_find_line_info))
-    return true;
+    return TRUE;
 
   msec = bfd_get_section_by_name (abfd, ".mdebug");
@@ -2153 +2764 @@
           char *fraw_end;
           struct fdr *fdr_ptr;
-
-          fi = ((struct mips_elf_find_line *)
-                bfd_zalloc (abfd, sizeof (struct mips_elf_find_line)));
+          bfd_size_type amt = sizeof (struct mips_elf_find_line);
+
+          fi = (struct mips_elf_find_line *) bfd_zalloc (abfd, amt);
           if (fi == NULL)
             {
               msec->flags = origflags;
-              return false;
+              return FALSE;
             }
 
@@ -2165 +2776 @@
             {
               msec->flags = origflags;
-              return false;
+              return FALSE;
             }
 
           /* Swap in the FDR information.  */
-          fi->d.fdr = ((struct fdr *)
-                       bfd_alloc (abfd,
-                                  (fi->d.symbolic_header.ifdMax *
-                                   sizeof (struct fdr))));
+          amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
+          fi->d.fdr = (struct fdr *) bfd_alloc (abfd, amt);
           if (fi->d.fdr == NULL)
             {
               msec->flags = origflags;
-              return false;
+              return FALSE;
             }
           external_fdr_size = swap->external_fdr_size;
@@ -2201 +2810 @@
         {
           msec->flags = origflags;
-          return true;
+          return TRUE;
         }
 
@@ -2223 +2832 @@
   struct ecoff_debug_info *debug;
   const struct ecoff_debug_swap *swap;
-  boolean failed;
+  bfd_boolean failed;
 };
 
-static boolean
+static bfd_boolean
 elf64_alpha_output_extsym (h, data)
      struct alpha_elf_link_hash_entry *h;
@@ -2232 +2841 @@
 {
   struct extsym_info *einfo = (struct extsym_info *) data;
-  boolean strip;
+  bfd_boolean strip;
   asection *sec, *output_section;
 
+  if (h->root.root.type == bfd_link_hash_warning)
+    h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
+
   if (h->root.indx == -2)
-    strip = false;
+    strip = FALSE;
   else if (((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
-           || (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
-          && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
-          && (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
-    strip = true;
+            || (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
+           && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
+           && (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
+    strip = TRUE;
   else if (einfo->info->strip == strip_all
-          || (einfo->info->strip == strip_some
-              && bfd_hash_lookup (einfo->info->keep_hash,
-                                  h->root.root.root.string,
-                                  false, false) == NULL))
-    strip = true;
+           || (einfo->info->strip == strip_some
+               && bfd_hash_lookup (einfo->info->keep_hash,
+                                   h->root.root.root.string,
+                                   FALSE, FALSE) == NULL))
+    strip = TRUE;
   else
-    strip = false;
+    strip = FALSE;
 
   if (strip)
-    return true;
+    return TRUE;
 
   if (h->esym.ifd == -2)
@@ -2265 +2877 @@
 
       if (h->root.root.type != bfd_link_hash_defined
-         && h->root.root.type != bfd_link_hash_defweak)
-       h->esym.asym.sc = scAbs;
+          && h->root.root.type != bfd_link_hash_defweak)
+        h->esym.asym.sc = scAbs;
       else
-       {
-         const char *name;
-
-         sec = h->root.root.u.def.section;
-         output_section = sec->output_section;
-
-         /* When making a shared library and symbol h is the one from
-            the another shared library, OUTPUT_SECTION may be null.  */
-         if (output_section == NULL)
-           h->esym.asym.sc = scUndefined;
-         else
-           {
-             name = bfd_section_name (output_section->owner, output_section);
-
-             if (strcmp (name, ".text") == 0)
-               h->esym.asym.sc = scText;
-             else if (strcmp (name, ".data") == 0)
-               h->esym.asym.sc = scData;
-             else if (strcmp (name, ".sdata") == 0)
-               h->esym.asym.sc = scSData;
-             else if (strcmp (name, ".rodata") == 0
-                      || strcmp (name, ".rdata") == 0)
-               h->esym.asym.sc = scRData;
-             else if (strcmp (name, ".bss") == 0)
-               h->esym.asym.sc = scBss;
-             else if (strcmp (name, ".sbss") == 0)
-               h->esym.asym.sc = scSBss;
-             else if (strcmp (name, ".init") == 0)
-               h->esym.asym.sc = scInit;
-             else if (strcmp (name, ".fini") == 0)
-               h->esym.asym.sc = scFini;
-             else
-               h->esym.asym.sc = scAbs;
-           }
-       }
+        {
+          const char *name;
+
+          sec = h->root.root.u.def.section;
+          output_section = sec->output_section;
+
+          /* When making a shared library and symbol h is the one from
+             the another shared library, OUTPUT_SECTION may be null.  */
+          if (output_section == NULL)
+            h->esym.asym.sc = scUndefined;
+          else
+            {
+              name = bfd_section_name (output_section->owner, output_section);
+
+              if (strcmp (name, ".text") == 0)
+                h->esym.asym.sc = scText;
+              else if (strcmp (name, ".data") == 0)
+                h->esym.asym.sc = scData;
+              else if (strcmp (name, ".sdata") == 0)
+                h->esym.asym.sc = scSData;
+              else if (strcmp (name, ".rodata") == 0
+                       || strcmp (name, ".rdata") == 0)
+                h->esym.asym.sc = scRData;
+              else if (strcmp (name, ".bss") == 0)
+                h->esym.asym.sc = scBss;
+              else if (strcmp (name, ".sbss") == 0)
+                h->esym.asym.sc = scSBss;
+              else if (strcmp (name, ".init") == 0)
+                h->esym.asym.sc = scInit;
+              else if (strcmp (name, ".fini") == 0)
+                h->esym.asym.sc = scFini;
+              else
+                h->esym.asym.sc = scAbs;
+            }
+        }
 
       h->esym.asym.reserved = 0;
@@ -2314 +2926 @@
     {
       if (h->esym.asym.sc == scCommon)
-       h->esym.asym.sc = scBss;
+        h->esym.asym.sc = scBss;
       else if (h->esym.asym.sc == scSCommon)
-       h->esym.asym.sc = scSBss;
+        h->esym.asym.sc = scSBss;
 
       sec = h->root.root.u.def.section;
       output_section = sec->output_section;
       if (output_section != NULL)
-       h->esym.asym.value = (h->root.root.u.def.value
-                             + sec->output_offset
-                             + output_section->vma);
+        h->esym.asym.value = (h->root.root.u.def.value
+                              + sec->output_offset
+                              + output_section->vma);
       else
-       h->esym.asym.value = 0;
+        h->esym.asym.value = 0;
     }
   else if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
@@ -2344 +2956 @@
             h->esym.asym.value = 0;
         }
-#if 0 /* FIXME?  */
-      h->esym.ifd = 0;
-#endif
     }
 
   if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
-                                     h->root.root.root.string,
-                                     &h->esym))
-    {
-      einfo->failed = true;
-      return false;
-    }
-
-  return true;
+                                      h->root.root.root.string,
+                                      &h->esym))
+    {
+      einfo->failed = TRUE;
+      return FALSE;
+    }
+
+  return TRUE;
 }
 
-/* FIXME:  Create a runtime procedure table from the .mdebug section.
-
-static boolean
-mips_elf_create_procedure_table (handle, abfd, info, s, debug)
-     PTR handle;
+
+/* Search for and possibly create a got entry.  */
+
+static struct alpha_elf_got_entry *
+get_got_entry (abfd, h, r_type, r_symndx, r_addend)
      bfd *abfd;
-     struct bfd_link_info *info;
-     asection *s;
-     struct ecoff_debug_info *debug;
-*/
-
+     struct alpha_elf_link_hash_entry *h;
+     unsigned long r_type, r_symndx;
+     bfd_vma r_addend;
+{
+  struct alpha_elf_got_entry *gotent;
+  struct alpha_elf_got_entry **slot;
+
+  if (h)
+    slot = &h->got_entries;
+  else
+    {
+      /* This is a local .got entry -- record for merge.  */
+
+      struct alpha_elf_got_entry **local_got_entries;
+
+      local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
+      if (!local_got_entries)
+        {
+          bfd_size_type size;
+          Elf_Internal_Shdr *symtab_hdr;
+
+          symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
+          size = symtab_hdr->sh_info;
+          size *= sizeof (struct alpha_elf_got_entry *);
+
+          local_got_entries
+            = (struct alpha_elf_got_entry **) bfd_zalloc (abfd, size);
+          if (!local_got_entries)
+            return NULL;
+
+          alpha_elf_tdata (abfd)->local_got_entries = local_got_entries;
+        }
+
+      slot = &local_got_entries[r_symndx];
+    }
+
+  for (gotent = *slot; gotent ; gotent = gotent->next)
+    if (gotent->gotobj == abfd
+        && gotent->reloc_type == r_type
+        && gotent->addend == r_addend)
+      break;
+
+  if (!gotent)
+    {
+      int entry_size;
+      bfd_size_type amt;
+
+      amt = sizeof (struct alpha_elf_got_entry);
+      gotent = (struct alpha_elf_got_entry *) bfd_alloc (abfd, amt);
+      if (!gotent)
+        return NULL;
+
+      gotent->gotobj = abfd;
+      gotent->addend = r_addend;
+      gotent->got_offset = -1;
+      gotent->use_count = 1;
+      gotent->reloc_type = r_type;
+      gotent->reloc_done = 0;
+      gotent->reloc_xlated = 0;
+
+      gotent->next = *slot;
+      *slot = gotent;
+
+      entry_size = alpha_got_entry_size (r_type);
+      alpha_elf_tdata (abfd)->total_got_size += entry_size;
+      if (!h)
+        alpha_elf_tdata(abfd)->local_got_size += entry_size;
+    }
+  else
+    gotent->use_count += 1;
+
+  return gotent;
+}
 
 /* Handle dynamic relocations when doing an Alpha ELF link.  */
 
-static boolean
+static bfd_boolean
 elf64_alpha_check_relocs (abfd, info, sec, relocs)
      bfd *abfd;
@@ -2386 +3063 @@
   Elf_Internal_Shdr *symtab_hdr;
   struct alpha_elf_link_hash_entry **sym_hashes;
-  struct alpha_elf_got_entry **local_got_entries;
   const Elf_Internal_Rela *rel, *relend;
-  int got_created;
+  bfd_boolean got_created;
+  bfd_size_type amt;
 
   if (info->relocateable)
-    return true;
+    return TRUE;
 
   dynobj = elf_hash_table(info)->dynobj;
@@ -2401 +3078 @@
   symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
   sym_hashes = alpha_elf_sym_hashes(abfd);
-  local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
-  got_created = 0;
+  got_created = FALSE;
 
   relend = relocs + sec->reloc_count;
   for (rel = relocs; rel < relend; ++rel)
     {
+      enum {
+        NEED_GOT = 1,
+        NEED_GOT_ENTRY = 2,
+        NEED_DYNREL = 4
+      };
+
       unsigned long r_symndx, r_type;
       struct alpha_elf_link_hash_entry *h;
+      unsigned int gotent_flags;
+      bfd_boolean maybe_dynamic;
+      unsigned int need;
+      bfd_vma addend;
 
       r_symndx = ELF64_R_SYM (rel->r_info);
@@ -2423 +3109 @@
           h->root.elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
         }
+
+      /* We can only get preliminary data on whether a symbol is
+         locally or externally defined, as not all of the input files
+         have yet been processed.  Do something with what we know, as
+         this may help reduce memory usage and processing time later.  */
+      maybe_dynamic = FALSE;
+      if (h && ((info->shared
+                 && (!info->symbolic || info->allow_shlib_undefined))
+                || ! (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)
+                || h->root.root.type == bfd_link_hash_defweak))
+        maybe_dynamic = TRUE;
+
+      need = 0;
+      gotent_flags = 0;
       r_type = ELF64_R_TYPE (rel->r_info);
+      addend = rel->r_addend;
 
       switch (r_type)
         {
         case R_ALPHA_LITERAL:
-          {
-            struct alpha_elf_got_entry *gotent;
-            int flags = 0;
-
-            if (h)
-              {
-                /* Search for and possibly create a got entry.  */
-                for (gotent = h->got_entries; gotent ; gotent = gotent->next)
-                  if (gotent->gotobj == abfd &&
-                      gotent->addend == rel->r_addend)
-                    break;
-
-                if (!gotent)
-                  {
-                    gotent = ((struct alpha_elf_got_entry *)
-                              bfd_alloc (abfd,
-                                         sizeof (struct alpha_elf_got_entry)));
-                    if (!gotent)
-                      return false;
-
-                    gotent->gotobj = abfd;
-                    gotent->addend = rel->r_addend;
-                    gotent->got_offset = -1;
-                    gotent->flags = 0;
-                    gotent->use_count = 1;
-
-                    gotent->next = h->got_entries;
-                    h->got_entries = gotent;
-
-                    alpha_elf_tdata (abfd)->total_got_entries++;
-                  }
-                else
-                  gotent->use_count += 1;
-              }
-            else
-              {
-                /* This is a local .got entry -- record for merge.  */
-                if (!local_got_entries)
-                  {
-                    size_t size;
-                    size = (symtab_hdr->sh_info
-                            * sizeof (struct alpha_elf_got_entry *));
-
-                    local_got_entries = ((struct alpha_elf_got_entry **)
-                                         bfd_alloc (abfd, size));
-                    if (!local_got_entries)
-                      return false;
-
-                    memset (local_got_entries, 0, size);
-                    alpha_elf_tdata (abfd)->local_got_entries =
-                      local_got_entries;
-                  }
-
-                for (gotent = local_got_entries[ELF64_R_SYM(rel->r_info)];
-                     gotent != NULL && gotent->addend != rel->r_addend;
-                     gotent = gotent->next)
-                  continue;
-                if (!gotent)
-                  {
-                    gotent = ((struct alpha_elf_got_entry *)
-                              bfd_alloc (abfd,
-                                         sizeof (struct alpha_elf_got_entry)));
-                    if (!gotent)
-                      return false;
-
-                    gotent->gotobj = abfd;
-                    gotent->addend = rel->r_addend;
-                    gotent->got_offset = -1;
-                    gotent->flags = 0;
-                    gotent->use_count = 1;
-
-                    gotent->next = local_got_entries[ELF64_R_SYM(rel->r_info)];
-                    local_got_entries[ELF64_R_SYM(rel->r_info)] = gotent;
-
-                    alpha_elf_tdata(abfd)->total_got_entries++;
-                    alpha_elf_tdata(abfd)->n_local_got_entries++;
-                  }
-                else
-                  gotent->use_count += 1;
-              }
-
-            /* Remember how this literal is used from its LITUSEs.
-               This will be important when it comes to decide if we can
-               create a .plt entry for a function symbol.  */
-            if (rel+1 < relend
-                && ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE)
-              {
-                do
-                  {
-                    ++rel;
-                    if (rel->r_addend >= 1 && rel->r_addend <= 3)
-                      flags |= 1 << rel->r_addend;
-                  }
-                while (rel+1 < relend &&
-                       ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE);
-              }
-            else
-              {
-                /* No LITUSEs -- presumably the address is not being
-                   loaded for nothing.  */
-                flags = ALPHA_ELF_LINK_HASH_LU_ADDR;
-              }
-
-            gotent->flags |= flags;
-            if (h)
-              {
-                /* Make a guess as to whether a .plt entry will be needed.  */
-                if ((h->flags |= flags) == ALPHA_ELF_LINK_HASH_LU_FUNC)
-                  h->root.elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
-                else
-                  h->root.elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
-              }
-          }
-          /* FALLTHRU */
+          need = NEED_GOT | NEED_GOT_ENTRY;
+
+          /* Remember how this literal is used from its LITUSEs.
+             This will be important when it comes to decide if we can
+             create a .plt entry for a function symbol.  */
+          while (++rel < relend && ELF64_R_TYPE (rel->r_info) == R_ALPHA_LITUSE)
+            if (rel->r_addend >= 1 && rel->r_addend <= 5)
+              gotent_flags |= 1 << rel->r_addend;
+          --rel;
+
+          /* No LITUSEs -- presumably the address is used somehow.  */
+          if (gotent_flags == 0)
+            gotent_flags = ALPHA_ELF_LINK_HASH_LU_ADDR;
+          break;
 
         case R_ALPHA_GPDISP:
+        case R_ALPHA_GPREL16:
         case R_ALPHA_GPREL32:
         case R_ALPHA_GPRELHIGH:
         case R_ALPHA_GPRELLOW:
-          /* We don't actually use the .got here, but the sections must
-             be created before the linker maps input sections to output
-             sections.  */
+        case R_ALPHA_BRSGP:
+          need = NEED_GOT;
+          break;
+
+        case R_ALPHA_REFLONG:
+        case R_ALPHA_REFQUAD:
+          if ((info->shared && (sec->flags & SEC_ALLOC)) || maybe_dynamic)
+            need = NEED_DYNREL;
+          break;
+
+        case R_ALPHA_TLSLDM:
+          /* The symbol for a TLSLDM reloc is ignored.  Collapse the
+             reloc to the 0 symbol so that they all match.  */
+          r_symndx = 0;
+          h = 0;
+          maybe_dynamic = FALSE;
+          /* FALLTHRU */
+
+        case R_ALPHA_TLSGD:
+        case R_ALPHA_GOTDTPREL:
+          need = NEED_GOT | NEED_GOT_ENTRY;
+          break;
+
+        case R_ALPHA_GOTTPREL:
+          need = NEED_GOT | NEED_GOT_ENTRY;
+          gotent_flags = ALPHA_ELF_LINK_HASH_TLS_IE;
+          if (info->shared)
+            info->flags |= DF_STATIC_TLS;
+          break;
+
+        case R_ALPHA_TPREL64:
+          if (info->shared || maybe_dynamic)
+            need = NEED_DYNREL;
+          if (info->shared)
+            info->flags |= DF_STATIC_TLS;
+          break;
+        }
+
+      if (need & NEED_GOT)
+        {
           if (!got_created)
             {
               if (!elf64_alpha_create_got_section (abfd, info))
-                return false;
+                return FALSE;
 
               /* Make sure the object's gotobj is set to itself so
@@ -2563 +3202 @@
               got_created = 1;
             }
-          break;
-
-        case R_ALPHA_SREL16:
-        case R_ALPHA_SREL32:
-        case R_ALPHA_SREL64:
-          if (h == NULL)
-            break;
-          /* FALLTHRU */
-
-        case R_ALPHA_REFLONG:
-        case R_ALPHA_REFQUAD:
+        }
+
+      if (need & NEED_GOT_ENTRY)
+        {
+          struct alpha_elf_got_entry *gotent;
+
+          gotent = get_got_entry (abfd, h, r_type, r_symndx, addend);
+          if (!gotent)
+            return FALSE;
+
+          if (gotent_flags)
+            {
+              gotent->flags |= gotent_flags;
+              if (h)
+                {
+                  gotent_flags |= h->flags;
+                  h->flags = gotent_flags;
+
+                  /* Make a guess as to whether a .plt entry is needed.  */
+                  if ((gotent_flags & ALPHA_ELF_LINK_HASH_LU_FUNC)
+                      && !(gotent_flags & ~ALPHA_ELF_LINK_HASH_LU_FUNC))
+                    h->root.elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
+                  else
+                    h->root.elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
+                }
+            }
+        }
+
+      if (need & NEED_DYNREL)
+        {
           if (rel_sec_name == NULL)
             {
@@ -2580 +3238 @@
                                elf_section_data(sec)->rel_hdr.sh_name));
               if (rel_sec_name == NULL)
-                return false;
+                return FALSE;
 
               BFD_ASSERT (strncmp (rel_sec_name, ".rela", 5) == 0
@@ -2596 +3254 @@
               if (sreloc == NULL)
                 {
+                  flagword flags;
+
                   sreloc = bfd_make_section (dynobj, rel_sec_name);
+                  flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
+                           | SEC_LINKER_CREATED | SEC_READONLY);
+                  if (sec->flags & SEC_ALLOC)
+                    flags |= SEC_ALLOC | SEC_LOAD;
                   if (sreloc == NULL
-                      || !bfd_set_section_flags (dynobj, sreloc,
-                                                 ((sec->flags & (SEC_ALLOC
-                                                                 | SEC_LOAD))
-                                                  | SEC_HAS_CONTENTS
-                                                  | SEC_IN_MEMORY
-                                                  | SEC_LINKER_CREATED
-                                                  | SEC_READONLY))
+                      || !bfd_set_section_flags (dynobj, sreloc, flags)
                       || !bfd_set_section_alignment (dynobj, sreloc, 3))
-                    return false;
+                    return FALSE;
                 }
             }
@@ -2626 +3284 @@
               if (!rent)
                 {
-                  rent = ((struct alpha_elf_reloc_entry *)
-                          bfd_alloc (abfd,
-                                     sizeof (struct alpha_elf_reloc_entry)));
+                  amt = sizeof (struct alpha_elf_reloc_entry);
+                  rent = (struct alpha_elf_reloc_entry *) bfd_alloc (abfd, amt);
                   if (!rent)
-                    return false;
+                    return FALSE;
 
                   rent->srel = sreloc;
                   rent->rtype = r_type;
                   rent->count = 1;
+                  rent->reltext = ((sec->flags & (SEC_READONLY | SEC_ALLOC))
+                                   == (SEC_READONLY | SEC_ALLOC));
 
                   rent->next = h->reloc_entries;
@@ -2642 +3301 @@
                 rent->count++;
             }
-          else if (info->shared && (sec->flags & SEC_ALLOC))
+          else if (info->shared)
             {
               /* If this is a shared library, and the section is to be
                  loaded into memory, we need a RELATIVE reloc.  */
               sreloc->_raw_size += sizeof (Elf64_External_Rela);
+              if ((sec->flags & (SEC_READONLY | SEC_ALLOC))
+                  == (SEC_READONLY | SEC_ALLOC))
+                info->flags |= DF_TEXTREL;
             }
-          break;
-        }
-    }
-
-  return true;
+        }
+    }
+
+  return TRUE;
 }
 
@@ -2661 +3322 @@
    understand.  */
 
-static boolean
+static bfd_boolean
 elf64_alpha_adjust_dynamic_symbol (info, h)
      struct bfd_link_info *info;
@@ -2676 +3337 @@
      about whether this symbol should get a .plt entry.  */
 
-  if (h->root.type != bfd_link_hash_undefweak
-      && alpha_elf_dynamic_symbol_p (h, info)
+  if (alpha_elf_dynamic_symbol_p (h, info)
       && ((h->type == STT_FUNC
            && !(ah->flags & ALPHA_ELF_LINK_HASH_LU_ADDR))
           || (h->type == STT_NOTYPE
-              && ah->flags == ALPHA_ELF_LINK_HASH_LU_FUNC))
+              && (ah->flags & ALPHA_ELF_LINK_HASH_LU_FUNC)
+              && !(ah->flags & ~ALPHA_ELF_LINK_HASH_LU_FUNC)))
       /* Don't prevent otherwise valid programs from linking by attempting
          to create a new .got entry somewhere.  A Correct Solution would be
@@ -2692 +3353 @@
       s = bfd_get_section_by_name(dynobj, ".plt");
       if (!s && !elf64_alpha_create_dynamic_sections (dynobj, info))
-        return false;
+        return FALSE;
 
       /* The first bit of the .plt is reserved.  */
@@ -2708 +3369 @@
           && h->root.type != bfd_link_hash_defweak)
         {
+          ah->plt_old_section = h->root.u.def.section;
+          ah->plt_old_value = h->root.u.def.value;
+          ah->flags |= ALPHA_ELF_LINK_HASH_PLT_LOC;
           h->root.u.def.section = s;
           h->root.u.def.value = h->plt.offset;
@@ -2717 +3381 @@
       s->_raw_size += sizeof (Elf64_External_Rela);
 
-      return true;
+      return TRUE;
     }
   else
@@ -2731 +3395 @@
       h->root.u.def.section = h->weakdef->root.u.def.section;
       h->root.u.def.value = h->weakdef->root.u.def.value;
-      return true;
+      return TRUE;
     }
 
@@ -2739 +3403 @@
      .dynbss section and COPY dynamic relocations.  */
 
-  return true;
+  return TRUE;
 }
 
@@ -2746 +3410 @@
    in these situations.  */
 
-static boolean
+static bfd_boolean
 elf64_alpha_merge_ind_symbols (hi, dummy)
      struct alpha_elf_link_hash_entry *hi;
@@ -2754 +3418 @@
 
   if (hi->root.root.type != bfd_link_hash_indirect)
-    return true;
+    return TRUE;
   hs = hi;
   do {
@@ -2778 +3442 @@
           gin = gi->next;
           for (gs = gsh; gs ; gs = gs->next)
-            if (gi->gotobj == gs->gotobj && gi->addend == gs->addend)
-              goto got_found;
+            if (gi->gotobj == gs->gotobj
+                && gi->reloc_type == gs->reloc_type
+                && gi->addend == gs->addend)
+              {
+                gi->use_count += gs->use_count;
+                goto got_found;
+              }
           gi->next = hs->got_entries;
           hs->got_entries = gi;
@@ -2800 +3469 @@
           rin = ri->next;
           for (rs = rsh; rs ; rs = rs->next)
-            if (ri->rtype == rs->rtype)
+            if (ri->rtype == rs->rtype && ri->srel == rs->srel)
               {
                 rs->count += ri->count;
@@ -2812 +3481 @@
   hi->reloc_entries = NULL;
 
-  return true;
+  return TRUE;
 }
 
 /* Is it possible to merge two object file's .got tables?  */
 
-static boolean
+static bfd_boolean
 elf64_alpha_can_merge_gots (a, b)
      bfd *a, *b;
 {
-  int total = alpha_elf_tdata (a)->total_got_entries;
+  int total = alpha_elf_tdata (a)->total_got_size;
   bfd *bsub;
 
   /* Trivial quick fallout test.  */
-  if (total + alpha_elf_tdata (b)->total_got_entries <= MAX_GOT_ENTRIES)
-    return true;
+  if (total + alpha_elf_tdata (b)->total_got_size <= MAX_GOT_SIZE)
+    return TRUE;
 
   /* By their nature, local .got entries cannot be merged.  */
-  if ((total += alpha_elf_tdata (b)->n_local_got_entries) > MAX_GOT_ENTRIES)
-    return false;
+  if ((total += alpha_elf_tdata (b)->local_got_size) > MAX_GOT_SIZE)
+    return FALSE;
 
   /* Failing the common trivial comparison, we must effectively
@@ -2860 +3529 @@
 
               for (ae = h->got_entries; ae ; ae = ae->next)
-                if (ae->gotobj == a && ae->addend == be->addend)
+                if (ae->gotobj == a
+                    && ae->reloc_type == be->reloc_type
+                    && ae->addend == be->addend)
                   goto global_found;
 
-              if (++total > MAX_GOT_ENTRIES)
-                return false;
+              total += alpha_got_entry_size (be->reloc_type);
+              if (total > MAX_GOT_SIZE)
+                return FALSE;
             global_found:;
             }
@@ -2870 +3542 @@
     }
 
-  return true;
+  return TRUE;
 }
 
@@ -2879 +3551 @@
      bfd *a, *b;
 {
-  int total = alpha_elf_tdata (a)->total_got_entries;
+  int total = alpha_elf_tdata (a)->total_got_size;
   bfd *bsub;
 
   /* Remember local expansion.  */
   {
-    int e = alpha_elf_tdata (b)->n_local_got_entries;
+    int e = alpha_elf_tdata (b)->local_got_size;
     total += e;
-    alpha_elf_tdata (a)->n_local_got_entries += e;
+    alpha_elf_tdata (a)->local_got_size += e;
   }
 
@@ -2936 +3608 @@
 
               for (ae = *start; ae ; ae = ae->next)
-                if (ae->gotobj == a && ae->addend == be->addend)
+                if (ae->gotobj == a
+                    && ae->reloc_type == be->reloc_type
+                    && ae->addend == be->addend)
                   {
                     ae->flags |= be->flags;
@@ -2944 +3618 @@
                   }
               be->gotobj = a;
-              total += 1;
+              total += alpha_got_entry_size (be->reloc_type);
 
             global_found:;
@@ -2952 +3626 @@
       alpha_elf_tdata (bsub)->gotobj = a;
     }
-  alpha_elf_tdata (a)->total_got_entries = total;
+  alpha_elf_tdata (a)->total_got_size = total;
 
   /* Merge the two in_got chains.  */
@@ -2968 +3642 @@
 /* Calculate the offsets for the got entries.  */
 
-static boolean
+static bfd_boolean
 elf64_alpha_calc_got_offsets_for_symbol (h, arg)
      struct alpha_elf_link_hash_entry *h;
-     PTR arg;
+     PTR arg ATTRIBUTE_UNUSED;
 {
   struct alpha_elf_got_entry *gotent;
+
+  if (h->root.root.type == bfd_link_hash_warning)
+    h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
 
   for (gotent = h->got_entries; gotent; gotent = gotent->next)
@@ -2982 +3659 @@
 
         gotent->got_offset = *plge;
-        *plge += 8;
+        *plge += alpha_got_entry_size (gotent->reloc_type);
       }
 
-  return true;
+  return TRUE;
 }
 
@@ -3024 +3701 @@
                 {
                   gotent->got_offset = got_offset;
-                  got_offset += 8;
+                  got_offset += alpha_got_entry_size (gotent->reloc_type);
                 }
         }
@@ -3035 +3712 @@
 /* Constructs the gots.  */
 
-static boolean
-elf64_alpha_size_got_sections (output_bfd, info)
-     bfd *output_bfd;
+static bfd_boolean
+elf64_alpha_size_got_sections (info)
      struct bfd_link_info *info;
 {
-  bfd *i, *got_list, *cur_got_obj;
+  bfd *i, *got_list, *cur_got_obj = NULL;
   int something_changed = 0;
 
@@ -3058 +3734 @@
           BFD_ASSERT (this_got == i);
 
-          if (alpha_elf_tdata (this_got)->total_got_entries > MAX_GOT_ENTRIES)
+          if (alpha_elf_tdata (this_got)->total_got_size > MAX_GOT_SIZE)
             {
               /* Yikes! A single object file has too many entries.  */
               (*_bfd_error_handler)
                 (_("%s: .got subsegment exceeds 64K (size %d)"),
-                 bfd_get_filename (i),
-                 alpha_elf_tdata (this_got)->total_got_entries * 8);
-              return false;
+                 bfd_archive_filename (i),
+                 alpha_elf_tdata (this_got)->total_got_size);
+              return FALSE;
             }
 
@@ -3077 +3753 @@
       /* Strange degenerate case of no got references.  */
       if (got_list == NULL)
-        return true;
+        return TRUE;
 
       alpha_elf_hash_table (info)->got_list = got_list;
@@ -3108 +3784 @@
     elf64_alpha_calc_got_offsets (info);
 
-  return true;
+  return TRUE;
 }
 
-static boolean
+/* Called from relax_section to rebuild the PLT in light of
+   potential changes in the function's status.  */
+
+static bfd_boolean
+elf64_alpha_size_plt_section (info)
+     struct bfd_link_info *info;
+{
+  asection *splt, *spltrel;
+  unsigned long entries;
+  bfd *dynobj;
+
+  dynobj = elf_hash_table(info)->dynobj;
+  splt = bfd_get_section_by_name(dynobj, ".plt");
+  if (splt == NULL)
+    return TRUE;
+
+  splt->_raw_size = 0;
+
+  alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
+                                elf64_alpha_size_plt_section_1, splt);
+
+  splt->_cooked_size = splt->_raw_size;
+
+  /* Every plt entry requires a JMP_SLOT relocation.  */
+  spltrel = bfd_get_section_by_name (dynobj, ".rela.plt");
+  if (splt->_raw_size)
+    entries = (splt->_raw_size - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
+  else
+    entries = 0;
+  spltrel->_raw_size = entries * sizeof (Elf64_External_Rela);
+  spltrel->_cooked_size = spltrel->_raw_size;
+
+  return TRUE;
+}
+
+static bfd_boolean
+elf64_alpha_size_plt_section_1 (h, data)
+     struct alpha_elf_link_hash_entry *h;
+     PTR data;
+{
+  asection *splt = (asection *) data;
+  struct alpha_elf_got_entry *gotent;
+
+  /* If we didn't need an entry before, we still don't.  */
+  if (!(h->root.elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT))
+    return TRUE;
+
+  /* There must still be a LITERAL got entry for the function.  */
+  for (gotent = h->got_entries; gotent ; gotent = gotent->next)
+    if (gotent->reloc_type == R_ALPHA_LITERAL
+        && gotent->use_count > 0)
+      break;
+
+  /* If there is, reset the PLT offset.  If not, there's no longer
+     a need for the PLT entry.  */
+  if (gotent)
+    {
+      if (splt->_raw_size == 0)
+        splt->_raw_size = PLT_HEADER_SIZE;
+      h->root.plt.offset = splt->_raw_size;
+      splt->_raw_size += PLT_ENTRY_SIZE;
+    }
+  else
+    {
+      h->root.elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
+      h->root.plt.offset = -1;
+
+      /* Undo the definition frobbing begun in adjust_dynamic_symbol.  */
+      if (h->flags & ALPHA_ELF_LINK_HASH_PLT_LOC)
+        {
+          h->root.root.u.def.section = h->plt_old_section;
+          h->root.root.u.def.value = h->plt_old_value;
+          h->flags &= ~ALPHA_ELF_LINK_HASH_PLT_LOC;
+        }
+    }
+
+  return TRUE;
+}
+
+static bfd_boolean
 elf64_alpha_always_size_sections (output_bfd, info)
-     bfd *output_bfd;
+     bfd *output_bfd ATTRIBUTE_UNUSED;
      struct bfd_link_info *info;
 {
@@ -3119 +3874 @@
 
   if (info->relocateable)
-    return true;
+    return TRUE;
 
   /* First, take care of the indirect symbols created by versioning.  */
@@ -3126 +3881 @@
                                 NULL);
 
-  if (!elf64_alpha_size_got_sections (output_bfd, info))
-    return false;
+  if (!elf64_alpha_size_got_sections (info))
+    return FALSE;
 
   /* Allocate space for all of the .got subsections.  */
@@ -3138 +3893 @@
           s->contents = (bfd_byte *) bfd_zalloc (i, s->_raw_size);
           if (s->contents == NULL)
-            return false;
-        }
-    }
-
-  return true;
+            return FALSE;
+        }
+    }
+
+  return TRUE;
 }
 
+/* The number of dynamic relocations required by a static relocation.  */
+
+static int
+alpha_dynamic_entries_for_reloc (r_type, dynamic, shared)
+     int r_type, dynamic, shared;
+{
+  switch (r_type)
+    {
+    /* May appear in GOT entries.  */
+    case R_ALPHA_TLSGD:
+      return (dynamic ? 2 : shared ? 1 : 0);
+    case R_ALPHA_TLSLDM:
+      return shared;
+    case R_ALPHA_LITERAL:
+    case R_ALPHA_GOTTPREL:
+      return dynamic || shared;
+    case R_ALPHA_GOTDTPREL:
+      return dynamic;
+
+    /* May appear in data sections.  */
+    case R_ALPHA_REFLONG:
+    case R_ALPHA_REFQUAD:
+    case R_ALPHA_TPREL64:
+      return dynamic || shared;
+
+    /* Everything else is illegal.  We'll issue an error during
+       relocate_section.  */
+    default:
+      return 0;
+    }
+}
+
 /* Work out the sizes of the dynamic relocation entries.  */
 
-static boolean
+static bfd_boolean
 elf64_alpha_calc_dynrel_sizes (h, info)
      struct alpha_elf_link_hash_entry *h;
      struct bfd_link_info *info;
 {
+  bfd_boolean dynamic;
+  struct alpha_elf_reloc_entry *relent;
+  unsigned long entries;
+
+  if (h->root.root.type == bfd_link_hash_warning)
+    h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
+
   /* If the symbol was defined as a common symbol in a regular object
      file, and there was no definition in any dynamic object, then the
@@ -3167 +3961 @@
           || h->root.root.type == bfd_link_hash_defweak)
       && !(h->root.root.u.def.section->owner->flags & DYNAMIC))
-    {
-      h->root.elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
-    }
+    h->root.elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
 
   /* If the symbol is dynamic, we'll need all the relocations in their
@@ -3175 +3967 @@
      local, we'll need the same number of RELATIVE relocations.  */
 
-  if (alpha_elf_dynamic_symbol_p (&h->root, info) || info->shared)
-    {
-      struct alpha_elf_reloc_entry *relent;
-      bfd *dynobj;
-      struct alpha_elf_got_entry *gotent;
-      bfd_size_type count;
-      asection *srel;
-
-      for (relent = h->reloc_entries; relent; relent = relent->next)
-        if (relent->rtype == R_ALPHA_REFLONG
-            || relent->rtype == R_ALPHA_REFQUAD)
-          {
-            relent->srel->_raw_size +=
-              sizeof (Elf64_External_Rela) * relent->count;
-          }
-
-      dynobj = elf_hash_table(info)->dynobj;
-      count = 0;
-
-      for (gotent = h->got_entries; gotent ; gotent = gotent->next)
-        count++;
-
-      /* If we are using a .plt entry, subtract one, as the first
-         reference uses a .rela.plt entry instead.  */
-      if (h->root.plt.offset != MINUS_ONE)
-        count--;
-
-      if (count > 0)
-        {
-          srel = bfd_get_section_by_name (dynobj, ".rela.got");
-          BFD_ASSERT (srel != NULL);
-          srel->_raw_size += sizeof (Elf64_External_Rela) * count;
-        }
-    }
-
-  return true;
+  dynamic = alpha_elf_dynamic_symbol_p (&h->root, info);
+
+  for (relent = h->reloc_entries; relent; relent = relent->next)
+    {
+      entries = alpha_dynamic_entries_for_reloc (relent->rtype, dynamic,
+                                                 info->shared);
+      if (entries)
+        {
+          relent->srel->_raw_size +=
+            entries * sizeof (Elf64_External_Rela) * relent->count;
+          if (relent->reltext)
+            info->flags |= DT_TEXTREL;
+        }
+    }
+
+  return TRUE;
 }
 
+/* Set the sizes of the dynamic relocation sections.  */
+
+static bfd_boolean
+elf64_alpha_size_rela_got_section (info)
+     struct bfd_link_info *info;
+{
+  unsigned long entries;
+  bfd *i, *dynobj;
+  asection *srel;
+
+  /* Shared libraries often require RELATIVE relocs, and some relocs
+     require attention for the main application as well.  */
+
+  entries = 0;
+  for (i = alpha_elf_hash_table(info)->got_list;
+       i ; i = alpha_elf_tdata(i)->got_link_next)
+    {
+      bfd *j;
+
+      for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
+        {
+          struct alpha_elf_got_entry **local_got_entries, *gotent;
+          int k, n;
+
+          local_got_entries = alpha_elf_tdata(j)->local_got_entries;
+          if (!local_got_entries)
+            continue;
+
+          for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
+            for (gotent = local_got_entries[k];
+                 gotent ; gotent = gotent->next)
+              if (gotent->use_count > 0)
+                entries += (alpha_dynamic_entries_for_reloc
+                            (gotent->reloc_type, 0, info->shared));
+        }
+    }
+
+  dynobj = elf_hash_table(info)->dynobj;
+  srel = bfd_get_section_by_name (dynobj, ".rela.got");
+  if (!srel)
+    {
+      BFD_ASSERT (entries == 0);
+      return TRUE;
+    }
+  srel->_raw_size = sizeof (Elf64_External_Rela) * entries;
+
+  /* Now do the non-local symbols.  */
+  alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
+                                elf64_alpha_size_rela_got_1, info);
+
+  srel->_cooked_size = srel->_raw_size;
+
+  return TRUE;
+}
+
+/* Subroutine of elf64_alpha_size_rela_got_section for doing the
+   global symbols.  */
+
+static bfd_boolean
+elf64_alpha_size_rela_got_1 (h, info)
+     struct alpha_elf_link_hash_entry *h;
+     struct bfd_link_info *info;
+{
+  bfd_boolean dynamic;
+  struct alpha_elf_got_entry *gotent;
+  unsigned long entries;
+
+  if (h->root.root.type == bfd_link_hash_warning)
+    h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
+
+  /* If the symbol is dynamic, we'll need all the relocations in their
+     natural form.  If this is a shared object, and it has been forced
+     local, we'll need the same number of RELATIVE relocations.  */
+
+  dynamic = alpha_elf_dynamic_symbol_p (&h->root, info);
+
+  entries = 0;
+  for (gotent = h->got_entries; gotent ; gotent = gotent->next)
+    if (gotent->use_count > 0)
+      entries += alpha_dynamic_entries_for_reloc (gotent->reloc_type,
+                                                  dynamic, info->shared);
+
+  /* If we are using a .plt entry, subtract one, as the first
+     reference uses a .rela.plt entry instead.  */
+  if (h->root.plt.offset != MINUS_ONE)
+    entries--;
+
+  if (entries > 0)
+    {
+      bfd *dynobj = elf_hash_table(info)->dynobj;
+      asection *srel = bfd_get_section_by_name (dynobj, ".rela.got");
+      BFD_ASSERT (srel != NULL);
+      srel->_raw_size += sizeof (Elf64_External_Rela) * entries;
+    }
+
+  return TRUE;
+}
+
 /* Set the sizes of the dynamic sections.  */
 
-static boolean
+static bfd_boolean
 elf64_alpha_size_dynamic_sections (output_bfd, info)
-     bfd *output_bfd;
+     bfd *output_bfd ATTRIBUTE_UNUSED;
      struct bfd_link_info *info;
 {
   bfd *dynobj;
   asection *s;
-  boolean reltext;
-  boolean relplt;
+  bfd_boolean relplt;
 
   dynobj = elf_hash_table(info)->dynobj;
@@ -3244 +4113 @@
          size the dynamic relocation sections.  */
       alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
-                                    elf64_alpha_calc_dynrel_sizes,
-                                    info);
-
-      /* When building shared libraries, each local .got entry needs a
-         RELATIVE reloc.  */
-      if (info->shared)
-        {
-          bfd *i;
-          asection *srel;
-          bfd_size_type count;
-
-          srel = bfd_get_section_by_name (dynobj, ".rela.got");
-          BFD_ASSERT (srel != NULL);
-
-          for (i = alpha_elf_hash_table(info)->got_list, count = 0;
-               i != NULL;
-               i = alpha_elf_tdata(i)->got_link_next)
-            count += alpha_elf_tdata(i)->n_local_got_entries;
-
-          srel->_raw_size += count * sizeof (Elf64_External_Rela);
-        }
+                                    elf64_alpha_calc_dynrel_sizes, info);
+
+      elf64_alpha_size_rela_got_section (info);
     }
   /* else we're not dynamic and by definition we don't need such things.  */
@@ -3271 +4122 @@
      determined the sizes of the various dynamic sections.  Allocate
      memory for them.  */
-  reltext = false;
-  relplt = false;
+  relplt = FALSE;
   for (s = dynobj->sections; s != NULL; s = s->next)
     {
       const char *name;
-      boolean strip;
+      bfd_boolean strip;
 
       if (!(s->flags & SEC_LINKER_CREATED))
@@ -3293 +4143 @@
          go into these sections.  */
 
-      strip = false;
+      strip = FALSE;
 
       if (strncmp (name, ".rela", 5) == 0)
@@ -3301 +4151 @@
           if (!strip)
             {
-              const char *outname;
-              asection *target;
-
-              /* If this relocation section applies to a read only
-                 section, then we probably need a DT_TEXTREL entry.  */
-              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;
-
               if (strcmp(name, ".rela.plt") == 0)
-                relplt = true;
+                relplt = TRUE;
 
               /* We use the reloc_count field as a counter if we need
@@ -3333 +4170 @@
         {
           /* Allocate memory for the section contents.  */
-          s->contents = (bfd_byte *) bfd_zalloc(dynobj, s->_raw_size);
+          s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
           if (s->contents == NULL && s->_raw_size != 0)
-            return false;
+            return FALSE;
         }
     }
@@ -3346 +4183 @@
          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 (! bfd_elf64_add_dynamic_entry (info, DT_PLTGOT, 0))
-        return false;
+          if (!add_dynamic_entry (DT_DEBUG, 0))
+            return FALSE;
+        }
 
       if (relplt)
         {
-          if (! 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 (! 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_PLTGOT, 0)
+              || !add_dynamic_entry (DT_PLTRELSZ, 0)
+              || !add_dynamic_entry (DT_PLTREL, DT_RELA)
+              || !add_dynamic_entry (DT_JMPREL, 0))
+            return FALSE;
+        }
+
+      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 (info->flags & DF_TEXTREL)
+        {
+          if (!add_dynamic_entry (DT_TEXTREL, 0))
+            return FALSE;
+        }
+    }
+#undef add_dynamic_entry
+
+  return TRUE;
 }
 
+/* Emit a dynamic relocation for (DYNINDX, RTYPE, ADDEND) at (SEC, OFFSET)
+   into the next available slot in SREL.  */
+
+static void
+elf64_alpha_emit_dynrel (abfd, info, sec, srel, offset, dynindx, rtype, addend)
+     bfd *abfd;
+     struct bfd_link_info *info;
+     asection *sec, *srel;
+     bfd_vma offset, addend;
+     long dynindx, rtype;
+{
+  Elf_Internal_Rela outrel;
+  bfd_byte *loc;
+
+  BFD_ASSERT (srel != NULL);
+
+  outrel.r_info = ELF64_R_INFO (dynindx, rtype);
+  outrel.r_addend = addend;
+
+  offset = _bfd_elf_section_offset (abfd, info, sec, offset);
+  if ((offset | 1) != (bfd_vma) -1)
+    outrel.r_offset = sec->output_section->vma + sec->output_offset + offset;
+  else
+    memset (&outrel, 0, sizeof (outrel));
+
+  loc = srel->contents;
+  loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
+  bfd_elf64_swap_reloca_out (abfd, &outrel, loc);
+  BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
+              <= srel->_cooked_size);
+}
+
+/* Relocate an Alpha ELF section for a relocatable 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.  */
+
+static bfd_boolean
+elf64_alpha_relocate_section_r (output_bfd, info, input_bfd, input_section,
+                                contents, relocs, local_syms, local_sections)
+     bfd *output_bfd ATTRIBUTE_UNUSED;
+     struct bfd_link_info *info ATTRIBUTE_UNUSED;
+     bfd *input_bfd;
+     asection *input_section;
+     bfd_byte *contents ATTRIBUTE_UNUSED;
+     Elf_Internal_Rela *relocs;
+     Elf_Internal_Sym *local_syms;
+     asection **local_sections;
+{
+  unsigned long symtab_hdr_sh_info;
+  Elf_Internal_Rela *rel;
+  Elf_Internal_Rela *relend;
+  bfd_boolean ret_val = TRUE;
+
+  symtab_hdr_sh_info = elf_tdata (input_bfd)->symtab_hdr.sh_info;
+
+  relend = relocs + input_section->reloc_count;
+  for (rel = relocs; rel < relend; rel++)
+    {
+      unsigned long r_symndx;
+      Elf_Internal_Sym *sym;
+      asection *sec;
+      unsigned long r_type;
+
+      r_type = ELF64_R_TYPE(rel->r_info);
+      if (r_type >= R_ALPHA_max)
+        {
+          (*_bfd_error_handler)
+            (_("%s: unknown relocation type %d"),
+             bfd_archive_filename (input_bfd), (int)r_type);
+          bfd_set_error (bfd_error_bad_value);
+          ret_val = FALSE;
+          continue;
+        }
+
+      r_symndx = ELF64_R_SYM(rel->r_info);
+
+      /* The symbol associated with GPDISP and LITUSE is
+         immaterial.  Only the addend is significant.  */
+      if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
+        continue;
+
+      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];
+              rel->r_addend += sec->output_offset + sym->st_value;
+            }
+        }
+    }
+
+  return ret_val;
+}
+
 /* Relocate an Alpha ELF section.  */
 
-static boolean
+static bfd_boolean
 elf64_alpha_relocate_section (output_bfd, info, input_bfd, input_section,
                               contents, relocs, local_syms, local_sections)
@@ -3397 +4331 @@
   Elf_Internal_Rela *rel;
   Elf_Internal_Rela *relend;
-  asection *sec, *sgot, *srel, *srelgot;
+  struct elf_link_tls_segment *tls_segment;
+  asection *sgot, *srel, *srelgot;
   bfd *dynobj, *gotobj;
-  bfd_vma gp;
-
-  srelgot = srel = NULL;
+  bfd_vma gp, tp_base, dtp_base;
+  struct alpha_elf_got_entry **local_got_entries;
+  bfd_boolean ret_val;
+  const char *section_name;
+
+  /* Handle relocatable links with a smaller loop.  */
+  if (info->relocateable)
+    return elf64_alpha_relocate_section_r (output_bfd, info, input_bfd,
+                                           input_section, contents, relocs,
+                                           local_syms, local_sections);
+
+  /* This is a final link.  */
+
+  ret_val = TRUE;
+
   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+
   dynobj = elf_hash_table (info)->dynobj;
   if (dynobj)
-    {
-      srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
-    }
+    srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
+  else
+    srelgot = NULL;
+
+  section_name = (bfd_elf_string_from_elf_section
+                  (input_bfd, elf_elfheader(input_bfd)->e_shstrndx,
+                   elf_section_data(input_section)->rel_hdr.sh_name));
+  BFD_ASSERT(section_name != NULL);
+  srel = bfd_get_section_by_name (dynobj, section_name);
 
   /* Find the gp value for this input bfd.  */
-  sgot = NULL;
-  gp = 0;
   gotobj = alpha_elf_tdata (input_bfd)->gotobj;
   if (gotobj)
@@ -3425 +4377 @@
         }
     }
-
-  rel = relocs;
+  else
+    {
+      sgot = NULL;
+      gp = 0;
+    }
+
+  local_got_entries = alpha_elf_tdata(input_bfd)->local_got_entries;
+
+  tls_segment = elf_hash_table (info)->tls_segment;
+  if (tls_segment)
+    {
+      dtp_base = alpha_get_dtprel_base (tls_segment);
+      tp_base = alpha_get_tprel_base (tls_segment);
+    }
+  else
+    dtp_base = tp_base = 0;
+
   relend = relocs + input_section->reloc_count;
-  for (; rel < relend; rel++)
-    {
-      int r_type;
+  for (rel = relocs; rel < relend; rel++)
+    {
+      struct alpha_elf_link_hash_entry *h = NULL;
+      struct alpha_elf_got_entry *gotent;
+      bfd_reloc_status_type r;
       reloc_howto_type *howto;
       unsigned long r_symndx;
-      struct alpha_elf_link_hash_entry *h;
-      Elf_Internal_Sym *sym;
-      bfd_vma relocation;
+      Elf_Internal_Sym *sym = NULL;
+      asection *sec = NULL;
+      bfd_vma value;
       bfd_vma addend;
-      bfd_reloc_status_type r;
+      bfd_boolean dynamic_symbol_p;
+      bfd_boolean undef_weak_ref = FALSE;
+      unsigned long r_type;
 
       r_type = ELF64_R_TYPE(rel->r_info);
-      if (r_type < 0 || r_type >= (int) R_ALPHA_max)
-        {
+      if (r_type >= R_ALPHA_max)
+        {
+          (*_bfd_error_handler)
+            (_("%s: unknown relocation type %d"),
+             bfd_archive_filename (input_bfd), (int)r_type);
           bfd_set_error (bfd_error_bad_value);
-          return false;
-        }
+          ret_val = FALSE;
+          continue;
+        }
+
       howto = elf64_alpha_howto_table + r_type;
-
       r_symndx = ELF64_R_SYM(rel->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.  */
-
-          /* The symbol associated with GPDISP and LITUSE is
-             immaterial.  Only the addend is significant.  */
-          if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
-            continue;
-
-          if (r_symndx < symtab_hdr->sh_info)
+      /* The symbol for a TLSLDM reloc is ignored.  Collapse the
+         reloc to the 0 symbol so that they all match.  */
+      if (r_type == R_ALPHA_TLSLDM)
+        r_symndx = 0;
+
+      if (r_symndx < symtab_hdr->sh_info)
+        {
+          sym = local_syms + r_symndx;
+          sec = local_sections[r_symndx];
+          value = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
+
+          /* If this is a tp-relative relocation against sym 0,
+             this is hackery from relax_section.  Force the value to
+             be the tls base.  */
+          if (r_symndx == 0
+              && (r_type == R_ALPHA_TLSLDM
+                  || r_type == R_ALPHA_GOTTPREL
+                  || r_type == R_ALPHA_TPREL64
+                  || r_type == R_ALPHA_TPRELHI
+                  || r_type == R_ALPHA_TPRELLO
+                  || r_type == R_ALPHA_TPREL16))
+            value = tp_base;
+
+          if (local_got_entries)
+            gotent = local_got_entries[r_symndx];
+          else
+            gotent = NULL;
+
+          /* Need to adjust local GOT entries' addends for SEC_MERGE
+             unless it has been done already.  */
+          if ((sec->flags & SEC_MERGE)
+              && ELF_ST_TYPE (sym->st_info) == STT_SECTION
+              && sec->sec_info_type == ELF_INFO_TYPE_MERGE
+              && gotent
+              && !gotent->reloc_xlated)
             {
-              sym = local_syms + r_symndx;
-              if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
+              struct alpha_elf_got_entry *ent;
+              asection *msec;
+
+              for (ent = gotent; ent; ent = ent->next)
                 {
-                  sec = local_sections[r_symndx];
-                  rel->r_addend += sec->output_offset + sym->st_value;
+                  ent->reloc_xlated = 1;
+                  if (ent->use_count == 0)
+                    continue;
+                  msec = sec;
+                  ent->addend =
+                    _bfd_merged_section_offset (output_bfd, &msec,
+                                                elf_section_data (sec)->
+                                                  sec_info,
+                                                sym->st_value + ent->addend,
+                                                (bfd_vma) 0);
+                  ent->addend -= sym->st_value;
+                  ent->addend += msec->output_section->vma
+                                 + msec->output_offset
+                                 - sec->output_section->vma
+                                 - sec->output_offset;
                 }
             }
 
-          continue;
-        }
-
-      /* This is a final link.  */
-
-      h = NULL;
-      sym = NULL;
-      sec = NULL;
-
-      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);
+          dynamic_symbol_p = FALSE;
         }
       else
@@ -3496 +4493 @@
             h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
 
+          value = 0;
           if (h->root.root.type == bfd_link_hash_defined
               || h->root.root.type == bfd_link_hash_defweak)
@@ -3501 +4499 @@
               sec = h->root.root.u.def.section;
 
-#if rth_notdef
-              if ((r_type == R_ALPHA_LITERAL
-                   && elf_hash_table(info)->dynamic_sections_created
-                   && (!info->shared
-                       || !info->symbolic
-                       || !(h->root.elf_link_hash_flags
-                            & ELF_LINK_HASH_DEF_REGULAR)))
-                  || (info->shared
-                      && (!info->symbolic
-                          || !(h->root.elf_link_hash_flags
-                               & ELF_LINK_HASH_DEF_REGULAR))
-                      && (input_section->flags & SEC_ALLOC)
-                      && (r_type == R_ALPHA_REFLONG
-                          || r_type == R_ALPHA_REFQUAD
-                          || r_type == R_ALPHA_LITERAL)))
-                {
-                  /* 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
-              /* FIXME: Are not these obscure cases simply bugs?  Let's
-                 get something working and come back to this.  */
-              if (sec->output_section == NULL)
-                relocation = 0;
-#endif /* rth_notdef */
-              else
-                {
-                  relocation = (h->root.root.u.def.value
-                                + sec->output_section->vma
-                                + sec->output_offset);
-                }
+              /* Detect the cases that sym_sec->output_section is
+                 expected to be NULL -- all cases in which the symbol
+                 is defined in another shared module.  This includes
+                 PLT relocs for which we've created a PLT entry and
+                 other relocs for which we're prepared to create
+                 dynamic relocations.  */
+              /* ??? Just accept it NULL and continue.  */
+
+              if (sec->output_section != NULL)
+                value = (h->root.root.u.def.value
+                         + sec->output_section->vma
+                              + sec->output_offset);
             }
           else if (h->root.root.type == bfd_link_hash_undefweak)
-            relocation = 0;
-          else if (info->shared && !info->symbolic
+            undef_weak_ref = TRUE;
+          else if (info->shared
                    && !info->no_undefined
                    && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
-            relocation = 0;
+            ;
           else
             {
@@ -3548 +4525 @@
                      (!info->shared || info->no_undefined
                       || ELF_ST_VISIBILITY (h->root.other)))))
-                return false;
-              relocation = 0;
+                return FALSE;
+              continue;
             }
-        }
+
+          dynamic_symbol_p = alpha_elf_dynamic_symbol_p (&h->root, info);
+          gotent = h->got_entries;
+        }
+
       addend = rel->r_addend;
+      value += addend;
+
+      /* Search for the proper got entry.  */
+      for (; gotent ; gotent = gotent->next)
+        if (gotent->gotobj == gotobj
+            && gotent->reloc_type == r_type
+            && gotent->addend == addend)
+          break;
 
       switch (r_type)
@@ -3562 +4551 @@
             BFD_ASSERT(gp != 0);
 
-            relocation = (input_section->output_section->vma
-                          + input_section->output_offset
-                          + rel->r_offset);
-
-            p_ldah = contents + rel->r_offset - input_section->vma;
+            value = (input_section->output_section->vma
+                     + input_section->output_offset
+                     + rel->r_offset);
+
+            p_ldah = contents + rel->r_offset;
             p_lda = p_ldah + rel->r_addend;
 
-            r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - relocation,
+            r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - value,
                                              p_ldah, p_lda);
           }
           break;
 
-        case R_ALPHA_OP_PUSH:
-        case R_ALPHA_OP_STORE:
-        case R_ALPHA_OP_PSUB:
-        case R_ALPHA_OP_PRSHIFT:
-          /* We hate these silly beasts.  */
-          abort ();
-
         case R_ALPHA_LITERAL:
-          {
-            struct alpha_elf_got_entry *gotent;
-            boolean dynamic_symbol;
-
-            BFD_ASSERT(sgot != NULL);
-            BFD_ASSERT(gp != 0);
-
-            if (h != NULL)
-              {
-                gotent = h->got_entries;
-                dynamic_symbol = alpha_elf_dynamic_symbol_p (&h->root, info);
-              }
-            else
-              {
-                gotent = (alpha_elf_tdata(input_bfd)->
-                          local_got_entries[r_symndx]);
-                dynamic_symbol = false;
-              }
-
-            BFD_ASSERT(gotent != NULL);
-
-            while (gotent->gotobj != gotobj || gotent->addend != addend)
-              gotent = gotent->next;
-
-            BFD_ASSERT(gotent->use_count >= 1);
-
-            /* Initialize the .got entry's value.  */
-            if (!(gotent->flags & ALPHA_ELF_GOT_ENTRY_RELOCS_DONE))
-              {
-                bfd_put_64 (output_bfd, relocation+addend,
-                            sgot->contents + gotent->got_offset);
-
-                /* If the symbol has been forced local, output a
-                   RELATIVE reloc, otherwise it will be handled in
-                   finish_dynamic_symbol.  */
-                if (info->shared && !dynamic_symbol)
-                  {
-                    Elf_Internal_Rela outrel;
-
-                    BFD_ASSERT(srelgot != NULL);
-
-                    outrel.r_offset = (sgot->output_section->vma
-                                       + sgot->output_offset
-                                       + gotent->got_offset);
-                    outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
-                    outrel.r_addend = 0;
-
-                    bfd_elf64_swap_reloca_out (output_bfd, &outrel,
-                                               ((Elf64_External_Rela *)
-                                                srelgot->contents)
-                                               + srelgot->reloc_count++);
-                    BFD_ASSERT (sizeof (Elf64_External_Rela)
-                                * srelgot->reloc_count
-                                <= srelgot->_cooked_size);
-                  }
-
-                gotent->flags |= ALPHA_ELF_GOT_ENTRY_RELOCS_DONE;
-              }
-
-            /* Figure the gprel relocation.  */
-            addend = 0;
-            relocation = (sgot->output_section->vma
-                          + sgot->output_offset
-                          + gotent->got_offset);
-            relocation -= gp;
-          }
-          /* overflow handled by _bfd_final_link_relocate */
+          BFD_ASSERT(sgot != NULL);
+          BFD_ASSERT(gp != 0);
+          BFD_ASSERT(gotent != NULL);
+          BFD_ASSERT(gotent->use_count >= 1);
+
+          if (!gotent->reloc_done)
+            {
+              gotent->reloc_done = 1;
+
+              bfd_put_64 (output_bfd, value,
+                          sgot->contents + gotent->got_offset);
+
+              /* If the symbol has been forced local, output a
+                 RELATIVE reloc, otherwise it will be handled in
+                 finish_dynamic_symbol.  */
+              if (info->shared && !dynamic_symbol_p)
+                elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
+                                         gotent->got_offset, 0,
+                                         R_ALPHA_RELATIVE, value);
+            }
+
+          value = (sgot->output_section->vma
+                   + sgot->output_offset
+                   + gotent->got_offset);
+          value -= gp;
           goto default_reloc;
 
         case R_ALPHA_GPREL32:
+          /* If the target section was a removed linkonce section,
+             r_symndx will be zero.  In this case, assume that the
+             switch will not be used, so don't fill it in.  If we
+             do nothing here, we'll get relocation truncated messages,
+             due to the placement of the application above 4GB.  */
+          if (r_symndx == 0)
+            {
+              r = bfd_reloc_ok;
+              break;
+            }
+          /* FALLTHRU */
+
+        case R_ALPHA_GPREL16:
         case R_ALPHA_GPRELLOW:
+          if (dynamic_symbol_p)
+            {
+              (*_bfd_error_handler)
+                (_("%s: gp-relative relocation against dynamic symbol %s"),
+                 bfd_archive_filename (input_bfd), h->root.root.root.string);
+              ret_val = FALSE;
+            }
           BFD_ASSERT(gp != 0);
-          relocation -= gp;
+          value -= gp;
           goto default_reloc;
 
         case R_ALPHA_GPRELHIGH:
+          if (dynamic_symbol_p)
+            {
+              (*_bfd_error_handler)
+                (_("%s: gp-relative relocation against dynamic symbol %s"),
+                 bfd_archive_filename (input_bfd), h->root.root.root.string);
+              ret_val = FALSE;
+            }
           BFD_ASSERT(gp != 0);
-          relocation -= gp;
-          relocation += addend;
-          addend = 0;
-          relocation = (((bfd_signed_vma) relocation >> 16)
-                        + ((relocation >> 15) & 1));
+          value -= gp;
+          value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
           goto default_reloc;
 
-        case R_ALPHA_BRADDR:
         case R_ALPHA_HINT:
+          /* A call to a dynamic symbol is definitely out of range of
+             the 16-bit displacement.  Don't bother writing anything.  */
+          if (dynamic_symbol_p)
+            {
+              r = bfd_reloc_ok;
+              break;
+            }
           /* The regular PC-relative stuff measures from the start of
              the instruction rather than the end.  */
-          addend -= 4;
+          value -= 4;
           goto default_reloc;
+
+        case R_ALPHA_BRADDR:
+          if (dynamic_symbol_p)
+            {
+              (*_bfd_error_handler)
+                (_("%s: pc-relative relocation against dynamic symbol %s"),
+                 bfd_archive_filename (input_bfd), h->root.root.root.string);
+              ret_val = FALSE;
+            }
+          /* The regular PC-relative stuff measures from the start of
+             the instruction rather than the end.  */
+          value -= 4;
+          goto default_reloc;
+
+        case R_ALPHA_BRSGP:
+          {
+            int other;
+            const char *name;
+
+            /* The regular PC-relative stuff measures from the start of
+               the instruction rather than the end.  */
+            value -= 4;
+
+            /* The source and destination gp must be the same.  Note that
+               the source will always have an assigned gp, since we forced
+               one in check_relocs, but that the destination may not, as
+               it might not have had any relocations at all.  Also take
+               care not to crash if H is an undefined symbol.  */
+            if (h != NULL && sec != NULL
+                && alpha_elf_tdata (sec->owner)->gotobj
+                && gotobj != alpha_elf_tdata (sec->owner)->gotobj)
+              {
+                (*_bfd_error_handler)
+                  (_("%s: change in gp: BRSGP %s"),
+                   bfd_archive_filename (input_bfd), h->root.root.root.string);
+                ret_val = FALSE;
+              }
+
+            /* The symbol should be marked either NOPV or STD_GPLOAD.  */
+            if (h != NULL)
+              other = h->root.other;
+            else
+              other = sym->st_other;
+            switch (other & STO_ALPHA_STD_GPLOAD)
+              {
+              case STO_ALPHA_NOPV:
+                break;
+              case STO_ALPHA_STD_GPLOAD:
+                value += 8;
+                break;
+              default:
+                if (h != NULL)
+                  name = h->root.root.root.string;
+                else
+                  {
+                    name = (bfd_elf_string_from_elf_section
+                            (input_bfd, symtab_hdr->sh_link, sym->st_name));
+                    if (name == NULL)
+                      name = _("<unknown>");
+                    else if (name[0] == 0)
+                      name = bfd_section_name (input_bfd, sec);
+                  }
+                (*_bfd_error_handler)
+                  (_("%s: !samegp reloc against symbol without .prologue: %s"),
+                   bfd_archive_filename (input_bfd), name);
+                ret_val = FALSE;
+                break;
+              }
+
+            goto default_reloc;
+          }
 
         case R_ALPHA_REFLONG:
         case R_ALPHA_REFQUAD:
+        case R_ALPHA_DTPREL64:
+        case R_ALPHA_TPREL64:
           {
-            Elf_Internal_Rela outrel;
-            boolean skip;
+            long dynindx, dyntype = r_type;
+            bfd_vma dynaddend;
 
             /* Careful here to remember RELATIVE relocations for global
                variables for symbolic shared objects.  */
 
-            if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
+            if (dynamic_symbol_p)
               {
                 BFD_ASSERT(h->root.dynindx != -1);
-                outrel.r_info = ELF64_R_INFO(h->root.dynindx, r_type);
-                outrel.r_addend = addend;
-                addend = 0, relocation = 0;
+                dynindx = h->root.dynindx;
+                dynaddend = addend;
+                addend = 0, value = 0;
               }
-            else if (info->shared && (input_section->flags & SEC_ALLOC))
+            else if (r_type == R_ALPHA_DTPREL64)
               {
-                outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
-                outrel.r_addend = 0;
+                BFD_ASSERT(tls_segment != NULL);
+                value -= dtp_base;
+                goto default_reloc;
+              }
+            else if (r_type == R_ALPHA_TPREL64)
+              {
+                BFD_ASSERT(tls_segment != NULL);
+                if (!info->shared)
+                  {
+                    value -= tp_base;
+                    goto default_reloc;
+                  }
+                dynindx = 0;
+                dynaddend = value - dtp_base;
+              }
+            else if (info->shared
+                     && r_symndx != 0
+                     && (input_section->flags & SEC_ALLOC))
+              {
+                if (r_type == R_ALPHA_REFLONG)
+                  {
+                    (*_bfd_error_handler)
+                      (_("%s: unhandled dynamic relocation against %s"),
+                       bfd_archive_filename (input_bfd),
+                       h->root.root.root.string);
+                    ret_val = FALSE;
+                  }
+                dynindx = 0;
+                dyntype = R_ALPHA_RELATIVE;
+                dynaddend = value;
               }
             else
               goto default_reloc;
 
-            if (!srel)
-              {
-                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));
-                BFD_ASSERT(name != NULL);
-
-                srel = bfd_get_section_by_name (dynobj, name);
-                BFD_ASSERT(srel != NULL);
-              }
-
-            skip = false;
-
-            if (elf_section_data (input_section)->stab_info == NULL)
-              outrel.r_offset = rel->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,
-                        rel->r_offset));
-                if (off == (bfd_vma) -1)
-                  skip = true;
-                outrel.r_offset = off;
-              }
-
-            if (! skip)
-              outrel.r_offset += (input_section->output_section->vma
-                                  + input_section->output_offset);
-            else
-              memset (&outrel, 0, sizeof outrel);
-
-            bfd_elf64_swap_reloca_out (output_bfd, &outrel,
-                                       ((Elf64_External_Rela *)
-                                        srel->contents)
-                                       + srel->reloc_count++);
-            BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
-                        <= srel->_cooked_size);
+            elf64_alpha_emit_dynrel (output_bfd, info, input_section,
+                                     srel, rel->r_offset, dynindx,
+                                     dyntype, dynaddend);
           }
+          goto default_reloc;
+
+        case R_ALPHA_SREL16:
+        case R_ALPHA_SREL32:
+        case R_ALPHA_SREL64:
+          if (dynamic_symbol_p)
+            {
+              (*_bfd_error_handler)
+                (_("%s: pc-relative relocation against dynamic symbol %s"),
+                 bfd_archive_filename (input_bfd), h->root.root.root.string);
+              ret_val = FALSE;
+            }
+
+          /* ??? .eh_frame references to discarded sections will be smashed
+             to relocations against SHN_UNDEF.  The .eh_frame format allows
+             NULL to be encoded as 0 in any format, so this works here.  */
+          if (r_symndx == 0)
+            howto = (elf64_alpha_howto_table
+                     + (r_type - R_ALPHA_SREL32 + R_ALPHA_REFLONG));
+          goto default_reloc;
+
+        case R_ALPHA_TLSLDM:
+          /* Ignore the symbol for the relocation.  The result is always
+             the current module.  */
+          dynamic_symbol_p = 0;
+          /* FALLTHRU */
+
+        case R_ALPHA_TLSGD:
+          if (!gotent->reloc_done)
+            {
+              gotent->reloc_done = 1;
+
+              /* Note that the module index for the main program is 1.  */
+              bfd_put_64 (output_bfd, !info->shared && !dynamic_symbol_p,
+                          sgot->contents + gotent->got_offset);
+
+              /* If the symbol has been forced local, output a
+                 DTPMOD64 reloc, otherwise it will be handled in
+                 finish_dynamic_symbol.  */
+              if (info->shared && !dynamic_symbol_p)
+                elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
+                                         gotent->got_offset, 0,
+                                         R_ALPHA_DTPMOD64, 0);
+
+              if (dynamic_symbol_p || r_type == R_ALPHA_TLSLDM)
+                value = 0;
+              else
+                {
+                  BFD_ASSERT(tls_segment != NULL);
+                  value -= dtp_base;
+                }
+              bfd_put_64 (output_bfd, value,
+                          sgot->contents + gotent->got_offset + 8);
+            }
+
+          value = (sgot->output_section->vma
+                   + sgot->output_offset
+                   + gotent->got_offset);
+          value -= gp;
+          goto default_reloc;
+
+        case R_ALPHA_DTPRELHI:
+        case R_ALPHA_DTPRELLO:
+        case R_ALPHA_DTPREL16:
+          if (dynamic_symbol_p)
+            {
+              (*_bfd_error_handler)
+                (_("%s: dtp-relative relocation against dynamic symbol %s"),
+                 bfd_archive_filename (input_bfd), h->root.root.root.string);
+              ret_val = FALSE;
+            }
+          BFD_ASSERT(tls_segment != NULL);
+          value -= dtp_base;
+          if (r_type == R_ALPHA_DTPRELHI)
+            value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
+          goto default_reloc;
+
+        case R_ALPHA_TPRELHI:
+        case R_ALPHA_TPRELLO:
+        case R_ALPHA_TPREL16:
+          if (info->shared)
+            {
+              (*_bfd_error_handler)
+                (_("%s: TLS local exec code cannot be linked into shared objects"),
+                bfd_archive_filename (input_bfd));
+              ret_val = FALSE;
+            }
+          else if (dynamic_symbol_p)
+            {
+              (*_bfd_error_handler)
+                (_("%s: tp-relative relocation against dynamic symbol %s"),
+                 bfd_archive_filename (input_bfd), h->root.root.root.string);
+              ret_val = FALSE;
+            }
+          BFD_ASSERT(tls_segment != NULL);
+          value -= tp_base;
+          if (r_type == R_ALPHA_TPRELHI)
+            value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
+          goto default_reloc;
+
+        case R_ALPHA_GOTDTPREL:
+        case R_ALPHA_GOTTPREL:
+          BFD_ASSERT(sgot != NULL);
+          BFD_ASSERT(gp != 0);
+          BFD_ASSERT(gotent != NULL);
+          BFD_ASSERT(gotent->use_count >= 1);
+
+          if (!gotent->reloc_done)
+            {
+              gotent->reloc_done = 1;
+
+              if (dynamic_symbol_p)
+                value = 0;
+              else
+                {
+                  BFD_ASSERT(tls_segment != NULL);
+                  if (r_type == R_ALPHA_GOTDTPREL)
+                    value -= dtp_base;
+                  else if (!info->shared)
+                    value -= tp_base;
+                  else
+                    {
+                      elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
+                                               gotent->got_offset, 0,
+                                               R_ALPHA_TPREL64,
+                                               value - dtp_base);
+                      value = 0;
+                    }
+                }
+              bfd_put_64 (output_bfd, value,
+                          sgot->contents + gotent->got_offset);
+            }
+
+          value = (sgot->output_section->vma
+                   + sgot->output_offset
+                   + gotent->got_offset);
+          value -= gp;
           goto default_reloc;
 
@@ -3746 +4914 @@
         default_reloc:
           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
-                                        contents, rel->r_offset, relocation,
-                                        addend);
+                                        contents, rel->r_offset, value, 0);
           break;
         }
@@ -3759 +4926 @@
           {
             const char *name;
+
+            /* Don't warn if the overflow is due to pc relative reloc
+               against discarded section.  Section optimization code should
+               handle it.  */
+
+            if (r_symndx < symtab_hdr->sh_info
+                && sec != NULL && howto->pc_relative
+                && elf_discarded_section (sec))
+              break;
 
             if (h != NULL)
@@ -3767 +4943 @@
                         (input_bfd, symtab_hdr->sh_link, sym->st_name));
                 if (name == NULL)
-                  return false;
+                  return FALSE;
                 if (*name == '\0')
                   name = bfd_section_name (input_bfd, sec);
@@ -3774 +4950 @@
                    (info, name, howto->name, (bfd_vma) 0,
                     input_bfd, input_section, rel->r_offset)))
-              return false;
+              ret_val = FALSE;
           }
           break;
@@ -3784 +4960 @@
     }
 
-  return true;
+  return ret_val;
 }
 
@@ -3790 +4966 @@
    dynamic sections here.  */
 
-static boolean
+static bfd_boolean
 elf64_alpha_finish_dynamic_symbol (output_bfd, info, h, sym)
      bfd *output_bfd;
@@ -3804 +4980 @@
       asection *splt, *sgot, *srel;
       Elf_Internal_Rela outrel;
+      bfd_byte *loc;
       bfd_vma got_addr, plt_addr;
       bfd_vma plt_index;
@@ -3833 +5010 @@
       /* Fill in the entry in the procedure linkage table.  */
       {
-        unsigned insn1, insn2, insn3;
+        bfd_vma insn1, insn2, insn3;
 
         insn1 = PLT_ENTRY_WORD1 | ((-(h->plt.offset + 4) >> 2) & 0x1fffff);
@@ -3849 +5026 @@
       outrel.r_addend = 0;
 
-      bfd_elf64_swap_reloca_out (output_bfd, &outrel,
-                                 ((Elf64_External_Rela *)srel->contents
-                                  + plt_index));
+      loc = srel->contents + plt_index * sizeof (Elf64_External_Rela);
+      bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
 
       if (!(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
@@ -3880 +5056 @@
 
               if (info->shared)
-                {
-                  outrel.r_offset = (sgot->output_section->vma
-                                     + sgot->output_offset
-                                     + gotent->got_offset);
-                  outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
-                  outrel.r_addend = 0;
-
-                  bfd_elf64_swap_reloca_out (output_bfd, &outrel,
-                                             ((Elf64_External_Rela *)
-                                              srel->contents)
-                                             + srel->reloc_count++);
-                  BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
-                              <= srel->_cooked_size);
-                }
+                elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel,
+                                         gotent->got_offset, 0,
+                                         R_ALPHA_RELATIVE, plt_addr);
 
               gotent = gotent->next;
@@ -3904 +5069 @@
       /* Fill in the dynamic relocations for this symbol's .got entries.  */
       asection *srel;
-      Elf_Internal_Rela outrel;
       struct alpha_elf_got_entry *gotent;
 
@@ -3910 +5074 @@
       BFD_ASSERT (srel != NULL);
 
-      outrel.r_info = ELF64_R_INFO (h->dynindx, R_ALPHA_GLOB_DAT);
       for (gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
            gotent != NULL;
            gotent = gotent->next)
         {
-          asection *sgot = alpha_elf_tdata (gotent->gotobj)->got;
-          outrel.r_offset = (sgot->output_section->vma
-                             + sgot->output_offset
-                             + gotent->got_offset);
-          outrel.r_addend = gotent->addend;
-
-          bfd_elf64_swap_reloca_out (output_bfd, &outrel,
-                                     ((Elf64_External_Rela *)srel->contents
-                                      + srel->reloc_count++));
-          BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
-                      <= srel->_cooked_size);
+          asection *sgot;
+          long r_type;
+
+          if (gotent->use_count == 0)
+            continue;
+
+          sgot = alpha_elf_tdata (gotent->gotobj)->got;
+
+          r_type = gotent->reloc_type;
+          switch (r_type)
+            {
+            case R_ALPHA_LITERAL:
+              r_type = R_ALPHA_GLOB_DAT;
+              break;
+            case R_ALPHA_TLSGD:
+              r_type = R_ALPHA_DTPMOD64;
+              break;
+            case R_ALPHA_GOTDTPREL:
+              r_type = R_ALPHA_DTPREL64;
+              break;
+            case R_ALPHA_GOTTPREL:
+              r_type = R_ALPHA_TPREL64;
+              break;
+            case R_ALPHA_TLSLDM:
+            default:
+              abort ();
+            }
+
+          elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel, 
+                                   gotent->got_offset, h->dynindx,
+                                   r_type, gotent->addend);
+
+          if (gotent->reloc_type == R_ALPHA_TLSGD)
+            elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel, 
+                                     gotent->got_offset + 8, h->dynindx,
+                                     R_ALPHA_DTPREL64, gotent->addend);
         }
     }
@@ -3935 +5123 @@
     sym->st_shndx = SHN_ABS;
 
-  return true;
+  return TRUE;
 }
 
 /* Finish up the dynamic sections.  */
 
-static boolean
+static bfd_boolean
 elf64_alpha_finish_dynamic_sections (output_bfd, info)
      bfd *output_bfd;
@@ -4010 +5198 @@
         }
 
-      /* Initialize the PLT0 entry */
+      /* Initialize the PLT0 entry.  */
       if (splt->_raw_size > 0)
         {
@@ -4019 +5207 @@
 
           /* The next two words will be filled in by ld.so */
-          bfd_put_64 (output_bfd, 0, splt->contents + 16);
-          bfd_put_64 (output_bfd, 0, splt->contents + 24);
-
-          elf_section_data (splt->output_section)->this_hdr.sh_entsize =
-            PLT_HEADER_SIZE;
-        }
-    }
-
-  return true;
+          bfd_put_64 (output_bfd, (bfd_vma) 0, splt->contents + 16);
+          bfd_put_64 (output_bfd, (bfd_vma) 0, splt->contents + 24);
+
+          elf_section_data (splt->output_section)->this_hdr.sh_entsize = 0;
+        }
+    }
+
+  return TRUE;
 }
 
-/* We need to use a special link routine to handle the .reginfo and
-   the .mdebug sections.  We need to merge all instances of these
-   sections together, not write them all out sequentially.  */
-
-static boolean
+/* We need to use a special link routine to handle the .mdebug section.
+   We need to merge all instances of these sections together, not write
+   them all out sequentially.  */
+
+static bfd_boolean
 elf64_alpha_final_link (abfd, info)
      bfd *abfd;
@@ -4041 +5228 @@
   asection *o;
   struct bfd_link_order *p;
-  asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
+  asection *mdebug_sec;
   struct ecoff_debug_info debug;
   const struct ecoff_debug_swap *swap
@@ -4048 +5235 @@
   PTR mdebug_handle = NULL;
 
-#if 0
-              if (++ngots == 2)
-                {
-                  (*info->callbacks->warning)
-                    (info, _("using multiple gp values"), (char *) NULL,
-                     output_bfd, (asection *) NULL, (bfd_vma) 0);
-                }
-#endif
-
-  /* Go through the sections and collect the .reginfo and .mdebug
-     information.  */
-  reginfo_sec = NULL;
+  /* Go through the sections and collect the mdebug information.  */
   mdebug_sec = NULL;
-  gptab_data_sec = NULL;
-  gptab_bss_sec = NULL;
   for (o = abfd->sections; o != (asection *) NULL; o = o->next)
     {
-#ifdef ERIC_neverdef
-      if (strcmp (o->name, ".reginfo") == 0)
-        {
-          memset (&reginfo, 0, sizeof reginfo);
-
-          /* We have found the .reginfo section in the output file.
-             Look through all the link_orders comprising it and merge
-             the information together.  */
-          for (p = o->link_order_head;
-               p != (struct bfd_link_order *) NULL;
-               p = p->next)
-            {
-              asection *input_section;
-              bfd *input_bfd;
-              Elf64_External_RegInfo ext;
-              Elf64_RegInfo sub;
-
-              if (p->type != bfd_indirect_link_order)
-                {
-                  if (p->type == bfd_fill_link_order)
-                    continue;
-                  abort ();
-                }
-
-              input_section = p->u.indirect.section;
-              input_bfd = input_section->owner;
-
-              /* The linker emulation code has probably clobbered the
-                 size to be zero bytes.  */
-              if (input_section->_raw_size == 0)
-                input_section->_raw_size = sizeof (Elf64_External_RegInfo);
-
-              if (! bfd_get_section_contents (input_bfd, input_section,
-                                              (PTR) &ext,
-                                              (file_ptr) 0,
-                                              sizeof ext))
-                return false;
-
-              bfd_alpha_elf64_swap_reginfo_in (input_bfd, &ext, &sub);
-
-              reginfo.ri_gprmask |= sub.ri_gprmask;
-              reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
-              reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
-              reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
-              reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
-
-              /* ri_gp_value is set by the function
-                 alpha_elf_section_processing when the section is
-                 finally written out.  */
-
-              /* Hack: reset the SEC_HAS_CONTENTS flag so that
-                 elf_link_input_bfd ignores this section.  */
-              input_section->flags &=~ SEC_HAS_CONTENTS;
-            }
-
-          /* Force the section size to the value we want.  */
-          o->_raw_size = sizeof (Elf64_External_RegInfo);
-
-          /* Skip this section later on (I don't think this currently
-             matters, but someday it might).  */
-          o->link_order_head = (struct bfd_link_order *) NULL;
-
-          reginfo_sec = o;
-        }
-#endif
-
       if (strcmp (o->name, ".mdebug") == 0)
         {
@@ -4170 +5278 @@
           mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
           if (mdebug_handle == (PTR) NULL)
-            return false;
+            return FALSE;
 
           if (1)
@@ -4176 +5284 @@
               asection *s;
               EXTR esym;
-              bfd_vma last;
+              bfd_vma last = 0;
               unsigned int i;
               static const char * const name[] =
@@ -4209 +5317 @@
                   if (! bfd_ecoff_debug_one_external (abfd, &debug, swap,
                                                       name[i], &esym))
-                    return false;
+                    return FALSE;
                 }
             }
@@ -4226 +5334 @@
               if (p->type != bfd_indirect_link_order)
                 {
-                  if (p->type == bfd_fill_link_order)
+                  if (p->type == bfd_data_link_order)
                     continue;
                   abort ();
@@ -4254 +5362 @@
               if (!elf64_alpha_read_ecoff_info (input_bfd, input_section,
                                                 &input_debug))
-                return false;
+                return FALSE;
 
               if (! (bfd_ecoff_debug_accumulate
                      (mdebug_handle, abfd, &debug, swap, input_bfd,
                       &input_debug, input_swap, info)))
-                return false;
+                return FALSE;
 
               /* Loop through the external symbols.  For each one with
@@ -4285 +5393 @@
                   name = input_debug.ssext + ext.asym.iss;
                   h = alpha_elf_link_hash_lookup (alpha_elf_hash_table (info),
-                                                  name, false, false, true);
+                                                  name, FALSE, FALSE, TRUE);
                   if (h == NULL || h->esym.ifd != -2)
                     continue;
@@ -4317 +5425 @@
             }
 
-#ifdef ERIC_neverdef
-          if (info->shared)
-            {
-              /* Create .rtproc section.  */
-              rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
-              if (rtproc_sec == NULL)
-                {
-                  flagword flags = (SEC_HAS_CONTENTS
-                                    | SEC_IN_MEMORY
-                                    | SEC_LINKER_CREATED
-                                    | SEC_READONLY);
-
-                  rtproc_sec = bfd_make_section (abfd, ".rtproc");
-                  if (rtproc_sec == NULL
-                      || ! bfd_set_section_flags (abfd, rtproc_sec, flags)
-                      || ! bfd_set_section_alignment (abfd, rtproc_sec, 12))
-                    return false;
-                }
-
-              if (! alpha_elf_create_procedure_table (mdebug_handle, abfd,
-                                                     info, rtproc_sec, &debug))
-                return false;
-            }
-#endif
-
           /* Build the external symbol information.  */
           einfo.abfd = abfd;
@@ -4347 +5430 @@
           einfo.debug = &debug;
           einfo.swap = swap;
-          einfo.failed = false;
+          einfo.failed = FALSE;
           elf_link_hash_traverse (elf_hash_table (info),
                                   elf64_alpha_output_extsym,
                                   (PTR) &einfo);
           if (einfo.failed)
-            return false;
+            return FALSE;
 
           /* Set the size of the .mdebug section.  */
@@ -4363 +5446 @@
           mdebug_sec = o;
         }
-
-#ifdef ERIC_neverdef
-      if (strncmp (o->name, ".gptab.", sizeof ".gptab." - 1) == 0)
-        {
-          const char *subname;
-          unsigned int c;
-          Elf64_gptab *tab;
-          Elf64_External_gptab *ext_tab;
-          unsigned int i;
-
-          /* The .gptab.sdata and .gptab.sbss sections hold
-             information describing how the small data area would
-             change depending upon the -G switch.  These sections
-             not used in executables files.  */
-          if (! info->relocateable)
-            {
-              asection **secpp;
-
-              for (p = o->link_order_head;
-                   p != (struct bfd_link_order *) NULL;
-                   p = p->next)
-                {
-                  asection *input_section;
-
-                  if (p->type != bfd_indirect_link_order)
-                    {
-                      if (p->type == bfd_fill_link_order)
-                        continue;
-                      abort ();
-                    }
-
-                  input_section = p->u.indirect.section;
-
-                  /* Hack: reset the SEC_HAS_CONTENTS flag so that
-                     elf_link_input_bfd ignores this section.  */
-                  input_section->flags &=~ SEC_HAS_CONTENTS;
-                }
-
-              /* Skip this section later on (I don't think this
-                 currently matters, but someday it might).  */
-              o->link_order_head = (struct bfd_link_order *) NULL;
-
-              /* Really remove the section.  */
-              for (secpp = &abfd->sections;
-                   *secpp != o;
-                   secpp = &(*secpp)->next)
-                ;
-              *secpp = (*secpp)->next;
-              --abfd->section_count;
-
-              continue;
-            }
-
-          /* There is one gptab for initialized data, and one for
-             uninitialized data.  */
-          if (strcmp (o->name, ".gptab.sdata") == 0)
-            gptab_data_sec = o;
-          else if (strcmp (o->name, ".gptab.sbss") == 0)
-            gptab_bss_sec = o;
-          else
-            {
-              (*_bfd_error_handler)
-                (_("%s: illegal section name `%s'"),
-                 bfd_get_filename (abfd), o->name);
-              bfd_set_error (bfd_error_nonrepresentable_section);
-              return false;
-            }
-
-          /* The linker script always combines .gptab.data and
-             .gptab.sdata into .gptab.sdata, and likewise for
-             .gptab.bss and .gptab.sbss.  It is possible that there is
-             no .sdata or .sbss section in the output file, in which
-             case we must change the name of the output section.  */
-          subname = o->name + sizeof ".gptab" - 1;
-          if (bfd_get_section_by_name (abfd, subname) == NULL)
-            {
-              if (o == gptab_data_sec)
-                o->name = ".gptab.data";
-              else
-                o->name = ".gptab.bss";
-              subname = o->name + sizeof ".gptab" - 1;
-              BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
-            }
-
-          /* Set up the first entry.  */
-          c = 1;
-          tab = (Elf64_gptab *) bfd_malloc (c * sizeof (Elf64_gptab));
-          if (tab == NULL)
-            return false;
-          tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
-          tab[0].gt_header.gt_unused = 0;
-
-          /* Combine the input sections.  */
-          for (p = o->link_order_head;
-               p != (struct bfd_link_order *) NULL;
-               p = p->next)
-            {
-              asection *input_section;
-              bfd *input_bfd;
-              bfd_size_type size;
-              unsigned long last;
-              bfd_size_type gpentry;
-
-              if (p->type != bfd_indirect_link_order)
-                {
-                  if (p->type == bfd_fill_link_order)
-                    continue;
-                  abort ();
-                }
-
-              input_section = p->u.indirect.section;
-              input_bfd = input_section->owner;
-
-              /* Combine the gptab entries for this input section one
-                 by one.  We know that the input gptab entries are
-                 sorted by ascending -G value.  */
-              size = bfd_section_size (input_bfd, input_section);
-              last = 0;
-              for (gpentry = sizeof (Elf64_External_gptab);
-                   gpentry < size;
-                   gpentry += sizeof (Elf64_External_gptab))
-                {
-                  Elf64_External_gptab ext_gptab;
-                  Elf64_gptab int_gptab;
-                  unsigned long val;
-                  unsigned long add;
-                  boolean exact;
-                  unsigned int look;
-
-                  if (! (bfd_get_section_contents
-                         (input_bfd, input_section, (PTR) &ext_gptab,
-                          gpentry, sizeof (Elf64_External_gptab))))
-                    {
-                      free (tab);
-                      return false;
-                    }
-
-                  bfd_alpha_elf64_swap_gptab_in (input_bfd, &ext_gptab,
-                                                &int_gptab);
-                  val = int_gptab.gt_entry.gt_g_value;
-                  add = int_gptab.gt_entry.gt_bytes - last;
-
-                  exact = false;
-                  for (look = 1; look < c; look++)
-                    {
-                      if (tab[look].gt_entry.gt_g_value >= val)
-                        tab[look].gt_entry.gt_bytes += add;
-
-                      if (tab[look].gt_entry.gt_g_value == val)
-                        exact = true;
-                    }
-
-                  if (! exact)
-                    {
-                      Elf64_gptab *new_tab;
-                      unsigned int max;
-
-                      /* We need a new table entry.  */
-                      new_tab = ((Elf64_gptab *)
-                                 bfd_realloc ((PTR) tab,
-                                              (c + 1) * sizeof (Elf64_gptab)));
-                      if (new_tab == NULL)
-                        {
-                          free (tab);
-                          return false;
-                        }
-                      tab = new_tab;
-                      tab[c].gt_entry.gt_g_value = val;
-                      tab[c].gt_entry.gt_bytes = add;
-
-                      /* Merge in the size for the next smallest -G
-                         value, since that will be implied by this new
-                         value.  */
-                      max = 0;
-                      for (look = 1; look < c; look++)
-                        {
-                          if (tab[look].gt_entry.gt_g_value < val
-                              && (max == 0
-                                  || (tab[look].gt_entry.gt_g_value
-                                      > tab[max].gt_entry.gt_g_value)))
-                            max = look;
-                        }
-                      if (max != 0)
-                        tab[c].gt_entry.gt_bytes +=
-                          tab[max].gt_entry.gt_bytes;
-
-                      ++c;
-                    }
-
-                  last = int_gptab.gt_entry.gt_bytes;
-                }
-
-              /* Hack: reset the SEC_HAS_CONTENTS flag so that
-                 elf_link_input_bfd ignores this section.  */
-              input_section->flags &=~ SEC_HAS_CONTENTS;
-            }
-
-          /* The table must be sorted by -G value.  */
-          if (c > 2)
-            qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
-
-          /* Swap out the table.  */
-          ext_tab = ((Elf64_External_gptab *)
-                     bfd_alloc (abfd, c * sizeof (Elf64_External_gptab)));
-          if (ext_tab == NULL)
-            {
-              free (tab);
-              return false;
-            }
-
-          for (i = 0; i < c; i++)
-            bfd_alpha_elf64_swap_gptab_out (abfd, tab + i, ext_tab + i);
-          free (tab);
-
-          o->_raw_size = c * sizeof (Elf64_External_gptab);
-          o->contents = (bfd_byte *) ext_tab;
-
-          /* Skip this section later on (I don't think this currently
-             matters, but someday it might).  */
-          o->link_order_head = (struct bfd_link_order *) NULL;
-        }
-#endif
-
     }
 
   /* Invoke the regular ELF backend linker to do all the work.  */
   if (! bfd_elf64_bfd_final_link (abfd, info))
-    return false;
+    return FALSE;
 
   /* Now write out the computed sections.  */
@@ -4609 +5469 @@
         sgot = alpha_elf_tdata(i)->got;
         if (! bfd_set_section_contents (abfd, sgot->output_section,
-                                        sgot->contents, sgot->output_offset,
+                                        sgot->contents,
+                                        (file_ptr) sgot->output_offset,
                                         sgot->_raw_size))
-          return false;
+          return FALSE;
       }
   }
-
-#ifdef ERIC_neverdef
-  if (reginfo_sec != (asection *) NULL)
-    {
-      Elf64_External_RegInfo ext;
-
-      bfd_alpha_elf64_swap_reginfo_out (abfd, &reginfo, &ext);
-      if (! bfd_set_section_contents (abfd, reginfo_sec, (PTR) &ext,
-                                      (file_ptr) 0, sizeof ext))
-        return false;
-    }
-#endif
 
   if (mdebug_sec != (asection *) NULL)
@@ -4633 +5482 @@
                                                swap, info,
                                                mdebug_sec->filepos))
-        return false;
+        return FALSE;
 
       bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
     }
 
-  if (gptab_data_sec != (asection *) NULL)
-    {
-      if (! bfd_set_section_contents (abfd, gptab_data_sec,
-                                      gptab_data_sec->contents,
-                                      (file_ptr) 0,
-                                      gptab_data_sec->_raw_size))
-        return false;
-    }
-
-  if (gptab_bss_sec != (asection *) NULL)
-    {
-      if (! bfd_set_section_contents (abfd, gptab_bss_sec,
-                                      gptab_bss_sec->contents,
-                                      (file_ptr) 0,
-                                      gptab_bss_sec->_raw_size))
-        return false;
-    }
-
-  return true;
+  return TRUE;
+}
+
+static enum elf_reloc_type_class
+elf64_alpha_reloc_type_class (rela)
+     const Elf_Internal_Rela *rela;
+{
+  switch ((int) ELF64_R_TYPE (rela->r_info))
+    {
+    case R_ALPHA_RELATIVE:
+      return reloc_class_relative;
+    case R_ALPHA_JMP_SLOT:
+      return reloc_class_plt;
+    case R_ALPHA_COPY:
+      return reloc_class_copy;
+    default:
+      return reloc_class_normal;
+    }
 }
 
@@ -4708 +5556 @@
 /* Use a non-standard hash bucket size of 8.  */
 
-const struct elf_size_info alpha_elf_size_info =
+static const struct elf_size_info alpha_elf_size_info =
 {
   sizeof (Elf64_External_Ehdr),
@@ -4725 +5573 @@
   bfd_elf64_write_shdrs_and_ehdr,
   bfd_elf64_write_relocs,
+  bfd_elf64_swap_symbol_in,
   bfd_elf64_swap_symbol_out,
   bfd_elf64_slurp_reloc_table,
@@ -4730 +5579 @@
   bfd_elf64_swap_dyn_in,
   bfd_elf64_swap_dyn_out,
-  NULL,
-  NULL,
-  NULL,
-  NULL
+  bfd_elf64_swap_reloc_in,
+  bfd_elf64_swap_reloc_out,
+  bfd_elf64_swap_reloca_in,
+  bfd_elf64_swap_reloca_out
 };
 
@@ -4757 +5606 @@
 #define elf_backend_section_from_shdr \
   elf64_alpha_section_from_shdr
+#define elf_backend_section_flags \
+  elf64_alpha_section_flags
 #define elf_backend_fake_sections \
   elf64_alpha_fake_sections
@@ -4787 +5638 @@
 #define bfd_elf64_bfd_final_link \
   elf64_alpha_final_link
+#define elf_backend_reloc_type_class \
+  elf64_alpha_reloc_type_class
 
 #define elf_backend_ecoff_debug_swap \
@@ -4802 +5655 @@
 
 #include "elf64-target.h"
+
+
+/* FreeBSD support.  */
+
+#undef TARGET_LITTLE_SYM
+#define TARGET_LITTLE_SYM       bfd_elf64_alpha_freebsd_vec
+#undef TARGET_LITTLE_NAME
+#define TARGET_LITTLE_NAME      "elf64-alpha-freebsd"
+
+/* The kernel recognizes executables as valid only if they carry a
+   "FreeBSD" label in the ELF header.  So we put this label on all
+   executables and (for simplicity) also all other object files.  */
+
+static void elf64_alpha_fbsd_post_process_headers
+  PARAMS ((bfd *, struct bfd_link_info *));
+
+static void
+elf64_alpha_fbsd_post_process_headers (abfd, link_info)
+     bfd * abfd;
+     struct bfd_link_info * link_info ATTRIBUTE_UNUSED;
+{
+  Elf_Internal_Ehdr * i_ehdrp;  /* ELF file header, internal form.  */
+
+  i_ehdrp = elf_elfheader (abfd);
+
+  /* Put an ABI label supported by FreeBSD >= 4.1.  */
+  i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
+#ifdef OLD_FREEBSD_ABI_LABEL
+  /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard.  */
+  memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
+#endif
+}
+
+#undef elf_backend_post_process_headers
+#define elf_backend_post_process_headers \
+  elf64_alpha_fbsd_post_process_headers
+
+#undef  elf64_bed
+#define elf64_bed elf64_alpha_fbsd_bed
+
+#include "elf64-target.h"