Re: Handling Floating Point Exception in VC++ 6.0
On Wed, 3 Dec 2008 14:45:05 -0800, SONET <SONET@discussions.microsoft.com>
wrote:
I've been trying to handle floating point exceptions but I am having some
problems.
Basically I am able to catch the exception with the catch(...), I wrote a
class that should be thrown but it is not working.
I basically coded the following class
FloatException::FloatException( int nSubCode )
{
subCode = nSubCode;
_fpreset();
}
void FloatException::FloatExceptionHandler( int sig, int nSubCode )
{
throw( new FloatException( nSubCode ) );
}
void FloatException::SetFloatExceptionHandler()
{
// Get the current floating point control word.
//unsigned int uWord = _controlfp( 0, 0 );
unsigned int uWord = 0;
// Set the exceptions we want
uWord |= _EM_UNDERFLOW;
uWord |= _EM_OVERFLOW;
uWord |= _EM_ZERODIVIDE;
uWord |= _EM_INVALID;
_controlfp(uWord, _MCW_EM);
uWord = _controlfp( 0, 0 );
// Set the exception handler.
signal( SIGFPE, (void (__cdecl*)(int))FloatExceptionHandler );
}
in the main code I do this
FloatException::SetFloatExceptionHandler();
try
{
double temp = exp(99999999);
}
catch(FloatException& e)
{
}
catch(...)
{
}
the problem is that it never hits the FloatException catch, and it never
executes the FloatExceptionHandler. it does get caught in the catch(...)
which didn't do before I wrote the code.
Is there something I am missing? Is there a better way to do floating point
exception.
Get rid of the signal call and use _set_se_translator. It looks like your
signal handler is never being called, and you're catching a Windows
structured exception in catch(...). For reasons why that is bad, see:
http://members.cox.net/doug_web/eh.htm
Note that it's no longer done under /EHs in recent versions of VC, and you
can download the Express Edition here:
http://www.microsoft.com/express/vc/
In order to use _set_se_translator, you also have to use /EHa, which brings
back the catch(...) ability to catch SEs, including untranslated, raw SEs,
so it remains not the greatest thing in the world. Have you considered
/not/ enabling FP exceptions? There are a couple of things to consider
besides the /EHa requirement, (1) They are not raised until a subsequent
FPU instruction is attempted, which means you need to do an _fwait or
equivalent at the end of a calculation, and (2) They are cumulative, which
means if you leave FP exceptions masked (disabled), you can poll the status
word with _statusfp at the end of a calculation and detect any error that
would have manifested in an exception had exceptions been enabled. Provided
there are natural places to call _statusfp, that's what I would use.
I am running Windows XP on a Xeon. Does the processor matter?
AFAIK, no.
--
Doug Harrison
Visual C++ MVP