How Do Strict Aliasing Rules Affect Compiler Optimization in C/C Code?

Strict Aliasing Rules and Function Optimization

Consider the following function:

inline u64 Swap_64(u64 x)
{
    u64 tmp;
    (*(u32*)&tmp)       = Swap_32(*(((u32*)&x)+1));
    (*(((u32*)&tmp)+1)) = Swap_32(*(u32*) &x);

    return tmp;
}

While it may seem harmless, this code exhibits suspicious behavior when optimization is enabled. The compiler seems to "optimize away" the assignments to the temporary variable tmp. To understand why this happens, we must delve into the "strict aliasing rules."

Strict Aliasing

Strict aliasing rules dictate that accessing an object through a pointer of a different type is illegal, even if the pointers point to the same memory. This allows the compiler to assume that pointers of different types do not alias (overlap) and optimize accordingly. Consider the example provided in the question.

In Swap_64, tmp is of type u64, while x is of type u32. The compiler interprets &x as a pointer to a u32 object. According to strict aliasing rules, accessing that memory through a pointer to a u64 object (&tmp) is illegal.

Optimization and Undefined Behavior

When high-level optimization is enabled, the compiler notices that the assignments to tmp could be optimized out since the memory it points to is not actually being modified. This optimization is within the compiler's rights, as strict aliasing rules would allow it to assume that &x and &tmp point to different memory.

However, this optimization relies on the assumption that the memory pointed to by &x is not accessed through a pointer of a different type. By violating strict aliasing rules, the code introduces undefined behavior. The compiler is free to do whatever it wants in such scenarios, including seemingly harmless operations like optimizing away the assignments. Hence, when optimization is enabled, the code stops functioning as expected.

Solution

To resolve this issue, one must ensure that strict aliasing rules are not violated. One approach is to use a union to reinterpret the bits of x as a u64. This ensures that the same memory is accessed through the appropriate type, avoiding the violation of strict aliasing rules and allowing the code to function correctly even with optimizations enabled.

The above is the detailed content of How Do Strict Aliasing Rules Affect Compiler Optimization in C/C Code?. For more information, please follow other related articles on the PHP Chinese website!