[PATCH 5/5] Fix for D demangling in GDB

[Iain Buclaw <ibuclaw at gdcproject dot org>]

On 10 January 2014 13:24, Iain Buclaw <ibuclaw@gdcproject.org> wrote:
> On 9 January 2014 21:54, Tom Tromey <tromey@redhat.com> wrote:
>> The usual approach in cases like this is to do a "pure move" patch to
>> move the functions to another file, followed by a second patch to
>> implement the fixes.
>>
>
> OK, I'll split it into two separate patches.
>

Couldn't find an easy way to move, then fix.  So I did fix, then move.

First change, fixes D demangling in GDB as per first post.

2014-01-10  Iain Buclaw  <ibuclaw@gdcproject.org>

    gdb/

        * d-lang.h (d_parse_symbol): Add declaration.
        * d-lang.c (extract_identifiers)
        (extract_type_info): Remove functions.
        (parse_call_convention, parse_attributes)
        (parse_function_types, parse_function_args)
        (parse_type, parse_identifier, call_convention_p)
        (d_parse_symbol): New functions.
        (d_demangle): Use d_parse_symbol to demangle D symbols.

    gdb/testsuite/

        * gdb.dlang/demangle.exp: New file.

---

 gdb/ChangeLog                        |   11 +
 gdb/d-lang.c                         |  722 +++++++++++++++++++++++++++-------
 gdb/d-lang.h                         |    2 +
 gdb/testsuite/ChangeLog              |    4 +
 gdb/testsuite/gdb.dlang/demangle.exp |  223 +++++++++++
 5 files changed, 824 insertions(+), 138 deletions(-)

diff --git a/gdb/d-lang.c b/gdb/d-lang.c
index efd0813..f45fae8 100644
--- a/gdb/d-lang.c
+++ b/gdb/d-lang.c
@@ -23,11 +23,13 @@
 #include "varobj.h"
 #include "d-lang.h"
 #include "c-lang.h"
-#include <string.h>
 #include "parser-defs.h"
 #include "gdb_obstack.h"
 
-#include <ctype.h>
+#include "safe-ctype.h"
+
+static const char *parse_function_args (struct obstack *, const char *);
+static const char *parse_type (struct obstack *, const char *);
 
 /* The name of the symbol to use to get the name of the main subprogram.  */
 static const char D_MAIN[] = "D main";
@@ -50,175 +52,619 @@ d_main_name (void)
   return NULL;
 }
 
