[builtins] Avoid using CRT_LDBL_128BIT in implementation. NFC

[arichardson]

Summary

Currently the *tf builtin functions can only be built if long double is an
IEEE float, which prevents them from being available e.g. for x86 targets
(unlike libgcc which has them). This non-functional change prepares the
builtins library *tf functions for being able to target x86 by decoupling
their presence from CRT_LDBL_128BIT and instead checking for a
CRT_HAS_TF_MODE macro. This change is NFC since the CRT_HAS_TF_MODE is
currently only set if long double is an IEEE 128-bit float.

compiler-rt/lib/builtins/addtf3.c

 //===-- lib/addtf3.c - Quad-precision addition --------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements quad-precision soft-float addition.
 //
 //===----------------------------------------------------------------------===//
 
 #define QUAD_PRECISION
 #include "fp_lib.h"
 
-#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+#if defined(CRT_HAS_TF_MODE)
 #include "fp_add_impl.inc"
 
 COMPILER_RT_ABI fp_t __addtf3(fp_t a, fp_t b) {
   return __addXf3__(a, b);
 }
 
 #endif

compiler-rt/lib/builtins/comparetf2.c

 // Note that __letf2( ) and __getf2( ) are identical except in their handling of
 // NaN values.
 //
 //===----------------------------------------------------------------------===//
 
 #define QUAD_PRECISION
 #include "fp_lib.h"
 
-#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+#if defined(CRT_HAS_TF_MODE)
 #include "fp_compare_impl.inc"
 
 COMPILER_RT_ABI CMP_RESULT __letf2(fp_t a, fp_t b) { return __leXf2__(a, b); }
 
 #if defined(__ELF__)
 // Alias for libgcc compatibility
 COMPILER_RT_ALIAS(__letf2, __cmptf2)
 #endif

compiler-rt/lib/builtins/divtf3.c

 //===-- lib/divtf3.c - Quad-precision division --------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements quad-precision soft-float division
 // with the IEEE-754 default rounding (to nearest, ties to even).
 //
 //===----------------------------------------------------------------------===//
 
 #define QUAD_PRECISION
 #include "fp_lib.h"
 
-#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+#if defined(CRT_HAS_TF_MODE)
 
 #define NUMBER_OF_HALF_ITERATIONS 4
 #define NUMBER_OF_FULL_ITERATIONS 1
 
 #include "fp_div_impl.inc"
 
 COMPILER_RT_ABI fp_t __divtf3(fp_t a, fp_t b) { return __divXf3__(a, b); }
 
 #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_128BIT) && defined(CRT_LDBL_128BIT)
+#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);
 }
 
 #endif

compiler-rt/lib/builtins/extendhftf2.c

 //===-- lib/extendhftf2.c - half -> quad conversion ---------------*- C -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #define QUAD_PRECISION
 #include "fp_lib.h"
 
-#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) &&                     \
-    defined(COMPILER_RT_HAS_FLOAT16)
+#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);
 }
 
 #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_128BIT) && defined(CRT_LDBL_128BIT)
+#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);
 }
 
 #endif

compiler-rt/lib/builtins/fixtfdi.c

 //===-- fixtfdi.c - Implement __fixtfdi -----------------------------------===//
 //
 // 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_128BIT) && defined(CRT_LDBL_128BIT)
+#if defined(CRT_HAS_TF_MODE)
 typedef di_int fixint_t;
 typedef du_int fixuint_t;
 #include "fp_fixint_impl.inc"
 
 COMPILER_RT_ABI di_int __fixtfdi(fp_t a) { return __fixint(a); }
 #endif

compiler-rt/lib/builtins/fixtfsi.c

 //===-- fixtfsi.c - Implement __fixtfsi -----------------------------------===//
 //
 // 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_128BIT) && defined(CRT_LDBL_128BIT)
+#if defined(CRT_HAS_TF_MODE)
 typedef si_int fixint_t;
 typedef su_int fixuint_t;
 #include "fp_fixint_impl.inc"
 
 COMPILER_RT_ABI si_int __fixtfsi(fp_t a) { return __fixint(a); }
 #endif

