re PR c/35712 (decimal float literal constant zero loses significant trailing zeroes)

2008-04-03  Janis Johnson  <janis187@us.ibm.com>

gcc/
	PR c/35712
	* dfp.c (decimal_from_decnumber): Retain trailing zeroes for
	  decimal-float literal constant zero.

testsuite/
	PR c/35712
	* gcc.dg/dfp/constants-zero.c: New test.

From-SVN: r133881

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index a9aad3268d55550883171f293653817294e606f5..6965a49c8f437d9916c1587e6aed8eae26727409 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,9 @@
+2008-04-03  Janis Johnson  <janis187@us.ibm.com>
+
+       PR c/35712
+       * dfp.c (decimal_from_decnumber): Retain trailing zeroes for
+         decimal-float literal constant zero.
+
 2008-04-03  Jakub Jelinek  <jakub@redhat.com>
 
        PR c/35738

diff --git a/gcc/dfp.c b/gcc/dfp.c
index 88ffdedbcfb41baf5272a9a3616801e495ff070f..2526ef60c0fd2fbdb6ff9730c7566493849f561e 100644 (file)
--- a/gcc/dfp.c
+++ b/gcc/dfp.c
@@ -46,8 +46,6 @@ decimal_from_decnumber (REAL_VALUE_TYPE *r, decNumber *dn, decContext *context)
   memset (r, 0, sizeof (REAL_VALUE_TYPE));
 
   r->cl = rvc_normal;
-  if (decNumberIsZero (dn))
-    r->cl = rvc_zero;
   if (decNumberIsNaN (dn))
     r->cl = rvc_nan;
   if (decNumberIsInfinite (dn))

diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index c89aa300f220d508b909816f822f1266deb1ab32..f3b7b6fa26521e1c73d3e9154ed27c8f4551cc93 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,8 @@
+2008-04-03  Janis Johnson  <janis187@us.ibm.com>
+
+       PR c/35712
+       * gcc.dg/dfp/constants-zero.c: New test.
+
 2008-04-03  Jakub Jelinek  <jakub@redhat.com>
 
        PR c/35738

