[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

66

Do you also need to update the Xcode project?

[JDevlieghere]

source/Utility/CMakeLists.txt

66

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

587

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

3479

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

1062

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

source/Core/Debugger.cpp

286

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"?

591

clang-format

593

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

3480

Factor this out into a static function?

[JDevlieghere]

Thanks a lot for the review feedback everyone!

source/API/SBDebugger.cpp

1062

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

286

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

public:
 
   bool SetTerminalWidth(uint32_t term_width);
 
   llvm::StringRef GetPrompt() const;
 
   void SetPrompt(llvm::StringRef p);
   void SetPrompt(const char *) = delete;
 
+  llvm::StringRef GetReproducerPath() const;
+
+  void SetReproducerPath(llvm::StringRef p);
+  void SetReproducerPath(const char *) = delete;
+
   bool GetUseExternalEditor() const;
 
   bool SetUseExternalEditor(bool use_external_editor_p);
 
   bool GetUseColor() const;
 
   bool SetUseColor(bool use_color);
 

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 "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; }
+  llvm::StringRef 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(llvm::StringRef directory) : m_directory(directory.str()) {}
+
+  /// Every provider keeps track of its own files.
+  ProviderInfo m_info;
+
+private:
+  /// Every provider knows where to dump its potential files.
+  std::string 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(llvm::StringRef directory);
+  llvm::StringRef GetDirectory() const;
+
+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.
+  std::string 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(llvm::StringRef directory);
+
+  llvm::StringRef GetDirectory() { return m_directory; }
+
+private:
+  llvm::StringMap<ProviderInfo> m_provider_info;
+  std::string m_directory;
+  bool m_loaded;
+};
+
+/// The reproducer enables clients to obtain access to the Generator and
+/// Loader.
+class Reproducer final {
+
+public:
+  static Reproducer &Instance();
+
+  Generator *GetGenerator();
+  Loader *GetLoader();
+
+  const Generator *GetGenerator() const;
+  const Loader *GetLoader() const;
+
+  llvm::Error SetGenerateReproducer(bool value);
+  llvm::Error SetReplayReproducer(bool value);
+
+  llvm::Error SetReproducerPath(llvm::StringRef path);
+  llvm::StringRef GetReproducerPath() const;
+
+private:
+  Generator m_generator;
+  Loader m_loader;
+
+  bool m_generate_reproducer = false;
+  bool m_replay_reproducer = false;
+
+  mutable std::mutex m_mutex;
+};
+
+} // 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__)
+    NO_DEBUG_INFO_TESTCASE = True
+
+    def test(self):
+        """Test record and replay of gdb-remote packets."""
+        self.build()
+
+        # Create temp directory for the reproducer.
+        exe = self.getBuildArtifact("a.out")
+
+        # First capture a regular debugging session.
+        self.runCmd("reproducer capture enable")
+
+        reproducer_path = self.dbg.GetReproducerPath()
+
+        self.runCmd("file {}".format(exe))
+        self.runCmd("breakpoint set -f main.c -l 13")
+        self.runCmd("run")
+        self.runCmd("bt")
+        self.runCmd("cont")
+
+        # Generate the reproducer and stop capturing.
+        self.runCmd("reproducer generate")
+        self.runCmd("reproducer capture disable")
+
+        # Replay the session from the reproducer.
+        self.runCmd("reproducer replay {}".format(reproducer_path))
+
+        # We have to issue the same commands.
+        self.runCmd("file {}".format(exe))
+        self.runCmd("breakpoint set -f main.c -l 13")
+        self.runCmd("run")
+        self.runCmd("bt")
+        self.expect("cont")

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;
+}

scripts/interface/SBDebugger.i

def disassemble_instructions (insts):
     for i in insts:
         print i
 
 ...
 
 # Create a new debugger instance
 debugger = lldb.SBDebugger.Create()
 
