Conditional move (cmov / csel)

A conditional move writes one of two source values into a destination depending on a condition flag, without branching. x86 calls it cmov; AArch64 calls it csel (conditional select). Instead of jumping over a store, the CPU computes both candidate inputs, then the instruction commits the one the flag selects. Control flow stays straight — there is exactly one path through the loop.

The tradeoff

A conditional move is not free speed. It trades a possible pipeline flush for guaranteed work. A predicted-correct branch is nearly free: the CPU speculates past it and the speculation holds. A conditional move always does the same work regardless of the flag, so it never mispredicts, but it also never gets the "skip the other side" discount a well-predicted branch gives.

So the rule is about predictability:

• If the branch is easy to predict (nearly always taken, or nearly always not), a branch is faster — the predictor is right almost every time and the branch costs almost nothing.
• If the branch is a coin flip, a conditional move is faster — a real branch would mispredict roughly half the time, and each miss flushes the pipeline and re-fetches instructions.

Quicksort partitioning on random data is close to the worst case for a branch predictor: about half the elements fall each side of the pivot with no pattern. That is exactly where the branchless form pays off. See compiler-codegen-luck for a case where the same partition loop ran 6x faster once Clang emitted csel instead of a branch.

Who decides

The compiler picks between a branch and a conditional move at compile time, before it knows the data distribution, so it is guessing. The choice is also brittle: on LLVM it comes out of the SimplifyCFG pass matching a specific IR shape, and small, semantically irrelevant differences in how the source is written can flip the decision. GCC and Clang often disagree on the same code.

Where you know the branch is genuinely unpredictable, you can nudge the compiler. Clang has __builtin_unpredictable() to mark a condition as a coin flip. A ternary (p = cond ? a : b) frequently lowers to a conditional move but is not guaranteed to. When it matters, the reliable check is to read the generated assembly rather than trust the source shape. The deeper reason this is hard: whether a conditional move helps depends on runtime data the source cannot express, so no amount of source-level cleverness settles it on its own.

Conditional select is one entry in a much larger catalog of branchless integer tricks — saturating arithmetic, sign extraction, min/max without a compare-jump, division by a constant. Warren's hackers-delight is where those live, and reading it is the fastest way to recognize the shapes a compiler is reaching for when it emits something unexpected.