[Fixed Point] Add floating point methods to APFixedPoint.

[ebevhan]

Summary

This adds methods for APFixedPoint for converting to and
from floating point values.

[ebevhan]

Added comments and more tests.

[ebevhan]

@gousemoodhin I just want to check; are you working on or planning to work on float-fixed support in the near future? Floating point conversions are the next step for the fixed-point support, so if you aren't immediately looking at it, I would like to take a shot at it.

If you want a suggestion for something fixed-point related to work on, there's a bug I filed a while back here: https://bugs.llvm.org/show_bug.cgi?id=46554

[gousemoodhin]

In D85961#2233554, @ebevhan wrote:

@gousemoodhin I just want to check; are you working on or planning to work on float-fixed support in the near future? Floating point conversions are the next step for the fixed-point support, so if you aren't immediately looking at it, I would like to take a shot at it.

If you want a suggestion for something fixed-point related to work on, there's a bug I filed a while back here: https://bugs.llvm.org/show_bug.cgi?id=46554

@ebevhan
I have not yet started the task (Implementation of Floating-point to Fixed-point conversion). If you would like to start implementation, you can start. I will contribute too.

Regarding Bug: https://bugs.llvm.org/show_bug.cgi?id=46554
I will resolve it.

[ebevhan]

Rebased and did minor adjustments.

[ebevhan]

Fix comment mistake.

[rjmccall]

llvm/include/llvm/ADT/APFixedPoint.h

217

This should specify the behavior on infinities and NaN.

llvm/lib/Support/APFixedPoint.cpp

455

This can overflow the format and result in infinity. Maybe APFloat just needs a method to do this given an APInt and a binary exponent? It should be as simple as putting the bits in the right place and then calling normalize().

518

I don't understand. It must be possible to have a value that's representable in both the source floating-point type and the destination fixed-point type but not after shifting.

Maybe you can add methods on APFloat that just extract the denormalized significand and exponent?

[ebevhan]

I hadn't considered half precision as that's sort of off my radar. That does make both these conversion methods and the corresponding codegen implementation rather problematic.

Would it be completely unthinkable to "promote" calculations to a larger FP type (both here and in codegen) if the exponent bits are insufficient to hold the necessary scaling?

llvm/lib/Support/APFixedPoint.cpp

455

You're right. I originally only considered this to be a problem when the overflow resulted in a value that wouldn't be representable, but it's clearly not the case. 0.9999999999ur to _Float16 produces infinity. For all common fixed-point scales, single precision floating point and higher should be fine, though.

I'm surprised there isn't already a method to construct an APFloat from its constituent components. It's probably because there are different, incompatible formats so it is not safe to assume that an APFloat is constructed in a particular way.

518

There is frexp, but it doesn't return the mantissa as an APInt. I suppose it is possible to bitcast the mantissa out of there.

I wonder how well that works on the non-IEEE format, though.

[rjmccall]

Would it be completely unthinkable to "promote" calculations to a larger FP type (both here and in codegen) if the exponent bits are insufficient to hold the necessary scaling?

You could have the same problem with float/bfloat and a 128-bit fixed-point type, right? 128-bit integer types aren't at all ridiculous. I think this is something you should accommodate properly in your design; I don't think it's that problematic.

[ebevhan]

In D85961#2255847, @rjmccall wrote:

Would it be completely unthinkable to "promote" calculations to a larger FP type (both here and in codegen) if the exponent bits are insufficient to hold the necessary scaling?

You could have the same problem with float/bfloat and a 128-bit fixed-point type, right? 128-bit integer types aren't at all ridiculous. I think this is something you should accommodate properly in your design; I don't think it's that problematic.

Sure, for a scaling factor of 128, float doesn't work either. So for the case of float + 128-scaled fixed-point, we would need to do the FP arithmetic in double.

I just suspect that the code will be simpler and probably more efficient for a pattern of fpext->fmul->fptoint or inttofp->fmul->fptrunc rather than chopping up the floats and manually processing their bits. The former may also be easier to select, in cases where that matters.

[rjmccall]

It is probably reasonable to assume that there's always a type you can safely extend to such that the conversion is safe; it's very unlikely that someone would have a fixed-point type large enough to cause problems for double.

[ebevhan]

Added a promotion mechanism to handle cases where the floating point type cannot be used to rescale the value.

[ebevhan]

Rebased.

[rjmccall]

llvm/include/llvm/ADT/APFixedPoint.h

19

Pleases just forward-declare the APFloat and fltSemantics.

69

This should have a doc comment, which should clarify that precision loss is acceptable as long as it doesn't overflow. Also, "accommodate" seems like the wrong direction for this: I'd expect that a fixed-point type can "accommodate" a floating-point type if the floating-point values are representable as the fixed-point type, not the reverse. Maybe fitsInFloatSemantics?

llvm/lib/Support/APFixedPoint.cpp

138

