2009-03-03 Tristan Gingold <gingold@adacore.com>

	    Eric Botcazou  <ebotcazou@adacore.com>
	    Douglas B Rupp  <rupp@gnat.com>

	* doc/as.texinfo (Overview): Mention -replace/-noreplace options
	for Alpha.
	* doc/c-alpha.texi (Alpha Options): Document -replace/-noreplace.
	* config/tc-alpha.h (TC_VALIDATE_FIX_SUB): Define to 1 (evax).
	(OBJ_SYMFIELD_TYPE): Remove.
	(tc_canonicalize_symbol_name): Define to evax_shorten_name.
	(TC_IMPLICIT_LCOMM_ALIGNMENT): For alignment to 3 on evax.
	(tc_frob_file_before_fix): Do not defined on evax.
	* config/tc-alpha.c: Always includes dwarf2dbg.h.
	Include vms.h if OBJ_EVAX.
	(struct alpha_fixup): Add xtrasym and procsym (evax only).
	(enum alpha_macro_arg): Remove trailing comma.
	(md_longopts): Add replace and noreplace arguments (evax only).
	(alpha_evax_proc_hash): New variable.
	(alpha_link_section): Make it global.
	(alpha_ctors_section, alpha_dtors_section): Removed.
	(alpha_ctors_symbol, alpha_dtors_symbol): Ditto.
	(alpha_lit8_section): Ifndef'ed on evax.
	(alpha_lit8_symbol): Ditto.
	(alpha_prologue_label): New variable.
	(alpha_linkage_symbol): New variable (evax only).
	(alpha_flag_replace): Ditto.
	(struct alpha_evax_procs): Add handler and handler_data field.
	(alpha_evax_proc): Now of type pointer.
	(alpha_linkage_fixup_root, alpha_linkage_fixup_tail): New variables.
	(struct alpha_reloc_tag): Add sym and psym fields (evax only).
	(get_alpha_reloc_tag): Initialize sym and psym fields (evax only).
	(alpha_adjust_relocs): Ifndef'ed on evax.
	(load_expression): Add opname argument.
	Implement LDA/BSR optimization for evax.
	(emit_lda): Adjust for new prototype of load_expression.
	(emit_ir_load): Ditto. Do not nothing for GP if ..lk symbols.
	(emit_loadstore): Likewise.
	(emit_ldXu): Likewise.
	(emit_stX): Likewise.
	(emit_jsrjmp): Likewise.  Implement LDA/BSR optimization for evax.
	(emit_ldgp): Avoid warning in evax case.
	(add_to_link_pool): Make it static.  Return symbolic expression rather
	than number expression for the offset.
	(s_alpha_text): Create .text symbol for evax if not already created.
	(s_alpha_comm): Do not create specific section for common symbol.
	Fill common area with zeros for evax.
	(s_alpha_prologue): Create alpha_prologue_label.
	(s_alpha_section_name): New function (evax).
	(s_alpha_section_word): Likewise.
	(section_name): New static variabke moved out from ...
	(s_alpha_section): ... here.  Create new sections on demand.
	(s_alpha_literals): New function (evax).
	(s_alpha_ent): Create alpha_evax_proc instance and insert it in the
	alpha_evax_proc_hash table.
	(s_alpha_handler): New function (evax).
	(s_alpha_frame): Adjust for new type of alpha_evax_proc.
	(s_alpha_prologue): New function (evax).
	(s_alpha_pdesc): Adjust for new type of alpha_evax_proc and new
	handling of procedures with hash table.
	Add support for condition handlers.
	(s_alpha_linkage): Create linkage_fixup instance and chain it.
	(s_alpha_fp_save): Adjust for new type of alpha_evax_proc.
	(s_alpha_mask): Likewise.
	(s_alpha_fmask): Likewise.
	(s_alpha_end): Clear alpha_evax_proc.
	(s_alpha_align): Increase max_alignment to 16.
	(alpha_print_token): Call print_expr_1 instead of print_expr.
	(md_pseudo_table): Add "section", "literals", "handler" and
	"handler_data" (evax).  Do not ignore "prologue" on evax.
	Fix indentation.
	(md_begin): Create hash table for alpha_evax_proc_hash.
	(md_parse_option): Handle OPTION_REPLACE and OPTION_NOREPLACE.
	(md_show_usage): Mention -replace/-noreplace for evax.
	(md_apply_fix): Handle evax relocs (_NOP, _LDA, _BSR and _BOH).
	(alpha_force_relocation): Likewise.
	(alpha_fix_adjustable): Likewise. Add BFD_RELOC_16 case.
	(tc_gen_reloc): Likewise.  Add BFD_RELOC_ALPHA_LINKAGE for evax.
	(emit_insn): New cases for evax specific relocs.
	(assemble_insn): Fix indentation.
	Take care of -MDISP in operand table.
	* config/obj-evax.h (struct alpha_linkage_fixups): New struct.
	(OBJ_SYMFIELD_TYPE): New macro.
	(obj_symbol_new_hook): Define.
	(obj_frob_symbol, obj_frob_file_before_adjust): Ditto.
	(obj_frob_file_before_fix): Ditto.
	(PDSC_S_M_HANDLER_VALID): New macro.
	(PDSC_S_M_HANDLER_DATA_VALID): Ditto.
	(TC_IMPLICIT_LCOMM_ALIGNMENT): Remove.
	Add prototypes for functions declared in obj-evax.c
	* config/obj-evax.c: Include subsegs.h, struc-symbol.h, safe-ctype.h.
	(s_evax_weak): Convert to ansi-C.
	(evax_symbol_new_hook): New function.
	(evax_frob_symbol): Ditto.
	(evax_frob_file_before_adjust): Ditto.
	(evax_frob_file_before_fix): Ditto.
	(evax_shorten_name): Ditto.
	(crc32): Ditto.
	(encode_32): Ditto.
	(encode_16): Ditto.
	(decode_16): Ditto.
	(shorten_identifier): Ditto.
	(is_truncated_identifier): Ditto.
	* dwarf2dbg.c (out_debug_info): Do not append trailing slash on	VMS.
	* as.c (close_output_file): Remove #ifndef OBJ_VMS.
	(main): Ditto.

9 files changed, 1487 insertions, 216 deletions

diff --git a/gas/ChangeLog b/gas/ChangeLog
index 7bd0ec2..d90b214 100644
--- a/gas/ChangeLog
+++ b/gas/ChangeLog
@@ -1,3 +1,109 @@
+2009-03-03  Tristan Gingold  <gingold@adacore.com>
+	    Eric Botcazou  <ebotcazou@adacore.com>
+	    Douglas B Rupp  <rupp@gnat.com>
+
+	* doc/as.texinfo (Overview): Mention -replace/-noreplace options
+	for Alpha.
+	* doc/c-alpha.texi (Alpha Options): Document -replace/-noreplace.
+	* config/tc-alpha.h (TC_VALIDATE_FIX_SUB): Define to 1 (evax).
+	(OBJ_SYMFIELD_TYPE): Remove.
+	(tc_canonicalize_symbol_name): Define to evax_shorten_name.
+	(TC_IMPLICIT_LCOMM_ALIGNMENT): For alignment to 3 on evax.
+	(tc_frob_file_before_fix): Do not defined on evax.
+	* config/tc-alpha.c: Always includes dwarf2dbg.h.
+	Include vms.h if OBJ_EVAX.
+	(struct alpha_fixup): Add xtrasym and procsym (evax only).
+	(enum alpha_macro_arg): Remove trailing comma.
+	(md_longopts): Add replace and noreplace arguments (evax only).
+	(alpha_evax_proc_hash): New variable.
+	(alpha_link_section): Make it global.
+	(alpha_ctors_section, alpha_dtors_section): Removed.
+	(alpha_ctors_symbol, alpha_dtors_symbol): Ditto.
+	(alpha_lit8_section): Ifndef'ed on evax.
+	(alpha_lit8_symbol): Ditto.
+	(alpha_prologue_label): New variable.
+	(alpha_linkage_symbol): New variable (evax only).
+	(alpha_flag_replace): Ditto.
+	(struct alpha_evax_procs): Add handler and handler_data field.
+	(alpha_evax_proc): Now of type pointer.
+	(alpha_linkage_fixup_root, alpha_linkage_fixup_tail): New variables.
+	(struct alpha_reloc_tag): Add sym and psym fields (evax only).
+	(get_alpha_reloc_tag): Initialize sym and psym fields (evax only).
+	(alpha_adjust_relocs): Ifndef'ed on evax.
+	(load_expression): Add opname argument.
+	Implement LDA/BSR optimization for evax.
+	(emit_lda): Adjust for new prototype of load_expression.
+	(emit_ir_load): Ditto. Do not nothing for GP if ..lk symbols.
+	(emit_loadstore): Likewise.
+	(emit_ldXu): Likewise.
+	(emit_stX): Likewise.
+	(emit_jsrjmp): Likewise.  Implement LDA/BSR optimization for evax.
+	(emit_ldgp): Avoid warning in evax case.
+	(add_to_link_pool): Make it static.  Return symbolic expression rather
+	than number expression for the offset.
+	(s_alpha_text): Create .text symbol for evax if not already created.
+	(s_alpha_comm): Do not create specific section for common symbol.
+	Fill common area with zeros for evax.
+	(s_alpha_prologue): Create alpha_prologue_label.
+	(s_alpha_section_name): New function (evax).
+	(s_alpha_section_word): Likewise.
+	(section_name): New static variabke moved out from ...
+	(s_alpha_section): ... here.  Create new sections on demand.
+	(s_alpha_literals): New function (evax).
+	(s_alpha_ent): Create alpha_evax_proc instance and insert it in the
+	alpha_evax_proc_hash table.
+	(s_alpha_handler): New function (evax).
+	(s_alpha_frame): Adjust for new type of alpha_evax_proc.
+	(s_alpha_prologue): New function (evax).
+	(s_alpha_pdesc): Adjust for new type of alpha_evax_proc and new
+	handling of procedures with hash table.
+	Add support for condition handlers.
+	(s_alpha_linkage): Create linkage_fixup instance and chain it.
+	(s_alpha_fp_save): Adjust for new type of alpha_evax_proc.
+	(s_alpha_mask): Likewise.
+	(s_alpha_fmask): Likewise.
+	(s_alpha_end): Clear alpha_evax_proc.
+	(s_alpha_align): Increase max_alignment to 16.
+	(alpha_print_token): Call print_expr_1 instead of print_expr.
+	(md_pseudo_table): Add "section", "literals", "handler" and 
+	"handler_data" (evax).  Do not ignore "prologue" on evax.
+	Fix indentation.
+	(md_begin): Create hash table for alpha_evax_proc_hash.
+	(md_parse_option): Handle OPTION_REPLACE and OPTION_NOREPLACE.
+	(md_show_usage): Mention -replace/-noreplace for evax.
+	(md_apply_fix): Handle evax relocs (_NOP, _LDA, _BSR and _BOH).
+	(alpha_force_relocation): Likewise.
+	(alpha_fix_adjustable): Likewise. Add BFD_RELOC_16 case.
+	(tc_gen_reloc): Likewise.  Add BFD_RELOC_ALPHA_LINKAGE for evax.
+	(emit_insn): New cases for evax specific relocs.
+	(assemble_insn): Fix indentation.
+	Take care of -MDISP in operand table.
+	* config/obj-evax.h (struct alpha_linkage_fixups): New struct.
+	(OBJ_SYMFIELD_TYPE): New macro.
+	(obj_symbol_new_hook): Define.
+	(obj_frob_symbol, obj_frob_file_before_adjust): Ditto.
+	(obj_frob_file_before_fix): Ditto.
+	(PDSC_S_M_HANDLER_VALID): New macro.
+	(PDSC_S_M_HANDLER_DATA_VALID): Ditto.
+	(TC_IMPLICIT_LCOMM_ALIGNMENT): Remove.
+	Add prototypes for functions declared in obj-evax.c
+	* config/obj-evax.c: Include subsegs.h, struc-symbol.h, safe-ctype.h.
+	(s_evax_weak): Convert to ansi-C.
+	(evax_symbol_new_hook): New function.
+	(evax_frob_symbol): Ditto.
+	(evax_frob_file_before_adjust): Ditto.
+	(evax_frob_file_before_fix): Ditto.
+	(evax_shorten_name): Ditto.
+	(crc32): Ditto.
+	(encode_32): Ditto.
+	(encode_16): Ditto.
+	(decode_16): Ditto.
+	(shorten_identifier): Ditto.
+	(is_truncated_identifier): Ditto.
+	* dwarf2dbg.c (out_debug_info): Do not append trailing slash on	VMS.
+	* as.c (close_output_file): Remove #ifndef OBJ_VMS.
+	(main): Ditto.
+
 2009-03-02  Nick Clifton  <nickc@redhat.com>
 
 	PR 9874
