Hacker News Reader

Comment by plorkyeran | Hacker News Reader

It's still fundamentally a misunderstanding of what the compiler is doing, and thinking about it that way is just going out of your way to cause confusion. The compiler saw a use of an uninitialized value, concluded that it must not be reachable as that's the only way for it to be a legal C program, and then deleted the dead code. You can make up all sorts of other behaviors that the compiler could have done which would have had the same result in a specific scenario, but why would you?

View on HN

I don't think the author misunderstands what the compiler is doing, just saying that it's probably unexpected behavior from the perspective of the program's author.

I don't think that the compiler approach is try and fix the code

> it must not be reachable as that's the only way for it to be a legal C program, and then deleted the dead code.

Rather it would make more sense if the approach was more like "this branch is UB so I can whatever is most convenient in terms of optimization" in this case it was merging the 2 branches but discarding the code for the UB branch.

But from a behavioral point of view all these formulations describe the same result

The compiler isn't trying to "fix" anything and I'm not sure where that idea came from. The core concept is that the compiler assumes the program is valid and optimizes based on that assumption. If UB would occur if certain values are passed as an argument to a function, the compiler assumes that those values won't be passed. If UB occurs unconditionally in a function, the compiler assumes that the function won't be called.

> The core concept is that the compiler assumes the program is valid

I was referring to this.

IIRC the spec language is that the compiler is free to assume that UB never happens, but from an operational perspective I believe that the compiler simply stop caring about those cases.

by this I mean that for code like

    #include <stdio.h>

    int main() {
        printf("Hello, ");
        0/0;
        *(NULL);
        printf("World!\n");
        return 0;
    }

most compiler will just pretend that bad lines did not exists

https://godbolt.org/#z:OYLghAFBqd5TKALEBjA9gEwKYFFMCWALugE4A...

The compiler is not trying to fix your program. It is just assuming that somehow those lines are never hit, and then is deleting the dead code to make your binary smaller.

I agree, I was only disagreeing with this view:

> > The core concept is that the compiler assumes the program is valid

I believe that it is more correct to say that the compiler is unrestricted in what it does with UB, so it handles it in the most convenient way (often toward optimizing binary size, runtime performance, and/or compilation time)

By reductio ad absurdum assuming that the program is valid would give the same behaviour. I just believe that it is not what happens operatively.

Reply on news.ycombinator.com