Merge dd45329f01 into 52204f78f9

googletest/include/gtest/internal/gtest-port.h

@@ -215,6 +215,7 @@
 //                                specializations. Always defined to 0 or 1.
 //   GTEST_USE_OWN_FLAGFILE_FLAG_ - Always defined to 0 or 1.
 //   GTEST_HAS_CXXABI_H_ - Always defined to 0 or 1.
+//   GTEST_HAS_STD_STACKTRACE_ - Always defined to 0 or 1.
 //   GTEST_CAN_STREAM_RESULTS_ - Always defined to 0 or 1.
 //   GTEST_HAS_ALT_PATH_SEP_ - Always defined to 0 or 1.
 //   GTEST_WIDE_STRING_USES_UTF16_ - Always defined to 0 or 1.
@@ -877,6 +878,14 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 #endif
 #endif
 
+#if !defined(GTEST_HAS_STD_STACKTRACE_)
+#if defined(__cpp_lib_stacktrace) && __cpp_lib_stacktrace >= 202011L
+#define GTEST_HAS_STD_STACKTRACE_ 1
+#else
+#define GTEST_HAS_STD_STACKTRACE_ 0
+#endif
+#endif
+
 // A function level attribute to disable checking for use of uninitialized
 // memory when built with MemorySanitizer.
 #if GTEST_HAVE_ATTRIBUTE_(no_sanitize_memory)

googletest/src/gtest-internal-inl.h

@@ -60,6 +60,10 @@
 #include <windows.h>  // NOLINT
 #endif                // GTEST_OS_WINDOWS
 
+#if GTEST_HAS_STD_STACKTRACE_
+#include <stacktrace>
+#endif
+
 #include "gtest/gtest-spi.h"
 #include "gtest/gtest.h"
 
@@ -434,16 +438,16 @@ class OsStackTraceGetterInterface {
       delete;
 };
 
+#ifdef GTEST_HAS_ABSL
 // A working implementation of the OsStackTraceGetterInterface interface.
