[NFC] Change VFShape so it contains an ElementCount rather than seperate VF and IsScalable properties.

[sdesmalen]

Nice cleanup, LGTM

llvm/include/llvm/Analysis/VectorUtils.h

 
 /// Contains the information about the kind of vectorization
 /// available.
 ///
 /// This object in independent on the paradigm used to
 /// represent vector functions. in particular, it is not attached to
 /// any target-specific ABI.
 struct VFShape {
-  unsigned VF;     // Vectorization factor.
-  bool IsScalable; // True if the function is a scalable function.
+  ElementCount VF;                        // Vectorization factor.
   SmallVector<VFParameter, 8> Parameters; // List of parameter information.
   // Comparison operator.
   bool operator==(const VFShape &Other) const {
-    return std::tie(VF, IsScalable, Parameters) ==
-           std::tie(Other.VF, Other.IsScalable, Other.Parameters);
+    return std::tie(VF, Parameters) == std::tie(Other.VF, Other.Parameters);
   }
 
   /// Update the parameter in position P.ParamPos to P.
   void updateParam(VFParameter P) {
     assert(P.ParamPos < Parameters.size() && "Invalid parameter position.");
     Parameters[P.ParamPos] = P;
     assert(hasValidParameterList() && "Invalid parameter list");
   }
struct VFShape {
   static VFShape get(const CallInst &CI, ElementCount EC, bool HasGlobalPred) {
     SmallVector<VFParameter, 8> Parameters;
     for (unsigned I = 0; I < CI.arg_size(); ++I)
       Parameters.push_back(VFParameter({I, VFParamKind::Vector}));
     if (HasGlobalPred)
       Parameters.push_back(
           VFParameter({CI.arg_size(), VFParamKind::GlobalPredicate}));
 
-    return {EC.getKnownMinValue(), EC.isScalable(), Parameters};
+    return {EC, Parameters};
   }
   /// Sanity check on the Parameters in the VFShape.
   bool hasValidParameterList() const;
 };
 
 /// Holds the VFShape for a specific scalar to vector function mapping.
 struct VFInfo {
   VFShape Shape;          /// Classification of the vector function.

llvm/lib/Analysis/VFABIDemangling.cpp

Optional<VFInfo> VFABI::tryDemangleForVFABI(StringRef MangledName,
   // 1. We don't accept a zero lanes vectorization factor.
   // 2. We don't accept the demangling if the vector function is not
   // present in the module.
   if (VF == 0)
     return None;
   if (!M.getFunction(VectorName))
     return None;
 
-  const VFShape Shape({VF, IsScalable, Parameters});
+  const VFShape Shape({ElementCount::get(VF, IsScalable), Parameters});
   return VFInfo({Shape, std::string(ScalarName), std::string(VectorName), ISA});
 }
 
 VFParamKind VFABI::getVFParamKindFromString(const StringRef Token) {
   const VFParamKind ParamKind = StringSwitch<VFParamKind>(Token)
                                     .Case("v", VFParamKind::Vector)
                                     .Case("l", VFParamKind::OMP_Linear)
                                     .Case("R", VFParamKind::OMP_LinearRef)

llvm/unittests/Analysis/VectorFunctionABITest.cpp

private:
 
   // Data needed to load the optional IR passed to invokeParser
   LLVMContext Ctx;
   SMDiagnostic Err;
   std::unique_ptr<Module> M;
   //  CallInst *CI;
 protected:
   // Referencies to the parser output field.
-  unsigned &VF = Info.Shape.VF;
+  ElementCount &VF = Info.Shape.VF;
   VFISAKind &ISA = Info.ISA;
   SmallVector<VFParameter, 8> &Parameters = Info.Shape.Parameters;
   std::string &ScalarName = Info.ScalarName;
   std::string &VectorName = Info.VectorName;
-  bool &IsScalable = Info.Shape.IsScalable;
   // Invoke the parser. We need to make sure that a function exist in
   // the module because the parser fails if such function don't
   // exists. Every time this method is invoked the state of the test
   // is reset.
   //
   // \p MangledName -> the string the parser has to demangle.
   //
   // \p VectorName -> optional vector name that the method needs to

 TEST_F(VFABIParserTest, ScalarNameAndVectorName_03) {
   EXPECT_TRUE(invokeParser("_ZGVnM2v___sin_sin_sin"));
   EXPECT_EQ(ScalarName, "__sin_sin_sin");
   EXPECT_EQ(VectorName, "_ZGVnM2v___sin_sin_sin");
 }
 
 TEST_F(VFABIParserTest, Parse) {
   EXPECT_TRUE(invokeParser("_ZGVnN2vls2Ls27Us4Rs5l1L10U100R1000_sin"));
-  EXPECT_EQ(VF, (unsigned)2);
+  EXPECT_EQ(VF, ElementCount::getFixed(2));
   EXPECT_FALSE(IsMasked());
   EXPECT_EQ(ISA, VFISAKind::AdvancedSIMD);
-  EXPECT_FALSE(IsScalable);
   EXPECT_EQ(Parameters.size(), (unsigned)9);
   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector, 0}));
   EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::OMP_LinearPos, 2}));
   EXPECT_EQ(Parameters[2], VFParameter({2, VFParamKind::OMP_LinearValPos, 27}));
   EXPECT_EQ(Parameters[3], VFParameter({3, VFParamKind::OMP_LinearUValPos, 4}));
   EXPECT_EQ(Parameters[4], VFParameter({4, VFParamKind::OMP_LinearRefPos, 5}));
   EXPECT_EQ(Parameters[5], VFParameter({5, VFParamKind::OMP_Linear, 1}));
   EXPECT_EQ(Parameters[6], VFParameter({6, VFParamKind::OMP_LinearVal, 10}));
   EXPECT_EQ(Parameters[7], VFParameter({7, VFParamKind::OMP_LinearUVal, 100}));
   EXPECT_EQ(Parameters[8], VFParameter({8, VFParamKind::OMP_LinearRef, 1000}));
   EXPECT_EQ(ScalarName, "sin");
   EXPECT_EQ(VectorName, "_ZGVnN2vls2Ls27Us4Rs5l1L10U100R1000_sin");
 }
 
 TEST_F(VFABIParserTest, ParseVectorName) {
   EXPECT_TRUE(invokeParser("_ZGVnN2v_sin(my_v_sin)", "my_v_sin"));
-  EXPECT_EQ(VF, (unsigned)2);
+  EXPECT_EQ(VF, ElementCount::getFixed(2));
   EXPECT_FALSE(IsMasked());
-  EXPECT_FALSE(IsScalable);
   EXPECT_EQ(ISA, VFISAKind::AdvancedSIMD);
   EXPECT_EQ(Parameters.size(), (unsigned)1);
   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector, 0}));
   EXPECT_EQ(ScalarName, "sin");
   EXPECT_EQ(VectorName, "my_v_sin");
 }
 
 TEST_F(VFABIParserTest, LinearWithCompileTimeNegativeStep) {
   EXPECT_TRUE(invokeParser("_ZGVnN2ln1Ln10Un100Rn1000_sin"));
-  EXPECT_EQ(VF, (unsigned)2);
+  EXPECT_EQ(VF, ElementCount::getFixed(2));
   EXPECT_FALSE(IsMasked());
   EXPECT_EQ(ISA, VFISAKind::AdvancedSIMD);
-  EXPECT_FALSE(IsScalable);
   EXPECT_EQ(Parameters.size(), (unsigned)4);
   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::OMP_Linear, -1}));
   EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::OMP_LinearVal, -10}));
   EXPECT_EQ(Parameters[2], VFParameter({2, VFParamKind::OMP_LinearUVal, -100}));
   EXPECT_EQ(Parameters[3], VFParameter({3, VFParamKind::OMP_LinearRef, -1000}));
   EXPECT_EQ(ScalarName, "sin");
   EXPECT_EQ(VectorName, "_ZGVnN2ln1Ln10Un100Rn1000_sin");
 }
 
 TEST_F(VFABIParserTest, ParseScalableSVE) {
   EXPECT_TRUE(invokeParser(
       "_ZGVsMxv_sin(custom_vg)", "custom_vg",
       "<vscale x 2 x i32>(<vscale x 2 x i32>, <vscale x 2 x i1>)"));
-  EXPECT_EQ(VF, (unsigned)2);
+  EXPECT_EQ(VF, ElementCount::getScalable(2));
   EXPECT_TRUE(IsMasked());
-  EXPECT_TRUE(IsScalable);
   EXPECT_EQ(ISA, VFISAKind::SVE);
   EXPECT_EQ(ScalarName, "sin");
   EXPECT_EQ(VectorName, "custom_vg");
 }
 
 TEST_F(VFABIParserTest, ParseFixedWidthSVE) {
   EXPECT_TRUE(invokeParser("_ZGVsM2v_sin"));
-  EXPECT_EQ(VF, (unsigned)2);
+  EXPECT_EQ(VF, ElementCount::getFixed(2));
   EXPECT_TRUE(IsMasked());
-  EXPECT_FALSE(IsScalable);
   EXPECT_EQ(ISA, VFISAKind::SVE);
   EXPECT_EQ(ScalarName, "sin");
   EXPECT_EQ(VectorName, "_ZGVsM2v_sin");
 }
 
 TEST_F(VFABIParserTest, NotAVectorFunctionABIName) {
   // Vector names should start with `_ZGV`.
   EXPECT_FALSE(invokeParser("ZGVnN2v_sin"));
TEST_F(VFABIParserTest, Align) {
   EXPECT_FALSE(invokeParser("_ZGVsN2l2a0_sin"));
   EXPECT_TRUE(invokeParser("_ZGVsN2l2a1_sin"));
   EXPECT_FALSE(invokeParser("_ZGVsN2l2a3_sin"));
   EXPECT_FALSE(invokeParser("_ZGVsN2l2a6_sin"));
 }
 
 TEST_F(VFABIParserTest, ParseUniform) {
   EXPECT_TRUE(invokeParser("_ZGVnN2u_sin"));
-  EXPECT_EQ(VF, (unsigned)2);
+  EXPECT_EQ(VF, ElementCount::getFixed(2));
   EXPECT_FALSE(IsMasked());
   EXPECT_EQ(ISA, VFISAKind::AdvancedSIMD);
-  EXPECT_FALSE(IsScalable);
   EXPECT_EQ(Parameters.size(), (unsigned)1);
   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::OMP_Uniform, 0}));
   EXPECT_EQ(ScalarName, "sin");
   EXPECT_EQ(VectorName, "_ZGVnN2u_sin");
 
   // Uniform doesn't expect extra data.
   EXPECT_FALSE(invokeParser("_ZGVnN2u0_sin"));
 }