diff --git a/gcc/testsuite/gcc.dg/dfp/constants-zero.c b/gcc/testsuite/gcc.dg/dfp/constants-zero.c
new file mode 100644 (file)
index 0000000..e0db28c
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/dfp/constants-zero.c
@@ -0,0 +1,159 @@
+/* { dg-options "-std=gnu99 -O0" } */
+
+/* Decimal float values can have significant trailing zeroes.  This is
+   true for zero values as well.  Check that various representations of
+   zero are handled correctly when specified as literal constants.  */
+
+extern void abort (void);
+
+int big_endian;
+
+typedef union U32 {
+  unsigned int i;
+  _Decimal32 d;
+  unsigned char b[4];
+} u32_t;
+
+typedef union U64 {
+  unsigned long long i;
+  _Decimal64 d;
+} u64_t;
+
+typedef union U128 {
+  unsigned long long i[2];
+  _Decimal128 d;
+} u128_t;
+
+int
+compare32 (_Decimal32 d, unsigned int i)
+{
+  u32_t u;
+
+  u.d = d;
+  return (u.i == i);
+}
+
+int
+compare64 (_Decimal64 d, unsigned long long i)
+{
+  u64_t u;
+
+  u.d = d;
+  return (u.i == i);
+}
+
+int
+compare128 (_Decimal64 d, unsigned long long i, unsigned long long j)
+{
+  u128_t u;
+
+  u.d = d;
+  if (big_endian)
+    return (u.i[0] == i && u.i[1] == j);
+  else
+    return (u.i[1] == i && u.i[0] == j);
+}
+
+void
+dpd_tests (void)
+{
+  if (! compare32 (0.DF, 0x22500000U))
+    abort ();
+  if (! compare32 (-0.DF, 0xa2500000U))
+    abort ();
+  if (! compare32 (0.E-4DF, 0x22100000U))
+    abort ();
+  if (! compare32 (0.E-7DF, 0x21e00000U))
+    abort ();
+  if (! compare32 (0.E+3DF, 0x22800000U))
+    abort ();
+
+  if (! compare64 (0.DD, 0x2238000000000000ULL))
+    abort ();
+  if (! compare64 (-0.DD, 0xa238000000000000ULL))
+    abort ();
+  if (! compare64 (0.E-6DD, 0x2220000000000000ULL))
+    abort ();
+  if (! compare64 (0.E-7DD, 0x221c000000000000ULL))
+    abort ();
+  if (! compare64 (0.E+2DD, 0x2240000000000000ULL))
+    abort ();
+
+  if (! compare128 (0.DL, 0x2208000000000000ULL, 0x0000000000000000ULL))
+    abort ();
+  if (! compare128 (-0.DL, 0xa208000000000000ULL, 0x0000000000000000ULL))
+    abort ();
+  if (! compare128 (0.E-3DL, 0x2207400000000000ULL, 0x0000000000000000ULL))
+    abort ();
+  if (! compare128 (0.E-8DL, 0x2206000000000000ULL, 0x0000000000000000ULL))
+    abort ();
+  if (! compare128 (0.E+2DL, 0x2208800000000000ULL, 0x0000000000000000ULL))
+    abort ();
+}
+
+void
+bid_tests (void)
+{
+  if (! compare32 (0.DF, 0x32800000U))
+    abort ();
+  if (! compare32 (-0.DF, 0xb2800000U))
+    abort ();
+  if (! compare32 (0.E-4DF, 0x30800000U))
+    abort ();
+  if (! compare32 (0.E-7DF, 0x2f000000U))
+    abort ();
+  if (! compare32 (0.E+3DF, 0x34000000U))
+    abort ();
+
+  if (! compare64 (0.DD, 0x31c0000000000000ULL))
+    abort ();
+  if (! compare64 (-0.DD, 0xb1c0000000000000ULL))
+    abort ();
+  if (! compare64 (0.E-6DD, 0x3100000000000000ULL))
+    abort ();
+  if (! compare64 (0.E-7DD, 0x30e0000000000000ULL))
+    abort ();
+  if (! compare64 (0.E+2DD, 0x3200000000000000ULL))
+    abort ();
+
+  if (! compare128 (0.DL, 0x3040000000000000ULL, 0x0000000000000000ULL))
+    abort ();
+  if (! compare128 (-0.DL, 0xb040000000000000ULL, 0x0000000000000000ULL))
+    abort ();
+  if (! compare128 (0.E-3DL, 0x303a000000000000ULL, 0x0000000000000000ULL))
+    abort ();
+  if (! compare128 (0.E-8DL, 0x3030000000000000ULL, 0x0000000000000000ULL))
+    abort ();
+  if (! compare128 (0.E+2DL, 0x3044000000000000ULL, 0x0000000000000000ULL))
+    abort ();
+}
+
+int
+main ()
+{
+  u32_t u32;
+  
+  /* These sizes are probably always true for targets that support decimal
+     float types, but check anyway.  Abort so we can fix the test.  */
+  if ((sizeof (_Decimal64) != sizeof (long long))
+      || (sizeof (_Decimal128) != 2 * sizeof (long long))
+      || (sizeof (_Decimal32) != sizeof (_Decimal32)))
+    abort ();
+
+  u32.d = 1.DF;
+
+  if (u32.i == 0x22500001)
+    {
+      big_endian = (u32.b[0] == 0x22);
+      dpd_tests ();
+    }
+  else if (u32.i == 0x32800001)
+    {
+       big_endian = (u32.b[0] == 0x32);
+       bid_tests ();
+    }
+  else
+    abort ();          /* unknown format; test problem  */
+
+  return 0;
+}