-class OsStackTraceGetter : public OsStackTraceGetterInterface {
+class AbslStackTraceGetter : public OsStackTraceGetterInterface {
  public:
-  OsStackTraceGetter() = default;
+  AbslStackTraceGetter() = default;
 
   std::string CurrentStackTrace(int max_depth, int skip_count) override;
   void UponLeavingGTest() override;
 
  private:
-#ifdef GTEST_HAS_ABSL
   Mutex mutex_;  // Protects all internal state.
 
   // We save the stack frame below the frame that calls user code.
@@ -451,10 +455,43 @@ class OsStackTraceGetter : public OsStackTraceGetterInterface {
   // the user code changes between the call to UponLeavingGTest()
   // and any calls to the stack trace code from within the user code.
   void* caller_frame_ = nullptr;
+
+  AbslStackTraceGetter(const AbslStackTraceGetter&) = delete;
+  AbslStackTraceGetter& operator=(const AbslStackTraceGetter&) = delete;
+};
 #endif  // GTEST_HAS_ABSL
 
-  OsStackTraceGetter(const OsStackTraceGetter&) = delete;
-  OsStackTraceGetter& operator=(const OsStackTraceGetter&) = delete;
+#if GTEST_HAS_STD_STACKTRACE_
+// A working implementation of the OsStackTraceGetterInterface interface.
+class StdStackTraceGetter : public OsStackTraceGetterInterface {
+ public:
+  StdStackTraceGetter() = default;
+
+  std::string CurrentStackTrace(int max_depth, int skip_count) override;
+  void UponLeavingGTest() override;
+
+ private:
+  Mutex mutex_;  // Protects all internal state.
+
+  // We save the stack frame below the frame that calls user code.
+  // We do this because the address of the frame immediately below
+  // the user code changes between the call to UponLeavingGTest()
+  // and any calls to the stack trace code from within the user code.
+  std::stacktrace_entry::native_handle_type caller_frame_ = {};
+
+  StdStackTraceGetter(const StdStackTraceGetter&) = delete;
+  StdStackTraceGetter& operator=(const StdStackTraceGetter&) = delete;
+};
+#endif  // GTEST_HAS_STD_STACKTRACE_
+
+// An implementation of OsStackTraceGetterInterface which returns no
+// stack trace.
+class NoopStackTraceGetter : public OsStackTraceGetterInterface {
+ public:
+  NoopStackTraceGetter() = default;
+
+  std::string CurrentStackTrace(int max_depth, int skip_count) override;
+  void UponLeavingGTest() override;
 };
 
 // Information about a Google Test trace point.
@@ -623,8 +660,8 @@ class GTEST_API_ UnitTestImpl {
   void set_os_stack_trace_getter(OsStackTraceGetterInterface* getter);
 
   // Returns the current OS stack trace getter if it is not NULL;
-  // otherwise, creates an OsStackTraceGetter, makes it the current
-  // getter, and returns it.
+  // otherwise, creates an OsStackTraceGetterInterface, makes it the
+  // current getter, and returns it.
   OsStackTraceGetterInterface* os_stack_trace_getter();
 
   // Returns the current OS stack trace as an std::string.
@@ -938,9 +975,9 @@ class GTEST_API_ UnitTestImpl {
   TestEventListeners listeners_;
 
   // The OS stack trace getter.  Will be deleted when the UnitTest
-  // object is destructed.  By default, an OsStackTraceGetter is used,
-  // but the user can set this field to use a custom getter if that is
-  // desired.
+  // object is destructed.  By default, an OsStackTraceGetterInterface
+  // is created when os_stack_trace_getter is first called, but the user
+  // can set this field to use a custom getter if that is desired.
   OsStackTraceGetterInterface* os_stack_trace_getter_;
 
   // True if and only if PostFlagParsingInit() has been called.

googletest/src/gtest.cc

@@ -154,6 +154,10 @@
 #include "absl/strings/strip.h"
 #endif  // GTEST_HAS_ABSL
 
+#if GTEST_HAS_STD_STACKTRACE_
+#include <stacktrace>
+#endif
+
 // Checks builtin compiler feature |x| while avoiding an extra layer of #ifdefs
 // at the callsite.
 #if defined(__has_builtin)
@@ -5062,9 +5066,9 @@ void StreamingListener::SocketWriter::MakeConnection() {
 const char* const OsStackTraceGetterInterface::kElidedFramesMarker =
     "... " GTEST_NAME_ " internal frames ...";
 
-std::string OsStackTraceGetter::CurrentStackTrace(int max_depth, int skip_count)
-    GTEST_LOCK_EXCLUDED_(mutex_) {
 #ifdef GTEST_HAS_ABSL
+std::string AbslStackTraceGetter::CurrentStackTrace(int max_depth, int skip_count)
+    GTEST_LOCK_EXCLUDED_(mutex_) {
   std::string result;
 
   if (max_depth <= 0) {
@@ -5104,16 +5108,11 @@ std::string OsStackTraceGetter::CurrentStackTrace(int max_depth, int skip_count)
   }
 
   return result;
-
-#else   // !GTEST_HAS_ABSL
-  static_cast<void>(max_depth);
-  static_cast<void>(skip_count);
-  return "";
-#endif  // GTEST_HAS_ABSL
 }
+#endif  // GTEST_HAS_ABSL
 
-void OsStackTraceGetter::UponLeavingGTest() GTEST_LOCK_EXCLUDED_(mutex_) {
 #ifdef GTEST_HAS_ABSL
+void AbslStackTraceGetter::UponLeavingGTest() GTEST_LOCK_EXCLUDED_(mutex_) {
   void* caller_frame = nullptr;
   if (absl::GetStackTrace(&caller_frame, 1, 3) <= 0) {
     caller_frame = nullptr;
@@ -5121,7 +5120,75 @@ void OsStackTraceGetter::UponLeavingGTest() GTEST_LOCK_EXCLUDED_(mutex_) {
 
   MutexLock lock(&mutex_);
   caller_frame_ = caller_frame;
+}
 #endif  // GTEST_HAS_ABSL
+
+#if GTEST_HAS_STD_STACKTRACE_
+std::string StdStackTraceGetter::CurrentStackTrace(int max_depth, int skip_count)
+    GTEST_LOCK_EXCLUDED_(mutex_) {
+  if (max_depth <= 0) {
+    return "";
+  }
+
+  max_depth = std::min(max_depth, kMaxStackTraceDepth);
+  // Skips the frames requested by the caller, plus this function.
+  skip_count += 1;
+
+  std::stacktrace stack = std::stacktrace::current(skip_count, max_depth);
+
+  std::stacktrace_entry::native_handle_type caller_frame = {};
+  {
+    MutexLock lock(&mutex_);
+    caller_frame = caller_frame_;
+  }
+
+  std::ostringstream result;
+  for (const std::stacktrace_entry &entry : stack) {
+    if (entry.native_handle() == caller_frame &&
+        !GTEST_FLAG_GET(show_internal_stack_frames)) {
+      // Add a marker to the trace and stop adding frames.
+      result << kElidedFramesMarker << '\n';
+      break;
+    }
+
+    result << "  " << entry.native_handle() << ": ";
+    std::string description = entry.description();
+    if (description.empty()) {
+        result << "(unknown)";
+    } else {
+        result << description;
+    }
+    std::string source_file = entry.source_file();
+    if (!source_file.empty()) {
+      result << ' ' << source_file << ':' << entry.source_line();
+    }
+    result << '\n';
+  }
+  return std::move(result).str();
+}
+#endif  // GTEST_HAS_ABSL
+
+#if GTEST_HAS_STD_STACKTRACE_
+void StdStackTraceGetter::UponLeavingGTest() GTEST_LOCK_EXCLUDED_(mutex_) {
+  std::stacktrace stack = std::stacktrace::current(/*skip=*/2, /*max_depth=*/1);
+  std::stacktrace_entry::native_handle_type caller_frame = {};
+  if (!stack.empty()) {
+    caller_frame = stack[0].native_handle();
+  }
+
+  MutexLock lock(&mutex_);
+  caller_frame_ = caller_frame;
+}
+#endif  // GTEST_HAS_ABSL
+
+std::string NoopStackTraceGetter::CurrentStackTrace(int max_depth, int skip_count) {
+  static_cast<void>(max_depth);
+  static_cast<void>(skip_count);
+  return "";
+}
+
+void NoopStackTraceGetter::UponLeavingGTest() {
+  // Do nothing.
 }
 
 #ifdef GTEST_HAS_DEATH_TEST
@@ -6407,14 +6474,18 @@ void UnitTestImpl::set_os_stack_trace_getter(
 }
 
 // Returns the current OS stack trace getter if it is not NULL;
-// otherwise, creates an OsStackTraceGetter, makes it the current
-// getter, and returns it.
+// otherwise, creates an OsStackTraceGetterInterface, makes it the
+// current getter, and returns it.
 OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
   if (os_stack_trace_getter_ == nullptr) {
 #ifdef GTEST_OS_STACK_TRACE_GETTER_
     os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;
+#elif GTEST_HAS_STD_STACKTRACE_
+    os_stack_trace_getter_ = new StdStackTraceGetter;
+#elif defined(GTEST_HAS_ABSL)
+    os_stack_trace_getter_ = new AbslStackTraceGetter;
 #else
-    os_stack_trace_getter_ = new OsStackTraceGetter;
+    os_stack_trace_getter_ = new NoopStackTraceGetter;
 #endif  // GTEST_OS_STACK_TRACE_GETTER_
   }