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 <ashaposhni...@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, " _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
