Add an option -sil-break-before-pass-count to break before running a pass when in the debugger

We often look at the SIL output of -sil-print-function and may want to debug a specific pass
after looking at the output.

-sil-break-before-pass-count=<pass_number> will allow to automatically break in the debugger
after <pass_count> of passes are run.

Example:
From -sil-print-function dump:
"SIL function after  swiftlang#6680, stage MidLevel,Function, pass 38: RedundantLoadElimination"

-Xllvm -sil-break-before-pass-count=6680 will break before running this pass in the debugger

Author: meg-gupta

include/swift/SILOptimizer/PassManager/PassManager.h

@@ -215,6 +215,7 @@ class SILPassManager {
 
   unsigned maxNumPassesToRun = UINT_MAX;
   unsigned maxNumSubpassesToRun = UINT_MAX;
+  unsigned breakBeforePassCount = UINT_MAX;
 
   /// For invoking Swift passes.
   SwiftPassInvocation swiftPassInvocation;
@@ -428,7 +429,8 @@ class SILPassManager {
   void runSwiftModuleVerification();
 
 private:
-  void parsePassCount(StringRef countsStr);
+  void parsePassesToRunCount(StringRef countsStr);
+  void parseBreakBeforePassCount(StringRef countsStr);
 
   bool doPrintBefore(SILTransform *T, SILFunction *F);
 
@@ -461,6 +463,9 @@ class SILPassManager {
   /// options) whether we should continue running passes.
   bool continueTransforming();
 
+  /// Break before running a pass.
+  bool breakBeforeRunning(StringRef fnName, SILFunctionTransform *SFT);
+
   /// Return true if all analyses are unlocked.
   bool analysesUnlocked();
 

lib/SILOptimizer/PassManager/PassManager.cpp

@@ -96,6 +96,10 @@ llvm::cl::opt<std::string> SILBreakOnPass(
     "sil-break-on-pass", llvm::cl::init(""),
     llvm::cl::desc("Break before running a particular function pass"));
 
+llvm::cl::opt<std::string>
+    SILBreakBeforePassCount("sil-break-before-pass-count", llvm::cl::init(""),
+                            llvm::cl::desc("Break before running pass number"));
+
 llvm::cl::list<std::string>
     SILPrintFunction("sil-print-function", llvm::cl::CommaSeparated,
                     llvm::cl::desc("Only print out the sil for this function"));
@@ -403,7 +407,7 @@ SILPassManager::SILPassManager(SILModule *M, bool isMandatory,
 #include "swift/SILOptimizer/Analysis/Analysis.def"
 
   if (!SILNumOptPassesToRun.empty()) {
-    parsePassCount(SILNumOptPassesToRun);
+    parsePassesToRunCount(SILNumOptPassesToRun);
   } else if (!SILPassCountConfigFile.empty()) {
     StringRef moduleName = M->getSwiftModule()->getName().str();
     std::fstream fs(SILPassCountConfigFile);
@@ -417,13 +421,17 @@ SILPassManager::SILPassManager(SILModule *M, bool isMandatory,
       StringRef modName = pair.first;
       StringRef countsStr = pair.second;
       if (modName == moduleName) {
-        parsePassCount(countsStr);
+        parsePassesToRunCount(countsStr);
         break;
       }
     }
     fs.close();
   }
 
+  if (!SILBreakBeforePassCount.empty()) {
+    parseBreakBeforePassCount(SILBreakBeforePassCount);
+  }
+
   for (SILAnalysis *A : Analyses) {
     A->initialize(this);
   }
@@ -434,7 +442,7 @@ SILPassManager::SILPassManager(SILModule *M, bool isMandatory,
   M->registerDeserializationNotificationHandler(std::move(handler));
 }
 
-void SILPassManager::parsePassCount(StringRef countsStr) {
+void SILPassManager::parsePassesToRunCount(StringRef countsStr) {
   bool validFormat = true;
   if (countsStr.consumeInteger(10, maxNumPassesToRun))
     validFormat = false;
@@ -449,6 +457,17 @@ void SILPassManager::parsePassCount(StringRef countsStr) {
   }
 }
 
+void SILPassManager::parseBreakBeforePassCount(StringRef countsStr) {
+  bool validFormat = true;
+  if (countsStr.consumeInteger(10, breakBeforePassCount))
+    validFormat = false;
+  if (!validFormat || !countsStr.empty()) {
+    llvm::errs()
+        << "error: wrong format of -sil-break-before-pass-count option\n";
+    exit(1);
+  }
+}
+
 bool SILPassManager::continueTransforming() {
   if (isMandatory)
     return true;
@@ -486,19 +505,24 @@ bool SILPassManager::analysesUnlocked() {
 // Test the function and pass names we're given against the debug
 // options that force us to break prior to a given pass and/or on a
 // given function.
-static bool breakBeforeRunning(StringRef fnName, SILFunctionTransform *SFT) {
-  if (SILBreakOnFun.empty() && SILBreakOnPass.empty())
+bool SILPassManager::breakBeforeRunning(StringRef fnName,
+                                        SILFunctionTransform *SFT) {
+  if (SILBreakOnFun.empty() && SILBreakOnPass.empty() &&
+      SILBreakBeforePassCount.empty())
     return false;
 
-  if (SILBreakOnFun.empty()
-      && (SFT->getID() == SILBreakOnPass || SFT->getTag() == SILBreakOnPass))
+  if (!SILBreakOnPass.empty() &&
+      (SFT->getID() == SILBreakOnPass || SFT->getTag() == SILBreakOnPass))
     return true;
 
-  if (SILBreakOnPass.empty() && fnName == SILBreakOnFun)
+  if (!SILBreakOnFun.empty() && fnName == SILBreakOnFun)
     return true;
 
-  return fnName == SILBreakOnFun
-    && (SFT->getID() == SILBreakOnPass || SFT->getTag() == SILBreakOnPass);
+  if (!SILBreakBeforePassCount.empty() &&
+      breakBeforePassCount == NumPassesRun) {
+    return true;
+  }
+  return false;
 }
 
 void SILPassManager::dumpPassInfo(const char *Title, SILTransform *Tr,