* configure.ac (ia64*-*-*vms*): Add support for ld.

	* configure: Regenerate.

	* scripttempl/ia64vms.sc: New file.
	* emultempl/vms.em (_before_parse): Support for ia64.
	(elf64-ia64-vms): New fragment for ia64.
	* emulparams/elf64_ia64_vms.sh: New file.
	* configure.tgt (ia64-*-*vms*): Add.
	* Makefile.am (ALL_64_EMULATION_SOURCES): Add eelf64_ia64_vms.c
	(eelf64_ia64_vms.c): New rule.
	* Makefile.in: Regenerate.

	* elflink.c (elf_link_output_extsym): Add a guard.
	(bfd_elf_final_link): Remove assertion.
	(bfd_elf_final_link): Add a guard.
	* elfnn-ia64.c (INCLUDE_IA64_VMS): Removed.
	(elfNN_vms_section_from_shdr, elfNN_vms_object_p)
	(elfNN_vms_post_process_headers, elfNN_vms_section_processing)
	(elfNN_vms_final_write_processing, elfNN_vms_close_and_cleanup):
	Remove.
	(elfNN-ia64-vms target): Move to ...
	* elf64-ia64-vms.c: New file.
	* configure.in (bfd_elf64_ia64_vms_vec): Add elf64-ia64-vms.lo
	* Makefile.am (BFD64_BACKENDS): Add elf64-ia64-vms.lo.
	(BFD64_BACKENDS_CFILES): Ad elf64-ia64-vms.c.
	* configure: Regenerate.
	* Makefile.in: Regenerate.

18 files changed, 5868 insertions, 375 deletions

diff --git a/ChangeLog b/ChangeLog
index cff1dfb..c4b159f 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,8 @@
+2012-03-19  Tristan Gingold  <gingold@adacore.com>
+
+	* configure.ac (ia64*-*-*vms*): Add support for ld.
+	* configure: Regenerate.
+
 2012-03-14  Rainer Orth  <ro@CeBiTec.Uni-Bielefeld.DE>
 
 	* configure.ac (enable_libgomp): Remove *-*-irix6*.
diff --git a/bfd/ChangeLog b/bfd/ChangeLog
index 74f8c3a..f84e758 100644
--- a/bfd/ChangeLog
+++ b/bfd/ChangeLog
@@ -1,3 +1,21 @@
+2012-04-12  Tristan Gingold  <gingold@adacore.com>
+
+	* elflink.c (elf_link_output_extsym): Add a guard.
+	(bfd_elf_final_link): Remove assertion.
+	(bfd_elf_final_link): Add a guard.
+	* elfnn-ia64.c (INCLUDE_IA64_VMS): Removed.
+	(elfNN_vms_section_from_shdr, elfNN_vms_object_p)
+	(elfNN_vms_post_process_headers, elfNN_vms_section_processing)
+	(elfNN_vms_final_write_processing, elfNN_vms_close_and_cleanup):
+	Remove.
+	(elfNN-ia64-vms target): Move to ...
+	* elf64-ia64-vms.c: New file.
+	* configure.in (bfd_elf64_ia64_vms_vec): Add elf64-ia64-vms.lo
+	* Makefile.am (BFD64_BACKENDS): Add elf64-ia64-vms.lo.
+	(BFD64_BACKENDS_CFILES): Ad elf64-ia64-vms.c.
+	* configure: Regenerate.
+	* Makefile.in: Regenerate.
+
 2012-04-11  Nick Clifton  <nickc@redhat.com>
 
 	PR binutils/13897
diff --git a/bfd/Makefile.am b/bfd/Makefile.am
index 50c84ee..627f1bb 100644
--- a/bfd/Makefile.am
+++ b/bfd/Makefile.am
@@ -619,6 +619,7 @@ BFD64_BACKENDS = \
 	elf64-gen.lo \
 	elf64-hppa.lo \
 	elf64-ia64.lo \
+	elf64-ia64-vms.lo \
 	elf64-mips.lo \
 	elf64-mmix.lo \
 	elf64-ppc.lo \
@@ -654,6 +655,7 @@ BFD64_BACKENDS_CFILES = \
 	elf64-alpha.c \
 	elf64-gen.c \
 	elf64-hppa.c \
+	elf64-ia64-vms.c \
 	elf64-mips.c \
 	elf64-mmix.c \
 	elf64-ppc.c \
diff --git a/bfd/Makefile.in b/bfd/Makefile.in
index cf7b380..6d9c760 100644
--- a/bfd/Makefile.in
+++ b/bfd/Makefile.in
@@ -920,6 +920,7 @@ BFD64_BACKENDS = \
 	elf64-gen.lo \
 	elf64-hppa.lo \
 	elf64-ia64.lo \
+	elf64-ia64-vms.lo \
 	elf64-mips.lo \
 	elf64-mmix.lo \
 	elf64-ppc.lo \
@@ -955,6 +956,7 @@ BFD64_BACKENDS_CFILES = \
 	elf64-alpha.c \
 	elf64-gen.c \
 	elf64-hppa.c \
+	elf64-ia64-vms.c \
 	elf64-mips.c \
 	elf64-mmix.c \
 	elf64-ppc.c \
@@ -1416,6 +1418,7 @@ distclean-compile:
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf64-alpha.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf64-gen.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf64-hppa.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf64-ia64-vms.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf64-ia64.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf64-mips.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf64-mmix.Plo@am__quote@
diff --git a/bfd/configure b/bfd/configure
index dd274bd..d90e52f 100755
--- a/bfd/configure
+++ b/bfd/configure
@@ -15341,7 +15341,7 @@ do
     bfd_elf64_ia64_big_vec)	tb="$tb elf64-ia64.lo elfxx-ia64.lo elf64.lo $elf"; target_size=64 ;;
     bfd_elf64_ia64_hpux_big_vec) tb="$tb elf64-ia64.lo elfxx-ia64.lo elf64.lo $elf"; target_size=64 ;;
     bfd_elf64_ia64_little_vec)	tb="$tb elf64-ia64.lo elfxx-ia64.lo elf64.lo $elf"; target_size=64 ;;
-    bfd_elf64_ia64_vms_vec)	tb="$tb elf64-ia64.lo elfxx-ia64.lo  elf64.lo vms-lib.lo vms-misc.lo $elf"; target_size=64 ;;
+    bfd_elf64_ia64_vms_vec)	tb="$tb elf64-ia64-vms.lo elf64-ia64.lo elfxx-ia64.lo elf64.lo vms-lib.lo vms-misc.lo $elf"; target_size=64 ;;
     bfd_elf64_little_generic_vec) tb="$tb elf64-gen.lo elf64.lo $elf"; target_size=64 ;;
     bfd_elf64_littlemips_vec) 	tb="$tb elf64-mips.lo elf64.lo elfxx-mips.lo elf-vxworks.lo elf32.lo $elf ecofflink.lo"; target_size=64 ;;
     bfd_elf64_mmix_vec) 	tb="$tb elf64-mmix.lo elf64.lo $elf" target_size=64 ;;
diff --git a/bfd/configure.in b/bfd/configure.in
index af3622b..37cc769 100644
--- a/bfd/configure.in
+++ b/bfd/configure.in
@@ -827,7 +827,7 @@ do
     bfd_elf64_ia64_big_vec)	tb="$tb elf64-ia64.lo elfxx-ia64.lo elf64.lo $elf"; target_size=64 ;;
     bfd_elf64_ia64_hpux_big_vec) tb="$tb elf64-ia64.lo elfxx-ia64.lo elf64.lo $elf"; target_size=64 ;;
     bfd_elf64_ia64_little_vec)	tb="$tb elf64-ia64.lo elfxx-ia64.lo elf64.lo $elf"; target_size=64 ;;
-    bfd_elf64_ia64_vms_vec)	tb="$tb elf64-ia64.lo elfxx-ia64.lo  elf64.lo vms-lib.lo vms-misc.lo $elf"; target_size=64 ;;
+    bfd_elf64_ia64_vms_vec)	tb="$tb elf64-ia64-vms.lo elf64-ia64.lo elfxx-ia64.lo elf64.lo vms-lib.lo vms-misc.lo $elf"; target_size=64 ;;    
     bfd_elf64_little_generic_vec) tb="$tb elf64-gen.lo elf64.lo $elf"; target_size=64 ;;
     bfd_elf64_littlemips_vec) 	tb="$tb elf64-mips.lo elf64.lo elfxx-mips.lo elf-vxworks.lo elf32.lo $elf ecofflink.lo"; target_size=64 ;;
     bfd_elf64_mmix_vec) 	tb="$tb elf64-mmix.lo elf64.lo $elf" target_size=64 ;;
