demangle.h (enum demangle_component_type): Add DEMANGLE_COMPONENT_DECLTYPE.

* include/demangle.h (enum demangle_component_type): Add
        DEMANGLE_COMPONENT_DECLTYPE.
        * libiberty/cp-demangle.c (d_dump): Handle DEMANGLE_COMPONENT_DECLTYPE.
        (d_make_comp): Likewise.
        (cplus_demangle_type): Handle decltype and DFP types.
        (cplus_demangle_operators): Call operator takes 2 args.
        (cplus_demangle_builtin_types): Add DFP types.
        (d_exprlist): New fn.
        (d_expression): Handle parm placeholders, T() and calls.
        (d_print_comp): Handle decltype, T() and calls.
        * libiberty/testsuite/demangle-expected: Test the above.

From-SVN: r140162

include/ChangeLog

@@ -1,3 +1,8 @@
+2008-09-09  Jason Merrill  <jason@redhat.com>
+
+	* demangle.h (enum demangle_component_type): Add
+	DEMANGLE_COMPONENT_DECLTYPE.
+
 2008-07-07  Joel Brobecker  <brobecker@adacore.com>
 
 	* safe-ctype.h: Add #include of ctype.h before redefining

include/demangle.h

@@ -370,7 +370,9 @@ enum demangle_component_type
      subtree is the first part and the right subtree the second.  */
   DEMANGLE_COMPONENT_COMPOUND_NAME,
   /* A name formed by a single character.  */
-  DEMANGLE_COMPONENT_CHARACTER
+  DEMANGLE_COMPONENT_CHARACTER,
+  /* A decltype type.  */
+  DEMANGLE_COMPONENT_DECLTYPE
 };
 
 /* Types which are only used internally.  */

libiberty/ChangeLog

@@ -1,3 +1,15 @@
+2008-09-09  Jason Merrill  <jason@redhat.com>
+
+	* cp-demangle.c (d_dump): Handle DEMANGLE_COMPONENT_DECLTYPE.
+	(d_make_comp): Likewise.
+	(cplus_demangle_type): Handle decltype and DFP types.
+	(cplus_demangle_operators): Call operator takes 2 args.
+	(cplus_demangle_builtin_types): Add DFP types.
+	(d_exprlist): New fn.
+	(d_expression): Handle parm placeholders, T() and calls.
+	(d_print_comp): Handle decltype, T() and calls.
+	* testsuite/demangle-expected: Test the above.
+
 2008-08-07  Aaron W. LaFramboise  <aaronavay62@aaronwl.com>
 
 	* pex-win32.c (argv_to_argc): New function.

libiberty/cp-demangle.c

@@ -660,6 +660,9 @@ d_dump (struct demangle_component *dc, int indent)
     case DEMANGLE_COMPONENT_CHARACTER:
       printf ("character '%c'\n",  dc->u.s_character.character);
       return;
+    case DEMANGLE_COMPONENT_DECLTYPE:
+      printf ("decltype\n");
+      break;
     }
 
   d_dump (d_left (dc), indent + 2);
@@ -807,6 +810,7 @@ d_make_comp (struct d_info *di, enum demangle_component_type type,
     case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
     case DEMANGLE_COMPONENT_CAST:
     case DEMANGLE_COMPONENT_JAVA_RESOURCE:
+    case DEMANGLE_COMPONENT_DECLTYPE:
       if (left == NULL)
 	return NULL;
       break;
@@ -1422,7 +1426,7 @@ const struct demangle_operator_info cplus_demangle_operators[] =
   { "aa", NL ("&&"),        2 },
   { "ad", NL ("&"),         1 },
   { "an", NL ("&"),         2 },
-  { "cl", NL ("()"),        0 },
+  { "cl", NL ("()"),        2 },
   { "cm", NL (","),         2 },
   { "co", NL ("~"),         1 },
   { "dV", NL ("/="),        2 },
@@ -1871,12 +1875,15 @@ cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT] =
   /* n */ { NL ("__int128"),	NL ("__int128"),	D_PRINT_DEFAULT },
   /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"),
 	    D_PRINT_DEFAULT },