I think there can be border cases with signed types where the maximum-magnitude negative value is unrepresentable but the maximum-magnitude positive value is.

Can you not do this check by just comparing the scale with the exponent range?

444

Can this just be static in this file?

464

Don't you need a type that can accommodate the shifted range?

[ebevhan]

llvm/include/llvm/ADT/APFixedPoint.h

69

Missed the doccomment by mistake.

I changed it to 'fitsInFloatSemantics'. It might be a bit misleading though, since it doesn't really check if the real value fits, but rather the value as an integer. That's why I went with something a bit more vague like "accommodate".

llvm/lib/Support/APFixedPoint.cpp

138

I was originally thinking of comparing the scale, but I came to the conclusion that comparing the scale is not enough. You could have a fixed-point semantic with a very tiny scale, but a huge integral part. That semantic might not work, even though the scale on its own fits.

I was testing with float and found that even with a scale equal to the max-exponent, both the min-integral value and max-integral value were representable (just not exactly).

For a signed 127-scale 128-bit fixed-point semantic, the max is 170141183460469231731687303715884105727, which is rounded to 170141183460469231731687303715884105728. Then, the minimum must also fit, naturally.

I'll add a min comparison for completion's sake, though.

444

It was originally, but I need it in codegen as well so I exported it.

464

Yes, canAccommodateFloatSemantics checks this. It doesn't check whether the 'real' min/max can fit in the floating point semantic; it checks whether the min/max as an integer can. That lets us know if the shifted value will fit, because the shifted value *is* the min/max as an integer.

[ebevhan]

Addressed comments.

[ebevhan]

Ping.

[rjmccall]

llvm/include/llvm/ADT/APFixedPoint.h

69

Do you just want a method on FixedPointSemantics that returns the unscaled, i.e. "value as an integer" semantics?

[ebevhan]

llvm/include/llvm/ADT/APFixedPoint.h

69

How would we be informed of whether the semantic can fit in the floating point type, then? We'd still need a method that does that. It just seems like there'd be extra steps.

[rjmccall]

llvm/include/llvm/ADT/APFixedPoint.h

69

You'd definitely still want a helper function like getUnscaledAccommodatingFloatSemantics() that you could just use consistently in these conversions. But it seems to me that there's virtue in having decomposed operations that seem independently useful, like being able to get the unscaled semantics, or being able to ask whether a floating-point type can accommodate the *scaled* range of a semantics.

[rjmccall]

If you disagree, I'm not going to insist, though.

[ebevhan]

llvm/include/llvm/ADT/APFixedPoint.h

69

If there was a direct use for such a semantic, it might be good to add it, but I don't see how it is.

[ebevhan]

So is this patch good to go then?

[rjmccall]

LGTM

llvm/include/llvm/ADT/APFixedPoint.h

 /// This is a class for abstracting various operations performed on fixed point
 /// types.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_APFIXEDPOINT_H
 #define LLVM_ADT_APFIXEDPOINT_H
 
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 
+class APFloat;
+struct fltSemantics;
+
 /// The fixed point semantics work similarly to fltSemantics. The width
 /// specifies the whole bit width of the underlying scaled integer (with padding
 /// if any). The scale represents the number of fractional bits in this type.
 /// When HasUnsignedPadding is true and this type is unsigned, the first bit
 /// in the value this represents is treated as padding.
 class FixedPointSemantics {
 public:
   FixedPointSemantics(unsigned Width, unsigned Scale, bool IsSigned,
public:
 
   /// Return the FixedPointSemantics that allows for calculating the full
   /// precision semantic that can precisely represent the precision and ranges
   /// of both input values. This does not compute the resulting semantics for a
   /// given binary operation.
   FixedPointSemantics
   getCommonSemantics(const FixedPointSemantics &Other) const;
 
+  /// Returns true if this fixed-point semantic with its value bits interpreted
+  /// as an integer can fit in the given floating point semantic without
+  /// overflowing to infinity.
+  /// For example, a signed 8-bit fixed-point semantic has a maximum and
+  /// minimum integer representation of 127 and -128, respectively. If both of
+  /// these values can be represented (possibly inexactly) in the floating
+  /// point semantic without overflowing, this returns true.
+  bool fitsInFloatSemantics(const fltSemantics &FloatSema) const;
+
   /// Return the FixedPointSemantics for an integer type.
   static FixedPointSemantics GetIntegerSemantics(unsigned Width,
                                                  bool IsSigned) {
     return FixedPointSemantics(Width, /*Scale=*/0, IsSigned,
                                /*IsSaturated=*/false,
                                /*HasUnsignedPadding=*/false);
   }
 
else
       return Val >> getScale();
   }
 
   /// Return the integral part of this fixed point number, rounded towards
   /// zero. The value is stored into an APSInt with the provided width and sign.
   /// If the overflow parameter is provided, and the integral value is not able
   /// to be fully stored in the provided width and sign, the overflow parameter
   /// is set to true.
-  ///
-  /// If the overflow parameter is provided, set this value to true or false to
-  /// indicate if this operation results in an overflow.
   APSInt convertToInt(unsigned DstWidth, bool DstSign,
                       bool *Overflow = nullptr) const;
 
+  /// Convert this fixed point number to a floating point value with the
+  /// provided semantics.
+  APFloat convertToFloat(const fltSemantics &FloatSema) const;
+
   void toString(SmallVectorImpl<char> &Str) const;
   std::string toString() const {
     SmallString<40> S;
     toString(S);
     return std::string(S.str());
   }
 
   // If LHS > RHS, return 1. If LHS == RHS, return 0. If LHS < RHS, return -1.
public:
   }
   bool operator<=(const APFixedPoint &Other) const {
     return compare(Other) <= 0;
   }
 
   static APFixedPoint getMax(const FixedPointSemantics &Sema);
   static APFixedPoint getMin(const FixedPointSemantics &Sema);
 
