* config/alpha/vms.h (VMS_DEBUGGING_INFO): New macro.

	(PREFERRED_DEBUGGING_TYPE): Define as VMS_AND_DWARF2_DEBUG.
	(ASM_SPEC): Don't redefine.
	(OPTIMIZATION_OPTIONS, OVERRIDE_OPTIONS, LINK_SPEC): Define.
	* config/alpha/t-vms (EXTRA_PARTS): Use; add rule for vms-dwarf2.asm.
	* config/alpha/vms-dwarf2.asm: New file.
	* Makefile.in (OBJS): Add vmsdbgout.c and its rule.
	* c-lex.c (init_c_lex): Test for VMS_AND_DWARF2_DEBUG.
	* debug.h (gcc_debug_hooks): Add vmsdbg_debug_hooks.
	(vmsdbgout_after_prologue): New declaration.
	* defaults.h (VMS_DEBUGGING_INFO): Add to PREFERRED_DEBUGGING_TYPE.
	* dwarf2.h (dwarf_attribute): New DW_AT_VMS_rtnbeg_pd_address.
	* dwarf2out.c (dwarf2out_do_frame): Test for VMS_AND_DWARF2_DEBUG.
	(dwarf2out_frame_finish): Test for VMS_AND_DWARF2_DEBUG.
	(dwarf_attr_name): Use DW_AT_VMS_rtnbeg_pd_address.
	(add_name_and_src_coords_attributes): Test VMS_DEBUGGING_INFO
	* final.c (final_start_function): Test for VMS_AND_DWARF2_DEBUG.
	Test VMS_DEBUGGING_INFO.
	(final_end_function): Test for VMS_AND_DWARF2_DEBUG.
	(final_scan_insn): Test for VMS_AND_DWARF2_DEBUG and VMS_DEBUG.
	* flags.h (debug_info_type): Add VMS_DEBUG and VMS_AND_DWARF2_DEBUG.
	* toplev.c (compile_file): Test VMS_DEBUGGING_INFO, VMS_DEBUG, and
	VMS_AND_DWARF2_DEBUG.
	(rest_of_type_compilation): Test for VMS_AND_DWARF2_DEBUG.
	(decode_g_option): Add "vms" to debug_type_names.
	(process_options): Set vmsdbg_debug_hooks if -gvms.
	(lang_independent_init): Emit line number for VMS unless -g0.
	* tree.c: (build_complex_type): Test for VMS_AND_DWARF2_DEBUG.
	* vmsdbg.h, vmsdbgout.c: New files.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@47532 138bc75d-0d04-0410-961f-82ee72b054a4

16 files changed, 2063 insertions, 30 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 6771647229a..2b5f1b7d620 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,36 @@
+Sun Dec  2 09:22:25 2001  Douglas B. Rupp  <rupp@gnat.com>
+
+	* config/alpha/vms.h (VMS_DEBUGGING_INFO): New macro.
+	(PREFERRED_DEBUGGING_TYPE): Define as VMS_AND_DWARF2_DEBUG.
+	(ASM_SPEC): Don't redefine.
+	(OPTIMIZATION_OPTIONS, OVERRIDE_OPTIONS, LINK_SPEC): Define.
+	* config/alpha/t-vms (EXTRA_PARTS): Use; add rule for vms-dwarf2.asm.
+	* config/alpha/vms-dwarf2.asm: New file.
+
+	* Makefile.in (OBJS): Add vmsdbgout.c and its rule.
+	* c-lex.c (init_c_lex): Test for VMS_AND_DWARF2_DEBUG.
+	* debug.h (gcc_debug_hooks): Add vmsdbg_debug_hooks.
+	(vmsdbgout_after_prologue): New declaration.
+	* defaults.h (VMS_DEBUGGING_INFO): Add to PREFERRED_DEBUGGING_TYPE.
+	* dwarf2.h (dwarf_attribute): New DW_AT_VMS_rtnbeg_pd_address.
+	* dwarf2out.c (dwarf2out_do_frame): Test for VMS_AND_DWARF2_DEBUG.
+	(dwarf2out_frame_finish): Test for VMS_AND_DWARF2_DEBUG.
+	(dwarf_attr_name): Use DW_AT_VMS_rtnbeg_pd_address.
+	(add_name_and_src_coords_attributes): Test VMS_DEBUGGING_INFO
+	* final.c (final_start_function): Test for VMS_AND_DWARF2_DEBUG.
+	Test VMS_DEBUGGING_INFO.
+	(final_end_function): Test for VMS_AND_DWARF2_DEBUG.
+	(final_scan_insn): Test for VMS_AND_DWARF2_DEBUG and VMS_DEBUG.
+	* flags.h (debug_info_type): Add VMS_DEBUG and VMS_AND_DWARF2_DEBUG.
+	* toplev.c (compile_file): Test VMS_DEBUGGING_INFO, VMS_DEBUG, and
+	VMS_AND_DWARF2_DEBUG.
+	(rest_of_type_compilation): Test for VMS_AND_DWARF2_DEBUG.
+	(decode_g_option): Add "vms" to debug_type_names.
+	(process_options): Set vmsdbg_debug_hooks if -gvms.
+	(lang_independent_init): Emit line number for VMS unless -g0.
+	* tree.c: (build_complex_type): Test for VMS_AND_DWARF2_DEBUG.
+	* vmsdbg.h, vmsdbgout.c: New files.
+
 Sun Dec  2 09:03:06 2001  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
 
 	* cfgbuild.c (SET_STATE): Add cast to eliminate warning.a
diff --git a/gcc/Makefile.in b/gcc/Makefile.in
index 2ef5984a9c2..32ed60ab69b 100644
--- a/gcc/Makefile.in
+++ b/gcc/Makefile.in
@@ -728,7 +728,7 @@ OBJS = alias.o bb-reorder.o bitmap.o builtins.o caller-save.o calls.o	\
  sbitmap.o sched-deps.o sched-ebb.o sched-rgn.o sched-vis.o sdbout.o	\
  sibcall.o simplify-rtx.o ssa.o ssa-ccp.o ssa-dce.o stmt.o	\
  stor-layout.o stringpool.o timevar.o toplev.o tree.o tree-dump.o 	\
- tree-inline.o unroll.o varasm.o varray.o version.o xcoffout.o 		\
+ tree-inline.o unroll.o varasm.o varray.o version.o vmsdbgout.o xcoffout.o \
  $(GGC) $(out_object_file) $(EXTRA_OBJS)
 
 BACKEND = main.o libbackend.a
@@ -1395,6 +1395,8 @@ dwarf2out.o : dwarf2out.c $(CONFIG_H) $(SYSTEM_H) $(TREE_H) $(RTL_H) dwarf2.h \
    $(GGC_H) except.h dwarf2asm.h $(TM_P_H) langhooks.h
 dwarf2asm.o : dwarf2asm.c $(CONFIG_H) $(SYSTEM_H) flags.h $(RTL_H) $(TREE_H) \
    output.h dwarf2asm.h $(TM_P_H)
+vmsdbgout.o : vmsdbgout.c $(CONFIG_H) $(SYSTEM_H) $(TREE_H) $(RTL_H) flags.h \
+   output.h vmsdbg.h debug.h langhooks.h
 xcoffout.o : xcoffout.c $(CONFIG_H) $(SYSTEM_H) $(TREE_H) $(RTL_H) xcoffout.h \
    flags.h toplev.h output.h dbxout.h $(GGC_H)
 emit-rtl.o : emit-rtl.c $(CONFIG_H) $(SYSTEM_H) $(RTL_H) $(TREE_H) flags.h \
