[clang] Move VFS overlays from HeaderSearchOptions to FileSystemOptions

Author: jansvoboda11

clang/include/clang/Basic/FileSystemOptions.h

@@ -24,6 +24,9 @@ class FileSystemOptions {
   /// If set, paths are resolved as if the working directory was
   /// set to the value of WorkingDir.
   std::string WorkingDir;
+
+  /// The set of user-provided virtual filesystem overlay files.
+  std::vector<std::string> VFSOverlayFiles;
 };
 
 } // end namespace clang

clang/include/clang/Lex/HeaderSearchOptions.h

@@ -187,9 +187,6 @@ class HeaderSearchOptions {
   /// of computing the module hash.
   llvm::SmallSetVector<llvm::CachedHashString, 16> ModulesIgnoreMacros;
 
-  /// The set of user-provided virtual filesystem overlay files.
-  std::vector<std::string> VFSOverlayFiles;
-
   /// Include the compiler builtin includes.
   LLVM_PREFERRED_TYPE(bool)
   unsigned UseBuiltinIncludes : 1;
@@ -307,10 +304,6 @@ class HeaderSearchOptions {
     SystemHeaderPrefixes.emplace_back(Prefix, IsSystemHeader);
   }
 
-  void AddVFSOverlayFile(StringRef Name) {
-    VFSOverlayFiles.push_back(std::string(Name));
-  }
-
   void AddPrebuiltModulePath(StringRef Name) {
     PrebuiltModulePaths.push_back(std::string(Name));
   }

clang/include/clang/Serialization/ASTBitCodes.h

@@ -392,9 +392,6 @@ enum OptionsRecordTypes {
   /// Record code for the target options table.
   TARGET_OPTIONS,
 
-  /// Record code for the filesystem options table.
-  FILE_SYSTEM_OPTIONS,
-
   /// Record code for the headers search options table.
   HEADER_SEARCH_OPTIONS,
 
@@ -413,6 +410,9 @@ enum UnhashedControlBlockRecordTypes {
   /// Record code for the diagnostic options table.
   DIAGNOSTIC_OPTIONS,
 
+  /// Record code for the filesystem options table.
+  FILE_SYSTEM_OPTIONS,
+
   /// Record code for the headers search paths.
   HEADER_SEARCH_PATHS,
 

clang/lib/Frontend/ASTUnit.cpp

@@ -517,24 +517,25 @@ namespace {
 class ASTInfoCollector : public ASTReaderListener {
   Preprocessor &PP;
   ASTContext *Context;
+  FileSystemOptions &FSOpts;
   HeaderSearchOptions &HSOpts;
   PreprocessorOptions &PPOpts;
   LangOptions &LangOpt;
   std::shared_ptr<TargetOptions> &TargetOpts;
   IntrusiveRefCntPtr<TargetInfo> &Target;
   unsigned &Counter;
   bool InitializedLanguage = false;
-  bool InitializedHeaderSearchPaths = false;
+  bool InitializedFileSystem = false;
 
 public:
   ASTInfoCollector(Preprocessor &PP, ASTContext *Context,
-                   HeaderSearchOptions &HSOpts, PreprocessorOptions &PPOpts,
-                   LangOptions &LangOpt,
+                   FileSystemOptions &FSOpts, HeaderSearchOptions &HSOpts,
+                   PreprocessorOptions &PPOpts, LangOptions &LangOpt,
                    std::shared_ptr<TargetOptions> &TargetOpts,
                    IntrusiveRefCntPtr<TargetInfo> &Target, unsigned &Counter)
-      : PP(PP), Context(Context), HSOpts(HSOpts), PPOpts(PPOpts),
-        LangOpt(LangOpt), TargetOpts(TargetOpts), Target(Target),
-        Counter(Counter) {}
+      : PP(PP), Context(Context), FSOpts(FSOpts), HSOpts(HSOpts),
+        PPOpts(PPOpts), LangOpt(LangOpt), TargetOpts(TargetOpts),
+        Target(Target), Counter(Counter) {}
 
   bool ReadLanguageOptions(const LangOptions &LangOpts,
                            StringRef ModuleFilename, bool Complain,
@@ -568,7 +569,6 @@ class ASTInfoCollector : public ASTReaderListener {
         this->HSOpts.ForceCheckCXX20ModulesInputFiles;
     llvm::SaveAndRestore X(this->HSOpts.UserEntries);
     llvm::SaveAndRestore Y(this->HSOpts.SystemHeaderPrefixes);
-    llvm::SaveAndRestore Z(this->HSOpts.VFSOverlayFiles);
 
     this->HSOpts = HSOpts;
     this->HSOpts.ForceCheckCXX20ModulesInputFiles =
@@ -577,24 +577,29 @@ class ASTInfoCollector : public ASTReaderListener {
     return false;
   }
 
-  bool ReadHeaderSearchPaths(const HeaderSearchOptions &HSOpts,
+  bool ReadFileSystemOptions(const FileSystemOptions &FSOpts,
                              bool Complain) override {
-    if (InitializedHeaderSearchPaths)
+    if (InitializedFileSystem)
       return false;
 
-    this->HSOpts.UserEntries = HSOpts.UserEntries;
-    this->HSOpts.SystemHeaderPrefixes = HSOpts.SystemHeaderPrefixes;
-    this->HSOpts.VFSOverlayFiles = HSOpts.VFSOverlayFiles;
+    this->FSOpts.VFSOverlayFiles = FSOpts.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(),
+        FSOpts.VFSOverlayFiles, PP.getDiagnostics(),
         PP.getFileManager().getVirtualFileSystemPtr()));
 
-    InitializedHeaderSearchPaths = true;
+    InitializedFileSystem = true;
+
+    return false;
+  }
 
+  bool ReadHeaderSearchPaths(const HeaderSearchOptions &HSOpts,
+                             bool Complain) override {
+    this->HSOpts.UserEntries = HSOpts.UserEntries;
+    this->HSOpts.SystemHeaderPrefixes = HSOpts.SystemHeaderPrefixes;
     return false;
   }
 
@@ -867,8 +872,8 @@ std::unique_ptr<ASTUnit> ASTUnit::LoadFromASTFile(
 
   unsigned Counter = 0;
   AST->Reader->setListener(std::make_unique<ASTInfoCollector>(
-      *AST->PP, AST->Ctx.get(), *AST->HSOpts, *AST->PPOpts, *AST->LangOpts,
-      AST->TargetOpts, AST->Target, Counter));
+      *AST->PP, AST->Ctx.get(), AST->FileSystemOpts, *AST->HSOpts, *AST->PPOpts,
+      *AST->LangOpts, AST->TargetOpts, AST->Target, Counter));
 
   // Attach the AST reader to the AST context as an external AST
   // source, so that declarations will be deserialized from the

clang/lib/Frontend/CompilerInstance.cpp

@@ -261,12 +261,12 @@ static void collectIncludePCH(CompilerInstance &CI,
 
 static void collectVFSEntries(CompilerInstance &CI,
                               std::shared_ptr<ModuleDependencyCollector> MDC) {
-  if (CI.getHeaderSearchOpts().VFSOverlayFiles.empty())
+  if (CI.getFileSystemOpts().VFSOverlayFiles.empty())
     return;
 
   // Collect all VFS found.
   SmallVector<llvm::vfs::YAMLVFSEntry, 16> VFSEntries;
-  for (const std::string &VFSFile : CI.getHeaderSearchOpts().VFSOverlayFiles) {
+  for (const std::string &VFSFile : CI.getFileSystemOpts().VFSOverlayFiles) {
     llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
         llvm::MemoryBuffer::getFile(VFSFile);
     if (!Buffer)

clang/lib/Frontend/CompilerInvocation.cpp

@@ -2421,6 +2421,9 @@ static void GenerateFileSystemArgs(const FileSystemOptions &Opts,
   GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
 #include "clang/Driver/Options.inc"
 #undef FILE_SYSTEM_OPTION_WITH_MARSHALLING
+
+  for (const std::string &F : Opts.VFSOverlayFiles)
+    GenerateArg(Consumer, OPT_ivfsoverlay, F);
 }
 
 static bool ParseFileSystemArgs(FileSystemOptions &Opts, const ArgList &Args,
@@ -2434,6 +2437,9 @@ static bool ParseFileSystemArgs(FileSystemOptions &Opts, const ArgList &Args,
 #include "clang/Driver/Options.inc"
 #undef FILE_SYSTEM_OPTION_WITH_MARSHALLING
 
+  for (const auto *A : Args.filtered(OPT_ivfsoverlay, OPT_vfsoverlay))
+    Opts.VFSOverlayFiles.push_back(std::string(A->getValue()));
+
   return Diags.getNumErrors() == NumErrorsBefore;
 }
 
@@ -3270,9 +3276,6 @@ static void GenerateHeaderSearchArgs(const HeaderSearchOptions &Opts,
                                         : OPT_no_system_header_prefix;
     GenerateArg(Consumer, Opt, P.Prefix);
   }
-
-  for (const std::string &F : Opts.VFSOverlayFiles)
-    GenerateArg(Consumer, OPT_ivfsoverlay, F);
 }
 
 static bool ParseHeaderSearchArgs(HeaderSearchOptions &Opts, ArgList &Args,
@@ -3411,9 +3414,6 @@ static bool ParseHeaderSearchArgs(HeaderSearchOptions &Opts, ArgList &Args,
     Opts.AddSystemHeaderPrefix(
         A->getValue(), A->getOption().matches(OPT_system_header_prefix));
 
-  for (const auto *A : Args.filtered(OPT_ivfsoverlay, OPT_vfsoverlay))
-    Opts.AddVFSOverlayFile(A->getValue());
-
   return Diags.getNumErrors() == NumErrorsBefore;
 }
 
@@ -4959,7 +4959,7 @@ bool CompilerInvocation::CreateFromArgsImpl(
   // to determine the PGO type.
   if (!Res.getCodeGenOpts().ProfileInstrumentUsePath.empty()) {
     auto FS =
-        createVFSFromOverlayFiles(Res.getHeaderSearchOpts().VFSOverlayFiles,
+        createVFSFromOverlayFiles(Res.getFileSystemOpts().VFSOverlayFiles,
                                   Diags, llvm::vfs::getRealFileSystem());
     setPGOUseInstrumentor(Res.getCodeGenOpts(),
                           Res.getCodeGenOpts().ProfileInstrumentUsePath, *FS,
@@ -5051,7 +5051,7 @@ std::string CompilerInvocation::getModuleHash() const {
   if (hsOpts.ModulesStrictContextHash) {
     HBuilder.addRange(hsOpts.SystemHeaderPrefixes);
     HBuilder.addRange(hsOpts.UserEntries);
-    HBuilder.addRange(hsOpts.VFSOverlayFiles);
+    HBuilder.addRange(getFileSystemOpts().VFSOverlayFiles);
 
     const DiagnosticOptions &diagOpts = getDiagnosticOpts();
 #define DIAGOPT(Name, Bits, Default) HBuilder.add(diagOpts.Name);
@@ -5171,7 +5171,7 @@ IntrusiveRefCntPtr<llvm::vfs::FileSystem>
 clang::createVFSFromCompilerInvocation(
     const CompilerInvocation &CI, DiagnosticsEngine &Diags,
     IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS) {
-  return createVFSFromOverlayFiles(CI.getHeaderSearchOpts().VFSOverlayFiles,
+  return createVFSFromOverlayFiles(CI.getFileSystemOpts().VFSOverlayFiles,
                                    Diags, std::move(BaseFS));
 }
 

clang/lib/Frontend/FrontendActions.cpp

@@ -706,6 +706,15 @@ namespace {
       return false;
     }
 
+    bool ReadFileSystemOptions(const FileSystemOptions &FSOpts,
+                               bool Complain) override {
+      Out.indent(2) << "File system options:\n";
+      Out.indent(4) << "VFS overlay files:\n";
+      for (const auto &Overlay : FSOpts.VFSOverlayFiles)
+        Out.indent(6) << Overlay << "\n";
+      return false;
+    }
+
     bool ReadHeaderSearchPaths(const HeaderSearchOptions &HSOpts,
                                bool Complain) override {
       Out.indent(2) << "Header search paths:\n";
@@ -715,9 +724,6 @@ namespace {
       Out.indent(4) << "System header prefixes:\n";
       for (const auto &Prefix : HSOpts.SystemHeaderPrefixes)
         Out.indent(6) << Prefix.Prefix << "\n";
-      Out.indent(4) << "VFS overlay files:\n";
-      for (const auto &Overlay : HSOpts.VFSOverlayFiles)
-        Out.indent(6) << Overlay << "\n";
       return false;
     }
 

clang/lib/Lex/HeaderSearch.cpp

@@ -157,7 +157,8 @@ std::vector<bool> HeaderSearch::collectVFSUsageAndClear() const {
       RFS->clearHasBeenUsed();
     }
   });
-  assert(VFSUsage.size() == getHeaderSearchOpts().VFSOverlayFiles.size() &&
+  assert(VFSUsage.size() ==
+             FileMgr.getFileSystemOpts().VFSOverlayFiles.size() &&
          "A different number of RedirectingFileSystem's were present than "
          "-ivfsoverlay options passed to Clang!");
   // VFS visit order is the opposite of VFSOverlayFiles order.

clang/lib/Serialization/ASTReader.cpp

@@ -2844,14 +2844,6 @@ ASTReader::ASTReadResult ASTReader::ReadOptionsBlock(
       break;
     }
 
-    case FILE_SYSTEM_OPTIONS: {
-      bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
-      if (!AllowCompatibleConfigurationMismatch &&
-          ParseFileSystemOptions(Record, Complain, Listener))
-        Result = ConfigurationMismatch;
-      break;
-    }
-
     case HEADER_SEARCH_OPTIONS: {
       bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
       if (!AllowCompatibleConfigurationMismatch &&
@@ -5015,6 +5007,13 @@ ASTReader::ASTReadResult ASTReader::readUnhashedControlBlockImpl(
         Result = OutOfDate; // Don't return early.  Read the signature.
       break;
     }
+    case FILE_SYSTEM_OPTIONS: {
+      bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
+      if (Listener && !AllowCompatibleConfigurationMismatch &&
+          ParseFileSystemOptions(Record, Complain, *Listener))
+        Result = ConfigurationMismatch;
+      break;
+    }
     case HEADER_SEARCH_PATHS: {
       bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
       if (Listener && !AllowCompatibleConfigurationMismatch &&
@@ -6155,7 +6154,12 @@ bool ASTReader::ParseFileSystemOptions(const RecordData &Record, bool Complain,
                                        ASTReaderListener &Listener) {
   FileSystemOptions FSOpts;
   unsigned Idx = 0;
+
   FSOpts.WorkingDir = ReadString(Record, Idx);
+
+  for (unsigned N = Record[Idx++]; N; --N)
+    FSOpts.VFSOverlayFiles.emplace_back(ReadString(Record, Idx));
+
   return Listener.ReadFileSystemOptions(FSOpts, Complain);
 }
 
@@ -6207,12 +6211,6 @@ bool ASTReader::ParseHeaderSearchPaths(const RecordData &Record, bool Complain,
     HSOpts.SystemHeaderPrefixes.emplace_back(std::move(Prefix), IsSystemHeader);
   }
 
-  // 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.ReadHeaderSearchPaths(HSOpts, Complain);
 }
 

clang/lib/Serialization/ASTWriter.cpp

@@ -868,7 +868,6 @@ void ASTWriter::WriteBlockInfoBlock() {
   BLOCK(OPTIONS_BLOCK);
   RECORD(LANGUAGE_OPTIONS);
   RECORD(TARGET_OPTIONS);
-  RECORD(FILE_SYSTEM_OPTIONS);
   RECORD(HEADER_SEARCH_OPTIONS);
   RECORD(PREPROCESSOR_OPTIONS);
 
@@ -1113,6 +1112,7 @@ void ASTWriter::WriteBlockInfoBlock() {
   RECORD(SIGNATURE);
   RECORD(AST_BLOCK_HASH);
   RECORD(DIAGNOSTIC_OPTIONS);
+  RECORD(FILE_SYSTEM_OPTIONS);
   RECORD(HEADER_SEARCH_PATHS);
   RECORD(DIAG_PRAGMA_MAPPINGS);
 
@@ -1342,6 +1342,19 @@ void ASTWriter::writeUnhashedControlBlock(Preprocessor &PP,
     Record.clear();
   }
 
+  // File system options.
+  const FileSystemOptions &FSOpts =
+      Context.getSourceManager().getFileManager().getFileSystemOpts();
+
+  AddString(FSOpts.WorkingDir, Record);
+
+  Record.push_back(FSOpts.VFSOverlayFiles.size());
+  for (StringRef VFSOverlayFile : FSOpts.VFSOverlayFiles)
+    AddString(VFSOverlayFile, Record);
+
+  Stream.EmitRecord(FILE_SYSTEM_OPTIONS, Record);
+  Record.clear();
+
   // Header search paths.
   if (!HSOpts.ModulesSkipHeaderSearchPaths) {
     // Include entries.
@@ -1361,11 +1374,6 @@ void ASTWriter::writeUnhashedControlBlock(Preprocessor &PP,
       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);
   }
 
@@ -1607,13 +1615,6 @@ void ASTWriter::WriteControlBlock(Preprocessor &PP, ASTContext &Context,
   }
   Stream.EmitRecord(TARGET_OPTIONS, Record);
 
-  // File system options.
-  Record.clear();
-  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 =
@@ -5019,8 +5020,7 @@ void ASTWriter::computeNonAffectingInputFiles() {
   FileManager &FileMgr = PP->getFileManager();
   FileMgr.trackVFSUsage(true);
   // Lookup the paths in the VFS to trigger `-ivfsoverlay` usage tracking.
-  for (StringRef Path :
-       PP->getHeaderSearchInfo().getHeaderSearchOpts().VFSOverlayFiles)
+  for (StringRef Path : FileMgr.getFileSystemOpts().VFSOverlayFiles)
     FileMgr.getVirtualFileSystem().exists(Path);
   for (unsigned I = 1; I != N; ++I) {
     if (IsSLocAffecting[I]) {