Program behaving strangely on online IDEs

by

I’m going to assume that the online compilers use GCC or compatible compiler. Of course, any other compiler is also allowed to do the same optimization, but GCC documentation explains well what it does:

-faggressive-loop-optimizations

This option tells the loop optimizer to use language constraints to derive bounds for the number of iterations of a loop. This assumes that loop code does not invoke undefined behavior by for example causing signed integer overflows or out-of-bound array accesses. The bounds for the number of iterations of a loop are used to guide loop unrolling and peeling and loop exit test optimizations. This option is enabled by default.

This option merely allows making assumptions based on cases where UB is proven. To take advantage of those assumptions, other optimizations may need to be enabled, such as constant folding.

Signed integer overflow has undefined behaviour. The optimizer was able to prove that any value of i greater than 173 would cause UB, and because it can assume that there is no UB, it can also assume that i is never greater than 173. It can then further prove that i < 300 is always true, and so the loop condition can be optimized away.

Why 4169 and not some other value?

Those sites probably limit the number of output lines (or characters or bytes) they show and happen to share the same limit.

More Related Contents:

  1. Why is unsigned integer overflow defined behavior but signed integer overflow isn’t?
  2. Is signed integer overflow still undefined behavior in C++?
  3. Detecting signed overflow in C/C++
  4. How disastrous is integer overflow in C++?
  5. What is the strict aliasing rule?
  6. How do I detect unsigned integer overflow?
  7. C++ delete – It deletes my objects but I can still access the data?
  8. Do I need to cast to unsigned char before calling toupper(), tolower(), et al.?
  9. Is uninitialized local variable the fastest random number generator?
  10. May I treat a 2D array as a contiguous 1D array?
  11. Undefined behavior and sequence points reloaded
  12. Why do constant expressions have an exclusion for undefined behavior?
  13. How is a variable at the same address producing 2 different values? [duplicate]
  14. Why dereferencing a null pointer is undefined behaviour?
  15. Why is out-of-bounds pointer arithmetic undefined behaviour?
  16. Why is initialization of a new variable by itself valid? [duplicate]
  17. Is this infinite recursion UB?
  18. Efficient unsigned-to-signed cast avoiding implementation-defined behavior
  19. Addition of two chars produces int
  20. How to handle arbitrarily large integers
  21. Division by zero: Undefined Behavior or Implementation Defined in C and/or C++?
  22. Implementing a std::vector like container without undefined behavior
  23. new() without delete() is Undefined Behavior or merely Memory Leak? [duplicate]
  24. Why does printf(“%f”,0); give undefined behavior?
  25. At what point does dereferencing the null pointer become undefined behavior?
  26. Setting extra bits in a bool makes it true and false at the same time
  27. When a float variable goes out of the float limits, what happens?
  28. Dangling references and undefined behavior
  29. Is there some meaningful statistical data to justify keeping signed integer arithmetic overflow undefined?
  30. Can undefined behavior erase the hard drive?

Leave a Comment