i need to check if an overflow of an floating-point arithmetic operation occured.
Currently I’m doing something like this (for addition):
(LHS > 0 && RHS > 0 && sum <= 0) || (LHS < 0 && RHS < 0 && sum >= 0)
This is checked for every addition.
Is there a more efficient way like the intrisic for int overflow?
How is it possible to raise a signal like SIGFPE?
IEEE floating-point doesn’t overflow like this; if the magnitude of a result is too
large to represent, it becomes an infinity rather than wrapping around like integer
arithmetic. You want to check whether the result is infinite.
I think the easiest way of doing that is to check whether (x - x) != (x - x).
1) Have you tried adding 2 float-max values together to see what you
get? It's not a negative (on most platforms, at least). IEEE
floating-point has "infinities".
2) That method doesn't even work for integers, since overflow in
signed addition is undefined, and compilers will, correctly, remove
the check as impossible.
If you’re talking about compile-time arithmetic, you should be using the APFloat library, which figures this out for you.
i know that the result is infinte, but there are sill flags in the FPU which indicate that an overflow, underflow or div by zero occured.
So isn’t there an easy way to check if one of those flags is set?
2010/7/23 John McCall <firstname.lastname@example.org>
I don't think so; we probably don't select those instructions at all. I'm not sure what the best way to select them would be, to be honest; maybe a processor-specific intrinsic. I'd suggest filing a bug.