diff --git a/gcc/c-lex.c b/gcc/c-lex.c
index 94bc63e6609..e70be7028e6 100644
--- a/gcc/c-lex.c
+++ b/gcc/c-lex.c
@@ -133,7 +133,8 @@ init_c_lex (filename)
 
   /* Set the debug callbacks if we can use them.  */
   if (debug_info_level == DINFO_LEVEL_VERBOSE
-      && (write_symbols == DWARF_DEBUG || write_symbols == DWARF2_DEBUG))
+      && (write_symbols == DWARF_DEBUG || write_symbols == DWARF2_DEBUG
+          || write_symbols == VMS_AND_DWARF2_DEBUG))
     {
       cb->define = cb_define;
       cb->undef = cb_undef;
diff --git a/gcc/config/alpha/t-vms b/gcc/config/alpha/t-vms
index 80299d2dc3d..3b079f0096e 100644
--- a/gcc/config/alpha/t-vms
+++ b/gcc/config/alpha/t-vms
@@ -1 +1,7 @@
 LIB2FUNCS_EXTRA = $(srcdir)/config/alpha/vms_tramp.asm
+EXTRA_PARTS = vms-dwarf2.o
+
+# This object must be linked in in order to make the executable debuggable.
+# vms-ld handles it automatically when passed -g.
+vms-dwarf2.o : $(srcdir)/config/alpha/vms-dwarf2.asm
+	gcc -c -x assembler $<
diff --git a/gcc/config/alpha/vms-dwarf2.asm b/gcc/config/alpha/vms-dwarf2.asm
new file mode 100644
index 00000000000..a94ae24b152
--- /dev/null
+++ b/gcc/config/alpha/vms-dwarf2.asm
@@ -0,0 +1,82 @@
+/* VMS dwarf2 section sequentializer.
+   Copyright (C) 2001 Free Software Foundation, Inc.
+   Contributed by Douglas B. Rupp (rupp@gnat.com).
+
+This file is part of GNU CC.
+
+GNU CC 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, or (at your option)
+any later version.
+
+In addition to the permissions in the GNU General Public License, the
+Free Software Foundation gives you unlimited permission to link the
+compiled version of this file into combinations with other programs,
+and to distribute those combinations without any restriction coming
+from the use of this file.  (The General Public License restrictions
+do apply in other respects; for example, they cover modification of
+the file, and distribution when not linked into a combine
+executable.)
+
+GNU CC 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 GNU CC; see the file COPYING.  If not, write to
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.  */
+
+/* Linking with this file forces Dwarf2 debug sections to be
+   sequentially loaded by the VMS linker, enabling GDB to read them.  */
+
+.section	.debug_abbrev,NOWRT
+		.align 0
+		.globl	$dwarf2.debug_abbrev
+$dwarf2.debug_abbrev:
+	
+.section	.debug_aranges,NOWRT
+		.align 0
+		.globl	$dwarf2.debug_aranges
+$dwarf2.debug_aranges:
+	
+.section	.debug_frame,NOWRT
+		.align 0
+		.globl	$dwarf2.debug_frame
+$dwarf2.debug_frame:		
+	
+.section	.debug_info,NOWRT
+		.align 0
+		.globl	$dwarf2.debug_info
+$dwarf2.debug_info:		
+	
+.section	.debug_line,NOWRT
+		.align 0
+		.globl	$dwarf2.debug_line
+$dwarf2.debug_line:		
+	
+.section	.debug_loc,NOWRT
+		.align 0
+		.globl	$dwarf2.debug_loc
+$dwarf2.debug_loc:		
+	
+.section	.debug_macinfo,NOWRT
+		.align 0
+		.globl	$dwarf2.debug_macinfo
+$dwarf2.debug_macinfo:		
+	
+.section	.debug_pubnames,NOWRT
+		.align 0
+		.globl	$dwarf2.debug_pubnames
+$dwarf2.debug_pubnames:		
+	
+.section	.debug_str,NOWRT
+		.align 0
+		.globl	$dwarf2.debug_str
+$dwarf2.debug_str:		
+	
+.section	.debug_zzzzzz,NOWRT
+		.align 0
+		.globl	$dwarf2.debug_zzzzzz
+$dwarf2.debug_zzzzzz:		
diff --git a/gcc/config/alpha/vms.h b/gcc/config/alpha/vms.h
index 88c649652c0..d53deb3102c 100644
--- a/gcc/config/alpha/vms.h
+++ b/gcc/config/alpha/vms.h
@@ -403,6 +403,7 @@ do {									\
 #undef DBX_DEBUGGING_INFO
 
 #define DWARF2_DEBUGGING_INFO
+#define VMS_DEBUGGING_INFO
 
 /* This is how to output an assembler line
    that says to advance the location counter
@@ -425,7 +426,7 @@ do {									\
   } while (0)
 
 #undef PREFERRED_DEBUGGING_TYPE
-#define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG
+#define PREFERRED_DEBUGGING_TYPE VMS_AND_DWARF2_DEBUG
 
 #undef ASM_FORMAT_PRIVATE_NAME
 #define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO)	\
@@ -437,10 +438,33 @@ do {									\
 
 #undef ASM_SPEC
 #undef ASM_FINAL_SPEC
+
+/* The VMS convention is to always provide minimal debug info
+   for a traceback unless specifically overridden.  Defaulting this here
+   is a kludge.  */
+
+#define OPTIMIZATION_OPTIONS(OPTIMIZE, OPTIMIZE_SIZE) \
+{                                                  \
+   write_symbols = VMS_DEBUG;                      \
+   debug_info_level = (enum debug_info_level) 1;   \
+}
+
+/* Override traceback debug info on -g0.  */
+#undef OVERRIDE_OPTIONS
+#define OVERRIDE_OPTIONS                           \
+{                                                  \
+   if (write_symbols == NO_DEBUG)                  \
+     debug_info_level = (enum debug_info_level) 0; \
+   override_options ();                            \
+}
+
+/* Link with vms-dwarf2.o if -g (except -g0). This causes the
+   VMS link to pull all the dwarf2 debug sections together. */
 #undef LINK_SPEC
+#define LINK_SPEC "%{g:-g vms-dwarf2.o%s} %{g0} %{g1:-g1 vms-dwarf2.o%s} \
+%{g2:-g2 vms-dwarf2.o%s} %{g3:-g3 vms-dwarf2.o%s} %{shared} %{v} %{map}"
+
 #undef STARTFILE_SPEC
-#define ASM_SPEC "-nocpp %{pg}"
-#define LINK_SPEC "%{g3:-g3} %{g0:-g0} %{shared:-shared} %{v:-v}"
 
 /* Define the names of the division and modulus functions.  */
 #define DIVSI3_LIBCALL "OTS$DIV_I"
diff --git a/gcc/debug.h b/gcc/debug.h
index 3626ed554e0..865e5f86e1b 100644
--- a/gcc/debug.h
+++ b/gcc/debug.h
@@ -133,22 +133,22 @@ extern struct gcc_debug_hooks sdb_debug_hooks;
 extern struct gcc_debug_hooks xcoff_debug_hooks;
 extern struct gcc_debug_hooks dwarf_debug_hooks;
 extern struct gcc_debug_hooks dwarf2_debug_hooks;
+extern struct gcc_debug_hooks vmsdbg_debug_hooks;
 
 /* Dwarf2 frame information.  */
 
-/* FILE is NULL iff being called for frame information for non-dwarf
-   debug output.  */
-extern void dwarf2out_begin_prologue
-  PARAMS ((unsigned int, const char * file));
-extern void dwarf2out_end_epilogue
-  PARAMS ((void));
-extern void dwarf2out_frame_init
-  PARAMS ((void));
-extern void dwarf2out_frame_finish
-  PARAMS ((void));
+extern void dwarf2out_begin_prologue	PARAMS ((unsigned int, const char *));
+extern void dwarf2out_end_epilogue	PARAMS ((void));
+extern void dwarf2out_frame_init	PARAMS ((void));
+extern void dwarf2out_frame_finish	PARAMS ((void));
 /* Decide whether we want to emit frame unwind information for the current
    translation unit.  */
-extern int dwarf2out_do_frame
-  PARAMS ((void));
+extern int dwarf2out_do_frame		PARAMS ((void));
+
+/* When writing VMS debug info, output label after the prologue of the
+   function.  */
+extern void vmsdbgout_after_prologue	PARAMS ((void));
+
+
 
 #endif /* !GCC_DEBUG_H  */
diff --git a/gcc/defaults.h b/gcc/defaults.h
index f8dd2b34c6f..f23b0ab8a43 100644
--- a/gcc/defaults.h
+++ b/gcc/defaults.h
@@ -425,7 +425,7 @@ do {								\
    PREFERRED_DEBUGGING_TYPE to choose a format in a system-dependent way.
 
    This is one long line cause VAXC can't handle a \-newline.  */
-#if 1 < (defined (DBX_DEBUGGING_INFO) + defined (SDB_DEBUGGING_INFO) + defined (DWARF_DEBUGGING_INFO) + defined (DWARF2_DEBUGGING_INFO) + defined (XCOFF_DEBUGGING_INFO))
+#if 1 < (defined (DBX_DEBUGGING_INFO) + defined (SDB_DEBUGGING_INFO) + defined (DWARF_DEBUGGING_INFO) + defined (DWARF2_DEBUGGING_INFO) + defined (XCOFF_DEBUGGING_INFO) + defined (VMS_DEBUGGING_INFO))
 #ifndef PREFERRED_DEBUGGING_TYPE
 You Lose!  You must define PREFERRED_DEBUGGING_TYPE!
 #endif /* no PREFERRED_DEBUGGING_TYPE */
@@ -443,6 +443,9 @@ You Lose!  You must define PREFERRED_DEBUGGING_TYPE!
 #ifdef DWARF2_DEBUGGING_INFO
 #define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG
 #endif
+#ifdef VMS_DEBUGGING_INFO
+#define PREFERRED_DEBUGGING_TYPE VMS_AND_DWARF2_DEBUG
+#endif
 #ifdef XCOFF_DEBUGGING_INFO
 #define PREFERRED_DEBUGGING_TYPE XCOFF_DEBUG
 #endif
diff --git a/gcc/dwarf2.h b/gcc/dwarf2.h
index ae63acdbadb..d73866ca5c1 100644
--- a/gcc/dwarf2.h
+++ b/gcc/dwarf2.h
@@ -232,7 +232,9 @@ enum dwarf_attribute
     DW_AT_mac_info = 0x2103,
     DW_AT_src_coords = 0x2104,
     DW_AT_body_begin = 0x2105,
-    DW_AT_body_end = 0x2106
+    DW_AT_body_end = 0x2106,
+    /* VMS Extensions */
+    DW_AT_VMS_rtnbeg_pd_address = 0x2201
   };
 
 #define DW_AT_lo_user	0x2000	/* implementation-defined range start */
diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
index 7d2ea7b8347..a10367381e1 100644
--- a/gcc/dwarf2out.c
+++ b/gcc/dwarf2out.c
@@ -91,6 +91,7 @@ int
 dwarf2out_do_frame ()
 {
   return (write_symbols == DWARF2_DEBUG
+	  || write_symbols == VMS_AND_DWARF2_DEBUG
 #ifdef DWARF2_FRAME_INFO
 	  || DWARF2_FRAME_INFO
 #endif
@@ -2115,7 +2116,7 @@ void
 dwarf2out_frame_finish ()
 {
   /* Output call frame information.  */
-  if (write_symbols == DWARF2_DEBUG)
+  if (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
     output_call_frame_info (0);
   if (! USING_SJLJ_EXCEPTIONS && (flag_unwind_tables || flag_exceptions))
     output_call_frame_info (1);
@@ -4099,6 +4100,9 @@ dwarf_attr_name (attr)
       return "DW_AT_body_begin";
     case DW_AT_body_end:
       return "DW_AT_body_end";
+    case DW_AT_VMS_rtnbeg_pd_address:
+      return "DW_AT_VMS_rtnbeg_pd_address";
+
     default:
       return "DW_AT_<unknown>";
     }
@@ -9311,6 +9315,15 @@ add_name_and_src_coords_attributes (die, decl)
 	add_AT_string (die, DW_AT_MIPS_linkage_name,
 		       IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
     }
+
+#ifdef VMS_DEBUGGING_INFO
+
+  /* Get the function's name, as described by its RTL.  This may be different
+     from the DECL_NAME name used in the source file.  */
+  if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
+    add_AT_string (die, DW_AT_VMS_rtnbeg_pd_address,
+		   xstrdup (XSTR (XEXP (DECL_RTL (decl), 0), 0)));
+#endif
 }
 
 /* Push a new declaration scope.  */
diff --git a/gcc/final.c b/gcc/final.c
index b225334e4fa..7af2c1f66a5 100644
--- a/gcc/final.c
+++ b/gcc/final.c
@@ -1678,7 +1678,7 @@ final_start_function (first, file, optimize)
   (*debug_hooks->begin_prologue) (last_linenum, last_filename);
 
 #if defined (DWARF2_UNWIND_INFO) || defined (IA64_UNWIND_INFO)
-  if (write_symbols != DWARF2_DEBUG)
+  if (write_symbols != DWARF2_DEBUG && write_symbols != VMS_AND_DWARF2_DEBUG)
     dwarf2out_begin_prologue (0, NULL);
 #endif
 
@@ -1715,6 +1715,12 @@ final_start_function (first, file, optimize)
   /* First output the function prologue: code to set up the stack frame.  */
   (*targetm.asm_out.function_prologue) (file, get_frame_size ());
 
+#ifdef VMS_DEBUGGING_INFO
+  /* Output label after the prologue of the function.  */
+  if (write_symbols == VMS_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
+    vmsdbgout_after_prologue ();
+#endif
+
   /* If the machine represents the prologue as RTL, the profiling code must
      be emitted when NOTE_INSN_PROLOGUE_END is scanned.  */
 #ifdef HAVE_prologue
@@ -1846,7 +1852,8 @@ final_end_function ()
   (*debug_hooks->end_epilogue) ();
 
 #if defined (DWARF2_UNWIND_INFO)
-  if (write_symbols != DWARF2_DEBUG && dwarf2out_do_frame ())
+  if (write_symbols != DWARF2_DEBUG && write_symbols != VMS_AND_DWARF2_DEBUG
+      && dwarf2out_do_frame ())
     dwarf2out_end_epilogue ();
 #endif
 
@@ -2160,7 +2167,9 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes)
 	  if (debug_info_level == DINFO_LEVEL_NORMAL
 	      || debug_info_level == DINFO_LEVEL_VERBOSE
 	      || write_symbols == DWARF_DEBUG
-	      || write_symbols == DWARF2_DEBUG)
+	      || write_symbols == DWARF2_DEBUG
+	      || write_symbols == VMS_AND_DWARF2_DEBUG
+	      || write_symbols == VMS_DEBUG)
 	    {
 	      int n = BLOCK_NUMBER (NOTE_BLOCK (insn));
 
@@ -2180,7 +2189,9 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes)
 	  if (debug_info_level == DINFO_LEVEL_NORMAL
 	      || debug_info_level == DINFO_LEVEL_VERBOSE
 	      || write_symbols == DWARF_DEBUG
-	      || write_symbols == DWARF2_DEBUG)
+	      || write_symbols == DWARF2_DEBUG
+	      || write_symbols == VMS_AND_DWARF2_DEBUG
+	      || write_symbols == VMS_DEBUG)
 	    {
 	      int n = BLOCK_NUMBER (NOTE_BLOCK (insn));
 
diff --git a/gcc/flags.h b/gcc/flags.h
index e1de92237f2..8c8fa264886 100644
--- a/gcc/flags.h
+++ b/gcc/flags.h
@@ -32,7 +32,10 @@ enum debug_info_type
   SDB_DEBUG,	    /* Write COFF for (old) SDB (using sdbout.c).  */
   DWARF_DEBUG,	    /* Write Dwarf debug info (using dwarfout.c).  */
   DWARF2_DEBUG,	    /* Write Dwarf v2 debug info (using dwarf2out.c).  */
-  XCOFF_DEBUG	    /* Write IBM/Xcoff debug info (using dbxout.c).  */
+  XCOFF_DEBUG,	    /* Write IBM/Xcoff debug info (using dbxout.c).  */
+  VMS_DEBUG,        /* Write VMS debug info (using vmsdbgout.c). */
+  VMS_AND_DWARF2_DEBUG /* Write VMS debug info (using vmsdbgout.c).
+                          and DWARF v2 debug info (using dwarf2out.c). */
 };
 
 /* Specify which kind of debugging info to generate.  */
diff --git a/gcc/toplev.c b/gcc/toplev.c
index 311ef95b7d0..54582dc4784 100644
--- a/gcc/toplev.c
+++ b/gcc/toplev.c
@@ -2332,7 +2332,9 @@ rest_of_type_compilation (type, toplev)
     sdbout_symbol (TYPE_STUB_DECL (type), !toplev);
 #endif
 #ifdef DWARF2_DEBUGGING_INFO
-  if (write_symbols == DWARF2_DEBUG && toplev)
+  if ((write_symbols == DWARF2_DEBUG
+       || write_symbols == VMS_AND_DWARF2_DEBUG)
+      && toplev)
     dwarf2out_decl (TYPE_STUB_DECL (type));
 #endif
   timevar_pop (TV_SYMOUT);
@@ -3974,7 +3976,7 @@ decode_g_option (arg)
   /* Indexed by enum debug_info_type.  */
   static const char *const debug_type_names[] =
   {
-    "none", "stabs", "coff", "dwarf-1", "dwarf-2", "xcoff"
+    "none", "stabs", "coff", "dwarf-1", "dwarf-2", "xcoff", "vms"
   };
 
   /* The maximum admissible debug level value.  */
@@ -4937,6 +4939,10 @@ process_options ()
   if (write_symbols == DWARF2_DEBUG)
     debug_hooks = &dwarf2_debug_hooks;
 #endif
+#ifdef VMS_DEBUGGING_INFO
+  if (write_symbols == VMS_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
+    debug_hooks = &vmsdbg_debug_hooks;
+#endif
 
   /* If auxiliary info generation is desired, open the output file.
      This goes in the same directory as the source file--unlike
@@ -4999,8 +5005,12 @@ lang_independent_init ()
 
   init_emit_once (debug_info_level == DINFO_LEVEL_NORMAL
 		  || debug_info_level == DINFO_LEVEL_VERBOSE
-		  || flag_test_coverage
-		  || warn_notreached);
+#ifdef VMS_DEBUGGING_INFO
+		    /* Enable line number info for traceback */
+		    || debug_info_level > DINFO_LEVEL_NONE
+#endif
+		    || flag_test_coverage
+		    || warn_notreached);
   init_regs ();
   init_alias_once ();
   init_stmt ();
diff --git a/gcc/tree.c b/gcc/tree.c
index 39ce8d8842e..3cc52c03f5f 100644
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -3997,7 +3997,8 @@ build_complex_type (component_type)
 
   /* If we are writing Dwarf2 output we need to create a name,
      since complex is a fundamental type.  */
-  if (write_symbols == DWARF2_DEBUG && ! TYPE_NAME (t))
+  if ((write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
+      && ! TYPE_NAME (t))
     {
       const char *name;
       if (component_type == char_type_node)
diff --git a/gcc/vmsdbg.h b/gcc/vmsdbg.h
new file mode 100644
index 00000000000..65147a6cf5d
--- /dev/null
+++ b/gcc/vmsdbg.h
@@ -0,0 +1,173 @@
+/* This file contains definitions for the data structures and codes used in
+   VMS debugging information.  */
+
+#ifndef VMSDBG_H
+#define VMSDBG_H 1
+	
+typedef unsigned short int DST_DTYPE;
+#define DST_K_SOURCE 155
+#define DST_K_PROLOG 162
+#define DST_K_BLKBEG 176
+#define DST_K_BLKEND 177
+#define DST_K_LINE_NUM 185
+#define DST_K_MODBEG 188
+#define DST_K_MODEND 189
+#define DST_K_RTNBEG 190
+#define DST_K_RTNEND 191
+
+typedef struct _DST_HEADER {
+  union  {
+    unsigned short int dst_w_length;
+    unsigned short int dst_x_length;
+  } dst__header_length;
+  union  {
+    DST_DTYPE dst_w_type;
+    DST_DTYPE dst_x_type;
+  } dst__header_type;
+} DST_HEADER;
+#define DST_K_DST_HEADER_SIZE 4
+	
+typedef unsigned int DST_LANGUAGE;
+#define DST_K_FORTRAN 1
+#define DST_K_C 7
+#define DST_K_ADA 9
+#define DST_K_UNKNOWN 10
+#define DST_K_CXX 15
+typedef struct _DST_MODULE_BEGIN {
+  DST_HEADER dst_a_modbeg_header;
+  struct  {
+    unsigned dst_v_modbeg_hide : 1;
+    unsigned dst_v_modbeg_version : 1;
+    unsigned dst_v_modbeg_unused : 6;
+  } dst_b_modbeg_flags;
+  unsigned char dst_b_modbeg_unused;
+  DST_LANGUAGE dst_l_modbeg_language;
+  unsigned short int dst_w_version_major;
+  unsigned short int dst_w_version_minor;
+  unsigned char dst_b_modbeg_name;
+} DST_MODULE_BEGIN;
+#define DST_K_MODBEG_SIZE 15
+	
+typedef struct _DST_MB_TRLR {
+  unsigned char dst_b_compiler;
+} DST_MB_TRLR;
+#define DST_K_MB_TRLR_SIZE 1
+#define DST_K_VERSION_MAJOR 1
+#define DST_K_VERSION_MINOR 13
+typedef struct _DST_MODULE_END {
+  DST_HEADER dst_a_modend_header;
+} DST_MODULE_END;
+#define DST_K_MODEND_SIZE 4
+typedef struct _DST_ROUTINE_BEGIN {
+  DST_HEADER dst_a_rtnbeg_header;
+  struct  {
+    unsigned dst_v_rtnbeg_unused : 4;
+    unsigned dst_v_rtnbeg_unalloc : 1;
+    unsigned dst_v_rtnbeg_prototype : 1;
+    unsigned dst_v_rtnbeg_inlined : 1;
+    unsigned dst_v_rtnbeg_no_call : 1;
+  } dst_b_rtnbeg_flags;
+  int *dst_l_rtnbeg_address;
+  int *dst_l_rtnbeg_pd_address;
+  unsigned char dst_b_rtnbeg_name;
+} DST_ROUTINE_BEGIN;
+#define DST_K_RTNBEG_SIZE 14
+typedef struct _DST_ROUTINE_END {
+  DST_HEADER dst_a_rtnend_header;
+  char dst_b_rtnend_unused;
+  unsigned int dst_l_rtnend_size;
+} DST_ROUTINE_END;
+#define DST_K_RTNEND_SIZE 9
+typedef struct _DST_BLOCK_BEGIN {
+  DST_HEADER dst_a_blkbeg_header;
+  unsigned char dst_b_blkbeg_unused;
+  int *dst_l_blkbeg_address;
+  unsigned char dst_b_blkbeg_name;
+} DST_BLOCK_BEGIN;
+#define DST_K_BLKBEG_SIZE 10
+typedef struct _DST_BLOCK_END {
+  DST_HEADER dst_a_blkend_header;
+  unsigned char dst_b_blkend_unused;
+  unsigned int dst_l_blkend_size;
+} DST_BLOCK_END;
+#define DST_K_BLKEND_SIZE 9
+typedef struct _DST_LINE_NUM_HEADER {
+  DST_HEADER dst_a_line_num_header;
+} DST_LINE_NUM_HEADER;
+#define DST_K_LINE_NUM_HEADER_SIZE 4
+
+typedef struct _DST_PCLINE_COMMANDS {
+  char dst_b_pcline_command;
+  union  {
+    unsigned int dst_l_pcline_unslong;
+    unsigned short int dst_w_pcline_unsword;
+    unsigned char dst_b_pcline_unsbyte;
+  } dst_a_pcline_access_fields;
+} DST_PCLINE_COMMANDS;
+#define DST_K_PCLINE_COMMANDS_SIZE 5
+#define DST_K_PCLINE_COMMANDS_SIZE_MIN 2
+#define DST_K_PCLINE_COMMANDS_SIZE_MAX 5
+#define DST_K_DELTA_PC_LOW -128
+#define DST_K_DELTA_PC_HIGH 0
+#define DST_K_DELTA_PC_W 1
+#define DST_K_INCR_LINUM 2
+#define DST_K_INCR_LINUM_W 3
+#define DST_K_SET_LINUM 9
+#define DST_K_SET_ABS_PC 16
+#define DST_K_DELTA_PC_L 17
+#define DST_K_INCR_LINUM_L 18
+#define DST_K_SET_LINUM_B 19
+#define DST_K_SET_LINUM_L 20
+typedef struct _DST_SOURCE_CORR {
+  DST_HEADER dst_a_source_corr_header;
+} DST_SOURCE_CORR;
+#define DST_K_SOURCE_CORR_HEADER_SIZE 4
+	
+#define DST_K_SRC_DECLFILE 1
+#define DST_K_SRC_SETFILE 2
+#define DST_K_SRC_SETREC_L 3
+#define DST_K_SRC_SETREC_W 4
+#define DST_K_SRC_SETLNUM_L 5
+#define DST_K_SRC_SETLNUM_W 6
+#define DST_K_SRC_INCRLNUM_B 7
+#define DST_K_SRC_DEFLINES_W 10
+#define DST_K_SRC_DEFLINES_B 11
+#define DST_K_SRC_FORMFEED 16
+#define DST_K_SRC_MIN_CMD 1
+#define DST_K_SRC_MAX_CMD 16
+typedef struct _DST_SRC_COMMAND {
+  unsigned char dst_b_src_command;
+  union  {
+    struct  {
+      unsigned char dst_b_src_df_length;
+      unsigned char dst_b_src_df_flags;
+      unsigned short int dst_w_src_df_fileid;
+#ifdef __GNUC__
+      long long dst_q_src_df_rms_cdt;
+#else
+      __int64 dst_q_src_df_rms_cdt;
+#endif
+      unsigned int dst_l_src_df_rms_ebk;
+      unsigned short int dst_w_src_df_rms_ffb;
+      unsigned char dst_b_src_df_rms_rfo;
+      unsigned char dst_b_src_df_filename;
+    } dst_a_src_decl_src;
+    unsigned int dst_l_src_unslong;
+    unsigned short int dst_w_src_unsword;
+    unsigned char dst_b_src_unsbyte;
+  } dst_a_src_cmd_fields;
+} DST_SRC_COMMAND;
+#define DST_K_SRC_COMMAND_SIZE 21
+	
+typedef struct _DST_SRC_CMDTRLR {
+  unsigned char dst_b_src_df_libmodname;
+} DST_SRC_CMDTRLR;
+#define DST_K_SRC_CMDTRLR_SIZE 1
+	
+typedef struct _DST_PROLOG {
+  DST_HEADER dst_a_prolog_header;
+  unsigned int dst_l_prolog_bkpt_addr;
+} DST_PROLOG;
+#define DST_K_PROLOG_SIZE 8
+	
+#endif /* VMSDBG_H */
diff --git a/gcc/vmsdbgout.c b/gcc/vmsdbgout.c
new file mode 100644
index 00000000000..afc17f5a01f
--- /dev/null
+++ b/gcc/vmsdbgout.c
@@ -0,0 +1,1669 @@
+/* Output VMS debug format symbol table information from the GNU C compiler.
+   Copyright (C) 1997-2001 Free Software Foundation, Inc.
+   Contributed by Douglas B. Rupp (rupp@gnat.com).
+
+This file is part of GNU CC.
+
+GNU CC 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, or (at your option)
+any later version.
+
+GNU CC 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 GNU CC; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#include "config.h"
+
+#ifdef VMS_DEBUGGING_INFO
+#include "system.h"
+#include "tree.h"
+#include "flags.h"
+#include "rtl.h"
+#include "output.h"
+#include "vmsdbg.h"
+#include "debug.h"
+#include "langhooks.h"
+
+/* Difference in seconds between the VMS Epoch and the Unix Epoch */
+static const long long vms_epoch_offset = 3506716800ll;
+
+/* NOTE: In the comments in this file, many references are made to "Debug
+   Symbol Table".  This term is abbreviated as `DST' throughout the remainder
+   of this file.  */
+
+typedef struct dst_line_info_struct *dst_line_info_ref;
+
+/* Each entry in the line_info_table maintains the file and
+   line number associated with the label generated for that
+   entry.  The label gives the PC value associated with
+   the line number entry.  */
+typedef struct dst_line_info_struct
+{
+  unsigned long dst_file_num;
+  unsigned long dst_line_num;
+}
+dst_line_info_entry;
+
+typedef struct dst_file_info_struct *dst_file_info_ref;
+
+typedef struct dst_file_info_struct
+{
+  char *file_name;
+  unsigned int max_line;
+  unsigned int listing_line_start;
+  long long cdt;
+  long ebk;
+  short ffb;
+  char rfo;
+  char flen;
+}
+dst_file_info_entry;
+
+/* How to start an assembler comment.  */
+#ifndef ASM_COMMENT_START
+#define ASM_COMMENT_START ";#"
+#endif
+
+/* Maximum size (in bytes) of an artificially generated label.   */
+#define MAX_ARTIFICIAL_LABEL_BYTES	30
+
+/* Make sure we know the sizes of the various types debug can describe. These
+   are only defaults.  If the sizes are different for your target, you should
+   override these values by defining the appropriate symbols in your tm.h
+   file.  */
+#ifndef CHAR_TYPE_SIZE
+#define CHAR_TYPE_SIZE BITS_PER_UNIT
+#endif
+#ifndef PTR_SIZE
+#define PTR_SIZE 4 /* Must be 32 bits for VMS debug info */
+#endif
+
+/* Pointer to an structure of filenames referenced by this compilation unit. */
+static dst_file_info_ref file_info_table;
+
+/* Total number of entries in the table (i.e. array) pointed to by
+   `file_info_table'.  This is the *total* and includes both used and unused
+   slots.  */
+static unsigned int file_info_table_allocated;
+
+/* Number of entries in the file_info_table which are actually in use.  */
+static unsigned int file_info_table_in_use;
+
+/* Size (in elements) of increments by which we may expand the filename
+   table.  */
+#define FILE_TABLE_INCREMENT 64
+
+static char **func_table;
+static unsigned int func_table_allocated;
+static unsigned int func_table_in_use;
+#define FUNC_TABLE_INCREMENT 256
+
+/* Local pointer to the name of the main input file.  Initialized in
+   avmdbgout_init.  */
+static const char *primary_filename;
+
+static char *module_producer;
+static unsigned int module_language;
+
+/* A pointer to the base of a table that contains line information
+   for each source code line in .text in the compilation unit.  */
+static dst_line_info_ref line_info_table;
+
+/* Number of elements currently allocated for line_info_table.  */
+static unsigned int line_info_table_allocated;
+
+/* Number of elements in line_info_table currently in use.  */
+static unsigned int line_info_table_in_use;
+
+/* Size (in elements) of increments by which we may expand line_info_table.  */
+#define LINE_INFO_TABLE_INCREMENT 1024
+
+/* The number of the current function definition for which debugging
+   information is being generated.  These numbers range from 1 up to the
+   maximum number of function definitions contained within the current
+   compilation unit.  These numbers are used to create unique label id's unique
+   to each function definition.  */
+static unsigned int current_funcdef_number = 0;
+
+/* Forward declarations for functions defined in this file.  */
+static char *full_name 		PARAMS ((const char *));
+static unsigned int lookup_filename PARAMS ((const char *));
+static void addr_const_to_string PARAMS ((char *, rtx));
+static int write_debug_header	PARAMS ((DST_HEADER *, const char *, int));
+static int write_debug_addr	PARAMS ((char *, const char *, int));
+static int write_debug_data1	PARAMS ((unsigned int, const char *, int));
+static int write_debug_data2	PARAMS ((unsigned int, const char *, int));
+static int write_debug_data4	PARAMS ((unsigned long, const char *, int));
+static int write_debug_data8	PARAMS ((unsigned long long, const char *,
+					 int));
+static int write_debug_delta4	PARAMS ((char *, char *, const char *, int));
+static int write_debug_string	PARAMS ((char *, const char *, int));
+static int write_modbeg		PARAMS ((int));
+static int write_modend		PARAMS ((int));
+static int write_rtnbeg		PARAMS ((int, int));
+static int write_rtnend		PARAMS ((int, int));
+static int write_pclines	PARAMS ((int));
+static int write_srccorr	PARAMS ((int, dst_file_info_entry, int));
+static int write_srccorrs	PARAMS ((int));
+
+static void vmsdbgout_init		PARAMS ((const char *));
+static void vmsdbgout_finish		PARAMS ((const char *));
+static void vmsdbgout_define		PARAMS ((unsigned int, const char *));
+static void vmsdbgout_undef		PARAMS ((unsigned int, const char *));
+static void vmsdbgout_start_source_file PARAMS ((unsigned int, const char *));
+static void vmsdbgout_end_source_file	PARAMS ((unsigned int));
+static void vmsdbgout_begin_block	PARAMS ((unsigned int, unsigned int));
+static void vmsdbgout_end_block		PARAMS ((unsigned int, unsigned int));
+static bool vmsdbgout_ignore_block	PARAMS ((tree));
+static void vmsdbgout_source_line	PARAMS ((unsigned int, const char *));
+static void vmsdbgout_begin_prologue	PARAMS ((unsigned int, const char *));
+static void vmsdbgout_end_epilogue	PARAMS ((void));
+static void vmsdbgout_begin_function	PARAMS ((tree));
+static void vmsdbgout_decl		PARAMS ((tree));
+static void vmsdbgout_global_decl	PARAMS ((tree));
+static void vmsdbgout_abstract_function PARAMS ((tree));
+
+
+/* The debug hooks structure.  */
+
+struct gcc_debug_hooks vmsdbg_debug_hooks
+= {vmsdbgout_init,
+   vmsdbgout_finish,
+   vmsdbgout_define,
+   vmsdbgout_undef,
+   vmsdbgout_start_source_file,
+   vmsdbgout_end_source_file,
+   vmsdbgout_begin_block,
+   vmsdbgout_end_block,
+   vmsdbgout_ignore_block,
+   vmsdbgout_source_line,
+   vmsdbgout_begin_prologue,
+   debug_nothing_int,		/* end_prologue */
+   vmsdbgout_end_epilogue,	/* end_epilogue */
+   vmsdbgout_begin_function,	/* begin_function */
+   debug_nothing_int,		/* end_function */
+   vmsdbgout_decl,
+   vmsdbgout_global_decl,
+   debug_nothing_tree,		/* deferred_inline_function */
+   vmsdbgout_abstract_function,
+   debug_nothing_rtx		/* label */
+};
+
+/* Definitions of defaults for assembler-dependent names of various
+   pseudo-ops and section names.
+   Theses may be overridden in the tm.h file (if necessary) for a particular
+   assembler.  */
+#ifdef UNALIGNED_SHORT_ASM_OP
+#undef UNALIGNED_SHORT_ASM_OP
+#endif
+#define UNALIGNED_SHORT_ASM_OP	".word"
+
+#ifdef UNALIGNED_INT_ASM_OP
+#undef UNALIGNED_INT_ASM_OP
+#endif
+#define UNALIGNED_INT_ASM_OP	".long"
+
+#ifdef UNALIGNED_LONG_ASM_OP
+#undef UNALIGNED_LONG_ASM_OP
+#endif
+#define UNALIGNED_LONG_ASM_OP	".long"
+
+#ifdef UNALIGNED_DOUBLE_INT_ASM_OP
+#undef UNALIGNED_DOUBLE_INT_ASM_OP
+#endif
+#define UNALIGNED_DOUBLE_INT_ASM_OP	".quad"
+
+#ifdef ASM_BYTE_OP
+#undef ASM_BYTE_OP
+#endif
+#define ASM_BYTE_OP	".byte"
+
+#define NUMBYTES(I) ((I) < 256 ? 1 : (I) < 65536 ? 2 : 4)
+
+#define NUMBYTES0(I) ((I) < 128 ? 0 : (I) < 65536 ? 2 : 4)
+
+#ifndef UNALIGNED_PTR_ASM_OP
+#define UNALIGNED_PTR_ASM_OP \
+  (PTR_SIZE == 8 ? UNALIGNED_DOUBLE_INT_ASM_OP : UNALIGNED_INT_ASM_OP)
+#endif
+
+#ifndef UNALIGNED_OFFSET_ASM_OP
+#define UNALIGNED_OFFSET_ASM_OP(OFFSET) \
+  (NUMBYTES(OFFSET) == 4 \
+   ? UNALIGNED_LONG_ASM_OP \
+   : (NUMBYTES(OFFSET) == 2 ? UNALIGNED_SHORT_ASM_OP : ASM_BYTE_OP))
+#endif
+
+/* Pseudo-op for defining a new section.  */
+#ifndef SECTION_ASM_OP
+#define SECTION_ASM_OP	".section"
+#endif
+
+/* Definitions of defaults for formats and names of various special
+   (artificial) labels which may be generated within this file (when the -g
+   options is used and VMS_DEBUGGING_INFO is in effect.  If necessary, these
+   may be overridden from within the tm.h file, but typically, overriding these
+   defaults is unnecessary.  */
+
+static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
+
+#ifndef TEXT_END_LABEL
+#define TEXT_END_LABEL		"Lvetext"
+#endif
+#ifndef FUNC_BEGIN_LABEL
+#define FUNC_BEGIN_LABEL	"LVFB"
+#endif
+#ifndef FUNC_PROLOG_LABEL
+#define FUNC_PROLOG_LABEL	"LVFP"
+#endif
+#ifndef FUNC_END_LABEL
+#define FUNC_END_LABEL		"LVFE"
+#endif
+#ifndef BLOCK_BEGIN_LABEL
+#define BLOCK_BEGIN_LABEL	"LVBB"
+#endif
+#ifndef BLOCK_END_LABEL
+#define BLOCK_END_LABEL		"LVBE"
+#endif
+#ifndef LINE_CODE_LABEL
+#define LINE_CODE_LABEL		"LVM"
+#endif
+
+#ifndef ASM_OUTPUT_DEBUG_DELTA2
+#define ASM_OUTPUT_DEBUG_DELTA2(FILE,LABEL1,LABEL2)			\
+ do {	fprintf ((FILE), "\t%s\t", UNALIGNED_SHORT_ASM_OP);		\
+	assemble_name (FILE, LABEL1);					\
+	fprintf (FILE, "-");						\
+	assemble_name (FILE, LABEL2);					\
+  } while (0)
+#endif
+
+#ifndef ASM_OUTPUT_DEBUG_DELTA4
+#define ASM_OUTPUT_DEBUG_DELTA4(FILE,LABEL1,LABEL2)			\
+ do {	fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP);		\
+	assemble_name (FILE, LABEL1);					\
+	fprintf (FILE, "-");						\
+	assemble_name (FILE, LABEL2);					\
+  } while (0)
+#endif
+
+#ifndef ASM_OUTPUT_DEBUG_ADDR_DELTA
+#define ASM_OUTPUT_DEBUG_ADDR_DELTA(FILE,LABEL1,LABEL2)			\
+ do {	fprintf ((FILE), "\t%s\t", UNALIGNED_PTR_ASM_OP);		\
+	assemble_name (FILE, LABEL1);					\
+	fprintf (FILE, "-");						\
+	assemble_name (FILE, LABEL2);					\
+  } while (0)
+#endif
+
+#ifndef ASM_OUTPUT_DEBUG_ADDR
+#define ASM_OUTPUT_DEBUG_ADDR(FILE,LABEL)				\
+ do {	fprintf ((FILE), "\t%s\t", UNALIGNED_PTR_ASM_OP);		\
+	assemble_name (FILE, LABEL);					\
+  } while (0)
+#endif
+
+#ifndef ASM_OUTPUT_DEBUG_ADDR_CONST
+#define ASM_OUTPUT_DEBUG_ADDR_CONST(FILE,ADDR)				\
+  fprintf ((FILE), "\t%s\t%s", UNALIGNED_PTR_ASM_OP, (ADDR))
+#endif
+
+#ifndef ASM_OUTPUT_DEBUG_DATA1
+#define ASM_OUTPUT_DEBUG_DATA1(FILE,VALUE) \
+  fprintf ((FILE), "\t%s\t0x%x", ASM_BYTE_OP, (unsigned char) VALUE)
+#endif
+
+#ifndef ASM_OUTPUT_DEBUG_DATA2
+#define ASM_OUTPUT_DEBUG_DATA2(FILE,VALUE) \
+  fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_SHORT_ASM_OP, \
+	   (unsigned short) VALUE)
+#endif
+
+#ifndef ASM_OUTPUT_DEBUG_DATA4
+#define ASM_OUTPUT_DEBUG_DATA4(FILE,VALUE) \
+  fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_INT_ASM_OP, (unsigned long) VALUE)
+#endif
+
+#ifndef ASM_OUTPUT_DEBUG_DATA
+#define ASM_OUTPUT_DEBUG_DATA(FILE,VALUE) \
+  fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_OFFSET_ASM_OP(VALUE), VALUE)
+#endif
+
+#ifndef ASM_OUTPUT_DEBUG_ADDR_DATA
+#define ASM_OUTPUT_DEBUG_ADDR_DATA(FILE,VALUE) \
+  fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_PTR_ASM_OP, \
+	   (unsigned long) VALUE)
+#endif
+
+#ifndef ASM_OUTPUT_DEBUG_DATA8
+#define ASM_OUTPUT_DEBUG_DATA8(FILE,VALUE) \
+  fprintf ((FILE), "\t%s\t0x%llx", UNALIGNED_DOUBLE_INT_ASM_OP, \
+                                 (unsigned long long) VALUE)
+#endif
+
+/* This is similar to the default ASM_OUTPUT_ASCII, except that no trailing
+   newline is produced.  When flag_verbose_asm is asserted, we add commnetary
+   at the end of the line, so we must avoid output of a newline here.  */
+#ifndef ASM_OUTPUT_DEBUG_STRING
+#define ASM_OUTPUT_DEBUG_STRING(FILE,P)	\
+  do {					\
+    register int slen = strlen(P);      \
+    register char *p = (P);  	        \
+    register int i;			\
+    fprintf (FILE, "\t.ascii \"");	\
+    for (i = 0; i < slen; i++)		\
+      {					\
+	  register int c = p[i];	\
+	  if (c == '\"' || c == '\\')	\
+	    putc ('\\', FILE);		\
+	  if (c >= ' ' && c < 0177)	\
+	    putc (c, FILE);		\
+	  else				\
+	    fprintf (FILE, "\\%o", c);	\
+      }					\
+    fprintf (FILE, "\"");		\
+  }					\
+  while (0)
+#endif
+
+/* Convert a reference to the assembler name of a C-level name.  This
+   macro has the same effect as ASM_OUTPUT_LABELREF, but copies to
+   a string rather than writing to a file.  */
+#ifndef ASM_NAME_TO_STRING
+#define ASM_NAME_TO_STRING(STR, NAME) \
+  do {									      \
+      if ((NAME)[0] == '*')						      \
+	strcpy (STR, NAME+1);						      \
+      else								      \
+	strcpy (STR, NAME);                                                   \
+  }                                                                           \
+  while (0)
+#endif
+
+
+/* General utility functions.  */
+
+/* Convert an integer constant expression into assembler syntax.  Addition and
+   subtraction are the only arithmetic that may appear in these expressions.
+   This is an adaptation of output_addr_const in final.c.  Here, the target
+   of the conversion is a string buffer.  We can't use output_addr_const
+   directly, because it writes to a file.  */
+
+static void
+addr_const_to_string (str, x)
+     char *str;
+     rtx x;
+{
+  char buf1[256];
+  char buf2[256];
+
+restart:
+  str[0] = '\0';
+  switch (GET_CODE (x))
+    {
+    case PC:
+      if (flag_pic)
+	strcat (str, ",");
+      else
+	abort ();
+      break;
+
+    case SYMBOL_REF:
+      ASM_NAME_TO_STRING (buf1, XSTR (x, 0));
+      strcat (str, buf1);
+      break;
+
+    case LABEL_REF:
+      ASM_GENERATE_INTERNAL_LABEL (buf1, "L", CODE_LABEL_NUMBER (XEXP (x, 0)));
+      ASM_NAME_TO_STRING (buf2, buf1);
+      strcat (str, buf2);
+      break;
+
+    case CODE_LABEL:
+      ASM_GENERATE_INTERNAL_LABEL (buf1, "L", CODE_LABEL_NUMBER (x));
+      ASM_NAME_TO_STRING (buf2, buf1);
+      strcat (str, buf2);
+      break;
+
+    case CONST_INT:
+      sprintf (buf1, HOST_WIDE_INT_PRINT_DEC, INTVAL (x));
+      strcat (str, buf1);
+      break;
+
+    case CONST:
+      /* This used to output parentheses around the expression, but that does 
+         not work on the 386 (either ATT or BSD assembler).  */
+      addr_const_to_string (buf1, XEXP (x, 0));
+      strcat (str, buf1);
+      break;
+
+    case CONST_DOUBLE:
+      if (GET_MODE (x) == VOIDmode)
+	{
+	  /* We can use %d if the number is one word and positive.  */
+	  if (CONST_DOUBLE_HIGH (x))
+	    sprintf (buf1, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
+		     CONST_DOUBLE_HIGH (x), CONST_DOUBLE_LOW (x));
+	  else if (CONST_DOUBLE_LOW (x) < 0)
+	    sprintf (buf1, HOST_WIDE_INT_PRINT_HEX, CONST_DOUBLE_LOW (x));
+	  else
+	    sprintf (buf1, HOST_WIDE_INT_PRINT_DEC,
+		     CONST_DOUBLE_LOW (x));
+	  strcat (str, buf1);
+	}
+      else
+	/* We can't handle floating point constants; PRINT_OPERAND must
+	   handle them.  */
+	output_operand_lossage ("floating constant misused");
+      break;
+
+    case PLUS:
+      /* Some assemblers need integer constants to appear last (eg masm).  */
+      if (GET_CODE (XEXP (x, 0)) == CONST_INT)
+	{
+	  addr_const_to_string (buf1, XEXP (x, 1));
+	  strcat (str, buf1);
+	  if (INTVAL (XEXP (x, 0)) >= 0)
+	    strcat (str, "+");
+	  addr_const_to_string (buf1, XEXP (x, 0));
+	  strcat (str, buf1);
+	}
+      else
+	{
+	  addr_const_to_string (buf1, XEXP (x, 0));
+	  strcat (str, buf1);
+	  if (INTVAL (XEXP (x, 1)) >= 0)
+	    strcat (str, "+");
+	  addr_const_to_string (buf1, XEXP (x, 1));
+	  strcat (str, buf1);
+	}
+      break;
+
+    case MINUS:
+      /* Avoid outputting things like x-x or x+5-x, since some assemblers
+         can't handle that.  */
+      x = simplify_subtraction (x);
+      if (GET_CODE (x) != MINUS)
+	goto restart;
+
+      addr_const_to_string (buf1, XEXP (x, 0));
+      strcat (str, buf1);
+      strcat (str, "-");
+      if (GET_CODE (XEXP (x, 1)) == CONST_INT
+	  && INTVAL (XEXP (x, 1)) < 0)
+	{
+	  strcat (str, "(");
+	  addr_const_to_string (buf1, XEXP (x, 1));
+	  strcat (str, buf1);
+	  strcat (str, ")");
+	}
+      else
+	{
+	  addr_const_to_string (buf1, XEXP (x, 1));
+	  strcat (str, buf1);
+	}
+      break;
+
+    case ZERO_EXTEND:
+    case SIGN_EXTEND:
+      addr_const_to_string (buf1, XEXP (x, 0));
+      strcat (str, buf1);
+      break;
+
+    default:
+      output_operand_lossage ("invalid expression as operand");
+    }
+}
+
+static int
+write_debug_header (header, comment, dosizeonly)
+     DST_HEADER *header;
+     const char *comment;
+     int dosizeonly;
+{
+  if (dosizeonly)
+    return 4;
+
+  ASM_OUTPUT_DEBUG_DATA2 (asm_out_file,
+			  header->dst__header_length.dst_w_length);
+  if (flag_verbose_asm)
+    fprintf (asm_out_file, "\t%s record length", ASM_COMMENT_START);
+  fputc ('\n', asm_out_file);
+
+  ASM_OUTPUT_DEBUG_DATA2 (asm_out_file,
+			  header->dst__header_type.dst_w_type);
+  if (flag_verbose_asm)
+    fprintf (asm_out_file, "\t%s record type (%s)", ASM_COMMENT_START,
+	     comment);
+
+  fputc ('\n', asm_out_file);
+
+  return 4;
+}
+
+static int
+write_debug_addr (symbol, comment, dosizeonly)
+     char *symbol;
+     const char *comment;
+     int dosizeonly;
+{
+  if (dosizeonly)
+    return PTR_SIZE;
+
+  ASM_OUTPUT_DEBUG_ADDR (asm_out_file, symbol);
+  if (flag_verbose_asm)
+    fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START, comment);
+  fputc ('\n', asm_out_file);
+  
+  return PTR_SIZE;
+}
+
+static int
+write_debug_data1 (data1, comment, dosizeonly)
+     unsigned int data1;
+     const char *comment;
+     int dosizeonly;
+{
+  if (dosizeonly)
+    return 1;
+
+  ASM_OUTPUT_DEBUG_DATA1 (asm_out_file, data1);
+  if (flag_verbose_asm)
+    fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START, comment);
+  fputc ('\n', asm_out_file);
+  
+  return 1;
+}
+
+static int
+write_debug_data2 (data2, comment, dosizeonly)
+     unsigned int data2;
+     const char *comment;
+     int dosizeonly;
+{
+  if (dosizeonly)
+    return 2;
+
+  ASM_OUTPUT_DEBUG_DATA2 (asm_out_file, data2);
+  if (flag_verbose_asm)
+    fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START, comment);
+  fputc ('\n', asm_out_file);
+  
+  return 2;
+}
+
+static int
+write_debug_data4 (data4, comment, dosizeonly)
+     unsigned long data4;
+     const char *comment;
+     int dosizeonly;
+{
+  if (dosizeonly)
+    return 4;
+
+  ASM_OUTPUT_DEBUG_DATA4 (asm_out_file, data4);
+  if (flag_verbose_asm)
+    fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START, comment);
+  fputc ('\n', asm_out_file);
+  
+  return 4;
+}
+
+static int
+write_debug_data8 (data8, comment, dosizeonly)
+     unsigned long long data8;
+     const char *comment;
+     int dosizeonly;
+{
+  if (dosizeonly)
+    return 8;
+
+  ASM_OUTPUT_DEBUG_DATA8 (asm_out_file, data8);
+  if (flag_verbose_asm)
+    fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START, comment);
+  fputc ('\n', asm_out_file);
+  
+  return 8;
+}
+
+static int
+write_debug_delta4 (label1, label2, comment, dosizeonly)
+     char *label1;
+     char *label2;
+     const char *comment;
+     int dosizeonly;
+{
+  if (dosizeonly)
+    return 4;
+
+  ASM_OUTPUT_DEBUG_DELTA4(asm_out_file, label1, label2);
+  if (flag_verbose_asm)
+    fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START, comment);
+  fputc ('\n', asm_out_file);
+  
+  return 4;
+}
+
+static int
+write_debug_string (string, comment, dosizeonly)
+     char *string;
+     const char *comment;
+     int dosizeonly;
+{
+  if (dosizeonly)
+    return strlen (string);
+
+  ASM_OUTPUT_DEBUG_STRING (asm_out_file, string);
+  if (flag_verbose_asm)
+    fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START, comment);
+  fputc ('\n', asm_out_file);
+  
+  return strlen (string);
+}
+
+static int
+write_modbeg (dosizeonly)
+     int dosizeonly;
+{
+
+  DST_MODULE_BEGIN modbeg;
+  DST_MB_TRLR mb_trlr;
+  int i;
+  char *module_name, *m;
+  int modnamelen;
+  int prodnamelen;
+  int totsize = 0;
+
+  /* Assumes primary filename has Unix syntax file spec. */
+  module_name = xstrdup (basename ((char *) primary_filename));
+
+  m = strrchr (module_name, '.');
+  if (m)
+    *m = 0;
+
+  modnamelen = strlen (module_name);
+  for (i = 0; i < modnamelen; i++)
+    module_name[i] = TOUPPER (module_name[i]);
+
+  prodnamelen = strlen (module_producer);
+
+  modbeg.dst_a_modbeg_header.dst__header_length.dst_w_length
+    = DST_K_MODBEG_SIZE + modnamelen + DST_K_MB_TRLR_SIZE + prodnamelen - 1;
+  modbeg.dst_a_modbeg_header.dst__header_type.dst_w_type = DST_K_MODBEG;
+  modbeg.dst_b_modbeg_flags.dst_v_modbeg_hide = 0;
+  modbeg.dst_b_modbeg_flags.dst_v_modbeg_version = 1;
+  modbeg.dst_b_modbeg_flags.dst_v_modbeg_unused = 0;
+  modbeg.dst_b_modbeg_unused = 0;
+  modbeg.dst_l_modbeg_language = module_language;
+  modbeg.dst_w_version_major = DST_K_VERSION_MAJOR;
+  modbeg.dst_w_version_minor = DST_K_VERSION_MINOR;
+  modbeg.dst_b_modbeg_name = strlen (module_name);
+
+  mb_trlr.dst_b_compiler = strlen (module_producer);
+
+  totsize += write_debug_header (&modbeg.dst_a_modbeg_header,
+				 "modbeg", dosizeonly);
+  totsize += write_debug_data1 (*((char *) &modbeg.dst_b_modbeg_flags),
+				"flags", dosizeonly);
+  totsize += write_debug_data1 (modbeg.dst_b_modbeg_unused,
+				"unused", dosizeonly);
+  totsize += write_debug_data4 (modbeg.dst_l_modbeg_language,
+				"language", dosizeonly);
+  totsize += write_debug_data2 (modbeg.dst_w_version_major,
+				"DST major version", dosizeonly);
+  totsize += write_debug_data2 (modbeg.dst_w_version_minor,
+				"DST minor version", dosizeonly);
+  totsize += write_debug_data1 (modbeg.dst_b_modbeg_name,
+				"length of module name", dosizeonly);
+  totsize += write_debug_string (module_name, "module name", dosizeonly);
+  totsize += write_debug_data1 (mb_trlr.dst_b_compiler,
+				"length of compiler name", dosizeonly);
+  totsize += write_debug_string (module_producer, "compiler name", dosizeonly);
+
+  return totsize;
+}
+
+static int
+write_modend (dosizeonly)
+     int dosizeonly;
+{
+  DST_MODULE_END modend;
+  int totsize = 0;
+
+  modend.dst_a_modend_header.dst__header_length.dst_w_length
+   = DST_K_MODEND_SIZE - 1;
+  modend.dst_a_modend_header.dst__header_type.dst_w_type = DST_K_MODEND;
+
+  totsize += write_debug_header (&modend.dst_a_modend_header, "modend",
+				 dosizeonly);
+
+  return totsize;
+}
+
+static int
+write_rtnbeg (rtnnum, dosizeonly)
+     int rtnnum;
+     int dosizeonly;
+{
+  char *rtnname;
+  int rtnnamelen, rtnentrynamelen;
+  char *rtnentryname;
+  int totsize = 0;
+  char label[MAX_ARTIFICIAL_LABEL_BYTES];
+  DST_ROUTINE_BEGIN rtnbeg;
+  DST_PROLOG prolog;
+
+  rtnname = func_table[rtnnum];
+  rtnnamelen = strlen (rtnname);
+  rtnentrynamelen = rtnnamelen + 4; /* "..en" */
+  rtnentryname = (char *) xmalloc (rtnentrynamelen + 1);
+  strcpy (rtnentryname, rtnname);
+  strcat (rtnentryname, "..en");
+
+  if (!strcmp (rtnname, "main"))
+    {
+      DST_HEADER header;
+      const char *go = "TRANSFER$BREAK$GO";
+
+      /* This command isn't documented in DSTRECORDS, so it's made to
+	 look like what DEC C does */
+
+      /* header size - 1st byte + flag byte + STO_LW size
+	 + string count byte + string length */
+      header.dst__header_length.dst_w_length
+        = DST_K_DST_HEADER_SIZE - 1 + 1 + 4 + 1 + strlen (go);
+      header.dst__header_type.dst_w_type = 0x17;
+
+      totsize += write_debug_header (&header, "transfer", dosizeonly);
+
+      /* I think this is a flag byte, but I don't know what this flag means */
+      totsize += write_debug_data1 (0x1, "flags ???", dosizeonly);
+
+      /* Routine Begin PD Address */
+      totsize += write_debug_addr (rtnname, "main procedure descriptor",
+				   dosizeonly);
+      totsize += write_debug_data1 (strlen (go), "length of main_name",
+				    dosizeonly);
+      totsize += write_debug_string ((char *) go, "main name", dosizeonly);
+    }
+
+  /* The header length never includes the length byte */
+  rtnbeg.dst_a_rtnbeg_header.dst__header_length.dst_w_length
+   = DST_K_RTNBEG_SIZE + rtnnamelen - 1;
+  rtnbeg.dst_a_rtnbeg_header.dst__header_type.dst_w_type = DST_K_RTNBEG;
+  rtnbeg.dst_b_rtnbeg_flags.dst_v_rtnbeg_unused = 0;
+  rtnbeg.dst_b_rtnbeg_flags.dst_v_rtnbeg_unalloc = 0;
+  rtnbeg.dst_b_rtnbeg_flags.dst_v_rtnbeg_prototype = 0;
+  rtnbeg.dst_b_rtnbeg_flags.dst_v_rtnbeg_inlined = 0;
+  rtnbeg.dst_b_rtnbeg_flags.dst_v_rtnbeg_no_call = 1;
+  rtnbeg.dst_b_rtnbeg_name = rtnnamelen;
+
+  totsize += write_debug_header (&rtnbeg.dst_a_rtnbeg_header, "rtnbeg",
+				 dosizeonly);
+  totsize += write_debug_data1 (*((char *) &rtnbeg.dst_b_rtnbeg_flags),
+				"flags", dosizeonly);
+
+  /* Routine Begin Address */
+  totsize += write_debug_addr (rtnentryname, "routine entry name", dosizeonly);
+
+  /* Routine Begin PD Address */
+  totsize += write_debug_addr (rtnname, "routine procedure descriptor",
+			       dosizeonly);
+
+  /* Routine Begin Name */
+  totsize += write_debug_data1 (rtnbeg.dst_b_rtnbeg_name,
+				"length of routine name", dosizeonly);
+
+  totsize += write_debug_string (rtnname, "routine name", dosizeonly);
+
+  free (rtnentryname);
+
+  if (debug_info_level > DINFO_LEVEL_TERSE)
+    {
+      prolog.dst_a_prolog_header.dst__header_length.dst_w_length
+	= DST_K_PROLOG_SIZE - 1;
+      prolog.dst_a_prolog_header.dst__header_type.dst_w_type = DST_K_PROLOG;
+
+      totsize += write_debug_header (&prolog.dst_a_prolog_header, "prolog",
+				     dosizeonly);
+
+      ASM_GENERATE_INTERNAL_LABEL (label, FUNC_PROLOG_LABEL, rtnnum);
+      totsize += write_debug_addr (label, "prolog breakpoint addr",
+				   dosizeonly);
+    }
+
+  return totsize;
+}
+
+static int
+write_rtnend (rtnnum, dosizeonly)
+     int rtnnum;
+     int dosizeonly;
+{
+  DST_ROUTINE_END rtnend;
+  char label1[MAX_ARTIFICIAL_LABEL_BYTES];
+  char label2[MAX_ARTIFICIAL_LABEL_BYTES];
+  int totsize;
+
+  totsize = 0;
+
+  rtnend.dst_a_rtnend_header.dst__header_length.dst_w_length
+   = DST_K_RTNEND_SIZE - 1;
+  rtnend.dst_a_rtnend_header.dst__header_type.dst_w_type = DST_K_RTNEND;
+  rtnend.dst_b_rtnend_unused = 0;
+  rtnend.dst_l_rtnend_size = 0; /* Calculated below.  */
+
+  totsize += write_debug_header (&rtnend.dst_a_rtnend_header, "rtnend",
+				 dosizeonly);
+  totsize += write_debug_data1 (rtnend.dst_b_rtnend_unused, "unused",
+				dosizeonly);
+
+  ASM_GENERATE_INTERNAL_LABEL (label1, FUNC_BEGIN_LABEL, rtnnum);
+  ASM_GENERATE_INTERNAL_LABEL (label2, FUNC_END_LABEL, rtnnum);
+  totsize += write_debug_delta4 (label2, label1, "routine size", dosizeonly);
+
+  return totsize;
+}
+
+#define K_DELTA_PC(I) \
+ ((I) < 128 ? -(I) : (I) < 65536 ? DST_K_DELTA_PC_W : DST_K_DELTA_PC_L)
+
+#define K_SET_LINUM(I) \
+ ((I) < 256 ? DST_K_SET_LINUM_B \
+  : (I) < 65536 ? DST_K_SET_LINUM : DST_K_SET_LINUM_L)
+
+#define K_INCR_LINUM(I) \
+ ((I) < 256 ? DST_K_INCR_LINUM \
+  : (I) < 65536 ? DST_K_INCR_LINUM_W : DST_K_INCR_LINUM_L)
+
+static int
+write_pclines (dosizeonly)
+     int dosizeonly;
+{
+  unsigned i;
+  int fn;
+  int ln, lastln;
+  int linestart = 0;
+  int max_line;
+  DST_LINE_NUM_HEADER line_num;
+  DST_PCLINE_COMMANDS pcline;
+  char label[MAX_ARTIFICIAL_LABEL_BYTES];
+  char lastlabel[MAX_ARTIFICIAL_LABEL_BYTES];
+  int totsize = 0;
+  char buff[256];
+
+  max_line = file_info_table[1].max_line;
+  file_info_table[1].listing_line_start = linestart;
+  linestart = linestart + ((max_line / 100000) + 1) * 100000;
+
+  for (i = 2; i < file_info_table_in_use; i++)
+    {
+      max_line = file_info_table[i].max_line;
+      file_info_table[i].listing_line_start = linestart;
+      linestart = linestart + ((max_line / 10000) + 1) * 10000;
+    }
+
+  /* Set starting address to beginning of text section */
+  line_num.dst_a_line_num_header.dst__header_length.dst_w_length = 8;
+  line_num.dst_a_line_num_header.dst__header_type.dst_w_type = DST_K_LINE_NUM;
+  pcline.dst_b_pcline_command = DST_K_SET_ABS_PC;
+
+  totsize += write_debug_header (&line_num.dst_a_line_num_header,
+				 "line_num", dosizeonly);
+  totsize += write_debug_data1 (pcline.dst_b_pcline_command,
+				"line_num (SET ABS PC)", dosizeonly);
+
+  if (dosizeonly)
+    totsize += 4;
+  else
+    {
+      ASM_OUTPUT_DEBUG_ADDR (asm_out_file, TEXT_SECTION_ASM_OP);
+      if (flag_verbose_asm)
+	fprintf (asm_out_file, "\t%s line_num", ASM_COMMENT_START);
+      fputc ('\n', asm_out_file);
+    }
+
+  fn = line_info_table[1].dst_file_num;
+  ln = (file_info_table[fn].listing_line_start
+	+ line_info_table[1].dst_line_num);
+  line_num.dst_a_line_num_header.dst__header_length.dst_w_length = 4 + 4;
+  pcline.dst_b_pcline_command = DST_K_SET_LINUM_L;
+
+  totsize += write_debug_header (&line_num.dst_a_line_num_header,
+				 "line_num", dosizeonly);
+  totsize += write_debug_data1 (pcline.dst_b_pcline_command,
+				"line_num (SET LINUM LONG)", dosizeonly);
+
+  sprintf (buff, "line_num (%d)", ln - 1);
+  totsize += write_debug_data4 (ln - 1, buff, dosizeonly);
+
+  lastln = ln;
+  strcpy (lastlabel, TEXT_SECTION_ASM_OP);
+  for (i = 1; i < line_info_table_in_use; i++)
+    {
+      int extrabytes;
+
+      fn = line_info_table[i].dst_file_num;
+      ln = (file_info_table[fn].listing_line_start
+	    + line_info_table[i].dst_line_num);
+
+      if (ln - lastln > 1)
+	extrabytes = 5; /* NUMBYTES (ln - lastln - 1) + 1; */
+      else if (ln <= lastln)
+	extrabytes = 5; /* NUMBYTES (ln - 1) + 1; */
+      else
+	extrabytes = 0;
+
+      line_num.dst_a_line_num_header.dst__header_length.dst_w_length
+	= 8 + extrabytes;
+
+      totsize += write_debug_header
+	(&line_num.dst_a_line_num_header, "line_num", dosizeonly);
+
+      if (ln - lastln > 1)
+	{
+	  int lndif = ln - lastln - 1;
+
+	  /* K_INCR_LINUM (lndif); */
+	  pcline.dst_b_pcline_command = DST_K_INCR_LINUM_L;
+
+	  totsize += write_debug_data1 (pcline.dst_b_pcline_command,
+					"line_num (INCR LINUM LONG)",
+					dosizeonly);
+
+	  sprintf (buff, "line_num (%d)", lndif);
+	  totsize += write_debug_data4 (lndif, buff, dosizeonly);
+	}
+      else if (ln <= lastln)
+	{
+	  /* K_SET_LINUM (ln-1); */
+	  pcline.dst_b_pcline_command = DST_K_SET_LINUM_L;
+
+	  totsize += write_debug_data1 (pcline.dst_b_pcline_command,
+					"line_num (SET LINUM LONG)",
+					dosizeonly);
+
+	  sprintf (buff, "line_num (%d)", ln - 1);
+	  totsize += write_debug_data4 (ln - 1, buff, dosizeonly);
+	}
+
+      pcline.dst_b_pcline_command = DST_K_DELTA_PC_L;
+
+      totsize += write_debug_data1 (pcline.dst_b_pcline_command,
+				    "line_num (DELTA PC LONG)", dosizeonly);
+
+      ASM_GENERATE_INTERNAL_LABEL (label, LINE_CODE_LABEL, i);
+      totsize += write_debug_delta4 (label, lastlabel, "increment line_num",
+				     dosizeonly);
+
+      lastln = ln;
+      strcpy (lastlabel, label);
+    }
+
+  return totsize;
+}
+
+static int
+write_srccorr (fileid, file_info_entry, dosizeonly)
+     int fileid;
+     dst_file_info_entry file_info_entry;
+     int dosizeonly;
+{
+  int src_command_size;
+  int linesleft = file_info_entry.max_line;
+  int linestart = file_info_entry.listing_line_start;
+  int flen = file_info_entry.flen;
+  int linestodo = 0;
+  DST_SOURCE_CORR src_header;
+  DST_SRC_COMMAND src_command;
+  DST_SRC_COMMAND src_command_sf;
+  DST_SRC_COMMAND src_command_sl;
+  DST_SRC_COMMAND src_command_sr;
+  DST_SRC_COMMAND src_command_dl;
+  DST_SRC_CMDTRLR src_cmdtrlr;
+  char buff[256];
+  int totsize = 0;
+
+  if (fileid == 1)
+    {
+      src_header.dst_a_source_corr_header.dst__header_length.dst_w_length
+	= DST_K_SOURCE_CORR_HEADER_SIZE + 1 - 1;
+      src_header.dst_a_source_corr_header.dst__header_type.dst_w_type
+	= DST_K_SOURCE;
+      src_command.dst_b_src_command = DST_K_SRC_FORMFEED;
+
+      totsize += write_debug_header (&src_header.dst_a_source_corr_header,
+				     "source corr", dosizeonly);
+
+      totsize += write_debug_data1 (src_command.dst_b_src_command,
+				    "source_corr (SRC FORMFEED)",
+				    dosizeonly);
+    }
+
+  src_command_size
+    = DST_K_SRC_COMMAND_SIZE + flen + DST_K_SRC_CMDTRLR_SIZE;
+  src_command.dst_b_src_command = DST_K_SRC_DECLFILE;
+  src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_b_src_df_length
+    = src_command_size - 2;
+  src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_b_src_df_flags = 0;
+  src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_w_src_df_fileid
+    = fileid;
+  src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_q_src_df_rms_cdt
+    = file_info_entry.cdt;
+  src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_l_src_df_rms_ebk
+    = file_info_entry.ebk;
+  src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_w_src_df_rms_ffb
+    = file_info_entry.ffb;
+  src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_b_src_df_rms_rfo
+    = file_info_entry.rfo;
+  src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_b_src_df_filename
+    = file_info_entry.flen;
+
+  src_header.dst_a_source_corr_header.dst__header_length.dst_w_length
+    = DST_K_SOURCE_CORR_HEADER_SIZE + src_command_size - 1;
+  src_header.dst_a_source_corr_header.dst__header_type.dst_w_type
+    = DST_K_SOURCE;
+
+  src_cmdtrlr.dst_b_src_df_libmodname = 0;
+  
+  totsize += write_debug_header (&src_header.dst_a_source_corr_header,
+				 "source corr", dosizeonly);
+  totsize += write_debug_data1 (src_command.dst_b_src_command,
+				"source_corr (DECL SRC FILE)", dosizeonly);
+  totsize += write_debug_data1
+    (src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_b_src_df_length,
+     "source_corr (length)", dosizeonly);
+
+  totsize += write_debug_data1
+    (src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_b_src_df_flags,
+     "source_corr (flags)", dosizeonly);
+
+  totsize += write_debug_data2
+    (src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_w_src_df_fileid,
+     "source_corr (fileid)", dosizeonly);
+
+  totsize += write_debug_data8
+    (src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_q_src_df_rms_cdt,
+     "source_corr (creation date)", dosizeonly);
+  
+  totsize += write_debug_data4
+    (src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_l_src_df_rms_ebk,
+     "source_corr (EOF block number)", dosizeonly);
+
+  totsize += write_debug_data2
+    (src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_w_src_df_rms_ffb,
+     "source_corr (first free byte)", dosizeonly);
+
+  totsize += write_debug_data1
+    (src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_b_src_df_rms_rfo,
+     "source_corr (record and file organization)", dosizeonly);
+
+  totsize += write_debug_data1
+    (src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_b_src_df_filename,
+     "source_corr (filename length)", dosizeonly);
+
+  totsize += write_debug_string (file_info_entry.file_name,
+				 "source file name", dosizeonly);
+  totsize += write_debug_data1 (src_cmdtrlr.dst_b_src_df_libmodname,
+				"source_corr (libmodname)", dosizeonly);
+
+  src_command_sf.dst_b_src_command = DST_K_SRC_SETFILE;
+  src_command_sf.dst_a_src_cmd_fields.dst_w_src_unsword = fileid;
+
+  src_command_sr.dst_b_src_command = DST_K_SRC_SETREC_W;
+  src_command_sr.dst_a_src_cmd_fields.dst_w_src_unsword = 1;
+
+  src_command_sl.dst_b_src_command = DST_K_SRC_SETLNUM_L;
+  src_command_sl.dst_a_src_cmd_fields.dst_l_src_unslong = linestart + 1;
+
+  src_command_dl.dst_b_src_command = DST_K_SRC_DEFLINES_W;
+
+  if (linesleft > 65534)
+    linesleft = linesleft - 65534, linestodo = 65534;
+  else
+    linestodo = linesleft, linesleft = 0;
+
+  src_command_dl.dst_a_src_cmd_fields.dst_w_src_unsword = linestodo;
+
+  src_header.dst_a_source_corr_header.dst__header_length.dst_w_length
+    = DST_K_SOURCE_CORR_HEADER_SIZE + 3 + 3 + 5 + 3 - 1;
+  src_header.dst_a_source_corr_header.dst__header_type.dst_w_type
+    = DST_K_SOURCE;
+
+  totsize += write_debug_header (&src_header.dst_a_source_corr_header,
+				 "source corr", dosizeonly);
+
+  totsize += write_debug_data1 (src_command_sf.dst_b_src_command,
+				"source_corr (src setfile)", dosizeonly);
+
+  totsize += write_debug_data2
+    (src_command_sf.dst_a_src_cmd_fields.dst_w_src_unsword,
+     "source_corr (fileid)", dosizeonly);
+
+  totsize += write_debug_data1 (src_command_sr.dst_b_src_command,
+				"source_corr (setrec)", dosizeonly);
+
+  totsize += write_debug_data2
+    (src_command_sr.dst_a_src_cmd_fields.dst_w_src_unsword,
+     "source_corr (recnum)", dosizeonly);
+
+  totsize += write_debug_data1 (src_command_sl.dst_b_src_command,
+				"source_corr (setlnum)", dosizeonly);
+
+  totsize += write_debug_data4
+    (src_command_sl.dst_a_src_cmd_fields.dst_l_src_unslong,
+     "source_corr (linenum)", dosizeonly);
+
+  totsize += write_debug_data1 (src_command_dl.dst_b_src_command,
+				"source_corr (deflines)", dosizeonly);
+
+  sprintf (buff, "source_corr (%d)",
+	   src_command_dl.dst_a_src_cmd_fields.dst_w_src_unsword);
+  totsize += write_debug_data2
+    (src_command_dl.dst_a_src_cmd_fields.dst_w_src_unsword, buff, dosizeonly);
+
+  while (linesleft > 0)
+    {
+      src_header.dst_a_source_corr_header.dst__header_length.dst_w_length
+	= DST_K_SOURCE_CORR_HEADER_SIZE + 3 - 1;
+      src_header.dst_a_source_corr_header.dst__header_type.dst_w_type
+	= DST_K_SOURCE;
+      src_command_dl.dst_b_src_command = DST_K_SRC_DEFLINES_W;
+
+      if (linesleft > 65534)
+	linesleft = linesleft - 65534, linestodo = 65534;
+      else
+	linestodo = linesleft, linesleft = 0;
+
+      src_command_dl.dst_a_src_cmd_fields.dst_w_src_unsword = linestodo;
+
+      totsize += write_debug_header (&src_header.dst_a_source_corr_header,
+				     "source corr", dosizeonly);
+      totsize += write_debug_data1 (src_command_dl.dst_b_src_command,
+				    "source_corr (deflines)", dosizeonly);
+      sprintf (buff, "source_corr (%d)",
+	       src_command_dl.dst_a_src_cmd_fields.dst_w_src_unsword);
+      totsize += write_debug_data2
+	(src_command_dl.dst_a_src_cmd_fields.dst_w_src_unsword,
+	 buff, dosizeonly);
+    }
+
+  return totsize;
+}
+
+static int
+write_srccorrs (dosizeonly)
+     int dosizeonly;
+{
+  unsigned int i;
+  int totsize = 0;
+
+  for (i = 1; i < file_info_table_in_use; i++)
+    totsize += write_srccorr (i, file_info_table[i], dosizeonly);
+
+  return totsize;
+}     
+
+
+/* Output a marker (i.e. a label) for the beginning of a function, before
+   the prologue.  */
+
+static void
+vmsdbgout_begin_prologue (line, file)
+     unsigned int line;
+     const char *file;
+{
+  char label[MAX_ARTIFICIAL_LABEL_BYTES];
+
+  if (write_symbols == VMS_AND_DWARF2_DEBUG)
+    (*dwarf2_debug_hooks.begin_prologue) (line, file);
+
+  if (debug_info_level > DINFO_LEVEL_NONE)
+    {
+      current_funcdef_number++;
+      ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
+				   current_funcdef_number);
+      ASM_OUTPUT_LABEL (asm_out_file, label);
+    }
+}
+
+/* Output a marker (i.e. a label) for the beginning of a function, after
+   the prologue.  */
+
+void
+vmsdbgout_after_prologue ()
+{
+  char label[MAX_ARTIFICIAL_LABEL_BYTES];
+
+  if (debug_info_level > DINFO_LEVEL_TERSE)
+    {
+      ASM_GENERATE_INTERNAL_LABEL (label, FUNC_PROLOG_LABEL,
+				   current_funcdef_number);
+      ASM_OUTPUT_LABEL (asm_out_file, label);
+    }
+}
+
+/* Output a marker (i.e. a label) for the absolute end of the generated code
+   for a function definition.  This gets called *after* the epilogue code has
+   been generated.  */
+
+static void
+vmsdbgout_end_epilogue ()
+{
+  char label[MAX_ARTIFICIAL_LABEL_BYTES];
+
+  if (write_symbols == VMS_AND_DWARF2_DEBUG)
+    (*dwarf2_debug_hooks.end_epilogue) ();
+
+  if (debug_info_level > DINFO_LEVEL_NONE)
+    {
+      /* Output a label to mark the endpoint of the code generated for this
+         function.        */
+      ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
+				   current_funcdef_number);
+      ASM_OUTPUT_LABEL (asm_out_file, label);
+    }
+}
+
+/* Output a marker (i.e. a label) for the beginning of the generated code for
+   a lexical block.  */
+
+static void
+vmsdbgout_begin_block (line, blocknum)
+     register unsigned line;
+     register unsigned blocknum;
+{
+  if (write_symbols == VMS_AND_DWARF2_DEBUG)
+    (*dwarf2_debug_hooks.begin_block) (line, blocknum);
+
+  if (debug_info_level > DINFO_LEVEL_TERSE)
+    ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
+}
+
+/* Output a marker (i.e. a label) for the end of the generated code for a
+   lexical block.  */
+
+static void
+vmsdbgout_end_block (line, blocknum)
+     register unsigned line;
+     register unsigned blocknum;
+{
+  if (write_symbols == VMS_AND_DWARF2_DEBUG)
+    (*dwarf2_debug_hooks.end_block) (line, blocknum);
+
+  if (debug_info_level > DINFO_LEVEL_TERSE)
+    ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
+}
+
+static bool
+vmsdbgout_ignore_block (block)
+     tree block;
+{
+  bool retval = 0;
+
+  if (write_symbols == VMS_AND_DWARF2_DEBUG)
+    retval = (*dwarf2_debug_hooks.ignore_block) (block);
+
+  return retval;
+}
+
+static void
+vmsdbgout_begin_function (decl)
+     tree decl;
+{
+  const char *name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
+
+  if (write_symbols == VMS_AND_DWARF2_DEBUG)
+    (*dwarf2_debug_hooks.begin_function) (decl);
+
+  if (func_table_in_use == func_table_allocated)
+    {
+      func_table_allocated += FUNC_TABLE_INCREMENT;
+      func_table = (char **) xrealloc (func_table,
+				       func_table_allocated * sizeof (char *));
+    }
+
+  /* Add the new entry to the end of the function name table.  */
+  func_table[func_table_in_use++] = xstrdup (name);
+}
+
+static char fullname_buff [4096];
+
+static char *
+full_name (filename)
+     const char *filename;
+{
+#ifdef VMS
+  FILE *fp = fopen (filename, "r");
+
+  fgetname (fp, fullname_buff, 1);
+  fclose (fp);
+#else
+  getcwd (fullname_buff, sizeof (fullname_buff));
+
+  strcat (fullname_buff, "/");
+  strcat (fullname_buff, filename);
+
+  /* ??? Insert hairy code here to translate Unix style file specification
+     to VMS style.  */
+#endif
+
+  return fullname_buff;
+}
+
+/* Lookup a filename (in the list of filenames that we know about here in
+   vmsdbgout.c) and return its "index".  The index of each (known) filename is
+   just a unique number which is associated with only that one filename.  We
+   need such numbers for the sake of generating labels (in the .debug_sfnames
+   section) and references to those files numbers (in the .debug_srcinfo
+   and.debug_macinfo sections).  If the filename given as an argument is not
+   found in our current list, add it to the list and assign it the next
+   available unique index number.  In order to speed up searches, we remember
+   the index of the filename was looked up last.  This handles the majority of
+   all searches.  */
+
+static unsigned int
+lookup_filename (file_name)
+     const char *file_name;
+{
+  static unsigned int last_file_lookup_index = 0;
+  register char *fn;
+  register unsigned i;
+  char *fnam;
+  long long cdt;
+  long ebk;
+  short ffb;
+  char rfo;
+  char flen;
+  struct stat statbuf;
+
+  if (stat (file_name, &statbuf) == 0)
+    {
+      cdt = 10000000 * (statbuf.st_ctime + vms_epoch_offset);
+      ebk = statbuf.st_size / 512 + 1;
+      ffb = statbuf.st_size - ((statbuf.st_size / 512) * 512);
+#ifdef VMS
+      rfo = statbuf.st_fab_rfm;
+#else
+      /* Assume stream LF type file */
+      rfo = 2;
+#endif
+      fnam = full_name (file_name);
+      flen = strlen (fnam);
+    }
+  else
+    {
+      cdt = 0;
+      ebk = 0;
+      ffb = 0;
+      rfo = 0;
+      fnam = (char *) 0;
+      flen = 0;
+    }
+
+  /* Check to see if the file name that was searched on the previous call
+     matches this file name. If so, return the index.  */
+  if (last_file_lookup_index != 0)
+    {
+      fn = file_info_table[last_file_lookup_index].file_name;
+      if (strcmp (fnam, fn) == 0)
+	return last_file_lookup_index;
+    }
+
+  /* Didn't match the previous lookup, search the table */
+  for (i = 1; i < file_info_table_in_use; ++i)
+    {
+      fn = file_info_table[i].file_name;
+      if (strcmp (fnam, fn) == 0)
+	{
+	  last_file_lookup_index = i;
+	  return i;
+	}
+    }
+
+  /* Prepare to add a new table entry by making sure there is enough space in 
+     the table to do so.  If not, expand the current table.  */
+  if (file_info_table_in_use == file_info_table_allocated)
+    {
+
+      file_info_table_allocated += FILE_TABLE_INCREMENT;
+      file_info_table
+	= (dst_file_info_ref) xrealloc (file_info_table,
+					(file_info_table_allocated
+					 * sizeof (dst_file_info_entry)));
+    }
+
+  /* Add the new entry to the end of the filename table.  */
+  file_info_table[file_info_table_in_use].file_name = xstrdup (fnam);
+  file_info_table[file_info_table_in_use].max_line = 0;
+  file_info_table[file_info_table_in_use].cdt = cdt;
+  file_info_table[file_info_table_in_use].ebk = ebk;
+  file_info_table[file_info_table_in_use].ffb = ffb;
+  file_info_table[file_info_table_in_use].rfo = rfo;
+  file_info_table[file_info_table_in_use].flen = flen;
+
+  last_file_lookup_index = file_info_table_in_use++;
+  return last_file_lookup_index;
+}
+
+/* Output a label to mark the beginning of a source code line entry
+   and record information relating to this source line, in
+   'line_info_table' for later output of the .debug_line section.  */
+
+static void
+vmsdbgout_source_line (line, filename)
+     register unsigned line;
+     register const char *filename;
+{
+  if (write_symbols == VMS_AND_DWARF2_DEBUG)
+    (*dwarf2_debug_hooks.source_line) (line, filename);
+
+  if (debug_info_level >= DINFO_LEVEL_TERSE)
+    {
+      dst_line_info_ref line_info;
+
+      ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, LINE_CODE_LABEL,
+				 line_info_table_in_use);
+
+      /* Expand the line info table if necessary.  */
+      if (line_info_table_in_use == line_info_table_allocated)
+	{
+	  line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
+	  line_info_table
+	    = (dst_line_info_ref) xrealloc (line_info_table,
+					    (line_info_table_allocated
+					     * sizeof (dst_line_info_entry)));
+	  }
+
+      /* Add the new entry at the end of the line_info_table.  */
+      line_info = &line_info_table[line_info_table_in_use++];
+      line_info->dst_file_num = lookup_filename (filename);
+      line_info->dst_line_num = line;
+      if (line > file_info_table[line_info->dst_file_num].max_line)
+	file_info_table[line_info->dst_file_num].max_line = line;
+    }
+}
+
+/* Record the beginning of a new source file, for later output.
+   At present, unimplemented.  */
+
+static void
+vmsdbgout_start_source_file (lineno, filename)
+     unsigned int lineno;
+     const char *filename;
+{
+  if (write_symbols == VMS_AND_DWARF2_DEBUG)
+    (*dwarf2_debug_hooks.start_source_file) (lineno, filename);
+}
+
+/* Record the end of a source file, for later output.
+   At present, unimplemented.  */
+
+static void
+vmsdbgout_end_source_file (lineno)
+     unsigned int lineno ATTRIBUTE_UNUSED;
+{
+  if (write_symbols == VMS_AND_DWARF2_DEBUG)
+    (*dwarf2_debug_hooks.end_source_file) (lineno);
+}
+
+/* Set up for Debug output at the start of compilation.  */
+
+static void
+vmsdbgout_init (main_input_filename)
+     const char *main_input_filename;
+{
+  const char *language_string = lang_hooks.name;
+
+  if (write_symbols == VMS_AND_DWARF2_DEBUG)
+    (*dwarf2_debug_hooks.init) (main_input_filename);
+
+  if (debug_info_level == DINFO_LEVEL_NONE)
+    return;
+
+  /* Remember the name of the primary input file.  */
+  primary_filename = main_input_filename;
+
+  /* Allocate the initial hunk of the file_info_table.  */
+  file_info_table
+    = (dst_file_info_ref) xcalloc (FILE_TABLE_INCREMENT,
+				   sizeof (dst_file_info_entry));
+  file_info_table_allocated = FILE_TABLE_INCREMENT;
+
+  /* Skip the first entry - file numbers begin at 1 */
+  file_info_table_in_use = 1;
+
+  func_table = (char **) xcalloc (FUNC_TABLE_INCREMENT, sizeof (char *));
+  func_table_allocated = FUNC_TABLE_INCREMENT;
+  func_table_in_use = 1;
+
+  /* Allocate the initial hunk of the line_info_table.  */
+  line_info_table
+    = (dst_line_info_ref) xcalloc (LINE_INFO_TABLE_INCREMENT,
+				   sizeof (dst_line_info_entry));
+  line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
+  /* zero-th entry is allocated, but unused */
+  line_info_table_in_use = 1;
+
+  lookup_filename (primary_filename);
+
+  if (!strcmp (language_string, "GNU C"))
+    module_language = DST_K_C;
+  else if (!strcmp (language_string, "GNU C++"))
+    module_language = DST_K_CXX;
+  else if (!strcmp (language_string, "GNU Ada"))
+    module_language = DST_K_ADA;
+  else if (!strcmp (language_string, "GNU F77"))
+    module_language = DST_K_FORTRAN;
+  else
+    module_language = DST_K_UNKNOWN;
+
+  module_producer
+    = (char *) xmalloc (strlen (language_string) + 1
+			+ strlen (version_string + 1));
+  sprintf (module_producer, "%s %s", language_string, version_string);
+
+  ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
+
+}
+
+static void
+vmsdbgout_define (lineno, buffer)
+     unsigned int lineno;
+     const char *buffer;
+{
+  if (write_symbols == VMS_AND_DWARF2_DEBUG)
+    (*dwarf2_debug_hooks.define) (lineno, buffer);
+}
+
+static void
+vmsdbgout_undef (lineno, buffer)
+     unsigned int lineno;
+     const char *buffer;
+{
+  if (write_symbols == VMS_AND_DWARF2_DEBUG)
+    (*dwarf2_debug_hooks.undef) (lineno, buffer);
+}
+
+static void
+vmsdbgout_decl (decl)
+     tree decl;
+{
+  if (write_symbols == VMS_AND_DWARF2_DEBUG)
+    (*dwarf2_debug_hooks.function_decl) (decl);
+}
+
+static void
+vmsdbgout_global_decl (decl)
+     tree decl;
+{
+  if (write_symbols == VMS_AND_DWARF2_DEBUG)
+    (*dwarf2_debug_hooks.global_decl) (decl);
+}
+
+static void
+vmsdbgout_abstract_function (decl)
+     tree decl;
+{
+  if (write_symbols == VMS_AND_DWARF2_DEBUG)
+    (*dwarf2_debug_hooks.outlining_inline_function) (decl);
+}
+
+/* Output stuff that Debug requires at the end of every file,
+   and generate the VMS Debug debugging info.  */
+
+static void
+vmsdbgout_finish (input_filename)
+     const char *input_filename ATTRIBUTE_UNUSED;
+{
+  unsigned int i;
+  int totsize;
+
+  if (write_symbols == VMS_AND_DWARF2_DEBUG)
+    (*dwarf2_debug_hooks.finish) (input_filename);
+
+  if (debug_info_level == DINFO_LEVEL_NONE)
+    return;
+
+  /* Output a terminator label for the .text section.  */
+  text_section ();
+  ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, TEXT_END_LABEL, 0);
+
+  /* Output debugging information.
+     Warning! Do not change the name of the .vmsdebug section without
+     changing it in the assembler also. */
+  named_section (NULL_TREE, ".vmsdebug", 0);
+  ASM_OUTPUT_ALIGN (asm_out_file, 0);
+
+  totsize = write_modbeg (1);
+  for (i = 1; i < func_table_in_use; i++)
+    {
+      totsize += write_rtnbeg (i, 1);
+      totsize += write_rtnend (i, 1);
+    }
+  totsize += write_pclines (1);
+
+  write_modbeg (0);
+  for (i = 1; i < func_table_in_use; i++)
+    {
+      write_rtnbeg (i, 0);
+      write_rtnend (i, 0);
+    }
+  write_pclines (0);
+
+  if (debug_info_level > DINFO_LEVEL_TERSE)
+    {
+      totsize = write_srccorrs (1);
+      write_srccorrs (0);
+    }
+
+  totsize = write_modend (1);
+  write_modend (0);
+}
+#endif /* VMS_DEBUGGING_INFO */