[clang][modules] Serialize VFS overlay paths into PCMs

[jansvoboda11]

Summary

With implicitly built modules, the importing CompilerInstance assumes PCMs were built in a "compatible way" (i.e. with similarly set up instance). Either because their context hash matches, or because this instance has just built them.

There are some use-cases, however, where this assumption doesn't hold, libclang/c-index-test being one of them. There, the importing instance (or ASTUnit) is being set up while the PCM file is being deserialized. Until now, we've assumed the serialized paths to input files are the actual on-disk files, meaning the default physical VFS was always able to resolve them. This won't be the case after D135636. Therefore, this patch makes sure ASTUnit is initialized with the same VFS as the PCM it's deserializing - by storing paths to the VFS overlay files into the PCM itself.

For the VFS overlay files to be adopted at the very start of PCM deserialization, they are stored in a new section in the unhashed control block, together with header search paths and system header prefixes. The move to the unhashed control block should be safe: if two modules were built with different header search paths and they produced different results, the hashed part of the PCM file will reflect that.

[akyrtzi]

This seems fine to me but note that we no longer depend on the functionality that test/Index/index-module-with-vfs.m is testing (and not sure anyone else does), so if there is another change affecting it that is more complicated we could consider removing the test.

clang/include/clang/Frontend/CompilerInvocation.h

298

The idiomatic LLVM way is to use ArrayRef for the parameter.

[akyrtzi]

clang/lib/Frontend/CompilerInvocation.cpp

4741

A bit nitpick but I'd suggest changing to std::move(BaseFS)

[jansvoboda11]

In D135634#3850224, @akyrtzi wrote:

This seems fine to me but note that we no longer depend on the functionality that test/Index/index-module-with-vfs.m is testing (and not sure anyone else does), so if there is another change affecting it that is more complicated we could consider removing the test.

Thanks, good to know. Other users of ASTUnit might be relying on that (e.g. replay AST), so still I think it would be nice to land this. Though it seems this requires D67010 ([Modules] Move search paths from control block to unhashed control block). That's because the unhashed control block is read before we start validating imports (and their input files). Without that patch, test/Index/index-module-with-vfs.m still starts to fail in D135636. Another solution would be to ensure the options block is serialized at the start of the control block.

[jansvoboda11]

Use ArrayRef, move VFS smart pointer

[benlangmuir]

I think we should deduplicate the vfs overlays if the same ivfsoverlay is specified in both the pcm and the command-line.

@bnbarham any concern about overlay vs chaining behaviour here? I remember you looking at that a while ago.

[bnbarham]

In D135634#3866353, @benlangmuir wrote:

I think we should deduplicate the vfs overlays if the same ivfsoverlay is specified in both the pcm and the command-line.

@bnbarham any concern about overlay vs chaining behaviour here? I remember you looking at that a while ago.

It still chains right now since I never ended up finishing those patches. This does explicitly *chain* with the command-line specified FS, not sure if one makes sense over the other here. Should we be passing in the real FS to the overlay creation here and then creating an actual overlay FS with both the original FileManager VFS + the PCM VFS (or building the overlay from scratch with the original overlays as well, though that still chains so...)?

Do reproducers read PCMs at all or do they rebuild from the headers?

[jansvoboda11]

In D135634#3866353, @benlangmuir wrote:

I think we should deduplicate the vfs overlays if the same ivfsoverlay is specified in both the pcm and the command-line.

My understanding is that ASTUnit never uses command-line and always adopts whatever is in the PCM.

In D135634#3866528, @bnbarham wrote:

Do reproducers read PCMs at all or do they rebuild from the headers?

I don't know. How are they related to this patch?

[bnbarham]

In D135634#3866704, @jansvoboda11 wrote:

In D135634#3866353, @benlangmuir wrote:

I think we should deduplicate the vfs overlays if the same ivfsoverlay is specified in both the pcm and the command-line.

My understanding is that ASTUnit never uses command-line and always adopts whatever is in the PCM.

It's now using the FS from FileManager as the base FS and I imagine was already just using the FileManager FS, so we are (and were) implicitly using the command-line overlays.

In D135634#3866528, @bnbarham wrote:

