[Reproducers] Include lldb version in the reproducer root

[JDevlieghere]

Summary

Generally, reproducers are rev-locked to the version of LLDB, so it's valuable to have the LLDB version in the reproducer. For now I just want the information to be present, without enforcing it, but I envision emitting a warning during replay in the future.

[aprantl]

lldb/include/lldb/Utility/Reproducer.h

114 ↗

(On Diff #204356)

Isn't a struct with two static members basically a namespace? I'm curious, I have not seen this pattern before.

119 ↗

(On Diff #204356)

Doxygen comments?

[JDevlieghere]

Adrian's feedback

[JDevlieghere]

Rebased to use the nested Info struct instead of the typedef.

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

public:
   }
 
   static char ID;
 
 private:
   FileCollector m_collector;
 };
 
+/// Provider for the LLDB version number.
+///
+/// When the reproducer is kept, it writes the lldb version to a file named
+/// version.txt in the reproducer root.
+class VersionProvider : public Provider<VersionProvider> {
+public:
+  VersionProvider(const FileSpec &directory) : Provider(directory) {}
+  struct Info {
+    static const char *name;
+    static const char *file;
+  };
+  void SetVersion(std::string version) {
+    assert(m_version.empty());
+    m_version = std::move(version);
+  }
+  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) {}
 
   static llvm::Expected<std::unique_ptr<DataRecorder>>
   Create(const FileSpec &filename);

lldb/trunk/lit/Reproducer/TestFileRepro.test

 # REQUIRES: system-darwin
 
 # This tests the replaying of GDB remote packets.
 #
 # We issue the same commands and ensure the output is identical to the original
 # process. To ensure we're not actually running the original binary we check
 # that the string "testing" is not printed.
 
 # RUN: rm -rf %t.repro
 # RUN: %clang %S/Inputs/simple.c -g -o %t.out
 # RUN: %lldb -x -b -s %S/Inputs/FileCapture.in --capture --capture-path %t.repro %t.out | FileCheck %s --check-prefix CHECK --check-prefix CAPTURE
 # RUN: rm %t.out
 # RUN: %lldb --replay %t.repro | FileCheck %s --check-prefix CHECK --check-prefix REPLAY
+# RUN: cat %t.repro/version.txt | FileCheck %s --check-prefix VERSION
 
 # CAPTURE: testing
 # REPLAY-NOT: testing
 
 # CHECK: Process {{.*}} exited
 
 # CAPTURE: Reproducer is in capture mode.
 # CAPTURE: Reproducer written
+
+# VERSION: lldb version

lldb/trunk/source/Initialization/SystemInitializerCommon.cpp

 #include "Plugins/Process/gdb-remote/ProcessGDBRemoteLog.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/Socket.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Reproducer.h"
 #include "lldb/Utility/Timer.h"
+#include "lldb/lldb-private.h"
 
 #if defined(__linux__) || defined(__FreeBSD__) || defined(__NetBSD__)
 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 #endif
 
 #if defined(_WIN32)
 #include "Plugins/Process/Windows/Common/ProcessWindowsLog.h"
 #include "lldb/Host/windows/windows.h"
#endif
 
   // If the reproducer wasn't initialized before, we can safely assume it's
   // off.
   if (!Reproducer::Initialized()) {
     if (auto e = Reproducer::Initialize(ReproducerMode::Off, llvm::None))
       return e;
   }
 
-  // Initialize the file system.
   auto &r = repro::Reproducer::Instance();
   if (repro::Loader *loader = r.GetLoader()) {
     FileSpec vfs_mapping = loader->GetFile<FileProvider::Info>();
     if (vfs_mapping) {
       if (llvm::Error e = FileSystem::Initialize(vfs_mapping))
         return e;
     } else {
       FileSystem::Initialize();
     }
   } else if (repro::Generator *g = r.GetGenerator()) {
+    repro::VersionProvider &vp = g->GetOrCreate<repro::VersionProvider>();
+    vp.SetVersion(lldb_private::GetVersion());
     repro::FileProvider &fp = g->GetOrCreate<repro::FileProvider>();
     FileSystem::Initialize(fp.GetFileCollector());
   } else {
     FileSystem::Initialize();
   }
 
   Log::Initialize();
   HostInfo::Initialize();

lldb/trunk/source/Utility/Reproducer.cpp

 //===-- Reproducer.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 "lldb/Utility/Reproducer.h"
 #include "lldb/Utility/LLDBAssert.h"
+#include "lldb/lldb-private.h"
 
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Threading.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace lldb_private;
 using namespace lldb_private::repro;
 using namespace llvm;
void CommandProvider::Keep() {
   if (ec)
     return;
   yaml::Output yout(os);
   yout << files;
 }
 
 void CommandProvider::Discard() { m_data_recorders.clear(); }
 
+void VersionProvider::Keep() {
+  FileSpec file = GetRoot().CopyByAppendingPathComponent(Info::file);
+  std::error_code ec;
+  llvm::raw_fd_ostream os(file.GetPath(), ec, llvm::sys::fs::F_Text);
+  if (ec)
+    return;
+  os << lldb_private::GetVersion() << "\n";
+}
+
 void ProviderBase::anchor() {}
 char ProviderBase::ID = 0;
-char FileProvider::ID = 0;
 char CommandProvider::ID = 0;
-const char *FileProvider::Info::name = "files";
-const char *FileProvider::Info::file = "files.yaml";
-const char *CommandProvider::Info::name = "command-interpreter";
+char FileProvider::ID = 0;
+char VersionProvider::ID = 0;
 const char *CommandProvider::Info::file = "command-interpreter.yaml";
+const char *CommandProvider::Info::name = "command-interpreter";
+const char *FileProvider::Info::file = "files.yaml";
+const char *FileProvider::Info::name = "files";
+const char *VersionProvider::Info::file = "version.txt";
+const char *VersionProvider::Info::name = "version";