[sanitizer] Add facility to print the full StackDepot

[tejohnson]

Summary

Split out of D87120 (memory profiler). Added unit testing of the new
printing facility.

[vitalybuka]

LGTM

[tejohnson]

I realized I had to make a change, PTAL.

compiler-rt/lib/sanitizer_common/tests/sanitizer_stackdepot_test.cpp

84

I realized last night that this isn't going to work on all platforms. The sanitizer_libc_test already had some handling for getting temp files, and for unlinking them, on various platforms. So I copied that handling here and structured the file handling similarly.

Note I tried moving it into sanitizer_test_utils.h and using it from there, but that caused some include file conflicts in an asan test that included sanitizer_test_utils.h and therefore ended up including both include/sanitizer/common_interface_defs.h and lib/sanitizer_common/sanitizer_interface_internal.h (the latter through the include files I had to add to sanitizer_test_utils.h to move this code there).

[tejohnson]

Fix tmp file handling to work on all platforms

[vitalybuka]

compiler-rt/lib/sanitizer_common/tests/sanitizer_stackdepot_test.cpp

72–96

something like that should work

[vitalybuka]

compiler-rt/lib/sanitizer_common/tests/sanitizer_stackdepot_test.cpp

72–96

 EXPECT_NE(i1, i2);
- StackDepotPrintAll();

[tejohnson]

compiler-rt/lib/sanitizer_common/tests/sanitizer_stackdepot_test.cpp

72–96

Thanks for the tip, that greatly simplifies the change!

[tejohnson]

Implement test suggestion

[tejohnson]

I had to revert due to 2 bot failures.

http://lab.llvm.org:8011/builders/sanitizer-windows/builds/69871/steps/stage%201%20check/logs/stdio

This one is in my new test. @vitalybuka can you think of why this might failure on Windows? It looks like the call to StackDepotPrintAll() is failing early as there is no output reported from it. Perhaps it is having trouble symbolizing the bogus stack addresses?

http://lab.llvm.org:8011/builders/sanitizer-x86_64-linux-fuzzer/builds/39187/steps/check-fuzzer/logs/stdio

@vitalybuka: This one seems completely unrelated to my change. Does it have flaky failures sometimes?

[vitalybuka]

I have a windows box, I'll take a look.
fuzzer looks like a flake, I started rebuild on the same revision
http://lab.llvm.org:8011/builders/sanitizer-x86_64-linux-fuzzer/builds/39189

[vitalybuka]

I lost connection to my Win box in the office. I will need Windows build
next week anyway. I will try to figure out why stderr is not captured there.
For now I relanded your patch and disabled the test on Windows.

[tejohnson]

In D87792#2281271, @vitalybuka wrote:

I lost connection to my Win box in the office. I will need Windows build
next week anyway. I will try to figure out why stderr is not captured there.
For now I relanded your patch and disabled the test on Windows.

Thanks @vitalybuka. [For my records: I see that you recommitted the patch in rGa90229d6cee8 and then disabled the test for windows in e259f7b88266572aaf00cfc1ff7fe88a9fdb1c7a]

Question on your recommit - I see you changed it to use testing::internal::CaptureStderr() and testing::internal::GetCapturedStderr() instead of EXPECT_EXIT. I had originally written the test using those interfaces in fact, but then read that they are internal testing APIs only for internal gtest testing and shouldn't be used outside of it. e.g. https://groups.google.com/g/googletestframework/c/7OTybZo-jp8. Should we change it back to the EXPECT_EXIT approach?

[vitalybuka]

In D87792#2281863, @tejohnson wrote:

In D87792#2281271, @vitalybuka wrote:

I lost connection to my Win box in the office. I will need Windows build
next week anyway. I will try to figure out why stderr is not captured there.
For now I relanded your patch and disabled the test on Windows.

Thanks @vitalybuka. [For my records: I see that you recommitted the patch in rGa90229d6cee8 and then disabled the test for windows in e259f7b88266572aaf00cfc1ff7fe88a9fdb1c7a]

