ValueTracking: Teach isKnownNeverInfinity about llvm.log*

[spatel]

llvm/lib/Analysis/ValueTracking.cpp

3844

Don't we need to check that the input is non-zero to guard against log(0) --> -inf?

This should not fold?

define i1 @isKnownNeverNegInfinity_log(double %x) {
  %a = call ninf double @llvm.sqrt.f64(double %x) ; could be 0.0
  %e = call double @llvm.log.f64(double %a) ; log(0.0) --> -inf
  %r = fcmp une double %e, 0xfff0000000000000
  ret i1 %r
}

[arsenm]

llvm/lib/Analysis/ValueTracking.cpp

3844

Yes, I was thinking cannotBeOrderedLessThanZeroImpl would catch it but we're missing the known-never-0 API. I want to merge all of these into one knownFPClass API which would help catch this

[arsenm]

Obsoleted between D148549 and D147942

llvm/lib/Analysis/ValueTracking.cpp

if (const auto *II = dyn_cast<IntrinsicInst>(V)) {
         // Requires knowing the value range.
         return false;
       case Intrinsic::minnum:
       case Intrinsic::maxnum:
       case Intrinsic::minimum:
       case Intrinsic::maximum:
       return isKnownNeverInfinity(Inst->getOperand(0), TLI, Depth + 1) &&
              isKnownNeverInfinity(Inst->getOperand(1), TLI, Depth + 1);
+      case Intrinsic::log:
+      case Intrinsic::log10:
+      case Intrinsic::log2:
+      // log(+inf) -> +inf
+      // log([+-]0.0) -> -inf
+      // log(-inf) -> nan
+      // log(-x) -> nan
+      return isKnownNeverInfinity(Inst->getOperand(0), TLI, Depth + 1) &&
+             cannotBeOrderedLessThanZeroImpl(Inst->getOperand(0), TLI,
+                                             /*SignBitOnly=*/false, Depth + 1);
       default:
         break;
       }
     }
   }
 
   // try to handle fixed width vector constants
   auto *VFVTy = dyn_cast<FixedVectorType>(V->getType());

llvm/test/Transforms/InstSimplify/floating-point-compare.ll

;
   %r = fcmp une double %e, 0x7ff0000000000000
   ret i1 %r
 }
 
 declare double @llvm.cos.f64(double)
 
 define i1 @isKnownNeverInfinity_log(double %x) {
 ; CHECK-LABEL: @isKnownNeverInfinity_log(
-; CHECK-NEXT:    [[X_CLAMP_ZERO:%.*]] = call double @llvm.maxnum.f64(double [[X:%.*]], double 0.000000e+00)
-; CHECK-NEXT:    [[A:%.*]] = fadd ninf double [[X_CLAMP_ZERO]], 1.000000e+00
-; CHECK-NEXT:    [[E:%.*]] = call double @llvm.log.f64(double [[A]])
-; CHECK-NEXT:    [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 true
 ;
   %x.clamp.zero = call double @llvm.maxnum.f64(double %x, double 0.0)
   %a = fadd ninf double %x.clamp.zero, 1.0
   %e = call double @llvm.log.f64(double %a)
   %r = fcmp une double %e, 0x7ff0000000000000
   ret i1 %r
 }
 
;
   %r = fcmp une double %e, 0x7ff0000000000000
   ret i1 %r
 }
 
 declare double @llvm.log.f64(double)
 
 define i1 @isKnownNeverInfinity_log10(double %x) {
 ; CHECK-LABEL: @isKnownNeverInfinity_log10(
-; CHECK-NEXT:    [[X_CLAMP_ZERO:%.*]] = call double @llvm.maxnum.f64(double [[X:%.*]], double 0.000000e+00)
-; CHECK-NEXT:    [[A:%.*]] = fadd ninf double [[X_CLAMP_ZERO]], 1.000000e+00
-; CHECK-NEXT:    [[E:%.*]] = call double @llvm.log10.f64(double [[A]])
-; CHECK-NEXT:    [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 true
 ;
   %x.clamp.zero = call double @llvm.maxnum.f64(double %x, double 0.0)
   %a = fadd ninf double %x.clamp.zero, 1.0
   %e = call double @llvm.log10.f64(double %a)
   %r = fcmp une double %e, 0x7ff0000000000000
   ret i1 %r
 }
 
;
   %r = fcmp une double %e, 0x7ff0000000000000
   ret i1 %r
 }
 
 declare double @llvm.log10.f64(double)
 
 define i1 @isKnownNeverInfinity_log2(double %x) {
 ; CHECK-LABEL: @isKnownNeverInfinity_log2(
-; CHECK-NEXT:    [[X_CLAMP_ZERO:%.*]] = call double @llvm.maxnum.f64(double [[X:%.*]], double 0.000000e+00)
-; CHECK-NEXT:    [[A:%.*]] = fadd ninf double [[X_CLAMP_ZERO]], 1.000000e+00
-; CHECK-NEXT:    [[E:%.*]] = call double @llvm.log2.f64(double [[A]])
-; CHECK-NEXT:    [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 true
 ;
   %x.clamp.zero = call double @llvm.maxnum.f64(double %x, double 0.0)
   %a = fadd ninf double %x.clamp.zero, 1.0
   %e = call double @llvm.log2.f64(double %a)
   %r = fcmp une double %e, 0x7ff0000000000000
   ret i1 %r
 }