[SVE] Add new isKnownXX comparison functions to TypeSize

[david-arm]

Summary

This patch introduces four new comparison functions:

isKnownLT, isKnownLE, isKnownGT, isKnownGE

that return true if we know at compile time that a particular
condition is met, i.e. that one size is definitely greater than
another. The existing operators <,>,<=,>= remain in the code for
now, but over time we would like to remove them and change the
code to use the isKnownXY routines instead. These functions do
not assert like the existing operators because the caller is
expected to properly deal with cases where we return false by
analysing the scalable properties. I've made more of an effort
to deal with cases where there are mixed comparisons, i.e. between
fixed width and scalable types.

I've also added some knownBitsXY routines to the EVT and MVT
classes that call the equivalent TypeSize::isKnownXY routines.
I've changed the existing bitsXY functions to call their knownBitsXY
equivalents and added asserts that the scalable properties match.
Again, over time we expect to migrate callers to use knownBitsXY
and make the code more aware of the scalable nature of the sizes.

[ctetreau]

I think this is fine, but I went cross-eyed verifying the conditionals. Somebody else should double-check that the conditionals are fine.

[paulwalker-arm]

My preference would be to follow the clang-format advice for TypeSize.h.

Is there value is adding isKnownEQ just in case somebody wants to use function pointers?

llvm/include/llvm/Support/TypeSize.h

190–195

I'm happy with this but wondered if the following might reduce the complexity.

return isKnownLT(LHS, RHS) || isKnownEQ(LHS, RHS);

[paulwalker-arm]

llvm/include/llvm/Support/TypeSize.h

190–195

As discussed, I can see that my suggestion actually covers less cases, so is not the way to go.

[sdesmalen]

llvm/include/llvm/Support/TypeSize.h

176

Sorry to spot this only after you've landed the patch, but was there an explicit reason for making these functions static as opposed to allowing the shorter X.isKnownLT(Y) (that wouldn't need the TypeSize:: or ElementCount:: prefix)?

[david-arm]

llvm/include/llvm/Support/TypeSize.h

176

So it just seemed like a much more natural replacement for the existing operators, i.e. friend functions with a LHS and RHS:

friend bool operator<(const TypeSize &LHS, const TypeSize &RHS)

Also, I can see value in introducing the operators this way as in future once we have a templated PolySize we might want these operators to be more generic, such as:

template <typename X, typename Y>
bool SomeNameSpace::isKnownGT(const PolySize<X> LHS, const PolySize<Y> RHS);

or even have the LHS not be a PolySize at all (i.e. LHS is a simple integer):

template <typename X, typename Y>
bool SomeNameSpace::isKnownGT(X LHS, const PolySize<Y> RHS) {

PolySize<X> LHS2 = PolySize::getFixed(LHS);
return isKnownGT(LHS2, RHS);

}

and so on.

llvm/include/llvm/CodeGen/ValueTypes.h

public:
     }
 
     /// Return true if this has the same number of bits as VT.
     bool bitsEq(EVT VT) const {
       if (EVT::operator==(VT)) return true;
       return getSizeInBits() == VT.getSizeInBits();
     }
 
+    /// Return true if we know at compile time this has more bits than VT.
+    bool knownBitsGT(EVT VT) const {
+      return TypeSize::isKnownGT(getSizeInBits(), VT.getSizeInBits());
+    }
+
+    /// Return true if we know at compile time this has more than or the same
+    /// bits as VT.
+    bool knownBitsGE(EVT VT) const {
+      return TypeSize::isKnownGE(getSizeInBits(), VT.getSizeInBits());
+    }
+
+    /// Return true if we know at compile time this has fewer bits than VT.
+    bool knownBitsLT(EVT VT) const {
+      return TypeSize::isKnownLT(getSizeInBits(), VT.getSizeInBits());
+    }
+
+    /// Return true if we know at compile time this has fewer than or the same
+    /// bits as VT.
+    bool knownBitsLE(EVT VT) const {
+      return TypeSize::isKnownLE(getSizeInBits(), VT.getSizeInBits());
+    }
+
     /// Return true if this has more bits than VT.
     bool bitsGT(EVT VT) const {
       if (EVT::operator==(VT)) return false;
-      return getSizeInBits() > VT.getSizeInBits();
+      assert(isScalableVector() == VT.isScalableVector() &&
+             "Comparison between scalable and fixed types");
+      return knownBitsGT(VT);
     }
 
     /// Return true if this has no less bits than VT.
     bool bitsGE(EVT VT) const {
       if (EVT::operator==(VT)) return true;
-      return getSizeInBits() >= VT.getSizeInBits();
+      assert(isScalableVector() == VT.isScalableVector() &&
+             "Comparison between scalable and fixed types");
+      return knownBitsGE(VT);
     }
 
     /// Return true if this has less bits than VT.
     bool bitsLT(EVT VT) const {
       if (EVT::operator==(VT)) return false;
-      return getSizeInBits() < VT.getSizeInBits();
+      assert(isScalableVector() == VT.isScalableVector() &&
+             "Comparison between scalable and fixed types");
+      return knownBitsLT(VT);
     }
 
     /// Return true if this has no more bits than VT.
     bool bitsLE(EVT VT) const {
       if (EVT::operator==(VT)) return true;
-      return getSizeInBits() <= VT.getSizeInBits();
+      assert(isScalableVector() == VT.isScalableVector() &&
+             "Comparison between scalable and fixed types");
+      return knownBitsLE(VT);
     }
 
     /// Return the SimpleValueType held in the specified simple EVT.
     MVT getSimpleVT() const {
       assert(isSimple() && "Expected a SimpleValueType!");
       return V;
     }
 

