SIL optimizer: add the ability to disable swift instruction passes with the -sil-disable-pass option.

Author: eeckstein

include/swift/SILOptimizer/PassManager/PassManager.h

@@ -352,6 +352,9 @@ class SILPassManager {
 
   void executePassPipelinePlan(const SILPassPipelinePlan &Plan);
 
+  static bool isPassDisabled(StringRef passName);
+  static bool disablePassesForFunction(SILFunction *function);
+
 private:
   void execute();
 

lib/SILOptimizer/PassManager/PassManager.cpp

@@ -224,21 +224,6 @@ static bool doPrintAfter(SILTransform *T, SILFunction *F, bool PassChangedSIL) {
   return PassChangedSIL && (SILPrintAll || !functionSelectionEmpty());
 }
 
-static bool isDisabled(SILTransform *T, SILFunction *F = nullptr) {
-  if (!SILDisablePassOnlyFun.empty() && F &&
-      SILDisablePassOnlyFun.end() == std::find(SILDisablePassOnlyFun.begin(),
-                                               SILDisablePassOnlyFun.end(),
-                                               F->getName()))
-    return false;
-
-  for (const std::string &NamePattern : SILDisablePass) {
-    if (T->getTag().contains(NamePattern) || T->getID().contains(NamePattern)) {
-      return true;
-    }
-  }
-  return false;
-}
-
 static void printModule(SILModule *Mod, bool EmitVerboseSIL) {
   if (functionSelectionEmpty()) {
     Mod->dump();
@@ -401,6 +386,35 @@ bool SILPassManager::isMandatoryFunctionPass(SILFunctionTransform *sft) {
          sft->getPassKind() == PassKind::OwnershipModelEliminator;
 }
 
+static bool isDisabled(SILTransform *T, SILFunction *F = nullptr) {
+  if (SILDisablePass.empty())
+    return false;
+
+  if (SILPassManager::isPassDisabled(T->getTag()) ||
+      SILPassManager::isPassDisabled(T->getID())) {
+    if (F && !SILPassManager::disablePassesForFunction(F))
+      return false;
+    return true;
+  }
+  return false;
+}
+
+bool SILPassManager::isPassDisabled(StringRef passName) {
+  for (const std::string &namePattern : SILDisablePass) {
+    if (passName.contains(namePattern))
+      return true;
+  }
+  return false;
+}
+
+bool SILPassManager::disablePassesForFunction(SILFunction *function) {
+  if (SILDisablePassOnlyFun.empty())
+    return true;
+
+  return std::find(SILDisablePassOnlyFun.begin(), SILDisablePassOnlyFun.end(),
+                   function->getName()) != SILDisablePassOnlyFun.end();
+}
+
 void SILPassManager::runPassOnFunction(unsigned TransIdx, SILFunction *F) {
 
   assert(analysesUnlocked() && "Expected all analyses to be unlocked!");

lib/SILOptimizer/SILCombiner/SILCombine.cpp

@@ -491,17 +491,23 @@ void SILCombine_registerInstructionPass(BridgedStringRef name,
 SILInstruction *SILCombiner::visit##INST(INST *inst) {                     \
   static BridgedInstructionPassRunFn runFunction = nullptr;                \
   static bool runFunctionSet = false;                                      \
+  static bool passDisabled = false;                                        \
   if (!runFunctionSet) {                                                   \
     runFunction = swiftInstPasses[TAG];                                    \
     if (!runFunction && passesRegistered) {                                \
       llvm::errs() << "Swift pass " << TAG << " is not registered\n";      \
       abort();                                                             \
     }                                                                      \
+    passDisabled = SILPassManager::isPassDisabled(TAG);                    \
     runFunctionSet = true;                                                 \
   }                                                                        \
   if (!runFunction) {                                                      \
     LEGACY_RUN;                                                            \
   }                                                                        \
+  if (passDisabled &&                                                      \
+      SILPassManager::disablePassesForFunction(inst->getFunction())) {     \
+    return nullptr;                                                        \
+  }                                                                        \
   runSwiftInstructionPass(inst, runFunction);                              \
   return nullptr;                                                          \
 }                                                                          \

test/SILOptimizer/disable_pass_flags.sil

@@ -0,0 +1,24 @@
+// RUN: %target-sil-opt -sil-combine %s | %FileCheck %s --check-prefix=CHECK_ENABLED
+// RUN: %target-sil-opt -sil-combine %s -sil-disable-pass=SILCombine | %FileCheck %s --check-prefix=CHECK_DISABLED
+// RUN: %target-sil-opt -sil-combine %s -sil-disable-pass=SILCombine -sil-disable-pass-only-function=test | %FileCheck %s --check-prefix=CHECK_DISABLED
+// RUN: %target-sil-opt -sil-combine %s -sil-disable-pass=SILCombine -sil-disable-pass-only-function=other | %FileCheck %s --check-prefix=CHECK_ENABLED
+// RUN: %target-sil-opt -sil-combine %s -sil-disable-pass=simplify-begin_cow_mutation | %FileCheck %s --check-prefix=CHECK_DISABLED
+// RUN: %target-sil-opt -sil-combine %s -sil-disable-pass=simplify-begin_cow_mutation -sil-disable-pass-only-function=test | %FileCheck %s --check-prefix=CHECK_DISABLED
+// RUN: %target-sil-opt -sil-combine %s -sil-disable-pass=simplify-begin_cow_mutation -sil-disable-pass-only-function=other | %FileCheck %s --check-prefix=CHECK_ENABLED
+
+// REQUIRES: swift_in_compiler
+
+import Builtin
+
+class Buffer {}
+
+// CHECK_ENABLED-NOT: begin_cow_mutation
+// CHECK_ENABLED-NOT: end_cow_mutation
+// CHECK_DISABLED: begin_cow_mutation
+// CHECK_DISABLED: end_cow_mutation
+sil [ossa] @test : $@convention(thin) (@owned Buffer) -> @owned Buffer {
+bb0(%0 : @owned $Buffer):
+  (%u, %b) = begin_cow_mutation %0 : $Buffer
+  %e = end_cow_mutation %b : $Buffer
+  return %e : $Buffer
+}