[CodeGen] Use SPLAT_VECTOR for zeroinitialiser with scalable types

[david-arm]

Summary

When generating code for the LLVM IR zeroinitialiser operation, if
the vector type is scalable we should be using SPLAT_VECTOR instead
of BUILD_VECTOR.

[sdesmalen]

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

1561

D77587 introduced FixedVectorType and ScalableVectorType, which means you can instead write:

cast<FixedVectorType>(VecTy)->getNumElements()

That also removes the need for an additional assert.

1569

I'd prefer to see the Scalable and FixedWidth cases more separated here, something like

if (isa<ScalableVectorType>(...))
  // Op = splat vector
else {
  if (EltVT.isFloatingPoint())
    ...
  ...
}

1574

You can then write:

if (isa<ScalableVectorType>(VecTy))
  Op = DAG.getSplatVector(VT, getCurSDLoc(), Op);

[david-arm]

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

1561

OK sure. It's just that I already got the ElementCount above from VecTy so I wasn't sure it was worth casting VecTy to a FixedVectorType here - it seemd a bit redundant. What's the preferred style in general here? Avoiding using ElementCount wherever possible and cast to Fixed and Scalable types? It would be good to have a consistent style because there are two ways of reaching the same answer.

1569

I'm not sure what you mean here. Are you suggesting duplicating the code into two separate cases? We still need to check whether it is floating point in either case, Wouldn't this be better?

assert(isa<ConstantAggregateZero>(C) && "Unknown vector constant!");
EVT EltVT =
    TLI.getValueType(DAG.getDataLayout(), VecTy->getElementType());

SDValue Op;
if (EltVT.isFloatingPoint())
  Op = DAG.getConstantFP(0, getCurSDLoc(), EltVT);
else
  Op = DAG.getConstant(0, getCurSDLoc(), EltVT);

if (isa<ScalableVectorType>(VecTy))
  return NodeMap[V] = DAG.getSplatVector(VT, getCurSDLoc(), Op);

...  Continue as normal for FixedVectorType

[sdesmalen]

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

1561

@ctetreau touched on that a bit on the mailing list yesterday, see http://lists.llvm.org/pipermail/llvm-dev/2020-April/141162.html.

AIUI:

• If the code only cares about fixed width vectors, use FixedVectorType and getNumElements.
• If the code only cares about scalable vectors, use ScalableVectorType and getMinNumElements or getElementCount.
• If the code cares about both, use VectorType and getElementCount.

1569

You're right, I misread this code.

In that case, does it make sense to move the return from this function into the branches, so that you get:

 if (constantVector) {
  ...
  return DAG.getBuildVector(..)
} else if (ConstantAggregateZero) {
  ...
  if (isa<ScalableVector>(..))
    return DAG.getSplatVector(..)
  else
    return DAG.getBuildVector(..);
}
llvm_unreachable("Unknown vector constant")

[sdesmalen]

LGTM

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

1579

nit: unnecessary newline.

1583

nit: the else is not necessary here.

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

bool SelectionDAG::haveNoCommonBitsSet(SDValue A, SDValue B) const {
   return (computeKnownBits(A).Zero | computeKnownBits(B).Zero).isAllOnesValue();
 }
 
 static SDValue FoldBUILD_VECTOR(const SDLoc &DL, EVT VT,
                                 ArrayRef<SDValue> Ops,
                                 SelectionDAG &DAG) {
   int NumOps = Ops.size();
   assert(NumOps != 0 && "Can't build an empty vector!");
+  assert(!VT.isScalableVector() &&
+         "BUILD_VECTOR cannot be used with scalable types");
   assert(VT.getVectorNumElements() == (unsigned)NumOps &&
          "Incorrect element count in BUILD_VECTOR!");
 
   // BUILD_VECTOR of UNDEFs is UNDEF.
   if (llvm::all_of(Ops, [](SDValue Op) { return Op.isUndef(); }))
     return DAG.getUNDEF(VT);
 
   // BUILD_VECTOR of seq extract/insert from the same vector + type is Identity.

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

if (C->getType()->isStructTy() || C->getType()->isArrayTy()) {
 
       return DAG.getMergeValues(Constants, getCurSDLoc());
     }
 
     if (const BlockAddress *BA = dyn_cast<BlockAddress>(C))
       return DAG.getBlockAddress(BA, VT);
 
     VectorType *VecTy = cast<VectorType>(V->getType());
-    unsigned NumElements = VecTy->getNumElements();
 
     // Now that we know the number and type of the elements, get that number of
     // elements into the Ops array based on what kind of constant it is.
-    SmallVector<SDValue, 16> Ops;
     if (const ConstantVector *CV = dyn_cast<ConstantVector>(C)) {
+      SmallVector<SDValue, 16> Ops;
+      unsigned NumElements = cast<FixedVectorType>(VecTy)->getNumElements();
       for (unsigned i = 0; i != NumElements; ++i)
         Ops.push_back(getValue(CV->getOperand(i)));
-    } else {
-      assert(isa<ConstantAggregateZero>(C) && "Unknown vector constant!");
+
+      return NodeMap[V] = DAG.getBuildVector(VT, getCurSDLoc(), Ops);
+    } else if (isa<ConstantAggregateZero>(C)) {
       EVT EltVT =
           TLI.getValueType(DAG.getDataLayout(), VecTy->getElementType());
 
       SDValue Op;
       if (EltVT.isFloatingPoint())
         Op = DAG.getConstantFP(0, getCurSDLoc(), EltVT);
       else
         Op = DAG.getConstant(0, getCurSDLoc(), EltVT);
-      Ops.assign(NumElements, Op);
-    }
 
-    // Create a BUILD_VECTOR node.
+      if (isa<ScalableVectorType>(VecTy))
+        return NodeMap[V] = DAG.getSplatVector(VT, getCurSDLoc(), Op);
+      else {
+        SmallVector<SDValue, 16> Ops;
+        Ops.assign(cast<FixedVectorType>(VecTy)->getNumElements(), Op);
         return NodeMap[V] = DAG.getBuildVector(VT, getCurSDLoc(), Ops);
       }
+    }
+    llvm_unreachable("Unknown vector constant");
+  }
 
   // If this is a static alloca, generate it as the frameindex instead of
   // computation.
   if (const AllocaInst *AI = dyn_cast<AllocaInst>(V)) {
     DenseMap<const AllocaInst*, int>::iterator SI =
       FuncInfo.StaticAllocaMap.find(AI);
     if (SI != FuncInfo.StaticAllocaMap.end())
       return DAG.getFrameIndex(SI->second,