Added a floating point exception guard.

Author: corbett5

src/system.cpp

@@ -41,8 +41,13 @@
  */
 struct UnwindState
 {
-  std::size_t frames_to_skip;
+  /// The number of frames left to skip.
+  std::size_t framesToSkip;
+
+  /// A pointer to the current frame.
   void * * current;
+
+  /// A pointer to the final frame.
   void * * end;
 };
 
@@ -57,9 +62,9 @@ static _Unwind_Reason_Code unwindCallback( _Unwind_Context * const context, void
   // Note: do not write `::_Unwind_GetIP` because it is a macro on some platforms.
   // Use `_Unwind_GetIP` instead!
   UnwindState * const state = static_cast< UnwindState * >(arg);
-  if( state->frames_to_skip )
+  if( state->framesToSkip )
   {
-    --state->frames_to_skip;
+    --state->framesToSkip;
     return _Unwind_GetIP( context ) ? _URC_NO_REASON : _URC_END_OF_STACK;
   }
 
@@ -525,7 +530,9 @@ int enableFloatingPointExceptions( int const exceptions )
 
   return fesetenv( &fenv ) ? -1 : oldExcepts;
 #else
-  return feenableexcept( exceptions );
+  int const oldExceptions = feenableexcept( exceptions );
+  LVARRAY_ERROR_IF_EQ( oldExceptions, -1 );
+  return oldExceptions;
 #endif
 }
 
@@ -552,7 +559,9 @@ int disableFloatingPointExceptions( int const exceptions )
 
   return fesetenv( &fenv ) ? -1 : oldExcepts;
 #else
-  return fedisableexcept( exceptions );
+  int const oldExceptions = fedisableexcept( exceptions );
+  LVARRAY_ERROR_IF_EQ( oldExceptions, -1 );
+  return oldExceptions;
 #endif
 }
 

src/system.hpp

@@ -103,6 +103,32 @@ int disableFloatingPointExceptions( int const exceptions );
  */
 void setFPE();
 
+/**
+ * @class FloatingPointExceptionGuard
+ * @brief Changes the floating point environment and reverts it when destoyed.
+ */
+class FloatingPointExceptionGuard
+{
+public:
+  /**
+   * @brief Disable the floating point exceptions given by @p exceptions.
+   * @param exceptions The floating point exceptions to disable.
+   */
+  FloatingPointExceptionGuard( int const exceptions ):
+    m_previousExceptions( disableFloatingPointExceptions( exceptions ) )
+  {}
+
+  /**
+   * @brief Re-enable the floating point exceptions that were active on construction.
+   */
+  ~FloatingPointExceptionGuard()
+  { enableFloatingPointExceptions( m_previousExceptions ); }
+
+private:
+  /// The floating point exceptions that were active on construction.
+  int const m_previousExceptions;
+};
+
 /**
  * @return A string representing @p bytes converted to either
  *   KB, MB, or GB.

unitTests/testFloatingPointExceptions.cpp

@@ -25,35 +25,61 @@ using namespace testFloatingPointExceptionsHelpers;
 
 const char IGNORE_OUTPUT[] = ".*";
 
-TEST( TestFloatingPointEnvironment, test_FE_UNDERFLOW_flush )
+namespace LvArray
 {
-  LvArray::system::enableFloatingPointExceptions( FE_UNDERFLOW );
-  EXPECT_DEATH_IF_SUPPORTED( uf_test( DBL_MIN, 2 ), IGNORE_OUTPUT );
-  LvArray::system::disableFloatingPointExceptions( FE_UNDERFLOW );
+namespace testing
+{
+
+TEST( TestFloatingPointEnvironment, Underflow )
+{
+  system::enableFloatingPointExceptions( FE_UNDERFLOW );
+  EXPECT_DEATH_IF_SUPPORTED( divide( DBL_MIN, 2 ), IGNORE_OUTPUT );
+  system::disableFloatingPointExceptions( FE_UNDERFLOW );
 
-  LvArray::system::setFPE();
-  double fpnum = uf_test( DBL_MIN, 2 );
+  system::setFPE();
+  double fpnum = divide( DBL_MIN, 2 );
   int fpclassification = std::fpclassify( fpnum );
   EXPECT_NE( fpclassification, FP_SUBNORMAL );
 }
 
-TEST( TestFloatingPointEnvironment, test_FE_DIVBYZERO )
+TEST( TestFloatingPointEnvironment, DivideByZero )
 {
-  LvArray::system::setFPE();
-  EXPECT_DEATH_IF_SUPPORTED( func3( 0.0 ), IGNORE_OUTPUT );
+  system::setFPE();
+  EXPECT_DEATH_IF_SUPPORTED( divide( 1, 0 ), IGNORE_OUTPUT );
 }
 
+TEST( TestFloatingPointEnvironment, Overlow )
+{
+  system::setFPE();
+  EXPECT_DEATH_IF_SUPPORTED( multiply( DBL_MAX, 2 ), IGNORE_OUTPUT );
+}
 
-TEST( TestFloatingPointEnvironment, test_FE_OVERFLOW )
+TEST( TestFloatingPointEnvironment, Invalid )
 {
-  LvArray::system::setFPE();
-  EXPECT_DEATH_IF_SUPPORTED( of_test( 2, DBL_MAX ), IGNORE_OUTPUT );
+  system::setFPE();
+  EXPECT_DEATH_IF_SUPPORTED( invalid(), IGNORE_OUTPUT );
 }
 
-TEST( TestFloatingPointEnvironment, test_FE_INVALID )
+TEST( TestFloatingPointEnvironment, FloatingPointExceptionGuard )
 {
-  LvArray::system::setFPE();
-  EXPECT_DEATH_IF_SUPPORTED( invalid_test( 0.0 ), IGNORE_OUTPUT );
+  system::setFPE();
+
+  {
+    system::FloatingPointExceptionGuard guard( FE_UNDERFLOW );
+    divide( DBL_MIN, 2 );
+    EXPECT_DEATH_IF_SUPPORTED( multiply( DBL_MAX, 2 ), IGNORE_OUTPUT );
+  }
 }
 
+} // namespace testing
+} // namespace LvArray
+
 #endif
+
+// This is the default gtest main method. It is included for ease of debugging.
+int main( int argc, char * * argv )
+{
+  ::testing::InitGoogleTest( &argc, argv );
+  int const result = RUN_ALL_TESTS();
+  return result;
+}

unitTests/testFloatingPointExceptionsHelpers.cpp

@@ -6,79 +6,30 @@
  */
 
 
