[ValueTracking] Use `select` condition to help determine if `select` is non-zero

[goldstein.w.n]

Summary

In select c, x, y the condition c dominates the resulting x or
y chosen by the select. This adds logic to isKnownNonZero to try
and use the icmp for the c condition to see if it implies the
select x or y are known non-zero.

For example in:

%c = icmp ugt i8 %x, %C
%r = select i1 %c, i8 %x, i8 %y
```
The true arm of select `%x` is non-zero (when "returned" by the
`select`) because `%c` being true implies `%x` is non-zero.

Alive2 Links (with x {pred} C):

• EQ iff C != 0:
  • https://alive2.llvm.org/ce/z/umLabn
• NE iff C == 0:
  • https://alive2.llvm.org/ce/z/DQvy8Y
• UGT [always]:
  • https://alive2.llvm.org/ce/z/HBkjgQ
• UGE iff C != 0:
  • https://alive2.llvm.org/ce/z/LDNifB
• SGT iff C s>= 0:
  • https://alive2.llvm.org/ce/z/QzWDj3
• SGE iff C s> 0:
  • https://alive2.llvm.org/ce/z/rR4g3D
• SLT iff C s<= 0:
  • https://alive2.llvm.org/ce/z/uysayx
• SLE iff C s< 0:
  • https://alive2.llvm.org/ce/z/2jYc7e

[nikic]

Can you please base this on cmpExcludesZero() instead? I don't think there's need to handle cases here that we don't handle for assumes or branches.

[nikic]

In D147900#4262716, @nikic wrote:

Can you please base this on cmpExcludesZero() instead? I don't think there's need to handle cases here that we don't handle for assumes or branches.

(I realized this might be ambiguous, so to clarify: What I mean is to use cmpExcludesZero() with its current set of supported functionality, not to generalize it to handle additional cases.)

[goldstein.w.n]

In D147900#4262795, @nikic wrote:

In D147900#4262716, @nikic wrote:

Can you please base this on cmpExcludesZero() instead? I don't think there's need to handle cases here that we don't handle for assumes or branches.

(I realized this might be ambiguous, so to clarify: What I mean is to use cmpExcludesZero() with its current set of supported functionality, not to generalize it to handle additional cases.)

Oh okay. Open to a future patch to expand cmpExcludesZero?
Although seems somewhat a shame to miss very handable cases.

[goldstein.w.n]

In D147900#4262716, @nikic wrote:

Can you please base this on cmpExcludesZero() instead? I don't think there's need to handle cases here that we don't handle for assumes or branches.

Any chance you are okay leaving this as a todo. i.e
"TODO: Integrate these cases in cmpExcludesZero"
Edit: Maybe a second version like cmpExcludesZeroRecursive for use
outside loops (maybe could get away with it in the assume loop).

Personally don't like leaving known missed-optimizations on the table :(

Also feels like a different circumstance. Other uses of cmpExcludesZero are in
loops so there is a case for skipping the over-analysis. This, on the otherhand
is capped at +2 recursive calls (only for ICMP_SGE, the rest +1/+0).

ultimately up to you, so LMK.

[goldstein.w.n]

use cmpExcludesZero

[goldstein.w.n]

ping.

[goldstein.w.n]

Rebase

[goldstein.w.n]

Rebase

[goldstein.w.n]

Rebase

[goldstein.w.n]

ping.

[nikic]

llvm/lib/Analysis/ValueTracking.cpp

586

possible -> possibly

2913

I'd factor this differently, so that you keep the general structure of the previous code (i.e. short circuit if one operand is not known non-zero). Basically move the isKnownNonZero() check into the lambda as well.

2926–2933

2940

Redundant with the TODO on cmpExcludesZero.

[goldstein.w.n]

Fixes

[nikic]

llvm/lib/Analysis/ValueTracking.cpp

2948–2949

I have a hard time following the logic here at the end. What I expected to see was something like this:

auto SelectArmIsNonZero = [&](bool IsTrueArm) {
  Value *Op = IsTrueArm ? I->getOperand(1) : I->getOperand(2);
  if (isKnownNonZero(Op, DemandedElts, Depth, Q))
    return true;

  // The condition of the select dominates the true/false arm. Check if the
  // condition implies that a given arm is non-zero.
  Value *X;
  CmpInst::Predicate Pred;
  if (!match(I->getOperand(0), m_c_ICmp(Pred, m_Specific(Op), m_Value(X))))
    return false;

  if (!IsTrueArm)
    Pred = ICmpInst::getInversePredicate(Pred);

  return cmpExcludesZero(Pred, X);
};

if (SelectArmIsNonZero(/* IsTrueArm */ true) &&
    SelectArmIsNonZero(/* IsTrueArm */ false))
  return true;

[goldstein.w.n]

llvm/lib/Analysis/ValueTracking.cpp

2948–2949

Ah, that is indeed much clearer.

[goldstein.w.n]

Cleanup as @nikic suggests

[nikic]

LGTM

[goldstein.w.n]

Rebase

llvm/lib/Analysis/ValueTracking.cpp

bool llvm::isValidAssumeForContext(const Instruction *Inv,
   } else if (Inv->getParent() == CxtI->getParent()->getSinglePredecessor()) {
     // We don't have a DT, but this trivially dominates.
     return true;
   }
 
   return false;
 }
 
+// TODO: cmpExcludesZero misses many cases where `RHS` is non-constant but
+// we still have enough information about `RHS` to conclude non-zero. For
+// example Pred=EQ, RHS=isKnownNonZero. cmpExcludesZero is called in loops
+// so the extra compile time may not be worth it, but possible a second API
+// should be created for use outside of loops.
 static bool cmpExcludesZero(CmpInst::Predicate Pred, const Value *RHS) {
   // v u> y implies v != 0.
   if (Pred == ICmpInst::ICMP_UGT)
     return true;
 
   // Special-case v != 0 to also handle v != null.
   if (Pred == ICmpInst::ICMP_NE)
     return match(RHS, m_Zero());
case Instruction::Mul: {
     // If there exists any subset of X (sX) and subset of Y (sY) s.t sX * sY is
     // non-zero, then X * Y is non-zero. We can find sX and sY by just taking
     // the the lowest known One of X and Y. If they are non-zero, the result
     // must be non-zero. We can check if LSB(X) * LSB(Y) != 0 by doing
     // X.CountLeadingZeros + Y.CountLeadingZeros < BitWidth.
     return (XKnown.countMaxTrailingZeros() + YKnown.countMaxTrailingZeros()) <
            BitWidth;
   }
-  case Instruction::Select:
+  case Instruction::Select: {
     // (C ? X : Y) != 0 if X != 0 and Y != 0.
-    if (isKnownNonZero(I->getOperand(1), DemandedElts, Depth, Q) &&
-        isKnownNonZero(I->getOperand(2), DemandedElts, Depth, Q))
+    bool Op1NonZero = isKnownNonZero(I->getOperand(1), DemandedElts, Depth, Q);
+    bool Op2NonZero = isKnownNonZero(I->getOperand(2), DemandedElts, Depth, Q);
+    if (Op1NonZero && Op2NonZero)
+      return true;
+
+    // The condition of the select dominates the true/false arm. Check if the
+    // condition implies that a given arm is non-zero.
+    auto SelectCondImpliesNonZero = [&](bool IsTrueArm) {
+      Value *X, *Op;
+      CmpInst::Predicate Pred;
+
+      Op = IsTrueArm ? I->getOperand(1) : I->getOperand(2);
+      // TODO: We currently only check if the exact value used in the `icmp`
+      // matches one of the arms. We could go further and see if the value used
+      // in the condition being non-zero implies one of the arm's is non-zero
+      // (through a use).
+      if (match(I->getOperand(0), m_ICmp(Pred, m_Specific(Op), m_Value(X)))) {
+        // pass
+      } else if (match(I->getOperand(0),
+                       m_ICmp(Pred, m_Value(X), m_Specific(Op)))) {
+        Pred = ICmpInst::getSwappedPredicate(Pred);
+      } else {
+        return false;
+      }
+
+      if (!IsTrueArm)
+        Pred = ICmpInst::getInversePredicate(Pred);
+
+      // TODO: cmpExcludesZero misses many cases where `X` is non-constant but
+      // we still have enough information about `X` to conclude `Op` is nonzero.
+      // If a better API ever comes about, update this use.
+      return cmpExcludesZero(Pred, X);
+    };
+
+    if (Op2NonZero && SelectCondImpliesNonZero(/* IsTrueArm */ true))
+      return true;
+    if (Op1NonZero && SelectCondImpliesNonZero(/* IsTrueArm */ false))
       return true;
     break;
+  }
   case Instruction::PHI: {
     auto *PN = cast<PHINode>(I);
     if (Q.IIQ.UseInstrInfo && isNonZeroRecurrence(PN))
       return true;
 
     // Check if all incoming values are non-zero using recursion.
     Query RecQ = Q;
     unsigned NewDepth = std::max(Depth, MaxAnalysisRecursionDepth - 1);

llvm/test/Analysis/ValueTracking/select-known-non-zero-const.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
 
 declare void @llvm.assume(i1)
 define <2 x i1> @select_v_ne_z(<2 x i8> %v, <2 x i8> %yy) {
 ; CHECK-LABEL: @select_v_ne_z(
-; CHECK-NEXT:    [[Y:%.*]] = or <2 x i8> [[YY:%.*]], <i8 1, i8 1>
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ne <2 x i8> [[V:%.*]], zeroinitializer
-; CHECK-NEXT:    [[S:%.*]] = select <2 x i1> [[CMP]], <2 x i8> [[V]], <2 x i8> [[Y]]
-; CHECK-NEXT:    [[R:%.*]] = icmp eq <2 x i8> [[S]], zeroinitializer
-; CHECK-NEXT:    ret <2 x i1> [[R]]
+; CHECK-NEXT:    ret <2 x i1> zeroinitializer
 ;
   %y = or <2 x i8> %yy, <i8 1, i8 1>
   %cmp = icmp ne <2 x i8> %v, zeroinitializer
   %s = select <2 x i1> %cmp, <2 x i8> %v, <2 x i8> %y
   %r = icmp eq <2 x i8> %s, zeroinitializer
   ret <2 x i1> %r
 }
 
;
   %r = icmp eq i8 %s, 0
   ret i1 %r
 }
 
 define i1 @select_v_eq_nz(i8 %v, i8 %y) {
 ; CHECK-LABEL: @select_v_eq_nz(
 ; CHECK-NEXT:    [[YNZ:%.*]] = icmp ne i8 [[Y:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[YNZ]])
-; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8 44, [[V:%.*]]
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[CMP]], i8 [[V]], i8 [[Y]]
-; CHECK-NEXT:    [[R:%.*]] = icmp eq i8 [[S]], 0
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 false
 ;
   %ynz = icmp ne i8 %y, 0
   call void @llvm.assume(i1 %ynz)
   %cmp = icmp eq i8 44, %v
   %s = select i1 %cmp, i8 %v, i8 %y
   %r = icmp eq i8 %s, 0
   ret i1 %r
 }
 
 define i1 @inv_select_v_ugt_nz(i8 %v, i8 %C, i8 %y) {
 ; CHECK-LABEL: @inv_select_v_ugt_nz(
 ; CHECK-NEXT:    [[YNZ:%.*]] = icmp ne i8 [[Y:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[YNZ]])
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i8 14, [[V:%.*]]
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[CMP]], i8 [[Y]], i8 [[V]]
-; CHECK-NEXT:    [[R:%.*]] = icmp eq i8 [[S]], 0
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 false
 ;
   %ynz = icmp ne i8 %y, 0
   call void @llvm.assume(i1 %ynz)
   %cmp = icmp ugt i8 14, %v
   %s = select i1 %cmp, i8 %y, i8 %v
   %r = icmp eq i8 %s, 0
   ret i1 %r
 }
 
 define i1 @inv_select_v_ugt_fail(i8 %v, i8 %C, i8 %y) {
 ; CHECK-LABEL: @inv_select_v_ugt_fail(
 ; CHECK-NEXT:    [[YNZ:%.*]] = icmp ne i8 [[Y:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[YNZ]])
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i8 -2, [[V:%.*]]
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[CMP]], i8 [[Y]], i8 [[V]]
-; CHECK-NEXT:    [[R:%.*]] = icmp eq i8 [[S]], 0
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 false
 ;
   %ynz = icmp ne i8 %y, 0
   call void @llvm.assume(i1 %ynz)
   %cmp = icmp ugt i8 -2, %v
   %s = select i1 %cmp, i8 %y, i8 %v
   %r = icmp eq i8 %s, 0
   ret i1 %r
 }
 
 define <2 x i1> @select_v_ult(<2 x i8> %v, <2 x i8> %C, <2 x i8> %yy) {
 ; CHECK-LABEL: @select_v_ult(
-; CHECK-NEXT:    [[Y:%.*]] = or <2 x i8> [[YY:%.*]], <i8 1, i8 1>
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ult <2 x i8> [[C:%.*]], [[V:%.*]]
-; CHECK-NEXT:    [[S:%.*]] = select <2 x i1> [[CMP]], <2 x i8> [[V]], <2 x i8> [[Y]]
-; CHECK-NEXT:    [[R:%.*]] = icmp eq <2 x i8> [[S]], zeroinitializer
-; CHECK-NEXT:    ret <2 x i1> [[R]]
+; CHECK-NEXT:    ret <2 x i1> zeroinitializer
 ;
   %y = or <2 x i8> %yy, <i8 1, i8 1>
   %cmp = icmp ult <2 x i8> %C, %v
   %s = select <2 x i1> %cmp, <2 x i8> %v, <2 x i8> %y
   %r = icmp eq <2 x i8> %s, zeroinitializer
   ret <2 x i1> %r
 }
 
 define <2 x i1> @select_v_uge_nz(<2 x i8> %v, <2 x i8> %yy) {
 ; CHECK-LABEL: @select_v_uge_nz(
-; CHECK-NEXT:    [[Y:%.*]] = or <2 x i8> [[YY:%.*]], <i8 1, i8 1>
-; CHECK-NEXT:    [[CMP:%.*]] = icmp uge <2 x i8> [[V:%.*]], <i8 1, i8 1>
-; CHECK-NEXT:    [[S:%.*]] = select <2 x i1> [[CMP]], <2 x i8> [[V]], <2 x i8> [[Y]]
-; CHECK-NEXT:    [[R:%.*]] = icmp eq <2 x i8> [[S]], zeroinitializer
-; CHECK-NEXT:    ret <2 x i1> [[R]]
+; CHECK-NEXT:    ret <2 x i1> zeroinitializer
 ;
   %y = or <2 x i8> %yy, <i8 1, i8 1>
   %cmp = icmp uge <2 x i8> %v, <i8 1, i8 1>
   %s = select <2 x i1> %cmp, <2 x i8> %v, <2 x i8> %y
   %r = icmp eq <2 x i8> %s, zeroinitializer
   ret <2 x i1> %r
 }
 
 define i1 @inv_select_v_ule(i8 %v, i8 %y) {
 ; CHECK-LABEL: @inv_select_v_ule(
 ; CHECK-NEXT:    [[YNZ:%.*]] = icmp ne i8 [[Y:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[YNZ]])
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ule i8 [[V:%.*]], 4
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[CMP]], i8 [[Y]], i8 [[V]]
-; CHECK-NEXT:    [[R:%.*]] = icmp eq i8 [[S]], 0
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 false
 ;
   %ynz = icmp ne i8 %y, 0
   call void @llvm.assume(i1 %ynz)
   %cmp = icmp ule i8 %v, 4
   %s = select i1 %cmp, i8 %y, i8 %v
   %r = icmp eq i8 %s, 0
   ret i1 %r
 }
 
 define i1 @select_v_sgt_nonneg(i8 %v, i8 %y) {
 ; CHECK-LABEL: @select_v_sgt_nonneg(
 ; CHECK-NEXT:    [[YNZ:%.*]] = icmp ne i8 [[Y:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[YNZ]])
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[V:%.*]], 0
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[CMP]], i8 [[V]], i8 [[Y]]
-; CHECK-NEXT:    [[R:%.*]] = icmp eq i8 [[S]], 0
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 false
 ;
   %ynz = icmp ne i8 %y, 0
   call void @llvm.assume(i1 %ynz)
   %cmp = icmp sgt i8 %v, 0
   %s = select i1 %cmp, i8 %v, i8 %y
   %r = icmp eq i8 %s, 0
   ret i1 %r
 }
;
   %r = icmp eq i8 %s, 0
   ret i1 %r
 }
 
 define i1 @inv_select_v_sgt_neg(i8 %v, i8 %y) {
 ; CHECK-LABEL: @inv_select_v_sgt_neg(
 ; CHECK-NEXT:    [[YNZ:%.*]] = icmp ne i8 [[Y:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[YNZ]])
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[V:%.*]], -1
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[CMP]], i8 [[Y]], i8 [[V]]
-; CHECK-NEXT:    [[R:%.*]] = icmp eq i8 [[S]], 0
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 false
 ;
   %ynz = icmp ne i8 %y, 0
   call void @llvm.assume(i1 %ynz)
   %cmp = icmp sgt i8 %v, -1
   %s = select i1 %cmp, i8 %y, i8 %v
   %r = icmp eq i8 %s, 0
   ret i1 %r
 }
 
 define i1 @inv_select_v_sgt_nonneg_nz(i8 %v, i8 %C, i8 %y) {
 ; CHECK-LABEL: @inv_select_v_sgt_nonneg_nz(
 ; CHECK-NEXT:    [[YNZ:%.*]] = icmp ne i8 [[Y:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[YNZ]])
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 99, [[V:%.*]]
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[CMP]], i8 [[Y]], i8 [[V]]
-; CHECK-NEXT:    [[R:%.*]] = icmp eq i8 [[S]], 0
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 false
 ;
   %ynz = icmp ne i8 %y, 0
   call void @llvm.assume(i1 %ynz)
   %cmp = icmp sgt i8 99, %v
   %s = select i1 %cmp, i8 %y, i8 %v
   %r = icmp eq i8 %s, 0
   ret i1 %r
 }
 
 define i1 @select_v_slt_nonneg(i8 %v, i8 %y) {
 ; CHECK-LABEL: @select_v_slt_nonneg(
 ; CHECK-NEXT:    [[YNZ:%.*]] = icmp ne i8 [[Y:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[YNZ]])
-; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i8 0, [[V:%.*]]
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[CMP]], i8 [[V]], i8 [[Y]]
-; CHECK-NEXT:    [[R:%.*]] = icmp eq i8 [[S]], 0
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 false
 ;
   %ynz = icmp ne i8 %y, 0
   call void @llvm.assume(i1 %ynz)
   %cmp = icmp slt i8 0, %v
   %s = select i1 %cmp, i8 %v, i8 %y
   %r = icmp eq i8 %s, 0
   ret i1 %r
 }
;
   %r = icmp eq i8 %s, 0
   ret i1 %r
 }
 
 define i1 @select_v_slt_neg(i8 %v, i8 %y) {
 ; CHECK-LABEL: @select_v_slt_neg(
 ; CHECK-NEXT:    [[YNZ:%.*]] = icmp ne i8 [[Y:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[YNZ]])
-; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i8 [[V:%.*]], -1
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[CMP]], i8 [[V]], i8 [[Y]]
-; CHECK-NEXT:    [[R:%.*]] = icmp eq i8 [[S]], 0
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 false
 ;
   %ynz = icmp ne i8 %y, 0
   call void @llvm.assume(i1 %ynz)
   %cmp = icmp slt i8 %v, -1
   %s = select i1 %cmp, i8 %v, i8 %y
   %r = icmp eq i8 %s, 0
   ret i1 %r
 }
 
 define i1 @select_v_sge_nonneg_nz(i8 %v, i8 %y) {
 ; CHECK-LABEL: @select_v_sge_nonneg_nz(
 ; CHECK-NEXT:    [[YNZ:%.*]] = icmp ne i8 [[Y:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[YNZ]])
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sge i8 [[V:%.*]], 1
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[CMP]], i8 [[V]], i8 [[Y]]
-; CHECK-NEXT:    [[R:%.*]] = icmp eq i8 [[S]], 0
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 false
 ;
   %ynz = icmp ne i8 %y, 0
   call void @llvm.assume(i1 %ynz)
   %cmp = icmp sge i8 %v, 1
   %s = select i1 %cmp, i8 %v, i8 %y
   %r = icmp eq i8 %s, 0
   ret i1 %r
 }
 
 define i1 @select_v_sge_neg(i8 %v, i8 %y) {
 ; CHECK-LABEL: @select_v_sge_neg(
 ; CHECK-NEXT:    [[YNZ:%.*]] = icmp ne i8 [[Y:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[YNZ]])
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sge i8 -3, [[V:%.*]]
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[CMP]], i8 [[V]], i8 [[Y]]
-; CHECK-NEXT:    [[R:%.*]] = icmp eq i8 [[S]], 0
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 false
 ;
   %ynz = icmp ne i8 %y, 0
   call void @llvm.assume(i1 %ynz)
   %cmp = icmp sge i8 -3, %v
   %s = select i1 %cmp, i8 %v, i8 %y
   %r = icmp eq i8 %s, 0
   ret i1 %r
 }
 
 define i1 @inv_select_v_sge_z(i8 %v, i8 %y) {
 ; CHECK-LABEL: @inv_select_v_sge_z(
 ; CHECK-NEXT:    [[YNZ:%.*]] = icmp ne i8 [[Y:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[YNZ]])
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sge i8 [[V:%.*]], 0
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[CMP]], i8 [[Y]], i8 [[V]]
-; CHECK-NEXT:    [[R:%.*]] = icmp eq i8 [[S]], 0
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 false
 ;
   %ynz = icmp ne i8 %y, 0
   call void @llvm.assume(i1 %ynz)
   %cmp = icmp sge i8 %v, 0
   %s = select i1 %cmp, i8 %y, i8 %v
   %r = icmp eq i8 %s, 0
   ret i1 %r
 }
 
 define i1 @inv_select_v_sge_fail(i8 %v, i8 %C, i8 %y) {
 ; CHECK-LABEL: @inv_select_v_sge_fail(
 ; CHECK-NEXT:    [[YNZ:%.*]] = icmp ne i8 [[Y:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[YNZ]])
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sge i8 [[V:%.*]], -44
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[CMP]], i8 [[Y]], i8 [[V]]
-; CHECK-NEXT:    [[R:%.*]] = icmp eq i8 [[S]], 0
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 false
 ;
   %ynz = icmp ne i8 %y, 0
   call void @llvm.assume(i1 %ynz)
   %cmp = icmp sge i8 %v, -44
   %s = select i1 %cmp, i8 %y, i8 %v
   %r = icmp eq i8 %s, 0
   ret i1 %r
 }
 
 define i1 @select_v_sle_neg(i8 %v, i8 %y) {
 ; CHECK-LABEL: @select_v_sle_neg(
 ; CHECK-NEXT:    [[YNZ:%.*]] = icmp ne i8 [[Y:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[YNZ]])
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sle i8 [[V:%.*]], -1
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[CMP]], i8 [[V]], i8 [[Y]]
-; CHECK-NEXT:    [[R:%.*]] = icmp eq i8 [[S]], 0
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 false
 ;
   %ynz = icmp ne i8 %y, 0
   call void @llvm.assume(i1 %ynz)
   %cmp = icmp sle i8 %v, -1
   %s = select i1 %cmp, i8 %v, i8 %y
   %r = icmp eq i8 %s, 0
   ret i1 %r
 }
 
 define i1 @select_v_sle_nonneg_nz(i8 %v, i8 %y) {
 ; CHECK-LABEL: @select_v_sle_nonneg_nz(
 ; CHECK-NEXT:    [[YNZ:%.*]] = icmp ne i8 [[Y:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[YNZ]])
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sle i8 1, [[V:%.*]]
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[CMP]], i8 [[V]], i8 [[Y]]
-; CHECK-NEXT:    [[R:%.*]] = icmp eq i8 [[S]], 0
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 false
 ;
   %ynz = icmp ne i8 %y, 0
   call void @llvm.assume(i1 %ynz)
   %cmp = icmp sle i8 1, %v
   %s = select i1 %cmp, i8 %v, i8 %y
   %r = icmp eq i8 %s, 0
   ret i1 %r
 }
;
   %r = icmp eq i8 %s, 0
   ret i1 %r
 }
 
 define i1 @inv_select_v_sle_nonneg(i8 %v, i8 %y) {
 ; CHECK-LABEL: @inv_select_v_sle_nonneg(
 ; CHECK-NEXT:    [[YNZ:%.*]] = icmp ne i8 [[Y:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[YNZ]])
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sle i8 [[V:%.*]], 0
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[CMP]], i8 [[Y]], i8 [[V]]
-; CHECK-NEXT:    [[R:%.*]] = icmp eq i8 [[S]], 0
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 false
 ;
   %ynz = icmp ne i8 %y, 0
   call void @llvm.assume(i1 %ynz)
   %cmp = icmp sle i8 %v, 0
   %s = select i1 %cmp, i8 %y, i8 %v
   %r = icmp eq i8 %s, 0
   ret i1 %r
 }

llvm/test/Analysis/ValueTracking/select-known-non-zero.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
 
 declare void @llvm.assume(i1)
 define i1 @select_v_ne_z(i8 %v, i8 %y) {
 ; CHECK-LABEL: @select_v_ne_z(
 ; CHECK-NEXT:    [[YNZ:%.*]] = icmp ne i8 [[Y:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[YNZ]])
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i8 [[V:%.*]], 0
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[CMP]], i8 [[V]], i8 [[Y]]
-; CHECK-NEXT:    [[R:%.*]] = icmp eq i8 [[S]], 0
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 false
 ;
   %ynz = icmp ne i8 %y, 0
   call void @llvm.assume(i1 %ynz)
   %cmp = icmp ne i8 %v, 0
   %s = select i1 %cmp, i8 %v, i8 %y
   %r = icmp eq i8 %s, 0
   ret i1 %r
 }
;
   %r = icmp eq i8 %s, 0
   ret i1 %r
 }
 
 define i1 @select_v_ult(i8 %v, i8 %C, i8 %y) {
 ; CHECK-LABEL: @select_v_ult(
 ; CHECK-NEXT:    [[YNZ:%.*]] = icmp ne i8 [[Y:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[YNZ]])
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i8 [[C:%.*]], [[V:%.*]]
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[CMP]], i8 [[V]], i8 [[Y]]
-; CHECK-NEXT:    [[R:%.*]] = icmp eq i8 [[S]], 0
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 false
 ;
   %ynz = icmp ne i8 %y, 0
   call void @llvm.assume(i1 %ynz)
   %cmp = icmp ult i8 %C, %v
   %s = select i1 %cmp, i8 %v, i8 %y
   %r = icmp eq i8 %s, 0
   ret i1 %r
 }
;
   %r = icmp eq i8 %s, 0
   ret i1 %r
 }
 
 define i1 @inv_select_v_ule(i8 %v, i8 %C, i8 %y) {
 ; CHECK-LABEL: @inv_select_v_ule(
 ; CHECK-NEXT:    [[YNZ:%.*]] = icmp ne i8 [[Y:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[YNZ]])
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ule i8 [[V:%.*]], [[C:%.*]]
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[CMP]], i8 [[Y]], i8 [[V]]
-; CHECK-NEXT:    [[R:%.*]] = icmp eq i8 [[S]], 0
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 false
 ;
   %ynz = icmp ne i8 %y, 0
   call void @llvm.assume(i1 %ynz)
   %cmp = icmp ule i8 %v, %C
   %s = select i1 %cmp, i8 %y, i8 %v
   %r = icmp eq i8 %s, 0
   ret i1 %r
 }
;
   %r = icmp eq i8 %s, 0
   ret i1 %r
 }
 
 define i1 @inv_select_v_sge_z(i8 %v, i8 %y) {
 ; CHECK-LABEL: @inv_select_v_sge_z(
 ; CHECK-NEXT:    [[YNZ:%.*]] = icmp ne i8 [[Y:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[YNZ]])
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sge i8 [[V:%.*]], 0
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[CMP]], i8 [[Y]], i8 [[V]]
-; CHECK-NEXT:    [[R:%.*]] = icmp eq i8 [[S]], 0
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 false
 ;
   %ynz = icmp ne i8 %y, 0
   call void @llvm.assume(i1 %ynz)
   %cmp = icmp sge i8 %v, 0
   %s = select i1 %cmp, i8 %y, i8 %v
   %r = icmp eq i8 %s, 0
   ret i1 %r
 }

llvm/test/Transforms/InstSimplify/compare.ll

;
   %c = icmp eq i32 %x, 0
   %s = select i1 %c, i32 1, i32 %x
   %c2 = icmp eq i32 %s, 0
   ret i1 %c2
 }
 
 define i1 @select6(i32 %x) {
 ; CHECK-LABEL: @select6(
-; CHECK-NEXT:    [[C:%.*]] = icmp sgt i32 [[X:%.*]], 0
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[C]], i32 [[X]], i32 4
-; CHECK-NEXT:    [[C2:%.*]] = icmp eq i32 [[S]], 0
-; CHECK-NEXT:    ret i1 [[C2]]
+; CHECK-NEXT:    ret i1 false
 ;
   %c = icmp sgt i32 %x, 0
   %s = select i1 %c, i32 %x, i32 4
   %c2 = icmp eq i32 %s, 0
   ret i1 %c2
 }
 
 define i1 @urem1(i32 %X, i32 %Y) {