-  /* p */ { NULL, 0,		NULL, 0,		D_PRINT_DEFAULT },
+  /* The decimal floating point and half-precision floating point types
-  /* q */ { NULL, 0,		NULL, 0,		D_PRINT_DEFAULT },
+     don't use the normal builtin type encoding, they're just stuck into
-  /* r */ { NULL, 0,		NULL, 0,		D_PRINT_DEFAULT },
+     holes in the table for convenience.  */
+  /* p */ { NL ("decimal32"),	NL ("decimal32"),	D_PRINT_DEFAULT },
+  /* q */ { NL ("decimal64"),	NL ("decimal64"),	D_PRINT_DEFAULT },
+  /* r */ { NL ("decimal128"),	NL ("decimal128"),	D_PRINT_DEFAULT },
   /* s */ { NL ("short"),	NL ("short"),		D_PRINT_DEFAULT },
   /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT },
-  /* u */ { NULL, 0,		NULL, 0,		D_PRINT_DEFAULT },
+  /* u */ { NL ("half"),	NL ("half"),		D_PRINT_FLOAT },
   /* v */ { NL ("void"),	NL ("void"),		D_PRINT_VOID },
   /* w */ { NL ("wchar_t"),	NL ("char"),		D_PRINT_DEFAULT },
   /* x */ { NL ("long long"),	NL ("long"),		D_PRINT_LONG_LONG },
@@ -2046,6 +2053,52 @@ cplus_demangle_type (struct d_info *di)
 			 cplus_demangle_type (di), ret);
       break;
 
+    case 'D':
+      can_subst = 0;
+      d_advance (di, 1);
+      peek = d_next_char (di);
+      switch (peek)
+	{
+	case 'T':
+	case 't':
+	  /* decltype (expression) */
+	  ret = d_make_comp (di, DEMANGLE_COMPONENT_DECLTYPE,
+			     d_expression (di), NULL);
+	  if (ret && d_next_char (di) != 'E')
+	    ret = NULL;
+	  break;
+	  
+	case 'p':
+	  /* Pack expansion.  */
+	  return NULL;
+	  
+	case 'f':
+	  /* 32-bit DFP */
+	  ret = d_make_builtin_type (di,
+				     &cplus_demangle_builtin_types['p' - 'a']);
+	  di->expansion += ret->u.s_builtin.type->len;
+	  break;
+	case 'd':
+	  /* 64-bit decimal floating point */
+	  ret = d_make_builtin_type (di,
+				     &cplus_demangle_builtin_types['q' - 'a']);
+	  di->expansion += ret->u.s_builtin.type->len;
+	  break;
+	case 'e':
+	  /* 128-bit DFP */
+	  ret = d_make_builtin_type (di,
+				     &cplus_demangle_builtin_types['r' - 'a']);
+	  di->expansion += ret->u.s_builtin.type->len;
+	  break;
+	case 'h':
+	  /* 16-bit half-precision FP */
+	  ret = d_make_builtin_type (di,
+				     &cplus_demangle_builtin_types['u' - 'a']);
+	  di->expansion += ret->u.s_builtin.type->len;
+	  break;
+	}
+      break;
+
     default:
       return NULL;
     }
@@ -2391,9 +2444,39 @@ d_template_arg (struct d_info *di)
     }
 }
 
+/* Subroutine of <expression> ::= cl <expression>+ E */
+
+static struct demangle_component *
+d_exprlist (struct d_info *di)
+{
+  struct demangle_component *list = NULL;
+  struct demangle_component **p = &list;
+
+  while (1)
+    {
+      struct demangle_component *arg = d_expression (di);
+      if (arg == NULL)
+	return NULL;
+
+      *p = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, arg, NULL);
+      if (*p == NULL)
+	return NULL;
+      p = &d_right (*p);
+
+      if (d_peek_char (di) == 'E')
+	{
+	  d_advance (di, 1);
+	  break;
+	}
+    }
+
+  return list;
+}
+
 /* <expression> ::= <(unary) operator-name> <expression>
                 ::= <(binary) operator-name> <expression> <expression>
                 ::= <(trinary) operator-name> <expression> <expression> <expression>
+		::= cl <expression>+ E
                 ::= st <type>
                 ::= <template-param>
                 ::= sr <type> <unqualified-name>
@@ -2426,6 +2509,12 @@ d_expression (struct d_info *di)
 			    d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
 					 d_template_args (di)));
     }
+  else if (peek == 's' && d_peek_next_char (di) == 'T')
+    {
+      /* Just demangle a parameter placeholder as its type.  */
+      d_advance (di, 2);
+      return cplus_demangle_type (di);
+    }
   else
     {
       struct demangle_component *op;
@@ -2454,7 +2543,12 @@ d_expression (struct d_info *di)
 	  args = op->u.s_extended_operator.args;
 	  break;
 	case DEMANGLE_COMPONENT_CAST:
-	  args = 1;
+	  if (d_peek_char (di) == 'v')
+	    /* T() encoded as an operand of void.  */
+	    return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
+				cplus_demangle_type (di));
+	  else
+	    args = 1;
 	  break;
 	}
 
