FreeBSD uses unchanged versions of this files.

1 files changed, 1414 insertions, 1127 deletions

diff --git a/contrib/gcc/dbxout.c b/contrib/gcc/dbxout.c
index b12ea5c..5732427 100644
--- a/contrib/gcc/dbxout.c
+++ b/contrib/gcc/dbxout.c
@@ -1,6 +1,7 @@
 /* Output dbx-format symbol table information from GNU compiler.
    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
-   1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+   Free Software Foundation, Inc.
 
 This file is part of GCC.
 
@@ -16,8 +17,8 @@ for more details.
 
 You should have received a copy of the GNU General Public License
 along with GCC; see the file COPYING.  If not, write to the Free
-Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA.  */
+Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA.  */
 
 
 /* Output dbx-format symbol table data.
@@ -79,7 +80,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "regs.h"
 #include "insn-config.h"
 #include "reload.h"
-#include "output.h" /* ASM_OUTPUT_SOURCE_LINE may refer to sdb functions.  */
+#include "output.h"
 #include "dbxout.h"
 #include "toplev.h"
 #include "tm_p.h"
@@ -88,28 +89,36 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "function.h"
 #include "target.h"
 #include "langhooks.h"
+#include "obstack.h"
+#include "expr.h"
 
 #ifdef XCOFF_DEBUGGING_INFO
 #include "xcoffout.h"
 #endif
 
-#undef DBXOUT_DECR_NESTING
 #define DBXOUT_DECR_NESTING \
   if (--debug_nesting == 0 && symbol_queue_index > 0) \
     { emit_pending_bincls_if_required (); debug_flush_symbol_queue (); }
 
-#undef DBXOUT_DECR_NESTING_AND_RETURN
 #define DBXOUT_DECR_NESTING_AND_RETURN(x) \
   do {--debug_nesting; return (x);} while (0)
 
 #ifndef ASM_STABS_OP
-#define ASM_STABS_OP "\t.stabs\t"
+# ifdef XCOFF_DEBUGGING_INFO
+#  define ASM_STABS_OP "\t.stabx\t"
+# else
+#  define ASM_STABS_OP "\t.stabs\t"
+# endif
 #endif
 
 #ifndef ASM_STABN_OP
 #define ASM_STABN_OP "\t.stabn\t"
 #endif
 
+#ifndef ASM_STABD_OP
+#define ASM_STABD_OP "\t.stabd\t"
+#endif
+
 #ifndef DBX_TYPE_DECL_STABS_CODE
 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
 #endif
@@ -126,24 +135,32 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #define DBX_REGPARM_STABS_LETTER 'P'
 #endif
 
-/* This is used for parameters passed by invisible reference in a register.  */
-#ifndef GDB_INV_REF_REGPARM_STABS_LETTER
-#define GDB_INV_REF_REGPARM_STABS_LETTER 'a'
+#ifndef NO_DBX_FUNCTION_END
+#define NO_DBX_FUNCTION_END 0
 #endif
 
-#ifndef DBX_MEMPARM_STABS_LETTER
-#define DBX_MEMPARM_STABS_LETTER 'p'
+#ifndef NO_DBX_BNSYM_ENSYM
+#define NO_DBX_BNSYM_ENSYM 0
 #endif
 
-#ifndef FILE_NAME_JOINER
-#define FILE_NAME_JOINER "/"
+#ifndef NO_DBX_MAIN_SOURCE_DIRECTORY
+#define NO_DBX_MAIN_SOURCE_DIRECTORY 0
+#endif
+
+#ifndef DBX_BLOCKS_FUNCTION_RELATIVE
+#define DBX_BLOCKS_FUNCTION_RELATIVE 0
+#endif
+
+#ifndef DBX_LINES_FUNCTION_RELATIVE
+#define DBX_LINES_FUNCTION_RELATIVE 0
+#endif
+
+#ifndef DBX_CONTIN_LENGTH
+#define DBX_CONTIN_LENGTH 80
 #endif
 
-/* GDB needs to know that the stabs were generated by GCC.  We emit an
-   N_OPT stab at the beginning of the source file to indicate this.
-   The string is historical, and different on a very few targets.  */
-#ifndef STABS_GCC_MARKER
-#define STABS_GCC_MARKER "gcc2_compiled."
+#ifndef DBX_CONTIN_CHAR
+#define DBX_CONTIN_CHAR '\\'
 #endif
 
 enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED};
@@ -179,6 +196,12 @@ static GTY(()) int typevec_len;
 
 static GTY(()) int next_type_number;
 
+/* The C front end may call dbxout_symbol before dbxout_init runs.
+   We save all such decls in this list and output them when we get
+   to dbxout_init.  */
+
+static GTY(()) tree preinit_symbols;
+
 enum binclstatus {BINCL_NOT_REQUIRED, BINCL_PENDING, BINCL_PROCESSED};
 
 /* When using N_BINCL in dbx output, each type number is actually a
@@ -220,13 +243,6 @@ static GTY(()) int scope_labelno;
 
 static GTY(()) int dbxout_source_line_counter;
 
-/* Nonzero if we have actually used any of the GDB extensions
-   to the debugging format.  The idea is that we use them for the
-   first time only if there's a strong reason, but once we have done that,
-   we use them whenever convenient.  */
-
-static GTY(()) int have_used_extensions = 0;
-
 /* Number for the next N_SOL filename stabs label.  The number 0 is reserved
    for the N_SO filename stabs label.  */
 
@@ -253,12 +269,8 @@ static int pending_bincls = 0;
 /* The original input file name.  */
 static const char *base_input_file;
 
-/* Current working directory.  */
-
-static const char *cwd;
-
 #ifdef DEBUG_SYMS_TEXT
-#define FORCE_TEXT function_section (current_function_decl);
+#define FORCE_TEXT switch_to_section (current_function_section ())
 #else
 #define FORCE_TEXT
 #endif
@@ -270,7 +282,7 @@ static const char *cwd;
 /* 1 if PARM is passed to this function in memory.  */
 
 #define PARM_PASSED_IN_MEMORY(PARM) \
- (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
+ (MEM_P (DECL_INCOMING_RTL (PARM)))
 
 /* A C expression for the integer offset value of an automatic variable
    (N_LSYM) having address X (an RTX).  */
@@ -285,46 +297,11 @@ static const char *cwd;
 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
 #endif
 
-/* Stream for writing to assembler file.  */
-
-static FILE *asmfile;
-
-/* These variables are for dbxout_symbol to communicate to
-   dbxout_finish_symbol.
-   current_sym_code is the symbol-type-code, a symbol N_... define in stab.h.
-   current_sym_value and current_sym_addr are two ways to address the
-   value to store in the symtab entry.
-   current_sym_addr if nonzero represents the value as an rtx.
-   If that is zero, current_sym_value is used.  This is used
-   when the value is an offset (such as for auto variables,
-   register variables and parms).  */
-
-static STAB_CODE_TYPE current_sym_code;
-static int current_sym_value;
-static rtx current_sym_addr;
-
-/* Number of chars of symbol-description generated so far for the
-   current symbol.  Used by CHARS and CONTIN.  */
-
-static int current_sym_nchars;
-
-/* Report having output N chars of the current symbol-description.  */
-
-#define CHARS(N) (current_sym_nchars += (N))
-
-/* Break the current symbol-description, generating a continuation,
-   if it has become long.  */
-
-#ifndef DBX_CONTIN_LENGTH
-#define DBX_CONTIN_LENGTH 80
-#endif
-
-#if DBX_CONTIN_LENGTH > 0
-#define CONTIN  \
-  do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0)
-#else
-#define CONTIN do { } while (0)
-#endif
+/* This obstack holds the stab string currently being constructed.  We
+   build it up here, then write it out, so we can split long lines up
+   properly (see dbxout_finish_complex_stabs).  */
+static struct obstack stabstr_ob;
+static size_t stabstr_last_contin_point;
 
 #ifdef DBX_USE_BINCL
 static void emit_bincl_stab             (const char *c);
@@ -333,40 +310,35 @@ static void emit_pending_bincls         (void);
 static inline void emit_pending_bincls_if_required (void);
 
 static void dbxout_init (const char *);
+ 
 static void dbxout_finish (const char *);
 static void dbxout_start_source_file (unsigned, const char *);
 static void dbxout_end_source_file (unsigned);
 static void dbxout_typedefs (tree);
 static void dbxout_type_index (tree);
-#if DBX_CONTIN_LENGTH > 0
-static void dbxout_continue (void);
-#endif
 static void dbxout_args (tree);
 static void dbxout_type_fields (tree);
-static void dbxout_type_method_1 (tree, const char *);
+static void dbxout_type_method_1 (tree);
 static void dbxout_type_methods (tree);
 static void dbxout_range_type (tree);
 static void dbxout_type (tree, int);
 static bool print_int_cst_bounds_in_octal_p (tree);
-static void print_int_cst_octal (tree);
-static void print_octal (unsigned HOST_WIDE_INT, int);
-static void print_wide_int (HOST_WIDE_INT);
 static void dbxout_type_name (tree);
 static void dbxout_class_name_qualifiers (tree);
 static int dbxout_symbol_location (tree, tree, const char *, rtx);
 static void dbxout_symbol_name (tree, const char *, int);
-static void dbxout_prepare_symbol (tree);
-static void dbxout_finish_symbol (tree);
 static void dbxout_block (tree, int, tree);
 static void dbxout_global_decl (tree);
+static void dbxout_type_decl (tree, int);
 static void dbxout_handle_pch (unsigned);
 
 /* The debug hooks structure.  */
 #if defined (DBX_DEBUGGING_INFO)
 
 static void dbxout_source_line (unsigned int, const char *);
-static void dbxout_source_file (FILE *, const char *);
-static void dbxout_function_end (void);
+static void dbxout_begin_prologue (unsigned int, const char *);
+static void dbxout_source_file (const char *);
+static void dbxout_function_end (tree);
 static void dbxout_begin_function (tree);
 static void dbxout_begin_block (unsigned, unsigned);
 static void dbxout_end_block (unsigned, unsigned);
@@ -382,23 +354,28 @@ const struct gcc_debug_hooks dbx_debug_hooks =
   dbxout_end_source_file,
   dbxout_begin_block,
   dbxout_end_block,
-  debug_true_tree,		/* ignore_block */
-  dbxout_source_line,		/* source_line */
-  dbxout_source_line,		/* begin_prologue: just output line info */
-  debug_nothing_int_charstar,	/* end_prologue */
-  debug_nothing_int_charstar,	/* end_epilogue */
+  debug_true_tree,		         /* ignore_block */
+  dbxout_source_line,		         /* source_line */
+  dbxout_begin_prologue,	         /* begin_prologue */
+  debug_nothing_int_charstar,	         /* end_prologue */
+  debug_nothing_int_charstar,	         /* end_epilogue */
 #ifdef DBX_FUNCTION_FIRST
   dbxout_begin_function,
 #else
-  debug_nothing_tree,		/* begin_function */
+  debug_nothing_tree,		         /* begin_function */
 #endif
-  debug_nothing_int,		/* end_function */
+  debug_nothing_int,		         /* end_function */
   dbxout_function_decl,
-  dbxout_global_decl,		/* global_decl */
-  debug_nothing_tree,		/* deferred_inline_function */
-  debug_nothing_tree,		/* outlining_inline_function */
-  debug_nothing_rtx,		/* label */
-  dbxout_handle_pch		/* handle_pch */
+  dbxout_global_decl,		         /* global_decl */
+  dbxout_type_decl,			 /* type_decl */
+  debug_nothing_tree_tree,               /* imported_module_or_decl */
+  debug_nothing_tree,		         /* deferred_inline_function */
+  debug_nothing_tree,		         /* outlining_inline_function */
+  debug_nothing_rtx,		         /* label */
+  dbxout_handle_pch,		         /* handle_pch */
+  debug_nothing_rtx,		         /* var_location */
+  debug_nothing_void,                    /* switch_text_section */
+  0                                      /* start_end_main_source_file */
 };
 #endif /* DBX_DEBUGGING_INFO  */
 
@@ -413,61 +390,591 @@ const struct gcc_debug_hooks xcoff_debug_hooks =
   dbxout_end_source_file,
   xcoffout_begin_block,
   xcoffout_end_block,
-  debug_true_tree,		/* ignore_block */
+  debug_true_tree,		         /* ignore_block */
   xcoffout_source_line,
-  xcoffout_begin_prologue,	/* begin_prologue */
-  debug_nothing_int_charstar,	/* end_prologue */
+  xcoffout_begin_prologue,	         /* begin_prologue */
+  debug_nothing_int_charstar,	         /* end_prologue */
   xcoffout_end_epilogue,
-  debug_nothing_tree,		/* begin_function */
+  debug_nothing_tree,		         /* begin_function */
   xcoffout_end_function,
-  debug_nothing_tree,		/* function_decl */
-  dbxout_global_decl,		/* global_decl */
-  debug_nothing_tree,		/* deferred_inline_function */
-  debug_nothing_tree,		/* outlining_inline_function */
-  debug_nothing_rtx,		/* label */
-  dbxout_handle_pch		/* handle_pch */
+  debug_nothing_tree,		         /* function_decl */
+  dbxout_global_decl,		         /* global_decl */
+  dbxout_type_decl,			 /* type_decl */
+  debug_nothing_tree_tree,               /* imported_module_or_decl */
+  debug_nothing_tree,		         /* deferred_inline_function */
+  debug_nothing_tree,		         /* outlining_inline_function */
+  debug_nothing_rtx,		         /* label */
+  dbxout_handle_pch,		         /* handle_pch */
+  debug_nothing_rtx,		         /* var_location */
+  debug_nothing_void,                    /* switch_text_section */
+  0                                      /* start_end_main_source_file */
 };
 #endif /* XCOFF_DEBUGGING_INFO  */
 
+/* Numeric formatting helper macro.  Note that this does not handle
+   hexadecimal.  */
+#define NUMBER_FMT_LOOP(P, NUM, BASE)		\
+  do						\
+    {						\
+      int digit = NUM % BASE;			\
+      NUM /= BASE;				\
+      *--P = digit + '0';			\
+    }						\
+  while (NUM > 0)
+
+/* Utility: write a decimal integer NUM to asm_out_file.  */
+void
+dbxout_int (int num)
+{
+  char buf[64];
+  char *p = buf + sizeof buf;
+  unsigned int unum;
+
+  if (num == 0)
+    {
+      putc ('0', asm_out_file);
+      return;
+    }
+  if (num < 0)
+    {
+      putc ('-', asm_out_file);
+      unum = -num;
+    }
+  else
+    unum = num;
+
+  NUMBER_FMT_LOOP (p, unum, 10);
+
+  while (p < buf + sizeof buf)
+    {
+      putc (*p, asm_out_file);
+      p++;
+    }
+}
+
+
+/* Primitives for emitting simple stabs directives.  All other stabs
+   routines should use these functions instead of directly emitting
+   stabs.  They are exported because machine-dependent code may need
+   to invoke them, e.g. in a DBX_OUTPUT_* macro whose definition
+   forwards to code in CPU.c.  */
+
+/* The following functions should all be called immediately after one
+   of the dbxout_begin_stab* functions (below).  They write out
+   various things as the value of a stab.  */
+
+/* Write out a literal zero as the value of a stab.  */
+void
+dbxout_stab_value_zero (void)
+{
+  fputs ("0\n", asm_out_file);
+}
+
+/* Write out the label LABEL as the value of a stab.  */
+void
+dbxout_stab_value_label (const char *label)
+{
+  assemble_name (asm_out_file, label);
+  putc ('\n', asm_out_file);
+}
+
+/* Write out the difference of two labels, LABEL - BASE, as the value
+   of a stab.  */
+void
+dbxout_stab_value_label_diff (const char *label, const char *base)
+{
+  assemble_name (asm_out_file, label);
+  putc ('-', asm_out_file);
+  assemble_name (asm_out_file, base);
+  putc ('\n', asm_out_file);
+}
+
+/* Write out an internal label as the value of a stab, and immediately
+   emit that internal label.  This should be used only when
+   dbxout_stabd will not work.  STEM is the name stem of the label,
+   COUNTERP is a pointer to a counter variable which will be used to
+   guarantee label uniqueness.  */
+void
+dbxout_stab_value_internal_label (const char *stem, int *counterp)
+{
+  char label[100];
+  int counter = counterp ? (*counterp)++ : 0;
+
+  ASM_GENERATE_INTERNAL_LABEL (label, stem, counter);
+  dbxout_stab_value_label (label);
+  targetm.asm_out.internal_label (asm_out_file, stem, counter);
+}
+
+/* Write out the difference between BASE and an internal label as the
+   value of a stab, and immediately emit that internal label.  STEM and
+   COUNTERP are as for dbxout_stab_value_internal_label.  */
+void
+dbxout_stab_value_internal_label_diff (const char *stem, int *counterp,
+				       const char *base)
+{
+  char label[100];
+  int counter = counterp ? (*counterp)++ : 0;
+
+  ASM_GENERATE_INTERNAL_LABEL (label, stem, counter);
+  dbxout_stab_value_label_diff (label, base);
+  targetm.asm_out.internal_label (asm_out_file, stem, counter);
+}
+
+/* The following functions produce specific kinds of stab directives.  */
+
+/* Write a .stabd directive with type STYPE and desc SDESC to asm_out_file.  */
+void
+dbxout_stabd (int stype, int sdesc)
+{
+  fputs (ASM_STABD_OP, asm_out_file);
+  dbxout_int (stype);
+  fputs (",0,", asm_out_file);
+  dbxout_int (sdesc);
+  putc ('\n', asm_out_file);
+}
+
+/* Write a .stabn directive with type STYPE.  This function stops
+   short of emitting the value field, which is the responsibility of
+   the caller (normally it will be either a symbol or the difference
+   of two symbols).  */
+
+void
+dbxout_begin_stabn (int stype)
+{
+  fputs (ASM_STABN_OP, asm_out_file);
+  dbxout_int (stype);
+  fputs (",0,0,", asm_out_file);
+}
+
+/* Write a .stabn directive with type N_SLINE and desc LINE.  As above,
+   the value field is the responsibility of the caller.  */
+void
+dbxout_begin_stabn_sline (int lineno)
+{
+  fputs (ASM_STABN_OP, asm_out_file);
+  dbxout_int (N_SLINE);
+  fputs (",0,", asm_out_file);
+  dbxout_int (lineno);
+  putc (',', asm_out_file);
+}
+
+/* Begin a .stabs directive with string "", type STYPE, and desc and
+   other fields 0.  The value field is the responsibility of the
+   caller.  This function cannot be used for .stabx directives.  */
+void
+dbxout_begin_empty_stabs (int stype)
+{
+  fputs (ASM_STABS_OP, asm_out_file);
+  fputs ("\"\",", asm_out_file);
+  dbxout_int (stype);
+  fputs (",0,0,", asm_out_file);
+}
+
+/* Begin a .stabs directive with string STR, type STYPE, and desc 0.
+   The value field is the responsibility of the caller.  */
+void
+dbxout_begin_simple_stabs (const char *str, int stype)
+{
+  fputs (ASM_STABS_OP, asm_out_file);
+  output_quoted_string (asm_out_file, str);
+  putc (',', asm_out_file);
+  dbxout_int (stype);
+  fputs (",0,0,", asm_out_file);
+}
+
+/* As above but use SDESC for the desc field.  */
+void
+dbxout_begin_simple_stabs_desc (const char *str, int stype, int sdesc)
+{
+  fputs (ASM_STABS_OP, asm_out_file);
+  output_quoted_string (asm_out_file, str);
+  putc (',', asm_out_file);
+  dbxout_int (stype);
+  fputs (",0,", asm_out_file);
+  dbxout_int (sdesc);
+  putc (',', asm_out_file);
+}
+
+/* The next set of functions are entirely concerned with production of
+   "complex" .stabs directives: that is, .stabs directives whose
+   strings have to be constructed piecemeal.  dbxout_type,
+   dbxout_symbol, etc. use these routines heavily.  The string is queued
+   up in an obstack, then written out by dbxout_finish_complex_stabs, which
+   is also responsible for splitting it up if it exceeds DBX_CONTIN_LENGTH.
+   (You might think it would be more efficient to go straight to stdio
+   when DBX_CONTIN_LENGTH is 0 (i.e. no length limit) but that turns
+   out not to be the case, and anyway this needs fewer #ifdefs.)  */
+
+/* Begin a complex .stabs directive.  If we can, write the initial
+   ASM_STABS_OP to the asm_out_file.  */
+
+static void
+dbxout_begin_complex_stabs (void)
+{
+  emit_pending_bincls_if_required ();
+  FORCE_TEXT;
+  fputs (ASM_STABS_OP, asm_out_file);
+  putc ('"', asm_out_file);
+  gcc_assert (stabstr_last_contin_point == 0);
+}
+
+/* As above, but do not force text or emit pending bincls.  This is
+   used by dbxout_symbol_location, which needs to do something else.  */
+static void
+dbxout_begin_complex_stabs_noforcetext (void)
+{
+  fputs (ASM_STABS_OP, asm_out_file);
+  putc ('"', asm_out_file);
+  gcc_assert (stabstr_last_contin_point == 0);
+}
+
+/* Add CHR, a single character, to the string being built.  */
+#define stabstr_C(chr) obstack_1grow (&stabstr_ob, chr)
+
+/* Add STR, a normal C string, to the string being built.  */
+#define stabstr_S(str) obstack_grow (&stabstr_ob, str, strlen(str))
+
+/* Add the text of ID, an IDENTIFIER_NODE, to the string being built.  */
+#define stabstr_I(id) obstack_grow (&stabstr_ob, \
+                                    IDENTIFIER_POINTER (id), \
+                                    IDENTIFIER_LENGTH (id))
+
+/* Add NUM, a signed decimal number, to the string being built.  */
+static void
+stabstr_D (HOST_WIDE_INT num)
+{
+  char buf[64];
+  char *p = buf + sizeof buf;
+  unsigned int unum;
+
+  if (num == 0)
+    {
+      stabstr_C ('0');
+      return;
+    }
+  if (num < 0)
+    {
+      stabstr_C ('-');
+      unum = -num;
+    }
+  else
+    unum = num;
+
+  NUMBER_FMT_LOOP (p, unum, 10);
+
+  obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p);
+}
+
+/* Add NUM, an unsigned decimal number, to the string being built.  */
+static void
+stabstr_U (unsigned HOST_WIDE_INT num)
+{
+  char buf[64];
+  char *p = buf + sizeof buf;
+  if (num == 0)
+    {
+      stabstr_C ('0');
+      return;
+    }
+  NUMBER_FMT_LOOP (p, num, 10);
+  obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p);
+}
+
+/* Add CST, an INTEGER_CST tree, to the string being built as an
+   unsigned octal number.  This routine handles values which are
+   larger than a single HOST_WIDE_INT.  */
+static void
+stabstr_O (tree cst)
+{
+  unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (cst);
+  unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (cst);
+
+  char buf[128];
+  char *p = buf + sizeof buf;
+
+  /* GDB wants constants with no extra leading "1" bits, so
+     we need to remove any sign-extension that might be
+     present.  */
+  {
+    const unsigned int width = TYPE_PRECISION (TREE_TYPE (cst));
+    if (width == HOST_BITS_PER_WIDE_INT * 2)
+      ;
+    else if (width > HOST_BITS_PER_WIDE_INT)
+      high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1);
+    else if (width == HOST_BITS_PER_WIDE_INT)
+      high = 0;
+    else
+      high = 0, low &= (((HOST_WIDE_INT) 1 << width) - 1);
+  }
+
+  /* Leading zero for base indicator.  */
+  stabstr_C ('0');
+
+  /* If the value is zero, the base indicator will serve as the value
+     all by itself.  */
+  if (high == 0 && low == 0)
+    return;
+
+  /* If the high half is zero, we need only print the low half normally.  */
+  if (high == 0)
+    NUMBER_FMT_LOOP (p, low, 8);
+  else
+    {
+      /* When high != 0, we need to print enough zeroes from low to
+	 give the digits from high their proper place-values.  Hence
+	 NUMBER_FMT_LOOP cannot be used.  */
+      const int n_digits = HOST_BITS_PER_WIDE_INT / 3;
+      int i;
+
+      for (i = 1; i <= n_digits; i++)
+	{
+	  unsigned int digit = low % 8;
+	  low /= 8;
+	  *--p = '0' + digit;
+	}
+
+      /* Octal digits carry exactly three bits of information.  The
+	 width of a HOST_WIDE_INT is not normally a multiple of three.
+	 Therefore, the next digit printed probably needs to carry
+	 information from both low and high.  */
+      if (HOST_BITS_PER_WIDE_INT % 3 != 0)
+	{
+	  const int n_leftover_bits = HOST_BITS_PER_WIDE_INT % 3;
+	  const int n_bits_from_high = 3 - n_leftover_bits;
+
+	  const unsigned HOST_WIDE_INT
+	    low_mask = (((unsigned HOST_WIDE_INT)1) << n_leftover_bits) - 1;
+	  const unsigned HOST_WIDE_INT
+	    high_mask = (((unsigned HOST_WIDE_INT)1) << n_bits_from_high) - 1;
+
+	  unsigned int digit;
+
+	  /* At this point, only the bottom n_leftover_bits bits of low
+	     should be set.  */
+	  gcc_assert (!(low & ~low_mask));
+
+	  digit = (low | ((high & high_mask) << n_leftover_bits));
+	  high >>= n_bits_from_high;
+
+	  *--p = '0' + digit;
+	}
+
+      /* Now we can format high in the normal manner.  However, if
+	 the only bits of high that were set were handled by the
+	 digit split between low and high, high will now be zero, and
+	 we don't want to print extra digits in that case.  */
+      if (high)
+	NUMBER_FMT_LOOP (p, high, 8);
+    }
+
+  obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p);
+}
+
+/* Called whenever it is safe to break a stabs string into multiple
+   .stabs directives.  If the current string has exceeded the limit
+   set by DBX_CONTIN_LENGTH, mark the current position in the buffer
+   as a continuation point by inserting DBX_CONTIN_CHAR (doubled if
+   it is a backslash) and a null character.  */
+static inline void
+stabstr_continue (void)
+{
+  if (DBX_CONTIN_LENGTH > 0
+      && obstack_object_size (&stabstr_ob) - stabstr_last_contin_point
+	 > DBX_CONTIN_LENGTH)
+    {
+      if (DBX_CONTIN_CHAR == '\\')
+	obstack_1grow (&stabstr_ob, '\\');
+      obstack_1grow (&stabstr_ob, DBX_CONTIN_CHAR);
+      obstack_1grow (&stabstr_ob, '\0');
+      stabstr_last_contin_point = obstack_object_size (&stabstr_ob);
+    }
+}
+#define CONTIN stabstr_continue ()
+
+/* Macro subroutine of dbxout_finish_complex_stabs, which emits
+   all of the arguments to the .stabs directive after the string.
+   Overridden by xcoffout.h.  CODE is the stabs code for this symbol;
+   LINE is the source line to write into the desc field (in extended
+   mode); SYM is the symbol itself.
+
+   ADDR, LABEL, and NUMBER are three different ways to represent the
+   stabs value field.  At most one of these should be nonzero.
+
+     ADDR is used most of the time; it represents the value as an
+     RTL address constant.
+
+     LABEL is used (currently) only for N_CATCH stabs; it represents
+     the value as a string suitable for assemble_name.
+
+     NUMBER is used when the value is an offset from an implicit base
+     pointer (e.g. for a stack variable), or an index (e.g. for a
+     register variable).  It represents the value as a decimal integer.  */
+
+#ifndef DBX_FINISH_STABS
+#define DBX_FINISH_STABS(SYM, CODE, LINE, ADDR, LABEL, NUMBER)	\
+do {								\
+  int line_ = use_gnu_debug_info_extensions ? LINE : 0;		\
+								\
+  dbxout_int (CODE);						\
+  fputs (",0,", asm_out_file);					\
+  dbxout_int (line_);						\
+  putc (',', asm_out_file);					\
+  if (ADDR)							\
+    output_addr_const (asm_out_file, ADDR);			\
+  else if (LABEL)						\
+    assemble_name (asm_out_file, LABEL);			\
+  else								\
+    dbxout_int (NUMBER);					\
+  putc ('\n', asm_out_file);					\
+} while (0)
+#endif
+
+/* Finish the emission of a complex .stabs directive.  When DBX_CONTIN_LENGTH
+   is zero, this has only to emit the close quote and the remainder of
+   the arguments.  When it is nonzero, the string has been marshalled in
+   stabstr_ob, and this routine is responsible for breaking it up into
+   DBX_CONTIN_LENGTH-sized chunks.
+
+   SYM is the DECL of the symbol under consideration; it is used only
+   for its DECL_SOURCE_LINE.  The other arguments are all passed directly
+   to DBX_FINISH_STABS; see above for details.  */
+   
+static void
+dbxout_finish_complex_stabs (tree sym, STAB_CODE_TYPE code,
+			     rtx addr, const char *label, int number)
+{
+  int line ATTRIBUTE_UNUSED;
+  char *str;
+  size_t len;
+
+  line = sym ? DECL_SOURCE_LINE (sym) : 0;
+  if (DBX_CONTIN_LENGTH > 0)
+    {
+      char *chunk;
+      size_t chunklen;
+
+      /* Nul-terminate the growing string, then get its size and
+	 address.  */
+      obstack_1grow (&stabstr_ob, '\0');
+
+      len = obstack_object_size (&stabstr_ob);
+      chunk = str = XOBFINISH (&stabstr_ob, char *);
+
+      /* Within the buffer are a sequence of NUL-separated strings,
+	 each of which is to be written out as a separate stab
+	 directive.  */
+      for (;;)
+	{
+	  chunklen = strlen (chunk);
+	  fwrite (chunk, 1, chunklen, asm_out_file);
+	  fputs ("\",", asm_out_file);
+
+	  /* Must add an extra byte to account for the NUL separator.  */
+	  chunk += chunklen + 1;
+	  len   -= chunklen + 1;
+
+	  /* Only put a line number on the last stab in the sequence.  */
+	  DBX_FINISH_STABS (sym, code, len == 0 ? line : 0,
+			    addr, label, number);
+	  if (len == 0)
+	    break;
+
+	  fputs (ASM_STABS_OP, asm_out_file);
+	  putc ('"', asm_out_file);
+	}
+      stabstr_last_contin_point = 0;
+    }
+  else
+    {
+      /* No continuations - we can put the whole string out at once.
+	 It is faster to augment the string with the close quote and
+	 comma than to do a two-character fputs.  */
+      obstack_grow (&stabstr_ob, "\",", 2);
+      len = obstack_object_size (&stabstr_ob);
+      str = XOBFINISH (&stabstr_ob, char *);
+      
+      fwrite (str, 1, len, asm_out_file);
+      DBX_FINISH_STABS (sym, code, line, addr, label, number);
+    }
+  obstack_free (&stabstr_ob, str);
+}
+
 #if defined (DBX_DEBUGGING_INFO)
+
 static void
-dbxout_function_end (void)
+dbxout_function_end (tree decl)
 {
   char lscope_label_name[100];
 
   /* The Lscope label must be emitted even if we aren't doing anything
      else; dbxout_block needs it.  */
-  /* Convert Ltext into the appropriate format for local labels in case
+  switch_to_section (function_section (current_function_decl));
+  
+  /* Convert Lscope into the appropriate format for local labels in case
      the system doesn't insert underscores in front of user generated
      labels.  */
   ASM_GENERATE_INTERNAL_LABEL (lscope_label_name, "Lscope", scope_labelno);
-  (*targetm.asm_out.internal_label) (asmfile, "Lscope", scope_labelno);
-  scope_labelno++;
+  targetm.asm_out.internal_label (asm_out_file, "Lscope", scope_labelno);
 
   /* The N_FUN tag at the end of the function is a GNU extension,
      which may be undesirable, and is unnecessary if we do not have
      named sections.  */
   if (!use_gnu_debug_info_extensions
-#if defined(NO_DBX_FUNCTION_END)
       || NO_DBX_FUNCTION_END
-#endif
-      || !targetm.have_named_sections)
+      || !targetm.have_named_sections
+      || DECL_IGNORED_P (decl))
     return;
 
   /* By convention, GCC will mark the end of a function with an N_FUN
      symbol and an empty string.  */
-#ifdef DBX_OUTPUT_NFUN
-  DBX_OUTPUT_NFUN (asmfile, lscope_label_name, current_function_decl);
-#else
-  fprintf (asmfile, "%s\"\",%d,0,0,", ASM_STABS_OP, N_FUN);
-  assemble_name (asmfile, lscope_label_name);
-  putc ('-', asmfile);
-  assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
-  fprintf (asmfile, "\n");
-#endif
+  if (flag_reorder_blocks_and_partition)
+    {
+      dbxout_begin_empty_stabs (N_FUN);
+      dbxout_stab_value_label_diff (cfun->hot_section_end_label, 
+				    cfun->hot_section_label);
+      dbxout_begin_empty_stabs (N_FUN);
+      dbxout_stab_value_label_diff (cfun->cold_section_end_label, 
+				    cfun->cold_section_label);
+    }
+  else
+    {
+      char begin_label[20];
+      /* Reference current function start using LFBB.  */
+      ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
+      dbxout_begin_empty_stabs (N_FUN);
+      dbxout_stab_value_label_diff (lscope_label_name, begin_label);
+    }
+
+  if (!NO_DBX_BNSYM_ENSYM && !flag_debug_only_used_symbols)
+    dbxout_stabd (N_ENSYM, 0);
 }
 #endif /* DBX_DEBUGGING_INFO */
 
+/* Get lang description for N_SO stab.  */
+static unsigned int ATTRIBUTE_UNUSED
+get_lang_number (void)
+{
+  const char *language_string = lang_hooks.name;
+
+  if (strcmp (language_string, "GNU C") == 0)
+    return N_SO_C;
+  else if (strcmp (language_string, "GNU C++") == 0)
+    return N_SO_CC;
+  else if (strcmp (language_string, "GNU F77") == 0)
+    return N_SO_FORTRAN;
+  else if (strcmp (language_string, "GNU F95") == 0)
+    return N_SO_FORTRAN90; /* CHECKME */
+  else if (strcmp (language_string, "GNU Pascal") == 0)
+    return N_SO_PASCAL;
+  else if (strcmp (language_string, "GNU Objective-C") == 0)
+    return N_SO_OBJC;
+  else if (strcmp (language_string, "GNU Objective-C++") == 0)
+    return N_SO_OBJCPLUS;
+  else
+    return 0;
+
+}
+
 /* At the beginning of compilation, start writing the symbol table.
    Initialize `typevec' and output the standard data types of C.  */
 
