[InstSimplify] use ConstantRange to simplify more and-of-icmps

[spatel]

Summary

We can simplify (and (icmp X, C1), (icmp X, C2)) to one of the icmps in many cases. I had to check some of these with Alive to prove to myself it's right, but everything seems to check out. Eg, the code in instcombine was completely ignoring predicates with mismatched signedness.

Handling or-of-icmps would be a follow-up step.

I initially thought I could use equivalence of the intersection with one of the input ranges rather than 'contains', but ConstantRange intersection doesn't work like I expected (not sure if it's wrong or if my expectations are off).

[sanjoy]

I initially thought I could use equivalence of the intersection with one of the input ranges rather than 'contains', but ConstantRange intersection doesn't work like I expected

Do you mean there are cases where A.contains(B) is true but A.intersect(B) is not B? If so, that does sound fishy.

[spatel]

In D32143#728857, @sanjoy wrote:

I initially thought I could use equivalence of the intersection with one of the input ranges rather than 'contains', but ConstantRange intersection doesn't work like I expected

Do you mean there are cases where A.contains(B) is true but A.intersect(B) is not B? If so, that does sound fishy.

I saw the inverse: A.contains(B) is false, but A.intersectsWith(B) is B.

Example:

define i1 @and_ne_ne(i8 %x) {
  %a = icmp ne i8 %x, 13
  %b = icmp ne i8 %x, 17
  %c = and i1 %a, %b
  ret i1 %c
}

ConstantRange shows:
A: Lower = 14, Upper = 13
B: Lower = 18, Upper = 17
A.intersectsWith(B) returns B (Lower = 18, Upper = 17).
I thought this would return Lower = 18, Upper = 13 based on the header comment for intersectsWith:
"Return the range that results from the intersection of this range with another range.
The resultant range is guaranteed to include all elements contained in both input ranges, and to
have the smallest possible set size that does so."

[sanjoy]

In D32143#729140, @spatel wrote:

In D32143#728857, @sanjoy wrote:

I initially thought I could use equivalence of the intersection with one of the input ranges rather than 'contains', but ConstantRange intersection doesn't work like I expected

Do you mean there are cases where A.contains(B) is true but A.intersect(B) is not B? If so, that does sound fishy.

I saw the inverse: A.contains(B) is false, but A.intersectsWith(B) is B.

Okay, that does not look fishy. :)

Example:

define i1 @and_ne_ne(i8 %x) {
  %a = icmp ne i8 %x, 13
  %b = icmp ne i8 %x, 17
  %c = and i1 %a, %b
  ret i1 %c
}

ConstantRange shows:
A: Lower = 14, Upper = 13
B: Lower = 18, Upper = 17
A.intersectsWith(B) returns B (Lower = 18, Upper = 17).
I thought this would return Lower = 18, Upper = 13 based on the header comment for intersectsWith:
"Return the range that results from the intersection of this range with another range.
The resultant range is guaranteed to include all elements contained in both input ranges, and to
have the smallest possible set size that does so."

In that case, (Lower = 18, Upper = 17) is one of the right answer(s). (Lower = 18, Upper = 13) would be wrong because, e.g., 15 is both in A and in B, but not in (Lower = 18, Upper = 13), and the contract is that "The resultant range is guaranteed to include all elements contained in both input ranges".

[spatel]

In D32143#729550, @sanjoy wrote:

In that case, (Lower = 18, Upper = 17) is one of the right answer(s). (Lower = 18, Upper = 13) would be wrong because, e.g., 15 is both in A and in B, but not in (Lower = 18, Upper = 13), and the contract is that "The resultant range is guaranteed to include all elements contained in both input ranges".

Ah, I get it now. Thanks for the explanation. In that case "contains" seems like my only option for this patch, and it is working as I expected.

[sanjoy]

lib/Analysis/InstructionSimplify.cpp

1592 ↗

(On Diff #95510)

As written, the code is correct but misleading.

I think the correct thing to do in this case is:

auto Range0 = ConstantRange::makeExactICmpRegion(Pred0, *C0);
auto Range1 = ConstantRange::makeExactICmpRegion(Pred1, *C1);

The current code is correct because for an APInt (as opposed to ConstantRange) RHS, makeExactICmpRegion just happens to be the same as makeAllowedICmpRegion. However, if *C0 and *C1 were ConstantRange s (i.e. someone generalized this code), then using makeAllowedICmpRegion would be wrong.

[spatel]

Patch updated:
Use "makeExactICmpRegion" rather than "makeAllowedICmpRegion" to avoid a potential bug. As Sanjoy noted, we're using APInt here currently, so there should be no difference right now. But if this code was converted to take ConstantRange inputs, that would be wrong.

[sanjoy]

LGTM! I did not sanity check the test changes, I've assumed you did that. :)

[spatel]

In D32143#733869, @sanjoy wrote:

LGTM! I did not sanity check the test changes, I've assumed you did that. :)

Yes, I have two 10x10 graphs for the predicate combinations...there's a pattern in here that we could probably encode into the predicate enum values (we do something like that for the fcmp predicates), but I don't see that pattern yet. :)
And I spot-checked several of these using Alive for extra confidence.

