From: Vladimir Makarov Date: Fri, 13 Apr 2018 22:55:16 +0000 (+0000) Subject: re PR rtl-optimization/79916 (ICE in Max. number of generated reload insns per insn... X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=53bdbcbc1265cd2a35bc24d5d4f36510e34174fe;p=gcc.git re PR rtl-optimization/79916 (ICE in Max. number of generated reload insns per insn is achieved (90)) 2018-04-13 Vladimir Makarov 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 PR rtl-optimization/79916 * gcc.target/powerpc/pr79916.c: New. From-SVN: r259379 --- diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 96247862f44..e04efca20d4 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,10 @@ +2018-04-13 Vladimir Makarov + + 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 PR rtl-optimization/85393 diff --git a/gcc/config/rs6000/rs6000.c b/gcc/config/rs6000/rs6000.c index a0c9b5c2736..c74e2a39d80 100644 --- 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 88c7185cf46..25225ec033e 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,8 @@ +2018-04-13 Vladimir Makarov + + PR rtl-optimization/79916 + * gcc.target/powerpc/pr79916.c: New. + 2018-04-13 Jakub Jelinek 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 index 00000000000..00f772e82af --- /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; +}