PassManager: infrastructure to disable or enable a specific instruction simplification

* for testing: add the option `-simplify-instruction=<instruction-name>` to only run simplification passes for that instruction type
* on the swift side, add `Options.enableSimplification`

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/PassManager/Options.swift

@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+import SIL
 import OptimizerBridging
 
 struct Options {
@@ -22,4 +23,8 @@ struct Options {
   var enableMoveInoutStackProtection: Bool {
     SILOptions_enableMoveInoutStackProtection(_bridged) != 0
   }
+
+  func enableSimplification(for inst: Instruction) -> Bool {
+    SILOptions_enableSimplificationFor(inst.bridged)
+  }
 }

include/swift/SILOptimizer/OptimizerBridging.h

@@ -204,6 +204,7 @@ PassContext_loadFunction(BridgedPassContext context, llvm::StringRef name);
 
 SwiftInt SILOptions_enableStackProtection(BridgedPassContext context);
 SwiftInt SILOptions_enableMoveInoutStackProtection(BridgedPassContext context);
+bool SILOptions_enableSimplificationFor(BridgedInstruction inst);
 
 BridgedValue SILUndef_get(BridgedType type, BridgedPassContext context);
 

include/swift/SILOptimizer/PassManager/PassManager.h

@@ -379,6 +379,7 @@ class SILPassManager {
                                   SILTransform *trans);
 
   static bool isPassDisabled(StringRef passName);
+  static bool isInstructionPassDisabled(StringRef instName);
   static bool disablePassesForFunction(SILFunction *function);
 
 private:

lib/SILOptimizer/PassManager/PassManager.cpp

@@ -140,6 +140,10 @@ llvm::cl::opt<bool> SILForceVerifyAll(
     llvm::cl::desc("For all passes, precompute analyses before the pass and "
                    "verify analyses after the pass"));
 
+llvm::cl::list<std::string>
+    SimplifyInstructionTest("simplify-instruction", llvm::cl::CommaSeparated,
+                     llvm::cl::desc("Simplify instruction of specified kind(s)"));
+
 static llvm::ManagedStatic<std::vector<unsigned>> DebugPassNumbers;
 
 namespace {
@@ -487,6 +491,18 @@ bool SILPassManager::isPassDisabled(StringRef passName) {
   return false;
 }
 
+bool SILPassManager::isInstructionPassDisabled(StringRef instName) {
+  StringRef prefix("simplify-");
+  for (const std::string &namePattern : SILDisablePass) {
+    StringRef pattern(namePattern);
+    if (pattern.startswith(prefix) && pattern.endswith(instName) &&
+        pattern.size() == prefix.size() + instName.size()) {
+      return true;
+    }
+  }
+  return false;
+}
+
 bool SILPassManager::disablePassesForFunction(SILFunction *function) {
   if (SILDisablePassOnlyFun.empty())
     return true;
@@ -1706,6 +1722,26 @@ SwiftInt SILOptions_enableMoveInoutStackProtection(BridgedPassContext context) {
   return mod->getOptions().EnableMoveInoutStackProtection;
 }
 
+bool SILOptions_enableSimplificationFor(BridgedInstruction inst) {
+  // Fast-path check.
+  if (SimplifyInstructionTest.empty() && SILDisablePass.empty())
+    return true;
+
+  StringRef instName = getSILInstructionName(castToInst(inst)->getKind());
+
+  if (SILPassManager::isInstructionPassDisabled(instName))
+    return false;
+
+  if (SimplifyInstructionTest.empty())
+    return true;
+
+  for (const std::string &testName : SimplifyInstructionTest) {
+    if (testName == instName)
+      return true;
+  }
+  return false;
+}
+
 BridgedValue SILUndef_get(BridgedType type, BridgedPassContext context) {
   SILUndef *undef = SILUndef::get(castToSILType(type),
                                   *castToPassInvocation(context)->getFunction());

lib/SILOptimizer/SILCombiner/SILCombine.cpp

@@ -558,8 +558,8 @@ SILInstruction *SILCombiner::visit##INST(INST *inst) {                     \
         return nullptr;                                                    \
       }                                                                    \
     }                                                                      \
-    passDisabled = SILPassManager::isPassDisabled(#INST) ||                \
-                   SILPassManager::isPassDisabled("sil-combine-" #INST);   \
+    StringRef instName = getSILInstructionName(SILInstructionKind::INST);  \
+    passDisabled = SILPassManager::isInstructionPassDisabled(instName);    \
   }                                                                        \
   if (passDisabled &&                                                      \
       SILPassManager::disablePassesForFunction(inst->getFunction())) {     \