diff --git a/gas/as.c b/gas/as.c
index 246ee68..87e88da 100644
--- a/gas/as.c
+++ b/gas/as.c
@@ -948,13 +948,11 @@ dump_statistics (void)
 #endif
 }
 
-#ifndef OBJ_VMS
 static void
 close_output_file (void)
 {
   output_file_close (out_file_name);
 }
-#endif
 
 /* The interface between the macro code and gas expression handling.  */
 
@@ -1136,10 +1134,8 @@ main (int argc, char ** argv)
   input_scrub_begin ();
   expr_begin ();
 
-#ifndef OBJ_VMS /* Does its own file handling.  */
   /* It has to be called after dump_statistics ().  */
   xatexit (close_output_file);
-#endif
 
   if (flag_print_statistics)
     xatexit (dump_statistics);
diff --git a/gas/config/obj-evax.c b/gas/config/obj-evax.c
index a0cbae2..eb50283 100644
--- a/gas/config/obj-evax.c
+++ b/gas/config/obj-evax.c
@@ -2,6 +2,7 @@
    Copyright 1996, 1997, 2007, 2008 Free Software Foundation, Inc.
    Contributed by Klaus Kämpf (kkaempf@progis.de) of
      proGIS Software, Aachen, Germany.
+   Extensively enhanced by Douglas Rupp of AdaCore.
 
    This file is part of GAS, the GNU Assembler
 
@@ -22,9 +23,18 @@
 
 #define OBJ_HEADER "obj-evax.h"
 
+#include "bfd.h"
+#include "vms.h"
 #include "as.h"
+#include "subsegs.h"
+#include "struc-symbol.h"
+#include "safe-ctype.h"
 
 static void s_evax_weak (int);
+static unsigned int crc32 (unsigned char *, int);
+static char *encode_32 (unsigned int);
+static char *encode_16 (unsigned int);
+static int decode_16 (const char *);
 
 const pseudo_typeS obj_pseudo_table[] =
 {
@@ -37,8 +47,7 @@ void obj_read_begin_hook () {}
 /* Handle the weak specific pseudo-op.  */
 
 static void
-s_evax_weak (ignore)
-     int ignore;
+s_evax_weak (int ignore ATTRIBUTE_UNUSED)
 {
   char *name;
   int c;
@@ -73,11 +82,436 @@ s_evax_weak (ignore)
   demand_empty_rest_of_line ();
 }
 
-/*
- * Local Variables:
- * comment-column: 0
- * fill-column: 131
- * End:
- */
+void
+evax_symbol_new_hook (symbolS *sym)
+{
+  struct evax_private_udata_struct *udata;
+
+  udata = (struct evax_private_udata_struct *)
+    xmalloc (sizeof (struct evax_private_udata_struct));
+
+  udata->bsym = symbol_get_bfdsym (sym);
+  udata->enbsym = NULL;
+  udata->origname = xstrdup (S_GET_NAME (sym));
+  udata->lkindex = 0;
+  symbol_get_bfdsym(sym)->udata.p = (PTR) udata;
+}
+
+void
+evax_frob_symbol (symbolS *sym, int *punt)
+{
+  const char *symname = S_GET_NAME (sym);
+  int symlen = strlen (symname);
+  asymbol *symbol = symbol_get_bfdsym (sym);
+
+  if (symlen > 4
+      && strcmp (symname + symlen - 4, "..en") == 0
+      && S_GET_SEGMENT (sym) == undefined_section)
+    {
+      symbol_clear_used_in_reloc (sym);
+      *punt = 1;
+    }
+
+  else if ((symbol->flags & BSF_GLOBAL) && (symbol->flags & BSF_FUNCTION))
+    {
+      struct evax_private_udata_struct *udata
+	= (struct evax_private_udata_struct *)symbol->udata.p;
+
+      /* Fix up equates of function definitions.  */
+      while (udata->enbsym == NULL)
+	{
+	  /* ??? Equates have been resolved at this point so their
+	     expression is O_constant; but they previously were
+	     O_symbol and we hope the equated symbol is still there.  */
+	  sym = symbol_get_value_expression (sym)->X_add_symbol;
+	  if (sym == NULL)
+	    abort ();
+	  symbol = symbol_get_bfdsym (sym);
+	  udata->enbsym
+	    = ((struct evax_private_udata_struct *)symbol->udata.p)->enbsym;
+	}
+    }
+}
+
+void
+evax_frob_file_before_adjust (void)
+{
+  struct alpha_linkage_fixups *l;
+  segT current_section = now_seg;
+  int current_subsec = now_subseg;
+  segment_info_type *seginfo;
+  int linkage_index = 1;
+
+  subseg_set (alpha_link_section, 0);
+  seginfo = seg_info (alpha_link_section);
+
+  for (l = alpha_linkage_fixup_root; l != NULL; l = l->next)
+    {
+      if (S_GET_SEGMENT (l->fixp->fx_addsy) == alpha_link_section)
+	{
+	  symbolS * entry_sym;
+	  fixS *fixpentry, *fixppdesc, *fixtail;
+
+	  fixtail = seginfo->fix_tail;
+
+	  /* Replace the linkage with the local symbols */
+	  entry_sym = symbol_find
+	    (((struct evax_private_udata_struct *)symbol_get_bfdsym (l->fixp->fx_addsy)->udata.p)->enbsym->name);
+	  if (!entry_sym)
+	    abort ();
+	  fixpentry = fix_new (l->fixp->fx_frag, l->fixp->fx_where, 8,
+			       entry_sym, l->fixp->fx_offset, 0,
+			       BFD_RELOC_64);
+	  fixppdesc = fix_new (l->fixp->fx_frag, l->fixp->fx_where+8, 8,
+			       l->fixp->fx_addsy, l->fixp->fx_offset, 0,
+			       BFD_RELOC_64);
+	  l->fixp->fx_size = 0;
+	  l->fixp->fx_done = 1;
+
+	  /* If not already at the tail, splice the new fixups into
+	     the chain right after the one we are nulling out */
+	  if (fixtail != l->fixp)
+	    {
+	      fixppdesc->fx_next = l->fixp->fx_next;
+	      l->fixp->fx_next = fixpentry;
+	      fixtail->fx_next = 0;
+	      seginfo->fix_tail = fixtail;
+	    }
+	}
+      else
+	{
+	  ((struct evax_private_udata_struct *)
+	   symbol_get_bfdsym (l->label)->udata.p)->lkindex = linkage_index;
+
+	  l->fixp->fx_addnumber = linkage_index;
+
+	  linkage_index += 2;
+	}
+    }
+
+  subseg_set (current_section, current_subsec);
+}
+
+void
+evax_frob_file_before_fix (void)
+{
+  /* Now that the fixups are done earlier, we need to transfer the values
+     into the BFD symbols before calling fix_segment (ideally should not
+     be done also later).  */
+  if (symbol_rootP)
+    {
+      symbolS *symp;
+
+      /* Set the value into the BFD symbol.  Up til now the value
+	 has only been kept in the gas symbolS struct.  */
+      for (symp = symbol_rootP; symp; symp = symbol_next (symp))
+	symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
+    }
+}
+
+/* The length is computed from the maximum allowable length of 64 less the
+   4 character ..xx extension that must be preserved (removed before
+   krunching and appended back on afterwards).  The $<nnn>.. prefix is
+   also removed and prepened back on, but doesn't enter into the length
+   computation because symbols with that prefix are always resolved
+   by the assembler and will never appear in the symbol table. At least
+   I hope that's true, TBD.  */
+#define MAX_LABEL_LENGTH 60
+
+static char *shorten_identifier (char *);
+static int is_truncated_identifier (char *);
+
+char *
+evax_shorten_name (char *id)
+{
+  int prefix_dotdot = 0;
+  char prefix [64];
+  int len = strlen (id);
+  int suffix_dotdot = len;
+  char suffix [64];
+  char *base_id;
+
+  /* This test may be too conservative.  */
+  if (len <= MAX_LABEL_LENGTH)
+    return id;
+
+  suffix [0] = 0;
+  prefix [0] = 0;
+
+  /* Check for ..xx suffix and save it.  */
+  if (strncmp (&id[len-4], "..", 2) == 0)
+    {
+      suffix_dotdot = len - 4;
+      strncpy (suffix, &id[len-4], 4);
+      suffix [4] = 0;
+    }
+
+  /* Check for $<nnn>.. prefix and save it.  */
+  if ((id[0] == '$') && ISDIGIT (id[1]))
+    {
+      int i;
+
+      for (i=2; i < len; i++)
+        {
+	  if (!ISDIGIT (id[i]))
+            {
+	      if (id[i] == '.' && id [i+1] == '.')
+                 {
+                   prefix_dotdot = i+2;
+                   strncpy (prefix, id, prefix_dotdot);
+                   prefix [prefix_dotdot] = 0;
+                 }
+               break;
+            }
+        }
+    }
+
+  /* We only need worry about krunching the base symbol.  */
+  base_id = xmalloc (suffix_dotdot - prefix_dotdot + 1);
+  strncpy (base_id, &id[prefix_dotdot], suffix_dotdot - prefix_dotdot);
+  base_id [suffix_dotdot - prefix_dotdot] = 0;
+
+  if (strlen (base_id) > MAX_LABEL_LENGTH)
+    {
+      char new_id [4096];
+      char *return_id;
+
+      strcpy (new_id, base_id);
+
+      /* Shorten it.  */
+      strcpy (new_id, shorten_identifier (new_id));
+
+      /* Prepend back the prefix if there was one.  */
+      if (prefix_dotdot)
+        {
+          memmove (&new_id [prefix_dotdot], new_id, strlen (new_id) + 1);
+          strncpy (new_id, prefix, prefix_dotdot);
+        }
+
+      /* Append back the suffix if there was one.  */
+      if (strlen (suffix))
+	strcat (new_id, suffix);
+
+      /* Save it on the heap and return.  */
+      return_id = xmalloc (strlen (new_id) + 1);
+      strcpy (return_id, new_id);
+
+      return return_id;
+    }
+  else
+    return id;
+}
+
+/* The code below implements a mechanism for truncating long
+   identifiers to an arbitrary length (set by MAX_LABEL_LENGTH).
+
+   It attempts to make each truncated identifier unique by replacing
+   part of the identifier with an encoded 32-bit CRC and an associated
+   checksum (the checksum is used as a way to determine that the name
+   was truncated).
+
+   Note that both a portion of the start and of the end of the
+   identifier may be kept.  The macro ID_SUFFIX_LENGTH will return the
+   number of characters in the suffix of the identifier that should be
+   kept.
+
+   The portion of the identifier that is going to be removed is
+   checksummed.  The checksum is then encoded as a 5-character string,
+   the characters of which are then summed.  This sum is then encoded
+   as a 3-character string.  Finally, the original length of the
+   identifier is encoded as a 3-character string.
+
+   These three strings are then concatenated together (along with an _h
+   which further designates that the name was truncated):
+
+   "original_identifier"_haaaaabbbccc
+   
+   aaaaa = 32-bit CRC
+   bbb = length of original identifier
+   ccc = sum of 32-bit CRC characters
+
+   The resulting identifier will be MAX_LABEL_LENGTH characters long.
+
+   */
+
+
+/* Table used to convert an integer into a string.  */
+
+static const char codings[] = {
+  'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
+  'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
+  'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+  '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '_'};
+
+/* The number of codings in the above table.  */
+static const int number_of_codings = sizeof (codings) / sizeof (char);
+
+/* Table used by decode_16 () to convert an encoded string back into
+   an integer.  */
+static char decodings[256];
+
+/* Table used by the crc32 function to calcuate the checksum.  */
+static unsigned int crc32_table[256] = {0, 0};
+
+/* Given a string in BUF, calculate a 32-bit CRC for it. 
+
+   This is used as a reasonably unique hash for the given string.  */
+
+static unsigned int
+crc32 (unsigned char *buf, int len)
+{
+  unsigned int crc = 0xffffffff;
+
+  if (! crc32_table[1])
+    {
+      /* Initialize the CRC table and the decoding table. */
+      int i, j;
+      unsigned int c;
+
+      for (i = 0; i < 256; i++)
+	{
+	  for (c = i << 24, j = 8; j > 0; --j)
+	    c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1);
+	  crc32_table[i] = c;
+	  decodings[i] = 0;
+	}
+      for (i = 0; i < number_of_codings; i++)
+	decodings[codings[i] & 255] = i;
+    }
+
+  while (len--)
+    {
+      crc = (crc << 8) ^ crc32_table[(crc >> 24) ^ *buf];
+      buf++;
+    }
+  return crc;
+}
+
+/* Encode the lower 32 bits of VALUE as a 5-character string.  */
+
+static char *
+encode_32 (unsigned int value)
+{
+  static char res[6];
+  int x;
+
+  res[5] = 0;
+  for(x = 0; x < 5; x++)
+    {
+      res[x] = codings[value % number_of_codings];
+      value = value / number_of_codings;
+    }
+  return res;
+}
+
+/* Encode the lower 16 bits of VALUE as a 3-character string.  */
+
+static char *
+encode_16 (unsigned int value)
+{
+  static char res[4];
+  int x;
+
+  res[3] = 0;
+  for(x = 0; x < 3; x++)
+    {
+      res[x] = codings[value % number_of_codings];
+      value = value / number_of_codings;
+    }
+  return res;
+}
+
+/* Convert the encoded string obtained from encode_16 () back into a
+   16-bit integer.  */
+
+static int
+decode_16 (const char *string)
+{
+  return decodings[(int) string[2]] * number_of_codings * number_of_codings
+    + decodings[(int) string[1]] * number_of_codings
+    + decodings[(int) string[0]];
+}
+
+/* ID_SUFFIX_LENGTH is used to determine how many characters in the
+   suffix of the identifier are to be preserved, if any.  */
+
+#ifndef ID_SUFFIX_LENGTH
+#define ID_SUFFIX_LENGTH(ID) (0)
+#endif
+
+/* Return a reasonably-unique version of NAME that is less than or
+   equal to MAX_LABEL_LENGTH characters long.  The string returned from
+   this function may be a copy of NAME; the function will never
+   actually modify the contents of NAME.  */
+
+static char newname[MAX_LABEL_LENGTH + 1];
+
+static char *
+shorten_identifier (char *name)
+{
+  int crc, len, sum, x, final_len;
+  char *crc_chars;
+  int suffix_length = ID_SUFFIX_LENGTH (name);
+
+  if ((len = strlen (name)) <= MAX_LABEL_LENGTH)
+    return name;
+
+  final_len = MAX_LABEL_LENGTH - 2 - 5 - 3 - 3 - suffix_length;
+  crc = crc32 ((unsigned char *)name + final_len,
+	       len - final_len - suffix_length);
+  crc_chars = encode_32 (crc);
+  sum = 0;
+  for (x = 0; x < 5; x++)
+    sum += crc_chars [x];
+  strncpy (newname, name, final_len);
+  newname [MAX_LABEL_LENGTH] = 0;
+  /* Now append the suffix of the original identifier, if any.  */
+  if (suffix_length)
+  strncpy (newname + MAX_LABEL_LENGTH - suffix_length,
+	   name + len - suffix_length,
+	   suffix_length);
+  strncpy (newname + final_len, "_h", 2);
+  strncpy (newname + final_len + 2 , crc_chars, 5);
+  strncpy (newname + final_len + 2 + 5, encode_16 (len), 3);
+  strncpy (newname + final_len + 2 + 5 + 3, encode_16 (sum), 3);
+  if (!is_truncated_identifier (newname))
+    abort ();
+  return newname;
+}
+
+/* Determine whether or not ID is a truncated identifier, and return a
+   non-zero value if it is.  */
+
+static int
+is_truncated_identifier (char *id)
+{
+  char *ptr;
+  int len = strlen (id);
+  /* If it's not exactly MAX_LABEL_LENGTH characters long, it can't be
+     a truncated identifier.  */
+  if (len != MAX_LABEL_LENGTH)
+    return 0;
+  
+  /* Start scanning backwards for a _h.  */
+  len = len - 3 - 3 - 5 - 2;
+  ptr = id + len;
+  while (ptr >= id)
+    {
+      if (ptr[0] == '_' && ptr[1] == 'h')
+	{
+	  /* Now see if the sum encoded in the identifer matches.  */
+	  int x, sum;
+	  sum = 0;
+	  for (x = 0; x < 5; x++)
+	    sum += ptr[x + 2];
+	  /* If it matches, this is probably a truncated identifier.  */
+	  if (sum == decode_16 (ptr + 5 + 2 + 3))
+	    return 1;
+	}
+      ptr--;
+    }
+  return 0;
+}
 
 /* end of obj-evax.c */
