2010-04-14 Tristan Gingold <gingold@adacore.com>

	* Makefile.am (BFD32_BACKENDS): Remove vms-gsd.lo, vms-hdr.lo,
	vms-tir.lo, vms.lo and add vms-alpha.lo
	(BFD32_BACKENDS_CFILES): Remove vms-gsd.c, vms-hdr.c,
	vms-tir.c, vms.c and add vms-alpha.c
	* Makefile.in: Regenerate.
	* configure.in (TDEFINES): Adjust file list for vms_alpha_vec.
	Remove vms_vax_vec.
	* configure: Regenerate.
	* targets.c (vms_vax_vec): Remove the declaration.
	(_bfd_target_vector): Remove vms_vax_vec.
	* vms-alpha.c: New file.
	* vms-gsd.c: Removed, rewritten in vms-alpha.c
	* vms-hdr.c: Ditto.
	* vms-tir.c: Ditto.
	* vms.c: Ditto.
	* vms-misc.c: Fix indentation and comments.  Replace most of
	#if VMS_DEBUG/vms_debug with vms_debug2.
	(_bfd_vms_hash_newfunc): Moved to vms-alpha.c
	(hash_string): Ditto.
	(_bfd_vms_length_hash_symbol): Ditto.
	(maybe_adjust_record_pointer_for_object): Ditto.
	(_bfd_vms_get_object_record): Ditto.
	(vms_get_remaining_object_record): Ditto.
	(_bfd_vms_push): Ditto.
	(_bfd_vms_pop): Ditto.
	(_bfd_vms_get_header_values): Removed.
	(_bfd_vms_get_first_record): Removed.
	(vms_get_remaining_image_record): Removed.
	(new_symbol): Removed.
	(_bfd_vms_enter_symbol): Removed.
	(_bfd_vms_save_sized_string): Use memcpy instead of strncpy.
	(_bfd_vms_output_begin): Remove rechead parameter.  Replace bfd
	parameter with struct vms_rec_wr.
	(_bfd_vms_output_push): Removed and replaced by ...
	(_bfd_vms_output_begin_subrec): ... new function.
	(_bfd_vms_output_alignment): Replace bfd parameter with
	struct vms_rec_wr, and adjust.
	(_bfd_vms_output_check): Ditto
	(_bfd_vms_output_byte): Ditto.
	(_bfd_vms_output_short): Ditto.
	(_bfd_vms_output_long): Ditto.
	(_bfd_vms_output_quad): Ditto.
	(_bfd_vms_output_counted): Ditto.
	(_bfd_vms_output_dump): Ditto.
	(_bfd_vms_output_fill): Ditto.
	(_bfd_vms_output_pop): Removed and replaced by ...
	(_bfd_vms_output_end_subrec): ... new function.
	(_bfd_vms_output_flush): Removed.
	(_bfd_vms_output_align): New function.
	(_bfd_vms_output_end): Add recwr parameter.  Adjust for this new
	parameter.
	(vms_convert_to_var): New function imported from vms.c
	(vms_convert_to_var_1): Ditto.
	(vms_convert_to_var_unix_filename): Ditto.
	(vms_get_module_name): Ditto.
	(get_vms_time_string): Ditto.
	(vms_time_to_time_t): Ditto.
	(vms_rawtime_to_time_t): Ditto.
	* vms.h: All macros for the VMS file format are now in include/vms.
	Prototypes for vms.c, vms-gsd.c, vms-misc.c, vms-hdr.c, vms-tir.c
	have been removed.
	(struct vms_symbol_struct, struct stack_struct): Moved to vms-alpha.c
	(struct fileinfo, struct srecinfo, struct lineinfo): Ditto.
	(struct funcinfo, struct vms_private_data_struct): Ditto.
	(struct vms_section_data_struct): Ditto.
	(struct vms_rec_rd, stryct vms_rec_wr): New declarations.
	(vms_get_module_name, get_vms_time_string): New declarations.
	(vms_time_to_time_t, vms_rawtime_to_time_t): Ditto.
	(_bfd_vms_output_begin_subrec, _bfd_vms_output_end_subrec): Ditto.
	(_bfd_vms_save_sized_string, _bfd_vms_save_counted_string): Adjusted.
	(_bfd_vms_output_begin, _bfd_vms_output_alignment): Ditto.
	(_bfd_vms_output_end,_bfd_vms_output_check): Ditto.
	(_bfd_vms_output_byte, _bfd_vms_output_short): Ditto.
	(_bfd_vms_output_long, _bfd_vms_output_quad): Ditto.
	(_bfd_vms_output_counted, _bfd_vms_output_dump): Ditto.
	(_bfd_vms_output_fill): Ditto.
	(bfd_vms_set_section_flags): Ditto.

13 files changed, 9304 insertions, 8408 deletions

diff --git a/bfd/ChangeLog b/bfd/ChangeLog
index 3ec74f2..59e1cba 100644
--- a/bfd/ChangeLog
+++ b/bfd/ChangeLog
@@ -1,3 +1,83 @@
+2010-04-14  Tristan Gingold  <gingold@adacore.com>
+
+	* Makefile.am (BFD32_BACKENDS): Remove vms-gsd.lo, vms-hdr.lo,
+	vms-tir.lo, vms.lo and add vms-alpha.lo
+	(BFD32_BACKENDS_CFILES): Remove vms-gsd.c, vms-hdr.c,
+	vms-tir.c, vms.c and add vms-alpha.c
+	* Makefile.in: Regenerate.
+	* configure.in (TDEFINES): Adjust file list for vms_alpha_vec.
+	Remove vms_vax_vec.
+	* configure: Regenerate.
+	* targets.c (vms_vax_vec): Remove the declaration.
+	(_bfd_target_vector): Remove vms_vax_vec.
+	* vms-alpha.c: New file.
+	* vms-gsd.c: Removed, rewritten in vms-alpha.c
+	* vms-hdr.c: Ditto.
+	* vms-tir.c: Ditto.
+	* vms.c: Ditto.
+	* vms-misc.c: Fix indentation and comments.  Replace most of
+	#if VMS_DEBUG/vms_debug with vms_debug2.
+	(_bfd_vms_hash_newfunc): Moved to vms-alpha.c
+	(hash_string): Ditto.
+	(_bfd_vms_length_hash_symbol): Ditto.
+	(maybe_adjust_record_pointer_for_object): Ditto.
+	(_bfd_vms_get_object_record): Ditto.
+	(vms_get_remaining_object_record): Ditto.
+	(_bfd_vms_push): Ditto.
+	(_bfd_vms_pop): Ditto.
+	(_bfd_vms_get_header_values): Removed.
+	(_bfd_vms_get_first_record): Removed.
+	(vms_get_remaining_image_record): Removed.
+	(new_symbol): Removed.
+	(_bfd_vms_enter_symbol): Removed.
+	(_bfd_vms_save_sized_string): Use memcpy instead of strncpy.
+	(_bfd_vms_output_begin): Remove rechead parameter.  Replace bfd
+	parameter with struct vms_rec_wr.
+	(_bfd_vms_output_push): Removed and replaced by ...
+	(_bfd_vms_output_begin_subrec): ... new function.
+	(_bfd_vms_output_alignment): Replace bfd parameter with
+	struct vms_rec_wr, and adjust.
+	(_bfd_vms_output_check): Ditto
+	(_bfd_vms_output_byte): Ditto.
+	(_bfd_vms_output_short): Ditto.
+	(_bfd_vms_output_long): Ditto.
+	(_bfd_vms_output_quad): Ditto.
+	(_bfd_vms_output_counted): Ditto.
+	(_bfd_vms_output_dump): Ditto.
+	(_bfd_vms_output_fill): Ditto.
+	(_bfd_vms_output_pop): Removed and replaced by ...
+	(_bfd_vms_output_end_subrec): ... new function.
+	(_bfd_vms_output_flush): Removed.
+	(_bfd_vms_output_align): New function.
+	(_bfd_vms_output_end): Add recwr parameter.  Adjust for this new
+	parameter.
+	(vms_convert_to_var): New function imported from vms.c
+	(vms_convert_to_var_1): Ditto.
+	(vms_convert_to_var_unix_filename): Ditto.
+	(vms_get_module_name): Ditto.
+	(get_vms_time_string): Ditto.
+	(vms_time_to_time_t): Ditto.
+	(vms_rawtime_to_time_t): Ditto.
+	* vms.h: All macros for the VMS file format are now in include/vms.
+	Prototypes for vms.c, vms-gsd.c, vms-misc.c, vms-hdr.c, vms-tir.c
+	have been removed.
+	(struct vms_symbol_struct, struct stack_struct): Moved to vms-alpha.c
+	(struct fileinfo, struct srecinfo, struct lineinfo): Ditto.
+	(struct funcinfo, struct vms_private_data_struct): Ditto.
+	(struct vms_section_data_struct): Ditto.
+	(struct vms_rec_rd, stryct vms_rec_wr): New declarations.
+	(vms_get_module_name, get_vms_time_string): New declarations.
+	(vms_time_to_time_t, vms_rawtime_to_time_t): Ditto.
+	(_bfd_vms_output_begin_subrec, _bfd_vms_output_end_subrec): Ditto.
+	(_bfd_vms_save_sized_string, _bfd_vms_save_counted_string): Adjusted.
+	(_bfd_vms_output_begin, _bfd_vms_output_alignment): Ditto.
+	(_bfd_vms_output_end,_bfd_vms_output_check): Ditto.
+	(_bfd_vms_output_byte, _bfd_vms_output_short): Ditto.
+	(_bfd_vms_output_long, _bfd_vms_output_quad): Ditto.
+	(_bfd_vms_output_counted, _bfd_vms_output_dump): Ditto.
+	(_bfd_vms_output_fill): Ditto.
+	(bfd_vms_set_section_flags): Ditto.
+
 2010-04-14  Matthew Gretton-Dann  <matthew.gretton-dann@arm.com>
 
 	* elflink.c (_bfd_elf_merge_symbol): Tighten up the test for early
diff --git a/bfd/Makefile.am b/bfd/Makefile.am
index ac38177..ef545f5 100644
--- a/bfd/Makefile.am
+++ b/bfd/Makefile.am
@@ -391,12 +391,9 @@ BFD32_BACKENDS = \
 	vaxbsd.lo \
 	vaxnetbsd.lo \
 	versados.lo \
-	vms-gsd.lo \
-	vms-hdr.lo \
+	vms-alpha.lo \
 	vms-lib.lo \
 	vms-misc.lo \
-	vms-tir.lo \
-	vms.lo \
 	xcofflink.lo \
 	xsym.lo \
 	xtensa-isa.lo \
@@ -576,12 +573,9 @@ BFD32_BACKENDS_CFILES = \
 	vaxbsd.c \
 	vaxnetbsd.c \
 	versados.c \
-	vms-gsd.c \
-	vms-hdr.c \
+	vms-alpha.c \
 	vms-lib.c \
 	vms-misc.c \
-	vms-tir.c \
-	vms.c \
 	xcofflink.c \
 	xsym.c \
 	xtensa-isa.c \
diff --git a/bfd/Makefile.in b/bfd/Makefile.in
index ed626c9..7134a70 100644
--- a/bfd/Makefile.in
+++ b/bfd/Makefile.in
@@ -688,12 +688,9 @@ BFD32_BACKENDS = \
 	vaxbsd.lo \
 	vaxnetbsd.lo \
 	versados.lo \
-	vms-gsd.lo \
-	vms-hdr.lo \
-	vms-lib.lo \
 	vms-misc.lo \
-	vms-tir.lo \
-	vms.lo \
+	vms-alpha.lo \
+	vms-lib.lo \
 	xcofflink.lo \
 	xsym.lo \
 	xtensa-isa.lo \
@@ -873,12 +870,9 @@ BFD32_BACKENDS_CFILES = \
 	vaxbsd.c \
 	vaxnetbsd.c \
 	versados.c \
-	vms-gsd.c \
-	vms-hdr.c \
+	vms-alpha.c \
 	vms-lib.c \
 	vms-misc.c \
-	vms-tir.c \
-	vms.c \
 	xcofflink.c \
 	xsym.c \
 	xtensa-isa.c \
@@ -1488,12 +1482,9 @@ distclean-compile:
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/vaxnetbsd.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/verilog.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/versados.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/vms-gsd.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/vms-hdr.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/vms-alpha.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/vms-lib.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/vms-misc.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/vms-tir.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/vms.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/xcofflink.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/xsym.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/xtensa-isa.Plo@am__quote@
diff --git a/bfd/configure b/bfd/configure
index 928f984..7d16fab 100755
--- a/bfd/configure
+++ b/bfd/configure
@@ -15283,9 +15283,8 @@ do
     vax1knetbsd_vec)		tb="$tb vax1knetbsd.lo aout32.lo" ;;
     vaxbsd_vec)			tb="$tb vaxbsd.lo aout32.lo" ;;
     versados_vec)		tb="$tb versados.lo" ;;
-    vms_alpha_vec)		tb="$tb vms.lo vms-hdr.lo vms-gsd.lo vms-tir.lo vms-misc.lo vms-lib.lo"; target_size=64 ;;
+    vms_alpha_vec)		tb="$tb vms-alpha.lo vms-misc.lo vms-lib.lo"; target_size=64 ;;
     vms_lib_txt_vec)		tb="$tb vms-lib.lo vms-misc.lo" ;;
-    vms_vax_vec)		tb="$tb vms.lo vms-hdr.lo vms-gsd.lo vms-tir.lo vms-misc.lo" ;;
     w65_vec)			tb="$tb coff-w65.lo reloc16.lo" ;;
     we32kcoff_vec)		tb="$tb coff-we32k.lo" ;;
     z80coff_vec)		tb="$tb coff-z80.lo reloc16.lo" ;;
diff --git a/bfd/configure.in b/bfd/configure.in
index 28d5bdd..eb9d7e7 100644
--- a/bfd/configure.in
+++ b/bfd/configure.in
@@ -927,9 +927,8 @@ do
     vax1knetbsd_vec)		tb="$tb vax1knetbsd.lo aout32.lo" ;;
     vaxbsd_vec)			tb="$tb vaxbsd.lo aout32.lo" ;;
     versados_vec)		tb="$tb versados.lo" ;;
-    vms_alpha_vec)		tb="$tb vms.lo vms-hdr.lo vms-gsd.lo vms-tir.lo vms-misc.lo vms-lib.lo"; target_size=64 ;;
+    vms_alpha_vec)		tb="$tb vms-alpha.lo vms-misc.lo vms-lib.lo"; target_size=64 ;;
     vms_lib_txt_vec)		tb="$tb vms-lib.lo vms-misc.lo" ;;
-    vms_vax_vec)		tb="$tb vms.lo vms-hdr.lo vms-gsd.lo vms-tir.lo vms-misc.lo" ;;
     w65_vec)			tb="$tb coff-w65.lo reloc16.lo" ;;
     we32kcoff_vec)		tb="$tb coff-we32k.lo" ;;
     z80coff_vec)		tb="$tb coff-z80.lo reloc16.lo" ;;
diff --git a/bfd/targets.c b/bfd/targets.c
index 5ee73c4..2e330e6 100644
--- a/bfd/targets.c
+++ b/bfd/targets.c
@@ -828,7 +828,6 @@ extern const bfd_target vax1knetbsd_vec;
 extern const bfd_target versados_vec;
 extern const bfd_target vms_alpha_vec;
 extern const bfd_target vms_lib_txt_vec;
-extern const bfd_target vms_vax_vec;
 extern const bfd_target w65_vec;
 extern const bfd_target we32kcoff_vec;
 extern const bfd_target x86_64pe_vec;
@@ -1229,7 +1228,6 @@ static const bfd_target * const _bfd_target_vector[] =
 	&vms_alpha_vec,
 #endif
         &vms_lib_txt_vec,
-	&vms_vax_vec,
 	&w65_vec,
 	&we32kcoff_vec,
 	&z80coff_vec,
diff --git a/bfd/vms-alpha.c b/bfd/vms-alpha.c
new file mode 100644
index 0000000..e213f4ee
--- /dev/null
+++ b/bfd/vms-alpha.c
@@ -0,0 +1,8968 @@
+/* vms.c -- BFD back-end for EVAX (openVMS/Alpha) files.
+   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+   2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+
+   Initial version written by Klaus Kaempf (kkaempf@rmi.de)
+   Major rewrite by Adacore.
+
+   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.  */
+
+/* TODO:
+   o  DMT
+   o  PIC
+   o  Generation of shared image
+   o  Generation of GST in image
+   o  Relocation optimizations
+   o  EISD for the stack
+   o  Vectors isect
+   o  64 bits sections
+   o  Entry point
+   ...
+*/
+
+#include "sysdep.h"
+#include "bfd.h"
+#include "bfdlink.h"
+#include "libbfd.h"
+#include "bfdver.h"
+
+#include "vms.h"
+#include "vms/eihd.h"
+#include "vms/eiha.h"
+#include "vms/eihi.h"
+#include "vms/eihs.h"
+#include "vms/eisd.h"
+#include "vms/dmt.h"
+#include "vms/dst.h"
+#include "vms/eihvn.h"
+#include "vms/eobjrec.h"
+#include "vms/egsd.h"
+#include "vms/egps.h"
+#include "vms/eeom.h"
+#include "vms/emh.h"
+#include "vms/eiaf.h"
+#include "vms/shl.h"
+#include "vms/eicp.h"
+#include "vms/etir.h"
+#include "vms/egsy.h"
+#include "vms/esdf.h"
+#include "vms/esdfm.h"
+#include "vms/esdfv.h"
+#include "vms/esrf.h"
+#include "vms/egst.h"
+#include "vms/dsc.h"
+#include "vms/prt.h"
+#include "vms/internal.h"
+
+
+#define MIN(a,b) ((a) < (b) ? (a) : (b))
+
+/* The r_type field in a reloc is one of the following values.  */
+#define ALPHA_R_IGNORE		0
+#define ALPHA_R_REFQUAD		1
+#define ALPHA_R_BRADDR		2
+#define ALPHA_R_HINT		3
+#define ALPHA_R_SREL16		4
+#define ALPHA_R_SREL32		5
+#define ALPHA_R_SREL64		6
+#define ALPHA_R_OP_PUSH		7
+#define ALPHA_R_OP_STORE	8
+#define ALPHA_R_OP_PSUB		9
+#define ALPHA_R_OP_PRSHIFT	10
+#define ALPHA_R_LINKAGE		11
+#define ALPHA_R_REFLONG		12
+#define ALPHA_R_CODEADDR	13
+#define ALPHA_R_NOP		14
+#define ALPHA_R_BSR		15
+#define ALPHA_R_LDA		16
+#define ALPHA_R_BOH		17
+/* These are used with DST_S_C_LINE_NUM.  */
+#define DST_S_C_LINE_NUM_HEADER_SIZE 4
+
+/* These are used with DST_S_C_SOURCE */
+
+#define DST_S_B_PCLINE_UNSBYTE	 1
+#define DST_S_W_PCLINE_UNSWORD	 1
+#define DST_S_L_PCLINE_UNSLONG	 1
+
+#define DST_S_B_MODBEG_NAME	14
+#define DST_S_L_RTNBEG_ADDRESS	 5
+#define DST_S_B_RTNBEG_NAME	13
+#define DST_S_L_RTNEND_SIZE	 5
+
+/* These are used with DST_S_C_SOURCE.  */
+#define DST_S_C_SOURCE_HEADER_SIZE 4
+
+#define DST_S_B_SRC_DF_LENGTH	  1
+#define DST_S_W_SRC_DF_FILEID	  3
+#define DST_S_B_SRC_DF_FILENAME	 20
+#define DST_S_B_SRC_UNSBYTE	  1
+#define DST_S_W_SRC_UNSWORD	  1
+#define DST_S_L_SRC_UNSLONG	  1
+
+/* Debugger symbol definitions.  */
+
+#define DBG_S_L_DMT_MODBEG       0
+#define DBG_S_L_DST_SIZE         4
+#define DBG_S_W_DMT_PSECT_COUNT  8
+#define DBG_S_C_DMT_HEADER_SIZE 12
+
+#define DBG_S_L_DMT_PSECT_START  0
+#define DBG_S_L_DMT_PSECT_LENGTH 4
+#define DBG_S_C_DMT_PSECT_SIZE   8
+
+/* VMS module header.  */
+
+struct hdr_struct
+{
+  char hdr_b_strlvl;
+  int hdr_l_arch1;
+  int hdr_l_arch2;
+  int hdr_l_recsiz;
+  char *hdr_t_name;
+  char *hdr_t_version;
+  char *hdr_t_date;
+  char *hdr_c_lnm;
+  char *hdr_c_src;
+  char *hdr_c_ttl;
+};
+
+#define EMH_DATE_LENGTH  17
+
+/* VMS End-Of-Module records (EOM/EEOM).  */
+
+struct eom_struct
+{
+  unsigned int eom_l_total_lps;
+  unsigned short eom_w_comcod;
+  bfd_boolean eom_has_transfer;
+  unsigned char eom_b_tfrflg;
+  unsigned int eom_l_psindx;
+  unsigned int eom_l_tfradr;
+};
+
+struct vms_symbol_entry
+{
+  bfd *owner;
+
+  /* Common fields.  */
+  unsigned char typ;
+  unsigned char data_type;
+  unsigned short flags;
+
+  /* Section and offset/value of the symbol.  */
+  unsigned int section;
+  unsigned int value;
+
+  /* Section and offset/value for the entry point (only for subprg).  */
+  unsigned int code_section;
+  unsigned int code_value;
+
+  /* Symbol vector offset.  */
+  unsigned int symbol_vector;
+
+  /* Length of the name.  */
+  unsigned char namelen;
+
+  char name[1];
+};
+
+/* Stack value for push/pop commands.  */
+
+struct stack_struct
+{
+  bfd_vma value;
+  unsigned int reloc;
+};
+
+#define STACKSIZE 128
+
+/* A minimal decoding of DST compilation units.  We only decode
+   what's needed to get to the line number information.  */
+
+struct fileinfo
+{
+  char *name;
+  unsigned int srec;
+};
+
+struct srecinfo
+{
+  struct srecinfo *next;
+  unsigned int line;
+  unsigned int sfile;
+  unsigned int srec;
+};
+
+struct lineinfo
+{
+  struct lineinfo *next;
+  bfd_vma address;
+  unsigned int line;
+};
+
+struct funcinfo
+{
+  struct funcinfo *next;
+  char *name;
+  bfd_vma low;
+  bfd_vma high;
+};
+
+struct module
+{
+  /* Chain the previously read compilation unit.  */
+  struct module *next;
+
+  /* The module name.  */
+  char *name;
+
+  /* The start offset and size of debug info in the DST section.  */
+  unsigned int modbeg;
+  unsigned int size;
+
+  /* The lowest and highest addresses contained in this compilation
+     unit as specified in the compilation unit header.  */
+  bfd_vma low;
+  bfd_vma high;
+
+  /* The listing line table.  */
+  struct lineinfo *line_table;
+
+  /* The source record table.  */
+  struct srecinfo *srec_table;
+
+  /* A list of the functions found in this module.  */
+  struct funcinfo *func_table;
+
+  /* Current allocation of file_table.  */
+  unsigned int file_table_count;
+
+  /* An array of the files making up this module.  */
+  struct fileinfo *file_table;
+};
+
+/* BFD private data for alpha-vms.  */
+
+struct vms_private_data_struct
+{
+  /* If true, relocs have been read.  */
+  bfd_boolean reloc_done;
+
+  /* Record input buffer.  */
+  struct vms_rec_rd recrd;
+  struct vms_rec_wr recwr;
+
+  struct hdr_struct hdr_data;		/* data from HDR/EMH record  */
+  struct eom_struct eom_data;		/* data from EOM/EEOM record  */
+  unsigned int section_count;		/* # of sections in following array  */
+  asection **sections;			/* array of GSD/EGSD sections  */
+
+  /* Array of raw symbols.  */
+  struct vms_symbol_entry **syms;
+
+  /* Canonicalized symbols.  */
+  asymbol **csymbols;
+
+  /* Number of symbols.  */
+  unsigned int gsd_sym_count;
+  /* Size of the syms array.  */
+  unsigned int max_sym_count;
+  /* Number of procedure symbols.  */
+  unsigned int norm_sym_count;
+
+  /* Stack used to evaluate TIR/ETIR commands.  */
+  struct stack_struct *stack;
+  int stackptr;
+
+  /* Content reading.  */
+  asection *image_section;		/* section for image_ptr  */
+  file_ptr image_offset;		/* Offset for image_ptr.  */
+  bfd_boolean image_autoextend;		/* Resize section if necessary.  */
+
+  struct module *modules;		/* list of all compilation units */
+
+  struct dst_info *dst_info;
+  asection *dst_section;
+
+  unsigned int dst_ptr_offsets_count;	/* # of offsets in following array  */
+  unsigned int *dst_ptr_offsets;	/* array of saved image_ptr offsets */
+
+  /* Shared library support */
+  bfd_vma symvva; /* relative virtual address of symbol vector */
+  unsigned int ident;
+  unsigned char matchctl;
+
+  /* Shared library index.  This is used for input bfd while linking.  */
+  unsigned int shr_index;
+
+  /* Used to place structures in the file.  */
+  file_ptr file_pos;
+
+  /* Simply linked list of eisd.  */
+  struct vms_internal_eisd_map *eisd_head;
+  struct vms_internal_eisd_map *eisd_tail;
+
+  /* Simply linked list of eisd for shared libraries.  */
+  struct vms_internal_eisd_map *gbl_eisd_head;
+  struct vms_internal_eisd_map *gbl_eisd_tail;
+
+  /* linkage index counter used by conditional store commands */
+  int vms_linkage_index;
+
+  /* see tc-alpha.c of gas for a description.  */
+  int flag_hash_long_names;	/* -+, hash instead of truncate */
+  int flag_show_after_trunc;	/* -H, show hashing/truncation */
+};
+
+#define PRIV2(abfd, name) \
+  (((struct vms_private_data_struct *)(abfd)->tdata.any)->name)
+#define PRIV(name) PRIV2(abfd,name)
+
+
+/* Used to keep extra VMS specific information for a given section.
+
+   reloc_size holds the size of the relocation stream, note this
+   is very different from the number of relocations as VMS relocations
+   are variable length.
+
+   reloc_stream is the actual stream of relocation entries.  */
+
+struct vms_section_data_struct
+{
+  /* Maximnum number of entries in sec->relocation.  */
+  unsigned reloc_max;
+
+  /* Corresponding eisd.  Used only while generating executables.  */
+  struct vms_internal_eisd_map *eisd;
+
+  /* PSC flags to be clear.  */
+  flagword no_flags;
+
+  /* PSC flags to be set.  */
+  flagword flags;
+};
+
+#define vms_section_data(sec) \
+  ((struct vms_section_data_struct *)sec->used_by_bfd)
+
+/* To be called from the debugger.  */
+struct vms_private_data_struct *bfd_vms_get_data (bfd *abfd);
+
+static int vms_get_remaining_object_record (bfd *abfd, int read_so_far);
+static bfd_boolean _bfd_vms_slurp_object_records (bfd * abfd);
+static void alpha_vms_add_fixup_lp (struct bfd_link_info *, bfd *, bfd *);
+static void alpha_vms_add_fixup_ca (struct bfd_link_info *, bfd *, bfd *);
+static void alpha_vms_add_fixup_qr (struct bfd_link_info *, bfd *, bfd *,
+                                    bfd_vma);
+static void alpha_vms_add_lw_reloc (struct bfd_link_info *info);
+static void alpha_vms_add_qw_reloc (struct bfd_link_info *info);
+static void alpha_vms_add_lw_fixup (struct bfd_link_info *, unsigned int,
+                                    bfd_vma);
+
+struct vector_type
+{
+  unsigned int max_el;
+  unsigned int nbr_el;
+  void *els;
+};
+
+/* Number of elements in VEC.  */
+
+#define VEC_COUNT(VEC) ((VEC).nbr_el)
+
+/* Get the address of the Nth element.  */
+
+#define VEC_EL(VEC, TYPE, N) (((TYPE *)((VEC).els))[N])
+
+#define VEC_INIT(VEC)                           \
+  do {                                          \
+    (VEC).max_el = 0;                           \
+    (VEC).nbr_el = 0;                           \
+    (VEC).els = NULL;                           \
+  } while (0)
+
+/* Be sure there is room for a new element.  */
+
+static void vector_grow1 (struct vector_type *vec, size_t elsz);
+
+/* Allocate room for a new element and return its address.  */
+
+#define VEC_APPEND(VEC, TYPE)                                   \
+  (vector_grow1 (&VEC, sizeof (TYPE)), &VEC_EL(VEC, TYPE, (VEC).nbr_el++))
+
+/* Append an element.  */
+
+#define VEC_APPEND_EL(VEC, TYPE, EL)            \
+  (*(VEC_APPEND (VEC, TYPE)) = EL)
+
+struct alpha_vms_vma_ref
+{
+  bfd_vma vma;	/* Vma in the output.  */
+  bfd_vma ref;	/* Reference in the input.  */
+};
+
+struct alpha_vms_shlib_el
+{
+  bfd *abfd;
+  bfd_boolean has_fixups;
+
+  struct vector_type lp;	/* Vector of bfd_vma.  */
+  struct vector_type ca;	/* Vector of bfd_vma.  */
+  struct vector_type qr;	/* Vector of struct alpha_vms_vma_ref.  */
+};
+
+/* Alpha VMS linker hash table.  */
+
+struct alpha_vms_link_hash_table
+{
+  struct bfd_link_hash_table root;
+
+  /* Vector of shared libaries.  */
+  struct vector_type shrlibs;
+
+  /* Fixup section.  */
+  asection *fixup;
+
+  /* Base address.  Used by fixups.  */
+  bfd_vma base_addr;
+};
+
+#define alpha_vms_link_hash(INFO) \
+  ((struct alpha_vms_link_hash_table *)(INFO->hash))
+
+/* Alpha VMS linker hash table entry.  */
+
+struct alpha_vms_link_hash_entry
+{
+  struct bfd_link_hash_entry root;
+
+  /* Pointer to the original vms symbol.  */
+  struct vms_symbol_entry *sym;
+};
+
+/* Image reading.  */
+
+/* Read & process EIHD record.
+   Return TRUE on success, FALSE on error.  */
+
+static bfd_boolean
+_bfd_vms_slurp_eihd (bfd *abfd, unsigned int *eisd_offset,
+                     unsigned int *eihs_offset)
+{
+  unsigned int imgtype, size;
+  bfd_vma symvva;
+  struct vms_eihd *eihd = (struct vms_eihd *)PRIV (recrd.rec);
+
+  vms_debug2 ((8, "_bfd_vms_slurp_eihd\n"));
+
+  size = bfd_getl32 (eihd->size);
+  imgtype = bfd_getl32 (eihd->imgtype);
+
+  if (imgtype == EIHD__K_EXE || imgtype == EIHD__K_LIM)
+    abfd->flags |= EXEC_P;
+
+  symvva = bfd_getl64 (eihd->symvva);
+  if (symvva != 0)
+    {
+      PRIV (symvva) = symvva;
+      abfd->flags |= DYNAMIC;
+    }
+
+  PRIV (ident) = bfd_getl32 (eihd->ident);
+  PRIV (matchctl) = eihd->matchctl;
+
+  *eisd_offset = bfd_getl32 (eihd->isdoff);
+  *eihs_offset = bfd_getl32 (eihd->symdbgoff);
+
+  vms_debug2 ((4, "EIHD size %d imgtype %d symvva 0x%lx eisd %d eihs %d\n",
+               size, imgtype, (unsigned long)symvva,
+               *eisd_offset, *eihs_offset));
+
+  return FALSE;
+}
+
+/* Read & process EISD record.
+   Return TRUE on success, FALSE on error.  */
+
+static bfd_boolean
+_bfd_vms_slurp_eisd (bfd *abfd, unsigned int offset)
+{
+  int section_count = 0;
+
+  vms_debug2 ((8, "_bfd_vms_slurp_eisd\n"));
+
+  while (1)
+    {
+      struct vms_eisd *eisd;
+      unsigned int rec_size;
+      unsigned int size;
+      unsigned long long vaddr;
+      unsigned int flags;
+      unsigned int vbn;
+      char *name = NULL;
+      asection *section;
+      flagword bfd_flags;
+
+      eisd = (struct vms_eisd *)(PRIV (recrd.rec) + offset);
+      rec_size = bfd_getl32 (eisd->eisdsize);
+
+      if (rec_size == 0)
+        break;
+
+      /* Skip to next block if pad.  */
+      if (rec_size == 0xffffffff)
+        {
+          offset = (offset + VMS_BLOCK_SIZE) & ~(VMS_BLOCK_SIZE - 1);
+          continue;
+        }
+      else
+        offset += rec_size;
+
+      size = bfd_getl32 (eisd->secsize);
+      vaddr = bfd_getl64 (eisd->virt_addr);
+      flags = bfd_getl32 (eisd->flags);
+      vbn = bfd_getl32 (eisd->vbn);
+
+      vms_debug2 ((4, "EISD at 0x%x size 0x%x addr 0x%lx flags 0x%x blk %d\n",
+                   offset, size, (unsigned long)vaddr, flags, vbn));
+
+      /* VMS combines psects from .obj files into isects in the .exe.  This
+	 process doesn't preserve enough information to reliably determine
+	 what's in each section without examining the data.  This is
+	 especially true of DWARF debug sections.  */
+      bfd_flags = SEC_ALLOC;
+
+      if (flags & EISD__M_EXE)
+	bfd_flags |= SEC_CODE | SEC_HAS_CONTENTS | SEC_LOAD;
+
+      if (flags & EISD__M_NONSHRADR)
+	bfd_flags |= SEC_DATA | SEC_HAS_CONTENTS | SEC_LOAD;
+
+      if (!(flags & EISD__M_WRT))
+	bfd_flags |= SEC_READONLY;
+
+      if (flags & EISD__M_DZRO)
+	bfd_flags |= SEC_DATA;
+
+      if (flags & EISD__M_FIXUPVEC)
+	bfd_flags |= SEC_DATA | SEC_HAS_CONTENTS | SEC_LOAD;
+
+      if (flags & EISD__M_CRF)
+	bfd_flags |= SEC_HAS_CONTENTS | SEC_LOAD;
+
+      if (flags & EISD__M_GBL)
+	{
+	  name = _bfd_vms_save_counted_string (eisd->gblnam);
+	  bfd_flags |= SEC_COFF_SHARED_LIBRARY;
+	  bfd_flags &= ~(SEC_ALLOC | SEC_LOAD);
+	}
+      else if (flags & EISD__M_FIXUPVEC)
+        name = "$FIXUPVEC$";
+      else if (eisd->type == EISD__K_USRSTACK)
+        name = "$STACK$";
+      else
+	{
+          const char *pfx;
+
+	  name = (char*) bfd_alloc (abfd, 32);
+          if (flags & EISD__M_DZRO)
+            pfx = "BSS";
+          else if (flags & EISD__M_EXE)
+            pfx = "CODE";
+          else if (!(flags & EISD__M_WRT))
+            pfx = "RO";
+          else
+            pfx = "LOCAL";
+          BFD_ASSERT (section_count < 999);
+	  sprintf (name, "$%s_%03d$", pfx, section_count++);
+	}
+
+      section = bfd_make_section (abfd, name);
+
+      if (!section)
+	return FALSE;
+
+      section->filepos = vbn ? VMS_BLOCK_SIZE * (vbn - 1) : 0;
+      section->size = size;
+      section->vma = vaddr;
+
+      if (!bfd_set_section_flags (abfd, section, bfd_flags))
+	return FALSE;
+    }
+
+  return TRUE;
+}
+
+/* Read & process EIHS record.
+   Return TRUE on success, FALSE on error.  */
+
+static bfd_boolean
+_bfd_vms_slurp_eihs (bfd *abfd, unsigned int offset)
+{
+  unsigned char *p = PRIV (recrd.rec) + offset;
+  unsigned int gstvbn = bfd_getl32 (p + EIHS__L_GSTVBN);
+  unsigned int gstsize ATTRIBUTE_UNUSED = bfd_getl32 (p + EIHS__L_GSTSIZE);
+  unsigned int dstvbn = bfd_getl32 (p + EIHS__L_DSTVBN);
+  unsigned int dstsize = bfd_getl32 (p + EIHS__L_DSTSIZE);
+  unsigned int dmtvbn = bfd_getl32 (p + EIHS__L_DMTVBN);
+  unsigned int dmtbytes = bfd_getl32 (p + EIHS__L_DMTBYTES);
+  asection *section;
+
+#if VMS_DEBUG
+  vms_debug (8, "_bfd_vms_slurp_ihs\n");
+  vms_debug (4, "EIHS record gstvbn %d gstsize %d dstvbn %d dstsize %d dmtvbn %d dmtbytes %d\n",
+	     gstvbn, gstsize, dstvbn, dstsize, dmtvbn, dmtbytes);
+#endif
+
+  if (dstvbn)
+    {
+      flagword bfd_flags = SEC_HAS_CONTENTS | SEC_DEBUGGING;
+
+      section = bfd_make_section (abfd, "$DST$");
+      if (!section)
+	return FALSE;
+
+      section->size = dstsize;
+      section->filepos = VMS_BLOCK_SIZE * (dstvbn - 1);
+
+      if (!bfd_set_section_flags (abfd, section, bfd_flags))
+	return FALSE;
+
+      PRIV (dst_section) = section;
+      abfd->flags |= (HAS_DEBUG | HAS_LINENO);
+    }
+
+  if (dmtvbn)
+    {
+      flagword bfd_flags = SEC_HAS_CONTENTS | SEC_DEBUGGING;
+
+      section = bfd_make_section (abfd, "$DMT$");
+      if (!section)
+	return FALSE;
+
+      section->size = dmtbytes;
+      section->filepos = VMS_BLOCK_SIZE * (dmtvbn - 1);
+
+      if (!bfd_set_section_flags (abfd, section, bfd_flags))
+	return FALSE;
+    }
+
+  if (gstvbn)
+    {
+      flagword bfd_flags = SEC_HAS_CONTENTS;
+
+      section = bfd_make_section (abfd, "$GST$");
+      if (!section)
+	return FALSE;
+
+      if (bfd_seek (abfd, VMS_BLOCK_SIZE * (gstvbn - 1), SEEK_SET))
+	{
+	  bfd_set_error (bfd_error_file_truncated);
+	  return FALSE;
+	}
+
+      if (_bfd_vms_slurp_object_records (abfd) != TRUE)
+	return FALSE;
+
+      section->filepos = VMS_BLOCK_SIZE * (gstvbn - 1);
+      section->size = bfd_tell (abfd) - section->filepos;
+
+      if (!bfd_set_section_flags (abfd, section, bfd_flags))
+	return FALSE;
+
+      abfd->flags |= HAS_SYMS;
+    }
+
+  return TRUE;
+}
+
+/* Object file reading.  */
+
+/* Object file input functions.  */
+
+/* Get next record from object file to vms_buf.
+   Set PRIV(buf_size) and return it
+
+   This is a little tricky since it should be portable.
+
+   The openVMS object file has 'variable length' which means that
+   read() returns data in chunks of (hopefully) correct and expected
+   size.  The linker (and other tools on VMS) depend on that. Unix
+   doesn't know about 'formatted' files, so reading and writing such
+   an object file in a Unix environment is not trivial.
+
+   With the tool 'file' (available on all VMS FTP sites), one
+   can view and change the attributes of a file.  Changing from
+   'variable length' to 'fixed length, 512 bytes' reveals the
+   record size at the first 2 bytes of every record.  The same
+   may happen during the transfer of object files from VMS to Unix,
+   at least with UCX, the DEC implementation of TCP/IP.
+
+   The VMS format repeats the size at bytes 2 & 3 of every record.
+
+   On the first call (file_format == FF_UNKNOWN) we check if
+   the first and the third byte pair (!) of the record match.
+   If they do it's an object file in an Unix environment or with
+   wrong attributes (FF_FOREIGN), else we should be in a VMS
+   environment where read() returns the record size (FF_NATIVE).
+
+   Reading is always done in 2 steps:
+    1. first just the record header is read and the size extracted,
+    2. then the read buffer is adjusted and the remaining bytes are
+       read in.
+
+   All file I/O is done on even file positions.  */
+
+#define VMS_OBJECT_ADJUSTMENT  2
+
+static void
+maybe_adjust_record_pointer_for_object (bfd *abfd)
+{
+  /* Set the file format once for all on the first invocation.  */
+  if (PRIV (recrd.file_format) == FF_UNKNOWN)
+    {
+      if (PRIV (recrd.rec)[0] == PRIV (recrd.rec)[4]
+	  && PRIV (recrd.rec)[1] == PRIV (recrd.rec)[5])
+	PRIV (recrd.file_format) = FF_FOREIGN;
+      else
+	PRIV (recrd.file_format) = FF_NATIVE;
+    }
+
+  /* The adjustment is needed only in an Unix environment.  */
+  if (PRIV (recrd.file_format) == FF_FOREIGN)
+    PRIV (recrd.rec) += VMS_OBJECT_ADJUSTMENT;
+}
+
+/* Implement step #1 of the object record reading procedure.
+   Return the record type or -1 on failure.  */
+
+static int
+_bfd_vms_get_object_record (bfd *abfd)
+{
+  unsigned int test_len;
+  int type;
+  int off = 0;
+
+  vms_debug2 ((8, "_bfd_vms_get_obj_record\n"));
+
+  test_len = 6;
+
+  /* Skip odd alignment byte.  */
+  if (bfd_tell (abfd) & 1)
+    {
+      if (bfd_bread (PRIV (recrd.buf), 1, abfd) != 1)
+        {
+          bfd_set_error (bfd_error_file_truncated);
+          return -1;
+        }
+      /* Alignment byte may be present or not.  This is not easy to
+         detect but all object record types are not 0 (on Alpha VMS).
+         We also hope that pad byte is 0.  */
+      if (PRIV (recrd.buf)[0])
+        off = 1;
+    }
+
+  /* Read the record header  */
+  if (bfd_bread (PRIV (recrd.buf) + off, test_len - off, abfd)
+      != test_len - off)
+    {
+      bfd_set_error (bfd_error_file_truncated);
+      return -1;
+    }
+
+  /* Reset the record pointer.  */
+  PRIV (recrd.rec) = PRIV (recrd.buf);
+  maybe_adjust_record_pointer_for_object (abfd);
+
+  if (vms_get_remaining_object_record (abfd, test_len) <= 0)
+    return -1;
+
+  type = bfd_getl16 (PRIV (recrd.rec));
+
+  vms_debug2 ((8, "_bfd_vms_get_obj_record: rec %p, size %d, type %d\n",
+               PRIV (recrd.rec), PRIV (recrd.rec_size), type));
+
+  return type;
+}
+
+/* Implement step #2 of the object record reading procedure.
+   Return the size of the record or 0 on failure.  */
+
+static int
+vms_get_remaining_object_record (bfd *abfd, int read_so_far)
+{
+  unsigned int to_read;
+
+  vms_debug2 ((8, "vms_get_remaining_obj_record\n"));
+
+  /* Extract record size.  */
+  PRIV (recrd.rec_size) = bfd_getl16 (PRIV (recrd.rec) + 2);
+
+  if (PRIV (recrd.rec_size) <= 0)
+    {
+      bfd_set_error (bfd_error_file_truncated);
+      return 0;
+    }
+
+  /* That's what the linker manual says.  */
+  if (PRIV (recrd.rec_size) > EOBJ__C_MAXRECSIZ)
+    {
+      bfd_set_error (bfd_error_file_truncated);
+      return 0;
+    }
+
+  /* Take into account object adjustment.  */
+  to_read = PRIV (recrd.rec_size);
+  if (PRIV (recrd.file_format) == FF_FOREIGN)
+    to_read += VMS_OBJECT_ADJUSTMENT;
+
+  /* Adjust the buffer.  */
+  if (to_read > PRIV (recrd.buf_size))
+    {
+      PRIV (recrd.buf)
+        = (unsigned char *) bfd_realloc (PRIV (recrd.buf), to_read);
+      if (PRIV (recrd.buf) == NULL)
+        return 0;
+      PRIV (recrd.buf_size) = to_read;
+    }
+
+  /* Read the remaining record.  */
+  to_read -= read_so_far;
+
+  vms_debug2 ((8, "vms_get_remaining_obj_record: to_read %d\n", to_read));
+
+  if (bfd_bread (PRIV (recrd.buf) + read_so_far, to_read, abfd) != to_read)
+    {
+      bfd_set_error (bfd_error_file_truncated);
+      return 0;
+    }
+
+  /* Reset the record pointer.  */
+  PRIV (recrd.rec) = PRIV (recrd.buf);
+  maybe_adjust_record_pointer_for_object (abfd);
+
+  vms_debug2 ((8, "vms_get_remaining_obj_record: size %d\n",
+               PRIV (recrd.rec_size)));
+
+  return PRIV (recrd.rec_size);
+}
+
+/* Read and process emh record.
+   Return TRUE on success, FALSE on error.  */
+
+static bfd_boolean
+_bfd_vms_slurp_ehdr (bfd *abfd)
+{
+  unsigned char *ptr;
+  unsigned char *vms_rec;
+  int subtype;
+
+  vms_rec = PRIV (recrd.rec);
+
+  vms_debug2 ((2, "HDR/EMH\n"));
+
+  subtype = bfd_getl16 (vms_rec + 4);
+
+  vms_debug2 ((3, "subtype %d\n", subtype));
+
+  switch (subtype)
+    {
+    case EMH__C_MHD:
+      /* Module header.  */
+      PRIV (hdr_data).hdr_b_strlvl = vms_rec[6];
+      PRIV (hdr_data).hdr_l_arch1  = bfd_getl32 (vms_rec + 8);
+      PRIV (hdr_data).hdr_l_arch2  = bfd_getl32 (vms_rec + 12);
+      PRIV (hdr_data).hdr_l_recsiz = bfd_getl32 (vms_rec + 16);
+      PRIV (hdr_data).hdr_t_name   = _bfd_vms_save_counted_string (vms_rec + 20);
+      ptr = vms_rec + 20 + vms_rec[20] + 1;
+      PRIV (hdr_data).hdr_t_version =_bfd_vms_save_counted_string (ptr);
+      ptr += *ptr + 1;
+      PRIV (hdr_data).hdr_t_date = _bfd_vms_save_sized_string (ptr, 17);
+      break;
+
+    case EMH__C_LNM:
+      PRIV (hdr_data).hdr_c_lnm =
+        _bfd_vms_save_sized_string (vms_rec, PRIV (recrd.rec_size - 6));
+      break;
+
+    case EMH__C_SRC:
+      PRIV (hdr_data).hdr_c_src =
+        _bfd_vms_save_sized_string (vms_rec, PRIV (recrd.rec_size - 6));
+      break;
+
+    case EMH__C_TTL:
+      PRIV (hdr_data).hdr_c_ttl =
+        _bfd_vms_save_sized_string (vms_rec, PRIV (recrd.rec_size - 6));
+      break;
+
+    case EMH__C_CPR:
+    case EMH__C_MTC:
+    case EMH__C_GTX:
+      break;
+
+    default:
+      bfd_set_error (bfd_error_wrong_format);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+/* Typical sections for evax object files.  */
+
+#define EVAX_ABS_NAME		"$ABS$"
+#define EVAX_CODE_NAME		"$CODE$"
+#define EVAX_LINK_NAME		"$LINK$"
+#define EVAX_DATA_NAME		"$DATA$"
+#define EVAX_BSS_NAME		"$BSS$"
+#define EVAX_READONLYADDR_NAME	"$READONLY_ADDR$"
+#define EVAX_READONLY_NAME	"$READONLY$"
+#define EVAX_LITERAL_NAME	"$LITERAL$"
+#define EVAX_LITERALS_NAME	"$LITERALS"
+#define EVAX_COMMON_NAME	"$COMMON$"
+#define EVAX_LOCAL_NAME		"$LOCAL$"
+
+struct sec_flags_struct
+{
+  const char *name;		/* Name of section.  */
+  int vflags_always;
+  flagword flags_always;	/* Flags we set always.  */
+  int vflags_hassize;
+  flagword flags_hassize;	/* Flags we set if the section has a size > 0.  */
+};
+
+/* These flags are deccrtl/vaxcrtl (openVMS 6.2 Alpha) compatible.  */
+
+static struct sec_flags_struct evax_section_flags[] =
+  {
+    { EVAX_ABS_NAME,
+      (EGPS__V_SHR),
+      (SEC_DATA),
+      (EGPS__V_SHR),
+      (SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD) },
+    { EVAX_CODE_NAME,
+      (EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_EXE),
+      (SEC_CODE),
+      (EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_EXE),
+      (SEC_CODE | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD) },
+    { EVAX_LITERAL_NAME,
+      (EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_RD | EGPS__V_NOMOD),
+      (SEC_DATA | SEC_READONLY),
+      (EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_RD),
+      (SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_READONLY | SEC_LOAD) },
+    { EVAX_LINK_NAME,
+      (EGPS__V_REL | EGPS__V_RD),
+      (SEC_DATA | SEC_READONLY),
+      (EGPS__V_REL | EGPS__V_RD),
+      (SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_READONLY | SEC_LOAD) },
+    { EVAX_DATA_NAME,
+      (EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT | EGPS__V_NOMOD),
+      (SEC_DATA),
+      (EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT),
+      (SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD) },
+    { EVAX_BSS_NAME,
+      (EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT | EGPS__V_NOMOD),
+      (SEC_NO_FLAGS),
+      (EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT | EGPS__V_NOMOD),
+      (SEC_ALLOC) },
+    { EVAX_READONLYADDR_NAME,
+      (EGPS__V_PIC | EGPS__V_REL | EGPS__V_RD),
+      (SEC_DATA | SEC_READONLY),
+      (EGPS__V_PIC | EGPS__V_REL | EGPS__V_RD),
+      (SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_READONLY | SEC_LOAD) },
+    { EVAX_READONLY_NAME,
+      (EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_RD | EGPS__V_NOMOD),
+      (SEC_DATA | SEC_READONLY),
+      (EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_RD),
+      (SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_READONLY | SEC_LOAD) },
+    { EVAX_LOCAL_NAME,
+      (EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT),
+      (SEC_DATA),
+      (EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT),
+      (SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD) },
+    { EVAX_LITERALS_NAME,
+      (EGPS__V_PIC | EGPS__V_OVR),
+      (SEC_DATA | SEC_READONLY),
+      (EGPS__V_PIC | EGPS__V_OVR),
+      (SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_READONLY | SEC_LOAD) },
+    { NULL,
+      (EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT),
+      (SEC_DATA),
+      (EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT),
+      (SEC_IN_MEMORY | SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD) }
+  };
+
+/* Retrieve bfd section flags by name and size.  */
+
+static flagword
+vms_secflag_by_name (bfd *abfd ATTRIBUTE_UNUSED,
+		     struct sec_flags_struct *section_flags,
+		     char *name,
+		     int hassize)
+{
+  int i = 0;
+
+  while (section_flags[i].name != NULL)
+    {
+      if (strcmp (name, section_flags[i].name) == 0)
+        {
+	  if (hassize)
+	    return section_flags[i].flags_hassize;
+	  else
+	    return section_flags[i].flags_always;
+	}
+      i++;
+    }
+  if (hassize)
+    return section_flags[i].flags_hassize;
+  return section_flags[i].flags_always;
+}
+
+/* Retrieve vms section flags by name and size.  */
+
+static flagword
+vms_esecflag_by_name (struct sec_flags_struct *section_flags,
+		      char *name,
+		      int hassize)
+{
+  int i = 0;
+
+  while (section_flags[i].name != NULL)
+    {
+      if (strcmp (name, section_flags[i].name) == 0)
+	{
+	  if (hassize)
+	    return section_flags[i].vflags_hassize;
+	  else
+	    return section_flags[i].vflags_always;
+	}
+      i++;
+    }
+  if (hassize)
+    return section_flags[i].vflags_hassize;
+  return section_flags[i].vflags_always;
+}
+
+/* Input routines.  */
+
+static struct vms_symbol_entry *
+add_symbol (bfd *abfd, const unsigned char *ascic)
+{
+  struct vms_symbol_entry *entry;
+  int len;
+
+  len = *ascic++;
+  entry = (struct vms_symbol_entry *)bfd_zalloc (abfd, sizeof (*entry) + len);
+  if (entry == NULL)
+    return NULL;
+  entry->namelen = len;
+  memcpy (entry->name, ascic, len);
+  entry->name[len] = 0;
+  entry->owner = abfd;
+
+  if (PRIV (gsd_sym_count) >= PRIV (max_sym_count))
+    {
+      if (PRIV (max_sym_count) == 0)
+        {
+          PRIV (max_sym_count) = 128;
+          PRIV (syms) = bfd_malloc
+            (PRIV (max_sym_count) * sizeof (struct vms_symbol_entry *));
+        }
+      else
+        {
+          PRIV (max_sym_count) *= 2;
+          PRIV (syms) = bfd_realloc
+            (PRIV (syms),
+             (PRIV (max_sym_count) * sizeof (struct vms_symbol_entry *)));
+        }
+      if (PRIV (syms) == NULL)
+        return NULL;
+    }
+
+  PRIV (syms)[PRIV (gsd_sym_count)++] = entry;
+  return entry;
+}
+
+/* Read and process EGSD.  Return FALSE on failure.  */
+
+static bfd_boolean
+_bfd_vms_slurp_egsd (bfd * abfd)
+{
+  int gsd_type, gsd_size;
+  asection *section;
+  unsigned char *vms_rec;
+  flagword new_flags, old_flags;
+  char *name;
+  unsigned long base_addr;
+  unsigned long align_addr;
+
+  vms_debug2 ((2, "EGSD\n"));
+
+  PRIV (recrd.rec) += 8;	/* Skip type, size, align pad.  */
+  PRIV (recrd.rec_size) -= 8;
+
+  /* Calculate base address for each section.  */
+  base_addr = 0L;
+
+  while (PRIV (recrd.rec_size) > 0)
+    {
+      vms_rec = PRIV (recrd.rec);
+
+      gsd_type = bfd_getl16 (vms_rec);
+      gsd_size = bfd_getl16 (vms_rec + 2);
+
+      vms_debug2 ((3, "egsd_type %d\n", gsd_type));
+
+      switch (gsd_type)
+	{
+	case EGSD__C_PSC:
+	  {
+	    /* Program section definition.  */
+            struct vms_egps *egps = (struct vms_egps *)vms_rec;
+	    name = _bfd_vms_save_counted_string (&egps->namlng);
+	    section = bfd_make_section (abfd, name);
+	    if (!section)
+	      return FALSE;
+	    old_flags = bfd_getl16 (egps->flags);
+            vms_section_data (section)->flags = old_flags;
+            vms_section_data (section)->no_flags = 0;
+	    section->size = bfd_getl32 (egps->alloc);
+	    new_flags = vms_secflag_by_name (abfd, evax_section_flags, name,
+					     section->size > 0);
+            if (!(old_flags & EGPS__V_NOMOD))
+              {
+                new_flags |= SEC_HAS_CONTENTS;
+                if (old_flags & EGPS__V_REL)
+                  new_flags |= SEC_RELOC;
+              }
+	    if (!bfd_set_section_flags (abfd, section, new_flags))
+	      return FALSE;
+	    section->alignment_power = egps->align;
+	    align_addr = (1 << section->alignment_power);
+	    if ((base_addr % align_addr) != 0)
+	      base_addr += (align_addr - (base_addr % align_addr));
+	    section->vma = (bfd_vma)base_addr;
+	    base_addr += section->size;
+	    section->filepos = (unsigned int)-1;
+#if VMS_DEBUG
+	    vms_debug (4, "EGSD P-section %d (%s, flags %04x) ",
+		       section->index, name, old_flags);
+	    vms_debug (4, "%lu bytes at 0x%08lx (mem %p)\n",
+		       (unsigned long)section->size,
+                       (unsigned long)section->vma, section->contents);
+#endif
+	  }
+	  break;
+
+	case EGSD__C_SYM:
+	  {
+            int nameoff;
+            struct vms_symbol_entry *entry;
+            struct vms_egsy *egsy = (struct vms_egsy *) vms_rec;
+
+	    old_flags = bfd_getl16 (egsy->flags);
+	    if (old_flags & EGSY__V_DEF)
+              nameoff = ESDF__B_NAMLNG;
+            else
+              nameoff = ESRF__B_NAMLNG;
+
+            entry = add_symbol (abfd, vms_rec + nameoff);
+            if (entry == NULL)
+              return FALSE;
+
+            /* Allow only duplicate reference.  */
+            if ((entry->flags & EGSY__V_DEF) && (old_flags & EGSY__V_DEF))
+              abort ();
+
+            if (entry->typ == 0)
+              {
+                entry->typ = gsd_type;
+                entry->data_type = egsy->datyp;
+                entry->flags = old_flags;
+              }
+
+	    if (old_flags & EGSY__V_DEF)
+              {
+                struct vms_esdf *esdf = (struct vms_esdf *)vms_rec;
+
+		entry->value = bfd_getl64 (esdf->value);
+		entry->section = bfd_getl32 (esdf->psindx);
+
+                if (old_flags & EGSY__V_NORM)
+                  {
+                    PRIV (norm_sym_count)++;
+
+                    entry->code_value = bfd_getl64 (esdf->code_address);
+                    entry->code_section = bfd_getl32 (esdf->ca_psindx);
+                  }
+              }
+	  }
+	  break;
+
+	case EGSD__C_SYMG:
+	  {
+            int nameoff;
+            struct vms_symbol_entry *entry;
+            struct vms_egst *egst = (struct vms_egst *)vms_rec;
+
+	    old_flags = bfd_getl16 (egst->header.flags);
+	    if (old_flags & EGSY__V_DEF)
+              nameoff = ESDF__B_NAMLNG;
+            else
+              nameoff = ESRF__B_NAMLNG;
+
+            entry = add_symbol (abfd, &egst->namlng);
+
+            if (entry == NULL)
+              return FALSE;
+
+            entry->typ = gsd_type;
+            entry->data_type = egst->header.datyp;
+            entry->flags = old_flags;
+
+            entry->symbol_vector = bfd_getl32 (egst->value);
+
+            entry->section = bfd_getl32 (egst->psindx);
+            entry->value = bfd_getl64 (egst->lp_2);
+
+            if (old_flags & EGSY__V_NORM)
+              {
+                PRIV (norm_sym_count)++;
+
+                entry->code_value = bfd_getl64 (egst->lp_1);
+                entry->code_section = 0;
+              }
+          }
+	  break;
+
+	case EGSD__C_IDC:
+	case EGSD__C_SYMM:
+	case EGSD__C_SYMV:
+	default:
+	  (*_bfd_error_handler) (_("Unknown EGSD subtype %d"), gsd_type);
+	  bfd_set_error (bfd_error_bad_value);
+	  return FALSE;
+	}
+
+      PRIV (recrd.rec_size) -= gsd_size;
+      PRIV (recrd.rec) += gsd_size;
+    }
+
+  if (PRIV (gsd_sym_count) > 0)
+    abfd->flags |= HAS_SYMS;
+
+  return TRUE;
+}
+
+/* Stack routines for vms ETIR commands.  */
+
+/* Push value and section index.  */
+
+static void
+_bfd_vms_push (bfd *abfd, bfd_vma val, unsigned int reloc)
+{
+  vms_debug2 ((4, "<push %08lx (0x%08x) at %d>\n",
+               (unsigned long)val, reloc, PRIV (stackptr)));
+
+  PRIV (stack[PRIV (stackptr)]).value = val;
+  PRIV (stack[PRIV (stackptr)]).reloc = reloc;
+  PRIV (stackptr)++;
+  if (PRIV (stackptr) >= STACKSIZE)
+    {
+      bfd_set_error (bfd_error_bad_value);
+      (*_bfd_error_handler) (_("Stack overflow (%d) in _bfd_vms_push"), PRIV (stackptr));
+      exit (1);
+    }
+}
+
+/* Pop value and section index.  */
+
+static void
+_bfd_vms_pop (bfd *abfd, bfd_vma *val, unsigned int *rel)
+{
+  if (PRIV (stackptr) == 0)
+    {
+      bfd_set_error (bfd_error_bad_value);
+      (*_bfd_error_handler) (_("Stack underflow in _bfd_vms_pop"));
+      exit (1);
+    }
+  PRIV (stackptr)--;
+  *val = PRIV (stack[PRIV (stackptr)]).value;
+  *rel = PRIV (stack[PRIV (stackptr)]).reloc;
+
+  vms_debug2 ((4, "<pop %08lx (0x%08x)>\n", (unsigned long)*val, *rel));
+}
+
+/* Routines to fill sections contents during tir/etir read.  */
+
+/* Initialize image buffer pointer to be filled.  */
+
+static void
+image_set_ptr (bfd *abfd, bfd_vma vma, int sect, struct bfd_link_info *info)
+{
+  asection *sec;
+
+  vms_debug2 ((4, "image_set_ptr (0x%08x, sect=%d)\n", (unsigned)vma, sect));
+
+  sec = PRIV (sections)[sect];
+
+  if (info)
+    {
+      /* Reading contents to an output bfd.  */
+
+      if (sec->output_section == NULL)
+        {
+          /* Section discarded.  */
+          vms_debug2 ((5, " section %s discarded\n", sec->name));
+
+          /* This is not used.  */
+          PRIV (image_section) = NULL;
+          PRIV (image_offset) = 0;
+          return;
+        }
+      PRIV (image_offset) = sec->output_offset + vma;
+      PRIV (image_section) = sec->output_section;
+    }
+  else
+    {
+      PRIV (image_offset) = vma;
+      PRIV (image_section) = sec;
+    }
+}
+
+/* Increment image buffer pointer by offset.  */
+
+static void
+image_inc_ptr (bfd *abfd, bfd_vma offset)
+{
+  vms_debug2 ((4, "image_inc_ptr (%u)\n", (unsigned)offset));
+
+  PRIV (image_offset) += offset;
+}
+
+/* Save current DST location counter under specified index.  */
+
+static void
+dst_define_location (bfd *abfd, unsigned int loc)
+{
+  vms_debug2 ((4, "dst_define_location (%d)\n", (int)loc));
+
+  /* Grow the ptr offset table if necessary.  */
+  if (loc + 1 > PRIV (dst_ptr_offsets_count))
+    {
+      PRIV (dst_ptr_offsets) = bfd_realloc (PRIV (dst_ptr_offsets),
+					   (loc + 1) * sizeof (unsigned int));
+      PRIV (dst_ptr_offsets_count) = loc + 1;
+    }
+
+  PRIV (dst_ptr_offsets)[loc] = PRIV (image_offset);
+}
+
+/* Restore saved DST location counter from specified index.  */
+
+static void
+dst_restore_location (bfd *abfd, unsigned int loc)
+{
+  vms_debug2 ((4, "dst_restore_location (%d)\n", (int)loc));
+
+  PRIV (image_offset) = PRIV (dst_ptr_offsets)[loc];
+}
+
+/* Retrieve saved DST location counter from specified index.  */
+
+static unsigned int
+dst_retrieve_location (bfd *abfd, unsigned int loc)
+{
+  vms_debug2 ((4, "dst_retrieve_location (%d)\n", (int)loc));
+
+  return PRIV (dst_ptr_offsets)[loc];
+}
+
+/* Check that the DST section is big enough for the specified
+   amount of bytes.  */
+
+static void
+dst_check_allocation (bfd *abfd, unsigned int size)
+{
+  asection *section = PRIV (image_section);
+
+  section->size += size;
+
+  /* Grow the section as necessary */
+  if (section->size <= section->rawsize)
+    return;
+  do
+    {
+      if (section->rawsize == 0)
+        section->rawsize = 1024;
+      else
+        section->rawsize *= 2;
+    }
+  while (section->size > section->rawsize);
+  section->contents = bfd_realloc (section->contents, section->rawsize);
+}
+
+/* Write multiple bytes to section image.  */
+
+static bfd_boolean
+image_write (bfd *abfd, unsigned char *ptr, int size)
+{
+#if VMS_DEBUG
+  _bfd_vms_debug (8, "image_write from (%p, %d) to (%ld)\n", ptr, size,
+                  (long)PRIV (image_offset));
+  _bfd_hexdump (9, ptr, size, 0);
+#endif
+
+  if (PRIV (image_autoextend))
+    dst_check_allocation (abfd, size);
+
+  if (PRIV (image_section)->contents != NULL)
+    {
+      asection *sec = PRIV (image_section);
+      file_ptr off = PRIV (image_offset);
+
+      /* Check bounds.  */
+      if (off > (file_ptr)sec->size
+          || size > (file_ptr)sec->size
+          || off + size > (file_ptr)sec->size)
+        {
+          bfd_set_error (bfd_error_bad_value);
+          return FALSE;
+        }
+
+      memcpy (sec->contents + off, ptr, size);
+    }
+
+  PRIV (image_offset) += size;
+  return TRUE;
+}
+
+/* Write byte to section image.  */
+
+static bfd_boolean
+image_write_b (bfd * abfd, unsigned int value)
+{
+  unsigned char data[1];
+
+  vms_debug2 ((6, "image_write_b (%02x)\n", (int) value));
+
+  *data = value;
+
+  return image_write (abfd, data, sizeof (data));
+}
+
+/* Write 2-byte word to image.  */
+
+static bfd_boolean
+image_write_w (bfd * abfd, unsigned int value)
+{
+  unsigned char data[2];
+
+  vms_debug2 ((6, "image_write_w (%04x)\n", (int) value));
+
+  bfd_putl16 (value, data);
+  return image_write (abfd, data, sizeof (data));
+}
+
+/* Write 4-byte long to image.  */
+
+static bfd_boolean
+image_write_l (bfd * abfd, unsigned long value)
+{
+  unsigned char data[4];
+
+  vms_debug2 ((6, "image_write_l (%08lx)\n", value));
+
+  bfd_putl32 (value, data);
+  return image_write (abfd, data, sizeof (data));
+}
+
+/* Write 8-byte quad to image.  */
+
+static bfd_boolean
+image_write_q (bfd * abfd, bfd_vma value)
+{
+  unsigned char data[8];
+
+  vms_debug2 ((6, "image_write_q (%08lx)\n", (unsigned long)value));
+
+  bfd_putl64 (value, data);
+  return image_write (abfd, data, sizeof (data));
+}
+
+static const char *
+_bfd_vms_etir_name (int cmd)
+{
+  switch (cmd)
+    {
+    case ETIR__C_STA_GBL: return "ETIR__C_STA_GBL";
+    case ETIR__C_STA_LW: return "ETIR__C_STA_LW";
+    case ETIR__C_STA_QW: return "ETIR__C_STA_QW";
+    case ETIR__C_STA_PQ: return "ETIR__C_STA_PQ";
+    case ETIR__C_STA_LI: return "ETIR__C_STA_LI";
+    case ETIR__C_STA_MOD: return "ETIR__C_STA_MOD";
+    case ETIR__C_STA_CKARG: return "ETIR__C_STA_CKARG";
+    case ETIR__C_STO_B: return "ETIR__C_STO_B";
+    case ETIR__C_STO_W: return "ETIR__C_STO_W";
+    case ETIR__C_STO_GBL: return "ETIR__C_STO_GBL";
+    case ETIR__C_STO_CA: return "ETIR__C_STO_CA";
+    case ETIR__C_STO_RB: return "ETIR__C_STO_RB";
+    case ETIR__C_STO_AB: return "ETIR__C_STO_AB";
+    case ETIR__C_STO_OFF: return "ETIR__C_STO_OFF";
+    case ETIR__C_STO_IMM: return "ETIR__C_STO_IMM";
+    case ETIR__C_STO_IMMR: return "ETIR__C_STO_IMMR";
+    case ETIR__C_STO_LW: return "ETIR__C_STO_LW";
+    case ETIR__C_STO_QW: return "ETIR__C_STO_QW";
+    case ETIR__C_STO_GBL_LW: return "ETIR__C_STO_GBL_LW";
+    case ETIR__C_STO_LP_PSB: return "ETIR__C_STO_LP_PSB";
+    case ETIR__C_STO_HINT_GBL: return "ETIR__C_STO_HINT_GBL";
+    case ETIR__C_STO_HINT_PS: return "ETIR__C_STO_HINT_PS";
+    case ETIR__C_OPR_ADD: return "ETIR__C_OPR_ADD";
+    case ETIR__C_OPR_SUB: return "ETIR__C_OPR_SUB";
+    case ETIR__C_OPR_INSV: return "ETIR__C_OPR_INSV";
+    case ETIR__C_OPR_USH: return "ETIR__C_OPR_USH";
+    case ETIR__C_OPR_ROT: return "ETIR__C_OPR_ROT";
+    case ETIR__C_OPR_REDEF: return "ETIR__C_OPR_REDEF";
+    case ETIR__C_OPR_DFLIT: return "ETIR__C_OPR_DFLIT";
+    case ETIR__C_STC_LP: return "ETIR__C_STC_LP";
+    case ETIR__C_STC_GBL: return "ETIR__C_STC_GBL";
+    case ETIR__C_STC_GCA: return "ETIR__C_STC_GCA";
+    case ETIR__C_STC_PS: return "ETIR__C_STC_PS";
+    case ETIR__C_STC_NBH_PS: return "ETIR__C_STC_NBH_PS";
+    case ETIR__C_STC_NOP_GBL: return "ETIR__C_STC_NOP_GBL";
+    case ETIR__C_STC_NOP_PS: return "ETIR__C_STC_NOP_PS";
+    case ETIR__C_STC_BSR_GBL: return "ETIR__C_STC_BSR_GBL";
+    case ETIR__C_STC_BSR_PS: return "ETIR__C_STC_BSR_PS";
+    case ETIR__C_STC_LDA_GBL: return "ETIR__C_STC_LDA_GBL";
+    case ETIR__C_STC_LDA_PS: return "ETIR__C_STC_LDA_PS";
+    case ETIR__C_STC_BOH_GBL: return "ETIR__C_STC_BOH_GBL";
+    case ETIR__C_STC_BOH_PS: return "ETIR__C_STC_BOH_PS";
+    case ETIR__C_STC_NBH_GBL: return "ETIR__C_STC_NBH_GBL";
+    case ETIR__C_STC_LP_PSB: return "ETIR__C_STC_LP_PSB";
+    case ETIR__C_CTL_SETRB: return "ETIR__C_CTL_SETRB";
+    case ETIR__C_CTL_AUGRB: return "ETIR__C_CTL_AUGRB";
+    case ETIR__C_CTL_DFLOC: return "ETIR__C_CTL_DFLOC";
+    case ETIR__C_CTL_STLOC: return "ETIR__C_CTL_STLOC";
+    case ETIR__C_CTL_STKDL: return "ETIR__C_CTL_STKDL";
+
+    default:
+      /* These names have not yet been added to this switch statement.  */
+      (*_bfd_error_handler) (_("unknown ETIR command %d"), cmd);
+    }
+
+  return NULL;
+}
+#define HIGHBIT(op) ((op & 0x80000000L) == 0x80000000L)
+
+static void
+_bfd_vms_get_value (bfd *abfd, const unsigned char *ascic,
+                    struct bfd_link_info *info,
+                    bfd_vma *vma,
+                    struct alpha_vms_link_hash_entry **hp)
+{
+  char name[257];
+  int len;
+  int i;
+  struct alpha_vms_link_hash_entry *h;
+
+  /* Not linking.  Do not try to resolve the symbol.  */
+  if (info == NULL)
+    {
+      *vma = 0;
+      *hp = NULL;
+      return;
+    }
+
+  len = *ascic;
+  for (i = 0; i < len; i++)
+    name[i] = ascic[i + 1];
+  name[i] = 0;
+
+  h = (struct alpha_vms_link_hash_entry *)
+    bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
+
+  *hp = h;
+
+  if (h != NULL
+      && (h->root.type == bfd_link_hash_defined
+          || h->root.type == bfd_link_hash_defweak))
+    *vma = h->root.u.def.value
+      + h->root.u.def.section->output_offset
+      + h->root.u.def.section->output_section->vma;
+  else if (h && h->root.type == bfd_link_hash_undefweak)
+    *vma = 0;
+  else
+    {
+      if (!(*info->callbacks->undefined_symbol)
+          (info, name, abfd, PRIV (image_section), PRIV (image_offset), TRUE))
+        abort ();
+      *vma = 0;
+    }
+}
+
+#define RELC_NONE 0
+#define RELC_REL  1
+#define RELC_SHR_BASE 0x10000
+#define RELC_SEC_BASE 0x20000
+#define RELC_MASK     0x0ffff
+
+static unsigned int
+alpha_vms_sym_to_ctxt (struct alpha_vms_link_hash_entry *h)
+{
+  /* Handle undefined symbols.  */
+  if (h == NULL || h->sym == NULL)
+    return RELC_NONE;
+
+  if (h->sym->typ == EGSD__C_SYMG)
+    {
+      if (h->sym->flags & EGSY__V_REL)
+        return RELC_SHR_BASE + PRIV2 (h->sym->owner, shr_index);
+      else
+        {
+          /* Can this happen ?  I'd like to see an example.  */
+          abort ();
+        }
+    }
+  if (h->sym->typ == EGSD__C_SYM)
+    {
+      if (h->sym->flags & EGSY__V_REL)
+        return RELC_REL;
+      else
+        return RELC_NONE;
+    }
+  abort ();
+}
+
+static bfd_vma
+alpha_vms_get_sym_value (unsigned int sect, bfd_vma addr,
+                         struct alpha_vms_link_hash_entry *h)
+{
+  asection *s;
+
+  BFD_ASSERT (h && (h->root.type == bfd_link_hash_defined
+                    || h->root.type == bfd_link_hash_defweak));
+
+  s = PRIV2 (h->root.u.def.section->owner, sections)[sect];
+  return s->output_section->vma + s->output_offset + addr;
+}
+
+static bfd_vma
+alpha_vms_fix_sec_rel (bfd *abfd, struct bfd_link_info *info,
+                       unsigned int rel, bfd_vma vma)
+{
+  asection *sec = PRIV (sections)[rel & RELC_MASK];
+
+  if (info)
+    {
+      if (sec->output_section == NULL)
+        abort ();
+      return vma + sec->output_section->vma + sec->output_offset;
+    }
+  else
+    return vma + sec->vma;
+}
+
+static bfd_boolean
+_bfd_vms_slurp_etir (bfd *abfd, struct bfd_link_info *info)
+{
+  unsigned char *ptr;
+  unsigned int length;
+  unsigned char *maxptr;
+  bfd_vma op1;
+  bfd_vma op2;
+  unsigned int rel1;
+  unsigned int rel2;
+  struct alpha_vms_link_hash_entry *h;
+
+  PRIV (recrd.rec) += ETIR__C_HEADER_SIZE;
+  PRIV (recrd.rec_size) -= ETIR__C_HEADER_SIZE;
+
+  ptr = PRIV (recrd.rec);
+  length = PRIV (recrd.rec_size);
+  maxptr = ptr + length;
+
+  vms_debug2 ((2, "ETIR: %d bytes\n", length));
+
+  while (ptr < maxptr)
+    {
+      int cmd = bfd_getl16 (ptr);
+      int cmd_length = bfd_getl16 (ptr + 2);
+
+      ptr += 4;
+
+#if VMS_DEBUG
+      _bfd_vms_debug (4, "etir: %s(%d)\n",
+                      _bfd_vms_etir_name (cmd), cmd);
+      _bfd_hexdump (8, ptr, cmd_length - 4, (long) ptr);
+#endif
+
+      switch (cmd)
+        {
+          /* Stack global
+             arg: cs	symbol name
+
+             stack 32 bit value of symbol (high bits set to 0).  */
+        case ETIR__C_STA_GBL:
+          _bfd_vms_get_value (abfd, ptr, info, &op1, &h);
+          _bfd_vms_push (abfd, op1, alpha_vms_sym_to_ctxt (h));
+          break;
+
+          /* Stack longword
+             arg: lw	value
+
+             stack 32 bit value, sign extend to 64 bit.  */
+        case ETIR__C_STA_LW:
+          _bfd_vms_push (abfd, bfd_getl32 (ptr), RELC_NONE);
+          break;
+
+          /* Stack quadword
+             arg: qw	value
+
+             stack 64 bit value of symbol.  */
+        case ETIR__C_STA_QW:
+          _bfd_vms_push (abfd, bfd_getl64 (ptr), RELC_NONE);
+          break;
+
+          /* Stack psect base plus quadword offset
+             arg: lw	section index
+             qw	signed quadword offset (low 32 bits)
+
+             Stack qw argument and section index
+             (see ETIR__C_STO_OFF, ETIR__C_CTL_SETRB).  */
+        case ETIR__C_STA_PQ:
+          {
+            int psect;
+
+            psect = bfd_getl32 (ptr);
+            if ((unsigned int) psect >= PRIV (section_count))
+              {
+                (*_bfd_error_handler) (_("bad section index in %s"),
+                                       _bfd_vms_etir_name (cmd));
+                bfd_set_error (bfd_error_bad_value);
+                return FALSE;
+              }
+            op1 = bfd_getl64 (ptr + 4);
+            _bfd_vms_push (abfd, op1, psect | RELC_SEC_BASE);
+          }
+          break;
+
+        case ETIR__C_STA_LI:
+        case ETIR__C_STA_MOD:
+        case ETIR__C_STA_CKARG:
+          (*_bfd_error_handler) (_("unsupported STA cmd %s"),
+                                 _bfd_vms_etir_name (cmd));
+          return FALSE;
+          break;
+
+          /* Store byte: pop stack, write byte
+             arg: -.  */
+        case ETIR__C_STO_B:
+          _bfd_vms_pop (abfd, &op1, &rel1);
+          if (rel1 != RELC_NONE)
+            goto bad_context;
+          image_write_b (abfd, (unsigned int) op1 & 0xff);
+          break;
+
+          /* Store word: pop stack, write word
+             arg: -.  */
+        case ETIR__C_STO_W:
+          _bfd_vms_pop (abfd, &op1, &rel1);
+          if (rel1 != RELC_NONE)
+            goto bad_context;
+          image_write_w (abfd, (unsigned int) op1 & 0xffff);
+          break;
+
+          /* Store longword: pop stack, write longword
+             arg: -.  */
+        case ETIR__C_STO_LW:
+          _bfd_vms_pop (abfd, &op1, &rel1);
+          if (rel1 & RELC_SEC_BASE)
+            {
+              op1 = alpha_vms_fix_sec_rel (abfd, info, rel1, op1);
+              rel1 = RELC_REL;
+            }
+          else if (rel1 & RELC_SHR_BASE)
+            {
+              alpha_vms_add_lw_fixup (info, rel1 & RELC_MASK, op1);
+              rel1 = RELC_NONE;
+            }
+          if (rel1 != RELC_NONE)
+            {
+              if (rel1 != RELC_REL)
+                abort ();
+              alpha_vms_add_lw_reloc (info);
+            }
+          image_write_l (abfd, op1);
+          break;
+
+          /* Store quadword: pop stack, write quadword
+             arg: -.  */
+        case ETIR__C_STO_QW:
+          _bfd_vms_pop (abfd, &op1, &rel1);
+          if (rel1 & RELC_SEC_BASE)
+            {
+              op1 = alpha_vms_fix_sec_rel (abfd, info, rel1, op1);
+              rel1 = RELC_REL;
+            }
+          else if (rel1 & RELC_SHR_BASE)
+            abort ();
+          if (rel1 != RELC_NONE)
+            {
+              if (rel1 != RELC_REL)
+                abort ();
+              alpha_vms_add_qw_reloc (info);
+            }
+          image_write_q (abfd, op1);
+          break;
+
+          /* Store immediate repeated: pop stack for repeat count
+             arg: lw	byte count
+             da	data.  */
+        case ETIR__C_STO_IMMR:
+          {
+            int size;
+
+            size = bfd_getl32 (ptr);
+            _bfd_vms_pop (abfd, &op1, &rel1);
+            if (rel1 != RELC_NONE)
+              goto bad_context;
+            while (op1-- > 0)
+              image_write (abfd, ptr + 4, size);
+          }
+          break;
+
+          /* Store global: write symbol value
+             arg: cs	global symbol name.  */
+        case ETIR__C_STO_GBL:
+          _bfd_vms_get_value (abfd, ptr, info, &op1, &h);
+          if (h && h->sym)
+            {
+              if (h->sym->typ == EGSD__C_SYMG)
+                {
+                  alpha_vms_add_fixup_qr
+                    (info, abfd, h->sym->owner, h->sym->symbol_vector);
+                  op1 = 0;
+                }
+              else
+                {
+                  op1 = alpha_vms_get_sym_value (h->sym->section,
+                                                 h->sym->value, h);
+                  alpha_vms_add_qw_reloc (info);
+                }
+            }
+          image_write_q (abfd, op1);
+          break;
+
+          /* Store code address: write address of entry point
+             arg: cs	global symbol name (procedure).  */
+        case ETIR__C_STO_CA:
+          _bfd_vms_get_value (abfd, ptr, info, &op1, &h);
+          if (h && h->sym)
+            {
+              if (h->sym->flags & EGSY__V_NORM)
+                {
+                  /* That's really a procedure.  */
+                  if (h->sym->typ == EGSD__C_SYMG)
+                    {
+                      alpha_vms_add_fixup_ca (info, abfd, h->sym->owner);
+                      op1 = h->sym->symbol_vector;
+                    }
+                  else
+                    {
+                      op1 = alpha_vms_get_sym_value (h->sym->code_section,
+                                                     h->sym->code_value, h);
+                      alpha_vms_add_qw_reloc (info);
+                    }
+                }
+              else
+                {
+                  /* Symbol is not a procedure.  */
+                  abort ();
+                }
+            }
+          image_write_q (abfd, op1);
+          break;
+
+          /* Store offset to psect: pop stack, add low 32 bits to base of psect
+             arg: none.  */
+        case ETIR__C_STO_OFF:
+          _bfd_vms_pop (abfd, &op1, &rel1);
+
+          if (!(rel1 & RELC_SEC_BASE))
+            abort ();
+
+          op1 = alpha_vms_fix_sec_rel (abfd, info, rel1, op1);
+          rel1 = RELC_REL;
+          image_write_q (abfd, op1);
+          break;
+
+          /* Store immediate
+             arg: lw	count of bytes
+             da	data.  */
+        case ETIR__C_STO_IMM:
+          {
+            int size;
+
+            size = bfd_getl32 (ptr);
+            image_write (abfd, ptr + 4, size);
+          }
+          break;
+
+          /* This code is 'reserved to digital' according to the openVMS
+             linker manual, however it is generated by the DEC C compiler
+             and defined in the include file.
+             FIXME, since the following is just a guess
+             store global longword: store 32bit value of symbol
+             arg: cs	symbol name.  */
+        case ETIR__C_STO_GBL_LW:
+          _bfd_vms_get_value (abfd, ptr, info, &op1, &h);
+#if 0
+          abort ();
+#endif
+          image_write_l (abfd, op1);
+          break;
+
+        case ETIR__C_STO_RB:
+        case ETIR__C_STO_AB:
+        case ETIR__C_STO_LP_PSB:
+          (*_bfd_error_handler) (_("%s: not supported"),
+                                 _bfd_vms_etir_name (cmd));
+          return FALSE;
+          break;
+        case ETIR__C_STO_HINT_GBL:
+        case ETIR__C_STO_HINT_PS:
+          (*_bfd_error_handler) (_("%s: not implemented"),
+                                 _bfd_vms_etir_name (cmd));
+          return FALSE;
+          break;
+
+          /* 200 Store-conditional Linkage Pair
+             arg: none.  */
+        case ETIR__C_STC_LP:
+
+          /* 202 Store-conditional Address at global address
+             lw	linkage index
+             cs	global name.  */
+
+        case ETIR__C_STC_GBL:
+
+          /* 203 Store-conditional Code Address at global address
+             lw	linkage index
+             cs	procedure name.  */
+        case ETIR__C_STC_GCA:
+
+          /* 204 Store-conditional Address at psect + offset
+             lw	linkage index
+             lw	psect index
+             qw	offset.  */
+        case ETIR__C_STC_PS:
+          (*_bfd_error_handler) (_("%s: not supported"),
+                                 _bfd_vms_etir_name (cmd));
+          return FALSE;
+          break;
+
+          /* 201 Store-conditional Linkage Pair with Procedure Signature
+             lw	linkage index
+             cs	procedure name
+             by	signature length
+             da	signature.  */
+
+        case ETIR__C_STC_LP_PSB:
+          _bfd_vms_get_value (abfd, ptr + 4, info, &op1, &h);
+          if (h && h->sym)
+            {
+              if (h->sym->typ == EGSD__C_SYMG)
+                {
+                  alpha_vms_add_fixup_lp (info, abfd, h->sym->owner);
+                  op1 = h->sym->symbol_vector;
+                  op2 = 0;
+                }
+              else
+                {
+                  op1 = alpha_vms_get_sym_value (h->sym->code_section,
+                                                 h->sym->code_value, h);
+                  op2 = alpha_vms_get_sym_value (h->sym->section,
+                                                h->sym->value, h);
+                }
+            }
+          else
+            {
+              /* Undefined symbol.  */
+              op1 = 0;
+              op2 = 0;
+            }
+          image_write_q (abfd, op1);
+          image_write_q (abfd, op2);
+          break;
+
+          /* 205 Store-conditional NOP at address of global
+             arg: none.  */
+        case ETIR__C_STC_NOP_GBL:
+          /* ALPHA_R_NOP */
+
+          /* 207 Store-conditional BSR at global address
+             arg: none.  */
+
+        case ETIR__C_STC_BSR_GBL:
+          /* ALPHA_R_BSR */
+
+          /* 209 Store-conditional LDA at global address
+             arg: none.  */
+
+        case ETIR__C_STC_LDA_GBL:
+          /* ALPHA_R_LDA */
+
+          /* 211 Store-conditional BSR or Hint at global address
+             arg: none.  */
+
+        case ETIR__C_STC_BOH_GBL:
+          /* Currentl ignored.  */
+          break;
+
+          /* 213 Store-conditional NOP,BSR or HINT at global address
+             arg: none.  */
+
+        case ETIR__C_STC_NBH_GBL:
+
+          /* 206 Store-conditional NOP at pect + offset
+             arg: none.  */
+
+        case ETIR__C_STC_NOP_PS:
+
+          /* 208 Store-conditional BSR at pect + offset
+             arg: none.  */
+
+        case ETIR__C_STC_BSR_PS:
+
+          /* 210 Store-conditional LDA at psect + offset
+             arg: none.  */
+
+        case ETIR__C_STC_LDA_PS:
+
+          /* 212 Store-conditional BSR or Hint at pect + offset
+             arg: none.  */
+
+        case ETIR__C_STC_BOH_PS:
+
+          /* 214 Store-conditional NOP, BSR or HINT at psect + offset
+             arg: none.  */
+        case ETIR__C_STC_NBH_PS:
+          (*_bfd_error_handler) ("%s: not supported",
+                                 _bfd_vms_etir_name (cmd));
+          return FALSE;
+          break;
+
+          /* Det relocation base: pop stack, set image location counter
+             arg: none.  */
+        case ETIR__C_CTL_SETRB:
+          _bfd_vms_pop (abfd, &op1, &rel1);
+          if (!(rel1 & RELC_SEC_BASE))
+            abort ();
+          image_set_ptr (abfd, op1, rel1 & RELC_MASK, info);
+          break;
+
+          /* Augment relocation base: increment image location counter by offset
+             arg: lw	offset value.  */
+        case ETIR__C_CTL_AUGRB:
+          op1 = bfd_getl32 (ptr);
+          image_inc_ptr (abfd, op1);
+          break;
+
+          /* Define location: pop index, save location counter under index
+             arg: none.  */
+        case ETIR__C_CTL_DFLOC:
+          _bfd_vms_pop (abfd, &op1, &rel1);
+          if (rel1 != RELC_NONE)
+            goto bad_context;
+          dst_define_location (abfd, op1);
+          break;
+
+          /* Set location: pop index, restore location counter from index
+             arg: none.  */
+        case ETIR__C_CTL_STLOC:
+          _bfd_vms_pop (abfd, &op1, &rel1);
+          if (rel1 != RELC_NONE)
+            goto bad_context;
+          dst_restore_location (abfd, op1);
+          break;
+
+          /* Stack defined location: pop index, push location counter from index
+             arg: none.  */
+        case ETIR__C_CTL_STKDL:
+          _bfd_vms_pop (abfd, &op1, &rel1);
+          if (rel1 != RELC_NONE)
+            goto bad_context;
+          _bfd_vms_push (abfd, dst_retrieve_location (abfd, op1), RELC_NONE);
+          break;
+
+        case ETIR__C_OPR_NOP:      /* No-op.  */
+          break;
+
+        case ETIR__C_OPR_ADD:      /* Add.  */
+          _bfd_vms_pop (abfd, &op1, &rel1);
+          _bfd_vms_pop (abfd, &op2, &rel2);
+          if (rel1 == RELC_NONE && rel2 != RELC_NONE)
+            rel1 = rel2;
+          else if (rel1 != RELC_NONE && rel2 != RELC_NONE)
+            goto bad_context;
+          _bfd_vms_push (abfd, op1 + op2, rel1);
+          break;
+
+        case ETIR__C_OPR_SUB:      /* Subtract.  */
+          _bfd_vms_pop (abfd, &op1, &rel1);
+          _bfd_vms_pop (abfd, &op2, &rel2);
+          if (rel1 == RELC_NONE && rel2 != RELC_NONE)
+            rel1 = rel2;
+          else if ((rel1 & RELC_SEC_BASE) && (rel2 & RELC_SEC_BASE))
+            {
+              op1 = alpha_vms_fix_sec_rel (abfd, info, rel1, op1);
+              op2 = alpha_vms_fix_sec_rel (abfd, info, rel2, op2);
+              rel1 = RELC_NONE;
+            }
+          else if (rel1 != RELC_NONE && rel2 != RELC_NONE)
+            goto bad_context;
+          _bfd_vms_push (abfd, op2 - op1, rel1);
+          break;
+
+        case ETIR__C_OPR_MUL:      /* Multiply.  */
+          _bfd_vms_pop (abfd, &op1, &rel1);
+          _bfd_vms_pop (abfd, &op2, &rel2);
+          if (rel1 != RELC_NONE || rel2 != RELC_NONE)
+            goto bad_context;
+          _bfd_vms_push (abfd, op1 * op2, RELC_NONE);
+          break;
+
+        case ETIR__C_OPR_DIV:      /* Divide.  */
+          _bfd_vms_pop (abfd, &op1, &rel1);
+          _bfd_vms_pop (abfd, &op2, &rel2);
+          if (rel1 != RELC_NONE || rel2 != RELC_NONE)
+            goto bad_context;
+          if (op2 == 0)
+            _bfd_vms_push (abfd, 0, RELC_NONE);
+          else
+            _bfd_vms_push (abfd, op2 / op1, RELC_NONE);
+          break;
+
+        case ETIR__C_OPR_AND:      /* Logical AND.  */
+          _bfd_vms_pop (abfd, &op1, &rel1);
+          _bfd_vms_pop (abfd, &op2, &rel2);
+          if (rel1 != RELC_NONE || rel2 != RELC_NONE)
+            goto bad_context;
+          _bfd_vms_push (abfd, op1 & op2, RELC_NONE);
+          break;
+
+        case ETIR__C_OPR_IOR:      /* Logical inclusive OR.  */
+          _bfd_vms_pop (abfd, &op1, &rel1);
+          _bfd_vms_pop (abfd, &op2, &rel2);
+          if (rel1 != RELC_NONE || rel2 != RELC_NONE)
+            goto bad_context;
+          _bfd_vms_push (abfd, op1 | op2, RELC_NONE);
+          break;
+
+        case ETIR__C_OPR_EOR:      /* Logical exclusive OR.  */
+          _bfd_vms_pop (abfd, &op1, &rel1);
+          _bfd_vms_pop (abfd, &op2, &rel2);
+          if (rel1 != RELC_NONE || rel2 != RELC_NONE)
+            goto bad_context;
+          _bfd_vms_push (abfd, op1 ^ op2, RELC_NONE);
+          break;
+
+        case ETIR__C_OPR_NEG:      /* Negate.  */
+          _bfd_vms_pop (abfd, &op1, &rel1);
+          if (rel1 != RELC_NONE)
+            goto bad_context;
+          _bfd_vms_push (abfd, -op1, RELC_NONE);
+          break;
+
+        case ETIR__C_OPR_COM:      /* Complement.  */
+          _bfd_vms_pop (abfd, &op1, &rel1);
+          if (rel1 != RELC_NONE)
+            goto bad_context;
+          _bfd_vms_push (abfd, ~op1, RELC_NONE);
+          break;
+
+        case ETIR__C_OPR_ASH:      /* Arithmetic shift.  */
+          _bfd_vms_pop (abfd, &op1, &rel1);
+          _bfd_vms_pop (abfd, &op2, &rel2);
+          if (rel1 != RELC_NONE || rel2 != RELC_NONE)
+            {
+            bad_context:
+              (*_bfd_error_handler) (_("invalid use of %s with contexts"),
+                                     _bfd_vms_etir_name (cmd));
+              return FALSE;
+            }
+          if ((int)op2 < 0)		/* Shift right.  */
+            op1 >>= -(int)op2;
+          else			/* Shift left.  */
+            op1 <<= (int)op2;
+          _bfd_vms_push (abfd, op1, RELC_NONE); /* FIXME: sym.  */
+          break;
+
+        case ETIR__C_OPR_INSV:      /* Insert field.   */
+        case ETIR__C_OPR_USH:       /* Unsigned shift.   */
+        case ETIR__C_OPR_ROT:       /* Rotate.  */
+        case ETIR__C_OPR_REDEF:     /* Redefine symbol to current location.  */
+        case ETIR__C_OPR_DFLIT:     /* Define a literal.  */
+          (*_bfd_error_handler) (_("%s: not supported"),
+                                 _bfd_vms_etir_name (cmd));
+          return FALSE;
+          break;
+
+        case ETIR__C_OPR_SEL:      /* Select.  */
+          _bfd_vms_pop (abfd, &op1, &rel1);
+          if (op1 & 0x01L)
+            _bfd_vms_pop (abfd, &op1, &rel1);
+          else
+            {
+              _bfd_vms_pop (abfd, &op1, &rel1);
+              _bfd_vms_pop (abfd, &op2, &rel2);
+              _bfd_vms_push (abfd, op1, rel1);
+            }
+          break;
+
+        default:
+          (*_bfd_error_handler) (_("reserved cmd %d"), cmd);
+          return FALSE;
+          break;
+        }
+
+      ptr += cmd_length - 4;
+    }
+
+  return TRUE;
+}
+
+/* Process EDBG/ETBT record.
+   Return TRUE on success, FALSE on error  */
+
+static bfd_boolean
+vms_slurp_debug (bfd *abfd)
+{
+  asection *section = PRIV (dst_section);
+
+  if (section == NULL)
+    {
+      /* We have no way to find out beforehand how much debug info there
+	 is in an object file, so pick an initial amount and grow it as
+	 needed later.  */
+      flagword flags = SEC_HAS_CONTENTS | SEC_DEBUGGING | SEC_RELOC
+        | SEC_IN_MEMORY;
+
+      section = bfd_make_section (abfd, "$DST$");
+      if (!section)
+	return FALSE;
+      if (!bfd_set_section_flags (abfd, section, flags))
+	return FALSE;
+      PRIV (dst_section) = section;
+    }
+
+  PRIV (image_section) = section;
+  PRIV (image_offset) = section->size;
+  PRIV (image_autoextend) = FALSE;
+
+  if (!_bfd_vms_slurp_etir (abfd, NULL))
+    return FALSE;
+
+  return TRUE;
+}
+
+/* Process EDBG record.
+   Return TRUE on success, FALSE on error.  */
+
+static bfd_boolean
+_bfd_vms_slurp_edbg (bfd *abfd)
+{
+  vms_debug2 ((2, "EDBG\n"));
+
+  abfd->flags |= (HAS_DEBUG | HAS_LINENO);
+
+  return vms_slurp_debug (abfd);
+}
+
+/* Process ETBT record.
+   Return TRUE on success, FALSE on error.  */
+
+static bfd_boolean
+_bfd_vms_slurp_etbt (bfd *abfd)
+{
+  vms_debug2 ((2, "ETBT\n"));
+
+  abfd->flags |= HAS_LINENO;
+
+  return vms_slurp_debug (abfd);
+}
+
+/* Process EEOM record.
+   Return TRUE on success, FALSE on error.  */
+
+static bfd_boolean
+_bfd_vms_slurp_eeom (bfd *abfd)
+{
+  struct vms_eeom *eeom = (struct vms_eeom *) PRIV (recrd.rec);
+
+  vms_debug2 ((2, "EEOM\n"));
+
+  PRIV (eom_data).eom_l_total_lps = bfd_getl32 (eeom->total_lps);
+  PRIV (eom_data).eom_w_comcod = bfd_getl16 (eeom->comcod);
+  if (PRIV (eom_data).eom_w_comcod > 1)
+    {
+      (*_bfd_error_handler) (_("Object module NOT error-free !\n"));
+      bfd_set_error (bfd_error_bad_value);
+      return FALSE;
+    }
+
+  PRIV (eom_data).eom_has_transfer = FALSE;
+  if (PRIV (recrd.rec_size) > 10)
+    {
+      PRIV (eom_data).eom_has_transfer = TRUE;
+      PRIV (eom_data).eom_b_tfrflg = eeom->tfrflg;
+      PRIV (eom_data).eom_l_psindx = bfd_getl32 (eeom->psindx);
+      PRIV (eom_data).eom_l_tfradr = bfd_getl32 (eeom->tfradr);
+
+      abfd->start_address = PRIV (eom_data).eom_l_tfradr;
+    }
+  return TRUE;
+}
+
+/* Slurp an ordered set of VMS object records.  Return FALSE on error.  */
+
+static bfd_boolean
+_bfd_vms_slurp_object_records (bfd * abfd)
+{
+  int err, new_type, type = -1;
+
+  do
+    {
+      vms_debug2 ((7, "reading at %08lx\n", (unsigned long)bfd_tell (abfd)));
+
+      new_type = _bfd_vms_get_object_record (abfd);
+      if (new_type < 0)
+	{
+	  vms_debug2 ((2, "next_record failed\n"));
+	  return FALSE;
+	}
+
+      type = new_type;
+
+      switch (type)
+	{
+        case EOBJ__C_EMH:
+          err = _bfd_vms_slurp_ehdr (abfd);
+          break;
+        case EOBJ__C_EEOM:
+          err = _bfd_vms_slurp_eeom (abfd);
+          break;
+        case EOBJ__C_EGSD:
+          err = _bfd_vms_slurp_egsd (abfd);
+          break;
+        case EOBJ__C_ETIR:
+          err = TRUE; /* _bfd_vms_slurp_etir (abfd); */
+          break;
+        case EOBJ__C_EDBG:
+          err = _bfd_vms_slurp_edbg (abfd);
+          break;
+        case EOBJ__C_ETBT:
+          err = _bfd_vms_slurp_etbt (abfd);
+          break;
+        default:
+          err = FALSE;
+	}
+      if (err != TRUE)
+	{
+	  vms_debug2 ((2, "slurp type %d failed\n", type));
+	  return FALSE;
+	}
+    }
+  while (type != EOBJ__C_EEOM);
+
+  return TRUE;
+}
+
+/* Initialize private data  */
+static bfd_boolean
+vms_initialize (bfd * abfd)
+{
+  bfd_size_type amt;
+
+  amt = sizeof (struct vms_private_data_struct);
+  abfd->tdata.any = bfd_zalloc (abfd, amt);
+  if (abfd->tdata.any == NULL)
+    return FALSE;
+
+  PRIV (recrd.file_format) = FF_UNKNOWN;
+
+  amt = sizeof (struct stack_struct) * STACKSIZE;
+  PRIV (stack) = bfd_alloc (abfd, amt);
+  if (PRIV (stack) == NULL)
+    goto error_ret1;
+
+  return TRUE;
+
+ error_ret1:
+  bfd_release (abfd, abfd->tdata.any);
+  abfd->tdata.any = NULL;
+  return FALSE;
+}
+
+/* Check the format for a file being read.
+   Return a (bfd_target *) if it's an object file or zero if not.  */
+
+static const struct bfd_target *
+alpha_vms_object_p (bfd *abfd)
+{
+  PTR tdata_save = abfd->tdata.any;
+  unsigned int test_len;
+  unsigned char *buf;
+
+  vms_debug2 ((1, "vms_object_p(%p)\n", abfd));
+
+  /* Allocate alpha-vms specific data.  */
+  if (!vms_initialize (abfd))
+    goto error_ret;
+
+  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET))
+    goto err_wrong_format;
+
+  /* The first challenge with VMS is to discover the kind of the file.
+
+     Image files (executable or shared images) are stored as a raw
+     stream of bytes (like on UNIX), but there is no magic number.
+
+     Object files are written with RMS (record management service), ie
+     each records are preceeded by its length (on a word - 2 bytes), and
+     padded for word-alignment.  That would be simple but when files
+     are transfered to a UNIX filesystem (using ftp), records are lost.
+     Only the raw content of the records are transfered.  Fortunately,
+     the Alpha Object file format also store the length of the record
+     in the records.  Is that clear ?  */
+
+  /* Minimum is 6 bytes for objects (2 bytes size, 2 bytes record id,
+     2 bytes size repeated) and 12 bytes for images (4 bytes major id,
+     4 bytes minor id, 4 bytes length).  */
+  test_len = 12;
+
+  /* Size the main buffer.  */
+  buf = (unsigned char *) bfd_malloc (test_len);
+  if (buf == NULL)
+    goto error_ret;
+  PRIV (recrd.buf) = buf;
+  PRIV (recrd.buf_size) = test_len;
+
+  /* Initialize the record pointer.  */
+  PRIV (recrd.rec) = buf;
+
+  if (bfd_bread (buf, test_len, abfd) != test_len)
+    {
+      bfd_set_error (bfd_error_file_truncated);
+      goto error_ret;
+    }
+
+  /* Is it an image?  */
+  if ((bfd_getl32 (buf) == EIHD__K_MAJORID)
+      && (bfd_getl32 (buf + 4) == EIHD__K_MINORID))
+    {
+      unsigned int to_read;
+      unsigned int read_so_far;
+      unsigned int remaining;
+      unsigned int eisd_offset, eihs_offset;
+
+      /* Extract the header size.  */
+      PRIV (recrd.rec_size) = bfd_getl32 (buf + EIHD__L_SIZE);
+
+      if (PRIV (recrd.rec_size) > PRIV (recrd.buf_size))
+        {
+          buf = bfd_realloc_or_free (buf, PRIV (recrd.rec_size));
+
+          if (buf == NULL)
+            {
+              PRIV (recrd.buf) = NULL;
+              bfd_set_error (bfd_error_no_memory);
+              goto error_ret;
+            }
+          PRIV (recrd.buf) = buf;
+          PRIV (recrd.buf_size) = PRIV (recrd.rec_size);
+        }
+
+      /* Read the remaining record.  */
+      remaining = PRIV (recrd.rec_size) - test_len;
+      to_read = MIN (VMS_BLOCK_SIZE - test_len, remaining);
+      read_so_far = test_len;
+
+      while (remaining > 0)
+        {
+          if (bfd_bread (buf + read_so_far, to_read, abfd) != to_read)
+            {
+              bfd_set_error (bfd_error_file_truncated);
+              goto err_wrong_format;
+            }
+
+          read_so_far += to_read;
+          remaining -= to_read;
+
+          to_read = MIN (VMS_BLOCK_SIZE, remaining);
+        }
+
+      /* Reset the record pointer.  */
+      PRIV (recrd.rec) = buf;
+
+      vms_debug2 ((2, "file type is image\n"));
+
+      if (_bfd_vms_slurp_eihd (abfd, &eisd_offset, &eihs_offset) != TRUE)
+        goto err_wrong_format;
+
+      if (_bfd_vms_slurp_eisd (abfd, eisd_offset) != TRUE)
+        goto err_wrong_format;
+
+      /* EIHS is optional.  */
+      if (eihs_offset != 0 && _bfd_vms_slurp_eihs (abfd, eihs_offset) != TRUE)
+        goto err_wrong_format;
+    }
+  else
+    {
+      int type;
+
+      /* Assume it's a module and adjust record pointer if necessary.  */
+      maybe_adjust_record_pointer_for_object (abfd);
+
+      /* But is it really a module?  */
+      if (bfd_getl16 (PRIV (recrd.rec)) <= EOBJ__C_MAXRECTYP
+          && bfd_getl16 (PRIV (recrd.rec) + 2) <= EOBJ__C_MAXRECSIZ)
+        {
+          if (vms_get_remaining_object_record (abfd, test_len) <= 0)
+            goto err_wrong_format;
+
+          vms_debug2 ((2, "file type is module\n"));
+
+          type = bfd_getl16 (PRIV (recrd.rec));
+          if (type != EOBJ__C_EMH || _bfd_vms_slurp_ehdr (abfd) != TRUE)
+            goto err_wrong_format;
+
+          if (_bfd_vms_slurp_object_records (abfd) != TRUE)
+            goto err_wrong_format;
+        }
+      else
+        goto err_wrong_format;
+    }
+
+  /* Set arch_info to alpha.   */
+
+  if (! bfd_default_set_arch_mach (abfd, bfd_arch_alpha, 0))
+    goto err_wrong_format;
+
+  return abfd->xvec;
+
+ err_wrong_format:
+  bfd_set_error (bfd_error_wrong_format);
+
+ error_ret:
+  if (PRIV (recrd.buf))
+    free (PRIV (recrd.buf));
+  if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
+    bfd_release (abfd, abfd->tdata.any);
+  abfd->tdata.any = tdata_save;
+  return NULL;
+}
+
+/* Image write.  */
+
+static void
+vector_grow1 (struct vector_type *vec, size_t elsz)
+{
+  if (vec->nbr_el + 1 < vec->max_el)
+    return;
+
+  if (vec->max_el == 0)
+    {
+      vec->max_el = 16;
+      vec->els = bfd_malloc2 (vec->max_el, elsz);
+    }
+  else
+    {
+      vec->max_el *= 2;
+      vec->els = bfd_realloc2 (vec->els, vec->max_el, elsz);
+    }
+}
+
+/* Bump ABFD file position to next block.  */
+
+static void
+alpha_vms_file_position_block (bfd *abfd)
+{
+  /* Next block.  */
+  PRIV (file_pos) += VMS_BLOCK_SIZE - 1;
+  PRIV (file_pos) -= (PRIV (file_pos) % VMS_BLOCK_SIZE);
+}
+
+static void
+alpha_vms_swap_eisd_out (struct vms_internal_eisd_map *src,
+                         struct vms_eisd *dst)
+{
+  bfd_putl32 (src->u.eisd.majorid, dst->majorid);
+  bfd_putl32 (src->u.eisd.minorid, dst->minorid);
+  bfd_putl32 (src->u.eisd.eisdsize, dst->eisdsize);
+  if (src->u.eisd.eisdsize <= EISD__K_LENEND)
+    return;
+  bfd_putl32 (src->u.eisd.secsize, dst->secsize);
+  bfd_putl64 (src->u.eisd.virt_addr, dst->virt_addr);
+  bfd_putl32 (src->u.eisd.flags, dst->flags);
+  bfd_putl32 (src->u.eisd.vbn, dst->vbn);
+  dst->pfc = src->u.eisd.pfc;
+  dst->matchctl = src->u.eisd.matchctl;
+  dst->type = src->u.eisd.type;
+  dst->fill_1 = 0;
+  if (src->u.eisd.flags & EISD__M_GBL)
+    {
+      bfd_putl32 (src->u.gbl_eisd.ident, dst->ident);
+      memcpy (dst->gblnam, src->u.gbl_eisd.gblnam,
+              src->u.gbl_eisd.gblnam[0] + 1);
+    }
+}
+
+/* Append EISD to the list of extra eisd for ABFD.  */
+
+static void
+alpha_vms_append_extra_eisd (bfd *abfd, struct vms_internal_eisd_map *eisd)
+{
+  eisd->next = NULL;
+  if (PRIV (gbl_eisd_head) == NULL)
+    PRIV (gbl_eisd_head) = eisd;
+  else
+    PRIV (gbl_eisd_tail)->next = eisd;
+  PRIV (gbl_eisd_tail) = eisd;
+}
+
+static bfd_boolean
+alpha_vms_create_eisd_for_shared (bfd *abfd, bfd *shrimg)
+{
+  struct vms_internal_eisd_map *eisd;
+  int namlen;
+
+  namlen = strlen (PRIV2 (shrimg, hdr_data.hdr_t_name));
+  if (namlen + 5 > EISD__K_GBLNAMLEN)
+    {
+      /* Won't fit.  */
+      return FALSE;
+    }
+
+  eisd = bfd_alloc (abfd, sizeof (*eisd));
+  if (eisd == NULL)
+    return FALSE;
+
+  /* Fill the fields.  */
+  eisd->u.gbl_eisd.common.majorid = EISD__K_MAJORID;
+  eisd->u.gbl_eisd.common.minorid = EISD__K_MINORID;
+  eisd->u.gbl_eisd.common.eisdsize = (EISD__K_LEN + 4 + namlen + 5 + 3) & ~3;
+  eisd->u.gbl_eisd.common.secsize = VMS_BLOCK_SIZE;	/* Must not be 0.  */
+  eisd->u.gbl_eisd.common.virt_addr = 0;
+  eisd->u.gbl_eisd.common.flags = EISD__M_GBL;
+  eisd->u.gbl_eisd.common.vbn = 0;
+  eisd->u.gbl_eisd.common.pfc = 0;
+  eisd->u.gbl_eisd.common.matchctl = PRIV2 (shrimg, matchctl);
+  eisd->u.gbl_eisd.common.type = EISD__K_SHRPIC;
+
+  eisd->u.gbl_eisd.ident = PRIV2 (shrimg, ident);
+  eisd->u.gbl_eisd.gblnam[0] = namlen + 4;
+  memcpy (eisd->u.gbl_eisd.gblnam + 1, PRIV2 (shrimg, hdr_data.hdr_t_name),
+          namlen);
+  memcpy (eisd->u.gbl_eisd.gblnam + 1 + namlen, "_001", 4);
+
+  /* Append it to the list.  */
+  alpha_vms_append_extra_eisd (abfd, eisd);
+
+  return TRUE;
+}
+
+static bfd_boolean
+alpha_vms_create_eisd_for_section (bfd *abfd, asection *sec)
+{
+  struct vms_internal_eisd_map *eisd;
+
+  /* Only for allocating section.  */
+  if (!(sec->flags & SEC_ALLOC))
+    return TRUE;
+
+  BFD_ASSERT (vms_section_data (sec)->eisd == NULL);
+  eisd = bfd_alloc (abfd, sizeof (*eisd));
+  if (eisd == NULL)
+    return FALSE;
+  vms_section_data (sec)->eisd = eisd;
+
+  /* Fill the fields.  */
+  eisd->u.eisd.majorid = EISD__K_MAJORID;
+  eisd->u.eisd.minorid = EISD__K_MINORID;
+  eisd->u.eisd.eisdsize = EISD__K_LEN;
+  eisd->u.eisd.secsize =
+    (sec->size + VMS_BLOCK_SIZE - 1) & ~(VMS_BLOCK_SIZE - 1);
+  eisd->u.eisd.virt_addr = sec->vma;
+  eisd->u.eisd.flags = 0;
+  eisd->u.eisd.vbn = 0; /* To be later defined.  */
+  eisd->u.eisd.pfc = 0; /* Default.  */
+  eisd->u.eisd.matchctl = EISD__K_MATALL;
+  eisd->u.eisd.type = EISD__K_NORMAL;
+
+  if (sec->flags & SEC_CODE)
+    eisd->u.eisd.flags |= EISD__M_EXE;
+  if (!(sec->flags & SEC_READONLY))
+    eisd->u.eisd.flags |= EISD__M_WRT | EISD__M_CRF;
+
+  if (!(sec->flags & SEC_LOAD))
+    {
+      eisd->u.eisd.flags |= EISD__M_DZRO;
+      eisd->u.eisd.flags &= ~EISD__M_CRF;
+    }
+  if (sec->flags & SEC_LINKER_CREATED)
+    {
+      if (strcmp (sec->name, "$FIXUP$") == 0)
+        eisd->u.eisd.flags |= EISD__M_FIXUPVEC;
+    }
+
+  /* Append it to the list.  */
+  eisd->next = NULL;
+  if (PRIV (eisd_head) == NULL)
+    PRIV (eisd_head) = eisd;
+  else
+    PRIV (eisd_tail)->next = eisd;
+  PRIV (eisd_tail) = eisd;
+
+  return TRUE;
+}
+
+static bfd_boolean
+alpha_vms_write_exec (bfd *abfd)
+{
+  struct vms_eihd eihd;
+  struct vms_eiha *eiha;
+  struct vms_eihi *eihi;
+  struct vms_eihs *eihs = NULL;
+  asection *sec;
+  struct vms_internal_eisd_map *first_eisd;
+  struct vms_internal_eisd_map *eisd;
+  asection *dst;
+
+  PRIV (file_pos) = EIHD__C_LENGTH;
+
+  memset (&eihd, 0, sizeof (eihd));
+  memset (eihd.fill_2, 0xff, sizeof (eihd.fill_2));
+
+  bfd_putl32 (EIHD__K_MAJORID, eihd.majorid);
+  bfd_putl32 (EIHD__K_MINORID, eihd.minorid);
+
+  bfd_putl32 (sizeof (eihd), eihd.size);
+  bfd_putl32 (0, eihd.isdoff);
+  bfd_putl32 (0, eihd.activoff);
+  bfd_putl32 (0, eihd.symdbgoff);
+  bfd_putl32 (0, eihd.imgidoff);
+  bfd_putl32 (0, eihd.patchoff);
+  bfd_putl64 (0, eihd.iafva);
+  bfd_putl32 (0, eihd.version_array_off);
+
+  bfd_putl32 (EIHD__K_EXE, eihd.imgtype);
+  bfd_putl32 (0, eihd.subtype);
+
+  bfd_putl32 (0, eihd.imgiocnt);
+  bfd_putl32 (-1, eihd.privreqs);
+  bfd_putl32 (-1, eihd.privreqs + 4);
+
+  bfd_putl32 ((sizeof (eihd) + VMS_BLOCK_SIZE - 1) / VMS_BLOCK_SIZE,
+              eihd.hdrblkcnt);
+  bfd_putl32 (0, eihd.lnkflags);
+  bfd_putl32 (0, eihd.ident);
+  bfd_putl32 (0, eihd.sysver);
+
+  eihd.matchctl = 0;
+  bfd_putl32 (0, eihd.symvect_size);
+  bfd_putl32 (16, eihd.virt_mem_block_size);
+  bfd_putl32 (0, eihd.ext_fixup_off);
+  bfd_putl32 (0, eihd.noopt_psect_off);
+  bfd_putl32 (-1, eihd.alias);
+
+  /* Alloc EIHA.  */
+  eiha = (struct vms_eiha *)((char *) &eihd + PRIV (file_pos));
+  bfd_putl32 (PRIV (file_pos), eihd.activoff);
+  PRIV (file_pos) += sizeof (struct vms_eiha);
+
+  bfd_putl32 (sizeof (struct vms_eiha), eiha->size);
+  bfd_putl32 (0, eiha->spare);
+  bfd_putl32 (0x00000340, eiha->tfradr1);	/* SYS$IMGACT */
+  bfd_putl32 (0xffffffff, eiha->tfradr1_h);
+  bfd_putl64 (bfd_get_start_address (abfd), eiha->tfradr2);
+  bfd_putl64 (0, eiha->tfradr3);
+  bfd_putl64 (0, eiha->tfradr4);
+  bfd_putl64 (0, eiha->inishr);
+
+  /* Alloc EIHI.  */
+  eihi = (struct vms_eihi *)((char *) &eihd + PRIV (file_pos));
+  bfd_putl32 (PRIV (file_pos), eihd.imgidoff);
+  PRIV (file_pos) += sizeof (struct vms_eihi);
+
+  bfd_putl32 (EIHI__K_MAJORID, eihi->majorid);
+  bfd_putl32 (EIHI__K_MINORID, eihi->minorid);
+  {
+    char *module;
+    unsigned int len;
+
+    module = vms_get_module_name (bfd_get_filename (abfd), TRUE);
+    len = strlen (module);
+    if (len > sizeof (eihi->imgnam) - 1)
+      len = sizeof (eihi->imgnam) - 1;
+    eihi->imgnam[0] = len;
+    memcpy (eihi->imgnam + 1, module, len);
+    free (module);
+  }
+  bfd_putl32 (0, eihi->linktime + 0);
+  bfd_putl32 (0, eihi->linktime + 4);
+  eihi->imgid[0] = 0;
+  eihi->linkid[0] = 0;
+  eihi->imgbid[0] = 0;
+
+  /* Alloc EIHS.  */
+  dst = bfd_get_section_by_name (abfd, "$DST$");
+  if (dst == NULL || dst->size == 0)
+    dst = bfd_get_section_by_name (abfd, "$TBT$");
+  if (dst != NULL && dst->size != 0)
+    {
+      eihs = (struct vms_eihs *)((char *) &eihd + PRIV (file_pos));
+      bfd_putl32 (PRIV (file_pos), eihd.symdbgoff);
+      PRIV (file_pos) += sizeof (struct vms_eihs);
+
+      bfd_putl32 (EIHS__K_MAJORID, eihs->majorid);
+      bfd_putl32 (EIHS__K_MINORID, eihs->minorid);
+      bfd_putl32 (0, eihs->dstvbn);
+      bfd_putl32 (0, eihs->dstsize);
+      bfd_putl32 (0, eihs->gstvbn);
+      bfd_putl32 (0, eihs->gstsize);
+      bfd_putl32 (0, eihs->dmtvbn);
+      bfd_putl32 (0, eihs->dmtsize);
+    }
+
+  /* One per section.  */
+  for (sec = abfd->sections; sec; sec = sec->next)
+    {
+      if (!alpha_vms_create_eisd_for_section (abfd, sec))
+        return FALSE;
+    }
+
+  /* Merge section EIDS which extra ones.  */
+  if (PRIV (eisd_tail))
+    PRIV (eisd_tail)->next = PRIV (gbl_eisd_head);
+  else
+    PRIV (eisd_head) = PRIV (gbl_eisd_head);
+  if (PRIV (gbl_eisd_tail))
+    PRIV (eisd_tail) = PRIV (gbl_eisd_tail);
+
+  first_eisd = PRIV (eisd_head);
+
+  /* Add end of eisd.  */
+  if (first_eisd)
+    {
+      eisd = bfd_zalloc (abfd, sizeof (*eisd));
+      if (eisd == NULL)
+        return FALSE;
+      eisd->u.eisd.majorid = 0;
+      eisd->u.eisd.minorid = 0;
+      eisd->u.eisd.eisdsize = 0;
+      alpha_vms_append_extra_eisd (abfd, eisd);
+    }
+
+  /* Place EISD in the file.  */
+  for (eisd = first_eisd; eisd; eisd = eisd->next)
+    {
+      file_ptr room = VMS_BLOCK_SIZE - (PRIV (file_pos) % VMS_BLOCK_SIZE);
+
+      /* First block is a little bit special: there is a word at the end.  */
+      if (PRIV (file_pos) < VMS_BLOCK_SIZE && room > 2)
+        room -= 2;
+      if (room < eisd->u.eisd.eisdsize + EISD__K_LENEND)
+        alpha_vms_file_position_block (abfd);
+
+      eisd->file_pos = PRIV (file_pos);
+      PRIV (file_pos) += eisd->u.eisd.eisdsize;
+
+      if (eisd->u.eisd.flags & EISD__M_FIXUPVEC)
+        bfd_putl64 (eisd->u.eisd.virt_addr, eihd.iafva);
+    }
+
+  if (first_eisd != NULL)
+    {
+      bfd_putl32 (first_eisd->file_pos, eihd.isdoff);
+      /* Real size of end of eisd marker.  */
+      PRIV (file_pos) += EISD__K_LENEND;
+    }
+
+  bfd_putl32 (PRIV (file_pos), eihd.size);
+  bfd_putl32 ((PRIV (file_pos) + VMS_BLOCK_SIZE - 1) / VMS_BLOCK_SIZE,
+              eihd.hdrblkcnt);
+
+  /* Place sections.  */
+  for (sec = abfd->sections; sec; sec = sec->next)
+    {
+      if (!(sec->flags & SEC_HAS_CONTENTS))
+        continue;
+
+      eisd = vms_section_data (sec)->eisd;
+
+      /* Align on a block.  */
+      alpha_vms_file_position_block (abfd);
+      sec->filepos = PRIV (file_pos);
+
+      if (eisd != NULL)
+        eisd->u.eisd.vbn = (sec->filepos / VMS_BLOCK_SIZE) + 1;
+
+      PRIV (file_pos) += sec->size;
+    }
+
+  if (eihs != NULL && dst != NULL)
+    {
+      bfd_putl32 ((dst->filepos / VMS_BLOCK_SIZE) + 1, eihs->dstvbn);
+      bfd_putl32 (dst->size, eihs->dstsize);
+    }
+
+  /* Write EISD in hdr.  */
+  for (eisd = first_eisd; eisd && eisd->file_pos < VMS_BLOCK_SIZE;
+       eisd = eisd->next)
+    alpha_vms_swap_eisd_out
+      (eisd, (struct vms_eisd *)((char *)&eihd + eisd->file_pos));
+
+  /* Write first block.  */
+  if (bfd_bwrite (&eihd, sizeof (eihd), abfd) != sizeof (eihd))
+    return FALSE;
+
+  /* Write remaining eisd.  */
+  if (eisd != NULL)
+    {
+      unsigned char blk[VMS_BLOCK_SIZE];
+      struct vms_internal_eisd_map *next_eisd;
+
+      memset (blk, 0xff, sizeof (blk));
+      while (eisd != NULL)
+        {
+          alpha_vms_swap_eisd_out
+            (eisd,
+             (struct vms_eisd *)(blk + (eisd->file_pos % VMS_BLOCK_SIZE)));
+
+          next_eisd = eisd->next;
+          if (next_eisd == NULL
+              || (next_eisd->file_pos / VMS_BLOCK_SIZE
+                  != eisd->file_pos / VMS_BLOCK_SIZE))
+            {
+              if (bfd_bwrite (blk, sizeof (blk), abfd) != sizeof (blk))
+                return FALSE;
+
+              memset (blk, 0xff, sizeof (blk));
+            }
+          eisd = next_eisd;
+        }
+    }
+
+  /* Write sections.  */
+  for (sec = abfd->sections; sec; sec = sec->next)
+    {
+      unsigned char blk[VMS_BLOCK_SIZE];
+      bfd_size_type len;
+
+      if (sec->size == 0 || !(sec->flags & SEC_HAS_CONTENTS))
+        continue;
+      if (bfd_bwrite (sec->contents, sec->size, abfd) != sec->size)
+        return FALSE;
+
+      /* Pad.  */
+      len = VMS_BLOCK_SIZE - sec->size % VMS_BLOCK_SIZE;
+      if (len != VMS_BLOCK_SIZE)
+        {
+          memset (blk, 0, len);
+          if (bfd_bwrite (blk, len, abfd) != len)
+            return FALSE;
+        }
+    }
+
+  return TRUE;
+}
+
+/* Object write.  */
+
+/* This hash routine borrowed from GNU-EMACS, and strengthened
+   slightly.  ERY.  */
+
+static int
+hash_string (const char *ptr)
+{
+  const unsigned char *p = (unsigned char *) ptr;
+  const unsigned char *end = p + strlen (ptr);
+  unsigned char c;
+  int hash = 0;
+
+  while (p != end)
+    {
+      c = *p++;
+      hash = ((hash << 3) + (hash << 15) + (hash >> 28) + c);
+    }
+  return hash;
+}
+
+/* Generate a length-hashed VMS symbol name (limited to maxlen chars).  */
+
+static char *
+_bfd_vms_length_hash_symbol (bfd *abfd, const char *in, int maxlen)
+{
+  unsigned long result;
+  int in_len;
+  char *new_name;
+  const char *old_name;
+  int i;
+  static char outbuf[EOBJ__C_SYMSIZ + 1];
+  char *out = outbuf;
+
+#if VMS_DEBUG
+  vms_debug (4, "_bfd_vms_length_hash_symbol \"%s\"\n", in);
+#endif
+
+  if (maxlen > EOBJ__C_SYMSIZ)
+    maxlen = EOBJ__C_SYMSIZ;
+
+  /* Save this for later.  */
+  new_name = out;
+
+  /* We may need to truncate the symbol, save the hash for later.  */
+  in_len = strlen (in);
+
+  result = (in_len > maxlen) ? hash_string (in) : 0;
+
+  old_name = in;
+
+  /* Do the length checking.  */
+  if (in_len <= maxlen)
+    i = in_len;
+  else
+    {
+      if (PRIV (flag_hash_long_names))
+	i = maxlen - 9;
+      else
+	i = maxlen;
+    }
+
+  strncpy (out, in, (size_t) i);
+  in += i;
+  out += i;
+
+  if ((in_len > maxlen)
+      && PRIV (flag_hash_long_names))
+    sprintf (out, "_%08lx", result);
+  else
+    *out = 0;
+
+#if VMS_DEBUG
+  vms_debug (4, "--> [%d]\"%s\"\n", (int)strlen (outbuf), outbuf);
+#endif
+
+  if (in_len > maxlen
+	&& PRIV (flag_hash_long_names)
+	&& PRIV (flag_show_after_trunc))
+    printf (_("Symbol %s replaced by %s\n"), old_name, new_name);
+
+  return outbuf;
+}
+
+/* Write section and symbol directory of bfd abfd.  Return FALSE on error.  */
+
+static bfd_boolean
+_bfd_vms_write_egsd (bfd *abfd)
+{
+  asection *section;
+  asymbol *symbol;
+  unsigned int symnum;
+  int last_index = -1;
+  char dummy_name[10];
+  char *sname;
+  flagword new_flags, old_flags;
+  int abs_section_index = 0;
+  struct vms_rec_wr *recwr = &PRIV (recwr);
+
+  vms_debug2 ((2, "vms_write_gsd\n"));
+
+  /* Output sections.  */
+  section = abfd->sections;
+  vms_debug2 ((3, "%d sections found\n", abfd->section_count));
+
+  /* Egsd is quadword aligned.  */
+  _bfd_vms_output_alignment (recwr, 8);
+
+  _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
+  _bfd_vms_output_long (recwr, 0);
+
+  while (section != 0)
+    {
+      vms_debug2 ((3, "Section #%d %s, %d bytes\n",
+                   section->index, section->name, (int)section->size));
+
+      /* Don't write out the VMS debug info section since it is in the
+         ETBT and EDBG sections in etir. */
+      if (!strcmp (section->name, ".vmsdebug"))
+        goto done;
+
+      /* 13 bytes egsd, max 31 chars name -> should be 44 bytes.  */
+      if (_bfd_vms_output_check (recwr, 64) < 0)
+	{
+	  _bfd_vms_output_end (abfd, recwr);
+	  _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
+	  _bfd_vms_output_long (recwr, 0);
+	}
+
+      /* Create dummy sections to keep consecutive indices.  */
+      while (section->index - last_index > 1)
+	{
+	  vms_debug2 ((3, "index %d, last %d\n", section->index, last_index));
+	  _bfd_vms_output_begin_subrec (recwr, EGSD__C_PSC);
+	  _bfd_vms_output_short (recwr, 0);
+	  _bfd_vms_output_short (recwr, 0);
+	  _bfd_vms_output_long (recwr, 0);
+	  sprintf (dummy_name, ".DUMMY%02d", last_index);
+	  _bfd_vms_output_counted (recwr, dummy_name);
+	  _bfd_vms_output_end_subrec (recwr);
+	  last_index++;
+	}
+
+      /* Don't know if this is necessary for the linker but for now it keeps
+	 vms_slurp_gsd happy  */
+      sname = (char *)section->name;
+      if (*sname == '.')
+	{
+	  sname++;
+	  if ((*sname == 't') && (strcmp (sname, "text") == 0))
+	    sname = EVAX_CODE_NAME;
+	  else if ((*sname == 'd') && (strcmp (sname, "data") == 0))
+	    sname = EVAX_DATA_NAME;
+	  else if ((*sname == 'b') && (strcmp (sname, "bss") == 0))
+	    sname = EVAX_BSS_NAME;
+	  else if ((*sname == 'l') && (strcmp (sname, "link") == 0))
+	    sname = EVAX_LINK_NAME;
+	  else if ((*sname == 'r') && (strcmp (sname, "rdata") == 0))
+	    sname = EVAX_READONLY_NAME;
+	  else if ((*sname == 'l') && (strcmp (sname, "literal") == 0))
+	    sname = EVAX_LITERAL_NAME;
+	  else if ((*sname == 'l') && (strcmp (sname, "literals") == 0))
+	    {
+	      sname = EVAX_LITERALS_NAME;
+	      abs_section_index = section->index;
+	    }
+	  else if ((*sname == 'c') && (strcmp (sname, "comm") == 0))
+	    sname = EVAX_COMMON_NAME;
+	  else if ((*sname == 'l') && (strcmp (sname, "lcomm") == 0))
+	    sname = EVAX_LOCAL_NAME;
+	}
+      else
+	sname = _bfd_vms_length_hash_symbol (abfd, sname, EOBJ__C_SECSIZ);
+
+      _bfd_vms_output_begin_subrec (recwr, EGSD__C_PSC);
+      _bfd_vms_output_short (recwr, section->alignment_power & 0xff);
+
+      if (bfd_is_com_section (section))
+	new_flags = (EGPS__V_OVR | EGPS__V_REL | EGPS__V_GBL | EGPS__V_RD
+		     | EGPS__V_WRT | EGPS__V_NOMOD | EGPS__V_COM);
+      else
+	new_flags = vms_esecflag_by_name (evax_section_flags, sname,
+					  section->size > 0);
+
+      /* Modify them as directed.  */
+      if (section->flags & SEC_READONLY)
+	new_flags &= ~EGPS__V_WRT;
+
+      new_flags &= ~vms_section_data (section)->no_flags;
+      new_flags |= vms_section_data (section)->flags;
+
+      vms_debug2 ((3, "sec flags %x\n", section->flags));
+      vms_debug2 ((3, "new_flags %x, _raw_size %lu\n",
+                   new_flags, (unsigned long)section->size));
+
+      _bfd_vms_output_short (recwr, new_flags);
+      _bfd_vms_output_long (recwr, (unsigned long) section->size);
+      _bfd_vms_output_counted (recwr, sname);
+      _bfd_vms_output_end_subrec (recwr);
+
+      last_index = section->index;
+done:
+      section = section->next;
+    }
+
+  /* Output symbols.  */
+  vms_debug2 ((3, "%d symbols found\n", abfd->symcount));
+
+  bfd_set_start_address (abfd, (bfd_vma) -1);
+
+  for (symnum = 0; symnum < abfd->symcount; symnum++)
+    {
+      char *hash;
+
+      symbol = abfd->outsymbols[symnum];
+      if (*(symbol->name) == '_')
+	{
+	  if (strcmp (symbol->name, "__main") == 0)
+	    bfd_set_start_address (abfd, (bfd_vma)symbol->value);
+	}
+      old_flags = symbol->flags;
+
+      if (old_flags & BSF_FILE)
+	continue;
+
+      if ((old_flags & BSF_GLOBAL) == 0		   /* Not xdef...  */
+	  && !bfd_is_und_section (symbol->section) /* and not xref... */
+	  && !((old_flags & BSF_SECTION_SYM) != 0  /* and not LIB$INITIALIZE.  */
+	       && strcmp (symbol->section->name, "LIB$INITIALIZE") == 0))
+	continue;
+
+      /* 13 bytes egsd, max 64 chars name -> should be 77 bytes.  */
+      if (_bfd_vms_output_check (recwr, 80) < 0)
+	{
+	  _bfd_vms_output_end (abfd, recwr);
+	  _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
+	  _bfd_vms_output_long (recwr, 0);
+	}
+
+      _bfd_vms_output_begin_subrec (recwr, EGSD__C_SYM);
+
+      /* Data type, alignment.  */
+      _bfd_vms_output_short (recwr, 0);
+
+      new_flags = 0;
+
+      if (old_flags & BSF_WEAK)
+	new_flags |= EGSY__V_WEAK;
+      if (bfd_is_com_section (symbol->section))		/* .comm  */
+	new_flags |= (EGSY__V_WEAK | EGSY__V_COMM);
+
+      if (old_flags & BSF_FUNCTION)
+	{
+	  new_flags |= EGSY__V_NORM;
+	  new_flags |= EGSY__V_REL;
+	}
+      if (old_flags & BSF_GLOBAL)
+	{
+	  new_flags |= EGSY__V_DEF;
+	  if (!bfd_is_abs_section (symbol->section))
+	    new_flags |= EGSY__V_REL;
+	}
+      _bfd_vms_output_short (recwr, new_flags);
+
+      if (old_flags & BSF_GLOBAL)
+	{
+	  /* Symbol definition.  */
+	  bfd_vma code_address = 0;
+	  unsigned long ca_psindx = 0;
+	  unsigned long psindx;
+
+	  if ((old_flags & BSF_FUNCTION) && symbol->udata.p != NULL)
+	    {
+	      asymbol *sym;
+
+              sym = ((struct evax_private_udata_struct *)symbol->udata.p)->enbsym;
+	      code_address = sym->value;
+	      ca_psindx = sym->section->index;
+	    }
+	  if (bfd_is_abs_section (symbol->section))
+	    psindx = abs_section_index;
+	  else
+	    psindx = symbol->section->index;
+
+	  _bfd_vms_output_quad (recwr, symbol->value);
+	  _bfd_vms_output_quad (recwr, code_address);
+	  _bfd_vms_output_long (recwr, ca_psindx);
+	  _bfd_vms_output_long (recwr, psindx);
+	}
+      hash = _bfd_vms_length_hash_symbol (abfd, symbol->name, EOBJ__C_SYMSIZ);
+      _bfd_vms_output_counted (recwr, hash);
+
+      _bfd_vms_output_end_subrec (recwr);
+
+    }
+
+  _bfd_vms_output_alignment (recwr, 8);
+  _bfd_vms_output_end (abfd, recwr);
+
+  return TRUE;
+}
+
+/* Write object header for bfd abfd.  Return FALSE on error.  */
+
+static bfd_boolean
+_bfd_vms_write_ehdr (bfd *abfd)
+{
+  asymbol *symbol;
+  unsigned int symnum;
+  int had_case = 0;
+  int had_file = 0;
+  char version [256];
+  struct vms_rec_wr *recwr = &PRIV (recwr);
+
+  vms_debug2 ((2, "vms_write_ehdr (%p)\n", abfd));
+
+  _bfd_vms_output_alignment (recwr, 2);
+
+  /* EMH.  */
+  _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
+  _bfd_vms_output_short (recwr, EMH__C_MHD);
+  _bfd_vms_output_short (recwr, EOBJ__C_STRLVL);
+  _bfd_vms_output_long (recwr, 0);
+  _bfd_vms_output_long (recwr, 0);
+  _bfd_vms_output_long (recwr, MAX_OUTREC_SIZE);
+
+  /* Create module name from filename.  */
+  if (bfd_get_filename (abfd) != 0)
+    {
+      char *module = vms_get_module_name (bfd_get_filename (abfd), TRUE);
+      _bfd_vms_output_counted (recwr, module);
+      free (module);
+    }
+  else
+    _bfd_vms_output_counted (recwr, "NONAME");
+
+  _bfd_vms_output_counted (recwr, BFD_VERSION_STRING);
+  _bfd_vms_output_dump (recwr, get_vms_time_string (), EMH_DATE_LENGTH);
+  _bfd_vms_output_fill (recwr, 0, EMH_DATE_LENGTH);
+  _bfd_vms_output_end (abfd, recwr);
+
+  /* LMN.  */
+  _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
+  _bfd_vms_output_short (recwr, EMH__C_LNM);
+  snprintf (version, sizeof (version), "GAS BFD v%s", BFD_VERSION_STRING);
+  _bfd_vms_output_dump (recwr, (unsigned char *)version, strlen (version));
+  _bfd_vms_output_end (abfd, recwr);
+
+  /* SRC.  */
+  _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
+  _bfd_vms_output_short (recwr, EMH__C_SRC);
+
+  for (symnum = 0; symnum < abfd->symcount; symnum++)
+    {
+      symbol = abfd->outsymbols[symnum];
+
+      if (symbol->flags & BSF_FILE)
+	{
+	  if (CONST_STRNEQ ((char *)symbol->name, "<CASE:"))
+	    {
+	      PRIV (flag_hash_long_names) = symbol->name[6] - '0';
+	      PRIV (flag_show_after_trunc) = symbol->name[7] - '0';
+
+	      if (had_file)
+		break;
+	      had_case = 1;
+	      continue;
+	    }
+
+	  _bfd_vms_output_dump (recwr, (unsigned char *) symbol->name,
+				(int) strlen (symbol->name));
+	  if (had_case)
+	    break;
+	  had_file = 1;
+	}
+    }
+
+  if (symnum == abfd->symcount)
+    _bfd_vms_output_dump (recwr, (unsigned char *) STRING_COMMA_LEN ("noname"));
+
+  _bfd_vms_output_end (abfd, recwr);
+
+  /* TTL.  */
+  _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
+  _bfd_vms_output_short (recwr, EMH__C_TTL);
+  _bfd_vms_output_dump (recwr, (unsigned char *) STRING_COMMA_LEN ("TTL"));
+  _bfd_vms_output_end (abfd, recwr);
+
+  /* CPR.  */
+  _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
+  _bfd_vms_output_short (recwr, EMH__C_CPR);
+  _bfd_vms_output_dump (recwr,
+                        (unsigned char *)"GNU BFD ported by Klaus Kämpf 1994-1996",
+			 39);
+  _bfd_vms_output_end (abfd, recwr);
+
+  return TRUE;
+}
+
+/* Part 4.6, relocations.  */
+
+
+/* WRITE ETIR SECTION
+
+   This is still under construction and therefore not documented.  */
+
+/* Close the etir/etbt record.  */
+
+static void
+end_etir_record (bfd * abfd)
+{
+  struct vms_rec_wr *recwr = &PRIV (recwr);
+
+  _bfd_vms_output_end (abfd, recwr);
+}
+
+static void
+start_etir_or_etbt_record (bfd *abfd, asection *section, bfd_vma offset)
+{
+  struct vms_rec_wr *recwr = &PRIV (recwr);
+
+  if (section->name[0] == '.' && section->name[1] == 'v'
+      && !strcmp (section->name, ".vmsdebug"))
+    {
+      _bfd_vms_output_begin (recwr, EOBJ__C_ETBT);
+
+      if (offset == 0)
+        {
+          /* Push start offset.  */
+          _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_LW);
+          _bfd_vms_output_long (recwr, (unsigned long) 0);
+          _bfd_vms_output_end_subrec (recwr);
+
+          /* Set location.  */
+          _bfd_vms_output_begin_subrec (recwr, ETIR__C_CTL_DFLOC);
+          _bfd_vms_output_end_subrec (recwr);
+        }
+    }
+  else
+    {
+      _bfd_vms_output_begin (recwr, EOBJ__C_ETIR);
+
+      if (offset == 0)
+        {
+          /* Push start offset.  */
+          _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_PQ);
+          _bfd_vms_output_long (recwr, (unsigned long) section->index);
+          _bfd_vms_output_quad (recwr, offset);
+          _bfd_vms_output_end_subrec (recwr);
+
+          /* Start = pop ().  */
+          _bfd_vms_output_begin_subrec (recwr, ETIR__C_CTL_SETRB);
+          _bfd_vms_output_end_subrec (recwr);
+        }
+    }
+}
+
+/* Output a STO_IMM command for SSIZE bytes of data from CPR at virtual
+   address VADDR in section specified by SEC_INDEX and NAME.  */
+
+static void
+sto_imm (bfd *abfd, asection *section,
+         bfd_size_type ssize, unsigned char *cptr, bfd_vma vaddr)
+{
+  bfd_size_type size;
+  struct vms_rec_wr *recwr = &PRIV (recwr);
+
+#if VMS_DEBUG
+  _bfd_vms_debug (8, "sto_imm %d bytes\n", (int) ssize);
+  _bfd_hexdump (9, cptr, (int) ssize, (int) vaddr);
+#endif
+
+  while (ssize > 0)
+    {
+      /* Try all the rest.  */
+      size = ssize;
+
+      if (_bfd_vms_output_check (recwr, size) < 0)
+	{
+	  /* Doesn't fit, split !  */
+	  end_etir_record (abfd);
+
+          start_etir_or_etbt_record (abfd, section, vaddr);
+
+	  size = _bfd_vms_output_check (recwr, 0);	/* get max size */
+	  if (size > ssize)			/* more than what's left ? */
+	    size = ssize;
+	}
+
+      _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_IMM);
+      _bfd_vms_output_long (recwr, (unsigned long) (size));
+      _bfd_vms_output_dump (recwr, cptr, size);
+      _bfd_vms_output_end_subrec (recwr);
+
+#if VMS_DEBUG
+      _bfd_vms_debug (10, "dumped %d bytes\n", (int) size);
+      _bfd_hexdump (10, cptr, (int) size, (int) vaddr);
+#endif
+
+      vaddr += size;
+      cptr += size;
+      ssize -= size;
+    }
+}
+
+static void
+etir_output_check (bfd *abfd, asection *section, bfd_vma vaddr, int checklen)
+{
+  if (_bfd_vms_output_check (&PRIV (recwr), checklen) < 0)
+    {
+      /* Not enough room in this record.  Close it and open a new one.  */
+      end_etir_record (abfd);
+      start_etir_or_etbt_record (abfd, section, vaddr);
+    }
+}
+
+/* Return whether RELOC must be deferred till the end.  */
+
+static bfd_boolean
+defer_reloc_p (arelent *reloc)
+{
+  switch (reloc->howto->type)
+    {
+    case ALPHA_R_NOP:
+    case ALPHA_R_LDA:
+    case ALPHA_R_BSR:
+    case ALPHA_R_BOH:
+      return TRUE;
+
+    default:
+      return FALSE;
+    }
+}
+
+/* Write section contents for bfd abfd.  Return FALSE on error.  */
+
+static bfd_boolean
+_bfd_vms_write_etir (bfd * abfd, int objtype ATTRIBUTE_UNUSED)
+{
+  asection *section;
+  struct vms_rec_wr *recwr = &PRIV (recwr);
+
+  vms_debug2 ((2, "vms_write_tir (%p, %d)\n", abfd, objtype));
+
+  _bfd_vms_output_alignment (recwr, 4);
+
+  PRIV (vms_linkage_index) = 1;
+
+  for (section = abfd->sections; section; section = section->next)
+    {
+      vms_debug2 ((4, "writing %d. section '%s' (%d bytes)\n",
+                   section->index, section->name, (int) (section->size)));
+
+      if (!(section->flags & SEC_HAS_CONTENTS)
+	  || bfd_is_com_section (section))
+	continue;
+
+      if (!section->contents)
+	{
+	  bfd_set_error (bfd_error_no_contents);
+	  return FALSE;
+	}
+
+      start_etir_or_etbt_record (abfd, section, 0);
+
+      if (section->flags & SEC_RELOC)
+	{
+	  bfd_vma curr_addr = 0;
+	  unsigned char *curr_data = section->contents;
+	  bfd_size_type size;
+	  int pass2_needed = 0;
+	  int pass2_in_progress = 0;
+	  unsigned int irel;
+
+	  if (section->reloc_count <= 0)
+	    (*_bfd_error_handler)
+	      (_("SEC_RELOC with no relocs in section %s"), section->name);
+
+#if VMS_DEBUG
+	  else
+	    {
+	      int i = section->reloc_count;
+	      arelent **rptr = section->orelocation;
+	      _bfd_vms_debug (4, "%d relocations:\n", i);
+	      while (i-- > 0)
+		{
+		  _bfd_vms_debug (4, "sym %s in sec %s, value %08lx, "
+				     "addr %08lx, off %08lx, len %d: %s\n",
+				  (*(*rptr)->sym_ptr_ptr)->name,
+				  (*(*rptr)->sym_ptr_ptr)->section->name,
+				  (long) (*(*rptr)->sym_ptr_ptr)->value,
+				  (unsigned long)(*rptr)->address,
+                                  (unsigned long)(*rptr)->addend,
+				  bfd_get_reloc_size ((*rptr)->howto),
+                                  ( *rptr)->howto->name);
+		  rptr++;
+		}
+	    }
+#endif
+
+	new_pass:
+	  for (irel = 0; irel < section->reloc_count; irel++)
+	    {
+	      struct evax_private_udata_struct *udata;
+	      arelent *rptr = section->orelocation [irel];
+	      bfd_vma addr = rptr->address;
+	      asymbol *sym = *rptr->sym_ptr_ptr;
+	      asection *sec = sym->section;
+	      bfd_boolean defer = defer_reloc_p (rptr);
+	      unsigned int slen;
+	      char *hash;
+
+	      if (pass2_in_progress)
+		{
+		  /* Non-deferred relocs have already been output.  */
+		  if (!defer)
+		    continue;
+		}
+	      else
+		{
+		  /* Deferred relocs must be output at the very end.  */
+		  if (defer)
+		    {
+		      pass2_needed = 1;
+		      continue;
+		    }
+
+		  /* Regular relocs are intertwined with binary data.  */
+	          if (curr_addr > addr)
+		    (*_bfd_error_handler) (_("Size error in section %s"),
+					   section->name);
+		  size = addr - curr_addr;
+		  sto_imm (abfd, section, size, curr_data, curr_addr);
+		  curr_data += size;
+		  curr_addr += size;
+		}
+
+	      size = bfd_get_reloc_size (rptr->howto);
+
+	      switch (rptr->howto->type)
+	        {
+		case ALPHA_R_IGNORE:
+		  break;
+
+		case ALPHA_R_REFLONG:
+		  if (bfd_is_und_section (sym->section))
+		    {
+		      bfd_vma addend = rptr->addend;
+		      slen = strlen ((char *) sym->name);
+		      hash = _bfd_vms_length_hash_symbol
+                        (abfd, sym->name, EOBJ__C_SYMSIZ);
+		      etir_output_check (abfd, section, curr_addr, slen);
+		      if (addend)
+			{
+			  _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_GBL);
+			  _bfd_vms_output_counted (recwr, hash);
+			  _bfd_vms_output_end_subrec (recwr);
+			  _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_LW);
+			  _bfd_vms_output_long (recwr, (unsigned long) addend);
+			  _bfd_vms_output_end_subrec (recwr);
+			  _bfd_vms_output_begin_subrec (recwr, ETIR__C_OPR_ADD);
+			  _bfd_vms_output_end_subrec (recwr);
+			  _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_LW);
+			  _bfd_vms_output_end_subrec (recwr);
+			}
+		      else
+			{
+			  _bfd_vms_output_begin_subrec
+                            (recwr, ETIR__C_STO_GBL_LW);
+			  _bfd_vms_output_counted (recwr, hash);
+			  _bfd_vms_output_end_subrec (recwr);
+			}
+		    }
+		  else if (bfd_is_abs_section (sym->section))
+		    {
+		      etir_output_check (abfd, section, curr_addr, 16);
+		      _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_LW);
+		      _bfd_vms_output_long (recwr, (unsigned long) sym->value);
+		      _bfd_vms_output_end_subrec (recwr);
+		      _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_LW);
+		      _bfd_vms_output_end_subrec (recwr);
+		    }
+		  else
+		    {
+		      etir_output_check (abfd, section, curr_addr, 32);
+		      _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_PQ);
+		      _bfd_vms_output_long (recwr, (unsigned long) sec->index);
+		      _bfd_vms_output_quad (recwr, rptr->addend + sym->value);
+		      _bfd_vms_output_end_subrec (recwr);
+		      /* ??? Table B-8 of the OpenVMS Linker Utilily Manual
+			 says that we should have a ETIR__C_STO_OFF here.
+			 But the relocation would not be BFD_RELOC_32 then.
+			 This case is very likely unreachable.  */
+		      _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_LW);
+		      _bfd_vms_output_end_subrec (recwr);
+		    }
+		  break;
+
+		case ALPHA_R_REFQUAD:
+		  if (bfd_is_und_section (sym->section))
+		    {
+		      bfd_vma addend = rptr->addend;
+		      slen = strlen ((char *) sym->name);
+		      hash = _bfd_vms_length_hash_symbol
+                        (abfd, sym->name, EOBJ__C_SYMSIZ);
+		      etir_output_check (abfd, section, curr_addr, slen);
+		      if (addend)
+			{
+			  _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_GBL);
+			  _bfd_vms_output_counted (recwr, hash);
+			  _bfd_vms_output_end_subrec (recwr);
+			  _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_QW);
+			  _bfd_vms_output_quad (recwr, addend);
+			  _bfd_vms_output_end_subrec (recwr);
+			  _bfd_vms_output_begin_subrec (recwr, ETIR__C_OPR_ADD);
+			  _bfd_vms_output_end_subrec (recwr);
+			  _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_QW);
+			  _bfd_vms_output_end_subrec (recwr);
+			}
+		      else
+			{
+			  _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_GBL);
+			  _bfd_vms_output_counted (recwr, hash);
+			  _bfd_vms_output_end_subrec (recwr);
+			}
+		    }
+		  else if (bfd_is_abs_section (sym->section))
+		    {
+		      etir_output_check (abfd, section, curr_addr, 16);
+		      _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_QW);
+		      _bfd_vms_output_quad (recwr, sym->value);
+		      _bfd_vms_output_end_subrec (recwr);
+		      _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_QW);
+		      _bfd_vms_output_end_subrec (recwr);
+		    }
+		  else
+		    {
+		      etir_output_check (abfd, section, curr_addr, 32);
+		      _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_PQ);
+		      _bfd_vms_output_long (recwr, (unsigned long) sec->index);
+		      _bfd_vms_output_quad (recwr, rptr->addend + sym->value);
+		      _bfd_vms_output_end_subrec (recwr);
+		      _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_OFF);
+		      _bfd_vms_output_end_subrec (recwr);
+		    }
+		  break;
+
+		case ALPHA_R_HINT:
+		  sto_imm (abfd, section, size, curr_data, curr_addr);
+		  break;
+
+		case ALPHA_R_LINKAGE:
+		  etir_output_check (abfd, section, curr_addr, 64);
+		  _bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_LP_PSB);
+		  _bfd_vms_output_long
+		    (recwr, (unsigned long) PRIV (vms_linkage_index));
+		  PRIV (vms_linkage_index) += 2;
+		  hash = _bfd_vms_length_hash_symbol
+                    (abfd, sym->name, EOBJ__C_SYMSIZ);
+		  _bfd_vms_output_counted (recwr, hash);
+		  _bfd_vms_output_byte (recwr, 0);
+		  _bfd_vms_output_end_subrec (recwr);
+		  break;
+
+		case ALPHA_R_CODEADDR:
+		  slen = strlen ((char *) sym->name);
+		  hash = _bfd_vms_length_hash_symbol
+                    (abfd, sym->name, EOBJ__C_SYMSIZ);
+		  etir_output_check (abfd, section, curr_addr, slen);
+		  _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_CA);
+		  _bfd_vms_output_counted (recwr, hash);
+		  _bfd_vms_output_end_subrec (recwr);
+		  break;
+
+		case ALPHA_R_NOP:
+		  udata
+		    = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr;
+		  etir_output_check (abfd, section, curr_addr,
+				     32 + 1 + strlen (udata->origname));
+		  _bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_NOP_GBL);
+		  _bfd_vms_output_long (recwr, (unsigned long) udata->lkindex);
+		  _bfd_vms_output_long
+		    (recwr, (unsigned long) udata->enbsym->section->index);
+		  _bfd_vms_output_quad (recwr, rptr->address);
+		  _bfd_vms_output_long (recwr, (unsigned long) 0x47ff041f);
+		  _bfd_vms_output_long
+		    (recwr, (unsigned long) udata->enbsym->section->index);
+		  _bfd_vms_output_quad (recwr, rptr->addend);
+		  _bfd_vms_output_counted
+		    (recwr, _bfd_vms_length_hash_symbol
+                     (abfd, udata->origname, EOBJ__C_SYMSIZ));
+		  _bfd_vms_output_end_subrec (recwr);
+		  break;
+
+		case ALPHA_R_BSR:
+		  (*_bfd_error_handler) (_("Spurious ALPHA_R_BSR reloc"));
+		  break;
+
+		case ALPHA_R_LDA:
+		  udata
+		    = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr;
+		  etir_output_check (abfd, section, curr_addr,
+				     32 + 1 + strlen (udata->origname));
+		  _bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_LDA_GBL);
+		  _bfd_vms_output_long
+		    (recwr, (unsigned long) udata->lkindex + 1);
+		  _bfd_vms_output_long
+		    (recwr, (unsigned long) udata->enbsym->section->index);
+		  _bfd_vms_output_quad (recwr, rptr->address);
+		  _bfd_vms_output_long (recwr, (unsigned long) 0x237B0000);
+		  _bfd_vms_output_long
+		    (recwr, (unsigned long) udata->bsym->section->index);
+		  _bfd_vms_output_quad (recwr, rptr->addend);
+		  _bfd_vms_output_counted
+		    (recwr, _bfd_vms_length_hash_symbol
+                     (abfd, udata->origname, EOBJ__C_SYMSIZ));
+		  _bfd_vms_output_end_subrec (recwr);
+		  break;
+
+		case ALPHA_R_BOH:
+		  udata
+		    = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr;
+		  etir_output_check (abfd, section, curr_addr,
+				       32 + 1 + strlen (udata->origname));
+		  _bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_BOH_GBL);
+		  _bfd_vms_output_long (recwr, (unsigned long) udata->lkindex);
+		  _bfd_vms_output_long
+		    (recwr, (unsigned long) udata->enbsym->section->index);
+		  _bfd_vms_output_quad (recwr, rptr->address);
+		  _bfd_vms_output_long (recwr, (unsigned long) 0xD3400000);
+		  _bfd_vms_output_long
+		    (recwr, (unsigned long) udata->enbsym->section->index);
+		  _bfd_vms_output_quad (recwr, rptr->addend);
+		  _bfd_vms_output_counted
+		    (recwr, _bfd_vms_length_hash_symbol
+                     (abfd, udata->origname, EOBJ__C_SYMSIZ));
+		  _bfd_vms_output_end_subrec (recwr);
+		  break;
+
+		default:
+		  (*_bfd_error_handler) (_("Unhandled relocation %s"),
+		  			 rptr->howto->name);
+		  break;
+		}
+
+	      curr_data += size;
+	      curr_addr += size;
+	    } /* End of relocs loop.  */
+
+	  if (!pass2_in_progress)
+	    {
+	      /* Output rest of section.  */
+	      if (curr_addr > section->size)
+		(*_bfd_error_handler) (_("Size error in section %s"),
+				       section->name);
+	      size = section->size - curr_addr;
+	      sto_imm (abfd, section, size, curr_data, curr_addr);
+	      curr_data += size;
+	      curr_addr += size;
+
+	      if (pass2_needed)
+		{
+		  pass2_in_progress = 1;
+		  goto new_pass;
+		}
+	    }
+	}
+
+      else /* (section->flags & SEC_RELOC) */
+	sto_imm (abfd, section, section->size, section->contents, 0);
+
+      end_etir_record (abfd);
+    }
+
+  _bfd_vms_output_alignment (recwr, 2);
+  return TRUE;
+}
+
+/* Write eom record for bfd abfd.  Return FALSE on error.  */
+
+static bfd_boolean
+_bfd_vms_write_eeom (bfd *abfd)
+{
+  struct vms_rec_wr *recwr = &PRIV (recwr);
+
+  vms_debug2 ((2, "vms_write_eeom\n"));
+
+  _bfd_vms_output_begin (recwr, EOBJ__C_EEOM);
+  _bfd_vms_output_long (recwr, (unsigned long) (PRIV (vms_linkage_index) >> 1));
+  _bfd_vms_output_byte (recwr, 0);	/* Completion code.  */
+  _bfd_vms_output_byte (recwr, 0);	/* Fill byte.  */
+
+  if (bfd_get_start_address (abfd) != (bfd_vma)-1)
+    {
+      asection *section;
+
+      section = bfd_get_section_by_name (abfd, ".link");
+      if (section == 0)
+	{
+	  bfd_set_error (bfd_error_nonrepresentable_section);
+	  return FALSE;
+	}
+      _bfd_vms_output_short (recwr, 0);
+      _bfd_vms_output_long (recwr, (unsigned long) (section->index));
+      _bfd_vms_output_long (recwr,
+			     (unsigned long) bfd_get_start_address (abfd));
+      _bfd_vms_output_long (recwr, 0);
+    }
+
+  _bfd_vms_output_end (abfd, recwr);
+  return TRUE;
+}
+
+/* Write cached information into a file being written, at bfd_close.  */
+
+static bfd_boolean
+alpha_vms_write_object_contents (bfd *abfd)
+{
+  vms_debug2 ((1, "vms_write_object_contents (%p)\n", abfd));
+
+  if (abfd->flags & (EXEC_P | DYNAMIC))
+    {
+      return alpha_vms_write_exec (abfd);
+    }
+  else
+    {
+      if (abfd->section_count > 0)			/* we have sections */
+        {
+          if (_bfd_vms_write_ehdr (abfd) != TRUE)
+            return FALSE;
+          if (_bfd_vms_write_egsd (abfd) != TRUE)
+            return FALSE;
+          if (_bfd_vms_write_etir (abfd, EOBJ__C_ETIR) != TRUE)
+            return FALSE;
+          if (_bfd_vms_write_eeom (abfd) != TRUE)
+            return FALSE;
+        }
+    }
+  return TRUE;
+}
+
+/* Debug stuff: nearest line.  */
+
+#define SET_MODULE_PARSED(m) \
+  do { if ((m)->name == NULL) (m)->name = ""; } while (0)
+#define IS_MODULE_PARSED(m) ((m)->name != NULL)
+
+/* Build a new module for the specified BFD.  */
+
+static struct module *
+new_module (bfd *abfd)
+{
+  struct module *module
+    = (struct module *) bfd_zalloc (abfd, sizeof (struct module));
+  module->file_table_count = 16; /* Arbitrary.  */
+  module->file_table
+    = bfd_malloc (module->file_table_count * sizeof (struct fileinfo));
+  return module;
+}
+
+/* Parse debug info for a module and internalize it.  */
+
+static void
+parse_module (bfd *abfd, struct module *module, unsigned char *ptr,
+	      int length)
+{
+  unsigned char *maxptr = ptr + length;
+  unsigned char *src_ptr, *pcl_ptr;
+  unsigned int prev_linum = 0, curr_linenum = 0;
+  bfd_vma prev_pc = 0, curr_pc = 0;
+  struct srecinfo *curr_srec, *srec;
+  struct lineinfo *curr_line, *line;
+  struct funcinfo *funcinfo;
+
+  /* Initialize tables with zero element.  */
+  curr_srec = (struct srecinfo *) bfd_zalloc (abfd, sizeof (struct srecinfo));
+  module->srec_table = curr_srec;
+
+  curr_line = (struct lineinfo *) bfd_zalloc (abfd, sizeof (struct lineinfo));
+  module->line_table = curr_line;
+
+  while (length == -1 || ptr < maxptr)
+    {
+      /* The first byte is not counted in the recorded length.  */
+      int rec_length = bfd_getl16 (ptr) + 1;
+      int rec_type = bfd_getl16 (ptr + 2);
+
+      vms_debug2 ((2, "DST record: leng %d, type %d\n", rec_length, rec_type));
+
+      if (length == -1 && rec_type == DST__K_MODEND)
+        break;
+
+      switch (rec_type)
+	{
+	case DST__K_MODBEG:
+	  module->name
+	    = _bfd_vms_save_counted_string (ptr + DST_S_B_MODBEG_NAME);
+
+	  curr_pc = 0;
+	  prev_pc = 0;
+	  curr_linenum = 0;
+	  prev_linum = 0;
+
+          vms_debug2 ((3, "module: %s\n", module->name));
+	  break;
+
+	case DST__K_MODEND:
+	  break;
+
+	case DST__K_RTNBEG:
+	  funcinfo = (struct funcinfo *)
+	    bfd_zalloc (abfd, sizeof (struct funcinfo));
+          funcinfo->name
+	    = _bfd_vms_save_counted_string (ptr + DST_S_B_RTNBEG_NAME);
+	  funcinfo->low = bfd_getl32 (ptr + DST_S_L_RTNBEG_ADDRESS);
+	  funcinfo->next = module->func_table;
+	  module->func_table = funcinfo;
+
+          vms_debug2 ((3, "routine: %s at 0x%lx\n",
+                       funcinfo->name, (unsigned long) funcinfo->low));
+	  break;
+
+	case DST__K_RTNEND:
+	  module->func_table->high = module->func_table->low
+	    + bfd_getl32 (ptr + DST_S_L_RTNEND_SIZE) - 1;
+
+	  if (module->func_table->high > module->high)
+	    module->high = module->func_table->high;
+
+          vms_debug2 ((3, "end routine\n"));
+	  break;
+
+	case DST__K_PROLOG:
+          vms_debug2 ((3, "prologue\n"));
+	  break;
+
+	case DST__K_EPILOG:
+          vms_debug2 ((3, "epilog\n"));
+	  break;
+
+	case DST__K_BLKBEG:
+          vms_debug2 ((3, "block\n"));
+	  break;
+
+	case DST__K_BLKEND:
+          vms_debug2 ((3, "end block\n"));
+	  break;
+
+	case DST__K_SOURCE:
+	  src_ptr = ptr + DST_S_C_SOURCE_HEADER_SIZE;
+
+	  vms_debug2 ((3, "source info\n"));
+
+	  while (src_ptr < ptr + rec_length)
+	    {
+	      int cmd = src_ptr[0], cmd_length, data;
+
+	      switch (cmd)
+		{
+		case DST__K_SRC_DECLFILE:
+		  {
+		    unsigned int fileid
+		      = bfd_getl16 (src_ptr + DST_S_W_SRC_DF_FILEID);
+		    char *filename
+		      = _bfd_vms_save_counted_string (src_ptr
+			  + DST_S_B_SRC_DF_FILENAME);
+
+		    while (fileid >= module->file_table_count)
+		      {
+			module->file_table_count *= 2;
+			module->file_table
+			  = bfd_realloc (module->file_table,
+					 module->file_table_count
+					   * sizeof (struct fileinfo));
+		      }
+
+		    module->file_table [fileid].name = filename;
+		    module->file_table [fileid].srec = 1;
+		    cmd_length = src_ptr[DST_S_B_SRC_DF_LENGTH] + 2;
+		    vms_debug2 ((4, "DST_S_C_SRC_DECLFILE: %d, %s\n",
+                                 fileid, module->file_table [fileid].name));
+		  }
+		  break;
+
+		case DST__K_SRC_DEFLINES_B:
+		  /* Perform the association and set the next higher index
+		     to the limit.  */
+		  data = src_ptr[DST_S_B_SRC_UNSBYTE];
+		  srec = (struct srecinfo *)
+		    bfd_zalloc (abfd, sizeof (struct srecinfo));
+		  srec->line = curr_srec->line + data;
+		  srec->srec = curr_srec->srec + data;
+		  srec->sfile = curr_srec->sfile;
+		  curr_srec->next = srec;
+		  curr_srec = srec;
+		  cmd_length = 2;
+		  vms_debug2 ((4, "DST_S_C_SRC_DEFLINES_B: %d\n", data));
+		  break;
+
+		case DST__K_SRC_DEFLINES_W:
+		  /* Perform the association and set the next higher index
+		     to the limit.  */
+		  data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
+		  srec = (struct srecinfo *)
+		    bfd_zalloc (abfd, sizeof (struct srecinfo));
+		  srec->line = curr_srec->line + data;
+		  srec->srec = curr_srec->srec + data,
+		  srec->sfile = curr_srec->sfile;
+		  curr_srec->next = srec;
+		  curr_srec = srec;
+		  cmd_length = 3;
+		  vms_debug2 ((4, "DST_S_C_SRC_DEFLINES_W: %d\n", data));
+		  break;
+
+		case DST__K_SRC_INCRLNUM_B:
+		  data = src_ptr[DST_S_B_SRC_UNSBYTE];
+		  curr_srec->line += data;
+		  cmd_length = 2;
+		  vms_debug2 ((4, "DST_S_C_SRC_INCRLNUM_B: %d\n", data));
+		  break;
+
+		case DST__K_SRC_SETFILE:
+		  data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
+		  curr_srec->sfile = data;
+		  curr_srec->srec = module->file_table[data].srec;
+		  cmd_length = 3;
+		  vms_debug2 ((4, "DST_S_C_SRC_SETFILE: %d\n", data));
+		  break;
+
+		case DST__K_SRC_SETLNUM_L:
+		  data = bfd_getl32 (src_ptr + DST_S_L_SRC_UNSLONG);
+		  curr_srec->line = data;
+		  cmd_length = 5;
+		  vms_debug2 ((4, "DST_S_C_SRC_SETLNUM_L: %d\n", data));
+		  break;
+
+		case DST__K_SRC_SETLNUM_W:
+		  data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
+		  curr_srec->line = data;
+		  cmd_length = 3;
+		  vms_debug2 ((4, "DST_S_C_SRC_SETLNUM_W: %d\n", data));
+		  break;
+
+		case DST__K_SRC_SETREC_L:
+		  data = bfd_getl32 (src_ptr + DST_S_L_SRC_UNSLONG);
+		  curr_srec->srec = data;
+		  module->file_table[curr_srec->sfile].srec = data;
+		  cmd_length = 5;
+		  vms_debug2 ((4, "DST_S_C_SRC_SETREC_L: %d\n", data));
+		  break;
+
+		case DST__K_SRC_SETREC_W:
+		  data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
+		  curr_srec->srec = data;
+		  module->file_table[curr_srec->sfile].srec = data;
+		  cmd_length = 3;
+		  vms_debug2 ((4, "DST_S_C_SRC_SETREC_W: %d\n", data));
+		  break;
+
+		case DST__K_SRC_FORMFEED:
+		  cmd_length = 1;
+		  vms_debug2 ((4, "DST_S_C_SRC_FORMFEED\n"));
+		  break;
+
+		default:
+		  (*_bfd_error_handler) (_("unknown source command %d"),
+					 cmd);
+		  cmd_length = 2;
+		  break;
+		}
+
+	      src_ptr += cmd_length;
+	    }
+	  break;
+
+	case DST__K_LINE_NUM:
+	  pcl_ptr = ptr + DST_S_C_LINE_NUM_HEADER_SIZE;
+
+	  vms_debug2 ((3, "line info\n"));
+
+	  while (pcl_ptr < ptr + rec_length)
+	    {
+	      /* The command byte is signed so we must sign-extend it.  */
+	      int cmd = ((signed char *)pcl_ptr)[0], cmd_length, data;
+
+	      switch (cmd)
+		{
+		case DST__K_DELTA_PC_W:
+		  data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
+		  curr_pc += data;
+		  curr_linenum += 1;
+		  cmd_length = 3;
+		  vms_debug2 ((4, "DST__K_DELTA_PC_W: %d\n", data));
+		  break;
+
+		case DST__K_DELTA_PC_L:
+		  data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
+		  curr_pc += data;
+		  curr_linenum += 1;
+		  cmd_length = 5;
+		  vms_debug2 ((4, "DST__K_DELTA_PC_L: %d\n", data));
+		  break;
+
+		case DST__K_INCR_LINUM:
+		  data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
+		  curr_linenum += data;
+		  cmd_length = 2;
+		  vms_debug2 ((4, "DST__K_INCR_LINUM: %d\n", data));
+		  break;
+
+		case DST__K_INCR_LINUM_W:
+		  data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
+		  curr_linenum += data;
+		  cmd_length = 3;
+		  vms_debug2 ((4, "DST__K_INCR_LINUM_W: %d\n", data));
+		  break;
+
+		case DST__K_INCR_LINUM_L:
+		  data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
+		  curr_linenum += data;
+		  cmd_length = 5;
+		  vms_debug2 ((4, "DST__K_INCR_LINUM_L: %d\n", data));
+		  break;
+
+		case DST__K_SET_LINUM_INCR:
+		  (*_bfd_error_handler)
+		    (_("DST__K_SET_LINUM_INCR not implemented"));
+		  cmd_length = 2;
+		  break;
+
+		case DST__K_SET_LINUM_INCR_W:
+		  (*_bfd_error_handler)
+		    (_("DST__K_SET_LINUM_INCR_W not implemented"));
+		  cmd_length = 3;
+		  break;
+
+		case DST__K_RESET_LINUM_INCR:
+		  (*_bfd_error_handler)
+		    (_("DST__K_RESET_LINUM_INCR not implemented"));
+		  cmd_length = 1;
+		  break;
+
+		case DST__K_BEG_STMT_MODE:
+		  (*_bfd_error_handler)
+		    (_("DST__K_BEG_STMT_MODE not implemented"));
+		  cmd_length = 1;
+		  break;
+
+		case DST__K_END_STMT_MODE:
+		  (*_bfd_error_handler)
+		    (_("DST__K_END_STMT_MODE not implemented"));
+		  cmd_length = 1;
+		  break;
+
+		case DST__K_SET_LINUM_B:
+		  data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
+		  curr_linenum = data;
+		  cmd_length = 2;
+		  vms_debug2 ((4, "DST__K_SET_LINUM_B: %d\n", data));
+		  break;
+
+		case DST__K_SET_LINUM:
+		  data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
+		  curr_linenum = data;
+		  cmd_length = 3;
+		  vms_debug2 ((4, "DST__K_SET_LINE_NUM: %d\n", data));
+		  break;
+
+		case DST__K_SET_LINUM_L:
+		  data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
+		  curr_linenum = data;
+		  cmd_length = 5;
+		  vms_debug2 ((4, "DST__K_SET_LINUM_L: %d\n", data));
+		  break;
+
+		case DST__K_SET_PC:
+		  (*_bfd_error_handler)
+		    (_("DST__K_SET_PC not implemented"));
+		  cmd_length = 2;
+		  break;
+
+		case DST__K_SET_PC_W:
+		  (*_bfd_error_handler)
+		    (_("DST__K_SET_PC_W not implemented"));
+		  cmd_length = 3;
+		  break;
+
+		case DST__K_SET_PC_L:
+		  (*_bfd_error_handler)
+		    (_("DST__K_SET_PC_L not implemented"));
+		  cmd_length = 5;
+		  break;
+
+		case DST__K_SET_STMTNUM:
+		  (*_bfd_error_handler)
+		    (_("DST__K_SET_STMTNUM not implemented"));
+		  cmd_length = 2;
+		  break;
+
+		case DST__K_TERM:
+		  data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
+		  curr_pc += data;
+		  cmd_length = 2;
+		  vms_debug2 ((4, "DST__K_TERM: %d\n", data));
+		  break;
+
+		case DST__K_TERM_W:
+		  data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
+		  curr_pc += data;
+		  cmd_length = 3;
+		  vms_debug2 ((4, "DST__K_TERM_W: %d\n", data));
+		  break;
+
+		case DST__K_TERM_L:
+		  data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
+		  curr_pc += data;
+		  cmd_length = 5;
+		  vms_debug2 ((4, "DST__K_TERM_L: %d\n", data));
+		  break;
+
+		case DST__K_SET_ABS_PC:
+		  data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
+		  curr_pc = data;
+		  cmd_length = 5;
+		  vms_debug2 ((4, "DST__K_SET_ABS_PC: 0x%x\n", data));
+		  break;
+
+		default:
+		  if (cmd <= 0)
+		    {
+		      curr_pc -= cmd;
+		      curr_linenum += 1;
+		      cmd_length = 1;
+		      vms_debug2 ((4, "bump pc to 0x%lx and line to %d\n",
+                                   (unsigned long)curr_pc, curr_linenum));
+		    }
+		  else
+		    {
+		      (*_bfd_error_handler) (_("unknown line command %d"),
+					     cmd);
+		      cmd_length = 2;
+		    }
+		  break;
+		}
+
+	      if ((curr_linenum != prev_linum && curr_pc != prev_pc)
+		  || cmd <= 0
+		  || cmd == DST__K_DELTA_PC_L
+		  || cmd == DST__K_DELTA_PC_W)
+		{
+		  line = (struct lineinfo *)
+		    bfd_zalloc (abfd, sizeof (struct lineinfo));
+		  line->address = curr_pc;
+		  line->line = curr_linenum;
+
+		  curr_line->next = line;
+		  curr_line = line;
+
+		  prev_linum = curr_linenum;
+		  prev_pc = curr_pc;
+		  vms_debug2 ((4, "-> correlate pc 0x%lx with line %d\n",
+                               (unsigned long)curr_pc, curr_linenum));
+		}
+
+	      pcl_ptr += cmd_length;
+	    }
+	  break;
+
+	case 0x17: /* Undocumented type used by DEC C to declare equates.  */
+	  vms_debug2 ((3, "undocumented type 0x17\n"));
+	  break;
+
+	default:
+	  vms_debug2 ((3, "ignoring record\n"));
+	  break;
+
+	}
+
+      ptr += rec_length;
+    }
+
+  /* Finalize tables with EOL marker.  */
+  srec = (struct srecinfo *) bfd_zalloc (abfd, sizeof (struct srecinfo));
+  srec->line = (unsigned int) -1;
+  srec->srec = (unsigned int) -1;
+  curr_srec->next = srec;
+
+  line = (struct lineinfo *) bfd_zalloc (abfd, sizeof (struct lineinfo));
+  line->line = (unsigned int) -1;
+  line->address = (bfd_vma) -1;
+  curr_line->next = line;
+
+  /* Advertise that this module has been parsed.  This is needed
+     because parsing can be either performed at module creation
+     or deferred until debug info is consumed.  */
+  SET_MODULE_PARSED (module);
+}
+
+/* Build the list of modules for the specified BFD.  */
+
+static struct module *
+build_module_list (bfd *abfd)
+{
+  struct module *module, *list = NULL;
+  asection *dmt;
+
+  if ((dmt = bfd_get_section_by_name (abfd, "$DMT$")))
+    {
+      /* We have a DMT section so this must be an image.  Parse the
+	 section and build the list of modules.  This is sufficient
+	 since we can compute the start address and the end address
+	 of every module from the section contents.  */
+      bfd_size_type size = bfd_get_section_size (dmt);
+      unsigned char *ptr, *end;
+
+      ptr = (unsigned char *) bfd_alloc (abfd, size);
+      if (! ptr)
+	return NULL;
+
+      if (! bfd_get_section_contents (abfd, dmt, ptr, 0, size))
+	return NULL;
+
+      vms_debug2 ((2, "DMT\n"));
+
+      end = ptr + size;
+
+      while (ptr < end)
+	{
+	  /* Each header declares a module with its start offset and size
+	     of debug info in the DST section, as well as the count of
+	     program sections (i.e. address spans) it contains.  */
+	  int modbeg = bfd_getl32 (ptr + DBG_S_L_DMT_MODBEG);
+	  int msize = bfd_getl32 (ptr + DBG_S_L_DST_SIZE);
+	  int count = bfd_getl16 (ptr + DBG_S_W_DMT_PSECT_COUNT);
+	  ptr += DBG_S_C_DMT_HEADER_SIZE;
+
+	  vms_debug2 ((3, "module: modbeg = %d, size = %d, count = %d\n",
+                       modbeg, msize, count));
+
+	  /* We create a 'module' structure for each program section since
+	     we only support contiguous addresses in a 'module' structure.
+	     As a consequence, the actual debug info in the DST section is
+	     shared and can be parsed multiple times; that doesn't seem to
+	     cause problems in practice.  */
+	  while (count-- > 0)
+	    {
+	      int start = bfd_getl32 (ptr + DBG_S_L_DMT_PSECT_START);
+	      int length = bfd_getl32 (ptr + DBG_S_L_DMT_PSECT_LENGTH);
+	      module = new_module (abfd);
+	      module->modbeg = modbeg;
+	      module->size = msize;
+	      module->low = start;
+	      module->high = start + length;
+	      module->next = list;
+	      list = module;
+	      ptr += DBG_S_C_DMT_PSECT_SIZE;
+
+	      vms_debug2 ((4, "section: start = 0x%x, length = %d\n",
+                           start, length));
+	    }
+	}
+    }
+  else
+    {
+      /* We don't have a DMT section so this must be an object.  Parse
+	 the module right now in order to compute its start address and
+	 end address.  */
+      module = new_module (abfd);
+      parse_module (abfd, module, PRIV (dst_section)->contents, -1);
+      list = module;
+    }
+
+  return list;
+}
+
+/* Calculate and return the name of the source file and the line nearest
+   to the wanted location in the specified module.  */
+
+static bfd_boolean
+module_find_nearest_line (bfd *abfd, struct module *module, bfd_vma addr,
+			  const char **file, const char **func,
+			  unsigned int *line)
+{
+  struct funcinfo *funcinfo;
+  struct lineinfo *lineinfo;
+  struct srecinfo *srecinfo;
+  bfd_boolean ret = FALSE;
+
+  /* Parse this module if that was not done at module creation.  */
+  if (! IS_MODULE_PARSED (module))
+    {
+      unsigned int size = module->size;
+      unsigned int modbeg = PRIV (dst_section)->filepos + module->modbeg;
+      unsigned char *buffer = (unsigned char *) bfd_malloc (module->size);
+
+      if (bfd_seek (abfd, modbeg, SEEK_SET) != 0
+	  || bfd_bread (buffer, size, abfd) != size)
+	{
+	  bfd_set_error (bfd_error_no_debug_section);
+	  return FALSE;
+	}
+
+      parse_module (abfd, module, buffer, size);
+      free (buffer);
+    }
+
+  /* Find out the function (if any) that contains the address.  */
+  for (funcinfo = module->func_table; funcinfo; funcinfo = funcinfo->next)
+    if (addr >= funcinfo->low && addr <= funcinfo->high)
+      {
+        *func = funcinfo->name;
+	ret = TRUE;
+	break;
+      }
+
+  /* Find out the source file and the line nearest to the address.  */
+  for (lineinfo = module->line_table; lineinfo; lineinfo = lineinfo->next)
+    if (lineinfo->next && addr < lineinfo->next->address)
+      {
+	for (srecinfo = module->srec_table; srecinfo; srecinfo = srecinfo->next)
+	  if (srecinfo->next && lineinfo->line < srecinfo->next->line)
+	    {
+	      if (srecinfo->sfile > 0)
+		{
+		  *file = module->file_table[srecinfo->sfile].name;
+		  *line = srecinfo->srec + lineinfo->line - srecinfo->line;
+		}
+	      else
+		{
+		  *file = module->name;
+		  *line = lineinfo->line;
+		}
+	      return TRUE;
+	    }
+
+	break;
+      }
+
+  return ret;
+}
+
+/* Provided a BFD, a section and an offset into the section, calculate and
+   return the name of the source file and the line nearest to the wanted
+   location.  */
+
+static bfd_boolean
+_bfd_vms_find_nearest_dst_line (bfd *abfd, asection *section,
+				asymbol **symbols ATTRIBUTE_UNUSED,
+				bfd_vma offset, const char **file,
+				const char **func, unsigned int *line)
+{
+  struct module *module;
+
+  /* What address are we looking for?  */
+  bfd_vma addr = section->vma + offset;
+
+  *file = NULL;
+  *func = NULL;
+  *line = 0;
+
+  if (PRIV (dst_section) == NULL || !(abfd->flags & (EXEC_P | DYNAMIC)))
+    return FALSE;
+
+  if (PRIV (modules) == NULL)
+    {
+      PRIV (modules) = build_module_list (abfd);
+      if (PRIV (modules) == NULL)
+        return FALSE;
+    }
+
+  for (module = PRIV (modules); module; module = module->next)
+    if (addr >= module->low && addr <= module->high)
+      return module_find_nearest_line (abfd, module, addr, file, func, line);
+
+  return FALSE;
+}
+
+/* Canonicalizations.  */
+/* Set name, value, section and flags of SYM from E.  */
+
+static bfd_boolean
+alpha_vms_convert_symbol (bfd *abfd, struct vms_symbol_entry *e, asymbol *sym)
+{
+  flagword flags;
+  symvalue value;
+  asection *sec;
+  const char *name;
+
+  name = e->name;
+  value = 0;
+  flags = BSF_NO_FLAGS;
+  sec = NULL;
+
+  switch (e->typ)
+    {
+    case EGSD__C_SYM:
+      if (e->flags & EGSY__V_WEAK)
+        flags |= BSF_WEAK;
+
+      if (e->flags & EGSY__V_DEF)
+        {
+          /* Symbol definition.  */
+          flags |= BSF_GLOBAL;
+          if (e->flags & EGSY__V_NORM)
+            flags |= BSF_FUNCTION;
+          value = e->value;
+          sec = PRIV (sections)[e->section];
+        }
+      else
+        {
+          /* Symbol reference.  */
+          sec = bfd_und_section_ptr;
+        }
+      break;
+
+    case EGSD__C_SYMG:
+      /* A universal symbol is by definition global...  */
+      flags |= BSF_GLOBAL;
+
+      /* ...and dynamic in shared libraries.  */
+      if (abfd->flags & DYNAMIC)
+        flags |= BSF_DYNAMIC;
+
+      if (e->flags & EGSY__V_WEAK)
+        flags |= BSF_WEAK;
+
+      if (!(e->flags & EGSY__V_DEF))
+        abort ();
+
+      if (e->flags & EGSY__V_NORM)
+        flags |= BSF_FUNCTION;
+
+      value = e->symbol_vector;
+
+      /* Adding this offset is necessary in order for GDB to
+         read the DWARF-2 debug info from shared libraries.  */
+      if ((abfd->flags & DYNAMIC) && strstr (name, "$DWARF2.DEBUG") != 0)
+        value += PRIV (symvva);
+
+      sec = bfd_abs_section_ptr;
+#if 0
+      /* Find containing section.  */
+      {
+        bfd_vma sbase = 0;
+        asection *s;
+
+        for (s = abfd->sections; s; s = s->next)
+          {
+            if (value >= s->vma
+                && s->vma > sbase
+                && !(s->flags & SEC_COFF_SHARED_LIBRARY)
+                && (s->size > 0 || !(e->flags & EGSY__V_REL)))
+              {
+                sbase = s->vma;
+                sec = s;
+              }
+          }
+        value -= sbase;
+      }
+#endif
+
+      break;
+
+    default:
+      return FALSE;
+    }
+
+  sym->name = name;
+  sym->section = sec;
+  sym->flags = flags;
+  sym->value = value;
+  return TRUE;
+}
+
+
+/* Return the number of bytes required to store a vector of pointers
+   to asymbols for all the symbols in the BFD abfd, including a
+   terminal NULL pointer. If there are no symbols in the BFD,
+   then return 0.  If an error occurs, return -1.  */
+
+static long
+alpha_vms_get_symtab_upper_bound (bfd *abfd)
+{
+  vms_debug2 ((1, "alpha_vms_get_symtab_upper_bound (%p), %d symbols\n",
+               abfd, PRIV (gsd_sym_count)));
+
+  return (PRIV (gsd_sym_count) + 1) * sizeof (asymbol *);
+}
+
+/* Read the symbols from the BFD abfd, and fills in the vector
+   location with pointers to the symbols and a trailing NULL.
+
+   Return number of symbols read.   */
+
+static long
+alpha_vms_canonicalize_symtab (bfd *abfd, asymbol **symbols)
+{
+  unsigned int i;
+
+  vms_debug2 ((1, "alpha_vms_canonicalize_symtab (%p, <ret>)\n", abfd));
+
+  if (PRIV (csymbols) == NULL)
+    {
+      PRIV (csymbols) = (asymbol **) bfd_alloc
+        (abfd, PRIV (gsd_sym_count) * sizeof (asymbol *));
+
+      /* Traverse table and fill symbols vector.  */
+      for (i = 0; i < PRIV (gsd_sym_count); i++)
+        {
+          struct vms_symbol_entry *e = PRIV (syms)[i];
+          asymbol *sym;
+
+          sym = bfd_make_empty_symbol (abfd);
+          if (sym == NULL || !alpha_vms_convert_symbol (abfd, e, sym))
+            {
+              bfd_release (abfd, PRIV (csymbols));
+              PRIV (csymbols) = NULL;
+              return -1;
+            }
+
+          PRIV (csymbols)[i] = sym;
+        }
+    }
+
+  if (symbols != NULL)
+    {
+      for (i = 0; i < PRIV (gsd_sym_count); i++)
+        symbols[i] = PRIV (csymbols)[i];
+      symbols[i] = NULL;
+    }
+
+  return PRIV (gsd_sym_count);
+}
+
+/* Read and convert relocations from ETIR.  We do it once for all sections.  */
+
+static bfd_boolean
+alpha_vms_slurp_relocs (bfd *abfd)
+{
+  int cur_psect = -1;
+
+  vms_debug2 ((3, "alpha_vms_slurp_relocs\n"));
+
+  /* We slurp relocs only once, for all sections.  */
+  if (PRIV (reloc_done))
+      return TRUE;
+  PRIV (reloc_done) = TRUE;
+
+  if (alpha_vms_canonicalize_symtab (abfd, NULL) < 0)
+    return FALSE;
+
+  if (bfd_seek (abfd, 0, SEEK_SET) != 0)
+    return FALSE;
+
+  while (1)
+    {
+      unsigned char *begin;
+      unsigned char *end;
+      unsigned char *ptr;
+      bfd_reloc_code_real_type reloc_code;
+      int type;
+      bfd_vma vaddr = 0;
+
+      int length;
+
+      bfd_vma cur_address;
+      int cur_psidx = -1;
+      unsigned char *cur_sym = NULL;
+      int prev_cmd = -1;
+      bfd_vma cur_addend = 0;
+
+      /* Skip non-ETIR records.  */
+      type = _bfd_vms_get_object_record (abfd);
+      if (type == EOBJ__C_EEOM)
+        break;
+      if (type != EOBJ__C_ETIR)
+        continue;
+
+      begin = PRIV (recrd.rec) + 4;
+      end = PRIV (recrd.rec) + PRIV (recrd.rec_size);
+
+      for (ptr = begin; ptr < end; ptr += length)
+        {
+          int cmd;
+
+          cmd = bfd_getl16 (ptr);
+          length = bfd_getl16 (ptr + 2);
+
+          cur_address = vaddr;
+
+          vms_debug2 ((4, "alpha_vms_slurp_relocs: etir %s\n",
+                       _bfd_vms_etir_name (cmd)));
+
+          switch (cmd)
+            {
+            case ETIR__C_STA_GBL: /* ALPHA_R_REFLONG und_section, step 1 */
+                                  /* ALPHA_R_REFQUAD und_section, step 1 */
+              cur_sym = ptr + 4;
+              prev_cmd = cmd;
+              continue;
+
+            case ETIR__C_STA_PQ: /* ALPHA_R_REF{LONG|QUAD}, others part 1 */
+              cur_psidx = bfd_getl32 (ptr + 4);
+              cur_addend = bfd_getl64 (ptr + 8);
+              prev_cmd = cmd;
+              continue;
+
+            case ETIR__C_CTL_SETRB:
+              if (prev_cmd != ETIR__C_STA_PQ)
+                {
+                  (*_bfd_error_handler)
+                    (_("Unknown reloc %s + %s"), _bfd_vms_etir_name (prev_cmd),
+                     _bfd_vms_etir_name (cmd));
+                  return FALSE;
+                }
+              cur_psect = cur_psidx;
+              vaddr = cur_addend;
+              cur_psidx = -1;
+              cur_addend = 0;
+              continue;
+
+            case ETIR__C_STA_LW: /* ALPHA_R_REFLONG abs_section, step 1 */
+                                 /* ALPHA_R_REFLONG und_section, step 2 */
+              if (prev_cmd != -1)
+                {
+                  if (prev_cmd != ETIR__C_STA_GBL)
+                    {
+                      (*_bfd_error_handler)
+                        (_("Unknown reloc %s + %s"), _bfd_vms_etir_name (cmd),
+                         _bfd_vms_etir_name (ETIR__C_STA_LW));
+                      return FALSE;
+                    }
+                }
+              cur_addend = bfd_getl32 (ptr + 4);
+              prev_cmd = cmd;
+              continue;
+
+            case ETIR__C_STA_QW: /* ALPHA_R_REFQUAD abs_section, step 1 */
+			         /* ALPHA_R_REFQUAD und_section, step 2 */
+              if (prev_cmd != -1 && prev_cmd != ETIR__C_STA_GBL)
+                {
+                  (*_bfd_error_handler)
+                    (_("Unknown reloc %s + %s"), _bfd_vms_etir_name (cmd),
+                     _bfd_vms_etir_name (ETIR__C_STA_QW));
+                  return FALSE;
+                }
+              cur_addend = bfd_getl64 (ptr + 4);
+              prev_cmd = cmd;
+              continue;
+
+            case ETIR__C_STO_LW: /* ALPHA_R_REFLONG und_section, step 4 */
+			         /* ALPHA_R_REFLONG abs_section, step 2 */
+                                 /* ALPHA_R_REFLONG others, step 2 */
+              if (prev_cmd != ETIR__C_OPR_ADD
+                  && prev_cmd != ETIR__C_STA_LW
+                  && prev_cmd != ETIR__C_STA_PQ)
+                {
+                  (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
+                                         _bfd_vms_etir_name (prev_cmd),
+                                         _bfd_vms_etir_name (ETIR__C_STO_LW));
+                  return FALSE;
+                }
+              reloc_code = BFD_RELOC_32;
+              break;
+
+            case ETIR__C_STO_QW: /* ALPHA_R_REFQUAD und_section, step 4 */
+			         /* ALPHA_R_REFQUAD abs_section, step 2 */
+              if (prev_cmd != ETIR__C_OPR_ADD && prev_cmd != ETIR__C_STA_QW)
+                {
+                  (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
+                                         _bfd_vms_etir_name (prev_cmd),
+                                         _bfd_vms_etir_name (ETIR__C_STO_QW));
+                  return FALSE;
+                }
+              reloc_code = BFD_RELOC_64;
+              break;
+
+            case ETIR__C_STO_OFF: /* ALPHA_R_REFQUAD others, step 2 */
+              if (prev_cmd != ETIR__C_STA_PQ)
+                {
+                  (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
+                                         _bfd_vms_etir_name (prev_cmd),
+                                         _bfd_vms_etir_name (ETIR__C_STO_OFF));
+                  return FALSE;
+                }
+              reloc_code = BFD_RELOC_64;
+              break;
+
+            case ETIR__C_OPR_ADD: /* ALPHA_R_REFLONG und_section, step 3 */
+                                  /* ALPHA_R_REFQUAD und_section, step 3 */
+              if (prev_cmd != ETIR__C_STA_LW && prev_cmd != ETIR__C_STA_QW)
+                {
+                  (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
+                                         _bfd_vms_etir_name (prev_cmd),
+                                         _bfd_vms_etir_name (ETIR__C_OPR_ADD));
+                  return FALSE;
+                }
+              prev_cmd = ETIR__C_OPR_ADD;
+              continue;
+
+            case ETIR__C_STO_CA: /* ALPHA_R_CODEADDR */
+              reloc_code = BFD_RELOC_ALPHA_CODEADDR;
+              cur_sym = ptr + 4;
+              break;
+
+            case ETIR__C_STO_GBL: /* ALPHA_R_REFQUAD und_section */
+              reloc_code = BFD_RELOC_64;
+              cur_sym = ptr + 4;
+              break;
+
+            case ETIR__C_STO_GBL_LW: /* ALPHA_R_REFLONG und_section */
+              reloc_code = BFD_RELOC_32;
+              cur_sym = ptr + 4;
+              break;
+
+            case ETIR__C_STC_LP_PSB: /* ALPHA_R_LINKAGE */
+              reloc_code = BFD_RELOC_ALPHA_LINKAGE;
+              cur_sym = ptr + 8;
+              break;
+
+            case ETIR__C_STC_NOP_GBL: /* ALPHA_R_NOP */
+              reloc_code = BFD_RELOC_ALPHA_NOP;
+              goto call_reloc;
+
+            case ETIR__C_STC_BSR_GBL: /* ALPHA_R_BSR */
+              reloc_code = BFD_RELOC_ALPHA_BSR;
+              goto call_reloc;
+
+            case ETIR__C_STC_LDA_GBL: /* ALPHA_R_LDA */
+              reloc_code = BFD_RELOC_ALPHA_LDA;
+              goto call_reloc;
+
+            case ETIR__C_STC_BOH_GBL: /* ALPHA_R_BOH */
+              reloc_code = BFD_RELOC_ALPHA_BOH;
+              goto call_reloc;
+
+            call_reloc:
+              cur_sym = ptr + 4 + 32;
+              cur_address = bfd_getl64 (ptr + 4 + 8);
+              cur_addend = bfd_getl64 (ptr + 4 + 24);
+              break;
+
+            case ETIR__C_STO_IMM:
+              vaddr += bfd_getl32 (ptr + 4);
+              continue;
+
+            default:
+              (*_bfd_error_handler) (_("Unknown reloc %s"),
+                                     _bfd_vms_etir_name (cmd));
+              return FALSE;
+            }
+
+          {
+            asection *sec;
+            struct vms_section_data_struct *vms_sec;
+            arelent *reloc;
+
+            /* Get section to which the relocation applies.  */
+            if (cur_psect < 0 || cur_psect > (int)PRIV (section_count))
+              {
+                (*_bfd_error_handler) (_("Invalid section index in ETIR"));
+                return FALSE;
+              }
+            sec = PRIV (sections)[cur_psect];
+            vms_sec = vms_section_data (sec);
+
+            /* Allocate a reloc entry.  */
+            if (sec->reloc_count >= vms_sec->reloc_max)
+              {
+                if (vms_sec->reloc_max == 0)
+                  {
+                    vms_sec->reloc_max = 64;
+                    sec->relocation = bfd_zmalloc
+                      (vms_sec->reloc_max * sizeof (arelent));
+                }
+                else
+                  {
+                    vms_sec->reloc_max *= 2;
+                    sec->relocation = bfd_realloc
+                      (sec->relocation, vms_sec->reloc_max * sizeof (arelent));
+                  }
+              }
+            reloc = &sec->relocation[sec->reloc_count];
+            sec->reloc_count++;
+
+            reloc->howto = bfd_reloc_type_lookup (abfd, reloc_code);
+
+            if (cur_sym != NULL)
+              {
+                unsigned int j;
+                unsigned int symlen = *cur_sym;
+                asymbol **sym;
+
+                /* Linear search.  */
+                symlen = *cur_sym;
+                cur_sym++;
+                sym = NULL;
+
+                for (j = 0; j < PRIV (gsd_sym_count); j++)
+                  if (PRIV (syms)[j]->namelen == symlen
+                      && memcmp (PRIV (syms)[j]->name, cur_sym, symlen) == 0)
+                    {
+                      sym = &PRIV (csymbols)[j];
+                      break;
+                    }
+                if (sym == NULL)
+                  {
+                    (*_bfd_error_handler) (_("Unknown symbol in command %s"),
+                                           _bfd_vms_etir_name (cmd));
+                    reloc->sym_ptr_ptr = NULL;
+                  }
+                else
+                  reloc->sym_ptr_ptr = sym;
+              }
+            else if (cur_psidx >= 0)
+              reloc->sym_ptr_ptr =
+                PRIV (sections)[cur_psidx]->symbol_ptr_ptr;
+            else
+              reloc->sym_ptr_ptr = NULL;
+
+            reloc->address = cur_address;
+            reloc->addend = cur_addend;
+
+            vaddr += bfd_get_reloc_size (reloc->howto);
+          }
+
+          cur_addend = 0;
+          prev_cmd = -1;
+          cur_sym = NULL;
+          cur_psidx = -1;
+        }
+    }
+  vms_debug2 ((3, "alpha_vms_slurp_relocs: result = TRUE\n"));
+
+  return TRUE;
+}
+
+/* Return the number of bytes required to store the relocation
+   information associated with the given section.  */
+
+static long
+alpha_vms_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED, asection *section)
+{
+  alpha_vms_slurp_relocs (abfd);
+
+  return (section->reloc_count + 1) * sizeof (arelent *);
+}
+
+/* Convert relocations from VMS (external) form into BFD internal
+   form.  Return the number of relocations.  */
+
+static long
+alpha_vms_canonicalize_reloc (bfd *abfd, asection *section, arelent **relptr,
+                              asymbol **symbols ATTRIBUTE_UNUSED)
+{
+  arelent *tblptr;
+  int count;
+
+  if (!alpha_vms_slurp_relocs (abfd))
+    return -1;
+
+  count = section->reloc_count;
+  tblptr = section->relocation;
+
+  while (count--)
+    *relptr++ = tblptr++;
+
+  *relptr = (arelent *) NULL;
+  return section->reloc_count;
+}
+
+/* This is just copied from ecoff-alpha, needs to be fixed probably.  */
+
+/* How to process the various reloc types.  */
+
+static bfd_reloc_status_type
+reloc_nil (bfd * abfd ATTRIBUTE_UNUSED,
+	   arelent *reloc ATTRIBUTE_UNUSED,
+	   asymbol *sym ATTRIBUTE_UNUSED,
+	   void * data ATTRIBUTE_UNUSED,
+	   asection *sec ATTRIBUTE_UNUSED,
+	   bfd *output_bfd ATTRIBUTE_UNUSED,
+	   char **error_message ATTRIBUTE_UNUSED)
+{
+#if VMS_DEBUG
+  vms_debug (1, "reloc_nil (abfd %p, output_bfd %p)\n", abfd, output_bfd);
+  vms_debug (2, "In section %s, symbol %s\n",
+	sec->name, sym->name);
+  vms_debug (2, "reloc sym %s, addr %08lx, addend %08lx, reloc is a %s\n",
+		reloc->sym_ptr_ptr[0]->name,
+		(unsigned long)reloc->address,
+		(unsigned long)reloc->addend, reloc->howto->name);
+  vms_debug (2, "data at %p\n", data);
+  /*  _bfd_hexdump (2, data, bfd_get_reloc_size (reloc->howto), 0); */
+#endif
+
+  return bfd_reloc_ok;
+}
+
+/* In case we're on a 32-bit machine, construct a 64-bit "-1" value
+   from smaller values.  Start with zero, widen, *then* decrement.  */
+#define MINUS_ONE	(((bfd_vma)0) - 1)
+
+static reloc_howto_type alpha_howto_table[] =
+{
+  HOWTO (ALPHA_R_IGNORE,	/* Type.  */
+	 0,			/* Rightshift.  */
+	 0,			/* Size (0 = byte, 1 = short, 2 = long).  */
+	 8,			/* Bitsize.  */
+	 TRUE,			/* PC relative.  */
+	 0,			/* Bitpos.  */
+	 complain_overflow_dont,/* Complain_on_overflow.  */
+	 reloc_nil,		/* Special_function.  */
+	 "IGNORE",		/* Name.  */
+	 TRUE,			/* Partial_inplace.  */
+	 0,			/* Source mask */
+	 0,			/* Dest mask.  */
+	 TRUE),			/* PC rel offset.  */
+
+  /* A 64 bit reference to a symbol.  */
+  HOWTO (ALPHA_R_REFQUAD,	/* Type.  */
+	 0,			/* Rightshift.  */
+	 4,			/* Size (0 = byte, 1 = short, 2 = long).  */
+	 64,			/* Bitsize.  */
+	 FALSE,			/* PC relative.  */
+	 0,			/* Bitpos.  */
+	 complain_overflow_bitfield, /* Complain_on_overflow.  */
+	 reloc_nil,		/* Special_function.  */
+	 "REFQUAD",		/* Name.  */
+	 TRUE,			/* Partial_inplace.  */
+	 MINUS_ONE,		/* Source mask.  */
+	 MINUS_ONE,		/* Dest mask.  */
+	 FALSE),		/* PC rel offset.  */
+
+  /* A 21 bit branch.  The native assembler generates these for
+     branches within the text segment, and also fills in the PC
+     relative offset in the instruction.  */
+  HOWTO (ALPHA_R_BRADDR,	/* Type.  */
+	 2,			/* Rightshift.  */
+	 2,			/* Size (0 = byte, 1 = short, 2 = long).  */
+	 21,			/* Bitsize.  */
+	 TRUE,			/* PC relative.  */
+	 0,			/* Bitpos.  */
+	 complain_overflow_signed, /* Complain_on_overflow.  */
+	 reloc_nil,		/* Special_function.  */
+	 "BRADDR",		/* Name.  */
+	 TRUE,			/* Partial_inplace.  */
+	 0x1fffff,		/* Source mask.  */
+	 0x1fffff,		/* Dest mask.  */
+	 FALSE),		/* PC rel offset.  */
+
+  /* A hint for a jump to a register.  */
+  HOWTO (ALPHA_R_HINT,		/* Type.  */
+	 2,			/* Rightshift.  */
+	 1,			/* Size (0 = byte, 1 = short, 2 = long).  */
+	 14,			/* Bitsize.  */
+	 TRUE,			/* PC relative.  */
+	 0,			/* Bitpos.  */
+	 complain_overflow_dont,/* Complain_on_overflow.  */
+	 reloc_nil,		/* Special_function.  */
+	 "HINT",		/* Name.  */
+	 TRUE,			/* Partial_inplace.  */
+	 0x3fff,		/* Source mask.  */
+	 0x3fff,		/* Dest mask.  */
+	 FALSE),		/* PC rel offset.  */
+
+  /* 16 bit PC relative offset.  */
+  HOWTO (ALPHA_R_SREL16,	/* Type.  */
+	 0,			/* Rightshift.  */
+	 1,			/* Size (0 = byte, 1 = short, 2 = long).  */
+	 16,			/* Bitsize.  */
+	 TRUE,			/* PC relative.  */
+	 0,			/* Bitpos.  */
+	 complain_overflow_signed, /* Complain_on_overflow.  */
+	 reloc_nil,		/* Special_function.  */
+	 "SREL16",		/* Name.  */
+	 TRUE,			/* Partial_inplace.  */
+	 0xffff,		/* Source mask.  */
+	 0xffff,		/* Dest mask.  */
+	 FALSE),		/* PC rel offset.  */
+
+  /* 32 bit PC relative offset.  */
+  HOWTO (ALPHA_R_SREL32,	/* Type.  */
+	 0,			/* Rightshift.  */
+	 2,			/* Size (0 = byte, 1 = short, 2 = long).  */
+	 32,			/* Bitsize.  */
+	 TRUE,			/* PC relative.  */
+	 0,			/* Bitpos.  */
+	 complain_overflow_signed, /* Complain_on_overflow.  */
+	 reloc_nil,		/* Special_function.  */
+	 "SREL32",		/* Name.  */
+	 TRUE,			/* Partial_inplace.  */
+	 0xffffffff,		/* Source mask.  */
+	 0xffffffff,		/* Dest mask.  */
+	 FALSE),		/* PC rel offset.  */
+
+  /* A 64 bit PC relative offset.  */
+  HOWTO (ALPHA_R_SREL64,	/* Type.  */
+	 0,			/* Rightshift.  */
+	 4,			/* Size (0 = byte, 1 = short, 2 = long).  */
+	 64,			/* Bitsize.  */
+	 TRUE,			/* PC relative.  */
+	 0,			/* Bitpos.  */
+	 complain_overflow_signed, /* Complain_on_overflow.  */
+	 reloc_nil,		/* Special_function.  */
+	 "SREL64",		/* Name.  */
+	 TRUE,			/* Partial_inplace.  */
+	 MINUS_ONE,		/* Source mask.  */
+	 MINUS_ONE,		/* Dest mask.  */
+	 FALSE),		/* PC rel offset.  */
+
+  /* Push a value on the reloc evaluation stack.  */
+  HOWTO (ALPHA_R_OP_PUSH,	/* Type.  */
+	 0,			/* Rightshift.  */
+	 0,			/* Size (0 = byte, 1 = short, 2 = long).  */
+	 0,			/* Bitsize.  */
+	 FALSE,			/* PC relative.  */
+	 0,			/* Bitpos.  */
+	 complain_overflow_dont,/* Complain_on_overflow.  */
+	 reloc_nil,		/* Special_function.  */
+	 "OP_PUSH",		/* Name.  */
+	 FALSE,			/* Partial_inplace.  */
+	 0,			/* Source mask.  */
+	 0,			/* Dest mask.  */
+	 FALSE),		/* PC rel offset.  */
+
+  /* Store the value from the stack at the given address.  Store it in
+     a bitfield of size r_size starting at bit position r_offset.  */
+  HOWTO (ALPHA_R_OP_STORE,	/* Type.  */
+	 0,			/* Rightshift.  */
+	 4,			/* Size (0 = byte, 1 = short, 2 = long).  */
+	 64,			/* Bitsize.  */
+	 FALSE,			/* PC relative.  */
+	 0,			/* Bitpos.  */
+	 complain_overflow_dont,/* Complain_on_overflow.  */
+	 reloc_nil,		/* Special_function.  */
+	 "OP_STORE",		/* Name.  */
+	 FALSE,			/* Partial_inplace.  */
+	 0,			/* Source mask.  */
+	 MINUS_ONE,		/* Dest mask.  */
+	 FALSE),		/* PC rel offset.  */
+
+  /* Subtract the reloc address from the value on the top of the
+     relocation stack.  */
+  HOWTO (ALPHA_R_OP_PSUB,	/* Type.  */
+	 0,			/* Rightshift.  */
+	 0,			/* Size (0 = byte, 1 = short, 2 = long).  */
+	 0,			/* Bitsize.  */
+	 FALSE,			/* PC relative.  */
+	 0,			/* Bitpos.  */
+	 complain_overflow_dont,/* Complain_on_overflow.  */
+	 reloc_nil,		/* Special_function.  */
+	 "OP_PSUB",		/* Name.  */
+	 FALSE,			/* Partial_inplace.  */
+	 0,			/* Source mask.  */
+	 0,			/* Dest mask.  */
+	 FALSE),		/* PC rel offset.  */
+
+  /* Shift the value on the top of the relocation stack right by the
+     given value.  */
+  HOWTO (ALPHA_R_OP_PRSHIFT,	/* Type.  */
+	 0,			/* Rightshift.  */
+	 0,			/* Size (0 = byte, 1 = short, 2 = long).  */
+	 0,			/* Bitsize.  */
+	 FALSE,			/* PC relative.  */
+	 0,			/* Bitpos.  */
+	 complain_overflow_dont,/* Complain_on_overflow.  */
+	 reloc_nil,		/* Special_function.  */
+	 "OP_PRSHIFT",		/* Name.  */
+	 FALSE,			/* Partial_inplace.  */
+	 0,			/* Source mask.  */
+	 0,			/* Dest mask.  */
+	 FALSE),		/* PC rel offset.  */
+
+  /* Hack. Linkage is done by linker.  */
+  HOWTO (ALPHA_R_LINKAGE,	/* Type.  */
+	 0,			/* Rightshift.  */
+	 8,			/* Size (0 = byte, 1 = short, 2 = long).  */
+	 256,			/* Bitsize.  */
+	 FALSE,			/* PC relative.  */
+	 0,			/* Bitpos.  */
+	 complain_overflow_dont,/* Complain_on_overflow.  */
+	 reloc_nil,		/* Special_function.  */
+	 "LINKAGE",		/* Name.  */
+	 FALSE,			/* Partial_inplace.  */
+	 0,			/* Source mask.  */
+	 0,			/* Dest mask.  */
+	 FALSE),		/* PC rel offset.  */
+
+  /* A 32 bit reference to a symbol.  */
+  HOWTO (ALPHA_R_REFLONG,	/* Type.  */
+	 0,			/* Rightshift.  */
+	 2,			/* Size (0 = byte, 1 = short, 2 = long).  */
+	 32,			/* Bitsize.  */
+	 FALSE,			/* PC relative.  */
+	 0,			/* Bitpos.  */
+	 complain_overflow_bitfield, /* Complain_on_overflow.  */
+	 reloc_nil,		/* Special_function.  */
+	 "REFLONG",		/* Name.  */
+	 TRUE,			/* Partial_inplace.  */
+	 0xffffffff,		/* Source mask.  */
+	 0xffffffff,		/* Dest mask.  */
+	 FALSE),		/* PC rel offset.  */
+
+  /* A 64 bit reference to a procedure, written as 32 bit value.  */
+  HOWTO (ALPHA_R_CODEADDR,	/* Type.  */
+	 0,			/* Rightshift.  */
+	 4,			/* Size (0 = byte, 1 = short, 2 = long).  */
+	 64,			/* Bitsize.  */
+	 FALSE,			/* PC relative.  */
+	 0,			/* Bitpos.  */
+	 complain_overflow_signed,/* Complain_on_overflow.  */
+	 reloc_nil,		/* Special_function.  */
+	 "CODEADDR",		/* Name.  */
+	 FALSE,			/* Partial_inplace.  */
+	 0xffffffff,		/* Source mask.  */
+	 0xffffffff,		/* Dest mask.  */
+	 FALSE),		/* PC rel offset.  */
+
+  HOWTO (ALPHA_R_NOP,		/* Type.  */
+	 0,			/* Rightshift.  */
+	 3,			/* Size (0 = byte, 1 = short, 2 = long).  */
+	 0,			/* Bitsize.  */
+	 /* The following value must match that of ALPHA_R_BSR/ALPHA_R_BOH
+	    because the calculations for the 3 relocations are the same.
+	    See B.4.5.2 of the OpenVMS Linker Utility Manual.  */
+	 TRUE,			/* PC relative.  */
+	 0,			/* Bitpos.   */
+	 complain_overflow_dont,/* Complain_on_overflow.  */
+	 reloc_nil,		/* Special_function.  */
+	 "NOP",			/* Name.  */
+	 FALSE,			/* Partial_inplace.  */
+	 0xffffffff,		/* Source mask.  */
+	 0xffffffff,		/* Dest mask.  */
+	 FALSE),		/* PC rel offset.  */
+
+  HOWTO (ALPHA_R_BSR,		/* Type.  */
+	 0,			/* Rightshift.  */
+	 3,			/* Size (0 = byte, 1 = short, 2 = long).  */
+	 0,			/* Bitsize.  */
+	 TRUE,			/* PC relative.  */
+	 0,			/* Bitpos.  */
+	 complain_overflow_dont,/* Complain_on_overflow.  */
+	 reloc_nil,		/* Special_function.  */
+	 "BSR",			/* Name.  */
+	 FALSE,			/* Partial_inplace.  */
+	 0xffffffff,		/* Source mask.  */
+	 0xffffffff,		/* Dest mask.  */
+	 FALSE),		/* PC rel offset.  */
+
+  HOWTO (ALPHA_R_LDA,		/* Type.  */
+	 0,			/* Rightshift.  */
+	 3,			/* Size (0 = byte, 1 = short, 2 = long).  */
+	 0,			/* Bitsize.  */
+	 FALSE,			/* PC relative.  */
+	 0,			/* Bitpos.  */
+	 complain_overflow_dont,/* Complain_on_overflow.  */
+	 reloc_nil,		/* Special_function.  */
+	 "LDA",			/* Name.  */
+	 FALSE,			/* Partial_inplace.  */
+	 0xffffffff,		/* Source mask.  */
+	 0xffffffff,		/* Dest mask.  */
+	 FALSE),		/* PC rel offset.  */
+
+  HOWTO (ALPHA_R_BOH,		/* Type.  */
+	 0,			/* Rightshift.  */
+	 3,			/* Size (0 = byte, 1 = short, 2 = long, 3 = nil).  */
+	 0,			/* Bitsize.  */
+	 TRUE,			/* PC relative.  */
+	 0,			/* Bitpos.  */
+	 complain_overflow_dont,/* Complain_on_overflow.  */
+	 reloc_nil,		/* Special_function.  */
+	 "BOH",			/* Name.  */
+	 FALSE,			/* Partial_inplace.  */
+	 0xffffffff,		/* Source mask.  */
+	 0xffffffff,		/* Dest mask.  */
+	 FALSE),		/* PC rel offset.  */
+};
+
+/* Return a pointer to a howto structure which, when invoked, will perform
+   the relocation code on data from the architecture noted.  */
+
+static const struct reloc_howto_struct *
+alpha_vms_bfd_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
+                                 bfd_reloc_code_real_type code)
+{
+  int alpha_type;
+
+  vms_debug2 ((1, "vms_bfd_reloc_type_lookup (%p, %d)\t", abfd, code));
+
+  switch (code)
+    {
+      case BFD_RELOC_16:		alpha_type = ALPHA_R_SREL16;	break;
+      case BFD_RELOC_32:		alpha_type = ALPHA_R_REFLONG;	break;
+      case BFD_RELOC_64:		alpha_type = ALPHA_R_REFQUAD;	break;
+      case BFD_RELOC_CTOR:		alpha_type = ALPHA_R_REFQUAD;	break;
+      case BFD_RELOC_23_PCREL_S2:	alpha_type = ALPHA_R_BRADDR;	break;
+      case BFD_RELOC_ALPHA_HINT:	alpha_type = ALPHA_R_HINT;	break;
+      case BFD_RELOC_16_PCREL:		alpha_type = ALPHA_R_SREL16;	break;
+      case BFD_RELOC_32_PCREL:		alpha_type = ALPHA_R_SREL32;	break;
+      case BFD_RELOC_64_PCREL:		alpha_type = ALPHA_R_SREL64;	break;
+      case BFD_RELOC_ALPHA_LINKAGE:	alpha_type = ALPHA_R_LINKAGE;	break;
+      case BFD_RELOC_ALPHA_CODEADDR:	alpha_type = ALPHA_R_CODEADDR;	break;
+      case BFD_RELOC_ALPHA_NOP:		alpha_type = ALPHA_R_NOP;	break;
+      case BFD_RELOC_ALPHA_BSR:		alpha_type = ALPHA_R_BSR;	break;
+      case BFD_RELOC_ALPHA_LDA:		alpha_type = ALPHA_R_LDA;	break;
+      case BFD_RELOC_ALPHA_BOH:		alpha_type = ALPHA_R_BOH;	break;
+      default:
+	(*_bfd_error_handler) ("reloc (%d) is *UNKNOWN*", code);
+	return NULL;
+    }
+  vms_debug2 ((2, "reloc is %s\n", alpha_howto_table[alpha_type].name));
+  return & alpha_howto_table[alpha_type];
+}
+
+static reloc_howto_type *
+alpha_vms_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
+                                 const char *r_name)
+{
+  unsigned int i;
+
+  for (i = 0;
+       i < sizeof (alpha_howto_table) / sizeof (alpha_howto_table[0]);
+       i++)
+    if (alpha_howto_table[i].name != NULL
+	&& strcasecmp (alpha_howto_table[i].name, r_name) == 0)
+      return &alpha_howto_table[i];
+
+  return NULL;
+}
+
+static long
+alpha_vms_get_synthetic_symtab (bfd *abfd,
+                                long symcount ATTRIBUTE_UNUSED,
+                                asymbol **usyms ATTRIBUTE_UNUSED,
+                                long dynsymcount ATTRIBUTE_UNUSED,
+                                asymbol **dynsyms ATTRIBUTE_UNUSED,
+                                asymbol **ret)
+{
+  asymbol *syms;
+  unsigned int i;
+  unsigned int n = 0;
+
+  syms = (asymbol *) bfd_malloc (PRIV (norm_sym_count) * sizeof (asymbol));
+  *ret = syms;
+  if (syms == NULL)
+    return -1;
+
+  for (i = 0; i < PRIV (gsd_sym_count); i++)
+    {
+      struct vms_symbol_entry *e = PRIV (syms)[i];
+      asymbol *sym;
+      flagword flags;
+      symvalue value;
+      asection *sec;
+      const char *name;
+      char *sname;
+      int l;
+
+      name = e->name;
+      value = 0;
+      flags = BSF_LOCAL | BSF_SYNTHETIC;
+      sec = NULL;
+
+      switch (e->typ)
+        {
+        case EGSD__C_SYM:
+          if ((e->flags & EGSY__V_DEF) && (e->flags & EGSY__V_NORM))
+            {
+              value = e->code_value;
+              sec = PRIV (sections)[e->code_section];
+            }
+          else
+            continue;
+          break;
+
+        case EGSD__C_SYMG:
+          if ((e->flags & EGSY__V_DEF) && (e->flags & EGSY__V_NORM))
+            {
+              bfd_vma sbase = 0;
+              asection *s;
+
+              value = e->code_value;
+
+              /* Find containing section.  */
+              for (s = abfd->sections; s; s = s->next)
+                {
+                  if (value >= s->vma
+                      && s->vma > sbase
+                      && !(s->flags & SEC_COFF_SHARED_LIBRARY)
+                      && (s->size > 0 || !(e->flags & EGSY__V_REL)))
+                    {
+                      sbase = s->vma;
+                      sec = s;
+                    }
+                }
+              value -= sbase;
+            }
+          else
+            continue;
+          break;
+
+        default:
+          abort ();
+        }
+
+      l = strlen (name);
+      sname = bfd_alloc (abfd, l + 5);
+      if (sname == NULL)
+        return FALSE;
+      memcpy (sname, name, l);
+      memcpy (sname + l, "..en", 5);
+
+      sym = &syms[n++];
+      sym->name = sname;
+      sym->section = sec;
+      sym->flags = flags;
+      sym->value = value;
+      sym->udata.p = NULL;
+    }
+
+  return n;
+}
+
+/* Private dump.  */
+
+static const char *
+vms_time_to_str (unsigned char *buf)
+{
+  time_t t = vms_rawtime_to_time_t (buf);
+  char *res = ctime (&t);
+
+  if (!res)
+    res = "*invalid time*";
+  else
+    res[24] = 0;
+  return res;
+}
+
+static void
+evax_bfd_print_emh (FILE *file, unsigned char *rec, unsigned int rec_len)
+{
+  struct vms_emh_common *emh = (struct vms_emh_common *)rec;
+  unsigned int subtype;
+
+  subtype = (unsigned)bfd_getl16 (emh->subtyp);
+
+  fprintf (file, _("  EMH %u (len=%u): "), subtype, rec_len);
+
+  switch (subtype)
+    {
+    case EMH__C_MHD:
+      {
+        struct vms_emh_mhd *mhd = (struct vms_emh_mhd *)rec;
+        const char *name;
+
+        fprintf (file, _("Module header\n"));
+        fprintf (file, _("   structure level: %u\n"), mhd->strlvl);
+        fprintf (file, _("   max record size: %u\n"),
+                 (unsigned)bfd_getl32 (mhd->recsiz));
+        name = (char *)(mhd + 1);
+        fprintf (file, _("   module name    : %.*s\n"), name[0], name + 1);
+        name += name[0] + 1;
+        fprintf (file, _("   module version : %.*s\n"), name[0], name + 1);
+        name += name[0] + 1;
+        fprintf (file, _("   compile date   : %.17s\n"), name);
+      }
+      break;
+    case EMH__C_LNM:
+      {
+        fprintf (file, _("Language Processor Name\n"));
+        fprintf (file, _("   language name: %.*s\n"),
+                 (int)(rec_len - sizeof (struct vms_emh_common)),
+                 (char *)rec + sizeof (struct vms_emh_common));
+      }
+      break;
+    case EMH__C_SRC:
+      {
+        fprintf (file, _("Source Files Header\n"));
+        fprintf (file, _("   file: %.*s\n"),
+                 (int)(rec_len - sizeof (struct vms_emh_common)),
+                 (char *)rec + sizeof (struct vms_emh_common));
+      }
+      break;
+    case EMH__C_TTL:
+      {
+        fprintf (file, _("Title Text Header\n"));
+        fprintf (file, _("   title: %.*s\n"),
+                 (int)(rec_len - sizeof (struct vms_emh_common)),
+                 (char *)rec + sizeof (struct vms_emh_common));
+      }
+      break;
+    case EMH__C_CPR:
+      {
+        fprintf (file, _("Copyright Header\n"));
+        fprintf (file, _("   copyright: %.*s\n"),
+                 (int)(rec_len - sizeof (struct vms_emh_common)),
+                 (char *)rec + sizeof (struct vms_emh_common));
+      }
+      break;
+    default:
+      fprintf (file, _("unhandled emh subtype %u\n"), subtype);
+      break;
+    }
+}
+
+static void
+evax_bfd_print_eeom (FILE *file, unsigned char *rec, unsigned int rec_len)
+{
+  struct vms_eeom *eeom = (struct vms_eeom *)rec;
+
+  fprintf (file, _("  EEOM (len=%u):\n"), rec_len);
+  fprintf (file, _("   number of cond linkage pairs: %u\n"),
+           (unsigned)bfd_getl32 (eeom->total_lps));
+  fprintf (file, _("   completion code: %u\n"),
+           (unsigned)bfd_getl16 (eeom->comcod));
+  if (rec_len > 10)
+    {
+      fprintf (file, _("   transfer addr flags: 0x%02x\n"), eeom->tfrflg);
+      fprintf (file, _("   transfer addr psect: %u\n"),
+               (unsigned)bfd_getl32 (eeom->psindx));
+      fprintf (file, _("   transfer address   : 0x%08x\n"),
+               (unsigned)bfd_getl32 (eeom->tfradr));
+    }
+}
+
+static void
+exav_bfd_print_egsy_flags (unsigned int flags, FILE *file)
+{
+  if (flags & EGSY__V_WEAK)
+    fputs (_(" WEAK"), file);
+  if (flags & EGSY__V_DEF)
+    fputs (_(" DEF"), file);
+  if (flags & EGSY__V_UNI)
+    fputs (_(" UNI"), file);
+  if (flags & EGSY__V_REL)
+    fputs (_(" REL"), file);
+  if (flags & EGSY__V_COMM)
+    fputs (_(" COMM"), file);
+  if (flags & EGSY__V_VECEP)
+    fputs (_(" VECEP"), file);
+  if (flags & EGSY__V_NORM)
+    fputs (_(" NORM"), file);
+  if (flags & EGSY__V_QUAD_VAL)
+    fputs (_(" QVAL"), file);
+}
+
+static void
+evax_bfd_print_egsd (FILE *file, unsigned char *rec, unsigned int rec_len)
+{
+  unsigned int off = sizeof (struct vms_egsd);
+  unsigned int n;
+
+  fprintf (file, _("  EGSD (len=%u):\n"), rec_len);
+
+  n = 0;
+  for (off = sizeof (struct vms_egsd); off < rec_len; )
+    {
+      struct vms_egsd_entry *e = (struct vms_egsd_entry *)(rec + off);
+      unsigned int type;
+      unsigned int len;
+
+      type = (unsigned)bfd_getl16 (e->gsdtyp);
+      len = (unsigned)bfd_getl16 (e->gsdsiz);
+
+      fprintf (file, _("  EGSD entry %2u (type: %u, len: %u): "),
+               n, type, len);
+      n++;
+
+      switch (type)
+        {
+        case EGSD__C_PSC:
+          {
+            struct vms_egps *egps = (struct vms_egps *)e;
+            unsigned int flags = bfd_getl16 (egps->flags);
+            unsigned int l;
+
+            fprintf (file, _("PSC - Program section definition\n"));
+            fprintf (file, _("   alignment  : 2**%u\n"), egps->align);
+            fprintf (file, _("   flags      : 0x%04x"), flags);
+            if (flags & EGPS__V_PIC)
+              fputs (_(" PIC"), file);
+            if (flags & EGPS__V_LIB)
+              fputs (_(" LIB"), file);
+            if (flags & EGPS__V_OVR)
+              fputs (_(" OVR"), file);
+            if (flags & EGPS__V_REL)
+              fputs (_(" REL"), file);
+            if (flags & EGPS__V_GBL)
+              fputs (_(" GBL"), file);
+            if (flags & EGPS__V_SHR)
+              fputs (_(" SHR"), file);
+            if (flags & EGPS__V_EXE)
+              fputs (_(" EXE"), file);
+            if (flags & EGPS__V_RD)
+              fputs (_(" RD"), file);
+            if (flags & EGPS__V_WRT)
+              fputs (_(" WRT"), file);
+            if (flags & EGPS__V_VEC)
+              fputs (_(" VEC"), file);
+            if (flags & EGPS__V_NOMOD)
+              fputs (_(" NOMOD"), file);
+            if (flags & EGPS__V_COM)
+              fputs (_(" COM"), file);
+            if (flags & EGPS__V_ALLOC_64BIT)
+              fputs (_(" 64B"), file);
+            fputc ('\n', file);
+            l = bfd_getl32 (egps->alloc);
+            fprintf (file, _("   alloc (len): %u (0x%08x)\n"), l, l);
+            fprintf (file, _("   name       : %.*s\n"),
+                     egps->namlng, egps->name);
+          }
+          break;
+        case EGSD__C_SYM:
+          {
+            struct vms_egsy *egsy = (struct vms_egsy *)e;
+            unsigned int flags = bfd_getl16 (egsy->flags);
+
+            if (flags & EGSY__V_DEF)
+              {
+                struct vms_esdf *esdf = (struct vms_esdf *)e;
+
+                fprintf (file, _("SYM - Global symbol definition\n"));
+                fprintf (file, _("   flags: 0x%04x"), flags);
+                exav_bfd_print_egsy_flags (flags, file);
+                fputc ('\n', file);
+                fprintf (file, _("   psect offset: 0x%08x\n"),
+                         (unsigned)bfd_getl32 (esdf->value));
+                if (flags & EGSY__V_NORM)
+                  {
+                    fprintf (file, _("   code address: 0x%08x\n"),
+                             (unsigned)bfd_getl32 (esdf->code_address));
+                    fprintf (file, _("   psect index for entry point : %u\n"),
+                             (unsigned)bfd_getl32 (esdf->ca_psindx));
+                  }
+                fprintf (file, _("   psect index : %u\n"),
+                         (unsigned)bfd_getl32 (esdf->psindx));
+                fprintf (file, _("   name        : %.*s\n"),
+                         esdf->namlng, esdf->name);
+              }
+            else
+              {
+                struct vms_esrf *esrf = (struct vms_esrf *)e;
+
+                fprintf (file, _("SYM - Global symbol reference\n"));
+                fprintf (file, _("   name       : %.*s\n"),
+                         esrf->namlng, esrf->name);
+              }
+          }
+          break;
+        case EGSD__C_SYMG:
+          {
+            struct vms_egst *egst = (struct vms_egst *)e;
+            unsigned int flags = bfd_getl16 (egst->header.flags);
+
+            fprintf (file, _("SYMG - Universal symbol definition\n"));
+            fprintf (file, _("   flags: 0x%04x"), flags);
+            exav_bfd_print_egsy_flags (flags, file);
+            fputc ('\n', file);
+            fprintf (file, _("   symbol vector offset: 0x%08x\n"),
+                     (unsigned)bfd_getl32 (egst->value));
+            fprintf (file, _("   entry point: 0x%08x\n"),
+                     (unsigned)bfd_getl32 (egst->lp_1));
+            fprintf (file, _("   proc descr : 0x%08x\n"),
+                     (unsigned)bfd_getl32 (egst->lp_2));
+            fprintf (file, _("   psect index: %u\n"),
+                     (unsigned)bfd_getl32 (egst->psindx));
+            fprintf (file, _("   name       : %.*s\n"),
+                     egst->namlng, egst->name);
+          }
+          break;
+        case EGSD__C_SYMV:
+          {
+            struct vms_esdfv *esdfv = (struct vms_esdfv *)e;
+            unsigned int flags = bfd_getl16 (esdfv->flags);
+
+            fprintf (file, _("SYMV - Vectored symbol definition\n"));
+            fprintf (file, _("   flags: 0x%04x"), flags);
+            exav_bfd_print_egsy_flags (flags, file);
+            fputc ('\n', file);
+            fprintf (file, _("   vector      : 0x%08x\n"),
+                     (unsigned)bfd_getl32 (esdfv->vector));
+            fprintf (file, _("   psect offset: %u\n"),
+                     (unsigned)bfd_getl32 (esdfv->value));
+            fprintf (file, _("   psect index : %u\n"),
+                     (unsigned)bfd_getl32 (esdfv->psindx));
+            fprintf (file, _("   name        : %.*s\n"),
+                     esdfv->namlng, esdfv->name);
+          }
+          break;
+        case EGSD__C_SYMM:
+          {
+            struct vms_esdfm *esdfm = (struct vms_esdfm *)e;
+            unsigned int flags = bfd_getl16 (esdfm->flags);
+
+            fprintf (file, _("SYMM - Global symbol definition with version\n"));
+            fprintf (file, _("   flags: 0x%04x"), flags);
+            exav_bfd_print_egsy_flags (flags, file);
+            fputc ('\n', file);
+            fprintf (file, _("   version mask: 0x%08x\n"),
+                     (unsigned)bfd_getl32 (esdfm->version_mask));
+            fprintf (file, _("   psect offset: %u\n"),
+                     (unsigned)bfd_getl32 (esdfm->value));
+            fprintf (file, _("   psect index : %u\n"),
+                     (unsigned)bfd_getl32 (esdfm->psindx));
+            fprintf (file, _("   name        : %.*s\n"),
+                     esdfm->namlng, esdfm->name);
+          }
+          break;
+        default:
+          fprintf (file, _("unhandled egsd entry type %u\n"), type);
+          break;
+        }
+      off += len;
+    }
+}
+
+static void
+evax_bfd_print_hex (FILE *file, const char *pfx,
+                    const unsigned char *buf, unsigned int len)
+{
+  unsigned int i;
+  unsigned int n;
+
+  n = 0;
+  for (i = 0; i < len; i++)
+    {
+      if (n == 0)
+        fputs (pfx, file);
+      fprintf (file, " %02x", buf[i]);
+      n++;
+      if (n == 16)
+        {
+          n = 0;
+          fputc ('\n', file);
+        }
+    }
+  if (n != 0)
+    fputc ('\n', file);
+}
+
+static void
+evax_bfd_print_etir_stc_ir (FILE *file, const unsigned char *buf, int is_ps)
+{
+  fprintf (file, _("    linkage index: %u, replacement insn: 0x%08x\n"),
+           (unsigned)bfd_getl32 (buf),
+           (unsigned)bfd_getl32 (buf + 16));
+  fprintf (file, _("    psect idx 1: %u, offset 1: 0x%08x %08x\n"),
+           (unsigned)bfd_getl32 (buf + 4),
+           (unsigned)bfd_getl32 (buf + 12),
+           (unsigned)bfd_getl32 (buf + 8));
+  fprintf (file, _("    psect idx 2: %u, offset 2: 0x%08x %08x\n"),
+           (unsigned)bfd_getl32 (buf + 20),
+           (unsigned)bfd_getl32 (buf + 28),
+           (unsigned)bfd_getl32 (buf + 24));
+  if (is_ps)
+    fprintf (file, _("    psect idx 3: %u, offset 3: 0x%08x %08x\n"),
+             (unsigned)bfd_getl32 (buf + 32),
+             (unsigned)bfd_getl32 (buf + 40),
+             (unsigned)bfd_getl32 (buf + 36));
+  else
+    fprintf (file, _("    global name: %.*s\n"), buf[32], buf + 33);
+}
+
+static void
+evax_bfd_print_etir (FILE *file, const char *name,
+                     unsigned char *rec, unsigned int rec_len)
+{
+  unsigned int off = sizeof (struct vms_egsd);
+  unsigned int sec_len;
+
+  fprintf (file, _("  %s (len=%u+%u):\n"), name,
+           (unsigned)(rec_len - sizeof (struct vms_eobjrec)),
+           (unsigned)sizeof (struct vms_eobjrec));
+
+  for (off = sizeof (struct vms_eobjrec); off < rec_len; )
+    {
+      struct vms_etir *etir = (struct vms_etir *)(rec + off);
+      unsigned char *buf;
+      unsigned int type;
+      unsigned int size;
+
+      type = bfd_getl16 (etir->rectyp);
+      size = bfd_getl16 (etir->size);
+      buf = rec + off + sizeof (struct vms_etir);
+
+      fprintf (file, _("   (type: %3u, size: 4+%3u): "), type, size - 4);
+      switch (type)
+        {
+        case ETIR__C_STA_GBL:
+          fprintf (file, _("STA_GBL (stack global) %.*s\n"),
+                   buf[0], buf + 1);
+          break;
+        case ETIR__C_STA_LW:
+          fprintf (file, _("STA_LW (stack longword) 0x%08x\n"),
+                   (unsigned)bfd_getl32 (buf));
+          break;
+        case ETIR__C_STA_QW:
+          fprintf (file, _("STA_QW (stack quadword) 0x%08x %08x\n"),
+                   (unsigned)bfd_getl32 (buf + 4),
+                   (unsigned)bfd_getl32 (buf + 0));
+          break;
+        case ETIR__C_STA_PQ:
+          fprintf (file, _("STA_PQ (stack psect base + offset)\n"));
+          fprintf (file, _("    psect: %u, offset: 0x%08x %08x\n"),
+                   (unsigned)bfd_getl32 (buf + 0),
+                   (unsigned)bfd_getl32 (buf + 8),
+                   (unsigned)bfd_getl32 (buf + 4));
+          break;
+        case ETIR__C_STA_LI:
+          fprintf (file, _("STA_LI (stack literal)\n"));
+          break;
+        case ETIR__C_STA_MOD:
+          fprintf (file, _("STA_MOD (stack module)\n"));
+          break;
+        case ETIR__C_STA_CKARG:
+          fprintf (file, _("STA_CKARG (compare procedure argument)\n"));
+          break;
+
+        case ETIR__C_STO_B:
+          fprintf (file, _("STO_B (store byte)\n"));
+          break;
+        case ETIR__C_STO_W:
+          fprintf (file, _("STO_W (store word)\n"));
+          break;
+        case ETIR__C_STO_LW:
+          fprintf (file, _("STO_LW (store longword)\n"));
+          break;
+        case ETIR__C_STO_QW:
+          fprintf (file, _("STO_QW (store quadword)\n"));
+          break;
+        case ETIR__C_STO_IMMR:
+          {
+            unsigned int len = bfd_getl32 (buf);
+            fprintf (file,
+                     _("STO_IMMR (store immediate repeat) %u bytes\n"),
+                     len);
+            evax_bfd_print_hex (file, "   ", buf + 4, len);
+            sec_len += len;
+          }
+          break;
+        case ETIR__C_STO_GBL:
+          fprintf (file, _("STO_GBL (store global) %.*s\n"),
+                   buf[0], buf + 1);
+          break;
+        case ETIR__C_STO_CA:
+          fprintf (file, _("STO_CA (store code address) %.*s\n"),
+                   buf[0], buf + 1);
+          break;
+        case ETIR__C_STO_RB:
+          fprintf (file, _("STO_RB (store relative branch)\n"));
+          break;
+        case ETIR__C_STO_AB:
+          fprintf (file, _("STO_AB (store absolute branch)\n"));
+          break;
+        case ETIR__C_STO_OFF:
+          fprintf (file, _("STO_OFF (store offset to psect)\n"));
+          break;
+        case ETIR__C_STO_IMM:
+          {
+            unsigned int len = bfd_getl32 (buf);
+            fprintf (file,
+                     _("STO_IMM (store immediate) %u bytes\n"),
+                     len);
+            evax_bfd_print_hex (file, "   ", buf + 4, len);
+            sec_len += len;
+          }
+          break;
+        case ETIR__C_STO_LP_PSB:
+          fprintf (file, _("STO_OFF (store LP with procedure signature)\n"));
+          break;
+        case ETIR__C_STO_HINT_GBL:
+          fprintf (file, _("STO_BR_GBL (store branch global) *todo*\n"));
+          break;
+        case ETIR__C_STO_HINT_PS:
+          fprintf (file, _("STO_BR_PS (store branch psect + offset) *todo*\n"));
+          break;
+
+        case ETIR__C_OPR_NOP:
+          fprintf (file, _("OPR_NOP (no-operation)\n"));
+          break;
+        case ETIR__C_OPR_ADD:
+          fprintf (file, _("OPR_ADD (add)\n"));
+          break;
+        case ETIR__C_OPR_SUB:
+          fprintf (file, _("OPR_SUB (substract)\n"));
+          break;
+        case ETIR__C_OPR_MUL:
+          fprintf (file, _("OPR_MUL (multiply)\n"));
+          break;
+        case ETIR__C_OPR_DIV:
+          fprintf (file, _("OPR_DIV (divide)\n"));
+          break;
+        case ETIR__C_OPR_AND:
+          fprintf (file, _("OPR_AND (logical and)\n"));
+          break;
+        case ETIR__C_OPR_IOR:
+          fprintf (file, _("OPR_IOR (logical inclusive or)\n"));
+          break;
+        case ETIR__C_OPR_EOR:
+          fprintf (file, _("OPR_EOR (logical exclusive or)\n"));
+          break;
+        case ETIR__C_OPR_NEG:
+          fprintf (file, _("OPR_NEG (negate)\n"));
+          break;
+        case ETIR__C_OPR_COM:
+          fprintf (file, _("OPR_COM (complement)\n"));
+          break;
+        case ETIR__C_OPR_INSV:
+          fprintf (file, _("OPR_INSV (insert field)\n"));
+          break;
+        case ETIR__C_OPR_ASH:
+          fprintf (file, _("OPR_ASH (arithmetic shift)\n"));
+          break;
+        case ETIR__C_OPR_USH:
+          fprintf (file, _("OPR_USH (unsigned shift)\n"));
+          break;
+        case ETIR__C_OPR_ROT:
+          fprintf (file, _("OPR_ROT (rotate)\n"));
+          break;
+        case ETIR__C_OPR_SEL:
+          fprintf (file, _("OPR_SEL (select)\n"));
+          break;
+        case ETIR__C_OPR_REDEF:
+          fprintf (file, _("OPR_REDEF (redefine symbol to curr location)\n"));
+          break;
+        case ETIR__C_OPR_DFLIT:
+          fprintf (file, _("OPR_REDEF (define a literal)\n"));
+          break;
+
+        case ETIR__C_STC_LP:
+          fprintf (file, _("STC_LP (store cond linkage pair)\n"));
+          break;
+        case ETIR__C_STC_LP_PSB:
+          fprintf (file,
+                   _("STC_LP_PSB (store cond linkage pair + signature)\n"));
+          fprintf (file, _("   linkage index: %u, procedure: %.*s\n"),
+                   (unsigned)bfd_getl32 (buf), buf[4], buf + 5);
+          buf += 4 + 1 + buf[4];
+          fprintf (file, _("   signature: %.*s\n"), buf[0], buf + 1);
+          break;
+        case ETIR__C_STC_GBL:
+          fprintf (file, _("STC_GBL (store cond global)\n"));
+          fprintf (file, _("   linkage index: %u, global: %.*s\n"),
+                   (unsigned)bfd_getl32 (buf), buf[4], buf + 5);
+          break;
+        case ETIR__C_STC_GCA:
+          fprintf (file, _("STC_GCA (store cond code address)\n"));
+          fprintf (file, _("   linkage index: %u, procedure name: %.*s\n"),
+                   (unsigned)bfd_getl32 (buf), buf[4], buf + 5);
+          break;
+        case ETIR__C_STC_PS:
+          fprintf (file, _("STC_PS (store cond psect + offset)\n"));
+          fprintf (file,
+                   _("   linkage index: %u, psect: %u, offset: 0x%08x %08x\n"),
+                   (unsigned)bfd_getl32 (buf),
+                   (unsigned)bfd_getl32 (buf + 4),
+                   (unsigned)bfd_getl32 (buf + 12),
+                   (unsigned)bfd_getl32 (buf + 8));
+          break;
+        case ETIR__C_STC_NOP_GBL:
+          fprintf (file, _("STC_NOP_GBL (store cond NOP at global addr)\n"));
+          evax_bfd_print_etir_stc_ir (file, buf, 0);
+          break;
+        case ETIR__C_STC_NOP_PS:
+          fprintf (file, _("STC_NOP_PS (store cond NOP at psect + offset)\n"));
+          evax_bfd_print_etir_stc_ir (file, buf, 1);
+          break;
+        case ETIR__C_STC_BSR_GBL:
+          fprintf (file, _("STC_BSR_GBL (store cond BSR at global addr)\n"));
+          evax_bfd_print_etir_stc_ir (file, buf, 0);
+          break;
+        case ETIR__C_STC_BSR_PS:
+          fprintf (file, _("STC_BSR_PS (store cond BSR at psect + offset)\n"));
+          evax_bfd_print_etir_stc_ir (file, buf, 1);
+          break;
+        case ETIR__C_STC_LDA_GBL:
+          fprintf (file, _("STC_LDA_GBL (store cond LDA at global addr)\n"));
+          evax_bfd_print_etir_stc_ir (file, buf, 0);
+          break;
+        case ETIR__C_STC_LDA_PS:
+          fprintf (file, _("STC_LDA_PS (store cond LDA at psect + offset)\n"));
+          evax_bfd_print_etir_stc_ir (file, buf, 1);
+          break;
+        case ETIR__C_STC_BOH_GBL:
+          fprintf (file, _("STC_BOH_GBL (store cond BOH at global addr)\n"));
+          evax_bfd_print_etir_stc_ir (file, buf, 0);
+          break;
+        case ETIR__C_STC_BOH_PS:
+          fprintf (file, _("STC_BOH_PS (store cond BOH at psect + offset)\n"));
+          evax_bfd_print_etir_stc_ir (file, buf, 1);
+          break;
+        case ETIR__C_STC_NBH_GBL:
+          fprintf (file,
+                   _("STC_NBH_GBL (store cond or hint at global addr)\n"));
+          break;
+        case ETIR__C_STC_NBH_PS:
+          fprintf (file,
+                   _("STC_NBH_PS (store cond or hint at psect + offset)\n"));
+          break;
+
+        case ETIR__C_CTL_SETRB:
+          fprintf (file, _("CTL_SETRB (set relocation base)\n"));
+          sec_len += 4;
+          break;
+        case ETIR__C_CTL_AUGRB:
+          {
+            unsigned int val = bfd_getl32 (buf);
+            fprintf (file, _("CTL_AUGRB (augment relocation base) %u\n"), val);
+          }
+          break;
+        case ETIR__C_CTL_DFLOC:
+          fprintf (file, _("CTL_DFLOC (define location)\n"));
+          break;
+        case ETIR__C_CTL_STLOC:
+          fprintf (file, _("CTL_STLOC (set location)\n"));
+          break;
+        case ETIR__C_CTL_STKDL:
+          fprintf (file, _("CTL_STKDL (stack defined location)\n"));
+          break;
+        default:
+          fprintf (file, _("*unhandled*\n"));
+          break;
+        }
+      off += size;
+    }
+}
+
+static void
+evax_bfd_print_eobj (struct bfd *abfd, FILE *file)
+{
+  bfd_boolean is_first = TRUE;
+  bfd_boolean has_records = FALSE;
+
+  while (1)
+    {
+      unsigned int rec_len;
+      unsigned int pad_len;
+      unsigned char *rec;
+      unsigned int hdr_size;
+      unsigned int type;
+
+      if (is_first)
+        {
+          unsigned char buf[6];
+
+          is_first = FALSE;
+
+          /* Read 6 bytes.  */
+          if (bfd_bread (buf, sizeof (buf), abfd) != sizeof (buf))
+            {
+              fprintf (file, _("cannot read GST record length\n"));
+              return;
+            }
+          rec_len = bfd_getl16 (buf + 0);
+          if (rec_len == bfd_getl16 (buf + 4)
+              && bfd_getl16 (buf + 2) == EOBJ__C_EMH)
+            {
+              /* The format is raw: record-size, type, record-size.  */
+              has_records = TRUE;
+              pad_len = (rec_len + 1) & ~1U;
+              hdr_size = 4;
+            }
+          else if (rec_len == EOBJ__C_EMH)
+            {
+              has_records = FALSE;
+              pad_len = bfd_getl16 (buf + 2);
+              hdr_size = 6;
+            }
+          else
+            {
+              /* Ill-formed.  */
+              fprintf (file, _("cannot find EMH in first GST record\n"));
+              return;
+            }
+          rec = bfd_malloc (pad_len);
+          memcpy (rec, buf + sizeof (buf) - hdr_size, hdr_size);
+        }
+      else
+        {
+          unsigned int rec_len2 = 0;
+          unsigned char hdr[4];
+
+          if (has_records)
+            {
+              unsigned char buf_len[2];
+
+              if (bfd_bread (buf_len, sizeof (buf_len), abfd)
+                  != sizeof (buf_len))
+                {
+                  fprintf (file, _("cannot read GST record length\n"));
+                  return;
+                }
+              rec_len2 = (unsigned)bfd_getl16 (buf_len);
+            }
+
+          if (bfd_bread (hdr, sizeof (hdr), abfd) != sizeof (hdr))
+            {
+              fprintf (file, _("cannot read GST record header\n"));
+              return;
+            }
+          rec_len = (unsigned)bfd_getl16 (hdr + 2);
+          if (has_records)
+            pad_len = (rec_len + 1) & ~1U;
+          else
+            pad_len = rec_len;
+          rec = bfd_malloc (pad_len);
+          memcpy (rec, hdr, sizeof (hdr));
+          hdr_size = sizeof (hdr);
+          if (has_records && rec_len2 != rec_len)
+            {
+              fprintf (file, _(" corrupted GST\n"));
+              break;
+            }
+        }
+
+      if (bfd_bread (rec + hdr_size, pad_len - hdr_size, abfd)
+          != pad_len - hdr_size)
+        {
+          fprintf (file, _("cannot read GST record\n"));
+          return;
+        }
+
+      type = (unsigned)bfd_getl16 (rec);
+
+      switch (type)
+        {
+        case EOBJ__C_EMH:
+          evax_bfd_print_emh (file, rec, rec_len);
+          break;
+        case EOBJ__C_EGSD:
+          evax_bfd_print_egsd (file, rec, rec_len);
+          break;
+        case EOBJ__C_EEOM:
+          evax_bfd_print_eeom (file, rec, rec_len);
+          free (rec);
+          return;
+          break;
+        case EOBJ__C_ETIR:
+          evax_bfd_print_etir (file, "ETIR", rec, rec_len);
+          break;
+        case EOBJ__C_EDBG:
+          evax_bfd_print_etir (file, "EDBG", rec, rec_len);
+          break;
+        case EOBJ__C_ETBT:
+          evax_bfd_print_etir (file, "ETBT", rec, rec_len);
+          break;
+        default:
+          fprintf (file, _(" unhandled EOBJ record type %u\n"), type);
+          break;
+        }
+      free (rec);
+    }
+}
+
+static void
+evax_bfd_print_relocation_records (FILE *file, const unsigned char *rel,
+                                   unsigned int stride)
+{
+  while (1)
+    {
+      unsigned int base;
+      unsigned int count;
+      unsigned int j;
+
+      count = bfd_getl32 (rel + 0);
+
+      if (count == 0)
+        break;
+      base = bfd_getl32 (rel + 4);
+
+      fprintf (file, _("  bitcount: %u, base addr: 0x%08x\n"),
+               count, base);
+
+      rel += 8;
+      for (j = 0; count > 0; j += 4, count -= 32)
+        {
+          unsigned int k;
+          unsigned int n = 0;
+          unsigned int val;
+
+          val = bfd_getl32 (rel);
+          rel += 4;
+
+          fprintf (file, _("   bitmap: 0x%08x (count: %u):\n"), val, count);
+
+          for (k = 0; k < 32; k++)
+            if (val & (1 << k))
+              {
+                if (n == 0)
+                  fputs ("   ", file);
+                fprintf (file, _(" %08x"), base + (j * 8 + k) * stride);
+                n++;
+                if (n == 8)
+                  {
+                    fputs ("\n", file);
+                    n = 0;
+                  }
+              }
+          if (n)
+            fputs ("\n", file);
+        }
+    }
+}
+
+static void
+evax_bfd_print_address_fixups (FILE *file, const unsigned char *rel)
+{
+  while (1)
+    {
+      unsigned int j;
+      unsigned int count;
+
+      count = bfd_getl32 (rel + 0);
+      if (count == 0)
+        return;
+      fprintf (file, _("  image %u (%u entries)\n"),
+               (unsigned)bfd_getl32 (rel + 4), count);
+      rel += 8;
+      for (j = 0; j < count; j++)
+        {
+          fprintf (file, _("   offset: 0x%08x, val: 0x%08x\n"),
+                   (unsigned)bfd_getl32 (rel + 0),
+                   (unsigned)bfd_getl32 (rel + 4));
+          rel += 8;
+        }
+    }
+}
+
+static void
+evax_bfd_print_reference_fixups (FILE *file, const unsigned char *rel)
+{
+  unsigned int count;
+
+  while (1)
+    {
+      unsigned int j;
+      unsigned int n = 0;
+
+      count = bfd_getl32 (rel + 0);
+      if (count == 0)
+        break;
+      fprintf (file, _("  image %u (%u entries), offsets:\n"),
+               (unsigned)bfd_getl32 (rel + 4), count);
+      rel += 8;
+      for (j = 0; j < count; j++)
+        {
+          if (n == 0)
+            fputs ("   ", file);
+          fprintf (file, _(" 0x%08x"), (unsigned)bfd_getl32 (rel));
+          n++;
+          if (n == 7)
+            {
+              fputs ("\n", file);
+              n = 0;
+            }
+          rel += 4;
+        }
+      if (n)
+        fputs ("\n", file);
+    }
+}
+
+static void
+evax_bfd_print_indent (int indent, FILE *file)
+{
+  for (; indent; indent--)
+    fputc (' ', file);
+}
+
+static const char *
+evax_bfd_get_dsc_name (unsigned int v)
+{
+  switch (v)
+    {
+    case DSC__K_DTYPE_Z:
+      return "Z (Unspecified)";
+    case DSC__K_DTYPE_V:
+      return "V (Bit)";
+    case DSC__K_DTYPE_BU:
+      return "BU (Byte logical)";
+    case DSC__K_DTYPE_WU:
+      return "WU (Word logical)";
+    case DSC__K_DTYPE_LU:
+      return "LU (Longword logical)";
+    case DSC__K_DTYPE_QU:
+      return "QU (Quadword logical)";
+    case DSC__K_DTYPE_B:
+      return "B (Byte integer)";
+    case DSC__K_DTYPE_W:
+      return "W (Word integer)";
+    case DSC__K_DTYPE_L:
+      return "L (Longword integer)";
+    case DSC__K_DTYPE_Q:
+      return "Q (Quadword integer)";
+    case DSC__K_DTYPE_F:
+      return "F (Single-precision floating)";
+    case DSC__K_DTYPE_D:
+      return "D (Double-precision floating)";
+    case DSC__K_DTYPE_FC:
+      return "FC (Complex)";
+    case DSC__K_DTYPE_DC:
+      return "DC (Double-precision Complex)";
+    case DSC__K_DTYPE_T:
+      return "T (ASCII text string)";
+    case DSC__K_DTYPE_NU:
+      return "NU (Numeric string, unsigned)";
+    case DSC__K_DTYPE_NL:
+      return "NL (Numeric string, left separate sign)";
+    case DSC__K_DTYPE_NLO:
+      return "NLO (Numeric string, left overpunched sign)";
+    case DSC__K_DTYPE_NR:
+      return "NR (Numeric string, right separate sign)";
+    case DSC__K_DTYPE_NRO:
+      return "NRO (Numeric string, right overpunched sig)";
+    case DSC__K_DTYPE_NZ:
+      return "NZ (Numeric string, zoned sign)";
+    case DSC__K_DTYPE_P:
+      return "P (Packed decimal string)";
+    case DSC__K_DTYPE_ZI:
+      return "ZI (Sequence of instructions)";
+    case DSC__K_DTYPE_ZEM:
+      return "ZEM (Procedure entry mask)";
+    case DSC__K_DTYPE_DSC:
+      return "DSC (Descriptor, used for arrays of dyn strings)";
+    case DSC__K_DTYPE_OU:
+      return "OU (Octaword logical)";
+    case DSC__K_DTYPE_O:
+      return "O (Octaword integer)";
+    case DSC__K_DTYPE_G:
+      return "G (Double precision G floating, 64 bit)";
+    case DSC__K_DTYPE_H:
+      return "H (Quadruple precision floating, 128 bit)";
+    case DSC__K_DTYPE_GC:
+      return "GC (Double precision complex, G floating)";
+    case DSC__K_DTYPE_HC:
+      return "HC (Quadruple precision complex, H floating)";
+    case DSC__K_DTYPE_CIT:
+      return "CIT (COBOL intermediate temporary)";
+    case DSC__K_DTYPE_BPV:
+      return "BPV (Bound Procedure Value)";
+    case DSC__K_DTYPE_BLV:
+      return "BLV (Bound Label Value)";
+    case DSC__K_DTYPE_VU:
+      return "VU (Bit Unaligned)";
+    case DSC__K_DTYPE_ADT:
+      return "ADT (Absolute Date-Time)";
+    case DSC__K_DTYPE_VT:
+      return "VT (Varying Text)";
+    case DSC__K_DTYPE_T2:
+      return "T2 (16-bit char)";
+    case DSC__K_DTYPE_VT2:
+      return "VT2 (16-bit varying char)";
+    default:
+      return "?? (unknown)";
+    }
+}
+
+static void
+evax_bfd_print_desc (const unsigned char *buf, int indent, FILE *file)
+{
+  unsigned char bclass = buf[3];
+  unsigned char dtype = buf[2];
+  unsigned int len = (unsigned)bfd_getl16 (buf);
+  unsigned int pointer = (unsigned)bfd_getl32 (buf + 4);
+
+  evax_bfd_print_indent (indent, file);
+
+  if (len == 1 && pointer == 0xffffffffUL)
+    {
+      /* 64 bits.  */
+      fprintf (file, _("64 bits *unhandled*\n"));
+    }
+  else
+    {
+      fprintf (file, _("class: %u, dtype: %u, length: %u, pointer: 0x%08x\n"),
+               bclass, dtype, len, pointer);
+      switch (bclass)
+        {
+        case DSC__K_CLASS_NCA:
+          {
+            const struct vms_dsc_nca *dsc = (const void *)buf;
+            unsigned int i;
+            const unsigned char *b;
+
+            evax_bfd_print_indent (indent, file);
+            fprintf (file, _("non-contiguous array of %s\n"),
+                     evax_bfd_get_dsc_name (dsc->dtype));
+            evax_bfd_print_indent (indent + 1, file);
+            fprintf (file,
+                     _("dimct: %u, aflags: 0x%02x, digits: %u, scale: %u\n"),
+                     dsc->dimct, dsc->aflags, dsc->digits, dsc->scale);
+            evax_bfd_print_indent (indent + 1, file);
+            fprintf (file,
+                     _("arsize: %u, a0: 0x%08x\n"),
+                     (unsigned)bfd_getl32 (dsc->arsize),
+                     (unsigned)bfd_getl32 (dsc->a0));
+            evax_bfd_print_indent (indent + 1, file);
+            fprintf (file, _("Strides:\n"));
+            b = buf + sizeof (*dsc);
+            for (i = 0; i < dsc->dimct; i++)
+              {
+                evax_bfd_print_indent (indent + 2, file);
+                fprintf (file, _("[%u]: %u\n"), i + 1,
+                         (unsigned)bfd_getl32 (b));
+                b += 4;
+              }
+            evax_bfd_print_indent (indent + 1, file);
+            fprintf (file, _("Bounds:\n"));
+            b = buf + sizeof (*dsc);
+            for (i = 0; i < dsc->dimct; i++)
+              {
+                evax_bfd_print_indent (indent + 2, file);
+                fprintf (file, _("[%u]: Lower: %u, upper: %u\n"), i + 1,
+                         (unsigned)bfd_getl32 (b + 0),
+                         (unsigned)bfd_getl32 (b + 4));
+                b += 8;
+              }
+          }
+          break;
+        case DSC__K_CLASS_UBS:
+          {
+            const struct vms_dsc_ubs *ubs = (const void *)buf;
+
+            evax_bfd_print_indent (indent, file);
+            fprintf (file, _("unaligned bit-string of %s\n"),
+                     evax_bfd_get_dsc_name (ubs->dtype));
+            evax_bfd_print_indent (indent + 1, file);
+            fprintf (file,
+                     _("base: %u, pos: %u\n"),
+                     (unsigned)bfd_getl32 (ubs->base),
+                     (unsigned)bfd_getl32 (ubs->pos));
+          }
+          break;
+        default:
+          fprintf (file, _("*unhandled*\n"));
+          break;
+        }
+    }
+}
+
+static unsigned int
+evax_bfd_print_valspec (const unsigned char *buf, int indent, FILE *file)
+{
+  unsigned int vflags = buf[0];
+  unsigned int value = (unsigned)bfd_getl32 (buf + 1);
+  unsigned int len = 5;
+
+  evax_bfd_print_indent (indent, file);
+  fprintf (file, _("vflags: 0x%02x, value: 0x%08x "), vflags, value);
+  buf += 5;
+
+  switch (vflags)
+    {
+    case DST__K_VFLAGS_NOVAL:
+      fprintf (file, _("(no value)\n"));
+      break;
+    case DST__K_VFLAGS_NOTACTIVE:
+      fprintf (file, _("(not active)\n"));
+      break;
+    case DST__K_VFLAGS_UNALLOC:
+      fprintf (file, _("(not allocated)\n"));
+      break;
+    case DST__K_VFLAGS_DSC:
+      fprintf (file, _("(descriptor)\n"));
+      evax_bfd_print_desc (buf + value, indent + 1, file);
+      break;
+    case DST__K_VFLAGS_TVS:
+      fprintf (file, _("(trailing value)\n"));
+      break;
+    case DST__K_VS_FOLLOWS:
+      fprintf (file, _("(value spec follows)\n"));
+      break;
+    case DST__K_VFLAGS_BITOFFS:
+      fprintf (file, _("(at bit offset %u)\n"), value);
+      break;
+    default:
+      fprintf (file, _("(reg: %u, disp: %u, indir: %u, kind: "),
+               (vflags & DST__K_REGNUM_MASK) >> DST__K_REGNUM_SHIFT,
+               vflags & DST__K_DISP ? 1 : 0,
+               vflags & DST__K_INDIR ? 1 : 0);
+      switch (vflags & DST__K_VALKIND_MASK)
+        {
+        case DST__K_VALKIND_LITERAL:
+          fputs (_("literal"), file);
+          break;
+        case DST__K_VALKIND_ADDR:
+          fputs (_("address"), file);
+          break;
+        case DST__K_VALKIND_DESC:
+          fputs (_("desc"), file);
+          break;
+        case DST__K_VALKIND_REG:
+          fputs (_("reg"), file);
+          break;
+        }
+      fputs (")\n", file);
+      break;
+    }
+  return len;
+}
+
+static void
+evax_bfd_print_typspec (const unsigned char *buf, int indent, FILE *file)
+{
+  unsigned char kind = buf[2];
+  unsigned int len = (unsigned)bfd_getl16 (buf);
+
+  evax_bfd_print_indent (indent, file);
+  fprintf (file, ("len: %2u, kind: %2u "), len, kind);
+  buf += 3;
+  switch (kind)
+    {
+    case DST__K_TS_ATOM:
+      fprintf (file, ("atomic, type=0x%02x %s\n"),
+               buf[0], evax_bfd_get_dsc_name (buf[0]));
+      break;
+    case DST__K_TS_IND:
+      fprintf (file, ("indirect, defined at 0x%08x\n"),
+               (unsigned)bfd_getl32 (buf));
+      break;
+    case DST__K_TS_TPTR:
+      fprintf (file, ("typed pointer\n"));
+      evax_bfd_print_typspec (buf, indent + 1, file);
+      break;
+    case DST__K_TS_PTR:
+      fprintf (file, ("pointer\n"));
+      break;
+    case DST__K_TS_ARRAY:
+      {
+        const unsigned char *vs;
+        unsigned int vec_len;
+        unsigned int i;
+
+        fprintf (file, ("array, dim: %u, bitmap: "), buf[0]);
+        vec_len = (buf[0] + 1 + 7) / 8;
+        for (i = 0; i < vec_len; i++)
+          fprintf (file, " %02x", buf[i + 1]);
+        fputc ('\n', file);
+        vs = buf + 1 + vec_len;
+        evax_bfd_print_indent (indent, file);
+        fprintf (file, ("array descriptor:\n"));
+        vs += evax_bfd_print_valspec (vs, indent + 1, file);
+        for (i = 0; i < buf[0] + 1U; i++)
+          if (buf[1 + i / 8] & (1 << (i % 8)))
+            {
+              evax_bfd_print_indent (indent, file);
+              if (i == 0)
+                fprintf (file, ("type spec for element:\n"));
+              else
+                fprintf (file, ("type spec for subscript %u:\n"), i);
+              evax_bfd_print_typspec (vs, indent + 1, file);
+              vs += bfd_getl16 (vs);
+            }
+      }
+      break;
+    default:
+      fprintf (file, ("*unhandled*\n"));
+    }
+}
+
+static void
+evax_bfd_print_dst (struct bfd *abfd, unsigned int dst_size, FILE *file)
+{
+  unsigned int off = 0;
+  unsigned int pc = 0;
+  unsigned int line = 0;
+
+  fprintf (file, _("Debug symbol table:\n"));
+
+  while (dst_size > 0)
+    {
+      struct vms_dst_header dsth;
+      unsigned int len;
+      unsigned int type;
+      unsigned char *buf;
+
+      if (bfd_bread (&dsth, sizeof (dsth), abfd) != sizeof (dsth))
+        {
+          fprintf (file, _("cannot read DST header\n"));
+          return;
+        }
+      len = bfd_getl16 (dsth.length);
+      type = bfd_getl16 (dsth.type);
+      fprintf (file, _(" type: %3u, len: %3u (at 0x%08x): "),
+               type, len, off);
+      if (len == 0)
+        {
+          fputc ('\n', file);
+          break;
+        }
+      len++;
+      dst_size -= len;
+      off += len;
+      len -= sizeof (dsth);
+      buf = bfd_malloc (len);
+      if (bfd_bread (buf, len, abfd) != len)
+        {
+          fprintf (file, _("cannot read DST symbol\n"));
+          return;
+        }
+      switch (type)
+        {
+        case DSC__K_DTYPE_V:
+        case DSC__K_DTYPE_BU:
+        case DSC__K_DTYPE_WU:
+        case DSC__K_DTYPE_LU:
+        case DSC__K_DTYPE_QU:
+        case DSC__K_DTYPE_B:
+        case DSC__K_DTYPE_W:
+        case DSC__K_DTYPE_L:
+        case DSC__K_DTYPE_Q:
+        case DSC__K_DTYPE_F:
+        case DSC__K_DTYPE_D:
+        case DSC__K_DTYPE_FC:
+        case DSC__K_DTYPE_DC:
+        case DSC__K_DTYPE_T:
+        case DSC__K_DTYPE_NU:
+        case DSC__K_DTYPE_NL:
+        case DSC__K_DTYPE_NLO:
+        case DSC__K_DTYPE_NR:
+        case DSC__K_DTYPE_NRO:
+        case DSC__K_DTYPE_NZ:
+        case DSC__K_DTYPE_P:
+        case DSC__K_DTYPE_ZI:
+        case DSC__K_DTYPE_ZEM:
+        case DSC__K_DTYPE_DSC:
+        case DSC__K_DTYPE_OU:
+        case DSC__K_DTYPE_O:
+        case DSC__K_DTYPE_G:
+        case DSC__K_DTYPE_H:
+        case DSC__K_DTYPE_GC:
+        case DSC__K_DTYPE_HC:
+        case DSC__K_DTYPE_CIT:
+        case DSC__K_DTYPE_BPV:
+        case DSC__K_DTYPE_BLV:
+        case DSC__K_DTYPE_VU:
+        case DSC__K_DTYPE_ADT:
+        case DSC__K_DTYPE_VT:
+        case DSC__K_DTYPE_T2:
+        case DSC__K_DTYPE_VT2:
+          fprintf (file, _("standard data: %s\n"),
+                   evax_bfd_get_dsc_name (type));
+          evax_bfd_print_valspec (buf, 4, file);
+          fprintf (file, _("    name: %.*s\n"), buf[5], buf + 6);
+          break;
+        case DST__K_MODBEG:
+          {
+            struct vms_dst_modbeg *dst = (void *)buf;
+            const char *name = (const char *)buf + sizeof (*dst);
+
+            fprintf (file, _("modbeg\n"));
+            fprintf (file, _("   flags: %d, language: %u, "
+                             "major: %u, minor: %u\n"),
+                     dst->flags,
+                     (unsigned)bfd_getl32 (dst->language),
+                     (unsigned)bfd_getl16 (dst->major),
+                     (unsigned)bfd_getl16 (dst->minor));
+            fprintf (file, _("   module name: %.*s\n"),
+                     name[0], name + 1);
+            name += name[0] + 1;
+            fprintf (file, _("   compiler   : %.*s\n"),
+                     name[0], name + 1);
+          }
+          break;
+        case DST__K_MODEND:
+          fprintf (file, _("modend\n"));
+          break;
+        case DST__K_RTNBEG:
+          {
+            struct vms_dst_rtnbeg *dst = (void *)buf;
+            const char *name = (const char *)buf + sizeof (*dst);
+
+            fputs (_("rtnbeg\n"), file);
+            fprintf (file, _("    flags: %u, address: 0x%08x, "
+                             "pd-address: 0x%08x\n"),
+                     dst->flags,
+                     (unsigned)bfd_getl32 (dst->address),
+                     (unsigned)bfd_getl32 (dst->pd_address));
+            fprintf (file, _("    routine name: %.*s\n"),
+                     name[0], name + 1);
+          }
+          break;
+        case DST__K_RTNEND:
+          {
+            struct vms_dst_rtnend *dst = (void *)buf;
+
+            fprintf (file, _("rtnend: size 0x%08x\n"),
+                     (unsigned)bfd_getl32 (dst->size));
+          }
+          break;
+        case DST__K_PROLOG:
+          {
+            struct vms_dst_prolog *dst = (void *)buf;
+
+            fprintf (file, _("prolog: bkpt address 0x%08x\n"),
+                     (unsigned)bfd_getl32 (dst->bkpt_addr));
+          }
+          break;
+        case DST__K_EPILOG:
+          {
+            struct vms_dst_epilog *dst = (void *)buf;
+
+            fprintf (file, _("epilog: flags: %u, count: %u\n"),
+                     dst->flags, (unsigned)bfd_getl32 (dst->count));
+          }
+          break;
+        case DST__K_BLKBEG:
+          {
+            struct vms_dst_blkbeg *dst = (void *)buf;
+            const char *name = (const char *)buf + sizeof (*dst);
+
+            fprintf (file, _("blkbeg: address: 0x%08x, name: %.*s\n"),
+                     (unsigned)bfd_getl32 (dst->address),
+                     name[0], name + 1);
+          }
+          break;
+        case DST__K_BLKEND:
+          {
+            struct vms_dst_blkend *dst = (void *)buf;
+
+            fprintf (file, _("blkend: size: 0x%08x\n"),
+                     (unsigned)bfd_getl32 (dst->size));
+          }
+          break;
+        case DST__K_TYPSPEC:
+          {
+            fprintf (file, _("typspec (len: %u)\n"), len);
+            fprintf (file, _("    name: %.*s\n"), buf[0], buf + 1);
+            evax_bfd_print_typspec (buf + 1 + buf[0], 5, file);
+          }
+          break;
+        case DST__K_SEPTYP:
+          {
+            fprintf (file, _("septyp, name: %.*s\n"), buf[5], buf + 6);
+            evax_bfd_print_valspec (buf, 4, file);
+          }
+          break;
+        case DST__K_RECBEG:
+          {
+            struct vms_dst_recbeg *recbeg = (void *)buf;
+            const char *name = (const char *)buf + sizeof (*recbeg);
+
+            fprintf (file, _("recbeg: name: %.*s\n"), name[0], name + 1);
+            evax_bfd_print_valspec (buf, 4, file);
+            fprintf (file, ("    len: %u bits\n"),
+                     (unsigned)bfd_getl32 (name + 1 + name[0]));
+          }
+          break;
+        case DST__K_RECEND:
+          fprintf (file, _("recend\n"));
+          break;
+        case DST__K_ENUMBEG:
+          fprintf (file, _("enumbeg, len: %u, name: %.*s\n"),
+                   buf[0], buf[1], buf + 2);
+          break;
+        case DST__K_ENUMELT:
+          fprintf (file, _("enumelt, name: %.*s\n"), buf[5], buf + 6);
+          evax_bfd_print_valspec (buf, 4, file);
+          break;
+        case DST__K_ENUMEND:
+          fprintf (file, _("enumend\n"));
+          break;
+        case DST__K_LABEL:
+          {
+            struct vms_dst_label *lab = (void *)buf;
+            fprintf (file, ("label, name: %.*s\n"),
+                     lab->name[0], lab->name + 1);
+            fprintf (file, ("    address: 0x%08x\n"),
+                     (unsigned)bfd_getl32 (lab->value));
+          }
+          break;
+        case DST__K_DIS_RANGE:
+          {
+            unsigned int cnt = bfd_getl32 (buf);
+            unsigned char *rng = buf + 4;
+            unsigned int i;
+
+            fprintf (file, _("discontiguous range (nbr: %u)\n"), cnt);
+            for (i = 0; i < cnt; i++, rng += 8)
+              fprintf (file, _("    address: 0x%08x, size: %u\n"),
+                       (unsigned)bfd_getl32 (rng),
+                       (unsigned)bfd_getl32 (rng + 4));
+
+          }
+          break;
+        case DST__K_LINE_NUM:
+          {
+            unsigned char *buf_orig = buf;
+
+            fprintf (file, _("line num  (len: %u)\n"), len);
+
+            while (len > 0)
+              {
+                signed char cmd;
+                unsigned char cmdlen;
+                unsigned int val;
+
+                cmd = buf[0];
+                cmdlen = 0;
+
+                fputs ("    ", file);
+
+                switch (cmd)
+                  {
+                  case DST__K_DELTA_PC_W:
+                    val = bfd_getl16 (buf + 1);
+                    fprintf (file, _("delta_pc_w %u\n"), val);
+                    pc += val;
+                    line++;
+                    cmdlen = 3;
+                    break;
+                  case DST__K_INCR_LINUM:
+                    val = buf[1];
+                    fprintf (file, _("incr_linum: +%u\n"), val);
+                    line += val;
+                    cmdlen = 2;
+                    break;
+                  case DST__K_INCR_LINUM_W:
+                    val = bfd_getl16 (buf + 1);
+                    fprintf (file, _("incr_linum: +%u\n"), val);
+                    line += val;
+                    cmdlen = 3;
+                    break;
+                  case DST__K_SET_LINUM:
+                    line = (unsigned)bfd_getl16 (buf + 1);
+                    fprintf (file, _("set_line_num %u\n"), line);
+                    cmdlen = 3;
+                    break;
+                  case DST__K_SET_LINUM_B:
+                    line = buf[1];
+                    fprintf (file, _("set_line_num_b %u\n"), line);
+                    cmdlen = 2;
+                    break;
+                  case DST__K_SET_LINUM_L:
+                    line = (unsigned)bfd_getl32 (buf + 1);
+                    fprintf (file, _("set_line_num_l %u\n"), line);
+                    cmdlen = 5;
+                    break;
+                  case DST__K_SET_ABS_PC:
+                    pc = (unsigned)bfd_getl32 (buf + 1);
+                    fprintf (file, _("set_abs_pc: 0x%08x\n"), pc);
+                    cmdlen = 5;
+                    break;
+                  case DST__K_DELTA_PC_L:
+                    fprintf (file, _("delta_pc_l: +0x%08x\n"),
+                             (unsigned)bfd_getl32 (buf + 1));
+                    cmdlen = 5;
+                    break;
+                  case DST__K_TERM:
+                    fprintf (file, _("term: 0x%02x"), buf[1]);
+                    pc += buf[1];
+                    fprintf (file, _("        pc: 0x%08x\n"), pc);
+                    cmdlen = 2;
+                    break;
+                  case DST__K_TERM_W:
+                    val = bfd_getl16 (buf + 1);
+                    fprintf (file, _("term_w: 0x%04x"), val);
+                    pc += val;
+                    fprintf (file, _("    pc: 0x%08x\n"), pc);
+                    cmdlen = 3;
+                    break;
+                  default:
+                    if (cmd <= 0)
+                      {
+                        fprintf (file, _("delta pc +%-4d"), -cmd);
+                        line++;  /* FIXME: curr increment.  */
+                        pc += -cmd;
+                        fprintf (file, _("    pc: 0x%08x line: %5u\n"),
+                                 pc, line);
+                        cmdlen = 1;
+                      }
+                    else
+                      fprintf (file, _("    *unhandled* cmd %u\n"), cmd);
+                    break;
+                  }
+                if (cmdlen == 0)
+                  break;
+                len -= cmdlen;
+                buf += cmdlen;
+              }
+            buf = buf_orig;
+          }
+          break;
+        case DST__K_SOURCE:
+          {
+            unsigned char *buf_orig = buf;
+
+            fprintf (file, _("source (len: %u)\n"), len);
+
+            while (len > 0)
+              {
+                signed char cmd = buf[0];
+                unsigned char cmdlen = 0;
+
+                switch (cmd)
+                  {
+                  case DST__K_SRC_DECLFILE:
+                    {
+                      struct vms_dst_src_decl_src *src = (void *)(buf + 1);
+                      const char *name;
+
+                      fprintf (file, _("   declfile: len: %u, flags: %u, "
+                                       "fileid: %u\n"),
+                               src->length, src->flags,
+                               (unsigned)bfd_getl16 (src->fileid));
+                      fprintf (file, _("   rms: cdt: 0x%08x %08x, "
+                                       "ebk: 0x%08x, ffb: 0x%04x, "
+                                       "rfo: %u\n"),
+                               (unsigned)bfd_getl32 (src->rms_cdt + 4),
+                               (unsigned)bfd_getl32 (src->rms_cdt + 0),
+                               (unsigned)bfd_getl32 (src->rms_ebk),
+                               (unsigned)bfd_getl16 (src->rms_ffb),
+                               src->rms_rfo);
+                      name = (const char *)buf + 1 + sizeof (*src);
+                      fprintf (file, _("   filename   : %.*s\n"),
+                               name[0], name + 1);
+                      name += name[0] + 1;
+                      fprintf (file, _("   module name: %.*s\n"),
+                               name[0], name + 1);
+                      cmdlen = 2 + src->length;
+                    }
+                    break;
+                  case DST__K_SRC_SETFILE:
+                    fprintf (file, _("   setfile %u\n"),
+                             (unsigned)bfd_getl16 (buf + 1));
+                    cmdlen = 3;
+                    break;
+                  case DST__K_SRC_SETREC_W:
+                    fprintf (file, _("   setrec %u\n"),
+                             (unsigned)bfd_getl16 (buf + 1));
+                    cmdlen = 3;
+                    break;
+                  case DST__K_SRC_SETREC_L:
+                    fprintf (file, _("   setrec %u\n"),
+                             (unsigned)bfd_getl32 (buf + 1));
+                    cmdlen = 5;
+                    break;
+                  case DST__K_SRC_SETLNUM_W:
+                    fprintf (file, _("   setlnum %u\n"),
+                             (unsigned)bfd_getl16 (buf + 1));
+                    cmdlen = 3;
+                    break;
+                  case DST__K_SRC_SETLNUM_L:
+                    fprintf (file, _("   setlnum %u\n"),
+                             (unsigned)bfd_getl32 (buf + 1));
+                    cmdlen = 5;
+                    break;
+                  case DST__K_SRC_DEFLINES_W:
+                    fprintf (file, _("   deflines %u\n"),
+                             (unsigned)bfd_getl16 (buf + 1));
+                    cmdlen = 3;
+                    break;
+                  case DST__K_SRC_DEFLINES_B:
+                    fprintf (file, _("   deflines %u\n"), buf[1]);
+                    cmdlen = 2;
+                    break;
+                  case DST__K_SRC_FORMFEED:
+                    fprintf (file, _("   formfeed\n"));
+                    cmdlen = 1;
+                    break;
+                  default:
+                    fprintf (file, _("   *unhandled* cmd %u\n"), cmd);
+                    break;
+                  }
+                if (cmdlen == 0)
+                  break;
+                len -= cmdlen;
+                buf += cmdlen;
+              }
+            buf = buf_orig;
+          }
+          break;
+        default:
+          fprintf (file, _("*unhandled* dst type %u\n"), type);
+          break;
+        }
+      free (buf);
+    }
+}
+
+static void
+evax_bfd_print_image (bfd *abfd, FILE *file)
+{
+  struct vms_eihd eihd;
+  const char *name;
+  unsigned int val;
+  unsigned int eiha_off;
+  unsigned int eihi_off;
+  unsigned int eihs_off;
+  unsigned int eisd_off;
+  unsigned int eihef_off = 0;
+  unsigned int eihnp_off = 0;
+  unsigned int dmt_vbn = 0;
+  unsigned int dmt_size = 0;
+  unsigned int dst_vbn = 0;
+  unsigned int dst_size = 0;
+  unsigned int gst_vbn = 0;
+  unsigned int gst_size = 0;
+  unsigned int eiaf_vbn = 0;
+  unsigned int eiaf_size = 0;
+  unsigned int eihvn_off;
+
+  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET)
+      || bfd_bread (&eihd, sizeof (eihd), abfd) != sizeof (eihd))
+    {
+      fprintf (file, _("cannot read EIHD\n"));
+      return;
+    }
+  fprintf (file, _("EIHD: (size: %u, nbr blocks: %u)\n"),
+           (unsigned)bfd_getl32 (eihd.size),
+           (unsigned)bfd_getl32 (eihd.hdrblkcnt));
+  fprintf (file, _(" majorid: %u, minorid: %u\n"),
+           (unsigned)bfd_getl32 (eihd.majorid),
+           (unsigned)bfd_getl32 (eihd.minorid));
+
+  val = (unsigned)bfd_getl32 (eihd.imgtype);
+  switch (val)
+    {
+    case EIHD__K_EXE:
+      name = _("executable");
+      break;
+    case EIHD__K_LIM:
+      name = _("linkable image");
+      break;
+    default:
+      name = _("unknown");
+      break;
+    }
+  fprintf (file, _(" image type: %u (%s)"), val, name);
+
+  val = (unsigned)bfd_getl32 (eihd.subtype);
+  switch (val)
+    {
+    case EIHD__C_NATIVE:
+      name = _("native");
+      break;
+    case EIHD__C_CLI:
+      name = _("CLI");
+      break;
+    default:
+      name = _("unknown");
+      break;
+    }
+  fprintf (file, _(", subtype: %u (%s)\n"), val, name);
+
+  eisd_off = bfd_getl32 (eihd.isdoff);
+  eiha_off = bfd_getl32 (eihd.activoff);
+  eihi_off = bfd_getl32 (eihd.imgidoff);
+  eihs_off = bfd_getl32 (eihd.symdbgoff);
+  fprintf (file, _(" offsets: isd: %u, activ: %u, symdbg: %u, "
+                   "imgid: %u, patch: %u\n"),
+           eisd_off, eiha_off, eihs_off, eihi_off,
+           (unsigned)bfd_getl32 (eihd.patchoff));
+  fprintf (file, _(" fixup info rva: "));
+  bfd_fprintf_vma (abfd, file, bfd_getl64 (eihd.iafva));
+  fprintf (file, _(", symbol vector rva: "));
+  bfd_fprintf_vma (abfd, file, bfd_getl64 (eihd.symvva));
+  eihvn_off = bfd_getl32 (eihd.version_array_off);
+  fprintf (file, _("\n"
+                   " version array off: %u\n"),
+           eihvn_off);
+  fprintf (file,
+           _(" img I/O count: %u, nbr channels: %u, req pri: %08x%08x\n"),
+           (unsigned)bfd_getl32 (eihd.imgiocnt),
+           (unsigned)bfd_getl32 (eihd.iochancnt),
+           (unsigned)bfd_getl32 (eihd.privreqs + 4),
+           (unsigned)bfd_getl32 (eihd.privreqs + 0));
+  val = (unsigned)bfd_getl32 (eihd.lnkflags);
+  fprintf (file, _(" linker flags: %08x:"), val);
+  if (val & EIHD__M_LNKDEBUG)
+    fprintf (file, " LNKDEBUG");
+  if (val & EIHD__M_LNKNOTFR)
+    fprintf (file, " LNKNOTFR");
+  if (val & EIHD__M_NOP0BUFS)
+    fprintf (file, " NOP0BUFS");
+  if (val & EIHD__M_PICIMG)
+    fprintf (file, " PICIMG");
+  if (val & EIHD__M_P0IMAGE)
+    fprintf (file, " P0IMAGE");
+  if (val & EIHD__M_DBGDMT)
+    fprintf (file, " DBGDMT");
+  if (val & EIHD__M_INISHR)
+    fprintf (file, " INISHR");
+  if (val & EIHD__M_XLATED)
+    fprintf (file, " XLATED");
+  if (val & EIHD__M_BIND_CODE_SEC)
+    fprintf (file, " BIND_CODE_SEC");
+  if (val & EIHD__M_BIND_DATA_SEC)
+    fprintf (file, " BIND_DATA_SEC");
+  if (val & EIHD__M_MKTHREADS)
+    fprintf (file, " MKTHREADS");
+  if (val & EIHD__M_UPCALLS)
+    fprintf (file, " UPCALLS");
+  if (val & EIHD__M_OMV_READY)
+    fprintf (file, " OMV_READY");
+  if (val & EIHD__M_EXT_BIND_SECT)
+    fprintf (file, " EXT_BIND_SECT");
+  fprintf (file, "\n");
+  fprintf (file, _(" ident: 0x%08x, sysver: 0x%08x, "
+                   "match ctrl: %u, symvect_size: %u\n"),
+           (unsigned)bfd_getl32 (eihd.ident),
+           (unsigned)bfd_getl32 (eihd.sysver),
+           eihd.matchctl,
+           (unsigned)bfd_getl32 (eihd.symvect_size));
+  fprintf (file, _(" BPAGE: %u"),
+           (unsigned)bfd_getl32 (eihd.virt_mem_block_size));
+  if (val & (EIHD__M_OMV_READY | EIHD__M_EXT_BIND_SECT))
+    {
+      eihef_off = bfd_getl32 (eihd.ext_fixup_off);
+      eihnp_off = bfd_getl32 (eihd.noopt_psect_off);
+      fprintf (file, _(", ext fixup offset: %u, no_opt psect off: %u"),
+               eihef_off, eihnp_off);
+    }
+  fprintf (file, _(", alias: %u\n"), (unsigned)bfd_getl16 (eihd.alias));
+
+  if (eihvn_off != 0)
+    {
+      struct vms_eihvn eihvn;
+      unsigned int mask;
+      unsigned int j;
+
+      fprintf (file, _("system version array information:\n"));
+      if (bfd_seek (abfd, (file_ptr) eihvn_off, SEEK_SET)
+          || bfd_bread (&eihvn, sizeof (eihvn), abfd) != sizeof (eihvn))
+        {
+          fprintf (file, _("cannot read EIHVN header\n"));
+          return;
+        }
+      mask = bfd_getl32 (eihvn.subsystem_mask);
+      for (j = 0; j < 32; j++)
+        if (mask & (1 << j))
+          {
+            struct vms_eihvn_subversion ver;
+            if (bfd_bread (&ver, sizeof (ver), abfd) != sizeof (ver))
+              {
+                fprintf (file, _("cannot read EIHVN version\n"));
+                return;
+              }
+            fprintf (file, _("   %02u "), j);
+            switch (j)
+              {
+              case EIHVN__BASE_IMAGE_BIT:
+		fputs (_("BASE_IMAGE       "), file);
+                break;
+              case EIHVN__MEMORY_MANAGEMENT_BIT:
+                fputs (_("MEMORY_MANAGEMENT"), file);
+                break;
+              case EIHVN__IO_BIT:
+                fputs (_("IO               "), file);
+                break;
+              case EIHVN__FILES_VOLUMES_BIT:
+                fputs (_("FILES_VOLUMES    "), file);
+                break;
+              case EIHVN__PROCESS_SCHED_BIT:
+                fputs (_("PROCESS_SCHED    "), file);
+                break;
+              case EIHVN__SYSGEN_BIT:
+		fputs (_("SYSGEN           "), file);
+                break;
+              case EIHVN__CLUSTERS_LOCKMGR_BIT:
+                fputs (_("CLUSTERS_LOCKMGR "), file);
+                break;
+              case EIHVN__LOGICAL_NAMES_BIT:
+                fputs (_("LOGICAL_NAMES    "), file);
+                break;
+              case EIHVN__SECURITY_BIT:
+		fputs (_("SECURITY         "), file);
+                break;
+              case EIHVN__IMAGE_ACTIVATOR_BIT:
+                fputs (_("IMAGE_ACTIVATOR  "), file);
+                break;
+              case EIHVN__NETWORKS_BIT:
+		fputs (_("NETWORKS         "), file);
+                break;
+              case EIHVN__COUNTERS_BIT:
+		fputs (_("COUNTERS         "), file);
+                break;
+              case EIHVN__STABLE_BIT:
+		fputs (_("STABLE           "), file);
+                break;
+              case EIHVN__MISC_BIT:
+                fputs (_("MISC             "), file);
+                break;
+              case EIHVN__CPU_BIT:
+                fputs (_("CPU              "), file);
+                break;
+              case EIHVN__VOLATILE_BIT:
+		fputs (_("VOLATILE         "), file);
+                break;
+              case EIHVN__SHELL_BIT:
+		fputs (_("SHELL            "), file);
+                break;
+              case EIHVN__POSIX_BIT:
+		fputs (_("POSIX            "), file);
+                break;
+              case EIHVN__MULTI_PROCESSING_BIT:
+                fputs (_("MULTI_PROCESSING "), file);
+                break;
+              case EIHVN__GALAXY_BIT:
+		fputs (_("GALAXY           "), file);
+                break;
+              default:
+                fputs (_("*unknown*        "), file);
+                break;
+              }
+            fprintf (file, _(": %u.%u\n"),
+                     (unsigned)bfd_getl16 (ver.major),
+                     (unsigned)bfd_getl16 (ver.minor));
+          }
+    }
+
+  if (eiha_off != 0)
+    {
+      struct vms_eiha eiha;
+
+      if (bfd_seek (abfd, (file_ptr) eiha_off, SEEK_SET)
+          || bfd_bread (&eiha, sizeof (eiha), abfd) != sizeof (eiha))
+        {
+          fprintf (file, _("cannot read EIHA\n"));
+          return;
+        }
+      fprintf (file, _("Image activation:  (size=%u)\n"),
+               (unsigned)bfd_getl32 (eiha.size));
+      fprintf (file, _(" First address : 0x%08x 0x%08x\n"),
+               (unsigned)bfd_getl32 (eiha.tfradr1_h),
+               (unsigned)bfd_getl32 (eiha.tfradr1));
+      fprintf (file, _(" Second address: 0x%08x 0x%08x\n"),
+               (unsigned)bfd_getl32 (eiha.tfradr2_h),
+               (unsigned)bfd_getl32 (eiha.tfradr2));
+      fprintf (file, _(" Third address : 0x%08x 0x%08x\n"),
+               (unsigned)bfd_getl32 (eiha.tfradr3_h),
+               (unsigned)bfd_getl32 (eiha.tfradr3));
+      fprintf (file, _(" Fourth address: 0x%08x 0x%08x\n"),
+               (unsigned)bfd_getl32 (eiha.tfradr4_h),
+               (unsigned)bfd_getl32 (eiha.tfradr4));
+      fprintf (file, _(" Shared image  : 0x%08x 0x%08x\n"),
+               (unsigned)bfd_getl32 (eiha.inishr_h),
+               (unsigned)bfd_getl32 (eiha.inishr));
+    }
+  if (eihi_off != 0)
+    {
+      struct vms_eihi eihi;
+
+      if (bfd_seek (abfd, (file_ptr) eihi_off, SEEK_SET)
+          || bfd_bread (&eihi, sizeof (eihi), abfd) != sizeof (eihi))
+        {
+          fprintf (file, _("cannot read EIHI\n"));
+          return;
+        }
+      fprintf (file, _("Image identification: (major: %u, minor: %u)\n"),
+               (unsigned)bfd_getl32 (eihi.majorid),
+               (unsigned)bfd_getl32 (eihi.minorid));
+      fprintf (file, _(" image name       : %.*s\n"),
+               eihi.imgnam[0], eihi.imgnam + 1);
+      fprintf (file, _(" link time        : %s\n"),
+               vms_time_to_str (eihi.linktime));
+      fprintf (file, _(" image ident      : %.*s\n"),
+               eihi.imgid[0], eihi.imgid + 1);
+      fprintf (file, _(" linker ident     : %.*s\n"),
+               eihi.linkid[0], eihi.linkid + 1);
+      fprintf (file, _(" image build ident: %.*s\n"),
+               eihi.imgbid[0], eihi.imgbid + 1);
+    }
+  if (eihs_off != 0)
+    {
+      struct vms_eihs eihs;
+
+      if (bfd_seek (abfd, (file_ptr) eihs_off, SEEK_SET)
+          || bfd_bread (&eihs, sizeof (eihs), abfd) != sizeof (eihs))
+        {
+          fprintf (file, _("cannot read EIHS\n"));
+          return;
+        }
+      fprintf (file, _("Image symbol & debug table: (major: %u, minor: %u)\n"),
+               (unsigned)bfd_getl32 (eihs.majorid),
+               (unsigned)bfd_getl32 (eihs.minorid));
+      dst_vbn = bfd_getl32 (eihs.dstvbn);
+      dst_size = bfd_getl32 (eihs.dstsize);
+      fprintf (file, _(" debug symbol table : vbn: %u, size: %u\n"),
+               dst_vbn, dst_size);
+      gst_vbn = bfd_getl32 (eihs.gstvbn);
+      gst_size = bfd_getl32 (eihs.gstsize);
+      fprintf (file, _(" global symbol table: vbn: %u, records: %u\n"),
+               gst_vbn, gst_size);
+      dmt_vbn = bfd_getl32 (eihs.dmtvbn);
+      dmt_size = bfd_getl32 (eihs.dmtsize);
+      fprintf (file, _(" debug module table : vbn: %u, size: %u\n"),
+               dmt_vbn, dmt_size);
+    }
+  while (eisd_off != 0)
+    {
+      struct vms_eisd eisd;
+      unsigned int len;
+
+      while (1)
+        {
+          if (bfd_seek (abfd, (file_ptr) eisd_off, SEEK_SET)
+              || bfd_bread (&eisd, sizeof (eisd), abfd) != sizeof (eisd))
+            {
+              fprintf (file, _("cannot read EISD\n"));
+              return;
+            }
+          len = (unsigned)bfd_getl32 (eisd.eisdsize);
+          if (len != (unsigned)-1)
+            break;
+
+          /* Next block.  */
+          eisd_off = (eisd_off + VMS_BLOCK_SIZE) & ~(VMS_BLOCK_SIZE - 1);
+        }
+      fprintf (file, _("Image section descriptor: (major: %u, minor: %u, "
+                       "size: %u, offset: %u)\n"),
+               (unsigned)bfd_getl32 (eisd.majorid),
+               (unsigned)bfd_getl32 (eisd.minorid),
+               len, eisd_off);
+      if (len == 0)
+        break;
+      fprintf (file, _(" section: base: 0x%08x%08x size: 0x%08x\n"),
+               (unsigned)bfd_getl32 (eisd.virt_addr + 4),
+               (unsigned)bfd_getl32 (eisd.virt_addr + 0),
+               (unsigned)bfd_getl32 (eisd.secsize));
+      val = (unsigned)bfd_getl32 (eisd.flags);
+      fprintf (file, _(" flags: 0x%04x"), val);
+      if (val & EISD__M_GBL)
+        fprintf (file, " GBL");
+      if (val & EISD__M_CRF)
+        fprintf (file, " CRF");
+      if (val & EISD__M_DZRO)
+        fprintf (file, " DZRO");
+      if (val & EISD__M_WRT)
+        fprintf (file, " WRT");
+      if (val & EISD__M_INITALCODE)
+	fprintf (file, " INITALCODE");
+      if (val & EISD__M_BASED)
+        fprintf (file, " BASED");
+      if (val & EISD__M_FIXUPVEC)
+	fprintf (file, " FIXUPVEC");
+      if (val & EISD__M_RESIDENT)
+	fprintf (file, " RESIDENT");
+      if (val & EISD__M_VECTOR)
+        fprintf (file, " VECTOR");
+      if (val & EISD__M_PROTECT)
+	fprintf (file, " PROTECT");
+      if (val & EISD__M_LASTCLU)
+	fprintf (file, " LASTCLU");
+      if (val & EISD__M_EXE)
+        fprintf (file, " EXE");
+      if (val & EISD__M_NONSHRADR)
+	fprintf (file, " NONSHRADR");
+      if (val & EISD__M_QUAD_LENGTH)
+	fprintf (file, " QUAD_LENGTH");
+      if (val & EISD__M_ALLOC_64BIT)
+	fprintf (file, " ALLOC_64BIT");
+      fprintf (file, "\n");
+      if (val & EISD__M_FIXUPVEC)
+        {
+          eiaf_vbn = bfd_getl32 (eisd.vbn);
+          eiaf_size = bfd_getl32 (eisd.secsize);
+        }
+      fprintf (file, _(" vbn: %u, pfc: %u, matchctl: %u type: %u ("),
+               (unsigned)bfd_getl32 (eisd.vbn),
+               eisd.pfc, eisd.matchctl, eisd.type);
+      switch (eisd.type)
+        {
+        case EISD__K_NORMAL:
+          fputs (_("NORMAL"), file);
+          break;
+        case EISD__K_SHRFXD:
+          fputs (_("SHRFXD"), file);
+          break;
+        case EISD__K_PRVFXD:
+          fputs (_("PRVFXD"), file);
+          break;
+        case EISD__K_SHRPIC:
+          fputs (_("SHRPIC"), file);
+          break;
+        case EISD__K_PRVPIC:
+          fputs (_("PRVPIC"), file);
+          break;
+        case EISD__K_USRSTACK:
+          fputs (_("USRSTACK"), file);
+          break;
+        default:
+          fputs (_("*unknown*"), file);
+          break;
+        }
+      fputs (_(")\n"), file);
+      if (val & EISD__M_GBL)
+        fprintf (file, _(" ident: 0x%08x, name: %.*s\n"),
+                 (unsigned)bfd_getl32 (eisd.ident),
+                 eisd.gblnam[0], eisd.gblnam + 1);
+      eisd_off += len;
+    }
+
+  if (dmt_vbn != 0)
+    {
+      if (bfd_seek (abfd, (file_ptr) (dmt_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET))
+        {
+          fprintf (file, _("cannot read DMT\n"));
+          return;
+        }
+
+      fprintf (file, _("Debug module table:\n"));
+
+      while (dmt_size > 0)
+        {
+          struct vms_dmt_header dmth;
+          unsigned int count;
+
+          if (bfd_bread (&dmth, sizeof (dmth), abfd) != sizeof (dmth))
+            {
+              fprintf (file, _("cannot read DMT header\n"));
+              return;
+            }
+          count = bfd_getl16 (dmth.psect_count);
+          fprintf (file,
+                   _(" module address: 0x%08x, size: 0x%08x, (%u psect)\n"),
+                   (unsigned)bfd_getl32 (dmth.modbeg),
+                   (unsigned)bfd_getl32 (dmth.size), count);
+          dmt_size -= sizeof (dmth);
+          while (count > 0)
+            {
+              struct vms_dmt_psect dmtp;
+
+              if (bfd_bread (&dmtp, sizeof (dmtp), abfd) != sizeof (dmtp))
+                {
+                  fprintf (file, _("cannot read DMT psect\n"));
+                  return;
+                }
+              fprintf (file, _("  psect start: 0x%08x, length: %u\n"),
+                       (unsigned)bfd_getl32 (dmtp.start),
+                       (unsigned)bfd_getl32 (dmtp.length));
+              count--;
+              dmt_size -= sizeof (dmtp);
+            }
+        }
+    }
+
+  if (dst_vbn != 0)
+    {
+      if (bfd_seek (abfd, (file_ptr) (dst_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET))
+        {
+          fprintf (file, _("cannot read DST\n"));
+          return;
+        }
+
+      evax_bfd_print_dst (abfd, dst_size, file);
+    }
+  if (gst_vbn != 0)
+    {
+      if (bfd_seek (abfd, (file_ptr) (gst_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET))
+        {
+          fprintf (file, _("cannot read GST\n"));
+          return;
+        }
+
+      fprintf (file, _("Global symbol table:\n"));
+      evax_bfd_print_eobj (abfd, file);
+    }
+  if (eiaf_vbn != 0)
+    {
+      unsigned char *buf;
+      struct vms_eiaf *eiaf;
+      unsigned int qrelfixoff;
+      unsigned int lrelfixoff;
+      unsigned int qdotadroff;
+      unsigned int ldotadroff;
+      unsigned int shrimgcnt;
+      unsigned int shlstoff;
+      unsigned int codeadroff;
+      unsigned int lpfixoff;
+      unsigned int chgprtoff;
+
+      buf = bfd_malloc (eiaf_size);
+
+      if (bfd_seek (abfd, (file_ptr) (eiaf_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET)
+          || bfd_bread (buf, eiaf_size, abfd) != eiaf_size)
+        {
+          fprintf (file, _("cannot read EIHA\n"));
+          free (buf);
+          return;
+        }
+      eiaf = (struct vms_eiaf *)buf;
+      fprintf (file,
+               _("Image activator fixup: (major: %u, minor: %u)\n"),
+               (unsigned)bfd_getl32 (eiaf->majorid),
+               (unsigned)bfd_getl32 (eiaf->minorid));
+      fprintf (file, _("  iaflink : 0x%08x %08x\n"),
+               (unsigned)bfd_getl32 (eiaf->iaflink + 0),
+               (unsigned)bfd_getl32 (eiaf->iaflink + 4));
+      fprintf (file, _("  fixuplnk: 0x%08x %08x\n"),
+               (unsigned)bfd_getl32 (eiaf->fixuplnk + 0),
+               (unsigned)bfd_getl32 (eiaf->fixuplnk + 4));
+      fprintf (file, _("  size : %u\n"),
+               (unsigned)bfd_getl32 (eiaf->size));
+      fprintf (file, _("  flags: 0x%08x\n"),
+               (unsigned)bfd_getl32 (eiaf->flags));
+      qrelfixoff = bfd_getl32 (eiaf->qrelfixoff);
+      lrelfixoff = bfd_getl32 (eiaf->lrelfixoff);
+      fprintf (file, _("  qrelfixoff: %5u, lrelfixoff: %5u\n"),
+               qrelfixoff, lrelfixoff);
+      qdotadroff = bfd_getl32 (eiaf->qdotadroff);
+      ldotadroff = bfd_getl32 (eiaf->ldotadroff);
+      fprintf (file, _("  qdotadroff: %5u, ldotadroff: %5u\n"),
+               qdotadroff, ldotadroff);
+      codeadroff = bfd_getl32 (eiaf->codeadroff);
+      lpfixoff = bfd_getl32 (eiaf->lpfixoff);
+      fprintf (file, _("  codeadroff: %5u, lpfixoff  : %5u\n"),
+               codeadroff, lpfixoff);
+      chgprtoff = bfd_getl32 (eiaf->chgprtoff);
+      fprintf (file, _("  chgprtoff : %5u\n"), chgprtoff);
+      shrimgcnt = bfd_getl32 (eiaf->shrimgcnt);
+      shlstoff = bfd_getl32 (eiaf->shlstoff);
+      fprintf (file, _("  shlstoff  : %5u, shrimgcnt : %5u\n"),
+               shlstoff, shrimgcnt);
+      fprintf (file, _("  shlextra  : %5u, permctx   : %5u\n"),
+               (unsigned)bfd_getl32 (eiaf->shlextra),
+               (unsigned)bfd_getl32 (eiaf->permctx));
+      fprintf (file, _("  base_va : 0x%08x\n"),
+               (unsigned)bfd_getl32 (eiaf->base_va));
+      fprintf (file, _("  lppsbfixoff: %5u\n"),
+               (unsigned)bfd_getl32 (eiaf->lppsbfixoff));
+
+      if (shlstoff)
+        {
+          struct vms_shl *shl = (struct vms_shl *)(buf + shlstoff);
+          unsigned int j;
+
+          fprintf (file, _(" Shareable images:\n"));
+          for (j = 0; j < shrimgcnt; j++, shl++)
+            {
+              fprintf (file,
+                       _("  %u: size: %u, flags: 0x%02x, name: %.*s\n"),
+                       j, shl->size, shl->flags,
+                       shl->imgnam[0], shl->imgnam + 1);
+            }
+        }
+      if (qrelfixoff != 0)
+        {
+          fprintf (file, _(" quad-word relocation fixups:\n"));
+          evax_bfd_print_relocation_records (file, buf + qrelfixoff, 8);
+        }
+      if (lrelfixoff != 0)
+        {
+          fprintf (file, _(" long-word relocation fixups:\n"));
+          evax_bfd_print_relocation_records (file, buf + lrelfixoff, 4);
+        }
+      if (qdotadroff != 0)
+        {
+          fprintf (file, _(" quad-word .address reference fixups:\n"));
+          evax_bfd_print_address_fixups (file, buf + qdotadroff);
+        }
+      if (ldotadroff != 0)
+        {
+          fprintf (file, _(" long-word .address reference fixups:\n"));
+          evax_bfd_print_address_fixups (file, buf + ldotadroff);
+        }
+      if (codeadroff != 0)
+        {
+          fprintf (file, _(" Code Address Reference Fixups:\n"));
+          evax_bfd_print_reference_fixups (file, buf + codeadroff);
+        }
+      if (lpfixoff != 0)
+        {
+          fprintf (file, _(" Linkage Pairs Referece Fixups:\n"));
+          evax_bfd_print_reference_fixups (file, buf + lpfixoff);
+        }
+      if (chgprtoff)
+        {
+          unsigned int count = (unsigned)bfd_getl32 (buf + chgprtoff);
+          struct vms_eicp *eicp = (struct vms_eicp *)(buf + chgprtoff + 4);
+          unsigned int j;
+
+          fprintf (file, _(" Change Protection (%u entries):\n"), count);
+          for (j = 0; j < count; j++, eicp++)
+            {
+              unsigned int prot = bfd_getl32 (eicp->newprt);
+              fprintf (file,
+                       _("  base: 0x%08x %08x, size: 0x%08x, prot: 0x%08x "),
+                       (unsigned)bfd_getl32 (eicp->baseva + 4),
+                       (unsigned)bfd_getl32 (eicp->baseva + 0),
+                       (unsigned)bfd_getl32 (eicp->size),
+                       (unsigned)bfd_getl32 (eicp->newprt));
+              switch (prot)
+                {
+                case PRT__C_NA:
+                  fprintf (file, "NA");
+                  break;
+                case PRT__C_RESERVED:
+                  fprintf (file, "RES");
+                  break;
+                case PRT__C_KW:
+                  fprintf (file, "KW");
+                  break;
+                case PRT__C_KR:
+                  fprintf (file, "KR");
+                  break;
+                case PRT__C_UW:
+                  fprintf (file, "UW");
+                  break;
+                case PRT__C_EW:
+                  fprintf (file, "EW");
+                  break;
+                case PRT__C_ERKW:
+                  fprintf (file, "ERKW");
+                  break;
+                case PRT__C_ER:
+                  fprintf (file, "ER");
+                  break;
+                case PRT__C_SW:
+                  fprintf (file, "SW");
+                  break;
+                case PRT__C_SREW:
+                  fprintf (file, "SREW");
+                  break;
+                case PRT__C_SRKW:
+                  fprintf (file, "SRKW");
+                  break;
+                case PRT__C_SR:
+                  fprintf (file, "SR");
+                  break;
+                case PRT__C_URSW:
+                  fprintf (file, "URSW");
+                  break;
+                case PRT__C_UREW:
+                  fprintf (file, "UREW");
+                  break;
+                case PRT__C_URKW:
+                  fprintf (file, "URKW");
+                  break;
+                case PRT__C_UR:
+                  fprintf (file, "UR");
+                  break;
+                default:
+                  fputs ("??", file);
+                  break;
+                }
+              fputc ('\n', file);
+            }
+        }
+      free (buf);
+    }
+}
+
+static bfd_boolean
+vms_bfd_print_private_bfd_data (bfd *abfd, void *ptr)
+{
+  FILE *file = (FILE *)ptr;
+
+  if (bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
+    evax_bfd_print_image (abfd, file);
+  else
+    {
+      if (bfd_seek (abfd, 0, SEEK_SET))
+        return FALSE;
+      evax_bfd_print_eobj (abfd, file);
+    }
+  return TRUE;
+}
+
+/* Linking.  */
+
+/* Slurp an ordered set of VMS object records.  */
+
+static bfd_boolean
+alpha_vms_read_sections_content (bfd *abfd, struct bfd_link_info *info)
+{
+  asection *cur_section;
+  file_ptr cur_offset;
+  asection *dst_section;
+  file_ptr dst_offset;
+
+  if (bfd_seek (abfd, 0, SEEK_SET) != 0)
+    return FALSE;
+
+  PRIV (image_autoextend) = FALSE;
+
+  cur_section = NULL;
+  cur_offset = 0;
+
+  dst_section = PRIV (dst_section);
+  dst_offset = 0;
+  if (info)
+    {
+      if (info->strip == strip_all || info->strip == strip_debugger)
+        {
+          dst_offset = 0;
+          dst_section = NULL;
+        }
+      else if (dst_section)
+        {
+          dst_offset = dst_section->output_offset;
+          dst_section = dst_section->output_section;
+        }
+    }
+
+  while (1)
+    {
+      int type;
+      bfd_boolean res;
+
+      type = _bfd_vms_get_object_record (abfd);
+      if (type < 0)
+	{
+	  vms_debug2 ((2, "next_record failed\n"));
+	  return FALSE;
+	}
+      switch (type)
+        {
+        case EOBJ__C_ETIR:
+          PRIV (image_section) = cur_section;
+          PRIV (image_offset) = cur_offset;
+          res = _bfd_vms_slurp_etir (abfd, info);
+          cur_section = PRIV (image_section);
+          cur_offset = PRIV (image_offset);
+          break;
+        case EOBJ__C_EDBG:
+        case EOBJ__C_ETBT:
+          if (dst_section == NULL)
+            continue;
+          PRIV (image_section) = dst_section;
+          PRIV (image_offset) = dst_offset;
+          PRIV (image_autoextend) = TRUE;
+          res = _bfd_vms_slurp_etir (abfd, info);
+          PRIV (image_autoextend) = FALSE;
+          dst_offset = PRIV (image_offset);
+          break;
+        case EOBJ__C_EEOM:
+          return TRUE;
+        default:
+          continue;
+        }
+      if (!res)
+        {
+          vms_debug2 ((2, "slurp eobj type %d failed\n", type));
+          return FALSE;
+        }
+    }
+}
+
+static int
+alpha_vms_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
+                          struct bfd_link_info *info ATTRIBUTE_UNUSED)
+{
+  return 0;
+}
+
+/* Add a linkage pair fixup at address SECT + OFFSET to SHLIB. */
+
+static void
+alpha_vms_add_fixup_lp (struct bfd_link_info *info, bfd *src, bfd *shlib)
+{
+  struct alpha_vms_shlib_el *sl;
+  asection *sect = PRIV2 (src, image_section);
+  file_ptr offset = PRIV2 (src, image_offset);
+
+  sl = &VEC_EL (alpha_vms_link_hash (info)->shrlibs,
+                struct alpha_vms_shlib_el, PRIV2 (shlib, shr_index));
+  sl->has_fixups = TRUE;
+  VEC_APPEND_EL (sl->lp, bfd_vma,
+                 sect->output_section->vma + sect->output_offset + offset);
+}
+
+static void
+alpha_vms_add_fixup_ca (struct bfd_link_info *info, bfd *src, bfd *shlib)
+{
+  struct alpha_vms_shlib_el *sl;
+  asection *sect = PRIV2 (src, image_section);
+  file_ptr offset = PRIV2 (src, image_offset);
+
+  sl = &VEC_EL (alpha_vms_link_hash (info)->shrlibs,
+                struct alpha_vms_shlib_el, PRIV2 (shlib, shr_index));
+  sl->has_fixups = TRUE;
+  VEC_APPEND_EL (sl->ca, bfd_vma,
+                 sect->output_section->vma + sect->output_offset + offset);
+}
+
+static void
+alpha_vms_add_fixup_qr (struct bfd_link_info *info, bfd *src,
+                        bfd *shlib, bfd_vma vec)
+{
+  struct alpha_vms_shlib_el *sl;
+  struct alpha_vms_vma_ref *r;
+  asection *sect = PRIV2 (src, image_section);
+  file_ptr offset = PRIV2 (src, image_offset);
+
+  sl = &VEC_EL (alpha_vms_link_hash (info)->shrlibs,
+                struct alpha_vms_shlib_el, PRIV2 (shlib, shr_index));
+  sl->has_fixups = TRUE;
+  r = VEC_APPEND (sl->qr, struct alpha_vms_vma_ref);
+  r->vma = sect->output_section->vma + sect->output_offset + offset;
+  r->ref = vec;
+}
+
+static void
+alpha_vms_add_lw_fixup (struct bfd_link_info *info ATTRIBUTE_UNUSED,
+                        unsigned int shr ATTRIBUTE_UNUSED,
+                        bfd_vma vec ATTRIBUTE_UNUSED)
+{
+  abort ();
+}
+
+#if 0
+static void
+alpha_vms_add_qw_fixup (struct bfd_link_info *info ATTRIBUTE_UNUSED,
+                        unsigned int shr ATTRIBUTE_UNUSED,
+                        bfd_vma vec ATTRIBUTE_UNUSED)
+{
+  abort ();
+}
+#endif
+
+static void
+alpha_vms_add_lw_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED)
+{
+}
+
+static void
+alpha_vms_add_qw_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED)
+{
+}
+
+static struct bfd_hash_entry *
+alpha_vms_link_hash_newfunc (struct bfd_hash_entry *entry,
+                             struct bfd_hash_table *table,
+                             const char *string)
+{
+  struct alpha_vms_link_hash_entry *ret =
+    (struct alpha_vms_link_hash_entry *) entry;
+
+  /* Allocate the structure if it has not already been allocated by a
+     subclass.  */
+  if (ret == NULL)
+    ret = ((struct alpha_vms_link_hash_entry *)
+	   bfd_hash_allocate (table,
+                              sizeof (struct alpha_vms_link_hash_entry)));
+  if (ret == NULL)
+    return NULL;
+
+  /* Call the allocation method of the superclass.  */
+  ret = ((struct alpha_vms_link_hash_entry *)
+	 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
+				 table, string));
+
+  ret->sym = NULL;
+
+  return (struct bfd_hash_entry *) ret;
+}
+
+/* Create an Alpha/VMS link hash table.  */
+
+static struct bfd_link_hash_table *
+alpha_vms_bfd_link_hash_table_create (bfd *abfd)
+{
+  struct alpha_vms_link_hash_table *ret;
+  bfd_size_type amt = sizeof (struct alpha_vms_link_hash_table);
+
+  ret = (struct alpha_vms_link_hash_table *) bfd_malloc (amt);
+  if (ret == NULL)
+    return NULL;
+  if (!_bfd_link_hash_table_init (&ret->root, abfd,
+				  alpha_vms_link_hash_newfunc,
+				  sizeof (struct alpha_vms_link_hash_entry)))
+    {
+      free (ret);
+      return NULL;
+    }
+
+  VEC_INIT (ret->shrlibs);
+  ret->fixup = NULL;
+
+  return &ret->root;
+}
+
+static bfd_boolean
+alpha_vms_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
+{
+  unsigned int i;
+
+  for (i = 0; i < PRIV (gsd_sym_count); i++)
+    {
+      struct vms_symbol_entry *e = PRIV (syms)[i];
+      struct alpha_vms_link_hash_entry *h;
+      asymbol sym;
+
+      if (!alpha_vms_convert_symbol (abfd, e, &sym))
+        return FALSE;
+
+      if ((e->flags & EGSY__V_DEF) && abfd->selective_search)
+        {
+          /* In selective_search mode, only add definition that are
+             required.  */
+          h = (struct alpha_vms_link_hash_entry *)bfd_link_hash_lookup
+            (info->hash, sym.name, FALSE, FALSE, FALSE);
+          if (h == NULL || h->root.type != bfd_link_hash_undefined)
+            continue;
+        }
+      else
+        h = NULL;
+
+      if (_bfd_generic_link_add_one_symbol
+          (info, abfd, sym.name, sym.flags, sym.section, sym.value,
+           NULL, FALSE, FALSE, (struct bfd_link_hash_entry **)&h) == FALSE)
+        return FALSE;
+
+      if ((e->flags & EGSY__V_DEF)
+          && h->sym == NULL
+          && abfd->xvec == info->output_bfd->xvec)
+        h->sym = e;
+    }
+
+  if (abfd->flags & DYNAMIC)
+    {
+      struct alpha_vms_shlib_el *shlib;
+
+      /* We do not want to include any of the sections in a dynamic
+         object in the output file.  See comment in elflink.c.  */
+      bfd_section_list_clear (abfd);
+
+      shlib = VEC_APPEND (alpha_vms_link_hash (info)->shrlibs,
+                          struct alpha_vms_shlib_el);
+      shlib->abfd = abfd;
+      VEC_INIT (shlib->ca);
+      VEC_INIT (shlib->lp);
+      VEC_INIT (shlib->qr);
+      PRIV (shr_index) = VEC_COUNT (alpha_vms_link_hash (info)->shrlibs) - 1;
+    }
+
+  return TRUE;
+}
+
+static bfd_boolean
+alpha_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;
+      file_ptr file_offset;
+      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.  */
+      file_offset = _bfd_vms_lib_find_symbol (abfd, h->root.string);
+      if (file_offset == 0)
+	{
+	  /* Nothing in this slot.  */
+	  continue;
+	}
+
+      element = bfd_get_elt_at_index (abfd, file_offset);
+      if (element == NULL)
+	return FALSE;
+
+      if (element->archive_pass == -1 || element->archive_pass == pass)
+        continue;
+
+      if (! bfd_check_format (element, bfd_object))
+        {
+          element->archive_pass = -1;
+          return FALSE;
+        }
+
+      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;
+            }
+        }
+
+      /* 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))
+	return FALSE;
+      if (! alpha_vms_link_add_object_symbols (element, info))
+	return FALSE;
+
+      orig_element->archive_pass = pass;
+    }
+
+  return TRUE;
+}
+
+static bfd_boolean
+alpha_vms_bfd_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
+{
+  switch (bfd_get_format (abfd))
+    {
+    case bfd_object:
+      vms_debug2 ((2, "vms_link_add_symbols for object %s\n",
+                   abfd->filename));
+      return alpha_vms_link_add_object_symbols (abfd, info);
+      break;
+    case bfd_archive:
+      vms_debug2 ((2, "vms_link_add_symbols for archive %s\n",
+                   abfd->filename));
+      return alpha_vms_link_add_archive_symbols (abfd, info);
+      break;
+    default:
+      bfd_set_error (bfd_error_wrong_format);
+      return FALSE;
+    }
+}
+
+static bfd_boolean
+alpha_vms_build_fixups (struct bfd_link_info *info)
+{
+  struct alpha_vms_link_hash_table *t = alpha_vms_link_hash (info);
+  unsigned char *content;
+  unsigned int i;
+  unsigned int sz = 0;
+  unsigned int lp_sz = 0;
+  unsigned int ca_sz = 0;
+  unsigned int qr_sz = 0;
+  unsigned int shrimg_cnt = 0;
+  struct vms_eiaf *eiaf;
+  unsigned int off;
+  asection *sec;
+
+  /* Shared libraries.  */
+  for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
+    {
+      struct alpha_vms_shlib_el *shlib;
+
+      shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
+
+      if (!shlib->has_fixups)
+        continue;
+
+      shrimg_cnt++;
+
+      if (VEC_COUNT (shlib->ca) > 0)
+        {
+          /* Header + entries.  */
+          ca_sz += 8;
+          ca_sz += VEC_COUNT (shlib->ca) * 4;
+        }
+      if (VEC_COUNT (shlib->lp) > 0)
+        {
+          /* Header + entries.  */
+          lp_sz += 8;
+          lp_sz += VEC_COUNT (shlib->lp) * 4;
+        }
+      if (VEC_COUNT (shlib->qr) > 0)
+        {
+          /* Header + entries.  */
+          qr_sz += 8;
+          qr_sz += VEC_COUNT (shlib->qr) * 8;
+        }
+    }
+  /* Add markers.  */
+  if (ca_sz > 0)
+    ca_sz += 8;
+  if (lp_sz > 0)
+    lp_sz += 8;
+  if (qr_sz > 0)
+    qr_sz += 8;
+
+  /* Finish now if there is no content.  */
+  if (ca_sz + lp_sz + qr_sz == 0)
+    return TRUE;
+
+  /* Allocate section content (round-up size)  */
+  sz = sizeof (struct vms_eiaf) + shrimg_cnt * sizeof (struct vms_shl)
+    + ca_sz + lp_sz + qr_sz;
+  sz = (sz + VMS_BLOCK_SIZE - 1) & ~(VMS_BLOCK_SIZE - 1);
+  content = bfd_zalloc (info->output_bfd, sz);
+  if (content == NULL)
+    return FALSE;
+
+  sec = alpha_vms_link_hash (info)->fixup;
+  sec->contents = content;
+  sec->size = sz;
+
+  eiaf = (struct vms_eiaf *)content;
+  off = sizeof (struct vms_eiaf);
+  bfd_putl32 (0, eiaf->majorid);
+  bfd_putl32 (0, eiaf->minorid);
+  bfd_putl32 (0, eiaf->iaflink);
+  bfd_putl32 (0, eiaf->fixuplnk);
+  bfd_putl32 (sizeof (struct vms_eiaf), eiaf->size);
+  bfd_putl32 (0, eiaf->flags);
+  bfd_putl32 (0, eiaf->qrelfixoff);
+  bfd_putl32 (0, eiaf->lrelfixoff);
+  bfd_putl32 (0, eiaf->qdotadroff);
+  bfd_putl32 (0, eiaf->ldotadroff);
+  bfd_putl32 (0, eiaf->codeadroff);
+  bfd_putl32 (0, eiaf->lpfixoff);
+  bfd_putl32 (0, eiaf->chgprtoff);
+  bfd_putl32 (shrimg_cnt ? off : 0, eiaf->shlstoff);
+  bfd_putl32 (shrimg_cnt, eiaf->shrimgcnt);
+  bfd_putl32 (0, eiaf->shlextra);
+  bfd_putl32 (0, eiaf->permctx);
+  bfd_putl32 (0, eiaf->base_va);
+  bfd_putl32 (0, eiaf->lppsbfixoff);
+
+  if (shrimg_cnt)
+    {
+      shrimg_cnt = 0;
+
+      /* Write shl.  */
+      for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
+        {
+          struct alpha_vms_shlib_el *shlib;
+          struct vms_shl *shl;
+
+          shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
+
+          if (!shlib->has_fixups)
+            continue;
+
+          /* Renumber shared images.  */
+          PRIV2 (shlib->abfd, shr_index) = shrimg_cnt++;
+
+          shl = (struct vms_shl *)(content + off);
+          bfd_putl32 (0, shl->baseva);
+          bfd_putl32 (0, shl->shlptr);
+          bfd_putl32 (0, shl->ident);
+          bfd_putl32 (0, shl->permctx);
+          shl->size = sizeof (struct vms_shl);
+          bfd_putl16 (0, shl->fill_1);
+          shl->flags = 0;
+          bfd_putl32 (0, shl->icb);
+          shl->imgnam[0] = strlen (PRIV2 (shlib->abfd, hdr_data.hdr_t_name));
+          memcpy (shl->imgnam + 1, PRIV2 (shlib->abfd, hdr_data.hdr_t_name),
+                  shl->imgnam[0]);
+
+          off += sizeof (struct vms_shl);
+        }
+
+      /* CA fixups.  */
+      if (ca_sz != 0)
+        {
+          bfd_putl32 (off, eiaf->codeadroff);
+
+          for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
+            {
+              struct alpha_vms_shlib_el *shlib;
+              unsigned int j;
+
+              shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
+
+              if (VEC_COUNT (shlib->ca) == 0)
+                continue;
+
+              bfd_putl32 (VEC_COUNT (shlib->ca), content + off);
+              bfd_putl32 (PRIV2 (shlib->abfd, shr_index), content + off + 4);
+              off += 8;
+
+              for (j = 0; j < VEC_COUNT (shlib->ca); j++)
+                {
+                  bfd_putl32 (VEC_EL (shlib->ca, bfd_vma, j) - t->base_addr,
+                              content + off);
+                  off += 4;
+                }
+            }
+
+          bfd_putl32 (0, content + off);
+          bfd_putl32 (0, content + off + 4);
+          off += 8;
+        }
+
+      /* LP fixups.  */
+      if (lp_sz != 0)
+        {
+          bfd_putl32 (off, eiaf->lpfixoff);
+
+          for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
+            {
+              struct alpha_vms_shlib_el *shlib;
+              unsigned int j;
+
+              shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
+
+              if (VEC_COUNT (shlib->lp) == 0)
+                continue;
+
+              bfd_putl32 (VEC_COUNT (shlib->lp), content + off);
+              bfd_putl32 (PRIV2 (shlib->abfd, shr_index), content + off + 4);
+              off += 8;
+
+              for (j = 0; j < VEC_COUNT (shlib->lp); j++)
+                {
+                  bfd_putl32 (VEC_EL (shlib->lp, bfd_vma, j) - t->base_addr,
+                              content + off);
+                  off += 4;
+                }
+            }
+
+          bfd_putl32 (0, content + off);
+          bfd_putl32 (0, content + off + 4);
+          off += 8;
+        }
+
+      /* QR fixups.  */
+      if (qr_sz != 0)
+        {
+          bfd_putl32 (off, eiaf->qdotadroff);
+
+          for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
+            {
+              struct alpha_vms_shlib_el *shlib;
+              unsigned int j;
+
+              shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
+
+              if (VEC_COUNT (shlib->qr) == 0)
+                continue;
+
+              bfd_putl32 (VEC_COUNT (shlib->qr), content + off);
+              bfd_putl32 (PRIV2 (shlib->abfd, shr_index), content + off + 4);
+              off += 8;
+
+              for (j = 0; j < VEC_COUNT (shlib->qr); j++)
+                {
+                  struct alpha_vms_vma_ref *r;
+                  r = &VEC_EL (shlib->qr, struct alpha_vms_vma_ref, j);
+                  bfd_putl32 (r->vma - t->base_addr, content + off);
+                  bfd_putl32 (r->ref, content + off + 4);
+                  off += 8;
+                }
+            }
+
+          bfd_putl32 (0, content + off);
+          bfd_putl32 (0, content + off + 4);
+          off += 8;
+        }
+
+      /* CA fixups.  */
+    }
+
+  return TRUE;
+}
+
+static bfd_boolean
+alpha_vms_bfd_final_link (bfd *abfd, struct bfd_link_info *info)
+{
+  asection *o;
+  struct bfd_link_order *p;
+  bfd *sub;
+  asection *fixupsec;
+  bfd_vma base_addr;
+  bfd_vma last_addr;
+
+  bfd_get_outsymbols (abfd) = NULL;
+  bfd_get_symcount (abfd) = 0;
+
+  /* Mark all sections which will be included in the output file.  */
+  for (o = abfd->sections; o != NULL; o = o->next)
+    for (p = o->map_head.link_order; p != NULL; p = p->next)
+      if (p->type == bfd_indirect_link_order)
+	p->u.indirect.section->linker_mark = TRUE;
+
+#if 0
+  /* Handle all the link order information for the sections.  */
+  for (o = abfd->sections; o != NULL; o = o->next)
+    {
+      printf ("For section %s (at 0x%08x, flags=0x%08x):\n",
+              o->name, (unsigned)o->vma, (unsigned)o->flags);
+
+      for (p = o->map_head.link_order; p != NULL; p = p->next)
+	{
+          printf (" at 0x%08x - 0x%08x: ",
+                  (unsigned)p->offset, (unsigned)(p->offset + p->size - 1));
+	  switch (p->type)
+	    {
+	    case bfd_section_reloc_link_order:
+	    case bfd_symbol_reloc_link_order:
+              printf ("  section/symbol reloc\n");
+	      break;
+	    case bfd_indirect_link_order:
+              printf ("  section %s of %s\n",
+                      p->u.indirect.section->name,
+                      p->u.indirect.section->owner->filename);
+	      break;
+            case bfd_data_link_order:
+              printf ("  explicit data\n");
+              break;
+	    default:
+              printf ("  *unknown* type %u\n", p->type);
+	      break;
+	    }
+	}
+    }
+#endif
+
+  /* Find entry point.  */
+  if (bfd_get_start_address (abfd) == 0)
+    {
+      bfd *startbfd = NULL;
+
+      for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
+        {
+          /* Consider only VMS object files.  */
+          if (sub->xvec != abfd->xvec)
+            continue;
+
+          if (!PRIV2 (sub, eom_data).eom_has_transfer)
+            continue;
+          if ((PRIV2 (sub, eom_data).eom_b_tfrflg & EEOM__M_WKTFR) && startbfd)
+            continue;
+          if (startbfd != NULL
+              && !(PRIV2 (sub, eom_data).eom_b_tfrflg & EEOM__M_WKTFR))
+            {
+              (*info->callbacks->einfo)
+                (_("%P: multiple entry points: in modules %B and %B\n"),
+                 startbfd, sub);
+              continue;
+            }
+          startbfd = sub;
+        }
+
+      if (startbfd)
+        {
+          unsigned int ps_idx = PRIV2 (startbfd, eom_data).eom_l_psindx;
+          bfd_vma tfradr = PRIV2 (startbfd, eom_data).eom_l_tfradr;
+          asection *sec;
+
+          sec = PRIV2 (startbfd, sections)[ps_idx];
+
+          bfd_set_start_address
+            (abfd, sec->output_section->vma + sec->output_offset + tfradr);
+        }
+    }
+
+  /* Allocate content.  */
+  base_addr = (bfd_vma)-1;
+  last_addr = 0;
+  for (o = abfd->sections; o != NULL; o = o->next)
+    {
+      if (o->flags & SEC_HAS_CONTENTS)
+        {
+          o->contents = bfd_alloc (abfd, o->size);
+          if (o->contents == NULL)
+            return FALSE;
+        }
+      if (o->flags & SEC_LOAD)
+        {
+          if (o->vma < base_addr)
+            base_addr = o->vma;
+          if (o->vma + o->size > last_addr)
+            last_addr = o->vma + o->size;
+        }
+    }
+
+  fixupsec = bfd_make_section_anyway_with_flags
+    (info->output_bfd, "$FIXUP$",
+     SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_LINKER_CREATED);
+  if (fixupsec == NULL)
+    return FALSE;
+  last_addr = (last_addr + 0xffff) & ~0xffff;
+  fixupsec->vma = last_addr;
+
+  alpha_vms_link_hash (info)->fixup = fixupsec;
+  alpha_vms_link_hash (info)->base_addr = base_addr;
+
+  /* Read all sections from the inputs.  */
+  for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
+    {
+      if (sub->flags & DYNAMIC)
+        {
+          alpha_vms_create_eisd_for_shared (abfd, sub);
+          continue;
+        }
+
+      if (!alpha_vms_read_sections_content (sub, info))
+        return FALSE;
+    }
+
+  /* Handle all the link order information for the sections.  */
+  for (o = abfd->sections; o != NULL; o = o->next)
+    {
+      for (p = o->map_head.link_order; p != NULL; p = p->next)
+	{
+	  switch (p->type)
+	    {
+	    case bfd_section_reloc_link_order:
+	    case bfd_symbol_reloc_link_order:
+              abort ();
+              return FALSE;
+	    case bfd_indirect_link_order:
+              /* Already done.  */
+	      break;
+	    default:
+	      if (! _bfd_default_link_order (abfd, info, o, p))
+		return FALSE;
+	      break;
+	    }
+	}
+    }
+
+  /* Compute fixups.  */
+  if (!alpha_vms_build_fixups (info))
+    return FALSE;
+
+  return TRUE;
+}
+
+/* Read the contents of a section.
+   buf points to a buffer of buf_size bytes to be filled with
+   section data (starting at offset into section)  */
+
+static bfd_boolean
+alpha_vms_get_section_contents (bfd *abfd, asection *section,
+                                void *buf, file_ptr offset,
+                                bfd_size_type count)
+{
+  asection *sec;
+
+  /* Image are easy.  */
+  if (bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
+    return _bfd_generic_get_section_contents (abfd, section,
+                                              buf, offset, count);
+
+  /* Safety check.  */
+  if (offset + count < count
+      || offset + count > section->size)
+    {
+      bfd_set_error (bfd_error_invalid_operation);
+      return FALSE;
+    }
+
+  /* Alloc in memory and read ETIRs.  */
+  BFD_ASSERT (section->contents == NULL);
+
+  for (sec = abfd->sections; sec; sec = sec->next)
+    {
+      BFD_ASSERT (sec->contents == NULL);
+
+      if (sec->size != 0 && (sec->flags & SEC_HAS_CONTENTS))
+        {
+          sec->contents = bfd_alloc (abfd, sec->size);
+          if (sec->contents == NULL)
+            return FALSE;
+        }
+    }
+  if (!alpha_vms_read_sections_content (abfd, NULL))
+    return FALSE;
+  for (sec = abfd->sections; sec; sec = sec->next)
+    if (section->contents)
+      section->flags |= SEC_IN_MEMORY;
+  memcpy (buf, section->contents + offset, count);
+  return TRUE;
+}
+
+
+/* Set the format of a file being written.  */
+
+static bfd_boolean
+alpha_vms_mkobject (bfd * abfd)
+{
+  const bfd_arch_info_type *arch;
+
+  vms_debug2 ((1, "alpha_vms_mkobject (%p)\n", abfd));
+
+  if (!vms_initialize (abfd))
+    return FALSE;
+
+  PRIV (recwr.buf) = bfd_alloc (abfd, MAX_OUTREC_SIZE);
+  if (PRIV (recwr.buf) == NULL)
+    return FALSE;
+
+  arch = bfd_scan_arch ("alpha");
+
+  if (arch == 0)
+    {
+      bfd_set_error (bfd_error_wrong_format);
+      return FALSE;
+    }
+
+  abfd->arch_info = arch;
+  return TRUE;
+}
+
+
+/* 4.1, generic.  */
+
+/* Called when the BFD is being closed to do any necessary cleanup.  */
+
+static bfd_boolean
+vms_close_and_cleanup (bfd * abfd)
+{
+  vms_debug2 ((1, "vms_close_and_cleanup (%p)\n", abfd));
+
+  if (abfd == NULL || abfd->tdata.any == NULL)
+    return TRUE;
+
+  if (abfd->format == bfd_archive)
+    {
+      bfd_release (abfd, abfd->tdata.any);
+      abfd->tdata.any = NULL;
+      return TRUE;
+    }
+
+  if (PRIV (recrd.buf) != NULL)
+    free (PRIV (recrd.buf));
+
+  if (PRIV (sections) != NULL)
+    free (PRIV (sections));
+
+  bfd_release (abfd, abfd->tdata.any);
+  abfd->tdata.any = NULL;
+
+#ifdef VMS
+  if (abfd->direction == write_direction)
+    {
+      /* Last step on VMS is to convert the file to variable record length
+	 format.  */
+      if (bfd_cache_close (abfd) != TRUE)
+	return FALSE;
+      if (vms_convert_to_var_unix_filename (abfd->filename) != TRUE)
+	return FALSE;
+    }
+#endif
+
+  return TRUE;
+}
+
+/* Called when a new section is created.  */
+
+static bfd_boolean
+vms_new_section_hook (bfd * abfd, asection *section)
+{
+  bfd_size_type amt;
+
+  /* Count hasn't been incremented yet.  */
+  unsigned int section_count = abfd->section_count + 1;
+
+  vms_debug2 ((1, "vms_new_section_hook (%p, [%d]%s), count %d\n",
+               abfd, section->index, section->name, section_count));
+
+  bfd_set_section_alignment (abfd, section, 0);
+
+  if (section_count > PRIV (section_count))
+    {
+      amt = section_count;
+      amt *= sizeof (asection *);
+      PRIV (sections) = bfd_realloc_or_free (PRIV (sections), amt);
+      if (PRIV (sections) == NULL)
+	return FALSE;
+      PRIV (section_count) = section_count;
+    }
+
+  vms_debug2 ((6, "section_count: %d\n", PRIV (section_count)));
+
+  PRIV (sections)[section->index] = section;
+
+  vms_debug2 ((7, "%d: %s\n", section->index, section->name));
+
+  amt = sizeof (struct vms_section_data_struct);
+  section->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
+  if (section->used_by_bfd == NULL)
+    return FALSE;
+
+  if (strcmp (bfd_get_section_name (abfd, section), "$DST$") == 0)
+    PRIV (dst_section) = section;
+
+  /* Create the section symbol.  */
+  return _bfd_generic_new_section_hook (abfd, section);
+}
+
+/* Part 4.5, symbols.  */
+
+/* Print symbol to file according to how. how is one of
+   bfd_print_symbol_name	just print the name
+   bfd_print_symbol_more	print more (???)
+   bfd_print_symbol_all	print all we know, which is not much right now :-).  */
+
+static void
+vms_print_symbol (bfd * abfd,
+		  void * file,
+		  asymbol *symbol,
+		  bfd_print_symbol_type how)
+{
+  vms_debug2 ((1, "vms_print_symbol (%p, %p, %p, %d)\n",
+               abfd, file, symbol, how));
+
+  switch (how)
+    {
+      case bfd_print_symbol_name:
+      case bfd_print_symbol_more:
+	fprintf ((FILE *)file," %s", symbol->name);
+      break;
+
+      case bfd_print_symbol_all:
+	{
+	  const char *section_name = symbol->section->name;
+
+	  bfd_print_symbol_vandf (abfd, file, symbol);
+
+	  fprintf ((FILE *) file," %-8s %s", section_name, symbol->name);
+        }
+      break;
+    }
+}
+
+/* Return information about symbol in ret.
+
+   fill type, value and name
+   type:
+	A	absolute
+	B	bss segment symbol
+	C	common symbol
+	D	data segment symbol
+	f	filename
+	t	a static function symbol
+	T	text segment symbol
+	U	undefined
+	-	debug.  */
+
+static void
+vms_get_symbol_info (bfd * abfd ATTRIBUTE_UNUSED,
+		     asymbol *symbol,
+		     symbol_info *ret)
+{
+  asection *sec;
+
+  vms_debug2 ((1, "vms_get_symbol_info (%p, %p, %p)\n", abfd, symbol, ret));
+
+  sec = symbol->section;
+
+  if (ret == NULL)
+    return;
+
+  if (sec == 0)
+    ret->type = 'U';
+  else if (bfd_is_com_section (sec))
+    ret->type = 'C';
+  else if (bfd_is_abs_section (sec))
+    ret->type = 'A';
+  else if (bfd_is_und_section (sec))
+    ret->type = 'U';
+  else if (bfd_is_ind_section (sec))
+    ret->type = 'I';
+  else if (bfd_get_section_flags (abfd, sec) & SEC_CODE)
+    ret->type = 'T';
+  else if (bfd_get_section_flags (abfd, sec) & SEC_DATA)
+    ret->type = 'D';
+  else if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
+    ret->type = 'B';
+  else
+    ret->type = '-';
+
+  if (ret->type != 'U')
+    ret->value = symbol->value + symbol->section->vma;
+  else
+    ret->value = 0;
+  ret->name = symbol->name;
+}
+
+/* Return TRUE if the given symbol sym in the BFD abfd is
+   a compiler generated local label, else return FALSE.  */
+
+static bfd_boolean
+vms_bfd_is_local_label_name (bfd * abfd ATTRIBUTE_UNUSED,
+			     const char *name)
+{
+  vms_debug2 ((1, "vms_bfd_is_local_label_name (%p, %s)\n", abfd, name));
+  return name[0] == '$';
+}
+
+/* Part 4.7, writing an object file.  */
+
+/* Sets the contents of the section section in BFD abfd to the data starting
+   in memory at LOCATION. The data is written to the output section starting
+   at offset offset for count bytes.
+
+   Normally TRUE is returned, else FALSE. Possible error returns are:
+   o bfd_error_no_contents - The output section does not have the
+	SEC_HAS_CONTENTS attribute, so nothing can be written to it.
+   o and some more too  */
+
+static bfd_boolean
+_bfd_vms_set_section_contents (bfd * abfd,
+                               asection *section,
+                               const void * location,
+                               file_ptr offset,
+                               bfd_size_type count)
+{
+  if (section->contents == NULL)
+    {
+      section->contents = bfd_alloc (abfd, section->size);
+      if (section->contents == NULL)
+        return FALSE;
+
+      memcpy (section->contents + offset, location, (size_t) count);
+    }
+
+  return TRUE;
+}
+
+/* Set the architecture and machine type in BFD abfd to arch and mach.
+   Find the correct pointer to a structure and insert it into the arch_info
+   pointer.  */
+
+static bfd_boolean
+alpha_vms_set_arch_mach (bfd *abfd,
+                         enum bfd_architecture arch, unsigned long mach)
+{
+  if (arch != bfd_arch_alpha
+      && arch != bfd_arch_unknown)
+    return FALSE;
+
+  return bfd_default_set_arch_mach (abfd, arch, mach);
+}
+
+/* Set section VMS flags.  Clear NO_FLAGS and set FLAGS.  */
+
+void
+bfd_vms_set_section_flags (bfd *abfd ATTRIBUTE_UNUSED,
+			   asection *sec, flagword no_flags, flagword flags)
+{
+  vms_section_data (sec)->no_flags = no_flags;
+  vms_section_data (sec)->flags = flags;
+}
+
+struct vms_private_data_struct *
+bfd_vms_get_data (bfd *abfd)
+{
+  return (struct vms_private_data_struct *)abfd->tdata.any;
+}
+
+#define vms_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
+#define vms_bfd_link_just_syms            _bfd_generic_link_just_syms
+#define vms_bfd_copy_link_hash_symbol_type \
+  _bfd_generic_copy_link_hash_symbol_type
+#define vms_bfd_is_group_section          bfd_generic_is_group_section
+#define vms_bfd_discard_group             bfd_generic_discard_group
+#define vms_section_already_linked        _bfd_generic_section_already_linked
+#define vms_bfd_define_common_symbol      bfd_generic_define_common_symbol
+#define vms_bfd_copy_private_header_data  _bfd_generic_bfd_copy_private_header_data
+
+#define vms_bfd_copy_private_bfd_data	  _bfd_generic_bfd_copy_private_bfd_data
+#define vms_bfd_free_cached_info	  _bfd_generic_bfd_free_cached_info
+#define vms_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
+#define vms_bfd_copy_private_symbol_data  _bfd_generic_bfd_copy_private_symbol_data
+#define vms_bfd_set_private_flags         _bfd_generic_bfd_set_private_flags
+#define vms_bfd_merge_private_bfd_data    _bfd_generic_bfd_merge_private_bfd_data
+
+/* Symbols table.  */
+#define alpha_vms_make_empty_symbol        _bfd_generic_make_empty_symbol
+#define alpha_vms_bfd_is_target_special_symbol \
+   ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
+#define alpha_vms_print_symbol             vms_print_symbol
+#define alpha_vms_get_symbol_info          vms_get_symbol_info
+#define alpha_vms_read_minisymbols         _bfd_generic_read_minisymbols
+#define alpha_vms_minisymbol_to_symbol     _bfd_generic_minisymbol_to_symbol
+#define alpha_vms_get_lineno               _bfd_nosymbols_get_lineno
+#define alpha_vms_find_inliner_info        _bfd_nosymbols_find_inliner_info
+#define alpha_vms_bfd_make_debug_symbol    _bfd_nosymbols_bfd_make_debug_symbol
+#define alpha_vms_find_nearest_line        _bfd_vms_find_nearest_dst_line
+#define alpha_vms_bfd_is_local_label_name  vms_bfd_is_local_label_name
+
+/* Generic table.  */
+#define alpha_vms_close_and_cleanup	   vms_close_and_cleanup
+#define alpha_vms_bfd_free_cached_info	   vms_bfd_free_cached_info
+#define alpha_vms_new_section_hook	   vms_new_section_hook
+#define alpha_vms_set_section_contents	   _bfd_vms_set_section_contents
+#define alpha_vms_get_section_contents_in_window _bfd_generic_get_section_contents_in_window
+
+#define alpha_vms_bfd_get_relocated_section_contents \
+  bfd_generic_get_relocated_section_contents
+
+#define alpha_vms_bfd_relax_section bfd_generic_relax_section
+#define alpha_vms_bfd_gc_sections bfd_generic_gc_sections
+#define alpha_vms_bfd_merge_sections bfd_generic_merge_sections
+#define alpha_vms_bfd_is_group_section bfd_generic_is_group_section
+#define alpha_vms_bfd_discard_group bfd_generic_discard_group
+#define alpha_vms_section_already_linked \
+  _bfd_generic_section_already_linked
+
+#define alpha_vms_bfd_define_common_symbol bfd_generic_define_common_symbol
+#define alpha_vms_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
+#define alpha_vms_bfd_link_just_syms _bfd_generic_link_just_syms
+#define alpha_vms_bfd_copy_link_hash_symbol_type \
+  _bfd_generic_copy_link_hash_symbol_type
+
+#define alpha_vms_bfd_link_split_section  _bfd_generic_link_split_section
+
+#define alpha_vms_get_dynamic_symtab_upper_bound \
+  _bfd_nodynamic_get_dynamic_symtab_upper_bound
+#define alpha_vms_canonicalize_dynamic_symtab \
+  _bfd_nodynamic_canonicalize_dynamic_symtab
+#define alpha_vms_get_dynamic_reloc_upper_bound \
+  _bfd_nodynamic_get_dynamic_reloc_upper_bound
+#define alpha_vms_canonicalize_dynamic_reloc \
+  _bfd_nodynamic_canonicalize_dynamic_reloc
+
+const bfd_target vms_alpha_vec =
+{
+  "vms-alpha",			/* Name.  */
+  bfd_target_evax_flavour,
+  BFD_ENDIAN_LITTLE,		/* Data byte order is little.  */
+  BFD_ENDIAN_LITTLE,		/* Header byte order is little.  */
+
+  (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS
+   | WP_TEXT | D_PAGED),	/* Object flags.  */
+  (SEC_ALLOC | SEC_LOAD | SEC_RELOC
+   | SEC_READONLY | SEC_CODE | SEC_DATA
+   | SEC_HAS_CONTENTS | SEC_IN_MEMORY),		/* Sect flags.  */
+  0,				/* symbol_leading_char.  */
+  ' ',				/* ar_pad_char.  */
+  15,				/* ar_max_namelen.  */
+  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
+  bfd_getl32, bfd_getl_signed_32, bfd_putl32,
+  bfd_getl16, bfd_getl_signed_16, bfd_putl16,
+  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
+  bfd_getl32, bfd_getl_signed_32, bfd_putl32,
+  bfd_getl16, bfd_getl_signed_16, bfd_putl16,
+
+  {_bfd_dummy_target, alpha_vms_object_p,	/* bfd_check_format.  */
+   _bfd_vms_lib_alpha_archive_p, _bfd_dummy_target},
+  {bfd_false, alpha_vms_mkobject,		/* bfd_set_format.  */
+   _bfd_vms_lib_mkarchive, bfd_false},
+  {bfd_false, alpha_vms_write_object_contents,	/* bfd_write_contents.  */
+   _bfd_vms_lib_write_archive_contents, bfd_false},
+
+  BFD_JUMP_TABLE_GENERIC (alpha_vms),
+  BFD_JUMP_TABLE_COPY (vms),
+  BFD_JUMP_TABLE_CORE (_bfd_nocore),
+  BFD_JUMP_TABLE_ARCHIVE (_bfd_vms_lib),
+  BFD_JUMP_TABLE_SYMBOLS (alpha_vms),
+  BFD_JUMP_TABLE_RELOCS (alpha_vms),
+  BFD_JUMP_TABLE_WRITE (alpha_vms),
+  BFD_JUMP_TABLE_LINK (alpha_vms),
+  BFD_JUMP_TABLE_DYNAMIC (alpha_vms),
+
+  NULL,
+
+  (PTR) 0
+};
diff --git a/bfd/vms-gsd.c b/bfd/vms-gsd.c
deleted file mode 100644
index d0ffd78..0000000
--- a/bfd/vms-gsd.c
+++ /dev/null
@@ -1,1082 +0,0 @@
-/* vms-gsd.c -- BFD back-end for VAX (openVMS/VAX) and
-   EVAX (openVMS/Alpha) files.
-   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
-   2007, 2009 Free Software Foundation, Inc.
-
-   GSD record handling functions
-   EGSD record handling functions
-
-   Go and read the openVMS linker manual (esp. appendix B)
-   if you don't know what's going on here :-)
-
-   Written by Klaus K"ampf (kkaempf@rmi.de)
-
-   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 "bfdlink.h"
-#include "libbfd.h"
-
-#include "vms.h"
-
-/* Typical sections for vax object files.  */
-
-#define VAX_CODE_NAME		"$CODE"
-#define VAX_DATA_NAME		"$DATA"
-#define VAX_ADDRESS_DATA_NAME	"$ADDRESS_DATA"
-
-/* Typical sections for evax object files.  */
-
-#define EVAX_ABS_NAME		"$ABS$"
-#define EVAX_CODE_NAME		"$CODE$"
-#define EVAX_LINK_NAME		"$LINK$"
-#define EVAX_DATA_NAME		"$DATA$"
-#define EVAX_BSS_NAME		"$BSS$"
-#define EVAX_READONLYADDR_NAME	"$READONLY_ADDR$"
-#define EVAX_READONLY_NAME	"$READONLY$"
-#define EVAX_LITERAL_NAME	"$LITERAL$"
-#define EVAX_LITERALS_NAME	"$LITERALS"
-#define EVAX_COMMON_NAME	"$COMMON$"
-#define EVAX_LOCAL_NAME		"$LOCAL$"
-
-struct sec_flags_struct
-{
-  char *name;			/* Name of section.  */
-  int vflags_always;
-  flagword flags_always;	/* Flags we set always.  */
-  int vflags_hassize;
-  flagword flags_hassize;	/* Flags we set if the section has a size > 0.  */
-};
-
-/* These flags are deccrtl/vaxcrtl (openVMS 6.2 VAX) compatible.  */
-
-static struct sec_flags_struct vax_section_flags[] =
-  {
-    { VAX_CODE_NAME,
-      (GPS_S_M_PIC | GPS_S_M_REL | GPS_S_M_SHR | GPS_S_M_EXE | GPS_S_M_RD),
-      (SEC_CODE),
-      (GPS_S_M_PIC | GPS_S_M_REL | GPS_S_M_SHR | GPS_S_M_EXE | GPS_S_M_RD),
-      (SEC_IN_MEMORY | SEC_CODE | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD) },
-    { VAX_DATA_NAME,
-      (GPS_S_M_PIC | GPS_S_M_REL | GPS_S_M_RD | GPS_S_M_WRT),
-      (SEC_DATA),
-      (GPS_S_M_PIC | GPS_S_M_REL | GPS_S_M_RD | GPS_S_M_WRT),
-      (SEC_IN_MEMORY | SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD) },
-    { VAX_ADDRESS_DATA_NAME,
-      (GPS_S_M_PIC | GPS_S_M_REL | GPS_S_M_RD),
-      (SEC_DATA | SEC_READONLY),
-      (GPS_S_M_PIC | GPS_S_M_REL | GPS_S_M_RD),
-      (SEC_IN_MEMORY | SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_READONLY | SEC_LOAD) },
-    { NULL,
-      (GPS_S_M_PIC | GPS_S_M_OVR | GPS_S_M_REL | GPS_S_M_GBL | GPS_S_M_RD | GPS_S_M_WRT),
-      (SEC_DATA),
-      (GPS_S_M_PIC | GPS_S_M_OVR | GPS_S_M_REL | GPS_S_M_GBL | GPS_S_M_RD | GPS_S_M_WRT),
-      (SEC_IN_MEMORY | SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD) }
-  };
-
-/* These flags are deccrtl/vaxcrtl (openVMS 6.2 Alpha) compatible.  */
-
-static struct sec_flags_struct evax_section_flags[] =
-  {
-    { EVAX_ABS_NAME,
-      (EGPS_S_V_SHR),
-      (SEC_DATA),
-      (EGPS_S_V_SHR),
-      (SEC_IN_MEMORY | SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD) },
-    { EVAX_CODE_NAME,
-      (EGPS_S_V_PIC | EGPS_S_V_REL | EGPS_S_V_SHR | EGPS_S_V_EXE),
-      (SEC_CODE),
-      (EGPS_S_V_PIC | EGPS_S_V_REL | EGPS_S_V_SHR | EGPS_S_V_EXE),
-      (SEC_IN_MEMORY | SEC_CODE | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD) },
-    { EVAX_LITERAL_NAME,
-      (EGPS_S_V_PIC | EGPS_S_V_REL | EGPS_S_V_SHR | EGPS_S_V_RD | EGPS_S_V_NOMOD),
-      (SEC_DATA | SEC_READONLY),
-      (EGPS_S_V_PIC | EGPS_S_V_REL | EGPS_S_V_SHR | EGPS_S_V_RD),
-      (SEC_IN_MEMORY | SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_READONLY | SEC_LOAD) },
-    { EVAX_LINK_NAME,
-      (EGPS_S_V_REL | EGPS_S_V_RD),
-      (SEC_DATA | SEC_READONLY),
-      (EGPS_S_V_REL | EGPS_S_V_RD),
-      (SEC_IN_MEMORY | SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_READONLY | SEC_LOAD) },
-    { EVAX_DATA_NAME,
-      (EGPS_S_V_REL | EGPS_S_V_RD | EGPS_S_V_WRT | EGPS_S_V_NOMOD),
-      (SEC_DATA),
-      (EGPS_S_V_REL | EGPS_S_V_RD | EGPS_S_V_WRT),
-      (SEC_IN_MEMORY | SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD) },
-    { EVAX_BSS_NAME,
-      (EGPS_S_V_REL | EGPS_S_V_RD | EGPS_S_V_WRT | EGPS_S_V_NOMOD),
-      (SEC_NO_FLAGS),
-      (EGPS_S_V_REL | EGPS_S_V_RD | EGPS_S_V_WRT | EGPS_S_V_NOMOD),
-      (SEC_IN_MEMORY | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD) },
-    { EVAX_READONLYADDR_NAME,
-      (EGPS_S_V_PIC | EGPS_S_V_REL | EGPS_S_V_RD),
-      (SEC_DATA | SEC_READONLY),
-      (EGPS_S_V_PIC | EGPS_S_V_REL | EGPS_S_V_RD),
-      (SEC_IN_MEMORY | SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_READONLY | SEC_LOAD) },
-    { EVAX_READONLY_NAME,
-      (EGPS_S_V_PIC | EGPS_S_V_REL | EGPS_S_V_SHR | EGPS_S_V_RD | EGPS_S_V_NOMOD),
-      (SEC_DATA | SEC_READONLY),
-      (EGPS_S_V_PIC | EGPS_S_V_REL | EGPS_S_V_SHR | EGPS_S_V_RD),
-      (SEC_IN_MEMORY | SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_READONLY | SEC_LOAD) },
-    { EVAX_LOCAL_NAME,
-      (EGPS_S_V_REL | EGPS_S_V_RD | EGPS_S_V_WRT),
-      (SEC_DATA),
-      (EGPS_S_V_REL | EGPS_S_V_RD | EGPS_S_V_WRT),
-      (SEC_IN_MEMORY | SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD) },
-    { EVAX_LITERALS_NAME,
-      (EGPS_S_V_PIC | EGPS_S_V_OVR),
-      (SEC_DATA | SEC_READONLY),
-      (EGPS_S_V_PIC | EGPS_S_V_OVR),
-      (SEC_IN_MEMORY | SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_READONLY | SEC_LOAD) },
-    { NULL,
-      (EGPS_S_V_REL | EGPS_S_V_RD | EGPS_S_V_WRT),
-      (SEC_DATA),
-      (EGPS_S_V_REL | EGPS_S_V_RD | EGPS_S_V_WRT),
-      (SEC_IN_MEMORY | SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD) }
-  };
-
-/* Retrieve bfd section flags by name and size.  */
-
-static flagword
-vms_secflag_by_name (bfd *abfd,
-		     struct sec_flags_struct *section_flags,
-		     char *name,
-		     int hassize)
-{
-  int i = 0;
-
-  while (section_flags[i].name != NULL)
-    {
-      if ((PRIV (is_vax)?
-	   strcasecmp (name, section_flags[i].name):
-	   strcmp (name, section_flags[i].name)) == 0)
-	{
-	  if (hassize)
-	    return section_flags[i].flags_hassize;
-	  else
-	    return section_flags[i].flags_always;
-	}
-      i++;
-    }
-  if (hassize)
-    return section_flags[i].flags_hassize;
-  return section_flags[i].flags_always;
-}
-
-/* Retrieve vms section flags by name and size.  */
-
-static flagword
-vms_esecflag_by_name (struct sec_flags_struct *section_flags,
-		      char *name,
-		      int hassize)
-{
-  int i = 0;
-
-  while (section_flags[i].name != NULL)
-    {
-      if (strcmp (name, section_flags[i].name) == 0)
-	{
-	  if (hassize)
-	    return section_flags[i].vflags_hassize;
-	  else
-	    return section_flags[i].vflags_always;
-	}
-      i++;
-    }
-  if (hassize)
-    return section_flags[i].vflags_hassize;
-  return section_flags[i].vflags_always;
-}
-
-#if VMS_DEBUG
-
-struct flagdescstruct { const char *name; flagword value; };
-
-static const struct flagdescstruct gpsflagdesc[] =
-{
-  { "PIC", GPS_S_M_PIC },
-  { "LIB", GPS_S_M_LIB },
-  { "OVR", GPS_S_M_OVR },
-  { "REL", GPS_S_M_REL },
-  { "GBL", GPS_S_M_GBL },
-  { "SHR", GPS_S_M_SHR },
-  { "EXE", GPS_S_M_EXE },
-  { "RD",  GPS_S_M_RD },
-  { "WRT", GPS_S_M_WRT },
-  { "VEC", GPS_S_M_VEC },
-  { "NOMOD", EGPS_S_V_NOMOD },
-  { "COM", EGPS_S_V_COM },
-  { NULL, 0 }
-};
-
-static const struct flagdescstruct gsyflagdesc[] =
-{
-  { "WEAK", GSY_S_M_WEAK },
-  { "DEF",  GSY_S_M_DEF },
-  { "UNI",  GSY_S_M_UNI },
-  { "REL",  GSY_S_M_REL },
-  { "COMM", EGSY_S_V_COMM },
-  { "VECEP", EGSY_S_V_VECEP },
-  { "NORM", EGSY_S_V_NORM },
-  { NULL, 0 }
-};
-
-static char *flag2str (struct flagdescstruct *, flagword);
-
-/* Convert flag to printable string.  */
-
-static char *
-flag2str (struct flagdescstruct * flagdesc, flagword flags)
-{
-  static char res[64];
-  int next = 0;
-
-  res[0] = 0;
-  while (flagdesc->name != NULL)
-    {
-      if ((flags & flagdesc->value) != 0)
-	{
-	  if (next)
-	    strcat (res, ",");
-	  else
-	    next = 1;
-	  strcat (res, flagdesc->name);
-	}
-      flagdesc++;
-    }
-  return res;
-}
-#endif
-
-/* Input routines.  */
-
-static int register_universal_symbol (bfd *abfd, asymbol *symbol,
-				      int vms_flags);
-
-/* Process GSD/EGSD record
-   return 0 on success, -1 on error.  */
-
-int
-_bfd_vms_slurp_gsd (bfd * abfd, int objtype)
-{
-  int gsd_type, gsd_size;
-  asection *section;
-  unsigned char *vms_rec;
-  flagword new_flags, old_flags;
-  char *name;
-  asymbol *symbol;
-  vms_symbol_entry *entry;
-  unsigned long base_addr;
-  unsigned long align_addr;
-  static unsigned int psect_idx = 0;
-
-#if VMS_DEBUG
-  vms_debug (2, "GSD/EGSD (%d/%x)\n", objtype, objtype);
-#endif
-
-  switch (objtype)
-    {
-    case EOBJ_S_C_EGSD:
-      PRIV (vms_rec) += 8;	/* Skip type, size, l_temp.  */
-      PRIV (rec_size) -= 8;
-      break;
-    case OBJ_S_C_GSD:
-      PRIV (vms_rec) += 1;
-      PRIV (rec_size) -= 1;
-      break;
-    default:
-      return -1;
-    }
-
-  /* Calculate base address for each section.  */
-  base_addr = 0L;
-
-  abfd->symcount = 0;
-
-  while (PRIV (rec_size) > 0)
-    {
-      vms_rec = PRIV (vms_rec);
-
-      if (objtype == OBJ_S_C_GSD)
-	gsd_type = vms_rec[0];
-      else
-	{
-	  _bfd_vms_get_header_values (abfd, vms_rec, &gsd_type, &gsd_size);
-	  gsd_type += EVAX_OFFSET;
-	}
-
-#if VMS_DEBUG
-      vms_debug (3, "gsd_type %d\n", gsd_type);
-#endif
-
-      switch (gsd_type)
-	{
-	case GSD_S_C_PSC:
-	  {
-	    /* Program section definition.  */
-	    asection *old_section = 0;
-
-#if VMS_DEBUG
-	    vms_debug (4, "GSD_S_C_PSC\n");
-#endif
-	    /* If this section isn't a bfd section.  */
-	    if (PRIV (is_vax) && (psect_idx < (abfd->section_count - 1)))
-	      {
-		/* Check for temporary section from TIR record.  */
-		if (psect_idx < PRIV (section_count))
-		  old_section = PRIV (sections)[psect_idx];
-		else
-		  old_section = 0;
-	      }
-
-	    name = _bfd_vms_save_counted_string (vms_rec + 8);
-	    section = bfd_make_section (abfd, name);
-	    if (!section)
-	      {
-		(*_bfd_error_handler) (_("bfd_make_section (%s) failed"),
-				       name);
-		return -1;
-	      }
-	    old_flags = bfd_getl16 (vms_rec + 2);
-	    section->size = bfd_getl32 (vms_rec + 4);  /* allocation */
-	    new_flags = vms_secflag_by_name (abfd, vax_section_flags, name,
-					     section->size > 0);
-	    if (old_flags & EGPS_S_V_REL)
-	      new_flags |= SEC_RELOC;
-	    if (old_flags & GPS_S_M_OVR)
-	      new_flags |= SEC_IS_COMMON;
-	    if (!bfd_set_section_flags (abfd, section, new_flags))
-	      {
-		(*_bfd_error_handler)
-		  (_("bfd_set_section_flags (%s, %x) failed"),
-		   name, new_flags);
-		return -1;
-	      }
-	    section->alignment_power = vms_rec[1];
-	    align_addr = (1 << section->alignment_power);
-	    if ((base_addr % align_addr) != 0)
-	      base_addr += (align_addr - (base_addr % align_addr));
-	    section->vma = (bfd_vma)base_addr;
-	    base_addr += section->size;
-
-	    /* Global section is common symbol.  */
-	    if (old_flags & GPS_S_M_GBL)
-	      {
-		entry = _bfd_vms_enter_symbol (abfd, name);
-		if (entry == NULL)
-		  {
-		    bfd_set_error (bfd_error_no_memory);
-		    return -1;
-		  }
-		symbol = entry->symbol;
-
-		symbol->value = 0;
-		symbol->section = section;
-		symbol->flags = (BSF_GLOBAL | BSF_SECTION_SYM | BSF_OLD_COMMON);
-	      }
-
-	    /* Copy saved contents if old_section set.  */
-	    if (old_section != 0)
-	      {
-		section->contents = old_section->contents;
-		if (section->size < old_section->size)
-		  {
-		    (*_bfd_error_handler)
-		      (_("Size mismatch section %s=%lx, %s=%lx"),
-		       old_section->name,
-		       (unsigned long) old_section->size,
-		       section->name,
-		       (unsigned long) section->size);
-		    return -1;
-		  }
-		else if (section->size > old_section->size)
-		  {
-		    section->contents = bfd_realloc (old_section->contents,
-						     section->size);
-		    if (section->contents == NULL)
-		      {
-			bfd_set_error (bfd_error_no_memory);
-			return -1;
-		      }
-		  }
-	      }
-	    else
-	      {
-		section->contents = bfd_zmalloc (section->size);
-		if (section->contents == NULL)
-		  {
-		    bfd_set_error (bfd_error_no_memory);
-		    return -1;
-		  }
-	      }
-#if VMS_DEBUG
-	    vms_debug (4, "gsd psc %d (%s, flags %04x=%s) ",
-		       section->index, name, old_flags, flag2str (gpsflagdesc, old_flags));
-	    vms_debug (4, "%d bytes at 0x%08lx (mem %p)\n",
-		       section->size, section->vma, section->contents);
-#endif
-
-	    gsd_size = vms_rec[8] + 9;
-
-	    psect_idx++;
-	  }
-	  break;
-
-	case GSD_S_C_EPM:
-	case GSD_S_C_EPMW:
-#if VMS_DEBUG
-	  vms_debug (4, "gsd epm\n");
-#endif
-	  /* Fall through.  */
-	case GSD_S_C_SYM:
-	case GSD_S_C_SYMW:
-	  {
-	    int name_offset = 0, value_offset = 0;
-
-	    /* Symbol specification (definition or reference).  */
-#if VMS_DEBUG
-	    vms_debug (4, "GSD_S_C_SYM(W)\n");
-#endif
-	    old_flags = bfd_getl16 (vms_rec + 2);
-	    new_flags = BSF_NO_FLAGS;
-
-	    if (old_flags & GSY_S_M_WEAK)
-	      new_flags |= BSF_WEAK;
-
-	    switch (gsd_type)
-	      {
-	      case GSD_S_C_EPM:
-		name_offset = 11;
-		value_offset = 5;
-		new_flags |= BSF_FUNCTION;
-		break;
-	      case GSD_S_C_EPMW:
-		name_offset = 12;
-		value_offset = 6;
-		new_flags |= BSF_FUNCTION;
-		break;
-	      case GSD_S_C_SYM:
-		if (old_flags & GSY_S_M_DEF)	/* Symbol definition.  */
-		  name_offset = 9;
-		else
-		  name_offset = 4;
-		value_offset = 5;
-		break;
-	      case GSD_S_C_SYMW:
-		if (old_flags & GSY_S_M_DEF)	/* Symbol definition.  */
-		  name_offset = 10;
-		else
-		  name_offset = 5;
-		value_offset = 6;
-		break;
-	      }
-
-	    /* Save symbol in vms_symbol_table.  */
-	    entry = _bfd_vms_enter_symbol
-	      (abfd, _bfd_vms_save_counted_string (vms_rec + name_offset));
-	    if (entry == NULL)
-	      {
-		bfd_set_error (bfd_error_no_memory);
-		return -1;
-	      }
-	    symbol = entry->symbol;
-
-	    if (old_flags & GSY_S_M_DEF)
-	      {
-		/* Symbol definition.  */
-		int psect;
-
-		symbol->value = bfd_getl32 (vms_rec + value_offset);
-		if ((gsd_type == GSD_S_C_SYMW)
-		    || (gsd_type == GSD_S_C_EPMW))
-		  psect = bfd_getl16 (vms_rec + value_offset - 2);
-		else
-		  psect = vms_rec[value_offset-1];
-
-		symbol->section = (asection *)(unsigned long)psect;
-#if VMS_DEBUG
-		vms_debug (4, "gsd sym def #%d (%s, %ld, %04x=%s)\n", abfd->symcount,
-			  symbol->name, (long)symbol->section, old_flags, flag2str(gsyflagdesc, old_flags));
-#endif
-	      }
-	    else
-	      {
-		/* Symbol reference.  */
-#if VMS_DEBUG
-		vms_debug (4, "gsd sym ref #%d (%s, %04x=%s)\n", abfd->symcount,
-			   symbol->name, old_flags, flag2str (gsyflagdesc, old_flags));
-#endif
-		symbol->section = (asection *)(unsigned long)-1;
-	      }
-
-	    gsd_size = vms_rec[name_offset] + name_offset + 1;
-	    symbol->flags = new_flags;
-	  }
-
-	  break;
-
-	case GSD_S_C_PRO:
-	case GSD_S_C_PROW:
-#if VMS_DEBUG
-	  vms_debug (4, "gsd pro\n");
-#endif
-	  break;
-	case GSD_S_C_IDC:
-#if VMS_DEBUG
-	  vms_debug (4, "gsd idc\n");
-#endif
-	  break;
-	case GSD_S_C_ENV:
-#if VMS_DEBUG
-	  vms_debug (4, "gsd env\n");
-#endif
-	  break;
-	case GSD_S_C_LSY:
-#if VMS_DEBUG
-	  vms_debug (4, "gsd lsy\n");
-#endif
-	  break;
-	case GSD_S_C_LEPM:
-#if VMS_DEBUG
-	  vms_debug (4, "gsd lepm\n");
-#endif
-	  break;
-	case GSD_S_C_LPRO:
-#if VMS_DEBUG
-	  vms_debug (4, "gsd lpro\n");
-#endif
-	  break;
-	case GSD_S_C_SPSC:
-#if VMS_DEBUG
-	  vms_debug (4, "gsd spsc\n");
-#endif
-	  break;
-	case GSD_S_C_SYMV:
-#if VMS_DEBUG
-	  vms_debug (4, "gsd symv\n");
-#endif
-	  break;
-	case GSD_S_C_EPMV:
-#if VMS_DEBUG
-	  vms_debug (4, "gsd epmv\n");
-#endif
-	  break;
-	case GSD_S_C_PROV:
-#if VMS_DEBUG
-	  vms_debug (4, "gsd prov\n");
-#endif
-	  break;
-
-	case EGSD_S_C_PSC + EVAX_OFFSET:
-	  {
-	    /* Program section definition.  */
-	    name = _bfd_vms_save_counted_string (vms_rec + EGPS_S_B_NAMLNG);
-	    section = bfd_make_section (abfd, name);
-	    if (!section)
-	      return -1;
-	    old_flags = bfd_getl16 (vms_rec + EGPS_S_W_FLAGS);
-	    section->size = bfd_getl32 (vms_rec + EGPS_S_L_ALLOC);
-	    new_flags = vms_secflag_by_name (abfd, evax_section_flags, name,
-					     section->size > 0);
-	    if (old_flags & EGPS_S_V_REL)
-	      new_flags |= SEC_RELOC;
-	    if (!bfd_set_section_flags (abfd, section, new_flags))
-	      return -1;
-	    section->alignment_power = vms_rec[EGPS_S_B_ALIGN];
-	    align_addr = (1 << section->alignment_power);
-	    if ((base_addr % align_addr) != 0)
-	      base_addr += (align_addr - (base_addr % align_addr));
-	    section->vma = (bfd_vma)base_addr;
-	    base_addr += section->size;
-	    section->contents = bfd_zmalloc (section->size);
-	    if (section->contents == NULL)
-	      return -1;
-	    section->filepos = (unsigned int)-1;
-#if VMS_DEBUG
-	    vms_debug (4, "EGSD P-section %d (%s, flags %04x=%s) ",
-		       section->index, name, old_flags, flag2str(gpsflagdesc, old_flags));
-	    vms_debug (4, "%d bytes at 0x%08lx (mem %p)\n",
-		       section->size, section->vma, section->contents);
-#endif
-	  }
-	  break;
-
-	case EGSD_S_C_SYM + EVAX_OFFSET:
-	  {
-	    /* Global symbol specification (definition or reference).  */
-	    symbol = bfd_make_empty_symbol (abfd);
-	    if (symbol == 0)
-	      return -1;
-
-	    old_flags = bfd_getl16 (vms_rec + EGSY_S_W_FLAGS);
-	    new_flags = BSF_NO_FLAGS;
-
-	    if (old_flags & EGSY_S_V_WEAK)
-	      new_flags |= BSF_WEAK;
-
-	    if (old_flags & EGSY_S_V_DEF)
-	      {
-		/* Symbol definition.  */
-		if (old_flags & EGSY_S_V_NORM)
-		  new_flags |= BSF_FUNCTION;
-		symbol->name =
-		  _bfd_vms_save_counted_string (vms_rec + ESDF_S_B_NAMLNG);
-		symbol->value = bfd_getl64 (vms_rec + ESDF_S_L_VALUE);
-		symbol->section =
-		  (asection *)(unsigned long) bfd_getl32 (vms_rec + ESDF_S_L_PSINDX);
-#if VMS_DEBUG
-		vms_debug (4, "EGSD sym def #%d (%s, %ld, %04x=%s)\n",
-			   abfd->symcount, symbol->name, (long)symbol->section,
-			   old_flags, flag2str (gsyflagdesc, old_flags));
-#endif
-	      }
-	    else
-	      {
-		/* Symbol reference.  */
-		symbol->name =
-		  _bfd_vms_save_counted_string (vms_rec + ESRF_S_B_NAMLNG);
-#if VMS_DEBUG
-		vms_debug (4, "EGSD sym ref #%d (%s, %04x=%s)\n",
-			   abfd->symcount, symbol->name, old_flags,
-			   flag2str (gsyflagdesc, old_flags));
-#endif
-		symbol->section = (asection *)(unsigned long)-1;
-	      }
-
-	    symbol->flags = new_flags;
-
-	    /* Register symbol in VMS symbol table.  */
-	    entry = (vms_symbol_entry *) bfd_hash_lookup
-	      (PRIV (vms_symbol_table), symbol->name, TRUE, FALSE);
-
-	    if (entry == NULL)
-	      {
-		bfd_set_error (bfd_error_no_memory);
-		return -1;
-	      }
-
-	    if (entry->symbol != NULL)
-	      {
-		/* FIXME ?, DEC C generates this.  */
-#if VMS_DEBUG
-		vms_debug (4, "EGSD_S_C_SYM: duplicate \"%s\"\n", symbol->name);
-#endif
-	      }
-	    else
-	      {
-		entry->symbol = symbol;
-		PRIV (gsd_sym_count)++;
-		abfd->symcount++;
-	      }
-	  }
-	  break;
-
-	case EGSD_S_C_SYMG + EVAX_OFFSET:
-	  {
-	    /* Universal symbol specification (definition).  */
-	    symbol = bfd_make_empty_symbol (abfd);
-	    if (symbol == 0)
-	      return -1;
-
-	    old_flags = bfd_getl16 (vms_rec + EGST_S_W_FLAGS);
-	    new_flags = BSF_NO_FLAGS;
-
-	    if (old_flags & EGSY_S_V_WEAK)
-	      new_flags |= BSF_WEAK;
-
-	    if (old_flags & EGSY_S_V_DEF) /* symbol definition */
-	      {
-		if (old_flags & EGSY_S_V_NORM)
-		  new_flags |= BSF_FUNCTION;
-
-		symbol->name =
-		  _bfd_vms_save_counted_string (vms_rec + EGST_S_B_NAMLNG);
-
-		/* For BSF_FUNCTION symbols, the entry point is in LP_1
-		   and the descriptor in LP_2.  For other symbols, the
-		   unique value is in LP_2.  */
-		symbol->value = bfd_getl64 (vms_rec + EGST_S_Q_LP_2);
-
-		/* Adding this offset is necessary in order for GDB to
-		   read the DWARF-2 debug info from shared libraries.  */
-		if (abfd->flags & DYNAMIC
-		    && strstr (symbol->name, "$DWARF2.DEBUG") != 0)
-		  symbol->value += PRIV (symvva);
-	      }
-	    else /* symbol reference */
-	      (*_bfd_error_handler) ("Invalid EGST reference");
-
-	    symbol->flags = new_flags;
-
-	    if (register_universal_symbol (abfd, symbol, old_flags) < 0)
-	      return -1;
-
-	    /* Make a second symbol for the entry point.  */
-	    if (symbol->flags & BSF_FUNCTION)
-	      {
-		asymbol *en_sym;
-
-		name = bfd_alloc (abfd, strlen (symbol->name) + 5);
-
-		en_sym = bfd_make_empty_symbol (abfd);
-		if (en_sym == 0)
-		  return -1;
-
-		strcpy (name, symbol->name);
-		strcat (name, "..en");
-
-		en_sym->name = name;
-		en_sym->value = bfd_getl64 (vms_rec + EGST_S_Q_LP_1);
-
-		if (register_universal_symbol (abfd, en_sym, old_flags) < 0)
-		  return -1;
-	      }
-	  }
-	  break;
-
-	case EGSD_S_C_IDC + EVAX_OFFSET:
-  	  break;
-
-	default:
-	  (*_bfd_error_handler) (_("Unknown GSD/EGSD subtype %d"), gsd_type);
-	  bfd_set_error (bfd_error_bad_value);
-	  return -1;
-	}
-
-      PRIV (rec_size) -= gsd_size;
-      PRIV (vms_rec) += gsd_size;
-    }
-
-  if (abfd->symcount > 0)
-    abfd->flags |= HAS_SYMS;
-
-  return 0;
-}
-
-/* Register a universal symbol in the VMS symbol table.  */
-
-static int
-register_universal_symbol (bfd *abfd, asymbol *symbol, int vms_flags)
-{
-  bfd_vma sbase = 0;
-  asection *s, *sec = NULL;
-  vms_symbol_entry *entry;
-
-  /* A universal symbol is by definition global...  */
-  symbol->flags |= BSF_GLOBAL;
-
-  /* ...and dynamic in shared libraries.  */
-  if (abfd->flags & DYNAMIC)
-    symbol->flags |= BSF_DYNAMIC;
-
-  /* Find containing section.  */
-  for (s = abfd->sections; s; s = s->next)
-    {
-      if (symbol->value >= s->vma
-	  && s->vma > sbase
-	  && !(s->flags & SEC_COFF_SHARED_LIBRARY)
-	  && (s->size > 0 || !(vms_flags & EGSY_S_V_REL)))
-	{
-	  sbase = s->vma;
-	  sec = s;
-	}
-    }
-
-  symbol->value -= sbase;
-  symbol->section = sec;
-
-#if VMS_DEBUG
-  vms_debug (4, "EGST sym def #%d (%s, 0x%llx => 0x%llx, %04x=%s)\n",
-	     abfd->symcount, symbol->name, symbol->value + sbase,
-	     symbol->value, vms_flags,
-	     flag2str(gsyflagdesc, vms_flags));
-#endif
-
-  entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV (vms_symbol_table),
-						symbol->name,
-						TRUE, FALSE);
-
-  if (entry == NULL)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      return -1;
-    }
-
-  if (entry->symbol) /* FIXME: DEC C generates this */
-    {
-#if VMS_DEBUG
-      vms_debug (4, "EGSD_S_C_SYMG: duplicate \"%s\"\n", symbol->name);
-#endif
-    }
-  else
-    {
-      entry->symbol = symbol;
-      PRIV (gsd_sym_count)++;
-      abfd->symcount++;
-    }
-
-  return 0;
-}
-
-/* Set section VMS flags.  */
-
-void
-bfd_vms_set_section_flags (bfd *abfd ATTRIBUTE_UNUSED,
-			   asection *sec, flagword flags)
-{
-  vms_section_data (sec)->vflags = flags;
-}
-
-/* Write section and symbol directory of bfd abfd.  */
-
-int
-_bfd_vms_write_gsd (bfd *abfd, int objtype ATTRIBUTE_UNUSED)
-{
-  asection *section;
-  asymbol *symbol;
-  unsigned int symnum;
-  int last_index = -1;
-  char dummy_name[10];
-  char *sname;
-  flagword new_flags, old_flags;
-  int abs_section_index = 0;
-
-#if VMS_DEBUG
-  vms_debug (2, "vms_write_gsd (%p, %d)\n", abfd, objtype);
-#endif
-
-  /* Output sections.  */
-  section = abfd->sections;
-#if VMS_DEBUG
-  vms_debug (3, "%d sections found\n", abfd->section_count);
-#endif
-
-  /* Egsd is quadword aligned.  */
-  _bfd_vms_output_alignment (abfd, 8);
-
-  _bfd_vms_output_begin (abfd, EOBJ_S_C_EGSD, -1);
-  _bfd_vms_output_long (abfd, 0);
-  /* Prepare output for subrecords.  */
-  _bfd_vms_output_push (abfd);
-
-  while (section != 0)
-    {
-#if VMS_DEBUG
-      vms_debug (3, "Section #%d %s, %d bytes\n", section->index, section->name, (int)section->size);
-#endif
-
-      /* Don't write out the VMS debug info section since it is in the
-         ETBT and EDBG sections in etir. */
-      if (!strcmp (section->name, ".vmsdebug"))
-        goto done;
-
-      /* 13 bytes egsd, max 31 chars name -> should be 44 bytes.  */
-      if (_bfd_vms_output_check (abfd, 64) < 0)
-	{
-	  _bfd_vms_output_pop (abfd);
-	  _bfd_vms_output_end (abfd);
-	  _bfd_vms_output_begin (abfd, EOBJ_S_C_EGSD, -1);
-	  _bfd_vms_output_long (abfd, 0);
-	  /* Prepare output for subrecords.  */
-	  _bfd_vms_output_push (abfd);
-	}
-
-      /* Create dummy sections to keep consecutive indices.  */
-      while (section->index - last_index > 1)
-	{
-#if VMS_DEBUG
-	  vms_debug (3, "index %d, last %d\n", section->index, last_index);
-#endif
-	  _bfd_vms_output_begin (abfd, EGSD_S_C_PSC, -1);
-	  _bfd_vms_output_short (abfd, 0);
-	  _bfd_vms_output_short (abfd, 0);
-	  _bfd_vms_output_long (abfd, 0);
-	  sprintf (dummy_name, ".DUMMY%02d", last_index);
-	  _bfd_vms_output_counted (abfd, dummy_name);
-	  _bfd_vms_output_flush (abfd);
-	  last_index++;
-	}
-
-      /* Don't know if this is necessary for the linker but for now it keeps
-	 vms_slurp_gsd happy  */
-      sname = (char *)section->name;
-      if (*sname == '.')
-	{
-	  sname++;
-	  if ((*sname == 't') && (strcmp (sname, "text") == 0))
-	    sname = PRIV (is_vax)?VAX_CODE_NAME:EVAX_CODE_NAME;
-	  else if ((*sname == 'd') && (strcmp (sname, "data") == 0))
-	    sname = PRIV (is_vax)?VAX_DATA_NAME:EVAX_DATA_NAME;
-	  else if ((*sname == 'b') && (strcmp (sname, "bss") == 0))
-	    sname = EVAX_BSS_NAME;
-	  else if ((*sname == 'l') && (strcmp (sname, "link") == 0))
-	    sname = EVAX_LINK_NAME;
-	  else if ((*sname == 'r') && (strcmp (sname, "rdata") == 0))
-	    sname = EVAX_READONLY_NAME;
-	  else if ((*sname == 'l') && (strcmp (sname, "literal") == 0))
-	    sname = EVAX_LITERAL_NAME;
-	  else if ((*sname == 'l') && (strcmp (sname, "literals") == 0))
-	    {
-	      sname = EVAX_LITERALS_NAME;
-	      abs_section_index = section->index;
-	    }
-	  else if ((*sname == 'c') && (strcmp (sname, "comm") == 0))
-	    sname = EVAX_COMMON_NAME;
-	  else if ((*sname == 'l') && (strcmp (sname, "lcomm") == 0))
-	    sname = EVAX_LOCAL_NAME;
-	}
-      else
-	sname = _bfd_vms_length_hash_symbol (abfd, sname, EOBJ_S_C_SECSIZ);
-
-      _bfd_vms_output_begin (abfd, EGSD_S_C_PSC, -1);
-      _bfd_vms_output_short (abfd, section->alignment_power & 0xff);
-
-      if (bfd_is_com_section (section))
-	new_flags = (EGPS_S_V_OVR | EGPS_S_V_REL | EGPS_S_V_GBL | EGPS_S_V_RD
-		     | EGPS_S_V_WRT | EGPS_S_V_NOMOD | EGPS_S_V_COM);
-      else
-	new_flags = vms_esecflag_by_name (evax_section_flags, sname,
-					  section->size > 0);
-
-      /* Modify them as directed.  */
-      if (section->flags & SEC_READONLY)
-	new_flags &= ~EGPS_S_V_WRT;
-
-      new_flags |= vms_section_data (section)->vflags & 0xffff;
-      new_flags &=
-	~((vms_section_data (section)->vflags >> EGPS_S_V_NO_SHIFT) & 0xffff);
-
-#if VMS_DEBUG
-      vms_debug (3, "sec flags %x\n", section->flags);
-      vms_debug (3, "new_flags %x, _raw_size %d\n", new_flags, section->size);
-#endif
-
-      _bfd_vms_output_short (abfd, new_flags);
-      _bfd_vms_output_long (abfd, (unsigned long) section->size);
-      _bfd_vms_output_counted (abfd, sname);
-      _bfd_vms_output_flush (abfd);
-
-      last_index = section->index;
-done:
-      section = section->next;
-    }
-
-  /* Output symbols.  */
-#if VMS_DEBUG
-  vms_debug (3, "%d symbols found\n", abfd->symcount);
-#endif
-
-  bfd_set_start_address (abfd, (bfd_vma) -1);
-
-  for (symnum = 0; symnum < abfd->symcount; symnum++)
-    {
-      char *hash;
-
-      symbol = abfd->outsymbols[symnum];
-      if (*(symbol->name) == '_')
-	{
-	  if (strcmp (symbol->name, "__main") == 0)
-	    bfd_set_start_address (abfd, (bfd_vma)symbol->value);
-	}
-      old_flags = symbol->flags;
-
-      if (old_flags & BSF_FILE)
-	continue;
-
-      if ((old_flags & BSF_GLOBAL) == 0		   /* Not xdef...  */
-	  && !bfd_is_und_section (symbol->section) /* and not xref... */
-	  && !((old_flags & BSF_SECTION_SYM) != 0  /* and not LIB$INITIALIZE.  */
-	       && strcmp (symbol->section->name, "LIB$INITIALIZE") == 0))
-	continue;
-
-      /* 13 bytes egsd, max 64 chars name -> should be 77 bytes.  */
-      if (_bfd_vms_output_check (abfd, 80) < 0)
-	{
-	  _bfd_vms_output_pop (abfd);
-	  _bfd_vms_output_end (abfd);
-	  _bfd_vms_output_begin (abfd, EOBJ_S_C_EGSD, -1);
-	  _bfd_vms_output_long (abfd, 0);
-	  /* Prepare output for subrecords.  */
-	  _bfd_vms_output_push (abfd);
-	}
-
-      _bfd_vms_output_begin (abfd, EGSD_S_C_SYM, -1);
-
-      /* Data type, alignment.  */
-      _bfd_vms_output_short (abfd, 0);
-
-      new_flags = 0;
-
-      if (old_flags & BSF_WEAK)
-	new_flags |= EGSY_S_V_WEAK;
-      if (bfd_is_com_section (symbol->section))		/* .comm  */
-	new_flags |= (EGSY_S_V_WEAK | EGSY_S_V_COMM);
-
-      if (old_flags & BSF_FUNCTION)
-	{
-	  new_flags |= EGSY_S_V_NORM;
-	  new_flags |= EGSY_S_V_REL;
-	}
-      if (old_flags & BSF_GLOBAL)
-	{
-	  new_flags |= EGSY_S_V_DEF;
-	  if (!bfd_is_abs_section (symbol->section))
-	    new_flags |= EGSY_S_V_REL;
-	}
-      _bfd_vms_output_short (abfd, new_flags);
-
-      if (old_flags & BSF_GLOBAL)
-	{
-	  /* Symbol definition.  */
-	  uquad code_address = 0;
-	  unsigned long ca_psindx = 0;
-	  unsigned long psindx;
-
-	  if ((old_flags & BSF_FUNCTION) && symbol->udata.p != NULL)
-	    {
-	      asymbol *sym;
-
-	      if (bfd_get_flavour (abfd) == bfd_target_evax_flavour)
-	        sym = ((struct evax_private_udata_struct *)symbol->udata.p)->enbsym;
-	      else
-	        sym = (asymbol *)symbol->udata.p;
-	      code_address = sym->value;
-	      ca_psindx = sym->section->index;
-	    }
-	  if (bfd_is_abs_section (symbol->section))
-	    psindx = abs_section_index;
-	  else
-	    psindx = symbol->section->index;
-
-	  _bfd_vms_output_quad (abfd, symbol->value);
-	  _bfd_vms_output_quad (abfd, code_address);
-	  _bfd_vms_output_long (abfd, ca_psindx);
-	  _bfd_vms_output_long (abfd, psindx);
-	}
-      hash = _bfd_vms_length_hash_symbol (abfd, symbol->name, EOBJ_S_C_SYMSIZ);
-      _bfd_vms_output_counted (abfd, hash);
-
-      _bfd_vms_output_flush (abfd);
-
-    }
-
-  _bfd_vms_output_alignment (abfd, 8);
-  _bfd_vms_output_pop (abfd);
-  _bfd_vms_output_end (abfd);
-
-  return 0;
-}
diff --git a/bfd/vms-hdr.c b/bfd/vms-hdr.c
deleted file mode 100644
index 343f53e..0000000
--- a/bfd/vms-hdr.c
+++ /dev/null
@@ -1,1382 +0,0 @@
-/* vms-hdr.c -- BFD back-end for VMS/VAX (openVMS/VAX) and
-   EVAX (openVMS/Alpha) files.
-   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006,
-   2007, 2008, 2009 Free Software Foundation, Inc.
-
-   HDR record handling functions
-   EMH record handling functions
-
-   EOM record handling functions
-   EEOM record handling functions
-
-   IHD record handling functions
-   EIHD record handling functions
-
-   ISD record handling functions
-   EISD record handling functions
-
-   IHS record handling functions
-   EIHS record handling functions
-
-   DBG record handling functions
-   EDBG record handling functions
-
-   TBT record handling functions
-   ETBT record handling functions
-
-   DST/DMT section handling functions
-
-   Written by Klaus K"ampf (kkaempf@rmi.de)
-
-   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 "bfdver.h"
-#include "bfdlink.h"
-#include "safe-ctype.h"
-#include "libbfd.h"
-
-#include "vms.h"
-
-static struct module *new_module (bfd *);
-static void parse_module
-  (bfd *, struct module *, unsigned char *, unsigned int);
-static struct module *build_module_list (bfd *);
-static bfd_boolean module_find_nearest_line
-  (bfd *, struct module *, bfd_vma, const char **, const char **,
-   unsigned int *);
-static int vms_slurp_debug (bfd *);
-
-#define SET_MODULE_PARSED(m) \
-  do { if ((m)->name == NULL) (m)->name = ""; } while (0)
-#define IS_MODULE_PARSED(m) ((m)->name != NULL)
-
-
-/* Read & process emh record
-   return 0 on success, -1 on error.  */
-
-int
-_bfd_vms_slurp_hdr (bfd *abfd, int objtype)
-{
-  unsigned char *ptr;
-  unsigned char *vms_rec;
-  int subtype;
-
-  vms_rec = PRIV(vms_rec);
-
-#if VMS_DEBUG
-  vms_debug(2, "HDR/EMH\n");
-#endif
-
-  switch (objtype)
-    {
-    case OBJ_S_C_HDR:
-      subtype = vms_rec[1];
-      break;
-    case EOBJ_S_C_EMH:
-      subtype = bfd_getl16 (vms_rec + 4) + EVAX_OFFSET;
-      break;
-    default:
-      subtype = -1;
-    }
-
-#if VMS_DEBUG
-  vms_debug(3, "subtype %d\n", subtype);
-#endif
-
-  switch (subtype)
-    {
-    case MHD_S_C_MHD:
-      /* Module header.  */
-      PRIV (hdr_data).hdr_b_strlvl = vms_rec[2];
-      PRIV (hdr_data).hdr_l_recsiz = bfd_getl16 (vms_rec + 3);
-      PRIV (hdr_data).hdr_t_name = _bfd_vms_save_counted_string (vms_rec + 5);
-      ptr = vms_rec + 5 + vms_rec[5] + 1;
-      PRIV (hdr_data).hdr_t_version = _bfd_vms_save_counted_string (ptr);
-      ptr += *ptr + 1;
-      PRIV (hdr_data).hdr_t_date = _bfd_vms_save_sized_string (ptr, 17);
-      break;
-
-    case MHD_S_C_LNM:
-      PRIV (hdr_data).hdr_c_lnm = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_size - 2));
-      break;
-
-    case MHD_S_C_SRC:
-      PRIV (hdr_data).hdr_c_src = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_size - 2));
-      break;
-
-    case MHD_S_C_TTL:
-      PRIV (hdr_data).hdr_c_ttl = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_size - 2));
-      break;
-
-    case EMH_S_C_MHD + EVAX_OFFSET:
-      /* Module header.  */
-      PRIV (hdr_data).hdr_b_strlvl = vms_rec[6];
-      PRIV (hdr_data).hdr_l_arch1  = bfd_getl32 (vms_rec + 8);
-      PRIV (hdr_data).hdr_l_arch2  = bfd_getl32 (vms_rec + 12);
-      PRIV (hdr_data).hdr_l_recsiz = bfd_getl32 (vms_rec + 16);
-      PRIV (hdr_data).hdr_t_name   = _bfd_vms_save_counted_string (vms_rec + 20);
-      ptr = vms_rec + 20 + vms_rec[20] + 1;
-      PRIV (hdr_data).hdr_t_version =_bfd_vms_save_counted_string (ptr);
-      ptr += *ptr + 1;
-      PRIV (hdr_data).hdr_t_date = _bfd_vms_save_sized_string (ptr, 17);
-      break;
-
-    case EMH_S_C_LNM + EVAX_OFFSET:
-      PRIV (hdr_data).hdr_c_lnm = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_size - 6));
-      break;
-
-    case EMH_S_C_SRC + EVAX_OFFSET:
-      PRIV (hdr_data).hdr_c_src = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_size - 6));
-      break;
-
-    case EMH_S_C_TTL + EVAX_OFFSET:
-      PRIV (hdr_data).hdr_c_ttl = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_size - 6));
-      break;
-
-    case MHD_S_C_CPR:
-    case MHD_S_C_MTC:
-    case MHD_S_C_GTX:
-    case EMH_S_C_CPR + EVAX_OFFSET:
-    case EMH_S_C_MTC + EVAX_OFFSET:
-    case EMH_S_C_GTX + EVAX_OFFSET:
-      break;
-
-    default:
-      bfd_set_error (bfd_error_wrong_format);
-      return -1;
-    }
-
-  return 0;
-}
-
-/* Output routines.  */
-
-/* Manufacture a VMS like time on a unix based system.
-   stolen from obj-vms.c.  */
-
-static unsigned char *
-get_vms_time_string (void)
-{
-  static unsigned char tbuf[18];
-#ifndef VMS
-#include <time.h>
-
-  char *pnt;
-  time_t timeb;
-
-  time (& timeb);
-  pnt = ctime (&timeb);
-  pnt[3] = 0;
-  pnt[7] = 0;
-  pnt[10] = 0;
-  pnt[16] = 0;
-  pnt[24] = 0;
-  sprintf ((char *) tbuf, "%2s-%3s-%s %s",
-	   pnt + 8, pnt + 4, pnt + 20, pnt + 11);
-#else
-#include <starlet.h>
-  struct
-  {
-    int Size;
-    unsigned char *Ptr;
-  } Descriptor;
-  Descriptor.Size = 17;
-  Descriptor.Ptr = tbuf;
-  SYS$ASCTIM (0, &Descriptor, 0, 0);
-#endif /* not VMS */
-
-#if VMS_DEBUG
-  vms_debug (6, "vmstimestring:'%s'\n", tbuf);
-#endif
-
-  return tbuf;
-}
-
-/* Write object header for bfd abfd.  */
-
-int
-_bfd_vms_write_hdr (bfd *abfd, int objtype)
-{
-  asymbol *symbol;
-  unsigned int symnum;
-  int had_case = 0;
-  int had_file = 0;
-  char version [256];
-
-#if VMS_DEBUG
-  vms_debug (2, "vms_write_hdr (%p)\n", abfd);
-#endif
-
-  _bfd_vms_output_alignment (abfd, 2);
-
-  /* MHD.  */
-  if (objtype != OBJ_S_C_HDR)
-    {
-      _bfd_vms_output_begin (abfd, EOBJ_S_C_EMH, EMH_S_C_MHD);
-      _bfd_vms_output_short (abfd, EOBJ_S_C_STRLVL);
-      _bfd_vms_output_long (abfd, 0);
-      _bfd_vms_output_long (abfd, 0);
-      _bfd_vms_output_long (abfd, MAX_OUTREC_SIZE);
-    }
-
-  /* Create module name from filename.  */
-  if (bfd_get_filename (abfd) != 0)
-    {
-      char *module = vms_get_module_name (bfd_get_filename (abfd), TRUE);
-      _bfd_vms_output_counted (abfd, module);
-      free (module);
-    }
-  else
-    _bfd_vms_output_counted (abfd, "NONAME");
-
-  _bfd_vms_output_counted (abfd, BFD_VERSION_STRING);
-  _bfd_vms_output_dump (abfd, get_vms_time_string (), EMH_DATE_LENGTH);
-  _bfd_vms_output_fill (abfd, 0, EMH_DATE_LENGTH);
-  _bfd_vms_output_flush (abfd);
-
-  /* LMN.  */
-  _bfd_vms_output_begin (abfd, EOBJ_S_C_EMH, EMH_S_C_LNM);
-  snprintf (version, sizeof (version), "GAS BFD v%s", BFD_VERSION_STRING);
-  _bfd_vms_output_dump (abfd, (unsigned char *)version, strlen (version));
-  _bfd_vms_output_flush (abfd);
-
-  /* SRC.  */
-  _bfd_vms_output_begin (abfd, EOBJ_S_C_EMH, EMH_S_C_SRC);
-
-  for (symnum = 0; symnum < abfd->symcount; symnum++)
-    {
-      symbol = abfd->outsymbols[symnum];
-
-      if (symbol->flags & BSF_FILE)
-	{
-	  if (CONST_STRNEQ ((char *)symbol->name, "<CASE:"))
-	    {
-	      PRIV (flag_hash_long_names) = symbol->name[6] - '0';
-	      PRIV (flag_show_after_trunc) = symbol->name[7] - '0';
-
-	      if (had_file)
-		break;
-	      had_case = 1;
-	      continue;
-	    }
-
-	  _bfd_vms_output_dump (abfd, (unsigned char *) symbol->name,
-				(int) strlen (symbol->name));
-	  if (had_case)
-	    break;
-	  had_file = 1;
-	}
-    }
-
-  if (symnum == abfd->symcount)
-    _bfd_vms_output_dump (abfd, (unsigned char *) STRING_COMMA_LEN ("noname"));
-
-  _bfd_vms_output_flush (abfd);
-
-  /* TTL.  */
-  _bfd_vms_output_begin (abfd, EOBJ_S_C_EMH, EMH_S_C_TTL);
-  _bfd_vms_output_dump (abfd, (unsigned char *) STRING_COMMA_LEN ("TTL"));
-  _bfd_vms_output_flush (abfd);
-
-  /* CPR.  */
-  _bfd_vms_output_begin (abfd, EOBJ_S_C_EMH, EMH_S_C_CPR);
-  _bfd_vms_output_dump (abfd,
-			 (unsigned char *)"GNU BFD ported by Klaus Kämpf 1994-1996",
-			 39);
-  _bfd_vms_output_flush (abfd);
-
-  return 0;
-}
-
-/* Process EOM/EEOM record
-   return 0 on success, -1 on error.  */
-
-int
-_bfd_vms_slurp_eom (bfd *abfd, int objtype)
-{
-  unsigned char *vms_rec;
-
-#if VMS_DEBUG
-  vms_debug(2, "EOM/EEOM\n");
-#endif
-
-  vms_rec = PRIV (vms_rec);
-
-  if ((objtype == OBJ_S_C_EOM)
-     || (objtype == OBJ_S_C_EOMW))
-    {
-    }
-  else
-    {
-      PRIV (eom_data).eom_l_total_lps
-        = bfd_getl32 (vms_rec + EEOM_S_L_TOTAL_LPS);
-      PRIV (eom_data).eom_w_comcod = bfd_getl16 (vms_rec + EEOM_S_W_COMCOD);
-      if (PRIV (eom_data).eom_w_comcod > 1)
-	{
-	  (*_bfd_error_handler) (_("Object module NOT error-free !\n"));
-	  bfd_set_error (bfd_error_bad_value);
-	  return -1;
-	}
-      PRIV (eom_data).eom_has_transfer = FALSE;
-      if (PRIV (rec_size) > 10)
-	{
-	   PRIV (eom_data).eom_has_transfer = TRUE;
-	   PRIV (eom_data).eom_b_tfrflg = vms_rec[EEOM_S_B_TFRFLG];
-	   PRIV (eom_data).eom_l_psindx
-	     = bfd_getl32 (vms_rec + EEOM_S_L_PSINDX);
-	   PRIV (eom_data).eom_l_tfradr
-	     = bfd_getl32 (vms_rec + EEOM_S_L_TFRADR);
-
-	   abfd->start_address = PRIV (eom_data).eom_l_tfradr;
-	}
-    }
-  return 0;
-}
-
-/* Write eom record for bfd abfd.  */
-
-int
-_bfd_vms_write_eom (bfd *abfd, int objtype)
-{
-#if VMS_DEBUG
-  vms_debug (2, "vms_write_eom (%p, %d)\n", abfd, objtype);
-#endif
-
-  _bfd_vms_output_begin (abfd, objtype, -1);
-  _bfd_vms_output_long (abfd, (unsigned long) (PRIV (vms_linkage_index) >> 1));
-  _bfd_vms_output_byte (abfd, 0);	/* Completion code.  */
-  _bfd_vms_output_byte (abfd, 0);	/* Fill byte.  */
-
-  if (bfd_get_start_address (abfd) != (bfd_vma)-1)
-    {
-      asection *section;
-
-      section = bfd_get_section_by_name (abfd, ".link");
-      if (section == 0)
-	{
-	  bfd_set_error (bfd_error_nonrepresentable_section);
-	  return -1;
-	}
-      _bfd_vms_output_short (abfd, 0);
-      _bfd_vms_output_long (abfd, (unsigned long) (section->index));
-      _bfd_vms_output_long (abfd,
-			     (unsigned long) bfd_get_start_address (abfd));
-      _bfd_vms_output_long (abfd, 0);
-    }
-
-  _bfd_vms_output_end (abfd);
-  return 0;
-}
-
-/* Read & process IHD/EIHD record.
-   Return 0 on success, -1 on error  */
-int
-_bfd_vms_slurp_ihd (bfd *abfd, unsigned int *isd_offset,
-		    unsigned int *ihs_offset)
-{
-  unsigned int imgtype, size;
-  bfd_vma symvva;
-
-#if VMS_DEBUG
-  vms_debug (8, "_bfd_vms_slurp_ihd\n");
-#endif
-
-  size = bfd_getl32 (PRIV (vms_rec) + EIHD_S_L_SIZE);
-  imgtype = bfd_getl32 (PRIV (vms_rec) + EIHD_S_L_IMGTYPE);
-
-  if (imgtype == EIHD_S_K_EXE)
-    abfd->flags |= EXEC_P;
-
-  symvva = bfd_getl64 (PRIV (vms_rec) + EIHD_S_Q_SYMVVA);
-  if (symvva != 0)
-    {
-      PRIV (symvva) = symvva;
-      abfd->flags |= DYNAMIC;
-    }
-
-  *isd_offset = bfd_getl32 (PRIV (vms_rec) + EIHD_S_L_ISDOFF);
-  *ihs_offset = bfd_getl32 (PRIV (vms_rec) + EIHD_S_L_SYMDBGOFF);
-
-#if VMS_DEBUG
-  vms_debug (4, "EIHD record size %d imgtype %d symvva 0x%llx isd %d ihs %d\n",
-	     size, imgtype, symvva, *isd_offset, *ihs_offset);
-#endif
-
-  return 0;
-}
-
-/* Read & process ISD/EISD record
-   return 0 on success, -1 on error  */
-
-int
-_bfd_vms_slurp_isd (bfd *abfd, unsigned int offset)
-{
-  int section_count = 0;
-  unsigned char *p;
-  unsigned int rec_size;
-
-#if VMS_DEBUG
-  vms_debug (8, "_bfd_vms_slurp_isd\n");
-#endif
-
-  for (p = PRIV (vms_rec) + offset;
-       (rec_size = bfd_getl32 (p + EISD_S_L_EISDSIZE)) != 0;
-       p += rec_size)
-    {
-      unsigned long long vaddr = bfd_getl64 (p + EISD_S_Q_VIR_ADDR);
-      unsigned int size = bfd_getl32 (p + EISD_S_L_SECSIZE);
-      unsigned int flags = bfd_getl32 (p + EISD_S_L_FLAGS);
-      unsigned int vbn = bfd_getl32 (p + EISD_S_L_VBN);
-      char *name = NULL;
-      asection *section;
-      flagword bfd_flags;
-
-#if VMS_DEBUG
-      vms_debug (4, "EISD record at 0x%x size 0x%x addr 0x%x bfd_flags 0x%x block %d\n",
-		 p - PRIV (vms_rec), size, vaddr, flags, vbn);
-#endif
-
-      /* VMS combines psects from .obj files into isects in the .exe.  This
-	 process doesn't preserve enough information to reliably determine
-	 what's in each section without examining the data.  This is
-	 especially true of DWARF debug sections.  */
-      bfd_flags = SEC_ALLOC;
-
-      if (flags & EISD_S_M_EXE)
-	bfd_flags |= SEC_CODE | SEC_HAS_CONTENTS | SEC_LOAD;
-
-      if (flags & EISD_S_M_NONSHRADR)
-	bfd_flags |= SEC_DATA | SEC_HAS_CONTENTS | SEC_LOAD;
-
-      if (!(flags & EISD_S_M_WRT))
-	bfd_flags |= SEC_READONLY;
-
-      if (flags & EISD_S_M_DZRO)
-	bfd_flags |= SEC_DATA;
-
-      if (flags & EISD_S_M_FIXUPVEC)
-	bfd_flags |= SEC_DATA | SEC_HAS_CONTENTS | SEC_LOAD;
-
-      if (flags & EISD_S_M_CRF)
-	bfd_flags |= SEC_HAS_CONTENTS | SEC_LOAD;
-
-      if (flags & EISD_S_M_GBL)
-	{
-	  name = _bfd_vms_save_counted_string (p + EISD_S_T_GBLNAM);
-	  bfd_flags |= SEC_COFF_SHARED_LIBRARY;
-	  bfd_flags &= ~(SEC_ALLOC | SEC_LOAD);
-	}
-      else
-	{
-	  name = (char*) bfd_alloc (abfd, 32);
-	  sprintf (name, "$LOCAL_%03d$", section_count++);
-	}
-
-      section = bfd_make_section (abfd, name);
-
-      if (!section)
-	return -1;
-
-      section->filepos = vbn ? VMS_BLOCK_SIZE * (vbn - 1) : (unsigned int)-1;
-      section->size = size;
-      section->vma = vaddr;
-
-      if (!bfd_set_section_flags (abfd, section, bfd_flags))
-	return -1;
-    }
-
-  return 0;
-}
-
-/* Read & process IHS/EIHS record
-   return 0 on success, -1 on error  */
-int
-_bfd_vms_slurp_ihs (bfd *abfd, unsigned int offset)
-{
-  unsigned char *p = PRIV (vms_rec) + offset;
-  unsigned int gstvbn = bfd_getl32 (p + EIHS_S_L_GSTVBN);
-  unsigned int gstsize ATTRIBUTE_UNUSED = bfd_getl32 (p + EIHS_S_L_GSTSIZE);
-  unsigned int dstvbn = bfd_getl32 (p + EIHS_S_L_DSTVBN);
-  unsigned int dstsize = bfd_getl32 (p + EIHS_S_L_DSTSIZE);
-  unsigned int dmtvbn = bfd_getl32 (p + EIHS_S_L_DMTVBN);
-  unsigned int dmtbytes = bfd_getl32 (p + EIHS_S_L_DMTBYTES);
-  asection *section;
-
-#if VMS_DEBUG
-  vms_debug (8, "_bfd_vms_slurp_ihs\n");
-  vms_debug (4, "EIHS record gstvbn %d gstsize %d dstvbn %d dstsize %d dmtvbn %d dmtbytes %d\n",
-	     gstvbn, gstsize, dstvbn, dstsize, dmtvbn, dmtbytes);
-#endif
-
-  if (dstvbn)
-    {
-      flagword bfd_flags = SEC_HAS_CONTENTS | SEC_DEBUGGING;
-
-      section = bfd_make_section (abfd, "$DST$");
-      if (!section)
-	return -1;
-
-      section->size = dstsize;
-      section->filepos = VMS_BLOCK_SIZE * (dstvbn - 1);
-
-      if (!bfd_set_section_flags (abfd, section, bfd_flags))
-	return -1;
-
-      PRIV (dst_section) = section;
-      abfd->flags |= (HAS_DEBUG | HAS_LINENO);
-    }
-
-  if (dmtvbn)
-    {
-      flagword bfd_flags = SEC_HAS_CONTENTS | SEC_DEBUGGING;
-
-      section = bfd_make_section (abfd, "$DMT$");
-      if (!section)
-	return -1;
-
-      section->size = dmtbytes;
-      section->filepos = VMS_BLOCK_SIZE * (dmtvbn - 1);
-
-      if (!bfd_set_section_flags (abfd, section, bfd_flags))
-	return -1;
-    }
-
-  if (gstvbn)
-    {
-      flagword bfd_flags = SEC_HAS_CONTENTS;
-
-      section = bfd_make_section (abfd, "$GST$");
-      if (!section)
-	return -1;
-
-      if (bfd_seek (abfd, VMS_BLOCK_SIZE * (gstvbn - 1), SEEK_SET))
-	{
-	  bfd_set_error (bfd_error_file_truncated);
-	  return -1;
-	}
-
-      if (_bfd_vms_slurp_object_records (abfd) != 0)
-	return -1;
-
-      section->filepos = VMS_BLOCK_SIZE * (gstvbn - 1);
-      section->size = bfd_tell (abfd) - section->filepos;
-
-      if (!bfd_set_section_flags (abfd, section, bfd_flags))
-	return -1;
-
-      abfd->flags |= HAS_SYMS;
-    }
-
-  return 0;
-}
-
-/* Build a new module for the specified BFD.  */
-
-static struct module *
-new_module (bfd *abfd)
-{
-  struct module *module
-    = (struct module *) bfd_zalloc (abfd, sizeof (struct module));
-  module->file_table_count = 16; /* Arbitrary.  */
-  module->file_table
-    = bfd_malloc (module->file_table_count * sizeof (struct fileinfo));
-  return module;
-}
-
-/* Parse debug info for a module and internalize it.  */
-
-static void
-parse_module (bfd *abfd, struct module *module, unsigned char *ptr,
-	      unsigned int length)
-{
-  unsigned char *maxptr = ptr + length, *src_ptr, *pcl_ptr;
-  unsigned int prev_linum = 0, curr_linenum = 0;
-  bfd_vma prev_pc = 0, curr_pc = 0;
-  struct srecinfo *curr_srec, *srec;
-  struct lineinfo *curr_line, *line;
-  struct funcinfo *funcinfo;
-
-  /* Initialize tables with zero element.  */
-  curr_srec = (struct srecinfo *) bfd_zalloc (abfd, sizeof (struct srecinfo));
-  module->srec_table = curr_srec;
-
-  curr_line = (struct lineinfo *) bfd_zalloc (abfd, sizeof (struct lineinfo));
-  module->line_table = curr_line;
-
-  while (ptr < maxptr)
-    {
-      /* The first byte is not counted in the recorded length.  */
-      int rec_length = bfd_getl16 (ptr) + 1;
-      int rec_type = bfd_getl16 (ptr + 2);
-
-#if VMS_DEBUG
-      _bfd_vms_debug (2, "DST record: length %d, type %d\n",
-		      rec_length, rec_type);
-#endif
-
-      switch (rec_type)
-	{
-	case DST_S_C_MODBEG:
-	  module->name
-	    = _bfd_vms_save_counted_string (ptr + DST_S_B_MODBEG_NAME);
-
-	  curr_pc = 0;
-	  prev_pc = 0;
-	  curr_linenum = 0;
-	  prev_linum = 0;
-
-#if VMS_DEBUG
-          _bfd_vms_debug (3, "module: %s\n", module->name);
-#endif
-	  break;
-
-	case DST_S_C_MODEND:
-#if VMS_DEBUG
-          _bfd_vms_debug (3, "end module\n");
-#endif
-	  break;
-
-	case DST_S_C_RTNBEG:
-	  funcinfo = (struct funcinfo *)
-	    bfd_zalloc (abfd, sizeof (struct funcinfo));
-          funcinfo->name
-	    = _bfd_vms_save_counted_string (ptr + DST_S_B_RTNBEG_NAME);
-	  funcinfo->low = bfd_getl32 (ptr + DST_S_L_RTNBEG_ADDRESS);
-	  funcinfo->next = module->func_table;
-	  module->func_table = funcinfo;
-    
-#if VMS_DEBUG
-          _bfd_vms_debug (3, "routine: %s at 0x%x\n",
-			  funcinfo->name, funcinfo->low);
-#endif
-	  break;
-
-	case DST_S_C_RTNEND:
-	  module->func_table->high = module->func_table->low
-	    + bfd_getl32 (ptr + DST_S_L_RTNEND_SIZE) - 1;
-
-	  if (module->func_table->high > module->high)
-	    module->high = module->func_table->high;
-
-#if VMS_DEBUG
-          _bfd_vms_debug (3, "end routine\n");
-#endif
-	  break;
-
-	case DST_S_C_PROLOG:
-#if VMS_DEBUG
-          _bfd_vms_debug (3, "prologue\n");
-#endif
-	  break;
-
-	case DST_S_C_EPILOG:
-#if VMS_DEBUG
-          _bfd_vms_debug (3, "epilog\n");
-#endif
-	  break;
-
-	case DST_S_C_BLKBEG:
-#if VMS_DEBUG
-          _bfd_vms_debug (3, "block\n");
-#endif
-	  break;
-
-	case DST_S_C_BLKEND:
-#if VMS_DEBUG
-          _bfd_vms_debug (3, "end block\n");
-#endif
-	  break;
-
-	case DST_S_C_SOURCE:
-	  src_ptr = ptr + DST_S_C_SOURCE_HEADER_SIZE;
-
-#if VMS_DEBUG
-	  _bfd_vms_debug (3, "source info\n");
-#endif
-
-	  while (src_ptr < ptr + rec_length)
-	    {
-	      int cmd = src_ptr[0], cmd_length, data;
-
-	      switch (cmd)
-		{
-		case DST_S_C_SRC_DECLFILE:
-		  {
-		    unsigned int fileid
-		      = bfd_getl16 (src_ptr + DST_S_W_SRC_DF_FILEID);
-		    char *filename
-		      = _bfd_vms_save_counted_string (src_ptr
-			  + DST_S_B_SRC_DF_FILENAME);
-
-		    while (fileid >= module->file_table_count)
-		      {
-			module->file_table_count *= 2;
-			module->file_table
-			  = bfd_realloc (module->file_table,
-					 module->file_table_count
-					   * sizeof (struct fileinfo));
-		      }
-
-		    module->file_table [fileid].name = filename;
-		    module->file_table [fileid].srec = 1;
-		    cmd_length = src_ptr[DST_S_B_SRC_DF_LENGTH] + 2;
-#if VMS_DEBUG
-		    _bfd_vms_debug (4, "DST_S_C_SRC_DECLFILE: %d, %s\n",
-				    fileid,
-				    module->file_table [fileid].name);
-#endif
-		  }
-		  break;
-
-		case DST_S_C_SRC_DEFLINES_B:
-		  /* Perform the association and set the next higher index
-		     to the limit.  */
-		  data = src_ptr[DST_S_B_SRC_UNSBYTE];
-		  srec = (struct srecinfo *)
-		    bfd_zalloc (abfd, sizeof (struct srecinfo));
-		  srec->line = curr_srec->line + data;
-		  srec->srec = curr_srec->srec + data;
-		  srec->sfile = curr_srec->sfile;
-		  curr_srec->next = srec;
-		  curr_srec = srec;
-		  cmd_length = 2;
-#if VMS_DEBUG
-		  _bfd_vms_debug (4, "DST_S_C_SRC_DEFLINES_B: %d\n", data);
-#endif
-		  break;
-
-		case DST_S_C_SRC_DEFLINES_W:
-		  /* Perform the association and set the next higher index
-		     to the limit.  */
-		  data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
-		  srec = (struct srecinfo *)
-		    bfd_zalloc (abfd, sizeof (struct srecinfo));
-		  srec->line = curr_srec->line + data;
-		  srec->srec = curr_srec->srec + data,
-		  srec->sfile = curr_srec->sfile;
-		  curr_srec->next = srec;
-		  curr_srec = srec;
-		  cmd_length = 3;
-#if VMS_DEBUG
-		  _bfd_vms_debug (4, "DST_S_C_SRC_DEFLINES_W: %d\n", data);
-#endif
-		  break;
-
-		case DST_S_C_SRC_INCRLNUM_B:
-		  data = src_ptr[DST_S_B_SRC_UNSBYTE];
-		  curr_srec->line += data;
-		  cmd_length = 2;
-#if VMS_DEBUG
-		  _bfd_vms_debug (4, "DST_S_C_SRC_INCRLNUM_B: %d\n", data);
-#endif
-		  break;
-
-		case DST_S_C_SRC_SETFILE:
-		  data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
-		  curr_srec->sfile = data;
-		  curr_srec->srec = module->file_table[data].srec;
-		  cmd_length = 3;
-#if VMS_DEBUG
-		  _bfd_vms_debug (4, "DST_S_C_SRC_SETFILE: %d\n", data);
-#endif
-		  break;
-
-		case DST_S_C_SRC_SETLNUM_L:
-		  data = bfd_getl32 (src_ptr + DST_S_L_SRC_UNSLONG);
-		  curr_srec->line = data;
-		  cmd_length = 5;
-#if VMS_DEBUG
-		  _bfd_vms_debug (4, "DST_S_C_SRC_SETLNUM_L: %d\n", data);
-#endif
-		  break;
-
-		case DST_S_C_SRC_SETLNUM_W:
-		  data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
-		  curr_srec->line = data;
-		  cmd_length = 3;
-#if VMS_DEBUG
-		  _bfd_vms_debug (4, "DST_S_C_SRC_SETLNUM_W: %d\n", data);
-#endif
-		  break;
-
-		case DST_S_C_SRC_SETREC_L:
-		  data = bfd_getl32 (src_ptr + DST_S_L_SRC_UNSLONG);
-		  curr_srec->srec = data;
-		  module->file_table[curr_srec->sfile].srec = data;
-		  cmd_length = 5;
-#if VMS_DEBUG
-		  _bfd_vms_debug (4, "DST_S_C_SRC_SETREC_L: %d\n", data);
-#endif
-		  break;
-
-		case DST_S_C_SRC_SETREC_W:
-		  data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
-		  curr_srec->srec = data;
-		  module->file_table[curr_srec->sfile].srec = data;
-		  cmd_length = 3;
-#if VMS_DEBUG
-		  _bfd_vms_debug (4, "DST_S_C_SRC_SETREC_W: %d\n", data);
-#endif
-		  break;
-
-		case DST_S_C_SRC_FORMFEED:
-		  cmd_length = 1;
-#if VMS_DEBUG
-		  _bfd_vms_debug (4, "DST_S_C_SRC_FORMFEED\n");
-#endif
-		  break;
-
-		default:
-		  (*_bfd_error_handler) (_("unknown source command %d"),
-					 cmd);
-		  cmd_length = 2;
-		  break;
-		}
-
-	      src_ptr += cmd_length;
-	    }
-	  break;
-
-	case DST_S_C_LINE_NUM:
-	  pcl_ptr = ptr + DST_S_C_LINE_NUM_HEADER_SIZE;
-
-#if VMS_DEBUG
-	  _bfd_vms_debug (3, "line info\n");
-#endif
-
-	  while (pcl_ptr < ptr + rec_length)
-	    {
-	      /* The command byte is signed so we must sign-extend it.  */
-	      int cmd = ((signed char *)pcl_ptr)[0], cmd_length, data;
-
-	      switch (cmd)
-		{
-		case DST_S_C_DELTA_PC_W:
-		  data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
-		  curr_pc += data;
-		  curr_linenum += 1;
-		  cmd_length = 3;
-#if VMS_DEBUG
-		  _bfd_vms_debug (4, "DST_S_C_DELTA_PC_W: %d\n", data);
-#endif
-		  break;
-
-		case DST_S_C_DELTA_PC_L:
-		  data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
-		  curr_pc += data;
-		  curr_linenum += 1;
-		  cmd_length = 5;
-#if VMS_DEBUG
-		  _bfd_vms_debug (4, "DST_S_C_DELTA_PC_L: %d\n", data);
-#endif
-		  break;
-
-		case DST_S_C_INCR_LINUM:
-		  data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
-		  curr_linenum += data;
-		  cmd_length = 2;
-#if VMS_DEBUG
-		  _bfd_vms_debug (4, "DST_S_C_INCR_LINUM: %d\n", data);
-#endif
-		  break;
-
-		case DST_S_C_INCR_LINUM_W:
-		  data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
-		  curr_linenum += data;
-		  cmd_length = 3;
-#if VMS_DEBUG
-		  _bfd_vms_debug (4, "DST_S_C_INCR_LINUM_W: %d\n", data);
-#endif
-		  break;
-
-		case DST_S_C_INCR_LINUM_L:
-		  data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
-		  curr_linenum += data;
-		  cmd_length = 5;
-#if VMS_DEBUG
-		  _bfd_vms_debug (4, "DST_S_C_INCR_LINUM_L: %d\n", data);
-#endif
-		  break;
-
-		case DST_S_C_SET_LINUM_INCR:
-		  (*_bfd_error_handler)
-		    (_("DST_S_C_SET_LINUM_INCR not implemented"));
-		  cmd_length = 2;
-		  break;
-
-		case DST_S_C_SET_LINUM_INCR_W:
-		  (*_bfd_error_handler)
-		    (_("DST_S_C_SET_LINUM_INCR_W not implemented"));
-		  cmd_length = 3;
-		  break;
-
-		case DST_S_C_RESET_LINUM_INCR:
-		  (*_bfd_error_handler)
-		    (_("DST_S_C_RESET_LINUM_INCR not implemented"));
-		  cmd_length = 1;
-		  break;
-
-		case DST_S_C_BEG_STMT_MODE:
-		  (*_bfd_error_handler)
-		    (_("DST_S_C_BEG_STMT_MODE not implemented"));
-		  cmd_length = 1;
-		  break;
-
-		case DST_S_C_END_STMT_MODE:
-		  (*_bfd_error_handler)
-		    (_("DST_S_C_END_STMT_MODE not implemented"));
-		  cmd_length = 1;
-		  break;
-
-		case DST_S_C_SET_LINUM_B:
-		  data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
-		  curr_linenum = data;
-		  cmd_length = 2;
-#if VMS_DEBUG
-		  _bfd_vms_debug (4, "DST_S_C_SET_LINUM_B: %d\n", data);
-#endif
-		  break;
-	
-		case DST_S_C_SET_LINE_NUM:
-		  data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
-		  curr_linenum = data;
-		  cmd_length = 3;
-#if VMS_DEBUG
-		  _bfd_vms_debug (4, "DST_S_C_SET_LINE_NUM: %d\n", data);
-#endif
-		  break;
-
-		case DST_S_C_SET_LINUM_L:
-		  data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
-		  curr_linenum = data;
-		  cmd_length = 5;
-#if VMS_DEBUG
-		  _bfd_vms_debug (4, "DST_S_C_SET_LINUM_L: %d\n", data);
-#endif
-		  break;
-
-		case DST_S_C_SET_PC:
-		  (*_bfd_error_handler)
-		    (_("DST_S_C_SET_PC not implemented"));
-		  cmd_length = 2;
-		  break;
-
-		case DST_S_C_SET_PC_W:
-		  (*_bfd_error_handler)
-		    (_("DST_S_C_SET_PC_W not implemented"));
-		  cmd_length = 3;
-		  break;
-
-		case DST_S_C_SET_PC_L:
-		  (*_bfd_error_handler)
-		    (_("DST_S_C_SET_PC_L not implemented"));
-		  cmd_length = 5;
-		  break;
-
-		case DST_S_C_SET_STMTNUM:
-		  (*_bfd_error_handler)
-		    (_("DST_S_C_SET_STMTNUM not implemented"));
-		  cmd_length = 2;
-		  break;
-
-		case DST_S_C_TERM:
-		  data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
-		  curr_pc += data;
-		  cmd_length = 2;
-#if VMS_DEBUG
-		  _bfd_vms_debug (4, "DST_S_C_TERM: %d\n", data);
-#endif
-		  break;
-
-		case DST_S_C_TERM_W:
-		  data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
-		  curr_pc += data;
-		  cmd_length = 3;
-#if VMS_DEBUG
-		  _bfd_vms_debug (4, "DST_S_C_TERM_W: %d\n", data);
-#endif
-		  break;
-
-		case DST_S_C_TERM_L:
-		  data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
-		  curr_pc += data;
-		  cmd_length = 5;
-#if VMS_DEBUG
-		  _bfd_vms_debug (4, "DST_S_C_TERM_L: %d\n", data);
-#endif
-		  break;
-
-		case DST_S_C_SET_ABS_PC:
-		  data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
-		  curr_pc = data;
-		  cmd_length = 5;
-#if VMS_DEBUG
-		  _bfd_vms_debug (4, "DST_S_C_SET_ABS_PC: 0x%x\n", data);
-#endif
-		  break;
-
-		default:
-		  if (cmd <= 0)
-		    {
-		      curr_pc -= cmd;
-		      curr_linenum += 1;
-		      cmd_length = 1;
-#if VMS_DEBUG
-		      _bfd_vms_debug (4, "bump pc to 0x%llx and line to %d\n",
-				      curr_pc, curr_linenum);
-#endif
-		    }
-		  else
-		    {
-		      (*_bfd_error_handler) (_("unknown line command %d"),
-					     cmd);
-		      cmd_length = 2;
-		    }
-		  break;
-		}
-
-	      if ((curr_linenum != prev_linum && curr_pc != prev_pc)
-		  || cmd <= 0
-		  || cmd == DST_S_C_DELTA_PC_L
-		  || cmd == DST_S_C_DELTA_PC_W)
-		{
-		  line = (struct lineinfo *)
-		    bfd_zalloc (abfd, sizeof (struct lineinfo));
-		  line->address = curr_pc;
-		  line->line = curr_linenum;
-
-		  curr_line->next = line;
-		  curr_line = line;
-
-		  prev_linum = curr_linenum;
-		  prev_pc = curr_pc;
-#if VMS_DEBUG
-		  _bfd_vms_debug (4, "-> correlate pc 0x%llx with line %d\n",
-				  curr_pc, curr_linenum);
-#endif
-		}
-
-	      pcl_ptr += cmd_length;
-	    }
-	  break;
-
-	case 0x17: /* Undocumented type used by DEC C to declare equates.  */
-#if VMS_DEBUG
-	  _bfd_vms_debug (3, "undocumented type 0x17\n");
-#endif
-	  break;
-
-	default:
-#if VMS_DEBUG
-	  _bfd_vms_debug (3, "ignoring record\n");
-#endif
-	  break;
-
-	}
-
-      ptr += rec_length;
-    }
-
-  /* Finalize tables with EOL marker.  */
-  srec = (struct srecinfo *) bfd_zalloc (abfd, sizeof (struct srecinfo));
-  srec->line = (unsigned int) -1;
-  srec->srec = (unsigned int) -1;
-  curr_srec->next = srec;
-
-  line = (struct lineinfo *) bfd_zalloc (abfd, sizeof (struct lineinfo));
-  line->line = (unsigned int) -1;
-  line->address = (bfd_vma) -1;
-  curr_line->next = line;
-
-  /* Advertise that this module has been parsed.  This is needed
-     because parsing can be either performed at module creation
-     or deferred until debug info is consumed.  */
-  SET_MODULE_PARSED (module);
-}
-
-/* Build the list of modules for the specified BFD.  */
-
-static struct module *
-build_module_list (bfd *abfd)
-{
-  struct module *module, *list = NULL;
-  asection *dmt;
-
-  if ((dmt = bfd_get_section_by_name (abfd, "$DMT$")))
-    {
-      /* We have a DMT section so this must be an image.  Parse the
-	 section and build the list of modules.  This is sufficient
-	 since we can compute the start address and the end address
-	 of every module from the section contents.  */
-      bfd_size_type size = bfd_get_section_size (dmt);
-      unsigned char *ptr, *end;
-
-      ptr = (unsigned char *) bfd_alloc (abfd, size);
-      if (! ptr)
-	return NULL;
-
-      if (! bfd_get_section_contents (abfd, dmt, ptr, 0, size))
-	return NULL;
-
-#if VMS_DEBUG
-      _bfd_vms_debug (2, "DMT\n");
-#endif
-
-      end = ptr + size;
-
-      while (ptr < end)
-	{
-	  /* Each header declares a module with its start offset and size
-	     of debug info in the DST section, as well as the count of
-	     program sections (i.e. address spans) it contains.  */
-	  int modbeg = bfd_getl32 (ptr + DBG_S_L_DMT_MODBEG);
-	  int msize = bfd_getl32 (ptr + DBG_S_L_DST_SIZE);
-	  int count = bfd_getl16 (ptr + DBG_S_W_DMT_PSECT_COUNT);
-	  ptr += DBG_S_C_DMT_HEADER_SIZE;
-
-#if VMS_DEBUG
-	  _bfd_vms_debug (3, "module: modbeg = %d, size = %d, count = %d\n",
-			  modbeg, msize, count);
-#endif
-
-	  /* We create a 'module' structure for each program section since
-	     we only support contiguous addresses in a 'module' structure.
-	     As a consequence, the actual debug info in the DST section is
-	     shared and can be parsed multiple times; that doesn't seem to
-	     cause problems in practice.  */
-	  while (count-- > 0)
-	    {
-	      int start = bfd_getl32 (ptr + DBG_S_L_DMT_PSECT_START);
-	      int length = bfd_getl32 (ptr + DBG_S_L_DMT_PSECT_LENGTH);
-	      module = new_module (abfd);
-	      module->modbeg = modbeg;
-	      module->size = msize;
-	      module->low = start;
-	      module->high = start + length;
-	      module->next = list;
-	      list = module;
-	      ptr += DBG_S_C_DMT_PSECT_SIZE;
-
-#if VMS_DEBUG
-	      _bfd_vms_debug (4, "section: start = 0x%x, length = %d\n",
-			      start, length);
-#endif
-	    }
-	}
-    }
-  else
-    {
-      /* We don't have a DMT section so this must be an object.  Parse
-	 the module right now in order to compute its start address and
-	 end address.  */
-      module = new_module (abfd);
-      parse_module (abfd, module, PRIV (dst_section)->contents,
-		    PRIV (dst_ptr_end) - PRIV (dst_section)->contents);
-      list = module;
-    }
-
-  return list;
-}
-
-/* Calculate and return the name of the source file and the line nearest
-   to the wanted location in the specified module.  */
-
-static bfd_boolean
-module_find_nearest_line (bfd *abfd, struct module *module, bfd_vma addr,
-			  const char **file, const char **func, 
-			  unsigned int *line)
-{
-  struct funcinfo *funcinfo;
-  struct lineinfo *lineinfo;
-  struct srecinfo *srecinfo;
-  bfd_boolean ret = FALSE;
-
-  /* Parse this module if that was not done at module creation.  */
-  if (! IS_MODULE_PARSED (module))
-    {
-      unsigned int size = module->size;
-      unsigned int modbeg = PRIV (dst_section)->filepos + module->modbeg;
-      unsigned char *buffer = (unsigned char *) bfd_malloc (module->size);
-
-      if (bfd_seek (abfd, modbeg, SEEK_SET) != 0
-	  || bfd_bread (buffer, size, abfd) != size)
-	{
-	  bfd_set_error (bfd_error_no_debug_section);
-	  return FALSE;
-	}
-
-      parse_module (abfd, module, buffer, size);
-      free (buffer);
-    }
-
-  /* Find out the function (if any) that contains the address.  */
-  for (funcinfo = module->func_table; funcinfo; funcinfo = funcinfo->next)
-    if (addr >= funcinfo->low && addr <= funcinfo->high)
-      {
-        *func = funcinfo->name;
-	ret = TRUE;
-	break;
-      }
-
-  /* Find out the source file and the line nearest to the address.  */
-  for (lineinfo = module->line_table; lineinfo; lineinfo = lineinfo->next)
-    if (lineinfo->next && addr < lineinfo->next->address)
-      {
-	for (srecinfo = module->srec_table; srecinfo; srecinfo = srecinfo->next)
-	  if (srecinfo->next && lineinfo->line < srecinfo->next->line)
-	    {
-	      if (srecinfo->sfile > 0)
-		{
-		  *file = module->file_table[srecinfo->sfile].name;
-		  *line = srecinfo->srec + lineinfo->line - srecinfo->line;
-		}
-	      else
-		{
-		  *file = module->name;
-		  *line = lineinfo->line;
-		}
-	      return TRUE;
-	    }
-
-	break;
-      }
-
-  return ret;
-}
-
-/* Provided a BFD, a section and an offset into the section, calculate and
-   return the name of the source file and the line nearest to the wanted
-   location.  */
-
-bfd_boolean
-_bfd_vms_find_nearest_dst_line (bfd *abfd, asection *section,
-				asymbol **symbols ATTRIBUTE_UNUSED,
-				bfd_vma offset, const char **file,
-				const char **func, unsigned int *line)
-{
-  struct module *module;
-
-  /* What address are we looking for?  */
-  bfd_vma addr = section->vma + offset;
-
-  *file = NULL;
-  *func = NULL;
-  *line = 0;
-
-  if (PRIV (dst_section) == NULL)
-    return FALSE;
-
-  if (PRIV (modules) == NULL)
-    {
-      PRIV (modules) = build_module_list (abfd);
-      if (PRIV (modules) == NULL)
-        return FALSE;
-    }
-
-  for (module = PRIV (modules); module; module = module->next)
-    if (addr >= module->low && addr <= module->high)
-      return module_find_nearest_line (abfd, module, addr, file, func, line);
-
-  return FALSE;
-}
-
-/* Process EDBG/ETBT record.
-   Return 0 on success, -1 on error  */
-
-static int
-vms_slurp_debug (bfd *abfd)
-{
-  if (PRIV (dst_section) == NULL)
-    {
-      /* We have no way to find out beforehand how much debug info there
-	 is in an object file, so pick an initial amount and grow it as
-	 needed later.  */
-      flagword flags = SEC_HAS_CONTENTS | SEC_DEBUGGING | SEC_RELOC;
-      asection *section = bfd_make_section (abfd, "$DST$");
-      if (!section)
-	return -1;
-      section->size = 1024;
-      if (!bfd_set_section_flags (abfd, section, flags))
-	return -1;
-      section->contents = ((unsigned char *)
-			   bfd_zmalloc (section->size));
-      if (section->contents == NULL)
-	return -1;
-      section->filepos = (unsigned int)-1;
-      PRIV (dst_section) = section;
-    }
-
-  PRIV (image_section) = PRIV (dst_section);
-  PRIV (image_ptr) = PRIV (dst_section)->contents;
- 
-  return _bfd_vms_slurp_tir (abfd, EOBJ_S_C_ETIR);
-}
-
-/* Process DBG/EDBG record.
-   Return 0 on success, -1 on error.  */
-
-int
-_bfd_vms_slurp_dbg (bfd *abfd, int objtype ATTRIBUTE_UNUSED)
-{
-#if VMS_DEBUG
-  _bfd_vms_debug (2, "DBG/EDBG\n");
-#endif
-
-  abfd->flags |= (HAS_DEBUG | HAS_LINENO);
-
-  return vms_slurp_debug (abfd);
-}
-
-/* Process TBT/ETBT record.
-   Return 0 on success, -1 on error.  */
-
-int
-_bfd_vms_slurp_tbt (bfd *abfd, int objtype ATTRIBUTE_UNUSED)
-{
-#if VMS_DEBUG
-  _bfd_vms_debug (2, "TBT/ETBT\n");
-#endif
-
-  abfd->flags |= HAS_LINENO;
-
-  return vms_slurp_debug (abfd);
-}
-
-/* Write DBG/EDBG record.  */
-
-int
-_bfd_vms_write_dbg (bfd *abfd ATTRIBUTE_UNUSED, int objtype ATTRIBUTE_UNUSED)
-{
-#if VMS_DEBUG
-  _bfd_vms_debug (2, "vms_write_dbg (%p, %d)\n", abfd, objtype);
-#endif
-
-  return 0;
-}
-
-/* Write TBT/ETBT record.  */
-
-int
-_bfd_vms_write_tbt (bfd *abfd ATTRIBUTE_UNUSED, int objtype ATTRIBUTE_UNUSED)
-{
-#if VMS_DEBUG
-  _bfd_vms_debug (2, "vms_write_tbt (%p, %d)\n", abfd, objtype);
-#endif
-
-  return 0;
-}
diff --git a/bfd/vms-misc.c b/bfd/vms-misc.c
index 9646324..67cc25a 100644
--- a/bfd/vms-misc.c
+++ b/bfd/vms-misc.c
@@ -32,15 +32,17 @@
 #include "libbfd.h"
 #include "safe-ctype.h"
 
-#include "vms.h"
-
-#define MIN(a,b) ((a) < (b) ? (a) : (b))
+#ifdef VMS
+#include <rms.h>
+#include <unixlib.h>
+#include <starlet.h>
+#define RME$C_SETRFM 0x00000001
+#include <unistd.h>
+#endif
+#include <time.h>
 
-static int hash_string PARAMS ((const char *));
-static asymbol *new_symbol PARAMS ((bfd *, char *));
-static void maybe_adjust_record_pointer_for_object PARAMS ((bfd *));
-static int vms_get_remaining_object_record PARAMS ((bfd *, int ));
-static int vms_get_remaining_image_record PARAMS ((bfd *, int ));
+#include "vms.h"
+#include "vms/emh.h"
 
 #if VMS_DEBUG
 /* Debug functions.  */
@@ -82,7 +84,7 @@ _bfd_vms_debug (int level, char *format, ...)
   if (abslvl > min_level)
     return;
 
-  while (--level>0)
+  while (--level > 0)
     fprintf (output, " ");
   va_start (args, format);
   vfprintf (output, format, args);
@@ -94,10 +96,7 @@ _bfd_vms_debug (int level, char *format, ...)
    hex dump 'size' bytes starting at 'ptr'.  */
 
 void
-_bfd_hexdump (int level,
-	      unsigned char *ptr,
-	      int size,
-	      int offset)
+_bfd_hexdump (int level, unsigned char *ptr, int size, int offset)
 {
   unsigned char *lptr = ptr;
   int count = 0;
@@ -105,445 +104,35 @@ _bfd_hexdump (int level,
 
   while (size-- > 0)
     {
-      if ((count%16) == 0)
+      if ((count % 16) == 0)
 	vms_debug (level, "%08lx:", start);
       vms_debug (-level, " %02x", *ptr++);
       count++;
       start++;
       if (size == 0)
 	{
-	  while ((count%16) != 0)
+	  while ((count % 16) != 0)
 	    {
 	      vms_debug (-level, "   ");
 	      count++;
 	    }
 	}
-      if ((count%16) == 0)
+      if ((count % 16) == 0)
 	{
 	  vms_debug (-level, " ");
 	  while (lptr < ptr)
 	    {
-	      vms_debug (-level, "%c", (*lptr < 32)?'.':*lptr);
+	      vms_debug (-level, "%c", (*lptr < 32) ? '.' : *lptr);
 	      lptr++;
 	    }
 	  vms_debug (-level, "\n");
 	}
     }
-  if ((count%16) != 0)
+  if ((count % 16) != 0)
     vms_debug (-level, "\n");
 }
 #endif
 
-/* Hash functions
-
-   These are needed when reading an object file.  */
-
-/* Allocate new vms_hash_entry
-   keep the symbol name and a pointer to the bfd symbol in the table.  */
-
-struct bfd_hash_entry *
-_bfd_vms_hash_newfunc (struct bfd_hash_entry *entry,
-		       struct bfd_hash_table *table,
-		       const char *string)
-{
-  vms_symbol_entry *ret;
-
-#if VMS_DEBUG
-  vms_debug (5, "_bfd_vms_hash_newfunc (%p, %p, %s)\n", entry, table, string);
-#endif
-
-  if (entry == NULL)
-    {
-      ret = (vms_symbol_entry *)
-	      bfd_hash_allocate (table, sizeof (vms_symbol_entry));
-      if (ret ==  NULL)
-	{
-	  bfd_set_error (bfd_error_no_memory);
-	  return NULL;
-	}
-      entry = (struct bfd_hash_entry *) ret;
-    }
-
-  /* Call the allocation method of the base class.  */
-  ret = (vms_symbol_entry *) bfd_hash_newfunc (entry, table, string);
-#if VMS_DEBUG
-  vms_debug (6, "_bfd_vms_hash_newfunc ret %p\n", ret);
-#endif
-
-  ret->symbol = NULL;
-
-  return (struct bfd_hash_entry *)ret;
-}
-
-/* Object file input functions.  */
-
-/* Return type and size from record header (buf) on Alpha.  */
-
-void
-_bfd_vms_get_header_values (bfd * abfd ATTRIBUTE_UNUSED,
-			    unsigned char *buf,
-			    int *type,
-			    int *size)
-{
-  if (type)
-    *type = bfd_getl16 (buf);
-
-  if (size)
-    *size = bfd_getl16 (buf+2);
-
-#if VMS_DEBUG
-  vms_debug (10, "_bfd_vms_get_header_values type %x, size %x\n",
-	     type ? *type : 0, size ? *size : 0);
-#endif
-}
-
-/* Get next record from object file to vms_buf.
-   Set PRIV(buf_size) and return it
-
-   This is a little tricky since it should be portable.
-
-   The openVMS object file has 'variable length' which means that
-   read() returns data in chunks of (hopefully) correct and expected
-   size.  The linker (and other tools on VMS) depend on that. Unix
-   doesn't know about 'formatted' files, so reading and writing such
-   an object file in a Unix environment is not trivial.
-
-   With the tool 'file' (available on all VMS FTP sites), one
-   can view and change the attributes of a file.  Changing from
-   'variable length' to 'fixed length, 512 bytes' reveals the
-   record size at the first 2 bytes of every record.  The same
-   may happen during the transfer of object files from VMS to Unix,
-   at least with UCX, the DEC implementation of TCP/IP.
-
-   The VMS format repeats the size at bytes 2 & 3 of every record.
-
-   On the first call (file_format == FF_UNKNOWN) we check if
-   the first and the third byte pair (!) of the record match.
-   If they do it's an object file in an Unix environment or with
-   wrong attributes (FF_FOREIGN), else we should be in a VMS
-   environment where read() returns the record size (FF_NATIVE).
-
-   Reading is always done in 2 steps:
-    1. first just the record header is read and the size extracted,
-    2. then the read buffer is adjusted and the remaining bytes are
-       read in.
-
-   All file I/O is done on even file positions.  */
-
-#define VMS_OBJECT_ADJUSTMENT  2
-
-static void
-maybe_adjust_record_pointer_for_object (bfd *abfd)
-{
-  /* Set the file format once for all on the first invocation.  */
-  if (PRIV (file_format) == FF_UNKNOWN)
-    {
-      if (PRIV (vms_rec)[0] == PRIV (vms_rec)[4]
-	  && PRIV (vms_rec)[1] == PRIV (vms_rec)[5])
-	PRIV (file_format) = FF_FOREIGN;
-      else
-	PRIV (file_format) = FF_NATIVE;
-    }
-
-  /* The adjustment is needed only in an Unix environment.  */
-  if (PRIV (file_format) == FF_FOREIGN)
-    PRIV (vms_rec) += VMS_OBJECT_ADJUSTMENT;
-}
-
-/* Get first record from file and return the file type.  */
-
-int
-_bfd_vms_get_first_record (bfd *abfd)
-{
-  unsigned int test_len;
-
-#if VMS_DEBUG
-  vms_debug (8, "_bfd_vms_get_first_record\n");
-#endif
-
-  if (PRIV (is_vax))
-    test_len = 0;
-  else
-    /* Minimum is 6 bytes for objects (2 bytes size, 2 bytes record id,
-       2 bytes size repeated) and 12 bytes for images (4 bytes major id,
-       4 bytes minor id, 4 bytes length).  */
-    test_len = 12;
-
-  /* Size the main buffer.  */
-  if (PRIV (buf_size) == 0)
-    {
-      /* On VAX there's no size information in the record, so
-	 start with OBJ_S_C_MAXRECSIZ.  */
-      bfd_size_type amt = (test_len ? test_len : OBJ_S_C_MAXRECSIZ);
-      PRIV (vms_buf) = (unsigned char *) bfd_malloc (amt);
-      PRIV (buf_size) = amt;
-    }
-
-  /* Initialize the record pointer.  */
-  PRIV (vms_rec) = PRIV (vms_buf);
-
-  /* We only support modules on VAX.  */
-  if (PRIV (is_vax))
-    {
-      if (vms_get_remaining_object_record (abfd, test_len) <= 0)
-	return FT_UNKNOWN;
-
-#if VMS_DEBUG
-      vms_debug (2, "file type is VAX module\n");
-#endif
-
-      return FT_MODULE;
-    }
-
-  if (bfd_bread (PRIV (vms_buf), test_len, abfd) != test_len)
-    {
-      bfd_set_error (bfd_error_file_truncated);
-      return FT_UNKNOWN;
-    }
-
-  /* Is it an image?  */
-  if ((bfd_getl32 (PRIV (vms_rec)) == EIHD_S_K_MAJORID)
-      && (bfd_getl32 (PRIV (vms_rec) + 4) == EIHD_S_K_MINORID))
-    {
-      if (vms_get_remaining_image_record (abfd, test_len) <= 0)
-	return FT_UNKNOWN;
-
-#if VMS_DEBUG
-      vms_debug (2, "file type is image\n");
-#endif
-
-      return FT_IMAGE;
-    }
-
-  /* Assume it's a module and adjust record pointer if necessary.  */
-  maybe_adjust_record_pointer_for_object (abfd);
-
-  /* But is it really a module?  */
-  if (bfd_getl16 (PRIV (vms_rec)) <= EOBJ_S_C_MAXRECTYP
-      && bfd_getl16 (PRIV (vms_rec) + 2) <= EOBJ_S_C_MAXRECSIZ)
-    {
-      if (vms_get_remaining_object_record (abfd, test_len) <= 0)
-	return FT_UNKNOWN;
-
-#if VMS_DEBUG
-      vms_debug (2, "file type is module\n");
-#endif
-
-      return FT_MODULE;
-    }
-
-#if VMS_DEBUG
-  vms_debug (2, "file type is unknown\n");
-#endif
-
-  return FT_UNKNOWN;
-}
-
-/* Implement step #1 of the object record reading procedure.
-   Return the record type or -1 on failure.  */
-
-int
-_bfd_vms_get_object_record (bfd *abfd)
-{
-  unsigned int test_len;
-  int type;
-
-#if VMS_DEBUG
-  vms_debug (8, "_bfd_vms_get_obj_record\n");
-#endif
-
-  if (PRIV (is_vax))
-    test_len = 0;
-  else
-    {
-      int off = 0;
-
-      /* See _bfd_vms_get_first_record.  */
-      test_len = 6;
-
-      /* Skip odd alignment byte.  */
-      if (bfd_tell (abfd) & 1)
-	{
-	  if (bfd_bread (PRIV (vms_buf), 1, abfd) != 1)
-	    {
-	      bfd_set_error (bfd_error_file_truncated);
-	      return -1;
-	    }
-          /* Alignment byte may be present or not.  This is not easy to
-             detect but all object record types are not 0 (on Alpha VMS).
-             We also hope that pad byte is 0.  */
-          if (PRIV (vms_buf)[0])
-            off = 1;
-	}
-
-      /* Read the record header  */
-      if (bfd_bread (PRIV (vms_buf) + off, test_len - off, abfd)
-          != test_len - off)
-	{
-	  bfd_set_error (bfd_error_file_truncated);
-	  return -1;
-	}
-
-      /* Reset the record pointer.  */
-      PRIV (vms_rec) = PRIV (vms_buf);
-      maybe_adjust_record_pointer_for_object (abfd);
-    }
-
-  if (vms_get_remaining_object_record (abfd, test_len) <= 0)
-    return -1;
-
-  if (PRIV (is_vax))
-    type = PRIV (vms_rec) [0];
-  else
-    type = bfd_getl16 (PRIV (vms_rec));
-
-#if VMS_DEBUG
-  vms_debug (8, "_bfd_vms_get_obj_record: rec %p, size %d, type %d\n",
-	      PRIV (vms_rec), PRIV (rec_size), type);
-#endif
-
-  return type;
-}
-
-/* Implement step #2 of the object record reading procedure.
-   Return the size of the record or 0 on failure.  */
-
-static int
-vms_get_remaining_object_record (bfd *abfd, int read_so_far)
-{
-#if VMS_DEBUG
-  vms_debug (8, "vms_get_remaining_obj_record\n");
-#endif
-
-  if (PRIV (is_vax))
-    {
-      if (read_so_far != 0)
-        abort ();
-
-      PRIV (rec_size) = bfd_bread (PRIV (vms_buf), PRIV (buf_size), abfd);
-
-      if (PRIV (rec_size) <= 0)
-	{
-	  bfd_set_error (bfd_error_file_truncated);
-	  return 0;
-	}
-
-      /* Reset the record pointer.  */
-      PRIV (vms_rec) = PRIV (vms_buf);
-    }
-  else
-    {
-      unsigned int to_read;
-
-      /* Extract record size.  */
-      PRIV (rec_size) = bfd_getl16 (PRIV (vms_rec) + 2);
-
-      if (PRIV (rec_size) <= 0)
-	{
-	  bfd_set_error (bfd_error_file_truncated);
-	  return 0;
-	}
-
-      /* That's what the linker manual says.  */
-      if (PRIV (rec_size) > EOBJ_S_C_MAXRECSIZ)
-	{
-	  bfd_set_error (bfd_error_file_truncated);
-	  return 0;
-	}
-
-      /* Take into account object adjustment.  */
-      to_read = PRIV (rec_size);
-      if (PRIV (file_format) == FF_FOREIGN)
-	to_read += VMS_OBJECT_ADJUSTMENT;
-
-      /* Adjust the buffer.  */
-      if (to_read > PRIV (buf_size))
-	{
-	  PRIV (vms_buf)
-	    = (unsigned char *) bfd_realloc (PRIV (vms_buf), to_read);
-	  if (PRIV (vms_buf) == NULL)
-	    return 0;
-	  PRIV (buf_size) = to_read;
-	}
-
-      /* Read the remaining record.  */
-      to_read -= read_so_far;
-
-#if VMS_DEBUG
-      vms_debug (8, "vms_get_remaining_obj_record: to_read %d\n", to_read);
-#endif
-
-      if (bfd_bread (PRIV (vms_buf) + read_so_far, to_read, abfd) != to_read)
-	{
-	  bfd_set_error (bfd_error_file_truncated);
-	  return 0;
-	}
-
-      /* Reset the record pointer.  */
-      PRIV (vms_rec) = PRIV (vms_buf);
-      maybe_adjust_record_pointer_for_object (abfd);
-    }
-
-#if VMS_DEBUG
-  vms_debug (8, "vms_get_remaining_obj_record: size %d\n", PRIV (rec_size));
-#endif
-
-  return PRIV (rec_size);
-}
-
-/* Implement step #2 of the record reading procedure for images.
-   Return the size of the record or 0 on failure.  */
-
-static int
-vms_get_remaining_image_record (bfd *abfd, int read_so_far)
-{
-  unsigned int to_read;
-  int remaining;
-
-  /* Extract record size.  */
-  PRIV (rec_size) = bfd_getl32 (PRIV (vms_rec) + EIHD_S_L_SIZE);
-
-  if (PRIV (rec_size) > PRIV (buf_size))
-    {
-      PRIV (vms_buf) = bfd_realloc (PRIV (vms_buf), PRIV (rec_size));
-
-      if (PRIV (vms_buf) == NULL)
-	{
-	  bfd_set_error (bfd_error_no_memory);
-	  return 0;
-	}
-
-      PRIV (buf_size) = PRIV (rec_size);
-    }
-
-  /* Read the remaining record.  */
-  remaining = PRIV (rec_size) - read_so_far;
-  to_read = MIN (VMS_BLOCK_SIZE - read_so_far, remaining);
-
-  while (remaining > 0)
-    {
-      if (bfd_bread (PRIV (vms_buf) + read_so_far, to_read, abfd) != to_read)
-	{
-	  bfd_set_error (bfd_error_file_truncated);
-	  return 0;
-	}
-
-      read_so_far += to_read;
-      remaining -= to_read;
-
-      /* Eat trailing 0xff's.  */
-      if (remaining > 0)
-	while (PRIV (vms_buf) [read_so_far - 1] == 0xff)
-	  read_so_far--;
-
-      to_read = MIN (VMS_BLOCK_SIZE, remaining);
-    }
-
-  /* Reset the record pointer.  */
-  PRIV (vms_rec) = PRIV (vms_buf);
-
-  return PRIV (rec_size);
-}
 
 /* Copy sized string (string with fixed size) to new allocated area
    size is string size (size of record)  */
@@ -555,7 +144,7 @@ _bfd_vms_save_sized_string (unsigned char *str, int size)
 
   if (newstr == NULL)
     return NULL;
-  strncpy (newstr, (char *) str, (size_t) size);
+  memcpy (newstr, (char *) str, (size_t) size);
   newstr[size] = 0;
 
   return newstr;
@@ -572,280 +161,196 @@ _bfd_vms_save_counted_string (unsigned char *ptr)
   return _bfd_vms_save_sized_string (ptr, len);
 }
 
-/* Stack routines for vms ETIR commands.  */
+/* Object output routines.   */
 
-/* Push value and section index.  */
+/* Begin new record.
+   Write 2 bytes rectype and 2 bytes record length.  */
 
 void
-_bfd_vms_push (bfd * abfd, uquad val, int psect)
+_bfd_vms_output_begin (struct vms_rec_wr *recwr, int rectype)
 {
-  static int last_psect;
+  vms_debug2 ((6, "_bfd_vms_output_begin (type %d)\n", rectype));
 
-#if VMS_DEBUG
-  vms_debug (4, "<push %016lx (%d) at %d>\n", val, psect, PRIV (stackptr));
-#endif
-
-  if (psect >= 0)
-    last_psect = psect;
+  /* Record must have been closed.  */
+  BFD_ASSERT (recwr->size == 0);
 
-  PRIV (stack[PRIV (stackptr)]).value = val;
-  PRIV (stack[PRIV (stackptr)]).psect = last_psect;
-  PRIV (stackptr)++;
-  if (PRIV (stackptr) >= STACKSIZE)
-    {
-      bfd_set_error (bfd_error_bad_value);
-      (*_bfd_error_handler) (_("Stack overflow (%d) in _bfd_vms_push"), PRIV (stackptr));
-      exit (1);
-    }
-}
+  _bfd_vms_output_short (recwr, (unsigned int) rectype);
 
-/* Pop value and section index.  */
-
-uquad
-_bfd_vms_pop (bfd * abfd, int *psect)
-{
-  uquad value;
-
-  if (PRIV (stackptr) == 0)
-    {
-      bfd_set_error (bfd_error_bad_value);
-      (*_bfd_error_handler) (_("Stack underflow in _bfd_vms_pop"));
-      exit (1);
-    }
-  PRIV (stackptr)--;
-  value = PRIV (stack[PRIV (stackptr)]).value;
-  if ((psect != NULL) && (PRIV (stack[PRIV (stackptr)]).psect >= 0))
-    *psect = PRIV (stack[PRIV (stackptr)]).psect;
-
-#if VMS_DEBUG
-  vms_debug (4, "<pop %016lx(%d)>\n", value, PRIV (stack[PRIV (stackptr)]).psect);
-#endif
-
-  return value;
+  /* Placeholder for length.  */
+  _bfd_vms_output_short (recwr, 0);
 }
-
-/* Object output routines.   */
 
-/* Begin new record or record header
-   write 2 bytes rectype
-   write 2 bytes record length (filled in at flush)
-   write 2 bytes header type (ommitted if rechead == -1).  */
+/* Begin new sub-record.
+   Write 2 bytes rectype, and 2 bytes record length.  */
 
 void
-_bfd_vms_output_begin (bfd * abfd, int rectype, int rechead)
+_bfd_vms_output_begin_subrec (struct vms_rec_wr *recwr, int rectype)
 {
-#if VMS_DEBUG
-  vms_debug (6, "_bfd_vms_output_begin (type %d, head %d)\n", rectype,
-	      rechead);
-#endif
+  vms_debug2 ((6, "_bfd_vms_output_begin_subrec (type %d)\n", rectype));
 
-  _bfd_vms_output_short (abfd, (unsigned int) rectype);
+  /* Subrecord must have been closed.  */
+  BFD_ASSERT (recwr->subrec_offset == 0);
 
-  /* Save current output position to fill in length later.   */
+  /* Save start of subrecord offset.  */
+  recwr->subrec_offset = recwr->size;
 
-  if (PRIV (push_level) > 0)
-    PRIV (length_pos) = PRIV (output_size);
-
-#if VMS_DEBUG
-  vms_debug (6, "_bfd_vms_output_begin: length_pos = %d\n",
-	      PRIV (length_pos));
-#endif
+  /* Subrecord type.  */
+  _bfd_vms_output_short (recwr, (unsigned int) rectype);
 
   /* Placeholder for length.  */
-  _bfd_vms_output_short (abfd, 0);
-
-  if (rechead != -1)
-    _bfd_vms_output_short (abfd, (unsigned int) rechead);
+  _bfd_vms_output_short (recwr, 0);
 }
 
 /* Set record/subrecord alignment.   */
 
 void
-_bfd_vms_output_alignment (bfd * abfd, int alignto)
+_bfd_vms_output_alignment (struct vms_rec_wr *recwr, int alignto)
 {
-#if VMS_DEBUG
-  vms_debug (6, "_bfd_vms_output_alignment (%d)\n", alignto);
-#endif
-
-  PRIV (output_alignment) = alignto;
+  vms_debug2 ((6, "_bfd_vms_output_alignment (%d)\n", alignto));
+  recwr->align = alignto;
 }
 
-/* Prepare for subrecord fields.  */
-
-void
-_bfd_vms_output_push (bfd * abfd)
-{
-#if VMS_DEBUG
-  vms_debug (6, "vms_output_push (pushed_size = %d)\n", PRIV (output_size));
-#endif
+/* Align the size of the current record (whose length is LENGTH).
+   Warning: this obviously changes the record (and the possible subrecord)
+   length.  */
 
-  PRIV (push_level)++;
-  PRIV (pushed_size) = PRIV (output_size);
-}
-
-/* End of subrecord fields.   */
-
-void
-_bfd_vms_output_pop (bfd * abfd)
+static void
+_bfd_vms_output_align (struct vms_rec_wr *recwr, unsigned int length)
 {
-#if VMS_DEBUG
-  vms_debug (6, "vms_output_pop (pushed_size = %d)\n", PRIV (pushed_size));
-#endif
-
-  _bfd_vms_output_flush (abfd);
-  PRIV (length_pos) = 2;
+  unsigned int real_size = recwr->size;
+  unsigned int aligncount;
 
-#if VMS_DEBUG
-  vms_debug (6, "vms_output_pop: length_pos = %d\n", PRIV (length_pos));
-#endif
+  /* Pad with 0 if alignment is required.  */
+  aligncount = (recwr->align - (length % recwr->align)) % recwr->align;
+  vms_debug2 ((6, "align: adding %d bytes\n", aligncount));
+  while (aligncount-- > 0)
+    recwr->buf[real_size++] = 0;
 
-  PRIV (pushed_size) = 0;
-  PRIV (push_level)--;
+  recwr->size = real_size;
 }
 
-/* Flush unwritten output, ends current record.  */
+/* Ends current sub-record.  Set length field.  */
 
 void
-_bfd_vms_output_flush (bfd * abfd)
+_bfd_vms_output_end_subrec (struct vms_rec_wr *recwr)
 {
-  int real_size = PRIV (output_size);
-  int aligncount;
+  int real_size = recwr->size;
   int length;
 
-#if VMS_DEBUG
-  vms_debug (6, "_bfd_vms_output_flush (real_size = %d, pushed_size %d at lenpos %d)\n",
-	      real_size, PRIV (pushed_size), PRIV (length_pos));
-#endif
+  /* Subrecord must be open.  */
+  BFD_ASSERT (recwr->subrec_offset != 0);
 
-  if (PRIV (push_level) > 0)
-    length = real_size - PRIV (pushed_size);
-  else
-    length = real_size;
+  length = real_size - recwr->subrec_offset;
 
   if (length == 0)
     return;
-  aligncount = (PRIV (output_alignment)
-		- (length % PRIV (output_alignment))) % PRIV (output_alignment);
-
-#if VMS_DEBUG
-  vms_debug (6, "align: adding %d bytes\n", aligncount);
-#endif
 
-  while (aligncount-- > 0)
-    {
-      PRIV (output_buf)[real_size++] = 0;
-      length++;
-    }
+  _bfd_vms_output_align (recwr, length);
 
   /* Put length to buffer.  */
-  PRIV (output_size) = PRIV (length_pos);
-  _bfd_vms_output_short (abfd, (unsigned int) length);
+  bfd_putl16 ((bfd_vma) (recwr->size - recwr->subrec_offset),
+              recwr->buf + recwr->subrec_offset + 2);
 
-  if (PRIV (push_level) == 0)
-    {
-      /* File is open in undefined (UDF) format on VMS, but ultimately will be
-	 converted to variable length (VAR) format.  VAR format has a length
-	 word first which must be explicitly output in UDF format.  */
-      bfd_bwrite (PRIV (output_buf) + 2, 2, abfd);
-      bfd_bwrite (PRIV (output_buf), (size_t) real_size, abfd);
-      PRIV (output_size) = 0;
-    }
-  else
-    {
-      PRIV (output_size) = real_size;
-      PRIV (pushed_size) = PRIV (output_size);
-    }
+  /* Close the subrecord.  */
+  recwr->subrec_offset = 0;
 }
 
-/* End record output.   */
+/* Ends current record (and write it).  */
 
 void
-_bfd_vms_output_end (bfd * abfd)
+_bfd_vms_output_end (bfd *abfd, struct vms_rec_wr *recwr)
 {
-#if VMS_DEBUG
-  vms_debug (6, "_bfd_vms_output_end\n");
-#endif
+  vms_debug2 ((6, "_bfd_vms_output_end (size %u)\n", recwr->size));
 
-  _bfd_vms_output_flush (abfd);
-}
+  /* Subrecord must have been closed.  */
+  BFD_ASSERT (recwr->subrec_offset == 0);
+
+  if (recwr->size == 0)
+    return;
 
-/* Check remaining buffer size
+  _bfd_vms_output_align (recwr, recwr->size);
 
-   Return what's left.  */
+  /* Write the length word.  */
+  bfd_putl16 ((bfd_vma) recwr->size, recwr->buf + 2);
+
+  /* File is open in undefined (UDF) format on VMS, but ultimately will be
+     converted to variable length (VAR) format.  VAR format has a length
+     word first which must be explicitly output in UDF format.  */
+  /* So, first the length word.  */
+  bfd_bwrite (recwr->buf + 2, 2, abfd);
+
+  /* Align.  */
+  if (recwr->size & 1)
+    recwr->buf[recwr->size++] = 0;
+
+  /* Then the record.  */
+  bfd_bwrite (recwr->buf, (size_t) recwr->size, abfd);
+
+  recwr->size = 0;
+}
+
+/* Check remaining buffer size.  Return what's left.  */
 
 int
-_bfd_vms_output_check (bfd * abfd, int size)
+_bfd_vms_output_check (struct vms_rec_wr *recwr, int size)
 {
-#if VMS_DEBUG
-  vms_debug (6, "_bfd_vms_output_check (%d)\n", size);
-#endif
+  vms_debug2 ((6, "_bfd_vms_output_check (%d)\n", size));
 
-  return (MAX_OUTREC_SIZE - (PRIV (output_size) + size + MIN_OUTREC_LUFT));
+  return (MAX_OUTREC_SIZE - (recwr->size + size + MIN_OUTREC_LUFT));
 }
 
 /* Output byte (8 bit) value.  */
 
 void
-_bfd_vms_output_byte (bfd * abfd, unsigned int value)
+_bfd_vms_output_byte (struct vms_rec_wr *recwr, unsigned int value)
 {
-#if VMS_DEBUG
-  vms_debug (6, "_bfd_vms_output_byte (%02x)\n", value);
-#endif
+  vms_debug2 ((6, "_bfd_vms_output_byte (%02x)\n", value));
 
-  bfd_put_8 (abfd, value & 0xff, PRIV (output_buf) + PRIV (output_size));
-  PRIV (output_size) += 1;
+  *(recwr->buf + recwr->size) = value;
+  recwr->size += 1;
 }
 
 /* Output short (16 bit) value.  */
 
 void
-_bfd_vms_output_short (bfd * abfd, unsigned int value)
+_bfd_vms_output_short (struct vms_rec_wr *recwr, unsigned int value)
 {
-#if VMS_DEBUG
-  vms_debug (6, "_bfd_vms_output_short (%04x)\n", value);
-#endif
+  vms_debug2 ((6, "_bfd_vms_output_short (%04x)\n", value));
 
-  bfd_put_16 (abfd, (bfd_vma) value & 0xffff,
-	      PRIV (output_buf) + PRIV (output_size));
-  PRIV (output_size) += 2;
+  bfd_putl16 ((bfd_vma) value & 0xffff, recwr->buf + recwr->size);
+  recwr->size += 2;
 }
 
 /* Output long (32 bit) value.  */
 
 void
-_bfd_vms_output_long (bfd * abfd, unsigned long value)
+_bfd_vms_output_long (struct vms_rec_wr *recwr, unsigned long value)
 {
-#if VMS_DEBUG
-  vms_debug (6, "_bfd_vms_output_long (%08lx)\n", value);
-#endif
+  vms_debug2 ((6, "_bfd_vms_output_long (%08lx)\n", value));
 
-  bfd_put_32 (abfd, (bfd_vma) value, PRIV (output_buf) + PRIV (output_size));
-  PRIV (output_size) += 4;
+  bfd_putl32 ((bfd_vma) value, recwr->buf + recwr->size);
+  recwr->size += 4;
 }
 
 /* Output quad (64 bit) value.  */
 
 void
-_bfd_vms_output_quad (bfd * abfd, uquad value)
+_bfd_vms_output_quad (struct vms_rec_wr *recwr, bfd_vma value)
 {
-#if VMS_DEBUG
-  vms_debug (6, "_bfd_vms_output_quad (%016lx)\n", value);
-#endif
+  vms_debug2 ((6, "_bfd_vms_output_quad (%08lx)\n", (unsigned long)value));
 
-  bfd_put_64(abfd, value, PRIV (output_buf) + PRIV (output_size));
-  PRIV (output_size) += 8;
+  bfd_putl64 (value, recwr->buf + recwr->size);
+  recwr->size += 8;
 }
 
 /* Output c-string as counted string.  */
 
 void
-_bfd_vms_output_counted (bfd * abfd, char *value)
+_bfd_vms_output_counted (struct vms_rec_wr *recwr, char *value)
 {
   int len;
 
-#if VMS_DEBUG
-  vms_debug (6, "_bfd_vms_output_counted (%s)\n", value);
-#endif
+  vms_debug2 ((6, "_bfd_vms_output_counted (%s)\n", value));
 
   len = strlen (value);
   if (len == 0)
@@ -858,193 +363,117 @@ _bfd_vms_output_counted (bfd * abfd, char *value)
       (*_bfd_error_handler) (_("_bfd_vms_output_counted called with too many bytes"));
       return;
     }
-  _bfd_vms_output_byte (abfd, (unsigned int) len & 0xff);
-  _bfd_vms_output_dump (abfd, (unsigned char *) value, len);
+  _bfd_vms_output_byte (recwr, (unsigned int) len & 0xff);
+  _bfd_vms_output_dump (recwr, (unsigned char *) value, len);
 }
 
 /* Output character area.  */
 
 void
-_bfd_vms_output_dump (bfd * abfd,
-		      unsigned char *data,
-		      int length)
+_bfd_vms_output_dump (struct vms_rec_wr *recwr, unsigned char *data, int len)
 {
-#if VMS_DEBUG
-  vms_debug (6, "_bfd_vms_output_dump (%d)\n", length);
-#endif
+  vms_debug2 ((6, "_bfd_vms_output_dump (%d)\n", len));
 
-  if (length == 0)
+  if (len == 0)
     return;
 
-  memcpy (PRIV (output_buf) + PRIV (output_size), data, (size_t) length);
-  PRIV (output_size) += length;
+  memcpy (recwr->buf + recwr->size, data, (size_t) len);
+  recwr->size += len;
 }
 
 /* Output count bytes of value.  */
 
 void
-_bfd_vms_output_fill (bfd * abfd,
-		      int value,
-		      int count)
+_bfd_vms_output_fill (struct vms_rec_wr *recwr, int value, int count)
 {
-#if VMS_DEBUG
-  vms_debug (6, "_bfd_vms_output_fill (val %02x times %d)\n", value, count);
-#endif
+  vms_debug2 ((6, "_bfd_vms_output_fill (val %02x times %d)\n", value, count));
 
   if (count == 0)
     return;
-  memset (PRIV (output_buf) + PRIV (output_size), value, (size_t) count);
-  PRIV (output_size) += count;
-}
-
-/* This hash routine borrowed from GNU-EMACS, and strengthened slightly.  ERY.  */
-
-static int
-hash_string (const char *ptr)
-{
-  const unsigned char *p = (unsigned char *) ptr;
-  const unsigned char *end = p + strlen (ptr);
-  unsigned char c;
-  int hash = 0;
-
-  while (p != end)
-    {
-      c = *p++;
-      hash = ((hash << 3) + (hash << 15) + (hash >> 28) + c);
-    }
-  return hash;
+  memset (recwr->buf + recwr->size, value, (size_t) count);
+  recwr->size += count;
 }
 
-/* Generate a length-hashed VMS symbol name (limited to maxlen chars).  */
+#ifdef VMS
+/* Convert the file to variable record length format. This is done
+   using undocumented system call sys$modify().
+   Pure VMS version.  */
 
-char *
-_bfd_vms_length_hash_symbol (bfd * abfd, const char *in, int maxlen)
+static void
+vms_convert_to_var (char *vms_filename)
 {
-  unsigned long result;
-  int in_len;
-  char *new_name;
-  const char *old_name;
-  int i;
-  static char outbuf[EOBJ_S_C_SYMSIZ+1];
-  char *out = outbuf;
-
-#if VMS_DEBUG
-  vms_debug (4, "_bfd_vms_length_hash_symbol \"%s\"\n", in);
-#endif
-
-  if (maxlen > EOBJ_S_C_SYMSIZ)
-    maxlen = EOBJ_S_C_SYMSIZ;
-
-  /* Save this for later.  */
-  new_name = out;
-
-  /* We may need to truncate the symbol, save the hash for later.  */
-  in_len = strlen (in);
+  struct FAB fab = cc$rms_fab;
 
-  result = (in_len > maxlen) ? hash_string (in) : 0;
+  fab.fab$l_fna = vms_filename;
+  fab.fab$b_fns = strlen (vms_filename);
+  fab.fab$b_fac = FAB$M_PUT;
+  fab.fab$l_fop = FAB$M_ESC;
+  fab.fab$l_ctx = RME$C_SETRFM;
 
-  old_name = in;
+  sys$open (&fab);
 
-  /* Do the length checking.  */
-  if (in_len <= maxlen)
-    i = in_len;
-  else
-    {
-      if (PRIV (flag_hash_long_names))
-	i = maxlen-9;
-      else
-	i = maxlen;
-    }
-
-  strncpy (out, in, (size_t) i);
-  in += i;
-  out += i;
-
-  if ((in_len > maxlen)
-      && PRIV (flag_hash_long_names))
-    sprintf (out, "_%08lx", result);
-  else
-    *out = 0;
-
-#if VMS_DEBUG
-  vms_debug (4, "--> [%d]\"%s\"\n", strlen (outbuf), outbuf);
-#endif
-
-  if (in_len > maxlen
-	&& PRIV (flag_hash_long_names)
-	&& PRIV (flag_show_after_trunc))
-    printf (_("Symbol %s replaced by %s\n"), old_name, new_name);
+  fab.fab$b_rfm = FAB$C_VAR;
 
-  return outbuf;
+  sys$modify (&fab);
+  sys$close (&fab);
 }
 
-/* Allocate and initialize a new symbol.  */
-
-static asymbol *
-new_symbol (bfd * abfd, char *name)
+static int
+vms_convert_to_var_1 (char *filename, int type)
 {
-  asymbol *symbol;
-
-#if VMS_DEBUG
-  _bfd_vms_debug (7,  "new_symbol %s\n", name);
-#endif
-
-  symbol = bfd_make_empty_symbol (abfd);
-  if (symbol == 0)
-    return symbol;
-  symbol->name = name;
-  symbol->section = (asection *)(unsigned long)-1;
-
-  return symbol;
+  if (type != DECC$K_FILE)
+    return FALSE;
+  vms_convert_to_var (filename);
+  return TRUE;
 }
 
-/* Allocate and enter a new private symbol.  */
+/* Convert the file to variable record length format. This is done
+   using undocumented system call sys$modify().
+   Unix filename version.  */
 
-vms_symbol_entry *
-_bfd_vms_enter_symbol (bfd * abfd, char *name)
-{
-  vms_symbol_entry *entry;
-
-#if VMS_DEBUG
-  _bfd_vms_debug (6,  "_bfd_vms_enter_symbol %s\n", name);
-#endif
-
-  entry = (vms_symbol_entry *)
-	  bfd_hash_lookup (PRIV (vms_symbol_table), name, FALSE, FALSE);
-  if (entry == 0)
-    {
-#if VMS_DEBUG
-      _bfd_vms_debug (8,  "creating hash entry for %s\n", name);
-#endif
-      entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV (vms_symbol_table),
-						    name, TRUE, FALSE);
-      if (entry != 0)
-	{
-	  asymbol *symbol;
-	  symbol = new_symbol (abfd, name);
-	  if (symbol != 0)
-	    {
-	      entry->symbol = symbol;
-	      PRIV (gsd_sym_count)++;
-	      abfd->symcount++;
-	    }
-	  else
-	    entry = 0;
-	}
-      else
-	(*_bfd_error_handler) (_("failed to enter %s"), name);
-    }
-  else
-    {
-#if VMS_DEBUG
-      _bfd_vms_debug (8,  "found hash entry for %s\n", name);
-#endif
-    }
-
-#if VMS_DEBUG
-  _bfd_vms_debug (7, "-> entry %p, entry->symbol %p\n", entry, entry->symbol);
-#endif
-  return entry;
+static int
+vms_convert_to_var_unix_filename (const char *unix_filename)
+{
+  if (decc$to_vms (unix_filename, &vms_convert_to_var_1, 0, 1) != 1)
+    return FALSE;
+  return TRUE;
+}
+#endif /* VMS */
+
+/* Manufacture a VMS like time on a unix based system.
+   stolen from obj-vms.c.  */
+
+unsigned char *
+get_vms_time_string (void)
+{
+  static unsigned char tbuf[18];
+#ifndef VMS
+  char *pnt;
+  time_t timeb;
+
+  time (& timeb);
+  pnt = ctime (&timeb);
+  pnt[3] = 0;
+  pnt[7] = 0;
+  pnt[10] = 0;
+  pnt[16] = 0;
+  pnt[24] = 0;
+  sprintf ((char *) tbuf, "%2s-%3s-%s %s",
+	   pnt + 8, pnt + 4, pnt + 20, pnt + 11);
+#else
+  struct
+  {
+    int Size;
+    unsigned char *Ptr;
+  } Descriptor;
+  Descriptor.Size = 17;
+  Descriptor.Ptr = tbuf;
+  SYS$ASCTIM (0, &Descriptor, 0, 0);
+#endif /* not VMS */
+
+  vms_debug2 ((6, "vmstimestring:'%s'\n", tbuf));
+
+  return tbuf;
 }
 
 /* Create module name from filename (ie, extract the basename and convert it
diff --git a/bfd/vms-tir.c b/bfd/vms-tir.c
deleted file mode 100644
index 1ecb151..0000000
--- a/bfd/vms-tir.c
+++ /dev/null
@@ -1,2808 +0,0 @@
-/* vms-tir.c -- BFD back-end for VAX (openVMS/VAX) and
-   EVAX (openVMS/Alpha) files.
-   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2004, 2005, 2007,
-   2008, 2009 Free Software Foundation, Inc.
-
-   TIR record handling functions
-   ETIR record handling functions
-
-   Go and read the openVMS linker manual (esp. appendix B)
-   if you don't know what's going on here :-)
-
-   Written by Klaus K"ampf (kkaempf@rmi.de)
-
-   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.  */
-
-/* The following type abbreviations are used:
-
-	cs	counted string (ascii string with length byte)
-	by	byte (1 byte)
-	sh	short (2 byte, 16 bit)
-	lw	longword (4 byte, 32 bit)
-	qw	quadword (8 byte, 64 bit)
-	da	data stream  */
-
-#include "sysdep.h"
-#include "bfd.h"
-#include "bfdlink.h"
-#include "libbfd.h"
-#include "vms.h"
-
-static int check_section (bfd *, int);
-static void image_set_ptr (bfd *abfd, int psect, uquad offset);
-static void image_inc_ptr (bfd *abfd, uquad offset);
-static void dst_define_location (bfd *abfd, uquad loc);
-static void dst_restore_location (bfd *abfd, uquad loc);
-static unsigned int dst_retrieve_location (bfd *abfd, uquad loc);
-static void dst_check_allocation (bfd *abfd, unsigned int size);
-static void image_dump (bfd *abfd, unsigned char *ptr, int size, int offset);
-static void image_write_b (bfd *abfd, unsigned int value);
-static void image_write_w (bfd *abfd, unsigned int value);
-static void image_write_l (bfd *abfd, unsigned long value);
-static void image_write_q (bfd *abfd, uquad value);
-static bfd_boolean etir_sta (bfd *, int, unsigned char *, int *);
-static bfd_boolean etir_sto (bfd *, int, unsigned char *, int *);
-static bfd_boolean etir_opr (bfd *, int, unsigned char *, int *);
-static bfd_boolean etir_ctl (bfd *, int, unsigned char *, int *);
-static bfd_boolean etir_stc (bfd *, int, unsigned char *, int *);
-static asection *new_section (bfd *, int);
-static int alloc_section (bfd *, unsigned int);
-static int etir_cmd (bfd *, int, unsigned char *, int *);
-static int analyze_tir (bfd *, unsigned char *, unsigned int);
-static int analyze_etir (bfd *, unsigned char *, unsigned int);
-static unsigned char *tir_opr (bfd *, unsigned char *);
-static const char *tir_cmd_name (int);
-static const char *cmd_name (int);
-
-
-static int
-check_section (bfd * abfd, int size)
-{
-  bfd_size_type offset;
-
-  offset = PRIV (image_ptr) - PRIV (image_section)->contents;
-  if (offset + size > PRIV (image_section)->size)
-    {
-      PRIV (image_section)->contents
-	= bfd_realloc_or_free (PRIV (image_section)->contents, offset + size);
-      if (PRIV (image_section)->contents == NULL)
-	{
-	  (*_bfd_error_handler) (_("No Mem !"));
-	  return -1;
-	}
-      PRIV (image_section)->size = offset + size;
-      PRIV (image_ptr) = PRIV (image_section)->contents + offset;
-    }
-
-  return 0;
-}
-
-/* Routines to fill sections contents during tir/etir read.  */
-
-/* Initialize image buffer pointer to be filled.  */
-
-static void
-image_set_ptr (bfd * abfd, int psect, uquad offset)
-{
-#if VMS_DEBUG
-  _bfd_vms_debug (4, "image_set_ptr (%d=%s, %d)\n",
-		  psect, PRIV (sections)[psect]->name, offset);
-#endif
-
-  PRIV (image_ptr) = PRIV (sections)[psect]->contents + offset;
-  PRIV (image_section) = PRIV (sections)[psect];
-}
-
-/* Increment image buffer pointer by offset.  */
-
-static void
-image_inc_ptr (bfd * abfd, uquad offset)
-{
-#if VMS_DEBUG
-  _bfd_vms_debug (4, "image_inc_ptr (%d)\n", offset);
-#endif
-
-  PRIV (image_ptr) += offset;
-}
-
-/* Save current DST location counter under specified index.  */
-
-static void
-dst_define_location (bfd *abfd, uquad loc)
-{
-  asection *dst_section = PRIV (dst_section);
-
-#if VMS_DEBUG
-  _bfd_vms_debug (4, "dst_define_location (%d)\n", (int)loc);
-#endif
-
-  /* Grow the ptr offset table if necessary.  */
-  if (loc + 1 > PRIV (dst_ptr_offsets_count))
-    {
-      PRIV (dst_ptr_offsets) = bfd_realloc (PRIV (dst_ptr_offsets),
-					   (loc + 1) * sizeof (unsigned int));
-      PRIV (dst_ptr_offsets_count) = loc + 1;
-    }
-
-  PRIV (dst_ptr_offsets)[loc] = PRIV (image_ptr) - dst_section->contents;
-}
-
-/* Restore saved DST location counter from specified index.  */
-
-static void
-dst_restore_location (bfd *abfd, uquad loc)
-{
-  asection *dst_section = PRIV (dst_section);
-
-#if VMS_DEBUG
-  _bfd_vms_debug (4, "dst_restore_location (%d)\n", (int)loc);
-#endif
-
-  PRIV (image_ptr) = dst_section->contents + PRIV (dst_ptr_offsets)[loc];
-}
-
-/* Retrieve saved DST location counter from specified index.  */
-
-static unsigned int
-dst_retrieve_location (bfd *abfd, uquad loc)
-{
-#if VMS_DEBUG
-  _bfd_vms_debug (4, "dst_retrieve_location (%d)\n", (int)loc);
-#endif
-
-  return PRIV (dst_ptr_offsets)[loc];
-}
-
-/* Check that the DST section is big enough for the specified
-   amount of bytes.  */
-
-static void
-dst_check_allocation (bfd *abfd, unsigned int size)
-{
-  asection *dst_section = PRIV (dst_section);
-
-  bfd_size_type used = PRIV (image_ptr) - dst_section->contents;
-  bfd_size_type left = dst_section->size - used;
-
-  /* Grow the DST section as necessary */
-  if (size > left)
-    {
-      dst_section->size *= 2;
-      dst_section->contents
-	= bfd_realloc (dst_section->contents, dst_section->size);
-      PRIV (image_ptr) = dst_section->contents + used;
-
-      dst_check_allocation (abfd, size);
-    }
-}
-
-/* Dump multiple bytes to section image.  */
-
-static void
-image_dump (bfd * abfd,
-	    unsigned char *ptr,
-	    int size,
-	    int offset ATTRIBUTE_UNUSED)
-{
-#if VMS_DEBUG
-  _bfd_vms_debug (8, "image_dump from (%p, %d) to (%p)\n", ptr, size,
-		  PRIV (image_ptr));
-  _bfd_hexdump (9, ptr, size, offset);
-#endif
-
-  if (PRIV (is_vax) && check_section (abfd, size))
-    return;
-
-  if (PRIV (dst_section))
-    dst_check_allocation (abfd, size);
-
-  while (size-- > 0)
-    *PRIV (image_ptr)++ = *ptr++;
-}
-
-/* Write byte to section image.  */
-
-static void
-image_write_b (bfd * abfd, unsigned int value)
-{
-#if VMS_DEBUG
-  _bfd_vms_debug (6, "image_write_b (%02x)\n", (int) value);
-#endif
-
-  if (PRIV (is_vax) && check_section (abfd, 1))
-    return;
-
-  if (PRIV (dst_section))
-    dst_check_allocation (abfd, 1);
-
-  *PRIV (image_ptr)++ = (value & 0xff);
-}
-
-/* Write 2-byte word to image.  */
-
-static void
-image_write_w (bfd * abfd, unsigned int value)
-{
-#if VMS_DEBUG
-  _bfd_vms_debug (6, "image_write_w (%04x)\n", (int) value);
-#endif
-
-  if (PRIV (is_vax) && check_section (abfd, 2))
-    return;
-
-  if (PRIV (dst_section))
-    dst_check_allocation (abfd, 2);
-
-  bfd_putl16 ((bfd_vma) value, PRIV (image_ptr));
-  PRIV (image_ptr) += 2;
-}
-
-/* Write 4-byte long to image.  */
-
-static void
-image_write_l (bfd * abfd, unsigned long value)
-{
-#if VMS_DEBUG
-  _bfd_vms_debug (6, "image_write_l (%08lx)\n", value);
-#endif
-
-  if (PRIV (is_vax) && check_section (abfd, 4))
-    return;
-
-  if (PRIV (dst_section))
-    dst_check_allocation (abfd, 4);
-
-  bfd_putl32 ((bfd_vma) value, PRIV (image_ptr));
-  PRIV (image_ptr) += 4;
-}
-
-/* Write 8-byte quad to image.  */
-
-static void
-image_write_q (bfd * abfd, uquad value)
-{
-#if VMS_DEBUG
-  _bfd_vms_debug (6, "image_write_q (%016lx)\n", value);
-#endif
-
-  if (PRIV (is_vax) && check_section (abfd, 8))
-    return;
-
-  if (PRIV (dst_section))
-    dst_check_allocation (abfd, 8);
-
-  bfd_putl64 (value, PRIV (image_ptr));
-  PRIV (image_ptr) += 8;
-}
-
-static const char *
-cmd_name (int cmd)
-{
-  switch (cmd)
-    {
-    case ETIR_S_C_STA_GBL: return "ETIR_S_C_STA_GBL";
-    case ETIR_S_C_STA_LW: return "ETIR_S_C_STA_LW";
-    case ETIR_S_C_STA_QW: return "ETIR_S_C_STA_QW";
-    case ETIR_S_C_STA_PQ: return "ETIR_S_C_STA_PQ";
-    case ETIR_S_C_STA_LI: return "ETIR_S_C_STA_LI";
-    case ETIR_S_C_STA_MOD: return "ETIR_S_C_STA_MOD";
-    case ETIR_S_C_STA_CKARG: return "ETIR_S_C_STA_CKARG";
-    case ETIR_S_C_STO_B: return "ETIR_S_C_STO_B";
-    case ETIR_S_C_STO_W: return "ETIR_S_C_STO_W";
-    case ETIR_S_C_STO_GBL: return "ETIR_S_C_STO_GBL";
-    case ETIR_S_C_STO_CA: return "ETIR_S_C_STO_CA";
-    case ETIR_S_C_STO_RB: return "ETIR_S_C_STO_RB";
-    case ETIR_S_C_STO_AB: return "ETIR_S_C_STO_AB";
-    case ETIR_S_C_STO_OFF: return "ETIR_S_C_STO_OFF";
-    case ETIR_S_C_STO_IMM: return "ETIR_S_C_STO_IMM";
-    case ETIR_S_C_STO_IMMR: return "ETIR_S_C_STO_IMMR";
-    case ETIR_S_C_STO_LW: return "ETIR_S_C_STO_LW";
-    case ETIR_S_C_STO_QW: return "ETIR_S_C_STO_QW";
-    case ETIR_S_C_STO_GBL_LW: return "ETIR_S_C_STO_GBL_LW";
-    case ETIR_S_C_STO_LP_PSB: return "ETIR_S_C_STO_LP_PSB";
-    case ETIR_S_C_STO_HINT_GBL: return "ETIR_S_C_STO_HINT_GBL";
-    case ETIR_S_C_STO_HINT_PS: return "ETIR_S_C_STO_HINT_PS";
-    case ETIR_S_C_OPR_ADD: return "ETIR_S_C_OPR_ADD";
-    case ETIR_S_C_OPR_INSV: return "ETIR_S_C_OPR_INSV";
-    case ETIR_S_C_OPR_USH: return "ETIR_S_C_OPR_USH";
-    case ETIR_S_C_OPR_ROT: return "ETIR_S_C_OPR_ROT";
-    case ETIR_S_C_OPR_REDEF: return "ETIR_S_C_OPR_REDEF";
-    case ETIR_S_C_OPR_DFLIT: return "ETIR_S_C_OPR_DFLIT";
-    case ETIR_S_C_STC_LP: return "ETIR_S_C_STC_LP";
-    case ETIR_S_C_STC_GBL: return "ETIR_S_C_STC_GBL";
-    case ETIR_S_C_STC_GCA: return "ETIR_S_C_STC_GCA";
-    case ETIR_S_C_STC_PS: return "ETIR_S_C_STC_PS";
-    case ETIR_S_C_STC_NBH_PS: return "ETIR_S_C_STC_NBH_PS";
-    case ETIR_S_C_STC_NOP_GBL: return "ETIR_S_C_STC_NOP_GBL";
-    case ETIR_S_C_STC_NOP_PS: return "ETIR_S_C_STC_NOP_PS";
-    case ETIR_S_C_STC_BSR_GBL: return "ETIR_S_C_STC_BSR_GBL";
-    case ETIR_S_C_STC_BSR_PS: return "ETIR_S_C_STC_BSR_PS";
-    case ETIR_S_C_STC_LDA_GBL: return "ETIR_S_C_STC_LDA_GBL";
-    case ETIR_S_C_STC_LDA_PS: return "ETIR_S_C_STC_LDA_PS";
-    case ETIR_S_C_STC_BOH_GBL: return "ETIR_S_C_STC_BOH_GBL";
-    case ETIR_S_C_STC_BOH_PS: return "ETIR_S_C_STC_BOH_PS";
-    case ETIR_S_C_STC_NBH_GBL: return "ETIR_S_C_STC_NBH_GBL";
-    case ETIR_S_C_CTL_SETRB: return "ETIR_S_C_CTL_SETRB";
-    case ETIR_S_C_STC_LP_PSB: return "ETIR_S_C_STC_LP_PSB";
-    case ETIR_S_C_CTL_DFLOC: return "ETIR_S_C_CTL_DFLOC";
-    case ETIR_S_C_CTL_STLOC: return "ETIR_S_C_CTL_STLOC";
-    case ETIR_S_C_CTL_STKDL: return "ETIR_S_C_CTL_STKDL";
-
-    default:
-      /* These names have not yet been added to this switch statement.  */
-      (*_bfd_error_handler) (_("unknown ETIR command %d"), cmd);
-    }
-
-  return NULL;
-}
-#define HIGHBIT(op) ((op & 0x80000000L) == 0x80000000L)
-
-/* etir_sta
-
-   Vms stack commands.
-
-   Handle sta_xxx commands in etir section,
-   ptr points to data area in record.
-
-   See table B-8 of the openVMS linker manual.  */
-
-static bfd_boolean
-etir_sta (bfd *abfd, int cmd, unsigned char *ptr, int *quarter_relocs)
-{
-#if VMS_DEBUG
-  _bfd_vms_debug (5, "etir_sta %d/%x\n", cmd, cmd);
-  _bfd_hexdump (8, ptr, 16, (long) ptr);
-#endif
-
-  switch (cmd)
-    {
-      /* Stack global
-	 arg: cs	symbol name
-
-	 stack 32 bit value of symbol (high bits set to 0).  */
-    case ETIR_S_C_STA_GBL:
-      {
-	char *name;
-	vms_symbol_entry *entry;
-
-	name = _bfd_vms_save_counted_string (ptr);
-	entry = (vms_symbol_entry *)
-	  bfd_hash_lookup (PRIV (vms_symbol_table), name, FALSE, FALSE);
-	if (entry == NULL)
-	  {
-#if VMS_DEBUG
-	    _bfd_vms_debug (3, "%s: no symbol \"%s\"\n",
-			    cmd_name (cmd), name);
-#endif
-	    _bfd_vms_push (abfd, (uquad) 0, -1);
-	  }
-	else
-	  _bfd_vms_push (abfd, (uquad) (entry->symbol->value), -1);
-      }
-      *quarter_relocs = 1;
-      break;
-
-      /* Stack longword
-	 arg: lw	value
-
-	 stack 32 bit value, sign extend to 64 bit.  */
-    case ETIR_S_C_STA_LW:
-      _bfd_vms_push (abfd, (uquad) bfd_getl32 (ptr), -1);
-      /* This one is special as it is both part of the section header
-         and of the ALPHA_R_REFLONG relocation.  */
-      if (bfd_getl16 (ptr - 4 + bfd_getl16 (ptr - 2)) == ETIR_S_C_CTL_DFLOC)
-	*quarter_relocs = 0;
-      else if (*quarter_relocs)
-	*quarter_relocs += 1;
-      else
-	*quarter_relocs = 2;
-      break;
-
-      /* Stack quadword
-	 arg: qw	value
-
-	 stack 64 bit value of symbol.  */
-    case ETIR_S_C_STA_QW:
-      _bfd_vms_push (abfd, (uquad) bfd_getl64 (ptr), -1);
-      if (*quarter_relocs)
-	*quarter_relocs += 1;
-      else
-	*quarter_relocs = 2;
-      break;
-
-      /* Stack psect base plus quadword offset
-	 arg: lw	section index
-	 qw	signed quadword offset (low 32 bits)
-
-	 Stack qw argument and section index
-	 (see ETIR_S_C_STO_OFF, ETIR_S_C_CTL_SETRB).  */
-    case ETIR_S_C_STA_PQ:
-      {
-	uquad dummy;
-	int psect;
-
-	psect = bfd_getl32 (ptr);
-	if ((unsigned int) psect >= PRIV (section_count))
-	  {
-	    (*_bfd_error_handler) (_("bad section index in %s"),
-				   cmd_name (cmd));
-	    bfd_set_error (bfd_error_bad_value);
-	    return FALSE;
-	  }
-	dummy = bfd_getl64 (ptr + 4);
-	_bfd_vms_push (abfd, dummy, (int) psect);
-      }
-      /* This one is special as it is both part of the section header
-         and of the ALPHA_R_REFLONG and ALPHA_R_REFQUAD relocations.  */
-      if (bfd_getl16 (ptr - 4 + bfd_getl16 (ptr - 2)) == ETIR_S_C_CTL_SETRB)
-	*quarter_relocs = 0;
-      else
-	*quarter_relocs = 2;
-      break;
-
-    case ETIR_S_C_STA_LI:
-    case ETIR_S_C_STA_MOD:
-    case ETIR_S_C_STA_CKARG:
-      (*_bfd_error_handler) (_("unsupported STA cmd %s"), cmd_name (cmd));
-      *quarter_relocs = 0;
-      return FALSE;
-
-    default:
-      (*_bfd_error_handler) (_("reserved STA cmd %d"), cmd);
-      *quarter_relocs = 0;
-      return FALSE;
-    }
-
-#if VMS_DEBUG
-  _bfd_vms_debug (5, "etir_sta true\n");
-#endif
-
-  return TRUE;
-}
-
-/* etir_sto
-
-   vms store commands
-
-   handle sto_xxx commands in etir section
-   ptr points to data area in record
-
-   see table B-9 of the openVMS linker manual.  */
-
-static bfd_boolean
-etir_sto (bfd *abfd, int cmd, unsigned char *ptr, int *quarter_relocs)
-{
-  uquad dummy;
-  int psect;
-
-#if VMS_DEBUG
-  _bfd_vms_debug (5, "etir_sto %d/%x\n", cmd, cmd);
-  _bfd_hexdump (8, ptr, 16, (long) ptr);
-#endif
-
-  switch (cmd)
-    {
-      /* Store byte: pop stack, write byte
-	 arg: -.  */
-    case ETIR_S_C_STO_B:
-      dummy = _bfd_vms_pop (abfd, &psect);
-      /* FIXME: check top bits.  */
-      image_write_b (abfd, (unsigned int) dummy & 0xff);
-      *quarter_relocs = 0;
-      break;
-
-      /* Store word: pop stack, write word
-	 arg: -.  */
-    case ETIR_S_C_STO_W:
-      dummy = _bfd_vms_pop (abfd, &psect);
-      /* FIXME: check top bits */
-      image_write_w (abfd, (unsigned int) dummy & 0xffff);
-      *quarter_relocs = 0;
-      break;
-
-      /* Store longword: pop stack, write longword
-	 arg: -.  */
-    case ETIR_S_C_STO_LW:
-      dummy = _bfd_vms_pop (abfd, &psect);
-      dummy += (PRIV (sections)[psect])->vma;
-      /* FIXME: check top bits.  */
-      image_write_l (abfd, (unsigned int) dummy & 0xffffffff);
-      if (*quarter_relocs == 2)
-	*quarter_relocs = 4;
-      else
-	*quarter_relocs += 1;
-      break;
-
-      /* Store quadword: pop stack, write quadword
-	 arg: -.  */
-    case ETIR_S_C_STO_QW:
-      dummy = _bfd_vms_pop (abfd, &psect);
-      dummy += (PRIV (sections)[psect])->vma;
-      /* FIXME: check top bits.  */
-      image_write_q (abfd, dummy);
-      if (*quarter_relocs == 2)
-	*quarter_relocs = 4;
-      else
-	*quarter_relocs += 1;
-      break;
-
-      /* Store immediate repeated: pop stack for repeat count
-	 arg: lw	byte count
-	 da	data.  */
-    case ETIR_S_C_STO_IMMR:
-      {
-	int size;
-
-	size = bfd_getl32 (ptr);
-	dummy = (unsigned long) _bfd_vms_pop (abfd, NULL);
-	while (dummy-- > 0)
-	  image_dump (abfd, ptr+4, size, 0);
-      }
-      *quarter_relocs = 0;
-      break;
-
-      /* Store global: write symbol value
-	 arg: cs	global symbol name.  */
-    case ETIR_S_C_STO_GBL:
-      {
-	vms_symbol_entry *entry;
-	char *name;
-
-	name = _bfd_vms_save_counted_string (ptr);
-	entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV (vms_symbol_table),
-						      name, FALSE, FALSE);
-	if (entry == NULL)
-	  /* FIXME, reloc.  */
-	  image_write_q (abfd, (uquad) (0));
-	else
-	  /* FIXME, reloc.  */
-	  image_write_q (abfd, (uquad) (entry->symbol->value));
-      }
-      *quarter_relocs = 4;
-      break;
-
-      /* Store code address: write address of entry point
-	 arg: cs	global symbol name (procedure).  */
-    case ETIR_S_C_STO_CA:
-      {
-	vms_symbol_entry *entry;
-	char *name;
-
-	name = _bfd_vms_save_counted_string (ptr);
-	entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV (vms_symbol_table),
-						      name, FALSE, FALSE);
-	if (entry == NULL)
-	  /* FIXME, reloc.  */
-	  image_write_q (abfd, (uquad) (0));
-	else
-	  /* FIXME, reloc.  */
-	  image_write_q (abfd, (uquad) (entry->symbol->value));
-      }
-      *quarter_relocs = 4;
-      break;
-
-      /* Store offset to psect: pop stack, add low 32 bits to base of psect
-	 arg: none.  */
-    case ETIR_S_C_STO_OFF:
-      {
-	uquad q;
-	int psect1;
-
-	q = _bfd_vms_pop (abfd, & psect1);
-	q += (PRIV (sections)[psect1])->vma;
-	image_write_q (abfd, q);
-      }
-      *quarter_relocs += 2;
-      break;
-
-      /* Store immediate
-	 arg: lw	count of bytes
-	      da	data.  */
-    case ETIR_S_C_STO_IMM:
-      {
-	int size;
-
-	size = bfd_getl32 (ptr);
-	image_dump (abfd, ptr+4, size, 0);
-      }
-      *quarter_relocs = 0;
-      break;
-
-      /* This code is 'reserved to digital' according to the openVMS
-	 linker manual, however it is generated by the DEC C compiler
-	 and defined in the include file.
-	 FIXME, since the following is just a guess
-	 store global longword: store 32bit value of symbol
-	 arg: cs	symbol name.  */
-    case ETIR_S_C_STO_GBL_LW:
-      {
-	vms_symbol_entry *entry;
-	char *name;
-
-	name = _bfd_vms_save_counted_string (ptr);
-	entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV (vms_symbol_table),
-						      name, FALSE, FALSE);
-	if (entry == NULL)
-	  {
-#if VMS_DEBUG
-	    _bfd_vms_debug (3, "%s: no symbol \"%s\"\n", cmd_name (cmd), name);
-#endif
-	    image_write_l (abfd, (unsigned long) 0);	/* FIXME, reloc */
-	  }
-	else
-	  /* FIXME, reloc.  */
-	  image_write_l (abfd, (unsigned long) (entry->symbol->value));
-      }
-      *quarter_relocs = 4;
-      break;
-
-    case ETIR_S_C_STO_RB:
-    case ETIR_S_C_STO_AB:
-    case ETIR_S_C_STO_LP_PSB:
-      (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
-      *quarter_relocs = 0;
-      return FALSE;
-
-    case ETIR_S_C_STO_HINT_GBL:
-    case ETIR_S_C_STO_HINT_PS:
-      (*_bfd_error_handler) (_("%s: not implemented"), cmd_name (cmd));
-      *quarter_relocs = 0;
-      return FALSE;
-
-    default:
-      (*_bfd_error_handler) (_("reserved STO cmd %d"), cmd);
-      *quarter_relocs = 0;
-      return FALSE;
-    }
-
-  return TRUE;
-}
-
-/* Stack operator commands
-   all 32 bit signed arithmetic
-   all word just like a stack calculator
-   arguments are popped from stack, results are pushed on stack
-
-   see table B-10 of the openVMS linker manual.  */
-
-static bfd_boolean
-etir_opr (bfd *abfd, int cmd, unsigned char *ptr ATTRIBUTE_UNUSED,
-	  int *quarter_relocs)
-{
-  long op1, op2;
-
-#if VMS_DEBUG
-  _bfd_vms_debug (5, "etir_opr %d/%x\n", cmd, cmd);
-  _bfd_hexdump (8, ptr, 16, (long) ptr);
-#endif
-
-  /* No relocation uses OPR commands except ETIR_S_C_OPR_ADD.  */
-  if (cmd == ETIR_S_C_OPR_ADD)
-    *quarter_relocs += 1;
-  else
-    *quarter_relocs = 0;
-
-  switch (cmd)
-    {
-    case ETIR_S_C_OPR_NOP:      /* No-op.  */
-      break;
-
-    case ETIR_S_C_OPR_ADD:      /* Add.  */
-      op1 = (long) _bfd_vms_pop (abfd, NULL);
-      op2 = (long) _bfd_vms_pop (abfd, NULL);
-      _bfd_vms_push (abfd, (uquad) (op1 + op2), -1);
-      break;
-
-    case ETIR_S_C_OPR_SUB:      /* Subtract.  */
-      op1 = (long) _bfd_vms_pop (abfd, NULL);
-      op2 = (long) _bfd_vms_pop (abfd, NULL);
-      _bfd_vms_push (abfd, (uquad) (op2 - op1), -1);
-      break;
-
-    case ETIR_S_C_OPR_MUL:      /* Multiply.  */
-      op1 = (long) _bfd_vms_pop (abfd, NULL);
-      op2 = (long) _bfd_vms_pop (abfd, NULL);
-      _bfd_vms_push (abfd, (uquad) (op1 * op2), -1);
-      break;
-
-    case ETIR_S_C_OPR_DIV:      /* Divide.  */
-      op1 = (long) _bfd_vms_pop (abfd, NULL);
-      op2 = (long) _bfd_vms_pop (abfd, NULL);
-      if (op2 == 0)
-	_bfd_vms_push (abfd, (uquad) 0, -1);
-      else
-	_bfd_vms_push (abfd, (uquad) (op2 / op1), -1);
-      break;
-
-    case ETIR_S_C_OPR_AND:      /* Logical AND.  */
-      op1 = (long) _bfd_vms_pop (abfd, NULL);
-      op2 = (long) _bfd_vms_pop (abfd, NULL);
-      _bfd_vms_push (abfd, (uquad) (op1 & op2), -1);
-      break;
-
-    case ETIR_S_C_OPR_IOR:      /* Logical inclusive OR.  */
-      op1 = (long) _bfd_vms_pop (abfd, NULL);
-      op2 = (long) _bfd_vms_pop (abfd, NULL);
-      _bfd_vms_push (abfd, (uquad) (op1 | op2), -1);
-      break;
-
-    case ETIR_S_C_OPR_EOR:      /* Logical exclusive OR.  */
-      op1 = (long) _bfd_vms_pop (abfd, NULL);
-      op2 = (long) _bfd_vms_pop (abfd, NULL);
-      _bfd_vms_push (abfd, (uquad) (op1 ^ op2), -1);
-      break;
-
-    case ETIR_S_C_OPR_NEG:      /* Negate.  */
-      op1 = (long) _bfd_vms_pop (abfd, NULL);
-      _bfd_vms_push (abfd, (uquad) (-op1), -1);
-      break;
-
-    case ETIR_S_C_OPR_COM:      /* Complement.  */
-      op1 = (long) _bfd_vms_pop (abfd, NULL);
-      _bfd_vms_push (abfd, (uquad) (op1 ^ -1L), -1);
-      break;
-
-    case ETIR_S_C_OPR_ASH:      /* Arithmetic shift.  */
-      op1 = (long) _bfd_vms_pop (abfd, NULL);
-      op2 = (long) _bfd_vms_pop (abfd, NULL);
-      if (op2 < 0)		/* Shift right.  */
-	op1 >>= -op2;
-      else			/* Shift left.  */
-	op1 <<= op2;
-      _bfd_vms_push (abfd, (uquad) op1, -1);
-      break;
-
-    case ETIR_S_C_OPR_INSV:      /* Insert field.   */
-      (void) _bfd_vms_pop (abfd, NULL);
-    case ETIR_S_C_OPR_USH:       /* Unsigned shift.   */
-    case ETIR_S_C_OPR_ROT:       /* Rotate.  */
-    case ETIR_S_C_OPR_REDEF:     /* Redefine symbol to current location.  */
-    case ETIR_S_C_OPR_DFLIT:     /* Define a literal.  */
-      (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
-      return FALSE;
-
-    case ETIR_S_C_OPR_SEL:      /* Select.  */
-      if ((long) _bfd_vms_pop (abfd, NULL) & 0x01L)
-	(void) _bfd_vms_pop (abfd, NULL);
-      else
-	{
-	  op1 = (long) _bfd_vms_pop (abfd, NULL);
-	  (void) _bfd_vms_pop (abfd, NULL);
-	  _bfd_vms_push (abfd, (uquad) op1, -1);
-	}
-      break;
-
-    default:
-      (*_bfd_error_handler) (_("reserved OPR cmd %d"), cmd);
-      return FALSE;
-    }
-
-  return TRUE;
-}
-
-/* Control commands.
-
-   See table B-11 of the openVMS linker manual.  */
-
-static bfd_boolean
-etir_ctl (bfd *abfd, int cmd, unsigned char *ptr, int *quarter_relocs)
-{
-  uquad dummy;
-  int psect;
-
-#if VMS_DEBUG
-  _bfd_vms_debug (5, "etir_ctl %d/%x\n", cmd, cmd);
-  _bfd_hexdump (8, ptr, 16, (long) ptr);
-#endif
-
-  /* No relocation uses CTL commands.  */
-  *quarter_relocs = 0;
-
-  switch (cmd)
-    {
-      /* Det relocation base: pop stack, set image location counter
-	 arg: none.  */
-    case ETIR_S_C_CTL_SETRB:
-      dummy = _bfd_vms_pop (abfd, &psect);
-      image_set_ptr (abfd, psect, dummy);
-      break;
-
-      /* Augment relocation base: increment image location counter by offset
-	 arg: lw	offset value.  */
-    case ETIR_S_C_CTL_AUGRB:
-      dummy = bfd_getl32 (ptr);
-      image_inc_ptr (abfd, dummy);
-      break;
-
-      /* Define location: pop index, save location counter under index
-	 arg: none.  */
-    case ETIR_S_C_CTL_DFLOC:
-      dummy = _bfd_vms_pop (abfd, NULL);
-      dst_define_location (abfd, dummy);
-      break;
-
-      /* Set location: pop index, restore location counter from index
-	 arg: none.  */
-    case ETIR_S_C_CTL_STLOC:
-      dummy = _bfd_vms_pop (abfd, NULL);
-      dst_restore_location (abfd, dummy);
-      break;
-
-      /* Stack defined location: pop index, push location counter from index
-	 arg: none.  */
-    case ETIR_S_C_CTL_STKDL:
-      dummy = _bfd_vms_pop (abfd, NULL);
-      _bfd_vms_push (abfd, dst_retrieve_location (abfd, dummy), -1);
-      break;
-
-    default:
-      (*_bfd_error_handler) (_("reserved CTL cmd %d"), cmd);
-      return FALSE;
-    }
-
-  return TRUE;
-}
-
-/* Store conditional commands
-
-   See table B-12 and B-13 of the openVMS linker manual.  */
-
-static bfd_boolean
-etir_stc (bfd *abfd, int cmd, unsigned char *ptr ATTRIBUTE_UNUSED,
-	  int *quarter_relocs)
-{
-#if VMS_DEBUG
-  _bfd_vms_debug (5, "etir_stc %d/%x\n", cmd, cmd);
-  _bfd_hexdump (8, ptr, 16, (long) ptr);
-#endif
-
-  switch (cmd)
-    {
-      /* 200 Store-conditional Linkage Pair
-	 arg: none.  */
-    case ETIR_S_C_STC_LP:
-
-      /* 202 Store-conditional Address at global address
-	 arg:	lw	linkage index
-		cs	global name.  */
-
-    case ETIR_S_C_STC_GBL:
-
-      /* 203 Store-conditional Code Address at global address
-	 arg:	lw	linkage index
-		cs	procedure name.  */
-    case ETIR_S_C_STC_GCA:
-
-      /* 204 Store-conditional Address at psect + offset
-	 arg:	lw	linkage index
-		lw	psect index
-		qw	offset.  */
-    case ETIR_S_C_STC_PS:
-      (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
-      *quarter_relocs = 0;
-      return FALSE;
-
-      /* 201 Store-conditional Linkage Pair with Procedure Signature
-	 arg:	lw	linkage index
-		cs	procedure name
-		by	signature length
-		da	signature.  */
-
-    case ETIR_S_C_STC_LP_PSB:
-      image_inc_ptr (abfd, (uquad) 16);	/* skip entry,procval */
-      *quarter_relocs = 4;
-      break;
-
-      /* 205 Store-conditional NOP at address of global
-	 arg: none.  */
-    case ETIR_S_C_STC_NOP_GBL:
-      /* ALPHA_R_NOP */
-
-      /* 207 Store-conditional BSR at global address
-	 arg: none.  */
-
-    case ETIR_S_C_STC_BSR_GBL:
-      /* ALPHA_R_BSR */
-
-      /* 209 Store-conditional LDA at global address
-	 arg: none.  */
-
-    case ETIR_S_C_STC_LDA_GBL:
-      /* ALPHA_R_LDA */
-
-      /* 211 Store-conditional BSR or Hint at global address
-	 arg: none.  */
-
-    case ETIR_S_C_STC_BOH_GBL:
-      *quarter_relocs = 4;
-      break;
-
-      /* 213 Store-conditional NOP,BSR or HINT at global address
-	 arg: none.  */
-
-    case ETIR_S_C_STC_NBH_GBL:
-
-      /* 206 Store-conditional NOP at pect + offset
-	 arg: none.  */
-
-    case ETIR_S_C_STC_NOP_PS:
-
-      /* 208 Store-conditional BSR at pect + offset
-	 arg: none.  */
-
-    case ETIR_S_C_STC_BSR_PS:
-
-      /* 210 Store-conditional LDA at psect + offset
-	 arg: none.  */
-
-    case ETIR_S_C_STC_LDA_PS:
-
-      /* 212 Store-conditional BSR or Hint at pect + offset
-	 arg: none.  */
-
-    case ETIR_S_C_STC_BOH_PS:
-
-      /* 214 Store-conditional NOP, BSR or HINT at psect + offset
-	 arg: none.  */
-    case ETIR_S_C_STC_NBH_PS:
-      (*_bfd_error_handler) ("%s: not supported", cmd_name (cmd));
-      *quarter_relocs = 0;
-      return FALSE;
-
-    default:
-      (*_bfd_error_handler) (_("reserved STC cmd %d"), cmd);
-      *quarter_relocs = 0;
-      return FALSE;
-    }
-
-  return TRUE;
-}
-
-static asection *
-new_section (bfd * abfd ATTRIBUTE_UNUSED, int idx)
-{
-  asection *section;
-  char sname[16];
-  char *name;
-
-#if VMS_DEBUG
-  _bfd_vms_debug (5, "new_section %d\n", idx);
-#endif
-  sprintf (sname, SECTION_NAME_TEMPLATE, idx);
-
-  name = bfd_malloc ((bfd_size_type) strlen (sname) + 1);
-  if (name == 0)
-    return NULL;
-  strcpy (name, sname);
-
-  section = bfd_malloc ((bfd_size_type) sizeof (asection));
-  if (section == 0)
-    {
-#if VMS_DEBUG
-      _bfd_vms_debug (6,  "new_section (%s) failed", name);
-#endif
-      return NULL;
-    }
-
-  section->size = 0;
-  section->vma = 0;
-  section->contents = 0;
-  section->name = name;
-  section->index = idx;
-
-  return section;
-}
-
-static int
-alloc_section (bfd * abfd, unsigned int idx)
-{
-  bfd_size_type amt;
-
-#if VMS_DEBUG
-  _bfd_vms_debug (4, "alloc_section %d\n", idx);
-#endif
-
-  amt = idx + 1;
-  amt *= sizeof (asection *);
-  PRIV (sections) = bfd_realloc_or_free (PRIV (sections), amt);
-  if (PRIV (sections) == NULL)
-    return -1;
-
-  while (PRIV (section_count) <= idx)
-    {
-      PRIV (sections)[PRIV (section_count)]
-	= new_section (abfd, (int) PRIV (section_count));
-      if (PRIV (sections)[PRIV (section_count)] == 0)
-	return -1;
-      PRIV (section_count)++;
-    }
-
-  return 0;
-}
-
-/* tir_sta
-
-   Vax stack commands.
-
-   Handle sta_xxx commands in tir section,
-   ptr points to data area in record.
-
-   See table 7-3 of the VAX/VMS linker manual.  */
-
-static unsigned char *
-tir_sta (bfd * abfd, unsigned char *ptr)
-{
-  int cmd = *ptr++;
-
-#if VMS_DEBUG
-  _bfd_vms_debug (5, "tir_sta %d\n", cmd);
-#endif
-
-  switch (cmd)
-    {
-      /* stack */
-    case TIR_S_C_STA_GBL:
-      /* stack global
-	 arg: cs	symbol name
-
-	 stack 32 bit value of symbol (high bits set to 0).  */
-      {
-	char *name;
-	vms_symbol_entry *entry;
-
-	name = _bfd_vms_save_counted_string (ptr);
-
-	entry = _bfd_vms_enter_symbol (abfd, name);
-	if (entry == NULL)
-	  return NULL;
-
-	_bfd_vms_push (abfd, (uquad) (entry->symbol->value), -1);
-	ptr += *ptr + 1;
-      }
-      break;
-
-    case TIR_S_C_STA_SB:
-      /* stack signed byte
-	 arg: by	value
-
-	 stack byte value, sign extend to 32 bit.  */
-      _bfd_vms_push (abfd, (uquad) *ptr++, -1);
-      break;
-
-    case TIR_S_C_STA_SW:
-      /* stack signed short word
-	 arg: sh	value
-
-	 stack 16 bit value, sign extend to 32 bit.  */
-      _bfd_vms_push (abfd, (uquad) bfd_getl16 (ptr), -1);
-      ptr += 2;
-      break;
-
-    case TIR_S_C_STA_LW:
-      /* stack signed longword
-	 arg: lw	value
-
-	 stack 32 bit value.  */
-      _bfd_vms_push (abfd, (uquad) bfd_getl32 (ptr), -1);
-      ptr += 4;
-      break;
-
-    case TIR_S_C_STA_PB:
-    case TIR_S_C_STA_WPB:
-      /* stack psect base plus byte offset (word index)
-	 arg: by	section index
-		(sh	section index)
-		by	signed byte offset.  */
-      {
-	unsigned long dummy;
-	int psect;
-
-	if (cmd == TIR_S_C_STA_PB)
-	  psect = *ptr++;
-	else
-	  {
-	    psect = bfd_getl16 (ptr);
-	    ptr += 2;
-	  }
-
-	if ((unsigned int) psect >= PRIV (section_count))
-	  alloc_section (abfd, psect);
-
-	dummy = (long) *ptr++;
-	dummy += (PRIV (sections)[psect])->vma;
-	_bfd_vms_push (abfd, (uquad) dummy, psect);
-      }
-      break;
-
-    case TIR_S_C_STA_PW:
-    case TIR_S_C_STA_WPW:
-      /* stack psect base plus word offset (word index)
-	 arg: by	section index
-		(sh	section index)
-		sh	signed short offset.  */
-      {
-	unsigned long dummy;
-	int psect;
-
-	if (cmd == TIR_S_C_STA_PW)
-	  psect = *ptr++;
-	else
-	  {
-	    psect = bfd_getl16 (ptr);
-	    ptr += 2;
-	  }
-
-	if ((unsigned int) psect >= PRIV (section_count))
-	  alloc_section (abfd, psect);
-
-	dummy = bfd_getl16 (ptr); ptr+=2;
-	dummy += (PRIV (sections)[psect])->vma;
-	_bfd_vms_push (abfd, (uquad) dummy, psect);
-      }
-      break;
-
-    case TIR_S_C_STA_PL:
-    case TIR_S_C_STA_WPL:
-      /* stack psect base plus long offset (word index)
-	 arg: by	section index
-		(sh	section index)
-		lw	signed longword offset.	 */
-      {
-	unsigned long dummy;
-	int psect;
-
-	if (cmd == TIR_S_C_STA_PL)
-	  psect = *ptr++;
-	else
-	  {
-	    psect = bfd_getl16 (ptr);
-	    ptr += 2;
-	  }
-
-	if ((unsigned int) psect >= PRIV (section_count))
-	  alloc_section (abfd, psect);
-
-	dummy = bfd_getl32 (ptr); ptr += 4;
-	dummy += (PRIV (sections)[psect])->vma;
-	_bfd_vms_push (abfd, (uquad) dummy, psect);
-      }
-      break;
-
-    case TIR_S_C_STA_UB:
-      /* stack unsigned byte
-	 arg: by	value
-
-	 stack byte value.  */
-      _bfd_vms_push (abfd, (uquad) *ptr++, -1);
-      break;
-
-    case TIR_S_C_STA_UW:
-      /* stack unsigned short word
-	 arg: sh	value
-
-	 stack 16 bit value.  */
-      _bfd_vms_push (abfd, (uquad) bfd_getl16 (ptr), -1);
-      ptr += 2;
-      break;
-
-    case TIR_S_C_STA_BFI:
-      /* stack byte from image
-	 arg: none.  */
-      /* FALLTHRU  */
-    case TIR_S_C_STA_WFI:
-      /* stack byte from image
-	 arg: none.  */
-      /* FALLTHRU */
-    case TIR_S_C_STA_LFI:
-      /* stack byte from image
-	 arg: none.  */
-      (*_bfd_error_handler) (_("stack-from-image not implemented"));
-      return NULL;
-
-    case TIR_S_C_STA_EPM:
-      /* stack entry point mask
-	 arg: cs	symbol name
-
-	 stack (unsigned) entry point mask of symbol
-	 err if symbol is no entry point.  */
-      {
-	char *name;
-	vms_symbol_entry *entry;
-
-	name = _bfd_vms_save_counted_string (ptr);
-	entry = _bfd_vms_enter_symbol (abfd, name);
-	if (entry == NULL)
-	  return NULL;
-
-	(*_bfd_error_handler) (_("stack-entry-mask not fully implemented"));
-	_bfd_vms_push (abfd, (uquad) 0, -1);
-	ptr += *ptr + 1;
-      }
-      break;
-
-    case TIR_S_C_STA_CKARG:
-      /* compare procedure argument
-	 arg: cs	symbol name
-		by	argument index
-		da	argument descriptor
-
-	 compare argument descriptor with symbol argument (ARG$V_PASSMECH)
-	 and stack TRUE (args match) or FALSE (args dont match) value.  */
-      (*_bfd_error_handler) (_("PASSMECH not fully implemented"));
-      _bfd_vms_push (abfd, (uquad) 1, -1);
-      break;
-
-    case TIR_S_C_STA_LSY:
-      /* stack local symbol value
-	 arg:	sh	environment index
-		cs	symbol name.  */
-      {
-	int envidx;
-	char *name;
-	vms_symbol_entry *entry;
-
-	envidx = bfd_getl16 (ptr);
-	ptr += 2;
-	name = _bfd_vms_save_counted_string (ptr);
-	entry = _bfd_vms_enter_symbol (abfd, name);
-	if (entry == NULL)
-	  return NULL;
-	(*_bfd_error_handler) (_("stack-local-symbol not fully implemented"));
-	_bfd_vms_push (abfd, (uquad) 0, -1);
-	ptr += *ptr + 1;
-      }
-      break;
-
-    case TIR_S_C_STA_LIT:
-      /* stack literal
-	 arg:	by	literal index
-
-	 stack literal.  */
-      ptr++;
-      _bfd_vms_push (abfd, (uquad) 0, -1);
-      (*_bfd_error_handler) (_("stack-literal not fully implemented"));
-      break;
-
-    case TIR_S_C_STA_LEPM:
-      /* stack local symbol entry point mask
-	 arg:	sh	environment index
-		cs	symbol name
-
-	 stack (unsigned) entry point mask of symbol
-	 err if symbol is no entry point.  */
-      {
-	int envidx;
-	char *name;
-	vms_symbol_entry *entry;
-
-	envidx = bfd_getl16 (ptr);
-	ptr += 2;
-	name = _bfd_vms_save_counted_string (ptr);
-	entry = _bfd_vms_enter_symbol (abfd, name);
-	if (entry == NULL)
-	  return NULL;
-	(*_bfd_error_handler) (_("stack-local-symbol-entry-point-mask not fully implemented"));
-	_bfd_vms_push (abfd, (uquad) 0, -1);
-	ptr += *ptr + 1;
-      }
-      break;
-
-    default:
-      (*_bfd_error_handler) (_("reserved STA cmd %d"), ptr[-1]);
-      return NULL;
-      break;
-    }
-
-  return ptr;
-}
-
-static const char *
-tir_cmd_name (int cmd)
-{
-  switch (cmd)
-    {
-    case TIR_S_C_STO_RSB: return "TIR_S_C_STO_RSB";
-    case TIR_S_C_STO_RSW: return "TIR_S_C_STO_RSW";
-    case TIR_S_C_STO_RL: return "TIR_S_C_STO_RL";
-    case TIR_S_C_STO_VPS: return "TIR_S_C_STO_VPS";
-    case TIR_S_C_STO_USB: return "TIR_S_C_STO_USB";
-    case TIR_S_C_STO_USW: return "TIR_S_C_STO_USW";
-    case TIR_S_C_STO_RUB: return "TIR_S_C_STO_RUB";
-    case TIR_S_C_STO_RUW: return "TIR_S_C_STO_RUW";
-    case TIR_S_C_STO_PIRR: return "TIR_S_C_STO_PIRR";
-    case TIR_S_C_OPR_INSV: return "TIR_S_C_OPR_INSV";
-    case TIR_S_C_OPR_DFLIT: return "TIR_S_C_OPR_DFLIT";
-    case TIR_S_C_OPR_REDEF: return "TIR_S_C_OPR_REDEF";
-    case TIR_S_C_OPR_ROT: return "TIR_S_C_OPR_ROT";
-    case TIR_S_C_OPR_USH: return "TIR_S_C_OPR_USH";
-    case TIR_S_C_OPR_ASH: return "TIR_S_C_OPR_ASH";
-    case TIR_S_C_CTL_DFLOC: return "TIR_S_C_CTL_DFLOC";
-    case TIR_S_C_CTL_STLOC: return "TIR_S_C_CTL_STLOC";
-    case TIR_S_C_CTL_STKDL: return "TIR_S_C_CTL_STKDL";
-
-    default:
-      /* These strings have not been added yet.  */
-      abort ();
-    }
-}
-
-/* tir_sto
-
-   vax store commands
-
-   handle sto_xxx commands in tir section
-   ptr points to data area in record
-
-   See table 7-4 of the VAX/VMS linker manual.  */
-
-static unsigned char *
-tir_sto (bfd * abfd, unsigned char *ptr)
-{
-  unsigned long dummy;
-  int size;
-  int psect;
-
-#if VMS_DEBUG
-  _bfd_vms_debug (5, "tir_sto %d\n", *ptr);
-#endif
-
-  switch (*ptr++)
-    {
-    case TIR_S_C_STO_SB:
-      /* Store signed byte: pop stack, write byte
-	 arg: none.  */
-      dummy = _bfd_vms_pop (abfd, &psect);
-      image_write_b (abfd, dummy & 0xff);	/* FIXME: check top bits */
-      break;
-
-    case TIR_S_C_STO_SW:
-      /* Store signed word: pop stack, write word
-	 arg: none.  */
-      dummy = _bfd_vms_pop (abfd, &psect);
-      image_write_w (abfd, dummy & 0xffff);	/* FIXME: check top bits */
-      break;
-
-    case TIR_S_C_STO_LW:
-      /* Store longword: pop stack, write longword
-	 arg: none.  */
-      dummy = _bfd_vms_pop (abfd, &psect);
-      image_write_l (abfd, dummy & 0xffffffff);	/* FIXME: check top bits */
-      break;
-
-    case TIR_S_C_STO_BD:
-      /* Store byte displaced: pop stack, sub lc+1, write byte
-	 arg: none.  */
-      dummy = _bfd_vms_pop (abfd, &psect);
-      dummy -= ((PRIV (sections)[psect])->vma + 1);
-      image_write_b (abfd, dummy & 0xff);/* FIXME: check top bits */
-      break;
-
-    case TIR_S_C_STO_WD:
-      /* Store word displaced: pop stack, sub lc+2, write word
-	 arg: none.  */
-      dummy = _bfd_vms_pop (abfd, &psect);
-      dummy -= ((PRIV (sections)[psect])->vma + 2);
-      image_write_w (abfd, dummy & 0xffff);/* FIXME: check top bits */
-      break;
-
-    case TIR_S_C_STO_LD:
-      /* Store long displaced: pop stack, sub lc+4, write long
-	 arg: none.  */
-      dummy = _bfd_vms_pop (abfd, &psect);
-      dummy -= ((PRIV (sections)[psect])->vma + 4);
-      image_write_l (abfd, dummy & 0xffffffff);/* FIXME: check top bits */
-      break;
-
-    case TIR_S_C_STO_LI:
-      /* Store short literal: pop stack, write byte
-	 arg: none.  */
-      dummy = _bfd_vms_pop (abfd, &psect);
-      image_write_b (abfd, dummy & 0xff);/* FIXME: check top bits */
-      break;
-
-    case TIR_S_C_STO_PIDR:
-      /* Store position independent data reference: pop stack, write longword
-	 arg: none.
-	 FIXME: incomplete !  */
-      dummy = _bfd_vms_pop (abfd, &psect);
-      image_write_l (abfd, dummy & 0xffffffff);
-      break;
-
-    case TIR_S_C_STO_PICR:
-      /* Store position independent code reference: pop stack, write longword
-	 arg: none.
-	 FIXME: incomplete !  */
-      dummy = _bfd_vms_pop (abfd, &psect);
-      image_write_b (abfd, 0x9f);
-      image_write_l (abfd, dummy & 0xffffffff);
-      break;
-
-    case TIR_S_C_STO_RIVB:
-      /* Store repeated immediate variable bytes
-	 1-byte count n field followed by n bytes of data
-	 pop stack, write n bytes <stack> times.  */
-      size = *ptr++;
-      dummy = (unsigned long) _bfd_vms_pop (abfd, NULL);
-      while (dummy-- > 0L)
-	image_dump (abfd, ptr, size, 0);
-      ptr += size;
-      break;
-
-    case TIR_S_C_STO_B:
-      /* Store byte from top longword.  */
-      dummy = (unsigned long) _bfd_vms_pop (abfd, NULL);
-      image_write_b (abfd, dummy & 0xff);
-      break;
-
-    case TIR_S_C_STO_W:
-      /* Store word from top longword.  */
-      dummy = (unsigned long) _bfd_vms_pop (abfd, NULL);
-      image_write_w (abfd, dummy & 0xffff);
-      break;
-
-    case TIR_S_C_STO_RB:
-      /* Store repeated byte from top longword.  */
-      size = (unsigned long) _bfd_vms_pop (abfd, NULL);
-      dummy = (unsigned long) _bfd_vms_pop (abfd, NULL);
-      while (size-- > 0)
-	image_write_b (abfd, dummy & 0xff);
-      break;
-
-    case TIR_S_C_STO_RW:
-      /* Store repeated word from top longword.  */
-      size = (unsigned long) _bfd_vms_pop (abfd, NULL);
-      dummy = (unsigned long) _bfd_vms_pop (abfd, NULL);
-      while (size-- > 0)
-	image_write_w (abfd, dummy & 0xffff);
-      break;
-
-    case TIR_S_C_STO_RSB:
-    case TIR_S_C_STO_RSW:
-    case TIR_S_C_STO_RL:
-    case TIR_S_C_STO_VPS:
-    case TIR_S_C_STO_USB:
-    case TIR_S_C_STO_USW:
-    case TIR_S_C_STO_RUB:
-    case TIR_S_C_STO_RUW:
-    case TIR_S_C_STO_PIRR:
-      (*_bfd_error_handler) (_("%s: not implemented"), tir_cmd_name (ptr[-1]));
-      break;
-
-    default:
-      (*_bfd_error_handler) (_("reserved STO cmd %d"), ptr[-1]);
-      break;
-    }
-
-  return ptr;
-}
-
-/* Stack operator commands
-   All 32 bit signed arithmetic
-   All word just like a stack calculator
-   Arguments are popped from stack, results are pushed on stack
-
-   See table 7-5 of the VAX/VMS linker manual.  */
-
-static unsigned char *
-tir_opr (bfd * abfd, unsigned char *ptr)
-{
-  long op1, op2;
-
-#if VMS_DEBUG
-  _bfd_vms_debug (5, "tir_opr %d\n", *ptr);
-#endif
-
-  /* Operation.  */
-  switch (*ptr++)
-    {
-    case TIR_S_C_OPR_NOP: /* No-op.  */
-      break;
-
-    case TIR_S_C_OPR_ADD: /* Add.  */
-      op1 = (long) _bfd_vms_pop (abfd, NULL);
-      op2 = (long) _bfd_vms_pop (abfd, NULL);
-      _bfd_vms_push (abfd, (uquad) (op1 + op2), -1);
-      break;
-
-    case TIR_S_C_OPR_SUB: /* Subtract.  */
-      op1 = (long) _bfd_vms_pop (abfd, NULL);
-      op2 = (long) _bfd_vms_pop (abfd, NULL);
-      _bfd_vms_push (abfd, (uquad) (op2 - op1), -1);
-      break;
-
-    case TIR_S_C_OPR_MUL: /* Multiply.  */
-      op1 = (long) _bfd_vms_pop (abfd, NULL);
-      op2 = (long) _bfd_vms_pop (abfd, NULL);
-      _bfd_vms_push (abfd, (uquad) (op1 * op2), -1);
-      break;
-
-    case TIR_S_C_OPR_DIV: /* Divide.  */
-      op1 = (long) _bfd_vms_pop (abfd, NULL);
-      op2 = (long) _bfd_vms_pop (abfd, NULL);
-      if (op2 == 0)
-	_bfd_vms_push (abfd, (uquad) 0, -1);
-      else
-	_bfd_vms_push (abfd, (uquad) (op2 / op1), -1);
-      break;
-
-    case TIR_S_C_OPR_AND: /* Logical AND.  */
-      op1 = (long) _bfd_vms_pop (abfd, NULL);
-      op2 = (long) _bfd_vms_pop (abfd, NULL);
-      _bfd_vms_push (abfd, (uquad) (op1 & op2), -1);
-      break;
-
-    case TIR_S_C_OPR_IOR: /* Logical inclusive OR.  */
-      op1 = (long) _bfd_vms_pop (abfd, NULL);
-      op2 = (long) _bfd_vms_pop (abfd, NULL);
-      _bfd_vms_push (abfd, (uquad) (op1 | op2), -1);
-      break;
-
-    case TIR_S_C_OPR_EOR: /* Logical exclusive OR.  */
-      op1 = (long) _bfd_vms_pop (abfd, NULL);
-      op2 = (long) _bfd_vms_pop (abfd, NULL);
-      _bfd_vms_push (abfd, (uquad) (op1 ^ op2), -1);
-      break;
-
-    case TIR_S_C_OPR_NEG: /* Negate.  */
-      op1 = (long) _bfd_vms_pop (abfd, NULL);
-      _bfd_vms_push (abfd, (uquad) (-op1), -1);
-      break;
-
-    case TIR_S_C_OPR_COM: /* Complement.  */
-      op1 = (long) _bfd_vms_pop (abfd, NULL);
-      _bfd_vms_push (abfd, (uquad) (op1 ^ -1L), -1);
-      break;
-
-    case TIR_S_C_OPR_INSV: /* Insert field.  */
-      (void) _bfd_vms_pop (abfd, NULL);
-      (*_bfd_error_handler)  (_("%s: not fully implemented"),
-			      tir_cmd_name (ptr[-1]));
-      break;
-
-    case TIR_S_C_OPR_ASH: /* Arithmetic shift.  */
-      op1 = (long) _bfd_vms_pop (abfd, NULL);
-      op2 = (long) _bfd_vms_pop (abfd, NULL);
-      if (HIGHBIT (op1))	/* Shift right.  */
-	op2 >>= op1;
-      else			/* Shift left.  */
-	op2 <<= op1;
-      _bfd_vms_push (abfd, (uquad) op2, -1);
-      (*_bfd_error_handler)  (_("%s: not fully implemented"),
-			      tir_cmd_name (ptr[-1]));
-      break;
-
-    case TIR_S_C_OPR_USH: /* Unsigned shift.  */
-      op1 = (long) _bfd_vms_pop (abfd, NULL);
-      op2 = (long) _bfd_vms_pop (abfd, NULL);
-      if (HIGHBIT (op1))	/* Shift right.  */
-	op2 >>= op1;
-      else			/* Shift left.  */
-	op2 <<= op1;
-      _bfd_vms_push (abfd, (uquad) op2, -1);
-      (*_bfd_error_handler)  (_("%s: not fully implemented"),
-			      tir_cmd_name (ptr[-1]));
-      break;
-
-    case TIR_S_C_OPR_ROT: /* Rotate.  */
-      op1 = (long) _bfd_vms_pop (abfd, NULL);
-      op2 = (long) _bfd_vms_pop (abfd, NULL);
-      if (HIGHBIT (0))	/* Shift right.  */
-	op2 >>= op1;
-      else		/* Shift left.  */
-	op2 <<= op1;
-      _bfd_vms_push (abfd, (uquad) op2, -1);
-      (*_bfd_error_handler)  (_("%s: not fully implemented"),
-			      tir_cmd_name (ptr[-1]));
-      break;
-
-    case TIR_S_C_OPR_SEL: /* Select.  */
-      if ((long) _bfd_vms_pop (abfd, NULL) & 0x01L)
-	(void) _bfd_vms_pop (abfd, NULL);
-      else
-	{
-	  op1 = (long) _bfd_vms_pop (abfd, NULL);
-	  (void) _bfd_vms_pop (abfd, NULL);
-	  _bfd_vms_push (abfd, (uquad) op1, -1);
-	}
-      break;
-
-    case TIR_S_C_OPR_REDEF: /* Redefine symbol to current location.  */
-    case TIR_S_C_OPR_DFLIT: /* Define a literal.  */
-      (*_bfd_error_handler) (_("%s: not supported"),
-			     tir_cmd_name (ptr[-1]));
-      break;
-
-    default:
-      (*_bfd_error_handler) (_("reserved OPR cmd %d"), ptr[-1]);
-      break;
-    }
-
-  return ptr;
-}
-
-/* Control commands
-
-   See table 7-6 of the VAX/VMS linker manual.  */
-
-static unsigned char *
-tir_ctl (bfd * abfd, unsigned char *ptr)
-{
-  unsigned long dummy;
-  int psect;
-
-#if VMS_DEBUG
-  _bfd_vms_debug (5, "tir_ctl %d\n", *ptr);
-#endif
-
-  switch (*ptr++)
-    {
-    case TIR_S_C_CTL_SETRB:
-      /* Set relocation base: pop stack, set image location counter
-	 arg: none.  */
-      dummy = _bfd_vms_pop (abfd, &psect);
-      if ((unsigned int) psect >= PRIV (section_count))
-	alloc_section (abfd, psect);
-      image_set_ptr (abfd, psect, (uquad) dummy);
-      break;
-
-    case TIR_S_C_CTL_AUGRB:
-      /* Augment relocation base: increment image location counter by offset
-	 arg: lw	offset value.  */
-      dummy = bfd_getl32 (ptr);
-      image_inc_ptr (abfd, (uquad) dummy);
-      break;
-
-    case TIR_S_C_CTL_DFLOC:
-      /* Define location: pop index, save location counter under index
-	 arg: none.  */
-      dummy = _bfd_vms_pop (abfd, NULL);
-      (*_bfd_error_handler) (_("%s: not fully implemented"),
-			     tir_cmd_name (ptr[-1]));
-      break;
-
-    case TIR_S_C_CTL_STLOC:
-      /* Set location: pop index, restore location counter from index
-	 arg: none.  */
-      dummy = _bfd_vms_pop (abfd, &psect);
-      (*_bfd_error_handler) (_("%s: not fully implemented"),
-			     tir_cmd_name (ptr[-1]));
-      break;
-
-    case TIR_S_C_CTL_STKDL:
-      /* Stack defined location: pop index, push location counter from index
-	 arg: none.  */
-      dummy = _bfd_vms_pop (abfd, &psect);
-      (*_bfd_error_handler) (_("%s: not fully implemented"),
-			     tir_cmd_name (ptr[-1]));
-      break;
-
-    default:
-      (*_bfd_error_handler) (_("reserved CTL cmd %d"), ptr[-1]);
-      break;
-    }
-  return ptr;
-}
-
-/* Handle command from TIR section.  */
-
-static unsigned char *
-tir_cmd (bfd * abfd, unsigned char *ptr)
-{
-  static const struct
-  {
-    int mincod;
-    int maxcod;
-    unsigned char * (*explain) (bfd *, unsigned char *);
-  }
-  tir_table[] =
-  {
-    { 0,		 TIR_S_C_MAXSTACOD, tir_sta },
-    { TIR_S_C_MINSTOCOD, TIR_S_C_MAXSTOCOD, tir_sto },
-    { TIR_S_C_MINOPRCOD, TIR_S_C_MAXOPRCOD, tir_opr },
-    { TIR_S_C_MINCTLCOD, TIR_S_C_MAXCTLCOD, tir_ctl },
-    { -1, -1, NULL }
-  };
-  int i = 0;
-
-#if VMS_DEBUG
-  _bfd_vms_debug (4, "tir_cmd %d/%x\n", *ptr, *ptr);
-  _bfd_hexdump (8, ptr, 16, (long) ptr);
-#endif
-
-  if (*ptr & 0x80)
-    {
-      /* Store immediate.  */
-      i = 128 - (*ptr++ & 0x7f);
-      image_dump (abfd, ptr, i, 0);
-      ptr += i;
-    }
-  else
-    {
-      while (tir_table[i].mincod >= 0)
-	{
-	  if ( (tir_table[i].mincod <= *ptr)
-	       && (*ptr <= tir_table[i].maxcod))
-	    {
-	      ptr = tir_table[i].explain (abfd, ptr);
-	      break;
-	    }
-	  i++;
-	}
-      if (tir_table[i].mincod < 0)
-	{
-	  (*_bfd_error_handler) (_("obj code %d not found"), *ptr);
-	  ptr = 0;
-	}
-    }
-
-  return ptr;
-}
-
-/* Handle command from ETIR section.  */
-
-static int
-etir_cmd (bfd *abfd, int cmd, unsigned char *ptr, int *quarter_relocs)
-{
-  static const struct
-  {
-    int mincod;
-    int maxcod;
-    bfd_boolean (*explain) (bfd *, int, unsigned char *, int *);
-  }
-  etir_table[] =
-  {
-    { ETIR_S_C_MINSTACOD, ETIR_S_C_MAXSTACOD, etir_sta },
-    { ETIR_S_C_MINSTOCOD, ETIR_S_C_MAXSTOCOD, etir_sto },
-    { ETIR_S_C_MINOPRCOD, ETIR_S_C_MAXOPRCOD, etir_opr },
-    { ETIR_S_C_MINCTLCOD, ETIR_S_C_MAXCTLCOD, etir_ctl },
-    { ETIR_S_C_MINSTCCOD, ETIR_S_C_MAXSTCCOD, etir_stc },
-    { -1, -1, NULL }
-  };
-
-  int i = 0;
-
-#if VMS_DEBUG
-  _bfd_vms_debug (4, "etir_cmd: %s(%d)\n", cmd_name (cmd), cmd);
-  _bfd_hexdump (8, ptr, 16, (long) ptr);
-#endif
-
-  while (etir_table[i].mincod >= 0)
-    {
-      if ( (etir_table[i].mincod <= cmd)
-	   && (cmd <= etir_table[i].maxcod))
-	{
-	  if (!etir_table[i].explain (abfd, cmd, ptr, quarter_relocs))
-	    return -1;
-	  break;
-	}
-      i++;
-    }
-
-#if VMS_DEBUG
-  _bfd_vms_debug (4, "etir_cmd: result = 0\n");
-#endif
-  return 0;
-}
-
-/* Text Information and Relocation Records (OBJ$C_TIR)
-   handle tir record.  */
-
-static int
-analyze_tir (bfd * abfd, unsigned char *ptr, unsigned int length)
-{
-  unsigned char *maxptr;
-
-#if VMS_DEBUG
-  _bfd_vms_debug (3, "analyze_tir: %d bytes\n", length);
-#endif
-
-  maxptr = ptr + length;
-
-  while (ptr < maxptr)
-    {
-      ptr = tir_cmd (abfd, ptr);
-      if (ptr == 0)
-	return -1;
-    }
-
-  return 0;
-}
-
-/* Text Information and Relocation Records (EOBJ$C_ETIR)
-   handle etir record.  */
-
-static int
-analyze_etir (bfd * abfd, unsigned char *ptr, unsigned int length)
-{
-  unsigned char *maxptr = ptr + length;
-  /* Relocations are made of 1, 2 or 4 ETIR commands.
-     We therefore count them using quarters.  */
-  int quarter_relocs = 0;
-  int result = 0;
-
-#if VMS_DEBUG
-  _bfd_vms_debug (3, "analyze_etir: %d bytes\n", length);
-#endif
-
-  while (ptr < maxptr)
-    {
-      int cmd = bfd_getl16 (ptr);
-      int cmd_length = bfd_getl16 (ptr + 2);
-      result = etir_cmd (abfd, cmd, ptr + 4, &quarter_relocs);
-      if (result != 0)
-	break;
-
-      /* If we have a relocation, we record its length to size
-	 future buffers and bump the reloc count of the section.  */
-      if (quarter_relocs)
-	{
-	  vms_section_data (PRIV (image_section))->reloc_size += cmd_length;
-	  abfd->flags |= HAS_RELOC;
-
-	  if (quarter_relocs == 4)
-	    {
-	      PRIV (image_section)->reloc_count++;
-
-#if VMS_DEBUG
-	      _bfd_vms_debug (4, "-> reloc %d at 0x%x\n",
-			      PRIV (image_section)->reloc_count-1,
-			      ptr - (maxptr - length));
-#endif
-
-	      quarter_relocs = 0;
-	    }
-	  else if (quarter_relocs > 4)
-	    {
-
-#if VMS_DEBUG
-	      _bfd_vms_debug (4, "Reloc count error (%d) in section %s\n",
-			      PRIV (image_section)->reloc_count,
-			      PRIV (image_section)->name);
-#endif
-
-	      quarter_relocs = 0;
-	    }
-	}
-
-      /* If we have a Store Immediate, we reserve space for the
-	 count argument.  */
-      else if (cmd == ETIR_S_C_STO_IMM)
-        vms_section_data (PRIV (image_section))->reloc_size
-	  += ETIR_S_C_HEADER_SIZE + 4;
-
-      ptr += cmd_length;
-    }
-
-#if VMS_DEBUG
-  _bfd_vms_debug (3, "analyze_etir: result = %d\n", result);
-#endif
-
-  return result;
-}
-
-/* Process ETIR record
-   Return 0 on success, -1 on error.  */
-
-int
-_bfd_vms_slurp_tir (bfd * abfd, int objtype)
-{
-  int result;
-
-#if VMS_DEBUG
-  _bfd_vms_debug (2, "TIR/ETIR\n");
-#endif
-
-  switch (objtype)
-    {
-    case EOBJ_S_C_ETIR:
-      PRIV (vms_rec) += ETIR_S_C_HEADER_SIZE;
-      PRIV (rec_size) -= ETIR_S_C_HEADER_SIZE;
-      result = analyze_etir (abfd, PRIV (vms_rec), (unsigned) PRIV (rec_size));
-      break;
-    case OBJ_S_C_TIR:
-      PRIV (vms_rec) += 1;	/* Skip type.  */
-      PRIV (rec_size) -= 1;
-      result = analyze_tir (abfd, PRIV (vms_rec), (unsigned) PRIV (rec_size));
-      break;
-    default:
-      result = -1;
-      break;
-    }
-
-  return result;
-}
-
- /* Slurp relocs from ETIR sections and (temporarily) save them
-    in the per-section reloc buffer.  */
-
-int
-_bfd_vms_slurp_relocs (bfd *abfd)
-{
-  struct vms_section_data_struct *vsd;
-  unsigned char *begin = PRIV (vms_rec) + 4;
-  unsigned char *end = PRIV (vms_rec) + PRIV (rec_size);
-  unsigned char *ptr;
-  int cmd, length, slurped_length;
-
-#if VMS_DEBUG
-  _bfd_vms_debug (3, "_bfd_vms_slurp_relocs: %d bytes\n", PRIV (rec_size));
-#endif
-
-  for (ptr = begin; ptr < end; ptr += length)
-    {
-      cmd = bfd_getl16 (ptr);
-      length = bfd_getl16 (ptr + 2);
-      slurped_length = length;
-
-      switch (cmd)
-	{
-	case ETIR_S_C_STA_PQ: /* ALPHA_R_REF{LONG|QUAD}, others part 1 */
-	  /* This one is special as it is both part of the section header
-	     and of the ALPHA_R_REFLONG and ALPHA_R_REFQUAD relocations.  */
-	  if (bfd_getl16 (ptr + length) == ETIR_S_C_CTL_SETRB)
-	    {
-	      int psect = bfd_getl32 (ptr + ETIR_S_C_HEADER_SIZE);
-	      PRIV (image_section) = PRIV (sections)[psect];
-	      continue;
-	    }
-
-	case ETIR_S_C_STA_GBL: /* ALPHA_R_REFLONG und_section, step 1 */
-			       /* ALPHA_R_REFQUAD und_section, step 1 */
-	  break;
-
-	case ETIR_S_C_STA_LW: /* ALPHA_R_REFLONG und_section, step 2 */
-			      /* ALPHA_R_REFLONG abs_section, step 1 */
-	  /* This one is special as it is both part of the section header
-	     and of the ALPHA_R_REFLONG relocation.  */
-	  if (bfd_getl16 (ptr + length) == ETIR_S_C_CTL_DFLOC)
-	    {
-	      PRIV (image_section) = PRIV (dst_section);
-	      continue;
-	    }
-
-	case ETIR_S_C_STA_QW: /* ALPHA_R_REFQUAD und_section, step 2 */
-			      /* ALPHA_R_REFQUAD abs_section, step 1 */
-
-	case ETIR_S_C_STO_LW: /* ALPHA_R_REFLONG und_section, step 4 */
-			      /* ALPHA_R_REFLONG abs_section, step 2 */
-			      /* ALPHA_R_REFLONG others, step 2 */
-
-	case ETIR_S_C_STO_QW: /* ALPHA_R_REFQUAD und_section, step 4 */
-			      /* ALPHA_R_REFQUAD abs_section, step 2 */
-
-	case ETIR_S_C_STO_OFF: /* ALPHA_R_REFQUAD others, step 2 */
-
-	case ETIR_S_C_OPR_ADD: /* ALPHA_R_REFLONG und_section, step 3 */
-			       /* ALPHA_R_REFQUAD und_section, step 3 */
-
-	case ETIR_S_C_STO_CA:      /* ALPHA_R_CODEADDR */
-	case ETIR_S_C_STO_GBL:     /* ALPHA_R_REFQUAD und_section */
-	case ETIR_S_C_STO_GBL_LW:  /* ALPHA_R_REFLONG und_section */
-	case ETIR_S_C_STC_LP_PSB:  /* ALPHA_R_LINKAGE */
-	case ETIR_S_C_STC_NOP_GBL: /* ALPHA_R_NOP */
-	case ETIR_S_C_STC_BSR_GBL: /* ALPHA_R_BSR */
-	case ETIR_S_C_STC_LDA_GBL: /* ALPHA_R_LDA */
-	case ETIR_S_C_STC_BOH_GBL: /* ALPHA_R_BOH */
-	  break;
-
-	case ETIR_S_C_STO_IMM:
-	  if (PRIV (image_section)->reloc_count == 0)
-	    continue;
-	  /* This is not a relocation, but we nevertheless slurp the
-	     count argument.  We'll use it to compute the addresses
-	     of the relocations.  */
-	  slurped_length = ETIR_S_C_HEADER_SIZE + 4;
-	  break;
-
-	default:
-	  continue;
-	}
-
-      vsd = vms_section_data (PRIV (image_section));
-      memcpy (vsd->reloc_stream + vsd->reloc_offset, ptr, slurped_length);
-      vsd->reloc_offset += slurped_length;
-      if (vsd->reloc_offset > vsd->reloc_size)
-        {
-	  (*_bfd_error_handler) (_("Reloc size error in section %s"),
-			         PRIV (image_section)->name);
-	  return -1;
-	}
-    }
-
-#if VMS_DEBUG
-  _bfd_vms_debug (3, "_bfd_vms_slurp_relocs: result = 0\n");
-#endif
-
-  return 0;
-}
-
-/* Decode relocs from the reloc buffer of the specified section
-   and internalize them in the specified buffer.  */
-
-int
-_bfd_vms_decode_relocs (bfd *abfd, arelent *relocs, asection *section,
-			asymbol **symbols ATTRIBUTE_UNUSED)
-{
-  int saved_cmd, saved_sym_offset, saved_sec_offset, saved_addend_offset;
-  int cmd, sym_offset, sec_offset, address_offset, addend_offset;
-  struct vms_section_data_struct *vsd = vms_section_data (section);
-  bfd_reloc_code_real_type reloc_code;
-  vms_symbol_entry *entry;
-  bfd_vma vaddr = 0;
-  unsigned char *begin = vsd->reloc_stream;
-  unsigned char *end = vsd->reloc_stream + vsd->reloc_size;
-  unsigned char *ptr, *arg_ptr;
-  const char *name;
-  int length;
-
-#if VMS_DEBUG
-  _bfd_vms_debug (3, "_bfd_vms_decode_relocs: %d bytes\n", vsd->reloc_size);
-#endif
-
-  #define PUSH_CMD()					\
-    {							\
-      saved_cmd = cmd;					\
-      saved_sym_offset = sym_offset - length;		\
-      saved_sec_offset = sec_offset - length;		\
-      saved_addend_offset = addend_offset - length;	\
-      continue;						\
-    }
-
-  #define POP_CMD()					\
-    {							\
-      cmd = saved_cmd;					\
-      saved_cmd = ETIR_S_C_MAXSTCCOD + 1;		\
-      sym_offset = saved_sym_offset;			\
-      sec_offset = saved_sec_offset;			\
-      addend_offset= saved_addend_offset;		\
-    }
-
-  #define CMD_PUSHED (saved_cmd != ETIR_S_C_MAXSTCCOD + 1)
-
-  #define NO_OFFSET -128
-
-  saved_cmd = ETIR_S_C_MAXSTCCOD + 1;
-  saved_sym_offset = NO_OFFSET;
-  saved_sec_offset = NO_OFFSET;
-  saved_addend_offset = NO_OFFSET;
-
-  for (ptr = begin; ptr < end; ptr += length)
-    {
-      cmd = bfd_getl16 (ptr);
-      length = bfd_getl16 (ptr + 2);
-
-      arg_ptr = ptr + ETIR_S_C_HEADER_SIZE;
-      sym_offset = NO_OFFSET;
-      sec_offset = NO_OFFSET;
-      address_offset = NO_OFFSET;
-      addend_offset = NO_OFFSET;
-
-      switch (cmd)
-	{
-	case ETIR_S_C_STA_GBL: /* ALPHA_R_REFLONG und_section, step 1 */
-			       /* ALPHA_R_REFQUAD und_section, step 1 */
-	  sym_offset = 0;
-	  PUSH_CMD ()
-
-	case ETIR_S_C_STA_PQ: /* ALPHA_R_REF{LONG|QUAD}, others part 1 */
-	  sec_offset = 0;
-	  addend_offset = 4;
-	  PUSH_CMD ()
-
-	case ETIR_S_C_STA_LW: /* ALPHA_R_REFLONG abs_section, step 1 */
-			      /* ALPHA_R_REFLONG und_section, step 2 */
-	  if (CMD_PUSHED)
-	    {
-	      POP_CMD ()
-	      if (cmd != ETIR_S_C_STA_GBL)
-		{
-		  (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
-					 cmd_name (cmd),
-					 cmd_name (ETIR_S_C_STA_LW));
-		  return 0;
-		}
-	      cmd = ETIR_S_C_STA_LW;
-	    }
-	  addend_offset = 0;
-	  PUSH_CMD ()
-
-	case ETIR_S_C_STA_QW: /* ALPHA_R_REFQUAD abs_section, step 1 */
-			      /* ALPHA_R_REFQUAD und_section, step 2 */
-	  if (CMD_PUSHED)
-	    {
-	      POP_CMD ()
-	      if (cmd != ETIR_S_C_STA_GBL)
-		{
-		  (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
-					 cmd_name (cmd),
-					 cmd_name (ETIR_S_C_STA_QW));
-		  return 0;
-		}
-	      cmd = ETIR_S_C_STA_QW;
-	    }
-	  addend_offset = 0;
-	  PUSH_CMD ()
-
-	case ETIR_S_C_STO_LW: /* ALPHA_R_REFLONG und_section, step 4 */
-			      /* ALPHA_R_REFLONG abs_section, step 2 */
-			      /* ALPHA_R_REFLONG others, step 2 */
-	  POP_CMD ()
-	  if (cmd != ETIR_S_C_OPR_ADD
-	      && cmd != ETIR_S_C_STA_LW
-	      && cmd != ETIR_S_C_STA_PQ)
-	    {
-	      (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
-	        cmd_name (cmd), cmd_name (ETIR_S_C_STO_LW));
-	      return 0;
-	    }
-	  reloc_code = BFD_RELOC_32;
-	  break;
-
-	case ETIR_S_C_STO_QW: /* ALPHA_R_REFQUAD und_section, step 4 */
-			      /* ALPHA_R_REFQUAD abs_section, step 2 */
-	  POP_CMD ()
-	  if (cmd != ETIR_S_C_OPR_ADD && cmd != ETIR_S_C_STA_QW)
-	    {
-	      (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
-	        cmd_name (cmd), cmd_name (ETIR_S_C_STO_QW));
-	      return 0;
-	    }
-	  reloc_code = BFD_RELOC_64;
-	  break;
-
-	case ETIR_S_C_STO_OFF: /* ALPHA_R_REFQUAD others, step 2 */
-	  POP_CMD ()
-	  if (cmd != ETIR_S_C_STA_PQ)
-	    {
-	      (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
-	        cmd_name (cmd), cmd_name (ETIR_S_C_STO_OFF));
-	      return 0;
-	    }
-	  reloc_code = BFD_RELOC_64;
-	  break;
-
-	case ETIR_S_C_OPR_ADD: /* ALPHA_R_REFLONG und_section, step 3 */
-			       /* ALPHA_R_REFQUAD und_section, step 3 */
-	  POP_CMD ()
-	  if (cmd != ETIR_S_C_STA_LW && cmd != ETIR_S_C_STA_QW)
-	    {
-	      (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
-	        cmd_name (cmd), cmd_name (ETIR_S_C_OPR_ADD));
-	      return 0;
-	    }
-	  cmd = ETIR_S_C_OPR_ADD;
-	  PUSH_CMD ()
-
-	case ETIR_S_C_STO_CA: /* ALPHA_R_CODEADDR */
-	  reloc_code = BFD_RELOC_ALPHA_CODEADDR;
-	  sym_offset = 0;
-	  break;
-
-	case ETIR_S_C_STO_GBL: /* ALPHA_R_REFQUAD und_section */
-	  reloc_code = BFD_RELOC_64;
-	  sym_offset = 0;
-	  break;
-
-	case ETIR_S_C_STO_GBL_LW: /* ALPHA_R_REFLONG und_section */
-	  reloc_code = BFD_RELOC_32;
-	  sym_offset = 0;
-	  break;
-
-	case ETIR_S_C_STC_LP_PSB: /* ALPHA_R_LINKAGE */
-	  reloc_code = BFD_RELOC_ALPHA_LINKAGE;
-	  sym_offset = 4;
-	  break;
-
-	case ETIR_S_C_STC_NOP_GBL: /* ALPHA_R_NOP */
-	  reloc_code = BFD_RELOC_ALPHA_NOP;
-	  goto call_reloc;
-
-	case ETIR_S_C_STC_BSR_GBL: /* ALPHA_R_BSR */
-	  reloc_code = BFD_RELOC_ALPHA_BSR;
-	  goto call_reloc;
-
-	case ETIR_S_C_STC_LDA_GBL: /* ALPHA_R_LDA */
-	  reloc_code = BFD_RELOC_ALPHA_LDA;
-	  goto call_reloc;
-
-	case ETIR_S_C_STC_BOH_GBL: /* ALPHA_R_BOH */
-	  reloc_code = BFD_RELOC_ALPHA_BOH;
-	  goto call_reloc;
-
-	call_reloc:
-	  sym_offset = 32;
-	  address_offset = 8;
-	  addend_offset = 24;
-	  break;
-
-	case ETIR_S_C_STO_IMM:
-	  vaddr += bfd_getl32 (arg_ptr);
-	  length = ETIR_S_C_HEADER_SIZE + 4;
-	  continue;
-
-	default:
-	  continue;
-	}
-
-      relocs->howto = bfd_reloc_type_lookup (abfd, reloc_code);
-
-      if (sym_offset > NO_OFFSET)
-	{
-	  name = _bfd_vms_save_counted_string (arg_ptr + sym_offset);
-	  entry = (vms_symbol_entry *)
-	    bfd_hash_lookup (PRIV (vms_symbol_table), name, FALSE, FALSE);
-	  if (entry == NULL)
-	    {
-	      (*_bfd_error_handler) (_("Unknown symbol %s in command %s"),
-				     name, cmd_name (cmd));
-	      relocs->sym_ptr_ptr = NULL;
-	    }
-	  else
-	    /* ??? This is a hack.  We should point in 'symbols'.  */
-	    relocs->sym_ptr_ptr = &entry->symbol;
-	}
-      else if (sec_offset > NO_OFFSET)
-	relocs->sym_ptr_ptr
-	  = PRIV (sections)[bfd_getl32 (arg_ptr + sec_offset)]->symbol_ptr_ptr;
-      else
-	relocs->sym_ptr_ptr = NULL;
-
-      if (address_offset > NO_OFFSET)
-	relocs->address = bfd_getl64 (arg_ptr + address_offset);
-      else
-	relocs->address = vaddr;
-
-      if (addend_offset > NO_OFFSET)
-	relocs->addend = bfd_getl64 (arg_ptr + addend_offset);
-      else
-	relocs->addend = 0;
-
-      vaddr += bfd_get_reloc_size (relocs->howto);
-      relocs++;     
-    }
-
-  #undef PUSH_CMD
-  #undef POP_CMD
-  #undef NO_OFFSET
-
-#if VMS_DEBUG
-  _bfd_vms_debug (3, "_bfd_vms_decode_relocs: result = 0\n");
-#endif
-
-  return 0;
-}
-
-/* Process LNK record
-   Return 0 on success, -1 on error
-
-   Not implemented yet.  */
-
-int
-_bfd_vms_slurp_lnk (bfd * abfd ATTRIBUTE_UNUSED,
-		    int objtype ATTRIBUTE_UNUSED)
-{
-#if VMS_DEBUG
-  _bfd_vms_debug (2, "LNK\n");
-#endif
-
-  return 0;
-}
-
-/* WRITE ETIR SECTION
-
-   This is still under construction and therefore not documented.  */
-
-static void start_etir_record (bfd *abfd, int sec_index, uquad offset,
-			       bfd_boolean justoffset);
-static void start_first_etbt_record (bfd *abfd);
-static void start_another_etbt_record (bfd *abfd);
-static void sto_imm (bfd *abfd, bfd_size_type, unsigned char *, bfd_vma vaddr,
-		     int sec_index, const char *name);
-static void end_etir_record (bfd *abfd);
-static void etir_output_check (bfd *abfd, asection *section, bfd_vma vaddr,
-			       int checklen);
-
-/* Start ETIR record for section #index at virtual addr offset.  */
-
-static void
-start_etir_record (bfd * abfd, int sec_index, uquad offset, bfd_boolean justoffset)
-{
-  if (!justoffset)
-    {
-      /* One ETIR per section.  */
-      _bfd_vms_output_begin (abfd, EOBJ_S_C_ETIR, -1);
-      _bfd_vms_output_push (abfd);
-    }
-
-  /* Push start offset.  */
-  _bfd_vms_output_begin (abfd, ETIR_S_C_STA_PQ, -1);
-  _bfd_vms_output_long (abfd, (unsigned long) sec_index);
-  _bfd_vms_output_quad (abfd, (uquad) offset);
-  _bfd_vms_output_flush (abfd);
-
-  /* Start = pop ().  */
-  _bfd_vms_output_begin (abfd, ETIR_S_C_CTL_SETRB, -1);
-  _bfd_vms_output_flush (abfd);
-}
-
-static void
-end_etir_record (bfd * abfd)
-{
-  _bfd_vms_output_pop (abfd);
-  _bfd_vms_output_end (abfd);
-}
-
-/* Output a STO_IMM command for SSIZE bytes of data from CPR at virtual
-   address VADDR in section specified by SEC_INDEX and NAME.  */
-
-static void
-sto_imm (bfd *abfd, bfd_size_type ssize, unsigned char *cptr, bfd_vma vaddr,
-	 int sec_index, const char *name)
-{
-  bfd_size_type size;
-
-#if VMS_DEBUG
-  _bfd_vms_debug (8, "sto_imm %d bytes\n", ssize);
-  _bfd_hexdump (9, cptr, (int) ssize, (int) vaddr);
-#endif
-
-  while (ssize > 0)
-    {
-      /* Try all the rest.  */
-      size = ssize;
-
-      if (_bfd_vms_output_check (abfd, size) < 0)
-	{
-	  /* Doesn't fit, split !  */
-	  end_etir_record (abfd);
-
-	  if (name [0] && name[1] == 'v' && !strcmp (name, ".vmsdebug"))
-	    start_another_etbt_record (abfd);
-	  else
-	    start_etir_record (abfd, sec_index, vaddr, FALSE);
-
-	  size = _bfd_vms_output_check (abfd, 0);	/* get max size */
-	  if (size > ssize)			/* more than what's left ? */
-	    size = ssize;
-	}
-
-      _bfd_vms_output_begin (abfd, ETIR_S_C_STO_IMM, -1);
-      _bfd_vms_output_long (abfd, (unsigned long) (size));
-      _bfd_vms_output_dump (abfd, cptr, size);
-      _bfd_vms_output_flush (abfd);
-
-#if VMS_DEBUG
-      _bfd_vms_debug (10, "dumped %d bytes\n", size);
-      _bfd_hexdump (10, cptr, (int) size, (int) vaddr);
-#endif
-
-      vaddr += size;
-      cptr += size;
-      ssize -= size;
-    }
-}
-
-/* Start ETBT record for section #index at virtual addr offset.  */
-
-static void
-start_first_etbt_record (bfd *abfd)
-{
-  _bfd_vms_output_begin (abfd, EOBJ_S_C_ETBT, -1);
-  _bfd_vms_output_push (abfd);
-
-  _bfd_vms_output_begin (abfd, ETIR_S_C_STA_LW, -1);	/* push start offset */
-  _bfd_vms_output_long (abfd, (unsigned long) 0);
-  _bfd_vms_output_flush (abfd);
-
-  _bfd_vms_output_begin (abfd, ETIR_S_C_CTL_DFLOC, -1);	/* start = pop() */
-  _bfd_vms_output_flush (abfd);
-}
-
-static void
-start_another_etbt_record (bfd *abfd)
-{
-  _bfd_vms_output_begin (abfd, EOBJ_S_C_ETBT, -1);
-  _bfd_vms_output_push (abfd);
-}
-
-static void
-etir_output_check (bfd *abfd, asection *section, bfd_vma vaddr, int checklen)
-{
-  if (_bfd_vms_output_check (abfd, checklen) < 0)
-    {
-      end_etir_record (abfd);
-      if (section->name[0] && section->name[1] == 'v'
-	  && !strcmp (section->name, ".vmsdebug"))
-	start_another_etbt_record (abfd);
-      else
-	start_etir_record (abfd, section->index, vaddr, FALSE);
-    }
-}
-
-/* Return whether RELOC must be deferred till the end.  */
-
-static int
-defer_reloc_p (arelent *reloc)
-{
-  switch (reloc->howto->type)
-    {
-    case ALPHA_R_NOP:
-    case ALPHA_R_LDA:
-    case ALPHA_R_BSR:
-    case ALPHA_R_BOH:
-      return 1;
-
-    default:
-      return 0;
-    }
-}
-
-/* Write section contents for bfd abfd.  */
-
-int
-_bfd_vms_write_tir (bfd * abfd, int objtype ATTRIBUTE_UNUSED)
-{
-  asection *section;
-
-#if VMS_DEBUG
-  _bfd_vms_debug (2, "vms_write_tir (%p, %d)\n", abfd, objtype);
-#endif
-
-  _bfd_vms_output_alignment (abfd, 4);
-
-  PRIV (vms_linkage_index) = 1;
-
-  for (section = abfd->sections; section; section = section->next)
-    {
-#if VMS_DEBUG
-      _bfd_vms_debug (4, "writing %d. section '%s' (%d bytes)\n",
-		      section->index, section->name,
-		      (int) (section->size));
-#endif
-
-      if (!(section->flags & SEC_HAS_CONTENTS)
-	  || bfd_is_com_section (section))
-	continue;
-
-      if (!section->contents)
-	{
-	  bfd_set_error (bfd_error_no_contents);
-	  return -1;
-	}
-
-      if (section->name[0]
-	  && section->name[1] == 'v'
-	  && !strcmp (section->name, ".vmsdebug"))
-	start_first_etbt_record (abfd);
-      else
-	start_etir_record (abfd, section->index, 0, FALSE);
-
-      if (section->flags & SEC_RELOC)
-	{
-	  bfd_vma curr_addr = 0;
-	  unsigned char *curr_data = section->contents;
-	  bfd_size_type size;
-	  int pass2_needed = 0;
-	  int pass2_in_progress = 0;
-	  unsigned int irel;
-
-	  if (section->reloc_count <= 0)
-	    (*_bfd_error_handler)
-	      (_("SEC_RELOC with no relocs in section %s"), section->name);
-
-#if VMS_DEBUG
-	  else
-	    {
-	      int i = section->reloc_count;
-	      arelent **rptr = section->orelocation;
-	      _bfd_vms_debug (4, "%d relocations:\n", i);
-	      while (i-- > 0)
-		{
-		  _bfd_vms_debug (4, "sym %s in sec %s, value %08lx, "
-				     "addr %08lx, off %08lx, len %d: %s\n",
-				  (*(*rptr)->sym_ptr_ptr)->name,
-				  (*(*rptr)->sym_ptr_ptr)->section->name,
-				  (long) (*(*rptr)->sym_ptr_ptr)->value,
-				  (*rptr)->address, (*rptr)->addend,
-				  bfd_get_reloc_size ((*rptr)->howto),
-				   ( *rptr)->howto->name);
-		  rptr++;
-		}
-	    }
-#endif
-
-	new_pass:
-	  for (irel = 0; irel < section->reloc_count; irel++)
-	    {
-	      struct evax_private_udata_struct *udata;
-	      arelent *rptr = section->orelocation [irel];
-	      bfd_vma addr = rptr->address;
-	      asymbol *sym = *rptr->sym_ptr_ptr;
-	      asection *sec = sym->section;
-	      int defer = defer_reloc_p (rptr);
-	      unsigned int slen;
-	      char *hash;
-
-	      if (pass2_in_progress)
-		{
-		  /* Non-deferred relocs have already been output.  */
-		  if (!defer)
-		    continue;
-		}
-	      else
-		{
-		  /* Deferred relocs must be output at the very end.  */
-		  if (defer)
-		    {
-		      pass2_needed = 1;
-		      continue;
-		    }
-
-		  /* Regular relocs are intertwined with binary data.  */
-	          if (curr_addr > addr)
-		    (*_bfd_error_handler) (_("Size error in section %s"),
-					   section->name);
-		  size = addr - curr_addr;
-		  sto_imm (abfd, size, curr_data, curr_addr,
-		          section->index, section->name);
-		  curr_data += size;
-		  curr_addr += size;
-		}
-
-	      size = bfd_get_reloc_size (rptr->howto);
-
-	      switch (rptr->howto->type)
-	        {
-		case ALPHA_R_IGNORE:
-		  break;
-
-		case ALPHA_R_REFLONG:
-		  if (bfd_is_und_section (sym->section))
-		    {
-		      bfd_vma addend = rptr->addend;
-		      slen = strlen ((char *) sym->name);
-		      hash = _bfd_vms_length_hash_symbol
-			       (abfd, sym->name, EOBJ_S_C_SYMSIZ);
-		      etir_output_check (abfd, section, curr_addr, slen);
-		      if (addend)
-			{
-			  _bfd_vms_output_begin (abfd, ETIR_S_C_STA_GBL, -1);
-			  _bfd_vms_output_counted (abfd, hash);
-			  _bfd_vms_output_flush (abfd);
-			  _bfd_vms_output_begin (abfd, ETIR_S_C_STA_LW, -1);
-			  _bfd_vms_output_long (abfd, (unsigned long) addend);
-			  _bfd_vms_output_flush (abfd);
-			  _bfd_vms_output_begin (abfd, ETIR_S_C_OPR_ADD, -1);
-			  _bfd_vms_output_flush (abfd);
-			  _bfd_vms_output_begin (abfd, ETIR_S_C_STO_LW, -1);
-			  _bfd_vms_output_flush (abfd);
-			}
-		      else
-			{
-			  _bfd_vms_output_begin (abfd, ETIR_S_C_STO_GBL_LW, -1);
-			  _bfd_vms_output_counted (abfd, hash);
-			  _bfd_vms_output_flush (abfd);
-			}
-		    }
-		  else if (bfd_is_abs_section (sym->section))
-		    {
-		      etir_output_check (abfd, section, curr_addr, 16);
-		      _bfd_vms_output_begin (abfd, ETIR_S_C_STA_LW, -1);
-		      _bfd_vms_output_long (abfd, (unsigned long) sym->value);
-		      _bfd_vms_output_flush (abfd);
-		      _bfd_vms_output_begin (abfd, ETIR_S_C_STO_LW, -1);
-		      _bfd_vms_output_flush (abfd);
-		    }
-		  else
-		    {
-		      etir_output_check (abfd, section, curr_addr, 32);
-		      _bfd_vms_output_begin (abfd, ETIR_S_C_STA_PQ, -1);
-		      _bfd_vms_output_long (abfd, (unsigned long) sec->index);
-		      _bfd_vms_output_quad (abfd, (uquad) rptr->addend
-						    + (uquad) sym->value);
-		      _bfd_vms_output_flush (abfd);
-		      /* ??? Table B-8 of the OpenVMS Linker Utilily Manual
-			 says that we should have a ETIR_S_C_STO_OFF here.
-			 But the relocation would not be BFD_RELOC_32 then.
-			 This case is very likely unreachable.  */
-		      _bfd_vms_output_begin (abfd, ETIR_S_C_STO_LW, -1);
-		      _bfd_vms_output_flush (abfd);
-		    }
-		  break;
-
-		case ALPHA_R_REFQUAD:
-		  if (bfd_is_und_section (sym->section))
-		    {
-		      bfd_vma addend = rptr->addend;
-		      slen = strlen ((char *) sym->name);
-		      hash = _bfd_vms_length_hash_symbol
-			       (abfd, sym->name, EOBJ_S_C_SYMSIZ);
-		      etir_output_check (abfd, section, curr_addr, slen);
-		      if (addend)
-			{
-			  _bfd_vms_output_begin (abfd, ETIR_S_C_STA_GBL, -1);
-			  _bfd_vms_output_counted (abfd, hash);
-			  _bfd_vms_output_flush (abfd);
-			  _bfd_vms_output_begin (abfd, ETIR_S_C_STA_QW, -1);
-			  _bfd_vms_output_quad (abfd, (uquad) addend);
-			  _bfd_vms_output_flush (abfd);
-			  _bfd_vms_output_begin (abfd, ETIR_S_C_OPR_ADD, -1);
-			  _bfd_vms_output_flush (abfd);
-			  _bfd_vms_output_begin (abfd, ETIR_S_C_STO_QW, -1);
-			  _bfd_vms_output_flush (abfd);
-			}
-		      else
-			{
-			  _bfd_vms_output_begin (abfd, ETIR_S_C_STO_GBL, -1);
-			  _bfd_vms_output_counted (abfd, hash);
-			  _bfd_vms_output_flush (abfd);
-			}
-		    }
-		  else if (bfd_is_abs_section (sym->section))
-		    {
-		      etir_output_check (abfd, section, curr_addr, 16);
-		      _bfd_vms_output_begin (abfd, ETIR_S_C_STA_QW, -1);
-		      _bfd_vms_output_quad (abfd, (uquad) sym->value);
-		      _bfd_vms_output_flush (abfd);
-		      _bfd_vms_output_begin (abfd, ETIR_S_C_STO_QW, -1);
-		      _bfd_vms_output_flush (abfd);
-		    }
-		  else
-		    {
-		      etir_output_check (abfd, section, curr_addr, 32);
-		      _bfd_vms_output_begin (abfd, ETIR_S_C_STA_PQ, -1);
-		      _bfd_vms_output_long (abfd, (unsigned long) sec->index);
-		      _bfd_vms_output_quad (abfd, (uquad) rptr->addend
-						    + (uquad) sym->value);
-		      _bfd_vms_output_flush (abfd);
-		      _bfd_vms_output_begin (abfd, ETIR_S_C_STO_OFF, -1);
-		      _bfd_vms_output_flush (abfd);
-		    }
-		  break;
-
-		case ALPHA_R_HINT:
-		  sto_imm (abfd, size, curr_data, curr_addr,
-			   section->index, section->name);
-		  break;
-		
-		case ALPHA_R_LINKAGE:
-		  etir_output_check (abfd, section, curr_addr, 64);
-		  _bfd_vms_output_begin (abfd, ETIR_S_C_STC_LP_PSB, -1);
-		  _bfd_vms_output_long
-		    (abfd, (unsigned long) PRIV (vms_linkage_index));
-		  PRIV (vms_linkage_index) += 2;
-		  hash = _bfd_vms_length_hash_symbol
-			   (abfd, sym->name, EOBJ_S_C_SYMSIZ);
-		  _bfd_vms_output_counted (abfd, hash);
-		  _bfd_vms_output_byte (abfd, 0);
-		  _bfd_vms_output_flush (abfd);
-		  break;
-
-		case ALPHA_R_CODEADDR:
-		  slen = strlen ((char *) sym->name);
-		  hash = _bfd_vms_length_hash_symbol
-			   (abfd, sym->name, EOBJ_S_C_SYMSIZ);
-		  etir_output_check (abfd, section, curr_addr, slen);
-		  _bfd_vms_output_begin (abfd, ETIR_S_C_STO_CA, -1);
-		  _bfd_vms_output_counted (abfd, hash);
-		  _bfd_vms_output_flush (abfd);
-		  break;
-
-		case ALPHA_R_NOP:
-		  udata
-		    = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr;
-		  etir_output_check (abfd, section, curr_addr,
-				     32 + 1 + strlen (udata->origname));
-		  _bfd_vms_output_begin (abfd, ETIR_S_C_STC_NOP_GBL, -1);
-		  _bfd_vms_output_long (abfd, (unsigned long) udata->lkindex);
-		  _bfd_vms_output_long
-		    (abfd, (unsigned long) udata->enbsym->section->index);
-		  _bfd_vms_output_quad (abfd, (uquad) rptr->address);
-		  _bfd_vms_output_long (abfd, (unsigned long) 0x47ff041f);
-		  _bfd_vms_output_long
-		    (abfd, (unsigned long) udata->enbsym->section->index);
-		  _bfd_vms_output_quad (abfd, (uquad) rptr->addend);
-		  _bfd_vms_output_counted
-		    (abfd, _bfd_vms_length_hash_symbol
-			     (abfd, udata->origname, EOBJ_S_C_SYMSIZ));
-		  _bfd_vms_output_flush (abfd);
-		  break;
-
-		case ALPHA_R_BSR:
-		  (*_bfd_error_handler) (_("Spurious ALPHA_R_BSR reloc"));
-		  break;
-
-		case ALPHA_R_LDA:
-		  udata
-		    = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr;
-		  etir_output_check (abfd, section, curr_addr,
-				     32 + 1 + strlen (udata->origname));
-		  _bfd_vms_output_begin (abfd, ETIR_S_C_STC_LDA_GBL, -1);
-		  _bfd_vms_output_long
-		    (abfd, (unsigned long) udata->lkindex + 1);
-		  _bfd_vms_output_long
-		    (abfd, (unsigned long) udata->enbsym->section->index);
-		  _bfd_vms_output_quad (abfd, (uquad) rptr->address);
-		  _bfd_vms_output_long (abfd, (unsigned long) 0x237B0000);
-		  _bfd_vms_output_long
-		    (abfd, (unsigned long) udata->bsym->section->index);
-		  _bfd_vms_output_quad (abfd, (uquad) rptr->addend);
-		  _bfd_vms_output_counted
-		    (abfd, _bfd_vms_length_hash_symbol
-			    (abfd, udata->origname, EOBJ_S_C_SYMSIZ));
-		  _bfd_vms_output_flush (abfd);
-		  break;
-
-		case ALPHA_R_BOH:
-		  udata
-		    = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr;
-		  etir_output_check (abfd, section, curr_addr,
-				       32 + 1 + strlen (udata->origname));
-		  _bfd_vms_output_begin (abfd, ETIR_S_C_STC_BOH_GBL, -1);
-		  _bfd_vms_output_long (abfd, (unsigned long) udata->lkindex);
-		  _bfd_vms_output_long
-		    (abfd, (unsigned long) udata->enbsym->section->index);
-		  _bfd_vms_output_quad (abfd, (uquad) rptr->address);
-		  _bfd_vms_output_long (abfd, (unsigned long) 0xD3400000);
-		  _bfd_vms_output_long
-		    (abfd, (unsigned long) udata->enbsym->section->index);
-		  _bfd_vms_output_quad (abfd, (uquad) rptr->addend);
-		  _bfd_vms_output_counted
-		    (abfd, _bfd_vms_length_hash_symbol
-			     (abfd, udata->origname, EOBJ_S_C_SYMSIZ));
-		  _bfd_vms_output_flush (abfd);
-		  break;
-
-		default:
-		  (*_bfd_error_handler) (_("Unhandled relocation %s"),
-		  			 rptr->howto->name);
-		  break;
-		}
-
-	      curr_data += size;
-	      curr_addr += size;
-	    } /* End of relocs loop.  */
-
-	  if (!pass2_in_progress)
-	    {
-	      /* Output rest of section.  */
-	      if (curr_addr > section->size)
-		(*_bfd_error_handler) (_("Size error in section %s"),
-				       section->name);
-	      size = section->size - curr_addr;
-	      sto_imm (abfd, size, curr_data, curr_addr,
-		       section->index, section->name);
-	      curr_data += size;
-	      curr_addr += size;
-
-	      if (pass2_needed)
-		{
-		  pass2_in_progress = 1;
-		  goto new_pass;
-		}
-	    }
-	}
-  
-      else /* (section->flags & SEC_RELOC) */
-	sto_imm (abfd, section->size, section->contents, 0,
-		 section->index, section->name);
-
-      end_etir_record (abfd);
-    }
-
-  _bfd_vms_output_alignment (abfd, 2);
-  return 0;
-}
diff --git a/bfd/vms.c b/bfd/vms.c
deleted file mode 100644
index c63e175..0000000
--- a/bfd/vms.c
+++ /dev/null
@@ -1,1518 +0,0 @@
-/* vms.c -- BFD back-end for VAX (openVMS/VAX) and
-   EVAX (openVMS/Alpha) files.
-   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
-   2006, 2007, 2008, 2009 Free Software Foundation, Inc.
-
-   Main file.
-
-   Written by Klaus K"ampf (kkaempf@rmi.de)
-
-   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.  */
-
-#ifdef VMS
-#include <rms.h>
-#include <unixlib.h>
-#include <starlet.h>
-#define RME$C_SETRFM 0x00000001
-#include <unistd.h>
-#endif
-
-#include "sysdep.h"
-#include "bfd.h"
-#include "bfdlink.h"
-#include "libbfd.h"
-
-#include "vms.h"
-
-static bfd_boolean vms_initialize (bfd *);
-static bfd_boolean fill_section_ptr (struct bfd_hash_entry *, PTR);
-static bfd_boolean vms_fixup_sections (bfd *);
-static bfd_boolean copy_symbols (struct bfd_hash_entry *, PTR);
-static bfd_reloc_status_type reloc_nil (bfd *, arelent *, asymbol *, PTR,
-					asection *, bfd *, char **);
-static int vms_slurp_module (bfd *abfd);
-static int vms_slurp_image (bfd *abfd);
-static const struct bfd_target *vms_object_p (bfd *abfd);
-static bfd_boolean vms_mkobject (bfd *abfd);
-static bfd_boolean vms_write_object_contents (bfd *abfd);
-static void free_reloc_stream (bfd *abfd, asection *section, void *data);
-static bfd_boolean vms_close_and_cleanup (bfd *abfd);
-static bfd_boolean vms_new_section_hook (bfd *abfd, asection *section);
-static bfd_boolean vms_get_section_contents
-  (bfd *abfd, asection *section, PTR x1, file_ptr x2, bfd_size_type x3);
-static long vms_get_symtab_upper_bound (bfd *abfd);
-static long vms_canonicalize_symtab (bfd *abfd, asymbol **symbols);
-static void vms_print_symbol (bfd *abfd, PTR file, asymbol *symbol,
-			      bfd_print_symbol_type how);
-static void vms_get_symbol_info (bfd *abfd, asymbol *symbol, symbol_info *ret);
-static bfd_boolean vms_bfd_is_local_label_name (bfd *abfd, const char *);
-static bfd_boolean vms_find_nearest_line
-  (bfd *abfd, asection *section, asymbol **symbols, bfd_vma offset,
-   const char **file, const char **func, unsigned int *line);
-static void alloc_reloc_stream (bfd *abfd, asection *section,
-				void *alloc_error);
-static bfd_boolean vms_slurp_reloc_table (bfd *abfd, asection *section,
-					  asymbol **symbols);
-static long vms_get_reloc_upper_bound (bfd *abfd, asection *sect);
-static long vms_canonicalize_reloc (bfd *abfd, asection *srcsec,
-				    arelent **location, asymbol **symbols);
-static const struct reloc_howto_struct *vms_bfd_reloc_type_lookup
-  (bfd *abfd, bfd_reloc_code_real_type code);
-static bfd_boolean vms_set_arch_mach
-  (bfd *abfd, enum bfd_architecture arch, unsigned long mach);
-static bfd_boolean vms_set_section_contents
-  (bfd *abfd, asection *section, const PTR location, file_ptr offset,
-   bfd_size_type count);
-
-#define vms_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
-#define vms_make_empty_symbol             _bfd_generic_make_empty_symbol
-#define vms_bfd_link_just_syms            _bfd_generic_link_just_syms
-#define vms_bfd_copy_link_hash_symbol_type \
-  _bfd_generic_copy_link_hash_symbol_type
-#define vms_bfd_is_group_section          bfd_generic_is_group_section
-#define vms_bfd_discard_group             bfd_generic_discard_group
-#define vms_section_already_linked        _bfd_generic_section_already_linked
-#define vms_bfd_define_common_symbol      bfd_generic_define_common_symbol
-#define vms_bfd_copy_private_header_data  _bfd_generic_bfd_copy_private_header_data
-#define vms_get_synthetic_symtab          _bfd_nodynamic_get_synthetic_symtab
-
-#define vms_bfd_copy_private_bfd_data	  _bfd_generic_bfd_copy_private_bfd_data
-#define vms_bfd_free_cached_info	  _bfd_generic_bfd_free_cached_info
-#define vms_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
-#define vms_bfd_copy_private_symbol_data  _bfd_generic_bfd_copy_private_symbol_data
-#define vms_bfd_set_private_flags         _bfd_generic_bfd_set_private_flags
-#define vms_bfd_merge_private_bfd_data    _bfd_generic_bfd_merge_private_bfd_data
-#define vms_get_section_contents_in_window _bfd_generic_get_section_contents_in_window
-#define vms_read_minisymbols               _bfd_generic_read_minisymbols
-#define vms_minisymbol_to_symbol           _bfd_generic_minisymbol_to_symbol
-#define vms_get_lineno                     _bfd_nosymbols_get_lineno
-#define vms_find_inliner_info              _bfd_nosymbols_find_inliner_info
-#define vms_bfd_make_debug_symbol          _bfd_nosymbols_bfd_make_debug_symbol
-
-#ifdef VMS_DEBUG
-/* Cause debug info to be emitted for the structure.  */
-struct vms_private_data_struct _vms_private_data_struct_dummy;
-struct vms_section_data_struct _vms_section_data_struct_dummy;
-#endif
-
-extern const bfd_target vms_vax_vec;
-extern const bfd_target vms_alpha_vec;
-
-/* Initialize private data  */
-static bfd_boolean
-vms_initialize (bfd * abfd)
-{
-  bfd_size_type amt;
-
-  bfd_set_start_address (abfd, (bfd_vma) -1);
-
-  amt = sizeof (struct vms_private_data_struct);
-  abfd->tdata.any = bfd_zalloc (abfd, amt);
-  if (abfd->tdata.any == NULL)
-    return FALSE;
-
-  if (bfd_get_flavour (abfd) == bfd_target_ovax_flavour)
-    PRIV (is_vax) = TRUE;
-
-  PRIV (file_format) = FF_UNKNOWN;
-
-  amt = sizeof (struct stack_struct) * STACKSIZE;
-  PRIV (stack) = bfd_alloc (abfd, amt);
-  if (PRIV (stack) == NULL)
-    goto error_ret1;
-
-  amt = sizeof (struct bfd_hash_table);
-  PRIV (vms_symbol_table) = bfd_alloc (abfd, amt);
-  if (PRIV (vms_symbol_table) == NULL)
-    goto error_ret1;
-
-  if (!bfd_hash_table_init (PRIV (vms_symbol_table), _bfd_vms_hash_newfunc,
-			    sizeof (vms_symbol_entry)))
-    goto error_ret1;
-
-  amt = MAX_OUTREC_SIZE;
-  PRIV (output_buf) = bfd_alloc (abfd, amt);
-  if (PRIV (output_buf) == NULL)
-    goto error_ret2;
-
-  PRIV (length_pos) = 2;
-
-  return TRUE;
-
- error_ret2:
-  bfd_hash_table_free (PRIV (vms_symbol_table));
- error_ret1:
-  bfd_release (abfd, abfd->tdata.any);
-  abfd->tdata.any = NULL;
-  return FALSE;
-}
-
-struct pair
-{
-  unsigned int section_count;
-  asection **sections;
-};
-
-/* Fill symbol->section with section pointer.
-
-   symbol->section is filled with the section index for defined symbols
-   during reading the GSD/EGSD section.  But we need the pointer to the
-   bfd section later.
-
-   It has the correct value for referenced (undefined section) symbols.
-
-   Called from bfd_hash_traverse in vms_fixup_sections.  */
-
-static bfd_boolean
-fill_section_ptr (struct bfd_hash_entry *entry, void *sections)
-{
-  asymbol *sym = ((vms_symbol_entry *)entry)->symbol;
-  struct pair *data = (struct pair *)sections;
-  unsigned long sec = (unsigned long)sym->section;
-
-  vms_debug2 ((6, "fill_section_ptr: sym %p, sec %lu\n", sym, sec));
-
-  if (sec < data->section_count)
-    {
-      sym->section = data->sections[sec];
-
-      if (strcmp (sym->name, sym->section->name) == 0)
-	sym->flags |= BSF_SECTION_SYM;
-    }
-  else if (sec == (unsigned long)-1)
-    sym->section = &bfd_und_section;
-
-  return TRUE;
-}
-
-/* Fixup section pointers in symbols.  */
-static bfd_boolean
-vms_fixup_sections (bfd * abfd)
-{
-  struct pair data;
-
-  if (PRIV (fixup_done))
-    return TRUE;
-
-  data.section_count = PRIV (section_count);
-  data.sections = PRIV (sections);
-  bfd_hash_traverse (PRIV (vms_symbol_table), fill_section_ptr, &data);
-
-  PRIV (fixup_done) = TRUE;
-  return TRUE;
-}
-
-/* Slurp an ordered set of VMS object records.  */
-int
-_bfd_vms_slurp_object_records (bfd * abfd)
-{
-  int err, new_type, type = -1;
-
-  do
-    {
-      vms_debug2 ((7, "reading at %08lx\n", bfd_tell (abfd)));
-
-      new_type = _bfd_vms_get_object_record (abfd);
-      if (new_type < 0)
-	{
-	  vms_debug2 ((2, "next_record failed\n"));
-	  return -1;
-	}
-
-      if (type == EOBJ_S_C_EGSD && new_type != EOBJ_S_C_EGSD)
-	{
-	  if (! vms_fixup_sections (abfd))
-	    {
-	      vms_debug2 ((2, "vms_fixup_sections failed\n"));
-	      return -1;
-	    }
-	}
-
-      type = new_type;
-
-      switch (type)
-	{
-	  case OBJ_S_C_HDR:
-	  case EOBJ_S_C_EMH:
-	    err = _bfd_vms_slurp_hdr (abfd, type);
-	    break;
-	  case OBJ_S_C_EOM:
-	  case OBJ_S_C_EOMW:
-	  case EOBJ_S_C_EEOM:
-	    err = _bfd_vms_slurp_eom (abfd, type);
-	    break;
-	  case OBJ_S_C_GSD:
-	  case EOBJ_S_C_EGSD:
-	    err = _bfd_vms_slurp_gsd (abfd, type);
-	    break;
-	  case OBJ_S_C_TIR:
-	  case EOBJ_S_C_ETIR:
-	    err = _bfd_vms_slurp_tir (abfd, type);
-	    break;
-	  case OBJ_S_C_DBG:
-	  case EOBJ_S_C_EDBG:
-	    err = _bfd_vms_slurp_dbg (abfd, type);
-	    PRIV (dst_ptr_end) = PRIV (image_ptr);
-	    break;
-	  case OBJ_S_C_TBT:
-	  case EOBJ_S_C_ETBT:
-	    err = _bfd_vms_slurp_tbt (abfd, type);
-	    PRIV (dst_ptr_end) = PRIV (image_ptr);
-	    break;
-	  case OBJ_S_C_LNK:
-	    err = _bfd_vms_slurp_lnk (abfd, type);
-	    break;
-	  default:
-	    err = -1;
-	}
-      if (err != 0)
-	{
-	  vms_debug2 ((2, "slurp type %d failed with %d\n", type, err));
-	  return err;
-	}
-    }
-  while (type != EOBJ_S_C_EEOM && type != OBJ_S_C_EOM && type != OBJ_S_C_EOMW);
-
-  return 0;
-}
-
-/* Slurp a VMS module and return an error status.  */
-
-static int
-vms_slurp_module (bfd *abfd)
-{
-  int type, err;
-
-  if (PRIV (is_vax))
-    type = PRIV (vms_rec)[0];
-  else
-    type = bfd_getl16 (PRIV (vms_rec));
-
-  err = _bfd_vms_slurp_hdr (abfd, type);
-  if (err != 0)
-    {
-      bfd_set_error (bfd_error_wrong_format);
-      return err;
-    }
-
-  return _bfd_vms_slurp_object_records (abfd);
-}
-
-/* Slurp a VMS image and return an error status.  */
-
-static int
-vms_slurp_image (bfd *abfd)
-{
-  unsigned int isd_offset, ihs_offset;
-  int err;
-
-  err = _bfd_vms_slurp_ihd (abfd, &isd_offset, &ihs_offset);
-  if (err != 0)
-    {
-      bfd_set_error (bfd_error_wrong_format);
-      return err;
-    }
-
-  err = _bfd_vms_slurp_isd (abfd, isd_offset);
-  if (err != 0)
-    {
-      bfd_set_error (bfd_error_wrong_format);
-      return err;
-    }
-
-  return _bfd_vms_slurp_ihs (abfd, ihs_offset);
-}
-
-/* Check the format for a file being read.
-   Return a (bfd_target *) if it's an object file or zero if not.  */
-
-static const struct bfd_target *
-vms_object_p (bfd *abfd)
-{
-  const struct bfd_target *target_vector;
-  const bfd_arch_info_type *arch;
-  PTR tdata_save = abfd->tdata.any;
-  bfd_vma saddr_save = bfd_get_start_address (abfd);
-  int err = 0;
-
-  vms_debug2 ((1, "vms_object_p(%p)\n", abfd));
-
-  if (!vms_initialize (abfd))
-    goto error_ret;
-
-  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET))
-    goto err_wrong_format;
-
-  switch (_bfd_vms_get_first_record (abfd))
-    {
-    case FT_UNKNOWN:
-    default:
-      err = -1;
-      break;
-
-    case FT_MODULE:
-      err = vms_slurp_module (abfd);
-      break;
-
-    case FT_IMAGE:
-      err = vms_slurp_image (abfd);
-      break;
-    }
-
-  if (err != 0)
-    goto err_wrong_format;
-
-  if (PRIV (is_vax))
-    {
-      if (! vms_fixup_sections (abfd))
-	{
-	  vms_debug2 ((2, "vms_fixup_sections failed\n"));
-	  goto err_wrong_format;
-	}
-
-      target_vector = &vms_vax_vec;
-      arch = bfd_scan_arch ("vax");
-
-      vms_debug2 ((2, "arch is vax\n"));
-    }
-  else
-    {
-      /* Set arch_info to alpha.   */
-      target_vector = &vms_alpha_vec;
-      arch = bfd_scan_arch ("alpha");
-      vms_debug2 ((2, "arch is alpha\n"));
-    }
-
-  abfd->arch_info = arch;
-  return target_vector;
-
- err_wrong_format:
-  bfd_set_error (bfd_error_wrong_format);
-
- error_ret:
-  if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
-    bfd_release (abfd, abfd->tdata.any);
-  abfd->tdata.any = tdata_save;
-  bfd_set_start_address (abfd, saddr_save);
-  return NULL;
-}
-
-/* Set the format of a file being written.  */
-
-static bfd_boolean
-vms_mkobject (bfd * abfd)
-{
-  const bfd_arch_info_type *arch;
-
-  vms_debug2 ((1, "vms_mkobject (%p)\n", abfd));
-
-  if (!vms_initialize (abfd))
-    return FALSE;
-
-  if (PRIV (is_vax))
-    arch = bfd_scan_arch ("vax");
-  else
-    arch = bfd_scan_arch ("alpha");
-
-  if (arch == 0)
-    {
-      bfd_set_error(bfd_error_wrong_format);
-      return FALSE;
-    }
-
-  abfd->arch_info = arch;
-  return TRUE;
-}
-
-/* Write cached information into a file being written, at bfd_close.  */
-
-static bfd_boolean
-vms_write_object_contents (bfd * abfd)
-{
-  vms_debug2 ((1, "vms_write_object_contents (%p)\n", abfd));
-
-  if (abfd->section_count > 0)			/* we have sections */
-    {
-      if (PRIV (is_vax))
-	{
-	  if (_bfd_vms_write_hdr (abfd, OBJ_S_C_HDR) != 0)
-	    return FALSE;
-	  if (_bfd_vms_write_gsd (abfd, OBJ_S_C_GSD) != 0)
-	    return FALSE;
-	  if (_bfd_vms_write_tir (abfd, OBJ_S_C_TIR) != 0)
-	    return FALSE;
-	  if (_bfd_vms_write_tbt (abfd, OBJ_S_C_TBT) != 0)
-	    return FALSE;
-	  if (_bfd_vms_write_dbg (abfd, OBJ_S_C_DBG) != 0)
-	    return FALSE;
-	  if (abfd->section_count > 255)
-	    {
-	      if (_bfd_vms_write_eom (abfd, OBJ_S_C_EOMW) != 0)
-		return FALSE;
-	    }
-	  else
-	    {
-	      if (_bfd_vms_write_eom (abfd, OBJ_S_C_EOM) != 0)
-		return FALSE;
-	    }
-	}
-      else
-	{
-	  if (_bfd_vms_write_hdr (abfd, EOBJ_S_C_EMH) != 0)
-	    return FALSE;
-	  if (_bfd_vms_write_gsd (abfd, EOBJ_S_C_EGSD) != 0)
-	    return FALSE;
-	  if (_bfd_vms_write_tir (abfd, EOBJ_S_C_ETIR) != 0)
-	    return FALSE;
-	  if (_bfd_vms_write_tbt (abfd, EOBJ_S_C_ETBT) != 0)
-	    return FALSE;
-	  if (_bfd_vms_write_dbg (abfd, EOBJ_S_C_EDBG) != 0)
-	    return FALSE;
-	  if (_bfd_vms_write_eom (abfd, EOBJ_S_C_EEOM) != 0)
-	    return FALSE;
-	}
-    }
-  return TRUE;
-}
-
-/* 4.1, generic.  */
-
-/* Free the reloc buffer for the specified section.  */
-
-static void
-free_reloc_stream (bfd *abfd ATTRIBUTE_UNUSED, asection *section,
-		   void *data ATTRIBUTE_UNUSED)
-{
-  if (vms_section_data (section)->reloc_stream)
-    free (vms_section_data (section)->reloc_stream);
-}
-
-#ifdef VMS
-/* Convert the file to variable record length format. This is done
-   using undocumented system call sys$modify().
-   Pure VMS version.  */
-
-static void
-vms_convert_to_var (char *vms_filename)
-{
-  struct FAB fab = cc$rms_fab;
-
-  fab.fab$l_fna = vms_filename;
-  fab.fab$b_fns = strlen (vms_filename);
-  fab.fab$b_fac = FAB$M_PUT;
-  fab.fab$l_fop = FAB$M_ESC;
-  fab.fab$l_ctx = RME$C_SETRFM;
-
-  sys$open (&fab);
-
-  fab.fab$b_rfm = FAB$C_VAR;
-
-  sys$modify (&fab);
-  sys$close (&fab);
-}
-
-static int
-vms_convert_to_var_1 (char *filename, int type)
-{
-  if (type != DECC$K_FILE)
-    return FALSE;
-  vms_convert_to_var (filename);
-  return TRUE;
-}
-
-/* Convert the file to variable record length format. This is done
-   using undocumented system call sys$modify().
-   Unix filename version.  */
-
-static int
-vms_convert_to_var_unix_filename (const char *unix_filename)
-{
-  if (decc$to_vms (unix_filename, &vms_convert_to_var_1, 0, 1) != 1)
-    return FALSE;
-  return TRUE;
-}
-#endif /* VMS */
-
-/* Called when the BFD is being closed to do any necessary cleanup.  */
-
-static bfd_boolean
-vms_close_and_cleanup (bfd * abfd)
-{
-  vms_debug2 ((1, "vms_close_and_cleanup (%p)\n", abfd));
-
-  if (abfd == NULL || abfd->tdata.any == NULL)
-    return TRUE;
-
-  if (PRIV (vms_buf) != NULL)
-    free (PRIV (vms_buf));
-
-  if (PRIV (sections) != NULL)
-    free (PRIV (sections));
-
-  if (PRIV (vms_symbol_table))
-    bfd_hash_table_free (PRIV (vms_symbol_table));
-
-  bfd_map_over_sections (abfd, free_reloc_stream, NULL);
-
-  bfd_release (abfd, abfd->tdata.any);
-  abfd->tdata.any = NULL;
-
-#ifdef VMS
-  if (abfd->direction == write_direction)
-    {
-      /* Last step on VMS is to convert the file to variable record length
-	 format.  */
-      if (bfd_cache_close (abfd) != TRUE)
-	return FALSE;
-      if (vms_convert_to_var_unix_filename (abfd->filename) != TRUE)
-	return FALSE;
-    }
-#endif
-
-  return TRUE;
-}
-
-/* Called when a new section is created.  */
-
-static bfd_boolean
-vms_new_section_hook (bfd * abfd, asection *section)
-{
-  bfd_size_type amt;
-
-  /* Count hasn't been incremented yet.  */
-  unsigned int section_count = abfd->section_count + 1;
-
-  vms_debug2 ((1, "vms_new_section_hook (%p, [%d]%s), count %d\n",
-               abfd, section->index, section->name, section_count));
-
-  bfd_set_section_alignment (abfd, section, 0);
-
-  if (section_count > PRIV (section_count))
-    {
-      amt = section_count;
-      amt *= sizeof (asection *);
-      PRIV (sections) = bfd_realloc_or_free (PRIV (sections), amt);
-      if (PRIV (sections) == NULL)
-	return FALSE;
-      PRIV (section_count) = section_count;
-    }
-
-  vms_debug2 ((6, "section_count: %d\n", PRIV (section_count)));
-
-  PRIV (sections)[section->index] = section;
-
-  vms_debug2 ((7, "%d: %s\n", section->index, section->name));
-
-  amt = sizeof (struct vms_section_data_struct);
-  section->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
-  if (section->used_by_bfd == NULL)
-    return FALSE;
-
-  return _bfd_generic_new_section_hook (abfd, section);
-}
-
-/* Read the contents of a section.
-   buf points to a buffer of buf_size bytes to be filled with
-   section data (starting at offset into section)  */
-
-static bfd_boolean
-vms_get_section_contents (bfd * abfd ATTRIBUTE_UNUSED,
-			  asection *section ATTRIBUTE_UNUSED,
-			  void * buf ATTRIBUTE_UNUSED,
-			  file_ptr offset ATTRIBUTE_UNUSED,
-			  bfd_size_type buf_size ATTRIBUTE_UNUSED)
-{
-  bfd_size_type size = section->size;
-
-  vms_debug2 ((1, "vms_get_section_contents (%p, %s, %p, off %ld, size %d)\n",
-               abfd, section->name, buf, offset, (int)buf_size));
-
-  if (section->contents)
-    abort ();
-
-  section->contents = (unsigned char *) bfd_malloc (size);
-
-  if (section->contents == NULL)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      return FALSE;
-    }
-
-  if (bfd_seek (abfd, section->filepos, SEEK_SET))
-    {
-      bfd_set_error (bfd_error_file_truncated);
-      return FALSE;
-    }
-
-  if (bfd_bread (section->contents, size, abfd) != size)
-    {
-      bfd_set_error (bfd_error_file_truncated);
-      return FALSE;
-    }
-
-  section->flags |= SEC_IN_MEMORY;
-
-  if (buf)
-    memcpy (buf, section->contents + offset, (size_t) buf_size);
-
-  return TRUE;
-}
-
-/* Part 4.5, symbols.  */
-
-/* Return the number of bytes required to store a vector of pointers
-   to asymbols for all the symbols in the BFD abfd, including a
-   terminal NULL pointer. If there are no symbols in the BFD,
-   then return 0.  If an error occurs, return -1.  */
-
-static long
-vms_get_symtab_upper_bound (bfd * abfd)
-{
-  vms_debug2 ((1, "vms_get_symtab_upper_bound (%p), %d symbols\n",
-               abfd, PRIV (gsd_sym_count)));
-
-  return (PRIV (gsd_sym_count) + 1) * sizeof (asymbol *);
-}
-
-/* Copy symbols from hash table to symbol vector
-
-   called from bfd_hash_traverse in vms_canonicalize_symtab
-   init counter to 0 if entry == 0.  */
-
-static bfd_boolean
-copy_symbols (struct bfd_hash_entry *entry, void * arg)
-{
-  bfd * abfd = (bfd *) arg;
-
-  if (entry == NULL)	/* Init counter.  */
-    PRIV (symnum) = 0;
-  else			/* Fill vector, inc counter.  */
-    PRIV (symcache)[PRIV (symnum)++] = ((vms_symbol_entry *)entry)->symbol;
-
-  return TRUE;
-}
-
-/* Read the symbols from the BFD abfd, and fills in the vector
-   location with pointers to the symbols and a trailing NULL.
-
-   Return number of symbols read.   */
-
-static long
-vms_canonicalize_symtab (bfd * abfd, asymbol **symbols)
-{
-  vms_debug2 ((1, "vms_canonicalize_symtab (%p, <ret>)\n", abfd));
-
-  /* Init counter.  */
-  copy_symbols (NULL, abfd);
-
-  /* Traverse table and fill symbols vector.  */
-  PRIV (symcache) = symbols;
-  bfd_hash_traverse (PRIV (vms_symbol_table), copy_symbols, abfd);
-
-  symbols[PRIV (gsd_sym_count)] = NULL;
-
-  return PRIV (gsd_sym_count);
-}
-
-/* Print symbol to file according to how. how is one of
-   bfd_print_symbol_name	just print the name
-   bfd_print_symbol_more	print more (???)
-   bfd_print_symbol_all	print all we know, which is not much right now :-).  */
-
-static void
-vms_print_symbol (bfd * abfd,
-		  void * file,
-		  asymbol *symbol,
-		  bfd_print_symbol_type how)
-{
-  vms_debug2 ((1, "vms_print_symbol (%p, %p, %p, %d)\n",
-               abfd, file, symbol, how));
-
-  switch (how)
-    {
-      case bfd_print_symbol_name:
-      case bfd_print_symbol_more:
-	fprintf ((FILE *)file," %s", symbol->name);
-      break;
-
-      case bfd_print_symbol_all:
-	{
-	  const char *section_name = symbol->section->name;
-
-	  bfd_print_symbol_vandf (abfd, file, symbol);
-
-	  fprintf ((FILE *) file," %-8s %s", section_name, symbol->name);
-        }
-      break;
-    }
-}
-
-/* Return information about symbol in ret.
-
-   fill type, value and name
-   type:
-	A	absolute
-	B	bss segment symbol
-	C	common symbol
-	D	data segment symbol
-	f	filename
-	t	a static function symbol
-	T	text segment symbol
-	U	undefined
-	-	debug.  */
-
-static void
-vms_get_symbol_info (bfd * abfd ATTRIBUTE_UNUSED,
-		     asymbol *symbol,
-		     symbol_info *ret)
-{
-  asection *sec;
-
-  vms_debug2 ((1, "vms_get_symbol_info (%p, %p, %p)\n", abfd, symbol, ret));
-
-  sec = symbol->section;
-
-  if (ret == NULL)
-    return;
-
-  if (sec == 0)
-    ret->type = 'U';
-  else if (bfd_is_com_section (sec))
-    ret->type = 'C';
-  else if (bfd_is_abs_section (sec))
-    ret->type = 'A';
-  else if (bfd_is_und_section (sec))
-    ret->type = 'U';
-  else if (bfd_is_ind_section (sec))
-    ret->type = 'I';
-  else if (bfd_get_section_flags (abfd, sec) & SEC_CODE)
-    ret->type = 'T';
-  else if (bfd_get_section_flags (abfd, sec) & SEC_DATA)
-    ret->type = 'D';
-  else if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
-    ret->type = 'B';
-  else
-    ret->type = '-';
-
-  if (ret->type != 'U')
-    ret->value = symbol->value + symbol->section->vma;
-  else
-    ret->value = 0;
-  ret->name = symbol->name;
-}
-
-/* Return TRUE if the given symbol sym in the BFD abfd is
-   a compiler generated local label, else return FALSE.  */
-
-static bfd_boolean
-vms_bfd_is_local_label_name (bfd * abfd ATTRIBUTE_UNUSED,
-			     const char *name)
-{
-  vms_debug2 ((1, "vms_bfd_is_local_label_name (%p, %s)\n", abfd, name));
-  return name[0] == '$';
-}
-
-/* Provided a BFD, a section and an offset into the section, calculate and
-   return the name of the source file and the line nearest to the wanted
-   location.  */
-
-static bfd_boolean
-vms_find_nearest_line (bfd * abfd ATTRIBUTE_UNUSED,
-		       asection *section ATTRIBUTE_UNUSED,
-		       asymbol **symbols ATTRIBUTE_UNUSED,
-		       bfd_vma offset ATTRIBUTE_UNUSED,
-		       const char **file ATTRIBUTE_UNUSED,
-		       const char **func ATTRIBUTE_UNUSED,
-		       unsigned int *line ATTRIBUTE_UNUSED)
-{
-  vms_debug2 ((1, "vms_find_nearest_line (%p, %s, %p, %ld, ...)\n",
-               abfd, section->name, symbols, (long int)offset));
-  return _bfd_vms_find_nearest_dst_line (abfd, section, symbols, offset, file, func, line);
-}
-
-/* Part 4.6, relocations.  */
-
-/* Allocate the reloc buffer for the specified section.  */
-
-static void
-alloc_reloc_stream (bfd *abfd ATTRIBUTE_UNUSED, asection *section,
-		    void *alloc_error)
-{
-  unsigned char *ptr;
-
-  /* If there were no relocations, there is nothing to do.  */
-  if (section->reloc_count == 0)
-    return;
-
-  ptr = bfd_malloc (vms_section_data (section)->reloc_size);
-  if (ptr == NULL)
-    {
-      *(bfd_boolean *)alloc_error = TRUE;
-      return;
-    }
-
-  vms_section_data (section)->reloc_stream = ptr;
-}
-
-/* Read in the relocs for the specified section and internalize them.
-
-   The implementation is loosely based on the SOM code and made up
-   of 3 distinct phases:
-
-   1. When the VMS object is opened and parsed, the number and the size
-      of the relocations are computed for all sections.  This makes it
-      possible to know upfront both which sections have no relocs and
-      the size of the reloc buffers for the other sections, at virtually
-      no cost for consumers that don't care about relocs at all.
-
-   2. When vms_slurp_reloc_table is invoked for the first time on a section
-      with relocs, the object is traversed and all the reloc information
-      is saved in per-section reloc buffers.  It would be very inefficient
-      to scan the whole file on each invocation, so we slurp for all the
-      sections at once.
-
-   3. On subsequent invocations of vms_slurp_reloc_table, the relocs for the
-      specified section are fetched from the buffer, decoded and internalized.
-      The buffer is then freed since the internalized relocs are attached to
-      the section, turning additional invocations of vms_slurp_reloc_table
-      on the same section into no-ops.
-
-   Since VMS objects have very few sections, it could be profitable to merge
-   phase #2 and phase #3, i.e. to decode and internalize the relocs for all
-   the sections at once.  The current implementation is more elegant.  */
-
-static bfd_boolean
-vms_slurp_reloc_table (bfd *abfd, asection *section, asymbol **symbols)
-{
-  arelent *internal_relocs;
-  bfd_size_type amt;
-  int err;
-
-  /* If there were no relocations, there is nothing to do.  */
-  if (section->reloc_count == 0)
-    return TRUE;
-
-  /* Return saved information about the relocations if it is available.  */
-  if (section->relocation != NULL)
-    return TRUE;
-
-  /* If the relocation stream has not been slurped, do it now.  */
-  if (vms_section_data (section)->reloc_stream == NULL)
-    {
-      bfd_boolean alloc_error = FALSE;
-      int type;
-
-      /* Size the reloc buffer for each section.  */
-      bfd_map_over_sections (abfd, alloc_reloc_stream, &alloc_error);
-      if (alloc_error)
-	return FALSE;
-
-      if (bfd_seek (abfd, 0, SEEK_SET) != 0)
-	return FALSE;
-
-      /* Reset section pointer.  */
-      PRIV (image_section) = NULL;
-
-      do
-	{
-	  type = _bfd_vms_get_object_record (abfd);
-	  if (type != EOBJ_S_C_ETIR
-	      && type != EOBJ_S_C_EDBG
-	      && type != EOBJ_S_C_ETBT)
-	    continue;
-	  err = _bfd_vms_slurp_relocs (abfd);
-	  if (err != 0)
-	    {
-	      vms_debug2 ((2, "slurp relocs failed with %d\n", err));
-	      return FALSE;
-	    }
-	}
-      while (type != EOBJ_S_C_EEOM);
-    }
-
-  amt = section->reloc_count * sizeof (arelent);
-  internal_relocs = (arelent *) bfd_zalloc (abfd, amt);
-  if (internal_relocs == NULL)
-    return FALSE;
-
-  /* Decode and internalize the relocations.  */
-  err = _bfd_vms_decode_relocs (abfd, internal_relocs, section, symbols);
-  if (err != 0)
-    {
-      vms_debug2 ((2, "decode relocs failed with %d\n", err));
-      return FALSE;
-    }
-
-  /* We're done with the external relocations.  Free them.  */
-  free (vms_section_data (section)->reloc_stream);
-  vms_section_data (section)->reloc_stream = NULL;
-
-  /* Save our results and return success.  */
-  section->relocation = internal_relocs;
-  return TRUE;
-}
-
-/* Return the number of bytes required to store the relocation
-   information associated with the given section.  */
-
-static long
-vms_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED, asection *section)
-{
-  return (section->reloc_count + 1) * sizeof (arelent *);
-}
-
-/* Convert relocations from VMS (external) form into BFD internal
-   form.  Return the number of relocations.  */
-
-static long
-vms_canonicalize_reloc (bfd *abfd, asection *section, arelent **relptr,
-			asymbol **symbols)
-{
-  arelent *tblptr;
-  int count;
-
-  if (! vms_slurp_reloc_table (abfd, section, symbols))
-    return -1;
-
-  count = section->reloc_count;
-  tblptr = section->relocation;
-
-  while (count--)
-    *relptr++ = tblptr++;
-
-  *relptr = (arelent *) NULL;
-  return section->reloc_count;
-}
-
-/* This is just copied from ecoff-alpha, needs to be fixed probably.  */
-
-/* How to process the various reloc types.  */
-
-static bfd_reloc_status_type
-reloc_nil (bfd * abfd ATTRIBUTE_UNUSED,
-	   arelent *reloc ATTRIBUTE_UNUSED,
-	   asymbol *sym ATTRIBUTE_UNUSED,
-	   void * data ATTRIBUTE_UNUSED,
-	   asection *sec ATTRIBUTE_UNUSED,
-	   bfd *output_bfd ATTRIBUTE_UNUSED,
-	   char **error_message ATTRIBUTE_UNUSED)
-{
-#if VMS_DEBUG
-  vms_debug (1, "reloc_nil (abfd %p, output_bfd %p)\n", abfd, output_bfd);
-  vms_debug (2, "In section %s, symbol %s\n",
-	sec->name, sym->name);
-  vms_debug (2, "reloc sym %s, addr %08lx, addend %08lx, reloc is a %s\n",
-		reloc->sym_ptr_ptr[0]->name,
-		(unsigned long)reloc->address,
-		(unsigned long)reloc->addend, reloc->howto->name);
-  vms_debug (2, "data at %p\n", data);
-  /*  _bfd_hexdump (2, data, bfd_get_reloc_size (reloc->howto), 0); */
-#endif
-
-  return bfd_reloc_ok;
-}
-
-/* In case we're on a 32-bit machine, construct a 64-bit "-1" value
-   from smaller values.  Start with zero, widen, *then* decrement.  */
-#define MINUS_ONE	(((bfd_vma)0) - 1)
-
-static reloc_howto_type alpha_howto_table[] =
-{
-  HOWTO (ALPHA_R_IGNORE,	/* Type.  */
-	 0,			/* Rightshift.  */
-	 0,			/* Size (0 = byte, 1 = short, 2 = long).  */
-	 8,			/* Bitsize.  */
-	 TRUE,			/* PC relative.  */
-	 0,			/* Bitpos.  */
-	 complain_overflow_dont,/* Complain_on_overflow.  */
-	 reloc_nil,		/* Special_function.  */
-	 "IGNORE",		/* Name.  */
-	 TRUE,			/* Partial_inplace.  */
-	 0,			/* Source mask */
-	 0,			/* Dest mask.  */
-	 TRUE),			/* PC rel offset.  */
-
-  /* A 64 bit reference to a symbol.  */
-  HOWTO (ALPHA_R_REFQUAD,	/* Type.  */
-	 0,			/* Rightshift.  */
-	 4,			/* Size (0 = byte, 1 = short, 2 = long).  */
-	 64,			/* Bitsize.  */
-	 FALSE,			/* PC relative.  */
-	 0,			/* Bitpos.  */
-	 complain_overflow_bitfield, /* Complain_on_overflow.  */
-	 reloc_nil,		/* Special_function.  */
-	 "REFQUAD",		/* Name.  */
-	 TRUE,			/* Partial_inplace.  */
-	 MINUS_ONE,		/* Source mask.  */
-	 MINUS_ONE,		/* Dest mask.  */
-	 FALSE),		/* PC rel offset.  */
-
-  /* A 21 bit branch.  The native assembler generates these for
-     branches within the text segment, and also fills in the PC
-     relative offset in the instruction.  */
-  HOWTO (ALPHA_R_BRADDR,	/* Type.  */
-	 2,			/* Rightshift.  */
-	 2,			/* Size (0 = byte, 1 = short, 2 = long).  */
-	 21,			/* Bitsize.  */
-	 TRUE,			/* PC relative.  */
-	 0,			/* Bitpos.  */
-	 complain_overflow_signed, /* Complain_on_overflow.  */
-	 reloc_nil,		/* Special_function.  */
-	 "BRADDR",		/* Name.  */
-	 TRUE,			/* Partial_inplace.  */
-	 0x1fffff,		/* Source mask.  */
-	 0x1fffff,		/* Dest mask.  */
-	 FALSE),		/* PC rel offset.  */
-
-  /* A hint for a jump to a register.  */
-  HOWTO (ALPHA_R_HINT,		/* Type.  */
-	 2,			/* Rightshift.  */
-	 1,			/* Size (0 = byte, 1 = short, 2 = long).  */
-	 14,			/* Bitsize.  */
-	 TRUE,			/* PC relative.  */
-	 0,			/* Bitpos.  */
-	 complain_overflow_dont,/* Complain_on_overflow.  */
-	 reloc_nil,		/* Special_function.  */
-	 "HINT",		/* Name.  */
-	 TRUE,			/* Partial_inplace.  */
-	 0x3fff,		/* Source mask.  */
-	 0x3fff,		/* Dest mask.  */
-	 FALSE),		/* PC rel offset.  */
-
-  /* 16 bit PC relative offset.  */
-  HOWTO (ALPHA_R_SREL16,	/* Type.  */
-	 0,			/* Rightshift.  */
-	 1,			/* Size (0 = byte, 1 = short, 2 = long).  */
-	 16,			/* Bitsize.  */
-	 TRUE,			/* PC relative.  */
-	 0,			/* Bitpos.  */
-	 complain_overflow_signed, /* Complain_on_overflow.  */
-	 reloc_nil,		/* Special_function.  */
-	 "SREL16",		/* Name.  */
-	 TRUE,			/* Partial_inplace.  */
-	 0xffff,		/* Source mask.  */
-	 0xffff,		/* Dest mask.  */
-	 FALSE),		/* PC rel offset.  */
-
-  /* 32 bit PC relative offset.  */
-  HOWTO (ALPHA_R_SREL32,	/* Type.  */
-	 0,			/* Rightshift.  */
-	 2,			/* Size (0 = byte, 1 = short, 2 = long).  */
-	 32,			/* Bitsize.  */
-	 TRUE,			/* PC relative.  */
-	 0,			/* Bitpos.  */
-	 complain_overflow_signed, /* Complain_on_overflow.  */
-	 reloc_nil,		/* Special_function.  */
-	 "SREL32",		/* Name.  */
-	 TRUE,			/* Partial_inplace.  */
-	 0xffffffff,		/* Source mask.  */
-	 0xffffffff,		/* Dest mask.  */
-	 FALSE),		/* PC rel offset.  */
-
-  /* A 64 bit PC relative offset.  */
-  HOWTO (ALPHA_R_SREL64,	/* Type.  */
-	 0,			/* Rightshift.  */
-	 4,			/* Size (0 = byte, 1 = short, 2 = long).  */
-	 64,			/* Bitsize.  */
-	 TRUE,			/* PC relative.  */
-	 0,			/* Bitpos.  */
-	 complain_overflow_signed, /* Complain_on_overflow.  */
-	 reloc_nil,		/* Special_function.  */
-	 "SREL64",		/* Name.  */
-	 TRUE,			/* Partial_inplace.  */
-	 MINUS_ONE,		/* Source mask.  */
-	 MINUS_ONE,		/* Dest mask.  */
-	 FALSE),		/* PC rel offset.  */
-
-  /* Push a value on the reloc evaluation stack.  */
-  HOWTO (ALPHA_R_OP_PUSH,	/* Type.  */
-	 0,			/* Rightshift.  */
-	 0,			/* Size (0 = byte, 1 = short, 2 = long).  */
-	 0,			/* Bitsize.  */
-	 FALSE,			/* PC relative.  */
-	 0,			/* Bitpos.  */
-	 complain_overflow_dont,/* Complain_on_overflow.  */
-	 reloc_nil,		/* Special_function.  */
-	 "OP_PUSH",		/* Name.  */
-	 FALSE,			/* Partial_inplace.  */
-	 0,			/* Source mask.  */
-	 0,			/* Dest mask.  */
-	 FALSE),		/* PC rel offset.  */
-
-  /* Store the value from the stack at the given address.  Store it in
-     a bitfield of size r_size starting at bit position r_offset.  */
-  HOWTO (ALPHA_R_OP_STORE,	/* Type.  */
-	 0,			/* Rightshift.  */
-	 4,			/* Size (0 = byte, 1 = short, 2 = long).  */
-	 64,			/* Bitsize.  */
-	 FALSE,			/* PC relative.  */
-	 0,			/* Bitpos.  */
-	 complain_overflow_dont,/* Complain_on_overflow.  */
-	 reloc_nil,		/* Special_function.  */
-	 "OP_STORE",		/* Name.  */
-	 FALSE,			/* Partial_inplace.  */
-	 0,			/* Source mask.  */
-	 MINUS_ONE,		/* Dest mask.  */
-	 FALSE),		/* PC rel offset.  */
-
-  /* Subtract the reloc address from the value on the top of the
-     relocation stack.  */
-  HOWTO (ALPHA_R_OP_PSUB,	/* Type.  */
-	 0,			/* Rightshift.  */
-	 0,			/* Size (0 = byte, 1 = short, 2 = long).  */
-	 0,			/* Bitsize.  */
-	 FALSE,			/* PC relative.  */
-	 0,			/* Bitpos.  */
-	 complain_overflow_dont,/* Complain_on_overflow.  */
-	 reloc_nil,		/* Special_function.  */
-	 "OP_PSUB",		/* Name.  */
-	 FALSE,			/* Partial_inplace.  */
-	 0,			/* Source mask.  */
-	 0,			/* Dest mask.  */
-	 FALSE),		/* PC rel offset.  */
-
-  /* Shift the value on the top of the relocation stack right by the
-     given value.  */
-  HOWTO (ALPHA_R_OP_PRSHIFT,	/* Type.  */
-	 0,			/* Rightshift.  */
-	 0,			/* Size (0 = byte, 1 = short, 2 = long).  */
-	 0,			/* Bitsize.  */
-	 FALSE,			/* PC relative.  */
-	 0,			/* Bitpos.  */
-	 complain_overflow_dont,/* Complain_on_overflow.  */
-	 reloc_nil,		/* Special_function.  */
-	 "OP_PRSHIFT",		/* Name.  */
-	 FALSE,			/* Partial_inplace.  */
-	 0,			/* Source mask.  */
-	 0,			/* Dest mask.  */
-	 FALSE),		/* PC rel offset.  */
-
-  /* Hack. Linkage is done by linker.  */
-  HOWTO (ALPHA_R_LINKAGE,	/* Type.  */
-	 0,			/* Rightshift.  */
-	 8,			/* Size (0 = byte, 1 = short, 2 = long).  */
-	 256,			/* Bitsize.  */
-	 FALSE,			/* PC relative.  */
-	 0,			/* Bitpos.  */
-	 complain_overflow_dont,/* Complain_on_overflow.  */
-	 reloc_nil,		/* Special_function.  */
-	 "LINKAGE",		/* Name.  */
-	 FALSE,			/* Partial_inplace.  */
-	 0,			/* Source mask.  */
-	 0,			/* Dest mask.  */
-	 FALSE),		/* PC rel offset.  */
-
-  /* A 32 bit reference to a symbol.  */
-  HOWTO (ALPHA_R_REFLONG,	/* Type.  */
-	 0,			/* Rightshift.  */
-	 2,			/* Size (0 = byte, 1 = short, 2 = long).  */
-	 32,			/* Bitsize.  */
-	 FALSE,			/* PC relative.  */
-	 0,			/* Bitpos.  */
-	 complain_overflow_bitfield, /* Complain_on_overflow.  */
-	 reloc_nil,		/* Special_function.  */
-	 "REFLONG",		/* Name.  */
-	 TRUE,			/* Partial_inplace.  */
-	 0xffffffff,		/* Source mask.  */
-	 0xffffffff,		/* Dest mask.  */
-	 FALSE),		/* PC rel offset.  */
-
-  /* A 64 bit reference to a procedure, written as 32 bit value.  */
-  HOWTO (ALPHA_R_CODEADDR,	/* Type.  */
-	 0,			/* Rightshift.  */
-	 4,			/* Size (0 = byte, 1 = short, 2 = long).  */
-	 64,			/* Bitsize.  */
-	 FALSE,			/* PC relative.  */
-	 0,			/* Bitpos.  */
-	 complain_overflow_signed,/* Complain_on_overflow.  */
-	 reloc_nil,		/* Special_function.  */
-	 "CODEADDR",		/* Name.  */
-	 FALSE,			/* Partial_inplace.  */
-	 0xffffffff,		/* Source mask.  */
-	 0xffffffff,		/* Dest mask.  */
-	 FALSE),		/* PC rel offset.  */
-
-  HOWTO (ALPHA_R_NOP,		/* Type.  */
-	 0,			/* Rightshift.  */
-	 3,			/* Size (0 = byte, 1 = short, 2 = long).  */
-	 0,			/* Bitsize.  */
-	 /* The following value must match that of ALPHA_R_BSR/ALPHA_R_BOH
-	    because the calculations for the 3 relocations are the same.
-	    See B.4.5.2 of the OpenVMS Linker Utility Manual.  */
-	 TRUE,			/* PC relative.  */
-	 0,			/* Bitpos.   */
-	 complain_overflow_dont,/* Complain_on_overflow.  */
-	 reloc_nil,		/* Special_function.  */
-	 "NOP",			/* Name.  */
-	 FALSE,			/* Partial_inplace.  */
-	 0xffffffff,		/* Source mask.  */
-	 0xffffffff,		/* Dest mask.  */
-	 FALSE),		/* PC rel offset.  */
-
-  HOWTO (ALPHA_R_BSR,		/* Type.  */
-	 0,			/* Rightshift.  */
-	 3,			/* Size (0 = byte, 1 = short, 2 = long).  */
-	 0,			/* Bitsize.  */
-	 TRUE,			/* PC relative.  */
-	 0,			/* Bitpos.  */
-	 complain_overflow_dont,/* Complain_on_overflow.  */
-	 reloc_nil,		/* Special_function.  */
-	 "BSR",			/* Name.  */
-	 FALSE,			/* Partial_inplace.  */
-	 0xffffffff,		/* Source mask.  */
-	 0xffffffff,		/* Dest mask.  */
-	 FALSE),		/* PC rel offset.  */
-
-  HOWTO (ALPHA_R_LDA,		/* Type.  */
-	 0,			/* Rightshift.  */
-	 3,			/* Size (0 = byte, 1 = short, 2 = long).  */
-	 0,			/* Bitsize.  */
-	 FALSE,			/* PC relative.  */
-	 0,			/* Bitpos.  */
-	 complain_overflow_dont,/* Complain_on_overflow.  */
-	 reloc_nil,		/* Special_function.  */
-	 "LDA",			/* Name.  */
-	 FALSE,			/* Partial_inplace.  */
-	 0xffffffff,		/* Source mask.  */
-	 0xffffffff,		/* Dest mask.  */
-	 FALSE),		/* PC rel offset.  */
-
-  HOWTO (ALPHA_R_BOH,		/* Type.  */
-	 0,			/* Rightshift.  */
-	 3,			/* Size (0 = byte, 1 = short, 2 = long, 3 = nil).  */
-	 0,			/* Bitsize.  */
-	 TRUE,			/* PC relative.  */
-	 0,			/* Bitpos.  */
-	 complain_overflow_dont,/* Complain_on_overflow.  */
-	 reloc_nil,		/* Special_function.  */
-	 "BOH",			/* Name.  */
-	 FALSE,			/* Partial_inplace.  */
-	 0xffffffff,		/* Source mask.  */
-	 0xffffffff,		/* Dest mask.  */
-	 FALSE),		/* PC rel offset.  */
-};
-
-/* Return a pointer to a howto structure which, when invoked, will perform
-   the relocation code on data from the architecture noted.  */
-
-static const struct reloc_howto_struct *
-vms_bfd_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
-			   bfd_reloc_code_real_type code)
-{
-  int alpha_type;
-
-  vms_debug2 ((1, "vms_bfd_reloc_type_lookup (%p, %d)\t", abfd, code));
-
-  switch (code)
-    {
-      case BFD_RELOC_16:		alpha_type = ALPHA_R_SREL16;	break;
-      case BFD_RELOC_32:		alpha_type = ALPHA_R_REFLONG;	break;
-      case BFD_RELOC_64:		alpha_type = ALPHA_R_REFQUAD;	break;
-      case BFD_RELOC_CTOR:		alpha_type = ALPHA_R_REFQUAD;	break;
-      case BFD_RELOC_23_PCREL_S2:	alpha_type = ALPHA_R_BRADDR;	break;
-      case BFD_RELOC_ALPHA_HINT:	alpha_type = ALPHA_R_HINT;	break;
-      case BFD_RELOC_16_PCREL:		alpha_type = ALPHA_R_SREL16;	break;
-      case BFD_RELOC_32_PCREL:		alpha_type = ALPHA_R_SREL32;	break;
-      case BFD_RELOC_64_PCREL:		alpha_type = ALPHA_R_SREL64;	break;
-      case BFD_RELOC_ALPHA_LINKAGE:	alpha_type = ALPHA_R_LINKAGE;	break;
-      case BFD_RELOC_ALPHA_CODEADDR:	alpha_type = ALPHA_R_CODEADDR;	break;
-      case BFD_RELOC_ALPHA_NOP:		alpha_type = ALPHA_R_NOP;	break;
-      case BFD_RELOC_ALPHA_BSR:		alpha_type = ALPHA_R_BSR;	break;
-      case BFD_RELOC_ALPHA_LDA:		alpha_type = ALPHA_R_LDA;	break;
-      case BFD_RELOC_ALPHA_BOH:		alpha_type = ALPHA_R_BOH;	break;
-      default:
-	(*_bfd_error_handler) ("reloc (%d) is *UNKNOWN*", code);
-	return NULL;
-    }
-  vms_debug2 ((2, "reloc is %s\n", alpha_howto_table[alpha_type].name));
-  return & alpha_howto_table[alpha_type];
-}
-
-static reloc_howto_type *
-vms_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
-			   const char *r_name)
-{
-  unsigned int i;
-
-  for (i = 0;
-       i < sizeof (alpha_howto_table) / sizeof (alpha_howto_table[0]);
-       i++)
-    if (alpha_howto_table[i].name != NULL
-	&& strcasecmp (alpha_howto_table[i].name, r_name) == 0)
-      return &alpha_howto_table[i];
-
-  return NULL;
-}
-
-/* Part 4.7, writing an object file.  */
-
-/* Set the architecture and machine type in BFD abfd to arch and mach.
-   Find the correct pointer to a structure and insert it into the arch_info
-   pointer.  */
-
-static bfd_boolean
-vms_set_arch_mach (bfd * abfd,
-		   enum bfd_architecture arch ATTRIBUTE_UNUSED,
-		   unsigned long mach ATTRIBUTE_UNUSED)
-{
-  vms_debug2 ((1, "vms_set_arch_mach (%p, %d, %ld)\n", abfd, arch, mach));
-
-  if (arch != bfd_arch_alpha
-      && arch != bfd_arch_vax
-      && arch != bfd_arch_unknown)
-    return FALSE;
-
-  return bfd_default_set_arch_mach (abfd, arch, mach);
-}
-
-/* Sets the contents of the section section in BFD abfd to the data starting
-   in memory at LOCATION. The data is written to the output section starting
-   at offset offset for count bytes.
-
-   Normally TRUE is returned, else FALSE. Possible error returns are:
-   o bfd_error_no_contents - The output section does not have the
-	SEC_HAS_CONTENTS attribute, so nothing can be written to it.
-   o and some more too  */
-
-static bfd_boolean
-vms_set_section_contents (bfd * abfd,
-			  asection *section,
-			  const void * location,
-			  file_ptr offset,
-			  bfd_size_type count)
-{
-#if VMS_DEBUG
-  vms_debug (1, "vms_set_section_contents (%p, sec %s, loc %p, off %ld, count %d)\n",
-	     abfd, section->name, location, (long int)offset, (int)count);
-  vms_debug (2, "size %d\n", (int) section->size);
-#endif
-  if (count == (bfd_size_type)0)
-    return TRUE;
-
-  if (section->contents == NULL)
-    section->contents = bfd_alloc (abfd, section->size);
-  if (section->contents == NULL)
-    return FALSE;
-
-  memcpy (section->contents + offset, location, (size_t) count);
-  return TRUE;
-}
-
-static bfd_boolean
-vms_bfd_print_private_bfd_data (bfd *abfd, void *ptr)
-{
-  FILE *file = (FILE *)ptr;
-
-  fprintf (file, _("structure level: %d\n"), PRIV(hdr_data.hdr_b_strlvl));
-  fprintf (file, _("module name    : %s\n"), PRIV(hdr_data.hdr_t_name));
-  fprintf (file, _("module version : %s\n"), PRIV(hdr_data.hdr_t_version));
-  fprintf (file, _("module date    : %s\n"), PRIV(hdr_data.hdr_t_date));
-  fprintf (file, _("language name  : %s\n"), PRIV(hdr_data.hdr_c_lnm));
-  fprintf (file, _("source files   : %s\n"), PRIV(hdr_data.hdr_c_src));
-  fprintf (file, _("title          : %s\n"), PRIV(hdr_data.hdr_c_ttl));
-
-  return TRUE;
-}
-
-const bfd_target vms_alpha_vec =
-{
-  "vms-alpha",			/* Name.  */
-  bfd_target_evax_flavour,
-  BFD_ENDIAN_LITTLE,		/* Data byte order is little.  */
-  BFD_ENDIAN_LITTLE,		/* Header byte order is little.  */
-
-  (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS
-   | WP_TEXT | D_PAGED),	/* Object flags.  */
-  (SEC_ALLOC | SEC_LOAD | SEC_RELOC
-   | SEC_READONLY | SEC_CODE | SEC_DATA
-   | SEC_HAS_CONTENTS | SEC_IN_MEMORY),		/* Sect flags.  */
-  0,				/* symbol_leading_char.  */
-  ' ',				/* ar_pad_char.  */
-  15,				/* ar_max_namelen.  */
-  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
-  bfd_getl32, bfd_getl_signed_32, bfd_putl32,
-  bfd_getl16, bfd_getl_signed_16, bfd_putl16,
-  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
-  bfd_getl32, bfd_getl_signed_32, bfd_putl32,
-  bfd_getl16, bfd_getl_signed_16, bfd_putl16,
-
-  {_bfd_dummy_target, vms_object_p,		/* bfd_check_format.  */
-   _bfd_vms_lib_alpha_archive_p, _bfd_dummy_target},
-  {bfd_false, vms_mkobject,			/* bfd_set_format.  */
-   _bfd_vms_lib_mkarchive, bfd_false},
-  {bfd_false, vms_write_object_contents,	/* bfd_write_contents.  */
-   _bfd_vms_lib_write_archive_contents, bfd_false},
-
-  BFD_JUMP_TABLE_GENERIC (vms),
-  BFD_JUMP_TABLE_COPY (vms),
-  BFD_JUMP_TABLE_CORE (_bfd_nocore),
-  BFD_JUMP_TABLE_ARCHIVE (_bfd_vms_lib),
-  BFD_JUMP_TABLE_SYMBOLS (vms),
-  BFD_JUMP_TABLE_RELOCS (vms),
-  BFD_JUMP_TABLE_WRITE (vms),
-  BFD_JUMP_TABLE_LINK (_bfd_nolink),
-  BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
-
-  NULL,
-
-  (PTR) 0
-};
-
-const bfd_target vms_vax_vec =
-{
-  "vms-vax",			/* Name.  */
-  bfd_target_ovax_flavour,
-  BFD_ENDIAN_LITTLE,		/* Data byte order is little.  */
-  BFD_ENDIAN_LITTLE,		/* Header byte order is little.  */
-
-  (HAS_RELOC | HAS_SYMS 	/* Object flags.  */
-   | WP_TEXT | D_PAGED
-   | HAS_LINENO | HAS_DEBUG | HAS_LOCALS),
-
-  (SEC_ALLOC | SEC_LOAD | SEC_RELOC
-   | SEC_READONLY | SEC_CODE | SEC_DATA
-   | SEC_HAS_CONTENTS | SEC_IN_MEMORY),		/* Sect flags.  */
-  0,				/* symbol_leading_char */
-  ' ',				/* ar_pad_char */
-  15,				/* ar_max_namelen */
-  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
-  bfd_getl32, bfd_getl_signed_32, bfd_putl32,
-  bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Data.  */
-  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
-  bfd_getl32, bfd_getl_signed_32, bfd_putl32,
-  bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Hdrs.  */
-
-  {_bfd_dummy_target, vms_object_p,		/* bfd_check_format.  */
-   _bfd_dummy_target, _bfd_dummy_target},
-  {bfd_false, vms_mkobject,			/* bfd_set_format.  */
-   bfd_false, bfd_false},
-  {bfd_false, vms_write_object_contents,	/* bfd_write_contents.  */
-   bfd_false, bfd_false},
-
-  BFD_JUMP_TABLE_GENERIC (vms),
-  BFD_JUMP_TABLE_COPY (vms),
-  BFD_JUMP_TABLE_CORE (_bfd_nocore),
-  BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
-  BFD_JUMP_TABLE_SYMBOLS (vms),
-  BFD_JUMP_TABLE_RELOCS (vms),
-  BFD_JUMP_TABLE_WRITE (vms),
-  BFD_JUMP_TABLE_LINK (_bfd_nolink),
-  BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
-
-  NULL,
-
-  (PTR) 0
-};
diff --git a/bfd/vms.h b/bfd/vms.h
index a40e85e..4a3e1d0 100644
--- a/bfd/vms.h
+++ b/bfd/vms.h
@@ -23,665 +23,23 @@
    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
    MA 02110-1301, USA.  */
 
-#include <time.h>
-
 #undef vms
 #ifndef VMS_H
 #define VMS_H
 
-/* Constants starting with 'Exxx_' are for openVMS/Alpha (EVAX object
-   language).  */
-
-#define VMS_BLOCK_SIZE  512
-
-/* VMS Text Information and Relocation Records (TIR/ETIR).  */
-
-#define TIR_S_C_STA_GBL		0
-#define TIR_S_C_STA_SB		1
-#define TIR_S_C_STA_SW		2
-#define TIR_S_C_STA_LW		3
-#define TIR_S_C_STA_PB		4
-#define TIR_S_C_STA_PW		5
-#define TIR_S_C_STA_PL		6
-#define TIR_S_C_STA_UB  	7
-#define TIR_S_C_STA_UW  	8
-#define TIR_S_C_STA_BFI 	9
-#define TIR_S_C_STA_WFI 	10
-#define TIR_S_C_STA_LFI 	11
-#define TIR_S_C_STA_EPM 	12
-#define TIR_S_C_STA_CKARG       13
-#define TIR_S_C_STA_WPB 	14
-#define TIR_S_C_STA_WPW 	15
-#define TIR_S_C_STA_WPL 	16
-#define TIR_S_C_STA_LSY 	17
-#define TIR_S_C_STA_LIT 	18
-#define TIR_S_C_STA_LEPM        19
-#define TIR_S_C_MAXSTACOD       19
-#define TIR_S_C_MINSTOCOD       20
-#define TIR_S_C_STO_SB  	20
-#define TIR_S_C_STO_SW  	21
-#define TIR_S_C_STO_L   	22
-#define TIR_S_C_STO_LW  	22
-#define TIR_S_C_STO_BD  	23
-#define TIR_S_C_STO_WD  	24
-#define TIR_S_C_STO_LD  	25
-#define TIR_S_C_STO_LI  	26
-#define TIR_S_C_STO_PIDR        27
-#define TIR_S_C_STO_PICR        28
-#define TIR_S_C_STO_RSB 	29
-#define TIR_S_C_STO_RSW 	30
-#define TIR_S_C_STO_RL  	31
-#define TIR_S_C_STO_VPS 	32
-#define TIR_S_C_STO_USB 	33
-#define TIR_S_C_STO_USW 	34
-#define TIR_S_C_STO_RUB 	35
-#define TIR_S_C_STO_RUW 	36
-#define TIR_S_C_STO_B   	37
-#define TIR_S_C_STO_W   	38
-#define TIR_S_C_STO_RB  	39
-#define TIR_S_C_STO_RW  	40
-#define TIR_S_C_STO_RIVB        41
-#define TIR_S_C_STO_PIRR        42
-#define TIR_S_C_MAXSTOCOD       42
-#define TIR_S_C_MINOPRCOD       50
-#define TIR_S_C_OPR_NOP 	50
-#define TIR_S_C_OPR_ADD 	51
-#define TIR_S_C_OPR_SUB 	52
-#define TIR_S_C_OPR_MUL 	53
-#define TIR_S_C_OPR_DIV 	54
-#define TIR_S_C_OPR_AND 	55
-#define TIR_S_C_OPR_IOR 	56
-#define TIR_S_C_OPR_EOR 	57
-#define TIR_S_C_OPR_NEG 	58
-#define TIR_S_C_OPR_COM 	59
-#define TIR_S_C_OPR_INSV        60
-#define TIR_S_C_OPR_ASH 	61
-#define TIR_S_C_OPR_USH 	62
-#define TIR_S_C_OPR_ROT 	63
-#define TIR_S_C_OPR_SEL 	64
-#define TIR_S_C_OPR_REDEF       65
-#define TIR_S_C_OPR_DFLIT       66
-#define TIR_S_C_MAXOPRCOD       66
-#define TIR_S_C_MINCTLCOD       80
-#define TIR_S_C_CTL_SETRB       80
-#define TIR_S_C_CTL_AUGRB       81
-#define TIR_S_C_CTL_DFLOC       82
-#define TIR_S_C_CTL_STLOC       83
-#define TIR_S_C_CTL_STKDL       84
-#define TIR_S_C_MAXCTLCOD       84
-
-#define ETIR_S_C_MINSTACOD 0		/* Minimum store code.		*/
-#define ETIR_S_C_STA_GBL 0		/* Stack global symbol value.	*/
-#define ETIR_S_C_STA_LW 1		/* Stack longword.		*/
-#define ETIR_S_C_STA_QW 2		/* Stack quadword.		*/
-#define ETIR_S_C_STA_PQ 3		/* Stack psect base + quadword off.  */
-#define ETIR_S_C_STA_LI 4		/* Stack literal.		*/
-#define ETIR_S_C_STA_MOD 5		/* Stack module.		*/
-#define ETIR_S_C_STA_CKARG 6		/* Check Arguments.		*/
-#define ETIR_S_C_MAXSTACOD 6		/* Maximum stack code.		*/
-#define ETIR_S_C_MINSTOCOD 50		/* Minimum store code.		*/
-#define ETIR_S_C_STO_B 50		/* Store byte.			*/
-#define ETIR_S_C_STO_W 51		/* Store word.			*/
-#define ETIR_S_C_STO_LW 52		/* Store longword.		*/
-#define ETIR_S_C_STO_QW 53		/* Store quadword.		*/
-#define ETIR_S_C_STO_IMMR 54		/* Store immediate Repeated.	*/
-#define ETIR_S_C_STO_GBL 55		/* Store global.		*/
-#define ETIR_S_C_STO_CA 56		/* Store code address.		*/
-#define ETIR_S_C_STO_RB 57		/* Store relative branch.	*/
-#define ETIR_S_C_STO_AB 58		/* Store absolute branch.	*/
-#define ETIR_S_C_STO_OFF 59		/* Store offset within psect.	*/
-#define ETIR_S_C_STO_IMM 61		/* Store immediate.		*/
-#define ETIR_S_C_STO_GBL_LW 62		/* Store global Longword.	*/
-#define ETIR_S_C_STO_LP_PSB 63		/* STO_LP_PSB not valid in level 2 use STC_LP_PSB.  */
-#define ETIR_S_C_STO_HINT_GBL 64	/* Store 14 bit HINT at global address.  */
-#define ETIR_S_C_STO_HINT_PS 65		/* Store 14 bit HINT at psect + offset */
-#define ETIR_S_C_MAXSTOCOD 65		/* Maximum store code.		*/
-#define ETIR_S_C_MINOPRCOD 100		/* Minimum operate code.	*/
-#define ETIR_S_C_OPR_NOP 100		/* No-op.			*/
-#define ETIR_S_C_OPR_ADD 101		/* Add.				*/
-#define ETIR_S_C_OPR_SUB 102		/* Subtract.			*/
-#define ETIR_S_C_OPR_MUL 103		/* Multiply.			*/
-#define ETIR_S_C_OPR_DIV 104		/* Divide.			*/
-#define ETIR_S_C_OPR_AND 105		/* Logical AND.			*/
-#define ETIR_S_C_OPR_IOR 106		/* Logical inclusive OR.	*/
-#define ETIR_S_C_OPR_EOR 107		/* Logical exclusive OR.	*/
-#define ETIR_S_C_OPR_NEG 108		/* Negate.			*/
-#define ETIR_S_C_OPR_COM 109		/* Complement.			*/
-#define ETIR_S_C_OPR_INSV 110		/* Insert bit field.		*/
-#define ETIR_S_C_OPR_ASH 111		/* Arithmetic shift.		*/
-#define ETIR_S_C_OPR_USH 112		/* Unsigned shift.		*/
-#define ETIR_S_C_OPR_ROT 113		/* Rotate.			*/
-#define ETIR_S_C_OPR_SEL 114		/* Select one of three longwords on top of stack.   */
-#define ETIR_S_C_OPR_REDEF 115		/* Redefine this symbol after pass 2.  */
-#define ETIR_S_C_OPR_DFLIT 116		/* Define a literal.		*/
-#define ETIR_S_C_MAXOPRCOD 116		/* Maximum operate code.	*/
-#define ETIR_S_C_MINCTLCOD 150		/* Minimum control code.	*/
-#define ETIR_S_C_CTL_SETRB 150		/* Set relocation base.		*/
-#define ETIR_S_C_CTL_AUGRB 151		/* Augment relocation base.	*/
-#define ETIR_S_C_CTL_DFLOC 152		/* Define debug location.	*/
-#define ETIR_S_C_CTL_STLOC 153		/* Set debug location.		*/
-#define ETIR_S_C_CTL_STKDL 154		/* Stack debug location.	*/
-#define ETIR_S_C_MAXCTLCOD 154		/* Maximum control code.	*/
-#define ETIR_S_C_MINSTCCOD 200		/* Minimum store-conditional code.   */
-#define ETIR_S_C_STC_LP 200		/* Store-conditional Linkage Pair.   */
-#define ETIR_S_C_STC_LP_PSB 201		/* Store-conditional Linkage Pair with Procedure Signature.  */
-#define ETIR_S_C_STC_GBL 202		/* Store-conditional Address at global address.  */
-#define ETIR_S_C_STC_GCA 203		/* Store-conditional Code Address at global address.  */
-#define ETIR_S_C_STC_PS 204		/* Store-conditional Address at psect + offset.  */
-#define ETIR_S_C_STC_NOP_GBL 205	/* Store-conditional NOP at address of global.  */
-#define ETIR_S_C_STC_NOP_PS 206		/* Store-conditional NOP at pect + offset.  */
-#define ETIR_S_C_STC_BSR_GBL 207	/* Store-conditional BSR at global address.  */
-#define ETIR_S_C_STC_BSR_PS 208		/* Store-conditional BSR at pect + offset.  */
-#define ETIR_S_C_STC_LDA_GBL 209	/* Store-conditional LDA at global address.  */
-#define ETIR_S_C_STC_LDA_PS 210		/* Store-conditional LDA at psect + offset.  */
-#define ETIR_S_C_STC_BOH_GBL 211	/* Store-conditional BSR or Hint at global address.  */
-#define ETIR_S_C_STC_BOH_PS 212		/* Store-conditional BSR or Hint at pect + offset.  */
-#define ETIR_S_C_STC_NBH_GBL 213	/* Store-conditional NOP,BSR or HINT at global address.  */
-#define ETIR_S_C_STC_NBH_PS 214		/* Store-conditional NOP,BSR or HINT at psect + offset.  */
-#define ETIR_S_C_MAXSTCCOD 214		/* Maximum store-conditional code.   */
-
-#define ETIR_S_C_HEADER_SIZE 4		/* Size of the header of a command */
-
-/* VMS Global Symbol Directory Records (GSD/EGSD).  */
-
-#define GSD_S_K_ENTRIES 1
-#define GSD_S_C_ENTRIES 1
-#define GSD_S_C_PSC     0
-#define GSD_S_C_SYM     1
-#define GSD_S_C_EPM     2
-#define GSD_S_C_PRO     3
-#define GSD_S_C_SYMW    4
-#define GSD_S_C_EPMW    5
-#define GSD_S_C_PROW    6
-#define GSD_S_C_IDC     7
-#define GSD_S_C_ENV     8
-#define GSD_S_C_LSY     9
-#define GSD_S_C_LEPM    10
-#define GSD_S_C_LPRO    11
-#define GSD_S_C_SPSC    12
-#define GSD_S_C_SYMV    13
-#define GSD_S_C_EPMV    14
-#define GSD_S_C_PROV    15
-#define GSD_S_C_MAXRECTYP       15
-
-#define EGSD_S_K_ENTRIES 2	/* Offset to first entry in record.	*/
-#define EGSD_S_C_ENTRIES 2	/* Offset to first entry in record.	*/
-#define EGSD_S_C_PSC 0		/* Psect definition.			*/
-#define EGSD_S_C_SYM 1		/* Symbol specification.		*/
-#define EGSD_S_C_IDC 2		/* Random entity check.			*/
-#define EGSD_S_C_SPSC 5		/* Shareable image psect definition.	*/
-#define EGSD_S_C_SYMV 6		/* Vectored (dual-valued) versions of SYM.  */
-#define EGSD_S_C_SYMM 7		/* Masked versions of SYM.		*/
-#define EGSD_S_C_SYMG 8		/* EGST - gst version of SYM.		*/
-#define EGSD_S_C_MAXRECTYP 8	/* Maximum entry type defined.		*/
-
-/* Program Section Definition.  */
-#define GPS_S_M_PIC     1
-#define GPS_S_M_LIB     2
-#define GPS_S_M_OVR     4
-#define GPS_S_M_REL     8
-#define GPS_S_M_GBL     16
-#define GPS_S_M_SHR     32
-#define GPS_S_M_EXE     64
-#define GPS_S_M_RD      128
-#define GPS_S_M_WRT     256
-#define GPS_S_M_VEC     512
-#define GPS_S_K_NAME    9
-#define GPS_S_C_NAME    9
-
-#define EGPS_S_B_ALIGN    4
-#define EGPS_S_W_FLAGS    6
-#define EGPS_S_L_ALLOC    8
-#define EGPS_S_B_NAMLNG  12
-
-#define EGPS_S_V_PIC		0x0001
-#define EGPS_S_V_LIB		0x0002
-#define EGPS_S_V_OVR		0x0004
-#define EGPS_S_V_REL		0x0008
-#define EGPS_S_V_GBL		0x0010
-#define EGPS_S_V_SHR		0x0020
-#define EGPS_S_V_EXE		0x0040
-#define EGPS_S_V_RD		0x0080
-#define EGPS_S_V_WRT		0x0100
-#define EGPS_S_V_VEC		0x0200
-#define EGPS_S_V_NOMOD		0x0400
-#define EGPS_S_V_COM		0x0800
-#define EGPS_S_V_ALLOC_64BIT	0x1000
-
-/* Symbol Defintion or Reference.  */
-#define GSY_S_M_WEAK    1
-#define GSY_S_M_DEF     2
-#define GSY_S_M_UNI     4
-#define GSY_S_M_REL     8
-
-#define EGSY_S_W_FLAGS  6
-
-#define EGSY_S_V_WEAK		0x0001
-#define EGSY_S_V_DEF		0x0002
-#define EGSY_S_V_UNI		0x0004
-#define EGSY_S_V_REL		0x0008
-#define EGSY_S_V_COMM		0x0010
-#define EGSY_S_V_VECEP		0x0020
-#define EGSY_S_V_NORM		0x0040
-#define EGSY_S_V_QUAD_VAL	0x0080
-
-#define LSY_S_M_DEF     2
-#define LSY_S_M_REL     8
-
-#define ENV_S_M_DEF     1
-#define ENV_S_M_NESTED  2
-
-/* Symbol Definition.  */
-#define ESDF_S_L_VALUE     8
-#define ESDF_S_L_PSINDX   28
-#define ESDF_S_B_NAMLNG   32
-
-/* Universal Symbol Definition.  */
-#define EGST_S_W_FLAGS    6
-#define EGST_S_Q_LP_1    16
-#define EGST_S_Q_LP_2    24
-#define EGST_S_L_PSINDX  32
-#define EGST_S_B_NAMLNG  36
-
-/* Symbol Reference.  */
-#define ESRF_S_B_NAMLNG   8
-
-/* Debugger symbol definitions:  These are done by hand,
-   as no machine-readable version seems to be available.  */
-#define DST_S_C_C		  7	/* Language == "C".	*/
-#define DST_S_C_CXX		 15	/* Language == "C++".	*/
-#define DST_S_C_EPILOG		127
-#define DST_S_C_VERSION		153
-#define	DST_S_C_SOURCE		155	/* Source file.		*/
-#define DST_S_C_PROLOG		162
-#define	DST_S_C_BLKBEG		176	/* Beginning of block.	*/
-#define	DST_S_C_BLKEND		177	/* End of block.	*/
-#define DST_S_C_ENTRY		181
-#define DST_S_C_PSECT		184
-#define	DST_S_C_LINE_NUM	185	/* Line Number.		*/
-#define DST_S_C_LBLORLIT	186
-#define DST_S_C_LABEL		187
-#define	DST_S_C_MODBEG		188	/* Beginning of module. */
-#define	DST_S_C_MODEND		189	/* End of module.	*/
-#define	DST_S_C_RTNBEG		190	/* Beginning of routine.*/
-#define	DST_S_C_RTNEND		191	/* End of routine.	*/
-
-/* These are used with DST_S_C_LINE_NUM.  */
-#define DST_S_C_LINE_NUM_HEADER_SIZE 4
-
-#define DST_S_C_DELTA_PC_W	 1	/* Incr PC.		*/
-#define DST_S_C_INCR_LINUM	 2	/* Incr Line #.		*/
-#define DST_S_C_INCR_LINUM_W	 3	/* Incr Line #.		*/
-#define DST_S_C_SET_LINUM_INCR	 4
-#define DST_S_C_SET_LINUM_INCR_W 5
-#define DST_S_C_RESET_LINUM_INCR 6
-#define DST_S_C_BEG_STMT_MODE	 7
-#define DST_S_C_END_STMT_MODE	 8
-#define DST_S_C_SET_LINE_NUM	 9	/* Set Line #.		*/
-#define DST_S_C_SET_PC		10
-#define DST_S_C_SET_PC_W	11
-#define DST_S_C_SET_PC_L	12
-#define DST_S_C_SET_STMTNUM	13
-#define DST_S_C_TERM		14	/* End of lines.	*/
-#define DST_S_C_TERM_W		15	/* End of lines.	*/
-#define	DST_S_C_SET_ABS_PC	16	/* Set PC.		*/
-#define	DST_S_C_DELTA_PC_L	17	/* Incr PC.		*/
-#define DST_S_C_INCR_LINUM_L	18	/* Incr Line #.		*/
-#define DST_S_C_SET_LINUM_B	19	/* Set Line #.		*/
-#define DST_S_C_SET_LINUM_L	20	/* Set Line #.		*/
-#define	DST_S_C_TERM_L		21	/* End of lines.	*/
-/* These are used with DST_S_C_SOURCE */
-#define DST_S_C_SRC_DECLFILE	 1	/* Declare source file.  */
-#define DST_S_C_SRC_SETFILE	 2	/* Set source file.	 */
-#define DST_S_C_SRC_SETREC_L	 3	/* Set record, longword value.  */
-#define DST_S_C_SRC_SETREC_W	 4	/* Set record, word value.  */
-#define DST_S_C_SRC_SETLNUM_L	 5	/* Set line, longword value.  */
-#define DST_S_C_SRC_SETLNUM_W	 6	/* Set line, word value.  */
-#define DST_S_C_SRC_INCRLNUM_B	 7	/* Increment line.  */
-#define DST_S_C_SRC_DEFLINES_W	10	/* # of line, word counter.  */
-#define DST_S_C_SRC_DEFLINES_B	11	/* # of line, byte counter.  */
-#define DST_S_C_SRC_FORMFEED	16	/* ^L counts as a record.  */
-
-#define DST_S_B_PCLINE_UNSBYTE	 1
-#define DST_S_W_PCLINE_UNSWORD	 1
-#define DST_S_L_PCLINE_UNSLONG	 1
-
-#define DST_S_B_MODBEG_NAME	14
-#define DST_S_L_RTNBEG_ADDRESS	 5
-#define DST_S_B_RTNBEG_NAME	13
-#define DST_S_L_RTNEND_SIZE	 5
-
-/* These are used with DST_S_C_SOURCE.  */
-#define DST_S_C_SOURCE_HEADER_SIZE 4
-
-#define DST_S_B_SRC_DF_LENGTH	  1
-#define DST_S_W_SRC_DF_FILEID	  3
-#define DST_S_B_SRC_DF_FILENAME	 20
-#define DST_S_B_SRC_UNSBYTE	  1
-#define DST_S_W_SRC_UNSWORD	  1
-#define DST_S_L_SRC_UNSLONG	  1
-
-/* The following are the codes for the various data types.  Anything not on
-   the list is included under 'advanced_type'.  */
-#define DBG_S_C_UCHAR		0x02
-#define DBG_S_C_USINT		0x03
-#define DBG_S_C_ULINT		0x04
-#define DBG_S_C_UQUAD		0x05
-#define DBG_S_C_SCHAR		0x06
-#define DBG_S_C_SSINT		0x07
-#define DBG_S_C_SLINT		0x08
-#define DBG_S_C_SQUAD		0x09
-#define DBG_S_C_REAL4		0x0a
-#define DBG_S_C_REAL8		0x0b	/* D_float double.  */
-#define DBG_S_C_COMPLX4		0x0c	/* 2xF_float complex float.  */
-#define DBG_S_C_COMPLX8		0x0d	/* 2xD_float complex double.  */
-#define DBG_S_C_REAL8_G		0x1b	/* G_float double.  */
-#define DBG_S_C_COMPLX8_G	0x1d	/* 2xG_float complex double.  */
-#define DBG_S_C_FUNCTION_ADDR	0x17
-#define DBG_S_C_ADVANCED_TYPE	0xa3
-/*  Some of these are just for future reference.  [pr].  */
-#define DBG_S_C_UBITA		0x01	/* Unsigned, aligned bit field.  */
-#define DBG_S_C_UBITU		0x22	/* Unsigned, unaligned bit field.  */
-#define DBG_S_C_SBITA		0x29	/* Signed, aligned bit field.  */
-#define DBG_S_C_SBITU		0x2a	/* Signed, unaligned bit field.  */
-#define DBG_S_C_CSTRING		0x2e	/* Asciz ('\0' terminated) string.  */
-#define DBG_S_C_WCHAR		0x38	/* Wchar_t.  */
-/*  These are descriptor class codes.  */
-#define DSC_K_CLASS_S		0x01	/* Static (fixed length).  */
-#define DSC_K_CLASS_D		0x02	/* Dynamic string (not via malloc!).  */
-#define DSC_K_CLASS_A		0x04	/* Array.  */
-#define DSC_K_CLASS_UBS		0x0d	/* Unaligned bit string.  */
-
-/*  These are the codes that are used to generate the definitions of struct
-    union and enum records.  */
-#define DBG_S_C_ENUM_ITEM		0xa4
-#define DBG_S_C_ENUM_START		0xa5
-#define DBG_S_C_ENUM_END		0xa6
-#define DBG_S_C_STRUCT_ITEM		DST_K_VFLAGS_BITOFFS	/* 0xff */
-#define DBG_S_C_STRUCT_START		0xab
-#define DBG_S_C_STRUCT_END		0xac
-#define DST_K_TYPSPEC			0xaf	/* Type specification.  */
-/* These codes are used in the generation of the symbol definition records.  */
-#define DST_K_VFLAGS_NOVAL		0x80	/* Struct definition only.  */
-#define DST_K_VFLAGS_DSC		0xfa	/* Descriptor used.  */
-#define DST_K_VFLAGS_TVS		0xfb	/* Trailing value specified.  */
-#define DST_K_VS_FOLLOWS		0xfd	/* Value spec follows.  */
-#define DST_K_VFLAGS_BITOFFS		0xff	/* Value contains bit offset.  */
-#define DST_K_VALKIND_LITERAL	0
-#define DST_K_VALKIND_ADDR	1
-#define DST_K_VALKIND_DESC	2
-#define DST_K_VALKIND_REG	3
-#define DST_K_REG_VAX_AP	0x0c	/* R12.  */
-#define DST_K_REG_VAX_FP	0x0d	/* R13.  */
-#define DST_K_REG_VAX_SP	0x0e	/* R14.  */
-#define DST_V_VALKIND		0	/* Offset of valkind field.  */
-#define DST_V_INDIRECT		2	/* Offset to indirect bit.  */
-#define DST_V_DISP		3	/* Offset to displacement bit.  */
-#define DST_V_REGNUM		4	/* Offset to register number.  */
-#define DST_M_INDIRECT		(1<<DST_V_INDIRECT)
-#define DST_M_DISP		(1<<DST_V_DISP)
-#define DBG_C_FUNCTION_PARAM	/* 0xc9 */	\
-	(DST_K_VALKIND_ADDR|DST_M_DISP|(DST_K_REG_VAX_AP<<DST_V_REGNUM))
-#define DBG_C_LOCAL_SYM		/* 0xd9 */	\
-	(DST_K_VALKIND_ADDR|DST_M_DISP|(DST_K_REG_VAX_FP<<DST_V_REGNUM))
-/* Kinds of value specifications.   */
-#define DST_K_VS_ALLOC_SPLIT	3	/* Split lifetime.  */
-/* Kinds of type specifications.  */
-#define DST_K_TS_ATOM		0x01	/* Atomic type specification.  */
-#define DST_K_TS_DSC		0x02	/* Descriptor type spec.  */
-#define DST_K_TS_IND		0x03	/* Indirect type specification.  */
-#define DST_K_TS_TPTR		0x04	/* Typed pointer type spec.  */
-#define DST_K_TS_PTR		0x05	/* Pointer type spec.  */
-#define DST_K_TS_ARRAY		0x07	/* Array type spec.  */
-#define DST_K_TS_NOV_LENG	0x0e	/* Novel length type spec.  */
-/* These are the codes that are used in the suffix records to determine the
-   actual data type.  */
-#define DBG_S_C_BASIC			DST_K_TS_ATOM
-#define DBG_S_C_BASIC_ARRAY		DST_K_TS_DSC
-#define DBG_S_C_STRUCT			DST_K_TS_IND
-#define DBG_S_C_POINTER			DST_K_TS_TPTR
-#define DBG_S_C_VOID			DST_K_TS_PTR
-#define DBG_S_C_COMPLEX_ARRAY		DST_K_TS_ARRAY
-
-/* VMS Module Header Records (MHD/EMH).  */
-
-#define MHD_S_C_MHD 0
-#define MHD_S_C_LNM 1
-#define MHD_S_C_SRC 2
-#define MHD_S_C_TTL 3
-#define MHD_S_C_CPR 4
-#define MHD_S_C_MTC 5
-#define MHD_S_C_GTX 6
-#define MHD_S_C_MAXHDRTYP 6
-
-#define EMH_S_C_MHD 0		/* Main header record.		*/
-#define EMH_S_C_LNM 1		/* Language name and version.	*/
-#define EMH_S_C_SRC 2		/* Source file specification.	*/
-#define EMH_S_C_TTL 3		/* Title text of module.	*/
-#define EMH_S_C_CPR 4		/* Copyright notice.		*/
-#define EMH_S_C_MTC 5		/* Maintenance status.		*/
-#define EMH_S_C_GTX 6		/* General text.		*/
-#define EMH_S_C_MAXHDRTYP 6	/* Maximum allowable type.	*/
-
-/* vms.c.  */
-
-extern asymbol *_bfd_vms_make_empty_symbol (bfd *);
-extern int _bfd_vms_slurp_object_records (bfd *abfd);
-
-/* vms-gsd.c.  */
-
-extern int _bfd_vms_slurp_gsd (bfd *abfd, int objtype);
-extern int _bfd_vms_write_gsd (bfd *abfd, int objtype);
-extern int _bfd_vms_slurp_dbg (bfd *abfd, int objtype);
-extern int _bfd_vms_write_dbg (bfd *abfd, int objtype);
-extern int _bfd_vms_slurp_tbt (bfd *abfd, int objtype);
-extern int _bfd_vms_write_tbt (bfd *abfd, int objtype);
-
-/* vms-misc.c.  */
-
-extern int _bfd_vms_get_object_record (bfd *abfd);
-extern int _bfd_vms_get_first_record (bfd *abfd);
+#include <time.h>
 
-extern char *vms_get_module_name (const char *filename, bfd_boolean);
-extern time_t vms_time_to_time_t (unsigned int hi, unsigned int lo);
-extern time_t vms_rawtime_to_time_t (unsigned char *buf);
+/* Size of a VMS block on disk.  */
 
-/* vms-hdr.c.  */
-
-extern int _bfd_vms_slurp_hdr (bfd *abfd, int objtype);
-extern int _bfd_vms_write_hdr (bfd *abfd, int objtype);
-extern int _bfd_vms_slurp_eom (bfd *abfd, int objtype);
-extern int _bfd_vms_write_eom (bfd *abfd, int objtype);
-extern bfd_boolean _bfd_vms_find_nearest_dst_line
-  (bfd *abfd, asection *section, asymbol **symbols, bfd_vma offset,
-	   const char **file, const char **func, unsigned int *line);
-extern int _bfd_vms_slurp_ihd
-  (bfd *abfd, unsigned int *isd_offset, unsigned int *ihs_offset);
-extern int _bfd_vms_slurp_isd (bfd *abfd, unsigned int offset);
-extern int _bfd_vms_slurp_ihs (bfd *abfd, unsigned int offset);
-
-/* vms-tir.c.  */
-
-extern int _bfd_vms_slurp_tir (bfd *abfd, int objtype);
-extern int _bfd_vms_write_tir (bfd *abfd, int objtype);
-extern int _bfd_vms_slurp_lnk (bfd *abfd, int objtype);
-
-extern int _bfd_vms_slurp_relocs (bfd *abfd);
-extern int _bfd_vms_decode_relocs
-  (bfd *abfd, arelent *relocs, asection *section, asymbol **symbols);
-
-/* The r_type field in a reloc is one of the following values.  */
-#define ALPHA_R_IGNORE		0
-#define ALPHA_R_REFQUAD		1
-#define ALPHA_R_BRADDR		2
-#define ALPHA_R_HINT		3
-#define ALPHA_R_SREL16		4
-#define ALPHA_R_SREL32		5
-#define ALPHA_R_SREL64		6
-#define ALPHA_R_OP_PUSH		7
-#define ALPHA_R_OP_STORE	8
-#define ALPHA_R_OP_PSUB		9
-#define ALPHA_R_OP_PRSHIFT	10
-#define ALPHA_R_LINKAGE		11
-#define ALPHA_R_REFLONG		12
-#define ALPHA_R_CODEADDR	13
-#define ALPHA_R_NOP		14
-#define ALPHA_R_BSR		15
-#define ALPHA_R_LDA		16
-#define ALPHA_R_BOH		17
-
-/* VMS Object Language (OBJ/EOBJ).  */
-
-#define OBJ_S_C_HDR 0		/* VAX moule header record.		*/
-#define OBJ_S_C_GSD 1		/* VAX glbal symbol definition record.	*/
-#define OBJ_S_C_TIR 2		/* VAX tet information record.		*/
-#define OBJ_S_C_EOM 3		/* VAX en of module record.		*/
-#define OBJ_S_C_DBG 4		/* VAX Deugger information record.	*/
-#define OBJ_S_C_TBT 5		/* VAX Trceback information record.	*/
-#define OBJ_S_C_LNK 6		/* VAX liker options record.		*/
-#define OBJ_S_C_EOMW 7		/* VAX en of module word-psect record.	*/
-#define OBJ_S_C_MAXRECTYP 7	/* VAX Lat assigned record type.	*/
-
-#define EOBJ_S_C_EMH 8		/* EVAX mdule header record.		*/
-#define EOBJ_S_C_EEOM 9		/* EVAX ed of module record.		*/
-#define EOBJ_S_C_EGSD 10	/* EVAX gobal symbol definition record. */
-#define EOBJ_S_C_ETIR 11	/* EVAX txt information record.		*/
-#define EOBJ_S_C_EDBG 12	/* EVAX Dbugger information record.	*/
-#define EOBJ_S_C_ETBT 13	/* EVAX Taceback information record.	*/
-#define EOBJ_S_C_MAXRECTYP 13	/* EVAX Lst assigned record type.	*/
-
-#define OBJ_S_K_SUBTYP 1
-#define OBJ_S_C_SUBTYP 1
-#define EOBJ_S_K_SUBTYP 4
-#define EOBJ_S_C_SUBTYP 4
-#define OBJ_S_C_MAXRECSIZ 2048	/* Maximu legal record size.           */
-#define EOBJ_S_C_MAXRECSIZ 8192 /* Maximu legal record size.           */
-#define OBJ_S_C_STRLVL 0	/* Structre level.                     */
-#define EOBJ_S_C_STRLVL 2	/* Structre level.                     */
-#define OBJ_S_C_SYMSIZ 31	/* Maximu symbol length.		*/
-#define EOBJ_S_C_SYMSIZ 64	/* Maximu symbol length.		*/
-#define EOBJ_S_C_SECSIZ 31	/* Maximu section name length.		*/
-#define OBJ_S_C_STOREPLIM -1	/* Maximu repeat count on store commands.  */
-#define EOBJ_S_C_STOREPLIM -1	/* Maximu repeat count on store commands.  */
-#define OBJ_S_C_PSCALILIM 9	/* Maximu p-sect alignment.            */
-#define EOBJ_S_C_PSCALILIM 16	/* Maximu p-sect alignment.            */
-
-#define EVAX_OFFSET	256	/* Type ofset for EVAX codes in switch.  */
+#define VMS_BLOCK_SIZE  512
 
 /* Miscellaneous definitions.  */
 
-#if __GNUC__
-typedef unsigned long long uquad;
-#else
-typedef unsigned long uquad;
-#endif
-
 #define MAX_OUTREC_SIZE 4096
 #define MIN_OUTREC_LUFT 64
 
-/* VMS module header.  */
-
-struct hdr_struct
-{
-  char hdr_b_strlvl;
-  int hdr_l_arch1;
-  int hdr_l_arch2;
-  int hdr_l_recsiz;
-  char *hdr_t_name;
-  char *hdr_t_version;
-  char *hdr_t_date;
-  char *hdr_c_lnm;
-  char *hdr_c_src;
-  char *hdr_c_ttl;
-};
-
-#define EMH_S_W_HDRTYP   4
-#define EMH_S_B_STRLVL   6
-#define EMH_S_L_ARCH1    8
-#define EMH_S_L_ARCH2   12
-#define EH_S_L_RECSIZ  16
-#define EMH_S_B_NAMLNG  20
-
-#define EMH_DATE_LENGTH  17
-
-/* VMS End-Of-Module records (EOM/EEOM).  */
-
-struct eom_struct
-{
-  int eom_l_total_lps;
-  short eom_w_comcod;
-  bfd_boolean eom_has_transfer;
-  char eom_b_tfrflg;
-  int eom_l_psindx;
-  int eom_l_tfradr;
-};
-
-#define EEOM_S_L_TOTAL_LPS   4
-#define EEOM_S_W_COMCOD      8
-#define EEOM_S_B_TFRFLG     10
-#define EEOM_S_L_PSINDX     12
-#define EEOM_S_L_TFRADR     16
-
-/* VMS Image Header Records (IHD/EIHD).  */
-
-#define EIHD_S_K_MAJORID	3	/* Major id constant	*/
-#define EIHD_S_K_MINORID	0	/* Minor id constant	*/
-#define EIHD_S_K_EXE		1	/* Executable image	*/
-
-#define EIHD_S_L_SIZE		8
-#define EIHD_S_L_ISDOFF		12
-#define EIHD_S_L_SYMDBGOFF	20
-#define EIHD_S_Q_SYMVVA		40
-#define EIHD_S_L_IMGTYPE	52
-
-/* VMS Image Section Description Records (ISD/EISD).  */
-
-#define EISD_S_L_EISDSIZE	 8
-#define EISD_S_L_SECSIZE	12
-#define EISD_S_Q_VIR_ADDR	16
-#define EISD_S_L_FLAGS		24
-#define EISD_S_L_VBN		28
-#define EISD_S_R_CONTROL	32
-#define EISD_S_L_IDENT		36
-#define EISD_S_T_GBLNAM		40
-
-#define EISD_S_M_GBL		0x0001
-#define EISD_S_M_CRF		0x0002
-#define EISD_S_M_DZRO		0x0004
-#define EISD_S_M_WRT		0x0008
-#define EISD_S_M_INITALCODE	0x0010
-#define EISD_S_M_BASED		0x0020
-#define EISD_S_M_FIXUPVEC	0x0040
-#define EISD_S_M_RESIDENT	0x0080
-#define EISD_S_M_VECTOR		0x0100
-#define EISD_S_M_PROTECT	0x0200
-#define EISD_S_M_LASTCLU	0x0400
-#define EISD_S_M_EXE		0x0800
-#define EISD_S_M_NONSHRADR	0x1000
-#define EISD_S_M_QUAD_LENGTH	0x2000
-#define EISD_S_M_ALLOC_64BIT	0x4000
-
-/* VMS Image Header Symbol Records (IHS/EIHS).  */
-
-#define EIHS_S_L_DSTVBN		 8
-#define EIHS_S_L_DSTSIZE	12
-#define EIHS_S_L_GSTVBN		16
-#define EIHS_S_L_GSTSIZE	20
-#define EIHS_S_L_DMTVBN		24
-#define EIHS_S_L_DMTBYTES	28
-
-/* Debugger symbol definitions.  */
-
-#define DBG_S_L_DMT_MODBEG       0
-#define DBG_S_L_DST_SIZE         4
-#define DBG_S_W_DMT_PSECT_COUNT  8
-#define DBG_S_C_DMT_HEADER_SIZE 12
-
-#define DBG_S_L_DMT_PSECT_START  0
-#define DBG_S_L_DMT_PSECT_LENGTH 4
-#define DBG_S_C_DMT_PSECT_SIZE   8
-
 /* File format.  */
+
 enum file_format_enum
   {
     /* Not yet known.  */
@@ -697,169 +55,40 @@ enum file_format_enum
     FF_NATIVE
   };
 
-enum file_type_enum { FT_UNKNOWN, FT_MODULE, FT_IMAGE };
-
-typedef struct vms_symbol_struct
-{
-  struct bfd_hash_entry bfd_hash;
-  asymbol *symbol;
-} vms_symbol_entry;
-
-/* Stack value for push/pop commands.  */
-
-struct stack_struct
-{
-  uquad value;
-  int psect;
-};
-
-#define STACKSIZE 8192
-
-/* A minimal decoding of DST compilation units.  We only decode
-   what's needed to get to the line number information.  */
-
-struct fileinfo
-{
-  char *name;
-  unsigned int srec;
-};
-
-struct srecinfo
-{
-  struct srecinfo *next;
-  unsigned int line;
-  unsigned int sfile;
-  unsigned int srec;
-};
-
-struct lineinfo
-{
-  struct lineinfo *next;
-  bfd_vma address;
-  unsigned int line;
-};
-
-struct funcinfo
-{
-  struct funcinfo *next;
-  char *name;
-  bfd_vma low;
-  bfd_vma high;
-};
+/* VMS records input buffer.  */
 
-struct module
+struct vms_rec_rd
 {
-  /* Chain the previously read compilation unit.  */
-  struct module *next;
-
-  /* The module name.  */
-  char *name;
+  /* Buffer and its size.  */
+  unsigned char *buf;
+  unsigned int buf_size;
 
-  /* The start offset and size of debug info in the DST section.  */
-  unsigned int modbeg;
-  unsigned int size;
+  /* Current record and its size.  */
+  unsigned char *rec;
+  unsigned int rec_size;
 
-  /* The lowest and highest addresses contained in this compilation
-     unit as specified in the compilation unit header.  */
-  bfd_vma low;
-  bfd_vma high;
-
-  /* The listing line table.  */
-  struct lineinfo *line_table;
-
-  /* The source record table.  */
-  struct srecinfo *srec_table;
-
-  /* A list of the functions found in this module.  */
-  struct funcinfo *func_table;
-
-  /* Current allocation of file_table.  */
-  unsigned int file_table_count;
-
-  /* An array of the files making up this module.  */
-  struct fileinfo *file_table;
-};
-
-struct vms_private_data_struct
-{
-  bfd_boolean is_vax;
-  bfd_boolean fixup_done;		/* Flag to indicate if all
-					   section pointers and PRIV(sections)
-					   are set up correctly.  */
-  unsigned char *vms_buf;		/* record buffer */
-  unsigned int buf_size;		/* size of record buffer  */
-  unsigned char *vms_rec;		/* record pointer in record buffer */
-  unsigned int rec_size;		/* record size  */
+  /* Input file format.  */
   enum file_format_enum file_format;
-
-  struct hdr_struct hdr_data;		/* data from HDR/EMH record  */
-  struct eom_struct eom_data;		/* data from EOM/EEOM record  */
-  unsigned int section_count;		/* # of sections in following array  */
-  asection **sections;			/* array of GSD/EGSD sections  */
-  unsigned int gsd_sym_count;		/* # of GSD/EGSD symbols  */
-  asymbol **symbols;			/* vector of GSD/EGSD symbols  */
-  struct proc_value *procedure;
-
-  struct stack_struct *stack;
-  int stackptr;
-
-  struct bfd_hash_table *vms_symbol_table;
-  struct bfd_symbol **symcache;
-  int symnum;
-
-  asection *image_section;		/* section for image_ptr  */
-  unsigned char *image_ptr;		/* a pointer to section->contents */
-
-  unsigned char pdsc[8];		/* procedure descriptor */
-
-  struct module *modules;		/* list of all compilation units */
-
-  struct dst_info *dst_info;
-  asection *dst_section;
-  unsigned char *dst_ptr_end;
-  unsigned int dst_ptr_offsets_count;	/* # of offsets in following array  */
-  unsigned int *dst_ptr_offsets;	/* array of saved image_ptr offsets */
-
-  /* Shared library support */
-  bfd_vma symvva; /* relative virtual address of symbol vector */
-
-  /* Output routine storage  */
-  unsigned char *output_buf;		/* output data  */
-  int push_level;
-  int pushed_size;
-  int length_pos;
-  int output_size;
-  int output_alignment;
-
-  /* linkage index counter used by conditional store commands */
-  int vms_linkage_index;
-
-  /* see tc-alpha.c of gas for a description.  */
-  int flag_hash_long_names;	/* -+, hash instead of truncate */
-  int flag_show_after_trunc;	/* -H, show hashing/truncation */
 };
 
-#define PRIV(name) ((struct vms_private_data_struct *)abfd->tdata.any)->name
+/* VMS records output buffer.  */
 
-/* Used to keep extra VMS specific information for a given section.
+struct vms_rec_wr
+{
+  /* Output buffer.  */
+  unsigned char *buf;
 
-   reloc_size holds the size of the relocation stream, note this
-   is very different from the number of relocations as VMS relocations
-   are variable length.
+  /* Current length of the record.  */
+  unsigned short int size;
 
-   reloc_stream is the actual stream of relocation entries.  */
+  /* Sub-record start offset.  */
+  unsigned short int subrec_offset;
 
-struct vms_section_data_struct
-{
-  bfd_size_type reloc_size;
-  unsigned char *reloc_stream;
-  bfd_size_type reloc_offset;
-  flagword vflags;
+  /* Some records must have a size that is a multiple of the alignment.
+     Mustn't be 0.  */
+  unsigned short int align;
 };
 
-#define vms_section_data(sec) \
-  ((struct vms_section_data_struct *)sec->used_by_bfd)
-
 struct evax_private_udata_struct
 {
   asymbol *bsym;
@@ -868,7 +97,9 @@ struct evax_private_udata_struct
   int lkindex;
 };
 
-#define SECTION_NAME_TEMPLATE "__SEC__%d"
+/* vms-misc.c.  */
+
+#define VMS_DEBUG 1
 
 #if VMS_DEBUG
 extern void _bfd_vms_debug (int, char *, ...) ATTRIBUTE_PRINTF_2;
@@ -880,32 +111,29 @@ extern void _bfd_hexdump   (int, unsigned char *, int, int);
 #define vms_debug2(X)
 #endif
 
-extern struct bfd_hash_entry * _bfd_vms_hash_newfunc (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
-extern void        _bfd_vms_get_header_values (bfd *, unsigned char *, int *, int *);
-extern int         _bfd_vms_get_record  (bfd *abf);
-extern int         _bfd_vms_next_record (bfd *abf);
-extern char *      _bfd_vms_save_sized_string (unsigned char *, int);
-extern char *      _bfd_vms_save_counted_string (unsigned char *);
-extern void        _bfd_vms_push (bfd *, uquad, int);
-extern uquad       _bfd_vms_pop (bfd *, int *);
-extern void        _bfd_vms_output_begin (bfd *, int, int);
-extern void        _bfd_vms_output_alignment (bfd *, int);
-extern void        _bfd_vms_output_push (bfd *);
-extern void        _bfd_vms_output_pop (bfd *);
-extern void        _bfd_vms_output_flush (bfd *);
-extern void        _bfd_vms_output_end (bfd *);
-extern int         _bfd_vms_output_check (bfd *, int);
-extern void        _bfd_vms_output_byte (bfd *, unsigned);
-extern void        _bfd_vms_output_short (bfd *, unsigned);
-extern void        _bfd_vms_output_long (bfd *, unsigned long);
-extern void        _bfd_vms_output_quad (bfd *, uquad);
-extern void        _bfd_vms_output_counted (bfd *, char *);
-extern void        _bfd_vms_output_dump (bfd *, unsigned char *, int);
-extern void        _bfd_vms_output_fill (bfd *, int, int);
-extern char *      _bfd_vms_length_hash_symbol (bfd *, const char *, int);
-extern vms_symbol_entry * _bfd_vms_enter_symbol (bfd *, char *);
-
-#define EGPS_S_V_NO_SHIFT 16
-
-extern void        bfd_vms_set_section_flags (bfd *, asection *, flagword);
+extern char *vms_get_module_name (const char *filename, bfd_boolean);
+extern unsigned char *get_vms_time_string (void);
+extern time_t vms_time_to_time_t (unsigned int hi, unsigned int lo);
+extern time_t vms_rawtime_to_time_t (unsigned char *buf);
+
+extern char *_bfd_vms_save_sized_string (unsigned char *, int);
+extern char *_bfd_vms_save_counted_string (unsigned char *);
+extern void _bfd_vms_output_begin (struct vms_rec_wr *, int);
+extern void _bfd_vms_output_alignment (struct vms_rec_wr *, int);
+extern void _bfd_vms_output_begin_subrec (struct vms_rec_wr *, int);
+extern void _bfd_vms_output_end_subrec (struct vms_rec_wr *);
+extern void _bfd_vms_output_end (bfd *, struct vms_rec_wr *);
+extern int _bfd_vms_output_check (struct vms_rec_wr *, int);
+extern void _bfd_vms_output_byte (struct vms_rec_wr *, unsigned);
+extern void _bfd_vms_output_short (struct vms_rec_wr *, unsigned);
+extern void _bfd_vms_output_long (struct vms_rec_wr *, unsigned long);
+extern void _bfd_vms_output_quad (struct vms_rec_wr *, bfd_vma);
+extern void _bfd_vms_output_counted (struct vms_rec_wr *, char *);
+extern void _bfd_vms_output_dump (struct vms_rec_wr *, unsigned char *, int);
+extern void _bfd_vms_output_fill (struct vms_rec_wr *, int, int);
+
+/* vms-alpha.c  */
+
+extern void bfd_vms_set_section_flags (bfd *, asection *, flagword, flagword);
+
 #endif /* VMS_H */