Hi all,
This is a second iteration of patch which gets rid of float casts in
comparisons when all values of casted integral type are exactly
representable by the float type
(https://gcc.gnu.org/bugzilla/show_bug.cgi?id=81376). The new version
addresses issue spotted by Richard in previous version
https://gcc.gnu.org/ml/gcc-patches/2018-02/msg01119.html
Bootstrapped and regtested on x64_64.
-Y
From 396be5ffa5e6bf919d78fa91885186876bce5461 Mon Sep 17 00:00:00 2001
From: Yury Gribov <tetra2005@gmail.com>
Date: Fri, 29 Sep 2017 07:34:54 +0200
Subject: [PATCH] Add pattern to remove useless float casts in comparison.
2018-09-18 Yury Gribov <tetra2005@gmail.com>
PR middle-end/81376
gcc/
* real.c (format_helper::can_represent_integral_type_p): New function
* real.h (format_helper::can_represent_integral_type_p): Ditto.
* match.pd: New pattern.
gcc/testsuite/
* c-c++-common/pr81376.c: New test.
* gcc.target/i386/387-ficom-2.c: Update test.
* gcc.target/i386/387-ficom-2.c: Ditto.
---
gcc/match.pd | 35 ++++++++++++++++-----
gcc/real.c | 13 ++++++++
gcc/real.h | 1 +
gcc/testsuite/c-c++-common/pr81376.c | 48 +++++++++++++++++++++++++++++
gcc/testsuite/gcc.target/i386/387-ficom-1.c | 5 +--
gcc/testsuite/gcc.target/i386/387-ficom-2.c | 5 +--
6 files changed, 96 insertions(+), 11 deletions(-)
create mode 100644 gcc/testsuite/c-c++-common/pr81376.c
diff --git a/gcc/match.pd b/gcc/match.pd
index be669ca..080b0d3 100644
--- a/gcc/match.pd
+++ b/gcc/match.pd
@@ -3348,6 +3348,32 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
(if (! HONOR_NANS (@0))
(cmp @0 @1))))))
+/* Optimize various special cases of (FTYPE) N CMP (FTYPE) M. */
+(for cmp (tcc_comparison)
+ (simplify
+ (cmp (float@0 @1) (float @2))
+ (if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (@0))
+ && ! DECIMAL_FLOAT_TYPE_P (TREE_TYPE (@0)))
+ (with
+ {
+ format_helper fmt (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (@0))));
+ tree type1 = TREE_TYPE (@1);
+ bool type1_signed_p = TYPE_SIGN (type1) == SIGNED;
+ tree type2 = TREE_TYPE (@2);
+ bool type2_signed_p = TYPE_SIGN (type2) == SIGNED;
+ }
+ (if (fmt.can_represent_integral_type_p (type1)
+ && fmt.can_represent_integral_type_p (type2))
+ (if (TYPE_PRECISION (type1) > TYPE_PRECISION (type2)
+ && type1_signed_p >= type2_signed_p)
+ (cmp @1 (convert @2))
+ (if (TYPE_PRECISION (type1) < TYPE_PRECISION (type2)
+ && type1_signed_p <= type2_signed_p)
+ (cmp (convert:type2 @1) @2)
+ (if (TYPE_PRECISION (type1) == TYPE_PRECISION (type2)
+ && type1_signed_p == type2_signed_p)
+ (cmp @1 @2)))))))))
+
/* Optimize various special cases of (FTYPE) N CMP CST. */
(for cmp (lt le eq ne ge gt)
icmp (le le eq ne ge ge)
@@ -3358,7 +3384,6 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
(with
{
tree itype = TREE_TYPE (@0);
- signop isign = TYPE_SIGN (itype);
format_helper fmt (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (@1))));
const REAL_VALUE_TYPE *cst = TREE_REAL_CST_PTR (@1);
/* Be careful to preserve any potential exceptions due to
@@ -3368,17 +3393,13 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
bool exception_p
= real_isnan (cst) && (cst->signalling
|| (cmp != EQ_EXPR && cmp != NE_EXPR));
- /* INT?_MIN is power-of-two so it takes
- only one mantissa bit. */
- bool signed_p = isign == SIGNED;
- bool itype_fits_ftype_p
- = TYPE_PRECISION (itype) - signed_p <= significand_size (fmt);
}
/* TODO: allow non-fitting itype and SNaNs when
-fno-trapping-math. */
- (if (itype_fits_ftype_p && ! exception_p)
+ (if (fmt.can_represent_integral_type_p (itype) && ! exception_p)
(with
{
+ signop isign = TYPE_SIGN (itype);
REAL_VALUE_TYPE imin, imax;
real_from_integer (&imin, fmt, wi::min_value (itype), isign);
real_from_integer (&imax, fmt, wi::max_value (itype), isign);
diff --git a/gcc/real.c b/gcc/real.c
index f822ae8..0cf4089 100644
--- a/gcc/real.c
+++ b/gcc/real.c
@@ -5176,6 +5176,19 @@ get_max_float (const struct real_format *fmt, char *buf, size_t len)
gcc_assert (strlen (buf) < len);
}
+/* True if all values of integral type can be represented
+ by this floating-point type exactly. */
+
+bool format_helper::can_represent_integral_type_p (tree type) const
+{
+ gcc_assert (! decimal_p () && INTEGRAL_TYPE_P (type));
+
+ /* INT?_MIN is power-of-two so it takes
+ only one mantissa bit. */
+ bool signed_p = TYPE_SIGN (type) == SIGNED;
+ return TYPE_PRECISION (type) - signed_p <= significand_size (*this);
+}
+
/* True if mode M has a NaN representation and
the treatment of NaN operands is important. */
diff --git a/gcc/real.h b/gcc/real.h
index 0ce4256..93db217 100644
--- a/gcc/real.h
+++ b/gcc/real.h
@@ -216,6 +216,7 @@ public:
operator const real_format *() const { return m_format; }
bool decimal_p () const { return m_format && m_format->b == 10; }
+ bool can_represent_integral_type_p (tree type) const;
private:
const real_format *m_format;
diff --git a/gcc/testsuite/c-c++-common/pr81376.c b/gcc/testsuite/c-c++-common/pr81376.c
new file mode 100644
index 0000000..e67f41e
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/pr81376.c
@@ -0,0 +1,48 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-original" } */
+
+typedef double c_t;
+typedef int a_t;
+int f(a_t a1, a_t a2) {
+ return (c_t) a1 < (c_t) a2;
+ /* { dg-final { scan-tree-dump "return (<retval> = )?a1 < a2" "original" } } */
+}
+
+void f1(short a, short b)
+{
+ volatile int s_s;
+ s_s = (float) a < (float) b;
+ /* { dg-final { scan-tree-dump "s_s = a < b" "original" } } */
+}
+
+void f2(unsigned short a, unsigned short b)
+{
+ volatile int us_us;
+ us_us = (float) a < (float) b;
+ /* { dg-final { scan-tree-dump "us_us = a < b" "original" } } */
+}
+
+/* We don't optimize here because neither of integral types is
+ subset of the other. */
+void f3(unsigned short a, short b)
+{
+ volatile int us_s;
+ us_s = (float) a < (float) b;
+ /* { dg-final { scan-tree-dump "us_s = \\(float\\) a < \\(float\\) b" "original" } } */
+}
+
+void f4(unsigned short a, int b)
+{
+ volatile int us_i;
+ us_i = (double) a < (double) b;
+ /* { dg-final { scan-tree-dump "us_i = \\(int\\) a < b" "original" } } */
+}
+
+/* We don't optimize here because neither of integral types is
+ subset of the other. */
+void f5(short a, unsigned int b)
+{
+ volatile int s_ui;
+ s_ui = (double) a < (double) b;
+ /* { dg-final { scan-tree-dump "s_ui = \\(double\\) a < \\(double\\) b" "original" } } */
+}
diff --git a/gcc/testsuite/gcc.target/i386/387-ficom-1.c b/gcc/testsuite/gcc.target/i386/387-ficom-1.c
index 3256988..8cef82d 100644
--- a/gcc/testsuite/gcc.target/i386/387-ficom-1.c
+++ b/gcc/testsuite/gcc.target/i386/387-ficom-1.c
@@ -37,5 +37,6 @@ int test_ld_i (int x)
return (long double)i != x;
}
-/* { dg-final { scan-assembler-times "ficomp\[s\t\]" 3 } } */
-/* { dg-final { scan-assembler-times "ficompl" 3 } } */
+/* { dg-final { scan-assembler-times "cmpw\[s\t\]" 3 } } */
+/* { dg-final { scan-assembler-times "ficompl" 1 } } */
+/* { dg-final { scan-assembler-times "cmpl" 2 } } */
diff --git a/gcc/testsuite/gcc.target/i386/387-ficom-2.c b/gcc/testsuite/gcc.target/i386/387-ficom-2.c
index d528368..46c4b55 100644
--- a/gcc/testsuite/gcc.target/i386/387-ficom-2.c
+++ b/gcc/testsuite/gcc.target/i386/387-ficom-2.c
@@ -5,5 +5,6 @@
#include "387-ficom-1.c"
-/* { dg-final { scan-assembler-times "ficomp\[s\t\]" 3 } } */
-/* { dg-final { scan-assembler-times "ficompl" 3 } } */
+/* { dg-final { scan-assembler-times "cmpw\[s\t\]" 3 } } */
+/* { dg-final { scan-assembler-times "ficompl" 1 } } */
+/* { dg-final { scan-assembler-times "cmpl" 2 } } */
--
2.9.4
