[llvm] r333591 - [TableGen] Avoid leaking TreePatternNodes by using shared_ptr.
Florian Hahn via llvm-commits
llvm-commits at lists.llvm.org
Wed May 30 14:00:18 PDT 2018
Author: fhahn
Date: Wed May 30 14:00:18 2018
New Revision: 333591
URL: http://llvm.org/viewvc/llvm-project?rev=333591&view=rev
Log:
[TableGen] Avoid leaking TreePatternNodes by using shared_ptr.
By using std::shared_ptr for TreePatternNode, we can avoid leaking them.
Reviewers: craig.topper, dsanders, stoklund, tstellar, zturner
Reviewed By: dsanders
Differential Revision: https://reviews.llvm.org/D47463
Modified:
llvm/trunk/utils/TableGen/CodeGenDAGPatterns.cpp
llvm/trunk/utils/TableGen/CodeGenDAGPatterns.h
llvm/trunk/utils/TableGen/DAGISelMatcherGen.cpp
Modified: llvm/trunk/utils/TableGen/CodeGenDAGPatterns.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/CodeGenDAGPatterns.cpp?rev=333591&r1=333590&r2=333591&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/CodeGenDAGPatterns.cpp (original)
+++ llvm/trunk/utils/TableGen/CodeGenDAGPatterns.cpp Wed May 30 14:00:18 2018
@@ -1564,7 +1564,7 @@ bool TreePatternNode::hasProperTypeByHwM
for (const TypeSetByHwMode &S : Types)
if (!S.isDefaultOnly())
return true;
- for (TreePatternNode *C : Children)
+ for (const TreePatternNodePtr &C : Children)
if (C->hasProperTypeByHwMode())
return true;
return false;
@@ -1574,7 +1574,7 @@ bool TreePatternNode::hasPossibleType()
for (const TypeSetByHwMode &S : Types)
if (!S.isPossible())
return false;
- for (TreePatternNode *C : Children)
+ for (const TreePatternNodePtr &C : Children)
if (!C->hasPossibleType())
return false;
return true;
@@ -1587,7 +1587,7 @@ bool TreePatternNode::setDefaultMode(uns
if (S.get(DefaultMode).empty())
return false;
}
- for (TreePatternNode *C : Children)
+ for (const TreePatternNodePtr &C : Children)
if (!C->setDefaultMode(Mode))
return false;
return true;
@@ -1644,13 +1644,6 @@ MVT::SimpleValueType SDNodeInfo::getKnow
// TreePatternNode implementation
//
-TreePatternNode::~TreePatternNode() {
-#if 0 // FIXME: implement refcounted tree nodes!
- for (unsigned i = 0, e = getNumChildren(); i != e; ++i)
- delete getChild(i);
-#endif
-}
-
static unsigned GetNumNodeResults(Record *Operator, CodeGenDAGPatterns &CDP) {
if (Operator->getName() == "set" ||
Operator->getName() == "implicit")
@@ -1783,16 +1776,17 @@ bool TreePatternNode::isIsomorphicTo(con
/// clone - Make a copy of this tree and all of its children.
///
-TreePatternNode *TreePatternNode::clone() const {
- TreePatternNode *New;
+TreePatternNodePtr TreePatternNode::clone() const {
+ TreePatternNodePtr New;
if (isLeaf()) {
- New = new TreePatternNode(getLeafValue(), getNumTypes());
+ New = std::make_shared<TreePatternNode>(getLeafValue(), getNumTypes());
} else {
- std::vector<TreePatternNode*> CChildren;
+ std::vector<TreePatternNodePtr> CChildren;
CChildren.reserve(Children.size());
for (unsigned i = 0, e = getNumChildren(); i != e; ++i)
CChildren.push_back(getChild(i)->clone());
- New = new TreePatternNode(getOperator(), CChildren, getNumTypes());
+ New = std::make_shared<TreePatternNode>(getOperator(), CChildren,
+ getNumTypes());
}
New->setName(getName());
New->Types = Types;
@@ -1813,8 +1807,8 @@ void TreePatternNode::RemoveAllTypes() {
/// SubstituteFormalArguments - Replace the formal arguments in this tree
/// with actual values specified by ArgMap.
-void TreePatternNode::
-SubstituteFormalArguments(std::map<std::string, TreePatternNode*> &ArgMap) {
+void TreePatternNode::SubstituteFormalArguments(
+ std::map<std::string, TreePatternNodePtr> &ArgMap) {
if (isLeaf()) return;
for (unsigned i = 0, e = getNumChildren(); i != e; ++i) {
@@ -1826,7 +1820,7 @@ SubstituteFormalArguments(std::map<std::
if (isa<UnsetInit>(Val) || (isa<DefInit>(Val) &&
cast<DefInit>(Val)->getDef()->getName() == "node")) {
// We found a use of a formal argument, replace it with its value.
- TreePatternNode *NewChild = ArgMap[Child->getName()];
+ TreePatternNodePtr NewChild = ArgMap[Child->getName()];
assert(NewChild && "Couldn't find formal argument!");
assert((Child->getPredicateFns().empty() ||
NewChild->getPredicateFns() == Child->getPredicateFns()) &&
@@ -1843,19 +1837,20 @@ SubstituteFormalArguments(std::map<std::
/// InlinePatternFragments - If this pattern refers to any pattern
/// fragments, inline them into place, giving us a pattern without any
/// PatFrag references.
-TreePatternNode *TreePatternNode::InlinePatternFragments(TreePattern &TP) {
+TreePatternNodePtr TreePatternNode::InlinePatternFragments(TreePatternNodePtr T,
+ TreePattern &TP) {
if (TP.hasError())
return nullptr;
if (isLeaf())
- return this; // nothing to do.
+ return T; // nothing to do.
Record *Op = getOperator();
if (!Op->isSubClassOf("PatFrag")) {
// Just recursively inline children nodes.
for (unsigned i = 0, e = getNumChildren(); i != e; ++i) {
- TreePatternNode *Child = getChild(i);
- TreePatternNode *NewChild = Child->InlinePatternFragments(TP);
+ TreePatternNodePtr Child = getChildShared(i);
+ TreePatternNodePtr NewChild = Child->InlinePatternFragments(Child, TP);
assert((Child->getPredicateFns().empty() ||
NewChild->getPredicateFns() == Child->getPredicateFns()) &&
@@ -1863,7 +1858,7 @@ TreePatternNode *TreePatternNode::Inline
setChild(i, NewChild);
}
- return this;
+ return T;
}
// Otherwise, we found a reference to a fragment. First, look up its
@@ -1874,10 +1869,10 @@ TreePatternNode *TreePatternNode::Inline
if (Frag->getNumArgs() != Children.size()) {
TP.error("'" + Op->getName() + "' fragment requires " +
Twine(Frag->getNumArgs()) + " operands!");
- return nullptr;
+ return {nullptr};
}
- TreePatternNode *FragTree = Frag->getOnlyTree()->clone();
+ TreePatternNodePtr FragTree = Frag->getOnlyTree()->clone();
TreePredicateFn PredFn(Frag);
if (!PredFn.isAlwaysTrue())
@@ -1886,9 +1881,11 @@ TreePatternNode *TreePatternNode::Inline
// Resolve formal arguments to their actual value.
if (Frag->getNumArgs()) {
// Compute the map of formal to actual arguments.
- std::map<std::string, TreePatternNode*> ArgMap;
- for (unsigned i = 0, e = Frag->getNumArgs(); i != e; ++i)
- ArgMap[Frag->getArgName(i)] = getChild(i)->InlinePatternFragments(TP);
+ std::map<std::string, TreePatternNodePtr> ArgMap;
+ for (unsigned i = 0, e = Frag->getNumArgs(); i != e; ++i) {
+ TreePatternNodePtr Child = getChildShared(i);
+ ArgMap[Frag->getArgName(i)] = Child->InlinePatternFragments(Child, TP);
+ }
FragTree->SubstituteFormalArguments(ArgMap);
}
@@ -1901,12 +1898,9 @@ TreePatternNode *TreePatternNode::Inline
for (const TreePredicateFn &Pred : getPredicateFns())
FragTree->addPredicateFn(Pred);
- // Get a new copy of this fragment to stitch into here.
- //delete this; // FIXME: implement refcounting!
-
// The fragment we inlined could have recursive inlining that is needed. See
// if there are any pattern fragments in it and inline them as needed.
- return FragTree->InlinePatternFragments(TP);
+ return FragTree->InlinePatternFragments(FragTree, TP);
}
/// getImplicitType - Check to see if the specified record has an implicit
@@ -2508,10 +2502,10 @@ TreePattern::TreePattern(Record *TheRec,
Trees.push_back(ParseTreePattern(Pat, ""));
}
-TreePattern::TreePattern(Record *TheRec, TreePatternNode *Pat, bool isInput,
- CodeGenDAGPatterns &cdp) : TheRecord(TheRec), CDP(cdp),
- isInputPattern(isInput), HasError(false),
- Infer(*this) {
+TreePattern::TreePattern(Record *TheRec, TreePatternNodePtr Pat, bool isInput,
+ CodeGenDAGPatterns &cdp)
+ : TheRecord(TheRec), CDP(cdp), isInputPattern(isInput), HasError(false),
+ Infer(*this) {
Trees.push_back(Pat);
}
@@ -2524,8 +2518,8 @@ void TreePattern::error(const Twine &Msg
}
void TreePattern::ComputeNamedNodes() {
- for (TreePatternNode *Tree : Trees)
- ComputeNamedNodes(Tree);
+ for (TreePatternNodePtr &Tree : Trees)
+ ComputeNamedNodes(Tree.get());
}
void TreePattern::ComputeNamedNodes(TreePatternNode *N) {
@@ -2536,8 +2530,8 @@ void TreePattern::ComputeNamedNodes(Tree
ComputeNamedNodes(N->getChild(i));
}
-
-TreePatternNode *TreePattern::ParseTreePattern(Init *TheInit, StringRef OpName){
+TreePatternNodePtr TreePattern::ParseTreePattern(Init *TheInit,
+ StringRef OpName) {
if (DefInit *DI = dyn_cast<DefInit>(TheInit)) {
Record *R = DI->getDef();
@@ -2551,7 +2545,7 @@ TreePatternNode *TreePattern::ParseTreeP
OpName);
// Input argument?
- TreePatternNode *Res = new TreePatternNode(DI, 1);
+ TreePatternNodePtr Res = std::make_shared<TreePatternNode>(DI, 1);
if (R->getName() == "node" && !OpName.empty()) {
if (OpName.empty())
error("'node' argument requires a name to match with operand list");
@@ -2566,7 +2560,7 @@ TreePatternNode *TreePattern::ParseTreeP
if (isa<UnsetInit>(TheInit)) {
if (OpName.empty())
error("'?' argument requires a name to match with operand list");
- TreePatternNode *Res = new TreePatternNode(TheInit, 1);
+ TreePatternNodePtr Res = std::make_shared<TreePatternNode>(TheInit, 1);
Args.push_back(OpName);
Res->setName(OpName);
return Res;
@@ -2575,7 +2569,7 @@ TreePatternNode *TreePattern::ParseTreeP
if (IntInit *II = dyn_cast<IntInit>(TheInit)) {
if (!OpName.empty())
error("Constant int argument should not have a name!");
- return new TreePatternNode(II, 1);
+ return std::make_shared<TreePatternNode>(II, 1);
}
if (BitsInit *BI = dyn_cast<BitsInit>(TheInit)) {
@@ -2601,8 +2595,8 @@ TreePatternNode *TreePattern::ParseTreeP
if (Dag->getNumArgs() != 1)
error("Type cast only takes one operand!");
- TreePatternNode *New = ParseTreePattern(Dag->getArg(0),
- Dag->getArgNameStr(0));
+ TreePatternNodePtr New =
+ ParseTreePattern(Dag->getArg(0), Dag->getArgNameStr(0));
// Apply the type cast.
assert(New->getNumTypes() == 1 && "FIXME: Unhandled");
@@ -2650,7 +2644,7 @@ TreePatternNode *TreePattern::ParseTreeP
error("Cannot use '" + Operator->getName() + "' in an output pattern!");
}
- std::vector<TreePatternNode*> Children;
+ std::vector<TreePatternNodePtr> Children;
// Parse all the operands.
for (unsigned i = 0, e = Dag->getNumArgs(); i != e; ++i)
@@ -2677,13 +2671,14 @@ TreePatternNode *TreePattern::ParseTreeP
else // Otherwise, no chain.
Operator = getDAGPatterns().get_intrinsic_wo_chain_sdnode();
- TreePatternNode *IIDNode = new TreePatternNode(IntInit::get(IID), 1);
+ TreePatternNodePtr IIDNode =
+ std::make_shared<TreePatternNode>(IntInit::get(IID), 1);
Children.insert(Children.begin(), IIDNode);
}
if (Operator->isSubClassOf("ComplexPattern")) {
for (unsigned i = 0; i < Children.size(); ++i) {
- TreePatternNode *Child = Children[i];
+ TreePatternNodePtr Child = Children[i];
if (Child->getName().empty())
error("All arguments to a ComplexPattern must be named");
@@ -2702,7 +2697,8 @@ TreePatternNode *TreePattern::ParseTreeP
}
}
- TreePatternNode *Result = new TreePatternNode(Operator, Children, NumResults);
+ TreePatternNodePtr Result =
+ std::make_shared<TreePatternNode>(Operator, Children, NumResults);
Result->setName(OpName);
if (Dag->getName()) {
@@ -2718,7 +2714,7 @@ TreePatternNode *TreePattern::ParseTreeP
/// more type generic things and have useless type casts fold away.
///
/// This returns true if any change is made.
-static bool SimplifyTree(TreePatternNode *&N) {
+static bool SimplifyTree(TreePatternNodePtr &N) {
if (N->isLeaf())
return false;
@@ -2728,7 +2724,7 @@ static bool SimplifyTree(TreePatternNode
N->getExtType(0).isValueTypeByHwMode(false) &&
N->getExtType(0) == N->getChild(0)->getExtType(0) &&
N->getName().empty()) {
- N = N->getChild(0);
+ N = N->getChildShared(0);
SimplifyTree(N);
return true;
}
@@ -2736,7 +2732,7 @@ static bool SimplifyTree(TreePatternNode
// Walk all children.
bool MadeChange = false;
for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) {
- TreePatternNode *Child = N->getChild(i);
+ TreePatternNodePtr Child = N->getChildShared(i);
MadeChange |= SimplifyTree(Child);
N->setChild(i, Child);
}
@@ -2756,7 +2752,7 @@ InferAllTypes(const StringMap<SmallVecto
bool MadeChange = true;
while (MadeChange) {
MadeChange = false;
- for (TreePatternNode *&Tree : Trees) {
+ for (TreePatternNodePtr &Tree : Trees) {
MadeChange |= Tree->ApplyTypeConstraints(*this, false);
MadeChange |= SimplifyTree(Tree);
}
@@ -2784,7 +2780,7 @@ InferAllTypes(const StringMap<SmallVecto
// changing the type of the input register in this case. This allows
// us to match things like:
// def : Pat<(v1i64 (bitconvert(v2i32 DPR:$src))), (v1i64 DPR:$src)>;
- if (Node == Trees[0] && Node->isLeaf()) {
+ if (Node == Trees[0].get() && Node->isLeaf()) {
DefInit *DI = dyn_cast<DefInit>(Node->getLeafValue());
if (DI && (DI->getDef()->isSubClassOf("RegisterClass") ||
DI->getDef()->isSubClassOf("RegisterOperand")))
@@ -2815,7 +2811,7 @@ InferAllTypes(const StringMap<SmallVecto
}
bool HasUnresolvedTypes = false;
- for (const TreePatternNode *Tree : Trees)
+ for (const TreePatternNodePtr &Tree : Trees)
HasUnresolvedTypes |= Tree->ContainsUnresolvedType(*this);
return !HasUnresolvedTypes;
}
@@ -2832,7 +2828,7 @@ void TreePattern::print(raw_ostream &OS)
if (Trees.size() > 1)
OS << "[\n";
- for (const TreePatternNode *Tree : Trees) {
+ for (const TreePatternNodePtr &Tree : Trees) {
OS << "\t";
Tree->print(OS);
OS << "\n";
@@ -3048,9 +3044,9 @@ void CodeGenDAGPatterns::ParseDefaultOpe
// Copy the operands over into a DAGDefaultOperand.
DAGDefaultOperand DefaultOpInfo;
- TreePatternNode *T = P.getTree(0);
+ const TreePatternNodePtr &T = P.getTree(0);
for (unsigned op = 0, e = T->getNumChildren(); op != e; ++op) {
- TreePatternNode *TPN = T->getChild(op);
+ TreePatternNodePtr TPN = T->getChildShared(op);
while (TPN->ApplyTypeConstraints(P, false))
/* Resolve all types */;
@@ -3069,8 +3065,8 @@ void CodeGenDAGPatterns::ParseDefaultOpe
/// HandleUse - Given "Pat" a leaf in the pattern, check to see if it is an
/// instruction input. Return true if this is a real use.
-static bool HandleUse(TreePattern *I, TreePatternNode *Pat,
- std::map<std::string, TreePatternNode*> &InstInputs) {
+static bool HandleUse(TreePattern *I, TreePatternNodePtr Pat,
+ std::map<std::string, TreePatternNodePtr> &InstInputs) {
// No name -> not interesting.
if (Pat->getName().empty()) {
if (Pat->isLeaf()) {
@@ -3095,7 +3091,7 @@ static bool HandleUse(TreePattern *I, Tr
if (Rec->getName() == "srcvalue")
return false;
- TreePatternNode *&Slot = InstInputs[Pat->getName()];
+ TreePatternNodePtr &Slot = InstInputs[Pat->getName()];
if (!Slot) {
Slot = Pat;
return true;
@@ -3119,11 +3115,11 @@ static bool HandleUse(TreePattern *I, Tr
/// FindPatternInputsAndOutputs - Scan the specified TreePatternNode (which is
/// part of "I", the instruction), computing the set of inputs and outputs of
/// the pattern. Report errors if we see anything naughty.
-void CodeGenDAGPatterns::
-FindPatternInputsAndOutputs(TreePattern *I, TreePatternNode *Pat,
- std::map<std::string, TreePatternNode*> &InstInputs,
- std::map<std::string, TreePatternNode*>&InstResults,
- std::vector<Record*> &InstImpResults) {
+void CodeGenDAGPatterns::FindPatternInputsAndOutputs(
+ TreePattern *I, TreePatternNodePtr Pat,
+ std::map<std::string, TreePatternNodePtr> &InstInputs,
+ std::map<std::string, TreePatternNodePtr> &InstResults,
+ std::vector<Record *> &InstImpResults) {
if (Pat->isLeaf()) {
bool isUse = HandleUse(I, Pat, InstInputs);
if (!isUse && Pat->getTransformFn())
@@ -3151,8 +3147,8 @@ FindPatternInputsAndOutputs(TreePattern
for (unsigned i = 0, e = Pat->getNumChildren(); i != e; ++i) {
if (Pat->getChild(i)->getNumTypes() == 0)
I->error("Cannot have void nodes inside of patterns!");
- FindPatternInputsAndOutputs(I, Pat->getChild(i), InstInputs, InstResults,
- InstImpResults);
+ FindPatternInputsAndOutputs(I, Pat->getChildShared(i), InstInputs,
+ InstResults, InstImpResults);
}
// If this is a non-leaf node with no children, treat it basically as if
@@ -3174,7 +3170,7 @@ FindPatternInputsAndOutputs(TreePattern
// Check the set destinations.
unsigned NumDests = Pat->getNumChildren()-1;
for (unsigned i = 0; i != NumDests; ++i) {
- TreePatternNode *Dest = Pat->getChild(i);
+ TreePatternNodePtr Dest = Pat->getChildShared(i);
if (!Dest->isLeaf())
I->error("set destination should be a register!");
@@ -3201,8 +3197,8 @@ FindPatternInputsAndOutputs(TreePattern
}
// Verify and collect info from the computation.
- FindPatternInputsAndOutputs(I, Pat->getChild(NumDests),
- InstInputs, InstResults, InstImpResults);
+ FindPatternInputsAndOutputs(I, Pat->getChildShared(NumDests), InstInputs,
+ InstResults, InstImpResults);
}
//===----------------------------------------------------------------------===//
@@ -3224,7 +3220,7 @@ public:
void Analyze(const TreePattern *Pat) {
// Assume only the first tree is the pattern. The others are clobber nodes.
- AnalyzeNode(Pat->getTree(0));
+ AnalyzeNode(Pat->getTree(0).get());
}
void Analyze(const PatternToMatch &Pat) {
@@ -3436,11 +3432,11 @@ const DAGInstruction &CodeGenDAGPatterns
// InstInputs - Keep track of all of the inputs of the instruction, along
// with the record they are declared as.
- std::map<std::string, TreePatternNode*> InstInputs;
+ std::map<std::string, TreePatternNodePtr> InstInputs;
// InstResults - Keep track of all the virtual registers that are 'set'
// in the instruction, including what reg class they are.
- std::map<std::string, TreePatternNode*> InstResults;
+ std::map<std::string, TreePatternNodePtr> InstResults;
std::vector<Record*> InstImpResults;
@@ -3449,7 +3445,7 @@ const DAGInstruction &CodeGenDAGPatterns
SmallString<32> TypesString;
for (unsigned j = 0, e = I->getNumTrees(); j != e; ++j) {
TypesString.clear();
- TreePatternNode *Pat = I->getTree(j);
+ TreePatternNodePtr Pat = I->getTree(j);
if (Pat->getNumTypes() != 0) {
raw_svector_ostream OS(TypesString);
for (unsigned k = 0, ke = Pat->getNumTypes(); k != ke; ++k) {
@@ -3477,7 +3473,7 @@ const DAGInstruction &CodeGenDAGPatterns
// Check that all of the results occur first in the list.
std::vector<Record*> Results;
- SmallVector<TreePatternNode *, 2> ResNodes;
+ SmallVector<TreePatternNodePtr, 2> ResNodes;
for (unsigned i = 0; i != NumResults; ++i) {
if (i == CGI.Operands.size())
I->error("'" + InstResults.begin()->first +
@@ -3485,7 +3481,7 @@ const DAGInstruction &CodeGenDAGPatterns
const std::string &OpName = CGI.Operands[i].Name;
// Check that it exists in InstResults.
- TreePatternNode *RNode = InstResults[OpName];
+ TreePatternNodePtr RNode = InstResults[OpName];
if (!RNode)
I->error("Operand $" + OpName + " does not exist in operand list!");
@@ -3508,9 +3504,9 @@ const DAGInstruction &CodeGenDAGPatterns
// Loop over the inputs next. Make a copy of InstInputs so we can destroy
// the copy while we're checking the inputs.
- std::map<std::string, TreePatternNode*> InstInputsCheck(InstInputs);
+ std::map<std::string, TreePatternNodePtr> InstInputsCheck(InstInputs);
- std::vector<TreePatternNode*> ResultNodeOperands;
+ std::vector<TreePatternNodePtr> ResultNodeOperands;
std::vector<Record*> Operands;
for (unsigned i = NumResults, e = CGI.Operands.size(); i != e; ++i) {
CGIOperandList::OperandInfo &Op = CGI.Operands[i];
@@ -3530,7 +3526,7 @@ const DAGInstruction &CodeGenDAGPatterns
I->error("Operand $" + OpName +
" does not appear in the instruction pattern");
}
- TreePatternNode *InVal = InstInputsCheck[OpName];
+ TreePatternNodePtr InVal = InstInputsCheck[OpName];
InstInputsCheck.erase(OpName); // It occurred, remove from map.
if (InVal->isLeaf() && isa<DefInit>(InVal->getLeafValue())) {
@@ -3542,7 +3538,7 @@ const DAGInstruction &CodeGenDAGPatterns
Operands.push_back(Op.Rec);
// Construct the result for the dest-pattern operand list.
- TreePatternNode *OpNode = InVal->clone();
+ TreePatternNodePtr OpNode = InVal->clone();
// No predicate is useful on the result.
OpNode->clearPredicateFns();
@@ -3550,9 +3546,10 @@ const DAGInstruction &CodeGenDAGPatterns
// Promote the xform function to be an explicit node if set.
if (Record *Xform = OpNode->getTransformFn()) {
OpNode->setTransformFn(nullptr);
- std::vector<TreePatternNode*> Children;
+ std::vector<TreePatternNodePtr> Children;
Children.push_back(OpNode);
- OpNode = new TreePatternNode(Xform, Children, OpNode->getNumTypes());
+ OpNode = std::make_shared<TreePatternNode>(Xform, Children,
+ OpNode->getNumTypes());
}
ResultNodeOperands.push_back(OpNode);
@@ -3562,9 +3559,9 @@ const DAGInstruction &CodeGenDAGPatterns
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));
+ TreePatternNodePtr ResultPattern = std::make_shared<TreePatternNode>(
+ I->getRecord(), ResultNodeOperands,
+ GetNumNodeResults(I->getRecord(), *this));
// Copy fully inferred output node types to instruction result pattern.
for (unsigned i = 0; i != NumResults; ++i) {
assert(ResNodes[i]->getNumTypes() == 1 && "FIXME: Unhandled");
@@ -3646,8 +3643,8 @@ void CodeGenDAGPatterns::ParseInstructio
PatternRewriter(I);
// FIXME: Assume only the first tree is the pattern. The others are clobber
// nodes.
- TreePatternNode *Pattern = I->getTree(0);
- TreePatternNode *SrcPattern;
+ TreePatternNodePtr Pattern = I->getTree(0);
+ TreePatternNodePtr SrcPattern;
if (Pattern->getOperator()->getName() == "set") {
SrcPattern = Pattern->getChild(Pattern->getNumChildren()-1)->clone();
} else{
@@ -3666,10 +3663,9 @@ void CodeGenDAGPatterns::ParseInstructio
}
}
+typedef std::pair<TreePatternNode *, unsigned> NameRecord;
-typedef std::pair<const TreePatternNode*, unsigned> NameRecord;
-
-static void FindNames(const TreePatternNode *P,
+static void FindNames(TreePatternNode *P,
std::map<std::string, NameRecord> &Names,
TreePattern *PatternTop) {
if (!P->getName().empty()) {
@@ -3929,10 +3925,10 @@ void CodeGenDAGPatterns::ParsePatterns()
if (hasNullFragReference(Tree))
continue;
- TreePattern *Pattern = new TreePattern(CurPattern, Tree, true, *this);
+ TreePattern Pattern(CurPattern, Tree, true, *this);
// Inline pattern fragments into it.
- Pattern->InlinePatternFragments();
+ Pattern.InlinePatternFragments();
ListInit *LI = CurPattern->getValueAsListInit("ResultInstrs");
if (LI->empty()) continue; // no pattern.
@@ -3953,12 +3949,12 @@ void CodeGenDAGPatterns::ParsePatterns()
// Infer as many types as possible. If we cannot infer all of them, we
// can never do anything with this pattern: report it to the user.
InferredAllPatternTypes =
- Pattern->InferAllTypes(&Pattern->getNamedNodesMap());
+ Pattern.InferAllTypes(&Pattern.getNamedNodesMap());
// Infer as many types as possible. If we cannot infer all of them, we
// can never do anything with this pattern: report it to the user.
InferredAllResultTypes =
- Result.InferAllTypes(&Pattern->getNamedNodesMap());
+ Result.InferAllTypes(&Pattern.getNamedNodesMap());
IterateInference = false;
@@ -3967,12 +3963,12 @@ void CodeGenDAGPatterns::ParsePatterns()
// is considered resolved), but the result knows it needs to be 32- or
// 64-bits. Infer the other way for good measure.
for (unsigned i = 0, e = std::min(Result.getTree(0)->getNumTypes(),
- Pattern->getTree(0)->getNumTypes());
+ Pattern.getTree(0)->getNumTypes());
i != e; ++i) {
- IterateInference = Pattern->getTree(0)->UpdateNodeType(
+ IterateInference = Pattern.getTree(0)->UpdateNodeType(
i, Result.getTree(0)->getExtType(i), Result);
IterateInference |= Result.getTree(0)->UpdateNodeType(
- i, Pattern->getTree(0)->getExtType(i), Result);
+ i, Pattern.getTree(0)->getExtType(i), Result);
}
// If our iteration has converged and the input pattern's types are fully
@@ -3987,45 +3983,45 @@ void CodeGenDAGPatterns::ParsePatterns()
if (!IterateInference && InferredAllPatternTypes &&
!InferredAllResultTypes)
IterateInference =
- ForceArbitraryInstResultType(Result.getTree(0), Result);
+ ForceArbitraryInstResultType(Result.getTree(0).get(), Result);
} while (IterateInference);
// Verify that we inferred enough types that we can do something with the
// pattern and result. If these fire the user has to add type casts.
if (!InferredAllPatternTypes)
- Pattern->error("Could not infer all types in pattern!");
+ Pattern.error("Could not infer all types in pattern!");
if (!InferredAllResultTypes) {
- Pattern->dump();
+ Pattern.dump();
Result.error("Could not infer all types in pattern result!");
}
// Validate that the input pattern is correct.
- std::map<std::string, TreePatternNode*> InstInputs;
- std::map<std::string, TreePatternNode*> InstResults;
+ std::map<std::string, TreePatternNodePtr> InstInputs;
+ std::map<std::string, TreePatternNodePtr> InstResults;
std::vector<Record*> InstImpResults;
- for (unsigned j = 0, ee = Pattern->getNumTrees(); j != ee; ++j)
- FindPatternInputsAndOutputs(Pattern, Pattern->getTree(j),
- InstInputs, InstResults,
- InstImpResults);
+ for (unsigned j = 0, ee = Pattern.getNumTrees(); j != ee; ++j)
+ FindPatternInputsAndOutputs(&Pattern, Pattern.getTree(j), InstInputs,
+ InstResults, InstImpResults);
// Promote the xform function to be an explicit node if set.
- TreePatternNode *DstPattern = Result.getOnlyTree();
- std::vector<TreePatternNode*> ResultNodeOperands;
+ TreePatternNodePtr DstPattern = Result.getOnlyTree();
+ std::vector<TreePatternNodePtr> ResultNodeOperands;
for (unsigned ii = 0, ee = DstPattern->getNumChildren(); ii != ee; ++ii) {
- TreePatternNode *OpNode = DstPattern->getChild(ii);
+ TreePatternNodePtr OpNode = DstPattern->getChildShared(ii);
if (Record *Xform = OpNode->getTransformFn()) {
OpNode->setTransformFn(nullptr);
- std::vector<TreePatternNode*> Children;
+ std::vector<TreePatternNodePtr> Children;
Children.push_back(OpNode);
- OpNode = new TreePatternNode(Xform, Children, OpNode->getNumTypes());
+ OpNode = std::make_shared<TreePatternNode>(Xform, Children,
+ OpNode->getNumTypes());
}
ResultNodeOperands.push_back(OpNode);
}
DstPattern = Result.getOnlyTree();
if (!DstPattern->isLeaf())
- DstPattern = new TreePatternNode(DstPattern->getOperator(),
- ResultNodeOperands,
- DstPattern->getNumTypes());
+ DstPattern = std::make_shared<TreePatternNode>(DstPattern->getOperator(),
+ ResultNodeOperands,
+ DstPattern->getNumTypes());
for (unsigned i = 0, e = Result.getOnlyTree()->getNumTypes(); i != e; ++i)
DstPattern->setType(i, Result.getOnlyTree()->getExtType(i));
@@ -4040,18 +4036,17 @@ void CodeGenDAGPatterns::ParsePatterns()
// that register class does not accept that type, the type inference
// will lead to a contradiction, which is not an error however, but
// a sign that this pattern will simply never match.
- if (Pattern->getTree(0)->hasPossibleType() &&
+ if (Pattern.getTree(0)->hasPossibleType() &&
Temp.getOnlyTree()->hasPossibleType()) {
ListInit *Preds = CurPattern->getValueAsListInit("Predicates");
int Complexity = CurPattern->getValueAsInt("AddedComplexity");
if (PatternRewriter)
- PatternRewriter(Pattern);
- AddPatternToMatch(
- Pattern,
- PatternToMatch(
- CurPattern, makePredList(Preds), Pattern->getTree(0),
- Temp.getOnlyTree(), std::move(InstImpResults), Complexity,
- CurPattern->getID()));
+ PatternRewriter(&Pattern);
+ AddPatternToMatch(&Pattern,
+ PatternToMatch(CurPattern, makePredList(Preds),
+ Pattern.getTree(0), Temp.getOnlyTree(),
+ std::move(InstImpResults), Complexity,
+ CurPattern->getID()));
}
}
}
@@ -4071,12 +4066,10 @@ void CodeGenDAGPatterns::ExpandHwModeBas
std::vector<PatternToMatch> Copy = PatternsToMatch;
PatternsToMatch.clear();
- auto AppendPattern = [this,&ModeChecks](PatternToMatch &P, unsigned Mode) {
- TreePatternNode *NewSrc = P.SrcPattern->clone();
- TreePatternNode *NewDst = P.DstPattern->clone();
+ auto AppendPattern = [this, &ModeChecks](PatternToMatch &P, unsigned Mode) {
+ TreePatternNodePtr NewSrc = P.SrcPattern->clone();
+ TreePatternNodePtr NewDst = P.DstPattern->clone();
if (!NewSrc->setDefaultMode(Mode) || !NewDst->setDefaultMode(Mode)) {
- delete NewSrc;
- delete NewDst;
return;
}
@@ -4089,7 +4082,7 @@ void CodeGenDAGPatterns::ExpandHwModeBas
};
for (PatternToMatch &P : Copy) {
- TreePatternNode *SrcP = nullptr, *DstP = nullptr;
+ TreePatternNodePtr SrcP = nullptr, DstP = nullptr;
if (P.SrcPattern->hasProperTypeByHwMode())
SrcP = P.SrcPattern;
if (P.DstPattern->hasProperTypeByHwMode())
@@ -4101,9 +4094,9 @@ void CodeGenDAGPatterns::ExpandHwModeBas
std::set<unsigned> Modes;
if (SrcP)
- collectModes(Modes, SrcP);
+ collectModes(Modes, SrcP.get());
if (DstP)
- collectModes(Modes, DstP);
+ collectModes(Modes, DstP.get());
// The predicate for the default mode needs to be constructed for each
// pattern separately.
@@ -4185,11 +4178,11 @@ static void DumpDepVars(MultipleUseVarSe
/// CombineChildVariants - Given a bunch of permutations of each child of the
/// 'operator' node, put them together in all possible ways.
-static void CombineChildVariants(TreePatternNode *Orig,
- const std::vector<std::vector<TreePatternNode*> > &ChildVariants,
- std::vector<TreePatternNode*> &OutVariants,
- CodeGenDAGPatterns &CDP,
- const MultipleUseVarSet &DepVars) {
+static void CombineChildVariants(
+ TreePatternNodePtr Orig,
+ const std::vector<std::vector<TreePatternNodePtr>> &ChildVariants,
+ std::vector<TreePatternNodePtr> &OutVariants, CodeGenDAGPatterns &CDP,
+ const MultipleUseVarSet &DepVars) {
// Make sure that each operand has at least one variant to choose from.
for (const auto &Variants : ChildVariants)
if (Variants.empty())
@@ -4210,10 +4203,10 @@ static void CombineChildVariants(TreePat
});
#endif
// Create the variant and add it to the output list.
- std::vector<TreePatternNode*> NewChildren;
+ std::vector<TreePatternNodePtr> NewChildren;
for (unsigned i = 0, e = ChildVariants.size(); i != e; ++i)
NewChildren.push_back(ChildVariants[i][Idxs[i]]);
- auto R = llvm::make_unique<TreePatternNode>(
+ TreePatternNodePtr R = std::make_shared<TreePatternNode>(
Orig->getOperator(), NewChildren, Orig->getNumTypes());
// Copy over properties.
@@ -4230,10 +4223,10 @@ static void CombineChildVariants(TreePat
// (and GPRC:$a, GPRC:$b) -> (and GPRC:$b, GPRC:$a)
// which are the same pattern. Ignore the dups.
if (R->canPatternMatch(ErrString, CDP) &&
- none_of(OutVariants, [&](TreePatternNode *Variant) {
- return R->isIsomorphicTo(Variant, DepVars);
+ none_of(OutVariants, [&](TreePatternNodePtr Variant) {
+ return R->isIsomorphicTo(Variant.get(), DepVars);
}))
- OutVariants.push_back(R.release());
+ OutVariants.push_back(R);
// Increment indices to the next permutation by incrementing the
// indices from last index backward, e.g., generate the sequence
@@ -4251,21 +4244,21 @@ static void CombineChildVariants(TreePat
/// CombineChildVariants - A helper function for binary operators.
///
-static void CombineChildVariants(TreePatternNode *Orig,
- const std::vector<TreePatternNode*> &LHS,
- const std::vector<TreePatternNode*> &RHS,
- std::vector<TreePatternNode*> &OutVariants,
+static void CombineChildVariants(TreePatternNodePtr Orig,
+ const std::vector<TreePatternNodePtr> &LHS,
+ const std::vector<TreePatternNodePtr> &RHS,
+ std::vector<TreePatternNodePtr> &OutVariants,
CodeGenDAGPatterns &CDP,
const MultipleUseVarSet &DepVars) {
- std::vector<std::vector<TreePatternNode*> > ChildVariants;
+ std::vector<std::vector<TreePatternNodePtr>> ChildVariants;
ChildVariants.push_back(LHS);
ChildVariants.push_back(RHS);
CombineChildVariants(Orig, ChildVariants, OutVariants, CDP, DepVars);
}
-
-static void GatherChildrenOfAssociativeOpcode(TreePatternNode *N,
- std::vector<TreePatternNode *> &Children) {
+static void
+GatherChildrenOfAssociativeOpcode(TreePatternNodePtr N,
+ std::vector<TreePatternNodePtr> &Children) {
assert(N->getNumChildren()==2 &&"Associative but doesn't have 2 children!");
Record *Operator = N->getOperator();
@@ -4277,21 +4270,21 @@ static void GatherChildrenOfAssociativeO
}
if (N->getChild(0)->isLeaf() || N->getChild(0)->getOperator() != Operator)
- Children.push_back(N->getChild(0));
+ Children.push_back(N->getChildShared(0));
else
- GatherChildrenOfAssociativeOpcode(N->getChild(0), Children);
+ GatherChildrenOfAssociativeOpcode(N->getChildShared(0), Children);
if (N->getChild(1)->isLeaf() || N->getChild(1)->getOperator() != Operator)
- Children.push_back(N->getChild(1));
+ Children.push_back(N->getChildShared(1));
else
- GatherChildrenOfAssociativeOpcode(N->getChild(1), Children);
+ GatherChildrenOfAssociativeOpcode(N->getChildShared(1), Children);
}
/// GenerateVariantsOf - Given a pattern N, generate all permutations we can of
/// the (potentially recursive) pattern by using algebraic laws.
///
-static void GenerateVariantsOf(TreePatternNode *N,
- std::vector<TreePatternNode*> &OutVariants,
+static void GenerateVariantsOf(TreePatternNodePtr N,
+ std::vector<TreePatternNodePtr> &OutVariants,
CodeGenDAGPatterns &CDP,
const MultipleUseVarSet &DepVars) {
// We cannot permute leaves or ComplexPattern uses.
@@ -4306,14 +4299,14 @@ static void GenerateVariantsOf(TreePatte
// If this node is associative, re-associate.
if (NodeInfo.hasProperty(SDNPAssociative)) {
// Re-associate by pulling together all of the linked operators
- std::vector<TreePatternNode*> MaximalChildren;
+ std::vector<TreePatternNodePtr> MaximalChildren;
GatherChildrenOfAssociativeOpcode(N, MaximalChildren);
// Only handle child sizes of 3. Otherwise we'll end up trying too many
// permutations.
if (MaximalChildren.size() == 3) {
// Find the variants of all of our maximal children.
- std::vector<TreePatternNode*> AVariants, BVariants, CVariants;
+ std::vector<TreePatternNodePtr> AVariants, BVariants, CVariants;
GenerateVariantsOf(MaximalChildren[0], AVariants, CDP, DepVars);
GenerateVariantsOf(MaximalChildren[1], BVariants, CDP, DepVars);
GenerateVariantsOf(MaximalChildren[2], CVariants, CDP, DepVars);
@@ -4323,12 +4316,12 @@ static void GenerateVariantsOf(TreePatte
// Within these forms, we can also permute A/B/C.
// Generate legal pair permutations of A/B/C.
- std::vector<TreePatternNode*> ABVariants;
- std::vector<TreePatternNode*> BAVariants;
- std::vector<TreePatternNode*> ACVariants;
- std::vector<TreePatternNode*> CAVariants;
- std::vector<TreePatternNode*> BCVariants;
- std::vector<TreePatternNode*> CBVariants;
+ std::vector<TreePatternNodePtr> ABVariants;
+ std::vector<TreePatternNodePtr> BAVariants;
+ std::vector<TreePatternNodePtr> ACVariants;
+ std::vector<TreePatternNodePtr> CAVariants;
+ std::vector<TreePatternNodePtr> BCVariants;
+ std::vector<TreePatternNodePtr> CBVariants;
CombineChildVariants(N, AVariants, BVariants, ABVariants, CDP, DepVars);
CombineChildVariants(N, BVariants, AVariants, BAVariants, CDP, DepVars);
CombineChildVariants(N, AVariants, CVariants, ACVariants, CDP, DepVars);
@@ -4356,10 +4349,10 @@ static void GenerateVariantsOf(TreePatte
}
// Compute permutations of all children.
- std::vector<std::vector<TreePatternNode*> > ChildVariants;
+ std::vector<std::vector<TreePatternNodePtr>> ChildVariants;
ChildVariants.resize(N->getNumChildren());
for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i)
- GenerateVariantsOf(N->getChild(i), ChildVariants[i], CDP, DepVars);
+ GenerateVariantsOf(N->getChildShared(i), ChildVariants[i], CDP, DepVars);
// Build all permutations based on how the children were formed.
CombineChildVariants(N, ChildVariants, OutVariants, CDP, DepVars);
@@ -4388,7 +4381,7 @@ static void GenerateVariantsOf(TreePatte
// after those.
assert(NC >= 3 &&
"Commutative intrinsic should have at least 3 children!");
- std::vector<std::vector<TreePatternNode*> > Variants;
+ std::vector<std::vector<TreePatternNodePtr>> Variants;
Variants.push_back(ChildVariants[0]); // Intrinsic id.
Variants.push_back(ChildVariants[2]);
Variants.push_back(ChildVariants[1]);
@@ -4396,7 +4389,7 @@ static void GenerateVariantsOf(TreePatte
Variants.push_back(ChildVariants[i]);
CombineChildVariants(N, Variants, OutVariants, CDP, DepVars);
} else if (NC == N->getNumChildren()) {
- std::vector<std::vector<TreePatternNode*> > Variants;
+ std::vector<std::vector<TreePatternNodePtr>> Variants;
Variants.push_back(ChildVariants[1]);
Variants.push_back(ChildVariants[0]);
for (unsigned i = 2; i != NC; ++i)
@@ -4423,13 +4416,13 @@ void CodeGenDAGPatterns::GenerateVariant
//
for (unsigned i = 0, e = PatternsToMatch.size(); i != e; ++i) {
MultipleUseVarSet DepVars;
- std::vector<TreePatternNode*> Variants;
+ std::vector<TreePatternNodePtr> Variants;
FindDepVars(PatternsToMatch[i].getSrcPattern(), DepVars);
LLVM_DEBUG(errs() << "Dependent/multiply used variables: ");
LLVM_DEBUG(DumpDepVars(DepVars));
LLVM_DEBUG(errs() << "\n");
- GenerateVariantsOf(PatternsToMatch[i].getSrcPattern(), Variants, *this,
- DepVars);
+ GenerateVariantsOf(PatternsToMatch[i].getSrcPatternShared(), Variants,
+ *this, DepVars);
assert(!Variants.empty() && "Must create at least original variant!");
if (Variants.size() == 1) // No additional variants for this pattern.
@@ -4439,7 +4432,7 @@ void CodeGenDAGPatterns::GenerateVariant
PatternsToMatch[i].getSrcPattern()->dump(); errs() << "\n");
for (unsigned v = 0, e = Variants.size(); v != e; ++v) {
- TreePatternNode *Variant = Variants[v];
+ TreePatternNodePtr Variant = Variants[v];
LLVM_DEBUG(errs() << " VAR#" << v << ": "; Variant->dump();
errs() << "\n");
@@ -4465,7 +4458,7 @@ void CodeGenDAGPatterns::GenerateVariant
// Otherwise, add it to the list of patterns we have.
PatternsToMatch.push_back(PatternToMatch(
PatternsToMatch[i].getSrcRecord(), PatternsToMatch[i].getPredicates(),
- Variant, PatternsToMatch[i].getDstPattern(),
+ Variant, PatternsToMatch[i].getDstPatternShared(),
PatternsToMatch[i].getDstRegs(),
PatternsToMatch[i].getAddedComplexity(), Record::getNewUID()));
}
Modified: llvm/trunk/utils/TableGen/CodeGenDAGPatterns.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/CodeGenDAGPatterns.h?rev=333591&r1=333590&r2=333591&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/CodeGenDAGPatterns.h (original)
+++ llvm/trunk/utils/TableGen/CodeGenDAGPatterns.h Wed May 30 14:00:18 2018
@@ -43,6 +43,9 @@ class TreePatternNode;
class CodeGenDAGPatterns;
class ComplexPattern;
+/// Shared pointer for TreePatternNode.
+using TreePatternNodePtr = std::shared_ptr<TreePatternNode>;
+
/// This represents a set of MVTs. Since the underlying type for the MVT
/// is uint8_t, there are at most 256 values. To reduce the number of memory
/// allocations and deallocations, represent the set as a sequence of bits.
@@ -552,9 +555,6 @@ private:
};
-/// FIXME: TreePatternNode's can be shared in some cases (due to dag-shaped
-/// patterns), and as such should be ref counted. We currently just leak all
-/// TreePatternNode objects!
class TreePatternNode {
/// The type of each node result. Before and during type inference, each
/// result may be a set of possible types. After (successful) type inference,
@@ -581,18 +581,18 @@ class TreePatternNode {
/// it can be substituted into the resulting instruction on a pattern match.
Record *TransformFn;
- std::vector<TreePatternNode*> Children;
+ std::vector<TreePatternNodePtr> Children;
+
public:
- TreePatternNode(Record *Op, const std::vector<TreePatternNode*> &Ch,
+ TreePatternNode(Record *Op, std::vector<TreePatternNodePtr> &Ch,
unsigned NumResults)
- : Operator(Op), Val(nullptr), TransformFn(nullptr), Children(Ch) {
+ : Operator(Op), Val(nullptr), TransformFn(nullptr), Children(Ch) {
Types.resize(NumResults);
}
TreePatternNode(Init *val, unsigned NumResults) // leaf ctor
: Operator(nullptr), Val(val), TransformFn(nullptr) {
Types.resize(NumResults);
}
- ~TreePatternNode();
bool hasName() const { return !Name.empty(); }
const std::string &getName() const { return Name; }
@@ -626,15 +626,17 @@ public:
Record *getOperator() const { assert(!isLeaf()); return Operator; }
unsigned getNumChildren() const { return Children.size(); }
- TreePatternNode *getChild(unsigned N) const { return Children[N]; }
- void setChild(unsigned i, TreePatternNode *N) {
- Children[i] = N;
+ TreePatternNode *getChild(unsigned N) const { return Children[N].get(); }
+ const TreePatternNodePtr &getChildShared(unsigned N) const {
+ return Children[N];
}
+ void setChild(unsigned i, TreePatternNodePtr N) { Children[i] = N; }
/// hasChild - Return true if N is any of our children.
bool hasChild(const TreePatternNode *N) const {
for (unsigned i = 0, e = Children.size(); i != e; ++i)
- if (Children[i] == N) return true;
+ if (Children[i].get() == N)
+ return true;
return false;
}
@@ -694,7 +696,7 @@ public: // Higher level manipulation r
/// clone - Return a new copy of this tree.
///
- TreePatternNode *clone() const;
+ TreePatternNodePtr clone() const;
/// RemoveAllTypes - Recursively strip all the types of this tree.
void RemoveAllTypes();
@@ -708,13 +710,14 @@ public: // Higher level manipulation r
/// SubstituteFormalArguments - Replace the formal arguments in this tree
/// with actual values specified by ArgMap.
- void SubstituteFormalArguments(std::map<std::string,
- TreePatternNode*> &ArgMap);
+ void
+ SubstituteFormalArguments(std::map<std::string, TreePatternNodePtr> &ArgMap);
/// InlinePatternFragments - If this pattern refers to any pattern
/// fragments, inline them into place, giving us a pattern without any
/// PatFrag references.
- TreePatternNode *InlinePatternFragments(TreePattern &TP);
+ TreePatternNodePtr InlinePatternFragments(TreePatternNodePtr T,
+ TreePattern &TP);
/// ApplyTypeConstraints - Apply all of the type constraints relevant to
/// this node and its children in the tree. This returns true if it makes a
@@ -759,11 +762,11 @@ class TreePattern {
/// Trees - The list of pattern trees which corresponds to this pattern.
/// Note that PatFrag's only have a single tree.
///
- std::vector<TreePatternNode*> Trees;
+ std::vector<TreePatternNodePtr> Trees;
/// NamedNodes - This is all of the nodes that have names in the trees in this
/// pattern.
- StringMap<SmallVector<TreePatternNode*,1> > NamedNodes;
+ StringMap<SmallVector<TreePatternNode *, 1>> NamedNodes;
/// TheRecord - The actual TableGen record corresponding to this pattern.
///
@@ -802,21 +805,21 @@ public:
CodeGenDAGPatterns &ise);
TreePattern(Record *TheRec, DagInit *Pat, bool isInput,
CodeGenDAGPatterns &ise);
- TreePattern(Record *TheRec, TreePatternNode *Pat, bool isInput,
+ TreePattern(Record *TheRec, TreePatternNodePtr Pat, bool isInput,
CodeGenDAGPatterns &ise);
/// getTrees - Return the tree patterns which corresponds to this pattern.
///
- const std::vector<TreePatternNode*> &getTrees() const { return Trees; }
+ const std::vector<TreePatternNodePtr> &getTrees() const { return Trees; }
unsigned getNumTrees() const { return Trees.size(); }
- TreePatternNode *getTree(unsigned i) const { return Trees[i]; }
- void setTree(unsigned i, TreePatternNode *Tree) { Trees[i] = Tree; }
- TreePatternNode *getOnlyTree() const {
+ const TreePatternNodePtr &getTree(unsigned i) const { return Trees[i]; }
+ void setTree(unsigned i, TreePatternNodePtr Tree) { Trees[i] = Tree; }
+ TreePatternNodePtr getOnlyTree() const {
assert(Trees.size() == 1 && "Doesn't have exactly one pattern!");
return Trees[0];
}
- const StringMap<SmallVector<TreePatternNode*,1> > &getNamedNodesMap() {
+ const StringMap<SmallVector<TreePatternNode *, 1>> &getNamedNodesMap() {
if (NamedNodes.empty())
ComputeNamedNodes();
return NamedNodes;
@@ -841,14 +844,14 @@ public:
/// PatFrag references.
void InlinePatternFragments() {
for (unsigned i = 0, e = Trees.size(); i != e; ++i)
- Trees[i] = Trees[i]->InlinePatternFragments(*this);
+ Trees[i] = Trees[i]->InlinePatternFragments(Trees[i], *this);
}
/// InferAllTypes - Infer/propagate as many types throughout the expression
/// patterns as possible. Return true if all types are inferred, false
/// otherwise. Bail out if a type contradiction is found.
- bool InferAllTypes(const StringMap<SmallVector<TreePatternNode*,1> >
- *NamedTypes=nullptr);
+ bool InferAllTypes(
+ const StringMap<SmallVector<TreePatternNode *, 1>> *NamedTypes = nullptr);
/// error - If this is the first error in the current resolution step,
/// print it and set the error flag. Otherwise, continue silently.
@@ -866,7 +869,7 @@ public:
void dump() const;
private:
- TreePatternNode *ParseTreePattern(Init *DI, StringRef OpName);
+ TreePatternNodePtr ParseTreePattern(Init *DI, StringRef OpName);
void ComputeNamedNodes();
void ComputeNamedNodes(TreePatternNode *N);
};
@@ -900,7 +903,7 @@ inline bool TreePatternNode::UpdateNodeT
/// DAGDefaultOperand - One of these is created for each OperandWithDefaultOps
/// that has a set ExecuteAlways / DefaultOps field.
struct DAGDefaultOperand {
- std::vector<TreePatternNode*> DefaultOps;
+ std::vector<TreePatternNodePtr> DefaultOps;
};
class DAGInstruction {
@@ -908,7 +911,8 @@ class DAGInstruction {
std::vector<Record*> Results;
std::vector<Record*> Operands;
std::vector<Record*> ImpResults;
- TreePatternNode *ResultPattern;
+ TreePatternNodePtr ResultPattern;
+
public:
DAGInstruction(TreePattern *TP,
const std::vector<Record*> &results,
@@ -923,7 +927,7 @@ public:
unsigned getNumImpResults() const { return ImpResults.size(); }
const std::vector<Record*>& getImpResults() const { return ImpResults; }
- void setResultPattern(TreePatternNode *R) { ResultPattern = R; }
+ void setResultPattern(TreePatternNodePtr R) { ResultPattern = R; }
Record *getResult(unsigned RN) const {
assert(RN < Results.size());
@@ -940,7 +944,7 @@ public:
return ImpResults[RN];
}
- TreePatternNode *getResultPattern() const { return ResultPattern; }
+ TreePatternNodePtr getResultPattern() const { return ResultPattern; }
};
/// This class represents a condition that has to be satisfied for a pattern
@@ -995,24 +999,24 @@ public:
class PatternToMatch {
public:
PatternToMatch(Record *srcrecord, const std::vector<Predicate> &preds,
- TreePatternNode *src, TreePatternNode *dst,
- const std::vector<Record*> &dstregs,
- int complexity, unsigned uid, unsigned setmode = 0)
- : SrcRecord(srcrecord), SrcPattern(src), DstPattern(dst),
- Predicates(preds), Dstregs(std::move(dstregs)),
- AddedComplexity(complexity), ID(uid), ForceMode(setmode) {}
+ TreePatternNodePtr src, TreePatternNodePtr dst,
+ const std::vector<Record *> &dstregs, int complexity,
+ unsigned uid, unsigned setmode = 0)
+ : SrcRecord(srcrecord), SrcPattern(src), DstPattern(dst),
+ Predicates(preds), Dstregs(std::move(dstregs)),
+ AddedComplexity(complexity), ID(uid), ForceMode(setmode) {}
PatternToMatch(Record *srcrecord, std::vector<Predicate> &&preds,
- TreePatternNode *src, TreePatternNode *dst,
- std::vector<Record*> &&dstregs,
- int complexity, unsigned uid, unsigned setmode = 0)
- : SrcRecord(srcrecord), SrcPattern(src), DstPattern(dst),
- Predicates(preds), Dstregs(std::move(dstregs)),
- AddedComplexity(complexity), ID(uid), ForceMode(setmode) {}
+ TreePatternNodePtr src, TreePatternNodePtr dst,
+ std::vector<Record *> &&dstregs, int complexity, unsigned uid,
+ unsigned setmode = 0)
+ : SrcRecord(srcrecord), SrcPattern(src), DstPattern(dst),
+ Predicates(preds), Dstregs(std::move(dstregs)),
+ AddedComplexity(complexity), ID(uid), ForceMode(setmode) {}
Record *SrcRecord; // Originating Record for the pattern.
- TreePatternNode *SrcPattern; // Source pattern to match.
- TreePatternNode *DstPattern; // Resulting pattern.
+ TreePatternNodePtr SrcPattern; // Source pattern to match.
+ TreePatternNodePtr DstPattern; // Resulting pattern.
std::vector<Predicate> Predicates; // Top level predicate conditions
// to match.
std::vector<Record*> Dstregs; // Physical register defs being matched.
@@ -1021,8 +1025,10 @@ public:
unsigned ForceMode; // Force this mode in type inference when set.
Record *getSrcRecord() const { return SrcRecord; }
- TreePatternNode *getSrcPattern() const { return SrcPattern; }
- TreePatternNode *getDstPattern() const { return DstPattern; }
+ TreePatternNode *getSrcPattern() const { return SrcPattern.get(); }
+ TreePatternNodePtr getSrcPatternShared() const { return SrcPattern; }
+ TreePatternNode *getDstPattern() const { return DstPattern.get(); }
+ TreePatternNodePtr getDstPatternShared() const { return DstPattern; }
const std::vector<Record*> &getDstRegs() const { return Dstregs; }
int getAddedComplexity() const { return AddedComplexity; }
const std::vector<Predicate> &getPredicates() const { return Predicates; }
@@ -1194,12 +1200,11 @@ private:
std::vector<Predicate> makePredList(ListInit *L);
void AddPatternToMatch(TreePattern *Pattern, PatternToMatch &&PTM);
- void FindPatternInputsAndOutputs(TreePattern *I, TreePatternNode *Pat,
- std::map<std::string,
- TreePatternNode*> &InstInputs,
- std::map<std::string,
- TreePatternNode*> &InstResults,
- std::vector<Record*> &InstImpResults);
+ void FindPatternInputsAndOutputs(
+ TreePattern *I, TreePatternNodePtr Pat,
+ std::map<std::string, TreePatternNodePtr> &InstInputs,
+ std::map<std::string, TreePatternNodePtr> &InstResults,
+ std::vector<Record *> &InstImpResults);
};
Modified: llvm/trunk/utils/TableGen/DAGISelMatcherGen.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/DAGISelMatcherGen.cpp?rev=333591&r1=333590&r2=333591&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/DAGISelMatcherGen.cpp (original)
+++ llvm/trunk/utils/TableGen/DAGISelMatcherGen.cpp Wed May 30 14:00:18 2018
@@ -58,7 +58,7 @@ namespace {
/// PatWithNoTypes - This is a clone of Pattern.getSrcPattern() that starts
/// out with all of the types removed. This allows us to insert type checks
/// as we scan the tree.
- TreePatternNode *PatWithNoTypes;
+ TreePatternNodePtr PatWithNoTypes;
/// VariableMap - A map from variable names ('$dst') to the recorded operand
/// number that they were captured as. These are biased by 1 to make
@@ -101,10 +101,6 @@ namespace {
public:
MatcherGen(const PatternToMatch &pattern, const CodeGenDAGPatterns &cgp);
- ~MatcherGen() {
- delete PatWithNoTypes;
- }
-
bool EmitMatcherCode(unsigned Variant);
void EmitResultCode();
@@ -521,7 +517,8 @@ bool MatcherGen::EmitMatcherCode(unsigne
}
// Emit the matcher for the pattern structure and types.
- EmitMatchCode(Pattern.getSrcPattern(), PatWithNoTypes, Pattern.ForceMode);
+ EmitMatchCode(Pattern.getSrcPattern(), PatWithNoTypes.get(),
+ Pattern.ForceMode);
// If the pattern has a predicate on it (e.g. only enabled when a subtarget
// feature is around, do the check).
@@ -533,7 +530,7 @@ bool MatcherGen::EmitMatcherCode(unsigne
// because they are generally more expensive to evaluate and more difficult to
// factor.
for (unsigned i = 0, e = MatchedComplexPatterns.size(); i != e; ++i) {
- const TreePatternNode *N = MatchedComplexPatterns[i].first;
+ auto N = MatchedComplexPatterns[i].first;
// Remember where the results of this match get stuck.
if (N->isLeaf()) {
@@ -673,7 +670,7 @@ GetInstPatternNode(const DAGInstruction
// FIXME2?: Assume actual pattern comes before "implicit".
TreePatternNode *InstPatNode;
if (InstPat)
- InstPatNode = InstPat->getTree(0);
+ InstPatNode = InstPat->getTree(0).get();
else if (/*isRoot*/ N == Pattern.getDstPattern())
InstPatNode = Pattern.getSrcPattern();
else
@@ -784,7 +781,7 @@ EmitResultInstructionAsOperand(const Tre
const DAGDefaultOperand &DefaultOp
= CGP.getDefaultOperand(OperandNode);
for (unsigned i = 0, e = DefaultOp.DefaultOps.size(); i != e; ++i)
- EmitResultOperand(DefaultOp.DefaultOps[i], InstOps);
+ EmitResultOperand(DefaultOp.DefaultOps[i].get(), InstOps);
continue;
}
More information about the llvm-commits
mailing list