Clang 14及以上版本-O2下为何不对特定浮点运算做编译优化？

The change in Clang 14's behavior stems from a deliberate shift toward stricter adherence to IEEE 754 floating-point semantics, prioritizing mathematical correctness over aggressive algebraic optimizations.

Here's a clear breakdown:

• Prior Clang versions: The compiler would unconditionally apply algebraic identities like x - x = 0, even if this ignored edge cases where the identity fails (e.g., when x is NaN or infinity). This produced faster code but could lead to unexpected results in scenarios involving non-standard floating-point values.
• Clang 14 and later: The optimizer now avoids such transformations unless it can definitively prove they are safe for all possible values of x under IEEE 754 rules. In your code, while a*b is mathematically finite, the compiler doesn't track this exact property at compile time. It skips the x-x=0 simplification to avoid breaking cases where x might be NaN or infinity.
• Non-zero output explanation: The unexpected result you observe comes from runtime floating-point behavior. Even though a*b is finite, computations may use extended-precision registers (like x87's 80-bit format) where intermediate values have more precision than a 64-bit double. When these values are stored to memory and reloaded, tiny rounding differences can lead to a non-zero result when subtracted—though this is a quirk of runtime execution, not the compiler's optimization choice itself.

内容的提问来源于stack exchange，提问作者Maxim Rayskiy