Add ifdefs to avoid compiling float128 when the host does not have fp128

Author: MDevereau

llvm/include/llvm/ADT/APFloat.h

@@ -300,7 +300,9 @@ class IEEEFloat final : public APFloatBase {
   IEEEFloat(const fltSemantics &, integerPart);
   IEEEFloat(const fltSemantics &, uninitializedTag);
   IEEEFloat(const fltSemantics &, const APInt &);
+#ifdef __FLOAT128__
   explicit IEEEFloat(float128 ld);
+#endif
   explicit IEEEFloat(double d);
   explicit IEEEFloat(float f);
   IEEEFloat(const IEEEFloat &);
@@ -356,7 +358,9 @@ class IEEEFloat final : public APFloatBase {
   Expected<opStatus> convertFromString(StringRef, roundingMode);
   APInt bitcastToAPInt() const;
   double convertToDouble() const;
+#ifdef __FLOAT128__
   float128 convertToQuad() const;
+#endif
   float convertToFloat() const;
 
   /// @}
@@ -945,7 +949,9 @@ class APFloat : public APFloatBase {
   APFloat(const fltSemantics &Semantics, uninitializedTag)
       : U(Semantics, uninitialized) {}
   APFloat(const fltSemantics &Semantics, const APInt &I) : U(Semantics, I) {}
+#ifdef __FLOAT128__
   explicit APFloat(float128 ld) : U(IEEEFloat(ld), IEEEquad()) {}
+#endif
   explicit APFloat(double d) : U(IEEEFloat(d), IEEEdouble()) {}
   explicit APFloat(float f) : U(IEEEFloat(f), IEEEsingle()) {}
   APFloat(const APFloat &RHS) = default;
@@ -1227,7 +1233,9 @@ class APFloat : public APFloatBase {
   /// \pre The APFloat must be built using semantics, that can be represented by
   /// the host float type without loss of precision. It can be IEEEquad and
   /// shorter semantics, like IEEEdouble and others.
+#ifdef __FLOAT128__
   float128 convertToQuad() const;
+#endif
 
   /// Converts this APFloat to host float value.
   ///

llvm/include/llvm/ADT/APInt.h

@@ -1671,10 +1671,12 @@ class [[nodiscard]] APInt {
   /// any bit width. Exactly 64 bits will be translated.
   double bitsToDouble() const { return llvm::bit_cast<double>(getWord(0)); }
 
+#ifdef __FLOAT128__
   float128 bitsToQuad() const {
     __uint128_t ul = ((__uint128_t)U.pVal[1] << 64) + U.pVal[0];
     return llvm::bit_cast<float128>(ul);
   }
+#endif
 
   /// Converts APInt bits to a float
   ///
@@ -1701,13 +1703,15 @@ class [[nodiscard]] APInt {
     return APInt(sizeof(float) * CHAR_BIT, llvm::bit_cast<uint32_t>(V));
   }
 
+#ifdef __FLOAT128__
   static APInt longDoubleToBits(float128 V) {
     const uint64_t Words[2] = {
         static_cast<uint64_t>(V),
         static_cast<uint64_t>(llvm::bit_cast<__uint128_t>(V) >> 64),
     };
     return APInt(sizeof(float128) * CHAR_BIT, 2, Words);
   }
+#endif
 
   /// @}
   /// \name Mathematics Operations

llvm/include/llvm/IR/Constants.h

@@ -290,7 +290,9 @@ class ConstantFP final : public ConstantData {
   /// host double and as the target format.
   static Constant *get(Type *Ty, double V);
 
+#ifdef __FLOAT128__
   static Constant *get128(Type *Ty, float128 V);
+#endif
 
   /// If Ty is a vector type, return a Constant with a splat of the given
   /// value. Otherwise return a ConstantFP for the given value.

llvm/include/llvm/Support/float128.h

@@ -9,12 +9,10 @@
 #ifndef LLVM_FLOAT128
 #define LLVM_FLOAT128
 
-#if defined(__clang__)
+#if defined(__clang__) && defined(__FLOAT128__)
 typedef __float128 float128;
-#elif defined(__GNUC__) || defined(__GNUG__)
+#elif defined(__FLOAT128__) && (defined(__GNUC__) || defined(__GNUG__))
 typedef _Float128 float128;
-#else
-typedef long double float128;
 #endif
 
 #endif // LLVM_FLOAT128

llvm/lib/Analysis/ConstantFolding.cpp

@@ -1674,8 +1674,7 @@ bool llvm::canConstantFoldCallTo(const CallBase *Call, const Function *F) {
            Name == "fmod" || Name == "fmodf";
   case 'l':
     return Name == "log" || Name == "logf" || Name == "log2" ||
-           Name == "log2f" || Name == "log10" || Name == "log10f" ||
-           Name == "logl";
+           Name == "log2f" || Name == "log10" || Name == "log10f";
   case 'n':
     return Name == "nearbyint" || Name == "nearbyintf";
   case 'p':
@@ -1758,15 +1757,6 @@ inline bool llvm_fenv_testexcept() {
   return false;
 }
 
-Constant *ConstantFoldLogf128(const APFloat &V, Type *Ty) {
-#ifdef HAS_LOGF128
-  float128 l = logf128(V.convertToQuad());
-  return ConstantFP::get128(Ty, l);
-#else
-  return nullptr;
-#endif
-}
-
 Constant *ConstantFoldFP(double (*NativeFP)(double), const APFloat &V,
                          Type *Ty) {
   llvm_fenv_clearexcept();
@@ -2214,8 +2204,11 @@ static Constant *ConstantFoldScalarCall1(StringRef Name,
     switch (IntrinsicID) {
       default: break;
       case Intrinsic::log:
-        if (Ty->isFP128Ty())
-          return ConstantFoldLogf128(APF, Ty);
+        #if defined(__FLOAT128__) && defined (HAS_LOGF128)
+        if (Ty->isFP128Ty()){
+          return ConstantFP::get(Ty, logf128(APF.convertToQuad()));
+        }
+        #endif
         return ConstantFoldFP(log, APF, Ty);
       case Intrinsic::log2:
         // TODO: What about hosts that lack a C99 library?
@@ -2345,11 +2338,6 @@ static Constant *ConstantFoldScalarCall1(StringRef Name,
       if (!APF.isNegative() && !APF.isZero() && TLI->has(Func))
         return ConstantFoldFP(log, APF, Ty);
       break;
-    case LibFunc_logl:
-      if (!APF.isNegative() && !APF.isZero() && TLI->has(Func) &&
-          Ty->isFP128Ty())
-        return ConstantFoldLogf128(APF, Ty);
-      break;
     case LibFunc_log2:
     case LibFunc_log2f:
     case LibFunc_log2_finite:

llvm/lib/IR/Constants.cpp

@@ -976,6 +976,7 @@ Constant *ConstantFP::get(Type *Ty, double V) {
   return C;
 }
 
+#ifdef __FLOAT128__
 Constant *ConstantFP::get128(Type *Ty, float128 V) {
   LLVMContext &Context = Ty->getContext();
 
@@ -991,6 +992,7 @@ Constant *ConstantFP::get128(Type *Ty, float128 V) {
 
   return C;
 }
+#endif
 
 Constant *ConstantFP::get(Type *Ty, const APFloat &V) {
   ConstantFP *C = get(Ty->getContext(), V);

llvm/lib/Support/APFloat.cpp

@@ -3670,12 +3670,14 @@ double IEEEFloat::convertToDouble() const {
   return api.bitsToDouble();
 }
 
+#ifdef __FLOAT128__
 float128 IEEEFloat::convertToQuad() const {
   assert(semantics == (const llvm::fltSemantics *)&semIEEEquad &&
          "Float semantics are not IEEEquads");
   APInt api = bitcastToAPInt();
   return api.bitsToQuad();
 }
+#endif
 
 /// Integer bit is explicit in this format.  Intel hardware (387 and later)
 /// does not support these bit patterns:
@@ -3965,9 +3967,11 @@ IEEEFloat::IEEEFloat(double d) {
   initFromAPInt(&semIEEEdouble, APInt::doubleToBits(d));
 }
 
+#ifdef __FLOAT128__
 IEEEFloat::IEEEFloat(float128 ld) {
   initFromAPInt(&semIEEEquad, APInt::longDoubleToBits(ld));
 }
+#endif
 
 namespace {
   void append(SmallVectorImpl<char> &Buffer, StringRef Str) {
@@ -5276,6 +5280,7 @@ double APFloat::convertToDouble() const {
   return Temp.getIEEE().convertToDouble();
 }
 
+#ifdef __FLOAT128__
 float128 APFloat::convertToQuad() const {
   if (&getSemantics() == (const llvm::fltSemantics *)&semIEEEquad)
     return getIEEE().convertToQuad();
@@ -5288,6 +5293,7 @@ float128 APFloat::convertToQuad() const {
   (void)St;
   return Temp.getIEEE().convertToQuad();
 }
+#endif
 
 float APFloat::convertToFloat() const {
   if (&getSemantics() == (const llvm::fltSemantics *)&semIEEEsingle)

llvm/unittests/Analysis/ConstantLogf128.cpp

@@ -17,13 +17,8 @@ using namespace llvm;
 
 namespace {
 
-class ConstantFoldLogf128Fixture
-    : public ::testing ::TestWithParam<std::string> {
-protected:
-  std::string FuncName;
-};
-
-TEST_P(ConstantFoldLogf128Fixture, ConstantFoldLogf128) {
+TEST(ConstantFoldLogf128Fixture, ConstantFoldLogf128) {
+#ifdef __FLOAT128__
   LLVMContext Context;
   IRBuilder<> Builder(Context);
   Module MainModule("Logf128TestModule", Context);
@@ -40,15 +35,13 @@ TEST_P(ConstantFoldLogf128Fixture, ConstantFoldLogf128) {
   FunctionType *FP128FP128Prototype =
       FunctionType::get(FP128Ty, {FP128Ty}, false);
   Constant *Constant2L = ConstantFP::get128(FP128Ty, 2.0L);
-
-  std::string FunctionName = GetParam();
-  Function *Logl = Function::Create(
-      FP128FP128Prototype, Function::ExternalLinkage, FunctionName, MainModule);
-  CallInst *LoglCall = Builder.CreateCall(Logl, Constant2L);
+  Function *Logf128 = Function::Create(
+      FP128FP128Prototype, Function::ExternalLinkage, "llvm.log.f128", MainModule);
+  CallInst *Logf128Call = Builder.CreateCall(Logf128, Constant2L);
 
   TargetLibraryInfoImpl TLII(Triple(MainModule.getTargetTriple()));
   TargetLibraryInfo TLI(TLII, Logf128TestFunction);
-  Constant *FoldResult = ConstantFoldCall(LoglCall, Logl, Constant2L, &TLI);
+  Constant *FoldResult = ConstantFoldCall(Logf128Call, Logf128, Constant2L, &TLI);
 
 #ifndef HAS_LOGF128
   ASSERT_TRUE(FoldResult == nullptr);
@@ -64,11 +57,11 @@ TEST_P(ConstantFoldLogf128Fixture, ConstantFoldLogf128) {
   EXPECT_GT(Size, 0U);
 
   ASSERT_STREQ(LongDoubleHexString,
-               std::string("0X1.62E42FEFA39E0000000000000000000P-1").c_str());
+               std::string("0X1.62E42FEFA39EF000000000000000000P-1").c_str());
+#endif //HAS_LOGF128
+#else // __FLOAT128__
+  ASSERT_TRUE(true);
 #endif
 }
 
-INSTANTIATE_TEST_SUITE_P(ConstantFoldLogf128, ConstantFoldLogf128Fixture,
-                         ::testing::Values("logl", "llvm.log.f128"));
-
-} // end anonymous namespace
+}