[Fixed Point Arithmetic] Remaining Binary Operations on Primary Fixed Point Types

[leonardchan]

Summary

This patch implements the remaining arithmetic and logical operations on the primary fixed point types.

The operations are +, -, *, /, <<, and >>.

// Addition
s_accum = 3.0hk;
short _Accum s_accum_sum = s_accum + s_accum2;
assert(s_accum_sum == 5);
assert(s_fract + s_fract2 == 0);

// Subtraction
short _Accum s_accum_diff = s_accum - s_accum2;
assert(s_accum_diff == 1);
assert(s_accum2 - s_accum == -1);

// Multiplication
short _Accum s_accum_mul = s_accum * s_accum2;
assert(s_accum_mul == 6);
assert(2.0hk * 3.0hk == 6);
assert(2.0hk * 3 == 6);
assert(2.5hk * 3 == 7.5k);
assert(-2.5hk * 3 == -7.5lk);
assert(3 * -2.5hk == -7.5hk);
assert(-2.5hk * 0 == 0);

// Division
const short _Accum s_accum3 = 2.5hk;
short _Accum s_accum_div = s_accum3 / s_accum2;
assert(s_accum_div == 1.25hk);
assert(5.0hk / s_accum3 == 2);
assert(-5.0hk / s_accum3 == -2);
assert(9.9k / 3.3k == 3);
assert(9.9hk / 3.3k != 3);  // We lose precision when converting between types of different
                            // fractional width.
assert(6.75hk / 2.25k == 3);  // Unless the fractional part can be evenly represented with
                              // sums of powers of 2.
assert(0 / 2.0hk == 0);

% is not a valid operation on fixed point types.

[leonardchan]

formatting

include/clang/AST/ASTContext.h

public:
 
   /// \brief Compare the rank of the two specified floating point types,
   /// ignoring the domain of the type (i.e. 'double' == '_Complex double').
   ///
   /// If \p LHS > \p RHS, returns 1.  If \p LHS == \p RHS, returns 0.  If
   /// \p LHS < \p RHS, return -1.
   int getFloatingTypeOrder(QualType LHS, QualType RHS) const;
 
+  /// \brief Compare the rank of the two specified fixed point types according
+  /// to 4.1.1 of ISO/IEC JTC1 SC22 WG14 N1169.
+  ///
+  /// If \p LHS > \p RHS, returns 1.  If \p LHS == \p RHS, returns 0.  If
+  /// \p LHS < \p RHS, return -1.
+  int getFixedPointTypeOrder(QualType LHS, QualType RHS) const;
+
   /// \brief Return a real floating point or a complex type (based on
   /// \p typeDomain/\p typeSize).
   ///
   /// \param typeDomain a real floating point or complex type.
   /// \param typeSize a real floating point or complex type.
   QualType getFloatingTypeOfSizeWithinDomain(QualType typeSize,
                                              QualType typeDomain) const;
 

include/clang/AST/OperationKinds.def

 /// CK_IntegralToBoolean - Integral to boolean.  A check against zero.
 ///    (bool) i
 CAST_OPERATION(IntegralToBoolean)
 
 /// CK_IntegralToFloating - Integral to floating point.
 ///    float f = i;
 CAST_OPERATION(IntegralToFloating)
 
+/// CK_FixedPointCast - Cast between fixed point types.
+///    short _Accum a = 1.2k;
+///    (short _Fract) a
+CAST_OPERATION(FixedPointCast)
+
 /// CK_IntegralToFixedPoint - Integral to fixed point.
-///    (short _Accum) i;
+///    (short _Accum) i
 CAST_OPERATION(IntegralToFixedPoint)
 
 /// CK_FloatingToIntegral - Floating point to integral.  Rounds
 /// towards zero, discarding any fractional component.
 ///    (int) f
 CAST_OPERATION(FloatingToIntegral)
 
 /// CK_FloatingToBoolean - Floating point to boolean.

include/clang/AST/Type.h

#include "clang/Basic/OpenCLImageTypes.def"
   bool isFixedPointType() const;
 
   // Return true if this is a saturated fixed point type according to
   // ISO/IEC JTC1 SC22 WG14 N1169.
   bool isSaturatedFixedPointType() const;
 
   // Return true if this is a fixed point type that is signed according
   // to ISO/IEC JTC1 SC22 WG14 N1169. [short _Fract, _Accum, long _Fract...]
+  // This type can also be saturated.
   bool isSignedFixedPointType() const;
 
   // Return true if this is a fixed point type that is unsigned according
-  // to ISO/IEC JTC1 SC22 WG14 N1169.
+  // to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
   bool isUnsignedFixedPointType() const;
 
+  // Return true if this is a fixed point type that is also an _Accum type.
+  // This type can also be saturated.
+  bool isAccumFixedPointType() const;
+
+  // Return true if this is a fixed point type that is also an _Fract type.
+  // This type can also be saturated.
+  bool isFractFixedPointType() const;
+
   /// Return true if this is not a variable sized type,
   /// according to the rules of C99 6.7.5p3.  It is not legal to call this on
   /// incomplete types.
   bool isConstantSizeType() const;
 
   /// Returns true if this type can be represented by some
   /// set of type specifiers.
   bool isSpecifierType() const;
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)){
     return ((BT->getKind() >= BuiltinType::UShortAccum && BT->getKind() <= BuiltinType::ULongAccum) ||
             (BT->getKind() >= BuiltinType::UShortFract && BT->getKind() <= BuiltinType::ULongFract) ||
             (BT->getKind() >= BuiltinType::SatUShortAccum && BT->getKind() <= BuiltinType::SatULongAccum) ||
             (BT->getKind() >= BuiltinType::SatUShortFract && BT->getKind() <= BuiltinType::SatULongFract));
   }
   return false;
 }
 
