[InstCombine] Add one use checks to or/and->xnor folding

[craig.topper]

Summary

If the components of the and/or have multiple uses this transform creates an additional instruction.

This patch makes sure we remove one of the components.

[spatel]

LGTM - although the test file was not updated here in the uploaded patch?

llvm/trunk/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

static Instruction *foldAndToXor(BinaryOperator &I,
   if (match(Op0, m_Or(m_Value(A), m_Value(B))) &&
       match(Op1, m_Not(m_c_And(m_Specific(A), m_Specific(B)))))
     return BinaryOperator::CreateXor(A, B);
 
   // (A | ~B) & (~A | B) --> ~(A ^ B)
   // (A | ~B) & (B | ~A) --> ~(A ^ B)
   // (~B | A) & (~A | B) --> ~(A ^ B)
   // (~B | A) & (B | ~A) --> ~(A ^ B)
+  if (Op0->hasOneUse() || Op1->hasOneUse())
     if (match(Op0, m_c_Or(m_Value(A), m_Not(m_Value(B)))) &&
         match(Op1, m_c_Or(m_Not(m_Specific(A)), m_Specific(B))))
       return BinaryOperator::CreateNot(Builder.CreateXor(A, B));
 
   return nullptr;
 }
 
 static Instruction *foldOrToXor(BinaryOperator &I,
                                 InstCombiner::BuilderTy &Builder) {
   assert(I.getOpcode() == Instruction::Or);
   Value *Op0 = I.getOperand(0);
   Value *Op1 = I.getOperand(1);
   Value *A, *B;
 
   // Operand complexity canonicalization guarantees that the 'and' is Op0.
   // (A & B) | ~(A | B) --> ~(A ^ B)
   // (A & B) | ~(B | A) --> ~(A ^ B)
+  if (Op0->hasOneUse() || Op1->hasOneUse())
     if (match(Op0, m_And(m_Value(A), m_Value(B))) &&
         match(Op1, m_Not(m_c_Or(m_Specific(A), m_Specific(B)))))
       return BinaryOperator::CreateNot(Builder.CreateXor(A, B));
 
   // (A & ~B) | (~A & B) --> A ^ B
   // (A & ~B) | (B & ~A) --> A ^ B
   // (~B & A) | (~A & B) --> A ^ B
   // (~B & A) | (B & ~A) --> A ^ B
   if (match(Op0, m_c_And(m_Value(A), m_Not(m_Value(B)))) &&
       match(Op1, m_c_And(m_Not(m_Specific(A)), m_Specific(B))))
     return BinaryOperator::CreateXor(A, B);

llvm/trunk/test/Transforms/InstCombine/and-or-not.ll

 define i32 @and_to_nxor_multiuse(float %fa, float %fb) {
 ; CHECK-LABEL: @and_to_nxor_multiuse(
 ; CHECK-NEXT:    [[A:%.*]] = fptosi float [[FA:%.*]] to i32
 ; CHECK-NEXT:    [[B:%.*]] = fptosi float [[FB:%.*]] to i32
 ; CHECK-NEXT:    [[NOTA:%.*]] = xor i32 [[A]], -1
 ; CHECK-NEXT:    [[NOTB:%.*]] = xor i32 [[B]], -1
 ; CHECK-NEXT:    [[OR1:%.*]] = or i32 [[NOTA]], [[B]]
 ; CHECK-NEXT:    [[OR2:%.*]] = or i32 [[NOTB]], [[A]]
-; CHECK-NEXT:    [[TMP1:%.*]] = xor i32 [[B]], [[A]]
-; CHECK-NEXT:    [[AND:%.*]] = xor i32 [[TMP1]], -1
+; CHECK-NEXT:    [[AND:%.*]] = and i32 [[OR1]], [[OR2]]
 ; CHECK-NEXT:    [[MUL1:%.*]] = mul i32 [[OR1]], [[OR2]]
 ; CHECK-NEXT:    [[MUL2:%.*]] = mul i32 [[MUL1]], [[AND]]
 ; CHECK-NEXT:    ret i32 [[MUL2]]
 ;
   %a = fptosi float %fa to i32
   %b = fptosi float %fb to i32
   %nota = xor i32 %a, -1
   %notb = xor i32 %b, -1
   %or1 = or i32 %nota, %b
   %or2 = or i32 %notb, %a
   %and = and i32 %or1, %or2
   %mul1 = mul i32 %or1, %or2 ; here to increase the use count of the inputs to the and
   %mul2 = mul i32 %mul1, %and
   ret i32 %mul2
 }
 
 ; (a & b) | ~(a | b) --> ~(a ^ b)
 ; TODO: this increases instrunction count if the pieces have additional users
 define i32 @or_to_nxor_multiuse(i32 %a, i32 %b) {
 ; CHECK-LABEL: @or_to_nxor_multiuse(
 ; CHECK-NEXT:    [[AND:%.*]] = and i32 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i32 [[A]], [[B]]
 ; CHECK-NEXT:    [[NOTOR:%.*]] = xor i32 [[OR]], -1
-; CHECK-NEXT:    [[TMP1:%.*]] = xor i32 [[A]], [[B]]
-; CHECK-NEXT:    [[OR2:%.*]] = xor i32 [[TMP1]], -1
+; CHECK-NEXT:    [[OR2:%.*]] = or i32 [[AND]], [[NOTOR]]
 ; CHECK-NEXT:    [[MUL1:%.*]] = mul i32 [[AND]], [[NOTOR]]
 ; CHECK-NEXT:    [[MUL2:%.*]] = mul i32 [[MUL1]], [[OR2]]
 ; CHECK-NEXT:    ret i32 [[MUL2]]
 ;
   %and = and i32 %a, %b
   %or = or i32 %a, %b
   %notor = xor i32 %or, -1
   %or2 = or i32 %and, %notor
   %mul1 = mul i32 %and, %notor ; here to increase the use count of the inputs to the or
   %mul2 = mul i32 %mul1, %or2
   ret i32 %mul2
 }