Question on your recommit - I see you changed it to use testing::internal::CaptureStderr() and testing::internal::GetCapturedStderr() instead of EXPECT_EXIT. I had originally written the test using those interfaces in fact, but then read that they are internal testing APIs only for internal gtest testing and shouldn't be used outside of it. e.g. https://groups.google.com/g/googletestframework/c/7OTybZo-jp8. Should we change it back to the EXPECT_EXIT approach?

You are right. I thought that it may help but I didn't noticed "internal".
Restored EXPECT_EXIT with 82827244e9bbc2804afd9070158c567ac89f0540

compiler-rt/lib/sanitizer_common/tests/sanitizer_stackdepot_test.cpp

80–83

I lost connection to my windows, but maybe this way will work.

[vitalybuka]

compiler-rt/lib/sanitizer_common/tests/sanitizer_stackdepot_test.cpp

80–83

I lost connection to my windows, but maybe this way will work.

Please ignore this, it's just old draft accidentally attached to reply.

compiler-rt/lib/sanitizer_common/sanitizer_stackdepot.h

 StackDepotStats *StackDepotGetStats();
 u32 StackDepotPut(StackTrace stack);
 StackDepotHandle StackDepotPut_WithHandle(StackTrace stack);
 // Retrieves a stored stack trace by the id.
 StackTrace StackDepotGet(u32 id);
 
 void StackDepotLockAll();
 void StackDepotUnlockAll();
