Is infinite loop still undefined behavior in C++ if it calls shared library?

by

There are a number of places where the language of the Standard gives compilers freedoms beyond what are required for useful optimizations, but which would instead provide compilers with ways to throw the Principle of Least Astonishment out the window. The way the rules about endless loops are written fits that category.

Most of the optimizations which would be facilitated by the rules about endless loops would be enabled by language which specified that the time required to execute a section of code, even if infinite, is not considered to be a side-effect that compilers are required to preserve. Such a rule would allow a compiler to omit any loop iterations which don’t have any direct side-effects and don’t modify values that are used elsewhere.

The Standard, however, goes beyond that. Given the code:

int foo(void)
{
  int x=0;
  do
  {
    x=functionWithNoSideEffects(x);
  } while(x != 23 && x != 42);
  return x;
}

a compiler that could show that functionWithNoSideEffects would never have
any defined side-effects and would never return 23 could replace the code for “foo” with “return 42;”. Even if the purpose of the program was to test whether functionWithNoSideEffects would ever return 42 (in which case having the generated code return 42 whether the function does or not would be unhelpful) the Standard would not require compilers to generate code to actually test that unless the loop included some kind of “side-effect”.

I’m not personally convinced that the value of having a rule that says that
if compilers can show that a loop can’t terminate without X being true, they
may regard X as being true whether or not there’s any means by which it
could be. Optimizations based on that principle seem popular, however.

More Related Contents:

  1. Undefined, unspecified and implementation-defined behavior
  2. Is segmentation fault actual undefined behavior when we refer to a non-static data-member
  3. Infinite loop with cin when typing string while a number is expected
  4. Is signed integer overflow still undefined behavior in C++?
  5. Uninitialized variable behaviour in C++
  6. Does the C++ standard allow for an uninitialized bool to crash a program?
  7. Detecting signed overflow in C/C++
  8. Is “for(;;)” faster than “while (true)”? If not, why do people use it?
  9. Multithreading program stuck in optimized mode but runs normally in -O0
  10. Why does this loop produce “warning: iteration 3u invokes undefined behavior” and output more than 4 lines?
  11. Why does integer overflow on x86 with GCC cause an infinite loop?
  12. Difference between Undefined Behavior and Ill-formed, no diagnostic message required
  13. Why is initialization of a new variable by itself valid? [duplicate]
  14. Using newly declared variable in initialization (int x = x+1)?
  15. Endless loop in C/C++ [closed]
  16. How to explain undefined behavior to know-it-all newbies?
  17. Is passing a C++ object into its own constructor legal?
  18. Does the ‘offsetof’ macro from invoke undefined behaviour?
  19. Why is it undefined behavior to delete[] an array of derived objects via a base pointer?
  20. Are multiple mutations of the same variable within initializer lists undefined behavior pre C++11
  21. Access array beyond the limit in C and C++ [duplicate]
  22. Division by zero: Undefined Behavior or Implementation Defined in C and/or C++?
  23. So why is i = ++i + 1 well-defined in C++11?
  24. Loop until integer input is in required range fails to work with non-digit character inputs
  25. Why is f(i = -1, i = -1) undefined behavior?
  26. Program behaving strangely on online IDEs
  27. Is left and right shifting negative integers defined behavior?
  28. Can different GCC dialects be linked together?
  29. Dangling references and undefined behavior
  30. Can undefined behavior erase the hard drive?

Leave a Comment