SIL: Check for leaked instructions in the SILVerifier and in the SILModule destructor.

Author: eeckstein

include/swift/SIL/SILModule.h

@@ -650,6 +650,19 @@ class SILModule {
   /// invariants.
   void verify() const;
 
+  /// Check if there are any leaking instructions.
+  ///
+  /// Aborts with an error if more instructions are allocated than contained in
+  /// the module.
+  void checkForLeaks() const;
+
+  /// Check if there are any leaking instructions after the SILModule is
+  /// destructed.
+  ///
+  /// The SILModule destructor already calls checkForLeaks(). This function is
+  /// useful to check if the destructor itself destroys all data structures.
+  static void checkForLeaksAfterDestruction();
+
   /// Pretty-print the module.
   void dump(bool Verbose = false) const;
 

lib/IRGen/IRGen.cpp

@@ -1009,7 +1009,10 @@ GeneratedModule IRGenRequest::evaluate(Evaluator &evaluator,
 
   // Free the memory occupied by the SILModule.
   // Execute this task in parallel to the embedding of bitcode.
-  auto SILModuleRelease = [&SILMod]() { SILMod.reset(nullptr); };
+  auto SILModuleRelease = [&SILMod]() {
+    SILMod.reset(nullptr);
+    SILModule::checkForLeaksAfterDestruction();
+  };
   auto Thread = std::thread(SILModuleRelease);
   // Wait for the thread to terminate.
   SWIFT_DEFER { Thread.join(); };
@@ -1307,7 +1310,10 @@ static void performParallelIRGeneration(IRGenDescriptor desc) {
 
   // Free the memory occupied by the SILModule.
   // Execute this task in parallel to the LLVM compilation.
-  auto SILModuleRelease = [&SILMod]() { SILMod.reset(nullptr); };
+  auto SILModuleRelease = [&SILMod]() {
+    SILMod.reset(nullptr);
+    SILModule::checkForLeaksAfterDestruction();
+  };
   auto releaseModuleThread = std::thread(SILModuleRelease);
 
   codeGenThreads.runMainThread();

lib/SIL/IR/SILModule.cpp

@@ -111,6 +111,10 @@ SILModule::SILModule(llvm::PointerUnion<FileUnit *, ModuleDecl *> context,
 }
 
 SILModule::~SILModule() {
+#ifndef NDEBUG
+  checkForLeaks();
+#endif
+
   // Decrement ref count for each SILGlobalVariable with static initializers.
   for (SILGlobalVariable &v : silGlobals)
     v.dropAllReferences();
@@ -130,6 +134,44 @@ SILModule::~SILModule() {
   }
 }
 
+void SILModule::checkForLeaks() const {
+  int instsInModule = 0;
+  for (const SILFunction &F : *this) {
+    for (const SILBasicBlock &block : F) {
+      instsInModule += std::distance(block.begin(), block.end());
+    }
+  }
+  for (const SILFunction &F : zombieFunctions) {
+    for (const SILBasicBlock &block : F) {
+      instsInModule += std::distance(block.begin(), block.end());
+    }
+  }
+  for (const SILGlobalVariable &global : getSILGlobals()) {
+      instsInModule += std::distance(global.StaticInitializerBlock.begin(),
+                                     global.StaticInitializerBlock.end());
+  }
+  
+  int numAllocated = SILInstruction::getNumCreatedInstructions() -
+                       SILInstruction::getNumDeletedInstructions();
+                       
+  if (numAllocated != instsInModule) {
+    llvm::errs() << "Leaking instructions!\n";
+    llvm::errs() << "Alloated instructions: " << numAllocated << '\n';
+    llvm::errs() << "Instructions in module: " << instsInModule << '\n';
+    llvm_unreachable("leaking instructions");
+  }
+}
+
+void SILModule::checkForLeaksAfterDestruction() {
+  int numAllocated = SILInstruction::getNumCreatedInstructions() -
+                     SILInstruction::getNumDeletedInstructions();
+
+  if (numAllocated != 0) {
+    llvm::errs() << "Leaking " << numAllocated << " instructions!\n";
+    llvm_unreachable("leaking instructions");
+  }
+}
+
 std::unique_ptr<SILModule> SILModule::createEmptyModule(
     llvm::PointerUnion<FileUnit *, ModuleDecl *> context,
     Lowering::TypeConverter &TC, const SILOptions &Options) {

lib/SIL/Verifier/SILVerifier.cpp

@@ -5559,6 +5559,8 @@ void SILModule::verify() const {
   if (!verificationEnabled(*this))
     return;
 
+  checkForLeaks();
+
   // Uniquing set to catch symbol name collisions.
   llvm::DenseSet<StringRef> symbolNames;