compiler-rt/lib/builtins/fixtfti.c

 //===-- fixtfti.c - Implement __fixtfti -----------------------------------===//
 //
 // 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_128BIT) && defined(CRT_LDBL_128BIT)
+#if defined(CRT_HAS_TF_MODE)
 typedef ti_int fixint_t;
 typedef tu_int fixuint_t;
 #include "fp_fixint_impl.inc"
 
 COMPILER_RT_ABI ti_int __fixtfti(fp_t a) { return __fixint(a); }
 #endif

compiler-rt/lib/builtins/fixunstfdi.c

 //===-- fixunstfdi.c - Implement __fixunstfdi -----------------------------===//
 //
 // 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_128BIT) && defined(CRT_LDBL_128BIT)
+#if defined(CRT_HAS_TF_MODE)
 typedef du_int fixuint_t;
 #include "fp_fixuint_impl.inc"
 
 COMPILER_RT_ABI du_int __fixunstfdi(fp_t a) { return __fixuint(a); }
 #endif

compiler-rt/lib/builtins/fixunstfsi.c

 //===-- fixunstfsi.c - Implement __fixunstfsi -----------------------------===//
 //
 // 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_128BIT) && defined(CRT_LDBL_128BIT)
+#if defined(CRT_HAS_TF_MODE)
 typedef su_int fixuint_t;
 #include "fp_fixuint_impl.inc"
 
 COMPILER_RT_ABI su_int __fixunstfsi(fp_t a) { return __fixuint(a); }
 #endif

compiler-rt/lib/builtins/fixunstfti.c

 //===-- fixunstfsi.c - Implement __fixunstfsi -----------------------------===//
 //
 // 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_128BIT) && defined(CRT_LDBL_128BIT)
+#if defined(CRT_HAS_TF_MODE)
 typedef tu_int fixuint_t;
 #include "fp_fixuint_impl.inc"
 
 COMPILER_RT_ABI tu_int __fixunstfti(fp_t a) { return __fixuint(a); }
 #endif

compiler-rt/lib/builtins/floatditf.c

 // compiler-rt library in the IEEE-754 default round-to-nearest, ties-to-even
 // mode.
 //
 //===----------------------------------------------------------------------===//
 
 #define QUAD_PRECISION
 #include "fp_lib.h"
 
