1 files changed, 115 insertions, 0 deletions

diff --git a/src/zencore/testing.cpp b/src/zencore/testing.cpp
index 089e376bb..d7eb3b17d 100644
--- a/src/zencore/testing.cpp
+++ b/src/zencore/testing.cpp
@@ -11,17 +11,131 @@
 
 #if ZEN_WITH_TESTS
 
+#	include <zencore/callstack.h>
+
 #	include <chrono>
 #	include <clocale>
+#	include <csignal>
 #	include <cstdlib>
 #	include <cstdio>
 #	include <string>
 #	include <vector>
 
+#	if ZEN_PLATFORM_LINUX || ZEN_PLATFORM_MAC
+#		include <execinfo.h>
+#		include <unistd.h>
+#	endif
+
 namespace zen::testing {
 
 using namespace std::literals;
 
+static void
+PrintCrashCallstack([[maybe_unused]] const char* SignalName)
+{
+#	if ZEN_PLATFORM_LINUX || ZEN_PLATFORM_MAC
+	// Use write() + backtrace_symbols_fd() which are async-signal-safe
+	write(STDERR_FILENO, "\n*** Caught ", 12);
+	write(STDERR_FILENO, SignalName, strlen(SignalName));
+	write(STDERR_FILENO, " — callstack:\n", 15);
+
+	void* Frames[64];
+	int	  FrameCount = backtrace(Frames, 64);
+	backtrace_symbols_fd(Frames, FrameCount, STDERR_FILENO);
+#	elif ZEN_PLATFORM_WINDOWS
+	// On Windows we're called from SEH, not a signal handler, so heap/locks are safe
+	void*	 Addresses[64];
+	uint32_t FrameCount = GetCallstack(2, 64, Addresses);
+	if (FrameCount > 0)
+	{
+		std::vector<std::string> Symbols = GetFrameSymbols(FrameCount, Addresses);
+		fprintf(stderr, "\n*** Caught %s - callstack:\n", SignalName);
+		for (uint32_t i = 0; i < FrameCount; ++i)
+		{
+			fprintf(stderr, "  %2u: %s\n", i, Symbols[i].c_str());
+		}
+	}
+#	endif
+}
+
+#	if ZEN_PLATFORM_LINUX || ZEN_PLATFORM_MAC
+
+static void
+CrashSignalHandler(int Signal)
+{
+	const char* SignalName = "Unknown signal";
+	switch (Signal)
+	{
+		case SIGSEGV:
+			SignalName = "SIGSEGV";
+			break;
+		case SIGABRT:
+			SignalName = "SIGABRT";
+			break;
+		case SIGFPE:
+			SignalName = "SIGFPE";
+			break;
+		case SIGBUS:
+			SignalName = "SIGBUS";
+			break;
+		case SIGILL:
+			SignalName = "SIGILL";
+			break;
+	}
+
+	PrintCrashCallstack(SignalName);
+
+	// Re-raise with default handler so the process terminates normally
+	signal(Signal, SIG_DFL);
+	raise(Signal);
+}
+
+#	endif	// ZEN_PLATFORM_LINUX || ZEN_PLATFORM_MAC
+
+#	if ZEN_PLATFORM_WINDOWS
+
+static LONG CALLBACK
+CrashVectoredHandler(PEXCEPTION_POINTERS ExceptionInfo)
+{
+	// Only handle fatal exceptions, not first-chance exceptions used for normal control flow
+	switch (ExceptionInfo->ExceptionRecord->ExceptionCode)
+	{
+		case EXCEPTION_ACCESS_VIOLATION:
+			PrintCrashCallstack("EXCEPTION_ACCESS_VIOLATION");
+			break;
+		case EXCEPTION_STACK_OVERFLOW:
+			PrintCrashCallstack("EXCEPTION_STACK_OVERFLOW");
+			break;
+		case EXCEPTION_ILLEGAL_INSTRUCTION:
+			PrintCrashCallstack("EXCEPTION_ILLEGAL_INSTRUCTION");
+			break;
+		case EXCEPTION_INT_DIVIDE_BY_ZERO:
+			PrintCrashCallstack("EXCEPTION_INT_DIVIDE_BY_ZERO");
+			break;
+		default:
+			break;
+	}
+
+	// Continue search so doctest's handler can report the test case context
+	return EXCEPTION_CONTINUE_SEARCH;
+}
+
+#	endif	// ZEN_PLATFORM_WINDOWS
+
+static void
+InstallCrashSignalHandlers()
+{
+#	if ZEN_PLATFORM_LINUX || ZEN_PLATFORM_MAC
+	signal(SIGSEGV, CrashSignalHandler);
+	signal(SIGABRT, CrashSignalHandler);
+	signal(SIGFPE, CrashSignalHandler);
+	signal(SIGBUS, CrashSignalHandler);
+	signal(SIGILL, CrashSignalHandler);
+#	elif ZEN_PLATFORM_WINDOWS
+	AddVectoredExceptionHandler(0 /*called last among vectored handlers*/, CrashVectoredHandler);
+#	endif
+}
+
 struct TestListener : public doctest::IReporter
 {
 	const std::string_view ColorYellow = "\033[0;33m"sv;
@@ -184,6 +298,7 @@ RunTestMain(int Argc, char* Argv[], const char* ExecutableName, void (*ForceLink
 
 	zen::logging::InitializeLogging();
 	zen::MaximizeOpenFileCount();
+	InstallCrashSignalHandlers();
 
 	TestRunner Runner;