Commit b851e3ee by Richard Biener Committed by Richard Biener

fold-const.c (negate_expr_p): Adjust the division case to properly avoid…

fold-const.c (negate_expr_p): Adjust the division case to properly avoid introducing undefined overflow.

2015-10-28  Richard Biener  <rguenther@suse.de>

	* fold-const.c (negate_expr_p): Adjust the division case to
	properly avoid introducing undefined overflow.
	(fold_negate_expr): Likewise.

From-SVN: r229484
parent 056b0995
2015-10-28 Richard Biener <rguenther@suse.de> 2015-10-28 Richard Biener <rguenther@suse.de>
* fold-const.c (negate_expr_p): Adjust the division case to
properly avoid introducing undefined overflow.
(fold_negate_expr): Likewise.
2015-10-28 Richard Biener <rguenther@suse.de>
PR tree-optimization/65962 PR tree-optimization/65962
* tree-ssa-pre.c (eliminate_dom_walker::before_dom_children): * tree-ssa-pre.c (eliminate_dom_walker::before_dom_children):
Avoid creating loop carried dependences also for outer loops Avoid creating loop carried dependences also for outer loops
...@@ -488,29 +488,19 @@ negate_expr_p (tree t) ...@@ -488,29 +488,19 @@ negate_expr_p (tree t)
case TRUNC_DIV_EXPR: case TRUNC_DIV_EXPR:
case ROUND_DIV_EXPR: case ROUND_DIV_EXPR:
case EXACT_DIV_EXPR: case EXACT_DIV_EXPR:
/* In general we can't negate A / B, because if A is INT_MIN and if (TYPE_UNSIGNED (type))
B is 1, we may turn this into INT_MIN / -1 which is undefined break;
and actually traps on some architectures. But if overflow is if (negate_expr_p (TREE_OPERAND (t, 0)))
undefined, we can negate, because - (INT_MIN / 1) is an
overflow. */
if (INTEGRAL_TYPE_P (TREE_TYPE (t)))
{
if (!TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (t)))
break;
/* If overflow is undefined then we have to be careful because
we ask whether it's ok to associate the negate with the
division which is not ok for example for
-((a - b) / c) where (-(a - b)) / c may invoke undefined
overflow because of negating INT_MIN. So do not use
negate_expr_p here but open-code the two important cases. */
if (TREE_CODE (TREE_OPERAND (t, 0)) == NEGATE_EXPR
|| (TREE_CODE (TREE_OPERAND (t, 0)) == INTEGER_CST
&& may_negate_without_overflow_p (TREE_OPERAND (t, 0))))
return true;
}
else if (negate_expr_p (TREE_OPERAND (t, 0)))
return true; return true;
return negate_expr_p (TREE_OPERAND (t, 1)); /* In general we can't negate B in A / B, because if A is INT_MIN and
B is 1, we may turn this into INT_MIN / -1 which is undefined
and actually traps on some architectures. */
if (! INTEGRAL_TYPE_P (TREE_TYPE (t))
|| TYPE_OVERFLOW_WRAPS (TREE_TYPE (t))
|| (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST
&& ! integer_onep (TREE_OPERAND (t, 1))))
return negate_expr_p (TREE_OPERAND (t, 1));
break;
case NOP_EXPR: case NOP_EXPR:
/* Negate -((double)float) as (double)(-float). */ /* Negate -((double)float) as (double)(-float). */
...@@ -680,40 +670,23 @@ fold_negate_expr (location_t loc, tree t) ...@@ -680,40 +670,23 @@ fold_negate_expr (location_t loc, tree t)
case TRUNC_DIV_EXPR: case TRUNC_DIV_EXPR:
case ROUND_DIV_EXPR: case ROUND_DIV_EXPR:
case EXACT_DIV_EXPR: case EXACT_DIV_EXPR:
/* In general we can't negate A / B, because if A is INT_MIN and if (TYPE_UNSIGNED (type))
break;
if (negate_expr_p (TREE_OPERAND (t, 0)))
return fold_build2_loc (loc, TREE_CODE (t), type,
negate_expr (TREE_OPERAND (t, 0)),
TREE_OPERAND (t, 1));
/* In general we can't negate B in A / B, because if A is INT_MIN and
B is 1, we may turn this into INT_MIN / -1 which is undefined B is 1, we may turn this into INT_MIN / -1 which is undefined
and actually traps on some architectures. But if overflow is and actually traps on some architectures. */
undefined, we can negate, because - (INT_MIN / 1) is an if ((! INTEGRAL_TYPE_P (TREE_TYPE (t))
overflow. */ || TYPE_OVERFLOW_WRAPS (TREE_TYPE (t))
if (!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type)) || (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST
{ && ! integer_onep (TREE_OPERAND (t, 1))))
const char * const warnmsg = G_("assuming signed overflow does not " && negate_expr_p (TREE_OPERAND (t, 1)))
"occur when negating a division"); return fold_build2_loc (loc, TREE_CODE (t), type,
tem = TREE_OPERAND (t, 1); TREE_OPERAND (t, 0),
if (negate_expr_p (tem)) negate_expr (TREE_OPERAND (t, 1)));
{
if (INTEGRAL_TYPE_P (type)
&& (TREE_CODE (tem) != INTEGER_CST
|| integer_onep (tem)))
fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MISC);
return fold_build2_loc (loc, TREE_CODE (t), type,
TREE_OPERAND (t, 0), negate_expr (tem));
}
/* If overflow is undefined then we have to be careful because
we ask whether it's ok to associate the negate with the
division which is not ok for example for
-((a - b) / c) where (-(a - b)) / c may invoke undefined
overflow because of negating INT_MIN. So do not use
negate_expr_p here but open-code the two important cases. */
tem = TREE_OPERAND (t, 0);
if ((INTEGRAL_TYPE_P (type)
&& (TREE_CODE (tem) == NEGATE_EXPR
|| (TREE_CODE (tem) == INTEGER_CST
&& may_negate_without_overflow_p (tem))))
|| !INTEGRAL_TYPE_P (type))
return fold_build2_loc (loc, TREE_CODE (t), type,
negate_expr (tem), TREE_OPERAND (t, 1));
}
break; break;
case NOP_EXPR: case NOP_EXPR:
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment