mirror/gcc
2
0
Fork 0
mirror of git://gcc.gnu.org/git/gcc.git synced 2025-03-23 09:40:54 +08:00
Code Issues Packages Projects Releases Wiki Activity

re PR tree-optimization/14490 ([tree-ssa] Simplify "a - 10 > 150" into "a > 160")

Browse Source 
2005-07-02  Andrew Pinski  <pinskia@physics.uc.edu>

        PR middle-end/14490
        * fold-const.c (fold_binary): Handle the return value of
        fold_to_nonsharp_ineq_using_bound if we get back the same operand back.
        Implement "X +- C1 CMP C2" folding to "X CMP C2 -+ C1".

From-SVN: r101535
This commit is contained in:
Andrew Pinski 2005-07-02 16:24:31 +00:00 committed by Andrew Pinski
parent 2d0dab7f2b
commit 70a9e64b3c
7 changed files with 98 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
gcc/ChangeLog
View File

@ -1,3 +1,10 @@
2005-07-02 Andrew Pinski <pinskia@physics.uc.edu>
PR middle-end/14490
* fold-const.c (fold_binary): Handle the return value of
fold_to_nonsharp_ineq_using_bound if we get back the same operand back.
Implement "X +- C1 CMP C2" folding to "X CMP C2 -+ C1".
2005-07-02 Jeff Law <law@redhat.com>
* tree-ssa-dom.c (find_equivalent_equality_comparison): Do not

28
gcc/fold-const.c
View File

@ -8575,11 +8575,11 @@ fold_binary (enum tree_code code, tree type, tree op0, tree op1)
&& !TREE_SIDE_EFFECTS (arg1))
{
tem = fold_to_nonsharp_ineq_using_bound (arg0, arg1);
if (tem)
if (tem && !operand_equal_p (tem, arg0, 0))
return fold_build2 (code, type, tem, arg1);
tem = fold_to_nonsharp_ineq_using_bound (arg1, arg0);
if (tem)
if (tem && !operand_equal_p (tem, arg1, 0))
return fold_build2 (code, type, arg0, tem);
}
@ -8865,6 +8865,30 @@ fold_binary (enum tree_code code, tree type, tree op0, tree op1)
}
}
/* Transform comparisons of the form X +- C1 CMP C2 to X CMP C2 +- C1. */
if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
&& (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
&& !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
&& !TYPE_UNSIGNED (TREE_TYPE (arg1))
&& !(flag_wrapv || flag_trapv))
&& (TREE_CODE (arg1) == INTEGER_CST
&& !TREE_OVERFLOW (arg1)))
{
tree const1 = TREE_OPERAND (arg0, 1);
tree const2 = arg1;
tree variable = TREE_OPERAND (arg0, 0);
tree lhs;
int lhs_add;
lhs_add = TREE_CODE (arg0) != PLUS_EXPR;
lhs = fold_build2 (lhs_add ? PLUS_EXPR : MINUS_EXPR,
TREE_TYPE (arg1), const2, const1);
if (TREE_CODE (lhs) == TREE_CODE (arg1)
&& (TREE_CODE (lhs) != INTEGER_CST
|| !TREE_OVERFLOW (lhs)))
return fold_build2 (code, type, variable, lhs);
}
if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
{
tree targ0 = strip_float_extensions (arg0);

24
gcc/testsuite/gcc.dg/20050702-1.c Normal file
View File

@ -0,0 +1,24 @@
/* { dg-do compile } */
/* { dg-options "-O2" } */
/* We going into an infinite loop in fold because we
were mishandling the return value of
fold_to_nonsharp_ineq_using_bound. */
_Bool f();
void g(int);
void h (int old_size)
{
int new_size = old_size, i;
g(old_size - 1);
i = 0;
while (i < old_size - 1)
{
if (f())
{
i++;
continue;
}
while (i < old_size - 1)
i++;
}
g(new_size);
}

11
gcc/testsuite/gcc.dg/tree-ssa/pr14490-1.c Normal file
View File

@ -0,0 +1,11 @@
/* { dg-do compile } */
/* { dg-options "-fdump-tree-gimple" } */
int g(int x)
{
return (x - 10) < 0;
}
/* There should be only x >= 9 and no x - 10. */
/* { dg-final { scan-tree-dump-times ">= 9" 1 "gimple"} } */
/* { dg-final { scan-tree-dump-times "- 10" 0 "gimple"} } */
/* { dg-final { cleanup-tree-dump "gimple" } } */

10
gcc/testsuite/gcc.dg/tree-ssa/pr14490-2.c Normal file
View File

@ -0,0 +1,10 @@
/* { dg-do compile } */
/* { dg-options "-fdump-tree-gimple -fwrapv" } */
int g(int x)
{
return (x - 10) < 0;
}
/* There should be no x >= 9 and one x - 10. */
/* { dg-final { scan-tree-dump-times ">= 9" 0 "gimple"} } */
/* { dg-final { scan-tree-dump-times "- 10" 1 "gimple"} } */
/* { dg-final { cleanup-tree-dump "gimple" } } */

10
gcc/testsuite/gcc.dg/tree-ssa/pr14490-3.c Normal file
View File

@ -0,0 +1,10 @@
/* { dg-do compile } */
/* { dg-options "-fdump-tree-gimple" } */
int g(int x)
{
return (x + 10) < 0;
}
/* There should be only x >= -9 and no x + 10. */
/* { dg-final { scan-tree-dump-times ">= 9" 1 "gimple"} } */
/* { dg-final { scan-tree-dump-times "- 10" 0 "gimple"} } */
/* { dg-final { cleanup-tree-dump "gimple" } } */

10
gcc/testsuite/gcc.dg/tree-ssa/pr14490-4.c Normal file
View File

@ -0,0 +1,10 @@
/* { dg-do compile } */
/* { dg-options "-fdump-tree-gimple -fwrapv" } */
int g(int x)
{
return (x + 10) < 0;
}
/* There should be no x >= -9 and one x + 10. */
/* { dg-final { scan-tree-dump-times ">= 9" 0 "gimple"} } */
/* { dg-final { scan-tree-dump-times "- 10" 1 "gimple"} } */
/* { dg-final { cleanup-tree-dump "gimple" } } */