@@ -475,59 +982,62 @@ static void
 dbxout_init (const char *input_file_name)
 {
   char ltext_label_name[100];
-  tree syms = (*lang_hooks.decls.getdecls) ();
-
-  asmfile = asm_out_file;
+  bool used_ltext_label_name = false;
+  tree syms = lang_hooks.decls.getdecls ();
 
   typevec_len = 100;
   typevec = ggc_calloc (typevec_len, sizeof typevec[0]);
 
+  /* stabstr_ob contains one string, which will be just fine with
+     1-byte alignment.  */
+  obstack_specify_allocation (&stabstr_ob, 0, 1, xmalloc, free);
+
   /* Convert Ltext into the appropriate format for local labels in case
      the system doesn't insert underscores in front of user generated
      labels.  */
   ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
 
   /* Put the current working directory in an N_SO symbol.  */
-  if (use_gnu_debug_info_extensions)
+  if (use_gnu_debug_info_extensions && !NO_DBX_MAIN_SOURCE_DIRECTORY)
     {
-      if (!cwd && (cwd = get_src_pwd ())
-	  && (!*cwd || cwd[strlen (cwd) - 1] != '/'))
-	cwd = concat (cwd, FILE_NAME_JOINER, NULL);
-      if (cwd)
+      static const char *cwd;
+
+      if (!cwd)
 	{
+	  cwd = get_src_pwd ();
+	  if (cwd[0] == '\0')
+	    cwd = "/";
+	  else if (!IS_DIR_SEPARATOR (cwd[strlen (cwd) - 1]))
+	    cwd = concat (cwd, "/", NULL);
+	}
 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
-	  DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile, cwd);
+      DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asm_out_file, cwd);
 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
-	  fprintf (asmfile, "%s", ASM_STABS_OP);
-	  output_quoted_string (asmfile, cwd);
-	  fprintf (asmfile, ",%d,0,0,", N_SO);
-	  assemble_name (asmfile, ltext_label_name);
-	  fputc ('\n', asmfile);
+      dbxout_begin_simple_stabs_desc (cwd, N_SO, get_lang_number ());
+      dbxout_stab_value_label (ltext_label_name);
+      used_ltext_label_name = true;
 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
-	}
     }
 
 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
-  DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile, input_file_name);
-#else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
-  /* We include outputting `Ltext:' here,
-     because that gives you a way to override it.  */
-  /* Used to put `Ltext:' before the reference, but that loses on sun 4.  */
-  fprintf (asmfile, "%s", ASM_STABS_OP);
-  output_quoted_string (asmfile, input_file_name);
-  fprintf (asmfile, ",%d,0,0,", N_SO);
-  assemble_name (asmfile, ltext_label_name);
-  fputc ('\n', asmfile);
-  text_section ();
-  (*targetm.asm_out.internal_label) (asmfile, "Ltext", 0);
-#endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
-
-#ifdef DBX_OUTPUT_GCC_MARKER
-  DBX_OUTPUT_GCC_MARKER (asmfile);
+  DBX_OUTPUT_MAIN_SOURCE_FILENAME (asm_out_file, input_file_name);
 #else
-  /* Emit an N_OPT stab to indicate that this file was compiled by GCC.  */
-  fprintf (asmfile, "%s\"%s\",%d,0,0,0\n",
-	   ASM_STABS_OP, STABS_GCC_MARKER, N_OPT);
+  dbxout_begin_simple_stabs_desc (input_file_name, N_SO, get_lang_number ());
+  dbxout_stab_value_label (ltext_label_name);
+  used_ltext_label_name = true;
+#endif
+
+  if (used_ltext_label_name)
+    {
+      switch_to_section (text_section);
+      targetm.asm_out.internal_label (asm_out_file, "Ltext", 0);
+    }
+
+  /* Emit an N_OPT stab to indicate that this file was compiled by GCC.
+     The string used is historical.  */
+#ifndef NO_DBX_GCC_MARKER
+  dbxout_begin_simple_stabs ("gcc2_compiled.", N_OPT);
+  dbxout_stab_value_zero ();
 #endif
 
   base_input_file = lastfile = input_file_name;
@@ -535,7 +1045,7 @@ dbxout_init (const char *input_file_name)
   next_type_number = 1;
 
 #ifdef DBX_USE_BINCL
-  current_file = xmalloc (sizeof *current_file);
+  current_file = XNEW (struct dbx_file);
   current_file->next = NULL;
   current_file->file_number = 0;
   current_file->next_type_number = 1;
@@ -545,22 +1055,20 @@ dbxout_init (const char *input_file_name)
   current_file->pending_bincl_name = NULL;
 #endif
 
-  /* Make sure that types `int' and `char' have numbers 1 and 2.
-     Definitions of other integer types will refer to those numbers.
-     (Actually it should no longer matter what their numbers are.
-     Also, if any types with tags have been defined, dbxout_symbol
-     will output them first, so the numbers won't be 1 and 2.  That
-     happens in C++.  So it's a good thing it should no longer matter).  */
-
-#ifdef DBX_OUTPUT_STANDARD_TYPES
-  DBX_OUTPUT_STANDARD_TYPES (syms);
-#endif
-
   /* Get all permanent types that have typedef names, and output them
      all, except for those already output.  Some language front ends
-     put these declarations in the top-level scope; some do not.  */
-  dbxout_typedefs ((*lang_hooks.decls.builtin_type_decls) ());
+     put these declarations in the top-level scope; some do not;
+     the latter are responsible for calling debug_hooks->type_decl from
+     their record_builtin_type function.  */
   dbxout_typedefs (syms);
+
+  if (preinit_symbols)
+    {
+      tree t;
+      for (t = nreverse (preinit_symbols); t; t = TREE_CHAIN (t))
+	dbxout_symbol (TREE_VALUE (t), 0);
+      preinit_symbols = 0;
+    }
 }
 
 /* Output any typedef names for types described by TYPE_DECLs in SYMS.  */
@@ -587,9 +1095,8 @@ dbxout_typedefs (tree syms)
 static void
 emit_bincl_stab (const char *name)
 {
-  fprintf (asmfile, "%s", ASM_STABS_OP);
-  output_quoted_string (asmfile, name);
-  fprintf (asmfile, ",%d,0,0,0\n", N_BINCL);
+  dbxout_begin_simple_stabs (name, N_BINCL);
+  dbxout_stab_value_zero ();
 }
 
 /* If there are pending bincls then it is time to emit all of them.  */
@@ -647,7 +1154,7 @@ dbxout_start_source_file (unsigned int line ATTRIBUTE_UNUSED,
 			  const char *filename ATTRIBUTE_UNUSED)
 {
 #ifdef DBX_USE_BINCL
-  struct dbx_file *n = xmalloc (sizeof *n);
+  struct dbx_file *n = XNEW (struct dbx_file);
 
   n->next = current_file;
   n->next_type_number = 1;
@@ -671,7 +1178,10 @@ dbxout_end_source_file (unsigned int line ATTRIBUTE_UNUSED)
 #ifdef DBX_USE_BINCL
   /* Emit EINCL stab only if BINCL is not pending.  */
   if (current_file->bincl_status == BINCL_PROCESSED)
-    fprintf (asmfile, "%s%d,0,0,0\n", ASM_STABN_OP, N_EINCL);
+    {
+      dbxout_begin_stabn (N_EINCL);
+      dbxout_stab_value_zero ();
+    }
   current_file->bincl_status = BINCL_NOT_REQUIRED;
   current_file = current_file->next;
 #endif
@@ -706,7 +1216,7 @@ dbxout_handle_pch (unsigned at_end)
 /* Output debugging info to FILE to switch to sourcefile FILENAME.  */
 
 static void
-dbxout_source_file (FILE *file, const char *filename)
+dbxout_source_file (const char *filename)
 {
   if (lastfile == 0 && lastfile_is_base)
     {
@@ -716,39 +1226,60 @@ dbxout_source_file (FILE *file, const char *filename)
 
   if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
     {
-      char ltext_label_name[100];
-
-      ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext",
-				   source_label_number);
-      fprintf (file, "%s", ASM_STABS_OP);
-      output_quoted_string (file, filename);
-      fprintf (asmfile, ",%d,0,0,", N_SOL);
-      assemble_name (asmfile, ltext_label_name);
-      fputc ('\n', asmfile);
-      if (current_function_decl != NULL_TREE
-	  && DECL_SECTION_NAME (current_function_decl) != NULL_TREE)
-	; /* Don't change section amid function.  */
-      else
-	text_section ();
-      (*targetm.asm_out.internal_label) (file, "Ltext", source_label_number);
-      source_label_number++;
+      /* Don't change section amid function.  */
+      if (current_function_decl == NULL_TREE)
+	switch_to_section (text_section);
+
+      dbxout_begin_simple_stabs (filename, N_SOL);
+      dbxout_stab_value_internal_label ("Ltext", &source_label_number);
       lastfile = filename;
     }
 }
 
+/* Output N_BNSYM, line number symbol entry, and local symbol at 
+   function scope  */
+
+static void
+dbxout_begin_prologue (unsigned int lineno, const char *filename)
+{
+  if (use_gnu_debug_info_extensions
+      && !NO_DBX_FUNCTION_END
+      && !NO_DBX_BNSYM_ENSYM
+      && !flag_debug_only_used_symbols)
+    dbxout_stabd (N_BNSYM, 0);
+
+  /* pre-increment the scope counter */
+  scope_labelno++;
+
+  dbxout_source_line (lineno, filename);
+  /* Output function begin block at function scope, referenced 
+     by dbxout_block, dbxout_source_line and dbxout_function_end.  */
+  emit_pending_bincls_if_required ();
+  targetm.asm_out.internal_label (asm_out_file, "LFBB", scope_labelno);
+}
+
 /* Output a line number symbol entry for source file FILENAME and line
    number LINENO.  */
 
 static void
 dbxout_source_line (unsigned int lineno, const char *filename)
 {
-  dbxout_source_file (asmfile, filename);
+  dbxout_source_file (filename);
 
-#ifdef ASM_OUTPUT_SOURCE_LINE
-  dbxout_source_line_counter += 1;
-  ASM_OUTPUT_SOURCE_LINE (asmfile, lineno, dbxout_source_line_counter);
+#ifdef DBX_OUTPUT_SOURCE_LINE
+  DBX_OUTPUT_SOURCE_LINE (asm_out_file, lineno, dbxout_source_line_counter);
 #else
-  fprintf (asmfile, "%s%d,0,%d\n", ASM_STABD_OP, N_SLINE, lineno);
+  if (DBX_LINES_FUNCTION_RELATIVE)
+    {
+      char begin_label[20];
+      dbxout_begin_stabn_sline (lineno);
+      /* Reference current function start using LFBB.  */
+      ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno); 
+      dbxout_stab_value_internal_label_diff ("LM", &dbxout_source_line_counter,
+					     begin_label);
+    }
+  else
+    dbxout_stabd (N_SLINE, lineno);
 #endif
 }
 
@@ -758,7 +1289,7 @@ static void
 dbxout_begin_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n)
 {
   emit_pending_bincls_if_required ();
-  (*targetm.asm_out.internal_label) (asmfile, "LBB", n);
+  targetm.asm_out.internal_label (asm_out_file, "LBB", n);
 }
 
 /* Describe the end line-number of an internal block within a function.  */
@@ -767,7 +1298,7 @@ static void
 dbxout_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n)
 {
   emit_pending_bincls_if_required ();
-  (*targetm.asm_out.internal_label) (asmfile, "LBE", n);
+  targetm.asm_out.internal_label (asm_out_file, "LBE", n);
 }
 
 /* Output dbx data for a function definition.
@@ -784,10 +1315,7 @@ dbxout_function_decl (tree decl)
   dbxout_begin_function (decl);
 #endif
   dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
-#ifdef DBX_OUTPUT_FUNCTION_END
-  DBX_OUTPUT_FUNCTION_END (asmfile, decl);
-#endif
-  dbxout_function_end ();
+  dbxout_function_end (decl);
 }
 
 #endif /* DBX_DEBUGGING_INFO  */
@@ -797,9 +1325,7 @@ dbxout_function_decl (tree decl)
 static void
 dbxout_global_decl (tree decl)
 {
-  if (TREE_CODE (decl) == VAR_DECL
-      && ! DECL_EXTERNAL (decl)
-      && DECL_RTL_SET_P (decl))	/* Not necessary?  */
+  if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
     {
       int saved_tree_used = TREE_USED (decl);
       TREE_USED (decl) = 1;
@@ -808,17 +1334,29 @@ dbxout_global_decl (tree decl)
     }
 }
 
+/* This is just a function-type adapter; dbxout_symbol does exactly
+   what we want but returns an int.  */
+static void
+dbxout_type_decl (tree decl, int local)
+{
+  dbxout_symbol (decl, local);
+}
+
 /* At the end of compilation, finish writing the symbol table.
-   Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
-   to do nothing.  */
+   The default is to call debug_free_queue but do nothing else.  */
 
 static void
 dbxout_finish (const char *filename ATTRIBUTE_UNUSED)
 {
 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
-  DBX_OUTPUT_MAIN_SOURCE_FILE_END (asmfile, filename);
-#endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
-
+  DBX_OUTPUT_MAIN_SOURCE_FILE_END (asm_out_file, filename);
+#elif defined DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
+ {
+   switch_to_section (text_section);
+   dbxout_begin_empty_stabs (N_SO);
+   dbxout_stab_value_internal_label ("Letext", 0);
+ }
+#endif
   debug_free_queue ();
 }
 
@@ -828,37 +1366,24 @@ static void
 dbxout_type_index (tree type)
 {
 #ifndef DBX_USE_BINCL
-  fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type));
-  CHARS (3);
+  stabstr_D (TYPE_SYMTAB_ADDRESS (type));
 #else
   struct typeinfo *t = &typevec[TYPE_SYMTAB_ADDRESS (type)];
-  fprintf (asmfile, "(%d,%d)", t->file_number, t->type_number);
-  CHARS (9);
+  stabstr_C ('(');
+  stabstr_D (t->file_number);
+  stabstr_C (',');
+  stabstr_D (t->type_number);
+  stabstr_C (')');
 #endif
 }
 
-#if DBX_CONTIN_LENGTH > 0
-/* Continue a symbol-description that gets too big.
-   End one symbol table entry with a double-backslash
-   and start a new one, eventually producing something like
-   .stabs "start......\\",code,0,value
-   .stabs "...rest",code,0,value   */
-
-static void
-dbxout_continue (void)
-{
-  emit_pending_bincls_if_required ();
-#ifdef DBX_CONTIN_CHAR
-  fprintf (asmfile, "%c", DBX_CONTIN_CHAR);
-#else
-  fprintf (asmfile, "\\\\");
-#endif
-  dbxout_finish_symbol (NULL_TREE);
-  fprintf (asmfile, "%s\"", ASM_STABS_OP);
-  current_sym_nchars = 0;
-}
-#endif /* DBX_CONTIN_LENGTH > 0 */
 
+
+/* Used in several places: evaluates to '0' for a private decl,
+   '1' for a protected decl, '2' for a public decl.  */
+#define DECL_ACCESSIBILITY_CHAR(DECL) \
+(TREE_PRIVATE (DECL) ? '0' : TREE_PROTECTED (DECL) ? '1' : '2')
+
 /* Subroutine of `dbxout_type'.  Output the type fields of TYPE.
    This must be a separate function because anonymous unions require
    recursive calls.  */
@@ -872,21 +1397,21 @@ dbxout_type_fields (tree type)
      field that we can support.  */
   for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
     {
-
-      /* If on of the nodes is an error_mark or its type is then return early. */
+      /* If one of the nodes is an error_mark or its type is then
+	 return early.  */
       if (tem == error_mark_node || TREE_TYPE (tem) == error_mark_node)
 	return;
 
       /* Omit here local type decls until we know how to support them.  */
       if (TREE_CODE (tem) == TYPE_DECL
+	  /* Omit here the nameless fields that are used to skip bits.  */
+	  || DECL_IGNORED_P (tem)
 	  /* Omit fields whose position or size are variable or too large to
 	     represent.  */
 	  || (TREE_CODE (tem) == FIELD_DECL
 	      && (! host_integerp (bit_position (tem), 0)
 		  || ! DECL_SIZE (tem)
-		  || ! host_integerp (DECL_SIZE (tem), 1)))
-	  /* Omit here the nameless fields that are used to skip bits.  */
-	   || DECL_IGNORED_P (tem))
+		  || ! host_integerp (DECL_SIZE (tem), 1))))
 	continue;
 
       else if (TREE_CODE (tem) != CONST_DECL)
@@ -897,26 +1422,15 @@ dbxout_type_fields (tree type)
 	    CONTIN;
 
 	  if (DECL_NAME (tem))
