#endif
}
-/// MarkNewNodes - The specified node is the root of a subtree of potentially
-/// new nodes. Add the correct NodeId to mark it.
-void DAGTypeLegalizer::MarkNewNodes(SDNode *N) {
+/// AnalyzeNewNode - The specified node is the root of a subtree of potentially
+/// new nodes. Correct any processed operands (this may change the node) and
+/// calculate the NodeId.
+void DAGTypeLegalizer::AnalyzeNewNode(SDNode *&N) {
// If this was an existing node that is already done, we're done.
if (N->getNodeId() != NewNode)
return;
//
// As we walk the operands, keep track of the number of nodes that are
// processed. If non-zero, this will become the new nodeid of this node.
+ // Already processed operands may need to be remapped to the node that
+ // replaced them, which can result in our node changing. Since remapping
+ // is rare, the code tries to minimize overhead in the non-remapping case.
+
+ SmallVector<SDOperand, 8> NewOps;
unsigned NumProcessed = 0;
for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {
- int OpId = N->getOperand(i).Val->getNodeId();
- if (OpId == NewNode)
- MarkNewNodes(N->getOperand(i).Val);
- else if (OpId == Processed)
+ SDOperand OrigOp = N->getOperand(i);
+ SDOperand Op = OrigOp;
+
+ if (Op.Val->getNodeId() == Processed)
+ RemapNode(Op);
+
+ if (Op.Val->getNodeId() == NewNode)
+ AnalyzeNewNode(Op.Val);
+ else if (Op.Val->getNodeId() == Processed)
++NumProcessed;
+
+ if (!NewOps.empty()) {
+ // Some previous operand changed. Add this one to the list.
+ NewOps.push_back(Op);
+ } else if (Op != OrigOp) {
+ // This is the first operand to change - add all operands so far.
+ for (unsigned j = 0; j < i; ++j)
+ NewOps.push_back(N->getOperand(j));
+ NewOps.push_back(Op);
+ }
}
-
+
+ // Some operands changed - update the node.
+ if (!NewOps.empty())
+ N = DAG.UpdateNodeOperands(SDOperand(N, 0), &NewOps[0], NewOps.size()).Val;
+
N->setNodeId(N->getNumOperands()-NumProcessed);
if (N->getNodeId() == ReadyToProcess)
Worklist.push_back(N);
assert(N->getNodeId() != DAGTypeLegalizer::Processed &&
N->getNodeId() != DAGTypeLegalizer::ReadyToProcess &&
"RAUW updated processed node!");
- DTL.ReanalyzeNodeFlags(N);
+ DTL.ReanalyzeNode(N);
}
};
}
/// of From to use To instead.
void DAGTypeLegalizer::ReplaceValueWith(SDOperand From, SDOperand To) {
if (From == To) return;
-
+
// If expansion produced new nodes, make sure they are properly marked.
- if (To.Val->getNodeId() == NewNode)
- MarkNewNodes(To.Val);
-
+ AnalyzeNewNode(To.Val);
+
// Anything that used the old node should now use the new one. Note that this
// can potentially cause recursive merging.
NodeUpdateListener NUL(*this);
/// node's results. The from and to node must define identical result types.
void DAGTypeLegalizer::ReplaceNodeWith(SDNode *From, SDNode *To) {
if (From == To) return;
+
+ // If expansion produced new nodes, make sure they are properly marked.
+ AnalyzeNewNode(To);
+
assert(From->getNumValues() == To->getNumValues() &&
"Node results don't match");
-
- // If expansion produced new nodes, make sure they are properly marked.
- if (To->getNodeId() == NewNode)
- MarkNewNodes(To);
-
+
// Anything that used the old node should now use the new one. Note that this
// can potentially cause recursive merging.
NodeUpdateListener NUL(*this);
}
void DAGTypeLegalizer::SetPromotedOp(SDOperand Op, SDOperand Result) {
- if (Result.Val->getNodeId() == NewNode)
- MarkNewNodes(Result.Val);
+ AnalyzeNewNode(Result.Val);
SDOperand &OpEntry = PromotedNodes[Op];
assert(OpEntry.Val == 0 && "Node is already promoted!");
}
void DAGTypeLegalizer::SetScalarizedOp(SDOperand Op, SDOperand Result) {
- if (Result.Val->getNodeId() == NewNode)
- MarkNewNodes(Result.Val);
-
+ AnalyzeNewNode(Result.Val);
+
SDOperand &OpEntry = ScalarizedNodes[Op];
assert(OpEntry.Val == 0 && "Node is already scalarized!");
OpEntry = Result;
}
void DAGTypeLegalizer::SetExpandedOp(SDOperand Op, SDOperand Lo, SDOperand Hi) {
+ // Lo/Hi may have been newly allocated, if so, add nodeid's as relevant.
+ AnalyzeNewNode(Lo.Val);
+ AnalyzeNewNode(Hi.Val);
+
// Remember that this is the result of the node.
std::pair<SDOperand, SDOperand> &Entry = ExpandedNodes[Op];
assert(Entry.first.Val == 0 && "Node already expanded");
Entry.first = Lo;
Entry.second = Hi;
-
- // Lo/Hi may have been newly allocated, if so, add nodeid's as relevant.
- if (Lo.Val->getNodeId() == NewNode)
- MarkNewNodes(Lo.Val);
- if (Hi.Val->getNodeId() == NewNode)
- MarkNewNodes(Hi.Val);
}
void DAGTypeLegalizer::GetSplitOp(SDOperand Op, SDOperand &Lo, SDOperand &Hi) {
}
void DAGTypeLegalizer::SetSplitOp(SDOperand Op, SDOperand Lo, SDOperand Hi) {
+ // Lo/Hi may have been newly allocated, if so, add nodeid's as relevant.
+ AnalyzeNewNode(Lo.Val);
+ AnalyzeNewNode(Hi.Val);
+
// Remember that this is the result of the node.
std::pair<SDOperand, SDOperand> &Entry = SplitNodes[Op];
assert(Entry.first.Val == 0 && "Node already split");
Entry.first = Lo;
Entry.second = Hi;
-
- // Lo/Hi may have been newly allocated, if so, add nodeid's as relevant.
- if (Lo.Val->getNodeId() == NewNode)
- MarkNewNodes(Lo.Val);
- if (Hi.Val->getNodeId() == NewNode)
- MarkNewNodes(Hi.Val);
}
// Mark N as new and remark N and its operands. This allows us to correctly
// revisit N if it needs another step of promotion and allows us to visit
// any new operands to N.
- N->setNodeId(NewNode);
- MarkNewNodes(N);
+ ReanalyzeNode(N);
return true;
}
-
+
assert(Res.getValueType() == N->getValueType(0) && N->getNumValues() == 1 &&
"Invalid operand expansion");
// that the value is properly zero extended.
unsigned BitWidth = Cond.getValueSizeInBits();
if (!DAG.MaskedValueIsZero(Cond,
- APInt::getHighBitsSet(BitWidth, BitWidth-1))) {
+ APInt::getHighBitsSet(BitWidth, BitWidth-1)))
Cond = DAG.getZeroExtendInReg(Cond, MVT::i1);
- MarkNewNodes(Cond.Val);
- }
// The chain (Op#0) and basic block destination (Op#2) are always legal types.
return DAG.UpdateNodeOperands(SDOperand(N, 0), Cond, N->getOperand(1),
// that the value is properly zero extended.
unsigned BitWidth = Cond.getValueSizeInBits();
if (!DAG.MaskedValueIsZero(Cond,
- APInt::getHighBitsSet(BitWidth, BitWidth-1))) {
+ APInt::getHighBitsSet(BitWidth, BitWidth-1)))
Cond = DAG.getZeroExtendInReg(Cond, MVT::i1);
- MarkNewNodes(Cond.Val);
- }
-
+
// The chain (Op#0) and basic block destination (Op#2) are always legal types.
return DAG.UpdateNodeOperands(SDOperand(N, 0), N->getOperand(0), Cond,
N->getOperand(2));