[MVT][SVE] Add EVT strings and Type mapping

[huntergr]

Summary

Adds mappings between scalable MVT types and IR Types,
along with string printing. Fixes an issue reported by Jeroen.

[huntergr]

This comment was removed by huntergr.

[jeroen.dobbelaere]

lib/CodeGen/ValueTypes.cpp

118 ↗

(On Diff #149950)

Won't you need to have printing support for the generic scalable vector ? That should come here.

[huntergr]

Fixed string representation of scalable vectors which don't map to the existing defined set of MVTs.

[greened]

lib/CodeGen/ValueTypes.cpp

193 ↗

(On Diff #150303)

I can't find where these are defined, but given that the IR type is <scalable v4f32> should these names reflect that? "nx" is nice and short but may be confusing in that the mapping from "scalable" to "nx" isn't necessarily obvious.

[rkruppe]

lib/CodeGen/ValueTypes.cpp

193 ↗

(On Diff #150303)

As MC layer support for SVE started landing quite a while ago, the backend types too landed back then with names matching the then-current proposal for the IR types (<n x 4 x ...>). I agree it would be nice to have the backend type names match, but that's a bunch of churn, so it shouldn't be coupled to this patch and should wait until the IR type system changes are committed in case their name changes again.

[greened]

lib/CodeGen/ValueTypes.cpp

193 ↗

(On Diff #150303)

Thanks, that makes sense to me.

[greened]

What's the status of this?

[huntergr]

• Updated to head
• Removed MVT-specific ElementCount in favour of using the common struct
• Added unit tests.

[greened]

llvm/lib/CodeGen/ValueTypes.cpp

347

It would be helpful to add a comment about what true means, here and below:

return VectorType::get(Type::getInt1Ty(Context), 1, /* isScalable = */true);

416

Add a comment about what false means, similar to above.

[huntergr]

• Added inline comments to clarify boolean parameter meaning.

[greened]

LGTM, thanks!

llvm/lib/CodeGen/ValueTypes.cpp

208

This isn't a comment on this patch per se but rather a question about this code overall. Why do we have all these vector and integer cases, for SVE and non-SVE? It seems like the default case should handle them all.

I'm not at all saying you should change this. It's just an observation for a possible future NFC change from <someone>.

llvm/include/llvm/CodeGen/TargetLowering.h

EVT getValueType(const DataLayout &DL, Type *Ty,
     if (auto *VTy = dyn_cast<VectorType>(Ty)) {
       Type *EltTy = VTy->getElementType();
       // Lower vectors of pointers to native pointer types.
       if (auto *PTy = dyn_cast<PointerType>(EltTy)) {
         EVT PointerTy(getPointerTy(DL, PTy->getAddressSpace()));
         EltTy = PointerTy.getTypeForEVT(Ty->getContext());
       }
       return EVT::getVectorVT(Ty->getContext(), EVT::getEVT(EltTy, false),
-                              VTy->getNumElements());
+                              VTy->getElementCount());
     }
 
     return EVT::getEVT(Ty, AllowUnknown);
   }
 
   EVT getMemValueType(const DataLayout &DL, Type *Ty,
                       bool AllowUnknown = false) const {
     // Lower scalar pointers to native pointer types.

llvm/include/llvm/CodeGen/ValueTypes.h

static EVT getVectorVT(LLVMContext &Context, EVT VT, unsigned NumElements,
         return M;
 
       assert(!IsScalable && "We don't support extended scalable types yet");
       return getExtendedVectorVT(Context, VT, NumElements);
     }
 
     /// Returns the EVT that represents a vector EC.Min elements in length,
     /// where each element is of type VT.
-    static EVT getVectorVT(LLVMContext &Context, EVT VT, MVT::ElementCount EC) {
+    static EVT getVectorVT(LLVMContext &Context, EVT VT, ElementCount EC) {
       MVT M = MVT::getVectorVT(VT.V, EC);
       if (M.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE)
         return M;
       assert (!EC.Scalable && "We don't support extended scalable types yet");
       return getExtendedVectorVT(Context, VT, EC.Min);
     }
 
     /// Return a vector with the same number of elements as this vector, but
public:
     unsigned getVectorNumElements() const {
       assert(isVector() && "Invalid vector type!");
       if (isSimple())
         return V.getVectorNumElements();
       return getExtendedVectorNumElements();
     }
 
     // Given a (possibly scalable) vector type, return the ElementCount
-    MVT::ElementCount getVectorElementCount() const {
+    ElementCount getVectorElementCount() const {
       assert((isVector()) && "Invalid vector type!");
       if (isSimple())
         return V.getVectorElementCount();
 
       assert(!isScalableVector() &&
              "We don't support extended scalable types yet");
       return {getExtendedVectorNumElements(), false};
     }

llvm/include/llvm/Support/MachineValueType.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_MACHINEVALUETYPE_H
 #define LLVM_SUPPORT_MACHINEVALUETYPE_H
 
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/ScalableSize.h"
 #include <cassert>
 
 namespace llvm {
 
   class Type;
 
   /// Machine Value Type. Every type that is supported natively by some
   /// processor targeted by LLVM occurs here. This means that any legal value
enum SimpleValueType : uint8_t {
 
       // Any type. This is used for intrinsics that have overloadings.
       // This is only for tblgen's consumption!
       Any            = 255
     };
 
     SimpleValueType SimpleTy = INVALID_SIMPLE_VALUE_TYPE;
 
-    // A class to represent the number of elements in a vector
-    //
-    // For fixed-length vectors, the total number of elements is equal to 'Min'
-    // For scalable vectors, the total number of elements is a multiple of 'Min'
-    class ElementCount {
-    public:
-      unsigned Min;
-      bool Scalable;
-
-      ElementCount(unsigned Min, bool Scalable)
-      : Min(Min), Scalable(Scalable) {}
-
-      ElementCount operator*(unsigned RHS) {
-        return { Min * RHS, Scalable };
-      }
-
-      ElementCount& operator*=(unsigned RHS) {
-        Min *= RHS;
-        return *this;
-      }
-
-      ElementCount operator/(unsigned RHS) {
-        return { Min / RHS, Scalable };
-      }
-
-      ElementCount& operator/=(unsigned RHS) {
-        Min /= RHS;
-        return *this;
-      }
-
-      bool operator==(const ElementCount& RHS) {
-        return Min == RHS.Min && Scalable == RHS.Scalable;
-      }
-    };
-
     constexpr MVT() = default;
     constexpr MVT(SimpleValueType SVT) : SimpleTy(SVT) {}
 
     bool operator>(const MVT& S)  const { return SimpleTy >  S.SimpleTy; }
     bool operator<(const MVT& S)  const { return SimpleTy <  S.SimpleTy; }
     bool operator==(const MVT& S) const { return SimpleTy == S.SimpleTy; }
     bool operator!=(const MVT& S) const { return SimpleTy != S.SimpleTy; }
     bool operator>=(const MVT& S) const { return SimpleTy >= S.SimpleTy; }
unsigned getVectorNumElements() const {
       case nxv1i16:
       case nxv1i32:
       case nxv1i64:
       case nxv1f32:
       case nxv1f64: return 1;
       }
     }
 
-    MVT::ElementCount getVectorElementCount() const {
+    ElementCount getVectorElementCount() const {
       return { getVectorNumElements(), isScalableVector() };
     }
 
     unsigned getSizeInBits() const {
       switch (SimpleTy) {
       default:
         llvm_unreachable("getSizeInBits called on extended MVT.");
       case Other:
public:
     }
 
     static MVT getVectorVT(MVT VT, unsigned NumElements, bool IsScalable) {
       if (IsScalable)
         return getScalableVectorVT(VT, NumElements);
       return getVectorVT(VT, NumElements);
     }
 
-    static MVT getVectorVT(MVT VT, MVT::ElementCount EC) {
+    static MVT getVectorVT(MVT VT, ElementCount EC) {
       if (EC.Scalable)
         return getScalableVectorVT(VT, EC.Min);
       return getVectorVT(VT, EC.Min);
     }
 
     /// Return the value type corresponding to the specified type.  This returns
     /// all pointers as iPTR.  If HandleUnknown is true, unknown types are
     /// returned as Other, otherwise they are invalid.

llvm/lib/CodeGen/ValueTypes.cpp

unsigned EVT::getExtendedSizeInBits() const {
   llvm_unreachable("Unrecognized extended type!");
 }
 
 /// getEVTString - This function returns value type as a string, e.g. "i32".
 std::string EVT::getEVTString() const {
   switch (V.SimpleTy) {
   default:
     if (isVector())
-      return "v" + utostr(getVectorNumElements()) +
-             getVectorElementType().getEVTString();
+      return (isScalableVector() ? "nxv" : "v") + utostr(getVectorNumElements())
+             + getVectorElementType().getEVTString();
     if (isInteger())
       return "i" + utostr(getSizeInBits());
     llvm_unreachable("Invalid EVT!");
   case MVT::i1:      return "i1";
   case MVT::i8:      return "i8";
   case MVT::i16:     return "i16";
   case MVT::i32:     return "i32";
   case MVT::i64:     return "i64";
std::string EVT::getEVTString() const {
   case MVT::v256f32: return "v256f32";
   case MVT::v512f32: return "v512f32";
   case MVT::v1024f32:return "v1024f32";
   case MVT::v2048f32:return "v2048f32";
   case MVT::v1f64:   return "v1f64";
   case MVT::v2f64:   return "v2f64";
   case MVT::v4f64:   return "v4f64";
   case MVT::v8f64:   return "v8f64";
+  case MVT::nxv1i1:  return "nxv1i1";
+  case MVT::nxv2i1:  return "nxv2i1";
+  case MVT::nxv4i1:  return "nxv4i1";
+  case MVT::nxv8i1:  return "nxv8i1";
+  case MVT::nxv16i1: return "nxv16i1";
+  case MVT::nxv32i1: return "nxv32i1";
+  case MVT::nxv1i8:  return "nxv1i8";
+  case MVT::nxv2i8:  return "nxv2i8";
+  case MVT::nxv4i8:  return "nxv4i8";
+  case MVT::nxv8i8:  return "nxv8i8";
+  case MVT::nxv16i8: return "nxv16i8";
+  case MVT::nxv32i8: return "nxv32i8";
+  case MVT::nxv1i16: return "nxv1i16";
+  case MVT::nxv2i16: return "nxv2i16";
+  case MVT::nxv4i16: return "nxv4i16";
+  case MVT::nxv8i16: return "nxv8i16";
+  case MVT::nxv16i16:return "nxv16i16";
+  case MVT::nxv32i16:return "nxv32i16";
+  case MVT::nxv1i32: return "nxv1i32";
+  case MVT::nxv2i32: return "nxv2i32";
+  case MVT::nxv4i32: return "nxv4i32";
+  case MVT::nxv8i32: return "nxv8i32";
+  case MVT::nxv16i32:return "nxv16i32";
+  case MVT::nxv32i32:return "nxv32i32";
+  case MVT::nxv1i64: return "nxv1i64";
+  case MVT::nxv2i64: return "nxv2i64";
+  case MVT::nxv4i64: return "nxv4i64";
+  case MVT::nxv8i64: return "nxv8i64";
+  case MVT::nxv16i64:return "nxv16i64";
+  case MVT::nxv32i64:return "nxv32i64";
+  case MVT::nxv2f16: return "nxv2f16";
+  case MVT::nxv4f16: return "nxv4f16";
+  case MVT::nxv8f16: return "nxv8f16";
+  case MVT::nxv1f32: return "nxv1f32";
+  case MVT::nxv2f32: return "nxv2f32";
+  case MVT::nxv4f32: return "nxv4f32";
+  case MVT::nxv8f32: return "nxv8f32";
+  case MVT::nxv16f32:return "nxv16f32";
+  case MVT::nxv1f64: return "nxv1f64";
+  case MVT::nxv2f64: return "nxv2f64";
+  case MVT::nxv4f64: return "nxv4f64";
+  case MVT::nxv8f64: return "nxv8f64";
   case MVT::Metadata:return "Metadata";
   case MVT::Untyped: return "Untyped";
   case MVT::exnref : return "exnref";
   }
 }
 
 /// getTypeForEVT - This method returns an LLVM type corresponding to the
 /// specified EVT.  For integer types, this returns an unsigned type.  Note
Type *EVT::getTypeForEVT(LLVMContext &Context) const {
   case MVT::v256f32: return VectorType::get(Type::getFloatTy(Context), 256);
   case MVT::v512f32: return VectorType::get(Type::getFloatTy(Context), 512);
   case MVT::v1024f32:return VectorType::get(Type::getFloatTy(Context), 1024);
   case MVT::v2048f32:return VectorType::get(Type::getFloatTy(Context), 2048);
   case MVT::v1f64:   return VectorType::get(Type::getDoubleTy(Context), 1);
   case MVT::v2f64:   return VectorType::get(Type::getDoubleTy(Context), 2);
   case MVT::v4f64:   return VectorType::get(Type::getDoubleTy(Context), 4);
   case MVT::v8f64:   return VectorType::get(Type::getDoubleTy(Context), 8);
+  case MVT::nxv1i1:  return VectorType::get(Type::getInt1Ty(Context), 1, true);
+  case MVT::nxv2i1:  return VectorType::get(Type::getInt1Ty(Context), 2, true);
+  case MVT::nxv4i1:  return VectorType::get(Type::getInt1Ty(Context), 4, true);
+  case MVT::nxv8i1:  return VectorType::get(Type::getInt1Ty(Context), 8, true);
+  case MVT::nxv16i1: return VectorType::get(Type::getInt1Ty(Context), 16, true);
+  case MVT::nxv32i1: return VectorType::get(Type::getInt1Ty(Context), 32, true);
+  case MVT::nxv1i8:  return VectorType::get(Type::getInt8Ty(Context), 1, true);
+  case MVT::nxv2i8:  return VectorType::get(Type::getInt8Ty(Context), 2, true);
+  case MVT::nxv4i8:  return VectorType::get(Type::getInt8Ty(Context), 4, true);
+  case MVT::nxv8i8:  return VectorType::get(Type::getInt8Ty(Context), 8, true);
+  case MVT::nxv16i8: return VectorType::get(Type::getInt8Ty(Context), 16, true);
+  case MVT::nxv32i8: return VectorType::get(Type::getInt8Ty(Context), 32, true);
+  case MVT::nxv1i16: return VectorType::get(Type::getInt16Ty(Context), 1, true);
+  case MVT::nxv2i16: return VectorType::get(Type::getInt16Ty(Context), 2, true);
+  case MVT::nxv4i16: return VectorType::get(Type::getInt16Ty(Context), 4, true);
+  case MVT::nxv8i16: return VectorType::get(Type::getInt16Ty(Context), 8, true);
+  case MVT::nxv16i16:return VectorType::get(Type::getInt16Ty(Context), 16,true);
+  case MVT::nxv32i16:return VectorType::get(Type::getInt16Ty(Context), 32,true);
+  case MVT::nxv1i32: return VectorType::get(Type::getInt32Ty(Context), 1, true);
+  case MVT::nxv2i32: return VectorType::get(Type::getInt32Ty(Context), 2, true);
+  case MVT::nxv4i32: return VectorType::get(Type::getInt32Ty(Context), 4, true);
+  case MVT::nxv8i32: return VectorType::get(Type::getInt32Ty(Context), 8, true);
+  case MVT::nxv16i32:return VectorType::get(Type::getInt32Ty(Context), 16,true);
+  case MVT::nxv32i32:return VectorType::get(Type::getInt32Ty(Context), 32,true);
+  case MVT::nxv1i64: return VectorType::get(Type::getInt64Ty(Context), 1, true);
+  case MVT::nxv2i64: return VectorType::get(Type::getInt64Ty(Context), 2, true);
+  case MVT::nxv4i64: return VectorType::get(Type::getInt64Ty(Context), 4, true);
+  case MVT::nxv8i64: return VectorType::get(Type::getInt64Ty(Context), 8, true);
+  case MVT::nxv16i64:return VectorType::get(Type::getInt64Ty(Context), 16,true);
+  case MVT::nxv32i64:return VectorType::get(Type::getInt64Ty(Context), 32,true);
+  case MVT::nxv2f16: return VectorType::get(Type::getHalfTy(Context), 2, true);
+  case MVT::nxv4f16: return VectorType::get(Type::getHalfTy(Context), 4, true);
+  case MVT::nxv8f16: return VectorType::get(Type::getHalfTy(Context), 8, true);
+  case MVT::nxv1f32: return VectorType::get(Type::getFloatTy(Context), 1, true);
+  case MVT::nxv2f32: return VectorType::get(Type::getFloatTy(Context), 2, true);
+  case MVT::nxv4f32: return VectorType::get(Type::getFloatTy(Context), 4, true);
+  case MVT::nxv8f32: return VectorType::get(Type::getFloatTy(Context), 8, true);
+  case MVT::nxv16f32:return VectorType::get(Type::getFloatTy(Context), 16,true);
+  case MVT::nxv1f64: return VectorType::get(Type::getDoubleTy(Context), 1,true);
+  case MVT::nxv2f64: return VectorType::get(Type::getDoubleTy(Context), 2,true);
+  case MVT::nxv4f64: return VectorType::get(Type::getDoubleTy(Context), 4,true);
+  case MVT::nxv8f64: return VectorType::get(Type::getDoubleTy(Context), 8,true);
   case MVT::Metadata: return Type::getMetadataTy(Context);
   }
 }
 
 /// Return the value type corresponding to the specified type.  This returns all
 /// pointers as MVT::iPTR.  If HandleUnknown is true, unknown types are returned
 /// as Other, otherwise they are invalid.
 MVT MVT::getVT(Type *Ty, bool HandleUnknown){
   switch (Ty->getTypeID()) {
   default:
MVT MVT::getVT(Type *Ty, bool HandleUnknown){
   case Type::X86_FP80TyID:  return MVT(MVT::f80);
   case Type::X86_MMXTyID:   return MVT(MVT::x86mmx);
   case Type::FP128TyID:     return MVT(MVT::f128);
   case Type::PPC_FP128TyID: return MVT(MVT::ppcf128);
   case Type::PointerTyID:   return MVT(MVT::iPTR);
   case Type::VectorTyID: {
     VectorType *VTy = cast<VectorType>(Ty);
     return getVectorVT(
-      getVT(VTy->getElementType(), false), VTy->getNumElements());
+      getVT(VTy->getElementType(), false), VTy->getElementCount());
   }
   }
 }
 
 /// getEVT - Return the value type corresponding to the specified type.  This
 /// returns all pointers as MVT::iPTR.  If HandleUnknown is true, unknown types
 /// are returned as Other, otherwise they are invalid.
 EVT EVT::getEVT(Type *Ty, bool HandleUnknown){
   switch (Ty->getTypeID()) {
   default:
     return MVT::getVT(Ty, HandleUnknown);
   case Type::IntegerTyID:
     return getIntegerVT(Ty->getContext(), cast<IntegerType>(Ty)->getBitWidth());
   case Type::VectorTyID: {
     VectorType *VTy = cast<VectorType>(Ty);
     return getVectorVT(Ty->getContext(), getEVT(VTy->getElementType(), false),
-                       VTy->getNumElements());
+                       VTy->getElementCount());
   }
   }
 }

llvm/unittests/CodeGen/ScalableVectorMVTsTest.cpp

 //===-------- llvm/unittest/CodeGen/ScalableVectorMVTsTest.cpp ------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/CodeGen/ValueTypes.h"
+#include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/Support/MachineValueType.h"
+#include "llvm/Support/ScalableSize.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 
 namespace {
 
 TEST(ScalableVectorMVTsTest, IntegerMVTs) {
   for (auto VecTy : MVT::integer_scalable_vector_valuetypes()) {

 
 TEST(ScalableVectorMVTsTest, HelperFuncs) {
   LLVMContext Ctx;
 
   // Create with scalable flag
   EVT Vnx4i32 = EVT::getVectorVT(Ctx, MVT::i32, 4, /*Scalable=*/true);
   ASSERT_TRUE(Vnx4i32.isScalableVector());
 
-  // Create with separate MVT::ElementCount
-  auto EltCnt = MVT::ElementCount(2, true);
+  // Create with separate llvm::ElementCount
+  auto EltCnt = ElementCount(2, true);
   EVT Vnx2i32 = EVT::getVectorVT(Ctx, MVT::i32, EltCnt);
   ASSERT_TRUE(Vnx2i32.isScalableVector());
 
-  // Create with inline MVT::ElementCount
+  // Create with inline llvm::ElementCount
   EVT Vnx2i64 = EVT::getVectorVT(Ctx, MVT::i64, {2, true});
   ASSERT_TRUE(Vnx2i64.isScalableVector());
 
   // Check that changing scalar types/element count works
   EXPECT_EQ(Vnx2i32.widenIntegerVectorElementType(Ctx), Vnx2i64);
   EXPECT_EQ(Vnx4i32.getHalfNumVectorElementsVT(Ctx), Vnx2i32);
 
   // Check that overloaded '*' and '/' operators work
   EXPECT_EQ(EVT::getVectorVT(Ctx, MVT::i64, EltCnt * 2), MVT::nxv4i64);
   EXPECT_EQ(EVT::getVectorVT(Ctx, MVT::i64, EltCnt / 2), MVT::nxv1i64);
 
   // Check that float->int conversion works
   EVT Vnx2f64 = EVT::getVectorVT(Ctx, MVT::f64, {2, true});
   EXPECT_EQ(Vnx2f64.changeTypeToInteger(), Vnx2i64);
 
-  // Check fields inside MVT::ElementCount
+  // Check fields inside llvm::ElementCount
   EltCnt = Vnx4i32.getVectorElementCount();
   EXPECT_EQ(EltCnt.Min, 4U);
   ASSERT_TRUE(EltCnt.Scalable);
 
   // Check that fixed-length vector types aren't scalable.
   EVT V8i32 = EVT::getVectorVT(Ctx, MVT::i32, 8);
   ASSERT_FALSE(V8i32.isScalableVector());
   EVT V4f64 = EVT::getVectorVT(Ctx, MVT::f64, {4, false});
   ASSERT_FALSE(V4f64.isScalableVector());
 
-  // Check that MVT::ElementCount works for fixed-length types.
+  // Check that llvm::ElementCount works for fixed-length types.
   EltCnt = V8i32.getVectorElementCount();
   EXPECT_EQ(EltCnt.Min, 8U);
   ASSERT_FALSE(EltCnt.Scalable);
 }
 
+TEST(ScalableVectorMVTsTest, IRToVTTranslation) {
+  LLVMContext Ctx;
+
+  Type *Int64Ty = Type::getInt64Ty(Ctx);
+  VectorType *ScV8Int64Ty = VectorType::get(Int64Ty, {8, true});
+
+  // Check that we can map a scalable IR type to an MVT 
+  MVT Mnxv8i64 = MVT::getVT(ScV8Int64Ty);
+  ASSERT_TRUE(Mnxv8i64.isScalableVector());
+  ASSERT_EQ(ScV8Int64Ty->getElementCount(), Mnxv8i64.getVectorElementCount());
+  ASSERT_EQ(MVT::getVT(ScV8Int64Ty->getElementType()),
+            Mnxv8i64.getScalarType());
+
+  // Check that we can map a scalable IR type to an EVT
+  EVT Enxv8i64 = EVT::getEVT(ScV8Int64Ty);
+  ASSERT_TRUE(Enxv8i64.isScalableVector());
+  ASSERT_EQ(ScV8Int64Ty->getElementCount(), Enxv8i64.getVectorElementCount());
+  ASSERT_EQ(EVT::getEVT(ScV8Int64Ty->getElementType()),
+            Enxv8i64.getScalarType());
 }
+
+TEST(ScalableVectorMVTsTest, VTToIRTranslation) {
+  LLVMContext Ctx;
+
+  EVT Enxv4f64 = EVT::getVectorVT(Ctx, MVT::f64, {4, true});
+
+  Type *Ty = Enxv4f64.getTypeForEVT(Ctx);
+  VectorType *ScV4Float64Ty = cast<VectorType>(Ty);
+  ASSERT_TRUE(ScV4Float64Ty->isScalable());
+  ASSERT_EQ(Enxv4f64.getVectorElementCount(), ScV4Float64Ty->getElementCount());
+  ASSERT_EQ(Enxv4f64.getScalarType().getTypeForEVT(Ctx),
+            ScV4Float64Ty->getElementType());
+}
+
+} // end anonymous namespace