// a reference to the root node, preventing it from being deleted,
// and tracking any changes of the root.
HandleSDNode Dummy(CurDAG->getRoot());
- ISelPosition = llvm::next(SelectionDAG::allnodes_iterator(CurDAG->getRoot().getNode()));
+ ISelPosition = SelectionDAG::allnodes_iterator(CurDAG->getRoot().getNode());
+ ++ISelPosition;
// The AllNodes list is now topological-sorted. Visit the
// nodes by starting at the end of the list (the root of the
// makes it theoretically possible to disable the DAGCombiner.
if (Node->use_empty())
continue;
-#if 0
- DAG.setSubgraphColor(Node, "red");
-#endif
+
SDNode *ResNode = Select(Node);
// If node should not be replaced, continue with the next one.
if (ResNode == Node)
continue;
// Replace node.
- if (ResNode) {
-#if 0
- DAG.setSubgraphColor(ResNode, "yellow");
- DAG.setSubgraphColor(ResNode, "black");
-#endif
+ if (ResNode)
ReplaceUses(Node, ResNode);
- }
+
// If after the replacement this node is not used any more,
// remove this dead node.
if (Node->use_empty()) { // Don't delete EntryToken, etc.
OPC_EmitMergeInputChains,
OPC_EmitCopyToReg,
OPC_EmitNodeXForm,
- OPC_EmitNode
+ OPC_EmitNode,
+ OPC_CompleteMatch
};
enum {
if (NumChains == 1) {
unsigned RecNo = MatcherTable[MatcherIndex++];
assert(RecNo < RecordedNodes.size() && "Invalid CheckSame");
+ ChainNodesMatched.push_back(RecordedNodes[RecNo].getNode());
InputChain = RecordedNodes[RecNo].getOperand(0);
assert(InputChain.getValueType() == MVT::Other && "Not a chain");
continue;
}
continue;
}
+
+ case OPC_CompleteMatch: {
+ // The match has been completed, and any new nodes (if any) have been
+ // created. Patch up references to the matched dag to use the newly
+ // created nodes.
+ unsigned NumResults = MatcherTable[MatcherIndex++];
+
+ for (unsigned i = 0; i != NumResults; ++i) {
+ unsigned ResSlot = MatcherTable[MatcherIndex++];
+ assert(ResSlot < RecordedNodes.size() && "Invalid CheckSame");
+ SDValue Res = RecordedNodes[ResSlot];
+ assert(NodeToMatch->getValueType(i) == Res.getValueType() &&
+ "invalid replacement");
+ ReplaceUses(SDValue(NodeToMatch, i), Res);
+ }
+
+ // Now that all the normal results are replaced, we replace the chain and
+ // flag results if present.
+ if (!ChainNodesMatched.empty()) {
+ assert(InputChain.getNode() != 0 &&
+ "Matched input chains but didn't produce a chain");
+ // Loop over all of the nodes we matched that produced a chain result.
+ // Replace all the chain results with the final chain we ended up with.
+ for (unsigned i = 0, e = ChainNodesMatched.size(); i != e; ++i) {
+ SDNode *ChainNode = ChainNodesMatched[i];
+ SDValue ChainVal = SDValue(ChainNode, ChainNode->getNumValues()-1);
+ if (ChainVal.getValueType() == MVT::Flag)
+ ChainVal = ChainVal.getValue(ChainVal->getNumValues()-2);
+ assert(ChainVal.getValueType() == MVT::Other && "Not a chain?");
+ ReplaceUses(ChainVal, InputChain);
+ }
+ }
+ // If the root node produces a flag, make sure to replace its flag
+ // result with the resultant flag.
+ if (NodeToMatch->getValueType(NodeToMatch->getNumValues()-1) ==
+ MVT::Flag)
+ ReplaceUses(SDValue(NodeToMatch, NodeToMatch->getNumValues()-1),
+ InputFlag);
+
+ // FIXME: We just return here, which interacts correctly with SelectRoot
+ // above. We should fix this to not return an SDNode* anymore.
+ return 0;
+ }
}
// If the code reached this point, then the match failed pop out to the next
// definitions. Emit the resultant instruction selector.
EmitInstructionSelector(OS);
-#if 0
+#if 1
MatcherNode *Matcher = 0;
// Walk the patterns backwards, building a matcher for each and adding it to
// the matcher for the whole target.
printNext(OS, indent);
}
-void PatternMarkerMatcherNode::print(raw_ostream &OS, unsigned indent) const {
+void CompleteMatchMatcherNode::print(raw_ostream &OS, unsigned indent) const {
+ OS.indent(indent) << "CompleteMatch <todo args>\n";
OS.indent(indent) << "Src = " << *Pattern.getSrcPattern() << "\n";
OS.indent(indent) << "Dst = " << *Pattern.getDstPattern() << "\n";
printNext(OS, indent);
EmitCopyToReg, // Emit a copytoreg into a physreg.
EmitNode, // Create a DAG node
EmitNodeXForm, // Run a SDNodeXForm
- PatternMarker // Comment for printing.
+ CompleteMatch // Finish a match and update the results.
};
const KindTy Kind;
virtual void print(raw_ostream &OS, unsigned indent = 0) const;
};
-
-/// PatternMarkerMatcherNode - This prints as a comment indicating the source
-/// and dest patterns.
-class PatternMarkerMatcherNode : public MatcherNode {
+
+/// CompleteMatchMatcherNode - Complete a match by replacing the results of the
+/// pattern with the newly generated nodes. This also prints a comment
+/// indicating the source and dest patterns.
+class CompleteMatchMatcherNode : public MatcherNode {
+ SmallVector<unsigned, 2> Results;
const PatternToMatch &Pattern;
public:
- PatternMarkerMatcherNode(const PatternToMatch &pattern)
- : MatcherNode(PatternMarker), Pattern(pattern) {}
-
+ CompleteMatchMatcherNode(const unsigned *results, unsigned numresults,
+ const PatternToMatch &pattern)
+ : MatcherNode(CompleteMatch), Results(results, results+numresults),
+ Pattern(pattern) {}
+
+ unsigned getNumResults() const { return Results.size(); }
+ unsigned getResult(unsigned R) const { return Results[R]; }
const PatternToMatch &getPattern() const { return Pattern; }
static inline bool classof(const MatcherNode *N) {
- return N->getKind() == PatternMarker;
+ return N->getKind() == CompleteMatch;
}
virtual void print(raw_ostream &OS, unsigned indent = 0) const;
OS << '\n';
return 5+EN->getNumVTs()+EN->getNumOperands();
}
- case MatcherNode::PatternMarker:
- OS << "// Src: "
- << *cast<PatternMarkerMatcherNode>(N)->getPattern().getSrcPattern() << '\n';
- OS.PadToColumn(Indent*2) << "// Dst: "
- << *cast<PatternMarkerMatcherNode>(N)->getPattern().getDstPattern() << '\n';
+ case MatcherNode::CompleteMatch: {
+ const CompleteMatchMatcherNode *CM = cast<CompleteMatchMatcherNode>(N);
+ OS << "OPC_CompleteMatch, " << CM->getNumResults() << ", ";
+ for (unsigned i = 0, e = CM->getNumResults(); i != e; ++i)
+ OS << CM->getResult(i) << ", ";
+ OS << '\n';
+ OS.PadToColumn(Indent*2) << "// Src: "
+ << *CM->getPattern().getSrcPattern() << '\n';
+ OS.PadToColumn(Indent*2) << "// Dst: "
+ << *CM->getPattern().getDstPattern() << '\n';
return 0;
}
+ }
assert(0 && "Unreachable");
return 0;
}
// The newly emitted node gets recorded.
// FIXME2: This should record all of the results except the (implicit) one.
- OutputOps.push_back(NextRecordedOperandNo++);
-
+ if (ResultVTs[0] != MVT::Other)
+ OutputOps.push_back(NextRecordedOperandNo++);
// FIXME2: Kill off all the SelectionDAG::SelectNodeTo and getMachineNode
// variants. Call MorphNodeTo instead of SelectNodeTo.
// We know that the resulting pattern has exactly one result/
// FIXME2: why? what about something like (set a,b,c, (complexpat))
// FIXME2: Implicit results should be pushed here I guess?
- assert(Ops.size() == 1);
+ assert(Ops.size() <= 1);
// FIXME: Handle Ops.
// FIXME: Handle (set EAX, (foo)) but not (implicit EFLAGS)
- AddMatcherNode(new PatternMarkerMatcherNode(Pattern));
+ AddMatcherNode(new CompleteMatchMatcherNode(Ops.data(), Ops.size(), Pattern));
}
projects / oota-llvm.git / commitdiff