[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

91

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.

113

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.

153

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

168

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

168

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

112–113

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

168

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

173

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

103

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.

96

Update doc

99–100

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

166–167

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

[gchatelet]

llvm/include/llvm/Support/TypeSize.h

168

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

168

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

168

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.

168

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 {};
-
 //===----------------------------------------------------------------------===//
-// 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 - Represent an offset with named fixed and scalable components.
 //===----------------------------------------------------------------------===//
 
-/// 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;
+/// 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 {
+  int64_t Fixed = 0;
+  int64_t Scalable = 0;
 
-protected:
-  LinearPolyBase(ArrayRef<ScalarTy> Values) {
-    std::copy(Values.begin(), Values.end(), Coefficients.begin());
-  }
+  StackOffset(int64_t Fixed, int64_t Scalable)
+      : Fixed(Fixed), Scalable(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;
-  }
-
-  friend LeafTy &operator-=(LeafTy &LHS, const LeafTy &RHS) {
-    for (unsigned I=0; I<Dimensions; ++I)
-      LHS.Coefficients[I] -= RHS.Coefficients[I];
-    return LHS;
+  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};
   }
 
-  friend LeafTy &operator*=(LeafTy &LHS, ScalarTy RHS) {
-    for (auto &C : LHS.Coefficients)
-      C *= RHS;
-    return LHS;
-  }
+  int64_t getFixed() const { return Fixed; }
+  int64_t getScalable() const { return 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) const {
+    return {Fixed - Rhs.Fixed, Scalable - Rhs.Scalable};
   }
 
-  friend LeafTy operator*(const LeafTy &LHS, ScalarTy RHS) {
-    LeafTy Copy = LHS;
-    return Copy *= RHS;
+  StackOffset &operator+=(const StackOffset &Rhs) {
+    Fixed += Rhs.Fixed;
+    Scalable += Rhs.Scalable;
+    return *this;
   }
 
-  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;
   }
 
-  bool operator==(const LinearPolyBase &RHS) const {
-    return std::equal(Coefficients.begin(), Coefficients.end(),
-                      RHS.Coefficients.begin());
-  }
+  StackOffset operator-() const { return {-Fixed, -Scalable}; }
 
-  bool operator!=(const LinearPolyBase &RHS) const {
-    return !(*this == RHS);
+  bool operator==(const StackOffset &Rhs) const {
+    return Fixed == Rhs.Fixed && Scalable == Rhs.Scalable;
   }
+  bool operator!=(const StackOffset &Rhs) const { return !(*this == Rhs); }
 
-  bool isZero() const {
-    return all_of(Coefficients, [](const ScalarTy &C) { return C == 0; });
-  }
-  bool isNonZero() const { return !isZero(); }
-  explicit operator bool() const { return isNonZero(); }
-
-  ScalarTy getValue(unsigned Dim) const { return Coefficients[Dim]; }
+  explicit operator bool() const { return Fixed != 0 || Scalable != 0; }
 };
 
 //===----------------------------------------------------------------------===//
-// StackOffset - Represent an offset with named fixed and scalable components.
+// FixedOrScalableQuantity - 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)
 //===----------------------------------------------------------------------===//
 
-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}) {}
+template <typename LeafTy, typename ScalarT> class FixedOrScalableQuantity {
 
 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};
-  }
-
-  ScalarTy getFixed() const { return this->getValue(0); }
-  ScalarTy getScalable() const { return this->getValue(1); }
-};
-
-//===----------------------------------------------------------------------===//
-// 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.
-//===----------------------------------------------------------------------===//
-
-/// 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 {
-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 = ScalarT;
 
 protected:
-  ScalarTy Value;         // The value at the univeriate dimension.
-  unsigned UnivariateDim; // The univeriate dimension.
+  ScalarTy MinValue = 0;
+  bool Scalable = false;
 
-  UnivariateLinearPolyBase(ScalarTy Val, unsigned UnivariateDim)
-      : Value(Val), UnivariateDim(UnivariateDim) {
-    assert(UnivariateDim < Dimensions && "Dimension out of range");
-  }
+  FixedOrScalableQuantity() = default;
+  FixedOrScalableQuantity(ScalarTy MinVal, bool Scalable)
+      : MinValue(MinVal), Scalable(Scalable) {}
 
