On Tue, 27 Oct 2015, Richard Biener wrote:
> On Tue, 27 Oct 2015, Richard Biener wrote:
>
> >
> > The following patch adjusts negate_expr_p to account for the fact
> > that we can't generally change a - (b - c) to (c - b) + a because
> > -INF - 0 is ok while 0 - -INF not. Similarly for a - (b + c).
> > While creating testcases I noticed that MULT_EXPR handling is bogus
> > as well as with -INF/2 * 2 neither operand can be negated safely.
> >
> > I believe the division case is also still wrong but I refrained
> > from touching it with this patch.
>
> Here is the division part.
>
> Bootstrap / regtest running on x86_64-unknown-linux-gnu. A
> related testcase went in with r202204.
Applied as follows.
Bootstrapped / tested on x86_64-unknown-linux-gnu.
Richard.
2015-10-28 Richard Biener <rguent...@suse.de>
* fold-const.c (negate_expr_p): Adjust the division case to
properly avoid introducing undefined overflow.
(fold_negate_expr): Likewise.
Index: gcc/fold-const.c
===================================================================
--- gcc/fold-const.c (revision 229481)
+++ gcc/fold-const.c (working copy)
@@ -488,29 +488,19 @@ negate_expr_p (tree t)
case TRUNC_DIV_EXPR:
case ROUND_DIV_EXPR:
case EXACT_DIV_EXPR:
- /* In general we can't negate 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. But if overflow is
- 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)))
+ if (TYPE_UNSIGNED (type))
+ break;
+ if (negate_expr_p (TREE_OPERAND (t, 0)))
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:
/* Negate -((double)float) as (double)(-float). */
@@ -680,40 +677,23 @@ fold_negate_expr (location_t loc, tree t
case TRUNC_DIV_EXPR:
case ROUND_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
- and actually traps on some architectures. But if overflow is
- undefined, we can negate, because - (INT_MIN / 1) is an
- overflow. */
- if (!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
- {
- const char * const warnmsg = G_("assuming signed overflow does not "
- "occur when negating a division");
- tem = TREE_OPERAND (t, 1);
- if (negate_expr_p (tem))
- {
- 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));
- }
+ 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))))
+ && negate_expr_p (TREE_OPERAND (t, 1)))
+ return fold_build2_loc (loc, TREE_CODE (t), type,
+ TREE_OPERAND (t, 0),
+ negate_expr (TREE_OPERAND (t, 1)));
break;
case NOP_EXPR:
