Reword rethrow implementation to use a flag system instead of exception pointers. This also supports MSVC's STL.

Author: jeremy-rifkin

README.md

@@ -617,10 +617,6 @@ namespace cpptrace {
 }
 ```
 
-> [!NOTE]
-> Unfortunately, this is only able to preserve traces under libstdc++ and libc++, not Microsoft's standard library. This
-> is due to details of Microsoft's implementation of exceptions and `std::current_exception`.
-
 Example:
 
 ```cpp
@@ -650,11 +646,16 @@ rethrown. Cpptrace provides an interface for getting the last rethrow location:
 
 ```cpp
 namespace cpptrace {
-    const raw_trace& raw_trace_from_current_exception_last_throw_point();
-    const stacktrace& from_current_exception_last_throw_point();
+    const raw_trace& raw_trace_from_current_exception_rethrow();
+    const stacktrace& from_current_exception_rethrow();
+    bool current_exception_was_rethrown();
 }
 ```
 
+If the current exception was not rethrown, these functions return references to empty traces.
+`current_exception_was_rethrown` can be used to check if the current exception was rethrown and a non-empty rethrow
+trace exists.
+
 Example usage, utilizing `foo` and `bar` from the above example:
 
 ```cpp
@@ -666,26 +667,11 @@ int main() {
         std::cerr<<"Thrown from:"<<std::endl;
         cpptrace::from_current_exception().print(); // trace containing main -> foo -> bar
         std::cerr<<"Rethrown from:"<<std::endl;
-        cpptrace::from_current_exception_last_throw_point().print(); // trace containing main -> foo
+        cpptrace::from_current_exception_rethrow().print(); // trace containing main -> foo
     }
 }
 ```
 
-### Implementation Note
-
-In order to preserve the original trace, `cpptrace::rethrow` must store the original trace using the current
-`exception_ptr` as a tag. This means both the trace and exception object will remain in memory until a later throw. This
-is not something to think twice about in 99% of use cases, however, in applications which are extremely sensitive to
-resource constraints or throw very large exception objects this may be worth considering. But, in practice, large
-exception objects are incredibly rare. None the less, cpptrace provides a utility to clear the saved `exception_ptr` tag
-and saved stack trace in the event it is useful:
-
-```cpp
-namespace cpptrace {
-    void clear_saved_exception_trace_from_rethrow();
-}
-```
-
 ## Traced Exception Objects
 
 Cpptrace provides a handful of traced exception classes which automatically collect stack traces when thrown. These

include/cpptrace/exceptions.hpp

@@ -39,6 +39,7 @@ namespace cpptrace {
             const raw_trace& get_raw_trace() const;
             stacktrace& get_resolved_trace();
             const stacktrace& get_resolved_trace() const;
+            bool is_resolved() const;
         private:
             void clear();
         };

include/cpptrace/from_current.hpp

@@ -24,10 +24,10 @@ namespace cpptrace {
     CPPTRACE_EXPORT const raw_trace& raw_trace_from_current_exception();
     CPPTRACE_EXPORT const stacktrace& from_current_exception();
 
-    CPPTRACE_EXPORT const raw_trace& raw_trace_from_current_exception_last_throw_point();
-    CPPTRACE_EXPORT const stacktrace& from_current_exception_last_throw_point();
+    CPPTRACE_EXPORT const raw_trace& raw_trace_from_current_exception_rethrow();
+    CPPTRACE_EXPORT const stacktrace& from_current_exception_rethrow();
 
-    CPPTRACE_EXPORT void clear_saved_exception_trace_from_rethrow();
+    CPPTRACE_EXPORT bool current_exception_was_rethrown();
 
     CPPTRACE_EXPORT CPPTRACE_NORETURN CPPTRACE_FORCE_NO_INLINE
     void rethrow();

src/exceptions.cpp

@@ -89,6 +89,9 @@ namespace cpptrace {
             }
             return resolved_trace;
         }
