Fix valgrind/windows

Author: vgvassilev

clang/include/clang/Interpreter/Interpreter.h

@@ -110,9 +110,12 @@ class Interpreter {
   /// and we must keep it alive.
   std::unique_ptr<llvm::Module> CachedInCodeGenModule;
 
+  /// Compiler instance performing the incremental compilation.
+  std::unique_ptr<CompilerInstance> CI;
+
 protected:
   // Derived classes can use an extended interface of the Interpreter.
-  Interpreter(std::unique_ptr<CompilerInstance> CI, llvm::Error &Err,
+  Interpreter(std::unique_ptr<CompilerInstance> Instance, llvm::Error &Err,
               std::unique_ptr<llvm::orc::LLJITBuilder> JITBuilder = nullptr,
               std::unique_ptr<clang::ASTConsumer> Consumer = nullptr);
 

clang/lib/Interpreter/DeviceOffload.cpp

@@ -25,14 +25,17 @@
 namespace clang {
 
 IncrementalCUDADeviceParser::IncrementalCUDADeviceParser(
-    std::unique_ptr<CompilerInstance> Instance, IncrementalParser &HostParser,
+    std::unique_ptr<CompilerInstance> DeviceInstance,
+    CompilerInstance &HostInstance,
     llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> FS,
     llvm::Error &Err, const std::list<PartialTranslationUnit> &PTUs)
-    : IncrementalParser(std::move(Instance), Err), PTUs(PTUs),
-      HostParser(HostParser), VFS(FS) {
+    : IncrementalParser(*DeviceInstance, Err), PTUs(PTUs), VFS(FS),
+      CodeGenOpts(HostInstance.getCodeGenOpts()),
+      TargetOpts(HostInstance.getTargetOpts()) {
   if (Err)
     return;
-  StringRef Arch = CI->getTargetOpts().CPU;
+  DeviceCI = std::move(DeviceInstance);
+  StringRef Arch = TargetOpts.CPU;
   if (!Arch.starts_with("sm_") || Arch.substr(3).getAsInteger(10, SMVersion)) {
     Err = llvm::joinErrors(std::move(Err), llvm::make_error<llvm::StringError>(
                                                "Invalid CUDA architecture",
@@ -62,7 +65,7 @@ IncrementalCUDADeviceParser::Parse(llvm::StringRef Input) {
                    llvm::StringRef(FatbinContent.data(), FatbinContent.size()),
                    "", false));
 
-  HostParser.getCI()->getCodeGenOpts().CudaGpuBinaryFileName = FatbinFileName;
+  CodeGenOpts.CudaGpuBinaryFileName = FatbinFileName;
 
   FatbinContent.clear();
 
@@ -80,7 +83,7 @@ llvm::Expected<llvm::StringRef> IncrementalCUDADeviceParser::GeneratePTX() {
                                                std::error_code());
   llvm::TargetOptions TO = llvm::TargetOptions();
   llvm::TargetMachine *TargetMachine = Target->createTargetMachine(
-      PTU.TheModule->getTargetTriple(), getCI()->getTargetOpts().CPU, "", TO,
+      PTU.TheModule->getTargetTriple(), TargetOpts.CPU, "", TO,
       llvm::Reloc::Model::PIC_);
   PTU.TheModule->setDataLayout(TargetMachine->createDataLayout());
 

clang/lib/Interpreter/DeviceOffload.h

@@ -19,12 +19,17 @@
 
 namespace clang {
 struct PartialTranslationUnit;
+class CompilerInstance;
+class CodeGenOptions;
+class TargetOptions;
+
 class IncrementalCUDADeviceParser : public IncrementalParser {
   const std::list<PartialTranslationUnit> &PTUs;
 
 public:
   IncrementalCUDADeviceParser(
-      std::unique_ptr<CompilerInstance> Instance, IncrementalParser &HostParser,
+      std::unique_ptr<CompilerInstance> DeviceInstance,
+      CompilerInstance &HostInstance,
       llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> VFS,
       llvm::Error &Err, const std::list<PartialTranslationUnit> &PTUs);
 
@@ -39,11 +44,13 @@ class IncrementalCUDADeviceParser : public IncrementalParser {
   ~IncrementalCUDADeviceParser();
 
 protected:
-  IncrementalParser &HostParser;
+  std::unique_ptr<CompilerInstance> DeviceCI;
   int SMVersion;
   llvm::SmallString<1024> PTXCode;
   llvm::SmallVector<char, 1024> FatbinContent;
   llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> VFS;
+  CodeGenOptions &CodeGenOpts; // intentionally a reference.
+  const TargetOptions &TargetOpts;
 };
 
 } // namespace clang

clang/lib/Interpreter/IncrementalParser.cpp

@@ -24,16 +24,14 @@
 
 namespace clang {
 
-IncrementalParser::IncrementalParser() {}
+// IncrementalParser::IncrementalParser() {}
 
-IncrementalParser::IncrementalParser(std::unique_ptr<CompilerInstance> Instance,
+IncrementalParser::IncrementalParser(CompilerInstance &Instance,
                                      llvm::Error &Err)
-    : CI(std::move(Instance)) {
+    : S(Instance.getSema()) {
   llvm::ErrorAsOutParameter EAO(&Err);
-
-  Consumer = &CI->getASTConsumer();
-  P.reset(
-      new Parser(CI->getPreprocessor(), CI->getSema(), /*SkipBodies=*/false));
+  Consumer = &S.getASTConsumer();
+  P.reset(new Parser(S.getPreprocessor(), S, /*SkipBodies=*/false));
   P->Initialize();
 }
 
@@ -42,7 +40,6 @@ IncrementalParser::~IncrementalParser() { P.reset(); }
 llvm::Expected<TranslationUnitDecl *>
 IncrementalParser::ParseOrWrapTopLevelDecl() {
   // Recover resources if we crash before exiting this method.
-  Sema &S = CI->getSema();
   llvm::CrashRecoveryContextCleanupRegistrar<Sema> CleanupSema(&S);
   Sema::GlobalEagerInstantiationScope GlobalInstantiations(S, /*Enabled=*/true);
   Sema::LocalEagerInstantiationScope LocalInstantiations(S);
@@ -73,7 +70,7 @@ IncrementalParser::ParseOrWrapTopLevelDecl() {
                                                  std::error_code());
   }
 
-  DiagnosticsEngine &Diags = getCI()->getDiagnostics();
+  DiagnosticsEngine &Diags = S.getDiagnostics();
   if (Diags.hasErrorOccurred()) {
     CleanUpPTU(C.getTranslationUnitDecl());
 
@@ -99,7 +96,7 @@ IncrementalParser::ParseOrWrapTopLevelDecl() {
 
 llvm::Expected<TranslationUnitDecl *>
 IncrementalParser::Parse(llvm::StringRef input) {
-  Preprocessor &PP = CI->getPreprocessor();
+  Preprocessor &PP = S.getPreprocessor();
   assert(PP.isIncrementalProcessingEnabled() && "Not in incremental mode!?");
 
   std::ostringstream SourceName;
@@ -115,7 +112,7 @@ IncrementalParser::Parse(llvm::StringRef input) {
   memcpy(MBStart, input.data(), InputSize);
   MBStart[InputSize] = '\n';
 
-  SourceManager &SM = CI->getSourceManager();
+  SourceManager &SM = S.getSourceManager();
 
   // FIXME: Create SourceLocation, which will allow clang to order the overload
   // candidates for example
@@ -183,7 +180,7 @@ void IncrementalParser::CleanUpPTU(TranslationUnitDecl *MostRecentTU) {
     // Check if we need to clean up the IdResolver chain.
     if (ND->getDeclName().getFETokenInfo() && !D->getLangOpts().ObjC &&
         !D->getLangOpts().CPlusPlus)
-      getCI()->getSema().IdResolver.RemoveDecl(ND);
+      S.IdResolver.RemoveDecl(ND);
   }
 }
 

clang/lib/Interpreter/IncrementalParser.h

@@ -24,15 +24,16 @@ class ASTConsumer;
 class CodeGenerator;
 class CompilerInstance;
 class Parser;
+class Sema;
 class TranslationUnitDecl;
 
 /// Provides support for incremental compilation. Keeps track of the state
 /// changes between the subsequent incremental input.
 ///
 class IncrementalParser {
 protected:
-  /// Compiler instance performing the incremental compilation.
-  std::unique_ptr<CompilerInstance> CI;
+  /// The Sema performing the incremental compilation.
+  Sema &S;
 
   /// Parser.
   std::unique_ptr<Parser> P;
@@ -43,15 +44,12 @@ class IncrementalParser {
   /// Counts the number of direct user input lines that have been parsed.
   unsigned InputCount = 0;
 
-  IncrementalParser();
+  // IncrementalParser();
 
 public:
-  IncrementalParser(std::unique_ptr<CompilerInstance> Instance,
-                    llvm::Error &Err);
+  IncrementalParser(CompilerInstance &Instance, llvm::Error &Err);
   virtual ~IncrementalParser();
 
-  CompilerInstance *getCI() { return CI.get(); }
-
   /// Parses incremental input by creating an in-memory file.
   ///\returns a \c PartialTranslationUnit which holds information about the
   /// \c TranslationUnitDecl.

clang/lib/Interpreter/Interpreter.cpp

@@ -378,11 +378,12 @@ class IncrementalAction : public WrapperFrontendAction {
   }
 };
 
-Interpreter::Interpreter(std::unique_ptr<CompilerInstance> CI,
+Interpreter::Interpreter(std::unique_ptr<CompilerInstance> Instance,
                          llvm::Error &ErrOut,
                          std::unique_ptr<llvm::orc::LLJITBuilder> JITBuilder,
                          std::unique_ptr<clang::ASTConsumer> Consumer)
     : JITBuilder(std::move(JITBuilder)) {
+  CI = std::move(Instance);
   llvm::ErrorAsOutParameter EAO(&ErrOut);
   auto LLVMCtx = std::make_unique<llvm::LLVMContext>();
   TSCtx = std::make_unique<llvm::orc::ThreadSafeContext>(std::move(LLVMCtx));
@@ -395,7 +396,7 @@ Interpreter::Interpreter(std::unique_ptr<CompilerInstance> CI,
 
   ASTContext &C = CI->getASTContext();
 
-  IncrParser = std::make_unique<IncrementalParser>(std::move(CI), ErrOut);
+  IncrParser = std::make_unique<IncrementalParser>(*CI, ErrOut);
 
   if (ErrOut)
     return;
@@ -427,8 +428,8 @@ Interpreter::Interpreter(std::unique_ptr<CompilerInstance> CI,
 }
 
 Interpreter::~Interpreter() {
-  Act->FinalizeAction();
   IncrParser.reset();
+  Act->FinalizeAction();
   if (IncrExecutor) {
     if (llvm::Error Err = IncrExecutor->cleanUp())
       llvm::report_fatal_error(
@@ -500,7 +501,7 @@ Interpreter::createWithCUDA(std::unique_ptr<CompilerInstance> CI,
 
   llvm::Error Err = llvm::Error::success();
   auto DeviceParser = std::make_unique<IncrementalCUDADeviceParser>(
-      std::move(DCI), *(*Interp)->IncrParser.get(), IMVFS, Err,
+      std::move(DCI), *(*Interp)->getCompilerInstance(), IMVFS, Err,
       (*Interp)->PTUs);
   if (Err)
     return std::move(Err);
@@ -511,12 +512,10 @@ Interpreter::createWithCUDA(std::unique_ptr<CompilerInstance> CI,
 }
 
 const CompilerInstance *Interpreter::getCompilerInstance() const {
-  return IncrParser->getCI();
+  return CI.get();
 }
 
-CompilerInstance *Interpreter::getCompilerInstance() {
-  return IncrParser->getCI();
-}
+CompilerInstance *Interpreter::getCompilerInstance() { return CI.get(); }
 
 llvm::Expected<llvm::orc::LLJIT &> Interpreter::getExecutionEngine() {
   if (!IncrExecutor) {