[Fixed Point Arithmetic] Comparison and Unary Operations for Fixed Point Types

[leonardchan]

Summary

This patch contains logic and tests for different unary and comparison operations on fixed point types, and casting between integers and fixed point types.

The operations are ==, !=, >, <, >=, <=, !, +, -, ++, and --.

~ is not a supported operation on fixed point types.

[leonardchan]

formatting

[ebevhan]

lib/CodeGen/CGExprScalar.cpp

2141

Please see my comments on other patches about these values.

2178

Use an APInt with the right size here instead of relying on types in the compiler.

[ebevhan]

lib/CodeGen/CGExprScalar.cpp

2178

Also, what about saturating types?

lib/CodeGen/CGExprScalar.cpp

Value *ScalarExprEmitter::EmitConversionToBool(Value *Src, QualType SrcType) {
   assert(SrcType.isCanonical() && "EmitScalarConversion strips typedefs");
 
   if (SrcType->isRealFloatingType())
     return EmitFloatToBoolConversion(Src);
 
   if (const MemberPointerType *MPT = dyn_cast<MemberPointerType>(SrcType))
     return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, Src, MPT);
 
-  assert((SrcType->isIntegerType() || isa<llvm::PointerType>(Src->getType())) &&
+  assert((SrcType->isIntegerType() || isa<llvm::PointerType>(Src->getType()) ||
+          SrcType->isFixedPointType()) &&
          "Unknown scalar type to convert");
 
   if (isa<llvm::IntegerType>(Src->getType()))
     return EmitIntToBoolConversion(Src);
 
   assert(isa<llvm::PointerType>(Src->getType()));
   return EmitPointerToBoolConversion(Src, SrcType);
 }
if (type->isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType) {
             CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16,
                                  CGF.CGM.FloatTy),
             value, "incdec.conv");
       } else {
         value = Builder.CreateFPTrunc(value, input->getType(), "incdec.conv");
       }
     }
 
+  // Fixed point type
+  } else if (type->isFixedPointType()) {
+    // TODO: Account for overflows and the sort for saturation
+    unsigned fbits;
+    const auto *BT = type->getAs<BuiltinType>();
+    switch (BT->getKind()) {
+      default:
+        llvm_unreachable("Not a fixed point type!");
+      case BuiltinType::ShortAccum:
+        fbits = BUILTIN_SACCUM_FBIT;
+        break;
+      case BuiltinType::Accum:
+        fbits = BUILTIN_ACCUM_FBIT;
+        break;
+      case BuiltinType::LongAccum:
+        fbits = BUILTIN_LACCUM_FBIT;
+        break;
+      case BuiltinType::UShortAccum:
+        fbits = BUILTIN_USACCUM_FBIT;
+        break;
+      case BuiltinType::UAccum:
+        fbits = BUILTIN_UACCUM_FBIT;
+        break;
+      case BuiltinType::ULongAccum:
+        fbits = BUILTIN_ULACCUM_FBIT;
+        break;
+      case BuiltinType::ShortFract:
+        fbits = BUILTIN_SFRACT_FBIT;
+        break;
+      case BuiltinType::Fract:
+        fbits = BUILTIN_FRACT_FBIT;
+        break;
+      case BuiltinType::LongFract:
+        fbits = BUILTIN_LFRACT_FBIT;
+        break;
+      case BuiltinType::UShortFract:
+        fbits = BUILTIN_USFRACT_FBIT;
+        break;
+      case BuiltinType::UFract:
+        fbits = BUILTIN_UFRACT_FBIT;
+        break;
+      case BuiltinType::ULongFract:
+        fbits = BUILTIN_ULFRACT_FBIT;
+        break;
+    }
+    llvm::Value *amt =
+        llvm::ConstantInt::get(value->getType(), 1 << fbits,
+                               /*isSigned=*/type->isSignedFixedPointType());
+    if (isInc) {
+      value = Builder.CreateAdd(value, amt, "fixed_point_post_inc");
+    } else {
+      value = Builder.CreateSub(value, amt, "fixed_point_post_dec");
+    }
+
   // Objective-C pointer types.
   } else {
     const ObjCObjectPointerType *OPT = type->castAs<ObjCObjectPointerType>();
     value = CGF.EmitCastToVoidPtr(value);
 
     CharUnits size = CGF.getContext().getTypeSizeInChars(OPT->getObjectType());
     if (!isInc) size = -size;
     llvm::Value *sizeValue =
if (LHSTy->isVectorType() && !E->getType()->isVectorType()) {
           E->getType() == CGF.getContext().BoolTy)
         Result = Builder.CreateTrunc(Result, Builder.getInt1Ty());
       return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType(),
                                   E->getExprLoc());
     }
 
     if (LHS->getType()->isFPOrFPVectorTy()) {
       Result = Builder.CreateFCmp(FCmpOpc, LHS, RHS, "cmp");
-    } else if (LHSTy->hasSignedIntegerRepresentation()) {
+    } else if (LHSTy->hasSignedIntegerRepresentation() ||
+               LHSTy->isSignedFixedPointType() ||
+               RHSTy->isSignedFixedPointType()) {
       Result = Builder.CreateICmp(SICmpOpc, LHS, RHS, "cmp");
     } else {
       // Unsigned integers and pointers.
       Result = Builder.CreateICmp(UICmpOpc, LHS, RHS, "cmp");
     }
 
     // If this is a vector comparison, sign extend the result to the appropriate
     // vector integer type and return it (don't convert to bool).

