Implement constexpr BinaryOperator for vector types

[erichkeane]

Summary

These operations do member-wise versions of the all of the listed
operations. This patch implements all of the binaryoperators for these
types. Note that the test is required to use codegen as I could not come
up with a good way to validate the values without the array-subscript
operator implemented (which is likely a much more involved change).

This is not full constexpr support for these types, but should at least
support a large number of uses.

[RKSimon]

Adding some people who know more about this

[RKSimon]

Any frontend people got any comments on this? I'm keen to see constexpr vector support added but know next to nothing about the frontend.

[aaron.ballman]

clang/lib/AST/ExprConstant.cpp

2699

typo: Should

2741

Typo: Should

2754

const auto *

2778

Might as well remove the spurious whitespace.

2782

How about:

bool Success = true;
if (BinaryOperator::isLogicalOp(Opcode))
  Success = handleLogicalOpForVector(...);
else if (BinaryOperator::isComparisonOp(Opcode))
  Success = handleCompareOpForVector(...);
else
  Success = handleIntIntBinOp(...);

if (!Success) {
  Info.FFDiag(E);
  return false;
}
ResultElements.push_back(...);

2799

emplace_back() instead?

2800

Spurious newline?

2813

emplace_back() instead?

9688

Can you re-flow the rest of the comment now that it's been changed?

[erichkeane]

@AaronBallman's suggestions.

[aaron.ballman]

LGTM!

[RKSimon]

Committed at rGb30c16670e428d09a0854a8f418e46a3e705e4d1 (with a typo in the Differential Revision tag so phab didn't catch it)

clang/lib/AST/ExprConstant.cpp

static bool handleFloatFloatBinOp(EvalInfo &Info, const Expr *E,
   // FIXME: C++ rules require us to not conform to IEEE 754 here.
   if (LHS.isNaN()) {
     Info.CCEDiag(E, diag::note_constexpr_float_arithmetic) << LHS.isNaN();
     return Info.noteUndefinedBehavior();
   }
   return true;
 }
 
+static bool handleLogicalOpForVector(const APInt &LHSValue,
+                                     BinaryOperatorKind Opcode,
+                                     const APInt &RHSValue, APInt &Result) {
+  bool LHS = (LHSValue != 0);
+  bool RHS = (RHSValue != 0);
+
+  if (Opcode == BO_LAnd)
+    Result = LHS && RHS;
+  else
+    Result = LHS || RHS;
+  return true;
+}
+static bool handleLogicalOpForVector(const APFloat &LHSValue,
+                                     BinaryOperatorKind Opcode,
+                                     const APFloat &RHSValue, APInt &Result) {
+  bool LHS = !LHSValue.isZero();
+  bool RHS = !RHSValue.isZero();
+
+  if (Opcode == BO_LAnd)
+    Result = LHS && RHS;
+  else
+    Result = LHS || RHS;
+  return true;
+}
+
+static bool handleLogicalOpForVector(const APValue &LHSValue,
+                                     BinaryOperatorKind Opcode,
+                                     const APValue &RHSValue, APInt &Result) {
+  // The result is always an int type, however operands match the first.
+  if (LHSValue.getKind() == APValue::Int)
+    return handleLogicalOpForVector(LHSValue.getInt(), Opcode,
+                                    RHSValue.getInt(), Result);
+  assert(LHSValue.getKind() == APValue::Float && "SHhuld be no other options");
+  return handleLogicalOpForVector(LHSValue.getFloat(), Opcode,
+                                  RHSValue.getFloat(), Result);
+}
+
+template <typename APTy>
+static bool
+handleCompareOpForVectorHelper(const APTy &LHSValue, BinaryOperatorKind Opcode,
+                               const APTy &RHSValue, APInt &Result) {
+  switch (Opcode) {
+  default:
+    llvm_unreachable("unsupported binary operator");
+  case BO_EQ:
+    Result = (LHSValue == RHSValue);
+    break;
+  case BO_NE:
+    Result = (LHSValue != RHSValue);
+    break;
+  case BO_LT:
+    Result = (LHSValue < RHSValue);
+    break;
+  case BO_GT:
+    Result = (LHSValue > RHSValue);
+    break;
+  case BO_LE:
+    Result = (LHSValue <= RHSValue);
+    break;
+  case BO_GE:
+    Result = (LHSValue >= RHSValue);
+    break;
+  }
+
+  return true;
+}
+
+static bool handleCompareOpForVector(const APValue &LHSValue,
+                                     BinaryOperatorKind Opcode,
+                                     const APValue &RHSValue, APInt &Result) {
+  // The result is always an int type, however operands match the first.
+  if (LHSValue.getKind() == APValue::Int)
+    return handleCompareOpForVectorHelper(LHSValue.getInt(), Opcode,
+                                          RHSValue.getInt(), Result);
+  assert(LHSValue.getKind() == APValue::Float && "SHhuld be no other options");
+  return handleCompareOpForVectorHelper(LHSValue.getFloat(), Opcode,
+                                        RHSValue.getFloat(), Result);
+}
+
+// Perform binary operations for vector types, in place on the LHS.
+static bool handleVectorVectorBinOp(EvalInfo &Info, const Expr *E,
+                                    BinaryOperatorKind Opcode,
+                                    APValue &LHSValue,
+                                    const APValue &RHSValue) {
+  assert(Opcode != BO_PtrMemD && Opcode != BO_PtrMemI &&
+         "Operation not supported on vector types");
+
+  const VectorType *VT = E->getType()->castAs<VectorType>();
+  unsigned NumElements = VT->getNumElements();
+  QualType EltTy = VT->getElementType();
+
+  // In the cases (typically C as I've observed) where we aren't evaluating
+  // constexpr but are checking for cases where the LHS isn't yet evaluatable,
+  // just give up.
+  if (!LHSValue.isVector()) {
+    assert(LHSValue.isLValue() &&
+           "A vector result that isn't a vector OR uncalculated LValue");
+    Info.FFDiag(E);
+    return false;
+  }
+
+  assert(LHSValue.getVectorLength() == NumElements &&
+         RHSValue.getVectorLength() == NumElements && "Different vector sizes");
+
+  SmallVector<APValue, 4> ResultElements;
+
+  for (unsigned EltNum = 0; EltNum < NumElements; ++EltNum) {
+    APValue LHSElt = LHSValue.getVectorElt(EltNum);
+    APValue RHSElt = RHSValue.getVectorElt(EltNum);
+
+    if (EltTy->isIntegerType()) {
+
+      APSInt EltResult{Info.Ctx.getIntWidth(EltTy),
+                       EltTy->isUnsignedIntegerType()};
+
+      if (BinaryOperator::isLogicalOp(Opcode)) {
+        if (!handleLogicalOpForVector(LHSElt, Opcode, RHSElt, EltResult)) {
+          Info.FFDiag(E);
+          return false;
+        }
+      } else if (BinaryOperator::isComparisonOp(Opcode)) {
+        if (!handleCompareOpForVector(LHSElt, Opcode, RHSElt, EltResult)) {
+          Info.FFDiag(E);
+          return false;
+        }
+      } else {
+        if (!handleIntIntBinOp(Info, E, LHSElt.getInt(), Opcode,
+                               RHSElt.getInt(), EltResult)) {
+          Info.FFDiag(E);
+          return false;
+        }
+      }
+      ResultElements.push_back(APValue(EltResult));
+
+    } else if (EltTy->isFloatingType()) {
+      assert(LHSElt.getKind() == APValue::Float &&
+             RHSElt.getKind() == APValue::Float &&
+             "Mismatched LHS/RHS/Result Type");
+      APFloat LHSFloat = LHSElt.getFloat();
+
+      if (!handleFloatFloatBinOp(Info, E, LHSFloat, Opcode,
+                                 RHSElt.getFloat())) {
+        Info.FFDiag(E);
+        return false;
+      }
+
+      ResultElements.push_back(APValue(LHSFloat));
+    }
+  }
+
+  LHSValue = APValue(ResultElements.data(), ResultElements.size());
+  return true;
+}
+
 /// Cast an lvalue referring to a base subobject to a derived class, by
 /// truncating the lvalue's path to the given length.
 static bool CastToDerivedClass(EvalInfo &Info, const Expr *E, LValue &Result,
                                const RecordDecl *TruncatedType,
                                unsigned TruncatedElements) {
   SubobjectDesignator &D = Result.Designator;
 
   // Check we actually point to a derived class object.
case APValue::Float:
       return found(Subobj.getFloat(), SubobjType);
     case APValue::ComplexInt:
     case APValue::ComplexFloat:
       // FIXME: Implement complex compound assignment.
       Info.FFDiag(E);
       return false;
     case APValue::LValue:
       return foundPointer(Subobj, SubobjType);
+    case APValue::Vector:
+      return foundVector(Subobj, SubobjType);
     default:
       // FIXME: can this happen?
       Info.FFDiag(E);
       return false;
     }
   }
