Hi, Here is the updated version:
This patch implements some of the optimizations discussed in https://gcc.gnu.org/bugzilla/show_bug.cgi?id=71026. Simplify (C / x >= 0.0) into x >= 0.0 with -fno-signed-zeros and -ffinite-math-only. If C is negative the comparison is reversed. Only handle >= and <= for now since C / x can underflow if C is small. Simplify (x * C1) > C2 into x > (C2 / C1) with -funsafe-math-optimizations. If C1 is negative the comparison is reversed. OK for commit? ChangeLog 2018-01-10 Wilco Dijkstra <wdijk...@arm.com> Jackson Woodruff <jackson.woodr...@arm.com> gcc/ PR 71026/tree-optimization * match.pd: Simplify floating point comparisons. gcc/testsuite/ PR 71026/tree-optimization * gcc.dg/div-cmp-1.c: New test. * gcc.dg/div-cmp-2.c: New test. -- diff --git a/gcc/match.pd b/gcc/match.pd index 435125a317275527661fba011a9d26e507d293a6..8a6fee906de6a750201362119862f8326868f26b 100644 --- a/gcc/match.pd +++ b/gcc/match.pd @@ -376,6 +376,21 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) (rdiv @0 (negate @1)) (rdiv (negate @0) @1)) +/* Simplify (C / x op 0.0) to x op 0.0 for C != 0, C != Inf/Nan. + Only handle >= and <= since C / x may underflow to zero. */ +(for op (le ge) + res_op (lt ge) + neg_op (ge lt) + (simplify + (op (rdiv REAL_CST@0 @1) real_zerop@2) + (if (!HONOR_SIGNED_ZEROS (@1) && !HONOR_INFINITIES (@1)) + (switch + (if (real_less (&dconst0, TREE_REAL_CST_PTR (@0))) + (res_op @1 @2)) + /* For C < 0, use the inverted operator. */ + (if (real_less (TREE_REAL_CST_PTR (@0), &dconst0)) + (neg_op @1 @2)))))) + /* Optimize (X & (-A)) / A where A is a power of 2, to X >> log2(A) */ (for div (trunc_div ceil_div floor_div round_div exact_div) (simplify @@ -3842,6 +3857,22 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) (rdiv @2 @1)) (rdiv (op @0 @2) @1))) + (for cmp (lt le gt ge) + neg_cmp (gt ge lt le) + /* Simplify (x * C1) cmp C2 -> x cmp (C2 / C1), where C1 != 0. */ + (simplify + (cmp (mult @0 REAL_CST@1) REAL_CST@2) + (with + { tree tem = const_binop (RDIV_EXPR, type, @2, @1); } + (if (tem + && !(REAL_VALUE_ISINF (TREE_REAL_CST (tem)) + || (real_zerop (tem) && !real_zerop (@1)))) + (switch + (if (real_less (&dconst0, TREE_REAL_CST_PTR (@1))) + (cmp @0 { tem; })) + (if (real_less (TREE_REAL_CST_PTR (@1), &dconst0)) + (neg_cmp @0 { tem; }))))))) + /* Simplify sqrt(x) * sqrt(y) -> sqrt(x*y). */ (for root (SQRT CBRT) (simplify diff --git a/gcc/testsuite/gcc.dg/div-cmp-1.c b/gcc/testsuite/gcc.dg/div-cmp-1.c new file mode 100644 index 0000000000000000000000000000000000000000..cd1a5cd3d6fee5a10e9859ca99b344fa3fdb7f5f --- /dev/null +++ b/gcc/testsuite/gcc.dg/div-cmp-1.c @@ -0,0 +1,29 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -funsafe-math-optimizations -fdump-tree-optimized-raw" } */ + +int +cmp_mul_1 (float x) +{ + return x * 3 <= 100; +} + +int +cmp_mul_2 (float x) +{ + return x * -5 > 100; +} + +int +div_cmp_1 (float x, float y) +{ + return x / 3 <= y; +} + +int +div_cmp_2 (float x, float y) +{ + return x / 3 <= 1; +} + +/* { dg-final { scan-tree-dump-times "mult_expr" 1 "optimized" } } */ +/* { dg-final { scan-tree-dump-not "rdiv_expr" "optimized" } } */ diff --git a/gcc/testsuite/gcc.dg/div-cmp-2.c b/gcc/testsuite/gcc.dg/div-cmp-2.c new file mode 100644 index 0000000000000000000000000000000000000000..1aa0797c2ff7a3fa1d6b93bc150a7c280541aed5 --- /dev/null +++ b/gcc/testsuite/gcc.dg/div-cmp-2.c @@ -0,0 +1,29 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fno-signed-zeros -ffinite-math-only -fdump-tree-optimized-raw" } */ + +int +cmp_1 (float x) +{ + return 5 / x >= 0; +} + +int +cmp_2 (float x) +{ + return 1 / x <= 0; +} + +int +cmp_3 (float x) +{ + return -2 / x >= 0; +} + +int +cmp_4 (float x) +{ + return -5 / x <= 0; +}