lib/Sema/SemaExpr.cpp

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());
if (Literal.isFixedPointLiteral()) {
     APFloat::opStatus result = Literal.GetFloatValue(Val);
 
     HandleFloatOverflow(*this, floatingTy, Tok.getLocation(), result, Val,
                         Format);
 
     // TODO: Check sizes to make sure we don't overflow or fit a value that
     // can't fit into the number of bits we have.
     double float_val = Val.convertToDouble();
-    assert(float_val > 0);
+    assert(float_val >= 0);
     double int_part;
     double fract_part = modf(float_val, &int_part);
     uint64_t int_part_as_int = static_cast<uint64_t>(int_part);
 
     if (Literal.fixedPointType == FPT_FRACT && int_part_as_int) {
       Diag(Tok.getLocation(), diag::err_integral_part_on_fract);
     } else {
       // Make sure the integral part fits into the integral bits we have.

test/Frontend/fixed_point_declarations.c

-// RUN: %clang -S -emit-llvm %s -o - | FileCheck %s
-
-// Primary fixed point types
-signed short _Accum s_short_accum;    // CHECK-DAG: @s_short_accum =  common dso_local global i16 0, align 2
-signed _Accum s_accum;                // CHECK-DAG: @s_accum =        common dso_local global i32 0, align 4
-signed long _Accum s_long_accum;      // CHECK-DAG: @s_long_accum =   common dso_local global i64 0, align 8
-unsigned short _Accum u_short_accum;  // CHECK-DAG: @u_short_accum =  common dso_local global i16 0, align 2
-unsigned _Accum u_accum;              // CHECK-DAG: @u_accum =        common dso_local global i32 0, align 4
-unsigned long _Accum u_long_accum;    // CHECK-DAG: @u_long_accum =   common dso_local global i64 0, align 8
-signed short _Fract s_short_fract;    // CHECK-DAG: @s_short_fract =  common dso_local global i16 0, align 2
-signed _Fract s_fract;                // CHECK-DAG: @s_fract =        common dso_local global i32 0, align 4
-signed long _Fract s_long_fract;      // CHECK-DAG: @s_long_fract =   common dso_local global i64 0, align 8
-unsigned short _Fract u_short_fract;  // CHECK-DAG: @u_short_fract =  common dso_local global i16 0, align 2
-unsigned _Fract u_fract;              // CHECK-DAG: @u_fract =        common dso_local global i32 0, align 4
-unsigned long _Fract u_long_fract;    // CHECK-DAG: @u_long_fract =   common dso_local global i64 0, align 8
-
-// There are 7 bits allocated to the fractional part and 8
-// 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
-
-void func() {
-  s_short_accum = s_short_accum2;
-  // CHECK-DAG: %0 = load i16, i16* @s_short_accum2, align 2
-  // CHECK-DAG: store i16 %0, i16* @s_short_accum, align 2
-
-  s_short_accum == 0;
-  // CHECK-DAG: %1 = load i16, i16* @s_short_accum, align 2
-  // CHECK-DAG: %cmp = icmp eq i16 %1, 0
-
-  s_accum == 2;
-}

test/Frontend/fixed_point_validation.c

+// RUN: %clang -S -emit-llvm %s -o - | FileCheck %s
 // RUN: %clang_cc1 -S -emit-llvm -o - %s | lli
 
+// The first test checks the emitted llvm IR.
+// The second test checks the output.
+// Both these test require that the default bit widths for the fixed point types
+// are used since we check for bit shifted literals that were converted from
+// ints and floats.
+
+// Primary fixed point types
+signed short _Accum s_short_accum;    // CHECK-DAG: @s_short_accum =  common dso_local global i16 0, align 2
+signed _Accum s_accum;                // CHECK-DAG: @s_accum =        common dso_local global i32 0, align 4
+signed long _Accum s_long_accum;      // CHECK-DAG: @s_long_accum =   common dso_local global i64 0, align 8
+unsigned short _Accum u_short_accum;  // CHECK-DAG: @u_short_accum =  common dso_local global i16 0, align 2
+unsigned _Accum u_accum;              // CHECK-DAG: @u_accum =        common dso_local global i32 0, align 4
+unsigned long _Accum u_long_accum;    // CHECK-DAG: @u_long_accum =   common dso_local global i64 0, align 8
+signed short _Fract s_short_fract;    // CHECK-DAG: @s_short_fract =  common dso_local global i16 0, align 2
+signed _Fract s_fract;                // CHECK-DAG: @s_fract =        common dso_local global i32 0, align 4
+signed long _Fract s_long_fract;      // CHECK-DAG: @s_long_fract =   common dso_local global i64 0, align 8
+unsigned short _Fract u_short_fract;  // CHECK-DAG: @u_short_fract =  common dso_local global i16 0, align 2
+unsigned _Fract u_fract;              // CHECK-DAG: @u_fract =        common dso_local global i32 0, align 4
+unsigned long _Fract u_long_fract;    // CHECK-DAG: @u_long_fract =   common dso_local global i64 0, align 8
+
+// There are 7 bits allocated to the fractional part and 8
+// 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; }
 
 int main(){
-  short _Accum s_accum;
+  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
+  // CHECK:      %s_accum2 = alloca i16, align 2
+  // CHECK:      %s_fract = alloca i16, align 2
+  // CHECK:      %s_fract2 = alloca i16, align 2
+  // CHECK:      %fract_zero = alloca i32, align 4
+  // CHECK:      store i16 0, i16* %s_accum, align 2
+  // CHECK:      store i16 256, i16* %s_accum2, align 2
+  // CHECK:      store i16 127, i16* %s_fract, align 2
+  // CHECK:      store i16 -127, i16* %s_fract2, align 2
+  // CHECK:      store i32 0, i32* %fract_zero, align 4
+
+  /**************** Simple Comparisons ***************/
 
   assert(s_accum == 0);
+  // CHECK:      {{.*}} = load i16, i16* %s_accum, align 2
+  // CHECK-NEXT: {{.*}} = icmp eq i16 {{.*}}, 0
 
   s_accum = s_accum2;
+  // CHECK:      {{.*}} = load i16, i16* %s_accum2, align 2
+  // CHECK-NEXT: store i16 %1, i16* %s_accum, align 2
 
   assert(s_accum == s_accum2);
+  // CHECK:      {{.*}} = load i16, i16* %s_accum, align 2
+  // CHECK-NEXT: {{.*}} = load i16, i16* %s_accum2, align 2
+  // CHECK-NEXT: {{.*}} = icmp eq i16 {{.*}}, {{.*}}
+
+  assert(s_accum2 == s_accum);
+  // CHECK:      {{.*}} = load i16, i16* %s_accum2, align 2
+  // CHECK-NEXT: {{.*}} = load i16, i16* %s_accum, align 2
+  // CHECK-NEXT: {{.*}} = icmp eq i16 {{.*}}, {{.*}}
+
   assert(s_accum == 2);
+  // CHECK:      {{.*}} = icmp eq i16 {{.*}}, 256
+
+  assert(2 == s_accum);
+  // CHECK:      {{.*}} = icmp eq i16 256, {{.*}}
+
+  int x = 2;
+  assert(s_accum == x);
+  // CHECK:      {{.*}} = load i32, i32* %x, align 4
+  // CHECK-NEXT: {{.*}} = trunc i32 {{.*}} to i16
+  // CHECK-NEXT: {{.*}} = shl i16 {{.*}}, 7
+  // CHECK-NEXT: {{.*}} = icmp eq i16 {{.*}}, {{.*}}
+
+  assert(x == s_accum);
+
+  assert(s_accum != -2);
+  // CHECK:      {{.*}} = icmp ne i16 {{.*}}, -256
+
+  assert(-2 != s_accum);
+  // CHECK:      {{.*}} = icmp ne i16 -256, {{.*}}
+
+  assert(s_accum != -x);
+  assert(-x != s_accum);
+
+  assert(s_fract != 1);
+  // CHECK:      {{.*}} = load i16, i16* %s_fract, align 2
+  // CHECK_NEXT: {{.*}} = icmp ne i16 {{.*}}, 128
+
+  assert(s_fract2 != -1);
+  // CHECK:      {{.*}} = load i16, i16* %s_fract2, align 2
+  // CHECK_NEXT: {{.*}} = icmp ne i16 {{.*}}, -128
+
+  assert(!fract_zero);
+  assert(s_fract);
+  assert(s_fract == -s_fract2);
+
+  assert(s_fract > s_fract2);
+  // CHECK:      {{.*}} = load i16, i16* %s_fract, align 2
+  // CHECK:      {{.*}} = load i16, i16* %s_fract2, align 2
+  // CHECK:      {{.*}} = icmp sgt i16 {{.*}}, {{.*}}
+
+  assert(s_fract2 < s_fract);
+  // CHECK:      {{.*}} = load i16, i16* %s_fract2, align 2
+  // CHECK-NEXT: {{.*}} = load i16, i16* %s_fract, align 2
+  // CHECK-NEXT: {{.*}} = icmp slt i16 {{.*}}, {{.*}}
+
+  assert(s_fract >= s_fract);
+  // CHECK:      {{.*}} = icmp sge i16 {{.*}}, {{.*}}
+
+  assert(s_fract <= s_fract);
+  // CHECK:      {{.*}} = icmp sle i16 {{.*}}, {{.*}}
+
+  assert(s_fract >= s_fract2);
+  assert(s_fract2 <= s_fract);
+
+  // Depending on the number of fractional bits used, lack of precision
+  // could cause some values for fixed point numbers to be rounded to precise
+  // numbers.
+  assert(2 == 2.001hk);  // This is valid if SACCUM_FBITS == 7
+
+  /**************** Unary operations ***************/
+
+  s_accum = 0.0hk;
+  assert(!s_accum++);
+  // CHECK:      [[VAL:%.+]] = load i16, i16* %s_accum, align 2
+  // CHECK-NEXT: [[INC:%.+]] = add i16 [[VAL]], 128
+  // CHECK-NEXT: store i16 [[INC]], i16* %s_accum, align 2
+  // CHECK-NEXT: icmp ne i16 [[VAL]], 0
+
+  assert(s_accum == 1);
+  // CHECK:       load
+
+  assert(s_accum--);
+  // CHECK:      [[VAL:%.+]] = load i16, i16* %s_accum, align 2
+  // CHECK-NEXT: [[DEC:%.+]] = sub i16 [[VAL]], 128
+  // CHECK-NEXT: store i16 [[DEC]], i16* %s_accum, align 2
+  // CHECK-NEXT: icmp ne i16 [[VAL]], 0
+
+  assert(!s_accum);
+  // CHECK:      load
+
+  assert(++s_accum);
+  // CHECK:      [[VAL:%.+]] = load i16, i16* %s_accum, align 2
+  // CHECK-NEXT: [[INC:%.+]] = add i16 [[VAL]], 128
+  // CHECK-NEXT: store i16 [[INC]], i16* %s_accum, align 2
+  // CHECK-NEXT: icmp ne i16 [[INC]], 0
+
+  assert(s_accum == 1);
+  // CHECK:      load
+
+  assert(!(--s_accum));
+  // CHECK:      [[VAL:%.+]] = load i16, i16* %s_accum, align 2
+  // CHECK-NEXT: [[DEC:%.+]] = sub i16 [[VAL]], 128
+  // CHECK-NEXT: store i16 [[DEC]], i16* %s_accum, align 2
+  // CHECK-NEXT: icmp ne i16 [[DEC]], 0
+
+  assert(+s_fract == s_fract);
+  assert(+s_fract2 == s_fract2);  // s_fract2 is negative
+  assert(-s_fract == s_fract2);
 }