From 599e65b1ff51d4f92ebf68696adb0955788db051 Mon Sep 17 00:00:00 2001
From: Sanjay Patel <spatel@rotateright.com>
Date: Sun, 7 May 2017 15:11:40 +0000
Subject: [PATCH] [InstSimplify] use ConstantRange to simplify or-of-icmps

We can simplify (or (icmp X, C1), (icmp X, C2)) to 'true' or 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 deleted code in instcombine was completely ignoring predicates with
mismatched signedness.

This is a follow-up to:
https://reviews.llvm.org/rL301260
https://reviews.llvm.org/D32143

llvm-svn: 302370
---
 llvm/lib/Analysis/InstructionSimplify.cpp          |  66 ++-
 .../Transforms/InstCombine/InstCombineAndOrXor.cpp |  57 +--
 .../2005-06-16-SetCCOrSetCCMiscompile.ll           |  14 -
 llvm/test/Transforms/InstCombine/and-or-icmps.ll   |   4 +-
 llvm/test/Transforms/InstCombine/or.ll             |  11 -
 llvm/test/Transforms/InstSimplify/icmp-ranges.ll   | 546 +++++----------------
 6 files changed, 176 insertions(+), 522 deletions(-)
 delete mode 100644 llvm/test/Transforms/InstCombine/2005-06-16-SetCCOrSetCCMiscompile.ll

diff --git a/llvm/lib/Analysis/InstructionSimplify.cpp b/llvm/lib/Analysis/InstructionSimplify.cpp
index 43e387b..18ac369 100644
--- a/llvm/lib/Analysis/InstructionSimplify.cpp
+++ b/llvm/lib/Analysis/InstructionSimplify.cpp
@@ -1519,6 +1519,46 @@ static Value *simplifyOrOfICmpsWithSameOperands(ICmpInst *Op0, ICmpInst *Op1) {
   return nullptr;
 }
 
+/// Test if a pair of compares with a shared operand and 2 constants has an
+/// empty set intersection, full set union, or if one compare is a superset of
+/// the other.
+static Value *simplifyAndOrOfICmpsWithConstants(ICmpInst *Cmp0, ICmpInst *Cmp1,
+                                                bool IsAnd) {
+  // Look for this pattern: {and/or} (icmp X, C0), (icmp X, C1)).
+  if (Cmp0->getOperand(0) != Cmp1->getOperand(0))
+    return nullptr;
+
+  const APInt *C0, *C1;
+  if (!match(Cmp0->getOperand(1), m_APInt(C0)) ||
+      !match(Cmp1->getOperand(1), m_APInt(C1)))
+    return nullptr;
+
+  auto Range0 = ConstantRange::makeExactICmpRegion(Cmp0->getPredicate(), *C0);
+  auto Range1 = ConstantRange::makeExactICmpRegion(Cmp1->getPredicate(), *C1);
+
+  // For and-of-comapares, check if the intersection is empty:
+  // (icmp X, C0) && (icmp X, C1) --> empty set --> false
+  if (IsAnd && Range0.intersectWith(Range1).isEmptySet())
+    return getFalse(Cmp0->getType());
+
+  // For or-of-compares, check if the union is full:
+  // (icmp X, C0) || (icmp X, C1) --> full set --> true
+  if (!IsAnd && Range0.unionWith(Range1).isFullSet())
+    return getTrue(Cmp0->getType());
+
+  // Is one range a superset of the other?
+  // If this is and-of-compares, take the smaller set:
+  // (icmp sgt X, 4) && (icmp sgt X, 42) --> icmp sgt X, 42
+  // If this is or-of-compares, take the larger set:
+  // (icmp sgt X, 4) || (icmp sgt X, 42) --> icmp sgt X, 4
+  if (Range0.contains(Range1))
+    return IsAnd ? Cmp1 : Cmp0;
+  if (Range1.contains(Range0))
+    return IsAnd ? Cmp0 : Cmp1;
+
+  return nullptr;
+}
+
 /// Commuted variants are assumed to be handled by calling this function again
 /// with the parameters swapped.
 static Value *simplifyAndOfICmps(ICmpInst *Op0, ICmpInst *Op1) {
@@ -1528,29 +1568,14 @@ static Value *simplifyAndOfICmps(ICmpInst *Op0, ICmpInst *Op1) {
   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)).
+  if (Value *X = simplifyAndOrOfICmpsWithConstants(Op0, Op1, true))
+    return X;
+
+  // (icmp (add V, C0), C1) & (icmp V, C0)
   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::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;
 
