[APFloat] convertToDouble/Float can work on shorter types

[sepavloff]

Summary

Previously APFloat::convertToDouble may be called only for APFloats that
were built using double semantics. Other semantics like single precision
were not allowed although corresponding numbers could be converted to
double without loss of precision. The similar restriction applied to
APFloat::convertToFloat.

With this change any APFloat that can be precisely represented by double
can be handled with convertToDouble. Behavior of convertToFloat was
updated similarly. It make the conversion operations more convenient and
adds support for numbers like half and bfloat.

[foad]

Looks good to me but I'd appreciate a review from someone else as well.

llvm/unittests/ADT/APFloatTest.cpp

4719

This should be D2? So maybe use something stronger than EXPECT_EQ, that distinguishes +0 from -0?

You've made the same typo below for B2, H2, etc.

4737–4738

Instead of two EXPECT_TRUE checks can't you use EXPECT_EQ(std::numeric_limits<double>::infinity(), D10.convertToDouble()) ?

[RKSimon]

llvm/unittests/ADT/APFloatTest.cpp

4715

Maybe break this into shorter tests "HalfToDouble", "BFloatToDouble", "FloatToDouble" etc, to help avoid the variable mismatches noticed by @foad ?

[sepavloff]

Use meaningful variable names. Fixed some errors.

[sepavloff]

Use EXPECT_EQ in checks for infinity

[sepavloff]

llvm/unittests/ADT/APFloatTest.cpp

4715

Now meaningful names are used.

4719

Thank you for the catch. Now meaningful names are used for the variables, it must help avoiding such errors.

4737–4738

The checks changed to use EXPECT_EQ.

[RKSimon]

LGTM

llvm/include/llvm/ADT/APFloat.h

opStatus convertFromZeroExtendedInteger(const integerPart *Input,
                                           roundingMode RM) {
     APFLOAT_DISPATCH_ON_SEMANTICS(
         convertFromZeroExtendedInteger(Input, InputSize, IsSigned, RM));
   }
   Expected<opStatus> convertFromString(StringRef, roundingMode);
   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; }
 
   bool operator!=(const APFloat &RHS) const { return compare(RHS) != cmpEqual; }
 
   bool operator<(const APFloat &RHS) const {
     return compare(RHS) == cmpLessThan;
   }

llvm/lib/Analysis/ConstantFolding.cpp

if (status != APFloat::opOK &&
       (!roundTowardZero || status != APFloat::opInexact))
     return nullptr;
   return ConstantInt::get(Ty, UIntVal, IsSigned);
 }
 
 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;
   APFloat APF = Op->getValueAPF();
   APF.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &unused);
   return APF.convertToDouble();
 }
 

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