llvm/include/llvm/Support/MachineValueType.h

public:
     }
 
     /// Returns true if the number of bits for the type is a multiple of an
     /// 8-bit byte.
     bool isByteSized() const {
       return getSizeInBits().isByteSized();
     }
 
+    /// Return true if we know at compile time this has more bits than VT.
+    bool knownBitsGT(MVT VT) const {
+      return TypeSize::isKnownGT(getSizeInBits(), VT.getSizeInBits());
+    }
+
+    /// Return true if we know at compile time this has more than or the same
+    /// bits as VT.
+    bool knownBitsGE(MVT VT) const {
+      return TypeSize::isKnownGE(getSizeInBits(), VT.getSizeInBits());
+    }
+
+    /// Return true if we know at compile time this has fewer bits than VT.
+    bool knownBitsLT(MVT VT) const {
+      return TypeSize::isKnownLT(getSizeInBits(), VT.getSizeInBits());
+    }
+
+    /// Return true if we know at compile time this has fewer than or the same
+    /// bits as VT.
+    bool knownBitsLE(MVT VT) const {
+      return TypeSize::isKnownLE(getSizeInBits(), VT.getSizeInBits());
+    }
+
     /// Return true if this has more bits than VT.
     bool bitsGT(MVT VT) const {
-      return getSizeInBits() > VT.getSizeInBits();
+      assert(isScalableVector() == VT.isScalableVector() &&
+             "Comparison between scalable and fixed types");
+      return knownBitsGT(VT);
     }
 
     /// Return true if this has no less bits than VT.
     bool bitsGE(MVT VT) const {
-      return getSizeInBits() >= VT.getSizeInBits();
+      assert(isScalableVector() == VT.isScalableVector() &&
+             "Comparison between scalable and fixed types");
+      return knownBitsGE(VT);
     }
 
     /// Return true if this has less bits than VT.
     bool bitsLT(MVT VT) const {
-      return getSizeInBits() < VT.getSizeInBits();
+      assert(isScalableVector() == VT.isScalableVector() &&
+             "Comparison between scalable and fixed types");
+      return knownBitsLT(VT);
     }
 
     /// Return true if this has no more bits than VT.
     bool bitsLE(MVT VT) const {
-      return getSizeInBits() <= VT.getSizeInBits();
+      assert(isScalableVector() == VT.isScalableVector() &&
+             "Comparison between scalable and fixed types");
+      return knownBitsLE(VT);
     }
 
     static MVT getFloatingPointVT(unsigned BitWidth) {
       switch (BitWidth) {
       default:
         llvm_unreachable("Bad bit width!");
       case 16:
         return MVT::f16;

llvm/include/llvm/Support/TypeSize.h

public:
 
   static constexpr TypeSize Scalable(uint64_t MinSize) {
     return TypeSize(MinSize, /*Scalable=*/true);
   }
 
   // Scalable vector types with the same minimum size as a fixed size type are
   // not guaranteed to be the same size at runtime, so they are never
   // considered to be equal.
-  friend bool operator==(const TypeSize &LHS, const TypeSize &RHS) {
-    return LHS.MinSize == RHS.MinSize && LHS.IsScalable == RHS.IsScalable;
+  bool operator==(const TypeSize &RHS) const {
+    return MinSize == RHS.MinSize && IsScalable == RHS.IsScalable;
   }
 
-  friend bool operator!=(const TypeSize &LHS, const TypeSize &RHS) {
-    return !(LHS == RHS);
-  }
+  bool operator!=(const TypeSize &RHS) const { return !(*this == RHS); }
 
-  // For many cases, size ordering between scalable and fixed size types cannot
+  // 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.
   //
-  // If the scalable flags match, just perform the requested comparison
-  // between the minimum sizes.
+  // 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 TypeSize &LHS, const TypeSize &RHS) {
+    if (!LHS.IsScalable || RHS.IsScalable)
+      return LHS.MinSize < RHS.MinSize;
+
+    // LHS.IsScalable = true, RHS.IsScalable = false
+    return false;
+  }
+
+  static bool isKnownGT(const TypeSize &LHS, const TypeSize &RHS) {
+    if (LHS.IsScalable || !RHS.IsScalable)
+      return LHS.MinSize > RHS.MinSize;
+
+    // LHS.IsScalable = false, RHS.IsScalable = true
+    return false;
+  }
+
+  static bool isKnownLE(const TypeSize &LHS, const TypeSize &RHS) {
+    if (!LHS.IsScalable || RHS.IsScalable)
+      return LHS.MinSize <= RHS.MinSize;
+
+    // LHS.IsScalable = true, RHS.IsScalable = false
+    return false;
+  }
+
+  static bool isKnownGE(const TypeSize &LHS, const TypeSize &RHS) {
+    if (LHS.IsScalable || !RHS.IsScalable)
+      return LHS.MinSize >= RHS.MinSize;
+
+    // LHS.IsScalable = false, RHS.IsScalable = true
+    return false;
+  }
+
   friend bool operator<(const TypeSize &LHS, const TypeSize &RHS) {
     assert(LHS.IsScalable == RHS.IsScalable &&
            "Ordering comparison of scalable and fixed types");
 
     return LHS.MinSize < RHS.MinSize;
   }
 
   friend bool operator>(const TypeSize &LHS, const TypeSize &RHS) {