[clang][deps] Store common, partially-formed invocation (llvm#65677)

We create one `CompilerInvocation` for each modular dependency we
discover. This means we create a lot of copies, even though most of the
invocation is the same between modules. This patch makes use of the
copy-on-write flavor of `CompilerInvocation` to share the common parts,
reducing memory usage and speeding up the scan.

Author: jansvoboda11

clang/include/clang/Frontend/CompileJobCacheKey.h

@@ -27,6 +27,7 @@ class raw_ostream;
 namespace clang {
 
 class CompilerInvocation;
+class CowCompilerInvocation;
 class DiagnosticsEngine;
 
 /// Caching-related options for a given \c CompilerInvocation that are
@@ -48,6 +49,9 @@ struct CompileJobCachingOptions {
 std::optional<llvm::cas::CASID>
 createCompileJobCacheKey(llvm::cas::ObjectStore &CAS, DiagnosticsEngine &Diags,
                          const CompilerInvocation &Invocation);
+std::optional<llvm::cas::CASID>
+createCompileJobCacheKey(llvm::cas::ObjectStore &CAS, DiagnosticsEngine &Diags,
+                         const CowCompilerInvocation &Invocation);
 
 /// Perform any destructive changes needed to canonicalize \p Invocation for
 /// caching, extracting the settings that affect compilation even if they do not

clang/include/clang/Frontend/CompilerInvocation.h

@@ -226,6 +226,8 @@ class CompilerInvocationBase {
   }
 };
 
+class CowCompilerInvocation;
+
 /// Helper class for holding the data necessary to invoke the compiler.
 ///
 /// This class is designed to represent an abstract "invocation" of the
@@ -245,6 +247,9 @@ class CompilerInvocation : public CompilerInvocationBase {
   }
   ~CompilerInvocation() = default;
 
+  explicit CompilerInvocation(const CowCompilerInvocation &X);
+  CompilerInvocation &operator=(const CowCompilerInvocation &X);
+
   /// Const getters.
   /// @{
   // Note: These need to be pulled in manually. Otherwise, they get hidden by

clang/include/clang/Tooling/DependencyScanning/DependencyScanningWorker.h

@@ -101,7 +101,7 @@ class DependencyActionController {
     return llvm::Error::success();
   }
 
-  virtual llvm::Error finalizeModuleInvocation(CompilerInvocation &CI,
+  virtual llvm::Error finalizeModuleInvocation(CowCompilerInvocation &CI,
                                                const ModuleDeps &MD) {
     return llvm::Error::success();
   }

clang/include/clang/Tooling/DependencyScanning/ModuleDepCollector.h

@@ -253,8 +253,11 @@ class ModuleDepCollector final : public DependencyCollector {
   llvm::SetVector<const Module *> DirectModularDeps;
   /// Options that control the dependency output generation.
   std::unique_ptr<DependencyOutputOptions> Opts;
-  /// The original Clang invocation passed to dependency scanner.
-  CompilerInvocation OriginalInvocation;
+  /// A Clang invocation that's based on the original TU invocation and that has
+  /// been partially transformed into one that can perform explicit build of
+  /// a discovered modular dependency. Note that this still needs to be adjusted
+  /// for each individual module.
+  CowCompilerInvocation CommonInvocation;
   /// Whether to optimize the modules' command-line arguments.
   bool OptimizeArgs;
   /// Whether to set up command-lines to load PCM files eagerly.
@@ -274,12 +277,11 @@ class ModuleDepCollector final : public DependencyCollector {
   /// Adds \p Path to \c MD.FileDeps, making it absolute if necessary.
   void addFileDep(ModuleDeps &MD, StringRef Path);
 
-  /// Constructs a CompilerInvocation that can be used to build the given
-  /// module, excluding paths to discovered modular dependencies that are yet to
-  /// be built.
-  CompilerInvocation makeInvocationForModuleBuildWithoutOutputs(
+  /// Get a Clang invocation adjusted to build the given modular dependency.
+  /// This excludes paths that are yet-to-be-provided by the build system.
+  CowCompilerInvocation getInvocationAdjustedForModuleBuildWithoutOutputs(
       const ModuleDeps &Deps,
-      llvm::function_ref<void(CompilerInvocation &)> Optimize) const;
+      llvm::function_ref<void(CowCompilerInvocation &)> Optimize) const;
 
   /// Collect module map files for given modules.
   llvm::DenseSet<const FileEntry *>
@@ -291,13 +293,16 @@ class ModuleDepCollector final : public DependencyCollector {
   /// Add module files (pcm) to the invocation, if needed.
   void addModuleFiles(CompilerInvocation &CI,
                       ArrayRef<ModuleID> ClangModuleDeps) const;
+  void addModuleFiles(CowCompilerInvocation &CI,
+                      ArrayRef<ModuleID> ClangModuleDeps) const;
 
   /// Add paths that require looking up outputs to the given dependencies.
-  void addOutputPaths(CompilerInvocation &CI, ModuleDeps &Deps);
+  void addOutputPaths(CowCompilerInvocation &CI, ModuleDeps &Deps);
 
   /// Compute the context hash for \p Deps, and create the mapping
   /// \c ModuleDepsByID[Deps.ID] = &Deps.
-  void associateWithContextHash(const CompilerInvocation &CI, ModuleDeps &Deps);
+  void associateWithContextHash(const CowCompilerInvocation &CI,
+                                ModuleDeps &Deps);
 };
 
 } // end namespace dependencies

clang/lib/Frontend/CompileJobCacheKey.cpp

@@ -186,9 +186,16 @@ std::optional<llvm::cas::CASID> clang::canonicalizeAndCreateCacheKey(
 
 std::optional<llvm::cas::CASID>
 clang::createCompileJobCacheKey(ObjectStore &CAS, DiagnosticsEngine &Diags,
-                                const CompilerInvocation &OriginalInvocation) {
+                                const CompilerInvocation &OriginalCI) {
+  CompilerInvocation CI(OriginalCI);
+  (void)canonicalizeForCaching(CAS, Diags, CI);
+  return createCompileJobCacheKeyImpl(CAS, Diags, std::move(CI));
+}
 
-  CompilerInvocation CI(OriginalInvocation);
+std::optional<llvm::cas::CASID>
+clang::createCompileJobCacheKey(ObjectStore &CAS, DiagnosticsEngine &Diags,
+                                const CowCompilerInvocation &OriginalCI) {
+  CompilerInvocation CI(OriginalCI);
   (void)canonicalizeForCaching(CAS, Diags, CI);
   return createCompileJobCacheKeyImpl(CAS, Diags, std::move(CI));
 }

clang/lib/Frontend/CompilerInvocation.cpp

@@ -189,6 +189,8 @@ CompilerInvocationBase::shallow_copy_assign(const CompilerInvocationBase &X) {
     PPOpts = X.PPOpts;
     AnalyzerOpts = X.AnalyzerOpts;
     MigratorOpts = X.MigratorOpts;
+    APINotesOpts = X.APINotesOpts;
+    CASOpts = X.CASOpts;
     CodeGenOpts = X.CodeGenOpts;
     FSOpts = X.FSOpts;
     FrontendOpts = X.FrontendOpts;
@@ -198,6 +200,17 @@ CompilerInvocationBase::shallow_copy_assign(const CompilerInvocationBase &X) {
   return *this;
 }
 
+CompilerInvocation::CompilerInvocation(const CowCompilerInvocation &X)
+    : CompilerInvocationBase(EmptyConstructor{}) {
+  CompilerInvocationBase::deep_copy_assign(X);
+}
+
+CompilerInvocation &
+CompilerInvocation::operator=(const CowCompilerInvocation &X) {
+  CompilerInvocationBase::deep_copy_assign(X);
+  return *this;
+}
+
 namespace {
 template <typename T>
 T &ensureOwned(std::shared_ptr<T> &Storage) {

clang/lib/Tooling/DependencyScanning/CASFSActionController.cpp

@@ -32,7 +32,7 @@ class CASFSActionController : public CallbackActionController {
   initializeModuleBuild(CompilerInstance &ModuleScanInstance) override;
   llvm::Error
   finalizeModuleBuild(CompilerInstance &ModuleScanInstance) override;
-  llvm::Error finalizeModuleInvocation(CompilerInvocation &CI,
+  llvm::Error finalizeModuleInvocation(CowCompilerInvocation &CI,
                                        const ModuleDeps &MD) override;
 
 private:
@@ -178,8 +178,11 @@ Error CASFSActionController::finalizeModuleBuild(
   return Error::success();
 }
 
-Error CASFSActionController::finalizeModuleInvocation(CompilerInvocation &CI,
-                                                      const ModuleDeps &MD) {
+Error CASFSActionController::finalizeModuleInvocation(
+    CowCompilerInvocation &CowCI, const ModuleDeps &MD) {
+  // TODO: Avoid this copy.
+  CompilerInvocation CI(CowCI);
+
   if (auto ID = MD.CASFileSystemRootID) {
     configureInvocationForCaching(CI, CASOpts, ID->toString(),
                                   CacheFS.getCurrentWorkingDirectory().get(),
@@ -189,6 +192,7 @@ Error CASFSActionController::finalizeModuleInvocation(CompilerInvocation &CI,
   if (Mapper)
     DepscanPrefixMapping::remapInvocationPaths(CI, *Mapper);
 
+  CowCI = CI;
   return llvm::Error::success();
 }
 

clang/lib/Tooling/DependencyScanning/IncludeTreeActionController.cpp

@@ -40,7 +40,7 @@ class IncludeTreeActionController : public CallbackActionController {
 
   Error initializeModuleBuild(CompilerInstance &ModuleScanInstance) override;
   Error finalizeModuleBuild(CompilerInstance &ModuleScanInstance) override;
-  Error finalizeModuleInvocation(CompilerInvocation &CI,
+  Error finalizeModuleInvocation(CowCompilerInvocation &CI,
                                  const ModuleDeps &MD) override;
 
 private:
@@ -392,17 +392,22 @@ Error IncludeTreeActionController::finalizeModuleBuild(
 }
 
 Error IncludeTreeActionController::finalizeModuleInvocation(
-    CompilerInvocation &CI, const ModuleDeps &MD) {
+    CowCompilerInvocation &CowCI, const ModuleDeps &MD) {
   if (!MD.IncludeTreeID)
     return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                    "missing include-tree for module '%s'",
                                    MD.ID.ModuleName.c_str());
 
+  // TODO: Avoid this copy.
+  CompilerInvocation CI(CowCI);
+
   configureInvocationForCaching(CI, CASOpts, *MD.IncludeTreeID,
                                 /*CASFSWorkingDir=*/"",
                                 /*ProduceIncludeTree=*/true);
 
   DepscanPrefixMapping::remapInvocationPaths(CI, PrefixMapper);
+
+  CowCI = CI;
   return Error::success();
 }