[CAS] Provide an API to canonicalize a CompilerInvocation

This patch adds a new function that canonicalizes the
CompilerInvocation. An initial use case is to allow serialization of the
invocation, where serializing a non canonical invocation might lead to
cache poisoning.

Author: usama54321

clang/include/clang/Frontend/CompileJobCacheKey.h

@@ -79,6 +79,9 @@ llvm::Error printCompileJobCacheKey(llvm::cas::ObjectStore &CAS,
                                     const llvm::cas::CASID &Key,
                                     llvm::raw_ostream &OS);
 
+void canonicalizeCASCompilerInvocation(const llvm::cas::ObjectStore &CAS,
+                                       CompilerInvocation &CI);
+
 } // namespace clang
 
 #endif // LLVM_CLANG_FRONTEND_COMPILEJOBCACHEKEY_H

clang/include/clang/Frontend/CompilerInstance.h

@@ -13,6 +13,7 @@
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
+#include "clang/Frontend/CompileJobCacheKey.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Frontend/PCHContainerOperations.h"
 #include "clang/Frontend/Utils.h"
@@ -213,8 +214,6 @@ class CompilerInstance : public ModuleLoader {
   /// Force an output buffer.
   std::unique_ptr<llvm::raw_pwrite_stream> OutputStream;
 
-  void createCASDatabases();
-
   CompilerInstance(const CompilerInstance &) = delete;
   void operator=(const CompilerInstance &) = delete;
 public:
@@ -753,6 +752,15 @@ class CompilerInstance : public ModuleLoader {
         getInvocation().getModuleHash(getDiagnostics()));
   }
 
+  CompilerInvocation getCacheCanonicalInvocation() {
+    if (!CAS)
+      return *Invocation;
+
+    CompilerInvocation Copy(*Invocation);
+    canonicalizeCASCompilerInvocation(*CAS, Copy);
+    return Copy;
+  }
+
   /// Create the AST context.
   void createASTContext();
 
@@ -994,6 +1002,10 @@ class CompilerInstance : public ModuleLoader {
                            StringRef Provider);
 
   ModuleCache &getModuleCache() const { return *ModCache; }
+
+  std::pair<std::shared_ptr<llvm::cas::ObjectStore>,
+            std::shared_ptr<llvm::cas::ActionCache>>
+  createCASDatabases();
 };
 
 } // end namespace clang

clang/lib/Frontend/CompileJobCache.cpp

