[InstCombine] Improve the expansion in SimplifyUsingDistributiveLaws to handle cases where one side doesn't simplify, but the other side resolves to an identity value

[craig.topper]

Summary

If one side simplifies to the identity value for inner opcode, we can replace the value with just the operation that can't be simplified.

I've removed a couple now unneeded special cases in visitAnd and visitOr. There are probably other cases I missed.

@spatel I believe this fixes your hidden not test cases with compares. If you send over your test cases I can add them to this patch.

[spatel]

betterdistribute.ll2 KBDownload

Thanks. I hadn't gotten to the first pattern that you're fixing/deleting, but these tests should cover the 2nd and 3rd.

[grandinj]

lib/Transforms/InstCombine/InstructionCombining.cpp

653 ↗

(On Diff #106755)

the do -> they do

662 ↗

(On Diff #106755)

the do -> they do

690 ↗

(On Diff #106755)

ditto

699 ↗

(On Diff #106755)

ditto

[craig.topper]

Added Sanjay's compare test cases.

[spatel]

There's an open question about whether InstCombine should be in the refactoring/distribution optimization business in the first place. However, given that this patch both improves that folding and reduces specialized matchers, it will make it easier to lift this code into a different pass when we decide to move this.

LGTM.

lib/Transforms/InstCombine/InstructionCombining.cpp

651 ↗

(On Diff #106776)

"Do" -> "Does" (and same for the comments below)

653 ↗

(On Diff #106776)

"They do!" -> "It does!" (and repeat below)

test/Transforms/InstCombine/and.ll

698 ↗

(On Diff #106776)

Should be "Commute the 'and':"
Also reverse the other similar comments; these got inverted from the 'or' tests.

753 ↗

(On Diff #106776)

This is a copy of my mistake in the original comment, so it's repeated 8 times I think: the result is actually (~X & Y).

llvm/trunk/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

// A&(A^B) => A & ~B
         // A is originally -1 (or a vector of -1 and undefs), then we enter
         // an endless loop. By checking that A is non-constant we ensure that
         // we will never get to the loop.
         if (A == tmpOp0 && !isa<Constant>(A)) // A&(A^B) -> A & ~B
           return BinaryOperator::CreateAnd(A, Builder.CreateNot(B));
       }
     }
 
-    // (A&((~A)|B)) -> A&B
-    if (match(Op0, m_c_Or(m_Not(m_Specific(Op1)), m_Value(A))))
-      return BinaryOperator::CreateAnd(A, Op1);
-    if (match(Op1, m_c_Or(m_Not(m_Specific(Op0)), m_Value(A))))
-      return BinaryOperator::CreateAnd(A, Op0);
-
     // (A ^ B) & ((B ^ C) ^ A) -> (A ^ B) & ~C
     if (match(Op0, m_Xor(m_Value(A), m_Value(B))))
       if (match(Op1, m_Xor(m_Xor(m_Specific(B), m_Value(C)), m_Specific(A))))
         if (Op1->hasOneUse() || IsFreeToInvert(C, C->hasOneUse()))
           return BinaryOperator::CreateAnd(Op0, Builder.CreateNot(C));
 
     // ((A ^ C) ^ B) & (B ^ A) -> (B ^ A) & ~C
     if (match(Op0, m_Xor(m_Xor(m_Value(A), m_Value(C)), m_Value(B))))
if (match(Op1, m_OneUse(m_Xor(m_Value(A), m_APInt(C)))) &&
       NOr->takeName(Op0);
       return BinaryOperator::CreateXor(NOr,
                                        ConstantInt::get(NOr->getType(), *C));
     }
   }
 
   Value *A, *B;
 
-  // ((~A & B) | A) -> (A | B)
-  if (match(Op0, m_c_And(m_Not(m_Specific(Op1)), m_Value(A))))
-    return BinaryOperator::CreateOr(A, Op1);
-  if (match(Op1, m_c_And(m_Not(m_Specific(Op0)), m_Value(A))))
-    return BinaryOperator::CreateOr(Op0, A);
-
-  // ((A & B) | ~A) -> (~A | B)
-  // The NOT is guaranteed to be in the RHS by complexity ordering.
-  if (match(Op1, m_Not(m_Value(A))) &&
-      match(Op0, m_c_And(m_Specific(A), m_Value(B))))
-    return BinaryOperator::CreateOr(Op1, B);
-
   // (A & C)|(B & D)
   Value *C = nullptr, *D = nullptr;
   if (match(Op0, m_And(m_Value(A), m_Value(C))) &&
       match(Op1, m_And(m_Value(B), m_Value(D)))) {
     Value *V1 = nullptr, *V2 = nullptr;
     ConstantInt *C1 = dyn_cast<ConstantInt>(C);
     ConstantInt *C2 = dyn_cast<ConstantInt>(D);
     if (C1 && C2) {  // (A & C1)|(B & C2)

llvm/trunk/lib/Transforms/InstCombine/InstructionCombining.cpp

Value *InstCombiner::SimplifyUsingDistributiveLaws(BinaryOperator &I) {
 
   // Expansion.
   if (Op0 && RightDistributesOverLeft(Op0->getOpcode(), TopLevelOpcode)) {
     // The instruction has the form "(A op' B) op C".  See if expanding it out
     // to "(A op C) op' (B op C)" results in simplifications.
     Value *A = Op0->getOperand(0), *B = Op0->getOperand(1), *C = RHS;
     Instruction::BinaryOps InnerOpcode = Op0->getOpcode(); // op'
 
+    Value *L = SimplifyBinOp(TopLevelOpcode, A, C, SQ.getWithInstruction(&I));
+    Value *R = SimplifyBinOp(TopLevelOpcode, B, C, SQ.getWithInstruction(&I));
+
     // Do "A op C" and "B op C" both simplify?
-    if (Value *L =
-            SimplifyBinOp(TopLevelOpcode, A, C, SQ.getWithInstruction(&I)))
-      if (Value *R =
-              SimplifyBinOp(TopLevelOpcode, B, C, SQ.getWithInstruction(&I))) {
-        // They do! Return "L op' R".
-        ++NumExpand;
-        C = Builder.CreateBinOp(InnerOpcode, L, R);
-        C->takeName(&I);
-        return C;
-      }
+    if (L && R) {
+
+    // Does "A op C" simplify to the identity value for the inner opcode?
+    if (L && L == ConstantExpr::getBinOpIdentity(InnerOpcode, L->getType())) {
+      // They do! Return "B op C".
+      ++NumExpand;
+      C = Builder.CreateBinOp(TopLevelOpcode, B, C);
+      C->takeName(&I);
+      return C;
+    }
+
+    // Does "B op C" simplify to the identity value for the inner opcode?
+    if (R && R == ConstantExpr::getBinOpIdentity(InnerOpcode, R->getType())) {
+      // They do! Return "A op C".
+      ++NumExpand;
+      C = Builder.CreateBinOp(TopLevelOpcode, A, C);
+      C->takeName(&I);
+      return C;
+    }
   }
 
   if (Op1 && LeftDistributesOverRight(TopLevelOpcode, Op1->getOpcode())) {
     // The instruction has the form "A op (B op' C)".  See if expanding it out
     // to "(A op B) op' (A op C)" results in simplifications.
     Value *A = LHS, *B = Op1->getOperand(0), *C = Op1->getOperand(1);
     Instruction::BinaryOps InnerOpcode = Op1->getOpcode(); // op'
 
+    Value *L = SimplifyBinOp(TopLevelOpcode, A, B, SQ.getWithInstruction(&I));
+    Value *R = SimplifyBinOp(TopLevelOpcode, A, C, SQ.getWithInstruction(&I));
+
     // Do "A op B" and "A op C" both simplify?
-    if (Value *L =
-            SimplifyBinOp(TopLevelOpcode, A, B, SQ.getWithInstruction(&I)))
-      if (Value *R =
-              SimplifyBinOp(TopLevelOpcode, A, C, SQ.getWithInstruction(&I))) {
-        // They do! Return "L op' R".
-        ++NumExpand;
-        A = Builder.CreateBinOp(InnerOpcode, L, R);
-        A->takeName(&I);
-        return A;
-      }
+    if (L && R) {
+
+    // Does "A op B" simplify to the identity value for the inner opcode?
+    if (L && L == ConstantExpr::getBinOpIdentity(InnerOpcode, L->getType())) {
+      // They do! Return "A op C".
+      ++NumExpand;
+      A = Builder.CreateBinOp(TopLevelOpcode, A, C);
+      A->takeName(&I);
+      return A;
+    }
+
+    // Does "A op C" simplify to the identity value for the inner opcode?
+    if (R && R == ConstantExpr::getBinOpIdentity(InnerOpcode, R->getType())) {
+      // They do! Return "A op B".
+      ++NumExpand;
+      A = Builder.CreateBinOp(TopLevelOpcode, A, B);
+      A->takeName(&I);
+      return A;
+    }
   }
 
   // (op (select (a, c, b)), (select (a, d, b))) -> (select (a, (op c, d), 0))
   // (op (select (a, b, c)), (select (a, b, d))) -> (select (a, 0, (op c, d)))
   if (auto *SI0 = dyn_cast<SelectInst>(LHS)) {
     if (auto *SI1 = dyn_cast<SelectInst>(RHS)) {
       if (SI0->getCondition() == SI1->getCondition()) {
         Value *SI = nullptr;

llvm/trunk/test/Transforms/InstCombine/and.ll

 }
 
 ; In the next 4 tests, vary the types and predicates for extra coverage.
 ; (X & (Y | ~X)) -> (X & Y), where 'not' is an inverted cmp
 
 define i1 @and_orn_cmp_1(i32 %a, i32 %b, i32 %c) {
 ; CHECK-LABEL: @and_orn_cmp_1(
 ; CHECK-NEXT:    [[X:%.*]] = icmp sgt i32 [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[X_INV:%.*]] = icmp sle i32 [[A]], [[B]]
 ; CHECK-NEXT:    [[Y:%.*]] = icmp ugt i32 [[C:%.*]], 42
-; CHECK-NEXT:    [[OR:%.*]] = or i1 [[Y]], [[X_INV]]
-; CHECK-NEXT:    [[AND:%.*]] = and i1 [[X]], [[OR]]
+; CHECK-NEXT:    [[AND:%.*]] = and i1 [[X]], [[Y]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
   %x = icmp sgt i32 %a, %b
   %x_inv = icmp sle i32 %a, %b
   %y = icmp ugt i32 %c, 42      ; thwart complexity-based ordering
   %or = or i1 %y, %x_inv
   %and = and i1 %x, %or
   ret i1 %and
 }
 
-; Commute the 'or':
+; Commute the 'and':
 ; ((Y | ~X) & X) -> (X & Y), where 'not' is an inverted cmp
 
 define <2 x i1> @and_orn_cmp_2(<2 x i32> %a, <2 x i32> %b, <2 x i32> %c) {
 ; CHECK-LABEL: @and_orn_cmp_2(
 ; CHECK-NEXT:    [[X:%.*]] = icmp sge <2 x i32> [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[X_INV:%.*]] = icmp slt <2 x i32> [[A]], [[B]]
 ; CHECK-NEXT:    [[Y:%.*]] = icmp ugt <2 x i32> [[C:%.*]], <i32 42, i32 47>
-; CHECK-NEXT:    [[OR:%.*]] = or <2 x i1> [[Y]], [[X_INV]]
-; CHECK-NEXT:    [[AND:%.*]] = and <2 x i1> [[OR]], [[X]]
+; CHECK-NEXT:    [[AND:%.*]] = and <2 x i1> [[Y]], [[X]]
 ; CHECK-NEXT:    ret <2 x i1> [[AND]]
 ;
   %x = icmp sge <2 x i32> %a, %b
   %x_inv = icmp slt <2 x i32> %a, %b
   %y = icmp ugt <2 x i32> %c, <i32 42, i32 47>      ; thwart complexity-based ordering
   %or = or <2 x i1> %y, %x_inv
   %and = and <2 x i1> %or, %x
   ret <2 x i1> %and
 }
 
-; Commute the 'and':
+; Commute the 'or':
 ; (X & (~X | Y)) -> (X & Y), where 'not' is an inverted cmp
 
 define i1 @and_orn_cmp_3(i72 %a, i72 %b, i72 %c) {
 ; CHECK-LABEL: @and_orn_cmp_3(
 ; CHECK-NEXT:    [[X:%.*]] = icmp ugt i72 [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[X_INV:%.*]] = icmp ule i72 [[A]], [[B]]
 ; CHECK-NEXT:    [[Y:%.*]] = icmp ugt i72 [[C:%.*]], 42
-; CHECK-NEXT:    [[OR:%.*]] = or i1 [[X_INV]], [[Y]]
-; CHECK-NEXT:    [[AND:%.*]] = and i1 [[X]], [[OR]]
+; CHECK-NEXT:    [[AND:%.*]] = and i1 [[X]], [[Y]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
   %x = icmp ugt i72 %a, %b
   %x_inv = icmp ule i72 %a, %b
   %y = icmp ugt i72 %c, 42      ; thwart complexity-based ordering
   %or = or i1 %x_inv, %y
   %and = and i1 %x, %or
   ret i1 %and
 }
 
-; Commute the 'or':
+; Commute the 'and':
 ; ((~X | Y) & X) -> (X & Y), where 'not' is an inverted cmp
 
 define <3 x i1> @or_andn_cmp_4(<3 x i32> %a, <3 x i32> %b, <3 x i32> %c) {
 ; CHECK-LABEL: @or_andn_cmp_4(
 ; CHECK-NEXT:    [[X:%.*]] = icmp eq <3 x i32> [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[X_INV:%.*]] = icmp ne <3 x i32> [[A]], [[B]]
 ; CHECK-NEXT:    [[Y:%.*]] = icmp ugt <3 x i32> [[C:%.*]], <i32 42, i32 43, i32 -1>
-; CHECK-NEXT:    [[OR:%.*]] = or <3 x i1> [[X_INV]], [[Y]]
-; CHECK-NEXT:    [[AND:%.*]] = and <3 x i1> [[OR]], [[X]]
+; CHECK-NEXT:    [[AND:%.*]] = and <3 x i1> [[Y]], [[X]]
 ; CHECK-NEXT:    ret <3 x i1> [[AND]]
 ;
   %x = icmp eq <3 x i32> %a, %b
   %x_inv = icmp ne <3 x i32> %a, %b
   %y = icmp ugt <3 x i32> %c, <i32 42, i32 43, i32 -1>      ; thwart complexity-based ordering
   %or = or <3 x i1> %x_inv, %y
   %and = and <3 x i1> %or, %x
   ret <3 x i1> %and
 }
 
 ; In the next 4 tests, vary the types and predicates for extra coverage.
-; (~X & (Y | X)) -> (X & Y), where 'not' is an inverted cmp
+; (~X & (Y | X)) -> (~X & Y), where 'not' is an inverted cmp
 
 define i1 @andn_or_cmp_1(i37 %a, i37 %b, i37 %c) {
 ; CHECK-LABEL: @andn_or_cmp_1(
-; CHECK-NEXT:    [[X:%.*]] = icmp sgt i37 [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[X_INV:%.*]] = icmp sle i37 [[A]], [[B]]
+; CHECK-NEXT:    [[X_INV:%.*]] = icmp sle i37 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[Y:%.*]] = icmp ugt i37 [[C:%.*]], 42
-; CHECK-NEXT:    [[OR:%.*]] = or i1 [[Y]], [[X]]
-; CHECK-NEXT:    [[AND:%.*]] = and i1 [[X_INV]], [[OR]]
+; CHECK-NEXT:    [[AND:%.*]] = and i1 [[X_INV]], [[Y]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
   %x = icmp sgt i37 %a, %b
   %x_inv = icmp sle i37 %a, %b
   %y = icmp ugt i37 %c, 42      ; thwart complexity-based ordering
   %or = or i1 %y, %x
   %and = and i1 %x_inv, %or
   ret i1 %and
 }
 
-; Commute the 'or':
-; ((Y | X) & ~X) -> (X & Y), where 'not' is an inverted cmp
+; Commute the 'and':
+; ((Y | X) & ~X) -> (~X & Y), where 'not' is an inverted cmp
 
 define i1 @andn_or_cmp_2(i16 %a, i16 %b, i16 %c) {
 ; CHECK-LABEL: @andn_or_cmp_2(
-; CHECK-NEXT:    [[X:%.*]] = icmp sge i16 [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[X_INV:%.*]] = icmp slt i16 [[A]], [[B]]
+; CHECK-NEXT:    [[X_INV:%.*]] = icmp slt i16 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[Y:%.*]] = icmp ugt i16 [[C:%.*]], 42
-; CHECK-NEXT:    [[OR:%.*]] = or i1 [[Y]], [[X]]
-; CHECK-NEXT:    [[AND:%.*]] = and i1 [[OR]], [[X_INV]]
+; CHECK-NEXT:    [[AND:%.*]] = and i1 [[Y]], [[X_INV]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
   %x = icmp sge i16 %a, %b
   %x_inv = icmp slt i16 %a, %b
   %y = icmp ugt i16 %c, 42      ; thwart complexity-based ordering
   %or = or i1 %y, %x
   %and = and i1 %or, %x_inv
   ret i1 %and
 }
 
-; Commute the 'and':
-; (~X & (X | Y)) -> (X & Y), where 'not' is an inverted cmp
+; Commute the 'or':
+; (~X & (X | Y)) -> (~X & Y), where 'not' is an inverted cmp
 
 define <4 x i1> @andn_or_cmp_3(<4 x i32> %a, <4 x i32> %b, <4 x i32> %c) {
 ; CHECK-LABEL: @andn_or_cmp_3(
-; CHECK-NEXT:    [[X:%.*]] = icmp ugt <4 x i32> [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[X_INV:%.*]] = icmp ule <4 x i32> [[A]], [[B]]
+; CHECK-NEXT:    [[X_INV:%.*]] = icmp ule <4 x i32> [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[Y:%.*]] = icmp ugt <4 x i32> [[C:%.*]], <i32 42, i32 0, i32 1, i32 -1>
-; CHECK-NEXT:    [[OR:%.*]] = or <4 x i1> [[X]], [[Y]]
-; CHECK-NEXT:    [[AND:%.*]] = and <4 x i1> [[X_INV]], [[OR]]
+; CHECK-NEXT:    [[AND:%.*]] = and <4 x i1> [[X_INV]], [[Y]]
 ; CHECK-NEXT:    ret <4 x i1> [[AND]]
 ;
   %x = icmp ugt <4 x i32> %a, %b
   %x_inv = icmp ule <4 x i32> %a, %b
   %y = icmp ugt <4 x i32> %c, <i32 42, i32 0, i32 1, i32 -1>      ; thwart complexity-based ordering
   %or = or <4 x i1> %x, %y
   %and = and <4 x i1> %x_inv, %or
   ret <4 x i1> %and
 }
 
-; Commute the 'or':
-; ((X | Y) & ~X) -> (X & Y), where 'not' is an inverted cmp
+; Commute the 'and':
+; ((X | Y) & ~X) -> (~X & Y), where 'not' is an inverted cmp
 
 define i1 @andn_or_cmp_4(i32 %a, i32 %b, i32 %c) {
 ; CHECK-LABEL: @andn_or_cmp_4(
-; CHECK-NEXT:    [[X:%.*]] = icmp eq i32 [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[X_INV:%.*]] = icmp ne i32 [[A]], [[B]]
+; CHECK-NEXT:    [[X_INV:%.*]] = icmp ne i32 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[Y:%.*]] = icmp ugt i32 [[C:%.*]], 42
-; CHECK-NEXT:    [[OR:%.*]] = or i1 [[X]], [[Y]]
-; CHECK-NEXT:    [[AND:%.*]] = and i1 [[OR]], [[X_INV]]
+; CHECK-NEXT:    [[AND:%.*]] = and i1 [[Y]], [[X_INV]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
   %x = icmp eq i32 %a, %b
   %x_inv = icmp ne i32 %a, %b
   %y = icmp ugt i32 %c, 42      ; thwart complexity-based ordering
   %or = or i1 %x, %y
   %and = and i1 %or, %x_inv
   ret i1 %and
 }

llvm/trunk/test/Transforms/InstCombine/or.ll

 }
 
 ; In the next 4 tests, vary the types and predicates for extra coverage.
 ; (X | (Y & ~X)) -> (X | Y), where 'not' is an inverted cmp
 
 define i1 @or_andn_cmp_1(i32 %a, i32 %b, i32 %c) {
 ; CHECK-LABEL: @or_andn_cmp_1(
 ; CHECK-NEXT:    [[X:%.*]] = icmp sgt i32 [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[X_INV:%.*]] = icmp sle i32 [[A]], [[B]]
 ; CHECK-NEXT:    [[Y:%.*]] = icmp ugt i32 [[C:%.*]], 42
-; CHECK-NEXT:    [[AND:%.*]] = and i1 [[Y]], [[X_INV]]
-; CHECK-NEXT:    [[OR:%.*]] = or i1 [[X]], [[AND]]
+; CHECK-NEXT:    [[OR:%.*]] = or i1 [[X]], [[Y]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
   %x = icmp sgt i32 %a, %b
   %x_inv = icmp sle i32 %a, %b
   %y = icmp ugt i32 %c, 42      ; thwart complexity-based ordering
   %and = and i1 %y, %x_inv
   %or = or i1 %x, %and
   ret i1 %or
 }
 
 ; Commute the 'or':
 ; ((Y & ~X) | X) -> (X | Y), where 'not' is an inverted cmp
 
 define <2 x i1> @or_andn_cmp_2(<2 x i32> %a, <2 x i32> %b, <2 x i32> %c) {
 ; CHECK-LABEL: @or_andn_cmp_2(
 ; CHECK-NEXT:    [[X:%.*]] = icmp sge <2 x i32> [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[X_INV:%.*]] = icmp slt <2 x i32> [[A]], [[B]]
 ; CHECK-NEXT:    [[Y:%.*]] = icmp ugt <2 x i32> [[C:%.*]], <i32 42, i32 47>
-; CHECK-NEXT:    [[AND:%.*]] = and <2 x i1> [[Y]], [[X_INV]]
-; CHECK-NEXT:    [[OR:%.*]] = or <2 x i1> [[AND]], [[X]]
+; CHECK-NEXT:    [[OR:%.*]] = or <2 x i1> [[Y]], [[X]]
 ; CHECK-NEXT:    ret <2 x i1> [[OR]]
 ;
   %x = icmp sge <2 x i32> %a, %b
   %x_inv = icmp slt <2 x i32> %a, %b
   %y = icmp ugt <2 x i32> %c, <i32 42, i32 47>      ; thwart complexity-based ordering
   %and = and <2 x i1> %y, %x_inv
   %or = or <2 x i1> %and, %x
   ret <2 x i1> %or
 }
 
 ; Commute the 'and':
 ; (X | (~X & Y)) -> (X | Y), where 'not' is an inverted cmp
 
 define i1 @or_andn_cmp_3(i72 %a, i72 %b, i72 %c) {
 ; CHECK-LABEL: @or_andn_cmp_3(
 ; CHECK-NEXT:    [[X:%.*]] = icmp ugt i72 [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[X_INV:%.*]] = icmp ule i72 [[A]], [[B]]
 ; CHECK-NEXT:    [[Y:%.*]] = icmp ugt i72 [[C:%.*]], 42
-; CHECK-NEXT:    [[AND:%.*]] = and i1 [[X_INV]], [[Y]]
-; CHECK-NEXT:    [[OR:%.*]] = or i1 [[X]], [[AND]]
+; CHECK-NEXT:    [[OR:%.*]] = or i1 [[X]], [[Y]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
   %x = icmp ugt i72 %a, %b
   %x_inv = icmp ule i72 %a, %b
   %y = icmp ugt i72 %c, 42      ; thwart complexity-based ordering
   %and = and i1 %x_inv, %y
   %or = or i1 %x, %and
   ret i1 %or
 }
 
 ; Commute the 'or':
 ; ((~X & Y) | X) -> (X | Y), where 'not' is an inverted cmp
 
 define <3 x i1> @or_andn_cmp_4(<3 x i32> %a, <3 x i32> %b, <3 x i32> %c) {
 ; CHECK-LABEL: @or_andn_cmp_4(
 ; CHECK-NEXT:    [[X:%.*]] = icmp eq <3 x i32> [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[X_INV:%.*]] = icmp ne <3 x i32> [[A]], [[B]]
 ; CHECK-NEXT:    [[Y:%.*]] = icmp ugt <3 x i32> [[C:%.*]], <i32 42, i32 43, i32 -1>
-; CHECK-NEXT:    [[AND:%.*]] = and <3 x i1> [[X_INV]], [[Y]]
-; CHECK-NEXT:    [[OR:%.*]] = or <3 x i1> [[AND]], [[X]]
+; CHECK-NEXT:    [[OR:%.*]] = or <3 x i1> [[Y]], [[X]]
 ; CHECK-NEXT:    ret <3 x i1> [[OR]]
 ;
   %x = icmp eq <3 x i32> %a, %b
   %x_inv = icmp ne <3 x i32> %a, %b
   %y = icmp ugt <3 x i32> %c, <i32 42, i32 43, i32 -1>      ; thwart complexity-based ordering
   %and = and <3 x i1> %x_inv, %y
   %or = or <3 x i1> %and, %x
   ret <3 x i1> %or
 }
 
 ; In the next 4 tests, vary the types and predicates for extra coverage.
-; (~X | (Y & X)) -> (X | Y), where 'not' is an inverted cmp
+; (~X | (Y & X)) -> (~X | Y), where 'not' is an inverted cmp
 
 define i1 @orn_and_cmp_1(i37 %a, i37 %b, i37 %c) {
 ; CHECK-LABEL: @orn_and_cmp_1(
-; CHECK-NEXT:    [[X:%.*]] = icmp sgt i37 [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[X_INV:%.*]] = icmp sle i37 [[A]], [[B]]
+; CHECK-NEXT:    [[X_INV:%.*]] = icmp sle i37 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[Y:%.*]] = icmp ugt i37 [[C:%.*]], 42
-; CHECK-NEXT:    [[AND:%.*]] = and i1 [[Y]], [[X]]
-; CHECK-NEXT:    [[OR:%.*]] = or i1 [[X_INV]], [[AND]]
+; CHECK-NEXT:    [[OR:%.*]] = or i1 [[X_INV]], [[Y]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
   %x = icmp sgt i37 %a, %b
   %x_inv = icmp sle i37 %a, %b
   %y = icmp ugt i37 %c, 42      ; thwart complexity-based ordering
   %and = and i1 %y, %x
   %or = or i1 %x_inv, %and
   ret i1 %or
 }
 
 ; Commute the 'or':
-; ((Y & X) | ~X) -> (X | Y), where 'not' is an inverted cmp
+; ((Y & X) | ~X) -> (~X | Y), where 'not' is an inverted cmp
 
 define i1 @orn_and_cmp_2(i16 %a, i16 %b, i16 %c) {
 ; CHECK-LABEL: @orn_and_cmp_2(
-; CHECK-NEXT:    [[X:%.*]] = icmp sge i16 [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[X_INV:%.*]] = icmp slt i16 [[A]], [[B]]
+; CHECK-NEXT:    [[X_INV:%.*]] = icmp slt i16 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[Y:%.*]] = icmp ugt i16 [[C:%.*]], 42
-; CHECK-NEXT:    [[AND:%.*]] = and i1 [[Y]], [[X]]
-; CHECK-NEXT:    [[OR:%.*]] = or i1 [[AND]], [[X_INV]]
+; CHECK-NEXT:    [[OR:%.*]] = or i1 [[Y]], [[X_INV]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
   %x = icmp sge i16 %a, %b
   %x_inv = icmp slt i16 %a, %b
   %y = icmp ugt i16 %c, 42      ; thwart complexity-based ordering
   %and = and i1 %y, %x
   %or = or i1 %and, %x_inv
   ret i1 %or
 }
 
 ; Commute the 'and':
-; (~X | (X & Y)) -> (X | Y), where 'not' is an inverted cmp
+; (~X | (X & Y)) -> (~X | Y), where 'not' is an inverted cmp
 
 define <4 x i1> @orn_and_cmp_3(<4 x i32> %a, <4 x i32> %b, <4 x i32> %c) {
 ; CHECK-LABEL: @orn_and_cmp_3(
-; CHECK-NEXT:    [[X:%.*]] = icmp ugt <4 x i32> [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[X_INV:%.*]] = icmp ule <4 x i32> [[A]], [[B]]
+; CHECK-NEXT:    [[X_INV:%.*]] = icmp ule <4 x i32> [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[Y:%.*]] = icmp ugt <4 x i32> [[C:%.*]], <i32 42, i32 0, i32 1, i32 -1>
-; CHECK-NEXT:    [[AND:%.*]] = and <4 x i1> [[X]], [[Y]]
-; CHECK-NEXT:    [[OR:%.*]] = or <4 x i1> [[X_INV]], [[AND]]
+; CHECK-NEXT:    [[OR:%.*]] = or <4 x i1> [[X_INV]], [[Y]]
 ; CHECK-NEXT:    ret <4 x i1> [[OR]]
 ;
   %x = icmp ugt <4 x i32> %a, %b
   %x_inv = icmp ule <4 x i32> %a, %b
   %y = icmp ugt <4 x i32> %c, <i32 42, i32 0, i32 1, i32 -1>      ; thwart complexity-based ordering
   %and = and <4 x i1> %x, %y
   %or = or <4 x i1> %x_inv, %and
   ret <4 x i1> %or
 }
 
 ; Commute the 'or':
-; ((X & Y) | ~X) -> (X | Y), where 'not' is an inverted cmp
+; ((X & Y) | ~X) -> (~X | Y), where 'not' is an inverted cmp
 
 define i1 @orn_and_cmp_4(i32 %a, i32 %b, i32 %c) {
 ; CHECK-LABEL: @orn_and_cmp_4(
-; CHECK-NEXT:    [[X:%.*]] = icmp eq i32 [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[X_INV:%.*]] = icmp ne i32 [[A]], [[B]]
+; CHECK-NEXT:    [[X_INV:%.*]] = icmp ne i32 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[Y:%.*]] = icmp ugt i32 [[C:%.*]], 42
-; CHECK-NEXT:    [[AND:%.*]] = and i1 [[X]], [[Y]]
-; CHECK-NEXT:    [[OR:%.*]] = or i1 [[AND]], [[X_INV]]
+; CHECK-NEXT:    [[OR:%.*]] = or i1 [[Y]], [[X_INV]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
   %x = icmp eq i32 %a, %b
   %x_inv = icmp ne i32 %a, %b
   %y = icmp ugt i32 %c, 42      ; thwart complexity-based ordering
   %and = and i1 %x, %y
   %or = or i1 %and, %x_inv
   ret i1 %or
 }