Protecting control dependencies with volatile_if()

The Linux kernel uses dependent READ_ONCE() in order to implement something akin to memory_order_consume. The assumption is that the compilers will never reorder instructions such as these due to there being a data dependency:

int* ptr = READ_ONCE(slot);
int value = READ_ONCE(ptr);

This article is about cases where there is no data dependency but there is a control dependency. AFAIK most weak-memory-model architectures respect such a dependency if there is a jump instruction in the middle, but the compiler must first not reorder the instructions itself and must actually generate a jump instruction (which is not always obvious as it could be lowered to a cmove-like instruction).

Regarding memory_order_consume (and [[carries_dependency]]), the problem is with ensuring that there is a dependency without involving the type system. If instead load(std::memory_order_consume) returned Dependent<T> and the compiler promised that loads using it are either data or control dependent on the original load then it would be a lot easier to define and implement. I think this is what the following is about:

http://wg21.link/P0750