From 8ef9c7958ad7a23ad15d7ff59e1377aec10ca42a Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Thu, 18 Feb 2010 02:49:24 +0000 Subject: [PATCH] eliminate the MatcherNodeWithChild class, give the 'child' field to MatcherNode. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96560 91177308-0d34-0410-b5e6-96231b3b80d8 --- utils/TableGen/DAGISelMatcher.cpp | 2 +- utils/TableGen/DAGISelMatcher.h | 96 +++++++++++------------- utils/TableGen/DAGISelMatcherEmitter.cpp | 8 +- utils/TableGen/DAGISelMatcherGen.cpp | 14 ++-- 4 files changed, 53 insertions(+), 67 deletions(-) diff --git a/utils/TableGen/DAGISelMatcher.cpp b/utils/TableGen/DAGISelMatcher.cpp index 83061093bc1..c6d18ce7dd2 100644 --- a/utils/TableGen/DAGISelMatcher.cpp +++ b/utils/TableGen/DAGISelMatcher.cpp @@ -22,7 +22,7 @@ void EmitNodeMatcherNode::print(raw_ostream &OS, unsigned indent) const { OS.indent(indent) << "EmitNode: Dst = " << *Pattern.getDstPattern() << "\n"; } -void MatcherNodeWithChild::printChild(raw_ostream &OS, unsigned indent) const { +void MatcherNode::printChild(raw_ostream &OS, unsigned indent) const { if (Child) return Child->print(OS, indent); OS.indent(indent) << "\n"; diff --git a/utils/TableGen/DAGISelMatcher.h b/utils/TableGen/DAGISelMatcher.h index 3aa29cdbe25..4eb11010de9 100644 --- a/utils/TableGen/DAGISelMatcher.h +++ b/utils/TableGen/DAGISelMatcher.h @@ -31,6 +31,7 @@ void EmitMatcherTable(const MatcherNode *Matcher, raw_ostream &OS); /// MatcherNode - Base class for all the the DAG ISel Matcher representation /// nodes. class MatcherNode { + OwningPtr Child; public: enum KindTy { EmitNode, @@ -54,19 +55,24 @@ public: CheckChainCompatible }; const KindTy Kind; - + protected: MatcherNode(KindTy K) : Kind(K) {} public: virtual ~MatcherNode() {} KindTy getKind() const { return Kind; } - + + MatcherNode *getChild() { return Child.get(); } + const MatcherNode *getChild() const { return Child.get(); } + void setChild(MatcherNode *C) { Child.reset(C); } static inline bool classof(const MatcherNode *) { return true; } virtual void print(raw_ostream &OS, unsigned indent = 0) const = 0; void dump() const; +protected: + void printChild(raw_ostream &OS, unsigned indent) const; }; /// EmitNodeMatcherNode - This signals a successful match and generates a node. @@ -85,33 +91,15 @@ public: virtual void print(raw_ostream &OS, unsigned indent = 0) const; }; -/// MatcherNodeWithChild - Every node accept the final accept state has a child -/// that is executed after the node runs. This class captures this commonality. -class MatcherNodeWithChild : public MatcherNode { - OwningPtr Child; -public: - MatcherNodeWithChild(KindTy K) : MatcherNode(K) {} - - MatcherNode *getChild() { return Child.get(); } - const MatcherNode *getChild() const { return Child.get(); } - void setChild(MatcherNode *C) { Child.reset(C); } - - static inline bool classof(const MatcherNode *N) { - return N->getKind() != EmitNode; - } - -protected: - void printChild(raw_ostream &OS, unsigned indent) const; -}; /// PushMatcherNode - This pushes a failure scope on the stack and evaluates /// 'child'. If 'child' fails to match, it pops its scope and attempts to /// match 'Failure'. -class PushMatcherNode : public MatcherNodeWithChild { +class PushMatcherNode : public MatcherNode { OwningPtr Failure; public: PushMatcherNode(MatcherNode *child = 0, MatcherNode *failure = 0) - : MatcherNodeWithChild(Push), Failure(failure) { + : MatcherNode(Push), Failure(failure) { setChild(child); } @@ -127,13 +115,13 @@ public: }; /// RecordMatcherNode - Save the current node in the operand list. -class RecordMatcherNode : public MatcherNodeWithChild { +class RecordMatcherNode : public MatcherNode { /// WhatFor - This is a string indicating why we're recording this. This /// should only be used for comment generation not anything semantic. std::string WhatFor; public: RecordMatcherNode(const std::string &whatfor) - : MatcherNodeWithChild(Record), WhatFor(whatfor) {} + : MatcherNode(Record), WhatFor(whatfor) {} const std::string &getWhatFor() const { return WhatFor; } @@ -146,11 +134,11 @@ public: /// MoveChildMatcherNode - This tells the interpreter to move into the /// specified child node. -class MoveChildMatcherNode : public MatcherNodeWithChild { +class MoveChildMatcherNode : public MatcherNode { unsigned ChildNo; public: MoveChildMatcherNode(unsigned childNo) - : MatcherNodeWithChild(MoveChild), ChildNo(childNo) {} + : MatcherNode(MoveChild), ChildNo(childNo) {} unsigned getChildNo() const { return ChildNo; } @@ -163,10 +151,10 @@ public: /// MoveParentMatcherNode - This tells the interpreter to move to the parent /// of the current node. -class MoveParentMatcherNode : public MatcherNodeWithChild { +class MoveParentMatcherNode : public MatcherNode { public: MoveParentMatcherNode() - : MatcherNodeWithChild(MoveParent) {} + : MatcherNode(MoveParent) {} static inline bool classof(const MatcherNode *N) { return N->getKind() == MoveParent; @@ -178,11 +166,11 @@ public: /// CheckSameMatcherNode - This checks to see if this node is exactly the same /// node as the specified match that was recorded with 'Record'. This is used /// when patterns have the same name in them, like '(mul GPR:$in, GPR:$in)'. -class CheckSameMatcherNode : public MatcherNodeWithChild { +class CheckSameMatcherNode : public MatcherNode { unsigned MatchNumber; public: CheckSameMatcherNode(unsigned matchnumber) - : MatcherNodeWithChild(CheckSame), MatchNumber(matchnumber) {} + : MatcherNode(CheckSame), MatchNumber(matchnumber) {} unsigned getMatchNumber() const { return MatchNumber; } @@ -196,11 +184,11 @@ public: /// CheckPatternPredicateMatcherNode - This checks the target-specific predicate /// to see if the entire pattern is capable of matching. This predicate does /// not take a node as input. This is used for subtarget feature checks etc. -class CheckPatternPredicateMatcherNode : public MatcherNodeWithChild { +class CheckPatternPredicateMatcherNode : public MatcherNode { std::string Predicate; public: CheckPatternPredicateMatcherNode(StringRef predicate) - : MatcherNodeWithChild(CheckPatternPredicate), Predicate(predicate) {} + : MatcherNode(CheckPatternPredicate), Predicate(predicate) {} StringRef getPredicate() const { return Predicate; } @@ -213,11 +201,11 @@ public: /// CheckPredicateMatcherNode - This checks the target-specific predicate to /// see if the node is acceptable. -class CheckPredicateMatcherNode : public MatcherNodeWithChild { +class CheckPredicateMatcherNode : public MatcherNode { StringRef PredName; public: CheckPredicateMatcherNode(StringRef predname) - : MatcherNodeWithChild(CheckPredicate), PredName(predname) {} + : MatcherNode(CheckPredicate), PredName(predname) {} StringRef getPredicateName() const { return PredName; } @@ -231,11 +219,11 @@ public: /// CheckOpcodeMatcherNode - This checks to see if the current node has the /// specified opcode, if not it fails to match. -class CheckOpcodeMatcherNode : public MatcherNodeWithChild { +class CheckOpcodeMatcherNode : public MatcherNode { StringRef OpcodeName; public: CheckOpcodeMatcherNode(StringRef opcodename) - : MatcherNodeWithChild(CheckOpcode), OpcodeName(opcodename) {} + : MatcherNode(CheckOpcode), OpcodeName(opcodename) {} StringRef getOpcodeName() const { return OpcodeName; } @@ -248,11 +236,11 @@ public: /// CheckTypeMatcherNode - This checks to see if the current node has the /// specified type, if not it fails to match. -class CheckTypeMatcherNode : public MatcherNodeWithChild { +class CheckTypeMatcherNode : public MatcherNode { MVT::SimpleValueType Type; public: CheckTypeMatcherNode(MVT::SimpleValueType type) - : MatcherNodeWithChild(CheckType), Type(type) {} + : MatcherNode(CheckType), Type(type) {} MVT::SimpleValueType getType() const { return Type; } @@ -265,11 +253,11 @@ public: /// CheckIntegerMatcherNode - This checks to see if the current node is a /// ConstantSDNode with the specified integer value, if not it fails to match. -class CheckIntegerMatcherNode : public MatcherNodeWithChild { +class CheckIntegerMatcherNode : public MatcherNode { int64_t Value; public: CheckIntegerMatcherNode(int64_t value) - : MatcherNodeWithChild(CheckInteger), Value(value) {} + : MatcherNode(CheckInteger), Value(value) {} int64_t getValue() const { return Value; } @@ -282,11 +270,11 @@ public: /// CheckCondCodeMatcherNode - This checks to see if the current node is a /// CondCodeSDNode with the specified condition, if not it fails to match. -class CheckCondCodeMatcherNode : public MatcherNodeWithChild { +class CheckCondCodeMatcherNode : public MatcherNode { StringRef CondCodeName; public: CheckCondCodeMatcherNode(StringRef condcodename) - : MatcherNodeWithChild(CheckCondCode), CondCodeName(condcodename) {} + : MatcherNode(CheckCondCode), CondCodeName(condcodename) {} StringRef getCondCodeName() const { return CondCodeName; } @@ -299,11 +287,11 @@ public: /// CheckValueTypeMatcherNode - This checks to see if the current node is a /// VTSDNode with the specified type, if not it fails to match. -class CheckValueTypeMatcherNode : public MatcherNodeWithChild { +class CheckValueTypeMatcherNode : public MatcherNode { StringRef TypeName; public: CheckValueTypeMatcherNode(StringRef type_name) - : MatcherNodeWithChild(CheckValueType), TypeName(type_name) {} + : MatcherNode(CheckValueType), TypeName(type_name) {} StringRef getTypeName() const { return TypeName; } @@ -318,11 +306,11 @@ public: /// CheckComplexPatMatcherNode - This node runs the specified ComplexPattern on /// the current node. -class CheckComplexPatMatcherNode : public MatcherNodeWithChild { +class CheckComplexPatMatcherNode : public MatcherNode { const ComplexPattern &Pattern; public: CheckComplexPatMatcherNode(const ComplexPattern &pattern) - : MatcherNodeWithChild(CheckComplexPat), Pattern(pattern) {} + : MatcherNode(CheckComplexPat), Pattern(pattern) {} const ComplexPattern &getPattern() const { return Pattern; } @@ -335,11 +323,11 @@ public: /// CheckAndImmMatcherNode - This checks to see if the current node is an 'and' /// with something equivalent to the specified immediate. -class CheckAndImmMatcherNode : public MatcherNodeWithChild { +class CheckAndImmMatcherNode : public MatcherNode { int64_t Value; public: CheckAndImmMatcherNode(int64_t value) - : MatcherNodeWithChild(CheckAndImm), Value(value) {} + : MatcherNode(CheckAndImm), Value(value) {} int64_t getValue() const { return Value; } @@ -352,11 +340,11 @@ public: /// CheckOrImmMatcherNode - This checks to see if the current node is an 'and' /// with something equivalent to the specified immediate. -class CheckOrImmMatcherNode : public MatcherNodeWithChild { +class CheckOrImmMatcherNode : public MatcherNode { int64_t Value; public: CheckOrImmMatcherNode(int64_t value) - : MatcherNodeWithChild(CheckOrImm), Value(value) {} + : MatcherNode(CheckOrImm), Value(value) {} int64_t getValue() const { return Value; } @@ -369,10 +357,10 @@ public: /// CheckFoldableChainNodeMatcherNode - This checks to see if the current node /// (which defines a chain operand) is safe to fold into a larger pattern. -class CheckFoldableChainNodeMatcherNode : public MatcherNodeWithChild { +class CheckFoldableChainNodeMatcherNode : public MatcherNode { public: CheckFoldableChainNodeMatcherNode() - : MatcherNodeWithChild(CheckFoldableChainNode) {} + : MatcherNode(CheckFoldableChainNode) {} static inline bool classof(const MatcherNode *N) { return N->getKind() == CheckFoldableChainNode; @@ -383,11 +371,11 @@ public: /// CheckChainCompatibleMatcherNode - Verify that the current node's chain /// operand is 'compatible' with the specified recorded node's. -class CheckChainCompatibleMatcherNode : public MatcherNodeWithChild { +class CheckChainCompatibleMatcherNode : public MatcherNode { unsigned PreviousOp; public: CheckChainCompatibleMatcherNode(unsigned previousop) - : MatcherNodeWithChild(CheckChainCompatible), PreviousOp(previousop) {} + : MatcherNode(CheckChainCompatible), PreviousOp(previousop) {} unsigned getPreviousOp() const { return PreviousOp; } diff --git a/utils/TableGen/DAGISelMatcherEmitter.cpp b/utils/TableGen/DAGISelMatcherEmitter.cpp index c284761de8e..ea134fe9d2f 100644 --- a/utils/TableGen/DAGISelMatcherEmitter.cpp +++ b/utils/TableGen/DAGISelMatcherEmitter.cpp @@ -221,7 +221,7 @@ EmitMatcher(const MatcherNode *N, unsigned Indent) { unsigned MatcherTableEmitter:: EmitMatcherAndChildren(const MatcherNode *N, unsigned Indent) { unsigned Size = 0; - while (1) { + while (N) { // Push is a special case since it is binary. if (const PushMatcherNode *PMN = dyn_cast(N)) { // We need to encode the child and the offset of the failure code before @@ -256,11 +256,9 @@ EmitMatcherAndChildren(const MatcherNode *N, unsigned Indent) { // If there are children of this node, iterate to them, otherwise we're // done. - if (const MatcherNodeWithChild *MNWC = dyn_cast(N)) - N = MNWC->getChild(); - else - return Size; + N = N->getChild(); } + return Size; } void MatcherTableEmitter::EmitPredicateFunctions() { diff --git a/utils/TableGen/DAGISelMatcherGen.cpp b/utils/TableGen/DAGISelMatcherGen.cpp index 8efcb4f982f..abe0d2a6f84 100644 --- a/utils/TableGen/DAGISelMatcherGen.cpp +++ b/utils/TableGen/DAGISelMatcherGen.cpp @@ -35,11 +35,11 @@ namespace { SmallVector InputChains; /// Matcher - This is the top level of the generated matcher, the result. - MatcherNodeWithChild *Matcher; + MatcherNode *Matcher; /// CurPredicate - As we emit matcher nodes, this points to the latest check /// which should have future checks stuck into its child position. - MatcherNodeWithChild *CurPredicate; + MatcherNode *CurPredicate; public: MatcherGen(const PatternToMatch &pattern, const CodeGenDAGPatterns &cgp); @@ -49,10 +49,10 @@ namespace { void EmitMatcherCode(); - MatcherNodeWithChild *GetMatcher() const { return Matcher; } - MatcherNodeWithChild *GetCurPredicate() const { return CurPredicate; } + MatcherNode *GetMatcher() const { return Matcher; } + MatcherNode *GetCurPredicate() const { return CurPredicate; } private: - void AddMatcherNode(MatcherNodeWithChild *NewNode); + void AddMatcherNode(MatcherNode *NewNode); void InferPossibleTypes(); void EmitMatchCode(const TreePatternNode *N, TreePatternNode *NodeNoTypes); void EmitLeafMatchCode(const TreePatternNode *N); @@ -107,7 +107,7 @@ void MatcherGen::InferPossibleTypes() { /// AddMatcherNode - Add a matcher node to the current graph we're building. -void MatcherGen::AddMatcherNode(MatcherNodeWithChild *NewNode) { +void MatcherGen::AddMatcherNode(MatcherNode *NewNode) { if (CurPredicate != 0) CurPredicate->setChild(NewNode); else @@ -388,7 +388,7 @@ MatcherNode *llvm::ConvertPatternToMatcher(const PatternToMatch &Pattern, EmitNodeMatcherNode *Result = new EmitNodeMatcherNode(Pattern); // Link it into the pattern. - if (MatcherNodeWithChild *Pred = Gen.GetCurPredicate()) { + if (MatcherNode *Pred = Gen.GetCurPredicate()) { Pred->setChild(Result); return Gen.GetMatcher(); }