[WIP][DAGCombiner] createBuildVecShuffle(): more vector concatenation

[lebedev.ri]

Summary

While i'm quite sure this is correct and optimal,
i'm having trouble coming up with a test case to demonstrate this.

llvm-stress provided a few snippets that showcase codegen differences
(https://godbolt.org/z/7G3T45cxq), but i can't quite turn them into something reasonable that i feel ok using as a codegen test :)

[lebedev.ri]

@RKSimon there are two changes here:

1. InVT2Size * 2 == VTSize && InVT1Size == VTSize -> (VTSize % InVT2Size == 0) && InVT1Size == VTSize
2. merging two blocks together.

Could you please specify if you'd like to have them separately, or bundled is fine?
Theoretically, both are testable separately, but coming up with test[s] will be comutational-expensive,
so i'd like to know how to proceed.

[lebedev.ri]

Wuld be good to have this, but this still needs test.

llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp

SDValue DAGCombiner::createBuildVecShuffle(const SDLoc &DL, SDNode *N,
   uint64_t InVT2Size = InVT2.getFixedSizeInBits();
 
   assert(InVT2Size <= InVT1Size &&
          "Inputs must be sorted to be in non-increasing vector size order.");
 
   // We can't generate a shuffle node with mismatched input and output types.
   // Try to make the types match the type of the output.
   if (InVT1 != VT || InVT2 != VT) {
-    if ((VTSize % InVT1Size == 0) && InVT1 == InVT2) {
-      // If the output vector length is a multiple of both input lengths,
-      // we can concatenate them and pad the rest with undefs.
+    if ((VTSize % InVT1Size == 0) && (InVT1Size % InVT2Size == 0)) {
+      // If the output vector length is a multiple of first input length, and
+      // the first vector length is a multiple of second input length, then we
+      // can firstly pad the second input until it's length equates with the
+      // length of first input, and afterwards, if their lenghts aren't equal
+      // to the output vector length, then concatenate them and pad the rest.
+      if (InVT2Size != InVT1Size) {
+        unsigned NumConcats = InVT1Size / InVT2Size;
+        assert(NumConcats >= 2 && "Concat needs at least two inputs!");
+        SmallVector<SDValue, 2> ConcatOps(NumConcats, DAG.getUNDEF(InVT2));
+        ConcatOps[0] = VecIn2;
+        VecIn2 = DAG.getNode(ISD::CONCAT_VECTORS, DL, InVT1, ConcatOps);
+        InVT2 = VecIn2.getValueType();
+        InVT2Size = InVT2.getFixedSizeInBits();
+      }
+      assert(InVT1Size == InVT2Size && "The inputs now have the same length.");
+
+      if (InVT1Size != VTSize) {
         unsigned NumConcats = VTSize / InVT1Size;
         assert(NumConcats >= 2 && "Concat needs at least two inputs!");
         SmallVector<SDValue, 2> ConcatOps(NumConcats, DAG.getUNDEF(InVT1));
         ConcatOps[0] = VecIn1;
-      ConcatOps[1] = VecIn2 ? VecIn2 : DAG.getUNDEF(InVT1);
+        if (VecIn2)
+          ConcatOps[1] = VecIn2;
         VecIn1 = DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, ConcatOps);
         VecIn2 = SDValue();
+      }
     } else if (InVT1Size == VTSize * 2) {
       if (!TLI.isExtractSubvectorCheap(VT, InVT1, NumElems))
         return SDValue();
 
       if (!VecIn2.getNode()) {
         // If we only have one input vector, and it's twice the size of the
         // output, split it in two.
         VecIn2 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, VecIn1,
if ((VTSize % InVT1Size == 0) && (InVT1Size % InVT2Size == 0)) {
         if (InVT1 != InVT2) {
           if (!TLI.isTypeLegal(InVT2))
             return SDValue();
           VecIn2 = DAG.getNode(ISD::INSERT_SUBVECTOR, DL, InVT1,
                                DAG.getUNDEF(InVT1), VecIn2, ZeroIdx);
         }
         ShuffleNumElems = NumElems * 2;
       }
-    } else if (InVT2Size * 2 == VTSize && InVT1Size == VTSize) {
-      SmallVector<SDValue, 2> ConcatOps(2, DAG.getUNDEF(InVT2));
-      ConcatOps[0] = VecIn2;
-      VecIn2 = DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, ConcatOps);
     } else {
       // TODO: Support cases where the length mismatch isn't exactly by a
       // factor of 2.
       // TODO: Move this check upwards, so that if we have bad type
       // mismatches, we don't create any DAG nodes.
       return SDValue();
     }
   }