[clang] Implement constexpr operator[] for vectors

[DaPorkchop_]

Summary

This implements the array subscript operator for vector types.

As vectors don't decay into pointers, I've opted to evaluate the vector
operand as an LValue, which still gives the expected behavior.

[DaPorkchop_]

Fixed test code for CodeGenCXX/temporaries.cpp

Creating and extracting a reference to a temporary
vector's element is now able to be evaluated at compile
time, which made this test case fail (since it was looking
for code which no longer needs to be generated).

clang/include/clang/Basic/DiagnosticASTKinds.td

 def note_constexpr_compare_virtual_mem_ptr : Note<
   "comparison of pointer to virtual member function %0 has unspecified value">;
 def note_constexpr_past_end : Note<
   "dereferenced pointer past the end of %select{|subobject of }0"
   "%select{temporary|%2}1 is not a constant expression">;
 def note_constexpr_past_end_subobject : Note<
   "cannot %select{access base class of|access derived class of|access field of|"
   "access array element of|ERROR|"
-  "access real component of|access imaginary component of}0 "
-  "pointer past the end of object">;
+  "access real component of|access imaginary component of|"
+  "access vector element of}0 pointer past the end of object">;
 def note_non_null_attribute_failed : Note<
   "null passed to a callee that requires a non-null argument">;
 def note_constexpr_null_subobject : Note<
   "cannot %select{access base class of|access derived class of|access field of|"
   "access array element of|perform pointer arithmetic on|"
   "access real component of|"
-  "access imaginary component of}0 null pointer">;
+  "access imaginary component of|access vector element of}0 null pointer">;
 def note_constexpr_null_callee : Note<
   "'%0' evaluates to a null function pointer">;
 def note_constexpr_function_param_value_unknown : Note<
   "function parameter %0 with unknown value cannot be used in a constant "
   "expression">;
 def note_constexpr_var_init_unknown : Note<
   "initializer of %0 is unknown">;
 def note_constexpr_var_init_non_constant : Note<

clang/lib/AST/ExprConstant.cpp