diff --git a/bfd/elf64-ia64-vms.c b/bfd/elf64-ia64-vms.c
new file mode 100644
index 0000000..1ab8e38
--- /dev/null
+++ b/bfd/elf64-ia64-vms.c
@@ -0,0 +1,5601 @@
+/* IA-64 support for OpenVMS
+   Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
+   2008, 2009, 2010, 2012  Free Software Foundation, Inc.
+
+   This file is part of BFD, the Binary File Descriptor library.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 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., 51 Franklin Street - Fifth Floor, Boston,
+   MA 02110-1301, USA.  */
+
+#include "sysdep.h"
+#include "bfd.h"
+#include "libbfd.h"
+#include "elf-bfd.h"
+#include "opcode/ia64.h"
+#include "elf/ia64.h"
+#include "objalloc.h"
+#include "hashtab.h"
+#include "elfxx-ia64.h"
+#include "vms.h"
+#include "bfdver.h"
+
+/* THE RULES for all the stuff the linker creates --
+
+  GOT		Entries created in response to LTOFF or LTOFF_FPTR
+		relocations.  Dynamic relocs created for dynamic
+		symbols in an application; REL relocs for locals
+		in a shared library.
+
+  FPTR		The canonical function descriptor.  Created for local
+		symbols in applications.  Descriptors for dynamic symbols
+		and local symbols in shared libraries are created by
+		ld.so.  Thus there are no dynamic relocs against these
+		objects.  The FPTR relocs for such _are_ passed through
+		to the dynamic relocation tables.
+
+  FULL_PLT	Created for a PCREL21B relocation against a dynamic symbol.
+		Requires the creation of a PLTOFF entry.  This does not
+		require any dynamic relocations.
+
+  PLTOFF	Created by PLTOFF relocations.  For local symbols, this
+		is an alternate function descriptor, and in shared libraries
+		requires two REL relocations.  Note that this cannot be
+		transformed into an FPTR relocation, since it must be in
+		range of the GP.  For dynamic symbols, this is a function
+		descriptor.  */
+
+typedef struct bfd_hash_entry *(*new_hash_entry_func)
+  (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
+
+/* In dynamically (linker-) created sections, we generally need to keep track
+   of the place a symbol or expression got allocated to. This is done via hash
+   tables that store entries of the following type.  */
+
+struct elf64_ia64_dyn_sym_info
+{
+  /* The addend for which this entry is relevant.  */
+  bfd_vma addend;
+
+  bfd_vma got_offset;
+  bfd_vma fptr_offset;
+  bfd_vma pltoff_offset;
+  bfd_vma plt_offset;
+  bfd_vma plt2_offset;
+
+  /* The symbol table entry, if any, that this was derived from.  */
+  struct elf_link_hash_entry *h;
+
+  /* Used to count non-got, non-plt relocations for delayed sizing
+     of relocation sections.  */
+  struct elf64_ia64_dyn_reloc_entry
+  {
+    struct elf64_ia64_dyn_reloc_entry *next;
+    asection *srel;
+    int type;
+    int count;
+  } *reloc_entries;
+
+  /* TRUE when the section contents have been updated.  */
+  unsigned got_done : 1;
+  unsigned fptr_done : 1;
+  unsigned pltoff_done : 1;
+
+  /* TRUE for the different kinds of linker data we want created.  */
+  unsigned want_got : 1;
+  unsigned want_gotx : 1;
+  unsigned want_fptr : 1;
+  unsigned want_ltoff_fptr : 1;
+  unsigned want_plt : 1;	/* A MIN_PLT entry.  */
+  unsigned want_plt2 : 1;	/* A FULL_PLT.  */
+  unsigned want_pltoff : 1;
+};
+
+struct elf64_ia64_local_hash_entry
+{
+  int id;
+  unsigned int r_sym;
+  /* The number of elements in elf64_ia64_dyn_sym_info array.  */
+  unsigned int count;
+  /* The number of sorted elements in elf64_ia64_dyn_sym_info array.  */
+  unsigned int sorted_count;
+  /* The size of elf64_ia64_dyn_sym_info array.  */
+  unsigned int size;
+  /* The array of elf64_ia64_dyn_sym_info.  */
+  struct elf64_ia64_dyn_sym_info *info;
+
+  /* TRUE if this hash entry's addends was translated for
+     SHF_MERGE optimization.  */
+  unsigned sec_merge_done : 1;
+};
+
+struct elf64_ia64_link_hash_entry
+{
+  struct elf_link_hash_entry root;
+
+  /* Set if this symbol is defined in a shared library.
+     We can't use root.u.def.section->owner as the symbol is an absolute
+     symbol.  */
+  bfd *shl;
+
+  /* The number of elements in elf64_ia64_dyn_sym_info array.  */
+  unsigned int count;
+  /* The number of sorted elements in elf64_ia64_dyn_sym_info array.  */
+  unsigned int sorted_count;
+  /* The size of elf64_ia64_dyn_sym_info array.  */
+  unsigned int size;
+  /* The array of elf64_ia64_dyn_sym_info.  */
+  struct elf64_ia64_dyn_sym_info *info;
+};
+
+struct elf64_ia64_link_hash_table
+{
+  /* The main hash table.  */
+  struct elf_link_hash_table root;
+
+  asection *fptr_sec;		/* Function descriptor table (or NULL).  */
+  asection *rel_fptr_sec;	/* Dynamic relocation section for same.  */
+  asection *pltoff_sec;		/* Private descriptors for plt (or NULL).  */
+  asection *fixups_sec;		/* Fixups section.  */
+  asection *transfer_sec;	/* Transfer vector section.  */
+  asection *note_sec;		/* .note section.  */
+
+  /* There are maybe R_IA64_GPREL22 relocations, including those
+     optimized from R_IA64_LTOFF22X, against non-SHF_IA_64_SHORT
+     sections.  We need to record those sections so that we can choose
+     a proper GP to cover all R_IA64_GPREL22 relocations.  */
+  asection *max_short_sec;	/* Maximum short output section.  */
+  bfd_vma max_short_offset;	/* Maximum short offset.  */
+  asection *min_short_sec;	/* Minimum short output section.  */
+  bfd_vma min_short_offset;	/* Minimum short offset.  */
+
+  htab_t loc_hash_table;
+  void *loc_hash_memory;
+};
+
+struct elf64_ia64_allocate_data
+{
+  struct bfd_link_info *info;
+  bfd_size_type ofs;
+};
+
+#define elf64_ia64_hash_table(p) \
+  (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
+  == IA64_ELF_DATA ? ((struct elf64_ia64_link_hash_table *) ((p)->hash)) : NULL)
+
+struct elf64_ia64_vms_obj_tdata
+{
+  struct elf_obj_tdata root;
+
+  /* Ident for shared library.  */
+  bfd_uint64_t ident;
+
+  /* Used only during link: offset in the .fixups section for this bfd.  */
+  bfd_vma fixups_off;
+
+  /* Max number of shared libraries.  */
+  unsigned int needed_count;
+};
+
+#define elf_ia64_vms_tdata(abfd) \
+  ((struct elf64_ia64_vms_obj_tdata *)((abfd)->tdata.any))
+#define elf_ia64_vms_ident(abfd) (elf_ia64_vms_tdata(abfd)->ident)
+
+struct elf64_vms_transfer
+{
+  unsigned char size[4];
+  unsigned char spare[4];
+  unsigned char tfradr1[8];
+  unsigned char tfradr2[8];
+  unsigned char tfradr3[8];
+  unsigned char tfradr4[8];
+  unsigned char tfradr5[8];
+
+  /* Local function descriptor for tfr3.  */
+  unsigned char tfr3_func[8];
+  unsigned char tfr3_gp[8];
+};
+
+typedef struct
+{
+  Elf64_External_Ehdr ehdr;
+  unsigned char vms_needed_count[8];
+} Elf64_External_VMS_Ehdr;
+
+static struct elf64_ia64_dyn_sym_info * get_dyn_sym_info
+  (struct elf64_ia64_link_hash_table *,
+   struct elf_link_hash_entry *,
+   bfd *, const Elf_Internal_Rela *, bfd_boolean);
+static bfd_boolean elf64_ia64_dynamic_symbol_p
+  (struct elf_link_hash_entry *);
+static bfd_boolean elf64_ia64_choose_gp
+  (bfd *, struct bfd_link_info *, bfd_boolean);
+static void elf64_ia64_dyn_sym_traverse
+  (struct elf64_ia64_link_hash_table *,
+   bfd_boolean (*) (struct elf64_ia64_dyn_sym_info *, void *),
+   void *);
+static bfd_boolean allocate_global_data_got
+  (struct elf64_ia64_dyn_sym_info *, void *);
+static bfd_boolean allocate_global_fptr_got
+  (struct elf64_ia64_dyn_sym_info *, void *);
+static bfd_boolean allocate_local_got
+  (struct elf64_ia64_dyn_sym_info *, void *);
+static bfd_boolean allocate_dynrel_entries
+  (struct elf64_ia64_dyn_sym_info *, void *);
+static asection *get_pltoff
+  (bfd *, struct elf64_ia64_link_hash_table *);
+static asection *get_got
+  (bfd *, struct elf64_ia64_link_hash_table *);
+
+
+/* Given a ELF reloc, return the matching HOWTO structure.  */
+
+static void
+elf64_ia64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
+			  arelent *bfd_reloc,
+			  Elf_Internal_Rela *elf_reloc)
+{
+  bfd_reloc->howto
+    = ia64_elf_lookup_howto ((unsigned int) ELF64_R_TYPE (elf_reloc->r_info));
+}
+
+
+#define PLT_FULL_ENTRY_SIZE	(2 * 16)
+
+static const bfd_byte plt_full_entry[PLT_FULL_ENTRY_SIZE] =
+{
+  0x0b, 0x78, 0x00, 0x02, 0x00, 0x24,  /*   [MMI]       addl r15=0,r1;;   */
+  0x00, 0x41, 0x3c, 0x70, 0x29, 0xc0,  /*               ld8.acq r16=[r15],8*/
+  0x01, 0x08, 0x00, 0x84,              /*               mov r14=r1;;      */
+  0x11, 0x08, 0x00, 0x1e, 0x18, 0x10,  /*   [MIB]       ld8 r1=[r15]      */
+  0x60, 0x80, 0x04, 0x80, 0x03, 0x00,  /*               mov b6=r16        */
+  0x60, 0x00, 0x80, 0x00               /*               br.few b6;;       */
+};
+
+static const bfd_byte oor_brl[16] =
+{
+  0x05, 0x00, 0x00, 0x00, 0x01, 0x00,  /*  [MLX]        nop.m 0           */
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  /*               brl.sptk.few tgt;;*/
+  0x00, 0x00, 0x00, 0xc0
+};
+
+
+/* These functions do relaxation for IA-64 ELF.  */
+
+/* Rename some of the generic section flags to better document how they
+   are used here.  */
+#define skip_relax_pass_0 sec_flg0
+#define skip_relax_pass_1 sec_flg1
+
+static void
+elf64_ia64_update_short_info (asection *sec, bfd_vma offset,
+			      struct elf64_ia64_link_hash_table *ia64_info)
+{
+  /* Skip ABS and SHF_IA_64_SHORT sections.  */
+  if (sec == bfd_abs_section_ptr
+      || (sec->flags & SEC_SMALL_DATA) != 0)
+    return;
+
+  if (!ia64_info->min_short_sec)
+    {
+      ia64_info->max_short_sec = sec;
+      ia64_info->max_short_offset = offset;
+      ia64_info->min_short_sec = sec;
+      ia64_info->min_short_offset = offset;
+    }
+  else if (sec == ia64_info->max_short_sec
+	   && offset > ia64_info->max_short_offset)
+    ia64_info->max_short_offset = offset;
+  else if (sec == ia64_info->min_short_sec
+	   && offset < ia64_info->min_short_offset)
+    ia64_info->min_short_offset = offset;
+  else if (sec->output_section->vma
+	   > ia64_info->max_short_sec->vma)
+    {
+      ia64_info->max_short_sec = sec;
+      ia64_info->max_short_offset = offset;
+    }
+  else if (sec->output_section->vma
+	   < ia64_info->min_short_sec->vma)
+    {
+      ia64_info->min_short_sec = sec;
+      ia64_info->min_short_offset = offset;
+    }
+}
+
+/* Use a two passes algorithm.  In the first pass, branches are relaxed
+   (which may increase the size of the section).  In the second pass,
+   the other relaxations are done.
+*/
+
+static bfd_boolean
+elf64_ia64_relax_section (bfd *abfd, asection *sec,
+			  struct bfd_link_info *link_info,
+			  bfd_boolean *again)
+{
+  struct one_fixup
+    {
+      struct one_fixup *next;
+      asection *tsec;
+      bfd_vma toff;
+      bfd_vma trampoff;
+    };
+
+  Elf_Internal_Shdr *symtab_hdr;
+  Elf_Internal_Rela *internal_relocs;
+  Elf_Internal_Rela *irel, *irelend;
+  bfd_byte *contents;
+  Elf_Internal_Sym *isymbuf = NULL;
+  struct elf64_ia64_link_hash_table *ia64_info;
+  struct one_fixup *fixups = NULL;
+  bfd_boolean changed_contents = FALSE;
+  bfd_boolean changed_relocs = FALSE;
+  bfd_boolean skip_relax_pass_0 = TRUE;
+  bfd_boolean skip_relax_pass_1 = TRUE;
+  bfd_vma gp = 0;
+
+  /* Assume we're not going to change any sizes, and we'll only need
+     one pass.  */
+  *again = FALSE;
+
+  if (link_info->relocatable)
+    (*link_info->callbacks->einfo)
+      (_("%P%F: --relax and -r may not be used together\n"));
+
+  /* Don't even try to relax for non-ELF outputs.  */
+  if (!is_elf_hash_table (link_info->hash))
+    return FALSE;
+
+  /* Nothing to do if there are no relocations or there is no need for
+     the current pass.  */
+  if ((sec->flags & SEC_RELOC) == 0
+      || sec->reloc_count == 0
+      || (link_info->relax_pass == 0 && sec->skip_relax_pass_0)
+      || (link_info->relax_pass == 1 && sec->skip_relax_pass_1))
+    return TRUE;
+
+  ia64_info = elf64_ia64_hash_table (link_info);
+  if (ia64_info == NULL)
+    return FALSE;
+
+  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+
+  /* Load the relocations for this section.  */
+  internal_relocs = (_bfd_elf_link_read_relocs
+		     (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
+		      link_info->keep_memory));
+  if (internal_relocs == NULL)
+    return FALSE;
+
+  irelend = internal_relocs + sec->reloc_count;
+
+  /* Get the section contents.  */
+  if (elf_section_data (sec)->this_hdr.contents != NULL)
+    contents = elf_section_data (sec)->this_hdr.contents;
+  else
+    {
+      if (!bfd_malloc_and_get_section (abfd, sec, &contents))
+	goto error_return;
+    }
+
+  for (irel = internal_relocs; irel < irelend; irel++)
+    {
+      unsigned long r_type = ELF64_R_TYPE (irel->r_info);
+      bfd_vma symaddr, reladdr, trampoff, toff, roff;
+      asection *tsec;
+      struct one_fixup *f;
+      bfd_size_type amt;
+      bfd_boolean is_branch;
+      struct elf64_ia64_dyn_sym_info *dyn_i;
+
+      switch (r_type)
+	{
+	case R_IA64_PCREL21B:
+	case R_IA64_PCREL21BI:
+	case R_IA64_PCREL21M:
+	case R_IA64_PCREL21F:
+	  /* In pass 1, all br relaxations are done. We can skip it. */
+	  if (link_info->relax_pass == 1)
+	    continue;
+	  skip_relax_pass_0 = FALSE;
+	  is_branch = TRUE;
+	  break;
+
+	case R_IA64_PCREL60B:
+	  /* We can't optimize brl to br in pass 0 since br relaxations
+	     will increase the code size. Defer it to pass 1.  */
+	  if (link_info->relax_pass == 0)
+	    {
+	      skip_relax_pass_1 = FALSE;
+	      continue;
+	    }
+	  is_branch = TRUE;
+	  break;
+
+	case R_IA64_GPREL22:
+	  /* Update max_short_sec/min_short_sec.  */
+
+	case R_IA64_LTOFF22X:
+	case R_IA64_LDXMOV:
+	  /* We can't relax ldx/mov in pass 0 since br relaxations will
+	     increase the code size. Defer it to pass 1.  */
+	  if (link_info->relax_pass == 0)
+	    {
+	      skip_relax_pass_1 = FALSE;
+	      continue;
+	    }
+	  is_branch = FALSE;
+	  break;
+
+	default:
+	  continue;
+	}
+
+      /* 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.  */
+	  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 == 0)
+		goto error_return;
+	    }
+
+	  isym = isymbuf + ELF64_R_SYM (irel->r_info);
+	  if (isym->st_shndx == SHN_UNDEF)
+	    continue;	/* We can't do anything with undefined symbols.  */
+	  else if (isym->st_shndx == SHN_ABS)
+	    tsec = bfd_abs_section_ptr;
+	  else if (isym->st_shndx == SHN_COMMON)
+	    tsec = bfd_com_section_ptr;
+	  else if (isym->st_shndx == SHN_IA_64_ANSI_COMMON)
+	    tsec = bfd_com_section_ptr;
+	  else
+	    tsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
+
+	  toff = isym->st_value;
+	  dyn_i = get_dyn_sym_info (ia64_info, NULL, abfd, irel, FALSE);
+	}
+      else
+	{
+	  unsigned long indx;
+	  struct elf_link_hash_entry *h;
+
+	  indx = ELF64_R_SYM (irel->r_info) - symtab_hdr->sh_info;
+	  h = elf_sym_hashes (abfd)[indx];
+	  BFD_ASSERT (h != NULL);
+
+	  while (h->root.type == bfd_link_hash_indirect
+		 || h->root.type == bfd_link_hash_warning)
+	    h = (struct elf_link_hash_entry *) h->root.u.i.link;
+
+	  dyn_i = get_dyn_sym_info (ia64_info, h, abfd, irel, FALSE);
+
+	  /* For branches to dynamic symbols, we're interested instead
+	     in a branch to the PLT entry.  */
+	  if (is_branch && dyn_i && dyn_i->want_plt2)
+	    {
+	      /* Internal branches shouldn't be sent to the PLT.
+		 Leave this for now and we'll give an error later.  */
+	      if (r_type != R_IA64_PCREL21B)
+		continue;
+
+	      tsec = ia64_info->root.splt;
+	      toff = dyn_i->plt2_offset;
+	      BFD_ASSERT (irel->r_addend == 0);
+	    }
+
+	  /* Can't do anything else with dynamic symbols.  */
+	  else if (elf64_ia64_dynamic_symbol_p (h))
+	    continue;
+
+	  else
+	    {
+	      /* We can't do anything with undefined symbols.  */
+	      if (h->root.type == bfd_link_hash_undefined
+		  || h->root.type == bfd_link_hash_undefweak)
+		continue;
+
+	      tsec = h->root.u.def.section;
+	      toff = h->root.u.def.value;
+	    }
+	}
+
+      toff += irel->r_addend;
+
+      symaddr = tsec->output_section->vma + tsec->output_offset + toff;
+
+      roff = irel->r_offset;
+
+      if (is_branch)
+	{
+	  bfd_signed_vma offset;
+
+	  reladdr = (sec->output_section->vma
+		     + sec->output_offset
+		     + roff) & (bfd_vma) -4;
+
+	  /* The .plt section is aligned at 32byte and the .text section
+	     is aligned at 64byte. The .text section is right after the
+	     .plt section.  After the first relaxation pass, linker may
+	     increase the gap between the .plt and .text sections up
+	     to 32byte.  We assume linker will always insert 32byte
+	     between the .plt and .text sections after the the first
+	     relaxation pass.  */
+	  if (tsec == ia64_info->root.splt)
+	    offset = -0x1000000 + 32;
+	  else
+	    offset = -0x1000000;
+
+	  /* If the branch is in range, no need to do anything.  */
+	  if ((bfd_signed_vma) (symaddr - reladdr) >= offset
+	      && (bfd_signed_vma) (symaddr - reladdr) <= 0x0FFFFF0)
+	    {
+	      /* If the 60-bit branch is in 21-bit range, optimize it. */
+	      if (r_type == R_IA64_PCREL60B)
+		{
+		  ia64_elf_relax_brl (contents, roff);
+
+		  irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
+                                               R_IA64_PCREL21B);
+
+		  /* If the original relocation offset points to slot
+		     1, change it to slot 2.  */
+		  if ((irel->r_offset & 3) == 1)
+		    irel->r_offset += 1;
+		}
+
+	      continue;
+	    }
+	  else if (r_type == R_IA64_PCREL60B)
+	    continue;
+	  else if (ia64_elf_relax_br (contents, roff))
+	    {
+	      irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
+                                           R_IA64_PCREL60B);
+
+	      /* Make the relocation offset point to slot 1.  */
+	      irel->r_offset = (irel->r_offset & ~((bfd_vma) 0x3)) + 1;
+	      continue;
+	    }
+
+	  /* We can't put a trampoline in a .init/.fini section. Issue
+	     an error.  */
+	  if (strcmp (sec->output_section->name, ".init") == 0
+	      || strcmp (sec->output_section->name, ".fini") == 0)
+	    {
+	      (*_bfd_error_handler)
+		(_("%B: Can't relax br at 0x%lx in section `%A'. Please use brl or indirect branch."),
+		 sec->owner, sec, (unsigned long) roff);
+	      bfd_set_error (bfd_error_bad_value);
+	      goto error_return;
+	    }
+
+	  /* If the branch and target are in the same section, you've
+	     got one honking big section and we can't help you unless
+	     you are branching backwards.  You'll get an error message
+	     later.  */
+	  if (tsec == sec && toff > roff)
+	    continue;
+
+	  /* Look for an existing fixup to this address.  */
+	  for (f = fixups; f ; f = f->next)
+	    if (f->tsec == tsec && f->toff == toff)
+	      break;
+
+	  if (f == NULL)
+	    {
+	      /* Two alternatives: If it's a branch to a PLT entry, we can
+		 make a copy of the FULL_PLT entry.  Otherwise, we'll have
+		 to use a `brl' insn to get where we're going.  */
+
+	      size_t size;
+
+	      if (tsec == ia64_info->root.splt)
+		size = sizeof (plt_full_entry);
+	      else
+		size = sizeof (oor_brl);
+
+	      /* Resize the current section to make room for the new branch. */
+	      trampoff = (sec->size + 15) & (bfd_vma) -16;
+
+	      /* If trampoline is out of range, there is nothing we
+		 can do.  */
+	      offset = trampoff - (roff & (bfd_vma) -4);
+	      if (offset < -0x1000000 || offset > 0x0FFFFF0)
+		continue;
+
+	      amt = trampoff + size;
+	      contents = (bfd_byte *) bfd_realloc (contents, amt);
+	      if (contents == NULL)
+		goto error_return;
+	      sec->size = amt;
+
+	      if (tsec == ia64_info->root.splt)
+		{
+		  memcpy (contents + trampoff, plt_full_entry, size);
+
+		  /* Hijack the old relocation for use as the PLTOFF reloc.  */
+		  irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
+					       R_IA64_PLTOFF22);
+		  irel->r_offset = trampoff;
+		}
+	      else
+		{
+                  memcpy (contents + trampoff, oor_brl, size);
+                  irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
+                                               R_IA64_PCREL60B);
+                  irel->r_offset = trampoff + 2;
+		}
+
+	      /* Record the fixup so we don't do it again this section.  */
+	      f = (struct one_fixup *)
+		bfd_malloc ((bfd_size_type) sizeof (*f));
+	      f->next = fixups;
+	      f->tsec = tsec;
+	      f->toff = toff;
+	      f->trampoff = trampoff;
+	      fixups = f;
+	    }
+	  else
+	    {
+	      /* If trampoline is out of range, there is nothing we
+		 can do.  */
+	      offset = f->trampoff - (roff & (bfd_vma) -4);
+	      if (offset < -0x1000000 || offset > 0x0FFFFF0)
+		continue;
+
+	      /* Nop out the reloc, since we're finalizing things here.  */
+	      irel->r_info = ELF64_R_INFO (0, R_IA64_NONE);
+	    }
+
+	  /* Fix up the existing branch to hit the trampoline.  */
+	  if (ia64_elf_install_value (contents + roff, offset, r_type)
+	      != bfd_reloc_ok)
+	    goto error_return;
+
+	  changed_contents = TRUE;
+	  changed_relocs = TRUE;
+	}
+      else
+	{
+	  /* Fetch the gp.  */
+	  if (gp == 0)
+	    {
+	      bfd *obfd = sec->output_section->owner;
+	      gp = _bfd_get_gp_value (obfd);
+	      if (gp == 0)
+		{
+		  if (!elf64_ia64_choose_gp (obfd, link_info, FALSE))
+		    goto error_return;
+		  gp = _bfd_get_gp_value (obfd);
+		}
+	    }
+
+	  /* If the data is out of range, do nothing.  */
+	  if ((bfd_signed_vma) (symaddr - gp) >= 0x200000
+	      ||(bfd_signed_vma) (symaddr - gp) < -0x200000)
+	    continue;
+
+	  if (r_type == R_IA64_GPREL22)
+	    elf64_ia64_update_short_info (tsec->output_section,
+					  tsec->output_offset + toff,
+					  ia64_info);
+	  else if (r_type == R_IA64_LTOFF22X)
+	    {
+              /* Can't deal yet correctly with ABS symbols.  */
+              if (bfd_is_abs_section (tsec))
+                continue;
+
+	      irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
+					   R_IA64_GPREL22);
+	      changed_relocs = TRUE;
+
+	      elf64_ia64_update_short_info (tsec->output_section,
+					    tsec->output_offset + toff,
+					    ia64_info);
+	    }
+	  else
+	    {
+	      ia64_elf_relax_ldxmov (contents, roff);
+	      irel->r_info = ELF64_R_INFO (0, R_IA64_NONE);
+	      changed_contents = TRUE;
+	      changed_relocs = TRUE;
+	    }
+	}
+    }
+
+  /* ??? If we created fixups, this may push the code segment large
+     enough that the data segment moves, which will change the GP.
+     Reset the GP so that we re-calculate next round.  We need to
+     do this at the _beginning_ of the next round; now will not do.  */
+
+  /* Clean up and go home.  */
+  while (fixups)
+    {
+      struct one_fixup *f = fixups;
+      fixups = fixups->next;
+      free (f);
+    }
+
+  if (isymbuf != NULL
+      && symtab_hdr->contents != (unsigned char *) isymbuf)
+    {
+      if (! link_info->keep_memory)
+	free (isymbuf);
+      else
+	{
+	  /* Cache the symbols for elf_link_input_bfd.  */
+	  symtab_hdr->contents = (unsigned char *) isymbuf;
+	}
+    }
+
+  if (contents != NULL
+      && elf_section_data (sec)->this_hdr.contents != contents)
+    {
+      if (!changed_contents && !link_info->keep_memory)
+	free (contents);
+      else
+	{
+	  /* Cache the section contents for elf_link_input_bfd.  */
+	  elf_section_data (sec)->this_hdr.contents = contents;
+	}
+    }
+
+  if (elf_section_data (sec)->relocs != internal_relocs)
+    {
+      if (!changed_relocs)
+	free (internal_relocs);
+      else
+	elf_section_data (sec)->relocs = internal_relocs;
+    }
+
+  if (link_info->relax_pass == 0)
+    {
+      /* Pass 0 is only needed to relax br.  */
+      sec->skip_relax_pass_0 = skip_relax_pass_0;
+      sec->skip_relax_pass_1 = skip_relax_pass_1;
+    }
+
+  *again = changed_contents || changed_relocs;
+  return TRUE;
+
+ error_return:
+  if (isymbuf != NULL && (unsigned char *) isymbuf != symtab_hdr->contents)
+    free (isymbuf);
+  if (contents != NULL
+      && elf_section_data (sec)->this_hdr.contents != contents)
+    free (contents);
+  if (internal_relocs != NULL
+      && elf_section_data (sec)->relocs != internal_relocs)
+    free (internal_relocs);
+  return FALSE;
+}
+#undef skip_relax_pass_0
+#undef skip_relax_pass_1
+
+/* Return TRUE if NAME is an unwind table section name.  */
+
+static inline bfd_boolean
+is_unwind_section_name (bfd *abfd ATTRIBUTE_UNUSED, const char *name)
+{
+  return ((CONST_STRNEQ (name, ELF_STRING_ia64_unwind)
+	   && ! CONST_STRNEQ (name, ELF_STRING_ia64_unwind_info))
+	  || CONST_STRNEQ (name, ELF_STRING_ia64_unwind_once));
+}
+
+
+/* Convert IA-64 specific section flags to bfd internal section flags.  */
+
+/* ??? There is no bfd internal flag equivalent to the SHF_IA_64_NORECOV
+   flag.  */
+
+static bfd_boolean
+elf64_ia64_section_flags (flagword *flags,
+			  const Elf_Internal_Shdr *hdr)
+{
+  if (hdr->sh_flags & SHF_IA_64_SHORT)
+    *flags |= SEC_SMALL_DATA;
+
+  return TRUE;
+}
+
+/* Set the correct type for an IA-64 ELF section.  We do this by the
+   section name, which is a hack, but ought to work.  */
+
+static bfd_boolean
+elf64_ia64_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr,
+			  asection *sec)
+{
+  const char *name;
+
+  name = bfd_get_section_name (abfd, sec);
+
+  if (is_unwind_section_name (abfd, name))
+    {
+      /* We don't have the sections numbered at this point, so sh_info
+	 is set later, in elf64_ia64_final_write_processing.  */
+      hdr->sh_type = SHT_IA_64_UNWIND;
+      hdr->sh_flags |= SHF_LINK_ORDER;
+    }
+  else if (strcmp (name, ELF_STRING_ia64_archext) == 0)
+    hdr->sh_type = SHT_IA_64_EXT;
+
+  if (sec->flags & SEC_SMALL_DATA)
+    hdr->sh_flags |= SHF_IA_64_SHORT;
+
+  return TRUE;
+}
+
+/* Hook called by the linker routine which adds symbols from an object
+   file.  We use it to put .comm items in .sbss, and not .bss.  */
+
+static bfd_boolean
+elf64_ia64_add_symbol_hook (bfd *abfd,
+			    struct bfd_link_info *info,
+			    Elf_Internal_Sym *sym,
+			    const char **namep ATTRIBUTE_UNUSED,
+			    flagword *flagsp ATTRIBUTE_UNUSED,
+			    asection **secp,
+			    bfd_vma *valp)
+{
+  if (sym->st_shndx == SHN_COMMON
+      && !info->relocatable
+      && sym->st_size <= elf_gp_size (abfd))
+    {
+      /* Common symbols less than or equal to -G nn bytes are
+	 automatically put into .sbss.  */
+
+      asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
+
+      if (scomm == NULL)
+	{
+	  scomm = bfd_make_section_with_flags (abfd, ".scommon",
+					       (SEC_ALLOC
+						| SEC_IS_COMMON
+						| SEC_LINKER_CREATED));
+	  if (scomm == NULL)
+	    return FALSE;
+	}
+
+      *secp = scomm;
+      *valp = sym->st_size;
+    }
+
+  return TRUE;
+}
+
+/* According to the Tahoe assembler spec, all labels starting with a
+   '.' are local.  */
+
+static bfd_boolean
+elf64_ia64_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
+				const char *name)
+{
+  return name[0] == '.';
+}
+
+/* Should we do dynamic things to this symbol?  */
+
+static bfd_boolean
+elf64_ia64_dynamic_symbol_p (struct elf_link_hash_entry *h)
+{
+  return h != NULL && h->def_dynamic;
+}
+
+static struct bfd_hash_entry*
+elf64_ia64_new_elf_hash_entry (struct bfd_hash_entry *entry,
+			       struct bfd_hash_table *table,
+			       const char *string)
+{
+  struct elf64_ia64_link_hash_entry *ret;
+  ret = (struct elf64_ia64_link_hash_entry *) entry;
+
+  /* Allocate the structure if it has not already been allocated by a
+     subclass.  */
+  if (!ret)
+    ret = bfd_hash_allocate (table, sizeof (*ret));
+
+  if (!ret)
+    return 0;
+
+  /* Call the allocation method of the superclass.  */
+  ret = ((struct elf64_ia64_link_hash_entry *)
+	 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
+				     table, string));
+
+  ret->info = NULL;
+  ret->count = 0;
+  ret->sorted_count = 0;
+  ret->size = 0;
+  return (struct bfd_hash_entry *) ret;
+}
+
+static void
+elf64_ia64_hash_hide_symbol (struct bfd_link_info *info,
+			     struct elf_link_hash_entry *xh,
+			     bfd_boolean force_local)
+{
+  struct elf64_ia64_link_hash_entry *h;
+  struct elf64_ia64_dyn_sym_info *dyn_i;
+  unsigned int count;
+
+  h = (struct elf64_ia64_link_hash_entry *)xh;
+
+  _bfd_elf_link_hash_hide_symbol (info, &h->root, force_local);
+
+  for (count = h->count, dyn_i = h->info;
+       count != 0;
+       count--, dyn_i++)
+    {
+      dyn_i->want_plt2 = 0;
+      dyn_i->want_plt = 0;
+    }
+}
+
+/* Compute a hash of a local hash entry.  */
+
+static hashval_t
+elf64_ia64_local_htab_hash (const void *ptr)
+{
+  struct elf64_ia64_local_hash_entry *entry
+    = (struct elf64_ia64_local_hash_entry *) ptr;
+
+  return ELF_LOCAL_SYMBOL_HASH (entry->id, entry->r_sym);
+}
+
+/* Compare local hash entries.  */
+
+static int
+elf64_ia64_local_htab_eq (const void *ptr1, const void *ptr2)
+{
+  struct elf64_ia64_local_hash_entry *entry1
+    = (struct elf64_ia64_local_hash_entry *) ptr1;
+  struct elf64_ia64_local_hash_entry *entry2
+    = (struct elf64_ia64_local_hash_entry *) ptr2;
+
+  return entry1->id == entry2->id && entry1->r_sym == entry2->r_sym;
+}
+
+/* Create the derived linker hash table.  The IA-64 ELF port uses this
+   derived hash table to keep information specific to the IA-64 ElF
+   linker (without using static variables).  */
+
+static struct bfd_link_hash_table *
+elf64_ia64_hash_table_create (bfd *abfd)
+{
+  struct elf64_ia64_link_hash_table *ret;
+
+  ret = bfd_zmalloc ((bfd_size_type) sizeof (*ret));
+  if (!ret)
+    return NULL;
+
+  if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
+				      elf64_ia64_new_elf_hash_entry,
+				      sizeof (struct elf64_ia64_link_hash_entry),
+				      IA64_ELF_DATA))
+    {
+      free (ret);
+      return NULL;
+    }
+
+  ret->loc_hash_table = htab_try_create (1024, elf64_ia64_local_htab_hash,
+					 elf64_ia64_local_htab_eq, NULL);
+  ret->loc_hash_memory = objalloc_create ();
+  if (!ret->loc_hash_table || !ret->loc_hash_memory)
+    {
+      free (ret);
+      return NULL;
+    }
+
+  return &ret->root.root;
+}
+
+/* Free the global elf64_ia64_dyn_sym_info array.  */
+
+static bfd_boolean
+elf64_ia64_global_dyn_info_free (void **xentry,
+				 void * unused ATTRIBUTE_UNUSED)
+{
+  struct elf64_ia64_link_hash_entry *entry
+    = (struct elf64_ia64_link_hash_entry *) xentry;
+
+  if (entry->root.root.type == bfd_link_hash_warning)
+    entry = (struct elf64_ia64_link_hash_entry *) entry->root.root.u.i.link;
+
+  if (entry->info)
+    {
+      free (entry->info);
+      entry->info = NULL;
+      entry->count = 0;
+      entry->sorted_count = 0;
+      entry->size = 0;
+    }
+
+  return TRUE;
+}
+
+/* Free the local elf64_ia64_dyn_sym_info array.  */
+
+static bfd_boolean
+elf64_ia64_local_dyn_info_free (void **slot,
+				void * unused ATTRIBUTE_UNUSED)
+{
+  struct elf64_ia64_local_hash_entry *entry
+    = (struct elf64_ia64_local_hash_entry *) *slot;
+
+  if (entry->info)
+    {
+      free (entry->info);
+      entry->info = NULL;
+      entry->count = 0;
+      entry->sorted_count = 0;
+      entry->size = 0;
+    }
+
+  return TRUE;
+}
+
+/* Destroy IA-64 linker hash table.  */
+
+static void
+elf64_ia64_hash_table_free (struct bfd_link_hash_table *hash)
+{
+  struct elf64_ia64_link_hash_table *ia64_info
+    = (struct elf64_ia64_link_hash_table *) hash;
+  if (ia64_info->loc_hash_table)
+    {
+      htab_traverse (ia64_info->loc_hash_table,
+		     elf64_ia64_local_dyn_info_free, NULL);
+      htab_delete (ia64_info->loc_hash_table);
+    }
+  if (ia64_info->loc_hash_memory)
+    objalloc_free ((struct objalloc *) ia64_info->loc_hash_memory);
+  elf_link_hash_traverse (&ia64_info->root,
+			  elf64_ia64_global_dyn_info_free, NULL);
+  _bfd_generic_link_hash_table_free (hash);
+}
+
+/* Traverse both local and global hash tables.  */
+
+struct elf64_ia64_dyn_sym_traverse_data
+{
+  bfd_boolean (*func) (struct elf64_ia64_dyn_sym_info *, void *);
+  void * data;
+};
+
+static bfd_boolean
+elf64_ia64_global_dyn_sym_thunk (struct bfd_hash_entry *xentry,
+				 void * xdata)
+{
+  struct elf64_ia64_link_hash_entry *entry
+    = (struct elf64_ia64_link_hash_entry *) xentry;
+  struct elf64_ia64_dyn_sym_traverse_data *data
+    = (struct elf64_ia64_dyn_sym_traverse_data *) xdata;
+  struct elf64_ia64_dyn_sym_info *dyn_i;
+  unsigned int count;
+
+  if (entry->root.root.type == bfd_link_hash_warning)
+    entry = (struct elf64_ia64_link_hash_entry *) entry->root.root.u.i.link;
+
+  for (count = entry->count, dyn_i = entry->info;
+       count != 0;
+       count--, dyn_i++)
+    if (! (*data->func) (dyn_i, data->data))
+      return FALSE;
+  return TRUE;
+}
+
+static bfd_boolean
+elf64_ia64_local_dyn_sym_thunk (void **slot, void * xdata)
+{
+  struct elf64_ia64_local_hash_entry *entry
+    = (struct elf64_ia64_local_hash_entry *) *slot;
+  struct elf64_ia64_dyn_sym_traverse_data *data
+    = (struct elf64_ia64_dyn_sym_traverse_data *) xdata;
+  struct elf64_ia64_dyn_sym_info *dyn_i;
+  unsigned int count;
+
+  for (count = entry->count, dyn_i = entry->info;
+       count != 0;
+       count--, dyn_i++)
+    if (! (*data->func) (dyn_i, data->data))
+      return FALSE;
+  return TRUE;
+}
+
+static void
+elf64_ia64_dyn_sym_traverse (struct elf64_ia64_link_hash_table *ia64_info,
+			     bfd_boolean (*func) (struct elf64_ia64_dyn_sym_info *, void *),
+			     void * data)
+{
+  struct elf64_ia64_dyn_sym_traverse_data xdata;
+
+  xdata.func = func;
+  xdata.data = data;
+
+  elf_link_hash_traverse (&ia64_info->root,
+			  elf64_ia64_global_dyn_sym_thunk, &xdata);
+  htab_traverse (ia64_info->loc_hash_table,
+		 elf64_ia64_local_dyn_sym_thunk, &xdata);
+}
+
+#define NOTE_NAME "IPF/VMS"
+
+static bfd_boolean
+create_ia64_vms_notes (bfd *abfd, struct bfd_link_info *info,
+                       unsigned int time_hi, unsigned int time_lo)
+{
+#define NBR_NOTES 7
+  Elf_Internal_Note notes[NBR_NOTES];
+  char *module_name;
+  int module_name_len;
+  unsigned char cur_time[8];
+  Elf64_External_VMS_ORIG_DYN_Note *orig_dyn;
+  unsigned int orig_dyn_size;
+  unsigned int note_size;
+  int i;
+  unsigned char *noteptr;
+  unsigned char *note_contents;
+  struct elf64_ia64_link_hash_table *ia64_info;
+
+  ia64_info = elf64_ia64_hash_table (info);
+
+  module_name = vms_get_module_name (bfd_get_filename (abfd), TRUE);
+  module_name_len = strlen (module_name) + 1;
+
+  bfd_putl32 (time_lo, cur_time + 0);
+  bfd_putl32 (time_hi, cur_time + 4);
+
+  /* Note 0: IMGNAM.  */
+  notes[0].type = NT_VMS_IMGNAM;
+  notes[0].descdata = module_name;
+  notes[0].descsz = module_name_len;
+
+  /* Note 1: GSTNAM.  */
+  notes[1].type = NT_VMS_GSTNAM;
+  notes[1].descdata = module_name;
+  notes[1].descsz = module_name_len;
+
+  /* Note 2: IMGID.  */
+#define IMG_ID "V1.0"
+  notes[2].type = NT_VMS_IMGID;
+  notes[2].descdata = IMG_ID;
+  notes[2].descsz = sizeof (IMG_ID);
+
+  /* Note 3: Linktime.  */
+  notes[3].type = NT_VMS_LINKTIME;
+  notes[3].descdata = (char *)cur_time;
+  notes[3].descsz = sizeof (cur_time);
+
+  /* Note 4: Linker id.  */
+  notes[4].type = NT_VMS_LINKID;
+  notes[4].descdata = "GNU ld " BFD_VERSION_STRING;
+  notes[4].descsz = strlen (notes[4].descdata) + 1;
+
+  /* Note 5: Original dyn.  */
+  orig_dyn_size = (sizeof (*orig_dyn) + sizeof (IMG_ID) - 1 + 7) & ~7;
+  orig_dyn = bfd_zalloc (abfd, orig_dyn_size);
+  if (orig_dyn == NULL)
+    return FALSE;
+  bfd_putl32 (1, orig_dyn->major_id);
+  bfd_putl32 (3, orig_dyn->minor_id);
+  memcpy (orig_dyn->manipulation_date, cur_time, sizeof (cur_time));
+  bfd_putl64 (VMS_LF_IMGSTA | VMS_LF_MAIN, orig_dyn->link_flags);
+  bfd_putl32 (EF_IA_64_ABI64, orig_dyn->elf_flags);
+  memcpy (orig_dyn->imgid, IMG_ID, sizeof (IMG_ID));
+  notes[5].type = NT_VMS_ORIG_DYN;
+  notes[5].descdata = (char *)orig_dyn;
+  notes[5].descsz = orig_dyn_size;
+
+  /* Note 3: Patchtime.  */
+  notes[6].type = NT_VMS_PATCHTIME;
+  notes[6].descdata = (char *)cur_time;
+  notes[6].descsz = sizeof (cur_time);
+
+  /* Compute notes size.  */
+  note_size = 0;
+  for (i = 0; i < NBR_NOTES; i++)
+    note_size += sizeof (Elf64_External_VMS_Note) - 1
+      + ((sizeof (NOTE_NAME) - 1 + 7) & ~7)
+      + ((notes[i].descsz + 7) & ~7);
+
+  /* Malloc a temporary buffer large enough for most notes */
+  note_contents = (unsigned char *) bfd_zalloc (abfd, note_size);
+  if (note_contents == NULL)
+    return FALSE;
+  noteptr = note_contents;
+
+  /* Fill notes.  */
+  for (i = 0; i < NBR_NOTES; i++)
+    {
+      Elf64_External_VMS_Note *enote = (Elf64_External_VMS_Note *) noteptr;
+
+      bfd_putl64 (sizeof (NOTE_NAME) - 1, enote->namesz);
+      bfd_putl64 (notes[i].descsz, enote->descsz);
+      bfd_putl64 (notes[i].type, enote->type);
+
+      noteptr = (unsigned char *)enote->name;
+      memcpy (noteptr, NOTE_NAME, sizeof (NOTE_NAME) - 1);
+      noteptr += (sizeof (NOTE_NAME) - 1 + 7) & ~7;
+      memcpy (noteptr, notes[i].descdata, notes[i].descsz);
+      noteptr += (notes[i].descsz + 7) & ~7;
+    }
+
+  ia64_info->note_sec->contents = note_contents;
+  ia64_info->note_sec->size = note_size;
+
+  free (module_name);
+
+  return TRUE;
+}
+
+static bfd_boolean
+elf64_ia64_create_dynamic_sections (bfd *abfd,
+				    struct bfd_link_info *info)
+{
+  struct elf64_ia64_link_hash_table *ia64_info;
+  asection *s;
+  flagword flags;
+  const struct elf_backend_data *bed;
+
+  ia64_info = elf64_ia64_hash_table (info);
+  if (ia64_info == NULL)
+    return FALSE;
+
+  if (elf_hash_table (info)->dynamic_sections_created)
+    return TRUE;
+
+  abfd = elf_hash_table (info)->dynobj;
+  bed = get_elf_backend_data (abfd);
+
+  flags = bed->dynamic_sec_flags;
+
+  s = bfd_make_section_with_flags (abfd, ".dynamic", flags | SEC_READONLY);
+  if (s == NULL
+      || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
+    return FALSE;
+
+  s = bfd_make_section_with_flags (abfd, ".plt", flags | SEC_READONLY);
+  if (s == NULL
+      || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
+    return FALSE;
+  ia64_info->root.splt = s;
+
+  if (!get_got (abfd, ia64_info))
+    return FALSE;
+
+  if (!get_pltoff (abfd, ia64_info))
+    return FALSE;
+
+  s = bfd_make_section_with_flags (abfd, ".vmsdynstr",
+				   (SEC_ALLOC
+				    | SEC_HAS_CONTENTS
+				    | SEC_IN_MEMORY
+				    | SEC_LINKER_CREATED));
+  if (s == NULL
+      || !bfd_set_section_alignment (abfd, s, 0))
+    return FALSE;
+
+  /* Create a fixup section.  */
+  s = bfd_make_section_with_flags (abfd, ".fixups",
+                                   (SEC_ALLOC
+                                    | SEC_HAS_CONTENTS
+                                    | SEC_IN_MEMORY
+                                    | SEC_LINKER_CREATED));
+  if (s == NULL
+      || !bfd_set_section_alignment (abfd, s, 3))
+    return FALSE;
+  ia64_info->fixups_sec = s;
+
+  /* Create the transfer fixup section.  */
+  s = bfd_make_section_with_flags (abfd, ".transfer",
+                                   (SEC_ALLOC
+                                    | SEC_HAS_CONTENTS
+                                    | SEC_IN_MEMORY
+                                    | SEC_LINKER_CREATED));
+  if (s == NULL
+      || !bfd_set_section_alignment (abfd, s, 3))
+    return FALSE;
+  s->size = sizeof (struct elf64_vms_transfer);
+  ia64_info->transfer_sec = s;
+
+  /* Create note section.  */
+  s = bfd_make_section_anyway_with_flags (abfd, ".vms.note",
+                                          (SEC_LINKER_CREATED
+                                           | SEC_HAS_CONTENTS
+                                           | SEC_IN_MEMORY
+                                           | SEC_READONLY));
+  if (s == NULL
+      || !bfd_set_section_alignment (abfd, s, 3))
+    return FALSE;
+  ia64_info->note_sec = s;
+
+  elf_hash_table (info)->dynamic_sections_created = TRUE;
+  return TRUE;
+}
+
+/* Find and/or create a hash entry for local symbol.  */
+static struct elf64_ia64_local_hash_entry *
+get_local_sym_hash (struct elf64_ia64_link_hash_table *ia64_info,
+		    bfd *abfd, const Elf_Internal_Rela *rel,
+		    bfd_boolean create)
+{
+  struct elf64_ia64_local_hash_entry e, *ret;
+  asection *sec = abfd->sections;
+  hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
+				       ELF64_R_SYM (rel->r_info));
+  void **slot;
+
+  e.id = sec->id;
+  e.r_sym = ELF64_R_SYM (rel->r_info);
+  slot = htab_find_slot_with_hash (ia64_info->loc_hash_table, &e, h,
+				   create ? INSERT : NO_INSERT);
+
+  if (!slot)
+    return NULL;
+
+  if (*slot)
+    return (struct elf64_ia64_local_hash_entry *) *slot;
+
+  ret = (struct elf64_ia64_local_hash_entry *)
+	objalloc_alloc ((struct objalloc *) ia64_info->loc_hash_memory,
+			sizeof (struct elf64_ia64_local_hash_entry));
+  if (ret)
+    {
+      memset (ret, 0, sizeof (*ret));
+      ret->id = sec->id;
+      ret->r_sym = ELF64_R_SYM (rel->r_info);
+      *slot = ret;
+    }
+  return ret;
+}
+
+/* Used to sort elf64_ia64_dyn_sym_info array.  */
+
+static int
+addend_compare (const void *xp, const void *yp)
+{
+  const struct elf64_ia64_dyn_sym_info *x
+    = (const struct elf64_ia64_dyn_sym_info *) xp;
+  const struct elf64_ia64_dyn_sym_info *y
+    = (const struct elf64_ia64_dyn_sym_info *) yp;
+
+  return x->addend < y->addend ? -1 : x->addend > y->addend ? 1 : 0;
+}
+
+/* Sort elf64_ia64_dyn_sym_info array and remove duplicates.  */
+
+static unsigned int
+sort_dyn_sym_info (struct elf64_ia64_dyn_sym_info *info,
+		   unsigned int count)
+{
+  bfd_vma curr, prev, got_offset;
+  unsigned int i, kept, dupes, diff, dest, src, len;
+
+  qsort (info, count, sizeof (*info), addend_compare);
+
+  /* Find the first duplicate.  */
+  prev = info [0].addend;
+  got_offset = info [0].got_offset;
+  for (i = 1; i < count; i++)
+    {
+      curr = info [i].addend;
+      if (curr == prev)
+	{
+	  /* For duplicates, make sure that GOT_OFFSET is valid.  */
+	  if (got_offset == (bfd_vma) -1)
+	    got_offset = info [i].got_offset;
+	  break;
+	}
+      got_offset = info [i].got_offset;
+      prev = curr;
+    }
+
+  /* We may move a block of elements to here.  */
+  dest = i++;
+
+  /* Remove duplicates.  */
+  if (i < count)
+    {
+      while (i < count)
+	{
+	  /* For duplicates, make sure that the kept one has a valid
+	     got_offset.  */
+	  kept = dest - 1;
+	  if (got_offset != (bfd_vma) -1)
+	    info [kept].got_offset = got_offset;
+
+	  curr = info [i].addend;
+	  got_offset = info [i].got_offset;
+
+	  /* Move a block of elements whose first one is different from
+	     the previous.  */
+	  if (curr == prev)
+	    {
+	      for (src = i + 1; src < count; src++)
+		{
+		  if (info [src].addend != curr)
+		    break;
+		  /* For duplicates, make sure that GOT_OFFSET is
+		     valid.  */
+		  if (got_offset == (bfd_vma) -1)
+		    got_offset = info [src].got_offset;
+		}
+
+	      /* Make sure that the kept one has a valid got_offset.  */
+	      if (got_offset != (bfd_vma) -1)
+		info [kept].got_offset = got_offset;
+	    }
+	  else
+	    src = i;
+
+	  if (src >= count)
+	    break;
+
+	  /* Find the next duplicate.  SRC will be kept.  */
+	  prev = info [src].addend;
+	  got_offset = info [src].got_offset;
+	  for (dupes = src + 1; dupes < count; dupes ++)
+	    {
+	      curr = info [dupes].addend;
+	      if (curr == prev)
+		{
+		  /* Make sure that got_offset is valid.  */
+		  if (got_offset == (bfd_vma) -1)
+		    got_offset = info [dupes].got_offset;
+
+		  /* For duplicates, make sure that the kept one has
+		     a valid got_offset.  */
+		  if (got_offset != (bfd_vma) -1)
+		    info [dupes - 1].got_offset = got_offset;
+		  break;
+		}
+	      got_offset = info [dupes].got_offset;
+	      prev = curr;
+	    }
+
+	  /* How much to move.  */
+	  len = dupes - src;
+	  i = dupes + 1;
+
+	  if (len == 1 && dupes < count)
+	    {
+	      /* If we only move 1 element, we combine it with the next
+		 one.  There must be at least a duplicate.  Find the
+		 next different one.  */
+	      for (diff = dupes + 1, src++; diff < count; diff++, src++)
+		{
+		  if (info [diff].addend != curr)
+		    break;
+		  /* Make sure that got_offset is valid.  */
+		  if (got_offset == (bfd_vma) -1)
+		    got_offset = info [diff].got_offset;
+		}
+
+	      /* Makre sure that the last duplicated one has an valid
+		 offset.  */
+	      BFD_ASSERT (curr == prev);
+	      if (got_offset != (bfd_vma) -1)
+		info [diff - 1].got_offset = got_offset;
+
+	      if (diff < count)
+		{
+		  /* Find the next duplicate.  Track the current valid
+		     offset.  */
+		  prev = info [diff].addend;
+		  got_offset = info [diff].got_offset;
+		  for (dupes = diff + 1; dupes < count; dupes ++)
+		    {
+		      curr = info [dupes].addend;
+		      if (curr == prev)
+			{
+			  /* For duplicates, make sure that GOT_OFFSET
+			     is valid.  */
+			  if (got_offset == (bfd_vma) -1)
+			    got_offset = info [dupes].got_offset;
+			  break;
+			}
+		      got_offset = info [dupes].got_offset;
+		      prev = curr;
+		      diff++;
+		    }
+
+		  len = diff - src + 1;
+		  i = diff + 1;
+		}
+	    }
+
+	  memmove (&info [dest], &info [src], len * sizeof (*info));
+
+	  dest += len;
+	}
+
+      count = dest;
+    }
+  else
+    {
+      /* When we get here, either there is no duplicate at all or
+	 the only duplicate is the last element.  */
+      if (dest < count)
+	{
+	  /* If the last element is a duplicate, make sure that the
+	     kept one has a valid got_offset.  We also update count.  */
+	  if (got_offset != (bfd_vma) -1)
+	    info [dest - 1].got_offset = got_offset;
+	  count = dest;
+	}
+    }
+
+  return count;
+}
+
+/* Find and/or create a descriptor for dynamic symbol info.  This will
+   vary based on global or local symbol, and the addend to the reloc.
+
+   We don't sort when inserting.  Also, we sort and eliminate
+   duplicates if there is an unsorted section.  Typically, this will
+   only happen once, because we do all insertions before lookups.  We
+   then use bsearch to do a lookup.  This also allows lookups to be
+   fast.  So we have fast insertion (O(log N) due to duplicate check),
+   fast lookup (O(log N)) and one sort (O(N log N) expected time).
+   Previously, all lookups were O(N) because of the use of the linked
+   list and also all insertions were O(N) because of the check for
+   duplicates.  There are some complications here because the array
+   size grows occasionally, which may add an O(N) factor, but this
+   should be rare.  Also,  we free the excess array allocation, which
+   requires a copy which is O(N), but this only happens once.  */
+
+static struct elf64_ia64_dyn_sym_info *
+get_dyn_sym_info (struct elf64_ia64_link_hash_table *ia64_info,
+		  struct elf_link_hash_entry *h, bfd *abfd,
+		  const Elf_Internal_Rela *rel, bfd_boolean create)
+{
+  struct elf64_ia64_dyn_sym_info **info_p, *info, *dyn_i, key;
+  unsigned int *count_p, *sorted_count_p, *size_p;
+  unsigned int count, sorted_count, size;
+  bfd_vma addend = rel ? rel->r_addend : 0;
+  bfd_size_type amt;
+
+  if (h)
+    {
+      struct elf64_ia64_link_hash_entry *global_h;
+
+      global_h = (struct elf64_ia64_link_hash_entry *) h;
+      info_p = &global_h->info;
+      count_p = &global_h->count;
+      sorted_count_p = &global_h->sorted_count;
+      size_p = &global_h->size;
+    }
+  else
+    {
+      struct elf64_ia64_local_hash_entry *loc_h;
+
+      loc_h = get_local_sym_hash (ia64_info, abfd, rel, create);
+      if (!loc_h)
+	{
+	  BFD_ASSERT (!create);
+	  return NULL;
+	}
+
+      info_p = &loc_h->info;
+      count_p = &loc_h->count;
+      sorted_count_p = &loc_h->sorted_count;
+      size_p = &loc_h->size;
+    }
+
+  count = *count_p;
+  sorted_count = *sorted_count_p;
+  size = *size_p;
+  info = *info_p;
+  if (create)
+    {
+      /* When we create the array, we don't check for duplicates,
+         except in the previously sorted section if one exists, and
+	 against the last inserted entry.  This allows insertions to
+	 be fast.  */
+      if (info)
+	{
+	  if (sorted_count)
+	    {
+	      /* Try bsearch first on the sorted section.  */
+	      key.addend = addend;
+	      dyn_i = bsearch (&key, info, sorted_count,
+			       sizeof (*info), addend_compare);
+
+	      if (dyn_i)
+		{
+		  return dyn_i;
+		}
+	    }
+
+	  /* Do a quick check for the last inserted entry.  */
+	  dyn_i = info + count - 1;
+	  if (dyn_i->addend == addend)
+	    {
+	      return dyn_i;
+	    }
+	}
+
+      if (size == 0)
+	{
+	  /* It is the very first element. We create the array of size
+	     1.  */
+	  size = 1;
+	  amt = size * sizeof (*info);
+	  info = bfd_malloc (amt);
+	}
+      else if (size <= count)
+	{
+	  /* We double the array size every time when we reach the
+	     size limit.  */
+	  size += size;
+	  amt = size * sizeof (*info);
+	  info = bfd_realloc (info, amt);
+	}
+      else
+	goto has_space;
+
+      if (info == NULL)
+	return NULL;
+      *size_p = size;
+      *info_p = info;
+
+has_space:
+      /* Append the new one to the array.  */
+      dyn_i = info + count;
+      memset (dyn_i, 0, sizeof (*dyn_i));
+      dyn_i->got_offset = (bfd_vma) -1;
+      dyn_i->addend = addend;
+
+      /* We increment count only since the new ones are unsorted and
+	 may have duplicate.  */
+      (*count_p)++;
+    }
+  else
+    {
+      /* It is a lookup without insertion.  Sort array if part of the
+	 array isn't sorted.  */
+      if (count != sorted_count)
+	{
+	  count = sort_dyn_sym_info (info, count);
+	  *count_p = count;
+	  *sorted_count_p = count;
+	}
+
+      /* Free unused memory.  */
+      if (size != count)
+	{
+	  amt = count * sizeof (*info);
+	  info = bfd_malloc (amt);
+	  if (info != NULL)
+	    {
+	      memcpy (info, *info_p, amt);
+	      free (*info_p);
+	      *size_p = count;
+	      *info_p = info;
+	    }
+	}
+
+      key.addend = addend;
+      dyn_i = bsearch (&key, info, count,
+		       sizeof (*info), addend_compare);
+    }
+
+  return dyn_i;
+}
+
+static asection *
+get_got (bfd *abfd, struct elf64_ia64_link_hash_table *ia64_info)
+{
+  asection *got;
+  bfd *dynobj;
+
+  got = ia64_info->root.sgot;
+  if (!got)
+    {
+      flagword flags;
+
+      dynobj = ia64_info->root.dynobj;
+      if (!dynobj)
+	ia64_info->root.dynobj = dynobj = abfd;
+
+      /* The .got section is always aligned at 8 bytes.  */
+      flags = get_elf_backend_data (dynobj)->dynamic_sec_flags;
+      got = bfd_make_section_with_flags (dynobj, ".got", flags | SEC_SMALL_DATA);
+      if (got == NULL
+          || !bfd_set_section_alignment (dynobj, got, 3))
+        return NULL;
+      ia64_info->root.sgot = got;
+    }
+
+  return got;
+}
+
+/* Create function descriptor section (.opd).  This section is called .opd
+   because it contains "official procedure descriptors".  The "official"
+   refers to the fact that these descriptors are used when taking the address
+   of a procedure, thus ensuring a unique address for each procedure.  */
+
+static asection *
+get_fptr (bfd *abfd, struct bfd_link_info *info,
+	  struct elf64_ia64_link_hash_table *ia64_info)
+{
+  asection *fptr;
+  bfd *dynobj;
+
+  fptr = ia64_info->fptr_sec;
+  if (!fptr)
+    {
+      dynobj = ia64_info->root.dynobj;
+      if (!dynobj)
+	ia64_info->root.dynobj = dynobj = abfd;
+
+      fptr = bfd_make_section_with_flags (dynobj, ".opd",
+					  (SEC_ALLOC
+					   | SEC_LOAD
+					   | SEC_HAS_CONTENTS
+					   | SEC_IN_MEMORY
+					   | (info->pie ? 0 : SEC_READONLY)
+					   | SEC_LINKER_CREATED));
+      if (!fptr
+	  || !bfd_set_section_alignment (dynobj, fptr, 4))
+	{
+	  BFD_ASSERT (0);
+	  return NULL;
+	}
+
+      ia64_info->fptr_sec = fptr;
+
+      if (info->pie)
+	{
+	  asection *fptr_rel;
+	  fptr_rel = bfd_make_section_with_flags (dynobj, ".rela.opd",
+						  (SEC_ALLOC | SEC_LOAD
+						   | SEC_HAS_CONTENTS
+						   | SEC_IN_MEMORY
+						   | SEC_LINKER_CREATED
+						   | SEC_READONLY));
+	  if (fptr_rel == NULL
+	      || !bfd_set_section_alignment (dynobj, fptr_rel, 3))
+	    {
+	      BFD_ASSERT (0);
+	      return NULL;
+	    }
+
+	  ia64_info->rel_fptr_sec = fptr_rel;
+	}
+    }
+
+  return fptr;
+}
+
+static asection *
+get_pltoff (bfd *abfd, struct elf64_ia64_link_hash_table *ia64_info)
+{
+  asection *pltoff;
+  bfd *dynobj;
+
+  pltoff = ia64_info->pltoff_sec;
+  if (!pltoff)
+    {
+      dynobj = ia64_info->root.dynobj;
+      if (!dynobj)
+	ia64_info->root.dynobj = dynobj = abfd;
+
+      pltoff = bfd_make_section_with_flags (dynobj,
+					    ELF_STRING_ia64_pltoff,
+					    (SEC_ALLOC
+					     | SEC_LOAD
+					     | SEC_HAS_CONTENTS
+					     | SEC_IN_MEMORY
+					     | SEC_SMALL_DATA
+					     | SEC_LINKER_CREATED));
+      if (!pltoff
+	  || !bfd_set_section_alignment (dynobj, pltoff, 4))
+	{
+	  BFD_ASSERT (0);
+	  return NULL;
+	}
+
+      ia64_info->pltoff_sec = pltoff;
+    }
+
+  return pltoff;
+}
+
+static asection *
+get_reloc_section (bfd *abfd,
+		   struct elf64_ia64_link_hash_table *ia64_info,
+		   asection *sec, bfd_boolean create)
+{
+  const char *srel_name;
+  asection *srel;
+  bfd *dynobj;
+
+  srel_name = (bfd_elf_string_from_elf_section
+	       (abfd, elf_elfheader(abfd)->e_shstrndx,
+		_bfd_elf_single_rel_hdr (sec)->sh_name));
+  if (srel_name == NULL)
+    return NULL;
+
+  BFD_ASSERT ((CONST_STRNEQ (srel_name, ".rela")
+	       && strcmp (bfd_get_section_name (abfd, sec),
+			  srel_name+5) == 0)
+	      || (CONST_STRNEQ (srel_name, ".rel")
+		  && strcmp (bfd_get_section_name (abfd, sec),
+			     srel_name+4) == 0));
+
+  dynobj = ia64_info->root.dynobj;
+  if (!dynobj)
+    ia64_info->root.dynobj = dynobj = abfd;
+
+  srel = bfd_get_section_by_name (dynobj, srel_name);
+  if (srel == NULL && create)
+    {
+      srel = bfd_make_section_with_flags (dynobj, srel_name,
+					  (SEC_ALLOC | SEC_LOAD
+					   | SEC_HAS_CONTENTS
+					   | SEC_IN_MEMORY
+					   | SEC_LINKER_CREATED
+					   | SEC_READONLY));
+      if (srel == NULL
+	  || !bfd_set_section_alignment (dynobj, srel, 3))
+	return NULL;
+    }
+
+  return srel;
+}
+
+static bfd_boolean
+count_dyn_reloc (bfd *abfd, struct elf64_ia64_dyn_sym_info *dyn_i,
+		 asection *srel, int type)
+{
+  struct elf64_ia64_dyn_reloc_entry *rent;
+
+  for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
+    if (rent->srel == srel && rent->type == type)
+      break;
+
+  if (!rent)
+    {
+      rent = ((struct elf64_ia64_dyn_reloc_entry *)
+	      bfd_alloc (abfd, (bfd_size_type) sizeof (*rent)));
+      if (!rent)
+	return FALSE;
+
+      rent->next = dyn_i->reloc_entries;
+      rent->srel = srel;
+      rent->type = type;
+      rent->count = 0;
+      dyn_i->reloc_entries = rent;
+    }
+  rent->count++;
+
+  return TRUE;
+}
+
+static bfd_boolean
+elf64_ia64_check_relocs (bfd *abfd, struct bfd_link_info *info,
+			 asection *sec,
+			 const Elf_Internal_Rela *relocs)
+{
+  struct elf64_ia64_link_hash_table *ia64_info;
+  const Elf_Internal_Rela *relend;
+  Elf_Internal_Shdr *symtab_hdr;
+  const Elf_Internal_Rela *rel;
+  asection *got, *fptr, *srel, *pltoff;
+  enum {
+    NEED_GOT = 1,
+    NEED_GOTX = 2,
+    NEED_FPTR = 4,
+    NEED_PLTOFF = 8,
+    NEED_MIN_PLT = 16,
+    NEED_FULL_PLT = 32,
+    NEED_DYNREL = 64,
+    NEED_LTOFF_FPTR = 128
+  };
+  int need_entry;
+  struct elf_link_hash_entry *h;
+  unsigned long r_symndx;
+  bfd_boolean maybe_dynamic;
+
+  if (info->relocatable)
+    return TRUE;
+
+  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+  ia64_info = elf64_ia64_hash_table (info);
+  if (ia64_info == NULL)
+    return FALSE;
+
+  got = fptr = srel = pltoff = NULL;
+
+  relend = relocs + sec->reloc_count;
+
+  /* We scan relocations first to create dynamic relocation arrays.  We
+     modified get_dyn_sym_info to allow fast insertion and support fast
+     lookup in the next loop.  */
+  for (rel = relocs; rel < relend; ++rel)
+    {
+      r_symndx = ELF64_R_SYM (rel->r_info);
+      if (r_symndx >= symtab_hdr->sh_info)
+	{
+	  long indx = r_symndx - symtab_hdr->sh_info;
+	  h = elf_sym_hashes (abfd)[indx];
+	  while (h->root.type == bfd_link_hash_indirect
+		 || h->root.type == bfd_link_hash_warning)
+	    h = (struct elf_link_hash_entry *) h->root.u.i.link;
+	}
+      else
+	h = NULL;
+
+      /* 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 = (h && ((!info->executable
+			      && (!SYMBOLIC_BIND (info, h)
+				  || info->unresolved_syms_in_shared_libs == RM_IGNORE))
+			     || !h->def_regular
+			     || h->root.type == bfd_link_hash_defweak));
+
+      need_entry = 0;
+      switch (ELF64_R_TYPE (rel->r_info))
+	{
+	case R_IA64_TPREL64MSB:
+	case R_IA64_TPREL64LSB:
+	case R_IA64_LTOFF_TPREL22:
+	case R_IA64_DTPREL32MSB:
+	case R_IA64_DTPREL32LSB:
+	case R_IA64_DTPREL64MSB:
+	case R_IA64_DTPREL64LSB:
+	case R_IA64_LTOFF_DTPREL22:
+	case R_IA64_DTPMOD64MSB:
+	case R_IA64_DTPMOD64LSB:
+	case R_IA64_LTOFF_DTPMOD22:
+          abort ();
+	  break;
+
+	case R_IA64_IPLTMSB:
+	case R_IA64_IPLTLSB:
+          break;
+
+	case R_IA64_LTOFF_FPTR22:
+	case R_IA64_LTOFF_FPTR64I:
+	case R_IA64_LTOFF_FPTR32MSB:
+	case R_IA64_LTOFF_FPTR32LSB:
+	case R_IA64_LTOFF_FPTR64MSB:
+	case R_IA64_LTOFF_FPTR64LSB:
+	  need_entry = NEED_FPTR | NEED_GOT | NEED_LTOFF_FPTR;
+	  break;
+
+	case R_IA64_FPTR64I:
+	case R_IA64_FPTR32MSB:
+	case R_IA64_FPTR32LSB:
+	case R_IA64_FPTR64MSB:
+	case R_IA64_FPTR64LSB:
+	  if (info->shared || h)
+	    need_entry = NEED_FPTR | NEED_DYNREL;
+	  else
+	    need_entry = NEED_FPTR;
+	  break;
+
+	case R_IA64_LTOFF22:
+	case R_IA64_LTOFF64I:
+	  need_entry = NEED_GOT;
+	  break;
+
+	case R_IA64_LTOFF22X:
+	  need_entry = NEED_GOTX;
+	  break;
+
+	case R_IA64_PLTOFF22:
+	case R_IA64_PLTOFF64I:
+	case R_IA64_PLTOFF64MSB:
+	case R_IA64_PLTOFF64LSB:
+	  need_entry = NEED_PLTOFF;
+	  if (h)
+	    {
+	      if (maybe_dynamic)
+		need_entry |= NEED_MIN_PLT;
+	    }
+	  else
+	    {
+	      (*info->callbacks->warning)
+		(info, _("@pltoff reloc against local symbol"), 0,
+		 abfd, 0, (bfd_vma) 0);
+	    }
+	  break;
+
+	case R_IA64_PCREL21B:
+        case R_IA64_PCREL60B:
+	  /* Depending on where this symbol is defined, we may or may not
+	     need a full plt entry.  Only skip if we know we'll not need
+	     the entry -- static or symbolic, and the symbol definition
+	     has already been seen.  */
+	  if (maybe_dynamic && rel->r_addend == 0)
+	    need_entry = NEED_FULL_PLT;
+	  break;
+
+	case R_IA64_IMM14:
+	case R_IA64_IMM22:
+	case R_IA64_IMM64:
+	case R_IA64_DIR32MSB:
+	case R_IA64_DIR32LSB:
+	case R_IA64_DIR64MSB:
+	case R_IA64_DIR64LSB:
+	  /* Shared objects will always need at least a REL relocation.  */
+	  if (info->shared || maybe_dynamic)
+	    need_entry = NEED_DYNREL;
+	  break;
+
+	case R_IA64_PCREL22:
+	case R_IA64_PCREL64I:
+	case R_IA64_PCREL32MSB:
+	case R_IA64_PCREL32LSB:
+	case R_IA64_PCREL64MSB:
+	case R_IA64_PCREL64LSB:
+	  if (maybe_dynamic)
+	    need_entry = NEED_DYNREL;
+	  break;
+	}
+
+      if (!need_entry)
+	continue;
+
+      if ((need_entry & NEED_FPTR) != 0
+	  && rel->r_addend)
+	{
+	  (*info->callbacks->warning)
+	    (info, _("non-zero addend in @fptr reloc"), 0,
+	     abfd, 0, (bfd_vma) 0);
+	}
+
+      if (get_dyn_sym_info (ia64_info, h, abfd, rel, TRUE) == NULL)
+	return FALSE;
+    }
+
+  /* Now, we only do lookup without insertion, which is very fast
+     with the modified get_dyn_sym_info.  */
+  for (rel = relocs; rel < relend; ++rel)
+    {
+      struct elf64_ia64_dyn_sym_info *dyn_i;
+      int dynrel_type = R_IA64_NONE;
+
+      r_symndx = ELF64_R_SYM (rel->r_info);
+      if (r_symndx >= symtab_hdr->sh_info)
+	{
+	  /* We're dealing with a global symbol -- find its hash entry
+	     and mark it as being referenced.  */
+	  long indx = r_symndx - symtab_hdr->sh_info;
+	  h = elf_sym_hashes (abfd)[indx];
+	  while (h->root.type == bfd_link_hash_indirect
+		 || h->root.type == bfd_link_hash_warning)
+	    h = (struct elf_link_hash_entry *) h->root.u.i.link;
+
+	  h->ref_regular = 1;
+	}
+      else
+	h = NULL;
+
+      /* 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 = (h && ((!info->executable
+			      && (!SYMBOLIC_BIND (info, h)
+				  || info->unresolved_syms_in_shared_libs == RM_IGNORE))
+			     || !h->def_regular
+			     || h->root.type == bfd_link_hash_defweak));
+
+      need_entry = 0;
+      switch (ELF64_R_TYPE (rel->r_info))
+	{
+	case R_IA64_TPREL64MSB:
+	case R_IA64_TPREL64LSB:
+	case R_IA64_LTOFF_TPREL22:
+	case R_IA64_DTPREL32MSB:
+	case R_IA64_DTPREL32LSB:
+	case R_IA64_DTPREL64MSB:
+	case R_IA64_DTPREL64LSB:
+	case R_IA64_LTOFF_DTPREL22:
+	case R_IA64_DTPMOD64MSB:
+	case R_IA64_DTPMOD64LSB:
+	case R_IA64_LTOFF_DTPMOD22:
+          abort ();
+	  break;
+
+	case R_IA64_LTOFF_FPTR22:
+	case R_IA64_LTOFF_FPTR64I:
+	case R_IA64_LTOFF_FPTR32MSB:
+	case R_IA64_LTOFF_FPTR32LSB:
+	case R_IA64_LTOFF_FPTR64MSB:
+	case R_IA64_LTOFF_FPTR64LSB:
+	  need_entry = NEED_FPTR | NEED_GOT | NEED_LTOFF_FPTR;
+	  break;
+
+	case R_IA64_FPTR64I:
+	case R_IA64_FPTR32MSB:
+	case R_IA64_FPTR32LSB:
+	case R_IA64_FPTR64MSB:
+	case R_IA64_FPTR64LSB:
+	  if (info->shared || h)
+	    need_entry = NEED_FPTR | NEED_DYNREL;
+	  else
+	    need_entry = NEED_FPTR;
+	  dynrel_type = R_IA64_FPTR64LSB;
+	  break;
+
+	case R_IA64_LTOFF22:
+	case R_IA64_LTOFF64I:
+	  need_entry = NEED_GOT;
+	  break;
+
+	case R_IA64_LTOFF22X:
+	  need_entry = NEED_GOTX;
+	  break;
+
+	case R_IA64_PLTOFF22:
+	case R_IA64_PLTOFF64I:
+	case R_IA64_PLTOFF64MSB:
+	case R_IA64_PLTOFF64LSB:
+	  need_entry = NEED_PLTOFF;
+	  if (h)
+	    {
+	      if (maybe_dynamic)
+		need_entry |= NEED_MIN_PLT;
+	    }
+	  break;
+
+	case R_IA64_PCREL21B:
+        case R_IA64_PCREL60B:
+	  /* Depending on where this symbol is defined, we may or may not
+	     need a full plt entry.  Only skip if we know we'll not need
+	     the entry -- static or symbolic, and the symbol definition
+	     has already been seen.  */
+	  if (maybe_dynamic && rel->r_addend == 0)
+	    need_entry = NEED_FULL_PLT;
+	  break;
+
+	case R_IA64_IMM14:
+	case R_IA64_IMM22:
+	case R_IA64_IMM64:
+	case R_IA64_DIR32MSB:
+	case R_IA64_DIR32LSB:
+	case R_IA64_DIR64MSB:
+	case R_IA64_DIR64LSB:
+	  /* Shared objects will always need at least a REL relocation.  */
+	  if (info->shared || maybe_dynamic)
+	    need_entry = NEED_DYNREL;
+	  dynrel_type = R_IA64_DIR64LSB;
+	  break;
+
+	case R_IA64_IPLTMSB:
+	case R_IA64_IPLTLSB:
+	  break;
+
+	case R_IA64_PCREL22:
+	case R_IA64_PCREL64I:
+	case R_IA64_PCREL32MSB:
+	case R_IA64_PCREL32LSB:
+	case R_IA64_PCREL64MSB:
+	case R_IA64_PCREL64LSB:
+	  if (maybe_dynamic)
+	    need_entry = NEED_DYNREL;
+	  dynrel_type = R_IA64_PCREL64LSB;
+	  break;
+	}
+
+      if (!need_entry)
+	continue;
+
+      dyn_i = get_dyn_sym_info (ia64_info, h, abfd, rel, FALSE);
+
+      /* Record whether or not this is a local symbol.  */
+      dyn_i->h = h;
+
+      /* Create what's needed.  */
+      if (need_entry & (NEED_GOT | NEED_GOTX))
+	{
+	  if (!got)
+	    {
+	      got = get_got (abfd, ia64_info);
+	      if (!got)
+		return FALSE;
+	    }
+	  if (need_entry & NEED_GOT)
+	    dyn_i->want_got = 1;
+	  if (need_entry & NEED_GOTX)
+	    dyn_i->want_gotx = 1;
+	}
+      if (need_entry & NEED_FPTR)
+	{
+          /* Create the .opd section.  */
+	  if (!fptr)
+	    {
+	      fptr = get_fptr (abfd, info, ia64_info);
+	      if (!fptr)
+		return FALSE;
+	    }
+	  dyn_i->want_fptr = 1;
+	}
+      if (need_entry & NEED_LTOFF_FPTR)
+	dyn_i->want_ltoff_fptr = 1;
+      if (need_entry & (NEED_MIN_PLT | NEED_FULL_PLT))
+	{
+          if (!ia64_info->root.dynobj)
+	    ia64_info->root.dynobj = abfd;
+	  h->needs_plt = 1;
+	  dyn_i->want_plt = 1;
+	}
+      if (need_entry & NEED_FULL_PLT)
+	dyn_i->want_plt2 = 1;
+      if (need_entry & NEED_PLTOFF)
+	{
+	  /* This is needed here, in case @pltoff is used in a non-shared
+	     link.  */
+	  if (!pltoff)
+	    {
+	      pltoff = get_pltoff (abfd, ia64_info);
+	      if (!pltoff)
+		return FALSE;
+	    }
+
+	  dyn_i->want_pltoff = 1;
+	}
+      if ((need_entry & NEED_DYNREL) && (sec->flags & SEC_ALLOC))
+	{
+	  if (!srel)
+	    {
+	      srel = get_reloc_section (abfd, ia64_info, sec, TRUE);
+	      if (!srel)
+		return FALSE;
+	    }
+	  if (!count_dyn_reloc (abfd, dyn_i, srel, dynrel_type))
+	    return FALSE;
+	}
+    }
+
+  return TRUE;
+}
+
+/* For cleanliness, and potentially faster dynamic loading, allocate
+   external GOT entries first.  */
+
+static bfd_boolean
+allocate_global_data_got (struct elf64_ia64_dyn_sym_info *dyn_i,
+			  void * data)
+{
+  struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
+
+  if ((dyn_i->want_got || dyn_i->want_gotx)
+      && ! dyn_i->want_fptr
+      && elf64_ia64_dynamic_symbol_p (dyn_i->h))
+     {
+       /* GOT entry with FPTR is done by allocate_global_fptr_got.  */
+       dyn_i->got_offset = x->ofs;
+       x->ofs += 8;
+     }
+  return TRUE;
+}
+
+/* Next, allocate all the GOT entries used by LTOFF_FPTR relocs.  */
+
+static bfd_boolean
+allocate_global_fptr_got (struct elf64_ia64_dyn_sym_info *dyn_i,
+			  void * data)
+{
+  struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
+
+  if (dyn_i->want_got
+      && dyn_i->want_fptr
+      && elf64_ia64_dynamic_symbol_p (dyn_i->h))
+    {
+      dyn_i->got_offset = x->ofs;
+      x->ofs += 8;
+    }
+  return TRUE;
+}
+
+/* Lastly, allocate all the GOT entries for local data.  */
+
+static bfd_boolean
+allocate_local_got (struct elf64_ia64_dyn_sym_info *dyn_i,
+		    void * data)
+{
+  struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *) data;
+
+  if ((dyn_i->want_got || dyn_i->want_gotx)
+      && !elf64_ia64_dynamic_symbol_p (dyn_i->h))
+    {
+      dyn_i->got_offset = x->ofs;
+      x->ofs += 8;
+    }
+  return TRUE;
+}
+
+/* Allocate function descriptors.  We can do these for every function
+   in a main executable that is not exported.  */
+
+static bfd_boolean
+allocate_fptr (struct elf64_ia64_dyn_sym_info *dyn_i, void * data)
+{
+  struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *) data;
+
+  if (dyn_i->want_fptr)
+    {
+      struct elf_link_hash_entry *h = dyn_i->h;
+
+      if (h)
+	while (h->root.type == bfd_link_hash_indirect
+	       || h->root.type == bfd_link_hash_warning)
+	  h = (struct elf_link_hash_entry *) h->root.u.i.link;
+
+      if (h == NULL || !h->def_dynamic)
+	{
+          /*  A non dynamic symbol.  */
+	  dyn_i->fptr_offset = x->ofs;
+	  x->ofs += 16;
+	}
+      else
+	dyn_i->want_fptr = 0;
+    }
+  return TRUE;
+}
+
+/* Allocate all the minimal PLT entries.  */
+
+static bfd_boolean
+allocate_plt_entries (struct elf64_ia64_dyn_sym_info *dyn_i,
+		      void * data ATTRIBUTE_UNUSED)
+{
+  if (dyn_i->want_plt)
+    {
+      struct elf_link_hash_entry *h = dyn_i->h;
+
+      if (h)
+	while (h->root.type == bfd_link_hash_indirect
+	       || h->root.type == bfd_link_hash_warning)
+	  h = (struct elf_link_hash_entry *) h->root.u.i.link;
+
+      /* ??? Versioned symbols seem to lose NEEDS_PLT.  */
+      if (elf64_ia64_dynamic_symbol_p (h))
+	{
+	  dyn_i->want_pltoff = 1;
+	}
+      else
+	{
+	  dyn_i->want_plt = 0;
+	  dyn_i->want_plt2 = 0;
+	}
+    }
+  return TRUE;
+}
+
+/* Allocate all the full PLT entries.  */
+
+static bfd_boolean
+allocate_plt2_entries (struct elf64_ia64_dyn_sym_info *dyn_i,
+		       void * data)
+{
+  struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
+
+  if (dyn_i->want_plt2)
+    {
+      struct elf_link_hash_entry *h = dyn_i->h;
+      bfd_size_type ofs = x->ofs;
+
+      dyn_i->plt2_offset = ofs;
+      x->ofs = ofs + PLT_FULL_ENTRY_SIZE;
+
+      while (h->root.type == bfd_link_hash_indirect
+	     || h->root.type == bfd_link_hash_warning)
+	h = (struct elf_link_hash_entry *) h->root.u.i.link;
+      dyn_i->h->plt.offset = ofs;
+    }
+  return TRUE;
+}
+
+/* Allocate all the PLTOFF entries requested by relocations and
+   plt entries.  We can't share space with allocated FPTR entries,
+   because the latter are not necessarily addressable by the GP.
+   ??? Relaxation might be able to determine that they are.  */
+
+static bfd_boolean
+allocate_pltoff_entries (struct elf64_ia64_dyn_sym_info *dyn_i,
+			 void * data)
+{
+  struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
+
+  if (dyn_i->want_pltoff)
+    {
+      dyn_i->pltoff_offset = x->ofs;
+      x->ofs += 16;
+    }
+  return TRUE;
+}
+
+/* Allocate dynamic relocations for those symbols that turned out
+   to be dynamic.  */
+
+static bfd_boolean
+allocate_dynrel_entries (struct elf64_ia64_dyn_sym_info *dyn_i,
+			 void * data)
+{
+  struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
+  struct elf64_ia64_link_hash_table *ia64_info;
+  struct elf64_ia64_dyn_reloc_entry *rent;
+  bfd_boolean dynamic_symbol, shared, resolved_zero;
+  struct elf64_ia64_link_hash_entry *h_ia64;
+
+  ia64_info = elf64_ia64_hash_table (x->info);
+  if (ia64_info == NULL)
+    return FALSE;
+
+  /* Note that this can't be used in relation to FPTR relocs below.  */
+  dynamic_symbol = elf64_ia64_dynamic_symbol_p (dyn_i->h);
+
+  shared = x->info->shared;
+  resolved_zero = (dyn_i->h
+		   && ELF_ST_VISIBILITY (dyn_i->h->other)
+		   && dyn_i->h->root.type == bfd_link_hash_undefweak);
+
+  /* Take care of the GOT and PLT relocations.  */
+
+  if ((!resolved_zero
+       && (dynamic_symbol || shared)
+       && (dyn_i->want_got || dyn_i->want_gotx))
+      || (dyn_i->want_ltoff_fptr
+	  && dyn_i->h
+	  && dyn_i->h->def_dynamic))
+    {
+      /* VMS: FIX64.  */
+      if (dyn_i->h != NULL && dyn_i->h->def_dynamic)
+        {
+          h_ia64 = (struct elf64_ia64_link_hash_entry *) dyn_i->h;
+          elf_ia64_vms_tdata (h_ia64->shl)->fixups_off +=
+            sizeof (Elf64_External_VMS_IMAGE_FIXUP);
+          ia64_info->fixups_sec->size +=
+            sizeof (Elf64_External_VMS_IMAGE_FIXUP);
+        }
+    }
+
+  if (ia64_info->rel_fptr_sec && dyn_i->want_fptr)
+    {
+      /* VMS: only image reloc.  */
+      if (dyn_i->h == NULL || dyn_i->h->root.type != bfd_link_hash_undefweak)
+	ia64_info->rel_fptr_sec->size += sizeof (Elf64_External_Rela);
+    }
+
+  if (!resolved_zero && dyn_i->want_pltoff)
+    {
+      /* VMS: FIXFD.  */
+      if (dyn_i->h != NULL && dyn_i->h->def_dynamic)
+        {
+          h_ia64 = (struct elf64_ia64_link_hash_entry *) dyn_i->h;
+          elf_ia64_vms_tdata (h_ia64->shl)->fixups_off +=
+            sizeof (Elf64_External_VMS_IMAGE_FIXUP);
+          ia64_info->fixups_sec->size +=
+            sizeof (Elf64_External_VMS_IMAGE_FIXUP);
+        }
+    }
+
+  /* Take care of the normal data relocations.  */
+
+  for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
+    {
+      int count = rent->count;
+
+      switch (rent->type)
+	{
+	case R_IA64_FPTR32LSB:
+	case R_IA64_FPTR64LSB:
+	  /* Allocate one iff !want_fptr and not PIE, which by this point
+	     will be true only if we're actually allocating one statically
+	     in the main executable.  Position independent executables
+	     need a relative reloc.  */
+	  if (dyn_i->want_fptr && !x->info->pie)
+	    continue;
+	  break;
+	case R_IA64_PCREL32LSB:
+	case R_IA64_PCREL64LSB:
+	  if (!dynamic_symbol)
+	    continue;
+	  break;
+	case R_IA64_DIR32LSB:
+	case R_IA64_DIR64LSB:
+	  if (!dynamic_symbol && !shared)
+	    continue;
+	  break;
+	case R_IA64_IPLTLSB:
+	  if (!dynamic_symbol && !shared)
+	    continue;
+	  /* Use two REL relocations for IPLT relocations
+	     against local symbols.  */
+	  if (!dynamic_symbol)
+	    count *= 2;
+	  break;
+	case R_IA64_DTPREL32LSB:
+	case R_IA64_TPREL64LSB:
+	case R_IA64_DTPREL64LSB:
+	case R_IA64_DTPMOD64LSB:
+	  break;
+	default:
+	  abort ();
+	}
+
+      /* Add a fixup.  */
+      if (!dynamic_symbol)
+        abort ();
+
+      h_ia64 = (struct elf64_ia64_link_hash_entry *) dyn_i->h;
+      elf_ia64_vms_tdata (h_ia64->shl)->fixups_off +=
+        sizeof (Elf64_External_VMS_IMAGE_FIXUP);
+      ia64_info->fixups_sec->size +=
+        sizeof (Elf64_External_VMS_IMAGE_FIXUP);
+    }
+
+  return TRUE;
+}
+
+static bfd_boolean
+elf64_ia64_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
+				  struct elf_link_hash_entry *h)
+{
+  /* ??? Undefined symbols with PLT entries should be re-defined
+     to be the PLT entry.  */
+
+  /* If this is a weak symbol, and there is a real definition, the
+     processor independent code will have arranged for us to see the
+     real definition first, and we can just use the same value.  */
+  if (h->u.weakdef != NULL)
+    {
+      BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
+                  || h->u.weakdef->root.type == bfd_link_hash_defweak);
+      h->root.u.def.section = h->u.weakdef->root.u.def.section;
+      h->root.u.def.value = h->u.weakdef->root.u.def.value;
+      return TRUE;
+    }
+
+  /* If this is a reference to a symbol defined by a dynamic object which
+     is not a function, we might allocate the symbol in our .dynbss section
+     and allocate a COPY dynamic relocation.
+
+     But IA-64 code is canonically PIC, so as a rule we can avoid this sort
+     of hackery.  */
+
+  return TRUE;
+}
+
+static bfd_boolean
+elf64_ia64_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
+				  struct bfd_link_info *info)
+{
+  struct elf64_ia64_allocate_data data;
+  struct elf64_ia64_link_hash_table *ia64_info;
+  asection *sec;
+  bfd *dynobj;
+  struct elf_link_hash_table *hash_table;
+
+  hash_table = elf_hash_table (info);
+  dynobj = hash_table->dynobj;
+  ia64_info = elf64_ia64_hash_table (info);
+  if (ia64_info == NULL)
+    return FALSE;
+  BFD_ASSERT(dynobj != NULL);
+  data.info = info;
+
+  /* Allocate the GOT entries.  */
+
+  if (ia64_info->root.sgot)
+    {
+      data.ofs = 0;
+      elf64_ia64_dyn_sym_traverse (ia64_info, allocate_global_data_got, &data);
+      elf64_ia64_dyn_sym_traverse (ia64_info, allocate_global_fptr_got, &data);
+      elf64_ia64_dyn_sym_traverse (ia64_info, allocate_local_got, &data);
+      ia64_info->root.sgot->size = data.ofs;
+    }
+
+  /* Allocate the FPTR entries.  */
+
+  if (ia64_info->fptr_sec)
+    {
+      data.ofs = 0;
+      elf64_ia64_dyn_sym_traverse (ia64_info, allocate_fptr, &data);
+      ia64_info->fptr_sec->size = data.ofs;
+    }
+
+  /* Now that we've seen all of the input files, we can decide which
+     symbols need plt entries.  Allocate the minimal PLT entries first.
+     We do this even though dynamic_sections_created may be FALSE, because
+     this has the side-effect of clearing want_plt and want_plt2.  */
+
+  data.ofs = 0;
+  elf64_ia64_dyn_sym_traverse (ia64_info, allocate_plt_entries, &data);
+
+  /* Align the pointer for the plt2 entries.  */
+  data.ofs = (data.ofs + 31) & (bfd_vma) -32;
+
+  elf64_ia64_dyn_sym_traverse (ia64_info, allocate_plt2_entries, &data);
+  if (data.ofs != 0 || ia64_info->root.dynamic_sections_created)
+    {
+      /* FIXME: we always reserve the memory for dynamic linker even if
+	 there are no PLT entries since dynamic linker may assume the
+	 reserved memory always exists.  */
+
+      BFD_ASSERT (ia64_info->root.dynamic_sections_created);
+
+      ia64_info->root.splt->size = data.ofs;
+    }
+
+  /* Allocate the PLTOFF entries.  */
+
+  if (ia64_info->pltoff_sec)
+    {
+      data.ofs = 0;
+      elf64_ia64_dyn_sym_traverse (ia64_info, allocate_pltoff_entries, &data);
+      ia64_info->pltoff_sec->size = data.ofs;
+    }
+
+  if (ia64_info->root.dynamic_sections_created)
+    {
+      /* Allocate space for the dynamic relocations that turned out to be
+	 required.  */
+      elf64_ia64_dyn_sym_traverse (ia64_info, allocate_dynrel_entries, &data);
+    }
+
+  /* We have now determined the sizes of the various dynamic sections.
+     Allocate memory for them.  */
+  for (sec = dynobj->sections; sec != NULL; sec = sec->next)
+    {
+      bfd_boolean strip;
+
+      if (!(sec->flags & SEC_LINKER_CREATED))
+	continue;
+
+      /* If we don't need this section, strip it from the output file.
+	 There were several sections primarily related to dynamic
+	 linking that must be create before the linker maps input
+	 sections to output sections.  The linker does that before
+	 bfd_elf_size_dynamic_sections is called, and it is that
+	 function which decides whether anything needs to go into
+	 these sections.  */
+
+      strip = (sec->size == 0);
+
+      if (sec == ia64_info->root.sgot)
+	strip = FALSE;
+      else if (sec == ia64_info->root.srelgot)
+	{
+	  if (strip)
+	    ia64_info->root.srelgot = NULL;
+	  else
+	    /* We use the reloc_count field as a counter if we need to
+	       copy relocs into the output file.  */
+	    sec->reloc_count = 0;
+	}
+      else if (sec == ia64_info->fptr_sec)
+	{
+	  if (strip)
+	    ia64_info->fptr_sec = NULL;
+	}
+      else if (sec == ia64_info->rel_fptr_sec)
+	{
+	  if (strip)
+	    ia64_info->rel_fptr_sec = NULL;
+	  else
+	    /* We use the reloc_count field as a counter if we need to
+	       copy relocs into the output file.  */
+	    sec->reloc_count = 0;
+	}
+      else if (sec == ia64_info->root.splt)
+	{
+	  if (strip)
+	    ia64_info->root.splt = NULL;
+	}
+      else if (sec == ia64_info->pltoff_sec)
+	{
+	  if (strip)
+	    ia64_info->pltoff_sec = NULL;
+	}
+      else if (sec == ia64_info->fixups_sec)
+	{
+          if (strip)
+            ia64_info->fixups_sec = NULL;
+	}
+      else if (sec == ia64_info->transfer_sec)
+        {
+          ;
+        }
+      else
+	{
+	  const char *name;
+
+	  /* It's OK to base decisions on the section name, because none
+	     of the dynobj section names depend upon the input files.  */
+	  name = bfd_get_section_name (dynobj, sec);
+
+	  if (strcmp (name, ".got.plt") == 0)
+	    strip = FALSE;
+	  else if (CONST_STRNEQ (name, ".rel"))
+	    {
+	      if (!strip)
+		{
+		  /* We use the reloc_count field as a counter if we need to
+		     copy relocs into the output file.  */
+		  sec->reloc_count = 0;
+		}
+	    }
+	  else
+	    continue;
+	}
+
+      if (strip)
+	sec->flags |= SEC_EXCLUDE;
+      else
+	{
+	  /* Allocate memory for the section contents.  */
+	  sec->contents = (bfd_byte *) bfd_zalloc (dynobj, sec->size);
+	  if (sec->contents == NULL && sec->size != 0)
+	    return FALSE;
+	}
+    }
+
+  if (elf_hash_table (info)->dynamic_sections_created)
+    {
+      bfd *abfd;
+      asection *dynsec;
+      asection *dynstrsec;
+      Elf_Internal_Dyn dyn;
+      const struct elf_backend_data *bed;
+      unsigned int shl_num = 0;
+      bfd_vma fixups_off = 0;
+      bfd_vma strdyn_off;
+      unsigned int time_hi, time_lo;
+
+      /* The .dynamic section must exist and be empty.  */
+      dynsec = bfd_get_section_by_name (hash_table->dynobj, ".dynamic");
+      BFD_ASSERT (dynsec != NULL);
+      BFD_ASSERT (dynsec->size == 0);
+
+      dynstrsec = bfd_get_section_by_name (hash_table->dynobj, ".vmsdynstr");
+      BFD_ASSERT (dynstrsec != NULL);
+      BFD_ASSERT (dynstrsec->size == 0);
+      dynstrsec->size = 1;	/* Initial blank.  */
+
+      /* Ident + link time.  */
+      vms_get_time (&time_hi, &time_lo);
+
+      if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_IDENT, 0))
+        return FALSE;
+      if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_LINKTIME,
+                                       (((bfd_uint64_t)time_hi) << 32)
+                                       + time_lo))
+        return FALSE;
+
+      /* Strtab.  */
+      strdyn_off = dynsec->size;
+      if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_STRTAB_OFFSET, 0))
+        return FALSE;
+      if (!_bfd_elf_add_dynamic_entry (info, DT_STRSZ, 0))
+        return FALSE;
+
+      /* PLTGOT  */
+      if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_PLTGOT_SEG, 0))
+        return FALSE;
+      if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_PLTGOT_OFFSET, 0))
+        return FALSE;
+
+      /* Misc.  */
+      if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_FPMODE, 0x9800000))
+        return FALSE;
+      if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_LNKFLAGS,
+                                       VMS_LF_IMGSTA | VMS_LF_MAIN))
+        return FALSE;
+
+      /* Add entries for shared libraries.  */
+      for (abfd = info->input_bfds; abfd; abfd = abfd->link_next)
+        {
+          char *soname;
+          size_t soname_len;
+          bfd_size_type strindex;
+          bfd_byte *newcontents;
+          bfd_vma fixups_shl_off;
+
+          if (!(abfd->flags & DYNAMIC))
+            continue;
+          BFD_ASSERT (abfd->xvec == output_bfd->xvec);
+
+          if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_NEEDED_IDENT,
+                                           elf_ia64_vms_ident (abfd)))
+            return FALSE;
+
+          soname = vms_get_module_name (abfd->filename, TRUE);
+          if (soname == NULL)
+            return FALSE;
+          strindex = dynstrsec->size;
+          soname_len = strlen (soname) + 1;
+          newcontents = (bfd_byte *) bfd_realloc (dynstrsec->contents,
+                                                  strindex + soname_len);
+          if (newcontents == NULL)
+            return FALSE;
+          memcpy (newcontents + strindex, soname, soname_len);
+          dynstrsec->size += soname_len;
+          dynstrsec->contents = newcontents;
+
+          if (!_bfd_elf_add_dynamic_entry (info, DT_NEEDED, strindex))
+            return FALSE;
+
+          if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_FIXUP_NEEDED,
+                                           shl_num))
+            return FALSE;
+          shl_num++;
+
+          /* The fixups_off was in fact containing the size of the fixup
+             section.  Remap into the offset.  */
+          fixups_shl_off = elf_ia64_vms_tdata (abfd)->fixups_off;
+          elf_ia64_vms_tdata (abfd)->fixups_off = fixups_off;
+
+          if (!_bfd_elf_add_dynamic_entry
+              (info, DT_IA_64_VMS_FIXUP_RELA_CNT,
+               fixups_shl_off / sizeof (Elf64_External_VMS_IMAGE_FIXUP)))
+            return FALSE;
+          if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_FIXUP_RELA_OFF,
+                                           fixups_off))
+            return FALSE;
+          fixups_off += fixups_shl_off;
+        }
+
+      /* Unwind.  */
+      if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_UNWINDSZ, 0))
+        return FALSE;
+      if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_UNWIND_CODSEG, 0))
+        return FALSE;
+      if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_UNWIND_INFOSEG, 0))
+        return FALSE;
+      if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_UNWIND_OFFSET, 0))
+        return FALSE;
+      if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_UNWIND_SEG, 0))
+        return FALSE;
+
+      if (!_bfd_elf_add_dynamic_entry (info, DT_NULL, 0xdead))
+            return FALSE;
+
+      /* Fix the strtab entries.  */
+      bed = get_elf_backend_data (hash_table->dynobj);
+
+      if (dynstrsec->size > 1)
+        dynstrsec->contents[0] = 0;
+      else
+        dynstrsec->size = 0;
+
+      /* Note: one 'spare' (ie DT_NULL) entry is added by
+         bfd_elf_size_dynsym_hash_dynstr.  */
+      dyn.d_tag = DT_IA_64_VMS_STRTAB_OFFSET;
+      dyn.d_un.d_val = dynsec->size /* + sizeof (Elf64_External_Dyn) */;
+      bed->s->swap_dyn_out (hash_table->dynobj, &dyn,
+                            dynsec->contents + strdyn_off);
+
+      dyn.d_tag = DT_STRSZ;
+      dyn.d_un.d_val = dynstrsec->size;
+      bed->s->swap_dyn_out (hash_table->dynobj, &dyn,
+                            dynsec->contents + strdyn_off + bed->s->sizeof_dyn);
+
+      elf_ia64_vms_tdata (output_bfd)->needed_count = shl_num;
+
+      /* Note section.  */
+      if (!create_ia64_vms_notes (output_bfd, info, time_hi, time_lo))
+        return FALSE;
+    }
+
+  /* ??? Perhaps force __gp local.  */
+
+  return TRUE;
+}
+
+static void
+elf64_ia64_install_fixup (bfd *output_bfd,
+                          struct elf64_ia64_link_hash_table *ia64_info,
+                          struct elf_link_hash_entry *h,
+                          unsigned int type, asection *sec, bfd_vma offset,
+                          bfd_vma addend)
+{
+  asection *relsec;
+  Elf64_External_VMS_IMAGE_FIXUP *fixup;
+  struct elf64_ia64_link_hash_entry *h_ia64;
+  bfd_vma fixoff;
+  Elf_Internal_Phdr *phdr;
+
+  if (h == NULL || !h->def_dynamic)
+    abort ();
+
+  h_ia64 = (struct elf64_ia64_link_hash_entry *) h;
+  fixoff = elf_ia64_vms_tdata (h_ia64->shl)->fixups_off;
+  elf_ia64_vms_tdata (h_ia64->shl)->fixups_off +=
+    sizeof (Elf64_External_VMS_IMAGE_FIXUP);
+  relsec = ia64_info->fixups_sec;
+
+  fixup = (Elf64_External_VMS_IMAGE_FIXUP *)(relsec->contents + fixoff);
+  offset += sec->output_section->vma + sec->output_offset;
+
+  /* FIXME: this is slow.  We should cache the last one used, or create a
+     map.  */
+  phdr = _bfd_elf_find_segment_containing_section
+    (output_bfd, sec->output_section);
+  BFD_ASSERT (phdr != NULL);
+
+  bfd_putl64 (offset - phdr->p_vaddr, fixup->fixup_offset);
+  bfd_putl32 (type, fixup->type);
+  bfd_putl32 (phdr - elf_tdata (output_bfd)->phdr, fixup->fixup_seg);
+  bfd_putl64 (addend, fixup->addend);
+  bfd_putl32 (h->root.u.def.value, fixup->symvec_index);
+  bfd_putl32 (2, fixup->data_type);
+}
+
+/* Store an entry for target address TARGET_ADDR in the linkage table
+   and return the gp-relative address of the linkage table entry.  */
+
+static bfd_vma
+set_got_entry (bfd *abfd, struct bfd_link_info *info,
+	       struct elf64_ia64_dyn_sym_info *dyn_i,
+	       bfd_vma addend, bfd_vma value, unsigned int dyn_r_type)
+{
+  struct elf64_ia64_link_hash_table *ia64_info;
+  asection *got_sec;
+  bfd_boolean done;
+  bfd_vma got_offset;
+
+  ia64_info = elf64_ia64_hash_table (info);
+  if (ia64_info == NULL)
+    return 0;
+
+  got_sec = ia64_info->root.sgot;
+
+  switch (dyn_r_type)
+    {
+    case R_IA64_TPREL64LSB:
+    case R_IA64_DTPMOD64LSB:
+    case R_IA64_DTPREL32LSB:
+    case R_IA64_DTPREL64LSB:
+      abort ();
+      break;
+    default:
+      done = dyn_i->got_done;
+      dyn_i->got_done = TRUE;
+      got_offset = dyn_i->got_offset;
+      break;
+    }
+
+  BFD_ASSERT ((got_offset & 7) == 0);
+
+  if (! done)
+    {
+      /* Store the target address in the linkage table entry.  */
+      bfd_put_64 (abfd, value, got_sec->contents + got_offset);
+
+      /* Install a dynamic relocation if needed.  */
+      if (((info->shared
+	    && (!dyn_i->h
+		|| ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT
+		|| dyn_i->h->root.type != bfd_link_hash_undefweak))
+           || elf64_ia64_dynamic_symbol_p (dyn_i->h))
+	  && (!dyn_i->want_ltoff_fptr
+	      || !info->pie
+	      || !dyn_i->h
+	      || dyn_i->h->root.type != bfd_link_hash_undefweak))
+	{
+	  if (!dyn_i->h || !dyn_i->h->def_dynamic)
+	    {
+	      dyn_r_type = R_IA64_REL64LSB;
+	      addend = value;
+	    }
+
+          /* VMS: install a FIX32 or FIX64.  */
+          switch (dyn_r_type)
+            {
+            case R_IA64_DIR32LSB:
+            case R_IA64_FPTR32LSB:
+              dyn_r_type = R_IA64_VMS_FIX32;
+              break;
+            case R_IA64_DIR64LSB:
+            case R_IA64_FPTR64LSB:
+              dyn_r_type = R_IA64_VMS_FIX64;
+              break;
+            default:
+              BFD_ASSERT (FALSE);
+              break;
+            }
+          elf64_ia64_install_fixup
+            (info->output_bfd, ia64_info, dyn_i->h,
+             dyn_r_type, got_sec, got_offset, addend);
+        }
+    }
+
+  /* Return the address of the linkage table entry.  */
+  value = (got_sec->output_section->vma
+	   + got_sec->output_offset
+	   + got_offset);
+
+  return value;
+}
+
+/* Fill in a function descriptor consisting of the function's code
+   address and its global pointer.  Return the descriptor's address.  */
+
+static bfd_vma
+set_fptr_entry (bfd *abfd, struct bfd_link_info *info,
+		struct elf64_ia64_dyn_sym_info *dyn_i,
+		bfd_vma value)
+{
+  struct elf64_ia64_link_hash_table *ia64_info;
+  asection *fptr_sec;
+
+  ia64_info = elf64_ia64_hash_table (info);
+  if (ia64_info == NULL)
+    return 0;
+
+  fptr_sec = ia64_info->fptr_sec;
+
+  if (!dyn_i->fptr_done)
+    {
+      dyn_i->fptr_done = 1;
+
+      /* Fill in the function descriptor.  */
+      bfd_put_64 (abfd, value, fptr_sec->contents + dyn_i->fptr_offset);
+      bfd_put_64 (abfd, _bfd_get_gp_value (abfd),
+		  fptr_sec->contents + dyn_i->fptr_offset + 8);
+    }
+
+  /* Return the descriptor's address.  */
+  value = (fptr_sec->output_section->vma
+	   + fptr_sec->output_offset
+	   + dyn_i->fptr_offset);
+
+  return value;
+}
+
+/* Fill in a PLTOFF entry consisting of the function's code address
+   and its global pointer.  Return the descriptor's address.  */
+
+static bfd_vma
+set_pltoff_entry (bfd *abfd, struct bfd_link_info *info,
+		  struct elf64_ia64_dyn_sym_info *dyn_i,
+		  bfd_vma value, bfd_boolean is_plt)
+{
+  struct elf64_ia64_link_hash_table *ia64_info;
+  asection *pltoff_sec;
+
+  ia64_info = elf64_ia64_hash_table (info);
+  if (ia64_info == NULL)
+    return 0;
+
+  pltoff_sec = ia64_info->pltoff_sec;
+
+  /* Don't do anything if this symbol uses a real PLT entry.  In
+     that case, we'll fill this in during finish_dynamic_symbol.  */
+  if ((! dyn_i->want_plt || is_plt)
+      && !dyn_i->pltoff_done)
+    {
+      bfd_vma gp = _bfd_get_gp_value (abfd);
+
+      /* Fill in the function descriptor.  */
+      bfd_put_64 (abfd, value, pltoff_sec->contents + dyn_i->pltoff_offset);
+      bfd_put_64 (abfd, gp, pltoff_sec->contents + dyn_i->pltoff_offset + 8);
+
+      /* Install dynamic relocations if needed.  */
+      if (!is_plt
+	  && info->shared
+	  && (!dyn_i->h
+	      || ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT
+	      || dyn_i->h->root.type != bfd_link_hash_undefweak))
+	{
+          /* VMS:  */
+          abort ();
+	}
+
+      dyn_i->pltoff_done = 1;
+    }
+
+  /* Return the descriptor's address.  */
+  value = (pltoff_sec->output_section->vma
+	   + pltoff_sec->output_offset
+	   + dyn_i->pltoff_offset);
+
+  return value;
+}
+
+/* Called through qsort to sort the .IA_64.unwind section during a
+   non-relocatable link.  Set elf64_ia64_unwind_entry_compare_bfd
+   to the output bfd so we can do proper endianness frobbing.  */
+
+static bfd *elf64_ia64_unwind_entry_compare_bfd;
+
+static int
+elf64_ia64_unwind_entry_compare (const void * a, const void * b)
+{
+  bfd_vma av, bv;
+
+  av = bfd_get_64 (elf64_ia64_unwind_entry_compare_bfd, a);
+  bv = bfd_get_64 (elf64_ia64_unwind_entry_compare_bfd, b);
+
+  return (av < bv ? -1 : av > bv ? 1 : 0);
+}
+
+/* Make sure we've got ourselves a nice fat __gp value.  */
+static bfd_boolean
+elf64_ia64_choose_gp (bfd *abfd, struct bfd_link_info *info, bfd_boolean final)
+{
+  bfd_vma min_vma = (bfd_vma) -1, max_vma = 0;
+  bfd_vma min_short_vma = min_vma, max_short_vma = 0;
+  struct elf_link_hash_entry *gp;
+  bfd_vma gp_val;
+  asection *os;
+  struct elf64_ia64_link_hash_table *ia64_info;
+
+  ia64_info = elf64_ia64_hash_table (info);
+  if (ia64_info == NULL)
+    return FALSE;
+
+  /* Find the min and max vma of all sections marked short.  Also collect
+     min and max vma of any type, for use in selecting a nice gp.  */
+  for (os = abfd->sections; os ; os = os->next)
+    {
+      bfd_vma lo, hi;
+
+      if ((os->flags & SEC_ALLOC) == 0)
+	continue;
+
+      lo = os->vma;
+      /* When this function is called from elfNN_ia64_final_link
+	 the correct value to use is os->size.  When called from
+	 elfNN_ia64_relax_section we are in the middle of section
+	 sizing; some sections will already have os->size set, others
+	 will have os->size zero and os->rawsize the previous size.  */
+      hi = os->vma + (!final && os->rawsize ? os->rawsize : os->size);
+      if (hi < lo)
+	hi = (bfd_vma) -1;
+
+      if (min_vma > lo)
+	min_vma = lo;
+      if (max_vma < hi)
+	max_vma = hi;
+      if (os->flags & SEC_SMALL_DATA)
+	{
+	  if (min_short_vma > lo)
+	    min_short_vma = lo;
+	  if (max_short_vma < hi)
+	    max_short_vma = hi;
+	}
+    }
+
+  if (ia64_info->min_short_sec)
+    {
+      if (min_short_vma
+	  > (ia64_info->min_short_sec->vma
+	     + ia64_info->min_short_offset))
+	min_short_vma = (ia64_info->min_short_sec->vma
+			 + ia64_info->min_short_offset);
+      if (max_short_vma
+	  < (ia64_info->max_short_sec->vma
+	     + ia64_info->max_short_offset))
+	max_short_vma = (ia64_info->max_short_sec->vma
+			 + ia64_info->max_short_offset);
+    }
+
+  /* See if the user wants to force a value.  */
+  gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,
+			     FALSE, FALSE);
+
+  if (gp
+      && (gp->root.type == bfd_link_hash_defined
+	  || gp->root.type == bfd_link_hash_defweak))
+    {
+      asection *gp_sec = gp->root.u.def.section;
+      gp_val = (gp->root.u.def.value
+		+ gp_sec->output_section->vma
+		+ gp_sec->output_offset);
+    }
+  else
+    {
+      /* Pick a sensible value.  */
+
+      if (ia64_info->min_short_sec)
+	{
+	  bfd_vma short_range = max_short_vma - min_short_vma;
+
+	  /* If min_short_sec is set, pick one in the middle bewteen
+	     min_short_vma and max_short_vma.  */
+	  if (short_range >= 0x400000)
+	    goto overflow;
+	  gp_val = min_short_vma + short_range / 2;
+	}
+      else
+	{
+	  asection *got_sec = ia64_info->root.sgot;
+
+	  /* Start with just the address of the .got.  */
+	  if (got_sec)
+	    gp_val = got_sec->output_section->vma;
+	  else if (max_short_vma != 0)
+	    gp_val = min_short_vma;
+	  else if (max_vma - min_vma < 0x200000)
+	    gp_val = min_vma;
+	  else
+	    gp_val = max_vma - 0x200000 + 8;
+	}
+
+      /* If it is possible to address the entire image, but we
+	 don't with the choice above, adjust.  */
+      if (max_vma - min_vma < 0x400000
+	  && (max_vma - gp_val >= 0x200000
+	      || gp_val - min_vma > 0x200000))
+	gp_val = min_vma + 0x200000;
+      else if (max_short_vma != 0)
+	{
+	  /* If we don't cover all the short data, adjust.  */
+	  if (max_short_vma - gp_val >= 0x200000)
+	    gp_val = min_short_vma + 0x200000;
+
+	  /* If we're addressing stuff past the end, adjust back.  */
+	  if (gp_val > max_vma)
+	    gp_val = max_vma - 0x200000 + 8;
+	}
+    }
+
+  /* Validate whether all SHF_IA_64_SHORT sections are within
+     range of the chosen GP.  */
+
+  if (max_short_vma != 0)
+    {
+      if (max_short_vma - min_short_vma >= 0x400000)
+	{
+overflow:
+	  (*_bfd_error_handler)
+	    (_("%s: short data segment overflowed (0x%lx >= 0x400000)"),
+	     bfd_get_filename (abfd),
+	     (unsigned long) (max_short_vma - min_short_vma));
+	  return FALSE;
+	}
+      else if ((gp_val > min_short_vma
+		&& gp_val - min_short_vma > 0x200000)
+	       || (gp_val < max_short_vma
+		   && max_short_vma - gp_val >= 0x200000))
+	{
+	  (*_bfd_error_handler)
+	    (_("%s: __gp does not cover short data segment"),
+	     bfd_get_filename (abfd));
+	  return FALSE;
+	}
+    }
+
+  _bfd_set_gp_value (abfd, gp_val);
+
+  return TRUE;
+}
+
+static bfd_boolean
+elf64_ia64_final_link (bfd *abfd, struct bfd_link_info *info)
+{
+  struct elf64_ia64_link_hash_table *ia64_info;
+  asection *unwind_output_sec;
+
+  ia64_info = elf64_ia64_hash_table (info);
+  if (ia64_info == NULL)
+    return FALSE;
+
+  /* Make sure we've got ourselves a nice fat __gp value.  */
+  if (!info->relocatable)
+    {
+      bfd_vma gp_val;
+      struct elf_link_hash_entry *gp;
+
+      /* We assume after gp is set, section size will only decrease. We
+	 need to adjust gp for it.  */
+      _bfd_set_gp_value (abfd, 0);
+      if (! elf64_ia64_choose_gp (abfd, info, TRUE))
+	return FALSE;
+      gp_val = _bfd_get_gp_value (abfd);
+
+      gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,
+			         FALSE, FALSE);
+      if (gp)
+	{
+	  gp->root.type = bfd_link_hash_defined;
+	  gp->root.u.def.value = gp_val;
+	  gp->root.u.def.section = bfd_abs_section_ptr;
+	}
+    }
+
+  /* If we're producing a final executable, we need to sort the contents
+     of the .IA_64.unwind section.  Force this section to be relocated
+     into memory rather than written immediately to the output file.  */
+  unwind_output_sec = NULL;
+  if (!info->relocatable)
+    {
+      asection *s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_unwind);
+      if (s)
+	{
+	  unwind_output_sec = s->output_section;
+	  unwind_output_sec->contents
+	    = bfd_malloc (unwind_output_sec->size);
+	  if (unwind_output_sec->contents == NULL)
+	    return FALSE;
+	}
+    }
+
+  /* Invoke the regular ELF backend linker to do all the work.  */
+  if (!bfd_elf_final_link (abfd, info))
+    return FALSE;
+
+  if (unwind_output_sec)
+    {
+      elf64_ia64_unwind_entry_compare_bfd = abfd;
+      qsort (unwind_output_sec->contents,
+	     (size_t) (unwind_output_sec->size / 24),
+	     24,
+	     elf64_ia64_unwind_entry_compare);
+
+      if (! bfd_set_section_contents (abfd, unwind_output_sec,
+				      unwind_output_sec->contents, (bfd_vma) 0,
+				      unwind_output_sec->size))
+	return FALSE;
+    }
+
+  return TRUE;
+}
+
+static bfd_boolean
+elf64_ia64_relocate_section (bfd *output_bfd,
+			     struct bfd_link_info *info,
+			     bfd *input_bfd,
+			     asection *input_section,
+			     bfd_byte *contents,
+			     Elf_Internal_Rela *relocs,
+			     Elf_Internal_Sym *local_syms,
+			     asection **local_sections)
+{
+  struct elf64_ia64_link_hash_table *ia64_info;
+  Elf_Internal_Shdr *symtab_hdr;
+  Elf_Internal_Rela *rel;
+  Elf_Internal_Rela *relend;
+  bfd_boolean ret_val = TRUE;	/* for non-fatal errors */
+  bfd_vma gp_val;
+
+  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+  ia64_info = elf64_ia64_hash_table (info);
+  if (ia64_info == NULL)
+    return FALSE;
+
+  /* Infect various flags from the input section to the output section.  */
+  if (info->relocatable)
+    {
+      bfd_vma flags;
+
+      flags = elf_section_data(input_section)->this_hdr.sh_flags;
+      flags &= SHF_IA_64_NORECOV;
+
+      elf_section_data(input_section->output_section)
+	->this_hdr.sh_flags |= flags;
+    }
+
+  gp_val = _bfd_get_gp_value (output_bfd);
+
+  rel = relocs;
+  relend = relocs + input_section->reloc_count;
+  for (; rel < relend; ++rel)
+    {
+      struct elf_link_hash_entry *h;
+      struct elf64_ia64_dyn_sym_info *dyn_i;
+      bfd_reloc_status_type r;
+      reloc_howto_type *howto;
+      unsigned long r_symndx;
+      Elf_Internal_Sym *sym;
+      unsigned int r_type;
+      bfd_vma value;
+      asection *sym_sec;
+      bfd_byte *hit_addr;
+      bfd_boolean dynamic_symbol_p;
+      bfd_boolean undef_weak_ref;
+
+      r_type = ELF64_R_TYPE (rel->r_info);
+      if (r_type > R_IA64_MAX_RELOC_CODE)
+	{
+	  (*_bfd_error_handler)
+	    (_("%B: unknown relocation type %d"),
+	     input_bfd, (int) r_type);
+	  bfd_set_error (bfd_error_bad_value);
+	  ret_val = FALSE;
+	  continue;
+	}
+
+      howto = ia64_elf_lookup_howto (r_type);
+      r_symndx = ELF64_R_SYM (rel->r_info);
+      h = NULL;
+      sym = NULL;
+      sym_sec = NULL;
+      undef_weak_ref = FALSE;
+
+      if (r_symndx < symtab_hdr->sh_info)
+	{
+	  /* Reloc against local symbol.  */
+	  asection *msec;
+	  sym = local_syms + r_symndx;
+	  sym_sec = local_sections[r_symndx];
+	  msec = sym_sec;
+	  value = _bfd_elf_rela_local_sym (output_bfd, sym, &msec, rel);
+	  if (!info->relocatable
+	      && (sym_sec->flags & SEC_MERGE) != 0
+	      && ELF_ST_TYPE (sym->st_info) == STT_SECTION
+	      && sym_sec->sec_info_type == ELF_INFO_TYPE_MERGE)
+	    {
+	      struct elf64_ia64_local_hash_entry *loc_h;
+
+	      loc_h = get_local_sym_hash (ia64_info, input_bfd, rel, FALSE);
+	      if (loc_h && ! loc_h->sec_merge_done)
+		{
+		  struct elf64_ia64_dyn_sym_info *dynent;
+		  unsigned int count;
+
+		  for (count = loc_h->count, dynent = loc_h->info;
+		       count != 0;
+		       count--, dynent++)
+		    {
+		      msec = sym_sec;
+		      dynent->addend =
+			_bfd_merged_section_offset (output_bfd, &msec,
+						    elf_section_data (msec)->
+						    sec_info,
+						    sym->st_value
+						    + dynent->addend);
+		      dynent->addend -= sym->st_value;
+		      dynent->addend += msec->output_section->vma
+					+ msec->output_offset
+					- sym_sec->output_section->vma
+					- sym_sec->output_offset;
+		    }
+
+		  /* We may have introduced duplicated entries. We need
+		     to remove them properly.  */
+		  count = sort_dyn_sym_info (loc_h->info, loc_h->count);
+		  if (count != loc_h->count)
+		    {
+		      loc_h->count = count;
+		      loc_h->sorted_count = count;
+		    }
+
+		  loc_h->sec_merge_done = 1;
+		}
+	    }
+	}
+      else
+	{
+	  bfd_boolean unresolved_reloc;
+	  bfd_boolean warned;
+	  struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
+
+	  RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
+				   r_symndx, symtab_hdr, sym_hashes,
+				   h, sym_sec, value,
+				   unresolved_reloc, warned);
+
+	  if (h->root.type == bfd_link_hash_undefweak)
+	    undef_weak_ref = TRUE;
+	  else if (warned)
+	    continue;
+	}
+
+      /* For relocs against symbols from removed linkonce sections,
+	 or sections discarded by a linker script, we just want the
+	 section contents zeroed.  Avoid any special processing.  */
+      if (sym_sec != NULL && elf_discarded_section (sym_sec))
+	RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
+					 rel, relend, howto, contents);
+
+      if (info->relocatable)
+	continue;
+
+      hit_addr = contents + rel->r_offset;
+      value += rel->r_addend;
+      dynamic_symbol_p = elf64_ia64_dynamic_symbol_p (h);
+
+      switch (r_type)
+	{
+	case R_IA64_NONE:
+	case R_IA64_LDXMOV:
+	  continue;
+
+	case R_IA64_IMM14:
+	case R_IA64_IMM22:
+	case R_IA64_IMM64:
+	case R_IA64_DIR32MSB:
+	case R_IA64_DIR32LSB:
+	case R_IA64_DIR64MSB:
+	case R_IA64_DIR64LSB:
+	  /* Install a dynamic relocation for this reloc.  */
+	  if ((dynamic_symbol_p || info->shared)
+	      && r_symndx != 0
+	      && (input_section->flags & SEC_ALLOC) != 0)
+	    {
+	      unsigned int dyn_r_type;
+	      bfd_vma addend;
+
+	      switch (r_type)
+		{
+		case R_IA64_IMM14:
+		case R_IA64_IMM22:
+		case R_IA64_IMM64:
+		  /* ??? People shouldn't be doing non-pic code in
+		     shared libraries nor dynamic executables.  */
+		  (*_bfd_error_handler)
+		    (_("%B: non-pic code with imm relocation against dynamic symbol `%s'"),
+		     input_bfd,
+		     h ? h->root.root.string
+		       : bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
+					   sym_sec));
+		  ret_val = FALSE;
+		  continue;
+
+		default:
+		  break;
+		}
+
+	      /* If we don't need dynamic symbol lookup, find a
+		 matching RELATIVE relocation.  */
+	      dyn_r_type = r_type;
+	      if (dynamic_symbol_p)
+		{
+		  addend = rel->r_addend;
+		  value = 0;
+		}
+	      else
+		{
+		  addend = value;
+		}
+
+              /* VMS: install a FIX64.  */
+              switch (dyn_r_type)
+                {
+                case R_IA64_DIR32LSB:
+                  dyn_r_type = R_IA64_VMS_FIX32;
+                  break;
+                case R_IA64_DIR64LSB:
+                  dyn_r_type = R_IA64_VMS_FIX64;
+                  break;
+                default:
+                  BFD_ASSERT (FALSE);
+                  break;
+                }
+              elf64_ia64_install_fixup
+                (output_bfd, ia64_info, h,
+                 dyn_r_type, input_section, rel->r_offset, addend);
+              r = bfd_reloc_ok;
+              break;
+	    }
+	  /* Fall through.  */
+
+	case R_IA64_LTV32MSB:
+	case R_IA64_LTV32LSB:
+	case R_IA64_LTV64MSB:
+	case R_IA64_LTV64LSB:
+	  r = ia64_elf_install_value (hit_addr, value, r_type);
+	  break;
+
+	case R_IA64_GPREL22:
+	case R_IA64_GPREL64I:
+	case R_IA64_GPREL32MSB:
+	case R_IA64_GPREL32LSB:
+	case R_IA64_GPREL64MSB:
+	case R_IA64_GPREL64LSB:
+	  if (dynamic_symbol_p)
+	    {
+	      (*_bfd_error_handler)
+		(_("%B: @gprel relocation against dynamic symbol %s"),
+		 input_bfd,
+		 h ? h->root.root.string
+		   : bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
+				       sym_sec));
+	      ret_val = FALSE;
+	      continue;
+	    }
+	  value -= gp_val;
+	  r = ia64_elf_install_value (hit_addr, value, r_type);
+	  break;
+
+	case R_IA64_LTOFF22:
+	case R_IA64_LTOFF22X:
+	case R_IA64_LTOFF64I:
+          dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
+	  value = set_got_entry (input_bfd, info, dyn_i,
+				 rel->r_addend, value, R_IA64_DIR64LSB);
+	  value -= gp_val;
+	  r = ia64_elf_install_value (hit_addr, value, r_type);
+	  break;
+
+	case R_IA64_PLTOFF22:
+	case R_IA64_PLTOFF64I:
+	case R_IA64_PLTOFF64MSB:
+	case R_IA64_PLTOFF64LSB:
+          dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
+	  value = set_pltoff_entry (output_bfd, info, dyn_i, value, FALSE);
+	  value -= gp_val;
+	  r = ia64_elf_install_value (hit_addr, value, r_type);
+	  break;
+
+	case R_IA64_FPTR64I:
+	case R_IA64_FPTR32MSB:
+	case R_IA64_FPTR32LSB:
+	case R_IA64_FPTR64MSB:
+	case R_IA64_FPTR64LSB:
+          dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
+	  if (dyn_i->want_fptr)
+	    {
+	      if (!undef_weak_ref)
+		value = set_fptr_entry (output_bfd, info, dyn_i, value);
+	    }
+	  if (!dyn_i->want_fptr || info->pie)
+	    {
+	      /* Otherwise, we expect the dynamic linker to create
+		 the entry.  */
+
+	      if (dyn_i->want_fptr)
+		{
+		  if (r_type == R_IA64_FPTR64I)
+		    {
+		      /* We can't represent this without a dynamic symbol.
+			 Adjust the relocation to be against an output
+			 section symbol, which are always present in the
+			 dynamic symbol table.  */
+		      /* ??? People shouldn't be doing non-pic code in
+			 shared libraries.  Hork.  */
+		      (*_bfd_error_handler)
+			(_("%B: linking non-pic code in a position independent executable"),
+			 input_bfd);
+		      ret_val = FALSE;
+		      continue;
+		    }
+		}
+	      else
+		{
+		  value = 0;
+		}
+
+              /* VMS: FIXFD.  */
+              elf64_ia64_install_fixup
+                (output_bfd, ia64_info, h, R_IA64_VMS_FIXFD,
+                 input_section, rel->r_offset, 0);
+              r = bfd_reloc_ok;
+              break;
+	    }
+
+	  r = ia64_elf_install_value (hit_addr, value, r_type);
+	  break;
+
+	case R_IA64_LTOFF_FPTR22:
+	case R_IA64_LTOFF_FPTR64I:
+	case R_IA64_LTOFF_FPTR32MSB:
+	case R_IA64_LTOFF_FPTR32LSB:
+	case R_IA64_LTOFF_FPTR64MSB:
+	case R_IA64_LTOFF_FPTR64LSB:
+          dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
+          if (dyn_i->want_fptr)
+            {
+              BFD_ASSERT (h == NULL || !h->def_dynamic);
+              if (!undef_weak_ref)
+                value = set_fptr_entry (output_bfd, info, dyn_i, value);
+            }
+          else
+            value = 0;
+
+          value = set_got_entry (output_bfd, info, dyn_i,
+                                 rel->r_addend, value, R_IA64_FPTR64LSB);
+          value -= gp_val;
+          r = ia64_elf_install_value (hit_addr, value, r_type);
+	  break;
+
+	case R_IA64_PCREL32MSB:
+	case R_IA64_PCREL32LSB:
+	case R_IA64_PCREL64MSB:
+	case R_IA64_PCREL64LSB:
+	  /* Install a dynamic relocation for this reloc.  */
+	  if (dynamic_symbol_p && r_symndx != 0)
+	    {
+              /* VMS: doesn't exist ???  */
+              abort ();
+	    }
+	  goto finish_pcrel;
+
+	case R_IA64_PCREL21B:
+	case R_IA64_PCREL60B:
+	  /* We should have created a PLT entry for any dynamic symbol.  */
+	  dyn_i = NULL;
+	  if (h)
+	    dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, FALSE);
+
+	  if (dyn_i && dyn_i->want_plt2)
+	    {
+	      /* Should have caught this earlier.  */
+	      BFD_ASSERT (rel->r_addend == 0);
+
+	      value = (ia64_info->root.splt->output_section->vma
+		       + ia64_info->root.splt->output_offset
+		       + dyn_i->plt2_offset);
+	    }
+	  else
+	    {
+	      /* Since there's no PLT entry, Validate that this is
+		 locally defined.  */
+	      BFD_ASSERT (undef_weak_ref || sym_sec->output_section != NULL);
+
+	      /* If the symbol is undef_weak, we shouldn't be trying
+		 to call it.  There's every chance that we'd wind up
+		 with an out-of-range fixup here.  Don't bother setting
+		 any value at all.  */
+	      if (undef_weak_ref)
+		continue;
+	    }
+	  goto finish_pcrel;
+
+	case R_IA64_PCREL21BI:
+	case R_IA64_PCREL21F:
+	case R_IA64_PCREL21M:
+	case R_IA64_PCREL22:
+	case R_IA64_PCREL64I:
+	  /* The PCREL21BI reloc is specifically not intended for use with
+	     dynamic relocs.  PCREL21F and PCREL21M are used for speculation
+	     fixup code, and thus probably ought not be dynamic.  The
+	     PCREL22 and PCREL64I relocs aren't emitted as dynamic relocs.  */
+	  if (dynamic_symbol_p)
+	    {
+	      const char *msg;
+
+	      if (r_type == R_IA64_PCREL21BI)
+		msg = _("%B: @internal branch to dynamic symbol %s");
+	      else if (r_type == R_IA64_PCREL21F || r_type == R_IA64_PCREL21M)
+		msg = _("%B: speculation fixup to dynamic symbol %s");
+	      else
+		msg = _("%B: @pcrel relocation against dynamic symbol %s");
+	      (*_bfd_error_handler) (msg, input_bfd,
+				     h ? h->root.root.string
+				       : bfd_elf_sym_name (input_bfd,
+							   symtab_hdr,
+							   sym,
+							   sym_sec));
+	      ret_val = FALSE;
+	      continue;
+	    }
+	  goto finish_pcrel;
+
+	finish_pcrel:
+	  /* Make pc-relative.  */
+	  value -= (input_section->output_section->vma
+		    + input_section->output_offset
+		    + rel->r_offset) & ~ (bfd_vma) 0x3;
+	  r = ia64_elf_install_value (hit_addr, value, r_type);
+	  break;
+
+	case R_IA64_SEGREL32MSB:
+	case R_IA64_SEGREL32LSB:
+	case R_IA64_SEGREL64MSB:
+	case R_IA64_SEGREL64LSB:
+	    {
+	      /* Find the segment that contains the output_section.  */
+	      Elf_Internal_Phdr *p = _bfd_elf_find_segment_containing_section
+		(output_bfd, sym_sec->output_section);
+
+	      if (p == NULL)
+		{
+		  r = bfd_reloc_notsupported;
+		}
+	      else
+		{
+		  /* The VMA of the segment is the vaddr of the associated
+		     program header.  */
+		  if (value > p->p_vaddr)
+		    value -= p->p_vaddr;
+		  else
+		    value = 0;
+		  r = ia64_elf_install_value (hit_addr, value, r_type);
+		}
+	      break;
+	    }
+
+	case R_IA64_SECREL32MSB:
+	case R_IA64_SECREL32LSB:
+	case R_IA64_SECREL64MSB:
+	case R_IA64_SECREL64LSB:
+	  /* Make output-section relative to section where the symbol
+	     is defined. PR 475  */
+	  if (sym_sec)
+	    value -= sym_sec->output_section->vma;
+	  r = ia64_elf_install_value (hit_addr, value, r_type);
+	  break;
+
+	case R_IA64_IPLTMSB:
+	case R_IA64_IPLTLSB:
+	  /* Install a dynamic relocation for this reloc.  */
+	  if ((dynamic_symbol_p || info->shared)
+	      && (input_section->flags & SEC_ALLOC) != 0)
+	    {
+              /* VMS: FIXFD ??  */
+              abort ();
+	    }
+
+	  if (r_type == R_IA64_IPLTMSB)
+	    r_type = R_IA64_DIR64MSB;
+	  else
+	    r_type = R_IA64_DIR64LSB;
+	  ia64_elf_install_value (hit_addr, value, r_type);
+	  r = ia64_elf_install_value (hit_addr + 8, gp_val, r_type);
+	  break;
+
+	case R_IA64_TPREL14:
+	case R_IA64_TPREL22:
+	case R_IA64_TPREL64I:
+	  r = bfd_reloc_notsupported;
+	  break;
+
+	case R_IA64_DTPREL14:
+	case R_IA64_DTPREL22:
+	case R_IA64_DTPREL64I:
+	case R_IA64_DTPREL32LSB:
+	case R_IA64_DTPREL32MSB:
+	case R_IA64_DTPREL64LSB:
+	case R_IA64_DTPREL64MSB:
+	  r = bfd_reloc_notsupported;
+	  break;
+
+	case R_IA64_LTOFF_TPREL22:
+	case R_IA64_LTOFF_DTPMOD22:
+	case R_IA64_LTOFF_DTPREL22:
+	  r = bfd_reloc_notsupported;
+	  break;
+
+	default:
+	  r = bfd_reloc_notsupported;
+	  break;
+	}
+
+      switch (r)
+	{
+	case bfd_reloc_ok:
+	  break;
+
+	case bfd_reloc_undefined:
+	  /* This can happen for global table relative relocs if
+	     __gp is undefined.  This is a panic situation so we
+	     don't try to continue.  */
+	  (*info->callbacks->undefined_symbol)
+	    (info, "__gp", input_bfd, input_section, rel->r_offset, 1);
+	  return FALSE;
+
+	case bfd_reloc_notsupported:
+	  {
+	    const char *name;
+
+	    if (h)
+	      name = h->root.root.string;
+	    else
+	      name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
+				       sym_sec);
+	    if (!(*info->callbacks->warning) (info, _("unsupported reloc"),
+					      name, input_bfd,
+					      input_section, rel->r_offset))
+	      return FALSE;
+	    ret_val = FALSE;
+	  }
+	  break;
+
+	case bfd_reloc_dangerous:
+	case bfd_reloc_outofrange:
+	case bfd_reloc_overflow:
+	default:
+	  {
+	    const char *name;
+
+	    if (h)
+	      name = h->root.root.string;
+	    else
+	      name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
+				       sym_sec);
+
+	    switch (r_type)
+	      {
+	      case R_IA64_TPREL14:
+	      case R_IA64_TPREL22:
+	      case R_IA64_TPREL64I:
+	      case R_IA64_DTPREL14:
+	      case R_IA64_DTPREL22:
+	      case R_IA64_DTPREL64I:
+	      case R_IA64_DTPREL32LSB:
+	      case R_IA64_DTPREL32MSB:
+	      case R_IA64_DTPREL64LSB:
+	      case R_IA64_DTPREL64MSB:
+	      case R_IA64_LTOFF_TPREL22:
+	      case R_IA64_LTOFF_DTPMOD22:
+	      case R_IA64_LTOFF_DTPREL22:
+		(*_bfd_error_handler)
+		  (_("%B: missing TLS section for relocation %s against `%s' at 0x%lx in section `%A'."),
+		   input_bfd, input_section, howto->name, name,
+		   rel->r_offset);
+		break;
+
+	      case R_IA64_PCREL21B:
+	      case R_IA64_PCREL21BI:
+	      case R_IA64_PCREL21M:
+	      case R_IA64_PCREL21F:
+		if (is_elf_hash_table (info->hash))
+		  {
+		    /* Relaxtion is always performed for ELF output.
+		       Overflow failures for those relocations mean
+		       that the section is too big to relax.  */
+		    (*_bfd_error_handler)
+		      (_("%B: Can't relax br (%s) to `%s' at 0x%lx in section `%A' with size 0x%lx (> 0x1000000)."),
+		       input_bfd, input_section, howto->name, name,
+		       rel->r_offset, input_section->size);
+		    break;
+		  }
+	      default:
+		if (!(*info->callbacks->reloc_overflow) (info,
+							 &h->root,
+							 name,
+							 howto->name,
+							 (bfd_vma) 0,
+							 input_bfd,
+							 input_section,
+							 rel->r_offset))
+		  return FALSE;
+		break;
+	      }
+
+	    ret_val = FALSE;
+	  }
+	  break;
+	}
+    }
+
+  return ret_val;
+}
+
+static bfd_boolean
+elf64_ia64_finish_dynamic_symbol (bfd *output_bfd,
+				  struct bfd_link_info *info,
+				  struct elf_link_hash_entry *h,
+				  Elf_Internal_Sym *sym)
+{
+  struct elf64_ia64_link_hash_table *ia64_info;
+  struct elf64_ia64_dyn_sym_info *dyn_i;
+
+  ia64_info = elf64_ia64_hash_table (info);
+  if (ia64_info == NULL)
+    return FALSE;
+
+  dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, FALSE);
+
+  /* Fill in the PLT data, if required.  */
+  if (dyn_i && dyn_i->want_plt)
+    {
+      bfd_byte *loc;
+      asection *plt_sec;
+      bfd_vma plt_addr, pltoff_addr, gp_val;
+
+      gp_val = _bfd_get_gp_value (output_bfd);
+
+      plt_sec = ia64_info->root.splt;
+      plt_addr = 0;  /* Not used as overriden by FIXUPs.  */
+      pltoff_addr = set_pltoff_entry (output_bfd, info, dyn_i, plt_addr, TRUE);
+
+      /* Initialize the FULL PLT entry, if needed.  */
+      if (dyn_i->want_plt2)
+	{
+	  loc = plt_sec->contents + dyn_i->plt2_offset;
+
+	  memcpy (loc, plt_full_entry, PLT_FULL_ENTRY_SIZE);
+	  ia64_elf_install_value (loc, pltoff_addr - gp_val, R_IA64_IMM22);
+
+	  /* Mark the symbol as undefined, rather than as defined in the
+	     plt section.  Leave the value alone.  */
+	  /* ??? We didn't redefine it in adjust_dynamic_symbol in the
+	     first place.  But perhaps elflink.c did some for us.  */
+	  if (!h->def_regular)
+	    sym->st_shndx = SHN_UNDEF;
+	}
+
+      /* VMS: FIXFD.  */
+      elf64_ia64_install_fixup
+        (output_bfd, ia64_info, h, R_IA64_VMS_FIXFD, ia64_info->pltoff_sec,
+         pltoff_addr - (ia64_info->pltoff_sec->output_section->vma
+                        + ia64_info->pltoff_sec->output_offset), 0);
+    }
+
+  /* Mark some specially defined symbols as absolute.  */
+  if (strcmp (h->root.root.string, "_DYNAMIC") == 0
+      || h == ia64_info->root.hgot
+      || h == ia64_info->root.hplt)
+    sym->st_shndx = SHN_ABS;
+
+  return TRUE;
+}
+
+static bfd_boolean
+elf64_ia64_finish_dynamic_sections (bfd *abfd,
+				    struct bfd_link_info *info)
+{
+  struct elf64_ia64_link_hash_table *ia64_info;
+  bfd *dynobj;
+
+  ia64_info = elf64_ia64_hash_table (info);
+  if (ia64_info == NULL)
+    return FALSE;
+
+  dynobj = ia64_info->root.dynobj;
+
+  if (elf_hash_table (info)->dynamic_sections_created)
+    {
+      Elf64_External_Dyn *dyncon, *dynconend;
+      asection *sdyn;
+      asection *unwind_sec;
+      bfd_vma gp_val;
+      unsigned int gp_seg;
+      bfd_vma gp_off;
+      Elf_Internal_Phdr *phdr;
+      Elf_Internal_Phdr *base_phdr;
+      unsigned int unwind_seg = 0;
+      unsigned int code_seg = 0;
+
+      sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
+      BFD_ASSERT (sdyn != NULL);
+      dyncon = (Elf64_External_Dyn *) sdyn->contents;
+      dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
+
+      gp_val = _bfd_get_gp_value (abfd);
+      phdr = _bfd_elf_find_segment_containing_section
+        (info->output_bfd, ia64_info->pltoff_sec->output_section);
+      BFD_ASSERT (phdr != NULL);
+      base_phdr = elf_tdata (info->output_bfd)->phdr;
+      gp_seg = phdr - base_phdr;
+      gp_off = gp_val - phdr->p_vaddr;
+
+      unwind_sec = bfd_get_section_by_name (abfd, ELF_STRING_ia64_unwind);
+      if (unwind_sec != NULL)
+        {
+          asection *code_sec;
+
+          phdr = _bfd_elf_find_segment_containing_section (abfd, unwind_sec);
+          BFD_ASSERT (phdr != NULL);
+          unwind_seg = phdr - base_phdr;
+
+          code_sec = bfd_get_section_by_name (abfd, "$CODE$");
+          phdr = _bfd_elf_find_segment_containing_section (abfd, code_sec);
+          BFD_ASSERT (phdr != NULL);
+          code_seg = phdr - base_phdr;
+        }
+
+      for (; dyncon < dynconend; dyncon++)
+	{
+	  Elf_Internal_Dyn dyn;
+
+	  bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
+
+	  switch (dyn.d_tag)
+	    {
+            case DT_IA_64_VMS_FIXUP_RELA_OFF:
+              dyn.d_un.d_val +=
+                (ia64_info->fixups_sec->output_section->vma
+                 + ia64_info->fixups_sec->output_offset)
+                - (sdyn->output_section->vma + sdyn->output_offset);
+              break;
+
+            case DT_IA_64_VMS_PLTGOT_OFFSET:
+              dyn.d_un.d_val = gp_off;
+              break;
+
+            case DT_IA_64_VMS_PLTGOT_SEG:
+              dyn.d_un.d_val = gp_seg;
+              break;
+
+            case DT_IA_64_VMS_UNWINDSZ:
+              if (unwind_sec == NULL)
+                {
+                  dyn.d_tag = DT_NULL;
+                  dyn.d_un.d_val = 0xdead;
+                }
+              else
+                dyn.d_un.d_val = unwind_sec->size;
+              break;
+
+            case DT_IA_64_VMS_UNWIND_CODSEG:
+              dyn.d_un.d_val = code_seg;
+              break;
+
+            case DT_IA_64_VMS_UNWIND_INFOSEG:
+            case DT_IA_64_VMS_UNWIND_SEG:
+              dyn.d_un.d_val = unwind_seg;
+              break;
+
+            case DT_IA_64_VMS_UNWIND_OFFSET:
+              break;
+
+            default:
+              /* No need to rewrite the entry.  */
+              continue;
+	    }
+
+	  bfd_elf64_swap_dyn_out (abfd, &dyn, dyncon);
+	}
+    }
+
+  /* Handle transfer addresses.  */
+  {
+    asection *tfr_sec = ia64_info->transfer_sec;
+    struct elf64_vms_transfer *tfr;
+    struct elf_link_hash_entry *tfr3;
+
+    tfr = (struct elf64_vms_transfer *)tfr_sec->contents;
+    bfd_putl32 (6 * 8, tfr->size);
+    bfd_putl64 (tfr_sec->output_section->vma
+                + tfr_sec->output_offset
+                + 6 * 8, tfr->tfradr3);
+
+    tfr3 = elf_link_hash_lookup (elf_hash_table (info), "ELF$TFRADR", FALSE,
+                                 FALSE, FALSE);
+
+    if (tfr3
+        && (tfr3->root.type == bfd_link_hash_defined
+            || tfr3->root.type == bfd_link_hash_defweak))
+      {
+        asection *tfr3_sec = tfr3->root.u.def.section;
+        bfd_vma tfr3_val;
+
+        tfr3_val = (tfr3->root.u.def.value
+                    + tfr3_sec->output_section->vma
+                    + tfr3_sec->output_offset);
+
+        bfd_putl64 (tfr3_val, tfr->tfr3_func);
+        bfd_putl64 (_bfd_get_gp_value (info->output_bfd), tfr->tfr3_gp);
+      }
+
+    /* FIXME: set linker flags,
+       handle lib$initialize.  */
+  }
+
+  return TRUE;
+}
+
+/* ELF file flag handling:  */
+
+/* Function to keep IA-64 specific file flags.  */
+static bfd_boolean
+elf64_ia64_set_private_flags (bfd *abfd, flagword flags)
+{
+  BFD_ASSERT (!elf_flags_init (abfd)
+	      || elf_elfheader (abfd)->e_flags == flags);
+
+  elf_elfheader (abfd)->e_flags = flags;
+  elf_flags_init (abfd) = TRUE;
+  return TRUE;
+}
+
+/* Merge backend specific data from an object file to the output
+   object file when linking.  */
+static bfd_boolean
+elf64_ia64_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
+{
+  flagword out_flags;
+  flagword in_flags;
+  bfd_boolean ok = TRUE;
+
+  /* Don't even pretend to support mixed-format linking.  */
+  if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
+      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
+    return FALSE;
+
+  in_flags  = elf_elfheader (ibfd)->e_flags;
+  out_flags = elf_elfheader (obfd)->e_flags;
+
+  if (! elf_flags_init (obfd))
+    {
+      elf_flags_init (obfd) = TRUE;
+      elf_elfheader (obfd)->e_flags = in_flags;
+
+      if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
+	  && bfd_get_arch_info (obfd)->the_default)
+	{
+	  return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
+				    bfd_get_mach (ibfd));
+	}
+
+      return TRUE;
+    }
+
+  /* Check flag compatibility.  */
+  if (in_flags == out_flags)
+    return TRUE;
+
+  /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set.  */
+  if (!(in_flags & EF_IA_64_REDUCEDFP) && (out_flags & EF_IA_64_REDUCEDFP))
+    elf_elfheader (obfd)->e_flags &= ~EF_IA_64_REDUCEDFP;
+
+  if ((in_flags & EF_IA_64_TRAPNIL) != (out_flags & EF_IA_64_TRAPNIL))
+    {
+      (*_bfd_error_handler)
+	(_("%B: linking trap-on-NULL-dereference with non-trapping files"),
+	 ibfd);
+
+      bfd_set_error (bfd_error_bad_value);
+      ok = FALSE;
+    }
+  if ((in_flags & EF_IA_64_BE) != (out_flags & EF_IA_64_BE))
+    {
+      (*_bfd_error_handler)
+	(_("%B: linking big-endian files with little-endian files"),
+	 ibfd);
+
+      bfd_set_error (bfd_error_bad_value);
+      ok = FALSE;
+    }
+  if ((in_flags & EF_IA_64_ABI64) != (out_flags & EF_IA_64_ABI64))
+    {
+      (*_bfd_error_handler)
+	(_("%B: linking 64-bit files with 32-bit files"),
+	 ibfd);
+
+      bfd_set_error (bfd_error_bad_value);
+      ok = FALSE;
+    }
+  if ((in_flags & EF_IA_64_CONS_GP) != (out_flags & EF_IA_64_CONS_GP))
+    {
+      (*_bfd_error_handler)
+	(_("%B: linking constant-gp files with non-constant-gp files"),
+	 ibfd);
+
+      bfd_set_error (bfd_error_bad_value);
+      ok = FALSE;
+    }
+  if ((in_flags & EF_IA_64_NOFUNCDESC_CONS_GP)
+      != (out_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
+    {
+      (*_bfd_error_handler)
+	(_("%B: linking auto-pic files with non-auto-pic files"),
+	 ibfd);
+
+      bfd_set_error (bfd_error_bad_value);
+      ok = FALSE;
+    }
+
+  return ok;
+}
+
+static bfd_boolean
+elf64_ia64_print_private_bfd_data (bfd *abfd, void * ptr)
+{
+  FILE *file = (FILE *) ptr;
+  flagword flags = elf_elfheader (abfd)->e_flags;
+
+  BFD_ASSERT (abfd != NULL && ptr != NULL);
+
+  fprintf (file, "private flags = %s%s%s%s%s%s%s%s\n",
+	   (flags & EF_IA_64_TRAPNIL) ? "TRAPNIL, " : "",
+	   (flags & EF_IA_64_EXT) ? "EXT, " : "",
+	   (flags & EF_IA_64_BE) ? "BE, " : "LE, ",
+	   (flags & EF_IA_64_REDUCEDFP) ? "REDUCEDFP, " : "",
+	   (flags & EF_IA_64_CONS_GP) ? "CONS_GP, " : "",
+	   (flags & EF_IA_64_NOFUNCDESC_CONS_GP) ? "NOFUNCDESC_CONS_GP, " : "",
+	   (flags & EF_IA_64_ABSOLUTE) ? "ABSOLUTE, " : "",
+	   (flags & EF_IA_64_ABI64) ? "ABI64" : "ABI32");
+
+  _bfd_elf_print_private_bfd_data (abfd, ptr);
+  return TRUE;
+}
+
+static enum elf_reloc_type_class
+elf64_ia64_reloc_type_class (const Elf_Internal_Rela *rela)
+{
+  switch ((int) ELF64_R_TYPE (rela->r_info))
+    {
+    case R_IA64_REL32MSB:
+    case R_IA64_REL32LSB:
+    case R_IA64_REL64MSB:
+    case R_IA64_REL64LSB:
+      return reloc_class_relative;
+    case R_IA64_IPLTMSB:
+    case R_IA64_IPLTLSB:
+      return reloc_class_plt;
+    case R_IA64_COPY:
+      return reloc_class_copy;
+    default:
+      return reloc_class_normal;
+    }
+}
+
+static const struct bfd_elf_special_section elf64_ia64_special_sections[] =
+{
+  { STRING_COMMA_LEN (".sbss"),  -1, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT },
+  { STRING_COMMA_LEN (".sdata"), -1, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT },
+  { NULL,                    0,   0, 0,            0 }
+};
+
+static bfd_boolean
+elf64_ia64_object_p (bfd *abfd)
+{
+  asection *sec;
+  asection *group, *unwi, *unw;
+  flagword flags;
+  const char *name;
+  char *unwi_name, *unw_name;
+  bfd_size_type amt;
+
+  if (abfd->flags & DYNAMIC)
+    return TRUE;
+
+  /* Flags for fake group section.  */
+  flags = (SEC_LINKER_CREATED | SEC_GROUP | SEC_LINK_ONCE
+	   | SEC_EXCLUDE);
+
+  /* We add a fake section group for each .gnu.linkonce.t.* section,
+     which isn't in a section group, and its unwind sections.  */
+  for (sec = abfd->sections; sec != NULL; sec = sec->next)
+    {
+      if (elf_sec_group (sec) == NULL
+	  && ((sec->flags & (SEC_LINK_ONCE | SEC_CODE | SEC_GROUP))
+	      == (SEC_LINK_ONCE | SEC_CODE))
+	  && CONST_STRNEQ (sec->name, ".gnu.linkonce.t."))
+	{
+	  name = sec->name + 16;
+
+	  amt = strlen (name) + sizeof (".gnu.linkonce.ia64unwi.");
+	  unwi_name = bfd_alloc (abfd, amt);
+	  if (!unwi_name)
+	    return FALSE;
+
+	  strcpy (stpcpy (unwi_name, ".gnu.linkonce.ia64unwi."), name);
+	  unwi = bfd_get_section_by_name (abfd, unwi_name);
+
+	  amt = strlen (name) + sizeof (".gnu.linkonce.ia64unw.");
+	  unw_name = bfd_alloc (abfd, amt);
+	  if (!unw_name)
+	    return FALSE;
+
+	  strcpy (stpcpy (unw_name, ".gnu.linkonce.ia64unw."), name);
+	  unw = bfd_get_section_by_name (abfd, unw_name);
+
+	  /* We need to create a fake group section for it and its
+	     unwind sections.  */
+	  group = bfd_make_section_anyway_with_flags (abfd, name,
+						      flags);
+	  if (group == NULL)
+	    return FALSE;
+
+	  /* Move the fake group section to the beginning.  */
+	  bfd_section_list_remove (abfd, group);
+	  bfd_section_list_prepend (abfd, group);
+
+	  elf_next_in_group (group) = sec;
+
+	  elf_group_name (sec) = name;
+	  elf_next_in_group (sec) = sec;
+	  elf_sec_group (sec) = group;
+
+	  if (unwi)
+	    {
+	      elf_group_name (unwi) = name;
+	      elf_next_in_group (unwi) = sec;
+	      elf_next_in_group (sec) = unwi;
+	      elf_sec_group (unwi) = group;
+	    }
+
+	   if (unw)
+	     {
+	       elf_group_name (unw) = name;
+	       if (unwi)
+		 {
+		   elf_next_in_group (unw) = elf_next_in_group (unwi);
+		   elf_next_in_group (unwi) = unw;
+		 }
+	       else
+		 {
+		   elf_next_in_group (unw) = sec;
+		   elf_next_in_group (sec) = unw;
+		 }
+	       elf_sec_group (unw) = group;
+	     }
+
+	   /* Fake SHT_GROUP section header.  */
+	  elf_section_data (group)->this_hdr.bfd_section = group;
+	  elf_section_data (group)->this_hdr.sh_type = SHT_GROUP;
+	}
+    }
+  return TRUE;
+}
+
+/* Handle an IA-64 specific section when reading an object file.  This
+   is called when bfd_section_from_shdr finds a section with an unknown
+   type.  */
+
+static bfd_boolean
+elf64_vms_section_from_shdr (bfd *abfd,
+			     Elf_Internal_Shdr *hdr,
+			     const char *name,
+			     int shindex)
+{
+  flagword secflags = 0;
+
+  switch (hdr->sh_type)
+    {
+    case SHT_IA_64_VMS_TRACE:
+    case SHT_IA_64_VMS_DEBUG:
+    case SHT_IA_64_VMS_DEBUG_STR:
+      secflags = SEC_DEBUGGING;
+      break;
+
+    case SHT_IA_64_UNWIND:
+    case SHT_IA_64_HP_OPT_ANOT:
+      break;
+
+    case SHT_IA_64_EXT:
+      if (strcmp (name, ELF_STRING_ia64_archext) != 0)
+	return FALSE;
+      break;
+
+    default:
+      return FALSE;
+    }
+
+  if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
+    return FALSE;
+
+  if (secflags != 0)
+    {
+      asection *newsect = hdr->bfd_section;
+
+      if (! bfd_set_section_flags
+          (abfd, newsect, bfd_get_section_flags (abfd, newsect) | secflags))
+	return FALSE;
+    }
+
+  return TRUE;
+}
+
+static bfd_boolean
+elf64_vms_object_p (bfd *abfd)
+{
+  Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
+  Elf_Internal_Phdr *i_phdr = elf_tdata (abfd)->phdr;
+  unsigned int i;
+  unsigned int num_text = 0;
+  unsigned int num_data = 0;
+  unsigned int num_rodata = 0;
+  char name[16];
+
+  if (!elf64_ia64_object_p (abfd))
+    return FALSE;
+
+  /* Many VMS compilers do not generate sections for the corresponding
+     segment.  This is boring as binutils tools won't be able to disassemble
+     the code.  So we simply create all the missing sections.  */
+  for (i = 0; i < i_ehdrp->e_phnum; i++, i_phdr++)
+    {
+      /* Is there a section for this segment?  */
+      bfd_vma base_vma = i_phdr->p_vaddr;
+      bfd_vma limit_vma = base_vma + i_phdr->p_filesz;
+
+      if (i_phdr->p_type != PT_LOAD)
+	continue;
+
+      /* We need to cover from base_vms to limit_vma.  */
+    again:
+      while (base_vma < limit_vma)
+	{
+	  bfd_vma next_vma = limit_vma;
+	  asection *nsec;
+	  asection *sec;
+	  flagword flags;
+	  char *nname = NULL;
+
+	  /* Find a section covering [base_vma;limit_vma)  */
+	  for (sec = abfd->sections; sec != NULL; sec = sec->next)
+	    {
+	      /* Skip uninteresting sections (either not in memory or
+		 below base_vma.  */
+	      if ((sec->flags & (SEC_ALLOC | SEC_LOAD)) == 0
+		  || sec->vma + sec->size <= base_vma)
+		continue;
+	      if (sec->vma <= base_vma)
+		{
+		  /* This section covers (maybe partially) the beginning
+		     of the range.  */
+		  base_vma = sec->vma + sec->size;
+		  goto again;
+		}
+	      if (sec->vma < next_vma)
+		{
+		  /* This section partially covers the end of the range.
+		     Used to compute the size of the hole.  */
+		  next_vma = sec->vma;
+		}
+	    }
+
+	  /* No section covering [base_vma; next_vma).  Create a fake one.  */
+	  flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS;
+	  if (i_phdr->p_flags & PF_X)
+	    {
+	      flags |= SEC_CODE;
+	      if (num_text++ == 0)
+		nname = ".text";
+	      else
+		sprintf (name, ".text$%u", num_text);
+	    }
+	  else if ((i_phdr->p_flags & (PF_R | PF_W)) == PF_R)
+	    {
+	      flags |= SEC_READONLY;
+	      sprintf (name, ".rodata$%u", num_rodata++);
+	    }
+	  else
+	    {
+	      flags |= SEC_DATA;
+	      sprintf (name, ".data$%u", num_data++);
+	    }
+
+	  /* Allocate name.  */
+	  if (nname == NULL)
+	    {
+	      size_t name_len = strlen (name) + 1;
+	      nname = bfd_alloc (abfd, name_len);
+	      if (nname == NULL)
+		return FALSE;
+	      memcpy (nname, name, name_len);
+	    }
+
+	  /* Create and fill new section.  */
+	  nsec = bfd_make_section_anyway_with_flags (abfd, nname, flags);
+	  if (nsec == NULL)
+	    return FALSE;
+	  nsec->vma = base_vma;
+	  nsec->size = next_vma - base_vma;
+	  nsec->filepos = i_phdr->p_offset + (base_vma - i_phdr->p_vaddr);
+
+	  base_vma = next_vma;
+	}
+    }
+  return TRUE;
+}
+
+static void
+elf64_vms_post_process_headers (bfd *abfd,
+				struct bfd_link_info *info ATTRIBUTE_UNUSED)
+{
+  Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
+
+  i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_OPENVMS;
+  i_ehdrp->e_ident[EI_ABIVERSION] = 2;
+}
+
+static bfd_boolean
+elf64_vms_section_processing (bfd *abfd ATTRIBUTE_UNUSED,
+			      Elf_Internal_Shdr *hdr)
+{
+  if (hdr->bfd_section != NULL)
+    {
+      const char *name = bfd_get_section_name (abfd, hdr->bfd_section);
+
+      if (strcmp (name, ".text") == 0)
+	hdr->sh_flags |= SHF_IA_64_VMS_SHARED;
+      else if ((strcmp (name, ".debug") == 0)
+	    || (strcmp (name, ".debug_abbrev") == 0)
+	    || (strcmp (name, ".debug_aranges") == 0)
+	    || (strcmp (name, ".debug_frame") == 0)
+	    || (strcmp (name, ".debug_info") == 0)
+	    || (strcmp (name, ".debug_loc") == 0)
+	    || (strcmp (name, ".debug_macinfo") == 0)
+	    || (strcmp (name, ".debug_pubnames") == 0)
+	    || (strcmp (name, ".debug_pubtypes") == 0))
+	hdr->sh_type = SHT_IA_64_VMS_DEBUG;
+      else if ((strcmp (name, ".debug_line") == 0)
+	    || (strcmp (name, ".debug_ranges") == 0)
+	    || (strcmp (name, ".trace_info") == 0)
+	    || (strcmp (name, ".trace_abbrev") == 0)
+	    || (strcmp (name, ".trace_aranges") == 0))
+	hdr->sh_type = SHT_IA_64_VMS_TRACE;
+      else if (strcmp (name, ".debug_str") == 0)
+	hdr->sh_type = SHT_IA_64_VMS_DEBUG_STR;
+    }
+
+  return TRUE;
+}
+
+/* The final processing done just before writing out a VMS IA-64 ELF
+   object file.  */
+
+static void
+elf64_vms_final_write_processing (bfd *abfd,
+				  bfd_boolean linker ATTRIBUTE_UNUSED)
+{
+  Elf_Internal_Shdr *hdr;
+  asection *s;
+  int unwind_info_sect_idx = 0;
+
+  for (s = abfd->sections; s; s = s->next)
+    {
+      hdr = &elf_section_data (s)->this_hdr;
+
+      if (strcmp (bfd_get_section_name (abfd, hdr->bfd_section),
+		  ".IA_64.unwind_info") == 0)
+	unwind_info_sect_idx = elf_section_data (s)->this_idx;
+
+      switch (hdr->sh_type)
+	{
+	case SHT_IA_64_UNWIND:
+	  /* VMS requires sh_info to point to the unwind info section.  */
+          hdr->sh_info = unwind_info_sect_idx;
+	  break;
+	}
+    }
+
+  if (! elf_flags_init (abfd))
+    {
+      unsigned long flags = 0;
+
+      if (abfd->xvec->byteorder == BFD_ENDIAN_BIG)
+	flags |= EF_IA_64_BE;
+      if (bfd_get_mach (abfd) == bfd_mach_ia64_elf64)
+	flags |= EF_IA_64_ABI64;
+
+      elf_elfheader (abfd)->e_flags = flags;
+      elf_flags_init (abfd) = TRUE;
+    }
+}
+
+static bfd_boolean
+elf64_vms_write_shdrs_and_ehdr (bfd *abfd)
+{
+  unsigned char needed_count[8];
+
+  if (!bfd_elf64_write_shdrs_and_ehdr (abfd))
+    return FALSE;
+
+  bfd_putl64 (elf_ia64_vms_tdata (abfd)->needed_count, needed_count);
+
+  if (bfd_seek (abfd, sizeof (Elf64_External_Ehdr), SEEK_SET) != 0
+      || bfd_bwrite (needed_count, 8, abfd) != 8)
+    return FALSE;
+
+  return TRUE;
+}
+
+static bfd_boolean
+elf64_vms_close_and_cleanup (bfd *abfd)
+{
+  if (bfd_get_format (abfd) == bfd_object)
+    {
+      long isize;
+
+      /* Pad to 8 byte boundary for IPF/VMS.  */
+      isize = bfd_get_size (abfd);
+      if ((isize & 7) != 0)
+	{
+	  int ishort = 8 - (isize & 7);
+          bfd_uint64_t pad = 0;
+
+	  bfd_seek (abfd, isize, SEEK_SET);
+	  bfd_bwrite (&pad, ishort, abfd);
+	}
+    }
+
+  return _bfd_elf_close_and_cleanup (abfd);
+}
+
+/* Add symbols from an ELF object file to the linker hash table.  */
+
+static bfd_boolean
+elf64_vms_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
+{
+  Elf_Internal_Shdr *hdr;
+  bfd_size_type symcount;
+  bfd_size_type extsymcount;
+  bfd_size_type extsymoff;
+  struct elf_link_hash_entry **sym_hash;
+  bfd_boolean dynamic;
+  Elf_Internal_Sym *isymbuf = NULL;
+  Elf_Internal_Sym *isym;
+  Elf_Internal_Sym *isymend;
+  const struct elf_backend_data *bed;
+  struct elf_link_hash_table *htab;
+  bfd_size_type amt;
+
+  htab = elf_hash_table (info);
+  bed = get_elf_backend_data (abfd);
+
+  if ((abfd->flags & DYNAMIC) == 0)
+    dynamic = FALSE;
+  else
+    {
+      dynamic = TRUE;
+
+      /* You can't use -r against a dynamic object.  Also, there's no
+	 hope of using a dynamic object which does not exactly match
+	 the format of the output file.  */
+      if (info->relocatable
+	  || !is_elf_hash_table (htab)
+	  || info->output_bfd->xvec != abfd->xvec)
+	{
+	  if (info->relocatable)
+	    bfd_set_error (bfd_error_invalid_operation);
+	  else
+	    bfd_set_error (bfd_error_wrong_format);
+	  goto error_return;
+	}
+    }
+
+  if (! dynamic)
+    {
+      /* If we are creating a shared library, create all the dynamic
+	 sections immediately.  We need to attach them to something,
+	 so we attach them to this BFD, provided it is the right
+	 format.  FIXME: If there are no input BFD's of the same
+	 format as the output, we can't make a shared library.  */
+      if (info->shared
+	  && is_elf_hash_table (htab)
+	  && info->output_bfd->xvec == abfd->xvec
+	  && !htab->dynamic_sections_created)
+	{
+	  if (! elf64_ia64_create_dynamic_sections (abfd, info))
+	    goto error_return;
+	}
+    }
+  else if (!is_elf_hash_table (htab))
+    goto error_return;
+  else
+    {
+      asection *s;
+      bfd_byte *dynbuf;
+      bfd_byte *extdyn;
+
+      /* ld --just-symbols and dynamic objects don't mix very well.
+	 ld shouldn't allow it.  */
+      if ((s = abfd->sections) != NULL
+	  && s->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
+	abort ();
+
+      /* Be sure there are dynamic sections.  */
+      if (! elf64_ia64_create_dynamic_sections (htab->dynobj, info))
+        goto error_return;
+
+      s = bfd_get_section_by_name (abfd, ".dynamic");
+      if (s == NULL)
+        {
+          /* VMS libraries do not have dynamic sections.  Create one from
+             the segment.  */
+          Elf_Internal_Phdr *phdr;
+          unsigned int i, phnum;
+
+          phdr = elf_tdata (abfd)->phdr;
+          if (phdr == NULL)
+            goto error_return;
+          phnum = elf_elfheader (abfd)->e_phnum;
+          for (i = 0; i < phnum; phdr++)
+            if (phdr->p_type == PT_DYNAMIC)
+              {
+                s = bfd_make_section (abfd, ".dynamic");
+                if (s == NULL)
+                  goto error_return;
+                s->vma = phdr->p_vaddr;
+                s->lma = phdr->p_paddr;
+                s->size = phdr->p_filesz;
+                s->filepos = phdr->p_offset;
+                s->flags |= SEC_HAS_CONTENTS;
+                s->alignment_power = bfd_log2 (phdr->p_align);
+                break;
+              }
+          if (s == NULL)
+            goto error_return;
+        }
+
+      /* Extract IDENT.  */
+      if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
+        {
+error_free_dyn:
+          free (dynbuf);
+          goto error_return;
+        }
+
+      for (extdyn = dynbuf;
+           extdyn < dynbuf + s->size;
+           extdyn += bed->s->sizeof_dyn)
+        {
+          Elf_Internal_Dyn dyn;
+
+          bed->s->swap_dyn_in (abfd, extdyn, &dyn);
+          if (dyn.d_tag == DT_IA_64_VMS_IDENT)
+            {
+              bfd_uint64_t tagv = dyn.d_un.d_val;
+              elf_ia64_vms_ident (abfd) = tagv;
+              break;
+            }
+        }
+      if (extdyn >= dynbuf + s->size)
+        {
+          /* Ident not found.  */
+          goto error_free_dyn;
+        }
+      free (dynbuf);
+
+      /* We do not want to include any of the sections in a dynamic
+	 object in the output file.  We hack by simply clobbering the
+	 list of sections in the BFD.  This could be handled more
+	 cleanly by, say, a new section flag; the existing
+	 SEC_NEVER_LOAD flag is not the one we want, because that one
+	 still implies that the section takes up space in the output
+	 file.  */
+      bfd_section_list_clear (abfd);
+
+      /* FIXME: should we detect if this library is already included ?
+         This should be harmless and shouldn't happen in practice.  */
+    }
+
+  hdr = &elf_tdata (abfd)->symtab_hdr;
+  symcount = hdr->sh_size / bed->s->sizeof_sym;
+
+  /* The sh_info field of the symtab header tells us where the
+     external symbols start.  We don't care about the local symbols at
+     this point.  */
+  extsymcount = symcount - hdr->sh_info;
+  extsymoff = hdr->sh_info;
+
+  sym_hash = NULL;
+  if (extsymcount != 0)
+    {
+      isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
+				      NULL, NULL, NULL);
+      if (isymbuf == NULL)
+	goto error_return;
+
+      /* We store a pointer to the hash table entry for each external
+	 symbol.  */
+      amt = extsymcount * sizeof (struct elf_link_hash_entry *);
+      sym_hash = (struct elf_link_hash_entry **) bfd_alloc (abfd, amt);
+      if (sym_hash == NULL)
+	goto error_free_sym;
+      elf_sym_hashes (abfd) = sym_hash;
+    }
+
+  for (isym = isymbuf, isymend = isymbuf + extsymcount;
+       isym < isymend;
+       isym++, sym_hash++)
+    {
+      int bind;
+      bfd_vma value;
+      asection *sec, *new_sec;
+      flagword flags;
+      const char *name;
+      struct elf_link_hash_entry *h;
+      bfd_boolean definition;
+      bfd_boolean size_change_ok;
+      bfd_boolean type_change_ok;
+      bfd_boolean common;
+      unsigned int old_alignment;
+      bfd *old_bfd;
+
+      flags = BSF_NO_FLAGS;
+      sec = NULL;
+      value = isym->st_value;
+      *sym_hash = NULL;
+      common = bed->common_definition (isym);
+
+      bind = ELF_ST_BIND (isym->st_info);
+      switch (bind)
+	{
+	case STB_LOCAL:
+	  /* This should be impossible, since ELF requires that all
+	     global symbols follow all local symbols, and that sh_info
+	     point to the first global symbol.  Unfortunately, Irix 5
+	     screws this up.  */
+	  continue;
+
+	case STB_GLOBAL:
+	  if (isym->st_shndx != SHN_UNDEF && !common)
+	    flags = BSF_GLOBAL;
+	  break;
+
+	case STB_WEAK:
+	  flags = BSF_WEAK;
+	  break;
+
+	case STB_GNU_UNIQUE:
+	  flags = BSF_GNU_UNIQUE;
+	  break;
+
+	default:
+	  /* Leave it up to the processor backend.  */
+	  break;
+	}
+
+      if (isym->st_shndx == SHN_UNDEF)
+	sec = bfd_und_section_ptr;
+      else if (isym->st_shndx == SHN_ABS)
+	sec = bfd_abs_section_ptr;
+      else if (isym->st_shndx == SHN_COMMON)
+	{
+	  sec = bfd_com_section_ptr;
+	  /* What ELF calls the size we call the value.  What ELF
+	     calls the value we call the alignment.  */
+	  value = isym->st_size;
+	}
+      else
+	{
+	  sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
+	  if (sec == NULL)
+	    sec = bfd_abs_section_ptr;
+	  else if (sec->kept_section)
+	    {
+	      /* Symbols from discarded section are undefined.  We keep
+		 its visibility.  */
+	      sec = bfd_und_section_ptr;
+	      isym->st_shndx = SHN_UNDEF;
+	    }
+	  else if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
+	    value -= sec->vma;
+	}
+
+      name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
+					      isym->st_name);
+      if (name == NULL)
+	goto error_free_vers;
+
+      if (bed->elf_add_symbol_hook)
+	{
+	  if (! (*bed->elf_add_symbol_hook) (abfd, info, isym, &name, &flags,
+					     &sec, &value))
+	    goto error_free_vers;
+
+	  /* The hook function sets the name to NULL if this symbol
+	     should be skipped for some reason.  */
+	  if (name == NULL)
+	    continue;
+	}
+
+      /* Sanity check that all possibilities were handled.  */
+      if (sec == NULL)
+	{
+	  bfd_set_error (bfd_error_bad_value);
+	  goto error_free_vers;
+	}
+
+      if (bfd_is_und_section (sec)
+	  || bfd_is_com_section (sec))
+	definition = FALSE;
+      else
+	definition = TRUE;
+
+      size_change_ok = FALSE;
+      type_change_ok = bed->type_change_ok;
+      old_alignment = 0;
+      old_bfd = NULL;
+      new_sec = sec;
+
+      if (! bfd_is_und_section (sec))
+        h = elf_link_hash_lookup (htab, name, TRUE, FALSE, FALSE);
+      else
+        h = ((struct elf_link_hash_entry *) bfd_wrapped_link_hash_lookup
+             (abfd, info, name, TRUE, FALSE, FALSE));
+      if (h == NULL)
+        goto error_free_sym;
+
+      *sym_hash = h;
+
+      if (is_elf_hash_table (htab))
+	{
+	  while (h->root.type == bfd_link_hash_indirect
+		 || h->root.type == bfd_link_hash_warning)
+	    h = (struct elf_link_hash_entry *) h->root.u.i.link;
+
+	  /* Remember the old alignment if this is a common symbol, so
+	     that we don't reduce the alignment later on.  We can't
+	     check later, because _bfd_generic_link_add_one_symbol
+	     will set a default for the alignment which we want to
+	     override. We also remember the old bfd where the existing
+	     definition comes from.  */
+	  switch (h->root.type)
+	    {
+	    default:
+	      break;
+
+	    case bfd_link_hash_defined:
+              if (abfd->selective_search)
+                continue;
+              /* Fall-through.  */
+	    case bfd_link_hash_defweak:
+	      old_bfd = h->root.u.def.section->owner;
+	      break;
+
+	    case bfd_link_hash_common:
+	      old_bfd = h->root.u.c.p->section->owner;
+	      old_alignment = h->root.u.c.p->alignment_power;
+	      break;
+	    }
+	}
+
+      if (! (_bfd_generic_link_add_one_symbol
+	     (info, abfd, name, flags, sec, value, NULL, FALSE, bed->collect,
+	      (struct bfd_link_hash_entry **) sym_hash)))
+	goto error_free_vers;
+
+      h = *sym_hash;
+      while (h->root.type == bfd_link_hash_indirect
+	     || h->root.type == bfd_link_hash_warning)
+	h = (struct elf_link_hash_entry *) h->root.u.i.link;
+
+      *sym_hash = h;
+      h->unique_global = (flags & BSF_GNU_UNIQUE) != 0;
+
+      /* Set the alignment of a common symbol.  */
+      if ((common || bfd_is_com_section (sec))
+	  && h->root.type == bfd_link_hash_common)
+	{
+	  unsigned int align;
+
+	  if (common)
+	    align = bfd_log2 (isym->st_value);
+	  else
+	    {
+	      /* The new symbol is a common symbol in a shared object.
+		 We need to get the alignment from the section.  */
+	      align = new_sec->alignment_power;
+	    }
+	  if (align > old_alignment
+	      /* Permit an alignment power of zero if an alignment of one
+		 is specified and no other alignments have been specified.  */
+	      || (isym->st_value == 1 && old_alignment == 0))
+	    h->root.u.c.p->alignment_power = align;
+	  else
+	    h->root.u.c.p->alignment_power = old_alignment;
+	}
+
+      if (is_elf_hash_table (htab))
+	{
+	  /* Check the alignment when a common symbol is involved. This
+	     can change when a common symbol is overridden by a normal
+	     definition or a common symbol is ignored due to the old
+	     normal definition. We need to make sure the maximum
+	     alignment is maintained.  */
+	  if ((old_alignment || common)
+	      && h->root.type != bfd_link_hash_common)
+	    {
+	      unsigned int common_align;
+	      unsigned int normal_align;
+	      unsigned int symbol_align;
+	      bfd *normal_bfd;
+	      bfd *common_bfd;
+
+	      symbol_align = ffs (h->root.u.def.value) - 1;
+	      if (h->root.u.def.section->owner != NULL
+		  && (h->root.u.def.section->owner->flags & DYNAMIC) == 0)
+		{
+		  normal_align = h->root.u.def.section->alignment_power;
+		  if (normal_align > symbol_align)
+		    normal_align = symbol_align;
+		}
+	      else
+		normal_align = symbol_align;
+
+	      if (old_alignment)
+		{
+		  common_align = old_alignment;
+		  common_bfd = old_bfd;
+		  normal_bfd = abfd;
+		}
+	      else
+		{
+		  common_align = bfd_log2 (isym->st_value);
+		  common_bfd = abfd;
+		  normal_bfd = old_bfd;
+		}
+
+	      if (normal_align < common_align)
+		{
+		  /* PR binutils/2735 */
+		  if (normal_bfd == NULL)
+		    (*_bfd_error_handler)
+		      (_("Warning: alignment %u of common symbol `%s' in %B"
+			 " is greater than the alignment (%u) of its section %A"),
+		       common_bfd, h->root.u.def.section,
+		       1 << common_align, name, 1 << normal_align);
+		  else
+		    (*_bfd_error_handler)
+		      (_("Warning: alignment %u of symbol `%s' in %B"
+			 " is smaller than %u in %B"),
+		       normal_bfd, common_bfd,
+		       1 << normal_align, name, 1 << common_align);
+		}
+	    }
+
+	  /* Remember the symbol size if it isn't undefined.  */
+	  if ((isym->st_size != 0 && isym->st_shndx != SHN_UNDEF)
+	      && (definition || h->size == 0))
+	    {
+	      if (h->size != 0
+		  && h->size != isym->st_size
+		  && ! size_change_ok)
+		(*_bfd_error_handler)
+		  (_("Warning: size of symbol `%s' changed"
+		     " from %lu in %B to %lu in %B"),
+		   old_bfd, abfd,
+		   name, (unsigned long) h->size,
+		   (unsigned long) isym->st_size);
+
+	      h->size = isym->st_size;
+	    }
+
+	  /* If this is a common symbol, then we always want H->SIZE
+	     to be the size of the common symbol.  The code just above
+	     won't fix the size if a common symbol becomes larger.  We
+	     don't warn about a size change here, because that is
+	     covered by --warn-common.  Allow changed between different
+	     function types.  */
+	  if (h->root.type == bfd_link_hash_common)
+	    h->size = h->root.u.c.size;
+
+	  if (ELF_ST_TYPE (isym->st_info) != STT_NOTYPE
+	      && (definition || h->type == STT_NOTYPE))
+	    {
+	      unsigned int type = ELF_ST_TYPE (isym->st_info);
+
+	      if (h->type != type)
+		{
+		  if (h->type != STT_NOTYPE && ! type_change_ok)
+		    (*_bfd_error_handler)
+		      (_("Warning: type of symbol `%s' changed"
+			 " from %d to %d in %B"),
+		       abfd, name, h->type, type);
+
+		  h->type = type;
+		}
+	    }
+
+	  /* Set a flag in the hash table entry indicating the type of
+	     reference or definition we just found.  Keep a count of
+	     the number of dynamic symbols we find.  A dynamic symbol
+	     is one which is referenced or defined by both a regular
+	     object and a shared object.  */
+	  if (! dynamic)
+	    {
+	      if (! definition)
+		{
+		  h->ref_regular = 1;
+		  if (bind != STB_WEAK)
+		    h->ref_regular_nonweak = 1;
+		}
+	      else
+		{
+                  BFD_ASSERT (!h->def_dynamic);
+		  h->def_regular = 1;
+		}
+	    }
+	  else
+	    {
+	      BFD_ASSERT (definition);
+              h->def_dynamic = 1;
+              h->dynindx = -2;
+              ((struct elf64_ia64_link_hash_entry *)h)->shl = abfd;
+	    }
+	}
+    }
+
+  if (isymbuf != NULL)
+    {
+      free (isymbuf);
+      isymbuf = NULL;
+    }
+
+  /* If this object is the same format as the output object, and it is
+     not a shared library, then let the backend look through the
+     relocs.
+
+     This is required to build global offset table entries and to
+     arrange for dynamic relocs.  It is not required for the
+     particular common case of linking non PIC code, even when linking
+     against shared libraries, but unfortunately there is no way of
+     knowing whether an object file has been compiled PIC or not.
+     Looking through the relocs is not particularly time consuming.
+     The problem is that we must either (1) keep the relocs in memory,
+     which causes the linker to require additional runtime memory or
+     (2) read the relocs twice from the input file, which wastes time.
+     This would be a good case for using mmap.
+
+     I have no idea how to handle linking PIC code into a file of a
+     different format.  It probably can't be done.  */
+  if (! dynamic
+      && is_elf_hash_table (htab)
+      && bed->check_relocs != NULL
+      && (*bed->relocs_compatible) (abfd->xvec, info->output_bfd->xvec))
+    {
+      asection *o;
+
+      for (o = abfd->sections; o != NULL; o = o->next)
+	{
+	  Elf_Internal_Rela *internal_relocs;
+	  bfd_boolean ok;
+
+	  if ((o->flags & SEC_RELOC) == 0
+	      || o->reloc_count == 0
+	      || ((info->strip == strip_all || info->strip == strip_debugger)
+		  && (o->flags & SEC_DEBUGGING) != 0)
+	      || bfd_is_abs_section (o->output_section))
+	    continue;
+
+	  internal_relocs = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
+						       info->keep_memory);
+	  if (internal_relocs == NULL)
+	    goto error_return;
+
+	  ok = (*bed->check_relocs) (abfd, info, o, internal_relocs);
+
+	  if (elf_section_data (o)->relocs != internal_relocs)
+	    free (internal_relocs);
+
+	  if (! ok)
+	    goto error_return;
+	}
+    }
+
+  return TRUE;
+
+ error_free_vers:
+ error_free_sym:
+  if (isymbuf != NULL)
+    free (isymbuf);
+ error_return:
+  return FALSE;
+}
+
+static bfd_boolean
+elf64_vms_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
+{
+  int pass;
+  struct bfd_link_hash_entry **pundef;
+  struct bfd_link_hash_entry **next_pundef;
+
+  /* We only accept VMS libraries.  */
+  if (info->output_bfd->xvec != abfd->xvec)
+    {
+      bfd_set_error (bfd_error_wrong_format);
+      return FALSE;
+    }
+
+  /* The archive_pass field in the archive itself is used to
+     initialize PASS, since we may search the same archive multiple
+     times.  */
+  pass = ++abfd->archive_pass;
+
+  /* Look through the list of undefined symbols.  */
+  for (pundef = &info->hash->undefs; *pundef != NULL; pundef = next_pundef)
+    {
+      struct bfd_link_hash_entry *h;
+      symindex symidx;
+      bfd *element;
+      bfd *orig_element;
+
+      h = *pundef;
+      next_pundef = &(*pundef)->u.undef.next;
+
+      /* When a symbol is defined, it is not necessarily removed from
+	 the list.  */
+      if (h->type != bfd_link_hash_undefined
+	  && h->type != bfd_link_hash_common)
+	{
+	  /* Remove this entry from the list, for general cleanliness
+	     and because we are going to look through the list again
+	     if we search any more libraries.  We can't remove the
+	     entry if it is the tail, because that would lose any
+	     entries we add to the list later on.  */
+	  if (*pundef != info->hash->undefs_tail)
+            {
+              *pundef = *next_pundef;
+              next_pundef = pundef;
+            }
+	  continue;
+	}
+
+      /* Look for this symbol in the archive hash table.  */
+      symidx = _bfd_vms_lib_find_symbol (abfd, h->root.string);
+      if (symidx == BFD_NO_MORE_SYMBOLS)
+	{
+	  /* Nothing in this slot.  */
+	  continue;
+	}
+
+      element = bfd_get_elt_at_index (abfd, symidx);
+      if (element == NULL)
+	return FALSE;
+
+      if (element->archive_pass == -1 || element->archive_pass == pass)
+        {
+          /* Next symbol if this archive is wrong or already handled.  */
+          continue;
+        }
+
+      orig_element = element;
+      if (bfd_is_thin_archive (abfd))
+        {
+          element = _bfd_vms_lib_get_imagelib_file (element);
+          if (element == NULL || !bfd_check_format (element, bfd_object))
+            {
+              orig_element->archive_pass = -1;
+              return FALSE;
+            }
+        }
+      else if (! bfd_check_format (element, bfd_object))
+        {
+          element->archive_pass = -1;
+          return FALSE;
+        }
+
+      /* Unlike the generic linker, we know that this element provides
+	 a definition for an undefined symbol and we know that we want
+	 to include it.  We don't need to check anything.  */
+      if (! (*info->callbacks->add_archive_element) (info, element,
+                                                     h->root.string, &element))
+	return FALSE;
+      if (! elf64_vms_link_add_object_symbols (element, info))
+	return FALSE;
+
+      orig_element->archive_pass = pass;
+    }
+
+  return TRUE;
+}
+
+static bfd_boolean
+elf64_vms_bfd_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
+{
+  switch (bfd_get_format (abfd))
+    {
+    case bfd_object:
+      return elf64_vms_link_add_object_symbols (abfd, info);
+      break;
+    case bfd_archive:
+      return elf64_vms_link_add_archive_symbols (abfd, info);
+      break;
+    default:
+      bfd_set_error (bfd_error_wrong_format);
+      return FALSE;
+    }
+}
+
+static bfd_boolean
+elf64_ia64_vms_mkobject (bfd *abfd)
+{
+  return bfd_elf_allocate_object
+    (abfd, sizeof (struct elf64_ia64_vms_obj_tdata), IA64_ELF_DATA);
+}
+
+
+/* Size-dependent data and functions.  */
+static const struct elf_size_info elf64_ia64_vms_size_info = {
+  sizeof (Elf64_External_VMS_Ehdr),
+  sizeof (Elf64_External_Phdr),
+  sizeof (Elf64_External_Shdr),
+  sizeof (Elf64_External_Rel),
+  sizeof (Elf64_External_Rela),
+  sizeof (Elf64_External_Sym),
+  sizeof (Elf64_External_Dyn),
+  sizeof (Elf_External_Note),
+  4,
+  1,
+  64, 3, /* ARCH_SIZE, LOG_FILE_ALIGN */
+  ELFCLASS64, EV_CURRENT,
+  bfd_elf64_write_out_phdrs,
+  elf64_vms_write_shdrs_and_ehdr,
+  bfd_elf64_checksum_contents,
+  bfd_elf64_write_relocs,
+  bfd_elf64_swap_symbol_in,
+  bfd_elf64_swap_symbol_out,
+  bfd_elf64_slurp_reloc_table,
+  bfd_elf64_slurp_symbol_table,
+  bfd_elf64_swap_dyn_in,
+  bfd_elf64_swap_dyn_out,
+  bfd_elf64_swap_reloc_in,
+  bfd_elf64_swap_reloc_out,
+  bfd_elf64_swap_reloca_in,
+  bfd_elf64_swap_reloca_out
+};
+
+#define ELF_ARCH			bfd_arch_ia64
+#define ELF_MACHINE_CODE		EM_IA_64
+#define ELF_MAXPAGESIZE			0x10000	/* 64KB */
+#define ELF_COMMONPAGESIZE		0x200	/* 16KB */
+
+#define elf_backend_section_from_shdr \
+	elf64_ia64_section_from_shdr
+#define elf_backend_section_flags \
+	elf64_ia64_section_flags
+#define elf_backend_fake_sections \
+	elf64_ia64_fake_sections
+#define elf_backend_final_write_processing \
+	elf64_ia64_final_write_processing
+#define elf_backend_add_symbol_hook \
+	elf64_ia64_add_symbol_hook
+#define elf_info_to_howto \
+	elf64_ia64_info_to_howto
+
+#define bfd_elf64_bfd_reloc_type_lookup \
+	ia64_elf_reloc_type_lookup
+#define bfd_elf64_bfd_reloc_name_lookup \
+	ia64_elf_reloc_name_lookup
+#define bfd_elf64_bfd_is_local_label_name \
+	elf64_ia64_is_local_label_name
+#define bfd_elf64_bfd_relax_section \
+	elf64_ia64_relax_section
+
+#define elf_backend_object_p \
+	elf64_ia64_object_p
+
+/* Stuff for the BFD linker: */
+#define bfd_elf64_bfd_link_hash_table_create \
+	elf64_ia64_hash_table_create
+#define bfd_elf64_bfd_link_hash_table_free \
+	elf64_ia64_hash_table_free
+#define elf_backend_create_dynamic_sections \
+	elf64_ia64_create_dynamic_sections
+#define elf_backend_check_relocs \
+	elf64_ia64_check_relocs
+#define elf_backend_adjust_dynamic_symbol \
+	elf64_ia64_adjust_dynamic_symbol
+#define elf_backend_size_dynamic_sections \
+	elf64_ia64_size_dynamic_sections
+#define elf_backend_omit_section_dynsym \
+  ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
+#define elf_backend_relocate_section \
+	elf64_ia64_relocate_section
+#define elf_backend_finish_dynamic_symbol \
+	elf64_ia64_finish_dynamic_symbol
+#define elf_backend_finish_dynamic_sections \
+	elf64_ia64_finish_dynamic_sections
+#define bfd_elf64_bfd_final_link \
+	elf64_ia64_final_link
+
+#define bfd_elf64_bfd_merge_private_bfd_data \
+	elf64_ia64_merge_private_bfd_data
+#define bfd_elf64_bfd_set_private_flags \
+	elf64_ia64_set_private_flags
+#define bfd_elf64_bfd_print_private_bfd_data \
+	elf64_ia64_print_private_bfd_data
+
+#define elf_backend_plt_readonly	1
+#define elf_backend_want_plt_sym	0
+#define elf_backend_plt_alignment	5
+#define elf_backend_got_header_size	0
+#define elf_backend_want_got_plt	1
+#define elf_backend_may_use_rel_p	1
+#define elf_backend_may_use_rela_p	1
+#define elf_backend_default_use_rela_p	1
+#define elf_backend_want_dynbss		0
+#define elf_backend_hide_symbol		elf64_ia64_hash_hide_symbol
+#define elf_backend_fixup_symbol	_bfd_elf_link_hash_fixup_symbol
+#define elf_backend_reloc_type_class	elf64_ia64_reloc_type_class
+#define elf_backend_rela_normal		1
+#define elf_backend_special_sections	elf64_ia64_special_sections
+#define elf_backend_default_execstack	0
+
+/* FIXME: PR 290: The Intel C compiler generates SHT_IA_64_UNWIND with
+   SHF_LINK_ORDER. But it doesn't set the sh_link or sh_info fields.
+   We don't want to flood users with so many error messages. We turn
+   off the warning for now. It will be turned on later when the Intel
+   compiler is fixed.   */
+#define elf_backend_link_order_error_handler NULL
+
+/* VMS-specific vectors.  */
+
+#undef  TARGET_LITTLE_SYM
+#define TARGET_LITTLE_SYM		bfd_elf64_ia64_vms_vec
+#undef  TARGET_LITTLE_NAME
+#define TARGET_LITTLE_NAME		"elf64-ia64-vms"
+#undef  TARGET_BIG_SYM
+#undef  TARGET_BIG_NAME
+
+/* These are VMS specific functions.  */
+
+#undef  elf_backend_object_p
+#define elf_backend_object_p elf64_vms_object_p
+
+#undef  elf_backend_section_from_shdr
+#define elf_backend_section_from_shdr elf64_vms_section_from_shdr
+
+#undef  elf_backend_post_process_headers
+#define elf_backend_post_process_headers elf64_vms_post_process_headers
+
+#undef  elf_backend_section_processing
+#define elf_backend_section_processing elf64_vms_section_processing
+
+#undef  elf_backend_final_write_processing
+#define elf_backend_final_write_processing elf64_vms_final_write_processing
+
+#undef  bfd_elf64_close_and_cleanup
+#define bfd_elf64_close_and_cleanup elf64_vms_close_and_cleanup
+
+#undef  elf_backend_section_from_bfd_section
+
+#undef  elf_backend_symbol_processing
+
+#undef  elf_backend_want_p_paddr_set_to_zero
+
+#undef  ELF_OSABI
+#define ELF_OSABI			ELFOSABI_OPENVMS
+
+#undef  ELF_MAXPAGESIZE
+#define ELF_MAXPAGESIZE			0x10000	/* 64KB */
+
+#undef  elf64_bed
+#define elf64_bed elf64_ia64_vms_bed
+
+#define elf_backend_size_info elf64_ia64_vms_size_info
+
+/* Use VMS-style archives (in particular, don't use the standard coff
+   archive format).  */
+#define bfd_elf64_archive_functions
+
+#undef bfd_elf64_archive_p
+#define bfd_elf64_archive_p _bfd_vms_lib_ia64_archive_p
+#undef bfd_elf64_write_archive_contents
+#define bfd_elf64_write_archive_contents _bfd_vms_lib_write_archive_contents
+#undef bfd_elf64_mkarchive
+#define bfd_elf64_mkarchive _bfd_vms_lib_ia64_mkarchive
+
+#define bfd_elf64_archive_slurp_armap \
+  _bfd_vms_lib_slurp_armap
+#define bfd_elf64_archive_slurp_extended_name_table \
+  _bfd_vms_lib_slurp_extended_name_table
+#define bfd_elf64_archive_construct_extended_name_table \
+  _bfd_vms_lib_construct_extended_name_table
+#define bfd_elf64_archive_truncate_arname \
+  _bfd_vms_lib_truncate_arname
+#define bfd_elf64_archive_write_armap \
+  _bfd_vms_lib_write_armap
+#define bfd_elf64_archive_read_ar_hdr \
+  _bfd_vms_lib_read_ar_hdr
+#define bfd_elf64_archive_write_ar_hdr \
+  _bfd_vms_lib_write_ar_hdr
+#define bfd_elf64_archive_openr_next_archived_file \
+  _bfd_vms_lib_openr_next_archived_file
+#define bfd_elf64_archive_get_elt_at_index \
+  _bfd_vms_lib_get_elt_at_index
+#define bfd_elf64_archive_generic_stat_arch_elt \
+  _bfd_vms_lib_generic_stat_arch_elt
+#define bfd_elf64_archive_update_armap_timestamp \
+  _bfd_vms_lib_update_armap_timestamp
+
+/* VMS link methods.  */
+#undef  bfd_elf64_bfd_link_add_symbols
+#define bfd_elf64_bfd_link_add_symbols 	elf64_vms_bfd_link_add_symbols
+
+#undef  elf_backend_want_got_sym
+#define elf_backend_want_got_sym 	0
+
+#undef  bfd_elf64_mkobject
+#define bfd_elf64_mkobject		elf64_ia64_vms_mkobject
+
+/* Redefine to align segments on block size.  */
+#undef  ELF_MAXPAGESIZE
+#define ELF_MAXPAGESIZE			0x200 /* 512B  */
+
+#undef  elf_backend_want_got_plt
+#define elf_backend_want_got_plt	0
+
+#include "elf64-target.h"
diff --git a/bfd/elflink.c b/bfd/elflink.c
index 12025a3..0ed5208 100644
--- a/bfd/elflink.c
+++ b/bfd/elflink.c
@@ -8908,7 +8908,8 @@ elf_link_output_extsym (struct bfd_hash_entry *bh, void *data)
   /* If this symbol should be put in the .dynsym section, then put it
      there now.  We already know the symbol index.  We also fill in
      the entry in the .hash section.  */
