[NFC] Vastly simplifies TypeSize

[gchatelet]

Summary

Simplifies the implementation of TypeSize while retaining its interface.
There is no need for abstract concepts like LinearPolyBase, UnivariateLinearPolyBase or LinearPolySize.

[barannikov88]

I like this patch as now I almost understand what these three classes are. But please see the comments.

llvm/include/llvm/Support/TypeSize.h

87

Would it be better to move the below comments to the derived classes? It is not immediately clear that the arrows represent relationship between classes.

105

LHS and RHS (all capital) seems canonical abbreviation (892 occurences of LHS, 16 occurences of Lhs in CodeGen). Retaining the names would also make the diff smaller and make it a lot easier to review.

142

Personally, this looks redundant to me (saving a few characters?).

145–146

univariate dimension --> fixed quantity?

[gchatelet]

• Make Rhs/Lhe uppercase

[gchatelet]

• Remove tie and reword description

[gchatelet]

Thx @barannikov88 for the comments. This patch is mostly to better understand what purpose TypeSize serves.
I'm trying to add a set of useful basic types D128052 and ElementCount / TypeSize will probably be tied to one of these at some point.

llvm/include/llvm/Support/TypeSize.h

145–146

Reworded it MinValue since this is what it is.

[barannikov88]

Mostly fine by me, but I think the initial author should take a look.

llvm/include/llvm/Support/TypeSize.h

102–104

Here, and in the method below, the error message is outdated.

145–146

Thanks. However, MinValue is an implementation detail that should not be exposed even in comments.

166–167

This class is no longer "size", it is now "quantity". Either the comments should be fixed, or the class name.

[barannikov88]

llvm/include/llvm/Support/TypeSize.h

92

Looks redundant.

[courbet]

llvm/include/llvm/Support/TypeSize.h

42

Given that this is not a template over its unit, I think the doc should explicitly mention that the unit is bytes.

91–92

This is now abstractly named ("Quantity"), but the documentation still refers to "size".

92

Update doc

141–144

Let's take this opportunity to document this non-obvious bool operator.

[gchatelet]

llvm/include/llvm/Support/TypeSize.h

145–146

Thanks. However, MinValue is an implementation detail that should not be exposed even in comments.

Is that true ? I'm under the impression that this is what it was intended for in the original patch
https://github.com/llvm/llvm-project/commit/b302561b763a1d2eb1a450e135b8d49931936755

* Adds a TypeSize struct to represent the known minimum size of a type
  along with a flag to indicate that the runtime size is a integer multiple
  of that size

[gchatelet]

llvm/include/llvm/Support/TypeSize.h

145–146

Let me rephrase "yes you're right that this is an implementation detail and it shouldn't be exposed but in that particular case it seems to be the exact semantic for the type".
I think it's better to update the documentation to reflect what was in the original comment. WDYT?

[barannikov88]

llvm/include/llvm/Support/TypeSize.h

145–146

Sorry for not being clear clear.
I meant that "MinValue" (spelled exactly) is a private field, which users of the class should not care about. "Minimum value", e.g., is different.
Since this class is now abstract, I'd avoid using "Min" in variable name and "Minimum" in the comment.
Finally, I'd remove this method and add operator+ instead :) There is an (outdated?) comment near divideCoefficientBy that suggests of not doing it though.

[gchatelet]

llvm/include/llvm/Support/TypeSize.h

42

I've reworded. Let me know if it's better.

145–146

Sorry for not being clear clear.
I meant that "MinValue" (spelled exactly) is a private field, which users of the class should not care about. "Minimum value", e.g., is different.
Since this class is now abstract, I'd avoid using "Min" in variable name and "Minimum" in the comment.

Sounds good to me, I went over the file and tried to use appropriate variable names where possible.

Finally, I'd remove this method and add operator+ instead :) There is an (outdated?) comment near divideCoefficientBy that suggests of not doing it though.

I think the comment refers to the class hierarchy that was in use before this patch.
I don't think there is a need for it anymore. It seems clear enough to me what the classical operators would mean for ElementCount and TypeSize without using the long names.

That said, and if you don't mind I'd rather do this in a second patch and keep this one NFC. There's already quite a few things going on.

[gchatelet]

• Address comments

[gchatelet]

• rephrased comment

[gchatelet]

• rebase and mark most functions/ctors constexpr

[gchatelet]

Ready for another round of comments if needed

[gchatelet]

rebase

[gchatelet]