-# When we step or continue, don't return from the function until the process 
+# When we step or continue, don't return from the function until the process
 # stops. We do this by setting the async mode to false.
 debugger.SetAsync (False)
 
 # Create a target from a file and arch
 print('Creating a target for \'%s\'' % exe)
 
 target = debugger.CreateTargetWithFileAndArch (exe, lldb.LLDB_ARCH_DEFAULT)
 
 if target:
     # If the target is valid set a breakpoint at main
     main_bp = target.BreakpointCreateByName (fname, target.GetExecutable().GetFilename());
 
     print main_bp
 
     # Launch the process. Since we specified synchronous mode, we won't return
     # from this function until we hit the breakpoint at main
     process = target.LaunchSimple (None, None, os.getcwd())
-    
     # Make sure the launch went ok
     if process:
         # Print some simple process info
         state = process.GetState ()
         print process
         if state == lldb.eStateStopped:
             # Get the first thread
             thread = process.GetThreadAtIndex (0)

 or the equivalent arguments for AttachToProcessWithID.
 ") SBDebugger;
 class SBDebugger
 {
 public:
 
     static void
     Initialize();
-    
     static void
     Terminate();
-    
     static lldb::SBDebugger
     Create();
 
     static lldb::SBDebugger
     Create(bool source_init_files);
 
     static lldb::SBDebugger
     Create(bool source_init_files, lldb::LogOutputCallback log_callback, void *baton);
public:
     bool
     IsValid() const;
 
     void
     Clear ();
 
     void
     SetAsync (bool b);
-    
-    bool 
+    bool
     GetAsync ();
 
     void
     SkipLLDBInitFiles (bool b);
 
     void
     SetInputFileHandle (FILE *f, bool transfer_ownership);
 
public:
     lldb::SBTarget
     GetSelectedTarget ();
 
     void
     SetSelectedTarget (lldb::SBTarget &target);
 
     lldb::SBPlatform
     GetSelectedPlatform();
-    
     void
     SetSelectedPlatform(lldb::SBPlatform &platform);
 
     %feature("docstring",
     "Get the number of currently active platforms."
     ) GetNumPlatforms;
     uint32_t
     GetNumPlatforms ();
public:
 
     lldb::SBSourceManager
     GetSourceManager ();
 
     // REMOVE: just for a quick fix, need to expose platforms through
     // SBPlatform from this class.
     lldb::SBError
     SetCurrentPlatform (const char *platform_name);
-    
     bool
     SetCurrentPlatformSDKRoot (const char *sysroot);
 
     // FIXME: Once we get the set show stuff in place, the driver won't need
     // an interface to the Set/Get UseExternalEditor.
     bool
     SetUseExternalEditor (bool input);
-    
-    bool 
+    bool
     GetUseExternalEditor ();
 
     bool
     SetUseColor (bool use_color);
 
     bool
     GetUseColor () const;
 
public:
     void
     DispatchInput (const void *data, size_t data_len);
 
     void
     DispatchInputInterrupt ();
 
     void
     DispatchInputEndOfFile ();
-    
     const char *
     GetInstanceName  ();
 
     static SBDebugger
     FindDebuggerWithID (int id);
 
     static lldb::SBError
     SetInternalVariable (const char *var_name, const char *value, const char *debugger_instance_name);
 
     static lldb::SBStringList
     GetInternalVariableValue (const char *var_name, const char *debugger_instance_name);
 
     bool
     GetDescription (lldb::SBStream &description);
 
     uint32_t
     GetTerminalWidth () const;
 
     void
     SetTerminalWidth (uint32_t term_width);
 
     lldb::user_id_t
     GetID ();
-    
     const char *
     GetPrompt() const;
 
     void
     SetPrompt (const char *prompt);
-        
-    lldb::ScriptLanguage 
+    const char *
+    GetReproducerPath() const;
+
+    void
+    SetReproducerPath (const char *path);
+
+    lldb::ScriptLanguage
     GetScriptLanguage() const;
 
     void
     SetScriptLanguage (lldb::ScriptLanguage script_lang);
 
     bool
     GetCloseInputOnEOF () const;
-    
     void
     SetCloseInputOnEOF (bool b);
-    
     lldb::SBTypeCategory
     GetCategory (const char* category_name);
-    
     SBTypeCategory
     GetCategory (lldb::LanguageType lang_type);
-    
     lldb::SBTypeCategory
     CreateCategory (const char* category_name);
-    
     bool
     DeleteCategory (const char* category_name);
-    
     uint32_t
     GetNumCategories ();
-    
     lldb::SBTypeCategory
     GetCategoryAtIndex (uint32_t);
-    
     lldb::SBTypeCategory
     GetDefaultCategory();
-    
     lldb::SBTypeFormat
     GetFormatForType (lldb::SBTypeNameSpecifier);
 
     lldb::SBTypeSummary
     GetSummaryForType (lldb::SBTypeNameSpecifier);
 
     lldb::SBTypeFilter
     GetFilterForType (lldb::SBTypeNameSpecifier);
 
     lldb::SBTypeSynthetic
     GetSyntheticForType (lldb::SBTypeNameSpecifier);
 
     void
     RunCommandInterpreter (bool auto_handle_events,
                            bool spawn_thread,
                            SBCommandInterpreterRunOptions &options,
                            int  &num_errors,
                            bool &quit_requested,
                            bool &stopped_for_crash);
-    
     lldb::SBError
     RunREPL (lldb::LanguageType language, const char *repl_options);
 }; // class SBDebugger
 
 } // namespace lldb

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()).GetCString()
+              : nullptr);
+}
+
+void SBDebugger::SetReproducerPath(const char *p) {
+  if (m_opaque_sp)
+    m_opaque_sp->SetReproducerPath(llvm::StringRef::withNullAsEmpty(p));
+}
+
 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/Commands/CMakeLists.txt

