12661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick//===- CodeGenSchedule.cpp - Scheduling MachineModels ---------------------===// 22661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick// 32661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick// The LLVM Compiler Infrastructure 42661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick// 52661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick// This file is distributed under the University of Illinois Open Source 62661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick// License. See LICENSE.TXT for details. 72661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick// 82661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick//===----------------------------------------------------------------------===// 92661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick// 1036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines// This file defines structures to encapsulate the machine model as described in 112661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick// the target description. 122661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick// 132661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick//===----------------------------------------------------------------------===// 142661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick 152661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick#include "CodeGenSchedule.h" 162661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick#include "CodeGenTarget.h" 174ffd89fa4d2788611187d1a534d2ed46adf1702cChandler Carruth#include "llvm/ADT/STLExtras.h" 182661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick#include "llvm/Support/Debug.h" 1913745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick#include "llvm/Support/Regex.h" 204ffd89fa4d2788611187d1a534d2ed46adf1702cChandler Carruth#include "llvm/TableGen/Error.h" 212661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick 222661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trickusing namespace llvm; 232661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick 24dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines#define DEBUG_TYPE "subtarget-emitter" 25dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 2648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick#ifndef NDEBUG 27f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainarstatic void dumpIdxVec(ArrayRef<unsigned> V) { 28f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar for (unsigned Idx : V) 29f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar dbgs() << Idx << ", "; 305e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick} 3148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick#endif 3248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick 339d7c776d32c8a4d64b37a91c2d627629cf1498efBill Wendlingnamespace { 3413745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick// (instrs a, b, ...) Evaluate and union all arguments. Identical to AddOp. 3513745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trickstruct InstrsOp : public SetTheory::Operator { 3636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines void apply(SetTheory &ST, DagInit *Expr, SetTheory::RecSet &Elts, 3736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines ArrayRef<SMLoc> Loc) override { 389d7c776d32c8a4d64b37a91c2d627629cf1498efBill Wendling ST.evaluate(Expr->arg_begin(), Expr->arg_end(), Elts, Loc); 399d7c776d32c8a4d64b37a91c2d627629cf1498efBill Wendling } 409d7c776d32c8a4d64b37a91c2d627629cf1498efBill Wendling}; 41354362524a72b3fa43a6c09380b7ae3b2380cbbaJuergen Ributzka 4213745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick// (instregex "OpcPat",...) Find all instructions matching an opcode pattern. 4313745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick// 4413745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick// TODO: Since this is a prefix match, perform a binary search over the 4513745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick// instruction names using lower_bound. Note that the predefined instrs must be 4613745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick// scanned linearly first. However, this is only safe if the regex pattern has 4713745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick// no top-level bars. The DAG already has a list of patterns, so there's no 4813745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick// reason to use top-level bars, but we need a way to verify they don't exist 4913745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick// before implementing the optimization. 5013745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trickstruct InstRegexOp : public SetTheory::Operator { 5113745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick const CodeGenTarget &Target; 5213745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick InstRegexOp(const CodeGenTarget &t): Target(t) {} 5313745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick 549d7c776d32c8a4d64b37a91c2d627629cf1498efBill Wendling void apply(SetTheory &ST, DagInit *Expr, SetTheory::RecSet &Elts, 5536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines ArrayRef<SMLoc> Loc) override { 56dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines SmallVector<Regex, 4> RegexList; 579d7c776d32c8a4d64b37a91c2d627629cf1498efBill Wendling for (DagInit::const_arg_iterator 589d7c776d32c8a4d64b37a91c2d627629cf1498efBill Wendling AI = Expr->arg_begin(), AE = Expr->arg_end(); AI != AE; ++AI) { 599d7c776d32c8a4d64b37a91c2d627629cf1498efBill Wendling StringInit *SI = dyn_cast<StringInit>(*AI); 609d7c776d32c8a4d64b37a91c2d627629cf1498efBill Wendling if (!SI) 619d7c776d32c8a4d64b37a91c2d627629cf1498efBill Wendling PrintFatalError(Loc, "instregex requires pattern string: " 629d7c776d32c8a4d64b37a91c2d627629cf1498efBill Wendling + Expr->getAsString()); 639d7c776d32c8a4d64b37a91c2d627629cf1498efBill Wendling std::string pat = SI->getValue(); 649d7c776d32c8a4d64b37a91c2d627629cf1498efBill Wendling // Implement a python-style prefix match. 659d7c776d32c8a4d64b37a91c2d627629cf1498efBill Wendling if (pat[0] != '^') { 669d7c776d32c8a4d64b37a91c2d627629cf1498efBill Wendling pat.insert(0, "^("); 679d7c776d32c8a4d64b37a91c2d627629cf1498efBill Wendling pat.insert(pat.end(), ')'); 689d7c776d32c8a4d64b37a91c2d627629cf1498efBill Wendling } 69dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines RegexList.push_back(Regex(pat)); 7013745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick } 71de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar for (const CodeGenInstruction *Inst : Target.getInstructionsByEnumValue()) { 72dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines for (auto &R : RegexList) { 73ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (R.match(Inst->TheDef->getName())) 74ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Elts.insert(Inst->TheDef); 759d7c776d32c8a4d64b37a91c2d627629cf1498efBill Wendling } 7613745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick } 7713745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick } 789d7c776d32c8a4d64b37a91c2d627629cf1498efBill Wendling}; 799d7c776d32c8a4d64b37a91c2d627629cf1498efBill Wendling} // end anonymous namespace 8013745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick 8148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick/// CodeGenModels ctor interprets machine model records and populates maps. 822661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew TrickCodeGenSchedModels::CodeGenSchedModels(RecordKeeper &RK, 832661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick const CodeGenTarget &TGT): 841ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick Records(RK), Target(TGT) { 8548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick 8613745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick Sets.addFieldExpander("InstRW", "Instrs"); 8713745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick 8813745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick // Allow Set evaluation to recognize the dags used in InstRW records: 8913745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick // (instrs Op1, Op1...) 906948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar Sets.addOperator("instrs", llvm::make_unique<InstrsOp>()); 916948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar Sets.addOperator("instregex", llvm::make_unique<InstRegexOp>(Target)); 9213745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick 9348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // Instantiate a CodeGenProcModel for each SchedMachineModel with the values 9448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // that are explicitly referenced in tablegen records. Resources associated 9548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // with each processor will be derived later. Populate ProcModelMap with the 9648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // CodeGenProcModel instances. 9748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick collectProcModels(); 9848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick 9948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // Instantiate a CodeGenSchedRW for each SchedReadWrite record explicitly 10048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // defined, and populate SchedReads and SchedWrites vectors. Implicit 10148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // SchedReadWrites that represent sequences derived from expanded variant will 10248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // be inferred later. 10348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick collectSchedRW(); 10448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick 10548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // Instantiate a CodeGenSchedClass for each unique SchedRW signature directly 10648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // required by an instruction definition, and populate SchedClassIdxMap. Set 10748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // NumItineraryClasses to the number of explicit itinerary classes referenced 10848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // by instructions. Set NumInstrSchedClasses to the number of itinerary 10948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // classes plus any classes implied by instructions that derive from class 11048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // Sched and provide SchedRW list. This does not infer any new classes from 11148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // SchedVariant. 11248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick collectSchedClasses(); 11348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick 11448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // Find instruction itineraries for each processor. Sort and populate 11592649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick // CodeGenProcModel::ItinDefList. (Cycle-to-cycle itineraries). This requires 11648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // all itinerary classes to be discovered. 11748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick collectProcItins(); 11848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick 11948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // Find ItinRW records for each processor and itinerary class. 12048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // (For per-operand resources mapped to itinerary classes). 12148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick collectProcItinRW(); 1225e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 123de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // Find UnsupportedFeatures records for each processor. 124de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // (For per-operand resources mapped to itinerary classes). 125de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar collectProcUnsupportedFeatures(); 126de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 1275e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // Infer new SchedClasses from SchedVariant. 1285e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick inferSchedClasses(); 1295e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 1303cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick // Populate each CodeGenProcModel's WriteResDefs, ReadAdvanceDefs, and 1313cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick // ProcResourceDefs. 1323cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick collectProcResources(); 133de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 134de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar checkCompleteness(); 13548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick} 13648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick 13748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick/// Gather all processor models. 13848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trickvoid CodeGenSchedModels::collectProcModels() { 13948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick RecVec ProcRecords = Records.getAllDerivedDefinitions("Processor"); 14048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick std::sort(ProcRecords.begin(), ProcRecords.end(), LessRecordFieldName()); 14148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick 14248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // Reserve space because we can. Reallocation would be ok. 14348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick ProcModels.reserve(ProcRecords.size()+1); 14448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick 14548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // Use idx=0 for NoModel/NoItineraries. 14648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick Record *NoModelDef = Records.getDef("NoSchedModel"); 14748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick Record *NoItinsDef = Records.getDef("NoItineraries"); 1486948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar ProcModels.emplace_back(0, "NoSchedModel", NoModelDef, NoItinsDef); 14948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick ProcModelMap[NoModelDef] = 0; 15048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick 15148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // For each processor, find a unique machine model. 15248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick for (unsigned i = 0, N = ProcRecords.size(); i < N; ++i) 15348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick addProcModel(ProcRecords[i]); 15448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick} 15548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick 15648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick/// Get a unique processor model based on the defined MachineModel and 15748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick/// ProcessorItineraries. 15848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trickvoid CodeGenSchedModels::addProcModel(Record *ProcDef) { 15948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick Record *ModelKey = getModelOrItinDef(ProcDef); 16048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick if (!ProcModelMap.insert(std::make_pair(ModelKey, ProcModels.size())).second) 16148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick return; 16248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick 16348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick std::string Name = ModelKey->getName(); 16448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick if (ModelKey->isSubClassOf("SchedMachineModel")) { 16548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick Record *ItinsDef = ModelKey->getValueAsDef("Itineraries"); 1666948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar ProcModels.emplace_back(ProcModels.size(), Name, ModelKey, ItinsDef); 16748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 16848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick else { 16948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // An itinerary is defined without a machine model. Infer a new model. 17048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick if (!ModelKey->getValueAsListOfDefs("IID").empty()) 17148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick Name = Name + "Model"; 1726948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar ProcModels.emplace_back(ProcModels.size(), Name, 1736948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar ProcDef->getValueAsDef("SchedModel"), ModelKey); 17448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 17548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick DEBUG(ProcModels.back().dump()); 17648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick} 17748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick 17848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick// Recursively find all reachable SchedReadWrite records. 17948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trickstatic void scanSchedRW(Record *RWDef, RecVec &RWDefs, 18048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick SmallPtrSet<Record*, 16> &RWSet) { 18137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (!RWSet.insert(RWDef).second) 18248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick return; 18348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick RWDefs.push_back(RWDef); 18448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // Reads don't current have sequence records, but it can be added later. 18548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick if (RWDef->isSubClassOf("WriteSequence")) { 18648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick RecVec Seq = RWDef->getValueAsListOfDefs("Writes"); 18748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick for (RecIter I = Seq.begin(), E = Seq.end(); I != E; ++I) 18848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick scanSchedRW(*I, RWDefs, RWSet); 18948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 19048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick else if (RWDef->isSubClassOf("SchedVariant")) { 19148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // Visit each variant (guarded by a different predicate). 19248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick RecVec Vars = RWDef->getValueAsListOfDefs("Variants"); 19348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick for (RecIter VI = Vars.begin(), VE = Vars.end(); VI != VE; ++VI) { 19448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // Visit each RW in the sequence selected by the current variant. 19548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick RecVec Selected = (*VI)->getValueAsListOfDefs("Selected"); 19648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick for (RecIter I = Selected.begin(), E = Selected.end(); I != E; ++I) 19748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick scanSchedRW(*I, RWDefs, RWSet); 19848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 19948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 20048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick} 20148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick 20248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick// Collect and sort all SchedReadWrites reachable via tablegen records. 20348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick// More may be inferred later when inferring new SchedClasses from variants. 20448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trickvoid CodeGenSchedModels::collectSchedRW() { 20548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // Reserve idx=0 for invalid writes/reads. 20648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick SchedWrites.resize(1); 20748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick SchedReads.resize(1); 2082661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick 20948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick SmallPtrSet<Record*, 16> RWSet; 2102661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick 21148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // Find all SchedReadWrites referenced by instruction defs. 21248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick RecVec SWDefs, SRDefs; 213de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar for (const CodeGenInstruction *Inst : Target.getInstructionsByEnumValue()) { 214ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Record *SchedDef = Inst->TheDef; 21564110ffc9eecbe999c29ac9d9f6697447a110036Jakob Stoklund Olesen if (SchedDef->isValueUnset("SchedRW")) 21648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick continue; 21748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick RecVec RWs = SchedDef->getValueAsListOfDefs("SchedRW"); 21848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick for (RecIter RWI = RWs.begin(), RWE = RWs.end(); RWI != RWE; ++RWI) { 21948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick if ((*RWI)->isSubClassOf("SchedWrite")) 22048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick scanSchedRW(*RWI, SWDefs, RWSet); 22148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick else { 22248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick assert((*RWI)->isSubClassOf("SchedRead") && "Unknown SchedReadWrite"); 22348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick scanSchedRW(*RWI, SRDefs, RWSet); 22448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 22548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 22648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 22748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // Find all ReadWrites referenced by InstRW. 22848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick RecVec InstRWDefs = Records.getAllDerivedDefinitions("InstRW"); 22948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick for (RecIter OI = InstRWDefs.begin(), OE = InstRWDefs.end(); OI != OE; ++OI) { 23048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // For all OperandReadWrites. 23148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick RecVec RWDefs = (*OI)->getValueAsListOfDefs("OperandReadWrites"); 23248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick for (RecIter RWI = RWDefs.begin(), RWE = RWDefs.end(); 23348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick RWI != RWE; ++RWI) { 23448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick if ((*RWI)->isSubClassOf("SchedWrite")) 23548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick scanSchedRW(*RWI, SWDefs, RWSet); 23648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick else { 23748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick assert((*RWI)->isSubClassOf("SchedRead") && "Unknown SchedReadWrite"); 23848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick scanSchedRW(*RWI, SRDefs, RWSet); 23948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 24048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 24148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 24248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // Find all ReadWrites referenced by ItinRW. 24348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick RecVec ItinRWDefs = Records.getAllDerivedDefinitions("ItinRW"); 24448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick for (RecIter II = ItinRWDefs.begin(), IE = ItinRWDefs.end(); II != IE; ++II) { 24548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // For all OperandReadWrites. 24648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick RecVec RWDefs = (*II)->getValueAsListOfDefs("OperandReadWrites"); 24748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick for (RecIter RWI = RWDefs.begin(), RWE = RWDefs.end(); 24848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick RWI != RWE; ++RWI) { 24948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick if ((*RWI)->isSubClassOf("SchedWrite")) 25048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick scanSchedRW(*RWI, SWDefs, RWSet); 25148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick else { 25248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick assert((*RWI)->isSubClassOf("SchedRead") && "Unknown SchedReadWrite"); 25348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick scanSchedRW(*RWI, SRDefs, RWSet); 25448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 25548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 25648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 25792649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick // Find all ReadWrites referenced by SchedAlias. AliasDefs needs to be sorted 25892649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick // for the loop below that initializes Alias vectors. 25992649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick RecVec AliasDefs = Records.getAllDerivedDefinitions("SchedAlias"); 26092649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick std::sort(AliasDefs.begin(), AliasDefs.end(), LessRecord()); 26192649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick for (RecIter AI = AliasDefs.begin(), AE = AliasDefs.end(); AI != AE; ++AI) { 26292649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick Record *MatchDef = (*AI)->getValueAsDef("MatchRW"); 26392649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick Record *AliasDef = (*AI)->getValueAsDef("AliasRW"); 26492649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick if (MatchDef->isSubClassOf("SchedWrite")) { 26592649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick if (!AliasDef->isSubClassOf("SchedWrite")) 26661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError((*AI)->getLoc(), "SchedWrite Alias must be SchedWrite"); 26792649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick scanSchedRW(AliasDef, SWDefs, RWSet); 26892649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick } 26992649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick else { 27092649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick assert(MatchDef->isSubClassOf("SchedRead") && "Unknown SchedReadWrite"); 27192649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick if (!AliasDef->isSubClassOf("SchedRead")) 27261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError((*AI)->getLoc(), "SchedRead Alias must be SchedRead"); 27392649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick scanSchedRW(AliasDef, SRDefs, RWSet); 27492649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick } 27592649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick } 27648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // Sort and add the SchedReadWrites directly referenced by instructions or 27748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // itinerary resources. Index reads and writes in separate domains. 27848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick std::sort(SWDefs.begin(), SWDefs.end(), LessRecord()); 27948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick for (RecIter SWI = SWDefs.begin(), SWE = SWDefs.end(); SWI != SWE; ++SWI) { 28048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick assert(!getSchedRWIdx(*SWI, /*IsRead=*/false) && "duplicate SchedWrite"); 2816948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar SchedWrites.emplace_back(SchedWrites.size(), *SWI); 28248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 28348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick std::sort(SRDefs.begin(), SRDefs.end(), LessRecord()); 28448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick for (RecIter SRI = SRDefs.begin(), SRE = SRDefs.end(); SRI != SRE; ++SRI) { 28548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick assert(!getSchedRWIdx(*SRI, /*IsRead-*/true) && "duplicate SchedWrite"); 2866948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar SchedReads.emplace_back(SchedReads.size(), *SRI); 28748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 28848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // Initialize WriteSequence vectors. 28948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick for (std::vector<CodeGenSchedRW>::iterator WI = SchedWrites.begin(), 29048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick WE = SchedWrites.end(); WI != WE; ++WI) { 29148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick if (!WI->IsSequence) 29248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick continue; 29348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick findRWs(WI->TheDef->getValueAsListOfDefs("Writes"), WI->Sequence, 29448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick /*IsRead=*/false); 29548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 29692649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick // Initialize Aliases vectors. 29792649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick for (RecIter AI = AliasDefs.begin(), AE = AliasDefs.end(); AI != AE; ++AI) { 29892649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick Record *AliasDef = (*AI)->getValueAsDef("AliasRW"); 29992649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick getSchedRW(AliasDef).IsAlias = true; 30092649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick Record *MatchDef = (*AI)->getValueAsDef("MatchRW"); 30192649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick CodeGenSchedRW &RW = getSchedRW(MatchDef); 30292649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick if (RW.IsAlias) 30361131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError((*AI)->getLoc(), "Cannot Alias an Alias"); 30492649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick RW.Aliases.push_back(*AI); 30592649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick } 30648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick DEBUG( 30748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick for (unsigned WIdx = 0, WEnd = SchedWrites.size(); WIdx != WEnd; ++WIdx) { 30848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick dbgs() << WIdx << ": "; 30948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick SchedWrites[WIdx].dump(); 31048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick dbgs() << '\n'; 31148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 31248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick for (unsigned RIdx = 0, REnd = SchedReads.size(); RIdx != REnd; ++RIdx) { 31348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick dbgs() << RIdx << ": "; 31448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick SchedReads[RIdx].dump(); 31548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick dbgs() << '\n'; 31648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 31748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick RecVec RWDefs = Records.getAllDerivedDefinitions("SchedReadWrite"); 31848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick for (RecIter RI = RWDefs.begin(), RE = RWDefs.end(); 31948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick RI != RE; ++RI) { 32048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick if (!getSchedRWIdx(*RI, (*RI)->isSubClassOf("SchedRead"))) { 32148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick const std::string &Name = (*RI)->getName(); 32248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick if (Name != "NoWrite" && Name != "ReadDefault") 32348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick dbgs() << "Unused SchedReadWrite " << (*RI)->getName() << '\n'; 32448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 32548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick }); 32648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick} 32748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick 32848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick/// Compute a SchedWrite name from a sequence of writes. 329f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainarstd::string CodeGenSchedModels::genRWName(ArrayRef<unsigned> Seq, bool IsRead) { 33048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick std::string Name("("); 331f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar for (auto I = Seq.begin(), E = Seq.end(); I != E; ++I) { 33248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick if (I != Seq.begin()) 33348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick Name += '_'; 33448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick Name += getSchedRW(*I, IsRead).Name; 33548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 33648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick Name += ')'; 33748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick return Name; 33848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick} 33948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick 34048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trickunsigned CodeGenSchedModels::getSchedRWIdx(Record *Def, bool IsRead, 34148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick unsigned After) const { 34248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick const std::vector<CodeGenSchedRW> &RWVec = IsRead ? SchedReads : SchedWrites; 34348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick assert(After < RWVec.size() && "start position out of bounds"); 34448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick for (std::vector<CodeGenSchedRW>::const_iterator I = RWVec.begin() + After, 34548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick E = RWVec.end(); I != E; ++I) { 34648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick if (I->TheDef == Def) 34748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick return I - RWVec.begin(); 34848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 34948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick return 0; 35048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick} 35148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick 3523b8fb648c6e1c519b7e0f487f4fb511744869d35Andrew Trickbool CodeGenSchedModels::hasReadOfWrite(Record *WriteDef) const { 3533b8fb648c6e1c519b7e0f487f4fb511744869d35Andrew Trick for (unsigned i = 0, e = SchedReads.size(); i < e; ++i) { 3543b8fb648c6e1c519b7e0f487f4fb511744869d35Andrew Trick Record *ReadDef = SchedReads[i].TheDef; 3553b8fb648c6e1c519b7e0f487f4fb511744869d35Andrew Trick if (!ReadDef || !ReadDef->isSubClassOf("ProcReadAdvance")) 3563b8fb648c6e1c519b7e0f487f4fb511744869d35Andrew Trick continue; 3573b8fb648c6e1c519b7e0f487f4fb511744869d35Andrew Trick 3583b8fb648c6e1c519b7e0f487f4fb511744869d35Andrew Trick RecVec ValidWrites = ReadDef->getValueAsListOfDefs("ValidWrites"); 3593b8fb648c6e1c519b7e0f487f4fb511744869d35Andrew Trick if (std::find(ValidWrites.begin(), ValidWrites.end(), WriteDef) 3603b8fb648c6e1c519b7e0f487f4fb511744869d35Andrew Trick != ValidWrites.end()) { 3613b8fb648c6e1c519b7e0f487f4fb511744869d35Andrew Trick return true; 3623b8fb648c6e1c519b7e0f487f4fb511744869d35Andrew Trick } 3633b8fb648c6e1c519b7e0f487f4fb511744869d35Andrew Trick } 3643b8fb648c6e1c519b7e0f487f4fb511744869d35Andrew Trick return false; 3653b8fb648c6e1c519b7e0f487f4fb511744869d35Andrew Trick} 3663b8fb648c6e1c519b7e0f487f4fb511744869d35Andrew Trick 36748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Tricknamespace llvm { 36848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trickvoid splitSchedReadWrites(const RecVec &RWDefs, 36948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick RecVec &WriteDefs, RecVec &ReadDefs) { 37048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick for (RecIter RWI = RWDefs.begin(), RWE = RWDefs.end(); RWI != RWE; ++RWI) { 37148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick if ((*RWI)->isSubClassOf("SchedWrite")) 37248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick WriteDefs.push_back(*RWI); 37348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick else { 37448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick assert((*RWI)->isSubClassOf("SchedRead") && "unknown SchedReadWrite"); 37548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick ReadDefs.push_back(*RWI); 37648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 37748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 37848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick} 37948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick} // namespace llvm 38048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick 38148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick// Split the SchedReadWrites defs and call findRWs for each list. 38248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trickvoid CodeGenSchedModels::findRWs(const RecVec &RWDefs, 38348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick IdxVec &Writes, IdxVec &Reads) const { 38448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick RecVec WriteDefs; 38548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick RecVec ReadDefs; 38648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick splitSchedReadWrites(RWDefs, WriteDefs, ReadDefs); 38748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick findRWs(WriteDefs, Writes, false); 38848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick findRWs(ReadDefs, Reads, true); 38948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick} 39048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick 39148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick// Call getSchedRWIdx for all elements in a sequence of SchedRW defs. 39248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trickvoid CodeGenSchedModels::findRWs(const RecVec &RWDefs, IdxVec &RWs, 39348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick bool IsRead) const { 39448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick for (RecIter RI = RWDefs.begin(), RE = RWDefs.end(); RI != RE; ++RI) { 39548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick unsigned Idx = getSchedRWIdx(*RI, IsRead); 39648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick assert(Idx && "failed to collect SchedReadWrite"); 39748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick RWs.push_back(Idx); 39848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 3992661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick} 4002661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick 4015e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trickvoid CodeGenSchedModels::expandRWSequence(unsigned RWIdx, IdxVec &RWSeq, 4025e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick bool IsRead) const { 4035e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick const CodeGenSchedRW &SchedRW = getSchedRW(RWIdx, IsRead); 4045e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick if (!SchedRW.IsSequence) { 4055e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick RWSeq.push_back(RWIdx); 4065e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick return; 4075e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 4085e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick int Repeat = 4095e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick SchedRW.TheDef ? SchedRW.TheDef->getValueAsInt("Repeat") : 1; 4105e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick for (int i = 0; i < Repeat; ++i) { 4115e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick for (IdxIter I = SchedRW.Sequence.begin(), E = SchedRW.Sequence.end(); 4125e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick I != E; ++I) { 4135e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick expandRWSequence(*I, RWSeq, IsRead); 4145e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 4155e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 4165e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick} 4175e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 4182062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick// Expand a SchedWrite as a sequence following any aliases that coincide with 4192062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick// the given processor model. 4202062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trickvoid CodeGenSchedModels::expandRWSeqForProc( 4212062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick unsigned RWIdx, IdxVec &RWSeq, bool IsRead, 4222062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick const CodeGenProcModel &ProcModel) const { 4232062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick 4242062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick const CodeGenSchedRW &SchedWrite = getSchedRW(RWIdx, IsRead); 425dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Record *AliasDef = nullptr; 4262062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick for (RecIter AI = SchedWrite.Aliases.begin(), AE = SchedWrite.Aliases.end(); 4272062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick AI != AE; ++AI) { 4282062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick const CodeGenSchedRW &AliasRW = getSchedRW((*AI)->getValueAsDef("AliasRW")); 4292062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick if ((*AI)->getValueInit("SchedModel")->isComplete()) { 4302062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick Record *ModelDef = (*AI)->getValueAsDef("SchedModel"); 4312062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick if (&getProcModel(ModelDef) != &ProcModel) 4322062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick continue; 4332062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick } 4342062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick if (AliasDef) 43561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(AliasRW.TheDef->getLoc(), "Multiple aliases " 43661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "defined for processor " + ProcModel.ModelName + 43761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger " Ensure only one SchedAlias exists per RW."); 4382062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick AliasDef = AliasRW.TheDef; 4392062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick } 4402062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick if (AliasDef) { 4412062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick expandRWSeqForProc(getSchedRWIdx(AliasDef, IsRead), 4422062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick RWSeq, IsRead,ProcModel); 4432062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick return; 4442062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick } 4452062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick if (!SchedWrite.IsSequence) { 4462062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick RWSeq.push_back(RWIdx); 4472062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick return; 4482062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick } 4492062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick int Repeat = 4502062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick SchedWrite.TheDef ? SchedWrite.TheDef->getValueAsInt("Repeat") : 1; 4512062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick for (int i = 0; i < Repeat; ++i) { 4522062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick for (IdxIter I = SchedWrite.Sequence.begin(), E = SchedWrite.Sequence.end(); 4532062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick I != E; ++I) { 4542062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick expandRWSeqForProc(*I, RWSeq, IsRead, ProcModel); 4552062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick } 4562062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick } 4572062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick} 4582062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick 4595e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick// Find the existing SchedWrite that models this sequence of writes. 460f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainarunsigned CodeGenSchedModels::findRWForSequence(ArrayRef<unsigned> Seq, 4615e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick bool IsRead) { 4625e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick std::vector<CodeGenSchedRW> &RWVec = IsRead ? SchedReads : SchedWrites; 4635e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 4645e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick for (std::vector<CodeGenSchedRW>::iterator I = RWVec.begin(), E = RWVec.end(); 4655e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick I != E; ++I) { 466f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (makeArrayRef(I->Sequence) == Seq) 4675e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick return I - RWVec.begin(); 4685e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 4695e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // Index zero reserved for invalid RW. 4705e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick return 0; 4715e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick} 4725e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 4735e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick/// Add this ReadWrite if it doesn't already exist. 4745e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trickunsigned CodeGenSchedModels::findOrInsertRW(ArrayRef<unsigned> Seq, 4755e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick bool IsRead) { 4765e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick assert(!Seq.empty() && "cannot insert empty sequence"); 4775e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick if (Seq.size() == 1) 4785e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick return Seq.back(); 4795e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 4805e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick unsigned Idx = findRWForSequence(Seq, IsRead); 4815e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick if (Idx) 4825e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick return Idx; 4835e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 4842062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick unsigned RWIdx = IsRead ? SchedReads.size() : SchedWrites.size(); 4852062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick CodeGenSchedRW SchedRW(RWIdx, IsRead, Seq, genRWName(Seq, IsRead)); 4862062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick if (IsRead) 4875e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick SchedReads.push_back(SchedRW); 4882062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick else 4892062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick SchedWrites.push_back(SchedRW); 4902062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick return RWIdx; 4915e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick} 4925e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 49348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick/// Visit all the instruction definitions for this target to gather and 49448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick/// enumerate the itinerary classes. These are the explicitly specified 49548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick/// SchedClasses. More SchedClasses may be inferred. 49648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trickvoid CodeGenSchedModels::collectSchedClasses() { 4972661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick 49848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // NoItinerary is always the first class at Idx=0 4992661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick SchedClasses.resize(1); 5001ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick SchedClasses.back().Index = 0; 5011ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick SchedClasses.back().Name = "NoInstrModel"; 5021ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick SchedClasses.back().ItinClassDef = Records.getDef("NoItinerary"); 50348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick SchedClasses.back().ProcIndices.push_back(0); 5042661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick 5051ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick // Create a SchedClass for each unique combination of itinerary class and 5061ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick // SchedRW list. 507de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar for (const CodeGenInstruction *Inst : Target.getInstructionsByEnumValue()) { 508ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Record *ItinDef = Inst->TheDef->getValueAsDef("Itinerary"); 50948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick IdxVec Writes, Reads; 510ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (!Inst->TheDef->isValueUnset("SchedRW")) 511ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines findRWs(Inst->TheDef->getValueAsListOfDefs("SchedRW"), Writes, Reads); 5121ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick 51348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // ProcIdx == 0 indicates the class applies to all processors. 51448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick IdxVec ProcIndices(1, 0); 5151ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick 5161ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick unsigned SCIdx = addSchedClass(ItinDef, Writes, Reads, ProcIndices); 517ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines InstrClassMap[Inst->TheDef] = SCIdx; 51848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 51992649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick // Create classes for InstRW defs. 52048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick RecVec InstRWDefs = Records.getAllDerivedDefinitions("InstRW"); 52148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick std::sort(InstRWDefs.begin(), InstRWDefs.end(), LessRecord()); 52248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick for (RecIter OI = InstRWDefs.begin(), OE = InstRWDefs.end(); OI != OE; ++OI) 52348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick createInstRWClass(*OI); 5242661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick 52548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick NumInstrSchedClasses = SchedClasses.size(); 52648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick 52748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick bool EnableDump = false; 52848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick DEBUG(EnableDump = true); 52948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick if (!EnableDump) 53048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick return; 5311ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick 532de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar for (const CodeGenInstruction *Inst : Target.getInstructionsByEnumValue()) { 533ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines std::string InstName = Inst->TheDef->getName(); 534ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines unsigned SCIdx = InstrClassMap.lookup(Inst->TheDef); 5351ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick if (!SCIdx) { 536de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (!Inst->hasNoSchedulingInfo) 537de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar dbgs() << "No machine model for " << Inst->TheDef->getName() << '\n'; 5381ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick continue; 5391ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick } 5401ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick CodeGenSchedClass &SC = getSchedClass(SCIdx); 5411ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick if (SC.ProcIndices[0] != 0) 542ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines PrintFatalError(Inst->TheDef->getLoc(), "Instruction's sched class " 5431ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick "must not be subtarget specific."); 5441ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick 5451ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick IdxVec ProcIndices; 5461ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick if (SC.ItinClassDef->getName() != "NoItinerary") { 5471ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick ProcIndices.push_back(0); 5481ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick dbgs() << "Itinerary for " << InstName << ": " 5491ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick << SC.ItinClassDef->getName() << '\n'; 5501ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick } 5511ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick if (!SC.Writes.empty()) { 5521ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick ProcIndices.push_back(0); 5531ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick dbgs() << "SchedRW machine model for " << InstName; 5541ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick for (IdxIter WI = SC.Writes.begin(), WE = SC.Writes.end(); WI != WE; ++WI) 5551ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick dbgs() << " " << SchedWrites[*WI].Name; 5561ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick for (IdxIter RI = SC.Reads.begin(), RE = SC.Reads.end(); RI != RE; ++RI) 5571ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick dbgs() << " " << SchedReads[*RI].Name; 5581ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick dbgs() << '\n'; 5591ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick } 5601ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick const RecVec &RWDefs = SchedClasses[SCIdx].InstRWs; 5611ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick for (RecIter RWI = RWDefs.begin(), RWE = RWDefs.end(); 5621ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick RWI != RWE; ++RWI) { 5631ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick const CodeGenProcModel &ProcModel = 5641ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick getProcModel((*RWI)->getValueAsDef("SchedModel")); 5651ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick ProcIndices.push_back(ProcModel.Index); 5661ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick dbgs() << "InstRW on " << ProcModel.ModelName << " for " << InstName; 56748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick IdxVec Writes; 56848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick IdxVec Reads; 5691ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick findRWs((*RWI)->getValueAsListOfDefs("OperandReadWrites"), 5701ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick Writes, Reads); 57148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick for (IdxIter WI = Writes.begin(), WE = Writes.end(); WI != WE; ++WI) 57248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick dbgs() << " " << SchedWrites[*WI].Name; 57348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick for (IdxIter RI = Reads.begin(), RE = Reads.end(); RI != RE; ++RI) 57448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick dbgs() << " " << SchedReads[*RI].Name; 57548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick dbgs() << '\n'; 57648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 5771ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick for (std::vector<CodeGenProcModel>::iterator PI = ProcModels.begin(), 5781ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick PE = ProcModels.end(); PI != PE; ++PI) { 5791ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick if (!std::count(ProcIndices.begin(), ProcIndices.end(), PI->Index)) 580ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines dbgs() << "No machine model for " << Inst->TheDef->getName() 5811ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick << " on processor " << PI->ModelName << '\n'; 58248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 58348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 5842661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick} 5852661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick 58648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick/// Find an SchedClass that has been inferred from a per-operand list of 58748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick/// SchedWrites and SchedReads. 5881ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trickunsigned CodeGenSchedModels::findSchedClassIdx(Record *ItinClassDef, 589f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar ArrayRef<unsigned> Writes, 590f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar ArrayRef<unsigned> Reads) const { 59148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick for (SchedClassIter I = schedClassBegin(), E = schedClassEnd(); I != E; ++I) { 592f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (I->ItinClassDef == ItinClassDef && makeArrayRef(I->Writes) == Writes && 593f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar makeArrayRef(I->Reads) == Reads) { 59448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick return I - schedClassBegin(); 59548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 59648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 59748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick return 0; 5982661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick} 5992661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick 60048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick// Get the SchedClass index for an instruction. 60148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trickunsigned CodeGenSchedModels::getSchedClassIdx( 60248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick const CodeGenInstruction &Inst) const { 6032661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick 6041ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick return InstrClassMap.lookup(Inst.TheDef); 60548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick} 6062661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick 607f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainarstd::string 608f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga NainarCodeGenSchedModels::createSchedClassName(Record *ItinClassDef, 609f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar ArrayRef<unsigned> OperWrites, 610f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar ArrayRef<unsigned> OperReads) { 61148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick 61248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick std::string Name; 6131ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick if (ItinClassDef && ItinClassDef->getName() != "NoItinerary") 6141ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick Name = ItinClassDef->getName(); 615f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar for (unsigned Idx : OperWrites) { 6161ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick if (!Name.empty()) 61748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick Name += '_'; 618f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar Name += SchedWrites[Idx].Name; 6192661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick } 620f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar for (unsigned Idx : OperReads) { 62148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick Name += '_'; 622f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar Name += SchedReads[Idx].Name; 6232661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick } 62448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick return Name; 62548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick} 6262661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick 62748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trickstd::string CodeGenSchedModels::createSchedClassName(const RecVec &InstDefs) { 6282661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick 62948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick std::string Name; 63048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick for (RecIter I = InstDefs.begin(), E = InstDefs.end(); I != E; ++I) { 63148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick if (I != InstDefs.begin()) 63248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick Name += '_'; 63348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick Name += (*I)->getName(); 63448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 63548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick return Name; 63648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick} 63748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick 6381ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick/// Add an inferred sched class from an itinerary class and per-operand list of 6391ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick/// SchedWrites and SchedReads. ProcIndices contains the set of IDs of 6401ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick/// processors that may utilize this class. 6411ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trickunsigned CodeGenSchedModels::addSchedClass(Record *ItinClassDef, 642f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar ArrayRef<unsigned> OperWrites, 643f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar ArrayRef<unsigned> OperReads, 644f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar ArrayRef<unsigned> ProcIndices) { 64548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick assert(!ProcIndices.empty() && "expect at least one ProcIdx"); 64648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick 6471ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick unsigned Idx = findSchedClassIdx(ItinClassDef, OperWrites, OperReads); 6481ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick if (Idx || SchedClasses[0].isKeyEqual(ItinClassDef, OperWrites, OperReads)) { 64948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick IdxVec PI; 65048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick std::set_union(SchedClasses[Idx].ProcIndices.begin(), 65148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick SchedClasses[Idx].ProcIndices.end(), 65248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick ProcIndices.begin(), ProcIndices.end(), 65348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick std::back_inserter(PI)); 65448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick SchedClasses[Idx].ProcIndices.swap(PI); 65548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick return Idx; 65648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 65748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick Idx = SchedClasses.size(); 65848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick SchedClasses.resize(Idx+1); 65948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick CodeGenSchedClass &SC = SchedClasses.back(); 6601ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick SC.Index = Idx; 6611ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick SC.Name = createSchedClassName(ItinClassDef, OperWrites, OperReads); 6621ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick SC.ItinClassDef = ItinClassDef; 66348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick SC.Writes = OperWrites; 66448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick SC.Reads = OperReads; 66548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick SC.ProcIndices = ProcIndices; 6662661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick 66748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick return Idx; 66848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick} 66948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick 67048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick// Create classes for each set of opcodes that are in the same InstReadWrite 67148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick// definition across all processors. 67248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trickvoid CodeGenSchedModels::createInstRWClass(Record *InstRWDef) { 67348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // ClassInstrs will hold an entry for each subset of Instrs in InstRWDef that 67448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // intersects with an existing class via a previous InstRWDef. Instrs that do 67548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // not intersect with an existing class refer back to their former class as 67648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // determined from ItinDef or SchedRW. 67748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick SmallVector<std::pair<unsigned, SmallVector<Record *, 8> >, 4> ClassInstrs; 67848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // Sort Instrs into sets. 67913745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick const RecVec *InstDefs = Sets.expand(InstRWDef); 68013745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick if (InstDefs->empty()) 68161131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(InstRWDef->getLoc(), "No matching instruction opcodes"); 68213745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick 68313745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick for (RecIter I = InstDefs->begin(), E = InstDefs->end(); I != E; ++I) { 68448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick InstClassMapTy::const_iterator Pos = InstrClassMap.find(*I); 6851ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick if (Pos == InstrClassMap.end()) 6861ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick PrintFatalError((*I)->getLoc(), "No sched class for instruction."); 6871ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick unsigned SCIdx = Pos->second; 68848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick unsigned CIdx = 0, CEnd = ClassInstrs.size(); 68948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick for (; CIdx != CEnd; ++CIdx) { 69048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick if (ClassInstrs[CIdx].first == SCIdx) 69148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick break; 69248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 69348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick if (CIdx == CEnd) { 69448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick ClassInstrs.resize(CEnd + 1); 69548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick ClassInstrs[CIdx].first = SCIdx; 69648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 69748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick ClassInstrs[CIdx].second.push_back(*I); 69848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 69948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // For each set of Instrs, create a new class if necessary, and map or remap 70048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // the Instrs to it. 70148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick unsigned CIdx = 0, CEnd = ClassInstrs.size(); 70248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick for (; CIdx != CEnd; ++CIdx) { 70348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick unsigned OldSCIdx = ClassInstrs[CIdx].first; 70448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick ArrayRef<Record*> InstDefs = ClassInstrs[CIdx].second; 70548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // If the all instrs in the current class are accounted for, then leave 70648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // them mapped to their old class. 707d7aad34bcbf90aa389f1cb73ade5a21897a73869Andrew Trick if (OldSCIdx) { 708d7aad34bcbf90aa389f1cb73ade5a21897a73869Andrew Trick const RecVec &RWDefs = SchedClasses[OldSCIdx].InstRWs; 709d7aad34bcbf90aa389f1cb73ade5a21897a73869Andrew Trick if (!RWDefs.empty()) { 710d7aad34bcbf90aa389f1cb73ade5a21897a73869Andrew Trick const RecVec *OrigInstDefs = Sets.expand(RWDefs[0]); 711d7aad34bcbf90aa389f1cb73ade5a21897a73869Andrew Trick unsigned OrigNumInstrs = 0; 712d7aad34bcbf90aa389f1cb73ade5a21897a73869Andrew Trick for (RecIter I = OrigInstDefs->begin(), E = OrigInstDefs->end(); 713d7aad34bcbf90aa389f1cb73ade5a21897a73869Andrew Trick I != E; ++I) { 714d7aad34bcbf90aa389f1cb73ade5a21897a73869Andrew Trick if (InstrClassMap[*I] == OldSCIdx) 715d7aad34bcbf90aa389f1cb73ade5a21897a73869Andrew Trick ++OrigNumInstrs; 716d7aad34bcbf90aa389f1cb73ade5a21897a73869Andrew Trick } 717d7aad34bcbf90aa389f1cb73ade5a21897a73869Andrew Trick if (OrigNumInstrs == InstDefs.size()) { 718d7aad34bcbf90aa389f1cb73ade5a21897a73869Andrew Trick assert(SchedClasses[OldSCIdx].ProcIndices[0] == 0 && 719d7aad34bcbf90aa389f1cb73ade5a21897a73869Andrew Trick "expected a generic SchedClass"); 720d7aad34bcbf90aa389f1cb73ade5a21897a73869Andrew Trick DEBUG(dbgs() << "InstRW: Reuse SC " << OldSCIdx << ":" 721d7aad34bcbf90aa389f1cb73ade5a21897a73869Andrew Trick << SchedClasses[OldSCIdx].Name << " on " 722d7aad34bcbf90aa389f1cb73ade5a21897a73869Andrew Trick << InstRWDef->getValueAsDef("SchedModel")->getName() << "\n"); 723d7aad34bcbf90aa389f1cb73ade5a21897a73869Andrew Trick SchedClasses[OldSCIdx].InstRWs.push_back(InstRWDef); 724d7aad34bcbf90aa389f1cb73ade5a21897a73869Andrew Trick continue; 725d7aad34bcbf90aa389f1cb73ade5a21897a73869Andrew Trick } 726d7aad34bcbf90aa389f1cb73ade5a21897a73869Andrew Trick } 72748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 72848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick unsigned SCIdx = SchedClasses.size(); 72948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick SchedClasses.resize(SCIdx+1); 73048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick CodeGenSchedClass &SC = SchedClasses.back(); 7311ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick SC.Index = SCIdx; 73248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick SC.Name = createSchedClassName(InstDefs); 733d7aad34bcbf90aa389f1cb73ade5a21897a73869Andrew Trick DEBUG(dbgs() << "InstRW: New SC " << SCIdx << ":" << SC.Name << " on " 734d7aad34bcbf90aa389f1cb73ade5a21897a73869Andrew Trick << InstRWDef->getValueAsDef("SchedModel")->getName() << "\n"); 735d7aad34bcbf90aa389f1cb73ade5a21897a73869Andrew Trick 73648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // Preserve ItinDef and Writes/Reads for processors without an InstRW entry. 73748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick SC.ItinClassDef = SchedClasses[OldSCIdx].ItinClassDef; 73848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick SC.Writes = SchedClasses[OldSCIdx].Writes; 73948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick SC.Reads = SchedClasses[OldSCIdx].Reads; 74048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick SC.ProcIndices.push_back(0); 74148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // Map each Instr to this new class. 74248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // Note that InstDefs may be a smaller list than InstRWDef's "Instrs". 74313745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick Record *RWModelDef = InstRWDef->getValueAsDef("SchedModel"); 74413745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick SmallSet<unsigned, 4> RemappedClassIDs; 74548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick for (ArrayRef<Record*>::const_iterator 74648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick II = InstDefs.begin(), IE = InstDefs.end(); II != IE; ++II) { 74748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick unsigned OldSCIdx = InstrClassMap[*II]; 74837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (OldSCIdx && RemappedClassIDs.insert(OldSCIdx).second) { 74913745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick for (RecIter RI = SchedClasses[OldSCIdx].InstRWs.begin(), 75013745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick RE = SchedClasses[OldSCIdx].InstRWs.end(); RI != RE; ++RI) { 75113745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick if ((*RI)->getValueAsDef("SchedModel") == RWModelDef) { 75261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(InstRWDef->getLoc(), "Overlapping InstRW def " + 75313745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick (*II)->getName() + " also matches " + 75413745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick (*RI)->getValue("Instrs")->getValue()->getAsString()); 75513745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick } 75613745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick assert(*RI != InstRWDef && "SchedClass has duplicate InstRW def"); 75713745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick SC.InstRWs.push_back(*RI); 75813745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick } 75948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 76048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick InstrClassMap[*II] = SCIdx; 76148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 76248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick SC.InstRWs.push_back(InstRWDef); 76348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 7642661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick} 7652661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick 7661ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick// True if collectProcItins found anything. 7671ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trickbool CodeGenSchedModels::hasItineraries() const { 7681ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick for (CodeGenSchedModels::ProcIter PI = procModelBegin(), PE = procModelEnd(); 7691ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick PI != PE; ++PI) { 7701ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick if (PI->hasItineraries()) 7711ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick return true; 7721ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick } 7731ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick return false; 7741ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick} 7751ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick 7762661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick// Gather the processor itineraries. 77748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trickvoid CodeGenSchedModels::collectProcItins() { 778ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines for (CodeGenProcModel &ProcModel : ProcModels) { 7791ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick if (!ProcModel.hasItineraries()) 78048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick continue; 7812661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick 7821ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick RecVec ItinRecords = ProcModel.ItinsDef->getValueAsListOfDefs("IID"); 7831ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick assert(!ItinRecords.empty() && "ProcModel.hasItineraries is incorrect"); 7841ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick 7851ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick // Populate ItinDefList with Itinerary records. 7861ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick ProcModel.ItinDefList.resize(NumInstrSchedClasses); 7872661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick 78848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // Insert each itinerary data record in the correct position within 78948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // the processor model's ItinDefList. 79048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick for (unsigned i = 0, N = ItinRecords.size(); i < N; i++) { 79148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick Record *ItinData = ItinRecords[i]; 79248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick Record *ItinDef = ItinData->getValueAsDef("TheClass"); 79302fec34de127d23987352b90bf095ad3fac75fb9Andrew Trick bool FoundClass = false; 79402fec34de127d23987352b90bf095ad3fac75fb9Andrew Trick for (SchedClassIter SCI = schedClassBegin(), SCE = schedClassEnd(); 79502fec34de127d23987352b90bf095ad3fac75fb9Andrew Trick SCI != SCE; ++SCI) { 79602fec34de127d23987352b90bf095ad3fac75fb9Andrew Trick // Multiple SchedClasses may share an itinerary. Update all of them. 7971ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick if (SCI->ItinClassDef == ItinDef) { 7981ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick ProcModel.ItinDefList[SCI->Index] = ItinData; 79902fec34de127d23987352b90bf095ad3fac75fb9Andrew Trick FoundClass = true; 8001ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick } 8011ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick } 80202fec34de127d23987352b90bf095ad3fac75fb9Andrew Trick if (!FoundClass) { 80348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick DEBUG(dbgs() << ProcModel.ItinsDef->getName() 8041ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick << " missing class for itinerary " << ItinDef->getName() << '\n'); 80548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 80648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 80748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick // Check for missing itinerary entries. 80848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick assert(!ProcModel.ItinDefList[0] && "NoItinerary class can't have rec"); 80948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick DEBUG( 81048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick for (unsigned i = 1, N = ProcModel.ItinDefList.size(); i < N; ++i) { 81148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick if (!ProcModel.ItinDefList[i]) 81248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick dbgs() << ProcModel.ItinsDef->getName() 81348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick << " missing itinerary for class " 81448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick << SchedClasses[i].Name << '\n'; 81548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick }); 81648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 81748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick} 8182661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick 81948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick// Gather the read/write types for each itinerary class. 82048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trickvoid CodeGenSchedModels::collectProcItinRW() { 82148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick RecVec ItinRWDefs = Records.getAllDerivedDefinitions("ItinRW"); 82248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick std::sort(ItinRWDefs.begin(), ItinRWDefs.end(), LessRecord()); 82348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick for (RecIter II = ItinRWDefs.begin(), IE = ItinRWDefs.end(); II != IE; ++II) { 82448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick if (!(*II)->getValueInit("SchedModel")->isComplete()) 82561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError((*II)->getLoc(), "SchedModel is undefined"); 82648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick Record *ModelDef = (*II)->getValueAsDef("SchedModel"); 82748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick ProcModelMapTy::const_iterator I = ProcModelMap.find(ModelDef); 82848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick if (I == ProcModelMap.end()) { 82961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError((*II)->getLoc(), "Undefined SchedMachineModel " 83048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick + ModelDef->getName()); 8312661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick } 83248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick ProcModels[I->second].ItinRWDefs.push_back(*II); 8332661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick } 83448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick} 83548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick 836de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar// Gather the unsupported features for processor models. 837de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainarvoid CodeGenSchedModels::collectProcUnsupportedFeatures() { 838de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar for (CodeGenProcModel &ProcModel : ProcModels) { 839de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar for (Record *Pred : ProcModel.ModelDef->getValueAsListOfDefs("UnsupportedFeatures")) { 840de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar ProcModel.UnsupportedFeaturesDefs.push_back(Pred); 841de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar } 842de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar } 843de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar} 844de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 8455e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick/// Infer new classes from existing classes. In the process, this may create new 8465e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick/// SchedWrites from sequences of existing SchedWrites. 8475e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trickvoid CodeGenSchedModels::inferSchedClasses() { 8481ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick DEBUG(dbgs() << NumInstrSchedClasses << " instr sched classes.\n"); 8491ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick 8505e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // Visit all existing classes and newly created classes. 8515e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick for (unsigned Idx = 0; Idx != SchedClasses.size(); ++Idx) { 8521ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick assert(SchedClasses[Idx].Index == Idx && "bad SCIdx"); 8531ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick 8545e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick if (SchedClasses[Idx].ItinClassDef) 8555e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick inferFromItinClass(SchedClasses[Idx].ItinClassDef, Idx); 8561ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick if (!SchedClasses[Idx].InstRWs.empty()) 8575e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick inferFromInstRWs(Idx); 8581ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick if (!SchedClasses[Idx].Writes.empty()) { 8595e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick inferFromRW(SchedClasses[Idx].Writes, SchedClasses[Idx].Reads, 8605e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick Idx, SchedClasses[Idx].ProcIndices); 8615e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 8625e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick assert(SchedClasses.size() < (NumInstrSchedClasses*6) && 8635e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick "too many SchedVariants"); 8645e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 8655e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick} 8665e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 8675e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick/// Infer classes from per-processor itinerary resources. 8685e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trickvoid CodeGenSchedModels::inferFromItinClass(Record *ItinClassDef, 8695e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick unsigned FromClassIdx) { 8705e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick for (unsigned PIdx = 0, PEnd = ProcModels.size(); PIdx != PEnd; ++PIdx) { 8715e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick const CodeGenProcModel &PM = ProcModels[PIdx]; 8725e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // For all ItinRW entries. 8735e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick bool HasMatch = false; 8745e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick for (RecIter II = PM.ItinRWDefs.begin(), IE = PM.ItinRWDefs.end(); 8755e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick II != IE; ++II) { 8765e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick RecVec Matched = (*II)->getValueAsListOfDefs("MatchedItinClasses"); 8775e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick if (!std::count(Matched.begin(), Matched.end(), ItinClassDef)) 8785e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick continue; 8795e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick if (HasMatch) 88061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError((*II)->getLoc(), "Duplicate itinerary class " 8815e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick + ItinClassDef->getName() 8825e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick + " in ItinResources for " + PM.ModelName); 8835e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick HasMatch = true; 8845e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick IdxVec Writes, Reads; 8855e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick findRWs((*II)->getValueAsListOfDefs("OperandReadWrites"), Writes, Reads); 8865e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick IdxVec ProcIndices(1, PIdx); 8875e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick inferFromRW(Writes, Reads, FromClassIdx, ProcIndices); 8885e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 8895e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 8905e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick} 8915e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 8925e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick/// Infer classes from per-processor InstReadWrite definitions. 8935e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trickvoid CodeGenSchedModels::inferFromInstRWs(unsigned SCIdx) { 894068ecc15c08ce4692df51f2de2cf73e48e396c97Benjamin Kramer for (unsigned I = 0, E = SchedClasses[SCIdx].InstRWs.size(); I != E; ++I) { 895aca93cf44f0459b6123e9ec640e4cdc7a86e90deBenjamin Kramer assert(SchedClasses[SCIdx].InstRWs.size() == E && "InstrRWs was mutated!"); 896068ecc15c08ce4692df51f2de2cf73e48e396c97Benjamin Kramer Record *Rec = SchedClasses[SCIdx].InstRWs[I]; 897068ecc15c08ce4692df51f2de2cf73e48e396c97Benjamin Kramer const RecVec *InstDefs = Sets.expand(Rec); 89813745262a8db98d6c4513ff9934db4be75a8b26cAndrew Trick RecIter II = InstDefs->begin(), IE = InstDefs->end(); 8995e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick for (; II != IE; ++II) { 9005e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick if (InstrClassMap[*II] == SCIdx) 9015e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick break; 9025e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 9035e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // If this class no longer has any instructions mapped to it, it has become 9045e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // irrelevant. 9055e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick if (II == IE) 9065e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick continue; 9075e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick IdxVec Writes, Reads; 908068ecc15c08ce4692df51f2de2cf73e48e396c97Benjamin Kramer findRWs(Rec->getValueAsListOfDefs("OperandReadWrites"), Writes, Reads); 909068ecc15c08ce4692df51f2de2cf73e48e396c97Benjamin Kramer unsigned PIdx = getProcModel(Rec->getValueAsDef("SchedModel")).Index; 9105e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick IdxVec ProcIndices(1, PIdx); 911068ecc15c08ce4692df51f2de2cf73e48e396c97Benjamin Kramer inferFromRW(Writes, Reads, SCIdx, ProcIndices); // May mutate SchedClasses. 9125e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 9135e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick} 9145e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 9155e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Tricknamespace { 91692649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick// Helper for substituteVariantOperand. 91792649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trickstruct TransVariant { 9182062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick Record *VarOrSeqDef; // Variant or sequence. 9192062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick unsigned RWIdx; // Index of this variant or sequence's matched type. 92092649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick unsigned ProcIdx; // Processor model index or zero for any. 92192649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick unsigned TransVecIdx; // Index into PredTransitions::TransVec. 92292649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick 92392649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick TransVariant(Record *def, unsigned rwi, unsigned pi, unsigned ti): 9242062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick VarOrSeqDef(def), RWIdx(rwi), ProcIdx(pi), TransVecIdx(ti) {} 92592649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick}; 92692649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick 9275e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick// Associate a predicate with the SchedReadWrite that it guards. 9285e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick// RWIdx is the index of the read/write variant. 9295e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trickstruct PredCheck { 9305e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick bool IsRead; 9315e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick unsigned RWIdx; 9325e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick Record *Predicate; 9335e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 9345e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick PredCheck(bool r, unsigned w, Record *p): IsRead(r), RWIdx(w), Predicate(p) {} 9355e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick}; 9365e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 9375e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick// A Predicate transition is a list of RW sequences guarded by a PredTerm. 9385e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trickstruct PredTransition { 9395e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // A predicate term is a conjunction of PredChecks. 9405e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick SmallVector<PredCheck, 4> PredTerm; 9415e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick SmallVector<SmallVector<unsigned,4>, 16> WriteSequences; 9425e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick SmallVector<SmallVector<unsigned,4>, 16> ReadSequences; 94392649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick SmallVector<unsigned, 4> ProcIndices; 9445e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick}; 9455e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 9465e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick// Encapsulate a set of partially constructed transitions. 9475e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick// The results are built by repeated calls to substituteVariants. 9485e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trickclass PredTransitions { 9495e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick CodeGenSchedModels &SchedModels; 9505e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 9515e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trickpublic: 9525e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick std::vector<PredTransition> TransVec; 9535e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 9545e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick PredTransitions(CodeGenSchedModels &sm): SchedModels(sm) {} 9555e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 9565e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick void substituteVariantOperand(const SmallVectorImpl<unsigned> &RWSeq, 9575e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick bool IsRead, unsigned StartIdx); 9585e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 9595e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick void substituteVariants(const PredTransition &Trans); 9605e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 9615e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick#ifndef NDEBUG 9625e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick void dump() const; 9635e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick#endif 9645e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 9655e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trickprivate: 9665e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick bool mutuallyExclusive(Record *PredDef, ArrayRef<PredCheck> Term); 9672062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick void getIntersectingVariants( 9682062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick const CodeGenSchedRW &SchedRW, unsigned TransIdx, 9692062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick std::vector<TransVariant> &IntersectingVariants); 97092649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick void pushVariant(const TransVariant &VInfo, bool IsRead); 9715e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick}; 9725e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick} // anonymous 9735e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 9745e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick// Return true if this predicate is mutually exclusive with a PredTerm. This 9755e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick// degenerates into checking if the predicate is mutually exclusive with any 9765e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick// predicate in the Term's conjunction. 9775e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick// 9785e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick// All predicates associated with a given SchedRW are considered mutually 9795e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick// exclusive. This should work even if the conditions expressed by the 9805e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick// predicates are not exclusive because the predicates for a given SchedWrite 9815e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick// are always checked in the order they are defined in the .td file. Later 9825e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick// conditions implicitly negate any prior condition. 9835e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trickbool PredTransitions::mutuallyExclusive(Record *PredDef, 9845e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick ArrayRef<PredCheck> Term) { 9855e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 9865e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick for (ArrayRef<PredCheck>::iterator I = Term.begin(), E = Term.end(); 9875e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick I != E; ++I) { 9885e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick if (I->Predicate == PredDef) 9895e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick return false; 9905e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 9915e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick const CodeGenSchedRW &SchedRW = SchedModels.getSchedRW(I->RWIdx, I->IsRead); 9925e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick assert(SchedRW.HasVariants && "PredCheck must refer to a SchedVariant"); 9935e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick RecVec Variants = SchedRW.TheDef->getValueAsListOfDefs("Variants"); 9945e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick for (RecIter VI = Variants.begin(), VE = Variants.end(); VI != VE; ++VI) { 9955e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick if ((*VI)->getValueAsDef("Predicate") == PredDef) 9965e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick return true; 9975e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 9985e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 9995e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick return false; 10005e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick} 10015e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 10022062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trickstatic bool hasAliasedVariants(const CodeGenSchedRW &RW, 10032062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick CodeGenSchedModels &SchedModels) { 10042062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick if (RW.HasVariants) 10052062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick return true; 10062062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick 10072062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick for (RecIter I = RW.Aliases.begin(), E = RW.Aliases.end(); I != E; ++I) { 10082062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick const CodeGenSchedRW &AliasRW = 10092062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick SchedModels.getSchedRW((*I)->getValueAsDef("AliasRW")); 10102062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick if (AliasRW.HasVariants) 10112062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick return true; 10122062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick if (AliasRW.IsSequence) { 10132062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick IdxVec ExpandedRWs; 10142062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick SchedModels.expandRWSequence(AliasRW.Index, ExpandedRWs, AliasRW.IsRead); 10152062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick for (IdxIter SI = ExpandedRWs.begin(), SE = ExpandedRWs.end(); 10162062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick SI != SE; ++SI) { 10172062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick if (hasAliasedVariants(SchedModels.getSchedRW(*SI, AliasRW.IsRead), 10182062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick SchedModels)) { 10192062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick return true; 10202062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick } 10212062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick } 10222062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick } 10232062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick } 10242062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick return false; 10252062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick} 10262062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick 10272062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trickstatic bool hasVariant(ArrayRef<PredTransition> Transitions, 10282062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick CodeGenSchedModels &SchedModels) { 10292062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick for (ArrayRef<PredTransition>::iterator 10302062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick PTI = Transitions.begin(), PTE = Transitions.end(); 10312062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick PTI != PTE; ++PTI) { 10322062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick for (SmallVectorImpl<SmallVector<unsigned,4> >::const_iterator 10332062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick WSI = PTI->WriteSequences.begin(), WSE = PTI->WriteSequences.end(); 10342062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick WSI != WSE; ++WSI) { 10352062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick for (SmallVectorImpl<unsigned>::const_iterator 10362062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick WI = WSI->begin(), WE = WSI->end(); WI != WE; ++WI) { 10372062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick if (hasAliasedVariants(SchedModels.getSchedWrite(*WI), SchedModels)) 10382062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick return true; 10392062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick } 10402062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick } 10412062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick for (SmallVectorImpl<SmallVector<unsigned,4> >::const_iterator 10422062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick RSI = PTI->ReadSequences.begin(), RSE = PTI->ReadSequences.end(); 10432062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick RSI != RSE; ++RSI) { 10442062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick for (SmallVectorImpl<unsigned>::const_iterator 10452062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick RI = RSI->begin(), RE = RSI->end(); RI != RE; ++RI) { 10462062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick if (hasAliasedVariants(SchedModels.getSchedRead(*RI), SchedModels)) 10472062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick return true; 10482062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick } 10492062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick } 10502062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick } 10512062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick return false; 10522062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick} 10532062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick 10542062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick// Populate IntersectingVariants with any variants or aliased sequences of the 10552062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick// given SchedRW whose processor indices and predicates are not mutually 1056bc4de7cec1b87fd84e6dad2c512c927d67967a22Andrew Trick// exclusive with the given transition. 10572062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trickvoid PredTransitions::getIntersectingVariants( 10582062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick const CodeGenSchedRW &SchedRW, unsigned TransIdx, 10592062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick std::vector<TransVariant> &IntersectingVariants) { 10602062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick 1061bc4de7cec1b87fd84e6dad2c512c927d67967a22Andrew Trick bool GenericRW = false; 1062bc4de7cec1b87fd84e6dad2c512c927d67967a22Andrew Trick 10632062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick std::vector<TransVariant> Variants; 10642062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick if (SchedRW.HasVariants) { 10652062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick unsigned VarProcIdx = 0; 10662062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick if (SchedRW.TheDef->getValueInit("SchedModel")->isComplete()) { 10672062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick Record *ModelDef = SchedRW.TheDef->getValueAsDef("SchedModel"); 10682062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick VarProcIdx = SchedModels.getProcModel(ModelDef).Index; 10692062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick } 10702062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick // Push each variant. Assign TransVecIdx later. 10712062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick const RecVec VarDefs = SchedRW.TheDef->getValueAsListOfDefs("Variants"); 10722062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick for (RecIter RI = VarDefs.begin(), RE = VarDefs.end(); RI != RE; ++RI) 10732062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick Variants.push_back(TransVariant(*RI, SchedRW.Index, VarProcIdx, 0)); 1074bc4de7cec1b87fd84e6dad2c512c927d67967a22Andrew Trick if (VarProcIdx == 0) 1075bc4de7cec1b87fd84e6dad2c512c927d67967a22Andrew Trick GenericRW = true; 10762062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick } 10772062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick for (RecIter AI = SchedRW.Aliases.begin(), AE = SchedRW.Aliases.end(); 10782062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick AI != AE; ++AI) { 10792062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick // If either the SchedAlias itself or the SchedReadWrite that it aliases 10802062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick // to is defined within a processor model, constrain all variants to 10812062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick // that processor. 10822062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick unsigned AliasProcIdx = 0; 10832062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick if ((*AI)->getValueInit("SchedModel")->isComplete()) { 10842062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick Record *ModelDef = (*AI)->getValueAsDef("SchedModel"); 10852062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick AliasProcIdx = SchedModels.getProcModel(ModelDef).Index; 10862062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick } 10872062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick const CodeGenSchedRW &AliasRW = 10882062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick SchedModels.getSchedRW((*AI)->getValueAsDef("AliasRW")); 10892062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick 10902062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick if (AliasRW.HasVariants) { 10912062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick const RecVec VarDefs = AliasRW.TheDef->getValueAsListOfDefs("Variants"); 10922062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick for (RecIter RI = VarDefs.begin(), RE = VarDefs.end(); RI != RE; ++RI) 10932062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick Variants.push_back(TransVariant(*RI, AliasRW.Index, AliasProcIdx, 0)); 10942062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick } 10952062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick if (AliasRW.IsSequence) { 10962062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick Variants.push_back( 10972062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick TransVariant(AliasRW.TheDef, SchedRW.Index, AliasProcIdx, 0)); 10982062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick } 1099bc4de7cec1b87fd84e6dad2c512c927d67967a22Andrew Trick if (AliasProcIdx == 0) 1100bc4de7cec1b87fd84e6dad2c512c927d67967a22Andrew Trick GenericRW = true; 11012062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick } 11022062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick for (unsigned VIdx = 0, VEnd = Variants.size(); VIdx != VEnd; ++VIdx) { 11032062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick TransVariant &Variant = Variants[VIdx]; 11042062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick // Don't expand variants if the processor models don't intersect. 11052062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick // A zero processor index means any processor. 1106a0ec3f9b7b826b9b40b80199923b664bad808cceCraig Topper SmallVectorImpl<unsigned> &ProcIndices = TransVec[TransIdx].ProcIndices; 11072062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick if (ProcIndices[0] && Variants[VIdx].ProcIdx) { 11082062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick unsigned Cnt = std::count(ProcIndices.begin(), ProcIndices.end(), 11092062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick Variant.ProcIdx); 11102062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick if (!Cnt) 11112062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick continue; 11122062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick if (Cnt > 1) { 11132062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick const CodeGenProcModel &PM = 11142062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick *(SchedModels.procModelBegin() + Variant.ProcIdx); 111561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(Variant.VarOrSeqDef->getLoc(), 111661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "Multiple variants defined for processor " + 111761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PM.ModelName + 111861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger " Ensure only one SchedAlias exists per RW."); 11192062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick } 11202062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick } 11212062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick if (Variant.VarOrSeqDef->isSubClassOf("SchedVar")) { 11222062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick Record *PredDef = Variant.VarOrSeqDef->getValueAsDef("Predicate"); 11232062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick if (mutuallyExclusive(PredDef, TransVec[TransIdx].PredTerm)) 11242062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick continue; 11252062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick } 11262062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick if (IntersectingVariants.empty()) { 11272062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick // The first variant builds on the existing transition. 11282062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick Variant.TransVecIdx = TransIdx; 11292062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick IntersectingVariants.push_back(Variant); 11302062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick } 11312062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick else { 11322062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick // Push another copy of the current transition for more variants. 11332062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick Variant.TransVecIdx = TransVec.size(); 11342062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick IntersectingVariants.push_back(Variant); 11351cbd4017566ea2fcb1a7cd605f412322da879e34Dan Gohman TransVec.push_back(TransVec[TransIdx]); 11362062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick } 11372062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick } 1138bc4de7cec1b87fd84e6dad2c512c927d67967a22Andrew Trick if (GenericRW && IntersectingVariants.empty()) { 1139bc4de7cec1b87fd84e6dad2c512c927d67967a22Andrew Trick PrintFatalError(SchedRW.TheDef->getLoc(), "No variant of this type has " 1140bc4de7cec1b87fd84e6dad2c512c927d67967a22Andrew Trick "a matching predicate on any processor"); 1141bc4de7cec1b87fd84e6dad2c512c927d67967a22Andrew Trick } 11422062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick} 11432062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick 114492649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick// Push the Reads/Writes selected by this variant onto the PredTransition 114592649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick// specified by VInfo. 114692649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trickvoid PredTransitions:: 114792649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew TrickpushVariant(const TransVariant &VInfo, bool IsRead) { 114892649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick 114992649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick PredTransition &Trans = TransVec[VInfo.TransVecIdx]; 115092649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick 115192649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick // If this operand transition is reached through a processor-specific alias, 115292649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick // then the whole transition is specific to this processor. 115392649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick if (VInfo.ProcIdx != 0) 115492649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick Trans.ProcIndices.assign(1, VInfo.ProcIdx); 115592649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick 11565e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick IdxVec SelectedRWs; 11572062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick if (VInfo.VarOrSeqDef->isSubClassOf("SchedVar")) { 11582062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick Record *PredDef = VInfo.VarOrSeqDef->getValueAsDef("Predicate"); 11592062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick Trans.PredTerm.push_back(PredCheck(IsRead, VInfo.RWIdx,PredDef)); 11602062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick RecVec SelectedDefs = VInfo.VarOrSeqDef->getValueAsListOfDefs("Selected"); 11612062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick SchedModels.findRWs(SelectedDefs, SelectedRWs, IsRead); 11622062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick } 11632062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick else { 11642062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick assert(VInfo.VarOrSeqDef->isSubClassOf("WriteSequence") && 11652062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick "variant must be a SchedVariant or aliased WriteSequence"); 11662062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick SelectedRWs.push_back(SchedModels.getSchedRWIdx(VInfo.VarOrSeqDef, IsRead)); 11672062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick } 11685e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 116992649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick const CodeGenSchedRW &SchedRW = SchedModels.getSchedRW(VInfo.RWIdx, IsRead); 11705e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 11715e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick SmallVectorImpl<SmallVector<unsigned,4> > &RWSequences = IsRead 11725e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick ? Trans.ReadSequences : Trans.WriteSequences; 11735e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick if (SchedRW.IsVariadic) { 11745e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick unsigned OperIdx = RWSequences.size()-1; 11755e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // Make N-1 copies of this transition's last sequence. 11765e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick for (unsigned i = 1, e = SelectedRWs.size(); i != e; ++i) { 117745dc03287e29affeeb7e1f1281fca63d8b9773b1Arnold Schwaighofer // Create a temporary copy the vector could reallocate. 11780efc78257b56d2ba45127e1a3f18b524a1c3dd57Arnold Schwaighofer RWSequences.reserve(RWSequences.size() + 1); 11790efc78257b56d2ba45127e1a3f18b524a1c3dd57Arnold Schwaighofer RWSequences.push_back(RWSequences[OperIdx]); 11805e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 11815e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // Push each of the N elements of the SelectedRWs onto a copy of the last 11825e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // sequence (split the current operand into N operands). 11835e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // Note that write sequences should be expanded within this loop--the entire 11845e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // sequence belongs to a single operand. 11855e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick for (IdxIter RWI = SelectedRWs.begin(), RWE = SelectedRWs.end(); 11865e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick RWI != RWE; ++RWI, ++OperIdx) { 11875e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick IdxVec ExpandedRWs; 11885e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick if (IsRead) 11895e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick ExpandedRWs.push_back(*RWI); 11905e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick else 11915e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick SchedModels.expandRWSequence(*RWI, ExpandedRWs, IsRead); 11925e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick RWSequences[OperIdx].insert(RWSequences[OperIdx].end(), 11935e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick ExpandedRWs.begin(), ExpandedRWs.end()); 11945e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 11955e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick assert(OperIdx == RWSequences.size() && "missed a sequence"); 11965e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 11975e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick else { 11985e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // Push this transition's expanded sequence onto this transition's last 11995e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // sequence (add to the current operand's sequence). 12005e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick SmallVectorImpl<unsigned> &Seq = RWSequences.back(); 12015e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick IdxVec ExpandedRWs; 12025e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick for (IdxIter RWI = SelectedRWs.begin(), RWE = SelectedRWs.end(); 12035e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick RWI != RWE; ++RWI) { 12045e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick if (IsRead) 12055e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick ExpandedRWs.push_back(*RWI); 12065e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick else 12075e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick SchedModels.expandRWSequence(*RWI, ExpandedRWs, IsRead); 12085e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 12095e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick Seq.insert(Seq.end(), ExpandedRWs.begin(), ExpandedRWs.end()); 12105e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 12115e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick} 12125e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 12135e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick// RWSeq is a sequence of all Reads or all Writes for the next read or write 12145e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick// operand. StartIdx is an index into TransVec where partial results 121592649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick// starts. RWSeq must be applied to all transitions between StartIdx and the end 12165e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick// of TransVec. 12175e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trickvoid PredTransitions::substituteVariantOperand( 12185e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick const SmallVectorImpl<unsigned> &RWSeq, bool IsRead, unsigned StartIdx) { 12195e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 12205e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // Visit each original RW within the current sequence. 12215e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick for (SmallVectorImpl<unsigned>::const_iterator 12225e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick RWI = RWSeq.begin(), RWE = RWSeq.end(); RWI != RWE; ++RWI) { 12235e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick const CodeGenSchedRW &SchedRW = SchedModels.getSchedRW(*RWI, IsRead); 12245e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // Push this RW on all partial PredTransitions or distribute variants. 12255e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // New PredTransitions may be pushed within this loop which should not be 12265e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // revisited (TransEnd must be loop invariant). 12275e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick for (unsigned TransIdx = StartIdx, TransEnd = TransVec.size(); 12285e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick TransIdx != TransEnd; ++TransIdx) { 12295e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // In the common case, push RW onto the current operand's sequence. 123092649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick if (!hasAliasedVariants(SchedRW, SchedModels)) { 12315e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick if (IsRead) 12325e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick TransVec[TransIdx].ReadSequences.back().push_back(*RWI); 12335e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick else 12345e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick TransVec[TransIdx].WriteSequences.back().push_back(*RWI); 12355e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick continue; 12365e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 12375e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // Distribute this partial PredTransition across intersecting variants. 12382062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick // This will push a copies of TransVec[TransIdx] on the back of TransVec. 123992649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick std::vector<TransVariant> IntersectingVariants; 12402062b1260fa9df3e69e7b4d24a657a0ebb7f8710Andrew Trick getIntersectingVariants(SchedRW, TransIdx, IntersectingVariants); 12415e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // Now expand each variant on top of its copy of the transition. 124292649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick for (std::vector<TransVariant>::const_iterator 12435e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick IVI = IntersectingVariants.begin(), 12445e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick IVE = IntersectingVariants.end(); 124592649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick IVI != IVE; ++IVI) { 124692649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick pushVariant(*IVI, IsRead); 124792649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick } 12485e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 12495e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 12505e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick} 12515e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 12525e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick// For each variant of a Read/Write in Trans, substitute the sequence of 12535e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick// Read/Writes guarded by the variant. This is exponential in the number of 12545e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick// variant Read/Writes, but in practice detection of mutually exclusive 12555e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick// predicates should result in linear growth in the total number variants. 12565e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick// 12575e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick// This is one step in a breadth-first search of nested variants. 12585e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trickvoid PredTransitions::substituteVariants(const PredTransition &Trans) { 12595e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // Build up a set of partial results starting at the back of 12605e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // PredTransitions. Remember the first new transition. 12615e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick unsigned StartIdx = TransVec.size(); 12625e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick TransVec.resize(TransVec.size() + 1); 12635e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick TransVec.back().PredTerm = Trans.PredTerm; 126492649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick TransVec.back().ProcIndices = Trans.ProcIndices; 12655e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 12665e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // Visit each original write sequence. 12675e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick for (SmallVectorImpl<SmallVector<unsigned,4> >::const_iterator 12685e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick WSI = Trans.WriteSequences.begin(), WSE = Trans.WriteSequences.end(); 12695e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick WSI != WSE; ++WSI) { 12705e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // Push a new (empty) write sequence onto all partial Transitions. 12715e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick for (std::vector<PredTransition>::iterator I = 12725e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick TransVec.begin() + StartIdx, E = TransVec.end(); I != E; ++I) { 12735e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick I->WriteSequences.resize(I->WriteSequences.size() + 1); 12745e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 12755e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick substituteVariantOperand(*WSI, /*IsRead=*/false, StartIdx); 12765e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 12775e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // Visit each original read sequence. 12785e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick for (SmallVectorImpl<SmallVector<unsigned,4> >::const_iterator 12795e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick RSI = Trans.ReadSequences.begin(), RSE = Trans.ReadSequences.end(); 12805e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick RSI != RSE; ++RSI) { 12815e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // Push a new (empty) read sequence onto all partial Transitions. 12825e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick for (std::vector<PredTransition>::iterator I = 12835e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick TransVec.begin() + StartIdx, E = TransVec.end(); I != E; ++I) { 12845e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick I->ReadSequences.resize(I->ReadSequences.size() + 1); 12855e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 12865e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick substituteVariantOperand(*RSI, /*IsRead=*/true, StartIdx); 12875e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 12885e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick} 12895e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 12905e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick// Create a new SchedClass for each variant found by inferFromRW. Pass 12915e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trickstatic void inferFromTransitions(ArrayRef<PredTransition> LastTransitions, 129292649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick unsigned FromClassIdx, 12935e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick CodeGenSchedModels &SchedModels) { 12945e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // For each PredTransition, create a new CodeGenSchedTransition, which usually 12955e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // requires creating a new SchedClass. 12965e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick for (ArrayRef<PredTransition>::iterator 12975e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick I = LastTransitions.begin(), E = LastTransitions.end(); I != E; ++I) { 12985e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick IdxVec OperWritesVariant; 12995e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick for (SmallVectorImpl<SmallVector<unsigned,4> >::const_iterator 13005e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick WSI = I->WriteSequences.begin(), WSE = I->WriteSequences.end(); 13015e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick WSI != WSE; ++WSI) { 13025e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // Create a new write representing the expanded sequence. 13035e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick OperWritesVariant.push_back( 13045e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick SchedModels.findOrInsertRW(*WSI, /*IsRead=*/false)); 13055e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 13065e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick IdxVec OperReadsVariant; 13075e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick for (SmallVectorImpl<SmallVector<unsigned,4> >::const_iterator 13085e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick RSI = I->ReadSequences.begin(), RSE = I->ReadSequences.end(); 13095e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick RSI != RSE; ++RSI) { 131092649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick // Create a new read representing the expanded sequence. 13115e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick OperReadsVariant.push_back( 13125e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick SchedModels.findOrInsertRW(*RSI, /*IsRead=*/true)); 13135e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 131492649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick IdxVec ProcIndices(I->ProcIndices.begin(), I->ProcIndices.end()); 13155e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick CodeGenSchedTransition SCTrans; 13165e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick SCTrans.ToClassIdx = 1317dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines SchedModels.addSchedClass(/*ItinClassDef=*/nullptr, OperWritesVariant, 13181ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick OperReadsVariant, ProcIndices); 13195e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick SCTrans.ProcIndices = ProcIndices; 13205e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // The final PredTerm is unique set of predicates guarding the transition. 13215e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick RecVec Preds; 13225e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick for (SmallVectorImpl<PredCheck>::const_iterator 13235e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick PI = I->PredTerm.begin(), PE = I->PredTerm.end(); PI != PE; ++PI) { 13245e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick Preds.push_back(PI->Predicate); 13255e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 13265e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick RecIter PredsEnd = std::unique(Preds.begin(), Preds.end()); 13275e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick Preds.resize(PredsEnd - Preds.begin()); 13285e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick SCTrans.PredTerm = Preds; 13295e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick SchedModels.getSchedClass(FromClassIdx).Transitions.push_back(SCTrans); 13305e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 13315e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick} 13325e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 133392649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick// Create new SchedClasses for the given ReadWrite list. If any of the 133492649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick// ReadWrites refers to a SchedVariant, create a new SchedClass for each variant 133592649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick// of the ReadWrite list, following Aliases if necessary. 1336f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainarvoid CodeGenSchedModels::inferFromRW(ArrayRef<unsigned> OperWrites, 1337f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar ArrayRef<unsigned> OperReads, 13385e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick unsigned FromClassIdx, 1339f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar ArrayRef<unsigned> ProcIndices) { 134082e7c4f533a98a16b0cadd5209c1d3dc8ce33d87Andrew Trick DEBUG(dbgs() << "INFER RW proc("; dumpIdxVec(ProcIndices); dbgs() << ") "); 13415e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 13425e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // Create a seed transition with an empty PredTerm and the expanded sequences 13435e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // of SchedWrites for the current SchedClass. 13445e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick std::vector<PredTransition> LastTransitions; 13455e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick LastTransitions.resize(1); 134692649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick LastTransitions.back().ProcIndices.append(ProcIndices.begin(), 134792649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick ProcIndices.end()); 134892649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick 1349f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar for (unsigned WriteIdx : OperWrites) { 13505e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick IdxVec WriteSeq; 1351f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar expandRWSequence(WriteIdx, WriteSeq, /*IsRead=*/false); 13525e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick unsigned Idx = LastTransitions[0].WriteSequences.size(); 13535e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick LastTransitions[0].WriteSequences.resize(Idx + 1); 13545e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick SmallVectorImpl<unsigned> &Seq = LastTransitions[0].WriteSequences[Idx]; 13555e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick for (IdxIter WI = WriteSeq.begin(), WE = WriteSeq.end(); WI != WE; ++WI) 13565e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick Seq.push_back(*WI); 13575e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick DEBUG(dbgs() << "("; dumpIdxVec(Seq); dbgs() << ") "); 13585e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 13595e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick DEBUG(dbgs() << " Reads: "); 1360f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar for (unsigned ReadIdx : OperReads) { 13615e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick IdxVec ReadSeq; 1362f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar expandRWSequence(ReadIdx, ReadSeq, /*IsRead=*/true); 13635e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick unsigned Idx = LastTransitions[0].ReadSequences.size(); 13645e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick LastTransitions[0].ReadSequences.resize(Idx + 1); 13655e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick SmallVectorImpl<unsigned> &Seq = LastTransitions[0].ReadSequences[Idx]; 13665e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick for (IdxIter RI = ReadSeq.begin(), RE = ReadSeq.end(); RI != RE; ++RI) 13675e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick Seq.push_back(*RI); 13685e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick DEBUG(dbgs() << "("; dumpIdxVec(Seq); dbgs() << ") "); 13695e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 13705e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick DEBUG(dbgs() << '\n'); 13715e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 13725e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // Collect all PredTransitions for individual operands. 13735e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // Iterate until no variant writes remain. 13745e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick while (hasVariant(LastTransitions, *this)) { 13755e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick PredTransitions Transitions(*this); 13765e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick for (std::vector<PredTransition>::const_iterator 13775e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick I = LastTransitions.begin(), E = LastTransitions.end(); 13785e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick I != E; ++I) { 13795e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick Transitions.substituteVariants(*I); 13805e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 13815e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick DEBUG(Transitions.dump()); 13825e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick LastTransitions.swap(Transitions.TransVec); 13835e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 13845e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // If the first transition has no variants, nothing to do. 13855e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick if (LastTransitions[0].PredTerm.empty()) 13865e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick return; 13875e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 13885e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // WARNING: We are about to mutate the SchedClasses vector. Do not refer to 13895e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick // OperWrites, OperReads, or ProcIndices after calling inferFromTransitions. 139092649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick inferFromTransitions(LastTransitions, FromClassIdx, *this); 13915e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick} 13925e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 1393e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick// Check if any processor resource group contains all resource records in 1394e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick// SubUnits. 1395e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trickbool CodeGenSchedModels::hasSuperGroup(RecVec &SubUnits, CodeGenProcModel &PM) { 1396e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick for (unsigned i = 0, e = PM.ProcResourceDefs.size(); i < e; ++i) { 1397e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick if (!PM.ProcResourceDefs[i]->isSubClassOf("ProcResGroup")) 1398e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick continue; 1399e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick RecVec SuperUnits = 1400e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick PM.ProcResourceDefs[i]->getValueAsListOfDefs("Resources"); 1401e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick RecIter RI = SubUnits.begin(), RE = SubUnits.end(); 1402e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick for ( ; RI != RE; ++RI) { 1403e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick if (std::find(SuperUnits.begin(), SuperUnits.end(), *RI) 1404e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick == SuperUnits.end()) { 1405e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick break; 1406e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick } 1407e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick } 1408e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick if (RI == RE) 1409e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick return true; 1410e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick } 1411e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick return false; 1412e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick} 1413e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick 1414e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick// Verify that overlapping groups have a common supergroup. 1415e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trickvoid CodeGenSchedModels::verifyProcResourceGroups(CodeGenProcModel &PM) { 1416e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick for (unsigned i = 0, e = PM.ProcResourceDefs.size(); i < e; ++i) { 1417e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick if (!PM.ProcResourceDefs[i]->isSubClassOf("ProcResGroup")) 1418e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick continue; 1419e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick RecVec CheckUnits = 1420e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick PM.ProcResourceDefs[i]->getValueAsListOfDefs("Resources"); 1421e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick for (unsigned j = i+1; j < e; ++j) { 1422e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick if (!PM.ProcResourceDefs[j]->isSubClassOf("ProcResGroup")) 1423e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick continue; 1424e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick RecVec OtherUnits = 1425e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick PM.ProcResourceDefs[j]->getValueAsListOfDefs("Resources"); 1426e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick if (std::find_first_of(CheckUnits.begin(), CheckUnits.end(), 1427e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick OtherUnits.begin(), OtherUnits.end()) 1428e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick != CheckUnits.end()) { 1429e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick // CheckUnits and OtherUnits overlap 1430e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick OtherUnits.insert(OtherUnits.end(), CheckUnits.begin(), 1431e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick CheckUnits.end()); 1432e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick if (!hasSuperGroup(OtherUnits, PM)) { 1433e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick PrintFatalError((PM.ProcResourceDefs[i])->getLoc(), 1434e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick "proc resource group overlaps with " 1435e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick + PM.ProcResourceDefs[j]->getName() 1436e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick + " but no supergroup contains both."); 1437e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick } 1438e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick } 1439e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick } 1440e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick } 1441e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick} 1442e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick 14433cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick// Collect and sort WriteRes, ReadAdvance, and ProcResources. 14443cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trickvoid CodeGenSchedModels::collectProcResources() { 1445de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar ProcResourceDefs = Records.getAllDerivedDefinitions("ProcResourceUnits"); 1446de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar ProcResGroups = Records.getAllDerivedDefinitions("ProcResGroup"); 1447de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 14483cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick // Add any subtarget-specific SchedReadWrites that are directly associated 14493cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick // with processor resources. Refer to the parent SchedClass's ProcIndices to 14503cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick // determine which processors they apply to. 14513cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick for (SchedClassIter SCI = schedClassBegin(), SCE = schedClassEnd(); 14523cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick SCI != SCE; ++SCI) { 14533cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick if (SCI->ItinClassDef) 14543cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick collectItinProcResources(SCI->ItinClassDef); 1455d9a4f0cbd28351155a7d9bd62aa08d8394435f82Andrew Trick else { 1456d9a4f0cbd28351155a7d9bd62aa08d8394435f82Andrew Trick // This class may have a default ReadWrite list which can be overriden by 1457d9a4f0cbd28351155a7d9bd62aa08d8394435f82Andrew Trick // InstRW definitions. 1458d9a4f0cbd28351155a7d9bd62aa08d8394435f82Andrew Trick if (!SCI->InstRWs.empty()) { 1459d9a4f0cbd28351155a7d9bd62aa08d8394435f82Andrew Trick for (RecIter RWI = SCI->InstRWs.begin(), RWE = SCI->InstRWs.end(); 1460d9a4f0cbd28351155a7d9bd62aa08d8394435f82Andrew Trick RWI != RWE; ++RWI) { 1461d9a4f0cbd28351155a7d9bd62aa08d8394435f82Andrew Trick Record *RWModelDef = (*RWI)->getValueAsDef("SchedModel"); 1462d9a4f0cbd28351155a7d9bd62aa08d8394435f82Andrew Trick IdxVec ProcIndices(1, getProcModel(RWModelDef).Index); 1463d9a4f0cbd28351155a7d9bd62aa08d8394435f82Andrew Trick IdxVec Writes, Reads; 1464d9a4f0cbd28351155a7d9bd62aa08d8394435f82Andrew Trick findRWs((*RWI)->getValueAsListOfDefs("OperandReadWrites"), 1465d9a4f0cbd28351155a7d9bd62aa08d8394435f82Andrew Trick Writes, Reads); 1466d9a4f0cbd28351155a7d9bd62aa08d8394435f82Andrew Trick collectRWResources(Writes, Reads, ProcIndices); 1467d9a4f0cbd28351155a7d9bd62aa08d8394435f82Andrew Trick } 1468d9a4f0cbd28351155a7d9bd62aa08d8394435f82Andrew Trick } 14693cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick collectRWResources(SCI->Writes, SCI->Reads, SCI->ProcIndices); 1470d9a4f0cbd28351155a7d9bd62aa08d8394435f82Andrew Trick } 14713cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick } 14723cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick // Add resources separately defined by each subtarget. 14733cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick RecVec WRDefs = Records.getAllDerivedDefinitions("WriteRes"); 14743cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick for (RecIter WRI = WRDefs.begin(), WRE = WRDefs.end(); WRI != WRE; ++WRI) { 14753cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick Record *ModelDef = (*WRI)->getValueAsDef("SchedModel"); 14763cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick addWriteRes(*WRI, getProcModel(ModelDef).Index); 14773cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick } 147836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines RecVec SWRDefs = Records.getAllDerivedDefinitions("SchedWriteRes"); 147936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines for (RecIter WRI = SWRDefs.begin(), WRE = SWRDefs.end(); WRI != WRE; ++WRI) { 148036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Record *ModelDef = (*WRI)->getValueAsDef("SchedModel"); 148136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines addWriteRes(*WRI, getProcModel(ModelDef).Index); 148236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 14833cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick RecVec RADefs = Records.getAllDerivedDefinitions("ReadAdvance"); 14843cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick for (RecIter RAI = RADefs.begin(), RAE = RADefs.end(); RAI != RAE; ++RAI) { 14853cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick Record *ModelDef = (*RAI)->getValueAsDef("SchedModel"); 14863cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick addReadAdvance(*RAI, getProcModel(ModelDef).Index); 14873cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick } 148836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines RecVec SRADefs = Records.getAllDerivedDefinitions("SchedReadAdvance"); 148936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines for (RecIter RAI = SRADefs.begin(), RAE = SRADefs.end(); RAI != RAE; ++RAI) { 149036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if ((*RAI)->getValueInit("SchedModel")->isComplete()) { 149136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Record *ModelDef = (*RAI)->getValueAsDef("SchedModel"); 149236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines addReadAdvance(*RAI, getProcModel(ModelDef).Index); 149336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 149436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 1495a3d82ce19fd825cbf3bf85b5969424217fc40b45Andrew Trick // Add ProcResGroups that are defined within this processor model, which may 1496a3d82ce19fd825cbf3bf85b5969424217fc40b45Andrew Trick // not be directly referenced but may directly specify a buffer size. 1497a3d82ce19fd825cbf3bf85b5969424217fc40b45Andrew Trick RecVec ProcResGroups = Records.getAllDerivedDefinitions("ProcResGroup"); 1498a3d82ce19fd825cbf3bf85b5969424217fc40b45Andrew Trick for (RecIter RI = ProcResGroups.begin(), RE = ProcResGroups.end(); 1499a3d82ce19fd825cbf3bf85b5969424217fc40b45Andrew Trick RI != RE; ++RI) { 1500a3d82ce19fd825cbf3bf85b5969424217fc40b45Andrew Trick if (!(*RI)->getValueInit("SchedModel")->isComplete()) 1501a3d82ce19fd825cbf3bf85b5969424217fc40b45Andrew Trick continue; 1502a3d82ce19fd825cbf3bf85b5969424217fc40b45Andrew Trick CodeGenProcModel &PM = getProcModel((*RI)->getValueAsDef("SchedModel")); 1503a3d82ce19fd825cbf3bf85b5969424217fc40b45Andrew Trick RecIter I = std::find(PM.ProcResourceDefs.begin(), 1504a3d82ce19fd825cbf3bf85b5969424217fc40b45Andrew Trick PM.ProcResourceDefs.end(), *RI); 1505a3d82ce19fd825cbf3bf85b5969424217fc40b45Andrew Trick if (I == PM.ProcResourceDefs.end()) 1506a3d82ce19fd825cbf3bf85b5969424217fc40b45Andrew Trick PM.ProcResourceDefs.push_back(*RI); 1507a3d82ce19fd825cbf3bf85b5969424217fc40b45Andrew Trick } 15083cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick // Finalize each ProcModel by sorting the record arrays. 1509ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines for (CodeGenProcModel &PM : ProcModels) { 15103cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick std::sort(PM.WriteResDefs.begin(), PM.WriteResDefs.end(), 15113cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick LessRecord()); 15123cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick std::sort(PM.ReadAdvanceDefs.begin(), PM.ReadAdvanceDefs.end(), 15133cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick LessRecord()); 15143cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick std::sort(PM.ProcResourceDefs.begin(), PM.ProcResourceDefs.end(), 15153cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick LessRecord()); 15163cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick DEBUG( 15173cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick PM.dump(); 15183cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick dbgs() << "WriteResDefs: "; 15193cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick for (RecIter RI = PM.WriteResDefs.begin(), 15203cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick RE = PM.WriteResDefs.end(); RI != RE; ++RI) { 15213cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick if ((*RI)->isSubClassOf("WriteRes")) 15223cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick dbgs() << (*RI)->getValueAsDef("WriteType")->getName() << " "; 15233cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick else 15243cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick dbgs() << (*RI)->getName() << " "; 15253cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick } 15263cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick dbgs() << "\nReadAdvanceDefs: "; 15273cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick for (RecIter RI = PM.ReadAdvanceDefs.begin(), 15283cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick RE = PM.ReadAdvanceDefs.end(); RI != RE; ++RI) { 15293cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick if ((*RI)->isSubClassOf("ReadAdvance")) 15303cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick dbgs() << (*RI)->getValueAsDef("ReadType")->getName() << " "; 15313cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick else 15323cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick dbgs() << (*RI)->getName() << " "; 15333cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick } 15343cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick dbgs() << "\nProcResourceDefs: "; 15353cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick for (RecIter RI = PM.ProcResourceDefs.begin(), 15363cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick RE = PM.ProcResourceDefs.end(); RI != RE; ++RI) { 15373cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick dbgs() << (*RI)->getName() << " "; 15383cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick } 15393cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick dbgs() << '\n'); 1540e30f32a69ba57dfecbd670d971048bccaf727798Andrew Trick verifyProcResourceGroups(PM); 15413cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick } 1542de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 1543de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar ProcResourceDefs.clear(); 1544de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar ProcResGroups.clear(); 1545de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar} 1546de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 1547de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainarvoid CodeGenSchedModels::checkCompleteness() { 1548de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar bool Complete = true; 1549de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar bool HadCompleteModel = false; 1550de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar for (const CodeGenProcModel &ProcModel : procModels()) { 1551de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (!ProcModel.ModelDef->getValueAsBit("CompleteModel")) 1552de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar continue; 1553de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar for (const CodeGenInstruction *Inst : Target.getInstructionsByEnumValue()) { 1554de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (Inst->hasNoSchedulingInfo) 1555de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar continue; 1556de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (ProcModel.isUnsupported(*Inst)) 1557de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar continue; 1558de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar unsigned SCIdx = getSchedClassIdx(*Inst); 1559de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (!SCIdx) { 1560de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (Inst->TheDef->isValueUnset("SchedRW") && !HadCompleteModel) { 1561de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar PrintError("No schedule information for instruction '" 1562de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar + Inst->TheDef->getName() + "'"); 1563de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Complete = false; 1564de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar } 1565de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar continue; 1566de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar } 1567de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 1568de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar const CodeGenSchedClass &SC = getSchedClass(SCIdx); 1569de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (!SC.Writes.empty()) 1570de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar continue; 1571de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (SC.ItinClassDef != nullptr) 1572de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar continue; 1573de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 1574de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar const RecVec &InstRWs = SC.InstRWs; 1575de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar auto I = std::find_if(InstRWs.begin(), InstRWs.end(), 1576de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar [&ProcModel] (const Record *R) { 1577de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return R->getValueAsDef("SchedModel") == 1578de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar ProcModel.ModelDef; 1579de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar }); 1580de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (I == InstRWs.end()) { 1581de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar PrintError("'" + ProcModel.ModelName + "' lacks information for '" + 1582de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Inst->TheDef->getName() + "'"); 1583de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Complete = false; 1584de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar } 1585de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar } 1586de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar HadCompleteModel = true; 1587de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar } 1588de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (!Complete) { 1589de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar errs() << "\n\nIncomplete schedule models found.\n" 1590de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar << "- Consider setting 'CompleteModel = 0' while developing new models.\n" 1591de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar << "- Pseudo instructions can be marked with 'hasNoSchedulingInfo = 1'.\n" 1592de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar << "- Instructions should usually have Sched<[...]> as a superclass, " 1593de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar "you may temporarily use an empty list.\n" 1594de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar << "- Instructions related to unsupported features can be excluded with " 1595de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar "list<Predicate> UnsupportedFeatures = [HasA,..,HasY]; in the " 1596de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar "processor model.\n\n"; 1597de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar PrintFatalError("Incomplete schedule model"); 1598de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar } 15993cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick} 16003cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick 16013cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick// Collect itinerary class resources for each processor. 16023cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trickvoid CodeGenSchedModels::collectItinProcResources(Record *ItinClassDef) { 16033cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick for (unsigned PIdx = 0, PEnd = ProcModels.size(); PIdx != PEnd; ++PIdx) { 16043cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick const CodeGenProcModel &PM = ProcModels[PIdx]; 16053cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick // For all ItinRW entries. 16063cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick bool HasMatch = false; 16073cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick for (RecIter II = PM.ItinRWDefs.begin(), IE = PM.ItinRWDefs.end(); 16083cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick II != IE; ++II) { 16093cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick RecVec Matched = (*II)->getValueAsListOfDefs("MatchedItinClasses"); 16103cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick if (!std::count(Matched.begin(), Matched.end(), ItinClassDef)) 16113cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick continue; 16123cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick if (HasMatch) 161361131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError((*II)->getLoc(), "Duplicate itinerary class " 161461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger + ItinClassDef->getName() 161561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger + " in ItinResources for " + PM.ModelName); 16163cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick HasMatch = true; 16173cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick IdxVec Writes, Reads; 16183cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick findRWs((*II)->getValueAsListOfDefs("OperandReadWrites"), Writes, Reads); 16193cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick IdxVec ProcIndices(1, PIdx); 16203cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick collectRWResources(Writes, Reads, ProcIndices); 16213cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick } 16223cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick } 16233cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick} 16243cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick 1625dbe6d43dfac78d567973dac8fc2a0190dad5135fAndrew Trickvoid CodeGenSchedModels::collectRWResources(unsigned RWIdx, bool IsRead, 1626f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar ArrayRef<unsigned> ProcIndices) { 1627dbe6d43dfac78d567973dac8fc2a0190dad5135fAndrew Trick const CodeGenSchedRW &SchedRW = getSchedRW(RWIdx, IsRead); 1628dbe6d43dfac78d567973dac8fc2a0190dad5135fAndrew Trick if (SchedRW.TheDef) { 1629dbe6d43dfac78d567973dac8fc2a0190dad5135fAndrew Trick if (!IsRead && SchedRW.TheDef->isSubClassOf("SchedWriteRes")) { 1630f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar for (unsigned Idx : ProcIndices) 1631f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar addWriteRes(SchedRW.TheDef, Idx); 16323cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick } 1633dbe6d43dfac78d567973dac8fc2a0190dad5135fAndrew Trick else if (IsRead && SchedRW.TheDef->isSubClassOf("SchedReadAdvance")) { 1634f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar for (unsigned Idx : ProcIndices) 1635f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar addReadAdvance(SchedRW.TheDef, Idx); 16363cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick } 1637dbe6d43dfac78d567973dac8fc2a0190dad5135fAndrew Trick } 1638dbe6d43dfac78d567973dac8fc2a0190dad5135fAndrew Trick for (RecIter AI = SchedRW.Aliases.begin(), AE = SchedRW.Aliases.end(); 1639dbe6d43dfac78d567973dac8fc2a0190dad5135fAndrew Trick AI != AE; ++AI) { 1640dbe6d43dfac78d567973dac8fc2a0190dad5135fAndrew Trick IdxVec AliasProcIndices; 1641dbe6d43dfac78d567973dac8fc2a0190dad5135fAndrew Trick if ((*AI)->getValueInit("SchedModel")->isComplete()) { 1642dbe6d43dfac78d567973dac8fc2a0190dad5135fAndrew Trick AliasProcIndices.push_back( 1643dbe6d43dfac78d567973dac8fc2a0190dad5135fAndrew Trick getProcModel((*AI)->getValueAsDef("SchedModel")).Index); 1644dbe6d43dfac78d567973dac8fc2a0190dad5135fAndrew Trick } 1645dbe6d43dfac78d567973dac8fc2a0190dad5135fAndrew Trick else 1646dbe6d43dfac78d567973dac8fc2a0190dad5135fAndrew Trick AliasProcIndices = ProcIndices; 1647dbe6d43dfac78d567973dac8fc2a0190dad5135fAndrew Trick const CodeGenSchedRW &AliasRW = getSchedRW((*AI)->getValueAsDef("AliasRW")); 1648dbe6d43dfac78d567973dac8fc2a0190dad5135fAndrew Trick assert(AliasRW.IsRead == IsRead && "cannot alias reads to writes"); 1649dbe6d43dfac78d567973dac8fc2a0190dad5135fAndrew Trick 1650dbe6d43dfac78d567973dac8fc2a0190dad5135fAndrew Trick IdxVec ExpandedRWs; 1651dbe6d43dfac78d567973dac8fc2a0190dad5135fAndrew Trick expandRWSequence(AliasRW.Index, ExpandedRWs, IsRead); 1652dbe6d43dfac78d567973dac8fc2a0190dad5135fAndrew Trick for (IdxIter SI = ExpandedRWs.begin(), SE = ExpandedRWs.end(); 1653dbe6d43dfac78d567973dac8fc2a0190dad5135fAndrew Trick SI != SE; ++SI) { 1654dbe6d43dfac78d567973dac8fc2a0190dad5135fAndrew Trick collectRWResources(*SI, IsRead, AliasProcIndices); 165592649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick } 16563cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick } 16573cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick} 16583cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick 1659dbe6d43dfac78d567973dac8fc2a0190dad5135fAndrew Trick// Collect resources for a set of read/write types and processor indices. 1660f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainarvoid CodeGenSchedModels::collectRWResources(ArrayRef<unsigned> Writes, 1661f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar ArrayRef<unsigned> Reads, 1662f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar ArrayRef<unsigned> ProcIndices) { 1663dbe6d43dfac78d567973dac8fc2a0190dad5135fAndrew Trick 1664f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar for (unsigned Idx : Writes) 1665f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar collectRWResources(Idx, /*IsRead=*/false, ProcIndices); 1666dbe6d43dfac78d567973dac8fc2a0190dad5135fAndrew Trick 1667f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar for (unsigned Idx : Reads) 1668f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar collectRWResources(Idx, /*IsRead=*/true, ProcIndices); 1669dbe6d43dfac78d567973dac8fc2a0190dad5135fAndrew Trick} 1670dbe6d43dfac78d567973dac8fc2a0190dad5135fAndrew Trick 1671dbe6d43dfac78d567973dac8fc2a0190dad5135fAndrew Trick 16723cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick// Find the processor's resource units for this kind of resource. 16733cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew TrickRecord *CodeGenSchedModels::findProcResUnits(Record *ProcResKind, 16743cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick const CodeGenProcModel &PM) const { 16753cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick if (ProcResKind->isSubClassOf("ProcResourceUnits")) 16763cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick return ProcResKind; 16773cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick 1678dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Record *ProcUnitDef = nullptr; 1679de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar assert(!ProcResourceDefs.empty()); 1680de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar assert(!ProcResGroups.empty()); 16813cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick 16823cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick for (RecIter RI = ProcResourceDefs.begin(), RE = ProcResourceDefs.end(); 16833cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick RI != RE; ++RI) { 16843cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick 16853cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick if ((*RI)->getValueAsDef("Kind") == ProcResKind 16863cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick && (*RI)->getValueAsDef("SchedModel") == PM.ModelDef) { 16873cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick if (ProcUnitDef) { 168861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError((*RI)->getLoc(), 168961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "Multiple ProcessorResourceUnits associated with " 169061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger + ProcResKind->getName()); 16913cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick } 16923cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick ProcUnitDef = *RI; 16933cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick } 16943cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick } 16951754aca83af1658c832706889c0e2933f8dfa8eeAndrew Trick for (RecIter RI = ProcResGroups.begin(), RE = ProcResGroups.end(); 16961754aca83af1658c832706889c0e2933f8dfa8eeAndrew Trick RI != RE; ++RI) { 16971754aca83af1658c832706889c0e2933f8dfa8eeAndrew Trick 16981754aca83af1658c832706889c0e2933f8dfa8eeAndrew Trick if (*RI == ProcResKind 16991754aca83af1658c832706889c0e2933f8dfa8eeAndrew Trick && (*RI)->getValueAsDef("SchedModel") == PM.ModelDef) { 17001754aca83af1658c832706889c0e2933f8dfa8eeAndrew Trick if (ProcUnitDef) { 17011754aca83af1658c832706889c0e2933f8dfa8eeAndrew Trick PrintFatalError((*RI)->getLoc(), 17021754aca83af1658c832706889c0e2933f8dfa8eeAndrew Trick "Multiple ProcessorResourceUnits associated with " 17031754aca83af1658c832706889c0e2933f8dfa8eeAndrew Trick + ProcResKind->getName()); 17041754aca83af1658c832706889c0e2933f8dfa8eeAndrew Trick } 17051754aca83af1658c832706889c0e2933f8dfa8eeAndrew Trick ProcUnitDef = *RI; 17061754aca83af1658c832706889c0e2933f8dfa8eeAndrew Trick } 17071754aca83af1658c832706889c0e2933f8dfa8eeAndrew Trick } 17083cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick if (!ProcUnitDef) { 170961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(ProcResKind->getLoc(), 171061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "No ProcessorResources associated with " 171161131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger + ProcResKind->getName()); 17123cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick } 17133cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick return ProcUnitDef; 17143cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick} 17153cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick 17163cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick// Iteratively add a resource and its super resources. 17173cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trickvoid CodeGenSchedModels::addProcResource(Record *ProcResKind, 17183cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick CodeGenProcModel &PM) { 17193cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick for (;;) { 17203cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick Record *ProcResUnits = findProcResUnits(ProcResKind, PM); 17213cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick 17223cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick // See if this ProcResource is already associated with this processor. 17233cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick RecIter I = std::find(PM.ProcResourceDefs.begin(), 17243cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick PM.ProcResourceDefs.end(), ProcResUnits); 17253cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick if (I != PM.ProcResourceDefs.end()) 17263cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick return; 17273cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick 17283cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick PM.ProcResourceDefs.push_back(ProcResUnits); 17291754aca83af1658c832706889c0e2933f8dfa8eeAndrew Trick if (ProcResUnits->isSubClassOf("ProcResGroup")) 17301754aca83af1658c832706889c0e2933f8dfa8eeAndrew Trick return; 17311754aca83af1658c832706889c0e2933f8dfa8eeAndrew Trick 17323cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick if (!ProcResUnits->getValueInit("Super")->isComplete()) 17333cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick return; 17343cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick 17353cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick ProcResKind = ProcResUnits->getValueAsDef("Super"); 17363cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick } 17373cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick} 17383cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick 17393cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick// Add resources for a SchedWrite to this processor if they don't exist. 17403cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trickvoid CodeGenSchedModels::addWriteRes(Record *ProcWriteResDef, unsigned PIdx) { 174192649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick assert(PIdx && "don't add resources to an invalid Processor model"); 174292649883119aaa8edd9ccf612eaaff5ccc8fcc77Andrew Trick 17433cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick RecVec &WRDefs = ProcModels[PIdx].WriteResDefs; 17443cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick RecIter WRI = std::find(WRDefs.begin(), WRDefs.end(), ProcWriteResDef); 17453cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick if (WRI != WRDefs.end()) 17463cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick return; 17473cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick WRDefs.push_back(ProcWriteResDef); 17483cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick 17493cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick // Visit ProcResourceKinds referenced by the newly discovered WriteRes. 17503cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick RecVec ProcResDefs = ProcWriteResDef->getValueAsListOfDefs("ProcResources"); 17513cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick for (RecIter WritePRI = ProcResDefs.begin(), WritePRE = ProcResDefs.end(); 17523cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick WritePRI != WritePRE; ++WritePRI) { 17533cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick addProcResource(*WritePRI, ProcModels[PIdx]); 17543cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick } 17553cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick} 17563cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick 17573cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick// Add resources for a ReadAdvance to this processor if they don't exist. 17583cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trickvoid CodeGenSchedModels::addReadAdvance(Record *ProcReadAdvanceDef, 17593cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick unsigned PIdx) { 17603cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick RecVec &RADefs = ProcModels[PIdx].ReadAdvanceDefs; 17613cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick RecIter I = std::find(RADefs.begin(), RADefs.end(), ProcReadAdvanceDef); 17623cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick if (I != RADefs.end()) 17633cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick return; 17643cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick RADefs.push_back(ProcReadAdvanceDef); 17653cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick} 17663cbd1786ac06fe751dc4b5ad55e75115cb1d51ceAndrew Trick 1767bc4ff6e3cf129294d10c2366cb157796964c903eAndrew Trickunsigned CodeGenProcModel::getProcResourceIdx(Record *PRDef) const { 1768bc4ff6e3cf129294d10c2366cb157796964c903eAndrew Trick RecIter PRPos = std::find(ProcResourceDefs.begin(), ProcResourceDefs.end(), 1769bc4ff6e3cf129294d10c2366cb157796964c903eAndrew Trick PRDef); 1770bc4ff6e3cf129294d10c2366cb157796964c903eAndrew Trick if (PRPos == ProcResourceDefs.end()) 177161131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(PRDef->getLoc(), "ProcResource def is not included in " 177261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "the ProcResources list for " + ModelName); 1773bc4ff6e3cf129294d10c2366cb157796964c903eAndrew Trick // Idx=0 is reserved for invalid. 1774322ff8834532915a4de0210a083672008d6499b6Rafael Espindola return 1 + (PRPos - ProcResourceDefs.begin()); 1775bc4ff6e3cf129294d10c2366cb157796964c903eAndrew Trick} 1776bc4ff6e3cf129294d10c2366cb157796964c903eAndrew Trick 1777de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainarbool CodeGenProcModel::isUnsupported(const CodeGenInstruction &Inst) const { 1778de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar for (const Record *TheDef : UnsupportedFeaturesDefs) { 1779de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar for (const Record *PredDef : Inst.TheDef->getValueAsListOfDefs("Predicates")) { 1780de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (TheDef->getName() == PredDef->getName()) 1781de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return true; 1782de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar } 1783de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar } 1784de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return false; 1785de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar} 1786de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 17872661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick#ifndef NDEBUG 178848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trickvoid CodeGenProcModel::dump() const { 178948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick dbgs() << Index << ": " << ModelName << " " 179048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick << (ModelDef ? ModelDef->getName() : "inferred") << " " 179148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick << (ItinsDef ? ItinsDef->getName() : "no itinerary") << '\n'; 179248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick} 179348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick 179448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trickvoid CodeGenSchedRW::dump() const { 179548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick dbgs() << Name << (IsVariadic ? " (V) " : " "); 179648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick if (IsSequence) { 179748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick dbgs() << "("; 179848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick dumpIdxVec(Sequence); 179948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick dbgs() << ")"; 18002661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick } 18012661b411ccc81b1fe19194d3f43b2630cbef3f28Andrew Trick} 180248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick 180348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trickvoid CodeGenSchedClass::dump(const CodeGenSchedModels* SchedModels) const { 18041ab961f6d3cdd284f5d6c696f3e26eb3627e2c8bAndrew Trick dbgs() << "SCHEDCLASS " << Index << ":" << Name << '\n' 180548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick << " Writes: "; 180648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick for (unsigned i = 0, N = Writes.size(); i < N; ++i) { 180748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick SchedModels->getSchedWrite(Writes[i]).dump(); 180848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick if (i < N-1) { 180948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick dbgs() << '\n'; 181048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick dbgs().indent(10); 181148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 181248605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 181348605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick dbgs() << "\n Reads: "; 181448605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick for (unsigned i = 0, N = Reads.size(); i < N; ++i) { 181548605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick SchedModels->getSchedRead(Reads[i]).dump(); 181648605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick if (i < N-1) { 181748605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick dbgs() << '\n'; 181848605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick dbgs().indent(10); 181948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 182048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick } 182148605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick dbgs() << "\n ProcIdx: "; dumpIdxVec(ProcIndices); dbgs() << '\n'; 182282e7c4f533a98a16b0cadd5209c1d3dc8ce33d87Andrew Trick if (!Transitions.empty()) { 182382e7c4f533a98a16b0cadd5209c1d3dc8ce33d87Andrew Trick dbgs() << "\n Transitions for Proc "; 182482e7c4f533a98a16b0cadd5209c1d3dc8ce33d87Andrew Trick for (std::vector<CodeGenSchedTransition>::const_iterator 182582e7c4f533a98a16b0cadd5209c1d3dc8ce33d87Andrew Trick TI = Transitions.begin(), TE = Transitions.end(); TI != TE; ++TI) { 182682e7c4f533a98a16b0cadd5209c1d3dc8ce33d87Andrew Trick dumpIdxVec(TI->ProcIndices); 182782e7c4f533a98a16b0cadd5209c1d3dc8ce33d87Andrew Trick } 182882e7c4f533a98a16b0cadd5209c1d3dc8ce33d87Andrew Trick } 182948605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick} 18305e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick 18315e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trickvoid PredTransitions::dump() const { 18325e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick dbgs() << "Expanded Variants:\n"; 18335e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick for (std::vector<PredTransition>::const_iterator 18345e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick TI = TransVec.begin(), TE = TransVec.end(); TI != TE; ++TI) { 18355e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick dbgs() << "{"; 18365e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick for (SmallVectorImpl<PredCheck>::const_iterator 18375e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick PCI = TI->PredTerm.begin(), PCE = TI->PredTerm.end(); 18385e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick PCI != PCE; ++PCI) { 18395e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick if (PCI != TI->PredTerm.begin()) 18405e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick dbgs() << ", "; 18415e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick dbgs() << SchedModels.getSchedRW(PCI->RWIdx, PCI->IsRead).Name 18425e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick << ":" << PCI->Predicate->getName(); 18435e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 18445e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick dbgs() << "},\n => {"; 18455e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick for (SmallVectorImpl<SmallVector<unsigned,4> >::const_iterator 18465e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick WSI = TI->WriteSequences.begin(), WSE = TI->WriteSequences.end(); 18475e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick WSI != WSE; ++WSI) { 18485e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick dbgs() << "("; 18495e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick for (SmallVectorImpl<unsigned>::const_iterator 18505e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick WI = WSI->begin(), WE = WSI->end(); WI != WE; ++WI) { 18515e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick if (WI != WSI->begin()) 18525e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick dbgs() << ", "; 18535e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick dbgs() << SchedModels.getSchedWrite(*WI).Name; 18545e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 18555e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick dbgs() << "),"; 18565e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 18575e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick dbgs() << "}\n"; 18585e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick } 18595e613c260bb3044eb059dea74cd6bccfa9b85bddAndrew Trick} 186048605c340614fc1fb2ae1d975fc565a4188182e0Andrew Trick#endif // NDEBUG 1861