[Reproducers] Make reproducer relocatable

[JDevlieghere]

Summary

Before this patch, reproducers weren't relocatable. The reproducer contained hard coded paths in the VFS mapping, as well in the yaml file listing the different input files for the command interpreter. This patch changes that:

• Use relative paths for the DataCollector.
• Use an overlay prefix for the FileCollector.

[jankratochvil]

lldb/trunk/source/Utility/FileCollector.cpp

137

Regression fixed by @labath's rL363770.

lldb/trunk/include/lldb/Utility/FileCollector.h

 #include <mutex>
 
 namespace lldb_private {
 
 /// Collects files into a directory and generates a mapping that can be used by
 /// the VFS.
 class FileCollector {
 public:
-  FileCollector(const FileSpec &root);
+  FileCollector(const FileSpec &root, const FileSpec &overlay);
 
   void AddFile(const llvm::Twine &file);
   void AddFile(const FileSpec &file) { return AddFile(file.GetPath()); }
 
   /// Write the yaml mapping (for the VFS) to the given file.
   std::error_code WriteMapping(const FileSpec &mapping_file);
 
   /// Copy the files into the root directory.
protected:
   }
 
   /// Synchronizes adding files.
   std::mutex m_mutex;
 
   /// The root directory where files are copied.
   FileSpec m_root;
 
+  /// The root directory where the VFS overlay lives.
+  FileSpec m_overlay_root;
+
   /// Tracks already seen files so they can be skipped.
   llvm::StringSet<> m_seen;
 
   /// The yaml mapping writer.
   llvm::vfs::YAMLVFSWriter m_vfs_writer;
 
   /// Caches real_path calls when resolving symlinks.
   llvm::StringMap<std::string> m_symlink_map;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_UTILITY_FILE_COLLECTOR_H

lldb/trunk/include/lldb/Utility/Reproducer.h

 public:
   struct Info {
     static const char *name;
     static const char *file;
   };
 
   FileProvider(const FileSpec &directory)
       : Provider(directory),
-        m_collector(directory.CopyByAppendingPathComponent("root")) {}
+        m_collector(directory.CopyByAppendingPathComponent("root"), directory) {
+  }
 
   FileCollector &GetFileCollector() { return m_collector; }
 
   void Keep() override {
     auto mapping = GetRoot().CopyByAppendingPathComponent(Info::file);
     // Temporary files that are removed during execution can cause copy errors.
     if (auto ec = m_collector.CopyFiles(/*stop_on_error=*/false))
       return;
public:
   void Keep() override;
   std::string m_version;
   static char ID;
 };
 
 class DataRecorder {
 public:
   DataRecorder(const FileSpec &filename, std::error_code &ec)
-      : m_filename(std::move(filename)),
-        m_os(m_filename.GetPath(), ec, llvm::sys::fs::F_Text), m_record(true) {}
+      : m_filename(filename.GetFilename().GetStringRef()),
+        m_os(filename.GetPath(), ec, llvm::sys::fs::F_Text), m_record(true) {}
 
   static llvm::Expected<std::unique_ptr<DataRecorder>>
   Create(const FileSpec &filename);
 
   template <typename T> void Record(const T &t, bool newline = false) {
     if (!m_record)
       return;
     m_os << t;

lldb/trunk/lit/Reproducer/TestReuseDirectory.test

 # UNSUPPORTED: system-windows, system-freebsd
 
 # Test that we can capture twice to the same directory without breaking the
 # reproducer functionality.
 
 # RUN: rm -rf %t.repro
 # RUN: %clang %S/Inputs/simple.c -g -o %t.out
 # RUN: %lldb -x -b -s %S/Inputs/GDBRemoteCapture.in --capture --capture-path %t.repro %t.out | FileCheck %S/TestGDBRemoteRepro.test --check-prefix CHECK --check-prefix CAPTURE
 # RUN: %lldb -x -b -s %S/Inputs/GDBRemoteCapture.in --capture --capture-path %t.repro %t.out | FileCheck %S/TestGDBRemoteRepro.test --check-prefix CHECK --check-prefix CAPTURE
 # RUN: %lldb --replay %t.repro | FileCheck %S/TestGDBRemoteRepro.test --check-prefix CHECK --check-prefix REPLAY
+
+# Test that we can replay from a different location, i.e. that the reproducer
+# is relocatable.
+
+# RUN: rm -rf %t.repro_moved
+# RUN: mv %t.repro %t.repro_moved
+# RUN: %lldb --replay %t.repro_moved | FileCheck %S/TestGDBRemoteRepro.test --check-prefix CHECK --check-prefix REPLAY

lldb/trunk/source/API/SBDebugger.cpp

static std::unique_ptr<CommandLoader> Create() {
 
     std::vector<std::string> files;
     llvm::yaml::Input yin((*error_or_file)->getBuffer());
     yin >> files;
 
     if (auto err = yin.error())
       return {};
 
+    for (auto &file : files) {
+      FileSpec absolute_path =
+          loader->GetRoot().CopyByAppendingPathComponent(file);
+      file = absolute_path.GetPath();
+    }
+
     return llvm::make_unique<CommandLoader>(std::move(files));
   }
 
   FILE *GetNextFile() {
     if (m_index >= m_files.size())
       return nullptr;
     return FileSystem::Instance().Fopen(m_files[m_index++].c_str(), "r");
   }

lldb/trunk/source/Host/common/FileSystem.cpp

llvm::Error FileSystem::Initialize(const FileSpec &mapping) {
   lldbassert(!InstanceImpl() && "Already initialized.");
 
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> buffer =
       llvm::vfs::getRealFileSystem()->getBufferForFile(mapping.GetPath());
 
   if (!buffer)
     return llvm::errorCodeToError(buffer.getError());
 
-  InstanceImpl().emplace(
-      llvm::vfs::getVFSFromYAML(std::move(buffer.get()), nullptr, ""), true);
+  InstanceImpl().emplace(llvm::vfs::getVFSFromYAML(std::move(buffer.get()),
+                                                   nullptr, mapping.GetPath()),
+                         true);
 
   return llvm::Error::success();
 }
 
 void FileSystem::Initialize(IntrusiveRefCntPtr<vfs::FileSystem> fs) {
   lldbassert(!InstanceImpl() && "Already initialized.");
   InstanceImpl().emplace(fs);
 }

lldb/trunk/source/Utility/FileCollector.cpp

static bool IsCaseSensitivePath(StringRef path) {
   // sensitive in the absence of real_path, since this is the YAMLVFSWriter
   // default.
   upper_dest = path.upper();
   if (sys::fs::real_path(upper_dest, real_dest) && path.equals(real_dest))
     return false;
   return true;
 }
 
-FileCollector::FileCollector(const FileSpec &root) : m_root(root) {
+FileCollector::FileCollector(const FileSpec &root, const FileSpec &overlay_root)
+    : m_root(root), m_overlay_root(overlay_root) {
   sys::fs::create_directories(m_root.GetPath(), true);
 }
 
 bool FileCollector::GetRealPath(StringRef src_path,
                                 SmallVectorImpl<char> &result) {
   SmallString<256> real_path;
   StringRef FileName = sys::path::filename(src_path);
   std::string directory = sys::path::parent_path(src_path).str();
for (auto &entry : m_vfs_writer.getMappings()) {
     }
   }
   return {};
 }
 
 std::error_code FileCollector::WriteMapping(const FileSpec &mapping_file) {
   std::lock_guard<std::mutex> lock(m_mutex);
 
-  const std::string root = m_root.GetPath();
+  llvm::StringRef root = m_overlay_root.GetPath();
+
+  m_vfs_writer.setOverlayDir(root);
   m_vfs_writer.setCaseSensitivity(IsCaseSensitivePath(root));
   m_vfs_writer.setUseExternalNames(false);
 
   std::error_code ec;
   raw_fd_ostream os(mapping_file.GetPath(), ec, sys::fs::F_Text);
   if (ec)
     return ec;
 
   m_vfs_writer.write(os);
 
   return {};
 }

lldb/trunk/unittests/Utility/FileCollectorTest.cpp

struct ScopedFile {
   }
   operator StringRef() { return Path.str(); }
 };
 } // end anonymous namespace
 
 TEST(FileCollectorTest, AddFile) {
   ScopedDir root("add_file_root", true);
   FileSpec root_fs(root.Path);
-  TestingFileCollector file_collector(root_fs);
+  TestingFileCollector file_collector(root_fs, root_fs);
 
   file_collector.AddFile(FileSpec("/path/to/a"));
   file_collector.AddFile(FileSpec("/path/to/b"));
   file_collector.AddFile(FileSpec("/path/to/c"));
 
   // Make sure the root is correct.
   EXPECT_EQ(file_collector.m_root, root_fs);
 
TEST(FileCollectorTest, CopyFiles) {
   ScopedDir file_root("file_root", true);
   ScopedFile a(file_root + "/aaa");
   ScopedFile b(file_root + "/bbb");
   ScopedFile c(file_root + "/ccc");
 
   // Create file collector and add files.
   ScopedDir root("copy_files_root", true);
   FileSpec root_fs(root.Path);
-  TestingFileCollector file_collector(root_fs);
+  TestingFileCollector file_collector(root_fs, root_fs);
   file_collector.AddFile(a.Path);
   file_collector.AddFile(b.Path);
   file_collector.AddFile(c.Path);
 
   // Make sure we can copy the files.
   std::error_code ec = file_collector.CopyFiles(true);
   EXPECT_FALSE(ec);
 
TEST(FileCollectorTest, Symlinks) {
   ScopedFile e(foo + "/../eee");
 
   // Create a symlink bar pointing to foo.
   ScopedLink symlink(file_root + "/foo", file_root + "/bar");
 
   // Root where files are copied to.
   ScopedDir reproducer_root("reproducer_root", true);
   FileSpec root_fs(reproducer_root.Path);
-  TestingFileCollector file_collector(root_fs);
+  TestingFileCollector file_collector(root_fs, root_fs);
 
   // Add all the files to the collector.
   file_collector.AddFile(a.Path);
   file_collector.AddFile(b.Path);
   file_collector.AddFile(c.Path);
   file_collector.AddFile(d.Path);
   file_collector.AddFile(e.Path);
   file_collector.AddFile(file_root + "/bar/ddd");