[builtins] Support building the 128-bit float functions on x86

[arichardson]

Summary

GCC provides these functions (e.g. __addtf3, etc.) in libgcc on x86_64.
Since Clang supports float128, we can also enable the existing code by
using float128 for fp_t if either __FLOAT128__ or __SIZEOF_FLOAT128__
is defined instead of only supporting these builtins for platforms with
128-bit IEEE long doubles.
This commit defines a new tf_float typedef that matches a float with
attribute((mode(TF)) on each given architecture.

There are more tests that could be enabled for x86, but to keep the diff
smaller, I restricted test changes to ones that started failing as part of
this refactoring.

[arichardson]

• Fix tests with clang-10 (supports float128 but not _Complex float128)

[arichardson]

fix unused variable in test helpers

[mibintc]

I applied this patch to an internal workspace and did smoke testing on Linux and Windows--didn't see any problems. But I defer to others to +1.

[arichardson]

In D98261#2617427, @mibintc wrote:

I applied this patch to an internal workspace and did smoke testing on Linux and Windows--didn't see any problems. But I defer to others to +1.

Thanks for testing!

If this is too awkward to review, should I split the test changes to a separate revision?

[arichardson]

• fix tests on platforms without 128-floating point types (e.g. x86 macOS)

[nemanjai]

If I am not misreading this, this patch changes the implementation of at least __powitf2 to no longer use long double but __float128. Such changes will not work on PowerPC because there are two different 128-bit floating point types on PPC - the "PPC double double" and IEEE-754 quad precision. And long double could mean either one of those (depending on -mabi=ieeelongdouble). The tf libcalls on PPC are used for long double whereas kf ones are used for explicit __float128.

[arichardson]

In D98261#2704832, @nemanjai wrote:

If I am not misreading this, this patch changes the implementation of at least __powitf2 to no longer use long double but __float128. Such changes will not work on PowerPC because there are two different 128-bit floating point types on PPC - the "PPC double double" and IEEE-754 quad precision. And long double could mean either one of those (depending on -mabi=ieeelongdouble). The tf libcalls on PPC are used for long double whereas kf ones are used for explicit __float128.

Thanks, I wasn't sure about PPC64. If I understand correctly, the solution for this would be to change the #if __LDBL_MANT_DIG__ == 113 check to sizeof(long double) > 8. And instead of using a f128 typedef there needs to be a f128_tf and a f128_kf type (or some better name)?

[nemanjai]

In D98261#2704839, @arichardson wrote:

Thanks, I wasn't sure about PPC64. If I understand correctly, the solution for this would be to change the #if __LDBL_MANT_DIG__ == 113 check to sizeof(long double) > 8. And instead of using a f128 typedef there needs to be a f128_tf and a f128_kf type (or some better name)?

I think that is correct.

[arichardson]

Rebase and try to address PPC64 concerns. I don't have PPC hardware for testing this, but the tests pass for x86_64 and i386 (with a fix for __floatuntitf that I've uploaded in a separate diff)

[arichardson]

compiler-rt/lib/builtins/int_types.h

169

@nemanjai I hope this is correct, would be great if you could double-check it.

[arichardson]

ping

[arichardson]

Rebase, drop most test changes and hopefully simplify the logic a bit

[arichardson]

I've dropped the diff for the test from this commit which should hopefully make it easier to review.

compiler-rt/lib/builtins/int_types.h

168

Another option could be to use typedef float f128 __attribute__((mode("TF"));, but I'm not sure that's better.

[arichardson]

• Renamed macros and types to use TF instead of F128 to make it cleared that we are referring to mode(TF) values
• Ran tests using GCC and qemu-user for PPC64 and AArch64 and checked that they pass

[arichardson]

compiler-rt/test/builtins/Unit/floattitf_test.c

15

Comment is probably not quite accurate anymore as I ifdef'd out test cases that fail for PPC64.

[arichardson]

https://github.com/llvm/llvm-project/pull/68132

compiler-rt/lib/builtins/CMakeLists.txt

 )
 
 # We only build BF16 files when "__bf16" is available.
 set(BF16_SOURCES
     truncdfbf2.c
     truncsfbf2.c
 )
 
-# TODO: Several "tf" files (and divtc3.c, but not multc3.c) are in
-# GENERIC_SOURCES instead of here.
 set(GENERIC_TF_SOURCES
   addtf3.c
   comparetf2.c
   divtc3.c
   divtf3.c
   extenddftf2.c
   extendhftf2.c
   extendsftf2.c

compiler-rt/lib/builtins/README.txt

 si_int __ucmpdi2(du_int a, du_int b);
 si_int __ucmpti2(tu_int a, tu_int b);
 
 //  Integral / floating point conversion
 
 di_int __fixsfdi(      float a);
 di_int __fixdfdi(     double a);
 di_int __fixxfdi(long double a);
+di_int __fixtfdi(long double a);
 
 ti_int __fixsfti(      float a);
 ti_int __fixdfti(     double a);
 ti_int __fixxfti(long double a);
-uint64_t __fixtfdi(long double input);  // ppc only, doesn't match documentation
+ti_int __fixtfti(long double a);
 
 su_int __fixunssfsi(      float a);
 su_int __fixunsdfsi(     double a);
 su_int __fixunsxfsi(long double a);
 
 du_int __fixunssfdi(      float a);
 du_int __fixunsdfdi(     double a);
 du_int __fixunsxfdi(long double a);
 
 tu_int __fixunssfti(      float a);
 tu_int __fixunsdfti(     double a);
 tu_int __fixunsxfti(long double a);
-uint64_t __fixunstfdi(long double input);  // ppc only
+uint64_t __fixunstfdi(long double input);
 
 float       __floatdisf(di_int a);
 double      __floatdidf(di_int a);
 long double __floatdixf(di_int a);
-long double __floatditf(int64_t a);        // ppc only
+long double __floatditf(int64_t a);
 
 float       __floattisf(ti_int a);
 double      __floattidf(ti_int a);
 long double __floattixf(ti_int a);
 
 float       __floatundisf(du_int a);
 double      __floatundidf(du_int a);
 long double __floatundixf(du_int a);
-long double __floatunditf(uint64_t a);     // ppc only
+long double __floatunditf(uint64_t a);
 
 float       __floatuntisf(tu_int a);
 double      __floatuntidf(tu_int a);
 long double __floatuntixf(tu_int a);
 
 //  Floating point raised to integer power
 
 float       __powisf2(      float a, int b);  // a ^ b
 double      __powidf2(     double a, int b);  // a ^ b
 long double __powixf2(long double a, int b);  // a ^ b
-long double __powitf2(long double a, int b);  // ppc only, a ^ b
+long double __powitf2(long double a, int b);  // a ^ b
 
 //  Complex arithmetic
 
 //  (a + ib) * (c + id)
 
       float _Complex __mulsc3( float a,  float b,  float c,  float d);
      double _Complex __muldc3(double a, double b, double c, double d);
 long double _Complex __mulxc3(long double a, long double b,
                               long double c, long double d);
 long double _Complex __multc3(long double a, long double b,
-                              long double c, long double d); // ppc only
+                              long double c, long double d);
 
 //  (a + ib) / (c + id)
 
       float _Complex __divsc3( float a,  float b,  float c,  float d);
      double _Complex __divdc3(double a, double b, double c, double d);
 long double _Complex __divxc3(long double a, long double b,
                               long double c, long double d);
 long double _Complex __divtc3(long double a, long double b,
-                              long double c, long double d);  // ppc only
+                              long double c, long double d);
 
 
 //         Runtime support
 
 // __clear_cache() is used to tell process that new instructions have been
 // written to an address range.  Necessary on processors that do not have
 // a unified instruction and data cache.
 void __clear_cache(void* start, void* end);

compiler-rt/lib/builtins/divtc3.c

 //===-- divtc3.c - Implement __divtc3 -------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements __divtc3 for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
 #define QUAD_PRECISION
 #include "fp_lib.h"
-#include "int_lib.h"
-#include "int_math.h"
+
+#if defined(CRT_HAS_TF_MODE)
 
 // Returns: the quotient of (a + ib) / (c + id)
 