+  /// Given a floating point semantic, return the next floating point semantic
+  /// with a larger exponent and larger or equal mantissa.
+  static const fltSemantics *promoteFloatSemantics(const fltSemantics *S);
+
   /// Create an APFixedPoint with a value equal to that of the provided integer,
   /// and in the same semantics as the provided target semantics. If the value
   /// is not able to fit in the specified fixed point semantics, and the
   /// overflow parameter is provided, it is set to true.
   static APFixedPoint getFromIntValue(const APSInt &Value,
                                       const FixedPointSemantics &DstFXSema,
                                       bool *Overflow = nullptr);
 
+  /// Create an APFixedPoint with a value equal to that of the provided
+  /// floating point value, in the provided target semantics. If the value is
+  /// not able to fit in the specified fixed point semantics and the overflow
+  /// parameter is specified, it is set to true.
+  /// For NaN, the Overflow flag is always set. For +inf and -inf, if the
+  /// semantic is saturating, the value saturates. Otherwise, the Overflow flag
+  /// is set.
+  static APFixedPoint getFromFloatValue(const APFloat &Value,
+                                        const FixedPointSemantics &DstFXSema,
+                                        bool *Overflow = nullptr);
+
 private:
   APSInt Val;
   FixedPointSemantics Sema;
 };
 
 inline raw_ostream &operator<<(raw_ostream &OS, const APFixedPoint &FX) {
   OS << FX.toString();
   return OS;
 }
 
-}  // namespace llvm
+} // namespace llvm
 
 #endif

llvm/lib/Support/APFixedPoint.cpp

 //===- APFixedPoint.cpp - Fixed point constant handling ---------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 /// \file
 /// Defines the implementation for the fixed point number interface.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/APFixedPoint.h"
