Add SEH try/except utility

Author: jeremy-rifkin

README.md

@@ -36,6 +36,7 @@ Cpptrace also has a C API, docs [here](docs/c-api.md).
     - [Performance](#performance)
   - [Rethrowing Exceptions](#rethrowing-exceptions)
   - [`cpptrace::try_catch`](#cpptracetry_catch)
+  - [Traces from SEH exceptions](#traces-from-seh-exceptions)
   - [Traced Exception Objects](#traced-exception-objects)
     - [Wrapping std::exceptions](#wrapping-stdexceptions)
     - [Exception handling with cpptrace exception objects](#exception-handling-with-cpptrace-exception-objects)
@@ -877,6 +878,40 @@ Similar to a language `try`/`catch`, `catch` handlers will be considered in the
 take exactly one argument, equivalent to what would be written for a catch handler, except for `catch(...)` which can be
 achieved by a handler taking no arguments.
 
+## Traces from SEH exceptions
+
+Similar to the above section on collecting [traces from C++ exceptions](#traces-from-all-exceptions-cpptrace_try-and-cpptrace_catch),
+cpptrace provides `CPPTRACE_SEH_TRY` and `CPPTRACE_SEH_EXCEPT` macros that collect traces from SEH exceptions on windows
+with no overhead in the non-throwing (happy) path:
+
+```cpp
+#include <cpptrace/from_current.hpp>
+#include <iostream>
+#include <windows.h>
+
+void foo(int x, int y) {
+    return x / y;
+}
+
+int divide_zero_filter(int code) {
+    if(code == STATUS_INTEGER_DIVIDE_BY_ZERO || code == EXCEPTION_FLT_DIVIDE_BY_ZERO) {
+        return EXCEPTION_EXECUTE_HANDLER;
+    }
+    return EXCEPTION_CONTINUE_SEARCH;
+}
+
+int main() {
+    CPPTRACE_SEH_TRY {
+        foo(10, 0);
+    } CPPTRACE_SEH_EXCEPT(divide_zero_filter(GetExceptionCode())) {
+        std::cerr<<"Division by zero happened!"<<std::endl;
+        cpptrace::from_current_exception().print();
+    }
+}
+```
+
+The `CPPTRACE_SEH_EXCEPT` macro takes a filter expression as input, any expression valid in `__except` is valid.
+
 ## Traced Exception Objects
 
 Cpptrace provides a handful of traced exception classes which automatically collect stack traces when thrown. These

include/cpptrace/from_current.hpp

@@ -42,6 +42,8 @@ CPPTRACE_BEGIN_NAMESPACE
         };
 
         #ifdef _MSC_VER
+         CPPTRACE_EXPORT CPPTRACE_FORCE_NO_INLINE
+         int maybe_collect_trace(EXCEPTION_POINTERS* exception_ptrs, int filter_result);
          CPPTRACE_EXPORT CPPTRACE_FORCE_NO_INLINE
          void maybe_collect_trace(EXCEPTION_POINTERS* exception_ptrs, const std::type_info& type_info);
          template<typename E>

include/cpptrace/from_current_macros.hpp

@@ -48,6 +48,9 @@
              } \
          }(); \
      } catch(param)
+ #define CPPTRACE_SEH_TRY __try
+ #define CPPTRACE_SEH_EXCEPT(filter) \
+    __except(::cpptrace::detail::maybe_collect_trace(GetExceptionInformation(), (filter)))
 #else
  #define CPPTRACE_UNWIND_INTERCEPTOR_FOR(param) \
      ::cpptrace::detail::unwind_interceptor_for<void(param)>
@@ -66,6 +69,10 @@
 #ifdef CPPTRACE_UNPREFIXED_TRY_CATCH
  #define TRY CPPTRACE_TRY
  #define CATCH(param) CPPTRACE_CATCH(param)
+ #ifdef _MSC_VER
+  #define SEH_TRY CPPTRACE_SEH_TRY
+  #define SEH_EXCEPT(filter) CPPTRACE_SEH_EXCEPT(filter)
+ #endif
 #endif
 
 #endif // CPPTRACE_FROM_CURRENT_MACROS_HPP

src/from_current.cpp

@@ -612,12 +612,23 @@ CPPTRACE_BEGIN_NAMESPACE
             return false;
         }
         CPPTRACE_FORCE_NO_INLINE
+        int maybe_collect_trace(EXCEPTION_POINTERS* exception_ptrs, int filter_result) {
+            if(filter_result == EXCEPTION_EXECUTE_HANDLER) {
+                #ifdef CPPTRACE_UNWIND_WITH_DBGHELP
+                 collect_current_trace(2, exception_ptrs);
+                #else
+                 collect_current_trace(2);
+                #endif
+            }
+            return filter_result;
+        }
+        CPPTRACE_FORCE_NO_INLINE
         void maybe_collect_trace(EXCEPTION_POINTERS* exception_ptrs, const std::type_info& type_info) {
             if(matches_exception(exception_ptrs, type_info)) {
                 #ifdef CPPTRACE_UNWIND_WITH_DBGHELP
-                collect_current_trace(2, exception_ptrs);
+                 collect_current_trace(2, exception_ptrs);
                 #else
-                collect_current_trace(2);
+                 collect_current_trace(2);
                 #endif
             }
         }

test/unit/tracing/from_current.cpp

@@ -180,3 +180,78 @@ TEST(FromCurrent, NonThrowingPath) {
     }
     does_reach_end = true;
 }
+
+#ifdef _MSC_VER
+
+CPPTRACE_FORCE_NO_INLINE
+int my_div_function(int x, int y) {
+    return x / y;
+}
+
+int divide_zero_filter(int code) {
+    if(code == STATUS_INTEGER_DIVIDE_BY_ZERO || code == EXCEPTION_FLT_DIVIDE_BY_ZERO) {
+        return EXCEPTION_EXECUTE_HANDLER;
+    }
+    return EXCEPTION_CONTINUE_SEARCH;
+}
+
+TEST(FromCurrent, SEHBasic) {
+    bool does_enter_catch = false;
+    auto guard = cpptrace::detail::scope_exit([&] {
+        EXPECT_TRUE(does_enter_catch);
+    });
+    [&] () {
+        CPPTRACE_SEH_TRY {
+            [&] () {
+                auto res = my_div_function(10, 0);
+                (void)res;
+            } ();
+        } CPPTRACE_SEH_EXCEPT(divide_zero_filter(GetExceptionCode())) {
+            [&] () {
+                does_enter_catch = true;
+                EXPECT_FALSE(cpptrace::current_exception_was_rethrown());
+                const auto& trace = cpptrace::from_current_exception();
+                ASSERT_GE(trace.frames.size(), 4);
+                auto it = std::find_if(
+                    trace.frames.begin(),
+                    trace.frames.end(),
+                    [](const cpptrace::stacktrace_frame& frame) {
+                        return frame.symbol.find("my_div_function") != std::string::npos;
+                    }
+                );
+                EXPECT_NE(it, trace.frames.end()) << trace;
+                size_t i = static_cast<size_t>(it - trace.frames.begin());
+                EXPECT_FILE(trace.frames[i].filename, "from_current.cpp");
+            } ();
+        }
+    } ();
+    EXPECT_TRUE(does_enter_catch);
+}
+
+TEST(FromCurrent, SEHCorrectHandler) {
+    bool does_enter_catch = false;
+    auto guard = cpptrace::detail::scope_exit([&] {
+        EXPECT_TRUE(does_enter_catch);
+    });
+    [&] () {
+        CPPTRACE_SEH_TRY {
+            [&] () {
+                CPPTRACE_SEH_TRY {
+                    [&] () {
+                        auto res = my_div_function(10, 0);
+                        (void)res;
+                    } ();
+                } CPPTRACE_SEH_EXCEPT(EXCEPTION_CONTINUE_SEARCH) {
+                    [&] () {
+                        FAIL();
+                    } ();
+                }
+            } ();
+        } CPPTRACE_SEH_EXCEPT(divide_zero_filter(GetExceptionCode())) {
+            does_enter_catch = true;
+        }
+    } ();
+    EXPECT_TRUE(does_enter_catch);
+}
+
+#endif