[clang-tools-extra] [compiler-rt] Implement __extendxftf2 for x86_64 (PR #66918)
Alexander Shaposhnikov via cfe-commits
cfe-commits at lists.llvm.org
Fri Sep 22 16:40:29 PDT 2023
https://github.com/alexander-shaposhnikov updated https://github.com/llvm/llvm-project/pull/66918
>From 84cb5de329c228702da9f864312df31dc00692dc Mon Sep 17 00:00:00 2001
From: Alexander Shaposhnikov <ashaposhnikov at google.com>
Date: Wed, 20 Sep 2023 14:25:46 +0000
Subject: [PATCH] Implement __extendxftf2 for x86_64
---
compiler-rt/lib/builtins/CMakeLists.txt | 1 +
compiler-rt/lib/builtins/extendxftf2.c | 23 +++++++
compiler-rt/lib/builtins/fp_extend.h | 24 +++++++
compiler-rt/lib/builtins/fp_extend_impl.inc | 48 ++++++++++----
compiler-rt/test/builtins/Unit/addtf3_test.c | 2 +-
compiler-rt/test/builtins/Unit/divtf3_test.c | 2 +-
.../test/builtins/Unit/extenddftf2_test.c | 2 +-
.../test/builtins/Unit/extendhftf2_test.c | 2 +-
.../test/builtins/Unit/extendsftf2_test.c | 2 +-
.../test/builtins/Unit/extendxftf2_test.c | 66 +++++++++++++++++++
.../test/builtins/Unit/floatditf_test.c | 2 +-
.../test/builtins/Unit/floatsitf_test.c | 2 +-
.../test/builtins/Unit/floatunditf_test.c | 2 +-
.../test/builtins/Unit/floatunsitf_test.c | 2 +-
compiler-rt/test/builtins/Unit/fp_test.h | 55 +++++++++++++---
compiler-rt/test/builtins/Unit/multf3_test.c | 2 +-
compiler-rt/test/builtins/Unit/subtf3_test.c | 2 +-
17 files changed, 205 insertions(+), 34 deletions(-)
create mode 100644 compiler-rt/lib/builtins/extendxftf2.c
create mode 100644 compiler-rt/test/builtins/Unit/extendxftf2_test.c
diff --git a/compiler-rt/lib/builtins/CMakeLists.txt b/compiler-rt/lib/builtins/CMakeLists.txt
index 43ef62ffb115d9d..b3e6e8c8b517d83 100644
--- a/compiler-rt/lib/builtins/CMakeLists.txt
+++ b/compiler-rt/lib/builtins/CMakeLists.txt
@@ -280,6 +280,7 @@ endif ()
# long double is not 80 bits on Android or MSVC.
set(x86_80_BIT_SOURCES
divxc3.c
+ extendxftf2.c
fixxfdi.c
fixxfti.c
fixunsxfdi.c
diff --git a/compiler-rt/lib/builtins/extendxftf2.c b/compiler-rt/lib/builtins/extendxftf2.c
new file mode 100644
index 000000000000000..aa5355e94839f93
--- /dev/null
+++ b/compiler-rt/lib/builtins/extendxftf2.c
@@ -0,0 +1,23 @@
+//===-- lib/extendxftf2.c - long double -> quad conversion --------*- C -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// Assumption: long double is a IEEE 80 bit floating point type padded to 128
+// bits.
+
+// TODO: use fp_lib.h once QUAD_PRECISION is available on x86_64.
+#if __LDBL_MANT_DIG__ == 64 && defined(__x86_64__) \
+ && (defined(__FLOAT128__) || defined(__SIZEOF_FLOAT128__))
+#define SRC_80
+#define DST_QUAD
+#include "fp_extend_impl.inc"
+
+COMPILER_RT_ABI __float128 __extendxftf2(long double a) {
+ return __extendXfYf2__(a);
+}
+
+#endif
diff --git a/compiler-rt/lib/builtins/fp_extend.h b/compiler-rt/lib/builtins/fp_extend.h
index eee4722bf90e69f..fc23c1c2d7a6a81 100644
--- a/compiler-rt/lib/builtins/fp_extend.h
+++ b/compiler-rt/lib/builtins/fp_extend.h
@@ -20,14 +20,18 @@
typedef float src_t;
typedef uint32_t src_rep_t;
#define SRC_REP_C UINT32_C
+static const int srcBits = sizeof(src_t) * CHAR_BIT;
static const int srcSigBits = 23;
+static const int srcSigFracBits = 23;
#define src_rep_t_clz clzsi
#elif defined SRC_DOUBLE
typedef double src_t;
typedef uint64_t src_rep_t;
#define SRC_REP_C UINT64_C
+static const int srcBits = sizeof(src_t) * CHAR_BIT;
static const int srcSigBits = 52;
+static const int srcSigFracBits = 52;
static __inline int src_rep_t_clz(src_rep_t a) {
#if defined __LP64__
return __builtin_clzl(a);
@@ -39,6 +43,16 @@ static __inline int src_rep_t_clz(src_rep_t a) {
#endif
}
+#elif defined SRC_80
+typedef long double src_t;
+typedef __uint128_t src_rep_t;
+#define SRC_REP_C (__uint128_t)
+// sign bit, exponent and significand occupy the lower 80 bits.
+static const int srcBits = 80;
+// significand stores the integer bit.
+static const int srcSigBits = 64;
+static const int srcSigFracBits = 63;
+
#elif defined SRC_HALF
#ifdef COMPILER_RT_HAS_FLOAT16
typedef _Float16 src_t;
@@ -47,7 +61,9 @@ typedef uint16_t src_t;
#endif
typedef uint16_t src_rep_t;
#define SRC_REP_C UINT16_C
+static const int srcBits = sizeof(src_t) * CHAR_BIT;
static const int srcSigBits = 10;
+static const int srcSigFracBits = 10;
#define src_rep_t_clz __builtin_clz
#else
@@ -59,18 +75,26 @@ typedef float dst_t;
typedef uint32_t dst_rep_t;
#define DST_REP_C UINT32_C
static const int dstSigBits = 23;
+static const int dstSigFracBits = 23;
#elif defined DST_DOUBLE
typedef double dst_t;
typedef uint64_t dst_rep_t;
#define DST_REP_C UINT64_C
static const int dstSigBits = 52;
+static const int dstSigFracBits = 52;
#elif defined DST_QUAD
+// TODO: use fp_lib.h once QUAD_PRECISION is available on x86_64.
+#if __LDBL_MANT_DIG__ == 113
typedef long double dst_t;
+#elif defined(__x86_64__) && (defined(__FLOAT128__) || defined(__SIZEOF_FLOAT128__))
+typedef __float128 dst_t;
+#endif
typedef __uint128_t dst_rep_t;
#define DST_REP_C (__uint128_t)
static const int dstSigBits = 112;
+static const int dstSigFracBits = 112;
#else
#error Destination should be single, double, or quad precision!
diff --git a/compiler-rt/lib/builtins/fp_extend_impl.inc b/compiler-rt/lib/builtins/fp_extend_impl.inc
index d1c9c02a00c5314..f470f29d3fa6515 100644
--- a/compiler-rt/lib/builtins/fp_extend_impl.inc
+++ b/compiler-rt/lib/builtins/fp_extend_impl.inc
@@ -37,19 +37,27 @@
#include "fp_extend.h"
+// The source type may use a usual IEEE-754 interchange format or Intel 80-bit
+// format. In particular, for the source type srcSigFracBits may be not equal to
+// srcSigBits. The destination type is assumed to be one of IEEE-754 standard
+// types, i.e. dstSigFracBits is assumed to be equal to dstSigBits.
static __inline dst_t __extendXfYf2__(src_t a) {
// Various constants whose values follow from the type parameters.
// Any reasonable optimizer will fold and propagate all of these.
- const int srcBits = sizeof(src_t) * CHAR_BIT;
+
const int srcExpBits = srcBits - srcSigBits - 1;
const int srcInfExp = (1 << srcExpBits) - 1;
const int srcExpBias = srcInfExp >> 1;
+ const src_rep_t srcSigFracMask = (SRC_REP_C(1) << srcSigFracBits) - 1;
+ const src_rep_t srcExpMask = ((SRC_REP_C(1) << srcExpBits) - 1) << srcSigBits;
const src_rep_t srcMinNormal = SRC_REP_C(1) << srcSigBits;
const src_rep_t srcInfinity = (src_rep_t)srcInfExp << srcSigBits;
+
const src_rep_t srcSignMask = SRC_REP_C(1) << (srcSigBits + srcExpBits);
const src_rep_t srcAbsMask = srcSignMask - 1;
- const src_rep_t srcQNaN = SRC_REP_C(1) << (srcSigBits - 1);
+
+ const src_rep_t srcQNaN = SRC_REP_C(1) << (srcSigFracBits - 1);
const src_rep_t srcNaNCode = srcQNaN - 1;
const int dstBits = sizeof(dst_t) * CHAR_BIT;
@@ -69,9 +77,11 @@ static __inline dst_t __extendXfYf2__(src_t a) {
// to (signed) int. To avoid that, explicitly cast to src_rep_t.
if ((src_rep_t)(aAbs - srcMinNormal) < srcInfinity - srcMinNormal) {
// a is a normal number.
- // Extend to the destination type by shifting the significand and
- // exponent into the proper position and rebiasing the exponent.
- absResult = (dst_rep_t)aAbs << (dstSigBits - srcSigBits);
+ // Extend to the destination type by shifting the significand into the proper position.
+ absResult = ((dst_rep_t)aAbs & srcSigFracMask) << (dstSigFracBits - srcSigFracBits);
+ // Extend to the destination type by shifting the exponent into the proper position.
+ absResult |= ((dst_rep_t)aAbs & srcExpMask) << (dstSigBits - srcSigBits);
+ // Rebias the expoenent.
absResult += (dst_rep_t)(dstExpBias - srcExpBias) << dstSigBits;
}
@@ -81,19 +91,29 @@ static __inline dst_t __extendXfYf2__(src_t a) {
// bit (if needed) and right-aligning the rest of the trailing NaN
// payload field.
absResult = (dst_rep_t)dstInfExp << dstSigBits;
- absResult |= (dst_rep_t)(aAbs & srcQNaN) << (dstSigBits - srcSigBits);
- absResult |= (dst_rep_t)(aAbs & srcNaNCode) << (dstSigBits - srcSigBits);
+ absResult |= (dst_rep_t)(aAbs & srcQNaN) << (dstSigFracBits - srcSigFracBits);
+ absResult |= (dst_rep_t)(aAbs & srcNaNCode) << (dstSigFracBits - srcSigFracBits);
}
else if (aAbs) {
// a is denormal.
- // renormalize the significand and clear the leading bit, then insert
- // the correct adjusted exponent in the destination type.
- const int scale = src_rep_t_clz(aAbs) - src_rep_t_clz(srcMinNormal);
- absResult = (dst_rep_t)aAbs << (dstSigBits - srcSigBits + scale);
- absResult ^= dstMinNormal;
- const int resultExponent = dstExpBias - srcExpBias - scale + 1;
- absResult |= (dst_rep_t)resultExponent << dstSigBits;
+ if (srcExpBits == dstExpBits) {
+ // Insert the significand into the correct location in the destination type.
+ absResult = ((dst_rep_t)aAbs & srcSigFracMask) << (dstSigFracBits - srcSigFracBits);
+ } else {
+ #ifndef src_rep_t_clz
+ // If src_rep_t_clz is not defined this branch must be unreachable.
+ __builtin_unreachable();
+ #define src_rep_t_clz (int)
+ #endif
+ // Renormalize the significand and clear the leading bit, then insert
+ // the correct adjusted exponent in the destination type.
+ const int scale = src_rep_t_clz(aAbs) - src_rep_t_clz(srcMinNormal);
+ absResult = (dst_rep_t)aAbs << (dstSigBits - srcSigBits + scale);
+ absResult ^= dstMinNormal;
+ const int resultExponent = dstExpBias - srcExpBias - scale + 1;
+ absResult |= (dst_rep_t)resultExponent << dstSigBits;
+ }
}
else {
diff --git a/compiler-rt/test/builtins/Unit/addtf3_test.c b/compiler-rt/test/builtins/Unit/addtf3_test.c
index fe2e2c80f655b7a..e6986c236a64f5e 100644
--- a/compiler-rt/test/builtins/Unit/addtf3_test.c
+++ b/compiler-rt/test/builtins/Unit/addtf3_test.c
@@ -16,7 +16,7 @@ int test__addtf3(long double a, long double b,
uint64_t expectedHi, uint64_t expectedLo)
{
long double x = __addtf3(a, b);
- int ret = compareResultLD(x, expectedHi, expectedLo);
+ int ret = compareResultF128(x, expectedHi, expectedLo);
if (ret){
printf("error in test__addtf3(%.20Lf, %.20Lf) = %.20Lf, "
diff --git a/compiler-rt/test/builtins/Unit/divtf3_test.c b/compiler-rt/test/builtins/Unit/divtf3_test.c
index 927d0b826f8f57c..da6465636e92326 100644
--- a/compiler-rt/test/builtins/Unit/divtf3_test.c
+++ b/compiler-rt/test/builtins/Unit/divtf3_test.c
@@ -15,7 +15,7 @@ int test__divtf3(long double a, long double b,
uint64_t expectedHi, uint64_t expectedLo)
{
long double x = __divtf3(a, b);
- int ret = compareResultLD(x, expectedHi, expectedLo);
+ int ret = compareResultF128(x, expectedHi, expectedLo);
if (ret){
printf("error in test__divtf3(%.20Le, %.20Le) = %.20Le, "
diff --git a/compiler-rt/test/builtins/Unit/extenddftf2_test.c b/compiler-rt/test/builtins/Unit/extenddftf2_test.c
index 04a346887661bf8..fcc030ca92202e9 100644
--- a/compiler-rt/test/builtins/Unit/extenddftf2_test.c
+++ b/compiler-rt/test/builtins/Unit/extenddftf2_test.c
@@ -13,7 +13,7 @@ COMPILER_RT_ABI long double __extenddftf2(double a);
int test__extenddftf2(double a, uint64_t expectedHi, uint64_t expectedLo)
{
long double x = __extenddftf2(a);
- int ret = compareResultLD(x, expectedHi, expectedLo);
+ int ret = compareResultF128(x, expectedHi, expectedLo);
if (ret){
printf("error in test__extenddftf2(%f) = %.20Lf, "
diff --git a/compiler-rt/test/builtins/Unit/extendhftf2_test.c b/compiler-rt/test/builtins/Unit/extendhftf2_test.c
index 7d3ea3049e8a195..5de17379093af18 100644
--- a/compiler-rt/test/builtins/Unit/extendhftf2_test.c
+++ b/compiler-rt/test/builtins/Unit/extendhftf2_test.c
@@ -12,7 +12,7 @@ COMPILER_RT_ABI long double __extendhftf2(TYPE_FP16 a);
int test__extendhftf2(TYPE_FP16 a, uint64_t expectedHi, uint64_t expectedLo) {
long double x = __extendhftf2(a);
- int ret = compareResultLD(x, expectedHi, expectedLo);
+ int ret = compareResultF128(x, expectedHi, expectedLo);
if (ret) {
printf("error in test__extendhftf2(%#.4x) = %.20Lf, "
diff --git a/compiler-rt/test/builtins/Unit/extendsftf2_test.c b/compiler-rt/test/builtins/Unit/extendsftf2_test.c
index 19dd5b02c07bd26..6ce9bd81a3dd919 100644
--- a/compiler-rt/test/builtins/Unit/extendsftf2_test.c
+++ b/compiler-rt/test/builtins/Unit/extendsftf2_test.c
@@ -13,7 +13,7 @@ COMPILER_RT_ABI long double __extendsftf2(float a);
int test__extendsftf2(float a, uint64_t expectedHi, uint64_t expectedLo)
{
long double x = __extendsftf2(a);
- int ret = compareResultLD(x, expectedHi, expectedLo);
+ int ret = compareResultF128(x, expectedHi, expectedLo);
if (ret)
{
diff --git a/compiler-rt/test/builtins/Unit/extendxftf2_test.c b/compiler-rt/test/builtins/Unit/extendxftf2_test.c
new file mode 100644
index 000000000000000..c4b561a42382055
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/extendxftf2_test.c
@@ -0,0 +1,66 @@
+// RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: librt_has_extendxftf2
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#if __LDBL_MANT_DIG__ == 64 && \
+ defined(__x86_64__) && (defined(__FLOAT128__) || defined(__SIZEOF_FLOAT128__))
+
+#include "fp_test.h"
+
+COMPILER_RT_ABI __float128 __extendxftf2(long double a);
+
+int test__extendxftf2(long double a, uint64_t expectedHi, uint64_t expectedLo) {
+ __float128 x = __extendxftf2(a);
+ int ret = compareResultF128(x, expectedHi, expectedLo);
+
+ if (ret) {
+ printf("error in __extendxftf2(%.20Lf) = %.20Lf, "
+ "expected %.20Lf\n",
+ a, x, fromRep128(expectedHi, expectedLo));
+ }
+ return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main() {
+#if __LDBL_MANT_DIG__ == 64 && \
+ defined(__x86_64__) && (defined(__FLOAT128__) || defined(__SIZEOF_FLOAT128__))
+ // qNaN
+ if (test__extendxftf2(makeQNaN80(), UINT64_C(0x7fff800000000000),
+ UINT64_C(0x0)))
+ return 1;
+ // NaN
+ if (test__extendxftf2(makeNaN80(UINT64_C(0x3fffffffffffffff)),
+ UINT64_C(0x7fff7fffffffffff),
+ UINT64_C(0xfffe000000000000)))
+ return 1;
+ // inf
+ if (test__extendxftf2(makeInf80(), UINT64_C(0x7fff000000000000),
+ UINT64_C(0x0)))
+ return 1;
+ // zero
+ if (test__extendxftf2(0.0, UINT64_C(0x0), UINT64_C(0x0)))
+ return 1;
+ if (test__extendxftf2(0x1.23456789abcdefp+5, UINT64_C(0x400423456789abcd),
+ UINT64_C(0xf000000000000000)))
+ return 1;
+ if (test__extendxftf2(0x1.edcba987654321fp-9, UINT64_C(0x3ff6edcba9876543),
+ UINT64_C(0x2000000000000000)))
+ return 1;
+ if (test__extendxftf2(0x1.23456789abcdefp+45, UINT64_C(0x402c23456789abcd),
+ UINT64_C(0xf000000000000000)))
+ return 1;
+ if (test__extendxftf2(0x1.edcba987654321fp-45, UINT64_C(0x3fd2edcba9876543),
+ UINT64_C(0x2000000000000000)))
+ return 1;
+#else
+ printf("skipped\n");
+
+#endif
+ return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/floatditf_test.c b/compiler-rt/test/builtins/Unit/floatditf_test.c
index 4d5da32ec25d42f..fe7a5fd86ae8423 100644
--- a/compiler-rt/test/builtins/Unit/floatditf_test.c
+++ b/compiler-rt/test/builtins/Unit/floatditf_test.c
@@ -17,7 +17,7 @@ COMPILER_RT_ABI long double __floatditf(di_int a);
int test__floatditf(di_int a, uint64_t expectedHi, uint64_t expectedLo)
{
long double x = __floatditf(a);
- int ret = compareResultLD(x, expectedHi, expectedLo);
+ int ret = compareResultF128(x, expectedHi, expectedLo);
if (ret)
printf("error in __floatditf(%Ld) = %.20Lf, "
diff --git a/compiler-rt/test/builtins/Unit/floatsitf_test.c b/compiler-rt/test/builtins/Unit/floatsitf_test.c
index 751a4a9b9207afb..b6571b9ba223d9b 100644
--- a/compiler-rt/test/builtins/Unit/floatsitf_test.c
+++ b/compiler-rt/test/builtins/Unit/floatsitf_test.c
@@ -13,7 +13,7 @@ COMPILER_RT_ABI long double __floatsitf(si_int a);
int test__floatsitf(si_int a, uint64_t expectedHi, uint64_t expectedLo)
{
long double x = __floatsitf(a);
- int ret = compareResultLD(x, expectedHi, expectedLo);
+ int ret = compareResultF128(x, expectedHi, expectedLo);
if (ret)
{
diff --git a/compiler-rt/test/builtins/Unit/floatunditf_test.c b/compiler-rt/test/builtins/Unit/floatunditf_test.c
index d44ae7934145a6d..8da78da9760293a 100644
--- a/compiler-rt/test/builtins/Unit/floatunditf_test.c
+++ b/compiler-rt/test/builtins/Unit/floatunditf_test.c
@@ -17,7 +17,7 @@ COMPILER_RT_ABI long double __floatunditf(du_int a);
int test__floatunditf(du_int a, uint64_t expectedHi, uint64_t expectedLo)
{
long double x = __floatunditf(a);
- int ret = compareResultLD(x, expectedHi, expectedLo);
+ int ret = compareResultF128(x, expectedHi, expectedLo);
if (ret)
printf("error in __floatunditf(%Lu) = %.20Lf, "
diff --git a/compiler-rt/test/builtins/Unit/floatunsitf_test.c b/compiler-rt/test/builtins/Unit/floatunsitf_test.c
index f0a6c63eb83799d..b6b1ba045739900 100644
--- a/compiler-rt/test/builtins/Unit/floatunsitf_test.c
+++ b/compiler-rt/test/builtins/Unit/floatunsitf_test.c
@@ -13,7 +13,7 @@ COMPILER_RT_ABI long double __floatunsitf(su_int a);
int test__floatunsitf(su_int a, uint64_t expectedHi, uint64_t expectedLo)
{
long double x = __floatunsitf(a);
- int ret = compareResultLD(x, expectedHi, expectedLo);
+ int ret = compareResultF128(x, expectedHi, expectedLo);
if (ret){
printf("error in test__floatunsitf(%u) = %.20Lf, "
diff --git a/compiler-rt/test/builtins/Unit/fp_test.h b/compiler-rt/test/builtins/Unit/fp_test.h
index e54dfc108e71887..e11eacf4a2db0c7 100644
--- a/compiler-rt/test/builtins/Unit/fp_test.h
+++ b/compiler-rt/test/builtins/Unit/fp_test.h
@@ -9,6 +9,18 @@
#define TYPE_FP16 uint16_t
#endif
+// TODO: Switch to using fp_lib.h once QUAD_PRECISION is available on x86_64.
+#if __LDBL_MANT_DIG__ == 113 || \
+ ((__LDBL_MANT_DIG__ == 64) && defined(__x86_64__) && \
+ (defined(__FLOAT128__) || defined(__SIZEOF_FLOAT128__)))
+#if __LDBL_MANT_DIG__ == 113
+#define TYPE_FP128 long double
+#else
+#define TYPE_FP128 __float128
+#endif
+#define TEST_COMPILER_RT_HAS_FLOAT128
+#endif
+
enum EXPECTED_RESULT {
LESS_0, LESS_EQUAL_0, EQUAL_0, GREATER_0, GREATER_EQUAL_0, NEQUAL_0
};
@@ -38,11 +50,11 @@ static inline double fromRep64(uint64_t x)
return ret;
}
-#if __LDBL_MANT_DIG__ == 113
-static inline long double fromRep128(uint64_t hi, uint64_t lo)
+#ifdef TEST_COMPILER_RT_HAS_FLOAT128
+static inline TYPE_FP128 fromRep128(uint64_t hi, uint64_t lo)
{
__uint128_t x = ((__uint128_t)hi << 64) + lo;
- long double ret;
+ TYPE_FP128 ret;
memcpy(&ret, &x, 16);
return ret;
}
@@ -73,8 +85,8 @@ static inline uint64_t toRep64(double x)
return ret;
}
-#if __LDBL_MANT_DIG__ == 113
-static inline __uint128_t toRep128(long double x)
+#ifdef TEST_COMPILER_RT_HAS_FLOAT128
+static inline __uint128_t toRep128(TYPE_FP128 x)
{
__uint128_t ret;
memcpy(&ret, &x, 16);
@@ -136,13 +148,13 @@ static inline int compareResultD(double result,
return 1;
}
-#if __LDBL_MANT_DIG__ == 113
+#ifdef TEST_COMPILER_RT_HAS_FLOAT128
// return 0 if equal
// use two 64-bit integers instead of one 128-bit integer
// because 128-bit integer constant can't be assigned directly
-static inline int compareResultLD(long double result,
- uint64_t expectedHi,
- uint64_t expectedLo)
+static inline int compareResultF128(TYPE_FP128 result,
+ uint64_t expectedHi,
+ uint64_t expectedLo)
{
__uint128_t rep = toRep128(result);
uint64_t hi = rep >> 64;
@@ -232,6 +244,31 @@ static inline double makeQNaN64(void)
return fromRep64(0x7ff8000000000000UL);
}
+#if __LDBL_MANT_DIG__ == 64 && defined(__x86_64__)
+static inline long double LDFromRep128(uint64_t hi, uint64_t lo)
+{
+ __uint128_t x = ((__uint128_t)hi << 64) + lo;
+ long double ret;
+ memcpy(&ret, &x, 16);
+ return ret;
+}
+
+static inline long double makeQNaN80(void)
+{
+ return LDFromRep128(0x7fffUL, 0xc000000000000000UL);
+}
+
+static inline long double makeNaN80(uint64_t rand)
+{
+ return LDFromRep128(0x7fffUL, 0x8000000000000000 | (rand & 0x3fffffffffffffff));
+}
+
+static inline long double makeInf80(void)
+{
+ return LDFromRep128(0x7fffUL, 0x8000000000000000UL);
+}
+#endif
+
#if __LDBL_MANT_DIG__ == 113
static inline long double makeQNaN128(void)
{
diff --git a/compiler-rt/test/builtins/Unit/multf3_test.c b/compiler-rt/test/builtins/Unit/multf3_test.c
index 3bf6ab24cec0221..543b55899ce82a9 100644
--- a/compiler-rt/test/builtins/Unit/multf3_test.c
+++ b/compiler-rt/test/builtins/Unit/multf3_test.c
@@ -15,7 +15,7 @@ int test__multf3(long double a, long double b,
uint64_t expectedHi, uint64_t expectedLo)
{
long double x = __multf3(a, b);
- int ret = compareResultLD(x, expectedHi, expectedLo);
+ int ret = compareResultF128(x, expectedHi, expectedLo);
if (ret){
printf("error in test__multf3(%.20Lf, %.20Lf) = %.20Lf, "
diff --git a/compiler-rt/test/builtins/Unit/subtf3_test.c b/compiler-rt/test/builtins/Unit/subtf3_test.c
index 377ae95a9a7d7bb..724fa4820d99d32 100644
--- a/compiler-rt/test/builtins/Unit/subtf3_test.c
+++ b/compiler-rt/test/builtins/Unit/subtf3_test.c
@@ -16,7 +16,7 @@ int test__subtf3(long double a, long double b,
uint64_t expectedHi, uint64_t expectedLo)
{
long double x = __subtf3(a, b);
- int ret = compareResultLD(x, expectedHi, expectedLo);
+ int ret = compareResultF128(x, expectedHi, expectedLo);
if (ret){
printf("error in test__subtf3(%.20Lf, %.20Lf) = %.20Lf, "
More information about the cfe-commits
mailing list