[ValueTracking] Add cases for additional ops in `isKnownNonZero`

[goldstein.w.n]

Summary

Add cases for the following ops:

• 0-X -- https://alive2.llvm.org/ce/z/6C75Li
• bitreverse(X) -- https://alive2.llvm.org/ce/z/SGG1q9
• bswap(X) -- https://alive2.llvm.org/ce/z/p7pzwh
• ctpop(X) -- https://alive2.llvm.org/ce/z/c5y3BC
• abs(X) -- https://alive2.llvm.org/ce/z/yxXGz_ https://alive2.llvm.org/ce/z/rSRg4K
• uadd_sat(X, Y) -- https://alive2.llvm.org/ce/z/Zw-y4W https://alive2.llvm.org/ce/z/2NRqRz https://alive2.llvm.org/ce/z/M1OpF8

[nikic]

LGTM

llvm/lib/Analysis/ValueTracking.cpp

2734

Invoke handling unnecessary

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

56

Not really relevant in InstSimplify?

[goldstein.w.n]

llvm/lib/Analysis/ValueTracking.cpp

2734

Invoke handling unnecessary

Dropped, sorry was just copying from computeKnowBits.

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

56

Not really relevant in InstSimplify?

Good point. Dropped from D142827 (and likewise this).

[goldstein.w.n]

Remove invoke/ rebase

llvm/lib/Analysis/ValueTracking.cpp

#endif
   case Instruction::PtrToInt:
     // Similar to int2ptr above, we can look through ptr2int here if the cast
     // is a no-op or an extend and not a truncate.
     if (!isa<ScalableVectorType>(I->getType()) &&
         Q.DL.getTypeSizeInBits(I->getOperand(0)->getType()).getFixedValue() <=
             Q.DL.getTypeSizeInBits(I->getType()).getFixedValue())
       return isKnownNonZero(I->getOperand(0), Depth, Q);
     break;
+  case Instruction::Sub:
+    if (auto *C = dyn_cast<Constant>(I->getOperand(0)))
+      if (C->isNullValue() &&
+          isKnownNonZero(I->getOperand(1), DemandedElts, Depth, Q))
+        return true;
+    break;
   case Instruction::Or:
     // X | Y != 0 if X != 0 or Y != 0.
     return isKnownNonZero(I->getOperand(0), DemandedElts, Depth, Q) ||
            isKnownNonZero(I->getOperand(1), DemandedElts, Depth, Q);
   case Instruction::SExt:
   case Instruction::ZExt:
     // ext X != 0 if X != 0.
     return isKnownNonZero(I->getOperand(0), Depth, Q);
if (const auto *EEI = dyn_cast<ExtractElementInst>(V)) {
       }
     }
     break;
   case Instruction::Freeze:
     return isKnownNonZero(I->getOperand(0), Depth, Q) &&
            isGuaranteedNotToBePoison(I->getOperand(0), Q.AC, Q.CxtI, Q.DT,
                                      Depth);
   case Instruction::Call:
-    if (cast<CallInst>(I)->getIntrinsicID() == Intrinsic::vscale)
+  case Instruction::Invoke:
+    if (auto *II = dyn_cast<IntrinsicInst>(I)) {
+      switch (II->getIntrinsicID()) {
+      case Intrinsic::abs:
+      case Intrinsic::bitreverse:
+      case Intrinsic::bswap:
+      case Intrinsic::ctpop:
+        if (isKnownNonZero(II->getArgOperand(0), DemandedElts, Depth, Q))
+          return true;
+        break;
+      case Intrinsic::uadd_sat:
+        if (isKnownNonZero(II->getArgOperand(0), DemandedElts, Depth, Q) ||
+            isKnownNonZero(II->getArgOperand(1), DemandedElts, Depth, Q))
+          return true;
+        break;
+      case Intrinsic::vscale:
         return true;
+      default:
+        break;
+      }
+    }
     break;
   }
 
   KnownBits Known(BitWidth);
   computeKnownBits(V, DemandedElts, Known, Depth, Q);
   return Known.One != 0;
 }
 

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

 ;; test explicitly that `isKnownNonZero` works.
 
 define i1 @check_neg(i8 %x, i8 %y) {
 ; CHECK-LABEL: @check_neg(
 ; CHECK-NEXT:    [[NE:%.*]] = icmp ne i8 [[X:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[NE]])
 ; CHECK-NEXT:    [[Z:%.*]] = sub i8 0, [[X]]
 ; CHECK-NEXT:    [[CMP0:%.*]] = icmp ugt i8 [[Z]], [[Y:%.*]]
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 [[Y]], 0
-; CHECK-NEXT:    [[R:%.*]] = or i1 [[CMP0]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 [[CMP0]]
 ;
   %ne = icmp ne i8 %x, 0
   call void @llvm.assume(i1 %ne)
   %z = sub i8 0, %x
   %cmp0 = icmp ugt i8 %z, %y
   %cmp1 = icmp eq i8 %y, 0
   %r = or i1 %cmp0, %cmp1
   ret i1 %r
 }
 
 define i1 @check_abs(i8 %x, i8 %y) {
 ; CHECK-LABEL: @check_abs(
 ; CHECK-NEXT:    [[NE:%.*]] = icmp ne i8 [[X:%.*]], 0
 ; CHECK-NEXT:    br i1 [[NE]], label [[TRUE:%.*]], label [[FALSE:%.*]]
 ; CHECK:       true:
 ; CHECK-NEXT:    [[Z:%.*]] = call i8 @llvm.abs.i8(i8 [[X]], i1 true)
 ; CHECK-NEXT:    [[CMP0:%.*]] = icmp ugt i8 [[Z]], [[Y:%.*]]
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 [[Y]], 0
-; CHECK-NEXT:    [[R:%.*]] = or i1 [[CMP0]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 [[CMP0]]
 ; CHECK:       false:
 ; CHECK-NEXT:    call void @use1(i1 [[NE]])
 ; CHECK-NEXT:    ret i1 [[NE]]
 ;
   %ne = icmp ne i8 %x, 0
   br i1 %ne, label %true, label %false
 true:
   %z = call i8 @llvm.abs.i8(i8 %x, i1 true)
   %cmp0 = icmp ugt i8 %z, %y
   %cmp1 = icmp eq i8 %y, 0
   %r = or i1 %cmp0, %cmp1
   ret i1 %r
 false:
   ;; So that branch doesn't fold to select.
   call void @use1(i1 %ne)
   ret i1 %ne
 }
 
 define i1 @check_abs_failish(i8 %x, i8 %y) {
 ; CHECK-LABEL: @check_abs_failish(
 ; CHECK-NEXT:    [[NE:%.*]] = icmp ne i8 [[X:%.*]], 0
 ; CHECK-NEXT:    br i1 [[NE]], label [[TRUE:%.*]], label [[FALSE:%.*]]

 }
 
 define i1 @check_bitreverse(i8 %x, i8 %y) {
 ; CHECK-LABEL: @check_bitreverse(
 ; CHECK-NEXT:    [[NE:%.*]] = icmp ne i8 [[X:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[NE]])
 ; CHECK-NEXT:    [[Z:%.*]] = call i8 @llvm.bitreverse.i8(i8 [[X]])
 ; CHECK-NEXT:    [[CMP0:%.*]] = icmp ugt i8 [[Z]], [[Y:%.*]]
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 [[Y]], 0
-; CHECK-NEXT:    [[R:%.*]] = or i1 [[CMP0]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 [[CMP0]]
 ;
   %ne = icmp ne i8 %x, 0
   call void @llvm.assume(i1 %ne)
   %z = call i8 @llvm.bitreverse.i8(i8 %x)
   %cmp0 = icmp ugt i8 %z, %y
   %cmp1 = icmp eq i8 %y, 0
   %r = or i1 %cmp0, %cmp1
   ret i1 %r
 }
 
 define i1 @check_bswap(i16 %x, i16 %y) {
 ; CHECK-LABEL: @check_bswap(
 ; CHECK-NEXT:    [[NE:%.*]] = icmp ne i16 [[X:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[NE]])
 ; CHECK-NEXT:    [[Z:%.*]] = call i16 @llvm.bswap.i16(i16 [[X]])
 ; CHECK-NEXT:    [[CMP0:%.*]] = icmp ugt i16 [[Z]], [[Y:%.*]]
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i16 [[Y]], 0
-; CHECK-NEXT:    [[R:%.*]] = or i1 [[CMP0]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 [[CMP0]]
 ;
   %ne = icmp ne i16 %x, 0
   call void @llvm.assume(i1 %ne)
   %z = call i16 @llvm.bswap.i16(i16 %x)
   %cmp0 = icmp ugt i16 %z, %y
   %cmp1 = icmp eq i16 %y, 0
   %r = or i1 %cmp0, %cmp1
   ret i1 %r
 }
 
 define i1 @check_ctpop(i8 %x, i8 %y) {
 ; CHECK-LABEL: @check_ctpop(
 ; CHECK-NEXT:    [[NE:%.*]] = icmp eq i8 [[X:%.*]], 0
 ; CHECK-NEXT:    br i1 [[NE]], label [[TRUE:%.*]], label [[FALSE:%.*]]
 ; CHECK:       true:
 ; CHECK-NEXT:    call void @use1(i1 [[NE]])
 ; CHECK-NEXT:    ret i1 [[NE]]
 ; CHECK:       false:
 ; CHECK-NEXT:    [[Z:%.*]] = call i8 @llvm.ctpop.i8(i8 [[X]])
 ; CHECK-NEXT:    [[CMP0:%.*]] = icmp ugt i8 [[Z]], [[Y:%.*]]
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 [[Y]], 0
-; CHECK-NEXT:    [[R:%.*]] = or i1 [[CMP0]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 [[CMP0]]
 ;
   %ne = icmp eq i8 %x, 0
   br i1 %ne, label %true, label %false
 true:
   ;; So that branch doesn't fold to select.
   call void @use1(i1 %ne)
   ret i1 %ne
 false:
   %z = call i8 @llvm.ctpop.i8(i8 %x)
   %cmp0 = icmp ugt i8 %z, %y
   %cmp1 = icmp eq i8 %y, 0
   %r = or i1 %cmp0, %cmp1
   ret i1 %r
 }
 
 define i1 @check_add_sat(i8 %x, i8 %y, i8 %w) {
 ; CHECK-LABEL: @check_add_sat(
 ; CHECK-NEXT:    [[NE:%.*]] = icmp ne i8 [[X:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[NE]])
 ; CHECK-NEXT:    [[Z:%.*]] = call i8 @llvm.uadd.sat.i8(i8 [[X]], i8 [[Y:%.*]])
 ; CHECK-NEXT:    [[CMP0:%.*]] = icmp ugt i8 [[Z]], [[W:%.*]]
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 [[W]], 0
-; CHECK-NEXT:    [[R:%.*]] = or i1 [[CMP0]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 [[CMP0]]
 ;
   %ne = icmp ne i8 %x, 0
   call void @llvm.assume(i1 %ne)
   %z = call i8 @llvm.uadd.sat.i8(i8 %x, i8 %y)
   %cmp0 = icmp ugt i8 %z, %w
   %cmp1 = icmp eq i8 %w, 0
   %r = or i1 %cmp0, %cmp1
   ret i1 %r
 }
 
 define <2 x i1> @check_add_sat_vec(<2 x i8> %x, <2 x i8> %y, <2 x i8> %w) {
 ; CHECK-LABEL: @check_add_sat_vec(
 ; CHECK-NEXT:    [[YNZ:%.*]] = or <2 x i8> [[Y:%.*]], <i8 2, i8 1>
 ; CHECK-NEXT:    [[Z:%.*]] = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> [[X:%.*]], <2 x i8> [[YNZ]])
 ; CHECK-NEXT:    [[CMP0:%.*]] = icmp ugt <2 x i8> [[Z]], [[W:%.*]]
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq <2 x i8> [[W]], zeroinitializer
-; CHECK-NEXT:    [[R:%.*]] = or <2 x i1> [[CMP0]], [[CMP1]]
-; CHECK-NEXT:    ret <2 x i1> [[R]]
+; CHECK-NEXT:    ret <2 x i1> [[CMP0]]
 ;
   %ynz = or <2 x i8> %y, <i8 2, i8 1>
   %z = call <2 x i8> @llvm.uadd.sat.2xi8(<2 x i8> %x, <2 x i8> %ynz)
   %cmp0 = icmp ugt <2 x i8> %z, %w
   %cmp1 = icmp eq <2 x i8> %w, <i8 0, i8 0>
   %r = or <2 x i1> %cmp0, %cmp1
   ret <2 x i1> %r
 }