Changeset 1340 for trunk/source/global/management/include/G4FPEDetection.hh

Timestamp:

Nov 5, 2010, 3:45:55 PM (14 years ago)

Author:

garnier

Message:

update ti head

File:

• trunk/source/global/management/include/G4FPEDetection.hh (modified) (6 diffs)

trunk/source/global/management/include/G4FPEDetection.hh

@@ -25 +25 @@
 //
 //
-// $Id: G4FPEDetection.hh,v 1.2 2006/11/15 16:00:18 gcosmo Exp $
-// GEANT4 tag $Name: geant4-09-04-beta-01 $
+// $Id: G4FPEDetection.hh,v 1.5 2010/10/14 17:02:52 mkelsey Exp $
+// GEANT4 tag $Name: global-V09-03-22 $
 //
 // 
@@ -32 +32 @@
 //
 // -----------------------------------------------------------------------
-// This global method should be used on LINUX platforms with gcc compiler
-// for activating NaN detection and FPE signals, and forcing abortion of
-// the application at the time these are detected.
+// This global method should be used on LINUX or MacOSX platforms with gcc
+// compiler for activating NaN detection and FPE signals, and forcing
+// abortion of the application at the time these are detected.
 // Meant to be used for debug purposes, can be activated by compiling the
 // "run" module with the flag G4FPE_DEBUG set in the environment.
@@ -41 +41 @@
 #ifndef G4FPEDetection_h
 #define G4FPEDetection_h 1
+
+#include <iostream>
+#include <stdlib.h>  /* abort(), exit() */
 
 #ifdef __linux__
@@ -48 +51 @@
   #include <csignal>
 
-  #include <iostream>
-
   struct sigaction termaction, oldaction;
 
-  void TerminationSignalHandler(int sig)
+  static void TerminationSignalHandler(int sig, siginfo_t* sinfo, void* /* context */)
   {
     std::cerr << "ERROR: " << sig;
-    std::string message;
-    switch (SIGFPE)
-    {
+    std::string message = "Floating-point exception (FPE).";
+
+    if (sinfo) {
+      switch (sinfo->si_code) {
+#ifdef FPE_NOOP         /* BUG: MacOSX uses this instead of INTDIV */
+      case FPE_NOOP:
+#endif
       case FPE_INTDIV:
         message = "Integer divide by zero.";
@@ -85 +90 @@
         message = "Unknown error.";
         break;
-    }
+      }
+    }
+
     std::cerr << " - " << message << std::endl;
-
+    
     ::abort();
   }
 
