Install an crash handler showing a stacktrace and useful information. (#890)

Author: vgvassilev

lib/CppInterOp/CppInterOp.cpp

@@ -64,6 +64,8 @@
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/Process.h"
+#include "llvm/Support/Signals.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/TargetParser/Host.h"
@@ -79,6 +81,7 @@
 #include <iterator>
 #include <map>
 #include <memory>
+#include <mutex>
 #include <set>
 #include <sstream>
 #include <stack>
@@ -163,24 +166,67 @@ struct InterpreterInfo {
   InterpreterInfo& operator=(const InterpreterInfo&) = delete;
 };
 
+static void DefaultProcessCrashHandler(void*);
 // Function-static storage for interpreters
 static std::deque<InterpreterInfo>& GetInterpreters() {
+  // static int FakeArgc = 1;
+  // static const std::string VersionStr = GetVersion();
+  // static const char* ArgvBuffer[] = {VersionStr.c_str(), nullptr};
+  // static const char** FakeArgv = ArgvBuffer;
+  // static llvm::InitLLVM X(FakeArgc, FakeArgv);
+  // Cannot be a llvm::ManagedStatic because X will call shutdown which will
+  // trigger destruction on llvm::ManagedStatics and the destruction of the
+  // InterpreterInfos require to have llvm around.
+  // FIXME: Currently we never call llvm::llvm_shutdown and sInterpreters leaks.
   static llvm::ManagedStatic<std::deque<InterpreterInfo>> sInterpreters;
-  static bool ProcessInitialized = false;
+  static std::once_flag ProcessInitialized;
+  std::call_once(ProcessInitialized, []() {
+    llvm::sys::PrintStackTraceOnErrorSignal("CppInterOp");
 
-  if (!ProcessInitialized) {
     // Initialize all targets (required for device offloading)
     llvm::InitializeAllTargetInfos();
     llvm::InitializeAllTargets();
     llvm::InitializeAllTargetMCs();
     llvm::InitializeAllAsmParsers();
     llvm::InitializeAllAsmPrinters();
-    ProcessInitialized = true;
-  }
+
+    llvm::sys::AddSignalHandler(DefaultProcessCrashHandler, /*Cookie=*/nullptr);
+    // std::atexit(llvm::llvm_shutdown);
+  });
 
   return *sInterpreters;
 }
 
+// Global crash handler for the entire process
+static void DefaultProcessCrashHandler(void*) {
+  // Access the static deque via the getter
+  std::deque<InterpreterInfo>& Interps = GetInterpreters();
+
+  llvm::errs() << "\n**************************************************\n";
+  llvm::errs() << "  CppInterOp CRASH DETECTED\n";
+
+  if (!Interps.empty()) {
+    llvm::errs() << "  Active Interpreters:\n";
+    for (const auto& Info : Interps) {
+      if (Info.Interpreter)
+        llvm::errs() << "    - " << Info.Interpreter << "\n";
+    }
+  }
+
+  llvm::errs() << "**************************************************\n";
+  llvm::errs().flush();
+
+  // Print backtrace (includes JIT symbols if registered)
+  llvm::sys::PrintStackTrace(llvm::errs());
+
+  llvm::errs() << "**************************************************\n";
+  llvm::errs().flush();
+
+  // The process must actually terminate for EXPECT_DEATH to pass.
+  // We use _exit to avoid calling atexit() handlers which might be corrupted.
+  llvm::sys::Process::Exit(/*RetCode=*/1, /*NoCleanup=*/false);
+}
+
 static void RegisterInterpreter(compat::Interpreter* I, bool Owned) {
   std::deque<InterpreterInfo>& Interps = GetInterpreters();
   Interps.emplace_back(I, Owned);

unittests/CppInterOp/InterpreterTest.cpp

@@ -25,6 +25,7 @@
 #include "gtest/gtest.h"
 
 #include <algorithm>
+#include <csignal>
 
 using ::testing::StartsWith;
 
@@ -108,7 +109,7 @@ TYPED_TEST(CPPINTEROP_TEST_MODE, Interpreter_DeleteInterpreter) {
 
   EXPECT_EQ(I3, Cpp::GetInterpreter()) << "I3 is not active";
 
-  EXPECT_TRUE(Cpp::DeleteInterpreter(nullptr));
+  EXPECT_TRUE(Cpp::DeleteInterpreter(/*I=*/nullptr));
   EXPECT_EQ(I2, Cpp::GetInterpreter());
 
   auto* I4 = reinterpret_cast<void*>(static_cast<std::uintptr_t>(~0U));
@@ -456,3 +457,54 @@ TYPED_TEST(CPPINTEROP_TEST_MODE, Interpreter_ExternalInterpreter) {
   delete ExtInterp;
 #endif
 }
+
+// Verify the basic crash banner and Active Interpreter reporting
+#ifdef GTEST_HAS_DEATH_TEST
+TYPED_TEST(CPPINTEROP_TEST_MODE, SignalHandler_BasicBanner) {
+  // Ensure a clean registry for each JIT configuration
+
+  // FIXME: Uncomment after resolving compiler-research/CppInterOp#887
+
+  // while (Cpp::GetInterpreter())
+  //   Cpp::DeleteInterpreter(/*I=*/nullptr);
+
+  // EXPECT_FALSE(Cpp::GetInterpreter()) << "Failed to delete all interpreters";
+
+  // // Create an interpreter (this calls RegisterInterpreter internally)
+  // TInterp_t I = TestFixture::CreateInterpreter();
+  // ASSERT_NE(I, nullptr);
+
+  // We expect the banner to appear in stderr when the process dies
+  std::string ExpectedMsg = "CppInterOp CRASH DETECTED";
+#ifdef _WIN32
+  // FIXME: Windows says 'Actual msg:' without maybe capturing the message.
+  ExpectedMsg = "";
+#endif //_WIN32
+
+  EXPECT_DEATH(
+      {
+        // Trigger a synchronous signal
+        raise(SIGABRT);
+      },
+      ExpectedMsg);
+}
+#endif // GTEST_HAS_DEATH_TEST
+
+// Verify that the handler correctly lists multiple interpreters
+#ifdef GTEST_HAS_DEATH_TEST
+TYPED_TEST(CPPINTEROP_TEST_MODE, SignalHandler_MultipleInterpreters) {
+  ASSERT_NE(TestFixture::CreateInterpreter(), nullptr);
+  ASSERT_NE(TestFixture::CreateInterpreter(), nullptr);
+
+  // The handler iterates through the deque and prints the pointers
+
+  // We check for the "Active Interpreters:" header and the list format
+  std::string ExpectedMsg = "Active Interpreters:.*- 0x";
+#ifdef _WIN32
+  // FIXME: Windows says 'Actual msg:' without maybe capturing the message.
+  ExpectedMsg = "";
+#endif //_WIN32
+
+  EXPECT_DEATH({ raise(SIGSEGV); }, ExpectedMsg);
+}
+#endif // GTEST_HAS_DEATH_TEST