-#include <iostream>
 #include "Macros.hpp"
 #include "system.hpp"
 #include "system.hpp"
 #include "testFloatingPointExceptionsHelpers.hpp"
 
-namespace testFloatingPointExceptionsHelpers
-{
-
-void func3( double divisor )
-{
-  double a = 1.0 / divisor;
-  std::cout << "1.0/0.0 didn't kill program, result is " << a;
-}
-
-void func2( double divisor )
-{
-  func3( divisor );
-}
-
-void func1( double divisor )
-{
-  func2( divisor );
-}
-
-void func0( double divisor )
-{
-  func1( divisor );
-}
-
-void testStackTrace( double divisor )
-{
-  LvArray::system::setSignalHandling( []( int const signal ) { LvArray::system::stackTraceHandler( signal, true ); } );
-  func0( divisor );
-}
-
-//TEST(testStackTrace_DeathTest, stackTrace)
-//{
-//   EXPECT_DEATH_IF_SUPPORTED(testStackTrace(0), IGNORE_OUTPUT);
-//}
-
+#include <fenv.h>
+#include <cmath>
+#include <float.h>
 
+#if defined(__x86_64__)
+#include <xmmintrin.h>
+#include <iostream>
+#endif
 
-void show_fe_exceptions( void )
+namespace testFloatingPointExceptionsHelpers
 {
-  printf( "exceptions raised:" );
-  if( fetestexcept( FE_DIVBYZERO ))
-    printf( " FE_DIVBYZERO" );
-  if( fetestexcept( FE_INEXACT ))
-    printf( " FE_INEXACT" );
-  if( fetestexcept( FE_INVALID ))
-    printf( " FE_INVALID" );
-  if( fetestexcept( FE_OVERFLOW ))
-    printf( " FE_OVERFLOW" );
-  if( fetestexcept( FE_UNDERFLOW ))
-    printf( " FE_UNDERFLOW" );
-  feclearexcept( FE_ALL_EXCEPT );
-  printf( "\n" );
-}
 
-double uf_test( double x, double denominator )
-{
-  return x / denominator;
-}
+double multiply( double const x, double const y )
+{ return x * y; }
 
-double of_test( double x, double y )
-{
-  return x * y;
-}
+double divide( double const x, double const y )
+{ return x / y; }
 
-double invalid_test( double LVARRAY_UNUSED_ARG( x ) )
-{
-  return std::acos( 2.0 );
-}
+double invalid()
+{ return std::acos( 2.0 ); }
 
 }

unitTests/testFloatingPointExceptionsHelpers.hpp

@@ -5,33 +5,16 @@
  * SPDX-License-Identifier: (BSD-3-Clause)
  */
 
-
-
-#include <fenv.h>
-#include <cmath>
-#include <float.h>
-
-#if defined(__x86_64__)
-#include <xmmintrin.h>
-#endif
-
 namespace testFloatingPointExceptionsHelpers
 {
-void func3( double divisor );
-
-void func2( double divisor );
-
-void func1( double divisor );
-
-void func0( double divisor );
-
-void testStackTrace( double divisor );
 
-void show_fe_exceptions( void );
+/// Return @p x / @p y.
+double divide( double const x, double const y );
 
-double uf_test( double x, double denominator );
+/// Return @p x * @p y.
+double multiply( double const x, double const y );
 
-double of_test( double x, double y );
+/// Performs an invalid floating point operations (generate a NaN).
+double invalid();
 
-double invalid_test( double x );
-}
+} // namespace testFloatingPointExceptionsHelpers