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

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

7 files changed, 98 insertions, 2 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 6e5396a..4b3d554 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -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
diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index 564cec3..682ae00 100644
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -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);
diff --git a/gcc/testsuite/gcc.dg/20050702-1.c b/gcc/testsuite/gcc.dg/20050702-1.c
new file mode 100644
index 0000000..ce151d3
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/20050702-1.c
@@ -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);
+}
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr14490-1.c b/gcc/testsuite/gcc.dg/tree-ssa/pr14490-1.c
new file mode 100644
index 0000000..733367b
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/pr14490-1.c
@@ -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" } } */
+
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr14490-2.c b/gcc/testsuite/gcc.dg/tree-ssa/pr14490-2.c
new file mode 100644
index 0000000..eaa0f13
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/pr14490-2.c
@@ -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" } } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr14490-3.c b/gcc/testsuite/gcc.dg/tree-ssa/pr14490-3.c
new file mode 100644
index 0000000..0e6873b
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/pr14490-3.c
@@ -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" } } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr14490-4.c b/gcc/testsuite/gcc.dg/tree-ssa/pr14490-4.c
new file mode 100644
index 0000000..365ab77
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/pr14490-4.c
@@ -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" } } */