-  if (h->dynindx != -1
+  if (finfo->dynsym_sec != NULL
+      && h->dynindx != -1
       && elf_hash_table (finfo->info)->dynamic_sections_created)
     {
       bfd_byte *esym;
@@ -10305,7 +10306,7 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
     {
       finfo.dynsym_sec = bfd_get_section_by_name (dynobj, ".dynsym");
       finfo.hash_sec = bfd_get_section_by_name (dynobj, ".hash");
-      BFD_ASSERT (finfo.dynsym_sec != NULL);
+      /* Note that dynsym_sec can be NULL (on VMS).  */
       finfo.symver_sec = bfd_get_section_by_name (dynobj, ".gnu.version");
       /* Note that it is OK if symver_sec is NULL.  */
     }
@@ -10825,6 +10826,7 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
   symtab_hdr->sh_info = bfd_get_symcount (abfd);
 
   if (dynamic
+      && finfo.dynsym_sec != NULL
       && finfo.dynsym_sec->output_section != bfd_abs_section_ptr)
     {
       Elf_Internal_Sym sym;
diff --git a/bfd/elfnn-ia64.c b/bfd/elfnn-ia64.c
index d70b28e..7ea2981 100644
--- a/bfd/elfnn-ia64.c
+++ b/bfd/elfnn-ia64.c
@@ -1,6 +1,6 @@
 /* IA-64 support for 64-bit ELF
    Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
-   2008, 2009, 2010, 2011  Free Software Foundation, Inc.
+   2008, 2009, 2010, 2011, 2012  Free Software Foundation, Inc.
    Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
 
    This file is part of BFD, the Binary File Descriptor library.
@@ -41,14 +41,6 @@
 #define	LOG_SECTION_ALIGN	2
 #endif
 
-/* Only add code for vms when the vms target is enabled.  This is required
-   because it depends on vms-lib.c for its archive format and we don't want
-   to compile that code if it is not used.  */
-#if ARCH_SIZE == 64 && \
-  (defined (HAVE_bfd_elf64_ia64_vms_vec) || defined (HAVE_all_vecs))
-#define INCLUDE_IA64_VMS
-#endif
-
 typedef struct bfd_hash_entry *(*new_hash_entry_func)
   (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
 
@@ -4978,277 +4970,6 @@ elfNN_hpux_backend_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
       break;
     }
 }
-
-#ifdef INCLUDE_IA64_VMS
-
-static bfd_boolean
-elfNN_vms_section_from_shdr (bfd *abfd,
-			     Elf_Internal_Shdr *hdr,
-			     const char *name,
-			     int shindex)
-{
-  switch (hdr->sh_type)
-    {
-    case SHT_IA_64_VMS_TRACE:
-    case SHT_IA_64_VMS_DEBUG:
-    case SHT_IA_64_VMS_DEBUG_STR:
-      break;
-
-    default:
-      return elfNN_ia64_section_from_shdr (abfd, hdr, name, shindex);
-    }
-
-  if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
-    return FALSE;
-
-  return TRUE;
-}
-
-static bfd_boolean
-elfNN_vms_object_p (bfd *abfd)
-{
-  Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
-  Elf_Internal_Phdr *i_phdr = elf_tdata (abfd)->phdr;
-  unsigned int i;
-  unsigned int num_text = 0;
-  unsigned int num_data = 0;
-  unsigned int num_rodata = 0;
-  char name[16];
-
-  if (!elfNN_ia64_object_p (abfd))
-    return FALSE;
-
-  for (i = 0; i < i_ehdrp->e_phnum; i++, i_phdr++)
-    {
-      /* Is there a section for this segment?  */
-      bfd_vma base_vma = i_phdr->p_vaddr;
-      bfd_vma limit_vma = base_vma + i_phdr->p_filesz;
-
-      if (i_phdr->p_type != PT_LOAD)
-	continue;
-
-    again:
-      while (base_vma < limit_vma)
-	{
-	  bfd_vma next_vma = limit_vma;
-	  asection *nsec;
-	  asection *sec;
-	  flagword flags;
-	  char *nname = NULL;
-
-	  /* Find a section covering [base_vma;limit_vma)  */
-	  for (sec = abfd->sections; sec != NULL; sec = sec->next)
-	    {
-	      /* Skip uninteresting sections (either not in memory or
-		 below base_vma.  */
-	      if ((sec->flags & (SEC_ALLOC | SEC_LOAD)) == 0
-		  || sec->vma + sec->size <= base_vma)
-		continue;
-	      if (sec->vma <= base_vma)
-		{
-		  /* This section covers (maybe partially) the beginning
-		     of the range.  */
-		  base_vma = sec->vma + sec->size;
-		  goto again;
-		}
-	      if (sec->vma < next_vma)
-		{
-		  /* This section partially covers the end of the range.
-		     Used to compute the size of the hole.  */
-		  next_vma = sec->vma;
-		}
-	    }
-
-	  /* No section covering [base_vma; next_vma).  Create a fake one.  */
-	  flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS;
-	  if (i_phdr->p_flags & PF_X)
-	    {
-	      flags |= SEC_CODE;
-	      if (num_text++ == 0)
-		nname = ".text";
-	      else
-		sprintf (name, ".text$%u", num_text);
-	    }
-	  else if ((i_phdr->p_flags & (PF_R | PF_W)) == PF_R)
-	    {
-	      flags |= SEC_READONLY;
-	      sprintf (name, ".rodata$%u", num_rodata++);
-	    }
-	  else
-	    {
-	      flags |= SEC_DATA;
-	      sprintf (name, ".data$%u", num_data++);
-	    }
-
-	  /* Allocate name.  */
-	  if (nname == NULL)
-	    {
-	      size_t name_len = strlen (name) + 1;
-	      nname = bfd_alloc (abfd, name_len);
-	      if (nname == NULL)
-		return FALSE;
-	      memcpy (nname, name, name_len);
-	    }
-
-	  /* Create and fill new section.  */
-	  nsec = bfd_make_section_anyway_with_flags (abfd, nname, flags);
-	  if (nsec == NULL)
-	    return FALSE;
-	  nsec->vma = base_vma;
-	  nsec->size = next_vma - base_vma;
-	  nsec->filepos = i_phdr->p_offset + (base_vma - i_phdr->p_vaddr);
-
-	  base_vma = next_vma;
-	}
-    }
-  return TRUE;
-}
-
-static void
-elfNN_vms_post_process_headers (bfd *abfd,
-				struct bfd_link_info *info ATTRIBUTE_UNUSED)
-{
-  Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
-
-  i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_OPENVMS;
-  i_ehdrp->e_ident[EI_ABIVERSION] = 2;
-}
-
-static bfd_boolean
-elfNN_vms_section_processing (bfd *abfd ATTRIBUTE_UNUSED,
-			      Elf_Internal_Shdr *hdr)
-{
-  if (hdr->bfd_section != NULL)
-    {
-      const char *name = bfd_get_section_name (abfd, hdr->bfd_section);
-
-      if (strcmp (name, ".text") == 0)
-	hdr->sh_flags |= SHF_IA_64_VMS_SHARED;
-      else if ((strcmp (name, ".debug") == 0)
-	    || (strcmp (name, ".debug_abbrev") == 0)
-	    || (strcmp (name, ".debug_aranges") == 0)
-	    || (strcmp (name, ".debug_frame") == 0)
-	    || (strcmp (name, ".debug_info") == 0)
-	    || (strcmp (name, ".debug_loc") == 0)
-	    || (strcmp (name, ".debug_macinfo") == 0)
-	    || (strcmp (name, ".debug_pubnames") == 0)
-	    || (strcmp (name, ".debug_pubtypes") == 0))
-	hdr->sh_type = SHT_IA_64_VMS_DEBUG;
-      else if ((strcmp (name, ".debug_line") == 0)
-	    || (strcmp (name, ".debug_ranges") == 0))
-	hdr->sh_type = SHT_IA_64_VMS_TRACE;
-      else if (strcmp (name, ".debug_str") == 0)
-	hdr->sh_type = SHT_IA_64_VMS_DEBUG_STR;
-      else if (strcmp (name, ".vms_display_name_info") == 0)
-	{
-	  int idx, symcount;
-	  asymbol **syms;
-	  struct elf_obj_tdata *t = elf_tdata (abfd);
-	  int buf[2];
-	  int demangler_sym_idx = -1;
-
-	  symcount = bfd_get_symcount (abfd);
-	  syms = bfd_get_outsymbols (abfd);
-	  for (idx = 0; idx < symcount; idx++)
-	    {
-	      asymbol *sym;
-	      sym = syms[idx];
-	      if ((sym->flags & (BSF_DEBUGGING | BSF_DYNAMIC))
-	          && strchr (sym->name, '@')
-		  && (strcmp (sym->section->name, BFD_ABS_SECTION_NAME) == 0))
-		{
-		  demangler_sym_idx = sym->udata.i;
-		  break;
-		}
-	    }
-
-	  hdr->sh_type = SHT_IA_64_VMS_DISPLAY_NAME_INFO;
-	  hdr->sh_entsize = 4;
-	  hdr->sh_addralign = 0;
-	  hdr->sh_link = t->symtab_section;
-
-	  /* Find symtab index of demangler routine and stuff it in
-	     the second long word of section data.  */
-
-	  if (demangler_sym_idx > -1)
-	    {
-	      bfd_seek (abfd, hdr->sh_offset, SEEK_SET);
-	      bfd_bread (buf, hdr->sh_size, abfd);
-	      buf [1] = demangler_sym_idx;
-	      bfd_seek (abfd, hdr->sh_offset, SEEK_SET);
-	      bfd_bwrite (buf, hdr->sh_size, abfd);
-	    }
-	}
-    }
-
-  return TRUE;
-}
-
-/* The final processing done just before writing out a VMS IA-64 ELF
-   object file.  */
-
-static void
-elfNN_vms_final_write_processing (bfd *abfd,
-				  bfd_boolean linker ATTRIBUTE_UNUSED)
-{
-  Elf_Internal_Shdr *hdr;
-  asection *s;
-  int unwind_info_sect_idx = 0;
-
-  for (s = abfd->sections; s; s = s->next)
-    {
-      hdr = &elf_section_data (s)->this_hdr;
-
-      if (strcmp (bfd_get_section_name (abfd, hdr->bfd_section),
-		  ".IA_64.unwind_info") == 0)
-	unwind_info_sect_idx = elf_section_data (s)->this_idx;
-
-      switch (hdr->sh_type)
-	{
-	case SHT_IA_64_UNWIND:
-	  /* VMS requires sh_info to point to the unwind info section.  */
-          hdr->sh_info = unwind_info_sect_idx;
-	  break;
-	}
-    }
-
-  if (! elf_flags_init (abfd))
-    {
-      unsigned long flags = 0;
-
-      if (abfd->xvec->byteorder == BFD_ENDIAN_BIG)
-	flags |= EF_IA_64_BE;
-      if (bfd_get_mach (abfd) == bfd_mach_ia64_elf64)
-	flags |= EF_IA_64_ABI64;
-
-      elf_elfheader(abfd)->e_flags = flags;
-      elf_flags_init (abfd) = TRUE;
-    }
-}
-
-static bfd_boolean
-elfNN_vms_close_and_cleanup (bfd *abfd)
-{
-  if (bfd_get_format (abfd) == bfd_object)
-    {
-      long isize, irsize;
-
-      if (elf_shstrtab (abfd) != NULL)
-	_bfd_elf_strtab_free (elf_shstrtab (abfd));
-
-      /* Pad to 8 byte boundary for IPF/VMS.  */
-      isize = bfd_get_size (abfd);
-      if ((irsize = isize/8*8) < isize)
-	{
-	  int ishort = (irsize + 8) - isize;
-	  bfd_seek (abfd, isize, SEEK_SET);
-	  bfd_bwrite (bfd_zmalloc (ishort), ishort, abfd);
-	}
-    }
-
-  return _bfd_generic_close_and_cleanup (abfd);
-}
-#endif /* INCLUDE_IA64_VMS */
 
 #define TARGET_LITTLE_SYM		bfd_elfNN_ia64_little_vec
 #define TARGET_LITTLE_NAME		"elfNN-ia64-little"
@@ -5381,86 +5102,3 @@ elfNN_vms_close_and_cleanup (bfd *abfd)
 #define elfNN_bed elfNN_ia64_hpux_bed
 
 #include "elfNN-target.h"
-
-/* VMS-specific vectors.  */
-#ifdef INCLUDE_IA64_VMS
-
-#undef  TARGET_LITTLE_SYM
-#define TARGET_LITTLE_SYM		bfd_elfNN_ia64_vms_vec
-#undef  TARGET_LITTLE_NAME
-#define TARGET_LITTLE_NAME		"elfNN-ia64-vms"
-#undef  TARGET_BIG_SYM
-#undef  TARGET_BIG_NAME
-
-/* These are VMS specific functions.  */
-
-#undef  elf_backend_object_p
-#define elf_backend_object_p elfNN_vms_object_p
-
-#undef  elf_backend_section_from_shdr
-#define elf_backend_section_from_shdr elfNN_vms_section_from_shdr
-
-#undef  elf_backend_post_process_headers
-#define elf_backend_post_process_headers elfNN_vms_post_process_headers
-
-#undef  elf_backend_section_processing
-#define elf_backend_section_processing elfNN_vms_section_processing
-
-#undef  elf_backend_final_write_processing
-#define elf_backend_final_write_processing elfNN_vms_final_write_processing
-
-#undef  bfd_elfNN_close_and_cleanup
-#define bfd_elfNN_close_and_cleanup elfNN_vms_close_and_cleanup
-
-#undef  elf_backend_section_from_bfd_section
-
-#undef  elf_backend_symbol_processing
-
-#undef  elf_backend_want_p_paddr_set_to_zero
-
-#undef ELF_OSABI
-#define ELF_OSABI			ELFOSABI_OPENVMS
-
-#undef  ELF_MAXPAGESIZE
-#define ELF_MAXPAGESIZE			0x10000	/* 64KB */
-
-#undef  elfNN_bed
-#define elfNN_bed elfNN_ia64_vms_bed
-
-/* Use VMS-style archives (in particular, don't use the standard coff
-   archive format).  */
-#define bfd_elfNN_archive_functions
-
-#undef bfd_elfNN_archive_p
-#define bfd_elfNN_archive_p _bfd_vms_lib_ia64_archive_p
-#undef bfd_elfNN_write_archive_contents
-#define bfd_elfNN_write_archive_contents _bfd_vms_lib_write_archive_contents
-#undef bfd_elfNN_mkarchive
-#define bfd_elfNN_mkarchive _bfd_vms_lib_ia64_mkarchive
-
-#define bfd_elfNN_archive_slurp_armap \
-  _bfd_vms_lib_slurp_armap
-#define bfd_elfNN_archive_slurp_extended_name_table \
-  _bfd_vms_lib_slurp_extended_name_table
-#define bfd_elfNN_archive_construct_extended_name_table \
-  _bfd_vms_lib_construct_extended_name_table
-#define bfd_elfNN_archive_truncate_arname \
-  _bfd_vms_lib_truncate_arname
-#define bfd_elfNN_archive_write_armap \
-  _bfd_vms_lib_write_armap
-#define bfd_elfNN_archive_read_ar_hdr \
-  _bfd_vms_lib_read_ar_hdr
-#define bfd_elfNN_archive_write_ar_hdr \
-  _bfd_vms_lib_write_ar_hdr
-#define bfd_elfNN_archive_openr_next_archived_file \
-  _bfd_vms_lib_openr_next_archived_file
-#define bfd_elfNN_archive_get_elt_at_index \
-  _bfd_vms_lib_get_elt_at_index
-#define bfd_elfNN_archive_generic_stat_arch_elt \
-  _bfd_vms_lib_generic_stat_arch_elt
-#define bfd_elfNN_archive_update_armap_timestamp \
-  _bfd_vms_lib_update_armap_timestamp
-
-#include "elfNN-target.h"
-
-#endif /* INCLUDE_IA64_VMS */
diff --git a/configure b/configure
index e3fef4f..2fee66b 100755
--- a/configure
+++ b/configure
@@ -3093,7 +3093,9 @@ case "${target}" in
     noconfigdirs="$noconfigdirs target-libssp"
     ;;
   rl78-*-*)
-    # Dereferencing -1 is a compile-time error
+    # libssp uses a misaligned load to trigger a fault, but the RL78
+    # doesn't fault for those - instead, it gives a build-time error
+    # for explicit misaligned loads.
     noconfigdirs="$noconfigdirs target-libssp"
     ;;
 esac
@@ -3496,8 +3498,7 @@ case "${target}" in
     noconfigdirs="$noconfigdirs libgui itcl ld"
     ;;
   ia64*-*-*vms*)
