merge from gcc

17 years ago · cbc4312826
4 changed files with 119 additions and 13 deletions
--- a/include/demangle.h
+++ b/include/demangle.h
@ -326,6 +326,9 @@ enum demangle_component_type
  DEMANGLE_COMPONENT_PTRMEM_TYPE,
  /* A fixed-point type.  */
  DEMANGLE_COMPONENT_FIXED_TYPE,
+  /* A vector type.  The left subtree is the number of elements,
+     the right subtree is the element type.  */
+  DEMANGLE_COMPONENT_VECTOR_TYPE,
  /* An argument list.  The left subtree is the current argument, and
     the right subtree is either NULL or another ARGLIST node.  */
  DEMANGLE_COMPONENT_ARGLIST,
@ -378,6 +381,8 @@ enum demangle_component_type
  DEMANGLE_COMPONENT_COMPOUND_NAME,
  /* A name formed by a single character.  */
  DEMANGLE_COMPONENT_CHARACTER,
+  /* A number.  */
+  DEMANGLE_COMPONENT_NUMBER,
  /* A decltype type.  */
  DEMANGLE_COMPONENT_DECLTYPE,
  /* Global constructors keyed to name.  */
--- a/libiberty/ChangeLog
+++ b/libiberty/ChangeLog
@ -1,3 +1,17 @@
+2010-02-03  Jason Merrill  <jason@redhat.com>
+
+	* cp-demangle.c (d_expression): Handle dependent operator name.
+
+	PR c++/12909
+	* cp-demangle.c (d_number_component, d_vector_type): New.
+	(cplus_demangle_type, d_print_comp, d_print_mod): Handle vectors.
+
+2010-01-25  Ian Lance Taylor  <iant@google.com>
+
+	* cp-demangle.c (cplus_demangle_type): Check for invalid type
+	after "DF".
+	* testsuite/demangle-expected: Add test.
+
 2010-01-20  Jason Merrill  <jason@redhat.com>

 	PR c++/42338
@ -294,7 +308,7 @@
 	with other than 1 operand.
 	(d_print_comp): Handle function parameters.  Fix bug with
 	function used in type of function.
-	* testsuite/demangle-expected: Upate tests.
+	* testsuite/demangle-expected: Update tests.

 2009-02-21  Mark Mitchell  <mark@codesourcery.com>

--- a/libiberty/cp-demangle.c
+++ b/libiberty/cp-demangle.c
@ -1,5 +1,5 @@
 /* Demangler for g++ V3 ABI.
-   Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008
+   Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   Free Software Foundation, Inc.
   Written by Ian Lance Taylor <ian@wasabisystems.com>.

@ -389,6 +389,8 @@ d_class_enum_type (struct d_info *);

 static struct demangle_component *d_array_type (struct d_info *);

+static struct demangle_component *d_vector_type (struct d_info *);
+
 static struct demangle_component *
 d_pointer_to_member_type (struct d_info *);

@ -796,6 +798,7 @@ d_make_comp (struct d_info *di, enum demangle_component_type type,
    case DEMANGLE_COMPONENT_LITERAL:
    case DEMANGLE_COMPONENT_LITERAL_NEG:
    case DEMANGLE_COMPONENT_COMPOUND_NAME:
+    case DEMANGLE_COMPONENT_VECTOR_TYPE:
      if (left == NULL || right == NULL)
 	return NULL;
      break;
@ -1442,6 +1445,20 @@ d_number (struct d_info *di)
    }
 }

+/* Like d_number, but returns a demangle_component.  */
+
+static struct demangle_component *
+d_number_component (struct d_info *di)
+{
+  struct demangle_component *ret = d_make_empty (di);
+  if (ret)
+    {
+      ret->type = DEMANGLE_COMPONENT_NUMBER;
+      ret->u.s_number.number = d_number (di);
+    }
+  return ret;
+}
+
 /* identifier ::= <(unqualified source code identifier)>  */

 static struct demangle_component *
@ -2193,11 +2210,17 @@ cplus_demangle_type (struct d_info *di)
 	    /* For demangling we don't care about the bits.  */
 	    d_number (di);
 	  ret->u.s_fixed.length = cplus_demangle_type (di);
+	  if (ret->u.s_fixed.length == NULL)
+	    return NULL;
 	  d_number (di);
 	  peek = d_next_char (di);
 	  ret->u.s_fixed.sat = (peek == 's');
 	  break;

+	case 'v':
+	  ret = d_vector_type (di);
+	  break;
+
 	default:
 	  return NULL;
 	}
@ -2416,6 +2439,34 @@ d_array_type (struct d_info *di)
 		      cplus_demangle_type (di));
 }

