TreePatternNodePtr TreePatternNode::clone() const {
TreePatternNodePtr New;
if (isLeaf()) {
- New = std::make_shared<TreePatternNode>(getLeafValue(), getNumTypes());
+ New = makeIntrusiveRefCnt<TreePatternNode>(getLeafValue(), getNumTypes());
} else {
std::vector<TreePatternNodePtr> CChildren;
CChildren.reserve(Children.size());
for (unsigned i = 0, e = getNumChildren(); i != e; ++i)
CChildren.push_back(getChild(i)->clone());
- New = std::make_shared<TreePatternNode>(getOperator(), std::move(CChildren),
+ New = makeIntrusiveRefCnt<TreePatternNode>(getOperator(), std::move(CChildren),
getNumTypes());
}
New->setName(getName());
NewChildren.reserve(ChildAlternatives.size());
for (unsigned i = 0, e = ChildAlternatives.size(); i != e; ++i)
NewChildren.push_back(ChildAlternatives[i][Idxs[i]]);
- TreePatternNodePtr R = std::make_shared<TreePatternNode>(
+ TreePatternNodePtr R = makeIntrusiveRefCnt<TreePatternNode>(
T->getOperator(), std::move(NewChildren), T->getNumTypes());
// Copy over properties.
OpName);
// Input argument?
- TreePatternNodePtr Res = std::make_shared<TreePatternNode>(DI, 1);
+ TreePatternNodePtr Res = makeIntrusiveRefCnt<TreePatternNode>(DI, 1);
if (R->getName() == "node" && !OpName.empty()) {
if (OpName.empty())
error("'node' argument requires a name to match with operand list");
if (isa<UnsetInit>(TheInit)) {
if (OpName.empty())
error("'?' argument requires a name to match with operand list");
- TreePatternNodePtr Res = std::make_shared<TreePatternNode>(TheInit, 1);
+ TreePatternNodePtr Res = makeIntrusiveRefCnt<TreePatternNode>(TheInit, 1);
Args.push_back(std::string(OpName));
Res->setName(OpName);
return Res;
error("Constant int or bit argument should not have a name!");
if (isa<BitInit>(TheInit))
TheInit = TheInit->convertInitializerTo(IntRecTy::get(RK));
- return std::make_shared<TreePatternNode>(TheInit, 1);
+ return makeIntrusiveRefCnt<TreePatternNode>(TheInit, 1);
}
if (BitsInit *BI = dyn_cast<BitsInit>(TheInit)) {
else // Otherwise, no chain.
Operator = getDAGPatterns().get_intrinsic_wo_chain_sdnode();
- Children.insert(Children.begin(), std::make_shared<TreePatternNode>(
+ Children.insert(Children.begin(), makeIntrusiveRefCnt<TreePatternNode>(
IntInit::get(RK, IID), 1));
}
}
TreePatternNodePtr Result =
- std::make_shared<TreePatternNode>(Operator, std::move(Children),
+ makeIntrusiveRefCnt<TreePatternNode>(Operator, std::move(Children),
NumResults);
Result->setName(OpName);
OpNode->setTransformFn(nullptr);
std::vector<TreePatternNodePtr> Children;
Children.push_back(OpNode);
- OpNode = std::make_shared<TreePatternNode>(Xform, std::move(Children),
+ OpNode = makeIntrusiveRefCnt<TreePatternNode>(Xform, std::move(Children),
OpNode->getNumTypes());
}
I.error("Input operand $" + InstInputs.begin()->first +
" occurs in pattern but not in operands list!");
- TreePatternNodePtr ResultPattern = std::make_shared<TreePatternNode>(
+ TreePatternNodePtr ResultPattern = makeIntrusiveRefCnt<TreePatternNode>(
I.getRecord(), std::move(ResultNodeOperands),
GetNumNodeResults(I.getRecord(), *this));
// Copy fully inferred output node types to instruction result pattern.
N->setTransformFn(nullptr);
std::vector<TreePatternNodePtr> Children;
Children.push_back(PromoteXForms(N));
- return std::make_shared<TreePatternNode>(Xform, std::move(Children),
+ return makeIntrusiveRefCnt<TreePatternNode>(Xform, std::move(Children),
N->getNumTypes());
}
std::vector<TreePatternNodePtr> NewChildren;
for (unsigned i = 0, e = ChildVariants.size(); i != e; ++i)
NewChildren.push_back(ChildVariants[i][Idxs[i]]);
- TreePatternNodePtr R = std::make_shared<TreePatternNode>(
+ TreePatternNodePtr R = makeIntrusiveRefCnt<TreePatternNode>(
Orig->getOperator(), std::move(NewChildren), Orig->getNumTypes());
// Copy over properties.
#include "CodeGenIntrinsics.h"
#include "CodeGenTarget.h"
#include "SDNodeProperties.h"
+#include "llvm/ADT/IntrusiveRefCntPtr.h"
#include "llvm/ADT/MapVector.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringMap.h"
class CodeGenDAGPatterns;
/// Shared pointer for TreePatternNode.
-using TreePatternNodePtr = std::shared_ptr<TreePatternNode>;
+using TreePatternNodePtr = IntrusiveRefCntPtr<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
}
};
-class TreePatternNode {
+class TreePatternNode : public RefCountedBase<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,
/// each is a single concrete type.