Do empty statements evaluate to NOP?

Question

I'm wondering if empty statements (i.e. null statements) evaluate to NOP or if it's compiler dependent.

// Trivial example
int main()
{
    ;;
}

Answer 1

It's compiler dependent but the observable behaviour must be that nothing happens. In practice, I'm sure most compilers will emit no code at all for an empty expression.

A conforming implementation executing a well-formed program shall produce the same observable behavior as one of the possible executions of the corresponding instance of the abstract machine with the same program and the same input.

And the observable behaviour is defined by:

The least requirements on a conforming implementation are:

• Access to volatile objects are evaluated strictly according to the rules of the abstract machine.
• At program termination, all data written into files shall be identical to one of the possible results that execution of the program according to the abstract semantics would have produced.
• The input and output dynamics of interactive devices shall take place in such a fashion that prompting output is actually delivered before a program waits for input. What constitutes an interactive device is implementation-defined.

These collectively are referred to as the observable behavior of the program.

This is really the only requirement for an implementation. It is often known as the "as-if" rule - the compiler can do whatever it likes as long as the observable behaviour is as expected.

For what it's worth, these empty expressions are known as null statements:

An expression statement with the expression missing is called a null statement.

If you really want a NOP, you can try:

asm("nop");

This is, however, conditionally supported and its behaviour is implementation-defined.

Answer 2

or if it's compiler dependent.

It is compiler-dependent ("as-if rule"), but most reasonable optimizing compilers will just ignore empty statements for the sake of efficiency, and they generally won't emit NOP instructions.