-	    {
-	      fprintf (asmfile, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem)));
-	      CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem)));
-	    }
-	  else
-	    {
-	      fprintf (asmfile, ":");
-	      CHARS (1);
-	    }
+	    stabstr_I (DECL_NAME (tem));
+	  stabstr_C (':');
 
 	  if (use_gnu_debug_info_extensions
 	      && (TREE_PRIVATE (tem) || TREE_PROTECTED (tem)
 		  || TREE_CODE (tem) != FIELD_DECL))
 	    {
-	      have_used_extensions = 1;
-	      putc ('/', asmfile);
-	      putc ((TREE_PRIVATE (tem) ? '0'
-		     : TREE_PROTECTED (tem) ? '1' : '2'),
-		    asmfile);
-	      CHARS (2);
+	      stabstr_C ('/');
+	      stabstr_C (DECL_ACCESSIBILITY_CHAR (tem));
 	    }
 
 	  dbxout_type ((TREE_CODE (tem) == FIELD_DECL
@@ -929,37 +1443,31 @@ dbxout_type_fields (tree type)
 		{
 		  tree name = DECL_ASSEMBLER_NAME (tem);
 
-		  have_used_extensions = 1;
-		  fprintf (asmfile, ":%s;", IDENTIFIER_POINTER (name));
-		  CHARS (IDENTIFIER_LENGTH (name) + 2);
+		  stabstr_C (':');
+		  stabstr_I (name);
+		  stabstr_C (';');
 		}
 	      else
-		{
-		  /* If TEM is non-static, GDB won't understand it.  */
-		  fprintf (asmfile, ",0,0;");
-		  CHARS (5);
-		}
+		/* If TEM is non-static, GDB won't understand it.  */
+		stabstr_S (",0,0;");
 	    }
 	  else
 	    {
-	      putc (',', asmfile);
-	      print_wide_int (int_bit_position (tem));
-	      putc (',', asmfile);
-	      print_wide_int (tree_low_cst (DECL_SIZE (tem), 1));
-	      putc (';', asmfile);
-	      CHARS (3);
+	      stabstr_C (',');
+	      stabstr_D (int_bit_position (tem));
+	      stabstr_C (',');
+	      stabstr_D (tree_low_cst (DECL_SIZE (tem), 1));
+	      stabstr_C (';');
 	    }
 	}
     }
 }
 
 /* Subroutine of `dbxout_type_methods'.  Output debug info about the
-   method described DECL.  DEBUG_NAME is an encoding of the method's
-   type signature.  ??? We may be able to do without DEBUG_NAME altogether
-   now.  */
+   method described DECL.  */
 
 static void
-dbxout_type_method_1 (tree decl, const char *debug_name)
+dbxout_type_method_1 (tree decl)
 {
   char c1 = 'A', c2;
 
@@ -983,20 +1491,21 @@ dbxout_type_method_1 (tree decl, const char *debug_name)
 	c2 = '.';
     }
 
-  fprintf (asmfile, ":%s;%c%c%c", debug_name,
-	   TREE_PRIVATE (decl) ? '0'
-	   : TREE_PROTECTED (decl) ? '1' : '2', c1, c2);
-  CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl)) + 6
-	 - (debug_name - IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))));
+  /* ??? Output the mangled name, which contains an encoding of the
+     method's type signature.  May not be necessary anymore.  */
+  stabstr_C (':');
+  stabstr_I (DECL_ASSEMBLER_NAME (decl));
+  stabstr_C (';');
+  stabstr_C (DECL_ACCESSIBILITY_CHAR (decl));
+  stabstr_C (c1);
+  stabstr_C (c2);
 
   if (DECL_VINDEX (decl) && host_integerp (DECL_VINDEX (decl), 0))
     {
-      print_wide_int (tree_low_cst (DECL_VINDEX (decl), 0));
-      putc (';', asmfile);
-      CHARS (1);
+      stabstr_D (tree_low_cst (DECL_VINDEX (decl), 0));
+      stabstr_C (';');
       dbxout_type (DECL_CONTEXT (decl), 0);
-      fprintf (asmfile, ";");
-      CHARS (1);
+      stabstr_C (';');
     }
 }
 
@@ -1008,39 +1517,12 @@ dbxout_type_methods (tree type)
 {
   /* C++: put out the method names and their parameter lists */
   tree methods = TYPE_METHODS (type);
-  tree type_encoding;
   tree fndecl;
   tree last;
-  char formatted_type_identifier_length[16];
-  int type_identifier_length;
 
   if (methods == NULL_TREE)
     return;
 
-  type_encoding = DECL_NAME (TYPE_NAME (type));
-
-#if 0
-  /* C++: Template classes break some assumptions made by this code about
-     the class names, constructor names, and encodings for assembler
-     label names.  For now, disable output of dbx info for them.  */
-  {
-    const char *ptr = IDENTIFIER_POINTER (type_encoding);
-    /* This should use index.  (mrs) */
-    while (*ptr && *ptr != '<') ptr++;
-    if (*ptr != 0)
-      {
-	static int warned;
-	if (!warned)
-	    warned = 1;
-	return;
-      }
-  }
-#endif
-
-  type_identifier_length = IDENTIFIER_LENGTH (type_encoding);
-
-  sprintf (formatted_type_identifier_length, "%d", type_identifier_length);
-
   if (TREE_CODE (methods) != TREE_VEC)
     fndecl = methods;
   else if (TREE_VEC_ELT (methods, 0) != NULL_TREE)
@@ -1061,18 +1543,12 @@ dbxout_type_methods (tree type)
 	   well as the name of the field before overloading, along
 	   with its parameter list */
 	{
-	  /* This is the "mangled" name of the method.
-	     It encodes the argument types.  */
-	  const char *debug_name;
-
 	  /* Skip methods that aren't FUNCTION_DECLs.  (In C++, these
 	     include TEMPLATE_DECLs.)  The debugger doesn't know what
 	     to do with such entities anyhow.  */
 	  if (TREE_CODE (fndecl) != FUNCTION_DECL)
 	    continue;
 
-	  debug_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl));
-
 	  CONTIN;
 
 	  last = fndecl;
@@ -1086,21 +1562,16 @@ dbxout_type_methods (tree type)
 	     expects.  */
 	  if (need_prefix)
 	    {
-	      tree name = DECL_NAME (fndecl);
-	      fprintf (asmfile, "%s::", IDENTIFIER_POINTER (name));
-	      CHARS (IDENTIFIER_LENGTH (name) + 2);
+	      stabstr_I (DECL_NAME (fndecl));
+	      stabstr_S ("::");
 	      need_prefix = 0;
 	    }
 
 	  dbxout_type (TREE_TYPE (fndecl), 0);
-
-	  dbxout_type_method_1 (fndecl, debug_name);
+	  dbxout_type_method_1 (fndecl);
 	}
       if (!need_prefix)
-	{
-	  putc (';', asmfile);
-	  CHARS (1);
-	}
+	stabstr_C (';');
     }
 }
 
@@ -1111,7 +1582,7 @@ dbxout_type_methods (tree type)
 static void
 dbxout_range_type (tree type)
 {
-  fprintf (asmfile, "r");
+  stabstr_C ('r');
   if (TREE_TYPE (type))
     dbxout_type (TREE_TYPE (type), 0);
   else if (TREE_CODE (type) != INTEGER_TYPE)
@@ -1136,39 +1607,30 @@ dbxout_range_type (tree type)
 	dbxout_type_index (integer_type_node);
     }
 
+  stabstr_C (';');
   if (TYPE_MIN_VALUE (type) != 0
       && host_integerp (TYPE_MIN_VALUE (type), 0))
     {
-      putc (';', asmfile);
-      CHARS (1);
       if (print_int_cst_bounds_in_octal_p (type))
-        print_int_cst_octal (TYPE_MIN_VALUE (type));
+        stabstr_O (TYPE_MIN_VALUE (type));
       else
-        print_wide_int (tree_low_cst (TYPE_MIN_VALUE (type), 0));
+        stabstr_D (tree_low_cst (TYPE_MIN_VALUE (type), 0));
     }
   else
-    {
-      fprintf (asmfile, ";0");
-      CHARS (2);
-    }
+    stabstr_C ('0');
 
+  stabstr_C (';');
   if (TYPE_MAX_VALUE (type) != 0
       && host_integerp (TYPE_MAX_VALUE (type), 0))
     {
-      putc (';', asmfile);
-      CHARS (1);
       if (print_int_cst_bounds_in_octal_p (type))
-        print_int_cst_octal (TYPE_MAX_VALUE (type));
+        stabstr_O (TYPE_MAX_VALUE (type));
       else
-        print_wide_int (tree_low_cst (TYPE_MAX_VALUE (type), 0));
-      putc (';', asmfile);
-      CHARS (1);
+        stabstr_D (tree_low_cst (TYPE_MAX_VALUE (type), 0));
+      stabstr_C (';');
     }
   else
-    {
-      fprintf (asmfile, ";-1;");
-      CHARS (4);
-    }
+    stabstr_S ("-1;");
 }
 
 
@@ -1188,11 +1650,15 @@ dbxout_type (tree type, int full)
   tree tem;
   tree main_variant;
   static int anonymous_type_number = 0;
+  bool vector_type = false;
 
   if (TREE_CODE (type) == VECTOR_TYPE)
-    /* The frontend feeds us a representation for the vector as a struct
-       containing an array.  Pull out the array type.  */
-    type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
+    {
+      /* The frontend feeds us a representation for the vector as a struct
+	 containing an array.  Pull out the array type.  */
+      type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
+      vector_type = true;
+    }
 
   /* If there was an input error and we don't really have a type,
      avoid crashing and write something that is at least valid
@@ -1250,7 +1716,7 @@ dbxout_type (tree type, int full)
 	   || TREE_CODE (type) == QUAL_UNION_TYPE
 	   || TREE_CODE (type) == ENUMERAL_TYPE)
 	  && TYPE_STUB_DECL (type)
-	  && TREE_CODE_CLASS (TREE_CODE (TYPE_STUB_DECL (type))) == 'd'
+	  && DECL_P (TYPE_STUB_DECL (type))
 	  && ! DECL_IGNORED_P (TYPE_STUB_DECL (type)))
 	debug_queue_symbol (TYPE_STUB_DECL (type));
       else if (TYPE_NAME (type)
@@ -1313,9 +1779,7 @@ dbxout_type (tree type, int full)
 #endif
 
   /* Output a definition now.  */
-
-  fprintf (asmfile, "=");
-  CHARS (1);
+  stabstr_C ('=');
 
   /* Mark it as defined, so that if it is self-referent
      we will not get into an infinite recursion of definitions.  */
@@ -1327,15 +1791,13 @@ dbxout_type (tree type, int full)
      cv-qualified types if we're using extensions.  */
   if (TYPE_READONLY (type) > TYPE_READONLY (main_variant))
     {
-      putc ('k', asmfile);
-      CHARS (1);
+      stabstr_C ('k');
       dbxout_type (build_type_variant (type, 0, TYPE_VOLATILE (type)), 0);
       return;
     }
   else if (TYPE_VOLATILE (type) > TYPE_VOLATILE (main_variant))
     {
-      putc ('B', asmfile);
-      CHARS (1);
+      stabstr_C ('B');
       dbxout_type (build_type_variant (type, TYPE_READONLY (type), 0), 0);
       return;
     }
@@ -1363,7 +1825,7 @@ dbxout_type (tree type, int full)
     {
     case VOID_TYPE:
     case LANG_TYPE:
-      /* For a void type, just define it as itself; ie, "5=5".
+      /* For a void type, just define it as itself; i.e., "5=5".
 	 This makes us consider it defined
 	 without saying what it is.  The debugger will make it
 	 a void type when the reference is seen, and nothing will
@@ -1372,18 +1834,16 @@ dbxout_type (tree type, int full)
       break;
 
     case INTEGER_TYPE:
-      if (type == char_type_node && ! TREE_UNSIGNED (type))
+      if (type == char_type_node && ! TYPE_UNSIGNED (type))
 	{
 	  /* Output the type `char' as a subrange of itself!
 	     I don't understand this definition, just copied it
 	     from the output of pcc.
 	     This used to use `r2' explicitly and we used to
 	     take care to make sure that `char' was type number 2.  */
-	  fprintf (asmfile, "r");
-	  CHARS (1);
+	  stabstr_C ('r');
 	  dbxout_type_index (type);
-	  fprintf (asmfile, ";0;127;");
-	  CHARS (7);
+	  stabstr_S (";0;127;");
 	}
 
       /* If this is a subtype of another integer type, always prefer to
@@ -1397,9 +1857,9 @@ dbxout_type (tree type, int full)
 	  if (use_gnu_debug_info_extensions
 	      && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
 	    {
-	      have_used_extensions = 1;
-	      fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
-	      CHARS (5);
+	      stabstr_S ("@s");
+	      stabstr_D (TYPE_PRECISION (type));
+	      stabstr_C (';');
 	    }
 
 	  dbxout_range_type (type);
@@ -1413,15 +1873,14 @@ dbxout_type (tree type, int full)
 	  if (use_gnu_debug_info_extensions
 	      && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
 	    {
-	      have_used_extensions = 1;
-	      fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
-	      CHARS (5);
+	      stabstr_S ("@s");
+	      stabstr_D (TYPE_PRECISION (type));
+	      stabstr_C (';');
 	    }
 
 	  if (print_int_cst_bounds_in_octal_p (type))
 	    {
-	      fprintf (asmfile, "r");
-	      CHARS (1);
+	      stabstr_C ('r');
 
               /* If this type derives from another type, output type index of
 		 parent type. This is particularly important when parent type
@@ -1433,14 +1892,11 @@ dbxout_type (tree type, int full)
               else
                 dbxout_type_index (type);
 
-	      fprintf (asmfile, ";");
-	      CHARS (1);
-	      print_int_cst_octal (TYPE_MIN_VALUE (type));
-	      fprintf (asmfile, ";");
-	      CHARS (1);
-	      print_int_cst_octal (TYPE_MAX_VALUE (type));
-	      fprintf (asmfile, ";");
-	      CHARS (1);
+	      stabstr_C (';');
+	      stabstr_O (TYPE_MIN_VALUE (type));
+	      stabstr_C (';');
+	      stabstr_O (TYPE_MAX_VALUE (type));
+	      stabstr_C (';');
 	    }
 
 	  else
@@ -1453,59 +1909,22 @@ dbxout_type (tree type, int full)
     case REAL_TYPE:
       /* This used to say `r1' and we used to take care
 	 to make sure that `int' was type number 1.  */
-      fprintf (asmfile, "r");
-      CHARS (1);
+      stabstr_C ('r');
       dbxout_type_index (integer_type_node);
-      putc (';', asmfile);
-      CHARS (1);
-      print_wide_int (int_size_in_bytes (type));
-      fputs (";0;", asmfile);
-      CHARS (3);
-      break;
-
-    case CHAR_TYPE:
-      if (use_gnu_debug_info_extensions)
-	{
-	  have_used_extensions = 1;
-	  fputs ("@s", asmfile);
-	  CHARS (2);
-	  print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
-	  fputs (";-20;", asmfile);
-	  CHARS (4);
-	}
-      else
-	{
-	  /* Output the type `char' as a subrange of itself.
-	     That is what pcc seems to do.  */
-	  fprintf (asmfile, "r");
-	  CHARS (1);
-	  dbxout_type_index (char_type_node);
-	  fprintf (asmfile, ";0;%d;", TREE_UNSIGNED (type) ? 255 : 127);
-	  CHARS (7);
-	}
+      stabstr_C (';');
+      stabstr_D (int_size_in_bytes (type));
+      stabstr_S (";0;");
       break;
 
     case BOOLEAN_TYPE:
       if (use_gnu_debug_info_extensions)
 	{
-	  have_used_extensions = 1;
-	  fputs ("@s", asmfile);
-	  CHARS (2);
-	  print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
-	  fputs (";-16;", asmfile);
-	  CHARS (4);
+	  stabstr_S ("@s");
+	  stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type));
+	  stabstr_S (";-16;");
 	}
       else /* Define as enumeral type (False, True) */
-	{
-	  fprintf (asmfile, "eFalse:0,True:1,;");
-	  CHARS (17);
-	}
-      break;
-
-    case FILE_TYPE:
-      putc ('d', asmfile);
-      CHARS (1);
-      dbxout_type (TREE_TYPE (type), 0);
+	stabstr_S ("eFalse:0,True:1,;");
       break;
 
     case COMPLEX_TYPE:
@@ -1515,71 +1934,46 @@ dbxout_type (tree type, int full)
 
       if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
 	{
-	  fputs ("R3;", asmfile);
-	  CHARS (3);
-	  print_wide_int (2 * int_size_in_bytes (TREE_TYPE (type)));
-	  fputs (";0;", asmfile);
-	  CHARS (3);
+	  stabstr_S ("R3;");
+	  stabstr_D (2 * int_size_in_bytes (TREE_TYPE (type)));
+	  stabstr_S (";0;");
 	}
       else
 	{
 	  /* Output a complex integer type as a structure,
 	     pending some other way to do it.  */
-	  putc ('s', asmfile);
-	  CHARS (1);
-	  print_wide_int (int_size_in_bytes (type));
-	  fprintf (asmfile, "real:");
-	  CHARS (5);
+	  stabstr_C ('s');
+	  stabstr_D (int_size_in_bytes (type));
 
+	  stabstr_S ("real:");
 	  dbxout_type (TREE_TYPE (type), 0);
-	  fprintf (asmfile, ",0,%d;", TYPE_PRECISION (TREE_TYPE (type)));
-	  CHARS (7);
-	  fprintf (asmfile, "imag:");
-	  CHARS (5);
-	  dbxout_type (TREE_TYPE (type), 0);
-	  fprintf (asmfile, ",%d,%d;;", TYPE_PRECISION (TREE_TYPE (type)),
-		   TYPE_PRECISION (TREE_TYPE (type)));
-	  CHARS (10);
-	}
-      break;
+	  stabstr_S (",0,");
+	  stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
 
-    case SET_TYPE:
-      if (use_gnu_debug_info_extensions)
-	{
-	  have_used_extensions = 1;
-	  fputs ("@s", asmfile);
-	  CHARS (2);
-	  print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
-	  putc (';', asmfile);
-	  CHARS (1);
-
-	  /* Check if a bitstring type, which in Chill is
-	     different from a [power]set.  */
-	  if (TYPE_STRING_FLAG (type))
-	    {
-	      fprintf (asmfile, "@S;");
-	      CHARS (3);
-	    }
+	  stabstr_S (";imag:");
+	  dbxout_type (TREE_TYPE (type), 0);
+	  stabstr_C (',');
+	  stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
+	  stabstr_C (',');
+	  stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
+	  stabstr_S (";;");
 	}
