Improve CodeGenDAGPattern support with multiple explicit results in an instruction pattern

[craig.topper]

Summary

This patch attempts to improve tablegen support for instruction patterns like this which have more than one explicit result.

[(set _.RC:$dst, _.KRCWM:$mask_wb,

(GatherNode  (_.VT _.RC:$src1), _.KRCWM:$mask,
       vectoraddr:$src2))]

[hfinkel]

LGTM, thanks!

utils/TableGen/CodeGenDAGPatterns.cpp

3058

Please improve the string in this assert to explain what is not handled.

[craig.topper]

To be honest I don't know if I know the code well enough to know if that
can fail. Just seemed bad to blindly assume there was only one type there.
There are quite a few such "unhandled" asserts in this file so I just wrote
the same.

[hfinkel]

In D8073#134733, @craig.topper wrote:

To be honest I don't know if I know the code well enough to know if that
can fail. Just seemed bad to blindly assume there was only one type there.
There are quite a few such "unhandled" asserts in this file so I just wrote
the same.

Okay, fair enough. You're right, the asserts on this condition are like this for some reason. Let's keep it this way in this patch, and we'll improve them all together later.

[craig.topper]

Committed in r231357

utils/TableGen/CodeGenDAGPatterns.cpp

if (Tree)
         Op = DI->getDef();
     assert(Op && "Invalid Fragment");
     return GetNumNodeResults(Op, CDP);
   }
 
   if (Operator->isSubClassOf("Instruction")) {
     CodeGenInstruction &InstInfo = CDP.getTargetInfo().getInstruction(Operator);
 
-    // FIXME: Should allow access to all the results here.
-    unsigned NumDefsToAdd = InstInfo.Operands.NumDefs ? 1 : 0;
+    unsigned NumDefsToAdd = InstInfo.Operands.NumDefs;
 
     // Add on one implicit def if it has a resolvable type.
     if (InstInfo.HasOneImplicitDefWithKnownVT(CDP.getTargetInfo()) !=MVT::Other)
       ++NumDefsToAdd;
     return NumDefsToAdd;
   }
 
   if (Operator->isSubClassOf("SDNodeXForm"))
if (getOperator()->isSubClassOf("Instruction")) {
     const DAGInstruction &Inst = CDP.getInstruction(getOperator());
     CodeGenInstruction &InstInfo =
       CDP.getTargetInfo().getInstruction(getOperator());
 
     bool MadeChange = false;
 
     // Apply the result types to the node, these come from the things in the
     // (outs) list of the instruction.
-    // FIXME: Cap at one result so far.
-    unsigned NumResultsToAdd = InstInfo.Operands.NumDefs ? 1 : 0;
+    unsigned NumResultsToAdd = InstInfo.Operands.NumDefs;
     for (unsigned ResNo = 0; ResNo != NumResultsToAdd; ++ResNo)
       MadeChange |= UpdateNodeTypeFromInst(ResNo, Inst.getResult(ResNo), TP);
 
     // If the instruction has implicit defs, we apply the first one as a result.
     // FIXME: This sucks, it should apply all implicit defs.
     if (!InstInfo.ImplicitDefs.empty()) {
       unsigned ResNo = NumResultsToAdd;
 
const DAGInstruction &CodeGenDAGPatterns::parseInstructionPattern(
     // added to the machine instruction the node corresponds to.
     unsigned NumResults = InstResults.size();
 
     // Parse the operands list from the (ops) list, validating it.
     assert(I->getArgList().empty() && "Args list should still be empty here!");
 
     // Check that all of the results occur first in the list.
     std::vector<Record*> Results;
-    TreePatternNode *Res0Node = nullptr;
+    SmallVector<TreePatternNode *, 2> ResNodes;
     for (unsigned i = 0; i != NumResults; ++i) {
       if (i == CGI.Operands.size())
         I->error("'" + InstResults.begin()->first +
                  "' set but does not appear in operand list!");
       const std::string &OpName = CGI.Operands[i].Name;
 
       // Check that it exists in InstResults.
       TreePatternNode *RNode = InstResults[OpName];
       if (!RNode)
         I->error("Operand $" + OpName + " does not exist in operand list!");
 
-      if (i == 0)
-        Res0Node = RNode;
+      ResNodes.push_back(RNode);
+
       Record *R = cast<DefInit>(RNode->getLeafValue())->getDef();
       if (!R)
         I->error("Operand $" + OpName + " should be a set destination: all "
                  "outputs must occur before inputs in operand list!");
 
       if (!checkOperandClass(CGI.Operands[i], R))
         I->error("Operand $" + OpName + " class mismatch!");
 
const DAGInstruction &CodeGenDAGPatterns::parseInstructionPattern(
 
     if (!InstInputsCheck.empty())
       I->error("Input operand $" + InstInputsCheck.begin()->first +
                " occurs in pattern but not in operands list!");
 
     TreePatternNode *ResultPattern =
       new TreePatternNode(I->getRecord(), ResultNodeOperands,
                           GetNumNodeResults(I->getRecord(), *this));
-    // Copy fully inferred output node type to instruction result pattern.
-    for (unsigned i = 0; i != NumResults; ++i)
-      ResultPattern->setType(i, Res0Node->getExtType(i));
+    // Copy fully inferred output node types to instruction result pattern.
+    for (unsigned i = 0; i != NumResults; ++i) {
+      assert(ResNodes[i]->getNumTypes() == 1 && "FIXME: Unhandled");
+      ResultPattern->setType(i, ResNodes[i]->getExtType(0));
+    }
 
     // Create and insert the instruction.
     // FIXME: InstImpResults should not be part of DAGInstruction.
     DAGInstruction TheInst(I, Results, Operands, InstImpResults);
     DAGInsts.insert(std::make_pair(I->getRecord(), TheInst));
 
     // Use a temporary tree pattern to infer all types and make sure that the
     // constructed result is correct.  This depends on the instruction already