[llvm] [InstCombine] Canoncalize complex boolean expressions into ~((y | z) ^ x) (PR #149530)

[via llvm-commits]

github-actions[bot] wrote:

<!--LLVM CODE FORMAT COMMENT: {clang-format}-->


:warning: C/C++ code formatter, clang-format found issues in your code. :warning:

<details>
<summary>
You can test this locally with the following command:
</summary>

``````````bash
git-clang-format --diff HEAD~1 HEAD --extensions cpp -- llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
``````````

</details>

<details>
<summary>
View the diff from clang-format here.
</summary>

``````````diff
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp b/llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
index 5d9bee7b3..4dc7e8893 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
@@ -2139,15 +2139,16 @@ static Instruction *foldComplexAndOrPatterns(BinaryOperator &I,
           X);
   }
 
-  // ((~Z) & ((X & Y) | (~X & ~Y))) ^ (Z & ((X & Y) | (X & ~Y))) -> ~((Y | Z) ^ X)
+  // ((~Z) & ((X & Y) | (~X & ~Y))) ^ (Z & ((X & Y) | (X & ~Y))) -> ~((Y | Z) ^
+  // X)
   {
     {
       Value *X, *Y, *Z;
       Value *SomethingOrZ, *ZAndX;
-      
+
       if (match(&I, m_c_Xor(m_Value(SomethingOrZ), m_Value(ZAndX))) &&
           match(ZAndX, m_And(m_Value(Z), m_Value(X))) &&
-          match(SomethingOrZ, m_Or(m_Value(), m_Specific(Z)))) {        
+          match(SomethingOrZ, m_Or(m_Value(), m_Specific(Z)))) {
         Value *Something;
         if (match(SomethingOrZ, m_Or(m_Value(Something), m_Specific(Z))) &&
             match(Something, m_Xor(m_Specific(X), m_Value(Y)))) {
@@ -2157,17 +2158,18 @@ static Instruction *foldComplexAndOrPatterns(BinaryOperator &I,
         }
       }
     }
-    
-    // ((X & Y) | (~X & ~Y)) ^ (Z & (((X & Y) | (~X & ~Y)) ^ ((X & Y) | (X & ~Y)))) -> ~((Y | Z) ^ X)
-    if (match(Op1, m_AllOnes())) {      
+
+    // ((X & Y) | (~X & ~Y)) ^ (Z & (((X & Y) | (~X & ~Y)) ^ ((X & Y) | (X &
+    // ~Y)))) -> ~((Y | Z) ^ X)
+    if (match(Op1, m_AllOnes())) {
       Value *X, *Y, *Z;
       Value *XorWithY;
-      if (match(Op0, m_Xor(m_Value(XorWithY), m_Value(Y)))) {        
+      if (match(Op0, m_Xor(m_Value(XorWithY), m_Value(Y)))) {
         Value *ZAndNotY;
-        if (match(XorWithY, m_Xor(m_Value(X), m_Value(ZAndNotY)))) {          
+        if (match(XorWithY, m_Xor(m_Value(X), m_Value(ZAndNotY)))) {
           Value *NotY;
           if (match(ZAndNotY, m_And(m_Value(Z), m_Value(NotY))) &&
-              match(NotY, m_Not(m_Specific(Y)))) {            
+              match(NotY, m_Not(m_Specific(Y)))) {
             Value *YOrZ = Builder.CreateOr(Y, Z);
             Value *YOrZXorX = Builder.CreateXor(YOrZ, X);
             return BinaryOperator::CreateNot(YOrZXorX);
@@ -3818,12 +3820,14 @@ Instruction *InstCombinerImpl::visitOr(BinaryOperator &I) {
     return replaceInstUsesWith(I, V);
 
   Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
-  
-  // ((X & Y & ~Z) | (X & ~Y & Z) | (~X & ~Y &~Z) | (X & Y &Z)) -> ~((Y | Z) ^ X)
+
+  // ((X & Y & ~Z) | (X & ~Y & Z) | (~X & ~Y &~Z) | (X & Y &Z)) -> ~((Y | Z) ^
+  // X)
   {
     Value *X, *Y, *Z;
     Value *Term1, *Term2, *XAndYAndZ;
-    if (match(&I, m_Or(m_Or(m_Value(Term1), m_Value(Term2)), m_Value(XAndYAndZ))) &&
+    if (match(&I,
+              m_Or(m_Or(m_Value(Term1), m_Value(Term2)), m_Value(XAndYAndZ))) &&
         match(XAndYAndZ, m_And(m_And(m_Value(X), m_Value(Y)), m_Value(Z)))) {
       Value *YOrZ = Builder.CreateOr(Y, Z);
       Value *YOrZXorX = Builder.CreateXor(YOrZ, X);

``````````

</details>


https://github.com/llvm/llvm-project/pull/149530