[SelectionDAG] Update getNode asserts for EXTRACT/INSERT_SUBVECTOR.

[paulwalker-arm]

Summary

The description of EXTACT_SUBVECTOR and INSERT_SUBVECTOR has been
changed to accommodate scalable vectors (see ISDOpcodes.h). This
patch updates the asserts used to verify these requirements when
using SelectionDAG's getNode interface.

This patch introduces the MVT function getVectorMinNumElements
that can be used against fixed-length and scalable vectors when
only the known minimum vector length is required.

[paulwalker-arm]

I'm waiting on a FileCheck patch to land before the fixed width code generation for SVE patches can move on so I've broken some assert fixes out of D80385 to help protect future work. There's no new tests as the core logic is already tested and D80385 is required to exercise the corner cases.

[david-arm]

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

5471

This suggests we permit fixed width vectors of arbitrary length being extracted as subvectors from a scalable vector. That's ok, but presumably we'll need to support that in the backend too with appropriate undefs being used to fill in the parts that exceed the bounds of the scalable vector.

5679

Same as above, this suggets we permit arbitrarily large fixed width vectors being inserted into a scalable vector.

[paulwalker-arm]

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

5471

Yes and no. We do permit the extraction of an arbitrary length fixed length vector from a scalable vector but the requirement that the extracted vector must be smaller than the source vector stands. As does the requirement for there to be no overflow. It's just that we cannot protect against those invalid use cases with a compiler time assert.

[sdesmalen]

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

5471

In D79806 we've defined insert/extract_subvector such that the result vector can be considered undefined if it is inserting/extracting beyond the valid runtime vector length.

/// Elements IDX through (IDX + num_elements(T) - 1) must be valid VECTOR1
/// indices. If this condition cannot be determined statically but is false at
/// runtime, then the result vector is undefined.

[efriedma]

LGTM

llvm/include/llvm/CodeGen/ValueTypes.h

#endif
     ElementCount getVectorElementCount() const {
       assert((isVector()) && "Invalid vector type!");
       if (isSimple())
         return V.getVectorElementCount();
 
       return {getExtendedVectorNumElements(), isExtendedScalableVector()};
     }
 
+    /// Given a vector type, return the minimum number of elements it contains.
+    unsigned getVectorMinNumElements() const {
+      return getVectorElementCount().Min;
+    }
+
     /// Return the size of the specified value type in bits.
     ///
     /// If the value type is a scalable vector type, the scalable property will
     /// be set and the runtime size will be a positive integer multiple of the
     /// base size.
     TypeSize getSizeInBits() const {
       if (isSimple())
         return V.getSizeInBits();

llvm/include/llvm/Support/MachineValueType.h

unsigned getVectorNumElements() const {
       case nxv1f64: return 1;
       }
     }
 
     ElementCount getVectorElementCount() const {
       return { getVectorNumElements(), isScalableVector() };
     }
 
