Why Does Signed Integer Overflow on x86 with GCC Cause an Infinite Loop?

Integer Overflow on x86 with GCC Causing Infinite Loop

Introduction
In the following code snippet, integer overflow on x86 with GCC unexpectedly leads to an infinite loop instead of the expected wrapping behavior:

int i = 0x10000000;
do {
  i += i;
} while (i > 0);

Analysis
Integer arithmetic on x86 CPUs typically follows the wrap-around behavior of two's complement representation. However, in the aforementioned code, the signed integer overflow causes the program to enter an infinite loop.

The Issue
The undefined behavior of signed integer overflow allows for unpredictable results on x86. GCC assumes integers will not overflow and optimizes away the loop test. As a consequence, the loop continues indefinitely.

Observations

• The infinite loop occurs only with optimizations enabled (-O2).
• Disabling optimizations (-O0) results in correct behavior.
• Other variations (i *= 2) also fail, while i <<= 1 succeeds.

Explanation
When integer overflow occurs, the CPU's status flags are not updated. The compiler, assuming no overflow, doesn't check the flags and proceeds with the loop, leading to an infinite loop.

Resolution
To ensure the desired wraparound behavior, the compiler flag -fwrapv should be used. This flag enables well-defined integer overflow semantics but may have performance implications.

Conclusion
Signed integer overflow is undefined behavior and can lead to unpredictable outcomes. Compilers may optimize based on the assumption of no overflow, resulting in unexpected behavior. Using -fwrapv can enforce wraparound behavior but should be weighed against potential performance impacts.

The above is the detailed content of Why Does Signed Integer Overflow on x86 with GCC Cause an Infinite Loop?. For more information, please follow other related articles on the PHP Chinese website!