[Reproducers] Initialize reproducers before initializing the debugger.

[JDevlieghere]

Summary

As per the discussion on the mailing list (http://lists.llvm.org/pipermail/lldb-commits/Week-of-Mon-20190218/048007.html) and IRC.

[JDevlieghere]

lldb/include/lldb/API/SBDebugger.h

48

This should be safe, I don't know anyone relying on this and apparently the python .i file contained an incorrect return type (void).

[JDevlieghere]

lldb/source/API/SBReproducer.cpp

69

The SBError is a problem. We can create it after the initialization, but then we’d need a bogus repro::Record to make sure the api boundary is correctly registered. Let me know if you can think of an alternative.

[labath]

I think this looks mostly fine. See my comment about not using SB classes in the reproducer api. I still kind of like the idea of naming the reproducer class in some special way, to make it more obvious that it is not "just another" SB class, but I'm not sure if that would be just more confusing.

lldb/include/lldb/API/SBReproducer.h

18–20

So, in this new world, how are we expected to perform the replay? InitializeReplay(), followed by Replay() ? Could we fold those two calls into one? I don't see what meaningful work could the user do between those two calls, as all sb calls (including SBDebugger::Initialize) will now be recorded (right?).

lldb/source/API/SBDebugger.cpp

127

I think the usual way to do that is to just cast the result to void.

lldb/source/API/SBReproducer.cpp

69

Maybe this function should not return an SBError at all (just like it does not accept an SBFileSpec due to bootstrapping problems). You could just return a std::string, and have an empty string denote success. This would be consistent with the idea that the repro API is not a part of SB API, but rather something sitting slightly above (or at least, besides) it.

[JDevlieghere]

• Return a string instead of an SBError
• Make InitializeReplay perform the actual replay.

[JDevlieghere]

In D58410#1403630, @labath wrote:

I think this looks mostly fine. See my comment about not using SB classes in the reproducer api. I still kind of like the idea of naming the reproducer class in some special way, to make it more obvious that it is not "just another" SB class, but I'm not sure if that would be just more confusing.

I'm afraid it's going to be confusing. I'll add a comment to the SBReproducer class to point out that we cannot rely on any other SB* objects because of bootstrapping.

[JDevlieghere]

• Add comment to SBReproducer.h explaining we cannot use any SB objects in the interface or implementation.

[labath]

LGTM. I'd maybe rename InitializeReplay into Replay (i.e., do the merging the other way around), since the Initialize part makes me think the replay will not actually commence there.

I forgot that we don't return STL objects through the API. It's a shame we have to resort to the static std::string hack. Another option would be to ConstStringify the string, but as these are functions that are to be called just once, this should do too.

lldb/include/lldb/API/SBDebugger.h

 //===-- SBDebugger.h --------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #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 lldb::SBError InitializeWithErrorHandling();
 
   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);
 

lldb/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/include/lldb/API/SBError.h

public:
   int SetErrorStringWithFormat(const char *format, ...)
       __attribute__((format(printf, 2, 3)));
 
   bool IsValid() const;
 
   bool GetDescription(lldb::SBStream &description);
 
 protected:
+  friend class SBBreakpoint;
+  friend class SBBreakpointLocation;
+  friend class SBBreakpointName;
   friend class SBCommandReturnObject;
+  friend class SBCommunication;
   friend class SBData;
   friend class SBDebugger;
-  friend class SBCommunication;
   friend class SBHostOS;
   friend class SBPlatform;
   friend class SBProcess;
+  friend class SBReproducer;
   friend class SBStructuredData;
+  friend class SBTarget;
   friend class SBThread;
   friend class SBTrace;
-  friend class SBTarget;
   friend class SBValue;
   friend class SBWatchpoint;
-  friend class SBBreakpoint;
-  friend class SBBreakpointLocation;
-  friend class SBBreakpointName;
 
   lldb_private::Status *get();
 
   lldb_private::Status *operator->();
 
   const lldb_private::Status &operator*() const;
 
   lldb_private::Status &ref();

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

