Make `-fmodule-file=<name>=<path>` apply to .pcm file compilations

[andrewjcg]

Summary

When precompiling a header module, -fmodule-file=name>=<path> flags
can be used to provide an updated path to a module, which allows modules
to be moved from the location they were compiled against.

This diff makes these flags also apply to when compiling a .pcm file
into a .o.

[dblaikie]

Looks reasonable to me, but I don't know a great deal about the PrebuiltModuleFiles & so I'd like @rsmith to at least glance at/approve this.

[modocache]

This seems like a outright improvement, but as mentioned above it would be nice to get @rsmith's take on it since I'm not an expert. Two nitpicks, though:

1. Could you please run clang-format on the lines you added/modified?
2. Could you apply these changes on top of the llvm-project monorepo? You can do so by using the "download raw diff" link on this page, and then running git apply --directory=clang -p 0 D70219.diff from within the monorepo. I tried just now to confirm the tests pass with this change (they do!), and that command was able to apply the patch cleanly for me.

lib/Frontend/FrontendAction.cpp

568 ↗

(On Diff #229226)

For example I think this line would change if clang-format were to be run on it.

[andrewjcg]

rebase onto monorepo and clang-format

clang/include/clang/Frontend/ASTUnit.h

public:
   /// Create a ASTUnit from an AST file.
   ///
   /// \param Filename - The AST file to load.
   ///
   /// \param PCHContainerRdr - The PCHContainerOperations to use for loading and
   /// creating modules.
   /// \param Diags - The diagnostics engine to use for reporting errors; its
   /// lifetime is expected to extend past that of the returned ASTUnit.
+  /// \param PrebuiltModuleFiles - A map for module names to prebuilt module
+  /// paths.
   ///
   /// \returns - The initialized ASTUnit or null if the AST failed to load.
   static std::unique_ptr<ASTUnit> LoadFromASTFile(
       const std::string &Filename, const PCHContainerReader &PCHContainerRdr,
       WhatToLoad ToLoad, IntrusiveRefCntPtr<DiagnosticsEngine> Diags,
       const FileSystemOptions &FileSystemOpts, bool UseDebugInfo = false,
       bool OnlyLocalDecls = false, ArrayRef<RemappedFile> RemappedFiles = None,
       CaptureDiagsKind CaptureDiagnostics = CaptureDiagsKind::None,
       bool AllowPCHWithCompilerErrors = false,
-      bool UserFilesAreVolatile = false);
+      bool UserFilesAreVolatile = false,
+      const std::map<std::string, std::string> &PrebuiltModuleFiles = {});
 
 private:
   /// Helper function for \c LoadFromCompilerInvocation() and
   /// \c LoadFromCommandLine(), which loads an AST from a compiler invocation.
   ///
   /// \param PrecompilePreambleAfterNParses After how many parses the preamble
   /// of this translation unit should be precompiled, to improve the performance
   /// of reparsing. Set to zero to disable preambles.

clang/lib/Frontend/ASTUnit.cpp

 }
 
 std::unique_ptr<ASTUnit> ASTUnit::LoadFromASTFile(
     const std::string &Filename, const PCHContainerReader &PCHContainerRdr,
     WhatToLoad ToLoad, IntrusiveRefCntPtr<DiagnosticsEngine> Diags,
     const FileSystemOptions &FileSystemOpts, bool UseDebugInfo,
     bool OnlyLocalDecls, ArrayRef<RemappedFile> RemappedFiles,
     CaptureDiagsKind CaptureDiagnostics, bool AllowPCHWithCompilerErrors,
-    bool UserFilesAreVolatile) {
+    bool UserFilesAreVolatile,
+    const std::map<std::string, std::string> &PrebuiltModuleFiles) {
   std::unique_ptr<ASTUnit> AST(new ASTUnit(true));
 
   // Recover resources if we crash before exiting this method.
   llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
     ASTUnitCleanup(AST.get());
   llvm::CrashRecoveryContextCleanupRegistrar<DiagnosticsEngine,
     llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine>>
     DiagCleanup(Diags.get());
std::unique_ptr<ASTUnit> ASTUnit::LoadFromASTFile(
   AST->FileMgr = new FileManager(FileSystemOpts, VFS);
   AST->UserFilesAreVolatile = UserFilesAreVolatile;
   AST->SourceMgr = new SourceManager(AST->getDiagnostics(),
                                      AST->getFileManager(),
                                      UserFilesAreVolatile);
   AST->ModuleCache = new InMemoryModuleCache;
   AST->HSOpts = std::make_shared<HeaderSearchOptions>();
   AST->HSOpts->ModuleFormat = PCHContainerRdr.getFormat();
+  AST->HSOpts->PrebuiltModuleFiles = PrebuiltModuleFiles;
   AST->HeaderInfo.reset(new HeaderSearch(AST->HSOpts,
                                          AST->getSourceManager(),
                                          AST->getDiagnostics(),
                                          AST->getLangOpts(),
                                          /*Target=*/nullptr));
   AST->PPOpts = std::make_shared<PreprocessorOptions>();
 
   for (const auto &RemappedFile : RemappedFiles)

clang/lib/Frontend/FrontendAction.cpp

IntrusiveRefCntPtr<DiagnosticsEngine> ASTDiags(
                               &Diags->getDiagnosticOptions()));
     ASTDiags->setClient(Diags->getClient(), /*OwnsClient*/false);
 
     // FIXME: What if the input is a memory buffer?
     StringRef InputFile = Input.getFile();
 
     std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromASTFile(
         InputFile, CI.getPCHContainerReader(), ASTUnit::LoadPreprocessorOnly,
-        ASTDiags, CI.getFileSystemOpts(), CI.getCodeGenOpts().DebugTypeExtRefs);
+        ASTDiags, CI.getFileSystemOpts(), CI.getCodeGenOpts().DebugTypeExtRefs,
+        false, None, CaptureDiagsKind::None, false, false,
+        CI.getHeaderSearchOpts().PrebuiltModuleFiles);
     if (!AST)
       goto failure;
 
     // Options relating to how we treat the input (but not what we do with it)
     // are inherited from the AST unit.
     CI.getHeaderSearchOpts() = AST->getHeaderSearchOpts();
     CI.getPreprocessorOpts() = AST->getPreprocessorOpts();
     CI.getLangOpts() = AST->getLangOpts();