-      putc ('S', asmfile);
-      CHARS (1);
-      dbxout_type (TYPE_DOMAIN (type), 0);
       break;
 
     case ARRAY_TYPE:
       /* Make arrays of packed bits look like bitstrings for chill.  */
       if (TYPE_PACKED (type) && use_gnu_debug_info_extensions)
 	{
-	  have_used_extensions = 1;
-	  fputs ("@s", asmfile);
-	  CHARS (2);
-	  print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
-	  fprintf (asmfile, ";@S;S");
-	  CHARS (5);
+	  stabstr_S ("@s");
+	  stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type));
+	  stabstr_S (";@S;S");
 	  dbxout_type (TYPE_DOMAIN (type), 0);
 	  break;
 	}
 
+      if (use_gnu_debug_info_extensions && vector_type)
+	stabstr_S ("@V;");
+
       /* Output "a" followed by a range type definition
 	 for the index type of the array
 	 followed by a reference to the target-type.
@@ -1588,23 +1982,18 @@ dbxout_type (tree type, int full)
 	 different from an array of characters.  */
       if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions)
 	{
-	  have_used_extensions = 1;
-	  fprintf (asmfile, "@S;");
-	  CHARS (3);
+	  stabstr_S ("@S;");
 	}
       tem = TYPE_DOMAIN (type);
       if (tem == NULL)
 	{
-	  fprintf (asmfile, "ar");
-	  CHARS (2);
+	  stabstr_S ("ar");
 	  dbxout_type_index (integer_type_node);
-	  fprintf (asmfile, ";0;-1;");
-	  CHARS (6);
+	  stabstr_S (";0;-1;");
 	}
       else
 	{
-	  fprintf (asmfile, "a");
-	  CHARS (1);
+	  stabstr_C ('a');
 	  dbxout_range_type (tem);
 	}
 
@@ -1615,12 +2004,7 @@ dbxout_type (tree type, int full)
     case UNION_TYPE:
     case QUAL_UNION_TYPE:
       {
-	int i, n_baseclasses = 0;
-
-	if (TYPE_BINFO (type) != 0
-	    && TREE_CODE (TYPE_BINFO (type)) == TREE_VEC
-	    && TYPE_BINFO_BASETYPES (type) != 0)
-	  n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type));
+	tree binfo = TYPE_BINFO (type);
 
 	/* Output a structure type.  We must use the same test here as we
 	   use in the DBX_NO_XREFS case above.  */
@@ -1639,93 +2023,83 @@ dbxout_type (tree type, int full)
 	       If the type has a name, don't nest its definition within
 	       another type's definition; instead, output an xref
 	       and let the definition come when the name is defined.  */
-	    fputs ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu", asmfile);
-	    CHARS (2);
-#if 0 /* This assertion is legitimately false in C++.  */
-	    /* We shouldn't be outputting a reference to a type before its
-	       definition unless the type has a tag name.
-	       A typedef name without a tag name should be impossible.  */
-	    if (TREE_CODE (TYPE_NAME (type)) != IDENTIFIER_NODE)
-	      abort ();
-#endif
+	    stabstr_S ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu");
 	    if (TYPE_NAME (type) != 0)
 	      dbxout_type_name (type);
 	    else
 	      {
-		fprintf (asmfile, "$$%d", anonymous_type_number++);
-		CHARS (5);
+		stabstr_S ("$$");
+		stabstr_D (anonymous_type_number++);
 	      }
 
-	    fprintf (asmfile, ":");
-	    CHARS (1);
+	    stabstr_C (':');
 	    typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
 	    break;
 	  }
 
 	/* Identify record or union, and print its size.  */
-	putc (((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u'), asmfile);
-	CHARS (1);
-	print_wide_int (int_size_in_bytes (type));
+	stabstr_C ((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u');
+	stabstr_D (int_size_in_bytes (type));
 
-	if (use_gnu_debug_info_extensions)
+	if (binfo)
 	  {
-	    if (n_baseclasses)
-	      {
-		have_used_extensions = 1;
-		fprintf (asmfile, "!%d,", n_baseclasses);
-		CHARS (8);
-	      }
-	  }
-	for (i = 0; i < n_baseclasses; i++)
-	  {
-	    tree binfo = TYPE_BINFO (type);
-	    tree child = BINFO_BASETYPE (binfo, i);
-	    tree access = (BINFO_BASEACCESSES (binfo)
-			   ? BINFO_BASEACCESS (binfo, i) : access_public_node);
-
+	    int i;
+	    tree child;
+	    VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
+	    
 	    if (use_gnu_debug_info_extensions)
 	      {
-		have_used_extensions = 1;
-                putc (TREE_VIA_VIRTUAL (child) ? '1' : '0', asmfile);
-                putc (access == access_public_node ? '2' :
-                      (access == access_protected_node ? '1' :'0'),
-                      asmfile);
-		CHARS (2);
-		if (TREE_VIA_VIRTUAL (child)
-		    && strcmp (lang_hooks.name, "GNU C++") == 0)
-		  /* For a virtual base, print the (negative) offset within
-		     the vtable where we must look to find the necessary
-		     adjustment.  */
-		  print_wide_int (tree_low_cst (BINFO_VPTR_FIELD (child), 0)
-				  * BITS_PER_UNIT);
-		else
-		  print_wide_int (tree_low_cst (BINFO_OFFSET (child), 0)
-				  * BITS_PER_UNIT);
-		putc (',', asmfile);
-		CHARS (1);
-		dbxout_type (BINFO_TYPE (child), 0);
-		putc (';', asmfile);
-		CHARS (1);
+		if (BINFO_N_BASE_BINFOS (binfo))
+		  {
+		    stabstr_C ('!');
+		    stabstr_U (BINFO_N_BASE_BINFOS (binfo));
+		    stabstr_C (',');
+		  }
 	      }
-	    else
+	    for (i = 0; BINFO_BASE_ITERATE (binfo, i, child); i++)
 	      {
-		/* Print out the base class information with fields
-		   which have the same names at the types they hold.  */
-		dbxout_type_name (BINFO_TYPE (child));
-		putc (':', asmfile);
-		CHARS (1);
-		dbxout_type (BINFO_TYPE (child), full);
-		putc (',', asmfile);
-		CHARS (1);
-		print_wide_int (tree_low_cst (BINFO_OFFSET (child), 0)
-				* BITS_PER_UNIT);
-		putc (',', asmfile);
-		CHARS (1);
-		print_wide_int (tree_low_cst (TYPE_SIZE (BINFO_TYPE (child)),
-					      0)
-				* BITS_PER_UNIT);
-		putc (';', asmfile);
-		CHARS (1);
+		tree access = (accesses ? VEC_index (tree, accesses, i)
+			       : access_public_node);
+
+		if (use_gnu_debug_info_extensions)
+		  {
+		    stabstr_C (BINFO_VIRTUAL_P (child) ? '1' : '0');
+		    stabstr_C (access == access_public_node ? '2' :
+				   access == access_protected_node
+				   ? '1' :'0');
+		    if (BINFO_VIRTUAL_P (child)
+			&& (strcmp (lang_hooks.name, "GNU C++") == 0
+			    || strcmp (lang_hooks.name, "GNU Objective-C++") == 0))
+		      /* For a virtual base, print the (negative)
+		     	 offset within the vtable where we must look
+		     	 to find the necessary adjustment.  */
+		      stabstr_D
+			(tree_low_cst (BINFO_VPTR_FIELD (child), 0)
+			 * BITS_PER_UNIT);
+		    else
+		      stabstr_D (tree_low_cst (BINFO_OFFSET (child), 0)
+				       * BITS_PER_UNIT);
+		    stabstr_C (',');
+		    dbxout_type (BINFO_TYPE (child), 0);
+		    stabstr_C (';');
+		  }
+		else
+		  {
+		    /* Print out the base class information with
+		       fields which have the same names at the types
+		       they hold.  */
+		    dbxout_type_name (BINFO_TYPE (child));
+		    stabstr_C (':');
+		    dbxout_type (BINFO_TYPE (child), full);
+		    stabstr_C (',');
+		    stabstr_D (tree_low_cst (BINFO_OFFSET (child), 0)
+				     * BITS_PER_UNIT);
+		    stabstr_C (',');
+		    stabstr_D
+		      (tree_low_cst (TYPE_SIZE (BINFO_TYPE (child)), 0)
+		       * BITS_PER_UNIT);
+		    stabstr_C (';');
+		  }
 	      }
 	  }
       }
@@ -1734,36 +2108,23 @@ dbxout_type (tree type, int full)
       dbxout_type_fields (type);
       if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
 	{
-	  have_used_extensions = 1;
 	  dbxout_type_methods (type);
 	}
 
-      putc (';', asmfile);
-      CHARS (1);
+      stabstr_C (';');
 
       if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
 	  /* Avoid the ~ if we don't really need it--it confuses dbx.  */
 	  && TYPE_VFIELD (type))
 	{
-	  have_used_extensions = 1;
-
-	  /* Tell GDB+ that it may keep reading.  */
-	  putc ('~', asmfile);
-	  CHARS (1);
 
 	  /* We need to write out info about what field this class
 	     uses as its "main" vtable pointer field, because if this
 	     field is inherited from a base class, GDB cannot necessarily
 	     figure out which field it's using in time.  */
-	  if (TYPE_VFIELD (type))
-	    {
-	      putc ('%', asmfile);
-	      CHARS (1);
-	      dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0);
-	    }
-
-	  putc (';', asmfile);
-	  CHARS (1);
+	  stabstr_S ("~%");
+	  dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0);
+	  stabstr_C (';');
 	}
       break;
 
@@ -1777,66 +2138,58 @@ dbxout_type (tree type, int full)
 	   && !full)
 	  || !COMPLETE_TYPE_P (type))
 	{
-	  fprintf (asmfile, "xe");
-	  CHARS (2);
+	  stabstr_S ("xe");
 	  dbxout_type_name (type);
 	  typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
-	  putc (':', asmfile);
-	  CHARS (1);
+	  stabstr_C (':');
 	  return;
 	}
       if (use_gnu_debug_info_extensions
 	  && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
 	{
-	  fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
-	  CHARS (5);
+	  stabstr_S ("@s");
+	  stabstr_D (TYPE_PRECISION (type));
+	  stabstr_C (';');
 	}
 
-      putc ('e', asmfile);
-      CHARS (1);
+      stabstr_C ('e');
       for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
 	{
-	  fprintf (asmfile, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
-	  CHARS (IDENTIFIER_LENGTH (TREE_PURPOSE (tem)) + 1);
+	  stabstr_I (TREE_PURPOSE (tem));
+	  stabstr_C (':');
+
 	  if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == 0)
-	    print_wide_int (TREE_INT_CST_LOW (TREE_VALUE (tem)));
+	    stabstr_D (TREE_INT_CST_LOW (TREE_VALUE (tem)));
 	  else if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == -1
 		   && (HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0)
-	    print_wide_int (TREE_INT_CST_LOW (TREE_VALUE (tem)));
+	    stabstr_D (TREE_INT_CST_LOW (TREE_VALUE (tem)));
 	  else
-	    print_int_cst_octal (TREE_VALUE (tem));
+	    stabstr_O (TREE_VALUE (tem));
 
-	  putc (',', asmfile);
-	  CHARS (1);
+	  stabstr_C (',');
 	  if (TREE_CHAIN (tem) != 0)
 	    CONTIN;
 	}
 
-      putc (';', asmfile);
-      CHARS (1);
+      stabstr_C (';');
       break;
 
     case POINTER_TYPE:
-      putc ('*', asmfile);
-      CHARS (1);
+      stabstr_C ('*');
       dbxout_type (TREE_TYPE (type), 0);
       break;
 
     case METHOD_TYPE:
       if (use_gnu_debug_info_extensions)
 	{
-	  have_used_extensions = 1;
-	  putc ('#', asmfile);
-	  CHARS (1);
+	  stabstr_C ('#');
 
 	  /* Write the argument types out longhand.  */
 	  dbxout_type (TYPE_METHOD_BASETYPE (type), 0);
-	  putc (',', asmfile);
-	  CHARS (1);
+	  stabstr_C (',');
 	  dbxout_type (TREE_TYPE (type), 0);
 	  dbxout_args (TYPE_ARG_TYPES (type));
-	  putc (';', asmfile);
-	  CHARS (1);
+	  stabstr_C (';');
 	}
       else
 	/* Treat it as a function type.  */
@@ -1846,12 +2199,9 @@ dbxout_type (tree type, int full)
     case OFFSET_TYPE:
       if (use_gnu_debug_info_extensions)
 	{
-	  have_used_extensions = 1;
-	  putc ('@', asmfile);
-	  CHARS (1);
+	  stabstr_C ('@');
 	  dbxout_type (TYPE_OFFSET_BASETYPE (type), 0);
-	  putc (',', asmfile);
-	  CHARS (1);
+	  stabstr_C (',');
 	  dbxout_type (TREE_TYPE (type), 0);
 	}
       else
@@ -1861,20 +2211,21 @@ dbxout_type (tree type, int full)
 
     case REFERENCE_TYPE:
       if (use_gnu_debug_info_extensions)
-	have_used_extensions = 1;
-      putc (use_gnu_debug_info_extensions ? '&' : '*', asmfile);
-      CHARS (1);
+	{
+	  stabstr_C ('&');
+	}
+      else
+	stabstr_C ('*');
       dbxout_type (TREE_TYPE (type), 0);
       break;
 
     case FUNCTION_TYPE:
-      putc ('f', asmfile);
-      CHARS (1);
+      stabstr_C ('f');
       dbxout_type (TREE_TYPE (type), 0);
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
@@ -1902,145 +2253,199 @@ print_int_cst_bounds_in_octal_p (tree type)
       && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST
       && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
 	  || ((TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
-	      && TREE_UNSIGNED (type))
+	      && TYPE_UNSIGNED (type))
 	  || TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT
 	  || (TYPE_PRECISION (type) == HOST_BITS_PER_WIDE_INT
-	      && TREE_UNSIGNED (type))))
+	      && TYPE_UNSIGNED (type))))
     return TRUE;
   else
     return FALSE;
 }
 
-/* Print the value of integer constant C, in octal,
-   handling double precision.  */
+/* Output the name of type TYPE, with no punctuation.
+   Such names can be set up either by typedef declarations
+   or by struct, enum and union tags.  */
 
 static void
-print_int_cst_octal (tree c)
+dbxout_type_name (tree type)
 {
-  unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (c);
-  unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (c);
-  int excess = (3 - (HOST_BITS_PER_WIDE_INT % 3));
-  unsigned int width = TYPE_PRECISION (TREE_TYPE (c));
+  tree t = TYPE_NAME (type);
+  
+  gcc_assert (t);
+  switch (TREE_CODE (t))
+    {
+    case IDENTIFIER_NODE:
+      break;
+    case TYPE_DECL:
+      t = DECL_NAME (t);
+      break;
+    default:
+      gcc_unreachable ();
+    }
 
-  /* GDB wants constants with no extra leading "1" bits, so
-     we need to remove any sign-extension that might be
-     present.  */
-  if (width == HOST_BITS_PER_WIDE_INT * 2)
-    ;
-  else if (width > HOST_BITS_PER_WIDE_INT)
-    high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1);
-  else if (width == HOST_BITS_PER_WIDE_INT)
-    high = 0;
-  else
-    high = 0, low &= (((HOST_WIDE_INT) 1 << width) - 1);
+  stabstr_I (t);
+}
+
+/* Output leading leading struct or class names needed for qualifying
+   type whose scope is limited to a struct or class.  */
 
-  fprintf (asmfile, "0");
-  CHARS (1);
+static void
+dbxout_class_name_qualifiers (tree decl)
+{
+  tree context = decl_type_context (decl);
 
-  if (excess == 3)
-    {
-      print_octal (high, HOST_BITS_PER_WIDE_INT / 3);
-      print_octal (low, HOST_BITS_PER_WIDE_INT / 3);
-    }
-  else
+  if (context != NULL_TREE
+      && TREE_CODE(context) == RECORD_TYPE
+      && TYPE_NAME (context) != 0
+      && (TREE_CODE (TYPE_NAME (context)) == IDENTIFIER_NODE
+          || (DECL_NAME (TYPE_NAME (context)) != 0)))
     {
-      unsigned HOST_WIDE_INT beg = high >> excess;
-      unsigned HOST_WIDE_INT middle
-	= ((high & (((HOST_WIDE_INT) 1 << excess) - 1)) << (3 - excess)
-	   | (low >> (HOST_BITS_PER_WIDE_INT / 3 * 3)));
-      unsigned HOST_WIDE_INT end
-	= low & (((unsigned HOST_WIDE_INT) 1
-		  << (HOST_BITS_PER_WIDE_INT / 3 * 3))
-		 - 1);
-
-      fprintf (asmfile, "%o%01o", (int) beg, (int) middle);
-      CHARS (2);
-      print_octal (end, HOST_BITS_PER_WIDE_INT / 3);
+      tree name = TYPE_NAME (context);
+
+      if (TREE_CODE (name) == TYPE_DECL)
+	{
+	  dbxout_class_name_qualifiers (name);
+	  name = DECL_NAME (name);
+	}
+      stabstr_I (name);
+      stabstr_S ("::");
     }
 }