lldb/include/lldb/API/SBInitializerOptions.h

-//===-- SBInitializerOptions.h ----------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#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/include/lldb/API/SBReproducer.h

 //===-- SBReproducer.h ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_API_SBREPRODUCER_H
 #define LLDB_API_SBREPRODUCER_H
 
-#include "lldb/lldb-defines.h"
+#include "lldb/API/SBDefines.h"
 
 namespace lldb {
 
 class LLDB_API SBReproducer {
 public:
-  static bool Replay();
+  static const char *InitializeCapture(const char *path);
+  static const char *InitializeReplay(const char *path);
 };
 
 } // namespace lldb
 
 #endif

lldb/include/lldb/Initialization/SystemInitializer.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 llvm::Error Initialize(const InitializerOptions &options) = 0;
+  virtual llvm::Error Initialize() = 0;
   virtual void Terminate() = 0;
 };
 }
 
 #endif

lldb/include/lldb/Initialization/SystemInitializerCommon.h

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

lldb/include/lldb/Initialization/SystemLifetimeManager.h

 namespace lldb_private {
 
 class SystemLifetimeManager {
 public:
   SystemLifetimeManager();
   ~SystemLifetimeManager();
 
   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/include/lldb/Utility/Reproducer.h

 
 /// The reproducer enables clients to obtain access to the Generator and
 /// Loader.
 class Reproducer {
 public:
   static Reproducer &Instance();
   static llvm::Error Initialize(ReproducerMode mode,
                                 llvm::Optional<FileSpec> root);
+  static bool Initialized();
   static void Terminate();
 
   Reproducer() = default;
 
   Generator *GetGenerator();
   Loader *GetLoader();
 
   const Generator *GetGenerator() const;

lldb/lldb.xcodeproj/project.pbxproj

/* Begin PBXBuildFile section */
     4CF52AF8142829390051E832 /* SBFileSpecList.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4CF52AF7142829390051E832 /* SBFileSpecList.cpp */; };
     4CF52AF51428291E0051E832 /* SBFileSpecList.h in Headers */ = {isa = PBXBuildFile; fileRef = 4CF52AF41428291E0051E832 /* SBFileSpecList.h */; settings = {ATTRIBUTES = (Public, ); }; };
     2668032C116005E2008E1FE4 /* SBFrame.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 9A633FE7112DCE3C001A7E43 /* SBFrame.cpp */; };
     26680225115FD13D008E1FE4 /* SBFrame.h in Headers */ = {isa = PBXBuildFile; fileRef = 9A633FE8112DCE3C001A7E43 /* SBFrame.h */; settings = {ATTRIBUTES = (Public, ); }; };
     26DE205D1161901400A093E2 /* SBFunction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26DE205C1161901400A093E2 /* SBFunction.cpp */; };
     26DE205311618FAC00A093E2 /* SBFunction.h in Headers */ = {isa = PBXBuildFile; fileRef = 26DE205211618FAC00A093E2 /* SBFunction.h */; settings = {ATTRIBUTES = (Public, ); }; };
     9A3576AA116E9AC700E8ED2F /* SBHostOS.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 9A3576A9116E9AC700E8ED2F /* SBHostOS.cpp */; };
     9A3576A8116E9AB700E8ED2F /* SBHostOS.h in Headers */ = {isa = PBXBuildFile; fileRef = 9A3576A7116E9AB700E8ED2F /* SBHostOS.h */; settings = {ATTRIBUTES = (Public, ); }; };