-/* Extract identifiers from MANGLED_STR and append it to TEMPBUF.
-   Return 1 on success or 0 on failure.  */
-static int
-extract_identifiers (const char *mangled_str, struct obstack *tempbuf)
+/* Demangle the calling convention from MANGLE and append it to TEMPBUF.
+   Return the remaining string on success or NULL on failure.  */
+static const char *
+parse_call_convention (struct obstack *tempbuf, const char *mangle)
+{
+  if (mangle == NULL || *mangle == '\0')
+    return mangle;
+
+  switch (*mangle)
+    {
+    case 'F': /* (D) */
+      mangle++;
+      break;
+    case 'U': /* (C) */
+      mangle++;
+      obstack_grow_str (tempbuf, "extern(C) ");
+      break;
+    case 'W': /* (Windows) */
+      mangle++;
+      obstack_grow_str (tempbuf, "extern(Windows) ");
+      break;
+    case 'V': /* (Pascal) */
+      mangle++;
+      obstack_grow_str (tempbuf, "extern(Pascal) ");
+      break;
+    case 'R': /* (C++) */
+      mangle++;
+      obstack_grow_str (tempbuf, "extern(C++) ");
+      break;
+    default:
+      return NULL;
+    }
+
+  return mangle;
+}
+
+/* Demangle the D function attributes from MANGLE and append it to TEMPBUF.
+   Return the remaining string on success or NULL on failure.  */
+static const char *
+parse_attributes (struct obstack *tempbuf, const char *mangle)
+{
+  if (mangle == NULL || *mangle == '\0')
+    return mangle;
+
+  while (*mangle == 'N')
+    {
+      mangle++;
+      switch (*mangle)
+	{
+	case 'a': /* pure */
+	  mangle++;
+	  obstack_grow_str (tempbuf, "pure ");
+	  continue;
+	case 'b': /* nothrow */
+	  mangle++;
+	  obstack_grow_str (tempbuf, "nothrow ");
+	  continue;
+	case 'c': /* ref */
+	  mangle++;
+	  obstack_grow_str (tempbuf, "ref ");
+	  continue;
+	case 'd': /* @property */
+	  mangle++;
+	  obstack_grow_str (tempbuf, "@property ");
+	  continue;
+	case 'e': /* @trusted */
+	  mangle++;
+	  obstack_grow_str (tempbuf, "@trusted ");
+	  continue;
+	case 'f': /* @safe */
+	  mangle++;
+	  obstack_grow_str (tempbuf, "@safe ");
+	  continue;
+	case 'g':
+	case 'h':
+	  /* inout parameter is represented as 'Ng'.
+	     vector parameter is represented as 'Nh'.
+	     If we see this, then we know we're really in the
+	     parameter list.  Rewind and break.  */
+	  mangle--;
+	}
+      break;
+    }
+  return mangle;
+}
+
+/* Demangle the function type from MANGLE and append it to TEMPBUF.
+   Return the remaining string on success or NULL on failure.  */
+static const char *
+parse_function_type (struct obstack *tempbuf, const char *mangle)
+{
+  struct obstack obattr, obargs, obtype;
+  char *attr, *args, *type;
+  size_t szattr, szargs, sztype;
+
+  if (mangle == NULL || *mangle == '\0')
+    return mangle;
+
+  /* The order of the mangled string is:
+     TypeFunction ::
+        CallConvention FuncAttrs Arguments ArgClose Type
+
+     The demangled string is re-ordered as:
+        CallConvention Type Arguments FuncAttrs
+   */
+  obstack_init (&obattr);
+  obstack_init (&obargs);
+  obstack_init (&obtype);
+
+  /* Function call convention.  */
+  mangle = parse_call_convention (tempbuf, mangle);
+
+  /* Function attributes.  */
+  mangle = parse_attributes (&obattr, mangle);
+  szattr = obstack_object_size (&obattr);
+  attr = obstack_finish (&obattr);
+
+  /* Function arguments.  */
+  mangle = parse_function_args (&obargs, mangle);
+  szargs = obstack_object_size (&obargs);
+  args = obstack_finish (&obargs);
+
+  /* Function return type.  */
+  mangle = parse_type (&obtype, mangle);
+  sztype = obstack_object_size (&obtype);
+  type = obstack_finish (&obtype);
+
+  /* Append to buffer in order. */
+  obstack_grow (tempbuf, type, sztype);
+  obstack_grow_str (tempbuf, "(");
+  obstack_grow (tempbuf, args, szargs);
+  obstack_grow_str (tempbuf, ") ");
+  obstack_grow (tempbuf, attr, szattr);
+
+  obstack_free (&obattr, NULL);
+  obstack_free (&obargs, NULL);
+  obstack_free (&obtype, NULL);
+  return mangle;
+}
+
+/* Demangle the argument list from MANGLE and append it to TEMPBUF.
+   Return the remaining string on success or NULL on failure.  */
+static const char *
+parse_function_args (struct obstack *tempbuf, const char *mangle)
+{
+  size_t n = 0;
+
+  while (mangle && *mangle != '\0')
+    {
+      switch (*mangle)
+	{
+	case 'X': /* (variadic T t...) style.  */
+	  mangle++;
+	  obstack_grow_str (tempbuf, "...");
+	  return mangle;
+	case 'Y': /* (variadic T t, ...) style.  */
+	  mangle++;
+	  obstack_grow_str (tempbuf, ", ...");
+	  return mangle;
+	case 'Z': /* Normal function.  */
+	  mangle++;
+	  return mangle;
+	}
+
+      if (n++)
+	obstack_grow_str (tempbuf, ", ");
+
+      if (*mangle == 'M') /* scope(T) */
+	{
+	  mangle++;
+	  obstack_grow_str (tempbuf, "scope ");
+	}
+
+      switch (*mangle)
+	{
+	case 'J': /* out(T) */
+	  mangle++;
+	  obstack_grow_str (tempbuf, "out ");
+	  break;
+	case 'K': /* ref(T) */
+	  mangle++;
+	  obstack_grow_str (tempbuf, "ref ");
+	  break;
+	case 'L': /* lazy(T) */
+	  mangle++;
+	  obstack_grow_str (tempbuf, "lazy ");
+	  break;
+	}
+      mangle = parse_type (tempbuf, mangle);
+    }
+  return mangle;
+}
+
+/* Demangle the type from MANGLE and append it to TEMPBUF.
+   Return the remaining string on success or NULL on failure.  */
+static const char *
+parse_type (struct obstack *tempbuf, const char *mangle)
 {
-  long i = 0;
+  if (mangle == NULL || *mangle == '\0')
+    return mangle;
 
-  while (isdigit (*mangled_str))
+  switch (*mangle)
     {
-      char *end_ptr;
-
-      i = strtol (mangled_str, &end_ptr, 10);
-      mangled_str = end_ptr;
-      if (i <= 0 || strlen (mangled_str) < i)
-        return 0;
-      obstack_grow (tempbuf, mangled_str, i);
-      mangled_str += i;
-      obstack_grow_str (tempbuf, ".");
+    case 'O': /* shared(T) */
+      mangle++;
+      obstack_grow_str (tempbuf, "shared(");
+      mangle = parse_type (tempbuf, mangle);
+      obstack_grow_str (tempbuf, ")");
+      return mangle;
+    case 'x': /* const(T) */
+      mangle++;
+      obstack_grow_str (tempbuf, "const(");
+      mangle = parse_type (tempbuf, mangle);
+      obstack_grow_str (tempbuf, ")");
+      return mangle;
+    case 'y': /* immutable(T) */
+      mangle++;
+      obstack_grow_str (tempbuf, "immutable(");
+      mangle = parse_type (tempbuf, mangle);
+      obstack_grow_str (tempbuf, ")");
+      return mangle;
+    case 'N':
+      mangle++;
+      if (*mangle == 'g') /* wild(T) */
+	{
+	  mangle++;
+	  obstack_grow_str (tempbuf, "inout(");
+	  mangle = parse_type (tempbuf, mangle);
+	  obstack_grow_str (tempbuf, ")");
+	  return mangle;
+	}
+      else if (*mangle == 'h') /* vector(T) */
+	{
+	  mangle++;
+	  /* The basetype for vectors are always static arrays.  */
+	  if (*mangle != 'G')
+	    return NULL;
+	  obstack_grow_str (tempbuf, "__vector(");
+	  mangle = parse_type (tempbuf, mangle);
+	  obstack_grow_str (tempbuf, ")");
+	  return mangle;
+	}
+      else
+	return NULL;
+    case 'A': /* dynamic array (T[]) */
+      mangle++;
+      mangle = parse_type (tempbuf, mangle);
+      obstack_grow_str (tempbuf, "[]");
+      return mangle;
+    case 'G': /* static array (T[N]) */
+    {
+      const char *numptr;
+      size_t num = 0;
+      mangle++;
+
+      numptr = mangle;
+      while (ISDIGIT (*mangle))
+	{
+	  num++;
+	  mangle++;
+	}
+      mangle = parse_type (tempbuf, mangle);
+      obstack_grow_str (tempbuf, "[");
+      obstack_grow (tempbuf, numptr, num);
+      obstack_grow_str (tempbuf, "]");
+      return mangle;
+    }
+    case 'H': /* associative array (T[T]) */
+    {
+      struct obstack obtype;
+      char *type;
+      size_t sztype;
+      mangle++;
+
+      obstack_init (&obtype);
+      mangle = parse_type (&obtype, mangle);
+      sztype = obstack_object_size (&obtype);
+      type = obstack_finish (&obtype);
+
+      mangle = parse_type (tempbuf, mangle);
+      obstack_grow_str (tempbuf, "[");
+      obstack_grow (tempbuf, type, sztype);
+      obstack_grow_str (tempbuf, "]");
+
+      obstack_free (&obtype, NULL);
+      return mangle;
+    }
+    case 'P': /* pointer (T*) */
+      mangle++;
+      mangle = parse_type (tempbuf, mangle);
+      obstack_grow_str (tempbuf, "*");
+      return mangle;
+    case 'I': /* ident T */
+    case 'C': /* class T */
+    case 'S': /* struct T */
+    case 'E': /* enum T */
+    case 'T': /* typedef T */
+      mangle++;
+      return d_parse_symbol (tempbuf, mangle);
+    case 'D': /* delegate T */
+      mangle++;
+      mangle = parse_function_type (tempbuf, mangle);
+      obstack_grow_str (tempbuf, "delegate");
+      return mangle;
+    case 'B': /* tuple T */
+      /* TODO: Handle this.  */
+      return NULL;
+
+    /* Function types */
+    case 'F': case 'U': case 'W':
+    case 'V': case 'R':
+      mangle = parse_function_type (tempbuf, mangle);
+      obstack_grow_str (tempbuf, "function");
+      return mangle;
+
+    /* Basic types */
+    case 'n':
+      mangle++;
+      obstack_grow_str (tempbuf, "none");
+      return mangle;
+    case 'v':
+      mangle++;
+      obstack_grow_str (tempbuf, "void");
+      return mangle;
+    case 'g':
+      mangle++;
+      obstack_grow_str (tempbuf, "byte");
+      return mangle;
+    case 'h':
+      mangle++;
+      obstack_grow_str (tempbuf, "ubyte");
+      return mangle;
+    case 's':
+      mangle++;
+      obstack_grow_str (tempbuf, "short");
+      return mangle;
+    case 't':
+      mangle++;
+      obstack_grow_str (tempbuf, "ushort");
+      return mangle;
+    case 'i':
+      mangle++;
+      obstack_grow_str (tempbuf, "int");
+      return mangle;
+    case 'k':
+      mangle++;
+      obstack_grow_str (tempbuf, "uint");
+      return mangle;
+    case 'l':
+      mangle++;
+      obstack_grow_str (tempbuf, "long");
+      return mangle;
+    case 'm':
+      mangle++;
+      obstack_grow_str (tempbuf, "ulong");
+      return mangle;
+    case 'f':
+      mangle++;
+      obstack_grow_str (tempbuf, "float");
+      return mangle;
+    case 'd':
+      mangle++;
+      obstack_grow_str (tempbuf, "double");
+      return mangle;
+    case 'e':
+      mangle++;
+      obstack_grow_str (tempbuf, "real");
+      return mangle;
+
+    /* Imaginary and Complex types */
+    case 'o':
+      mangle++;
+      obstack_grow_str (tempbuf, "ifloat");
+      return mangle;
+    case 'p':
+      mangle++;
+      obstack_grow_str (tempbuf, "idouble");
+      return mangle;
+    case 'j':
+      mangle++;
+      obstack_grow_str (tempbuf, "ireal");
+      return mangle;
+    case 'q':
+      mangle++;
+      obstack_grow_str (tempbuf, "cfloat");
+      return mangle;
+    case 'r':
+      mangle++;
+      obstack_grow_str (tempbuf, "cdouble");
+      return mangle;
+    case 'c':
+      mangle++;
+      obstack_grow_str (tempbuf, "creal");
+      return mangle;
+
+    /* Other types */
+    case 'b':
+      mangle++;
+      obstack_grow_str (tempbuf, "bool");
+      return mangle;
+    case 'a':
+      mangle++;
+      obstack_grow_str (tempbuf, "char");
+      return mangle;
+    case 'u':
+      mangle++;
+      obstack_grow_str (tempbuf, "wchar");
+      return mangle;
+    case 'w':
+      mangle++;
+      obstack_grow_str (tempbuf, "dchar");
+      return mangle;
+
+    default: /* unhandled */
+      return NULL;
     }
-  if (*mangled_str == '\0' || i == 0)
-    return 0;
-  obstack_blank (tempbuf, -1);
-  return 1;
 }
 
