[InstCombine] Optimised expressions in issue #97044

Author: yafet-a

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

@@ -3780,6 +3780,43 @@ 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)
+  {
+    Value *X, *Y, *Z;
+    Value *Term1, *Term2, *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);
+      return BinaryOperator::CreateNot(YOrZXorX);
+    }
+  }
+
+  // (Z & X) | ~((Y ^ X) | Z) -> ~((Y | Z) ^ X)
+  {
+    Value *X, *Y, *Z;
+    Value *ZAndX, *NotPattern;
+
+    if (match(&I, m_c_Or(m_Value(ZAndX), m_Value(NotPattern))) &&
+        match(ZAndX, m_c_And(m_Value(Z), m_Value(X)))) {
+      
+      Value *YXorXOrZ;
+      if (match(NotPattern, m_Not(m_Value(YXorXOrZ)))) {
+        Value *YXorX;
+        if (match(YXorXOrZ, m_c_Or(m_Value(YXorX), m_Specific(Z))) &&
+            match(YXorX, m_c_Xor(m_Value(Y), m_Specific(X)))) {
+          
+          Value *YOrZ = Builder.CreateOr(Y, Z);
+          Value *YOrZXorX = Builder.CreateXor(YOrZ, X);
+          return BinaryOperator::CreateNot(YOrZXorX);
+        }
+      }
+    }
+  }
+  
   Type *Ty = I.getType();
   if (Ty->isIntOrIntVectorTy(1)) {
     if (auto *SI0 = dyn_cast<SelectInst>(Op0)) {
@@ -5191,6 +5228,25 @@ Instruction *InstCombinerImpl::visitXor(BinaryOperator &I) {
     }
   }
 
+  // ((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)))) {
+      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)))) {
+          Value *YOrZ = Builder.CreateOr(Y, Z);
+          Value *YOrZXorX = Builder.CreateXor(YOrZ, X);
+          return BinaryOperator::CreateNot(YOrZXorX);
+        }
+      }
+    }
+  }
+
   if (auto *LHS = dyn_cast<ICmpInst>(I.getOperand(0)))
     if (auto *RHS = dyn_cast<ICmpInst>(I.getOperand(1)))
       if (Value *V = foldXorOfICmps(LHS, RHS, I))

llvm/test/Transforms/InstCombine/pr97044.ll

@@ -3,20 +3,9 @@
 ; Tests for GitHub issue #97044 - Boolean expression canonicalization
 define i32 @test0_4way_or(i32 %x, i32 %y, i32 %z) {
 ; CHECK-LABEL: @test0_4way_or(
-; CHECK-NEXT:    [[NOT:%.*]] = xor i32 [[Z:%.*]], -1
-; CHECK-NEXT:    [[AND:%.*]] = and i32 [[Y:%.*]], [[NOT]]
-; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[AND]], [[X:%.*]]
-; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[Y]], -1
-; CHECK-NEXT:    [[AND3:%.*]] = and i32 [[X]], [[NOT2]]
-; CHECK-NEXT:    [[AND4:%.*]] = and i32 [[AND3]], [[Z]]
-; CHECK-NEXT:    [[OR:%.*]] = or i32 [[AND1]], [[AND4]]
-; CHECK-NEXT:    [[AND7_DEMORGAN:%.*]] = or i32 [[X]], [[Y]]
-; CHECK-NEXT:    [[AND9_DEMORGAN:%.*]] = or i32 [[AND7_DEMORGAN]], [[Z]]
-; CHECK-NEXT:    [[AND9:%.*]] = xor i32 [[AND9_DEMORGAN]], -1
-; CHECK-NEXT:    [[OR10:%.*]] = or i32 [[OR]], [[AND9]]
-; CHECK-NEXT:    [[AND11:%.*]] = and i32 [[X]], [[Y]]
-; CHECK-NEXT:    [[AND12:%.*]] = and i32 [[AND11]], [[Z]]
-; CHECK-NEXT:    [[OR13:%.*]] = or i32 [[OR10]], [[AND12]]
+; CHECK-NEXT:    [[TMP1:%.*]] = or i32 [[Y:%.*]], [[Z:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = xor i32 [[TMP1]], [[X:%.*]]
+; CHECK-NEXT:    [[OR13:%.*]] = xor i32 [[TMP2]], -1
 ; CHECK-NEXT:    ret i32 [[OR13]]
 ;
   %not = xor i32 %z, -1
@@ -39,11 +28,9 @@ define i32 @test0_4way_or(i32 %x, i32 %y, i32 %z) {
 }
 define i32 @test1_xor_pattern(i32 %x, i32 %y, i32 %z) {
 ; CHECK-LABEL: @test1_xor_pattern(
-; CHECK-NEXT:    [[TMP1:%.*]] = xor i32 [[X:%.*]], [[Y:%.*]]
-; CHECK-NEXT:    [[AND4_DEMORGAN:%.*]] = or i32 [[TMP1]], [[Z:%.*]]
-; CHECK-NEXT:    [[AND8:%.*]] = and i32 [[Z]], [[X]]
-; CHECK-NEXT:    [[TMP2:%.*]] = xor i32 [[AND4_DEMORGAN]], -1
-; CHECK-NEXT:    [[XOR:%.*]] = or i32 [[AND8]], [[TMP2]]
+; CHECK-NEXT:    [[TMP1:%.*]] = or i32 [[Y:%.*]], [[Z:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = xor i32 [[TMP1]], [[X:%.*]]
+; CHECK-NEXT:    [[XOR:%.*]] = xor i32 [[TMP2]], -1
 ; CHECK-NEXT:    ret i32 [[XOR]]
 ;
   %not = xor i32 %z, -1
@@ -62,10 +49,10 @@ define i32 @test1_xor_pattern(i32 %x, i32 %y, i32 %z) {
 }
 define i32 @test2_nested_xor(i32 %x, i32 %y, i32 %z) {
 ; CHECK-LABEL: @test2_nested_xor(
-; CHECK-NEXT:    [[NOT7:%.*]] = xor i32 [[Y:%.*]], -1
-; CHECK-NEXT:    [[AND8:%.*]] = and i32 [[Z:%.*]], [[NOT7]]
-; CHECK-NEXT:    [[TMP1:%.*]] = xor i32 [[X:%.*]], [[AND8]]
-; CHECK-NEXT:    ret i32 [[TMP1]]
+; CHECK-NEXT:    [[TMP1:%.*]] = or i32 [[Y:%.*]], [[Z:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = xor i32 [[TMP1]], [[X:%.*]]
+; CHECK-NEXT:    [[TMP3:%.*]] = xor i32 [[TMP2]], [[Y]]
+; CHECK-NEXT:    ret i32 [[TMP3]]
 ;
   %and = and i32 %x, %y
   %not = xor i32 %x, -1