[MVT][SVE] Scalable vector MVTs (3/3)

[huntergr]

Summary

Adds MVT::ElementCount to represent the length of a
vector which may be scalable, then adds helper functions
that work with it.

[rengolin]

include/llvm/CodeGen/MachineValueType.h

607 ↗

(On Diff #95133)

Can't you just return EC here?

include/llvm/CodeGen/ValueTypes.h

77 ↗

(On Diff #95133)

Add the comment inside the assert, like:

assert(!IsScalable && "we don't support extended scalable types yet");

97 ↗

(On Diff #95133)

ditto

157 ↗

(On Diff #95133)

I don't think this check is necessary, and may bite you later if you forget.

Either make it an assert, like the others, or just let the comparison get inlined.

284 ↗

(On Diff #95133)

ditto

[RKSimon]

include/llvm/CodeGen/MachineValueType.h

241 ↗

(On Diff #95133)

Why uint64_t and not unsigned like the other existing vector element count uses?

[huntergr]

include/llvm/CodeGen/MachineValueType.h

241 ↗

(On Diff #95133)

It was mostly to match the equivalent for IR -- VectorType::getNumElements() returns a uint64_t now (since NumElements was moved to SequentialType). I guess it doesn't need to be the same for CodeGen.

607 ↗

(On Diff #95133)

There isn't a defined EC variable for an MVT; it just contains a single SimpleValueType. Each MVT used would be noticeably larger (and increasing from 8bits to 16bits may already cause some problems, see comments on patch 2) if it included an ElementCount instance, so we just construct them on the fly based on the enum value of SimpleTy.

include/llvm/CodeGen/ValueTypes.h

77 ↗

(On Diff #95133)

Ok, will do.

157 ↗

(On Diff #95133)

So I would have preferred to use an assert, but this is called by existing code on extended types because the asserts query it.

This check and the asserts can all be removed once the IR type is in place.

[rengolin]

include/llvm/CodeGen/MachineValueType.h

607 ↗

(On Diff #95133)

Right, makes sense.

include/llvm/CodeGen/ValueTypes.h

157 ↗

(On Diff #95133)

I see.

Asserts for unsupported things are known to be ephemeral, but this check isn't. Adding a FIXME with that rationale would make it so, for now.

[huntergr]

Changed 'Min' to unsigned.
Moved text to asserts instead of comments.
Added FIXME to explain why extended scalable vector types aren't handled yet.

[rengolin]

Right, the code looks good now, but I'm worried about tests... We don't seem to have unit tests on this area and I'm not sure how we'd create one (not terribly familiar here).

We could wait to have IR tests, like the rest, when AArch64 uses it... If everyone agrees with it.

[huntergr]

In D32019#730341, @rengolin wrote:

Right, the code looks good now, but I'm worried about tests... We don't seem to have unit tests on this area and I'm not sure how we'd create one (not terribly familiar here).

We could wait to have IR tests, like the rest, when AArch64 uses it... If everyone agrees with it.

It looks like I may be able to test it via C++ code (in llvm/unittests/CodeGen) instead of the usual .ll/.mir/.s tests. I'll try that and see how easy it is.

[huntergr]

Added unit tests via gtest framework.
Changed getHalfNumVectorElementsVT to use 'EltCnt.Min' when determining whether the current vector length is evenly divisible.
Changed iterator names to be more obvious.

[rengolin]

Nice! Thanks Graham! This looks good to me, now.

llvm/trunk/include/llvm/CodeGen/MachineValueType.h

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;
 
+
+    // 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() : SimpleTy(INVALID_SIMPLE_VALUE_TYPE) {}
     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; }
public:
     }
 
     /// Return true if this is a vector value type.
     bool isVector() const {
       return (SimpleTy >= MVT::FIRST_VECTOR_VALUETYPE &&
               SimpleTy <= MVT::LAST_VECTOR_VALUETYPE);
     }
 
+    /// Return true if this is a vector value type where the
+    /// runtime length is machine dependent
+    bool isScalableVector() const {
+      return ((SimpleTy >= MVT::FIRST_INTEGER_SCALABLE_VALUETYPE &&
+               SimpleTy <= MVT::LAST_INTEGER_SCALABLE_VALUETYPE) ||
+              (SimpleTy >= MVT::FIRST_FP_SCALABLE_VALUETYPE &&
+               SimpleTy <= MVT::LAST_FP_SCALABLE_VALUETYPE));
+    }
+
     /// Return true if this is a 16-bit vector type.
     bool is16BitVector() const {
       return (SimpleTy == MVT::v2i8  || SimpleTy == MVT::v1i16 ||
               SimpleTy == MVT::v16i1);
     }
 
     /// Return true if this is a 32-bit vector type.
     bool is32BitVector() const {
unsigned getVectorNumElements() const {
       case nxv1i16:
       case nxv1i32:
       case nxv1i64:
       case nxv1f32:
       case nxv1f64: return 1;
       }
     }
 
+    MVT::ElementCount getVectorElementCount() const {
+      return { getVectorNumElements(), isScalableVector() };
+    }
+
     unsigned getSizeInBits() const {
       switch (SimpleTy) {
       default:
         llvm_unreachable("getSizeInBits called on extended MVT.");
       case Other:
         llvm_unreachable("Value type is non-standard value, Other.");
       case iPTR:
         llvm_unreachable("Value type size is target-dependent. Ask TLI.");
static MVT getVectorVT(MVT VT, unsigned NumElements) {
         if (NumElements == 2)  return MVT::v2f64;
         if (NumElements == 4)  return MVT::v4f64;
         if (NumElements == 8)  return MVT::v8f64;
         break;
       }
       return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE);
     }
 
+    static MVT getScalableVectorVT(MVT VT, unsigned NumElements) {
+      switch(VT.SimpleTy) {
+        default:
+          break;
+        case MVT::i1:
+          if (NumElements == 2)  return MVT::nxv2i1;
+          if (NumElements == 4)  return MVT::nxv4i1;
+          if (NumElements == 8)  return MVT::nxv8i1;
+          if (NumElements == 16) return MVT::nxv16i1;
+          if (NumElements == 32) return MVT::nxv32i1;
+          break;
+        case MVT::i8:
+          if (NumElements == 1)  return MVT::nxv1i8;
+          if (NumElements == 2)  return MVT::nxv2i8;
+          if (NumElements == 4)  return MVT::nxv4i8;
+          if (NumElements == 8)  return MVT::nxv8i8;
+          if (NumElements == 16) return MVT::nxv16i8;
+          if (NumElements == 32) return MVT::nxv32i8;
+          break;
+        case MVT::i16:
+          if (NumElements == 1)  return MVT::nxv1i16;
+          if (NumElements == 2)  return MVT::nxv2i16;
+          if (NumElements == 4)  return MVT::nxv4i16;
+          if (NumElements == 8)  return MVT::nxv8i16;
+          if (NumElements == 16) return MVT::nxv16i16;
+          if (NumElements == 32) return MVT::nxv32i16;
+          break;
+        case MVT::i32:
+          if (NumElements == 1)  return MVT::nxv1i32;
+          if (NumElements == 2)  return MVT::nxv2i32;
+          if (NumElements == 4)  return MVT::nxv4i32;
+          if (NumElements == 8)  return MVT::nxv8i32;
+          if (NumElements == 16) return MVT::nxv16i32;
+          if (NumElements == 32) return MVT::nxv32i32;
+          break;
+        case MVT::i64:
+          if (NumElements == 1)  return MVT::nxv1i64;
+          if (NumElements == 2)  return MVT::nxv2i64;
+          if (NumElements == 4)  return MVT::nxv4i64;
+          if (NumElements == 8)  return MVT::nxv8i64;
+          if (NumElements == 16) return MVT::nxv16i64;
+          if (NumElements == 32) return MVT::nxv32i64;
+          break;
+        case MVT::f16:
+          if (NumElements == 2)  return MVT::nxv2f16;
+          if (NumElements == 4)  return MVT::nxv4f16;
+          if (NumElements == 8)  return MVT::nxv8f16;
+          break;
+        case MVT::f32:
+          if (NumElements == 1)  return MVT::nxv1f32;
+          if (NumElements == 2)  return MVT::nxv2f32;
+          if (NumElements == 4)  return MVT::nxv4f32;
+          if (NumElements == 8)  return MVT::nxv8f32;
+          if (NumElements == 16) return MVT::nxv16f32;
+          break;
+        case MVT::f64:
+          if (NumElements == 1)  return MVT::nxv1f64;
+          if (NumElements == 2)  return MVT::nxv2f64;
+          if (NumElements == 4)  return MVT::nxv4f64;
+          if (NumElements == 8)  return MVT::nxv8f64;
+          break;
+      }
+      return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE);
+    }
+
+    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) {
+      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.
     static MVT getVT(Type *Ty, bool HandleUnknown = false);
 
   private:
     /// A simple iterator over the MVT::SimpleValueType enum.
     struct mvt_iterator {
static mvt_range integer_vector_valuetypes() {
           MVT::FIRST_INTEGER_VECTOR_VALUETYPE,
           (MVT::SimpleValueType)(MVT::LAST_INTEGER_VECTOR_VALUETYPE + 1));
     }
     static mvt_range fp_vector_valuetypes() {
       return mvt_range(
           MVT::FIRST_FP_VECTOR_VALUETYPE,
           (MVT::SimpleValueType)(MVT::LAST_FP_VECTOR_VALUETYPE + 1));
     }
+    static mvt_range integer_scalable_vector_valuetypes() {
+      return mvt_range(MVT::FIRST_INTEGER_SCALABLE_VALUETYPE,
+              (MVT::SimpleValueType)(MVT::LAST_INTEGER_SCALABLE_VALUETYPE + 1));
+    }
+    static mvt_range fp_scalable_vector_valuetypes() {
+      return mvt_range(MVT::FIRST_FP_SCALABLE_VALUETYPE,
+                   (MVT::SimpleValueType)(MVT::LAST_FP_SCALABLE_VALUETYPE + 1));
+    }
     /// @}
   };
 
 } // End llvm namespace
 
 #endif

llvm/trunk/include/llvm/CodeGen/ValueTypes.h

static EVT getIntegerVT(LLVMContext &Context, unsigned BitWidth) {
       MVT M = MVT::getIntegerVT(BitWidth);
       if (M.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE)
         return M;
       return getExtendedIntegerVT(Context, BitWidth);
     }
 
     /// Returns the EVT that represents a vector NumElements in length, where
     /// each element is of type VT.
-    static EVT getVectorVT(LLVMContext &Context, EVT VT, unsigned NumElements) {
-      MVT M = MVT::getVectorVT(VT.V, NumElements);
+    static EVT getVectorVT(LLVMContext &Context, EVT VT, unsigned NumElements,
+                           bool IsScalable = false) {
+      MVT M = MVT::getVectorVT(VT.V, NumElements, IsScalable);
       if (M.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE)
         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) {
+      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
     /// with the element type converted to an integer type with the same
     /// bitwidth.
     EVT changeVectorElementTypeToInteger() const {
-      if (!isSimple())
+      if (!isSimple()) {
+        assert (!isScalableVector() &&
+                "We don't support extended scalable types yet");
         return changeExtendedVectorElementTypeToInteger();
+      }
       MVT EltTy = getSimpleVT().getVectorElementType();
       unsigned BitWidth = EltTy.getSizeInBits();
       MVT IntTy = MVT::getIntegerVT(BitWidth);
-      MVT VecTy = MVT::getVectorVT(IntTy, getVectorNumElements());
-      assert(VecTy.SimpleTy >= 0 &&
+      MVT VecTy = MVT::getVectorVT(IntTy, getVectorNumElements(),
+                                   isScalableVector());
+      assert(VecTy.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE &&
              "Simple vector VT not representable by simple integer vector VT!");
       return VecTy;
     }
 
     /// Return the type converted to an equivalently sized integer or vector
     /// with integer element type. Similar to changeVectorElementTypeToInteger,
     /// but also handles scalars.
     EVT changeTypeToInteger() {
bool isScalarInteger() const {
       return isSimple() ? V.isScalarInteger() : isExtendedScalarInteger();
     }
 
     /// Return true if this is a vector value type.
     bool isVector() const {
       return isSimple() ? V.isVector() : isExtendedVector();
     }
 
+    /// Return true if this is a vector type where the runtime
+    /// length is machine dependent
+    bool isScalableVector() const {
+      // FIXME: We don't support extended scalable types yet, because the
+      // matching IR type doesn't exist. Once it has been added, this can
+      // be changed to call isExtendedScalableVector.
+      if (!isSimple())
+        return false;
+      return V.isScalableVector();
+    }
+
     /// Return true if this is a 16-bit vector type.
     bool is16BitVector() const {
       return isSimple() ? V.is16BitVector() : isExtended16BitVector();
     }
 
     /// Return true if this is a 32-bit vector type.
     bool is32BitVector() const {
       return isSimple() ? V.is32BitVector() : isExtended32BitVector();
public:
     /// Given a vector type, return the number of elements it contains.
     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 {
+      assert((isVector()) && "Invalid vector type!");
+      if (isSimple())
+        return V.getVectorElementCount();
+
+      assert(!isScalableVector() &&
+             "We don't support extended scalable types yet");
+      return {getExtendedVectorNumElements(), false};
+    }
+
     /// Return the size of the specified value type in bits.
     unsigned getSizeInBits() const {
       if (isSimple())
         return V.getSizeInBits();
       return getExtendedSizeInBits();
     }
 
     unsigned getScalarSizeInBits() const {
EVT getHalfSizedIntegerVT(LLVMContext &Context) const {
       return getIntegerVT(Context, (EVTSize + 1) / 2);
     }
 
     /// Return a VT for an integer vector type with the size of the
     /// elements doubled. The typed returned may be an extended type.
     EVT widenIntegerVectorElementType(LLVMContext &Context) const {
       EVT EltVT = getVectorElementType();
       EltVT = EVT::getIntegerVT(Context, 2 * EltVT.getSizeInBits());
-      return EVT::getVectorVT(Context, EltVT, getVectorNumElements());
+      return EVT::getVectorVT(Context, EltVT, getVectorElementCount());
     }
 
     // Return a VT for a vector type with the same element type but
     // half the number of elements. The type returned may be an
     // extended type.
     EVT getHalfNumVectorElementsVT(LLVMContext &Context) const {
       EVT EltVT = getVectorElementType();
-      auto EltCnt = getVectorNumElements();
-      assert(!(getVectorNumElements() & 1) &&
-             "Splitting vector, but not in half!");
+      auto EltCnt = getVectorElementCount();
+      assert(!(EltCnt.Min & 1) && "Splitting vector, but not in half!");
       return EVT::getVectorVT(Context, EltVT, EltCnt / 2);
     }
 
     /// Returns true if the given vector is a power of 2.
     bool isPow2VectorType() const {
       unsigned NElts = getVectorNumElements();
       return !(NElts & (NElts - 1));
     }
 
     /// Widens the length of the given vector EVT up to the nearest power of 2
     /// and returns that type.
     EVT getPow2VectorType(LLVMContext &Context) const {
       if (!isPow2VectorType()) {
         unsigned NElts = getVectorNumElements();
         unsigned Pow2NElts = 1 <<  Log2_32_Ceil(NElts);
-        return EVT::getVectorVT(Context, getVectorElementType(), Pow2NElts);
+        return EVT::getVectorVT(Context, getVectorElementType(), Pow2NElts,
+                                isScalableVector());
       }
       else {
         return *this;
       }
     }
 
     /// This function returns value type as a string, e.g. "i32".
     std::string getEVTString() const;

llvm/trunk/lib/CodeGen/SelectionDAG/LegalizeTypes.cpp

return DAG.getNode(ISD::BITCAST, SDLoc(Op),
                      EVT::getIntegerVT(*DAG.getContext(), BitWidth), Op);
 }
 
 /// Convert to a vector of integers of the same size.
 SDValue DAGTypeLegalizer::BitConvertVectorToIntegerVector(SDValue Op) {
   assert(Op.getValueType().isVector() && "Only applies to vectors!");
   unsigned EltWidth = Op.getScalarValueSizeInBits();
   EVT EltNVT = EVT::getIntegerVT(*DAG.getContext(), EltWidth);
-  unsigned NumElts = Op.getValueType().getVectorNumElements();
+  auto EltCnt = Op.getValueType().getVectorElementCount();
   return DAG.getNode(ISD::BITCAST, SDLoc(Op),
-                     EVT::getVectorVT(*DAG.getContext(), EltNVT, NumElts), Op);
+                     EVT::getVectorVT(*DAG.getContext(), EltNVT, EltCnt), Op);
 }
 
 SDValue DAGTypeLegalizer::CreateStackStoreLoad(SDValue Op,
                                                EVT DestVT) {
   SDLoc dl(Op);
   // Create the stack frame object.  Make sure it is aligned for both
   // the source and destination types.
   SDValue StackPtr = DAG.CreateStackTemporary(Op.getValueType(), DestVT);

llvm/trunk/unittests/CodeGen/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   AsmPrinter
   CodeGen
   Core
   Support
   )
 
 set(CodeGenSources
   DIEHashTest.cpp
   LowLevelTypeTest.cpp
   MachineInstrBundleIteratorTest.cpp
+  ScalableVectorMVTsTest.cpp
   )
 
 add_llvm_unittest(CodeGenTests
   ${CodeGenSources}
   )
 
 add_subdirectory(GlobalISel)

llvm/trunk/unittests/CodeGen/ScalableVectorMVTsTest.cpp

+//===-------- llvm/unittest/CodeGen/ScalableVectorMVTsTest.cpp ------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/CodeGen/MachineValueType.h"
+#include "llvm/CodeGen/ValueTypes.h"
+#include "llvm/IR/LLVMContext.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+
+namespace {
+
+TEST(ScalableVectorMVTsTest, IntegerMVTs) {
+  for (auto VecTy : MVT::integer_scalable_vector_valuetypes()) {
+    ASSERT_TRUE(VecTy.isValid());
+    ASSERT_TRUE(VecTy.isInteger());
+    ASSERT_TRUE(VecTy.isVector());
+    ASSERT_TRUE(VecTy.isScalableVector());
+    ASSERT_TRUE(VecTy.getScalarType().isValid());
+
+    ASSERT_FALSE(VecTy.isFloatingPoint());
+  }
+}
+
+TEST(ScalableVectorMVTsTest, FloatMVTs) {
+  for (auto VecTy : MVT::fp_scalable_vector_valuetypes()) {
+    ASSERT_TRUE(VecTy.isValid());
+    ASSERT_TRUE(VecTy.isFloatingPoint());
+    ASSERT_TRUE(VecTy.isVector());
+    ASSERT_TRUE(VecTy.isScalableVector());
+    ASSERT_TRUE(VecTy.getScalarType().isValid());
+
+    ASSERT_FALSE(VecTy.isInteger());
+  }
+}
+
+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);
+  EVT Vnx2i32 = EVT::getVectorVT(Ctx, MVT::i32, EltCnt);
+  ASSERT_TRUE(Vnx2i32.isScalableVector());
+
+  // Create with inline MVT::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
+  EltCnt = Vnx4i32.getVectorElementCount();
+  EXPECT_EQ(EltCnt.Min, 4);
+  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.
+  EltCnt = V8i32.getVectorElementCount();
+  EXPECT_EQ(EltCnt.Min, 8);
+  ASSERT_FALSE(EltCnt.Scalable);
+}
+
+}