OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

tree-vrp.c (extract_range_from_binary_expr): Remove TRUTH-binary cases and add new bitwise-cases. 

2011-07-27  Kai Tietz  <ktietz@redhat.com>

        * tree-vrp.c (extract_range_from_binary_expr): Remove
        TRUTH-binary cases and add new bitwise-cases.
        (extract_range_from_assignment): Likewise.
        (register_edge_assert_for_1): Likeiwise.
        (register_edge_assert_for): Likewise.
        (simplify_truth_ops_using_ranges): Likewise.
        (simplify_stmt_using_ranges): Likewise.

From-SVN: r176818
This commit is contained in:
Kai Tietz 2011-07-27 11:21:06 +02:00 committed by Kai Tietz
parent d2a99e8756
commit aebf4828b8
2 changed files with 70 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
gcc/ChangeLog
View File

@ -1,3 +1,13 @@
2011-07-27 Kai Tietz <ktietz@redhat.com>
* tree-vrp.c (extract_range_from_binary_expr): Remove
TRUTH-binary cases and add new bitwise-cases.
(extract_range_from_assignment): Likewise.
(register_edge_assert_for_1): Likeiwise.
(register_edge_assert_for): Likewise.
(simplify_truth_ops_using_ranges): Likewise.
(simplify_stmt_using_ranges): Likewise.
2011-07-26 H.J. Lu <hongjiu.lu@intel.com>
PR target/47372

156
gcc/tree-vrp.c
View File