+inline bool Type::isAccumFixedPointType() const {
+  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)){
+    return ((BT->getKind() >= BuiltinType::ShortAccum && BT->getKind() <= BuiltinType::ULongAccum) ||
+            (BT->getKind() >= BuiltinType::SatShortAccum && BT->getKind() <= BuiltinType::SatULongAccum));
+  }
+  return false;
+}
+
+inline bool Type::isFractFixedPointType() const {
+  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)){
+    return ((BT->getKind() >= BuiltinType::ShortFract && BT->getKind() <= BuiltinType::ULongFract) ||
+            (BT->getKind() >= BuiltinType::SatShortFract && BT->getKind() <= BuiltinType::SatULongFract));
+  }
+  return false;
+}
+
 inline bool Type::isScalarType() const {
   if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
     return BT->getKind() > BuiltinType::Void &&
            BT->getKind() <= BuiltinType::NullPtr;
   if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
     // Enums are scalar types, but only if they are defined.  Incomplete enums
     // are not treated as scalar types.
     return IsEnumDeclComplete(ET->getDecl());

 }
 
 QualType DecayedType::getPointeeType() const {
   QualType Decayed = getDecayedType();
   (void)AttributedType::stripOuterNullability(Decayed);
   return cast<PointerType>(Decayed)->getPointeeType();
 }
 
+// Return the number of fractional bits in a fixed point type.
+unsigned getFixedPointFBits(const QualType& Ty);
+
+// Return the number of integral bits in a fixed point type.
+unsigned getFixedPointIBits(const QualType& Ty);
+
 } // namespace clang
 
 #endif // LLVM_CLANG_AST_TYPE_H

lib/AST/ASTContext.cpp

 unsigned ASTContext::NumImplicitMoveAssignmentOperatorsDeclared;
 unsigned ASTContext::NumImplicitDestructors;
 unsigned ASTContext::NumImplicitDestructorsDeclared;
 
 enum FloatingRank {
   Float16Rank, HalfRank, FloatRank, DoubleRank, LongDoubleRank, Float128Rank
 };
 
