This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[PATCH] Kill verify_expr
- From: Richard Biener <rguenther at suse dot de>
- To: gcc-patches at gcc dot gnu dot org
- Date: Mon, 30 Apr 2018 14:48:40 +0200 (CEST)
- Subject: [PATCH] Kill verify_expr
This finally removes verify_expr and moves all its bells and whistles
(where they exist) elsewhere. There's one pice that didn't fit somewhere
and I put it where it fit most closely (but it still doesn't work because
of weird debug stmts so it's #if 0ed out).
This ends the series of verifier TLC for me at this moment.
Bootstrapped on x86_64-unknown-linux-gnu, testing in progress.
Richard.
2018-04-30 Richard Biener <rguenther@suse.de>
* tree-cfg.c (verify_address): Remove base argument, add
flag whether to check TREE_ADDRESSABLE and do that.
(verify_expr): Remove.
(verify_types_in_gimple_reference): Add pieces from verify_expr.
(verify_gimple_assign_single): Likewise.
(verify_gimple_switch): Likewise.
(verify_expr_location_1): Dereference tp once. Add (disabled)
piece from verify_expr.
(verify_gimple_in_cfg): Do not call verify_expr on all ops.
Index: gcc/tree-cfg.c
===================================================================
*** gcc/tree-cfg.c (revision 259754)
--- gcc/tree-cfg.c (working copy)
*************** gimple_split_edge (edge edge_in)
*** 2982,2991 ****
}
! /* Verify properties of the address expression T with base object BASE. */
! static tree
! verify_address (tree t, tree base)
{
bool old_constant;
bool old_side_effects;
--- 2982,2992 ----
}
! /* Verify properties of the address expression T whose base should be
! TREE_ADDRESSABLE if VERIFY_ADDRESSABLE is true. */
! static bool
! verify_address (tree t, bool verify_addressable)
{
bool old_constant;
bool old_side_effects;
*************** verify_address (tree t, tree base)
*** 3002,3320 ****
if (old_constant != new_constant)
{
error ("constant not recomputed when ADDR_EXPR changed");
! return t;
}
if (old_side_effects != new_side_effects)
{
error ("side effects not recomputed when ADDR_EXPR changed");
! return t;
}
if (!(VAR_P (base)
|| TREE_CODE (base) == PARM_DECL
|| TREE_CODE (base) == RESULT_DECL))
! return NULL_TREE;
if (DECL_GIMPLE_REG_P (base))
{
error ("DECL_GIMPLE_REG_P set on a variable with address taken");
! return base;
}
! return NULL_TREE;
! }
!
! /* Callback for walk_tree, check that all elements with address taken are
! properly noticed as such. The DATA is an int* that is 1 if TP was seen
! inside a PHI node. */
!
! static tree
! verify_expr (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
! {
! tree t = *tp, x;
!
! if (TYPE_P (t))
! *walk_subtrees = 0;
!
! /* Check operand N for being valid GIMPLE and give error MSG if not. */
! #define CHECK_OP(N, MSG) \
! do { if (!is_gimple_val (TREE_OPERAND (t, N))) \
! { error (MSG); return TREE_OPERAND (t, N); }} while (0)
!
! switch (TREE_CODE (t))
{
! case SSA_NAME:
! if (SSA_NAME_IN_FREE_LIST (t))
! {
! error ("SSA name in freelist but still referenced");
! return *tp;
! }
! break;
!
! case PARM_DECL:
! case VAR_DECL:
! case RESULT_DECL:
! {
! tree context = decl_function_context (t);
! if (context != cfun->decl
! && !SCOPE_FILE_SCOPE_P (context)
! && !TREE_STATIC (t)
! && !DECL_EXTERNAL (t))
! {
! error ("Local declaration from a different function");
! return t;
! }
! }
! break;
!
! case INDIRECT_REF:
! error ("INDIRECT_REF in gimple IL");
! return t;
!
! case MEM_REF:
! x = TREE_OPERAND (t, 0);
! if (!POINTER_TYPE_P (TREE_TYPE (x))
! || !is_gimple_mem_ref_addr (x))
! {
! error ("invalid first operand of MEM_REF");
! return x;
! }
! if (!poly_int_tree_p (TREE_OPERAND (t, 1))
! || !POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (t, 1))))
! {
! error ("invalid offset operand of MEM_REF");
! return TREE_OPERAND (t, 1);
! }
! if (TREE_CODE (x) == ADDR_EXPR)
! {
! tree va = verify_address (x, TREE_OPERAND (x, 0));
! if (va)
! return va;
! x = TREE_OPERAND (x, 0);
! }
! walk_tree (&x, verify_expr, data, NULL);
! *walk_subtrees = 0;
! break;
!
! case ASSERT_EXPR:
! x = fold (ASSERT_EXPR_COND (t));
! if (x == boolean_false_node)
! {
! error ("ASSERT_EXPR with an always-false condition");
! return *tp;
! }
! break;
!
! case MODIFY_EXPR:
! error ("MODIFY_EXPR not expected while having tuples");
! return *tp;
!
! case ADDR_EXPR:
! {
! tree tem;
!
! gcc_assert (is_gimple_address (t));
!
! /* Skip any references (they will be checked when we recurse down the
! tree) and ensure that any variable used as a prefix is marked
! addressable. */
! for (x = TREE_OPERAND (t, 0);
! handled_component_p (x);
! x = TREE_OPERAND (x, 0))
! ;
!
! if ((tem = verify_address (t, x)))
! return tem;
!
! if (!(VAR_P (x)
! || TREE_CODE (x) == PARM_DECL
! || TREE_CODE (x) == RESULT_DECL))
! return NULL;
!
! if (!TREE_ADDRESSABLE (x))
! {
! error ("address taken, but ADDRESSABLE bit not set");
! return x;
! }
!
! break;
! }
!
! case COND_EXPR:
! gcc_unreachable ();
!
! case NON_LVALUE_EXPR:
! case TRUTH_NOT_EXPR:
! gcc_unreachable ();
!
! CASE_CONVERT:
! case FIX_TRUNC_EXPR:
! case FLOAT_EXPR:
! case NEGATE_EXPR:
! case ABS_EXPR:
! case BIT_NOT_EXPR:
! gcc_unreachable ();
!
! case REALPART_EXPR:
! case IMAGPART_EXPR:
! case BIT_FIELD_REF:
! if (!is_gimple_reg_type (TREE_TYPE (t)))
! {
! error ("non-scalar BIT_FIELD_REF, IMAGPART_EXPR or REALPART_EXPR");
! return t;
! }
!
! if (TREE_CODE (t) == BIT_FIELD_REF)
! {
! tree t0 = TREE_OPERAND (t, 0);
! tree t1 = TREE_OPERAND (t, 1);
! tree t2 = TREE_OPERAND (t, 2);
! poly_uint64 size, bitpos;
! if (!poly_int_tree_p (t1, &size)
! || !poly_int_tree_p (t2, &bitpos)
! || !types_compatible_p (bitsizetype, TREE_TYPE (t1))
! || !types_compatible_p (bitsizetype, TREE_TYPE (t2)))
! {
! error ("invalid position or size operand to BIT_FIELD_REF");
! return t;
! }
! if (INTEGRAL_TYPE_P (TREE_TYPE (t))
! && maybe_ne (TYPE_PRECISION (TREE_TYPE (t)), size))
! {
! error ("integral result type precision does not match "
! "field size of BIT_FIELD_REF");
! return t;
! }
! else if (!INTEGRAL_TYPE_P (TREE_TYPE (t))
! && TYPE_MODE (TREE_TYPE (t)) != BLKmode
! && maybe_ne (GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (t))),
! size))
! {
! error ("mode size of non-integral result does not "
! "match field size of BIT_FIELD_REF");
! return t;
! }
! if (!AGGREGATE_TYPE_P (TREE_TYPE (t0))
! && maybe_gt (size + bitpos,
! tree_to_poly_uint64 (TYPE_SIZE (TREE_TYPE (t0)))))
! {
! error ("position plus size exceeds size of referenced object in "
! "BIT_FIELD_REF");
! return t;
! }
! }
! t = TREE_OPERAND (t, 0);
!
! /* Fall-through. */
! case COMPONENT_REF:
! case ARRAY_REF:
! case ARRAY_RANGE_REF:
! case VIEW_CONVERT_EXPR:
! /* We have a nest of references. Verify that each of the operands
! that determine where to reference is either a constant or a variable,
! verify that the base is valid, and then show we've already checked
! the subtrees. */
! while (handled_component_p (t))
! {
! if (TREE_CODE (t) == COMPONENT_REF && TREE_OPERAND (t, 2))
! CHECK_OP (2, "invalid COMPONENT_REF offset operator");
! else if (TREE_CODE (t) == ARRAY_REF
! || TREE_CODE (t) == ARRAY_RANGE_REF)
! {
! CHECK_OP (1, "invalid array index");
! if (TREE_OPERAND (t, 2))
! CHECK_OP (2, "invalid array lower bound");
! if (TREE_OPERAND (t, 3))
! CHECK_OP (3, "invalid array stride");
! }
! else if (TREE_CODE (t) == BIT_FIELD_REF
! || TREE_CODE (t) == REALPART_EXPR
! || TREE_CODE (t) == IMAGPART_EXPR)
! {
! error ("non-top-level BIT_FIELD_REF, IMAGPART_EXPR or "
! "REALPART_EXPR");
! return t;
! }
!
! t = TREE_OPERAND (t, 0);
! }
!
! if (!is_gimple_min_invariant (t) && !is_gimple_lvalue (t))
! {
! error ("invalid reference prefix");
! return t;
! }
! walk_tree (&t, verify_expr, data, NULL);
! *walk_subtrees = 0;
! break;
! case PLUS_EXPR:
! case MINUS_EXPR:
! gcc_unreachable ();
!
! case POINTER_DIFF_EXPR:
! gcc_unreachable ();
!
! case POINTER_PLUS_EXPR:
! 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 LSHIFT_EXPR:
! case RSHIFT_EXPR:
! case LROTATE_EXPR:
! case RROTATE_EXPR:
! case BIT_IOR_EXPR:
! case BIT_XOR_EXPR:
! case BIT_AND_EXPR:
! gcc_unreachable ();
!
! 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:
! /* Reachable via COND_EXPR condition which is GENERIC. */
! CHECK_OP (0, "invalid operand to binary operator");
! CHECK_OP (1, "invalid operand to binary operator");
! break;
!
! case CONSTRUCTOR:
! if (TREE_CONSTANT (t) && TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
! *walk_subtrees = 0;
! break;
!
! case CASE_LABEL_EXPR:
! if (CASE_CHAIN (t))
! {
! error ("invalid CASE_CHAIN");
! return t;
! }
! break;
!
! default:
! break;
}
- return NULL;
! #undef CHECK_OP
}
--- 3003,3038 ----
if (old_constant != new_constant)
{
error ("constant not recomputed when ADDR_EXPR changed");
! return true;
}
if (old_side_effects != new_side_effects)
{
error ("side effects not recomputed when ADDR_EXPR changed");
! return true;
}
+ tree base = TREE_OPERAND (t, 0);
+ while (handled_component_p (base))
+ base = TREE_OPERAND (base, 0);
+
if (!(VAR_P (base)
|| TREE_CODE (base) == PARM_DECL
|| TREE_CODE (base) == RESULT_DECL))
! return false;
if (DECL_GIMPLE_REG_P (base))
{
error ("DECL_GIMPLE_REG_P set on a variable with address taken");
! return true;
}
! if (verify_addressable && !TREE_ADDRESSABLE (base))
{
! error ("address taken, but ADDRESSABLE bit not set");
! return true;
}
! return false;
}
*************** verify_types_in_gimple_min_lval (tree ex
*** 3359,3366 ****
--- 3077,3155 ----
static bool
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 op = TREE_OPERAND (expr, 0);
+ if (!is_gimple_reg_type (TREE_TYPE (expr)))
+ {
+ error ("non-scalar BIT_FIELD_REF, IMAGPART_EXPR or REALPART_EXPR");
+ return true;
+ }
+
+ if (TREE_CODE (expr) == BIT_FIELD_REF)
+ {
+ tree t1 = TREE_OPERAND (expr, 1);
+ tree t2 = TREE_OPERAND (expr, 2);
+ poly_uint64 size, bitpos;
+ if (!poly_int_tree_p (t1, &size)
+ || !poly_int_tree_p (t2, &bitpos)
+ || !types_compatible_p (bitsizetype, TREE_TYPE (t1))
+ || !types_compatible_p (bitsizetype, TREE_TYPE (t2)))
+ {
+ error ("invalid position or size operand to BIT_FIELD_REF");
+ return true;
+ }
+ if (INTEGRAL_TYPE_P (TREE_TYPE (expr))
+ && maybe_ne (TYPE_PRECISION (TREE_TYPE (expr)), size))
+ {
+ error ("integral result type precision does not match "
+ "field size of BIT_FIELD_REF");
+ return true;
+ }
+ else if (!INTEGRAL_TYPE_P (TREE_TYPE (expr))
+ && TYPE_MODE (TREE_TYPE (expr)) != BLKmode
+ && maybe_ne (GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr))),
+ size))
+ {
+ error ("mode size of non-integral result does not "
+ "match field size of BIT_FIELD_REF");
+ return true;
+ }
+ if (!AGGREGATE_TYPE_P (TREE_TYPE (op))
+ && maybe_gt (size + bitpos,
+ tree_to_poly_uint64 (TYPE_SIZE (TREE_TYPE (op)))))
+ {
+ error ("position plus size exceeds size of referenced object in "
+ "BIT_FIELD_REF");
+ return true;
+ }
+ }
+
+ if ((TREE_CODE (expr) == REALPART_EXPR
+ || TREE_CODE (expr) == IMAGPART_EXPR)
+ && !useless_type_conversion_p (TREE_TYPE (expr),
+ TREE_TYPE (TREE_TYPE (op))))
+ {
+ error ("type mismatch in real/imagpart reference");
+ debug_generic_stmt (TREE_TYPE (expr));
+ debug_generic_stmt (TREE_TYPE (TREE_TYPE (op)));
+ return true;
+ }
+ expr = op;
+ }
+
while (handled_component_p (expr))
{
+ if (TREE_CODE (expr) == REALPART_EXPR
+ || TREE_CODE (expr) == IMAGPART_EXPR
+ || TREE_CODE (expr) == BIT_FIELD_REF)
+ {
+ error ("non-top-level BIT_FIELD_REF, IMAGPART_EXPR or REALPART_EXPR");
+ return true;
+ }
+
tree op = TREE_OPERAND (expr, 0);
if (TREE_CODE (expr) == ARRAY_REF
*************** verify_types_in_gimple_reference (tree e
*** 3398,3422 ****
return true;
}
! if ((TREE_CODE (expr) == REALPART_EXPR
! || TREE_CODE (expr) == IMAGPART_EXPR)
! && !useless_type_conversion_p (TREE_TYPE (expr),
! TREE_TYPE (TREE_TYPE (op))))
! {
! error ("type mismatch in real/imagpart reference");
! debug_generic_stmt (TREE_TYPE (expr));
! debug_generic_stmt (TREE_TYPE (TREE_TYPE (op)));
! return true;
! }
!
! if (TREE_CODE (expr) == COMPONENT_REF
! && !useless_type_conversion_p (TREE_TYPE (expr),
! TREE_TYPE (TREE_OPERAND (expr, 1))))
{
! error ("type mismatch in component reference");
! debug_generic_stmt (TREE_TYPE (expr));
! debug_generic_stmt (TREE_TYPE (TREE_OPERAND (expr, 1)));
! return true;
}
if (TREE_CODE (expr) == VIEW_CONVERT_EXPR)
--- 3187,3208 ----
return true;
}
! if (TREE_CODE (expr) == COMPONENT_REF)
{
! if (TREE_OPERAND (expr, 2)
! && !is_gimple_val (TREE_OPERAND (expr, 2)))
! {
! error ("invalid COMPONENT_REF offset operator");
! return true;
! }
! if (!useless_type_conversion_p (TREE_TYPE (expr),
! TREE_TYPE (TREE_OPERAND (expr, 1))))
! {
! error ("type mismatch in component reference");
! debug_generic_stmt (TREE_TYPE (expr));
! debug_generic_stmt (TREE_TYPE (TREE_OPERAND (expr, 1)));
! return true;
! }
}
if (TREE_CODE (expr) == VIEW_CONVERT_EXPR)
*************** verify_types_in_gimple_reference (tree e
*** 3450,3456 ****
if (TREE_CODE (expr) == MEM_REF)
{
! if (!is_gimple_mem_ref_addr (TREE_OPERAND (expr, 0)))
{
error ("invalid address operand in MEM_REF");
debug_generic_stmt (expr);
--- 3236,3244 ----
if (TREE_CODE (expr) == MEM_REF)
{
! if (!is_gimple_mem_ref_addr (TREE_OPERAND (expr, 0))
! || (TREE_CODE (TREE_OPERAND (expr, 0)) == ADDR_EXPR
! && verify_address (TREE_OPERAND (expr, 0), false)))
{
error ("invalid address operand in MEM_REF");
debug_generic_stmt (expr);
*************** verify_types_in_gimple_reference (tree e
*** 3467,3473 ****
else if (TREE_CODE (expr) == TARGET_MEM_REF)
{
if (!TMR_BASE (expr)
! || !is_gimple_mem_ref_addr (TMR_BASE (expr)))
{
error ("invalid address operand in TARGET_MEM_REF");
return true;
--- 3255,3263 ----
else if (TREE_CODE (expr) == TARGET_MEM_REF)
{
if (!TMR_BASE (expr)
! || !is_gimple_mem_ref_addr (TMR_BASE (expr))
! || (TREE_CODE (TMR_BASE (expr)) == ADDR_EXPR
! && verify_address (TMR_BASE (expr), false)))
{
error ("invalid address operand in TARGET_MEM_REF");
return true;
*************** verify_types_in_gimple_reference (tree e
*** 3481,3486 ****
--- 3271,3282 ----
return true;
}
}
+ else if (TREE_CODE (expr) == INDIRECT_REF)
+ {
+ error ("INDIRECT_REF in gimple IL");
+ debug_generic_stmt (expr);
+ return true;
+ }
return ((require_lvalue || !is_gimple_min_invariant (expr))
&& verify_types_in_gimple_min_lval (expr));
*************** verify_gimple_assign_single (gassign *st
*** 4579,4585 ****
return true;
}
! return verify_types_in_gimple_reference (op, true);
}
/* tcc_reference */
--- 4375,4382 ----
return true;
}
! return (verify_address (rhs1, true)
! || verify_types_in_gimple_reference (op, true));
}
/* tcc_reference */
*************** verify_gimple_assign_single (gassign *st
*** 4719,4726 ****
return true;
}
return res;
! case OBJ_TYPE_REF:
case ASSERT_EXPR:
case WITH_SIZE_EXPR:
/* FIXME. */
return res;
--- 4516,4534 ----
return true;
}
return res;
!
case ASSERT_EXPR:
+ /* FIXME. */
+ rhs1 = fold (ASSERT_EXPR_COND (rhs1));
+ if (rhs1 == boolean_false_node)
+ {
+ error ("ASSERT_EXPR with an always-false condition");
+ debug_generic_stmt (rhs1);
+ return true;
+ }
+ break;
+
+ case OBJ_TYPE_REF:
case WITH_SIZE_EXPR:
/* FIXME. */
return res;
*************** verify_gimple_switch (gswitch *stmt)
*** 4845,4851 ****
}
elt = gimple_switch_label (stmt, 0);
! if (CASE_LOW (elt) != NULL_TREE || CASE_HIGH (elt) != NULL_TREE)
{
error ("invalid default case label in switch statement");
debug_generic_expr (elt);
--- 4653,4661 ----
}
elt = gimple_switch_label (stmt, 0);
! if (CASE_LOW (elt) != NULL_TREE
! || CASE_HIGH (elt) != NULL_TREE
! || CASE_CHAIN (elt) != NULL_TREE)
{
error ("invalid default case label in switch statement");
debug_generic_expr (elt);
*************** verify_gimple_switch (gswitch *stmt)
*** 4857,4862 ****
--- 4667,4678 ----
{
elt = gimple_switch_label (stmt, i);
+ if (CASE_CHAIN (elt))
+ {
+ error ("invalid CASE_CHAIN");
+ debug_generic_expr (elt);
+ return true;
+ }
if (! CASE_LOW (elt))
{
error ("invalid case label in switch statement");
*************** static tree
*** 5310,5343 ****
verify_expr_location_1 (tree *tp, int *walk_subtrees, void *data)
{
hash_set<tree> *blocks = (hash_set<tree> *) data;
! if (VAR_P (*tp) && DECL_HAS_DEBUG_EXPR_P (*tp))
{
! tree t = DECL_DEBUG_EXPR (*tp);
! tree addr = walk_tree (&t, verify_expr_no_block, NULL, NULL);
if (addr)
return addr;
}
! if ((VAR_P (*tp)
! || TREE_CODE (*tp) == PARM_DECL
! || TREE_CODE (*tp) == RESULT_DECL)
! && DECL_HAS_VALUE_EXPR_P (*tp))
{
! tree t = DECL_VALUE_EXPR (*tp);
! tree addr = walk_tree (&t, verify_expr_no_block, NULL, NULL);
if (addr)
return addr;
}
! if (!EXPR_P (*tp))
{
*walk_subtrees = false;
return NULL;
}
! location_t loc = EXPR_LOCATION (*tp);
if (verify_location (blocks, loc))
! return *tp;
return NULL;
}
--- 5126,5181 ----
verify_expr_location_1 (tree *tp, int *walk_subtrees, void *data)
{
hash_set<tree> *blocks = (hash_set<tree> *) data;
+ tree t = *tp;
! /* ??? This doesn't really belong here but there's no good place to
! stick this remainder of old verify_expr. */
! /* ??? This barfs on debug stmts which contain binds to vars with
! different function context. */
! #if 0
! if (VAR_P (t)
! || TREE_CODE (t) == PARM_DECL
! || TREE_CODE (t) == RESULT_DECL)
! {
! tree context = decl_function_context (t);
! if (context != cfun->decl
! && !SCOPE_FILE_SCOPE_P (context)
! && !TREE_STATIC (t)
! && !DECL_EXTERNAL (t))
! {
! error ("local declaration from a different function");
! return t;
! }
! }
! #endif
!
! if (VAR_P (t) && DECL_HAS_DEBUG_EXPR_P (t))
{
! tree x = DECL_DEBUG_EXPR (t);
! tree addr = walk_tree (&x, verify_expr_no_block, NULL, NULL);
if (addr)
return addr;
}
! if ((VAR_P (t)
! || TREE_CODE (t) == PARM_DECL
! || TREE_CODE (t) == RESULT_DECL)
! && DECL_HAS_VALUE_EXPR_P (t))
{
! tree x = DECL_VALUE_EXPR (t);
! tree addr = walk_tree (&x, verify_expr_no_block, NULL, NULL);
if (addr)
return addr;
}
! if (!EXPR_P (t))
{
*walk_subtrees = false;
return NULL;
}
! location_t loc = EXPR_LOCATION (t);
if (verify_location (blocks, loc))
! return t;
return NULL;
}
*************** verify_gimple_in_cfg (struct function *f
*** 5479,5499 ****
err2 |= true;
}
- /* ??? Instead of not checking these stmts at all the walker
- should know its context via wi. */
- if (!is_gimple_debug (stmt)
- && !is_gimple_omp (stmt))
- {
- memset (&wi, 0, sizeof (wi));
- addr = walk_gimple_op (stmt, verify_expr, &wi);
- if (addr)
- {
- debug_generic_expr (addr);
- inform (gimple_location (stmt), "in statement");
- err2 |= true;
- }
- }
-
/* If the statement is marked as part of an EH region, then it is
expected that the statement could throw. Verify that when we
have optimizations that simplify statements such that we prove
--- 5317,5322 ----