Fix up llexception.h's cross-platform SEH wrapper.

Introduce AlwaysReturn<void> specialization, which always discards any result
of calling the specified callable with specified args.

Derive new Windows_SEH_exception from LLException, not std::runtime_error.

Put the various SEH functions in LL::seh nested namespace, e.g.
LL::seh::catcher() as the primary API.

Break out more levels of Windows SEH handler to work around the restrictions on
functions containing __try/__except.

The triadic catcher() overload now does little save declare a std::string
stacktrace before forwarding the call to catcher_inner(), passing a reference
to stacktrace along with the trycode, filter and handler functions.

catcher_inner() accepts the stacktrace and the three function template
arguments. It contains the __try/__except logic. It calls a new filter_()
wrapper template, which calls fill_stacktrace() before forwarding the call to
the caller's filter function. fill_stacktrace(), in the .cpp file, contains
the logic to populate the stacktrace string -- unless the Structured Exception
is stack overflow, in which case it puts an explanatory string instead.

catcher_inner()'s __except clause passes not only the code, but also the
stacktrace string, to the caller's handler function. It wraps the caller's
handler function in always_return<rtype>(), where rtype is the type returned
by the trycode function. This allows a handler to return a value, while also
supporting the void handler case, e.g. one that throws a C++ exception. (This
is why we need AlwaysReturn<void>: some trycode() functions are themselves
void.)

For the dyadic catcher() overload, introduce common_filter() containing the
logic to distinguish a C++ exception from any other kind of Structured
Exception. The fact that the stacktrace is captured before the filter function
is called should permit capturing a stacktrace for a C++ exception as well as
for most other Structured Exceptions.

As before, the monadic catcher() overload supplies the rethrow() handler, in
the .cpp file.

Change existing calls from seh_catcher() to LL::seh::catcher().

1 files changed, 63 insertions, 41 deletions

diff --git a/indra/llcommon/llexception.h b/indra/llcommon/llexception.h
index 3e50678b44..f58a553eb3 100644
--- a/indra/llcommon/llexception.h
+++ b/indra/llcommon/llexception.h
@@ -12,6 +12,7 @@
 #if ! defined(LL_LLEXCEPTION_H)
 #define LL_LLEXCEPTION_H
 
+#include "always_return.h"
 #include <stdexcept>
 #include <boost/exception/exception.hpp>
 #include <boost/throw_exception.hpp>
@@ -106,90 +107,111 @@ void log_unhandled_exception_(const char*, int, const char*, const std::string&)
 *   Structured Exception Handling
 *****************************************************************************/
 // this is used in platform-generic code -- define outside #if LL_WINDOWS
-struct Windows_SEH_exception: public std::runtime_error
+struct Windows_SEH_exception: public LLException
 {
-    Windows_SEH_exception(const std::string& what): std::runtime_error(what) {}
+    Windows_SEH_exception(const std::string& what): LLException(what) {}
 };
 