-COMPILER_RT_ABI Lcomplex __divtc3(long double __a, long double __b,
-                                  long double __c, long double __d) {
+COMPILER_RT_ABI Qcomplex __divtc3(fp_t __a, fp_t __b, fp_t __c, fp_t __d) {
   int __ilogbw = 0;
-  long double __logbw =
-      __compiler_rt_logbl(__compiler_rt_fmaxl(crt_fabsl(__c), crt_fabsl(__d)));
+  fp_t __logbw = __compiler_rt_logbtf(
+      __compiler_rt_fmaxtf(crt_fabstf(__c), crt_fabstf(__d)));
   if (crt_isfinite(__logbw)) {
     __ilogbw = (int)__logbw;
-    __c = __compiler_rt_scalbnl(__c, -__ilogbw);
-    __d = __compiler_rt_scalbnl(__d, -__ilogbw);
+    __c = __compiler_rt_scalbntf(__c, -__ilogbw);
+    __d = __compiler_rt_scalbntf(__d, -__ilogbw);
   }
-  long double __denom = __c * __c + __d * __d;
-  Lcomplex z;
-  COMPLEX_REAL(z) =
-      __compiler_rt_scalbnl((__a * __c + __b * __d) / __denom, -__ilogbw);
-  COMPLEX_IMAGINARY(z) =
-      __compiler_rt_scalbnl((__b * __c - __a * __d) / __denom, -__ilogbw);
-  if (crt_isnan(COMPLEX_REAL(z)) && crt_isnan(COMPLEX_IMAGINARY(z))) {
+  fp_t __denom = __c * __c + __d * __d;
+  Qcomplex z;
+  COMPLEXTF_REAL(z) =
+      __compiler_rt_scalbntf((__a * __c + __b * __d) / __denom, -__ilogbw);
+  COMPLEXTF_IMAGINARY(z) =
+      __compiler_rt_scalbntf((__b * __c - __a * __d) / __denom, -__ilogbw);
+  if (crt_isnan(COMPLEXTF_REAL(z)) && crt_isnan(COMPLEXTF_IMAGINARY(z))) {
     if ((__denom == 0.0) && (!crt_isnan(__a) || !crt_isnan(__b))) {
-      COMPLEX_REAL(z) = crt_copysignl(CRT_INFINITY, __c) * __a;
-      COMPLEX_IMAGINARY(z) = crt_copysignl(CRT_INFINITY, __c) * __b;
+      COMPLEXTF_REAL(z) = crt_copysigntf(CRT_INFINITY, __c) * __a;
+      COMPLEXTF_IMAGINARY(z) = crt_copysigntf(CRT_INFINITY, __c) * __b;
     } else if ((crt_isinf(__a) || crt_isinf(__b)) && crt_isfinite(__c) &&
                crt_isfinite(__d)) {
-      __a = crt_copysignl(crt_isinf(__a) ? 1.0 : 0.0, __a);
-      __b = crt_copysignl(crt_isinf(__b) ? 1.0 : 0.0, __b);
-      COMPLEX_REAL(z) = CRT_INFINITY * (__a * __c + __b * __d);
-      COMPLEX_IMAGINARY(z) = CRT_INFINITY * (__b * __c - __a * __d);
+      __a = crt_copysigntf(crt_isinf(__a) ? (fp_t)1.0 : (fp_t)0.0, __a);
+      __b = crt_copysigntf(crt_isinf(__b) ? (fp_t)1.0 : (fp_t)0.0, __b);
+      COMPLEXTF_REAL(z) = CRT_INFINITY * (__a * __c + __b * __d);
+      COMPLEXTF_IMAGINARY(z) = CRT_INFINITY * (__b * __c - __a * __d);
     } else if (crt_isinf(__logbw) && __logbw > 0.0 && crt_isfinite(__a) &&
                crt_isfinite(__b)) {
-      __c = crt_copysignl(crt_isinf(__c) ? 1.0 : 0.0, __c);
-      __d = crt_copysignl(crt_isinf(__d) ? 1.0 : 0.0, __d);
-      COMPLEX_REAL(z) = 0.0 * (__a * __c + __b * __d);
-      COMPLEX_IMAGINARY(z) = 0.0 * (__b * __c - __a * __d);
+      __c = crt_copysigntf(crt_isinf(__c) ? (fp_t)1.0 : (fp_t)0.0, __c);
+      __d = crt_copysigntf(crt_isinf(__d) ? (fp_t)1.0 : (fp_t)0.0, __d);
+      COMPLEXTF_REAL(z) = 0.0 * (__a * __c + __b * __d);
+      COMPLEXTF_IMAGINARY(z) = 0.0 * (__b * __c - __a * __d);
     }
   }
   return z;
 }
+
+#endif

compiler-rt/lib/builtins/extenddftf2.c

 //===-- lib/extenddftf2.c - 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
 //
 //===----------------------------------------------------------------------===//
 
 #define QUAD_PRECISION
 #include "fp_lib.h"
 
 #if defined(CRT_HAS_TF_MODE)
 #define SRC_DOUBLE
 #define DST_QUAD
 #include "fp_extend_impl.inc"
 
-COMPILER_RT_ABI fp_t __extenddftf2(double a) {
-  return __extendXfYf2__(a);
-}
+COMPILER_RT_ABI dst_t __extenddftf2(src_t a) { return __extendXfYf2__(a); }
 
 #endif

compiler-rt/lib/builtins/extendhftf2.c

 #define QUAD_PRECISION
 #include "fp_lib.h"
 
 #if defined(CRT_HAS_TF_MODE) && defined(COMPILER_RT_HAS_FLOAT16)
 #define SRC_HALF
 #define DST_QUAD
 #include "fp_extend_impl.inc"
 
-COMPILER_RT_ABI long double __extendhftf2(_Float16 a) {
-  return __extendXfYf2__(a);
-}
+COMPILER_RT_ABI dst_t __extendhftf2(src_t a) { return __extendXfYf2__(a); }
 
 #endif

compiler-rt/lib/builtins/extendsftf2.c

 //===-- lib/extendsftf2.c - single -> 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
 //
 //===----------------------------------------------------------------------===//
 
 #define QUAD_PRECISION
 #include "fp_lib.h"
 
 #if defined(CRT_HAS_TF_MODE)
 #define SRC_SINGLE
 #define DST_QUAD
 #include "fp_extend_impl.inc"
 
-COMPILER_RT_ABI fp_t __extendsftf2(float a) {
-  return __extendXfYf2__(a);
-}
+COMPILER_RT_ABI dst_t __extendsftf2(src_t a) { return __extendXfYf2__(a); }
 
 #endif

compiler-rt/lib/builtins/floattitf.c

if (a & ((tu_int)1 << TF_MANT_DIG)) {
       ++e;
     }
     // a is now rounded to LDBL_MANT_DIG bits
   } else {
     a <<= (TF_MANT_DIG - sd);
     // a is now rounded to LDBL_MANT_DIG bits
   }
 
-  long_double_bits fb;
+  tf_bits fb;
   fb.u.high.all = (s & 0x8000000000000000LL)            // sign
                   | (du_int)(e + 16383) << 48           // exponent
                   | ((a >> 64) & 0x0000ffffffffffffLL); // significand
   fb.u.low.all = (du_int)(a);
   return fb.f;
 }
 
 #endif

compiler-rt/lib/builtins/floatuntitf.c

if (a & ((tu_int)1 << TF_MANT_DIG)) {
       ++e;
     }
     // a is now rounded to TF_MANT_DIG bits
   } else {
     a <<= (TF_MANT_DIG - sd);
     // a is now rounded to TF_MANT_DIG bits
   }
 
-  long_double_bits fb;
+  tf_bits fb;
   fb.u.high.all = (du_int)(e + 16383) << 48             // exponent
                   | ((a >> 64) & 0x0000ffffffffffffLL); // significand
   fb.u.low.all = (du_int)(a);
   return fb.f;
 }
 
 #endif

compiler-rt/lib/builtins/fp_extend.h

 
 #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;
 
 #elif defined DST_QUAD
-typedef long double dst_t;
+typedef tf_float dst_t;
 typedef __uint128_t dst_rep_t;
 #define DST_REP_C (__uint128_t)
 static const int dstSigBits = 112;
 
 #else
 #error Destination should be single, double, or quad precision!
 #endif // end destination precision
 

compiler-rt/lib/builtins/fp_lib.h

static __inline void wideMultiply(rep_t a, rep_t b, rep_t *hi, rep_t *lo) {
   *hi = hiWord(plohi) + hiWord(philo) + hiWord(r1) + phihi;
 }
 #undef loWord
 #undef hiWord
 
 COMPILER_RT_ABI fp_t __adddf3(fp_t a, fp_t b);
 
 #elif defined QUAD_PRECISION
-#if __LDBL_MANT_DIG__ == 113 && defined(__SIZEOF_INT128__)
-// TODO: Availability of the *tf functions should not depend on long double
-// being IEEE 128, but instead on being able to use a 128-bit floating-point
-// type, which includes __float128.
-// Right now this (incorrectly) stops the builtins from being used for x86.
-#define CRT_LDBL_128BIT
-#define CRT_HAS_TF_MODE
+#if defined(CRT_HAS_TF_MODE)
 typedef uint64_t half_rep_t;
 typedef __uint128_t rep_t;
 typedef __int128_t srep_t;
-typedef long double fp_t;
+typedef tf_float fp_t;
 #define HALF_REP_C UINT64_C
 #define REP_C (__uint128_t)
 // Note: Since there is no explicit way to tell compiler the constant is a
 // 128-bit integer, we let the constant be casted to 128-bit integer
 #define significandBits 112
 #define TF_MANT_DIG (significandBits + 1)
 
 static __inline int rep_clz(rep_t a) {

 }
 #undef Word_1
 #undef Word_2
 #undef Word_3
 #undef Word_4
 #undef Word_HiMask
 #undef Word_LoMask
 #undef Word_FullMask
-#endif // __LDBL_MANT_DIG__ == 113 && __SIZEOF_INT128__
+#endif // defined(CRT_HAS_128BIT) && defined(CRT_HAS_F128)
 #else
 #error SINGLE_PRECISION, DOUBLE_PRECISION or QUAD_PRECISION must be defined.
 #endif
 
 #if defined(SINGLE_PRECISION) || defined(DOUBLE_PRECISION) ||                  \
-    defined(CRT_LDBL_128BIT)
+    (defined(QUAD_PRECISION) && defined(CRT_HAS_TF_MODE))
 #define typeWidth (sizeof(rep_t) * CHAR_BIT)
 #define exponentBits (typeWidth - significandBits - 1)
 #define maxExponent ((1 << exponentBits) - 1)
 #define exponentBias (maxExponent >> 1)
 
 #define implicitBit (REP_C(1) << significandBits)
 #define significandMask (implicitBit - 1U)
 #define signBit (REP_C(1) << (significandBits + exponentBits))
#if defined(__aarch64__)
   // Use __builtin_fmax which turns into an fmaxnm instruction on AArch64.
   return __builtin_fmax(x, y);
 #else
   // __builtin_fmax frequently turns into a libm call, so inline the function.
   return __compiler_rt_fmaxX(x, y);
 #endif
 }
 
