OSDN Git Service

2008-09-17 Richard Guenther <rguenther@suse.de>
authorrguenth <rguenth@138bc75d-0d04-0410-961f-82ee72b054a4>
Wed, 17 Sep 2008 21:42:55 +0000 (21:42 +0000)
committerrguenth <rguenth@138bc75d-0d04-0410-961f-82ee72b054a4>
Wed, 17 Sep 2008 21:42:55 +0000 (21:42 +0000)
* tree-cfg.c (verify_types_in_gimple_assign): Rename to ...
(verify_gimple_assign): ... this.  Split into ...
(verify_gimple_assign_unary): ... this,
(verify_gimple_assign_binary): ... that,
(verify_gimple_assign_single): ... and this.
(verify_types_in_gimple_stmt): Call verify_gimple_assign.
Fix GIMPLE_CHANGE_DYNAMIC_TYPE handling.
(verify_types_in_gimple_min_lval): Handle TARGET_MEM_REF.
(verify_types_in_gimple_reference): Be forgiving with
VIEW_CONVERT_EXPRs.
(verify_gimple_phi): Deal with virtual operands.

* tree.def (PREDICT_EXPR): Change to tcc_expression.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@140431 138bc75d-0d04-0410-961f-82ee72b054a4

gcc/ChangeLog
gcc/tree-cfg.c
gcc/tree.def

index 468c604..fc5263e 100644 (file)
@@ -1,3 +1,19 @@
+2008-09-17  Richard Guenther  <rguenther@suse.de>
+
+       * tree-cfg.c (verify_types_in_gimple_assign): Rename to ...
+       (verify_gimple_assign): ... this.  Split into ...
+       (verify_gimple_assign_unary): ... this,
+       (verify_gimple_assign_binary): ... that,
+       (verify_gimple_assign_single): ... and this.
+       (verify_types_in_gimple_stmt): Call verify_gimple_assign.
+       Fix GIMPLE_CHANGE_DYNAMIC_TYPE handling.
+       (verify_types_in_gimple_min_lval): Handle TARGET_MEM_REF.
+       (verify_types_in_gimple_reference): Be forgiving with
+       VIEW_CONVERT_EXPRs.
+       (verify_gimple_phi): Deal with virtual operands.
+
+       * tree.def (PREDICT_EXPR): Change to tcc_expression.
+
 2008-09-17  Andrew Pinski  <andrew_pinski@playstation.sony.com>
 
        * tree.c (get_callee_fndecl): Don't call the language hook.
index 4b253bf..ef891e5 100644 (file)
@@ -3035,14 +3035,17 @@ verify_types_in_gimple_min_lval (tree expr)
   if (is_gimple_id (expr))
     return false;
 
-  if (TREE_CODE (expr) != INDIRECT_REF
-      && TREE_CODE (expr) != ALIGN_INDIRECT_REF
-      && TREE_CODE (expr) != MISALIGNED_INDIRECT_REF)
+  if (!INDIRECT_REF_P (expr)
+      && TREE_CODE (expr) != TARGET_MEM_REF)
     {
       error ("invalid expression for min lvalue");
       return true;
     }
 
+  /* TARGET_MEM_REFs are strange beasts.  */
+  if (TREE_CODE (expr) == TARGET_MEM_REF)
+    return false;
+
   op = TREE_OPERAND (expr, 0);
   if (!is_gimple_val (op))
     {
@@ -3131,6 +3134,9 @@ verify_types_in_gimple_reference (tree expr)
       /* For VIEW_CONVERT_EXPRs which are allowed here, too, there
         is nothing to verify.  Gross mismatches at most invoke
         undefined behavior.  */
+      if (TREE_CODE (expr) == VIEW_CONVERT_EXPR
+         && !handled_component_p (op))
+       return false;
 
       expr = op;
     }
@@ -3257,45 +3263,50 @@ verify_gimple_comparison (tree type, tree op0, tree op1)
   return false;
 }
 
-/* Verify the contents of a GIMPLE_ASSIGN STMT.  Returns true when there
-   is a problem, otherwise false.
-
-   Verify that the types of the LHS and the RHS operands are
-   compatible.  This verification largely depends on what kind of
-   operation is done on the RHS of the assignment.  It is not always
-   the case that all the types of the operands must match (e.g., 'a =
-   (unsigned long) b' or 'ptr = ptr + 1').  */
+/* Verify a gimple assignment statement STMT with an unary rhs.
+   Returns true if anything is wrong.  */
 
 static bool
