Do (A == C1 || A == C2) -> (A & ~(C1 ^ C2)) == C1 rather than (A == C1 || A == C2) -> (A | (C1 ^ C2)) == C2 when C1 ^ C2 is a power of 2.

[deadalnix]

Summary

As per title.

[majnemer]

Both transforms are correct, what is the specific rationale behind this change?

[deadalnix]

I get a power of 2 as a constant rather than something full of ones, which lead to more compact codegen in some cases (depending on how the target encode constant in the instruction stream).

[majnemer]

In D14223#278790, @deadalnix wrote:

I get a power of 2 as a constant rather than something full of ones, which lead to more compact codegen in some cases (depending on how the target encode constant in the instruction stream).

LGTM

[deadalnix]

Can we get this in ?

[deadalnix]

Rebase, also, can we get this merged ?

[deadalnix]

Rebased and ping whoever with merge right feels like merging this now that it is accepted ?

[mcrosier]

Committed in r254518.

lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

Value *InstCombiner::FoldOrOfICmps(ICmpInst *LHS, ICmpInst *RHS,
   switch (LHSCC) {
   default: llvm_unreachable("Unknown integer condition code!");
   case ICmpInst::ICMP_EQ:
     switch (RHSCC) {
     default: llvm_unreachable("Unknown integer condition code!");
     case ICmpInst::ICMP_EQ:
       if (LHS->getOperand(0) == RHS->getOperand(0)) {
         // if LHSCst and RHSCst differ only by one bit:
-        // (A == C1 || A == C2) -> (A & ~(C1 ^ C2)) == C1
+        // (A == C1 || A == C2) -> (A | (C1 ^ C2)) == C2
         assert(LHSCst->getValue().ule(LHSCst->getValue()));
 
         APInt Xor = LHSCst->getValue() ^ RHSCst->getValue();
         if (Xor.isPowerOf2()) {
-          Value *NegCst = Builder->getInt(~Xor);
-          Value *And = Builder->CreateAnd(LHS->getOperand(0), NegCst);
-          return Builder->CreateICmp(ICmpInst::ICMP_EQ, And, LHSCst);
+          Value *Cst = Builder->getInt(Xor);
+          Value *Or = Builder->CreateOr(LHS->getOperand(0), Cst);
+          return Builder->CreateICmp(ICmpInst::ICMP_EQ, Or, RHSCst);
         }
       }
 
       if (LHSCst == SubOne(RHSCst)) {
         // (X == 13 | X == 14) -> X-13 <u 2
         Constant *AddCST = ConstantExpr::getNeg(LHSCst);
         Value *Add = Builder->CreateAdd(Val, AddCST, Val->getName()+".off");
         AddCST = ConstantExpr::getSub(AddOne(RHSCst), LHSCst);

test/Transforms/InstCombine/icmp.ll

 define i1 @test68(i32 %x) nounwind uwtable {
   %and = and i32 %x, 127
   %cmp = icmp sgt i32 %and, 30
   ret i1 %cmp
 }
 
 ; PR14708
 ; CHECK-LABEL: @test69(
-; CHECK: %1 = and i32 %c, -33
-; CHECK: %2 = icmp eq i32 %1, 65
+; CHECK: %1 = or i32 %c, 32
+; CHECK: %2 = icmp eq i32 %1, 97
 ; CHECK: ret i1 %2
 define i1 @test69(i32 %c) nounwind uwtable {
   %1 = icmp eq i32 %c, 97
   %2 = icmp eq i32 %c, 65
   %3 = or i1 %1, %2
   ret i1 %3
 }
 

test/Transforms/InstCombine/load-cmp.ll

 
 define i1 @test8(i32 %X) {
   %P = getelementptr inbounds [10 x i16], [10 x i16]* @G16, i32 0, i32 %X
   %Q = load i16, i16* %P
   %R = and i16 %Q, 3
   %S = icmp eq i16 %R, 0
   ret i1 %S
 ; CHECK-LABEL: @test8(
-; CHECK-NEXT: and i32 %X, -2
-; CHECK-NEXT: icmp eq i32 {{.*}}, 8
+; CHECK-NEXT: or i32 %X, 1
+; CHECK-NEXT: icmp eq i32 {{.*}}, 9
 ; CHECK-NEXT: ret i1
 }
 
 @GA = internal constant [4 x { i32, i32 } ] [
   { i32, i32 } { i32 1, i32 0 },
   { i32, i32 } { i32 2, i32 1 },
   { i32, i32 } { i32 3, i32 1 },
   { i32, i32 } { i32 4, i32 0 }

test/Transforms/InstCombine/or.ll

 
 define i1 @test19(i32 %A) {
         %B = icmp eq i32 %A, 50
         %C = icmp eq i32 %A, 51
         ;; (A&-2) == 50
         %D = or i1 %B, %C
         ret i1 %D
 ; CHECK-LABEL: @test19(
-; CHECK: and i32
+; CHECK: or i32
 ; CHECK: icmp eq 
 ; CHECK: ret i1
 }
 
 define i32 @test20(i32 %x) {
         %y = and i32 %x, 123
         %z = or i32 %y, %x
         ret i32 %z