Hello,
this patch adds the ability for bitwise-truth operations to sink into
use-statement, if it is a cast, if type of it is compatible.
By this we can sink cases like
_Bool D1, D2, D3;
int R, x, y;
D1 = (bool) x;
D2 = (bool) y;
D3 = D1 & D2
R = (int) D3;
into R-statment as
R = x & y;
This fixes known vrp47.c regression.
ChangeLog gcc
2011-07-21 Kai Tietz <kti...@redhat.com>
* tree-vrp.c (ssa_name_get_inner_ssa_name_p): New helper.
(ssa_name_get_cast_to_p): Likewise.
(simplify_truth_ops_using_ranges): Try to use type-cast
for simplification of bitwise-binary expressions.
(simplify_stmt_using_ranges): Try to sink into cast for
bitwise-truth operations.
2011-07-21 Kai Tietz <kti...@redhat.com>
* gcc.dg/tree-ssa/vrp47.c: Adjust testcase.
Bootstrapped and regression tested for all standard languages
(including Ada and Obj-C++) on
host x86_64-pc-linux-gnu. Ok for apply?
Regards,
Kai
Index: gcc-head/gcc/tree-vrp.c
===================================================================
--- gcc-head.orig/gcc/tree-vrp.c
+++ gcc-head/gcc/tree-vrp.c
@@ -6747,19 +6746,92 @@ varying:
return SSA_PROP_VARYING;
}
+/* Returns operand1 of ssa-name with SSA_NAME as code, Otherwise it
+ returns NULL_TREE. */
+static tree
+ssa_name_get_inner_ssa_name_p (tree op)
+{
+ gimple stmt;
+
+ if (TREE_CODE (op) != SSA_NAME
+ || !is_gimple_assign (SSA_NAME_DEF_STMT (op)))
+ return NULL_TREE;
+ stmt = SSA_NAME_DEF_STMT (op);
+ if (gimple_assign_rhs_code (stmt) != SSA_NAME)
+ return NULL_TREE;
+ return gimple_assign_rhs1 (stmt);
+}
+
+/* Returns operand of cast operation, if OP is a type-conversion. Otherwise
+ return NULL_TREE. */
+static tree
+ssa_name_get_cast_to_p (tree op)
+{
+ gimple stmt;
+
+ if (TREE_CODE (op) != SSA_NAME
+ || !is_gimple_assign (SSA_NAME_DEF_STMT (op)))
+ return NULL_TREE;
+ stmt = SSA_NAME_DEF_STMT (op);
+ if (!CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt)))
+ return NULL_TREE;
+ return gimple_assign_rhs1 (stmt);
+}
+
/* Simplify boolean operations if the source is known
to be already a boolean. */
static bool
simplify_truth_ops_using_ranges (gimple_stmt_iterator *gsi, gimple stmt)
{
enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
+ gimple stmt2 = stmt;
tree val = NULL;
tree op0, op1;
value_range_t *vr;
bool sop = false;
bool need_conversion;
+ location_t loc = gimple_location (stmt);
op0 = gimple_assign_rhs1 (stmt);
+ op1 = NULL_TREE;
+
+ /* Handle cases with prefixed type-cast. */
+ if (CONVERT_EXPR_CODE_P (rhs_code)
+ && INTEGRAL_TYPE_P (TREE_TYPE (op0))
+ && TREE_CODE (op0) == SSA_NAME
+ && is_gimple_assign (SSA_NAME_DEF_STMT (op0))
+ && INTEGRAL_TYPE_P (TREE_TYPE (gimple_assign_lhs (stmt))))
+ {
+ stmt2 = SSA_NAME_DEF_STMT (op0);
+ op0 = gimple_assign_rhs1 (stmt2);
+ if (!INTEGRAL_TYPE_P (TREE_TYPE (op0)))
+ return false;
+ rhs_code = gimple_assign_rhs_code (stmt2);
+ if (rhs_code != BIT_NOT_EXPR
+ && rhs_code != BIT_AND_EXPR
+ && rhs_code != BIT_IOR_EXPR
+ && rhs_code != BIT_XOR_EXPR
+ && rhs_code != NE_EXPR && rhs_code != EQ_EXPR)
+ return false;
+
+ if (rhs_code != BIT_NOT_EXPR)
+ op1 = gimple_assign_rhs2 (stmt2);
+
+ if (gimple_has_location (stmt2))
+ loc = gimple_location (stmt2);
+ }
+ else if (CONVERT_EXPR_CODE_P (rhs_code))
+ return false;
+ else if (rhs_code != BIT_NOT_EXPR)
+ op1 = gimple_assign_rhs2 (stmt);
+
+ /* ~X is only equivalent to !X, if type-precision is one and X has
+ an integral type. */
+ if (rhs_code == BIT_NOT_EXPR
+ && (!INTEGRAL_TYPE_P (TREE_TYPE (op0))
+ || TYPE_PRECISION (TREE_TYPE (op0)) != 1))
+ return false;
+
if (TYPE_PRECISION (TREE_TYPE (op0)) != 1)
{
if (TREE_CODE (op0) != SSA_NAME)
@@ -6775,19 +6847,83 @@ simplify_truth_ops_using_ranges (gimple_
return false;
}
- if (rhs_code == BIT_NOT_EXPR && TYPE_PRECISION (TREE_TYPE (op0)) == 1)
+ need_conversion =
+ !useless_type_conversion_p (TREE_TYPE (gimple_assign_lhs (stmt)),
+ TREE_TYPE (op0));
+ /* As comparisons X != 0 getting folded to (bool) X by VRP,
+ but X == 0 might be not folded for none boolean type of X
+ to (bool) (X ^ 1), we need to handle this case special
+ to simplify this.
+ For bitwise-binary operations we have three cases to handle:
+ a) ((bool) X) op ((bool) Y)
+ b) ((bool) X) op (Y == 0) -OR- (X == 0) op ((bool) Y)
+ c) (X == 0) op (Y == 0)
+ The later two cases can't be handled for now, as we would beed to
+ insert new statements. */
+ if (need_conversion
+ && (rhs_code == BIT_XOR_EXPR
+ || rhs_code == BIT_AND_EXPR
+ || rhs_code == BIT_IOR_EXPR)
+ && TREE_CODE (op1) == SSA_NAME
+ && TREE_CODE (op0) == SSA_NAME)
{
- rhs_code = NE_EXPR;
- op1 = build_int_cst (TREE_TYPE (op0), 1);
+ tree cop0 = ssa_name_get_cast_to_p (op0);
+ tree cop1 = ssa_name_get_cast_to_p (op1);
+
+ /* We would need an new statment for cases b and c, and we can't
+ due vr table, so bail out. */
+ if (!cop0 || !cop1)
+ return false;
+
+ if (!INTEGRAL_TYPE_P (TREE_TYPE (cop0))
+ || !types_compatible_p (TREE_TYPE (cop0), TREE_TYPE (cop1)))
+ return false;
+
+ need_conversion =
+ !useless_type_conversion_p (TREE_TYPE (gimple_assign_lhs (stmt)),
+ TREE_TYPE (cop0));
+ if (need_conversion)
+ return false;
+
+ op0 = cop0;
+ op1 = cop1;
+
+ /* We need to re-check if value ranges for new operands
+ for 1-bit precision/range. */
+ if (TYPE_PRECISION (TREE_TYPE (op0)) != 1)
+ {
+ if (TREE_CODE (op0) != SSA_NAME)
+ return false;
+ vr = get_value_range (op0);
+
+ val = compare_range_with_value (GE_EXPR, vr, integer_zero_node, &sop);
+ if (!val || !integer_onep (val))
+ return false;
+
+ val = compare_range_with_value (LE_EXPR, vr, integer_one_node, &sop);
+ if (!val || !integer_onep (val))
+ return false;
+ }
+
+ if (TYPE_PRECISION (TREE_TYPE (op1)) != 1)
+ {
+ vr = get_value_range (op1);
+ val = compare_range_with_value (GE_EXPR, vr, integer_zero_node, &sop);
+ if (!val || !integer_onep (val))
+ return false;
+
+ val = compare_range_with_value (LE_EXPR, vr, integer_one_node, &sop);
+ if (!val || !integer_onep (val))
+ return false;
+ }
}
- else
- {
- op1 = gimple_assign_rhs2 (stmt);
- /* Reduce number of cases to handle. */
+ /* Reduce number of cases to handle. */
+ if (op1 != NULL_TREE)
+ {
if (is_gimple_min_invariant (op1))
{
- /* Exclude anything that should have been already folded. */
+ /* Exclude anything that should have been already folded. */
if (rhs_code != EQ_EXPR
&& rhs_code != NE_EXPR
&& rhs_code != BIT_XOR_EXPR)
@@ -6818,32 +6954,34 @@ simplify_truth_ops_using_ranges (gimple_
vr = get_value_range (op1);
val = compare_range_with_value (GE_EXPR, vr, integer_zero_node,
&sop);
if (!val || !integer_onep (val))
- return false;
+ return false;
val = compare_range_with_value (LE_EXPR, vr, integer_one_node,
&sop);
if (!val || !integer_onep (val))
- return false;
+ return false;
}
}
- }
- if (sop && issue_strict_overflow_warning (WARN_STRICT_OVERFLOW_MISC))
- {
- location_t location;
+ if (sop && issue_strict_overflow_warning (WARN_STRICT_OVERFLOW_MISC))
+ {
+ location_t location;
- if (!gimple_has_location (stmt))
- location = input_location;
- else
- location = gimple_location (stmt);
+ if (!gimple_has_location (stmt))
+ location = input_location;
+ else
+ location = gimple_location (stmt);
- warning_at (location, OPT_Wstrict_overflow,
- _("assuming signed overflow does not occur when "
- "simplifying ==, != or ! to identity or ^"));
+ warning_at (location, OPT_Wstrict_overflow,
+ _("assuming signed overflow does not occur when "
+ "simplifying ==, != or ! to identity or ^"));
+ }
}
- need_conversion =
- !useless_type_conversion_p (TREE_TYPE (gimple_assign_lhs (stmt)),
- TREE_TYPE (op0));
+ if (rhs_code == BIT_NOT_EXPR)
+ {
+ rhs_code = NE_EXPR;
+ op1 = build_int_cst (TREE_TYPE (op0), 1);
+ }
/* Make sure to not sign-extend -1 as a boolean value. */
if (need_conversion
@@ -6863,6 +7001,7 @@ simplify_truth_ops_using_ranges (gimple_
gimple_assign_set_rhs_with_ops (gsi,
need_conversion ? NOP_EXPR : SSA_NAME,
op0, NULL);
+ gimple_set_location (stmt, loc);
update_stmt (gsi_stmt (*gsi));
return true;
}
@@ -6873,10 +7012,20 @@ simplify_truth_ops_using_ranges (gimple_
gcc_unreachable ();
}
+ /* We can't insert here new expression as otherwise
+ tracked vr tables getting out of bounds. */
if (need_conversion)
return false;
+ /* Reduce here simple SSA_NAME assignments to other expressions.
+ This produces better results. */
+ while ((val = ssa_name_get_inner_ssa_name_p (op0)) != NULL_TREE)
+ op0 = val;
+ while ((val = ssa_name_get_inner_ssa_name_p (op1)) != NULL_TREE)
+ op1 = val;
+
gimple_assign_set_rhs_with_ops (gsi, rhs_code, op0, op1);
+ gimple_set_location (stmt, loc);
update_stmt (gsi_stmt (*gsi));
return true;
}
@@ -7455,7 +7604,11 @@ simplify_stmt_using_ranges (gimple_stmt_
CASE_CONVERT:
if (TREE_CODE (rhs1) == SSA_NAME
&& INTEGRAL_TYPE_P (TREE_TYPE (rhs1)))
- return simplify_conversion_using_ranges (stmt);
+ {
+ if (simplify_truth_ops_using_ranges (gsi, stmt))
+ return true;
+ return simplify_conversion_using_ranges (stmt);
+ }
break;
default:
Index: gcc-head/gcc/testsuite/gcc.dg/tree-ssa/vrp47.c
===================================================================
--- gcc-head.orig/gcc/testsuite/gcc.dg/tree-ssa/vrp47.c
+++ gcc-head/gcc/testsuite/gcc.dg/tree-ssa/vrp47.c
@@ -4,7 +4,7 @@
jumps when evaluating an && condition. VRP is not able to optimize
this. */
/* { dg-do compile { target { ! "mips*-*-* s390*-*-* avr-*-*
mn10300-*-*" } } } */
-/* { dg-options "-O2 -fdump-tree-vrp -fdump-tree-dom" } */
+/* { dg-options "-O2 -fdump-tree-vrp" } */
/* { dg-options "-O2 -fdump-tree-vrp -fdump-tree-dom -march=i586" {
target { i?86-*-* && ilp32 } } } */
int h(int x, int y)
@@ -36,13 +36,10 @@ int f(int x)
0 or 1. */
/* { dg-final { scan-tree-dump-times "\[xy\]\[^ \]* !=" 0 "vrp1" } } */
-/* This one needs more copy propagation that only happens in dom1. */
-/* { dg-final { scan-tree-dump-times "x\[^ \]* & y" 1 "dom1" } } */
-/* { dg-final { scan-tree-dump-times "x\[^ \]* & y" 1 "vrp1" { xfail
*-*-* } } } */
+/* { dg-final { scan-tree-dump-times "x\[^ \]* & y" 1 "vrp1" } } */
/* These two are fully simplified by VRP. */
/* { dg-final { scan-tree-dump-times "x\[^ \]* \[|\] y" 1 "vrp1" } } */
/* { dg-final { scan-tree-dump-times "x\[^ \]* \\^ 1" 1 "vrp1" } } */
/* { dg-final { cleanup-tree-dump "vrp\[0-9\]" } } */
-/* { dg-final { cleanup-tree-dump "dom\[0-9\]" } } */
