void MatcherGen::EmitMatchCode(const TreePatternNode *N, TreePatternNode *NodeNoTypes, unsigned ForceMode) { // If N and NodeNoTypes don't agree on a type, then this is a case where we // need to do a type check. Emit the check, apply the type to NodeNoTypes and // reinfer any correlated types. SmallVector<unsigned, 2> ResultsToTypeCheck; for (unsigned i = 0, e = NodeNoTypes->getNumTypes(); i != e; ++i) { if (NodeNoTypes->getExtType(i) == N->getExtType(i)) continue; NodeNoTypes->setType(i, N->getExtType(i)); InferPossibleTypes(ForceMode); ResultsToTypeCheck.push_back(i); } // If this node has a name associated with it, capture it in VariableMap. If // we already saw this in the pattern, emit code to verify dagness. SmallVector<std::string, 4> Names; if (!N->getName().empty()) Names.push_back(N->getName()); for (const ScopedName &Name : N->getNamesAsPredicateArg()) { Names.push_back(("pred:" + Twine(Name.getScope()) + ":" + Name.getIdentifier()).str()); } if (!Names.empty()) { if (!recordUniqueNode(Names)) return; } if (N->isLeaf()) EmitLeafMatchCode(N); else EmitOperatorMatchCode(N, NodeNoTypes, ForceMode); // If there are node predicates for this node, generate their checks. for (unsigned i = 0, e = N->getPredicateCalls().size(); i != e; ++i) { const TreePredicateCall &Pred = N->getPredicateCalls()[i]; SmallVector<unsigned, 4> Operands; if (Pred.Fn.usesOperands()) { TreePattern *TP = Pred.Fn.getOrigPatFragRecord(); for (unsigned i = 0; i < TP->getNumArgs(); ++i) { std::string Name = ("pred:" + Twine(Pred.Scope) + ":" + TP->getArgName(i)).str(); Operands.push_back(getNamedArgumentSlot(Name)); } } AddMatcher(new CheckPredicateMatcher(Pred.Fn, Operands)); } for (unsigned i = 0, e = ResultsToTypeCheck.size(); i != e; ++i) AddMatcher(new CheckTypeMatcher(N->getSimpleType(ResultsToTypeCheck[i]), ResultsToTypeCheck[i])); }
InstSemantics::InstSemantics(SemanticsTarget &Target, const CodeGenInstruction &CGI, const TreePattern &TP) { Flattener Flat(Target, CGI, *this); for (TreePatternNode *TPN : TP.getTrees()) Flat.flatten(TPN); }
void DAGISelEmitter::EmitPredicateFunctions(raw_ostream &OS) { OS << "\n// Predicate functions.\n"; // Walk the pattern fragments, adding them to a map, which sorts them by // name. typedef std::map<std::string, std::pair<Record*, TreePattern*> > 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) const {\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 << ") const {\n"; if (ClassName != "SDNode") OS << " " << ClassName << " *N = cast<" << ClassName << ">(inN);\n"; } OS << Code << "\n}\n"; } OS << "\n\n"; }
void MatcherTableEmitter::EmitPredicateFunctions(formatted_raw_ostream &OS) { // Emit pattern predicates. if (!PatternPredicates.empty()) { OS << "bool CheckPatternPredicate(unsigned PredNo) const {\n"; OS << " switch (PredNo) {\n"; OS << " default: assert(0 && \"Invalid predicate in table?\");\n"; for (unsigned i = 0, e = PatternPredicates.size(); i != e; ++i) OS << " case " << i << ": return " << PatternPredicates[i] << ";\n"; OS << " }\n"; OS << "}\n\n"; } // Emit Node predicates. // FIXME: Annoyingly, these are stored by name, which we never even emit. Yay? StringMap<TreePattern*> PFsByName; for (CodeGenDAGPatterns::pf_iterator I = CGP.pf_begin(), E = CGP.pf_end(); I != E; ++I) PFsByName[I->first->getName()] = I->second; if (!NodePredicates.empty()) { OS << "bool CheckNodePredicate(SDNode *Node, unsigned PredNo) const {\n"; OS << " switch (PredNo) {\n"; OS << " default: assert(0 && \"Invalid predicate in table?\");\n"; for (unsigned i = 0, e = NodePredicates.size(); i != e; ++i) { // FIXME: Storing this by name is horrible. TreePattern *P =PFsByName[NodePredicates[i].substr(strlen("Predicate_"))]; assert(P && "Unknown name?"); // Emit the predicate code corresponding to this pattern. std::string Code = P->getRecord()->getValueAsCode("Predicate"); assert(!Code.empty() && "No code in this predicate"); OS << " case " << i << ": { // " << NodePredicates[i] << '\n'; std::string ClassName; if (P->getOnlyTree()->isLeaf()) ClassName = "SDNode"; else ClassName = CGP.getSDNodeInfo(P->getOnlyTree()->getOperator()).getSDClassName(); if (ClassName == "SDNode") OS << " SDNode *N = Node;\n"; else OS << " " << ClassName << "*N = cast<" << ClassName << ">(Node);\n"; OS << Code << "\n }\n"; } OS << " }\n"; OS << "}\n\n"; } // Emit CompletePattern matchers. // FIXME: This should be const. if (!ComplexPatterns.empty()) { OS << "bool CheckComplexPattern(SDNode *Root, SDNode *Parent, SDValue N,\n"; OS << " unsigned PatternNo,\n"; OS << " SmallVectorImpl<std::pair<SDValue, SDNode*> > &Result) {\n"; OS << " unsigned NextRes = Result.size();\n"; OS << " switch (PatternNo) {\n"; OS << " default: assert(0 && \"Invalid pattern # in table?\");\n"; for (unsigned i = 0, e = ComplexPatterns.size(); i != e; ++i) { const ComplexPattern &P = *ComplexPatterns[i]; unsigned NumOps = P.getNumOperands(); if (P.hasProperty(SDNPHasChain)) ++NumOps; // Get the chained node too. OS << " case " << i << ":\n"; OS << " Result.resize(NextRes+" << NumOps << ");\n"; OS << " return " << P.getSelectFunc(); OS << "("; // If the complex pattern wants the root of the match, pass it in as the // first argument. if (P.hasProperty(SDNPWantRoot)) OS << "Root, "; // If the complex pattern wants the parent of the operand being matched, // pass it in as the next argument. if (P.hasProperty(SDNPWantParent)) OS << "Parent, "; OS << "N"; for (unsigned i = 0; i != NumOps; ++i) OS << ", Result[NextRes+" << i << "].first"; OS << ");\n"; } OS << " }\n"; OS << "}\n\n"; } // Emit SDNodeXForm handlers. // FIXME: This should be const. if (!NodeXForms.empty()) { OS << "SDValue RunSDNodeXForm(SDValue V, unsigned XFormNo) {\n"; OS << " switch (XFormNo) {\n"; OS << " default: assert(0 && \"Invalid xform # in table?\");\n"; // FIXME: The node xform could take SDValue's instead of SDNode*'s. for (unsigned i = 0, e = NodeXForms.size(); i != e; ++i) { const CodeGenDAGPatterns::NodeXForm &Entry = CGP.getSDNodeTransform(NodeXForms[i]); Record *SDNode = Entry.first; const std::string &Code = Entry.second; OS << " case " << i << ": { "; if (!OmitComments) OS << "// " << NodeXForms[i]->getName(); OS << '\n'; std::string ClassName = CGP.getSDNodeInfo(SDNode).getSDClassName(); if (ClassName == "SDNode") OS << " SDNode *N = V.getNode();\n"; else OS << " " << ClassName << " *N = cast<" << ClassName << ">(V.getNode());\n"; OS << Code << "\n }\n"; } OS << " }\n"; OS << "}\n\n"; } }