const SmallVector<VFParameter, 8> ExpectedParams = {
       VFParameter({6, VFParamKind::OMP_LinearVal, 10}),
       VFParameter({7, VFParamKind::OMP_LinearUVal, 100}),
       VFParameter({8, VFParamKind::OMP_LinearRef, 1000}),
       VFParameter({9, VFParamKind::OMP_Uniform, 0}),
   };
 
 #define __COMMON_CHECKS                                                        \
   do {                                                                         \
-    EXPECT_EQ(VF, (unsigned)2);                                                \
+    EXPECT_EQ(VF, ElementCount::getFixed(2));                                  \
     EXPECT_FALSE(IsMasked());                                                  \
-    EXPECT_FALSE(IsScalable);                                                  \
     EXPECT_EQ(Parameters.size(), (unsigned)10);                                \
     EXPECT_EQ(Parameters, ExpectedParams);                                     \
     EXPECT_EQ(ScalarName, "sin");                                              \
   } while (0)
 
   // Advanced SIMD: <isa> = "n"
   EXPECT_TRUE(invokeParser("_ZGVnN2vls2Ls27Us4Rs5l1L10U100R1000u_sin"));
   EXPECT_EQ(ISA, VFISAKind::AdvancedSIMD);

 }
 
 TEST_F(VFABIParserTest, MissingVectorNameTermination) {
   EXPECT_FALSE(invokeParser("_ZGVnN2v_foo(bar"));
 }
 
 TEST_F(VFABIParserTest, ParseMaskingNEON) {
   EXPECT_TRUE(invokeParser("_ZGVnM2v_sin"));
-  EXPECT_EQ(VF, (unsigned)2);
+  EXPECT_EQ(VF, ElementCount::getFixed(2));
   EXPECT_TRUE(IsMasked());
-  EXPECT_FALSE(IsScalable);
   EXPECT_EQ(ISA, VFISAKind::AdvancedSIMD);
   EXPECT_EQ(Parameters.size(), (unsigned)2);
   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector}));
   EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::GlobalPredicate}));
   EXPECT_EQ(ScalarName, "sin");
 }
 
 TEST_F(VFABIParserTest, ParseMaskingSVE) {
   EXPECT_TRUE(invokeParser("_ZGVsM2v_sin"));
-  EXPECT_EQ(VF, (unsigned)2);
+  EXPECT_EQ(VF, ElementCount::getFixed(2));
   EXPECT_TRUE(IsMasked());
-  EXPECT_FALSE(IsScalable);
   EXPECT_EQ(ISA, VFISAKind::SVE);
   EXPECT_EQ(Parameters.size(), (unsigned)2);
   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector}));
   EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::GlobalPredicate}));
   EXPECT_EQ(ScalarName, "sin");
 }
 
 TEST_F(VFABIParserTest, ParseMaskingSSE) {
   EXPECT_TRUE(invokeParser("_ZGVbM2v_sin"));
-  EXPECT_EQ(VF, (unsigned)2);
+  EXPECT_EQ(VF, ElementCount::getFixed(2));
   EXPECT_TRUE(IsMasked());
-  EXPECT_FALSE(IsScalable);
   EXPECT_EQ(ISA, VFISAKind::SSE);
   EXPECT_EQ(Parameters.size(), (unsigned)2);
   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector}));
   EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::GlobalPredicate}));
   EXPECT_EQ(ScalarName, "sin");
 }
 
 TEST_F(VFABIParserTest, ParseMaskingAVX) {
   EXPECT_TRUE(invokeParser("_ZGVcM2v_sin"));
-  EXPECT_EQ(VF, (unsigned)2);
+  EXPECT_EQ(VF, ElementCount::getFixed(2));
   EXPECT_TRUE(IsMasked());
-  EXPECT_FALSE(IsScalable);
   EXPECT_EQ(ISA, VFISAKind::AVX);
   EXPECT_EQ(Parameters.size(), (unsigned)2);
   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector}));
   EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::GlobalPredicate}));
   EXPECT_EQ(ScalarName, "sin");
 }
 
 TEST_F(VFABIParserTest, ParseMaskingAVX2) {
   EXPECT_TRUE(invokeParser("_ZGVdM2v_sin"));
-  EXPECT_EQ(VF, (unsigned)2);
+  EXPECT_EQ(VF, ElementCount::getFixed(2));
   EXPECT_TRUE(IsMasked());
-  EXPECT_FALSE(IsScalable);
   EXPECT_EQ(ISA, VFISAKind::AVX2);
   EXPECT_EQ(Parameters.size(), (unsigned)2);
   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector}));
   EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::GlobalPredicate}));
   EXPECT_EQ(ScalarName, "sin");
 }
 
 TEST_F(VFABIParserTest, ParseMaskingAVX512) {
   EXPECT_TRUE(invokeParser("_ZGVeM2v_sin"));
-  EXPECT_EQ(VF, (unsigned)2);
+  EXPECT_EQ(VF, ElementCount::getFixed(2));
   EXPECT_TRUE(IsMasked());
-  EXPECT_FALSE(IsScalable);
   EXPECT_EQ(ISA, VFISAKind::AVX512);
   EXPECT_EQ(Parameters.size(), (unsigned)2);
   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector}));
   EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::GlobalPredicate}));
   EXPECT_EQ(ScalarName, "sin");
 }
 
 TEST_F(VFABIParserTest, ParseMaskingLLVM) {
   EXPECT_TRUE(invokeParser("_ZGV_LLVM_M2v_sin(custom_vector_sin)",
                            "custom_vector_sin"));
-  EXPECT_EQ(VF, (unsigned)2);
+  EXPECT_EQ(VF, ElementCount::getFixed(2));
   EXPECT_TRUE(IsMasked());
-  EXPECT_FALSE(IsScalable);
   EXPECT_EQ(ISA, VFISAKind::LLVM);
   EXPECT_EQ(Parameters.size(), (unsigned)2);
   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector}));
   EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::GlobalPredicate}));
   EXPECT_EQ(ScalarName, "sin");
   EXPECT_EQ(VectorName, "custom_vector_sin");
 }
 
 TEST_F(VFABIParserTest, ParseScalableMaskingLLVM) {
   EXPECT_TRUE(invokeParser(
       "_ZGV_LLVM_Mxv_sin(custom_vector_sin)", "custom_vector_sin",
       "<vscale x 2 x i32> (<vscale x 2 x i32>, <vscale x 2 x i1>)"));
   EXPECT_TRUE(IsMasked());
-  EXPECT_EQ(VF, (unsigned)2);
-  EXPECT_TRUE(IsScalable);
+  EXPECT_EQ(VF, ElementCount::getScalable(2));
   EXPECT_EQ(ISA, VFISAKind::LLVM);
   EXPECT_EQ(Parameters.size(), (unsigned)2);
   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector}));
   EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::GlobalPredicate}));
   EXPECT_EQ(ScalarName, "sin");
   EXPECT_EQ(VectorName, "custom_vector_sin");
 }
 
 TEST_F(VFABIParserTest, ParseScalableMaskingLLVMSincos) {
   EXPECT_TRUE(invokeParser("_ZGV_LLVM_Mxvl8l8_sincos(custom_vector_sincos)",
                            "custom_vector_sincos",
                            "void(<vscale x 2 x double>, double *, double *)"));
-  EXPECT_EQ(VF, (unsigned)2);
+  EXPECT_EQ(VF, ElementCount::getScalable(2));
   EXPECT_TRUE(IsMasked());
-  EXPECT_TRUE(IsScalable);
   EXPECT_EQ(ISA, VFISAKind::LLVM);
   EXPECT_EQ(Parameters.size(), (unsigned)4);
   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector}));
   EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::OMP_Linear, 8}));
   EXPECT_EQ(Parameters[2], VFParameter({2, VFParamKind::OMP_Linear, 8}));
   EXPECT_EQ(Parameters[3], VFParameter({3, VFParamKind::GlobalPredicate}));
   EXPECT_EQ(ScalarName, "sincos");
   EXPECT_EQ(VectorName, "custom_vector_sincos");
