s390x regtest: Rework pfpo

The pfpo test case relies on `_Decimal*' type support, which currently
excludes Clang.  Rework the test to avoid this.  Also, fix a typo that
causes conversions to 64-bit decimal types to be shown as "-> d6" instead
of "-> d64" in the output.  Adjust the output file accordingly.

diff --git a/none/tests/s390x/pfpo.c b/none/tests/s390x/pfpo.c
index a5300d5c51d34bfdb4382289f9ae467db24783ab..5e3cd7bf2de4e03b08d18fc460dbac3a70193655 100644 (file)
--- a/none/tests/s390x/pfpo.c
+++ b/none/tests/s390x/pfpo.c
@@ -1,11 +1,6 @@
-#include <stdio.h>
-#include <stdint.h>
 #include "dfp_utils.h"
-#define __STDC_WANT_DEC_FP__ 1
-#include <float.h>
+#include <stdio.h>
 
-#ifndef PFPO_FUNCTIONS
-#define PFPO_FUNCTIONS
 #define PFPO_F32_TO_D32   0x01080500
 #define PFPO_D32_TO_F32   0x01050800
 #define PFPO_F32_TO_D64   0x01090500
@@ -26,249 +21,123 @@
 #define PFPO_F128_TO_D128 0x010A0700
 #define PFPO_D128_TO_F128 0x01070A00
 
-#define PFPO(initial, src_type, dst_type, fn_code, round, ret_code, cc) \
-({                                                                      \
-  register src_type src_reg asm("f4") = initial;                        \
-  register dst_type dst_reg asm("f0");                                  \
-  register unsigned long fn asm("0") = fn_code | (round & 0xf);         \
-  register unsigned int ret asm("1");                                   \
-  asm volatile(".short 0x010a\n\t"                                      \
-               "ipm %2\n\t"                                             \
-               "srl %2,28\n\t"                                          \
-               :"=f"(dst_reg), "=d"(ret), "=d" (cc)                     \
-               : "f"(src_reg), "d"(fn)                                  \
-               : "cc");                                                 \
-  ret_code = ret;                                                       \
-  dst_reg;                                                              \
-})
-
-#endif /* PFPO_FUNCTIONS */
+static const pun_d32 f32_in[] = {
+   {.f = 123.5656789},
+   {.f = 0x1.fffffep+127}, /* FLT_MAX */
+   {.f = 0x1p-126},        /* FLT_MIN */
+};
+
+static const pun_d64 f64_in[] = {
+   {.f = 123456789999.5656789},
+   {.f = 0x1p-1022},               /* DBL_MIN */
+   {.f = 0x1.fffffffffffffp+1023}, /* DBL_MAX */
+};
+
+static const pun_d128 f128_in[] = {
+   {.f = 1234567812345678912345678912.5656789L},
+   {.f = 0x1p-16382L},                              /* LDBL_MIN */
+   {.f = 0x1.ffffffffffffffffffffffffffffp+16383L}, /* LDBL_MAX */
+};
+
+static const pun_d32 d32_in[] = {
+   {0x2614d757}, /* 123.5656789DF */
+   {0x77f3fcff}, /* DEC32_MAX */
+   {0x00600001}, /* DEC32_MAX */
+};
+
+static const pun_d64 d64_in[] = {
+   {0x262934b9c7fa7f57}, /* 123456789999.5656789DD */
+   {0x003c000000000001}, /* DEC64_MIN */
+   {0x77fcff3fcff3fcff}, /* DEC64_MAX */
+};
+
+static const pun_d128 d128_in[] = {
+   {{0x2606934b9d1c7177, 0x8671c5de19cb9779}},
+   {{0x0008400000000000, 0x0000000000000001}},
+   {{0x77ffcff3fcff3fcf, 0xf3fcff3fcff3fcff}},
+};
+
+#define PFPO(initial, src_type, dst_type, fn_code, round, ret_code, cc)        \
+   ({                                                                          \
+      pun_##dst_type          dst;                                             \
+      register reg_##src_type src_reg asm("f4") = initial.f;                   \
+      register reg_##dst_type dst_reg asm("f0");                               \
+      register unsigned long  fn asm("0") = fn_code | (round & 0xf);           \
+      register unsigned int   ret asm("1");                                    \
+      asm(".insn e,0x010a\n\t"                                                 \
+          "ipm %2\n\t"                                                         \
+          "srl %2,28\n\t"                                                      \
+          : "=f"(dst_reg), "=d"(ret), "=d"(cc)                                 \
+          : "f"(src_reg), "d"(fn)                                              \
+          : "cc");                                                             \
+      ret_code = ret;                                                          \
+      dst.f    = dst_reg;                                                      \
+      dst;                                                                     \
+   })
+
+#define TEST_TO_DEC(in_bits, out_bits, flg, round)                             \
+   ({                                                                          \
+      pun_d##out_bits result;                                                  \
+      for (unsigned j = 0; j < 3; j++) {                                       \
+         printf("f" #in_bits " -> d" #out_bits ": round=%x ", round);          \
+         printf("%" flg "a -> ", f##in_bits##_in[j].f);                        \
+         result = PFPO(f##in_bits##_in[j], d##in_bits, d##out_bits,            \
+                       PFPO_F##in_bits##_TO_D##out_bits, round, ret_code, cc); \
+         DFP_VAL_PRINT(result, pun_d##out_bits);                               \
+         printf(" ret=%d cc=%d\n", ret_code, cc);                              \
+      }                                                                        \
+   })
+
+#define TEST_FROM_DEC(in_bits, out_bits, flg, round)                           \
+   ({                                                                          \
+      pun_d##out_bits result;                                                  \
+      for (unsigned j = 0; j < 3; j++) {                                       \
+         printf("d" #in_bits " -> f" #out_bits ": round=%x ", round);          \
+         DFP_VAL_PRINT(d##in_bits##_in[j], pun_d##in_bits);                    \
+         result = PFPO(d##in_bits##_in[j], d##in_bits, d##out_bits,            \
+                       PFPO_D##in_bits##_TO_F##out_bits, round, ret_code, cc); \
+         printf(" -> %" flg "a", result.f);                                    \
+         printf(" ret=%d cc=%d\n", ret_code, cc);                              \
+      }                                                                        \
+   })
 
 /* Test BFP <-> DFP conversions */
 int main()
 {
-  int cc;
-  uint8_t i, j;
-  unsigned int ret_code;
-
-  float f32;
-  double f64;
-  long double f128;
-
-  _Decimal32 d32;
-  _Decimal64 d64;
-  _Decimal128 d128;
-
-  float f32_in[] = {123.5656789, FLT_MAX, FLT_MIN};
-  double f64_in[] = {123456789999.5656789, DBL_MIN, DBL_MAX};
-  long double f128_in[] = {1234567812345678912345678912.5656789L,
-                           LDBL_MIN, LDBL_MAX};
-
-  _Decimal32 d32_in[] = {123.5656789DF, DEC32_MAX, DEC32_MIN};
-  _Decimal64 d64_in[] = {123456789999.5656789DD, DEC64_MIN, DEC64_MAX};
-  _Decimal128 d128_in[] = {1234567812345678912345678912.5656789DL,
-                           DEC128_MIN, DEC128_MAX};
-
- /* valid function code */
-  PFPO(0., double, _Decimal64, 0x81090600, 0, ret_code, cc);
-  printf("pfpo test: function=%x ret=%d cc=%d\n", 0x81090600, ret_code, cc);
-
- /* invalid function code */
-  PFPO(0., double, _Decimal64, 0x81990600, 0, ret_code, cc);
-  printf("pfpo test: function=%x ret=%d cc=%d\n", 0x81990600, ret_code, cc);
-
-  for (i = 0; i < 16; i++) {
-    if (i < 2 || i > 7) {
-
-      /* f32 -> d32 */
-      for(j = 0; j < 3; j++) {
-        printf("f32 -> d32: round=%x ", i);
-        printf("%a -> ", f32_in[j]);
-        d32 = PFPO(f32_in[j], float, _Decimal32, PFPO_F32_TO_D32,
-                   i, ret_code, cc);
-        DFP_VAL_PRINT(d32, _Decimal32);
-        printf(" ret=%d cc=%d\n", ret_code, cc);
-      }
-
-      /* f32 -> d64 */
-      for(j = 0; j < 3; j++) {
-        printf("f32 -> d64: round=%x ", i);
-        printf("%a -> ", f32_in[j]);
-        d64 = PFPO(f32_in[j], float, _Decimal64, PFPO_F32_TO_D64,
-                   i, ret_code, cc);
-        DFP_VAL_PRINT(d64, _Decimal64);
-        printf(" ret=%d cc=%d\n", ret_code, cc);
-      }
-
-      /* f32 -> d128 */
-      for(j = 0; j < 3; j++) {
-        printf("f32 -> d128: round=%x ", i);
-        printf("%a -> ", f32_in[j]);
-        d128 = PFPO(f32_in[j], float, _Decimal128, PFPO_F32_TO_D128,
-                    i, ret_code, cc);
-        DFP_VAL_PRINT(d128, _Decimal128);
-        printf(" ret=%d cc=%d\n", ret_code, cc);
-      }
-
-      /* f64 -> d32 */
-      for(j = 0; j < 3; j++) {
-        printf("f64 -> d32: round=%x ", i);
-        printf("%a -> ", f64_in[j]);
-        d32 = PFPO(f64_in[j], double, _Decimal32, PFPO_F64_TO_D32,
-                   i, ret_code, cc);
-        DFP_VAL_PRINT(d32, _Decimal32);
-        printf(" ret=%d cc=%d\n", ret_code, cc);
-      }
-
-      /* f64 -> d64 */
-      for(j = 0; j < 3; j++) {
-        printf("f64 -> d64: round=%x ", i);
-        printf("%a -> ", f64_in[j]);
-        d64 = PFPO(f64_in[j], double, _Decimal64, PFPO_F64_TO_D64,
-                   i, ret_code, cc);
-        DFP_VAL_PRINT(d64, _Decimal64);
-        printf(" ret=%d cc=%d\n", ret_code, cc);
-      }
-
-      /* f64 -> d128 */
-      for(j = 0; j < 3; j++) {
-        printf("f64 -> d128: round=%x ", i);
-        printf("%a -> ", f64_in[j]);
-        d128 = PFPO(f64_in[j], double, _Decimal128, PFPO_F64_TO_D128,
-                   i, ret_code, cc);
-        DFP_VAL_PRINT(d128, _Decimal128);
-        printf(" ret=%d cc=%d\n", ret_code, cc);
-      }
-
-      /* f128 -> d32 */
-      for(j = 0; j < 3; j++) {
-        printf("f128 -> d32: round=%x ", i);
-        printf("%La -> ", f128_in[j]);
-        d32 = PFPO(f128_in[j], long double, _Decimal32, PFPO_F128_TO_D32,
-                   i, ret_code, cc);
-        DFP_VAL_PRINT(d32, _Decimal32);
-        printf(" ret=%d cc=%d\n", ret_code, cc);
-      }
-
-      /* f128 -> d64 */
-      for(j = 0; j < 3; j++) {
-        printf("f128 -> d6: round=%x ", i);
-        printf("%La -> ", f128_in[j]);
-        d64 = PFPO(f128_in[j], long double, _Decimal64, PFPO_F128_TO_D64,
-                   i, ret_code, cc);
-        DFP_VAL_PRINT(d64, _Decimal64);
-        printf(" ret=%d cc=%d\n", ret_code, cc);
-      }
-
-      /* f128 -> d128 */
-      for(j = 0; j < 3; j++) {
-        printf("f128 -> d128: round=%x ", i);
-        printf("%La -> ", f128_in[j]);
-        d128 = PFPO(f128_in[j], long double, _Decimal128, PFPO_F128_TO_D128,
-                   i, ret_code, cc);
-        DFP_VAL_PRINT(d128, _Decimal128);
-        printf(" ret=%d cc=%d\n", ret_code, cc);
-      }
-
-      /* d32 -> f32 */
-      for(j = 0; j < 3; j++) {
-        printf("d32 -> f32: round=%x ", i);
-        DFP_VAL_PRINT(d32_in[j], _Decimal32);
-        printf(" -> ");
-        f32 = PFPO(d32_in[j], _Decimal32, float, PFPO_D32_TO_F32,
-                   i, ret_code, cc);
-        printf("%a", f32);
-        printf(" ret=%d cc=%d\n", ret_code, cc);
-      }
-
-      /* d32 -> f64 */
-      for(j = 0; j < 3; j++) {
-        printf("d32 -> f64: round=%x ", i);
-        DFP_VAL_PRINT(d32_in[j], _Decimal32);
-        printf(" -> ");
-        f64 = PFPO(d32_in[j], _Decimal32, double, PFPO_D32_TO_F64,
-                   i, ret_code, cc);
-        printf("%a", f64);
-        printf(" ret=%d cc=%d\n", ret_code, cc);
-      }
-
-      /* d32 -> f128 */
-      for(j = 0; j < 3; j++) {
-        printf("d32 -> f128: round=%x ", i);
-        DFP_VAL_PRINT(d32_in[j], _Decimal32);
-        printf(" -> ");
-        f128 = PFPO(d32_in[j], _Decimal32, long double, PFPO_D32_TO_F128,
-                   i, ret_code, cc);
-        printf("%La", f128);
-        printf(" ret=%d cc=%d\n", ret_code, cc);
-      }
-
-      /* d64 -> f32 */
-      for(j = 0; j < 3; j++) {
-        printf("d64 -> f32: round=%x ", i);
-        DFP_VAL_PRINT(d64_in[j], _Decimal64);
-        printf(" -> ");
-        f32 = PFPO(d64_in[j], _Decimal64, float, PFPO_D64_TO_F32,
-                   i, ret_code, cc);
-        printf("%a", f32);
-        printf(" ret=%d cc=%d\n", ret_code, cc);
-      }
-
-      /* d64 -> f64 */
-      for(j = 0; j < 3; j++) {
-        printf("d64 -> f64: round=%x ", i);
-        DFP_VAL_PRINT(d64_in[j], _Decimal64);
-        printf(" -> ");
-        f64 = PFPO(d64_in[j], _Decimal64, double, PFPO_D64_TO_F64,
-                   i, ret_code, cc);
-        printf("%a", f64);
-        printf(" ret=%d cc=%d\n", ret_code, cc);
-      }
-
-      /* d64 -> f128 */
-      for(j = 0; j < 3; j++) {
-        printf("d64 -> f128: round=%x ", i);
-        DFP_VAL_PRINT(d64_in[j], _Decimal64);
-        printf(" -> ");
-        f128 = PFPO(d64_in[j], _Decimal64, long double, PFPO_D64_TO_F128,
-                   i, ret_code, cc);
-        printf("%La", f128);
-        printf(" ret=%d cc=%d\n", ret_code, cc);
-      }
-
-      /* d128 -> f32 */
-      for(j = 0; j < 3; j++) {
-        printf("d128 -> f32: round=%x ", i);
-        DFP_VAL_PRINT(d128_in[j], _Decimal128);
-        printf(" -> ");
-        f32 = PFPO(d128_in[j], _Decimal128, float, PFPO_D128_TO_F32,
-                   i, ret_code, cc);
-        printf("%a", f32);
-        printf(" ret=%d cc=%d\n", ret_code, cc);
-      }
-
-      /* d128 -> f64 */
-      for(j = 0; j < 3; j++) {
-        printf("d128 -> f64: round=%x ", i);
-        DFP_VAL_PRINT(d128_in[j], _Decimal128);
-        printf(" -> ");
-        f64 = PFPO(d128_in[j], _Decimal128, double, PFPO_D128_TO_F64,
-                   i, ret_code, cc);
-        printf("%a", f64);
-        printf(" ret=%d cc=%d\n", ret_code, cc);
-      }
-
-      /* d128 -> f128 */
-      for(j = 0; j < 3; j++) {
-        printf("d128 -> f128: round=%x ", i);
-        DFP_VAL_PRINT(d128_in[j], _Decimal128);
-        printf(" -> ");
-        f128 = PFPO(d128_in[j], _Decimal128, long double, PFPO_D128_TO_F128,
-                   i, ret_code, cc);
-        printf("%La", f128);
-        printf(" ret=%d cc=%d\n", ret_code, cc);
-      }
-    }
-  }
-  return 0;
+   int                  cc;
+   unsigned             ret_code;
+   static const pun_d64 f64_zero = {.f = 0.};
+
+   /* valid function code */
+   PFPO(f64_zero, d64, d64, 0x81090600, 0, ret_code, cc);
+   printf("pfpo test: function=%x ret=%d cc=%d\n", 0x81090600, ret_code, cc);
+
+   /* invalid function code */
+   PFPO(f64_zero, d64, d64, 0x81990600, 0, ret_code, cc);
+   printf("pfpo test: function=%x ret=%d cc=%d\n", 0x81990600, ret_code, cc);
+
+   for (unsigned i = 0; i < 16; i++) {
+      if (i < 2 || i > 7) {
+         TEST_TO_DEC(32, 32, "", i);
+         TEST_TO_DEC(32, 64, "", i);
+         TEST_TO_DEC(32, 128, "", i);
+         TEST_TO_DEC(64, 32, "", i);
+         TEST_TO_DEC(64, 64, "", i);
+         TEST_TO_DEC(64, 128, "", i);
+         TEST_TO_DEC(128, 32, "L", i);
+         TEST_TO_DEC(128, 64, "L", i);
+         TEST_TO_DEC(128, 128, "L", i);
+
+         TEST_FROM_DEC(32, 32, "", i);
+         TEST_FROM_DEC(32, 64, "", i);
+         TEST_FROM_DEC(32, 128, "L", i);
+         TEST_FROM_DEC(64, 32, "", i);
+         TEST_FROM_DEC(64, 64, "", i);
+         TEST_FROM_DEC(64, 128, "L", i);
+         TEST_FROM_DEC(128, 32, "", i);
+         TEST_FROM_DEC(128, 64, "", i);
+         TEST_FROM_DEC(128, 128, "L", i);
+      }
+   }
+   return 0;
 }

diff --git a/none/tests/s390x/pfpo.stdout.exp b/none/tests/s390x/pfpo.stdout.exp
index ed628c26991eff948d53cdc80f7b13d5cfe3cc5a..a726c97377e33cdf27de6b210ae34875278a2062 100644 (file)
--- a/none/tests/s390x/pfpo.stdout.exp
+++ b/none/tests/s390x/pfpo.stdout.exp
@@ -21,9 +21,9 @@ f64 -> d128: round=0 0x1.fffffffffffffp+1023 -> 264cffbcecb45b195e20c55d13765c44
 f128 -> d32: round=0 0x1.fe9af39b0ba6d66022922048682bp+89 -> 27a4d2e8 ret=0 cc=1
 f128 -> d32: round=0 0x1p-16382 -> 00000000 ret=0 cc=1
 f128 -> d32: round=0 0x1.ffffffffffffffffffffffffffffp+16383 -> 78000000 ret=0 cc=1
-f128 -> d6: round=0 0x1.fe9af39b0ba6d66022922048682bp+89 -> 266934b9d1c71779 ret=0 cc=1
-f128 -> d6: round=0 0x1p-16382 -> 0000000000000000 ret=0 cc=1
-f128 -> d6: round=0 0x1.ffffffffffffffffffffffffffffp+16383 -> 7800000000000000 ret=0 cc=1
+f128 -> d64: round=0 0x1.fe9af39b0ba6d66022922048682bp+89 -> 266934b9d1c71779 ret=0 cc=1
+f128 -> d64: round=0 0x1p-16382 -> 0000000000000000 ret=0 cc=1
+f128 -> d64: round=0 0x1.ffffffffffffffffffffffffffffp+16383 -> 7800000000000000 ret=0 cc=1
 f128 -> d128: round=0 0x1.fe9af39b0ba6d66022922048682bp+89 -> 2606934b9d1c71778671c5de19cb9779 ret=0 cc=1
 f128 -> d128: round=0 0x1p-16382 -> 0d2ede220cc32483ba1962ddf1d687d3 ret=0 cc=1
 f128 -> d128: round=0 0x1.ffffffffffffffffffffffffffffp+16383 -> 46d0ccfec65b75d31f944bf65a6ca007 ret=0 cc=1
@@ -75,9 +75,9 @@ f64 -> d128: round=1 0x1.fffffffffffffp+1023 -> 264cffbcecb45b195e20c55d13765c44
 f128 -> d32: round=1 0x1.fe9af39b0ba6d66022922048682bp+89 -> 27a4d2e8 ret=0 cc=1
 f128 -> d32: round=1 0x1p-16382 -> 00000000 ret=0 cc=1
 f128 -> d32: round=1 0x1.ffffffffffffffffffffffffffffp+16383 -> 78000000 ret=0 cc=1
-f128 -> d6: round=1 0x1.fe9af39b0ba6d66022922048682bp+89 -> 266934b9d1c71779 ret=0 cc=1
-f128 -> d6: round=1 0x1p-16382 -> 0000000000000000 ret=0 cc=1
-f128 -> d6: round=1 0x1.ffffffffffffffffffffffffffffp+16383 -> 7800000000000000 ret=0 cc=1
+f128 -> d64: round=1 0x1.fe9af39b0ba6d66022922048682bp+89 -> 266934b9d1c71779 ret=0 cc=1
+f128 -> d64: round=1 0x1p-16382 -> 0000000000000000 ret=0 cc=1
+f128 -> d64: round=1 0x1.ffffffffffffffffffffffffffffp+16383 -> 7800000000000000 ret=0 cc=1
 f128 -> d128: round=1 0x1.fe9af39b0ba6d66022922048682bp+89 -> 2606934b9d1c71778671c5de19cb9779 ret=0 cc=1
 f128 -> d128: round=1 0x1p-16382 -> 0d2ede220cc32483ba1962ddf1d687d3 ret=0 cc=1
 f128 -> d128: round=1 0x1.ffffffffffffffffffffffffffffp+16383 -> 46d0ccfec65b75d31f944bf65a6ca007 ret=0 cc=1
@@ -129,9 +129,9 @@ f64 -> d128: round=8 0x1.fffffffffffffp+1023 -> 264cffbcecb45b195e20c55d13765c44
 f128 -> d32: round=8 0x1.fe9af39b0ba6d66022922048682bp+89 -> 27a4d2e8 ret=0 cc=1
 f128 -> d32: round=8 0x1p-16382 -> 00000000 ret=0 cc=1
 f128 -> d32: round=8 0x1.ffffffffffffffffffffffffffffp+16383 -> 78000000 ret=0 cc=1
-f128 -> d6: round=8 0x1.fe9af39b0ba6d66022922048682bp+89 -> 266934b9d1c71779 ret=0 cc=1
-f128 -> d6: round=8 0x1p-16382 -> 0000000000000000 ret=0 cc=1
-f128 -> d6: round=8 0x1.ffffffffffffffffffffffffffffp+16383 -> 7800000000000000 ret=0 cc=1
+f128 -> d64: round=8 0x1.fe9af39b0ba6d66022922048682bp+89 -> 266934b9d1c71779 ret=0 cc=1
+f128 -> d64: round=8 0x1p-16382 -> 0000000000000000 ret=0 cc=1
+f128 -> d64: round=8 0x1.ffffffffffffffffffffffffffffp+16383 -> 7800000000000000 ret=0 cc=1
 f128 -> d128: round=8 0x1.fe9af39b0ba6d66022922048682bp+89 -> 2606934b9d1c71778671c5de19cb9779 ret=0 cc=1
 f128 -> d128: round=8 0x1p-16382 -> 0d2ede220cc32483ba1962ddf1d687d3 ret=0 cc=1
 f128 -> d128: round=8 0x1.ffffffffffffffffffffffffffffp+16383 -> 46d0ccfec65b75d31f944bf65a6ca007 ret=0 cc=1
@@ -183,9 +183,9 @@ f64 -> d128: round=9 0x1.fffffffffffffp+1023 -> 264cffbcecb45b195e20c55d13765c43
 f128 -> d32: round=9 0x1.fe9af39b0ba6d66022922048682bp+89 -> 27a4d2e7 ret=0 cc=1
 f128 -> d32: round=9 0x1p-16382 -> 00000000 ret=0 cc=1
 f128 -> d32: round=9 0x1.ffffffffffffffffffffffffffffp+16383 -> 77f3fcff ret=0 cc=1
-f128 -> d6: round=9 0x1.fe9af39b0ba6d66022922048682bp+89 -> 266934b9d1c71778 ret=0 cc=1
-f128 -> d6: round=9 0x1p-16382 -> 0000000000000000 ret=0 cc=1
-f128 -> d6: round=9 0x1.ffffffffffffffffffffffffffffp+16383 -> 77fcff3fcff3fcff ret=0 cc=1
+f128 -> d64: round=9 0x1.fe9af39b0ba6d66022922048682bp+89 -> 266934b9d1c71778 ret=0 cc=1
+f128 -> d64: round=9 0x1p-16382 -> 0000000000000000 ret=0 cc=1
+f128 -> d64: round=9 0x1.ffffffffffffffffffffffffffffp+16383 -> 77fcff3fcff3fcff ret=0 cc=1
 f128 -> d128: round=9 0x1.fe9af39b0ba6d66022922048682bp+89 -> 2606934b9d1c71778671c5de19cb9778 ret=0 cc=1
 f128 -> d128: round=9 0x1p-16382 -> 0d2ede220cc32483ba1962ddf1d687d2 ret=0 cc=1
 f128 -> d128: round=9 0x1.ffffffffffffffffffffffffffffp+16383 -> 46d0ccfec65b75d31f944bf65a6ca007 ret=0 cc=1
@@ -237,9 +237,9 @@ f64 -> d128: round=a 0x1.fffffffffffffp+1023 -> 264cffbcecb45b195e20c55d13765c44
 f128 -> d32: round=a 0x1.fe9af39b0ba6d66022922048682bp+89 -> 27a4d2e8 ret=0 cc=1
 f128 -> d32: round=a 0x1p-16382 -> 00000001 ret=0 cc=1
 f128 -> d32: round=a 0x1.ffffffffffffffffffffffffffffp+16383 -> 78000000 ret=0 cc=1
-f128 -> d6: round=a 0x1.fe9af39b0ba6d66022922048682bp+89 -> 266934b9d1c71779 ret=0 cc=1
-f128 -> d6: round=a 0x1p-16382 -> 0000000000000001 ret=0 cc=1
-f128 -> d6: round=a 0x1.ffffffffffffffffffffffffffffp+16383 -> 7800000000000000 ret=0 cc=1
+f128 -> d64: round=a 0x1.fe9af39b0ba6d66022922048682bp+89 -> 266934b9d1c71779 ret=0 cc=1
+f128 -> d64: round=a 0x1p-16382 -> 0000000000000001 ret=0 cc=1
+f128 -> d64: round=a 0x1.ffffffffffffffffffffffffffffp+16383 -> 7800000000000000 ret=0 cc=1
 f128 -> d128: round=a 0x1.fe9af39b0ba6d66022922048682bp+89 -> 2606934b9d1c71778671c5de19cb9779 ret=0 cc=1
 f128 -> d128: round=a 0x1p-16382 -> 0d2ede220cc32483ba1962ddf1d687d3 ret=0 cc=1
 f128 -> d128: round=a 0x1.ffffffffffffffffffffffffffffp+16383 -> 46d0ccfec65b75d31f944bf65a6ca008 ret=0 cc=1
@@ -291,9 +291,9 @@ f64 -> d128: round=b 0x1.fffffffffffffp+1023 -> 264cffbcecb45b195e20c55d13765c43
 f128 -> d32: round=b 0x1.fe9af39b0ba6d66022922048682bp+89 -> 27a4d2e7 ret=0 cc=1
 f128 -> d32: round=b 0x1p-16382 -> 00000000 ret=0 cc=1
 f128 -> d32: round=b 0x1.ffffffffffffffffffffffffffffp+16383 -> 77f3fcff ret=0 cc=1
-f128 -> d6: round=b 0x1.fe9af39b0ba6d66022922048682bp+89 -> 266934b9d1c71778 ret=0 cc=1
-f128 -> d6: round=b 0x1p-16382 -> 0000000000000000 ret=0 cc=1
-f128 -> d6: round=b 0x1.ffffffffffffffffffffffffffffp+16383 -> 77fcff3fcff3fcff ret=0 cc=1
+f128 -> d64: round=b 0x1.fe9af39b0ba6d66022922048682bp+89 -> 266934b9d1c71778 ret=0 cc=1
+f128 -> d64: round=b 0x1p-16382 -> 0000000000000000 ret=0 cc=1
+f128 -> d64: round=b 0x1.ffffffffffffffffffffffffffffp+16383 -> 77fcff3fcff3fcff ret=0 cc=1
 f128 -> d128: round=b 0x1.fe9af39b0ba6d66022922048682bp+89 -> 2606934b9d1c71778671c5de19cb9778 ret=0 cc=1
 f128 -> d128: round=b 0x1p-16382 -> 0d2ede220cc32483ba1962ddf1d687d2 ret=0 cc=1
 f128 -> d128: round=b 0x1.ffffffffffffffffffffffffffffp+16383 -> 46d0ccfec65b75d31f944bf65a6ca007 ret=0 cc=1
@@ -345,9 +345,9 @@ f64 -> d128: round=c 0x1.fffffffffffffp+1023 -> 264cffbcecb45b195e20c55d13765c44
 f128 -> d32: round=c 0x1.fe9af39b0ba6d66022922048682bp+89 -> 27a4d2e8 ret=0 cc=1
 f128 -> d32: round=c 0x1p-16382 -> 00000000 ret=0 cc=1
 f128 -> d32: round=c 0x1.ffffffffffffffffffffffffffffp+16383 -> 78000000 ret=0 cc=1
-f128 -> d6: round=c 0x1.fe9af39b0ba6d66022922048682bp+89 -> 266934b9d1c71779 ret=0 cc=1
-f128 -> d6: round=c 0x1p-16382 -> 0000000000000000 ret=0 cc=1
-f128 -> d6: round=c 0x1.ffffffffffffffffffffffffffffp+16383 -> 7800000000000000 ret=0 cc=1
+f128 -> d64: round=c 0x1.fe9af39b0ba6d66022922048682bp+89 -> 266934b9d1c71779 ret=0 cc=1
+f128 -> d64: round=c 0x1p-16382 -> 0000000000000000 ret=0 cc=1
+f128 -> d64: round=c 0x1.ffffffffffffffffffffffffffffp+16383 -> 7800000000000000 ret=0 cc=1
 f128 -> d128: round=c 0x1.fe9af39b0ba6d66022922048682bp+89 -> 2606934b9d1c71778671c5de19cb9779 ret=0 cc=1
 f128 -> d128: round=c 0x1p-16382 -> 0d2ede220cc32483ba1962ddf1d687d3 ret=0 cc=1
 f128 -> d128: round=c 0x1.ffffffffffffffffffffffffffffp+16383 -> 46d0ccfec65b75d31f944bf65a6ca007 ret=0 cc=1
@@ -399,9 +399,9 @@ f64 -> d128: round=d 0x1.fffffffffffffp+1023 -> 264cffbcecb45b195e20c55d13765c44
 f128 -> d32: round=d 0x1.fe9af39b0ba6d66022922048682bp+89 -> 27a4d2e8 ret=0 cc=1
 f128 -> d32: round=d 0x1p-16382 -> 00000000 ret=0 cc=1
 f128 -> d32: round=d 0x1.ffffffffffffffffffffffffffffp+16383 -> 78000000 ret=0 cc=1
-f128 -> d6: round=d 0x1.fe9af39b0ba6d66022922048682bp+89 -> 266934b9d1c71779 ret=0 cc=1
-f128 -> d6: round=d 0x1p-16382 -> 0000000000000000 ret=0 cc=1
-f128 -> d6: round=d 0x1.ffffffffffffffffffffffffffffp+16383 -> 7800000000000000 ret=0 cc=1
+f128 -> d64: round=d 0x1.fe9af39b0ba6d66022922048682bp+89 -> 266934b9d1c71779 ret=0 cc=1
+f128 -> d64: round=d 0x1p-16382 -> 0000000000000000 ret=0 cc=1
+f128 -> d64: round=d 0x1.ffffffffffffffffffffffffffffp+16383 -> 7800000000000000 ret=0 cc=1
 f128 -> d128: round=d 0x1.fe9af39b0ba6d66022922048682bp+89 -> 2606934b9d1c71778671c5de19cb9779 ret=0 cc=1
 f128 -> d128: round=d 0x1p-16382 -> 0d2ede220cc32483ba1962ddf1d687d3 ret=0 cc=1
 f128 -> d128: round=d 0x1.ffffffffffffffffffffffffffffp+16383 -> 46d0ccfec65b75d31f944bf65a6ca007 ret=0 cc=1
@@ -453,9 +453,9 @@ f64 -> d128: round=e 0x1.fffffffffffffp+1023 -> 264cffbcecb45b195e20c55d13765c44
 f128 -> d32: round=e 0x1.fe9af39b0ba6d66022922048682bp+89 -> 27a4d2e8 ret=0 cc=1
 f128 -> d32: round=e 0x1p-16382 -> 00000001 ret=0 cc=1
 f128 -> d32: round=e 0x1.ffffffffffffffffffffffffffffp+16383 -> 78000000 ret=0 cc=1
-f128 -> d6: round=e 0x1.fe9af39b0ba6d66022922048682bp+89 -> 266934b9d1c71779 ret=0 cc=1
-f128 -> d6: round=e 0x1p-16382 -> 0000000000000001 ret=0 cc=1
-f128 -> d6: round=e 0x1.ffffffffffffffffffffffffffffp+16383 -> 7800000000000000 ret=0 cc=1
+f128 -> d64: round=e 0x1.fe9af39b0ba6d66022922048682bp+89 -> 266934b9d1c71779 ret=0 cc=1
+f128 -> d64: round=e 0x1p-16382 -> 0000000000000001 ret=0 cc=1
+f128 -> d64: round=e 0x1.ffffffffffffffffffffffffffffp+16383 -> 7800000000000000 ret=0 cc=1
 f128 -> d128: round=e 0x1.fe9af39b0ba6d66022922048682bp+89 -> 2606934b9d1c71778671c5de19cb9779 ret=0 cc=1
 f128 -> d128: round=e 0x1p-16382 -> 0d2ede220cc32483ba1962ddf1d687d3 ret=0 cc=1
 f128 -> d128: round=e 0x1.ffffffffffffffffffffffffffffp+16383 -> 46d0ccfec65b75d31f944bf65a6ca008 ret=0 cc=1
@@ -507,9 +507,9 @@ f64 -> d128: round=f 0x1.fffffffffffffp+1023 -> 264cffbcecb45b195e20c55d13765c43
 f128 -> d32: round=f 0x1.fe9af39b0ba6d66022922048682bp+89 -> 27a4d2e7 ret=0 cc=1
 f128 -> d32: round=f 0x1p-16382 -> 00000001 ret=0 cc=1
 f128 -> d32: round=f 0x1.ffffffffffffffffffffffffffffp+16383 -> 77f3fcff ret=0 cc=1
-f128 -> d6: round=f 0x1.fe9af39b0ba6d66022922048682bp+89 -> 266934b9d1c71778 ret=0 cc=1
-f128 -> d6: round=f 0x1p-16382 -> 0000000000000001 ret=0 cc=1
-f128 -> d6: round=f 0x1.ffffffffffffffffffffffffffffp+16383 -> 77fcff3fcff3fcff ret=0 cc=1
+f128 -> d64: round=f 0x1.fe9af39b0ba6d66022922048682bp+89 -> 266934b9d1c71778 ret=0 cc=1
+f128 -> d64: round=f 0x1p-16382 -> 0000000000000001 ret=0 cc=1
+f128 -> d64: round=f 0x1.ffffffffffffffffffffffffffffp+16383 -> 77fcff3fcff3fcff ret=0 cc=1
 f128 -> d128: round=f 0x1.fe9af39b0ba6d66022922048682bp+89 -> 2606934b9d1c71778671c5de19cb9778 ret=0 cc=1
 f128 -> d128: round=f 0x1p-16382 -> 0d2ede220cc32483ba1962ddf1d687d2 ret=0 cc=1
 f128 -> d128: round=f 0x1.ffffffffffffffffffffffffffffp+16383 -> 46d0ccfec65b75d31f944bf65a6ca007 ret=0 cc=1