Line data    Source code

       1           1 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : /// \file
       5             : /// Functions to enable/disable termination on floating point exceptions
       6             : 
       7             : #pragma once
       8             : 
       9             : #include <optional>
      10             : 
      11             : /// \cond
      12             : #ifdef __APPLE__
      13             : #ifndef __arm64__
      14             : #define SPECTRE_FPE_CSR 1
      15             : #endif
      16             : #elif not defined(__aarch64__)
      17             : #define SPECTRE_FPE_FENV 1
      18             : #endif
      19             : /// \endcond
      20             : 
      21             : /// \ingroup ErrorHandlingGroup
      22             : /// After a call to this function, the code will terminate with a floating
      23             : /// point exception on overflow, divide-by-zero, and invalid operations.
      24           1 : void enable_floating_point_exceptions();
      25             : 
      26             : /// \ingroup ErrorHandlingGroup
      27             : /// After a call to this function, the code will NOT terminate with a floating
      28             : /// point exception on overflow, divide-by-zero, and invalid operations.
      29             : ///
      30             : /// \warning Do not use this function to temporarily disable FPEs,
      31             : /// because it will not interact correctly with C++ exceptions.  Use
      32             : /// `ScopedFpeState` instead.
      33           1 : void disable_floating_point_exceptions();
      34             : 
      35             : /// \ingroup ErrorHandlingGroup
      36             : /// An RAII object to temporarily modify the handling of floating
      37             : /// point exceptions.
      38           1 : class ScopedFpeState {
      39             :  public:
      40           0 :   ScopedFpeState(const ScopedFpeState&) = delete;
      41           0 :   ScopedFpeState(ScopedFpeState&&) = delete;
      42           0 :   ScopedFpeState& operator=(const ScopedFpeState&) = delete;
      43           0 :   ScopedFpeState& operator=(ScopedFpeState&&) = delete;
      44           0 :   ~ScopedFpeState();
      45             : 
      46             :   /// Start a scope that will be restored, without changing the
      47             :   /// current state.
      48           1 :   ScopedFpeState();
      49             :   /// Start a scope with the specified exception state.  This is
      50             :   /// equivalent to calling the default constructor followed by
      51             :   /// `set_exceptions`.
      52           1 :   explicit ScopedFpeState(bool exceptions_enabled);
      53             : 
      54           0 :   struct DoNotSave {};
      55             :   /// Start a scope without saving the current state.  The only valid
      56             :   /// method call from this state is `save_exceptions`.
      57           1 :   explicit ScopedFpeState(DoNotSave /*meta*/);
      58             : 
      59             :   /// Enable or disable floating point exceptions.  It is an error if
      60             :   /// the exception state is not currently saved.
      61           1 :   void set_exceptions(bool exceptions_enabled) const;
      62             : 
      63             :   /// Save the current exception handling state after it has been
      64             :   /// cleared by `restore_exceptions`.  It will be restored by a later
      65             :   /// call to `restore_exceptions`.  It is an error to call this if
      66             :   /// a state is already saved.
      67           1 :   void save_exceptions();
      68             : 
      69             :   /// Restore the FPE handling to the internally saved state if
      70             :   /// present and clear that state.  This is called automatically by
      71             :   /// the destructor if it is not called manually.
      72           1 :   void restore_exceptions();
      73             : 
      74             :  private:
      75             : #if SPECTRE_FPE_CSR
      76             :   std::optional<unsigned int> original_state_;
      77             : #elif SPECTRE_FPE_FENV
      78             :   std::optional<int> original_state_;
      79             : #else
      80             :   // FPEs not supported, but this is still used to check method calls
      81             :   // are valid.
      82           0 :   struct DummyState {};
      83           0 :   std::optional<DummyState> original_state_;
      84             : #endif
      85             : };