__builtin_unreachable优化作用及brswap编译差异技术问询

Great question! Let's break this down step by step, with clear explanations for each part of your inquiry.

Why brswap doesn't optimize to the same mov-based swap as stdswap and rswap #

First, let's clarify the core differences in how the compiler interprets each function:

• stdswap uses std::swap, a well-known pattern the GCC optimizer immediately recognizes and maps to the optimal mov-based sequence. This is a direct, high-level hint for the compiler to generate efficient swap code.
• rswap uses __restrict, an explicit pointer aliasing annotation that tells the compiler the two reference parameters never point to the same memory location. This lets the compiler safely replace the XOR swap with a mov swap—since XOR's only theoretical benefit (avoiding a temporary register) is irrelevant here, and mov is more efficient (fewer instructions, no dependency chains from XOR operations).

For brswap, your __builtin_unreachable() tells the compiler the &x == &y branch will never execute, eliminating checks for overlapping pointers. However, the compiler's optimization pipeline doesn't automatically connect this control-flow hint to rewriting the XOR swap sequence. Here's why:
__restrict is a low-level aliasing guarantee processed early in optimization, while __builtin_unreachable() is a control-flow hint that's handled later. The compiler sees the XOR instructions as a valid (though less optimal) sequence, and doesn't rewrite them to mov unless it has an explicit aliasing guarantee like __restrict. The inferential leap from "this branch is unreachable" to "these pointers never alias" isn't a priority in GCC's current optimization passes for this specific pattern.

Can we make brswap optimize to the mov-based swap with __builtin_unreachable? #

Sort of, but it requires nudging the compiler to connect the unreachable branch to the aliasing guarantee. For newer GCC versions (12+), you might see the optimization if you restructure the code to make the non-aliasing intent more explicit, but __restrict remains the more reliable and direct way to get this result.

If you want to stick with __builtin_unreachable, try restructuring the code to force the compiler to recognize non-overlapping memory accesses:

void brswap(int& x, int& y) {
    if (&x == &y) __builtin_unreachable();
    // Explicit temporary makes the compiler prioritize mov-based swap
    int temp = x;
    x = y;
    y = temp;
}

This will compile to the same mov sequence as stdswap and rswap. If you keep the original XOR-based code, you may need a newer GCC release with improved alias analysis to infer non-aliasing from the unreachable branch.

What optimizations can __builtin_unreachable enable? #

__builtin_unreachable is a powerful hint that tells the compiler "this code path will never execute—optimize as if it doesn't exist". Key use cases include:

• Dead code elimination: The compiler removes any code only reachable through the unreachable path. For example, an if (false) branch with __builtin_unreachable() gets deleted entirely.
• Redundancy elimination: If you have a validity check followed by __builtin_unreachable() in the failure case, the compiler removes the check. Example:

  int safe_div(int a, int b) {
      if (b == 0) __builtin_unreachable();
      return a / b;
  }
  

  The compiler eliminates the b == 0 check entirely.
• Branch prediction optimization: The compiler marks adjacent branches as "always taken" or "never taken", helping the CPU's branch predictor make better decisions.
• Control flow simplification: Unreachable paths are removed, flattening control flow and enabling further optimizations like loop unrolling or instruction scheduling.
• Enum exhaustiveness checks: Adding __builtin_unreachable() to the default case of an enum switch tells the compiler all enum values are covered by cases. This lets it eliminate redundant checks and optimize the switch more effectively.
• Loop optimization: For loops with an never-false exit condition, __builtin_unreachable() in the exit branch helps the compiler unroll the loop or optimize it as an infinite loop (if intended).

内容的提问来源于stack exchange，提问作者Passer By