[InstCombine] Transform `(icmp eq/ne (or x, C), x)` -> `(icmp eq/ne (and x, C), C)`

[goldstein.w.n]

Summary

This eliminates a use on x which can enable other transforms. As
well and is often easier to analyze than or.

Proof: https://alive2.llvm.org/ce/z/N4CcaK

[nikic]

Proof (note constants are always noundef): https://alive2.llvm.org/ce/z/N4CcaK

undef is a constant :) Or more typically in this context, a vector with undef elements.

[goldstein.w.n]

Add check for undef

[goldstein.w.n]

In D154139#4465123, @nikic wrote:

Proof (note constants are always noundef): https://alive2.llvm.org/ce/z/N4CcaK

undef is a constant :) Or more typically in this context, a vector with undef elements.

Oof, fixed.

[nikic]

I believe this has been obsoleted by the recently added icmp or folds?

[goldstein.w.n]

Yeah. Obsolete now.

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

if (match(Op1, m_Xor(m_Value(C), m_Value(D)))) {
       if (B == D)
         return new ICmpInst(Pred, A, C);
     }
   }
 
   // canoncalize:
   // (icmp eq/ne (and X, C), X)
   //    -> (icmp eq/ne (and X, ~C), 0)
-  {
+  // (icmp eq/ne (or X, C), X)
+  //    -> (icmp eq/ne (and X, C), C)
+  auto SimplifyBitwiseAndOrBitwiseOr =
+      [this, Pred](Value *BitwiseOp, Value *Operand) -> Instruction * {
     Constant *CMask;
-    A = nullptr;
-    if (match(Op0, m_OneUse(m_And(m_Specific(Op1), m_ImmConstant(CMask)))))
-      A = Op1;
-    else if (match(Op1, m_OneUse(m_And(m_Specific(Op0), m_ImmConstant(CMask)))))
-      A = Op0;
-    if (A)
-      return new ICmpInst(Pred, Builder.CreateAnd(A, Builder.CreateNot(CMask)),
-                          Constant::getNullValue(A->getType()));
-  }
+    if (!BitwiseOp->hasOneUse())
+      return nullptr;
+
+    if (match(BitwiseOp, m_And(m_Specific(Operand), m_ImmConstant(CMask))) &&
+        !CMask->containsUndefElement())
+      return new ICmpInst(Pred,
+                          Builder.CreateAnd(Operand, Builder.CreateNot(CMask)),
+                          Constant::getNullValue(Operand->getType()));
+    if (match(BitwiseOp, m_Or(m_Specific(Operand), m_ImmConstant(CMask))) &&
+        !CMask->containsUndefElement())
+      return new ICmpInst(Pred, Builder.CreateAnd(Operand, CMask), CMask);
+    return nullptr;
+  };
+
+  if (Instruction *R = SimplifyBitwiseAndOrBitwiseOr(Op0, Op1))
+    return R;
+  if (Instruction *R = SimplifyBitwiseAndOrBitwiseOr(Op1, Op0))
+    return R;
 
   if (match(Op1, m_Xor(m_Value(A), m_Value(B))) && (A == Op0 || B == Op0)) {
     // A == (A^B)  ->  B == 0
     Value *OtherVal = A == Op0 ? B : A;
     return new ICmpInst(Pred, OtherVal, Constant::getNullValue(A->getType()));
   }
 
   // (X&Z) == (Y&Z) -> (X^Y) & Z == 0

llvm/test/Transforms/InstCombine/icmp-or-x-with-x.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
 ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
 
 declare void @use.i8(i8)
 define i1 @fold_or_eq(i8 %x) {
 ; CHECK-LABEL: define i1 @fold_or_eq
 ; CHECK-SAME: (i8 [[X:%.*]]) {
-; CHECK-NEXT:    [[XO:%.*]] = or i8 [[X]], 123
-; CHECK-NEXT:    [[R:%.*]] = icmp eq i8 [[XO]], [[X]]
+; CHECK-NEXT:    [[TMP1:%.*]] = and i8 [[X]], 123
+; CHECK-NEXT:    [[R:%.*]] = icmp eq i8 [[TMP1]], 123
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
   %xo = or i8 %x, 123
   %r = icmp eq i8 %xo, %x
   ret i1 %r
 }
 
 define <2 x i1> @fold_or_ne(<2 x i8> %xx) {
 ; CHECK-LABEL: define <2 x i1> @fold_or_ne
 ; CHECK-SAME: (<2 x i8> [[XX:%.*]]) {
 ; CHECK-NEXT:    [[X:%.*]] = mul <2 x i8> [[XX]], [[XX]]
-; CHECK-NEXT:    [[XO:%.*]] = or <2 x i8> [[X]], <i8 123, i8 12>
-; CHECK-NEXT:    [[R:%.*]] = icmp ne <2 x i8> [[X]], [[XO]]
+; CHECK-NEXT:    [[TMP1:%.*]] = and <2 x i8> [[X]], <i8 123, i8 12>
+; CHECK-NEXT:    [[R:%.*]] = icmp ne <2 x i8> [[TMP1]], <i8 123, i8 12>
 ; CHECK-NEXT:    ret <2 x i1> [[R]]
 ;
   %x = mul <2 x i8> %xx, %xx
   %xo = or <2 x i8> %x, <i8 123, i8 12>
   %r = icmp ne <2 x i8> %x, %xo
   ret <2 x i1> %r
 }
 
;
   %xo = or <2 x i8> %x, <i8 123, i8 undef>
   %r = icmp ne <2 x i8> %x, %xo
   ret <2 x i1> %r
 }
 
 define <2 x i1> @fold_or_eq_with_poison(<2 x i8> %x) {
 ; CHECK-LABEL: define <2 x i1> @fold_or_eq_with_poison
 ; CHECK-SAME: (<2 x i8> [[X:%.*]]) {
-; CHECK-NEXT:    [[XO:%.*]] = or <2 x i8> [[X]], <i8 poison, i8 12>
-; CHECK-NEXT:    [[R:%.*]] = icmp eq <2 x i8> [[XO]], [[X]]
+; CHECK-NEXT:    [[TMP1:%.*]] = and <2 x i8> [[X]], <i8 poison, i8 12>
+; CHECK-NEXT:    [[R:%.*]] = icmp eq <2 x i8> [[TMP1]], <i8 poison, i8 12>
 ; CHECK-NEXT:    ret <2 x i1> [[R]]
 ;
   %xo = or <2 x i8> %x, <i8 poison, i8 12>
   %r = icmp eq <2 x i8> %x, %xo
   ret <2 x i1> %r
 }