This makes us honor -frounding-math for integer to float conversions
and avoid constant folding when such conversion is not exact.
Bootstrapped and tested on x86_64-unknown-linux-gnu, OK?
Thanks,
Richard.
2021-10-28 Richard Biener <rguent...@suse.de>
PR middle-end/84407
* fold-const.c (fold_convert_const): Avoid int to float
constant folding with -frounding-math and inexact result.
* simplify-rtx.c (simplify_const_unary_operation): Likewise.
* gcc.dg/torture/fp-uint64-convert-double-1.c: New testcase.
---
gcc/fold-const.c | 15 +++-
gcc/simplify-rtx.c | 13 ++++
.../torture/fp-uint64-convert-double-1.c | 74 +++++++++++++++++++
3 files changed, 101 insertions(+), 1 deletion(-)
create mode 100644 gcc/testsuite/gcc.dg/torture/fp-uint64-convert-double-1.c
diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index 18950aeb760..c7daf871125 100644
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -2290,7 +2290,20 @@ fold_convert_const (enum tree_code code, tree type, tree
arg1)
else if (TREE_CODE (type) == REAL_TYPE)
{
if (TREE_CODE (arg1) == INTEGER_CST)
- return build_real_from_int_cst (type, arg1);
+ {
+ tree res = build_real_from_int_cst (type, arg1);
+ /* Avoid the folding if flag_rounding_math is on and the
+ conversion is not exact. */
+ if (HONOR_SIGN_DEPENDENT_ROUNDING (type))
+ {
+ bool fail = false;
+ wide_int w = real_to_integer (&TREE_REAL_CST (res), &fail,
+ TYPE_PRECISION (TREE_TYPE (arg1)));
+ if (fail || wi::ne_p (w, wi::to_wide (arg1)))
+ return NULL_TREE;
+ }
+ return res;
+ }
else if (TREE_CODE (arg1) == REAL_CST)
return fold_convert_const_real_from_real (type, arg1);
else if (TREE_CODE (arg1) == FIXED_CST)
diff --git a/gcc/simplify-rtx.c b/gcc/simplify-rtx.c
index f38b6d7d31c..a16395befcd 100644
--- a/gcc/simplify-rtx.c
+++ b/gcc/simplify-rtx.c
@@ -1917,6 +1917,19 @@ simplify_const_unary_operation (enum rtx_code code,
machine_mode mode,
return 0;
d = real_value_truncate (mode, d);
+
+ /* Avoid the folding if flag_rounding_math is on and the
+ conversion is not exact. */
+ if (HONOR_SIGN_DEPENDENT_ROUNDING (mode))
+ {
+ bool fail = false;
+ wide_int w = real_to_integer (&d, &fail,
+ GET_MODE_PRECISION
+ (as_a <scalar_int_mode> (op_mode)));
+ if (fail || wi::ne_p (w, wide_int (rtx_mode_t (op, op_mode))))
+ return 0;
+ }
+
return const_double_from_real_value (d, mode);
}
else if (code == UNSIGNED_FLOAT && CONST_SCALAR_INT_P (op))
diff --git a/gcc/testsuite/gcc.dg/torture/fp-uint64-convert-double-1.c
b/gcc/testsuite/gcc.dg/torture/fp-uint64-convert-double-1.c
new file mode 100644
index 00000000000..b40a16a2257
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/fp-uint64-convert-double-1.c
@@ -0,0 +1,74 @@
+/* PR84407 */
+/* { dg-do run } */
+/* { dg-require-effective-target fenv } */
+/* { dg-additional-options "-frounding-math" } */
+
+#include <fenv.h>
+#include <stdlib.h>
+
+void __attribute__((noipa))
+fooa ()
+{
+#if __DBL_MANT_DIG__ == 53
+#ifdef FE_TONEAREST
+ fesetround(FE_TONEAREST);
+ __UINT64_TYPE__ x = 0x7fffffffffffffff;
+ double f = x;
+ if (f != 0x1p+63)
+ abort ();
+#endif
+#endif
+}
+
+void __attribute__((noipa))
+foob ()
+{
+#if __DBL_MANT_DIG__ == 53
+#ifdef FE_DOWNWARD
+ fesetround(FE_DOWNWARD);
+ __UINT64_TYPE__ x = 0x7fffffffffffffff;
+ double f = x;
+ if (f != 0x1.fffffffffffffp+62)
+ abort ();
+#endif
+#endif
+}
+
+void __attribute__((noipa))
+fooc ()
+{
+#if __DBL_MANT_DIG__ == 53
+#ifdef FE_UPWARD
+ fesetround(FE_UPWARD);
+ __UINT64_TYPE__ x = 0x7fffffffffffffff;
+ double f = x;
+ if (f != 0x1p+63)
+ abort ();
+#endif
+#endif
+}
+
+void __attribute__((noipa))
+food ()
+{
+#if __DBL_MANT_DIG__ == 53
+#ifdef FE_TOWARDZERO
+ fesetround(FE_TOWARDZERO);
+ __UINT64_TYPE__ x = 0x7fffffffffffffff;
+ double f = x;
+ if (f != 0x1.fffffffffffffp+62)
+ abort ();
+#endif
+#endif
+}
+
+
+int
+main ()
+{
+ fooa ();
+ foob ();
+ fooc ();
+ food ();
+ return 0;
+}
--
2.31.1