-#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+#if defined(CRT_HAS_TF_MODE)
 COMPILER_RT_ABI fp_t __floatditf(di_int a) {
 
   const int aWidth = sizeof a * CHAR_BIT;
 
   // Handle zero as a special case to protect clz
   if (a == 0)
     return fromRep(0);
 

compiler-rt/lib/builtins/floatsitf.c

 // compiler-rt library in the IEEE-754 default round-to-nearest, ties-to-even
 // mode.
 //
 //===----------------------------------------------------------------------===//
 
 #define QUAD_PRECISION
 #include "fp_lib.h"
 
-#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+#if defined(CRT_HAS_TF_MODE)
 COMPILER_RT_ABI fp_t __floatsitf(si_int a) {
 
   const int aWidth = sizeof a * CHAR_BIT;
 
   // Handle zero as a special case to protect clz
   if (a == 0)
     return fromRep(0);
 

compiler-rt/lib/builtins/floattitf.c

 
 // Assumption: fp_t 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
 
-#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+#if defined(CRT_HAS_TF_MODE)
 COMPILER_RT_ABI fp_t __floattitf(ti_int a) {
   if (a == 0)
     return 0.0;
   const unsigned N = sizeof(ti_int) * CHAR_BIT;
   const ti_int s = a >> (N - 1);
   a = (a ^ s) - s;
   int sd = N - __clzti2(a); // number of significant digits
   int e = sd - 1;           // exponent

compiler-rt/lib/builtins/floatunditf.c

 // compiler-rt library in the IEEE-754 default round-to-nearest, ties-to-even
 // mode.
 //
 //===----------------------------------------------------------------------===//
 
 #define QUAD_PRECISION
 #include "fp_lib.h"
 
-#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+#if defined(CRT_HAS_TF_MODE)
 COMPILER_RT_ABI fp_t __floatunditf(du_int a) {
 
   const int aWidth = sizeof a * CHAR_BIT;
 
   // Handle zero as a special case to protect clz
   if (a == 0)
     return fromRep(0);
 

compiler-rt/lib/builtins/floatunsitf.c

 // compiler-rt library in the IEEE-754 default round-to-nearest, ties-to-even
 // mode.
 //
 //===----------------------------------------------------------------------===//
 
 #define QUAD_PRECISION
 #include "fp_lib.h"
 
-#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+#if defined(CRT_HAS_TF_MODE)
 COMPILER_RT_ABI fp_t __floatunsitf(su_int a) {
 
   const int aWidth = sizeof a * CHAR_BIT;
 
   // Handle zero as a special case to protect clz
   if (a == 0)
     return fromRep(0);
 

compiler-rt/lib/builtins/floatuntitf.c

 
 // Assumption: fp_t 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
 
-#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+#if defined(CRT_HAS_TF_MODE)
 COMPILER_RT_ABI fp_t __floatuntitf(tu_int a) {
   if (a == 0)
     return 0.0;
   const unsigned N = sizeof(tu_int) * CHAR_BIT;
   int sd = N - __clzti2(a); // number of significant digits
   int e = sd - 1;           // exponent
   if (sd > TF_MANT_DIG) {
     //  start:  0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx

compiler-rt/lib/builtins/fp_lib.h

 }
 #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
 #define TF_C(c) c##L
 typedef uint64_t half_rep_t;
 typedef __uint128_t rep_t;
 typedef __int128_t srep_t;
 typedef long double 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

compiler-rt/lib/builtins/multf3.c

 //===-- lib/multf3.c - Quad-precision multiplication --------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements quad-precision soft-float multiplication
 // with the IEEE-754 default rounding (to nearest, ties to even).
 //
 //===----------------------------------------------------------------------===//
 
 #define QUAD_PRECISION
 #include "fp_lib.h"
 
-#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+#if defined(CRT_HAS_TF_MODE)
 #include "fp_mul_impl.inc"
 
 COMPILER_RT_ABI fp_t __multf3(fp_t a, fp_t b) { return __mulXf3__(a, b); }
 
 #endif

compiler-rt/lib/builtins/powitf2.c

 //===-- powitf2.cpp - Implement __powitf2 ---------------------------------===//
 //
 // 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 __powitf2 for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
 #define QUAD_PRECISION
 #include "fp_lib.h"
 
-#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+#if defined(CRT_HAS_TF_MODE)
 
 // Returns: a ^ b
 
 COMPILER_RT_ABI long double __powitf2(long double a, int b) {
   const int recip = b < 0;
   long double r = 1;
   while (1) {
     if (b & 1)

compiler-rt/lib/builtins/subtf3.c

 //===-- lib/subtf3.c - Quad-precision subtraction -----------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements quad-precision soft-float subtraction.
 //
 //===----------------------------------------------------------------------===//
 
 #define QUAD_PRECISION
 #include "fp_lib.h"
 
-#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+#if defined(CRT_HAS_TF_MODE)
 COMPILER_RT_ABI fp_t __addtf3(fp_t a, fp_t b);
 
 // Subtraction; flip the sign bit of b and add.
 COMPILER_RT_ABI fp_t __subtf3(fp_t a, fp_t b) {
   return __addtf3(a, fromRep(toRep(b) ^ signBit));
 }
 
 #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_128BIT) && defined(CRT_LDBL_128BIT)
+#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); }
 
 #endif

compiler-rt/lib/builtins/trunctfhf2.c

 //===-- lib/trunctfhf2.c - quad -> half conversion ----------------*- C -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #define QUAD_PRECISION
 #include "fp_lib.h"
 
-#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) &&                     \
-    defined(COMPILER_RT_HAS_FLOAT16)
+#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);
 }
 
 #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_128BIT) && defined(CRT_LDBL_128BIT)
+#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); }
 
 #endif