-  void InvalidOperationDetection()
+  static void InvalidOperationDetection()
   {
     std::cout << std::endl
@@ -106 +113 @@
     //(void) feenableexcept( FE_UNDERFLOW );
 
-    sigset_t *def_set;
-    def_set=&termaction.sa_mask;
-    sigfillset(def_set);
-    sigdelset(def_set,SIGFPE);
-    termaction.sa_handler=TerminationSignalHandler;
-    termaction.sa_flags=0;
-    sigaction(SIGFPE, &termaction,&oldaction);
-  }
-#endif
-#else
-  void InvalidOperationDetection() {;}
-#endif
-
-#endif
+    sigdelset(&termaction.sa_mask,SIGFPE);
+    termaction.sa_sigaction=TerminationSignalHandler;
+    termaction.sa_flags=SA_SIGINFO;
+    sigaction(SIGFPE, &termaction, &oldaction);
+  }
+#endif
+#elif __MACH__      /* MacOSX */
+
+  #include <fenv.h>
+  #include <signal.h>
+
+  #define DEFINED_PPC      (defined(__ppc__) || defined(__ppc64__))
+  #define DEFINED_INTEL    (defined(__i386__) || defined(__x86_64__))
+
+  #if DEFINED_PPC
+
+    #define FE_EXCEPT_SHIFT 22  // shift flags right to get masks
+    #define FM_ALL_EXCEPT    FE_ALL_EXCEPT >> FE_EXCEPT_SHIFT 
+
+    static inline int feenableexcept (unsigned int excepts)
+    {
+      static fenv_t fenv;
+      unsigned int new_excepts = (excepts & FE_ALL_EXCEPT) >> FE_EXCEPT_SHIFT,
+                   old_excepts;  // all previous masks
+
+      if ( fegetenv (&fenv) )  { return -1; }
+      old_excepts = (fenv & FM_ALL_EXCEPT) << FE_EXCEPT_SHIFT;
+      fenv = (fenv & ~new_excepts) | new_excepts;
+
+      return ( fesetenv (&fenv) ? -1 : old_excepts );
+    }
+
+    static inline int fedisableexcept (unsigned int excepts)
+    {
+      static fenv_t fenv;
+      unsigned int still_on = ~((excepts & FE_ALL_EXCEPT) >> FE_EXCEPT_SHIFT),
+                   old_excepts;  // previous masks
+
+      if ( fegetenv (&fenv) )  { return -1; }
+      old_excepts = (fenv & FM_ALL_EXCEPT) << FE_EXCEPT_SHIFT;
+      fenv &= still_on;
+
+      return ( fesetenv (&fenv) ? -1 : old_excepts );
+    }
+
+  #elif DEFINED_INTEL
+
+    static inline int feenableexcept (unsigned int excepts)
+    {
+      static fenv_t fenv;
+      unsigned int new_excepts = excepts & FE_ALL_EXCEPT,
+                   old_excepts;  // previous masks
+
+      if ( fegetenv (&fenv) )  { return -1; }
+      old_excepts = fenv.__control & FE_ALL_EXCEPT;
+
+      // unmask
+      //
+      fenv.__control &= ~new_excepts;
+      fenv.__mxcsr   &= ~(new_excepts << 7);
+
+      return ( fesetenv (&fenv) ? -1 : old_excepts );
+    }
+
+    static inline int fedisableexcept (unsigned int excepts)
+    {
+      static fenv_t fenv;
+      unsigned int new_excepts = excepts & FE_ALL_EXCEPT,
+                   old_excepts;  // all previous masks
+
+      if ( fegetenv (&fenv) )  { return -1; }
+      old_excepts = fenv.__control & FE_ALL_EXCEPT;
+
+      // mask
+      //
+      fenv.__control |= new_excepts;
+      fenv.__mxcsr   |= new_excepts << 7;
+
+      return ( fesetenv (&fenv) ? -1 : old_excepts );
+    }
+
+  #endif  /* PPC or INTEL enabling */
+
+  static void TerminationSignalHandler(int sig, siginfo_t* sinfo, void* /* context */)
+  {
+    std::cerr << "ERROR: " << sig;
+    std::string message = "Floating-point exception (FPE).";
+
+    if (sinfo) {
+      switch (sinfo->si_code) {
+#ifdef FPE_NOOP         /* BUG: MacOSX uses this instead of INTDIV */
+      case FPE_NOOP:
+#endif
+      case FPE_INTDIV:
+        message = "Integer divide by zero.";
+        break;
+      case FPE_INTOVF:
+        message = "Integer overflow.";
+        break;
+      case FPE_FLTDIV:
+        message = "Floating point divide by zero.";
+        break;
+      case FPE_FLTOVF:
+        message = "Floating point overflow.";
+        break;
+      case FPE_FLTUND:
+        message = "Floating point underflow.";
+        break;
+      case FPE_FLTRES:
+        message = "Floating point inexact result.";
+        break;
+      case FPE_FLTINV:
+        message = "Floating point invalid operation.";
+        break;
+      case FPE_FLTSUB:
+        message = "Subscript out of range.";
+        break;
+      default:
+        message = "Unknown error.";
+        break;
+      }
+    }
+
+    std::cerr << " - " << message << std::endl;
+    
+    ::abort();
+  }
+
+  static void InvalidOperationDetection()
+  {
+    struct sigaction termaction, oldaction;
+
+    std::cout << std::endl
+              << "        "
+              << "############################################" << std::endl
+              << "        "
+              << "!!! WARNING - FPE detection is activated !!!" << std::endl
+              << "        "
+              << "############################################" << std::endl;
+
+    feenableexcept ( FE_DIVBYZERO );
+    feenableexcept ( FE_INVALID   );
+    // fedisableexcept( FE_OVERFLOW  );
+    // fedisableexcept( FE_UNDERFLOW );
+
+    sigdelset(&termaction.sa_mask,SIGFPE);
+    termaction.sa_sigaction=TerminationSignalHandler;
+    termaction.sa_flags=SA_SIGINFO;
+    sigaction(SIGFPE, &termaction, &oldaction);
+  }
+#else  /* Not Linux, nor MacOSX ... */
+
+  static void InvalidOperationDetection() {;}
+
+#endif
+
+#endif