-/* Extract and demangle type from MANGLED_STR and append it to TEMPBUF.
-   Return 1 on success or 0 on failure.  */
+/* Extract the identifier from MANGLE and append it to TEMPBUF.
+   Return the remaining string on success or NULL on failure.  */
+static const char *
+parse_identifier (struct obstack *tempbuf, const char *mangle)
+{
+  if (mangle == NULL || *mangle == '\0')
+    return mangle;
+
+  if (ISDIGIT (*mangle))
+    {
+      char *endptr;
+      long i = strtol (mangle, &endptr, 10);
+
+      if (i <= 0 || strlen (endptr) < i)
+	return NULL;
+
+      mangle = endptr;
+
+      /* No support for demangling templates.  */
+      if (i >= 5 && strncmp (mangle, "__T", 3) == 0)
+	return NULL;
+
+      if (strncmp (mangle, "__ctor", i) == 0)
+	{
+	  /* Constructor symbol for a class/struct.  */
+	  obstack_grow_str (tempbuf, "this");
+	  mangle += i;
+	  return mangle;
+	}
+      else if (strncmp (mangle, "__dtor", i) == 0)
+	{
+	  /* Destructor symbol for a class/struct.  */
+	  obstack_grow_str (tempbuf, "~this");
+	  mangle += i;
+	  return mangle;
+	}
+      else if (strncmp (mangle, "__postblit", i) == 0)
+	{
+	  /* Postblit symbol for a struct.  */
+	  obstack_grow_str (tempbuf, "this(this)");
+	  mangle += i;
+	  return mangle;
+	}
+      else if (strncmp (mangle, "__initZ", i+1) == 0)
+	{
+	  /* The static initialiser for a given symbol.  */
+	  obstack_grow_str (tempbuf, "init$");
+	  mangle += i + 1;
+	  return mangle;
+	}
+      else if (strncmp (mangle, "__ClassZ", i+1) == 0)
+	{
+	  /* The classinfo symbol for a given class.  */
+	  obstack_grow_str (tempbuf, "classinfo$");
+	  mangle += i + 1;
+	  return mangle;
+	}
+      else if (strncmp (mangle, "__vtblZ", i+1) == 0)
+	{
+	  /* The vtable symbol for a given class.  */
+	  obstack_grow_str (tempbuf, "vtbl$");
+	  mangle += i + 1;
+	  return mangle;
+	}
+      else if (strncmp (mangle, "__InterfaceZ", i+1) == 0)
+	{
+	  /* The interface symbol for a given class.  */
+	  obstack_grow_str (tempbuf, "interface$");
+	  mangle += i + 1;
+	  return mangle;
+	}
+      else if (strncmp (mangle, "__ModuleInfoZ", i+1) == 0)
+	{
+	  /* The ModuleInfo symbol for a given module.  */
+	  obstack_grow_str (tempbuf, "moduleinfo$");
+	  mangle += i + 1;
+	  return mangle;
+	}
+      obstack_grow (tempbuf, mangle, i);
+      mangle += i;
+    }
+  else
+    return NULL;
+
+  return mangle;
+}
+
 static int