@ -2187,9 +2187,7 @@ extract_range_from_binary_expr (value_range_t *vr,
&& code != MIN_EXPR
&& code != MAX_EXPR
&& code != BIT_AND_EXPR
&& code != BIT_IOR_EXPR
&& code != TRUTH_AND_EXPR
&& code != TRUTH_OR_EXPR)
&& code != BIT_IOR_EXPR)
{
/* We can still do constant propagation here. */
tree const_op0 = op_with_constant_singleton_value_range (op0);
@ -2244,8 +2242,7 @@ extract_range_from_binary_expr (value_range_t *vr,
divisions. TODO, we may be able to derive anti-ranges in
some cases. */
if (code != BIT_AND_EXPR
&& code != TRUTH_AND_EXPR
&& code != TRUTH_OR_EXPR
&& code != BIT_IOR_EXPR
&& code != TRUNC_DIV_EXPR
&& code != FLOOR_DIV_EXPR
&& code != CEIL_DIV_EXPR
@ -2267,7 +2264,12 @@ extract_range_from_binary_expr (value_range_t *vr,
|| POINTER_TYPE_P (TREE_TYPE (op0))
|| POINTER_TYPE_P (TREE_TYPE (op1)))
{
if (code == MIN_EXPR || code == MAX_EXPR)
if (code == BIT_IOR_EXPR)
{
set_value_range_to_varying (vr);
return;
}
else if (code == MIN_EXPR || code == MAX_EXPR)
{
/* For MIN/MAX expressions with pointers, we only care about
nullness, if both are non null, then the result is nonnull.
@ -2312,57 +2314,9 @@ extract_range_from_binary_expr (value_range_t *vr,
/* For integer ranges, apply the operation to each end of the
range and see what we end up with. */
if (code == TRUTH_AND_EXPR
|| code == TRUTH_OR_EXPR)
{
/* If one of the operands is zero, we know that the whole
expression evaluates zero. */
if (code == TRUTH_AND_EXPR
&& ((vr0.type == VR_RANGE
&& integer_zerop (vr0.min)
&& integer_zerop (vr0.max))
|| (vr1.type == VR_RANGE
&& integer_zerop (vr1.min)
&& integer_zerop (vr1.max))))
{
type = VR_RANGE;
min = max = build_int_cst (expr_type, 0);
}
/* If one of the operands is one, we know that the whole
expression evaluates one. */
else if (code == TRUTH_OR_EXPR
&& ((vr0.type == VR_RANGE
&& integer_onep (vr0.min)
&& integer_onep (vr0.max))
|| (vr1.type == VR_RANGE
&& integer_onep (vr1.min)
&& integer_onep (vr1.max))))
{
type = VR_RANGE;
min = max = build_int_cst (expr_type, 1);
}
else if (vr0.type != VR_VARYING
&& vr1.type != VR_VARYING
&& vr0.type == vr1.type
&& !symbolic_range_p (&vr0)
&& !overflow_infinity_range_p (&vr0)
&& !symbolic_range_p (&vr1)
&& !overflow_infinity_range_p (&vr1))
{
/* Boolean expressions cannot be folded with int_const_binop. */
min = fold_binary (code, expr_type, vr0.min, vr1.min);
max = fold_binary (code, expr_type, vr0.max, vr1.max);
}
else
{
/* The result of a TRUTH_*_EXPR is always true or false. */
set_value_range_to_truthvalue (vr, expr_type);
return;
}
}
else if (code == PLUS_EXPR
|| code == MIN_EXPR
|| code == MAX_EXPR)
if (code == PLUS_EXPR
|| code == MIN_EXPR
|| code == MAX_EXPR)
{
/* If we have a PLUS_EXPR with two VR_ANTI_RANGEs, drop to
VR_VARYING. It would take more effort to compute a precise
@ -2694,6 +2648,8 @@ extract_range_from_binary_expr (value_range_t *vr,
bool int_cst_range0, int_cst_range1;
double_int may_be_nonzero0, may_be_nonzero1;
double_int must_be_nonzero0, must_be_nonzero1;
value_range_t *non_singleton_vr;
tree singleton_val;
vr0_int_cst_singleton_p = range_int_cst_singleton_p (&vr0);
vr1_int_cst_singleton_p = range_int_cst_singleton_p (&vr1);
@ -2702,9 +2658,39 @@ extract_range_from_binary_expr (value_range_t *vr,
int_cst_range1 = zero_nonzero_bits_from_vr (&vr1, &may_be_nonzero1,
&must_be_nonzero1);
singleton_val = (vr0_int_cst_singleton_p ? vr0.min : vr1.min);
non_singleton_vr = (vr0_int_cst_singleton_p ? &vr1 : &vr0);
type = VR_RANGE;
if (vr0_int_cst_singleton_p && vr1_int_cst_singleton_p)
min = max = int_const_binop (code, vr0.max, vr1.max);
else if ((vr0_int_cst_singleton_p || vr1_int_cst_singleton_p)
&& (integer_zerop (singleton_val)
|| integer_all_onesp (singleton_val)))
{
/* If one of the operands is zero for and-case, we know that
* the whole expression evaluates zero.
If one of the operands has all bits set to one for
or-case, we know that the whole expression evaluates
to this one. */
min = max = singleton_val;
if ((code == BIT_IOR_EXPR
&& integer_zerop (singleton_val))
|| (code == BIT_AND_EXPR
&& integer_all_onesp (singleton_val)))
/* If one of the operands has all bits set to one, we know
that the whole expression evaluates to the other one for
the and-case.
If one of the operands is zero, we know that the whole
expression evaluates to the other one for the or-case. */
{
type = non_singleton_vr->type;
min = non_singleton_vr->min;
max = non_singleton_vr->max;
}
set_value_range (vr, type, min, max, NULL);
return;
}
else if (!int_cst_range0 && !int_cst_range1)
{
set_value_range_to_varying (vr);
@ -3316,10 +3302,7 @@ extract_range_from_assignment (value_range_t *vr, gimple stmt)
extract_range_from_assert (vr, gimple_assign_rhs1 (stmt));
else if (code == SSA_NAME)
extract_range_from_ssa_name (vr, gimple_assign_rhs1 (stmt));
else if (TREE_CODE_CLASS (code) == tcc_binary
|| code == TRUTH_AND_EXPR
|| code == TRUTH_OR_EXPR
|| code == TRUTH_XOR_EXPR)
else if (TREE_CODE_CLASS (code) == tcc_binary)
extract_range_from_binary_expr (vr, gimple_assign_rhs_code (stmt),
gimple_expr_type (stmt),
gimple_assign_rhs1 (stmt),
@ -4532,11 +4515,9 @@ register_edge_assert_for_1 (tree op, enum tree_code code,
invert);
}
else if ((code == NE_EXPR
&& (gimple_assign_rhs_code (op_def) == TRUTH_AND_EXPR
|| gimple_assign_rhs_code (op_def) == BIT_AND_EXPR))
&& gimple_assign_rhs_code (op_def) == BIT_AND_EXPR)
|| (code == EQ_EXPR
&& (gimple_assign_rhs_code (op_def) == TRUTH_OR_EXPR
|| gimple_assign_rhs_code (op_def) == BIT_IOR_EXPR)))
&& gimple_assign_rhs_code (op_def) == BIT_IOR_EXPR))
{
/* Recurse on each operand. */
retval |= register_edge_assert_for_1 (gimple_assign_rhs1 (op_def),
@ -4601,8 +4582,8 @@ register_edge_assert_for (tree name, edge e, gimple_stmt_iterator si,
the value zero or one, then we may be able to assert values
for SSA_NAMEs which flow into COND. */
/* In the case of NAME == 1 or NAME != 0, for TRUTH_AND_EXPR defining
statement of NAME we can assert both operands of the TRUTH_AND_EXPR
/* In the case of NAME == 1 or NAME != 0, for BIT_AND_EXPR defining
statement of NAME we can assert both operands of the BIT_AND_EXPR
have nonzero value. */
if (((comp_code == EQ_EXPR && integer_onep (val))
|| (comp_code == NE_EXPR && integer_zerop (val))))
@ -4610,8 +4591,7 @@ register_edge_assert_for (tree name, edge e, gimple_stmt_iterator si,
gimple def_stmt = SSA_NAME_DEF_STMT (name);
if (is_gimple_assign (def_stmt)
&& (gimple_assign_rhs_code (def_stmt) == TRUTH_AND_EXPR
|| gimple_assign_rhs_code (def_stmt) == BIT_AND_EXPR))
&& gimple_assign_rhs_code (def_stmt) == BIT_AND_EXPR)
{
tree op0 = gimple_assign_rhs1 (def_stmt);
tree op1 = gimple_assign_rhs2 (def_stmt);
@ -4620,20 +4600,20 @@ register_edge_assert_for (tree name, edge e, gimple_stmt_iterator si,
}
}
/* In the case of NAME == 0 or NAME != 1, for TRUTH_OR_EXPR defining
statement of NAME we can assert both operands of the TRUTH_OR_EXPR
/* In the case of NAME == 0 or NAME != 1, for BIT_IOR_EXPR defining
statement of NAME we can assert both operands of the BIT_IOR_EXPR
have zero value. */
if (((comp_code == EQ_EXPR && integer_zerop (val))
|| (comp_code == NE_EXPR && integer_onep (val))))
{
gimple def_stmt = SSA_NAME_DEF_STMT (name);
/* For BIT_IOR_EXPR only if NAME == 0 both operands have
necessarily zero value, or if type-precision is one. */
if (is_gimple_assign (def_stmt)
&& (gimple_assign_rhs_code (def_stmt) == TRUTH_OR_EXPR
/* For BIT_IOR_EXPR only if NAME == 0 both operands have
necessarily zero value. */
|| (comp_code == EQ_EXPR
&& (gimple_assign_rhs_code (def_stmt) == BIT_IOR_EXPR))))
&& (gimple_assign_rhs_code (def_stmt) == BIT_IOR_EXPR
&& (TYPE_PRECISION (TREE_TYPE (name)) == 1
|| comp_code == EQ_EXPR)))
{
tree op0 = gimple_assign_rhs1 (def_stmt);
tree op1 = gimple_assign_rhs2 (def_stmt);
@ -6804,8 +6784,7 @@ simplify_truth_ops_using_ranges (gimple_stmt_iterator *gsi, gimple stmt)
{
/* Exclude anything that should have been already folded. */
if (rhs_code != EQ_EXPR
&& rhs_code != NE_EXPR
&& rhs_code != TRUTH_XOR_EXPR)
&& rhs_code != NE_EXPR)
return false;
if (!integer_zerop (op1)
@ -6849,14 +6828,9 @@ simplify_truth_ops_using_ranges (gimple_stmt_iterator *gsi, gimple stmt)
else
location = gimple_location (stmt);
if (rhs_code == TRUTH_AND_EXPR || rhs_code == TRUTH_OR_EXPR)
warning_at (location, OPT_Wstrict_overflow,
_("assuming signed overflow does not occur when "
"simplifying && or || to & or |"));
else
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 =
@ -6871,13 +6845,6 @@ simplify_truth_ops_using_ranges (gimple_stmt_iterator *gsi, gimple stmt)
switch (rhs_code)
{
case TRUTH_AND_EXPR:
rhs_code = BIT_AND_EXPR;
break;
case TRUTH_OR_EXPR:
rhs_code = BIT_IOR_EXPR;
break;
case TRUTH_XOR_EXPR:
case NE_EXPR:
if (integer_zerop (op1))
{
@ -7548,9 +7515,6 @@ simplify_stmt_using_ranges (gimple_stmt_iterator *gsi)
case EQ_EXPR:
case NE_EXPR:
case TRUTH_NOT_EXPR:
case TRUTH_AND_EXPR:
case TRUTH_OR_EXPR:
case TRUTH_XOR_EXPR:
/* Transform EQ_EXPR, NE_EXPR, TRUTH_NOT_EXPR into BIT_XOR_EXPR
or identity if the RHS is zero or one, and the LHS are known
to be boolean values. Transform all TRUTH_*_EXPR into