add_lldb_library(lldbCommands
   CommandObjectLog.cpp
   CommandObjectMemory.cpp
   CommandObjectMultiword.cpp
   CommandObjectPlatform.cpp
   CommandObjectPlugin.cpp
   CommandObjectProcess.cpp
   CommandObjectQuit.cpp
   CommandObjectRegister.cpp
+  CommandObjectReproducer.cpp
   CommandObjectSettings.cpp
   CommandObjectSource.cpp
   CommandObjectStats.cpp
   CommandObjectTarget.cpp
   CommandObjectThread.cpp
   CommandObjectType.cpp
   CommandObjectVersion.cpp
   CommandObjectWatchpoint.cpp

source/Commands/CommandObjectReproducer.h

+//===-- CommandObjectReproducer.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_CommandObjectReproducer_h_
+#define liblldb_CommandObjectReproducer_h_
+
+#include "lldb/Interpreter/CommandObjectMultiword.h"
+#include "lldb/Interpreter/Options.h"
+
+namespace lldb_private {
+
+//-------------------------------------------------------------------------
+// CommandObjectReproducer
+//-------------------------------------------------------------------------
+
+class CommandObjectReproducer : public CommandObjectMultiword {
+public:
+  CommandObjectReproducer(CommandInterpreter &interpreter);
+
+  ~CommandObjectReproducer() override;
+};
+
+} // namespace lldb_private
+
+#endif // liblldb_CommandObjectReproducer_h_

source/Commands/CommandObjectReproducer.cpp

+//===-- CommandObjectReproducer.cpp -----------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "CommandObjectReproducer.h"
+
+#include "lldb/Utility/Reproducer.h"
+
+#include "lldb/Interpreter/CommandReturnObject.h"
+#include "lldb/Interpreter/OptionArgParser.h"
+#include "lldb/Interpreter/OptionGroupBoolean.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+static void AppendErrorToResult(llvm::Error e, CommandReturnObject &result) {
+  std::string error_str = llvm::toString(std::move(e));
+  result.AppendErrorWithFormat("%s", error_str.c_str());
+}
+
+class CommandObjectReproducerCaptureEnable : public CommandObjectParsed {
+public:
+  CommandObjectReproducerCaptureEnable(CommandInterpreter &interpreter)
+      : CommandObjectParsed(interpreter, "reproducer capture enable",
+                            "Enable gathering information for reproducer",
+                            nullptr) {}
+
+  ~CommandObjectReproducerCaptureEnable() override = default;
+
+protected:
+  bool DoExecute(Args &command, CommandReturnObject &result) override {
+    if (!command.empty()) {
+      result.AppendErrorWithFormat("'%s' takes no arguments",
+                                   m_cmd_name.c_str());
+      return false;
+    }
+
+    auto &r = repro::Reproducer::Instance();
+    if (auto e = r.SetGenerateReproducer(true)) {
+      AppendErrorToResult(std::move(e), result);
+      return false;
+    }
+
+    result.SetStatus(eReturnStatusSuccessFinishNoResult);
+    return result.Succeeded();
+  }
+};
+
+class CommandObjectReproducerCaptureDisable : public CommandObjectParsed {
+public:
+  CommandObjectReproducerCaptureDisable(CommandInterpreter &interpreter)
+      : CommandObjectParsed(interpreter, "reproducer capture enable",
+                            "Disable gathering information for reproducer",
+                            nullptr) {}
+
+  ~CommandObjectReproducerCaptureDisable() override = default;
+
+protected:
+  bool DoExecute(Args &command, CommandReturnObject &result) override {
+    if (!command.empty()) {
+      result.AppendErrorWithFormat("'%s' takes no arguments",
+                                   m_cmd_name.c_str());
+      return false;
+    }
+
+    auto &r = repro::Reproducer::Instance();
+    if (auto e = r.SetGenerateReproducer(false)) {
+      AppendErrorToResult(std::move(e), result);
+      return false;
+    }
+
+    result.SetStatus(eReturnStatusSuccessFinishNoResult);
+    return result.Succeeded();
+  }
+};
+
+class CommandObjectReproducerGenerate : public CommandObjectParsed {
+public:
+  CommandObjectReproducerGenerate(CommandInterpreter &interpreter)
+      : CommandObjectParsed(interpreter, "reproducer generate",
+                            "Generate reproducer on disk.", nullptr) {}
+
+  ~CommandObjectReproducerGenerate() override = default;
+
+protected:
+  bool DoExecute(Args &command, CommandReturnObject &result) override {
+    if (!command.empty()) {
+      result.AppendErrorWithFormat("'%s' takes no arguments",
+                                   m_cmd_name.c_str());
+      return false;
+    }
+
+    auto &r = repro::Reproducer::Instance();
+    if (auto generator = r.GetGenerator()) {
+      generator->Keep();
+    } else {
+      result.AppendErrorWithFormat("Unable to get the reproducer generator");
+      return false;
+    }
+
+    result.GetOutputStream()
+        << "Reproducer written to '" << r.GetReproducerPath() << "'\n";
+
+    result.SetStatus(eReturnStatusSuccessFinishResult);
+    return result.Succeeded();
+  }
+};
+
+class CommandObjectReproducerReplay : public CommandObjectParsed {
+public:
+  CommandObjectReproducerReplay(CommandInterpreter &interpreter)
+      : CommandObjectParsed(interpreter, "reproducer capture",
+                            "Enable or disable gathering of information needed "
+                            "to generate a reproducer.",
+                            nullptr) {
+    CommandArgumentEntry arg1;
+    CommandArgumentData path_arg;
+
+    // Define the first (and only) variant of this arg.
+    path_arg.arg_type = eArgTypePath;
+    path_arg.arg_repetition = eArgRepeatPlain;
+
+    // There is only one variant this argument could be; put it into the
+    // argument entry.
+    arg1.push_back(path_arg);
+
+    // Push the data for the first argument into the m_arguments vector.
+    m_arguments.push_back(arg1);
+  }
+
+  ~CommandObjectReproducerReplay() override = default;
+
+protected:
+  bool DoExecute(Args &command, CommandReturnObject &result) override {
+    if (command.empty()) {
+      result.AppendErrorWithFormat(
+          "'%s' takes a single argument: the reproducer path",
+          m_cmd_name.c_str());
+      return false;
+    }
+
+    auto &r = repro::Reproducer::Instance();
+
+    if (auto e = r.SetReplayReproducer(true)) {
+      std::string error_str = llvm::toString(std::move(e));
+      result.AppendErrorWithFormat("%s", error_str.c_str());
+      return false;
+    }
+
+    if (auto loader = r.GetLoader()) {
+      const char *repro_path = command.GetArgumentAtIndex(0);
+      if (auto e = loader->LoadIndex(repro_path)) {
+        std::string error_str = llvm::toString(std::move(e));
+        result.AppendErrorWithFormat("Unable to load reproducer: %s",
+                                     error_str.c_str());
+        return false;
+      }
+    } else {
+      result.AppendErrorWithFormat("Unable to get the reproducer loader");
+      return false;
+    }
+
+    result.SetStatus(eReturnStatusSuccessFinishNoResult);
+    return result.Succeeded();
+  }
+};
+
+class CommandObjectReproducerCapture : public CommandObjectMultiword {
+private:
+public:
+  CommandObjectReproducerCapture(CommandInterpreter &interpreter)
+      : CommandObjectMultiword(
+            interpreter, "reproducer capture",
+            "Manage gathering of information needed to generate a reproducer.",
+            NULL) {
+    LoadSubCommand(
+        "enable",
+        CommandObjectSP(new CommandObjectReproducerCaptureEnable(interpreter)));
+    LoadSubCommand("disable",
+                   CommandObjectSP(
+                       new CommandObjectReproducerCaptureDisable(interpreter)));
+  }
+
+  ~CommandObjectReproducerCapture() {}
+};
+
+CommandObjectReproducer::CommandObjectReproducer(
+    CommandInterpreter &interpreter)
+    : CommandObjectMultiword(interpreter, "reproducer",
+                             "Commands controlling LLDB reproducers.",
+                             "log <subcommand> [<command-options>]") {
+  LoadSubCommand("capture", CommandObjectSP(new CommandObjectReproducerCapture(
+                                interpreter)));
+  LoadSubCommand(
+      "generate",
+      CommandObjectSP(new CommandObjectReproducerGenerate(interpreter)));
+  LoadSubCommand("replay", CommandObjectSP(
+                               new CommandObjectReproducerReplay(interpreter)));
+}
+
+CommandObjectReproducer::~CommandObjectReproducer() = default;