-extract_type_info (const char *mangled_str, struct obstack *tempbuf)
+call_convention_p (const char *mangle)
 {
-  if (*mangled_str == '\0')
-    return 0;
-  switch (*mangled_str++)
+  size_t i;
+
+  switch (*mangle)
     {
-      case 'A': /* dynamic array */
-      case 'G': /* static array */
-      case 'H': /* associative array */
-	if (!extract_type_info (mangled_str, tempbuf))
-	  return 0;
-	obstack_grow_str (tempbuf, "[]");
-	return 1;
-      case 'P': /* pointer */
-	if (!extract_type_info (mangled_str, tempbuf))
-	  return 0;
-	obstack_grow_str (tempbuf, "*");
-	return 1;
-      case 'R': /* reference */
-	if (!extract_type_info (mangled_str, tempbuf))
-	  return 0;
-	obstack_grow_str (tempbuf, "&");
-	return 1;
-      case 'Z': /* return value */
-	return extract_type_info (mangled_str, tempbuf);
-      case 'J': /* out */
-	obstack_grow_str (tempbuf, "out ");
-	return extract_type_info (mangled_str, tempbuf);
-      case 'K': /* inout */
-	obstack_grow_str (tempbuf, "inout ");
-	return extract_type_info (mangled_str, tempbuf);
-      case 'E': /* enum */
-      case 'T': /* typedef */
-      case 'D': /* delegate */
-      case 'C': /* class */
-      case 'S': /* struct */
-	return extract_identifiers (mangled_str, tempbuf);
-
-      /* basic types: */
-      case 'n': obstack_grow_str (tempbuf, "none"); return 1;
-      case 'v': obstack_grow_str (tempbuf, "void"); return 1;
-      case 'g': obstack_grow_str (tempbuf, "byte"); return 1;
-      case 'h': obstack_grow_str (tempbuf, "ubyte"); return 1;
-      case 's': obstack_grow_str (tempbuf, "short"); return 1;
-      case 't': obstack_grow_str (tempbuf, "ushort"); return 1;
-      case 'i': obstack_grow_str (tempbuf, "int"); return 1;
-      case 'k': obstack_grow_str (tempbuf, "uint"); return 1;
-      case 'l': obstack_grow_str (tempbuf, "long"); return 1;
-      case 'm': obstack_grow_str (tempbuf, "ulong"); return 1;
-      case 'f': obstack_grow_str (tempbuf, "float"); return 1;
-      case 'd': obstack_grow_str (tempbuf, "double"); return 1;
-      case 'e': obstack_grow_str (tempbuf, "real"); return 1;
-
-      /* imaginary and complex: */
-      case 'o': obstack_grow_str (tempbuf, "ifloat"); return 1;
-      case 'p': obstack_grow_str (tempbuf, "idouble"); return 1;
-      case 'j': obstack_grow_str (tempbuf, "ireal"); return 1;
-      case 'q': obstack_grow_str (tempbuf, "cfloat"); return 1;
-      case 'r': obstack_grow_str (tempbuf, "cdouble"); return 1;
-      case 'c': obstack_grow_str (tempbuf, "creal"); return 1;
-
-      /* other types: */
-      case 'b': obstack_grow_str (tempbuf, "bit"); return 1;
-      case 'a': obstack_grow_str (tempbuf, "char"); return 1;
-      case 'u': obstack_grow_str (tempbuf, "wchar"); return 1;
-      case 'w': obstack_grow_str (tempbuf, "dchar"); return 1;
-
-      default:
-	obstack_grow_str (tempbuf, "unknown");
-	return 1;
+    case 'F': case 'U': case 'V':
+    case 'W': case 'R':
+      return 1;
+
+    case 'M': /* Prefix for functions needing 'this' */
+      i = 1;
+      if (mangle[i] == 'x')
+	i++;
+
+      switch (mangle[i])
+	{
+	case 'F': case 'U': case 'V':
+	case 'W': case 'R':
+	  return 1;
+	}
+
+    default:
+      return 0;
     }
 }
 
