diff --git a/llvm/include/llvm/ADT/APFloat.h b/llvm/include/llvm/ADT/APFloat.h --- a/llvm/include/llvm/ADT/APFloat.h +++ b/llvm/include/llvm/ADT/APFloat.h @@ -1132,8 +1132,20 @@ APInt bitcastToAPInt() const { APFLOAT_DISPATCH_ON_SEMANTICS(bitcastToAPInt()); } - double convertToDouble() const { return getIEEE().convertToDouble(); } - float convertToFloat() const { return getIEEE().convertToFloat(); } + + /// Converts this APFloat to host double value. + /// + /// \pre The APFloat must be built using semantics, that can be represented by + /// the host double type without loss of precision. It can be IEEEdouble and + /// shorter semantics, like IEEEsingle and others. + double convertToDouble() const; + + /// Converts this APFloat to host float value. + /// + /// \pre The APFloat must be built using semantics, that can be represented by + /// the host float type without loss of precision. It can be IEEEsingle and + /// shorter semantics, like IEEEhalf. + float convertToFloat() const; bool operator==(const APFloat &RHS) const { return compare(RHS) == cmpEqual; } diff --git a/llvm/lib/Analysis/ConstantFolding.cpp b/llvm/lib/Analysis/ConstantFolding.cpp --- a/llvm/lib/Analysis/ConstantFolding.cpp +++ b/llvm/lib/Analysis/ConstantFolding.cpp @@ -1794,10 +1794,7 @@ double getValueAsDouble(ConstantFP *Op) { Type *Ty = Op->getType(); - if (Ty->isFloatTy()) - return Op->getValueAPF().convertToFloat(); - - if (Ty->isDoubleTy()) + if (Ty->isBFloatTy() || Ty->isHalfTy() || Ty->isFloatTy() || Ty->isDoubleTy()) return Op->getValueAPF().convertToDouble(); bool unused; diff --git a/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp b/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp --- a/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp @@ -953,9 +953,9 @@ switch (Op.getType()) { case MachineOperand::MO_FPImmediate: { APFloat APF = APFloat(Op.getFPImm()->getValueAPF()); - if (Op.getFPImm()->getType()->isFloatTy()) { - OS << (double)APF.convertToFloat(); - } else if (Op.getFPImm()->getType()->isDoubleTy()) { + Type *ImmTy = Op.getFPImm()->getType(); + if (ImmTy->isBFloatTy() || ImmTy->isHalfTy() || ImmTy->isFloatTy() || + ImmTy->isDoubleTy()) { OS << APF.convertToDouble(); } else { // There is no good way to print long double. Convert a copy to diff --git a/llvm/lib/IR/AsmWriter.cpp b/llvm/lib/IR/AsmWriter.cpp --- a/llvm/lib/IR/AsmWriter.cpp +++ b/llvm/lib/IR/AsmWriter.cpp @@ -1368,7 +1368,7 @@ bool isInf = APF.isInfinity(); bool isNaN = APF.isNaN(); if (!isInf && !isNaN) { - double Val = isDouble ? APF.convertToDouble() : APF.convertToFloat(); + double Val = APF.convertToDouble(); SmallString<128> StrVal; APF.toString(StrVal, 6, 0, false); // Check to make sure that the stringized number is not some string like diff --git a/llvm/lib/IR/Core.cpp b/llvm/lib/IR/Core.cpp --- a/llvm/lib/IR/Core.cpp +++ b/llvm/lib/IR/Core.cpp @@ -1399,12 +1399,8 @@ ConstantFP *cFP = unwrap(ConstantVal) ; Type *Ty = cFP->getType(); - if (Ty->isFloatTy()) { - *LosesInfo = false; - return cFP->getValueAPF().convertToFloat(); - } - - if (Ty->isDoubleTy()) { + if (Ty->isHalfTy() || Ty->isBFloatTy() || Ty->isFloatTy() || + Ty->isDoubleTy()) { *LosesInfo = false; return cFP->getValueAPF().convertToDouble(); } diff --git a/llvm/lib/Support/APFloat.cpp b/llvm/lib/Support/APFloat.cpp --- a/llvm/lib/Support/APFloat.cpp +++ b/llvm/lib/Support/APFloat.cpp @@ -66,6 +66,13 @@ /* Number of bits actually used in the semantics. */ unsigned int sizeInBits; + + // Returns true if any number described by this semantics can be precisely + // represented by the specified semantics. + bool isRepresentableBy(const fltSemantics &S) const { + return maxExponent <= S.maxExponent && minExponent >= S.minExponent && + precision <= S.precision; + } }; static const fltSemantics semIEEEhalf = {15, -14, 11, 16}; @@ -4875,6 +4882,32 @@ return status; } +double APFloat::convertToDouble() const { + if (&getSemantics() == (const llvm::fltSemantics *)&semIEEEdouble) + return getIEEE().convertToDouble(); + assert(getSemantics().isRepresentableBy(semIEEEdouble) && + "Float semantics is not representable by IEEEdouble"); + APFloat Temp = *this; + bool LosesInfo; + opStatus St = Temp.convert(semIEEEdouble, rmNearestTiesToEven, &LosesInfo); + assert(!(St & opInexact) && !LosesInfo && "Unexpected imprecision"); + (void)St; + return Temp.getIEEE().convertToDouble(); +} + +float APFloat::convertToFloat() const { + if (&getSemantics() == (const llvm::fltSemantics *)&semIEEEsingle) + return getIEEE().convertToFloat(); + assert(getSemantics().isRepresentableBy(semIEEEsingle) && + "Float semantics is not representable by IEEEsingle"); + APFloat Temp = *this; + bool LosesInfo; + opStatus St = Temp.convert(semIEEEsingle, rmNearestTiesToEven, &LosesInfo); + assert(!(St & opInexact) && !LosesInfo && "Unexpected imprecision"); + (void)St; + return Temp.getIEEE().convertToFloat(); +} + } // namespace llvm #undef APFLOAT_DISPATCH_ON_SEMANTICS diff --git a/llvm/unittests/ADT/APFloatTest.cpp b/llvm/unittests/ADT/APFloatTest.cpp --- a/llvm/unittests/ADT/APFloatTest.cpp +++ b/llvm/unittests/ADT/APFloatTest.cpp @@ -1271,8 +1271,10 @@ #ifdef GTEST_HAS_DEATH_TEST #ifndef NDEBUG TEST(APFloatTest, SemanticsDeath) { - EXPECT_DEATH(APFloat(APFloat::IEEEsingle(), 0).convertToDouble(), "Float semantics are not IEEEdouble"); - EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), 0).convertToFloat(), "Float semantics are not IEEEsingle"); + EXPECT_DEATH(APFloat(APFloat::IEEEquad(), 0).convertToDouble(), + "Float semantics is not representable by IEEEdouble"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), 0).convertToFloat(), + "Float semantics is not representable by IEEEsingle"); } #endif #endif @@ -4709,4 +4711,271 @@ F.next(false); EXPECT_TRUE(ilogb(F) == -1); } + +TEST(APFloatTest, ToDouble) { + APFloat DPosZero(0.0); + APFloat DPosZeroToDouble(DPosZero.convertToDouble()); + EXPECT_TRUE(DPosZeroToDouble.isPosZero()); + APFloat DNegZero(-0.0); + APFloat DNegZeroToDouble(DNegZero.convertToDouble()); + EXPECT_TRUE(DNegZeroToDouble.isNegZero()); + + APFloat DOne(1.0); + EXPECT_EQ(1.0, DOne.convertToDouble()); + APFloat DPosLargest = APFloat::getLargest(APFloat::IEEEdouble(), false); + EXPECT_EQ(std::numeric_limits::max(), DPosLargest.convertToDouble()); + APFloat DNegLargest = APFloat::getLargest(APFloat::IEEEdouble(), true); + EXPECT_EQ(-std::numeric_limits::max(), DNegLargest.convertToDouble()); + APFloat DPosSmallest = + APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false); + EXPECT_EQ(std::numeric_limits::min(), DPosSmallest.convertToDouble()); + APFloat DNegSmallest = + APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true); + EXPECT_EQ(-std::numeric_limits::min(), + DNegSmallest.convertToDouble()); + + APFloat DSmallestDenorm = APFloat::getSmallest(APFloat::IEEEdouble(), false); + EXPECT_EQ(std::numeric_limits::denorm_min(), + DSmallestDenorm.convertToDouble()); + APFloat DLargestDenorm(APFloat::IEEEdouble(), "0x0.FFFFFFFFFFFFFp-1022"); + EXPECT_EQ(/*0x0.FFFFFFFFFFFFFp-1022*/ 2.225073858507201e-308, + DLargestDenorm.convertToDouble()); + + APFloat DPosInf = APFloat::getInf(APFloat::IEEEdouble()); + EXPECT_EQ(std::numeric_limits::infinity(), DPosInf.convertToDouble()); + APFloat DNegInf = APFloat::getInf(APFloat::IEEEdouble(), true); + EXPECT_EQ(-std::numeric_limits::infinity(), + DNegInf.convertToDouble()); + APFloat DQNaN = APFloat::getQNaN(APFloat::IEEEdouble()); + EXPECT_TRUE(std::isnan(DQNaN.convertToDouble())); + + APFloat FPosZero(0.0F); + APFloat FPosZeroToDouble(FPosZero.convertToDouble()); + EXPECT_TRUE(FPosZeroToDouble.isPosZero()); + APFloat FNegZero(-0.0F); + APFloat FNegZeroToDouble(FNegZero.convertToDouble()); + EXPECT_TRUE(FNegZeroToDouble.isNegZero()); + + APFloat FOne(1.0F); + EXPECT_EQ(1.0, FOne.convertToDouble()); + APFloat FPosLargest = APFloat::getLargest(APFloat::IEEEsingle(), false); + EXPECT_EQ(std::numeric_limits::max(), FPosLargest.convertToDouble()); + APFloat FNegLargest = APFloat::getLargest(APFloat::IEEEsingle(), true); + EXPECT_EQ(-std::numeric_limits::max(), FNegLargest.convertToDouble()); + APFloat FPosSmallest = + APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false); + EXPECT_EQ(std::numeric_limits::min(), FPosSmallest.convertToDouble()); + APFloat FNegSmallest = + APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true); + EXPECT_EQ(-std::numeric_limits::min(), FNegSmallest.convertToDouble()); + + APFloat FSmallestDenorm = APFloat::getSmallest(APFloat::IEEEsingle(), false); + EXPECT_EQ(std::numeric_limits::denorm_min(), + FSmallestDenorm.convertToDouble()); + APFloat FLargestDenorm(APFloat::IEEEdouble(), "0x0.FFFFFEp-126"); + EXPECT_EQ(/*0x0.FFFFFEp-126*/ 1.1754942106924411e-38, + FLargestDenorm.convertToDouble()); + + APFloat FPosInf = APFloat::getInf(APFloat::IEEEsingle()); + EXPECT_EQ(std::numeric_limits::infinity(), FPosInf.convertToDouble()); + APFloat FNegInf = APFloat::getInf(APFloat::IEEEsingle(), true); + EXPECT_EQ(-std::numeric_limits::infinity(), + FNegInf.convertToDouble()); + APFloat FQNaN = APFloat::getQNaN(APFloat::IEEEsingle()); + EXPECT_TRUE(std::isnan(FQNaN.convertToDouble())); + + APFloat HPosZero = APFloat::getZero(APFloat::IEEEhalf()); + APFloat HPosZeroToDouble(HPosZero.convertToDouble()); + EXPECT_TRUE(HPosZeroToDouble.isPosZero()); + APFloat HNegZero = APFloat::getZero(APFloat::IEEEhalf(), true); + APFloat HNegZeroToDouble(HNegZero.convertToDouble()); + EXPECT_TRUE(HNegZeroToDouble.isNegZero()); + + APFloat HOne(APFloat::IEEEhalf(), "1.0"); + EXPECT_EQ(1.0, HOne.convertToDouble()); + APFloat HPosLargest = APFloat::getLargest(APFloat::IEEEhalf(), false); + EXPECT_EQ(65504, HPosLargest.convertToDouble()); + APFloat HNegLargest = APFloat::getLargest(APFloat::IEEEhalf(), true); + EXPECT_EQ(-65504.0, HNegLargest.convertToDouble()); + APFloat HPosSmallest = + APFloat::getSmallestNormalized(APFloat::IEEEhalf(), false); + EXPECT_EQ(/*0x1.p-14*/ 6.103515625e-05, HPosSmallest.convertToDouble()); + APFloat HNegSmallest = + APFloat::getSmallestNormalized(APFloat::IEEEhalf(), true); + EXPECT_EQ(/*-0x1.p-14*/ -6.103515625e-05, HNegSmallest.convertToDouble()); + + APFloat HSmallestDenorm = APFloat::getSmallest(APFloat::IEEEhalf(), false); + EXPECT_EQ(/*0x1.p-24*/ 5.960464477539063e-08, + HSmallestDenorm.convertToDouble()); + APFloat HLargestDenorm(APFloat::IEEEhalf(), "0x1.FFCp-14"); + EXPECT_EQ(/*0x1.FFCp-14*/ 0.00012201070785522461, + HLargestDenorm.convertToDouble()); + + APFloat HPosInf = APFloat::getInf(APFloat::IEEEhalf()); + EXPECT_TRUE(std::isinf(HPosInf.convertToDouble())); + EXPECT_TRUE(0 < HPosInf.convertToDouble()); + APFloat HNegInf = APFloat::getInf(APFloat::IEEEhalf(), true); + EXPECT_TRUE(std::isinf(HNegInf.convertToDouble())); + EXPECT_TRUE(0 > HNegInf.convertToDouble()); + APFloat HQNaN = APFloat::getQNaN(APFloat::IEEEhalf()); + EXPECT_TRUE(std::isnan(HQNaN.convertToDouble())); + + APFloat BPosZero = APFloat::getZero(APFloat::IEEEhalf()); + APFloat BPosZeroToDouble(BPosZero.convertToDouble()); + EXPECT_TRUE(BPosZeroToDouble.isPosZero()); + APFloat BNegZero = APFloat::getZero(APFloat::IEEEhalf(), true); + APFloat BNegZeroToDouble(BNegZero.convertToDouble()); + EXPECT_TRUE(BNegZeroToDouble.isNegZero()); + + APFloat BOne(APFloat::BFloat(), "1.0"); + EXPECT_EQ(1.0, BOne.convertToDouble()); + APFloat BPosLargest = APFloat::getLargest(APFloat::BFloat(), false); + EXPECT_EQ(/*0x1.FEp127*/ 3.3895313892515355e+38, + BPosLargest.convertToDouble()); + APFloat BNegLargest = APFloat::getLargest(APFloat::BFloat(), true); + EXPECT_EQ(/*-0x1.FEp127*/ -3.3895313892515355e+38, + BNegLargest.convertToDouble()); + APFloat BPosSmallest = + APFloat::getSmallestNormalized(APFloat::BFloat(), false); + EXPECT_EQ(/*0x1.p-126*/ 1.1754943508222875e-38, + BPosSmallest.convertToDouble()); + APFloat BNegSmallest = + APFloat::getSmallestNormalized(APFloat::BFloat(), true); + EXPECT_EQ(/*-0x1.p-126*/ -1.1754943508222875e-38, + BNegSmallest.convertToDouble()); + + APFloat BSmallestDenorm = APFloat::getSmallest(APFloat::BFloat(), false); + EXPECT_EQ(/*0x1.p-133*/ 9.183549615799121e-41, + BSmallestDenorm.convertToDouble()); + APFloat BLargestDenorm(APFloat::BFloat(), "0x1.FCp-127"); + EXPECT_EQ(/*0x1.FCp-127*/ 1.1663108012064884e-38, + BLargestDenorm.convertToDouble()); + + APFloat BPosInf = APFloat::getInf(APFloat::BFloat()); + EXPECT_TRUE(std::isinf(BPosInf.convertToDouble())); + EXPECT_TRUE(0 < BPosInf.convertToDouble()); + EXPECT_EQ(0x7F80ULL, BPosInf.bitcastToAPInt().getRawData()[0]); + APFloat BNegInf = APFloat::getInf(APFloat::BFloat(), true); + EXPECT_TRUE(std::isinf(BNegInf.convertToDouble())); + EXPECT_TRUE(0 > BNegInf.convertToDouble()); + EXPECT_EQ(0xFF80ULL, BNegInf.bitcastToAPInt().getRawData()[0]); + APFloat BQNaN = APFloat::getQNaN(APFloat::BFloat()); + EXPECT_TRUE(std::isnan(BQNaN.convertToDouble())); +} + +TEST(APFloatTest, ToFloat) { + APFloat FPosZero(0.0F); + APFloat FPosZeroToFloat(FPosZero.convertToFloat()); + EXPECT_TRUE(FPosZeroToFloat.isPosZero()); + APFloat FNegZero(-0.0F); + APFloat FNegZeroToFloat(FNegZero.convertToFloat()); + EXPECT_TRUE(FNegZeroToFloat.isNegZero()); + + APFloat FOne(1.0F); + EXPECT_EQ(1.0F, FOne.convertToFloat()); + APFloat FPosLargest = APFloat::getLargest(APFloat::IEEEsingle(), false); + EXPECT_EQ(std::numeric_limits::max(), FPosLargest.convertToFloat()); + APFloat FNegLargest = APFloat::getLargest(APFloat::IEEEsingle(), true); + EXPECT_EQ(-std::numeric_limits::max(), FNegLargest.convertToFloat()); + APFloat FPosSmallest = + APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false); + EXPECT_EQ(std::numeric_limits::min(), FPosSmallest.convertToFloat()); + APFloat FNegSmallest = + APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true); + EXPECT_EQ(-std::numeric_limits::min(), FNegSmallest.convertToFloat()); + + APFloat FSmallestDenorm = APFloat::getSmallest(APFloat::IEEEsingle(), false); + EXPECT_EQ(std::numeric_limits::denorm_min(), + FSmallestDenorm.convertToFloat()); + APFloat FLargestDenorm(APFloat::IEEEsingle(), "0x1.FFFFFEp-126"); + EXPECT_EQ(/*0x1.FFFFFEp-126*/ 2.3509885615147286e-38F, + FLargestDenorm.convertToFloat()); + + APFloat FPosInf = APFloat::getInf(APFloat::IEEEsingle()); + EXPECT_EQ(std::numeric_limits::infinity(), FPosInf.convertToFloat()); + APFloat FNegInf = APFloat::getInf(APFloat::IEEEsingle(), true); + EXPECT_EQ(-std::numeric_limits::infinity(), FNegInf.convertToFloat()); + APFloat FQNaN = APFloat::getQNaN(APFloat::IEEEsingle()); + EXPECT_TRUE(std::isnan(FQNaN.convertToFloat())); + + APFloat HPosZero = APFloat::getZero(APFloat::IEEEhalf()); + APFloat HPosZeroToFloat(HPosZero.convertToFloat()); + EXPECT_TRUE(HPosZeroToFloat.isPosZero()); + APFloat HNegZero = APFloat::getZero(APFloat::IEEEhalf(), true); + APFloat HNegZeroToFloat(HNegZero.convertToFloat()); + EXPECT_TRUE(HNegZeroToFloat.isNegZero()); + + APFloat HOne(APFloat::IEEEhalf(), "1.0"); + EXPECT_EQ(1.0F, HOne.convertToFloat()); + APFloat HPosLargest = APFloat::getLargest(APFloat::IEEEhalf(), false); + EXPECT_EQ(/*0x1.FFCp15*/ 65504.0F, HPosLargest.convertToFloat()); + APFloat HNegLargest = APFloat::getLargest(APFloat::IEEEhalf(), true); + EXPECT_EQ(/*-0x1.FFCp15*/ -65504.0F, HNegLargest.convertToFloat()); + APFloat HPosSmallest = + APFloat::getSmallestNormalized(APFloat::IEEEhalf(), false); + EXPECT_EQ(/*0x1.p-14*/ 6.103515625e-05F, HPosSmallest.convertToFloat()); + APFloat HNegSmallest = + APFloat::getSmallestNormalized(APFloat::IEEEhalf(), true); + EXPECT_EQ(/*-0x1.p-14*/ -6.103515625e-05F, HNegSmallest.convertToFloat()); + + APFloat HSmallestDenorm = APFloat::getSmallest(APFloat::IEEEhalf(), false); + EXPECT_EQ(/*0x1.p-24*/ 5.960464477539063e-08F, + HSmallestDenorm.convertToFloat()); + APFloat HLargestDenorm(APFloat::IEEEhalf(), "0x1.FFCp-14"); + EXPECT_EQ(/*0x1.FFCp-14*/ 0.00012201070785522461F, + HLargestDenorm.convertToFloat()); + + APFloat HPosInf = APFloat::getInf(APFloat::IEEEhalf()); + EXPECT_TRUE(std::isinf(HPosInf.convertToFloat())); + EXPECT_TRUE(0 < HPosInf.convertToFloat()); + EXPECT_EQ(0x7C00ULL, HPosInf.bitcastToAPInt().getRawData()[0]); + APFloat HNegInf = APFloat::getInf(APFloat::IEEEhalf(), true); + EXPECT_TRUE(std::isinf(HNegInf.convertToFloat())); + EXPECT_TRUE(0 > HNegInf.convertToFloat()); + EXPECT_EQ(0xFC00ULL, HNegInf.bitcastToAPInt().getRawData()[0]); + APFloat HQNaN = APFloat::getQNaN(APFloat::IEEEhalf()); + EXPECT_TRUE(std::isnan(HQNaN.convertToFloat())); + + APFloat BPosZero = APFloat::getZero(APFloat::BFloat()); + APFloat BPosZeroToDouble(BPosZero.convertToFloat()); + EXPECT_TRUE(BPosZeroToDouble.isPosZero()); + APFloat BNegZero = APFloat::getZero(APFloat::BFloat(), true); + APFloat BNegZeroToDouble(BNegZero.convertToFloat()); + EXPECT_TRUE(BNegZeroToDouble.isNegZero()); + + APFloat BOne(APFloat::BFloat(), "1.0"); + EXPECT_EQ(1.0F, BOne.convertToFloat()); + APFloat BPosLargest = APFloat::getLargest(APFloat::BFloat(), false); + EXPECT_EQ(/*0x1.FEp127*/ 3.3895313892515355e+38F, + BPosLargest.convertToFloat()); + APFloat BNegLargest = APFloat::getLargest(APFloat::BFloat(), true); + EXPECT_EQ(/*-0x1.FEp127*/ -3.3895313892515355e+38F, + BNegLargest.convertToFloat()); + APFloat BPosSmallest = + APFloat::getSmallestNormalized(APFloat::BFloat(), false); + EXPECT_EQ(/*0x1.p-126*/ 1.1754943508222875e-38F, + BPosSmallest.convertToFloat()); + APFloat BNegSmallest = + APFloat::getSmallestNormalized(APFloat::BFloat(), true); + EXPECT_EQ(/*-0x1.p-126*/ -1.1754943508222875e-38F, + BNegSmallest.convertToFloat()); + + APFloat BSmallestDenorm = APFloat::getSmallest(APFloat::BFloat(), false); + EXPECT_EQ(/*0x1.p-133*/ 9.183549615799121e-41F, + BSmallestDenorm.convertToFloat()); + APFloat BLargestDenorm(APFloat::BFloat(), "0x1.FCp-127"); + EXPECT_EQ(/*0x1.FCp-127*/ 1.1663108012064884e-38F, + BLargestDenorm.convertToFloat()); + + APFloat BPosInf = APFloat::getInf(APFloat::BFloat()); + EXPECT_TRUE(std::isinf(BPosInf.convertToFloat())); + EXPECT_TRUE(0 < BPosInf.convertToFloat()); + EXPECT_EQ(0x7F80ULL, BPosInf.bitcastToAPInt().getRawData()[0]); + APFloat BNegInf = APFloat::getInf(APFloat::BFloat(), true); + EXPECT_TRUE(std::isinf(BNegInf.convertToFloat())); + EXPECT_TRUE(0 > BNegInf.convertToFloat()); + EXPECT_EQ(0xFF80ULL, BNegInf.bitcastToAPInt().getRawData()[0]); + APFloat BQNaN = APFloat::getQNaN(APFloat::BFloat()); + EXPECT_TRUE(std::isnan(BQNaN.convertToFloat())); +} }