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"; } }