-    AFB2F2F621B71AF30078DEF1 /* SBInitializerOptions.cpp in Sources */ = {isa = PBXBuildFile; fileRef = AFB2F2F421B71AE90078DEF1 /* SBInitializerOptions.cpp */; };
-    4C38996D21BA11CA002BAEF4 /* SBInitializerOptions.h in Headers */ = {isa = PBXBuildFile; fileRef = 4C38996C21BA11CA002BAEF4 /* SBInitializerOptions.h */; settings = {ATTRIBUTES = (Public, ); }; };
     9AC703AF117675410086C050 /* SBInstruction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 9AC703AE117675410086C050 /* SBInstruction.cpp */; };
     9AC7038E117674FB0086C050 /* SBInstruction.h in Headers */ = {isa = PBXBuildFile; fileRef = 9AC7038D117674EB0086C050 /* SBInstruction.h */; settings = {ATTRIBUTES = (Public, ); }; };
     9AC703B1117675490086C050 /* SBInstructionList.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 9AC703B0117675490086C050 /* SBInstructionList.cpp */; };
     9AC70390117675270086C050 /* SBInstructionList.h in Headers */ = {isa = PBXBuildFile; fileRef = 9AC7038F117675270086C050 /* SBInstructionList.h */; settings = {ATTRIBUTES = (Public, ); }; };
     964381701C8D6B8200023D59 /* SBLanguageRuntime.cpp in Sources */ = {isa = PBXBuildFile; fileRef = AF20F76C1AF18FC700751A6E /* SBLanguageRuntime.cpp */; };
     332CCB181AFF41620034D4C4 /* SBLanguageRuntime.h in Headers */ = {isa = PBXBuildFile; fileRef = 3392EBB71AFF402200858B9F /* SBLanguageRuntime.h */; settings = {ATTRIBUTES = (Public, ); }; };
     254FBB951A81AA7F00BD6378 /* SBLaunchInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 254FBB941A81AA7F00BD6378 /* SBLaunchInfo.cpp */; };
     254FBB971A81B03100BD6378 /* SBLaunchInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 254FBB961A81B03100BD6378 /* SBLaunchInfo.h */; settings = {ATTRIBUTES = (Public, ); }; };

     9A633FE8112DCE3C001A7E43 /* SBFrame.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SBFrame.h; path = include/lldb/API/SBFrame.h; sourceTree = "<group>"; };
     2611FEFE142D83060017FEA3 /* SBFrame.i */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c.preprocessed; path = SBFrame.i; sourceTree = "<group>"; };
     26DE205C1161901400A093E2 /* SBFunction.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SBFunction.cpp; path = source/API/SBFunction.cpp; sourceTree = "<group>"; };
     26DE205211618FAC00A093E2 /* SBFunction.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SBFunction.h; path = include/lldb/API/SBFunction.h; sourceTree = "<group>"; };
     2611FEFF142D83060017FEA3 /* SBFunction.i */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c.preprocessed; path = SBFunction.i; sourceTree = "<group>"; };
     9A3576A9116E9AC700E8ED2F /* SBHostOS.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SBHostOS.cpp; path = source/API/SBHostOS.cpp; sourceTree = "<group>"; };
     9A3576A7116E9AB700E8ED2F /* SBHostOS.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SBHostOS.h; path = include/lldb/API/SBHostOS.h; sourceTree = "<group>"; };
     2611FF00142D83060017FEA3 /* SBHostOS.i */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c.preprocessed; path = SBHostOS.i; sourceTree = "<group>"; };
