Does not CSE b&c in a&b&c

[Alcaro]

// Type your code here, or load an example.
void square(unsigned board, unsigned& e, unsigned& f) {
    unsigned a = (board >> 1) & board;
    unsigned b = (board >> 5) & board;
    unsigned c = (board << 5) & board;
    e = (b&c);
    f = (a&b&c);
}
void cube(unsigned board, unsigned& e, unsigned& f) {
    unsigned a = (board >> 1) & board;
    unsigned b = (board >> 5) & board;
    unsigned c = (board << 5) & board;
    e = (b&c);
    f = (a&(b&c));
}

https://godbolt.org/z/YvKoW8jza

Expected: Since the only difference is an extra paren on the f line, the b&c should be deemed a common subexpression and deduplicated

Actual:

square(unsigned int, unsigned int&, unsigned int&):
        mov     eax, edi
        shr     eax
        mov     ecx, edi
        shl     ecx, 5
        mov     r8d, ecx
        and     r8d, edi
        and     eax, edi
        shr     edi, 5
        and     r8d, edi
        mov     dword ptr [rsi], r8d
        and     ecx, edi
        and     ecx, eax
        mov     dword ptr [rdx], ecx
        ret

cube(unsigned int, unsigned int&, unsigned int&):
        mov     eax, edi
        shr     eax, 5
        mov     ecx, edi
        shl     ecx, 5
        and     ecx, eax
        and     ecx, edi
        shr     edi
        mov     dword ptr [rsi], ecx
        and     ecx, edi
        mov     dword ptr [rdx], ecx
        ret

[antoniofrighetto]

Different ASTs for the two snippets lead to different IRs, which looks as follows for the second function:

define void @square(i32 noundef %board, ptr noundef %e, ptr noundef %f) {
entry:
  %shr = lshr i32 %board, 1
  %shr1 = lshr i32 %board, 5
  %shl = shl i32 %board, 5
  %and3 = and i32 %shl, %board
  %and4 = and i32 %and3, %shr1
  store i32 %and4, ptr %f, align 4
  %0 = and i32 %shr, %board
  %and5 = and i32 %0, %shr1
  %and6 = and i32 %and5, %shl
  store i32 %and6, ptr %e, align 4
  ret void
}

Instructions are not the same, so they cannot be CSE'd easily here. For the three ands at the end, we don't leverage knowledge of %and4 and %and3. @nikic Any suggestion on where this knowledge can be propagated? I'd say GVN, but maybe I'm losing something in ValueTracking / InstSimplify.

[nikic]

Possibly Reassociate if we can produce some kind of canonical reassociation?