+        bool lazy_trace_holder::is_resolved() const {
+            return resolved;
+        }
         void lazy_trace_holder::clear() {
             if(resolved) {
                 resolved_trace.~stacktrace();

src/from_current.cpp

@@ -9,6 +9,7 @@
 
 #include "platform/platform.hpp"
 #include "utils/microfmt.hpp"
+#include "utils/utils.hpp"
 
 #ifndef _MSC_VER
  #include <string.h>
@@ -35,28 +36,20 @@
 namespace cpptrace {
     namespace detail {
         thread_local lazy_trace_holder current_exception_trace;
+        thread_local lazy_trace_holder saved_rethrow_trace;
 
-        struct saved_rethrow_trace_data {
-            std::exception_ptr ptr{};
-            lazy_trace_holder rethrown_exception_trace;
-        };
-        thread_local saved_rethrow_trace_data saved_rethrow_trace;
-
-        CPPTRACE_FORCE_NO_INLINE void collect_current_trace(std::size_t skip) {
-            current_exception_trace = lazy_trace_holder(cpptrace::generate_raw_trace(skip + 1));
-        }
-
-        void save_current_trace_exception_as_rethrow_trace(std::exception_ptr exception) {
-            // TODO: Maybe move current_exception_trace instead of copy?
-            saved_rethrow_trace.ptr = std::move(exception);
-            saved_rethrow_trace.rethrown_exception_trace = current_exception_trace;
+        bool& get_rethrow_switch() {
+            static thread_local bool rethrow_switch = false;
+            return rethrow_switch;
         }
 
-        lazy_trace_holder& get_current_trace() {
-            if(saved_rethrow_trace.ptr == std::current_exception()) {
-                return saved_rethrow_trace.rethrown_exception_trace;
+        CPPTRACE_FORCE_NO_INLINE void collect_current_trace(std::size_t skip) {
+            auto trace = cpptrace::generate_raw_trace(skip + 1);
+            if(get_rethrow_switch()) {
+                saved_rethrow_trace = lazy_trace_holder(std::move(trace));
             } else {
-                return current_exception_trace;
+                current_exception_trace = lazy_trace_holder(std::move(trace));
+                saved_rethrow_trace = lazy_trace_holder();
             }
         }
 
@@ -340,35 +333,49 @@ namespace cpptrace {
     }
 
     const raw_trace& raw_trace_from_current_exception() {
-        return detail::get_current_trace().get_raw_trace();
+        return detail::current_exception_trace.get_raw_trace();
     }
 
     const stacktrace& from_current_exception() {
-        return detail::get_current_trace().get_resolved_trace();
+        return detail::current_exception_trace.get_resolved_trace();
     }
 
-    const raw_trace& raw_trace_from_current_exception_last_throw_point() {
-        return detail::current_exception_trace.get_raw_trace();
+    const raw_trace& raw_trace_from_current_exception_rethrow() {
+        return detail::saved_rethrow_trace.get_raw_trace();
     }
 
-    const stacktrace& from_current_exception_last_throw_point() {
-        return detail::current_exception_trace.get_resolved_trace();
+    const stacktrace& from_current_exception_rethrow() {
+        return detail::saved_rethrow_trace.get_resolved_trace();
+    }
+
+    bool current_exception_was_rethrown() {
+        if(detail::saved_rethrow_trace.is_resolved()) {
+            return !detail::saved_rethrow_trace.get_resolved_trace().empty();
+        } else {
+            return !detail::saved_rethrow_trace.get_raw_trace().empty();
+        }
+    }
+
+    // called when unwinding starts after rethrowing, after search phase
+    void rethrow_scope_cleanup() {
+        detail::get_rethrow_switch() = false;
     }
 
-    void clear_saved_exception_trace_from_rethrow() {
-        detail::saved_rethrow_trace.ptr = nullptr;
-        detail::saved_rethrow_trace.rethrown_exception_trace = detail::lazy_trace_holder{};
+    detail::scope_guard<void(&)()> setup_rethrow() {
+        detail::saved_rethrow_trace = detail::current_exception_trace;
+        detail::get_rethrow_switch() = true;
+        // will flip the switch back to true as soon as the search phase completes and the unwinding begins
+        return detail::scope_exit<void(&)()>(rethrow_scope_cleanup);
     }
 
+    // The non-argument overload is to serve as room for possible future optimization under Microsoft's STL
     CPPTRACE_FORCE_NO_INLINE void rethrow() {
-        // The non-argument overload is to serve as room for possible future optimization under Microsoft's STL
-        auto ptr = std::current_exception();
-        detail::save_current_trace_exception_as_rethrow_trace(ptr);
-        std::rethrow_exception(ptr);
+        auto guard = setup_rethrow();
+        std::rethrow_exception(std::current_exception());
     }
 
     CPPTRACE_FORCE_NO_INLINE void rethrow(std::exception_ptr exception) {
-        detail::save_current_trace_exception_as_rethrow_trace(exception);
+        auto guard = setup_rethrow();
         std::rethrow_exception(exception);
     }
 }

test/unit/tracing/from_current.cpp

@@ -47,6 +47,7 @@ TEST(FromCurrent, Basic) {
         static volatile int tco_guard = stacktrace_from_current_1(line_numbers);
         (void)tco_guard;
     } CPPTRACE_CATCH(const std::runtime_error& e) {
+        EXPECT_FALSE(cpptrace::current_exception_was_rethrown());
         EXPECT_EQ(e.what(), "foobar"sv);
         const auto& trace = cpptrace::from_current_exception();
         ASSERT_GE(trace.frames.size(), 4);

test/unit/tracing/from_current_z.cpp

@@ -48,6 +48,7 @@ TEST(FromCurrentZ, Basic) {
         static volatile int tco_guard = stacktrace_from_current_z_1(line_numbers);
         (void)tco_guard;
     } CPPTRACE_CATCHZ(const std::runtime_error& e) {
+        EXPECT_FALSE(cpptrace::current_exception_was_rethrown());
         EXPECT_EQ(e.what(), "foobar"sv);
         const auto& trace = cpptrace::from_current_exception();
         ASSERT_GE(trace.frames.size(), 4);

test/unit/tracing/rethrow.cpp

@@ -15,10 +15,6 @@
 
 using namespace std::literals;
 
-// only enable for libstdc++ and libc++, not Microsoft's STL
-
-#if defined(__GLIBCXX__) || defined(_LIBCPP_VERSION)
-
 static volatile int truthy = 2;
 
 // NOTE: returning something and then return stacktrace_multi_3(line_numbers) * rand(); is done to prevent TCO even
@@ -61,6 +57,7 @@ TEST(Rethrow, RethrowPreservesTrace) {
         static volatile int tco_guard = stacktrace_from_current_rethrow_1(line_numbers, rethrow_line_numbers);
         (void)tco_guard;
     } CPPTRACE_CATCH(const std::runtime_error& e) {
+        EXPECT_TRUE(cpptrace::current_exception_was_rethrown());
         EXPECT_EQ(e.what(), "foobar"sv);
         const auto& trace = cpptrace::from_current_exception();
         ASSERT_GE(trace.frames.size(), 4);
@@ -112,8 +109,9 @@ TEST(Rethrow, RethrowTraceCorrect) {
         static volatile int tco_guard = stacktrace_from_current_rethrow_1(line_numbers, rethrow_line_numbers);
         (void)tco_guard;
     } CPPTRACE_CATCH(const std::runtime_error& e) {
+        EXPECT_TRUE(cpptrace::current_exception_was_rethrown());
         EXPECT_EQ(e.what(), "foobar"sv);
-        const auto& rethrow_trace = cpptrace::from_current_exception_last_throw_point();
+        const auto& rethrow_trace = cpptrace::from_current_exception_rethrow();
         ASSERT_GE(rethrow_trace.frames.size(), 4);
         auto it = std::find_if(
             rethrow_trace.frames.begin(),
@@ -184,6 +182,7 @@ TEST(Rethrow, RethrowDoesntInterfereWithSubsequentTraces) {
         line_numbers.insert(line_numbers.begin(), __LINE__ + 1);
         stacktrace_from_current_basic_1(line_numbers);
     } CPPTRACE_CATCH(const std::runtime_error& e) {
+        EXPECT_FALSE(cpptrace::current_exception_was_rethrown());
         EXPECT_EQ(e.what(), "foobar"sv);
         const auto& trace = cpptrace::from_current_exception();
         ASSERT_GE(trace.frames.size(), 4);
@@ -228,5 +227,3 @@ TEST(Rethrow, RethrowDoesntInterfereWithSubsequentTraces) {
         );
     }
 }
-
-#endif