Index: lib/CodeGen/CGExprScalar.cpp =================================================================== --- lib/CodeGen/CGExprScalar.cpp +++ lib/CodeGen/CGExprScalar.cpp @@ -781,7 +781,8 @@ if (const MemberPointerType *MPT = dyn_cast(SrcType)) return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, Src, MPT); - assert((SrcType->isIntegerType() || isa(Src->getType())) && + assert((SrcType->isIntegerType() || isa(Src->getType()) || + SrcType->isFixedPointType()) && "Unknown scalar type to convert"); if (isa(Src->getType())) @@ -2102,6 +2103,34 @@ } } + // Fixed point type + } else if (type->isFixedPointType()) { + // TODO: Account for overflows and the sort for saturation + unsigned fbits; + const auto *BT = type->getAs(); + 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(); @@ -3264,7 +3293,9 @@ 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. Index: lib/Sema/SemaExpr.cpp =================================================================== --- lib/Sema/SemaExpr.cpp +++ lib/Sema/SemaExpr.cpp @@ -3489,7 +3489,7 @@ // 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(int_part); Index: test/Frontend/fixed_point_declarations.c =================================================================== --- test/Frontend/fixed_point_declarations.c +++ /dev/null @@ -1,33 +0,0 @@ -// 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; -} Index: test/Frontend/fixed_point_validation.c =================================================================== --- test/Frontend/fixed_point_validation.c +++ test/Frontend/fixed_point_validation.c @@ -1,19 +1,170 @@ +// 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); }