-  friend LeafTy &operator+=(LeafTy &LHS, const LeafTy &RHS) {
-    assert(LHS.UnivariateDim == RHS.UnivariateDim && "Invalid dimensions");
-    LHS.Value += RHS.Value;
-    return LHS;
+  friend LeafTy &operator+=(LeafTy &Lhs, const LeafTy &Rhs) {
+    assert(Lhs.Scalable == Rhs.Scalable && "Invalid dimensions");
+    Lhs.MinValue += Rhs.MinValue;
+    return Lhs;
   }
 
-  friend LeafTy &operator-=(LeafTy &LHS, const LeafTy &RHS) {
-    assert(LHS.UnivariateDim == RHS.UnivariateDim && "Invalid dimensions");
-    LHS.Value -= RHS.Value;
-    return LHS;
+  friend LeafTy &operator-=(LeafTy &Lhs, const LeafTy &Rhs) {
+    assert(Lhs.Scalable == Rhs.Scalable && "Invalid dimensions");
+    Lhs.MinValue -= Rhs.MinValue;
+    return Lhs;
   }
 
-  friend LeafTy &operator*=(LeafTy &LHS, ScalarTy RHS) {
-    LHS.Value *= RHS;
-    return LHS;
+  friend LeafTy &operator*=(LeafTy &Lhs, ScalarTy Rhs) {
+    Lhs.MinValue *= Rhs;
+    return Lhs;
   }
 
-  friend LeafTy operator+(const LeafTy &LHS, const LeafTy &RHS) {
-    LeafTy Copy = LHS;
-    return Copy += RHS;
+  friend LeafTy operator+(const LeafTy &Lhs, const LeafTy &Rhs) {
+    LeafTy Copy = Lhs;
+    return Copy += Rhs;
   }
 
-  friend LeafTy operator-(const LeafTy &LHS, const LeafTy &RHS) {
-    LeafTy Copy = LHS;
-    return Copy -= RHS;
+  friend LeafTy operator-(const LeafTy &Lhs, const LeafTy &Rhs) {
+    LeafTy Copy = Lhs;
+    return Copy -= Rhs;
   }
 
-  friend LeafTy operator*(const LeafTy &LHS, ScalarTy RHS) {
-    LeafTy Copy = LHS;
-    return Copy *= RHS;
+  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;
+  operator-(const LeafTy &Lhs) {
+    LeafTy Copy = Lhs;
     return Copy *= -1;
   }
 
+private:
+  auto tie() const { return std::tie(MinValue, Scalable); }
+
 public:
-  bool operator==(const UnivariateLinearPolyBase &RHS) const {
-    return Value == RHS.Value && UnivariateDim == RHS.UnivariateDim;
+  bool operator==(const FixedOrScalableQuantity &Rhs) const {
+    return tie() == Rhs.tie();
   }
 
-  bool operator!=(const UnivariateLinearPolyBase &RHS) const {
-    return !(*this == RHS);
+  bool operator!=(const FixedOrScalableQuantity &Rhs) const {
+    return tie() != Rhs.tie();
   }
 
-  bool isZero() const { return !Value; }
-  bool isNonZero() const { return !isZero(); }
+  bool isZero() const { return MinValue == 0; }
+  bool isNonZero() const { return MinValue != 0; }
   explicit operator bool() const { return isNonZero(); }
-  ScalarTy getValue(unsigned Dim) const {
-    return Dim == UnivariateDim ? Value : 0;
-  }
-
-  /// Add \p RHS to the value at the univariate dimension.
-  LeafTy getWithIncrement(ScalarTy RHS) const {
-    return static_cast<LeafTy>(
-        UnivariateLinearPolyBase(Value + RHS, UnivariateDim));
-  }
 
-  /// Subtract \p RHS from the value at the univariate dimension.
-  LeafTy getWithDecrement(ScalarTy RHS) const {
-    return static_cast<LeafTy>(
-        UnivariateLinearPolyBase(Value - RHS, UnivariateDim));
+  /// Add \p Rhs to the value at the univariate dimension.
+  LeafTy getWithIncrement(ScalarTy Rhs) const {
+    return LeafTy::get(MinValue + Rhs, Scalable);
   }
-};
-
-
-//===----------------------------------------------------------------------===//
-// 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>;
-
-public:
-  using ScalarTy = typename UnivariateLinearPolyBase<LeafTy>::ScalarTy;
-  enum Dims : unsigned { FixedDim = 0, ScalableDim = 1 };
-
-protected:
-  LinearPolySize(ScalarTy MinVal, Dims D)
-      : UnivariateLinearPolyBase<LeafTy>(MinVal, D) {}
-
-  LinearPolySize(const UnivariateLinearPolyBase<LeafTy> &V)
-      : UnivariateLinearPolyBase<LeafTy>(V) {}
-
-public:
-
-  static LeafTy getFixed(ScalarTy MinVal) {
-    return static_cast<LeafTy>(LinearPolySize(MinVal, FixedDim));
-  }
-  static LeafTy getScalable(ScalarTy MinVal) {
-    return static_cast<LeafTy>(LinearPolySize(MinVal, ScalableDim));
-  }
-  static LeafTy get(ScalarTy MinVal, bool Scalable) {
-    return static_cast<LeafTy>(
-        LinearPolySize(MinVal, Scalable ? ScalableDim : FixedDim));
-  }
-  static LeafTy getNull() { return get(0, false); }
 
   /// Returns the minimum value this size can represent.
-  ScalarTy getKnownMinValue() const { return this->Value; }
+  ScalarTy getKnownMinValue() const { return MinValue; }
   /// Returns whether the size is scaled by a runtime quantity (vscale).
-  bool isScalable() const { return this->UnivariateDim == ScalableDim; }
+  bool isScalable() const { return Scalable; }
   /// 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.
   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.
-  bool isKnownMultipleOf(ScalarTy RHS) const {
-    return getKnownMinValue() % RHS == 0;
+  /// compile time to be a multiple of the scalar value Rhs.
+  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).
   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.
   //
   // 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 bool isKnownLT(const LinearPolySize &LHS, const LinearPolySize &RHS) {
-    if (!LHS.isScalable() || RHS.isScalable())
-      return LHS.getKnownMinValue() < RHS.getKnownMinValue();
+  static bool isKnownLT(const FixedOrScalableQuantity &Lhs,
+                        const FixedOrScalableQuantity &Rhs) {
+    if (!Lhs.isScalable() || Rhs.isScalable())
+      return Lhs.getKnownMinValue() < Rhs.getKnownMinValue();
     return false;
   }
 
-  static bool isKnownGT(const LinearPolySize &LHS, const LinearPolySize &RHS) {
-    if (LHS.isScalable() || !RHS.isScalable())
-      return LHS.getKnownMinValue() > RHS.getKnownMinValue();
+  static bool isKnownGT(const FixedOrScalableQuantity &Lhs,
+                        const FixedOrScalableQuantity &Rhs) {
+    if (Lhs.isScalable() || !Rhs.isScalable())
+      return Lhs.getKnownMinValue() > Rhs.getKnownMinValue();
     return false;
   }
 
-  static bool isKnownLE(const LinearPolySize &LHS, const LinearPolySize &RHS) {
-    if (!LHS.isScalable() || RHS.isScalable())
-      return LHS.getKnownMinValue() <= RHS.getKnownMinValue();
+  static bool isKnownLE(const FixedOrScalableQuantity &Lhs,
+                        const FixedOrScalableQuantity &Rhs) {
+    if (!Lhs.isScalable() || Rhs.isScalable())
+      return Lhs.getKnownMinValue() <= Rhs.getKnownMinValue();
     return false;
   }
 
-  static bool isKnownGE(const LinearPolySize &LHS, const LinearPolySize &RHS) {
-    if (LHS.isScalable() || !RHS.isScalable())
-      return LHS.getKnownMinValue() >= RHS.getKnownMinValue();
+  static 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
+  /// only divide the minimum value (or coefficient) by Rhs, which is not the
   /// same as
-  ///   (Min * Vscale) / RHS
+  ///   (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.
-  LeafTy divideCoefficientBy(ScalarTy RHS) const {
-    return static_cast<LeafTy>(
-        LinearPolySize::get(getKnownMinValue() / RHS, isScalable()));
+  /// isKnownMultipleOf(Rhs), which lets the caller know if it's possible to
+  /// perform a lossless divide by Rhs.
+  LeafTy divideCoefficientBy(ScalarTy Rhs) const {
+    return LeafTy::get(getKnownMinValue() / Rhs, isScalable());
   }
 
-  LeafTy multiplyCoefficientBy(ScalarTy RHS) const {
-    return static_cast<LeafTy>(
-        LinearPolySize::get(getKnownMinValue() * RHS, isScalable()));
+  LeafTy multiplyCoefficientBy(ScalarTy Rhs) const {
+    return LeafTy::get(getKnownMinValue() * Rhs, isScalable());
   }
 
   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)
+  /// Returns true if there exists a value X where Rhs.multiplyCoefficientBy(X)
   /// will result in a value whose size matches our own.
-  bool hasKnownScalarFactor(const LinearPolySize &RHS) const {
-    return isScalable() == RHS.isScalable() &&
-           getKnownMinValue() % RHS.getKnownMinValue() == 0;
+  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
+  /// Returns a value X where Rhs.multiplyCoefficientBy(X) will result in a
   /// value whose size matches our own.
-  ScalarTy getKnownScalarFactor(const LinearPolySize &RHS) const {
-    assert(hasKnownScalarFactor(RHS) && "Expected RHS to be a known factor!");
-    return getKnownMinValue() / RHS.getKnownMinValue();
+  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;
-};
+class ElementCount : public FixedOrScalableQuantity<ElementCount, unsigned> {
+  ElementCount(ScalarTy MinVal, bool Scalable)
+      : FixedOrScalableQuantity(MinVal, Scalable) {}
+
+  ElementCount(const FixedOrScalableQuantity<ElementCount, unsigned> &V)
+      : FixedOrScalableQuantity(V) {}
 
-class ElementCount : public LinearPolySize<ElementCount> {
 public:
-  ElementCount() : LinearPolySize(LinearPolySize::getNull()) {}
+  ElementCount() : FixedOrScalableQuantity() {}
 
-  ElementCount(const LinearPolySize<ElementCount> &V) : LinearPolySize(V) {}
+  static ElementCount getFixed(ScalarTy MinVal) {
+    return ElementCount(MinVal, false);
+  }
+  static ElementCount getScalable(ScalarTy MinVal) {
+    return ElementCount(MinVal, true);
+  }
+  static ElementCount get(ScalarTy MinVal, bool Scalable) {
+    return ElementCount(MinVal, Scalable);
+  }
 
-  /// Counting predicates.
-  ///
-  ///@{ Number of elements..
   /// Exactly one element.
   bool isScalar() const { return !isScalable() && getKnownMinValue() == 1; }
   /// One or more elements.
   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;
-};
-
-// 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> {
+class TypeSize : public FixedOrScalableQuantity<TypeSize, uint64_t> {
+  TypeSize(const FixedOrScalableQuantity<TypeSize, uint64_t> &V)
+      : FixedOrScalableQuantity(V) {}
+
 public:
-  TypeSize(const LinearPolySize<TypeSize> &V) : LinearPolySize(V) {}
-  TypeSize(ScalarTy MinVal, bool IsScalable)
-      : LinearPolySize(LinearPolySize::get(MinVal, IsScalable)) {}
+  TypeSize(ScalarTy MinVal, bool Scalable)
+      : FixedOrScalableQuantity(MinVal, Scalable) {}
+
+  static TypeSize getFixed(ScalarTy MinVal) { return TypeSize(MinVal, false); }
+  static TypeSize getScalable(ScalarTy MinVal) {
+    return TypeSize(MinVal, true);
+  }
+  static TypeSize get(ScalarTy MinVal, bool Scalable) {
+    return TypeSize(MinVal, Scalable);
+  }
 
   static TypeSize Fixed(ScalarTy MinVal) { return TypeSize(MinVal, false); }
   static TypeSize Scalable(ScalarTy MinVal) { return TypeSize(MinVal, true); }
 
   ScalarTy getFixedSize() const { return getFixedValue(); }
   ScalarTy getKnownMinSize() const { return getKnownMinValue(); }
 
   // All code for this class below this point is needed because of the
public:
   //       update the algorithm and use getKnownMinValue()
   //     else
   //       bail out early for scalable vectors and use getFixedValue()
   //   }
   operator ScalarTy() const;
 
   // Additional operators needed to avoid ambiguous parses
   // because of the implicit conversion hack.
-  friend TypeSize operator*(const TypeSize &LHS, const int RHS) {
-    return LHS * (ScalarTy)RHS;
+  friend TypeSize operator*(const TypeSize &Lhs, const int Rhs) {
+    return Lhs * (ScalarTy)Rhs;
   }
-  friend TypeSize operator*(const TypeSize &LHS, const unsigned RHS) {
-    return LHS * (ScalarTy)RHS;
+  friend TypeSize operator*(const TypeSize &Lhs, const unsigned Rhs) {
+    return Lhs * (ScalarTy)Rhs;
   }
-  friend TypeSize operator*(const TypeSize &LHS, const int64_t RHS) {
-    return LHS * (ScalarTy)RHS;
+  friend TypeSize operator*(const TypeSize &Lhs, const int64_t Rhs) {
+    return Lhs * (ScalarTy)Rhs;
   }
-  friend TypeSize operator*(const int LHS, const TypeSize &RHS) {
-    return RHS * LHS;
+  friend TypeSize operator*(const int Lhs, const TypeSize &Rhs) {
+    return Rhs * Lhs;
   }
-  friend TypeSize operator*(const unsigned LHS, const TypeSize &RHS) {
-    return RHS * LHS;
+  friend TypeSize operator*(const unsigned Lhs, const TypeSize &Rhs) {
+    return Rhs * Lhs;
   }
-  friend TypeSize operator*(const int64_t LHS, const TypeSize &RHS) {
-    return RHS * LHS;
+  friend TypeSize operator*(const int64_t Lhs, const TypeSize &Rhs) {
+    return Rhs * Lhs;
   }
-  friend TypeSize operator*(const uint64_t LHS, const TypeSize &RHS) {
-    return RHS * LHS;
+  friend TypeSize operator*(const uint64_t Lhs, const TypeSize &Rhs) {
+    return Rhs * Lhs;
   }
 };
 
 //===----------------------------------------------------------------------===//
 // 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 MinValue and is a multiple
 /// of \p Align. \p Align must be non-zero.
 ///
 /// Similar to the alignTo functions in MathExtras.h
 inline 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 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;
+  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
   HashBuilderTest.cpp
   Host.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;
-  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/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 {