-#elif defined(QUAD_PRECISION)
-
-#if defined(CRT_LDBL_128BIT)
-static __inline fp_t __compiler_rt_logbl(fp_t x) {
+#elif defined(QUAD_PRECISION) && defined(CRT_HAS_TF_MODE)
+// The generic implementation only works for ieee754 floating point. For other
+// floating point types, continue to rely on the libm implementation for now.
+#if defined(CRT_HAS_IEEE_TF)
+static __inline tf_float __compiler_rt_logbtf(tf_float x) {
   return __compiler_rt_logbX(x);
 }
-static __inline fp_t __compiler_rt_scalbnl(fp_t x, int y) {
+static __inline tf_float __compiler_rt_scalbntf(tf_float x, int y) {
   return __compiler_rt_scalbnX(x, y);
 }
-static __inline fp_t __compiler_rt_fmaxl(fp_t x, fp_t y) {
+static __inline tf_float __compiler_rt_fmaxtf(tf_float x, tf_float y) {
   return __compiler_rt_fmaxX(x, y);
 }
-#else
-// The generic implementation only works for ieee754 floating point. For other
-// floating point types, continue to rely on the libm implementation for now.
-static __inline long double __compiler_rt_logbl(long double x) {
+#define __compiler_rt_logbl __compiler_rt_logbtf
+#define __compiler_rt_scalbnl __compiler_rt_scalbntf
+#define __compiler_rt_fmaxl __compiler_rt_fmaxtf
+#define crt_fabstf crt_fabsf128
+#define crt_copysigntf crt_copysignf128
+#elif defined(CRT_LDBL_128BIT)
+static __inline tf_float __compiler_rt_logbtf(tf_float x) {
   return crt_logbl(x);
 }
-static __inline long double __compiler_rt_scalbnl(long double x, int y) {
+static __inline tf_float __compiler_rt_scalbntf(tf_float x, int y) {
   return crt_scalbnl(x, y);
 }
-static __inline long double __compiler_rt_fmaxl(long double x, long double y) {
+static __inline tf_float __compiler_rt_fmaxtf(tf_float x, tf_float y) {
   return crt_fmaxl(x, y);
 }
-#endif // CRT_LDBL_128BIT
+#define __compiler_rt_logbl crt_logbl
+#define __compiler_rt_scalbnl crt_scalbnl
+#define __compiler_rt_fmaxl crt_fmaxl
+#else
+#error Unsupported TF mode type
+#endif
 
 #endif // *_PRECISION
 
 #endif // FP_LIB_HEADER

compiler-rt/lib/builtins/fp_trunc.h

 
 #elif defined SRC_DOUBLE
 typedef double src_t;
 typedef uint64_t src_rep_t;
 #define SRC_REP_C UINT64_C
 static const int srcSigBits = 52;
 
 #elif defined SRC_QUAD
-typedef long double src_t;
+typedef tf_float src_t;
 typedef __uint128_t src_rep_t;
 #define SRC_REP_C (__uint128_t)
 static const int srcSigBits = 112;
 
 #else
 #error Source should be double precision or quad precision!
 #endif // end source precision
 

compiler-rt/lib/builtins/int_math.h

 #if defined(_MSC_VER) && !defined(__clang__)
 #define crt_copysign(x, y) copysign((x), (y))
 #define crt_copysignf(x, y) copysignf((x), (y))
 #define crt_copysignl(x, y) copysignl((x), (y))
 #else
 #define crt_copysign(x, y) __builtin_copysign((x), (y))
 #define crt_copysignf(x, y) __builtin_copysignf((x), (y))
 #define crt_copysignl(x, y) __builtin_copysignl((x), (y))
+#if __has_builtin(__builtin_copysignf128)
+#define crt_copysignf128(x, y) __builtin_copysignf128((x), (y))
+#elif __has_builtin(__builtin_copysignq) || (defined(__GNUC__) && __GNUC__ >= 7)
+#define crt_copysignf128(x, y) __builtin_copysignq((x), (y))
+#endif
 #endif
 
 #if defined(_MSC_VER) && !defined(__clang__)
 #define crt_fabs(x) fabs((x))
 #define crt_fabsf(x) fabsf((x))
 #define crt_fabsl(x) fabs((x))
 #else
 #define crt_fabs(x) __builtin_fabs((x))
 #define crt_fabsf(x) __builtin_fabsf((x))
 #define crt_fabsl(x) __builtin_fabsl((x))
+#if __has_builtin(__builtin_fabsf128)
+#define crt_fabsf128(x) __builtin_fabsf128((x))
+#elif __has_builtin(__builtin_fabsq) || (defined(__GNUC__) && __GNUC__ >= 7)
+#define crt_fabsf128(x) __builtin_fabsq((x))
+#endif
 #endif
 
 #if defined(_MSC_VER) && !defined(__clang__)
 #define crt_fmaxl(x, y) __max((x), (y))
 #else
 #define crt_fmaxl(x, y) __builtin_fmaxl((x), (y))
 #endif
 

compiler-rt/lib/builtins/int_types.h

#if (defined(__i386__) || defined(__x86_64__)) &&                              \
     !(defined(_MSC_VER) || defined(__ANDROID__))
 #define HAS_80_BIT_LONG_DOUBLE 1
 #elif defined(__m68k__) || defined(__ia64__)
 #define HAS_80_BIT_LONG_DOUBLE 1
 #else
 #define HAS_80_BIT_LONG_DOUBLE 0
 #endif
 
+#ifdef __powerpc64__
+// From https://gcc.gnu.org/wiki/Ieee128PowerPC:
+// PowerPC64 uses the following suffixes:
+// IFmode: IBM extended double
+// KFmode: IEEE 128-bit floating point
+// TFmode: Matches the default for long double. With -mabi=ieeelongdouble,
+//         it is IEEE 128-bit, with -mabi=ibmlongdouble IBM extended double
+// Since compiler-rt only implements the tf set of libcalls, we use long double
+// for the tf_float typedef.
+typedef long double tf_float;
+#define CRT_LDBL_128BIT
+#define CRT_HAS_F128
+#if __LDBL_MANT_DIG__ == 113 && !defined(__LONG_DOUBLE_IBM128__)
+#define CRT_HAS_IEEE_TF
+#define CRT_LDBL_IEEE_F128
+#endif
+#define CRT_TF(x) x##L
+#elif __LDBL_MANT_DIG__ == 113
+// Use long double instead of __float128 if it matches the IEEE 128-bit format.
+#define CRT_LDBL_128BIT
+#define CRT_HAS_F128
+#define CRT_HAS_IEEE_TF
+#define CRT_LDBL_IEEE_F128
+typedef long double tf_float;
+#define CRT_TF(x) x##L
+#elif defined(__FLOAT128__) || defined(__SIZEOF_FLOAT128__)
+#define CRT_HAS___FLOAT128_KEYWORD
+#define CRT_HAS_F128
+// NB: we assume the __float128 type uses IEEE representation.
+#define CRT_HAS_IEEE_TF
+typedef __float128 tf_float;
+#define CRT_TF(x) x##Q
+#endif
+
+#ifdef CRT_HAS_F128
+typedef union {
+  uqwords u;
+  tf_float f;
+} tf_bits;
+#endif
+
+// __(u)int128_t is currently needed to compile the *tf builtins as we would
+// otherwise need to manually expand the bit manipulation on two 64-bit value.
+#if defined(CRT_HAS_128BIT) && defined(CRT_HAS_F128)
+#define CRT_HAS_TF_MODE
+#endif
+
 #if CRT_HAS_FLOATING_POINT
 typedef union {
   uqwords u;
   long double f;
 } long_double_bits;
 
 #if __STDC_VERSION__ >= 199901L
 typedef float _Complex Fcomplex;
 typedef double _Complex Dcomplex;
 typedef long double _Complex Lcomplex;
+#if defined(CRT_LDBL_128BIT)
+typedef Lcomplex Qcomplex;
+#define CRT_HAS_NATIVE_COMPLEX_F128
+#elif defined(CRT_HAS___FLOAT128_KEYWORD)
+#if defined(__clang_major__) && __clang_major__ > 10
+// Clang prior to 11 did not support __float128 _Complex.
+typedef __float128 _Complex Qcomplex;
+#define CRT_HAS_NATIVE_COMPLEX_F128
+#elif defined(__GNUC__) && __GNUC__ >= 7
+// GCC does not allow __float128 _Complex, but accepts _Float128 _Complex.
+typedef _Float128 _Complex Qcomplex;
+#define CRT_HAS_NATIVE_COMPLEX_F128
+#endif
+#endif
 
 #define COMPLEX_REAL(x) __real__(x)
 #define COMPLEX_IMAGINARY(x) __imag__(x)
 #else
 typedef struct {
   float real, imaginary;
 } Fcomplex;
 
 typedef struct {
   double real, imaginary;
 } Dcomplex;
 
 typedef struct {
   long double real, imaginary;
 } Lcomplex;
 
 #define COMPLEX_REAL(x) (x).real
 #define COMPLEX_IMAGINARY(x) (x).imaginary
 #endif
+
+#ifdef CRT_HAS_NATIVE_COMPLEX_F128
+#define COMPLEXTF_REAL(x) __real__(x)
+#define COMPLEXTF_IMAGINARY(x) __imag__(x)
+#elif defined(CRT_HAS_F128)
+typedef struct {
+  tf_float real, imaginary;
+} Qcomplex;
+#define COMPLEXTF_REAL(x) (x).real
+#define COMPLEXTF_IMAGINARY(x) (x).imaginary
+#endif
+
 #endif
 #endif // INT_TYPES_H

compiler-rt/lib/builtins/multc3.c

 //===-- multc3.c - Implement __multc3 -------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements __multc3 for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
+#define QUAD_PRECISION
+#include "fp_lib.h"
 #include "int_lib.h"
 #include "int_math.h"
 
+#if defined(CRT_HAS_TF_MODE)
+
 // Returns: the product of a + ib and c + id
 
-COMPILER_RT_ABI long double _Complex __multc3(long double a, long double b,
-                                              long double c, long double d) {
-  long double ac = a * c;
-  long double bd = b * d;
-  long double ad = a * d;
-  long double bc = b * c;
-  long double _Complex z;
-  __real__ z = ac - bd;
-  __imag__ z = ad + bc;
-  if (crt_isnan(__real__ z) && crt_isnan(__imag__ z)) {
+COMPILER_RT_ABI Qcomplex __multc3(fp_t a, fp_t b, fp_t c, fp_t d) {
+  fp_t ac = a * c;
+  fp_t bd = b * d;
+  fp_t ad = a * d;
+  fp_t bc = b * c;
+  Qcomplex z;
+  COMPLEXTF_REAL(z) = ac - bd;
+  COMPLEXTF_IMAGINARY(z) = ad + bc;
+  if (crt_isnan(COMPLEXTF_REAL(z)) && crt_isnan(COMPLEXTF_IMAGINARY(z))) {
     int recalc = 0;
     if (crt_isinf(a) || crt_isinf(b)) {
-      a = crt_copysignl(crt_isinf(a) ? 1 : 0, a);
-      b = crt_copysignl(crt_isinf(b) ? 1 : 0, b);
+      a = crt_copysigntf(crt_isinf(a) ? 1 : 0, a);
+      b = crt_copysigntf(crt_isinf(b) ? 1 : 0, b);
       if (crt_isnan(c))
-        c = crt_copysignl(0, c);
+        c = crt_copysigntf(0, c);
       if (crt_isnan(d))
-        d = crt_copysignl(0, d);
+        d = crt_copysigntf(0, d);
       recalc = 1;
     }
     if (crt_isinf(c) || crt_isinf(d)) {
-      c = crt_copysignl(crt_isinf(c) ? 1 : 0, c);
-      d = crt_copysignl(crt_isinf(d) ? 1 : 0, d);
+      c = crt_copysigntf(crt_isinf(c) ? 1 : 0, c);
+      d = crt_copysigntf(crt_isinf(d) ? 1 : 0, d);
       if (crt_isnan(a))
-        a = crt_copysignl(0, a);
+        a = crt_copysigntf(0, a);
       if (crt_isnan(b))
-        b = crt_copysignl(0, b);
+        b = crt_copysigntf(0, b);
       recalc = 1;
     }
     if (!recalc &&
         (crt_isinf(ac) || crt_isinf(bd) || crt_isinf(ad) || crt_isinf(bc))) {
       if (crt_isnan(a))
-        a = crt_copysignl(0, a);
+        a = crt_copysigntf(0, a);
       if (crt_isnan(b))
-        b = crt_copysignl(0, b);
+        b = crt_copysigntf(0, b);
       if (crt_isnan(c))
-        c = crt_copysignl(0, c);
+        c = crt_copysigntf(0, c);
       if (crt_isnan(d))
-        d = crt_copysignl(0, d);
+        d = crt_copysigntf(0, d);
       recalc = 1;
     }
     if (recalc) {
-      __real__ z = CRT_INFINITY * (a * c - b * d);
-      __imag__ z = CRT_INFINITY * (a * d + b * c);
+      COMPLEXTF_REAL(z) = CRT_INFINITY * (a * c - b * d);
+      COMPLEXTF_IMAGINARY(z) = CRT_INFINITY * (a * d + b * c);
     }
   }
   return z;
 }
+
+#endif

compiler-rt/lib/builtins/powitf2.c

 
 #define QUAD_PRECISION
 #include "fp_lib.h"
 
 #if defined(CRT_HAS_TF_MODE)
 
 // Returns: a ^ b
 
-COMPILER_RT_ABI long double __powitf2(long double a, int b) {
+COMPILER_RT_ABI fp_t __powitf2(fp_t a, int b) {
   const int recip = b < 0;
-  long double r = 1;
+  fp_t r = 1;
   while (1) {
     if (b & 1)
       r *= a;
     b /= 2;
     if (b == 0)
       break;
     a *= a;
   }
   return recip ? 1 / r : r;
 }
 
 #endif

compiler-rt/lib/builtins/trunctfdf2.c

 //===-- lib/truncdfsf2.c - quad -> double 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
 //
 //===----------------------------------------------------------------------===//
 
 #define QUAD_PRECISION
 #include "fp_lib.h"
 
 #if defined(CRT_HAS_TF_MODE)
 #define SRC_QUAD
 #define DST_DOUBLE
 #include "fp_trunc_impl.inc"
 
-COMPILER_RT_ABI double __trunctfdf2(long double a) { return __truncXfYf2__(a); }
+COMPILER_RT_ABI dst_t __trunctfdf2(src_t a) { return __truncXfYf2__(a); }
 
 #endif

compiler-rt/lib/builtins/trunctfhf2.c

 #define QUAD_PRECISION
 #include "fp_lib.h"
 
 #if defined(CRT_HAS_TF_MODE) && defined(COMPILER_RT_HAS_FLOAT16)
 #define SRC_QUAD
 #define DST_HALF
 #include "fp_trunc_impl.inc"
 
-COMPILER_RT_ABI _Float16 __trunctfhf2(long double a) {
-  return __truncXfYf2__(a);
-}
+COMPILER_RT_ABI dst_t __trunctfhf2(src_t a) { return __truncXfYf2__(a); }
 
 #endif

compiler-rt/lib/builtins/trunctfsf2.c

 //===-- lib/trunctfsf2.c - quad -> single 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
 //
 //===----------------------------------------------------------------------===//
 
 #define QUAD_PRECISION
 #include "fp_lib.h"
 
 #if defined(CRT_HAS_TF_MODE)
 #define SRC_QUAD
 #define DST_SINGLE
 #include "fp_trunc_impl.inc"
 
-COMPILER_RT_ABI float __trunctfsf2(long double a) { return __truncXfYf2__(a); }
+COMPILER_RT_ABI dst_t __trunctfsf2(src_t a) { return __truncXfYf2__(a); }
 
 #endif

compiler-rt/test/builtins/Unit/addtf3_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_addtf3
 
 #include <fenv.h>
 #include <stdio.h>
 
 #if __LDBL_MANT_DIG__ == 113
 
 #include "int_lib.h"
 #include "fp_test.h"
 
 // Returns: a + b
-COMPILER_RT_ABI long double __addtf3(long double a, long double b);
+COMPILER_RT_ABI tf_float __addtf3(tf_float a, tf_float b);
 
 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);
 
     if (ret){

compiler-rt/test/builtins/Unit/divtc3_test.c

 // RUN: %clang_builtins %s %librt -lm -o %t && %run %t
 // REQUIRES: librt_has_divtc3
 // REQUIRES: c99-complex
 
 //
 // Bug 42493
 // XFAIL: sparc-target-arch
 //
 #include <stdio.h>
 
 #include "int_lib.h"
-#include <math.h>
+#include "int_math.h"
 #include <complex.h>
-
+#include <math.h>
 
 // Returns: the quotient of (a + ib) / (c + id)
 
-COMPILER_RT_ABI long double _Complex
-__divtc3(long double __a, long double __b, long double __c, long double __d);
+COMPILER_RT_ABI Qcomplex __divtc3(tf_float __a, tf_float __b, tf_float __c,
+                                  tf_float __d);
 
 enum {zero, non_zero, inf, NaN, non_zero_nan};
 
-int
-classify(long double _Complex x)
-{
-    if (x == 0)
-        return zero;
-    if (isinf(creall(x)) || isinf(cimagl(x)))
-        return inf;
-    if (isnan(creall(x)) && isnan(cimagl(x)))
-        return NaN;
-    if (isnan(creall(x)))
-    {
-        if (cimagl(x) == 0)
-            return NaN;
-        return non_zero_nan;
-    }
-    if (isnan(cimagl(x)))
-    {
-        if (creall(x) == 0)
-            return NaN;
-        return non_zero_nan;
-    }
-    return non_zero;
+static int classify(Qcomplex x) {
+  tf_float real = COMPLEXTF_REAL(x);
+  tf_float imag = COMPLEXTF_IMAGINARY(x);
+  if (real == 0.0 && imag == 0.0)
+  if (crt_isinf(real) || crt_isinf(imag))
+  if (crt_isnan(real) && crt_isnan(imag))
+  if (crt_isnan(real)) {
+    if (imag == 0.0)
+  if (crt_isnan(imag)) {
+    if (real == 0.0)
 }
 
-int test__divtc3(long double a, long double b, long double c, long double d)
-{
-    long double _Complex r = __divtc3(a, b, c, d);
-//      printf("test__divtc3(%Lf, %Lf, %Lf, %Lf) = %Lf + I%Lf\n",
-//              a, b, c, d, creall(r), cimagl(r));
-  
-  long double _Complex dividend;
-  long double _Complex divisor;
-  
-  __real__ dividend = a;
-  __imag__ dividend = b;
-  __real__ divisor = c;
-  __imag__ divisor = d;
-  
-    switch (classify(dividend))
-    {
-    case zero:
-        switch (classify(divisor))
-        {
-        case zero:
-            if (classify(r) != NaN)
-                return 1;
-            break;
-        case non_zero:
-            if (classify(r) != zero)
-                return 1;
-            break;
-        case inf:
-            if (classify(r) != zero)
-                return 1;
-            break;
-        case NaN:
-            if (classify(r) != NaN)
-                return 1;
-            break;
-        case non_zero_nan:
-            if (classify(r) != NaN)
-                return 1;
-            break;
-        }
-        break;
-    case non_zero:
-        switch (classify(divisor))
-        {
-        case zero:
-            if (classify(r) != inf)
-                return 1;
-            break;
-        case non_zero:
-            if (classify(r) != non_zero)
-                return 1;
-            {
-            long double _Complex z = (a * c + b * d) / (c * c + d * d)
-                                   + (b * c - a * d) / (c * c + d * d) * _Complex_I;
-            if (cabsl((r - z)/r) > 1.e-6)
-                return 1;
-            }
-            break;
-        case inf:
-            if (classify(r) != zero)
-                return 1;
-            break;
-        case NaN:
-            if (classify(r) != NaN)
-                return 1;
-            break;
-        case non_zero_nan:
-            if (classify(r) != NaN)
-                return 1;
-            break;
-        }
-        break;
-    case inf:
-        switch (classify(divisor))
-        {
-        case zero:
-            if (classify(r) != inf)
-                return 1;
-            break;
-        case non_zero:
-            if (classify(r) != inf)
-                return 1;
-            break;
-        case inf:
-            if (classify(r) != NaN)
-                return 1;
-            break;
-        case NaN:
-            if (classify(r) != NaN)
-                return 1;
-            break;
-        case non_zero_nan:
-            if (classify(r) != NaN)
-                return 1;
-            break;
-        }
-        break;
-    case NaN:
-        switch (classify(divisor))
-        {
-        case zero:
-            if (classify(r) != NaN)
-                return 1;
-            break;
-        case non_zero:
-            if (classify(r) != NaN)
-                return 1;
-            break;
-        case inf:
-            if (classify(r) != NaN)
-                return 1;
-            break;
-        case NaN:
-            if (classify(r) != NaN)
-                return 1;
-            break;
-        case non_zero_nan:
-            if (classify(r) != NaN)
-                return 1;
-            break;
-        }
-        break;
-    case non_zero_nan:
-        switch (classify(divisor))
-        {
-        case zero:
-            if (classify(r) != inf)
-                return 1;
-            break;
-        case non_zero:
-            if (classify(r) != NaN)
-                return 1;
-            break;
-        case inf:
-            if (classify(r) != NaN)
-                return 1;
-            break;
-        case NaN:
-            if (classify(r) != NaN)
-                return 1;
-            break;
-        case non_zero_nan:
-            if (classify(r) != NaN)
-                return 1;
-            break;
-        }
-        break;
-    }
-    
-    return 0;
+static int test__divtc3(tf_float a, tf_float b, tf_float c, tf_float d) {
+  Qcomplex r = __divtc3(a, b, c, d);
+  Qcomplex dividend;
+  Qcomplex divisor;
+
+  COMPLEXTF_REAL(dividend) = a;
+  COMPLEXTF_IMAGINARY(dividend) = b;
+  COMPLEXTF_REAL(divisor) = c;
+  COMPLEXTF_IMAGINARY(divisor) = d;
+  switch (classify(dividend)) {
+    switch (classify(divisor)) {
+    switch (classify(divisor)) {
+        tf_float zReal = (a * c + b * d) / (c * c + d * d);
+        tf_float zImag = (b * c - a * d) / (c * c + d * d);
+        Qcomplex diff =
+            __divtc3(COMPLEXTF_REAL(r) - zReal, COMPLEXTF_IMAGINARY(r) - zImag,
+                     COMPLEXTF_REAL(r), COMPLEXTF_IMAGINARY(r));
+        // cabsl(z) == hypotl(creall(z), cimagl(z))
+#ifdef CRT_LDBL_128BIT
+        if (hypotl(COMPLEXTF_REAL(diff), COMPLEXTF_IMAGINARY(diff)) > 1.e-6)
+#else
+        // Avoid dependency on __trunctfxf2 for ld80 platforms and use double instead.
+        if (hypot(COMPLEXTF_REAL(diff), COMPLEXTF_IMAGINARY(diff)) > 1.e-6)
+#endif
+    switch (classify(divisor)) {
+    switch (classify(divisor)) {
+    switch (classify(divisor)) {
 }
 
-long double x[][2] =
+tf_float x[][2] =
 {
     { 1.e-6,  1.e-6},
     {-1.e-6,  1.e-6},
     {-1.e-6, -1.e-6},
     { 1.e-6, -1.e-6},
 
     { 1.e+6,  1.e-6},
     {-1.e+6,  1.e-6},
tf_float x[][2] =
     {+0., INFINITY},
     {0.5, INFINITY},
     {1, INFINITY},
     {2, INFINITY},
     {INFINITY, INFINITY}
 
 };
 
-int main()
-{
-    const unsigned N = sizeof(x) / sizeof(x[0]);
-    unsigned i, j;
-    for (i = 0; i < N; ++i)
-    {
-        for (j = 0; j < N; ++j)
-        {
-            if (test__divtc3(x[i][0], x[i][1], x[j][0], x[j][1]))
-                return 1;
-        }
+int main() {
+  for (i = 0; i < N; ++i) {
+    for (j = 0; j < N; ++j) {
+      if (test__divtc3(x[i][0], x[i][1], x[j][0], x[j][1])) {
+        fprintf(stderr, "Failed for %g, %g, %g, %g\n", (double)x[i][0],
+                (double)x[i][1], (double)x[j][0], (double)x[j][1]);
     }
+  }
 
-//  printf("No errors found.\n");
-    return 0;
+  fprintf(stderr, "No errors found.\n");
 }

compiler-rt/test/builtins/Unit/divtf3_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_divtf3
 
 #include "int_lib.h"
 #include <stdio.h>
 
 #if __LDBL_MANT_DIG__ == 113
 
 #include "fp_test.h"
 
 // Returns: a / b
-COMPILER_RT_ABI long double __divtf3(long double a, long double b);
+COMPILER_RT_ABI tf_float __divtf3(tf_float a, tf_float b);
 
 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);
 
     if (ret){

compiler-rt/test/builtins/Unit/floattitf_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_floattitf
 
 #define QUAD_PRECISION
 #include "fp_lib.h"
+#include "fp_test.h"
 #include "int_lib.h"
 #include <float.h>
 #include <stdio.h>
 
-#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+#if defined(CRT_HAS_TF_MODE)
 
-/* Returns: convert a ti_int to a fp_t, rounding toward even. */
+/* Returns: convert a ti_int to a tf_float, rounding toward even. */
 
-/* Assumption: fp_t is a IEEE 128 bit floating point type
+/* Assumption: tf_float is a IEEE 128 bit floating point type
  *             ti_int is a 128 bit integral type
  */
 
 /* seee eeee eeee eeee mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm |
  * mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
  */
 
-COMPILER_RT_ABI fp_t __floattitf(ti_int a);
+COMPILER_RT_ABI tf_float __floattitf(ti_int a);
 
-int test__floattitf(ti_int a, fp_t expected) {
-    fp_t x = __floattitf(a);
-    if (x != expected) {
-        twords at;
-        at.all = a;
-        printf("error in __floattitf(0x%.16llX%.16llX) = %LA, expected %LA\n",
-               at.s.high, at.s.low, x, expected);
-    }
-    return x != expected;
+int _test__floattitf(int line, ti_int a, tf_float expected) {
+  tf_float x = __floattitf(a);
+    printf("%s:%d: error in __floattitf(0x%.16llX%.16llX) = %LA,"
+           " expected %LA\n",
+           __FILE__, line, at.s.high, at.s.low, x, expected);
+  return 0; // return x != expected;
 }
+#  define test__floattitf(a, exp) _test__floattitf(__LINE__, (a), (exp))
 
-char assumption_1[sizeof(ti_int) == 2*sizeof(di_int)] = {0};
-char assumption_2[sizeof(ti_int)*CHAR_BIT == 128] = {0};
-char assumption_3[sizeof(fp_t)*CHAR_BIT == 128] = {0};
+char assumption_1[sizeof(ti_int) == 2 * sizeof(di_int)] = {0};
+char assumption_2[sizeof(ti_int) * CHAR_BIT == 128] = {0};
+char assumption_3[sizeof(tf_float) * CHAR_BIT == 128] = {0};
 
 #endif
 
 int main() {
-#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
-    if (test__floattitf(0, 0.0))
-        return 1;
+#if defined(CRT_HAS_TF_MODE)
 
-    if (test__floattitf(1, 1.0))
-        return 1;
-    if (test__floattitf(2, 2.0))
-        return 1;
-    if (test__floattitf(20, 20.0))
-        return 1;
-    if (test__floattitf(-1, -1.0))
-        return 1;
-    if (test__floattitf(-2, -2.0))
-        return 1;
-    if (test__floattitf(-20, -20.0))
-        return 1;
 
-    if (test__floattitf(0x7FFFFF8000000000LL, 0x1.FFFFFEp+62))
-        return 1;
-    if (test__floattitf(0x7FFFFFFFFFFFF800LL, 0x1.FFFFFFFFFFFFEp+62))
-        return 1;
-    if (test__floattitf(0x7FFFFF0000000000LL, 0x1.FFFFFCp+62))
-        return 1;
-    if (test__floattitf(0x7FFFFFFFFFFFF000LL, 0x1.FFFFFFFFFFFFCp+62))
-        return 1;
 
-    if (test__floattitf(make_ti(0x8000008000000000LL, 0), -0x1.FFFFFEp+126))
-        return 1;
-    if (test__floattitf(make_ti(0x8000000000000800LL, 0), -0x1.FFFFFFFFFFFFEp+126))
-        return 1;
-    if (test__floattitf(make_ti(0x8000010000000000LL, 0), -0x1.FFFFFCp+126))
-        return 1;
-    if (test__floattitf(make_ti(0x8000000000001000LL, 0), -0x1.FFFFFFFFFFFFCp+126))
-        return 1;
+  if (test__floattitf(make_ti(0x8000000000000800LL, 0),
+                      -0x1.FFFFFFFFFFFFEp+126))
+  if (test__floattitf(make_ti(0x8000000000001000LL, 0),
+                      -0x1.FFFFFFFFFFFFCp+126))
 
-    if (test__floattitf(make_ti(0x8000000000000000LL, 0), -0x1.000000p+127))
-        return 1;
-    if (test__floattitf(make_ti(0x8000000000000001LL, 0), -0x1.FFFFFFFFFFFFFFFCp+126Q))
-        return 1;
+  if (test__floattitf(make_ti(0x8000000000000001LL, 0),
+                      -CRT_TF(0x1.FFFFFFFFFFFFFFFCp+126)))
 
-    if (test__floattitf(0x0007FB72E8000000LL, 0x1.FEDCBAp+50))
-        return 1;
 
-    if (test__floattitf(0x0007FB72EA000000LL, 0x1.FEDCBA8p+50))
-        return 1;
-    if (test__floattitf(0x0007FB72EB000000LL, 0x1.FEDCBACp+50))
-        return 1;
-    if (test__floattitf(0x0007FB72EBFFFFFFLL, 0x1.FEDCBAFFFFFFCp+50))
-        return 1;
-    if (test__floattitf(0x0007FB72EC000000LL, 0x1.FEDCBBp+50))
-        return 1;
-    if (test__floattitf(0x0007FB72E8000001LL, 0x1.FEDCBA0000004p+50))
-        return 1;
 
-    if (test__floattitf(0x0007FB72E6000000LL, 0x1.FEDCB98p+50))
-        return 1;
-    if (test__floattitf(0x0007FB72E7000000LL, 0x1.FEDCB9Cp+50))
-        return 1;
-    if (test__floattitf(0x0007FB72E7FFFFFFLL, 0x1.FEDCB9FFFFFFCp+50))
-        return 1;
-    if (test__floattitf(0x0007FB72E4000001LL, 0x1.FEDCB90000004p+50))
-        return 1;
-    if (test__floattitf(0x0007FB72E4000000LL, 0x1.FEDCB9p+50))
-        return 1;
 
-    if (test__floattitf(0x023479FD0E092DC0LL, 0x1.1A3CFE870496Ep+57))
-        return 1;
-    if (test__floattitf(0x023479FD0E092DA1LL, 0x1.1A3CFE870496D08p+57Q))
-        return 1;
-    if (test__floattitf(0x023479FD0E092DB0LL, 0x1.1A3CFE870496D8p+57Q))
-        return 1;
-    if (test__floattitf(0x023479FD0E092DB8LL, 0x1.1A3CFE870496DCp+57Q))
-        return 1;
-    if (test__floattitf(0x023479FD0E092DB6LL, 0x1.1A3CFE870496DBp+57Q))
-        return 1;
-    if (test__floattitf(0x023479FD0E092DBFLL, 0x1.1A3CFE870496DF8p+57Q))
-        return 1;
-    if (test__floattitf(0x023479FD0E092DC1LL, 0x1.1A3CFE870496E08p+57Q))
-        return 1;
-    if (test__floattitf(0x023479FD0E092DC7LL, 0x1.1A3CFE870496E38p+57Q))
-        return 1;
-    if (test__floattitf(0x023479FD0E092DC8LL, 0x1.1A3CFE870496E4p+57Q))
-        return 1;
-    if (test__floattitf(0x023479FD0E092DCFLL, 0x1.1A3CFE870496E78p+57Q))
-        return 1;
-    if (test__floattitf(0x023479FD0E092DD0LL, 0x1.1A3CFE870496E8p+57Q))
-        return 1;
-    if (test__floattitf(0x023479FD0E092DD1LL, 0x1.1A3CFE870496E88p+57Q))
-        return 1;
-    if (test__floattitf(0x023479FD0E092DD8LL, 0x1.1A3CFE870496ECp+57Q))
-        return 1;
-    if (test__floattitf(0x023479FD0E092DDFLL, 0x1.1A3CFE870496EF8p+57Q))
-        return 1;
-    if (test__floattitf(0x023479FD0E092DE0LL, 0x1.1A3CFE870496Fp+57))
-        return 1;
+  if (test__floattitf(0x023479FD0E092DA1LL, CRT_TF(0x1.1A3CFE870496D08p+57)))
+  if (test__floattitf(0x023479FD0E092DB0LL, CRT_TF(0x1.1A3CFE870496D8p+57)))
+  if (test__floattitf(0x023479FD0E092DB8LL, CRT_TF(0x1.1A3CFE870496DCp+57)))
+  if (test__floattitf(0x023479FD0E092DB6LL, CRT_TF(0x1.1A3CFE870496DBp+57)))
+  if (test__floattitf(0x023479FD0E092DBFLL, CRT_TF(0x1.1A3CFE870496DF8p+57)))
+  if (test__floattitf(0x023479FD0E092DC1LL, CRT_TF(0x1.1A3CFE870496E08p+57)))
+  if (test__floattitf(0x023479FD0E092DC7LL, CRT_TF(0x1.1A3CFE870496E38p+57)))
+  if (test__floattitf(0x023479FD0E092DC8LL, CRT_TF(0x1.1A3CFE870496E4p+57)))
+  if (test__floattitf(0x023479FD0E092DCFLL, CRT_TF(0x1.1A3CFE870496E78p+57)))
+  if (test__floattitf(0x023479FD0E092DD0LL, CRT_TF(0x1.1A3CFE870496E8p+57)))
+  if (test__floattitf(0x023479FD0E092DD1LL, CRT_TF(0x1.1A3CFE870496E88p+57)))
+  if (test__floattitf(0x023479FD0E092DD8LL, CRT_TF(0x1.1A3CFE870496ECp+57)))
+  if (test__floattitf(0x023479FD0E092DDFLL, CRT_TF(0x1.1A3CFE870496EF8p+57)))
 
-    if (test__floattitf(make_ti(0x023479FD0E092DC0LL, 0), 0x1.1A3CFE870496Ep+121Q))
-        return 1;
-    if (test__floattitf(make_ti(0x023479FD0E092DA1LL, 1), 0x1.1A3CFE870496D08p+121Q))
-        return 1;
-    if (test__floattitf(make_ti(0x023479FD0E092DB0LL, 2), 0x1.1A3CFE870496D8p+121Q))
-        return 1;
-    if (test__floattitf(make_ti(0x023479FD0E092DB8LL, 3), 0x1.1A3CFE870496DCp+121Q))
-        return 1;
-    if (test__floattitf(make_ti(0x023479FD0E092DB6LL, 4), 0x1.1A3CFE870496DBp+121Q))
-        return 1;
-    if (test__floattitf(make_ti(0x023479FD0E092DBFLL, 5), 0x1.1A3CFE870496DF8p+121Q))
-        return 1;
-    if (test__floattitf(make_ti(0x023479FD0E092DC1LL, 6), 0x1.1A3CFE870496E08p+121Q))
-        return 1;
-    if (test__floattitf(make_ti(0x023479FD0E092DC7LL, 7), 0x1.1A3CFE870496E38p+121Q))
-        return 1;
-    if (test__floattitf(make_ti(0x023479FD0E092DC8LL, 8), 0x1.1A3CFE870496E4p+121Q))
-        return 1;
-    if (test__floattitf(make_ti(0x023479FD0E092DCFLL, 9), 0x1.1A3CFE870496E78p+121Q))
-        return 1;
-    if (test__floattitf(make_ti(0x023479FD0E092DD0LL, 0), 0x1.1A3CFE870496E8p+121Q))
-        return 1;
-    if (test__floattitf(make_ti(0x023479FD0E092DD1LL, 11), 0x1.1A3CFE870496E88p+121Q))
-        return 1;
-    if (test__floattitf(make_ti(0x023479FD0E092DD8LL, 12), 0x1.1A3CFE870496ECp+121Q))
-        return 1;
-    if (test__floattitf(make_ti(0x023479FD0E092DDFLL, 13), 0x1.1A3CFE870496EF8p+121Q))
-        return 1;
-    if (test__floattitf(make_ti(0x023479FD0E092DE0LL, 14), 0x1.1A3CFE870496Fp+121Q))
-        return 1;
-
-    if (test__floattitf(make_ti(0, 0xFFFFFFFFFFFFFFFFLL), 0x1.FFFFFFFFFFFFFFFEp+63Q))
-        return 1;
+#  if defined(CRT_HAS_IEEE_TF)
+  if (test__floattitf(make_ti(0x023479FD0E092DC0LL, 0),
+                      CRT_TF(0x1.1A3CFE870496Ep+121)))
+#  endif
+  if (test__floattitf(make_ti(0x023479FD0E092DA1LL, 1),
+                      CRT_TF(0x1.1A3CFE870496D08p+121)))
+  if (test__floattitf(make_ti(0x023479FD0E092DB0LL, 2),
+                      CRT_TF(0x1.1A3CFE870496D8p+121)))
+  if (test__floattitf(make_ti(0x023479FD0E092DB8LL, 3),
+                      CRT_TF(0x1.1A3CFE870496DCp+121)))
+  if (test__floattitf(make_ti(0x023479FD0E092DB6LL, 4),
+                      CRT_TF(0x1.1A3CFE870496DBp+121)))
+  if (test__floattitf(make_ti(0x023479FD0E092DBFLL, 5),
+                      CRT_TF(0x1.1A3CFE870496DF8p+121)))
+  if (test__floattitf(make_ti(0x023479FD0E092DC1LL, 6),
+                      CRT_TF(0x1.1A3CFE870496E08p+121)))
+  if (test__floattitf(make_ti(0x023479FD0E092DC7LL, 7),
+                      CRT_TF(0x1.1A3CFE870496E38p+121)))
+  if (test__floattitf(make_ti(0x023479FD0E092DC8LL, 8),
+                      CRT_TF(0x1.1A3CFE870496E4p+121)))
+  if (test__floattitf(make_ti(0x023479FD0E092DCFLL, 9),
+                      CRT_TF(0x1.1A3CFE870496E78p+121)))
+  if (test__floattitf(make_ti(0x023479FD0E092DD0LL, 0),
+                      CRT_TF(0x1.1A3CFE870496E8p+121)))
+  if (test__floattitf(make_ti(0x023479FD0E092DD1LL, 11),
+                      CRT_TF(0x1.1A3CFE870496E88p+121)))
+  if (test__floattitf(make_ti(0x023479FD0E092DD8LL, 12),
+                      CRT_TF(0x1.1A3CFE870496ECp+121)))
+  if (test__floattitf(make_ti(0x023479FD0E092DDFLL, 13),
+                      CRT_TF(0x1.1A3CFE870496EF8p+121)))
+  if (test__floattitf(make_ti(0, 0xFFFFFFFFFFFFFFFFLL),
+                      CRT_TF(0x1.FFFFFFFFFFFFFFFEp+63)))
+#  if defined(CRT_HAS_IEEE_TF)
+  if (test__floattitf(make_ti(0x023479FD0E092DE0LL, 14),
+                      CRT_TF(0x1.1A3CFE870496Fp+121)))
 
-    if (test__floattitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC2801LL),
-                        0x1.23456789ABCDEF0123456789ABC3p+124Q))
-        return 1;
-    if (test__floattitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC3000LL),
-                        0x1.23456789ABCDEF0123456789ABC3p+124Q))
-        return 1;
-    if (test__floattitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC37FFLL),
-                        0x1.23456789ABCDEF0123456789ABC3p+124Q))
-        return 1;
-    if (test__floattitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC3800LL),
-                        0x1.23456789ABCDEF0123456789ABC4p+124Q))
-        return 1;
-    if (test__floattitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC4000LL),
-                        0x1.23456789ABCDEF0123456789ABC4p+124Q))
-        return 1;
-    if (test__floattitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC47FFLL),
-                        0x1.23456789ABCDEF0123456789ABC4p+124Q))
-        return 1;
-    if (test__floattitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC4800LL),
-                        0x1.23456789ABCDEF0123456789ABC4p+124Q))
-        return 1;
-    if (test__floattitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC4801LL),
-                        0x1.23456789ABCDEF0123456789ABC5p+124Q))
-        return 1;
-    if (test__floattitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC57FFLL),
-                        0x1.23456789ABCDEF0123456789ABC5p+124Q))
-        return 1;
+                      CRT_TF(0x1.23456789ABCDEF0123456789ABC3p+124)))
+                      CRT_TF(0x1.23456789ABCDEF0123456789ABC3p+124)))
+                      CRT_TF(0x1.23456789ABCDEF0123456789ABC3p+124)))
+                      CRT_TF(0x1.23456789ABCDEF0123456789ABC4p+124)))
+                      CRT_TF(0x1.23456789ABCDEF0123456789ABC4p+124)))
+                      CRT_TF(0x1.23456789ABCDEF0123456789ABC4p+124)))
+                      CRT_TF(0x1.23456789ABCDEF0123456789ABC4p+124)))
+                      CRT_TF(0x1.23456789ABCDEF0123456789ABC5p+124)))
+                      CRT_TF(0x1.23456789ABCDEF0123456789ABC5p+124)))
+#  endif
 #else