+enum FixedPointRank {
+  ShortFractRank,
+  FractRank,
+  LongFractRank,
+  ShortAccumRank,
+  AccumRank,
+  LongAccumRank
+};
+
 RawComment *ASTContext::getRawCommentForDeclNoCache(const Decl *D) const {
   if (!CommentsLoaded && ExternalSource) {
     ExternalSource->ReadComments();
 
 #ifndef NDEBUG
     ArrayRef<RawComment *> RawComments = Comments.getComments();
     assert(std::is_sorted(RawComments.begin(), RawComments.end(),
                           BeforeThanCompare<RawComment>(SourceMgr)));
static FloatingRank getFloatingRank(QualType T) {
   case BuiltinType::Half:       return HalfRank;
   case BuiltinType::Float:      return FloatRank;
   case BuiltinType::Double:     return DoubleRank;
   case BuiltinType::LongDouble: return LongDoubleRank;
   case BuiltinType::Float128:   return Float128Rank;
   }
 }
 
+/// getFixedPointRank - Return a relative rank for fixed point types.
+/// This routine will assert if passed a built-in type that isn't a fixed point.
+static FixedPointRank getFixedPointRank(QualType T) {
+  assert(T->isFixedPointType() && T->getAs<BuiltinType>() &&
+         "getFixedPointRank(): not a fixed point type");
+  switch (T->getAs<BuiltinType>()->getKind()) {
+  default: llvm_unreachable("getFixedPointRank(): not a fixed point type");
+  case BuiltinType::ShortAccum:
+  case BuiltinType::UShortAccum:
+  case BuiltinType::SatShortAccum:
+  case BuiltinType::SatUShortAccum:
+    return ShortAccumRank;
+
+  case BuiltinType::Accum:
+  case BuiltinType::UAccum:
+  case BuiltinType::SatAccum:
+  case BuiltinType::SatUAccum:
+    return AccumRank;
+
+  case BuiltinType::LongAccum:
+  case BuiltinType::ULongAccum:
+  case BuiltinType::SatLongAccum:
+  case BuiltinType::SatULongAccum:
+    return LongAccumRank;
+
+  case BuiltinType::ShortFract:
+  case BuiltinType::UShortFract:
+  case BuiltinType::SatShortFract:
+  case BuiltinType::SatUShortFract:
+    return ShortFractRank;
+
+  case BuiltinType::Fract:
+  case BuiltinType::UFract:
+  case BuiltinType::SatFract:
+  case BuiltinType::SatUFract:
+    return FractRank;
+
+  case BuiltinType::LongFract:
+  case BuiltinType::ULongFract:
+  case BuiltinType::SatLongFract:
+  case BuiltinType::SatULongFract:
+    return LongFractRank;
+  }
+}
+
 /// getFloatingTypeOfSizeWithinDomain - Returns a real floating
 /// point or a complex type (based on typeDomain/typeSize).
 /// 'typeDomain' is a real floating point or complex type.
 /// 'typeSize' is a real floating point or complex type.
 QualType ASTContext::getFloatingTypeOfSizeWithinDomain(QualType Size,
                                                        QualType Domain) const {
   FloatingRank EltRank = getFloatingRank(Size);
   if (Domain->isComplexType()) {
int ASTContext::getFloatingTypeOrder(QualType LHS, QualType RHS) const {
 
   if (LHSR == RHSR)
     return 0;
   if (LHSR > RHSR)
     return 1;
   return -1;
 }
 
+/// getFixedPointTypeOrder - Compare the rank of the two specified fixed
+/// point types.
+/// If LHS > RHS, return 1.  If LHS == RHS, return 0. If
+/// LHS < RHS, return -1.
+int ASTContext::getFixedPointTypeOrder(QualType LHS, QualType RHS) const {
+  FixedPointRank LHSR = getFixedPointRank(LHS);
+  FixedPointRank RHSR = getFixedPointRank(RHS);
+
+  if (LHSR == RHSR)
+    return 0;
+  if (LHSR > RHSR)
+    return 1;
+  return -1;
+}
+
 /// getIntegerRank - Return an integer conversion rank (C99 6.3.1.1p1). This
 /// routine will assert if passed a built-in type that isn't an integer or enum,
 /// or if it is not canonicalized.
 unsigned ASTContext::getIntegerRank(const Type *T) const {
   assert(T->isCanonicalUnqualified() && "T should be canonicalized");
 
   switch (cast<BuiltinType>(T)->getKind()) {
   default: llvm_unreachable("getIntegerRank(): not a built-in integer");

lib/AST/Expr.cpp

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

public:
   //                            Visitor Methods
   //===--------------------------------------------------------------------===//
 
   bool VisitFixedPointLiteral(const FixedPointLiteral *E) {
     return Success(E->getValue(), E);
   }
 
   bool VisitUnaryOperator(const UnaryOperator *E);
+  bool VisitCastExpr(const CastExpr* E);
 };
 } // end anonymous namespace
 
 /// EvaluateIntegerOrLValue - Evaluate an rvalue integral-typed expression, and
 /// produce either the integer value or a pointer.
 ///
 /// GCC has a heinous extension which folds casts between pointer types and
 /// pointer-sized integral types. We support this by allowing the evaluation of
if (LHSTy->isNullPtrType()) {
     assert(RHSTy->isNullPtrType() && "missing pointer conversion");
     // C++11 [expr.rel]p4, [expr.eq]p3: If two operands of type std::nullptr_t
     // are compared, the result is true of the operator is <=, >= or ==, and
     // false otherwise.
     BinaryOperator::Opcode Opcode = E->getOpcode();
     return Success(Opcode == BO_EQ || Opcode == BO_LE || Opcode == BO_GE, E);
   }
 
+  if (LHSTy->isFixedPointType() && RHSTy->isFixedPointType()) {
+    APValue LHSVal, RHSVal;
+
+    if (!FixedPointExprEvaluator(Info, LHSVal).Visit(E->getLHS())) {
+      return false;
+    }
+
+    if (!FixedPointExprEvaluator(Info, RHSVal).Visit(E->getRHS())) {
+      return false;
+    }
+
+    const APSInt& LHSInt = LHSVal.getInt();
+    const APSInt& RHSInt = RHSVal.getInt();
+
+    switch (E->getOpcode()) {
+    default:
+      llvm_unreachable("Invalid binary operator!");
+    case BO_LT:
+      return Success(LHSInt < RHSInt, E);
+    case BO_GT:
+      return Success(LHSInt > RHSInt, E);
+    case BO_LE:
+      return Success(LHSInt <= RHSInt, E);
+    case BO_GE:
+      return Success(LHSInt >= RHSInt, E);
+    case BO_EQ:
+      return Success(LHSInt == RHSInt, E);
+    case BO_NE:
+      return Success(LHSInt != RHSInt, E);
+    }
+  }
+
   assert((!LHSTy->isIntegralOrEnumerationType() ||
           !RHSTy->isIntegralOrEnumerationType()) &&
          "DataRecursiveIntBinOpEvaluator should have handled integral types");
   // We can't continue from here for non-integral types.
   return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
 }
 
 /// VisitUnaryExprOrTypeTraitExpr - Evaluate a sizeof, alignof or vec_step with

 /// 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_FixedPointCast: llvm_unreachable("CK_FixedPointCast"); // TODO
   case CK_IntegralToFixedPoint: llvm_unreachable("IntExprEvaluator::VisitCastExpr CK_IntegralToFixedPoint"); // TODO
   case CK_BaseToDerived:
   case CK_DerivedToBase:
   case CK_UncheckedDerivedToBase:
   case CK_Dynamic:
   case CK_ToUnion:
   case CK_ArrayToPointerDecay:
   case CK_FunctionToPointerDecay:
case UO_LNot: {
     bool bres;
     if (!EvaluateAsBooleanCondition(E->getSubExpr(), bres, Info))
       return false;
     return Success(!bres, E);
   }
   }
 }
 