diff --git a/gas/config/obj-evax.h b/gas/config/obj-evax.h
index 824eeac..162d566 100644
--- a/gas/config/obj-evax.h
+++ b/gas/config/obj-evax.h
@@ -25,6 +25,8 @@
  * object format specific header files.
  */
 
+#include "as.h"
+
 /* define an obj specific macro off which target cpu back ends may key.  */
 #define OBJ_EVAX 1
 
@@ -33,6 +35,16 @@
 
 #define OUTPUT_FLAVOR bfd_target_evax_flavour
 
+struct fix;
+
+struct alpha_linkage_fixups
+{
+  struct alpha_linkage_fixups *next;
+  struct fix *fixp;
+  segT seg;
+  symbolS *label;
+};
+
 /*
  * SYMBOLS
  */
@@ -58,7 +70,13 @@ typedef void *object_headers;
 
 #define OBJ_EMIT_LINENO(a,b,c)	/* must be *something*.  This no-op's it out.  */
 
-#define obj_symbol_new_hook(s)        {;}
+/* This field keeps the symbols position in the link section.  */
+#define OBJ_SYMFIELD_TYPE valueT
+
+#define obj_symbol_new_hook(s)       evax_symbol_new_hook (s)
+#define obj_frob_symbol(s,p)         evax_frob_symbol (s, &p)
+#define obj_frob_file_before_adjust  evax_frob_file_before_adjust
+#define obj_frob_file_before_fix     evax_frob_file_before_fix
 
 #define S_SET_OTHER(S,V)
 #define S_SET_TYPE(S,T)
@@ -75,13 +93,23 @@ typedef void *object_headers;
 #define PDSC_S_K_MIN_REGISTER_SIZE 24
 #define PDSC_S_K_NULL_SIZE 16
 
-#define PDSC_S_M_BASE_REG_IS_FP 0x80	/* low byte */
+#define PDSC_S_M_HANDLER_VALID 0x10		/* low byte */
+#define PDSC_S_M_HANDLER_DATA_VALID 0x40	/* low byte */
+#define PDSC_S_M_BASE_REG_IS_FP 0x80		/* low byte */
 #define PDSC_S_M_NATIVE 0x10		/* high byte */
 #define PDSC_S_M_NO_JACKET 0x20		/* high byte */
 
 #define LKP_S_K_SIZE 16
 
-#define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR) (P2VAR) = 3
+extern segT alpha_link_section;
+extern struct alpha_linkage_fixups *alpha_linkage_fixup_root;
+
+extern void evax_section (int);
+extern void evax_symbol_new_hook (symbolS *);
+extern void evax_frob_symbol (symbolS *, int *);
+extern void evax_frob_file_before_adjust (void);
+extern void evax_frob_file_before_fix (void);
+extern char *evax_shorten_name (char *);
 
 /*
  * Local Variables:
diff --git a/gas/config/tc-alpha.c b/gas/config/tc-alpha.c
index cc3f74e..bc355b8 100644
--- a/gas/config/tc-alpha.c
+++ b/gas/config/tc-alpha.c
@@ -57,9 +57,13 @@
 
 #ifdef OBJ_ELF
 #include "elf/alpha.h"
-#include "dwarf2dbg.h"
 #endif
 
+#ifdef OBJ_EVAX
+#include "vms.h"
+#endif
+
+#include "dwarf2dbg.h"
 #include "dw2gencfi.h"
 #include "safe-ctype.h"
 
@@ -74,6 +78,9 @@ struct alpha_fixup
 {
   expressionS exp;
   bfd_reloc_code_real_type reloc;
+#ifdef OBJ_EVAX
+  symbolS *xtrasym, *procsym;
+#endif
 };
 
 struct alpha_insn
@@ -92,7 +99,7 @@ enum alpha_macro_arg
     MACRO_OPIR,
     MACRO_CPIR,
     MACRO_FPR,
-    MACRO_EXP,
+    MACRO_EXP
   };
 
 struct alpha_macro
@@ -245,6 +252,12 @@ struct option md_longopts[] =
     { "mdebug", no_argument, NULL, OPTION_MDEBUG },
     { "no-mdebug", no_argument, NULL, OPTION_NO_MDEBUG },
 #endif
+#ifdef OBJ_EVAX
+#define OPTION_REPLACE (OPTION_RELAX + 1)
+#define OPTION_NOREPLACE (OPTION_REPLACE+1)
+    { "replace", no_argument, NULL, OPTION_REPLACE },
+    { "noreplace", no_argument, NULL, OPTION_NOREPLACE },    
+#endif
     { NULL, no_argument, NULL, 0 }
   };
 
@@ -268,6 +281,9 @@ size_t md_longopts_size = sizeof (md_longopts);
 
 #undef AXP_REG_GP
 #define AXP_REG_GP AXP_REG_PV
+
+static struct hash_control *alpha_evax_proc_hash;
+
 #endif /* OBJ_EVAX  */
 
 /* The cpu for which we are generating code.  */
@@ -299,11 +315,11 @@ static symbolS *alpha_register_table[64];
 static segT alpha_lita_section;
 #endif
 #ifdef OBJ_EVAX
-static segT alpha_link_section;
-static segT alpha_ctors_section;
-static segT alpha_dtors_section;
+segT alpha_link_section;
 #endif
+#ifndef OBJ_EVAX
 static segT alpha_lit8_section;
+#endif
 
 /* Symbols referring to said sections.  */
 #ifdef OBJ_ECOFF
@@ -311,10 +327,10 @@ static symbolS *alpha_lita_symbol;
 #endif
 #ifdef OBJ_EVAX
 static symbolS *alpha_link_symbol;
-static symbolS *alpha_ctors_symbol;
-static symbolS *alpha_dtors_symbol;
 #endif
+#ifndef OBJ_EVAX
 static symbolS *alpha_lit8_symbol;
+#endif
 
 /* Literal for .litX+0x8000 within .lita.  */
 #ifdef OBJ_ECOFF
@@ -339,6 +355,12 @@ static int alpha_addr32_on = 0;
    and the section happens to not be on an eight byte boundary, it
    will align both the symbol and the .quad to an eight byte boundary.  */
 static symbolS *alpha_insn_label;
+static symbolS *alpha_prologue_label;
+
+#ifdef OBJ_EVAX
+/* Symbol associate with the current jsr instruction.  */
+static symbolS *alpha_linkage_symbol;
+#endif
 
 /* Whether we should automatically align data generation pseudo-ops.
    .align 0 will turn this off.  */
@@ -358,6 +380,11 @@ static int alpha_debug;
 int alpha_flag_mdebug = -1;
 #endif
 
+#ifdef OBJ_EVAX
+/* Whether to perform the VMS procedure call optimization.  */
+int alpha_flag_replace = 1;
+#endif
+
 /* Don't fully resolve relocations, allowing code movement in the linker.  */
 static int alpha_flag_relax;
 
@@ -366,7 +393,7 @@ static int g_switch_value = 8;
 
 #ifdef OBJ_EVAX
 /* Collect information about current procedure here.  */
-static struct
+struct alpha_evax_procs
 {
   symbolS *symbol;	/* Proc pdesc symbol.  */
   int pdsckind;
@@ -379,7 +406,14 @@ static struct
   long fmask;
   int type;
   int prologue;
-} alpha_evax_proc;
+  symbolS *handler;
+  int handler_data;
+};
+
+struct alpha_linkage_fixups *alpha_linkage_fixup_root;
+static struct alpha_linkage_fixups *alpha_linkage_fixup_tail;
+
+static struct alpha_evax_procs *alpha_evax_proc;
 
 static int alpha_flag_hash_long_names = 0;		/* -+ */
 static int alpha_flag_show_after_trunc = 0;		/* -H */
@@ -451,6 +485,10 @@ static const int alpha_num_reloc_op
 struct alpha_reloc_tag
 {
   fixS *master;			/* The literal reloc.  */
+#ifdef OBJ_EVAX
+  struct symbol *sym;
+  struct symbol *psym;
+#endif
   fixS *slaves;			/* Head of linked list of lituses.  */
   segT segment;			/* Segment relocs are in or undefined_section.  */
   long sequence;		/* Sequence #.  */
@@ -527,6 +565,10 @@ static const char * const ldXu_op[] = { "ldbu", "ldwu", NULL, NULL };
 static void assemble_insn (const struct alpha_opcode *, const expressionS *, int, struct alpha_insn *, bfd_reloc_code_real_type);
 static void emit_insn (struct alpha_insn *);
 static void assemble_tokens (const char *, const expressionS *, int, int);
+#ifdef OBJ_EVAX
+static char *s_alpha_section_name (void);
+static symbolS *add_to_link_pool (symbolS *, symbolS *, offsetT);
+#endif
 
 static struct alpha_reloc_tag *
 get_alpha_reloc_tag (long sequence)
@@ -550,11 +592,17 @@ get_alpha_reloc_tag (long sequence)
       errmsg = hash_insert (alpha_literal_hash, info->string, (void *) info);
       if (errmsg)
 	as_fatal (errmsg);
+#ifdef OBJ_EVAX
+      info->sym = 0;
+      info->psym = 0;
+#endif
     }
 
   return info;
 }
 
