[CodeGen] Fix warnings in getCopyFromPartsVector

[david-arm]

Summary

Replace some of the calls to getVectorNumElements() with
getVectorElementCount(). These warnings were being hit by
this test:

llvm/test/CodeGen/AArch64/sve-gep.ll

As part of this patch I have introduced another comparison
operator in ElementCount, namely to check if one count
is > than another. However, when doing mathematical
operations we do not always know the answer at compile
time and therefore we have two functions:

bool isGT(const ElementCount &RHS, bool &Known);
bool knownGT(const ElementCount &RHS);

The first function returns true if the answer is known at
compile time to be >, otherwise it returns false. The Known
boolean is set true if the answer is known at compile time.

The second function also does the comparison, but asserts
that the answer is known at compile time.

[rovka]

llvm/include/llvm/Support/TypeSize.h

56

Is it ever safe to ignore the value of Known? If not, I'd suggest making this method private so people are forced to use knownGT. Alternatively, you could define a 'compare' function and have it return an enum value saying Unknown, GT, LE etc.

64

To be honest I find this whole sequence a bit difficult to follow. Shouldn't Known only be true if LHS and RHS are either both scalable or both fixed? If so, then you can just say Known = (Scalable == RHS.Scalable). Similar to how it's handled for TypeSize. This looks like another argument in favor of the alternative design with an enum, which just separates these concerns and makes you decide up front whether or not it's possible to make the comparison.

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

443

If we know that the vector element types are the same, can't we just compare the type sizes here and piggy-back on the comparison operators we already have instead of adding new ones?

[david-arm]

I'll give this patch some more thought for now and see if I can just simply remove the assert in getCopy...

llvm/include/llvm/Support/TypeSize.h

56

I think it's more the other way around really. In many cases we will probably be trying to apply an optimisation based on whether the result is true or false. If the answer cannot be determined (Known=false), then we shouldn't be applying that transformation or going down that particular code path. I'll think more about this though and perhaps I can refactor the existing code in getCopyFromParts such that we don't even need to ask this question.

64

So the Min variable represents the absolute minimum number of elements. Therefore, when LHS is a fixed width vector the element count is guaranteed to always be <=the element count of RHS, regardless of whether it's scalable or not. Hence the odd looking code! I could always return "Known = false" when Scalable != RHS.Scalable, but I just thought we can cover more cases than that.

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

443

So we can't really piggyback on the TypeSize class here as they are quite different classes, although I could certainly duplicate the operators. The operators in TypeSize simply assert that both LHS and RHS are either fixed or scalable types. I guess this will often be the case, but is not guaranteed. To be honest, TypeSize and ElementCount will need to be refactored at some point to make use of some common base class.

[david-arm]

Already fixed by https://reviews.llvm.org/D80826

llvm/include/llvm/Support/TypeSize.h

public:
   }
 
   bool operator==(const ElementCount& RHS) const {
     return Min == RHS.Min && Scalable == RHS.Scalable;
   }
   bool operator!=(const ElementCount& RHS) const {
     return !(*this == RHS);
   }
+
+  // Returns true if the answer is known at compile time to be >, else we
+  // return false. Known is only set to false if we cannot prove we know the
+  // answer at compile time.
+  bool isGT(const ElementCount &RHS, bool &Known) {
+    bool Result;
+    if ((Scalable || !RHS.Scalable) && Min > RHS.Min)
+      Known = Result = true;
+    else if ((!Scalable || RHS.Scalable) && Min <= RHS.Min) {
+      Known = true;
+      Result = false;
+    } else
+      Known = Result = false;
+    return Result;
+  }
+
+  bool knownGT(const ElementCount &RHS) {
+    bool Known;
+    bool Result = isGT(RHS, Known);
+    assertKnown(Known);
+    return Result;
+  }
+
+private:
+  void assertKnown(bool Known) {
+    assert(Known && "Cannot compare element counts at runtime");
+  }
 };
 
 // This class 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 {
   uint64_t MinSize;   // The known minimum size.
   bool IsScalable;    // If true, then the runtime size is an integer multiple

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

static SDValue getCopyFromPartsVector(SelectionDAG &DAG, const SDLoc &DL,
   if (PartEVT == ValueVT)
     return Val;
 
   if (PartEVT.isVector()) {
     // If the element type of the source/dest vectors are the same, but the
     // parts vector has more elements than the value vector, then we have a
     // vector widening case (e.g. <2 x float> -> <4 x float>).  Extract the
     // elements we want.
+    ElementCount PartEC = PartEVT.getVectorElementCount();
+    ElementCount ValueEC = ValueVT.getVectorElementCount();
     if (PartEVT.getVectorElementType() == ValueVT.getVectorElementType()) {
-      assert(PartEVT.getVectorNumElements() > ValueVT.getVectorNumElements() &&
+      assert(PartEC.knownGT(ValueEC) &&
              "Cannot narrow, it would be a lossy transformation");
       return DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, ValueVT, Val,
                          DAG.getVectorIdxConstant(0, DL));
     }
 
     // Vector/Vector bitcast.
     if (ValueVT.getSizeInBits() == PartEVT.getSizeInBits())
       return DAG.getNode(ISD::BITCAST, DL, ValueVT, Val);
 
-    assert(PartEVT.getVectorNumElements() == ValueVT.getVectorNumElements() &&
-      "Cannot handle this kind of promotion");
+    assert(PartEC == ValueEC && "Cannot handle this kind of promotion");
     // Promoted vector extract
     return DAG.getAnyExtOrTrunc(Val, DL, ValueVT);
 
   }
 
   // Trivial bitcast if the types are the same size and the destination
   // vector type is legal.
   if (PartEVT.getSizeInBits() == ValueVT.getSizeInBits() &&