From 2fb8b5aaf9374ab64f9f360390d8c0fdbfdda3bb Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Sat, 5 Jan 2008 22:43:57 +0000 Subject: [PATCH] move predicate printing code from CodeGenDAGPatterns -> DAGISelEmitter. llvm-svn: 45634 --- utils/TableGen/CodeGenDAGPatterns.cpp | 46 +++++++---------------- utils/TableGen/CodeGenDAGPatterns.h | 2 +- utils/TableGen/DAGISelEmitter.cpp | 54 ++++++++++++++++++++++++++- utils/TableGen/DAGISelEmitter.h | 3 ++ 4 files changed, 69 insertions(+), 36 deletions(-) diff --git a/utils/TableGen/CodeGenDAGPatterns.cpp b/utils/TableGen/CodeGenDAGPatterns.cpp index 4d367648591..ec57a674c65 100644 --- a/utils/TableGen/CodeGenDAGPatterns.cpp +++ b/utils/TableGen/CodeGenDAGPatterns.cpp @@ -1119,7 +1119,7 @@ CodegenDAGPatterns::CodegenDAGPatterns(RecordKeeper &R, std::ostream &OS) ParseNodeInfo(); ParseNodeTransforms(OS); ParseComplexPatterns(); - ParsePatternFragments(OS); + ParsePatternFragments(); ParseDefaultOperands(); ParseInstructions(); ParsePatterns(); @@ -1200,23 +1200,20 @@ void CodegenDAGPatterns::ParseComplexPatterns() { /// inline fragments together as necessary, so that there are no references left /// inside a pattern fragment to a pattern fragment. /// -/// This also emits all of the predicate functions to the output file. -/// -void CodegenDAGPatterns::ParsePatternFragments(std::ostream &OS) { +void CodegenDAGPatterns::ParsePatternFragments() { std::vector Fragments = Records.getAllDerivedDefinitions("PatFrag"); - // First step, parse all of the fragments and emit predicate functions. - OS << "\n// Predicate functions.\n"; + // First step, parse all of the fragments. for (unsigned i = 0, e = Fragments.size(); i != e; ++i) { DagInit *Tree = Fragments[i]->getValueAsDag("Fragment"); TreePattern *P = new TreePattern(Fragments[i], Tree, true, *this); PatternFragments[Fragments[i]] = P; - // Validate the argument list, converting it to map, to discard duplicates. + // Validate the argument list, converting it to set, to discard duplicates. std::vector &Args = P->getArgList(); - std::set OperandsMap(Args.begin(), Args.end()); + std::set OperandsSet(Args.begin(), Args.end()); - if (OperandsMap.count("")) + if (OperandsSet.count("")) P->error("Cannot have unnamed 'node' values in pattern fragment!"); // Parse the operands list. @@ -1239,37 +1236,22 @@ void CodegenDAGPatterns::ParsePatternFragments(std::ostream &OS) { P->error("Operands list should all be 'node' values."); if (OpsList->getArgName(j).empty()) P->error("Operands list should have names for each operand!"); - if (!OperandsMap.count(OpsList->getArgName(j))) + if (!OperandsSet.count(OpsList->getArgName(j))) P->error("'" + OpsList->getArgName(j) + "' does not occur in pattern or was multiply specified!"); - OperandsMap.erase(OpsList->getArgName(j)); + OperandsSet.erase(OpsList->getArgName(j)); Args.push_back(OpsList->getArgName(j)); } - if (!OperandsMap.empty()) + if (!OperandsSet.empty()) P->error("Operands list does not contain an entry for operand '" + - *OperandsMap.begin() + "'!"); + *OperandsSet.begin() + "'!"); - // If there is a code init for this fragment, emit the predicate code and - // keep track of the fact that this fragment uses it. + // If there is a code init for this fragment, keep track of the fact that + // this fragment uses it. std::string Code = Fragments[i]->getValueAsCode("Predicate"); - if (!Code.empty()) { - if (P->getOnlyTree()->isLeaf()) - OS << "inline bool Predicate_" << Fragments[i]->getName() - << "(SDNode *N) {\n"; - else { - std::string ClassName = - getSDNodeInfo(P->getOnlyTree()->getOperator()).getSDClassName(); - const char *C2 = ClassName == "SDNode" ? "N" : "inN"; - - OS << "inline bool Predicate_" << Fragments[i]->getName() - << "(SDNode *" << C2 << ") {\n"; - if (ClassName != "SDNode") - OS << " " << ClassName << " *N = cast<" << ClassName << ">(inN);\n"; - } - OS << Code << "\n}\n"; + if (!Code.empty()) P->getOnlyTree()->setPredicateFn("Predicate_"+Fragments[i]->getName()); - } // If there is a node transformation corresponding to this, keep track of // it. @@ -1278,8 +1260,6 @@ void CodegenDAGPatterns::ParsePatternFragments(std::ostream &OS) { P->getOnlyTree()->setTransformFn(Transform); } - OS << "\n\n"; - // Now that we've parsed all of the tree fragments, do a closure on them so // that there are not references to PatFrags left inside of them. for (std::map::iterator I = PatternFragments.begin(), diff --git a/utils/TableGen/CodeGenDAGPatterns.h b/utils/TableGen/CodeGenDAGPatterns.h index d386963810c..ddeadc9bb25 100644 --- a/utils/TableGen/CodeGenDAGPatterns.h +++ b/utils/TableGen/CodeGenDAGPatterns.h @@ -532,7 +532,7 @@ private: void ParseNodeInfo(); void ParseNodeTransforms(std::ostream &OS); void ParseComplexPatterns(); - void ParsePatternFragments(std::ostream &OS); + void ParsePatternFragments(); void ParseDefaultOperands(); void ParseInstructions(); void ParsePatterns(); diff --git a/utils/TableGen/DAGISelEmitter.cpp b/utils/TableGen/DAGISelEmitter.cpp index 8632bc5ce8d..89b41a4f311 100644 --- a/utils/TableGen/DAGISelEmitter.cpp +++ b/utils/TableGen/DAGISelEmitter.cpp @@ -21,10 +21,9 @@ using namespace llvm; //===----------------------------------------------------------------------===// -// DAGISelEmitter implementation +// DAGISelEmitter Helper methods // - /// NodeIsComplexPattern - return true if N is a leaf node and a subclass of /// ComplexPattern. static bool NodeIsComplexPattern(TreePatternNode *N) { @@ -207,6 +206,55 @@ static bool PatternHasProperty(TreePatternNode *N, SDNP Property, return false; } +//===----------------------------------------------------------------------===// +// Predicate emitter implementation. +// + +void DAGISelEmitter::EmitPredicateFunctions(std::ostream &OS) { + OS << "\n// Predicate functions.\n"; + + // Walk the pattern fragments, adding them to a map, which sorts them by + // name. + typedef std::map > PFsByNameTy; + PFsByNameTy PFsByName; + + for (CodegenDAGPatterns::pf_iterator I = CGP->pf_begin(), E = CGP->pf_end(); + I != E; ++I) + PFsByName.insert(std::make_pair(I->first->getName(), *I)); + + + for (PFsByNameTy::iterator I = PFsByName.begin(), E = PFsByName.end(); + I != E; ++I) { + Record *PatFragRecord = I->second.first;// Record that derives from PatFrag. + TreePattern *P = I->second.second; + + // If there is a code init for this fragment, emit the predicate code. + std::string Code = PatFragRecord->getValueAsCode("Predicate"); + if (Code.empty()) continue; + + if (P->getOnlyTree()->isLeaf()) + OS << "inline bool Predicate_" << PatFragRecord->getName() + << "(SDNode *N) {\n"; + else { + std::string ClassName = + CGP->getSDNodeInfo(P->getOnlyTree()->getOperator()).getSDClassName(); + const char *C2 = ClassName == "SDNode" ? "N" : "inN"; + + OS << "inline bool Predicate_" << PatFragRecord->getName() + << "(SDNode *" << C2 << ") {\n"; + if (ClassName != "SDNode") + OS << " " << ClassName << " *N = cast<" << ClassName << ">(inN);\n"; + } + OS << Code << "\n}\n"; + } + + OS << "\n\n"; +} + + +//===----------------------------------------------------------------------===// +// PatternCodeEmitter implementation. +// class PatternCodeEmitter { private: CodegenDAGPatterns &CGP; @@ -1966,6 +2014,8 @@ OS << " unsigned NumKilled = ISelKilled.size();\n"; this->CGP = &CGP; + EmitPredicateFunctions(OS); + DOUT << "\n\nALL PATTERNS TO MATCH:\n\n"; for (CodegenDAGPatterns::ptm_iterator I = CGP.ptm_begin(), E = CGP.ptm_end(); I != E; ++I) { diff --git a/utils/TableGen/DAGISelEmitter.h b/utils/TableGen/DAGISelEmitter.h index 278af7812d7..0fdbbafccb6 100644 --- a/utils/TableGen/DAGISelEmitter.h +++ b/utils/TableGen/DAGISelEmitter.h @@ -33,6 +33,8 @@ public: private: + void EmitPredicateFunctions(std::ostream &OS); + void GenerateCodeForPattern(const PatternToMatch &Pattern, std::vector > &GeneratedCode, std::set &GeneratedDecl, @@ -41,6 +43,7 @@ private: void EmitPatterns(std::vector > > > &Patterns, unsigned Indent, std::ostream &OS); + void EmitInstructionSelector(std::ostream &OS); };