From 1ea62f7bf4394142e0c473a69de8a0e9b1718a69 Mon Sep 17 00:00:00 2001 From: Yury Gribov Date: Fri, 29 Sep 2017 07:34:54 +0200 Subject: [PATCH] Add pattern to remove useless float casts in comparison. 2018-02-17 Yury Gribov 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/match.pd | 30 ++++++++++++++++++++------- gcc/real.c | 13 ++++++++++++ gcc/real.h | 1 + gcc/testsuite/c-c++-common/pr81376.c | 39 ++++++++++++++++++++++++++++++++++++ 4 files changed, 76 insertions(+), 7 deletions(-) create mode 100644 gcc/testsuite/c-c++-common/pr81376.c diff --git a/gcc/match.pd b/gcc/match.pd index 4452b58..33a5f36 100644 --- a/gcc/match.pd +++ b/gcc/match.pd @@ -3252,6 +3252,27 @@ 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); + tree type2 = TREE_TYPE (@2); + } + (if (fmt.can_represent_integral_type_p (type1) + && fmt.can_represent_integral_type_p (type2)) + (if (TYPE_PRECISION (type1) > TYPE_PRECISION (type2)) + (cmp @1 (convert @2)) + (if (TYPE_PRECISION (type1) < TYPE_PRECISION (type2)) + (cmp (convert:type2 @1) @2) + (if (TYPE_SIGN (type1) == TYPE_SIGN (type2)) + (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) @@ -3262,7 +3283,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 @@ -3272,17 +3292,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 2a46737..bf048c2 100644 --- a/gcc/real.c +++ b/gcc/real.c @@ -5080,6 +5080,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 e51073b..5b43b5d 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..4daefd1 --- /dev/null +++ b/gcc/testsuite/c-c++-common/pr81376.c @@ -0,0 +1,39 @@ +/* { 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 ( = )?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" } } */ +} -- 2.9.4