[TablgeGen] : Tidy up CodeGenSchedule. NFC.

[javed.absar]

Summary

Hi Matthias :

I am not sure if your permission for 'no-review needed for NFC/range changes etc' extended to TableGen. If so, I wont bother you with similar tablegen reviews in the future.

[MatzeB]

Sure feel free to also make such changes in tablegen without review. LGTM

utils/TableGen/CodeGenSchedule.cpp

588

Use a const reference here to avoid unnecessary copying.

[kparzysz]

utils/TableGen/CodeGenSchedule.cpp

589

make_range is unnecessary for objects that have "begin" and "end".

695

Same here.

998

And here.

1018

And here.

1507

And here.

utils/TableGen/CodeGenSchedule.cpp

 // before implementing the optimization.
 struct InstRegexOp : public SetTheory::Operator {
   const CodeGenTarget &Target;
   InstRegexOp(const CodeGenTarget &t): Target(t) {}
 
   void apply(SetTheory &ST, DagInit *Expr, SetTheory::RecSet &Elts,
              ArrayRef<SMLoc> Loc) override {
     SmallVector<Regex, 4> RegexList;
-    for (DagInit::const_arg_iterator
-           AI = Expr->arg_begin(), AE = Expr->arg_end(); AI != AE; ++AI) {
-      StringInit *SI = dyn_cast<StringInit>(*AI);
+    for (Init *Arg : make_range(Expr->arg_begin(), Expr->arg_end())) {
+      StringInit *SI = dyn_cast<StringInit>(Arg);
       if (!SI)
         PrintFatalError(Loc, "instregex requires pattern string: "
           + Expr->getAsString());
       std::string pat = SI->getValue();
       // Implement a python-style prefix match.
       if (pat[0] != '^') {
         pat.insert(0, "^(");
         pat.insert(pat.end(), ')');
for (Record *RWDef : RWDefs) {
       for (unsigned WIdx : Writes)
         dbgs() << " " << SchedWrites[WIdx].Name;
       for (unsigned RIdx : Reads)
         dbgs() << " " << SchedReads[RIdx].Name;
       dbgs() << '\n';
     }
     // If ProcIndices contains zero, the class applies to all processors.
     if (!std::count(ProcIndices.begin(), ProcIndices.end(), 0)) {
-      for (std::vector<CodeGenProcModel>::iterator PI = ProcModels.begin(),
-             PE = ProcModels.end(); PI != PE; ++PI) {
-        if (!std::count(ProcIndices.begin(), ProcIndices.end(), PI->Index))
+      for (CodeGenProcModel PM :
+           make_range(ProcModels.begin(), ProcModels.end())) {
+        if (!std::count(ProcIndices.begin(), ProcIndices.end(), PM.Index))
           dbgs() << "No machine model for " << Inst->TheDef->getName()
-                 << " on processor " << PI->ModelName << '\n';
+                 << " on processor " << PM.ModelName << '\n';
       }
     }
   }
 }
 
 /// Find an SchedClass that has been inferred from a per-operand list of
 /// SchedWrites and SchedReads.
 unsigned CodeGenSchedModels::findSchedClassIdx(Record *ItinClassDef,
void CodeGenSchedModels::createInstRWClass(Record *InstRWDef) {
   // not intersect with an existing class refer back to their former class as
   // determined from ItinDef or SchedRW.
   SmallVector<std::pair<unsigned, SmallVector<Record *, 8>>, 4> ClassInstrs;
   // Sort Instrs into sets.
   const RecVec *InstDefs = Sets.expand(InstRWDef);
   if (InstDefs->empty())
     PrintFatalError(InstRWDef->getLoc(), "No matching instruction opcodes");
 
-  for (RecIter I = InstDefs->begin(), E = InstDefs->end(); I != E; ++I) {
-    InstClassMapTy::const_iterator Pos = InstrClassMap.find(*I);
+  for (Record *InstDef : make_range(InstDefs->begin(), InstDefs->end())) {
+    InstClassMapTy::const_iterator Pos = InstrClassMap.find(InstDef);
     if (Pos == InstrClassMap.end())
-      PrintFatalError((*I)->getLoc(), "No sched class for instruction.");
+      PrintFatalError(InstDef->getLoc(), "No sched class for instruction.");
     unsigned SCIdx = Pos->second;
     unsigned CIdx = 0, CEnd = ClassInstrs.size();
     for (; CIdx != CEnd; ++CIdx) {
       if (ClassInstrs[CIdx].first == SCIdx)
         break;
     }
     if (CIdx == CEnd) {
       ClassInstrs.resize(CEnd + 1);
       ClassInstrs[CIdx].first = SCIdx;
     }
-    ClassInstrs[CIdx].second.push_back(*I);
+    ClassInstrs[CIdx].second.push_back(InstDef);
   }
   // For each set of Instrs, create a new class if necessary, and map or remap
   // the Instrs to it.
   unsigned CIdx = 0, CEnd = ClassInstrs.size();
   for (; CIdx != CEnd; ++CIdx) {
     unsigned OldSCIdx = ClassInstrs[CIdx].first;
     ArrayRef<Record*> InstDefs = ClassInstrs[CIdx].second;
     // If the all instrs in the current class are accounted for, then leave
for (CodeGenProcModel &ProcModel : ProcModels) {
     RecVec ItinRecords = ProcModel.ItinsDef->getValueAsListOfDefs("IID");
     assert(!ItinRecords.empty() && "ProcModel.hasItineraries is incorrect");
 
     // Populate ItinDefList with Itinerary records.
     ProcModel.ItinDefList.resize(NumInstrSchedClasses);
 
     // Insert each itinerary data record in the correct position within
     // the processor model's ItinDefList.
-    for (unsigned i = 0, N = ItinRecords.size(); i < N; i++) {
-      Record *ItinData = ItinRecords[i];
+    for (Record *ItinData : ItinRecords) {
       Record *ItinDef = ItinData->getValueAsDef("TheClass");
       bool FoundClass = false;
       for (SchedClassIter SCI = schedClassBegin(), SCE = schedClassEnd();
            SCI != SCE; ++SCI) {
         // Multiple SchedClasses may share an itinerary. Update all of them.
         if (SCI->ItinClassDef == ItinDef) {
           ProcModel.ItinDefList[SCI->Index] = ItinData;
           FoundClass = true;

 //
 // All predicates associated with a given SchedRW are considered mutually
 // exclusive. This should work even if the conditions expressed by the
 // predicates are not exclusive because the predicates for a given SchedWrite
 // are always checked in the order they are defined in the .td file. Later
 // conditions implicitly negate any prior condition.
 bool PredTransitions::mutuallyExclusive(Record *PredDef,
                                         ArrayRef<PredCheck> Term) {
-  for (ArrayRef<PredCheck>::iterator I = Term.begin(), E = Term.end();
-       I != E; ++I) {
-    if (I->Predicate == PredDef)
+  for (const PredCheck &PC: make_range(Term.begin(), Term.end())) {
+    if (PC.Predicate == PredDef)
       return false;
 
-    const CodeGenSchedRW &SchedRW = SchedModels.getSchedRW(I->RWIdx, I->IsRead);
+    const CodeGenSchedRW &SchedRW = SchedModels.getSchedRW(PC.RWIdx, PC.IsRead);
     assert(SchedRW.HasVariants && "PredCheck must refer to a SchedVariant");
     RecVec Variants = SchedRW.TheDef->getValueAsListOfDefs("Variants");
     for (RecIter VI = Variants.begin(), VE = Variants.end(); VI != VE; ++VI) {
       if ((*VI)->getValueAsDef("Predicate") == PredDef)
         return true;
     }
   }
   return false;
 }
 
 static bool hasAliasedVariants(const CodeGenSchedRW &RW,
                                CodeGenSchedModels &SchedModels) {
   if (RW.HasVariants)
     return true;
 
-  for (RecIter I = RW.Aliases.begin(), E = RW.Aliases.end(); I != E; ++I) {
+  for (Record *Alias : make_range(RW.Aliases.begin(), RW.Aliases.end())) {
     const CodeGenSchedRW &AliasRW =
-      SchedModels.getSchedRW((*I)->getValueAsDef("AliasRW"));
+      SchedModels.getSchedRW(Alias->getValueAsDef("AliasRW"));
     if (AliasRW.HasVariants)
       return true;
     if (AliasRW.IsSequence) {
       IdxVec ExpandedRWs;
       SchedModels.expandRWSequence(AliasRW.Index, ExpandedRWs, AliasRW.IsRead);
       for (IdxIter SI = ExpandedRWs.begin(), SE = ExpandedRWs.end();
            SI != SE; ++SI) {
         if (hasAliasedVariants(SchedModels.getSchedRW(*SI, AliasRW.IsRead),
for (RecIter RAI = SRADefs.begin(), RAE = SRADefs.end(); RAI != RAE; ++RAI) {
     if ((*RAI)->getValueInit("SchedModel")->isComplete()) {
       Record *ModelDef = (*RAI)->getValueAsDef("SchedModel");
       addReadAdvance(*RAI, getProcModel(ModelDef).Index);
     }
   }
   // Add ProcResGroups that are defined within this processor model, which may
   // not be directly referenced but may directly specify a buffer size.
   RecVec ProcResGroups = Records.getAllDerivedDefinitions("ProcResGroup");
-  for (RecIter RI = ProcResGroups.begin(), RE = ProcResGroups.end();
-       RI != RE; ++RI) {
-    if (!(*RI)->getValueInit("SchedModel")->isComplete())
-      continue;
-    CodeGenProcModel &PM = getProcModel((*RI)->getValueAsDef("SchedModel"));
-    if (!is_contained(PM.ProcResourceDefs, *RI))
-      PM.ProcResourceDefs.push_back(*RI);
+  for (Record *PRG : make_range(ProcResGroups.begin(), ProcResGroups.end())) {
+    if (!PRG->getValueInit("SchedModel")->isComplete())
+      continue;
+    CodeGenProcModel &PM = getProcModel(PRG->getValueAsDef("SchedModel"));
+    if (!is_contained(PM.ProcResourceDefs, PRG))
+      PM.ProcResourceDefs.push_back(PRG);
   }
   // Finalize each ProcModel by sorting the record arrays.
   for (CodeGenProcModel &PM : ProcModels) {
     std::sort(PM.WriteResDefs.begin(), PM.WriteResDefs.end(),
               LessRecord());
     std::sort(PM.ReadAdvanceDefs.begin(), PM.ReadAdvanceDefs.end(),
               LessRecord());
     std::sort(PM.ProcResourceDefs.begin(), PM.ProcResourceDefs.end(),