@@ -2466,13 +2560,18 @@ d_expression (struct d_info *di)
 	case 2:
 	  {
 	    struct demangle_component *left;
+	    struct demangle_component *right;
 
 	    left = d_expression (di);
+	    if (!strcmp (op->u.s_operator.op->code, "cl"))
+	      right = d_exprlist (di);
+	    else
+	      right = d_expression (di);
+
 	    return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op,
 				d_make_comp (di,
 					     DEMANGLE_COMPONENT_BINARY_ARGS,
-					     left,
+					     left, right));
-					     d_expression (di)));
 	  }
 	case 3:
 	  {
@@ -3520,7 +3619,9 @@ d_print_comp (struct d_print_info *dpi,
 	  d_append_char (dpi, ')');
 	}
       d_append_char (dpi, '(');
-      d_print_comp (dpi, d_right (dc));
+      if (d_left (dc)->type != DEMANGLE_COMPONENT_CAST
+	  || d_right (dc)->type != DEMANGLE_COMPONENT_BUILTIN_TYPE)
+	d_print_comp (dpi, d_right (dc));
       d_append_char (dpi, ')');
       return;
 
@@ -3531,6 +3632,15 @@ d_print_comp (struct d_print_info *dpi,
 	  return;
 	}
 
+      if (!strcmp (d_left (dc)->u.s_operator.op->code, "cl"))
+	{
+	  d_print_comp (dpi, d_left (d_right (dc)));
+	  d_append_string (dpi, " (");
+	  d_print_comp (dpi, d_right (d_right (dc)));
+	  d_append_char (dpi, ')');
+	  return;
+	}
+
       /* We wrap an expression which uses the greater-than operator in
 	 an extra layer of parens so that it does not get confused
 	 with the '>' which ends the template parameters.  */
@@ -3681,6 +3791,12 @@ d_print_comp (struct d_print_info *dpi,
       d_append_char (dpi, dc->u.s_character.character);
       return;
 
+    case DEMANGLE_COMPONENT_DECLTYPE:
+      d_append_string (dpi, "decltype (");
+      d_print_comp (dpi, d_left (dc));
+      d_append_char (dpi, ')');
+      return;
+
     default:
       d_print_error (dpi);
       return;

libiberty/testsuite/demangle-expected

@@ -3882,3 +3882,19 @@ myspace::foo()::localstruct::f(myspace::foo()::otherlocalstruct)
 --format=gnu-v3
 _ZGr32_java$Sutil$Siso4217$_properties
 java resource java/util/iso4217.properties
+# decltype/param placeholder test
+--format=gnu-v3
+_Z3addIidEDTplsTT_sTT0_ES0_S1_
+decltype ((int) + (double)) add<int, double>(int, double)
+# decltype/T() test
+--format=gnu-v3
+_Z4add2IidEDTplcvT_vcvT0_vES0_S1_
+decltype (((int)()) + ((double)())) add2<int, double>(int, double)
+# decltype/fn call test
+--format=gnu-v3
+_Z4add3IidEDTclL_Z1gEsTT_sTT0_EES0_S1_
+decltype (g (int, double)) add3<int, double>(int, double)
+# Extended floating point types test
+--format=gnu-v3
+_Z1fDfDdDeDh
+f(decimal32, decimal64, decimal128, half)