+namespace LL
+{
+namespace seh
+{
+
 #if LL_WINDOWS //-------------------------------------------------------------
 
-#include <functional>
+void fill_stacktrace(std::string& stacktrace, U32 code);
+
+// wrapper around caller's U32 filter(U32 code, struct _EXCEPTION_POINTERS*)
+// filter function: capture a stacktrace, if possible, before forwarding the
+// call to the caller's filter() function
+template <typename FILTER>
+U32 filter_(std::string& stacktrace, FILTER&& filter,
+            U32 code, struct _EXCEPTION_POINTERS* exptrs)
+{
+    // By the time the handler gets control, the stack has been unwound,
+    // so report the stack trace now at filter() time.
+    fill_stacktrace(stacktrace, code);
+    return std::forward<FILTER>(filter)(code, exptrs);
+}
 
-// triadic variant specifies try(), filter(U32, struct _EXCEPTION_POINTERS*),
-// handler(U32, const std::string& stacktrace)
-// stacktrace may or may not be available
 template <typename TRYCODE, typename FILTER, typename HANDLER>
-auto seh_catcher(TRYCODE&& trycode, FILTER&& filter, HANDLER&& handler)
+auto catcher_inner(std::string& stacktrace,
+                   TRYCODE&& trycode, FILTER&& filter, HANDLER&& handler)
 {
-    // don't try to construct a std::function at the moment of Structured Exception
-    std::function<U32(U32, struct _EXCEPTION_POINTERS*)>
-        filter_function(std::forward<FILTER>(filter));
-    std::string stacktrace;
     __try
     {
         return std::forward<TRYCODE>(trycode)();
     }
-    __except (ll_seh_filter(
-                  stacktrace,
-                  filter_function,
-                  GetExceptionCode(),
-                  GetExceptionInformation()))
+    __except (filter_(stacktrace,
+                      std::forward<FILTER>(filter),
+                      GetExceptionCode(), GetExceptionInformation()))
     {
-        return std::forward<HANDLER>(handler)(GetExceptionCode(), stacktrace);
+        return always_return<decltype(trycode())>(
+            std::forward<HANDLER>(handler), GetExceptionCode(), stacktrace);
     }
 }
 
-// dyadic variant specifies try(), handler(U32, stacktrace), assumes default filter
+// triadic variant specifies try(), filter(U32, struct _EXCEPTION_POINTERS*),
+// handler(U32, const std::string& stacktrace)
+// stacktrace may or may not be available
+template <typename TRYCODE, typename FILTER, typename HANDLER>
+auto catcher(TRYCODE&& trycode, FILTER&& filter, HANDLER&& handler)
+{
+    // Construct and destroy this stacktrace string in the outer function
+    // because we can't do either in the function with __try/__except.
+    std::string stacktrace;
+    return catcher_inner(stacktrace,
+                         std::forward<TRYCODE>(trycode),
+                         std::forward<FILTER>(filter),
+                         std::forward<HANDLER>(handler));
+}
+
+// common_filter() handles the typical case in which we want our handler
+// clause to handle only Structured Exceptions rather than explicitly-thrown
+// C++ exceptions
+U32 common_filter(U32 code, struct _EXCEPTION_POINTERS*);
+
+// dyadic variant specifies try(), handler(U32, stacktrace), assumes common_filter()
 template <typename TRYCODE, typename HANDLER>
-auto seh_catcher(TRYCODE&& trycode, HANDLER&& handler)
+auto catcher(TRYCODE&& trycode, HANDLER&& handler)
 {
-    return seh_catcher(
-        std::forward<TRYCODE>(trycode),
-        seh_filter,
-        std::forward<HANDLER>(handler));
+    return catcher(std::forward<TRYCODE>(trycode),
+                   common_filter,
+                   std::forward<HANDLER>(handler));
 }
 
 // monadic variant specifies try(), assumes default filter and handler
 template <typename TRYCODE>
-auto seh_catcher(TRYCODE&& trycode)
+auto catcher(TRYCODE&& trycode)
 {
-    return seh_catcher(
-        std::forward<TRYCODE>(trycode),
-        seh_filter,
-        seh_rethrow);
+    return catcher(std::forward<TRYCODE>(trycode), rethrow);
 }
 
-// SEH exception filtering for use in __try __except
-// Separates C++ exceptions from C SEH exceptions
-// Todo: might be good idea to do some kind of seh_to_msc_wrapper(function, ARGS&&);
-U32 ll_seh_filter(
-    std::string& stacktrace,
-    std::function<U32(U32, struct _EXCEPTION_POINTERS*)> filter,
-    U32 code,
-    struct _EXCEPTION_POINTERS* exception_infop);
-U32 seh_filter(U32 code, struct _EXCEPTION_POINTERS* exception_infop);
-void seh_rethrow(U32 code, const std::string& stacktrace);
+[[noreturn]] void rethrow(U32 code, const std::string& stacktrace);
 
 #else  // not LL_WINDOWS -----------------------------------------------------
 
 template <typename TRYCODE, typename FILTER, typename HANDLER>
-auto seh_catcher(TRYCODE&& trycode, FILTER&&, HANDLER&&)
+auto catcher(TRYCODE&& trycode, FILTER&&, HANDLER&&)
 {
     return std::forward<TRYCODE>(trycode)();
 }
 
 template <typename TRYCODE, typename HANDLER>
-auto seh_catcher(TRYCODE&& trycode, HANDLER&&)
+auto catcher(TRYCODE&& trycode, HANDLER&&)
 {
     return std::forward<TRYCODE>(trycode)();
 }
 
 template <typename TRYCODE>
-auto seh_catcher(TRYCODE&& trycode)
+auto catcher(TRYCODE&& trycode)
 {
     return std::forward<TRYCODE>(trycode)();
 }
 
 #endif // not LL_WINDOWS -----------------------------------------------------
 
+} // namespace LL::seh
+} // namespace LL
+
 #endif /* ! defined(LL_LLEXCEPTION_H) */