[Fixed Point Arithmetic] Test for Conversion Between Valid Builtin Types

[leonardchan]

Summary

This patch contains changes and a test for checking that fixed point types can be converted between all other valid types. Fixed point types can be converted between floating point types, integral types, and other fixed point types.

[leonardchan]

formatting

include/clang/AST/OperationKinds.def

 /// 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_FloatingToFixedPoint - Floating point to fixed point.  Rounds
+/// towards zero, discarding any fractional component.
+///    (short _Accum) f
+CAST_OPERATION(FloatingToFixedPoint)
+
 /// 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)

lib/AST/Expr.cpp

bool CastExpr::CastConsistency() const {
   case CK_ARCReclaimReturnedObject:
   case CK_ARCExtendBlockObject:
   case CK_ZeroToOCLEvent:
   case CK_ZeroToOCLQueue:
   case CK_IntToOCLSampler:
   case CK_IntegralToFixedPoint:
   case CK_FixedPointCast:
   case CK_FixedPointToFloating:
+  case CK_FloatingToFixedPoint:
     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

 /// HandleCast - This is used to evaluate implicit or explicit casts where the
 /// result type is integer.
 bool IntExprEvaluator::VisitCastExpr(const CastExpr *E) {
   const Expr *SubExpr = E->getSubExpr();
   QualType DestType = E->getType();
   QualType SrcType = SubExpr->getType();
 
   switch (E->getCastKind()) {
+  case CK_FloatingToFixedPoint:
+    llvm_unreachable("CK_FloatingToFixedPoint");
   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
+    llvm_unreachable("CK_FixedPointToFloating");  // 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::VisitImaginaryLiteral(const ImaginaryLiteral *E) {
   }
 }
 
 bool ComplexExprEvaluator::VisitCastExpr(const CastExpr *E) {
 
   switch (E->getCastKind()) {
   case CK_FixedPointCast:
     llvm_unreachable("CK_FixedPointCast");  // TODO
+  case CK_FloatingToFixedPoint:
+    llvm_unreachable("CK_FloatingToFixedPoint");
   case CK_IntegralToFixedPoint:
     llvm_unreachable(
         "ComplexExprEvaluator::VisitCastExpr CK_IntegralToFixedPoint");  // TODO
   case CK_FixedPointToFloating:
-    llvm_unreachable("CK_FixedPointCast");  // TODO
+    llvm_unreachable("CK_FixedPointToFloating");  // 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

 /// then it must mean that we need the address of an aggregate in order to
 /// access one of its members.  This can happen for all the reasons that casts
 /// are permitted with aggregate result, including noop aggregate casts, and
 /// cast from scalar to union.
 LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) {
   switch (E->getCastKind()) {
   case CK_FixedPointCast:
     llvm_unreachable("CK_FixedPointCast");  // TODO
+  case CK_FloatingToFixedPoint:
+    llvm_unreachable("CK_FloatingToFixedPoint");
   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:

lib/CodeGen/CGExprAgg.cpp

while (true) {
     return nullptr;
   }
 }
 
 void AggExprEmitter::VisitCastExpr(CastExpr *E) {
   if (const auto *ECE = dyn_cast<ExplicitCastExpr>(E))
     CGF.CGM.EmitExplicitCastExprType(ECE, &CGF);
   switch (E->getCastKind()) {
+  case CK_FloatingToFixedPoint:
+    llvm_unreachable("CK_FloatingToFixedPoint");
   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: {

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_FloatingToFixedPoint:
+    llvm_unreachable("CK_FloatingToFixedPoint");
   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:

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_FloatingToFixedPoint:
+      llvm_unreachable("CK_FloatingToFixedPoint");
     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) {
   // These cases are generally not written to ignore the result of
   // evaluating their sub-expressions, so we clear this now.
   bool Ignored = TestAndClearIgnoreResultAssign();
 
   // Since almost all cast kinds apply to scalars, this switch doesn't have
   // a default case, so the compiler will warn on a missing case.  The cases
   // are in the same order as in the CastKind enum.
   switch (Kind) {
+  case CK_FloatingToFixedPoint:
+    llvm_unreachable("CK_FloatingToFixedPoint");
   case CK_Dependent: llvm_unreachable("dependent cast kind in IR gen!");
   case CK_BuiltinFnToFnPtr:
     llvm_unreachable("builtin functions are handled elsewhere");
 
   case CK_LValueBitCast:
   case CK_ObjCObjectLValueCast: {
     Address Addr = EmitLValue(E).getAddress();
     Addr = Builder.CreateElementBitCast(Addr, CGF.ConvertTypeForMem(DestTy));

lib/Edit/RewriteObjCFoundationAPI.cpp

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_FloatingToFixedPoint:
+      llvm_unreachable("CK_FloatingToFixedPoint");
     case CK_LValueToRValue:
     case CK_NoOp:
     case CK_UserDefinedConversion:
       break;
 
     case CK_IntegralCast: {
       if (MK == NSAPI::NSNumberWithBool && OrigTy->isBooleanType())
         break;

lib/Sema/SemaExpr.cpp

case Type::STK_ObjCObjectPointer:
     }
     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
+        return CK_IntegralToFixedPoint;
       case Type::STK_Floating:
         return CK_FixedPointToFloating;
       case Type::STK_FixedPoint:
         return CK_FixedPointCast;
     }
   }
 
   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
+      return CK_IntegralToFixedPoint;
     case Type::STK_CPointer:
     case Type::STK_ObjCObjectPointer:
     case Type::STK_BlockPointer:
       if (Src.get()->isNullPointerConstant(Context,
                                            Expr::NPC_ValueDependentIsNull))
         return CK_NullToPointer;
       return CK_IntegralToPointer;
     case Type::STK_Bool:
case Type::STK_Integral:
     case Type::STK_MemberPointer:
       llvm_unreachable("member pointer type in C");
     }
     llvm_unreachable("Should have returned before this");
 
   case Type::STK_Floating:
     switch (DestTy->getScalarTypeKind()) {
     case Type::STK_FixedPoint:
-      llvm_unreachable(
-          "Sema::PrepareScalarCast from STK_Floating to STK_FixedPoint");  // TODO
+      return CK_FloatingToFixedPoint;
     case Type::STK_Floating:
       return CK_FloatingCast;
     case Type::STK_Bool:
       return CK_FloatingToBoolean;
     case Type::STK_Integral:
       return CK_FloatingToIntegral;
     case Type::STK_FloatingComplex:
       Src = ImpCastExprToType(Src.get(),

lib/StaticAnalyzer/Core/ExprEngineC.cpp

for (ExplodedNodeSet::iterator I = dstPreStmt.begin(), E = dstPreStmt.end();
 
     Pred = *I;
     ProgramStateRef state = Pred->getState();
     const LocationContext *LCtx = Pred->getLocationContext();
 
     switch (CastE->getCastKind()) {
       case CK_FixedPointCast:
         llvm_unreachable("CK_FixedPointCast");  // TODO
+      case CK_FloatingToFixedPoint:
+        llvm_unreachable("CK_FloatingToFixedPoint");
       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:

test/Frontend/fixed_point_all_conversions.c

+// RUN: %clang_cc1 -Werror %s
+
+// Test for conversions between fixed point types and all other valid types.
+
+// Conversion from one type to another type
+#define CONVERT(FROM_TYPE, FROM_ID, TO_TYPE, TO_ID) \
+  TO_TYPE FROM_ID##_to_##TO_ID(FROM_TYPE x) { return x; }
+
+// Conversion between 2 types
+#define CONVERT_COMBINATION(TYPE1, ID1, TYPE2, ID2) \
+  CONVERT(TYPE1, ID1, TYPE2, ID2)                   \
+  CONVERT(TYPE2, ID2, TYPE1, ID1)
+
+// Conversion between one type and floating point types
+#define CONVERT_BETWEEN_FLOATS(TYPE, ID)      \
+  CONVERT_COMBINATION(TYPE, ID, float, Float) \
+  CONVERT_COMBINATION(TYPE, ID, double, Double)
+
+// Conversion between one type and an integral type with differant signage
+#define CONVERT_BETWEEN_INTEGRALS_WITH_SIGN(TYPE, ID, INT_TYPE, INT_ID) \
+  CONVERT_COMBINATION(TYPE, ID, INT_TYPE, INT_ID)                       \
+  CONVERT_COMBINATION(TYPE, ID, signed INT_TYPE, Signed##INT_ID)        \
+  CONVERT_COMBINATION(TYPE, ID, unsigned INT_TYPE, Unsigned##INT_ID)
+
+// Conversion between one type and all integral types
+#define CONVERT_BETWEEN_INTEGRALS(TYPE, ID)                   \
+  CONVERT_BETWEEN_INTEGRALS_WITH_SIGN(TYPE, ID, char, Char)   \
+  CONVERT_BETWEEN_INTEGRALS_WITH_SIGN(TYPE, ID, short, Short) \
+  CONVERT_BETWEEN_INTEGRALS_WITH_SIGN(TYPE, ID, int, Int)     \
+  CONVERT_BETWEEN_INTEGRALS_WITH_SIGN(TYPE, ID, long, Long)   \
+  CONVERT_BETWEEN_INTEGRALS_WITH_SIGN(TYPE, ID, long long, LongLong)
+
+// Conversion between one type and a fixed point type with different saturation
+#define CONVERT_BETWEEN_FIXED_POINT_WITH_SAT(TYPE, ID, FIXED_TYPE, FIXED_ID) \
+  CONVERT_COMBINATION(TYPE, ID, FIXED_TYPE, FIXED_ID)                        \
+  CONVERT_COMBINATION(TYPE, ID, _Sat FIXED_TYPE, Sat##FIXED_ID)
+
+// Conversion between one type and a fixed point type with different signage
+#define CONVERT_BETWEEN_FIXED_POINT_WITH_SIGN(TYPE, ID, FIXED_TYPE, FIXED_ID) \
+  CONVERT_BETWEEN_FIXED_POINT_WITH_SAT(TYPE, ID, FIXED_TYPE, FIXED_ID)        \
+  CONVERT_BETWEEN_FIXED_POINT_WITH_SAT(TYPE, ID, signed FIXED_TYPE,           \
+                                       Signed##FIXED_ID)                      \
+  CONVERT_BETWEEN_FIXED_POINT_WITH_SAT(TYPE, ID, unsigned FIXED_TYPE,         \
+                                       Unsigned##FIXED_ID)
+
+// Convert between one type and all fixed point types.
+// Add "Type" to the end of the ID to avoid multiple definitions of a function
+// if the Type is a fixed point type.
+#define CONVERT_BETWEEN_FIXED_POINT(TYPE, ID)                        \
+  CONVERT_BETWEEN_FIXED_POINT_WITH_SIGN(TYPE, ID, _Fract, FractType) \
+  CONVERT_BETWEEN_FIXED_POINT_WITH_SIGN(TYPE, ID, _Accum, AccumType)
+
+// Convert between one type and all other types
+#define CONVERT_BETWEEN_ALL_TYPES(TYPE, ID) \
+  CONVERT_BETWEEN_FLOATS(TYPE, ID)          \
+  CONVERT_BETWEEN_INTEGRALS(TYPE, ID)       \
+  CONVERT_BETWEEN_FIXED_POINT(TYPE, ID)
+
+#define CONVERT_FIXED_POINT_TYPE_WITH_SAT(TYPE, ID) \
+  CONVERT_BETWEEN_ALL_TYPES(TYPE, ID)               \
+  CONVERT_BETWEEN_ALL_TYPES(_Sat TYPE, Sat##ID)
+
+#define CONVERT_FIXED_POINT_TYPE(TYPE, ID)                   \
+  CONVERT_FIXED_POINT_TYPE_WITH_SAT(TYPE, ID)                \
+  CONVERT_FIXED_POINT_TYPE_WITH_SAT(signed TYPE, Signed##ID) \
+  CONVERT_FIXED_POINT_TYPE_WITH_SAT(unsigned TYPE, Unsigned##ID)
+
+CONVERT_FIXED_POINT_TYPE(short _Fract, ShortFract);
+CONVERT_FIXED_POINT_TYPE(_Fract, Fract);
+CONVERT_FIXED_POINT_TYPE(long _Fract, LongFract);
+
+CONVERT_FIXED_POINT_TYPE(short _Accum, ShortAccum);
+CONVERT_FIXED_POINT_TYPE(_Accum, Accum);
+CONVERT_FIXED_POINT_TYPE(long _Accum, LongAccum);