[ValueTracking] Compute `sdiv` as non-zero if `abs(num) u>= abs(denum)`

[goldstein.w.n]

Summary

Just covering an additional case.

Proof: https://alive2.llvm.org/ce/z/MJz9fT

[nikic]

LGTM

llvm/lib/Analysis/ValueTracking.cpp

2582

computing

2583

Pre existing, but this should be an early return false.

[goldstein.w.n]

Fixup comment/early return

llvm/lib/Analysis/ValueTracking.cpp

case Instruction::AShr: {
     KnownBits Known =
         computeKnownBits(I->getOperand(0), DemandedElts, Depth, Q);
     if (Known.isNegative())
       return true;
 
     return isNonZeroShift(I, DemandedElts, Depth, Q, Known);
   }
   case Instruction::UDiv:
-  case Instruction::SDiv:
+  case Instruction::SDiv: {
     // X / Y
     // div exact can only produce a zero if the dividend is zero.
     if (cast<PossiblyExactOperator>(I)->isExact())
       return isKnownNonZero(I->getOperand(0), DemandedElts, Depth, Q);
-    if (I->getOpcode() == Instruction::UDiv) {
-      std::optional<bool> XUgeY;
-      KnownBits XKnown =
-          computeKnownBits(I->getOperand(0), DemandedElts, Depth, Q);
-      if (!XKnown.isUnknown()) {
-        KnownBits YKnown =
-            computeKnownBits(I->getOperand(1), DemandedElts, Depth, Q);
-        // If X u>= Y then div is non zero (0/0 is UB).
-        XUgeY = KnownBits::uge(XKnown, YKnown);
-      }
-      // If X is total unknown or X u< Y we won't be able to prove non-zero
-      // with compute known bits so just return early.
-      return XUgeY && *XUgeY;
-    }
-    break;
+
+    // If X is fully unknown we won't be able to figure anything out so don't
+    // both computing knownbits for Y.
+    if (XKnown.isUnknown())
+      return false;
+
+    if (I->getOpcode() == Instruction::SDiv) {
+      // For signed division need to compare abs value of the operands.
+      XKnown = XKnown.abs(/*IntMinIsPoison*/ false);
+      YKnown = YKnown.abs(/*IntMinIsPoison*/ false);
+    }
   case Instruction::Add: {
     // X + Y.
 
     // If Add has nuw wrap flag, then if either X or Y is non-zero the result is
     // non-zero.
     auto *BO = cast<OverflowingBinaryOperator>(I);
     if (Q.IIQ.hasNoUnsignedWrap(BO))
       return isKnownNonZero(I->getOperand(1), DemandedElts, Depth, Q) ||

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

;
   %yy = or i8 %y, 8
   %xy = mul i8 %xx, %yy
   %nz = icmp ne i8 %xy, 0
   ret i1 %nz
 }
 
 define i1 @sdiv_known_non_zero(i8 %x, i8 %y) {
 ; CHECK-LABEL: @sdiv_known_non_zero(
-; CHECK-NEXT:    [[XX0:%.*]] = or i8 [[X:%.*]], -121
-; CHECK-NEXT:    [[XX:%.*]] = and i8 [[XX0]], -2
-; CHECK-NEXT:    [[XY:%.*]] = sdiv i8 [[XX]], -2
-; CHECK-NEXT:    [[NZ:%.*]] = icmp ne i8 [[XY]], 0
-; CHECK-NEXT:    ret i1 [[NZ]]
+; CHECK-NEXT:    ret i1 true
 ;
   %xx0 = or i8 %x, 135
   %xx = and i8 %xx0, -2
   %xy = sdiv i8 %xx, -2
   %nz = icmp ne i8 %xy, 0
   ret i1 %nz
 }
 
 define i1 @sdiv_known_non_zero2(i8 %x, i8 %y) {
 ; CHECK-LABEL: @sdiv_known_non_zero2(
-; CHECK-NEXT:    [[XX0:%.*]] = or i8 [[X:%.*]], 15
-; CHECK-NEXT:    [[XX:%.*]] = and i8 [[XX0]], -4
-; CHECK-NEXT:    [[YY:%.*]] = and i8 [[Y:%.*]], 3
-; CHECK-NEXT:    [[XY:%.*]] = sdiv i8 [[XX]], [[YY]]
-; CHECK-NEXT:    [[NZ:%.*]] = icmp ne i8 [[XY]], 0
-; CHECK-NEXT:    ret i1 [[NZ]]
+; CHECK-NEXT:    ret i1 true
 ;
   %xx0 = or i8 %x, 15
   %xx = and i8 %xx0, -4
   %yy = and i8 %y, 3
   %xy = sdiv i8 %xx, %yy
   %nz = icmp ne i8 %xy, 0
   ret i1 %nz
 }