for (unsigned I = 0, N = Path.size(); I != N; ++I) {
           ArraySize = AssumedSizeForUnsizedArray;
         }
       } else if (Type->isAnyComplexType()) {
         const ComplexType *CT = Type->castAs<ComplexType>();
         Type = CT->getElementType();
         ArraySize = 2;
         MostDerivedLength = I + 1;
         IsArray = true;
+      } else if (Type->isVectorType()) {
+        const VectorType *VT = Type->castAs<VectorType>();
+        Type = VT->getElementType();
+        ArraySize = VT->getNumElements();
+        MostDerivedLength = I + 1;
+        IsArray = true;
       } else if (const FieldDecl *FD = getAsField(Path[I])) {
         Type = FD->getType();
         ArraySize = 0;
         MostDerivedLength = I + 1;
         IsArray = false;
       } else {
         // Path[I] describes a base class.
         ArraySize = 0;
void addComplexUnchecked(QualType EltTy, bool Imag) {
 
       // This is technically a most-derived object, though in practice this
       // is unlikely to matter.
       MostDerivedType = EltTy;
       MostDerivedIsArrayElement = true;
       MostDerivedArraySize = 2;
       MostDerivedPathLength = Entries.size();
     }
+    /// Update this designator to refer to the first element within this vector.
+    void addVectorUnchecked(const VectorType *VT) {
+      Entries.push_back(PathEntry::ArrayIndex(0));
+
+      // This is technically a most-derived object, though in practice this
+      // is unlikely to matter.
+      MostDerivedType = VT->getElementType();
+      MostDerivedIsArrayElement = true;
+      MostDerivedArraySize = VT->getNumElements();
+      MostDerivedPathLength = Entries.size();
+    }
     void diagnoseUnsizedArrayPointerArithmetic(EvalInfo &Info, const Expr *E);
     void diagnosePointerArithmetic(EvalInfo &Info, const Expr *E,
                                    const APSInt &N);
     /// Add N to the address of this subobject.
     void adjustIndex(EvalInfo &Info, const Expr *E, APSInt N) {
       if (Invalid || !N) return;
       uint64_t TruncatedN = N.extOrTrunc(64).getZExtValue();
       if (isMostDerivedAnUnsizedArray()) {
public:
     void addArray(EvalInfo &Info, const Expr *E, const ConstantArrayType *CAT) {
       if (checkSubobject(Info, E, CSK_ArrayToPointer))
         Designator.addArrayUnchecked(CAT);
     }
     void addComplex(EvalInfo &Info, const Expr *E, QualType EltTy, bool Imag) {
       if (checkSubobject(Info, E, Imag ? CSK_Imag : CSK_Real))
         Designator.addComplexUnchecked(EltTy, Imag);
     }
+    void addVector(EvalInfo &Info, const Expr *E, const VectorType *VT) {
+      if (checkSubobject(Info, E, CSK_VectorToPointer))
+        Designator.addVectorUnchecked(VT);
+    }
     void clearIsNullPointer() {
       IsNullPtr = false;
     }
     void adjustOffsetAndIndex(EvalInfo &Info, const Expr *E,
                               const APSInt &Index, CharUnits ElementSize) {
       // An index of 0 has no effect. (In C, adding 0 to a null pointer is UB,
       // but we're not required to diagnose it and it's valid in C++.)
       if (!Index)
if (Imag) {
     if (!HandleSizeof(Info, E->getExprLoc(), EltTy, SizeOfComponent))
       return false;
     LVal.Offset += SizeOfComponent;
   }
   LVal.addComplex(Info, E, EltTy, Imag);
   return true;
 }
 
+/// Update an lvalue to refer to an element of a vector.
+/// \param Info - Information about the ongoing evaluation.
+/// \param LVal - The lvalue to be updated.
+/// \param EltTy - The vector's element type.
+/// \param Idx - The index of the referenced vector element.
+static bool HandleLValueVectorElement(EvalInfo &Info, const Expr *E,
+                                      LValue &LVal, const VectorType *VT,
+                                      APSInt Idx) {
+  LVal.addVector(Info, E, VT);
+
+  return HandleLValueArrayAdjustment(Info, E, LVal, VT->getElementType(), Idx);
+}
+
 /// Try to evaluate the initializer for a variable declaration.
 ///
 /// \param Info   Information about the ongoing evaluation.
 /// \param E      An expression to be used when printing diagnostics.
 /// \param VD     The variable whose initializer should be obtained.
 /// \param Version The version of the variable within the frame.
 /// \param Frame  The frame in which the variable was created. Must be null
 ///               if this variable is not local to the evaluation.
if (ObjType->isArrayType()) {
       if (O->isComplexInt()) {
         return handler.found(Index ? O->getComplexIntImag()
                                    : O->getComplexIntReal(), ObjType);
       } else {
         assert(O->isComplexFloat());
         return handler.found(Index ? O->getComplexFloatImag()
                                    : O->getComplexFloatReal(), ObjType);
       }
+    } else if (ObjType->isVectorType()) {
+      // Next subobject is a vector.
+      const VectorType *VT = ObjType->castAs<VectorType>();
+      uint64_t Index = Sub.Entries[I].getAsArrayIndex();
+      if (Index >= VT->getNumElements()) {
+        if (Info.getLangOpts().CPlusPlus11)
+          Info.FFDiag(E, diag::note_constexpr_access_past_end)
+              << handler.AccessKind;
+        else
+          Info.FFDiag(E);
+        return handler.failed();
+      }
+
+      ObjType = getSubobjectType(ObjType, VT->getElementType());
+
+      assert(I == N - 1 && "extracting subobject of scalar?");
+      assert(O->isVector());
+      return handler.found(O->getVectorElt(Index), ObjType);
     } else if (const FieldDecl *Field = getAsField(Sub.Entries[I])) {
       if (Field->isMutable() &&
           !Obj.mayAccessMutableMembers(Info, handler.AccessKind)) {
         Info.FFDiag(E, diag::note_constexpr_access_mutable, 1)
           << handler.AccessKind << Field;
         Info.Note(Field->getLocation(), diag::note_declared_at);
         return handler.failed();
       }
bool LValueExprEvaluator::VisitMemberExpr(const MemberExpr *E) {
   }
 
   // Handle non-static data members.
   return LValueExprEvaluatorBaseTy::VisitMemberExpr(E);
 }
 
 bool LValueExprEvaluator::VisitArraySubscriptExpr(const ArraySubscriptExpr *E) {
   // FIXME: Deal with vectors as array subscript bases.
-  if (E->getBase()->getType()->isVectorType() ||
-      E->getBase()->getType()->isVLSTBuiltinType())
+  if (E->getBase()->getType()->isVLSTBuiltinType())
     return Error(E);
 
+  bool IsVector = E->getBase()->getType()->isVectorType();
+
   APSInt Index;
   bool Success = true;
 
   // C++17's rules require us to evaluate the LHS first, regardless of which
   // side is the base.
   for (const Expr *SubExpr : {E->getLHS(), E->getRHS()}) {
-    if (SubExpr == E->getBase() ? !evaluatePointer(SubExpr, Result)
-                                : !EvaluateInteger(SubExpr, Index, Info)) {
+    bool IsBase = SubExpr == E->getBase();
+    if (IsBase ? IsVector ? !EvaluateLValue(SubExpr, Result, Info)
+                          : !evaluatePointer(SubExpr, Result)
       if (!Info.noteFailure())
         return false;
       Success = false;
     }
   }
 
-  return Success &&
-         HandleLValueArrayAdjustment(Info, E, Result, E->getType(), Index);
+  if (!Success)
+    return false;
+
+  return IsVector ? HandleLValueVectorElement(
+                        Info, E, Result,
+                        E->getBase()->getType()->castAs<VectorType>(), Index)
+                  : HandleLValueArrayAdjustment(Info, E, Result, E->getType(),
+                                                Index);
 }
 
 bool LValueExprEvaluator::VisitUnaryDeref(const UnaryOperator *E) {
   return evaluatePointer(E->getSubExpr(), Result);
 }
 
 bool LValueExprEvaluator::VisitUnaryReal(const UnaryOperator *E) {
   if (!Visit(E->getSubExpr()))

clang/lib/AST/Interp/State.h

 /// The order of this enum is important for diagnostics.
 enum CheckSubobjectKind {
   CSK_Base,
   CSK_Derived,
   CSK_Field,
   CSK_ArrayToPointer,
   CSK_ArrayIndex,
   CSK_Real,
-  CSK_Imag
+  CSK_Imag,
+  CSK_VectorToPointer
 };
 
 namespace interp {
 class Frame;
 class SourceInfo;
 
 /// Interface for the VM to interact with the AST walker's context.
 class State {

clang/test/CodeGenCXX/temporaries.cpp

struct SelfReferential {
     int ints[3] = {1, 2, 3};
   };
 
   // CHECK: @_ZGRN16RefTempSubobject2srE_ = internal global { ptr, [3 x i32] } { {{.*}} getelementptr {{.*}} @_ZGRN16RefTempSubobject2srE_, {{.*}}, [3 x i32] [i32 1, i32 2, i32 3] }
   // CHECK: @_ZN16RefTempSubobject2srE = constant {{.*}} @_ZGRN16RefTempSubobject2srE_
   constexpr const SelfReferential &sr = SelfReferential();
 }
 
+namespace Vector {
+  typedef __attribute__((vector_size(16))) int vi4a;
+  typedef __attribute__((ext_vector_type(4))) int vi4b;
+  struct S {
+    vi4a v;
+    vi4b w;
+  };
+  // CHECK: @_ZGRN6Vector1rE_ = internal global i32 0,
+  // CHECK: @_ZN6Vector1rE ={{.*}} constant ptr @_ZGRN6Vector1rE_,
+  int &&r = S().v[1];
+
+  // CHECK: @_ZGRN6Vector1sE_ = internal global i32 0,
+  // CHECK: @_ZN6Vector1sE ={{.*}} constant ptr @_ZGRN6Vector1sE_,
+  int &&s = S().w[1];
+  // FIXME PR16204: The following code leads to an assertion in Sema.
+  //int &&s = S().w.y;
+}
+
 struct A {
   A();
   ~A();
   void f();
 };
 
 void f1() {
   // CHECK: call void @_ZN1AC1Ev
namespace Bitfield {
   // CHECK: alloca
   // CHECK: call {{.*}}memset
   // CHECK: store i32 {{.*}}, ptr @_ZGRN8Bitfield1rE_
   // CHECK: call void @_ZN8Bitfield1SD1
   // CHECK: store ptr @_ZGRN8Bitfield1rE_, ptr @_ZN8Bitfield1rE, align 8
   int &&r = S().a;
 }
 
-namespace Vector {
-  typedef __attribute__((vector_size(16))) int vi4a;
-  typedef __attribute__((ext_vector_type(4))) int vi4b;
-  struct S {
-    vi4a v;
-    vi4b w;
-  };
-  // CHECK: alloca
-  // CHECK: extractelement
-  // CHECK: store i32 {{.*}}, ptr @_ZGRN6Vector1rE_
-  // CHECK: store ptr @_ZGRN6Vector1rE_, ptr @_ZN6Vector1rE,
-  int &&r = S().v[1];
-
-  // CHECK: alloca
-  // CHECK: extractelement
-  // CHECK: store i32 {{.*}}, ptr @_ZGRN6Vector1sE_
-  // CHECK: store ptr @_ZGRN6Vector1sE_, ptr @_ZN6Vector1sE,
-  int &&s = S().w[1];
-  // FIXME PR16204: The following code leads to an assertion in Sema.
-  //int &&s = S().w.y;
-}
-
 namespace ImplicitTemporaryCleanup {
   struct A { A(int); ~A(); };
   void g();
 
   // CHECK-LABEL: define{{.*}} void @_ZN24ImplicitTemporaryCleanup1fEv(
   void f() {
     // CHECK: call {{.*}} @_ZN24ImplicitTemporaryCleanup1AC1Ei(
     A &&a = 0;

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.
+// RUN: %clang_cc1 -std=c++14 -triple x86_64-linux-gnu -Wno-unused-value %s
 
 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 FourI128VecSize __attribute__((vector_size(64))) = __int128;
 
constexpr auto MathShiftOps##Type(Type a, Type b) { \
     a < b;                                            \
     a > b;                                            \
     a <= b;                                           \
     a >= b;                                           \
     a == b;                                           \
     a != b;                                           \
     a &&b;                                            \
     a || b;                                           \
+    a += a[1];                                        \
+    a[1] += 1;                                        \
+    a[1] = 1;                                         \
+    a[1] = b[1];                                      \
+    a[1]++;                                           \
+    ++a[1];                                           \
     auto c = (a, b);                                  \
     return c;                                         \
   }
 
 // Ops specific to Integers.
 #define MathShiftOpsInts(Type)                            \
   constexpr auto MathShiftopsInts##Type(Type a, Type b) { \
     a = a << b;                                           \

 
 MathShiftOpsInts(FourCharsVecSize);
 MathShiftOpsInts(FourIntsVecSize);
 MathShiftOpsInts(FourLongLongsVecSize);
 MathShiftOpsInts(FourCharsExtVec);
 MathShiftOpsInts(FourIntsExtVec);
 MathShiftOpsInts(FourLongLongsExtVec);
 
-template <typename T, typename U>
+template<typename T, typename U>
+constexpr bool VectorsEqual(T a, U b) {
+  for (unsigned I = 0; I < 4; ++I) {
+    if (a[I] != b[I])
+      return false;
+  }
+  return true;
+}
+
+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 CmpBinOr(T t, U u) {
   t |= u;
   return t;
 }
 
+template <typename T, typename U>
+constexpr auto UpdateElementsInPlace(T t, U u) {
+  t[0] += u[0];
+  t[1]++;
+  t[2] = 1;
+  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>
+  static_assert(VectorsEqual(a, FourCharsVecSize{18, 18, 7, 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>
+  static_assert(VectorsEqual(b, FourCharsVecSize{6, 1, 8, 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>
+  static_assert(VectorsEqual(c, FourCharsVecSize{24, 16, 10, 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>
+  static_assert(VectorsEqual(d, FourCharsVecSize{2, 3, 2, 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>
+  static_assert(VectorsEqual(e, FourCharsVecSize{0, 0, 2, 1}), "");
 
   constexpr auto f = FourCharsVecSize{6, 3, 2, 1} + 3;
-  // CHECK: store <4 x i8> <i8 9, i8 6, i8 5, i8 4>
+  static_assert(VectorsEqual(f, FourCharsVecSize{9, 6, 5, 4}), "");
+
   constexpr auto g = FourCharsVecSize{19, 15, 12, 10} - 3;
-  // CHECK: store <4 x i8> <i8 16, i8 12, i8 9, i8 7>
+  static_assert(VectorsEqual(g, FourCharsVecSize{16, 12, 9, 7}), "");
+
   constexpr auto h = FourCharsVecSize{8, 4, 2, 1} * 3;
-  // CHECK: store <4 x i8> <i8 24, i8 12, i8 6, i8 3>
+  static_assert(VectorsEqual(h, FourCharsVecSize{24, 12, 6, 3}), "");
+
   constexpr auto j = FourCharsVecSize{12, 15, 18, 21} / 3;
-  // CHECK: store <4 x i8> <i8 4, i8 5, i8 6, i8 7>
+  static_assert(VectorsEqual(j, FourCharsVecSize{4, 5, 6, 7}), "");
+
   constexpr auto k = FourCharsVecSize{12, 17, 19, 22} % 3;
-  // CHECK: store <4 x i8> <i8 0, i8 2, i8 1, i8 1>
+  static_assert(VectorsEqual(k, FourCharsVecSize{0, 2, 1, 1}), "");
 
   constexpr auto l = 3 + FourCharsVecSize{6, 3, 2, 1};
-  // CHECK: store <4 x i8> <i8 9, i8 6, i8 5, i8 4>
+  static_assert(VectorsEqual(l, FourCharsVecSize{9, 6, 5, 4}), "");
+
   constexpr auto m = 20 - FourCharsVecSize{19, 15, 12, 10};
-  // CHECK: store <4 x i8> <i8 1, i8 5, i8 8, i8 10>
+  static_assert(VectorsEqual(m, FourCharsVecSize{1, 5, 8, 10}), "");
+
   constexpr auto n = 3 * FourCharsVecSize{8, 4, 2, 1};
-  // CHECK: store <4 x i8> <i8 24, i8 12, i8 6, i8 3>
+  static_assert(VectorsEqual(n, FourCharsVecSize{24, 12, 6, 3}), "");
+
   constexpr auto o = 100 / FourCharsVecSize{12, 15, 18, 21};
-  // CHECK: store <4 x i8> <i8 8, i8 6, i8 5, i8 4>
+  static_assert(VectorsEqual(o, FourCharsVecSize{8, 6, 5, 4}), "");
+
   constexpr auto p = 100 % FourCharsVecSize{12, 15, 18, 21};
-  // CHECK: store <4 x i8> <i8 4, i8 10, i8 10, i8 16>
+  static_assert(VectorsEqual(p, FourCharsVecSize{4, 10, 10, 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>
+  static_assert(VectorsEqual(q, FourCharsVecSize{12, 6, 8, 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>
+  static_assert(VectorsEqual(r, FourCharsVecSize{9, 7, 3, 2}), "");
+
   constexpr auto s = FourCharsVecSize{6, 3, 5, 10} << 1;
-  // CHECK: store <4 x i8> <i8 12, i8 6, i8 10, i8 20>
+  static_assert(VectorsEqual(s, FourCharsVecSize{12, 6, 10, 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>
+  static_assert(VectorsEqual(t, FourCharsVecSize{9, 7, 5, 10}), "");
+
+  //TODO: These are being auto-deduced as FourCharsExtVec instead of FourCharsVecSize
+  constexpr FourCharsVecSize u = 12 << FourCharsVecSize{1, 2, 3, 3};
+  static_assert(VectorsEqual(u, FourCharsVecSize{24, 48, 96, 96}), "");
+
+  constexpr FourCharsVecSize v = 12 >> FourCharsVecSize{1, 2, 2, 1};
+  static_assert(VectorsEqual(v, FourCharsVecSize{6, 3, 3, 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>
+  static_assert(VectorsEqual(w, FourCharsVecSize{-1, -1, 0, 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>
+  static_assert(VectorsEqual(x, FourCharsVecSize{0, 0, -1, -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>
+  static_assert(VectorsEqual(y, FourCharsVecSize{-1, -1, -1, 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>
+  static_assert(VectorsEqual(z, FourCharsVecSize{0, 0, -1, -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>
+  static_assert(VectorsEqual(A, FourCharsVecSize{0, 0, -1, 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>
+  static_assert(VectorsEqual(B, FourCharsVecSize{-1, -1, 0, -1}), "");
 
   constexpr auto C = FourCharsVecSize{1, 2, 3, 4} < 3;
-  // CHECK: store <4 x i8> <i8 -1, i8 -1, i8 0, i8 0>
+  static_assert(VectorsEqual(C, FourCharsVecSize{-1, -1, 0, 0}), "");
+
   constexpr auto D = FourCharsVecSize{1, 2, 3, 4} > 3;
-  // CHECK: store <4 x i8> <i8 0, i8 0, i8 0, i8 -1>
+  static_assert(VectorsEqual(D, FourCharsVecSize{0, 0, 0, -1}), "");
+
   constexpr auto E = FourCharsVecSize{1, 2, 3, 4} <= 3;
-  // CHECK: store <4 x i8> <i8 -1, i8 -1, i8 -1, i8 0>
+  static_assert(VectorsEqual(E, FourCharsVecSize{-1, -1, -1, 0}), "");
+
   constexpr auto F = FourCharsVecSize{1, 2, 3, 4} >= 3;
-  // CHECK: store <4 x i8> <i8 0, i8 0, i8 -1, i8 -1>
+  static_assert(VectorsEqual(F, FourCharsVecSize{0, 0, -1, -1}), "");
+
   constexpr auto G = FourCharsVecSize{1, 2, 3, 4} == 3;
-  // CHECK: store <4 x i8> <i8 0, i8 0, i8 -1, i8 0>
+  static_assert(VectorsEqual(G, FourCharsVecSize{0, 0, -1, 0}), "");
+
   constexpr auto H = FourCharsVecSize{1, 2, 3, 4} != 3;
-  // CHECK: store <4 x i8> <i8 -1, i8 -1, i8 0, i8 -1>
+  static_assert(VectorsEqual(H, FourCharsVecSize{-1, -1, 0, -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>
+  static_assert(VectorsEqual(I, FourCharsVecSize{0, 2, 2, 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>
+  static_assert(VectorsEqual(J, FourCharsVecSize{5, 1, 1, 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>
+  static_assert(VectorsEqual(K, FourCharsVecSize{5, 3, 3, 5}), "");
+
   constexpr auto L = FourCharsVecSize{1, 2, 3, 4} & 3;
-  // CHECK: store <4 x i8> <i8 1, i8 2, i8 3, i8 0>
+  static_assert(VectorsEqual(L, FourCharsVecSize{1, 2, 3, 0}), "");
+
   constexpr auto M = FourCharsVecSize{1, 2, 3, 4} ^ 3;
-  // CHECK: store <4 x i8> <i8 2, i8 1, i8 0, i8 7>
+  static_assert(VectorsEqual(M, FourCharsVecSize{2, 1, 0, 7}), "");
+
   constexpr auto N = FourCharsVecSize{1, 2, 3, 4} | 3;
-  // CHECK: store <4 x i8> <i8 3, i8 3, i8 3, i8 7>
+  static_assert(VectorsEqual(N, FourCharsVecSize{3, 3, 3, 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>
+  static_assert(VectorsEqual(O, FourCharsVecSize{1, 0, 0, 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>
+  static_assert(VectorsEqual(P, FourCharsVecSize{1, 1, 1, 0}), "");
 
   constexpr auto Q = FourCharsVecSize{5, 0, 6, 0} && 3;
-  // CHECK: store <4 x i8> <i8 1, i8 0, i8 1, i8 0>
+  static_assert(VectorsEqual(Q, FourCharsVecSize{1, 0, 1, 0}), "");
+
   constexpr auto R = FourCharsVecSize{5, 0, 6, 0} || 3;
-  // CHECK: store <4 x i8> <i8 1, i8 1, i8 1, i8 1>
+  static_assert(VectorsEqual(R, FourCharsVecSize{1, 1, 1, 1}), "");
 
   constexpr auto T = CmpMul(a, b);
-  // CHECK: store <4 x i8> <i8 108, i8 18, i8 56, i8 72>
+  static_assert(VectorsEqual(T, FourCharsVecSize{108, 18, 56, 72}), "");
 
   constexpr auto U = CmpDiv(a, b);
-  // CHECK: store <4 x i8> <i8 3, i8 18, i8 0, i8 0>
+  static_assert(VectorsEqual(U, FourCharsVecSize{3, 18, 0, 0}), "");
 
   constexpr auto V = CmpRem(a, b);
-  // CHECK: store <4 x i8> <i8 0, i8 0, i8 7, i8 8>
+  static_assert(VectorsEqual(V, FourCharsVecSize{0, 0, 7, 8}), "");
 
   constexpr auto X = CmpAdd(a, b);
-  // CHECK: store <4 x i8> <i8 24, i8 19, i8 15, i8 17>
+  static_assert(VectorsEqual(X, FourCharsVecSize{24, 19, 15, 17}), "");
 
   constexpr auto Y = CmpSub(a, b);
-  // CHECK: store <4 x i8> <i8 12, i8 17, i8 -1, i8 -1>
+  static_assert(VectorsEqual(Y, FourCharsVecSize{12, 17, -1, -1}), "");
 
   constexpr auto InvH = -H;
-  // CHECK: store <4 x i8> <i8 1, i8 1, i8 0, i8 1>
+  static_assert(VectorsEqual(InvH, FourCharsVecSize{1, 1, 0, 1}), "");
+
   constexpr auto Z = CmpLSH(a, InvH);
-  // CHECK: store <4 x i8> <i8 36, i8 36, i8 7, i8 16>
+  static_assert(VectorsEqual(Z, FourCharsVecSize{36, 36, 7, 16}), "");
 
   constexpr auto aa = CmpRSH(a, InvH);
-  // CHECK: store <4 x i8> <i8 9, i8 9, i8 7, i8 4>
+  static_assert(VectorsEqual(aa, FourCharsVecSize{9, 9, 7, 4}), "");
 
   constexpr auto ab = CmpBinAnd(a, b);
-  // CHECK: store <4 x i8> <i8 2, i8 0, i8 0, i8 8>
+  static_assert(VectorsEqual(ab, FourCharsVecSize{2, 0, 0, 8}), "");
 
   constexpr auto ac = CmpBinXOr(a, b);
-  // CHECK: store <4 x i8> <i8 20, i8 19, i8 15, i8 1>
+  static_assert(VectorsEqual(ac, FourCharsVecSize{20, 19, 15, 1}), "");
 
   constexpr auto ad = CmpBinOr(a, b);
-  // CHECK: store <4 x i8> <i8 22, i8 19, i8 15, i8 9>
+  static_assert(VectorsEqual(ad, FourCharsVecSize{22, 19, 15, 9}), "");
 
   constexpr auto ae = ~FourCharsVecSize{1, 2, 10, 20};
-  // CHECK: store <4 x i8> <i8 -2, i8 -3, i8 -11, i8 -21>
+  static_assert(VectorsEqual(ae, FourCharsVecSize{-2, -3, -11, -21}), "");
 
   constexpr auto af = !FourCharsVecSize{0, 1, 8, -1};
-  // CHECK: store <4 x i8> <i8 -1, i8 0, i8 0, i8 0>
+  static_assert(VectorsEqual(af, FourCharsVecSize{-1, 0, 0, 0}), "");
+
+  constexpr auto ag = UpdateElementsInPlace(
+                    FourCharsVecSize{3, 3, 0, 0}, FourCharsVecSize{3, 0, 0, 0});
+  static_assert(VectorsEqual(ag, FourCharsVecSize{6, 4, 1, 0}), "");
 }
 
 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>
+  static_assert(VectorsEqual(a, FourCharsExtVec{18, 18, 7, 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>
+  static_assert(VectorsEqual(b, FourCharsExtVec{6, 1, 8, 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>
+  static_assert(VectorsEqual(c, FourCharsExtVec{24, 16, 10, 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>
+  static_assert(VectorsEqual(d, FourCharsExtVec{2, 3, 2, 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>
+  static_assert(VectorsEqual(e, FourCharsExtVec{0, 0, 2, 1}), "");
 
   constexpr auto f = FourCharsExtVec{6, 3, 2, 1} + 3;
-  // CHECK: store <4 x i8> <i8 9, i8 6, i8 5, i8 4>
+  static_assert(VectorsEqual(f, FourCharsExtVec{9, 6, 5, 4}), "");
+
   constexpr auto g = FourCharsExtVec{19, 15, 12, 10} - 3;
-  // CHECK: store <4 x i8> <i8 16, i8 12, i8 9, i8 7>
+  static_assert(VectorsEqual(g, FourCharsExtVec{16, 12, 9, 7}), "");
+
   constexpr auto h = FourCharsExtVec{8, 4, 2, 1} * 3;
-  // CHECK: store <4 x i8> <i8 24, i8 12, i8 6, i8 3>
+  static_assert(VectorsEqual(h, FourCharsExtVec{24, 12, 6, 3}), "");
+
   constexpr auto j = FourCharsExtVec{12, 15, 18, 21} / 3;
-  // CHECK: store <4 x i8> <i8 4, i8 5, i8 6, i8 7>
+  static_assert(VectorsEqual(j, FourCharsExtVec{4, 5, 6, 7}), "");
+
   constexpr auto k = FourCharsExtVec{12, 17, 19, 22} % 3;
-  // CHECK: store <4 x i8> <i8 0, i8 2, i8 1, i8 1>
+  static_assert(VectorsEqual(k, FourCharsExtVec{0, 2, 1, 1}), "");
 
   constexpr auto l = 3 + FourCharsExtVec{6, 3, 2, 1};
-  // CHECK: store <4 x i8> <i8 9, i8 6, i8 5, i8 4>
+  static_assert(VectorsEqual(l, FourCharsExtVec{9, 6, 5, 4}), "");
+
   constexpr auto m = 20 - FourCharsExtVec{19, 15, 12, 10};
-  // CHECK: store <4 x i8> <i8 1, i8 5, i8 8, i8 10>
+  static_assert(VectorsEqual(m, FourCharsExtVec{1, 5, 8, 10}), "");
+
   constexpr auto n = 3 * FourCharsExtVec{8, 4, 2, 1};
-  // CHECK: store <4 x i8> <i8 24, i8 12, i8 6, i8 3>
+  static_assert(VectorsEqual(n, FourCharsExtVec{24, 12, 6, 3}), "");
+
   constexpr auto o = 100 / FourCharsExtVec{12, 15, 18, 21};
-  // CHECK: store <4 x i8> <i8 8, i8 6, i8 5, i8 4>
+  static_assert(VectorsEqual(o, FourCharsExtVec{8, 6, 5, 4}), "");
+
   constexpr auto p = 100 % FourCharsExtVec{12, 15, 18, 21};
-  // CHECK: store <4 x i8> <i8 4, i8 10, i8 10, i8 16>
+  static_assert(VectorsEqual(p, FourCharsExtVec{4, 10, 10, 16}), "");
+
+  constexpr auto q = FourCharsExtVec{6, 3, 2, 1} << FourCharsExtVec{1, 1, 2, 2};
+  static_assert(VectorsEqual(q, FourCharsExtVec{12, 6, 8, 4}), "");
 
-  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>
+  static_assert(VectorsEqual(r, FourCharsExtVec{9, 7, 3, 2}), "");
+
   constexpr auto s = FourCharsExtVec{6, 3, 5, 10} << 1;
-  // CHECK: store <4 x i8> <i8 12, i8 6, i8 10, i8 20>
+  static_assert(VectorsEqual(s, FourCharsExtVec{12, 6, 10, 20}), "");
+
   constexpr auto t = FourCharsExtVec{19, 15, 10, 20} >> 1;
-  // CHECK: store <4 x i8> <i8 9, i8 7, i8 5, i8 10>
+  static_assert(VectorsEqual(t, FourCharsExtVec{9, 7, 5, 10}), "");
+
   constexpr auto u = 12 << FourCharsExtVec{1, 2, 3, 3};
-  // CHECK: store <4 x i8> <i8 24, i8 48, i8 96, i8 96>
+  static_assert(VectorsEqual(u, FourCharsExtVec{24, 48, 96, 96}), "");
+
   constexpr auto v = 12 >> FourCharsExtVec{1, 2, 2, 1};
-  // CHECK: store <4 x i8> <i8 6, i8 3, i8 3, i8 6>
+  static_assert(VectorsEqual(v, FourCharsExtVec{6, 3, 3, 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>
+  static_assert(VectorsEqual(w, FourCharsExtVec{-1, -1, 0, 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>
+  static_assert(VectorsEqual(x, FourCharsExtVec{0, 0, -1, -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>
+  static_assert(VectorsEqual(y, FourCharsExtVec{-1, -1, -1, 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>
+  static_assert(VectorsEqual(z, FourCharsExtVec{0, 0, -1, -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>
+  static_assert(VectorsEqual(A, FourCharsExtVec{0, 0, -1, 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>
+  static_assert(VectorsEqual(B, FourCharsExtVec{-1, -1, 0, -1}), "");
 
   constexpr auto C = FourCharsExtVec{1, 2, 3, 4} < 3;
-  // CHECK: store <4 x i8> <i8 -1, i8 -1, i8 0, i8 0>
+  static_assert(VectorsEqual(C, FourCharsExtVec{-1, -1, 0, 0}), "");
+
   constexpr auto D = FourCharsExtVec{1, 2, 3, 4} > 3;
-  // CHECK: store <4 x i8> <i8 0, i8 0, i8 0, i8 -1>
+  static_assert(VectorsEqual(D, FourCharsExtVec{0, 0, 0, -1}), "");
+
   constexpr auto E = FourCharsExtVec{1, 2, 3, 4} <= 3;
-  // CHECK: store <4 x i8> <i8 -1, i8 -1, i8 -1, i8 0>
+  static_assert(VectorsEqual(E, FourCharsExtVec{-1, -1, -1, 0}), "");
+
   constexpr auto F = FourCharsExtVec{1, 2, 3, 4} >= 3;
-  // CHECK: store <4 x i8> <i8 0, i8 0, i8 -1, i8 -1>
+  static_assert(VectorsEqual(F, FourCharsExtVec{0, 0, -1, -1}), "");
+
   constexpr auto G = FourCharsExtVec{1, 2, 3, 4} == 3;
-  // CHECK: store <4 x i8> <i8 0, i8 0, i8 -1, i8 0>
+  static_assert(VectorsEqual(G, FourCharsExtVec{0, 0, -1, 0}), "");
+
   constexpr auto H = FourCharsExtVec{1, 2, 3, 4} != 3;
-  // CHECK: store <4 x i8> <i8 -1, i8 -1, i8 0, i8 -1>
+  static_assert(VectorsEqual(H, FourCharsExtVec{-1, -1, 0, -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>
+  static_assert(VectorsEqual(I, FourCharsExtVec{0, 2, 2, 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>
+  static_assert(VectorsEqual(J, FourCharsExtVec{5, 1, 1, 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>
+  static_assert(VectorsEqual(K, FourCharsExtVec{5, 3, 3, 5}), "");
+
   constexpr auto L = FourCharsExtVec{1, 2, 3, 4} & 3;
-  // CHECK: store <4 x i8> <i8 1, i8 2, i8 3, i8 0>
+  static_assert(VectorsEqual(L, FourCharsExtVec{1, 2, 3, 0}), "");
+
   constexpr auto M = FourCharsExtVec{1, 2, 3, 4} ^ 3;
-  // CHECK: store <4 x i8> <i8 2, i8 1, i8 0, i8 7>
+  static_assert(VectorsEqual(M, FourCharsExtVec{2, 1, 0, 7}), "");
+
   constexpr auto N = FourCharsExtVec{1, 2, 3, 4} | 3;
-  // CHECK: store <4 x i8> <i8 3, i8 3, i8 3, i8 7>
+  static_assert(VectorsEqual(N, FourCharsExtVec{3, 3, 3, 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>
+  static_assert(VectorsEqual(O, FourCharsExtVec{1, 0, 0, 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>
+  static_assert(VectorsEqual(P, FourCharsExtVec{1, 1, 1, 0}), "");
 
   constexpr auto Q = FourCharsExtVec{5, 0, 6, 0} && 3;
-  // CHECK: store <4 x i8> <i8 1, i8 0, i8 1, i8 0>
+  static_assert(VectorsEqual(Q, FourCharsExtVec{1, 0, 1, 0}), "");
+
   constexpr auto R = FourCharsExtVec{5, 0, 6, 0} || 3;
-  // CHECK: store <4 x i8> <i8 1, i8 1, i8 1, i8 1>
+  static_assert(VectorsEqual(R, FourCharsExtVec{1, 1, 1, 1}), "");
 
   constexpr auto T = CmpMul(a, b);
-  // CHECK: store <4 x i8> <i8 108, i8 18, i8 56, i8 72>
+  static_assert(VectorsEqual(T, FourCharsExtVec{108, 18, 56, 72}), "");
 
   constexpr auto U = CmpDiv(a, b);
-  // CHECK: store <4 x i8> <i8 3, i8 18, i8 0, i8 0>
+  static_assert(VectorsEqual(U, FourCharsExtVec{3, 18, 0, 0}), "");
 
   constexpr auto V = CmpRem(a, b);
-  // CHECK: store <4 x i8> <i8 0, i8 0, i8 7, i8 8>
+  static_assert(VectorsEqual(V, FourCharsExtVec{0, 0, 7, 8}), "");
 
   constexpr auto X = CmpAdd(a, b);
-  // CHECK: store <4 x i8> <i8 24, i8 19, i8 15, i8 17>
+  static_assert(VectorsEqual(X, FourCharsExtVec{24, 19, 15, 17}), "");
 
   constexpr auto Y = CmpSub(a, b);
-  // CHECK: store <4 x i8> <i8 12, i8 17, i8 -1, i8 -1>
+  static_assert(VectorsEqual(Y, FourCharsExtVec{12, 17, -1, -1}), "");
 
   constexpr auto InvH = -H;
-  // CHECK: store <4 x i8> <i8 1, i8 1, i8 0, i8 1>
+  static_assert(VectorsEqual(InvH, FourCharsExtVec{1, 1, 0, 1}), "");
 
   constexpr auto Z = CmpLSH(a, InvH);
-  // CHECK: store <4 x i8> <i8 36, i8 36, i8 7, i8 16>
+  static_assert(VectorsEqual(Z, FourCharsExtVec{36, 36, 7, 16}), "");
 
   constexpr auto aa = CmpRSH(a, InvH);
-  // CHECK: store <4 x i8> <i8 9, i8 9, i8 7, i8 4>
+  static_assert(VectorsEqual(aa, FourCharsExtVec{9, 9, 7, 4}), "");
 
   constexpr auto ab = CmpBinAnd(a, b);
-  // CHECK: store <4 x i8> <i8 2, i8 0, i8 0, i8 8>
+  static_assert(VectorsEqual(ab, FourCharsExtVec{2, 0, 0, 8}), "");
 
   constexpr auto ac = CmpBinXOr(a, b);
-  // CHECK: store <4 x i8> <i8 20, i8 19, i8 15, i8 1>
+  static_assert(VectorsEqual(ac, FourCharsExtVec{20, 19, 15, 1}), "");
 
   constexpr auto ad = CmpBinOr(a, b);
-  // CHECK: store <4 x i8> <i8 22, i8 19, i8 15, i8 9>
+  static_assert(VectorsEqual(ad, FourCharsExtVec{22, 19, 15, 9}), "");
 
   constexpr auto ae = ~FourCharsExtVec{1, 2, 10, 20};
-  // CHECK: store <4 x i8> <i8 -2, i8 -3, i8 -11, i8 -21>
+  static_assert(VectorsEqual(ae, FourCharsExtVec{-2, -3, -11, -21}), "");
 
   constexpr auto af = !FourCharsExtVec{0, 1, 8, -1};
-  // CHECK: store <4 x i8> <i8 -1, i8 0, i8 0, i8 0>
+  static_assert(VectorsEqual(af, FourCharsExtVec{-1, 0, 0, 0}), "");
+
+  constexpr auto ag = UpdateElementsInPlace(
+                  FourCharsExtVec{3, 3, 0, 0}, FourCharsExtVec{3, 0, 0, 0});
+  static_assert(VectorsEqual(ag, FourCharsExtVec{6, 4, 1, 0}), "");
 }
 
 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>
+  static_assert(VectorsEqual(a, FourFloatsVecSize{1.800000e+01, 1.800000e+01, 7.000000e+00, 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>
+  static_assert(VectorsEqual(b, FourFloatsVecSize{6.000000e+00, 1.000000e+00, 8.000000e+00, 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>
+  static_assert(VectorsEqual(c, FourFloatsVecSize{2.400000e+01, 1.600000e+01, 1.000000e+01, 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>
+  static_assert(VectorsEqual(d, FourFloatsVecSize{2.000000e+00, 3.000000e+00, 2.000000e+00, 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>
+  static_assert(VectorsEqual(f, FourFloatsVecSize{9.000000e+00, 6.000000e+00, 5.000000e+00, 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>
+  static_assert(VectorsEqual(g, FourFloatsVecSize{1.600000e+01, 1.200000e+01, 9.000000e+00, 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>
+  static_assert(VectorsEqual(h, FourFloatsVecSize{2.400000e+01, 1.200000e+01, 6.000000e+00, 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>
+  static_assert(VectorsEqual(j, FourFloatsVecSize{4.000000e+00, 5.000000e+00, 6.000000e+00, 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>
+  static_assert(VectorsEqual(l, FourFloatsVecSize{9.000000e+00, 6.000000e+00, 5.000000e+00, 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>
+  static_assert(VectorsEqual(m, FourFloatsVecSize{1.000000e+00, 5.000000e+00, 8.000000e+00, 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>
+  static_assert(VectorsEqual(n, FourFloatsVecSize{2.400000e+01, 1.200000e+01, 6.000000e+00, 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>
+  static_assert(VectorsEqual(o, FourFloatsVecSize{100.0f / 12.0f, 100.0f / 15.0f, 100.0f / 18.0f, 100.0f / 21.0f}), "");
 
   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>
+  static_assert(VectorsEqual(w, FourIntsVecSize{-1, -1, 0, 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>
+  static_assert(VectorsEqual(x, FourIntsVecSize{0, 0, -1, -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>
+  static_assert(VectorsEqual(y, FourIntsVecSize{-1, -1, -1, 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>
+  static_assert(VectorsEqual(z, FourIntsVecSize{0, 0, -1, -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>
+  static_assert(VectorsEqual(A, FourIntsVecSize{0, 0, -1, 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>
+  static_assert(VectorsEqual(B, FourIntsVecSize{-1, -1, 0, -1}), "");
 
   constexpr auto C = FourFloatsVecSize{1, 2, 3, 4} < 3;
-  // CHECK: store <4 x i32> <i32 -1, i32 -1, i32 0, i32 0>
+  static_assert(VectorsEqual(C, FourIntsVecSize{-1, -1, 0, 0}), "");
+
   constexpr auto D = FourFloatsVecSize{1, 2, 3, 4} > 3;
-  // CHECK: store <4 x i32> <i32 0, i32 0, i32 0, i32 -1>
+  static_assert(VectorsEqual(D, FourIntsVecSize{0, 0, 0, -1}), "");
+
   constexpr auto E = FourFloatsVecSize{1, 2, 3, 4} <= 3;
-  // CHECK: store <4 x i32> <i32 -1, i32 -1, i32 -1, i32 0>
+  static_assert(VectorsEqual(E, FourIntsVecSize{-1, -1, -1, 0}), "");
+
   constexpr auto F = FourFloatsVecSize{1, 2, 3, 4} >= 3;
-  // CHECK: store <4 x i32> <i32 0, i32 0, i32 -1, i32 -1>
+  static_assert(VectorsEqual(F, FourIntsVecSize{0, 0, -1, -1}), "");
+
   constexpr auto G = FourFloatsVecSize{1, 2, 3, 4} == 3;
-  // CHECK: store <4 x i32> <i32 0, i32 0, i32 -1, i32 0>
+  static_assert(VectorsEqual(G, FourIntsVecSize{0, 0, -1, 0}), "");
+
   constexpr auto H = FourFloatsVecSize{1, 2, 3, 4} != 3;
-  // CHECK: store <4 x i32> <i32 -1, i32 -1, i32 0, i32 -1>
+  static_assert(VectorsEqual(H, FourIntsVecSize{-1, -1, 0, -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>
+  static_assert(VectorsEqual(O, FourIntsVecSize{1, 0, 0, 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>
+  static_assert(VectorsEqual(P, FourIntsVecSize{1, 1, 1, 0}), "");
 
   constexpr auto Q = FourFloatsVecSize{5, 0, 6, 0} && 3;
-  // CHECK: store <4 x i32> <i32 1, i32 0, i32 1, i32 0>
+  static_assert(VectorsEqual(Q, FourIntsVecSize{1, 0, 1, 0}), "");
+
   constexpr auto R = FourFloatsVecSize{5, 0, 6, 0} || 3;
-  // CHECK: store <4 x i32> <i32 1, i32 1, i32 1, i32 1>
+  static_assert(VectorsEqual(R, FourIntsVecSize{1, 1, 1, 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>
+  static_assert(VectorsEqual(T, FourFloatsVecSize{1.080000e+02, 1.800000e+01, 5.600000e+01, 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>
+  static_assert(VectorsEqual(U, FourFloatsVecSize{3.000000e+00, 1.800000e+01, 8.750000e-01, a[3] / b[3]}), "");
 
   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>
+  static_assert(VectorsEqual(X, FourFloatsVecSize{2.400000e+01, 1.900000e+01, 1.500000e+01, 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>
+  static_assert(VectorsEqual(Y, FourFloatsVecSize{1.200000e+01, 1.700000e+01, -1.000000e+00, -1.000000e+00}), "");
 
   constexpr auto Z = -Y;
-  // CHECK: store <4 x float> <float -1.200000e+01, float -1.700000e+01, float 1.000000e+00, float 1.000000e+00>
+  static_assert(VectorsEqual(Z, FourFloatsVecSize{-1.200000e+01, -1.700000e+01, 1.000000e+00, 1.000000e+00}), "");
 
   // Operator ~ is illegal on floats, so no test for that.
   constexpr auto af = !FourFloatsVecSize{0, 1, 8, -1};
-  // CHECK: store <4 x i32> <i32 -1, i32 0, i32 0, i32 0>
+  static_assert(VectorsEqual(af, FourIntsVecSize{-1, 0, 0, 0}), "");
+
+  constexpr auto ag = UpdateElementsInPlace(
+                    FourFloatsVecSize{3, 3, 0, 0}, FourFloatsVecSize{3, 0, 0, 0});
+  static_assert(VectorsEqual(ag, FourFloatsVecSize{6, 4, 1, 0}), "");
 }
 
 void FloatVecUsage() {
-  constexpr auto a = FourFloatsVecSize{6, 3, 2, 1} +
-                     FourFloatsVecSize{12, 15, 5, 7};
+  constexpr auto a = FourFloatsExtVec{6, 3, 2, 1} +
+                     FourFloatsExtVec{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 b = FourFloatsExtVec{19, 15, 13, 12} -
+                     FourFloatsExtVec{13, 14, 5, 3};
+  static_assert(VectorsEqual(b, FourFloatsExtVec{6.000000e+00, 1.000000e+00, 8.000000e+00, 9.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 c = FourFloatsExtVec{8, 4, 2, 1} *
+                     FourFloatsExtVec{3, 4, 5, 6};
+  static_assert(VectorsEqual(c, FourFloatsExtVec{2.400000e+01, 1.600000e+01, 1.000000e+01, 6.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 d = FourFloatsExtVec{12, 12, 10, 10} /
+                     FourFloatsExtVec{6, 4, 5, 2};
+  static_assert(VectorsEqual(d, FourFloatsExtVec{2.000000e+00, 3.000000e+00, 2.000000e+00, 5.000000e+00}), "");
 
-  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 f = FourFloatsExtVec{6, 3, 2, 1} + 3;
+  static_assert(VectorsEqual(f, FourFloatsExtVec{9.000000e+00, 6.000000e+00, 5.000000e+00, 4.000000e+00}), "");
 
-  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 g = FourFloatsExtVec{19, 15, 12, 10} - 3;
+  static_assert(VectorsEqual(g, FourFloatsExtVec{1.600000e+01, 1.200000e+01, 9.000000e+00, 7.000000e+00}), "");
 
-  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 h = FourFloatsExtVec{8, 4, 2, 1} * 3;
+  static_assert(VectorsEqual(h, FourFloatsExtVec{2.400000e+01, 1.200000e+01, 6.000000e+00, 3.000000e+00}), "");
 
-  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 j = FourFloatsExtVec{12, 15, 18, 21} / 3;
+  static_assert(VectorsEqual(j, FourFloatsExtVec{4.000000e+00, 5.000000e+00, 6.000000e+00, 7.000000e+00}), "");
+
+  constexpr auto l = 3 + FourFloatsExtVec{6, 3, 2, 1};
+  static_assert(VectorsEqual(l, FourFloatsExtVec{9.000000e+00, 6.000000e+00, 5.000000e+00, 4.000000e+00}), "");
+
+  constexpr auto m = 20 - FourFloatsExtVec{19, 15, 12, 10};
+  static_assert(VectorsEqual(m, FourFloatsExtVec{1.000000e+00, 5.000000e+00, 8.000000e+00, 1.000000e+01}), "");
+
+  constexpr auto n = 3 * FourFloatsExtVec{8, 4, 2, 1};
+  static_assert(VectorsEqual(n, FourFloatsExtVec{2.400000e+01, 1.200000e+01, 6.000000e+00, 3.000000e+00}), "");
+
+  constexpr auto o = 100 / FourFloatsExtVec{12, 15, 18, 21};
+  static_assert(VectorsEqual(o, FourFloatsExtVec{100.0f / 12.0f, 100.0f / 15.0f, 100.0f / 18.0f, 100.0f / 21.0f}), "");
+
+  constexpr auto w = FourFloatsExtVec{1, 2, 3, 4} <
+                     FourFloatsExtVec{4, 3, 2, 1};
+  static_assert(VectorsEqual(w, FourIntsExtVec{-1, -1, 0, 0}), "");
+
+  constexpr auto x = FourFloatsExtVec{1, 2, 3, 4} >
+                     FourFloatsExtVec{4, 3, 2, 1};
+  static_assert(VectorsEqual(x, FourIntsExtVec{0, 0, -1, -1}), "");
+
+  constexpr auto y = FourFloatsExtVec{1, 2, 3, 4} <=
+                     FourFloatsExtVec{4, 3, 3, 1};
+  static_assert(VectorsEqual(y, FourIntsExtVec{-1, -1, -1, 0}), "");
+
+  constexpr auto z = FourFloatsExtVec{1, 2, 3, 4} >=
+                     FourFloatsExtVec{4, 3, 3, 1};
+  static_assert(VectorsEqual(z, FourIntsExtVec{0, 0, -1, -1}), "");
+
+  constexpr auto A = FourFloatsExtVec{1, 2, 3, 4} ==
+                     FourFloatsExtVec{4, 3, 3, 1};
+  static_assert(VectorsEqual(A, FourIntsExtVec{0, 0, -1, 0}), "");
+
+  constexpr auto B = FourFloatsExtVec{1, 2, 3, 4} !=
+                     FourFloatsExtVec{4, 3, 3, 1};
+  static_assert(VectorsEqual(B, FourIntsExtVec{-1, -1, 0, -1}), "");
+
+  constexpr auto C = FourFloatsExtVec{1, 2, 3, 4} < 3;
+  static_assert(VectorsEqual(C, FourIntsExtVec{-1, -1, 0, 0}), "");
+
+  constexpr auto D = FourFloatsExtVec{1, 2, 3, 4} > 3;
+  static_assert(VectorsEqual(D, FourIntsExtVec{0, 0, 0, -1}), "");
+
+  constexpr auto E = FourFloatsExtVec{1, 2, 3, 4} <= 3;
+  static_assert(VectorsEqual(E, FourIntsExtVec{-1, -1, -1, 0}), "");
+
+  constexpr auto F = FourFloatsExtVec{1, 2, 3, 4} >= 3;
+  static_assert(VectorsEqual(F, FourIntsExtVec{0, 0, -1, -1}), "");
+
+  constexpr auto G = FourFloatsExtVec{1, 2, 3, 4} == 3;
+  static_assert(VectorsEqual(G, FourIntsExtVec{0, 0, -1, 0}), "");
+
+  constexpr auto H = FourFloatsExtVec{1, 2, 3, 4} != 3;
+  static_assert(VectorsEqual(H, FourIntsExtVec{-1, -1, 0, -1}), "");
+
+  constexpr auto O = FourFloatsExtVec{5, 0, 6, 0} &&
+                     FourFloatsExtVec{5, 5, 0, 0};
+  static_assert(VectorsEqual(O, FourIntsExtVec{1, 0, 0, 0}), "");
+
+  constexpr auto P = FourFloatsExtVec{5, 0, 6, 0} ||
+                     FourFloatsExtVec{5, 5, 0, 0};
+  static_assert(VectorsEqual(P, FourIntsExtVec{1, 1, 1, 0}), "");
+
+  constexpr auto Q = FourFloatsExtVec{5, 0, 6, 0} && 3;
+  static_assert(VectorsEqual(Q, FourIntsExtVec{1, 0, 1, 0}), "");
+
+  constexpr auto R = FourFloatsExtVec{5, 0, 6, 0} || 3;
+  static_assert(VectorsEqual(R, FourIntsExtVec{1, 1, 1, 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>
+  static_assert(VectorsEqual(T, FourFloatsExtVec{1.080000e+02, 1.800000e+01, 5.600000e+01, 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>
+  static_assert(VectorsEqual(U, FourFloatsExtVec{3.000000e+00, 1.800000e+01, 8.750000e-01, a[3] / b[3]}), "");
 
   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>
+  static_assert(VectorsEqual(X, FourFloatsExtVec{2.400000e+01, 1.900000e+01, 1.500000e+01, 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>
+  static_assert(VectorsEqual(Y, FourFloatsExtVec{1.200000e+01, 1.700000e+01, -1.000000e+00, -1.000000e+00}), "");
 
   constexpr auto Z = -Y;
-  // CHECK: store <4 x float> <float -1.200000e+01, float -1.700000e+01, float 1.000000e+00, float 1.000000e+00>
+  static_assert(VectorsEqual(Z, FourFloatsExtVec{-1.200000e+01, -1.700000e+01, 1.000000e+00, 1.000000e+00}), "");
 
   // Operator ~ is illegal on floats, so no test for that.
-  constexpr auto af = !FourFloatsVecSize{0, 1, 8, -1};
-  // CHECK: store <4 x i32> <i32 -1, i32 0, i32 0, i32 0>
+  constexpr auto af = !FourFloatsExtVec{0, 1, 8, -1};
+  static_assert(VectorsEqual(af, FourIntsExtVec{-1, 0, 0, 0}), "");
+
+  constexpr auto ag = UpdateElementsInPlace(
+                    FourFloatsExtVec{3, 3, 0, 0}, FourFloatsExtVec{3, 0, 0, 0});
+  static_assert(VectorsEqual(ag, FourFloatsExtVec{6, 4, 1, 0}), "");
 }
 
 void I128Usage() {
   constexpr auto a = FourI128VecSize{1, 2, 3, 4};
-  // CHECK: store <4 x i128> <i128 1, i128 2, i128 3, i128 4>
+  static_assert(VectorsEqual(a, FourI128VecSize{1, 2, 3, 4}), "");
+
   constexpr auto b = a < 3;
-  // CHECK: store <4 x i128> <i128 -1, i128 -1, i128 0, i128 0>
+  static_assert(VectorsEqual(b, FourI128VecSize{-1, -1, 0, 0}), "");
 
   // Operator ~ is illegal on floats, so no test for that.
   constexpr auto c = ~FourI128VecSize{1, 2, 10, 20};
-  // CHECK: store <4 x i128> <i128 -2, i128 -3, i128 -11, i128 -21>
+  static_assert(VectorsEqual(c, FourI128VecSize{-2, -3, -11, -21}), "");
 
   constexpr auto d = !FourI128VecSize{0, 1, 8, -1};
-  // CHECK: store <4 x i128> <i128 -1, i128 0, i128 0, i128 0>
+  static_assert(VectorsEqual(d, FourI128VecSize{-1, 0, 0, 0}), "");
 }
 
 void I128VecUsage() {
   constexpr auto a = FourI128ExtVec{1, 2, 3, 4};
-  // CHECK: store <4 x i128> <i128 1, i128 2, i128 3, i128 4>
+  static_assert(VectorsEqual(a, FourI128ExtVec{1, 2, 3, 4}), "");
+
   constexpr auto b = a < 3;
-  // CHECK: store <4 x i128> <i128 -1, i128 -1, i128 0, i128 0>
+  static_assert(VectorsEqual(b, FourI128ExtVec{-1, -1, 0, 0}), "");
 
   // Operator ~ is illegal on floats, so no test for that.
   constexpr auto c = ~FourI128ExtVec{1, 2, 10, 20};
-  // CHECK: store <4 x i128>  <i128 -2, i128 -3, i128 -11, i128 -21>
+  static_assert(VectorsEqual(c, FourI128ExtVec{-2, -3, -11, -21}), "");
 
   constexpr auto d = !FourI128ExtVec{0, 1, 8, -1};
-  // CHECK: store <4 x i128>  <i128 -1, i128 0, i128 0, i128 0>
+  static_assert(VectorsEqual(d, FourI128ExtVec{-1, 0, 0, 0}), "");
 }
 
 using FourBoolsExtVec __attribute__((ext_vector_type(4))) = bool;
 void BoolVecUsage() {
   constexpr auto a = FourBoolsExtVec{true, false, true, false} <
                      FourBoolsExtVec{false, false, true, true};
-  // CHECK: store i8 bitcast (<8 x i1> <i1 false, i1 false, i1 false, i1 true, i1 undef, i1 undef, i1 undef, i1 undef> to i8), ptr %a, align 1
+  static_assert(VectorsEqual(a, FourBoolsExtVec{false, false, false, true}), "");
+
   constexpr auto b = FourBoolsExtVec{true, false, true, false} <=
                      FourBoolsExtVec{false, false, true, true};
-  // CHECK: store i8 bitcast (<8 x i1> <i1 false, i1 true, i1 true, i1 true, i1 undef, i1 undef, i1 undef, i1 undef> to i8), ptr %b, align 1
+  static_assert(VectorsEqual(b, FourBoolsExtVec{false, true, true, true}), "");
+
   constexpr auto c = FourBoolsExtVec{true, false, true, false} ==
                      FourBoolsExtVec{false, false, true, true};
-  // CHECK: store i8 bitcast (<8 x i1> <i1 false, i1 true, i1 true, i1 false, i1 undef, i1 undef, i1 undef, i1 undef> to i8), ptr %c, align 1
+  static_assert(VectorsEqual(c, FourBoolsExtVec{false, true, true, false}), "");
+
   constexpr auto d = FourBoolsExtVec{true, false, true, false} !=
                      FourBoolsExtVec{false, false, true, true};
-  // CHECK: store i8 bitcast (<8 x i1> <i1 true, i1 false, i1 false, i1 true, i1 undef, i1 undef, i1 undef, i1 undef> to i8), ptr %d, align 1
+  static_assert(VectorsEqual(d, FourBoolsExtVec{true, false, false, true}), "");
+
   constexpr auto e = FourBoolsExtVec{true, false, true, false} >=
                      FourBoolsExtVec{false, false, true, true};
-  // CHECK: store i8 bitcast (<8 x i1> <i1 true, i1 true, i1 true, i1 false, i1 undef, i1 undef, i1 undef, i1 undef> to i8), ptr %e, align 1
+  static_assert(VectorsEqual(e, FourBoolsExtVec{true, true, true, false}), "");
+
   constexpr auto f = FourBoolsExtVec{true, false, true, false} >
                      FourBoolsExtVec{false, false, true, true};
-  // CHECK: store i8 bitcast (<8 x i1> <i1 true, i1 false, i1 false, i1 false, i1 undef, i1 undef, i1 undef, i1 undef> to i8), ptr %f, align 1
+  static_assert(VectorsEqual(f, FourBoolsExtVec{true, false, false, false}), "");
+
   constexpr auto g = FourBoolsExtVec{true, false, true, false} &
                      FourBoolsExtVec{false, false, true, true};
-  // CHECK: store i8 bitcast (<8 x i1> <i1 false, i1 false, i1 true, i1 false, i1 undef, i1 undef, i1 undef, i1 undef> to i8), ptr %g, align 1
+  static_assert(VectorsEqual(g, FourBoolsExtVec{false, false, true, false}), "");
+
   constexpr auto h = FourBoolsExtVec{true, false, true, false} |
                      FourBoolsExtVec{false, false, true, true};
-  // CHECK: store i8 bitcast (<8 x i1> <i1 true, i1 false, i1 true, i1 true, i1 undef, i1 undef, i1 undef, i1 undef> to i8), ptr %h, align 1
+  static_assert(VectorsEqual(h, FourBoolsExtVec{true, false, true, true}), "");
+
   constexpr auto i = FourBoolsExtVec{true, false, true, false} ^
                      FourBoolsExtVec { false, false, true, true };
-  // CHECK: store i8 bitcast (<8 x i1> <i1 true, i1 false, i1 false, i1 true, i1 undef, i1 undef, i1 undef, i1 undef> to i8), ptr %i, align 1
+  static_assert(VectorsEqual(i, FourBoolsExtVec{true, false, false, true}), "");
+
   constexpr auto j = !FourBoolsExtVec{true, false, true, false};
-  // CHECK: store i8 bitcast (<8 x i1> <i1 false, i1 true, i1 false, i1 true, i1 undef, i1 undef, i1 undef, i1 undef> to i8), ptr %j, align 1
+  static_assert(VectorsEqual(j, FourBoolsExtVec{false, true, false, true}), "");
+
   constexpr auto k = ~FourBoolsExtVec{true, false, true, false};
-  // CHECK: store i8 bitcast (<8 x i1> <i1 false, i1 true, i1 false, i1 true, i1 undef, i1 undef, i1 undef, i1 undef> to i8), ptr %k, align 1
+  static_assert(VectorsEqual(k, FourBoolsExtVec{false, true, false, true}), "");
 }