[lldb] Avoid confusing crashes during reproducer replay when initialization failed

[JDevlieghere]

Summary

During active replay, the ::Initialize call is replayed like any other SB API
call and the return value is ignored. Since we can't intercept this, we
terminate here before the uninitialized debugger inevitably crashes.

[JDevlieghere]

clang-format

[labath]

I wonder if there's a way to add some consistency checks into the (active) replay machinery. Like, maybe we could, for each function that returns an SBError, record a flag saying whether that error was in a success state or not. Then if this flag differs during replay, we know that we have started to diverge and can stop replaying (or at least give a very loud warning about it).

lldb/source/API/SystemInitializerFull.cpp

45

Print the error that has happened? maybe via report_fatal_error ?

[JDevlieghere]

In D90987#2381853, @labath wrote:

I wonder if there's a way to add some consistency checks into the (active) replay machinery. Like, maybe we could, for each function that returns an SBError, record a flag saying whether that error was in a success state or not. Then if this flag differs during replay, we know that we have started to diverge and can stop replaying (or at least give a very loud warning about it).

On the one hand I like the idea of detecting divergence early, but on the other hand I don't like special-casing something for SBError. There's a bunch of function that return a boolean and some that got error handling after the fact through and overload with an in-out parameter. A more generic approach could be a way to checkpoint the "object registry" an give (some of) the SB classes a private method that returns a "hash" (whatever that means for the reproducers, for an SBError that could be success or not, but for a target or a process it could be whether it's connected) and then have the reproducers periodically compare the state of the registry against that in the reproducer.

[labath]

In D90987#2383141, @JDevlieghere wrote:

In D90987#2381853, @labath wrote:

I wonder if there's a way to add some consistency checks into the (active) replay machinery. Like, maybe we could, for each function that returns an SBError, record a flag saying whether that error was in a success state or not. Then if this flag differs during replay, we know that we have started to diverge and can stop replaying (or at least give a very loud warning about it).

On the one hand I like the idea of detecting divergence early, but on the other hand I don't like special-casing something for SBError. There's a bunch of function that return a boolean and some that got error handling after the fact through and overload with an in-out parameter. A more generic approach could be a way to checkpoint the "object registry" an give (some of) the SB classes a private method that returns a "hash" (whatever that means for the reproducers, for an SBError that could be success or not, but for a target or a process it could be whether it's connected) and then have the reproducers periodically compare the state of the registry against that in the reproducer.

I like that idea.

lldb/source/API/SystemInitializerFull.cpp

45

Btw, there's a new report_fatal_error overload taking an llvm::Error -- I meant to use that one :)

[JDevlieghere]

lldb/source/API/SystemInitializerFull.cpp

45

😍

lldb/source/API/SystemInitializerFull.cpp

 #include "lldb/API/SBCommandInterpreter.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Host/Config.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Initialization/SystemInitializerCommon.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Target/ProcessTrace.h"
+#include "lldb/Utility/Reproducer.h"
 #include "lldb/Utility/Timer.h"
 #include "llvm/Support/TargetSelect.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wglobal-constructors"
 #include "llvm/ExecutionEngine/MCJIT.h"
 #pragma clang diagnostic pop
 
 #include <string>
 
 #define LLDB_PLUGIN(p) LLDB_PLUGIN_DECLARE(p)
 #include "Plugins/Plugins.def"
 
 using namespace lldb_private;
 
 SystemInitializerFull::SystemInitializerFull() = default;
 SystemInitializerFull::~SystemInitializerFull() = default;
 
 llvm::Error SystemInitializerFull::Initialize() {
-  if (auto e = SystemInitializerCommon::Initialize())
-    return e;
+  llvm::Error error = SystemInitializerCommon::Initialize();
+  if (error) {
+    // During active replay, the ::Initialize call is replayed like any other
+    // SB API call and the return value is ignored. Since we can't intercept
+    // this, we terminate here before the uninitialized debugger inevitably
+    // crashes.
+    if (repro::Reproducer::Instance().IsReplaying())
+      llvm::report_fatal_error("system initialization failed");
+    return error;
+  }
 
   // Initialize LLVM and Clang
   llvm::InitializeAllTargets();
   llvm::InitializeAllAsmPrinters();
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllDisassemblers();
 
 #define LLDB_PLUGIN(p) LLDB_PLUGIN_INITIALIZE(p);