[InstCombine] Add missing commute handling to (A | B) & (B ^ (~A)) -> (A & B)

[craig.topper]

Summary

The matching here wasn't able to handle all the possible commutes. It always assumed the not would be on the left of the xor, but that's not guaranteed.

[spatel]

LGTM.

lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

if (Instruction *DeMorgan = matchDeMorgansLaws(I, Builder))
 
     // ((A ^ C) ^ B) & (B ^ A) -> (B ^ A) & ~C
     if (match(Op0, m_Xor(m_Xor(m_Value(A), m_Value(C)), m_Value(B))))
       if (match(Op1, m_Xor(m_Specific(B), m_Specific(A))))
         if (Op0->hasOneUse() || cast<BinaryOperator>(Op0)->hasOneUse())
           return BinaryOperator::CreateAnd(Op1, Builder->CreateNot(C));
 
     // (A | B) & ((~A) ^ B) -> (A & B)
-    if (match(Op0, m_Or(m_Value(A), m_Value(B))) &&
-        match(Op1, m_Xor(m_Not(m_Specific(A)), m_Specific(B))))
+    // (A | B) & (B ^ (~A)) -> (A & B)
+    // (B | A) & ((~A) ^ B) -> (A & B)
+    // (B | A) & (B ^ (~A)) -> (A & B)
+    if (match(Op1, m_c_Xor(m_Not(m_Value(A)), m_Value(B))) &&
+        match(Op0, m_c_Or(m_Specific(A), m_Specific(B))))
       return BinaryOperator::CreateAnd(A, B);
 
     // ((~A) ^ B) & (A | B) -> (A & B)
     // ((~A) ^ B) & (B | A) -> (A & B)
-    if (match(Op0, m_Xor(m_Not(m_Value(A)), m_Value(B))) &&
+    // (B ^ (~A)) & (A | B) -> (A & B)
+    // (B ^ (~A)) & (B | A) -> (A & B)
+    if (match(Op0, m_c_Xor(m_Not(m_Value(A)), m_Value(B))) &&
         match(Op1, m_c_Or(m_Specific(A), m_Specific(B))))
       return BinaryOperator::CreateAnd(A, B);
   }
 
   {
     ICmpInst *LHS = dyn_cast<ICmpInst>(Op0);
     ICmpInst *RHS = dyn_cast<ICmpInst>(Op1);
     if (LHS && RHS)

test/Transforms/InstCombine/and.ll

final:
   %A = phi <2 x i32> [ <i32 1000, i32 2500>, %entry ], [ <i32 10, i32 30>, %delay ]
   %value = and <2 x i32> %A, <i32 123, i32 333>
   ret <2 x i32> %value
 }
 
 define i32 @test42(i32 %a, i32 %c, i32 %d) {
 ; CHECK-LABEL: @test42(
 ; CHECK-NEXT:    [[FORCE:%.*]] = mul i32 [[C:%.*]], [[D:%.*]]
-; CHECK-NEXT:    [[OR:%.*]] = or i32 [[FORCE]], [[A:%.*]]
-; CHECK-NEXT:    [[NOTA:%.*]] = xor i32 [[A]], -1
-; CHECK-NEXT:    [[XOR:%.*]] = xor i32 [[FORCE]], [[NOTA]]
-; CHECK-NEXT:    [[AND:%.*]] = and i32 [[XOR]], [[OR]]
+; CHECK-NEXT:    [[AND:%.*]] = and i32 [[FORCE]], [[A:%.*]]
 ; CHECK-NEXT:    ret i32 [[AND]]
 ;
   %force = mul i32 %c, %d ; forces the complexity sorting
   %or = or i32 %a, %force
   %nota = xor i32 %a, -1
   %xor = xor i32 %nota, %force
   %and = and i32 %xor, %or
   ret i32 %and
 }
 
 define i32 @test43(i32 %a, i32 %c, i32 %d) {
 ; CHECK-LABEL: @test43(
 ; CHECK-NEXT:    [[FORCE:%.*]] = mul i32 [[C:%.*]], [[D:%.*]]
-; CHECK-NEXT:    [[OR:%.*]] = or i32 [[FORCE]], [[A:%.*]]
-; CHECK-NEXT:    [[NOTA:%.*]] = xor i32 [[A]], -1
-; CHECK-NEXT:    [[XOR:%.*]] = xor i32 [[FORCE]], [[NOTA]]
-; CHECK-NEXT:    [[AND:%.*]] = and i32 [[OR]], [[XOR]]
+; CHECK-NEXT:    [[AND:%.*]] = and i32 [[FORCE]], [[A:%.*]]
 ; CHECK-NEXT:    ret i32 [[AND]]
 ;
   %force = mul i32 %c, %d ; forces the complexity sorting
   %or = or i32 %a, %force
   %nota = xor i32 %a, -1
   %xor = xor i32 %nota, %force
   %and = and i32 %or, %xor
   ret i32 %and
 }