* fold-const.c (fold): Reorder tests for conditional expressions.

[pf3gnuchains/gcc-fork.git] / gcc / fold-const.c

diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index ebb87e2..065a4fc 100644 (file)
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -5063,6 +5063,14 @@ fold (expr)
                            fold (build1 (code, type, integer_one_node)),
                            fold (build1 (code, type, integer_zero_node))));
    }
+  else if (TREE_CODE_CLASS (code) == '<'
+          && TREE_CODE (arg0) == COMPOUND_EXPR)
+    return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
+                 fold (build (code, type, TREE_OPERAND (arg0, 1), arg1)));
+  else if (TREE_CODE_CLASS (code) == '<'
+          && TREE_CODE (arg1) == COMPOUND_EXPR)
+    return build (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
+                 fold (build (code, type, arg0, TREE_OPERAND (arg1, 1))));
   else if (TREE_CODE_CLASS (code) == '2'
           || TREE_CODE_CLASS (code) == '<')
     {
@@ -5098,14 +5106,6 @@ fold (expr)
          fold_binary_op_with_conditional_arg (code, type, arg0, arg1,
                                               /*cond_first_p=*/1);
     }
-  else if (TREE_CODE_CLASS (code) == '<'
-          && TREE_CODE (arg0) == COMPOUND_EXPR)
-    return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
-                 fold (build (code, type, TREE_OPERAND (arg0, 1), arg1)));
-  else if (TREE_CODE_CLASS (code) == '<'
-          && TREE_CODE (arg1) == COMPOUND_EXPR)
-    return build (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
-                 fold (build (code, type, arg0, TREE_OPERAND (arg1, 1))));
 
   switch (code)
     {
@@ -6484,6 +6484,19 @@ fold (expr)
              && ! TREE_CONSTANT_OVERFLOW (tem))
            return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
 
+         /* Likewise, we can simplify a comparison of a real constant with
+            a MINUS_EXPR whose first operand is also a real constant, i.e.
+            (c1 - x) < c2 becomes x > c1-c2.  */
+         if (flag_unsafe_math_optimizations
+             && TREE_CODE (arg1) == REAL_CST
+             && TREE_CODE (arg0) == MINUS_EXPR
+             && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST
+             && 0 != (tem = const_binop (MINUS_EXPR, TREE_OPERAND (arg0, 0),
+                                         arg1, 0))
+             && ! TREE_CONSTANT_OVERFLOW (tem))
+           return fold (build (swap_tree_comparison (code), type,
+                               TREE_OPERAND (arg0, 1), tem));
+
          /* Fold comparisons against built-in math functions.  */
          if (TREE_CODE (arg1) == REAL_CST
              && flag_unsafe_math_optimizations