Why can't an infinite loop be eliminated?

Question

The "as-if" rule is covered by these rules:

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.

... Accessing an object designated by a volatile glvalue (3.10), modifying an object, calling a library I/O function, or calling a function that does any of those operations are all side effects, which are changes in the state of the execution environment. ...

But let us take a program like the following:

while (1) { }
// or
for (;;) { }

The fact is there are no objects or calls to functions and therefore no side effects and therefore no "changes in state of the execution environment". What's preventing the compiler from compiling this code to

xorl    %eax, %eax
retq

Is it all that non-deterministic? An infinite loop is essentially "Here's a label, jump to it over and over" and will continue until the computer is shut off. The code does nothing interesting, no calculations, no I/O output, etc.

In kernel code, an infinite loop becomes interesting. But in userspace code, an infinite loop is generally a sign of a badly written program. So what's the flaw in my logic?

Answer 1

It can, because of [intro.multithread]/p27 (quoting N4140; this is p24 in N3337):

The implementation may assume that any thread will eventually do one of the following:

• terminate,
• make a call to a library I/O function,
• access or modify a volatile object, or
• perform a synchronization operation or an atomic operation.

Empty infinite loops are UB in C++11 and later.