I've just found myself looking at a piece of C code like the
snippet given below. It's supposed to be adding two longs
and doing something special when the sum overflows.
Here a and b could have any value, but are likely to be small
in the common case. The snippet occurs in a fairly performance-
critical section of code.
long a, b, x;
...
x = a + b;
if ((x^a) < 0 && (x^b) < 0)
goto deal_with_overflow;
...
This code is wrong, I think, because it depends on undefined
behaviour. I'm wondering how best to rewrite it so that (a)
the replacement code is correct and portable C89, and (b)
there's a reasonable chance of gcc compiling it to efficient
assembler on common platforms.
A bullet-proof solution (valid even in the presence of ones'
complement machines, trap representations, etc.) is
something like:
if ((a >= 0 && 0UL + a > (unsigned long)LONG_MAX - b) ||
(a < 0 && 0UL - a > b - (unsigned long)LONG_MIN))
goto deal_with_overflow;
x = a + b;
but, not surprisingly, this generates rather inefficient assembler
(with gcc-4.4 -O3).
Any suggestions for improvements over this?
On x86 or x86-64, the optimal generated code would
presumably consist of just two instructions: an addition
followed by a jump-on-overflow. Unfortunately, using
inline assembly isn't really an option here. Are there
any common C code constructs that gcc would compile
to a jump-on-overflow instruction on x86?
Mark
