Fix direct clang cc1 emit-pcm commands with vfs overlay on Windows

hjyamauchi · hjyamauchi · commit 7b4835f12495 · 2025-11-10T13:17:51.000-08:00
Explicit module builds currently fail on Windows because
direct-clang-cc1-module-build emit-pcm commands take overlaid system
module map files as inputs but miss the clang VFS overlay. This change
adds the overlay and fixes explicit module builds on Windows.
diff --git a/include/swift/AST/ASTContext.h b/include/swift/AST/ASTContext.h
@@ -435,6 +435,9 @@ class ASTContext final {
 
   /// The block list where we can find special actions based on module name;
   BlockListStore blockListConfig;
+
+  llvm::BumpPtrAllocator ClangInvocationFileMappingAllocator;
+
 private:
   /// The current generation number, which reflects the number of
   /// times that external modules have been loaded.
diff --git a/include/swift/ClangImporter/ClangImporter.h b/include/swift/ClangImporter/ClangImporter.h
@@ -74,6 +74,7 @@ namespace dependencies {
 namespace swift {
 enum class ResultConvention : uint8_t;
 class ASTContext;
+class CASOptions;
 class CompilerInvocation;
 class ClangImporterOptions;
 class ClangInheritanceInfo;
@@ -82,6 +83,7 @@ class ClangNode;
 class ConcreteDeclRef;
 class Decl;
 class DeclContext;
+class DiagnosticEngine;
 class EffectiveClangContext;
 class EnumDecl;
 class FuncDecl;
@@ -881,6 +883,33 @@ struct ClangInvocationFileMapping {
   bool requiresBuiltinHeadersInSystemModules;
 };
 
+class ClangInvocationFileMappingContext {
+public:
+  const LangOptions &LangOpts;
+  SearchPathOptions &SearchPathOpts;
+  ClangImporterOptions &ClangImporterOpts;
+  const CASOptions &CASOpts;
+  DiagnosticEngine &Diags;
+
+  ClangInvocationFileMappingContext(
+    const LangOptions &LangOpts, SearchPathOptions &SearchPathOpts,
+    ClangImporterOptions &ClangImporterOpts, const CASOptions &CASOpts,
+    DiagnosticEngine &Diags)
+    : LangOpts(LangOpts), SearchPathOpts(SearchPathOpts),
+      ClangImporterOpts(ClangImporterOpts), CASOpts(CASOpts),
+      Diags(Diags) {}
+
+  virtual void *Allocate(unsigned long bytes, unsigned alignment) const = 0;
+
+  template <typename T>
+  MutableArrayRef<T> Allocate(unsigned numElts) const {
+    T *res = (T *) Allocate(sizeof(T) * numElts, alignof(T));
+    for (unsigned i = 0; i != numElts; ++i)
+      new (res+i) T();
+    return {res, numElts};
+  }
+};
+
 /// On Linux, some platform libraries (glibc, libstdc++) are not modularized.
 /// We inject modulemaps for those libraries into their include directories
 /// to allow using them from Swift.
@@ -892,6 +921,11 @@ ClangInvocationFileMapping getClangInvocationFileMapping(
     llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> vfs = nullptr,
     bool suppressDiagnostic = false);
 
+ClangInvocationFileMapping getClangInvocationFileMapping(
+    const ClangInvocationFileMappingContext &ctx,
+    llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> vfs = nullptr,
+    bool suppressDiagnostic = false);
+
 /// Apply the given file mapping to the specified 'fileSystem', used
 /// primarily to inject modulemaps on platforms with non-modularized
 /// platform libraries.
@@ -901,6 +935,12 @@ ClangInvocationFileMapping applyClangInvocationMapping(
     llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> &fileSystem,
     bool suppressDiagnostics = false);
 
+ClangInvocationFileMapping applyClangInvocationMapping(
+    const ClangInvocationFileMappingContext &ctx,
+    llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> baseVFS,
+    llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> &fileSystem,
+    bool suppressDiagnostics = false);
+
 /// Information used to compute the access level of inherited C++ members.
 class ClangInheritanceInfo {
   /// The cumulative inheritance access specifier, that is used to compute the
diff --git a/include/swift/Frontend/Frontend.h b/include/swift/Frontend/Frontend.h
@@ -49,6 +49,7 @@
 #include "llvm/CAS/ActionCache.h"
 #include "llvm/CAS/ObjectStore.h"
 #include "llvm/Option/ArgList.h"
+#include "llvm/Support/Allocator.h"
 #include "llvm/Support/BLAKE3.h"
 #include "llvm/Support/HashingOutputBackend.h"
 #include "llvm/Support/MemoryBuffer.h"
@@ -562,6 +563,8 @@ class CompilerInstance {
 
   bool isWholeModuleCompilation() const { return PrimaryBufferIDs.empty(); }
 
+  llvm::BumpPtrAllocator ClangInvocationFileMappingAllocator;
+
 public:
   // Out of line to avoid having to import SILModule.h.
   CompilerInstance();
diff --git a/lib/ClangImporter/ClangIncludePaths.cpp b/lib/ClangImporter/ClangIncludePaths.cpp
@@ -200,8 +200,25 @@ ClangImporter::createClangArgs(const ClangImporterOptions &ClangImporterOpts,
   return clangDriverArgs;
 }
 
+namespace {
+class ClangInvocationFileMappingContextWithASTContext
+  : public ClangInvocationFileMappingContext {
+  const ASTContext &Ctx;
+
+public:
+  ClangInvocationFileMappingContextWithASTContext(const ASTContext &Ctx)
+    : ClangInvocationFileMappingContext(Ctx.LangOpts, Ctx.SearchPathOpts,
+          Ctx.ClangImporterOpts, Ctx.CASOpts, Ctx.Diags), Ctx(Ctx) {}
+
+  void *Allocate(unsigned long bytes, unsigned alignment) const override {
+    return Ctx.Allocate(bytes, alignment);
+  }
+};
+} // namespace
+
 static SmallVector<std::pair<std::string, std::string>, 2>
-getLibcFileMapping(const ASTContext &ctx, StringRef modulemapFileName,
+getLibcFileMapping(const ClangInvocationFileMappingContext &ctx,
+                   StringRef modulemapFileName,
                    std::optional<ArrayRef<StringRef>> maybeHeaderFileNames,
                    const llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> &vfs,
                    bool suppressDiagnostic) {
@@ -267,7 +284,8 @@ getLibcFileMapping(const ASTContext &ctx, StringRef modulemapFileName,
 }
 
 static void getLibStdCxxFileMapping(
-    ClangInvocationFileMapping &fileMapping, const ASTContext &ctx,
+    ClangInvocationFileMapping &fileMapping,
+    const ClangInvocationFileMappingContext &ctx,
     const llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> &vfs,
     bool suppressDiagnostic) {
   assert(ctx.LangOpts.EnableCXXInterop &&
@@ -472,7 +490,8 @@ GetPlatformAuxiliaryFile(StringRef Platform, StringRef File,
 }
 
 void GetWindowsFileMappings(
-    ClangInvocationFileMapping &fileMapping, const ASTContext &Context,
+    ClangInvocationFileMapping &fileMapping,
+    const ClangInvocationFileMappingContext &Context,
     const llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> &driverVFS,
     bool &requiresBuiltinHeadersInSystemModules) {
   const llvm::Triple &Triple = Context.LangOpts.Target;
@@ -612,7 +631,16 @@ void GetWindowsFileMappings(
 } // namespace
 
 ClangInvocationFileMapping swift::getClangInvocationFileMapping(
-  const ASTContext &ctx, llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> vfs,
+  const ASTContext &ctx,
+  llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> vfs,
+  bool suppressDiagnostic) {
+  ClangInvocationFileMappingContextWithASTContext Ctx(ctx);
+  return getClangInvocationFileMapping(Ctx, vfs, suppressDiagnostic);
+}
+
+ClangInvocationFileMapping swift::getClangInvocationFileMapping(
+  const ClangInvocationFileMappingContext &ctx,
+  llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> vfs,
   bool suppressDiagnostic) {
   ClangInvocationFileMapping result;
   if (!vfs)
@@ -683,10 +711,21 @@ ClangInvocationFileMapping swift::getClangInvocationFileMapping(
   return result;
 }
 
-ClangInvocationFileMapping swift::applyClangInvocationMapping(const ASTContext &ctx,
-                                        llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> baseVFS,
-                                        llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> &fileSystem,
-                                        bool suppressDiagnostics) {
+ClangInvocationFileMapping swift::applyClangInvocationMapping(
+    const ASTContext &ctx,
+    llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> baseVFS,
+    llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> &fileSystem,
+    bool suppressDiagnostics) {
+  ClangInvocationFileMappingContextWithASTContext Ctx(ctx);
+  return applyClangInvocationMapping(Ctx, baseVFS, fileSystem,
+      suppressDiagnostics);
+}
+
+ClangInvocationFileMapping swift::applyClangInvocationMapping(
+    const ClangInvocationFileMappingContext &ctx,
+    llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> baseVFS,
+    llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> &fileSystem,
+    bool suppressDiagnostics) {
   if (ctx.CASOpts.HasImmutableFileSystem)
     return ClangInvocationFileMapping();
 
diff --git a/lib/DependencyScan/ModuleDependencyScanner.cpp b/lib/DependencyScan/ModuleDependencyScanner.cpp
@@ -1992,6 +1992,14 @@ ModuleDependencyInfo ModuleDependencyScanner::bridgeClangModuleDependency(
     }
   }
 
+  // Pass the -sdk flag to make the system header VFS overlay finable
+  // for the -direct-clang-cc1-module-build emit-pcm command on Windows.
+  StringRef SDKPath = ScanASTContext.SearchPathOpts.getSDKPath();
+  if (!SDKPath.empty()) {
+    swiftArgs.push_back("-sdk");
+    swiftArgs.push_back(SDKPath.str());
+  }
+
   // Add args reported by the scanner.
   auto clangArgs = invocation.getCC1CommandLine();
   llvm::for_each(clangArgs, addClangArg);
diff --git a/lib/Frontend/Frontend.cpp b/lib/Frontend/Frontend.cpp
@@ -365,6 +365,15 @@ bool CompilerInstance::setUpASTContextIfNeeded() {
       Invocation.getLangOptions().DebuggerSupport)
     Invocation.getLangOptions().EnableDeserializationSafety = false;
 
+  if (!Invocation.getCASOptions().requireCASFS() &&
+      Invocation.getClangImporterOptions().DirectClangCC1ModuleBuild &&
+      Invocation.getFrontendOptions().RequestedAction ==
+          FrontendOptions::ActionType::EmitPCM) {
+    // For non-caching builds, transfer the ownership to the ASTContext.
+    Context->ClangInvocationFileMappingAllocator =
+        std::move(ClangInvocationFileMappingAllocator);
+  }
+
   if (setUpModuleLoaders())
     return true;
   if (setUpPluginLoader())
@@ -559,6 +568,26 @@ void CompilerInstance::setupCachingDiagnosticsProcessorIfNeeded() {
   CDP->startDiagnosticCapture();
 }
 
+namespace {
+// This is used before ASTContext is initialized.
+class ClangInvocationFileMappingContextPreASTContext
+  : public ClangInvocationFileMappingContext {
+  llvm::BumpPtrAllocator &Allocator;
+
+public:
+  ClangInvocationFileMappingContextPreASTContext(
+    const LangOptions &LangOpts, SearchPathOptions &SearchPathOpts,
+    ClangImporterOptions &ClangImporterOpts, const CASOptions &CASOpts,
+    DiagnosticEngine &Diags, llvm::BumpPtrAllocator &Allocator)
+    : ClangInvocationFileMappingContext(LangOpts, SearchPathOpts,
+          ClangImporterOpts, CASOpts, Diags), Allocator(Allocator) {}
+
+  void *Allocate(unsigned long bytes, unsigned alignment) const override {
+    return Allocator.Allocate(bytes, alignment);
+  }
+};
+} // namespace
+
 bool CompilerInstance::setup(const CompilerInvocation &Invoke,
                              std::string &Error, ArrayRef<const char *> Args) {
   Invocation = Invoke;
@@ -708,6 +737,25 @@ bool CompilerInstance::setUpVirtualFileSystemOverlays() {
         new llvm::vfs::OverlayFileSystem(MemFS);
     OverlayVFS->pushOverlay(SourceMgr.getFileSystem());
     SourceMgr.setFileSystem(std::move(OverlayVFS));
+  } else {
+    // For non-caching -direct-clang-cc1-module-build emit-pcm build,
+    // setup the clang VFS so it can find system modulemap files
+    // (like vcruntime.modulemap) as an input file.
+    if (Invocation.getClangImporterOptions().DirectClangCC1ModuleBuild &&
+        Invocation.getFrontendOptions().RequestedAction ==
+            FrontendOptions::ActionType::EmitPCM) {
+      llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS =
+          SourceMgr.getFileSystem();
+      ClangInvocationFileMappingContextPreASTContext ClangContext(
+          Invocation.getLangOptions(), Invocation.getSearchPathOptions(),
+          Invocation.getClangImporterOptions(), Invocation.getCASOptions(),
+          Diagnostics, ClangInvocationFileMappingAllocator);
+      ClangInvocationFileMapping FileMapping = applyClangInvocationMapping(
+          ClangContext, nullptr, VFS, /*suppressDiagnostic=*/false);
+      if (!FileMapping.redirectedFiles.empty()) {
+        SourceMgr.setFileSystem(std::move(VFS));
+      }
+    }
   }
 
   auto ExpectedOverlay =
diff --git a/test/ScanDependencies/Inputs/WinSDK/usr/share/vcruntime.modulemap b/test/ScanDependencies/Inputs/WinSDK/usr/share/vcruntime.modulemap
@@ -0,0 +1,4 @@
+module SAL [system] {
+  header "sal.h"
+  export *
+}
diff --git a/test/ScanDependencies/direct-clang-cc1-emit-pcm-vfs-overlay.swift b/test/ScanDependencies/direct-clang-cc1-emit-pcm-vfs-overlay.swift
@@ -0,0 +1,13 @@
+// REQUIRES: OS=windows-msvc
+
+// Test that the -direct-clang-cc1-module-build is able to create a module from the VC runtime with an overlaid modulemap file
+
+// RUN: %empty-directory(%t)
+// RUN: split-file %s %t
+
+// RUN: %swift_frontend_plain -target %target-triple -module-cache-path %t/clang-module-cache -scan-dependencies -module-name Test -sdk %S/Inputs/WinSDK %t/Test.swift -o %t/deps.json
+// RUN: %{python} %S/../CAS/Inputs/BuildCommandExtractor.py %t/deps.json clang:SAL > %t/SAL.cmd
+// RUN: %swift_frontend_plain @%t/SAL.cmd
+
+//--- Test.swift
+import SAL

Original file line number	Diff line number	Diff line change
`@@ -1992,6 +1992,14 @@ ModuleDependencyInfo ModuleDependencyScanner::bridgeClangModuleDependency(`
`1992`	`1992`	`}`
`1993`	`1993`	`}`
`1994`	`1994`
	`1995`	`+ // Pass the -sdk flag to make the system header VFS overlay finable`
	`1996`	`+ // for the -direct-clang-cc1-module-build emit-pcm command on Windows.`
	`1997`	`+ StringRef SDKPath = ScanASTContext.SearchPathOpts.getSDKPath();`
	`1998`	`+ if (!SDKPath.empty()) {`
	`1999`	`+ swiftArgs.push_back("-sdk");`
	`2000`	`+ swiftArgs.push_back(SDKPath.str());`
	`2001`	`+ }`
	`2002`	`+`
`1995`	`2003`	`// Add args reported by the scanner.`
`1996`	`2004`	`auto clangArgs = invocation.getCC1CommandLine();`
`1997`	`2005`	`llvm::for_each(clangArgs, addClangArg);`