TEST_F(VFABIParserTest, LLVM_InternalISA) {
   EXPECT_FALSE(invokeParser("_ZGV_LLVM_N2v_sin"));
   EXPECT_TRUE(invokeParser("_ZGV_LLVM_N2v_sin_(vector_name)", "vector_name"));
   EXPECT_EQ(ISA, VFISAKind::LLVM);
 }
 
 TEST_F(VFABIParserTest, IntrinsicsInLLVMIsa) {
   EXPECT_TRUE(invokeParser("_ZGV_LLVM_N4vv_llvm.pow.f32(__svml_powf4)",
                            "__svml_powf4"));
-  EXPECT_EQ(VF, (unsigned)4);
+  EXPECT_EQ(VF, ElementCount::getFixed(4));
   EXPECT_FALSE(IsMasked());
-  EXPECT_FALSE(IsScalable);
   EXPECT_EQ(ISA, VFISAKind::LLVM);
   EXPECT_EQ(Parameters.size(), (unsigned)2);
   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector}));
   EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::Vector}));
   EXPECT_EQ(ScalarName, "llvm.pow.f32");
 }
 
 TEST_F(VFABIParserTest, ParseScalableRequiresDeclaration) {

llvm/unittests/Analysis/VectorUtilsTest.cpp

const char *IR = "define i32 @f(i32 %a, i64 %b, double %c) {\n"
                    "  ret i32 %1\n"
                    "}\n"
                    "declare i32 @g(i32, i64, double)\n";
   LLVMContext Ctx;
   SMDiagnostic Err;
   std::unique_ptr<Module> M;
   CallInst *CI;
   // Dummy shape with no parameters, overwritten by buildShape when invoked.
-  VFShape Shape = {/*VF*/ 2, /*IsScalable*/ false, /*Parameters*/ {}};
+  VFShape Shape = {/*VF*/ ElementCount::getFixed(2), /*Parameters*/ {}};
   VFShape Expected;
   SmallVector<VFParameter, 8> &ExpectedParams = Expected.Parameters;
 
-  void buildShape(unsigned VF, bool IsScalable, bool HasGlobalPred) {
-    Shape = VFShape::get(*CI, ElementCount::get(VF, IsScalable), HasGlobalPred);
+  void buildShape(ElementCount VF, bool HasGlobalPred) {
+    Shape = VFShape::get(*CI, VF, HasGlobalPred);
   }
 
   bool validParams(ArrayRef<VFParameter> Parameters) {
     Shape.Parameters =
         SmallVector<VFParameter, 8>(Parameters.begin(), Parameters.end());
     return Shape.hasValidParameterList();
   }
 };
 
 TEST_F(VFShapeAPITest, API_buildVFShape) {
-  buildShape(/*VF*/ 2, /*IsScalable*/ false, /*HasGlobalPred*/ false);
-  Expected = {/*VF*/ 2, /*IsScalable*/ false, /*Parameters*/ {
+  buildShape(/*VF*/ ElementCount::getFixed(2), /*HasGlobalPred*/ false);
+  Expected = {/*VF*/ ElementCount::getFixed(2), /*Parameters*/ {
                   {0, VFParamKind::Vector},
                   {1, VFParamKind::Vector},
                   {2, VFParamKind::Vector},
               }};
   EXPECT_EQ(Shape, Expected);
 
-  buildShape(/*VF*/ 4, /*IsScalable*/ false, /*HasGlobalPred*/ true);
-  Expected = {/*VF*/ 4, /*IsScalable*/ false, /*Parameters*/ {
+  buildShape(/*VF*/ ElementCount::getFixed(4), /*HasGlobalPred*/ true);
+  Expected = {/*VF*/ ElementCount::getFixed(4), /*Parameters*/ {
                   {0, VFParamKind::Vector},
                   {1, VFParamKind::Vector},
                   {2, VFParamKind::Vector},
                   {3, VFParamKind::GlobalPredicate},
               }};
   EXPECT_EQ(Shape, Expected);
 
-  buildShape(/*VF*/ 16, /*IsScalable*/ true, /*HasGlobalPred*/ false);
-  Expected = {/*VF*/ 16, /*IsScalable*/ true, /*Parameters*/ {
+  buildShape(/*VF*/ ElementCount::getScalable(16), /*HasGlobalPred*/ false);
+  Expected = {/*VF*/ ElementCount::getScalable(16), /*Parameters*/ {
                   {0, VFParamKind::Vector},
                   {1, VFParamKind::Vector},
                   {2, VFParamKind::Vector},
               }};
   EXPECT_EQ(Shape, Expected);
 }
 
 TEST_F(VFShapeAPITest, API_getScalarShape) {
-  buildShape(/*VF*/ 1, /*IsScalable*/ false, /*HasGlobalPred*/ false);
+  buildShape(/*VF*/ ElementCount::getFixed(1), /*HasGlobalPred*/ false);
   EXPECT_EQ(VFShape::getScalarShape(*CI), Shape);
 }
 
 TEST_F(VFShapeAPITest, API_getVectorizedFunction) {
   VFShape ScalarShape = VFShape::getScalarShape(*CI);
   EXPECT_EQ(VFDatabase(*CI).getVectorizedFunction(ScalarShape),
             M->getFunction("g"));
 
-  buildShape(/*VF*/ 1, /*IsScalable*/ true, /*HasGlobalPred*/ false);
+  buildShape(/*VF*/ ElementCount::getScalable(1), /*HasGlobalPred*/ false);
   EXPECT_EQ(VFDatabase(*CI).getVectorizedFunction(Shape), nullptr);
-  buildShape(/*VF*/ 1, /*IsScalable*/ false, /*HasGlobalPred*/ true);
+  buildShape(/*VF*/ ElementCount::getFixed(1), /*HasGlobalPred*/ true);
   EXPECT_EQ(VFDatabase(*CI).getVectorizedFunction(Shape), nullptr);
-  buildShape(/*VF*/ 1, /*IsScalable*/ true, /*HasGlobalPred*/ true);
+  buildShape(/*VF*/ ElementCount::getScalable(1), /*HasGlobalPred*/ true);
   EXPECT_EQ(VFDatabase(*CI).getVectorizedFunction(Shape), nullptr);
 }
 
 TEST_F(VFShapeAPITest, API_updateVFShape) {
 
-  buildShape(/*VF*/ 2, /*IsScalable*/ false, /*HasGlobalPred*/ false);
+  buildShape(/*VF*/ ElementCount::getFixed(2), /*HasGlobalPred*/ false);
   Shape.updateParam({0 /*Pos*/, VFParamKind::OMP_Linear, 1, Align(4)});
-  Expected = {/*VF*/ 2, /*IsScalable*/ false, /*Parameters*/ {
+  Expected = {/*VF*/ ElementCount::getFixed(2), /*Parameters*/ {
                   {0, VFParamKind::OMP_Linear, 1, Align(4)},
                   {1, VFParamKind::Vector},
                   {2, VFParamKind::Vector},
               }};
   EXPECT_EQ(Shape, Expected);
 
   // From this point on, we update only the parameters of the VFShape,
   // so we update only the reference of the expected Parameters.
ExpectedParams = {
       {1, VFParamKind::OMP_Uniform},
       {2, VFParamKind::OMP_LinearRefPos, 1},
   };
   EXPECT_EQ(Shape, Expected);
 }
 
 TEST_F(VFShapeAPITest, API_updateVFShape_GlobalPredicate) {
 
-  buildShape(/*VF*/ 2, /*IsScalable*/ true, /*HasGlobalPred*/ true);
+  buildShape(/*VF*/ ElementCount::getScalable(2), /*HasGlobalPred*/ true);
   Shape.updateParam({1 /*Pos*/, VFParamKind::OMP_Uniform});
-  Expected = {/*VF*/ 2, /*IsScalable*/ true,
+  Expected = {/*VF*/ ElementCount::getScalable(2),
               /*Parameters*/ {{0, VFParamKind::Vector},
                               {1, VFParamKind::OMP_Uniform},
                               {2, VFParamKind::Vector},
                               {3, VFParamKind::GlobalPredicate}}};
   EXPECT_EQ(Shape, Expected);
 }
 
 TEST_F(VFShapeAPITest, Parameters_Valid) {