[InstCombine] fold icmp of the sum of ext bool based on limited range

[bcl5980]

Summary

For the pattern (zext i1 X) + (sext i1 Y), the constant range is [-1, 1].
We can simplify the pattern by logical operations. Like:

(zext i1 X) + (sext i1 Y) == -1 -->  ~X & Y
(zext i1 X) + (sext i1 Y) == 0  --> ~(X ^ Y)
(zext i1 X) + (sext i1 Y) == 1 --> X & ~Y

And other predicates can the combination of these results:

(zext i1 X) + (sext i1 Y)) != -1 --> X | ~Y
(zext i1 X) + (sext i1 Y)) s> -1 --> X | ~Y
(zext i1 X) + (sext i1 Y)) u< -1 --> X | ~Y
(zext i1 X) + (sext i1 Y)) s> 0 --> X & ~Y
(zext i1 X) + (sext i1 Y)) s< 0 --> ~X & Y
(zext i1 X) + (sext i1 Y)) != 1 --> ~X | Y
(zext i1 X) + (sext i1 Y)) s< 1 --> ~X | Y
(zext i1 X) + (sext i1 Y)) u> 1 --> ~X & Y

All alive proofs:
https://alive2.llvm.org/ce/z/KmgDpF
https://alive2.llvm.org/ce/z/fLwWa9
https://alive2.llvm.org/ce/z/ZKQn2P

Fix: https://github.com/llvm/llvm-project/issues/59666

[bcl5980]

rebase with precommit tests.

[spatel]

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

5886

This description does not make sense to me. We need to specify the predicate along with the constant value to know the correct transform?

5899

Include "ULT" here?

llvm/test/Transforms/InstCombine/icmp-range.ll

662

Where do we transform this pattern? Is it possible that the existing code can be extended to handle more predicates?

[goldstein.w.n]

Can you add alive2 links?

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

5896

Think it would be clearer to have the comments for each transform at their respective case statement.

5899

Include "ULT" here?

All corresponding unsigned predicts no?

[spatel]

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

5899

We could, but it would probably just be dead code.

UGT: "x u> -1" is really "x u> 0xffff..." (is always simplified to false).
SLT: handled by SCCP, but nothing in instcombine gets it, so we should add that to the list too.

All of ULE/UGE/SLE/SGE will be canonicalized to their LT/GT counterparts, so we don't need to handle those.

[bcl5980]

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

5899

Thanks for the mention for the unsigned compare.
ult -1 is the same to ne -1 here.
ugt 1 is the same to eq -1 here.
ugt 0 is the same to ne 0 here.
ult 1 is the same to eq 0 here.

llvm/test/Transforms/InstCombine/icmp-range.ll

662

It comes from computeKnownBits, sgt -1 can ignore the sign bit to do this. It only works for sgt -1 I think.

[bcl5980]

Address comments.

[bcl5980]

rebase tests.

[bcl5980]

Make the code easier to read.

[spatel]

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

5892–5893

Since we are going through these combinations, we should handle these cases that are missed by InstCombine:
https://alive2.llvm.org/ce/z/3m9D9D

If there are other combinations that are not already handled, then let's reduce those too?

[bcl5980]

remove the condition CmpC->abs().ule(1)
add cases return constant

[spatel]

In D143373#4121737, @bcl5980 wrote:

remove the condition CmpC->abs().ule(1)

Without that condition, we can't use getSextValue() safely on the compare constant. This test needs to be added (please pre-commit the new tests too) because it will now crash:

define i1 @zext_sext_add_icmp_sgt_minus2(i1 %a, i1 %b) {
  %zext.a = zext i1 %a to i128
  %sext.b = sext i1 %b to i128
  %add = add i128 %zext.a, %sext.b
  %r = icmp sgt i128 %add, 9223372036854775808
  ret i1 %r
}

[bcl5980]

use APint to compare to make it work for integer types with larger than 64bits.

[bcl5980]

In D143373#4122975, @spatel wrote:

In D143373#4121737, @bcl5980 wrote:

remove the condition CmpC->abs().ule(1)

Without that condition, we can't use getSextValue() safely on the compare constant. This test needs to be added (please pre-commit the new tests too) because it will now crash:

define i1 @zext_sext_add_icmp_sgt_minus2(i1 %a, i1 %b) {
  %zext.a = zext i1 %a to i128
  %sext.b = sext i1 %b to i128
  %add = add i128 %zext.a, %sext.b
  %r = icmp sgt i128 %add, 9223372036854775808
  ret i1 %r
}

Thanks for the catch!

[spatel]

LGTM - please pre-commit the extra baseline tests that were added in the last few rounds of review.

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

if (match(&I, m_c_ICmp(Pred, m_Value(X), m_OneUse(m_ZExt(m_Value(Y))))) &&
     return BinaryOperator::CreateAnd(Builder.CreateIsNull(X), Y);
 
   // X must be 0 or bool must be true for "ULE":
   // X <=u (sext i1 Y) --> (X == 0) | Y
   if (match(&I, m_c_ICmp(Pred, m_Value(X), m_OneUse(m_SExt(m_Value(Y))))) &&
       Y->getType()->isIntOrIntVectorTy(1) && Pred == ICmpInst::ICMP_ULE)
     return BinaryOperator::CreateOr(Builder.CreateIsNull(X), Y);
 
+  const APInt *CmpC;
+  if (match(I.getOperand(0),
+            m_OneUse(m_c_Add(m_ZExt(m_Value(X)), m_SExt(m_Value(Y))))) &&
+      match(I.getOperand(1), m_APInt(CmpC)) &&
+      X->getType()->isIntOrIntVectorTy(1) &&
+      Y->getType()->isIntOrIntVectorTy(1) && CmpC->abs().ule(1)) {
+    Pred = I.getPredicate();
+    int64_t C = CmpC->getSExtValue();
+    // canonicalize predicate to eq/ne
+    if ((C == 0 && Pred == ICmpInst::ICMP_SLT) ||
+        (C == 1 && Pred == ICmpInst::ICMP_UGT)) {
+      // x s< 0 in [-1, 1] --> x == -1
+      // x u> 1 in [-1, 1] --> x == -1
+      C = -1;
+      Pred = ICmpInst::ICMP_EQ;
+    } else if (C == -1 &&
+               (Pred == ICmpInst::ICMP_SGT || Pred == ICmpInst::ICMP_ULT)) {
+      // x s> -1 in [-1, 1] --> x != -1
+      // x u< -1 in [-1, 1] --> x != -1
+      Pred = ICmpInst::ICMP_NE;
+    } else if (C == 0 && Pred == ICmpInst::ICMP_SGT) {
+      // x s> 0 in [-1, 1] --> x == 1
+      C = 1;
+      Pred = ICmpInst::ICMP_EQ;
+    } else if (C == 1 && Pred == ICmpInst::ICMP_SLT) {
+      // x s< 1 in [-1, 1] --> x != 1
+      Pred = ICmpInst::ICMP_NE;
+    }
+
+    if (C == -1) {
+      if (Pred == ICmpInst::ICMP_EQ)
+        return BinaryOperator::CreateAnd(Builder.CreateNot(X), Y);
+      if (Pred == ICmpInst::ICMP_NE)
+        return BinaryOperator::CreateOr(X, Builder.CreateNot(Y));
+    } else if (C == 1) {
+      if (Pred == ICmpInst::ICMP_EQ)
+        return BinaryOperator::CreateAnd(X, Builder.CreateNot(Y));
+      if (Pred == ICmpInst::ICMP_NE)
+        return BinaryOperator::CreateOr(Builder.CreateNot(X), Y);
+    }
+  }
+
   return nullptr;
 }
 
 std::optional<std::pair<CmpInst::Predicate, Constant *>>
 InstCombiner::getFlippedStrictnessPredicateAndConstant(CmpInst::Predicate Pred,
                                                        Constant *C) {
   assert(ICmpInst::isRelational(Pred) && ICmpInst::isIntPredicate(Pred) &&
          "Only for relational integer predicates.");

llvm/test/Transforms/InstCombine/icmp-range.ll

 ; CHECK-NEXT:    [[R:%.*]] = icmp uge i8 [[A]], [[S]]
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
   %a = ashr i8 %b, 7
   %s = sub i8 %x, %y
   %r = icmp uge i8 %a, %s
   ret i1 %r
 }