+    /// Given a vector type, return the minimum number of elements it contains.
+    unsigned getVectorMinNumElements() const {
+      return getVectorElementCount().Min;
+    }
+
     /// Returns the size of the specified MVT in bits.
     ///
     /// If the value type is a scalable vector type, the scalable property will
     /// be set and the runtime size will be a positive integer multiple of the
     /// base size.
     TypeSize getSizeInBits() const {
       switch (SimpleTy) {
       default:

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

case ISD::EXTRACT_ELEMENT:
     if (N1C) {
       unsigned ElementSize = VT.getSizeInBits();
       unsigned Shift = ElementSize * N2C->getZExtValue();
       APInt ShiftedVal = N1C->getAPIntValue().lshr(Shift);
       return getConstant(ShiftedVal.trunc(ElementSize), DL, VT);
     }
     break;
   case ISD::EXTRACT_SUBVECTOR:
-    assert(VT.isVector() && N1.getValueType().isVector() &&
-           "Extract subvector VTs must be a vectors!");
-    assert(VT.getVectorElementType() ==
-               N1.getValueType().getVectorElementType() &&
+    EVT N1VT = N1.getValueType();
+    assert(VT.isVector() && N1VT.isVector() &&
+           "Extract subvector VTs must be vectors!");
+    assert(VT.getVectorElementType() == N1VT.getVectorElementType() &&
            "Extract subvector VTs must have the same element type!");
-    assert(VT.getVectorNumElements() <=
-               N1.getValueType().getVectorNumElements() &&
+    assert((VT.isFixedLengthVector() || N1VT.isScalableVector()) &&
+           "Cannot extract a scalable vector from a fixed length vector!");
+    assert((VT.isScalableVector() != N1VT.isScalableVector() ||
+            VT.getVectorMinNumElements() <= N1VT.getVectorMinNumElements()) &&
            "Extract subvector must be from larger vector to smaller vector!");
     assert(N2C && "Extract subvector index must be a constant");
-    assert(VT.getVectorNumElements() + N2C->getZExtValue() <=
-               N1.getValueType().getVectorNumElements() &&
+    assert((VT.isScalableVector() != N1VT.isScalableVector() ||
+            (VT.getVectorMinNumElements() + N2C->getZExtValue()) <=
+                N1VT.getVectorMinNumElements()) &&
            "Extract subvector overflow!");
 
     // Trivial extraction.
-    if (VT == N1.getValueType())
+    if (VT == N1VT)
       return N1;
 
     // EXTRACT_SUBVECTOR of an UNDEF is an UNDEF.
     if (N1.isUndef())
       return getUNDEF(VT);
 
     // EXTRACT_SUBVECTOR of CONCAT_VECTOR can be simplified if the pieces of
     // the concat have the same type as the extract.
if (N2.isUndef())
       return N1;
 
     break;
   }
   case ISD::INSERT_SUBVECTOR: {
     // Inserting undef into undef is still undef.
     if (N1.isUndef() && N2.isUndef())
       return getUNDEF(VT);
-    assert(VT.isVector() && N1.getValueType().isVector() &&
-           N2.getValueType().isVector() &&
-           "Insert subvector VTs must be a vectors");
+
+    EVT N2VT = N2.getValueType();
     assert(VT == N1.getValueType() &&
            "Dest and insert subvector source types must match!");
-    assert(N2.getSimpleValueType() <= N1.getSimpleValueType() &&
+    assert(VT.isVector() && N2VT.isVector() &&
+           "Insert subvector VTs must be vectors!");
+    assert((VT.isScalableVector() || N2VT.isFixedLengthVector()) &&
+           "Cannot insert a scalable vector into a fixed length vector!");
+    assert((VT.isScalableVector() != N2VT.isScalableVector() ||
+            VT.getVectorMinNumElements() >= N2VT.getVectorMinNumElements()) &&
            "Insert subvector must be from smaller vector to larger vector!");
     assert(isa<ConstantSDNode>(N3) &&
            "Insert subvector index must be constant");
-    assert(N2.getValueType().getVectorNumElements() +
-                   cast<ConstantSDNode>(N3)->getZExtValue() <=
-               VT.getVectorNumElements() &&
+    assert((VT.isScalableVector() != N2VT.isScalableVector() ||
+            (N2VT.getVectorMinNumElements() +
+             cast<ConstantSDNode>(N3)->getZExtValue()) <=
+                VT.getVectorMinNumElements()) &&
            "Insert subvector overflow!");
 
     // Trivial insertion.
-    if (VT == N2.getValueType())
+    if (VT == N2VT)
       return N2;
 
     // If this is an insert of an extracted vector into an undef vector, we
     // can just use the input to the extract.
     if (N1.isUndef() && N2.getOpcode() == ISD::EXTRACT_SUBVECTOR &&
         N2.getOperand(1) == N3 && N2.getOperand(0).getValueType() == VT)
       return N2.getOperand(0);
     break;