-verify_types_in_gimple_assign (gimple stmt)
+verify_gimple_assign_unary (gimple stmt)
 {
   enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
   tree lhs = gimple_assign_lhs (stmt);
-  tree rhs1 = gimple_assign_rhs1 (stmt);
-  tree rhs2 = (gimple_num_ops (stmt) == 3) ? gimple_assign_rhs2 (stmt) : NULL;
   tree lhs_type = TREE_TYPE (lhs);
+  tree rhs1 = gimple_assign_rhs1 (stmt);
   tree rhs1_type = TREE_TYPE (rhs1);
-  tree rhs2_type = (rhs2) ? TREE_TYPE (rhs2) : NULL;
 
-  /* Special codes we cannot handle via their class.  */
+  if (!is_gimple_reg (lhs)
+      && !(optimize == 0
+          && TREE_CODE (lhs_type) == COMPLEX_TYPE))
+    {
+      error ("non-register as LHS of unary operation");
+      return true;
+    }
+
+  if (!is_gimple_val (rhs1))
+    {
+      error ("invalid operand in unary operation");
+      return true;
+    }
+
+  /* First handle conversions.  */
   switch (rhs_code)
     {
     CASE_CONVERT:
       {
-       if (!is_gimple_val (rhs1))
-         {
-           error ("invalid operand in conversion");
-           return true;
-         }
-
        /* Allow conversions between integral types and pointers only if
-          there is no sign or zero extension involved.  */
-       if (((POINTER_TYPE_P (lhs_type) && INTEGRAL_TYPE_P (rhs1_type))
-            || (POINTER_TYPE_P (rhs1_type) && INTEGRAL_TYPE_P (lhs_type)))
-           && (TYPE_PRECISION (lhs_type) == TYPE_PRECISION (rhs1_type)
-               /* For targets were the precision of sizetype doesn't
-                  match that of pointers we need the following.  */
-               || lhs_type == sizetype || rhs1_type == sizetype))
+          there is no sign or zero extension involved.
+          For targets were the precision of sizetype doesn't match that
+          of pointers we need to allow arbitrary conversions from and
+          to sizetype.  */
+       if ((POINTER_TYPE_P (lhs_type)
+            && INTEGRAL_TYPE_P (rhs1_type)
+            && (TYPE_PRECISION (lhs_type) >= TYPE_PRECISION (rhs1_type)
+                || rhs1_type == sizetype))
+           || (POINTER_TYPE_P (rhs1_type)
+               && INTEGRAL_TYPE_P (lhs_type)
+               && (TYPE_PRECISION (rhs1_type) >= TYPE_PRECISION (lhs_type)
+                   || lhs_type == sizetype)))
          return false;
 
        /* Allow conversion from integer to offset type and vice versa.  */
@@ -3320,12 +3331,6 @@ verify_types_in_gimple_assign (gimple stmt)
 
     case FIXED_CONVERT_EXPR:
       {
-       if (!is_gimple_val (rhs1))
-         {
-           error ("invalid operand in conversion");
-           return true;
-         }
-
        if (!valid_fixed_convert_types_p (lhs_type, rhs1_type)
            && !valid_fixed_convert_types_p (rhs1_type, lhs_type))
          {
@@ -3340,12 +3345,6 @@ verify_types_in_gimple_assign (gimple stmt)
 
     case FLOAT_EXPR:
       {
-       if (!is_gimple_val (rhs1))
-         {
-           error ("invalid operand in int to float conversion");
-           return true;
-         }
-
        if (!INTEGRAL_TYPE_P (rhs1_type) || !SCALAR_FLOAT_TYPE_P (lhs_type))
          {
            error ("invalid types in conversion to floating point");
@@ -3359,12 +3358,6 @@ verify_types_in_gimple_assign (gimple stmt)
 
     case FIX_TRUNC_EXPR:
       {
-       if (!is_gimple_val (rhs1))
-         {
-           error ("invalid operand in float to int conversion");
-           return true;
-         }
-
        if (!INTEGRAL_TYPE_P (lhs_type) || !SCALAR_FLOAT_TYPE_P (rhs1_type))
          {
            error ("invalid types in conversion to integer");
@@ -3376,18 +3369,79 @@ verify_types_in_gimple_assign (gimple stmt)
         return false;
       }
 
-    case COMPLEX_EXPR:
+    case TRUTH_NOT_EXPR:
       {
-       if (!is_gimple_val (rhs1) || !is_gimple_val (rhs2))
-         {
-           error ("invalid operands in complex expression");
-           return true;
-         }
+      }
+
+    case NEGATE_EXPR:
+    case ABS_EXPR:
+    case BIT_NOT_EXPR:
+    case PAREN_EXPR:
+    case NON_LVALUE_EXPR:
+    case CONJ_EXPR:
+    case REDUC_MAX_EXPR:
+    case REDUC_MIN_EXPR:
+    case REDUC_PLUS_EXPR:
+    case VEC_UNPACK_HI_EXPR:
+    case VEC_UNPACK_LO_EXPR:
+    case VEC_UNPACK_FLOAT_HI_EXPR:
+    case VEC_UNPACK_FLOAT_LO_EXPR:
+      break;
+
+    default:
+      gcc_unreachable ();
+    }
+
+  /* For the remaining codes assert there is no conversion involved.  */
+  if (!useless_type_conversion_p (lhs_type, rhs1_type))
+    {
+      error ("non-trivial conversion in unary operation");
+      debug_generic_expr (lhs_type);
+      debug_generic_expr (rhs1_type);
+      return true;
+    }
+
+  return false;
+}
+
+/* Verify a gimple assignment statement STMT with a binary rhs.
+   Returns true if anything is wrong.  */
+
+static bool
+verify_gimple_assign_binary (gimple stmt)
+{
+  enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
+  tree lhs = gimple_assign_lhs (stmt);
+  tree lhs_type = TREE_TYPE (lhs);
+  tree rhs1 = gimple_assign_rhs1 (stmt);
+  tree rhs1_type = TREE_TYPE (rhs1);
+  tree rhs2 = gimple_assign_rhs2 (stmt);
+  tree rhs2_type = TREE_TYPE (rhs2);
+
+  if (!is_gimple_reg (lhs)
+      && !(optimize == 0
+          && TREE_CODE (lhs_type) == COMPLEX_TYPE))
+    {
+      error ("non-register as LHS of binary operation");
+      return true;
+    }
 
-       if (!TREE_CODE (lhs_type) == COMPLEX_TYPE
-           || !(TREE_CODE (rhs1_type) == INTEGER_TYPE
+  if (!is_gimple_val (rhs1)
+      || !is_gimple_val (rhs2))
+    {
+      error ("invalid operands in binary operation");
+      return true;
+    }
+
+  /* First handle operations that involve different types.  */
+  switch (rhs_code)
+    {
+    case COMPLEX_EXPR:
+      {
+       if (TREE_CODE (lhs_type) != COMPLEX_TYPE
+           || !(INTEGRAL_TYPE_P (rhs1_type)
                 || SCALAR_FLOAT_TYPE_P (rhs1_type))
-           || !(TREE_CODE (rhs2_type) == INTEGER_TYPE
+           || !(INTEGRAL_TYPE_P (rhs2_type)
                 || SCALAR_FLOAT_TYPE_P (rhs2_type)))
          {
            error ("type mismatch in complex expression");
@@ -3400,26 +3454,13 @@ verify_types_in_gimple_assign (gimple stmt)
        return false;
       }
 
-    case CONSTRUCTOR:
-      {
-       /* In this context we know that we are on the RHS of an
-          assignment, so CONSTRUCTOR operands are OK.  */
-       /* FIXME: verify constructor arguments.  */
-       return false;
-      }
-
     case LSHIFT_EXPR:
     case RSHIFT_EXPR:
     case LROTATE_EXPR:
     case RROTATE_EXPR:
       {
-       if (!is_gimple_val (rhs1) || !is_gimple_val (rhs2))
-         {
-           error ("invalid operands in shift expression");
-           return true;
-         }
-
-       if (!TREE_CODE (rhs1_type) == INTEGER_TYPE
+       if (!INTEGRAL_TYPE_P (rhs1_type)
+           || !INTEGRAL_TYPE_P (rhs2_type)
            || !useless_type_conversion_p (lhs_type, rhs1_type))
          {
            error ("type mismatch in shift expression");
@@ -3432,28 +3473,28 @@ verify_types_in_gimple_assign (gimple stmt)
        return false;
       }
 
-    case PLUS_EXPR:
-    case MINUS_EXPR:
+    case VEC_LSHIFT_EXPR:
+    case VEC_RSHIFT_EXPR:
       {
-       if (POINTER_TYPE_P (lhs_type)
-           || POINTER_TYPE_P (rhs1_type)
-           || POINTER_TYPE_P (rhs2_type))
+       if (TREE_CODE (rhs1_type) != VECTOR_TYPE
+           || !INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))
+           || (!INTEGRAL_TYPE_P (rhs2_type)
+               && (TREE_CODE (rhs2_type) != VECTOR_TYPE
+                   || !INTEGRAL_TYPE_P (TREE_TYPE (rhs2_type))))
+           || !useless_type_conversion_p (lhs_type, rhs1_type))
          {
-           error ("invalid (pointer) operands to plus/minus");
+           error ("type mismatch in vector shift expression");
+           debug_generic_expr (lhs_type);
+           debug_generic_expr (rhs1_type);
+           debug_generic_expr (rhs2_type);
            return true;
          }
 
-       /* Continue with generic binary expression handling.  */
-       break;
+       return false;
       }
 
     case POINTER_PLUS_EXPR:
       {
-       if (!is_gimple_val (rhs1) || !is_gimple_val (rhs2))
-         {
-           error ("invalid operands in pointer plus expression");
-           return true;
-         }
        if (!POINTER_TYPE_P (rhs1_type)
            || !useless_type_conversion_p (lhs_type, rhs1_type)
            || !useless_type_conversion_p (sizetype, rhs2_type))
@@ -3468,30 +3509,6 @@ verify_types_in_gimple_assign (gimple stmt)
        return false;
       } 
 
-    case ADDR_EXPR:
-      {
-       tree op = TREE_OPERAND (rhs1, 0);
-       if (!is_gimple_addressable (op))
-         {
-           error ("invalid operand in unary expression");
-           return true;
-         }
-
-       if (!one_pointer_to_useless_type_conversion_p (lhs_type, TREE_TYPE (op))
-           /* FIXME: a longstanding wart, &a == &a[0].  */
-           && (TREE_CODE (TREE_TYPE (op)) != ARRAY_TYPE
-               || !one_pointer_to_useless_type_conversion_p (lhs_type,
-                     TREE_TYPE (TREE_TYPE (op)))))
-         {
-           error ("type mismatch in address expression");
-           debug_generic_stmt (lhs_type);
-           debug_generic_stmt (TYPE_POINTER_TO (TREE_TYPE (op)));
-           return true;
-         }
-
-       return verify_types_in_gimple_reference (TREE_OPERAND (rhs1, 0));
-      }
-
     case TRUTH_ANDIF_EXPR:
     case TRUTH_ORIF_EXPR:
       gcc_unreachable ();
@@ -3500,12 +3517,6 @@ verify_types_in_gimple_assign (gimple stmt)
     case TRUTH_OR_EXPR:
     case TRUTH_XOR_EXPR:
       {
-       if (!is_gimple_val (rhs1) || !is_gimple_val (rhs2))
-         {
-           error ("invalid operands in truth expression");
-           return true;
-         }
-
        /* We allow any kind of integral typed argument and result.  */
        if (!INTEGRAL_TYPE_P (rhs1_type)
            || !INTEGRAL_TYPE_P (rhs2_type)
@@ -3521,108 +3532,226 @@ verify_types_in_gimple_assign (gimple stmt)
        return false;
       }
 
-    case TRUTH_NOT_EXPR:
-      {
-       if (!is_gimple_val (rhs1))
-         {
-           error ("invalid operand in unary not");
-           return true;
-         }
+    case LT_EXPR:
+    case LE_EXPR:
+    case GT_EXPR:
+    case GE_EXPR:
+    case EQ_EXPR:
+    case NE_EXPR:
+    case UNORDERED_EXPR:
+    case ORDERED_EXPR:
+    case UNLT_EXPR:
+    case UNLE_EXPR:
+    case UNGT_EXPR:
+    case UNGE_EXPR:
+    case UNEQ_EXPR:
+    case LTGT_EXPR:
+      /* Comparisons are also binary, but the result type is not
+        connected to the operand types.  */
+      return verify_gimple_comparison (lhs_type, rhs1, rhs2);
 
-       /* For TRUTH_NOT_EXPR we can have any kind of integral
-          typed arguments and results.  */
-       if (!INTEGRAL_TYPE_P (rhs1_type)
-           || !INTEGRAL_TYPE_P (lhs_type))
+    case PLUS_EXPR:
+    case MINUS_EXPR:
+      {
+       if (POINTER_TYPE_P (lhs_type)
+           || POINTER_TYPE_P (rhs1_type)
+           || POINTER_TYPE_P (rhs2_type))
          {
-           error ("type mismatch in not expression");
-           debug_generic_expr (lhs_type);
-           debug_generic_expr (rhs1_type);
+           error ("invalid (pointer) operands to plus/minus");
            return true;
          }
 
-       return false;
+       /* Continue with generic binary expression handling.  */
+       break;
       }
 
-    /* After gimplification we should not have any of these.  */
-    case ASM_EXPR:
-    case BIND_EXPR:
-    case CALL_EXPR:
-    case COND_EXPR:
-    case TREE_LIST:
-    case COMPOUND_EXPR:
-    case MODIFY_EXPR:
-    case INIT_EXPR:
-    case GOTO_EXPR:
-    case LABEL_EXPR:
-    case RETURN_EXPR:
-    case TRY_FINALLY_EXPR:
-    case TRY_CATCH_EXPR:
-    case EH_FILTER_EXPR:
-    case STATEMENT_LIST:
-      {
-       error ("tree node that should already be gimple.");
-       return true;
-      }
+    case MULT_EXPR:
+    case TRUNC_DIV_EXPR:
+    case CEIL_DIV_EXPR:
+    case FLOOR_DIV_EXPR:
+    case ROUND_DIV_EXPR:
+    case TRUNC_MOD_EXPR:
+    case CEIL_MOD_EXPR:
+    case FLOOR_MOD_EXPR:
+    case ROUND_MOD_EXPR:
+    case RDIV_EXPR:
+    case EXACT_DIV_EXPR:
+    case MIN_EXPR:
+    case MAX_EXPR:
+    case BIT_IOR_EXPR:
+    case BIT_XOR_EXPR:
+    case BIT_AND_EXPR:
+    case WIDEN_SUM_EXPR:
+    case WIDEN_MULT_EXPR:
+    case VEC_WIDEN_MULT_HI_EXPR:
+    case VEC_WIDEN_MULT_LO_EXPR:
+    case VEC_PACK_TRUNC_EXPR:
+    case VEC_PACK_SAT_EXPR:
+    case VEC_PACK_FIX_TRUNC_EXPR:
+    case VEC_EXTRACT_EVEN_EXPR:
+    case VEC_EXTRACT_ODD_EXPR:
+    case VEC_INTERLEAVE_HIGH_EXPR:
+    case VEC_INTERLEAVE_LOW_EXPR:
+      /* Continue with generic binary expression handling.  */
+      break;
 
-    case OBJ_TYPE_REF:
-      /* FIXME.  */
-      return false;
+    default:
+      gcc_unreachable ();
+    }
 
-    default:;
+  if (!useless_type_conversion_p (lhs_type, rhs1_type)
+      || !useless_type_conversion_p (lhs_type, rhs2_type))
+    {
+      error ("type mismatch in binary expression");
+      debug_generic_stmt (lhs_type);
+      debug_generic_stmt (rhs1_type);
+      debug_generic_stmt (rhs2_type);
+      return true;
+    }
+
+  return false;
+}
+
+/* Verify a gimple assignment statement STMT with a single rhs.
+   Returns true if anything is wrong.  */
+
+static bool
+verify_gimple_assign_single (gimple stmt)
+{
+  enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
+  tree lhs = gimple_assign_lhs (stmt);
+  tree lhs_type = TREE_TYPE (lhs);
+  tree rhs1 = gimple_assign_rhs1 (stmt);
+  tree rhs1_type = TREE_TYPE (rhs1);
+  bool res = false;
+
+  if (!useless_type_conversion_p (lhs_type, rhs1_type))
+    {
+      error ("non-trivial conversion at assignment");
+      debug_generic_expr (lhs_type);
+      debug_generic_expr (rhs1_type);
+      return true;
     }
 
-  /* Generic handling via classes.  */
-  switch (TREE_CODE_CLASS (rhs_code))
+  if (handled_component_p (lhs))
+    res |= verify_types_in_gimple_reference (lhs);
+
+  /* Special codes we cannot handle via their class.  */
+  switch (rhs_code)
     {
-    case tcc_exceptional: /* for SSA_NAME */
-    case tcc_unary:
-      if (!useless_type_conversion_p (lhs_type, rhs1_type))
-       {
-         error ("non-trivial conversion at assignment");
-         debug_generic_expr (lhs_type);
-         debug_generic_expr (rhs1_type);
-         return true;
-       }
-      break;
+    case ADDR_EXPR:
+      {
+       tree op = TREE_OPERAND (rhs1, 0);
+       if (!is_gimple_addressable (op))
+         {
+           error ("invalid operand in unary expression");
+           return true;
+         }
 
-    case tcc_binary:
-      if (!is_gimple_val (rhs1) || !is_gimple_val (rhs2))
-       {
-         error ("invalid operands in binary expression");
-         return true;
-       }
-      if (!useless_type_conversion_p (lhs_type, rhs1_type)
-         || !useless_type_conversion_p (lhs_type, rhs2_type))
+       if (!one_pointer_to_useless_type_conversion_p (lhs_type, TREE_TYPE (op))
+           /* FIXME: a longstanding wart, &a == &a[0].  */
+           && (TREE_CODE (TREE_TYPE (op)) != ARRAY_TYPE
+               || !one_pointer_to_useless_type_conversion_p (lhs_type,
+                     TREE_TYPE (TREE_TYPE (op)))))
+         {
+           error ("type mismatch in address expression");
+           debug_generic_stmt (lhs_type);
+           debug_generic_stmt (TYPE_POINTER_TO (TREE_TYPE (op)));
+           return true;
+         }
+
+       return verify_types_in_gimple_reference (op);
+      }
+
+    /* tcc_reference  */
+    case COMPONENT_REF:
+    case BIT_FIELD_REF:
+    case INDIRECT_REF:
+    case ALIGN_INDIRECT_REF:
+    case MISALIGNED_INDIRECT_REF:
+    case ARRAY_REF:
+    case ARRAY_RANGE_REF:
+    case VIEW_CONVERT_EXPR:
+    case REALPART_EXPR:
+    case IMAGPART_EXPR:
+    case TARGET_MEM_REF:
+      if (!is_gimple_reg (lhs)
+         && is_gimple_reg_type (TREE_TYPE (lhs)))
        {
-         error ("type mismatch in binary expression");
-         debug_generic_stmt (lhs_type);
-         debug_generic_stmt (rhs1_type);
-         debug_generic_stmt (rhs2_type);
+         error ("invalid rhs for gimple memory store");
+         debug_generic_stmt (lhs);
+         debug_generic_stmt (rhs1);
          return true;
        }
-      break;
+      return res || verify_types_in_gimple_reference (rhs1);
 
-    case tcc_reference:
-      /* All tcc_reference trees are GIMPLE_SINGLE_RHS.  Verify that
-         no implicit type change happens here.  */
-      if (!useless_type_conversion_p (lhs_type, rhs1_type))
+    /* tcc_constant  */
+    case SSA_NAME:
+    case INTEGER_CST:
+    case REAL_CST:
+    case FIXED_CST:
+    case COMPLEX_CST:
+    case VECTOR_CST:
+    case STRING_CST:
+      return res;
+
+    /* tcc_declaration  */
+    case CONST_DECL:
+      return res;
+    case VAR_DECL:
+    case PARM_DECL:
+      if (!is_gimple_reg (lhs)
+         && !is_gimple_reg (rhs1)
+         && is_gimple_reg_type (TREE_TYPE (lhs)))
        {
-         error ("non-trivial conversion at assignment");
-         debug_generic_expr (lhs_type);
-         debug_generic_expr (rhs1_type);
+         error ("invalid rhs for gimple memory store");
+         debug_generic_stmt (lhs);
+         debug_generic_stmt (rhs1);
          return true;
        }
-      return verify_types_in_gimple_reference (rhs1);
+      return res;
 
-    case tcc_comparison:
-      return verify_gimple_comparison (lhs_type, rhs1, rhs2);
+    case COND_EXPR:
+    case CONSTRUCTOR:
+    case OBJ_TYPE_REF:
+    case ASSERT_EXPR:
+    case WITH_SIZE_EXPR:
+    case EXC_PTR_EXPR:
+    case FILTER_EXPR:
+    case POLYNOMIAL_CHREC:
+    case DOT_PROD_EXPR:
+    case VEC_COND_EXPR:
+    case REALIGN_LOAD_EXPR:
+      /* FIXME.  */
+      return res;
 
     default:;
     }
 
-  return false;
+  return res;
 }
 
+/* Verify the contents of a GIMPLE_ASSIGN STMT.  Returns true when there
+   is a problem, otherwise false.  */
+
+static bool
+verify_gimple_assign (gimple stmt)
+{
+  switch (gimple_assign_rhs_class (stmt))
+    {
+    case GIMPLE_SINGLE_RHS:
+      return verify_gimple_assign_single (stmt);
+
+    case GIMPLE_UNARY_RHS:
+      return verify_gimple_assign_unary (stmt);
+
+    case GIMPLE_BINARY_RHS:
+      return verify_gimple_assign_binary (stmt);
+
+    default:
+      gcc_unreachable ();
+    }
+}
 
 /* Verify the contents of a GIMPLE_RETURN STMT.  Returns true when there
    is a problem, otherwise false.  */
@@ -3719,7 +3848,10 @@ verify_gimple_phi (gimple stmt)
   for (i = 0; i < gimple_phi_num_args (stmt); i++)
     {
       tree arg = gimple_phi_arg_def (stmt, i);
-      if (!is_gimple_val (arg))
+      if ((is_gimple_reg (gimple_phi_result (stmt))
+          && !is_gimple_val (arg))
+         || (!is_gimple_reg (gimple_phi_result (stmt))
+             && !is_gimple_addressable (arg)))
        {
          error ("Invalid PHI argument");
          debug_generic_stmt (arg);
@@ -3758,7 +3890,7 @@ verify_types_in_gimple_stmt (gimple stmt)
   switch (gimple_code (stmt))
     {
     case GIMPLE_ASSIGN:
-      return verify_types_in_gimple_assign (stmt);
+      return verify_gimple_assign (stmt);
 
     case GIMPLE_LABEL:
       return TREE_CODE (gimple_label_label (stmt)) != LABEL_DECL;
@@ -3784,7 +3916,7 @@ verify_types_in_gimple_stmt (gimple stmt)
       return false;
 
     case GIMPLE_CHANGE_DYNAMIC_TYPE:
-      return (!is_gimple_reg (gimple_cdt_location (stmt))
+      return (!is_gimple_val (gimple_cdt_location (stmt))
              || !POINTER_TYPE_P (TREE_TYPE (gimple_cdt_location (stmt))));
 
     case GIMPLE_PHI:
index e9c8917..ef103cd 100644 (file)
@@ -1137,7 +1137,7 @@ DEFTREECODE (VEC_INTERLEAVE_LOW_EXPR, "vec_interleavelow_expr", tcc_binary, 2)
    outcome (0 for not taken and 1 for taken).  Once the profile is guessed
    all conditional branches leading to execution paths executing the
    PREDICT_EXPR will get predicted by the specified predictor.  */
-DEFTREECODE (PREDICT_EXPR, "predict_expr", tcc_unary, 1)
+DEFTREECODE (PREDICT_EXPR, "predict_expr", tcc_expression, 1)
 
 /* OPTIMIZATION_NODE.  Node to store the optimization options.  */
 DEFTREECODE (OPTIMIZATION_NODE, "optimization_node", tcc_exceptional, 0)