@@ -1600,6 +1625,9 @@ static Value *simplifyOrOfICmps(ICmpInst *Op0, ICmpInst *Op1) {
   if (Value *X = simplifyOrOfICmpsWithSameOperands(Op0, Op1))
     return X;
 
+  if (Value *X = simplifyAndOrOfICmpsWithConstants(Op0, Op1, false))
+    return X;
+
   // (icmp (add V, C0), C1) | (icmp V, C0)
   ICmpInst::Predicate Pred0, Pred1;
   const APInt *C0, *C1;
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp b/llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
index c7092bf..b114801 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
@@ -1834,25 +1834,8 @@ Value *InstCombiner::FoldOrOfICmps(ICmpInst *LHS, ICmpInst *RHS,
     case ICmpInst::ICMP_UGT: // (X == 13 | X u> 14) -> no change
     case ICmpInst::ICMP_SGT: // (X == 13 | X s> 14) -> no change
       break;
-    case ICmpInst::ICMP_NE:  // (X == 13 | X != 15) -> X != 15
-    case ICmpInst::ICMP_ULT: // (X == 13 | X u< 15) -> X u< 15
-    case ICmpInst::ICMP_SLT: // (X == 13 | X s< 15) -> X s< 15
-      return RHS;
     }
     break;
-  case ICmpInst::ICMP_NE:
-    switch (PredR) {
-    default:
-      llvm_unreachable("Unknown integer condition code!");
-    case ICmpInst::ICMP_EQ:  // (X != 13 | X == 15) -> X != 13
-    case ICmpInst::ICMP_UGT: // (X != 13 | X u> 15) -> X != 13
-    case ICmpInst::ICMP_SGT: // (X != 13 | X s> 15) -> X != 13
-      return LHS;
-    case ICmpInst::ICMP_NE:  // (X != 13 | X != 15) -> true
-    case ICmpInst::ICMP_ULT: // (X != 13 | X u< 15) -> true
-    case ICmpInst::ICMP_SLT: // (X != 13 | X s< 15) -> true
-      return Builder->getTrue();
-    }
   case ICmpInst::ICMP_ULT:
     switch (PredR) {
     default:
@@ -1860,15 +1843,9 @@ Value *InstCombiner::FoldOrOfICmps(ICmpInst *LHS, ICmpInst *RHS,
     case ICmpInst::ICMP_EQ: // (X u< 13 | X == 14) -> no change
       break;
     case ICmpInst::ICMP_UGT: // (X u< 13 | X u> 15) -> (X-13) u> 2
-      // If RHSC is [us]MAXINT, it is always false.  Not handling
-      // this can cause overflow.
-      if (RHSC->isMaxValue(false))
-        return LHS;
+      assert(!RHSC->isMaxValue(false) && "Missed icmp simplification");
       return insertRangeTest(LHS0, LHSC->getValue(), RHSC->getValue() + 1,
                              false, false);
-    case ICmpInst::ICMP_NE:  // (X u< 13 | X != 15) -> X != 15
-    case ICmpInst::ICMP_ULT: // (X u< 13 | X u< 15) -> X u< 15
-      return RHS;
     }
     break;
   case ICmpInst::ICMP_SLT:
@@ -1878,39 +1855,9 @@ Value *InstCombiner::FoldOrOfICmps(ICmpInst *LHS, ICmpInst *RHS,
     case ICmpInst::ICMP_EQ: // (X s< 13 | X == 14) -> no change
       break;
     case ICmpInst::ICMP_SGT: // (X s< 13 | X s> 15) -> (X-13) s> 2
-      // If RHSC is [us]MAXINT, it is always false.  Not handling
-      // this can cause overflow.
-      if (RHSC->isMaxValue(true))
-        return LHS;
+      assert(!RHSC->isMaxValue(true) && "Missed icmp simplification");
       return insertRangeTest(LHS0, LHSC->getValue(), RHSC->getValue() + 1, true,
                              false);
-    case ICmpInst::ICMP_NE:  // (X s< 13 | X != 15) -> X != 15
-    case ICmpInst::ICMP_SLT: // (X s< 13 | X s< 15) -> X s< 15
-      return RHS;
-    }
-    break;
-  case ICmpInst::ICMP_UGT:
-    switch (PredR) {
-    default:
-      llvm_unreachable("Unknown integer condition code!");
-    case ICmpInst::ICMP_EQ:  // (X u> 13 | X == 15) -> X u> 13
-    case ICmpInst::ICMP_UGT: // (X u> 13 | X u> 15) -> X u> 13
-      return LHS;
-    case ICmpInst::ICMP_NE:  // (X u> 13 | X != 15) -> true
-    case ICmpInst::ICMP_ULT: // (X u> 13 | X u< 15) -> true
-      return Builder->getTrue();
-    }
-    break;
-  case ICmpInst::ICMP_SGT:
-    switch (PredR) {
-    default:
-      llvm_unreachable("Unknown integer condition code!");
-    case ICmpInst::ICMP_EQ:  // (X s> 13 | X == 15) -> X > 13
-    case ICmpInst::ICMP_SGT: // (X s> 13 | X s> 15) -> X > 13
-      return LHS;
-    case ICmpInst::ICMP_NE:  // (X s> 13 | X != 15) -> true
-    case ICmpInst::ICMP_SLT: // (X s> 13 | X s< 15) -> true
-      return Builder->getTrue();
     }
     break;
   }
diff --git a/llvm/test/Transforms/InstCombine/2005-06-16-SetCCOrSetCCMiscompile.ll b/llvm/test/Transforms/InstCombine/2005-06-16-SetCCOrSetCCMiscompile.ll
deleted file mode 100644
index 9c989b9..0000000
--- a/llvm/test/Transforms/InstCombine/2005-06-16-SetCCOrSetCCMiscompile.ll
+++ /dev/null
@@ -1,14 +0,0 @@
-; RUN: opt < %s -instcombine -S | \
-; RUN:   grep "ret i1 true"
-; PR586
-
-@g_07918478 = external global i32               ; <i32*> [#uses=1]
-
-define i1 @test() {
-        %tmp.0 = load i32, i32* @g_07918478          ; <i32> [#uses=2]
-        %tmp.1 = icmp ne i32 %tmp.0, 0          ; <i1> [#uses=1]
-        %tmp.4 = icmp ult i32 %tmp.0, 4111              ; <i1> [#uses=1]
-        %bothcond = or i1 %tmp.1, %tmp.4                ; <i1> [#uses=1]
-        ret i1 %bothcond
-}
-
diff --git a/llvm/test/Transforms/InstCombine/and-or-icmps.ll b/llvm/test/Transforms/InstCombine/and-or-icmps.ll
index 464f390..165f5d1 100644
--- a/llvm/test/Transforms/InstCombine/and-or-icmps.ll
+++ b/llvm/test/Transforms/InstCombine/and-or-icmps.ll
@@ -15,9 +15,7 @@ define i1 @PR1817_1(i32 %X) {
 define i1 @PR1817_2(i32 %X) {
 ; CHECK-LABEL: @PR1817_2(
 ; CHECK-NEXT:    [[A:%.*]] = icmp slt i32 %X, 10
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i32 %X, 10
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %A = icmp slt i32 %X, 10
   %B = icmp ult i32 %X, 10
diff --git a/llvm/test/Transforms/InstCombine/or.ll b/llvm/test/Transforms/InstCombine/or.ll
index 9ae5eaf..bfafd66 100644
--- a/llvm/test/Transforms/InstCombine/or.ll
+++ b/llvm/test/Transforms/InstCombine/or.ll
@@ -661,17 +661,6 @@ define i1 @test47(i8 signext %c)  {
   ret i1 %or
 }
 
-define i1 @test48(i64 %x, i1 %b) {
-; CHECK-LABEL: @test48(
-; CHECK-NEXT:    ret i1 true
-;
-  %1 = icmp ult i64 %x, 2305843009213693952
-  %2 = icmp ugt i64 %x, 2305843009213693951
-  %.b = or i1 %2, %b
-  %3 = or i1 %1, %.b
-  ret i1 %3
-}
-
 define i32 @test49(i1 %C) {
 ; CHECK-LABEL: @test49(
 ; CHECK-NEXT:    [[V:%.*]] = select i1 [[C:%.*]], i32 1019, i32 123
diff --git a/llvm/test/Transforms/InstSimplify/icmp-ranges.ll b/llvm/test/Transforms/InstSimplify/icmp-ranges.ll
index 8c0e95b..45194f2 100644
--- a/llvm/test/Transforms/InstSimplify/icmp-ranges.ll
+++ b/llvm/test/Transforms/InstSimplify/icmp-ranges.ll
@@ -2749,10 +2749,8 @@ define i1 @or_eq_eq(i8 %x) {
 
 define i1 @or_eq_ne(i8 %x) {
 ; CHECK-LABEL: @or_eq_ne(
-; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp eq i8 %x, 13
   %b = icmp ne i8 %x, 17
@@ -2794,10 +2792,8 @@ define i1 @or_eq_sgt(i8 %x) {
 
 define i1 @or_eq_sle(i8 %x) {
 ; CHECK-LABEL: @or_eq_sle(
-; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp eq i8 %x, 13
   %b = icmp sle i8 %x, 17
@@ -2809,10 +2805,8 @@ define i1 @or_eq_sle(i8 %x) {
 
 define i1 @or_eq_slt(i8 %x) {
 ; CHECK-LABEL: @or_eq_slt(
-; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp eq i8 %x, 13
   %b = icmp slt i8 %x, 17
@@ -2854,10 +2848,8 @@ define i1 @or_eq_ugt(i8 %x) {
 
 define i1 @or_eq_ule(i8 %x) {
 ; CHECK-LABEL: @or_eq_ule(
-; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp eq i8 %x, 13
   %b = icmp ule i8 %x, 17
@@ -2869,10 +2861,8 @@ define i1 @or_eq_ule(i8 %x) {
 
 define i1 @or_eq_ult(i8 %x) {
 ; CHECK-LABEL: @or_eq_ult(
-; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp eq i8 %x, 13
   %b = icmp ult i8 %x, 17
@@ -2886,9 +2876,7 @@ define i1 @or_eq_ult(i8 %x) {
 define i1 @or_ne_eq(i8 %x) {
 ; CHECK-LABEL: @or_ne_eq(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ne i8 %x, 13
   %b = icmp eq i8 %x, 17
@@ -2900,10 +2888,7 @@ define i1 @or_ne_eq(i8 %x) {
 
 define i1 @or_ne_ne(i8 %x) {
 ; CHECK-LABEL: @or_ne_ne(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp ne i8 %x, 13
   %b = icmp ne i8 %x, 17
@@ -2916,9 +2901,7 @@ define i1 @or_ne_ne(i8 %x) {
 define i1 @or_ne_sge(i8 %x) {
 ; CHECK-LABEL: @or_ne_sge(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ne i8 %x, 13
   %b = icmp sge i8 %x, 17
@@ -2931,9 +2914,7 @@ define i1 @or_ne_sge(i8 %x) {
 define i1 @or_ne_sgt(i8 %x) {
 ; CHECK-LABEL: @or_ne_sgt(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ne i8 %x, 13
   %b = icmp sgt i8 %x, 17
@@ -2945,10 +2926,7 @@ define i1 @or_ne_sgt(i8 %x) {
 
 define i1 @or_ne_sle(i8 %x) {
 ; CHECK-LABEL: @or_ne_sle(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp ne i8 %x, 13
   %b = icmp sle i8 %x, 17
@@ -2960,10 +2938,7 @@ define i1 @or_ne_sle(i8 %x) {
 
 define i1 @or_ne_slt(i8 %x) {
 ; CHECK-LABEL: @or_ne_slt(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp ne i8 %x, 13
   %b = icmp slt i8 %x, 17
@@ -2976,9 +2951,7 @@ define i1 @or_ne_slt(i8 %x) {
 define i1 @or_ne_uge(i8 %x) {
 ; CHECK-LABEL: @or_ne_uge(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ne i8 %x, 13
   %b = icmp uge i8 %x, 17
@@ -2991,9 +2964,7 @@ define i1 @or_ne_uge(i8 %x) {
 define i1 @or_ne_ugt(i8 %x) {
 ; CHECK-LABEL: @or_ne_ugt(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ne i8 %x, 13
   %b = icmp ugt i8 %x, 17
@@ -3005,10 +2976,7 @@ define i1 @or_ne_ugt(i8 %x) {
 
 define i1 @or_ne_ule(i8 %x) {
 ; CHECK-LABEL: @or_ne_ule(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp ne i8 %x, 13
   %b = icmp ule i8 %x, 17
@@ -3020,10 +2988,7 @@ define i1 @or_ne_ule(i8 %x) {
 
 define i1 @or_ne_ult(i8 %x) {
 ; CHECK-LABEL: @or_ne_ult(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp ne i8 %x, 13
   %b = icmp ult i8 %x, 17
@@ -3037,9 +3002,7 @@ define i1 @or_ne_ult(i8 %x) {
 define i1 @or_sge_eq(i8 %x) {
 ; CHECK-LABEL: @or_sge_eq(
 ; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sge i8 %x, 13
   %b = icmp eq i8 %x, 17
@@ -3051,10 +3014,7 @@ define i1 @or_sge_eq(i8 %x) {
 
 define i1 @or_sge_ne(i8 %x) {
 ; CHECK-LABEL: @or_sge_ne(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp sge i8 %x, 13
   %b = icmp ne i8 %x, 17
@@ -3067,9 +3027,7 @@ define i1 @or_sge_ne(i8 %x) {
 define i1 @or_sge_sge(i8 %x) {
 ; CHECK-LABEL: @or_sge_sge(
 ; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sge i8 %x, 13
   %b = icmp sge i8 %x, 17
@@ -3082,9 +3040,7 @@ define i1 @or_sge_sge(i8 %x) {
 define i1 @or_sge_sgt(i8 %x) {
 ; CHECK-LABEL: @or_sge_sgt(
 ; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sge i8 %x, 13
   %b = icmp sgt i8 %x, 17
@@ -3096,10 +3052,7 @@ define i1 @or_sge_sgt(i8 %x) {
 
 define i1 @or_sge_sle(i8 %x) {
 ; CHECK-LABEL: @or_sge_sle(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp sge i8 %x, 13
   %b = icmp sle i8 %x, 17
@@ -3111,10 +3064,7 @@ define i1 @or_sge_sle(i8 %x) {
 
 define i1 @or_sge_slt(i8 %x) {
 ; CHECK-LABEL: @or_sge_slt(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp sge i8 %x, 13
   %b = icmp slt i8 %x, 17
@@ -3188,9 +3138,7 @@ define i1 @or_sge_ult(i8 %x) {
 define i1 @or_sgt_eq(i8 %x) {
 ; CHECK-LABEL: @or_sgt_eq(
 ; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sgt i8 %x, 13
   %b = icmp eq i8 %x, 17
@@ -3202,10 +3150,7 @@ define i1 @or_sgt_eq(i8 %x) {
 
 define i1 @or_sgt_ne(i8 %x) {
 ; CHECK-LABEL: @or_sgt_ne(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp sgt i8 %x, 13
   %b = icmp ne i8 %x, 17
@@ -3218,9 +3163,7 @@ define i1 @or_sgt_ne(i8 %x) {
 define i1 @or_sgt_sge(i8 %x) {
 ; CHECK-LABEL: @or_sgt_sge(
 ; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sgt i8 %x, 13
   %b = icmp sge i8 %x, 17
@@ -3233,9 +3176,7 @@ define i1 @or_sgt_sge(i8 %x) {
 define i1 @or_sgt_sgt(i8 %x) {
 ; CHECK-LABEL: @or_sgt_sgt(
 ; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sgt i8 %x, 13
   %b = icmp sgt i8 %x, 17
@@ -3247,10 +3188,7 @@ define i1 @or_sgt_sgt(i8 %x) {
 
 define i1 @or_sgt_sle(i8 %x) {
 ; CHECK-LABEL: @or_sgt_sle(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp sgt i8 %x, 13
   %b = icmp sle i8 %x, 17
@@ -3262,10 +3200,7 @@ define i1 @or_sgt_sle(i8 %x) {
 
 define i1 @or_sgt_slt(i8 %x) {
 ; CHECK-LABEL: @or_sgt_slt(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp sgt i8 %x, 13
   %b = icmp slt i8 %x, 17
@@ -3353,10 +3288,8 @@ define i1 @or_sle_eq(i8 %x) {
 
 define i1 @or_sle_ne(i8 %x) {
 ; CHECK-LABEL: @or_sle_ne(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sle i8 %x, 13
   %b = icmp ne i8 %x, 17
@@ -3398,10 +3331,8 @@ define i1 @or_sle_sgt(i8 %x) {
 
 define i1 @or_sle_sle(i8 %x) {
 ; CHECK-LABEL: @or_sle_sle(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sle i8 %x, 13
   %b = icmp sle i8 %x, 17
@@ -3413,10 +3344,8 @@ define i1 @or_sle_sle(i8 %x) {
 
 define i1 @or_sle_slt(i8 %x) {
 ; CHECK-LABEL: @or_sle_slt(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sle i8 %x, 13
   %b = icmp slt i8 %x, 17
@@ -3504,10 +3433,8 @@ define i1 @or_slt_eq(i8 %x) {
 
 define i1 @or_slt_ne(i8 %x) {
 ; CHECK-LABEL: @or_slt_ne(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp slt i8 %x, 13
   %b = icmp ne i8 %x, 17
@@ -3549,10 +3476,8 @@ define i1 @or_slt_sgt(i8 %x) {
 
 define i1 @or_slt_sle(i8 %x) {
 ; CHECK-LABEL: @or_slt_sle(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp slt i8 %x, 13
   %b = icmp sle i8 %x, 17
@@ -3564,10 +3489,8 @@ define i1 @or_slt_sle(i8 %x) {
 
 define i1 @or_slt_slt(i8 %x) {
 ; CHECK-LABEL: @or_slt_slt(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp slt i8 %x, 13
   %b = icmp slt i8 %x, 17
@@ -3641,9 +3564,7 @@ define i1 @or_slt_ult(i8 %x) {
 define i1 @or_uge_eq(i8 %x) {
 ; CHECK-LABEL: @or_uge_eq(
 ; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp uge i8 %x, 13
   %b = icmp eq i8 %x, 17
@@ -3655,10 +3576,7 @@ define i1 @or_uge_eq(i8 %x) {
 
 define i1 @or_uge_ne(i8 %x) {
 ; CHECK-LABEL: @or_uge_ne(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp uge i8 %x, 13
   %b = icmp ne i8 %x, 17
@@ -3671,9 +3589,7 @@ define i1 @or_uge_ne(i8 %x) {
 define i1 @or_uge_sge(i8 %x) {
 ; CHECK-LABEL: @or_uge_sge(
 ; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp uge i8 %x, 13
   %b = icmp sge i8 %x, 17
@@ -3686,9 +3602,7 @@ define i1 @or_uge_sge(i8 %x) {
 define i1 @or_uge_sgt(i8 %x) {
 ; CHECK-LABEL: @or_uge_sgt(
 ; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp uge i8 %x, 13
   %b = icmp sgt i8 %x, 17
@@ -3700,10 +3614,7 @@ define i1 @or_uge_sgt(i8 %x) {
 
 define i1 @or_uge_sle(i8 %x) {
 ; CHECK-LABEL: @or_uge_sle(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp uge i8 %x, 13
   %b = icmp sle i8 %x, 17
@@ -3715,10 +3626,7 @@ define i1 @or_uge_sle(i8 %x) {
 
 define i1 @or_uge_slt(i8 %x) {
 ; CHECK-LABEL: @or_uge_slt(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp uge i8 %x, 13
   %b = icmp slt i8 %x, 17
@@ -3731,9 +3639,7 @@ define i1 @or_uge_slt(i8 %x) {
 define i1 @or_uge_uge(i8 %x) {
 ; CHECK-LABEL: @or_uge_uge(
 ; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp uge i8 %x, 13
   %b = icmp uge i8 %x, 17
@@ -3746,9 +3652,7 @@ define i1 @or_uge_uge(i8 %x) {
 define i1 @or_uge_ugt(i8 %x) {
 ; CHECK-LABEL: @or_uge_ugt(
 ; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp uge i8 %x, 13
   %b = icmp ugt i8 %x, 17
@@ -3760,10 +3664,7 @@ define i1 @or_uge_ugt(i8 %x) {
 
 define i1 @or_uge_ule(i8 %x) {
 ; CHECK-LABEL: @or_uge_ule(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp uge i8 %x, 13
   %b = icmp ule i8 %x, 17
@@ -3775,10 +3676,7 @@ define i1 @or_uge_ule(i8 %x) {
 
 define i1 @or_uge_ult(i8 %x) {
 ; CHECK-LABEL: @or_uge_ult(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp uge i8 %x, 13
   %b = icmp ult i8 %x, 17
@@ -3792,9 +3690,7 @@ define i1 @or_uge_ult(i8 %x) {
 define i1 @or_ugt_eq(i8 %x) {
 ; CHECK-LABEL: @or_ugt_eq(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ugt i8 %x, 13
   %b = icmp eq i8 %x, 17
@@ -3806,10 +3702,7 @@ define i1 @or_ugt_eq(i8 %x) {
 
 define i1 @or_ugt_ne(i8 %x) {
 ; CHECK-LABEL: @or_ugt_ne(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp ugt i8 %x, 13
   %b = icmp ne i8 %x, 17
@@ -3822,9 +3715,7 @@ define i1 @or_ugt_ne(i8 %x) {
 define i1 @or_ugt_sge(i8 %x) {
 ; CHECK-LABEL: @or_ugt_sge(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ugt i8 %x, 13
   %b = icmp sge i8 %x, 17
@@ -3837,9 +3728,7 @@ define i1 @or_ugt_sge(i8 %x) {
 define i1 @or_ugt_sgt(i8 %x) {
 ; CHECK-LABEL: @or_ugt_sgt(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ugt i8 %x, 13
   %b = icmp sgt i8 %x, 17
@@ -3851,10 +3740,7 @@ define i1 @or_ugt_sgt(i8 %x) {
 
 define i1 @or_ugt_sle(i8 %x) {
 ; CHECK-LABEL: @or_ugt_sle(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp ugt i8 %x, 13
   %b = icmp sle i8 %x, 17
@@ -3866,10 +3752,7 @@ define i1 @or_ugt_sle(i8 %x) {
 
 define i1 @or_ugt_slt(i8 %x) {
 ; CHECK-LABEL: @or_ugt_slt(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp ugt i8 %x, 13
   %b = icmp slt i8 %x, 17
@@ -3882,9 +3765,7 @@ define i1 @or_ugt_slt(i8 %x) {
 define i1 @or_ugt_uge(i8 %x) {
 ; CHECK-LABEL: @or_ugt_uge(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ugt i8 %x, 13
   %b = icmp uge i8 %x, 17
@@ -3897,9 +3778,7 @@ define i1 @or_ugt_uge(i8 %x) {
 define i1 @or_ugt_ugt(i8 %x) {
 ; CHECK-LABEL: @or_ugt_ugt(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ugt i8 %x, 13
   %b = icmp ugt i8 %x, 17
@@ -3911,10 +3790,7 @@ define i1 @or_ugt_ugt(i8 %x) {
 
 define i1 @or_ugt_ule(i8 %x) {
 ; CHECK-LABEL: @or_ugt_ule(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp ugt i8 %x, 13
   %b = icmp ule i8 %x, 17
@@ -3926,10 +3802,7 @@ define i1 @or_ugt_ule(i8 %x) {
 
 define i1 @or_ugt_ult(i8 %x) {
 ; CHECK-LABEL: @or_ugt_ult(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp ugt i8 %x, 13
   %b = icmp ult i8 %x, 17
@@ -3957,10 +3830,8 @@ define i1 @or_ule_eq(i8 %x) {
 
 define i1 @or_ule_ne(i8 %x) {
 ; CHECK-LABEL: @or_ule_ne(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ule i8 %x, 13
   %b = icmp ne i8 %x, 17
@@ -4002,10 +3873,8 @@ define i1 @or_ule_sgt(i8 %x) {
 
 define i1 @or_ule_sle(i8 %x) {
 ; CHECK-LABEL: @or_ule_sle(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ule i8 %x, 13
   %b = icmp sle i8 %x, 17
@@ -4017,10 +3886,8 @@ define i1 @or_ule_sle(i8 %x) {
 
 define i1 @or_ule_slt(i8 %x) {
 ; CHECK-LABEL: @or_ule_slt(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ule i8 %x, 13
   %b = icmp slt i8 %x, 17
@@ -4062,10 +3929,8 @@ define i1 @or_ule_ugt(i8 %x) {
 
 define i1 @or_ule_ule(i8 %x) {
 ; CHECK-LABEL: @or_ule_ule(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ule i8 %x, 13
   %b = icmp ule i8 %x, 17
@@ -4077,10 +3942,8 @@ define i1 @or_ule_ule(i8 %x) {
 
 define i1 @or_ule_ult(i8 %x) {
 ; CHECK-LABEL: @or_ule_ult(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ule i8 %x, 13
   %b = icmp ult i8 %x, 17
@@ -4108,10 +3971,8 @@ define i1 @or_ult_eq(i8 %x) {
 
 define i1 @or_ult_ne(i8 %x) {
 ; CHECK-LABEL: @or_ult_ne(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ult i8 %x, 13
   %b = icmp ne i8 %x, 17
@@ -4153,10 +4014,8 @@ define i1 @or_ult_sgt(i8 %x) {
 
 define i1 @or_ult_sle(i8 %x) {
 ; CHECK-LABEL: @or_ult_sle(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ult i8 %x, 13
   %b = icmp sle i8 %x, 17
@@ -4168,10 +4027,8 @@ define i1 @or_ult_sle(i8 %x) {
 
 define i1 @or_ult_slt(i8 %x) {
 ; CHECK-LABEL: @or_ult_slt(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ult i8 %x, 13
   %b = icmp slt i8 %x, 17
@@ -4213,10 +4070,8 @@ define i1 @or_ult_ugt(i8 %x) {
 
 define i1 @or_ult_ule(i8 %x) {
 ; CHECK-LABEL: @or_ult_ule(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ult i8 %x, 13
   %b = icmp ule i8 %x, 17
@@ -4228,10 +4083,8 @@ define i1 @or_ult_ule(i8 %x) {
 
 define i1 @or_ult_ult(i8 %x) {
 ; CHECK-LABEL: @or_ult_ult(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 13
 ; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ult i8 %x, 13
   %b = icmp ult i8 %x, 17
@@ -4259,10 +4112,8 @@ define i1 @or_eq_eq_swap(i8 %x) {
 
 define i1 @or_eq_ne_swap(i8 %x) {
 ; CHECK-LABEL: @or_eq_ne_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp eq i8 %x, 23
   %b = icmp ne i8 %x, 17
@@ -4274,10 +4125,8 @@ define i1 @or_eq_ne_swap(i8 %x) {
 
 define i1 @or_eq_sge_swap(i8 %x) {
 ; CHECK-LABEL: @or_eq_sge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp eq i8 %x, 23
   %b = icmp sge i8 %x, 17
@@ -4289,10 +4138,8 @@ define i1 @or_eq_sge_swap(i8 %x) {
 
 define i1 @or_eq_sgt_swap(i8 %x) {
 ; CHECK-LABEL: @or_eq_sgt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp eq i8 %x, 23
   %b = icmp sgt i8 %x, 17
@@ -4334,10 +4181,8 @@ define i1 @or_eq_slt_swap(i8 %x) {
 
 define i1 @or_eq_uge_swap(i8 %x) {
 ; CHECK-LABEL: @or_eq_uge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp eq i8 %x, 23
   %b = icmp uge i8 %x, 17
@@ -4349,10 +4194,8 @@ define i1 @or_eq_uge_swap(i8 %x) {
 
 define i1 @or_eq_ugt_swap(i8 %x) {
 ; CHECK-LABEL: @or_eq_ugt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp eq i8 %x, 23
   %b = icmp ugt i8 %x, 17
@@ -4396,9 +4239,7 @@ define i1 @or_eq_ult_swap(i8 %x) {
 define i1 @or_ne_eq_swap(i8 %x) {
 ; CHECK-LABEL: @or_ne_eq_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ne i8 %x, 23
   %b = icmp eq i8 %x, 17
@@ -4410,10 +4251,7 @@ define i1 @or_ne_eq_swap(i8 %x) {
 
 define i1 @or_ne_ne_swap(i8 %x) {
 ; CHECK-LABEL: @or_ne_ne_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp ne i8 %x, 23
   %b = icmp ne i8 %x, 17
@@ -4425,10 +4263,7 @@ define i1 @or_ne_ne_swap(i8 %x) {
 
 define i1 @or_ne_sge_swap(i8 %x) {
 ; CHECK-LABEL: @or_ne_sge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp ne i8 %x, 23
   %b = icmp sge i8 %x, 17
@@ -4440,10 +4275,7 @@ define i1 @or_ne_sge_swap(i8 %x) {
 
 define i1 @or_ne_sgt_swap(i8 %x) {
 ; CHECK-LABEL: @or_ne_sgt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp ne i8 %x, 23
   %b = icmp sgt i8 %x, 17
@@ -4456,9 +4288,7 @@ define i1 @or_ne_sgt_swap(i8 %x) {
 define i1 @or_ne_sle_swap(i8 %x) {
 ; CHECK-LABEL: @or_ne_sle_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ne i8 %x, 23
   %b = icmp sle i8 %x, 17
@@ -4471,9 +4301,7 @@ define i1 @or_ne_sle_swap(i8 %x) {
 define i1 @or_ne_slt_swap(i8 %x) {
 ; CHECK-LABEL: @or_ne_slt_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ne i8 %x, 23
   %b = icmp slt i8 %x, 17
@@ -4485,10 +4313,7 @@ define i1 @or_ne_slt_swap(i8 %x) {
 
 define i1 @or_ne_uge_swap(i8 %x) {
 ; CHECK-LABEL: @or_ne_uge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp ne i8 %x, 23
   %b = icmp uge i8 %x, 17
@@ -4500,10 +4325,7 @@ define i1 @or_ne_uge_swap(i8 %x) {
 
 define i1 @or_ne_ugt_swap(i8 %x) {
 ; CHECK-LABEL: @or_ne_ugt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp ne i8 %x, 23
   %b = icmp ugt i8 %x, 17
@@ -4516,9 +4338,7 @@ define i1 @or_ne_ugt_swap(i8 %x) {
 define i1 @or_ne_ule_swap(i8 %x) {
 ; CHECK-LABEL: @or_ne_ule_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ne i8 %x, 23
   %b = icmp ule i8 %x, 17
@@ -4531,9 +4351,7 @@ define i1 @or_ne_ule_swap(i8 %x) {
 define i1 @or_ne_ult_swap(i8 %x) {
 ; CHECK-LABEL: @or_ne_ult_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ne i8 %x, 23
   %b = icmp ult i8 %x, 17
@@ -4561,10 +4379,8 @@ define i1 @or_sge_eq_swap(i8 %x) {
 
 define i1 @or_sge_ne_swap(i8 %x) {
 ; CHECK-LABEL: @or_sge_ne_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sge i8 %x, 23
   %b = icmp ne i8 %x, 17
@@ -4576,10 +4392,8 @@ define i1 @or_sge_ne_swap(i8 %x) {
 
 define i1 @or_sge_sge_swap(i8 %x) {
 ; CHECK-LABEL: @or_sge_sge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sge i8 %x, 23
   %b = icmp sge i8 %x, 17
@@ -4591,10 +4405,8 @@ define i1 @or_sge_sge_swap(i8 %x) {
 
 define i1 @or_sge_sgt_swap(i8 %x) {
 ; CHECK-LABEL: @or_sge_sgt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sge i8 %x, 23
   %b = icmp sgt i8 %x, 17
@@ -4636,10 +4448,8 @@ define i1 @or_sge_slt_swap(i8 %x) {
 
 define i1 @or_sge_uge_swap(i8 %x) {
 ; CHECK-LABEL: @or_sge_uge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sge i8 %x, 23
   %b = icmp uge i8 %x, 17
@@ -4651,10 +4461,8 @@ define i1 @or_sge_uge_swap(i8 %x) {
 
 define i1 @or_sge_ugt_swap(i8 %x) {
 ; CHECK-LABEL: @or_sge_ugt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sge i8 %x, 23
   %b = icmp ugt i8 %x, 17
@@ -4712,10 +4520,8 @@ define i1 @or_sgt_eq_swap(i8 %x) {
 
 define i1 @or_sgt_ne_swap(i8 %x) {
 ; CHECK-LABEL: @or_sgt_ne_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sgt i8 %x, 23
   %b = icmp ne i8 %x, 17
@@ -4727,10 +4533,8 @@ define i1 @or_sgt_ne_swap(i8 %x) {
 
 define i1 @or_sgt_sge_swap(i8 %x) {
 ; CHECK-LABEL: @or_sgt_sge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sgt i8 %x, 23
   %b = icmp sge i8 %x, 17
@@ -4742,10 +4546,8 @@ define i1 @or_sgt_sge_swap(i8 %x) {
 
 define i1 @or_sgt_sgt_swap(i8 %x) {
 ; CHECK-LABEL: @or_sgt_sgt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sgt i8 %x, 23
   %b = icmp sgt i8 %x, 17
@@ -4787,10 +4589,8 @@ define i1 @or_sgt_slt_swap(i8 %x) {
 
 define i1 @or_sgt_uge_swap(i8 %x) {
 ; CHECK-LABEL: @or_sgt_uge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sgt i8 %x, 23
   %b = icmp uge i8 %x, 17
@@ -4802,10 +4602,8 @@ define i1 @or_sgt_uge_swap(i8 %x) {
 
 define i1 @or_sgt_ugt_swap(i8 %x) {
 ; CHECK-LABEL: @or_sgt_ugt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sgt i8 %x, 23
   %b = icmp ugt i8 %x, 17
@@ -4849,9 +4647,7 @@ define i1 @or_sgt_ult_swap(i8 %x) {
 define i1 @or_sle_eq_swap(i8 %x) {
 ; CHECK-LABEL: @or_sle_eq_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sle i8 %x, 23
   %b = icmp eq i8 %x, 17
@@ -4863,10 +4659,7 @@ define i1 @or_sle_eq_swap(i8 %x) {
 
 define i1 @or_sle_ne_swap(i8 %x) {
 ; CHECK-LABEL: @or_sle_ne_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp sle i8 %x, 23
   %b = icmp ne i8 %x, 17
@@ -4878,10 +4671,7 @@ define i1 @or_sle_ne_swap(i8 %x) {
 
 define i1 @or_sle_sge_swap(i8 %x) {
 ; CHECK-LABEL: @or_sle_sge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp sle i8 %x, 23
   %b = icmp sge i8 %x, 17
@@ -4893,10 +4683,7 @@ define i1 @or_sle_sge_swap(i8 %x) {
 
 define i1 @or_sle_sgt_swap(i8 %x) {
 ; CHECK-LABEL: @or_sle_sgt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp sle i8 %x, 23
   %b = icmp sgt i8 %x, 17
@@ -4909,9 +4696,7 @@ define i1 @or_sle_sgt_swap(i8 %x) {
 define i1 @or_sle_sle_swap(i8 %x) {
 ; CHECK-LABEL: @or_sle_sle_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sle i8 %x, 23
   %b = icmp sle i8 %x, 17
@@ -4924,9 +4709,7 @@ define i1 @or_sle_sle_swap(i8 %x) {
 define i1 @or_sle_slt_swap(i8 %x) {
 ; CHECK-LABEL: @or_sle_slt_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sle i8 %x, 23
   %b = icmp slt i8 %x, 17
@@ -4938,10 +4721,7 @@ define i1 @or_sle_slt_swap(i8 %x) {
 
 define i1 @or_sle_uge_swap(i8 %x) {
 ; CHECK-LABEL: @or_sle_uge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp sle i8 %x, 23
   %b = icmp uge i8 %x, 17
@@ -4953,10 +4733,7 @@ define i1 @or_sle_uge_swap(i8 %x) {
 
 define i1 @or_sle_ugt_swap(i8 %x) {
 ; CHECK-LABEL: @or_sle_ugt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp sle i8 %x, 23
   %b = icmp ugt i8 %x, 17
@@ -4969,9 +4746,7 @@ define i1 @or_sle_ugt_swap(i8 %x) {
 define i1 @or_sle_ule_swap(i8 %x) {
 ; CHECK-LABEL: @or_sle_ule_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sle i8 %x, 23
   %b = icmp ule i8 %x, 17
@@ -4984,9 +4759,7 @@ define i1 @or_sle_ule_swap(i8 %x) {
 define i1 @or_sle_ult_swap(i8 %x) {
 ; CHECK-LABEL: @or_sle_ult_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sle i8 %x, 23
   %b = icmp ult i8 %x, 17
@@ -5000,9 +4773,7 @@ define i1 @or_sle_ult_swap(i8 %x) {
 define i1 @or_slt_eq_swap(i8 %x) {
 ; CHECK-LABEL: @or_slt_eq_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp slt i8 %x, 23
   %b = icmp eq i8 %x, 17
@@ -5014,10 +4785,7 @@ define i1 @or_slt_eq_swap(i8 %x) {
 
 define i1 @or_slt_ne_swap(i8 %x) {
 ; CHECK-LABEL: @or_slt_ne_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp slt i8 %x, 23
   %b = icmp ne i8 %x, 17
@@ -5029,10 +4797,7 @@ define i1 @or_slt_ne_swap(i8 %x) {
 
 define i1 @or_slt_sge_swap(i8 %x) {
 ; CHECK-LABEL: @or_slt_sge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp slt i8 %x, 23
   %b = icmp sge i8 %x, 17
@@ -5044,10 +4809,7 @@ define i1 @or_slt_sge_swap(i8 %x) {
 
 define i1 @or_slt_sgt_swap(i8 %x) {
 ; CHECK-LABEL: @or_slt_sgt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp slt i8 %x, 23
   %b = icmp sgt i8 %x, 17
@@ -5060,9 +4822,7 @@ define i1 @or_slt_sgt_swap(i8 %x) {
 define i1 @or_slt_sle_swap(i8 %x) {
 ; CHECK-LABEL: @or_slt_sle_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp slt i8 %x, 23
   %b = icmp sle i8 %x, 17
@@ -5075,9 +4835,7 @@ define i1 @or_slt_sle_swap(i8 %x) {
 define i1 @or_slt_slt_swap(i8 %x) {
 ; CHECK-LABEL: @or_slt_slt_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp slt i8 %x, 23
   %b = icmp slt i8 %x, 17
@@ -5089,10 +4847,7 @@ define i1 @or_slt_slt_swap(i8 %x) {
 
 define i1 @or_slt_uge_swap(i8 %x) {
 ; CHECK-LABEL: @or_slt_uge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp slt i8 %x, 23
   %b = icmp uge i8 %x, 17
@@ -5104,10 +4859,7 @@ define i1 @or_slt_uge_swap(i8 %x) {
 
 define i1 @or_slt_ugt_swap(i8 %x) {
 ; CHECK-LABEL: @or_slt_ugt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp slt i8 %x, 23
   %b = icmp ugt i8 %x, 17
@@ -5120,9 +4872,7 @@ define i1 @or_slt_ugt_swap(i8 %x) {
 define i1 @or_slt_ule_swap(i8 %x) {
 ; CHECK-LABEL: @or_slt_ule_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp slt i8 %x, 23
   %b = icmp ule i8 %x, 17
@@ -5135,9 +4885,7 @@ define i1 @or_slt_ule_swap(i8 %x) {
 define i1 @or_slt_ult_swap(i8 %x) {
 ; CHECK-LABEL: @or_slt_ult_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp slt i8 %x, 23
   %b = icmp ult i8 %x, 17
@@ -5165,10 +4913,8 @@ define i1 @or_uge_eq_swap(i8 %x) {
 
 define i1 @or_uge_ne_swap(i8 %x) {
 ; CHECK-LABEL: @or_uge_ne_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp uge i8 %x, 23
   %b = icmp ne i8 %x, 17
@@ -5240,10 +4986,8 @@ define i1 @or_uge_slt_swap(i8 %x) {
 
 define i1 @or_uge_uge_swap(i8 %x) {
 ; CHECK-LABEL: @or_uge_uge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp uge i8 %x, 23
   %b = icmp uge i8 %x, 17
@@ -5255,10 +4999,8 @@ define i1 @or_uge_uge_swap(i8 %x) {
 
 define i1 @or_uge_ugt_swap(i8 %x) {
 ; CHECK-LABEL: @or_uge_ugt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp uge i8 %x, 23
   %b = icmp ugt i8 %x, 17
@@ -5316,10 +5058,8 @@ define i1 @or_ugt_eq_swap(i8 %x) {
 
 define i1 @or_ugt_ne_swap(i8 %x) {
 ; CHECK-LABEL: @or_ugt_ne_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ugt i8 %x, 23
   %b = icmp ne i8 %x, 17
@@ -5391,10 +5131,8 @@ define i1 @or_ugt_slt_swap(i8 %x) {
 
 define i1 @or_ugt_uge_swap(i8 %x) {
 ; CHECK-LABEL: @or_ugt_uge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ugt i8 %x, 23
   %b = icmp uge i8 %x, 17
@@ -5406,10 +5144,8 @@ define i1 @or_ugt_uge_swap(i8 %x) {
 
 define i1 @or_ugt_ugt_swap(i8 %x) {
 ; CHECK-LABEL: @or_ugt_ugt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 23
 ; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ugt i8 %x, 23
   %b = icmp ugt i8 %x, 17
@@ -5453,9 +5189,7 @@ define i1 @or_ugt_ult_swap(i8 %x) {
 define i1 @or_ule_eq_swap(i8 %x) {
 ; CHECK-LABEL: @or_ule_eq_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ule i8 %x, 23
   %b = icmp eq i8 %x, 17
@@ -5467,10 +5201,7 @@ define i1 @or_ule_eq_swap(i8 %x) {
 
 define i1 @or_ule_ne_swap(i8 %x) {
 ; CHECK-LABEL: @or_ule_ne_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp ule i8 %x, 23
   %b = icmp ne i8 %x, 17
@@ -5542,10 +5273,7 @@ define i1 @or_ule_slt_swap(i8 %x) {
 
 define i1 @or_ule_uge_swap(i8 %x) {
 ; CHECK-LABEL: @or_ule_uge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp ule i8 %x, 23
   %b = icmp uge i8 %x, 17
@@ -5557,10 +5285,7 @@ define i1 @or_ule_uge_swap(i8 %x) {
 
 define i1 @or_ule_ugt_swap(i8 %x) {
 ; CHECK-LABEL: @or_ule_ugt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp ule i8 %x, 23
   %b = icmp ugt i8 %x, 17
@@ -5573,9 +5298,7 @@ define i1 @or_ule_ugt_swap(i8 %x) {
 define i1 @or_ule_ule_swap(i8 %x) {
 ; CHECK-LABEL: @or_ule_ule_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ule i8 %x, 23
   %b = icmp ule i8 %x, 17
@@ -5588,9 +5311,7 @@ define i1 @or_ule_ule_swap(i8 %x) {
 define i1 @or_ule_ult_swap(i8 %x) {
 ; CHECK-LABEL: @or_ule_ult_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ule i8 %x, 23
   %b = icmp ult i8 %x, 17
@@ -5604,9 +5325,7 @@ define i1 @or_ule_ult_swap(i8 %x) {
 define i1 @or_ult_eq_swap(i8 %x) {
 ; CHECK-LABEL: @or_ult_eq_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ult i8 %x, 23
   %b = icmp eq i8 %x, 17
@@ -5618,10 +5337,7 @@ define i1 @or_ult_eq_swap(i8 %x) {
 
 define i1 @or_ult_ne_swap(i8 %x) {
 ; CHECK-LABEL: @or_ult_ne_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp ult i8 %x, 23
   %b = icmp ne i8 %x, 17
@@ -5693,10 +5409,7 @@ define i1 @or_ult_slt_swap(i8 %x) {
 
 define i1 @or_ult_uge_swap(i8 %x) {
 ; CHECK-LABEL: @or_ult_uge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp ult i8 %x, 23
   %b = icmp uge i8 %x, 17
@@ -5708,10 +5421,7 @@ define i1 @or_ult_uge_swap(i8 %x) {
 
 define i1 @or_ult_ugt_swap(i8 %x) {
 ; CHECK-LABEL: @or_ult_ugt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = icmp ult i8 %x, 23
   %b = icmp ugt i8 %x, 17
@@ -5724,9 +5434,7 @@ define i1 @or_ult_ugt_swap(i8 %x) {
 define i1 @or_ult_ule_swap(i8 %x) {
 ; CHECK-LABEL: @or_ult_ule_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ult i8 %x, 23
   %b = icmp ule i8 %x, 17
@@ -5739,9 +5447,7 @@ define i1 @or_ult_ule_swap(i8 %x) {
 define i1 @or_ult_ult_swap(i8 %x) {
 ; CHECK-LABEL: @or_ult_ult_swap(
 ; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
-; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ult i8 %x, 23
   %b = icmp ult i8 %x, 17
-- 
2.7.4