[RFC] Add GDB remote packet reproducer.

[JDevlieghere]

Summary

RFC on the mailing list: http://lists.llvm.org/pipermail/lldb-dev/2018-September/014184.html

[sgraenitz]

Hi Jonas, great you are working on this! I look through and can't say much about the logic. It looks good to me, just added a few notes on minor things.

include/lldb/Utility/Reproducer.h

29

Not sure if this is relevant here, but in my experience nested classes always caused trouble as there is still no way in C++ to forward declare their names.

49

This returns a copy by value, while AddProviderToIndex() takes a const ref (that makes sense because ProviderInfo is no sink argument there).
It works because local const refs prolong the lifespan of the temporary, but is it intended?

100

This is the same as Provider &Register(std::unique_ptr<Provider> provider);

https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#Rf-consume

source/Utility/Reproducer.cpp

35

Missing brackets, should be assert((!value || !use_reproducer) && "..."); Same below.

[JDevlieghere]

Thanks for the review Stefan!

[shafik]

source/Utility/CMakeLists.txt

64

Do you also need to update the Xcode project?

[JDevlieghere]

source/Utility/CMakeLists.txt

64

Yup. I'm using the cmake build for development so I'll leave that until the end of the review.

[JDevlieghere]

ping

[JDevlieghere]

I'm having some trouble with the test case. Based on the initialization code I assume I'm not supposed to destroy the SBDebugger singleton shared by the LLDB test suite. If I do it anyway the test crashes with the an exception:

libc++abi.dylib: terminating with uncaught exception of type std::__1::system_error: recursive_mutex lock failed: Invalid argument

Instead I tried to create my own SBDebugger instance and do everything though my_debugger.GetCommandInterpreter().HandleCommand(). But then I don't get a backtrace:

Output Message:
* thread #1
  * frame #0: 0x0000000100004000 dyld`_dyld_start

While I expect:

* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
  * frame #0: 0x0000000100000f48 a.out`foo at main.c:13
    frame #1: 0x0000000100000f7b a.out`main(argc=1, argv=0x00007ffeefbff188) at main.c:17
    frame #2: 0x00007fff6b9380a1 libdyld.dylib`start + 1
    frame #3: 0x00007fff6b9380a1 libdyld.dylib`start + 1

Anybody know what I'm doing wrong here?

[sgraenitz]

Sorry, I can't help with the test. Code looks great! Only a few minor things inline.

source/Core/Debugger.cpp

593

Is static_cast<bool>(p) not working?

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationHistory.h

56

The default is support to record no history? I think the % operator in NormalizeIndex() will cause UB in that case.

98

This code existed already, but anyway: it's an overwriting ring buffer right? Maybe that's worth a comment.
Is there another usage apart from DumpProcessGDBRemotePacketHistory?

[shafik]

First batch of comments, may come back to it today.

source/Host/common/HostInfoBase.cpp

200

So C++11 made it thread safe when initializing a static variable see stmt.dcl/p4 and also std::call_once docs also mention this.

Is there a reason why in llvm we would prefer call_once?

source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp

1256

5 looks like a magic number, we should give it a name.

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationHistory.h

44

It says binary data but it contains a string ... it feels confusing. I can see the underlying methods you are using take char which is annoying since char could be either signed or unsigned so not obvious which u/int8_t make sense.

source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

3465

It is not obvious to me what the underlying assumptions but GetTarget() is locking a weak_ptr don't we have to check and make sure we actually obtain a non empty result? I realize that is not directly here but then why use a weak_ptr if we never verify the return of lock() ?

[aprantl]

source/API/SBDebugger.cpp

1057

This pattern appears multiple times in this file. Factor it out into a make / get CStringOrNull() function?

source/Core/Debugger.cpp

290

Will it do this on the side or on demand? If it is the former, then "log" seems more appropriate than "generate". If it is the latter, the help text should indicate what triggers the generation.

What about "replay" instead of "reproduce"?

597

clang-format

599

I don't understand that comment. What's that?

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationHistory.cpp

40

if (!size)
  return;

56

ditto

85

if (!log) return ...

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationHistory.h

24

Doxygen comments?

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationReplayServer.cpp

63

please invert the condition and early-exit in the error case.

150

invert

186

while (true)

195

return nullptr

198

return nullptr

Does this ever return anything else?

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationReplayServer.h

21

These should be before the C++ includes.

37

Doxygen?

source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

3466

Factor this out into a static function?

[JDevlieghere]

Thanks a lot for the review feedback everyone!

source/API/SBDebugger.cpp

1057

I don't think that would help a lot:

• It only happens twice: for the prompt and for the reproducer.
• We call different methods on m_opaque_sp so we'd have to pass a lambda or function pointer.

source/Core/Debugger.cpp

290

Sounds good!

source/Host/common/HostInfoBase.cpp

200

I just copied the code from somewhere else. However, your link to cppref specifies thread safety for function-local statics, which is not the case here. I don't think that guarantee applies to globals?

source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp

1256

I moved this code, but you're totally right, I had to open the header to know what it was.

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationHistory.h

98

Added it to the Doxygen comment.

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationReplayServer.cpp

198

Nope :-)

[friss]

source/Host/common/HostInfoBase.cpp

200

call_once is better for a couple reasons:

• it avoid a static constructor which would slow down the launch/loading of the debugger.
• When you have global objects, you have to care not only about their construction, but also their destruction. This will cost time on exit and potentially introduce ordering issues if those objects use other global resources.

[shafik]

source/Host/common/HostInfoBase.cpp

200

Fred, thank you for the comments on general usage.

200

It is not obvious this is being invoked during global construction ... so I guess that would mean Generator is a global since that seems to be what is calling GetReproducerTempDir?

Maybe a comment explaining the rationale would help prevent someone in the future from coming around and saying hey we can refactor this.

[friss]

source/Host/common/HostInfoBase.cpp

200

Note that my comment was really general about the use of call_once. I'm a little ashamed to admit that I haven't actually looked at this particular case :-)

[JDevlieghere]

Ping. Anybody have any potential issues/suggestions/concerns regarding this patch?

[JDevlieghere]

• Introduce command object for reproducers.
• Fix issue where lifetime of the reproducer conflicted with the lifetime of the GDB remote process.
• Ensure packets are properly flushed.
• Reduce complexity in test.

[JDevlieghere]

• Rebase
• Replace reproducer capture -enable and reproducer capture -disable with reproducer capture enable and reproducer capture disable

[jingham]

LGTM

[JDevlieghere]

Forgot to edit the patch description before landing this.

This landed in rL346780

[sidneym]

In D50254#1239334, @JDevlieghere wrote:

I'm having some trouble with the test case. Based on the initialization code I assume I'm not supposed to destroy the SBDebugger singleton shared by the LLDB test suite. If I do it anyway the test crashes with the an exception:

libc++abi.dylib: terminating with uncaught exception of type std::__1::system_error: recursive_mutex lock failed: Invalid argument

I'm looking at a similar issue that happens during extended lldb testing. I see the following error: "terminating with uncaught exception of type std::__1::system_error: mutex lock failed: Invalid argument "

It happens *very* infrequently, a fraction of a percentage of the time, and only seems to happen on release builds and always when lldb test appears to be exiting. Looks like this:

test_find_types_struct_type (TestFindStructTypes.TestFindTypesOnStructType)

Ran 1 test in 0.813s

RESULT: PASSED (1 passes, 0 failures, 0 errors, 0 skipped, 0 expected failures, 0 unexpected successes)
terminating with uncaught exception of type std::__1::system_error: mutex lock failed: Invalid argument

---

This causes the harness to report false failures and there is no clear cut pattern of failure so I can note the tests as flaky and rerun.

Any clue as to what I might look at? I think it might be something in the teardown sequence in Debugger.cpp.

Thanks

include/lldb/API/SBDebugger.h

public:
 
   lldb::SBTarget CreateTargetWithFileAndTargetTriple(const char *filename,
                                                      const char *target_triple);
 
   lldb::SBTarget CreateTargetWithFileAndArch(const char *filename,
                                              const char *archname);
 
   lldb::SBTarget CreateTarget(const char *filename);
-  
   lldb::SBTarget GetDummyTarget();
 
   // Return true if target is deleted from the target list of the debugger.
   bool DeleteTarget(lldb::SBTarget &target);
 
   lldb::SBTarget GetTargetAtIndex(uint32_t idx);
 
   uint32_t GetIndexOfTarget(lldb::SBTarget target);
public:
   void SetTerminalWidth(uint32_t term_width);
 
   lldb::user_id_t GetID();
 
   const char *GetPrompt() const;
 
   void SetPrompt(const char *prompt);
 
+  const char *GetReproducerPath() const;
+
+  void SetReproducerPath(const char *reproducer);
+
   lldb::ScriptLanguage GetScriptLanguage() const;
 
   void SetScriptLanguage(lldb::ScriptLanguage script_lang);
 
   bool GetCloseInputOnEOF() const;
 
   void SetCloseInputOnEOF(bool b);
 

include/lldb/Core/Debugger.h

 #include "lldb/Core/UserSettingsController.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/Terminal.h"
 #include "lldb/Target/ExecutionContext.h" // for ExecutionContext
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/TargetList.h"
 #include "lldb/Utility/ConstString.h" // for ConstString
 #include "lldb/Utility/FileSpec.h"    // for FileSpec
+#include "lldb/Utility/Reproducer.h"
 #include "lldb/Utility/Status.h"      // for Status
 #include "lldb/Utility/UserID.h"
 #include "lldb/lldb-defines.h"              // for DISALLOW_COPY_AND_ASSIGN
 #include "lldb/lldb-enumerations.h"         // for ScriptLanguage, Langua...
 #include "lldb/lldb-forward.h"              // for StreamFileSP, DebuggerSP
 #include "lldb/lldb-private-enumerations.h" // for VarSetOperationType
 #include "lldb/lldb-private-types.h"        // for LoadPluginCallbackType
 #include "lldb/lldb-types.h"                // for LogOutputCallback, thr...
public:
 
   bool EnableLog(llvm::StringRef channel,
                  llvm::ArrayRef<const char *> categories,
                  llvm::StringRef log_file, uint32_t log_options,
                  llvm::raw_ostream &error_stream);
 
   void SetLoggingCallback(lldb::LogOutputCallback log_callback, void *baton);
 
+  repro::Reproducer &GetReproducer() { return m_reproducer; }
+
   //----------------------------------------------------------------------
   // Properties Functions
   //----------------------------------------------------------------------
   enum StopDisassemblyType {
     eStopDisassemblyTypeNever = 0,
     eStopDisassemblyTypeNoDebugInfo,
     eStopDisassemblyTypeNoSource,
     eStopDisassemblyTypeAlways
public:
   bool GetPrintDecls() const;
 
   bool SetPrintDecls(bool b);
 
   uint32_t GetTabSize() const;
 
   bool SetTabSize(uint32_t tab_size);
 
+  bool GetGenerateReproducer() const;
+
+  bool SetGenerateReproducer(bool b);
+
+  FileSpec GetReproducerPath() const;
+
+  void SetReproducerPath(const FileSpec &p);
+
   bool GetEscapeNonPrintables() const;
 
   bool GetNotifyVoid() const;
 
   const ConstString &GetInstanceName() { return m_instance_name; }
 
   bool LoadPlugin(const FileSpec &spec, Status &error);
 
protected:
   static LoadPluginCallbackType g_load_plugin_callback;
   typedef std::vector<llvm::sys::DynamicLibrary> LoadedPluginsList;
   LoadedPluginsList m_loaded_plugins;
   HostThread m_event_handler_thread;
   HostThread m_io_handler_thread;
   Broadcaster m_sync_broadcaster;
   lldb::ListenerSP m_forward_listener_sp;
   llvm::once_flag m_clear_once;
+  repro::Reproducer m_reproducer;
 
   //----------------------------------------------------------------------
   // Events for m_sync_broadcaster
   //----------------------------------------------------------------------
   enum {
     eBroadcastBitEventThreadIsListening = (1 << 0),
   };
 

include/lldb/Host/HostInfoBase.h

public:
   /// filled in.
   static FileSpec GetProcessTempDir();
 
   /// Returns the global temporary directory. This directory will **not** be
   /// cleaned up when this process exits. Only the directory member of the
   /// FileSpec is filled in.
   static FileSpec GetGlobalTempDir();
 
+  /// Returns the reproducer temporary directory. This directory will **not**
+  /// be automatically cleaned up when this process exits, but might be removed
+  /// by the reproducer generator. Only the directory member of the FileSpec is
+  /// filled in.
+  static FileSpec GetReproducerTempDir();
+
   //---------------------------------------------------------------------------
   /// If the triple does not specify the vendor, os, and environment parts, we
   /// "augment" these using information from the host and return the resulting
   /// ArchSpec object.
   //---------------------------------------------------------------------------
   static ArchSpec GetAugmentedArchSpec(llvm::StringRef triple);
 
 protected:
   static bool ComputeSharedLibraryDirectory(FileSpec &file_spec);
   static bool ComputeSupportExeDirectory(FileSpec &file_spec);
   static bool ComputeProcessTempFileDirectory(FileSpec &file_spec);
   static bool ComputeGlobalTempFileDirectory(FileSpec &file_spec);
+  static bool ComputeReproducerTempFileDirectory(FileSpec &file_spec);
   static bool ComputeTempFileBaseDirectory(FileSpec &file_spec);
   static bool ComputeHeaderDirectory(FileSpec &file_spec);
   static bool ComputeSystemPluginsDirectory(FileSpec &file_spec);
   static bool ComputeUserPluginsDirectory(FileSpec &file_spec);
 
   static void ComputeHostArchitectureSupport(ArchSpec &arch_32,
                                              ArchSpec &arch_64);
 };
 }
 
 #endif