+/// HandleCast - This is used to evaluate implicit or explicit casts where the
+/// result type is integer.
+bool FixedPointExprEvaluator::VisitCastExpr(const CastExpr *E) {
+  const Expr *SubExpr = E->getSubExpr();
+  QualType DestType = E->getType();
+  QualType SrcType = SubExpr->getType();
+
+  switch (E->getCastKind()) {
+  default: llvm_unreachable("unknown cast resulting in fixed point value");
+  case CK_FixedPointCast: {
+    assert(DestType->isFixedPointType());
+    assert(SrcType->isFixedPointType());
+
+    if (!Visit(SubExpr))
+      return false;
+
+    assert(Result.isInt());
+
+    unsigned dest_fbits = getFixedPointFBits(DestType);
+    unsigned src_fbits = getFixedPointFBits(SrcType);
+    APSInt Val = Result.getInt();
+
+    Val.setIsSigned(DestType->isSignedFixedPointType());
+    unsigned DestWidth = Info.Ctx.getIntWidth(DestType);
+    Val = Val.extOrTrunc(DestWidth);
+
+    if (dest_fbits > src_fbits) {
+      Val <<= (dest_fbits - src_fbits);
+    } else if (dest_fbits < src_fbits) {
+      Val >>= (src_fbits - dest_fbits);
+    }
+
+    return Success(Val, E);
+  }
+
+  case CK_IntegralToFixedPoint: {
+    assert(DestType->isFixedPointType());
+    assert(SrcType->isIntegralOrEnumerationType());
+
+    if (!Visit(SubExpr))
+      return false;
+
+    assert(Result.isInt());
+
+    unsigned dest_fbits = getFixedPointFBits(DestType);
+
+    APSInt Val = Result.getInt();
+
+    Val.setIsSigned(DestType->isSignedFixedPointType());
+    Val <<= dest_fbits;
+
+    unsigned DestWidth = Info.Ctx.getIntWidth(DestType);
+    Val = Val.extOrTrunc(DestWidth);
+
+    return Success(Val, E);
+  }
+
+  case CK_UserDefinedConversion:
+  case CK_LValueToRValue:
+  case CK_AtomicToNonAtomic:
+  case CK_NoOp:
+    return ExprEvaluatorBaseTy::VisitCastExpr(E);
+  }
+}
+
 //===----------------------------------------------------------------------===//
 // Float Evaluation
 //===----------------------------------------------------------------------===//
 
 namespace {
 class FloatExprEvaluator
   : public ExprEvaluatorBase<FloatExprEvaluator> {
   APFloat &Result;
if (SubExpr->getType()->isRealFloatingType()) {
     return true;
   }
 }
 
 bool ComplexExprEvaluator::VisitCastExpr(const CastExpr *E) {
 
   switch (E->getCastKind()) {
   case CK_IntegralToFixedPoint: llvm_unreachable("ComplexExprEvaluator::VisitCastExpr CK_IntegralToFixedPoint"); // TODO
+  case CK_FixedPointCast: 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/AST/Type.cpp

 #include "clang/AST/TemplateName.h"
 #include "clang/AST/TypeVisitor.h"
 #include "clang/Basic/AddressSpaces.h"
 #include "clang/Basic/ExceptionSpecificationType.h"
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/Linkage.h"
+#include "clang/Basic/FixedPoint.h"
 #include "clang/Basic/Specifiers.h"
 #include "clang/Basic/TargetCXXABI.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/Visibility.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/FoldingSet.h"
QualType::DestructionKind QualType::isDestructedTypeImpl(QualType type) {
   }
 
   return DK_none;
 }
 
 CXXRecordDecl *MemberPointerType::getMostRecentCXXRecordDecl() const {
   return getClass()->getAsCXXRecordDecl()->getMostRecentDecl();
 }
+
+unsigned clang::getFixedPointFBits(const QualType& Ty) {
+  assert(Ty->isFixedPointType());
+
+  const auto *BT = Ty->getAs<BuiltinType>();
+  switch (BT->getKind()) {
+    default: llvm_unreachable("Not a fixed point type!");
+    case BuiltinType::ShortAccum:
+    case BuiltinType::SatShortAccum:
+      return BUILTIN_SACCUM_FBIT;
+
+    case BuiltinType::Accum:
+    case BuiltinType::SatAccum:
+      return BUILTIN_ACCUM_FBIT;
+
+    case BuiltinType::LongAccum:
+    case BuiltinType::SatLongAccum:
+      return BUILTIN_LACCUM_FBIT;
+
+    case BuiltinType::UShortAccum:
+    case BuiltinType::SatUShortAccum:
+      return BUILTIN_USACCUM_FBIT;
+
+    case BuiltinType::UAccum:
+    case BuiltinType::SatUAccum:
+      return BUILTIN_UACCUM_FBIT;
+
+    case BuiltinType::ULongAccum:
+    case BuiltinType::SatULongAccum:
+      return BUILTIN_ULACCUM_FBIT;
+
+    case BuiltinType::ShortFract:
+    case BuiltinType::SatShortFract:
+      return BUILTIN_SFRACT_FBIT;
+
+    case BuiltinType::Fract:
+    case BuiltinType::SatFract:
+      return BUILTIN_FRACT_FBIT;
+
+    case BuiltinType::LongFract:
+    case BuiltinType::SatLongFract:
+      return BUILTIN_LFRACT_FBIT;
+
+    case BuiltinType::UShortFract:
+    case BuiltinType::SatUShortFract:
+      return BUILTIN_USFRACT_FBIT;
+
+    case BuiltinType::UFract:
+    case BuiltinType::SatUFract:
+      return BUILTIN_UFRACT_FBIT;
+
+    case BuiltinType::ULongFract:
+    case BuiltinType::SatULongFract:
+      return BUILTIN_ULFRACT_FBIT;
+  }
+}
+
+unsigned clang::getFixedPointIBits(const QualType& Ty) {
+  assert(Ty->isFixedPointType());
+
+  const auto *BT = Ty->getAs<BuiltinType>();
+  switch (BT->getKind()) {
+    default: llvm_unreachable("Not a fixed point type!");
+    case BuiltinType::ShortAccum:
+    case BuiltinType::SatShortAccum:
+      return BUILTIN_SACCUM_IBIT;
+
+    case BuiltinType::Accum:
+    case BuiltinType::SatAccum:
+      return BUILTIN_ACCUM_IBIT;
+
+    case BuiltinType::LongAccum:
+    case BuiltinType::SatLongAccum:
+      return BUILTIN_LACCUM_IBIT;
+
+    case BuiltinType::UShortAccum:
+    case BuiltinType::SatUShortAccum:
+      return BUILTIN_USACCUM_IBIT;
+
+    case BuiltinType::UAccum:
+    case BuiltinType::SatUAccum:
+      return BUILTIN_UACCUM_IBIT;
+
+    case BuiltinType::ULongAccum:
+    case BuiltinType::SatULongAccum:
+      return BUILTIN_ULACCUM_IBIT;
+
+    case BuiltinType::ShortFract:
+    case BuiltinType::Fract:
+    case BuiltinType::LongFract:
+    case BuiltinType::UShortFract:
+    case BuiltinType::UFract:
+    case BuiltinType::ULongFract:
+    case BuiltinType::SatShortFract:
+    case BuiltinType::SatFract:
+    case BuiltinType::SatLongFract:
+    case BuiltinType::SatUShortFract:
+    case BuiltinType::SatUFract:
+    case BuiltinType::SatULongFract:
+      return 0;
+  }
+}

lib/CodeGen/CGExpr.cpp

 /// otherwise if a cast is needed by the code generator in an lvalue context,
 /// 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_IntegralToFixedPoint: llvm_unreachable("CodeGenFunction::EmitCastLValue CK_IntegralToFixedPoint"); // TODO
+  case CK_FixedPointCast: llvm_unreachable("CK_FixedPointCast"); // 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

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_FixedPointCast: llvm_unreachable("CK_FixedPointCast"); // TODO
   case CK_IntegralToFixedPoint: llvm_unreachable("AggExprEmitter::VisitCastExpr CK_IntegralToFixedPoint"); // 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())

lib/CodeGen/CGExprComplex.cpp

ComplexPairTy ComplexExprEmitter::EmitScalarToComplexCast(llvm::Value *Val,
   // Return (realval, 0).
   return ComplexPairTy(Val, llvm::Constant::getNullValue(Val->getType()));
 }
 
 ComplexPairTy ComplexExprEmitter::EmitCast(CastKind CK, Expr *Op,
                                            QualType DestTy) {
   switch (CK) {
   case CK_IntegralToFixedPoint: llvm_unreachable("ComplexExprEmitter::EmitCast CK_IntegralToFixedPoint"); // TODO
+  case CK_FixedPointCast: llvm_unreachable("CK_FixedPointCast"); // 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_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!");
 
       auto field = E->getTargetUnionField();
 

lib/CodeGen/CGExprScalar.cpp

if (Ops.Ty->isSignedIntegerOrEnumerationType()) {
         // Fall through.
       case LangOptions::SOB_Trapping:
         if (CanElideOverflowCheck(CGF.getContext(), Ops))
           return Builder.CreateNSWMul(Ops.LHS, Ops.RHS, "mul");
         return EmitOverflowCheckedBinOp(Ops);
       }
     }
 
+    // If either is a fixed point, we will need to cast up before multiplying.
+    if (Ops.Ty->isFixedPointType()){
+      const auto* BinExpr = dyn_cast<BinaryOperator>(Ops.E);
+      const Expr* LHS = BinExpr->getLHS();
+      const Expr* RHS = BinExpr->getRHS();
+      Value* LHSVal = Ops.LHS;
+      Value* RHSVal = Ops.RHS;
+      QualType LHSTy = LHS->getType();
+      QualType RHSTy = RHS->getType();
+
+      // At least one side should be implicitely casted up to fixed point
+      assert(LHSTy->isFixedPointType() && RHSTy->isFixedPointType());
+      assert(LHSTy == RHSTy);
+
+      bool isSignedResult = LHSTy->isSignedFixedPointType() || RHSTy->isSignedFixedPointType();
+
+      // Round up the bit widths to allocate enough space for calculating the
+      // result.
+      unsigned LHSWidth = CGF.getContext().getIntWidth(LHSTy);
+      unsigned bufferWidth = LHSWidth * 2;
+      if (bufferWidth > 128) {
+        bufferWidth = 128;
+      }
+
+      LHSVal = Builder.CreateIntCast(LHSVal, Builder.getIntNTy(bufferWidth), isSignedResult);
+      RHSVal = Builder.CreateIntCast(RHSVal, Builder.getIntNTy(bufferWidth), isSignedResult);
+
+      llvm::Value* MulResult = Builder.CreateMul(LHSVal, RHSVal);
+      MulResult = Builder.CreateAShr(MulResult, getFixedPointFBits(Ops.Ty));
+      return Builder.CreateIntCast(MulResult, Builder.getIntNTy(LHSWidth), isSignedResult);
+    }
+
     if (Ops.Ty->isUnsignedIntegerType() &&
         CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow) &&
         !CanElideOverflowCheck(CGF.getContext(), Ops))
       return EmitOverflowCheckedBinOp(Ops);
 
     if (Ops.LHS->getType()->isFPOrFPVectorTy()) {
       Value *V = Builder.CreateFMul(Ops.LHS, Ops.RHS, "mul");
       return propagateFMFlags(V, Ops);
if (SrcTy->isFloatingPointTy()) {
             CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16, SrcTy), Src);
       // If the half type is supported, just use an fptrunc.
       return Builder.CreateFPTrunc(Src, DstTy);
     }
     DstTy = CGF.FloatTy;
   }
 
   if (isa<llvm::IntegerType>(SrcTy)) {
-    bool InputSigned = SrcType->isSignedIntegerOrEnumerationType();
+    bool InputSigned = (SrcType->isSignedIntegerOrEnumerationType() ||
+                        SrcType->isFixedPointType());
     if (SrcType->isBooleanType() && TreatBooleanAsSigned) {
       InputSigned = true;
     }
     if (isa<llvm::IntegerType>(DstTy))
       Res = Builder.CreateIntCast(Src, DstTy, InputSigned, "conv");
     else if (InputSigned)
       Res = Builder.CreateSIToFP(Src, DstTy, "conv");
     else
Value *ScalarExprEmitter::VisitCastExpr(CastExpr *CE) {
   case CK_VectorSplat: {
     llvm::Type *DstTy = ConvertType(DestTy);
     Value *Elt = Visit(const_cast<Expr*>(E));
     // Splat the element across to all elements
     unsigned NumElements = DstTy->getVectorNumElements();
     return Builder.CreateVectorSplat(NumElements, Elt, "splat");
   }
 
-  case CK_IntegralToFixedPoint: {
+  case CK_FixedPointCast: {
+    // Casting between fixed point types involves separating the integral and
+    // fractional bits, potentially shifting them, then joining back together.
     assert(DestTy->isFixedPointType());
-    assert(E->getType()->isIntegerType());
+    assert(E->getType()->isFixedPointType());
 
-    unsigned fbits;
-    const auto *BT = DestTy->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;
-    }
+    unsigned dest_fbits = getFixedPointFBits(DestTy);
+    unsigned src_fbits = getFixedPointFBits(E->getType());
+    unsigned dest_ibits = getFixedPointIBits(DestTy);
+    unsigned src_ibits = getFixedPointIBits(E->getType());
+
+    llvm::Value* result = EmitScalarConversion(Visit(E), E->getType(), DestTy, CE->getExprLoc());
+
+    // If the number of integral bits is decreasing, trim off any extra bits while
+    // retaining the sign.
+    if (dest_ibits < src_ibits) {
+      result = Builder.CreateShl(result, src_ibits - dest_ibits);
+      result = Builder.CreateAShr(result, src_ibits - dest_ibits);
+    }
+
+    // Move the radix. For irrational numbers, there will be loss of precision using
+    // this method when the number of fbits increases since we will be right padding
+    // zeros. Precision can still be retained if we temporarily convert to a float
+    // and perform some floating point arithmetic, though this may cost more. Enable
+    // that if #pragma FX_FULL_PRECISION is provided.
+    if (dest_fbits > src_fbits) {
+      result = EmitScalarConversion(result, E->getType(), DestTy, CE->getExprLoc());
+      result = Builder.CreateShl(result, dest_fbits - src_fbits);
+    } else if (dest_fbits < src_fbits) {
+      result = Builder.CreateAShr(result, src_fbits - dest_fbits);
+    }
+    return result;
 
+  case CK_IntegralToFixedPoint: {
+    assert(DestTy->isFixedPointType());
+    assert(E->getType()->isIntegerType());
     return Builder.CreateShl(EmitScalarConversion(Visit(E), E->getType(), DestTy, CE->getExprLoc()),
-                             fbits, "fixed_point_shl");
+                             getFixedPointFBits(DestTy), "int_to_fixed");
   }
 
   case CK_IntegralCast:
   case CK_IntegralToFloating:
   case CK_FloatingToIntegral:
   case CK_FloatingCast:
     return EmitScalarConversion(Visit(E), E->getType(), DestTy,
                                 CE->getExprLoc());
switch (BT->getKind()) {
       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,
+    llvm::Value *amt = llvm::ConstantInt::get(value->getType(), 1ULL << 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.
if ((CGF.SanOpts.has(SanitizerKind::IntegerDivideByZero) ||
                Ops.mayHaveFloatDivisionByZero()) {
       llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty));
       llvm::Value *NonZero = Builder.CreateFCmpUNE(Ops.RHS, Zero);
       EmitBinOpCheck(std::make_pair(NonZero, SanitizerKind::FloatDivideByZero),
                      Ops);
     }
   }
 
+  // If either is a fixed point, we will need to cast up before dividing.
+  if (Ops.Ty->isFixedPointType()){
+    const auto* BinExpr = dyn_cast<BinaryOperator>(Ops.E);
+    const Expr* LHS = BinExpr->getLHS();
+    const Expr* RHS = BinExpr->getRHS();
+    Value* LHSVal = Ops.LHS;
+    Value* RHSVal = Ops.RHS;
+    QualType LHSTy = LHS->getType();
+    QualType RHSTy = RHS->getType();
+
+    // At least one side should be implicitely casted up to fixed point
+    assert(LHSTy->isFixedPointType() && RHSTy->isFixedPointType());
+    assert(LHSTy == RHSTy);
+
+    bool isSignedResult = LHSTy->isSignedFixedPointType() || RHSTy->isSignedFixedPointType();
+
+    // Round up the bit widths to allocate enough space for calculating the
+    // result.
+    unsigned LHSWidth = CGF.getContext().getIntWidth(LHSTy);
+    unsigned bufferWidth = LHSWidth * 2;
+    if (bufferWidth > 128) {
+      bufferWidth = 128;
+    }
+
+    LHSVal = Builder.CreateIntCast(LHSVal, Builder.getIntNTy(bufferWidth), isSignedResult);
+    RHSVal = Builder.CreateIntCast(RHSVal, Builder.getIntNTy(bufferWidth), isSignedResult);
+    LHSVal = Builder.CreateShl(LHSVal, getFixedPointFBits(LHSTy));
+
+    llvm::Value* DivResult = Builder.CreateSDiv(LHSVal, RHSVal);
+    return Builder.CreateIntCast(DivResult, Builder.getIntNTy(LHSWidth), isSignedResult);
+  }
+
   if (Ops.LHS->getType()->isFPOrFPVectorTy()) {
     llvm::Value *Val = Builder.CreateFDiv(Ops.LHS, Ops.RHS, "div");
     if (CGF.getLangOpts().OpenCL &&
         !CGF.CGM.getCodeGenOpts().CorrectlyRoundedDivSqrt) {
       // OpenCL v1.1 s7.4: minimum accuracy of single precision / is 2.5ulp
       // OpenCL v1.2 s5.6.4.2: The -cl-fp32-correctly-rounded-divide-sqrt
       // build option allows an application to specify that single precision
       // floating-point divide (x/y and 1/x) and sqrt used in the program

lib/Edit/RewriteObjCFoundationAPI.cpp

static bool rewriteToNumericBoxedExpression(const ObjCMessageExpr *Msg,
   uint64_t OrigTySize = Ctx.getTypeSize(OrigTy);
 
   bool isTruncated = FinalTySize < OrigTySize; 
   bool needsCast = false;
 
   if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Arg)) {
     switch (ICE->getCastKind()) {
     case CK_IntegralToFixedPoint: llvm_unreachable("rewriteToNumericBoxedExpression CK_IntegralToFixedPoint"); // TODO
+    case CK_FixedPointCast: llvm_unreachable("rewriteToNumericBoxedExpression CK_FixedPointCast"); // TODO
     case CK_LValueToRValue:
     case CK_NoOp:
     case CK_UserDefinedConversion:
       break;
 
     case CK_IntegralCast: {
       if (MK == NSAPI::NSNumberWithBool && OrigTy->isBooleanType())
         break;

lib/Sema/SemaExpr.cpp

static QualType handleFixedPointConversion(Sema &S, ExprResult &LHS,
   // At this point, the only other type we should be able to convert to is
   // integer types since all prior types were handled beforehand in
   // UsualArithmeticConventions().
   bool LHSFixed = LHSType->isFixedPointType();
   bool RHSFixed = RHSType->isFixedPointType();
 
   if (LHSFixed && RHSFixed) {
     // Cast up the smaller operand to the bigger
-    llvm_unreachable("Unhandled conversion between fixed point types");  // TODO
+    int order = S.Context.getFixedPointTypeOrder(LHSType, RHSType);
+    if (order > 0) {
+      RHS = S.ImpCastExprToType(RHS.get(), LHSType, CK_FixedPointCast);
+      return LHSType;
+    } else if (!order) {
+      bool LHSSigned = LHSType->isSignedFixedPointType();
+      bool RHSSigned = RHSType->isSignedFixedPointType();
+      if (LHSSigned && !RHSSigned) {
+        RHS = S.ImpCastExprToType(RHS.get(), LHSType, CK_FixedPointCast);
+        return LHSType;
+      } else if (!LHSSigned && RHSSigned) {
+        if (!IsCompAssign)
+          LHS = S.ImpCastExprToType(LHS.get(), RHSType, CK_FixedPointCast);
+        return RHSType;
+      } else {
+        assert(LHSType == RHSType);
+        return LHSType;
+      }
+    } else {
+      if (!IsCompAssign)
+        LHS = S.ImpCastExprToType(LHS.get(), RHSType, CK_FixedPointCast);
+      return RHSType;
+    }
   } else if (LHSFixed) {
     assert(RHSType->isIntegerType());
     return handleIntToFixedPointConversion(S, LHS, RHS, LHSType, RHSType);
   } else if (RHSFixed) {
     assert(LHSType->isIntegerType());
     return handleIntToFixedPointConversion(S, RHS, LHS, RHSType, LHSType);
   } else {
-    llvm_unreachable("Expected LHS and RHS to both be fixed point types.");
+    llvm_unreachable("Expected LHS and RHS to both be fixed point or integral types.");
   }
 }
 
 /// UsualArithmeticConversions - Performs various conversions that are common to
 /// binary operators (C99 6.3.1.8). If both operands aren't arithmetic, this
 /// routine returns the first non-arithmetic type found. The client is
 /// responsible for emitting appropriate error diagnostics.
 QualType Sema::UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS,
if (Literal.isFixedPointLiteral()){
     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.
       uint64_t max_int_val = 0;
       if (isSigned) {
-        max_int_val = 1 << (ibits - 1);  // min signed is -2^(n-1)
+        max_int_val = 1ULL << (ibits - 1);  // min signed is -2^(n-1)
       } else {
-        max_int_val = (1 << ibits) - 1;
+        max_int_val = (1ULL << ibits) - 1;
       }
 
       // TODO: What should be done for literals with no unsigned suffix whose
       // value is equal to the absolute value of the smallest possible value for
       // that type. Ie. 128.0hk -> -128.0hk? What happens is user writes
       // "-128.0hk" since we are only interpretting a literal and do now know of
       // the unary operator?
       if (int_part_as_int > max_int_val) {
         Diag(Tok.getLocation(), diag::err_integral_part_of_accum_too_large) << (isSigned ? 0 : 1);
       }
     }
 
-    uint64_t fract_part_as_int = static_cast<uint64_t>(fabs(fract_part) * (1 << fbits));
+    uint64_t fract_part_as_int = static_cast<uint64_t>(fract_part * (1ULL << fbits));
     uint64_t final_fixed_point_as_int = (int_part_as_int << fbits) + fract_part_as_int;
 
     llvm::APInt ResultVal(bit_width, final_fixed_point_as_int, isSigned);
     Res = FixedPointLiteral::CreateFromRawInt(Context, ResultVal, Ty, Tok.getLocation());
   } else if (Literal.isFloatingLiteral()) {
     QualType Ty;
     if (Literal.isHalf){
       if (getOpenCLOptions().isEnabled("cl_khr_fp16"))
QualType Sema::CheckShiftOperands(ExprResult &LHS, ExprResult &RHS,
   // The RHS is simpler.
   RHS = UsualUnaryConversions(RHS.get());
   if (RHS.isInvalid())
     return QualType();
   QualType RHSType = RHS.get()->getType();
 
   // C99 6.5.7p2: Each of the operands shall have integer type.
   if (!LHSType->hasIntegerRepresentation() ||
-      !RHSType->hasIntegerRepresentation())
+      !RHSType->hasIntegerRepresentation()) {
+    if (!LHSType->isFixedPointType()) {
       return InvalidOperands(Loc, LHS, RHS);
+    }
+  }
 
   // C++0x: Don't allow scoped enums. FIXME: Use something better than
   // hasIntegerRepresentation() above instead of this.
   if (isScopedEnumerationType(LHSType) ||
       isScopedEnumerationType(RHSType)) {
     return InvalidOperands(Loc, LHS, RHS);
   }
   // Sanity-check shift operands

lib/StaticAnalyzer/Core/ExprEngineC.cpp

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

-// RUN: %clang -S -emit-llvm %s -o - | FileCheck %s
 // RUN: %clang_cc1 -S -emit-llvm -o - %s | lli
+// RUN: %clang -S -emit-llvm %s -o - | FileCheck %s
 
 // 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
int main(){
   // CHECK-NEXT: {{.*}} = icmp eq i16 {{.*}}, {{.*}}
 
   assert(s_accum == 2);
   // CHECK:      {{.*}} = icmp eq i16 {{.*}}, 256
 
   assert(2 == s_accum);
   // CHECK:      {{.*}} = icmp eq i16 256, {{.*}}
 
+  assert(2 == 2.0hk);
+  assert(2 != 2.01hk);
+
   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);
int main(){
   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
 
+  // Comparisons between fixed-point types
+  // Signed _Accum to signed _Accum types.
+  assert(2.5hk == 2.5k);
+  assert(2.5k == 2.5lk);
+  assert(-2.5hk == -2.5k);
+  assert(-2.5k == -2.5lk);
+
+  // Unsigned _Accum to unigned _Accum
+  assert(2.5uhk == 2.5uk);
+  assert(2.5uk == 2.5ulk);
+
+  // Signed _Fract to signed _Fract types.
+  assert(0.333hr != 0.333r);  // Loss of precision since different fractional widths
+  assert(0.333r != 0.333lr);
+  assert(-0.333hr != -0.333r);
+  assert(-0.333r != -0.333lr);
+
+  // Unsigned _Fract to unsigned _Fract types.
+  assert(0.333uhr != 0.333ur);
+  assert(0.333ur != 0.333ulr);
+
+  // Signed _Accum to signed _Fract
+  assert(0.333hk == 0.333hr);
+  assert(0.333k == 0.333r);
+  assert(0.333lk == 0.333lr);
+  assert(0.333hk == 0.333r);  // Although _Fract has higher precision, it gets casted up to
+                              // short _Accum which (using default precisions)
+                              // has fewer fractional bits.
+
+  // Signed _Accum to unsigned _Fract
+  assert(0.333hk == 0.333uhr);
+  assert(0.333k == 0.333ur);
+  assert(0.333lk == 0.333ulr);
+
+  // Signed _Accum to unsigned _Accum
+  assert(2.5hk == 2.5uhk);
+  assert(2.5k == 2.5uk);
+  assert(2.5lk == 2.5ulk);
+
+
   /**************** 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
int main(){
   // 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);
+
+  /**************** Binary operations ***************/
+
+  // Addition
+  s_accum = 3.0hk;
+  short _Accum s_accum_sum = s_accum + s_accum2;
+  assert(s_accum_sum == 5);
+  assert(s_fract + s_fract2 == 0);
+
+  // Subtraction
+  short _Accum s_accum_diff = s_accum - s_accum2;
+  assert(s_accum_diff == 1);
+  assert(s_accum2 - s_accum == -1);
+
+  // Multiplication
+  short _Accum s_accum_mul = s_accum * s_accum2;
+  assert(s_accum_mul == 6);
+  assert(2.0hk * 3.0hk == 6);
+  assert(2.0hk * 3 == 6);
+  assert(2.5hk * 3 == 7.5k);
+  assert(-2.5hk * 3 == -7.5lk);
+  assert(3 * -2.5hk == -7.5hk);
+  assert(-2.5hk * 0 == 0);
+
+  // Division
+  const short _Accum s_accum3 = 2.5hk;
+  short _Accum s_accum_div = s_accum3 / s_accum2;
+  assert(s_accum_div == 1.25hk);
+  assert(5.0hk / s_accum3 == 2);
+  assert(-5.0hk / s_accum3 == -2);
+  assert(9.9k / 3.3k == 3);
+  assert(9.9hk / 3.3k != 3);  // We lose precision when converting between types of different
+                              // fractional width.
+  assert(6.75hk / 2.25k == 3);  // Unless the fractional part can be evenly represented with
+                                // sums of powers of 2.
+  assert(0 / 2.0hk == 0);
+
+  // Left shift
+  short _Accum s_accum_shl = s_accum2 << 3;
+  assert(s_accum_shl == 16);
+  assert(1.0hk << 3 == 8);
+  assert(-1.0hk << 3 == -8);
+  assert(1.5k << 1 == 3);  // LShift is equivalent to multiplying by 2
+  assert(-1.25hk << 2 == -5);
+
+  // Right shift
+  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);
 }