Tue Jun 18 14:42:58 1996 Klaus Kaempf <kkaempf@progis.de>

	Added support for Alpha OpenVMS:
	* evax.h, evax-alpha.c, evax-egsd.c, evax-emh.c: New files.
	* evax-etir.c, evax-misc.c, hosts/alphavms.h: New files.
	* config.h-vms, makefile.vms: New files.
	* config.bfd (alpha-*-*vms*): New target.
	* configure.in (evax_alpha_vec): New target vector.
	* configure: Rebuild.
	* reloc.c (BFD_RELOC_SWREL32, BFD_RELOC_SWREL64): Define.
	(BFD_RELOC_ALPHA_LINKAGE, BFD_RELOC_ALPHA_BASEREG): Define.
	* targets.c (bfd_target_evax_flavour): Define.
	(evax_alpha_vec): Declare.
	(bfd_target_vector): Add ecoffalpha_little_vec and evax_alpha_vec
	if BFD64 is defined.
	* bfd-in2.h, libbfd.h: Rebuild.
	* Makefile.in: Rebuild dependencies.
	(BFD64_BACKENDS): Add evax-alpha.o, evax-egsd.o, evax-etir.o,
	evax-emh.o, and evax-misc.o.
	(BFD64_BACKENDS_CFILES): Add evax-alpha.c, evax-egsd.c,
	evax-etir.c, evax-emh.c, and evax-misc.c.
	(HFILES): Add evax.h.

13 files changed, 5953 insertions, 5 deletions

diff --git a/bfd/.Sanitize b/bfd/.Sanitize
index 41c481c..8217e3f 100644
--- a/bfd/.Sanitize
+++ b/bfd/.Sanitize
@@ -92,6 +92,7 @@ coffgen.c
 cofflink.c
 coffswap.h
 config.bfd
+config.h-vms
 config.in
 configure
 configure.bat
@@ -147,6 +148,12 @@ elfcode.h
 elfcore.h
 elflink.c
 elflink.h
+evax.h
+evax-alpha.c
+evax-egsd.c
+evax-emh.c
+evax-etir.c
+evax-misc.c
 filemode.c
 format.c
 freebsd.h
@@ -193,6 +200,7 @@ m68klynx.c
 m68knetbsd.c
 m88kmach3.c
 makefile.dos
+makefile.vms
 mipsbsd.c
 mpw-config.in
 mpw-make.sed
diff --git a/bfd/ChangeLog b/bfd/ChangeLog
index e336ca0..c09c545 100644
--- a/bfd/ChangeLog
+++ b/bfd/ChangeLog
@@ -1,3 +1,26 @@
+Tue Jun 18 14:42:58 1996  Klaus Kaempf  <kkaempf@progis.de>
+
+	Added support for Alpha OpenVMS:
+	* evax.h, evax-alpha.c, evax-egsd.c, evax-emh.c: New files.
+	* evax-etir.c, evax-misc.c, hosts/alphavms.h: New files.
+	* config.h-vms, makefile.vms: New files.
+	* config.bfd (alpha-*-*vms*): New target.
+	* configure.in (evax_alpha_vec): New target vector.
+	* configure: Rebuild.
+	* reloc.c (BFD_RELOC_SWREL32, BFD_RELOC_SWREL64): Define.
+	(BFD_RELOC_ALPHA_LINKAGE, BFD_RELOC_ALPHA_BASEREG): Define.
+	* targets.c (bfd_target_evax_flavour): Define.
+	(evax_alpha_vec): Declare.
+	(bfd_target_vector): Add ecoffalpha_little_vec and evax_alpha_vec
+	if BFD64 is defined.
+	* bfd-in2.h, libbfd.h: Rebuild.
+	* Makefile.in: Rebuild dependencies.
+	(BFD64_BACKENDS): Add evax-alpha.o, evax-egsd.o, evax-etir.o,
+	evax-emh.o, and evax-misc.o.
+	(BFD64_BACKENDS_CFILES): Add evax-alpha.c, evax-egsd.c,
+	evax-etir.c, evax-emh.c, and evax-misc.c.
+	(HFILES): Add evax.h.
+
 Tue Jun 18 13:54:18 1996  Ian Lance Taylor  <ian@cygnus.com>
 
 	* coff-h8300.c (h8300_reloc16_extra_cases): Make name a const
diff --git a/bfd/bfd-in2.h b/bfd/bfd-in2.h
index 8003d45..a6b59aa 100644
--- a/bfd/bfd-in2.h
+++ b/bfd/bfd-in2.h
@@ -125,7 +125,9 @@ typedef long int file_ptr;
 #else
 #ifdef __GNUC__
 #define BFD_HOST_64_BIT long long
-#endif /* defined (__GNUC__) */
+#else /* ! defined (__GNUC__) */
+ #error No 64 bit integer type available
+#endif /* ! defined (__GNUC__) */
 #endif /* ! BFD_HOST_64BIT_LONG */
 #endif /* ! defined (BFD_HOST_64_BIT) */
 
@@ -665,6 +667,18 @@ extern boolean bfd_xcoff_size_dynamic_sections
 	   unsigned long, unsigned long, unsigned long, boolean,
 	   int, boolean, boolean, struct sec **));
 
+/* Externally visible COFF routines.  */
+
+#if defined(__STDC__) || defined(ALMOST_STDC)
+struct internal_syment;
+union internal_auxent;
+#endif
+
+extern boolean bfd_coff_get_syment
+  PARAMS ((bfd *, struct symbol_cache_entry *, struct internal_syment *));
+extern boolean bfd_coff_get_auxent
+  PARAMS ((bfd *, struct symbol_cache_entry *, int, union internal_auxent *));
+
 /* And more from the source.  */
 void 
 bfd_init PARAMS ((void));
@@ -1190,9 +1204,6 @@ enum bfd_architecture
   bfd_arch_arm,        /* Advanced Risc Machines ARM */
   bfd_arch_ns32k,      /* National Semiconductors ns32000 */
   bfd_arch_w65,        /* WDC 65816 */
-  /* start-sanitize-rce */
-  bfd_arch_rce,        /* Motorola RCE */
-  /* end-sanitize-rce */
   /* start-sanitize-arc */
   bfd_arch_arc,        /* Argonaut RISC Core */
 #define bfd_mach_arc_base 0
@@ -1533,6 +1544,11 @@ decided relatively late. */
   BFD_RELOC_GPREL16,
   BFD_RELOC_GPREL32,
 
+/* For openVMS/Alpha systems, these are displacements for switch
+tables. */
+  BFD_RELOC_SWREL32,
+  BFD_RELOC_SWREL64,
+
 /* Reloc types used for i960/b.out. */
   BFD_RELOC_I960_CALLJ,
 
@@ -1617,6 +1633,13 @@ The GNU linker currently doesn't do any of this optimizing. */
 prediction logic which may be provided on some processors. */
   BFD_RELOC_ALPHA_HINT,
 
+/* The LINKAGE relocation outputs a special code in the object file,
+the rest is handled by the linker. */
+  BFD_RELOC_ALPHA_LINKAGE,
+
+/* The BASEREG relocation calculates differences to basereg. */
+  BFD_RELOC_ALPHA_BASEREG,
+
 /* Bits 27..2 of the relocation address shifted right 2 bits;
 simple reloc otherwise. */
   BFD_RELOC_MIPS_JMP,
@@ -2270,7 +2293,8 @@ enum bfd_flavour {
   bfd_target_som_flavour,
   bfd_target_os9k_flavour,
   bfd_target_versados_flavour,
-  bfd_target_msdos_flavour
+  bfd_target_msdos_flavour,
+  bfd_target_evax_flavour
 };
 
 enum bfd_endian { BFD_ENDIAN_BIG, BFD_ENDIAN_LITTLE, BFD_ENDIAN_UNKNOWN };
