Update catch.hpp (fixes #1856)

See also catchorg/Catch2#2627

extras/tests/catch/catch.hpp

@@ -1,6 +1,6 @@
 /*
  *  Catch v1.12.2
- *  Generated: 2018-05-14 15:10:01.112442
+ *  Generated: 2023-01-17 08:45:40.979381
  *  ----------------------------------------------------------
  *  This file has been merged from multiple headers. Please don't edit it directly
  *  Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved.
@@ -214,7 +214,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 // Use variadic macros if the compiler supports them
-#if ( defined _MSC_VER && _MSC_VER > 1400 && !defined __EDGE__) || \
+#if ( defined _MSC_VER && _MSC_VER >= 1400 && !defined __EDGE__) || \
     ( defined __WAVE__ && __WAVE_HAS_VARIADICS ) || \
     ( defined __GNUC__ && __GNUC__ >= 3 ) || \
     ( !defined __cplusplus && __STDC_VERSION__ >= 199901L || __cplusplus >= 201103L )
@@ -2129,6 +2129,9 @@ namespace Catch{
         #define CATCH_TRAP() \
                 __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n" \
                 : : : "memory","r0","r3","r4" ) /* NOLINT */
+    #elif defined(__aarch64__)
+        // Backport of https://github.com/catchorg/Catch2/commit/a25c1a24af8bffd35727a888a307ff0280cf9387
+        #define CATCH_TRAP() __asm__(".inst 0xd4200000")
     #else
         #define CATCH_TRAP() __asm__("int $3\n" : : /* NOLINT */ )
     #endif
@@ -6392,9 +6395,12 @@ CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS
 // #included from: catch_fatal_condition.hpp
 #define TWOBLUECUBES_CATCH_FATAL_CONDITION_H_INCLUDED
 
+#include <cassert>
+#include <stdexcept>
+
 namespace Catch {
 
-    // Report the error condition
+//! Signals fatal error message to the run context
 inline void reportFatal(std::string const &message) {
   IContext &context = Catch::getCurrentContext();
   IResultCapture *resultCapture = context.getResultCapture();
@@ -6432,16 +6438,43 @@ namespace Catch {
 #if !defined(CATCH_CONFIG_WINDOWS_SEH)
 
 namespace Catch {
-    struct FatalConditionHandler {
+class FatalConditionHandler {
-        void reset() {}
+  bool m_started;
-    };
+
+  // Install/disengage implementation for specific platform.
+  // Should be if-defed to work on current platform, can assume
+  // engage-disengage 1:1 pairing.
+  void engage_platform() {}
+  void disengage_platform() {}
+
+public:
+  // Should also have platform-specific implementations as needed
+  FatalConditionHandler() : m_started(false) {}
+  ~FatalConditionHandler() {}
+
+  void engage() {
+    assert(!m_started && "Handler cannot be installed twice.");
+    m_started = true;
+    engage_platform();
   }
 
+  void disengage() {
+    assert(m_started &&
+           "Handler cannot be uninstalled without being installed first");
+    m_started = false;
+    disengage_platform();
+  }
+};
+} // namespace Catch
+
 #else // CATCH_CONFIG_WINDOWS_SEH is defined
 
 namespace Catch {
 
-    struct SignalDefs { DWORD id; const char* name; };
+struct SignalDefs {
+  DWORD id;
+  const char *name;
+};
 extern SignalDefs signalDefs[];
 // There is no 1-1 mapping between signals and windows exceptions.
 // Windows can easily distinguish between SO and SigSegV,
@@ -6453,9 +6486,8 @@ namespace Catch {
     {EXCEPTION_INT_DIVIDE_BY_ZERO, "Divide by zero error"},
 };
 
-    struct FatalConditionHandler {
+static LONG CALLBACK
-
+handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {
-        static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {
   for (int i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
     if (ExceptionInfo->ExceptionRecord->ExceptionCode == signalDefs[i].id) {
       reportFatal(signalDefs[i].name);
@@ -6466,41 +6498,64 @@ namespace Catch {
   return EXCEPTION_CONTINUE_SEARCH;
 }
 
-        FatalConditionHandler() {
+// Since we do not support multiple instantiations, we put these
-            isSet = true;
+// into global variables and rely on cleaning them up in outlined
-            // 32k seems enough for Catch to handle stack overflow,
+// constructors/destructors
-            // but the value was found experimentally, so there is no strong guarantee
+static PVOID exceptionHandlerHandle = CATCH_NULL;
-            guaranteeSize = 32 * 1024;
+
-            exceptionHandlerHandle = CATCH_NULL;
+class FatalConditionHandler {
+  bool m_started;
+
+  // Install/disengage implementation for specific platform.
+  // Should be if-defed to work on current platform, can assume
+  // engage-disengage 1:1 pairing.
+
+  void engage_platform() {
     // Register as first handler in current chain
-            exceptionHandlerHandle = AddVectoredExceptionHandler(1, handleVectoredException);
+    exceptionHandlerHandle =
-            // Pass in guarantee size to be filled
+        AddVectoredExceptionHandler(1, handleVectoredException);
-            SetThreadStackGuarantee(&guaranteeSize);
+    if (!exceptionHandlerHandle) {
+      throw std::runtime_error("Could not register vectored exception handler");
+    }
   }
 
-        static void reset() {
+  void disengage_platform() {
-            if (isSet) {
+    if (!RemoveVectoredExceptionHandler(exceptionHandlerHandle)) {
-                // Unregister handler and restore the old guarantee
+      throw std::runtime_error(
-                RemoveVectoredExceptionHandler(exceptionHandlerHandle);
+          "Could not unregister vectored exception handler");
-                SetThreadStackGuarantee(&guaranteeSize);
+    }
     exceptionHandlerHandle = CATCH_NULL;
-                isSet = false;
+  }
+
+public:
+  FatalConditionHandler() : m_started(false) {
+    ULONG guaranteeSize = static_cast<ULONG>(32 * 1024);
+    if (!SetThreadStackGuarantee(&guaranteeSize)) {
+      // We do not want to fully error out, because needing
+      // the stack reserve should be rare enough anyway.
+      Catch::cerr() << "Failed to reserve piece of stack."
+                    << " Stack overflows will not be reported successfully.";
     }
   }
 
-        ~FatalConditionHandler() {
+  // We do not attempt to unset the stack guarantee, because
-            reset();
+  // Windows does not support lowering the stack size guarantee.
+  ~FatalConditionHandler() {}
+
+  void engage() {
+    assert(!m_started && "Handler cannot be installed twice.");
+    m_started = true;
+    engage_platform();
+  }
+
+  void disengage() {
+    assert(m_started &&
+           "Handler cannot be uninstalled without being installed first");
+    m_started = false;
+    disengage_platform();
   }
-    private:
-        static bool isSet;
-        static ULONG guaranteeSize;
-        static PVOID exceptionHandlerHandle;
 };
 
-    bool FatalConditionHandler::isSet = false;
-    ULONG FatalConditionHandler::guaranteeSize = 0;
-    PVOID FatalConditionHandler::exceptionHandlerHandle = CATCH_NULL;
-
 } // namespace Catch
 
 #endif // CATCH_CONFIG_WINDOWS_SEH
@@ -6510,11 +6565,35 @@ namespace Catch {
 #if !defined(CATCH_CONFIG_POSIX_SIGNALS)
 
 namespace Catch {
-    struct FatalConditionHandler {
+class FatalConditionHandler {
-        void reset() {}
+  bool m_started;
-    };
+
+  // Install/disengage implementation for specific platform.
+  // Should be if-defed to work on current platform, can assume
+  // engage-disengage 1:1 pairing.
+  void engage_platform() {}
+  void disengage_platform() {}
+
+public:
+  // Should also have platform-specific implementations as needed
+  FatalConditionHandler() : m_started(false) {}
+  ~FatalConditionHandler() {}
+
+  void engage() {
+    assert(!m_started && "Handler cannot be installed twice.");
+    m_started = true;
+    engage_platform();
   }
 
+  void disengage() {
+    assert(m_started &&
+           "Handler cannot be uninstalled without being installed first");
+    m_started = false;
+    disengage_platform();
+  }
+};
+} // namespace Catch
+
 #else // CATCH_CONFIG_POSIX_SIGNALS is defined
 
 #include <signal.h>
@@ -6532,18 +6611,35 @@ namespace Catch {
     {SIGFPE, "SIGFPE - Floating point error signal"},
     {SIGSEGV, "SIGSEGV - Segmentation violation signal"},
     {SIGTERM, "SIGTERM - Termination request signal"},
-            { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }
+    {SIGABRT, "SIGABRT - Abort (abnormal termination) signal"}};
-    };
 
-    struct FatalConditionHandler {
+// Older GCCs trigger -Wmissing-field-initializers for T foo = {}
+// which is zero initialization, but not explicit. We want to avoid
+// that.
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+#endif
 
-        static bool isSet;
+static char *altStackMem = CATCH_NULL;
-        static struct sigaction oldSigActions [sizeof(signalDefs)/sizeof(SignalDefs)];
+static std::size_t altStackSize = 0;
 static stack_t oldSigStack;
-        static char altStackMem[SIGSTKSZ];
+static struct sigaction oldSigActions[sizeof(signalDefs) / sizeof(SignalDefs)];
+
+static void restorePreviousSignalHandlers() {
+  // We set signal handlers back to the previous ones. Hopefully
+  // nobody overwrote them in the meantime, and doesn't expect
+  // their signal handlers to live past ours given that they
+  // installed them after ours..
+  for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
+    sigaction(signalDefs[i].id, &oldSigActions[i], CATCH_NULL);
+  }
+  // Return the old stack
+  sigaltstack(&oldSigStack, CATCH_NULL);
+}
 
 static void handleSignal(int sig) {
-            std::string name = "<unknown signal>";
+  char const *name = "<unknown signal>";
   for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
     SignalDefs &def = signalDefs[i];
     if (sig == def.id) {
@@ -6551,13 +6647,22 @@ namespace Catch {
       break;
     }
   }
-            reset();
+  // We need to restore previous signal handlers and let them do
+  // their thing, so that the users can have the debugger break
+  // when a signal is raised, and so on.
+  restorePreviousSignalHandlers();
   reportFatal(name);
   raise(sig);
 }
 
-        FatalConditionHandler() {
+class FatalConditionHandler {
-            isSet = true;
+  bool m_started;
+
+  // Install/disengage implementation for specific platform.
+  // Should be if-defed to work on current platform, can assume
+  // engage-disengage 1:1 pairing.
+
+  void engage_platform() {
     stack_t sigStack;
     sigStack.ss_sp = altStackMem;
     sigStack.ss_size = SIGSTKSZ;
@@ -6572,26 +6677,42 @@ namespace Catch {
     }
   }
 
+  void disengage_platform() { restorePreviousSignalHandlers(); }
+
+public:
+  FatalConditionHandler() : m_started(false) {
+    assert(!altStackMem &&
+           "Cannot initialize POSIX signal handler when one already exists");
+    if (altStackSize == 0) {
+      altStackSize = SIGSTKSZ;
+    }
+    altStackMem = new char[altStackSize]();
+  }
+
   ~FatalConditionHandler() {
-            reset();
+    delete[] altStackMem;
+    // We signal that another instance can be constructed by zeroing
+    // out the pointer.
+    altStackMem = CATCH_NULL;
   }
-        static void reset() {
+
-            if( isSet ) {
+  void engage() {
-                // Set signals back to previous values -- hopefully nobody overwrote them in the meantime
+    assert(!m_started && "Handler cannot be installed twice.");
-                for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) {
+    m_started = true;
-                    sigaction(signalDefs[i].id, &oldSigActions[i], CATCH_NULL);
+    engage_platform();
-                }
-                // Return the old stack
-                sigaltstack(&oldSigStack, CATCH_NULL);
-                isSet = false;
   }
+
+  void disengage() {
+    assert(m_started &&
+           "Handler cannot be uninstalled without being installed first");
+    m_started = false;
+    disengage_platform();
   }
 };
 
-    bool FatalConditionHandler::isSet = false;
+#if defined(__GNUC__)
-    struct sigaction FatalConditionHandler::oldSigActions[sizeof(signalDefs)/sizeof(SignalDefs)] = {};
+#pragma GCC diagnostic pop
-    stack_t FatalConditionHandler::oldSigStack = {};
+#endif
-    char FatalConditionHandler::altStackMem[SIGSTKSZ] = {};
 
 } // namespace Catch
 
@@ -6599,6 +6720,22 @@ namespace Catch {
 
 #endif // not Windows
 
+namespace Catch {
+
+//! Simple RAII guard for (dis)engaging the FatalConditionHandler
+class FatalConditionHandlerGuard {
+  FatalConditionHandler *m_handler;
+
+public:
+  FatalConditionHandlerGuard(FatalConditionHandler *handler)
+      : m_handler(handler) {
+    m_handler->engage();
+  }
+  ~FatalConditionHandlerGuard() { m_handler->disengage(); }
+};
+
+} // end namespace Catch
+
 #include <cassert>
 #include <set>
 #include <string>
@@ -6938,9 +7075,8 @@ namespace Catch {
         }
 
         void invokeActiveTestCase() {
-            FatalConditionHandler fatalConditionHandler; // Handle signals
+            FatalConditionHandlerGuard _(&m_fatalConditionhandler);
             m_activeTestCase->invoke();
-            fatalConditionHandler.reset();
         }
 
     private:
@@ -6978,6 +7114,7 @@ namespace Catch {
         std::vector<SectionEndInfo> m_unfinishedSections;
         std::vector<ITracker*> m_activeSections;
         TrackerContext m_trackerContext;
+        FatalConditionHandler m_fatalConditionhandler;
         size_t m_prevPassed;
         bool m_shouldReportUnexpected;
     };