Do reproducers read PCMs at all or do they rebuild from the headers?

I don't know. How are they related to this patch?

It was more related to the chaining discussion. If reproducers do use PCMs then that would imply we *have* to chain, since we'd need to map from the path in the PCM -> original path (with PCM overlay) -> reproducer path (with reproducer overlay).

I suspect the answer is here is that they don't as it'd be easier to just include all the headers (I think?).

[jansvoboda11]

Ah, I now see that there are modes where ASTUnit gets configured with command-line arguments.

I'm not very familiar with its clients, but I'd be inclined to:

1. If the original HeaderSearchOptions didn't have any VFS overlay files, adopt the PCM ones.
2. If the original HeaderSearchOptions did have VFS overlay files of its own, error out if the PCM has different ones.

Any thoughts?

[jansvoboda11]

Move header search paths into unhashed control block.

[benlangmuir]

If the original HeaderSearchOptions didn't have any VFS overlay files, adopt the PCM ones.

IIUC this is what the patch does, right?

If the original HeaderSearchOptions did have VFS overlay files of its own, error out if the PCM has different ones.

Where did we land on this on?

clang/include/clang/Serialization/ASTReader.h

179

We should document what the expectations are for ReadHeaderSearchOptions and ReadHeaderSearchPaths callbacks: will paths be set when ReadHeaderSearchOptions is called? Will non-paths be set when ReadHeaderSearchPaths is called? I assume we want to say "no" so that we're not tied to callback order, but we should document it.

[jansvoboda11]

In D135634#3967718, @benlangmuir wrote:

If the original HeaderSearchOptions didn't have any VFS overlay files, adopt the PCM ones.

IIUC this is what the patch does, right?

Yes, that's correct.

If the original HeaderSearchOptions did have VFS overlay files of its own, error out if the PCM has different ones.

Where did we land on this on?

We didn't. I looked into the current behavior once again and noticed that for language options and the target, we adopt whatever the PCM reports for the first time the ASTReader callbacks get called and ignore everything else. I didn't want to complicate things beyond that, since @akyrtzi mentioned this mode of ASTUnit (adopting stuff from PCMs) isn't being actively used anyways, so I did the same thing.

clang/include/clang/Serialization/ASTReader.h

179

Sounds good.

[benlangmuir]

Thanks for the explanation, make sense. LGTM with the documentation tweak!

clang/include/clang/Frontend/CompilerInvocation.h

 IntrusiveRefCntPtr<llvm::vfs::FileSystem>
 createVFSFromCompilerInvocation(const CompilerInvocation &CI,
                                 DiagnosticsEngine &Diags);
 
 IntrusiveRefCntPtr<llvm::vfs::FileSystem> createVFSFromCompilerInvocation(
     const CompilerInvocation &CI, DiagnosticsEngine &Diags,
     IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS);
 
+IntrusiveRefCntPtr<llvm::vfs::FileSystem>
+createVFSFromOverlayFiles(ArrayRef<std::string> VFSOverlayFiles,
+                          DiagnosticsEngine &Diags,
+                          IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS);
+
 } // namespace clang
 
 #endif // LLVM_CLANG_FRONTEND_COMPILERINVOCATION_H

clang/include/clang/Serialization/ASTBitCodes.h

 /// Whenever the AST file format changes in a way that makes it
 /// incompatible with previous versions (such that a reader
 /// designed for the previous version could not support reading
 /// the new version), this number should be increased.
 ///
 /// Version 4 of AST files also requires that the version control branch and
 /// revision match exactly, since there is no backward compatibility of
 /// AST files at this time.
-const unsigned VERSION_MAJOR = 24;
+const unsigned VERSION_MAJOR = 25;
 
 /// AST file minor version number supported by this version of
 /// Clang.
 ///
 /// Whenever the AST format changes in a way that is still
 /// compatible with previous versions (such that a reader designed
 /// for the previous version could still support reading the new
 /// version by ignoring new kinds of subblocks), this number
enum UnhashedControlBlockRecordTypes {
   SIGNATURE = 1,
 
   /// Record code for the content hash of the AST block.
   AST_BLOCK_HASH,
 
