[Fixed Point Arithmetic] Conversion between Fixed Point and Floating Point Numbers

[leonardchan]

Summary

This patch has the implementation and tests for converting between fixed point and floating point numbers.

The conversion process is simply dividing the fixed point value, as an integer, by 2^(# of fractional bits) as a float.

float f = (float)2.5k;
assert(f > 2.4999 && f < 2.5001);  // High precision since the fractional value can be evenly
                                                          // represented.

[leonardchan]

formatting

[scanon]

IIRC the optimization of divide-by-power-of-two --> multiply-by-inverse does not occur at -O0, so it would be better to multiply by 2^(-fbits) instead.

[leonardchan]

The logic in this patch is moved to https://reviews.llvm.org/D48456

include/clang/AST/OperationKinds.def

 ///    short _Accum a = 1.2k;
 ///    (short _Fract) a
 CAST_OPERATION(FixedPointCast)
 
 /// CK_IntegralToFixedPoint - Integral to fixed point.
 ///    (short _Accum) i
 CAST_OPERATION(IntegralToFixedPoint)
 
+/// CK_FixedPointToFloating - Fixed point to floating point.
+///    (float) 2.5hk
+CAST_OPERATION(FixedPointToFloating)
+
 /// CK_FloatingToIntegral - Floating point to integral.  Rounds
 /// towards zero, discarding any fractional component.
 ///    (int) f
 CAST_OPERATION(FloatingToIntegral)
 
 /// CK_FloatingToBoolean - Floating point to boolean.
 ///    (bool) f
 CAST_OPERATION(FloatingToBoolean)

include/clang/Basic/DiagnosticSemaKinds.td

def warn_side_effects_typeid : Warning<
   "operand to 'typeid'">, InGroup<PotentiallyEvaluatedExpression>;
 def warn_unused_result : Warning<
   "ignoring return value of function declared with %0 attribute">,
   InGroup<UnusedResult>;
 def warn_unused_volatile : Warning<
   "expression result unused; assign into a variable to force a volatile load">,
   InGroup<DiagGroup<"unused-volatile-lvalue">>;
 
+def err_typecheck_fixed_point_cast : Error<"Cannot convert fixed point type to %0">;
+
 def ext_cxx14_attr : Extension<
   "use of the %0 attribute is a C++14 extension">, InGroup<CXX14>;
 def ext_cxx17_attr : Extension<
   "use of the %0 attribute is a C++17 extension">, InGroup<CXX17>;
 
 def warn_unused_comparison : Warning<
   "%select{equality|inequality|relational|three-way}0 comparison result unused">,
   InGroup<UnusedComparison>;

lib/AST/Expr.cpp

bool CastExpr::CastConsistency() const {
   case CK_ARCConsumeObject:
   case CK_ARCReclaimReturnedObject:
   case CK_ARCExtendBlockObject:
   case CK_ZeroToOCLEvent:
   case CK_ZeroToOCLQueue:
   case CK_IntToOCLSampler:
   case CK_IntegralToFixedPoint:
   case CK_FixedPointCast:
+  case CK_FixedPointToFloating:
     assert(!getType()->isBooleanType() && "unheralded conversion to bool");
     goto CheckNoBasePath;
 
   case CK_Dependent:
   case CK_LValueToRValue:
   case CK_NoOp:
   case CK_AtomicToNonAtomic:
   case CK_NonAtomicToAtomic:

lib/AST/ExprConstant.cpp

bool IntExprEvaluator::VisitCastExpr(const CastExpr *E) {
   QualType SrcType = SubExpr->getType();
 
   switch (E->getCastKind()) {
   case CK_FixedPointCast:
     llvm_unreachable("CK_FixedPointCast");  // TODO
   case CK_IntegralToFixedPoint:
     llvm_unreachable(
         "IntExprEvaluator::VisitCastExpr CK_IntegralToFixedPoint");  // TODO
+  case CK_FixedPointToFloating:
+    llvm_unreachable("CK_FixedPointCast");  // TODO
   case CK_BaseToDerived:
   case CK_DerivedToBase:
   case CK_UncheckedDerivedToBase:
   case CK_Dynamic:
   case CK_ToUnion:
   case CK_ArrayToPointerDecay:
   case CK_FunctionToPointerDecay:
   case CK_NullToPointer:

 bool ComplexExprEvaluator::VisitCastExpr(const CastExpr *E) {
 
   switch (E->getCastKind()) {
   case CK_FixedPointCast:
     llvm_unreachable("CK_FixedPointCast");  // TODO
   case CK_IntegralToFixedPoint:
     llvm_unreachable(
         "ComplexExprEvaluator::VisitCastExpr CK_IntegralToFixedPoint");  // TODO
+  case CK_FixedPointToFloating:
+    llvm_unreachable("CK_FixedPointCast");  // TODO
   case CK_BitCast:
   case CK_BaseToDerived:
   case CK_DerivedToBase:
   case CK_UncheckedDerivedToBase:
   case CK_Dynamic:
   case CK_ToUnion:
   case CK_ArrayToPointerDecay:
   case CK_FunctionToPointerDecay:

lib/CodeGen/CGExpr.cpp

 /// cast from scalar to union.
 LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) {
   switch (E->getCastKind()) {
   case CK_FixedPointCast:
     llvm_unreachable("CK_FixedPointCast");  // TODO
   case CK_IntegralToFixedPoint:
     llvm_unreachable(
         "CodeGenFunction::EmitCastLValue CK_IntegralToFixedPoint");  // TODO
+  case CK_FixedPointToFloating:
+    llvm_unreachable("CK_FixedPointToFloating");  // TODO
   case CK_ToVoid:
   case CK_BitCast:
   case CK_ArrayToPointerDecay:
   case CK_FunctionToPointerDecay:
   case CK_NullToMemberPointer:
   case CK_NullToPointer:
   case CK_IntegralToPointer:
   case CK_PointerToIntegral:

lib/CodeGen/CGExprAgg.cpp

void AggExprEmitter::VisitCastExpr(CastExpr *E) {
   if (const auto *ECE = dyn_cast<ExplicitCastExpr>(E))
     CGF.CGM.EmitExplicitCastExprType(ECE, &CGF);
   switch (E->getCastKind()) {
   case CK_FixedPointCast:
     llvm_unreachable("CK_FixedPointCast");  // TODO
   case CK_IntegralToFixedPoint:
     llvm_unreachable(
         "AggExprEmitter::VisitCastExpr CK_IntegralToFixedPoint");  // TODO
+  case CK_FixedPointToFloating:
+    llvm_unreachable("CK_FixedPointToFloating");  // TODO
   case CK_Dynamic: {
     // FIXME: Can this actually happen? We have no test coverage for it.
     assert(isa<CXXDynamicCastExpr>(E) && "CK_Dynamic without a dynamic_cast?");
     LValue LV = CGF.EmitCheckedLValue(E->getSubExpr(),
                                       CodeGenFunction::TCK_Load);
     // FIXME: Do we also need to handle property references here?
     if (LV.isSimple())
       CGF.EmitDynamicCast(LV.getAddress(), cast<CXXDynamicCastExpr>(E));

lib/CodeGen/CGExprComplex.cpp

 ComplexPairTy ComplexExprEmitter::EmitCast(CastKind CK, Expr *Op,
                                            QualType DestTy) {
   switch (CK) {
   case CK_FixedPointCast:
     llvm_unreachable("CK_FixedPointCast");  // TODO
   case CK_IntegralToFixedPoint:
     llvm_unreachable(
         "ComplexExprEmitter::EmitCast CK_IntegralToFixedPoint");  // TODO
+  case CK_FixedPointToFloating:
+    llvm_unreachable("CK_FixedPointToFloating");  // TODO
   case CK_Dependent: llvm_unreachable("dependent cast kind in IR gen!");
 
   // Atomic to non-atomic casts may be more than a no-op for some platforms and
   // for some types.
   case CK_AtomicToNonAtomic:
   case CK_NonAtomicToAtomic:
   case CK_NoOp:
   case CK_LValueToRValue:

lib/CodeGen/CGExprConstant.cpp

public:
   }
 
   llvm::Constant *VisitCastExpr(CastExpr *E, QualType destType) {
     if (const auto *ECE = dyn_cast<ExplicitCastExpr>(E))
       CGM.EmitExplicitCastExprType(ECE, Emitter.CGF);
     Expr *subExpr = E->getSubExpr();
 
     switch (E->getCastKind()) {
+    case CK_FixedPointToFloating:
+      llvm_unreachable("Unimplemented logic for CK_FixedPointToFloating");
     case CK_FixedPointCast:
       llvm_unreachable("CK_FixedPointCast");  // TODO
     case CK_IntegralToFixedPoint:
       llvm_unreachable("VisitCastExpr CK_IntegralToFixedPoint");  // TODO
     case CK_ToUnion: {
       // GCC cast to union extension
       assert(E->getType()->isUnionType() &&
              "Destination type is not union type!");

lib/CodeGen/CGExprScalar.cpp

Value *ScalarExprEmitter::VisitCastExpr(CastExpr *CE) {
   case CK_IntegralToFixedPoint: {
     assert(DestTy->isFixedPointType());
     assert(E->getType()->isIntegerType());
     return Builder.CreateShl(
         EmitScalarConversion(Visit(E), E->getType(), DestTy, CE->getExprLoc()),
         getFixedPointFBits(DestTy), "int_to_fixed");
   }
 
+  case CK_FixedPointToFloating: {
+    assert(DestTy->isFloatingType());
+    assert(E->getType()->isFixedPointType());
+    unsigned fbits = getFixedPointFBits(E->getType());
+    return Builder.CreateFDiv(
+        EmitScalarConversion(Visit(E), E->getType(), DestTy, CE->getExprLoc()),
+        llvm::ConstantFP::get(CGF.CGM.FloatTy, (1ULL << fbits) * 1.0));
+  }
+
   case CK_IntegralCast:
   case CK_IntegralToFloating:
   case CK_FloatingToIntegral:
   case CK_FloatingCast:
     return EmitScalarConversion(Visit(E), E->getType(), DestTy,
                                 CE->getExprLoc());
   case CK_BooleanToSignedIntegral:
     return EmitScalarConversion(Visit(E), E->getType(), DestTy,

lib/Edit/RewriteObjCFoundationAPI.cpp

static bool rewriteToNumericBoxedExpression(const ObjCMessageExpr *Msg,
   if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Arg)) {
     switch (ICE->getCastKind()) {
     case CK_FixedPointCast:
       llvm_unreachable(
           "rewriteToNumericBoxedExpression CK_FixedPointCast");  // TODO
     case CK_IntegralToFixedPoint:
       llvm_unreachable(
           "rewriteToNumericBoxedExpression CK_IntegralToFixedPoint");  // TODO
+    case CK_FixedPointToFloating:
+      llvm_unreachable(
+          "Unimplemented logic for CK_FixedPointToFloating");
     case CK_LValueToRValue:
     case CK_NoOp:
     case CK_UserDefinedConversion:
       break;
 
     case CK_IntegralCast: {
       if (MK == NSAPI::NSNumberWithBool && OrigTy->isBooleanType())
         break;

lib/Sema/SemaCast.cpp

if (Self.getLangOpts().allowsNonTrivialObjCLifetimeQualifiers()) {
     else if (!Self.CheckObjCARCUnavailableWeakConversion(DestType, SrcType)) {
       Self.Diag(SrcExpr.get()->getLocStart(), 
                 diag::err_arc_convesion_of_weak_unavailable)
         << 1 << SrcType << DestType << SrcExpr.get()->getSourceRange();
       SrcExpr = ExprError();
       return;
     }
   }
-  
+  if (SrcType->isFixedPointType()) {
+    switch (DestType->getScalarTypeKind()) {
+      default:
+        Self.Diag(SrcExpr.get()->getLocStart(),
+                  diag::err_typecheck_fixed_point_cast)
+            << DestType;
+        return;
+      case Type::STK_Floating:
+      case Type::STK_Integral:
+      case Type::STK_FixedPoint:
+        break;  // Allow
+    }
+  }
+  
   DiagnoseCastOfObjCSEL(Self, SrcExpr, DestType);
   DiagnoseCallingConvCast(Self, SrcExpr, DestType, OpRange);
   DiagnoseBadFunctionCast(Self, SrcExpr, DestType);
   Kind = Self.PrepareScalarCast(SrcExpr, DestType);
   if (SrcExpr.isInvalid())
     return;
 
   if (Kind == CK_BitCast)

lib/Sema/SemaExpr.cpp

static QualType handleIntToFloatConversion(Sema &S, ExprResult &FloatExpr,
   // float -> _Complex float
   if (ConvertFloat)
     FloatExpr = S.ImpCastExprToType(FloatExpr.get(), result,
                                     CK_FloatingRealToComplex);
 
   return result;
 }
 
+/// \brief Handle arithmetic conversion from fixed point to floating.  Helper
+/// function of UsualArithmeticConversions()
+static QualType handleFixedPointToFloatConversion(Sema &S,
+                                                  ExprResult &FloatExpr,
+                                                  ExprResult &FixedPointExpr,
+                                                  QualType FloatTy,
+                                                  QualType FixedPointTy) {
+  assert(FloatTy->isFloatingType());
+  assert(FixedPointTy->isFixedPointType());
+
+  FixedPointExpr = S.ImpCastExprToType(FixedPointExpr.get(), FloatTy,
+                                       CK_FixedPointToFloating);
+  return FloatTy;
+}
+
 /// \brief Handle arithmethic conversion with floating point types.  Helper
 /// function of UsualArithmeticConversions()
 static QualType handleFloatConversion(Sema &S, ExprResult &LHS,
                                       ExprResult &RHS, QualType LHSType,
                                       QualType RHSType, bool IsCompAssign) {
   bool LHSFloat = LHSType->isRealFloatingType();
   bool RHSFloat = RHSType->isRealFloatingType();
 
if (LHSFloat && RHSFloat) {
     return RHSType;
   }
 
   if (LHSFloat) {
     // Half FP has to be promoted to float unless it is natively supported
     if (LHSType->isHalfType() && !S.getLangOpts().NativeHalfType)
       LHSType = S.Context.FloatTy;
 
+    if (RHSType->isFixedPointType()) {
+      return handleFixedPointToFloatConversion(S, LHS, RHS, LHSType, RHSType);
+    }
+
     return handleIntToFloatConversion(S, LHS, RHS, LHSType, RHSType,
                                       /*convertFloat=*/!IsCompAssign,
                                       /*convertInt=*/ true);
   }
   assert(RHSFloat);
+
+  if (LHSType->isFixedPointType()) {
+    return handleFixedPointToFloatConversion(S, RHS, LHS, RHSType, LHSType);
+  }
+
   return handleIntToFloatConversion(S, RHS, LHS, RHSType, LHSType,
                                     /*convertInt=*/ true,
                                     /*convertFloat=*/!IsCompAssign);
 }
 
 /// \brief Diagnose attempts to convert between __float128 and long double if
 /// there is no support for such conversion. Helper function of
 /// UsualArithmeticConversions().
handleIntegerConversion<doIntegralCast, doComplexIntegralCast>
       (S, LHS, RHS, LHSType, RHSEltType, IsCompAssign);
   QualType ComplexType = S.Context.getComplexType(ScalarType);
   
   if (!IsCompAssign)
     LHS = S.ImpCastExprToType(LHS.get(), ComplexType,
                               CK_IntegralRealToComplex);
   return ComplexType;
 }
+
 /// \brief Handle arithmetic conversion from integer to fixed point.  Helper
 /// function of UsualArithmeticConversions()
 static QualType handleIntToFixedPointConversion(Sema &S,
                                                 ExprResult &FixedPointExpr,
                                                 ExprResult &IntExpr,
                                                 QualType FixedPointTy,
                                                 QualType IntTy) {
   assert(IntTy->isIntegerType());
case Type::STK_ObjCObjectPointer:
     case Type::STK_FloatingComplex:
     case Type::STK_IntegralComplex:
     case Type::STK_MemberPointer:
     case Type::STK_FixedPoint:
       llvm_unreachable("illegal cast from pointer");
     }
     llvm_unreachable("Should have returned before this");
 
+  case Type::STK_FixedPoint: {
+    switch (DestTy->getScalarTypeKind()) {
+      default:
+        llvm_unreachable("Unable to convert from fixed point type");
+      case Type::STK_Integral:
+        llvm_unreachable(
+            "Unimplemented scalar cast from fixed point to int");  // TODO
+      case Type::STK_Floating:
+        return CK_FixedPointToFloating;
       case Type::STK_FixedPoint:
         llvm_unreachable(
-        "Sema::PrepareScalarCast from STK_FixedPoint to anything");  // TODO
+            "Unimplemented scalar cast from fixed point to fixed point");  // TODO
+    }
+  }
 
   case Type::STK_Bool: // casting from bool is like casting from an integer
   case Type::STK_Integral:
     switch (DestTy->getScalarTypeKind()) {
     case Type::STK_FixedPoint:
       llvm_unreachable(
           "Sema::PrepareScalarCast from STK_Integral to STK_FixedPoint");  // TODO
     case Type::STK_CPointer:

lib/StaticAnalyzer/Core/ExprEngineC.cpp

for (ExplodedNodeSet::iterator I = dstPreStmt.begin(), E = dstPreStmt.end();
     const LocationContext *LCtx = Pred->getLocationContext();
 
     switch (CastE->getCastKind()) {
       case CK_FixedPointCast:
         llvm_unreachable("CK_FixedPointCast");  // TODO
       case CK_IntegralToFixedPoint:
         llvm_unreachable(
             "ExprEngine::VisitCast CK_IntegralToFixedPoint");  // TODO
+      case CK_FixedPointToFloating:
+        llvm_unreachable("Unimplemented logic for CK_FixedPointToFloating");
       case CK_LValueToRValue:
         llvm_unreachable("LValueToRValue casts handled earlier.");
       case CK_ToVoid:
         continue;
         // The analyzer doesn't do anything special with these casts,
         // since it understands retain/release semantics already.
       case CK_ARCProduceObject:
       case CK_ARCConsumeObject:

test/Frontend/fixed_point_validation.c

 // bits allocated to the integral part of a short _Accum by default.
 
 signed short _Accum s_short_accum2 = 2.5hk;  // CHECK-DAG: @s_short_accum2 = dso_local global i16 320, align 2
 short _Fract short_fract = 0.33333333333hr;  // CHECK-DAG: @short_fract = dso_local global i16 42, align 2
 
 // Run simple validation tests
 
 #define assert(b) if (!(b)) { return 1; }
+#define abs(x) x < 0 ? -x : x
 
 int main(){
   short _Accum s_accum = 0.0hk;
   short _Accum s_accum2 = 2.0hk;
   short _Fract s_fract = 0.999hr;
   short _Fract s_fract2 = -0.999hr;
   const _Fract fract_zero = 0.0r;
   // CHECK:      %s_accum = alloca i16, align 2
int main(){
   const signed short _Accum s_accum4 = 16.0hk;
   short _Accum s_accum_shr = s_accum4 >> 3;
   assert(s_accum_shr == 2);
   assert(s_accum_shr >> 1 == 1);
   assert(s_accum_shr >> 2 == 0.5hr);  // RShift is equivalent to dividing by 2
   assert(5.0hk >> 2 == 1.25hk);
   assert(-5.0hk >> 2 == -1.25k);
   assert(0.0hr >> 2 == 0);
+
+  /**************** Float conversions ***************/
+
+  float f = (float)2.5k;
+  assert(f > 2.4999 && f < 2.5001);  // High precision since the fractional
+                                     // value can be evenly represented.
+  assert((float)2.333hk != 2.333f);
+
+  float base = 2.333f;
+  float saccum_diff = abs(base - 2.333hk);
+  float accum_diff = abs(base - 2.333k);
+  float laccum_diff = abs(base - 2.333lk);
+  assert(accum_diff < saccum_diff);
+  assert(laccum_diff < accum_diff);
 }