-    # No ld support yet.
-    noconfigdirs="$noconfigdirs libgui itcl ld"
+    noconfigdirs="$noconfigdirs libgui itcl"
     ;;
   i[3456789]86-w64-mingw*)
     ;;
diff --git a/configure.ac b/configure.ac
index 386ec78..c279587 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1,5 +1,5 @@
 #   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
-#   2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
+#   2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
 #   Free Software Foundation, Inc.
 #
 # This file is free software; you can redistribute it and/or modify it
@@ -519,7 +519,9 @@ case "${target}" in
     noconfigdirs="$noconfigdirs target-libssp"
     ;;
   rl78-*-*)
-    # Dereferencing -1 is a compile-time error
+    # libssp uses a misaligned load to trigger a fault, but the RL78
+    # doesn't fault for those - instead, it gives a build-time error
+    # for explicit misaligned loads.
     noconfigdirs="$noconfigdirs target-libssp"
     ;;
 esac
@@ -922,8 +924,7 @@ case "${target}" in
     noconfigdirs="$noconfigdirs libgui itcl ld"
     ;;
   ia64*-*-*vms*)
-    # No ld support yet.
-    noconfigdirs="$noconfigdirs libgui itcl ld"
+    noconfigdirs="$noconfigdirs libgui itcl"
     ;;
   i[[3456789]]86-w64-mingw*)
     ;;