static bool emitDebugValueComment(const MachineInstr *MI, AsmPrinter &AP) {
 
   // Register or immediate value. Register 0 means undef.
   for (const MachineOperand &Op : MI->debug_operands()) {
     if (&Op != MI->debug_operands().begin())
       OS << ", ";
     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
         // double.  Ah well, it's only a comment.
         bool ignored;
         APF.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven,
                     &ignored);
         OS << "(long double) " << APF.convertToDouble();

llvm/lib/IR/AsmWriter.cpp

if (&APF.getSemantics() == &APFloat::IEEEsingle() ||
       // make sure that we only output it in exponential format if we can parse
       // the value back and get the same value.
       //
       bool ignored;
       bool isDouble = &APF.getSemantics() == &APFloat::IEEEdouble();
       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
         // "Inf" or NaN, that atof will accept, but the lexer will not.  Check
         // that the string matches the "[-+]?[0-9]" regex.
         //
         assert((isDigit(StrVal[0]) || ((StrVal[0] == '-' || StrVal[0] == '+') &&
                                        isDigit(StrVal[1]))) &&

llvm/lib/IR/Core.cpp

 long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal) {
   return unwrap<ConstantInt>(ConstantVal)->getSExtValue();
 }
 
 double LLVMConstRealGetDouble(LLVMValueRef ConstantVal, LLVMBool *LosesInfo) {
   ConstantFP *cFP = unwrap<ConstantFP>(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();
   }
 
   bool APFLosesInfo;
   APFloat APF = cFP->getValueAPF();
   APF.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &APFLosesInfo);
   *LosesInfo = APFLosesInfo;

llvm/lib/Support/APFloat.cpp

struct fltSemantics {
     APFloatBase::ExponentType minExponent;
 
     /* Number of bits in the significand.  This includes the integer
        bit.  */
     unsigned int precision;
 
     /* 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};
   static const fltSemantics semBFloat = {127, -126, 8, 16};
   static const fltSemantics semIEEEsingle = {127, -126, 24, 32};
   static const fltSemantics semIEEEdouble = {1023, -1022, 53, 64};
   static const fltSemantics semIEEEquad = {16383, -16382, 113, 128};
   static const fltSemantics semX87DoubleExtended = {16383, -16382, 64, 80};
APFloat::opStatus APFloat::convertToInteger(APSInt &result,
   SmallVector<uint64_t, 4> parts(result.getNumWords());
   opStatus status = convertToInteger(parts, bitWidth, result.isSigned(),
                                      rounding_mode, isExact);
   // Keeps the original signed-ness.
   result = APInt(bitWidth, parts);
   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

llvm/unittests/ADT/APFloatTest.cpp

TEST(APFloatTest, makeNaN) {
   for (const auto &t : tests) {
     ASSERT_EQ(t.expected, nanbitsFromAPInt(t.semantics, t.SNaN, t.Negative, t.payload));
   }
 }
 
 #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
 
 TEST(APFloatTest, StringDecimalError) {
   EXPECT_EQ("Invalid string length", convertToErrorFromString(""));
   EXPECT_EQ("String has no digits", convertToErrorFromString("+"));
   EXPECT_EQ("String has no digits", convertToErrorFromString("-"));
TEST(APFloatTest, x87Largest) {
   EXPECT_TRUE(MaxX87Val.isLargest());
 }
 
 TEST(APFloatTest, x87Next) {
   APFloat F(APFloat::x87DoubleExtended(), "-1.0");
   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<double>::max(), DPosLargest.convertToDouble());
+  APFloat DNegLargest = APFloat::getLargest(APFloat::IEEEdouble(), true);
+  EXPECT_EQ(-std::numeric_limits<double>::max(), DNegLargest.convertToDouble());
+  APFloat DPosSmallest =
+      APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false);
+  EXPECT_EQ(std::numeric_limits<double>::min(), DPosSmallest.convertToDouble());
+  APFloat DNegSmallest =
+      APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true);
+  EXPECT_EQ(-std::numeric_limits<double>::min(),
+            DNegSmallest.convertToDouble());
+
+  APFloat DSmallestDenorm = APFloat::getSmallest(APFloat::IEEEdouble(), false);
+  EXPECT_EQ(std::numeric_limits<double>::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<double>::infinity(), DPosInf.convertToDouble());
+  APFloat DNegInf = APFloat::getInf(APFloat::IEEEdouble(), true);
+  EXPECT_EQ(-std::numeric_limits<double>::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<float>::max(), FPosLargest.convertToDouble());
+  APFloat FNegLargest = APFloat::getLargest(APFloat::IEEEsingle(), true);
+  EXPECT_EQ(-std::numeric_limits<float>::max(), FNegLargest.convertToDouble());
+  APFloat FPosSmallest =
+      APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
+  EXPECT_EQ(std::numeric_limits<float>::min(), FPosSmallest.convertToDouble());
+  APFloat FNegSmallest =
+      APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
+  EXPECT_EQ(-std::numeric_limits<float>::min(), FNegSmallest.convertToDouble());
+
+  APFloat FSmallestDenorm = APFloat::getSmallest(APFloat::IEEEsingle(), false);
+  EXPECT_EQ(std::numeric_limits<float>::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<double>::infinity(), FPosInf.convertToDouble());
+  APFloat FNegInf = APFloat::getInf(APFloat::IEEEsingle(), true);
+  EXPECT_EQ(-std::numeric_limits<double>::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<float>::max(), FPosLargest.convertToFloat());
+  APFloat FNegLargest = APFloat::getLargest(APFloat::IEEEsingle(), true);
+  EXPECT_EQ(-std::numeric_limits<float>::max(), FNegLargest.convertToFloat());
+  APFloat FPosSmallest =
+      APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
+  EXPECT_EQ(std::numeric_limits<float>::min(), FPosSmallest.convertToFloat());
+  APFloat FNegSmallest =
+      APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
+  EXPECT_EQ(-std::numeric_limits<float>::min(), FNegSmallest.convertToFloat());
+
+  APFloat FSmallestDenorm = APFloat::getSmallest(APFloat::IEEEsingle(), false);
+  EXPECT_EQ(std::numeric_limits<float>::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<float>::infinity(), FPosInf.convertToFloat());
+  APFloat FNegInf = APFloat::getInf(APFloat::IEEEsingle(), true);
+  EXPECT_EQ(-std::numeric_limits<float>::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()));
+}
 }