[uweigand]

I'm seeing a performance regression which I traced back to this commit. A reduced test case to show the problem is this:

define i1 @test(i64 %a) {
  %cmpge = icmp sge i64 %a, 1
  %cmpeq = icmp eq i64 %a, 1
  %cmpne = icmp eq i1 %cmpeq, false
  %cmp = and i1 %cmpge, %cmpne
  ret i1 %cmp
}

Before this commit, InstCombine would reduce the above to simply:

define i1 @test(i64 %a) {
  %1 = icmp sgt i64 %a, 1
  ret i1 %1
}

but for some reason this no longer happens now.

Note that when directly using an "icmp ne" instead of inverting the result of the "icmp eq", the optimization does still happen.

[spatel]

In D32143#757324, @uweigand wrote:

I'm seeing a performance regression which I traced back to this commit. A reduced test case to show the problem is this:

define i1 @test(i64 %a) {
  %cmpge = icmp sge i64 %a, 1
  %cmpeq = icmp eq i64 %a, 1
  %cmpne = icmp eq i1 %cmpeq, false
  %cmp = and i1 %cmpge, %cmpne
  ret i1 %cmp
}

Before this commit, InstCombine would reduce the above to simply:

define i1 @test(i64 %a) {
  %1 = icmp sgt i64 %a, 1
  ret i1 %1
}

but for some reason this no longer happens now.

Note that when directly using an "icmp ne" instead of inverting the result of the "icmp eq", the optimization does still happen.

Thanks for the small test. I'll take a look.

[spatel]

This is a fun one. The ultimate problem is that by making InstSimplify smarter, we revealed a shortcoming in InstCombine. InstCombine is missing a fold for xor-of-icmps like this:

; (a > 0) ^ (a == 1) --> ((a > 0) & (a != 1)) | ((a <= 0) & (a == 1)) --> (a > 1) 
define i1 @test1(i64 %a) {
  %b = icmp sgt i64 %a, 0
  %c = icmp eq i64 %a, 1
  %and = xor i1 %c, %b
  ret i1 %and
}

I think we can avoid the problem in your original test case though. Ie, there's another InstCombine bug because it creates an unnecessary instruction:
IC: ADD: %notctmp = xor i1 %c, false

And that's what triggers another fold (the 'and' in the original code becomes an 'xor') which produces the pattern that we don't know how to fold yet.

[spatel]

This should reduce the chance of finding the optimization gap:
rL303312

Related clean-up commits ahead of that:
rL303295
rL303309
rL303310

We might want to treat an xor-of-icmps as an or-of-and-of-icmps to really fix this....or we just handle xor-of-icmps directly. There was a patch:
rL289813
...that might have gotten this case, but it got reverted:
rL290266

[uweigand]

In D32143#758001, @spatel wrote:

This should reduce the chance of finding the optimization gap:
rL303312

Yes, this works for me. Thanks for the quick fix!

[spatel]

Here's a proposal to fix xor-of-icmps better:
D33342

Also, the post-commit thread for:
https://reviews.llvm.org/rL303312
...suggests that that patch caused a regression for SimplifyCFG. I don't know how that would happen yet, but I'll investigate if I get an example.

