Item — HN Reader

It does not need to be able to rely on having the behavior that causes the bug to be visible. We just need tools that make the bug visible, e.g. the undefined behavior sanitizers. Those tools work extremely well for signed overflow, but not for unsigned, exactly because unsigned wraparound is defined and for this reason many programs use it. So you can not distinguish between intended wraparound and incorrect wraparound.

For this reason, signed overflow is essentially a solved problem, while unsigned wraparound will be the source for many interesting bugs - exactly because it is not UB!

1 comments

> We just need tools that make the bug visible, e.g. the undefined behavior sanitizers.

Does the compiler faithfully compile the source code with sanitizers? Of course not, so we still cannot rely on them.

> So you can not distinguish between intended wraparound and incorrect wraparound.

This is exactly why I implemented both types in my arithmetic. The one I used is the one I intended.

A compiler which compiles with a sanitizer can be perfectly conforming, i.e. faithfully compile a program.

That is not what I mean. I mean that the compiler follows the programmer's intent.

How would a compiler know the programmer's intent?