+; (zext i1 a) + (sext i1 b)) == -1 --> ~a & b
 
 define i1 @zext_sext_add_icmp_eq_minus1(i1 %a, i1 %b) {
 ; CHECK-LABEL: @zext_sext_add_icmp_eq_minus1(
-; CHECK-NEXT:    [[ZEXT_A:%.*]] = zext i1 [[A:%.*]] to i8
-; CHECK-NEXT:    [[SEXT_B:%.*]] = sext i1 [[B:%.*]] to i8
-; CHECK-NEXT:    [[ADD:%.*]] = add nsw i8 [[ZEXT_A]], [[SEXT_B]]
-; CHECK-NEXT:    [[R:%.*]] = icmp eq i8 [[ADD]], -1
+; CHECK-NEXT:    [[TMP1:%.*]] = xor i1 [[A:%.*]], true
+; CHECK-NEXT:    [[R:%.*]] = and i1 [[TMP1]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
   %zext.a = zext i1 %a to i8
   %sext.b = sext i1 %b to i8
   %add = add i8 %zext.a, %sext.b
   %r = icmp eq i8 %add, -1
   ret i1 %r
 }
 
+
+; (zext i1 a) + (sext i1 b)) != -1 --> a | ~b
+
 define i1 @zext_sext_add_icmp_ne_minus1(i1 %a, i1 %b) {
 ; CHECK-LABEL: @zext_sext_add_icmp_ne_minus1(
-; CHECK-NEXT:    [[ZEXT_A:%.*]] = zext i1 [[A:%.*]] to i8
-; CHECK-NEXT:    [[SEXT_B:%.*]] = sext i1 [[B:%.*]] to i8
-; CHECK-NEXT:    [[ADD:%.*]] = add nsw i8 [[ZEXT_A]], [[SEXT_B]]
-; CHECK-NEXT:    [[R:%.*]] = icmp ne i8 [[ADD]], -1
+; CHECK-NEXT:    [[TMP1:%.*]] = xor i1 [[B:%.*]], true
+; CHECK-NEXT:    [[R:%.*]] = or i1 [[TMP1]], [[A:%.*]]
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
   %zext.a = zext i1 %a to i8
   %sext.b = sext i1 %b to i8
   %add = add i8 %zext.a, %sext.b
   %r = icmp ne i8 %add, -1
   ret i1 %r
 }
 
+; (zext i1 a) + (sext i1 b)) s> -1 --> a | ~b
+
 define i1 @zext_sext_add_icmp_sgt_minus1(i1 %a, i1 %b) {
 ; CHECK-LABEL: @zext_sext_add_icmp_sgt_minus1(
-; CHECK-NEXT:    [[B_NOT:%.*]] = xor i1 [[B:%.*]], true
-; CHECK-NEXT:    [[R:%.*]] = or i1 [[B_NOT]], [[A:%.*]]
+; CHECK-NEXT:    [[TMP1:%.*]] = xor i1 [[B:%.*]], true
+; CHECK-NEXT:    [[R:%.*]] = or i1 [[TMP1]], [[A:%.*]]
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
   %zext.a = zext i1 %a to i8
   %sext.b = sext i1 %b to i8
   %add = add i8 %zext.a, %sext.b
   %r = icmp sgt i8 %add, -1
   ret i1 %r
 }
 
+; (zext i1 a) + (sext i1 b)) u< -1 --> a | ~b
+
 define i1 @zext_sext_add_icmp_ult_minus1(i1 %a, i1 %b) {
 ; CHECK-LABEL: @zext_sext_add_icmp_ult_minus1(
-; CHECK-NEXT:    [[ZEXT_A:%.*]] = zext i1 [[A:%.*]] to i8
-; CHECK-NEXT:    [[SEXT_B:%.*]] = sext i1 [[B:%.*]] to i8
-; CHECK-NEXT:    [[ADD:%.*]] = add nsw i8 [[ZEXT_A]], [[SEXT_B]]
-; CHECK-NEXT:    [[R:%.*]] = icmp ne i8 [[ADD]], -1
+; CHECK-NEXT:    [[TMP1:%.*]] = xor i1 [[B:%.*]], true
+; CHECK-NEXT:    [[R:%.*]] = or i1 [[TMP1]], [[A:%.*]]
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
   %zext.a = zext i1 %a to i8
   %sext.b = sext i1 %b to i8
   %add = add i8 %zext.a, %sext.b
   %r = icmp ult i8 %add, -1
   ret i1 %r
 }
 
+; (zext i1 a) + (sext i1 b)) s> 0 --> a & ~b
+
 define i1 @zext_sext_add_icmp_sgt_0(i1 %a, i1 %b) {
 ; CHECK-LABEL: @zext_sext_add_icmp_sgt_0(
-; CHECK-NEXT:    [[ZEXT_A:%.*]] = zext i1 [[A:%.*]] to i8
-; CHECK-NEXT:    [[SEXT_B:%.*]] = sext i1 [[B:%.*]] to i8
-; CHECK-NEXT:    [[ADD:%.*]] = add nsw i8 [[ZEXT_A]], [[SEXT_B]]
-; CHECK-NEXT:    [[R:%.*]] = icmp sgt i8 [[ADD]], 0
+; CHECK-NEXT:    [[TMP1:%.*]] = xor i1 [[B:%.*]], true
+; CHECK-NEXT:    [[R:%.*]] = and i1 [[TMP1]], [[A:%.*]]
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
   %zext.a = zext i1 %a to i8
   %sext.b = sext i1 %b to i8
   %add = add i8 %zext.a, %sext.b
   %r = icmp sgt i8 %add, 0
   ret i1 %r
 }
 
+; (zext i1 a) + (sext i1 b)) s< 0 --> ~a & b
+
 define i1 @zext_sext_add_icmp_slt_0(i1 %a, i1 %b) {
 ; CHECK-LABEL: @zext_sext_add_icmp_slt_0(
 ; CHECK-NEXT:    [[TMP1:%.*]] = xor i1 [[A:%.*]], true
-; CHECK-NEXT:    [[TMP2:%.*]] = and i1 [[TMP1]], [[B:%.*]]
-; CHECK-NEXT:    ret i1 [[TMP2]]
+; CHECK-NEXT:    [[R:%.*]] = and i1 [[TMP1]], [[B:%.*]]
+; CHECK-NEXT:    ret i1 [[R]]
 ;
   %zext.a = zext i1 %a to i8
   %sext.b = sext i1 %b to i8
   %add = add i8 %zext.a, %sext.b
   %r = icmp slt i8 %add, 0
   ret i1 %r
 }
 
+; (zext i1 a) + (sext i1 b)) == 1 --> a & ~b
+
 define i1 @zext_sext_add_icmp_eq_1(i1 %a, i1 %b) {
 ; CHECK-LABEL: @zext_sext_add_icmp_eq_1(
-; CHECK-NEXT:    [[ZEXT_A:%.*]] = zext i1 [[A:%.*]] to i8
-; CHECK-NEXT:    [[SEXT_B:%.*]] = sext i1 [[B:%.*]] to i8
-; CHECK-NEXT:    [[ADD:%.*]] = add nsw i8 [[ZEXT_A]], [[SEXT_B]]
-; CHECK-NEXT:    [[R:%.*]] = icmp eq i8 [[ADD]], 1
+; CHECK-NEXT:    [[TMP1:%.*]] = xor i1 [[B:%.*]], true
+; CHECK-NEXT:    [[R:%.*]] = and i1 [[TMP1]], [[A:%.*]]
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
   %zext.a = zext i1 %a to i8
   %sext.b = sext i1 %b to i8
   %add = add i8 %zext.a, %sext.b
   %r = icmp eq i8 %add, 1
   ret i1 %r
 }
 
+; (zext i1 a) + (sext i1 b)) != 1 --> ~a | b
+
 define i1 @zext_sext_add_icmp_ne_1(i1 %a, i1 %b) {
 ; CHECK-LABEL: @zext_sext_add_icmp_ne_1(
-; CHECK-NEXT:    [[ZEXT_A:%.*]] = zext i1 [[A:%.*]] to i8
-; CHECK-NEXT:    [[SEXT_B:%.*]] = sext i1 [[B:%.*]] to i8
-; CHECK-NEXT:    [[ADD:%.*]] = add nsw i8 [[ZEXT_A]], [[SEXT_B]]
-; CHECK-NEXT:    [[R:%.*]] = icmp ne i8 [[ADD]], 1
+; CHECK-NEXT:    [[TMP1:%.*]] = xor i1 [[A:%.*]], true
+; CHECK-NEXT:    [[R:%.*]] = or i1 [[TMP1]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
   %zext.a = zext i1 %a to i8
   %sext.b = sext i1 %b to i8
   %add = add i8 %zext.a, %sext.b
   %r = icmp ne i8 %add, 1
   ret i1 %r
 }
 
+; (zext i1 a) + (sext i1 b)) s< 1 --> ~a | b
+
 define i1 @zext_sext_add_icmp_slt_1(i1 %a, i1 %b) {
 ; CHECK-LABEL: @zext_sext_add_icmp_slt_1(
-; CHECK-NEXT:    [[ZEXT_A:%.*]] = zext i1 [[A:%.*]] to i8
-; CHECK-NEXT:    [[SEXT_B:%.*]] = sext i1 [[B:%.*]] to i8
-; CHECK-NEXT:    [[ADD:%.*]] = add nsw i8 [[ZEXT_A]], [[SEXT_B]]
-; CHECK-NEXT:    [[R:%.*]] = icmp slt i8 [[ADD]], 1
+; CHECK-NEXT:    [[TMP1:%.*]] = xor i1 [[A:%.*]], true
+; CHECK-NEXT:    [[R:%.*]] = or i1 [[TMP1]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
   %zext.a = zext i1 %a to i8
   %sext.b = sext i1 %b to i8
   %add = add i8 %zext.a, %sext.b
   %r = icmp slt i8 %add, 1
   ret i1 %r
 }
 
+; (zext i1 a) + (sext i1 b)) u> 1 --> ~a & b
+
 define i1 @zext_sext_add_icmp_ugt_1(i1 %a, i1 %b) {
 ; CHECK-LABEL: @zext_sext_add_icmp_ugt_1(
 ; CHECK-NEXT:    [[TMP1:%.*]] = xor i1 [[A:%.*]], true
-; CHECK-NEXT:    [[TMP2:%.*]] = and i1 [[TMP1]], [[B:%.*]]
-; CHECK-NEXT:    ret i1 [[TMP2]]
+; CHECK-NEXT:    [[R:%.*]] = and i1 [[TMP1]], [[B:%.*]]
+; CHECK-NEXT:    ret i1 [[R]]
 ;
   %zext.a = zext i1 %a to i8
   %sext.b = sext i1 %b to i8
   %add = add i8 %zext.a, %sext.b
   %r = icmp ugt i8 %add, 1
   ret i1 %r
 }
 
 define <2 x i1> @vector_zext_sext_add_icmp_slt_1(<2 x i1> %a, <2 x i1> %b) {
 ; CHECK-LABEL: @vector_zext_sext_add_icmp_slt_1(
-; CHECK-NEXT:    [[ZEXT_A:%.*]] = zext <2 x i1> [[A:%.*]] to <2 x i8>
-; CHECK-NEXT:    [[SEXT_B:%.*]] = sext <2 x i1> [[B:%.*]] to <2 x i8>
-; CHECK-NEXT:    [[ADD:%.*]] = add nsw <2 x i8> [[ZEXT_A]], [[SEXT_B]]
-; CHECK-NEXT:    [[R:%.*]] = icmp slt <2 x i8> [[ADD]], <i8 1, i8 1>
+; CHECK-NEXT:    [[TMP1:%.*]] = xor <2 x i1> [[A:%.*]], <i1 true, i1 true>
+; CHECK-NEXT:    [[R:%.*]] = or <2 x i1> [[TMP1]], [[B:%.*]]
 ; CHECK-NEXT:    ret <2 x i1> [[R]]
 ;
   %zext.a = zext <2 x i1> %a to <2 x i8>
   %sext.b = sext <2 x i1> %b to <2 x i8>
   %add = add <2 x i8> %zext.a, %sext.b
   %r = icmp slt <2 x i8> %add, <i8 1, i8 1>
   ret <2 x i1> %r
 }
 
 define <2 x i1> @vector_zext_sext_add_icmp_slt_1_poison(<2 x i1> %a, <2 x i1> %b) {
 ; CHECK-LABEL: @vector_zext_sext_add_icmp_slt_1_poison(
 ; CHECK-NEXT:    [[ZEXT_A:%.*]] = zext <2 x i1> [[A:%.*]] to <2 x i8>
 ; CHECK-NEXT:    [[SEXT_B:%.*]] = sext <2 x i1> [[B:%.*]] to <2 x i8>
 ; CHECK-NEXT:    [[ADD:%.*]] = add nsw <2 x i8> [[ZEXT_A]], [[SEXT_B]]
 ; CHECK-NEXT:    [[R:%.*]] = icmp slt <2 x i8> [[ADD]], <i8 1, i8 poison>
 ; CHECK-NEXT:    ret <2 x i1> [[R]]
 ;
   %zext.a = zext <2 x i1> %a to <2 x i8>
   %sext.b = sext <2 x i1> %b to <2 x i8>
   %add = add <2 x i8> %zext.a, %sext.b
   %r = icmp slt <2 x i8> %add, <i8 1, i8 poison>
   ret <2 x i1> %r
 }
 
+; Negative test, more than one use for icmp LHS
+
 define i1 @zext_sext_add_icmp_slt_1_no_oneuse(i1 %a, i1 %b) {
 ; CHECK-LABEL: @zext_sext_add_icmp_slt_1_no_oneuse(
 ; CHECK-NEXT:    [[ZEXT_A:%.*]] = zext i1 [[A:%.*]] to i8
 ; CHECK-NEXT:    [[SEXT_B:%.*]] = sext i1 [[B:%.*]] to i8
 ; CHECK-NEXT:    [[ADD:%.*]] = add nsw i8 [[ZEXT_A]], [[SEXT_B]]
 ; CHECK-NEXT:    call void @use(i8 [[ADD]])
 ; CHECK-NEXT:    [[R:%.*]] = icmp slt i8 [[ADD]], 1
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
   %zext.a = zext i1 %a to i8
   %sext.b = sext i1 %b to i8
   %add = add i8 %zext.a, %sext.b
   call void @use(i8 %add)
   %r = icmp slt i8 %add, 1
   ret i1 %r
 }
 
+; Negative test, icmp RHS is not a constant
+
 define i1 @zext_sext_add_icmp_slt_1_rhs_not_const(i1 %a, i1 %b, i8 %c) {
 ; CHECK-LABEL: @zext_sext_add_icmp_slt_1_rhs_not_const(
 ; CHECK-NEXT:    [[ZEXT_A:%.*]] = zext i1 [[A:%.*]] to i8
 ; CHECK-NEXT:    [[SEXT_B:%.*]] = sext i1 [[B:%.*]] to i8
 ; CHECK-NEXT:    [[ADD:%.*]] = add nsw i8 [[ZEXT_A]], [[SEXT_B]]
 ; CHECK-NEXT:    [[R:%.*]] = icmp slt i8 [[ADD]], [[C:%.*]]
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
   %zext.a = zext i1 %a to i8
   %sext.b = sext i1 %b to i8
   %add = add i8 %zext.a, %sext.b
   %r = icmp slt i8 %add, %c
   ret i1 %r
 }
 
+; Negative test, ext source is not i1
+
 define i1 @zext_sext_add_icmp_slt_1_type_not_i1(i2 %a, i1 %b) {
 ; CHECK-LABEL: @zext_sext_add_icmp_slt_1_type_not_i1(
 ; CHECK-NEXT:    [[ZEXT_A:%.*]] = zext i2 [[A:%.*]] to i8
 ; CHECK-NEXT:    [[SEXT_B:%.*]] = sext i1 [[B:%.*]] to i8
 ; CHECK-NEXT:    [[ADD:%.*]] = add nsw i8 [[ZEXT_A]], [[SEXT_B]]
 ; CHECK-NEXT:    [[R:%.*]] = icmp slt i8 [[ADD]], 1
 ; CHECK-NEXT:    ret i1 [[R]]
 ;