   /// Record code for the diagnostic options table.
   DIAGNOSTIC_OPTIONS,
 
+  /// Record code for the headers search paths.
+  HEADER_SEARCH_PATHS,
+
   /// Record code for \#pragma diagnostic mappings.
   DIAG_PRAGMA_MAPPINGS,
 
   /// Record code for the indices of used header search entries.
   HEADER_SEARCH_ENTRY_USAGE,
 };
 
 /// Record code for extension blocks.

clang/include/clang/Serialization/ASTReader.h

public:
   /// \returns true to indicate the header search options are invalid, or false
   /// otherwise.
   virtual bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
                                        StringRef SpecificModuleCachePath,
                                        bool Complain) {
     return false;
   }
 
+  /// Receives the header search paths.
+  ///
+  /// \returns true to indicate the header search paths are invalid, or false
+  /// otherwise.
+  virtual bool ReadHeaderSearchPaths(const HeaderSearchOptions &HSOpts,
+                                     bool Complain) {
+    return false;
+  }
+
   /// Receives the preprocessor options.
   ///
   /// \param SuggestedPredefines Can be filled in with the set of predefines
   /// that are suggested by the preprocessor options. Typically only used when
   /// loading a precompiled header.
   ///
   /// \returns true to indicate the preprocessor options are invalid, or false
   /// otherwise.
static bool ParseTargetOptions(const RecordData &Record, bool Complain,
                                  ASTReaderListener &Listener,
                                  bool AllowCompatibleDifferences);
   static bool ParseDiagnosticOptions(const RecordData &Record, bool Complain,
                                      ASTReaderListener &Listener);
   static bool ParseFileSystemOptions(const RecordData &Record, bool Complain,
                                      ASTReaderListener &Listener);
   static bool ParseHeaderSearchOptions(const RecordData &Record, bool Complain,
                                        ASTReaderListener &Listener);
+  static bool ParseHeaderSearchPaths(const RecordData &Record, bool Complain,
+                                     ASTReaderListener &Listener);
   static bool ParsePreprocessorOptions(const RecordData &Record, bool Complain,
                                        ASTReaderListener &Listener,
                                        std::string &SuggestedPredefines);
 
   struct RecordLocation {
     ModuleFile *F;
     uint64_t Offset;
 

clang/lib/Frontend/ASTUnit.cpp

 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CrashRecoveryContext.h"
 #include "llvm/Support/DJB.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/SaveAndRestore.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <atomic>
 #include <cassert>
 #include <cstdint>
 #include <cstdio>
class ASTInfoCollector : public ASTReaderListener {
   ASTContext *Context;
   HeaderSearchOptions &HSOpts;
   PreprocessorOptions &PPOpts;
   LangOptions &LangOpt;
   std::shared_ptr<TargetOptions> &TargetOpts;
   IntrusiveRefCntPtr<TargetInfo> &Target;
   unsigned &Counter;
   bool InitializedLanguage = false;
+  bool InitializedHeaderSearchPaths = false;
 
 public:
   ASTInfoCollector(Preprocessor &PP, ASTContext *Context,
                    HeaderSearchOptions &HSOpts, PreprocessorOptions &PPOpts,
                    LangOptions &LangOpt,
                    std::shared_ptr<TargetOptions> &TargetOpts,
                    IntrusiveRefCntPtr<TargetInfo> &Target, unsigned &Counter)
       : PP(PP), Context(Context), HSOpts(HSOpts), PPOpts(PPOpts),
bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
 
     updated();
     return false;
   }
 
   bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
                                StringRef SpecificModuleCachePath,
                                bool Complain) override {
+    // Preserve previously set header search paths.
+    llvm::SaveAndRestore X(this->HSOpts.UserEntries);
+    llvm::SaveAndRestore Y(this->HSOpts.SystemHeaderPrefixes);
+    llvm::SaveAndRestore Z(this->HSOpts.VFSOverlayFiles);
+
     this->HSOpts = HSOpts;
+
+    return false;
+  }
+
+  bool ReadHeaderSearchPaths(const HeaderSearchOptions &HSOpts,
+                             bool Complain) override {
+    if (InitializedHeaderSearchPaths)
+      return false;
+
+    this->HSOpts.UserEntries = HSOpts.UserEntries;
+    this->HSOpts.SystemHeaderPrefixes = HSOpts.SystemHeaderPrefixes;
+    this->HSOpts.VFSOverlayFiles = HSOpts.VFSOverlayFiles;
+
+    // Initialize the FileManager. We can't do this in update(), since that
+    // performs the initialization too late (once both target and language
+    // options are read).
+    PP.getFileManager().setVirtualFileSystem(createVFSFromOverlayFiles(
+        HSOpts.VFSOverlayFiles, PP.getDiagnostics(),
+        PP.getFileManager().getVirtualFileSystemPtr()));
+
+    InitializedHeaderSearchPaths = true;
+
     return false;
   }
 
   bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool Complain,
                                std::string &SuggestedPredefines) override {
     this->PPOpts = PPOpts;
     return false;
   }

