C++ compilation bug?

by

This is due to undefined behavior, you are accessing the array mc out of bounds on the last iteration of your loop. Some compilers may perform aggressive loop optimization around the assumptions of no undefined behavior. The logic would be similar to the following:

  • Accessing mc out of bounds is undefined behavior
  • Assume no undefined behavior
  • Therefore di < 4 is always true since otherwise mc[di] would invoke undefined behavior

gcc with optimization turned on and using the -fno-aggressive-loop-optimizations flag causes the infinite loop behavior to disappear(see it live). While a live example with optimization but without -fno-aggressive-loop-optimizations exhibits the infinite loop behavior you observe.

A godbolt live example of the code shows the di < 4 check is removed and replaced with and unconditional jmp:

jmp .L6

This is almost identical to the case outlined in GCC pre-4.8 Breaks Broken SPEC 2006 Benchmarks. The comments to this article are excellent and well worth the read. It notes that clang caught the case in the article using -fsanitize=undefined which I can not reproduce for this case but gcc using -fsanitize=undefined does (see it live). Probably the most infamous bug around an optimizer making an inference around undefined behavior is the Linux kernel null pointer check removal.

Although this is an aggressive optimizations, it is important to note that as the C++ standard says undefined behavior is:

behavior for which this International Standard imposes no requirements

Which essentially means anything is possible and it notes (emphasis mine):

[…]Permissible undefined behavior
ranges from ignoring the situation completely with unpredictable results, to behaving during translation or
program execution in a documented manner characteristic of the environment (with or without the issuance of
a diagnostic message), to terminating a translation or execution (with the issuance of a diagnostic message).[…]

In order to get a warning from gcc we need to move the cout outside the loop and then we see the following warning (see it live):

warning: iteration 3u invokes undefined behavior [-Waggressive-loop-optimizations]
     for(di=0; di<4;di++,delta=mc[di]){ }
     ^

which would have likely been sufficient to provide the OP with enough information to figure out what was going on. Inconsistency like this are typical of the types of behavior we can see with undefined behavior. To get a better understanding of why such waring can be inconsitent in the face of undefined behavior Why can’t you warn when optimizing based on undefined behavior? is a good read.

Note, -fno-aggressive-loop-optimizations is documented in the gcc 4.8 release notes.

More Related Contents:

  1. Why does this loop produce “warning: iteration 3u invokes undefined behavior” and output more than 4 lines?
  2. Why does integer overflow on x86 with GCC cause an infinite loop?
  3. Is right shift undefined behavior if the count is larger than the width of the type?
  4. Why does the enhanced GCC 6 optimizer break practical C++ code?
  5. Arithmetic right shift gives bogus result?
  6. Can different GCC dialects be linked together?
  7. Fun with uninitialized variables and compiler (GCC)
  8. Why is GCC saying multiple definitions of main? I have one main [closed]
  9. How does #include work in C++? [duplicate]
  10. GCC -fPIC option
  11. Using C++ library in C code
  12. What is __gxx_personality_v0 for?
  13. Does MinGW-w64 support std::thread out of the box when using the Win32 threading model?
  14. GCC style weak linking in Visual Studio?
  15. How to create a static library with g++?
  16. GCC C++ “Hello World” program -> .exe is 500kb big when compiled on Windows. How can I reduce its size?
  17. Linking libstdc++ statically: any gotchas?
  18. Error enabling openmp – “ld: library not found for -lgomp” and Clang errors
  19. C++ new operator thread safety in linux and gcc 4
  20. Linking g++ 4.8 to libstdc++
  21. Link errors using members in C++17
  22. Implementing a std::vector like container without undefined behavior
  23. GCC: Difference between -O3 and -Os
  24. Using bts assembly instruction with gcc compiler
  25. When a float variable goes out of the float limits, what happens?
  26. Dangling references and undefined behavior
  27. version `CXXABI_1.3.8′ not found (required by …) [duplicate]
  28. What information does GCC Profile Guided Optimization (PGO) collect and which optimizations use it?
  29. How to count clock cycles with RDTSC in GCC x86? [duplicate]
  30. How to assert if a std::mutex is locked?

Leave a Comment