+
+  bool foundVector(APValue &Value, QualType SubobjType) {
+    if (!checkConst(SubobjType))
+      return false;
+
+    if (!SubobjType->isVectorType()) {
+      Info.FFDiag(E);
+      return false;
+    }
+    return handleVectorVectorBinOp(Info, E, Opcode, Value, RHS);
+  }
+
   bool found(APSInt &Value, QualType SubobjType) {
     if (!checkConst(SubobjType))
       return false;
 
     if (!SubobjType->isIntegerType()) {
       // We don't support compound assignment on integer-cast-to-pointer
       // values.
       Info.FFDiag(E);
public:
     }
     bool ZeroInitialization(const Expr *E);
 
     bool VisitUnaryReal(const UnaryOperator *E)
       { return Visit(E->getSubExpr()); }
     bool VisitCastExpr(const CastExpr* E);
     bool VisitInitListExpr(const InitListExpr *E);
     bool VisitUnaryImag(const UnaryOperator *E);
-    // FIXME: Missing: unary -, unary ~, binary add/sub/mul/div,
-    //                 binary comparisons, binary and/or/xor,
+    bool VisitBinaryOperator(const BinaryOperator *E);
+    // FIXME: Missing: unary -, unary ~,
     //                 conditional operator (for GNU conditional select),
     //                 shufflevector, ExtVectorElementExpr
   };
 } // end anonymous namespace
 
 static bool EvaluateVector(const Expr* E, APValue& Result, EvalInfo &Info) {
   assert(E->isRValue() && E->getType()->isVectorType() &&"not a vector rvalue");
   return VectorExprEvaluator(Info, Result).Visit(E);
VectorExprEvaluator::ZeroInitialization(const Expr *E) {
   return Success(Elements, E);
 }
 
 bool VectorExprEvaluator::VisitUnaryImag(const UnaryOperator *E) {
   VisitIgnoredValue(E->getSubExpr());
   return ZeroInitialization(E);
 }
 
+bool VectorExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
+  BinaryOperatorKind Op = E->getOpcode();
+  assert(Op != BO_PtrMemD && Op != BO_PtrMemI && Op != BO_Cmp &&
+         "Operation not supported on vector types");
+
+  if (Op == BO_Comma)
+    return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
+
+  Expr *LHS = E->getLHS();
+  Expr *RHS = E->getRHS();
+
+  assert(LHS->getType()->isVectorType() && RHS->getType()->isVectorType() &&
+         "Must both be vector types");
+  // Checking JUST the types are the same would be fine, except shifts don't
+  // need to have their types be the same (since you always shift by an int).
+  assert(LHS->getType()->getAs<VectorType>()->getNumElements() ==
+             E->getType()->getAs<VectorType>()->getNumElements() &&
+         RHS->getType()->getAs<VectorType>()->getNumElements() ==
+             E->getType()->getAs<VectorType>()->getNumElements() &&
+         "All operands must be the same size.");
+
+  APValue LHSValue;
+  APValue RHSValue;
+  bool LHSOK = Evaluate(LHSValue, Info, LHS);
+  if (!LHSOK && !Info.noteFailure())
+    return false;
+  if (!Evaluate(RHSValue, Info, RHS) || !LHSOK)
+    return false;
+
+  if (!handleVectorVectorBinOp(Info, E, Op, LHSValue, RHSValue))
+    return false;
+
+  return Success(LHSValue, E);
+}
+
 //===----------------------------------------------------------------------===//
 // Array Evaluation
 //===----------------------------------------------------------------------===//
 
 namespace {
   class ArrayExprEvaluator
   : public ExprEvaluatorBase<ArrayExprEvaluator> {
     const LValue &This;

clang/test/SemaCXX/constexpr-vectors.cpp

+// RUN: %clang_cc1 -std=c++14 -Wno-unused-value %s -disable-llvm-passes -triple x86_64-linux-gnu -emit-llvm -o - | FileCheck %s
+
+// FIXME: Unfortunately there is no good way to validate that our values are
+// correct since Vector types don't have operator [] implemented for constexpr.
+// Instead, we need to use filecheck to ensure the emitted IR is correct. Once
+// someone implements array subscript operator for these types as constexpr,
+// this test should modified to jsut use static asserts.
+
+using FourCharsVecSize __attribute__((vector_size(4))) = char;
+using FourIntsVecSize __attribute__((vector_size(16))) = int;
+using FourLongLongsVecSize __attribute__((vector_size(32))) = long long;
+using FourFloatsVecSize __attribute__((vector_size(16))) = float;
+using FourDoublesVecSize __attribute__((vector_size(32))) = double;
+
+using FourCharsExtVec __attribute__((ext_vector_type(4))) = char;
+using FourIntsExtVec __attribute__((ext_vector_type(4))) = int;
+using FourLongLongsExtVec __attribute__((ext_vector_type(4))) = long long;
+using FourFloatsExtVec __attribute__((ext_vector_type(4))) = float;
+using FourDoublesExtVec __attribute__((ext_vector_type(4))) = double;
+
+// Next a series of tests to make sure these operations are usable in
+// constexpr functions. Template instantiations don't emit Winvalid-constexpr,
+// so we have to do these as macros.
+#define MathShiftOps(Type)                            \
+  constexpr auto MathShiftOps##Type(Type a, Type b) { \
+    a = a + b;                                        \
+    a = a - b;                                        \
+    a = a * b;                                        \
+    a = a / b;                                        \
+    b = a + 1;                                        \
+    b = a - 1;                                        \
+    b = a * 1;                                        \
+    b = a / 1;                                        \
+    a += a;                                           \
+    a -= a;                                           \
+    a *= a;                                           \
+    a /= a;                                           \
+    b += a;                                           \
+    b -= a;                                           \
+    b *= a;                                           \
+    b /= a;                                           \
+    a < b;                                            \
+    a > b;                                            \
+    a <= b;                                           \
+    a >= b;                                           \
+    a == b;                                           \
+    a != b;                                           \
+    a &&b;                                            \
+    a || b;                                           \
+    auto c = (a, b);                                  \
+    return c;                                         \
+  }
+
+// Ops specific to Integers.
+#define MathShiftOpsInts(Type)                            \
+  constexpr auto MathShiftopsInts##Type(Type a, Type b) { \
+    a = a << b;                                           \
+    a = a >> b;                                           \
+    a = a << 3;                                           \
+    a = a >> 3;                                           \
+    a = 3 << b;                                           \
+    a = 3 >> b;                                           \
+    a <<= b;                                              \
+    a >>= b;                                              \
+    a <<= 3;                                              \
+    a >>= 3;                                              \
+    a = a % b;                                            \
+    a &b;                                                 \
+    a | b;                                                \
+    a ^ b;                                                \
+    return a;                                             \
+  }
+
+MathShiftOps(FourCharsVecSize);
+MathShiftOps(FourIntsVecSize);
+MathShiftOps(FourLongLongsVecSize);
+MathShiftOps(FourFloatsVecSize);
+MathShiftOps(FourDoublesVecSize);
+MathShiftOps(FourCharsExtVec);
+MathShiftOps(FourIntsExtVec);
+MathShiftOps(FourLongLongsExtVec);
+MathShiftOps(FourFloatsExtVec);
+MathShiftOps(FourDoublesExtVec);
+
+MathShiftOpsInts(FourCharsVecSize);
+MathShiftOpsInts(FourIntsVecSize);
+MathShiftOpsInts(FourLongLongsVecSize);
+MathShiftOpsInts(FourCharsExtVec);
+MathShiftOpsInts(FourIntsExtVec);
+MathShiftOpsInts(FourLongLongsExtVec);
+
+template <typename T, typename U>
+constexpr auto CmpMul(T t, U u) {
+  t *= u;
+  return t;
+}
+template <typename T, typename U>
+constexpr auto CmpDiv(T t, U u) {
+  t /= u;
+  return t;
+}
+template <typename T, typename U>
+constexpr auto CmpRem(T t, U u) {
+  t %= u;
+  return t;
+}
+
+template <typename T, typename U>
+constexpr auto CmpAdd(T t, U u) {
+  t += u;
+  return t;
+}
+
+template <typename T, typename U>
+constexpr auto CmpSub(T t, U u) {
+  t -= u;
+  return t;
+}
+
+template <typename T, typename U>
+constexpr auto CmpLSH(T t, U u) {
+  t <<= u;
+  return t;
+}
+
+template <typename T, typename U>
+constexpr auto CmpRSH(T t, U u) {
+  t >>= u;
+  return t;
+}
+
+template <typename T, typename U>
+constexpr auto CmpBinAnd(T t, U u) {
+  t &= u;
+  return t;
+}
+
+template <typename T, typename U>
+constexpr auto CmpBinXOr(T t, U u) {
+  t ^= u;
+  return t;
+}
+
+template <typename T, typename U>
+constexpr auto CmpBinOr(T t, U u) {
+  t |= u;
+  return t;
+}
+
+// Only int vs float makes a difference here, so we only need to test 1 of each.
+// Test Char to make sure the mixed-nature of shifts around char is evident.
+void CharUsage() {
+  constexpr auto a = FourCharsVecSize{6, 3, 2, 1} +
+                     FourCharsVecSize{12, 15, 5, 7};
+  // CHECK: store <4 x i8> <i8 18, i8 18, i8 7, i8 8>
+  constexpr auto b = FourCharsVecSize{19, 15, 13, 12} -
+                     FourCharsVecSize{13, 14, 5, 3};
+  // CHECK: store <4 x i8> <i8 6, i8 1, i8 8, i8 9>
+  constexpr auto c = FourCharsVecSize{8, 4, 2, 1} *
+                     FourCharsVecSize{3, 4, 5, 6};
+  // CHECK: store <4 x i8> <i8 24, i8 16, i8 10, i8 6>
+  constexpr auto d = FourCharsVecSize{12, 12, 10, 10} /
+                     FourCharsVecSize{6, 4, 5, 2};
+  // CHECK: store <4 x i8> <i8 2, i8 3, i8 2, i8 5>
+  constexpr auto e = FourCharsVecSize{12, 12, 10, 10} %
+                     FourCharsVecSize{6, 4, 4, 3};
+  // CHECK: store <4 x i8> <i8 0, i8 0, i8 2, i8 1>
+
+  constexpr auto f = FourCharsVecSize{6, 3, 2, 1} + 3;
+  // CHECK: store <4 x i8> <i8 9, i8 6, i8 5, i8 4>
+  constexpr auto g = FourCharsVecSize{19, 15, 12, 10} - 3;
+  // CHECK: store <4 x i8> <i8 16, i8 12, i8 9, i8 7>
+  constexpr auto h = FourCharsVecSize{8, 4, 2, 1} * 3;
+  // CHECK: store <4 x i8> <i8 24, i8 12, i8 6, i8 3>
+  constexpr auto j = FourCharsVecSize{12, 15, 18, 21} / 3;
+  // CHECK: store <4 x i8> <i8 4, i8 5, i8 6, i8 7>
+  constexpr auto k = FourCharsVecSize{12, 17, 19, 22} % 3;
+  // CHECK: store <4 x i8> <i8 0, i8 2, i8 1, i8 1>
+
+  constexpr auto l = 3 + FourCharsVecSize{6, 3, 2, 1};
+  // CHECK: store <4 x i8> <i8 9, i8 6, i8 5, i8 4>
+  constexpr auto m = 20 - FourCharsVecSize{19, 15, 12, 10};
+  // CHECK: store <4 x i8> <i8 1, i8 5, i8 8, i8 10>
+  constexpr auto n = 3 * FourCharsVecSize{8, 4, 2, 1};
+  // CHECK: store <4 x i8> <i8 24, i8 12, i8 6, i8 3>
+  constexpr auto o = 100 / FourCharsVecSize{12, 15, 18, 21};
+  // CHECK: store <4 x i8> <i8 8, i8 6, i8 5, i8 4>
+  constexpr auto p = 100 % FourCharsVecSize{12, 15, 18, 21};
+  // CHECK: store <4 x i8> <i8 4, i8 10, i8 10, i8 16>
+
+  constexpr auto q = FourCharsVecSize{6, 3, 2, 1} << FourCharsVecSize{1, 1, 2, 2};
+  // CHECK: store <4 x i8> <i8 12, i8 6, i8 8, i8 4>
+  constexpr auto r = FourCharsVecSize{19, 15, 12, 10} >>
+                     FourCharsVecSize{1, 1, 2, 2};
+  // CHECK: store <4 x i8> <i8 9, i8 7, i8 3, i8 2>
+  constexpr auto s = FourCharsVecSize{6, 3, 5, 10} << 1;
+  // CHECK: store <4 x i8> <i8 12, i8 6, i8 10, i8 20>
+  constexpr auto t = FourCharsVecSize{19, 15, 10, 20} >> 1;
+  // CHECK: store <4 x i8> <i8 9, i8 7, i8 5, i8 10>
+  constexpr auto u = 12 << FourCharsVecSize{1, 2, 3, 3};
+  // CHECK: store <4 x i8> <i8 24, i8 48, i8 96, i8 96>
+  constexpr auto v = 12 >> FourCharsVecSize{1, 2, 2, 1};
+  // CHECK: store <4 x i8> <i8 6, i8 3, i8 3, i8 6>
+
+  constexpr auto w = FourCharsVecSize{1, 2, 3, 4} <
+                     FourCharsVecSize{4, 3, 2, 1};
+  // CHECK: store <4 x i8> <i8 1, i8 1, i8 0, i8 0>
+  constexpr auto x = FourCharsVecSize{1, 2, 3, 4} >
+                     FourCharsVecSize{4, 3, 2, 1};
+  // CHECK: store <4 x i8> <i8 0, i8 0, i8 1, i8 1>
+  constexpr auto y = FourCharsVecSize{1, 2, 3, 4} <=
+                     FourCharsVecSize{4, 3, 3, 1};
+  // CHECK: store <4 x i8> <i8 1, i8 1, i8 1, i8 0>
+  constexpr auto z = FourCharsVecSize{1, 2, 3, 4} >=
+                     FourCharsVecSize{4, 3, 3, 1};
+  // CHECK: store <4 x i8> <i8 0, i8 0, i8 1, i8 1>
+  constexpr auto A = FourCharsVecSize{1, 2, 3, 4} ==
+                     FourCharsVecSize{4, 3, 3, 1};
+  // CHECK: store <4 x i8> <i8 0, i8 0, i8 1, i8 0>
+  constexpr auto B = FourCharsVecSize{1, 2, 3, 4} !=
+                     FourCharsVecSize{4, 3, 3, 1};
+  // CHECK: store <4 x i8> <i8 1, i8 1, i8 0, i8 1>
+
+  constexpr auto C = FourCharsVecSize{1, 2, 3, 4} < 3;
+  // CHECK: store <4 x i8> <i8 1, i8 1, i8 0, i8 0>
+  constexpr auto D = FourCharsVecSize{1, 2, 3, 4} > 3;
+  // CHECK: store <4 x i8> <i8 0, i8 0, i8 0, i8 1>
+  constexpr auto E = FourCharsVecSize{1, 2, 3, 4} <= 3;
+  // CHECK: store <4 x i8> <i8 1, i8 1, i8 1, i8 0>
+  constexpr auto F = FourCharsVecSize{1, 2, 3, 4} >= 3;
+  // CHECK: store <4 x i8> <i8 0, i8 0, i8 1, i8 1>
+  constexpr auto G = FourCharsVecSize{1, 2, 3, 4} == 3;
+  // CHECK: store <4 x i8> <i8 0, i8 0, i8 1, i8 0>
+  constexpr auto H = FourCharsVecSize{1, 2, 3, 4} != 3;
+  // CHECK: store <4 x i8> <i8 1, i8 1, i8 0, i8 1>
+
+  constexpr auto I = FourCharsVecSize{1, 2, 3, 4} &
+                     FourCharsVecSize{4, 3, 2, 1};
+  // CHECK: store <4 x i8> <i8 0, i8 2, i8 2, i8 0>
+  constexpr auto J = FourCharsVecSize{1, 2, 3, 4} ^
+                     FourCharsVecSize { 4, 3, 2, 1 };
+  // CHECK: store <4 x i8> <i8 5, i8 1, i8 1, i8 5>
+  constexpr auto K = FourCharsVecSize{1, 2, 3, 4} |
+                     FourCharsVecSize{4, 3, 2, 1};
+  // CHECK: store <4 x i8> <i8 5, i8 3, i8 3, i8 5>
+  constexpr auto L = FourCharsVecSize{1, 2, 3, 4} & 3;
+  // CHECK: store <4 x i8> <i8 1, i8 2, i8 3, i8 0>
+  constexpr auto M = FourCharsVecSize{1, 2, 3, 4} ^ 3;
+  // CHECK: store <4 x i8> <i8 2, i8 1, i8 0, i8 7>
+  constexpr auto N = FourCharsVecSize{1, 2, 3, 4} | 3;
+  // CHECK: store <4 x i8> <i8 3, i8 3, i8 3, i8 7>
+
+  constexpr auto O = FourCharsVecSize{5, 0, 6, 0} &&
+                     FourCharsVecSize{5, 5, 0, 0};
+  // CHECK: store <4 x i8> <i8 1, i8 0, i8 0, i8 0>
+  constexpr auto P = FourCharsVecSize{5, 0, 6, 0} ||
+                     FourCharsVecSize{5, 5, 0, 0};
+  // CHECK: store <4 x i8> <i8 1, i8 1, i8 1, i8 0>
+
+  constexpr auto Q = FourCharsVecSize{5, 0, 6, 0} && 3;
+  // CHECK: store <4 x i8> <i8 1, i8 0, i8 1, i8 0>
+  constexpr auto R = FourCharsVecSize{5, 0, 6, 0} || 3;
+  // CHECK: store <4 x i8> <i8 1, i8 1, i8 1, i8 1>
+
+  constexpr auto T = CmpMul(a, b);
+  // CHECK: store <4 x i8> <i8 108, i8 18, i8 56, i8 72>
+
+  constexpr auto U = CmpDiv(a, b);
+  // CHECK: store <4 x i8> <i8 3, i8 18, i8 0, i8 0>
+
+  constexpr auto V = CmpRem(a, b);
+  // CHECK: store <4 x i8> <i8 0, i8 0, i8 7, i8 8>
+
+  constexpr auto X = CmpAdd(a, b);
+  // CHECK: store <4 x i8> <i8 24, i8 19, i8 15, i8 17>
+
+  constexpr auto Y = CmpSub(a, b);
+  // CHECK: store <4 x i8> <i8 12, i8 17, i8 -1, i8 -1>
+
+  constexpr auto Z = CmpLSH(a, H);
+  // CHECK: store <4 x i8> <i8 36, i8 36, i8 7, i8 16>
+
+  constexpr auto aa = CmpRSH(a, H);
+  // CHECK: store <4 x i8> <i8 9, i8 9, i8 7, i8 4>
+
+  constexpr auto ab = CmpBinAnd(a, b);
+  // CHECK: store <4 x i8> <i8 2, i8 0, i8 0, i8 8>
+
+  constexpr auto ac = CmpBinXOr(a, b);
+  // CHECK: store <4 x i8> <i8 20, i8 19, i8 15, i8 1>
+
+  constexpr auto ad = CmpBinOr(a, b);
+  // CHECK: store <4 x i8> <i8 22, i8 19, i8 15, i8 9>
+}
+
+void CharExtVecUsage() {
+  constexpr auto a = FourCharsExtVec{6, 3, 2, 1} +
+                     FourCharsExtVec{12, 15, 5, 7};
+  // CHECK: store <4 x i8> <i8 18, i8 18, i8 7, i8 8>
+  constexpr auto b = FourCharsExtVec{19, 15, 13, 12} -
+                     FourCharsExtVec{13, 14, 5, 3};
+  // CHECK: store <4 x i8> <i8 6, i8 1, i8 8, i8 9>
+  constexpr auto c = FourCharsExtVec{8, 4, 2, 1} *
+                     FourCharsExtVec{3, 4, 5, 6};
+  // CHECK: store <4 x i8> <i8 24, i8 16, i8 10, i8 6>
+  constexpr auto d = FourCharsExtVec{12, 12, 10, 10} /
+                     FourCharsExtVec{6, 4, 5, 2};
+  // CHECK: store <4 x i8> <i8 2, i8 3, i8 2, i8 5>
+  constexpr auto e = FourCharsExtVec{12, 12, 10, 10} %
+                     FourCharsExtVec{6, 4, 4, 3};
+  // CHECK: store <4 x i8> <i8 0, i8 0, i8 2, i8 1>
+
+  constexpr auto f = FourCharsExtVec{6, 3, 2, 1} + 3;
+  // CHECK: store <4 x i8> <i8 9, i8 6, i8 5, i8 4>
+  constexpr auto g = FourCharsExtVec{19, 15, 12, 10} - 3;
+  // CHECK: store <4 x i8> <i8 16, i8 12, i8 9, i8 7>
+  constexpr auto h = FourCharsExtVec{8, 4, 2, 1} * 3;
+  // CHECK: store <4 x i8> <i8 24, i8 12, i8 6, i8 3>
+  constexpr auto j = FourCharsExtVec{12, 15, 18, 21} / 3;
+  // CHECK: store <4 x i8> <i8 4, i8 5, i8 6, i8 7>
+  constexpr auto k = FourCharsExtVec{12, 17, 19, 22} % 3;
+  // CHECK: store <4 x i8> <i8 0, i8 2, i8 1, i8 1>
+
+  constexpr auto l = 3 + FourCharsExtVec{6, 3, 2, 1};
+  // CHECK: store <4 x i8> <i8 9, i8 6, i8 5, i8 4>
+  constexpr auto m = 20 - FourCharsExtVec{19, 15, 12, 10};
+  // CHECK: store <4 x i8> <i8 1, i8 5, i8 8, i8 10>
+  constexpr auto n = 3 * FourCharsExtVec{8, 4, 2, 1};
+  // CHECK: store <4 x i8> <i8 24, i8 12, i8 6, i8 3>
+  constexpr auto o = 100 / FourCharsExtVec{12, 15, 18, 21};
+  // CHECK: store <4 x i8> <i8 8, i8 6, i8 5, i8 4>
+  constexpr auto p = 100 % FourCharsExtVec{12, 15, 18, 21};
+  // CHECK: store <4 x i8> <i8 4, i8 10, i8 10, i8 16>
+
+  constexpr auto q = FourCharsExtVec{6, 3, 2, 1} << FourCharsVecSize{1, 1, 2, 2};
+  // CHECK: store <4 x i8> <i8 12, i8 6, i8 8, i8 4>
+  constexpr auto r = FourCharsExtVec{19, 15, 12, 10} >>
+                     FourCharsExtVec{1, 1, 2, 2};
+  // CHECK: store <4 x i8> <i8 9, i8 7, i8 3, i8 2>
+  constexpr auto s = FourCharsExtVec{6, 3, 5, 10} << 1;
+  // CHECK: store <4 x i8> <i8 12, i8 6, i8 10, i8 20>
+  constexpr auto t = FourCharsExtVec{19, 15, 10, 20} >> 1;
+  // CHECK: store <4 x i8> <i8 9, i8 7, i8 5, i8 10>
+  constexpr auto u = 12 << FourCharsExtVec{1, 2, 3, 3};
+  // CHECK: store <4 x i8> <i8 24, i8 48, i8 96, i8 96>
+  constexpr auto v = 12 >> FourCharsExtVec{1, 2, 2, 1};
+  // CHECK: store <4 x i8> <i8 6, i8 3, i8 3, i8 6>
+
+  constexpr auto w = FourCharsExtVec{1, 2, 3, 4} <
+                     FourCharsExtVec{4, 3, 2, 1};
+  // CHECK: store <4 x i8> <i8 1, i8 1, i8 0, i8 0>
+  constexpr auto x = FourCharsExtVec{1, 2, 3, 4} >
+                     FourCharsExtVec{4, 3, 2, 1};
+  // CHECK: store <4 x i8> <i8 0, i8 0, i8 1, i8 1>
+  constexpr auto y = FourCharsExtVec{1, 2, 3, 4} <=
+                     FourCharsExtVec{4, 3, 3, 1};
+  // CHECK: store <4 x i8> <i8 1, i8 1, i8 1, i8 0>
+  constexpr auto z = FourCharsExtVec{1, 2, 3, 4} >=
+                     FourCharsExtVec{4, 3, 3, 1};
+  // CHECK: store <4 x i8> <i8 0, i8 0, i8 1, i8 1>
+  constexpr auto A = FourCharsExtVec{1, 2, 3, 4} ==
+                     FourCharsExtVec{4, 3, 3, 1};
+  // CHECK: store <4 x i8> <i8 0, i8 0, i8 1, i8 0>
+  constexpr auto B = FourCharsExtVec{1, 2, 3, 4} !=
+                     FourCharsExtVec{4, 3, 3, 1};
+  // CHECK: store <4 x i8> <i8 1, i8 1, i8 0, i8 1>
+
+  constexpr auto C = FourCharsExtVec{1, 2, 3, 4} < 3;
+  // CHECK: store <4 x i8> <i8 1, i8 1, i8 0, i8 0>
+  constexpr auto D = FourCharsExtVec{1, 2, 3, 4} > 3;
+  // CHECK: store <4 x i8> <i8 0, i8 0, i8 0, i8 1>
+  constexpr auto E = FourCharsExtVec{1, 2, 3, 4} <= 3;
+  // CHECK: store <4 x i8> <i8 1, i8 1, i8 1, i8 0>
+  constexpr auto F = FourCharsExtVec{1, 2, 3, 4} >= 3;
+  // CHECK: store <4 x i8> <i8 0, i8 0, i8 1, i8 1>
+  constexpr auto G = FourCharsExtVec{1, 2, 3, 4} == 3;
+  // CHECK: store <4 x i8> <i8 0, i8 0, i8 1, i8 0>
+  constexpr auto H = FourCharsExtVec{1, 2, 3, 4} != 3;
+  // CHECK: store <4 x i8> <i8 1, i8 1, i8 0, i8 1>
+
+  constexpr auto I = FourCharsExtVec{1, 2, 3, 4} &
+                     FourCharsExtVec{4, 3, 2, 1};
+  // CHECK: store <4 x i8> <i8 0, i8 2, i8 2, i8 0>
+  constexpr auto J = FourCharsExtVec{1, 2, 3, 4} ^
+                     FourCharsExtVec { 4, 3, 2, 1 };
+  // CHECK: store <4 x i8> <i8 5, i8 1, i8 1, i8 5>
+  constexpr auto K = FourCharsExtVec{1, 2, 3, 4} |
+                     FourCharsExtVec{4, 3, 2, 1};
+  // CHECK: store <4 x i8> <i8 5, i8 3, i8 3, i8 5>
+  constexpr auto L = FourCharsExtVec{1, 2, 3, 4} & 3;
+  // CHECK: store <4 x i8> <i8 1, i8 2, i8 3, i8 0>
+  constexpr auto M = FourCharsExtVec{1, 2, 3, 4} ^ 3;
+  // CHECK: store <4 x i8> <i8 2, i8 1, i8 0, i8 7>
+  constexpr auto N = FourCharsExtVec{1, 2, 3, 4} | 3;
+  // CHECK: store <4 x i8> <i8 3, i8 3, i8 3, i8 7>
+
+  constexpr auto O = FourCharsExtVec{5, 0, 6, 0} &&
+                     FourCharsExtVec{5, 5, 0, 0};
+  // CHECK: store <4 x i8> <i8 1, i8 0, i8 0, i8 0>
+  constexpr auto P = FourCharsExtVec{5, 0, 6, 0} ||
+                     FourCharsExtVec{5, 5, 0, 0};
+  // CHECK: store <4 x i8> <i8 1, i8 1, i8 1, i8 0>
+
+  constexpr auto Q = FourCharsExtVec{5, 0, 6, 0} && 3;
+  // CHECK: store <4 x i8> <i8 1, i8 0, i8 1, i8 0>
+  constexpr auto R = FourCharsExtVec{5, 0, 6, 0} || 3;
+  // CHECK: store <4 x i8> <i8 1, i8 1, i8 1, i8 1>
+
+  constexpr auto T = CmpMul(a, b);
+  // CHECK: store <4 x i8> <i8 108, i8 18, i8 56, i8 72>
+
+  constexpr auto U = CmpDiv(a, b);
+  // CHECK: store <4 x i8> <i8 3, i8 18, i8 0, i8 0>
+
+  constexpr auto V = CmpRem(a, b);
+  // CHECK: store <4 x i8> <i8 0, i8 0, i8 7, i8 8>
+
+  constexpr auto X = CmpAdd(a, b);
+  // CHECK: store <4 x i8> <i8 24, i8 19, i8 15, i8 17>
+
+  constexpr auto Y = CmpSub(a, b);
+  // CHECK: store <4 x i8> <i8 12, i8 17, i8 -1, i8 -1>
+
+  constexpr auto Z = CmpLSH(a, H);
+  // CHECK: store <4 x i8> <i8 36, i8 36, i8 7, i8 16>
+
+  constexpr auto aa = CmpRSH(a, H);
+  // CHECK: store <4 x i8> <i8 9, i8 9, i8 7, i8 4>
+
+  constexpr auto ab = CmpBinAnd(a, b);
+  // CHECK: store <4 x i8> <i8 2, i8 0, i8 0, i8 8>
+
+  constexpr auto ac = CmpBinXOr(a, b);
+  // CHECK: store <4 x i8> <i8 20, i8 19, i8 15, i8 1>
+
+  constexpr auto ad = CmpBinOr(a, b);
+  // CHECK: store <4 x i8> <i8 22, i8 19, i8 15, i8 9>
+}
+
+void FloatUsage() {
+  constexpr auto a = FourFloatsVecSize{6, 3, 2, 1} +
+                     FourFloatsVecSize{12, 15, 5, 7};
+  // CHECK: <4 x float> <float 1.800000e+01, float 1.800000e+01, float 7.000000e+00, float 8.000000e+00>
+  constexpr auto b = FourFloatsVecSize{19, 15, 13, 12} -
+                     FourFloatsVecSize{13, 14, 5, 3};
+  // CHECK: store <4 x float> <float 6.000000e+00, float 1.000000e+00, float 8.000000e+00, float 9.000000e+00>
+  constexpr auto c = FourFloatsVecSize{8, 4, 2, 1} *
+                     FourFloatsVecSize{3, 4, 5, 6};
+  // CHECK: store <4 x float> <float 2.400000e+01, float 1.600000e+01, float 1.000000e+01, float 6.000000e+00>
+  constexpr auto d = FourFloatsVecSize{12, 12, 10, 10} /
+                     FourFloatsVecSize{6, 4, 5, 2};
+  // CHECK: store <4 x float> <float 2.000000e+00, float 3.000000e+00, float 2.000000e+00, float 5.000000e+00>
+
+  constexpr auto f = FourFloatsVecSize{6, 3, 2, 1} + 3;
+  // CHECK: store <4 x float> <float 9.000000e+00, float 6.000000e+00, float 5.000000e+00, float 4.000000e+00>
+  constexpr auto g = FourFloatsVecSize{19, 15, 12, 10} - 3;
+  // CHECK: store <4 x float> <float 1.600000e+01, float 1.200000e+01, float 9.000000e+00, float 7.000000e+00>
+  constexpr auto h = FourFloatsVecSize{8, 4, 2, 1} * 3;
+  // CHECK: store <4 x float> <float 2.400000e+01, float 1.200000e+01, float 6.000000e+00, float 3.000000e+00>
+  constexpr auto j = FourFloatsVecSize{12, 15, 18, 21} / 3;
+  // CHECK: store <4 x float> <float 4.000000e+00, float 5.000000e+00, float 6.000000e+00, float 7.000000e+00>
+
+  constexpr auto l = 3 + FourFloatsVecSize{6, 3, 2, 1};
+  // CHECK: store <4 x float> <float 9.000000e+00, float 6.000000e+00, float 5.000000e+00, float 4.000000e+00>
+  constexpr auto m = 20 - FourFloatsVecSize{19, 15, 12, 10};
+  // CHECK: store <4 x float> <float 1.000000e+00, float 5.000000e+00, float 8.000000e+00, float 1.000000e+01>
+  constexpr auto n = 3 * FourFloatsVecSize{8, 4, 2, 1};
+  // CHECK: store <4 x float> <float 2.400000e+01, float 1.200000e+01, float 6.000000e+00, float 3.000000e+00>
+  constexpr auto o = 100 / FourFloatsVecSize{12, 15, 18, 21};
+  // CHECK: store <4 x float> <float 0x4020AAAAA0000000, float 0x401AAAAAA0000000, float 0x401638E380000000, float 0x40130C30C0000000>
+
+  constexpr auto w = FourFloatsVecSize{1, 2, 3, 4} <
+                     FourFloatsVecSize{4, 3, 2, 1};
+  // CHECK: store <4 x i32> <i32 1, i32 1, i32 0, i32 0>
+  constexpr auto x = FourFloatsVecSize{1, 2, 3, 4} >
+                     FourFloatsVecSize{4, 3, 2, 1};
+  // CHECK: store <4 x i32> <i32 0, i32 0, i32 1, i32 1>
+  constexpr auto y = FourFloatsVecSize{1, 2, 3, 4} <=
+                     FourFloatsVecSize{4, 3, 3, 1};
+  // CHECK: store <4 x i32> <i32 1, i32 1, i32 1, i32 0>
+  constexpr auto z = FourFloatsVecSize{1, 2, 3, 4} >=
+                     FourFloatsVecSize{4, 3, 3, 1};
+  // CHECK: store <4 x i32> <i32 0, i32 0, i32 1, i32 1>
+  constexpr auto A = FourFloatsVecSize{1, 2, 3, 4} ==
+                     FourFloatsVecSize{4, 3, 3, 1};
+  // CHECK: store <4 x i32> <i32 0, i32 0, i32 1, i32 0>
+  constexpr auto B = FourFloatsVecSize{1, 2, 3, 4} !=
+                     FourFloatsVecSize{4, 3, 3, 1};
+  // CHECK: store <4 x i32> <i32 1, i32 1, i32 0, i32 1>
+
+  constexpr auto C = FourFloatsVecSize{1, 2, 3, 4} < 3;
+  // CHECK: store <4 x i32> <i32 1, i32 1, i32 0, i32 0>
+  constexpr auto D = FourFloatsVecSize{1, 2, 3, 4} > 3;
+  // CHECK: store <4 x i32> <i32 0, i32 0, i32 0, i32 1>
+  constexpr auto E = FourFloatsVecSize{1, 2, 3, 4} <= 3;
+  // CHECK: store <4 x i32> <i32 1, i32 1, i32 1, i32 0>
+  constexpr auto F = FourFloatsVecSize{1, 2, 3, 4} >= 3;
+  // CHECK: store <4 x i32> <i32 0, i32 0, i32 1, i32 1>
+  constexpr auto G = FourFloatsVecSize{1, 2, 3, 4} == 3;
+  // CHECK: store <4 x i32> <i32 0, i32 0, i32 1, i32 0>
+  constexpr auto H = FourFloatsVecSize{1, 2, 3, 4} != 3;
+  // CHECK: store <4 x i32> <i32 1, i32 1, i32 0, i32 1>
+
+  constexpr auto O = FourFloatsVecSize{5, 0, 6, 0} &&
+                     FourFloatsVecSize{5, 5, 0, 0};
+  // CHECK: store <4 x i32> <i32 1, i32 0, i32 0, i32 0>
+  constexpr auto P = FourFloatsVecSize{5, 0, 6, 0} ||
+                     FourFloatsVecSize{5, 5, 0, 0};
+  // CHECK: store <4 x i32> <i32 1, i32 1, i32 1, i32 0>
+
+  constexpr auto Q = FourFloatsVecSize{5, 0, 6, 0} && 3;
+  // CHECK: store <4 x i32> <i32 1, i32 0, i32 1, i32 0>
+  constexpr auto R = FourFloatsVecSize{5, 0, 6, 0} || 3;
+  // CHECK: store <4 x i32> <i32 1, i32 1, i32 1, i32 1>
+
+  constexpr auto T = CmpMul(a, b);
+  // CHECK: store <4 x float> <float 1.080000e+02, float 1.800000e+01, float 5.600000e+01, float 7.200000e+01>
+
+  constexpr auto U = CmpDiv(a, b);
+  // CHECK: store <4 x float> <float 3.000000e+00, float 1.800000e+01, float 8.750000e-01, float 0x3FEC71C720000000>
+
+  constexpr auto X = CmpAdd(a, b);
+  // CHECK: store <4 x float> <float 2.400000e+01, float 1.900000e+01, float 1.500000e+01, float 1.700000e+01>
+
+  constexpr auto Y = CmpSub(a, b);
+  // CHECK: store <4 x float> <float 1.200000e+01, float 1.700000e+01, float -1.000000e+00, float -1.000000e+00>
+}
+
+void FloatVecUsage() {
+  constexpr auto a = FourFloatsVecSize{6, 3, 2, 1} +
+                     FourFloatsVecSize{12, 15, 5, 7};
+  // CHECK: <4 x float> <float 1.800000e+01, float 1.800000e+01, float 7.000000e+00, float 8.000000e+00>
+  constexpr auto b = FourFloatsVecSize{19, 15, 13, 12} -
+                     FourFloatsVecSize{13, 14, 5, 3};
+  // CHECK: store <4 x float> <float 6.000000e+00, float 1.000000e+00, float 8.000000e+00, float 9.000000e+00>
+  constexpr auto c = FourFloatsVecSize{8, 4, 2, 1} *
+                     FourFloatsVecSize{3, 4, 5, 6};
+  // CHECK: store <4 x float> <float 2.400000e+01, float 1.600000e+01, float 1.000000e+01, float 6.000000e+00>
+  constexpr auto d = FourFloatsVecSize{12, 12, 10, 10} /
+                     FourFloatsVecSize{6, 4, 5, 2};
+  // CHECK: store <4 x float> <float 2.000000e+00, float 3.000000e+00, float 2.000000e+00, float 5.000000e+00>
+
+  constexpr auto f = FourFloatsVecSize{6, 3, 2, 1} + 3;
+  // CHECK: store <4 x float> <float 9.000000e+00, float 6.000000e+00, float 5.000000e+00, float 4.000000e+00>
+  constexpr auto g = FourFloatsVecSize{19, 15, 12, 10} - 3;
+  // CHECK: store <4 x float> <float 1.600000e+01, float 1.200000e+01, float 9.000000e+00, float 7.000000e+00>
+  constexpr auto h = FourFloatsVecSize{8, 4, 2, 1} * 3;
+  // CHECK: store <4 x float> <float 2.400000e+01, float 1.200000e+01, float 6.000000e+00, float 3.000000e+00>
+  constexpr auto j = FourFloatsVecSize{12, 15, 18, 21} / 3;
+  // CHECK: store <4 x float> <float 4.000000e+00, float 5.000000e+00, float 6.000000e+00, float 7.000000e+00>
+
+  constexpr auto l = 3 + FourFloatsVecSize{6, 3, 2, 1};
+  // CHECK: store <4 x float> <float 9.000000e+00, float 6.000000e+00, float 5.000000e+00, float 4.000000e+00>
+  constexpr auto m = 20 - FourFloatsVecSize{19, 15, 12, 10};
+  // CHECK: store <4 x float> <float 1.000000e+00, float 5.000000e+00, float 8.000000e+00, float 1.000000e+01>
+  constexpr auto n = 3 * FourFloatsVecSize{8, 4, 2, 1};
+  // CHECK: store <4 x float> <float 2.400000e+01, float 1.200000e+01, float 6.000000e+00, float 3.000000e+00>
+  constexpr auto o = 100 / FourFloatsVecSize{12, 15, 18, 21};
+  // CHECK: store <4 x float> <float 0x4020AAAAA0000000, float 0x401AAAAAA0000000, float 0x401638E380000000, float 0x40130C30C0000000>
+
+  constexpr auto w = FourFloatsVecSize{1, 2, 3, 4} <
+                     FourFloatsVecSize{4, 3, 2, 1};
+  // CHECK: store <4 x i32> <i32 1, i32 1, i32 0, i32 0>
+  constexpr auto x = FourFloatsVecSize{1, 2, 3, 4} >
+                     FourFloatsVecSize{4, 3, 2, 1};
+  // CHECK: store <4 x i32> <i32 0, i32 0, i32 1, i32 1>
+  constexpr auto y = FourFloatsVecSize{1, 2, 3, 4} <=
+                     FourFloatsVecSize{4, 3, 3, 1};
+  // CHECK: store <4 x i32> <i32 1, i32 1, i32 1, i32 0>
+  constexpr auto z = FourFloatsVecSize{1, 2, 3, 4} >=
+                     FourFloatsVecSize{4, 3, 3, 1};
+  // CHECK: store <4 x i32> <i32 0, i32 0, i32 1, i32 1>
+  constexpr auto A = FourFloatsVecSize{1, 2, 3, 4} ==
+                     FourFloatsVecSize{4, 3, 3, 1};
+  // CHECK: store <4 x i32> <i32 0, i32 0, i32 1, i32 0>
+  constexpr auto B = FourFloatsVecSize{1, 2, 3, 4} !=
+                     FourFloatsVecSize{4, 3, 3, 1};
+  // CHECK: store <4 x i32> <i32 1, i32 1, i32 0, i32 1>
+
+  constexpr auto C = FourFloatsVecSize{1, 2, 3, 4} < 3;
+  // CHECK: store <4 x i32> <i32 1, i32 1, i32 0, i32 0>
+  constexpr auto D = FourFloatsVecSize{1, 2, 3, 4} > 3;
+  // CHECK: store <4 x i32> <i32 0, i32 0, i32 0, i32 1>
+  constexpr auto E = FourFloatsVecSize{1, 2, 3, 4} <= 3;
+  // CHECK: store <4 x i32> <i32 1, i32 1, i32 1, i32 0>
+  constexpr auto F = FourFloatsVecSize{1, 2, 3, 4} >= 3;
+  // CHECK: store <4 x i32> <i32 0, i32 0, i32 1, i32 1>
+  constexpr auto G = FourFloatsVecSize{1, 2, 3, 4} == 3;
+  // CHECK: store <4 x i32> <i32 0, i32 0, i32 1, i32 0>
+  constexpr auto H = FourFloatsVecSize{1, 2, 3, 4} != 3;
+  // CHECK: store <4 x i32> <i32 1, i32 1, i32 0, i32 1>
+
+  constexpr auto O = FourFloatsVecSize{5, 0, 6, 0} &&
+                     FourFloatsVecSize{5, 5, 0, 0};
+  // CHECK: store <4 x i32> <i32 1, i32 0, i32 0, i32 0>
+  constexpr auto P = FourFloatsVecSize{5, 0, 6, 0} ||
+                     FourFloatsVecSize{5, 5, 0, 0};
+  // CHECK: store <4 x i32> <i32 1, i32 1, i32 1, i32 0>
+
+  constexpr auto Q = FourFloatsVecSize{5, 0, 6, 0} && 3;
+  // CHECK: store <4 x i32> <i32 1, i32 0, i32 1, i32 0>
+  constexpr auto R = FourFloatsVecSize{5, 0, 6, 0} || 3;
+  // CHECK: store <4 x i32> <i32 1, i32 1, i32 1, i32 1>
+
+  constexpr auto T = CmpMul(a, b);
+  // CHECK: store <4 x float> <float 1.080000e+02, float 1.800000e+01, float 5.600000e+01, float 7.200000e+01>
+
+  constexpr auto U = CmpDiv(a, b);
+  // CHECK: store <4 x float> <float 3.000000e+00, float 1.800000e+01, float 8.750000e-01, float 0x3FEC71C720000000>
+
+  constexpr auto X = CmpAdd(a, b);
+  // CHECK: store <4 x float> <float 2.400000e+01, float 1.900000e+01, float 1.500000e+01, float 1.700000e+01>
+
+  constexpr auto Y = CmpSub(a, b);
+  // CHECK: store <4 x float> <float 1.200000e+01, float 1.700000e+01, float -1.000000e+00, float -1.000000e+00>
+}