[InstCombine] Relax and reorganize one use checks in the ~(a | b) & c

[rampitec]

Summary

Since there is just a single check for LHS in ~(A | B) & C | ...
transforms and multiple RHS checks inside with more coming I am
removing m_OneUse checks for LHS and adding new checks for RHS.
This is non essential as long as there is total benefit.

In addition (~(A | B) & C) | (~(A | C) & B) --> (B ^ C) & ~A
checks were overly restrictive, it should be good without any
additional checks.

[spatel]

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

2661–2662

This isn't strong enough to prevent the transform from ending up with more instructions than we started with - we are creating 3 instructions, so we need to eliminate at least 2 intermediate values plus the final value.

I think we'd be ok if we have 2 m_OneUse checks in this match (similar to the transform above this).

Please add a test like this to confirm:

define i32 @or_and_not_not_2_extra_uses(i32 %a, i32 %b, i32 %c) {
  %or1 = or i32 %b, %a
  call void @use(i32 %or1)
  %not1 = xor i32 %or1, -1
  %or2 = or i32 %a, %c
  %not2 = xor i32 %or2, -1
  %and = and i32 %not2, %b
  call void @use(i32 %and)
  %or3 = or i32 %not1, %and
  ret i32 %or3
}

[rampitec]

Added one more m_OneUse.

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

2661–2662

Thanks for the catch!

[rampitec]

Fixed second pattern with m_OneUse.

[rampitec]

Rebased to precommited tests.

[spatel]

LGTM

llvm/test/Transforms/InstCombine/and-xor-or.ll

1715

Might want to put an explanatory comment on this test and/or add another test that shows that we have a use-limit in place, but it could be adjusted in the future to be more flexible.

[rampitec]

Added test comment and rebased.

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

Instruction *InstCombinerImpl::visitOr(BinaryOperator &I) {
   // ((B | C) & A) | B -> B | (A & C)
   if (match(Op0, m_And(m_Or(m_Specific(Op1), m_Value(C)), m_Value(A))))
     return BinaryOperator::CreateOr(Op1, Builder.CreateAnd(A, C));
 
   // (~(A | B) & C) | ... --> ...
   // TODO: One use checks are conservative. We just need to check that a total
   //       number of multiple used values does not exceed reduction
   //       in operations.
-  if (match(Op0, m_OneUse(m_c_And(m_OneUse(m_Not(m_Or(m_Value(A), m_Value(B)))),
-                                  m_Value(C))))) {
+  if (match(Op0, m_c_And(m_Not(m_Or(m_Value(A), m_Value(B))), m_Value(C)))) {
     // (~(A | B) & C) | (~(A | C) & B) --> (B ^ C) & ~A
     if (match(Op1, m_OneUse(m_c_And(
                        m_OneUse(m_Not(m_c_Or(m_Specific(A), m_Specific(C)))),
                        m_Specific(B))))) {
       Value *Xor = Builder.CreateXor(B, C);
       return BinaryOperator::CreateAnd(Xor, Builder.CreateNot(A));
     }
 
     // (~(A | B) & C) | (~(B | C) & A) --> (A ^ C) & ~B
     if (match(Op1, m_OneUse(m_c_And(
                        m_OneUse(m_Not(m_c_Or(m_Specific(B), m_Specific(C)))),
                        m_Specific(A))))) {
       Value *Xor = Builder.CreateXor(A, C);
       return BinaryOperator::CreateAnd(Xor, Builder.CreateNot(B));
     }
 
     // (~(A | B) & C) | ~(A | C) --> ~((B & C) | A)
-    if (match(Op1, m_Not(m_c_Or(m_Specific(A), m_Specific(C)))))
+    if (match(Op1,
+              m_OneUse(m_Not(m_OneUse(m_c_Or(m_Specific(A), m_Specific(C)))))))
       return BinaryOperator::CreateNot(
           Builder.CreateOr(Builder.CreateAnd(B, C), A));
 
     // (~(A | B) & C) | ~(B | C) --> ~((A & C) | B)
-    if (match(Op1, m_Not(m_c_Or(m_Specific(B), m_Specific(C)))))
+    if (match(Op1,
+              m_OneUse(m_Not(m_OneUse(m_c_Or(m_Specific(B), m_Specific(C)))))))
       return BinaryOperator::CreateNot(
           Builder.CreateOr(Builder.CreateAnd(A, C), B));
   }
 
   if (Instruction *DeMorgan = matchDeMorgansLaws(I, Builder))
     return DeMorgan;
 
   // Canonicalize xor to the RHS.

llvm/test/Transforms/InstCombine/and-xor-or.ll

;
   %or3 = or i32 %and1, %and2
   ret i32 %or3
 }
 
 define i32 @or_not_and_extra_not_use1(i32 %a, i32 %b, i32 %c) {
 ; CHECK-LABEL: @or_not_and_extra_not_use1(
 ; CHECK-NEXT:    [[OR1:%.*]] = or i32 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[NOT1:%.*]] = xor i32 [[OR1]], -1
-; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[NOT1]], [[C:%.*]]
-; CHECK-NEXT:    [[OR2:%.*]] = or i32 [[A]], [[C]]
-; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[OR2]], -1
-; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[NOT2]], [[B]]
-; CHECK-NEXT:    [[OR3:%.*]] = or i32 [[AND1]], [[AND2]]
+; CHECK-NEXT:    [[TMP1:%.*]] = xor i32 [[B]], [[C:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = xor i32 [[A]], -1
+; CHECK-NEXT:    [[OR3:%.*]] = and i32 [[TMP1]], [[TMP2]]
 ; CHECK-NEXT:    call void @use(i32 [[NOT1]])
 ; CHECK-NEXT:    ret i32 [[OR3]]
 ;
   %or1 = or i32 %a, %b
   %not1 = xor i32 %or1, -1
   %and1 = and i32 %not1, %c
   %or2 = or i32 %a, %c
   %not2 = xor i32 %or2, -1
;
   ret i32 %or3
 }
 
 define i32 @or_not_and_extra_and_use1(i32 %a, i32 %b, i32 %c) {
 ; CHECK-LABEL: @or_not_and_extra_and_use1(
 ; CHECK-NEXT:    [[OR1:%.*]] = or i32 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[NOT1:%.*]] = xor i32 [[OR1]], -1
 ; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[NOT1]], [[C:%.*]]
-; CHECK-NEXT:    [[OR2:%.*]] = or i32 [[A]], [[C]]
-; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[OR2]], -1
-; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[NOT2]], [[B]]
-; CHECK-NEXT:    [[OR3:%.*]] = or i32 [[AND1]], [[AND2]]
+; CHECK-NEXT:    [[TMP1:%.*]] = xor i32 [[B]], [[C]]
+; CHECK-NEXT:    [[TMP2:%.*]] = xor i32 [[A]], -1
+; CHECK-NEXT:    [[OR3:%.*]] = and i32 [[TMP1]], [[TMP2]]
 ; CHECK-NEXT:    call void @use(i32 [[AND1]])
 ; CHECK-NEXT:    ret i32 [[OR3]]
 ;
   %or1 = or i32 %a, %b
   %not1 = xor i32 %or1, -1
   %and1 = and i32 %not1, %c
   %or2 = or i32 %a, %c
   %not2 = xor i32 %or2, -1
