projects / gcc.git / commitdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: 465d008)
re PR rtl-optimization/79916 (ICE in Max. number of generated reload insns per insn...
authorVladimir Makarov <vmakarov@redhat.com>
Fri, 13 Apr 2018 22:55:16 +0000 (22:55 +0000)
committerVladimir Makarov <vmakarov@gcc.gnu.org>
Fri, 13 Apr 2018 22:55:16 +0000 (22:55 +0000)
2018-04-13  Vladimir Makarov  <vmakarov@redhat.com>

PR rtl-optimization/79916
* config/rs6000/rs6000.c (rs6000_emit_move): Use assigned hard
regs (if any) to define how to gnerate SD moves when LRA is in
progress.

2018-04-13  Vladimir Makarov  <vmakarov@redhat.com>

PR rtl-optimization/79916
* gcc.target/powerpc/pr79916.c: New.

From-SVN: r259379

gcc/ChangeLog patch | blob | history
gcc/config/rs6000/rs6000.c patch | blob | history
gcc/testsuite/ChangeLog patch | blob | history
gcc/testsuite/gcc.target/powerpc/pr79916.c [new file with mode: 0644] patch | blob

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 96247862f447421940c0c62de0c8bf2b63f1e827..e04efca20d42612023170135cc5d22b796aec68f 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,10 @@
+2018-04-13  Vladimir Makarov  <vmakarov@redhat.com>
+
+       PR rtl-optimization/79916
+       * config/rs6000/rs6000.c (rs6000_emit_move): Use assigned hard
+       regs (if any) to define how to gnerate SD moves when LRA is in
+       progress.
+
 2018-04-13  Jakub Jelinek  <jakub@redhat.com>
 
        PR rtl-optimization/85393
diff --git a/gcc/config/rs6000/rs6000.c b/gcc/config/rs6000/rs6000.c
index a0c9b5c2736bcfc775c6d606bb0085590a074ab2..c74e2a39d80dcb9649876f683f434cbb5c4c3070 100644 (file)
--- a/gcc/config/rs6000/rs6000.c
+++ b/gcc/config/rs6000/rs6000.c
@@ -10610,7 +10610,9 @@ rs6000_emit_move (rtx dest, rtx source, machine_mode mode)
       if (regno >= FIRST_PSEUDO_REGISTER)
        {
          cl = reg_preferred_class (regno);
-         regno = cl == NO_REGS ? -1 : ira_class_hard_regs[cl][1];
+         regno = reg_renumber[regno];
+         if (regno < 0)
+           regno = cl == NO_REGS ? -1 : ira_class_hard_regs[cl][1];
        }
       if (regno >= 0 && ! FP_REGNO_P (regno))
        {
@@ -10635,7 +10637,9 @@ rs6000_emit_move (rtx dest, rtx source, machine_mode mode)
        {
          cl = reg_preferred_class (regno);
          gcc_assert (cl != NO_REGS);
-         regno = ira_class_hard_regs[cl][0];
+         regno = reg_renumber[regno];
+         if (regno < 0)
+           regno = ira_class_hard_regs[cl][0];
        }
       if (FP_REGNO_P (regno))
        {
@@ -10664,7 +10668,9 @@ rs6000_emit_move (rtx dest, rtx source, machine_mode mode)
       if (regno >= FIRST_PSEUDO_REGISTER)
        {
          cl = reg_preferred_class (regno);
-         regno = cl == NO_REGS ? -1 : ira_class_hard_regs[cl][0];
+         regno = reg_renumber[regno];
+         if (regno < 0)
+           regno = cl == NO_REGS ? -1 : ira_class_hard_regs[cl][0];
        }
       if (regno >= 0 && ! FP_REGNO_P (regno))
        {
@@ -10689,7 +10695,9 @@ rs6000_emit_move (rtx dest, rtx source, machine_mode mode)
        {
          cl = reg_preferred_class (regno);
          gcc_assert (cl != NO_REGS);
-         regno = ira_class_hard_regs[cl][0];
+         regno = reg_renumber[regno];
+         if (regno < 0)
+           regno = ira_class_hard_regs[cl][0];
        }
       if (FP_REGNO_P (regno))
        {
diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index 88c7185cf4664adcd8555ef98c47c075b2870a07..25225ec033ead263adcff6beb7a2a4f8e817b0a4 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,8 @@
+2018-04-13  Vladimir Makarov  <vmakarov@redhat.com>
+
+       PR rtl-optimization/79916
+       * gcc.target/powerpc/pr79916.c: New.
+
 2018-04-13  Jakub Jelinek  <jakub@redhat.com>
 
        PR rtl-optimization/85393
diff --git a/gcc/testsuite/gcc.target/powerpc/pr79916.c b/gcc/testsuite/gcc.target/powerpc/pr79916.c
new file mode 100644 (file)
index 0000000..00f772e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/pr79916.c
@@ -0,0 +1,556 @@
+/* { dg-do compile  { target { powerpc*-*-* } } } */
+/* { dg-options "-fno-expensive-optimizations --param ira-max-conflict-table-size=0 -mno-popcntd -O3" } */
+
+#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))                \
+    __builtin_abort ();
+
+#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))                \
+    __builtin_abort ();
+
+#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))                \
+    __builtin_abort ();
+
+#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))                \
+    __builtin_abort ();
+
+#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 ();
+
+  return 0;
+}