+/* <vector-type> ::= Dv <number> _ <type>
+                 ::= Dv _ <expression> _ <type> */
+
+static struct demangle_component *
+d_vector_type (struct d_info *di)
+{
+  char peek;
+  struct demangle_component *dim;
+
+  peek = d_peek_char (di);
+  if (peek == '_')
+    {
+      d_advance (di, 1);
+      dim = d_expression (di);
+    }
+  else
+    dim = d_number_component (di);
+
+  if (dim == NULL)
+    return NULL;
+
+  if (! d_check_char (di, '_'))
+    return NULL;
+
+  return d_make_comp (di, DEMANGLE_COMPONENT_VECTOR_TYPE, dim,
+		      cplus_demangle_type (di));
+}
+
 /* <pointer-to-member-type> ::= M <(class) type> <(member) type>  */

 static struct demangle_component *
@ -2671,11 +2722,18 @@ d_expression (struct d_info *di)

      return d_make_function_param (di, index);
    }
-  else if (IS_DIGIT (peek))
+  else if (IS_DIGIT (peek)
+	   || (peek == 'o' && d_peek_next_char (di) == 'n'))
    {
      /* We can get an unqualified name as an expression in the case of
-         a dependent member access, i.e. decltype(T().i).  */
-      struct demangle_component *name = d_unqualified_name (di);
+         a dependent function call, i.e. decltype(f(t)).  */
+      struct demangle_component *name;
+
+      if (peek == 'o')
+	/* operator-function-id, i.e. operator+(t).  */
+	d_advance (di, 2);
+
+      name = d_unqualified_name (di);
      if (name == NULL)
 	return NULL;
      if (d_peek_char (di) == 'I')
@ -2733,10 +2791,18 @@ d_expression (struct d_info *di)
 	  {
 	    struct demangle_component *left;
 	    struct demangle_component *right;
+	    const char *code = op->u.s_operator.op->code;

 	    left = d_expression (di);
-	    if (!strcmp (op->u.s_operator.op->code, "cl"))
+	    if (!strcmp (code, "cl"))
 	      right = d_exprlist (di);
+	    else if (!strcmp (code, "dt") || !strcmp (code, "pt"))
+	      {
+		right = d_unqualified_name (di);
+		if (d_peek_char (di) == 'I')
+		  right = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE,
+				       right, d_template_args (di));
+	      }
 	    else
 	      right = d_expression (di);

@ -3928,6 +3994,7 @@ d_print_comp (struct d_print_info *dpi,
      }

    case DEMANGLE_COMPONENT_PTRMEM_TYPE:
+    case DEMANGLE_COMPONENT_VECTOR_TYPE:
      {
 	struct d_print_mod dpm;

@ -3942,11 +4009,7 @@ d_print_comp (struct d_print_info *dpi,
 	/* If the modifier didn't get printed by the type, print it
 	   now.  */
 	if (! dpm.printed)
-	  {
-	    d_append_char (dpi, ' ');
-	    d_print_comp (dpi, d_left (dc));
-	    d_append_string (dpi, "::*");
-	  }
+	  d_print_mod (dpi, dc);

 	dpi->modifiers = dpm.next;

@ -4166,6 +4229,10 @@ d_print_comp (struct d_print_info *dpi,
      }
      return;

+    case DEMANGLE_COMPONENT_NUMBER:
+      d_append_num (dpi, dc->u.s_number.number);
+      return;
+
    case DEMANGLE_COMPONENT_JAVA_RESOURCE:
      d_append_string (dpi, "java resource ");
      d_print_comp (dpi, d_left (dc));
@ -4438,6 +4505,12 @@ d_print_mod (struct d_print_info *dpi,
    case DEMANGLE_COMPONENT_TYPED_NAME:
      d_print_comp (dpi, d_left (mod));
      return;
+    case DEMANGLE_COMPONENT_VECTOR_TYPE:
+      d_append_string (dpi, " vector[");
+      d_print_comp (dpi, d_left (mod));
+      d_append_char (dpi, ']');
+      return;
+
    default:
      /* Otherwise, we have something that won't go back on the
 	 modifier stack, so we can just print it.  */
--- a/libiberty/testsuite/demangle-expected
+++ b/libiberty/testsuite/demangle-expected
@ -3926,6 +3926,17 @@ S<int>::x::{lambda()#3}::operator()() const
 --format=gnu-v3
 _Z1fN1SUt_E
 f(S::{unnamed type#1})
+--format=gnu-v3
+_Z1fDv32_f
+f(float vector[32])
+--format=gnu-v3
+_Z1fIfLi4EEvDv_T0__T_
+void f<float, 4>(float vector[4])
+_Z1fI1AEDTclonplfp_fp_EET_
+decltype ((operator+)({parm#1}, {parm#1})) f<A>(A)
+--format=gnu-v3
+_Z1hI1AEDTcldtfp_miEET_
+decltype (({parm#1}.(operator-))()) h<A>(A)
 #
 # Ada (GNAT) tests.
 #
@ -4019,5 +4030,8 @@ prot.lock.update
 --format=gnat
 prot__lock__update_E6s
 prot.lock.update
-
-
+#
+# Used to crash the demangler.
+--format=gnu-v3
+DFA
+DFA