SIL: Only enable instruction leaks checking in the frontend's and SILOpt's modules.

Leaks checking is not thread safe and e.g. lldb creates multiple SILModules in multiple threads, which would result in false alarms.
Ideally we would make it thread safe, e.g. by putting the instruction counters in the SILModule, but this would be a big effort and it's not worth doing it. Leaks checking in the frontend's and SILOpt's SILModule (not including SILModules created for module interface building) is a good enough test.

rdar://84688015

Author: eeckstein

include/swift/AST/SILOptions.h

@@ -198,6 +198,12 @@ class SILOptions {
   /// Are we parsing the stdlib, i.e. -parse-stdlib?
   bool ParseStdlib = false;
 
+  /// If true, check for leaking instructions when the SILModule is destructed.
+  ///
+  /// Warning: this is not thread safe. It can only be enabled in case there
+  /// is a single SILModule in a single thread.
+  bool checkSILModuleLeaks = false;
+
   /// The name of the file to which the backend should save optimization
   /// records.
   std::string OptRecordFile;

include/swift/SIL/SILInstruction.h

@@ -349,7 +349,9 @@ class SILInstruction : public llvm::ilist_node<SILInstruction> {
   void setDebugScope(const SILDebugScope *DS);
 
   /// Total number of created and deleted SILInstructions.
-  /// It is used only for collecting the compiler statistics.
+  ///
+  /// Ideally, those counters would be inside SILModules to allow mutiple
+  /// SILModules (e.g. in different threads).
   static int NumCreatedInstructions;
   static int NumDeletedInstructions;
 
@@ -759,6 +761,11 @@ class SILInstruction : public llvm::ilist_node<SILInstruction> {
   static int getNumDeletedInstructions() {
     return NumDeletedInstructions;
   }
+  
+  static void resetInstructionCounts() {
+    NumCreatedInstructions = 0;
+    NumDeletedInstructions = 0;
+  }
 
   /// Pretty-print the value.
   void dump() const;

lib/FrontendTool/FrontendTool.cpp

@@ -2065,6 +2065,10 @@ int swift::performFrontend(ArrayRef<const char *> Args,
       FrontendOptions::ActionType::Immediate) {
     llvm::setBugReportMsg(nullptr);
   }
+  
+  /// Enable leaks checking because this SILModule is the only one in the process
+  /// (leaks checking is not thread safe).
+  Invocation.getSILOptions().checkSILModuleLeaks = true;
 
   PrettyStackTraceFrontend frontendTrace(Invocation.getLangOptions());
 

lib/IRGen/IRGen.cpp

@@ -1145,8 +1145,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]() {
+    bool checkForLeaks = SILMod->getOptions().checkSILModuleLeaks;
     SILMod.reset(nullptr);
-    SILModule::checkForLeaksAfterDestruction();
+    if (checkForLeaks)
+      SILModule::checkForLeaksAfterDestruction();
   };
   auto Thread = std::thread(SILModuleRelease);
   // Wait for the thread to terminate.
@@ -1447,8 +1449,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]() {
+    bool checkForLeaks = SILMod->getOptions().checkSILModuleLeaks;
     SILMod.reset(nullptr);
-    SILModule::checkForLeaksAfterDestruction();
+    if (checkForLeaks)
+      SILModule::checkForLeaksAfterDestruction();
   };
   auto releaseModuleThread = std::thread(SILModuleRelease);
 

lib/SIL/IR/SILModule.cpp

@@ -151,6 +151,13 @@ SILModule::~SILModule() {
 }
 
 void SILModule::checkForLeaks() const {
+
+  /// Leak checking is not thread safe, because the instruction counters are
+  /// global non-atomic variables. Leak checking can only be done in case there
+  /// is a single SILModule in a single thread.
+  if (!getOptions().checkSILModuleLeaks)
+    return;
+
   int instsInModule = std::distance(scheduledForDeletion.begin(),
                                     scheduledForDeletion.end());
   for (const SILFunction &F : *this) {

lib/SIL/Parser/ParseSIL.cpp

@@ -74,6 +74,9 @@ ParseSILModuleRequest::evaluate(Evaluator &evaluator,
   auto bufferID = SF->getBufferID();
   assert(bufferID);
 
+  // For leak detection.
+  SILInstruction::resetInstructionCounts();
+
   auto silMod = SILModule::createEmptyModule(desc.context, desc.conv,
                                              desc.opts);
   SILParserState parserState(*silMod.get());

lib/SILGen/SILGen.cpp

@@ -2149,6 +2149,9 @@ ASTLoweringRequest::evaluate(Evaluator &evaluator,
     return llvm::cantFail(evaluator(ParseSILModuleRequest{desc}));
   }
 
+  // For leak detection.
+  SILInstruction::resetInstructionCounts();
+
   auto silMod = SILModule::createEmptyModule(desc.context, desc.conv,
                                              desc.opts);
 

tools/sil-opt/SILOpt.cpp

@@ -483,6 +483,7 @@ int main(int argc, char **argv) {
   SILOpts.VerifySILOwnership = !DisableSILOwnershipVerifier;
   SILOpts.OptRecordFile = RemarksFilename;
   SILOpts.OptRecordPasses = RemarksPasses;
+  SILOpts.checkSILModuleLeaks = true;
 
   SILOpts.VerifyExclusivity = VerifyExclusivity;
   if (EnforceExclusivity.getNumOccurrences() != 0) {