@@ -296,7 +296,7 @@ std::optional<int> CompileJobCache::initialize(CompilerInstance &Clang) {
   if (!CacheCompileJob)
     return std::nullopt;
 
-  std::tie(CAS, Cache) = Invocation.getCASOpts().getOrCreateDatabases(Diags);
+  std::tie(CAS, Cache) = Clang.createCASDatabases();
   if (!CAS || !Cache)
     return 1; // Exit with error!
 

clang/lib/Frontend/CompileJobCacheKey.cpp

@@ -67,9 +67,7 @@ static llvm::cas::CASID createCompileJobCacheKeyForArgs(
   return llvm::cantFail(Builder.create(CAS)).getID();
 }
 
-static std::optional<llvm::cas::CASID>
-createCompileJobCacheKeyImpl(ObjectStore &CAS, DiagnosticsEngine &Diags,
-                             CompilerInvocation CI) {
+static void canonicalizeForCacheKey(CompilerInvocation &CI) {
   FrontendOptions &FrontendOpts = CI.getFrontendOpts();
   DependencyOutputOptions &DepOpts = CI.getDependencyOutputOpts();
 
@@ -136,7 +134,12 @@ createCompileJobCacheKeyImpl(ObjectStore &CAS, DiagnosticsEngine &Diags,
     // These are intended for caching introspection, they are not cached.
     return Remark.starts_with("compile-job-cache");
   });
+}
 
+static std::optional<llvm::cas::CASID>
+createCompileJobCacheKeyImpl(ObjectStore &CAS, DiagnosticsEngine &Diags,
+                             CompilerInvocation CI) {
+  canonicalizeForCacheKey(CI);
   // Generate a new command-line in case Invocation has been canonicalized.
   llvm::BumpPtrAllocator Alloc;
   llvm::StringSaver Saver(Alloc);
@@ -182,7 +185,7 @@ createCompileJobCacheKeyImpl(ObjectStore &CAS, DiagnosticsEngine &Diags,
 }
 
 static CompileJobCachingOptions
-canonicalizeForCaching(llvm::cas::ObjectStore &CAS, DiagnosticsEngine &Diags,
+canonicalizeForCaching(const llvm::cas::ObjectStore &CAS,
                        CompilerInvocation &Invocation) {
   CompileJobCachingOptions Opts;
   FrontendOptions &FrontendOpts = Invocation.getFrontendOpts();
@@ -220,6 +223,12 @@ canonicalizeForCaching(llvm::cas::ObjectStore &CAS, DiagnosticsEngine &Diags,
   return Opts;
 }
 
+void clang::canonicalizeCASCompilerInvocation(const ObjectStore &CAS,
+                                              CompilerInvocation &CI) {
+  (void)canonicalizeForCaching(CAS, CI);
+  canonicalizeForCacheKey(CI);
+}
+
 std::optional<std::pair<llvm::cas::CASID, llvm::cas::CASID>>
 clang::canonicalizeAndCreateCacheKeys(ObjectStore &CAS,
                                       ActionCache &Cache,
@@ -231,7 +240,7 @@ clang::canonicalizeAndCreateCacheKeys(ObjectStore &CAS,
   CASOptions CASOpts(CI.getCASOpts());
   CASOpts.freezeConfig(Diags);
 
-  Opts = canonicalizeForCaching(CAS, Diags, CI);
+  Opts = canonicalizeForCaching(CAS, CI);
   auto CacheKey = createCompileJobCacheKeyImpl(CAS, Diags, CI);
   if (!CacheKey)
     return std::nullopt;
@@ -265,7 +274,7 @@ clang::canonicalizeAndCreateCacheKeys(ObjectStore &CAS,
   CI.getFrontendOpts().CASInputFileCacheKey.clear();
 
   CompilerInvocation CICopy = CI;
-  (void)canonicalizeForCaching(CAS, Diags, CICopy);
+  (void)canonicalizeForCaching(CAS, CICopy);
   auto CanonicalCacheKey = createCompileJobCacheKeyImpl(CAS, Diags, CICopy);
   if (!CanonicalCacheKey)
     return std::nullopt;
@@ -277,15 +286,15 @@ std::optional<llvm::cas::CASID>
 clang::createCompileJobCacheKey(ObjectStore &CAS, DiagnosticsEngine &Diags,
                                 const CompilerInvocation &OriginalCI) {
   CompilerInvocation CI(OriginalCI);
-  (void)canonicalizeForCaching(CAS, Diags, CI);
+  (void)canonicalizeForCaching(CAS, CI);
   return createCompileJobCacheKeyImpl(CAS, Diags, std::move(CI));
 }
 
 std::optional<llvm::cas::CASID>
 clang::createCompileJobCacheKey(ObjectStore &CAS, DiagnosticsEngine &Diags,
                                 const CowCompilerInvocation &OriginalCI) {
   CompilerInvocation CI(OriginalCI);
-  (void)canonicalizeForCaching(CAS, Diags, CI);
+  (void)canonicalizeForCaching(CAS, CI);
   return createCompileJobCacheKeyImpl(CAS, Diags, std::move(CI));
 }
 

clang/lib/Frontend/CompilerInstance.cpp

@@ -957,13 +957,16 @@ llvm::vfs::OutputBackend &CompilerInstance::getOrCreateOutputBackend() {
   return getOutputBackend();
 }
 
-void CompilerInstance::createCASDatabases() {
+std::pair<std::shared_ptr<llvm::cas::ObjectStore>,
+          std::shared_ptr<llvm::cas::ActionCache>>
+CompilerInstance::createCASDatabases() {
   // Create a new CAS databases from the CompilerInvocation. Future calls to
   // createFileManager() will use the same CAS.
   std::tie(CAS, ActionCache) =
       getInvocation().getCASOpts().getOrCreateDatabases(
           getDiagnostics(),
           /*CreateEmptyCASOnFailure=*/true);
+  return {CAS, ActionCache};
 }
 
 llvm::cas::ObjectStore &CompilerInstance::getOrCreateObjectStore() {