Added InstCombine transform for pattern " ( ( A ^ B ) ^ ( ( ~A ) | B ) -> ( A | ( ~ B ) ) ".

[sonamkumari]

Summary

Hi All,

This patch implements transform for pattern " ( ( A ^ B ) ^ ( ( ~A ) | B ) -> ( A | ( ~ B ) ) ".

Z3 Link : http://rise4fun.com/Z3/jS88

Please help in reviewing the same.

David,

I tried to generalize the expression for " ( ~ A ) " by using " (A ^ C) " as you mentioned in few of my previous patches. But by doing that, I found the following result.

( ( A ^ B ) ^ ( ( A ^ C ) | B ) -> ( ( A & B) | ( ( ~B ) & C ) )

So, I think by doing this we are not reducing the number of operations. Am I thinking in the right direction.

Your inputs are highly welcomed. :)

Thanks,
Sonam.

[majnemer]

We actually do a better job CodeGen'ing the ((A & B) | ( ( ~B ) & C )) form, I think you should canonicalize to that form.

[majnemer]

Looking at it some more, the generalized from can be simplified.

(A ^ B) ^ ((A ^ C) | B) -> C ^ (B & (A ^ C))

This takes us from four binops to three binops.

[sonamkumari]

Hi David,

Thanks for your time and support. :)
I have modified the patch based on your review comments.
Kindly review it.Your comments are highly welcomed.

Regards,
Sonam.

[sonamkumari]

Gentle Ping !

[sonamkumari]

Gentle Ping !

[asl]

Please provide the information asked in other thread for similar pattern:

1. How often this transformation triggers in LLVM testsuite. Where, in which tests.
2. How often this transformation triggers in SPEC. Where, in which tests.

lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

if (Op0I && Op1I) {
     // (A & B) ^ (A ^ B) -> (A | B)
     if (match(Op0I, m_And(m_Value(A), m_Value(B))) &&
         match(Op1I, m_Xor(m_Specific(A), m_Specific(B))))
       return BinaryOperator::CreateOr(A, B);
     // (A ^ B) ^ (A & B) -> (A | B)
     if (match(Op0I, m_Xor(m_Value(A), m_Value(B))) &&
         match(Op1I, m_And(m_Specific(A), m_Specific(B))))
       return BinaryOperator::CreateOr(A, B);
+    // (A ^ B) ^ ((A ^ C) | B) -> C ^ (B & (A ^ C))
+    if (match(Op0I, m_Xor(m_Value(A), m_Value(B))) &&
+        match(Op1I, m_Or(m_Xor(m_Specific(A), m_Value(C)), m_Specific(B))))
+      return BinaryOperator::CreateXor(
+          C, Builder->CreateAnd(B, Builder->CreateXor(A, C)));
   }
 
   // (A | B)^(~A) -> (A | ~B)
   Value *A = nullptr, *B = nullptr;
   if (match(Op0, m_Or(m_Value(A), m_Value(B))) &&
       match(Op1, m_Not(m_Specific(A))))
     return BinaryOperator::CreateOr(A, Builder->CreateNot(B));
 

test/Transforms/InstCombine/xor2.ll

  %negb = xor i32 %b, -1
  %and = and i32 %a, %negb
  %xor = xor i32 %nega, %and
  ret i32 %xor
 ; CHECK-LABEL: @test14(
 ; CHECK-NEXT: %1 = and i32 %a, %b
 ; CHECK-NEXT: %xor = xor i32 %1, -1
 }
+
+; (A ^ B) ^ ((A ^ C) | B) -> C ^ (B & (A ^ C))
+define i32 @test15(i32 %a, i32 %b, i32 %c) {
+; CHECK-LABEL: test15(
+; CHECK-NEXT: %1 = xor i32 %a, %c
+; CHECK-NEXT: %2 = and i32 %1, %b
+; CHECK-NEXT: %xor2 = xor i32 %2, %c
+; CHECK-NEXT: ret i32 %xor2
+ %xor = xor i32 %a, %b
+ %xor1 = xor i32 %a, %c
+ %or = or i32 %xor1, %b
+ %xor2 = xor i32 %xor, %or
+ ret i32 %xor2
+}