[clang] Constant "(a && 0)" not folded at -O0

[pbo-linaro]

While working on QEMU, we recently exposed a missed constant folding with clang -O0.

Given this code:
$ cat main.c

extern int f(void);
int main(int argc) {
  if (argc && 0)
    f();
}

$ clang -O0 main.c
/usr/bin/ld: /tmp/main-19bcf0.o: in function `main':
main.c:(.text+0x21): undefined reference to `f'

Since argc && 0 is always false, it could be expected (though not required by the standard) that branch is eliminated and thus, f should not be referenced. Some code on QEMU expect dead code elimination to happen, to not cross reference some symbols.
When changing condition to (0 && argc), the branch is removed as expected.

Original discussion on QEMU side: https://lore.kernel.org/qemu-devel/95b00393-bdd2-4db3-ac39-02a09f83b4d7@linaro.org/

[shafik]

Splitting code and console commands since otherwise it makes the github quick copy functionality useless.

[erichkeane]

THIS is the line where we give up: https://github.com/llvm/llvm-project/blob/main/clang/lib/AST/ExprConstant.cpp#L14158

We 'note side effects', which for the purposes of the short-cuts in EmitIfStmt, is sufficient to make us emit everything.

It seems to me that we could 'try harder' to figure out if the LHS there ACTUALLY had a side-effect and not set the side-effect state. We get into some work with DataRecursiveIntBinOpEvaluator::process to continue anyway, but by that point we've already set the side effect.

I suspect that bit of code is supposed to be pessimistic on 'side effect', so 'trying not hard enough' isn't a correctness problem. BUT I think we could try harder if we cared to.

That said, this is something that at O1 we figure out no problem in LLVM, so i'm not sure how much effort it is worth.

[pbo-linaro]

Thanks @erichkeane. To be fair, it's not a big problem, and we simply dealt with it by reordering the condition by hand.
Just thought it would be interesting to report, as it creates a difference with gcc behavior, which performs the folding even at -O0.

[erichkeane]

Thanks @erichkeane. To be fair, it's not a big problem, and we simply dealt with it by reordering the condition by hand. Just thought it would be interesting to report, as it creates a difference with gcc behavior, which performs the folding even at -O0.

Yep, appreciate the report! Hopefully this is something that someone makes some effort on, I'm sure we could be much better with our side-effect detection throughout ExprConstant.cpp