* config/h8300/h8300.md (inverted load with HImode dest): Add

[pf3gnuchains/gcc-fork.git] / libiberty / cp-demangle.c

diff --git a/libiberty/cp-demangle.c b/libiberty/cp-demangle.c
index 43cf34a..6db1f78 100644 (file)
--- 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 *
@@ -1970,6 +1987,8 @@ cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT] =
   /* 29 */ { NL ("half"),      NL ("half"),            D_PRINT_FLOAT },
   /* 30 */ { NL ("char16_t"),  NL ("char16_t"),        D_PRINT_DEFAULT },
   /* 31 */ { NL ("char32_t"),  NL ("char32_t"),        D_PRINT_DEFAULT },
+  /* 32 */ { NL ("decltype(nullptr)"), NL ("decltype(nullptr)"),
+            D_PRINT_DEFAULT },
 };
 
 CP_STATIC_IF_GLIBCPP_V3
@@ -2193,11 +2212,23 @@ 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;
+
+        case 'n':
+          /* decltype(nullptr) */
+         ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[32]);
+         di->expansion += ret->u.s_builtin.type->len;
+         break;
+
        default:
          return NULL;
        }
@@ -2416,6 +2447,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 +2730,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 +2799,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 +4002,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 +4017,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;
 
@@ -4037,9 +4108,18 @@ d_print_comp (struct d_print_info *dpi,
        d_append_char (dpi, '(');
 
       d_print_subexpr (dpi, d_left (d_right (dc)));
-      if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") != 0)
-       d_print_expr_op (dpi, d_left (dc));
-      d_print_subexpr (dpi, d_right (d_right (dc)));
+      if (strcmp (d_left (dc)->u.s_operator.op->code, "ix") == 0)
+       {
+         d_append_char (dpi, '[');
+         d_print_comp (dpi, d_right (d_right (dc)));
+         d_append_char (dpi, ']');
+       }
+      else
+       {
+         if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") != 0)
+           d_print_expr_op (dpi, d_left (dc));
+         d_print_subexpr (dpi, d_right (d_right (dc)));
+       }
 
       if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
          && d_left (dc)->u.s_operator.op->len == 1
@@ -4157,6 +4237,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));
@@ -4429,6 +4513,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.  */
@@ -4777,7 +4867,7 @@ d_demangle (const char *mangled, int options, size_t *palc)
       return NULL;
     }
 
-  *palc = dgs.allocation_failure ? 1 : 0;
+  *palc = dgs.allocation_failure ? 1 : dgs.alc;
   return dgs.buf;
 }