diff --git a/ld/ChangeLog b/ld/ChangeLog
index ebad05a..b97aa86 100644
--- a/ld/ChangeLog
+++ b/ld/ChangeLog
@@ -1,3 +1,14 @@
+2012-04-11  Tristan Gingold  <gingold@adacore.com>
+
+	* scripttempl/ia64vms.sc: New file.
+	* emultempl/vms.em (_before_parse): Support for ia64.
+	(elf64-ia64-vms): New fragment for ia64.
+	* emulparams/elf64_ia64_vms.sh: New file.
+	* configure.tgt (ia64-*-*vms*): Add.
+	* Makefile.am (ALL_64_EMULATION_SOURCES): Add eelf64_ia64_vms.c
+	(eelf64_ia64_vms.c): New rule.
+	* Makefile.in: Regenerate.
+
 2012-04-06  Roland McGrath  <mcgrathr@google.com>
 
 	* configure.in (AC_CHECK_HEADERS): Add locale.h.
diff --git a/ld/Makefile.am b/ld/Makefile.am
index 524350e..df7ab98 100644
--- a/ld/Makefile.am
+++ b/ld/Makefile.am
@@ -467,6 +467,7 @@ ALL_64_EMULATION_SOURCES = \
 	eelf64_aix.c \
 	eelf64_ia64.c \
 	eelf64_ia64_fbsd.c \