-    printf("skipped\n");
 #endif
-   return 0;
 }

compiler-rt/test/builtins/Unit/floatunditf_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_floatunditf
 
 #include "int_lib.h"
 #include <math.h>
 #include <complex.h>
 #include <stdio.h>
 
 #if __LDBL_MANT_DIG__ == 113
 
 #include "fp_test.h"
 
 // Returns: long integer converted to long double
 
-COMPILER_RT_ABI long double __floatunditf(du_int a);
+COMPILER_RT_ABI tf_float __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);
 
     if (ret)
         printf("error in __floatunditf(%Lu) = %.20Lf, "

compiler-rt/test/builtins/Unit/floatuntitf_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_floatuntitf
 
 #define QUAD_PRECISION
 #include "fp_lib.h"
 #include "int_lib.h"
 #include <float.h>
 #include <stdio.h>
 
-#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+#if defined(CRT_HAS_TF_MODE)
 
-/* Returns: convert a tu_int to a fp_t, rounding toward even. */
+/* Returns: convert a tu_int to a tf_float, rounding toward even. */
 
-/* Assumption: fp_t is a IEEE 128 bit floating point type
+/* Assumption: tf_float is a IEEE 128 bit floating point type
  *             tu_int is a 128 bit integral type
  */
 
 /* seee eeee eeee eeee mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm |
  * mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
  */
 
-COMPILER_RT_ABI fp_t __floatuntitf(tu_int a);
+COMPILER_RT_ABI tf_float __floatuntitf(tu_int a);
 
-int test__floatuntitf(tu_int a, fp_t expected) {
-    fp_t x = __floatuntitf(a);
-    if (x != expected) {
-        utwords at;
-        at.all = a;
-        printf("error in __floatuntitf(0x%.16llX%.16llX) = %LA, expected %LA\n",
-               at.s.high, at.s.low, x, expected);
-    }
-    return x != expected;
+int test__floatuntitf(tu_int a, tf_float expected) {
+  tf_float x = __floatuntitf(a);
 }
 
 char assumption_1[sizeof(tu_int) == 2*sizeof(du_int)] = {0};
 char assumption_2[sizeof(tu_int)*CHAR_BIT == 128] = {0};
-char assumption_3[sizeof(fp_t)*CHAR_BIT == 128] = {0};
+char assumption_3[sizeof(tf_float) * CHAR_BIT == 128] = {0};
 
 #endif
 
 int main() {
-#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
-    if (test__floatuntitf(0, 0.0))
-        return 1;
+#if defined(CRT_HAS_TF_MODE)
 
-    if (test__floatuntitf(1, 1.0))
-        return 1;
-    if (test__floatuntitf(2, 2.0))
-        return 1;
-    if (test__floatuntitf(20, 20.0))
-        return 1;
 
-    if (test__floatuntitf(0x7FFFFF8000000000ULL, 0x1.FFFFFEp+62))
-        return 1;
-    if (test__floatuntitf(0x7FFFFFFFFFFFF800ULL, 0x1.FFFFFFFFFFFFEp+62))
-        return 1;
-    if (test__floatuntitf(0x7FFFFF0000000000ULL, 0x1.FFFFFCp+62))
-        return 1;
-    if (test__floatuntitf(0x7FFFFFFFFFFFF000ULL, 0x1.FFFFFFFFFFFFCp+62))
-        return 1;
-    if (test__floatuntitf(0x7FFFFFFFFFFFFFFFULL, 0xF.FFFFFFFFFFFFFFEp+59L))
-        return 1;
-    if (test__floatuntitf(0xFFFFFFFFFFFFFFFEULL, 0xF.FFFFFFFFFFFFFFEp+60L))
-        return 1;
-    if (test__floatuntitf(0xFFFFFFFFFFFFFFFFULL, 0xF.FFFFFFFFFFFFFFFp+60L))
-        return 1;
 
-    if (test__floatuntitf(0x8000008000000000ULL, 0x8.000008p+60))
-        return 1;
-    if (test__floatuntitf(0x8000000000000800ULL, 0x8.0000000000008p+60))
-        return 1;
-    if (test__floatuntitf(0x8000010000000000ULL, 0x8.00001p+60))
-        return 1;
-    if (test__floatuntitf(0x8000000000001000ULL, 0x8.000000000001p+60))
-        return 1;
 
-    if (test__floatuntitf(0x8000000000000000ULL, 0x8p+60))
-        return 1;
-    if (test__floatuntitf(0x8000000000000001ULL, 0x8.000000000000001p+60Q))
-        return 1;
+  if (test__floatuntitf(0x8000000000000001ULL, CRT_TF(0x8.000000000000001p+60)))
 
-    if (test__floatuntitf(0x0007FB72E8000000LL, 0x1.FEDCBAp+50))
-        return 1;
 
-    if (test__floatuntitf(0x0007FB72EA000000LL, 0x1.FEDCBA8p+50))
-        return 1;
-    if (test__floatuntitf(0x0007FB72EB000000LL, 0x1.FEDCBACp+50))
-        return 1;
-    if (test__floatuntitf(0x0007FB72EBFFFFFFLL, 0x1.FEDCBAFFFFFFCp+50))
-        return 1;
-    if (test__floatuntitf(0x0007FB72EC000000LL, 0x1.FEDCBBp+50))
-        return 1;
-    if (test__floatuntitf(0x0007FB72E8000001LL, 0x1.FEDCBA0000004p+50))
-        return 1;
 
-    if (test__floatuntitf(0x0007FB72E6000000LL, 0x1.FEDCB98p+50))
-        return 1;
-    if (test__floatuntitf(0x0007FB72E7000000LL, 0x1.FEDCB9Cp+50))
-        return 1;
-    if (test__floatuntitf(0x0007FB72E7FFFFFFLL, 0x1.FEDCB9FFFFFFCp+50))
-        return 1;
-    if (test__floatuntitf(0x0007FB72E4000001LL, 0x1.FEDCB90000004p+50))
-        return 1;
-    if (test__floatuntitf(0x0007FB72E4000000LL, 0x1.FEDCB9p+50))
-        return 1;
 
-    if (test__floatuntitf(0x023479FD0E092DC0LL, 0x1.1A3CFE870496Ep+57))
-        return 1;
-    if (test__floatuntitf(0x023479FD0E092DA1LL, 0x1.1A3CFE870496D08p+57Q))
-        return 1;
-    if (test__floatuntitf(0x023479FD0E092DB0LL, 0x1.1A3CFE870496D8p+57Q))
-        return 1;
-    if (test__floatuntitf(0x023479FD0E092DB8LL, 0x1.1A3CFE870496DCp+57Q))
-        return 1;
-    if (test__floatuntitf(0x023479FD0E092DB6LL, 0x1.1A3CFE870496DBp+57Q))
-        return 1;
-    if (test__floatuntitf(0x023479FD0E092DBFLL, 0x1.1A3CFE870496DF8p+57Q))
-        return 1;
-    if (test__floatuntitf(0x023479FD0E092DC1LL, 0x1.1A3CFE870496E08p+57Q))
-        return 1;
-    if (test__floatuntitf(0x023479FD0E092DC7LL, 0x1.1A3CFE870496E38p+57Q))
-        return 1;
-    if (test__floatuntitf(0x023479FD0E092DC8LL, 0x1.1A3CFE870496E4p+57Q))
-        return 1;
-    if (test__floatuntitf(0x023479FD0E092DCFLL, 0x1.1A3CFE870496E78p+57Q))
-        return 1;
-    if (test__floatuntitf(0x023479FD0E092DD0LL, 0x1.1A3CFE870496E8p+57Q))
-        return 1;
-    if (test__floatuntitf(0x023479FD0E092DD1LL, 0x1.1A3CFE870496E88p+57Q))
-        return 1;
-    if (test__floatuntitf(0x023479FD0E092DD8LL, 0x1.1A3CFE870496ECp+57Q))
-        return 1;
-    if (test__floatuntitf(0x023479FD0E092DDFLL, 0x1.1A3CFE870496EF8p+57Q))
-        return 1;
-    if (test__floatuntitf(0x023479FD0E092DE0LL, 0x1.1A3CFE870496Fp+57))
-        return 1;
+  if (test__floatuntitf(0x023479FD0E092DA1LL, CRT_TF(0x1.1A3CFE870496D08p+57)))
+  if (test__floatuntitf(0x023479FD0E092DB0LL, CRT_TF(0x1.1A3CFE870496D8p+57)))
+  if (test__floatuntitf(0x023479FD0E092DB8LL, CRT_TF(0x1.1A3CFE870496DCp+57)))
+  if (test__floatuntitf(0x023479FD0E092DB6LL, CRT_TF(0x1.1A3CFE870496DBp+57)))
+  if (test__floatuntitf(0x023479FD0E092DBFLL, CRT_TF(0x1.1A3CFE870496DF8p+57)))
+  if (test__floatuntitf(0x023479FD0E092DC1LL, CRT_TF(0x1.1A3CFE870496E08p+57)))
+  if (test__floatuntitf(0x023479FD0E092DC7LL, CRT_TF(0x1.1A3CFE870496E38p+57)))
+  if (test__floatuntitf(0x023479FD0E092DC8LL, CRT_TF(0x1.1A3CFE870496E4p+57)))
+  if (test__floatuntitf(0x023479FD0E092DCFLL, CRT_TF(0x1.1A3CFE870496E78p+57)))
+  if (test__floatuntitf(0x023479FD0E092DD0LL, CRT_TF(0x1.1A3CFE870496E8p+57)))
+  if (test__floatuntitf(0x023479FD0E092DD1LL, CRT_TF(0x1.1A3CFE870496E88p+57)))
+  if (test__floatuntitf(0x023479FD0E092DD8LL, CRT_TF(0x1.1A3CFE870496ECp+57)))
+  if (test__floatuntitf(0x023479FD0E092DDFLL, CRT_TF(0x1.1A3CFE870496EF8p+57)))
 
-    if (test__floatuntitf(make_ti(0x023479FD0E092DC0LL, 0), 0x1.1A3CFE870496Ep+121Q))
-        return 1;
-    if (test__floatuntitf(make_ti(0x023479FD0E092DA1LL, 1), 0x1.1A3CFE870496D08p+121Q))
-        return 1;
-    if (test__floatuntitf(make_ti(0x023479FD0E092DB0LL, 2), 0x1.1A3CFE870496D8p+121Q))
-        return 1;
-    if (test__floatuntitf(make_ti(0x023479FD0E092DB8LL, 3), 0x1.1A3CFE870496DCp+121Q))
-        return 1;
-    if (test__floatuntitf(make_ti(0x023479FD0E092DB6LL, 4), 0x1.1A3CFE870496DBp+121Q))
-        return 1;
-    if (test__floatuntitf(make_ti(0x023479FD0E092DBFLL, 5), 0x1.1A3CFE870496DF8p+121Q))
-        return 1;
-    if (test__floatuntitf(make_ti(0x023479FD0E092DC1LL, 6), 0x1.1A3CFE870496E08p+121Q))
-        return 1;
-    if (test__floatuntitf(make_ti(0x023479FD0E092DC7LL, 7), 0x1.1A3CFE870496E38p+121Q))
-        return 1;
-    if (test__floatuntitf(make_ti(0x023479FD0E092DC8LL, 8), 0x1.1A3CFE870496E4p+121Q))
-        return 1;
-    if (test__floatuntitf(make_ti(0x023479FD0E092DCFLL, 9), 0x1.1A3CFE870496E78p+121Q))
-        return 1;
-    if (test__floatuntitf(make_ti(0x023479FD0E092DD0LL, 0), 0x1.1A3CFE870496E8p+121Q))
-        return 1;
-    if (test__floatuntitf(make_ti(0x023479FD0E092DD1LL, 11), 0x1.1A3CFE870496E88p+121Q))
-        return 1;
-    if (test__floatuntitf(make_ti(0x023479FD0E092DD8LL, 12), 0x1.1A3CFE870496ECp+121Q))
-        return 1;
-    if (test__floatuntitf(make_ti(0x023479FD0E092DDFLL, 13), 0x1.1A3CFE870496EF8p+121Q))
-        return 1;
-    if (test__floatuntitf(make_ti(0x023479FD0E092DE0LL, 14), 0x1.1A3CFE870496Fp+121Q))
-        return 1;
+  if (test__floatuntitf(make_ti(0x023479FD0E092DC0LL, 0),
+                        CRT_TF(0x1.1A3CFE870496Ep+121)))
+  if (test__floatuntitf(make_ti(0x023479FD0E092DA1LL, 1),
+                        CRT_TF(0x1.1A3CFE870496D08p+121)))
+  if (test__floatuntitf(make_ti(0x023479FD0E092DB0LL, 2),
+                        CRT_TF(0x1.1A3CFE870496D8p+121)))
+  if (test__floatuntitf(make_ti(0x023479FD0E092DB8LL, 3),
+                        CRT_TF(0x1.1A3CFE870496DCp+121)))
+  if (test__floatuntitf(make_ti(0x023479FD0E092DB6LL, 4),
+                        CRT_TF(0x1.1A3CFE870496DBp+121)))
+  if (test__floatuntitf(make_ti(0x023479FD0E092DBFLL, 5),
+                        CRT_TF(0x1.1A3CFE870496DF8p+121)))
+  if (test__floatuntitf(make_ti(0x023479FD0E092DC1LL, 6),
+                        CRT_TF(0x1.1A3CFE870496E08p+121)))
+  if (test__floatuntitf(make_ti(0x023479FD0E092DC7LL, 7),
+                        CRT_TF(0x1.1A3CFE870496E38p+121)))
+  if (test__floatuntitf(make_ti(0x023479FD0E092DC8LL, 8),
+                        CRT_TF(0x1.1A3CFE870496E4p+121)))
+  if (test__floatuntitf(make_ti(0x023479FD0E092DCFLL, 9),
+                        CRT_TF(0x1.1A3CFE870496E78p+121)))
+  if (test__floatuntitf(make_ti(0x023479FD0E092DD0LL, 0),
+                        CRT_TF(0x1.1A3CFE870496E8p+121)))
+  if (test__floatuntitf(make_ti(0x023479FD0E092DD1LL, 11),
+                        CRT_TF(0x1.1A3CFE870496E88p+121)))
+  if (test__floatuntitf(make_ti(0x023479FD0E092DD8LL, 12),
+                        CRT_TF(0x1.1A3CFE870496ECp+121)))
+  if (test__floatuntitf(make_ti(0x023479FD0E092DDFLL, 13),
+                        CRT_TF(0x1.1A3CFE870496EF8p+121)))
+  if (test__floatuntitf(make_ti(0x023479FD0E092DE0LL, 14),
+                        CRT_TF(0x1.1A3CFE870496Fp+121)))
 
-    if (test__floatuntitf(make_ti(0, 0xFFFFFFFFFFFFFFFFLL), 0x1.FFFFFFFFFFFFFFFEp+63Q))
-        return 1;
+  if (test__floatuntitf(make_ti(0, 0xFFFFFFFFFFFFFFFFLL),
+                        CRT_TF(0x1.FFFFFFFFFFFFFFFEp+63)))
 
-    if (test__floatuntitf(make_ti(0xFFFFFFFFFFFFFFFFLL, 0x0000000000000000LL),
-                          0x1.FFFFFFFFFFFFFFFEp+127Q))
-        return 1;
-    if (test__floatuntitf(make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL),
-                          0x1.0000000000000000p+128Q))
-        return 1;
+                        CRT_TF(0x1.FFFFFFFFFFFFFFFEp+127)))
+                        CRT_TF(0x1.0000000000000000p+128)))
 