diff --git a/bfd/config.h-vms b/bfd/config.h-vms
new file mode 100644
index 0000000..66c4344
--- /dev/null
+++ b/bfd/config.h-vms
@@ -0,0 +1,59 @@
+/* config.h-vms.  Generated by hand by Klaus Kämpf, kkaempf@didymus.rmi.de.  */
+/* config.in.  Generated automatically from configure.in by autoheader.  */
+
+/* Whether malloc must be declared even if <stdlib.h> is included.  */
+/* #undef NEED_DECLARATION_MALLOC */
+
+/* Whether free must be declared even if <stdlib.h> is included.  */
+/* #undef NEED_DECLARATION_FREE */
+
+/* Define if you have a working `mmap' system call.  */
+/* #define HAVE_MMAP 1 */
+
+/* Do we need to use the b modifier when opening binary files?  */
+/* #undef USE_BINARY_FOPEN */
+
+/* Name of host specific header file to include in trad-core.c.  */
+/* #undef TRAD_HEADER */
+
+/* Define only if <sys/procfs.h> is available *and* it defines prstatus_t.  */
+/* #undef HAVE_SYS_PROCFS_H */
+
+/* Do we really want to use mmap if it's available?  */
+/* #undef USE_MMAP */
+
+/* Define if you have the fcntl function.  */
+#define HAVE_FCNTL 1
+
+/* Define if you have the getpagesize function.  */
+#define HAVE_GETPAGESIZE 1
+
+/* Define if you have the madvise function.  */
+#define HAVE_MADVISE 1
+
+/* Define if you have the mprotect function.  */
+#define HAVE_MPROTECT 1
+
+/* Define if you have the <fcntl.h> header file.  */
+#define HAVE_FCNTL_H 1
+
+/* Define if you have the <stddef.h> header file.  */
+#define HAVE_STDDEF_H 1
+
+/* Define if you have the <stdlib.h> header file.  */
+#define HAVE_STDLIB_H 1
+
+/* Define if you have the <string.h> header file.  */
+#define HAVE_STRING_H 1
+
+/* Define if you have the <strings.h> header file.  */
+#define HAVE_STRINGS_H 1
+
+/* Define if you have the <sys/file.h> header file.  */
+#define HAVE_SYS_FILE_H 1
+
+/* Define if you have the <time.h> header file.  */
+#define HAVE_TIME_H 1
+
+/* Define if you have the <unistd.h> header file.  */
+#define HAVE_UNISTD_H 1
diff --git a/bfd/evax-alpha.c b/bfd/evax-alpha.c
new file mode 100644
index 0000000..2f43039
--- /dev/null
+++ b/bfd/evax-alpha.c
@@ -0,0 +1,1857 @@
+/* evax-alpha.c -- BFD back-end for ALPHA EVAX (openVMS/AXP) files.
+   Copyright 1996 Free Software Foundation, Inc.
+   Written by Klaus Kämpf (kkaempf@progis.de)
+   of proGIS Softwareentwicklung, Aachen, Germany
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+
+#include <stdio.h>
+
+#include "bfd.h"
+#include "sysdep.h"
+#include "bfdlink.h"
+#include "libbfd.h"
+
+#include "evax.h"
+
+static boolean evax_initialize PARAMS ((bfd *));
+static boolean fill_section_ptr PARAMS ((struct bfd_hash_entry *, PTR));
+static boolean evax_fixup_sections PARAMS ((bfd *));
+static boolean copy_symbols PARAMS ((struct bfd_hash_entry *, PTR));
+static bfd_reloc_status_type reloc_nil
+  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
+static const struct bfd_target *evax_object_p PARAMS ((bfd *abfd));
+static const struct bfd_target *evax_archive_p PARAMS ((bfd *abfd));
+static boolean evax_mkobject PARAMS ((bfd *abfd));
+static boolean evax_write_object_contents PARAMS ((bfd *abfd));
+static boolean evax_close_and_cleanup PARAMS ((bfd *abfd));
+static boolean evax_bfd_free_cached_info PARAMS ((bfd *abfd));
+static boolean evax_new_section_hook PARAMS ((bfd *abfd, asection *section));
+static boolean evax_get_section_contents
+  PARAMS ((bfd *abfd, asection *section, PTR x1, file_ptr x2,
+	   bfd_size_type x3));
+static boolean evax_get_section_contents_in_window
+  PARAMS ((bfd *abfd, asection *section, bfd_window *w, file_ptr offset,
+	   bfd_size_type count));
+static boolean evax_bfd_copy_private_bfd_data PARAMS ((bfd *src, bfd *dest));
+static boolean evax_bfd_copy_private_section_data
+  PARAMS ((bfd *srcbfd, asection *srcsec, bfd *dstbfd, asection *dstsec));
+static boolean evax_bfd_copy_private_symbol_data
+  PARAMS ((bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym));
+static boolean evax_bfd_print_private_bfd_data
+  PARAMS ((bfd *abfd, void *file));
+static char *evax_core_file_failing_command PARAMS ((bfd *abfd));
+static int evax_core_file_failing_signal PARAMS ((bfd *abfd));
+static boolean evax_core_file_matches_executable_p
+  PARAMS ((bfd *abfd, bfd *bbfd));
+static boolean evax_slurp_armap PARAMS ((bfd *abfd));
+static boolean evax_slurp_extended_name_table PARAMS ((bfd *abfd));
+static boolean evax_construct_extended_name_table
+  PARAMS ((bfd *abfd, char **tabloc, bfd_size_type *tablen,
+	   const char **name));
+static void evax_truncate_arname
+  PARAMS ((bfd *abfd, CONST char *pathname, char *arhdr));
+static boolean evax_write_armap
+  PARAMS ((bfd *arch, unsigned int elength, struct orl *map,
+	   unsigned int orl_count, int stridx));
+static PTR evax_read_ar_hdr PARAMS ((bfd *abfd));
+static bfd *evax_get_elt_at_index PARAMS ((bfd *abfd, symindex index));
+static bfd *evax_openr_next_archived_file PARAMS ((bfd *arch, bfd *prev));
+static boolean evax_update_armap_timestamp PARAMS ((bfd *abfd));
+static int evax_generic_stat_arch_elt PARAMS ((bfd *abfd, struct stat *stat));
+static long evax_get_symtab_upper_bound PARAMS ((bfd *abfd));
+static long evax_get_symtab PARAMS ((bfd *abfd, asymbol **symbols));
+static void evax_print_symbol
+  PARAMS ((bfd *abfd, PTR file, asymbol *symbol, bfd_print_symbol_type how));
+static void evax_get_symbol_info
+  PARAMS ((bfd *abfd, asymbol *symbol, symbol_info *ret));
+static boolean evax_bfd_is_local_label PARAMS ((bfd *abfd, asymbol *symbol));
+static alent *evax_get_lineno PARAMS ((bfd *abfd, asymbol *symbol));
+static boolean evax_find_nearest_line
+  PARAMS ((bfd *abfd, asection *section, asymbol **symbols, bfd_vma offset,
+	   const char **file, const char **func, unsigned int *line));
+static asymbol *evax_bfd_make_debug_symbol
+  PARAMS ((bfd *abfd, void *ptr, unsigned long size));
+static long evax_read_minisymbols
+  PARAMS ((bfd *abfd, boolean dynamic, PTR *minisymsp, unsigned int *sizep));
+static asymbol *evax_minisymbol_to_symbol
+  PARAMS ((bfd *abfd, boolean dynamic, const PTR minisym, asymbol *sym));
+static long evax_get_reloc_upper_bound PARAMS ((bfd *abfd, asection *sect));
+static long evax_canonicalize_reloc
+  PARAMS ((bfd *abfd, asection *srcsec, arelent **location,
+	   asymbol **symbols));
+static const struct reloc_howto_struct *evax_bfd_reloc_type_lookup
+  PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
+static boolean evax_set_arch_mach
+  PARAMS ((bfd *abfd, enum bfd_architecture arch, unsigned long mach));
+static boolean evax_set_section_contents
+  PARAMS ((bfd *abfd, asection *section, PTR location, file_ptr offset,
+	   bfd_size_type count));
+static int evax_sizeof_headers PARAMS ((bfd *abfd, boolean reloc));
+static bfd_byte *evax_bfd_get_relocated_section_contents
+  PARAMS ((bfd *abfd, struct bfd_link_info *link_info,
+	   struct bfd_link_order *link_order, bfd_byte *data,
+	   boolean relocateable, asymbol **symbols));
+static boolean evax_bfd_relax_section
+  PARAMS ((bfd *abfd, asection *section, struct bfd_link_info *link_info,
+	   boolean *again));
+static struct bfd_link_hash_table *evax_bfd_link_hash_table_create
+  PARAMS ((bfd *abfd));
+static boolean evax_bfd_link_add_symbols
+  PARAMS ((bfd *abfd, struct bfd_link_info *link_info));
+static boolean evax_bfd_final_link
+  PARAMS ((bfd *abfd, struct bfd_link_info *link_info));
+static boolean evax_bfd_link_split_section
+  PARAMS ((bfd *abfd, asection *section));
+static long evax_get_dynamic_symtab_upper_bound PARAMS ((bfd *abfd));
+static long evax_canonicalize_dynamic_symtab
+  PARAMS ((bfd *abfd, asymbol **symbols));
+static long evax_get_dynamic_reloc_upper_bound PARAMS ((bfd *abfd));
+static long evax_canonicalize_dynamic_reloc
+  PARAMS ((bfd *abfd, arelent **arel, asymbol **symbols));
+static boolean evax_bfd_merge_private_bfd_data PARAMS ((bfd *ibfd, bfd *obfd));
+static boolean evax_bfd_set_private_flags PARAMS ((bfd *abfd, flagword flags));
+
+#define evax_make_empty_symbol _bfd_evax_make_empty_symbol
+
+/*===========================================================================*/
+
+const bfd_target evax_alpha_vec =
+{
+
+  "evax-alpha",			/* name */
+  bfd_target_evax_flavour,
+  false,			/* data byte order is little */
+  false,			/* header byte order is little */
+
+  (HAS_RELOC |			/* object flags */
+   HAS_LINENO | HAS_DEBUG |
+   HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
+
+  (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* sect flags */
+  0,				/* symbol_leading_char */
+  ' ',				/* ar_pad_char */
+  15,				/* ar_max_namelen */
+  bfd_getl64,			/* bfd_getx64 */
+  bfd_getl_signed_64,		/* bfd_getx_signed_64 */
+  bfd_putl64,			/* bfd_putx64 */
+  bfd_getl32,			/* bfd_getx32 */
+  bfd_getl_signed_32,		/* bfd_getx_signed_32 */
+  bfd_putl32,			/* bfd_putx32 */
+  bfd_getl16,			/* bfd_getx16 */
+  bfd_getl_signed_16,		/* bfd_getx_signed_16 */
+  bfd_putl16,			/* bfd_putx16 */
+  bfd_getl64,			/* bfd_h_getx64 */
+  bfd_getl_signed_64,		/* bfd_h_getx_signed_64 */
+  bfd_putl64,			/* bfd_h_putx64 */
+  bfd_getl32,			/* bfd_h_getx32 */
+  bfd_getl_signed_32,		/* bfd_h_getx_signed_32 */
+  bfd_putl32,			/* bfd_h_putx32 */
+  bfd_getl16,			/* bfd_h_getx16 */
+  bfd_getl_signed_16,		/* bfd_h_getx_signed_16 */
+  bfd_putl16,			/* bfd_h_putx16 */
+
+  {_bfd_dummy_target, evax_object_p,		/* bfd_check_format */
+   evax_archive_p, _bfd_dummy_target},
+  {bfd_false, evax_mkobject,			/* bfd_set_format */
+   _bfd_generic_mkarchive, bfd_false},
+  {bfd_false, evax_write_object_contents,	/* bfd_write_contents */
+   _bfd_write_archive_contents, bfd_false},
+
+  BFD_JUMP_TABLE_GENERIC (evax),
+  BFD_JUMP_TABLE_COPY (evax),
+  BFD_JUMP_TABLE_CORE (evax),
+  BFD_JUMP_TABLE_ARCHIVE (evax),
+  BFD_JUMP_TABLE_SYMBOLS (evax),
+  BFD_JUMP_TABLE_RELOCS (evax),
+  BFD_JUMP_TABLE_WRITE (evax),
+  BFD_JUMP_TABLE_LINK (evax),
+  BFD_JUMP_TABLE_DYNAMIC (evax),
+
+  (PTR) 0
+};
+
+
+/*===========================================================================*/
+
+/* Initialize private data  */
+
+static boolean
+evax_initialize (abfd)
+     bfd *abfd;
+{
+  int i;
+
+  if (abfd->tdata.any != 0)
+    return true;
+
+  bfd_set_start_address (abfd, (bfd_vma)-1);
+
+  abfd->tdata.any = ((struct evax_private_data_struct*)
+		     bfd_malloc (sizeof (struct evax_private_data_struct)));
+  if (abfd->tdata.any == 0)
+    return false;
+  PRIV(evax_buf) = 0;
+  PRIV(buf_size) = 0;
+  PRIV(rec_length) = 0;
+  PRIV(file_format) = FF_UNKNOWN;
+  PRIV(filename) = NULL;
+  PRIV(fixup_done) = false;
+  PRIV(sections) = NULL;
+
+  PRIV(stack) = ((struct stack_struct *)
+		 bfd_malloc (sizeof (struct stack_struct) * STACKSIZE));
+  if (PRIV(stack) == 0)
+    {
+     evax_init_no_mem1:
+      free (abfd->tdata.any);
+      abfd->tdata.any = 0;
+      return false;
+    }
+  PRIV(stackptr) = 0;
+
+  PRIV(evax_symbol_table) = ((struct bfd_hash_table *)
+			     bfd_malloc (sizeof (struct bfd_hash_table)));
+  if (PRIV(evax_symbol_table) == 0)
+    {
+     evax_init_no_mem2:
+      free (PRIV(stack));
+      PRIV(stack) = 0;
+      goto evax_init_no_mem1;
+    }
+
+  if (!bfd_hash_table_init (PRIV(evax_symbol_table), _bfd_evax_hash_newfunc))
+    return false;
+
+  PRIV(location_stack) = ((struct location_struct *)
+			  bfd_malloc (sizeof (struct location_struct)
+				      * LOCATION_SAVE_SIZE));
+  if (PRIV(location_stack) == 0)
+    {
+     evax_init_no_mem3:
+      free (PRIV(evax_symbol_table));
+      PRIV(evax_symbol_table) = 0;
+      goto evax_init_no_mem2;
+    }
+
+  for (i=0; i<EVAX_SECTION_COUNT; i++)
+    {
+      PRIV(evax_section_table)[i] = NULL;
+      PRIV(evax_reloc_table)[i] = NULL;
+    }
+
+  PRIV(output_buf) = (unsigned char *) malloc (MAX_OUTREC_SIZE);
+  if (PRIV(output_buf) == 0)
+    {
+      free (PRIV(location_stack));
+      PRIV(location_stack) = 0;
+      goto evax_init_no_mem3;
+    }
+  PRIV(push_level) = 0;
+  PRIV(pushed_size) = 0;
+  PRIV(length_pos) = 2;
+  PRIV(output_size) = 0;
+  PRIV(output_alignment) = 1;
+
+  return true;
+}
+
+
+/* Fill symbol->section with section ptr
+   symbol->section is filled with the section index for defined symbols
+   during reading the 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 evax_fixup_sections  */
+
+static boolean
+fill_section_ptr (entry, sections)
+     struct bfd_hash_entry *entry;
+     PTR sections;
+{
+  asection *sec;
+  asymbol *sym;
+
+  sym =  ((evax_symbol_entry *)entry)->symbol;
+  sec = sym->section;
+
+  if (!bfd_is_und_section (sec))
+    {
+      sec = ((evax_symbol_entry *)entry)->symbol->section =
+	((asection **)sections)[(int)sec];
+    }
+
+  if (strcmp (sym->name, sec->name) == 0)
+    sym->flags |= BSF_SECTION_SYM;
+
+  return true;
+}
+
+
+/* Fixup sections
+   set up all pointers and arrays, counters and sizes are fixed now
+
+   we build a private sections vector for easy access since sections
+   are always referenced by an index number.
+
+   alloc PRIV(sections) according to abfd->section_count
+	copy abfd->sections to PRIV(sections)  */
+
+static boolean
+evax_fixup_sections (abfd)
+     bfd *abfd;
+{
+  asection *s;
+
+  if (PRIV(fixup_done))
+    return true;
+
+  PRIV(sections) = ((asection **)
+		    bfd_malloc (abfd->section_count * sizeof (asection *)));
+  if (PRIV(sections) == 0)
+    return false;
+  PRIV(egsd_sec_count) = abfd->section_count;
+  s = abfd->sections;
+  while (s)
+    {
+      PRIV(sections)[s->index] = s;
+      s = s->next;
+    }
+
+  /*
+   * traverse symbol table and fill in all section pointers
+   */
+
+  bfd_hash_traverse (PRIV(evax_symbol_table), fill_section_ptr,
+		    (PTR)(PRIV(sections)));
+
+  PRIV(fixup_done) = true;
+
+  return true;
+}
+
+/*===========================================================================*/
+
+/* 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 *
+evax_object_p (abfd)
+     bfd *abfd;
+{
+  int err = 0;
+  int prev_type;
+#if EVAX_DEBUG
+  evax_debug (1, "evax_object_p(%p)\n", abfd);
+#endif
+  if (bfd_seek (abfd, 0L, SEEK_SET))
+    {
+      bfd_set_error (bfd_error_file_truncated);
+      return 0;
+    }
+
+  prev_type = -1;
+
+  do
+    {
+#if EVAX_DEBUG
+      evax_debug (3, "reading at %08lx\n", bfd_tell(abfd));
+#endif
+      if (_bfd_evax_next_record (abfd) < 0)
+	{
+#if EVAX_DEBUG
+	  evax_debug (2, "next_record failed\n");      
+#endif
+	  bfd_set_error (bfd_error_wrong_format);
+	  return 0;
+	}
+
+      if ((prev_type == EOBJ_S_C_EGSD) && (PRIV(rec_type) != EOBJ_S_C_EGSD))
+	{
+	  if (evax_fixup_sections (abfd) == false)
+	    {
+#if EVAX_DEBUG
+	      evax_debug (2, "evax_fixup_sections failed\n");
+#endif
+	      bfd_set_error (bfd_error_wrong_format);
+	      return 0;
+	    }
+	}
+
+      prev_type = PRIV(rec_type);
+
+      switch (PRIV(rec_type))
+	{
+	  case EOBJ_S_C_EMH:
+	    err = _bfd_evax_slurp_emh (abfd);
+	    break;
+	  case EOBJ_S_C_EEOM:
+	    err = _bfd_evax_slurp_eeom (abfd);
+	    break;
+	  case EOBJ_S_C_EGSD:
+	    err = _bfd_evax_slurp_egsd (abfd);
+	    break;
+	  case EOBJ_S_C_ETIR:
+	    err = _bfd_evax_slurp_etir (abfd);
+	    break;
+	  case EOBJ_S_C_EDBG:
+	    err = _bfd_evax_slurp_edbg (abfd);
+	    break;
+	  case EOBJ_S_C_ETBT:
+	    err = _bfd_evax_slurp_etbt (abfd);
+	    break;
+	  default:
+	    err = -1;
+	}
+      if (err != 0)
+	{
+#if EVAX_DEBUG
+	  evax_debug (2, "slurp type %d failed with %d\n", PRIV(rec_type), err);
+#endif
+	  bfd_set_error (bfd_error_wrong_format);
+	  return 0;
+	}
+    }
+  while (prev_type != EOBJ_S_C_EEOM);
+
+  /* set arch_info to alpha  */
+ 
+  {
+    const bfd_arch_info_type *arch = bfd_scan_arch ("alpha");
+    if (arch == 0)
+      {
+#if EVAX_DEBUG
+	evax_debug (2, "arch not found\n");
+#endif
+	bfd_set_error (bfd_error_wrong_format);
+	return 0;
+      }
+    abfd->arch_info = arch;
+  }
+
+  return &evax_alpha_vec;
+}
+
+
+/* Check the format for a file being read.
+   Return a (bfd_target *) if it's an archive file or zero.  */
+
+static const struct bfd_target *
+evax_archive_p (abfd)
+     bfd *abfd;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_archive_p(%p)\n", abfd);
+#endif
+
+  if (!evax_initialize (abfd))
+    return 0;
+
+  return 0;
+}
+
+
+/* Set the format of a file being written.  */
+
+static boolean
+evax_mkobject (abfd)
+     bfd *abfd;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_mkobject(%p)\n", abfd);
+#endif
+
+  if (!evax_initialize (abfd))
+    return 0;
+
+  {
+    const bfd_arch_info_type *arch = bfd_scan_arch ("alpha");
+    if (arch == 0)
+      {
+	bfd_set_error(bfd_error_wrong_format);
+	return 0;
+      }
+    abfd->arch_info = arch;
+  }
+
+  return true;
+}
+
+
+/* Write cached information into a file being written, at bfd_close.  */
+
+static boolean
+evax_write_object_contents (abfd)
+     bfd *abfd;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_write_object_contents(%p)\n", abfd);
+#endif
+
+  if (abfd->section_count > 0)			/* we have sections */
+    {
+      if (_bfd_evax_write_emh (abfd) != 0)
+	return false;
+      if (_bfd_evax_write_egsd (abfd) != 0)
+	return false;
+      if (_bfd_evax_write_etir (abfd) != 0)
+	return false;
+      if (_bfd_evax_write_etbt (abfd) != 0)
+	return false;
+      if (_bfd_evax_write_eeom (abfd) != 0)
+	return false;
+    }
+  return true;
+}
+
+/*-- 4.1, generic -----------------------------------------------------------*/
+
+/* Called when the BFD is being closed to do any necessary cleanup.  */
+
+static boolean
+evax_close_and_cleanup (abfd)
+     bfd *abfd;
+{
+  asection *sec;
+  evax_section *es, *es1;
+  evax_reloc *er, *er1;
+  int i;
+
+#if EVAX_DEBUG
+  evax_debug (1, "evax_close_and_cleanup(%p)\n", abfd);
+#endif
+  if (abfd == 0)
+    return true;
+
+  if (PRIV(evax_buf) != NULL)
+    {
+      free (PRIV(evax_buf));
+      PRIV(evax_buf) = NULL;
+    }
+  PRIV(buf_size) = 0;
+
+  if (PRIV(filename) != NULL)
+    {
+      free (PRIV(filename));
+      PRIV(filename) = NULL;
+    }
+
+  if (PRIV(output_buf) != 0)
+    {
+      free (PRIV(output_buf));
+      PRIV(output_buf) = 0;
+    }
+
+  sec = abfd->sections;
+  while (sec != NULL)
+    {
+      if (sec->contents)
+	free (sec->contents);
+      sec = sec->next;
+    }
+
+  if (PRIV(sections) != NULL)
+    {
+      free (PRIV(sections));
+      PRIV(sections) = NULL;
+    }
+
+  if (PRIV(evax_symbol_table))
+    {
+      bfd_hash_table_free (PRIV(evax_symbol_table));
+      PRIV(evax_symbol_table) = 0;
+    }
+
+  if (PRIV(stack))
+    {
+      free (PRIV(stack));
+      PRIV(stack) = 0;
+    }
+
+  if (PRIV(location_stack))
+    {
+      free (PRIV(location_stack));
+      PRIV(location_stack) = 0;
+    }
+
+  for (i = 0; i < EVAX_SECTION_COUNT; i++)
+    {
+      es = PRIV(evax_section_table)[i];
+      while (es != NULL)
+	{
+	  es1 = es->next;
+	  free (es);
+	  es = es1;
+	}
+      PRIV(evax_section_table)[i] = NULL;
+
+      er = PRIV(evax_reloc_table)[i];
+      while (er != NULL)
+	{
+	  er1 = er->next;
+	  free (er);
+	  er = er1;
+	}
+      PRIV(evax_reloc_table)[i] = NULL;
+   }
+
+  free (abfd->tdata.any);
+  abfd->tdata.any = NULL;
+
+  return true;
+}
+
+
+/* Ask the BFD to free all cached information.  */
+static boolean
+evax_bfd_free_cached_info (abfd)
+     bfd *abfd;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_bfd_free_cached_info(%p)\n", abfd);
+#endif
+  return true;
+}
+
+
+/* Called when a new section is created.  */
+
+static boolean
+evax_new_section_hook (abfd, section)
+     bfd *abfd;
+     asection *section;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_new_section_hook(%p, %s)\n", abfd, section->name);
+#endif
+  bfd_set_section_alignment(abfd, section, 4);
+  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 boolean
+evax_get_section_contents (abfd, section, buf, offset, buf_size)
+     bfd *abfd;
+     asection *section;
+     PTR buf;
+     file_ptr offset;
+     bfd_size_type buf_size;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_get_section_contents(%p, %s, %p, off %ld, size %d)\n",
+		 abfd, section->name, buf, offset, (int)buf_size);
+#endif
+
+  /* shouldn't be called, since all sections are IN_MEMORY  */
+
+  return false;
+}
+
+/* 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 boolean
+evax_get_section_contents_in_window (abfd, section, w, offset, count)
+     bfd *abfd;
+     asection *section;
+     bfd_window *w;
+     file_ptr offset;
+     bfd_size_type count;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_get_section_contents_in_window(%p, %s, %p, off %ld, count %d)\n",
+		 abfd, section->name, w, offset, (int)count);
+#endif
+
+  /* shouldn't be called, since all sections are IN_MEMORY  */
+
+  return false;
+}
+
+/*-- Part 4.2, copy private data --------------------------------------------*/
+
+/* Called to copy BFD general private data from one object file
+   to another.  */
+
+static boolean
+evax_bfd_copy_private_bfd_data (src, dest)
+     bfd *src;
+     bfd *dest;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_bfd_copy_private_bfd_data(%p, %p)\n", src, dest);
+#endif
+  return true;
+}
+
+
+/* Merge private BFD information from the BFD @var{ibfd} to the
+   the output file BFD @var{obfd} when linking.  Return <<true>>
+   on success, <<false>> on error.  Possible error returns are:
+
+   o <<bfd_error_no_memory>> -
+     Not enough memory exists to create private data for @var{obfd}.  */
+
+static boolean
+evax_bfd_merge_private_bfd_data (ibfd, obfd)
+     bfd *ibfd;
+     bfd *obfd;
+{
+#if EVAX_DEBUG
+  evax_debug (1,"evax_bfd_merge_private_bfd_data(%p, %p)\n", ibfd, obfd);
+#endif
+  return true;
+}
+
+
+/* Set private BFD flag information in the BFD @var{abfd}.
+   Return <<true>> on success, <<false>> on error.  Possible error
+   returns are:
+
+   o <<bfd_error_no_memory>> -
+     Not enough memory exists to create private data for @var{obfd}.  */
+
+static boolean
+evax_bfd_set_private_flags (abfd, flags)
+     bfd *abfd;
+     flagword flags;
+{
+#if EVAX_DEBUG
+  evax_debug (1,"evax_bfd_set_private_flags(%p, %lx)\n", abfd, (long)flags);
+#endif
+  return true;
+}
+
+
+/* Called to copy BFD private section data from one object file
+   to another.  */
+
+static boolean
+evax_bfd_copy_private_section_data (srcbfd, srcsec, dstbfd, dstsec)
+     bfd *srcbfd;
+     asection *srcsec;
+     bfd *dstbfd;
+     asection *dstsec;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_bfd_copy_private_section_data(%p, %s, %p, %s)\n",
+		 srcbfd, srcsec->name, dstbfd, dstsec->name);
+#endif
+  return true;
+}
+
+/* Called to copy BFD private symbol data from one object file
+   to another.  */
+
+static boolean 
+evax_bfd_copy_private_symbol_data (ibfd, isym, obfd, osym)
+     bfd *ibfd;
+     asymbol *isym;
+     bfd *obfd;
+     asymbol *osym;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_bfd_copy_private_symbol_data(%p, %s, %p, %s)\n",
+		 ibfd, isym->name, obfd, osym->name);
+#endif
+  return true;
+}
+
+/*-- Part 4.3, core file ----------------------------------------------------*/
+
+/* Return a read-only string explaining which program was running
+   when it failed and produced the core file abfd.  */
+
+static char *
+evax_core_file_failing_command (abfd)
+     bfd *abfd;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_core_file_failing_command(%p)\n", abfd);
+#endif
+  return 0;
+}
+
+
+/* Returns the signal number which caused the core dump which
+   generated the file the BFD abfd is attached to.  */
+
+static int
+evax_core_file_failing_signal (abfd)
+     bfd *abfd;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_core_file_failing_signal(%p)\n", abfd);
+#endif
+  return 0;
+}
+
+
+/* Return true if the core file attached to core_bfd was generated
+   by a run of the executable file attached to exec_bfd, false otherwise.  */
+
+static boolean
+evax_core_file_matches_executable_p (abfd, bbfd)
+     bfd *abfd;
+     bfd *bbfd;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_core_file_matches_executable_p(%p, %p)\n", abfd, bbfd);
+#endif
+  return false;
+}
+
+/*-- Part 4.4, archive ------------------------------------------------------*/
+
+/* ???	do something with an archive map.
+   Return false on error, true otherwise.  */
+
+static boolean
+evax_slurp_armap (abfd)
+     bfd *abfd;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_slurp_armap(%p)\n", abfd);
+#endif
+  return false;
+}
+
+
+/* ???	do something with an extended name table.
+   Return false on error, true otherwise.  */
+
+static boolean
+evax_slurp_extended_name_table (abfd)
+     bfd *abfd;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_slurp_extended_name_table(%p)\n", abfd);
+#endif
+  return false;
+}
+
+
+/* ???	do something with an extended name table.
+   Return false on error, true otherwise.  */
+
+static boolean
+evax_construct_extended_name_table (abfd, tabloc, tablen, name)
+     bfd *abfd;
+     char **tabloc;
+     bfd_size_type *tablen;
+     const char **name;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_construct_extended_name_table(%p)\n", abfd);
+#endif
+  return false;
+}
+
+
+/* Truncate the name of an archive to match system-dependent restrictions  */
+
+static void
+evax_truncate_arname (abfd, pathname, arhdr)
+     bfd *abfd;
+     CONST char *pathname;
+     char *arhdr;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_truncate_arname(%p, %s, %s)\n", abfd, pathname, arhdr);
+#endif
+  return;
+}
+
+
+/* ???	write archive map  */
+
+static boolean
+evax_write_armap (arch, elength, map, orl_count, stridx)
+     bfd *arch;
+     unsigned int elength;
+     struct orl *map;
+     unsigned int orl_count;
+     int stridx;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_write_armap(%p, %d, %p, %d %d)\n",
+	arch, elength, map, orl_count, stridx);
+#endif
+  return true;
+}
+
+/* Read archive header ???  */
+
+static PTR
+evax_read_ar_hdr (abfd)
+    bfd * abfd;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_read_ar_hdr(%p)\n", abfd);
+#endif
+  return (PTR)0;
+}
+
+
+/* Provided a BFD, @var{archive}, containing an archive and NULL, open
+   an input BFD on the first contained element and returns that.
+   Subsequent calls should pass the archive and the previous return value
+   to return a created BFD to the next contained element.
+   NULL is returned when there are no more.  */
+
+static bfd *
+evax_openr_next_archived_file (arch, prev)
+     bfd *arch;
+     bfd *prev;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_openr_next_archived_file(%p, %p)\n", arch, prev);
+#endif
+  return false;
+}
+
+
+/* Return the BFD which is referenced by the symbol in ABFD indexed by
+   INDEX.  INDEX should have been returned by bfd_get_next_mapent.  */
+
+static bfd *
+evax_get_elt_at_index (abfd, index)
+     bfd *abfd;
+     symindex index;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_get_elt_at_index(%p, %p)\n", abfd, index);
+#endif
+  return _bfd_generic_get_elt_at_index(abfd, index);
+}
+
+
+/* ???
+   -> bfd_generic_stat_arch_elt  */
+
+static int
+evax_generic_stat_arch_elt (abfd, stat)
+     bfd *abfd;
+     struct stat *stat;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_generic_stat_arch_elt(%p, %p)\n", abfd, stat);
+#endif
+  return bfd_generic_stat_arch_elt(abfd, stat);
+}
+
+
+/* This is a new function in bfd 2.5  */
+
+static boolean
+evax_update_armap_timestamp (abfd)
+     bfd *abfd;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_update_armap_timestamp(%p)\n", abfd);
+#endif
+  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
+evax_get_symtab_upper_bound (abfd)
+     bfd *abfd;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_get_symtab_upper_bound(%p), %d symbols\n", abfd, PRIV(egsd_sym_count));
+#endif
+  return (PRIV(egsd_sym_count)+1) * sizeof(asymbol *);
+}
+
+
+/* Copy symbols from hash table to symbol vector
+
+   called from bfd_hash_traverse in evax_get_symtab
+   init counter to 0 if entry == 0  */
+
+static boolean
+copy_symbols (entry, arg)
+     struct bfd_hash_entry *entry;
+     PTR arg;
+{
+  bfd *abfd = (bfd *) arg;
+
+  if (entry == NULL)	/* init counter */
+    PRIV(symnum) = 0;
+  else			/* fill vector, inc counter */
+    PRIV(symcache)[PRIV(symnum)++] = ((evax_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 # of symbols read  */
+
+static long
+evax_get_symtab (abfd, symbols)
+     bfd *abfd;
+     asymbol **symbols;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_get_symtab(%p, <ret>)\n", abfd);
+#endif
+
+	/* init counter */
+  (void)copy_symbols((struct bfd_hash_entry *)0, abfd);
+
+	/* traverse table and fill symbols vector */
+
+  PRIV(symcache) = symbols;
+  bfd_hash_traverse(PRIV(evax_symbol_table), copy_symbols, (PTR)abfd);
+
+  symbols[bfd_get_symcount(abfd)] = NULL;
+
+  return bfd_get_symcount(abfd);
+}
+
+
+/* Create a new asymbol structure for the BFD abfd and return a pointer
+   to it.
+   This routine is necessary because each back end has private information
+   surrounding the asymbol. Building your own asymbol and pointing to it
+   will not create the private information, and will cause problems later on.  */
+
+asymbol *
+_bfd_evax_make_empty_symbol (abfd)
+     bfd *abfd;
+{
+  asymbol *symbol = (asymbol *)bfd_zalloc(abfd, sizeof(asymbol));
+
+#if EVAX_DEBUG
+  evax_debug (1, "_bfd_evax_make_empty_symbol(%p)\n", abfd);
+#endif
+
+  if (symbol == 0)
+    {
+      bfd_set_error (bfd_error_no_memory);
+      return 0;
+    }
+  symbol->the_bfd = abfd;
+
+  return symbol;
+}
+
+
+/* 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
+evax_print_symbol (abfd, file, symbol, how)
+     bfd *abfd;
+     PTR file;
+     asymbol *symbol;
+     bfd_print_symbol_type how;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_print_symbol(%p, %p, %p, %d)\n", abfd, file, symbol, how);
+#endif
+
+  switch (how)
+    {
+      case bfd_print_symbol_name:
+      case bfd_print_symbol_more:
+	fprintf((FILE *)file," %s", symbol->name);
+      break;
+
+      break;
+
+      case bfd_print_symbol_all:
+	{
+	  CONST char *section_name = symbol->section->name;
+
+	  bfd_print_symbol_vandf((PTR)file,symbol);
+
+	  fprintf((FILE *)file," %-8s %s", section_name, symbol->name);
+        }
+      break;
+    }
+  return;
+}
+
+
+/* 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
+evax_get_symbol_info (abfd, symbol, ret)
+     bfd *abfd;
+     asymbol *symbol;
+     symbol_info *ret;
+{
+  asection *sec;
+
+#if EVAX_DEBUG
+  evax_debug (1, "evax_get_symbol_info(%p, %p, <ret>)\n", abfd, symbol);
+#endif
+
+  sec = symbol->section;
+
+  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_abs_section (sec))
+    ret->type = 'A';
+  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;
+}
+
+
+/* Return true if the given symbol sym in the BFD abfd is
+   a compiler generated local label, else return false.  */
+
+static boolean
+evax_bfd_is_local_label (abfd, symbol)
+     bfd *abfd;
+     asymbol *symbol;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_bfd_is_local_label(%p, %p)\n", abfd, symbol);
+#endif
+  return false;
+}
+
+
+/* Get source line number for symbol  */
+
+static alent *
+evax_get_lineno (abfd, symbol)
+     bfd *abfd;
+     asymbol *symbol;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_get_lineno(%p, %p)\n", abfd, symbol);
+#endif
+  return 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 boolean
+evax_find_nearest_line (abfd, section, symbols, offset, file, func, line)
+     bfd *abfd;
+     asection *section;
+     asymbol **symbols;
+     bfd_vma offset;
+     CONST char **file;
+     CONST char **func;
+     unsigned int *line;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_find_nearest_line(%p, %s, %p, %ld, <ret>, <ret>, <ret>)\n",
+	      abfd, section->name, symbols, (long int)offset);
+#endif
+  return false;
+}
+
+
+/* Back-door to allow format-aware applications to create debug symbols
+   while using BFD for everything else.  Currently used by the assembler
+   when creating COFF files.  */
+
+static asymbol *
+evax_bfd_make_debug_symbol (abfd, ptr, size)
+     bfd *abfd;
+     void *ptr;
+     unsigned long size;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_bfd_make_debug_symbol(%p, %p, %ld)\n", abfd, ptr, size);
+#endif
+  return 0;
+}
+
+
+/* Read minisymbols.  For minisymbols, we use the unmodified a.out
+   symbols.  The minisymbol_to_symbol function translates these into
+   BFD asymbol structures.  */
+
+static long
+evax_read_minisymbols (abfd, dynamic, minisymsp, sizep)
+     bfd *abfd;
+     boolean dynamic;
+     PTR *minisymsp;
+     unsigned int *sizep;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_read_minisymbols(%p, %d, %p, %d)\n", abfd, dynamic, minisymsp, *sizep);
+#endif
+  return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep);
+}
+
+/* Convert a minisymbol to a BFD asymbol.  A minisymbol is just an
+   unmodified a.out symbol.  The SYM argument is a structure returned
+   by bfd_make_empty_symbol, which we fill in here.  */
+
+static asymbol *
+evax_minisymbol_to_symbol (abfd, dynamic, minisym, sym)
+     bfd *abfd;
+     boolean dynamic;
+     const PTR minisym;
+     asymbol *sym;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_minisymbol_to_symbol(%p, %d, %p, %p)\n", abfd, dynamic, minisym, sym);
+#endif
+  return _bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym);
+}
+
+/*-- Part 4.6, relocations --------------------------------------------------*/
+
+/* Return the number of bytes required to store the relocation information
+   associated with section sect attached to bfd abfd.
+   If an error occurs, return -1.  */
+
+static long
+evax_get_reloc_upper_bound (abfd, section)
+     bfd *abfd;
+     asection *section;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_get_reloc_upper_bound(%p, %s)\n", abfd, section->name);
+#endif
+  return -1L;
+}
+
+
+/* Call the back end associated with the open BFD abfd and translate the
+   external form of the relocation information attached to sec into the
+   internal canonical form.  Place the table into memory at loc, which has
+   been preallocated, usually by a call to bfd_get_reloc_upper_bound.
+   Returns the number of relocs, or -1 on error.  */
+
+static long
+evax_canonicalize_reloc (abfd, section, location, symbols)
+     bfd *abfd;
+     asection *section;
+     arelent **location;
+     asymbol **symbols;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_canonicalize_reloc(%p, %s, <ret>, <ret>)\n", abfd, section->name);
+#endif
+  return false;
+}
+
+/*---------------------------------------------------------------------------*/
+/* 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 (abfd, reloc, sym, data, sec, output_bfd, error_message)
+     bfd *abfd;
+     arelent *reloc;
+     asymbol *sym;
+     PTR data;
+     asection *sec;
+     bfd *output_bfd;
+     char **error_message;
+{
+  evax_reloc *er;
+
+#if EVAX_DEBUG
+  evax_debug (1, "reloc_nil(abfd %p, output_bfd %p)\n", abfd, output_bfd);
+  evax_debug (2, "In section %s, symbol %s\n",
+	sec->name, sym->name);
+  evax_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);
+  evax_debug (2, "data at %p\n", data);
+/*  _bfd_hexdump (2, data, bfd_get_reloc_size(reloc->howto),0); */
+#endif
+
+  er = (evax_reloc *)malloc (sizeof(evax_reloc));
+  if (er == NULL)
+    {
+      bfd_set_error (bfd_error_no_memory);
+      return bfd_reloc_notsupported;	/* FIXME */
+    }
+  er->section = sec;
+  er->reloc = reloc;
+  er->next = NULL;
+  if (PRIV(evax_reloc_table)[sec->index] == NULL)
+    {
+      PRIV(evax_reloc_table)[sec->index] = er;
+    }
+  else
+    {
+      er->next = PRIV(evax_reloc_table)[sec->index];
+    }
+  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,			/* src_mask */
+	 0,			/* dst_mask */
+	 true),			/* pcrel_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,		/* src_mask */
+	 MINUS_ONE,		/* dst_mask */
+	 false),		/* pcrel_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,		/* src_mask */
+	 0x1fffff,		/* dst_mask */
+	 false),		/* pcrel_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,		/* src_mask */
+	 0x3fff,		/* dst_mask */
+	 false),		/* pcrel_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,		/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_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,		/* src_mask */
+	 0xffffffff,		/* dst_mask */
+	 false),		/* pcrel_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,		/* src_mask */
+	 MINUS_ONE,		/* dst_mask */
+	 false),		/* pcrel_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,			/* src_mask */
+	 0,			/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Store the value from the stack at the given address.  Store it in
+     a bitfield of size r_size starting at bit position r_offset.  */
+  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,			/* src_mask */
+	 MINUS_ONE,		/* dst_mask */
+	 false),		/* pcrel_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,			/* src_mask */
+	 0,			/* dst_mask */
+	 false),		/* pcrel_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,			/* src_mask */
+	 0,			/* dst_mask */
+	 false),		/* pcrel_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,			/* src_mask */
+	 0,			/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Switch table, 32bit relocation.  */
+  HOWTO (ALPHA_R_SWREL32,	/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 reloc_nil,		/* special_function */
+	 "SWREL32",		/* name */
+	 false,			/* partial_inplace */
+	 0xffffffff,		/* src_mask */
+	 0xffffffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Switch table, 64bit relocation.  */
+  HOWTO (ALPHA_R_SWREL64,	/* 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 */
+	 "SWREL64",		/* name */
+	 false,			/* partial_inplace */
+	 MINUS_ONE,		/* src_mask */
+	 MINUS_ONE,		/* dst_mask */
+	 false),			/* pcrel_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,		/* src_mask */
+	 0xffffffff,		/* dst_mask */
+	 false),		/* pcrel_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 *
+evax_bfd_reloc_type_lookup (abfd, code)
+     bfd *abfd;
+     bfd_reloc_code_real_type code;
+{
+  int alpha_type;
+
+#if EVAX_DEBUG
+  evax_debug (1, "evax_bfd_reloc_type_lookup(%p, %d)\t", abfd, code);
+#endif
+
+  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_SWREL32:		alpha_type = ALPHA_R_SWREL32;	break;
+      case BFD_RELOC_SWREL64:		alpha_type = ALPHA_R_SWREL64;	break;
+#if 0
+      case ???:				alpha_type = ALPHA_R_OP_PUSH;	break;
+      case ???:				alpha_type = ALPHA_R_OP_STORE;	break;
+      case ???:				alpha_type = ALPHA_R_OP_PSUB;	break;
+      case ???:				alpha_type = ALPHA_R_OP_PRSHIFT;break;
+      case ???:				alpha_type = ALPHA_R_GPVALUE;	break;
+#endif
+      default:
+	(*_bfd_error_handler) ("reloc (%d) is *UNKNOWN*", code);
+	return (const struct reloc_howto_struct *) NULL;
+    }
+#if EVAX_DEBUG
+  evax_debug (2, "reloc is %s\n", alpha_howto_table[alpha_type].name);
+#endif
+  return &alpha_howto_table[alpha_type];
+}
+
+
+/*-- 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 boolean
+evax_set_arch_mach (abfd, arch, mach)
+     bfd *abfd;
+     enum bfd_architecture arch;
+     unsigned long mach;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_set_arch_mach(%p, %d, %ld)\n", abfd, arch, mach);
+#endif
+  abfd->arch_info = bfd_scan_arch("alpha");
+
+  return true;
+}
+
+
+/* Sets the contents of the section section in BFD abfd to the data starting
+   in memory at data. 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 boolean
+evax_set_section_contents (abfd, section, location, offset, count)
+     bfd *abfd;
+     asection *section;
+     PTR location;
+     file_ptr offset;
+     bfd_size_type count;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_set_section_contents(%p, sec %s, loc %p, off %ld, count %d)\n",
+					abfd, section->name, location, (long int)offset, (int)count);
+#endif
+  return _bfd_save_evax_section(abfd, section, location, offset, count);
+}
+
+
+/*-- Part 4.8, linker -------------------------------------------------------*/
+
+/* Get the size of the section headers.  */
+
+static int
+evax_sizeof_headers (abfd, reloc)
+     bfd *abfd;
+     boolean reloc;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_sizeof_headers(%p, %s)\n", abfd, (reloc)?"True":"False");
+#endif
+  return 0;
+}
+
+
+/* Provides default handling of relocation effort for back ends
+   which can't be bothered to do it efficiently.  */
+
+static bfd_byte *
+evax_bfd_get_relocated_section_contents (abfd, link_info, link_order, data,
+					 relocateable, symbols)
+     bfd *abfd;
+     struct bfd_link_info *link_info;
+     struct bfd_link_order *link_order;
+     bfd_byte *data;
+     boolean relocateable;
+     asymbol **symbols;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_bfd_get_relocated_section_contents(%p, %p, %p, %p, %s, %p)\n",
+			abfd, link_info, link_order, data, (relocateable)?"True":"False", symbols);
+#endif
+  return 0;
+}
+
+
+/* ???  */
+
+static boolean
+evax_bfd_relax_section (abfd, section, link_info, again)
+     bfd *abfd;
+     asection *section;
+     struct bfd_link_info *link_info;
+     boolean *again;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_bfd_relax_section(%p, %s, %p, <ret>)\n",
+					abfd, section->name, link_info);
+#endif
+  return true;
+}
+
+
+/* Create a hash table for the linker.  Different backends store
+   different information in this table.  */
+
+static struct bfd_link_hash_table *
+evax_bfd_link_hash_table_create (abfd)
+     bfd *abfd;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_bfd_link_hash_table_create(%p)\n", abfd);
+#endif
+  return 0;
+}
+
+
+/* Add symbols from this object file into the hash table.  */
+
+static boolean
+evax_bfd_link_add_symbols (abfd, link_info)
+     bfd *abfd;
+     struct bfd_link_info *link_info;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_bfd_link_add_symbols(%p, %p)\n", abfd, link_info);
+#endif
+  return false;
+}
+
+
+/* Do a link based on the link_order structures attached to each
+   section of the BFD.  */
+
+static boolean
+evax_bfd_final_link (abfd, link_info)
+     bfd *abfd;
+     struct bfd_link_info *link_info;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_bfd_final_link(%p, %p)\n", abfd, link_info);
+#endif
+  return true;
+}
+
+/* Should this section be split up into smaller pieces during linking.  */
+
+static boolean
+evax_bfd_link_split_section (abfd, section)
+     bfd *abfd;
+     asection *section;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_bfd_link_split_section(%p, %s)\n", abfd, section->name);
+#endif
+  return false;
+}
+
+/*-- Part 4.9, dynamic symbols and relocations ------------------------------*/
+
+/* Get the amount of memory required to hold the dynamic symbols.  */
+
+static long
+evax_get_dynamic_symtab_upper_bound (abfd)
+     bfd *abfd;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_get_dynamic_symtab_upper_bound(%p)\n", abfd);
+#endif
+  return 0;
+}
+
+static boolean
+evax_bfd_print_private_bfd_data (abfd, file)
+    bfd *abfd;
+    void *file;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_bfd_print_private_bfd_data(%p)\n", abfd);
+#endif
+  return 0;
+}
+
+
+/* Read in the dynamic symbols.  */
+
+static long
+evax_canonicalize_dynamic_symtab (abfd, symbols)
+     bfd *abfd;
+     asymbol **symbols;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_canonicalize_dynamic_symtab(%p, <ret>)\n", abfd);
+#endif
+  return 0L;
+}
+
+
+/* Get the amount of memory required to hold the dynamic relocs.  */
+
+static long
+evax_get_dynamic_reloc_upper_bound (abfd)
+     bfd *abfd;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_get_dynamic_reloc_upper_bound(%p)\n", abfd);
+#endif
+  return 0L;
+}
+
+
+/* Read in the dynamic relocs.  */
+
+static long
+evax_canonicalize_dynamic_reloc (abfd, arel, symbols)
+     bfd *abfd;
+     arelent **arel;
+     asymbol **symbols;
+{
+#if EVAX_DEBUG
+  evax_debug (1, "evax_canonicalize_dynamic_reloc(%p)\n", abfd);
+#endif
+  return 0L;
+}
diff --git a/bfd/evax-egsd.c b/bfd/evax-egsd.c
new file mode 100644
index 0000000..b1394f1
--- /dev/null
+++ b/bfd/evax-egsd.c
@@ -0,0 +1,583 @@
+/* evax-egsd.c -- BFD back-end for ALPHA EVAX (openVMS/AXP) files.
+   Copyright 1996 Free Software Foundation Inc.
+
+   go and read the openVMS linker manual (esp. appendix B)
+   if you don't know what's going on here :-)
+
+   Written by Klaus Kämpf (kkaempf@progis.de)
+   of proGIS Softwareentwicklung, Aachen, Germany
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+
+#include <stdio.h>
+#include <ctype.h>
+
+#include "bfd.h"
+#include "sysdep.h"
+#include "bfdlink.h"
+#include "libbfd.h"
+
+#include "evax.h"
+
+/*-----------------------------------------------------------------------------*/
+
+/* sections every evax object file has  */
+
+#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_READONLY_NAME	"$READONLY$"
+#define EVAX_LITERAL_NAME	"$LITERAL$"
+
+struct sec_flags_struct {
+  char *name;			/* name of section */
+  int eflags_always;
+  flagword flags_always;	/* flags we set always */
+  int eflags_hassize;
+  flagword flags_hassize;	/* flags we set if the section has a size > 0 */
+};
+
+/* just a dummy flag array since i don't understand it yet  */
+
+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_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),
+	(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_READONLY_NAME,
+	(EGPS_S_V_PIC|EGPS_S_V_REL|EGPS_S_V_SHR|EGPS_S_V_RD),
+	(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_LITERAL_NAME,
+	(EGPS_S_V_PIC|EGPS_S_V_REL|EGPS_S_V_SHR|EGPS_S_V_RD),
+	(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) },
+  { 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
+evax_secflag_by_name(name, size)
+     char *name;
+     int size;
+{
+  int i = 0;
+
+  while (evax_section_flags[i].name != NULL)
+    {
+      if (strcmp (name, evax_section_flags[i].name) == 0)
+	{
+	  if (size > 0)
+	    return evax_section_flags[i].flags_hassize;
+	  else
+	    return evax_section_flags[i].flags_always;
+	}
+      i++;
+    }
+  if (size > 0)
+    return evax_section_flags[i].flags_hassize;
+  return evax_section_flags[i].flags_always;
+}
+
+
+/* Retrieve evax section flags by name and size  */
+
+static flagword
+evax_esecflag_by_name(name, size)
+     char *name;
+     int size;
+{
+  int i = 0;
+
+  while (evax_section_flags[i].name != NULL)
+    {
+      if (strcmp (name, evax_section_flags[i].name) == 0)
+	{
+	  if (size > 0)
+	    return evax_section_flags[i].eflags_hassize;
+	  else
+	    return evax_section_flags[i].eflags_always;
+	}
+      i++;
+    }
+  if (size > 0)
+    return evax_section_flags[i].eflags_hassize;
+  return evax_section_flags[i].eflags_always;
+}
+
+/*-----------------------------------------------------------------------------*/
+#if EVAX_DEBUG
+/* debug */
+
+struct flagdescstruct { char *name; flagword value; };
+
+/* Convert flag to printable string  */
+
+static char *
+flag2str(flagdesc, flags)
+     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 */
+
+/* Process EGSD record
+   return 0 on success, -1 on error  */
+
+int
+_bfd_evax_slurp_egsd (abfd)
+     bfd *abfd;
+{
+#if EVAX_DEBUG
+  static struct flagdescstruct gpsflagdesc[] =
+  {
+    { "PIC", 0x0001 },
+    { "LIB", 0x0002 },
+    { "OVR", 0x0004 },
+    { "REL", 0x0008 },
+    { "GBL", 0x0010 },
+    { "SHR", 0x0020 },
+    { "EXE", 0x0040 },
+    { "RD",  0x0080 },
+    { "WRT", 0x0100 },
+    { "VEC", 0x0200 },
+    { "NOMOD", 0x0400 },
+    { "COM", 0x0800 },
+    { NULL, 0 }
+  };
+
+  static struct flagdescstruct gsyflagdesc[] =
+  {
+    { "WEAK", 0x0001 },
+    { "DEF",  0x0002 },
+    { "UNI",  0x0004 },
+    { "REL",  0x0008 },
+    { "COMM", 0x0010 },
+    { "VECEP", 0x0020 },
+    { "NORM", 0x0040 },
+    { NULL, 0 }
+  };
+#endif
+
+  int gsd_type, gsd_size;
+  asection *section;
+  unsigned char *evax_rec;
+  flagword new_flags, old_flags;
+  char *name;
+  asymbol *symbol;
+  evax_symbol_entry *entry;
+  unsigned long base_addr;
+  unsigned long align_addr;
+
+#if EVAX_DEBUG
+  evax_debug (2, "EGSD\n");
+#endif
+
+  PRIV(evax_rec) += 8;	/* skip type, size, l_temp */
+  PRIV(rec_size) -= 8;
+
+  /* calculate base address for each section  */
+  base_addr = 0L;
+
+  abfd->symcount = 0;
+
+  while (PRIV(rec_size) > 0)
+    {
+      evax_rec = PRIV(evax_rec);
+      _bfd_evax_get_header_values (abfd, evax_rec, &gsd_type, &gsd_size);
+      switch (gsd_type)
+	{
+	case EGSD_S_C_PSC:
+	  {
+	    /* program section definition  */
+
+	    name = _bfd_evax_save_counted_string ((char *)evax_rec+12);
+	    section = bfd_make_section (abfd, name);
+	    if (!section)
+	      return -1;
+	    old_flags = bfd_getl16 (evax_rec + 6);
+	    section->_raw_size = bfd_getl32 (evax_rec + 8);	/* allocation */
+	    new_flags = evax_secflag_by_name (name, section->_raw_size);
+	    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 = evax_rec[4];
+	    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->_raw_size;	/* FIXME: should be cooked size */
+	    section->contents = (unsigned char *) malloc (section->_raw_size);
+	    if (section->contents == NULL)
+	      {
+		bfd_set_error (bfd_error_no_memory);
+		return -1;
+	      }
+	    memset (section->contents, 0, section->_raw_size);
+#if EVAX_DEBUG
+	    evax_debug(3, "egsd psc %d (%s, flags %04x=%s) ",
+		       section->index, name, old_flags, flag2str(gpsflagdesc, old_flags));
+	    evax_debug(3, "%d bytes at 0x%08lx (mem %p)\n",
+		       section->_raw_size, section->vma, section->contents);
+#endif
+	  }
+	  break;
+
+	case EGSD_S_C_SYM:
+	  {
+	    /* symbol specification (definition or reference)  */
+
+            symbol = _bfd_evax_make_empty_symbol (abfd);
+            if (symbol == 0)
+              return -1;
+
+	    old_flags = bfd_getl16 (evax_rec + 6);
+	    new_flags = BSF_NO_FLAGS;
+
+	    if (old_flags & EGSY_S_V_WEAK)
+	      new_flags |= BSF_WEAK;
+
+	    if (evax_rec[6] & EGSY_S_V_DEF)	/* symbol definition */
+	      {
+		symbol->name =
+		  _bfd_evax_save_counted_string ((char *)evax_rec+32);
+		if (old_flags & EGSY_S_V_NORM)
+		  {         /* proc def */
+		    new_flags |= BSF_FUNCTION;
+		  }
+		symbol->value = bfd_getl64 (evax_rec+8);
+		symbol->section = (asection *)((unsigned long) bfd_getl32 (evax_rec+28));
+#if EVAX_DEBUG
+		evax_debug(3, "egsd sym def #%d (%s, %d, %04x=%s)\n", abfd->symcount,
+			   symbol->name, (int)symbol->section, old_flags, flag2str(gsyflagdesc, old_flags));
+#endif
+	      }
+	    else	/* symbol reference */
+	      {
+#if EVAX_DEBUG
+		evax_debug(3, "egsd sym ref #%d (%s, %04x=%s)\n", abfd->symcount, evax_rec+9, old_flags, flag2str(gsyflagdesc, old_flags));
+#endif
+                symbol->name =
+		  _bfd_evax_save_counted_string ((char *)evax_rec+8);
+                symbol->section = bfd_make_section (abfd, BFD_UND_SECTION_NAME);
+	      }
+
+	    symbol->flags = new_flags;
+
+	    /* save symbol in evax_symbol_table  */
+
+            entry = (evax_symbol_entry *) bfd_hash_lookup (PRIV(evax_symbol_table), symbol->name, true, false);
+	    if (entry == (evax_symbol_entry *)NULL)
+	      {
+		bfd_set_error (bfd_error_no_memory);
+		return -1;
+	      }
+	    if (entry->symbol != (asymbol *)NULL)
+	      {					/* FIXME ?, DEC C generates this */
+#if EVAX_DEBUG
+		evax_debug(3, "EGSD_S_C_SYM: duplicate \"%s\"\n", symbol->name);
+#endif
+	      }
+	    else
+	      {
+		entry->symbol = symbol;
+		PRIV(egsd_sym_count)++;
+		abfd->symcount++;
+	      }
+	  }
+	  break;
+
+	case EGSD_S_C_IDC:
+	  break;
+
+	default:
+	  (*_bfd_error_handler) ("unknown egsd subtype %d", gsd_type);
+	  bfd_set_error (bfd_error_bad_value);
+	  return -1;
+
+	} /* switch */
+
+      PRIV(rec_size) -= gsd_size;
+      PRIV(evax_rec) += gsd_size;
+
+    } /* while (recsize > 0) */
+
+  if (abfd->symcount > 0)
+    abfd->flags |= HAS_SYMS;
+
+  return 0;
+}
+
+/*-----------------------------------------------------------------------------*/
+/* output routines */
+
+/* Write section and symbol directory of bfd abfd  */
+
+int
+_bfd_evax_write_egsd (abfd)
+     bfd *abfd;
+{
+  asection *section;
+  asymbol *symbol;
+  int symnum;
+  int last_index = -1;
+  char dummy_name[10];
+  char *sname;
+  flagword new_flags, old_flags;
+  char uname[200];
+  char *nptr, *uptr;
+
+#if EVAX_DEBUG
+  evax_debug (2, "evax_write_egsd(%p)\n", abfd);
+#endif
+
+  /* output sections  */
+
+  section = abfd->sections;
+#if EVAX_DEBUG
+  evax_debug (3, "%d sections found\n", abfd->section_count);
+#endif
+
+  /* egsd is quadword aligned  */
+
+  _bfd_evax_output_alignment (abfd, 8);
+
+  _bfd_evax_output_begin (abfd, EOBJ_S_C_EGSD, -1);
+  _bfd_evax_output_long (abfd, 0);
+  _bfd_evax_output_push (abfd);		/* prepare output for subrecords */
+
+  while (section != 0)
+    {
+#if EVAX_DEBUG
+  evax_debug (3, "Section #%d %s, %d bytes\n", section->index, section->name, (int)section->_raw_size);
+#endif
+
+	/* 13 bytes egsd, max 31 chars name -> should be 44 bytes */
+      if (_bfd_evax_output_check (abfd, 64) < 0)
+	{
+	  _bfd_evax_output_pop (abfd);
+	  _bfd_evax_output_end (abfd);
+	  _bfd_evax_output_begin (abfd, EOBJ_S_C_EGSD, -1);
+	  _bfd_evax_output_long (abfd, 0);
+	  _bfd_evax_output_push (abfd);		/* prepare output for subrecords */
+	}
+
+	/* Create dummy sections to keep consecutive indices */
+
+      while (section->index - last_index > 1)
+	{
+#if EVAX_DEBUG
+	  evax_debug (3, "index %d, last %d\n", section->index, last_index);
+#endif
+	  _bfd_evax_output_begin (abfd, EGSD_S_C_PSC, -1);
+	  _bfd_evax_output_short (abfd, 0);
+	  _bfd_evax_output_short (abfd, 0);
+	  _bfd_evax_output_long (abfd, 0);
+	  sprintf (dummy_name, ".DUMMY%02d", last_index);
+	  _bfd_evax_output_counted (abfd, dummy_name);
+	  _bfd_evax_output_flush (abfd);
+	  last_index++;
+	}
+
+      /* Don't know if this is neccesary for the linker but for now it keeps
+	 evax_slurp_egsd 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;
+	}
+
+      _bfd_evax_output_begin (abfd, EGSD_S_C_PSC, -1);
+      _bfd_evax_output_short (abfd, section->alignment_power & 0xff);
+      _bfd_evax_output_short (abfd,
+			      evax_esecflag_by_name (sname,
+						     section->_raw_size));
+      _bfd_evax_output_long (abfd, section->_raw_size);
+      _bfd_evax_output_counted (abfd, sname);
+      _bfd_evax_output_flush (abfd);
+
+      last_index = section->index;
+      section = section->next;
+    }
+
+  /* output symbols  */
+
+#if EVAX_DEBUG
+  evax_debug (3, "%d symbols found\n", abfd->symcount);
+#endif
+
+  bfd_set_start_address (abfd, (bfd_vma)-1);
+
+  for (symnum = 0; symnum < abfd->symcount; symnum++)
+    {
+
+      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_GLOBAL) == 0)		/* not xdef */
+	  && (!bfd_is_und_section (symbol->section)))	/* and not xref */
+	continue;					/* dont output */
+
+      /* 13 bytes egsd, max 64 chars name -> should be 77 bytes  */
+
+      if (_bfd_evax_output_check (abfd, 80) < 0)
+	{
+	  _bfd_evax_output_pop (abfd);
+	  _bfd_evax_output_end (abfd);
+	  _bfd_evax_output_begin (abfd, EOBJ_S_C_EGSD, -1);
+	  _bfd_evax_output_long (abfd, 0);
+	  _bfd_evax_output_push (abfd);		/* prepare output for subrecords */
+	}
+
+      _bfd_evax_output_begin (abfd, EGSD_S_C_SYM, -1);
+
+      _bfd_evax_output_short (abfd, 0);			/* data type, alignment */
+
+      new_flags = 0;
+      if (old_flags & BSF_WEAK)
+	new_flags |= EGSY_S_V_WEAK;
+      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_evax_output_short (abfd, new_flags);
+
+      if (old_flags & BSF_GLOBAL)			/* symbol definition */
+	{
+	  if (old_flags & BSF_FUNCTION)
+	    {
+	      _bfd_evax_output_quad (abfd, symbol->value);
+	      _bfd_evax_output_quad (abfd,
+				     ((asymbol *)(symbol->udata.p))->value);
+	      _bfd_evax_output_long (abfd,
+				     (((asymbol *)(symbol->udata.p))
+				      ->section->index));
+	      _bfd_evax_output_long (abfd, symbol->section->index);
+	    }
+	  else
+	    {
+	      _bfd_evax_output_quad (abfd, symbol->value);	/* L_VALUE */
+	      _bfd_evax_output_quad (abfd, 0);			/* L_CODE_ADDRESS */
+	      _bfd_evax_output_long (abfd, 0);			/* L_CA_PSINDX */
+	      _bfd_evax_output_long (abfd, symbol->section->index);/* L_PSINDX, FIXME */
+	    }
+	}
+      if (strlen ((char *)symbol->name) > 198)
+	{
+	  (*_bfd_error_handler) ("Name '%s' too long\n", symbol->name);
+	  abort ();
+	}
+      nptr = (char *)symbol->name;
+      uptr = uname;
+      while (*nptr)
+	{
+	  if (islower (*nptr))
+	    *uptr = toupper (*nptr);
+	  else
+	    *uptr = *nptr;
+	  uptr++;
+	  nptr++;
+	}
+      *uptr = 0;
+      _bfd_evax_output_counted (abfd, uname);
+
+      _bfd_evax_output_flush (abfd);
+
+    }
+
+  _bfd_evax_output_alignment (abfd, 8);
+  _bfd_evax_output_pop (abfd);
+  _bfd_evax_output_end (abfd); 
+
+  return 0;
+}
diff --git a/bfd/evax-emh.c b/bfd/evax-emh.c
new file mode 100644
index 0000000..7151938
--- /dev/null
+++ b/bfd/evax-emh.c
@@ -0,0 +1,288 @@
+/* evax-emh.c -- BFD back-end for ALPHA EVAX (openVMS/AXP) files.
+   Copyright 1996 Free Software Foundation, Inc.
+
+   EMH record handling functions
+   and
+   EEOM record handling functions
+
+   Written by Klaus Kämpf (kkaempf@progis.de)
+   of proGIS Softwareentwicklung, Aachen, Germany
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#include <stdio.h>
+
+#include "bfd.h"
+#include "sysdep.h"
+#include "bfdlink.h"
+#include "libbfd.h"
+
+#include "evax.h"
+
+/*---------------------------------------------------------------------------*/
+
+
+/* Read & process emh record
+   return 0 on success, -1 on error  */
+
+int
+_bfd_evax_slurp_emh (abfd)
+     bfd *abfd;
+{
+  unsigned char *ptr;
+  unsigned char *evax_rec;
+
+  evax_rec = PRIV(evax_rec);
+
+#if EVAX_DEBUG
+  evax_debug(2, "EMH\n");
+#endif
+
+  switch (bfd_getl16 (evax_rec + 4))
+    {
+
+      case EMH_S_C_MHD:
+	/*
+	 * module header
+	 */
+	PRIV(emh_data).emh_b_strlvl = evax_rec[6];
+	PRIV(emh_data).emh_l_arch1 = bfd_getl32 (evax_rec + 8);
+	PRIV(emh_data).emh_l_arch2 = bfd_getl32 (evax_rec + 12);
+	PRIV(emh_data).emh_l_recsiz = bfd_getl32 (evax_rec + 16);
+	PRIV(emh_data).emh_t_name =
+	  _bfd_evax_save_counted_string ((char *)evax_rec + 20);
+	ptr = evax_rec + 20 + evax_rec[20] + 1;
+	PRIV(emh_data).emh_t_version =
+	  _bfd_evax_save_counted_string ((char *)ptr);
+	ptr += *ptr + 1;
+	PRIV(emh_data).emh_t_date =
+	  _bfd_evax_save_sized_string ((char *)ptr, 17);
+
+      break;
+
+      case EMH_S_C_LNM:
+	/*
+	 *
+	 */
+	PRIV(emh_data).emh_c_lnm =
+	  _bfd_evax_save_sized_string ((char *)evax_rec, PRIV(rec_length-6));
+      break;
+
+      case EMH_S_C_SRC:
+	/*
+	 *
+	 */
+	PRIV(emh_data).emh_c_src =
+	  _bfd_evax_save_sized_string ((char *)evax_rec, PRIV(rec_length-6));
+      break;
+
+      case EMH_S_C_TTL:
+	/*
+	 *
+	 */
+	PRIV(emh_data).emh_c_ttl =
+	  _bfd_evax_save_sized_string ((char *)evax_rec, PRIV(rec_length-6));
+      break;
+
+      case EMH_S_C_CPR:
+	/*
+	 *
+	 */
+      break;
+
+      case EMH_S_C_MTC:
+	/*
+	 *
+	 */
+      break;
+
+      case EMH_S_C_GTX:
+	/*
+	 *
+	 */
+      break;
+
+      default:
+	bfd_set_error (bfd_error_wrong_format);
+      return -1;
+
+    } /* switch */
+
+  return 0;
+}
+
+
+#if 0
+
+/* register a file name  */
+
+int
+_bfd_evax_register_filename (abfd, name)
+     bfd *abfd;
+     char *name;
+{
+  if (PRIV(filename) != NULL)
+    {
+#if EVAX_DEBUG
+      evax_debug(3, "Second filename %s, first was %s\n", name, PRIV(filename));
+#endif
+      return -1;
+    }
+  PRIV(filename) = strdup (name);
+  return 0;
+}
+
+#endif /* 0 */
+
+/* write object header for bfd abfd  */
+
+int
+_bfd_evax_write_emh (abfd)
+     bfd *abfd;
+{
+  char *name;
+
+#if EVAX_DEBUG
+  evax_debug (2, "evax_write_emh(%p)\n", abfd);
+#endif
+
+  _bfd_evax_output_alignment (abfd, 2);
+
+  /* MHD */
+
+  _bfd_evax_output_begin (abfd, EOBJ_S_C_EMH, EMH_S_C_MHD);
+  _bfd_evax_output_short (abfd, EOBJ_S_C_STRLVL);
+  _bfd_evax_output_long (abfd, 0);
+  _bfd_evax_output_long (abfd, 0);
+  _bfd_evax_output_long (abfd, MAX_OUTREC_SIZE);
+  if (bfd_get_filename (abfd) != NULL)
+    {
+      name = strdup (bfd_get_filename (abfd));
+      _bfd_evax_output_counted (abfd, _bfd_evax_basename (name));
+    }
+  else
+    _bfd_evax_output_counted (abfd, "NONAME");
+  _bfd_evax_output_counted (abfd, BFD_VERSION);
+  _bfd_evax_output_dump (abfd, (unsigned char *)_bfd_get_vms_time_string (),
+			 17);
+  _bfd_evax_output_fill (abfd, 0, 17);
+  _bfd_evax_output_flush (abfd);
+
+  /* LMN */
+
+  _bfd_evax_output_begin (abfd, EOBJ_S_C_EMH, EMH_S_C_LNM);
+  _bfd_evax_output_dump (abfd, (unsigned char *)"GAS proGIS", 10);
+  _bfd_evax_output_flush (abfd);
+
+  /* SRC */
+
+  _bfd_evax_output_begin (abfd, EOBJ_S_C_EMH, EMH_S_C_SRC);
+  if (PRIV(filename) != 0)
+    _bfd_evax_output_dump (abfd, (unsigned char *)PRIV(filename), strlen (PRIV(filename)));
+  else
+    _bfd_evax_output_dump (abfd, (unsigned char *)"noname", 6);
+  _bfd_evax_output_flush (abfd);
+
+  /* TTL */
+
+  _bfd_evax_output_begin (abfd, EOBJ_S_C_EMH, EMH_S_C_TTL);
+  _bfd_evax_output_dump (abfd, (unsigned char *)"TTL", 3);
+  _bfd_evax_output_flush (abfd);
+
+  /* CPR */
+
+  _bfd_evax_output_begin (abfd, EOBJ_S_C_EMH, EMH_S_C_CPR);
+  _bfd_evax_output_dump (abfd,
+			 (unsigned char *)"GNU BFD ported by Klaus Kämpf 1994-1996",
+			 39);
+  _bfd_evax_output_flush (abfd);
+
+  return 0;
+}
+
+/*-----------------------------------------------------------------------------*/
+
+/* Process EEOM record
+   return 0 on success, -1 on error  */
+
+int
+_bfd_evax_slurp_eeom (abfd)
+     bfd *abfd;
+{
+  unsigned char *evax_rec;
+
+#if EVAX_DEBUG
+  evax_debug(2, "EEOM\n");
+#endif
+
+  evax_rec = PRIV(evax_rec);
+
+  PRIV(eeom_data).eeom_l_total_lps = bfd_getl32 (evax_rec + 4);
+  PRIV(eeom_data).eeom_b_comcod = *(evax_rec + 8);
+  if (PRIV(eeom_data).eeom_b_comcod > 1)
+    {
+      (*_bfd_error_handler) ("Object module NOT error-free !\n");
+      bfd_set_error (bfd_error_bad_value);
+      return -1;
+    }
+  PRIV(eeom_data).eeom_has_transfer = false;
+  if (PRIV(rec_size) > 10)
+    {
+       PRIV(eeom_data).eeom_has_transfer = true;
+       PRIV(eeom_data).eeom_b_tfrflg = *(evax_rec + 9);
+       PRIV(eeom_data).eeom_l_psindx = bfd_getl32 (evax_rec + 12);
+       PRIV(eeom_data).eeom_l_tfradr = bfd_getl32 (evax_rec + 16);
+
+       abfd->start_address = PRIV(eeom_data).eeom_l_tfradr;
+    }
+  return 0;
+}
+
+
+/* Write eom record for bfd abfd  */
+
+int
+_bfd_evax_write_eeom (abfd)
+     bfd *abfd;
+{
+#if EVAX_DEBUG
+  evax_debug (2, "evax_write_eeom(%p)\n", abfd);
+#endif
+
+  _bfd_evax_output_begin (abfd,EOBJ_S_C_EEOM, -1);
+  _bfd_evax_output_long (abfd, (unsigned long)(PRIV(evax_linkage_index) >> 1));
+  _bfd_evax_output_byte (abfd, 0);	/* completion code */
+  _bfd_evax_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_evax_output_short (abfd, 0);
+      _bfd_evax_output_long (abfd, (unsigned long)(section->index));
+      _bfd_evax_output_long (abfd,
+			     (unsigned long) bfd_get_start_address (abfd));
+      _bfd_evax_output_long (abfd, 0);
+    }
+
+  _bfd_evax_output_end (abfd);
+  return 0;
+}
diff --git a/bfd/evax-etir.c b/bfd/evax-etir.c
new file mode 100644
index 0000000..b9c53bc
--- /dev/null
+++ b/bfd/evax-etir.c
@@ -0,0 +1,1553 @@
+/* evax-etir.c -- BFD back-end for ALPHA EVAX (openVMS/AXP) files.
+   Copyright 1996 Free Software Foundation, Inc.
+   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ämpf (kkaempf@progis.de)
+   of proGIS Softwareentwicklung, Aachen, Germany
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+
+/* 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 <stdio.h>
+#include <ctype.h>
+
+#include "bfd.h"
+#include "sysdep.h"
+#include "bfdlink.h"
+#include "libbfd.h"
+
+#include "evax.h"
+
+#if 0
+static void location_save
+  PARAMS ((bfd *abfd, unsigned long index, unsigned long loc, int section));
+static unsigned long location_restore
+  PARAMS ((bfd *abfd, unsigned long index, int *section));
+#endif /* 0 */
+
+static void image_set_ptr PARAMS ((bfd *abfd, int psect, uquad offset));
+static void image_inc_ptr PARAMS ((bfd *abfd, uquad offset));
+static void image_dump PARAMS ((bfd *abfd, unsigned char *ptr, int size, int offset));
+static void image_write_b PARAMS ((bfd *abfd, unsigned int value));
+static void image_write_w PARAMS ((bfd *abfd, unsigned int value));
+static void image_write_l PARAMS ((bfd *abfd, unsigned long value));
+static void image_write_q PARAMS ((bfd *abfd, uquad value));
+
+/*-----------------------------------------------------------------------------*/
+
+#if 0
+
+/* Save location counter at index  */
+
+static void
+location_save (abfd, index, loc, section)
+     bfd *abfd;
+     unsigned long index;
+     unsigned long loc;
+     int section;
+{
+  PRIV(location_stack)[index].value = loc;
+  PRIV(location_stack)[index].psect = section;
+
+  return;
+}
+
+/* Restore location counter from index  */
+
+static unsigned long
+location_restore (abfd, index, section)
+     bfd *abfd;
+     unsigned long index;
+     int *section;
+{
+  if (section != NULL)
+    *section = PRIV(location_stack)[index].psect;
+  return PRIV(location_stack)[index].value;
+}
+
+#endif /* 0 */
+
+/* routines to fill sections contents during etir read */
+
+/* Initialize image buffer pointer to be filled  */
+
+static void
+image_set_ptr (abfd, psect, offset)
+     bfd *abfd;
+     int psect;
+     uquad offset;
+{
+#if EVAX_DEBUG
+  evax_debug (4, "image_set_ptr(%d=%s, %d)\n",
+		psect, PRIV(sections)[psect]->name, offset);
+#endif
+
+  PRIV(image_ptr) = PRIV(sections)[psect]->contents + offset;
+  return;
+}
+
+
+/* Increment image buffer pointer by offset  */
+
+static void
+image_inc_ptr (abfd, offset)
+     bfd *abfd;
+     uquad offset;
+{
+#if EVAX_DEBUG
+  evax_debug (4, "image_inc_ptr(%d)\n", offset);
+#endif
+
+  PRIV(image_ptr) += offset;
+
+  return;
+}
+
+
+/* Dump multiple bytes to section image  */
+
+static void
+image_dump (abfd, ptr, size, offset)
+    bfd *abfd;
+    unsigned char *ptr;
+    int size;
+    int offset;
+{
+#if EVAX_DEBUG
+  evax_debug (6, "image_dump from (%p, %d) to (%p)\n", ptr, size, PRIV(image_ptr));
+  _bfd_hexdump (7, ptr, size, offset);
+#endif
+
+  while (size-- > 0)
+    *PRIV(image_ptr)++ = *ptr++;
+  return;
+}
+
+
+/* Write byte to section image  */
+
+static void
+image_write_b (abfd, value)
+     bfd *abfd;
+     unsigned int value;
+{
+#if EVAX_DEBUG
+  evax_debug (6, "image_write_b(%02x)\n", (int)value);
+#endif
+
+  *PRIV(image_ptr)++ = (value & 0xff);
+  return;
+}
+
+
+/* Write 2-byte word to image  */
+
+static void
+image_write_w (abfd, value)
+     bfd *abfd;
+     unsigned int value;
+{
+#if EVAX_DEBUG
+  evax_debug (6, "image_write_w(%04x)\n", (int)value);
+#endif
+
+  bfd_putl16 (value, PRIV(image_ptr));
+  PRIV(image_ptr) += 2;
+
+  return;
+}
+
+
+/* Write 4-byte long to image  */
+
+static void
+image_write_l (abfd, value)
+     bfd *abfd;
+     unsigned long value;
+{
+#if EVAX_DEBUG
+  evax_debug (6, "image_write_l(%08lx)\n", value);
+#endif
+
+  bfd_putl32 (value, PRIV(image_ptr));
+  PRIV(image_ptr) += 4;
+
+  return;
+}
+
+
+/* Write 4-byte long to image  */
+
+static void
+image_write_q (abfd, value)
+     bfd *abfd;
+     uquad value;
+{
+#if EVAX_DEBUG
+  evax_debug (6, "image_write_q(%016lx)\n", value);
+#endif
+
+  bfd_putl64 (value, PRIV(image_ptr));
+  PRIV(image_ptr) += 8;
+
+  return;
+}
+
+
+#define HIGHBIT(op) ((op & 0x80000000L) == 0x80000000L)
+
+/* etir_sta
+  
+   evax 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 boolean
+etir_sta (abfd, cmd, ptr)
+     bfd *abfd;
+     int cmd;
+     unsigned char *ptr;
+{
+
+  switch (cmd)
+    {
+      /* stack */
+
+      /* 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;
+	  evax_symbol_entry *entry;
+
+	  name = _bfd_evax_save_counted_string ((char *)ptr);
+	  entry = (evax_symbol_entry *)
+		  bfd_hash_lookup (PRIV(evax_symbol_table), name, false, false);
+	  if (entry == (evax_symbol_entry *)NULL)
+	    {
+#if EVAX_DEBUG
+	      evax_debug (3, "ETIR_S_C_STA_GBL: no symbol \"%s\"\n", name);
+#endif
+	      return false;
+	    }
+	  else
+	    {
+	      _bfd_evax_push (abfd, (uquad)(entry->symbol->value), -1);
+	    }
+	}
+      break;
+
+	/* stack longword
+	   arg: lw	value
+
+	   stack 32 bit value, sign extend to 64 bit  */
+
+      case ETIR_S_C_STA_LW:
+	_bfd_evax_push (abfd, (uquad)bfd_getl32 (ptr), -1);
+      break;
+
+	/* stack global
+	   arg: qw	value
+
+	   stack 64 bit value of symbol	 */
+
+      case ETIR_S_C_STA_QW:
+	_bfd_evax_push (abfd, (uquad)bfd_getl64(ptr), -1);
+      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 (psect >= PRIV(egsd_sec_count))
+	    {
+	      (*_bfd_error_handler) ("Bad section index in ETIR_S_C_STA_PQ");
+	      bfd_set_error (bfd_error_bad_value);
+	      return false;
+	    }
+	  dummy = bfd_getl64 (ptr+4);
+	  _bfd_evax_push (abfd, dummy, psect);
+        }
+      break;
+
+	/* all not supported  */
+
+      case ETIR_S_C_STA_LI:
+      case ETIR_S_C_STA_MOD:
+      case ETIR_S_C_STA_CKARG:
+
+	(*_bfd_error_handler) ("Unsupported STA cmd %d", cmd);
+	return false;
+      break;
+
+      default:
+	(*_bfd_error_handler) ("Reserved STA cmd %d", cmd);
+	return false;
+      break;
+  }
+  return true;
+}
+
+
+/*
+   etir_sto
+  
+   evax 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 boolean
+etir_sto (abfd, cmd, ptr)
+     bfd *abfd;
+     int cmd;
+     unsigned char *ptr;
+{
+  uquad dummy;
+  int psect;
+
+  switch (cmd)
+    {
+
+      /* store byte: pop stack, write byte
+	 arg: -  */
+
+    case ETIR_S_C_STO_B:
+      dummy = _bfd_evax_pop (abfd, &psect);
+#if 0
+      if (is_share)		/* FIXME */
+	(*_bfd_error_handler) ("ETIR_S_C_STO_B: byte fixups not supported");
+#endif
+      image_write_b (abfd, dummy & 0xff);	/* FIXME: check top bits */
+      break;
+
+      /* store word: pop stack, write word
+	 arg: -  */
+
+    case ETIR_S_C_STO_W:
+      dummy = _bfd_evax_pop (abfd, &psect);
+#if 0
+      if (is_share)		/* FIXME */
+	(*_bfd_error_handler) ("ETIR_S_C_STO_B: word fixups not supported");
+#endif
+      image_write_w (abfd, dummy & 0xffff);	/* FIXME: check top bits */
+      break;
+
+      /* store longword: pop stack, write longword
+	 arg: -  */
+
+    case ETIR_S_C_STO_LW:
+      dummy = _bfd_evax_pop (abfd, &psect);
+      dummy += (PRIV(sections)[psect])->vma;
+      image_write_l (abfd, dummy & 0xffffffff);/* FIXME: check top bits */
+#if 0				/* FIXME */
+      if (is_rel)
+	evax_debug (3, "ETIR_S_C_STO_LW: Relocation !\n");
+      if (is_share)
+	evax_debug (3, "ETIR_S_C_STO_LW: Fix-up share !\n");
+#endif
+      break;
+
+      /* store quadword: pop stack, write quadword
+	 arg: -  */
+
+    case ETIR_S_C_STO_QW:
+      dummy = _bfd_evax_pop (abfd, &psect);
+      dummy += (PRIV(sections)[psect])->vma;
+      image_write_q(abfd, dummy);		/* FIXME: check top bits */
+#if 0				/* FIXME */
+      if (is_rel)
+	evax_debug (3, "ETIR_S_C_STO_LW: Relocation !\n");
+      if (is_share)
+	evax_debug (3, "ETIR_S_C_STO_LW: Fix-up share !\n");
+#endif
+      break;
+
+      /* store immediate repeated: pop stack for repeat count
+	 arg: lw	byte count
+	 da	data  */
+
+    case ETIR_S_C_STO_IMMR:
+      {
+	unsigned long size;
+
+	size = bfd_getl32 (ptr);
+	dummy = (unsigned long)_bfd_evax_pop (abfd, NULL);
+	while (dummy-- > 0L)
+	  image_dump (abfd, ptr+4, size, 0);
+      }
+      break;
+
+      /* store global: write symbol value
+	 arg: cs	global symbol name  */
+
+    case ETIR_S_C_STO_GBL:
+      {
+	evax_symbol_entry *entry;
+	char *name;
+
+	name = _bfd_evax_save_counted_string ((char *)ptr);
+	entry = (evax_symbol_entry *)bfd_hash_lookup (PRIV(evax_symbol_table), name, false, false);
+	if (entry == (evax_symbol_entry *)NULL)
+	  {
+	    (*_bfd_error_handler) ("ETIR_S_C_STO_GBL: no symbol \"%s\"",
+				   name);
+	    return false;
+	  }
+	else
+	  image_write_q (abfd, (uquad)(entry->symbol->value));	/* FIXME, reloc */
+      }
+      break;
+
+      /* store code address: write address of entry point
+	 arg: cs	global symbol name (procedure)  */
+
+    case ETIR_S_C_STO_CA:
+      {
+	evax_symbol_entry *entry;
+	char *name;
+
+	name = _bfd_evax_save_counted_string ((char *)ptr);
+	entry = (evax_symbol_entry *) bfd_hash_lookup (PRIV(evax_symbol_table), name, false, false);
+	if (entry == (evax_symbol_entry *)NULL)
+	  {
+	    (*_bfd_error_handler) ("ETIR_S_C_STO_CA: no symbol \"%s\"",
+				   name);
+	    return false;
+	  }
+	else
+	  image_write_q (abfd, (uquad)(entry->symbol->value));	/* FIXME, reloc */
+      }
+      break;
+
+      /* not supported  */
+
+    case ETIR_S_C_STO_RB:
+    case ETIR_S_C_STO_AB:
+      (*_bfd_error_handler) ("ETIR_S_C_STO_RB/AB: Not supported");
+      break;
+
+    /* store offset to psect: pop stack, add low 32 bits to base of psect
+       arg: -  */
+
+    case ETIR_S_C_STO_OFF:
+      {
+	uquad q;
+	int psect;
+
+	q = _bfd_evax_pop (abfd, &psect);
+	q += (PRIV(sections)[psect])->vma;
+	image_write_q (abfd, q);
+      }
+      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);
+      }
+      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:
+      {
+	evax_symbol_entry *entry;
+	char *name;
+
+	name = _bfd_evax_save_counted_string ((char *)ptr);
+	entry = (evax_symbol_entry *)bfd_hash_lookup (PRIV(evax_symbol_table), name, false, false);
+	if (entry == (evax_symbol_entry *)NULL)
+	  {
+#if EVAX_DEBUG
+	    evax_debug (3, "ETIR_S_C_STO_GBL_LW: no symbol \"%s\"\n", name);
+#endif
+	    return false;
+	  }
+	else
+	  image_write_l (abfd, (unsigned long)(entry->symbol->value));	/* FIXME, reloc */
+      }
+      break;
+
+      /* not supported  */
+
+    case ETIR_S_C_STO_LP_PSB:
+      (*_bfd_error_handler) ("ETIR_S_C_STO_LP_PSB: Not supported");
+      break;
+
+    /* */
+
+    case ETIR_S_C_STO_HINT_GBL:
+      (*_bfd_error_handler) ("ETIR_S_C_STO_HINT_GBL: not implemented");
+      break;
+
+    /* */
+
+    case ETIR_S_C_STO_HINT_PS:
+      (*_bfd_error_handler) ("ETIR_S_C_STO_HINT_PS: not implemented");
+      break;
+
+    default:
+      (*_bfd_error_handler) ("Reserved STO cmd %d", cmd);
+      break;
+    }
+
+  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 boolean
+etir_opr (abfd, cmd, ptr)
+     bfd *abfd;
+     int cmd;
+     unsigned char *ptr;
+{
+  long op1, op2;
+
+  switch (cmd)
+    {
+      /* operation */
+
+      /* no-op  */
+
+    case ETIR_S_C_OPR_NOP:
+      break;
+
+      /* add  */
+
+    case ETIR_S_C_OPR_ADD:
+      op1 = (long)_bfd_evax_pop (abfd, NULL);
+      op2 = (long)_bfd_evax_pop (abfd, NULL);
+      _bfd_evax_push (abfd, (uquad)(op1 + op2), -1);
+      break;
+
+      /* subtract  */
+
+    case ETIR_S_C_OPR_SUB:
+      op1 = (long)_bfd_evax_pop (abfd, NULL);
+      op2 = (long)_bfd_evax_pop (abfd, NULL);
+      _bfd_evax_push (abfd, (uquad)(op2 - op1), -1);
+      break;
+
+      /* multiply  */
+
+    case ETIR_S_C_OPR_MUL:
+      op1 = (long)_bfd_evax_pop (abfd, NULL);
+      op2 = (long)_bfd_evax_pop (abfd, NULL);
+      _bfd_evax_push (abfd, (uquad)(op1 * op2), -1);
+      break;
+
+      /* divide  */
+
+    case ETIR_S_C_OPR_DIV:
+      op1 = (long)_bfd_evax_pop (abfd, NULL);
+      op2 = (long)_bfd_evax_pop (abfd, NULL);
+      if (op2 == 0)
+	_bfd_evax_push (abfd, (uquad)0L, -1);
+      else
+	_bfd_evax_push (abfd, (uquad)(op2 / op1), -1);
+      break;
+
+      /* logical and  */
+
+    case ETIR_S_C_OPR_AND:
+      op1 = (long)_bfd_evax_pop (abfd, NULL);
+      op2 = (long)_bfd_evax_pop (abfd, NULL);
+      _bfd_evax_push (abfd, (uquad)(op1 & op2), -1);
+      break;
+
+      /* logical inclusive or	 */
+
+    case ETIR_S_C_OPR_IOR:
+      op1 = (long)_bfd_evax_pop (abfd, NULL);
+      op2 = (long)_bfd_evax_pop (abfd, NULL);
+      _bfd_evax_push (abfd, (uquad)(op1 | op2), -1);
+      break;
+
+      /* logical exclusive or  */
+
+    case ETIR_S_C_OPR_EOR:
+      op1 = (long)_bfd_evax_pop (abfd, NULL);
+      op2 = (long)_bfd_evax_pop (abfd, NULL);
+      _bfd_evax_push (abfd, (uquad)(op1 ^ op2), -1);
+      break;
+
+      /* negate  */
+
+    case ETIR_S_C_OPR_NEG:
+      op1 = (long)_bfd_evax_pop (abfd, NULL);
+      _bfd_evax_push (abfd, (uquad)(-op1), -1);
+      break;
+
+      /* complement  */
+
+    case ETIR_S_C_OPR_COM:
+      op1 = (long)_bfd_evax_pop (abfd, NULL);
+      _bfd_evax_push (abfd, (uquad)(op1 ^ -1L), -1);
+      break;
+
+      /* insert field  */
+
+    case ETIR_S_C_OPR_INSV:
+      (void)_bfd_evax_pop (abfd, NULL);
+      (*_bfd_error_handler) ("ETIR_S_C_OPR_INSV: Not supported");
+      break;
+
+    /* arithmetic shift  */
+
+    case ETIR_S_C_OPR_ASH:
+      op1 = (long)_bfd_evax_pop (abfd, NULL);
+      op2 = (long)_bfd_evax_pop (abfd, NULL);
+      if (op2 < 0)		/* shift right */
+	op1 >>= -op2;
+      else			/* shift left */
+	op1 <<= op2;
+      _bfd_evax_push (abfd, (uquad)op1, -1);
+      break;
+
+      /* unsigned shift  */
+
+    case ETIR_S_C_OPR_USH:
+      (*_bfd_error_handler) ("ETIR_S_C_OPR_USH: Not supported");
+      break;
+
+      /* rotate  */
+
+    case ETIR_S_C_OPR_ROT:
+      (*_bfd_error_handler) ("ETIR_S_C_OPR_ROT: Not supported");
+      break;
+
+      /* select  */
+
+    case ETIR_S_C_OPR_SEL:
+      if ((long)_bfd_evax_pop (abfd, NULL) & 0x01L)
+	(void)_bfd_evax_pop (abfd, NULL);
+      else
+	{
+	  op1 = (long)_bfd_evax_pop (abfd, NULL);
+	  (void)_bfd_evax_pop (abfd, NULL);
+	  _bfd_evax_push (abfd, (uquad)op1, -1);
+	}
+      break;
+
+      /* redefine symbol to current location  */
+
+    case ETIR_S_C_OPR_REDEF:
+      (*_bfd_error_handler) ("ETIR_S_C_OPR_REDEF: Not supported");
+      break;
+
+      /* define a literal  */
+
+    case ETIR_S_C_OPR_DFLIT:
+      (*_bfd_error_handler) ("ETIR_S_C_OPR_DFLIT: Not supported");
+      break;
+
+    default:
+      (*_bfd_error_handler) ("Reserved OPR cmd %d", cmd);
+      break;
+    }
+
+  return true;
+}
+
+
+/* control commands
+  
+   see table B-11 of the openVMS linker manual  */
+
+static boolean
+etir_ctl (abfd, cmd, ptr)
+     bfd *abfd;
+     int cmd;
+     unsigned char *ptr;
+{
+  uquad	 dummy;
+  int psect;
+
+  switch (cmd)
+    {
+      /* set relocation base: pop stack, set image location counter
+	 arg: -  */
+
+    case ETIR_S_C_CTL_SETRB:
+      dummy = _bfd_evax_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: -  */
+
+    case ETIR_S_C_CTL_DFLOC:
+      dummy = _bfd_evax_pop (abfd, NULL);
+      /* FIXME */
+      break;
+
+      /* set location: pop index, restore location counter from index
+	 arg: -  */
+
+    case ETIR_S_C_CTL_STLOC:
+      dummy = _bfd_evax_pop (abfd, &psect);
+      /* FIXME */
+      break;
+
+      /* stack defined location: pop index, push location counter from index
+	 arg: -  */
+
+    case ETIR_S_C_CTL_STKDL:
+      dummy = _bfd_evax_pop (abfd, &psect);
+      /* FIXME */
+      break;
+
+    default:
+      (*_bfd_error_handler) ("Reserved CTL cmd %d", cmd);
+      break;
+    }
+  return true;
+}
+
+
+/* store conditional commands
+  
+   see table B-12 and B-13 of the openVMS linker manual  */
+
+static boolean
+etir_stc (abfd, cmd, ptr)
+     bfd *abfd;
+     int cmd;
+     unsigned char *ptr;
+{
+
+  switch (cmd)
+    {
+      /* 200 Store-conditional Linkage Pair
+	 arg:  */
+
+    case ETIR_S_C_STC_LP:
+      (*_bfd_error_handler) ("ETIR_S_C_STC_LP: not supported");
+      break;
+
+      /* 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, 16);	/* skip entry,procval */
+      break;
+
+      /* 202 Store-conditional Address at global address
+	 arg:	lw	linkage index
+	 cs	global name  */
+
+    case ETIR_S_C_STC_GBL:
+      (*_bfd_error_handler) ("ETIR_S_C_STC_GBL: not supported");
+      break;
+
+      /* 203 Store-conditional Code Address at global address
+	 arg:	lw	linkage index
+	 cs	procedure name  */
+
+    case ETIR_S_C_STC_GCA:
+      (*_bfd_error_handler) ("ETIR_S_C_STC_GCA: not supported");
+      break;
+
+      /* 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) ("ETIR_S_C_STC_PS: not supported");
+      break;
+
+      /* 205 Store-conditional NOP at address of global
+	 arg:  */
+
+    case ETIR_S_C_STC_NOP_GBL:
+
+      /* 206 Store-conditional NOP at pect + offset
+	 arg:  */
+
+    case ETIR_S_C_STC_NOP_PS:
+
+      /* 207 Store-conditional BSR at global address
+	 arg:  */
+
+    case ETIR_S_C_STC_BSR_GBL:
+
+      /* 208 Store-conditional BSR at pect + offset
+	 arg:  */
+
+    case ETIR_S_C_STC_BSR_PS:
+
+      /* 209 Store-conditional LDA at global address
+	 arg:  */
+
+    case ETIR_S_C_STC_LDA_GBL:
+
+      /* 210 Store-conditional LDA at psect + offset
+	 arg:  */
+
+    case ETIR_S_C_STC_LDA_PS:
+
+      /* 211 Store-conditional BSR or Hint at global address
+	 arg:  */
+
+    case ETIR_S_C_STC_BOH_GBL:
+
+      /* 212 Store-conditional BSR or Hint at pect + offset
+	 arg:  */
+
+    case ETIR_S_C_STC_BOH_PS:
+
+      /* 213 Store-conditional NOP,BSR or HINT at global address
+	 arg:  */
+
+    case ETIR_S_C_STC_NBH_GBL:
+
+      /* 214 Store-conditional NOP,BSR or HINT at psect + offset
+	 arg:  */
+
+    case ETIR_S_C_STC_NBH_PS:
+      (*_bfd_error_handler) ("ETIR_S_C_STC_xx: (%d) not supported", cmd);
+      break;
+
+    default:
+#if EVAX_DEBUG
+      evax_debug (3,  "Reserved STC cmd %d", cmd);
+#endif
+      break;
+    }
+  return true;
+}
+
+
+/* handle command from ETIR section  */
+
+static boolean
+tir_cmd (abfd, cmd, ptr)
+     bfd *abfd;
+     int cmd;
+     unsigned char *ptr;
+{
+  static struct {
+    int mincod;
+    int maxcod;
+    boolean (*explain) PARAMS((bfd *, int, unsigned char *));
+  } tir_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;
+  boolean res = true;
+
+  while (tir_table[i].mincod >= 0)
+    {
+      if ( (tir_table[i].mincod <= cmd) 
+	&& (cmd <= tir_table[i].maxcod))
+	{
+	  res = tir_table[i].explain (abfd, cmd, ptr);
+	  break;
+	}
+      i++;
+    }
+
+  return res;
+}
+
+
+/* Text Information and Relocation Records (OBJ$C_TIR)
+   handle etir record  */
+
+static boolean
+analyze_etir (abfd, ptr, length)
+     bfd *abfd;
+     unsigned char *ptr;
+     unsigned int length;
+{
+  int cmd;
+  unsigned char *maxptr;
+  boolean res = true;
+
+  maxptr = ptr + length;
+
+  while (ptr < maxptr)
+    {
+      cmd = bfd_getl16 (ptr);
+      length = bfd_getl16 (ptr + 2);
+      res = tir_cmd (abfd, cmd, ptr+4);
+      if (!res)
+	break;
+      ptr += length;
+    }
+  return res;
+}
+
+
+/* process ETIR record
+  
+   return 0 on success, -1 on error  */
+
+int
+_bfd_evax_slurp_etir (abfd)
+     bfd *abfd;
+{
+
+#if EVAX_DEBUG
+  evax_debug (2, "ETIR\n");
+#endif
+
+  PRIV(evax_rec) += 4;	/* skip type, size */
+  PRIV(rec_size) -= 4;
+  if (analyze_etir (abfd, PRIV(evax_rec), PRIV(rec_size)))
+    return 0;
+
+  return -1;
+}
+
+
+/* process EDBG record
+   return 0 on success, -1 on error
+  
+   not implemented yet  */
+
+int
+_bfd_evax_slurp_edbg (abfd)
+     bfd *abfd;
+{
+#if EVAX_DEBUG
+  evax_debug (2, "EDBG\n");
+#endif
+
+  abfd->flags |= (HAS_DEBUG | HAS_LINENO);
+  return 0;
+}
+
+
+/* process ETBT record
+   return 0 on success, -1 on error
+  
+   not implemented yet  */
+
+int
+_bfd_evax_slurp_etbt (abfd)
+     bfd *abfd;
+{
+#if EVAX_DEBUG
+  evax_debug (2, "ETBT\n");
+#endif
+
+  return 0;
+}
+
+/*----------------------------------------------------------------------*/
+/*									*/
+/*	WRITE ETIR SECTION						*/
+/*									*/
+/*	this is still under construction and therefore not documented	*/
+/*									*/
+/*----------------------------------------------------------------------*/
+
+static void start_etir_record PARAMS ((bfd *abfd, int index, uquad offset, boolean justoffset));
+static void sto_imm PARAMS ((bfd *abfd, evax_section *sptr, bfd_vma vaddr, int index));
+static void end_etir_record PARAMS ((bfd *abfd));
+
+static void
+sto_imm (abfd, sptr, vaddr, index)
+     bfd *abfd;
+     evax_section *sptr;
+     bfd_vma vaddr;
+     int index;
+{
+  int size;
+  int ssize;
+  unsigned char *cptr;
+
+#if EVAX_DEBUG
+  evax_debug (8, "sto_imm %d bytes\n", sptr->size);
+  _bfd_hexdump (9, sptr->contents, (int)sptr->size, (int)vaddr);
+#endif
+
+  ssize = sptr->size;
+  cptr = sptr->contents;
+
+  while (ssize > 0)
+    {
+
+      size = ssize;				/* try all the rest */
+
+      if (_bfd_evax_output_check (abfd, size) < 0)
+	{					/* doesn't fit, split ! */
+	  end_etir_record (abfd);
+	  start_etir_record (abfd, index, vaddr, false);
+	  size = _bfd_evax_output_check (abfd, 0);	/* get max size */
+	  if (size > ssize)			/* more than what's left ? */
+	    size = ssize;
+	}
+
+      _bfd_evax_output_begin (abfd, ETIR_S_C_STO_IMM, -1);
+      _bfd_evax_output_long (abfd, (unsigned long)(size));
+      _bfd_evax_output_dump (abfd, cptr, size);
+      _bfd_evax_output_flush (abfd);
+
+#if EVAX_DEBUG
+      evax_debug (10, "dumped %d bytes\n", size);
+      _bfd_hexdump (10, cptr, (int)size, (int)vaddr);
+#endif
+
+      vaddr += size;
+      ssize -= size;
+      cptr += size;
+    }
+
+  return;
+}
+
+/*-------------------------------------------------------------------*/
+
+/* start ETIR record for section #index at virtual addr offset.  */
+
+static void
+start_etir_record (abfd, index, offset, justoffset)
+    bfd *abfd;
+    int index;
+    uquad offset;
+    boolean justoffset;
+{
+  if (!justoffset)
+    {
+      _bfd_evax_output_begin (abfd, EOBJ_S_C_ETIR, -1);	/* one ETIR per section */
+      _bfd_evax_output_push (abfd);
+    }
+
+  _bfd_evax_output_begin (abfd, ETIR_S_C_STA_PQ, -1);	/* push start offset */
+  _bfd_evax_output_long (abfd, (unsigned long)index);
+  _bfd_evax_output_quad (abfd, (uquad)offset);
+  _bfd_evax_output_flush (abfd);
+
+  _bfd_evax_output_begin (abfd, ETIR_S_C_CTL_SETRB, -1);	/* start = pop() */
+  _bfd_evax_output_flush (abfd);
+
+  return;
+}
+
+
+/* end etir record  */
+static void
+end_etir_record (abfd)
+    bfd *abfd;
+{
+  _bfd_evax_output_pop (abfd);
+  _bfd_evax_output_end (abfd); 
+}
+
+/* write section contents for bfd abfd  */
+
+int
+_bfd_evax_write_etir (abfd)
+     bfd *abfd;
+{
+  asection *section;
+  evax_section *sptr;
+  int nextoffset;
+  char uname[200];
+  char *nptr, *uptr;
+
+#if EVAX_DEBUG
+  evax_debug (2, "evax_write_etir(%p)\n", abfd);
+#endif
+
+  _bfd_evax_output_alignment (abfd, 4);
+
+  nextoffset = 0;
+  PRIV(evax_linkage_index) = 1;
+
+  /* dump all other sections  */
+
+  section = abfd->sections;
+
+  while (section != NULL)
+    {
+
+#if EVAX_DEBUG
+      evax_debug (4, "writing %d. section '%s' (%d bytes)\n", section->index, section->name, (int)(section->_raw_size));
+#endif
+
+      if (section->flags & SEC_RELOC)
+	{
+	  int i;
+
+	  if ((i = section->reloc_count) <= 0)
+	    {
+	      (*_bfd_error_handler) ("SEC_RELOC with no relocs in section %s",
+				     section->name);
+	    }
+#if EVAX_DEBUG
+	  else
+	    {
+	      arelent **rptr;
+	      evax_debug (4, "%d relocations:\n", i);
+	      rptr = section->orelocation;
+	      while (i-- > 0)
+		{
+		  evax_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
+	}
+
+      if (section->flags & SEC_HAS_CONTENTS)
+	{
+	  bfd_vma vaddr;		/* virtual addr in section */
+
+	  sptr = _bfd_get_evax_section (abfd, section->index);
+	  if (sptr == NULL)
+	    {
+	      bfd_set_error (bfd_error_no_contents);
+	      return -1;
+	    }
+
+	  vaddr = (bfd_vma)(sptr->offset);
+
+	  start_etir_record (abfd, section->index, (uquad) sptr->offset,
+			     false);
+
+	  while (sptr != NULL)				/* one STA_PQ, CTL_SETRB per evax_section */
+	    {
+
+	      if (section->flags & SEC_RELOC)			/* check for relocs */
+		{
+		  arelent **rptr = section->orelocation;
+		  int i = section->reloc_count;
+		  for (;;)
+		    {
+		      bfd_size_type addr = (*rptr)->address;
+		      int len = bfd_get_reloc_size ((*rptr)->howto);
+		      if (sptr->offset < addr)		/* sptr starts before reloc */
+			{
+			  int before = addr - sptr->offset;
+			  if (sptr->size <= before)		/* complete before */
+			    {
+			      sto_imm (abfd, sptr, vaddr, section->index);
+			      vaddr += sptr->size;
+			      break;
+			    }
+			  else				/* partly before */
+			    {
+			      int after = sptr->size - before;
+			      sptr->size = before;
+			      sto_imm (abfd, sptr, vaddr, section->index);
+			      vaddr += sptr->size;
+			      sptr->contents += before;
+			      sptr->offset += before;
+			      sptr->size = after;
+			    }
+			}
+		      else if (sptr->offset == addr)	/* sptr starts at reloc */
+			{
+			  asymbol *sym = *(*rptr)->sym_ptr_ptr;
+			  asection *sec = sym->section;
+
+			  switch ((*rptr)->howto->type)
+			    {
+			    case ALPHA_R_IGNORE:
+			      break;
+
+			    case ALPHA_R_REFLONG:
+			      {
+				if (bfd_is_und_section (sym->section))
+				  {
+				    if (_bfd_evax_output_check (abfd,
+								strlen((char *)sym->name))
+					< 0)
+				      {
+					end_etir_record (abfd);
+					start_etir_record (abfd,
+							   section->index,
+							   vaddr, false);
+				      }
+				    _bfd_evax_output_begin (abfd,
+							    ETIR_S_C_STO_GBL_LW,
+							    -1);
+				    uptr = uname;
+				    nptr = (char *)sym->name;
+				    while (*nptr)
+				      {
+					if (islower (*nptr))
+					  *uptr = toupper (*nptr);
+					else
+					  *uptr = *nptr;
+					nptr++;
+					uptr++;
+				      }
+				    *uptr = 0;
+				    _bfd_evax_output_counted (abfd, uname);
+				    _bfd_evax_output_flush (abfd);
+				  }
+				else if (bfd_is_abs_section (sym->section))
+				  {
+				    if (_bfd_evax_output_check (abfd, 16) < 0)
+				      {
+					end_etir_record (abfd);
+					start_etir_record (abfd,
+							   section->index,
+							   vaddr, false);
+				      }
+				    _bfd_evax_output_begin (abfd,
+							    ETIR_S_C_STA_LW,
+							    -1);
+				    _bfd_evax_output_quad (abfd,
+							   (uquad)sym->value);
+				    _bfd_evax_output_flush (abfd);
+				    _bfd_evax_output_begin (abfd,
+							    ETIR_S_C_STO_LW,
+							    -1);
+				    _bfd_evax_output_flush (abfd);
+				  }
+				else
+				  {
+				    if (_bfd_evax_output_check (abfd, 32) < 0)
+				      {
+					end_etir_record (abfd);
+					start_etir_record (abfd,
+							   section->index,
+							   vaddr, false);
+				      }
+				    _bfd_evax_output_begin (abfd,
+							    ETIR_S_C_STA_PQ,
+							    -1);
+				    _bfd_evax_output_long (abfd,
+							   (unsigned long)(sec->index));
+				    _bfd_evax_output_quad (abfd,
+							   ((uquad)(*rptr)->addend
+							    + (uquad)sym->value));
+				    _bfd_evax_output_flush (abfd);
+				    _bfd_evax_output_begin (abfd,
+							    ETIR_S_C_STO_LW,
+							    -1);
+				    _bfd_evax_output_flush (abfd);
+				  }
+			      }
+			      break;
+
+			    case ALPHA_R_REFQUAD:
+			      {
+				if (bfd_is_und_section (sym->section))
+				  {
+				    if (_bfd_evax_output_check (abfd,
+								strlen((char *)sym->name))
+					< 0)
+				      {
+					end_etir_record (abfd);
+					start_etir_record (abfd,
+							   section->index,
+							   vaddr, false);
+				      }
+				    _bfd_evax_output_begin (abfd,
+							    ETIR_S_C_STO_GBL,
+							    -1);
+				    uptr = uname;
+				    nptr = (char *)sym->name;
+				    while (*nptr)
+				      {
+					if (islower (*nptr))
+					  *uptr = toupper (*nptr);
+					else
+					  *uptr = *nptr;
+					nptr++;
+					uptr++;
+				      }
+				    *uptr = 0;
+				    _bfd_evax_output_counted (abfd, uname);
+				    _bfd_evax_output_flush (abfd);
+				  }
+				else if (bfd_is_abs_section (sym->section))
+				  {
+				    if (_bfd_evax_output_check (abfd, 16) < 0)
+				      {
+					end_etir_record (abfd);
+					start_etir_record (abfd,
+							   section->index,
+							   vaddr, false);
+				      }
+				    _bfd_evax_output_begin (abfd,
+							    ETIR_S_C_STA_QW,
+							    -1);
+				    _bfd_evax_output_quad (abfd,
+							   (uquad)sym->value);
+				    _bfd_evax_output_flush (abfd);
+				    _bfd_evax_output_begin (abfd,
+							    ETIR_S_C_STO_QW,
+							    -1);
+				    _bfd_evax_output_flush (abfd);
+				  }
+				else
+				  {
+				    if (_bfd_evax_output_check (abfd, 32) < 0)
+				      {
+					end_etir_record (abfd);
+					start_etir_record (abfd,
+							   section->index,
+							   vaddr, false);
+				      }
+				    _bfd_evax_output_begin (abfd,
+							    ETIR_S_C_STA_PQ,
+							    -1);
+				    _bfd_evax_output_long (abfd,
+							   (unsigned long)(sec->index));
+				    _bfd_evax_output_quad (abfd,
+							   ((uquad)(*rptr)->addend
+							    + (uquad)sym->value));
+				    _bfd_evax_output_flush (abfd);
+				    _bfd_evax_output_begin (abfd,
+							    ETIR_S_C_STO_OFF,
+							    -1);
+				    _bfd_evax_output_flush (abfd);
+				  }
+			      }
+			      break;
+
+			    case ALPHA_R_HINT:
+			      {
+				int hint_size;
+
+				hint_size = sptr->size;
+				sptr->size = len;
+				sto_imm (abfd, sptr, vaddr, section->index);
+				sptr->size = hint_size;
+#if 0
+				evax_output_begin(abfd, ETIR_S_C_STO_HINT_GBL, -1);
+				evax_output_long(abfd, (unsigned long)(sec->index));
+				evax_output_quad(abfd, (uquad)addr);
+				uptr = uname;
+				nptr = (char *)(*(*rptr)->sym_ptr_ptr)->name;
+				while (*nptr)
+				  {
+				    if (islower (*nptr))
+				      *uptr = toupper (*nptr);
+				    else
+				      *uptr = *nptr;
+				    nptr++;
+				    uptr++;
+				  }
+				*uptr = 0;
+
+				evax_output_counted(abfd, uname);
+				evax_output_flush(abfd);
+#endif
+			      }
+			      break;
+#if 0
+			    case ALPHA_R_BRADDR:
+			      break;
+			    case ALPHA_R_SREL16:
+			      break;
+			    case ALPHA_R_SREL32:
+			      break;
+			    case ALPHA_R_SREL64:
+			      break;
+			    case ALPHA_R_OP_PUSH:
+			      break;
+			    case ALPHA_R_OP_STORE:
+			      break;
+			    case ALPHA_R_OP_PSUB:
+			      break;
+			    case ALPHA_R_OP_PRSHIFT:
+			      break;
+#endif
+			    case ALPHA_R_LINKAGE:
+			      {
+				if (_bfd_evax_output_check (abfd, 64) < 0)
+				  {
+				    end_etir_record (abfd);
+				    start_etir_record (abfd, section->index,
+						       vaddr, false);
+				  }
+				_bfd_evax_output_begin (abfd,
+							ETIR_S_C_STC_LP_PSB,
+							-1);
+				_bfd_evax_output_long (abfd,
+						       (unsigned long)PRIV(evax_linkage_index));
+				PRIV(evax_linkage_index) += 2;
+				uptr = uname;
+				nptr = (char *)(*(*rptr)->sym_ptr_ptr)->name;
+				while (*nptr)
+				  {
+				    if (islower (*nptr))
+				      *uptr = toupper (*nptr);
+				    else
+				      *uptr = *nptr;
+				    nptr++;
+				    uptr++;
+				  }
+				*uptr = 0;
+				_bfd_evax_output_counted (abfd, uname);
+				_bfd_evax_output_byte (abfd, 0);
+				_bfd_evax_output_flush (abfd);
+			      }
+			      break;
+
+			    default:
+			      (*_bfd_error_handler) ("Unhandled relocation %s",
+						     (*rptr)->howto->name);
+			      break;
+			    }
+
+			  vaddr += len;
+
+			  if (len == sptr->size)
+			    {
+			      break;
+			    }
+			  else
+			    {
+			      sptr->contents += len;
+			      sptr->offset += len;
+			      sptr->size -= len;
+			      i--;
+			      rptr++;
+			    }
+			}
+		      else					/* sptr starts after reloc */
+			{
+			  i--;				/* check next reloc */
+			  rptr++;
+			}
+
+		      if (i==0)				/* all reloc checked */
+			{
+			  if (sptr->size > 0)
+			    {
+			      sto_imm (abfd, sptr, vaddr, section->index);	/* dump rest */
+			      vaddr += sptr->size;
+			    }
+			  break;
+			}
+		    } /* for (;;) */
+		} /* if SEC_RELOC */
+	      else						/* no relocs, just dump */
+		{
+		  sto_imm (abfd, sptr, vaddr, section->index);
+		  vaddr += sptr->size;
+		}
+
+	      sptr = sptr->next;
+
+	    } /* while (sptr != 0) */
+
+	  end_etir_record (abfd);
+
+	} /* has_contents */
+
+      section = section->next;
+    }
+
+  _bfd_evax_output_alignment(abfd, 2);
+  return 0;
+}
+
+
+/* write traceback data for bfd abfd  */
+
+int
+_bfd_evax_write_etbt (abfd)
+     bfd *abfd;
+{
+#if EVAX_DEBUG
+  evax_debug (2, "evax_write_etbt(%p)\n", abfd);
+#endif
+
+  return 0;
+}
+
+
+/* write debug info for bfd abfd  */
+
+int
+_bfd_evax_write_edbg (abfd)
+     bfd *abfd;
+{
+#if EVAX_DEBUG
+  evax_debug (2, "evax_write_edbg(%p)\n", abfd);
+#endif
+
+  return 0;
+}
diff --git a/bfd/evax-misc.c b/bfd/evax-misc.c
new file mode 100644
index 0000000..aade68a
--- /dev/null
+++ b/bfd/evax-misc.c
@@ -0,0 +1,1065 @@
+/* evax-misc.c -- Miscellaneous functions for ALPHA EVAX (openVMS/AXP) files.
+   Copyright 1996 Free Software Foundation, Inc.
+   Written by Klaus Kämpf (kkaempf@progis.de)
+   of proGIS Softwareentwicklung, Aachen, Germany
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+
+#if __STDC__
+#include <stdarg.h>
+#endif
+#include <stdio.h>
+
+#include "bfd.h"
+#include "sysdep.h"
+#include "bfdlink.h"
+#include "libbfd.h"
+
+#include "evax.h"
+
+/*-----------------------------------------------------------------------------*/
+#if EVAX_DEBUG
+/* debug functions */
+
+/* debug function for all evax extensions
+   evaluates environment variable EVAX_DEBUG for a
+   numerical value on the first call
+   all error levels below this value are printed
+  
+   levels:
+   1	toplevel bfd calls (functions from the bfd vector)
+   2	functions called by bfd calls
+   ...
+   9	almost everything
+
+   level is also identation level. Indentation is performed
+   if level > 0
+	*/
+
+#if __STDC__
+void
+_bfd_evax_debug (int level, char *format, ...)
+{
+  static int min_level = -1;
+  static FILE *output = NULL;
+  char *eptr;
+  va_list args;
+  int abslvl = (level > 0)?level:-level;
+
+  if (min_level == -1)
+    {
+      if ((eptr = getenv("EVAX_DEBUG")) != NULL)
+	{
+	  min_level = atoi(eptr);
+	  output = stderr;
+	}
+      else
+	min_level = 0;
+    }
+  if (output == NULL)
+    return;
+  if (abslvl > min_level)
+    return;
+
+  while(--level>0)
+    fprintf(output, " ");
+  va_start(args, format);
+  vfprintf(output, format, args);
+  fflush(output);
+  va_end(args);
+
+  return;
+}
+
+#else /* not __STDC__ */
+
+void
+_bfd_evax_debug (level, format, a1, a2, a3, a4, a5, a6)
+     int level;
+     char *format;
+     long a1; long a2; long a3;
+     long a4; long a5; long a6;
+{
+  static int min_level = -1;
+  static FILE *output = NULL;
+  char *eptr;
+
+  if (min_level == -1)
+    {
+      if ((eptr = getenv("EVAX_DEBUG")) != NULL)
+	{
+	  min_level = atoi(eptr);
+	  output = stderr;
+	}
+      else
+	min_level = 0;
+    }
+  if (output == NULL)
+    return;
+  if (level > min_level)
+    return;
+
+  while(--level>0)
+    fprintf(output, " ");
+  fprintf(output, format, a1, a2, a3, a4, a5, a6);
+  fflush(output);
+
+  return;
+}
+#endif /* __STDC__ */
+
+
+/* a debug function
+   hex dump 'size' bytes starting at 'ptr'  */
+
+void
+_bfd_hexdump (level, ptr, size, offset)
+     int level;
+     unsigned char *ptr;
+     int size;
+     int offset;
+{
+  unsigned char *lptr = ptr;
+  int count = 0;
+  long start = offset;
+
+  while (size-- > 0)
+    {
+      if ((count%16) == 0)
+	evax_debug (level, "%08lx:", start);
+      evax_debug (-level, " %02x", *ptr++);
+      count++;
+      start++;
+      if (size == 0)
+	{
+	  while ((count%16) != 0)
+	    {
+	      evax_debug (-level, "   ");
+	      count++;
+	    }
+	}
+      if ((count%16) == 0)
+	{
+	  evax_debug (-level, " ");
+	  while (lptr < ptr)
+	    {
+	      evax_debug (-level, "%c", (*lptr < 32)?'.':*lptr);
+	      lptr++;
+	    }
+	  evax_debug (-level, "\n");
+	}
+    }
+  if ((count%16) != 0)
+    evax_debug (-level, "\n");
+
+  return;
+}
+#endif
+
+
+/* hash functions
+
+   These are needed when reading an object file.  */
+
+/* allocate new evax_hash_entry
+   keep the symbol name and a pointer to the bfd symbol in the table  */
+
+struct bfd_hash_entry *
+_bfd_evax_hash_newfunc (entry, table, string)
+     struct bfd_hash_entry *entry;
+     struct bfd_hash_table *table;
+     const char *string;
+{
+  evax_symbol_entry *ret = (evax_symbol_entry *)entry;
+
+#if EVAX_DEBUG
+  evax_debug (5, "_bfd_evax_hash_newfunc(%p, %p, %s)\n", entry, table, string);
+#endif
+
+  if (ret == (evax_symbol_entry *)NULL)
+    ret = ((evax_symbol_entry *) bfd_hash_allocate (table, sizeof (evax_symbol_entry)));
+  if (ret == (evax_symbol_entry *)NULL)
+    {
+      bfd_set_error (bfd_error_no_memory);
+      return (struct bfd_hash_entry *)NULL;
+    }
+  ret = (evax_symbol_entry *) bfd_hash_newfunc ((struct bfd_hash_entry *)ret, table, string);
+
+  ret->symbol = (asymbol *)NULL;
+
+  return (struct bfd_hash_entry *)ret;
+}
+
+
+/* object file input functions */
+
+/* Return type and length from record header (buf)  */
+
+void
+_bfd_evax_get_header_values (abfd, buf, type, length)
+     bfd *abfd;
+     unsigned char *buf;
+     int *type;
+     int *length;
+{
+  if (type != 0)
+    *type = bfd_getl16 (buf);
+  buf += 2;
+  if (length != 0)
+    *length = bfd_getl16 (buf);
+
+  return;
+}
+
+
+/* Get next record from object file to evax_buf
+   set PRIV(buf_size) and return it
+  
+   this is a little tricky since it should be portable.
+  
+   the openVMS/AXP 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 length at the first 2 bytes of every record. The same
+   happens during the transfer of object files from vms to unix,
+   at least with ucx, dec's implementation of tcp/ip.
+  
+   The EVAX format repeats the length 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.
+   first just the record header is read and the length extracted
+   by get_header_values
+   then the read buffer is adjusted and the remaining bytes are
+   read in.
+  
+   all file i/o is always done on even file positions  */
+
+int
+_bfd_evax_get_record (abfd)
+     bfd *abfd;
+{
+  int test_len, test_start, remaining;
+  unsigned char *evax_buf;
+
+#if EVAX_DEBUG
+  evax_debug (8, "_bfd_evax_get_record\n");
+#endif
+
+  /* minimum is 6 bytes
+     (2 bytes length, 2 bytes record id, 2 bytes length repeated)  */
+
+  if (PRIV(buf_size) == 0)
+    {
+      PRIV(evax_buf) = (unsigned char *) malloc (6);
+#if EVAX_DEBUG
+      evax_debug (9, "PRIV(evax_buf) %p\n", PRIV(evax_buf));
+#endif
+    }
+
+  evax_buf = PRIV(evax_buf);
+
+  if (evax_buf == 0)
+    {
+#if EVAX_DEBUG
+      evax_debug (9, "can't alloc evax_buf\n");
+#endif
+      bfd_set_error (bfd_error_no_memory);
+      return -1;
+    }
+
+  switch (PRIV(file_format))
+    {
+      case FF_UNKNOWN:
+      case FF_FOREIGN:
+	test_len = 6;				/* probe 6 bytes */
+	test_start = 2;				/* where the record starts */
+      break;
+
+      case FF_NATIVE:
+	test_len = 4;
+	test_start = 0;
+      break;
+  }
+
+  /* skip odd alignment byte  */
+#if 0
+  if (PRIV(file_format) == FF_FOREIGN)
+    {
+#endif
+      if (bfd_tell (abfd) & 1)
+	{
+#if EVAX_DEBUG
+	  evax_debug (10, "skip odd\n");
+#endif
+	  if (bfd_read (PRIV(evax_buf), 1, 1, abfd) != 1)
+	    {
+#if EVAX_DEBUG
+	      evax_debug (9, "skip odd failed\n");
+#endif
+	      bfd_set_error (bfd_error_file_truncated);
+	      return 0;
+	    }
+	}
+#if 0
+    }
+#endif
+  /* read the record header  */
+
+  if (bfd_read (PRIV(evax_buf), 1, test_len, abfd) != test_len)
+    {
+#if EVAX_DEBUG
+      evax_debug (9, "can't bfd_read test %d bytes\n", test_len);
+#endif
+      bfd_set_error (bfd_error_file_truncated);
+      return 0;
+    }
+
+  /* check file format on first call  */
+
+  if (PRIV(file_format) == FF_UNKNOWN)
+    {						/* record length repeats ? */
+      if ( (evax_buf[0] == evax_buf[4])
+        && (evax_buf[1] == evax_buf[5]))
+	{
+	  PRIV(file_format) = FF_FOREIGN;	/* Y: foreign environment */
+	  test_start = 2;
+	}
+      else
+	{
+	  PRIV(file_format) = FF_NATIVE;	/* N: native environment */
+	  test_start = 0;
+	}
+#if EVAX_DEBUG
+      evax_debug (10, "File format is %s\n", (PRIV(file_format) == FF_FOREIGN)?"foreign":"native");
+#endif
+    }
+
+  /* extract evax record length  */
+
+  _bfd_evax_get_header_values (abfd, evax_buf+test_start, NULL,
+			       &PRIV(rec_length));
+
+  if (PRIV(rec_length) <= 0)
+    {
+      bfd_set_error (bfd_error_file_truncated);
+      return 0;
+    }
+
+  /* that's what the linker manual says  */
+
+  if (PRIV(rec_length) > EOBJ_S_C_MAXRECSIZ)
+    {
+      bfd_set_error (bfd_error_file_truncated);
+      return 0;
+    }
+
+  /* adjust the buffer  */
+
+  if (PRIV(rec_length) > PRIV(buf_size))
+    {
+      PRIV(evax_buf) = (unsigned char *) realloc (evax_buf, PRIV(rec_length));
+#if EVAX_DEBUG
+      evax_debug (3, "adjusted the buffer (%p) from %d to %d\n", PRIV(evax_buf), PRIV(buf_size), PRIV(rec_length));
+#endif
+      evax_buf = PRIV(evax_buf);
+      if (evax_buf == 0)
+	{
+#if EVAX_DEBUG
+	  evax_debug (9, "can't realloc evax_buf to %d bytes\n", PRIV(rec_length));
+#endif
+	  bfd_set_error (bfd_error_no_memory);
+	  return -1;
+	}
+      PRIV(buf_size) = PRIV(rec_length);
+    }
+
+  /* read the remaining record  */
+
+  remaining = PRIV(rec_length) - test_len + test_start;
+
+  if (bfd_read (evax_buf + test_len, 1, remaining, abfd) != remaining)
+    {
+#if EVAX_DEBUG
+      evax_debug (9, "can't bfd_read remaining %d bytes\n", remaining);
+#endif
+      bfd_set_error (bfd_error_file_truncated);
+      return 0;
+    }
+
+  PRIV(evax_rec) = evax_buf + test_start;
+
+  return PRIV(rec_length);
+}
+
+
+/* get next EVAX record from file
+   update evax_rec and rec_length to new (remaining) values  */
+
+int
+_bfd_evax_next_record (abfd)
+     bfd *abfd;
+{
+#if EVAX_DEBUG
+  evax_debug (8, "_bfd_evax_next_record (len %d, size %d)\n",
+	      PRIV(rec_length), PRIV(rec_size));
+#endif
+
+  if (PRIV(rec_length) > 0)
+    {
+      PRIV(evax_rec) += PRIV(rec_size);
+    }
+  else
+    {
+      if (_bfd_evax_get_record (abfd) <= 0)
+	return -1;
+    }
+  _bfd_evax_get_header_values (abfd, PRIV(evax_rec), &PRIV(rec_type),
+			       &PRIV(rec_size));
+  PRIV(rec_length) -= PRIV(rec_size);
+
+#if EVAX_DEBUG
+  evax_debug (8, "_bfd_evax_next_record: rec %p, size %d, length %d, type %d\n",
+	      PRIV(evax_rec), PRIV(rec_size),	PRIV(rec_length),
+	      PRIV(rec_type));
+#endif
+
+  return PRIV(rec_type);
+}
+
+
+
+/* Copy sized string (string with fixed length) to new allocated area
+   size is string length (size of record)  */
+
+char *
+_bfd_evax_save_sized_string (str, size)
+     char *str;
+     int size;
+{
+  char *newstr = bfd_malloc (size + 1);
+
+  if (newstr == NULL)
+    return 0;
+  strncpy (newstr, str, size);
+  newstr[size] = 0;
+
+  return newstr;
+}
+
+/* Copy counted string (string with length at first byte) to new allocated area
+   ptr points to length byte on entry  */
+
+char *
+_bfd_evax_save_counted_string (ptr)
+     char *ptr;
+{
+  int len = *ptr++;
+
+  return _bfd_evax_save_sized_string (ptr, len);
+}
+
+
+/* stack routines for EVAX ETIR commands */
+
+/* Push value and section index  */
+
+void
+_bfd_evax_push (abfd, val, psect)
+     bfd *abfd;
+     uquad val;
+     int psect;
+{
+  static int last_psect;
+
+#if EVAX_DEBUG
+  evax_debug (4, "<push %016lx(%d) at %d>\n", val, psect, PRIV(stackptr));
+#endif
+
+  if (psect >= 0)
+    last_psect = psect;
+
+  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);
+      exit(1);
+    }
+  return;
+}
+
+
+/* Pop value and section index  */
+
+uquad
+_bfd_evax_pop (abfd, psect)
+     bfd *abfd;
+     int *psect;
+{
+  uquad value;
+
+  if (PRIV(stackptr) == 0)
+    {
+      bfd_set_error (bfd_error_bad_value);
+      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 EVAX_DEBUG
+  evax_debug (4, "<pop %016lx(%d)>\n", value, PRIV(stack[PRIV(stackptr)]).psect);
+#endif
+
+  return value;
+}
+
+
+/* object file output functions */
+
+/* GAS tends to write sections in little chunks (bfd_set_section_contents)
+   which we can't use directly. So we save the little chunks in linked
+   lists (one per section) and write them later.  */
+
+/* Add a new evax_section structure to evax_section_table
+   - forward chaining -  */
+
+static evax_section *
+add_new_contents (abfd, section)
+     bfd *abfd;
+     sec_ptr section;
+{
+  evax_section *sptr, *newptr;
+
+  newptr = (evax_section *) bfd_zalloc (abfd, sizeof (evax_section));
+  if (newptr == (evax_section *)NULL)
+    {
+      bfd_set_error (bfd_error_no_memory);
+      return NULL;
+    }
+  sptr = PRIV(evax_section_table)[section->index];
+  if (sptr == NULL)
+    {
+      PRIV(evax_section_table)[section->index] = (evax_section *)newptr;
+    }
+  else
+    {
+      while (sptr->next != NULL)
+	sptr = sptr->next;
+      sptr->next = newptr;
+    }
+  return newptr;
+}
+
+
+/* Save section data & offset to an evax_section structure
+   evax_section_table[] holds the evax_section chain  */
+
+boolean
+_bfd_save_evax_section (abfd, section, data, offset, count)
+     bfd *abfd;
+     sec_ptr section;
+     PTR data;
+     file_ptr offset;
+     bfd_size_type count;
+{
+  evax_section *sptr;
+
+  if (section->index >= EVAX_SECTION_COUNT)
+    {
+      bfd_set_error (bfd_error_nonrepresentable_section);
+      return false;
+    }
+  if (count == (bfd_size_type)0)
+    return true;
+  sptr = add_new_contents (abfd, section);
+  if (sptr == NULL)
+    return false;
+  sptr->contents = (unsigned char *) bfd_alloc (abfd, (int)count);
+  if (sptr->contents == (unsigned char *)NULL)
+    {
+      bfd_set_error (bfd_error_no_memory);
+      return false;
+    }
+  memcpy (sptr->contents, data, (int)count);
+  sptr->offset = (bfd_vma)offset;
+  sptr->size = count;
+
+#if EVAX_DEBUG
+  evax_debug (6, "_bfd_save_evax_section sptr = %08lx\n", sptr);
+  _bfd_hexdump (6, data, count, (int)offset);
+#endif
+
+  return true;
+}
+
+
+/* Get evax_section pointer to saved contents for section # index  */
+
+evax_section *
+_bfd_get_evax_section (abfd, index)
+     bfd *abfd;
+     int index;
+{
+  if (index >=  EVAX_SECTION_COUNT)
+    {
+      bfd_set_error (bfd_error_nonrepresentable_section);
+      return NULL;
+    }
+  return PRIV(evax_section_table)[index];
+}
+
+
+/* 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)  */
+
+void
+_bfd_evax_output_begin (abfd, rectype, rechead)
+     bfd *abfd;
+     int rectype;
+     int rechead;
+{
+#if EVAX_DEBUG
+  evax_debug (6, "_bfd_evax_output_begin(type %d, head %d)\n", rectype,
+	      rechead);
+#endif
+
+  _bfd_evax_output_short (abfd,rectype);
+
+  /* save current output position to fill in lenght later  */
+
+  if (PRIV(push_level) > 0)
+    PRIV(length_pos) = PRIV(output_size);
+
+#if EVAX_DEBUG
+  evax_debug (6, "_bfd_evax_output_begin: length_pos = %d\n",
+	      PRIV(length_pos));
+#endif
+
+  _bfd_evax_output_short (abfd,0);		/* placeholder for length */
+
+  if (rechead != -1)
+    _bfd_evax_output_short (abfd,rechead);
+
+  return;
+}
+
+
+/* Set record/subrecord alignment  */
+
+void
+_bfd_evax_output_alignment (abfd, alignto)
+     bfd *abfd;
+     int alignto;
+{
+#if EVAX_DEBUG
+  evax_debug (6, "_bfd_evax_output_alignment(%d)\n", alignto);
+#endif
+
+  PRIV(output_alignment) = alignto;
+  return;
+}
+
+
+/* Prepare for subrecord fields  */
+
+void
+_bfd_evax_output_push (abfd)
+     bfd *abfd;
+{
+#if EVAX_DEBUG
+  evax_debug (6, "evax_output_push(pushed_size = %d)\n", PRIV(output_size));
+#endif
+
+  PRIV(push_level)++;
+  PRIV(pushed_size) = PRIV(output_size);
+  return;
+}
+
+
+/* End of subrecord fields  */
+
+void
+_bfd_evax_output_pop (abfd)
+     bfd *abfd;
+{
+#if EVAX_DEBUG
+  evax_debug (6, "evax_output_pop(pushed_size = %d)\n", PRIV(pushed_size));
+#endif
+
+  _bfd_evax_output_flush (abfd);
+  PRIV(length_pos) = 2;
+
+#if EVAX_DEBUG
+  evax_debug (6, "evax_output_pop: length_pos = %d\n", PRIV(length_pos));
+#endif
+
+  PRIV(pushed_size) = 0;
+  PRIV(push_level)--;
+  return;
+}
+
+
+/* Flush unwritten output, ends current record  */
+
+void
+_bfd_evax_output_flush (abfd)
+     bfd *abfd;
+{
+  int real_size = PRIV(output_size);
+  int aligncount;
+  int length;
+
+#if EVAX_DEBUG
+  evax_debug (6, "_bfd_evax_output_flush(real_size = %d, pushed_size %d at lenpos %d)\n",
+	      real_size, PRIV(pushed_size), PRIV(length_pos));
+#endif
+
+  if (PRIV(push_level) > 0)
+    length = real_size - PRIV(pushed_size);
+  else
+    length = real_size;
+
+  if (length == 0)
+    return;
+  aligncount = (PRIV(output_alignment)
+		- (length % PRIV(output_alignment))) % PRIV(output_alignment);
+
+#if EVAX_DEBUG
+  evax_debug (6, "align: adding %d bytes\n", aligncount);
+#endif
+
+  while(aligncount-- > 0)
+    {
+      PRIV(output_buf)[real_size++] = 0;
+#if 0
+      /* this is why I *love* vms: inconsistency :-}
+	 alignment is added to the subrecord length
+	 but not to the record length  */
+      if (PRIV(push_level) > 0)
+#endif
+	length++;
+    }
+
+  /* put length to buffer  */
+  PRIV(output_size) = PRIV(length_pos);
+  _bfd_evax_output_short (abfd, (unsigned int)length);
+
+  if (PRIV(push_level) == 0)
+    {
+#ifndef VMS
+	/* write length first, see FF_FOREIGN in the input routines */
+      fwrite (PRIV(output_buf)+2, 2, 1, (FILE *)abfd->iostream);
+#endif
+      fwrite (PRIV(output_buf), real_size, 1, (FILE *)abfd->iostream);
+
+      PRIV(output_size) = 0;
+    }
+  else
+    {
+      PRIV(output_size) = real_size;
+      PRIV(pushed_size) = PRIV(output_size);
+    }
+
+  return;
+}
+
+
+/* End record output  */
+
+void
+_bfd_evax_output_end (abfd)
+     bfd *abfd;
+{
+#if EVAX_DEBUG
+  evax_debug (6, "_bfd_evax_output_end\n");
+#endif
+
+  _bfd_evax_output_flush (abfd);
+
+  return;
+}
+
+
+/* check remaining buffer size
+
+   return what's left.  */
+
+int
+_bfd_evax_output_check (abfd, size)
+    bfd *abfd;
+    int size;
+{
+#if EVAX_DEBUG
+  evax_debug (6, "_bfd_evax_output_check(%d)\n", size);
+#endif
+
+  return (MAX_OUTREC_SIZE - (PRIV(output_size) + size + MIN_OUTREC_LUFT));
+}
+
+
+/* Output byte (8 bit) value  */
+
+void
+_bfd_evax_output_byte (abfd, value)
+     bfd *abfd;
+     unsigned int value;
+{
+#if EVAX_DEBUG
+  evax_debug (6, "_bfd_evax_output_byte(%02x)\n", value);
+#endif
+
+  bfd_put_8 (abfd, value & 0xff, PRIV(output_buf) + PRIV(output_size));
+  PRIV(output_size) += 1;
+  return;
+}
+
+
+/* Output short (16 bit) value  */
+
+void
+_bfd_evax_output_short (abfd, value)
+     bfd *abfd;
+     unsigned int value;
+{
+#if EVAX_DEBUG
+  evax_debug (6, "_bfd_evax_output_short (%04x)\n", value);
+#endif
+
+  bfd_put_16 (abfd, value & 0xffff, PRIV(output_buf) + PRIV(output_size));
+  PRIV(output_size) += 2;
+  return;
+}
+
+
+/* Output long (32 bit) value  */
+
+void
+_bfd_evax_output_long (abfd, value)
+     bfd *abfd;
+     unsigned long value;
+{
+#if EVAX_DEBUG
+  evax_debug (6, "_bfd_evax_output_long (%08lx)\n", value);
+#endif
+
+  bfd_put_32 (abfd, value, PRIV(output_buf) + PRIV(output_size));
+  PRIV(output_size) += 4;
+  return;
+}
+
+
+/* Output quad (64 bit) value  */
+
+void
+_bfd_evax_output_quad (abfd, value)
+     bfd *abfd;
+     uquad value;
+{
+#if EVAX_DEBUG
+  evax_debug (6, "_bfd_evax_output_quad(%016lx)\n", value);
+#endif
+
+  bfd_put_64(abfd, value, PRIV(output_buf) + PRIV(output_size));
+  PRIV(output_size) += 8;
+  return;
+}
+
+
+/* Output c-string as counted string  */
+
+void
+_bfd_evax_output_counted (abfd, value)
+     bfd *abfd;
+     char *value;
+{
+int len;
+
+#if EVAX_DEBUG
+  evax_debug (6, "_bfd_evax_output_counted(%s)\n", value);
+#endif
+
+  len = strlen (value);
+  if (len == 0)
+    {
+      (*_bfd_error_handler) ("_bfd_evax_output_counted called with zero bytes");
+      return;
+    }
+  if (len > 255)
+    {
+      (*_bfd_error_handler) ("_bfd_evax_output_counted called with too many bytes");
+      return;
+    }
+  _bfd_evax_output_byte (abfd, len & 0xff);
+  _bfd_evax_output_dump (abfd, (unsigned char *)value, len);
+}
+
+
+/* Output character area  */
+
+void
+_bfd_evax_output_dump (abfd, data, length)
+     bfd *abfd;
+     unsigned char *data;
+     int length;
+{
+#if EVAX_DEBUG
+  evax_debug (6, "_bfd_evax_output_dump(%d)\n", length);
+#endif
+
+  if (length == 0)
+    return;
+
+  memcpy (PRIV(output_buf) + PRIV(output_size), data, length);
+  PRIV(output_size) += length;
+
+  return;
+}
+
+
+/* Output count bytes of value  */
+
+void
+_bfd_evax_output_fill (abfd, value, count)
+     bfd *abfd;
+     int value;
+     int count;
+{
+#if EVAX_DEBUG
+  evax_debug (6, "_bfd_evax_output_fill(val %02x times %d)\n", value, count);
+#endif
+
+  if (count == 0)
+    return;
+  memset (PRIV(output_buf) + PRIV(output_size), value, count);
+  PRIV(output_size) += count;
+
+  return;
+}
+
+/*-----------------------------------------------------------------------------*/
+
+/* Return basename (stripped of directory information) of filename  */
+
+char *
+_bfd_evax_basename (name)
+     char *name;
+{
+  char *ptr;
+
+#if EVAX_DEBUG
+  evax_debug (6, "_bfd_evax_basename %s -> ", name);
+#endif
+
+#ifndef VMS
+  /* assume unix host */
+  ptr = strrchr (name, '.');
+  if (ptr)
+    *ptr = 0;
+  ptr = strrchr (name, '/');
+  if (ptr)
+    *ptr++ = 0;
+  else
+    ptr = name;
+#else
+  /* assume vms host */
+  ptr = strrchr (name, '.');
+  if (ptr)
+    {
+      *ptr = 0;
+      ptr = name;
+    }
+  else
+    {
+      ptr = strrchr (name, ']');
+      if (ptr)
+	*ptr++ = 0;
+      else
+	{
+	  ptr = strrchr (name, ':');
+	  if (ptr)
+	    *ptr++ = 0;
+	  else
+	    ptr = name;
+	}
+    }
+#endif
+
+#if EVAX_DEBUG
+  evax_debug (6, "%s\n", ptr);
+#endif
+
+  return ptr;
+}
+
+
+/* Manufacure a VMS like time on a unix based system.
+   stolen from obj-vms.c  */
+
+char *
+_bfd_get_vms_time_string ()
+{
+  static char tbuf[18];
+#ifndef VMS
+#include <sys/types.h>
+#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 (tbuf, "%2s-%3s-%s %s", pnt + 8, pnt + 4, pnt + 20, pnt + 11);
+#else
+#include <starlet.h>
+  struct
+  {
+    int Size;
+    char *Ptr;
+  } Descriptor;
+  Descriptor.Size = 17;
+  Descriptor.Ptr = tbuf;
+  sys$asctim (0, &Descriptor, 0, 0);
+#endif /* not VMS */
+
+#if EVAX_DEBUG
+  evax_debug (6, "vmstimestring:'%s'\n", tbuf);
+#endif
+
+  return tbuf;
+}
diff --git a/bfd/evax.h b/bfd/evax.h
new file mode 100644
index 0000000..6717bdc
--- /dev/null
+++ b/bfd/evax.h
@@ -0,0 +1,382 @@
+/* evax.h -- Header file for ALPHA EVAX (openVMS/AXP) support.
+   Copyright 1996 Free Software Foundation, Inc.
+   Written by Klaus Kämpf (kkaempf@progis.de)
+   of proGIS Softwareentwicklung, Aachen, Germany
+
+This file is part of BFD, the Binary File Descriptor library.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#ifndef EVAX_H
+#define EVAX_H
+
+/* EVAX Text, information and relocation record (ETIR) definitions.  */
+
+#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 plus quadword offset  */
+#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    */
+
+/* EVAX Global symbol definition record (EGSD).  */
+
+#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		*/
+
+#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 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
+
+/* EVAX Module header record (EMH) definitions.  */
+
+#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	*/
+
+/* evax-alpha.c.  */
+
+extern asymbol *_bfd_evax_make_empty_symbol PARAMS ((bfd *abfd));
+
+/* evax-egsd.c.  */
+
+extern int _bfd_evax_slurp_egsd PARAMS ((bfd *abfd));
+extern int _bfd_evax_write_egsd PARAMS ((bfd *abfd));
+
+/* evax-emh.c.  */
+
+extern int _bfd_evax_slurp_emh PARAMS ((bfd *abfd));
+extern int _bfd_evax_write_emh PARAMS ((bfd *abfd));
+extern int _bfd_evax_slurp_eeom PARAMS ((bfd *abfd));
+extern int _bfd_evax_write_eeom PARAMS ((bfd *abfd));
+
+/* evax-etir.c.  */
+
+extern int _bfd_evax_slurp_etir PARAMS ((bfd *abfd));
+extern int _bfd_evax_slurp_edbg PARAMS ((bfd *abfd));
+extern int _bfd_evax_slurp_etbt PARAMS ((bfd *abfd));
+
+extern int _bfd_evax_write_etir PARAMS ((bfd *abfd));
+extern int _bfd_evax_write_etbt PARAMS ((bfd *abfd));
+extern int _bfd_evax_write_edbg PARAMS ((bfd *abfd));
+
+/* 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_SWREL32		12
+#define ALPHA_R_SWREL64		13
+#define ALPHA_R_REFLONG		14
+
+/* Object language definitions.  */
+
+#define EOBJ_S_C_EMH 8            /*EVAX module header record         */
+#define EOBJ_S_C_EEOM 9           /*EVAX end of module record         */
+#define EOBJ_S_C_EGSD 10          /*EVAX global symbol definition record  */
+#define EOBJ_S_C_ETIR 11          /*EVAX text information record      */
+#define EOBJ_S_C_EDBG 12          /*EVAX Debugger information record  */
+#define EOBJ_S_C_ETBT 13          /*EVAX Traceback information record  */
+#define EOBJ_S_C_MAXRECTYP 13     /*Last assigned record type         */
+#define EOBJ_S_K_SUBTYP 4
+#define EOBJ_S_C_SUBTYP 4
+#define EOBJ_S_C_MAXRECSIZ 8192   /*Maximum legal record size         */
+#define EOBJ_S_C_STRLVL 2         /*Structure level                   */
+#define EOBJ_S_C_SYMSIZ 64        /*Maxymum symbol length             */
+#define EOBJ_S_C_STOREPLIM -1     /*Maximum repeat count on store commands  */
+#define EOBJ_S_C_PSCALILIM 16     /*Maximum p-sect alignment          */
+
+/* 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
+
+typedef struct _evax_section {
+  unsigned char *contents;
+  bfd_vma offset;
+  bfd_size_type size;
+  struct _evax_section *next;
+} evax_section;
+
+extern boolean _bfd_save_evax_section
+  PARAMS ((bfd *abfd, asection *section, PTR data, file_ptr offset,
+	   bfd_size_type count));
+extern evax_section *_bfd_get_evax_section PARAMS ((bfd *abfd, int index));
+
+typedef struct _evax_reloc {
+  struct _evax_reloc *next;
+  arelent *reloc;
+  asection *section;
+} evax_reloc;
+
+/* evax module header  */
+
+struct emh_struc {
+  int emh_b_strlvl;
+  long emh_l_arch1;
+  long emh_l_arch2;
+  long emh_l_recsiz;
+  char *emh_t_name;
+  char *emh_t_version;
+  char *emh_t_date;
+  char *emh_c_lnm;
+  char *emh_c_src;
+  char *emh_c_ttl;
+};
+
+
+/* evax end of module  */
+
+struct eeom_struc {
+  long eeom_l_total_lps;
+  unsigned char eeom_b_comcod;
+  boolean eeom_has_transfer;
+  unsigned char eeom_b_tfrflg;
+  long eeom_l_psindx;
+  long eeom_l_tfradr;
+};
+
+enum file_format_enum { FF_UNKNOWN, FF_FOREIGN, FF_NATIVE };
+
+typedef struct evax_symbol_struct {
+  struct bfd_hash_entry bfd_hash;
+  asymbol *symbol;
+} evax_symbol_entry;
+
+/* stack value for push/pop commands  */
+
+struct stack_struct {
+  uquad value;
+  int psect;
+};
+#define STACKSIZE 50
+
+/* location stack definitions for CTL_DFLOC, CTL_STLOC, and CTL_STKDL  */
+
+struct location_struct {
+  unsigned long value;
+  int psect;
+};
+#define LOCATION_SAVE_SIZE 32
+
+#define EVAX_SECTION_COUNT 32
+
+struct evax_private_data_struct {
+  char *filename;			/* Filename of object file   */
+  boolean fixup_done;			/* Flag to indicate if all
+					   section pointers and PRIV(sections)
+					   are set up correctly  */
+  unsigned char *evax_buf;		/* buffer to record  */
+  int buf_size;				/* max size of buffer  */
+  unsigned char *evax_rec;		/* actual record ptr  */
+  int rec_length;			/* remaining record length  */
+  int rec_size;				/* actual record size  */
+  int rec_type;				/* actual record type  */
+  enum file_format_enum file_format;
+
+  struct emh_struc emh_data;		/* data from EMH record  */
+  struct eeom_struc eeom_data;		/* data from EEOM record  */
+  int egsd_sec_count;			/* # of EGSD sections  */
+  asection **sections;			/* vector of EGSD sections  */
+  int egsd_sym_count;			/* # of EGSD symbols  */
+  asymbol **symbols;			/* vector of EGSD symbols  */
+  struct proc_value *procedure;
+
+  struct stack_struct *stack;
+  int stackptr;
+
+  evax_section *evax_section_table[EVAX_SECTION_COUNT];
+  evax_reloc *evax_reloc_table[EVAX_SECTION_COUNT];
+
+  struct bfd_hash_table *evax_symbol_table;
+  struct symbol_cache_entry **symcache;
+  int symnum;
+
+  struct location_struct *location_stack;
+
+  unsigned char *image_ptr;		/* a pointer to section->contents */
+
+  unsigned char pdsc[8];		/* procedure descriptor */
+
+  /* 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 (ETIR_S_C_STC_)  */
+
+  int evax_linkage_index;
+
+};
+
+#define PRIV(name)	((struct evax_private_data_struct *)abfd->tdata.any)->name
+
+#if EVAX_DEBUG
+extern void _bfd_evax_debug PARAMS((int level, char *format, ...));
+extern void _bfd_hexdump
+  PARAMS ((int level, unsigned char *ptr, int size, int offset));
+
+#define evax_debug _bfd_evax_debug
+
+#endif
+
+extern struct bfd_hash_entry *_bfd_evax_hash_newfunc
+  PARAMS ((struct bfd_hash_entry *entry, struct bfd_hash_table *table,
+	   const char *string));
+extern void _bfd_evax_get_header_values
+  PARAMS ((bfd *abfd, unsigned char *buf, int *type, int *length));
+extern int _bfd_evax_get_record PARAMS ((bfd *abfd));
+extern int _bfd_evax_next_record PARAMS ((bfd *abfd));
+
+extern char *_bfd_evax_save_sized_string PARAMS ((char *str, int size));
+extern char *_bfd_evax_save_counted_string PARAMS ((char *ptr));
+extern void _bfd_evax_push PARAMS ((bfd *abfd, uquad val, int psect));
+extern uquad _bfd_evax_pop PARAMS ((bfd *abfd, int *psect));
+
+extern boolean _bfd_save_evax_section
+  PARAMS ((bfd *abfd, asection *section, PTR data, file_ptr offset,
+	   bfd_size_type count));
+extern void _bfd_evax_output_begin
+  PARAMS ((bfd *abfd, int rectype, int rechead));
+extern void _bfd_evax_output_alignment PARAMS ((bfd *abfd, int alignto));
+extern void _bfd_evax_output_push PARAMS ((bfd *abfd));
+extern void _bfd_evax_output_pop PARAMS ((bfd *abfd));
+extern void _bfd_evax_output_flush PARAMS ((bfd *abfd));
+extern void _bfd_evax_output_end PARAMS ((bfd *abfd));
+extern int _bfd_evax_output_check PARAMS ((bfd *abfd, int size));
+extern void _bfd_evax_output_byte PARAMS ((bfd *abfd, unsigned int value));
+extern void _bfd_evax_output_short PARAMS ((bfd *abfd, unsigned int value));
+extern void _bfd_evax_output_long PARAMS ((bfd *abfd, unsigned long value));
+extern void _bfd_evax_output_quad PARAMS ((bfd *abfd, uquad value));
+extern void _bfd_evax_output_counted PARAMS ((bfd *abfd, char *value));
+extern void _bfd_evax_output_dump PARAMS ((bfd *abfd, unsigned char *data,
+					   int length));
+extern void _bfd_evax_output_fill PARAMS ((bfd *abfd, int value, int length));
+extern char *_bfd_get_vms_time_string PARAMS ((void));
+extern char *_bfd_evax_basename PARAMS ((char *name));
+
+#endif /* EVAX_H */
diff --git a/bfd/hosts/.Sanitize b/bfd/hosts/.Sanitize
index 7f47671..5ce2c15 100644
--- a/bfd/hosts/.Sanitize
+++ b/bfd/hosts/.Sanitize
@@ -25,6 +25,7 @@ Do-first:
 Things-to-keep:
 
 alphalinux.h
+alphavms.h
 decstation.h
 delta68.h
 dpx2.h
diff --git a/bfd/hosts/alphavms.h b/bfd/hosts/alphavms.h
new file mode 100644
index 0000000..38f8153
--- /dev/null
+++ b/bfd/hosts/alphavms.h
@@ -0,0 +1,65 @@
+/* alphavms.h -- BFD definitions for an openVMS host
+   Copyright 1996 Free Software Foundation, Inc.
+   Written by Klaus Kämpf (kkaempf@progis.de)
+   of proGIS Softwareentwicklung, Aachen, Germany
+
+This file is part of BFD, the Binary File Descriptor library.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#include <stddef.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <ctype.h>
+#include <string.h>
+#include <sys/file.h>
+#include <stdlib.h>
+#include <unixlib.h>
+#include <unixio.h>
+#include <time.h>
+
+#include "bfd.h"
+
+#ifndef BFD_HOST_64_BIT
+/* Make the basic types 64-bit quantities on the host.
+   Also provide the support macros BFD needs.  */
+# ifdef __GNUC__
+#  define	BFD_HOST_64_BIT	long long
+# else
+#  define	BFD_HOST_64_BIT	long
+# endif
+typedef unsigned BFD_HOST_64_BIT uint64_type;
+typedef BFD_HOST_64_BIT int64_type;
+
+# define sprintf_vma(s,x) sprintf (s, "%016lx", x) /* BFD_HOST_64_BIT */
+# define fprintf_vma(f,x) fprintf (f, "%016lx", x) /* BFD_HOST_64_BIT */
+
+# define BYTES_IN_PRINTF_INT 4
+
+/* These must have type unsigned long because they are used as
+   arguments in printf functions.  */
+# define uint64_typeLOW(x) ((unsigned long) (((x) & 0xffffffff))) /* BFD_HOST_64_BIT */
+# define uint64_typeHIGH(x) ((unsigned long) (((x) >> 32) & 0xffffffff)) /* BFD_HOST_64_BIT */
+
+#endif /* BFD_HOST_64_BIT */
+
+#include "fopen-vms.h"
+
+#define NO_FCNTL 1
+
+extern int getpagesize PARAMS ((void));
diff --git a/bfd/makefile.vms b/bfd/makefile.vms
new file mode 100644
index 0000000..8331dfc
--- /dev/null
+++ b/bfd/makefile.vms
@@ -0,0 +1,40 @@
+#
+# Makefile for bfd library under openVMS/AXP
+#
+# For use with gnu-make for vms
+#
+# Created by Klaus Kaempf, kkaempf@progis.de
+#
+#
+CC=gcc
+
+OBJS=archive.obj,archures.obj,bfd.obj,cache.obj,coffgen.obj,corefile.obj,format.obj,\
+  init.obj,libbfd.obj,opncls.obj,reloc.obj,section.obj,syms.obj,targets.obj,\
+  hash.obj,linker.obj,elf.obj,srec.obj,binary.obj,tekhex.obj,ihex.obj,stab-syms.obj,\
+  evax-alpha.obj,evax-emh.obj,evax-egsd.obj,evax-etir.obj,evax-misc.obj,\
+  cpu-alpha.obj
+
+ifeq ($(CC),gcc)
+DEFS=/define=(SELECT_VECS="&evax_alpha_vec",SELECT_ARCHITECTURES="&bfd_alpha_arch","unlink=remove")
+CFLAGS=/include=([],[-.include])$(DEFS)
+else
+DEFS=/define=(DEFAULT_VECTOR="evax_alpha_vec",SELECT_VECS="&evax_alpha_vec",\
+SELECT_ARCHITECTURES="&bfd_alpha_arch","unlink=remove",\
+"_bfd_generic_get_section_contents_in_window"="_bfd_generic_get_win_section_cont",\
+"_bfd_elf_section_from_bfd_section"="_bfd_elf_sec_from_bfd_sec")
+CFLAGS=/machine/list=cc.s/noopt/debug/include=([],[-.include])$(DEFS)
+endif
+
+
+libbfd.olb: sysdep.h bfd.h $(OBJS)
+	purge
+	lib/create libbfd $(OBJS)
+
+sysdep.h: [.hosts]alphavms.h config.h
+	$(CP) $< $@
+
+bfd.h: bfd.h-vms
+	$(CP) $< $@
+
+config.h: config.h-vms
+	$(CP) $< $@