AMDGPU/SI: Use range loops to simplify some code in the SI Scheduler

[axeldavy]

Looks good to me.

llvm/trunk/lib/Target/AMDGPU/SIMachineScheduler.cpp

void SIScheduleBlockCreator::colorComputeReservedDependencies() {
   CurrentBottomUpReservedDependencyColoring.clear();
 
   CurrentTopDownReservedDependencyColoring.resize(DAGSize, 0);
   CurrentBottomUpReservedDependencyColoring.resize(DAGSize, 0);
 
   // Traverse TopDown, and give different colors to SUs depending
   // on which combination of High Latencies they depend on.
 
-  for (unsigned i = 0, e = DAGSize; i != e; ++i) {
-    SUnit *SU = &DAG->SUnits[DAG->TopDownIndex2SU[i]];
+  for (unsigned SUNum : DAG->TopDownIndex2SU) {
+    SUnit *SU = &DAG->SUnits[SUNum];
     std::set<unsigned> SUColors;
 
     // Already given.
     if (CurrentColoring[SU->NodeNum]) {
       CurrentTopDownReservedDependencyColoring[SU->NodeNum] =
         CurrentColoring[SU->NodeNum];
       continue;
     }
else {
       }
     }
   }
 
   ColorCombinations.clear();
 
   // Same as before, but BottomUp.
 
-  for (unsigned i = 0, e = DAGSize; i != e; ++i) {
-    SUnit *SU = &DAG->SUnits[DAG->BottomUpIndex2SU[i]];
+  for (unsigned SUNum : DAG->BottomUpIndex2SU) {
+    SUnit *SU = &DAG->SUnits[SUNum];
     std::set<unsigned> SUColors;
 
     // Already given.
     if (CurrentColoring[SU->NodeNum]) {
       CurrentBottomUpReservedDependencyColoring[SU->NodeNum] =
         CurrentColoring[SU->NodeNum];
       continue;
     }
for (unsigned i = 0, e = DAGSize; i != e; ++i) {
     }
   }
 }
 
 void SIScheduleBlockCreator::colorEndsAccordingToDependencies() {
   unsigned DAGSize = DAG->SUnits.size();
   std::vector<int> PendingColoring = CurrentColoring;
 
-  for (unsigned i = 0, e = DAGSize; i != e; ++i) {
-    SUnit *SU = &DAG->SUnits[DAG->BottomUpIndex2SU[i]];
+  for (unsigned SUNum : DAG->BottomUpIndex2SU) {
+    SUnit *SU = &DAG->SUnits[SUNum];
     std::set<unsigned> SUColors;
     std::set<unsigned> SUColorsPending;
 
     if (CurrentColoring[SU->NodeNum] <= (int)DAGSize)
       continue;
 
     if (CurrentBottomUpReservedDependencyColoring[SU->NodeNum] > 0 ||
         CurrentTopDownReservedDependencyColoring[SU->NodeNum] > 0)
for (unsigned i = 1, e = DAGSize; i != e; ++i) {
     else
       CurrentColoring[i] = CurrentColoring[i-1];
   }
 }
 
 void SIScheduleBlockCreator::colorMergeConstantLoadsNextGroup() {
   unsigned DAGSize = DAG->SUnits.size();
 
-  for (unsigned i = 0, e = DAGSize; i != e; ++i) {
-    SUnit *SU = &DAG->SUnits[DAG->BottomUpIndex2SU[i]];
+  for (unsigned SUNum : DAG->BottomUpIndex2SU) {
+    SUnit *SU = &DAG->SUnits[SUNum];
     std::set<unsigned> SUColors;
 
     if (CurrentColoring[SU->NodeNum] <= (int)DAGSize)
       continue;
 
     // No predecessor: Vgpr constant loading.
     // Low latency instructions usually have a predecessor (the address)
     if (SU->Preds.size() > 0 && !DAG->IsLowLatencySU[SU->NodeNum])
       continue;
 
     for (SDep& SuccDep : SU->Succs) {
       SUnit *Succ = SuccDep.getSUnit();
       if (SuccDep.isWeak() || Succ->NodeNum >= DAGSize)
         continue;
       SUColors.insert(CurrentColoring[Succ->NodeNum]);
     }
     if (SUColors.size() == 1)
       CurrentColoring[SU->NodeNum] = *SUColors.begin();
   }
 }
 
 void SIScheduleBlockCreator::colorMergeIfPossibleNextGroup() {
   unsigned DAGSize = DAG->SUnits.size();
 
-  for (unsigned i = 0, e = DAGSize; i != e; ++i) {
-    SUnit *SU = &DAG->SUnits[DAG->BottomUpIndex2SU[i]];
+  for (unsigned SUNum : DAG->BottomUpIndex2SU) {
+    SUnit *SU = &DAG->SUnits[SUNum];
     std::set<unsigned> SUColors;
 
     if (CurrentColoring[SU->NodeNum] <= (int)DAGSize)
       continue;
 
     for (SDep& SuccDep : SU->Succs) {
        SUnit *Succ = SuccDep.getSUnit();
       if (SuccDep.isWeak() || Succ->NodeNum >= DAGSize)
         continue;
       SUColors.insert(CurrentColoring[Succ->NodeNum]);
     }
     if (SUColors.size() == 1)
       CurrentColoring[SU->NodeNum] = *SUColors.begin();
   }
 }
 
 void SIScheduleBlockCreator::colorMergeIfPossibleNextGroupOnlyForReserved() {
   unsigned DAGSize = DAG->SUnits.size();
 
-  for (unsigned i = 0, e = DAGSize; i != e; ++i) {
-    SUnit *SU = &DAG->SUnits[DAG->BottomUpIndex2SU[i]];
+  for (unsigned SUNum : DAG->BottomUpIndex2SU) {
+    SUnit *SU = &DAG->SUnits[SUNum];
     std::set<unsigned> SUColors;
 
     if (CurrentColoring[SU->NodeNum] <= (int)DAGSize)
       continue;
 
     for (SDep& SuccDep : SU->Succs) {
        SUnit *Succ = SuccDep.getSUnit();
       if (SuccDep.isWeak() || Succ->NodeNum >= DAGSize)
         continue;
       SUColors.insert(CurrentColoring[Succ->NodeNum]);
     }
     if (SUColors.size() == 1 && *SUColors.begin() <= DAGSize)
       CurrentColoring[SU->NodeNum] = *SUColors.begin();
   }
 }
 
 void SIScheduleBlockCreator::colorMergeIfPossibleSmallGroupsToNextGroup() {
   unsigned DAGSize = DAG->SUnits.size();
   std::map<unsigned, unsigned> ColorCount;
 
-  for (unsigned i = 0, e = DAGSize; i != e; ++i) {
-    SUnit *SU = &DAG->SUnits[DAG->BottomUpIndex2SU[i]];
+  for (unsigned SUNum : DAG->BottomUpIndex2SU) {
+    SUnit *SU = &DAG->SUnits[SUNum];
     unsigned color = CurrentColoring[SU->NodeNum];
     std::map<unsigned, unsigned>::iterator Pos = ColorCount.find(color);
       if (Pos != ColorCount.end()) {
         ++ColorCount[color];
       } else {
         ColorCount[color] = 1;
       }
   }
 
-  for (unsigned i = 0, e = DAGSize; i != e; ++i) {
-    SUnit *SU = &DAG->SUnits[DAG->BottomUpIndex2SU[i]];
+  for (unsigned SUNum : DAG->BottomUpIndex2SU) {
+    SUnit *SU = &DAG->SUnits[SUNum];
     unsigned color = CurrentColoring[SU->NodeNum];
     std::set<unsigned> SUColors;
 
     if (CurrentColoring[SU->NodeNum] <= (int)DAGSize)
       continue;
 
     if (ColorCount[color] > 1)
       continue;

 void SIScheduleBlockCreator::cutHugeBlocks() {
   // TODO
 }
 
 void SIScheduleBlockCreator::regroupNoUserInstructions() {
   unsigned DAGSize = DAG->SUnits.size();
   int GroupID = NextNonReservedID++;
 
-  for (unsigned i = 0, e = DAGSize; i != e; ++i) {
-    SUnit *SU = &DAG->SUnits[DAG->BottomUpIndex2SU[i]];
+  for (unsigned SUNum : DAG->BottomUpIndex2SU) {
+    SUnit *SU = &DAG->SUnits[SUNum];
     bool hasSuccessor = false;
 
     if (CurrentColoring[SU->NodeNum] <= (int)DAGSize)
       continue;
 
     for (SDep& SuccDep : SU->Succs) {
        SUnit *Succ = SuccDep.getSUnit();
       if (SuccDep.isWeak() || Succ->NodeNum >= DAGSize)