SwiftCompilerSources: add the ability to implement SIL verification in swift

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -17,6 +17,7 @@ import OptimizerBridging
 public func initializeSwiftModules() {
   registerSILClasses()
   registerSwiftAnalyses()
+  registerUtilities()
   registerSwiftPasses()
   registerOptimizerTests()
 }
@@ -120,3 +121,7 @@ private func registerSwiftAnalyses() {
   AliasAnalysis.register()
   CalleeAnalysis.register()
 }
+
+private func registerUtilities() {
+  registerVerifier()
+}

SwiftCompilerSources/Sources/Optimizer/Utilities/CMakeLists.txt

@@ -20,4 +20,5 @@ swift_compiler_sources(Optimizer
   SSAUpdater.swift
   StaticInitCloner.swift
   Test.swift
+  Verifier.swift
 )

SwiftCompilerSources/Sources/Optimizer/Utilities/Verifier.swift

@@ -0,0 +1,45 @@
+//===--- Verifier.swift ---------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SIL
+import OptimizerBridging
+
+private protocol VerifyableInstruction : Instruction {
+  func verify(_ context: FunctionPassContext)
+}
+
+private func require(_ condition: Bool, _ message: @autoclosure () -> String) {
+  if !condition {
+    fatalError(message())
+  }
+}
+
+extension Function {
+  func verify(_ context: FunctionPassContext) {
+    for block in blocks {
+      for inst in block.instructions {
+        if let verifyableInst = inst as? VerifyableInstruction {
+          verifyableInst.verify(context)
+        }
+      }
+    }
+  }
+}
+
+func registerVerifier() {
+  BridgedUtilities.registerVerifier(
+    { (bridgedCtxt: BridgedPassContext, bridgedFunction: BridgedFunction) in
+      let context = FunctionPassContext(_bridged: bridgedCtxt)
+      bridgedFunction.function.verify(context)
+    }
+  )
+}

include/swift/SILOptimizer/OptimizerBridging.h

@@ -128,6 +128,12 @@ struct BridgedPostDomTree {
   BRIDGED_INLINE bool postDominates(BridgedBasicBlock dominating, BridgedBasicBlock dominated) const;
 };
 
