[LegalizeVectorOps] Expand MERGE_VALUES created by custom legalization immediately

[craig.topper]

Summary

This matches what we do in LegalizeDAG. This is based on D72224. I had to modify the Custom handling code from that again to support MERGE_VALUES being disintegrated.

[RKSimon]

llvm/lib/CodeGen/SelectionDAG/LegalizeVectorOps.cpp

843

e = Node->getNumValues(); i != e

[craig.topper]

Committed a version of this in ddfcd82bdc219dd2dc04d6826c417cea3da65d12.

llvm/lib/CodeGen/SelectionDAG/LegalizeVectorOps.cpp

if (LD->getMemoryVT().isVector() && ExtType != ISD::NON_EXTLOAD) {
       default: llvm_unreachable("This action is not supported yet!");
       case TargetLowering::Legal:
         return TranslateLegalizeResults(Op, Node);
       case TargetLowering::Custom:
         if (SDValue Lowered = TLI.LowerOperation(SDValue(Node, 0), DAG)) {
           assert(Lowered->getNumValues() == Op->getNumValues() &&
                  "Unexpected number of results");
           if (Lowered != SDValue(Node, 0)) {
-            // Make sure the new code is also legal.
-            Lowered = LegalizeOp(Lowered);
             Changed = true;
+
+            // Make sure the new code is also legal.
+            for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i)
+              AddLegalizedOperand(Op.getValue(i),
+                                  LegalizeOp(Lowered.getValue(i)));
+
+            // Map was updated above, return corresponding result.
+            return LegalizedNodes[Op];
           }
           return TranslateLegalizeResults(Op, Lowered.getNode());
         }
         LLVM_FALLTHROUGH;
       case TargetLowering::Expand: {
         Changed = true;
         std::pair<SDValue, SDValue> Tmp = ExpandLoad(Node);
         AddLegalizedOperand(Op.getValue(0), Tmp.first);
#include "llvm/IR/ConstrainedOps.def"
   case ISD::VECREDUCE_UMIN:
   case ISD::VECREDUCE_FADD:
   case ISD::VECREDUCE_FMUL:
   case ISD::VECREDUCE_FMAX:
   case ISD::VECREDUCE_FMIN:
     Action = TLI.getOperationAction(Node->getOpcode(),
                                     Node->getOperand(0).getValueType());
     break;
+  case ISD::MERGE_VALUES:
+    Action = TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0));
+    // This operation lies about being legal: when they claim to be legal,
+    // they should actually be expanded.
+    if (Action == TargetLowering::Legal)
+      Action = TargetLowering::Expand;
   }
 
   LLVM_DEBUG(dbgs() << "\nLegalizing vector op: "; Node->dump(&DAG));
 
   switch (Action) {
   default: llvm_unreachable("This action is not supported yet!");
   case TargetLowering::Promote: {
     LLVM_DEBUG(dbgs() << "Promoting\n");
     return Promote(Node, Op.getResNo());
   }
   case TargetLowering::Legal:
     LLVM_DEBUG(dbgs() << "Legal node: nothing to do\n");
     TranslateLegalizeResults(Op, Node);
     return SDValue(Node, Op.getResNo());
   case TargetLowering::Custom: {
     LLVM_DEBUG(dbgs() << "Trying custom legalization\n");
     if (SDValue Tmp = TLI.LowerOperation(SDValue(Node, 0), DAG)) {
       LLVM_DEBUG(dbgs() << "Successfully custom legalized node\n");
       if (Tmp != SDValue(Node, 0)) {
-        // Make sure that the generated code is itself legal.
-        Tmp = LegalizeOp(Tmp);
         Changed = true;
-      }
 
         // Tmp might point to a single result from a multi result node, in that
         // case we need to use it's result number.
         if (Node->getNumValues() == 1) {
+          Tmp = LegalizeOp(Tmp);
           AddLegalizedOperand(Op, Tmp);
           return Tmp;
         }
 
         // Otherwise it should be a multi-result node with the same number of
         // results.
         assert(Tmp->getNumValues() == Node->getNumValues() &&
                "Unexpected number of results");
+
+        for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i)
+          AddLegalizedOperand(Op.getValue(i), LegalizeOp(Tmp.getValue(i)));
+
+        // Map was updated above, return corresponding result.
+        return LegalizedNodes[Op];
+      }
+
       return TranslateLegalizeResults(Op, Tmp.getNode());
     }
     LLVM_DEBUG(dbgs() << "Could not custom legalize node\n");
     LLVM_FALLTHROUGH;
   }
   case TargetLowering::Expand:
     LLVM_DEBUG(dbgs() << "Expanding\n");
     return Expand(Node, Op.getResNo());
SDValue VectorLegalizer::ExpandStore(SDNode *N) {
   return TF;
 }
 
 SDValue VectorLegalizer::Expand(SDNode *Node, unsigned ResNo) {
   SDValue Op(Node, 0); // FIXME: Just pass Node to all the expanders.
 
   SmallVector<SDValue, 8> Results;
   switch (Op->getOpcode()) {
+  case ISD::MERGE_VALUES:
+    for (unsigned i = 0; i != Node->getNumValues(); ++i)
+      Results.push_back(Node->getOperand(i));
+    break;
   case ISD::SIGN_EXTEND_INREG:
     Results.push_back(ExpandSEXTINREG(Op));
     break;
   case ISD::ANY_EXTEND_VECTOR_INREG:
     Results.push_back(ExpandANY_EXTEND_VECTOR_INREG(Op));
     break;
   case ISD::SIGN_EXTEND_VECTOR_INREG:
     Results.push_back(ExpandSIGN_EXTEND_VECTOR_INREG(Op));