source/Core/Debugger.cpp

 #include "lldb/Target/Process.h"
 #include "lldb/Target/StructuredDataPlugin.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/TargetList.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadList.h" // for ThreadList
 #include "lldb/Utility/AnsiTerminal.h"
 #include "lldb/Utility/Log.h" // for LLDB_LOG_OPTION_...
+#include "lldb/Utility/Reproducer.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/Stream.h" // for Stream
 #include "lldb/Utility/StreamCallback.h"
 #include "lldb/Utility/StreamString.h"
 
 #if defined(_WIN32)
 #include "lldb/Host/windows/PosixApi.h" // for PATH_MAX
 #include "lldb/Host/windows/windows.h"
static constexpr PropertyDefinition g_properties[] = {
      {},
      "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, {},
      "The default frame format string to use when displaying stack frame"
      "information for threads from thread backtrace unique."}};
 
 enum {
   ePropertyAutoConfirm = 0,
   ePropertyDisassemblyFormat,
   ePropertyFrameFormat,
   ePropertyNotiftVoid,
   ePropertyPrompt,
   ePropertyScriptLanguage,
   ePropertyStopDisassemblyCount,
   ePropertyStopDisassemblyDisplay,
void Debugger::SetPrompt(llvm::StringRef p) {
   llvm::StringRef new_prompt = GetPrompt();
   std::string str =
       lldb_utility::ansi::FormatAnsiTerminalCodes(new_prompt, GetUseColor());
   if (str.length())
     new_prompt = str;
   GetCommandInterpreter().UpdatePrompt(new_prompt);
 }
 
+llvm::StringRef Debugger::GetReproducerPath() const {
+  auto &r = repro::Reproducer::Instance();
+  return r.GetReproducerPath();
+}
+
+void Debugger::SetReproducerPath(llvm::StringRef p) {
+  auto &r = repro::Reproducer::Instance();
+  if (auto e = r.SetReproducerPath(p))
+    llvm::consumeError(std::move(e));
+}
+
 const FormatEntity::Entry *Debugger::GetThreadFormat() const {
   const uint32_t idx = ePropertyThreadFormat;
   return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
 }
 
 const FormatEntity::Entry *Debugger::GetThreadStopFormat() const {
   const uint32_t idx = ePropertyThreadStopFormat;
   return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
void Debugger::Initialize(LoadPluginCallbackType load_plugin_callback) {
   g_debugger_list_ptr = new DebuggerList();
   g_load_plugin_callback = load_plugin_callback;
 }
 
 void Debugger::Terminate() {
   assert(g_debugger_list_ptr &&
          "Debugger::Terminate called without a matching Debugger::Initialize!");
 
   if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
     // Clear our master list of debugger objects
     {
       std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
       for (const auto &debugger : *g_debugger_list_ptr)
         debugger->Clear();
       g_debugger_list_ptr->clear();
     }
   }
 }
 
 void Debugger::SettingsInitialize() { Target::SettingsInitialize(); }
 
 void Debugger::SettingsTerminate() { Target::SettingsTerminate(); }
 

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/Interpreter/CommandInterpreter.cpp

 #include "Commands/CommandObjectLanguage.h"
 #include "Commands/CommandObjectLog.h"
 #include "Commands/CommandObjectMemory.h"
 #include "Commands/CommandObjectPlatform.h"
 #include "Commands/CommandObjectPlugin.h"
 #include "Commands/CommandObjectProcess.h"
 #include "Commands/CommandObjectQuit.h"
 #include "Commands/CommandObjectRegister.h"
+#include "Commands/CommandObjectReproducer.h"
 #include "Commands/CommandObjectSettings.h"
 #include "Commands/CommandObjectSource.h"
 #include "Commands/CommandObjectStats.h"
 #include "Commands/CommandObjectTarget.h"
 #include "Commands/CommandObjectThread.h"
 #include "Commands/CommandObjectType.h"
 #include "Commands/CommandObjectVersion.h"
 #include "Commands/CommandObjectWatchpoint.h"
#endif
   }
 
   cmd_obj_sp = GetCommandSPExact("frame variable", false);
   if (cmd_obj_sp) {
     AddAlias("v", cmd_obj_sp);
     AddAlias("var", cmd_obj_sp);
     AddAlias("vo", cmd_obj_sp, "--object-description");
   }
