[MVT][SVE] Scalable vector MVTs (1/3)

[huntergr]

Summary

This patch adds a few helper functions to obtain new vector
value types based on existing ones without needing to care
about whether they are scalable or not.

I've confined their use to a few common locations right now,
and targets that don't have scalable vectors should never
need to care about these.

[rengolin]

include/llvm/CodeGen/ValueTypes.h

318 ↗

(On Diff #95128)

I know it's for completeness, but you don't need this function, better not create it at this time.

[RKSimon]

include/llvm/CodeGen/ValueTypes.h

311 ↗

(On Diff #95128)

assert that the size is even? Also, we don't seem to have a use for this function yet?

329 ↗

(On Diff #95128)

Use unsigned for clarity and assert that its even? The asserts in LegalizeVectorTypes.cpp and SelectionDAG.cpp can then be dropped

[huntergr]

include/llvm/CodeGen/ValueTypes.h

311 ↗

(On Diff #95128)

As with the other function below, it would be used later, but I'll delay it until that patch.

318 ↗

(On Diff #95128)

It'll be used later (in the AArch64 backend), but ok, will remove until that later patch.

329 ↗

(On Diff #95128)

So the reason for the 'auto' is that this will be converted to use MVT::ElementCount in patch 3, so that it works with scalable vectors; you're right that I can move the assert about even numbers of elements here, though.

[huntergr]

Removed unused functions, moved assert on halving the number of elements when there's an odd element count.

[RKSimon]

LGTM with one minor

include/llvm/CodeGen/ValueTypes.h

314 ↗

(On Diff #95713)

Use EltCnt directly?

[rengolin]

Looks good to me to, but, what about tests?

[huntergr]

In D32017#730310, @rengolin wrote:

Looks good to me to, but, what about tests?

This is effectively an NFC patch, as are the other two -- there's no way to test the scalable aspect of this code until a backend (AArch64) implements them. All existing code using the functions works, though.

[rengolin]

Right, this one is ok, but the other two patches also don't have tests either, and they're certainly not NFC.

I'm not sure how to test them, though.

llvm/trunk/include/llvm/CodeGen/ValueTypes.h

public:
     /// Return a VT for an integer vector type with the size of the
     /// elements doubled. The typed returned may be an extended type.
     EVT widenIntegerVectorElementType(LLVMContext &Context) const {
       EVT EltVT = getVectorElementType();
       EltVT = EVT::getIntegerVT(Context, 2 * EltVT.getSizeInBits());
       return EVT::getVectorVT(Context, EltVT, getVectorNumElements());
     }
 
+    // Return a VT for a vector type with the same element type but
+    // half the number of elements. The type returned may be an
+    // extended type.
+    EVT getHalfNumVectorElementsVT(LLVMContext &Context) const {
+      EVT EltVT = getVectorElementType();
+      auto EltCnt = getVectorNumElements();
+      assert(!(getVectorNumElements() & 1) &&
+             "Splitting vector, but not in half!");
+      return EVT::getVectorVT(Context, EltVT, EltCnt / 2);
+    }
+
     /// Returns true if the given vector is a power of 2.
     bool isPow2VectorType() const {
       unsigned NElts = getVectorNumElements();
       return !(NElts & (NElts - 1));
     }
 
     /// Widens the length of the given vector EVT up to the nearest power of 2
     /// and returns that type.

llvm/trunk/lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp

void DAGTypeLegalizer::SplitVecRes_ExtendOp(SDNode *N, SDValue &Lo,
   // This won't necessarily completely legalize the operation, but it will
   // more effectively move in the right direction and prevent falling down
   // to scalarization in many cases due to the input vector being split too
   // far.
   unsigned NumElements = SrcVT.getVectorNumElements();
   if ((NumElements & 1) == 0 &&
       SrcVT.getSizeInBits() * 2 < DestVT.getSizeInBits()) {
     LLVMContext &Ctx = *DAG.getContext();
-    EVT NewSrcVT = EVT::getVectorVT(
-        Ctx, EVT::getIntegerVT(
-                 Ctx, SrcVT.getScalarSizeInBits() * 2),
-        NumElements);
-    EVT SplitSrcVT =
-        EVT::getVectorVT(Ctx, SrcVT.getVectorElementType(), NumElements / 2);
+    EVT NewSrcVT = SrcVT.widenIntegerVectorElementType(Ctx);
+    EVT SplitSrcVT = SrcVT.getHalfNumVectorElementsVT(Ctx);
+
     EVT SplitLoVT, SplitHiVT;
     std::tie(SplitLoVT, SplitHiVT) = DAG.GetSplitDestVTs(NewSrcVT);
     if (TLI.isTypeLegal(SrcVT) && !TLI.isTypeLegal(SplitSrcVT) &&
         TLI.isTypeLegal(NewSrcVT) && TLI.isTypeLegal(SplitLoVT)) {
       DEBUG(dbgs() << "Split vector extend via incremental extend:";
             N->dump(&DAG); dbgs() << "\n");
       // Extend the source vector by one step.
       SDValue NewSrc =
SDValue DAGTypeLegalizer::WidenVSELECTAndMask(SDNode *N) {
   EVT VSelVT = N->getValueType(0);
   // Only handle vector types which are a power of 2.
   if (!isPowerOf2_64(VSelVT.getSizeInBits()))
     return SDValue();
 
   // Don't touch if this will be scalarized.
   EVT FinalVT = VSelVT;
   while (getTypeAction(FinalVT) == TargetLowering::TypeSplitVector)
-    FinalVT = EVT::getVectorVT(Ctx, FinalVT.getVectorElementType(),
-                               FinalVT.getVectorNumElements() / 2);
+    FinalVT = FinalVT.getHalfNumVectorElementsVT(Ctx);
+
   if (FinalVT.getVectorNumElements() == 1)
     return SDValue();
 
   // If there is support for an i1 vector mask, don't touch.
   if (Cond.getOpcode() == ISD::SETCC) {
     EVT SetCCOpVT = Cond->getOperand(0).getValueType();
     while (TLI.getTypeAction(Ctx, SetCCOpVT) != TargetLowering::TypeLegal)
       SetCCOpVT = TLI.getTypeToTransformTo(Ctx, SetCCOpVT);

llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

unsigned SelectionDAG::InferPtrAlignment(SDValue Ptr) const {
   return 0;
 }
 
 /// GetSplitDestVTs - Compute the VTs needed for the low/hi parts of a type
 /// which is split (or expanded) into two not necessarily identical pieces.
 std::pair<EVT, EVT> SelectionDAG::GetSplitDestVTs(const EVT &VT) const {
   // Currently all types are split in half.
   EVT LoVT, HiVT;
-  if (!VT.isVector()) {
+  if (!VT.isVector())
     LoVT = HiVT = TLI->getTypeToTransformTo(*getContext(), VT);
-  } else {
-    unsigned NumElements = VT.getVectorNumElements();
-    assert(!(NumElements & 1) && "Splitting vector, but not in half!");
-    LoVT = HiVT = EVT::getVectorVT(*getContext(), VT.getVectorElementType(),
-                                   NumElements/2);
-  }
+  else
+    LoVT = HiVT = VT.getHalfNumVectorElementsVT(*getContext());
+
   return std::make_pair(LoVT, HiVT);
 }
 
 /// SplitVector - Split the vector with EXTRACT_SUBVECTOR and return the
 /// low/high part.
 std::pair<SDValue, SDValue>
 SelectionDAG::SplitVector(const SDValue &N, const SDLoc &DL, const EVT &LoVT,
                           const EVT &HiVT) {