+	eelf64_ia64_vms.c \
 	eelf64_s390.c \
 	eelf64_sparc.c \
 	eelf64_sparc_fbsd.c \
@@ -1928,6 +1929,10 @@ eelf64_ia64_fbsd.c: $(srcdir)/emulparams/elf64_ia64_fbsd.sh \
   $(srcdir)/emultempl/needrelax.em \
   $(srcdir)/scripttempl/elf.sc ${GEN_DEPENDS}
 	${GENSCRIPTS} elf64_ia64_fbsd "$(tdir_elf64_ia64_fbsd)"
+eelf64_ia64_vms.c: $(srcdir)/emulparams/elf64_ia64_vms.sh \
+  $(srcdir)/emultempl/vms.em \
+  $(srcdir)/scripttempl/ia64vms.sc ${GEN_DEPENDS}
+	${GENSCRIPTS} elf64_ia64_vms "$(tdir_elf64_ia64_vms)"
 eelf64_s390.c: $(srcdir)/emulparams/elf64_s390.sh \
   $(ELF_DEPS) $(srcdir)/scripttempl/elf.sc ${GEN_DEPENDS}
 	${GENSCRIPTS} elf64_s390 "$(tdir_elf64_s390)"
diff --git a/ld/Makefile.in b/ld/Makefile.in
index 776a4e0..af27d3f 100644
--- a/ld/Makefile.in
+++ b/ld/Makefile.in
@@ -55,6 +55,7 @@ am__aclocal_m4_deps = $(top_srcdir)/../bfd/acinclude.m4 \
 	$(top_srcdir)/../config/depstand.m4 \
 	$(top_srcdir)/../config/gettext-sister.m4 \
 	$(top_srcdir)/../config/largefile.m4 \