+
+/* This is a specialized subset of expand_expr for use by dbxout_symbol in
+   evaluating DECL_VALUE_EXPR.  In particular, we stop if we find decls that
+   havn't been expanded, or if the expression is getting so complex we won't
+   be able to represent it in stabs anyway.  Returns NULL on failure.  */
 
-static void
-print_octal (unsigned HOST_WIDE_INT value, int digits)
+static rtx
+dbxout_expand_expr (tree expr)
 {
-  int i;
+  switch (TREE_CODE (expr))
+    {
+    case VAR_DECL:
+    case PARM_DECL:
+      if (DECL_HAS_VALUE_EXPR_P (expr))
+	return dbxout_expand_expr (DECL_VALUE_EXPR (expr));
+      /* FALLTHRU */
 
-  for (i = digits - 1; i >= 0; i--)
-    fprintf (asmfile, "%01o", (int) ((value >> (3 * i)) & 7));
+    case CONST_DECL:
+    case RESULT_DECL:
+      return DECL_RTL_IF_SET (expr);
 
-  CHARS (digits);
-}
+    case INTEGER_CST:
+      return expand_expr (expr, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
 
-/* Output C in decimal while adjusting the number of digits written.  */
+    case COMPONENT_REF:
+    case ARRAY_REF:
+    case ARRAY_RANGE_REF:
+    case BIT_FIELD_REF:
+      {
+	enum machine_mode mode;
+	HOST_WIDE_INT bitsize, bitpos;
+	tree offset, tem;
+	int volatilep = 0, unsignedp = 0;
+	rtx x;
+
+	tem = get_inner_reference (expr, &bitsize, &bitpos, &offset,
+				   &mode, &unsignedp, &volatilep, true);
+
+	x = dbxout_expand_expr (tem);
+	if (x == NULL || !MEM_P (x))
+	  return NULL;
+	if (offset != NULL)
+	  {
+	    if (!host_integerp (offset, 0))
+	      return NULL;
+	    x = adjust_address_nv (x, mode, tree_low_cst (offset, 0));
+	  }
+	if (bitpos != 0)
+	  x = adjust_address_nv (x, mode, bitpos / BITS_PER_UNIT);
 
-static void
-print_wide_int (HOST_WIDE_INT c)
-{
-  int digs = 0;
+	return x;
+      }
 
-  fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, c);
+    default:
+      return NULL;
+    }
+}
 
-  if (c < 0)
-    digs++, c = -c;
+/* Helper function for output_used_types.  Queue one entry from the
+   used types hash to be output.  */
 
-  while (c > 0)
-    c /= 10; digs++;
+static int
+output_used_types_helper (void **slot, void *data)
+{
+  tree type = *slot;
+  VEC(tree, heap) **types_p = data;
 
-  CHARS (digs);
+  if ((TREE_CODE (type) == RECORD_TYPE
+       || TREE_CODE (type) == UNION_TYPE
+       || TREE_CODE (type) == QUAL_UNION_TYPE
+       || TREE_CODE (type) == ENUMERAL_TYPE)
+      && TYPE_STUB_DECL (type)
+      && DECL_P (TYPE_STUB_DECL (type))
+      && ! DECL_IGNORED_P (TYPE_STUB_DECL (type)))
+    VEC_quick_push (tree, *types_p, TYPE_STUB_DECL (type));
+  else if (TYPE_NAME (type)
+	   && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
+    VEC_quick_push (tree, *types_p, TYPE_NAME (type));
+
+  return 1;
 }
 
-/* Output the name of type TYPE, with no punctuation.
-   Such names can be set up either by typedef declarations
-   or by struct, enum and union tags.  */
+/* This is a qsort callback which sorts types and declarations into a
+   predictable order (types, then declarations, sorted by UID
+   within).  */
 
-static void
-dbxout_type_name (tree type)
+static int
+output_types_sort (const void *pa, const void *pb)
 {
-  tree t;
-  if (TYPE_NAME (type) == 0)
-    abort ();
-  if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
+  const tree lhs = *((const tree *)pa);
+  const tree rhs = *((const tree *)pb);
+
+  if (TYPE_P (lhs))
     {
-      t = TYPE_NAME (type);
+      if (TYPE_P (rhs))
+	return TYPE_UID (lhs) - TYPE_UID (rhs);
+      else
+	return 1;
     }
-  else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
+  else
     {
-      t = DECL_NAME (TYPE_NAME (type));
+      if (TYPE_P (rhs))
+	return -1;
+      else
+	return DECL_UID (lhs) - DECL_UID (rhs);
     }
-  else
-    abort ();
-
-  fprintf (asmfile, "%s", IDENTIFIER_POINTER (t));
-  CHARS (IDENTIFIER_LENGTH (t));
 }
 
-/* Output leading leading struct or class names needed for qualifying
-   type whose scope is limited to a struct or class.  */
+
+/* Force all types used by this function to be output in debug
+   information.  */
 
 static void
-dbxout_class_name_qualifiers (tree decl)
+output_used_types (void)
 {
-  tree context = decl_type_context (decl);
-
-  if (context != NULL_TREE
-      && TREE_CODE(context) == RECORD_TYPE
-      && TYPE_NAME (context) != 0
-      && (TREE_CODE (TYPE_NAME (context)) == IDENTIFIER_NODE
-          || (DECL_NAME (TYPE_NAME (context)) != 0)))
+  if (cfun && cfun->used_types_hash)
     {
-      tree name = TYPE_NAME (context);
+      VEC(tree, heap) *types;
+      int i;
+      tree type;
 
-      emit_pending_bincls_if_required ();
+      types = VEC_alloc (tree, heap, htab_elements (cfun->used_types_hash));
+      htab_traverse (cfun->used_types_hash, output_used_types_helper, &types);
 
-      if (TREE_CODE (name) == TYPE_DECL)
-	{
-	  dbxout_class_name_qualifiers (name);
-	  name = DECL_NAME (name);
-	}
-      fprintf (asmfile, "%s::", IDENTIFIER_POINTER (name));
-      CHARS (IDENTIFIER_LENGTH (name) + 2);
+      /* Sort by UID to prevent dependence on hash table ordering.  */
+      qsort (VEC_address (tree, types), VEC_length (tree, types),
+	     sizeof (tree), output_types_sort);
+
+      for (i = 0; VEC_iterate (tree, types, i, type); i++)
+	debug_queue_symbol (type);
+
+      VEC_free (tree, heap, types);
     }
 }
-
+
 /* Output a .stabs for the symbol defined by DECL,
    which must be a ..._DECL node in the normal namespace.
    It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
@@ -2053,6 +2458,7 @@ dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED)
   tree type = TREE_TYPE (decl);
   tree context = NULL_TREE;
   int result = 0;
+  rtx decl_rtl;
 
   /* "Intercept" dbxout_symbol() calls like we do all debug_hooks.  */
   ++debug_nesting;
@@ -2064,22 +2470,30 @@ dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED)
     DBXOUT_DECR_NESTING_AND_RETURN (0);
 
   /* If we are to generate only the symbols actually used then such
-     symbol nodees are flagged with TREE_USED.  Ignore any that
+     symbol nodes are flagged with TREE_USED.  Ignore any that
      aren't flaged as TREE_USED.  */
 
+  if (flag_debug_only_used_symbols
+      && (!TREE_USED (decl)
+          && (TREE_CODE (decl) != VAR_DECL || !DECL_INITIAL (decl))))
+    DBXOUT_DECR_NESTING_AND_RETURN (0);
+
+  /* If dbxout_init has not yet run, queue this symbol for later.  */
+  if (!typevec)
+    {
+      preinit_symbols = tree_cons (0, decl, preinit_symbols);
+      DBXOUT_DECR_NESTING_AND_RETURN (0);
+    }
+
   if (flag_debug_only_used_symbols)
     {
       tree t;
 
-      if (!TREE_USED (decl)
-          && (TREE_CODE (decl) != VAR_DECL || !DECL_INITIAL (decl)))
-        DBXOUT_DECR_NESTING_AND_RETURN (0);
-
       /* We now have a used symbol.  We need to generate the info for
          the symbol's type in addition to the symbol itself.  These
          type symbols are queued to be generated after were done with
-         the symbol itself (done because the symbol's info is generated
-         with fprintf's, etc. as it determines what's needed).
+         the symbol itself (otherwise they would fight over the
+         stabstr obstack).
 
          Note, because the TREE_TYPE(type) might be something like a
          pointer to a named type we need to look for the first name
@@ -2096,38 +2510,32 @@ dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED)
          a different name.  In that case we also want to output
          that.  */
 
-      if ((TREE_CODE (t) == RECORD_TYPE
+      if (TREE_CODE (t) == RECORD_TYPE
            || TREE_CODE (t) == UNION_TYPE
            || TREE_CODE (t) == QUAL_UNION_TYPE
            || TREE_CODE (t) == ENUMERAL_TYPE)
-          && TYPE_STUB_DECL (t)
-          && TYPE_STUB_DECL (t) != decl
-          && TREE_CODE_CLASS (TREE_CODE (TYPE_STUB_DECL (t))) == 'd'
-          && ! DECL_IGNORED_P (TYPE_STUB_DECL (t)))
         {
-          debug_queue_symbol (TYPE_STUB_DECL (t));
-          if (TYPE_NAME (t)
-              && TYPE_NAME (t) != TYPE_STUB_DECL (t)
-              && TYPE_NAME (t) != decl
-              && TREE_CODE_CLASS (TREE_CODE (TYPE_NAME (t))) == 'd')
-            debug_queue_symbol (TYPE_NAME (t));
-        }
+	    if (TYPE_STUB_DECL (t)
+		&& TYPE_STUB_DECL (t) != decl
+		&& DECL_P (TYPE_STUB_DECL (t))
+		&& ! DECL_IGNORED_P (TYPE_STUB_DECL (t)))
+	    {
+	      debug_queue_symbol (TYPE_STUB_DECL (t));
+	      if (TYPE_NAME (t)
+		  && TYPE_NAME (t) != TYPE_STUB_DECL (t)
+		  && TYPE_NAME (t) != decl
+		  && DECL_P (TYPE_NAME (t)))
+		debug_queue_symbol (TYPE_NAME (t));
+	    }
+	}
       else if (TYPE_NAME (t)
 	       && TYPE_NAME (t) != decl
-	       && TREE_CODE_CLASS (TREE_CODE (TYPE_NAME (t))) == 'd')
+	       && DECL_P (TYPE_NAME (t)))
         debug_queue_symbol (TYPE_NAME (t));
     }
 
   emit_pending_bincls_if_required ();
 
-  dbxout_prepare_symbol (decl);
-
-  /* The output will always start with the symbol name,
-     so always count that in the length-output-so-far.  */
-
-  if (DECL_NAME (decl) != 0)
-    current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (decl));
-
   switch (TREE_CODE (decl))
     {
     case CONST_DECL:
@@ -2135,7 +2543,8 @@ dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED)
       break;
 
     case FUNCTION_DECL:
-      if (DECL_RTL (decl) == 0)
+      decl_rtl = DECL_RTL_IF_SET (decl);
+      if (!decl_rtl)
 	DBXOUT_DECR_NESTING_AND_RETURN (0);
       if (DECL_EXTERNAL (decl))
 	break;
@@ -2143,18 +2552,20 @@ dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED)
       context = decl_function_context (decl);
       if (context == current_function_decl)
 	break;
-      if (GET_CODE (DECL_RTL (decl)) != MEM
-	  || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
+      /* Don't mention an inline instance of a nested function.  */
+      if (context && DECL_FROM_INLINE (decl))
+	break;
+      if (!MEM_P (decl_rtl)
+	  || GET_CODE (XEXP (decl_rtl, 0)) != SYMBOL_REF)
 	break;
-      FORCE_TEXT;
 
-      fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
-	       IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
-	       TREE_PUBLIC (decl) ? 'F' : 'f');
-      result = 1;
+      if (flag_debug_only_used_symbols)
+	output_used_types ();
 
-      current_sym_code = N_FUN;
-      current_sym_addr = XEXP (DECL_RTL (decl), 0);
+      dbxout_begin_complex_stabs ();
+      stabstr_I (DECL_ASSEMBLER_NAME (decl));
+      stabstr_S (TREE_PUBLIC (decl) ? ":F" : ":f");
+      result = 1;
 
       if (TREE_TYPE (type))
 	dbxout_type (TREE_TYPE (type), 0);
@@ -2165,11 +2576,14 @@ dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED)
 	 mention the containing function name
 	 as well as (since dbx wants it) our own assembler-name.  */
       if (context != 0)
-	fprintf (asmfile, ",%s,%s",
-		 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
-		 IDENTIFIER_POINTER (DECL_NAME (context)));
+	{
+	  stabstr_C (',');
+	  stabstr_I (DECL_ASSEMBLER_NAME (decl));
+	  stabstr_C (',');
+	  stabstr_I (DECL_NAME (context));
+	}
 
-      dbxout_finish_symbol (decl);
+      dbxout_finish_complex_stabs (decl, N_FUN, XEXP (decl_rtl, 0), 0, 0);
       break;
 
     case TYPE_DECL:
@@ -2178,6 +2592,20 @@ dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED)
       if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl))
 	DBXOUT_DECR_NESTING_AND_RETURN (0);
 
+      /* Don't output typedefs for types with magic type numbers (XCOFF).  */
+#ifdef DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER
+      {
+	int fundamental_type_number =
+	  DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER (decl);
+
+	if (fundamental_type_number != 0)
+	  {
+	    TREE_ASM_WRITTEN (decl) = 1;
+	    TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl)) = fundamental_type_number;
+	    DBXOUT_DECR_NESTING_AND_RETURN (0);
+	  }
+      }
+#endif
       FORCE_TEXT;
       result = 1;
       {
@@ -2197,7 +2625,7 @@ dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED)
 		 || TREE_CODE (type) == UNION_TYPE
 		 || TREE_CODE (type) == QUAL_UNION_TYPE)
 		&& TYPE_NAME (type) == decl
-		&& !(use_gnu_debug_info_extensions && have_used_extensions)
+		&& !use_gnu_debug_info_extensions
 		&& !TREE_ASM_WRITTEN (TYPE_NAME (type))
 		/* Distinguish the implicit typedefs of C++
 		   from explicit ones that might be found in C.  */
@@ -2213,28 +2641,23 @@ dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED)
 		if (TREE_CODE (name) == TYPE_DECL)
 		  name = DECL_NAME (name);
 
-		current_sym_code = DBX_TYPE_DECL_STABS_CODE;
-		current_sym_value = 0;
-		current_sym_addr = 0;
-		current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
-
-		fprintf (asmfile, "%s\"%s:T", ASM_STABS_OP,
-			 IDENTIFIER_POINTER (name));
+		dbxout_begin_complex_stabs ();
+		stabstr_I (name);
+		stabstr_S (":T");
 		dbxout_type (type, 1);
-		dbxout_finish_symbol (NULL_TREE);
+		dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE,
+					     0, 0, 0);
 	      }
 
-	    /* Output .stabs (or whatever) and leading double quote.  */
-	    fprintf (asmfile, "%s\"", ASM_STABS_OP);
+	    dbxout_begin_complex_stabs ();
 
+	    /* Output leading class/struct qualifiers.  */
 	    if (use_gnu_debug_info_extensions)
-	      {
-		/* Output leading class/struct qualifiers.  */
-		dbxout_class_name_qualifiers (decl);
-	      }
+	      dbxout_class_name_qualifiers (decl);
 
 	    /* Output typedef name.  */
-	    fprintf (asmfile, "%s:", IDENTIFIER_POINTER (DECL_NAME (decl)));
+	    stabstr_I (DECL_NAME (decl));
+	    stabstr_C (':');
 
 	    /* Short cut way to output a tag also.  */
 	    if ((TREE_CODE (type) == RECORD_TYPE
@@ -2245,22 +2668,17 @@ dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED)
 		   from explicit ones that might be found in C.  */
 		&& DECL_ARTIFICIAL (decl))
 	      {
-		if (use_gnu_debug_info_extensions && have_used_extensions)
+		if (use_gnu_debug_info_extensions)
 		  {
-		    putc ('T', asmfile);
+		    stabstr_C ('T');
 		    TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
 		  }
-#if 0 /* Now we generate the tag for this case up above.  */
-		else
-		  tag_needed = 1;
-#endif
 	      }
 
-	    putc ('t', asmfile);
-	    current_sym_code = DBX_TYPE_DECL_STABS_CODE;
-
+	    stabstr_C ('t');
 	    dbxout_type (type, 1);
-	    dbxout_finish_symbol (decl);
+	    dbxout_finish_complex_stabs (decl, DBX_TYPE_DECL_STABS_CODE,
+					 0, 0, 0);
 	    did_output = 1;
 	  }
 
@@ -2282,33 +2700,26 @@ dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED)
 	    if (TREE_CODE (name) == TYPE_DECL)
 	      name = DECL_NAME (name);
 
-	    current_sym_code = DBX_TYPE_DECL_STABS_CODE;
-	    current_sym_value = 0;
-	    current_sym_addr = 0;
-	    current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
-
-	    fprintf (asmfile, "%s\"%s:T", ASM_STABS_OP,
-		     IDENTIFIER_POINTER (name));
+	    dbxout_begin_complex_stabs ();
+	    stabstr_I (name);
+	    stabstr_S (":T");
 	    dbxout_type (type, 1);
