TreePatternNode *Pattern::ParseTreePattern(DagInit *Dag) { Record *Operator = Dag->getNodeType(); if (Operator->isSubClassOf("ValueType")) { // If the operator is a ValueType, then this must be "type cast" of a leaf // node. if (Dag->getNumArgs() != 1) error("Type cast only valid for a leaf node!"); Init *Arg = Dag->getArg(0); TreePatternNode *New; if (DefInit *DI = dynamic_cast<DefInit*>(Arg)) { New = new TreePatternNode(DI); // If it's a regclass or something else known, set the type. New->setType(getIntrinsicType(DI->getDef())); } else if (DagInit *DI = dynamic_cast<DagInit*>(Arg)) { New = ParseTreePattern(DI); } else { Arg->dump(); error("Unknown leaf value for tree pattern!"); return 0; } // Apply the type cast... New->updateNodeType(getValueType(Operator), TheRecord->getName()); return New; } if (!ISE.getNodeTypes().count(Operator)) error("Unrecognized node '" + Operator->getName() + "'!"); std::vector<std::pair<TreePatternNode*, std::string> > Children; for (unsigned i = 0, e = Dag->getNumArgs(); i != e; ++i) { Init *Arg = Dag->getArg(i); if (DagInit *DI = dynamic_cast<DagInit*>(Arg)) { Children.push_back(std::make_pair(ParseTreePattern(DI), Dag->getArgName(i))); } else if (DefInit *DefI = dynamic_cast<DefInit*>(Arg)) { Record *R = DefI->getDef(); // Direct reference to a leaf DagNode? Turn it into a DagNode if its own. if (R->isSubClassOf("DagNode")) { Dag->setArg(i, new DagInit(R, std::vector<std::pair<Init*, std::string> >())); --i; // Revisit this node... } else { Children.push_back(std::make_pair(new TreePatternNode(DefI), Dag->getArgName(i))); // If it's a regclass or something else known, set the type. Children.back().first->setType(getIntrinsicType(R)); } } else { Arg->dump(); error("Unknown leaf value for tree pattern!"); } } return new TreePatternNode(Operator, Children); }
/// clone - Make a copy of this tree and all of its children. /// TreePatternNode *TreePatternNode::clone() const { TreePatternNode *New; if (isLeaf()) { New = new TreePatternNode(Value); } else { std::vector<std::pair<TreePatternNode*, std::string> > CChildren; CChildren.reserve(Children.size()); for (unsigned i = 0, e = getNumChildren(); i != e; ++i) CChildren.push_back(std::make_pair(getChild(i)->clone(),getChildName(i))); New = new TreePatternNode(Operator, CChildren); } New->setType(Type); return New; }
/// GetInstPatternNode - Get the pattern for an instruction. /// const TreePatternNode *MatcherGen:: GetInstPatternNode(const DAGInstruction &Inst, const TreePatternNode *N) { const TreePattern *InstPat = Inst.getPattern(); // FIXME2?: Assume actual pattern comes before "implicit". TreePatternNode *InstPatNode; if (InstPat) InstPatNode = InstPat->getTree(0); else if (/*isRoot*/ N == Pattern.getDstPattern()) InstPatNode = Pattern.getSrcPattern(); else return 0; if (InstPatNode && !InstPatNode->isLeaf() && InstPatNode->getOperator()->getName() == "set") InstPatNode = InstPatNode->getChild(InstPatNode->getNumChildren()-1); return InstPatNode; }
/// getPatternSize - Return the 'size' of this pattern. We want to match large /// patterns before small ones. This is used to determine the size of a /// pattern. static unsigned getPatternSize(TreePatternNode *P, CodeGenDAGPatterns &CGP) { assert((EEVT::isExtIntegerInVTs(P->getExtTypes()) || EEVT::isExtFloatingPointInVTs(P->getExtTypes()) || P->getExtTypeNum(0) == MVT::isVoid || P->getExtTypeNum(0) == MVT::Flag || P->getExtTypeNum(0) == MVT::iPTR || P->getExtTypeNum(0) == MVT::iPTRAny) && "Not a valid pattern node to size!"); unsigned Size = 3; // The node itself. // If the root node is a ConstantSDNode, increases its size. // e.g. (set R32:$dst, 0). if (P->isLeaf() && dynamic_cast<IntInit*>(P->getLeafValue())) Size += 2; // FIXME: This is a hack to statically increase the priority of patterns // which maps a sub-dag to a complex pattern. e.g. favors LEA over ADD. // Later we can allow complexity / cost for each pattern to be (optionally) // specified. To get best possible pattern match we'll need to dynamically // calculate the complexity of all patterns a dag can potentially map to. const ComplexPattern *AM = P->getComplexPatternInfo(CGP); if (AM) Size += AM->getNumOperands() * 3; // If this node has some predicate function that must match, it adds to the // complexity of this node. if (!P->getPredicateFns().empty()) ++Size; // Count children in the count if they are also nodes. for (unsigned i = 0, e = P->getNumChildren(); i != e; ++i) { TreePatternNode *Child = P->getChild(i); if (!Child->isLeaf() && Child->getExtTypeNum(0) != MVT::Other) Size += getPatternSize(Child, CGP); else if (Child->isLeaf()) { if (dynamic_cast<IntInit*>(Child->getLeafValue())) Size += 5; // Matches a ConstantSDNode (+3) and a specific value (+2). else if (Child->getComplexPatternInfo(CGP)) Size += getPatternSize(Child, CGP); else if (!Child->getPredicateFns().empty()) ++Size; } } return Size; }
void FastISelMap::CollectPatterns(CodeGenDAGPatterns &CGP) { const CodeGenTarget &Target = CGP.getTargetInfo(); // Determine the target's namespace name. InstNS = Target.getInstNamespace() + "::"; assert(InstNS.size() > 2 && "Can't determine target-specific namespace!"); // Scan through all the patterns and record the simple ones. for (CodeGenDAGPatterns::ptm_iterator I = CGP.ptm_begin(), E = CGP.ptm_end(); I != E; ++I) { const PatternToMatch &Pattern = *I; // For now, just look at Instructions, so that we don't have to worry // about emitting multiple instructions for a pattern. TreePatternNode *Dst = Pattern.getDstPattern(); if (Dst->isLeaf()) continue; Record *Op = Dst->getOperator(); if (!Op->isSubClassOf("Instruction")) continue; CodeGenInstruction &II = CGP.getTargetInfo().getInstruction(Op->getName()); if (II.OperandList.empty()) continue; // For now, ignore multi-instruction patterns. bool MultiInsts = false; for (unsigned i = 0, e = Dst->getNumChildren(); i != e; ++i) { TreePatternNode *ChildOp = Dst->getChild(i); if (ChildOp->isLeaf()) continue; if (ChildOp->getOperator()->isSubClassOf("Instruction")) { MultiInsts = true; break; } } if (MultiInsts) continue; // For now, ignore instructions where the first operand is not an // output register. const CodeGenRegisterClass *DstRC = 0; unsigned SubRegNo = ~0; if (Op->getName() != "EXTRACT_SUBREG") { Record *Op0Rec = II.OperandList[0].Rec; if (!Op0Rec->isSubClassOf("RegisterClass")) continue; DstRC = &Target.getRegisterClass(Op0Rec); if (!DstRC) continue; } else { SubRegNo = static_cast<IntInit*>( Dst->getChild(1)->getLeafValue())->getValue(); } // Inspect the pattern. TreePatternNode *InstPatNode = Pattern.getSrcPattern(); if (!InstPatNode) continue; if (InstPatNode->isLeaf()) continue; Record *InstPatOp = InstPatNode->getOperator(); std::string OpcodeName = getOpcodeName(InstPatOp, CGP); MVT::SimpleValueType RetVT = InstPatNode->getTypeNum(0); MVT::SimpleValueType VT = RetVT; if (InstPatNode->getNumChildren()) VT = InstPatNode->getChild(0)->getTypeNum(0); // For now, filter out instructions which just set a register to // an Operand or an immediate, like MOV32ri. if (InstPatOp->isSubClassOf("Operand")) continue; // For now, filter out any instructions with predicates. if (!InstPatNode->getPredicateFns().empty()) continue; // Check all the operands. OperandsSignature Operands; if (!Operands.initialize(InstPatNode, Target, VT)) continue; std::vector<std::string>* PhysRegInputs = new std::vector<std::string>(); if (!InstPatNode->isLeaf() && (InstPatNode->getOperator()->getName() == "imm" || InstPatNode->getOperator()->getName() == "fpimmm")) PhysRegInputs->push_back(""); else if (!InstPatNode->isLeaf()) { for (unsigned i = 0, e = InstPatNode->getNumChildren(); i != e; ++i) { TreePatternNode *Op = InstPatNode->getChild(i); if (!Op->isLeaf()) { PhysRegInputs->push_back(""); continue; } DefInit *OpDI = dynamic_cast<DefInit*>(Op->getLeafValue()); Record *OpLeafRec = OpDI->getDef(); std::string PhysReg; if (OpLeafRec->isSubClassOf("Register")) { PhysReg += static_cast<StringInit*>(OpLeafRec->getValue( \ "Namespace")->getValue())->getValue(); PhysReg += "::"; std::vector<CodeGenRegister> Regs = Target.getRegisters(); for (unsigned i = 0; i < Regs.size(); ++i) { if (Regs[i].TheDef == OpLeafRec) { PhysReg += Regs[i].getName(); break; } } } PhysRegInputs->push_back(PhysReg); } } else PhysRegInputs->push_back(""); // Get the predicate that guards this pattern. std::string PredicateCheck = Pattern.getPredicateCheck(); // Ok, we found a pattern that we can handle. Remember it. InstructionMemo Memo = { Pattern.getDstPattern()->getOperator()->getName(), DstRC, SubRegNo, PhysRegInputs }; assert(!SimplePatterns[Operands][OpcodeName][VT][RetVT].count(PredicateCheck) && "Duplicate pattern!"); SimplePatterns[Operands][OpcodeName][VT][RetVT][PredicateCheck] = Memo; } }
void FastISelMap::collectPatterns(CodeGenDAGPatterns &CGP) { const CodeGenTarget &Target = CGP.getTargetInfo(); // Determine the target's namespace name. InstNS = Target.getInstNamespace() + "::"; assert(InstNS.size() > 2 && "Can't determine target-specific namespace!"); // Scan through all the patterns and record the simple ones. for (CodeGenDAGPatterns::ptm_iterator I = CGP.ptm_begin(), E = CGP.ptm_end(); I != E; ++I) { const PatternToMatch &Pattern = *I; // For now, just look at Instructions, so that we don't have to worry // about emitting multiple instructions for a pattern. TreePatternNode *Dst = Pattern.getDstPattern(); if (Dst->isLeaf()) continue; Record *Op = Dst->getOperator(); if (!Op->isSubClassOf("Instruction")) continue; CodeGenInstruction &II = CGP.getTargetInfo().getInstruction(Op); if (II.Operands.empty()) continue; // For now, ignore multi-instruction patterns. bool MultiInsts = false; for (unsigned i = 0, e = Dst->getNumChildren(); i != e; ++i) { TreePatternNode *ChildOp = Dst->getChild(i); if (ChildOp->isLeaf()) continue; if (ChildOp->getOperator()->isSubClassOf("Instruction")) { MultiInsts = true; break; } } if (MultiInsts) continue; // For now, ignore instructions where the first operand is not an // output register. const CodeGenRegisterClass *DstRC = nullptr; std::string SubRegNo; if (Op->getName() != "EXTRACT_SUBREG") { Record *Op0Rec = II.Operands[0].Rec; if (Op0Rec->isSubClassOf("RegisterOperand")) Op0Rec = Op0Rec->getValueAsDef("RegClass"); if (!Op0Rec->isSubClassOf("RegisterClass")) continue; DstRC = &Target.getRegisterClass(Op0Rec); if (!DstRC) continue; } else { // If this isn't a leaf, then continue since the register classes are // a bit too complicated for now. if (!Dst->getChild(1)->isLeaf()) continue; DefInit *SR = dyn_cast<DefInit>(Dst->getChild(1)->getLeafValue()); if (SR) SubRegNo = getQualifiedName(SR->getDef()); else SubRegNo = Dst->getChild(1)->getLeafValue()->getAsString(); } // Inspect the pattern. TreePatternNode *InstPatNode = Pattern.getSrcPattern(); if (!InstPatNode) continue; if (InstPatNode->isLeaf()) continue; // Ignore multiple result nodes for now. if (InstPatNode->getNumTypes() > 1) continue; Record *InstPatOp = InstPatNode->getOperator(); std::string OpcodeName = getOpcodeName(InstPatOp, CGP); MVT::SimpleValueType RetVT = MVT::isVoid; if (InstPatNode->getNumTypes()) RetVT = InstPatNode->getType(0); MVT::SimpleValueType VT = RetVT; if (InstPatNode->getNumChildren()) { assert(InstPatNode->getChild(0)->getNumTypes() == 1); VT = InstPatNode->getChild(0)->getType(0); } // For now, filter out any instructions with predicates. if (!InstPatNode->getPredicateFns().empty()) continue; // Check all the operands. OperandsSignature Operands; if (!Operands.initialize(InstPatNode, Target, VT, ImmediatePredicates, DstRC)) continue; std::vector<std::string>* PhysRegInputs = new std::vector<std::string>(); if (InstPatNode->getOperator()->getName() == "imm" || InstPatNode->getOperator()->getName() == "fpimm") PhysRegInputs->push_back(""); else { // Compute the PhysRegs used by the given pattern, and check that // the mapping from the src to dst patterns is simple. bool FoundNonSimplePattern = false; unsigned DstIndex = 0; for (unsigned i = 0, e = InstPatNode->getNumChildren(); i != e; ++i) { std::string PhysReg = PhyRegForNode(InstPatNode->getChild(i), Target); if (PhysReg.empty()) { if (DstIndex >= Dst->getNumChildren() || Dst->getChild(DstIndex)->getName() != InstPatNode->getChild(i)->getName()) { FoundNonSimplePattern = true; break; } ++DstIndex; } PhysRegInputs->push_back(PhysReg); } if (Op->getName() != "EXTRACT_SUBREG" && DstIndex < Dst->getNumChildren()) FoundNonSimplePattern = true; if (FoundNonSimplePattern) continue; } // Check if the operands match one of the patterns handled by FastISel. std::string ManglingSuffix; raw_string_ostream SuffixOS(ManglingSuffix); Operands.PrintManglingSuffix(SuffixOS, ImmediatePredicates, true); SuffixOS.flush(); if (!StringSwitch<bool>(ManglingSuffix) .Cases("", "r", "rr", "ri", "i", "f", true) .Default(false)) continue; // Get the predicate that guards this pattern. std::string PredicateCheck = Pattern.getPredicateCheck(); // Ok, we found a pattern that we can handle. Remember it. InstructionMemo Memo = { Pattern.getDstPattern()->getOperator()->getName(), DstRC, SubRegNo, PhysRegInputs, PredicateCheck }; int complexity = Pattern.getPatternComplexity(CGP); if (SimplePatternsCheck[Operands][OpcodeName][VT] [RetVT].count(PredicateCheck)) { PrintFatalError(Pattern.getSrcRecord()->getLoc(), "Duplicate predicate in FastISel table!"); } SimplePatternsCheck[Operands][OpcodeName][VT][RetVT].insert( std::make_pair(PredicateCheck, true)); // Note: Instructions with the same complexity will appear in the order // that they are encountered. SimplePatterns[Operands][OpcodeName][VT][RetVT].insert( std::make_pair(complexity, Memo)); // If any of the operands were immediates with predicates on them, strip // them down to a signature that doesn't have predicates so that we can // associate them with the stripped predicate version. if (Operands.hasAnyImmediateCodes()) { SignaturesWithConstantForms[Operands.getWithoutImmCodes()] .push_back(Operands); } } }
void InstrSelectorEmitter::run(std::ostream &OS) { // Type-check all of the node types to ensure we "understand" them. ReadNodeTypes(); // Read in all of the nonterminals, instructions, and expanders... ReadNonterminals(); ReadInstructionPatterns(); ReadExpanderPatterns(); // Instantiate any unresolved nonterminals with information from the context // that they are used in. InstantiateNonterminals(); // Clear InstantiatedNTs, we don't need it anymore... InstantiatedNTs.clear(); DEBUG(std::cerr << "Patterns acquired:\n"); for (std::map<Record*, Pattern*>::iterator I = Patterns.begin(), E = Patterns.end(); I != E; ++I) if (I->second->isResolved()) DEBUG(std::cerr << " " << *I->second << "\n"); CalculateComputableValues(); OS << "#include \"llvm/CodeGen/MachineInstrBuilder.h\"\n"; EmitSourceFileHeader("Instruction Selector for the " + Target.getName() + " target", OS); // Output the slot number enums... OS << "\nenum { // Slot numbers...\n" << " LastBuiltinSlot = ISD::NumBuiltinSlots-1, // Start numbering here\n"; for (PatternOrganizer::iterator I = ComputableValues.begin(), E = ComputableValues.end(); I != E; ++I) OS << " " << I->first << "_Slot,\n"; OS << " NumSlots\n};\n\n// Reduction value typedefs...\n"; // Output the reduction value typedefs... for (PatternOrganizer::iterator I = ComputableValues.begin(), E = ComputableValues.end(); I != E; ++I) { OS << "typedef ReducedValue<unsigned, " << I->first << "_Slot> ReducedValue_" << I->first << ";\n"; } // Output the pattern enums... OS << "\n\n" << "enum { // Patterns...\n" << " NotComputed = 0,\n" << " NoMatchPattern, \n"; for (PatternOrganizer::iterator I = ComputableValues.begin(), E = ComputableValues.end(); I != E; ++I) { OS << " // " << I->first << " patterns...\n"; for (PatternOrganizer::NodesForSlot::iterator J = I->second.begin(), E = I->second.end(); J != E; ++J) for (unsigned i = 0, e = J->second.size(); i != e; ++i) OS << " " << J->second[i]->getRecord()->getName() << "_Pattern,\n"; } OS << "};\n\n"; //===--------------------------------------------------------------------===// // Emit the class definition... // OS << "namespace {\n" << " class " << Target.getName() << "ISel {\n" << " SelectionDAG &DAG;\n" << " public:\n" << " " << Target.getName () << "ISel(SelectionDAG &D) : DAG(D) {}\n" << " void generateCode();\n" << " private:\n" << " unsigned makeAnotherReg(const TargetRegisterClass *RC) {\n" << " return DAG.getMachineFunction().getSSARegMap()->createVirt" "ualRegister(RC);\n" << " }\n\n" << " // DAG matching methods for classes... all of these methods" " return the cost\n" << " // of producing a value of the specified class and type, which" " also gets\n" << " // added to the DAG node.\n"; // Output all of the matching prototypes for slots... for (PatternOrganizer::iterator I = ComputableValues.begin(), E = ComputableValues.end(); I != E; ++I) OS << " unsigned Match_" << I->first << "(SelectionDAGNode *N);\n"; OS << "\n // DAG matching methods for DAG nodes...\n"; // Output all of the matching prototypes for slot/node pairs for (PatternOrganizer::iterator I = ComputableValues.begin(), E = ComputableValues.end(); I != E; ++I) for (PatternOrganizer::NodesForSlot::iterator J = I->second.begin(), E = I->second.end(); J != E; ++J) OS << " unsigned Match_" << I->first << "_" << getNodeName(J->first) << "(SelectionDAGNode *N);\n"; // Output all of the dag reduction methods prototypes... OS << "\n // DAG reduction methods...\n"; for (PatternOrganizer::iterator I = ComputableValues.begin(), E = ComputableValues.end(); I != E; ++I) OS << " ReducedValue_" << I->first << " *Reduce_" << I->first << "(SelectionDAGNode *N,\n" << std::string(27+2*I->first.size(), ' ') << "MachineBasicBlock *MBB);\n"; OS << " };\n}\n\n"; // Emit the generateCode entry-point... OS << "void " << Target.getName () << "ISel::generateCode() {\n" << " SelectionDAGNode *Root = DAG.getRoot();\n" << " assert(Root->getValueType() == MVT::isVoid && " "\"Root of DAG produces value??\");\n\n" << " std::cerr << \"\\n\";\n" << " unsigned Cost = Match_Void_void(Root);\n" << " if (Cost >= ~0U >> 1) {\n" << " std::cerr << \"Match failed!\\n\";\n" << " Root->dump();\n" << " abort();\n" << " }\n\n" << " std::cerr << \"Total DAG Cost: \" << Cost << \"\\n\\n\";\n\n" << " Reduce_Void_void(Root, 0);\n" << "}\n\n" << "//===" << std::string(70, '-') << "===//\n" << "// Matching methods...\n" << "//\n\n"; //===--------------------------------------------------------------------===// // Emit all of the matcher methods... // for (PatternOrganizer::iterator I = ComputableValues.begin(), E = ComputableValues.end(); I != E; ++I) { const std::string &SlotName = I->first; OS << "unsigned " << Target.getName() << "ISel::Match_" << SlotName << "(SelectionDAGNode *N) {\n" << " assert(N->getValueType() == MVT::" << getEnumName((*I->second.begin()).second[0]->getTree()->getType()) << ");\n" << " // If we already have a cost available for " << SlotName << " use it!\n" << " if (N->getPatternFor(" << SlotName << "_Slot))\n" << " return N->getCostFor(" << SlotName << "_Slot);\n\n" << " unsigned Cost;\n" << " switch (N->getNodeType()) {\n" << " default: Cost = ~0U >> 1; // Match failed\n" << " N->setPatternCostFor(" << SlotName << "_Slot, NoMatchPattern, Cost, NumSlots);\n" << " break;\n"; for (PatternOrganizer::NodesForSlot::iterator J = I->second.begin(), E = I->second.end(); J != E; ++J) if (!J->first->isSubClassOf("Nonterminal")) OS << " case ISD::" << getNodeName(J->first) << ":\tCost = Match_" << SlotName << "_" << getNodeName(J->first) << "(N); break;\n"; OS << " }\n"; // End of the switch statement // Emit any patterns which have a nonterminal leaf as the RHS. These may // match multiple root nodes, so they cannot be handled with the switch... for (PatternOrganizer::NodesForSlot::iterator J = I->second.begin(), E = I->second.end(); J != E; ++J) if (J->first->isSubClassOf("Nonterminal")) { OS << " unsigned " << J->first->getName() << "_Cost = Match_" << getNodeName(J->first) << "(N);\n" << " if (" << getNodeName(J->first) << "_Cost < Cost) Cost = " << getNodeName(J->first) << "_Cost;\n"; } OS << " return Cost;\n}\n\n"; for (PatternOrganizer::NodesForSlot::iterator J = I->second.begin(), E = I->second.end(); J != E; ++J) { Record *Operator = J->first; bool isNonterm = Operator->isSubClassOf("Nonterminal"); if (!isNonterm) { OS << "unsigned " << Target.getName() << "ISel::Match_"; if (!isNonterm) OS << SlotName << "_"; OS << getNodeName(Operator) << "(SelectionDAGNode *N) {\n" << " unsigned Pattern = NoMatchPattern;\n" << " unsigned MinCost = ~0U >> 1;\n"; std::vector<std::pair<Pattern*, TreePatternNode*> > Patterns; for (unsigned i = 0, e = J->second.size(); i != e; ++i) Patterns.push_back(std::make_pair(J->second[i], J->second[i]->getTree())); EmitMatchCosters(OS, Patterns, "N", 2); OS << "\n N->setPatternCostFor(" << SlotName << "_Slot, Pattern, MinCost, NumSlots);\n" << " return MinCost;\n" << "}\n"; } } } //===--------------------------------------------------------------------===// // Emit all of the reducer methods... // OS << "\n\n//===" << std::string(70, '-') << "===//\n" << "// Reducer methods...\n" << "//\n"; for (PatternOrganizer::iterator I = ComputableValues.begin(), E = ComputableValues.end(); I != E; ++I) { const std::string &SlotName = I->first; OS << "ReducedValue_" << SlotName << " *" << Target.getName() << "ISel::Reduce_" << SlotName << "(SelectionDAGNode *N, MachineBasicBlock *MBB) {\n" << " ReducedValue_" << SlotName << " *Val = N->hasValue<ReducedValue_" << SlotName << ">(" << SlotName << "_Slot);\n" << " if (Val) return Val;\n" << " if (N->getBB()) MBB = N->getBB();\n\n" << " switch (N->getPatternFor(" << SlotName << "_Slot)) {\n"; // Loop over all of the patterns that can produce a value for this slot... PatternOrganizer::NodesForSlot &NodesForSlot = I->second; for (PatternOrganizer::NodesForSlot::iterator J = NodesForSlot.begin(), E = NodesForSlot.end(); J != E; ++J) for (unsigned i = 0, e = J->second.size(); i != e; ++i) { Pattern *P = J->second[i]; OS << " case " << P->getRecord()->getName() << "_Pattern: {\n" << " // " << *P << "\n"; // Loop over the operands, reducing them... std::vector<std::pair<TreePatternNode*, std::string> > Operands; ReduceAllOperands(P->getTree(), "N", Operands, OS); // Now that we have reduced all of our operands, and have the values // that reduction produces, perform the reduction action for this // pattern. std::string Result; // If the pattern produces a register result, generate a new register // now. if (Record *R = P->getResult()) { assert(R->isSubClassOf("RegisterClass") && "Only handle register class results so far!"); OS << " unsigned NewReg = makeAnotherReg(" << Target.getName() << "::" << R->getName() << "RegisterClass);\n"; Result = "NewReg"; DEBUG(OS << " std::cerr << \"%reg\" << NewReg << \" =\t\";\n"); } else { DEBUG(OS << " std::cerr << \"\t\t\";\n"); Result = "0"; } // Print out the pattern that matched... DEBUG(OS << " std::cerr << \" " << P->getRecord()->getName() <<'"'); DEBUG(for (unsigned i = 0, e = Operands.size(); i != e; ++i) if (Operands[i].first->isLeaf()) { Record *RV = Operands[i].first->getValueRecord(); assert(RV->isSubClassOf("RegisterClass") && "Only handles registers here so far!"); OS << " << \" %reg\" << " << Operands[i].second << "->Val"; } else { OS << " << ' ' << " << Operands[i].second << "->Val"; }); DEBUG(OS << " << \"\\n\";\n"); // Generate the reduction code appropriate to the particular type of // pattern that this is... switch (P->getPatternType()) { case Pattern::Instruction: // Instruction patterns just emit a single MachineInstr, using BuildMI OS << " BuildMI(MBB, " << Target.getName() << "::" << P->getRecord()->getName() << ", " << Operands.size(); if (P->getResult()) OS << ", NewReg"; OS << ")"; for (unsigned i = 0, e = Operands.size(); i != e; ++i) { TreePatternNode *Op = Operands[i].first; if (Op->isLeaf()) { Record *RV = Op->getValueRecord(); assert(RV->isSubClassOf("RegisterClass") && "Only handles registers here so far!"); OS << ".addReg(" << Operands[i].second << "->Val)"; } else if (Op->getOperator()->getName() == "imm") { OS << ".addZImm(" << Operands[i].second << "->Val)"; } else if (Op->getOperator()->getName() == "basicblock") { OS << ".addMBB(" << Operands[i].second << "->Val)"; } else { assert(0 && "Unknown value type!"); } } OS << ";\n"; break; case Pattern::Expander: { // Expander patterns emit one machine instr for each instruction in // the list of instructions expanded to. ListInit *Insts = P->getRecord()->getValueAsListInit("Result"); for (unsigned IN = 0, e = Insts->getSize(); IN != e; ++IN) { DagInit *DIInst = dynamic_cast<DagInit*>(Insts->getElement(IN)); if (!DIInst) P->error("Result list must contain instructions!"); Record *InstRec = DIInst->getNodeType(); Pattern *InstPat = getPattern(InstRec); if (!InstPat || InstPat->getPatternType() != Pattern::Instruction) P->error("Instruction list must contain Instruction patterns!"); bool hasResult = InstPat->getResult() != 0; if (InstPat->getNumArgs() != DIInst->getNumArgs()-hasResult) { P->error("Incorrect number of arguments specified for inst '" + InstPat->getRecord()->getName() + "' in result list!"); } // Start emission of the instruction... OS << " BuildMI(MBB, " << Target.getName() << "::" << InstRec->getName() << ", " << DIInst->getNumArgs()-hasResult; // Emit register result if necessary.. if (hasResult) { std::string ArgNameVal = getArgName(P, DIInst->getArgName(0), Operands); PrintExpanderOperand(DIInst->getArg(0), ArgNameVal, InstPat->getResultNode(), P, false, OS << ", "); } OS << ")"; for (unsigned i = hasResult, e = DIInst->getNumArgs(); i != e; ++i){ std::string ArgNameVal = getArgName(P, DIInst->getArgName(i), Operands); PrintExpanderOperand(DIInst->getArg(i), ArgNameVal, InstPat->getArg(i-hasResult), P, true, OS); } OS << ";\n"; } break; } default: assert(0 && "Reduction of this type of pattern not implemented!"); } OS << " Val = new ReducedValue_" << SlotName << "(" << Result<<");\n" << " break;\n" << " }\n"; } OS << " default: assert(0 && \"Unknown " << SlotName << " pattern!\");\n" << " }\n\n N->addValue(Val); // Do not ever recalculate this\n" << " return Val;\n}\n\n"; }
// EmitMatchCosters - Given a list of patterns, which all have the same root // pattern operator, emit an efficient decision tree to decide which one to // pick. This is structured this way to avoid reevaluations of non-obvious // subexpressions. void InstrSelectorEmitter::EmitMatchCosters(std::ostream &OS, const std::vector<std::pair<Pattern*, TreePatternNode*> > &Patterns, const std::string &VarPrefix, unsigned IndentAmt) { assert(!Patterns.empty() && "No patterns to emit matchers for!"); std::string Indent(IndentAmt, ' '); // Load all of the operands of the root node into scalars for fast access const NodeType &ONT = getNodeType(Patterns[0].second->getOperator()); for (unsigned i = 0, e = ONT.ArgTypes.size(); i != e; ++i) OS << Indent << "SelectionDAGNode *" << VarPrefix << "_Op" << i << " = N->getUse(" << i << ");\n"; // Compute the costs of computing the various nonterminals/registers, which // are directly used at this level. OS << "\n" << Indent << "// Operand matching costs...\n"; std::set<std::string> ComputedValues; // Avoid duplicate computations... for (unsigned i = 0, e = Patterns.size(); i != e; ++i) { TreePatternNode *NParent = Patterns[i].second; for (unsigned c = 0, e = NParent->getNumChildren(); c != e; ++c) { TreePatternNode *N = NParent->getChild(c); if (N->isLeaf()) { Record *VR = N->getValueRecord(); const std::string &LeafName = VR->getName(); std::string OpName = VarPrefix + "_Op" + utostr(c); std::string ValName = OpName + "_" + LeafName + "_Cost"; if (!ComputedValues.count(ValName)) { OS << Indent << "unsigned " << ValName << " = Match_" << Pattern::getSlotName(VR) << "(" << OpName << ");\n"; ComputedValues.insert(ValName); } } } } OS << "\n"; std::string LocCostName = VarPrefix + "_Cost"; OS << Indent << "unsigned " << LocCostName << "Min = ~0U >> 1;\n" << Indent << "unsigned " << VarPrefix << "_PatternMin = NoMatchPattern;\n"; #if 0 // Separate out all of the patterns into groups based on what their top-level // signature looks like... std::vector<std::pair<Pattern*, TreePatternNode*> > PatternsLeft(Patterns); while (!PatternsLeft.empty()) { // Process all of the patterns that have the same signature as the last // element... std::vector<std::pair<Pattern*, TreePatternNode*> > Group; MoveIdenticalPatterns(PatternsLeft.back().second, PatternsLeft, Group); assert(!Group.empty() && "Didn't at least pick the source pattern?"); #if 0 OS << "PROCESSING GROUP:\n"; for (unsigned i = 0, e = Group.size(); i != e; ++i) OS << " " << *Group[i].first << "\n"; OS << "\n\n"; #endif OS << Indent << "{ // "; if (Group.size() != 1) { OS << Group.size() << " size group...\n"; OS << Indent << " unsigned " << VarPrefix << "_Pattern = NoMatch;\n"; } else { OS << *Group[0].first << "\n"; OS << Indent << " unsigned " << VarPrefix << "_Pattern = " << Group[0].first->getRecord()->getName() << "_Pattern;\n"; } OS << Indent << " unsigned " << LocCostName << " = "; if (Group.size() == 1) OS << "1;\n"; // Add inst cost if at individual rec else OS << "0;\n"; // Loop over all of the operands, adding in their costs... TreePatternNode *N = Group[0].second; const std::vector<TreePatternNode*> &Children = N->getChildren(); // If necessary, emit conditionals to check for the appropriate tree // structure here... for (unsigned i = 0, e = Children.size(); i != e; ++i) { TreePatternNode *C = Children[i]; if (C->isLeaf()) { // We already calculated the cost for this leaf, add it in now... OS << Indent << " " << LocCostName << " += " << VarPrefix << "_Op" << utostr(i) << "_" << C->getValueRecord()->getName() << "_Cost;\n"; } else { // If it's not a leaf, we have to check to make sure that the current // node has the appropriate structure, then recurse into it... OS << Indent << " if (" << VarPrefix << "_Op" << i << "->getNodeType() == ISD::" << getNodeName(C->getOperator()) << ") {\n"; std::vector<std::pair<Pattern*, TreePatternNode*> > SubPatterns; for (unsigned n = 0, e = Group.size(); n != e; ++n) SubPatterns.push_back(std::make_pair(Group[n].first, Group[n].second->getChild(i))); EmitMatchCosters(OS, SubPatterns, VarPrefix+"_Op"+utostr(i), IndentAmt + 4); OS << Indent << " }\n"; } } // If the cost for this match is less than the minimum computed cost so far, // update the minimum cost and selected pattern. OS << Indent << " if (" << LocCostName << " < " << LocCostName << "Min) { " << LocCostName << "Min = " << LocCostName << "; " << VarPrefix << "_PatternMin = " << VarPrefix << "_Pattern; }\n"; OS << Indent << "}\n"; } #endif for (unsigned i = 0, e = Patterns.size(); i != e; ++i) { Pattern *P = Patterns[i].first; TreePatternNode *PTree = P->getTree(); unsigned PatternCost = 1; // Check to see if there are any non-leaf elements in the pattern. If so, // we need to emit a predicate for this match. bool AnyNonLeaf = false; for (unsigned c = 0, e = PTree->getNumChildren(); c != e; ++c) if (!PTree->getChild(c)->isLeaf()) { AnyNonLeaf = true; break; } if (!AnyNonLeaf) { // No predicate necessary, just output a scope... OS << " {// " << *P << "\n"; } else { // We need to emit a predicate to make sure the tree pattern matches, do // so now... OS << " if (1"; for (unsigned c = 0, e = PTree->getNumChildren(); c != e; ++c) if (!PTree->getChild(c)->isLeaf()) EmitPatternPredicates(PTree->getChild(c), VarPrefix + "_Op" + utostr(c), OS); OS << ") {\n // " << *P << "\n"; } OS << " unsigned PatCost = " << PatternCost; for (unsigned c = 0, e = PTree->getNumChildren(); c != e; ++c) if (PTree->getChild(c)->isLeaf()) { OS << " + " << VarPrefix << "_Op" << c << "_" << PTree->getChild(c)->getValueRecord()->getName() << "_Cost"; } else { EmitPatternCosts(PTree->getChild(c), VarPrefix + "_Op" + utostr(c), OS); } OS << ";\n"; OS << " if (PatCost < MinCost) { MinCost = PatCost; Pattern = " << P->getRecord()->getName() << "_Pattern; }\n" << " }\n"; } }
// MoveIdenticalPatterns - Given a tree pattern 'P', move all of the tree // patterns which have the same top-level structure as P from the 'From' list to // the 'To' list. static void MoveIdenticalPatterns(TreePatternNode *P, std::vector<std::pair<Pattern*, TreePatternNode*> > &From, std::vector<std::pair<Pattern*, TreePatternNode*> > &To) { assert(!P->isLeaf() && "All leaves are identical!"); const std::vector<TreePatternNode*> &PChildren = P->getChildren(); for (unsigned i = 0; i != From.size(); ++i) { TreePatternNode *N = From[i].second; assert(P->getOperator() == N->getOperator() &&"Differing operators?"); assert(PChildren.size() == N->getChildren().size() && "Nodes with different arity??"); bool isDifferent = false; for (unsigned c = 0, e = PChildren.size(); c != e; ++c) { TreePatternNode *PC = PChildren[c]; TreePatternNode *NC = N->getChild(c); if (PC->isLeaf() != NC->isLeaf()) { isDifferent = true; break; } if (!PC->isLeaf()) { if (PC->getOperator() != NC->getOperator()) { isDifferent = true; break; } } else { // It's a leaf! if (PC->getValueRecord() != NC->getValueRecord()) { isDifferent = true; break; } } } // If it's the same as the reference one, move it over now... if (!isDifferent) { To.push_back(std::make_pair(From[i].first, N)); From.erase(From.begin()+i); --i; // Don't skip an entry... } } }
// InferTypes - Perform type inference on the tree, returning true if there // are any remaining untyped nodes and setting MadeChange if any changes were // made. bool Pattern::InferTypes(TreePatternNode *N, bool &MadeChange) { if (N->isLeaf()) return N->getType() == MVT::Other; bool AnyUnset = false; Record *Operator = N->getOperator(); const NodeType &NT = ISE.getNodeType(Operator); // Check to see if we can infer anything about the argument types from the // return types... if (N->getNumChildren() != NT.ArgTypes.size()) error("Incorrect number of children for " + Operator->getName() + " node!"); for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) { TreePatternNode *Child = N->getChild(i); AnyUnset |= InferTypes(Child, MadeChange); switch (NT.ArgTypes[i]) { case NodeType::Any: break; case NodeType::I8: MadeChange |= Child->updateNodeType(MVT::i1, TheRecord->getName()); break; case NodeType::Arg0: MadeChange |= Child->updateNodeType(N->getChild(0)->getType(), TheRecord->getName()); break; case NodeType::Arg1: MadeChange |= Child->updateNodeType(N->getChild(1)->getType(), TheRecord->getName()); break; case NodeType::Val: if (Child->getType() == MVT::isVoid) error("Inferred a void node in an illegal place!"); break; case NodeType::Ptr: MadeChange |= Child->updateNodeType(ISE.getTarget().getPointerType(), TheRecord->getName()); break; case NodeType::Void: MadeChange |= Child->updateNodeType(MVT::isVoid, TheRecord->getName()); break; default: assert(0 && "Invalid argument ArgType!"); } } // See if we can infer anything about the return type now... switch (NT.ResultType) { case NodeType::Any: break; case NodeType::Void: MadeChange |= N->updateNodeType(MVT::isVoid, TheRecord->getName()); break; case NodeType::I8: MadeChange |= N->updateNodeType(MVT::i1, TheRecord->getName()); break; case NodeType::Arg0: MadeChange |= N->updateNodeType(N->getChild(0)->getType(), TheRecord->getName()); break; case NodeType::Arg1: MadeChange |= N->updateNodeType(N->getChild(1)->getType(), TheRecord->getName()); break; case NodeType::Ptr: MadeChange |= N->updateNodeType(ISE.getTarget().getPointerType(), TheRecord->getName()); break; case NodeType::Val: if (N->getType() == MVT::isVoid) error("Inferred a void node in an illegal place!"); break; default: assert(0 && "Unhandled type constraint!"); break; } return AnyUnset | N->getType() == MVT::Other; }