+struct BridgedUtilities {
+  typedef void (* _Nonnull VerifyFunctionFn)(BridgedPassContext, BridgedFunction);
+
+  static void registerVerifier(VerifyFunctionFn verifyFunctionFn);
+};
+
 struct BridgedBasicBlockSet {
   swift::BasicBlockSet * _Nonnull set;
 

include/swift/SILOptimizer/PassManager/PassManager.h

@@ -151,6 +151,9 @@ class SwiftPassInvocation {
 
   void endTransformFunction();
 
+  void beginVerifyFunction(SILFunction *function);
+  void endVerifyFunction();
+
   void notifyNewCloner() { numClonersAllocated++; }
   void notifyClonerDestroyed() { numClonersAllocated--; }
 
@@ -417,6 +420,12 @@ class SILPassManager {
   static bool isInstructionPassDisabled(StringRef instName);
   static bool disablePassesForFunction(SILFunction *function);
 
+  /// Runs the SIL verifier which is implemented in the SwiftCompilerSources.
+  void runSwiftFunctionVerification(SILFunction *f);
+
+  /// Runs the SIL verifier which is implemented in the SwiftCompilerSources.
+  void runSwiftModuleVerification();
+
 private:
   void parsePassCount(StringRef countsStr);
 

lib/DriverTool/sil_opt_main.cpp

@@ -558,8 +558,11 @@ static void runCommandLineSelectedPasses(SILModule *Module,
       Module, SILPassPipelinePlan::getPassPipelineForKinds(opts, options.Passes),
       isMandatory, IRGenMod);
 
-  if (Module->getOptions().VerifyAll)
+  if (Module->getOptions().VerifyAll) {
     Module->verify();
+    SILPassManager pm(Module, isMandatory, IRGenMod);
+    pm.runSwiftModuleVerification();
+  }
 }
 
 namespace {

lib/SILOptimizer/Mandatory/OwnershipModelEliminator.cpp

@@ -836,6 +836,7 @@ struct OwnershipModelEliminator : SILFunctionTransform {
           "ownership. Please re-run with -sil-verify-all to identify the "
           "actual pass that introduced the verification error.");
       f->verify(getAnalysis<BasicCalleeAnalysis>()->getCalleeCache());
+      getPassManager()->runSwiftFunctionVerification(f);
     }
 
     if (stripOwnership(*f)) {

lib/SILOptimizer/PassManager/PassManager.cpp

@@ -161,6 +161,11 @@ llvm::cl::opt<bool> SILForceVerifyAll(
     llvm::cl::desc("For all passes, precompute analyses before the pass and "
                    "verify analyses after the pass"));
 
+llvm::cl::opt<bool> DisableSwiftVerification(
+    "disable-swift-verification", llvm::cl::init(false),
+    llvm::cl::desc("Disable verification which is implemented in the SwiftCompilerSources"));
+
+
 static llvm::ManagedStatic<std::vector<unsigned>> DebugPassNumbers;
 
 namespace {
@@ -611,6 +616,7 @@ void SILPassManager::runPassOnFunction(unsigned TransIdx, SILFunction *F) {
                                                  MatchFun))) {
     F->verify(getAnalysis<BasicCalleeAnalysis>()->getCalleeCache());
     verifyAnalyses();
+    runSwiftFunctionVerification(F);
   }
 
   if (SILPrintPassName)
@@ -706,6 +712,7 @@ void SILPassManager::runPassOnFunction(unsigned TransIdx, SILFunction *F) {
       (CurrentPassHasInvalidated || SILVerifyWithoutInvalidation)) {
     F->verify(getAnalysis<BasicCalleeAnalysis>()->getCalleeCache());
     verifyAnalyses(F);
+    runSwiftFunctionVerification(F);
   } else {
     if ((SILVerifyAfterPass.end() != std::find_if(SILVerifyAfterPass.begin(),
                                                   SILVerifyAfterPass.end(),
@@ -715,6 +722,7 @@ void SILPassManager::runPassOnFunction(unsigned TransIdx, SILFunction *F) {
                                                    MatchFun))) {
       F->verify(getAnalysis<BasicCalleeAnalysis>()->getCalleeCache());
       verifyAnalyses();
+      runSwiftFunctionVerification(F);
     }
   }
 
@@ -821,6 +829,7 @@ void SILPassManager::runModulePass(unsigned TransIdx) {
                                                  MatchFun))) {
     Mod->verify(getAnalysis<BasicCalleeAnalysis>()->getCalleeCache());
     verifyAnalyses();
+    runSwiftModuleVerification();
   }
 
   swiftPassInvocation.startModulePassRun(SMT);
@@ -855,6 +864,7 @@ void SILPassManager::runModulePass(unsigned TransIdx) {
       (CurrentPassHasInvalidated || !SILVerifyWithoutInvalidation)) {
     Mod->verify(getAnalysis<BasicCalleeAnalysis>()->getCalleeCache());
     verifyAnalyses();
+    runSwiftModuleVerification();
   } else {
     if ((SILVerifyAfterPass.end() != std::find_if(SILVerifyAfterPass.begin(),
                                                   SILVerifyAfterPass.end(),
@@ -864,6 +874,7 @@ void SILPassManager::runModulePass(unsigned TransIdx) {
                                                    MatchFun))) {
       Mod->verify(getAnalysis<BasicCalleeAnalysis>()->getCalleeCache());
       verifyAnalyses();
+      runSwiftModuleVerification();
     }
   }
 }
@@ -1483,6 +1494,26 @@ void SwiftPassInvocation::endTransformFunction() {
   assert(numNodeSetsAllocated == 0 && "Not all NodeSets deallocated");
 }
 
+void SwiftPassInvocation::beginVerifyFunction(SILFunction *function) {
+  if (transform) {
+    assert(this->function == function);
+  } else {
+    assert(!this->function);
+    this->function = function;
+  }
+}
+
+void SwiftPassInvocation::endVerifyFunction() {
+  assert(function);
+  if (!transform) {
+    assert(changeNotifications == SILAnalysis::InvalidationKind::Nothing &&
+           "verifyication must not change the SIL of a function");
+    assert(numBlockSetsAllocated == 0 && "Not all BasicBlockSets deallocated");
+    assert(numNodeSetsAllocated == 0 && "Not all NodeSets deallocated");
+    function = nullptr;
+  }
+}
+
 SwiftPassInvocation::~SwiftPassInvocation() {}
 
 //===----------------------------------------------------------------------===//
@@ -1864,3 +1895,29 @@ void BridgedCloner::clone(BridgedInstruction inst) {
   cloner->cloneInst(inst.unbridged());
 }
 
+static BridgedUtilities::VerifyFunctionFn verifyFunctionFunction;
+
+void BridgedUtilities::registerVerifier(VerifyFunctionFn verifyFunctionFn) {
+  verifyFunctionFunction = verifyFunctionFn;
+}
+
+void SILPassManager::runSwiftFunctionVerification(SILFunction *f) {
+  if (!verifyFunctionFunction)
+    return;
+
+  if (f->getModule().getOptions().VerifyNone)
+    return;
+
+  if (DisableSwiftVerification)
+    return;
+
+  getSwiftPassInvocation()->beginVerifyFunction(f);
+  verifyFunctionFunction({getSwiftPassInvocation()}, {f});
+  getSwiftPassInvocation()->endVerifyFunction();
+}
+
+void SILPassManager::runSwiftModuleVerification() {
+  for (SILFunction &f : *Mod) {
+    runSwiftFunctionVerification(&f);
+  }
+}

lib/SILOptimizer/Transforms/PerformanceInliner.cpp

@@ -1195,6 +1195,7 @@ bool SILPerformanceInliner::inlineCallsIntoFunction(SILFunction *Caller) {
       }
 
       Caller->verify();
+      pm->runSwiftFunctionVerification(Caller);
     }
   }
   deleter.cleanupDeadInstructions();
@@ -1212,6 +1213,7 @@ bool SILPerformanceInliner::inlineCallsIntoFunction(SILFunction *Caller) {
   // the inliner without running the entire inliner.
   if (EnableVerifyAfterInlining) {
     Caller->verify();
+    pm->runSwiftFunctionVerification(Caller);
   }
 
   return true;