+#include "llvm/ADT/APFloat.h"
 
 namespace llvm {
 
 APFixedPoint APFixedPoint::convert(const FixedPointSemantics &DstSema,
                                    bool *Overflow) const {
   APSInt NewVal = Val;
   unsigned DstWidth = DstSema.getWidth();
   unsigned DstScale = DstSema.getScale();
APFixedPoint APFixedPoint::getMax(const FixedPointSemantics &Sema) {
   return APFixedPoint(Val, Sema);
 }
 
 APFixedPoint APFixedPoint::getMin(const FixedPointSemantics &Sema) {
   auto Val = APSInt::getMinValue(Sema.getWidth(), !Sema.isSigned());
   return APFixedPoint(Val, Sema);
 }
 
+bool FixedPointSemantics::fitsInFloatSemantics(
+    const fltSemantics &FloatSema) const {
+  // A fixed point semantic fits in a floating point semantic if the maximum
+  // and minimum values as integers of the fixed point semantic can fit in the
+  // floating point semantic.
+
+  // If these values do not fit, then a floating point rescaling of the true
+  // maximum/minimum value will not fit either, so the floating point semantic
+  // cannot be used to perform such a rescaling.
+
+  APSInt MaxInt = APFixedPoint::getMax(*this).getValue();
+  APFloat F(FloatSema);
+  APFloat::opStatus Status = F.convertFromAPInt(MaxInt, MaxInt.isSigned(),
+                                                APFloat::rmNearestTiesToAway);
+  if ((Status & APFloat::opOverflow) || !isSigned())
+    return !(Status & APFloat::opOverflow);
+
+  APSInt MinInt = APFixedPoint::getMin(*this).getValue();
+  Status = F.convertFromAPInt(MinInt, MinInt.isSigned(),
+                              APFloat::rmNearestTiesToAway);
+  return !(Status & APFloat::opOverflow);
+}
+
 FixedPointSemantics FixedPointSemantics::getCommonSemantics(
     const FixedPointSemantics &Other) const {
   unsigned CommonScale = std::max(getScale(), Other.getScale());
   unsigned CommonWidth =
       std::max(getIntegralBits(), Other.getIntegralBits()) + CommonScale;
 
   bool ResultIsSigned = isSigned() || Other.isSigned();
   bool ResultIsSaturated = isSaturated() || Other.isSaturated();
if (Result.isSigned() && !DstSign) {
       *Overflow = Result < DstMin || Result > DstMax;
     }
   }
 
   Result.setIsSigned(DstSign);
   return Result.extOrTrunc(DstWidth);
 }
 
+const fltSemantics *APFixedPoint::promoteFloatSemantics(const fltSemantics *S) {
+  if (S == &APFloat::BFloat())
+    return &APFloat::IEEEdouble();
+  else if (S == &APFloat::IEEEhalf())
+    return &APFloat::IEEEsingle();
+  else if (S == &APFloat::IEEEsingle())
+    return &APFloat::IEEEdouble();
+  else if (S == &APFloat::IEEEdouble())
+    return &APFloat::IEEEquad();
+  llvm_unreachable("Could not promote float type!");
+}
+
+APFloat APFixedPoint::convertToFloat(const fltSemantics &FloatSema) const {
+  // For some operations, rounding mode has an effect on the result, while
+  // other operations are lossless and should never result in rounding.
+  // To signify which these operations are, we define two rounding modes here.
+  APFloat::roundingMode RM = APFloat::rmNearestTiesToEven;
+  APFloat::roundingMode LosslessRM = APFloat::rmTowardZero;
+
+  // Make sure that we are operating in a type that works with this fixed-point
+  // semantic.
+  const fltSemantics *OpSema = &FloatSema;
+  while (!Sema.fitsInFloatSemantics(*OpSema))
+    OpSema = promoteFloatSemantics(OpSema);
+
+  // Convert the fixed point value bits as an integer. If the floating point
+  // value does not have the required precision, we will round according to the
+  // given mode.
+  APFloat Flt(*OpSema);
+  APFloat::opStatus S = Flt.convertFromAPInt(Val, Sema.isSigned(), RM);
+
+  // If we cared about checking for precision loss, we could look at this
+  // status.
+  (void)S;
+
+  // Scale down the integer value in the float to match the correct scaling
+  // factor.
+  APFloat ScaleFactor(std::pow(2, -(int)Sema.getScale()));
+  bool Ignored;
+  ScaleFactor.convert(*OpSema, LosslessRM, &Ignored);
+  Flt.multiply(ScaleFactor, LosslessRM);
+
+  if (OpSema != &FloatSema)
+    Flt.convert(FloatSema, RM, &Ignored);
+
+  return Flt;
+}
+
 APFixedPoint APFixedPoint::getFromIntValue(const APSInt &Value,
                                            const FixedPointSemantics &DstFXSema,
                                            bool *Overflow) {
   FixedPointSemantics IntFXSema = FixedPointSemantics::GetIntegerSemantics(
       Value.getBitWidth(), Value.isSigned());
   return APFixedPoint(Value, IntFXSema).convert(DstFXSema, Overflow);
 }
 
-}  // namespace clang
+APFixedPoint
+APFixedPoint::getFromFloatValue(const APFloat &Value,
+                                const FixedPointSemantics &DstFXSema,
+                                bool *Overflow) {
+  // For some operations, rounding mode has an effect on the result, while
+  // other operations are lossless and should never result in rounding.
+  // To signify which these operations are, we define two rounding modes here,
+  // even though they are the same mode.
+  APFloat::roundingMode RM = APFloat::rmTowardZero;
+  APFloat::roundingMode LosslessRM = APFloat::rmTowardZero;
+
+  const fltSemantics &FloatSema = Value.getSemantics();
+
+  if (Value.isNaN()) {
+    // Handle NaN immediately.
+    if (Overflow)
+      *Overflow = true;
+    return APFixedPoint(DstFXSema);
+  }
+
+  // Make sure that we are operating in a type that works with this fixed-point
+  // semantic.
+  const fltSemantics *OpSema = &FloatSema;
+  while (!DstFXSema.fitsInFloatSemantics(*OpSema))
+    OpSema = promoteFloatSemantics(OpSema);
+
+  APFloat Val = Value;
+
+  bool Ignored;
+  if (&FloatSema != OpSema)
+    Val.convert(*OpSema, LosslessRM, &Ignored);
+
+  // Scale up the float so that the 'fractional' part of the mantissa ends up in
+  // the integer range instead. Rounding mode is irrelevant here.
+  // It is fine if this overflows to infinity even for saturating types,
+  // since we will use floating point comparisons to check for saturation.
+  APFloat ScaleFactor(std::pow(2, DstFXSema.getScale()));
+  ScaleFactor.convert(*OpSema, LosslessRM, &Ignored);
+  Val.multiply(ScaleFactor, LosslessRM);
+
+  // Convert to the integral representation of the value. This rounding mode
+  // is significant.
+  APSInt Res(DstFXSema.getWidth(), !DstFXSema.isSigned());
+  Val.convertToInteger(Res, RM, &Ignored);
+
+  // Round the integral value and scale back. This makes the
+  // overflow calculations below work properly. If we do not round here,
+  // we risk checking for overflow with a value that is outside the
+  // representable range of the fixed-point semantic even though no overflow
+  // would occur had we rounded first.
+  ScaleFactor = APFloat(std::pow(2, -(int)DstFXSema.getScale()));
+  ScaleFactor.convert(*OpSema, LosslessRM, &Ignored);
+  Val.roundToIntegral(RM);
+  Val.multiply(ScaleFactor, LosslessRM);
+
+  // Check for overflow/saturation by checking if the floating point value
+  // is outside the range representable by the fixed-point value.
+  APFloat FloatMax = getMax(DstFXSema).convertToFloat(*OpSema);
+  APFloat FloatMin = getMin(DstFXSema).convertToFloat(*OpSema);
+  bool Overflowed = false;
+  if (DstFXSema.isSaturated()) {
+    if (Val > FloatMax)
+      Res = getMax(DstFXSema).getValue();
+    else if (Val < FloatMin)
+      Res = getMin(DstFXSema).getValue();
+  } else
+    Overflowed = Val > FloatMax || Val < FloatMin;
+
+  if (Overflow)
+    *Overflow = Overflowed;
+
+  return APFixedPoint(Res, DstFXSema);
+}
+
+} // namespace llvm