-  
 }
 
 void CommandInterpreter::Clear() {
   m_command_io_handler_sp.reset();
 
   if (m_script_interpreter_sp)
     m_script_interpreter_sp->Clear();
 }
void CommandInterpreter::LoadCommandDictionary() {
   m_command_dict["platform"] =
       CommandObjectSP(new CommandObjectPlatform(*this));
   m_command_dict["plugin"] = CommandObjectSP(new CommandObjectPlugin(*this));
   m_command_dict["process"] =
       CommandObjectSP(new CommandObjectMultiwordProcess(*this));
   m_command_dict["quit"] = CommandObjectSP(new CommandObjectQuit(*this));
   m_command_dict["register"] =
       CommandObjectSP(new CommandObjectRegister(*this));
+  m_command_dict["reproducer"] =
+      CommandObjectSP(new CommandObjectReproducer(*this));
   m_command_dict["script"] =
       CommandObjectSP(new CommandObjectScript(*this, script_language));
   m_command_dict["settings"] =
       CommandObjectSP(new CommandObjectMultiwordSettings(*this));
   m_command_dict["source"] =
       CommandObjectSP(new CommandObjectMultiwordSource(*this));
   m_command_dict["statistics"] = CommandObjectSP(new CommandObjectStats(*this));
   m_command_dict["target"] =
if (error.Success()) {
         } else if (m_command_source_flags.back() &
                    eHandleCommandFlagStopOnError) {
           flags |= eHandleCommandFlagStopOnError;
         }
       } else if (options.m_stop_on_error == eLazyBoolYes) {
         flags |= eHandleCommandFlagStopOnError;
       }
 