-	    dbxout_finish_symbol (NULL_TREE);
+	    dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 0, 0, 0);
 	    did_output = 1;
 	  }
 
-	/* If an enum type has no name, it cannot be referred to,
-	   but we must output it anyway, since the enumeration constants
-	   can be referred to.  */
+	/* If an enum type has no name, it cannot be referred to, but
+	   we must output it anyway, to record the enumeration
+	   constants.  */
+
 	if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE)
 	  {
-	    current_sym_code = DBX_TYPE_DECL_STABS_CODE;
-	    current_sym_value = 0;
-	    current_sym_addr = 0;
-	    current_sym_nchars = 2;
-
+	    dbxout_begin_complex_stabs ();
 	    /* Some debuggers fail when given NULL names, so give this a
-	       harmless name of ` '.  */
-	    fprintf (asmfile, "%s\" :T", ASM_STABS_OP);
+	       harmless name of " " (Why not "(anon)"?).  */
+	    stabstr_S (" :T");
 	    dbxout_type (type, 1);
-	    dbxout_finish_symbol (NULL_TREE);
+	    dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 0, 0, 0);
 	  }
 
 	/* Prevent duplicate output of a typedef.  */
@@ -2319,58 +2730,59 @@ dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED)
     case PARM_DECL:
       /* Parm decls go in their own separate chains
 	 and are output by dbxout_reg_parms and dbxout_parms.  */
-      abort ();
+      gcc_unreachable ();
 
     case RESULT_DECL:
-      /* Named return value, treat like a VAR_DECL.  */
     case VAR_DECL:
-      if (! DECL_RTL_SET_P (decl))
-	DBXOUT_DECR_NESTING_AND_RETURN (0);
       /* Don't mention a variable that is external.
 	 Let the file that defines it describe it.  */
       if (DECL_EXTERNAL (decl))
 	break;
 
       /* If the variable is really a constant
-	 and not written in memory, inform the debugger.  */
+	 and not written in memory, inform the debugger.
+
+	 ??? Why do we skip emitting the type and location in this case?  */
       if (TREE_STATIC (decl) && TREE_READONLY (decl)
 	  && DECL_INITIAL (decl) != 0
 	  && host_integerp (DECL_INITIAL (decl), 0)
 	  && ! TREE_ASM_WRITTEN (decl)
 	  && (DECL_CONTEXT (decl) == NULL_TREE
-	      || TREE_CODE (DECL_CONTEXT (decl)) == BLOCK))
+	      || TREE_CODE (DECL_CONTEXT (decl)) == BLOCK
+	      || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
+	  && TREE_PUBLIC (decl) == 0)
 	{
-	  if (TREE_PUBLIC (decl) == 0)
-	    {
-	      /* The sun4 assembler does not grok this.  */
-	      const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
+	  /* The sun4 assembler does not grok this.  */
 
-	      if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
-		  || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
-		{
-		  HOST_WIDE_INT ival = tree_low_cst (DECL_INITIAL (decl), 0);
-		  fprintf (asmfile, "%s\"%s:c=i" HOST_WIDE_INT_PRINT_DEC
-			   "\",0x%x,0,0,0\n",
-			   ASM_STABS_OP, name, ival, N_LSYM);
-		  DBXOUT_DECR_NESTING;
-		  return 1;
-		}
-	      else if (TREE_CODE (TREE_TYPE (decl)) == REAL_TYPE)
-		{
-		  /* Don't know how to do this yet.  */
-		}
-	      break;
+	  if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
+	      || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
+	    {
+	      HOST_WIDE_INT ival = TREE_INT_CST_LOW (DECL_INITIAL (decl));
+
+	      dbxout_begin_complex_stabs ();
+	      dbxout_symbol_name (decl, NULL, 'c');
+	      stabstr_S ("=i");
+	      stabstr_D (ival);
+	      dbxout_finish_complex_stabs (0, N_LSYM, 0, 0, 0);
+	      DBXOUT_DECR_NESTING;
+	      return 1;
 	    }
-	  /* else it is something we handle like a normal variable.  */
+	  else
+	    break;
 	}
+      /* else it is something we handle like a normal variable.  */
+
+      decl_rtl = dbxout_expand_expr (decl);
+      if (!decl_rtl)
+	DBXOUT_DECR_NESTING_AND_RETURN (0);
 
-      SET_DECL_RTL (decl, eliminate_regs (DECL_RTL (decl), 0, NULL_RTX));
+      decl_rtl = eliminate_regs (decl_rtl, 0, NULL_RTX);
 #ifdef LEAF_REG_REMAP
       if (current_function_uses_only_leaf_regs)
-	leaf_renumber_regs_insn (DECL_RTL (decl));
+	leaf_renumber_regs_insn (decl_rtl);
 #endif
 
-      result = dbxout_symbol_location (decl, type, 0, DECL_RTL (decl));
+      result = dbxout_symbol_location (decl, type, 0, decl_rtl);
       break;
 
     default:
@@ -2390,10 +2802,11 @@ static int
 dbxout_symbol_location (tree decl, tree type, const char *suffix, rtx home)
 {
   int letter = 0;
+  STAB_CODE_TYPE code;
+  rtx addr = 0;
+  int number = 0;
   int regno = -1;
 
-  emit_pending_bincls_if_required ();
-
   /* Don't mention a variable at all
      if it was completely optimized into nothingness.
 
@@ -2406,14 +2819,14 @@ dbxout_symbol_location (tree decl, tree type, const char *suffix, rtx home)
 
       while (GET_CODE (value) == SUBREG)
 	value = SUBREG_REG (value);
-      if (GET_CODE (value) == REG)
+      if (REG_P (value))
 	{
 	  if (REGNO (value) >= FIRST_PSEUDO_REGISTER)
 	    return 0;
 	}
       home = alter_subreg (&home);
     }
-  if (GET_CODE (home) == REG)
+  if (REG_P (home))
     {
       regno = REGNO (home);
       if (regno >= FIRST_PSEUDO_REGISTER)
@@ -2433,17 +2846,16 @@ dbxout_symbol_location (tree decl, tree type, const char *suffix, rtx home)
      no letter at all, and N_LSYM, for auto variable,
      r and N_RSYM for register variable.  */
 
-  if (GET_CODE (home) == MEM
-      && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
+  if (MEM_P (home) && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
     {
       if (TREE_PUBLIC (decl))
 	{
 	  letter = 'G';
-	  current_sym_code = N_GSYM;
+	  code = N_GSYM;
 	}
       else
 	{
-	  current_sym_addr = XEXP (home, 0);
+	  addr = XEXP (home, 0);
 
 	  letter = decl_function_context (decl) ? 'V' : 'S';
 
@@ -2452,23 +2864,23 @@ dbxout_symbol_location (tree decl, tree type, const char *suffix, rtx home)
 	     dumped into a constant pool.  Alternatively, the symbol
 	     in the constant pool might be referenced by a different
 	     symbol.  */
-	  if (GET_CODE (current_sym_addr) == SYMBOL_REF
-	      && CONSTANT_POOL_ADDRESS_P (current_sym_addr))
+	  if (GET_CODE (addr) == SYMBOL_REF
+	      && CONSTANT_POOL_ADDRESS_P (addr))
 	    {
 	      bool marked;
-	      rtx tmp = get_pool_constant_mark (current_sym_addr, &marked);
+	      rtx tmp = get_pool_constant_mark (addr, &marked);
 
 	      if (GET_CODE (tmp) == SYMBOL_REF)
 		{
-		  current_sym_addr = tmp;
-		  if (CONSTANT_POOL_ADDRESS_P (current_sym_addr))
-		    get_pool_constant_mark (current_sym_addr, &marked);
+		  addr = tmp;
+		  if (CONSTANT_POOL_ADDRESS_P (addr))
+		    get_pool_constant_mark (addr, &marked);
 		  else
 		    marked = true;
 		}
 	      else if (GET_CODE (tmp) == LABEL_REF)
 		{
-		  current_sym_addr = tmp;
+		  addr = tmp;
 		  marked = true;
 		}
 
@@ -2485,30 +2897,30 @@ dbxout_symbol_location (tree decl, tree type, const char *suffix, rtx home)
 	  if (DECL_INITIAL (decl) == 0
 	      || (!strcmp (lang_hooks.name, "GNU C++")
 		  && DECL_INITIAL (decl) == error_mark_node))
-	    current_sym_code = N_LCSYM;
+	    code = N_LCSYM;
 	  else if (DECL_IN_TEXT_SECTION (decl))
 	    /* This is not quite right, but it's the closest
 	       of all the codes that Unix defines.  */
-	    current_sym_code = DBX_STATIC_CONST_VAR_CODE;
+	    code = DBX_STATIC_CONST_VAR_CODE;
 	  else
 	    {
 	      /* Ultrix `as' seems to need this.  */
 #ifdef DBX_STATIC_STAB_DATA_SECTION
-	      data_section ();
+	      switch_to_section (data_section);
 #endif
-	      current_sym_code = N_STSYM;
+	      code = N_STSYM;
 	    }
 	}
     }
   else if (regno >= 0)
     {
       letter = 'r';
-      current_sym_code = N_RSYM;
-      current_sym_value = DBX_REGISTER_NUMBER (regno);
+      code = N_RSYM;
+      number = DBX_REGISTER_NUMBER (regno);
     }
-  else if (GET_CODE (home) == MEM
-	   && (GET_CODE (XEXP (home, 0)) == MEM
-	       || (GET_CODE (XEXP (home, 0)) == REG
+  else if (MEM_P (home)
+	   && (MEM_P (XEXP (home, 0))
+	       || (REG_P (XEXP (home, 0))
 		   && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM
 		   && REGNO (XEXP (home, 0)) != STACK_POINTER_REGNUM
 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
@@ -2520,24 +2932,22 @@ dbxout_symbol_location (tree decl, tree type, const char *suffix, rtx home)
        then it means the object is variable-sized and address through
        that register or stack slot.  DBX has no way to represent this
        so all we can do is output the variable as a pointer.
-       If it's not a parameter, ignore it.
-       (VAR_DECLs like this can be made by integrate.c.)  */
+       If it's not a parameter, ignore it.  */
     {
-      if (GET_CODE (XEXP (home, 0)) == REG)
+      if (REG_P (XEXP (home, 0)))
 	{
 	  letter = 'r';
-	  current_sym_code = N_RSYM;
+	  code = N_RSYM;
 	  if (REGNO (XEXP (home, 0)) >= FIRST_PSEUDO_REGISTER)
 	    return 0;
-	  current_sym_value = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
+	  number = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
 	}
       else
 	{
-	  current_sym_code = N_LSYM;
+	  code = N_LSYM;
 	  /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
 	     We want the value of that CONST_INT.  */
-	  current_sym_value
-	    = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
+	  number = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
 	}
 
       /* Effectively do build_pointer_type, but don't cache this type,
@@ -2547,22 +2957,22 @@ dbxout_symbol_location (tree decl, tree type, const char *suffix, rtx home)
       type = make_node (POINTER_TYPE);
       TREE_TYPE (type) = TREE_TYPE (decl);
     }
-  else if (GET_CODE (home) == MEM
-	   && GET_CODE (XEXP (home, 0)) == REG)
+  else if (MEM_P (home)
+	   && REG_P (XEXP (home, 0)))
     {
-      current_sym_code = N_LSYM;
-      current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
+      code = N_LSYM;
+      number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
     }
-  else if (GET_CODE (home) == MEM
+  else if (MEM_P (home)
 	   && GET_CODE (XEXP (home, 0)) == PLUS
 	   && GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT)
     {
-      current_sym_code = N_LSYM;
+      code = N_LSYM;
       /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
 	 We want the value of that CONST_INT.  */
-      current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
+      number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
     }
-  else if (GET_CODE (home) == MEM
+  else if (MEM_P (home)
 	   && GET_CODE (XEXP (home, 0)) == CONST)
     {
       /* Handle an obscure case which can arise when optimizing and
@@ -2576,9 +2986,9 @@ dbxout_symbol_location (tree decl, tree type, const char *suffix, rtx home)
 	 variable, thereby avoiding the need for a register.  In such
 	 cases we're forced to lie to debuggers and tell them that
 	 this variable was itself `static'.  */
-      current_sym_code = N_LCSYM;
+      code = N_LCSYM;
       letter = 'V';
-      current_sym_addr = XEXP (XEXP (home, 0), 0);
+      addr = XEXP (XEXP (home, 0), 0);
     }
   else if (GET_CODE (home) == CONCAT)
     {
@@ -2599,8 +3009,6 @@ dbxout_symbol_location (tree decl, tree type, const char *suffix, rtx home)
       else
 	dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0));
 
-      dbxout_prepare_symbol (decl);
-
       if (WORDS_BIG_ENDIAN)
 	dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1));
       else
@@ -2614,18 +3022,20 @@ dbxout_symbol_location (tree decl, tree type, const char *suffix, rtx home)
     return 0;
 
   /* Ok, start a symtab entry and output the variable name.  */
+  emit_pending_bincls_if_required ();
   FORCE_TEXT;
 
 #ifdef DBX_STATIC_BLOCK_START
-  DBX_STATIC_BLOCK_START (asmfile, current_sym_code);
+  DBX_STATIC_BLOCK_START (asm_out_file, code);
 #endif
 
+  dbxout_begin_complex_stabs_noforcetext ();
   dbxout_symbol_name (decl, suffix, letter);
   dbxout_type (type, 0);
-  dbxout_finish_symbol (decl);
+  dbxout_finish_complex_stabs (decl, code, addr, 0, number);
 
 #ifdef DBX_STATIC_BLOCK_END
-  DBX_STATIC_BLOCK_END (asmfile, current_sym_code);
+  DBX_STATIC_BLOCK_END (asm_out_file, code);
 #endif
   return 1;
 }
@@ -2636,7 +3046,7 @@ dbxout_symbol_location (tree decl, tree type, const char *suffix, rtx home)
 static void
 dbxout_symbol_name (tree decl, const char *suffix, int letter)
 {
-  const char *name;
+  tree name;
 
   if (DECL_CONTEXT (decl) 
       && (TYPE_P (DECL_CONTEXT (decl))
@@ -2645,56 +3055,22 @@ dbxout_symbol_name (tree decl, const char *suffix, int letter)
        or a namespace member, we must put out the mangled name instead of the
        DECL_NAME.  Note also that static member (variable) names DO NOT begin
        with underscores in .stabs directives.  */
-    name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
+    name = DECL_ASSEMBLER_NAME (decl);
   else
     /* ...but if we're function-local, we don't want to include the junk
        added by ASM_FORMAT_PRIVATE_NAME.  */
-    name = IDENTIFIER_POINTER (DECL_NAME (decl));
+    name = DECL_NAME (decl);
 
-  if (name == 0)
-    name = "(anon)";
-  fprintf (asmfile, "%s\"%s%s:", ASM_STABS_OP, name,
-	   (suffix ? suffix : ""));
+  if (name)
+    stabstr_I (name);
+  else
+    stabstr_S ("(anon)");
 
+  if (suffix)
+    stabstr_S (suffix);
+  stabstr_C (':');
   if (letter)
-    putc (letter, asmfile);
-}
-
-static void
-dbxout_prepare_symbol (tree decl ATTRIBUTE_UNUSED)
-{
-#ifdef WINNING_GDB
-  const char *filename = DECL_SOURCE_FILE (decl);
-
-  dbxout_source_file (asmfile, filename);
-#endif
-
-  /* Initialize variables used to communicate each symbol's debug
-     information to dbxout_finish_symbol with zeroes.  */
-
-  /* Cast avoids warning in old compilers.  */
-  current_sym_code = (STAB_CODE_TYPE) 0;
-  current_sym_value = 0;
-  current_sym_addr = 0;
-}
-
-static void
-dbxout_finish_symbol (tree sym)
-{
-#ifdef DBX_FINISH_SYMBOL
-  DBX_FINISH_SYMBOL (sym);
-#else
-  int line = 0;
-  if (use_gnu_debug_info_extensions && sym != 0)
-    line = DECL_SOURCE_LINE (sym);
-
-  fprintf (asmfile, "\",%d,0,%d,", current_sym_code, line);
-  if (current_sym_addr)
-    output_addr_const (asmfile, current_sym_addr);
-  else
-    fprintf (asmfile, "%d", current_sym_value);
-  putc ('\n', asmfile);
-#endif
+    stabstr_C (letter);
 }
 
 /* Output definitions of all the decls in a chain. Return nonzero if
@@ -2728,13 +3104,18 @@ void
 dbxout_parms (tree parms)
 {
   ++debug_nesting;
-
   emit_pending_bincls_if_required ();
 
   for (; parms; parms = TREE_CHAIN (parms))
-    if (DECL_NAME (parms) && TREE_TYPE (parms) != error_mark_node)
+    if (DECL_NAME (parms)
+	&& TREE_TYPE (parms) != error_mark_node
+	&& DECL_RTL_SET_P (parms)
+	&& DECL_INCOMING_RTL (parms))
       {
-	dbxout_prepare_symbol (parms);
+	tree eff_type;
+	char letter;
+	STAB_CODE_TYPE code;
+	int number;
 
 	/* Perform any necessary register eliminations on the parameter's rtl,
 	   so that the debugging output will be accurate.  */
@@ -2751,107 +3132,63 @@ dbxout_parms (tree parms)
 
 	if (PARM_PASSED_IN_MEMORY (parms))
 	  {
-	    rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
+	    rtx inrtl = XEXP (DECL_INCOMING_RTL (parms), 0);
 
 	    /* ??? Here we assume that the parm address is indexed
 	       off the frame pointer or arg pointer.
 	       If that is not true, we produce meaningless results,
 	       but do not crash.  */
-	    if (GET_CODE (addr) == PLUS
-		&& GET_CODE (XEXP (addr, 1)) == CONST_INT)
-	      current_sym_value = INTVAL (XEXP (addr, 1));
-	    else
-	      current_sym_value = 0;
-
-	    current_sym_code = N_PSYM;
-	    current_sym_addr = 0;
-
-	    FORCE_TEXT;
-	    if (DECL_NAME (parms))
-	      {
-		current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
-
-		fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
-			 IDENTIFIER_POINTER (DECL_NAME (parms)),
-			 DBX_MEMPARM_STABS_LETTER);
-	      }
+	    if (GET_CODE (inrtl) == PLUS
+		&& GET_CODE (XEXP (inrtl, 1)) == CONST_INT)
+	      number = INTVAL (XEXP (inrtl, 1));
 	    else
-	      {
-		current_sym_nchars = 8;
-		fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
-			 DBX_MEMPARM_STABS_LETTER);
-	      }
-
-	    /* It is quite tempting to use:
-
-	           dbxout_type (TREE_TYPE (parms), 0);
-
-	       as the next statement, rather than using DECL_ARG_TYPE(), so
-	       that gcc reports the actual type of the parameter, rather
-	       than the promoted type.  This certainly makes GDB's life
-	       easier, at least for some ports.  The change is a bad idea
-	       however, since GDB expects to be able access the type without
-	       performing any conversions.  So for example, if we were
-	       passing a float to an unprototyped function, gcc will store a
-	       double on the stack, but if we emit a stab saying the type is a
-	       float, then gdb will only read in a single value, and this will
-	       produce an erroneous value.  */
-	    dbxout_type (DECL_ARG_TYPE (parms), 0);
-	    current_sym_value = DEBUGGER_ARG_OFFSET (current_sym_value, addr);
-	    dbxout_finish_symbol (parms);
+	      number = 0;
+
+	    code = N_PSYM;
+	    number = DEBUGGER_ARG_OFFSET (number, inrtl);
+	    letter = 'p';
+
+	    /* It is quite tempting to use TREE_TYPE (parms) instead
+	       of DECL_ARG_TYPE (parms) for the eff_type, so that gcc
+	       reports the actual type of the parameter, rather than
+	       the promoted type.  This certainly makes GDB's life
+	       easier, at least for some ports.  The change is a bad
+	       idea however, since GDB expects to be able access the
+	       type without performing any conversions.  So for
+	       example, if we were passing a float to an unprototyped
+	       function, gcc will store a double on the stack, but if
+	       we emit a stab saying the type is a float, then gdb
+	       will only read in a single value, and this will produce
+	       an erroneous value.  */
+	    eff_type = DECL_ARG_TYPE (parms);
 	  }
-	else if (GET_CODE (DECL_RTL (parms)) == REG)
+	else if (REG_P (DECL_RTL (parms)))
 	  {
 	    rtx best_rtl;
-	    char regparm_letter;
-	    tree parm_type;
-	    /* Parm passed in registers and lives in registers or nowhere.  */
 
-	    current_sym_code = DBX_REGPARM_STABS_CODE;
-	    regparm_letter = DBX_REGPARM_STABS_LETTER;
-	    current_sym_addr = 0;
-
-	    /* If parm lives in a register, use that register;
-	       pretend the parm was passed there.  It would be more consistent
-	       to describe the register where the parm was passed,
-	       but in practice that register usually holds something else.
-
-	       If we use DECL_RTL, then we must use the declared type of
-	       the variable, not the type that it arrived in.  */
+	    /* Parm passed in registers and lives in registers or nowhere.  */
+	    code = DBX_REGPARM_STABS_CODE;
+	    letter = DBX_REGPARM_STABS_LETTER;
+
+	    /* For parms passed in registers, it is better to use the
+	       declared type of the variable, not the type it arrived in.  */
+	    eff_type = TREE_TYPE (parms);
+
+	    /* If parm lives in a register, use that register; pretend
+	       the parm was passed there.  It would be more consistent
+	       to describe the register where the parm was passed, but
+	       in practice that register usually holds something else.
+	       If the parm lives nowhere, use the register where it
+	       was passed.  */
 	    if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
-	      {
-		best_rtl = DECL_RTL (parms);
-		parm_type = TREE_TYPE (parms);
-	      }
-	    /* If the parm lives nowhere, use the register where it was
-	       passed.  It is also better to use the declared type here.  */
+	      best_rtl = DECL_RTL (parms);
 	    else
-	      {
-		best_rtl = DECL_INCOMING_RTL (parms);
-		parm_type = TREE_TYPE (parms);
-	      }
-	    current_sym_value = DBX_REGISTER_NUMBER (REGNO (best_rtl));
-
-	    FORCE_TEXT;
-	    if (DECL_NAME (parms))
-	      {
-		current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
-		fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
-			 IDENTIFIER_POINTER (DECL_NAME (parms)),
-			 regparm_letter);
-	      }
-	    else
-	      {
-		current_sym_nchars = 8;
-		fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
-			 regparm_letter);
-	      }
+	      best_rtl = DECL_INCOMING_RTL (parms);
 
-	    dbxout_type (parm_type, 0);
-	    dbxout_finish_symbol (parms);
+	    number = DBX_REGISTER_NUMBER (REGNO (best_rtl));
 	  }
-	else if (GET_CODE (DECL_RTL (parms)) == MEM
-		 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
+	else if (MEM_P (DECL_RTL (parms))
+		 && REG_P (XEXP (DECL_RTL (parms), 0))
 		 && REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM
 		 && REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM
 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
@@ -2865,73 +3202,44 @@ dbxout_parms (tree parms)
 	       The debugger will know from the type
 	       that it was actually passed by invisible reference.  */
 
-	    char regparm_letter;
-	    /* Parm passed in registers and lives in registers or nowhere.  */
-
-	    current_sym_code = DBX_REGPARM_STABS_CODE;
-	    if (use_gnu_debug_info_extensions)
-	      regparm_letter = GDB_INV_REF_REGPARM_STABS_LETTER;
-	    else
-	      regparm_letter = DBX_REGPARM_STABS_LETTER;
+	    code = DBX_REGPARM_STABS_CODE;
+ 
+	    /* GDB likes this marked with a special letter.  */
+	    letter = (use_gnu_debug_info_extensions
+		      ? 'a' : DBX_REGPARM_STABS_LETTER);
+	    eff_type = TREE_TYPE (parms);
 
 	    /* DECL_RTL looks like (MEM (REG...).  Get the register number.
 	       If it is an unallocated pseudo-reg, then use the register where
-	       it was passed instead.  */
-	    if (REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER)
-	      current_sym_value = REGNO (XEXP (DECL_RTL (parms), 0));
-	    else
-	      current_sym_value = REGNO (DECL_INCOMING_RTL (parms));
-
-	    current_sym_addr = 0;
-
-	    FORCE_TEXT;
-	    if (DECL_NAME (parms))
-	      {
-		current_sym_nchars
-		  = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
+	       it was passed instead.
+	       ??? Why is DBX_REGISTER_NUMBER not used here?  */
 
-		fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
-			 IDENTIFIER_POINTER (DECL_NAME (parms)),
-			 regparm_letter);
-	      }
+	    if (REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER)
+	      number = REGNO (XEXP (DECL_RTL (parms), 0));
 	    else
-	      {
-		current_sym_nchars = 8;
-		fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
-			 regparm_letter);
-	      }
-
-	    dbxout_type (TREE_TYPE (parms), 0);
-	    dbxout_finish_symbol (parms);
+	      number = REGNO (DECL_INCOMING_RTL (parms));
 	  }
-	else if (GET_CODE (DECL_RTL (parms)) == MEM
-		 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM)
+	else if (MEM_P (DECL_RTL (parms))
+		 && MEM_P (XEXP (DECL_RTL (parms), 0)))
 	  {
 	    /* Parm was passed via invisible reference, with the reference
 	       living on the stack.  DECL_RTL looks like
 	       (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
 	       could look like (MEM (MEM (REG))).  */
-	    const char *const decl_name = (DECL_NAME (parms)
-				     ? IDENTIFIER_POINTER (DECL_NAME (parms))
-				     : "(anon)");
-	    if (GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 0)) == REG)
-	      current_sym_value = 0;
+
+	    code = N_PSYM;
+	    letter = 'v';
+	    eff_type = TREE_TYPE (parms);
+
+	    if (!REG_P (XEXP (XEXP (DECL_RTL (parms), 0), 0)))
+	      number = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms), 0), 0), 1));
 	    else
