[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?).

157–158

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

157–158

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

103–104

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

157–158

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

46

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

154–155

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

[gchatelet]

llvm/include/llvm/Support/TypeSize.h

157–158

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

157–158

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

157–158

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

46

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

157–158

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

46

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:
-  LinearPolyBase(ArrayRef<ScalarTy> Values) {
-    std::copy(Values.begin(), Values.end(), Coefficients.begin());
-  }
-
-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;
-  }
-
-  friend LeafTy &operator*=(LeafTy &LHS, ScalarTy RHS) {
-    for (auto &C : LHS.Coefficients)
-      C *= RHS;
-    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+(const LeafTy &LHS, const LeafTy &RHS) {
-    LeafTy Copy = LHS;
-    return Copy += RHS;
-  }
+  /// Returns the fixed component of the stack.
+  int64_t getFixed() const { return Fixed; }
 
-  friend LeafTy operator-(const LeafTy &LHS, const LeafTy &RHS) {
-    LeafTy Copy = LHS;
-    return Copy -= RHS;
-  }
+  /// Returns the scalable component of the stack.
+  int64_t getScalable() const { return Scalable; }
 
-  friend LeafTy operator*(const LeafTy &LHS, ScalarTy RHS) {
-    LeafTy Copy = LHS;
-    return Copy *= RHS;
+  // Arithmetic operations.
+  StackOffset operator+(const StackOffset &RHS) const {
+    return {Fixed + RHS.Fixed, Scalable + RHS.Scalable};
   }
-
-  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) const {
+    return {Fixed - RHS.Fixed, Scalable - RHS.Scalable};
   }
-
-  bool operator==(const LinearPolyBase &RHS) const {
-    return std::equal(Coefficients.begin(), Coefficients.end(),
-                      RHS.Coefficients.begin());
+  StackOffset &operator+=(const StackOffset &RHS) {
+    Fixed += RHS.Fixed;
+    Scalable += RHS.Scalable;
+    return *this;
   }
-
-  bool operator!=(const LinearPolyBase &RHS) const {
-    return !(*this == RHS);
+  StackOffset &operator-=(const StackOffset &RHS) {
+    Fixed -= RHS.Fixed;
+    Scalable -= RHS.Scalable;
+    return *this;
   }
+  StackOffset operator-() const { return {-Fixed, -Scalable}; }
 
-  bool isZero() const {
-    return all_of(Coefficients, [](const ScalarTy &C) { return C == 0; });
+  // Equality comparisons.
+  bool operator==(const StackOffset &RHS) const {
+    return Fixed == RHS.Fixed && Scalable == RHS.Scalable;
   }
-  bool isNonZero() const { return !isZero(); }
-  explicit operator bool() const { return isNonZero(); }
-
-  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.
+  ScalarTy Quantity = 0;
+  bool Scalable = false;
 
-  UnivariateLinearPolyBase(ScalarTy Val, unsigned UnivariateDim)
-      : Value(Val), UnivariateDim(UnivariateDim) {
-    assert(UnivariateDim < Dimensions && "Dimension out of range");
-  }
+  FixedOrScalableQuantity() = default;
+  FixedOrScalableQuantity(ScalarTy Quantity, bool Scalable)
+      : Quantity(Quantity), Scalable(Scalable) {}
 
   friend LeafTy &operator+=(LeafTy &LHS, const LeafTy &RHS) {
-    assert(LHS.UnivariateDim == RHS.UnivariateDim && "Invalid dimensions");
-    LHS.Value += RHS.Value;
+    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;
+    assert(LHS.Scalable == RHS.Scalable && "Incompatible types");
+    LHS.Quantity -= RHS.Quantity;
     return LHS;
   }
 
   friend LeafTy &operator*=(LeafTy &LHS, ScalarTy RHS) {
-    LHS.Value *= RHS;
+    LHS.Quantity *= RHS;
     return LHS;
   }
 
   friend LeafTy operator+(const LeafTy &LHS, const LeafTy &RHS) {
     LeafTy Copy = LHS;
     return Copy += RHS;
   }
 
protected:
   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;
   }
 
 public:
-  bool operator==(const UnivariateLinearPolyBase &RHS) const {
-    return Value == RHS.Value && UnivariateDim == RHS.UnivariateDim;
+  bool operator==(const FixedOrScalableQuantity &RHS) const {
+    return Quantity == RHS.Quantity && Scalable == RHS.Scalable;
   }
 
-  bool operator!=(const UnivariateLinearPolyBase &RHS) const {
-    return !(*this == RHS);
+  bool operator!=(const FixedOrScalableQuantity &RHS) const {
+    return Quantity != RHS.Quantity || Scalable != RHS.Scalable;
   }
 
-  bool isZero() const { return !Value; }
-  bool isNonZero() const { return !isZero(); }
+  bool isZero() const { return Quantity == 0; }
+
+  bool isNonZero() const { return Quantity != 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.
+  /// Add \p RHS to Quantity.
   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));
+    return LeafTy::get(Quantity + 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) {}
+  /// Returns the minimum value this quantity can represent.
+  ScalarTy getKnownMinValue() const { return Quantity; }
 
-public:
+  /// Returns whether the quantity is scaled by a runtime quantity (vscale).
+  bool isScalable() const { return Scalable; }
 
-  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; }
-  /// Returns whether the size is scaled by a runtime quantity (vscale).
-  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.
   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;
   }
 
   // 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.
+  // 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 bool isKnownLT(const LinearPolySize &LHS, const LinearPolySize &RHS) {
+  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) {
+  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) {
+  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) {
+  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
   /// 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.
   LeafTy divideCoefficientBy(ScalarTy RHS) const {
-    return static_cast<LeafTy>(
-        LinearPolySize::get(getKnownMinValue() / RHS, isScalable()));
+    return LeafTy::get(getKnownMinValue() / RHS, isScalable());
   }
 
   LeafTy multiplyCoefficientBy(ScalarTy RHS) const {
-    return static_cast<LeafTy>(
-        LinearPolySize::get(getKnownMinValue() * RHS, isScalable()));
+    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)
-  /// will result in a value whose size matches our own.
-  bool hasKnownScalarFactor(const LinearPolySize &RHS) const {
+  /// will result in a value whose quantity matches our own.
+  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.
-  ScalarTy getKnownScalarFactor(const LinearPolySize &RHS) const {
+  /// value whose quantity matches our own.
+  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> {
+  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;
-};
+// 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:
-  TypeSize(const LinearPolySize<TypeSize> &V) : LinearPolySize(V) {}
-  TypeSize(ScalarTy MinVal, bool IsScalable)
-      : LinearPolySize(LinearPolySize::get(MinVal, IsScalable)) {}
+  TypeSize(ScalarTy Quantity, bool Scalable)
+      : FixedOrScalableQuantity(Quantity, Scalable) {}
 
-  static TypeSize Fixed(ScalarTy MinVal) { return TypeSize(MinVal, false); }
-  static TypeSize Scalable(ScalarTy MinVal) { return TypeSize(MinVal, true); }
+  static TypeSize getFixed(ScalarTy ExactSize) {
+    return TypeSize(ExactSize, false);
+  }
+  static TypeSize getScalable(ScalarTy MinimunSize) {
+    return TypeSize(MinimunSize, true);
+  }
+  static TypeSize get(ScalarTy Quantity, bool Scalable) {
+    return TypeSize(Quantity, Scalable);
+  }
+  static TypeSize Fixed(ScalarTy ExactSize) {
+    return TypeSize(ExactSize, false);
+  }
+  static TypeSize Scalable(ScalarTy MinimumSize) {
+    return TypeSize(MinimumSize, true);
+  }
 
   ScalarTy getFixedSize() const { return getFixedValue(); }
   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
   // UnivariateLinearPolyBase -> TypeSize is ambiguous.
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 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
   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 {