Hi!
Unfortunately, the following further testcase shows that there aren't
problems only with very large precisions and large exponents, but pretty
much anything larger than 64-bits. After all, before _BitInt support dfp
didn't even have {,unsigned }__int128 <-> _Decimal{32,64,128,64x} support,
and the testcase again shows some of the conversions yielding zeros.
While the pr120631.c test worked even without the earlier patch.
So, this patch assumes 64-bit precision at most is ok and for anything
larger it just uses exponent 0 and multiplies afterwards.
Bootstrapped/regtested on x86_64-linux and i686-linux, ok for
trunk/15.2/14.4?
2025-06-18 Jakub Jelinek <ja...@redhat.com>
PR middle-end/120631
* dfp.cc (decimal_real_to_integer): Use result multiplication not just
when precision > 128 and dn.exponent > 19, but when precision > 64
and dn.exponent > 0.
* gcc.dg/dfp/bitint-10.c: New test.
* gcc.dg/dfp/pr120631.c: New test.
--- gcc/dfp.cc.jj 2025-06-18 08:07:15.397023476 +0200
+++ gcc/dfp.cc 2025-06-18 09:11:09.555934992 +0200
@@ -625,14 +625,14 @@ decimal_real_to_integer (const REAL_VALU
set.traps = 0;
set.round = DEC_ROUND_DOWN;
decimal128ToNumber ((const decimal128 *) r->sig, &dn);
- if (precision > 128 && decNumberIsFinite (&dn) && dn.exponent > 19)
+ if (precision > 64 && decNumberIsFinite (&dn) && dn.exponent > 0)
{
/* libdecNumber doesn't really handle too large integers.
So when precision is large and exponent as well, trim the
exponent and adjust the resulting wide_int by multiplying
- it multiple times with 10^19. */
- scale = dn.exponent / 19;
- dn.exponent %= 19;
+ it multiple times with powers of ten. */
+ scale = dn.exponent;
+ dn.exponent = 0;
}
decNumberToIntegralValue (&dn2, &dn, &set);
@@ -649,13 +649,42 @@ decimal_real_to_integer (const REAL_VALU
*fail = true;
if (scale && !failp)
{
- wide_int wm = wi::uhwi (HOST_WIDE_INT_UC (10000000000000000000),
- w.get_precision ());
bool isneg = wi::neg_p (w);
if (isneg)
w = -w;
enum wi::overflow_type ovf = wi::OVF_NONE;
- do
+ unsigned HOST_WIDE_INT pow10s[] = {
+ HOST_WIDE_INT_UC (10),
+ HOST_WIDE_INT_UC (100),
+ HOST_WIDE_INT_UC (1000),
+ HOST_WIDE_INT_UC (10000),
+ HOST_WIDE_INT_UC (100000),
+ HOST_WIDE_INT_UC (1000000),
+ HOST_WIDE_INT_UC (10000000),
+ HOST_WIDE_INT_UC (100000000),
+ HOST_WIDE_INT_UC (1000000000),
+ HOST_WIDE_INT_UC (10000000000),
+ HOST_WIDE_INT_UC (100000000000),
+ HOST_WIDE_INT_UC (1000000000000),
+ HOST_WIDE_INT_UC (10000000000000),
+ HOST_WIDE_INT_UC (100000000000000),
+ HOST_WIDE_INT_UC (1000000000000000),
+ HOST_WIDE_INT_UC (10000000000000000),
+ HOST_WIDE_INT_UC (100000000000000000),
+ HOST_WIDE_INT_UC (1000000000000000000),
+ HOST_WIDE_INT_UC (10000000000000000000),
+ };
+ int s = scale % 19;
+ if (s)
+ {
+ wide_int wm = wi::uhwi (pow10s[s - 1], w.get_precision ());
+ w = wi::umul (w, wm, &ovf);
+ if (ovf)
+ scale = 0;
+ }
+ scale /= 19;
+ wide_int wm = wi::uhwi (pow10s[18], w.get_precision ());
+ while (scale)
{
if (scale & 1)
{
@@ -667,8 +696,9 @@ decimal_real_to_integer (const REAL_VALU
if (!scale)
break;
wm = wi::umul (wm, wm, &ovf);
+ if (ovf)
+ break;
}
- while (!ovf);
if (ovf)
{
*fail = true;
--- gcc/testsuite/gcc.dg/dfp/bitint-10.c.jj 2025-06-18 08:21:39.610714324
+0200
+++ gcc/testsuite/gcc.dg/dfp/bitint-10.c 2025-06-18 08:38:02.954411784
+0200
@@ -0,0 +1,49 @@
+/* PR middle-end/120631 */
+/* { dg-do run { target bitint } } */
+/* { dg-options "-O2" } */
+
+#if __BITINT_MAXWIDTH__ >= 128
+_Decimal128 a = 123456789135792468012345678900000000000.0dl;
+_BitInt(128) b = 123456789135792468012345678900000000000wb;
+_Decimal64 c = 12345678913579000000000000000000000000.0dd;
+_BitInt(127) d = 12345678913579000000000000000000000000wb;
+#endif
+#if __BITINT_MAXWIDTH__ >= 256
+_Decimal128 m =
1234567891357924680123456789000000000000000000000000000000000000000000000000.0dl;
+_BitInt(256) n =
1234567891357924680123456789000000000000000000000000000000000000000000000000wb;
+_Decimal64 o =
1234567891357900000000000000000000000000000000000000000000000000000000000000.0dd;
+_BitInt(255) p =
1234567891357900000000000000000000000000000000000000000000000000000000000000wb;
+#endif
+
+int
+main ()
+{
+#if __BITINT_MAXWIDTH__ >= 128
+ if (a != b || (_BitInt(128)) a != b || c != d || (_BitInt(127)) c != d)
+ __builtin_abort ();
+ _Decimal128 e = 123456789135792468012345678900000000000.0dl;
+ _BitInt(128) f = 123456789135792468012345678900000000000wb;
+ _Decimal128 g = 123456789135792468012345678900000000000wb;
+ _BitInt(128) h = 123456789135792468012345678900000000000.0dl;
+ _Decimal64 i = 12345678913579000000000000000000000000.0dd;
+ _BitInt(128) j = 12345678913579000000000000000000000000wb;
+ _Decimal64 k = 12345678913579000000000000000000000000wb;
+ _BitInt(128) l = 12345678913579000000000000000000000000.0dd;
+ if (e != g || f != h || i != k || j != l)
+ __builtin_abort ();
+#endif
+#if __BITINT_MAXWIDTH__ >= 256
+ if (m != n || (_BitInt(256)) m != n || o != p || (_BitInt(255)) o != p)
+ __builtin_abort ();
+ _Decimal128 q =
1234567891357924680123456789000000000000000000000000000000000000000000000000.0dl;
+ _BitInt(256) r =
1234567891357924680123456789000000000000000000000000000000000000000000000000wb;
+ _Decimal128 s =
1234567891357924680123456789000000000000000000000000000000000000000000000000wb;
+ _BitInt(256) t =
1234567891357924680123456789000000000000000000000000000000000000000000000000.0dl;
+ _Decimal64 u =
1234567891357900000000000000000000000000000000000000000000000000000000000000.0dd;
+ _BitInt(255) v =
1234567891357900000000000000000000000000000000000000000000000000000000000000wb;
+ _Decimal64 w =
1234567891357900000000000000000000000000000000000000000000000000000000000000wb;
+ _BitInt(255) x =
1234567891357900000000000000000000000000000000000000000000000000000000000000.0dd;
+ if (q != s || r != t || u != w || v != x)
+ __builtin_abort ();
+#endif
+}
--- gcc/testsuite/gcc.dg/dfp/pr120631.c.jj 2025-06-18 09:00:28.322767316
+0200
+++ gcc/testsuite/gcc.dg/dfp/pr120631.c 2025-06-18 09:06:22.655964098 +0200
@@ -0,0 +1,25 @@
+/* PR middle-end/120631 */
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+_Decimal64 a = 1234567891357900000.0dd;
+long long b = 1234567891357900000LL;
+_Decimal32 c = 1234567000000000000.0df;
+long long d = 1234567000000000000LL;
+
+int
+main ()
+{
+ if (a != b || (long long) a != b || c != d || (long long) c != d)
+ __builtin_abort ();
+ _Decimal64 e = 1234567891357900000.0dd;
+ long long f = 1234567891357900000LL;
+ _Decimal64 g = 1234567891357900000LL;
+ long long h = 1234567891357900000.0dd;
+ _Decimal32 i = 1234567000000000000.0df;
+ long long j = 1234567000000000000LL;
+ _Decimal32 k = 1234567000000000000LL;
+ long long l = 1234567000000000000.0df;
+ if (e != g || f != h || i != k || j != l)
+ __builtin_abort ();
+}
Jakub