clang/lib/Frontend/CompilerInvocation.cpp

clang::createVFSFromCompilerInvocation(const CompilerInvocation &CI,
   return createVFSFromCompilerInvocation(CI, Diags,
                                          llvm::vfs::getRealFileSystem());
 }
 
 IntrusiveRefCntPtr<llvm::vfs::FileSystem>
 clang::createVFSFromCompilerInvocation(
     const CompilerInvocation &CI, DiagnosticsEngine &Diags,
     IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS) {
-  if (CI.getHeaderSearchOpts().VFSOverlayFiles.empty())
+  return createVFSFromOverlayFiles(CI.getHeaderSearchOpts().VFSOverlayFiles,
+                                   Diags, std::move(BaseFS));
+}
+
+IntrusiveRefCntPtr<llvm::vfs::FileSystem> clang::createVFSFromOverlayFiles(
+    ArrayRef<std::string> VFSOverlayFiles, DiagnosticsEngine &Diags,
+    IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS) {
+  if (VFSOverlayFiles.empty())
     return BaseFS;
 
   IntrusiveRefCntPtr<llvm::vfs::FileSystem> Result = BaseFS;
   // earlier vfs files are on the bottom
-  for (const auto &File : CI.getHeaderSearchOpts().VFSOverlayFiles) {
+  for (const auto &File : VFSOverlayFiles) {
     llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
         Result->getBufferForFile(File);
     if (!Buffer) {
       Diags.Report(diag::err_missing_vfs_overlay_file) << File;
       continue;
     }
 
     IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS = llvm::vfs::getVFSFromYAML(

clang/lib/Serialization/ASTReader.cpp

while (true) {
     case DIAGNOSTIC_OPTIONS: {
       bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
       if (Listener && ValidateDiagnosticOptions &&
           !AllowCompatibleConfigurationMismatch &&
           ParseDiagnosticOptions(Record, Complain, *Listener))
         Result = OutOfDate; // Don't return early.  Read the signature.
       break;
     }
+    case HEADER_SEARCH_PATHS: {
+      bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
+      if (!AllowCompatibleConfigurationMismatch &&
+          ParseHeaderSearchPaths(Record, Complain, *Listener))
+        Result = ConfigurationMismatch;
+      break;
+    }
     case DIAG_PRAGMA_MAPPINGS:
       if (!F)
         break;
       if (F->PragmaDiagMappings.empty())
         F->PragmaDiagMappings.swap(Record);
       else
         F->PragmaDiagMappings.insert(F->PragmaDiagMappings.end(),
                                      Record.begin(), Record.end());

 
 bool ASTReader::ParseHeaderSearchOptions(const RecordData &Record,
                                          bool Complain,
                                          ASTReaderListener &Listener) {
   HeaderSearchOptions HSOpts;
   unsigned Idx = 0;
   HSOpts.Sysroot = ReadString(Record, Idx);
 
+  HSOpts.ResourceDir = ReadString(Record, Idx);
+  HSOpts.ModuleCachePath = ReadString(Record, Idx);
+  HSOpts.ModuleUserBuildPath = ReadString(Record, Idx);
+  HSOpts.DisableModuleHash = Record[Idx++];
+  HSOpts.ImplicitModuleMaps = Record[Idx++];
+  HSOpts.ModuleMapFileHomeIsCwd = Record[Idx++];
+  HSOpts.EnablePrebuiltImplicitModules = Record[Idx++];
+  HSOpts.UseBuiltinIncludes = Record[Idx++];
+  HSOpts.UseStandardSystemIncludes = Record[Idx++];
+  HSOpts.UseStandardCXXIncludes = Record[Idx++];
+  HSOpts.UseLibcxx = Record[Idx++];
+  std::string SpecificModuleCachePath = ReadString(Record, Idx);
+
+  return Listener.ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
+                                          Complain);
+}
+
+bool ASTReader::ParseHeaderSearchPaths(const RecordData &Record,
+                                       bool Complain,
+                                       ASTReaderListener &Listener) {
+  HeaderSearchOptions HSOpts;
+  unsigned Idx = 0;
+
   // Include entries.
   for (unsigned N = Record[Idx++]; N; --N) {
     std::string Path = ReadString(Record, Idx);
     frontend::IncludeDirGroup Group
       = static_cast<frontend::IncludeDirGroup>(Record[Idx++]);
     bool IsFramework = Record[Idx++];
     bool IgnoreSysRoot = Record[Idx++];
     HSOpts.UserEntries.emplace_back(std::move(Path), Group, IsFramework,
                                     IgnoreSysRoot);
   }
 
   // System header prefixes.
   for (unsigned N = Record[Idx++]; N; --N) {
     std::string Prefix = ReadString(Record, Idx);
     bool IsSystemHeader = Record[Idx++];
     HSOpts.SystemHeaderPrefixes.emplace_back(std::move(Prefix), IsSystemHeader);
   }
 
-  HSOpts.ResourceDir = ReadString(Record, Idx);
-  HSOpts.ModuleCachePath = ReadString(Record, Idx);
-  HSOpts.ModuleUserBuildPath = ReadString(Record, Idx);
-  HSOpts.DisableModuleHash = Record[Idx++];
-  HSOpts.ImplicitModuleMaps = Record[Idx++];
-  HSOpts.ModuleMapFileHomeIsCwd = Record[Idx++];
-  HSOpts.EnablePrebuiltImplicitModules = Record[Idx++];
-  HSOpts.UseBuiltinIncludes = Record[Idx++];
-  HSOpts.UseStandardSystemIncludes = Record[Idx++];
-  HSOpts.UseStandardCXXIncludes = Record[Idx++];
-  HSOpts.UseLibcxx = Record[Idx++];
-  std::string SpecificModuleCachePath = ReadString(Record, Idx);
+  // VFS overlay files.
+  for (unsigned N = Record[Idx++]; N; --N) {
+    std::string VFSOverlayFile = ReadString(Record, Idx);
+    HSOpts.VFSOverlayFiles.emplace_back(std::move(VFSOverlayFile));
+  }
 
-  return Listener.ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
-                                          Complain);
+  return Listener.ReadHeaderSearchPaths(HSOpts, Complain);
 }
 
 bool ASTReader::ParsePreprocessorOptions(const RecordData &Record,
                                          bool Complain,
                                          ASTReaderListener &Listener,
                                          std::string &SuggestedPredefines) {
   PreprocessorOptions PPOpts;
   unsigned Idx = 0;

clang/lib/Serialization/ASTWriter.cpp

#include "clang/Basic/DiagnosticOptions.def"
   Record.push_back(DiagOpts.Remarks.size());
   for (unsigned I = 0, N = DiagOpts.Remarks.size(); I != N; ++I)
     AddString(DiagOpts.Remarks[I], Record);
   // Note: we don't serialize the log or serialization file names, because they
   // are generally transient files and will almost always be overridden.
   Stream.EmitRecord(DIAGNOSTIC_OPTIONS, Record);
   Record.clear();
 
+  // Header search paths.
+  Record.clear();
+  const HeaderSearchOptions &HSOpts
+      = PP.getHeaderSearchInfo().getHeaderSearchOpts();
+
+  // Include entries.
+  Record.push_back(HSOpts.UserEntries.size());
+  for (unsigned I = 0, N = HSOpts.UserEntries.size(); I != N; ++I) {
+    const HeaderSearchOptions::Entry &Entry = HSOpts.UserEntries[I];
+    AddString(Entry.Path, Record);
+    Record.push_back(static_cast<unsigned>(Entry.Group));
+    Record.push_back(Entry.IsFramework);
+    Record.push_back(Entry.IgnoreSysRoot);
+  }
+
+  // System header prefixes.
+  Record.push_back(HSOpts.SystemHeaderPrefixes.size());
+  for (unsigned I = 0, N = HSOpts.SystemHeaderPrefixes.size(); I != N; ++I) {
+    AddString(HSOpts.SystemHeaderPrefixes[I].Prefix, Record);
+    Record.push_back(HSOpts.SystemHeaderPrefixes[I].IsSystemHeader);
+  }
+
+  // VFS overlay files.
+  Record.push_back(HSOpts.VFSOverlayFiles.size());
+  for (StringRef VFSOverlayFile : HSOpts.VFSOverlayFiles)
+    AddString(VFSOverlayFile, Record);
+
+  Stream.EmitRecord(HEADER_SEARCH_PATHS, Record);
+
   // Write out the diagnostic/pragma mappings.
   WritePragmaDiagnosticMappings(Diags, /* isModule = */ WritingModule);
 
   // Header search entry usage.
   auto HSEntryUsage = PP.getHeaderSearchInfo().computeUserEntryUsage();
   auto Abbrev = std::make_shared<BitCodeAbbrev>();
   Abbrev->Add(BitCodeAbbrevOp(HEADER_SEARCH_ENTRY_USAGE));
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Number of bits.
const FileSystemOptions &FSOpts =
       Context.getSourceManager().getFileManager().getFileSystemOpts();
   AddString(FSOpts.WorkingDir, Record);
   Stream.EmitRecord(FILE_SYSTEM_OPTIONS, Record);
 
   // Header search options.
   Record.clear();
   const HeaderSearchOptions &HSOpts
     = PP.getHeaderSearchInfo().getHeaderSearchOpts();
-  AddString(HSOpts.Sysroot, Record);
-
-  // Include entries.
-  Record.push_back(HSOpts.UserEntries.size());
-  for (unsigned I = 0, N = HSOpts.UserEntries.size(); I != N; ++I) {
-    const HeaderSearchOptions::Entry &Entry = HSOpts.UserEntries[I];
-    AddString(Entry.Path, Record);
-    Record.push_back(static_cast<unsigned>(Entry.Group));
-    Record.push_back(Entry.IsFramework);
-    Record.push_back(Entry.IgnoreSysRoot);
-  }
-
-  // System header prefixes.
-  Record.push_back(HSOpts.SystemHeaderPrefixes.size());
-  for (unsigned I = 0, N = HSOpts.SystemHeaderPrefixes.size(); I != N; ++I) {
-    AddString(HSOpts.SystemHeaderPrefixes[I].Prefix, Record);
-    Record.push_back(HSOpts.SystemHeaderPrefixes[I].IsSystemHeader);
-  }
 
+  AddString(HSOpts.Sysroot, Record);
   AddString(HSOpts.ResourceDir, Record);
   AddString(HSOpts.ModuleCachePath, Record);
   AddString(HSOpts.ModuleUserBuildPath, Record);
   Record.push_back(HSOpts.DisableModuleHash);
   Record.push_back(HSOpts.ImplicitModuleMaps);
   Record.push_back(HSOpts.ModuleMapFileHomeIsCwd);
   Record.push_back(HSOpts.EnablePrebuiltImplicitModules);
   Record.push_back(HSOpts.UseBuiltinIncludes);

llvm/include/llvm/Support/SaveAndRestore.h

template <typename T> struct SaveAndRestore {
   ~SaveAndRestore() { X = std::move(OldValue); }
   const T &get() { return OldValue; }
 
 private:
   T &X;
   T OldValue;
 };
 
+// User-defined CTAD guides.
+template <typename T> SaveAndRestore(T &) -> SaveAndRestore<T>;
+template <typename T> SaveAndRestore(T &, const T &) -> SaveAndRestore<T>;
+template <typename T> SaveAndRestore(T &, T &&) -> SaveAndRestore<T>;
+
 } // namespace llvm
 
 #endif