A C++ implementation that detects undefined behavior?

by

This is a great question, but let me give an idea for why I think it might be impossible (or at least very hard) in general.

Presumably, such an implementation would almost be a C++ interpreter, or at least a compiler for something more like Lisp or Java. It would need to keep extra data for each pointer to ensure you did not perform arithmetic outside of an array or dereference something that was already freed or whatever.

Now, consider the following code:

int *p = new int;
delete p;
int *q = new int;

if (p == q)
    *p = 17;

Is the *p = 17 undefined behavior? On the one hand, it dereferences p after it has been freed. On the other hand, dereferencing q is fine and p == q…

But that is not really the point. The point is that whether the if evaluates to true at all depends on the details of the heap implementation, which can vary from implementation to implementation. So replace *p = 17 by some actual undefined behavior, and you have a program that might very well blow up on a normal compiler but run fine on your hypothetical “UB detector”. (A typical C++ implementation will use a LIFO free list, so the pointers have a good chance of being equal. A hypothetical “UB detector” might work more like a garbage collected language in order to detect use-after-free problems.)

Put another way, the existence of merely implementation-defined behavior makes it impossible to write a “UB detector” that works for all programs, I suspect.

That said, a project to create an “uber-strict C++ compiler” would be very interesting. Let me know if you want to start one. 🙂

More Related Contents:

  1. Undefined behavior and sequence points
  2. What are all the common undefined behaviours that a C++ programmer should know about? [closed]
  3. Accessing inactive union member and undefined behavior?
  4. When does invoking a member function on a null instance result in undefined behavior?
  5. Optimizing away a “while(1);” in C++0x
  6. Does initialization entail lvalue-to-rvalue conversion? Is `int x = x;` UB?
  7. Is `reinterpret_cast`ing between hardware SIMD vector pointer and the corresponding type an undefined behavior?
  8. What’s a proper way of type-punning a float to an int and vice-versa?
  9. Does “Undefined Behavior” really permit *anything* to happen? [duplicate]
  10. How could pairing new[] with delete possibly lead to memory leak only?
  11. Where exactly does C++ standard say dereferencing an uninitialized pointer is undefined behavior?
  12. Is right shift undefined behavior if the count is larger than the width of the type?
  13. May I take the address of the one-past-the-end element of an array? [duplicate]
  14. Are memory leaks “undefined behavior” class problem in C++?
  15. Are multiple mutations within initializer lists undefined behavior?
  16. Why does the enhanced GCC 6 optimizer break practical C++ code?
  17. Why is it that we can write outside of bounds in C?
  18. Why is f(i = -1, i = -1) undefined behavior?
  19. Does “undefined behaviour” extend to compile-time?
  20. Is infinite loop still undefined behavior in C++ if it calls shared library?
  21. Why is locking a std::mutex twice ‘Undefined Behaviour’?
  22. What is a dangling reference? [duplicate]
  23. Mixing class and struct
  24. Is there a platform or situation where dereferencing (but not using) a null pointer to make a null reference will behave badly?
  25. Is it allowed to cast away const on a const-defined object as long as it is not actually modified?
  26. Ramifications of C++20 requiring two’s complement
  27. Can branches with undefined behavior be assumed unreachable and optimized as dead code?
  28. How disastrous is integer overflow in C++?
  29. behavior of const_cast in C++ [duplicate]
  30. reinterpret_cast from object to first member

Leave a Comment