llvm/unittests/ADT/APFixedPointTest.cpp

 //===- unittests/ADT/FixedPointTest.cpp -- fixed point number tests -----===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/APFixedPoint.h"
+#include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APSInt.h"
 #include "gtest/gtest.h"
 
 using llvm::APFixedPoint;
-using llvm::FixedPointSemantics;
+using llvm::APFloat;
 using llvm::APInt;
 using llvm::APSInt;
+using llvm::FixedPointSemantics;
 
 namespace {
 
 FixedPointSemantics Saturated(FixedPointSemantics Sema) {
   Sema.setSaturated(true);
   return Sema;
 }
 
TEST(FixedPoint, ModularWrapAround) {
   Val = APFixedPoint(-(1 << 15), getAccumSema());
   ASSERT_EQ(Val.convert(getUAccumSema()).getValue(), 65535ULL << 16);
 
   Val = APFixedPoint(-(1ULL << 31), getLAccumSema());
   ASSERT_EQ(Val.convert(getULAccumSema()).getValue().getZExtValue(),
             4294967295ULL << 32);
 }
 
+enum OvfKind { MinSat, MaxSat };
+
+void CheckFloatToFixedConversion(APFloat &Val, const FixedPointSemantics &Sema,
+                                 int64_t ExpectedNonSat) {
+  bool Ovf;
+  ASSERT_EQ(APFixedPoint::getFromFloatValue(Val, Sema, &Ovf).getValue(),
+            ExpectedNonSat);
+  ASSERT_EQ(Ovf, false);
+  ASSERT_EQ(
+      APFixedPoint::getFromFloatValue(Val, Saturated(Sema), &Ovf).getValue(),
+      ExpectedNonSat);
+  ASSERT_EQ(Ovf, false);
+}
+
+void CheckFloatToFixedConversion(APFloat &Val, const FixedPointSemantics &Sema,
+                                 OvfKind ExpectedOvf) {
+  bool Ovf;
+  (void)APFixedPoint::getFromFloatValue(Val, Sema, &Ovf);
+  ASSERT_EQ(Ovf, true);
+  ASSERT_EQ(
+      APFixedPoint::getFromFloatValue(Val, Saturated(Sema), &Ovf).getValue(),
+      (ExpectedOvf == MinSat ? APFixedPoint::getMin(Sema)
+                             : APFixedPoint::getMax(Sema))
+          .getValue());
+  ASSERT_EQ(Ovf, false);
+}
+
+TEST(FixedPoint, FloatToFixed) {
+  APFloat Val(0.0f);
+
+  // Simple exact fraction
+  Val = APFloat(0.75f);
+  CheckFloatToFixedConversion(Val, getSAccumSema(), 3ULL << 5);
+  CheckFloatToFixedConversion(Val, getAccumSema(),  3ULL << 13);
+  CheckFloatToFixedConversion(Val, getLAccumSema(), 3ULL << 29);
+
+  CheckFloatToFixedConversion(Val, getUSAccumSema(), 3ULL << 6);
+  CheckFloatToFixedConversion(Val, getUAccumSema(),  3ULL << 14);
+  CheckFloatToFixedConversion(Val, getULAccumSema(), 3ULL << 30);
+
+  CheckFloatToFixedConversion(Val, getSFractSema(), 3ULL << 5);
+  CheckFloatToFixedConversion(Val, getFractSema(),  3ULL << 13);
+  CheckFloatToFixedConversion(Val, getLFractSema(), 3ULL << 29);
+
+  CheckFloatToFixedConversion(Val, getUSFractSema(), 3ULL << 6);
+  CheckFloatToFixedConversion(Val, getUFractSema(),  3ULL << 14);
+  CheckFloatToFixedConversion(Val, getULFractSema(), 3ULL << 30);
+
+  // Simple negative exact fraction
+  Val = APFloat(-0.75f);
+  CheckFloatToFixedConversion(Val, getSAccumSema(), -3ULL << 5);
+  CheckFloatToFixedConversion(Val, getAccumSema(),  -3ULL << 13);
+  CheckFloatToFixedConversion(Val, getLAccumSema(), -3ULL << 29);
+
+  CheckFloatToFixedConversion(Val, getUSAccumSema(), MinSat);
+  CheckFloatToFixedConversion(Val, getUAccumSema(),  MinSat);
+  CheckFloatToFixedConversion(Val, getULAccumSema(), MinSat);
+
+  CheckFloatToFixedConversion(Val, getSFractSema(), -3ULL << 5);
+  CheckFloatToFixedConversion(Val, getFractSema(),  -3ULL << 13);
+  CheckFloatToFixedConversion(Val, getLFractSema(), -3ULL << 29);
+
+  CheckFloatToFixedConversion(Val, getUSFractSema(), MinSat);
+  CheckFloatToFixedConversion(Val, getUFractSema(),  MinSat);
+  CheckFloatToFixedConversion(Val, getULFractSema(), MinSat);
+
+  // Highly precise fraction
+  Val = APFloat(0.999999940395355224609375f);
+  CheckFloatToFixedConversion(Val, getSAccumSema(), 0x7FULL);
+  CheckFloatToFixedConversion(Val, getAccumSema(),  0x7FFFULL);
+  CheckFloatToFixedConversion(Val, getLAccumSema(), 0xFFFFFFULL << 7);
+
+  CheckFloatToFixedConversion(Val, getUSAccumSema(), 0xFFULL);
+  CheckFloatToFixedConversion(Val, getUAccumSema(),  0xFFFFULL);
+  CheckFloatToFixedConversion(Val, getULAccumSema(), 0xFFFFFFULL << 8);
+
+  CheckFloatToFixedConversion(Val, getSFractSema(), 0x7FULL);
+  CheckFloatToFixedConversion(Val, getFractSema(),  0x7FFFULL);
+  CheckFloatToFixedConversion(Val, getLFractSema(), 0xFFFFFFULL << 7);
+
+  CheckFloatToFixedConversion(Val, getUSFractSema(), 0xFFULL);
+  CheckFloatToFixedConversion(Val, getUFractSema(),  0xFFFFULL);
+  CheckFloatToFixedConversion(Val, getULFractSema(), 0xFFFFFFULL << 8);
+
+  // Integral and fraction
+  Val = APFloat(17.99609375f);
+  CheckFloatToFixedConversion(Val, getSAccumSema(), 0x11FFULL >> 1);
+  CheckFloatToFixedConversion(Val, getAccumSema(),  0x11FFULL << 7);
+  CheckFloatToFixedConversion(Val, getLAccumSema(), 0x11FFULL << 23);
+
+  CheckFloatToFixedConversion(Val, getUSAccumSema(), 0x11FFULL);
+  CheckFloatToFixedConversion(Val, getUAccumSema(),  0x11FFULL << 8);
+  CheckFloatToFixedConversion(Val, getULAccumSema(), 0x11FFULL << 24);
+
+  CheckFloatToFixedConversion(Val, getSFractSema(), MaxSat);
+  CheckFloatToFixedConversion(Val, getFractSema(),  MaxSat);
+  CheckFloatToFixedConversion(Val, getLFractSema(), MaxSat);
+
+  CheckFloatToFixedConversion(Val, getUSFractSema(), MaxSat);
+  CheckFloatToFixedConversion(Val, getUFractSema(),  MaxSat);
+  CheckFloatToFixedConversion(Val, getULFractSema(), MaxSat);
+
+  // Negative integral and fraction
+  Val = APFloat(-17.99609375f);
+  CheckFloatToFixedConversion(Val, getSAccumSema(), -0x11FELL >> 1);
+  CheckFloatToFixedConversion(Val, getAccumSema(),  -0x11FFULL << 7);
+  CheckFloatToFixedConversion(Val, getLAccumSema(), -0x11FFULL << 23);
+
+  CheckFloatToFixedConversion(Val, getUSAccumSema(), MinSat);
+  CheckFloatToFixedConversion(Val, getUAccumSema(),  MinSat);
+  CheckFloatToFixedConversion(Val, getULAccumSema(), MinSat);
+
+  CheckFloatToFixedConversion(Val, getSFractSema(), MinSat);
+  CheckFloatToFixedConversion(Val, getFractSema(),  MinSat);
+  CheckFloatToFixedConversion(Val, getLFractSema(), MinSat);
+
+  CheckFloatToFixedConversion(Val, getUSFractSema(), MinSat);
+  CheckFloatToFixedConversion(Val, getUFractSema(),  MinSat);
+  CheckFloatToFixedConversion(Val, getULFractSema(), MinSat);
+
+  // Very large value
+  Val = APFloat(1.0e38f);
+  CheckFloatToFixedConversion(Val, getSAccumSema(), MaxSat);
+  CheckFloatToFixedConversion(Val, getAccumSema(),  MaxSat);
+  CheckFloatToFixedConversion(Val, getLAccumSema(), MaxSat);
+
+  CheckFloatToFixedConversion(Val, getUSAccumSema(), MaxSat);
+  CheckFloatToFixedConversion(Val, getUAccumSema(),  MaxSat);
+  CheckFloatToFixedConversion(Val, getULAccumSema(), MaxSat);
+
+  CheckFloatToFixedConversion(Val, getSFractSema(), MaxSat);
+  CheckFloatToFixedConversion(Val, getFractSema(),  MaxSat);
+  CheckFloatToFixedConversion(Val, getLFractSema(), MaxSat);
+
+  CheckFloatToFixedConversion(Val, getUSFractSema(), MaxSat);
+  CheckFloatToFixedConversion(Val, getUFractSema(),  MaxSat);
+  CheckFloatToFixedConversion(Val, getULFractSema(), MaxSat);
+
+  // Very small value
+  Val = APFloat(1.0e-38f);
+  CheckFloatToFixedConversion(Val, getSAccumSema(), 0);
+  CheckFloatToFixedConversion(Val, getAccumSema(),  0);
+  CheckFloatToFixedConversion(Val, getLAccumSema(), 0);
+
+  CheckFloatToFixedConversion(Val, getUSAccumSema(), 0);
+  CheckFloatToFixedConversion(Val, getUAccumSema(),  0);
+  CheckFloatToFixedConversion(Val, getULAccumSema(), 0);
+
+  CheckFloatToFixedConversion(Val, getSFractSema(), 0);
+  CheckFloatToFixedConversion(Val, getFractSema(),  0);
+  CheckFloatToFixedConversion(Val, getLFractSema(), 0);
+
+  CheckFloatToFixedConversion(Val, getUSFractSema(), 0);
+  CheckFloatToFixedConversion(Val, getUFractSema(),  0);
+  CheckFloatToFixedConversion(Val, getULFractSema(), 0);
+
+  // Half conversion
+  Val = APFloat(0.99951171875f);
+  bool Ignored;
+  Val.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven, &Ignored);
+
+  CheckFloatToFixedConversion(Val, getSAccumSema(), 0x7FULL);
+  CheckFloatToFixedConversion(Val, getAccumSema(),  0x7FFULL << 4);
+  CheckFloatToFixedConversion(Val, getLAccumSema(), 0x7FFULL << 20);
+
+  CheckFloatToFixedConversion(Val, getUSAccumSema(), 0xFFULL);
+  CheckFloatToFixedConversion(Val, getUAccumSema(),  0xFFEULL << 4);
+  CheckFloatToFixedConversion(Val, getULAccumSema(), 0xFFEULL << 20);
+
+  CheckFloatToFixedConversion(Val, getSFractSema(), 0x7FULL);
+  CheckFloatToFixedConversion(Val, getFractSema(),  0x7FFULL << 4);
+  CheckFloatToFixedConversion(Val, getLFractSema(), 0x7FFULL << 20);
+
+  CheckFloatToFixedConversion(Val, getUSFractSema(), 0xFFULL);
+  CheckFloatToFixedConversion(Val, getUFractSema(),  0xFFEULL << 4);
+  CheckFloatToFixedConversion(Val, getULFractSema(), 0xFFEULL << 20);
+}
+
+void CheckFixedToFloatConversion(int64_t Val, const FixedPointSemantics &Sema,
+                                 float Result) {
+  APFixedPoint FXVal(Val, Sema);
+  APFloat APRes(Result);
+  ASSERT_EQ(FXVal.convertToFloat(APFloat::IEEEsingle()), APRes);
+}
+
+void CheckFixedToHalfConversion(int64_t Val, const FixedPointSemantics &Sema,
+                                float Result) {
+  APFixedPoint FXVal(Val, Sema);
+  APFloat APRes(Result);
+  bool Ignored;
+  APRes.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven, &Ignored);
+  ASSERT_EQ(FXVal.convertToFloat(APFloat::IEEEhalf()), APRes);
+}
+
+TEST(FixedPoint, FixedToFloat) {
+  int64_t Val = 0x1ULL;
+  CheckFixedToFloatConversion(Val, getSAccumSema(), 0.0078125f);
+  CheckFixedToFloatConversion(Val, getFractSema(),  0.000030517578125f);
+  CheckFixedToFloatConversion(Val, getAccumSema(),  0.000030517578125f);
+  CheckFixedToFloatConversion(Val, getLFractSema(),
+                              0.0000000004656612873077392578125f);
+
+  CheckFixedToFloatConversion(Val, getUSAccumSema(), 0.00390625f);
+  CheckFixedToFloatConversion(Val, getUFractSema(),  0.0000152587890625f);
+  CheckFixedToFloatConversion(Val, getUAccumSema(),  0.0000152587890625f);
+  CheckFixedToFloatConversion(Val, getULFractSema(),
+                              0.00000000023283064365386962890625f);
+
+  Val = 0x7FULL;
+  CheckFixedToFloatConversion(Val, getSAccumSema(), 0.9921875f);
+  CheckFixedToFloatConversion(Val, getFractSema(),  0.003875732421875f);
+  CheckFixedToFloatConversion(Val, getAccumSema(),  0.003875732421875f);
+  CheckFixedToFloatConversion(Val, getLFractSema(),
+                              0.0000000591389834880828857421875f);
+
+  CheckFixedToFloatConversion(Val, getUSAccumSema(), 0.49609375f);
+  CheckFixedToFloatConversion(Val, getUFractSema(),  0.0019378662109375f);
+  CheckFixedToFloatConversion(Val, getUAccumSema(),  0.0019378662109375f);
+  CheckFixedToFloatConversion(Val, getULFractSema(),
+                              0.00000002956949174404144287109375f);
+
+  Val = -0x1ULL;
+  CheckFixedToFloatConversion(Val, getSAccumSema(), -0.0078125f);
+  CheckFixedToFloatConversion(Val, getFractSema(),  -0.000030517578125f);
+  CheckFixedToFloatConversion(Val, getAccumSema(),  -0.000030517578125f);
+  CheckFixedToFloatConversion(Val, getLFractSema(),
+                              -0.0000000004656612873077392578125f);
+
+
+  CheckFixedToFloatConversion(-0x80ULL,       getSAccumSema(), -1.0f);
+  CheckFixedToFloatConversion(-0x8000ULL,     getFractSema(),  -1.0f);
+  CheckFixedToFloatConversion(-0x8000ULL,     getAccumSema(),  -1.0f);
+  CheckFixedToFloatConversion(-0x80000000ULL, getLFractSema(), -1.0f);
+
+  Val = 0xAFAULL;
+  CheckFixedToFloatConversion(Val, getSAccumSema(), 21.953125f);
+  CheckFixedToFloatConversion(Val, getFractSema(),  0.08575439453125f);
+  CheckFixedToFloatConversion(Val, getAccumSema(),  0.08575439453125f);
+  CheckFixedToFloatConversion(Val, getLFractSema(),
+                              0.000001308508217334747314453125f);
+
+  CheckFixedToFloatConversion(Val, getUSAccumSema(), 10.9765625f);
+  CheckFixedToFloatConversion(Val, getUFractSema(),  0.042877197265625f);
+  CheckFixedToFloatConversion(Val, getUAccumSema(),  0.042877197265625f);
+  CheckFixedToFloatConversion(Val, getULFractSema(),
+                              0.0000006542541086673736572265625f);
+
+  Val = -0xAFAULL;
+  CheckFixedToFloatConversion(Val, getSAccumSema(), -21.953125f);
+  CheckFixedToFloatConversion(Val, getFractSema(),  -0.08575439453125f);
+  CheckFixedToFloatConversion(Val, getAccumSema(),  -0.08575439453125f);
+  CheckFixedToFloatConversion(Val, getLFractSema(),
+                              -0.000001308508217334747314453125f);
+
+  Val = 0x40000080ULL;
+  CheckFixedToFloatConversion(Val, getAccumSema(),  32768.00390625f);
+  CheckFixedToFloatConversion(Val, getLFractSema(),
+                              0.500000059604644775390625f);
+
+  CheckFixedToFloatConversion(Val, getUAccumSema(),  16384.001953125f);
+  CheckFixedToFloatConversion(Val, getULFractSema(),
+                              0.2500000298023223876953125f);
+
+  Val = 0x40000040ULL;
+  CheckFixedToFloatConversion(Val, getAccumSema(),  32768.0f);
+  CheckFixedToFloatConversion(Val, getLFractSema(), 0.5f);
+
+  CheckFixedToFloatConversion(Val, getUAccumSema(),  16384.0f);
+  CheckFixedToFloatConversion(Val, getULFractSema(), 0.25f);
+
+  Val = 0x7FF0ULL;
+  CheckFixedToHalfConversion(Val, getAccumSema(), 0.99951171875f);
+  CheckFixedToHalfConversion(Val, getLFractSema(), 0.000015251338481903076171875f);
+
+  CheckFixedToHalfConversion(Val, getUAccumSema(), 0.499755859375f);
+  CheckFixedToHalfConversion(Val, getULFractSema(), 0.0000076256692409515380859375f);
+}
+
 } // namespace