-      // stop-on-crash can only be set, if it is present in all levels of 
+      // stop-on-crash can only be set, if it is present in all levels of
       // pushed flag sets.
       if (options.GetStopOnCrash()) {
         if (m_command_source_flags.empty()) {
           flags |= eHandleCommandFlagStopOnCrash;
         } else if (m_command_source_flags.back() &
                    eHandleCommandFlagStopOnCrash) {
           flags |= eHandleCommandFlagStopOnCrash;
         }

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(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(llvm::raw_ostream *strm) {
+  m_history.SetStream(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(llvm::raw_ostream *strm) { m_stream = 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;
+  llvm::raw_ostream *m_stream = nullptr;
+};
+
+} // 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);
+  strm.flush();
+}
+
+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 && type == ePacketTypeRecv)
+    m_packets[idx].Serialize(*m_stream);
+}
+
+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 && type == ePacketTypeRecv)
+    m_packets[idx].Serialize(*m_stream);
+}
+
+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 constexpr PropertyDefinition g_properties[] = {
     {"packet-timeout", OptionValue::eTypeUInt64, true, 1, NULL, {},
      "Specify the default packet timeout in seconds."},
     {"target-definition-file", OptionValue::eTypeFileSpec, true, 0, 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(llvm::StringRef directory) : Provider(directory) {
+    m_info.name = "gdb-remote";
+    m_info.files.push_back("gdb-remote.yaml");
+  }
+
+  raw_ostream *GetHistoryStream() {
+    FileSpec history_file(GetDirectory(), false);
+    history_file.AppendPathComponent("gdb-remote.yaml");
+
+    std::error_code EC;
+    m_stream_up = make_unique<raw_fd_ostream>(history_file.GetPath(), EC,
+                                              sys::fs::OpenFlags::F_None);
+    return m_stream_up.get();
+  }
+
+  void SetCallback(std::function<void()> callback) {
+    m_callback = std::move(callback);
+  }
+
+  void Keep() override { m_callback(); }
+
+  void Discard() override { m_callback(); }
+
+private:
+  std::function<void()> m_callback;
+  std::unique_ptr<raw_fd_ostream> m_stream_up;
+};
+
+} // 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 = repro::Reproducer::Instance().GetGenerator();
+  if (generator) {
+    ProcessGDBRemoteProvider &provider =
+        generator->CreateProvider<ProcessGDBRemoteProvider>();
+    // Set the history stream to the stream owned by the provider.
+    m_gdb_comm.SetHistoryStream(provider.GetHistoryStream());
+    // Make sure to clear the stream again when we're finished.
+    provider.SetCallback([&]() { m_gdb_comm.SetHistoryStream(nullptr); });
+  }
+
   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(), false);
