[CodeGen] Refactor ExpandBVWithShuffles. NFC.

[HanKuanChen]

Summary

Phase 0 is used to detect whether a vector_shuffle is supported. But we
can check a vector_shuffle is legal just before calling
getVectorShuffle.

[spatel]

LGTM - seems like a nice cleanup.

llvm/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp

 //===- LegalizeDAG.cpp - Implement SelectionDAG::Legalize -----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
ExpandBVWithShuffles(SDNode *Node, SelectionDAG &DAG,
   SDLoc dl(Node);
   EVT VT = Node->getValueType(0);
 
   // Try to group the scalars into pairs, shuffle the pairs together, then
   // shuffle the pairs of pairs together, etc. until the vector has
   // been built. This will work only if all of the necessary shuffle masks
   // are legal.
 
-  // We do this in two phases; first to check the legality of the shuffles,
-  // and next, assuming that all shuffles are legal, to create the new nodes.
-  for (int Phase = 0; Phase < 2; ++Phase) {
-    SmallVector<std::pair<SDValue, SmallVector<int, 16>>, 16> IntermedVals,
-                                                              NewIntermedVals;
-    for (unsigned i = 0; i < NumElems; ++i) {
-      SDValue V = Node->getOperand(i);
-      if (V.isUndef())
-        continue;
 
-      SDValue Vec;
-      if (Phase)
-        Vec = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, V);
-      IntermedVals.push_back(std::make_pair(Vec, SmallVector<int, 16>(1, i)));
-    }
+    SDValue Vec = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, V);
 
-    while (IntermedVals.size() > 2) {
-      NewIntermedVals.clear();
-      for (unsigned i = 0, e = (IntermedVals.size() & ~1u); i < e; i += 2) {
-        // This vector and the next vector are shuffled together (simply to
-        // append the one to the other).
-        SmallVector<int, 16> ShuffleVec(NumElems, -1);
 
-        SmallVector<int, 16> FinalIndices;
-        FinalIndices.reserve(IntermedVals[i].second.size() +
-                             IntermedVals[i+1].second.size());
+                           IntermedVals[i + 1].second.size());
 
-        int k = 0;
-        for (unsigned j = 0, f = IntermedVals[i].second.size(); j != f;
-             ++j, ++k) {
-          ShuffleVec[k] = j;
-          FinalIndices.push_back(IntermedVals[i].second[j]);
-        }
-        for (unsigned j = 0, f = IntermedVals[i+1].second.size(); j != f;
-             ++j, ++k) {
-          ShuffleVec[k] = NumElems + j;
-          FinalIndices.push_back(IntermedVals[i+1].second[j]);
-        }
+      for (unsigned j = 0, f = IntermedVals[i + 1].second.size(); j != f;
+        FinalIndices.push_back(IntermedVals[i + 1].second[j]);
 
-        SDValue Shuffle;
-        if (Phase)
-          Shuffle = DAG.getVectorShuffle(VT, dl, IntermedVals[i].first,
-                                         IntermedVals[i+1].first,
-                                         ShuffleVec);
-        else if (!TLI.isShuffleMaskLegal(ShuffleVec, VT))
-          return false;
-        NewIntermedVals.push_back(
-            std::make_pair(Shuffle, std::move(FinalIndices)));
-      }
+      if (!TLI.isShuffleMaskLegal(ShuffleVec, VT))
+
+      SDValue Shuffle = DAG.getVectorShuffle(
+          VT, dl, IntermedVals[i].first, IntermedVals[i + 1].first, ShuffleVec);
 
-      // If we had an odd number of defined values, then append the last
-      // element to the array of new vectors.
-      if ((IntermedVals.size() & 1) != 0)
-        NewIntermedVals.push_back(IntermedVals.back());
 
-      IntermedVals.swap(NewIntermedVals);
-    }
 
-    assert(IntermedVals.size() <= 2 && IntermedVals.size() > 0 &&
-           "Invalid number of intermediate vectors");
-    SDValue Vec1 = IntermedVals[0].first;
-    SDValue Vec2;
-    if (IntermedVals.size() > 1)
-      Vec2 = IntermedVals[1].first;
-    else if (Phase)
-      Vec2 = DAG.getUNDEF(VT);
+  else
 
-    SmallVector<int, 16> ShuffleVec(NumElems, -1);
-    for (unsigned i = 0, e = IntermedVals[0].second.size(); i != e; ++i)
-      ShuffleVec[IntermedVals[0].second[i]] = i;
-    for (unsigned i = 0, e = IntermedVals[1].second.size(); i != e; ++i)
-      ShuffleVec[IntermedVals[1].second[i]] = NumElems + i;
 
-    if (Phase)
-      Res = DAG.getVectorShuffle(VT, dl, Vec1, Vec2, ShuffleVec);
-    else if (!TLI.isShuffleMaskLegal(ShuffleVec, VT))
-      return false;
-  }
+  if (!TLI.isShuffleMaskLegal(ShuffleVec, VT))
+  Res = DAG.getVectorShuffle(VT, dl, Vec1, Vec2, ShuffleVec);
 
   return true;
 }
 
 /// Expand a BUILD_VECTOR node on targets that don't
 /// support the operation, but do support the resultant vector type.
 SDValue SelectionDAGLegalize::ExpandBUILD_VECTOR(SDNode *Node) {
   unsigned NumElems = Node->getNumOperands();