What is the explanation for “warning: assuming that the loop is not infinite”

Question

I had just taken the decision to change as many variables from unsigned to int and upon recompiling the code in question, was greeted by this warning m

Answer 1

The reason GCC warns you is because it have pulled of an unsafe optimization. Instead of

for (x = startx; x <= endx; ++x, ++xptr)

it basically uses:

for( x = startx; x < (endx+1); ++x, ++xptr)

which is correct only if endx+1 doesn't overflow, but this happens when endx is the largest possible value which means that x <= endx is always true. The compiler assumes that this doesn't happen.

The warning is sometimes a bit confusing because it's not actually the finiteness of the loop that is the point here. I don't know if there's a better candidate for a message that would be short enough for a compiler warning.

One example is the case where for example x and endx are integers the optimization could actually be interpreted as being allowed by the standard, if endx==MAX_INT you would have the condition being true which will lead to that x eventually overflows which is undefined behavior, this mean that the compiler may assume that this doesn't happen. To skip the loop entirely is a standard conforming behavior according to this interpretations.

Another case is if the program doesn't terminate during the loop or alters volatile memory (ie have observable behavior) which means that an infinite loop means undefined behavior (IIRC, at least the compiler is allowed to assume that this doesn't happen).

Answer 2

According to this GCC patch from 2005, it appears that GCC is performing an "unsafe loop optimization" (and you are being warned because -funsafe-loop-optimizations is set). If the loop is infinite, this particular optimization will fail somehow.

Since you said it is a terminating loop, it sounds as though you have nothing to worry about.

Another relevant part of the patch:

@opindex Wunsafe-loop-optimizations
Warn if the loop cannot be optimized because the compiler could not
assume anything on the bounds of the loop indices.  With
@option{-funsafe-loop-optimizations} warn if the compiler made
+such assumptions.

Answer 3

I think that GCC is telling you that it can't determine that the loop is not infinite and is carrying on with compilation regardless. It's a warning, not an error, something you may want to think about.