+  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 = repro::Reproducer::Instance().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)
 #define USE_SOCKETPAIR_FOR_LOCAL_CONNECTION 1
#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;

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/Threading.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace lldb_private;
+using namespace lldb_private::repro;
+using namespace llvm;
+using namespace llvm::yaml;
+
+Reproducer &Reproducer::Instance() {
+  static Reproducer *g_reproducer;
+  static llvm::once_flag g_once_flag;
+  llvm::call_once(g_once_flag, []() {
+    if (g_reproducer == nullptr)
+      g_reproducer = new Reproducer();
+  });
+  return *g_reproducer;
+}
+
+const Generator *Reproducer::GetGenerator() const {
+  std::lock_guard<std::mutex> guard(m_mutex);
+  if (m_generate_reproducer)
+    return &m_generator;
+  return nullptr;
+}
+
+const Loader *Reproducer::GetLoader() const {
+  std::lock_guard<std::mutex> guard(m_mutex);
+  if (m_replay_reproducer)
+    return &m_loader;
+  return nullptr;
+}
+
+Generator *Reproducer::GetGenerator() {
+  std::lock_guard<std::mutex> guard(m_mutex);
+  if (m_generate_reproducer)
+    return &m_generator;
+  return nullptr;
+}
+
+Loader *Reproducer::GetLoader() {
+  std::lock_guard<std::mutex> guard(m_mutex);
+  if (m_replay_reproducer)
+    return &m_loader;
+  return nullptr;
+}
+
+llvm::Error Reproducer::SetGenerateReproducer(bool value) {
+  std::lock_guard<std::mutex> guard(m_mutex);
+
+  if (value && m_replay_reproducer)
+    return make_error<StringError>(
+        "cannot generate a reproducer when replay one",
+        inconvertibleErrorCode());
+
+  m_generate_reproducer = value;
+  m_generator.SetEnabled(value);
+
+  return Error::success();
+}
+
+llvm::Error Reproducer::SetReplayReproducer(bool value) {
+  std::lock_guard<std::mutex> guard(m_mutex);
+
+  if (value && m_generate_reproducer)
+    return make_error<StringError>(
+        "cannot replay a reproducer when generating one",
+        inconvertibleErrorCode());
+
+  m_replay_reproducer = value;
+
+  return Error::success();
+}
+
+llvm::Error Reproducer::SetReproducerPath(llvm::StringRef path) {
+  // Setting the path implies using the reproducer.
+  if (auto e = SetReplayReproducer(true))
+    return e;
+
+  // Tell the reproducer to load the index form the given path.
+  if (auto loader = GetLoader()) {
+    if (auto e = loader->LoadIndex(path))
+      return e;
+  }
+
+  return make_error<StringError>("unable to get loader",
+                                 inconvertibleErrorCode());
+}
+
+llvm::StringRef Reproducer::GetReproducerPath() const {
+  if (auto g = GetGenerator())
+    return g->GetDirectory();
+  return {};
+}
+
+Generator::Generator() : m_enabled(false), m_done(false) {
+  m_directory = HostInfo::GetReproducerTempDir().GetPath();
+}
+
+Generator::~Generator() {}
+
+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();
+}
+
+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);
+}
+
+void Generator::ChangeDirectory(llvm::StringRef directory) {
+  assert(m_providers.empty() && "Changing the directory after providers have "
+                                "been registered would invalidate the index.");
+  m_directory = directory.str();
+}
+
+llvm::StringRef Generator::GetDirectory() const { return m_directory; }
+
+void Generator::AddProviderToIndex(const ProviderInfo &provider_info) {
+  SmallString<128> index(m_directory.begin(), m_directory.end());
+  sys::path::append(index, "index.yaml");
+
+  std::error_code EC;
+  auto strm =
+      make_unique<raw_fd_ostream>(index, 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(llvm::StringRef directory) {
+  if (m_loaded)
+    return llvm::Error::success();
+
+  SmallString<128> index(directory.begin(), directory.end());
+  sys::path::append(index, "index.yaml");
+
+  auto error_or_file = MemoryBuffer::getFile(index);
+  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 constexpr 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 constexpr 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."}};
 
 static constexpr auto g_num_options = sizeof(g_options)/sizeof(OptionDefinition);
 
 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