tree-optimization/109644 - missing IL checking

We fail to verify the constraints under which we allow handled
components to wrap registers.  The gcc.dg/pr70022.c testcase shows
that we happily end up with

  _2 = VIEW_CONVERT_EXPR<int[4]>(v_1(D))

as produced by SSA rewrite and update_address_taken.  But the intent
was that we wrap registers with at most a single level of handled
components and specifically only allow __real, __imag, BIT_FIELD_REF
and VIEW_CONVERT_EXPR on them, but not ARRAY_REF or COMPONENT_REF.

The following makes IL verification stricter which catches the
problem.

	PR tree-optimization/109644
	* tree-cfg.cc (verify_types_in_gimple_reference): Check
	register constraints on the outermost VIEW_CONVERT_EXPR
	only.  Do not allow register or invariant bases on
	multi-level or possibly variable index handled components.

diff --git a/gcc/tree-cfg.cc b/gcc/tree-cfg.cc
index 5ef201adb25212729e5ac42efbad3b1972c7bc1b..4927fc0a8d9f4fc7542f44d788128964d1eb61f0 100644 (file)
--- a/gcc/tree-cfg.cc
+++ b/gcc/tree-cfg.cc
@@ -3107,10 +3107,12 @@ verify_types_in_gimple_reference (tree expr, bool require_lvalue)
 
   if (TREE_CODE (expr) == REALPART_EXPR
       || TREE_CODE (expr) == IMAGPART_EXPR
-      || TREE_CODE (expr) == BIT_FIELD_REF)
+      || TREE_CODE (expr) == BIT_FIELD_REF
+      || TREE_CODE (expr) == VIEW_CONVERT_EXPR)
     {
       tree op = TREE_OPERAND (expr, 0);
-      if (!is_gimple_reg_type (TREE_TYPE (expr)))
+      if (TREE_CODE (expr) != VIEW_CONVERT_EXPR
+         && !is_gimple_reg_type (TREE_TYPE (expr)))
        {
          error ("non-scalar %qs", code_name);
          return true;
@@ -3172,11 +3174,39 @@ verify_types_in_gimple_reference (tree expr, bool require_lvalue)
          debug_generic_stmt (TREE_TYPE (TREE_TYPE (op)));
          return true;
        }
+
+      if (TREE_CODE (expr) == VIEW_CONVERT_EXPR)
+       {
+         /* For VIEW_CONVERT_EXPRs which are allowed here too, we only check
+            that their operand is not a register an invariant when
+            requiring an lvalue (this usually means there is a SRA or IPA-SRA
+            bug).  Otherwise there is nothing to verify, gross mismatches at
+            most invoke undefined behavior.  */
+         if (require_lvalue
+             && (is_gimple_reg (op) || is_gimple_min_invariant (op)))
+           {
+             error ("conversion of %qs on the left hand side of %qs",
+                    get_tree_code_name (TREE_CODE (op)), code_name);
+             debug_generic_stmt (expr);
+             return true;
+           }
+         else if (is_gimple_reg (op)
+                  && TYPE_SIZE (TREE_TYPE (expr)) != TYPE_SIZE (TREE_TYPE (op)))
+           {
+             error ("conversion of register to a different size in %qs",
+                    code_name);
+             debug_generic_stmt (expr);
+             return true;
+           }
+       }
+
       expr = op;
     }
 
+  bool require_non_reg = false;
   while (handled_component_p (expr))
     {
+      require_non_reg = true;
       code_name = get_tree_code_name (TREE_CODE (expr));
 
       if (TREE_CODE (expr) == REALPART_EXPR
@@ -3242,34 +3272,6 @@ verify_types_in_gimple_reference (tree expr, bool require_lvalue)
            }
        }
 
-      if (TREE_CODE (expr) == VIEW_CONVERT_EXPR)
-       {
-         /* For VIEW_CONVERT_EXPRs which are allowed here too, we only check
-            that their operand is not an SSA name or an invariant when
-            requiring an lvalue (this usually means there is a SRA or IPA-SRA
-            bug).  Otherwise there is nothing to verify, gross mismatches at
-            most invoke undefined behavior.  */
-         if (require_lvalue
-             && (TREE_CODE (op) == SSA_NAME
-                 || is_gimple_min_invariant (op)))
-           {
-             error ("conversion of %qs on the left hand side of %qs",
-                    get_tree_code_name (TREE_CODE (op)), code_name);
-             debug_generic_stmt (expr);
-             return true;
-           }
-         else if (TREE_CODE (op) == SSA_NAME
-                  && TYPE_SIZE (TREE_TYPE (expr)) != TYPE_SIZE (TREE_TYPE (op)))
-           {
-             error ("conversion of register to a different size in %qs",
-                    code_name);
-             debug_generic_stmt (expr);
-             return true;
-           }
-         else if (!handled_component_p (op))
-           return false;
-       }
-
       expr = op;
     }
 
@@ -3332,9 +3334,20 @@ verify_types_in_gimple_reference (tree expr, bool require_lvalue)
       debug_generic_stmt (expr);
       return true;
     }
+  else if (require_non_reg
+          && (is_gimple_reg (expr)
+              || (is_gimple_min_invariant (expr)
+                  /* STRING_CSTs are representatives of the string table
+                     entry which lives in memory.  */
+                  && TREE_CODE (expr) != STRING_CST)))
+    {
+      error ("%qs as base where non-register is required", code_name);
+      debug_generic_stmt (expr);
+      return true;
+    }
 
   if (!require_lvalue
-      && (TREE_CODE (expr) == SSA_NAME || is_gimple_min_invariant (expr)))
+      && (is_gimple_reg (expr) || is_gimple_min_invariant (expr)))
     return false;
 
   if (TREE_CODE (expr) != SSA_NAME && is_gimple_id (expr))