+	$(top_srcdir)/../config/lcmessage.m4 \
 	$(top_srcdir)/../config/lead-dot.m4 \
 	$(top_srcdir)/../config/nls.m4 \
 	$(top_srcdir)/../config/override.m4 \
@@ -772,6 +773,7 @@ ALL_64_EMULATION_SOURCES = \
 	eelf64_aix.c \
 	eelf64_ia64.c \
 	eelf64_ia64_fbsd.c \
+	eelf64_ia64_vms.c \
 	eelf64_s390.c \
 	eelf64_sparc.c \
 	eelf64_sparc_fbsd.c \
@@ -1176,6 +1178,7 @@ distclean-compile:
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/eelf64_aix.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/eelf64_ia64.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/eelf64_ia64_fbsd.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/eelf64_ia64_vms.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/eelf64_s390.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/eelf64_sparc.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/eelf64_sparc_fbsd.Po@am__quote@
@@ -3389,6 +3392,10 @@ eelf64_ia64_fbsd.c: $(srcdir)/emulparams/elf64_ia64_fbsd.sh \
   $(srcdir)/emultempl/needrelax.em \
   $(srcdir)/scripttempl/elf.sc ${GEN_DEPENDS}
 	${GENSCRIPTS} elf64_ia64_fbsd "$(tdir_elf64_ia64_fbsd)"
