[Reproducers] Have clang make use of lldb's VFS.

[JDevlieghere]

Summary

In r353906 we hooked up clang and lldb's reproducer infrastructure to
capture files used by clang. This patch adds the necessary logic to have
clang reuse the files from lldb's reproducer during replay.

[aprantl]

lldb/lit/Reproducer/Modules/Inputs/main.cpp

5 ↗

(On Diff #187095)

This is not very robust, since there is no code on this line. Personally I'd use:

void stop() {}

int main(int argc, char **argv) {
  Foo foo;
  stop(); // break here
  return 0;
}

lldb/lit/Reproducer/Modules/TestModuleCXX.test

9 ↗

(On Diff #187095)

does %clang set a -fmodule-cache-path ?
Please make sure that one is set otherwise this will cause chaos on incremental bots where upstream clang changes the PCM file format without bumping the version number,.

[JDevlieghere]

• Code review feedback Adrian

[aprantl]

lldb/lit/Reproducer/Modules/TestModuleCXX.test

17 ↗

(On Diff #187101)

Does %lldb source the config file that sets the module cache path?
I think it does...

lldb/lit/Reproducer/Modules/TestModuleCocoa.test

8 ↗

(On Diff #187101)

Does this have to be the real Cocoa? It's both really expensive to compile it and will vary based on the SDK.

[JDevlieghere]

• Have lldb use a custom module cache and remove it before replaying the reproducer.
• Remove the cocoa test now that we have a capture and replay test.

[aprantl]

LGTM as long as we always set a custom module cache path.

lldb/trunk/include/lldb/Host/FileSystem.h

void EnumerateDirectory(llvm::Twine path, bool find_directories,
                           void *callback_baton);
 
   std::error_code GetRealPath(const llvm::Twine &path,
                               llvm::SmallVectorImpl<char> &output) const;
 
   llvm::ErrorOr<std::string> GetExternalPath(const llvm::Twine &path);
   llvm::ErrorOr<std::string> GetExternalPath(const FileSpec &file_spec);
 
+  llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> GetVirtualFileSystem() {
+    return m_fs;
+  }
+
 private:
   static llvm::Optional<FileSystem> &InstanceImpl();
   llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> m_fs;
   FileCollector *m_collector;
   bool m_mapped;
 };
 } // namespace lldb_private
 
 #endif

lldb/trunk/include/lldb/Symbol/ClangASTImporter.h

 
 #include "clang/AST/ASTImporter.h"
 #include "clang/AST/CharUnits.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/FileSystemOptions.h"
 
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/lldb-types.h"
 
 #include "llvm/ADT/DenseMap.h"
 
 namespace lldb_private {
 
 class ClangASTMetrics {
struct LayoutInfo {
     uint64_t bit_size;
     uint64_t alignment;
     llvm::DenseMap<const clang::FieldDecl *, uint64_t> field_offsets;
     llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> base_offsets;
     llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
         vbase_offsets;
   };
 
-  ClangASTImporter() : m_file_manager(clang::FileSystemOptions()) {}
+  ClangASTImporter()
+      : m_file_manager(clang::FileSystemOptions(),
+                       FileSystem::Instance().GetVirtualFileSystem()) {}
 
   clang::QualType CopyType(clang::ASTContext *dst_ctx,
                            clang::ASTContext *src_ctx, clang::QualType type);
 
   lldb::opaque_compiler_type_t CopyType(clang::ASTContext *dst_ctx,
                                         clang::ASTContext *src_ctx,
                                         lldb::opaque_compiler_type_t type);
 

lldb/trunk/lit/Reproducer/Inputs/ModuleCapture.in

-expr -- @import Cocoa
-reproducer generate

lldb/trunk/lit/Reproducer/Modules/Inputs/Bar.h

+struct Bar {
+  int success;
+};

lldb/trunk/lit/Reproducer/Modules/Inputs/Foo.h

+struct Foo {};

lldb/trunk/lit/Reproducer/Modules/Inputs/ModuleCXX.in

+breakpoint set -f main.cpp -l 5
+run
+expr -l Objective-C++ -- @import Foo
+expr -l Objective-C++ -- @import Bar
+expr -- Bar()
+reproducer generate

lldb/trunk/lit/Reproducer/Modules/Inputs/main.cpp

+#include "Foo.h"
+
+void stop() {}
+
+int main(int argc, char **argv) {
+  Foo foo;
+  stop(); // break here.
+  return 0;
+}

lldb/trunk/lit/Reproducer/Modules/Inputs/module.modulemap

+module Foo {
+  header "Foo.h"
+}
+
+module Bar {
+  header "Bar.h"
+}

lldb/trunk/lit/Reproducer/Modules/TestModuleCXX.test

+# Start fresh.
+# RUN: rm -rf %t.root
+# RUN: rm -rf %t.clang-cache
+# RUN: rm -rf %t.lldb-cache
+
+# Create a temporary root we can remove later.
+# RUN: mkdir -p %t.root
+# RUN: mkdir -p %t.clang-cache
+# RUN: mkdir -p %t.lldb-cache
+# RUN: cp %S/Inputs/main.cpp %t.root
+# RUN: cp %S/Inputs/Foo.h %t.root
+# RUN: cp %S/Inputs/Bar.h %t.root
+# RUN: cp %S/Inputs/module.modulemap %t.root
+
+# Compile the test case form the temporary root.
+# RUN: %clang %t.root/main.cpp -g -fmodules -fcxx-modules -fmodules-cache-path=%t.clang-cache -o %t.root/a.out
+
+# Capture the debug session.
+# RUN: %lldb -x -b -o 'settings set symbols.clang-modules-cache-path %t.lldb-cache' -s %S/Inputs/ModuleCXX.in --capture %t.repro %t.root/a.out | FileCheck %s --check-prefix CAPTURE
+# CAPTURE: (success = 0)
+
+# RUN: cat %t.repro/files.yaml | FileCheck %s --check-prefix YAML
+# YAML-DAG: Foo.h
+# YAML-DAG: Bar.h
+# YAML-DAG: module.modulemap
+
+# Remove the temporary root.
+# RUN: rm -rf %t.root
+# RUN: rm -rf %t.clang-cache
+# RUN: rm -rf %t.lldb-cache
+
+# Replay the debug session.
+# RUN: %lldb -x -b -o 'settings set symbols.clang-modules-cache-path %t.lldb-cache' -s %S/Inputs/ModuleCXX.in --replay %t.repro %t.root/a.out | FileCheck %s --check-prefix REPLAY
+# REPLAY: (success = 0)

lldb/trunk/lit/Reproducer/TestClangFileRepro.test

-# REQUIRES: system-darwin
-#
-# This tests that modules files from clang end up in the reproducer.
-#
-# RUN: %lldb -x -b -s %S/Inputs/ModuleCapture.in --capture %t.repro
-# cat %t.repro/files.yaml | FileCheck %s
-#
-# CHECK: Cocoa.h

lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

if (repro::Generator *g = repro::Reproducer::Instance().GetGenerator()) {
     m_compiler->setModuleDepCollector(
         std::make_shared<ModuleDependencyCollectorAdaptor>(
             fp.GetFileCollector()));
     DependencyOutputOptions &opts = m_compiler->getDependencyOutputOpts();
     opts.IncludeSystemHeaders = true;
     opts.IncludeModuleFiles = true;
   }
 
+  // Make sure clang uses the same VFS as LLDB.
+  m_compiler->setVirtualFileSystem(
+      FileSystem::Instance().GetVirtualFileSystem());
+
   lldb::LanguageType frame_lang =
       expr.Language(); // defaults to lldb::eLanguageTypeUnknown
   bool overridden_target_opts = false;
   lldb_private::LanguageRuntime *lang_rt = nullptr;
 
   std::string abi;
   ArchSpec target_arch;
   target_arch = target_sp->GetArchitecture();

lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.cpp

if (repro::Generator *g = repro::Reproducer::Instance().GetGenerator()) {
     instance->setModuleDepCollector(
         std::make_shared<ModuleDependencyCollectorAdaptor>(
             fp.GetFileCollector()));
     clang::DependencyOutputOptions &opts = instance->getDependencyOutputOpts();
     opts.IncludeSystemHeaders = true;
     opts.IncludeModuleFiles = true;
   }
 
+  // Make sure clang uses the same VFS as LLDB.
+  instance->setVirtualFileSystem(FileSystem::Instance().GetVirtualFileSystem());
   instance->setDiagnostics(diagnostics_engine.get());
   instance->setInvocation(invocation);
 
   std::unique_ptr<clang::FrontendAction> action(new clang::SyntaxOnlyAction);
 
   instance->setTarget(clang::TargetInfo::CreateTargetInfo(
       *diagnostics_engine, instance->getInvocation().TargetOpts));
 

lldb/trunk/source/Plugins/Language/ClangCommon/ClangHighlighter.cpp

 //===-- ClangHighlighter.cpp ------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "ClangHighlighter.h"
 
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Utility/AnsiTerminal.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "clang/Basic/SourceManager.h"
 #include "clang/Lex/Lexer.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Support/MemoryBuffer.h"

 void ClangHighlighter::Highlight(const HighlightStyle &options,
                                  llvm::StringRef line,
                                  llvm::Optional<size_t> cursor_pos,
                                  llvm::StringRef previous_lines,
                                  Stream &result) const {
   using namespace clang;
 
   FileSystemOptions file_opts;
-  FileManager file_mgr(file_opts);
+  FileManager file_mgr(file_opts,
+                       FileSystem::Instance().GetVirtualFileSystem());
 
   unsigned line_number = previous_lines.count('\n') + 1U;
 
   // Let's build the actual source code Clang needs and setup some utility
   // objects.
   std::string full_source = previous_lines.str() + line.str();
   llvm::IntrusiveRefCntPtr<DiagnosticIDs> diag_ids(new DiagnosticIDs());
   llvm::IntrusiveRefCntPtr<DiagnosticOptions> diags_opts(

lldb/trunk/source/Symbol/ClangASTContext.cpp

SelectorTable *ClangASTContext::getSelectorTable() {
   if (m_selector_table_up == nullptr)
     m_selector_table_up.reset(new SelectorTable());
   return m_selector_table_up.get();
 }
 
 clang::FileManager *ClangASTContext::getFileManager() {
   if (m_file_manager_up == nullptr) {
     clang::FileSystemOptions file_system_options;
-    m_file_manager_up.reset(new clang::FileManager(file_system_options));
+    m_file_manager_up.reset(new clang::FileManager(
+        file_system_options, FileSystem::Instance().GetVirtualFileSystem()));
   }
   return m_file_manager_up.get();
 }
 
 clang::SourceManager *ClangASTContext::getSourceManager() {
   if (m_source_manager_up == nullptr)
     m_source_manager_up.reset(
         new clang::SourceManager(*getDiagnosticsEngine(), *getFileManager()));

lldb/trunk/unittests/Language/Highlighting/HighlighterTest.cpp

 //===-- HighlighterTest.cpp -------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "gtest/gtest.h"
 
 #include "lldb/Core/Highlighter.h"
+#include "lldb/Host/FileSystem.h"
 
 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
 #include "Plugins/Language/ObjC/ObjCLanguage.h"
 #include "Plugins/Language/ObjCPlusPlus/ObjCPlusPlusLanguage.h"
 
 using namespace lldb_private;
 
 namespace {
 class HighlighterTest : public testing::Test {
 public:
   static void SetUpTestCase();
   static void TearDownTestCase();
 };
 } // namespace
 
 void HighlighterTest::SetUpTestCase() {
   // The HighlighterManager uses the language plugins under the hood, so we
   // have to initialize them here for our test process.
+  FileSystem::Initialize();
   CPlusPlusLanguage::Initialize();
   ObjCLanguage::Initialize();
   ObjCPlusPlusLanguage::Initialize();
 }
 
 void HighlighterTest::TearDownTestCase() {
   CPlusPlusLanguage::Terminate();
   ObjCLanguage::Terminate();
   ObjCPlusPlusLanguage::Terminate();
+  FileSystem::Terminate();
 }
 
 static std::string getName(lldb::LanguageType type) {
   HighlighterManager m;
   return m.getHighlighterFor(type, "").GetName().str();
 }
 
 static std::string getName(llvm::StringRef path) {