-    if (test__floatuntitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC2801LL),
-                        0x1.23456789ABCDEF0123456789ABC3p+124Q))
-        return 1;
-    if (test__floatuntitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC3000LL),
-                        0x1.23456789ABCDEF0123456789ABC3p+124Q))
-        return 1;
-    if (test__floatuntitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC37FFLL),
-                        0x1.23456789ABCDEF0123456789ABC3p+124Q))
-        return 1;
-    if (test__floatuntitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC3800LL),
-                        0x1.23456789ABCDEF0123456789ABC4p+124Q))
-        return 1;
-    if (test__floatuntitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC4000LL),
-                        0x1.23456789ABCDEF0123456789ABC4p+124Q))
-        return 1;
-    if (test__floatuntitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC47FFLL),
-                        0x1.23456789ABCDEF0123456789ABC4p+124Q))
-        return 1;
-    if (test__floatuntitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC4800LL),
-                        0x1.23456789ABCDEF0123456789ABC4p+124Q))
-        return 1;
-    if (test__floatuntitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC4801LL),
-                        0x1.23456789ABCDEF0123456789ABC5p+124Q))
-        return 1;
-    if (test__floatuntitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC57FFLL),
-                        0x1.23456789ABCDEF0123456789ABC5p+124Q))
-        return 1;
+                        CRT_TF(0x1.23456789ABCDEF0123456789ABC3p+124)))
+                        CRT_TF(0x1.23456789ABCDEF0123456789ABC3p+124)))
+                        CRT_TF(0x1.23456789ABCDEF0123456789ABC3p+124)))
+                        CRT_TF(0x1.23456789ABCDEF0123456789ABC4p+124)))
+                        CRT_TF(0x1.23456789ABCDEF0123456789ABC4p+124)))
+                        CRT_TF(0x1.23456789ABCDEF0123456789ABC4p+124)))
+                        CRT_TF(0x1.23456789ABCDEF0123456789ABC4p+124)))
+                        CRT_TF(0x1.23456789ABCDEF0123456789ABC5p+124)))
+                        CRT_TF(0x1.23456789ABCDEF0123456789ABC5p+124)))
 #else
     printf("skipped\n");
 #endif
    return 0;
 }