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.
Bootstrapped and tested with all languages enabled on
x86_64-unknown-linux-gnu with {,-m32}.
Pushed.
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.
---
gcc/tree-cfg.cc | 75 +++++++++++++++++++++++++++++--------------------
1 file changed, 44 insertions(+), 31 deletions(-)
diff --git a/gcc/tree-cfg.cc b/gcc/tree-cfg.cc
index 5ef201adb25..4927fc0a8d9 100644
--- 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))
--
2.35.3