-    AFB2F2F421B71AE90078DEF1 /* SBInitializerOptions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SBInitializerOptions.cpp; path = source/API/SBInitializerOptions.cpp; sourceTree = "<group>"; };
-    4C38996C21BA11CA002BAEF4 /* SBInitializerOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SBInitializerOptions.h; path = include/lldb/API/SBInitializerOptions.h; sourceTree = "<group>"; };
     9AC703AE117675410086C050 /* SBInstruction.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SBInstruction.cpp; path = source/API/SBInstruction.cpp; sourceTree = "<group>"; };
     9AC7038D117674EB0086C050 /* SBInstruction.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SBInstruction.h; path = include/lldb/API/SBInstruction.h; sourceTree = "<group>"; };
     2611FF02142D83060017FEA3 /* SBInstruction.i */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c.preprocessed; path = SBInstruction.i; sourceTree = "<group>"; };
     9AC703B0117675490086C050 /* SBInstructionList.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SBInstructionList.cpp; path = source/API/SBInstructionList.cpp; sourceTree = "<group>"; };
     9AC7038F117675270086C050 /* SBInstructionList.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SBInstructionList.h; path = include/lldb/API/SBInstructionList.h; sourceTree = "<group>"; };
     2611FF03142D83060017FEA3 /* SBInstructionList.i */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c.preprocessed; path = SBInstructionList.i; sourceTree = "<group>"; };
     AF20F76C1AF18FC700751A6E /* SBLanguageRuntime.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SBLanguageRuntime.cpp; path = source/API/SBLanguageRuntime.cpp; sourceTree = "<group>"; };
     3392EBB71AFF402200858B9F /* SBLanguageRuntime.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SBLanguageRuntime.h; path = include/lldb/API/SBLanguageRuntime.h; sourceTree = "<group>"; };
262D3190111B4341004E6F88 /* API */ = {
         4CF52AF41428291E0051E832 /* SBFileSpecList.h */,
         4CF52AF7142829390051E832 /* SBFileSpecList.cpp */,
         9A633FE8112DCE3C001A7E43 /* SBFrame.h */,
         9A633FE7112DCE3C001A7E43 /* SBFrame.cpp */,
         26DE205211618FAC00A093E2 /* SBFunction.h */,
         26DE205C1161901400A093E2 /* SBFunction.cpp */,
         9A3576A7116E9AB700E8ED2F /* SBHostOS.h */,
         9A3576A9116E9AC700E8ED2F /* SBHostOS.cpp */,
-        AFB2F2F421B71AE90078DEF1 /* SBInitializerOptions.cpp */,
-        4C38996C21BA11CA002BAEF4 /* SBInitializerOptions.h */,
         9AC7038D117674EB0086C050 /* SBInstruction.h */,
         9AC703AE117675410086C050 /* SBInstruction.cpp */,
         9AC7038F117675270086C050 /* SBInstructionList.h */,
         9AC703B0117675490086C050 /* SBInstructionList.cpp */,
         3392EBB71AFF402200858B9F /* SBLanguageRuntime.h */,
         AF20F76C1AF18FC700751A6E /* SBLanguageRuntime.cpp */,
         254FBB961A81B03100BD6378 /* SBLaunchInfo.h */,
         254FBB941A81AA7F00BD6378 /* SBLaunchInfo.cpp */,
26680202115FD0ED008E1FE4 /* Headers */ = {
         23DCBEA31D63E71F0084C36B /* SBStructuredData.h in Headers */,
         26DE204111618AB900A093E2 /* SBSymbolContext.h in Headers */,
         268F9D53123AA15200B91E9B /* SBSymbolContextList.h in Headers */,
         2668022C115FD13D008E1FE4 /* SBTarget.h in Headers */,
         2668022E115FD13D008E1FE4 /* SBThread.h in Headers */,
         4C56543519D2297A002E9C44 /* SBThreadPlan.h in Headers */,
         263C493A178B50CF0070F12D /* SBModuleSpec.h in Headers */,
         2617447A11685869005ADD65 /* SBType.h in Headers */,
-        4C38996D21BA11CA002BAEF4 /* SBInitializerOptions.h in Headers */,
         9475C18914E5EA08001BFC6D /* SBTypeCategory.h in Headers */,
         941BCC7F14E48C4000BB969C /* SBTypeFilter.h in Headers */,
         941BCC8014E48C4000BB969C /* SBTypeFormat.h in Headers */,
         9475C18F14E5F858001BFC6D /* SBTypeNameSpecifier.h in Headers */,
         941BCC8114E48C4000BB969C /* SBTypeSummary.h in Headers */,
         9A36D24E1EB3BE7F00AAD9EA /* SBTraceOptions.h in Headers */,
         23059A121958B3B2007B8189 /* SBUnixSignals.h in Headers */,
         941BCC8214E48C4000BB969C /* SBTypeSynthetic.h in Headers */,
26680204115FD0ED008E1FE4 /* Sources */ = {
         26680331116005E9008E1FE4 /* SBCommunication.cpp in Sources */,
         9A1E595D1EB2B141002206A5 /* SBTraceOptions.cpp in Sources */,
         26680332116005EA008E1FE4 /* SBCommandReturnObject.cpp in Sources */,
         26680333116005EC008E1FE4 /* SBCommandInterpreter.cpp in Sources */,
         26680335116005EE008E1FE4 /* SBBroadcaster.cpp in Sources */,
         26680336116005EF008E1FE4 /* SBBreakpointLocation.cpp in Sources */,
         26680337116005F1008E1FE4 /* SBBreakpoint.cpp in Sources */,
         26DE204511618ADA00A093E2 /* SBAddress.cpp in Sources */,
-        AFB2F2F621B71AF30078DEF1 /* SBInitializerOptions.cpp in Sources */,
         26DE204711618AED00A093E2 /* SBSymbolContext.cpp in Sources */,
         26DE204D11618E7A00A093E2 /* SBModule.cpp in Sources */,
         26DE205D1161901400A093E2 /* SBFunction.cpp in Sources */,
         26DE205F1161901B00A093E2 /* SBCompileUnit.cpp in Sources */,
         AF0EBBE9185940FB0059E52F /* SBQueueItem.cpp in Sources */,
         AF0EBBE8185940FB0059E52F /* SBQueue.cpp in Sources */,
         964381701C8D6B8200023D59 /* SBLanguageRuntime.cpp in Sources */,
         26DE20611161902700A093E2 /* SBBlock.cpp in Sources */,

lldb/scripts/interface/SBDebugger.i

 ") SBDebugger;
 class SBDebugger
 {
 public:
 
     static void
     Initialize();
 
-    static void
-    Initialize(lldb::SBInitializerOptions& options);
+    static SBError
+    InitializeWithErrorHandling();
 
     static void
     Terminate();
 
     static lldb::SBDebugger
     Create();
 
     static lldb::SBDebugger

lldb/scripts/interface/SBInitializerOptions.i

-//===-- SWIG Interface for SBInitializerOptions -----------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-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/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/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/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);
+  SBError ignored = SBDebugger::InitializeWithErrorHandling();
 }
 
-lldb::SBError SBDebugger::Initialize(SBInitializerOptions &options) {
+lldb::SBError SBDebugger::InitializeWithErrorHandling() {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)
     log->Printf("SBDebugger::Initialize ()");
 
   SBError error;
   if (auto e = g_debugger_lifetime->Initialize(
-          llvm::make_unique<SystemInitializerFull>(), *options.m_opaque_up,
-          LoadPlugin)) {
+          llvm::make_unique<SystemInitializerFull>(), LoadPlugin)) {
     error.SetError(Status(std::move(e)));
   }
   return error;
 }
 
 void SBDebugger::Terminate() { g_debugger_lifetime->Terminate(); }
 
 void SBDebugger::Clear() {

lldb/source/API/SBInitializerOptions.cpp

-//===-- SBInitializerOptions.cpp --------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include "lldb/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/source/API/SBReproducer.cpp

 #include "lldb/Host/FileSystem.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::repro;
 
 SBRegistry::SBRegistry() {}
 
-bool SBReproducer::Replay() {
+const char *SBReproducer::InitializeCapture(const char *path) {
+  static std::string error;
+  if (auto e =
+          Reproducer::Initialize(ReproducerMode::Capture, FileSpec(path))) {
+    error = llvm::toString(std::move(e));
+    return error.c_str();
+  }
+  return nullptr;
+}
+
+const char *SBReproducer::InitializeReplay(const char *path) {
+  static std::string error;
+  if (auto e = Reproducer::Initialize(ReproducerMode::Replay, FileSpec(path))) {
+    error = llvm::toString(std::move(e));
+    return error.c_str();
+  }
+
   repro::Loader *loader = repro::Reproducer::Instance().GetLoader();
-  if (!loader)
-    return false;
+  if (!loader) {
+    error = "unable to get replay loader.";
+    return error.c_str();
+  }
 
   FileSpec file = loader->GetFile<SBInfo>();
-  if (!file)
-    return false;
+  if (!file) {
+    error = "unable to get replay data from reproducer.";
+    return error.c_str();
+  }
 
   SBRegistry registry;
   registry.Replay(file);
 
-  return true;
+  return nullptr;
 }
 
 char lldb_private::repro::SBProvider::ID = 0;
 const char *SBInfo::name = "sbapi";
 const char *SBInfo::file = "sbapi.bin";

lldb/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;
 
-  llvm::Error Initialize(const InitializerOptions &options) override;
+  llvm::Error Initialize() override;
   void Terminate() override;
 
 private:
   void InitializeSWIG();
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_API_SYSTEM_INITIALIZER_FULL_H

lldb/source/API/SystemInitializerFull.cpp

LLDBSWIGPython_GetDynamicSetting(void *module, const char *setting,
                                  const lldb::TargetSP &target_sp);
 
 #endif
 
 SystemInitializerFull::SystemInitializerFull() {}
 
 SystemInitializerFull::~SystemInitializerFull() {}
 
-llvm::Error
-SystemInitializerFull::Initialize(const InitializerOptions &options) {
-  if (auto e = SystemInitializerCommon::Initialize(options))
+llvm::Error SystemInitializerFull::Initialize() {
+  if (auto e = SystemInitializerCommon::Initialize())
     return e;
 
   breakpad::ObjectFileBreakpad::Initialize();
   ObjectFileELF::Initialize();
   ObjectFileMachO::Initialize();
   ObjectFilePECOFF::Initialize();
 
   ScriptInterpreterNone::Initialize();

lldb/source/Initialization/SystemInitializerCommon.cpp

 
 using namespace lldb_private;
 using namespace lldb_private::repro;
 
 SystemInitializerCommon::SystemInitializerCommon() {}
 
 SystemInitializerCommon::~SystemInitializerCommon() {}
 
-llvm::Error
-SystemInitializerCommon::Initialize(const InitializerOptions &options) {
+llvm::Error SystemInitializerCommon::Initialize() {
 #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
 
-  // Initialize the reproducer.
-  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)))
+  // If the reproducer wasn't initialized before, we can safely assume it's
+  // off.
+  if (!Reproducer::Initialized()) {
+    if (auto e = Reproducer::Initialize(ReproducerMode::Off, llvm::None))
       return e;
+  }
 
   // Initialize the file system.
   auto &r = repro::Reproducer::Instance();
   if (repro::Loader *loader = r.GetLoader()) {
     FileSpec vfs_mapping = loader->GetFile<FileInfo>();
     if (vfs_mapping) {
       if (llvm::Error e = FileSystem::Initialize(vfs_mapping))
         return e;

lldb/source/Initialization/SystemLifetimeManager.cpp

 
 SystemLifetimeManager::~SystemLifetimeManager() {
   assert(!m_initialized &&
          "SystemLifetimeManager destroyed without calling Terminate!");
 }
 
 llvm::Error SystemLifetimeManager::Initialize(
     std::unique_ptr<SystemInitializer> initializer,
-    const InitializerOptions &options, LoadPluginCallbackType plugin_callback) {
+    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);
 
-    if (auto e = m_initializer->Initialize(options))
+    if (auto e = m_initializer->Initialize())
       return e;
 
     Debugger::Initialize(plugin_callback);
   }
 
   return llvm::Error::success();
 }
 

lldb/source/Utility/Reproducer.cpp

case ReproducerMode::Replay:
     return Instance().SetReplay(root);
   case ReproducerMode::Off:
     break;
   };
 
   return Error::success();
 }
 
+bool Reproducer::Initialized() { return InstanceImpl().operator bool(); }
+
 void Reproducer::Terminate() {
   lldbassert(InstanceImpl() && "Already terminated.");
   InstanceImpl().reset();
 }
 
 Optional<Reproducer> &Reproducer::InstanceImpl() {
   static Optional<Reproducer> g_reproducer;
   return g_reproducer;

lldb/tools/driver/Driver.cpp

 //===-- Driver.cpp ----------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Driver.h"
 
 #include "lldb/API/SBCommandInterpreter.h"
 #include "lldb/API/SBCommandReturnObject.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBHostOS.h"
 #include "lldb/API/SBLanguageRuntime.h"
+#include "lldb/API/SBReproducer.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/PrettyStackTrace.h"
if (input_args.hasArg(OPT_help)) {
     return 0;
   }
 
   for (auto *arg : input_args.filtered(OPT_UNKNOWN)) {
     WithColor::warning() << "ignoring unknown option: " << arg->getSpelling()
                          << '\n';
   }
 
-  SBInitializerOptions options;
   if (auto *arg = input_args.getLastArg(OPT_capture)) {
     auto arg_value = arg->getValue();
-    options.SetReproducerPath(arg_value);
-    options.SetCaptureReproducer(true);
+    const char *error = SBReproducer::InitializeCapture(arg_value);
+    if (error) {
+      WithColor::error() << "reproducer capture failed: " << error << '\n';
+      return 1;
+    }
   }
 
   if (auto *arg = input_args.getLastArg(OPT_replay)) {
     auto arg_value = arg->getValue();
-    options.SetReplayReproducer(true);
-    options.SetReproducerPath(arg_value);
+    const char *error = SBReproducer::InitializeReplay(arg_value);
+    if (error) {
+      WithColor::error() << "reproducer replay failed: " << error << '\n';
+      return 1;
+    }
   }
 
-  SBError error = SBDebugger::Initialize(options);
+  SBError error = SBDebugger::InitializeWithErrorHandling();
   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/tools/lldb-server/SystemInitializerLLGS.h

 //===-- SystemInitializerLLGS.h ---------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #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:
-  llvm::Error
-  Initialize(const lldb_private::InitializerOptions &options) override;
+  llvm::Error Initialize() override;
   void Terminate() override;
 };
 
 #endif // LLDB_SYSTEMINITIALIZERLLGS_H

lldb/tools/lldb-server/SystemInitializerLLGS.cpp

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

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

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

lldb/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;
 
-  llvm::Error Initialize(const InitializerOptions &options) override;
+  llvm::Error Initialize() override;
   void Terminate() override;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_API_SYSTEM_INITIALIZER_FULL_H

lldb/tools/lldb-test/SystemInitializerTest.cpp

 #include <string>
 
 using namespace lldb_private;
 
 SystemInitializerTest::SystemInitializerTest() {}
 
 SystemInitializerTest::~SystemInitializerTest() {}
 
-llvm::Error
-SystemInitializerTest::Initialize(const InitializerOptions &options) {
-  if (auto e = SystemInitializerCommon::Initialize(options))
+llvm::Error SystemInitializerTest::Initialize() {
+  if (auto e = SystemInitializerCommon::Initialize())
     return e;
 
   breakpad::ObjectFileBreakpad::Initialize();
   ObjectFileELF::Initialize();
   ObjectFileMachO::Initialize();
   ObjectFilePECOFF::Initialize();
 
   ScriptInterpreterNone::Initialize();

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

int main(int argc, const char *argv[]) {
   sys::PrintStackTraceOnErrorSignal(ToolName);
   PrettyStackTraceProgram X(argc, argv);
   llvm_shutdown_obj Y;
 
   cl::ParseCommandLineOptions(argc, argv, "LLDB Testing Utility\n");
 
   SystemLifetimeManager DebuggerLifetime;
   if (auto e = DebuggerLifetime.Initialize(
-          llvm::make_unique<SystemInitializerTest>(), {}, nullptr)) {
+          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();