include/lldb/Utility/Reproducer.h

+//===-- Reproducer.h --------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_UTILITY_REPRODUCER_H
+#define LLDB_UTILITY_REPRODUCER_H
+
+#include "lldb/Utility/FileSpec.h"
+
+#include "llvm/ADT/StringMap.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/YAMLTraits.h"
+
+#include <mutex>
+#include <string>
+#include <vector>
+
+namespace lldb_private {
+namespace repro {
+
+class Reproducer;
+
+/// Abstraction for information associated with a provider. This information
+/// is serialized into an index which is used by the loader.
+struct ProviderInfo {
+  std::string name;
+  std::vector<std::string> files;
+};
+
+/// The provider defines an interface for generating files needed for
+/// reproducing. The provider must populate its ProviderInfo to communicate
+/// its name and files to the index, before registering with the generator,
+/// i.e. in the constructor.
+///
+/// Different components will implement different providers.
+class Provider {
+public:
+  virtual ~Provider() = default;
+
+  const ProviderInfo &GetInfo() { return m_info; }
+  const FileSpec &GetDirectory() { return m_directory; }
+
+  /// The Keep method is called when it is decided that we need to keep the
+  /// data in order to provide a reproducer.
+  virtual void Keep(){};
+
+  /// The Discard method is called when it is decided that we do not need to
+  /// keep any information and will not generate a reproducer.
+  virtual void Discard(){};
+
+protected:
+  Provider(FileSpec directory) : m_directory(directory) {}
+
+  /// Every provider keeps track of its own files.
+  ProviderInfo m_info;
+
+private:
+  /// Every provider knows where to dump its potential files.
+  FileSpec m_directory;
+};
+
+/// The generator is responsible for the logic needed to generate a
+/// reproducer. For doing so it relies on providers, who serialize data that
+/// is necessary for reproducing  a failure.
+class Generator final {
+public:
+  Generator();
+  ~Generator();
+
+  /// Method to indicate we want to keep the reproducer. If reproducer
+  /// generation is disabled, this does nothing.
+  void Keep();
+
+  /// Method to indicate we do not want to keep the reproducer. This is
+  /// unaffected by whether or not generation reproduction is enabled, as we
+  /// might need to clean up files already written to disk.
+  void Discard();
+
+  /// Providers are registered at creating time.
+  template <typename T> T &CreateProvider() {
+    std::unique_ptr<T> provider = llvm::make_unique<T>(m_directory);
+    return static_cast<T &>(Register(std::move(provider)));
+  }
+
+  void ChangeDirectory(const FileSpec &directory);
+
+private:
+  friend Reproducer;
+
+  void SetEnabled(bool enabled) { m_enabled = enabled; }
+  Provider &Register(std::unique_ptr<Provider> provider);
+  void AddProviderToIndex(const ProviderInfo &provider_info);
+
+  std::vector<std::unique_ptr<Provider>> m_providers;
+  std::mutex m_providers_mutex;
+
+  /// The reproducer root directory.
+  FileSpec m_directory;
+
+  /// Flag for controlling whether we generate a reproducer when Keep is
+  /// called.
+  bool m_enabled;
+
+  /// Flag to ensure that we never call both keep and discard.
+  bool m_done;
+};
+
+class Loader final {
+public:
+  Loader();
+
+  llvm::Optional<ProviderInfo> GetProviderInfo(llvm::StringRef name);
+  llvm::Error LoadIndex(const FileSpec &directory);
+
+  const FileSpec &GetDirectory() { return m_directory; }
+
+private:
+  llvm::StringMap<ProviderInfo> m_provider_info;
+  FileSpec m_directory;
+  bool m_loaded;
+};
+
+/// The reproducer enables clients to obtain access to the Generator and
+/// Loader.
+class Reproducer final {
+
+public:
+  Generator *GetGenerator();
+  Loader *GetLoader();
+
+  void SetGenerateReproducer(bool value);
+  void SetUseReproducer(bool value);
+
+private:
+  Generator m_generator;
+  Loader m_loader;
+
+  bool m_generate_reproducer = false;
+  bool m_use_reproducer = false;
+};
+
+} // namespace repro
+} // namespace lldb_private
+
+LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(lldb_private::repro::ProviderInfo)
+
+namespace llvm {
+namespace yaml {
+
+template <> struct MappingTraits<lldb_private::repro::ProviderInfo> {
+  static void mapping(IO &io, lldb_private::repro::ProviderInfo &info) {
+    io.mapRequired("name", info.name);
+    io.mapOptional("files", info.files);
+  }
+};
+} // namespace yaml
+} // namespace llvm
+
+#endif // LLDB_UTILITY_REPRODUCER_H

packages/Python/lldbsuite/test/functionalities/reproducer/gdb-remote/Makefile

+LEVEL = ../../../make
+
+C_SOURCES := main.c
+
+include $(LEVEL)/Makefile.rules

packages/Python/lldbsuite/test/functionalities/reproducer/gdb-remote/TestGdbRemoteReproducer.py

+"""
+Test the GDB remote reproducer.
+"""
+
+from __future__ import print_function
+
+import os
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestGdbRemoteReproducer(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def reset(self):
+        lldb.SBDebugger.Destroy(lldb.dbg)
+        lldb.dbg = lldb.SBDebugger.Create()
+
+    def contains(self, retobject, substrs, message):
+        for string in substrs:
+            self.assertTrue(string in retobj.GetOutput(), message)
+
+    def test(self):
+        """Test record and replay of gdb-remote packets."""
+        self.build()
+
+        debugger_1 = lldb.SBDebugger.Create(False)
+        interpreter_1 = debugger_1.GetCommandInterpreter()
+        retobj = lldb.SBCommandReturnObject()
+
+        # Create temp directory for the reproducer.
+        temp_dir = tempfile.mkdtemp()
+
+        # Run debug session and record gdb remote packets.
+        interpreter_1.HandleCommand("settings set log-reproducer true", retobj)
+        self.assertTrue(retobj.Succeeded())
+
+        interpreter_1.HandleCommand("settings set reproducer-path {}".format(temp_dir), retobj)
+        self.assertTrue(retobj.Succeeded())
+
+        exe = self.getBuildArtifact("a.out")
+        interpreter_1.HandleCommand("file {}".format(exe), retobj)
+        self.assertTrue(retobj.Succeeded())
+        print(str(retobj))
+
+        interpreter_1.HandleCommand("breakpoint set -f main.c -l 13", retobj)
+        self.assertTrue(retobj.Succeeded())
+        print(str(retobj))
+
+        interpreter_1.HandleCommand("run", retobj)
+        self.assertTrue(retobj.Succeeded())
+        print(str(retobj))
+
+        interpreter_1.HandleCommand("bt", retobj)
+        self.assertTrue(retobj.Succeeded())
+        print(str(retobj))
+
+        interpreter_1.HandleCommand("cont", retobj)
+        self.assertTrue(retobj.Succeeded())
+        print(str(retobj))
+
+        lldb.SBDebugger.Destroy(debugger_1)
+
+        return
+
+        lldbutil.run_break_set_by_file_and_line(
+            self, "main.c", 13, loc_exact=True)
+
+        self.runCmd("run", RUN_SUCCEEDED)
+
+        self.expect(
+            "bt",
+            substrs=['a.out`foo', 'main.c:13', 'a.out`main', 'main.c:17'])
+
+        self.expect('cont', 'testing')
+
+        # Reset the debugger instance.
+        self.reset()
+
+        # Ensure reproducer files are in our temp directory.
+        self.assertTrue(os.path.exists(os.path.join(temp_dir, 'index.yaml')))
+        self.assertTrue(
+            os.path.exists(os.path.join(temp_dir, 'gdb-remote.yaml')))
+
+        exe = self.getBuildArtifact("a.out")
+        target = self.dbg.CreateTarget(exe)
+
+        # Now replay the session from the reproducer.
+        self.runCmd("settings set reproducer-path {}".format(temp_dir))
+
+        lldbutil.run_break_set_by_file_and_line(
+            self, "main.c", 13, loc_exact=True)
+
+        self.runCmd("run", RUN_SUCCEEDED)
+
+        self.expect(
+            "bt",
+            substrs=['a.out`foo', 'main.c:13', 'a.out`main', 'main.c:17'])
+
+        # Ensure we're looking at the replay and we don't seen the binary's
+        # output.
+        self.expect('cont', matching=False, substrs=['testing'])
+
+        # Reset the debugger instance.
+        self.reset()

packages/Python/lldbsuite/test/functionalities/reproducer/gdb-remote/main.c

+//===-- main.c --------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+void foo() {
+    printf("testing\n");
+}
+
+int main (int argc, char const *argv[]) {
+    foo();
+    return 0;
+}

source/API/SBDebugger.cpp

return (m_opaque_sp ? ConstString(m_opaque_sp->GetPrompt()).GetCString()
                       : nullptr);
 }
 
 void SBDebugger::SetPrompt(const char *prompt) {
   if (m_opaque_sp)
     m_opaque_sp->SetPrompt(llvm::StringRef::withNullAsEmpty(prompt));
 }
 
