[sanitizer] Expose __sanitizer_print_stack_trace().

[earthdok]

Summary

Useful for debugging code built with sanitizer tools.

[samsonov]

include/sanitizer/common_interface_defs.h

88

Specify that this is useful for debugging purposes only.

lib/sanitizer_common/sanitizer_common_libcdep.cc

41 ↗

(On Diff #5659)

Looks like this should go to sanitizer_stacktrace_libcdep.cc

45 ↗

(On Diff #5659)

What if slow unwind is unavailable (caller can learn about this via StackTrace::WillUseFastUnwind function)?
Also, unwinding a stack from the sanitizer runtime and is (unfortunately) tool-specific. See complicated GET_STACK_TRACE_WITH_PC_AND_BP in ASan runtime and GetStackTrace in MSan runtime. It would be cool to
generalize it somehow, but we're not there at the moment. But we should probably address this before adding a generic
interface usable with all sanitizers - just imagine that you call __sanitizer_print_stack_trace() in your program or in gdb,
and suddenly see an MSan report caused by unblocked interceptors called during _Unwind_Backtrace.

You'll also need lit tests.

[earthdok]

implement __sanitizer_get_stack_trace() separately in asan/msan/lsan/tsan

[samsonov]

include/sanitizer/common_interface_defs.h

89

What about ubsan or dfsan implementations? If we decide to make this function tool-specific and implement it in a different way in each tool [1], let's start from the tools that need it right now (IIRC you want it for LSan/ASan).

[1] - though, I don't like it. I've spent some time to make stack unwinding and printing more generic (but apparently it's still not generic enough), and I think it would be better to fix the code in such a way that we'll be able to write a single __sanitizer_print_stack_trace in sanitizer_common that would work for all tools.

lib/msan/msan.cc

195 ↗

(On Diff #5814)

How does it confuse the unwinder?

lib/tsan/rtl/tsan_interface.cc

90 ↗

(On Diff #5814)

interface attribute?

[earthdok]

lib/msan/msan.cc

195 ↗

(On Diff #5814)

Like this:

#0 0x7fef07e475a8 in __sanitizer_print_stack_trace llvm/projects/compiler-rt/lib/msan/msan.cc:578
#1 0x7fef07e47658 in GetStackTrace san/llvm/projects/compiler-rt/lib/msan/msan.cc:188
#2 0x7fef07e47658 in __sanitizer_print_stack_trace llvm/projects/compiler-rt/lib/msan/msan.cc:579
#3 0x7fef07e8b2e1 in main (reproducers/a.out+0x602e1)
#4 0x7fef06a2c76c in __libc_start_main /build/buildd/eglibc-2.15/csu/libc-start.c:226
#5 0x7fef07e8b1d4 in _start (reproducers/a.out+0x601d4)

[glider]

The patch doesn't seem to work for me if I add __sanitizer_print_stack_trace() into BlockingMutex::{Lock,Unlock} in sanitizer_common/sanitizer_linux.cc

[earthdok]

• leave only the ASan implementation for now
• add a test

[samsonov]

lib/asan/asan_stack.cc

49

Can we instead use asan:: in sanitizer_print_stack_trace (and probably in GET_STACK_TRACE_) macro expansions?

lib/asan/lit_tests/TestCases/print-stack-trace.cc

3

I think you may just leave -O0 and -O3 here.

17

Remove trailing .*

[earthdok]

lib/asan/asan_stack.cc

49

Let's not bloat the macros with this. How about a scoped using directive as a compromise?

lib/asan/lit_tests/TestCases/print-stack-trace.cc

3

done

17

done

[earthdok]

• address samsonov's comments

[samsonov]

LGTM

include/sanitizer/common_interface_defs.h

#endif
   //   int32_t x[3];  // 12 bytes, but 8-aligned under AddressSanitizer.
   //   char *beg = (char*)&x[0];
   //   char *end = beg + 12;  // Not 8-aligned, but is the end of the buffer.
   void __sanitizer_annotate_contiguous_container(const void *beg,
                                                  const void *end,
                                                  const void *old_mid,
                                                  const void *new_mid);
 
+  // Print the stack trace leading to this call. Useful for debugging user code.
+  void __sanitizer_print_stack_trace();
+
 #ifdef __cplusplus
 }  // extern "C"
 #endif
 
 #endif  // SANITIZER_COMMON_INTERFACE_DEFS_H

lib/asan/asan_stack.h

#define GET_STACK_TRACE_THREAD                                    \
   GET_STACK_TRACE(kStackTraceMax, true)
 
 #define GET_STACK_TRACE_MALLOC                                    \
   GET_STACK_TRACE(common_flags()->malloc_context_size,            \
                   common_flags()->fast_unwind_on_malloc)
 
 #define GET_STACK_TRACE_FREE GET_STACK_TRACE_MALLOC
 
-#define PRINT_CURRENT_STACK()                    \
-  {                                              \
-    GET_STACK_TRACE(kStackTraceMax,              \
-      common_flags()->fast_unwind_on_fatal);     \
-    PrintStack(&stack);                          \
+#define PRINT_CURRENT_STACK()   \
+  {                             \
+    GET_STACK_TRACE_FATAL_HERE; \
+    PrintStack(&stack);         \
   }
 
 #endif  // ASAN_STACK_H

lib/asan/asan_stack.cc

 // and may be overriden by user if he wants to use his own symbolization.
 // ASan on Windows has its own implementation of this.
 #if !SANITIZER_WINDOWS && !SANITIZER_SUPPORTS_WEAK_HOOKS
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE NOINLINE
 bool __asan_symbolize(const void *pc, char *out_buffer, int out_size) {
   return false;
 }
 #endif
+
+SANITIZER_INTERFACE_ATTRIBUTE
+extern "C" void __sanitizer_print_stack_trace() {
+  using namespace __asan;
+  PRINT_CURRENT_STACK();
+}

lib/asan/lit_tests/TestCases/print-stack-trace.cc

+// RUN: %clangxx_asan -O0 %s -o %t && %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -o %t && %t 2>&1 | FileCheck %s
+
+#include <sanitizer/asan_interface.h>
+
+void FooBarBaz() {
+  __sanitizer_print_stack_trace();
+}
+
+int main() {
+  FooBarBaz();
+  return 0;
+}
+// CHECK: {{    #0 0x.* in __sanitizer_print_stack_trace}}
+// CHECK: {{    #1 0x.* in FooBarBaz\(\) .*print-stack-trace.cc:7}}
+// CHECK: {{    #2 0x.* in main .*print-stack-trace.cc:11}}