Support virtual inheritance paths to std::exception in exception tracer library

Summary:
This diff implements stack trace collection for derived exceptions in virtual inheritance hierarchies.

## Description of current behavior

Stack traces for exceptions `A` at the time they are thrown are stored by `SmartExceptionTracer` in a global `map<void*, ExceptionInfo>`. Previously, when performing lookups to obtain stack traces, the address of the object `B` to obtain a stack trace for needed to match the pointer previously stored. This works for simple cases where `A` and `B` are [pointer interconvertible](https://en.cppreference.com/w/cpp/language/static_cast.html#pointer-interconvertible), but failed lookups for cases where there is a non-zero offset between addresses of B and the thrown object A due to their differing layout.

## Fix

The fix uses `dynamic_cast<void*>` to obtain the address of the [most derived object](https://eel.is/c++draft/intro.object#6) associated with the object passed into `getTrace` for the case where a reference to a derived type (like `std::exception`) is passed in. This ensures that the address used in the lookup in the global map of thrown exceptions corresponds to the address placed there by the hook (ie the address passed by the runtime to `__cxa_throw()`.

## Side effects of this change

One side effect of how the fix is implemented is that we avoid a `dynamic_cast` to `std::exception` in the lookup paths where `std::exception_ptr` or `folly::ExceptionWrapper` are passed. This enables support for collecting stack traces for thrown objects that are not derived from `std::exception` (see the changed `NonStdException` test case).

In addition to that, this diffs skips unnecessary RTTI inspection of thrown objects to find out whether they are compatible with `std::exception` as the pointer to the originally thrown exception is already available when `std::exception_ptr` or `folly::exception_wrapper` is available, which increases performance slightly (see benchmarks below).

Reviewed By: shr, yfeldblum

Differential Revision: D84131474

fbshipit-source-id: 4e5434ffa01ad5739fed4226ec5b8891ee3c2daa

Author: jupp0r

third-party/folly/src/folly/debugging/exception_tracer/SmartExceptionTracer.cpp

@@ -41,7 +41,7 @@ std::atomic_bool loggedMessage{false};
 // the stack frames to use.
 template <typename ExceptionMetaFunc>
 ExceptionInfo getTraceWithFunc(
-    const std::exception& ex, ExceptionMetaFunc func) {
+    void* ex, const std::type_info* typeInfo, ExceptionMetaFunc func) {
   if (!detail::isSmartExceptionTracerHookEnabled() &&
       !loggedMessage.load(std::memory_order_relaxed)) {
     LOG(WARNING)
@@ -50,9 +50,9 @@ ExceptionInfo getTraceWithFunc(
   }
 
   ExceptionInfo info;
-  info.type = &typeid(ex);
+  info.type = typeInfo;
 
-  if (auto meta = get_default(*detail::getMetaMap().rlock(), &ex)) {
+  if (auto meta = get_default(*detail::getMetaMap().rlock(), ex)) {
     auto [traceBeginIt, traceEndIt] = func(*meta);
     info.frames.assign(traceBeginIt, traceEndIt);
   }
@@ -63,12 +63,22 @@ ExceptionInfo getTraceWithFunc(
 template <typename ExceptionMetaFunc>
 ExceptionInfo getTraceWithFunc(
     const std::exception_ptr& ptr, ExceptionMetaFunc func) {
-  if (auto* ex = folly::exception_ptr_get_object<std::exception>(ptr)) {
-    return getTraceWithFunc(*ex, std::move(func));
+  if (auto ex = folly::exception_ptr_get_object(ptr, nullptr)) {
+    return getTraceWithFunc(
+        ex, folly::exception_ptr_get_type(ptr), std::move(func));
   }
   return ExceptionInfo();
 }
 
+template <typename ExceptionMetaFunc>
+ExceptionInfo getTraceWithFunc(
+    const std::exception& e, ExceptionMetaFunc func) {
+  return getTraceWithFunc(
+      const_cast<void*>(dynamic_cast<const void*>(&e)),
+      &typeid(e),
+      std::move(func));
+}
+
 template <typename ExceptionMetaFunc>
 ExceptionInfo getTraceWithFunc(
     const exception_wrapper& ew, ExceptionMetaFunc func) {

third-party/folly/src/folly/debugging/exception_tracer/test/SmartExceptionTracerTest.cpp

@@ -17,6 +17,7 @@
 #include <folly/coro/BlockingWait.h>
 #include <folly/coro/Task.h>
 #include <folly/debugging/exception_tracer/SmartExceptionTracer.h>
+#include <folly/portability/GMock.h>
 #include <folly/portability/GTest.h>
 
 #if FOLLY_HAVE_ELF && FOLLY_HAVE_DWARF
@@ -67,16 +68,15 @@ TEST(SmartExceptionTracer, EmptyExceptionWrapper) {
       ss.str().find("Exception type: (unknown type)") != std::string::npos);
 }
 
-TEST(SmartExceptionTracer, InvalidException) {
+TEST(SmartExceptionTracer, NonStdException) {
   try {
     throw 10;
   } catch (...) {
     auto info = getTrace(std::current_exception());
 
     std::ostringstream ss;
     ss << info;
-    ASSERT_TRUE(
-        ss.str().find("Exception type: (unknown type)") != std::string::npos);
+    ASSERT_THAT(ss.str(), testing::HasSubstr("Exception type: int"));
   }
 }
 
@@ -143,4 +143,51 @@ TEST(SmartExceptionTracer, AsyncStackTrace) {
   }
 }
 
+class ExceptionE : virtual public std::runtime_error {
+ public:
+  ExceptionE() : std::runtime_error("ExceptionA") {}
+};
+
+class ExceptionF : virtual public std::runtime_error {
+ public:
+  ExceptionF() : std::runtime_error("ExceptionB") {}
+};
+
+class ExceptionG : virtual public ExceptionE, virtual public ExceptionF {
+ public:
+  ExceptionG() : std::runtime_error("ExceptionC"), ExceptionE(), ExceptionF() {}
+};
+
+[[noreturn]] FOLLY_NOINLINE void throwDiamond() {
+  throw ExceptionG();
+}
+
+TEST(SmartExceptionTracer, diamondExceptionPointer) {
+  try {
+    throwDiamond();
+  } catch (...) {
+    ASSERT_NE(
+        folly::exception_ptr_get_object<std::exception>(
+            std::current_exception()),
+        nullptr);
+    auto info = getTrace(std::current_exception());
+    auto infoStr = std::stringstream{} << info;
+
+    EXPECT_THAT(info.frames, testing::SizeIs(testing::Gt(0)));
+    EXPECT_THAT(infoStr.str(), testing::HasSubstr("throwDiamond"));
+  }
+}
+
+TEST(SmartExceptionTracer, diamondStdException) {
+  try {
+    throwDiamond();
+  } catch (const std::exception& e) {
+    auto info = getTrace(e);
+    auto infoStr = std::stringstream{} << info;
+
+    EXPECT_THAT(info.frames, testing::SizeIs(testing::Gt(0)));
+    EXPECT_THAT(infoStr.str(), testing::HasSubstr("throwDiamond"));
+  }
+}
+
 #endif // FOLLY_HAVE_ELF && FOLLY_HAVE_DWARF