[ValueTracking] Use `isKnownNonZero` for checking if `sdiv`/`srem` are speculatable

[goldstein.w.n]

Summary

Previously was using KnownBits.isNonZero() which is weaker the
isKnownNonZero. KnownBits.isNonZero() requires us to actually know
a bit which is often not the case even when we know non-zero.

llvm/lib/Analysis/ValueTracking.cpp

case Instruction::URem: {
     // x / y is undefined if y == 0.
     const DataLayout &DL = Inst->getModule()->getDataLayout();
     return isKnownNonZero(Inst->getOperand(1), DL, /*Depth*/ 0, AC, CtxI, DT);
   }
   case Instruction::SDiv:
   case Instruction::SRem: {
     // x / y is undefined if y == 0 or x == INT_MIN and y == -1
     const DataLayout &DL = Inst->getModule()->getDataLayout();
-    KnownBits KnownDenominator =
-        computeKnownBits(Inst->getOperand(1), DL, /*Depth*/ 0, AC, CtxI, DT);
     // We cannot hoist this division if the denominator is 0.
-    if (!KnownDenominator.isNonZero())
+    if (!isKnownNonZero(Inst->getOperand(1), DL, /*Depth*/ 0, AC, CtxI, DT))
       return false;
 
+    KnownBits KnownDenominator =
+        computeKnownBits(Inst->getOperand(1), DL, /*Depth*/ 0, AC, CtxI, DT);
+
     // It's safe to hoist if the denominator is not 0 or -1.
     if (!KnownDenominator.Zero.isZero())
       return true;
 
     // At this point denominator may be -1.  It is safe to hoist as
     // long we know that the numerator is not INT_MIN.
     KnownBits KnownNumerator =
         computeKnownBits(Inst->getOperand(0), DL, /*Depth*/ 0, AC, CtxI, DT);

llvm/test/Transforms/InstCombine/binop-select.ll

;
   %cond = select <2 x i1> %c, <2 x i32> <i32 7, i32 9>, <2 x i32> <i32 17, i32 5>
   %div = sdiv <2 x i32> %x, %cond
   ret <2 x i32> %div
 }
 
 define <2 x i32> @test_sdiv_to_const_Csdiv_todo_no_common_bit(<2 x i32> %x) {
 ; CHECK-LABEL: @test_sdiv_to_const_Csdiv_todo_no_common_bit(
 ; CHECK-NEXT:    [[C_NOT:%.*]] = icmp eq <2 x i32> [[X:%.*]], <i32 90, i32 91>
-; CHECK-NEXT:    [[COND:%.*]] = select <2 x i1> [[C_NOT]], <2 x i32> <i32 16, i32 4>, <2 x i32> <i32 7, i32 9>
-; CHECK-NEXT:    [[DIV:%.*]] = sdiv <2 x i32> [[X]], [[COND]]
+; CHECK-NEXT:    [[TMP1:%.*]] = sdiv <2 x i32> [[X]], <i32 7, i32 9>
+; CHECK-NEXT:    [[DIV:%.*]] = select <2 x i1> [[C_NOT]], <2 x i32> <i32 5, i32 22>, <2 x i32> [[TMP1]]
 ; CHECK-NEXT:    ret <2 x i32> [[DIV]]
 ;
   %c = icmp ne <2 x i32> %x, <i32 90, i32 91>
   %cond = select <2 x i1> %c, <2 x i32> <i32 7, i32 9>, <2 x i32> <i32 16, i32 4>
   %div = sdiv <2 x i32> %x, %cond
   ret <2 x i32> %div
 }
 
 define i32 @test_srem_to_const_Csrem(i32 %x) {
 ; CHECK-LABEL: @test_srem_to_const_Csrem(
 ; CHECK-NEXT:    [[C:%.*]] = icmp eq i32 [[X:%.*]], 24
 ; CHECK-NEXT:    [[TMP1:%.*]] = srem i32 [[X]], 16
 ; CHECK-NEXT:    [[DIV:%.*]] = select i1 [[C]], i32 6, i32 [[TMP1]]
 ; CHECK-NEXT:    ret i32 [[DIV]]
 ;
   %c = icmp eq i32 %x, 24
   %cond = select i1 %c, i32 18, i32 16
   %div = srem i32 %x, %cond
   ret i32  %div
 }
 
 define i32 @test_srem_to_const_Csrem_todo_no_common_bits(i32 %x) {
 ; CHECK-LABEL: @test_srem_to_const_Csrem_todo_no_common_bits(
 ; CHECK-NEXT:    [[C:%.*]] = icmp eq i32 [[X:%.*]], 24
-; CHECK-NEXT:    [[COND:%.*]] = select i1 [[C]], i32 7, i32 16
-; CHECK-NEXT:    [[DIV:%.*]] = srem i32 [[X]], [[COND]]
+; CHECK-NEXT:    [[TMP1:%.*]] = srem i32 [[X]], 16
+; CHECK-NEXT:    [[DIV:%.*]] = select i1 [[C]], i32 3, i32 [[TMP1]]
 ; CHECK-NEXT:    ret i32 [[DIV]]
 ;
   %c = icmp eq i32 %x, 24
   %cond = select i1 %c, i32 7, i32 16
   %div = srem i32 %x, %cond
   ret i32  %div
 }
 

llvm/test/Transforms/LICM/speculate-div.ll

loop:
   br label %loop
 }
 
 define void @srem_ok3(i16 %nn, i16 %xx) {
 ; CHECK-LABEL: @srem_ok3(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[N:%.*]] = and i16 [[NN:%.*]], 123
 ; CHECK-NEXT:    [[X:%.*]] = add nuw nsw i16 [[XX:%.*]], 1
+; CHECK-NEXT:    [[DIV:%.*]] = srem i16 [[N]], [[X]]
 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 ; CHECK:       loop:
 ; CHECK-NEXT:    call void @maythrow()
-; CHECK-NEXT:    [[DIV:%.*]] = srem i16 [[N]], [[X]]
 ; CHECK-NEXT:    call void @use(i16 [[DIV]])
 ; CHECK-NEXT:    br label [[LOOP]]
 ;
 entry:
   %n = and i16 %nn, 123
   %x = add nuw nsw i16 %xx, 1
   br label %loop
 loop: