"Actually undefined behavior is defined. It is defined as undefined."

Glad you asked.

So consider the following code with corresponding assembly:

int i = 0;
loop:
int j = i;
j *= 123456789;
print(j)
i += 1;
if (i < 100)
    goto loop;

mov r1 0
loop:
mov ra r1
mul ra 123456789
call printf
add r1 1
cmp r1 100
jle loop

Multiplications are quite slow, so this code will be slow. Can we make it faster?

Well, we're actually only using i for one thing, namely to calculate j. We can clearly see that j == i * 123456789, so why not iterate over j instead?

int j = 0;
loop:
print(j);
j += 123456789;
if (j < 12345678900)
    goto loop;

mov ra 0
loop:
call print
add ra 123456789
cmp ra 12345678900
jle loop

We got rid of the multiplication, and shaved off a few instructions as well. But we also know that 12345678900 is larger than any 32 bit integer that fits inside the ra register, so j < 12345678900 will always return true:

int j = 0;
loop:
print(j);
j += 123456789;
goto loop;

mov ra 0
loop:
call print
add ra 123456789
jmp loop

Which gives us an infinite loop.

Both transformations (induction variable analysis and dead code elimination) are allowed to be performed by the compiler, because it assumes that overflows will not happen.

Did they fucking patch it?!

There goes my jerking material.

A standard compliant compiler is still perfectly allowed to generate an infinite loop for this code. Actually, if it does, you should be thankful that it didn't generate code that deletes your home directory and orders a nuclear strike on your neighborhood, because that wouldn't have been any less standard compliant.

Did you enable all optimizations?

lol no stdint.h