+const char *SBDebugger::GetReproducerPath() const {
+  return (
+      m_opaque_sp
+          ? ConstString(m_opaque_sp->GetReproducerPath().GetPath()).GetCString()
+          : nullptr);
+}
+
+void SBDebugger::SetReproducerPath(const char *p) {
+  if (m_opaque_sp)
+    m_opaque_sp->SetReproducerPath(FileSpec(p, true));
+}
+
 ScriptLanguage SBDebugger::GetScriptLanguage() const {
   return (m_opaque_sp ? m_opaque_sp->GetScriptLanguage() : eScriptLanguageNone);
 }
 
 void SBDebugger::SetScriptLanguage(ScriptLanguage script_lang) {
   if (m_opaque_sp) {
     m_opaque_sp->SetScriptLanguage(script_lang);
   }

source/Core/Debugger.cpp

static PropertyDefinition g_properties[] = {
     {"escape-non-printables", OptionValue::eTypeBoolean, true, true, nullptr,
      nullptr,
      "If true, LLDB will automatically escape non-printable and "
      "escape characters when formatting strings."},
     {"frame-format-unique", OptionValue::eTypeFormatEntity, true, 0,
      DEFAULT_FRAME_FORMAT_NO_ARGS, nullptr,
      "The default frame format string to use when displaying stack frame"
      "information for threads from thread backtrace unique."},
+    {"log-reproducer", OptionValue::eTypeBoolean, false, false, nullptr,
+     nullptr,
+     "If true, LLDB will gather and log data necessary to replay the current "
+     "session."},
+    {"reproducer-path", OptionValue::eTypeFileSpec, false, 0, nullptr, nullptr,
+     "If set, LLDB will replay the session from the provided reproducer."},
     {nullptr, OptionValue::eTypeInvalid, true, 0, nullptr, nullptr, nullptr}};
 
 enum {
   ePropertyAutoConfirm = 0,
   ePropertyDisassemblyFormat,
   ePropertyFrameFormat,
   ePropertyNotiftVoid,
   ePropertyPrompt,
enum {
   ePropertyUseExternalEditor,
   ePropertyUseColor,
   ePropertyAutoOneLineSummaries,
   ePropertyAutoIndent,
   ePropertyPrintDecls,
   ePropertyTabSize,
   ePropertyEscapeNonPrintables,
   ePropertyFrameFormatUnique,
+  ePropertyGenerateReproducer,
+  ePropertyReproducerPath,
 };
 
 LoadPluginCallbackType Debugger::g_load_plugin_callback = nullptr;
 
 Status Debugger::SetPropertyValue(const ExecutionContext *exe_ctx,
                                   VarSetOperationType op,
                                   llvm::StringRef property_path,
                                   llvm::StringRef value) {
if (property_path == g_properties[ePropertyPrompt].name) {
       auto bytes = llvm::make_unique<EventDataBytes>(new_prompt);
       auto prompt_change_event_sp = std::make_shared<Event>(
           CommandInterpreter::eBroadcastBitResetPrompt, bytes.release());
       GetCommandInterpreter().BroadcastEvent(prompt_change_event_sp);
     } else if (property_path == g_properties[ePropertyUseColor].name) {
       // use-color changed. Ping the prompt so it can reset the ansi terminal
       // codes.
       SetPrompt(GetPrompt());
+    } else if (property_path ==
+               g_properties[ePropertyGenerateReproducer].name) {
+      SetGenerateReproducer(GetGenerateReproducer());
+    } else if (property_path == g_properties[ePropertyReproducerPath].name) {
+      SetReproducerPath(GetReproducerPath());
     } else if (is_load_script && target_sp &&
                load_script_old_value == eLoadScriptFromSymFileWarn) {
       if (target_sp->TargetProperties::GetLoadScriptFromSymbolFile() ==
           eLoadScriptFromSymFileTrue) {
         std::list<Status> errors;
         StreamString feedback_stream;
         if (!target_sp->LoadScriptingResources(errors, &feedback_stream)) {
           StreamFileSP stream_sp(GetErrorFile());
return m_collection_sp->GetPropertyAtIndexAsUInt64(
       nullptr, idx, g_properties[idx].default_uint_value);
 }
 
 bool Debugger::SetTabSize(uint32_t tab_size) {
   const uint32_t idx = ePropertyTabSize;
   return m_collection_sp->SetPropertyAtIndexAsUInt64(nullptr, idx, tab_size);
 }
 
+bool Debugger::GetGenerateReproducer() const {
+  const uint32_t idx = ePropertyGenerateReproducer;
+  return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, true);
+}
+
+bool Debugger::SetGenerateReproducer(bool b) {
+  const uint32_t idx = ePropertyGenerateReproducer;
+  m_reproducer.SetGenerateReproducer(b);
+  return m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
+}
+
+FileSpec Debugger::GetReproducerPath() const {
+  const uint32_t idx = ePropertyReproducerPath;
+  return m_collection_sp->GetPropertyAtIndexAsFileSpec(nullptr, idx);
+}
+
+void Debugger::SetReproducerPath(const FileSpec &p) {
+  const uint32_t idx = ePropertyReproducerPath;
+  m_collection_sp->SetPropertyAtIndexAsFileSpec(nullptr, idx, p);
+
+  if (!GetGenerateReproducer()) {
+    m_reproducer.SetUseReproducer(static_cast<bool>(p));
+    if (auto loader = m_reproducer.GetLoader())
+      if (auto e = loader->LoadIndex(p))
+        llvm::consumeError(std::move(e));
+  } else if (auto generator = m_reproducer.GetGenerator()) {
+    // If the reproducer path is set *after* we've already enabled logging of a
+    // reproducer, we use the given path as the reproducer root.
+    generator->ChangeDirectory(p);
+  }
+}
+
 #pragma mark Debugger
 
 // const DebuggerPropertiesSP &
 // Debugger::GetSettings() const
 //{
 //    return m_properties_sp;
 //}
 //

source/Host/common/HostInfoBase.cpp

llvm::call_once(g_once_flag, []() {
     success = HostInfo::ComputeGlobalTempFileDirectory(
         g_fields->m_lldb_global_tmp_dir);
     Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
     LLDB_LOG(log, "global temp dir -> `{0}`", g_fields->m_lldb_global_tmp_dir);
   });
   return success ? g_fields->m_lldb_global_tmp_dir : FileSpec();
 }
 
+FileSpec HostInfoBase::GetReproducerTempDir() {
+  static llvm::once_flag g_once_flag;
+  static bool success = false;
+  llvm::call_once(g_once_flag, []() {
+    success = HostInfo::ComputeReproducerTempFileDirectory(
+        g_fields->m_lldb_global_tmp_dir);
+    Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
+    LLDB_LOG(log, "reproducer temp dir -> `{0}`",
+             g_fields->m_lldb_global_tmp_dir);
+  });
+  return success ? g_fields->m_lldb_global_tmp_dir : FileSpec();
+}
+
 ArchSpec HostInfoBase::GetAugmentedArchSpec(llvm::StringRef triple) {
   if (triple.empty())
     return ArchSpec();
   llvm::Triple normalized_triple(llvm::Triple::normalize(triple));
   if (!ArchSpec::ContainsOnlyArch(normalized_triple))
     return ArchSpec(triple);
 
   if (auto kind = HostInfo::ParseArchitectureKind(triple))
bool HostInfoBase::ComputeGlobalTempFileDirectory(FileSpec &file_spec) {
   temp_file_spec.AppendPathComponent("lldb");
   if (llvm::sys::fs::create_directory(temp_file_spec.GetPath()))
     return false;
 
   file_spec.GetDirectory().SetCString(temp_file_spec.GetCString());
   return true;
 }
 
+bool HostInfoBase::ComputeReproducerTempFileDirectory(FileSpec &file_spec) {
+  file_spec.Clear();
+
+  FileSpec temp_file_spec;
+  if (!HostInfo::ComputeTempFileBaseDirectory(temp_file_spec))
+    return false;
+
+  temp_file_spec.AppendPathComponent("reproducer");
+  if (llvm::sys::fs::create_directory(temp_file_spec.GetPath()))
+    return false;
+
+  std::string pid_str{llvm::to_string(Host::GetCurrentProcessID())};
+  temp_file_spec.AppendPathComponent(pid_str);
+  if (llvm::sys::fs::create_directory(temp_file_spec.GetPath()))
+    return false;
+
+  file_spec.GetDirectory().SetCString(temp_file_spec.GetCString());
+  return true;
+}
+
 bool HostInfoBase::ComputeHeaderDirectory(FileSpec &file_spec) {
   // TODO(zturner): Figure out how to compute the header directory for all
   // platforms.
   return false;
 }
 
 bool HostInfoBase::ComputeSystemPluginsDirectory(FileSpec &file_spec) {
   // TODO(zturner): Figure out how to compute the system plugins directory for

source/Plugins/Process/gdb-remote/CMakeLists.txt

 if(HAVE_LIBCOMPRESSION)
   set(LIBCOMPRESSION compression)
 endif()
 
 add_lldb_library(lldbPluginProcessGDBRemote PLUGIN
   GDBRemoteClientBase.cpp
   GDBRemoteCommunication.cpp
   GDBRemoteCommunicationClient.cpp
+  GDBRemoteCommunicationHistory.cpp
+  GDBRemoteCommunicationReplayServer.cpp
   GDBRemoteCommunicationServer.cpp
   GDBRemoteCommunicationServerCommon.cpp
   GDBRemoteCommunicationServerLLGS.cpp
   GDBRemoteCommunicationServerPlatform.cpp
   GDBRemoteRegisterContext.cpp
   ProcessGDBRemote.cpp
   ProcessGDBRemoteLog.cpp
   ThreadGDBRemote.cpp

source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h

 // C++ Includes
 #include <condition_variable>
 #include <mutex>
 #include <queue>
 #include <string>
 #include <vector>
 
 // Other libraries and framework includes
-// Project includes
 #include "lldb/Core/Communication.h"
 #include "lldb/Core/Listener.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/Predicate.h"
+#include "lldb/Utility/StringExtractorGDBRemote.h"
 #include "lldb/lldb-public.h"
 
-#include "lldb/Utility/StringExtractorGDBRemote.h"
+// Project includes
+#include "GDBRemoteCommunicationHistory.h"
 
 namespace lldb_private {
 namespace process_gdb_remote {
 
 typedef enum {
   eStoppointInvalid = -1,
   eBreakpointSoftware = 0,
   eBreakpointHardware,
Status StartDebugserverProcess(
       const char *url,
       Platform *platform, // If non nullptr, then check with the platform for
                           // the GDB server binary if it can't be located
       ProcessLaunchInfo &launch_info, uint16_t *port, const Args *inferior_args,
       int pass_comm_fd); // Communication file descriptor to pass during
                          // fork/exec to avoid having to connect/accept
 
   void DumpHistory(Stream &strm);
+  void SetHistoryStream(std::unique_ptr<llvm::raw_ostream> strm);
 
-protected:
-  class History {
-  public:
-    enum PacketType {
-      ePacketTypeInvalid = 0,
-      ePacketTypeSend,
-      ePacketTypeRecv
-    };
-
-    struct Entry {
-      Entry()
-          : packet(), type(ePacketTypeInvalid), bytes_transmitted(0),
-            packet_idx(0), tid(LLDB_INVALID_THREAD_ID) {}
-
-      void Clear() {
-        packet.clear();
-        type = ePacketTypeInvalid;
-        bytes_transmitted = 0;
-        packet_idx = 0;
-        tid = LLDB_INVALID_THREAD_ID;
-      }
-      std::string packet;
-      PacketType type;
-      uint32_t bytes_transmitted;
-      uint32_t packet_idx;
-      lldb::tid_t tid;
-    };
-
-    History(uint32_t size);
-
-    ~History();
-
-    // For single char packets for ack, nack and /x03
-    void AddPacket(char packet_char, PacketType type,
-                   uint32_t bytes_transmitted);
-
-    void AddPacket(const std::string &src, uint32_t src_len, PacketType type,
-                   uint32_t bytes_transmitted);
-
-    void Dump(Stream &strm) const;
-
-    void Dump(Log *log) const;
-
-    bool DidDumpToLog() const { return m_dumped_to_log; }
+  static llvm::Error ConnectLocally(GDBRemoteCommunication &client,
+                                    GDBRemoteCommunication &server);
 
-  protected:
-    uint32_t GetFirstSavedPacketIndex() const {
-      if (m_total_packet_count < m_packets.size())
-        return 0;
-      else
-        return m_curr_idx + 1;
-    }
-
-    uint32_t GetNumPacketsInHistory() const {
-      if (m_total_packet_count < m_packets.size())
-        return m_total_packet_count;
-      else
-        return (uint32_t)m_packets.size();
-    }
-
-    uint32_t GetNextIndex() {
-      ++m_total_packet_count;
-      const uint32_t idx = m_curr_idx;
-      m_curr_idx = NormalizeIndex(idx + 1);
-      return idx;
-    }
-
-    uint32_t NormalizeIndex(uint32_t i) const { return i % m_packets.size(); }
-
-    std::vector<Entry> m_packets;
-    uint32_t m_curr_idx;
-    uint32_t m_total_packet_count;
-    mutable bool m_dumped_to_log;
-  };
-
   std::chrono::seconds m_packet_timeout;
   uint32_t m_echo_number;
   LazyBool m_supports_qEcho;
-  History m_history;
+  GDBRemoteCommunicationHistory m_history;
   bool m_send_acks;
   bool m_is_platform; // Set to true if this class represents a platform,
                       // false if this class represents a debug session for
                       // a single process
 
   CompressionType m_compression_type;
 
   PacketResult SendPacketNoLock(llvm::StringRef payload);
+  PacketResult SendRawPacketNoLock(llvm::StringRef payload,
+                                   bool skip_ack = false);
 
   PacketResult ReadPacket(StringExtractorGDBRemote &response,
                           Timeout<std::micro> timeout, bool sync_on_timeout);
 
   PacketResult ReadPacketWithOutputSupport(
       StringExtractorGDBRemote &response, Timeout<std::micro> timeout,
       bool sync_on_timeout,
       llvm::function_ref<void(llvm::StringRef)> output_callback);

source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp

 //===-- GDBRemoteCommunication.cpp ------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "GDBRemoteCommunication.h"
 
 // C Includes
+#include <future>
 #include <limits.h>
 #include <string.h>
 #include <sys/stat.h>
 
 // C++ Includes
 // Other libraries and framework includes
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/Pipe.h"
 #include "lldb/Host/Socket.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Host/ThreadLauncher.h"
+#include "lldb/Host/common/TCPSocket.h"
+#include "lldb/Host/posix/ConnectionFileDescriptorPosix.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/StreamString.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/ScopedPrinter.h"

 #if defined(HAVE_LIBZ)
 #include <zlib.h>
 #endif
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::process_gdb_remote;
 
-GDBRemoteCommunication::History::History(uint32_t size)
-    : m_packets(), m_curr_idx(0), m_total_packet_count(0),
-      m_dumped_to_log(false) {
-  m_packets.resize(size);
-}
-
-GDBRemoteCommunication::History::~History() {}
-
-void GDBRemoteCommunication::History::AddPacket(char packet_char,
-                                                PacketType type,
-                                                uint32_t bytes_transmitted) {
-  const size_t size = m_packets.size();
-  if (size > 0) {
-    const uint32_t idx = GetNextIndex();
-    m_packets[idx].packet.assign(1, packet_char);
-    m_packets[idx].type = type;
-    m_packets[idx].bytes_transmitted = bytes_transmitted;
-    m_packets[idx].packet_idx = m_total_packet_count;
-    m_packets[idx].tid = llvm::get_threadid();
-  }
-}
-
-void GDBRemoteCommunication::History::AddPacket(const std::string &src,
-                                                uint32_t src_len,
-                                                PacketType type,
-                                                uint32_t bytes_transmitted) {
-  const size_t size = m_packets.size();
-  if (size > 0) {
-    const uint32_t idx = GetNextIndex();
-    m_packets[idx].packet.assign(src, 0, src_len);
-    m_packets[idx].type = type;
-    m_packets[idx].bytes_transmitted = bytes_transmitted;
-    m_packets[idx].packet_idx = m_total_packet_count;
-    m_packets[idx].tid = llvm::get_threadid();
-  }
-}
-
-void GDBRemoteCommunication::History::Dump(Stream &strm) const {
-  const uint32_t size = GetNumPacketsInHistory();
-  const uint32_t first_idx = GetFirstSavedPacketIndex();
-  const uint32_t stop_idx = m_curr_idx + size;
-  for (uint32_t i = first_idx; i < stop_idx; ++i) {
-    const uint32_t idx = NormalizeIndex(i);
-    const Entry &entry = m_packets[idx];
-    if (entry.type == ePacketTypeInvalid || entry.packet.empty())
-      break;
-    strm.Printf("history[%u] tid=0x%4.4" PRIx64 " <%4u> %s packet: %s\n",
-                entry.packet_idx, entry.tid, entry.bytes_transmitted,
-                (entry.type == ePacketTypeSend) ? "send" : "read",
-                entry.packet.c_str());
-  }
-}
-
-void GDBRemoteCommunication::History::Dump(Log *log) const {
-  if (log && !m_dumped_to_log) {
-    m_dumped_to_log = true;
-    const uint32_t size = GetNumPacketsInHistory();
-    const uint32_t first_idx = GetFirstSavedPacketIndex();
-    const uint32_t stop_idx = m_curr_idx + size;
-    for (uint32_t i = first_idx; i < stop_idx; ++i) {
-      const uint32_t idx = NormalizeIndex(i);
-      const Entry &entry = m_packets[idx];
-      if (entry.type == ePacketTypeInvalid || entry.packet.empty())
-        break;
-      log->Printf("history[%u] tid=0x%4.4" PRIx64 " <%4u> %s packet: %s",
-                  entry.packet_idx, entry.tid, entry.bytes_transmitted,
-                  (entry.type == ePacketTypeSend) ? "send" : "read",
-                  entry.packet.c_str());
-    }
-  }
-}
-
 //----------------------------------------------------------------------
 // GDBRemoteCommunication constructor
 //----------------------------------------------------------------------
 GDBRemoteCommunication::GDBRemoteCommunication(const char *comm_name,
                                                const char *listener_name)
     : Communication(comm_name),
 #ifdef LLDB_CONFIGURATION_DEBUG
       m_packet_timeout(1000),

 
 size_t GDBRemoteCommunication::SendAck() {
   Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PACKETS));
   ConnectionStatus status = eConnectionStatusSuccess;
   char ch = '+';
   const size_t bytes_written = Write(&ch, 1, status, NULL);
   if (log)
     log->Printf("<%4" PRIu64 "> send packet: %c", (uint64_t)bytes_written, ch);
-  m_history.AddPacket(ch, History::ePacketTypeSend, bytes_written);
+  m_history.AddPacket(ch, GDBRemoteCommunicationHistory::ePacketTypeSend,
+                      bytes_written);
   return bytes_written;
 }
 
 size_t GDBRemoteCommunication::SendNack() {
   Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PACKETS));
   ConnectionStatus status = eConnectionStatusSuccess;
   char ch = '-';
   const size_t bytes_written = Write(&ch, 1, status, NULL);
   if (log)
     log->Printf("<%4" PRIu64 "> send packet: %c", (uint64_t)bytes_written, ch);
-  m_history.AddPacket(ch, History::ePacketTypeSend, bytes_written);
+  m_history.AddPacket(ch, GDBRemoteCommunicationHistory::ePacketTypeSend,
+                      bytes_written);
   return bytes_written;
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunication::SendPacketNoLock(llvm::StringRef payload) {
-  if (IsConnected()) {
     StreamString packet(0, 4, eByteOrderBig);
-
     packet.PutChar('$');
     packet.Write(payload.data(), payload.size());
     packet.PutChar('#');
     packet.PutHex8(CalculcateChecksum(payload));
+    std::string packet_str = packet.GetString();
+
+    return SendRawPacketNoLock(packet_str);
+}
 
+GDBRemoteCommunication::PacketResult
+GDBRemoteCommunication::SendRawPacketNoLock(llvm::StringRef packet,
+                                            bool skip_ack) {
+  if (IsConnected()) {
     Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PACKETS));
     ConnectionStatus status = eConnectionStatusSuccess;
-    // TODO: Don't shimmy through a std::string, just use StringRef.
-    std::string packet_str = packet.GetString();
-    const char *packet_data = packet_str.c_str();
-    const size_t packet_length = packet.GetSize();
+    const char *packet_data = packet.data();
+    const size_t packet_length = packet.size();
     size_t bytes_written = Write(packet_data, packet_length, status, NULL);
     if (log) {
       size_t binary_start_offset = 0;
       if (strncmp(packet_data, "$vFile:pwrite:", strlen("$vFile:pwrite:")) ==
           0) {
         const char *first_comma = strchr(packet_data, ',');
         if (first_comma) {
           const char *second_comma = strchr(first_comma + 1, ',');
if (log) {
         // Print the checksum
         strm.Printf("%*s", (int)3, p);
         log->PutString(strm.GetString());
       } else
         log->Printf("<%4" PRIu64 "> send packet: %.*s", (uint64_t)bytes_written,
                     (int)packet_length, packet_data);
     }
 
-    m_history.AddPacket(packet.GetString(), packet_length,
-                        History::ePacketTypeSend, bytes_written);
+    m_history.AddPacket(packet.str(), packet_length,
+                        GDBRemoteCommunicationHistory::ePacketTypeSend,
+                        bytes_written);
 
     if (bytes_written == packet_length) {
-      if (GetSendAcks())
+      if (!skip_ack && GetSendAcks())
         return GetAck();
       else
         return PacketResult::Success;
     } else {
       if (log)
         log->Printf("error: failed to send packet: %.*s", (int)packet_length,
                     packet_data);
     }
if (content_length == std::string::npos) {
                         (int)(total_length), m_bytes.c_str());
           else
             log->Printf("<%4" PRIu64 "> read packet: %.*s",
                         (uint64_t)total_length, (int)(total_length),
                         m_bytes.c_str());
         }
       }
 
-      m_history.AddPacket(m_bytes, total_length, History::ePacketTypeRecv,
+      m_history.AddPacket(m_bytes, total_length,
+                          GDBRemoteCommunicationHistory::ePacketTypeRecv,
                           total_length);
 
       // Clear packet_str in case there is some existing data in it.
       packet_str.clear();
       // Copy the packet from m_bytes to packet_str expanding the run-length
       // encoding in the process. Reserve enough byte for the most common case
       // (no RLE used)
       packet_str.reserve(m_bytes.length());
if (log)
                   error.AsCString());
   }
 
   return error;
 }
 
 void GDBRemoteCommunication::DumpHistory(Stream &strm) { m_history.Dump(strm); }
 
+void GDBRemoteCommunication::SetHistoryStream(
+    std::unique_ptr<llvm::raw_ostream> strm) {
+  m_history.SetStream(std::move(strm));
+};
+
+llvm::Error
+GDBRemoteCommunication::ConnectLocally(GDBRemoteCommunication &client,
+                                       GDBRemoteCommunication &server) {
+  const bool child_processes_inherit = false;
+  const int backlog = 5;
+  TCPSocket listen_socket(true, child_processes_inherit);
+  if (llvm::Error error =
+          listen_socket.Listen("127.0.0.1:0", backlog).ToError())
+    return error;
+
+  Socket *accept_socket;
+  std::future<Status> accept_status = std::async(
+      std::launch::async, [&] { return listen_socket.Accept(accept_socket); });
+
+  llvm::SmallString<32> remote_addr;
+  llvm::raw_svector_ostream(remote_addr)
+      << "connect://localhost:" << listen_socket.GetLocalPortNumber();
+
+  std::unique_ptr<ConnectionFileDescriptor> conn_up(
+      new ConnectionFileDescriptor());
+  if (conn_up->Connect(remote_addr, nullptr) != lldb::eConnectionStatusSuccess)
+    return llvm::make_error<llvm::StringError>("Unable to connect",
+                                               llvm::inconvertibleErrorCode());
+
+  client.SetConnection(conn_up.release());
+  if (llvm::Error error = accept_status.get().ToError())
+    return error;
+
+  server.SetConnection(new ConnectionFileDescriptor(accept_socket));
+  return llvm::Error::success();
+}
+
 GDBRemoteCommunication::ScopedTimeout::ScopedTimeout(
     GDBRemoteCommunication &gdb_comm, std::chrono::seconds timeout)
   : m_gdb_comm(gdb_comm), m_timeout_modified(false) {
     auto curr_timeout = gdb_comm.GetPacketTimeout();
     // Only update the timeout if the timeout is greater than the current
     // timeout. If the current timeout is larger, then just use that.
     if (curr_timeout < timeout) {
       m_timeout_modified = true;

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationHistory.h

+//===-- GDBRemoteCommunicationHistory.h--------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_GDBRemoteCommunicationHistory_h_
+#define liblldb_GDBRemoteCommunicationHistory_h_
+
+#include <string>
+#include <vector>
+
+#include "lldb/lldb-public.h"
+#include "llvm/Support/YAMLTraits.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace lldb_private {
+namespace process_gdb_remote {
+
+/// The history keeps a circular buffer of GDB remote packets. The history is
+/// used for logging and replaying GDB remote packets.
+class GDBRemoteCommunicationHistory {
+public:
+  friend llvm::yaml::MappingTraits<GDBRemoteCommunicationHistory>;
+
+  enum PacketType { ePacketTypeInvalid = 0, ePacketTypeSend, ePacketTypeRecv };
+
+  /// Entry in the ring buffer containing the packet data, its type, size and
+  /// index. Entries can be serialized to file.
+  struct Entry {
+    Entry()
+        : packet(), type(ePacketTypeInvalid), bytes_transmitted(0),
+          packet_idx(0), tid(LLDB_INVALID_THREAD_ID) {}
+
+    void Clear() {
+      packet.data.clear();
+      type = ePacketTypeInvalid;
+      bytes_transmitted = 0;
+      packet_idx = 0;
+      tid = LLDB_INVALID_THREAD_ID;
+    }
+
+    struct BinaryData {
+      std::string data;
+    };
+
+    void Serialize(llvm::raw_ostream &strm) const;
+
+    BinaryData packet;
+    PacketType type;
+    uint32_t bytes_transmitted;
+    uint32_t packet_idx;
+    lldb::tid_t tid;
+  };
+
+  GDBRemoteCommunicationHistory(uint32_t size = 0);
+
+  ~GDBRemoteCommunicationHistory();
+
+  // For single char packets for ack, nack and /x03
+  void AddPacket(char packet_char, PacketType type, uint32_t bytes_transmitted);
+
+  void AddPacket(const std::string &src, uint32_t src_len, PacketType type,
+                 uint32_t bytes_transmitted);
+
+  void Dump(Stream &strm) const;
+  void Dump(Log *log) const;
+  bool DidDumpToLog() const { return m_dumped_to_log; }
+
+  void SetStream(std::unique_ptr<llvm::raw_ostream> strm) {
+    m_stream_up = std::move(strm);
+  }
+
+private:
+  uint32_t GetFirstSavedPacketIndex() const {
+    if (m_total_packet_count < m_packets.size())
+      return 0;
+    else
+      return m_curr_idx + 1;
+  }
+
+  uint32_t GetNumPacketsInHistory() const {
+    if (m_total_packet_count < m_packets.size())
+      return m_total_packet_count;
+    else
+      return (uint32_t)m_packets.size();
+  }
+
+  uint32_t GetNextIndex() {
+    ++m_total_packet_count;
+    const uint32_t idx = m_curr_idx;
+    m_curr_idx = NormalizeIndex(idx + 1);
+    return idx;
+  }
+
+  uint32_t NormalizeIndex(uint32_t i) const {
+    return m_packets.empty() ? 0 : i % m_packets.size();
+  }
+
+  std::vector<Entry> m_packets;
+  uint32_t m_curr_idx;
+  uint32_t m_total_packet_count;
+  mutable bool m_dumped_to_log;
+  std::unique_ptr<llvm::raw_ostream> m_stream_up;
+};
+
+} // namespace process_gdb_remote
+} // namespace lldb_private
+
+LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(
+    lldb_private::process_gdb_remote::GDBRemoteCommunicationHistory::Entry)
+
+namespace llvm {
+namespace yaml {
+
+template <>
+struct ScalarEnumerationTraits<lldb_private::process_gdb_remote::
+                                   GDBRemoteCommunicationHistory::PacketType> {
+  static void enumeration(IO &io,
+                          lldb_private::process_gdb_remote::
+                              GDBRemoteCommunicationHistory::PacketType &value);
+};
+
+template <>
+struct ScalarTraits<lldb_private::process_gdb_remote::
+                        GDBRemoteCommunicationHistory::Entry::BinaryData> {
+  static void output(const lldb_private::process_gdb_remote::
+                         GDBRemoteCommunicationHistory::Entry::BinaryData &,
+                     void *, raw_ostream &);
+
+  static StringRef
+  input(StringRef, void *,
+        lldb_private::process_gdb_remote::GDBRemoteCommunicationHistory::Entry::
+            BinaryData &);
+
+  static QuotingType mustQuote(StringRef S) { return QuotingType::None; }
+};
+
+template <>
+struct MappingTraits<
+    lldb_private::process_gdb_remote::GDBRemoteCommunicationHistory::Entry> {
+  static void
+  mapping(IO &io,
+          lldb_private::process_gdb_remote::GDBRemoteCommunicationHistory::Entry
+              &Entry);
+
+  static StringRef validate(
+      IO &io,
+      lldb_private::process_gdb_remote::GDBRemoteCommunicationHistory::Entry &);
+};
+
+} // namespace yaml
+} // namespace llvm
+
+#endif // liblldb_GDBRemoteCommunicationHistory_h_

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationHistory.cpp

+//===-- GDBRemoteCommunicationHistory.cpp -----------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "GDBRemoteCommunicationHistory.h"
+
+// Other libraries and framework includes
+#include "lldb/Core/StreamFile.h"
+#include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/Log.h"
+
+using namespace llvm;
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::process_gdb_remote;
+
+void GDBRemoteCommunicationHistory::Entry::Serialize(raw_ostream &strm) const {
+  yaml::Output yout(strm);
+  yout << const_cast<GDBRemoteCommunicationHistory::Entry &>(*this);
+}
+
+GDBRemoteCommunicationHistory::GDBRemoteCommunicationHistory(uint32_t size)
+    : m_packets(), m_curr_idx(0), m_total_packet_count(0),
+      m_dumped_to_log(false) {
+  if (size)
+    m_packets.resize(size);
+}
+
+GDBRemoteCommunicationHistory::~GDBRemoteCommunicationHistory() {}
+
+void GDBRemoteCommunicationHistory::AddPacket(char packet_char, PacketType type,
+                                              uint32_t bytes_transmitted) {
+  const size_t size = m_packets.size();
+  if (size == 0)
+    return;
+
+  const uint32_t idx = GetNextIndex();
+  m_packets[idx].packet.data.assign(1, packet_char);
+  m_packets[idx].type = type;
+  m_packets[idx].bytes_transmitted = bytes_transmitted;
+  m_packets[idx].packet_idx = m_total_packet_count;
+  m_packets[idx].tid = llvm::get_threadid();
+  if (m_stream_up && type == ePacketTypeRecv)
+    m_packets[idx].Serialize(*m_stream_up);
+}
+
+void GDBRemoteCommunicationHistory::AddPacket(const std::string &src,
+                                              uint32_t src_len, PacketType type,
+                                              uint32_t bytes_transmitted) {
+  const size_t size = m_packets.size();
+  if (size == 0)
+    return;
+
+  const uint32_t idx = GetNextIndex();
+  m_packets[idx].packet.data.assign(src, 0, src_len);
+  m_packets[idx].type = type;
+  m_packets[idx].bytes_transmitted = bytes_transmitted;
+  m_packets[idx].packet_idx = m_total_packet_count;
+  m_packets[idx].tid = llvm::get_threadid();
+  if (m_stream_up && type == ePacketTypeRecv)
+    m_packets[idx].Serialize(*m_stream_up);
+}
+
+void GDBRemoteCommunicationHistory::Dump(Stream &strm) const {
+  const uint32_t size = GetNumPacketsInHistory();
+  const uint32_t first_idx = GetFirstSavedPacketIndex();
+  const uint32_t stop_idx = m_curr_idx + size;
+  for (uint32_t i = first_idx; i < stop_idx; ++i) {
+    const uint32_t idx = NormalizeIndex(i);
+    const Entry &entry = m_packets[idx];
+    if (entry.type == ePacketTypeInvalid || entry.packet.data.empty())
+      break;
+    strm.Printf("history[%u] tid=0x%4.4" PRIx64 " <%4u> %s packet: %s\n",
+                entry.packet_idx, entry.tid, entry.bytes_transmitted,
+                (entry.type == ePacketTypeSend) ? "send" : "read",
+                entry.packet.data.c_str());
+  }
+}
+
+void GDBRemoteCommunicationHistory::Dump(Log *log) const {
+  if (!log || m_dumped_to_log)
+    return;
+
+  m_dumped_to_log = true;
+  const uint32_t size = GetNumPacketsInHistory();
+  const uint32_t first_idx = GetFirstSavedPacketIndex();
+  const uint32_t stop_idx = m_curr_idx + size;
+  for (uint32_t i = first_idx; i < stop_idx; ++i) {
+    const uint32_t idx = NormalizeIndex(i);
+    const Entry &entry = m_packets[idx];
+    if (entry.type == ePacketTypeInvalid || entry.packet.data.empty())
+      break;
+    log->Printf("history[%u] tid=0x%4.4" PRIx64 " <%4u> %s packet: %s",
+                entry.packet_idx, entry.tid, entry.bytes_transmitted,
+                (entry.type == ePacketTypeSend) ? "send" : "read",
+                entry.packet.data.c_str());
+  }
+}
+
+void yaml::ScalarEnumerationTraits<GDBRemoteCommunicationHistory::PacketType>::
+    enumeration(IO &io, GDBRemoteCommunicationHistory::PacketType &value) {
+  io.enumCase(value, "Invalid",
+              GDBRemoteCommunicationHistory::ePacketTypeInvalid);
+  io.enumCase(value, "Send", GDBRemoteCommunicationHistory::ePacketTypeSend);
+  io.enumCase(value, "Recv", GDBRemoteCommunicationHistory::ePacketTypeRecv);
+}
+
+void yaml::ScalarTraits<GDBRemoteCommunicationHistory::Entry::BinaryData>::
+    output(const GDBRemoteCommunicationHistory::Entry::BinaryData &Val, void *,
+           raw_ostream &Out) {
+  Out << toHex(Val.data);
+}
+
+StringRef
+yaml::ScalarTraits<GDBRemoteCommunicationHistory::Entry::BinaryData>::input(
+    StringRef Scalar, void *,
+    GDBRemoteCommunicationHistory::Entry::BinaryData &Val) {
+  Val.data = fromHex(Scalar);
+  return {};
+}
+
+void yaml::MappingTraits<GDBRemoteCommunicationHistory::Entry>::mapping(
+    IO &io, GDBRemoteCommunicationHistory::Entry &Entry) {
+  io.mapRequired("packet", Entry.packet);
+  io.mapRequired("type", Entry.type);
+  io.mapRequired("bytes", Entry.bytes_transmitted);
+  io.mapRequired("index", Entry.packet_idx);
+  io.mapRequired("tid", Entry.tid);
+}
+
+StringRef yaml::MappingTraits<GDBRemoteCommunicationHistory::Entry>::validate(
+    IO &io, GDBRemoteCommunicationHistory::Entry &Entry) {
+  if (Entry.bytes_transmitted != Entry.packet.data.size())
+    return "BinaryData size doesn't match bytes transmitted";
+
+  return {};
+}

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationReplayServer.h

+//===-- GDBRemoteCommunicationReplayServer.h --------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_GDBRemoteCommunicationReplayServer_h_
+#define liblldb_GDBRemoteCommunicationReplayServer_h_
+
+// Other libraries and framework includes
+#include "GDBRemoteCommunication.h"
+#include "GDBRemoteCommunicationHistory.h"
+
+// Project includes
+#include "lldb/Core/Broadcaster.h"
+#include "lldb/Host/HostThread.h"
+#include "lldb/lldb-private-forward.h"
+#include "llvm/Support/Error.h"
+
+// C Includes
+// C++ Includes
+#include <functional>
+#include <map>
+#include <thread>
+
+class StringExtractorGDBRemote;
+
+namespace lldb_private {
+namespace process_gdb_remote {
+
+class ProcessGDBRemote;
+
+/// Dummy GDB server that replays packets from the GDB Remote Communication
+/// history. This is used to replay GDB packets.
+class GDBRemoteCommunicationReplayServer : public GDBRemoteCommunication {
+public:
+  GDBRemoteCommunicationReplayServer();
+
+  ~GDBRemoteCommunicationReplayServer() override;
+
+  PacketResult GetPacketAndSendResponse(Timeout<std::micro> timeout,
+                                        Status &error, bool &interrupt,
+                                        bool &quit);
+
+  bool HandshakeWithClient() { return GetAck() == PacketResult::Success; }
+
+  llvm::Error LoadReplayHistory(const FileSpec &path);
+
+  bool StartAsyncThread();
+  void StopAsyncThread();
+
+protected:
+  enum {
+    eBroadcastBitAsyncContinue = (1 << 0),
+    eBroadcastBitAsyncThreadShouldExit = (1 << 1),
+  };
+
+  static void ReceivePacket(GDBRemoteCommunicationReplayServer &server,
+                            bool &done);
+  static lldb::thread_result_t AsyncThread(void *arg);
+
+  /// Replay history with the oldest packet at the end.
+  std::vector<GDBRemoteCommunicationHistory::Entry> m_packet_history;
+
+  /// Server thread.
+  Broadcaster m_async_broadcaster;
+  lldb::ListenerSP m_async_listener_sp;
+  HostThread m_async_thread;
+  std::recursive_mutex m_async_thread_state_mutex;
+
+  bool m_skip_acks;
+
+private:
+  DISALLOW_COPY_AND_ASSIGN(GDBRemoteCommunicationReplayServer);
+};
+
+} // namespace process_gdb_remote
+} // namespace lldb_private
+
+#endif // liblldb_GDBRemoteCommunicationReplayServer_h_

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationReplayServer.cpp

+//===-- GDBRemoteCommunicationReplayServer.cpp ------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <errno.h>
+
+#include "lldb/Host/Config.h"
+
+#include "GDBRemoteCommunicationReplayServer.h"
+#include "ProcessGDBRemoteLog.h"
+
+// C Includes
+// C++ Includes
+#include <cstring>
+
+// Project includes
+#include "lldb/Core/Event.h"
+#include "lldb/Host/ThreadLauncher.h"
+#include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/StreamString.h"
+#include "lldb/Utility/StringExtractorGDBRemote.h"
+
+using namespace llvm;
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::process_gdb_remote;
+
+GDBRemoteCommunicationReplayServer::GDBRemoteCommunicationReplayServer()
+    : GDBRemoteCommunication("gdb-remote.server",
+                             "gdb-remote.server.rx_packet"),
+      m_async_broadcaster(nullptr, "lldb.gdb-remote.server.async-broadcaster"),
+      m_async_listener_sp(
+          Listener::MakeListener("lldb.gdb-remote.server.async-listener")),
+      m_async_thread_state_mutex(), m_skip_acks(false) {
+  m_async_broadcaster.SetEventName(eBroadcastBitAsyncContinue,
+                                   "async thread continue");
+  m_async_broadcaster.SetEventName(eBroadcastBitAsyncThreadShouldExit,
+                                   "async thread should exit");
+
+  const uint32_t async_event_mask =
+      eBroadcastBitAsyncContinue | eBroadcastBitAsyncThreadShouldExit;
+  m_async_listener_sp->StartListeningForEvents(&m_async_broadcaster,
+                                               async_event_mask);
+}
+
+GDBRemoteCommunicationReplayServer::~GDBRemoteCommunicationReplayServer() {
+  StopAsyncThread();
+}
+
+GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationReplayServer::GetPacketAndSendResponse(
+    Timeout<std::micro> timeout, Status &error, bool &interrupt, bool &quit) {
+  StringExtractorGDBRemote packet;
+  PacketResult packet_result = WaitForPacketNoLock(packet, timeout, false);
+
+  if (packet_result != PacketResult::Success) {
+    if (!IsConnected()) {
+      error.SetErrorString("lost connection");
+      quit = true;
+    } else {
+      error.SetErrorString("timeout");
+    }
+    return packet_result;
+  }
+
+  m_async_broadcaster.BroadcastEvent(eBroadcastBitAsyncContinue);
+
+  if (m_skip_acks) {
+    const StringExtractorGDBRemote::ServerPacketType packet_type =
+        packet.GetServerPacketType();
+    switch (packet_type) {
+    case StringExtractorGDBRemote::eServerPacketType_nack:
+    case StringExtractorGDBRemote::eServerPacketType_ack:
+      return PacketResult::Success;
+    default:
+      break;
+    }
+  } else if (packet.GetStringRef() == "QStartNoAckMode") {
+    m_skip_acks = true;
+    m_send_acks = false;
+  }
+
+  while (!m_packet_history.empty()) {
+    // Pop last packet from the history.
+    GDBRemoteCommunicationHistory::Entry entry = m_packet_history.back();
+    m_packet_history.pop_back();
+
+    // We only care about what we received from the server. Skip everything
+    // the client sent.
+    if (entry.type != GDBRemoteCommunicationHistory::ePacketTypeRecv)
+      continue;
+
+    return SendRawPacketNoLock(entry.packet.data, true);
+  }
+
+  quit = true;
+
+  return packet_result;
+}
+
+LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(
+    std::vector<
+        lldb_private::process_gdb_remote::GDBRemoteCommunicationHistory::Entry>)
+
+llvm::Error
+GDBRemoteCommunicationReplayServer::LoadReplayHistory(const FileSpec &path) {
+  auto error_or_file = MemoryBuffer::getFile(path.GetPath());
+  if (auto err = error_or_file.getError())
+    return errorCodeToError(err);
+
+  yaml::Input yin((*error_or_file)->getBuffer());
+  yin >> m_packet_history;
+
+  if (auto err = yin.error())
+    return errorCodeToError(err);
+
+  // We want to manipulate the vector like a stack so we need to reverse the
+  // order of the packets to have the oldest on at the back.
+  std::reverse(m_packet_history.begin(), m_packet_history.end());
+
+  return Error::success();
+}
+
+bool GDBRemoteCommunicationReplayServer::StartAsyncThread() {
+  std::lock_guard<std::recursive_mutex> guard(m_async_thread_state_mutex);
+  if (!m_async_thread.IsJoinable()) {
+    // Create a thread that watches our internal state and controls which
+    // events make it to clients (into the DCProcess event queue).
+    m_async_thread = ThreadLauncher::LaunchThread(
+        "<lldb.gdb-remote.server.async>",
+        GDBRemoteCommunicationReplayServer::AsyncThread, this, nullptr);
+  }
+
+  // Wait for handshake.
+  m_async_broadcaster.BroadcastEvent(eBroadcastBitAsyncContinue);
+
+  return m_async_thread.IsJoinable();
+}
+
+void GDBRemoteCommunicationReplayServer::StopAsyncThread() {
+  std::lock_guard<std::recursive_mutex> guard(m_async_thread_state_mutex);
+
+  if (!m_async_thread.IsJoinable())
+    return;
+
+  // Request thread to stop.
+  m_async_broadcaster.BroadcastEvent(eBroadcastBitAsyncThreadShouldExit);
+
+  // Disconnect client.
+  Disconnect();
+
+  // Stop the thread.
+  m_async_thread.Join(nullptr);
+  m_async_thread.Reset();
+}
+
+void GDBRemoteCommunicationReplayServer::ReceivePacket(
+    GDBRemoteCommunicationReplayServer &server, bool &done) {
+  Status error;
+  bool interrupt;
+  auto packet_result = server.GetPacketAndSendResponse(std::chrono::seconds(1),
+                                                       error, interrupt, done);
+  if (packet_result != GDBRemoteCommunication::PacketResult::Success &&
+      packet_result !=
+          GDBRemoteCommunication::PacketResult::ErrorReplyTimeout) {
+    done = true;
+  } else {
+    server.m_async_broadcaster.BroadcastEvent(eBroadcastBitAsyncContinue);
+  }
+}
+
+thread_result_t GDBRemoteCommunicationReplayServer::AsyncThread(void *arg) {
+  GDBRemoteCommunicationReplayServer *server =
+      (GDBRemoteCommunicationReplayServer *)arg;
+
+  EventSP event_sp;
+  bool done = false;
+
+  while (true) {
+    if (server->m_async_listener_sp->GetEvent(event_sp, llvm::None)) {
+      const uint32_t event_type = event_sp->GetType();
+      if (event_sp->BroadcasterIs(&server->m_async_broadcaster)) {
+        switch (event_type) {
+        case eBroadcastBitAsyncContinue:
+          ReceivePacket(*server, done);
+          if (done)
+            return nullptr;
+          break;
+        case eBroadcastBitAsyncThreadShouldExit:
+        default:
+          return nullptr;
+        }
+      }
+    }
+  }
+
+  return nullptr;
+}

source/Plugins/Process/gdb-remote/ProcessGDBRemote.h

 #include "lldb/Utility/StreamGDBRemote.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/StringExtractor.h"
 #include "lldb/Utility/StringList.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/lldb-private-forward.h"
 
 #include "GDBRemoteCommunicationClient.h"
+#include "GDBRemoteCommunicationReplayServer.h"
 #include "GDBRemoteRegisterContext.h"
 
 #include "llvm/ADT/DenseMap.h"
 
 namespace lldb_private {
+namespace repro {
+class Loader;
+}
 namespace process_gdb_remote {
 
 class ThreadGDBRemote;
 
 class ProcessGDBRemote : public Process,
                          private GDBRemoteClientBase::ContinueDelegate {
 public:
   ProcessGDBRemote(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp);
protected:
   //------------------------------------------------------------------
   enum {
     eBroadcastBitAsyncContinue = (1 << 0),
     eBroadcastBitAsyncThreadShouldExit = (1 << 1),
     eBroadcastBitAsyncThreadDidExit = (1 << 2)
   };
 
   GDBRemoteCommunicationClient m_gdb_comm;
+  GDBRemoteCommunicationReplayServer m_gdb_replay_server;
   std::atomic<lldb::pid_t> m_debugserver_pid;
   std::vector<StringExtractorGDBRemote> m_stop_packet_stack; // The stop packet
                                                              // stack replaces
                                                              // the last stop
                                                              // packet variable
   std::recursive_mutex m_last_stop_packet_mutex;
   GDBRemoteDynamicRegisterInfo m_register_info;
   Broadcaster m_async_broadcaster;
protected:
   MMapMap m_addr_to_mmap_size;
   lldb::BreakpointSP m_thread_create_bp_sp;
   bool m_waiting_for_attach;
   bool m_destroy_tried_resuming;
   lldb::CommandObjectSP m_command_sp;
   int64_t m_breakpoint_pc_offset;
   lldb::tid_t m_initial_tid; // The initial thread ID, given by stub on attach
 
+  bool m_replay_mode;
   bool m_allow_flash_writes;
   using FlashRangeVector = lldb_private::RangeVector<lldb::addr_t, size_t>;
   using FlashRange = FlashRangeVector::Entry;
   FlashRangeVector m_erased_flash_ranges;
 
   //----------------------------------------------------------------------
   // Accessors
   //----------------------------------------------------------------------
protected:
 
   bool ProcessIDIsValid() const;
 
   void Clear();
 
   bool UpdateThreadList(ThreadList &old_thread_list,
                         ThreadList &new_thread_list) override;
 
+  Status ConnectToReplayServer(repro::Loader *loader);
+
   Status EstablishConnectionIfNeeded(const ProcessInfo &process_info);
 
   Status LaunchAndConnectToDebugserver(const ProcessInfo &process_info);
 
   void KillDebugserverProcess();
 
   void BuildDynamicRegisterInfo(bool force);
 

source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/TargetList.h"
 #include "lldb/Target/ThreadPlanCallFunction.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/CleanUp.h"
 #include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/Reproducer.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
 
 // Project includes
 #include "GDBRemoteRegisterContext.h"
 #include "Plugins/Platform/MacOSX/PlatformRemoteiOS.h"
 #include "Plugins/Process/Utility/GDBRemoteSignals.h"
 #include "Plugins/Process/Utility/InferiorCallPOSIX.h"
 #include "Plugins/Process/Utility/StopInfoMachException.h"
 #include "ProcessGDBRemote.h"
 #include "ProcessGDBRemoteLog.h"
 #include "ThreadGDBRemote.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Utility/StringExtractorGDBRemote.h"
 
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/Threading.h"
 #include "llvm/Support/raw_ostream.h"
 
 #define DEBUGSERVER_BASENAME "debugserver"
+using namespace llvm;
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::process_gdb_remote;
 
 namespace lldb {
 // Provide a function that can easily dump the packet history if we know a
 // ProcessGDBRemote * value (which we can get from logs or from debugging). We
 // need the function in the lldb namespace so it makes it into the final
 // executable since the LLDB shared library only exports stuff in the lldb
 // namespace. This allows you to attach with a debugger and call this function
 // and get the packet history dumped to a file.
 void DumpProcessGDBRemotePacketHistory(void *p, const char *path) {
   StreamFile strm;
   Status error(strm.GetFile().Open(path, File::eOpenOptionWrite |
                                              File::eOpenOptionCanCreate));
   if (error.Success())
     ((ProcessGDBRemote *)p)->GetGDBRemote().DumpHistory(strm);
 }
-}
+} // namespace lldb
 
 namespace {
 
 static PropertyDefinition g_properties[] = {
     {"packet-timeout", OptionValue::eTypeUInt64, true, 1, NULL, NULL,
      "Specify the default packet timeout in seconds."},
     {"target-definition-file", OptionValue::eTypeFileSpec, true, 0, NULL, NULL,
      "The file that provides the description for remote target registers."},

 
 static const ProcessKDPPropertiesSP &GetGlobalPluginProperties() {
   static ProcessKDPPropertiesSP g_settings_sp;
   if (!g_settings_sp)
     g_settings_sp.reset(new PluginProperties());
   return g_settings_sp;
 }
 
-} // anonymous namespace end
+class ProcessGDBRemoteProvider : public repro::Provider {
+public:
+  ProcessGDBRemoteProvider(FileSpec directory) : Provider(directory) {
+    m_info.name = "gdb-remote";
+    m_info.files.push_back("gdb-remote.yaml");
+  }
+
+  FileSpec GetHistoryFile() {
+    FileSpec history_file = GetDirectory();
+    history_file.AppendPathComponent("gdb-remote.yaml");
+    return history_file;
+  }
+};
+
+} // namespace
 
 // TODO Randomly assigning a port is unsafe.  We should get an unused
 // ephemeral port from the kernel and make sure we reserve it before passing it
 // to debugserver.
 
 #if defined(__APPLE__)
 #define LOW_PORT (IPPORT_RESERVED)
 #define HIGH_PORT (IPPORT_HIFIRSTAUTO)
: Process(target_sp, listener_sp),
           Listener::MakeListener("lldb.process.gdb-remote.async-listener")),
       m_async_thread_state_mutex(), m_thread_ids(), m_thread_pcs(),
       m_jstopinfo_sp(), m_jthreadsinfo_sp(), m_continue_c_tids(),
       m_continue_C_tids(), m_continue_s_tids(), m_continue_S_tids(),
       m_max_memory_size(0), m_remote_stub_max_memory_size(0),
       m_addr_to_mmap_size(), m_thread_create_bp_sp(),
       m_waiting_for_attach(false), m_destroy_tried_resuming(false),
       m_command_sp(), m_breakpoint_pc_offset(0),
-      m_initial_tid(LLDB_INVALID_THREAD_ID), m_allow_flash_writes(false),
-      m_erased_flash_ranges() {
+      m_initial_tid(LLDB_INVALID_THREAD_ID), m_replay_mode(false),
+      m_allow_flash_writes(false), m_erased_flash_ranges() {
   m_async_broadcaster.SetEventName(eBroadcastBitAsyncThreadShouldExit,
                                    "async thread should exit");
   m_async_broadcaster.SetEventName(eBroadcastBitAsyncContinue,
                                    "async thread continue");
   m_async_broadcaster.SetEventName(eBroadcastBitAsyncThreadDidExit,
                                    "async thread did exit");
 
+  repro::Generator *generator =
+      GetTarget().GetDebugger().GetReproducer().GetGenerator();
+  if (generator) {
+    ProcessGDBRemoteProvider &provider =
+        generator->CreateProvider<ProcessGDBRemoteProvider>();
+
+    std::error_code EC;
+    auto file_out = make_unique<raw_fd_ostream>(
+        provider.GetHistoryFile().GetPath(), EC, sys::fs::OpenFlags::F_None);
+    if (!EC)
+      m_gdb_comm.SetHistoryStream(std::move(file_out));
+  }
+
   Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_ASYNC));
 
   const uint32_t async_event_mask =
       eBroadcastBitAsyncContinue | eBroadcastBitAsyncThreadShouldExit;
 
   if (m_async_listener_sp->StartListeningForEvents(
           &m_async_broadcaster, async_event_mask) != async_event_mask) {
     if (log)
if (GetID() != LLDB_INVALID_PROCESS_ID) {
     // process.
 
     const ArchSpec &remote_process_arch = m_gdb_comm.GetProcessArchitecture();
     if (remote_process_arch.IsValid()) {
       process_arch = remote_process_arch;
       if (log)
         log->Printf("ProcessGDBRemote::%s gdb-remote had process architecture, "
                     "using %s %s",
-                    __FUNCTION__, process_arch.GetArchitectureName()
-                                      ? process_arch.GetArchitectureName()
-                                      : "<null>",
+                    __FUNCTION__,
+                    process_arch.GetArchitectureName()
                     process_arch.GetTriple().getTriple().c_str()
                         ? process_arch.GetTriple().getTriple().c_str()
                         : "<null>");
     } else {
       process_arch = m_gdb_comm.GetHostArchitecture();
       if (log)
         log->Printf("ProcessGDBRemote::%s gdb-remote did not have process "
                     "architecture, using gdb-remote host architecture %s %s",
-                    __FUNCTION__, process_arch.GetArchitectureName()
-                                      ? process_arch.GetArchitectureName()
-                                      : "<null>",
+                    __FUNCTION__,
+                    process_arch.GetArchitectureName()
                     process_arch.GetTriple().getTriple().c_str()
                         ? process_arch.GetTriple().getTriple().c_str()
                         : "<null>");
     }
 
     if (process_arch.IsValid()) {
       const ArchSpec &target_arch = GetTarget().GetArchitecture();
       if (target_arch.IsValid()) {
         if (log)
           log->Printf(
               "ProcessGDBRemote::%s analyzing target arch, currently %s %s",
-              __FUNCTION__, target_arch.GetArchitectureName()
-                                ? target_arch.GetArchitectureName()
-                                : "<null>",
+              __FUNCTION__,
+              target_arch.GetArchitectureName()
               target_arch.GetTriple().getTriple().c_str()
                   ? target_arch.GetTriple().getTriple().c_str()
                   : "<null>");
 
         // If the remote host is ARM and we have apple as the vendor, then
         // ARM executables and shared libraries can have mixed ARM
         // architectures.
         // You can have an armv6 executable, and if the host is armv7, then the
         // system will load the best possible architecture for all shared
         // libraries it has, so we really need to take the remote host
         // architecture as our defacto architecture in this case.
 
         if ((process_arch.GetMachine() == llvm::Triple::arm ||
              process_arch.GetMachine() == llvm::Triple::thumb) &&
             process_arch.GetTriple().getVendor() == llvm::Triple::Apple) {
           GetTarget().SetArchitecture(process_arch);
           if (log)
             log->Printf("ProcessGDBRemote::%s remote process is ARM/Apple, "
                         "setting target arch to %s %s",
-                        __FUNCTION__, process_arch.GetArchitectureName()
-                                          ? process_arch.GetArchitectureName()
-                                          : "<null>",
+                        __FUNCTION__,
+                        process_arch.GetArchitectureName()
                         process_arch.GetTriple().getTriple().c_str()
                             ? process_arch.GetTriple().getTriple().c_str()
                             : "<null>");
         } else {
           // Fill in what is missing in the triple
           const llvm::Triple &remote_triple = process_arch.GetTriple();
           llvm::Triple new_target_triple = target_arch.GetTriple();
           if (new_target_triple.getVendorName().size() == 0) {
if (process_arch.IsValid()) {
             new_target_arch.SetTriple(new_target_triple);
             GetTarget().SetArchitecture(new_target_arch);
           }
         }
 
         if (log)
           log->Printf("ProcessGDBRemote::%s final target arch after "
                       "adjustments for remote architecture: %s %s",
-                      __FUNCTION__, target_arch.GetArchitectureName()
-                                        ? target_arch.GetArchitectureName()
-                                        : "<null>",
+                      __FUNCTION__,
+                      target_arch.GetArchitectureName()
                       target_arch.GetTriple().getTriple().c_str()
                           ? target_arch.GetTriple().getTriple().c_str()
                           : "<null>");
       } else {
         // The target doesn't have a valid architecture yet, set it from the
         // architecture we got from the remote GDB server
         GetTarget().SetArchitecture(process_arch);
       }
Status ProcessGDBRemote::DoSignal(int signo) {
   if (log)
     log->Printf("ProcessGDBRemote::DoSignal (signal = %d)", signo);
 
   if (!m_gdb_comm.SendAsyncSignal(signo))
     error.SetErrorStringWithFormat("failed to send signal %i", signo);
   return error;
 }
 
+Status ProcessGDBRemote::ConnectToReplayServer(repro::Loader *loader) {
+  if (!loader)
+    return Status("No loader provided.");
+
+  auto provider_info = loader->GetProviderInfo("gdb-remote");
+  if (!provider_info)
+    return Status("No provider for gdb-remote.");
+
+  if (provider_info->files.empty())
+    return Status("Provider for  gdb-remote contains no files.");
+
+  // Construct replay history path.
+  FileSpec history_file = loader->GetDirectory();
+  history_file.AppendPathComponent(provider_info->files.front());
+
+  // Enable replay mode.
+  m_replay_mode = true;
+
+  // Load replay history.
+  if (auto error = m_gdb_replay_server.LoadReplayHistory(history_file))
+    return Status("Unable to load replay history");
+
+  // Make a local connection.
+  if (auto error = GDBRemoteCommunication::ConnectLocally(m_gdb_comm,
+                                                          m_gdb_replay_server))
+    return Status("Unable to connect to replay server");
+
+  // Start server thread.
+  m_gdb_replay_server.StartAsyncThread();
+
+  // Start client thread.
+  StartAsyncThread();
+
+  // Do the usual setup.
+  return ConnectToDebugserver("");
+}
+
 Status
 ProcessGDBRemote::EstablishConnectionIfNeeded(const ProcessInfo &process_info) {
   // Make sure we aren't already connected?
   if (m_gdb_comm.IsConnected())
     return Status();
 
   PlatformSP platform_sp(GetTarget().GetPlatform());
   if (platform_sp && !platform_sp->IsHost())
     return Status("Lost debug server connection");
 
+  if (repro::Loader *loader =
+          GetTarget().GetDebugger().GetReproducer().GetLoader())
+    return ConnectToReplayServer(loader);
+
   auto error = LaunchAndConnectToDebugserver(process_info);
   if (error.Fail()) {
     const char *error_string = error.AsCString();
     if (error_string == nullptr)
       error_string = "unable to launch " DEBUGSERVER_BASENAME;
   }
   return error;
 }
 #if !defined(_WIN32)
#endif
   return error;
 }
 
 bool ProcessGDBRemote::MonitorDebugserverProcess(
     std::weak_ptr<ProcessGDBRemote> process_wp, lldb::pid_t debugserver_pid,
     bool exited,    // True if the process did exit
     int signo,      // Zero for no signal
     int exit_status // Exit value of process if signal is zero
-    ) {
   // "debugserver_pid" argument passed in is the process ID for debugserver
   // that we are tracking...
   Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
   const bool handled = true;
 
   if (log)
     log->Printf("ProcessGDBRemote::%s(process_wp, pid=%" PRIu64
                 ", signo=%i (0x%x), exit_status=%i)",

 
 bool ParseRegisters(XMLNode feature_node, GdbServerTargetInfo &target_info,
                     GDBRemoteDynamicRegisterInfo &dyn_reg_info, ABISP abi_sp,
                     uint32_t &cur_reg_num, uint32_t &reg_offset) {
   if (!feature_node)
     return false;
 
   feature_node.ForEachChildElementWithName(
-      "reg", [&target_info, &dyn_reg_info, &cur_reg_num, &reg_offset,
-              &abi_sp](const XMLNode &reg_node) -> bool {
+      "reg",
+      [&target_info, &dyn_reg_info, &cur_reg_num, &reg_offset,
         std::string gdb_group;
         std::string gdb_type;
         ConstString reg_name;
         ConstString alt_name;
         ConstString set_name;
         std::vector<uint32_t> value_regs;
         std::vector<uint32_t> invalidate_regs;
         std::vector<uint8_t> dwarf_opcode_bytes;
feature_node.ForEachChildElementWithName(
         AugmentRegisterInfoViaABI(reg_info, reg_name, abi_sp);
         dyn_reg_info.AddRegister(reg_info, reg_name, alt_name, set_name);
 
         return true; // Keep iterating through all "reg" elements
       });
   return true;
 }
 
-} // namespace {}
+} // namespace
 
 // query the target of gdb-remote for extended target information return:
 // 'true'  on success
 //          'false' on failure
 bool ProcessGDBRemote::GetGDBServerRegisterInfo(ArchSpec &arch_to_use) {
   // Make sure LLDB has an XML parser it can use first
   if (!XMLDocument::XMLEnabled())
     return false;
if (target_node) {
                 return true; // Keep iterating through all "group" elements
               });
         }
         return true; // Keep iterating through all children of the target_node
       });
 
       // If the target.xml includes an architecture entry like
       //   <architecture>i386:x86-64</architecture> (seen from VMWare ESXi)
-      //   <architecture>arm</architecture> (seen from Segger JLink on unspecified arm board)
+      //   <architecture>arm</architecture> (seen from Segger JLink on
+      //   unspecified arm board)
       // use that if we don't have anything better.
       if (!arch_to_use.IsValid() && !target_info.arch.empty()) {
-        if (target_info.arch == "i386:x86-64")
-        {
+        if (target_info.arch == "i386:x86-64") {
           // We don't have any information about vendor or OS.
           arch_to_use.SetTriple("x86_64--");
           GetTarget().MergeArchitecture(arch_to_use);
         }
       }
 
       // Initialize these outside of ParseRegisters, since they should not be
       // reset inside each include feature

source/Utility/CMakeLists.txt

add_lldb_library(lldbUtility
   JSON.cpp
   LLDBAssert.cpp
   Log.cpp
   Logging.cpp
   NameMatches.cpp
   Range.cpp
   RegisterValue.cpp
   RegularExpression.cpp
+  Reproducer.cpp
   Scalar.cpp
   SelectHelper.cpp
   SharingPtr.cpp
   State.cpp
   Status.cpp
   Stream.cpp
   StreamCallback.cpp
   StreamGDBRemote.cpp

source/Utility/Reproducer.cpp

+//===-- Reproducer.cpp ------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Utility/Reproducer.h"
+#include "lldb/Host/HostInfo.h"
+
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace lldb_private;
+using namespace lldb_private::repro;
+using namespace llvm;
+using namespace llvm::yaml;
+
+Generator *Reproducer::GetGenerator() {
+  if (m_generate_reproducer)
+    return &m_generator;
+  return nullptr;
+}
+
+Loader *Reproducer::GetLoader() {
+  if (m_use_reproducer)
+    return &m_loader;
+  return nullptr;
+}
+
+void Reproducer::SetGenerateReproducer(bool value) {
+  assert((!value || !m_use_reproducer) &&
+         "Cannot generate reproducer when using one.");
+  m_generate_reproducer = value;
+  m_generator.SetEnabled(value);
+}
+
+void Reproducer::SetUseReproducer(bool value) {
+  assert((!value || !m_generate_reproducer) &&
+         "Cannot use reproducer when generating one.");
+  m_use_reproducer = value;
+}
+
+Generator::Generator() : m_enabled(false), m_done(false) {
+  m_directory = HostInfo::GetReproducerTempDir();
+}
+
+Generator::~Generator() {
+  if (m_done)
+    return;
+  if (m_enabled)
+    Keep();
+  else
+    Discard();
+}
+
+Provider &Generator::Register(std::unique_ptr<Provider> provider) {
+  std::lock_guard<std::mutex> lock(m_providers_mutex);
+
+  AddProviderToIndex(provider->GetInfo());
+
+  m_providers.push_back(std::move(provider));
+  return *m_providers.back();
+}
+
+void Generator::Keep() {
+  assert(!m_done);
+  m_done = true;
+
+  if (!m_enabled)
+    return;
+
+  for (auto &provider : m_providers)
+    provider->Keep();
+
+  errs() << "Reproducer written to '" << m_directory.GetPath() << "'\n";
+}
+
+void Generator::Discard() {
+  assert(!m_done);
+  m_done = true;
+
+  if (!m_enabled)
+    return;
+
+  for (auto &provider : m_providers)
+    provider->Discard();
+
+  llvm::sys::fs::remove_directories(m_directory.GetPath());
+}
+
+void Generator::ChangeDirectory(const FileSpec &directory) {
+  assert(m_providers.empty() && "Changing the directory after providers have "
+                                "been registered would invalidate the index.");
+  m_directory = directory;
+}
+
+void Generator::AddProviderToIndex(const ProviderInfo &provider_info) {
+  FileSpec index = m_directory;
+  index.AppendPathComponent("index.yaml");
+
+  std::error_code EC;
+  auto strm = make_unique<raw_fd_ostream>(index.GetPath(), EC,
+                                          sys::fs::OpenFlags::F_None);
+  yaml::Output yout(*strm);
+  yout << const_cast<ProviderInfo &>(provider_info);
+}
+
+Loader::Loader() : m_loaded(false) {}
+
+llvm::Error Loader::LoadIndex(const FileSpec &directory) {
+  if (m_loaded)
+    return llvm::Error::success();
+
+  FileSpec index = directory;
+  index.AppendPathComponent("index.yaml");
+
+  auto error_or_file = MemoryBuffer::getFile(index.GetPath());
+  if (auto err = error_or_file.getError())
+    return errorCodeToError(err);
+
+  std::vector<ProviderInfo> provider_info;
+  yaml::Input yin((*error_or_file)->getBuffer());
+  yin >> provider_info;
+
+  if (auto err = yin.error())
+    return errorCodeToError(err);
+
+  for (auto &info : provider_info)
+    m_provider_info[info.name] = info;
+
+  m_directory = directory;
+  m_loaded = true;
+
+  return llvm::Error::success();
+}
+
+llvm::Optional<ProviderInfo> Loader::GetProviderInfo(StringRef name) {
+  assert(m_loaded);
+
+  auto it = m_provider_info.find(name);
+  if (it == m_provider_info.end())
+    return llvm::None;
+
+  return it->second;
+}

tools/driver/Driver.cpp

static OptionDefinition g_options[] = {
      "launch before attaching."},
     {LLDB_3_TO_5, false, "source", 's', required_argument, 0, eArgTypeFilename,
      "Tells the debugger to read in and execute the lldb commands in the given "
      "file, after any file provided on the command line has been loaded."},
     {LLDB_3_TO_5, false, "one-line", 'o', required_argument, 0, eArgTypeNone,
      "Tells the debugger to execute this one-line lldb command after any file "
      "provided on the command line has been loaded."},
     {LLDB_3_TO_5, false, "source-before-file", 'S', required_argument, 0,
-     eArgTypeFilename, "Tells the debugger to read in and execute the lldb "
-                       "commands in the given file, before any file provided "
-                       "on the command line has been loaded."},
+     eArgTypeFilename,
+     "Tells the debugger to read in and execute the lldb "
     {LLDB_3_TO_5, false, "one-line-before-file", 'O', required_argument, 0,
-     eArgTypeNone, "Tells the debugger to execute this one-line lldb command "
-                   "before any file provided on the command line has been "
-                   "loaded."},
+     eArgTypeNone,
+     "Tells the debugger to execute this one-line lldb command "
     {LLDB_3_TO_5, false, "one-line-on-crash", 'k', required_argument, 0,
-     eArgTypeNone, "When in batch mode, tells the debugger to execute this "
-                   "one-line lldb command if the target crashes."},
+     eArgTypeNone,
+     "When in batch mode, tells the debugger to execute this "
     {LLDB_3_TO_5, false, "source-on-crash", 'K', required_argument, 0,
-     eArgTypeFilename, "When in batch mode, tells the debugger to source this "
-                       "file of lldb commands if the target crashes."},
+     eArgTypeFilename,
+     "When in batch mode, tells the debugger to source this "
     {LLDB_3_TO_5, false, "source-quietly", 'Q', no_argument, 0, eArgTypeNone,
      "Tells the debugger to execute this one-line lldb command before any file "
      "provided on the command line has been loaded."},
     {LLDB_3_TO_5, false, "batch", 'b', no_argument, 0, eArgTypeNone,
      "Tells the debugger to run the commands from -s, -S, -o & -O, and "
      "then quit.  However if any run command stopped due to a signal or crash, "
      "the debugger will return to the interactive prompt at the place of the "
      "crash."},
static OptionDefinition g_options[] = {
      eArgTypeScriptLang,
      "Tells the debugger to use the specified scripting language for "
      "user-defined scripts, rather than the default.  "
      "Valid scripting languages that can be specified include Python, Perl, "
      "Ruby and Tcl.  Currently only the Python "
      "extensions have been implemented."},
     {LLDB_3_TO_5, false, "debug", 'd', no_argument, 0, eArgTypeNone,
      "Tells the debugger to print out extra information for debugging itself."},
+    {LLDB_3_TO_5, false, "reproducer", 'z', required_argument, 0,
+     eArgTypeFilename,
+     "Tells the debugger to use the fullpath to <path> as a reproducer."},
     {LLDB_OPT_SET_7, true, "repl", 'r', optional_argument, 0, eArgTypeNone,
      "Runs lldb in REPL mode with a stub process."},
     {LLDB_OPT_SET_7, true, "repl-language", 'R', required_argument, 0,
      eArgTypeNone, "Chooses the language for the REPL."},
     {0, false, NULL, 0, 0, 0, eArgTypeNone, NULL}};
 
 static const uint32_t last_option_set_with_args = 2;
 
else {
         case 'l':
           m_option_data.m_script_lang = m_debugger.GetScriptingLanguage(optarg);
           break;
 
         case 'd':
           m_option_data.m_debug_mode = true;
           break;
 
+        case 'z': {
+          SBFileSpec file(optarg);
+          if (file.Exists()) {
+            m_debugger.SetReproducerPath(optarg);
+          } else
+            error.SetErrorStringWithFormat("file specified in --reproducer "
+                                           "(-z) option doesn't exist: '%s'",
+                                           optarg);
+        } break;
+
         case 'Q':
           m_option_data.m_source_quietly = true;
           break;
 
         case 'K':
           m_option_data.AddInitialCommand(optarg, eCommandPlacementAfterCrash,
                                           true, error);
           break;

unittests/Process/gdb-remote/GDBRemoteClientBaseTest.cpp

struct TestClient : public GDBRemoteClientBase {
   TestClient() : GDBRemoteClientBase("test.client", "test.client.listener") {
     m_send_acks = false;
   }
 };
 
 class GDBRemoteClientBaseTest : public GDBRemoteTest {
 public:
   void SetUp() override {
-    ASSERT_THAT_ERROR(Connect(client, server), llvm::Succeeded());
+    ASSERT_THAT_ERROR(GDBRemoteCommunication::ConnectLocally(client, server),
+                      llvm::Succeeded());
     ASSERT_EQ(TestClient::eBroadcastBitRunPacketSent,
               listener_sp->StartListeningForEvents(
                   &client, TestClient::eBroadcastBitRunPacketSent));
   }
 
 protected:
   TestClient client;
   MockServer server;

unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp

 uint8_t one_register[] = {'A', 'B', 'C', 'D'};
 std::string one_register_hex = "41424344";
 
 } // end anonymous namespace
 
 class GDBRemoteCommunicationClientTest : public GDBRemoteTest {
 public:
   void SetUp() override {
-    ASSERT_THAT_ERROR(Connect(client, server), llvm::Succeeded());
+    ASSERT_THAT_ERROR(GDBRemoteCommunication::ConnectLocally(client, server),
+                      llvm::Succeeded());
   }
 
 protected:
   TestClient client;
   MockServer server;
 };
 
 TEST_F(GDBRemoteCommunicationClientTest, WriteRegister) {

unittests/Process/gdb-remote/GDBRemoteCommunicationTest.cpp

PacketResult ReadPacket(StringExtractorGDBRemote &response) {
     return GDBRemoteCommunication::ReadPacket(response, std::chrono::seconds(1),
                                               /*sync_on_timeout*/ false);
   }
 };
 
 class GDBRemoteCommunicationTest : public GDBRemoteTest {
 public:
   void SetUp() override {
-    ASSERT_THAT_ERROR(Connect(client, server), llvm::Succeeded());
+    ASSERT_THAT_ERROR(GDBRemoteCommunication::ConnectLocally(client, server),
+                      llvm::Succeeded());
   }
 
 protected:
   TestClient client;
   MockServer server;
 
   bool Write(llvm::StringRef packet) {
     ConnectionStatus status;

unittests/Process/gdb-remote/GDBRemoteTestUtils.h

 
 namespace lldb_private {
 namespace process_gdb_remote {
 
 class GDBRemoteTest : public testing::Test {
 public:
   static void SetUpTestCase();
   static void TearDownTestCase();
-
-protected:
-  llvm::Error Connect(GDBRemoteCommunication &client,
-                      GDBRemoteCommunication &server);
 };
 
 struct MockServer : public GDBRemoteCommunicationServer {
   MockServer()
       : GDBRemoteCommunicationServer("mock-server", "mock-server.listener") {
     m_send_acks = false;
   }
 

unittests/Process/gdb-remote/GDBRemoteTestUtils.cpp

 //===-- GDBRemoteTestUtils.cpp ----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "GDBRemoteTestUtils.h"
 
-#include "lldb/Host/common/TCPSocket.h"
-#include "lldb/Host/posix/ConnectionFileDescriptorPosix.h"
-
-#include <future>
-
 namespace lldb_private {
 namespace process_gdb_remote {
 
 void GDBRemoteTest::SetUpTestCase() {
 #if defined(_MSC_VER)
   WSADATA data;
   ::WSAStartup(MAKEWORD(2, 2), &data);
 #endif
 }
 
 void GDBRemoteTest::TearDownTestCase() {
 #if defined(_MSC_VER)
   ::WSACleanup();
 #endif
 }
 
-llvm::Error GDBRemoteTest::Connect(GDBRemoteCommunication &client,
-                                   GDBRemoteCommunication &server) {
-  bool child_processes_inherit = false;
-  TCPSocket listen_socket(true, child_processes_inherit);
-  if (llvm::Error error = listen_socket.Listen("127.0.0.1:0", 5).ToError())
-    return error;
-
-  Socket *accept_socket;
-  std::future<Status> accept_status = std::async(
-      std::launch::async, [&] { return listen_socket.Accept(accept_socket); });
-
-  llvm::SmallString<32> remote_addr;
-  llvm::raw_svector_ostream(remote_addr)
-      << "connect://localhost:" << listen_socket.GetLocalPortNumber();
-
-  std::unique_ptr<ConnectionFileDescriptor> conn_up(
-      new ConnectionFileDescriptor());
-  if (conn_up->Connect(remote_addr, nullptr) != lldb::eConnectionStatusSuccess)
-    return llvm::make_error<llvm::StringError>("Unable to connect",
-                                               llvm::inconvertibleErrorCode());
-
-  client.SetConnection(conn_up.release());
-  if (llvm::Error error = accept_status.get().ToError())
-    return error;
-
-  server.SetConnection(new ConnectionFileDescriptor(accept_socket));
-  return llvm::Error::success();
-}
-
 } // namespace process_gdb_remote
 } // namespace lldb_private