-	      current_sym_value
-	        = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms), 0), 0), 1));
-	    current_sym_addr = 0;
-	    current_sym_code = N_PSYM;
-
-	    FORCE_TEXT;
-	    fprintf (asmfile, "%s\"%s:v", ASM_STABS_OP, decl_name);
-
-	    current_sym_value
-	      = DEBUGGER_ARG_OFFSET (current_sym_value,
-				     XEXP (XEXP (DECL_RTL (parms), 0), 0));
-	    dbxout_type (TREE_TYPE (parms), 0);
-	    dbxout_finish_symbol (parms);
+	      number = 0;
+
+	    number = DEBUGGER_ARG_OFFSET (number,
+					  XEXP (XEXP (DECL_RTL (parms), 0), 0));
 	  }
-	else if (GET_CODE (DECL_RTL (parms)) == MEM
+	else if (MEM_P (DECL_RTL (parms))
 		 && XEXP (DECL_RTL (parms), 0) != const0_rtx
 		 /* ??? A constant address for a parm can happen
 		    when the reg it lives in is equiv to a constant in memory.
@@ -2940,53 +3248,43 @@ dbxout_parms (tree parms)
 	  {
 	    /* Parm was passed in registers but lives on the stack.  */
 
-	    current_sym_code = N_PSYM;
+	    code = N_PSYM;
+	    letter = 'p';
+	    eff_type = TREE_TYPE (parms);
+
 	    /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
 	       in which case we want the value of that CONST_INT,
 	       or (MEM (REG ...)),
 	       in which case we use a value of zero.  */
-	    if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG)
-	      current_sym_value = 0;
+	    if (!REG_P (XEXP (DECL_RTL (parms), 0)))
+	      number = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
 	    else
-		current_sym_value
-		  = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
-
-	    current_sym_addr = 0;
+	      number = 0;
 
 	    /* Make a big endian correction if the mode of the type of the
 	       parameter is not the same as the mode of the rtl.  */
 	    if (BYTES_BIG_ENDIAN
 		&& TYPE_MODE (TREE_TYPE (parms)) != GET_MODE (DECL_RTL (parms))
 		&& GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))) < UNITS_PER_WORD)
-	      {
-		current_sym_value +=
-		    GET_MODE_SIZE (GET_MODE (DECL_RTL (parms)))
-		    - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms)));
-	      }
-
-	    FORCE_TEXT;
-	    if (DECL_NAME (parms))
-	      {
-		current_sym_nchars
-		  = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
-
-		fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
-			 IDENTIFIER_POINTER (DECL_NAME (parms)),
-			 DBX_MEMPARM_STABS_LETTER);
-	      }
-	    else
-	      {
-		current_sym_nchars = 8;
-		fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
-		DBX_MEMPARM_STABS_LETTER);
-	      }
+	      number += (GET_MODE_SIZE (GET_MODE (DECL_RTL (parms)))
+			 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))));
+	  }
+	else
+	  /* ??? We don't know how to represent this argument.  */
+	  continue;
 
-	    current_sym_value
-	      = DEBUGGER_ARG_OFFSET (current_sym_value,
-				     XEXP (DECL_RTL (parms), 0));
-	    dbxout_type (TREE_TYPE (parms), 0);
-	    dbxout_finish_symbol (parms);
+	dbxout_begin_complex_stabs ();
+	    
+	if (DECL_NAME (parms))
+	  {
+	    stabstr_I (DECL_NAME (parms));
+	    stabstr_C (':');
 	  }
+	else
+	  stabstr_S ("(anon):");
+	stabstr_C (letter);
+	dbxout_type (eff_type, 0);
+	dbxout_finish_complex_stabs (parms, code, 0, 0, number);
       }
   DBXOUT_DECR_NESTING;
 }
@@ -3010,11 +3308,9 @@ dbxout_reg_parms (tree parms)
   for (; parms; parms = TREE_CHAIN (parms))
     if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms))
       {
-	dbxout_prepare_symbol (parms);
-
 	/* Report parms that live in registers during the function
 	   but were passed in memory.  */
-	if (GET_CODE (DECL_RTL (parms)) == REG
+	if (REG_P (DECL_RTL (parms))
 	    && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
 	  dbxout_symbol_location (parms, TREE_TYPE (parms),
 				  0, DECL_RTL (parms));
@@ -3022,7 +3318,7 @@ dbxout_reg_parms (tree parms)
 	  dbxout_symbol_location (parms, TREE_TYPE (parms),
 				  0, DECL_RTL (parms));
 	/* Report parms that live in memory but not where they were passed.  */
-	else if (GET_CODE (DECL_RTL (parms)) == MEM
+	else if (MEM_P (DECL_RTL (parms))
 		 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
 	  dbxout_symbol_location (parms, TREE_TYPE (parms),
 				  0, DECL_RTL (parms));
@@ -3038,9 +3334,8 @@ dbxout_args (tree args)
 {
   while (args)
     {
-      putc (',', asmfile);
+      stabstr_C (',');
       dbxout_type (TREE_VALUE (args), 0);
-      CHARS (1);
       args = TREE_CHAIN (args);
     }
 }
@@ -3052,17 +3347,11 @@ static void
 dbx_output_lbrac (const char *label,
 		  const char *begin_label ATTRIBUTE_UNUSED)
 {
-#ifdef DBX_OUTPUT_LBRAC
-  DBX_OUTPUT_LBRAC (asmfile, label);
-#else
-  fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_LBRAC);
-  assemble_name (asmfile, label);
-#if DBX_BLOCKS_FUNCTION_RELATIVE
-  putc ('-', asmfile);
-  assemble_name (asmfile, begin_label);
-#endif
-  fprintf (asmfile, "\n");
-#endif
+  dbxout_begin_stabn (N_LBRAC);
+  if (DBX_BLOCKS_FUNCTION_RELATIVE)
+    dbxout_stab_value_label_diff (label, begin_label);
+  else
+    dbxout_stab_value_label (label);
 }
 
 /* Subroutine of dbxout_block.  Emit an N_RBRAC stab referencing LABEL.
@@ -3072,17 +3361,11 @@ static void
 dbx_output_rbrac (const char *label,
 		  const char *begin_label ATTRIBUTE_UNUSED)
 {
-#ifdef DBX_OUTPUT_RBRAC
-  DBX_OUTPUT_RBRAC (asmfile, label);
-#else
-  fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_RBRAC);
-  assemble_name (asmfile, label);
-#if DBX_BLOCKS_FUNCTION_RELATIVE
-  putc ('-', asmfile);
-  assemble_name (asmfile, begin_label);
-#endif
-  fprintf (asmfile, "\n");
-#endif
+  dbxout_begin_stabn (N_RBRAC);
+  if (DBX_BLOCKS_FUNCTION_RELATIVE)
+    dbxout_stab_value_label_diff (label, begin_label);
+  else
+    dbxout_stab_value_label (label);
 }
 
 /* Output everything about a symbol block (a BLOCK node
@@ -3105,11 +3388,9 @@ dbx_output_rbrac (const char *label,
 static void
 dbxout_block (tree block, int depth, tree args)
 {
-  const char *begin_label;
-  if (current_function_func_begin_label != NULL_TREE)
-    begin_label = IDENTIFIER_POINTER (current_function_func_begin_label);
-  else
-    begin_label = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
+  char begin_label[20];
+  /* Reference current function start using LFBB.  */
+  ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
 
   while (block)
     {
@@ -3138,7 +3419,7 @@ dbxout_block (tree block, int depth, tree args)
 
 	      if (depth == 0)
 		/* The outermost block doesn't get LBB labels; use
-		   the function symbol.  */
+		   the LFBB local symbol emitted by dbxout_begin_prologue.  */
 		scope_start = begin_label;
 	      else
 		{
@@ -3152,10 +3433,11 @@ dbxout_block (tree block, int depth, tree args)
 		  tree decl = BLOCK_VARS (block);
 		  while (decl)
 		    {
-		      fprintf (asmfile, "%s\"%s:C1\",%d,0,0,", ASM_STABS_OP,
-			       IDENTIFIER_POINTER (DECL_NAME (decl)), N_CATCH);
-		      assemble_name (asmfile, scope_start);
-		      fprintf (asmfile, "\n");
+		      dbxout_begin_complex_stabs ();
+		      stabstr_I (DECL_NAME (decl));
+		      stabstr_S (":C1");
+		      dbxout_finish_complex_stabs (0, N_CATCH, 0,
+						   scope_start, 0);
 		      decl = TREE_CHAIN (decl);
 		    }
 		}
@@ -3192,7 +3474,12 @@ dbxout_block (tree block, int depth, tree args)
 static void
 dbxout_begin_function (tree decl)
 {
-  int saved_tree_used1 = TREE_USED (decl);
+  int saved_tree_used1;
+
+  if (DECL_IGNORED_P (decl))
+    return;
+
+  saved_tree_used1 = TREE_USED (decl);
   TREE_USED (decl) = 1;
   if (DECL_NAME (DECL_RESULT (decl)) != 0)
     {