[CodeGen] Fix warnings in foldCONCAT_VECTORS

[david-arm]

Summary

Instead of asserting the number of elements is the same, we should be
comparing the element counts instead. In addition, when looking at
concats of extract_subvectors it's fine to use getVectorMinNumElements()
for scalable vectors.

I discovered these warnings when compiling the structured loads tests in
this file:

test/CodeGen/AArch64/sve-intrinsics-loads.ll

[RKSimon]

test/CodeGen/AArch64/sve-intrinsics-loads.ll

These currently pass in trunk (with assertions enabled) - do you have additional test cases that fail that can you add?

[efriedma]

Currently, getVectorNumElements() on a scalable vector prints a warning to stderr instead of asserting. This is a temporary state, while we fix enough of the code to get simple regression tests working without triggering the warning; we eventually plan to make this an assertion.

So the only consequence of this patch at the moment is reducing the number of warnings printed.

[RKSimon]

Thanks for the explanation - LGTM

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

static SDValue foldCONCAT_VECTORS(const SDLoc &DL, EVT VT,
                                   ArrayRef<SDValue> Ops,
                                   SelectionDAG &DAG) {
   assert(!Ops.empty() && "Can't concatenate an empty list of vectors!");
   assert(llvm::all_of(Ops,
                       [Ops](SDValue Op) {
                         return Ops[0].getValueType() == Op.getValueType();
                       }) &&
          "Concatenation of vectors with inconsistent value types!");
-  assert((Ops.size() * Ops[0].getValueType().getVectorNumElements()) ==
-             VT.getVectorNumElements() &&
+  assert((Ops[0].getValueType().getVectorElementCount() * Ops.size()) ==
+             VT.getVectorElementCount() &&
          "Incorrect element count in vector concatenation!");
 
   if (Ops.size() == 1)
     return Ops[0];
 
   // Concat of UNDEFs is UNDEF.
   if (llvm::all_of(Ops, [](SDValue Op) { return Op.isUndef(); }))
     return DAG.getUNDEF(VT);
 
   // Scan the operands and look for extract operations from a single source
   // that correspond to insertion at the same location via this concatenation:
   // concat (extract X, 0*subvec_elts), (extract X, 1*subvec_elts), ...
   SDValue IdentitySrc;
   bool IsIdentity = true;
   for (unsigned i = 0, e = Ops.size(); i != e; ++i) {
     SDValue Op = Ops[i];
-    unsigned IdentityIndex = i * Op.getValueType().getVectorNumElements();
+    unsigned IdentityIndex = i * Op.getValueType().getVectorMinNumElements();
     if (Op.getOpcode() != ISD::EXTRACT_SUBVECTOR ||
         Op.getOperand(0).getValueType() != VT ||
         (IdentitySrc && Op.getOperand(0) != IdentitySrc) ||
         Op.getConstantOperandVal(1) != IdentityIndex) {
       IsIdentity = false;
       break;
     }
     assert((!IdentitySrc || IdentitySrc == Op.getOperand(0)) &&
            "Unexpected identity source vector for concat of extracts");
     IdentitySrc = Op.getOperand(0);
   }
   if (IsIdentity) {
     assert(IdentitySrc && "Failed to set source vector of extracts");
     return IdentitySrc;
   }
 
+  // The code below this point is only designed to work for fixed width
+  // vectors, so we bail out for now.
+  if (VT.isScalableVector())
+    return SDValue();
+
   // A CONCAT_VECTOR with all UNDEF/BUILD_VECTOR operands can be
   // simplified to one big BUILD_VECTOR.
   // FIXME: Add support for SCALAR_TO_VECTOR as well.
   EVT SVT = VT.getScalarType();
   SmallVector<SDValue, 16> Elts;
   for (SDValue Op : Ops) {
     EVT OpVT = Op.getValueType();
     if (Op.isUndef())