Merge pull request #1827 from JDevlieghere/cherrypick-reproducer-backlog

Cherrypick reproducer backlog

Author: JDevlieghere

lldb/include/lldb/API/SBReproducer.h

@@ -11,8 +11,32 @@
 
 #include "lldb/API/SBDefines.h"
 
+namespace lldb_private {
+namespace repro {
+struct ReplayOptions;
+}
+} // namespace lldb_private
+
 namespace lldb {
 
+class LLDB_API SBReplayOptions {
+public:
+  SBReplayOptions();
+  SBReplayOptions(const SBReplayOptions &rhs);
+  ~SBReplayOptions();
+
+  SBReplayOptions &operator=(const SBReplayOptions &rhs);
+
+  void SetVerify(bool verify);
+  bool GetVerify() const;
+
+  void SetCheckVersion(bool check);
+  bool GetCheckVersion() const;
+
+private:
+  std::unique_ptr<lldb_private::repro::ReplayOptions> m_opaque_up;
+};
+
 /// The SBReproducer class is special because it bootstraps the capture and
 /// replay of SB API calls. As a result we cannot rely on any other SB objects
 /// in the interface or implementation of this class.
@@ -22,6 +46,7 @@ class LLDB_API SBReproducer {
   static const char *Capture(const char *path);
   static const char *Replay(const char *path);
   static const char *Replay(const char *path, bool skip_version_check);
+  static const char *Replay(const char *path, const SBReplayOptions &options);
   static const char *PassiveReplay(const char *path);
   static const char *GetPath();
   static bool SetAutoGenerate(bool b);

lldb/include/lldb/Core/IOHandler.h

@@ -15,7 +15,6 @@
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Flags.h"
 #include "lldb/Utility/Predicate.h"
-#include "lldb/Utility/Reproducer.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StringList.h"
 #include "lldb/lldb-defines.h"
@@ -32,6 +31,9 @@
 
 namespace lldb_private {
 class Debugger;
+namespace repro {
+class DataRecorder;
+}
 }
 
 namespace curses {

lldb/include/lldb/Host/FileSystem.h

@@ -33,13 +33,14 @@ class FileSystem {
 
   FileSystem()
       : m_fs(llvm::vfs::getRealFileSystem()), m_collector(nullptr),
-        m_mapped(false) {}
+        m_home_directory(), m_mapped(false) {}
   FileSystem(std::shared_ptr<llvm::FileCollector> collector)
-      : m_fs(llvm::vfs::getRealFileSystem()), m_collector(collector),
-        m_mapped(false) {}
+      : m_fs(llvm::vfs::getRealFileSystem()), m_collector(std::move(collector)),
+        m_home_directory(), m_mapped(false) {}
   FileSystem(llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> fs,
              bool mapped = false)
-      : m_fs(fs), m_collector(nullptr), m_mapped(mapped) {}
+      : m_fs(std::move(fs)), m_collector(nullptr), m_home_directory(),
+        m_mapped(mapped) {}
 
   FileSystem(const FileSystem &fs) = delete;
   FileSystem &operator=(const FileSystem &fs) = delete;
@@ -193,10 +194,13 @@ class FileSystem {
   void Collect(const FileSpec &file_spec);
   void Collect(const llvm::Twine &file);
 
+  void SetHomeDirectory(std::string home_directory);
+
 private:
   static llvm::Optional<FileSystem> &InstanceImpl();
   llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> m_fs;
   std::shared_ptr<llvm::FileCollector> m_collector;
+  std::string m_home_directory;
   bool m_mapped;
 };
 } // namespace lldb_private

lldb/include/lldb/Utility/ArchSpec.h

@@ -505,7 +505,7 @@ class ArchSpec {
 
   void SetFlags(uint32_t flags) { m_flags = flags; }
 
-  void SetFlags(std::string elf_abi);
+  void SetFlags(const std::string &elf_abi);
 
 protected:
   bool IsEqualTo(const ArchSpec &rhs, bool exact_match) const;

lldb/include/lldb/Utility/Broadcaster.h

@@ -39,7 +39,7 @@ namespace lldb_private {
 /// Debugger maintains a list of BroadcastEventSpec's and when it is made
 class BroadcastEventSpec {
 public:
-  BroadcastEventSpec(ConstString broadcaster_class, uint32_t event_bits)
+  BroadcastEventSpec(const ConstString &broadcaster_class, uint32_t event_bits)
       : m_broadcaster_class(broadcaster_class), m_event_bits(event_bits) {}
 
   ~BroadcastEventSpec() = default;
@@ -117,7 +117,7 @@ class BroadcasterManager
 
   class BroadcasterClassMatches {
   public:
-    BroadcasterClassMatches(ConstString broadcaster_class)
+    BroadcasterClassMatches(const ConstString &broadcaster_class)
         : m_broadcaster_class(broadcaster_class) {}
 
     ~BroadcasterClassMatches() = default;

lldb/include/lldb/Utility/ConstString.h

@@ -133,7 +133,7 @@ class ConstString {
   ///
   /// \return
   ///     A const reference to this object.
-  ConstString operator=(ConstString rhs) {
+  ConstString operator=(const ConstString &rhs) {
     m_string = rhs.m_string;
     return *this;
   }
@@ -150,7 +150,7 @@ class ConstString {
   /// \return
   ///     true if this object is equal to \a rhs.
   ///     false if this object is not equal to \a rhs.
-  bool operator==(ConstString rhs) const {
+  bool operator==(const ConstString &rhs) const {
     // We can do a pointer compare to compare these strings since they must
     // come from the same pool in order to be equal.
     return m_string == rhs.m_string;
@@ -192,7 +192,7 @@ class ConstString {
   /// \return
   ///     \b true if this object is not equal to \a rhs.
   ///     \b false if this object is equal to \a rhs.
-  bool operator!=(ConstString rhs) const {
+  bool operator!=(const ConstString &rhs) const {
     return m_string != rhs.m_string;
   }
 
@@ -209,7 +209,7 @@ class ConstString {
   /// \return \b true if this object is not equal to \a rhs, false otherwise.
   bool operator!=(const char *rhs) const { return !(*this == rhs); }
 
-  bool operator<(ConstString rhs) const;
+  bool operator<(const ConstString &rhs) const;
 
   /// Get the string value as a C string.
   ///
@@ -279,7 +279,7 @@ class ConstString {
   ///     will be tested, otherwise character case will be ignored
   ///
   /// \return \b true if this object is equal to \a rhs, \b false otherwise.
-  static bool Equals(ConstString lhs, ConstString rhs,
+  static bool Equals(const ConstString &lhs, const ConstString &rhs,
                      const bool case_sensitive = true);
 
   /// Compare two string objects.
@@ -303,7 +303,7 @@ class ConstString {
   ///     will be performed, otherwise character case will be ignored
   ///
   /// \return -1 if lhs < rhs, 0 if lhs == rhs, 1 if lhs > rhs
-  static int Compare(ConstString lhs, ConstString rhs,
+  static int Compare(const ConstString &lhs, const ConstString &rhs,
                      const bool case_sensitive = true);
 
   /// Dump the object description to a stream.
@@ -371,7 +371,7 @@ class ConstString {
   ///     The already uniqued mangled ConstString to correlate the
   ///     soon to be uniqued version of \a demangled.
   void SetStringWithMangledCounterpart(llvm::StringRef demangled,
-                                       ConstString mangled);
+                                       const ConstString &mangled);
 
   /// Retrieve the mangled or demangled counterpart for a mangled or demangled
   /// ConstString.
@@ -452,7 +452,7 @@ class ConstString {
 };
 
 /// Stream the string value \a str to the stream \a s
-Stream &operator<<(Stream &s, ConstString str);
+Stream &operator<<(Stream &s, const ConstString &str);
 
 } // namespace lldb_private
 
@@ -473,11 +473,11 @@ template <> struct DenseMapInfo<lldb_private::ConstString> {
     return lldb_private::ConstString::FromStringPoolPointer(
         DenseMapInfo<const char *>::getTombstoneKey());
   }
-  static unsigned getHashValue(lldb_private::ConstString val) {
+  static unsigned getHashValue(const lldb_private::ConstString &val) {
     return DenseMapInfo<const char *>::getHashValue(val.m_string);
   }
-  static bool isEqual(lldb_private::ConstString LHS,
-                      lldb_private::ConstString RHS) {
+  static bool isEqual(const lldb_private::ConstString &LHS,
+                      const lldb_private::ConstString &RHS) {
     return LHS == RHS;
   }
 };
@@ -491,7 +491,8 @@ template <> struct ScalarTraits<lldb_private::ConstString> {
 };
 } // namespace yaml
 
-inline raw_ostream &operator<<(raw_ostream &os, lldb_private::ConstString s) {
+inline raw_ostream &operator<<(raw_ostream &os,
+                               const lldb_private::ConstString &s) {
   os << s.GetStringRef();
   return os;
 }

lldb/include/lldb/Utility/GDBRemote.h

@@ -10,7 +10,7 @@
 #define LLDB_UTILITY_GDBREMOTE_H
 
 #include "lldb/Utility/FileSpec.h"
-#include "lldb/Utility/Reproducer.h"
+#include "lldb/Utility/ReproducerProvider.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-public.h"

lldb/include/lldb/Utility/ProcessInfo.h

@@ -14,7 +14,6 @@
 #include "lldb/Utility/Environment.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/NameMatches.h"
-#include "lldb/Utility/Reproducer.h"
 #include "llvm/Support/YAMLTraits.h"
 #include <vector>
 
@@ -217,40 +216,7 @@ class ProcessInstanceInfoMatch {
 };
 
 namespace repro {
-class ProcessInfoRecorder : public AbstractRecorder {
-public:
-  ProcessInfoRecorder(const FileSpec &filename, std::error_code &ec)
-      : AbstractRecorder(filename, ec) {}
-
-  static llvm::Expected<std::unique_ptr<ProcessInfoRecorder>>
-  Create(const FileSpec &filename);
-
-  void Record(const ProcessInstanceInfoList &process_infos);
-};
-
-class ProcessInfoProvider : public repro::Provider<ProcessInfoProvider> {
-public:
-  struct Info {
-    static const char *name;
-    static const char *file;
-  };
-
-  ProcessInfoProvider(const FileSpec &directory) : Provider(directory) {}
-
-  ProcessInfoRecorder *GetNewProcessInfoRecorder();
-
-  void Keep() override;
-  void Discard() override;
-
-  static char ID;
-
-private:
-  std::unique_ptr<llvm::raw_fd_ostream> m_stream_up;
-  std::vector<std::unique_ptr<ProcessInfoRecorder>> m_process_info_recorders;
-};
-
 llvm::Optional<ProcessInstanceInfoList> GetReplayProcessInstanceInfoList();
-
 } // namespace repro
 } // namespace lldb_private
 

lldb/include/lldb/Utility/RegisterValue.h

@@ -18,6 +18,7 @@
 #include "llvm/ADT/StringRef.h"
 #include <cstdint>
 #include <cstring>
+#include <utility>
 
 namespace lldb_private {
 class DataExtractor;
@@ -60,7 +61,7 @@ class RegisterValue {
   }
 
   explicit RegisterValue(llvm::APInt inst) : m_type(eTypeUInt128) {
-    m_scalar = llvm::APInt(inst);
+    m_scalar = llvm::APInt(std::move(inst));
   }
 
   explicit RegisterValue(float value) : m_type(eTypeFloat) { m_scalar = value; }
@@ -169,7 +170,7 @@ class RegisterValue {
 
   void operator=(llvm::APInt uint) {
     m_type = eTypeUInt128;
-    m_scalar = llvm::APInt(uint);
+    m_scalar = llvm::APInt(std::move(uint));
   }
 
   void operator=(float f) {
@@ -209,7 +210,7 @@ class RegisterValue {
 
   void SetUInt128(llvm::APInt uint) {
     m_type = eTypeUInt128;
-    m_scalar = uint;
+    m_scalar = std::move(uint);
   }
 
   bool SetUInt(uint64_t uint, uint32_t byte_size);