[Support][WIP] Add unit test for symbolized stack traces

[luismarques]

Summary

Stack trace symbolization is missing unit tests. This patch adds such a test.

The preprocessor condition gating the new test is the same as in LLVM's Signal.inc implementation. Some of the platforms that match that condition actually have broken stack traces and/or broken symbolization. The WIP is to investigate on what platforms symbolized traces actually work and to update the gating condition.

[dblaikie]

llvm/unittests/Support/CrashRecoveryTest.cpp

118–120

Presumably the condition is more than the "can we do backtraces" condition - but can we do /symbolized/ backtraces, which means testing for whether this is built with debug info, but I'm not sure if we have a preprocessor define for that/way to detect that?

[luismarques]

llvm/unittests/Support/CrashRecoveryTest.cpp

118–120

You're right. I'm not aware of any standard preprocessor macro to detect exactly that condition, though maybe NDEBUG correlates with it well enough. I suppose we could define our own in LLVM's CMake files, based on the build options. Alternatively, we could make this translation unit always be built with debug info. Yet another option might be to do some kind of runtime inspection to detect debug info and skip the unit test if it's missing.

[dblaikie]

You're right. I'm not aware of any standard preprocessor macro to detect exactly that condition, though maybe NDEBUG correlates with it well enough.

I'd guess probably not - people enable assertions pretty regularly in LLVM, probably quite independently of debug info. But I might be wrong.

I suppose we could define our own in LLVM's CMake files, based on the build options. Alternatively, we could make this translation unit always be built with debug info.

Not sure if there's a tidy way to do that (always with debug info) - flags will vary by compiler/platform, and cmake abstracts that at the high level, not sure if it can be done at a lower/per-file level too.

Yet another option might be to do some kind of runtime inspection to detect debug info and skip the unit test if it's missing.

Yeah, though then the inspection probably has the same problems/complexities as the thing it's testing...

llvm/unittests/Support/CrashRecoveryTest.cpp

 #include "llvm/Support/CrashRecoveryContext.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/TargetParser/Triple.h"
 #include "gtest/gtest.h"
+#include <charconv>
 
 #ifdef _WIN32
 #define WIN32_LEAN_AND_MEAN
 #define NOGDI
 #include <windows.h>
 #endif
 
 #ifdef LLVM_ON_UNIX
if (Triple(sys::getProcessTriple()).isOSWindows())
     GTEST_SKIP();
   std::string Res;
   llvm::raw_string_ostream RawStream(Res);
   PrintStackTrace(RawStream, 1);
   std::string Str = RawStream.str();
   EXPECT_EQ(std::string::npos, Str.find("#1"));
 }
 
+#if defined(HAVE_BACKTRACE) && ENABLE_BACKTRACES && HAVE_LINK_H &&             \
+    (defined(__linux__) || defined(__FreeBSD__) ||                             \
+     defined(__FreeBSD_kernel__) || defined(__NetBSD__))
+TEST(CrashRecoveryTest, SymbolizedStackTrace) {
+  std::string Res;
+  llvm::raw_string_ostream RawStream(Res);
+  PrintStackTrace(RawStream);
+  int ExpectedLine = __LINE__ - 1; // The line that calls PrintStackTrace.
+  std::string Str = RawStream.str();
+  // Symbolized trace lines have "file:line:column", others "(file+offset)".
+  std::string ExpectedFile = __FILE__ ":"; // Match this file and the colon.
+  size_t ActualLineStartPos = Str.find(ExpectedFile) + ExpectedFile.length();
+  ASSERT_NE(std::string::npos, ActualLineStartPos);
+  int ActualLine;
+  auto LineResult = std::from_chars(Str.data() + ActualLineStartPos,
+                                    Str.data() + Str.size(), ActualLine);
+  ASSERT_EQ(LineResult.ec, std::errc());
+  // Check that the stack trace contains the correct line for this source file.
+  // At the time this test was added x86_64 Linux was printing the line after
+  // the PrintStackTrace call while AArch64 Linux was printing the expected line
+  // so for now we do a fuzzy match.
+  EXPECT_NEAR(ExpectedLine, ActualLine, 1);
+}
+#endif
+
 #ifdef _WIN32
 static void raiseIt() {
   RaiseException(123, EXCEPTION_NONCONTINUABLE, 0, NULL);
 }
 
 TEST(CrashRecoveryTest, RaiseException) {
   llvm::CrashRecoveryContext::Enable();
   EXPECT_FALSE(CrashRecoveryContext().RunSafely(raiseIt));