+/* Extract and demangle the symbol in MANGLE and append it to TEMPBUF.
+   Return the remaining signature on success or NULL on failure.  */
+const char *
+d_parse_symbol (struct obstack *tempbuf, const char *mangle)
+{
+  size_t n = 0;
+  do
+    {
+      if (n++)
+	obstack_grow_str (tempbuf, ".");
+
+      mangle = parse_identifier (tempbuf, mangle);
+
+      if (mangle && call_convention_p (mangle))
+	{
+	  char *saved;
+
+	  /* Skip over 'this' parameter.  */
+	  if (*mangle == 'M')
+	    mangle += (mangle[1] == 'x') ? 2 : 1;
+
+	  /* Skip over calling convention and attributes in qualified name.  */
+	  saved = obstack_next_free (tempbuf);
+	  mangle = parse_call_convention (tempbuf, mangle);
+	  mangle = parse_attributes (tempbuf, mangle);
+	  obstack_next_free (tempbuf) = saved;
+
+	  obstack_grow_str (tempbuf, "(");
+	  mangle = parse_function_args (tempbuf, mangle);
+	  obstack_grow_str (tempbuf, ")");
+
+	  /* Demangle the function return type as a kind of sanity test.  */
+	  if (mangle && !ISDIGIT (*mangle))
+	    {
+	      saved = obstack_next_free (tempbuf);
+	      mangle = parse_type (tempbuf, mangle);
+	      obstack_next_free (tempbuf) = saved;
+	    }
+	}
+    }
+  while (mangle && ISDIGIT (*mangle));
+
+  return mangle;
+}
+
 /* Implements the la_demangle language_defn routine for language D.  */
 char *
 d_demangle (const char *symbol, int options)
 {
   struct obstack tempbuf;
-  char *out_str;
-  unsigned char is_func = 0;
+  char *result;
 
-  if (symbol == NULL)
+  if (symbol == NULL || *symbol == '\0')
     return NULL;
   else if (strcmp (symbol, "_Dmain") == 0)
     return xstrdup ("D main");
 
   obstack_init (&tempbuf);
-  
-  if (symbol[0] == '_' && symbol[1] == 'D')
-    {
-      symbol += 2;
-      is_func = 1;
-    }
-  else if (strncmp (symbol, "__Class_", 8) == 0)
-    symbol += 8;
-  else if (strncmp (symbol, "__init_", 7) == 0)
-    symbol += 7;
-  else if (strncmp (symbol, "__vtbl_", 7) == 0)
-    symbol += 7;
-  else if (strncmp (symbol, "__modctor_", 10) == 0)
-    symbol += 10;
-  else if (strncmp (symbol, "__moddtor_", 10) == 0)
-    symbol += 10;
-  else if (strncmp (symbol, "__ModuleInfo_", 13) == 0)
-    symbol += 13;
+
+  if (strncmp (symbol, "_D", 2) == 0)
+    symbol += 2;
   else
     {
       obstack_free (&tempbuf, NULL);
       return NULL;
     }
-  
-  if (!extract_identifiers (symbol, &tempbuf))
+
+  if (d_parse_symbol (&tempbuf, symbol) != NULL)
     {
+      obstack_grow_str0 (&tempbuf, "");
+      result = xstrdup (obstack_finish (&tempbuf));
       obstack_free (&tempbuf, NULL);
-      return NULL;
     }
-
-  obstack_grow_str (&tempbuf, "(");
-  if (is_func == 1 && *symbol == 'F')
+  else
     {
-      symbol++;
-      while (*symbol != '\0' && *symbol != 'Z')
-	{
-	  if (is_func == 1)
-	    is_func++;
-	  else
-	    obstack_grow_str (&tempbuf, ", ");
-	  if (!extract_type_info (symbol, &tempbuf))
-	    {
-	      obstack_free (&tempbuf, NULL);
-	      return NULL;
-	   }
-	}
-     }
-  obstack_grow_str0 (&tempbuf, ")");
-
-  /* Doesn't display the return type, but wouldn't be too hard to do.  */
+      obstack_free (&tempbuf, NULL);
+      return NULL;
+    }
 