+void StackDepotPrintAll();
 
 // Instantiating this class creates a snapshot of StackDepot which can be
 // efficiently queried with StackDepotGet(). You can use it concurrently with
 // StackDepot, but the snapshot is only guaranteed to contain those stack traces
 // which were stored before it was instantiated.
 class StackDepotReverseMap {
  public:
   StackDepotReverseMap();

compiler-rt/lib/sanitizer_common/sanitizer_stackdepot.cpp

 void StackDepotLockAll() {
   theDepot.LockAll();
 }
 
 void StackDepotUnlockAll() {
   theDepot.UnlockAll();
 }
 
+void StackDepotPrintAll() {
+#if !SANITIZER_GO
+  theDepot.PrintAll();
+#endif
+}
+
 bool StackDepotReverseMap::IdDescPair::IdComparator(
     const StackDepotReverseMap::IdDescPair &a,
     const StackDepotReverseMap::IdDescPair &b) {
   return a.id < b.id;
 }
 
 StackDepotReverseMap::StackDepotReverseMap() {
   map_.reserve(StackDepotGetStats()->n_uniq_ids + 100);

compiler-rt/lib/sanitizer_common/sanitizer_stackdepotbase.h

 //===-- sanitizer_stackdepotbase.h ------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Implementation of a mapping from arbitrary values to unique 32-bit
 // identifiers.
 //===----------------------------------------------------------------------===//
 
 #ifndef SANITIZER_STACKDEPOTBASE_H
 #define SANITIZER_STACKDEPOTBASE_H
 
+#include <stdio.h>
+
+#include "sanitizer_atomic.h"
 #include "sanitizer_internal_defs.h"
 #include "sanitizer_mutex.h"
-#include "sanitizer_atomic.h"
 #include "sanitizer_persistent_allocator.h"
 
 namespace __sanitizer {
 
 template <class Node, int kReservedBits, int kTabSizeLog>
 class StackDepotBase {
  public:
   typedef typename Node::args_type args_type;
   typedef typename Node::handle_type handle_type;
   // Maps stack trace to an unique id.
   handle_type Put(args_type args, bool *inserted = nullptr);
   // Retrieves a stored stack trace by the id.
   args_type Get(u32 id);
 
   StackDepotStats *GetStats() { return &stats; }
 
   void LockAll();
   void UnlockAll();
+  void PrintAll();
 
  private:
   static Node *find(Node *s, args_type args, u32 hash);
   static Node *lock(atomic_uintptr_t *p);
   static void unlock(atomic_uintptr_t *p, Node *s);
 
   static const int kTabSize = 1 << kTabSizeLog;  // Hash table size.
   static const int kPartBits = 8;

 void StackDepotBase<Node, kReservedBits, kTabSizeLog>::UnlockAll() {
   for (int i = 0; i < kTabSize; ++i) {
     atomic_uintptr_t *p = &tab[i];
     uptr s = atomic_load(p, memory_order_relaxed);
     unlock(p, (Node *)(s & ~1UL));
   }
 }
 
+template <class Node, int kReservedBits, int kTabSizeLog>
+void StackDepotBase<Node, kReservedBits, kTabSizeLog>::PrintAll() {
+  for (int i = 0; i < kTabSize; ++i) {
+    atomic_uintptr_t *p = &tab[i];
+    lock(p);
+    uptr v = atomic_load(p, memory_order_relaxed);
+    Node *s = (Node *)(v & ~1UL);
+    for (; s; s = s->link) {
+      Printf("Stack for id %u:\n", s->id);
+      s->load().Print();
+    }
+    unlock(p, s);
+  }
+}
+
 } // namespace __sanitizer
 
 #endif // SANITIZER_STACKDEPOTBASE_H

compiler-rt/lib/sanitizer_common/tests/CMakeLists.txt

set(SANITIZER_TEST_HEADERS
   )
 foreach(header ${SANITIZER_IMPL_HEADERS})
   list(APPEND SANITIZER_TEST_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/../${header})
 endforeach()
 
 set(SANITIZER_TEST_CFLAGS_COMMON
   ${COMPILER_RT_UNITTEST_CFLAGS}
   ${COMPILER_RT_GTEST_CFLAGS}
+  ${COMPILER_RT_GMOCK_CFLAGS}
   -I${COMPILER_RT_SOURCE_DIR}/include
   -I${COMPILER_RT_SOURCE_DIR}/lib
   -I${COMPILER_RT_SOURCE_DIR}/lib/sanitizer_common
   -fno-rtti
   -O2
   -Werror=sign-compare
   -Wno-non-virtual-dtor
   -Wno-gnu-zero-variadic-macro-arguments
if( CMAKE_SIZEOF_VOID_P EQUAL 4 )
     list(APPEND extra_flags "-D_FILE_OFFSET_BITS=64")
   endif()
   get_sanitizer_common_lib_for_arch(${arch} SANITIZER_COMMON_LIB)
 
   set(SANITIZER_TEST_OBJECTS)
   generate_compiler_rt_tests(SANITIZER_TEST_OBJECTS SanitizerUnitTests
     "Sanitizer-${arch}-Test" ${arch}
     RUNTIME "${SANITIZER_COMMON_LIB}"
-    SOURCES ${SANITIZER_UNITTESTS} ${COMPILER_RT_GTEST_SOURCE}
+    SOURCES ${SANITIZER_UNITTESTS} ${COMPILER_RT_GTEST_SOURCE} ${COMPILER_RT_GMOCK_SOURCE}
     COMPILE_DEPS ${SANITIZER_TEST_HEADERS}
     DEPS gtest
     CFLAGS  ${SANITIZER_TEST_CFLAGS_COMMON} ${extra_flags}
     LINK_FLAGS ${SANITIZER_TEST_LINK_FLAGS_COMMON} ${extra_flags})
 
   if("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux" AND "${arch}" STREQUAL "x86_64")
     # Test that the libc-independent part of sanitizer_common is indeed
     # independent of libc, by linking this binary without libc (here) and
if(COMPILER_RT_CAN_EXECUTE_TESTS AND NOT ANDROID)
   endforeach()
 endif()
 
 if(ANDROID)
   foreach(arch ${SANITIZER_COMMON_SUPPORTED_ARCH})
     add_executable(SanitizerTest
       ${SANITIZER_UNITTESTS}
       ${COMPILER_RT_GTEST_SOURCE}
+      ${COMPILER_RT_GMOCK_SOURCE}
       $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
       $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
       $<TARGET_OBJECTS:RTSanitizerCommonSymbolizer.${arch}>)
     set_target_compile_flags(SanitizerTest
       ${SANITIZER_COMMON_CFLAGS}
       ${SANITIZER_TEST_CFLAGS_COMMON})
     # Setup correct output directory and link flags.
     set_target_properties(SanitizerTest PROPERTIES
       RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
     set_target_link_flags(SanitizerTest ${SANITIZER_TEST_LINK_FLAGS_COMMON})
     target_link_libraries(SanitizerTest ${SANITIZER_TEST_LINK_LIBS})
     # Add unit test to test suite.
     add_dependencies(SanitizerUnitTests SanitizerTest)
   endforeach()
 endif()

compiler-rt/lib/sanitizer_common/tests/sanitizer_stackdepot_test.cpp

 //===-- sanitizer_stackdepot_test.cpp -------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of ThreadSanitizer/AddressSanitizer runtime.
 //
 //===----------------------------------------------------------------------===//
 #include "sanitizer_common/sanitizer_stackdepot.h"
+
+#include <fstream>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
 #include "sanitizer_common/sanitizer_internal_defs.h"
 #include "sanitizer_common/sanitizer_libc.h"
-#include "gtest/gtest.h"
+#include "sanitizer_common/sanitizer_posix.h"
 
 namespace __sanitizer {
 
 TEST(SanitizerCommon, StackDepotBasic) {
   uptr array[] = {1, 2, 3, 4, 5};
   StackTrace s1(array, ARRAY_SIZE(array));
   u32 i1 = StackDepotPut(s1);
   StackTrace stack = StackDepotGet(i1);
TEST(SanitizerCommon, StackDepotSeveral) {
   StackTrace s1(array1, ARRAY_SIZE(array1));
   u32 i1 = StackDepotPut(s1);
   uptr array2[] = {1, 2, 3, 4, 8, 9};
   StackTrace s2(array2, ARRAY_SIZE(array2));
   u32 i2 = StackDepotPut(s2);
   EXPECT_NE(i1, i2);
 }
 
+TEST(SanitizerCommon, StackDepotPrint) {
+  uptr array1[] = {1, 2, 3, 4, 7};
+  StackTrace s1(array1, ARRAY_SIZE(array1));
+  u32 i1 = StackDepotPut(s1);
+  uptr array2[] = {1, 2, 3, 4, 8, 9};
+  StackTrace s2(array2, ARRAY_SIZE(array2));
+  u32 i2 = StackDepotPut(s2);
+  EXPECT_NE(i1, i2);
+  char tmpfile[128];
+  const char *tmpdir = "/tmp";
+  internal_snprintf(tmpfile, sizeof(tmpfile), "%s/%sXXXXXX", tmpdir,
+                    "sanitizer_common.stackdepotprint.tmp.");
+  fd_t fd = mkstemp(tmpfile);
+  __sanitizer_set_report_fd(reinterpret_cast<void *>(fd));
+  StackDepotPrintAll();
+  std::ifstream t(tmpfile);
+  std::stringstream buffer;
+  buffer << t.rdbuf();
+  EXPECT_THAT(
+      buffer.str(),
+      testing::MatchesRegex(
+          "Stack for id .*#0 0x0.*#1 0x1.*#2 0x2.*#3 0x3.*#4 0x6.*Stack for id "
+          ".*#0 0x0.*#1 0x1.*#2 0x2.*#3 0x3.*#4 0x7.*#5 0x8.*"));
+  internal_unlink(tmpfile);
+}
+
 TEST(SanitizerCommon, StackDepotReverseMap) {
   uptr array1[] = {1, 2, 3, 4, 5};
   uptr array2[] = {7, 1, 3, 0};
   uptr array3[] = {10, 2, 5, 3};
   uptr array4[] = {1, 3, 2, 5};
   u32 ids[4] = {0};
   StackTrace s1(array1, ARRAY_SIZE(array1));
   StackTrace s2(array2, ARRAY_SIZE(array2));