This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[patch] c/41049 fixes for int to dfp conversions
- From: Janis Johnson <janis187 at us dot ibm dot com>
- To: gcc-patches at gcc dot gnu dot org
- Date: Tue, 25 Aug 2009 09:40:18 -0700
- Subject: [patch] c/41049 fixes for int to dfp conversions
- Reply-to: janis187 at us dot ibm dot com
Trailing zeroes are significant in decimal floating-point values. Each
value can have many cohorts which compare equal but have a different
number of trailing zeroes. Furthermore, the preferred exponent of the
result of a conversion from an integer to a decimal float value is zero.
Compile-time conversion from an integral constant to decimal float
strips all trailing zeroes and adds one back. A runtime conversion from
DI mode for the densely-packed decimal (DPD) format adds an extra
trailing zero. Furthermore, the DPD runtime conversion from SI mode
uses the rounding mode that is needed for conversion to integer types
but can give the wrong result for conversion from integer to decimal
float.
The processing in real.c to convert an integral constant to a decimal
float constant is quite convoluted and loses track of the fact that the
value is integral. Rather than adding new checks to code that is
already much-patched and presumably error-prone I added new routines
called from real_to_integer to handle this particular case.
Tested with full bootstrap of all languages but Ada and regression
testing with -m32/-m64 on powerpc64-unknown-linux-gnu, plus bootstrap
of C only on i686-pc-linux-gnu with both --enable-decimal-float=bid
and --enable-decimal-float=dpd, running only the tests for dfp.exp.
OK for trunk? OK for 4.4 and 4.3 branches, assuming testing passes
there?
2009-08-25 Janis Johnson <janis187@us.ibm.com>
gcc/
PR c/41049
* real.c decimal_from_integer, decimal_integer_string): New.
(real_from_integer): Use them as special case for decimal float.
* config/dfp-bit.c (_si_to_sd, _usi_to_sd): Use default rounding.
(_di_to_sd, _di_to_dd, _di_to_td, _udi_to_sd, _udi_to_dd, _udi_to_td):
Do not append zero after the decimal point in string to convert.
gcc/testsuite/
PR c/41049
* dfp/pr41049.c: New test.
Index: gcc/real.c
===================================================================
--- gcc/real.c (revision 151064)
+++ gcc/real.c (working copy)
@@ -110,6 +110,9 @@ static int do_compare (const REAL_VALUE_
static void do_fix_trunc (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
static unsigned long rtd_divmod (REAL_VALUE_TYPE *, REAL_VALUE_TYPE *);
+static void decimal_from_integer (REAL_VALUE_TYPE *);
+static void decimal_integer_string (char *, const REAL_VALUE_TYPE *,
+ size_t);
static const REAL_VALUE_TYPE * ten_to_ptwo (int);
static const REAL_VALUE_TYPE * ten_to_mptwo (int);
@@ -2168,10 +2171,74 @@ real_from_integer (REAL_VALUE_TYPE *r, e
normalize (r);
}
- if (mode != VOIDmode)
+ if (DECIMAL_FLOAT_MODE_P (mode))
+ decimal_from_integer (r);
+ else if (mode != VOIDmode)
real_convert (r, mode, r);
}
+/* Render R, an integral value, as a floating point constant with no
+ specified exponent. */
+
+static void
+decimal_integer_string (char *str, const REAL_VALUE_TYPE *r_orig,
+ size_t buf_size)
+{
+ int dec_exp, digit, digits, i;
+ const REAL_VALUE_TYPE *one, *ten;
+ REAL_VALUE_TYPE r, pten;
+ char *p;
+ bool sign;
+
+ r = *r_orig;
+
+ if (r.cl == rvc_zero)
+ {
+ strcpy (str, "0.");
+ return;
+ }
+
+ one = real_digit (1);
+ ten = ten_to_ptwo (0);
+ pten = *one;
+
+ sign = r.sign;
+ r.sign = 0;
+
+ dec_exp = REAL_EXP (&r) * M_LOG10_2;
+ for (i = 0; i < dec_exp; i++)
+ do_multiply (&pten, &pten, ten);
+ digits = dec_exp + 1;
+ gcc_assert ((digits + 2) < (int)buf_size);
+
+ p = str;
+ if (sign)
+ *p++ = '-';
+
+ digit = rtd_divmod (&r, &pten);
+ gcc_assert (digit >= 0 && digit <= 9);
+ *p++ = digit + '0';
+ while (--digits > 0)
+ {
+ do_multiply (&r, &r, ten);
+ digit = rtd_divmod (&r, &pten);
+ *p++ = digit + '0';
+ }
+ *p++ = '.';
+ *p++ = '\0';
+}
+
+/* Convert a real with an integral value to decimal float. */
+
+static void
+decimal_from_integer (REAL_VALUE_TYPE *r)
+{
+ char str[256];
+
+ decimal_integer_string (str, r, sizeof (str) - 1);
+ decimal_real_from_string (r, str);
+}
+
/* Returns 10**2**N. */
static const REAL_VALUE_TYPE *
Index: gcc/config/dfp-bit.c
===================================================================
--- gcc/config/dfp-bit.c (revision 151064)
+++ gcc/config/dfp-bit.c (working copy)
@@ -568,7 +568,6 @@ INT_TO_DFP (INT_TYPE i)
decContext context;
decContextDefault (&context, DEC_INIT_DECIMAL128);
- context.round = DEC_ROUND_DOWN;
f64 = *DEC_FLOAT_FROM_INT (&f64, i);
u32.f = *decSingleFromWider (&u32.f, &f64, &context);
if (DFP_EXCEPTIONS_ENABLED && context.status != 0)
@@ -593,7 +592,7 @@ INT_TO_DFP (INT_TYPE i)
DFP_INIT_ROUNDMODE (context.round);
/* Use a C library function to get a floating point string. */
- sprintf (buf, INT_FMT ".0", CAST_FOR_FMT(i));
+ sprintf (buf, INT_FMT ".", CAST_FOR_FMT(i));
/* Convert from the floating point string to a decimal* type. */
FROM_STRING (&s, buf, &context);
IEEE_TO_HOST (s, &f);
Index: gcc/testsuite/gcc.dg/dfp/pr41049.c
===================================================================
--- gcc/testsuite/gcc.dg/dfp/pr41049.c (revision 0)
+++ gcc/testsuite/gcc.dg/dfp/pr41049.c (revision 0)
@@ -0,0 +1,573 @@
+/* { dg-options "-std=gnu99" } */
+
+/* The preferred exponent of the result of a conversion from an
+ integral type to a decimal float type is zero. A conversion at
+ either compile time or runtime should not change the number of
+ trailing zeroes. */
+
+extern void abort (void);
+static int failcnt = 0;
+
+#ifdef DBG
+#include <stdio.h>
+#define FAILURE \
+ { printf ("failed at line %d\n", __LINE__); failcnt++; }
+#define FINISH { if (failcnt != 0) abort(); }
+#else
+#define FAILURE abort ();
+#define FINISH
+#endif
+
+#define PASTE2(A,B) A ## B
+#define PASTE(A,B) PASTE2(A,B)
+
+#define TESTVAL_NEG(VAL,SUF,SIZE) \
+ x = PASTE(PASTE(VAL,.),SUF); \
+ si = VAL; \
+ sll = PASTE(VAL,LL); \
+ a = si; \
+ b = sll; \
+ c = VAL; \
+ d = PASTE(VAL,LL); \
+ if ((__builtin_memcmp ((void *)&x, (void *)&a, SIZE) != 0) \
+ || (__builtin_memcmp ((void *)&x, (void *)&b,SIZE) != 0) \
+ || (__builtin_memcmp ((void *)&x, (void *)&c,SIZE) != 0) \
+ || (__builtin_memcmp ((void *)&x, (void *)&d,SIZE) != 0)) \
+ FAILURE
+
+#define TESTVAL_NEG_BIG(VAL,SUF,SIZE) \
+ x = PASTE(PASTE(VAL,.),SUF); \
+ sll = PASTE(VAL,LL); \
+ a = sll; \
+ b = PASTE(VAL,LL); \
+ if ((__builtin_memcmp ((void *)&x, (void *)&a, SIZE) != 0) \
+ || (__builtin_memcmp ((void *)&x, (void *)&b,SIZE) != 0)) \
+ FAILURE
+
+#define TESTVAL_NONNEG(VAL,SUF,SIZE) \
+ x = PASTE(PASTE(VAL,.),SUF); \
+ si = VAL; \
+ ui = VAL; \
+ sll = PASTE(VAL,LL); \
+ ull = PASTE(VAL,ULL); \
+ a = si; \
+ b = sll; \
+ c = ui; \
+ d = ull; \
+ e = VAL; \
+ f = VAL; \
+ g = PASTE(VAL,LL); \
+ h = PASTE(VAL,ULL); \
+ if ((__builtin_memcmp ((void *)&x, (void *)&a, SIZE) != 0) \
+ || (__builtin_memcmp ((void *)&x, (void *)&b,SIZE) != 0) \
+ || (__builtin_memcmp ((void *)&x, (void *)&c,SIZE) != 0) \
+ || (__builtin_memcmp ((void *)&x, (void *)&d,SIZE) != 0) \
+ || (__builtin_memcmp ((void *)&x, (void *)&e,SIZE) != 0) \
+ || (__builtin_memcmp ((void *)&x, (void *)&f,SIZE) != 0) \
+ || (__builtin_memcmp ((void *)&x, (void *)&g,SIZE) != 0) \
+ || (__builtin_memcmp ((void *)&x, (void *)&h,SIZE) != 0)) \
+ FAILURE
+
+#define TESTVAL_NONNEG_BIG(VAL,SUF,SIZE) \
+ x = PASTE(PASTE(VAL,.),SUF); \
+ sll = PASTE(VAL,LL); \
+ ull = PASTE(VAL,ULL); \
+ b = sll; \
+ d = ull; \
+ f = PASTE(VAL,LL); \
+ g = PASTE(VAL,ULL); \
+ if ((__builtin_memcmp ((void *)&x, (void *)&b, SIZE) != 0) \
+ || (__builtin_memcmp ((void *)&d, (void *)&d,SIZE) != 0) \
+ || (__builtin_memcmp ((void *)&f, (void *)&d,SIZE) != 0) \
+ || (__builtin_memcmp ((void *)&g, (void *)&d,SIZE) != 0)) \
+ FAILURE
+
+#undef SUFFIX
+#define SUFFIX DF
+#undef TYPE
+#define TYPE _Decimal32
+
+void
+zeroes_32 (void)
+{
+ volatile TYPE x, a, b, c, d, e, f, g, h;
+ volatile int si;
+ volatile unsigned int ui;
+ volatile long long sll;
+ volatile unsigned long long ull;
+
+ TESTVAL_NONNEG (0, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (1, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (5, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (9, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (10, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (50, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (90, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (100, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (500, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (900, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (1000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (5000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (9000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (10000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (50000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (90000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (100000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (500000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (900000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (1000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (5000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (9000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (10000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (50000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (90000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (100000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (500000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (900000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (1000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (5000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (9000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (10000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (50000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (90000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (100000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (500000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (900000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (1000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (5000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (9000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (10000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (50000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (90000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (100000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (500000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (900000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (1000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (5000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (9000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (10000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (50000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (90000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (100000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (500000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (900000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (1000000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (5000000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (9000000000000000000, SUFFIX, sizeof (TYPE));
+
+ TESTVAL_NEG (0, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-1, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-5, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-9, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-10, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-50, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-90, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-100, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-500, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-900, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-1000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-5000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-9000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-10000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-50000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-90000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-100000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-500000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-900000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-1000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-5000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-9000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-10000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-50000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-90000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-100000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-500000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-900000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-1000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-5000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-9000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-10000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-50000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-90000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-100000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-500000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-900000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-1000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-5000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-9000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-10000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-50000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-90000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-100000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-500000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-900000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-1000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-5000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-9000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-10000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-50000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-90000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-100000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-500000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-900000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-1000000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-5000000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-9000000000000000000, SUFFIX, sizeof (TYPE));
+}
+
+void
+round_32 (void)
+{
+ volatile TYPE x, a, b, c, d, e, f, g, h;
+ volatile int si;
+ volatile unsigned int ui;
+ volatile long long sll;
+ volatile unsigned long long ull;
+
+ TESTVAL_NONNEG (10000049, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (10000050, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (10000051, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (10000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (10000001, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (10000002, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (10000003, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (10000004, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (100000049, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (100000051, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (10000006, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (10000007, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (10000008, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (10000009, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (10000010, SUFFIX, sizeof (TYPE));
+
+ TESTVAL_NEG (-10000049, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-10000050, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-10000051, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-10000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-10000001, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-10000002, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-10000003, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-10000004, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-100000049, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-100000051, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-10000006, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-10000007, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-10000008, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-10000009, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-10000010, SUFFIX, sizeof (TYPE));
+}
+
+#undef SUFFIX
+#define SUFFIX DD
+#undef TYPE
+#define TYPE _Decimal64
+
+void
+zeroes_64 (void)
+{
+ volatile TYPE x, a, b, c, d, e, f, g, h;
+ volatile int si;
+ volatile unsigned int ui;
+ volatile long long sll;
+ volatile unsigned long long ull;
+
+ TESTVAL_NONNEG (0, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (1, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (5, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (9, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (10, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (50, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (90, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (100, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (500, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (900, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (1000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (5000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (9000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (10000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (50000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (90000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (100000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (500000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (900000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (1000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (5000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (9000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (10000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (50000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (90000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (100000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (500000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (900000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (1000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (5000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (9000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (10000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (50000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (90000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (100000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (500000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (900000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (1000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (5000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (9000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (10000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (50000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (90000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (100000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (500000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (900000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (1000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (5000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (9000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (10000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (50000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (90000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (100000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (500000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (900000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (1000000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (5000000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (9000000000000000000, SUFFIX, sizeof (TYPE));
+
+ TESTVAL_NEG (0, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-1, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-5, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-9, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-10, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-50, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-90, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-100, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-500, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-900, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-1000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-5000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-9000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-10000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-50000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-90000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-100000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-500000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-900000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-1000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-5000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-9000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-10000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-50000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-90000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-100000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-500000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-900000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-1000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-5000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-9000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-10000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-50000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-90000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-100000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-500000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-900000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-1000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-5000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-9000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-10000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-50000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-90000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-100000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-500000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-900000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-1000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-5000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-9000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-10000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-50000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-90000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-100000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-500000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-900000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-1000000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-5000000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-9000000000000000000, SUFFIX, sizeof (TYPE));
+}
+
+void
+round_64 (void)
+{
+ volatile TYPE x, a, b, c, d, e, f, g, h;
+ volatile int si;
+ volatile unsigned int ui;
+ volatile long long sll;
+ volatile unsigned long long ull;
+
+ TESTVAL_NONNEG_BIG (10000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (10000000000000001, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (10000000000000002, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (10000000000000003, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (10000000000000004, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (100000000000000049, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (100000000000000051, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (10000000000000006, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (10000000000000007, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (10000000000000008, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (10000000000000009, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (10000000000000010, SUFFIX, sizeof (TYPE));
+
+ TESTVAL_NEG_BIG (-10000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-10000000000000001, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-10000000000000002, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-10000000000000003, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-10000000000000004, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-100000000000000049, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-100000000000000051, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-10000000000000006, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-10000000000000007, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-10000000000000008, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-10000000000000009, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-10000000000000010, SUFFIX, sizeof (TYPE));
+}
+
+#undef SUFFIX
+#define SUFFIX DL
+#undef TYPE
+#define TYPE _Decimal128
+
+void
+zeroes_128 (void)
+{
+ volatile TYPE x, a, b, c, d, e, f, g, h;
+ volatile int si;
+ volatile unsigned int ui;
+ volatile long long sll;
+ volatile unsigned long long ull;
+
+ TESTVAL_NONNEG (0, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (1, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (5, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (9, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (10, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (50, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (90, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (100, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (500, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (900, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (1000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (5000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (9000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (10000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (50000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (90000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (100000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (500000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (900000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (1000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (5000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (9000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (10000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (50000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (90000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (100000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (500000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (900000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG (1000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (5000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (9000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (10000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (50000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (90000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (100000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (500000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (900000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (1000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (5000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (9000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (10000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (50000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (90000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (100000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (500000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (900000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (1000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (5000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (9000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (10000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (50000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (90000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (100000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (500000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (900000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (1000000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (5000000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NONNEG_BIG (9000000000000000000, SUFFIX, sizeof (TYPE));
+
+ TESTVAL_NEG (0, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-1, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-5, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-9, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-10, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-50, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-90, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-100, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-500, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-900, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-1000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-5000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-9000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-10000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-50000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-90000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-100000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-500000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-900000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-1000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-5000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-9000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-10000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-50000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-90000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-100000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-500000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-900000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG (-1000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-5000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-9000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-10000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-50000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-90000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-100000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-500000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-900000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-1000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-5000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-9000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-10000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-50000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-90000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-100000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-500000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-900000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-1000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-5000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-9000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-10000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-50000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-90000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-100000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-500000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-900000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-1000000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-5000000000000000000, SUFFIX, sizeof (TYPE));
+ TESTVAL_NEG_BIG (-9000000000000000000, SUFFIX, sizeof (TYPE));
+}
+
+
+int
+main ()
+{
+ zeroes_32 ();
+ zeroes_64 ();
+ zeroes_128 ();
+ round_32 ();
+ round_64 ();
+
+ FINISH
+}