+eelf64_ia64_vms.c: $(srcdir)/emulparams/elf64_ia64_vms.sh \
+  $(srcdir)/emultempl/vms.em \
+  $(srcdir)/scripttempl/ia64vms.sc ${GEN_DEPENDS}
+	${GENSCRIPTS} elf64_ia64_vms "$(tdir_elf64_ia64_vms)"
 eelf64_s390.c: $(srcdir)/emulparams/elf64_s390.sh \
   $(ELF_DEPS) $(srcdir)/scripttempl/elf.sc ${GEN_DEPENDS}
 	${GENSCRIPTS} elf64_s390 "$(tdir_elf64_s390)"
diff --git a/ld/configure.tgt b/ld/configure.tgt
index 6418768..abb4706 100644
--- a/ld/configure.tgt
+++ b/ld/configure.tgt
@@ -308,6 +308,7 @@ ia64-*-freebsd* | ia64-*-kfreebsd*-gnu)
 			targ_extra_emuls="elf64_ia64" ;;
 ia64-*-netbsd*)		targ_emul=elf64_ia64 ;;
 ia64-*-linux*)		targ_emul=elf64_ia64 ;;
+ia64-*-*vms*)		targ_emul=elf64_ia64_vms ;;
 ia64-*-aix*)		targ_emul=elf64_aix
 			;;
 ip2k-*-elf)		targ_emul=elf32ip2k
diff --git a/ld/emulparams/elf64_ia64_vms.sh b/ld/emulparams/elf64_ia64_vms.sh
new file mode 100644
index 0000000..0688402
--- /dev/null
+++ b/ld/emulparams/elf64_ia64_vms.sh
@@ -0,0 +1,7 @@
+SCRIPT_NAME=ia64vms
+
+OUTPUT_FORMAT="elf64-ia64-vms"
+ARCH=ia64
+
+COMPILE_IN=yes
+EXTRA_EM_FILE=vms
diff --git a/ld/emultempl/vms.em b/ld/emultempl/vms.em
index 164f2e1..98837e3 100644
--- a/ld/emultempl/vms.em
+++ b/ld/emultempl/vms.em
@@ -31,6 +31,10 @@ gld${EMULATION_NAME}_before_parse (void)
   ldfile_set_output_arch ("${ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`);
   input_flags.dynamic = TRUE;
   config.has_shared = FALSE; /* Not yet.  */
+
+  /* For ia64, harmless for alpha.  */
+  link_info.emit_hash = FALSE;
+  link_info.spare_dynamic_tags = 0;
 }
 
 /* This is called before the input files are opened.  We add the
@@ -132,7 +136,8 @@ gld${EMULATION_NAME}_add_options
    int nrl ATTRIBUTE_UNUSED,
    struct option **really_longopts ATTRIBUTE_UNUSED)
 {
-  static const struct option xtra_long[] = {
+  static const struct option xtra_long[] =
+  {
     {"identification", required_argument, NULL, OPTION_IDENTIFICATION},
     {NULL, no_argument, NULL, 0}
   };
@@ -166,6 +171,63 @@ gld${EMULATION_NAME}_handle_option (int optc)
 
 EOF
 
+if test "$OUTPUT_FORMAT" = "elf64-ia64-vms"; then
+
+fragment <<EOF
+#include "elf-bfd.h"
+EOF
+
+source_em ${srcdir}/emultempl/elf-generic.em
+
+fragment <<EOF
+
+/* This is called after the sections have been attached to output
+   sections, but before any sizes or addresses have been set.  */
+
+static void
+gld${EMULATION_NAME}_before_allocation (void)
+{
+  const struct elf_backend_data *bed;
+
+  if (!is_elf_hash_table (link_info.hash))
+    return;
+
+  bed = get_elf_backend_data (link_info.output_bfd);
+
+  /* The backend must work out the sizes of all the other dynamic
+     sections.  */
+  if (elf_hash_table (&link_info)->dynamic_sections_created
+      && bed->elf_backend_size_dynamic_sections
+      && ! (*bed->elf_backend_size_dynamic_sections) (link_info.output_bfd,
+                                                      &link_info))
+    einfo ("%P%F: failed to set dynamic section sizes: %E\n");
+
+  before_allocation_default ();
+}
+
+static void
+gld${EMULATION_NAME}_after_allocation (void)
+{
+  bfd_boolean need_layout = bfd_elf_discard_info (link_info.output_bfd,
+						  &link_info);
+  gld${EMULATION_NAME}_map_segments (need_layout);
+}
+
+static void
+gld${EMULATION_NAME}_after_parse (void)
+{
+  link_info.relax_pass = 2;
+  after_parse_default ();
+}
+EOF
+
+LDEMUL_BEFORE_ALLOCATION=gld"$EMULATION_NAME"_before_allocation
+LDEMUL_AFTER_ALLOCATION=gld"$EMULATION_NAME"_after_allocation
+
+LDEMUL_AFTER_PARSE=gld${EMULATION_NAME}_after_parse
+source_em ${srcdir}/emultempl/needrelax.em
+fi
+
 LDEMUL_PLACE_ORPHAN=vms_place_orphan
 LDEMUL_BEFORE_PARSE=gld"$EMULATION_NAME"_before_parse
 LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=gld"$EMULATION_NAME"_create_output_section_statements
diff --git a/ld/scripttempl/ia64vms.sc b/ld/scripttempl/ia64vms.sc
new file mode 100644
index 0000000..b0b1c42
--- /dev/null
+++ b/ld/scripttempl/ia64vms.sc
@@ -0,0 +1,129 @@
+# Linker script for Itanium VMS systems.
+# Tristan Gingold <gingold@adacore.com>.
+
+PAGESIZE=0x10000
+BLOCKSIZE=0x200
+
+cat <<EOF
+OUTPUT_FORMAT("${OUTPUT_FORMAT}")
+${LIB_SEARCH_DIRS}
+ENTRY(__entry)
+
+SECTIONS
+{
+  /* RW segment.  */
+  ${RELOCATING+. = ${PAGESIZE};}
+
+  \$DATA\$ ALIGN (${BLOCKSIZE}) : {
+    *(\$DATA\$ .data .data.*)
+    *(\$BSS\$ .bss)
+  }
+
+  /* Code segment.  Note: name must be \$CODE\$ */
+  ${RELOCATING+. = ALIGN (${PAGESIZE});}
+
+  \$CODE\$ ALIGN (${BLOCKSIZE}) : {
+    *(\$CODE\$ .text)
+  }
+  .plt ALIGN (8) : {
+    *(.plt)
+  }
+
+  /* RO segment.  */
+  ${RELOCATING+. = ALIGN (${PAGESIZE});}
+
+  /* RO initialized data.  */
+  \$LITERAL\$ ALIGN (${BLOCKSIZE}) : {
+    *(\$LITERAL\$)
+    *(\$READONLY\$ .rodata)
+    *(.jcr)
+    *(.ctors)
+    *(.dtors)
+    *(.opd)
+    *(.gcc_except_table)
+
+    /* LIB$INITIALIZE stuff.  */
+    *(LIB\$INITIALIZDZ)	/* Start marker.  */
+    *(LIB\$INITIALIZD_)	/* Hi priority.  */
+    *(LIB\$INITIALIZE)	/* User.  */
+    *(LIB\$INITIALIZE$)	/* End marker.  */
+  }
+
+  /* Short segment.  */
+  ${RELOCATING+. = ALIGN (${PAGESIZE});}
+
+  .srodata : {
+    *(.srodata)
+  }
+  .got ALIGN (8) : {
+    *(.got)
+  }
+  .IA_64.pltoff ALIGN (16) : {
+    *(.IA_64.pltoff)
+  }
+  \$TFR\$ ALIGN (16) : {
+    /* Tranfer vector.  */
+    __entry = .;
+    *(.transfer)
+  }
+
+  ${RELOCATING+. = ALIGN (${PAGESIZE});}
+
+  \$RW_SHORT\$ ALIGN (${BLOCKSIZE}) : {
+    *(.sdata .sdata.*)
+    *(.sbss)
+  }
+
+  ${RELOCATING+. = ALIGN (${PAGESIZE});}
+
+  .IA_64.unwind ALIGN (${BLOCKSIZE}) : {
+    *(.IA_64.unwind .IA_64.unwind.*)
+  }
+
+  .IA_64.unwind_info ALIGN (8) : {
+    *(.IA_64.unwind_info .IA_64.unwind_info.*)
+  }
+
+  ${RELOCATING+. = ALIGN (${PAGESIZE});}
+
+  .dynamic /* \$DYNAMIC\$ */ ALIGN (${BLOCKSIZE}) : {
+    *(.dynamic)
+    *(.vmsdynstr)
+    *(.fixups)
+  }
+
+  ${RELOCATING+. = ALIGN (${PAGESIZE});}
+
+  .dynstr : { *(.dynstr) }
+
+  .dynsym       ${RELOCATING-0} : { *(.dynsym) }
+  .rela.got : { *(.rela.got) }
+  .got.plt : { *(.got.plt) }
+  .gnu.version_d : { *(.gnu.version_d) }
+  .gnu.version : { *(.gnu.version) }
+  .gnu.version_r : { *(.gnu.version_r) }
+  .rela.IA_64.pltoff : { *(.rela.IA_64.pltoff) }
+
+  /* DWARF 2 */
+  .debug_info     0 : { *(.debug_info${RELOCATING+ .gnu.linkonce.wi.*}) }
+  .debug_abbrev   0 : { *(.debug_abbrev) }
+  .debug_line     0 : { *(.debug_line) }
+  .debug_frame    0 : { *(.debug_frame) }
+  .debug_str      0 : { *(.debug_str) }
+  .debug_loc      0 : { *(.debug_loc) }
+  .debug_macinfo  0 : { *(.debug_macinfo) }
+  .debug_aranges  0 : { *(.debug_aranges) }
+  .debug_pubnames 0 : { *(.debug_pubnames) }
+  .trace_info     0 : { *(.trace_info) }
+  .trace_abbrev   0 : { *(.trace_abbrev) }
+  .trace_aranges  0 : { *(.trace_aranges) }
+
+  /* DWARF 3 */
+  .debug_pubtypes 0 : { *(.debug_pubtypes) }
+  .debug_ranges   0 : { *(.debug_ranges) }
+
+  .note : { *(.vms.note) }
+
+  /DISCARD/ : { *(.note) }
+}
+EOF