if (Input.getKind().getFormat() == InputKind::Precompiled) {
 
     IntrusiveRefCntPtr<DiagnosticsEngine> Diags(&CI.getDiagnostics());
 
     // FIXME: What if the input is a memory buffer?
     StringRef InputFile = Input.getFile();
 
     std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromASTFile(
         InputFile, CI.getPCHContainerReader(), ASTUnit::LoadEverything, Diags,
-        CI.getFileSystemOpts(), CI.getCodeGenOpts().DebugTypeExtRefs);
+        CI.getFileSystemOpts(), CI.getCodeGenOpts().DebugTypeExtRefs, false,
+        None, CaptureDiagsKind::None, false, false,
+        CI.getHeaderSearchOpts().PrebuiltModuleFiles);
 
     if (!AST)
       goto failure;
 
     // Inform the diagnostic client we are processing a source file.
     CI.getDiagnosticClient().BeginSourceFile(CI.getLangOpts(), nullptr);
     HasBegunSourceFile = true;
 

clang/test/Modules/Inputs/explicit-build-pcm/a.h

+#if !__building_module(a) && !BUILDING_A_PCH
+#error "should only get here when building module a"
+#endif
+
+const int a = 1;

clang/test/Modules/Inputs/explicit-build-pcm/b.h

+#include "a.h"
+
+#if !__building_module(b)
+#error "should only get here when building module b"
+#endif
+
+const int b = 2;

clang/test/Modules/Inputs/explicit-build-pcm/c.h

+#include "b.h"
+
+#if !__building_module(c)
+#error "should only get here when building module c"
+#endif
+
+const int c = 3;

clang/test/Modules/Inputs/explicit-build-pcm/module.modulemap

+module a { header "a.h" }
+module b { header "b.h" export * }
+module c { header "c.h" export * }
+module d { header "d.h" }

clang/test/Modules/explicit-build-pcm.cpp

+// RUN: rm -rf %t
+// expected-no-diagnostics
+
+// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \
+// RUN:            -fmodule-name=a -emit-module %S/Inputs/explicit-build/module.modulemap -o %t/a.pcm
+
+// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \
+// RUN:            -fmodule-file=a=%t/a.pcm \
+// RUN:            -fmodule-name=b -emit-module %S/Inputs/explicit-build/module.modulemap -o %t/b.pcm
+
+// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \
+// RUN:            -fmodule-file=a=%t/a.pcm \
+// RUN:            -fmodule-file=b=%t/b.pcm \
+// RUN:            -fmodule-name=c -emit-module %S/Inputs/explicit-build/module.modulemap -o %t/c.pcm
+
+// RUN: mv %t/a.pcm %t/a.moved.pcm
+// RUN: mv %t/b.pcm %t/b.moved.pcm
+// RUN: mv %t/c.pcm %t/c.moved.pcm
+//
+// RUN: %clang_cc1 -x pcm -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \
+// RUN:            -fmodule-file=a=%t/a.moved.pcm \
+// RUN:            -fmodule-file=b=%t/b.moved.pcm \
+// RUN:            %t/c.moved.pcm -o %t/c.o
+// expected-no-diagnostics
+
+#include <stdio.h>