llvm/trunk/lib/Analysis/InstructionSimplify.cpp

 /// with the parameters swapped.
 static Value *SimplifyAndOfICmps(ICmpInst *Op0, ICmpInst *Op1) {
   if (Value *X = simplifyUnsignedRangeCheck(Op0, Op1, /*IsAnd=*/true))
     return X;
 
   if (Value *X = simplifyAndOfICmpsWithSameOperands(Op0, Op1))
     return X;
 
+  // FIXME: This should be shared with or-of-icmps.
   // Look for this pattern: (icmp V, C0) & (icmp V, C1)).
   Type *ITy = Op0->getType();
   ICmpInst::Predicate Pred0, Pred1;
   const APInt *C0, *C1;
   Value *V;
   if (match(Op0, m_ICmp(Pred0, m_Value(V), m_APInt(C0))) &&
       match(Op1, m_ICmp(Pred1, m_Specific(V), m_APInt(C1)))) {
     // Make a constant range that's the intersection of the two icmp ranges.
     // If the intersection is empty, we know that the result is false.
-    auto Range0 = ConstantRange::makeAllowedICmpRegion(Pred0, *C0);
-    auto Range1 = ConstantRange::makeAllowedICmpRegion(Pred1, *C1);
+    auto Range0 = ConstantRange::makeExactICmpRegion(Pred0, *C0);
+    auto Range1 = ConstantRange::makeExactICmpRegion(Pred1, *C1);
     if (Range0.intersectWith(Range1).isEmptySet())
       return getFalse(ITy);
+
+    // If a range is a superset of the other, the smaller set is all we need.
+    if (Range0.contains(Range1))
+      return Op1;
+    if (Range1.contains(Range0))
+      return Op0;
   }
 
   // (icmp (add V, C0), C1) & (icmp V, C0)
   if (!match(Op0, m_ICmp(Pred0, m_Add(m_Value(V), m_APInt(C0)), m_APInt(C1))))
     return nullptr;
 
   if (!match(Op1, m_ICmp(Pred1, m_Specific(V), m_Value())))
     return nullptr;

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

Value *InstCombiner::FoldAndOfICmps(ICmpInst *LHS, ICmpInst *RHS) {
   // icmp eq, icmp ne, icmp [su]lt, and icmp [SU]gt here. We also know
   // (from the icmp folding check above), that the two constants
   // are not equal and that the larger constant is on the RHS
   assert(LHSC != RHSC && "Compares not folded above?");
 
   switch (PredL) {
   default:
     llvm_unreachable("Unknown integer condition code!");
-  case ICmpInst::ICMP_EQ:
-    switch (PredR) {
-    default:
-      llvm_unreachable("Unknown integer condition code!");
-    case ICmpInst::ICMP_NE:  // (X == 13 & X != 15) -> X == 13
-    case ICmpInst::ICMP_ULT: // (X == 13 & X <  15) -> X == 13
-    case ICmpInst::ICMP_SLT: // (X == 13 & X <  15) -> X == 13
-      return LHS;
-    }
   case ICmpInst::ICMP_NE:
     switch (PredR) {
     default:
       llvm_unreachable("Unknown integer condition code!");
     case ICmpInst::ICMP_ULT:
       if (LHSC == SubOne(RHSC)) // (X != 13 & X u< 14) -> X < 13
         return Builder->CreateICmpULT(LHS0, LHSC);
       if (LHSC->isNullValue()) // (X !=  0 & X u< 14) -> X-1 u< 13
         return insertRangeTest(LHS0, LHSC->getValue() + 1, RHSC->getValue(),
                                false, true);
       break; // (X != 13 & X u< 15) -> no change
     case ICmpInst::ICMP_SLT:
       if (LHSC == SubOne(RHSC)) // (X != 13 & X s< 14) -> X < 13
         return Builder->CreateICmpSLT(LHS0, LHSC);
       break;                 // (X != 13 & X s< 15) -> no change
-    case ICmpInst::ICMP_EQ:  // (X != 13 & X == 15) -> X == 15
-    case ICmpInst::ICMP_UGT: // (X != 13 & X u> 15) -> X u> 15
-    case ICmpInst::ICMP_SGT: // (X != 13 & X s> 15) -> X s> 15
-      return RHS;
     case ICmpInst::ICMP_NE:
       // Potential folds for this case should already be handled.
       break;
     }
     break;
-  case ICmpInst::ICMP_ULT:
-    switch (PredR) {
-    default:
-      llvm_unreachable("Unknown integer condition code!");
-    case ICmpInst::ICMP_EQ:  // (X u< 13 & X == 15) -> false
-    case ICmpInst::ICMP_UGT: // (X u< 13 & X u> 15) -> false
-      return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 0);
-    case ICmpInst::ICMP_NE:  // (X u< 13 & X != 15) -> X u< 13
-    case ICmpInst::ICMP_ULT: // (X u< 13 & X u< 15) -> X u< 13
-      return LHS;
-    }
-    break;
-  case ICmpInst::ICMP_SLT:
-    switch (PredR) {
-    default:
-      llvm_unreachable("Unknown integer condition code!");
-    case ICmpInst::ICMP_NE:  // (X s< 13 & X != 15) -> X < 13
-    case ICmpInst::ICMP_SLT: // (X s< 13 & X s< 15) -> X < 13
-      return LHS;
-    }
-    break;
   case ICmpInst::ICMP_UGT:
     switch (PredR) {
     default:
       llvm_unreachable("Unknown integer condition code!");
-    case ICmpInst::ICMP_EQ:  // (X u> 13 & X == 15) -> X == 15
-    case ICmpInst::ICMP_UGT: // (X u> 13 & X u> 15) -> X u> 15
-      return RHS;
     case ICmpInst::ICMP_NE:
       if (RHSC == AddOne(LHSC)) // (X u> 13 & X != 14) -> X u> 14
         return Builder->CreateICmp(PredL, LHS0, RHSC);
       break;                 // (X u> 13 & X != 15) -> no change
     case ICmpInst::ICMP_ULT: // (X u> 13 & X u< 15) -> (X-14) <u 1
       return insertRangeTest(LHS0, LHSC->getValue() + 1, RHSC->getValue(),
                              false, true);
     }
     break;
   case ICmpInst::ICMP_SGT:
     switch (PredR) {
     default:
       llvm_unreachable("Unknown integer condition code!");
-    case ICmpInst::ICMP_EQ:  // (X s> 13 & X == 15) -> X == 15
-    case ICmpInst::ICMP_SGT: // (X s> 13 & X s> 15) -> X s> 15
-      return RHS;
     case ICmpInst::ICMP_NE:
       if (RHSC == AddOne(LHSC)) // (X s> 13 & X != 14) -> X s> 14
         return Builder->CreateICmp(PredL, LHS0, RHSC);
       break;                 // (X s> 13 & X != 15) -> no change
     case ICmpInst::ICMP_SLT: // (X s> 13 & X s< 15) -> (X-14) s< 1
       return insertRangeTest(LHS0, LHSC->getValue() + 1, RHSC->getValue(), true,
                              true);
     }

llvm/trunk/test/Transforms/InstCombine/and-or-icmps.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instcombine -S | FileCheck %s
 
 define i1 @PR1817_1(i32 %X) {
 ; CHECK-LABEL: @PR1817_1(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i32 %X, 10
 ; CHECK-NEXT:    [[B:%.*]] = icmp ult i32 %X, 10
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %A = icmp slt i32 %X, 10
   %B = icmp ult i32 %X, 10
   %C = and i1 %A, %B
   ret i1 %C
 }
 
 define i1 @PR1817_2(i32 %X) {

llvm/trunk/test/Transforms/InstCombine/minmax-fold.ll

 ;
   %cmp = icmp sgt i32 %x, 92
   %cond = select i1 %cmp, i32 92, i32 %x
   %cmp3 = icmp sgt i32 %cond, 11
   %retval = select i1 %cmp3, i32 11, i32 %cond
   ret i32 %retval
 }
 
-; FIXME - vector neglect: FoldAndOfICmps() / FoldOrOfICmps()
-
 define <2 x i32> @test72vec(<2 x i32> %x) {
 ; CHECK-LABEL: @test72vec(
-; CHECK-NEXT:    [[TMP1:%.*]] = icmp slt <2 x i32> %x, <i32 92, i32 92>
 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp slt <2 x i32> %x, <i32 11, i32 11>
-; CHECK-NEXT:    [[TMP3:%.*]] = and <2 x i1> [[TMP1]], [[TMP2]]
-; CHECK-NEXT:    [[RETVAL:%.*]] = select <2 x i1> [[TMP3]], <2 x i32> %x, <2 x i32> <i32 11, i32 11>
+; CHECK-NEXT:    [[RETVAL:%.*]] = select <2 x i1> [[TMP2]], <2 x i32> %x, <2 x i32> <i32 11, i32 11>
 ; CHECK-NEXT:    ret <2 x i32> [[RETVAL]]
 ;
   %cmp = icmp sgt <2 x i32> %x, <i32 92, i32 92>
   %cond = select <2 x i1> %cmp, <2 x i32> <i32 92, i32 92>, <2 x i32> %x
   %cmp3 = icmp sgt <2 x i32> %cond, <i32 11, i32 11>
   %retval = select <2 x i1> %cmp3, <2 x i32> <i32 11, i32 11>, <2 x i32> %cond
   ret <2 x i32> %retval
 }

llvm/trunk/test/Transforms/InstSimplify/icmp-ranges.ll

;
   ret i1 %c
 }
 
 ; x == 13 && x != 17
 
 define i1 @and_eq_ne(i8 %x) {
 ; CHECK-LABEL: @and_eq_ne(
 ; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp eq i8 %x, 13
   %b = icmp ne i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x == 13 && x >=s 17
;
   ret i1 %c
 }
 
 ; x == 13 && x <=s 17
 
 define i1 @and_eq_sle(i8 %x) {
 ; CHECK-LABEL: @and_eq_sle(
 ; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp eq i8 %x, 13
   %b = icmp sle i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x == 13 && x <s 17
 
 define i1 @and_eq_slt(i8 %x) {
 ; CHECK-LABEL: @and_eq_slt(
 ; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp eq i8 %x, 13
   %b = icmp slt i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x == 13 && x >=u 17
;
   ret i1 %c
 }
 
 ; x == 13 && x <=u 17
 
 define i1 @and_eq_ule(i8 %x) {
 ; CHECK-LABEL: @and_eq_ule(
 ; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp eq i8 %x, 13
   %b = icmp ule i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x == 13 && x <u 17
 
 define i1 @and_eq_ult(i8 %x) {
 ; CHECK-LABEL: @and_eq_ult(
 ; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp eq i8 %x, 13
   %b = icmp ult i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; ne
 ; x != 13 && x == 17
 
 define i1 @and_ne_eq(i8 %x) {
 ; CHECK-LABEL: @and_ne_eq(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ne i8 %x, 13
   %b = icmp eq i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x != 13 && x != 17
;
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x != 13 && x >=s 17
 
 define i1 @and_ne_sge(i8 %x) {
 ; CHECK-LABEL: @and_ne_sge(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ne i8 %x, 13
   %b = icmp sge i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x != 13 && x >s 17
 
 define i1 @and_ne_sgt(i8 %x) {
 ; CHECK-LABEL: @and_ne_sgt(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ne i8 %x, 13
   %b = icmp sgt i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x != 13 && x <=s 17
;
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x != 13 && x >=u 17
 
 define i1 @and_ne_uge(i8 %x) {
 ; CHECK-LABEL: @and_ne_uge(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ne i8 %x, 13
   %b = icmp uge i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x != 13 && x >u 17
 
 define i1 @and_ne_ugt(i8 %x) {
 ; CHECK-LABEL: @and_ne_ugt(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ne i8 %x, 13
   %b = icmp ugt i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x != 13 && x <=u 17
;
   ret i1 %c
 }
 
 ; sge
 ; x >=s 13 && x == 17
 
 define i1 @and_sge_eq(i8 %x) {
 ; CHECK-LABEL: @and_sge_eq(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sge i8 %x, 13
   %b = icmp eq i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >=s 13 && x != 17
;
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >=s 13 && x >=s 17
 
 define i1 @and_sge_sge(i8 %x) {
 ; CHECK-LABEL: @and_sge_sge(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sge i8 %x, 13
   %b = icmp sge i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >=s 13 && x >s 17
 
 define i1 @and_sge_sgt(i8 %x) {
 ; CHECK-LABEL: @and_sge_sgt(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sge i8 %x, 13
   %b = icmp sgt i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >=s 13 && x <=s 17
;
   ret i1 %c
 }
 
 ; sgt
 ; x >s 13 && x == 17
 
 define i1 @and_sgt_eq(i8 %x) {
 ; CHECK-LABEL: @and_sgt_eq(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sgt i8 %x, 13
   %b = icmp eq i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >s 13 && x != 17
;
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >s 13 && x >=s 17
 
 define i1 @and_sgt_sge(i8 %x) {
 ; CHECK-LABEL: @and_sgt_sge(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sgt i8 %x, 13
   %b = icmp sge i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >s 13 && x >s 17
 
 define i1 @and_sgt_sgt(i8 %x) {
 ; CHECK-LABEL: @and_sgt_sgt(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sgt i8 %x, 13
   %b = icmp sgt i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >s 13 && x <=s 17
;
   ret i1 %c
 }
 
 ; x <=s 13 && x != 17
 
 define i1 @and_sle_ne(i8 %x) {
 ; CHECK-LABEL: @and_sle_ne(
 ; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sle i8 %x, 13
   %b = icmp ne i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <=s 13 && x >=s 17
;
   ret i1 %c
 }
 
 ; x <=s 13 && x <=s 17
 
 define i1 @and_sle_sle(i8 %x) {
 ; CHECK-LABEL: @and_sle_sle(
 ; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sle i8 %x, 13
   %b = icmp sle i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <=s 13 && x <s 17
 
 define i1 @and_sle_slt(i8 %x) {
 ; CHECK-LABEL: @and_sle_slt(
 ; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sle i8 %x, 13
   %b = icmp slt i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <=s 13 && x >=u 17
;
   ret i1 %c
 }
 
 ; x <s 13 && x != 17
 
 define i1 @and_slt_ne(i8 %x) {
 ; CHECK-LABEL: @and_slt_ne(
 ; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp slt i8 %x, 13
   %b = icmp ne i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <s 13 && x >=s 17
;
   ret i1 %c
 }
 
 ; x <s 13 && x <=s 17
 
 define i1 @and_slt_sle(i8 %x) {
 ; CHECK-LABEL: @and_slt_sle(
 ; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp slt i8 %x, 13
   %b = icmp sle i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <s 13 && x <s 17
 
 define i1 @and_slt_slt(i8 %x) {
 ; CHECK-LABEL: @and_slt_slt(
 ; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp slt i8 %x, 13
   %b = icmp slt i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <s 13 && x >=u 17
;
   ret i1 %c
 }
 
 ; uge
 ; x >=u 13 && x == 17
 
 define i1 @and_uge_eq(i8 %x) {
 ; CHECK-LABEL: @and_uge_eq(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp uge i8 %x, 13
   %b = icmp eq i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >=u 13 && x != 17
;
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >=u 13 && x >=s 17
 
 define i1 @and_uge_sge(i8 %x) {
 ; CHECK-LABEL: @and_uge_sge(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp uge i8 %x, 13
   %b = icmp sge i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >=u 13 && x >s 17
 
 define i1 @and_uge_sgt(i8 %x) {
 ; CHECK-LABEL: @and_uge_sgt(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp uge i8 %x, 13
   %b = icmp sgt i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >=u 13 && x <=s 17
;
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >=u 13 && x >=u 17
 
 define i1 @and_uge_uge(i8 %x) {
 ; CHECK-LABEL: @and_uge_uge(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp uge i8 %x, 13
   %b = icmp uge i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >=u 13 && x >u 17
 
 define i1 @and_uge_ugt(i8 %x) {
 ; CHECK-LABEL: @and_uge_ugt(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp uge i8 %x, 13
   %b = icmp ugt i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >=u 13 && x <=u 17
;
   ret i1 %c
 }
 
 ; ugt
 ; x >u 13 && x == 17
 
 define i1 @and_ugt_eq(i8 %x) {
 ; CHECK-LABEL: @and_ugt_eq(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ugt i8 %x, 13
   %b = icmp eq i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >u 13 && x != 17
;
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >u 13 && x >=s 17
 
 define i1 @and_ugt_sge(i8 %x) {
 ; CHECK-LABEL: @and_ugt_sge(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ugt i8 %x, 13
   %b = icmp sge i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >u 13 && x >s 17
 
 define i1 @and_ugt_sgt(i8 %x) {
 ; CHECK-LABEL: @and_ugt_sgt(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ugt i8 %x, 13
   %b = icmp sgt i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >u 13 && x <=s 17
;
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >u 13 && x >=u 17
 
 define i1 @and_ugt_uge(i8 %x) {
 ; CHECK-LABEL: @and_ugt_uge(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ugt i8 %x, 13
   %b = icmp uge i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >u 13 && x >u 17
 
 define i1 @and_ugt_ugt(i8 %x) {
 ; CHECK-LABEL: @and_ugt_ugt(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ugt i8 %x, 13
   %b = icmp ugt i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >u 13 && x <=u 17
;
   ret i1 %c
 }
 
 ; x <=u 13 && x != 17
 
 define i1 @and_ule_ne(i8 %x) {
 ; CHECK-LABEL: @and_ule_ne(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ule i8 %x, 13
   %b = icmp ne i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <=u 13 && x >=s 17
;
   ret i1 %c
 }
 
 ; x <=u 13 && x <=s 17
 
 define i1 @and_ule_sle(i8 %x) {
 ; CHECK-LABEL: @and_ule_sle(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ule i8 %x, 13
   %b = icmp sle i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <=u 13 && x <s 17
 
 define i1 @and_ule_slt(i8 %x) {
 ; CHECK-LABEL: @and_ule_slt(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ule i8 %x, 13
   %b = icmp slt i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <=u 13 && x >=u 17
;
   ret i1 %c
 }
 
 ; x <=u 13 && x <=u 17
 
 define i1 @and_ule_ule(i8 %x) {
 ; CHECK-LABEL: @and_ule_ule(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ule i8 %x, 13
   %b = icmp ule i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <=u 13 && x <u 17
 
 define i1 @and_ule_ult(i8 %x) {
 ; CHECK-LABEL: @and_ule_ult(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ule i8 %x, 13
   %b = icmp ult i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; ult
;
   ret i1 %c
 }
 
 ; x <u 13 && x != 17
 
 define i1 @and_ult_ne(i8 %x) {
 ; CHECK-LABEL: @and_ult_ne(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ult i8 %x, 13
   %b = icmp ne i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <u 13 && x >=s 17
;
   ret i1 %c
 }
 
 ; x <u 13 && x <=s 17
 
 define i1 @and_ult_sle(i8 %x) {
 ; CHECK-LABEL: @and_ult_sle(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ult i8 %x, 13
   %b = icmp sle i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <u 13 && x <s 17
 
 define i1 @and_ult_slt(i8 %x) {
 ; CHECK-LABEL: @and_ult_slt(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ult i8 %x, 13
   %b = icmp slt i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <u 13 && x >=u 17
;
   ret i1 %c
 }
 
 ; x <u 13 && x <=u 17
 
 define i1 @and_ult_ule(i8 %x) {
 ; CHECK-LABEL: @and_ult_ule(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ult i8 %x, 13
   %b = icmp ule i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <u 13 && x <u 17
 
 define i1 @and_ult_ult(i8 %x) {
 ; CHECK-LABEL: @and_ult_ult(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ult i8 %x, 13
   %b = icmp ult i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; eq
;
   ret i1 %c
 }
 
 ; x == 23 && x != 17
 
 define i1 @and_eq_ne_swap(i8 %x) {
 ; CHECK-LABEL: @and_eq_ne_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp eq i8 %x, 23
   %b = icmp ne i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x == 23 && x >=s 17
 
 define i1 @and_eq_sge_swap(i8 %x) {
 ; CHECK-LABEL: @and_eq_sge_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp eq i8 %x, 23
   %b = icmp sge i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x == 23 && x >s 17
 
 define i1 @and_eq_sgt_swap(i8 %x) {
 ; CHECK-LABEL: @and_eq_sgt_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp eq i8 %x, 23
   %b = icmp sgt i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x == 23 && x <=s 17
;
   ret i1 %c
 }
 
 ; x == 23 && x >=u 17
 
 define i1 @and_eq_uge_swap(i8 %x) {
 ; CHECK-LABEL: @and_eq_uge_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp eq i8 %x, 23
   %b = icmp uge i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x == 23 && x >u 17
 
 define i1 @and_eq_ugt_swap(i8 %x) {
 ; CHECK-LABEL: @and_eq_ugt_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp eq i8 %x, 23
   %b = icmp ugt i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x == 23 && x <=u 17
;
   ret i1 %c
 }
 
 ; ne
 ; x != 23 && x == 17
 
 define i1 @and_ne_eq_swap(i8 %x) {
 ; CHECK-LABEL: @and_ne_eq_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ne i8 %x, 23
   %b = icmp eq i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x != 23 && x != 17
;
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x != 23 && x <=s 17
 
 define i1 @and_ne_sle_swap(i8 %x) {
 ; CHECK-LABEL: @and_ne_sle_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ne i8 %x, 23
   %b = icmp sle i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x != 23 && x <s 17
 
 define i1 @and_ne_slt_swap(i8 %x) {
 ; CHECK-LABEL: @and_ne_slt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ne i8 %x, 23
   %b = icmp slt i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x != 23 && x >=u 17
;
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x != 23 && x <=u 17
 
 define i1 @and_ne_ule_swap(i8 %x) {
 ; CHECK-LABEL: @and_ne_ule_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ne i8 %x, 23
   %b = icmp ule i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x != 23 && x <u 17
 
 define i1 @and_ne_ult_swap(i8 %x) {
 ; CHECK-LABEL: @and_ne_ult_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ne i8 %x, 23
   %b = icmp ult i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; sge
;
   ret i1 %c
 }
 
 ; x >=s 23 && x != 17
 
 define i1 @and_sge_ne_swap(i8 %x) {
 ; CHECK-LABEL: @and_sge_ne_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sge i8 %x, 23
   %b = icmp ne i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >=s 23 && x >=s 17
 
 define i1 @and_sge_sge_swap(i8 %x) {
 ; CHECK-LABEL: @and_sge_sge_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sge i8 %x, 23
   %b = icmp sge i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >=s 23 && x >s 17
 
 define i1 @and_sge_sgt_swap(i8 %x) {
 ; CHECK-LABEL: @and_sge_sgt_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sge i8 %x, 23
   %b = icmp sgt i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >=s 23 && x <=s 17
;
   ret i1 %c
 }
 
 ; x >=s 23 && x >=u 17
 
 define i1 @and_sge_uge_swap(i8 %x) {
 ; CHECK-LABEL: @and_sge_uge_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sge i8 %x, 23
   %b = icmp uge i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >=s 23 && x >u 17
 
 define i1 @and_sge_ugt_swap(i8 %x) {
 ; CHECK-LABEL: @and_sge_ugt_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sge i8 %x, 23
   %b = icmp ugt i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >=s 23 && x <=u 17
;
   ret i1 %c
 }
 
 ; x >s 23 && x != 17
 
 define i1 @and_sgt_ne_swap(i8 %x) {
 ; CHECK-LABEL: @and_sgt_ne_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sgt i8 %x, 23
   %b = icmp ne i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >s 23 && x >=s 17
 
 define i1 @and_sgt_sge_swap(i8 %x) {
 ; CHECK-LABEL: @and_sgt_sge_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sgt i8 %x, 23
   %b = icmp sge i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >s 23 && x >s 17
 
 define i1 @and_sgt_sgt_swap(i8 %x) {
 ; CHECK-LABEL: @and_sgt_sgt_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sgt i8 %x, 23
   %b = icmp sgt i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >s 23 && x <=s 17
;
   ret i1 %c
 }
 
 ; x >s 23 && x >=u 17
 
 define i1 @and_sgt_uge_swap(i8 %x) {
 ; CHECK-LABEL: @and_sgt_uge_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sgt i8 %x, 23
   %b = icmp uge i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >s 23 && x >u 17
 
 define i1 @and_sgt_ugt_swap(i8 %x) {
 ; CHECK-LABEL: @and_sgt_ugt_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sgt i8 %x, 23
   %b = icmp ugt i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >s 23 && x <=u 17
;
   ret i1 %c
 }
 
 ; sle
 ; x <=s 23 && x == 17
 
 define i1 @and_sle_eq_swap(i8 %x) {
 ; CHECK-LABEL: @and_sle_eq_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sle i8 %x, 23
   %b = icmp eq i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <=s 23 && x != 17
;
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <=s 23 && x <=s 17
 
 define i1 @and_sle_sle_swap(i8 %x) {
 ; CHECK-LABEL: @and_sle_sle_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sle i8 %x, 23
   %b = icmp sle i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <=s 23 && x <s 17
 
 define i1 @and_sle_slt_swap(i8 %x) {
 ; CHECK-LABEL: @and_sle_slt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sle i8 %x, 23
   %b = icmp slt i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <=s 23 && x >=u 17
;
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <=s 23 && x <=u 17
 
 define i1 @and_sle_ule_swap(i8 %x) {
 ; CHECK-LABEL: @and_sle_ule_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sle i8 %x, 23
   %b = icmp ule i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <=s 23 && x <u 17
 
 define i1 @and_sle_ult_swap(i8 %x) {
 ; CHECK-LABEL: @and_sle_ult_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sle i8 %x, 23
   %b = icmp ult i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; slt
 ; x <s 23 && x == 17
 
 define i1 @and_slt_eq_swap(i8 %x) {
 ; CHECK-LABEL: @and_slt_eq_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp slt i8 %x, 23
   %b = icmp eq i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <s 23 && x != 17
;
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <s 23 && x <=s 17
 
 define i1 @and_slt_sle_swap(i8 %x) {
 ; CHECK-LABEL: @and_slt_sle_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp slt i8 %x, 23
   %b = icmp sle i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <s 23 && x <s 17
 
 define i1 @and_slt_slt_swap(i8 %x) {
 ; CHECK-LABEL: @and_slt_slt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp slt i8 %x, 23
   %b = icmp slt i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <s 23 && x >=u 17
;
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <s 23 && x <=u 17
 
 define i1 @and_slt_ule_swap(i8 %x) {
 ; CHECK-LABEL: @and_slt_ule_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp slt i8 %x, 23
   %b = icmp ule i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <s 23 && x <u 17
 
 define i1 @and_slt_ult_swap(i8 %x) {
 ; CHECK-LABEL: @and_slt_ult_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp slt i8 %x, 23
   %b = icmp ult i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; uge
;
   ret i1 %c
 }
 
 ; x >=u 23 && x != 17
 
 define i1 @and_uge_ne_swap(i8 %x) {
 ; CHECK-LABEL: @and_uge_ne_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp uge i8 %x, 23
   %b = icmp ne i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >=u 23 && x >=s 17
;
   ret i1 %c
 }
 
 ; x >=u 23 && x >=u 17
 
 define i1 @and_uge_uge_swap(i8 %x) {
 ; CHECK-LABEL: @and_uge_uge_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp uge i8 %x, 23
   %b = icmp uge i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >=u 23 && x >u 17
 
 define i1 @and_uge_ugt_swap(i8 %x) {
 ; CHECK-LABEL: @and_uge_ugt_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp uge i8 %x, 23
   %b = icmp ugt i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >=u 23 && x <=u 17
;
   ret i1 %c
 }
 
 ; x >u 23 && x != 17
 
 define i1 @and_ugt_ne_swap(i8 %x) {
 ; CHECK-LABEL: @and_ugt_ne_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ugt i8 %x, 23
   %b = icmp ne i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >u 23 && x >=s 17
;
   ret i1 %c
 }
 
 ; x >u 23 && x >=u 17
 
 define i1 @and_ugt_uge_swap(i8 %x) {
 ; CHECK-LABEL: @and_ugt_uge_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ugt i8 %x, 23
   %b = icmp uge i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >u 23 && x >u 17
 
 define i1 @and_ugt_ugt_swap(i8 %x) {
 ; CHECK-LABEL: @and_ugt_ugt_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ugt i8 %x, 23
   %b = icmp ugt i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x >u 23 && x <=u 17
;
   ret i1 %c
 }
 
 ; ule
 ; x <=u 23 && x == 17
 
 define i1 @and_ule_eq_swap(i8 %x) {
 ; CHECK-LABEL: @and_ule_eq_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ule i8 %x, 23
   %b = icmp eq i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <=u 23 && x != 17
;
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <=u 23 && x <=u 17
 
 define i1 @and_ule_ule_swap(i8 %x) {
 ; CHECK-LABEL: @and_ule_ule_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ule i8 %x, 23
   %b = icmp ule i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <=u 23 && x <u 17
 
 define i1 @and_ule_ult_swap(i8 %x) {
 ; CHECK-LABEL: @and_ule_ult_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ule i8 %x, 23
   %b = icmp ult i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; ult
 ; x <u 23 && x == 17
 
 define i1 @and_ult_eq_swap(i8 %x) {
 ; CHECK-LABEL: @and_ult_eq_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ult i8 %x, 23
   %b = icmp eq i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <u 23 && x != 17
;
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <u 23 && x <=u 17
 
 define i1 @and_ult_ule_swap(i8 %x) {
 ; CHECK-LABEL: @and_ult_ule_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ult i8 %x, 23
   %b = icmp ule i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; x <u 23 && x <u 17
 
 define i1 @and_ult_ult_swap(i8 %x) {
 ; CHECK-LABEL: @and_ult_ult_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ult i8 %x, 23
   %b = icmp ult i8 %x, 17
   %c = and i1 %a, %b
   ret i1 %c
 }
 
 ; Special case - slt is uge