Adding the original author (@sdesmalen) to try to understand the purpose of these abstractions.
The original patch (https://reviews.llvm.org/D88982) does not give any insight into why this is helpful.

[lebedev.ri]

In D140263#4023220, @gchatelet wrote:

Adding the original author (@sdesmalen) to try to understand the purpose of these abstractions.
The original patch (https://reviews.llvm.org/D88982) does not give any insight into why this is helpful.

(i personally suspect it was a part of series(?) to support spills to stack of scalable vectors)

[courbet]

The code in this patch looks good to me, and I think it turned easier to read than the LinearPoly* abstractions. So unless there is a good reason to keep them, LGTM.

[sdesmalen]

The initial implementation was indeed too generic and complicated. It followed from discussions where we thought there might be value in keeping it generic so that we might extend it to more dimensions at some point. But given the complexity of adding even just one extra dimension, I don't see this happening any time soon (if ever). The refactor looks like a welcome improvement!

llvm/include/llvm/Support/TypeSize.h

42

Seems fine to me.

[gchatelet]

Thx @sdesmalen, I'll land this now then.

[arichardson]

This commit breaks the build for me (and some of the buildbots): https://lab.llvm.org/buildbot/#/builders/16/builds/41419/steps/5/logs/stdio

CCACHE_CPP2=yes CCACHE_HASHDIR=yes /usr/bin/ccache /usr/bin/clang++ -DEXPENSIVE_CHECKS -DGTEST_HAS_RTTI=0 -D_DEBUG -D_GLIBCXX_DEBUG -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -I/b/1/llvm-clang-x86_64-expensive-checks-debian/build/lib/IR -I/b/1/llvm-clang-x86_64-expensive-checks-debian/llvm-project/llvm/lib/IR -I/b/1/llvm-clang-x86_64-expensive-checks-debian/build/include -I/b/1/llvm-clang-x86_64-expensive-checks-debian/llvm-project/llvm/include -U_GLIBCXX_DEBUG -fPIC -fvisibility-inlines-hidden -Werror=date-time -Werror=unguarded-availability-new -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wmissing-field-initializers -pedantic -Wno-long-long -Wc++98-compat-extra-semi -Wimplicit-fallthrough -Wcovered-switch-default -Wno-noexcept-type -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -Wsuggest-override -Wstring-conversion -Wmisleading-indentation -Wctad-maybe-unsupported -fdiagnostics-color -ffunction-sections -fdata-sections -O3 -DNDEBUG  -fno-exceptions -fno-rtti -UNDEBUG -std=c++17 -MD -MT lib/IR/CMakeFiles/LLVMCore.dir/StructuralHash.cpp.o -MF lib/IR/CMakeFiles/LLVMCore.dir/StructuralHash.cpp.o.d -o lib/IR/CMakeFiles/LLVMCore.dir/StructuralHash.cpp.o -c /b/1/llvm-clang-x86_64-expensive-checks-debian/llvm-project/llvm/lib/IR/StructuralHash.cpp
/b/1/llvm-clang-x86_64-expensive-checks-debian/llvm-project/llvm/lib/IR/StructuralHash.cpp:73:3: error: no type named 'StructuralHash' in namespace 'llvm::details'; did you mean '::details::StructuralHash'?
  details::StructuralHash H;
  ^~~~~~~~~~~~~~~~~~~~~~~
  ::details::StructuralHash
/b/1/llvm-clang-x86_64-expensive-checks-debian/llvm-project/llvm/lib/IR/StructuralHash.cpp:25:7: note: '::details::StructuralHash' declared here
class StructuralHash {
      ^
/b/1/llvm-clang-x86_64-expensive-checks-debian/llvm-project/llvm/lib/IR/StructuralHash.cpp:79:3: error: no type named 'StructuralHash' in namespace 'llvm::details'; did you mean '::details::StructuralHash'?
  details::StructuralHash H;
  ^~~~~~~~~~~~~~~~~~~~~~~
  ::details::StructuralHash
/b/1/llvm-clang-x86_64-expensive-checks-debian/llvm-project/llvm/lib/IR/StructuralHash.cpp:25:7: note: '::details::StructuralHash' declared here
class StructuralHash {
      ^
2 errors generated.

[ABataev]

In D140263#4031491, @arichardson wrote:

This commit breaks the build for me (and some of the buildbots): https://lab.llvm.org/buildbot/#/builders/16/builds/41419/steps/5/logs/stdio

CCACHE_CPP2=yes CCACHE_HASHDIR=yes /usr/bin/ccache /usr/bin/clang++ -DEXPENSIVE_CHECKS -DGTEST_HAS_RTTI=0 -D_DEBUG -D_GLIBCXX_DEBUG -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -I/b/1/llvm-clang-x86_64-expensive-checks-debian/build/lib/IR -I/b/1/llvm-clang-x86_64-expensive-checks-debian/llvm-project/llvm/lib/IR -I/b/1/llvm-clang-x86_64-expensive-checks-debian/build/include -I/b/1/llvm-clang-x86_64-expensive-checks-debian/llvm-project/llvm/include -U_GLIBCXX_DEBUG -fPIC -fvisibility-inlines-hidden -Werror=date-time -Werror=unguarded-availability-new -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wmissing-field-initializers -pedantic -Wno-long-long -Wc++98-compat-extra-semi -Wimplicit-fallthrough -Wcovered-switch-default -Wno-noexcept-type -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -Wsuggest-override -Wstring-conversion -Wmisleading-indentation -Wctad-maybe-unsupported -fdiagnostics-color -ffunction-sections -fdata-sections -O3 -DNDEBUG  -fno-exceptions -fno-rtti -UNDEBUG -std=c++17 -MD -MT lib/IR/CMakeFiles/LLVMCore.dir/StructuralHash.cpp.o -MF lib/IR/CMakeFiles/LLVMCore.dir/StructuralHash.cpp.o.d -o lib/IR/CMakeFiles/LLVMCore.dir/StructuralHash.cpp.o -c /b/1/llvm-clang-x86_64-expensive-checks-debian/llvm-project/llvm/lib/IR/StructuralHash.cpp
/b/1/llvm-clang-x86_64-expensive-checks-debian/llvm-project/llvm/lib/IR/StructuralHash.cpp:73:3: error: no type named 'StructuralHash' in namespace 'llvm::details'; did you mean '::details::StructuralHash'?
  details::StructuralHash H;
  ^~~~~~~~~~~~~~~~~~~~~~~
  ::details::StructuralHash
/b/1/llvm-clang-x86_64-expensive-checks-debian/llvm-project/llvm/lib/IR/StructuralHash.cpp:25:7: note: '::details::StructuralHash' declared here
class StructuralHash {
      ^
/b/1/llvm-clang-x86_64-expensive-checks-debian/llvm-project/llvm/lib/IR/StructuralHash.cpp:79:3: error: no type named 'StructuralHash' in namespace 'llvm::details'; did you mean '::details::StructuralHash'?
  details::StructuralHash H;
  ^~~~~~~~~~~~~~~~~~~~~~~
  ::details::StructuralHash
/b/1/llvm-clang-x86_64-expensive-checks-debian/llvm-project/llvm/lib/IR/StructuralHash.cpp:25:7: note: '::details::StructuralHash' declared here
class StructuralHash {
      ^
2 errors generated.

+1, please revert the commit.

[gchatelet]

Reverting now

llvm/include/llvm/Support/TypeSize.h

 #include <type_traits>
 
 namespace llvm {
 
 /// Reports a diagnostic message to indicate an invalid size request has been
 /// done on a scalable vector. This function may not return.
 void reportInvalidSizeRequest(const char *Msg);
 
-template <typename LeafTy> struct LinearPolyBaseTypeTraits {};
+/// StackOffset holds a fixed and a scalable offset in bytes.
+class StackOffset {
+  int64_t Fixed = 0;
+  int64_t Scalable = 0;
 
-//===----------------------------------------------------------------------===//
-// LinearPolyBase - a base class for linear polynomials with multiple
-// dimensions. This can e.g. be used to describe offsets that are have both a
-// fixed and scalable component.
-//===----------------------------------------------------------------------===//
+  StackOffset(int64_t Fixed, int64_t Scalable)
+      : Fixed(Fixed), Scalable(Scalable) {}
 
-/// LinearPolyBase describes a linear polynomial:
-///  c0 * scale0 + c1 * scale1 + ... + cK * scaleK
-/// where the scale is implicit, so only the coefficients are encoded.
-template <typename LeafTy>
-class LinearPolyBase {
 public:
-  using ScalarTy = typename LinearPolyBaseTypeTraits<LeafTy>::ScalarTy;
-  static constexpr auto Dimensions = LinearPolyBaseTypeTraits<LeafTy>::Dimensions;
-  static_assert(Dimensions != std::numeric_limits<unsigned>::max(),
-                "Dimensions out of range");
-
-private:
-  std::array<ScalarTy, Dimensions> Coefficients;
-
-protected:
-  constexpr LinearPolyBase(ArrayRef<ScalarTy> Values) {
-    std::copy(Values.begin(), Values.end(), Coefficients.begin());
+  StackOffset() = default;
+  static StackOffset getFixed(int64_t Fixed) { return {Fixed, 0}; }
+  static StackOffset getScalable(int64_t Scalable) { return {0, Scalable}; }
+  static StackOffset get(int64_t Fixed, int64_t Scalable) {
+    return {Fixed, Scalable};
   }
 
-public:
-  friend LeafTy &operator+=(LeafTy &LHS, const LeafTy &RHS) {
-    for (unsigned I=0; I<Dimensions; ++I)
-      LHS.Coefficients[I] += RHS.Coefficients[I];
-    return LHS;
-  }
+  /// Returns the fixed component of the stack.
+  int64_t getFixed() const { return Fixed; }
 
-  friend LeafTy &operator-=(LeafTy &LHS, const LeafTy &RHS) {
-    for (unsigned I=0; I<Dimensions; ++I)
-      LHS.Coefficients[I] -= RHS.Coefficients[I];
-    return LHS;
-  }
+  /// Returns the scalable component of the stack.
+  int64_t getScalable() const { return Scalable; }
 
-  friend LeafTy &operator*=(LeafTy &LHS, ScalarTy RHS) {
-    for (auto &C : LHS.Coefficients)
-      C *= RHS;
-    return LHS;
+  // Arithmetic operations.
+  StackOffset operator+(const StackOffset &RHS) const {
+    return {Fixed + RHS.Fixed, Scalable + RHS.Scalable};
   }
-
-  friend LeafTy operator+(const LeafTy &LHS, const LeafTy &RHS) {
-    LeafTy Copy = LHS;
-    return Copy += RHS;
+  StackOffset operator-(const StackOffset &RHS) const {
+    return {Fixed - RHS.Fixed, Scalable - RHS.Scalable};
   }
-
-  friend LeafTy operator-(const LeafTy &LHS, const LeafTy &RHS) {
-    LeafTy Copy = LHS;
-    return Copy -= RHS;
+  StackOffset &operator+=(const StackOffset &RHS) {
+    Fixed += RHS.Fixed;
+    Scalable += RHS.Scalable;
+    return *this;
   }
-
-  friend LeafTy operator*(const LeafTy &LHS, ScalarTy RHS) {
-    LeafTy Copy = LHS;
-    return Copy *= RHS;
-  }
-
-  template <typename U = ScalarTy>
-  friend std::enable_if_t<std::is_signed<U>::value, LeafTy>
-  operator-(const LeafTy &LHS) {
-    LeafTy Copy = LHS;
-    return Copy *= -1;
+  StackOffset &operator-=(const StackOffset &RHS) {
+    Fixed -= RHS.Fixed;
+    Scalable -= RHS.Scalable;
+    return *this;
   }
+  StackOffset operator-() const { return {-Fixed, -Scalable}; }
 
-  constexpr bool operator==(const LinearPolyBase &RHS) const {
-    return std::equal(Coefficients.begin(), Coefficients.end(),
-                      RHS.Coefficients.begin());
+  // Equality comparisons.
+  bool operator==(const StackOffset &RHS) const {
+    return Fixed == RHS.Fixed && Scalable == RHS.Scalable;
   }
-
-  constexpr bool operator!=(const LinearPolyBase &RHS) const {
-    return !(*this == RHS);
-  }
-
-  constexpr bool isZero() const {
-    return all_of(Coefficients, [](const ScalarTy &C) { return C == 0; });
-  }
-  constexpr bool isNonZero() const { return !isZero(); }
-  constexpr explicit operator bool() const { return isNonZero(); }
-
-  constexpr ScalarTy getValue(unsigned Dim) const { return Coefficients[Dim]; }
-};
-
-//===----------------------------------------------------------------------===//
-// StackOffset - Represent an offset with named fixed and scalable components.
-//===----------------------------------------------------------------------===//
-
-class StackOffset;
-template <> struct LinearPolyBaseTypeTraits<StackOffset> {
-  using ScalarTy = int64_t;
-  static constexpr unsigned Dimensions = 2;
-};
-
-/// StackOffset is a class to represent an offset with 2 dimensions,
-/// named fixed and scalable, respectively. This class allows a value for both
-/// dimensions to depict e.g. "8 bytes and 16 scalable bytes", which is needed
-/// to represent stack offsets.
-class StackOffset : public LinearPolyBase<StackOffset> {
-protected:
-  StackOffset(ScalarTy Fixed, ScalarTy Scalable)
-      : LinearPolyBase<StackOffset>({Fixed, Scalable}) {}
-
-public:
-  StackOffset() : StackOffset({0, 0}) {}
-  StackOffset(const LinearPolyBase<StackOffset> &Other)
-      : LinearPolyBase<StackOffset>(Other) {}
-  static StackOffset getFixed(ScalarTy Fixed) { return {Fixed, 0}; }
-  static StackOffset getScalable(ScalarTy Scalable) { return {0, Scalable}; }
-  static StackOffset get(ScalarTy Fixed, ScalarTy Scalable) {
-    return {Fixed, Scalable};
+  bool operator!=(const StackOffset &RHS) const {
+    return Fixed != RHS.Fixed || Scalable != RHS.Scalable;
   }
 
-  ScalarTy getFixed() const { return this->getValue(0); }
-  ScalarTy getScalable() const { return this->getValue(1); }
+  // The bool operator returns true iff any of the components is non zero.
+  explicit operator bool() const { return Fixed != 0 || Scalable != 0; }
 };
 
-//===----------------------------------------------------------------------===//
-// UnivariateLinearPolyBase - a base class for linear polynomials with multiple
-// dimensions, but where only one dimension can be set at any time.
-// This can e.g. be used to describe sizes that are either fixed or scalable.
-//===----------------------------------------------------------------------===//
+namespace details {
 
-/// UnivariateLinearPolyBase is a base class for ElementCount and TypeSize.
-/// Like LinearPolyBase it tries to represent a linear polynomial
-/// where only one dimension can be set at any time, e.g.
-///   0 * scale0 + 0 * scale1 + ... + cJ * scaleJ + ... + 0 * scaleK
-/// The dimension that is set is the univariate dimension.
-template <typename LeafTy>
-class UnivariateLinearPolyBase {
+// Base class for ElementCount and TypeSize below.
+template <typename LeafTy, typename ValueTy> class FixedOrScalableQuantity {
 public:
-  using ScalarTy = typename LinearPolyBaseTypeTraits<LeafTy>::ScalarTy;
-  static constexpr auto Dimensions = LinearPolyBaseTypeTraits<LeafTy>::Dimensions;
-  static_assert(Dimensions != std::numeric_limits<unsigned>::max(),
-                "Dimensions out of range");
+  using ScalarTy = ValueTy;
 
 protected:
-  ScalarTy Value;         // The value at the univeriate dimension.
-  unsigned UnivariateDim; // The univeriate dimension.
-
-  constexpr UnivariateLinearPolyBase(ScalarTy Val, unsigned UnivariateDim)
-      : Value(Val), UnivariateDim(UnivariateDim) {
-    assert(UnivariateDim < Dimensions && "Dimension out of range");
-  }
+  ScalarTy Quantity = 0;
+  bool Scalable = false;
 
-  friend LeafTy &operator+=(LeafTy &LHS, const LeafTy &RHS) {
-    assert(LHS.UnivariateDim == RHS.UnivariateDim && "Invalid dimensions");
-    LHS.Value += RHS.Value;
+  constexpr FixedOrScalableQuantity() = default;
+  constexpr FixedOrScalableQuantity(ScalarTy Quantity, bool Scalable)
+      : Quantity(Quantity), Scalable(Scalable) {}
+
+  friend constexpr LeafTy &operator+=(LeafTy &LHS, const LeafTy &RHS) {
+    assert(LHS.Scalable == RHS.Scalable && "Incompatible types");
+    LHS.Quantity += RHS.Quantity;
     return LHS;
   }
 
-  friend LeafTy &operator-=(LeafTy &LHS, const LeafTy &RHS) {
-    assert(LHS.UnivariateDim == RHS.UnivariateDim && "Invalid dimensions");
-    LHS.Value -= RHS.Value;
+  friend constexpr LeafTy &operator-=(LeafTy &LHS, const LeafTy &RHS) {
+    assert(LHS.Scalable == RHS.Scalable && "Incompatible types");
+    LHS.Quantity -= RHS.Quantity;
     return LHS;
   }
 
   friend constexpr LeafTy &operator*=(LeafTy &LHS, ScalarTy RHS) {
-    LHS.Value *= RHS;
+    LHS.Quantity *= RHS;
     return LHS;
   }
 
-  friend LeafTy operator+(const LeafTy &LHS, const LeafTy &RHS) {
+  friend constexpr LeafTy operator+(const LeafTy &LHS, const LeafTy &RHS) {
     LeafTy Copy = LHS;
     return Copy += RHS;
   }
 
-  friend LeafTy operator-(const LeafTy &LHS, const LeafTy &RHS) {
+  friend constexpr LeafTy operator-(const LeafTy &LHS, const LeafTy &RHS) {
     LeafTy Copy = LHS;
     return Copy -= RHS;
   }
 
   friend constexpr LeafTy operator*(const LeafTy &LHS, ScalarTy RHS) {
     LeafTy Copy = LHS;
     return Copy *= RHS;
   }
 
   template <typename U = ScalarTy>
-  friend std::enable_if_t<std::is_signed<U>::value, LeafTy>
+  friend constexpr std::enable_if_t<std::is_signed<U>::value, LeafTy>
   operator-(const LeafTy &LHS) {
     LeafTy Copy = LHS;
     return Copy *= -1;
   }
 
 public:
-  constexpr bool operator==(const UnivariateLinearPolyBase &RHS) const {
-    return Value == RHS.Value && UnivariateDim == RHS.UnivariateDim;
-  }
-
-  constexpr bool operator!=(const UnivariateLinearPolyBase &RHS) const {
-    return !(*this == RHS);
+  constexpr bool operator==(const FixedOrScalableQuantity &RHS) const {
+    return Quantity == RHS.Quantity && Scalable == RHS.Scalable;
   }
 
-  constexpr bool isZero() const { return !Value; }
-  constexpr bool isNonZero() const { return !isZero(); }
-  explicit constexpr operator bool() const { return isNonZero(); }
-  constexpr ScalarTy getValue(unsigned Dim) const {
-    return Dim == UnivariateDim ? Value : 0;
+  constexpr bool operator!=(const FixedOrScalableQuantity &RHS) const {
+    return Quantity != RHS.Quantity || Scalable != RHS.Scalable;
   }
 
-  /// Add \p RHS to the value at the univariate dimension.
-  constexpr LeafTy getWithIncrement(ScalarTy RHS) const {
-    return static_cast<LeafTy>(
-        UnivariateLinearPolyBase(Value + RHS, UnivariateDim));
-  }
-
-  /// Subtract \p RHS from the value at the univariate dimension.
-  constexpr LeafTy getWithDecrement(ScalarTy RHS) const {
-    return static_cast<LeafTy>(
-        UnivariateLinearPolyBase(Value - RHS, UnivariateDim));
-  }
-};
+  constexpr bool isZero() const { return Quantity == 0; }
 
+  constexpr bool isNonZero() const { return Quantity != 0; }
 
-//===----------------------------------------------------------------------===//
-// LinearPolySize - base class for fixed- or scalable sizes.
-//  ^  ^
-//  |  |
-//  |  +----- ElementCount - Leaf class to represent an element count
-//  |                        (vscale x unsigned)
-//  |
-//  +-------- TypeSize - Leaf class to represent a type size
-//                       (vscale x uint64_t)
-//===----------------------------------------------------------------------===//
-
-/// LinearPolySize is a base class to represent sizes. It is either
-/// fixed-sized or it is scalable-sized, but it cannot be both.
-template <typename LeafTy>
-class LinearPolySize : public UnivariateLinearPolyBase<LeafTy> {
-  // Make the parent class a friend, so that it can access the protected
-  // conversion/copy-constructor for UnivariatePolyBase<LeafTy> ->
-  // LinearPolySize<LeafTy>.
-  friend class UnivariateLinearPolyBase<LeafTy>;
+  explicit operator bool() const { return isNonZero(); }
 
-public:
-  using ScalarTy = typename UnivariateLinearPolyBase<LeafTy>::ScalarTy;
-  enum Dims : unsigned { FixedDim = 0, ScalableDim = 1 };
+  /// Add \p RHS to the underlying quantity.
+  constexpr LeafTy getWithIncrement(ScalarTy RHS) const {
+    return LeafTy::get(Quantity + RHS, Scalable);
+  }
 
-protected:
-  constexpr LinearPolySize(ScalarTy MinVal, Dims D)
-      : UnivariateLinearPolyBase<LeafTy>(MinVal, D) {}
+  /// Returns the minimum value this quantity can represent.
+  constexpr ScalarTy getKnownMinValue() const { return Quantity; }
 
-  constexpr LinearPolySize(const UnivariateLinearPolyBase<LeafTy> &V)
-      : UnivariateLinearPolyBase<LeafTy>(V) {}
+  /// Returns whether the quantity is scaled by a runtime quantity (vscale).
+  constexpr bool isScalable() const { return Scalable; }
 
-public:
-  static constexpr LeafTy getFixed(ScalarTy MinVal) {
-    return static_cast<LeafTy>(LinearPolySize(MinVal, FixedDim));
-  }
-  static constexpr LeafTy getScalable(ScalarTy MinVal) {
-    return static_cast<LeafTy>(LinearPolySize(MinVal, ScalableDim));
-  }
-  static constexpr LeafTy get(ScalarTy MinVal, bool Scalable) {
-    return static_cast<LeafTy>(
-        LinearPolySize(MinVal, Scalable ? ScalableDim : FixedDim));
-  }
-  static constexpr LeafTy getNull() { return get(0, false); }
-
-  /// Returns the minimum value this size can represent.
-  constexpr ScalarTy getKnownMinValue() const { return this->Value; }
-  /// Returns whether the size is scaled by a runtime quantity (vscale).
-  constexpr bool isScalable() const {
-    return this->UnivariateDim == ScalableDim;
-  }
   /// A return value of true indicates we know at compile time that the number
   /// of elements (vscale * Min) is definitely even. However, returning false
   /// does not guarantee that the total number of elements is odd.
   constexpr bool isKnownEven() const { return (getKnownMinValue() & 0x1) == 0; }
+
   /// This function tells the caller whether the element count is known at
   /// compile time to be a multiple of the scalar value RHS.
   constexpr bool isKnownMultipleOf(ScalarTy RHS) const {
     return getKnownMinValue() % RHS == 0;
   }
 
   // Return the minimum value with the assumption that the count is exact.
   // Use in places where a scalable count doesn't make sense (e.g. non-vector
   // types, or vectors in backends which don't support scalable vectors).
   constexpr ScalarTy getFixedValue() const {
     assert(!isScalable() &&
            "Request for a fixed element count on a scalable object");
     return getKnownMinValue();
   }
 
-  // For some cases, size ordering between scalable and fixed size types cannot
-  // be determined at compile time, so such comparisons aren't allowed.
+  // For some cases, quantity ordering between scalable and fixed quantity types
+  // cannot be determined at compile time, so such comparisons aren't allowed.
   //
   // e.g. <vscale x 2 x i16> could be bigger than <4 x i32> with a runtime
   // vscale >= 5, equal sized with a vscale of 4, and smaller with
   // a vscale <= 3.
   //
   // All the functions below make use of the fact vscale is always >= 1, which
   // means that <vscale x 4 x i32> is guaranteed to be >= <4 x i32>, etc.
 
-  static constexpr bool isKnownLT(const LinearPolySize &LHS,
-                                  const LinearPolySize &RHS) {
+  static constexpr bool isKnownLT(const FixedOrScalableQuantity &LHS,
+                                  const FixedOrScalableQuantity &RHS) {
     if (!LHS.isScalable() || RHS.isScalable())
       return LHS.getKnownMinValue() < RHS.getKnownMinValue();
     return false;
   }
 
-  static constexpr bool isKnownGT(const LinearPolySize &LHS,
-                                  const LinearPolySize &RHS) {
+  static constexpr bool isKnownGT(const FixedOrScalableQuantity &LHS,
+                                  const FixedOrScalableQuantity &RHS) {
     if (LHS.isScalable() || !RHS.isScalable())
       return LHS.getKnownMinValue() > RHS.getKnownMinValue();
     return false;
   }
 
-  static constexpr bool isKnownLE(const LinearPolySize &LHS,
-                                  const LinearPolySize &RHS) {
+  static constexpr bool isKnownLE(const FixedOrScalableQuantity &LHS,
+                                  const FixedOrScalableQuantity &RHS) {
     if (!LHS.isScalable() || RHS.isScalable())
       return LHS.getKnownMinValue() <= RHS.getKnownMinValue();
     return false;
   }
 
-  static constexpr bool isKnownGE(const LinearPolySize &LHS,
-                                  const LinearPolySize &RHS) {
+  static constexpr bool isKnownGE(const FixedOrScalableQuantity &LHS,
+                                  const FixedOrScalableQuantity &RHS) {
     if (LHS.isScalable() || !RHS.isScalable())
       return LHS.getKnownMinValue() >= RHS.getKnownMinValue();
     return false;
   }
 
   /// We do not provide the '/' operator here because division for polynomial
   /// types does not work in the same way as for normal integer types. We can
   /// only divide the minimum value (or coefficient) by RHS, which is not the
   /// same as
   ///   (Min * Vscale) / RHS
   /// The caller is recommended to use this function in combination with
   /// isKnownMultipleOf(RHS), which lets the caller know if it's possible to
   /// perform a lossless divide by RHS.
   constexpr LeafTy divideCoefficientBy(ScalarTy RHS) const {
-    return static_cast<LeafTy>(
-        LinearPolySize::get(getKnownMinValue() / RHS, isScalable()));
+    return LeafTy::get(getKnownMinValue() / RHS, isScalable());
   }
 
   constexpr LeafTy multiplyCoefficientBy(ScalarTy RHS) const {
-    return static_cast<LeafTy>(
-        LinearPolySize::get(getKnownMinValue() * RHS, isScalable()));
+    return LeafTy::get(getKnownMinValue() * RHS, isScalable());
   }
 
   constexpr LeafTy coefficientNextPowerOf2() const {
-    return static_cast<LeafTy>(LinearPolySize::get(
+    return LeafTy::get(
         static_cast<ScalarTy>(llvm::NextPowerOf2(getKnownMinValue())),
-        isScalable()));
+        isScalable());
   }
 
   /// Returns true if there exists a value X where RHS.multiplyCoefficientBy(X)
-  /// will result in a value whose size matches our own.
-  constexpr bool hasKnownScalarFactor(const LinearPolySize &RHS) const {
+  /// will result in a value whose quantity matches our own.
+  constexpr bool
+  hasKnownScalarFactor(const FixedOrScalableQuantity &RHS) const {
     return isScalable() == RHS.isScalable() &&
            getKnownMinValue() % RHS.getKnownMinValue() == 0;
   }
 
   /// Returns a value X where RHS.multiplyCoefficientBy(X) will result in a
-  /// value whose size matches our own.
-  constexpr ScalarTy getKnownScalarFactor(const LinearPolySize &RHS) const {
+  /// value whose quantity matches our own.
+  constexpr ScalarTy
+  getKnownScalarFactor(const FixedOrScalableQuantity &RHS) const {
     assert(hasKnownScalarFactor(RHS) && "Expected RHS to be a known factor!");
     return getKnownMinValue() / RHS.getKnownMinValue();
   }
 
   /// Printing function.
   void print(raw_ostream &OS) const {
     if (isScalable())
       OS << "vscale x ";
     OS << getKnownMinValue();
   }
 };
 
-class ElementCount;
-template <> struct LinearPolyBaseTypeTraits<ElementCount> {
-  using ScalarTy = unsigned;
-  static constexpr unsigned Dimensions = 2;
-};
+} // namespace details
+
+// Stores the number of elements for a type and whether this type is fixed
+// (N-Elements) or scalable (e.g., SVE).
+//  - ElementCount::getFixed(1) : A scalar value.
+//  - ElementCount::getFixed(2) : A vector type holding 2 values.
+//  - ElementCount::getScalable(4) : A scalable vector type holding 4 values.
+class ElementCount
+    : public details::FixedOrScalableQuantity<ElementCount, unsigned> {
+  constexpr ElementCount(ScalarTy MinVal, bool Scalable)
+      : FixedOrScalableQuantity(MinVal, Scalable) {}
+
+  constexpr ElementCount(
+      const FixedOrScalableQuantity<ElementCount, unsigned> &V)
+      : FixedOrScalableQuantity(V) {}
 
-class ElementCount : public LinearPolySize<ElementCount> {
 public:
-  constexpr ElementCount() : LinearPolySize(LinearPolySize::getNull()) {}
+  constexpr ElementCount() : FixedOrScalableQuantity() {}
 
-  constexpr ElementCount(const LinearPolySize<ElementCount> &V)
-      : LinearPolySize(V) {}
+  static constexpr ElementCount getFixed(ScalarTy MinVal) {
+    return ElementCount(MinVal, false);
+  }
+  static constexpr ElementCount getScalable(ScalarTy MinVal) {
+    return ElementCount(MinVal, true);
+  }
+  static constexpr ElementCount get(ScalarTy MinVal, bool Scalable) {
+    return ElementCount(MinVal, Scalable);
+  }
 
-  /// Counting predicates.
-  ///
-  ///@{ Number of elements..
   /// Exactly one element.
   constexpr bool isScalar() const {
     return !isScalable() && getKnownMinValue() == 1;
   }
   /// One or more elements.
   constexpr bool isVector() const {
     return (isScalable() && getKnownMinValue() != 0) || getKnownMinValue() > 1;
   }
-  ///@}
 };
 
-// This class is used to represent the size of types. If the type is of fixed
-class TypeSize;
-template <> struct LinearPolyBaseTypeTraits<TypeSize> {
-  using ScalarTy = uint64_t;
-  static constexpr unsigned Dimensions = 2;
-};
+// Stores the size of a type. If the type is of fixed size, it will represent
+// the exact size. If the type is a scalable vector, it will represent the known
+// minimum size.
+class TypeSize : public details::FixedOrScalableQuantity<TypeSize, uint64_t> {
+  TypeSize(const FixedOrScalableQuantity<TypeSize, uint64_t> &V)
+      : FixedOrScalableQuantity(V) {}
 
-// TODO: Most functionality in this class will gradually be phased out
-// so it will resemble LinearPolySize as much as possible.
-//
-// TypeSize is used to represent the size of types. If the type is of fixed
-// size, it will represent the exact size. If the type is a scalable vector,
-// it will represent the known minimum size.
-class TypeSize : public LinearPolySize<TypeSize> {
 public:
-  constexpr TypeSize(const LinearPolySize<TypeSize> &V) : LinearPolySize(V) {}
-  constexpr TypeSize(ScalarTy MinVal, bool IsScalable)
-      : LinearPolySize(LinearPolySize::get(MinVal, IsScalable)) {}
+  constexpr TypeSize(ScalarTy Quantity, bool Scalable)
+      : FixedOrScalableQuantity(Quantity, Scalable) {}
 
-  static constexpr TypeSize Fixed(ScalarTy MinVal) {
-    return TypeSize(MinVal, false);
+  static constexpr TypeSize getFixed(ScalarTy ExactSize) {
+    return TypeSize(ExactSize, false);
   }
-  static constexpr TypeSize Scalable(ScalarTy MinVal) {
-    return TypeSize(MinVal, true);
+  static constexpr TypeSize getScalable(ScalarTy MinimunSize) {
+    return TypeSize(MinimunSize, true);
+  }
+  static constexpr TypeSize get(ScalarTy Quantity, bool Scalable) {
+    return TypeSize(Quantity, Scalable);
+  }
+  static constexpr TypeSize Fixed(ScalarTy ExactSize) {
+    return TypeSize(ExactSize, false);
+  }
+  static constexpr TypeSize Scalable(ScalarTy MinimumSize) {
+    return TypeSize(MinimumSize, true);
   }
 
   constexpr ScalarTy getFixedSize() const { return getFixedValue(); }
   constexpr ScalarTy getKnownMinSize() const { return getKnownMinValue(); }
 
   // All code for this class below this point is needed because of the
   // temporary implicit conversion to uint64_t. The operator overloads are
   // needed because otherwise the conversion of the parent class
public:
   }
 };
 
 //===----------------------------------------------------------------------===//
 // Utilities
 //===----------------------------------------------------------------------===//
 
 /// Returns a TypeSize with a known minimum size that is the next integer
-/// (mod 2**64) that is greater than or equal to \p Value and is a multiple
+/// (mod 2**64) that is greater than or equal to \p Quantity and is a multiple
 /// of \p Align. \p Align must be non-zero.
 ///
 /// Similar to the alignTo functions in MathExtras.h
 inline constexpr TypeSize alignTo(TypeSize Size, uint64_t Align) {
   assert(Align != 0u && "Align must be non-zero");
   return {(Size.getKnownMinValue() + Align - 1) / Align * Align,
           Size.isScalable()};
 }
 
-/// Stream operator function for `LinearPolySize`.
-template <typename LeafTy>
-inline raw_ostream &operator<<(raw_ostream &OS,
-                               const LinearPolySize<LeafTy> &PS) {
+/// Stream operator function for `FixedOrScalableQuantity`.
+template <typename LeafTy, typename ScalarTy>
+inline raw_ostream &
+operator<<(raw_ostream &OS,
+           const details::FixedOrScalableQuantity<LeafTy, ScalarTy> &PS) {
   PS.print(OS);
   return OS;
 }
 
 template <> struct DenseMapInfo<ElementCount, void> {
   static inline ElementCount getEmptyKey() {
     return ElementCount::getScalable(~0U);
   }
   static inline ElementCount getTombstoneKey() {
     return ElementCount::getFixed(~0U - 1);
   }
   static unsigned getHashValue(const ElementCount &EltCnt) {
     unsigned HashVal = EltCnt.getKnownMinValue() * 37U;
     if (EltCnt.isScalable())
       return (HashVal - 1U);
 
     return HashVal;
   }
-
   static bool isEqual(const ElementCount &LHS, const ElementCount &RHS) {
     return LHS == RHS;
   }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_SUPPORT_TYPESIZE_H

llvm/unittests/Support/CMakeLists.txt

add_llvm_unittest(SupportTests
   GlobPatternTest.cpp
   HashBuilderTest.cpp
   IndexedAccessorTest.cpp
   InstructionCostTest.cpp
   ItaniumManglingCanonicalizerTest.cpp
   JSONTest.cpp
   KnownBitsTest.cpp
   LEB128Test.cpp
-  LinearPolyBaseTest.cpp
   LineIteratorTest.cpp
   LockFileManagerTest.cpp
   MatchersTest.cpp
   MD5Test.cpp
   ManagedStatic.cpp
   MathExtrasTest.cpp
   MemoryBufferRefTest.cpp
   MemoryBufferTest.cpp

llvm/unittests/Support/LinearPolyBaseTest.cpp

-//===- TestPoly3D.cpp - Poly3D unit tests------------------------===//
-//
-// 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/Support/TypeSize.h"
-#include "gtest/gtest.h"
-
-using namespace llvm;
-
-class Poly3D;
-
-namespace llvm {
-template <> struct LinearPolyBaseTypeTraits<Poly3D> {
-  using ScalarTy = int64_t;
-  static const unsigned Dimensions = 3;
-};
-}
-
-using Poly3DBase = LinearPolyBase<Poly3D>;
-class Poly3D : public Poly3DBase {
-public:
-  using ScalarTy = Poly3DBase::ScalarTy;
-  Poly3D(ScalarTy x, ScalarTy y, ScalarTy z) : Poly3DBase({x, y, z}) {}
-  Poly3D(const Poly3DBase &Convert) : Poly3DBase(Convert) {}
-};
-
-TEST(LinearPolyBase, Poly3D_isZero) {
-  EXPECT_TRUE(Poly3D(0, 0, 0).isZero());
-  EXPECT_TRUE(Poly3D(0, 0, 1).isNonZero());
-  EXPECT_TRUE(Poly3D(0, 0, 1));
-}
-
-TEST(LinearPolyBase, Poly3D_Equality) {
-  EXPECT_EQ(Poly3D(1, 2, 3), Poly3D(1, 2, 3));
-  EXPECT_NE(Poly3D(1, 2, 3), Poly3D(1, 2, 4));
-}
-
-TEST(LinearPolyBase, Poly3D_GetValue) {
-  EXPECT_EQ(Poly3D(1, 2, 3).getValue(0), 1);
-  EXPECT_EQ(Poly3D(1, 2, 3).getValue(1), 2);
-  EXPECT_EQ(Poly3D(1, 2, 3).getValue(2), 3);
-}
-
-TEST(LinearPolyBase, Poly3D_Add) {
-  // Test operator+
-  EXPECT_EQ(Poly3D(42, 0, 0) + Poly3D(0, 42, 0) + Poly3D(0, 0, 42),
-            Poly3D(42, 42, 42));
-
-  // Test operator+=
-  Poly3D X(42, 0, 0);
-  X += Poly3D(0, 42, 0);
-  X += Poly3D(0, 0, 42);
-  EXPECT_EQ(X, Poly3D(42, 42, 42));
-}
-
-TEST(LinearPolyBase, Poly3D_Sub) {
-  // Test operator-
-  EXPECT_EQ(Poly3D(42, 42, 42) - Poly3D(42, 0, 0) - Poly3D(0, 42, 0) -
-                Poly3D(0, 0, 42),
-            Poly3D(0, 0, 0));
-
-  // Test operator-=
-  Poly3D X(42, 42, 42);
-  X -= Poly3D(42, 0, 0);
-  X -= Poly3D(0, 42, 0);
-  X -= Poly3D(0, 0, 42);
-  EXPECT_EQ(X, Poly3D(0, 0, 0));
-}
-
-TEST(LinearPolyBase, Poly3D_Scale) {
-  // Test operator*
-  EXPECT_EQ(Poly3D(1, 2, 4) * 2, Poly3D(2, 4, 8));
-  EXPECT_EQ(Poly3D(1, 2, 4) * -2, Poly3D(-2, -4, -8));
-}
-
-TEST(LinearPolyBase, Poly3D_Invert) {
-  // Test operator-
-  EXPECT_EQ(-Poly3D(2, 4, 8), Poly3D(-2, -4, -8));
-}
-
-class Univariate3D;
-namespace llvm {
-template <> struct LinearPolyBaseTypeTraits<Univariate3D> {
-  using ScalarTy = int64_t;
-  static const unsigned Dimensions = 3;
-};
-}
-
-using Univariate3DBase = UnivariateLinearPolyBase<Univariate3D>;
-class Univariate3D : public Univariate3DBase {
-public:
-  using ScalarTy = Univariate3DBase::ScalarTy;
-  constexpr Univariate3D(ScalarTy x, unsigned Dim) : Univariate3DBase(x, Dim) {}
-  Univariate3D(const Univariate3DBase &Convert) : Univariate3DBase(Convert) {}
-};
-
-TEST(UnivariateLinearPolyBase, Univariate3D_isZero) {
-  EXPECT_TRUE(Univariate3D(0, 0).isZero());
-  EXPECT_TRUE(Univariate3D(0, 1).isZero());
-  EXPECT_TRUE(Univariate3D(0, 2).isZero());
-  EXPECT_TRUE(Univariate3D(1, 0).isNonZero());
-  EXPECT_TRUE(Univariate3D(1, 1).isNonZero());
-  EXPECT_TRUE(Univariate3D(1, 2).isNonZero());
-  EXPECT_TRUE(Univariate3D(1, 0));
-}
-
-TEST(UnivariateLinearPolyBase, Univariate3D_Equality) {
-  EXPECT_EQ(Univariate3D(1, 0), Univariate3D(1, 0));
-  EXPECT_NE(Univariate3D(1, 0), Univariate3D(1, 2));
-  EXPECT_NE(Univariate3D(1, 0), Univariate3D(1, 1));
-  EXPECT_NE(Univariate3D(1, 0), Univariate3D(2, 0));
-  EXPECT_NE(Univariate3D(1, 0), Univariate3D(0, 0));
-}
-
-TEST(UnivariateLinearPolyBase, Univariate3D_GetValue) {
-  EXPECT_EQ(Univariate3D(42, 0).getValue(0), 42);
-  EXPECT_EQ(Univariate3D(42, 0).getValue(1), 0);
-  EXPECT_EQ(Univariate3D(42, 0).getValue(2), 0);
-
-  EXPECT_EQ(Univariate3D(42, 1).getValue(0), 0);
-  EXPECT_EQ(Univariate3D(42, 1).getValue(1), 42);
-  EXPECT_EQ(Univariate3D(42, 1).getValue(2), 0);
-}
-
-TEST(UnivariateLinearPolyBase, Univariate3D_Add) {
-  // Test operator+
-  EXPECT_EQ(Univariate3D(42, 0) + Univariate3D(42, 0), Univariate3D(84, 0));
-  EXPECT_EQ(Univariate3D(42, 1) + Univariate3D(42, 1), Univariate3D(84, 1));
-  EXPECT_DEBUG_DEATH(Univariate3D(42, 0) + Univariate3D(42, 1),
-                     "Invalid dimensions");
-
-  // Test operator+=
-  Univariate3D X(42, 0);
-  X += Univariate3D(42, 0);
-  EXPECT_EQ(X, Univariate3D(84, 0));
-
-  // Test 'getWithIncrement' method
-  EXPECT_EQ(Univariate3D(42, 0).getWithIncrement(1), Univariate3D(43, 0));
-  EXPECT_EQ(Univariate3D(42, 1).getWithIncrement(2), Univariate3D(44, 1));
-  EXPECT_EQ(Univariate3D(42, 2).getWithIncrement(3), Univariate3D(45, 2));
-}
-
-TEST(UnivariateLinearPolyBase, Univariate3D_Sub) {
-  // Test operator+
-  EXPECT_EQ(Univariate3D(84, 0) - Univariate3D(42, 0), Univariate3D(42, 0));
-  EXPECT_EQ(Univariate3D(84, 1) - Univariate3D(42, 1), Univariate3D(42, 1));
-  EXPECT_DEBUG_DEATH(Univariate3D(84, 0) - Univariate3D(42, 1),
-                     "Invalid dimensions");
-
-  // Test operator+=
-  Univariate3D X(84, 0);
-  X -= Univariate3D(42, 0);
-  EXPECT_EQ(X, Univariate3D(42, 0));
-
-  // Test 'getWithDecrement' method
-  EXPECT_EQ(Univariate3D(43, 0).getWithDecrement(1), Univariate3D(42, 0));
-  EXPECT_EQ(Univariate3D(44, 1).getWithDecrement(2), Univariate3D(42, 1));
-  EXPECT_EQ(Univariate3D(45, 2).getWithDecrement(3), Univariate3D(42, 2));
-}
-
-TEST(UnivariateLinearPolyBase, Univariate3D_Scale) {
-  // Test operator*
-  EXPECT_EQ(Univariate3D(4, 0) * 2, Univariate3D(8, 0));
-  EXPECT_EQ(Univariate3D(4, 1) * -2, Univariate3D(-8, 1));
-}
-
-TEST(UnivariateLinearPolyBase, Univariate3D_Invert) {
-  // Test operator-
-  EXPECT_EQ(-Univariate3D(4, 0), Univariate3D(-4, 0));
-  EXPECT_EQ(-Univariate3D(4, 1), Univariate3D(-4, 1));
-}
-

llvm/unittests/Support/TypeSizeTest.cpp

 static_assert(CEElementCountFixed4.isKnownEven());
 static_assert(!CEElementCountFixed3.isKnownEven());
 static_assert(!CEElementCountFixed4.isScalable());
 static_assert(!CEElementCountFixed3.isScalable());
 
 constexpr ElementCount CEElementCountScalable4 = ElementCount::getScalable(4);
 
 static_assert(CEElementCountScalable4.isScalable());
-static_assert(!ElementCount::getNull().isScalable());
+static_assert(!ElementCount().isScalable());
 static_assert(
     CEElementCountScalable4.hasKnownScalarFactor(ElementCount::getScalable(2)));
 static_assert(ElementCount::getScalable(8).getKnownScalarFactor(
                   ElementCount::getScalable(2)) == 4);
 
 static_assert(CEElementCountScalable4 == ElementCount::get(4, true));
 static_assert(CEElementCountFixed4 == ElementCount::get(4, false));
 static_assert(ElementCount::isKnownLT(CEElementCountFixed3,

llvm/utils/TableGen/CodeGenDAGPatterns.cpp

if (W.empty())
     Changed |= EnforceAny(W);
 
   // An actual vector type cannot have 0 elements, so we can treat scalars
   // as zero-length vectors. This way both vectors and scalars can be
   // processed identically.
   auto NoLength = [](const SmallDenseSet<ElementCount> &Lengths,
                      MVT T) -> bool {
     return !Lengths.count(T.isVector() ? T.getVectorElementCount()
-                                       : ElementCount::getNull());
+                                       : ElementCount());
   };
 
   SmallVector<unsigned, 4> Modes;
   union_modes(V, W, Modes);
   for (unsigned M : Modes) {
     TypeSetByHwMode::SetType &VS = V.get(M);
     TypeSetByHwMode::SetType &WS = W.get(M);
 
     SmallDenseSet<ElementCount> VN, WN;
     for (MVT T : VS)
-      VN.insert(T.isVector() ? T.getVectorElementCount()
-                             : ElementCount::getNull());
+      VN.insert(T.isVector() ? T.getVectorElementCount() : ElementCount());
     for (MVT T : WS)
-      WN.insert(T.isVector() ? T.getVectorElementCount()
-                             : ElementCount::getNull());
+      WN.insert(T.isVector() ? T.getVectorElementCount() : ElementCount());
 
     Changed |= berase_if(VS, std::bind(NoLength, WN, std::placeholders::_1));
     Changed |= berase_if(WS, std::bind(NoLength, VN, std::placeholders::_1));
   }
   return Changed;
 }
 
 namespace {