;
   %or3 = or i32 %and, %not1
   ret i32 %or3
 }
 
 define i32 @or_and_not_not_extra_not_use1(i32 %a, i32 %b, i32 %c) {
 ; CHECK-LABEL: @or_and_not_not_extra_not_use1(
 ; CHECK-NEXT:    [[OR1:%.*]] = or i32 [[B:%.*]], [[A:%.*]]
 ; CHECK-NEXT:    [[NOT1:%.*]] = xor i32 [[OR1]], -1
-; CHECK-NEXT:    [[TMP1:%.*]] = and i32 [[C:%.*]], [[B]]
-; CHECK-NEXT:    [[TMP2:%.*]] = or i32 [[TMP1]], [[A]]
-; CHECK-NEXT:    [[OR3:%.*]] = xor i32 [[TMP2]], -1
+; CHECK-NEXT:    [[OR2:%.*]] = or i32 [[A]], [[C:%.*]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[OR2]], -1
+; CHECK-NEXT:    [[AND:%.*]] = and i32 [[NOT2]], [[B]]
+; CHECK-NEXT:    [[OR3:%.*]] = or i32 [[AND]], [[NOT1]]
 ; CHECK-NEXT:    call void @use(i32 [[NOT1]])
 ; CHECK-NEXT:    ret i32 [[OR3]]
 ;
   %or1 = or i32 %b, %a
   %not1 = xor i32 %or1, -1
   %or2 = or i32 %a, %c
   %not2 = xor i32 %or2, -1
   %and = and i32 %not2, %b
   %or3 = or i32 %and, %not1
   call void @use(i32 %not1)
   ret i32 %or3
 }
 
 define i32 @or_and_not_not_extra_not_use2(i32 %a, i32 %b, i32 %c) {
 ; CHECK-LABEL: @or_and_not_not_extra_not_use2(
-; CHECK-NEXT:    [[OR1:%.*]] = or i32 [[B:%.*]], [[A:%.*]]
-; CHECK-NEXT:    [[NOT1:%.*]] = xor i32 [[OR1]], -1
-; CHECK-NEXT:    [[OR2:%.*]] = or i32 [[A]], [[C:%.*]]
+; CHECK-NEXT:    [[OR2:%.*]] = or i32 [[A:%.*]], [[C:%.*]]
 ; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[OR2]], -1
-; CHECK-NEXT:    [[AND:%.*]] = and i32 [[NOT2]], [[B]]
-; CHECK-NEXT:    [[OR3:%.*]] = or i32 [[AND]], [[NOT1]]
+; CHECK-NEXT:    [[TMP1:%.*]] = and i32 [[C]], [[B:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = or i32 [[TMP1]], [[A]]
+; CHECK-NEXT:    [[OR3:%.*]] = xor i32 [[TMP2]], -1
 ; CHECK-NEXT:    call void @use(i32 [[NOT2]])
 ; CHECK-NEXT:    ret i32 [[OR3]]
 ;
   %or1 = or i32 %b, %a
   %not1 = xor i32 %or1, -1
   %or2 = or i32 %a, %c
   %not2 = xor i32 %or2, -1
   %and = and i32 %not2, %b
   %or3 = or i32 %and, %not1
   call void @use(i32 %not2)
   ret i32 %or3
 }
 
 define i32 @or_and_not_not_extra_and_use(i32 %a, i32 %b, i32 %c) {
 ; CHECK-LABEL: @or_and_not_not_extra_and_use(
-; CHECK-NEXT:    [[OR1:%.*]] = or i32 [[B:%.*]], [[A:%.*]]
-; CHECK-NEXT:    [[NOT1:%.*]] = xor i32 [[OR1]], -1
-; CHECK-NEXT:    [[OR2:%.*]] = or i32 [[A]], [[C:%.*]]
+; CHECK-NEXT:    [[OR2:%.*]] = or i32 [[A:%.*]], [[C:%.*]]
 ; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[OR2]], -1
-; CHECK-NEXT:    [[AND:%.*]] = and i32 [[NOT2]], [[B]]
-; CHECK-NEXT:    [[OR3:%.*]] = or i32 [[AND]], [[NOT1]]
+; CHECK-NEXT:    [[AND:%.*]] = and i32 [[NOT2]], [[B:%.*]]
+; CHECK-NEXT:    [[TMP1:%.*]] = and i32 [[C]], [[B]]
+; CHECK-NEXT:    [[TMP2:%.*]] = or i32 [[TMP1]], [[A]]
+; CHECK-NEXT:    [[OR3:%.*]] = xor i32 [[TMP2]], -1
 ; CHECK-NEXT:    call void @use(i32 [[AND]])
 ; CHECK-NEXT:    ret i32 [[OR3]]
 ;
   %or1 = or i32 %b, %a
   %not1 = xor i32 %or1, -1
   %or2 = or i32 %a, %c
   %not2 = xor i32 %or2, -1
   %and = and i32 %not2, %b
   %or3 = or i32 %and, %not1
   call void @use(i32 %and)
   ret i32 %or3
 }
 
 define i32 @or_and_not_not_extra_or_use1(i32 %a, i32 %b, i32 %c) {
 ; CHECK-LABEL: @or_and_not_not_extra_or_use1(
 ; CHECK-NEXT:    [[OR1:%.*]] = or i32 [[B:%.*]], [[A:%.*]]
-; CHECK-NEXT:    [[TMP1:%.*]] = and i32 [[C:%.*]], [[B]]
-; CHECK-NEXT:    [[TMP2:%.*]] = or i32 [[TMP1]], [[A]]
-; CHECK-NEXT:    [[OR3:%.*]] = xor i32 [[TMP2]], -1
+; CHECK-NEXT:    [[NOT1:%.*]] = xor i32 [[OR1]], -1
+; CHECK-NEXT:    [[OR2:%.*]] = or i32 [[A]], [[C:%.*]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[OR2]], -1
+; CHECK-NEXT:    [[AND:%.*]] = and i32 [[NOT2]], [[B]]
+; CHECK-NEXT:    [[OR3:%.*]] = or i32 [[AND]], [[NOT1]]
 ; CHECK-NEXT:    call void @use(i32 [[OR1]])
 ; CHECK-NEXT:    ret i32 [[OR3]]
 ;
   %or1 = or i32 %b, %a
   %not1 = xor i32 %or1, -1
   %or2 = or i32 %a, %c
   %not2 = xor i32 %or2, -1
   %and = and i32 %not2, %b
;
   %or2 = or i32 %a, %c
   %not2 = xor i32 %or2, -1
   %and = and i32 %not2, %b
   %or3 = or i32 %and, %not1
   call void @use(i32 %or2)
   ret i32 %or3
 }
 
+; Check the use limit. It can be adjusted in the future in terms of
+; LHS and RHS uses distribution to be more flexible.
 define i32 @or_and_not_not_2_extra_uses(i32 %a, i32 %b, i32 %c) {
 ; CHECK-LABEL: @or_and_not_not_2_extra_uses(
 ; CHECK-NEXT:    [[OR1:%.*]] = or i32 [[B:%.*]], [[A:%.*]]
 ; CHECK-NEXT:    call void @use(i32 [[OR1]])
 ; CHECK-NEXT:    [[NOT1:%.*]] = xor i32 [[OR1]], -1
 ; CHECK-NEXT:    [[OR2:%.*]] = or i32 [[A]], [[C:%.*]]
 ; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[OR2]], -1
 ; CHECK-NEXT:    [[AND:%.*]] = and i32 [[NOT2]], [[B]]
 ; CHECK-NEXT:    call void @use(i32 [[AND]])