[Reproducers] Change how reproducers are initialized.

[JDevlieghere]

Summary

This patch changes the way the reproducer is initialized. Rather than making changes at run time we now do everything at initialization time. To make this happen we had to introduce initializer options and their SB variant. This allows us to tell the initializer that we're running in reproducer capture/replay mode.

Because of this change we also had to alter our testing strategy. We cannot reinitialize LLDB when using the dotest infrastructure. Instead we use lit and invoke two instances of the driver.

Another consequence is that we can no longer enable capture or replay through commands. This was bound to go away form the beginning, but I had something in mind where you could enable/disable specific providers. However this seems like it adds very little value right now so I just removed the corresponding commands. This also means you now have to control this through the driver, for which I replaced --reproducer with --capture and --replay.

[labath]

I have a lot of comments, but I think they're mostly cosmetic. I think the general idea here is good.

include/lldb/API/SBInitializerOptions.h

15 ↗

(On Diff #175792)

You cannot include non-API headers from SB headers (cpp files are fine). SystemInitializer::Options needs to forward-declared. (I guess that means moving it out of the SystemInitializer class).

17 ↗

(On Diff #175792)

not needed?

32 ↗

(On Diff #175792)

I think this will make the copy-constructor of this class deleted, which will not play well with python. I think you'll need to declare your own copy operations here (something like SBExpressionOptions, I guess).

Also, why is this mutable? SBExpressionOptions seems to have that too, but it's not clear to me why would that be needed?

include/lldb/Initialization/SystemInitializer.h

28 ↗

(On Diff #175792)

const Options & ? (it contains a string so it's not trivial to copy).

lit/Reproducer/TestGDBRemoteRepro.test

7 ↗

(On Diff #175792)

With --target this test will not run on other platforms. This sounds like it should work on platforms using gdb-remote (i.e., mac & linux). Maybe remove the --target and set an appropriate REQUIRES directive.

8 ↗

(On Diff #175792)

s/REPLAY/CAPTURE ?

scripts/interface/SBInitializerOptions.i

15 ↗

(On Diff #175792)

Weird formatting.

source/Initialization/SystemInitializerCommon.cpp

74 ↗

(On Diff #175792)

remove .c_str()

source/Utility/Reproducer.cpp

41–42 ↗

(On Diff #175792)

It should be possible to bubble this all the way up to the SBDebugger::Initialize call. Is there a reason to not do that?

tools/driver/CMakeLists.txt

21 ↗

(On Diff #175792)

This is wrong. The driver should only use the public API exposed via liblldb. Why did you need to do that?

unittests/Utility/ReproducerTest.cpp

39–43 ↗

(On Diff #175792)

You should be able to change the visibility of these via using directives. (using Reproducer::SetCapture).

[JDevlieghere]

Address feedback from Pavel.

source/Utility/Reproducer.cpp

41–42 ↗

(On Diff #175792)

Do you mean having the private Initialize function return an error (and an SBError for the SB variant)?

tools/driver/CMakeLists.txt

21 ↗

(On Diff #175792)

I don't remember, anyway it's definitely not necessary or correct.

[JDevlieghere]

Test didn't run. Is there a way to REQUIRE either darwin or linux?

[labath]

In D55038#1314026, @JDevlieghere wrote:

Test didn't run. Is there a way to REQUIRE either darwin or linux?

I think the canonical way to do that would be to define a new feature in lit, which gets set when the target supports remote debugging and then use that feature in the REQUIRES directive.

source/Utility/Reproducer.cpp

41–42 ↗

(On Diff #175792)

Yes, that's what I meant. Up until now, our initialization functions were mostly just hooking up various pointers, which are things that can't (shouldn't) fail, but if now a simple typo in the reproducer path can cause the initialization to fail, then I think it would be good to report that.

[JDevlieghere]

Make initialize return an error.

[JDevlieghere]

In D55038#1314336, @labath wrote:

In D55038#1314026, @JDevlieghere wrote:

Test didn't run. Is there a way to REQUIRE either darwin or linux?

I think the canonical way to do that would be to define a new feature in lit, which gets set when the target supports remote debugging and then use that feature in the REQUIRES directive.

I've changed the check to non-windows (as it wouldn't compile there anyway). Is there anything not covered by this that would warrant this new feature?

[labath]

In D55038#1314968, @JDevlieghere wrote:

In D55038#1314336, @labath wrote:

I think the canonical way to do that would be to define a new feature in lit, which gets set when the target supports remote debugging and then use that feature in the REQUIRES directive.

I've changed the check to non-windows (as it wouldn't compile there anyway). Is there anything not covered by this that would warrant this new feature?

Well.. FreeBSD also uses a local debugging plugin, though I don't believe anyone runs tests there on a regular basis. I suppose that could be handled by adding system-freebsd into the UNSUPPORTED clause...

Looks good to me, modulo one comment.

source/Initialization/SystemLifetimeManager.cpp

27 ↗

(On Diff #176161)

The calls to this function in lldb-server and lldb-test need to be updated to handle the newly returned Error object.

[stella.stamenova]

One of these tests fail on Windows (TestDriverOptions):

http://lab.llvm.org:8014/builders/lldb-x64-windows-ninja/builds/1848/steps/test/logs/stdio

[JDevlieghere]

In D55038#1317099, @stella.stamenova wrote:

One of these tests fail on Windows (TestDriverOptions):

http://lab.llvm.org:8014/builders/lldb-x64-windows-ninja/builds/1848/steps/test/logs/stdio

Thanks, I've disabled the test in r348186 while I try to figure out why it fails.

lldb/trunk/include/lldb/API/SBDebugger.h

 //===-- SBDebugger.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_SBDebugger_h_
 #define LLDB_SBDebugger_h_
 
 #include <stdio.h>
 
 #include "lldb/API/SBDefines.h"
+#include "lldb/API/SBInitializerOptions.h"
 #include "lldb/API/SBPlatform.h"
 
 namespace lldb {
 
 class LLDB_API SBInputReader {
 public:
   SBInputReader() = default;
   ~SBInputReader() = default;
public:
 
   SBDebugger(const lldb::DebuggerSP &debugger_sp);
 
   ~SBDebugger();
 
   lldb::SBDebugger &operator=(const lldb::SBDebugger &rhs);
 
   static void Initialize();
+  static lldb::SBError Initialize(SBInitializerOptions &options);
 
   static void Terminate();
 
   // Deprecated, use the one that takes a source_init_files bool.
   static lldb::SBDebugger Create();
 
   static lldb::SBDebugger Create(bool source_init_files);
 
public:
   lldb::user_id_t GetID();
 
   const char *GetPrompt() const;
 
   void SetPrompt(const char *prompt);
 
   const char *GetReproducerPath() const;
 
-  lldb::SBError ReplayReproducer(const char *path);
-
   lldb::ScriptLanguage GetScriptLanguage() const;
 
   void SetScriptLanguage(lldb::ScriptLanguage script_lang);
 
   bool GetCloseInputOnEOF() const;
 
   void SetCloseInputOnEOF(bool b);
 

lldb/trunk/include/lldb/API/SBDefines.h

 class LLDB_API SBEventList;
 class LLDB_API SBExecutionContext;
 class LLDB_API SBExpressionOptions;
 class LLDB_API SBFileSpec;
 class LLDB_API SBFileSpecList;
 class LLDB_API SBFrame;
 class LLDB_API SBFunction;
 class LLDB_API SBHostOS;
+class LLDB_API SBInitializerOptions;
 class LLDB_API SBInstruction;
 class LLDB_API SBInstructionList;
 class LLDB_API SBLanguageRuntime;
 class LLDB_API SBLaunchInfo;
 class LLDB_API SBLineEntry;
 class LLDB_API SBListener;
 class LLDB_API SBMemoryRegionInfo;
 class LLDB_API SBMemoryRegionInfoList;

lldb/trunk/include/lldb/API/SBFileSpec.h

 private:
   friend class SBAttachInfo;
   friend class SBBlock;
   friend class SBCommandInterpreter;
   friend class SBCompileUnit;
   friend class SBDeclaration;
   friend class SBFileSpecList;
   friend class SBHostOS;
+  friend class SBInitializerOptions;
   friend class SBLaunchInfo;
   friend class SBLineEntry;
   friend class SBModule;
   friend class SBModuleSpec;
   friend class SBPlatform;
   friend class SBProcess;
   friend class SBProcessInfo;
   friend class SBSourceManager;
-  friend class SBThread;
   friend class SBTarget;
+  friend class SBThread;
 
   SBFileSpec(const lldb_private::FileSpec &fspec);
 
   void SetFileSpec(const lldb_private::FileSpec &fspec);
 
   const lldb_private::FileSpec *operator->() const;
 
   const lldb_private::FileSpec *get() const;

lldb/trunk/include/lldb/API/SBInitializerOptions.h

+//===-- SBInitializerOptions.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_SBInitializerOptuions_h_
+#define LLDB_SBInitializerOptuions_h_
+
+#include "lldb/API/SBDefines.h"
+#include "lldb/API/SBFileSpec.h"
+
+namespace lldb_private {
+struct InitializerOptions;
+}
+
+namespace lldb {
+
+class LLDB_API SBInitializerOptions {
+public:
+  SBInitializerOptions();
+  SBInitializerOptions(const lldb::SBInitializerOptions &rhs);
+  ~SBInitializerOptions();
+  const SBInitializerOptions &operator=(const lldb::SBInitializerOptions &rhs);
+
+  void SetCaptureReproducer(bool b);
+  void SetReplayReproducer(bool b);
+  void SetReproducerPath(const char *path);
+
+  lldb_private::InitializerOptions &ref() const;
+
+private:
+  friend class SBDebugger;
+
+  std::unique_ptr<lldb_private::InitializerOptions> m_opaque_up;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBInitializerOptuions_h_

lldb/trunk/include/lldb/Core/Debugger.h

public:
 
   llvm::StringRef GetPrompt() const;
 
   void SetPrompt(llvm::StringRef p);
   void SetPrompt(const char *) = delete;
 
   llvm::StringRef GetReproducerPath() const;
 
-  llvm::Error SetReproducerReplay(llvm::StringRef p);
-  llvm::Error SetReproducerReplay(const char *) = delete;
-
-  llvm::Error SetReproducerCapture(bool b);
-
   bool GetUseExternalEditor() const;
 
   bool SetUseExternalEditor(bool use_external_editor_p);
 
   bool GetUseColor() const;
 
   bool SetUseColor(bool use_color);
 

lldb/trunk/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

lldb/trunk/include/lldb/Initialization/SystemInitializer.h

 //===-- SystemInitializer.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_INITIALIZATION_SYSTEM_INITIALIZER_H
 #define LLDB_INITIALIZATION_SYSTEM_INITIALIZER_H
 
+#include "llvm/Support/Error.h"
+
+#include <string>
+
 namespace lldb_private {
+
+struct InitializerOptions {
+  bool reproducer_capture = false;
+  bool reproducer_replay = false;
+  std::string reproducer_path;
+};
+
 class SystemInitializer {
 public:
   SystemInitializer();
   virtual ~SystemInitializer();
 
-  virtual void Initialize() = 0;
+  virtual llvm::Error Initialize(const InitializerOptions &options) = 0;
   virtual void Terminate() = 0;
 };
 }
 
 #endif

lldb/trunk/include/lldb/Initialization/SystemInitializerCommon.h

 /// an instance of SystemLifetimeManager with this class passed to
 /// the constructor.
 //------------------------------------------------------------------
 class SystemInitializerCommon : public SystemInitializer {
 public:
   SystemInitializerCommon();
   ~SystemInitializerCommon() override;
 
-  void Initialize() override;
+  llvm::Error Initialize(const InitializerOptions &options) override;
   void Terminate() override;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_INITIALIZATION_SYSTEM_INITIALIZER_COMMON_H

lldb/trunk/include/lldb/Initialization/SystemLifetimeManager.h

 //===-- SystemLifetimeManager.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_INITIALIZATION_SYSTEM_LIFETIME_MANAGER_H
 #define LLDB_INITIALIZATION_SYSTEM_LIFETIME_MANAGER_H
 
+#include "lldb/Initialization/SystemInitializer.h"
 #include "lldb/lldb-private-types.h"
+#include "llvm/Support/Error.h"
 
 #include <memory>
 #include <mutex>
 
 namespace lldb_private {
-class SystemInitializer;
 
 class SystemLifetimeManager {
 public:
   SystemLifetimeManager();
   ~SystemLifetimeManager();
 
-  void Initialize(std::unique_ptr<SystemInitializer> initializer,
+  llvm::Error Initialize(std::unique_ptr<SystemInitializer> initializer,
+                         const InitializerOptions &options,
                          LoadPluginCallbackType plugin_callback);
   void Terminate();
 
 private:
   std::recursive_mutex m_mutex;
   std::unique_ptr<SystemInitializer> m_initializer;
   bool m_initialized;
 
   // Noncopyable.
   SystemLifetimeManager(const SystemLifetimeManager &other) = delete;
   SystemLifetimeManager &operator=(const SystemLifetimeManager &other) = delete;
 };
 }
 
 #endif

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

 #include <string>
 #include <vector>
 
 namespace lldb_private {
 namespace repro {
 
 class Reproducer;
 
+enum class ReproducerMode {
+  Capture,
+  Replay,
+  Off,
+};
+
 /// 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

 private:
   llvm::StringMap<ProviderInfo> m_provider_info;
   FileSpec m_root;
   bool m_loaded;
 };
 
 /// The reproducer enables clients to obtain access to the Generator and
 /// Loader.
-class Reproducer final {
-
+class Reproducer {
 public:
   static Reproducer &Instance();
+  static llvm::Error Initialize(ReproducerMode mode,
+                                llvm::Optional<FileSpec> root);
+  static void Terminate();
+
+  Reproducer() = default;
 
   Generator *GetGenerator();
   Loader *GetLoader();
 
   const Generator *GetGenerator() const;
   const Loader *GetLoader() const;
 
+  FileSpec GetReproducerPath() const;
+
+protected:
   llvm::Error SetCapture(llvm::Optional<FileSpec> root);
   llvm::Error SetReplay(llvm::Optional<FileSpec> root);
 
-  FileSpec GetReproducerPath() const;
-
 private:
+  static llvm::Optional<Reproducer> &InstanceImpl();
+
   llvm::Optional<Generator> m_generator;
   llvm::Optional<Loader> m_loader;
 
   mutable std::mutex m_mutex;
 };
 
 } // namespace repro
 } // namespace lldb_private

lldb/trunk/lit/Reproducer/Inputs/GDBRemoteCapture.in

+breakpoint set -f simple.c -l 13
+run
+bt
+cont
+reproducer status
+reproducer generate

lldb/trunk/lit/Reproducer/Inputs/GDBRemoteReplay.in

+reproducer status
+breakpoint set -f simple.c -l 13
+run
+bt
+cont

lldb/trunk/lit/Reproducer/Inputs/simple.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;
+}

lldb/trunk/lit/Reproducer/TestDriverOptions.test

+# Check that errors are propagated to the driver.
+
+# RUN: not %lldb --capture /bogus 2>&1 | FileCheck %s --check-prefix CAPTURE
+# RUN: not %lldb --replay /bogus  2>&1 | FileCheck %s --check-prefix REPLAY
+
+# CAPTURE: unable to create reproducer directory
+# REPLAY: unable to load reproducer index

lldb/trunk/lit/Reproducer/TestGDBRemoteRepro.test

+# UNSUPPORTED: system-windows, system-freebsd
+
+# This tests the replaying of GDB remote packets.
+#
+# We issue the same commands and ensure the output is identical to the original
+# process. To ensure we're not actually running the original binary we check
+# that the string "testing" is not printed.
+
+# RUN: %clang %S/Inputs/simple.c -g -o %t.out
+# RUN: %lldb -x -b -s %S/Inputs/GDBRemoteCapture.in --capture %T/reproducer -- %t.out | FileCheck %s --check-prefix CHECK --check-prefix CAPTURE
+# RUN: %lldb -x -b -s %S/Inputs/GDBRemoteReplay.in --replay %T/reproducer -- %t.out | FileCheck %s --check-prefix CHECK --check-prefix REPLAY
+
+# CHECK: Breakpoint 1
+# CHECK: Process {{.*}} stopped
+# CHECK: Process {{.*}} launched
+# CHECK: thread {{.*}} stop reason = breakpoint
+# CHECK: frame {{.*}} simple.c
+
+# CAPTURE: testing
+# REPLAY-NOT: testing
+
+# CHECK: Process {{.*}} resuming
+# CHECK: Process {{.*}} exited
+
+# CAPTURE: Reproducer is in capture mode.
+# CAPTURE: Reproducer written

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

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

lldb/trunk/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")

lldb/trunk/scripts/interface/SBDebugger.i

 class SBDebugger
 {
 public:
 
     static void
     Initialize();
 
     static void
+    Initialize(lldb::SBInitializerOptions& options);
+
+    static void
     Terminate();
 
     static lldb::SBDebugger
     Create();
 
     static lldb::SBDebugger
     Create(bool source_init_files);
 
public:
     GetPrompt() const;
 
     void
     SetPrompt (const char *prompt);
 
     const char *
     GetReproducerPath() const;
 
-    lldb::SBError
-    ReplayReproducer (const char *path);
-
     lldb::ScriptLanguage
     GetScriptLanguage() const;
 
     void
     SetScriptLanguage (lldb::ScriptLanguage script_lang);
 
     bool
     GetCloseInputOnEOF () const;

lldb/trunk/scripts/interface/SBInitializerOptions.i

+//===-- SWIG Interface for SBInitializerOptions -----------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+namespace lldb {
+
+class SBInitializerOptions
+{
+public:
+  SBInitializerOptions ();
+  SBInitializerOptions (const lldb::SBInitializerOptions &rhs);
+  ~SBInitializerOptions();
+
+  void SetCaptureReproducer(bool b);
+  void SetReplayReproducer(bool b);
+  void SetReproducerPath(const char* path);
+};
+
+} // namespace lldb

lldb/trunk/scripts/lldb.swig

 %include "./interface/SBEvent.i"
 %include "./interface/SBExecutionContext.i"
 %include "./interface/SBExpressionOptions.i"
 %include "./interface/SBFileSpec.i"
 %include "./interface/SBFileSpecList.i"
 %include "./interface/SBFrame.i"
 %include "./interface/SBFunction.i"
 %include "./interface/SBHostOS.i"
+%include "./interface/SBInitializerOptions.i"
 %include "./interface/SBInstruction.i"
 %include "./interface/SBInstructionList.i"
 %include "./interface/SBLanguageRuntime.i"
 %include "./interface/SBLaunchInfo.i"
 %include "./interface/SBLineEntry.i"
 %include "./interface/SBListener.i"
 %include "./interface/SBMemoryRegionInfo.i"
 %include "./interface/SBMemoryRegionInfoList.i"

lldb/trunk/source/API/CMakeLists.txt

add_lldb_library(liblldb SHARED
   SBEvent.cpp
   SBExecutionContext.cpp
   SBExpressionOptions.cpp
   SBFileSpec.cpp
   SBFileSpecList.cpp
   SBFrame.cpp
   SBFunction.cpp
   SBHostOS.cpp
+  SBInitializerOptions.cpp
   SBInstruction.cpp
   SBInstructionList.cpp
   SBLanguageRuntime.cpp
   SBLaunchInfo.cpp
   SBLineEntry.cpp
   SBListener.cpp
   SBMemoryRegionInfo.cpp
   SBMemoryRegionInfoList.cpp

lldb/trunk/source/API/SBDebugger.cpp

 SBDebugger &SBDebugger::operator=(const SBDebugger &rhs) {
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
   }
   return *this;
 }
 
 void SBDebugger::Initialize() {
+  SBInitializerOptions options;
+  SBDebugger::Initialize(options);
+}
+
+lldb::SBError SBDebugger::Initialize(SBInitializerOptions &options) {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)
     log->Printf("SBDebugger::Initialize ()");
 
-  g_debugger_lifetime->Initialize(llvm::make_unique<SystemInitializerFull>(),
-                                  LoadPlugin);
+  SBError error;
+  if (auto e = g_debugger_lifetime->Initialize(
+          llvm::make_unique<SystemInitializerFull>(), *options.m_opaque_up,
+          LoadPlugin)) {
+    error.SetError(Status(std::move(e)));
+  }
+  return error;
 }
 
 void SBDebugger::Terminate() { g_debugger_lifetime->Terminate(); }
 
 void SBDebugger::Clear() {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)

 }
 
 const char *SBDebugger::GetReproducerPath() const {
   return (m_opaque_sp
               ? ConstString(m_opaque_sp->GetReproducerPath()).GetCString()
               : nullptr);
 }
 
-SBError SBDebugger::ReplayReproducer(const char *p) {
-  SBError sb_error;
-  if (m_opaque_sp) {
-    auto error =
-        m_opaque_sp->SetReproducerReplay(llvm::StringRef::withNullAsEmpty(p));
-    std::string error_str = llvm::toString(std::move(error));
-    sb_error.ref().SetErrorString(error_str);
-  }
-  return sb_error;
-}
-
 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);
   }

lldb/trunk/source/API/SBInitializerOptions.cpp

+//===-- SBInitializerOptions.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/API/SBInitializerOptions.h"
+#include "lldb/Initialization/SystemInitializer.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+SBInitializerOptions::SBInitializerOptions(const SBInitializerOptions &rhs) {
+  m_opaque_up.reset(new InitializerOptions());
+  *(m_opaque_up.get()) = rhs.ref();
+}
+
+const SBInitializerOptions &SBInitializerOptions::
+operator=(const SBInitializerOptions &rhs) {
+  if (this != &rhs) {
+    this->ref() = rhs.ref();
+  }
+  return *this;
+}
+
+SBInitializerOptions::~SBInitializerOptions() {}
+
+SBInitializerOptions::SBInitializerOptions() {
+  m_opaque_up.reset(new InitializerOptions());
+}
+
+void SBInitializerOptions::SetCaptureReproducer(bool b) {
+  m_opaque_up->reproducer_capture = b;
+}
+
+void SBInitializerOptions::SetReplayReproducer(bool b) {
+  m_opaque_up->reproducer_replay = b;
+}
+
+void SBInitializerOptions::SetReproducerPath(const char *path) {
+  m_opaque_up->reproducer_path = path;
+}
+
+InitializerOptions &SBInitializerOptions::ref() const {
+  return *(m_opaque_up.get());
+}

lldb/trunk/source/API/SystemInitializerFull.h

 /// not intended to be used externally, but is instead used
 /// internally by SBDebugger to initialize the system.
 //------------------------------------------------------------------
 class SystemInitializerFull : public SystemInitializerCommon {
 public:
   SystemInitializerFull();
   ~SystemInitializerFull() override;
 
-  void Initialize() override;
+  llvm::Error Initialize(const InitializerOptions &options) override;
   void Terminate() override;
 
 private:
   void InitializeSWIG();
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_API_SYSTEM_INITIALIZER_FULL_H

lldb/trunk/source/API/SystemInitializerFull.cpp

LLDBSWIGPython_GetDynamicSetting(void *module, const char *setting,
                                  const lldb::TargetSP &target_sp);
 
 #endif
 
 SystemInitializerFull::SystemInitializerFull() {}
 
 SystemInitializerFull::~SystemInitializerFull() {}
 
-void SystemInitializerFull::Initialize() {
-  SystemInitializerCommon::Initialize();
+llvm::Error
+SystemInitializerFull::Initialize(const InitializerOptions &options) {
+  if (auto e = SystemInitializerCommon::Initialize(options))
+    return e;
 
   ObjectFileELF::Initialize();
   ObjectFileMachO::Initialize();
   ObjectFilePECOFF::Initialize();
 
   ScriptInterpreterNone::Initialize();
 
 #ifndef LLDB_DISABLE_PYTHON
#endif
   // Scan for any system or user LLDB plug-ins
   PluginManager::Initialize();
 
   // The process settings need to know about installed plug-ins, so the
   // Settings must be initialized
   // AFTER PluginManager::Initialize is called.
 
   Debugger::SettingsInitialize();
+
+  return llvm::Error::success();
 }
 
 void SystemInitializerFull::InitializeSWIG() {
 #if !defined(LLDB_DISABLE_PYTHON)
   ScriptInterpreterPython::InitializeInterpreter(
       LLDBSwigPyInit, LLDBSwigPythonBreakpointCallbackFunction,
       LLDBSwigPythonWatchpointCallbackFunction, LLDBSwigPythonCallTypeScript,
       LLDBSwigPythonCreateSyntheticProvider, LLDBSwigPythonCreateCommandObject,

lldb/trunk/source/Commands/CommandObjectReproducer.cpp

 #include "lldb/Interpreter/CommandInterpreter.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;
-    }
-
-    if (auto e = m_interpreter.GetDebugger().SetReproducerCapture(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;
-    }
-
-    if (auto e = m_interpreter.GetDebugger().SetReproducerCapture(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;
 
bool DoExecute(Args &command, CommandReturnObject &result) override {
     result.GetOutputStream()
         << "Reproducer written to '" << r.GetReproducerPath() << "'\n";
 
     result.SetStatus(eReturnStatusSuccessFinishResult);
     return result.Succeeded();
   }
 };
 
-class CommandObjectReproducerReplay : public CommandObjectParsed {
+class CommandObjectReproducerStatus : public CommandObjectParsed {
 public:
-  CommandObjectReproducerReplay(CommandInterpreter &interpreter)
-      : CommandObjectParsed(interpreter, "reproducer replay",
-                            "Replay a reproducer.", nullptr) {
-    CommandArgumentEntry arg1;
-    CommandArgumentData path_arg;
+  CommandObjectReproducerStatus(CommandInterpreter &interpreter)
+      : CommandObjectParsed(interpreter, "reproducer status",
+                            "Show the current reproducer status.", nullptr) {}
 
-    // 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;
+  ~CommandObjectReproducerStatus() override = default;
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    if (command.empty()) {
-      result.AppendErrorWithFormat(
-          "'%s' takes a single argument: the reproducer path",
+    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()) {
+      result.GetOutputStream() << "Reproducer is in capture mode.\n";
+    } else if (auto generator = r.GetLoader()) {
+      result.GetOutputStream() << "Reproducer is in replay mode.\n";
+    } else {
 
-    const char *repro_path = command.GetArgumentAtIndex(0);
-    if (auto e = r.SetReplay(FileSpec(repro_path))) {
-      std::string error_str = llvm::toString(std::move(e));
-      result.AppendErrorWithFormat("%s", error_str.c_str());
-      return false;
+      result.GetOutputStream() << "Reproducer is off.\n";
     }
 
-    result.SetStatus(eReturnStatusSuccessFinishNoResult);
+    result.SetStatus(eReturnStatusSuccessFinishResult);
     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)));
+  LoadSubCommand("status", CommandObjectSP(
+                               new CommandObjectReproducerStatus(interpreter)));
 }
 
 CommandObjectReproducer::~CommandObjectReproducer() = default;

lldb/trunk/source/Core/Debugger.cpp

void Debugger::SetPrompt(llvm::StringRef p) {
   GetCommandInterpreter().UpdatePrompt(new_prompt);
 }
 
 llvm::StringRef Debugger::GetReproducerPath() const {
   auto &r = repro::Reproducer::Instance();
   return r.GetReproducerPath().GetCString();
 }
 
-llvm::Error Debugger::SetReproducerReplay(llvm::StringRef p) {
-  llvm::Optional<FileSpec> arg = llvm::None;
-
-  if (!p.empty())
-    arg = FileSpec(p);
-
-  return repro::Reproducer::Instance().SetReplay(arg);
-}
-
-llvm::Error Debugger::SetReproducerCapture(bool b) {
-  llvm::Optional<FileSpec> arg = llvm::None;
-
-  if (b)
-    arg = HostInfo::GetReproducerTempDir();
-
-  return repro::Reproducer::Instance().SetCapture(arg);
-}
-
 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);

lldb/trunk/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

lldb/trunk/source/Initialization/SystemInitializerCommon.cpp

 #include "Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.h"
 #include "Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.h"
 #include "Plugins/ObjectContainer/Universal-Mach-O/ObjectContainerUniversalMachO.h"
 #include "Plugins/Process/gdb-remote/ProcessGDBRemoteLog.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/Reproducer.h"
 #include "lldb/Utility/Timer.h"
 
 #if defined(__linux__) || defined(__FreeBSD__) || defined(__NetBSD__)
 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 #endif
 
 #if defined(_MSC_VER)
 #include "Plugins/Process/Windows/Common/ProcessWindowsLog.h"
 #include "lldb/Host/windows/windows.h"
 #endif
 
 #include "llvm/Support/TargetSelect.h"
 
 #include <string>
 
 using namespace lldb_private;
+using namespace lldb_private::repro;
 
 SystemInitializerCommon::SystemInitializerCommon() {}
 
 SystemInitializerCommon::~SystemInitializerCommon() {}
 
-void SystemInitializerCommon::Initialize() {
+llvm::Error
+SystemInitializerCommon::Initialize(const InitializerOptions &options) {
 #if defined(_MSC_VER)
   const char *disable_crash_dialog_var = getenv("LLDB_DISABLE_CRASH_DIALOG");
   if (disable_crash_dialog_var &&
       llvm::StringRef(disable_crash_dialog_var).equals_lower("true")) {
     // This will prevent Windows from displaying a dialog box requiring user
     // interaction when
     // LLDB crashes.  This is mostly useful when automating LLDB, for example
     // via the test
     // suite, so that a crash in LLDB does not prevent completion of the test
     // suite.
     ::SetErrorMode(GetErrorMode() | SEM_FAILCRITICALERRORS |
                    SEM_NOGPFAULTERRORBOX);
 
     _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
     _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
     _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
     _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
     _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
     _CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
   }
 #endif
 
+  ReproducerMode mode = ReproducerMode::Off;
+  if (options.reproducer_capture)
+    mode = ReproducerMode::Capture;
+  if (options.reproducer_replay)
+    mode = ReproducerMode::Replay;
+
+  if (auto e = Reproducer::Initialize(mode, FileSpec(options.reproducer_path)))
+    return e;
+
   FileSystem::Initialize();
   Log::Initialize();
   HostInfo::Initialize();
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
 
   process_gdb_remote::ProcessGDBRemoteLog::Initialize();
 
#endif
   ObjectContainerUniversalMachO::Initialize();
 
 #if defined(__linux__) || defined(__FreeBSD__) || defined(__NetBSD__)
   ProcessPOSIXLog::Initialize();
 #endif
 #if defined(_MSC_VER)
   ProcessWindowsLog::Initialize();
 #endif
+
+  return llvm::Error::success();
 }
 
 void SystemInitializerCommon::Terminate() {
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
   ObjectContainerBSDArchive::Terminate();
 
   EmulateInstructionARM::Terminate();
   EmulateInstructionMIPS::Terminate();
   EmulateInstructionMIPS64::Terminate();
 
   ObjectContainerUniversalMachO::Terminate();
 
 #if defined(_MSC_VER)
   ProcessWindowsLog::Terminate();
 #endif
 
   HostInfo::Terminate();
   Log::DisableAllLogChannels();
   FileSystem::Terminate();
+  Reproducer::Terminate();
 }

lldb/trunk/source/Initialization/SystemLifetimeManager.cpp

 SystemLifetimeManager::SystemLifetimeManager()
     : m_mutex(), m_initialized(false) {}
 
 SystemLifetimeManager::~SystemLifetimeManager() {
   assert(!m_initialized &&
          "SystemLifetimeManager destroyed without calling Terminate!");
 }
 
-void SystemLifetimeManager::Initialize(
+llvm::Error SystemLifetimeManager::Initialize(
     std::unique_ptr<SystemInitializer> initializer,
-    LoadPluginCallbackType plugin_callback) {
+    const InitializerOptions &options, LoadPluginCallbackType plugin_callback) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   if (!m_initialized) {
     assert(!m_initializer && "Attempting to call "
                              "SystemLifetimeManager::Initialize() when it is "
                              "already initialized");
     m_initialized = true;
     m_initializer = std::move(initializer);
 
-    m_initializer->Initialize();
+    if (auto e = m_initializer->Initialize(options))
+      return e;
+
     Debugger::Initialize(plugin_callback);
   }
+
+  return llvm::Error::success();
 }
 
 void SystemLifetimeManager::Terminate() {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
   if (m_initialized) {
     Debugger::Terminate();
     m_initializer->Terminate();
 
     m_initializer.reset();
     m_initialized = false;
   }
 }

lldb/trunk/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/Utility/LLDBAssert.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;
+Reproducer &Reproducer::Instance() { return *InstanceImpl(); }
+
+llvm::Error Reproducer::Initialize(ReproducerMode mode,
+                                   llvm::Optional<FileSpec> root) {
+  lldbassert(!InstanceImpl() && "Already initialized.");
+  InstanceImpl().emplace();
+
+  switch (mode) {
+  case ReproducerMode::Capture: {
+    if (!root) {
+      SmallString<128> repro_dir;
+      auto ec = sys::fs::createUniqueDirectory("reproducer", repro_dir);
+      if (ec)
+        return make_error<StringError>(
+            "unable to create unique reproducer directory", ec);
+      root.emplace(repro_dir);
+    } else {
+      auto ec = sys::fs::create_directories(root->GetPath());
+      if (ec)
+        return make_error<StringError>("unable to create reproducer directory",
+                                       ec);
+    }
+    return Instance().SetCapture(root);
+  } break;
+  case ReproducerMode::Replay:
+    return Instance().SetReplay(root);
+  case ReproducerMode::Off:
+    break;
+  };
+
+  return Error::success();
+}
+
+void Reproducer::Terminate() {
+  lldbassert(InstanceImpl() && "Already terminated.");
+  InstanceImpl().reset();
+}
+
+Optional<Reproducer> &Reproducer::InstanceImpl() {
+  static Optional<Reproducer> g_reproducer;
   return g_reproducer;
 }
 
 const Generator *Reproducer::GetGenerator() const {
   std::lock_guard<std::mutex> guard(m_mutex);
   if (m_generator)
     return &(*m_generator);
   return nullptr;

 llvm::Error Reproducer::SetCapture(llvm::Optional<FileSpec> root) {
   std::lock_guard<std::mutex> guard(m_mutex);
 
   if (root && m_loader)
     return make_error<StringError>(
         "cannot generate a reproducer when replay one",
         inconvertibleErrorCode());
 
-  if (root)
-    m_generator.emplace(*root);
-  else
+  if (!root) {
     m_generator.reset();
+    return Error::success();
+  }
 
+  m_generator.emplace(*root);
   return Error::success();
 }
 
 llvm::Error Reproducer::SetReplay(llvm::Optional<FileSpec> root) {
   std::lock_guard<std::mutex> guard(m_mutex);
 
   if (root && m_generator)
     return make_error<StringError>(
         "cannot replay a reproducer when generating one",
         inconvertibleErrorCode());
 
-  if (root) {
-    m_loader.emplace(*root);
-    if (auto e = m_loader->LoadIndex())
-      return e;
-  } else {
-    m_loader.reset();
-  }
+  if (!root) {
+    m_loader.reset();
+    return Error::success();
+  }
+
 
   return Error::success();
 }
 
 FileSpec Reproducer::GetReproducerPath() const {
   if (auto g = GetGenerator())
     return g->GetRoot();
   if (auto l = GetLoader())

 llvm::Error Loader::LoadIndex() {
   if (m_loaded)
     return llvm::Error::success();
 
   FileSpec index = m_root.CopyByAppendingPathComponent("index.yaml");
 
   auto error_or_file = MemoryBuffer::getFile(index.GetPath());
   if (auto err = error_or_file.getError())
-    return errorCodeToError(err);
+    return make_error<StringError>("unable to load reproducer index", err);
 
   std::vector<ProviderInfo> provider_info;
   yaml::Input yin((*error_or_file)->getBuffer());
   yin >> provider_info;
 
   if (auto err = yin.error())
-    return errorCodeToError(err);
+    return make_error<StringError>("unable to read reproducer index", err);
 
   for (auto &info : provider_info)
     m_provider_info[info.name] = info;
 
   m_loaded = true;
 
   return llvm::Error::success();
 }

lldb/trunk/tools/driver/Driver.cpp

if (auto *arg = args.getLastArg(OPT_script_language)) {
     auto arg_value = arg->getValue();
     m_option_data.m_script_lang = m_debugger.GetScriptingLanguage(arg_value);
   }
 
   if (args.hasArg(OPT_no_use_colors)) {
     m_option_data.m_debug_mode = true;
   }
 
-  if (auto *arg = args.getLastArg(OPT_reproducer)) {
-    auto arg_value = arg->getValue();
-    SBFileSpec file(arg_value);
-    if (file.Exists()) {
-      SBError repro_error = m_debugger.ReplayReproducer(arg_value);
-      if (repro_error.Fail())
-        return repro_error;
-    } else {
-      error.SetErrorStringWithFormat("file specified in --reproducer "
-                                     "(-z) option doesn't exist: '%s'",
-                                     arg_value);
-      return error;
-    }
-  }
-
   if (args.hasArg(OPT_no_use_colors)) {
     m_debugger.SetUseColor(false);
   }
 
   if (args.hasArg(OPT_source_quietly)) {
     m_option_data.m_source_quietly = true;
   }
 
if (input_args.hasArg(OPT_help)) {
     return 0;
   }
 
   for (auto *arg : input_args.filtered(OPT_UNKNOWN)) {
     WithColor::warning() << "ignoring unknown option: " << arg->getSpelling()
                          << '\n';
   }
 
-  SBDebugger::Initialize();
+  SBInitializerOptions options;
+
+  if (auto *arg = input_args.getLastArg(OPT_capture)) {
+    auto arg_value = arg->getValue();
+    options.SetReproducerPath(arg_value);
+    options.SetCaptureReproducer(true);
+  }
+
+  if (auto *arg = input_args.getLastArg(OPT_replay)) {
+    auto arg_value = arg->getValue();
+    options.SetReplayReproducer(true);
+    options.SetReproducerPath(arg_value);
+  }
+
+  SBError error = SBDebugger::Initialize(options);
+  if (error.Fail()) {
+    WithColor::error() << "initialization failed: " << error.GetCString()
+                       << '\n';
+    return 1;
+  }
+
   SBHostOS::ThreadCreated("<lldb.driver.main-thread>");
 
   signal(SIGINT, sigint_handler);
 #if !defined(_MSC_VER)
   signal(SIGPIPE, SIG_IGN);
   signal(SIGWINCH, sigwinch_handler);
   signal(SIGTSTP, sigtstp_handler);
   signal(SIGCONT, sigcont_handler);

lldb/trunk/tools/driver/Options.td

def: Separate<["-"], "a">,
   HelpText<"Alias for --arch">;
 
 def debug: F<"debug">,
   HelpText<"Tells the debugger to print out extra information for debugging itself.">;
 def: Flag<["-"], "d">,
   Alias<debug>,
   HelpText<"Alias for --debug">;
 
-def reproducer: Separate<["--", "-"], "reproducer">,
+def capture: Separate<["--", "-"], "capture">,
   MetaVarName<"<filename>">,
-  HelpText<"Tells the debugger to use the fullpath to <filename> as a reproducer.">;
-def: Separate<["-"], "z">,
-  Alias<file>,
-  HelpText<"Alias for --reproducer">;
+  HelpText<"Tells the debugger to capture a reproducer to <filename>.">;
+def replay: Separate<["--", "-"], "replay">,
+  MetaVarName<"<filename>">,
+  HelpText<"Tells the debugger to replay a reproducer from <filename>.">;
 
 def REM : R<["--"], "">;

lldb/trunk/tools/lldb-server/SystemInitializerLLGS.h

 //===-- SystemInitializerLLGS.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_SYSTEMINITIALIZERLLGS_H
 #define LLDB_SYSTEMINITIALIZERLLGS_H
 
+#include "lldb/Initialization/SystemInitializer.h"
 #include "lldb/Initialization/SystemInitializerCommon.h"
 
 class SystemInitializerLLGS : public lldb_private::SystemInitializerCommon {
 public:
-  void Initialize() override;
+  llvm::Error
+  Initialize(const lldb_private::InitializerOptions &options) override;
   void Terminate() override;
 };
 
 #endif // LLDB_SYSTEMINITIALIZERLLGS_H

lldb/trunk/tools/lldb-server/SystemInitializerLLGS.cpp

 using HostObjectFile = ObjectFilePECOFF;
 #else
 #include "Plugins/ObjectFile/ELF/ObjectFileELF.h"
 using HostObjectFile = ObjectFileELF;
 #endif
 
 using namespace lldb_private;
 
-void SystemInitializerLLGS::Initialize() {
-  SystemInitializerCommon::Initialize();
+llvm::Error
+SystemInitializerLLGS::Initialize(const InitializerOptions &options) {
+  if (auto e = SystemInitializerCommon::Initialize(options))
+    return e;
+
   HostObjectFile::Initialize();
+
+  return llvm::Error::success();
 }
 
 void SystemInitializerLLGS::Terminate() {
   HostObjectFile::Terminate();
   SystemInitializerCommon::Terminate();
 }

lldb/trunk/tools/lldb-server/lldb-server.cpp

static void display_usage(const char *progname) {
   exit(0);
 }
 
 // Forward declarations of subcommand main methods.
 int main_gdbserver(int argc, char *argv[]);
 int main_platform(int argc, char *argv[]);
 
 static void initialize() {
-  g_debugger_lifetime->Initialize(llvm::make_unique<SystemInitializerLLGS>(),
-                                  nullptr);
+  if (auto e = g_debugger_lifetime->Initialize(
+          llvm::make_unique<SystemInitializerLLGS>(), {}, nullptr))
+    llvm::consumeError(std::move(e));
 }
 
 static void terminate() { g_debugger_lifetime->Terminate(); }
 
 //----------------------------------------------------------------------
 // main
 //----------------------------------------------------------------------
 int main(int argc, char *argv[]) {

lldb/trunk/tools/lldb-test/SystemInitializerTest.h

 /// not intended to be used externally, but is instead used
 /// internally by SBDebugger to initialize the system.
 //------------------------------------------------------------------
 class SystemInitializerTest : public SystemInitializerCommon {
 public:
   SystemInitializerTest();
   ~SystemInitializerTest() override;
 
-  void Initialize() override;
+  llvm::Error Initialize(const InitializerOptions &options) override;
   void Terminate() override;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_API_SYSTEM_INITIALIZER_FULL_H

lldb/trunk/tools/lldb-test/SystemInitializerTest.cpp

 #include <string>
 
 using namespace lldb_private;
 
 SystemInitializerTest::SystemInitializerTest() {}
 
 SystemInitializerTest::~SystemInitializerTest() {}
 
-void SystemInitializerTest::Initialize() {
-  SystemInitializerCommon::Initialize();
+llvm::Error
+SystemInitializerTest::Initialize(const InitializerOptions &options) {
+  if (auto e = SystemInitializerCommon::Initialize(options))
+    return e;
 
   ObjectFileELF::Initialize();
   ObjectFileMachO::Initialize();
   ObjectFilePECOFF::Initialize();
 
   ScriptInterpreterNone::Initialize();
 
 
#endif
   // Scan for any system or user LLDB plug-ins
   PluginManager::Initialize();
 
   // The process settings need to know about installed plug-ins, so the Settings
   // must be initialized
   // AFTER PluginManager::Initialize is called.
 
   Debugger::SettingsInitialize();
+
+  return llvm::Error::success();
 }
 
 void SystemInitializerTest::Terminate() {
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
 
   Debugger::SettingsTerminate();
 

lldb/trunk/tools/lldb-test/lldb-test.cpp

int main(int argc, const char *argv[]) {
   StringRef ToolName = argv[0];
   sys::PrintStackTraceOnErrorSignal(ToolName);
   PrettyStackTraceProgram X(argc, argv);
   llvm_shutdown_obj Y;
 
   cl::ParseCommandLineOptions(argc, argv, "LLDB Testing Utility\n");
 
   SystemLifetimeManager DebuggerLifetime;
-  DebuggerLifetime.Initialize(llvm::make_unique<SystemInitializerTest>(),
-                              nullptr);
+  if (auto e = DebuggerLifetime.Initialize(
+          llvm::make_unique<SystemInitializerTest>(), {}, nullptr)) {
+    WithColor::error() << "initialization failed: " << toString(std::move(e))
+                       << '\n';
+    return 1;
+  }
+
   CleanUp TerminateDebugger([&] { DebuggerLifetime.Terminate(); });
 
   auto Dbg = lldb_private::Debugger::CreateInstance();
 
   if (!opts::Log.empty())
     Dbg->EnableLog("lldb", {"all"}, opts::Log, 0, errs());
 
   if (opts::BreakpointSubcommand)

lldb/trunk/unittests/Utility/ReproducerTest.cpp

public:
   DummyProvider(const FileSpec &directory) : Provider(directory) {
     m_info.name = "dummy";
     m_info.files.push_back("dummy.yaml");
   }
 
   static char ID;
 };
 
+class DummyReproducer : public Reproducer {
+public:
+  DummyReproducer() : Reproducer(){};
+
+  using Reproducer::SetCapture;
+  using Reproducer::SetReplay;
+};
+
 char DummyProvider::ID = 0;
 
 TEST(ReproducerTest, SetCapture) {
-  Reproducer reproducer;
+  DummyReproducer reproducer;
 
   // Initially both generator and loader are unset.
   EXPECT_EQ(nullptr, reproducer.GetGenerator());
   EXPECT_EQ(nullptr, reproducer.GetLoader());
 
   // Enable capture and check that means we have a generator.
   EXPECT_THAT_ERROR(reproducer.SetCapture(FileSpec("/bogus/path")),
                     Succeeded());
   EXPECT_NE(nullptr, reproducer.GetGenerator());
   EXPECT_EQ(FileSpec("/bogus/path"), reproducer.GetGenerator()->GetRoot());
   EXPECT_EQ(FileSpec("/bogus/path"), reproducer.GetReproducerPath());
 
   // Ensure that we cannot enable replay.
   EXPECT_THAT_ERROR(reproducer.SetReplay(FileSpec("/bogus/path")), Failed());
   EXPECT_EQ(nullptr, reproducer.GetLoader());
 
   // Ensure we can disable the generator again.
   EXPECT_THAT_ERROR(reproducer.SetCapture(llvm::None), Succeeded());
   EXPECT_EQ(nullptr, reproducer.GetGenerator());
   EXPECT_EQ(nullptr, reproducer.GetLoader());
 }
 
 TEST(ReproducerTest, SetReplay) {
-  Reproducer reproducer;
+  DummyReproducer reproducer;
 
   // Initially both generator and loader are unset.
   EXPECT_EQ(nullptr, reproducer.GetGenerator());
   EXPECT_EQ(nullptr, reproducer.GetLoader());
 
   // Expected to fail because we can't load the index.
   EXPECT_THAT_ERROR(reproducer.SetReplay(FileSpec("/bogus/path")), Failed());
   // However the loader should still be set, which we check here.
   EXPECT_NE(nullptr, reproducer.GetLoader());
 
   // Make sure the bogus path is correctly set.
   EXPECT_EQ(FileSpec("/bogus/path"), reproducer.GetLoader()->GetRoot());
   EXPECT_EQ(FileSpec("/bogus/path"), reproducer.GetReproducerPath());
 
   // Ensure that we cannot enable replay.
   EXPECT_THAT_ERROR(reproducer.SetCapture(FileSpec("/bogus/path")), Failed());
   EXPECT_EQ(nullptr, reproducer.GetGenerator());
 }
 
 TEST(GeneratorTest, Create) {
-  Reproducer reproducer;
+  DummyReproducer reproducer;
 
   EXPECT_THAT_ERROR(reproducer.SetCapture(FileSpec("/bogus/path")),
                     Succeeded());
   auto &generator = *reproducer.GetGenerator();
 
   auto *provider = generator.Create<DummyProvider>();
   EXPECT_NE(nullptr, provider);
   EXPECT_EQ(FileSpec("/bogus/path"), provider->GetRoot());
   EXPECT_EQ(std::string("dummy"), provider->GetInfo().name);
   EXPECT_EQ((size_t)1, provider->GetInfo().files.size());
   EXPECT_EQ(std::string("dummy.yaml"), provider->GetInfo().files.front());
 }
 
 TEST(GeneratorTest, Get) {
-  Reproducer reproducer;
+  DummyReproducer reproducer;
 
   EXPECT_THAT_ERROR(reproducer.SetCapture(FileSpec("/bogus/path")),
                     Succeeded());
   auto &generator = *reproducer.GetGenerator();
 
   auto *provider = generator.Create<DummyProvider>();
   EXPECT_NE(nullptr, provider);
 
   auto *provider_alt = generator.Get<DummyProvider>();
   EXPECT_EQ(provider, provider_alt);
 }
 
 TEST(GeneratorTest, GetOrCreate) {
-  Reproducer reproducer;
+  DummyReproducer reproducer;
 
   EXPECT_THAT_ERROR(reproducer.SetCapture(FileSpec("/bogus/path")),
                     Succeeded());
   auto &generator = *reproducer.GetGenerator();
 
   auto &provider = generator.GetOrCreate<DummyProvider>();
   EXPECT_EQ(FileSpec("/bogus/path"), provider.GetRoot());
   EXPECT_EQ(std::string("dummy"), provider.GetInfo().name);
   EXPECT_EQ((size_t)1, provider.GetInfo().files.size());
   EXPECT_EQ(std::string("dummy.yaml"), provider.GetInfo().files.front());
 
   auto &provider_alt = generator.GetOrCreate<DummyProvider>();
   EXPECT_EQ(&provider, &provider_alt);
 }