+#ifndef OBJ_EVAX
+
 static void
 alpha_adjust_relocs (bfd *abfd ATTRIBUTE_UNUSED,
 		     asection *sec,
@@ -718,6 +766,8 @@ alpha_before_fix (void)
   if (alpha_literal_hash)
     bfd_map_over_sections (stdoutput, alpha_adjust_relocs, NULL);
 }
+
+#endif
 
 #ifdef DEBUG_ALPHA
 static void
@@ -1176,7 +1226,8 @@ static long
 load_expression (int targreg,
 		 const expressionS *exp,
 		 int *pbasereg,
-		 expressionS *poffset)
+		 expressionS *poffset,
+		 const char *opname)
 {
   long emit_lituse = 0;
   offsetT addend = exp->X_add_number;
@@ -1268,11 +1319,9 @@ load_expression (int targreg,
 	insn.sequence = emit_lituse = next_sequence_num--;
 #endif /* OBJ_ELF */
 #ifdef OBJ_EVAX
-	offsetT link;
-
 	/* Find symbol or symbol pointer in link section.  */
 
-	if (exp->X_add_symbol == alpha_evax_proc.symbol)
+	if (exp->X_add_symbol == alpha_evax_proc->symbol)
 	  {
 	    if (range_signed_16 (addend))
 	      {
@@ -1292,20 +1341,97 @@ load_expression (int targreg,
 	  }
 	else
 	  {
-	    if (!range_signed_32 (addend))
+	    const char *symname = S_GET_NAME (exp->X_add_symbol);
+	    const char *ptr1, *ptr2;
+	    int symlen = strlen (symname);
+
+	    if ((symlen > 4 &&
+		 strcmp (ptr2 = &symname [symlen - 4], "..lk") == 0))
 	      {
-		link = add_to_link_pool (alpha_evax_proc.symbol,
-					 exp->X_add_symbol, addend);
-		addend = 0;
+		set_tok_reg (newtok[0], targreg);
+
+		newtok[1] = *exp;
+		newtok[1].X_op = O_subtract;
+		newtok[1].X_op_symbol = alpha_evax_proc->symbol;
+
+		set_tok_preg (newtok[2], basereg);
+		assemble_tokens_to_insn ("ldq", newtok, 3, &insn);
+		alpha_linkage_symbol = exp->X_add_symbol;
+
+		if (poffset)
+		  set_tok_const (*poffset, 0);
+
+		if (alpha_flag_replace && targreg == 26)
+		  {
+		    char *ensymname;
+		    symbolS *ensym;
+		    volatile asymbol *dummy;
+
+		    ptr1 = strstr (symname, "..") + 2;
+		    if (ptr1 > ptr2)
+		      ptr1 = symname;
+		    ensymname = (char *) xmalloc (ptr2 - ptr1 + 5);
+		    memcpy (ensymname, ptr1, ptr2 - ptr1);
+		    memcpy (ensymname + (ptr2 - ptr1), "..en", 5);
+
+		    assert (insn.nfixups + 1 <= MAX_INSN_FIXUPS);
+		    insn.fixups[insn.nfixups].reloc = BFD_RELOC_ALPHA_NOP;
+		    ensym = symbol_find_or_make (ensymname);
+		    ensym->sy_used = 1;
+		    /* The fixup must be the same as the BFD_RELOC_ALPHA_BOH
+		       case in emit_jsrjmp.  See B.4.5.2 of the OpenVMS Linker
+		       Utility Manual.  */
+		    insn.fixups[insn.nfixups].exp.X_op = O_symbol;
+		    insn.fixups[insn.nfixups].exp.X_add_symbol = ensym;
+		    insn.fixups[insn.nfixups].exp.X_add_number = 0;
+		    insn.fixups[insn.nfixups].xtrasym = alpha_linkage_symbol;
+		    insn.fixups[insn.nfixups].procsym = alpha_evax_proc->symbol;
+		    insn.nfixups++;
+
+		    /* ??? Force bsym to be instantiated now, as it will be
+		       too late to do so in tc_gen_reloc.  */
+		    dummy = symbol_get_bfdsym (exp->X_add_symbol);
+		  }
+		else if (alpha_flag_replace && targreg == 27)
+		  {
+		    char *psymname;
+		    symbolS *psym;
+
+		    ptr1 = strstr (symname, "..") + 2;
+		    if (ptr1 > ptr2)
+		      ptr1 = symname;
+		    psymname = (char *) xmalloc (ptr2 - ptr1 + 1);
+		    memcpy (psymname, ptr1, ptr2 - ptr1);
+		    psymname [ptr2 - ptr1] = 0;
+		    assert (insn.nfixups + 1 <= MAX_INSN_FIXUPS);
+		    insn.fixups[insn.nfixups].reloc = BFD_RELOC_ALPHA_LDA;
+		    psym = symbol_find_or_make (psymname);
+		    psym->sy_used = 1;
+		    insn.fixups[insn.nfixups].exp.X_op = O_subtract;
+		    insn.fixups[insn.nfixups].exp.X_add_symbol = psym;
+		    insn.fixups[insn.nfixups].exp.X_op_symbol = alpha_evax_proc->symbol;
+		    insn.fixups[insn.nfixups].exp.X_add_number = 0;
+		    insn.fixups[insn.nfixups].xtrasym = alpha_linkage_symbol;
+		    insn.fixups[insn.nfixups].procsym = alpha_evax_proc->symbol;
+		    insn.nfixups++;
+		  }
+
+		emit_insn(&insn);
+		return 0;
 	      }
 	    else
-	      link = add_to_link_pool (alpha_evax_proc.symbol,
-				       exp->X_add_symbol, 0);
+	      {
+		symbolS *linkexp;
 
-	    set_tok_reg (newtok[0], targreg);
-	    set_tok_const (newtok[1], link);
-	    set_tok_preg (newtok[2], basereg);
-	    assemble_tokens_to_insn ("ldq", newtok, 3, &insn);
+		if (!range_signed_32 (addend))
+		  addend = sign_extend_32 (addend);
+		linkexp = add_to_link_pool (alpha_evax_proc->symbol,
+					    exp->X_add_symbol, 0);
+		set_tok_reg (newtok[0], targreg);
+		set_tok_sym (newtok[1], linkexp, 0);
+		set_tok_preg (newtok[2], basereg);
+		assemble_tokens_to_insn ("ldq", newtok, 3, &insn);
+	      }
 	  }
 #endif /* OBJ_EVAX */
 
@@ -1335,7 +1461,7 @@ load_expression (int targreg,
       set_tok_reg (newtok[0], targreg);
       newtok[1] = *exp;
       set_tok_preg (newtok[2], basereg);
-      assemble_tokens ("lda", newtok, 3, 0);
+      assemble_tokens (opname, newtok, 3, 0);
 
       if (poffset)
 	set_tok_const (*poffset, 0);
@@ -1357,16 +1483,20 @@ load_expression (int targreg,
 
   if (!range_signed_32 (addend))
     {
+#ifdef OBJ_EVAX
+      symbolS *litexp;
+#else
       offsetT lit;
       long seq_num = next_sequence_num--;
+#endif
 
       /* For 64-bit addends, just put it in the literal pool.  */
 #ifdef OBJ_EVAX
       /* Emit "ldq targreg, lit(basereg)".  */
-      lit = add_to_link_pool (alpha_evax_proc.symbol,
-			      section_symbol (absolute_section), addend);
+      litexp = add_to_link_pool (alpha_evax_proc->symbol,
+				 section_symbol (absolute_section), addend);
       set_tok_reg (newtok[0], targreg);
-      set_tok_const (newtok[1], lit);
+      set_tok_sym (newtok[1], litexp, 0);
       set_tok_preg (newtok[2], alpha_gp_register);
       assemble_tokens ("ldq", newtok, 3, 0);
 #else
@@ -1525,7 +1655,7 @@ emit_lda (const expressionS *tok,
   else
     basereg = tok[2].X_add_number;
 
-  (void) load_expression (tok[0].X_add_number, &tok[1], &basereg, NULL);
+  (void) load_expression (tok[0].X_add_number, &tok[1], &basereg, NULL, "lda");
 }
 
 /* The ldah macro differs from the ldah instruction in that it has $31
@@ -1636,8 +1766,20 @@ emit_insn (struct alpha_insn *insn)
 	  assert (reloc_howto);
 
 	  size = bfd_get_reloc_size (reloc_howto);
-	  assert (size >= 1 && size <= 4);
 
+	  switch (fixup->reloc)
+	    {
+#ifdef OBJ_EVAX
+	    case BFD_RELOC_ALPHA_NOP:
+	    case BFD_RELOC_ALPHA_BSR:
+	    case BFD_RELOC_ALPHA_LDA:
+	    case BFD_RELOC_ALPHA_BOH:
+	      break;
+#endif
+	    default:
+	      assert (size >= 1 && size <= 4);
+	    }
+ 
 	  pcrel = reloc_howto->pc_relative;
 	}
 
@@ -1784,6 +1926,18 @@ emit_insn (struct alpha_insn *insn)
 	  fixP->tc_fix_data.info = info;
 	  break;
 #endif
+#ifdef OBJ_EVAX
+	case BFD_RELOC_ALPHA_NOP:
+	case BFD_RELOC_ALPHA_LDA:
+	case BFD_RELOC_ALPHA_BSR:
+	case BFD_RELOC_ALPHA_BOH:
+	  info = get_alpha_reloc_tag (next_sequence_num--);
+	  fixP->tc_fix_data.info = info;
+	  fixP->tc_fix_data.info->sym = fixup->xtrasym;
+	  fixP->tc_fix_data.info->psym = fixup->procsym;
+	  break;
+#endif
+
 	default:
 	  if ((int) fixup->reloc < 0)
 	    {
@@ -1963,8 +2117,9 @@ assemble_insn (const struct alpha_opcode *opcode,
 	}
 
       /* If this is a real relocation (as opposed to a lituse hint), then
-	 the relocation width should match the operand width.  */
-      else if (reloc < BFD_RELOC_UNUSED)
+	 the relocation width should match the operand width.
+	 Take care of -MDISP in operand table.  */ 
+      else if (reloc < BFD_RELOC_UNUSED && reloc > 0)
 	{
 	  reloc_howto_type *reloc_howto
 	    = bfd_reloc_type_lookup (stdoutput, reloc);
@@ -2000,15 +2155,22 @@ emit_ir_load (const expressionS *tok,
   long lituse;
   expressionS newtok[3];
   struct alpha_insn insn;
+  const char *symname
+    = tok[1].X_add_symbol ? S_GET_NAME (tok[1].X_add_symbol): "";
+  int symlen = strlen (symname);
 
   if (ntok == 2)
     basereg = (tok[1].X_op == O_constant ? AXP_REG_ZERO : alpha_gp_register);
   else
     basereg = tok[2].X_add_number;
 
-  lituse = load_expression (tok[0].X_add_number, &tok[1], &basereg,
-			    &newtok[1]);
+  lituse = load_expression (tok[0].X_add_number, &tok[1],
+			    &basereg, &newtok[1], opname);
 
+  if (basereg == alpha_gp_register &&
+      (symlen > 4 && strcmp (&symname [symlen - 4], "..lk") == 0))
+    return;
+  
   newtok[0] = tok[0];
   set_tok_preg (newtok[2], basereg);
 
@@ -2049,7 +2211,8 @@ emit_loadstore (const expressionS *tok,
       if (alpha_noat_on)
 	as_bad (_("macro requires $at register while noat in effect"));
 
-      lituse = load_expression (AXP_REG_AT, &tok[1], &basereg, &newtok[1]);
+      lituse = load_expression (AXP_REG_AT, &tok[1], 
+				&basereg, &newtok[1], opname);
     }
   else
     {
@@ -2100,7 +2263,7 @@ emit_ldXu (const expressionS *tok,
 	basereg = tok[2].X_add_number;
 
       /* Emit "lda $at, exp".  */
-      lituse = load_expression (AXP_REG_AT, &tok[1], &basereg, NULL);
+      lituse = load_expression (AXP_REG_AT, &tok[1], &basereg, NULL, "lda");
 
       /* Emit "ldq_u targ, 0($at)".  */
       newtok[0] = tok[0];
@@ -2252,7 +2415,7 @@ emit_stX (const expressionS *tok,
 	basereg = tok[2].X_add_number;
 
       /* Emit "lda $at, exp".  */
-      lituse = load_expression (AXP_REG_AT, &tok[1], &basereg, NULL);
+      lituse = load_expression (AXP_REG_AT, &tok[1], &basereg, NULL, "lda");
 
       /* Emit "ldq_u $t9, 0($at)".  */
       set_tok_reg (newtok[0], AXP_REG_T9);
@@ -2662,15 +2825,14 @@ emit_jsrjmp (const expressionS *tok,
   else
     {
       int basereg = alpha_gp_register;
-      lituse = load_expression (r = AXP_REG_PV, &tok[tokidx], &basereg, NULL);
+      lituse = load_expression (r = AXP_REG_PV, &tok[tokidx],
+				&basereg, NULL, opname);
     }
 #endif
 
   set_tok_cpreg (newtok[1], r);
 
-#ifdef OBJ_EVAX
-  /* FIXME: Add hint relocs to BFD for evax.  */
-#else
+#ifndef OBJ_EVAX
   if (tokidx < ntok)
     newtok[2] = tok[tokidx];
   else
@@ -2688,6 +2850,41 @@ emit_jsrjmp (const expressionS *tok,
       insn.sequence = lituse;
     }
 
+#ifdef OBJ_EVAX
+  if (alpha_flag_replace
+      && r == AXP_REG_RA
+      && tok[tokidx].X_add_symbol
+      && alpha_linkage_symbol)
+    {
+      const char *symname = S_GET_NAME (tok[tokidx].X_add_symbol);
+      int symlen = strlen (symname);
+      char *ensymname;
+
+      ensymname = (char *) xmalloc (symlen + 5);
+      memcpy (ensymname, symname, symlen);
+      memcpy (ensymname + symlen, "..en", 5);
+
+      assert (insn.nfixups < MAX_INSN_FIXUPS);
+      if (insn.nfixups > 0)
+	{
+	  memmove (&insn.fixups[1], &insn.fixups[0],
+		   sizeof(struct alpha_fixup) * insn.nfixups);
+	}
+
+      /* The fixup must be the same as the BFD_RELOC_ALPHA_NOP
+	 case in load_expression.  See B.4.5.2 of the OpenVMS
+	 Linker Utility Manual.  */
+      insn.fixups[0].reloc = BFD_RELOC_ALPHA_BOH;
+      insn.fixups[0].exp.X_op = O_symbol;
+      insn.fixups[0].exp.X_add_symbol = symbol_find_or_make (ensymname);
+      insn.fixups[0].exp.X_add_number = 0;
+      insn.fixups[0].xtrasym = alpha_linkage_symbol;
+      insn.fixups[0].procsym = alpha_evax_proc->symbol;
+      insn.nfixups++;
+      alpha_linkage_symbol = 0;
+    }
+#endif
+
   emit_insn (&insn);
 }
 
@@ -2784,7 +2981,10 @@ FIXME
   insn.sequence = next_sequence_num--;
 
   emit_insn (&insn);
-#endif /* OBJ_ECOFF || OBJ_ELF */
+#else /* OBJ_ECOFF || OBJ_ELF */
+  /* Avoid warning.  */
+  tok = NULL;
+#endif
 }
 
 /* The macro table.  */
@@ -3153,7 +3353,7 @@ assemble_tokens (const char *opname,
 
    Add new fixup only if offset isn't 16bit.  */
 
-valueT
+static symbolS *
 add_to_link_pool (symbolS *basesym,
 		  symbolS *sym,
 		  offsetT addend)
@@ -3161,12 +3361,13 @@ add_to_link_pool (symbolS *basesym,
   segT current_section = now_seg;
   int current_subsec = now_subseg;
   valueT offset;
-  bfd_reloc_code_real_type reloc_type;
   char *p;
   segment_info_type *seginfo = seg_info (alpha_link_section);
   fixS *fixp;
-
-  offset = - *symbol_get_obj (basesym);
+  symbolS *linksym, *expsym;
+  expressionS e;
+  
+  offset = 0; /* ??? DBR */
 
   /* @@ This assumes all entries in a given section will be of the same
      size...  Probably correct, but unwise to rely on.  */
@@ -3175,31 +3376,44 @@ add_to_link_pool (symbolS *basesym,
   if (seginfo->frchainP)
     for (fixp = seginfo->frchainP->fix_root;
 	 fixp != (fixS *) NULL;
-	 fixp = fixp->fx_next, offset += 8)
+	 fixp = fixp->fx_next)
       {
-	if (fixp->fx_addsy == sym && fixp->fx_offset == addend)
-	  {
-	    if (range_signed_16 (offset))
-	      {
-		return offset;
-	      }
-	  }
+	if (fixp->tc_fix_data.info
+	    && fixp->tc_fix_data.info->sym
+	    && fixp->tc_fix_data.info->sym->sy_value.X_op_symbol == basesym)
+	  offset += 8;
+	
+	if (fixp->fx_addsy == sym
+	    && fixp->fx_offset == (valueT)addend
+	    && fixp->tc_fix_data.info
+	    && fixp->tc_fix_data.info->sym
+	    && fixp->tc_fix_data.info->sym->sy_value.X_op_symbol == basesym)
+	  return fixp->tc_fix_data.info->sym;
       }
 
   /* Not found in 16bit signed range.  */
 
   subseg_set (alpha_link_section, 0);
+  linksym = symbol_new
+    (FAKE_LABEL_NAME, now_seg, (valueT) frag_now_fix (), frag_now);
   p = frag_more (8);
   memset (p, 0, 8);
 
-  fix_new (frag_now, p - frag_now->fr_literal, 8, sym, addend, 0,
-	   BFD_RELOC_64);
+  e.X_op = O_subtract;
+  e.X_add_symbol = linksym;
+  e.X_op_symbol = basesym;
+  e.X_add_number = 0;
+  expsym = make_expr_symbol (&e);
+
+  fixp = fix_new
+    (frag_now, p-frag_now->fr_literal, 8, sym, addend, 0, BFD_RELOC_64);
+  fixp->tc_fix_data.info = get_alpha_reloc_tag (next_sequence_num--);
+  fixp->tc_fix_data.info->sym = expsym;
 
   subseg_set (current_section, current_subsec);
   seginfo->literal_pool_size += 8;
-  return offset;
+  return expsym;
 }
-
 #endif /* OBJ_EVAX */
 
 /* Assembler directives.  */
@@ -3209,13 +3423,25 @@ add_to_link_pool (symbolS *basesym,
 
 static void
 s_alpha_text (int i)
-
 {
 #ifdef OBJ_ELF
   obj_elf_text (i);
 #else
   s_text (i);
 #endif
+#ifdef OBJ_EVAX
+  {
+    symbolS * symbolP;
+
+    symbolP = symbol_find (".text");
+    if (symbolP == NULL)
+      {
+	symbolP = symbol_make (".text");
+	S_SET_SEGMENT (symbolP, text_section);
+	symbol_table_insert (symbolP);
+      }
+  }
+#endif
   alpha_insn_label = NULL;
   alpha_auto_align_on = 1;
   alpha_current_align = 0;
@@ -3239,8 +3465,7 @@ s_alpha_data (int i)
 
 #if defined (OBJ_ECOFF) || defined (OBJ_EVAX)
 
-/* Handle the OSF/1 and openVMS .comm pseudo quirks.
-   openVMS constructs a section for every common symbol.  */
+/* Handle the OSF/1 and openVMS .comm pseudo quirks.  */
 
 static void
 s_alpha_comm (int ignore ATTRIBUTE_UNUSED)
@@ -3248,13 +3473,9 @@ s_alpha_comm (int ignore ATTRIBUTE_UNUSED)
   char *name;
   char c;
   char *p;
-  offsetT temp;
+  offsetT temp, size;
   symbolS *symbolP;
-#ifdef OBJ_EVAX
-  segT current_section = now_seg;
-  int current_subsec = now_subseg;
-  segT new_seg;
-#endif
+  int log_align = 0;
 
   name = input_line_pointer;
   c = get_symbol_end ();
@@ -3271,35 +3492,17 @@ s_alpha_comm (int ignore ATTRIBUTE_UNUSED)
       input_line_pointer++;
       SKIP_WHITESPACE ();
     }
-  if ((temp = get_absolute_expression ()) < 0)
+  if ((size = get_absolute_expression ()) < 0)
     {
-      as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp);
+      as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size);
       ignore_rest_of_line ();
       return;
     }
 
   *p = 0;
   symbolP = symbol_find_or_make (name);
-
-#ifdef OBJ_EVAX
-  /* Make a section for the common symbol.  */
-  new_seg = subseg_new (xstrdup (name), 0);
-#endif
-
   *p = c;
 
-#ifdef OBJ_EVAX
-  /* Alignment might follow.  */
-  if (*input_line_pointer == ',')
-    {
-      offsetT align;
-
-      input_line_pointer++;
-      align = get_absolute_expression ();
-      bfd_set_section_alignment (stdoutput, new_seg, align);
-    }
-#endif
-
   if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
     {
       as_bad (_("Ignoring attempt to re-define symbol"));
@@ -3308,44 +3511,108 @@ s_alpha_comm (int ignore ATTRIBUTE_UNUSED)
     }
 
 #ifdef OBJ_EVAX
-  if (bfd_section_size (stdoutput, new_seg) > 0)
+  if (*input_line_pointer != ',')
+    temp = 8; /* Default alignment.  */
+  else
     {
-      if (bfd_section_size (stdoutput, new_seg) != temp)
-	as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
-		S_GET_NAME (symbolP),
-		(long) bfd_section_size (stdoutput, new_seg),
-		(long) temp);
+      input_line_pointer++;
+      SKIP_WHITESPACE ();
+      temp = get_absolute_expression ();
     }
-#else
-  if (S_GET_VALUE (symbolP))
+
+  /* ??? Unlike on OSF/1, the alignment factor is not in log units.  */
+  while ((temp >>= 1) != 0)
+    ++log_align;
+
+  if (*input_line_pointer == ',')
     {
-      if (S_GET_VALUE (symbolP) != (valueT) temp)
-	as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
-		S_GET_NAME (symbolP),
-		(long) S_GET_VALUE (symbolP),
-		(long) temp);
+      /* Extended form of the directive
+
+	   .comm symbol, size, alignment, section
+
+         where the "common" semantics is transferred to the section.
+         The symbol is effectively an alias for the section name.  */
+
+      segT sec;
+      char *sec_name;
+      symbolS *sec_symbol;
+      segT current_seg = now_seg;
+      subsegT current_subseg = now_subseg;
+      int cur_size;
+      
+      input_line_pointer++;
+      SKIP_WHITESPACE ();
+      sec_name = s_alpha_section_name ();
+      sec_symbol = symbol_find_or_make (sec_name);
+      sec = subseg_new (sec_name, 0);
+      S_SET_SEGMENT (sec_symbol, sec);
+      symbol_get_bfdsym (sec_symbol)->flags |= BSF_SECTION_SYM;
+      bfd_vms_set_section_flags (stdoutput, sec,
+				 EGPS_S_V_OVR | EGPS_S_V_GBL | EGPS_S_V_NOMOD);
+      record_alignment (sec, log_align);
+
+      /* Reuse stab_string_size to store the size of the section.  */
+      cur_size = seg_info (sec)->stabu.stab_string_size;
+      if ((int) size > cur_size)
+	{
+	  char *pfrag
+	    = frag_var (rs_fill, 1, 1, (relax_substateT)0, NULL,
+			(valueT)size - (valueT)cur_size, NULL);
+	  *pfrag = 0;
+	  seg_info (sec)->stabu.stab_string_size = (int)size;
+	}
+
+      S_SET_SEGMENT (symbolP, sec);
+
+      subseg_set (current_seg, current_subseg);
+    }
+  else
+    {
+      /* Regular form of the directive
+
+	   .comm symbol, size, alignment
+
+	 where the "common" semantics in on the symbol.
+	 These symbols are assembled in the .bss section.  */
+
+      char *pfrag;
+      segT current_seg = now_seg;
+      subsegT current_subseg = now_subseg;
+
+      subseg_set (bss_section, 1);
+      frag_align (log_align, 0, 0);
+      record_alignment (bss_section, log_align);
+
+      symbolP->sy_frag = frag_now;
+      pfrag = frag_var (rs_org, 1, 1, (relax_substateT)0, symbolP,
+                        size, NULL);
+      *pfrag = 0;
+
+      S_SET_SEGMENT (symbolP, bss_section);
+
+      subseg_set (current_seg, current_subseg);
     }
 #endif
+  
+  if (S_GET_VALUE (symbolP))
+    {
+      if (S_GET_VALUE (symbolP) != (valueT) size)
+        as_bad ("Length of .comm \"%s\" is already %ld. Not changed to %ld.",
+                S_GET_NAME (symbolP),
+                (long) S_GET_VALUE (symbolP),
+                (long) size);
+    }
   else
     {
-#ifdef OBJ_EVAX
-      subseg_set (new_seg, 0);
-      p = frag_more (temp);
-      new_seg->flags |= SEC_IS_COMMON;
-      S_SET_SEGMENT (symbolP, new_seg);
-#else
-      S_SET_VALUE (symbolP, (valueT) temp);
-      S_SET_SEGMENT (symbolP, bfd_com_section_ptr);
+#ifndef OBJ_EVAX
+      S_SET_VALUE (symbolP, (valueT) size);
 #endif
       S_SET_EXTERNAL (symbolP);
     }
-
-#ifdef OBJ_EVAX
-  subseg_set (current_section, current_subsec);
+  
+#ifndef OBJ_EVAX
+  know (symbolP->sy_frag == &zero_address_frag);
 #endif
-
-  know (symbol_get_frag (symbolP) == &zero_address_frag);
-
   demand_empty_rest_of_line ();
 }
 
@@ -3623,6 +3890,8 @@ s_alpha_prologue (int ignore ATTRIBUTE_UNUSED)
 
   arg = get_absolute_expression ();
   demand_empty_rest_of_line ();
+  alpha_prologue_label = symbol_new
+    (FAKE_LABEL_NAME, now_seg, (valueT) frag_now_fix (), frag_now);
 
   if (ECOFF_DEBUGGING)
     sym = ecoff_get_cur_proc_sym ();
@@ -3886,24 +4155,169 @@ alpha_cfi_frame_initial_instructions (void)
 
 #ifdef OBJ_EVAX
 
+/* Get name of section.  */
+static char *
+s_alpha_section_name (void)
+{
+  char *name;
+
+  SKIP_WHITESPACE ();
+  if (*input_line_pointer == '"')
+    {
+      int dummy;
+
+      name = demand_copy_C_string (&dummy);
+      if (name == NULL)
+	{
+	  ignore_rest_of_line ();
+	  return NULL;
+	}
+    }
+  else
+    {
+      char *end = input_line_pointer;
+
+      while (0 == strchr ("\n\t,; ", *end))
+	end++;
+      if (end == input_line_pointer)
+	{
+	  as_warn (_("missing name"));
+	  ignore_rest_of_line ();
+	  return NULL;
+	}
+
+      name = xmalloc (end - input_line_pointer + 1);
+      memcpy (name, input_line_pointer, end - input_line_pointer);
+      name[end - input_line_pointer] = '\0';
+      input_line_pointer = end;
+    }
+  SKIP_WHITESPACE ();
+  return name;
+}
+
+static flagword
+s_alpha_section_word (char *str, size_t len)
+{
+  int no = 0;
+  flagword flag = 0;
+
+  if (len == 5 && strncmp (str, "NO", 2) == 0)
+    {
+      no = 1;
+      str += 2;
+      len -= 2; 
+    }
+
+  if (len == 3)
+    {
+      if (strncmp (str, "PIC", 3) == 0)
+	flag = EGPS_S_V_PIC;
+      else if (strncmp (str, "LIB", 3) == 0)
+	flag = EGPS_S_V_LIB;
+      else if (strncmp (str, "OVR", 3) == 0)
+	flag = EGPS_S_V_OVR;
+      else if (strncmp (str, "REL", 3) == 0)
+	flag = EGPS_S_V_REL;
+      else if (strncmp (str, "GBL", 3) == 0)
+	flag = EGPS_S_V_GBL;
+      else if (strncmp (str, "SHR", 3) == 0)
+	flag = EGPS_S_V_SHR;
+      else if (strncmp (str, "EXE", 3) == 0)
+	flag = EGPS_S_V_EXE;
+      else if (strncmp (str, "WRT", 3) == 0)
+	flag = EGPS_S_V_WRT;
+      else if (strncmp (str, "VEC", 3) == 0)
+	flag = EGPS_S_V_VEC;
+      else if (strncmp (str, "MOD", 3) == 0)
+	{
+	  flag = no ? EGPS_S_V_NOMOD : EGPS_S_V_NOMOD << EGPS_S_V_NO_SHIFT;
+	  no = 0;
+	}
+      else if (strncmp (str, "COM", 3) == 0)
+	flag = EGPS_S_V_COM;
+    }
+
+  if (flag == 0)
+    {
+      char c = str[len];
+      str[len] = 0;
+      as_warn (_("unknown section attribute %s"), str);
+      str[len] = c;
+      return 0;
+    }
+
+  if (no)
+    return flag << EGPS_S_V_NO_SHIFT;
+  else
+    return flag;
+}
+
 /* Handle the section specific pseudo-op.  */
 
+#define EVAX_SECTION_COUNT 5
+
+static char *section_name[EVAX_SECTION_COUNT + 1] =
+  { "NULL", ".rdata", ".comm", ".link", ".ctors", ".dtors" };
+
 static void
 s_alpha_section (int secid)
 {
   int temp;
-#define EVAX_SECTION_COUNT 5
-  static char *section_name[EVAX_SECTION_COUNT + 1] =
-    { "NULL", ".rdata", ".comm", ".link", ".ctors", ".dtors" };
+  char *name, *beg;
+  segT sec;
+  flagword vms_flags = 0;
+  symbolS *symbol;
 
-  if ((secid <= 0) || (secid > EVAX_SECTION_COUNT))
+  if (secid == 0)
     {
-      as_fatal (_("Unknown section directive"));
-      demand_empty_rest_of_line ();
-      return;
+      name = s_alpha_section_name ();
+      if (name == NULL)
+        return;
+      sec = subseg_new (name, 0);
+      if (*input_line_pointer == ',')
+        {
+          /* Skip the comma.  */
+          ++input_line_pointer;
+          SKIP_WHITESPACE ();
+
+     	  do
+     	    {
+     	      char c;
+
+     	      SKIP_WHITESPACE ();
+     	      beg = input_line_pointer;
+     	      c = get_symbol_end ();
+     	      *input_line_pointer = c;
+
+     	      vms_flags |= s_alpha_section_word (beg, input_line_pointer - beg);
+
+     	      SKIP_WHITESPACE ();
+     	    }
+     	  while (*input_line_pointer++ == ',');
+     	  --input_line_pointer;
+        }
+
+	symbol = symbol_find_or_make (name);
+	S_SET_SEGMENT (symbol, sec);
+	symbol_get_bfdsym (symbol)->flags |= BSF_SECTION_SYM;
+        bfd_vms_set_section_flags (stdoutput, sec, vms_flags);
     }
-  temp = get_absolute_expression ();
-  subseg_new (section_name[secid], 0);
+  else
+    {
+      temp = get_absolute_expression ();
+      subseg_new (section_name[secid], 0);
+    }
+
+  demand_empty_rest_of_line ();
+  alpha_insn_label = NULL;
+  alpha_auto_align_on = 1;
+  alpha_current_align = 0;
+}
+
+static void
+s_alpha_literals (int ignore ATTRIBUTE_UNUSED)
+{
+  subseg_new (".literals", 0);
   demand_empty_rest_of_line ();
   alpha_insn_label = NULL;
   alpha_auto_align_on = 1;
@@ -3918,16 +4332,21 @@ s_alpha_ent (int ignore ATTRIBUTE_UNUSED)
   symbolS *symbol;
   expressionS symexpr;
 
-  alpha_evax_proc.pdsckind = 0;
-  alpha_evax_proc.framereg = -1;
-  alpha_evax_proc.framesize = 0;
-  alpha_evax_proc.rsa_offset = 0;
-  alpha_evax_proc.ra_save = AXP_REG_RA;
-  alpha_evax_proc.fp_save = -1;
-  alpha_evax_proc.imask = 0;
-  alpha_evax_proc.fmask = 0;
-  alpha_evax_proc.prologue = 0;
-  alpha_evax_proc.type = 0;
+  alpha_evax_proc
+    = (struct alpha_evax_procs *) xmalloc (sizeof (struct alpha_evax_procs));
+
+  alpha_evax_proc->pdsckind = 0;
+  alpha_evax_proc->framereg = -1;
+  alpha_evax_proc->framesize = 0;
+  alpha_evax_proc->rsa_offset = 0;
+  alpha_evax_proc->ra_save = AXP_REG_RA;
+  alpha_evax_proc->fp_save = -1;
+  alpha_evax_proc->imask = 0;
+  alpha_evax_proc->fmask = 0;
+  alpha_evax_proc->prologue = 0;
+  alpha_evax_proc->type = 0;
+  alpha_evax_proc->handler = 0;
+  alpha_evax_proc->handler_data = 0;
 
   expression (&symexpr);
 
@@ -3940,11 +4359,44 @@ s_alpha_ent (int ignore ATTRIBUTE_UNUSED)
 
   symbol = make_expr_symbol (&symexpr);
   symbol_get_bfdsym (symbol)->flags |= BSF_FUNCTION;
-  alpha_evax_proc.symbol = symbol;
+  alpha_evax_proc->symbol = symbol;
+
+  (void) hash_insert
+    (alpha_evax_proc_hash,
+     symbol_get_bfdsym (alpha_evax_proc->symbol)->name, (PTR)alpha_evax_proc);
 
   demand_empty_rest_of_line ();
 }
 
+static void
+s_alpha_handler (int is_data)
+{
+  if (is_data)
+    alpha_evax_proc->handler_data = get_absolute_expression ();
+  else
+    {
+      char *name, name_end;
+      name = input_line_pointer;
+      name_end = get_symbol_end ();
+
+      if (! is_name_beginner (*name))
+	{
+	  as_warn (_(".handler directive has no name"));
+	  *input_line_pointer = name_end;
+	}
+      else
+	{
+	  symbolS *sym;
+
+	  sym = symbol_find_or_make (name);
+	  symbol_get_bfdsym (sym)->flags |= BSF_FUNCTION;
+	  alpha_evax_proc->handler = sym;
+	  *input_line_pointer = name_end;
+	}
+      }
+  demand_empty_rest_of_line ();
+}
+
 /* Parse .frame <framreg>,<framesize>,RA,<rsa_offset> directives.  */
 
 static void
@@ -3952,7 +4404,7 @@ s_alpha_frame (int ignore ATTRIBUTE_UNUSED)
 {
   long val;
 
-  alpha_evax_proc.framereg = tc_get_register (1);
+  alpha_evax_proc->framereg = tc_get_register (1);
 
   SKIP_WHITESPACE ();
   if (*input_line_pointer++ != ','
@@ -3964,7 +4416,7 @@ s_alpha_frame (int ignore ATTRIBUTE_UNUSED)
       return;
     }
 
-  alpha_evax_proc.framesize = val;
+  alpha_evax_proc->framesize = val;
 
   (void) tc_get_register (1);
   SKIP_WHITESPACE ();
@@ -3975,7 +4427,18 @@ s_alpha_frame (int ignore ATTRIBUTE_UNUSED)
       demand_empty_rest_of_line ();
       return;
     }
-  alpha_evax_proc.rsa_offset = get_absolute_expression ();
+  alpha_evax_proc->rsa_offset = get_absolute_expression ();
+}
+
+static void
+s_alpha_prologue (int ignore ATTRIBUTE_UNUSED)
+{
+  int arg;
+
+  arg = get_absolute_expression ();
+  demand_empty_rest_of_line ();
+  alpha_prologue_label = symbol_new
+    (FAKE_LABEL_NAME, now_seg, (valueT) frag_now_fix (), frag_now);
 }
 
 static void
@@ -3983,12 +4446,14 @@ s_alpha_pdesc (int ignore ATTRIBUTE_UNUSED)
 {
   char *name;
   char name_end;
-  long val;
   register char *p;
   expressionS exp;
   symbolS *entry_sym;
   fixS *fixp;
   segment_info_type *seginfo = seg_info (alpha_link_section);
+  const char *entry_sym_name;
+  char *sym_name;
+  int len;
 
   if (now_seg != alpha_link_section)
     {
@@ -3997,30 +4462,42 @@ s_alpha_pdesc (int ignore ATTRIBUTE_UNUSED)
       return;
     }
 
-  if ((alpha_evax_proc.symbol == 0)
-      || (!S_IS_DEFINED (alpha_evax_proc.symbol)))
+  expression (&exp);
+  if (exp.X_op != O_symbol)
     {
-      as_fatal (_(".pdesc has no matching .ent"));
+      as_warn (_(".pdesc directive has no entry symbol"));
       demand_empty_rest_of_line ();
       return;
     }
-
-  *symbol_get_obj (alpha_evax_proc.symbol) =
-    (valueT) seginfo->literal_pool_size;
-
-  expression (&exp);
-  if (exp.X_op != O_symbol)
+  
+  entry_sym = make_expr_symbol (&exp);
+  entry_sym_name = symbol_get_bfdsym (entry_sym)->name;
+ 
+  len = strlen (entry_sym_name);
+  sym_name = (char *) xmalloc (len - 4 + 1);
+  strncpy (sym_name, entry_sym_name, len - 4);
+  sym_name [len - 4] = 0;
+  
+  alpha_evax_proc = (struct alpha_evax_procs *)
+    hash_find (alpha_evax_proc_hash, sym_name);
+ 
+  if (!alpha_evax_proc || !S_IS_DEFINED (alpha_evax_proc->symbol))
     {
-      as_warn (_(".pdesc directive has no entry symbol"));
+      as_fatal (_(".pdesc has no matching .ent"));
       demand_empty_rest_of_line ();
       return;
     }
 
-  entry_sym = make_expr_symbol (&exp);
-  /* Save bfd symbol of proc desc in function symbol.  */
-  symbol_get_bfdsym (alpha_evax_proc.symbol)->udata.p
-    = symbol_get_bfdsym (entry_sym);
+  *symbol_get_obj (alpha_evax_proc->symbol) =
+    (valueT) seginfo->literal_pool_size;
 
+  alpha_evax_proc->symbol->sy_obj = (valueT)seginfo->literal_pool_size;
+ 
+  /* Save bfd symbol of proc entry in function symbol.  */
+  ((struct evax_private_udata_struct *)
+     symbol_get_bfdsym (alpha_evax_proc->symbol)->udata.p)->enbsym
+       = symbol_get_bfdsym (entry_sym);
+  
   SKIP_WHITESPACE ();
   if (*input_line_pointer++ != ',')
     {
@@ -4034,13 +4511,13 @@ s_alpha_pdesc (int ignore ATTRIBUTE_UNUSED)
   name_end = get_symbol_end ();
 
   if (strncmp (name, "stack", 5) == 0)
-    alpha_evax_proc.pdsckind = PDSC_S_K_KIND_FP_STACK;
+    alpha_evax_proc->pdsckind = PDSC_S_K_KIND_FP_STACK;
 
   else if (strncmp (name, "reg", 3) == 0)
-    alpha_evax_proc.pdsckind = PDSC_S_K_KIND_FP_REGISTER;
+    alpha_evax_proc->pdsckind = PDSC_S_K_KIND_FP_REGISTER;
 
   else if (strncmp (name, "null", 4) == 0)
-    alpha_evax_proc.pdsckind = PDSC_S_K_KIND_NULL;
+    alpha_evax_proc->pdsckind = PDSC_S_K_KIND_NULL;
 
   else
     {
@@ -4062,53 +4539,58 @@ s_alpha_pdesc (int ignore ATTRIBUTE_UNUSED)
   fixp->fx_done = 1;
   seginfo->literal_pool_size += 16;
 
-  *p = alpha_evax_proc.pdsckind
-    | ((alpha_evax_proc.framereg == 29) ? PDSC_S_M_BASE_REG_IS_FP : 0);
+  *p = alpha_evax_proc->pdsckind
+    | ((alpha_evax_proc->framereg == 29) ? PDSC_S_M_BASE_REG_IS_FP : 0)
+    | ((alpha_evax_proc->handler) ? PDSC_S_M_HANDLER_VALID : 0)
+    | ((alpha_evax_proc->handler_data) ? PDSC_S_M_HANDLER_DATA_VALID : 0);
   *(p + 1) = PDSC_S_M_NATIVE | PDSC_S_M_NO_JACKET;
 
-  switch (alpha_evax_proc.pdsckind)
+  switch (alpha_evax_proc->pdsckind)
     {
     case PDSC_S_K_KIND_NULL:
       *(p + 2) = 0;
       *(p + 3) = 0;
       break;
     case PDSC_S_K_KIND_FP_REGISTER:
-      *(p + 2) = alpha_evax_proc.fp_save;
-      *(p + 3) = alpha_evax_proc.ra_save;
+      *(p + 2) = alpha_evax_proc->fp_save;
+      *(p + 3) = alpha_evax_proc->ra_save;
       break;
     case PDSC_S_K_KIND_FP_STACK:
-      md_number_to_chars (p + 2, (valueT) alpha_evax_proc.rsa_offset, 2);
+      md_number_to_chars (p + 2, (valueT) alpha_evax_proc->rsa_offset, 2);
       break;
     default:		/* impossible */
       break;
     }
 
   *(p + 4) = 0;
-  *(p + 5) = alpha_evax_proc.type & 0x0f;
+  *(p + 5) = alpha_evax_proc->type & 0x0f;
 
   /* Signature offset.  */
   md_number_to_chars (p + 6, (valueT) 0, 2);
 
   fix_new_exp (frag_now, p - frag_now->fr_literal+8, 8, &exp, 0, BFD_RELOC_64);
 
-  if (alpha_evax_proc.pdsckind == PDSC_S_K_KIND_NULL)
+  if (alpha_evax_proc->pdsckind == PDSC_S_K_KIND_NULL)
     return;
 
   /* Add dummy fix to make add_to_link_pool work.  */
-  p = frag_more (8);
-  fixp = fix_new (frag_now, p - frag_now->fr_literal, 8, 0, 0, 0, 0);
+  p = frag_more (6);
+  fixp = fix_new (frag_now, p - frag_now->fr_literal, 6, 0, 0, 0, 0);
   fixp->fx_done = 1;
-  seginfo->literal_pool_size += 8;
-
+  seginfo->literal_pool_size += 6;
+  
   /* pdesc+16: Size.  */
-  md_number_to_chars (p, (valueT) alpha_evax_proc.framesize, 4);
+  md_number_to_chars (p, (valueT) alpha_evax_proc->framesize, 4);
 
   md_number_to_chars (p + 4, (valueT) 0, 2);
 
   /* Entry length.  */
-  md_number_to_chars (p + 6, alpha_evax_proc.prologue, 2);
+  exp.X_op = O_subtract;
+  exp.X_add_symbol = alpha_prologue_label;
+  exp.X_op_symbol = entry_sym;
+  emit_expr (&exp, 2);
 
-  if (alpha_evax_proc.pdsckind == PDSC_S_K_KIND_FP_REGISTER)
+  if (alpha_evax_proc->pdsckind == PDSC_S_K_KIND_FP_REGISTER)
     return;
 
   /* Add dummy fix to make add_to_link_pool work.  */
@@ -4119,8 +4601,25 @@ s_alpha_pdesc (int ignore ATTRIBUTE_UNUSED)
 
   /* pdesc+24: register masks.  */
 
-  md_number_to_chars (p, alpha_evax_proc.imask, 4);
-  md_number_to_chars (p + 4, alpha_evax_proc.fmask, 4);
+  md_number_to_chars (p, alpha_evax_proc->imask, 4);
+  md_number_to_chars (p + 4, alpha_evax_proc->fmask, 4);
+
+  if (alpha_evax_proc->handler)
+    {
+      p = frag_more (8);
+      fixp = fix_new (frag_now, p - frag_now->fr_literal, 8,
+	              alpha_evax_proc->handler, 0, 0, BFD_RELOC_64);
+    }
+
+  if (alpha_evax_proc->handler_data)
+    {
+      /* Add dummy fix to make add_to_link_pool work.  */
+      p = frag_more (8);
+      fixp = fix_new (frag_now, p - frag_now->fr_literal, 8, 0, 0, 0, 0);
+      fixp->fx_done = 1;
+      seginfo->literal_pool_size += 8;
+      md_number_to_chars (p, alpha_evax_proc->handler_data, 8);
+    }
 }
 
 /* Support for crash debug on vms.  */
@@ -4165,6 +4664,7 @@ s_alpha_linkage (int ignore ATTRIBUTE_UNUSED)
 {
   expressionS exp;
   char *p;
+  fixS *fixp;
 
 #ifdef md_flush_pending_output
   md_flush_pending_output ();
@@ -4177,10 +4677,36 @@ s_alpha_linkage (int ignore ATTRIBUTE_UNUSED)
     }
   else
     {
+      struct alpha_linkage_fixups *linkage_fixup;
+      
       p = frag_more (LKP_S_K_SIZE);
       memset (p, 0, LKP_S_K_SIZE);
-      fix_new_exp (frag_now, p - frag_now->fr_literal, LKP_S_K_SIZE, &exp, 0,\
-		   BFD_RELOC_ALPHA_LINKAGE);
+      fixp = fix_new_exp
+	(frag_now, p - frag_now->fr_literal, LKP_S_K_SIZE, &exp, 0,\
+	 BFD_RELOC_ALPHA_LINKAGE);
+
+      linkage_fixup = (struct alpha_linkage_fixups *)
+	xmalloc (sizeof (struct alpha_linkage_fixups));
+
+      linkage_fixup->fixp = fixp;
+      linkage_fixup->next = 0;
+
+      if (alpha_insn_label == 0)
+	alpha_insn_label = symbol_new
+	  (FAKE_LABEL_NAME, now_seg, (valueT) frag_now_fix (), frag_now);
+      linkage_fixup->label = alpha_insn_label;
+
+      if (alpha_linkage_fixup_root == 0)
+	{
+	  alpha_linkage_fixup_root = alpha_linkage_fixup_tail = linkage_fixup;
+	  alpha_linkage_fixup_tail->next = 0;
+	}
+      else
+	{
+	  alpha_linkage_fixup_tail->next = linkage_fixup;
+	  alpha_linkage_fixup_tail = linkage_fixup;
+	  alpha_linkage_fixup_tail->next = 0;
+	}
     }
   demand_empty_rest_of_line ();
 }
@@ -4212,7 +4738,7 @@ static void
 s_alpha_fp_save (int ignore ATTRIBUTE_UNUSED)
 {
 
-  alpha_evax_proc.fp_save = tc_get_register (1);
+  alpha_evax_proc->fp_save = tc_get_register (1);
 
   demand_empty_rest_of_line ();
 }
@@ -4229,7 +4755,7 @@ s_alpha_mask (int ignore ATTRIBUTE_UNUSED)
     }
   else
     {
-      alpha_evax_proc.imask = val;
+      alpha_evax_proc->imask = val;
       (void) get_absolute_expression ();
     }
   demand_empty_rest_of_line ();
@@ -4247,7 +4773,7 @@ s_alpha_fmask (int ignore ATTRIBUTE_UNUSED)
     }
   else
     {
-      alpha_evax_proc.fmask = val;
+      alpha_evax_proc->fmask = val;
       (void) get_absolute_expression ();
     }
   demand_empty_rest_of_line ();
@@ -4261,7 +4787,7 @@ s_alpha_end (int ignore ATTRIBUTE_UNUSED)
   c = get_symbol_end ();
   *input_line_pointer = c;
   demand_empty_rest_of_line ();
-  alpha_evax_proc.symbol = 0;
+  alpha_evax_proc = 0;
 }
 
 static void
@@ -4485,7 +5011,7 @@ s_alpha_align (int ignore ATTRIBUTE_UNUSED)
 {
   int align;
   char fill, *pfill;
-  long max_alignment = 15;
+  long max_alignment = 16;
 
   align = get_absolute_expression ();
   if (align > max_alignment)
@@ -4612,12 +5138,12 @@ alpha_print_token (FILE *f, const expressionS *exp)
       {
 	expressionS nexp = *exp;
 	nexp.X_op = O_register;
-	print_expr (f, &nexp);
+	print_expr_1 (f, &nexp);
       }
       putc (')', f);
       break;
     default:
-      print_expr (f, exp);
+      print_expr_1 (f, exp);
       break;
     }
 }
@@ -4643,22 +5169,26 @@ const pseudo_typeS md_pseudo_table[] =
   {"sect.s", s_alpha_section, 0},
 #endif
 #ifdef OBJ_EVAX
-  { "pdesc", s_alpha_pdesc, 0},
-  { "name", s_alpha_name, 0},
-  { "linkage", s_alpha_linkage, 0},
-  { "code_address", s_alpha_code_address, 0},
-  { "ent", s_alpha_ent, 0},
-  { "frame", s_alpha_frame, 0},
-  { "fp_save", s_alpha_fp_save, 0},
-  { "mask", s_alpha_mask, 0},
-  { "fmask", s_alpha_fmask, 0},
-  { "end", s_alpha_end, 0},
-  { "file", s_alpha_file, 0},
-  { "rdata", s_alpha_section, 1},
-  { "comm", s_alpha_comm, 0},
-  { "link", s_alpha_section, 3},
-  { "ctors", s_alpha_section, 4},
-  { "dtors", s_alpha_section, 5},
+  {"section", s_alpha_section, 0},
+  {"literals", s_alpha_literals, 0},
+  {"pdesc", s_alpha_pdesc, 0},
+  {"name", s_alpha_name, 0},
+  {"linkage", s_alpha_linkage, 0},
+  {"code_address", s_alpha_code_address, 0},
+  {"ent", s_alpha_ent, 0},
+  {"frame", s_alpha_frame, 0},
+  {"fp_save", s_alpha_fp_save, 0},
+  {"mask", s_alpha_mask, 0},
+  {"fmask", s_alpha_fmask, 0},
+  {"end", s_alpha_end, 0},
+  {"file", s_alpha_file, 0},
+  {"rdata", s_alpha_section, 1},
+  {"comm", s_alpha_comm, 0},
+  {"link", s_alpha_section, 3},
+  {"ctors", s_alpha_section, 4},
+  {"dtors", s_alpha_section, 5},
+  {"handler", s_alpha_handler, 0},
+  {"handler_data", s_alpha_handler, 1},
 #endif
 #ifdef OBJ_ELF
   /* Frame related pseudos.  */
@@ -4683,8 +5213,12 @@ const pseudo_typeS md_pseudo_table[] =
   {"tag", s_alpha_coff_wrapper, 6},
   {"val", s_alpha_coff_wrapper, 7},
 #else
+#ifdef OBJ_EVAX
+  {"prologue", s_alpha_prologue, 0},
+#else
   {"prologue", s_ignore, 0},
 #endif
+#endif
   {"gprel32", s_alpha_gprel32, 0},
   {"t_floating", s_alpha_float_cons, 'd'},
   {"s_floating", s_alpha_float_cons, 'f'},
@@ -4955,6 +5489,7 @@ md_begin (void)
 
 #ifdef OBJ_EVAX
   create_literal_section (".link", &alpha_link_section, &alpha_link_symbol);
+  alpha_evax_proc_hash = hash_new ();
 #endif
 
 #ifdef OBJ_ELF
@@ -5089,6 +5624,14 @@ md_parse_option (int c, char *arg)
 
     case 'h':			/* For gnu-c/vax compatibility.  */
       break;
+
+    case OPTION_REPLACE:
+      alpha_flag_replace = 1;
+      break;
+
+    case OPTION_NOREPLACE:
+      alpha_flag_replace = 0;
+      break;
 #endif
 
     case OPTION_RELAX:
@@ -5128,8 +5671,9 @@ Alpha options:\n\
 #ifdef OBJ_EVAX
   fputs (_("\
 VMS options:\n\
--+			hash encode (don't truncate) names longer than 64 characters\n\
--H			show new symbol after hash truncation\n"),
+-+			encode (don't truncate) names longer than 64 characters\n\
+-H			show new symbol after hash truncation\n\
+-replace/-noreplace	enable or disable the optimization of procedure calls\n"),
 	stream);
 #endif
 }
@@ -5294,6 +5838,79 @@ md_apply_fix (fixS *fixP, valueT * valP, segT seg)
     case BFD_RELOC_ALPHA_CODEADDR:
       return;
 
+#ifdef OBJ_EVAX
+    case BFD_RELOC_ALPHA_NOP:
+      value -= (8 + 4); /* PC-relative, base is jsr+4.  */
+
+      /* From B.4.5.2 of the OpenVMS Linker Utility Manual:
+	 "Finally, the ETIR$C_STC_BSR command passes the same address
+	  as ETIR$C_STC_NOP (so that they will fail or succeed together),
+	  and the same test is done again."  */
+      if (S_GET_SEGMENT (fixP->fx_addsy) == undefined_section)
+	{
+	  fixP->fx_addnumber = -value;
+	  return;
+	}
+
+      if ((abs (value) >> 2) & ~0xfffff)
+	goto done;
+      else
+	{
+	  /* Change to a nop.  */
+	  image = 0x47FF041F;
+	  goto write_done;
+	}
+
+    case BFD_RELOC_ALPHA_LDA:
+      /* fixup_segment sets fixP->fx_addsy to NULL when it can pre-compute
+	 the value for an O_subtract.  */
+      if (fixP->fx_addsy
+	  && S_GET_SEGMENT (fixP->fx_addsy) == undefined_section)
+	{
+	  fixP->fx_addnumber = symbol_get_bfdsym (fixP->fx_subsy)->value;
+	  return;
+	}
+
+      if ((abs (value)) & ~0x7fff)
+	goto done;
+      else
+	{
+	  /* Change to an lda.  */
+	  image = 0x237B0000 | (value & 0xFFFF);
+	  goto write_done;
+	}
+
+    case BFD_RELOC_ALPHA_BSR:
+    case BFD_RELOC_ALPHA_BOH:
+      value -= 4; /* PC-relative, base is jsr+4.  */
+
+      /* See comment in the BFD_RELOC_ALPHA_NOP case above.  */
+      if (S_GET_SEGMENT (fixP->fx_addsy) == undefined_section)
+	{
+	  fixP->fx_addnumber = -value;
+	  return;
+	}
+
+      if ((abs (value) >> 2) & ~0xfffff)
+	{
+	  /* Out of range.  */
+	  if (fixP->fx_r_type == BFD_RELOC_ALPHA_BOH)
+	    {
+	      /* Add a hint.  */
+	      image = bfd_getl32(fixpos);
+	      image = (image & ~0x3FFF) | ((value >> 2) & 0x3FFF);
+	      goto write_done;
+	    }
+	  goto done;
+	}
+      else
+	{
+	  /* Change to a branch.  */
+	  image = 0xD3400000 | ((value >> 2) & 0x1FFFFF);
+	  goto write_done;
+	}
+#endif
+
     case BFD_RELOC_VTABLE_INHERIT:
     case BFD_RELOC_VTABLE_ENTRY:
       return;
@@ -5463,6 +6080,12 @@ alpha_force_relocation (fixS *f)
     case BFD_RELOC_ALPHA_TPREL_HI16:
     case BFD_RELOC_ALPHA_TPREL_LO16:
     case BFD_RELOC_ALPHA_TPREL16:
+#ifdef OBJ_EVAX
+    case BFD_RELOC_ALPHA_NOP:
+    case BFD_RELOC_ALPHA_BSR:
+    case BFD_RELOC_ALPHA_LDA:
+    case BFD_RELOC_ALPHA_BOH:
+#endif
       return 1;
 
     default:
@@ -5502,6 +6125,7 @@ alpha_fix_adjustable (fixS *f)
     case BFD_RELOC_ALPHA_GPREL_HI16:
     case BFD_RELOC_ALPHA_GPREL_LO16:
     case BFD_RELOC_23_PCREL_S2:
+    case BFD_RELOC_16:
     case BFD_RELOC_32:
     case BFD_RELOC_64:
     case BFD_RELOC_ALPHA_HINT:
@@ -5555,6 +6179,13 @@ alpha_fix_adjustable (fixS *f)
 	return 1;
       }
 #endif
+#ifdef OBJ_EVAX
+    case BFD_RELOC_ALPHA_NOP:
+    case BFD_RELOC_ALPHA_BSR:
+    case BFD_RELOC_ALPHA_LDA:
+    case BFD_RELOC_ALPHA_BOH:
+      return 1;
+#endif
 
     default:
       return 1;
@@ -5615,6 +6246,62 @@ tc_gen_reloc (asection *sec ATTRIBUTE_UNUSED,
 #endif
     }
 
+#ifdef OBJ_EVAX
+  switch (fixp->fx_r_type)
+    {
+      struct evax_private_udata_struct *udata;
+      const char *pname;
+      int pname_len;
+
+    case BFD_RELOC_ALPHA_LINKAGE:
+      reloc->addend = fixp->fx_addnumber;
+      break;
+
+    case BFD_RELOC_ALPHA_NOP:
+    case BFD_RELOC_ALPHA_BSR:
+    case BFD_RELOC_ALPHA_LDA:
+    case BFD_RELOC_ALPHA_BOH:
+      pname = symbol_get_bfdsym (fixp->fx_addsy)->name;
+
+      /* We need the non-suffixed name of the procedure.  Beware that
+      the main symbol might be equated so look it up and take its name.  */
+      pname_len = strlen (pname);
+      if (pname_len > 4 && strcmp (pname + pname_len - 4, "..en") == 0)
+	{
+	  symbolS *sym;
+	  char *my_pname = xstrdup (pname);
+	  my_pname [pname_len - 4] = 0;
+	  sym = symbol_find (my_pname);
+	  if (sym == NULL)
+	    abort ();
+	  while (symbol_equated_reloc_p (sym))
+	    {
+	      symbolS *n = symbol_get_value_expression (sym)->X_add_symbol;
+
+	      /* We must avoid looping, as that can occur with a badly
+	         written program.  */
+	      if (n == sym)
+		break;
+	      sym = n;
+	    }
+	  pname = symbol_get_bfdsym (sym)->name;
+	}
+
+      udata = (struct evax_private_udata_struct *)
+	xmalloc (sizeof (struct evax_private_udata_struct));
+      udata->enbsym = symbol_get_bfdsym (fixp->fx_addsy);
+      udata->bsym = symbol_get_bfdsym (fixp->tc_fix_data.info->psym);
+      udata->origname = (char *)pname;
+      udata->lkindex = ((struct evax_private_udata_struct *)
+        symbol_get_bfdsym (fixp->tc_fix_data.info->sym)->udata.p)->lkindex;
+      reloc->sym_ptr_ptr = (void *)udata;
+      reloc->addend = fixp->fx_addnumber;
+
+    default:
+      break;
+    }
+#endif
+
   return reloc;
 }
 
diff --git a/gas/config/tc-alpha.h b/gas/config/tc-alpha.h
index eb104cc..b3c930b 100644
--- a/gas/config/tc-alpha.h
+++ b/gas/config/tc-alpha.h
@@ -69,9 +69,9 @@ extern valueT alpha_gp_value;
 #define md_operand(x)
 
 #ifdef OBJ_EVAX
+#define TC_VALIDATE_FIX_SUB(FIX, SEG) 1
 
-/* This field keeps the symbols position in the link section.  */
-#define OBJ_SYMFIELD_TYPE valueT
+#define tc_canonicalize_symbol_name evax_shorten_name
 
 #define TC_CONS_FIX_NEW(FRAG,OFF,LEN,EXP) \
       fix_new_exp (FRAG, OFF, (int)LEN, EXP, 0, \
@@ -81,7 +81,9 @@ extern valueT alpha_gp_value;
 	: BFD_RELOC_ALPHA_LINKAGE);
 #endif
 
-#ifndef VMS
+#ifdef OBJ_EVAX
+#define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR) (P2VAR) = 3
+#else
 #define TC_IMPLICIT_LCOMM_ALIGNMENT(size, align) \
   do							\
     {							\
@@ -133,12 +135,14 @@ extern flagword alpha_elf_section_flags (flagword, bfd_vma, int);
 #define RELOC_OP_P
 #endif
 
+#ifndef OBJ_EVAX
 /* Before the relocations are written, reorder them, so that user
    supplied !lituse relocations follow the appropriate !literal
    relocations.  Also convert the gas-internal relocations to the
    appropriate linker relocations.  */
 #define tc_frob_file_before_fix() alpha_before_fix ()
 extern void alpha_before_fix (void);
+#endif
 
 #ifdef OBJ_ELF
 #define md_end  alpha_elf_md_end
diff --git a/gas/doc/as.texinfo b/gas/doc/as.texinfo
index fd6c0a3..a64b3d0 100644
--- a/gas/doc/as.texinfo
+++ b/gas/doc/as.texinfo
@@ -248,6 +248,7 @@ gcc(1), ld(1), and the Info entries for @file{binutils} and @file{ld}.
 @emph{Target Alpha options:}
    [@b{-m@var{cpu}}]
    [@b{-mdebug} | @b{-no-mdebug}]
+   [@b{-replace} | @b{-noreplace}]
    [@b{-relax}] [@b{-g}] [@b{-G@var{size}}]
    [@b{-F}] [@b{-32addr}]
 @end ifset
diff --git a/gas/doc/c-alpha.texi b/gas/doc/c-alpha.texi
index f426b82..0d789d2 100644
--- a/gas/doc/c-alpha.texi
+++ b/gas/doc/c-alpha.texi
@@ -90,6 +90,15 @@ this option does not propagate all symbol arithmetic into the object file,
 because not all symbol arithmetic can be represented.  However, the option
 can still be useful in specific applications.
 
+@cindex @code{-replace} command line option, Alpha
+@cindex @code{-noreplace} command line option, Alpha
+@item -replace
+@item -noreplace
+Enables or disables the optimization of procedure calls, both at assemblage
+and at link time.  These options are only available for VMS targets and
+@code{-replace} is the default.  See section 1.4.1 of the OpenVMS Linker
+Utility Manual.
+
 @cindex @code{-g} command line option, Alpha
 @item -g
 This option is used when the compiler generates debug information.  When
diff --git a/gas/dwarf2dbg.c b/gas/dwarf2dbg.c
index 2bcba9b..f332865 100644
--- a/gas/dwarf2dbg.c
+++ b/gas/dwarf2dbg.c
@@ -1636,9 +1636,15 @@ out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg, segT ranges_seg)
     {
       dirname = remap_debug_filename (dirs[files[1].dir]);
       len = strlen (dirname);
+#ifdef TE_VMS
+      /* Already has trailing slash.  */
+      p = frag_more (len);
+      memcpy (p, dirname, len);
+#else
       p = frag_more (len + 1);
       memcpy (p, dirname, len);
       INSERT_DIR_SEPARATOR (p, len);
+#endif
     }
   len = strlen (files[1].filename) + 1;
   p = frag_more (len);