Inefficient code generation: bitwise AND of disjoint booleans from equal and bitwise AND may not be optimized to constant 0

[pmor13]

clang -O3 optimizes this code:

_Bool f1(char x)
{
    _Bool b1 = x == 4;
    _Bool b2 = x & 3;
    return b1 & b2;
}

to:

f1:
        xor     eax, eax
        ret

However, clang -O3 does not optimize this code:

_Bool f1(char x)
{
    _Bool b1 = x == 2;
    _Bool b2 = x & 1;
    return b1 & b2;
}

f1:
        cmp     dil, 2
        sete    al
        and     al, dil
        ret

Why?

Note: the & b1 & b2 is used intentionally. If && is used, then clang -O3 optimizes it to:

f1:
        xor     eax, eax
        ret

How it can be explained?

Extra: if #define LOGIC_AND is uncommitted here, then the whole program transfers into a no-op. Courtesy of Lundin.

[nikic]

IR test case: https://alive2.llvm.org/ce/z/qy4_Hc

[rotateright]

This seems likely to be fixed by changing an unusual canonicalization that converts 'trunc X to i1' into 'icmp ne (and X, 1), 0'.

Alternatively, we are missing narrowing transforms for bitwise logic ops when zexts are from different sizes:
https://alive2.llvm.org/ce/z/sYXMLA

[rotateright]

Should be fixed after:
b5a9361

But this example reveals several other potential missing transforms (DeMorgan with i1 + icmp, simplify based on range?), so it's possible that we still don't get optimal code for similar examples. If you still see problems, please do file another bug.