[InstCombine] Factor out a common pattern match used 3 times. NFC.

[rampitec]

Summary

This is needed for the next patch which will add more patterns
to the same match.

[rampitec]

ping

[spatel]

Making the caller pass a dummy seems awkward.
I don't have any suggestions to improve it, but adding some more potential reviewers.

[rampitec]

In D116194#3223354, @spatel wrote:

Making the caller pass a dummy seems awkward.
I don't have any suggestions to improve it, but adding some more potential reviewers.

I can pass a pointer with default null. Is that better?

[spatel]

In D116194#3223711, @rampitec wrote:

In D116194#3223354, @spatel wrote:

Making the caller pass a dummy seems awkward.
I don't have any suggestions to improve it, but adding some more potential reviewers.

I can pass a pointer with default null. Is that better?

Wouldn't it be a pointer to a pointer in that case?
Since we already have 'X' in the caller, we could just always pass 'X' instead of using 'Dummy' even if it is not used.
I don't have a strong opinion on it, so LGTM.
Although I am still hoping we can find an alternative to complicated (yet ultimately still fragile) pattern-matching that is trying to work around limits of reassociation and multi-use.

[rampitec]

In D116194#3225474, @spatel wrote:

In D116194#3223711, @rampitec wrote:

In D116194#3223354, @spatel wrote:

Making the caller pass a dummy seems awkward.
I don't have any suggestions to improve it, but adding some more potential reviewers.

I can pass a pointer with default null. Is that better?

Wouldn't it be a pointer to a pointer in that case?

Yes

Since we already have 'X' in the caller, we could just always pass 'X' instead of using 'Dummy' even if it is not used.

This will clobber X even if pattern is not matched, and then X is used later at line 1800.

I don't have a strong opinion on it, so LGTM.
Although I am still hoping we can find an alternative to complicated (yet ultimately still fragile) pattern-matching that is trying to work around limits of reassociation and multi-use.

I hope D114126 is a right answer to multi-use problem, although somewhat complex.

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

static Instruction *foldComplexAndOrPatterns(BinaryOperator &I,
   const Instruction::BinaryOps Opcode = I.getOpcode();
   assert(Opcode == Instruction::And || Opcode == Instruction::Or);
 
   // Flip the logic operation.
   const Instruction::BinaryOps FlippedOpcode =
       (Opcode == Instruction::And) ? Instruction::Or : Instruction::And;
 
   Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
-  Value *A, *B, *C, *X, *Y;
+  Value *A, *B, *C, *X, *Y, *Dummy;
+
+  // Match following expressions:
+  // (~(A | B) & C)
+  // (~(A & B) | C)
+  // Captures X = ~(A | B) or ~(A & B)
+  const auto matchNotOrAnd =
+      [Opcode, FlippedOpcode](Value *Op, auto m_A, auto m_B, auto m_C,
+                              Value *&X, bool CountUses = false) -> bool {
+    if (CountUses && !Op->hasOneUse())
+      return false;
+
+    if (match(Op, m_c_BinOp(FlippedOpcode,
+                            m_CombineAnd(m_Value(X),
+                                         m_Not(m_c_BinOp(Opcode, m_A, m_B))),
+                            m_C)))
+      return !CountUses || X->hasOneUse();
+
+    return false;
+  };
 
   // (~(A | B) & 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_c_BinOp(FlippedOpcode,
-                      m_CombineAnd(m_Value(X), m_Not(m_BinOp(Opcode, m_Value(A),
-                                                             m_Value(B)))),
-                      m_Value(C)))) {
+  if (matchNotOrAnd(Op0, m_Value(A), m_Value(B), m_Value(C), X)) {
     // (~(A | B) & C) | (~(A | C) & B) --> (B ^ C) & ~A
     // (~(A & B) | C) & (~(A & C) | B) --> ~((B ^ C) & A)
-    if (match(Op1,
-              m_OneUse(m_c_BinOp(FlippedOpcode,
-                                 m_OneUse(m_Not(m_c_BinOp(Opcode, m_Specific(A),
-                                                          m_Specific(C)))),
-                                 m_Specific(B))))) {
+    if (matchNotOrAnd(Op1, m_Specific(A), m_Specific(C), m_Specific(B), Dummy,
+                      true)) {
       Value *Xor = Builder.CreateXor(B, C);
       return (Opcode == Instruction::Or)
                  ? BinaryOperator::CreateAnd(Xor, Builder.CreateNot(A))
                  : BinaryOperator::CreateNot(Builder.CreateAnd(Xor, A));
     }
 
     // (~(A | B) & C) | (~(B | C) & A) --> (A ^ C) & ~B
     // (~(A & B) | C) & (~(B & C) | A) --> ~((A ^ C) & B)
-    if (match(Op1,
-              m_OneUse(m_c_BinOp(FlippedOpcode,
-                                 m_OneUse(m_Not(m_c_BinOp(Opcode, m_Specific(B),
-                                                          m_Specific(C)))),
-                                 m_Specific(A))))) {
+    if (matchNotOrAnd(Op1, m_Specific(B), m_Specific(C), m_Specific(A), Dummy,
+                      true)) {
       Value *Xor = Builder.CreateXor(A, C);
       return (Opcode == Instruction::Or)
                  ? BinaryOperator::CreateAnd(Xor, Builder.CreateNot(B))
                  : BinaryOperator::CreateNot(Builder.CreateAnd(Xor, B));
     }
 
     // (~(A | B) & C) | ~(A | C) --> ~((B & C) | A)
     // (~(A & B) | C) & ~(A & C) --> ~((B | C) & A)