-  out_str = xstrdup (obstack_finish (&tempbuf));
-  obstack_free (&tempbuf, NULL);
-  return out_str;
+  return result;
 }
 
 /* Table mapping opcodes into strings for printing operators
diff --git a/gdb/d-lang.h b/gdb/d-lang.h
index 455c808..a1b4456 100644
--- a/gdb/d-lang.h
+++ b/gdb/d-lang.h
@@ -62,6 +62,8 @@ extern char *d_demangle (const char *mangled, int options);
 
 extern const struct builtin_d_type *builtin_d_type (struct gdbarch *);
 
+extern const char *d_parse_symbol (struct obstack *, const char *);
+
 /* Defined in d-valprint.c  */
 
 extern void d_val_print (struct type *type, const gdb_byte *valaddr,
diff --git a/gdb/testsuite/gdb.dlang/demangle.exp b/gdb/testsuite/gdb.dlang/demangle.exp
new file mode 100644
index 0000000..4c237c5
--- /dev/null
+++ b/gdb/testsuite/gdb.dlang/demangle.exp
@@ -0,0 +1,223 @@
+# Copyright (C) 2014 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# Test D demangling.
+# The tests here intentionally do not require a D compiler.
+
+load_lib "d-support.exp"
+
+if { [skip_d_tests] } { continue }
+
+### Utility function for test_demangling and test_demangling_exact.
+proc test_demangling {test result} {
+    gdb_test_exact "maintenance demangle $test" $result $test
+}
+
+#
+#  Test D demangler
+#
+
+proc test_d_demangling {} {
+
+    test_demangling "_Dmain" "D main"
+
+    test_demangling "_D8demangle4testFaZv" "demangle.test(char)"
+    test_demangling "_D8demangle4testFbZv" "demangle.test(bool)"
+    test_demangling "_D8demangle4testFcZv" "demangle.test(creal)"
+    test_demangling "_D8demangle4testFdZv" "demangle.test(double)"
+    test_demangling "_D8demangle4testFeZv" "demangle.test(real)"
+    test_demangling "_D8demangle4testFfZv" "demangle.test(float)"
+    test_demangling "_D8demangle4testFgZv" "demangle.test(byte)"
+    test_demangling "_D8demangle4testFhZv" "demangle.test(ubyte)"
+    test_demangling "_D8demangle4testFiZv" "demangle.test(int)"
+    test_demangling "_D8demangle4testFjZv" "demangle.test(ireal)"
+    test_demangling "_D8demangle4testFkZv" "demangle.test(uint)"
+    test_demangling "_D8demangle4testFlZv" "demangle.test(long)"
+    test_demangling "_D8demangle4testFmZv" "demangle.test(ulong)"
+    test_demangling "_D8demangle4testFnZv" "demangle.test(none)"
+    test_demangling "_D8demangle4testFoZv" "demangle.test(ifloat)"
+    test_demangling "_D8demangle4testFpZv" "demangle.test(idouble)"
+    test_demangling "_D8demangle4testFqZv" "demangle.test(cfloat)"
+    test_demangling "_D8demangle4testFrZv" "demangle.test(cdouble)"
+    test_demangling "_D8demangle4testFsZv" "demangle.test(short)"
+    test_demangling "_D8demangle4testFtZv" "demangle.test(ushort)"
+    test_demangling "_D8demangle4testFuZv" "demangle.test(wchar)"
+    test_demangling "_D8demangle4testFvZv" "demangle.test(void)"
+    test_demangling "_D8demangle4testFwZv" "demangle.test(dchar)"
+
+    test_demangling "_D8demangle4testFOaZv" "demangle.test(shared(char))"
+    test_demangling "_D8demangle4testFxaZv" "demangle.test(const(char))"
+    test_demangling "_D8demangle4testFyaZv" "demangle.test(immutable(char))"
+    test_demangling "_D8demangle4testFNgaZv" "demangle.test(inout(char))"
+    test_demangling "_D8demangle4testFOxaZv" "demangle.test(shared(const(char)))"
+    test_demangling "_D8demangle4testFONgaZv" "demangle.test(shared(inout(char)))"
+    test_demangling "_D8demangle4testFAaZv" "demangle.test(char\[\])"
+    test_demangling "_D8demangle4testFAAaZv" "demangle.test(char\[\]\[\])"
+    test_demangling "_D8demangle4testFAAAaZv" "demangle.test(char\[\]\[\]\[\])"
+    test_demangling "_D8demangle4testFG42aZv" "demangle.test(char\[42\])"
+    test_demangling "_D8demangle4testFG42G42aZv" "demangle.test(char\[42\]\[42\])"
+    test_demangling "_D8demangle4testFG42G42G42aZv" "demangle.test(char\[42\]\[42\]\[42\])"
+    test_demangling "_D8demangle4testFG1234567890aZv" "demangle.test(char\[1234567890\])"
+    test_demangling "_D8demangle4testFHaaZv" "demangle.test(char\[char\])"
+    test_demangling "_D8demangle4testFHHaaaZv" "demangle.test(char\[char\[char\]\])"
+    test_demangling "_D8demangle4testFPaZv" "demangle.test(char*)"
+    test_demangling "_D8demangle4testFPPaZv" "demangle.test(char**)"
+    test_demangling "_D8demangle4testFPPPaZv" "demangle.test(char***)"
+
+    test_demangling "_D8demangle4testFNhG8gZv" "demangle.test(__vector(byte\[8\]))"
+    test_demangling "_D8demangle4testFNhG16gZv" "demangle.test(__vector(byte\[16\]))"
+    test_demangling "_D8demangle4testFNhG32gZv" "demangle.test(__vector(byte\[32\]))"
+    test_demangling "_D8demangle4testFNhG4sZv" "demangle.test(__vector(short\[4\]))"
+    test_demangling "_D8demangle4testFNhG8sZv" "demangle.test(__vector(short\[8\]))"
+    test_demangling "_D8demangle4testFNhG16sZv" "demangle.test(__vector(short\[16\]))"
+    test_demangling "_D8demangle4testFNhG2iZv" "demangle.test(__vector(int\[2\]))"
+    test_demangling "_D8demangle4testFNhG4iZv" "demangle.test(__vector(int\[4\]))"
+    test_demangling "_D8demangle4testFNhG8iZv" "demangle.test(__vector(int\[8\]))"
+    test_demangling "_D8demangle4testFNhG1lZv" "demangle.test(__vector(long\[1\]))"
+    test_demangling "_D8demangle4testFNhG2lZv" "demangle.test(__vector(long\[2\]))"
+    test_demangling "_D8demangle4testFNhG4lZv" "demangle.test(__vector(long\[4\]))"
+    test_demangling "_D8demangle4testFNhG2fZv" "demangle.test(__vector(float\[2\]))"
+    test_demangling "_D8demangle4testFNhG4fZv" "demangle.test(__vector(float\[4\]))"
+    test_demangling "_D8demangle4testFNhG8fZv" "demangle.test(__vector(float\[8\]))"
+    test_demangling "_D8demangle4testFNhG1dZv" "demangle.test(__vector(double\[1\]))"
+    test_demangling "_D8demangle4testFNhG2dZv" "demangle.test(__vector(double\[2\]))"
+    test_demangling "_D8demangle4testFNhG4dZv" "demangle.test(__vector(double\[4\]))"
+
+    test_demangling "_D8demangle4testFI5identZv" "demangle.test(ident)"
+    test_demangling "_D8demangle4testFI5ident4testZv" "demangle.test(ident.test)"
+    test_demangling "_D8demangle4testFC5classZv" "demangle.test(class)"
+    test_demangling "_D8demangle4testFC5class4testZv" "demangle.test(class.test)"
+    test_demangling "_D8demangle4testFS6structZv" "demangle.test(struct)"
+    test_demangling "_D8demangle4testFS6struct4testZv" "demangle.test(struct.test)"
+    test_demangling "_D8demangle4testFE4enumZv" "demangle.test(enum)"
+    test_demangling "_D8demangle4testFE4enum4testZv" "demangle.test(enum.test)"
+    test_demangling "_D8demangle4testFT7typedefZv" "demangle.test(typedef)"
+    test_demangling "_D8demangle4testFT7typedef4testZv" "demangle.test(typedef.test)"
+
+    test_demangling "_D8demangle4testFJaZv" "demangle.test(out char)"
+    test_demangling "_D8demangle4testFKaZv" "demangle.test(ref char)"
+    test_demangling "_D8demangle4testFLaZv" "demangle.test(lazy char)"
+    test_demangling "_D8demangle4testFMaZv" "demangle.test(scope char)"
+    test_demangling "_D8demangle4testFaXv" "demangle.test(char...)"
+    test_demangling "_D8demangle4testFaYv" "demangle.test(char, ...)"
+    test_demangling "_D8demangle4testFaaYv" "demangle.test(char, char, ...)"
+    test_demangling "_D8demangle4testFaaZv" "demangle.test(char, char)"
+
+    test_demangling "_D8demangle4testFDFZaZv" "demangle.test(char() delegate)"
+    test_demangling "_D8demangle4testFDUZaZv" "demangle.test(extern(C) char() delegate)"
+    test_demangling "_D8demangle4testFDWZaZv" "demangle.test(extern(Windows) char() delegate)"
+    test_demangling "_D8demangle4testFDVZaZv" "demangle.test(extern(Pascal) char() delegate)"
+    test_demangling "_D8demangle4testFDRZaZv" "demangle.test(extern(C++) char() delegate)"
+
+    test_demangling "_D8demangle4testFFZaZv" "demangle.test(char() function)"
+    test_demangling "_D8demangle4testFUZaZv" "demangle.test(extern(C) char() function)"
+    test_demangling "_D8demangle4testFWZaZv" "demangle.test(extern(Windows) char() function)"
+    test_demangling "_D8demangle4testFVZaZv" "demangle.test(extern(Pascal) char() function)"
+    test_demangling "_D8demangle4testFRZaZv" "demangle.test(extern(C++) char() function)"
+
+    test_demangling "_D8demangle4testFDFNaZaZv" "demangle.test(char() pure delegate)"
+    test_demangling "_D8demangle4testFDFNbZaZv" "demangle.test(char() nothrow delegate)"
+    test_demangling "_D8demangle4testFDFNcZaZv" "demangle.test(char() ref delegate)"
+    test_demangling "_D8demangle4testFDFNdZaZv" "demangle.test(char() @property delegate)"
+    test_demangling "_D8demangle4testFDFNeZaZv" "demangle.test(char() @trusted delegate)"
+    test_demangling "_D8demangle4testFDFNfZaZv" "demangle.test(char() @safe delegate)"
+
+    test_demangling "_D8demangle4testFFNaZaZv" "demangle.test(char() pure function)"
+    test_demangling "_D8demangle4testFFNbZaZv" "demangle.test(char() nothrow function)"
+    test_demangling "_D8demangle4testFFNcZaZv" "demangle.test(char() ref function)"
+    test_demangling "_D8demangle4testFFNdZaZv" "demangle.test(char() @property function)"
+    test_demangling "_D8demangle4testFFNeZaZv" "demangle.test(char() @trusted function)"
+    test_demangling "_D8demangle4testFFNfZaZv" "demangle.test(char() @safe function)"
+    test_demangling "_D8demangle4testFFNaNbZaZv" "demangle.test(char() pure nothrow function)"
+    test_demangling "_D8demangle4testFFNbNaZaZv" "demangle.test(char() nothrow pure function)"
+    test_demangling "_D8demangle4testFFNdNfNaZaZv" "demangle.test(char() @property @safe pure function)"
+
+    test_demangling "_D8demangle4test6__vtblZ" "demangle.test.vtbl$"
+    test_demangling "_D8demangle4test6__initZ" "demangle.test.init$"
+    test_demangling "_D8demangle4test12__ModuleInfoZ" "demangle.test.moduleinfo$"
+    test_demangling "_D8demangle4test7__ClassZ" "demangle.test.classinfo$"
+    test_demangling "_D8demangle4test11__InterfaceZ" "demangle.test.interface$"
+
+    test_demangling "_D8demangle4test6__ctorMFZv" "demangle.test.this()"
+    test_demangling "_D8demangle4test6__dtorMFZv" "demangle.test.~this()"
+    test_demangling "_D8demangle4test6__postblitMFZv" "demangle.test.this(this)"
+
+    test_demangling "_D8demangle4testFHAbaZv" "demangle.test(char\[bool\[\]\])"
+    test_demangling "_D8demangle4testFHG42caZv" "demangle.test(char\[creal\[42\]\])"
+    test_demangling "_D8demangle4testFAiXv" "demangle.test(int\[\]...)"
+    test_demangling "_D8demangle4testFLAiXv" "demangle.test(lazy int\[\]...)"
+    test_demangling "_D8demangle4testFAiYv" "demangle.test(int\[\], ...)"
+    test_demangling "_D8demangle4testFLAiYv" "demangle.test(lazy int\[\], ...)"
+    test_demangling "_D8demangle4testFLilZv" "demangle.test(lazy int, long)"
+    test_demangling "_D8demangle4testFLliZv" "demangle.test(lazy long, int)"
+
+    test_demangling "_D8demangle4testPFLAiYi" "demangle.test"
+    test_demangling "_D1a1bi" "a.b"
+    test_demangling "_D1a1bPFiZi" "a.b"
+    test_demangling "_D4test3fooAa" "test.foo"
+    test_demangling "_D4test2dgDFiYd" "test.dg"
+    test_demangling "_D8demangle8demangleFAaZAa" "demangle.demangle(char\[\])"
+    test_demangling "_D6object6Object8opAssignFC6ObjectZi" "object.Object.opAssign(Object)"
+    test_demangling "_D6object6Object8opEqualsFC6ObjectZi" "object.Object.opEquals(Object)"
+    test_demangling "_D8demangle4testFLC6ObjectLDFLiZiZi" "demangle.test(lazy Object, lazy int(lazy int) delegate)"
+    test_demangling "_D6plugin8generateFiiZAya" "plugin.generate(int, int)"
+    test_demangling "_D8demangle3fnAFZv3fnBMFZv" "demangle.fnA().fnB()"
+    test_demangling "_D8demangle4mainFZv1S3fnCFZv" "demangle.main().S.fnC()"
+    test_demangling "_D8demangle4mainFZv1S3fnDMFZv" "demangle.main().S.fnD()"
+    test_demangling "_D8demangle2fnFNgiZNgi" "demangle.fn(inout(int))"
+    test_demangling "_D8demangle4mainFZv5localMFZi" "demangle.main().local()"
+    test_demangling "_D3std5ascii9uppercaseyAa" "std.ascii.uppercase"
+    test_demangling "_D3std6stream9BOMEndianyG5E3std6system6Endian" "std.stream.BOMEndian"
+    test_demangling "_D3std8internal7uni_tab10unicodeNkoyS3std8internal3uni12CodepointSet" "std.internal.uni_tab.unicodeNko"
+    test_demangling "_D2gc2gc2GC6addrOfMFPvZPv" "gc.gc.GC.addrOf(void*)"
+    test_demangling "_D3std7process10setCLOEXECFibZv" "std.process.setCLOEXEC(int, bool)"
+    test_demangling "_D3std6digest2md3MD53putMFNaNbNeMAxhXv" "std.digest.md.MD5.put(scope const(ubyte)\[\]...)"
+    test_demangling "_D3std6mmfile6MmFile13opIndexAssignMFhmZh" "std.mmfile.MmFile.opIndexAssign(ubyte, ulong)"
+    test_demangling "_D3std7process18escapeShellCommandFxAAaXAya" "std.process.escapeShellCommand(const(char\[\]\[\])...)"
+    test_demangling "_D4core4sync5mutex5Mutex6__ctorMFC6ObjectZC4core4sync5mutex5Mutex" "core.sync.mutex.Mutex.this(Object)"
+    test_demangling "_D6object14TypeInfo_Array8argTypesMFNbNfJC8TypeInfoJC8TypeInfoZi" "object.TypeInfo_Array.argTypes(out TypeInfo, out TypeInfo)"
+    test_demangling "_D2rt6dmain211_d_run_mainUiPPaPUAAaZiZi7tryExecMFMDFZvZv" "rt.dmain2._d_run_main(int, char**, extern(C) int(char\[\]\[\]) function*).tryExec(scope void() delegate)"
+    test_demangling "_D6object9Exception6__ctorMFNaNbNfAyaAyamC6object9ThrowableZC9Exception" "object.Exception.this(immutable(char)\[\], immutable(char)\[\], ulong, object.Throwable)"
+    test_demangling "_D3gcc3deh17parse_lsda_headerFPS3gcc6unwind7generic15_Unwind_ContextPhPS3gcc3deh16lsda_header_infoZPh" "gcc.deh.parse_lsda_header(gcc.unwind.generic._Unwind_Context*, ubyte*, gcc.deh.lsda_header_info*)"
+    test_demangling "_D3std6socket23UnknownAddressReference6__ctorMFPS4core3sys5posix3sys6socket8sockaddrkZC3std6socket23UnknownAddressReference" "std.socket.UnknownAddressReference.this(core.sys.posix.sys.socket.sockaddr*, uint)"
+}
+
+proc catch_demangling_errors {command} {
+    if {[catch $command result]} {
+	puts "ERROR: demangle.exp: while running $command: $result"
+    }
+}
+
+# Test support for different demangling styles.  Note that this does
+# not depend upon running the test program and does not depend upon
+# gdb being able to lookup any D symbols.  It simply calls the
+# internal demangler with synthesized strings and tests the results.
+
+# Start with a fresh gdb.
+
+gdb_exit
+gdb_start
+
+if [set_lang_d] {
+    gdb_test_no_output "set width 0"
+
+    # Using catch_demangling_errors this way ensures that, if one of
+    # the functions raises a Tcl error, then it'll get reported, and
+    # the rest of the functions will still run.
+    catch_demangling_errors test_d_demangling
+
+} else {
+    warning "D demangling tests suppressed."
+}