Revert "Simplify the pass manager execution logic."

This reverts commit 9d4d3c8.

I forgot to finish up changes required to make -Xllvm
-sil-opt-pass-count continue working the way it did, so I'll back that
out until I have those changes as well.

Author: rudkx

lib/SILOptimizer/PassManager/PassManager.cpp

@@ -330,40 +330,45 @@ void SILPassManager::runOneIteration() {
   NumOptimizationIterations++;
   SmallVector<SILFunctionTransform*, 16> PendingFuncTransforms;
 
-  auto KeepTransforming = [&]() {
-    return Mod->getStage() == SILStage::Raw ||
-           NumPassesRun < SILNumOptPassesToRun;
-  };
-
-  // Run the transforms by alternating between function transforms and
-  // module transforms. We'll queue up all the function transforms
-  // that we see in a row and then run the entire group of transforms
-  // on each function in turn. Then we move on to running the next set
-  // of consequtive module transforms.
-  auto It = Transformations.begin();
-  auto End = Transformations.end();
-
-  while (It != End && KeepTransforming()) {
-    assert((isa<SILFunctionTransform>(*It) || isa<SILModuleTransform>(*It)) &&
-           "Unexpected pass kind!");
+  // For each transformation:
+  for (SILTransform *ST : Transformations) {
+    // Bail out if we've hit the optimization pass limit.
+    if (Mod->getStage() == SILStage::Canonical
+        && NumPassesRun >= SILNumOptPassesToRun)
+      return;
+
+    // Run module transformations on the module.
+    if (SILModuleTransform *SMT = llvm::dyn_cast<SILModuleTransform>(ST)) {
+      // Run all function passes that we've seen since the last module pass.
+      // Stop stop this optimization phase if one of the passes requested to
+      // stop.
+      bool NeedToStop = runFunctionPasses(PendingFuncTransforms);
+      if (NeedToStop)
+        return;
+
+      PendingFuncTransforms.clear();
+
+      runModulePass(SMT);
 
-    while (It != End && isa<SILFunctionTransform>(*It) && KeepTransforming()) {
-      PendingFuncTransforms.push_back(cast<SILFunctionTransform>(*It));
-
-      ++It;
       ++NumPassesRun;
+      if (Mod->getStage() == SILStage::Canonical
+          && NumPassesRun >= SILNumOptPassesToRun) {
+        return;
+      }
+      
+      continue;
     }
 
-    runFunctionPasses(PendingFuncTransforms);
-    PendingFuncTransforms.clear();
-
-    while (It != End && isa<SILModuleTransform>(*It) && KeepTransforming()) {
-      runModulePass(cast<SILModuleTransform>(*It));
-
-      ++It;
-      ++NumPassesRun;
+    // Run function transformation on all functions.
+    if (SILFunctionTransform *SFT = llvm::dyn_cast<SILFunctionTransform>(ST)) {
+      PendingFuncTransforms.push_back(SFT);      
+      continue;
     }
+
+    llvm_unreachable("Unknown pass kind.");
   }
+
+  runFunctionPasses(PendingFuncTransforms);
 }
 
 void SILPassManager::run() {