This is an archive of the discontinued LLVM Phabricator instance.

Differential D139320

ValueTracking: Document some difficult isKnownNeverInfinity cases
ClosedPublic

Authored by arsenm on Dec 5 2022, 5:39 AM.

Details

Reviewers
spatel
nlopes
jcranmer-intel
kpn
andrew.w.kaylor
Summary

Add a comment and some negative tests. I'd like to have test coverage
and explicit handling of all the math operations for clarity.

Diff Detail

Revision Contents

Diff 480076

llvm/lib/Analysis/ValueTracking.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 3,837 Lines • ▼ Show 20 Lines if (const auto *II = dyn_cast<IntrinsicInst>(V)) {
case Intrinsic::log2: case Intrinsic::log2:
// log(+inf) -> +inf // log(+inf) -> +inf
// log([+-]0.0) -> -inf // log([+-]0.0) -> -inf
// log(-inf) -> nan // log(-inf) -> nan
// log(-x) -> nan // log(-x) -> nan
return isKnownNeverInfinity(Inst->getOperand(0), TLI, Depth + 1) && return isKnownNeverInfinity(Inst->getOperand(0), TLI, Depth + 1) &&
cannotBeOrderedLessThanZeroImpl(Inst->getOperand(0), TLI, cannotBeOrderedLessThanZeroImpl(Inst->getOperand(0), TLI,
/*SignBitOnly=*/false, Depth + 1); /*SignBitOnly=*/false, Depth + 1);
case Intrinsic::exp:
case Intrinsic::exp2:
case Intrinsic::pow:
case Intrinsic::powi:
case Intrinsic::fma:
case Intrinsic::fmuladd:
// These can return infinities on overflow cases, so it's hard to prove
// anything about it.
return false;
default: default:
break; break;
} }
} }
} }
// try to handle fixed width vector constants // try to handle fixed width vector constants
auto *VFVTy = dyn_cast<FixedVectorType>(V->getType()); auto *VFVTy = dyn_cast<FixedVectorType>(V->getType());
▲ Show 20 Lines • Show All 3,649 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 1,863 Lines • ▼ Show 20 Lines
; ;
%x.clamp.zero = call double @llvm.maxnum.f64(double %x, double 0.0) %x.clamp.zero = call double @llvm.maxnum.f64(double %x, double 0.0)
%e = call double @llvm.log2.f64(double %x.clamp.zero) %e = call double @llvm.log2.f64(double %x.clamp.zero)
%r = fcmp une double %e, 0x7ff0000000000000 %r = fcmp une double %e, 0x7ff0000000000000
ret i1 %r ret i1 %r
} }
declare double @llvm.log2.f64(double) declare double @llvm.log2.f64(double)
define i1 @isNotKnownNeverInfinity_pow(double %x, double %y) {
; CHECK-LABEL: @isNotKnownNeverInfinity_pow(
; CHECK-NEXT: [[NINF_X:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
; CHECK-NEXT: [[NINF_Y:%.*]] = fadd ninf double [[Y:%.*]], 1.000000e+00
; CHECK-NEXT: [[OP:%.*]] = call double @llvm.pow.f64(double [[NINF_X]], double [[NINF_Y]])
; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
; CHECK-NEXT: ret i1 [[CMP]]
;
%ninf.x = fadd ninf double %x, 1.0
%ninf.y = fadd ninf double %y, 1.0
%op = call double @llvm.pow.f64(double %ninf.x, double %ninf.y)
%cmp = fcmp une double %op, 0x7ff0000000000000
ret i1 %cmp
}
declare double @llvm.pow.f64(double, double)
define i1 @isNotKnownNeverInfinity_powi(double %x) {
; CHECK-LABEL: @isNotKnownNeverInfinity_powi(
; CHECK-NEXT: [[NINF_X:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
; CHECK-NEXT: [[OP:%.*]] = call double @llvm.powi.f64.i32(double [[NINF_X]], i32 2)
; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
; CHECK-NEXT: ret i1 [[CMP]]
;
%ninf.x = fadd ninf double %x, 1.0
%op = call double @llvm.powi.f64.i32(double %ninf.x, i32 2)
%cmp = fcmp une double %op, 0x7ff0000000000000
ret i1 %cmp
}
declare double @llvm.powi.f64(double, i32)
define i1 @isNotKnownNeverInfinity_exp(double %x) {
; CHECK-LABEL: @isNotKnownNeverInfinity_exp(
; CHECK-NEXT: [[A:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
; CHECK-NEXT: [[E:%.*]] = call double @llvm.exp.f64(double [[A]])
; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
; CHECK-NEXT: ret i1 [[R]]
;
%a = fadd ninf double %x, 1.0
%e = call double @llvm.exp.f64(double %a)
%r = fcmp une double %e, 0x7ff0000000000000
ret i1 %r
}
declare double @llvm.exp.f64(double)
define i1 @isNotKnownNeverInfinity_exp2(double %x) {
; CHECK-LABEL: @isNotKnownNeverInfinity_exp2(
; CHECK-NEXT: [[A:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
; CHECK-NEXT: [[E:%.*]] = call double @llvm.exp2.f64(double [[A]])
; CHECK-NEXT: [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
; CHECK-NEXT: ret i1 [[R]]
;
%a = fadd ninf double %x, 1.0
%e = call double @llvm.exp2.f64(double %a)
%r = fcmp une double %e, 0x7ff0000000000000
ret i1 %r
}
define i1 @isNotKnownNeverInfinity_fma(double %x, double %y, double %z) {
; CHECK-LABEL: @isNotKnownNeverInfinity_fma(
; CHECK-NEXT: [[NINF_X:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
; CHECK-NEXT: [[NINF_Y:%.*]] = fadd ninf double [[Y:%.*]], 1.000000e+00
; CHECK-NEXT: [[NINF_Z:%.*]] = fadd ninf double [[Z:%.*]], 1.000000e+00
; CHECK-NEXT: [[OP:%.*]] = call double @llvm.fma.f64(double [[NINF_X]], double [[NINF_Y]], double [[NINF_Z]])
; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
; CHECK-NEXT: ret i1 [[CMP]]
;
%ninf.x = fadd ninf double %x, 1.0
%ninf.y = fadd ninf double %y, 1.0
%ninf.z = fadd ninf double %z, 1.0
%op = call double @llvm.fma.f64(double %ninf.x, double %ninf.y, double %ninf.z)
%cmp = fcmp une double %op, 0x7ff0000000000000
ret i1 %cmp
}
declare double @llvm.fma.f64(double, double, double)
define i1 @isNotKnownNeverInfinity_fmuladd(double %x, double %y, double %z) {
; CHECK-LABEL: @isNotKnownNeverInfinity_fmuladd(
; CHECK-NEXT: [[NINF_X:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
; CHECK-NEXT: [[NINF_Y:%.*]] = fadd ninf double [[Y:%.*]], 1.000000e+00
; CHECK-NEXT: [[NINF_Z:%.*]] = fadd ninf double [[Z:%.*]], 1.000000e+00
; CHECK-NEXT: [[OP:%.*]] = call double @llvm.fmuladd.f64(double [[NINF_X]], double [[NINF_Y]], double [[NINF_Z]])
; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
; CHECK-NEXT: ret i1 [[CMP]]
;
%ninf.x = fadd ninf double %x, 1.0
%ninf.y = fadd ninf double %y, 1.0
%ninf.z = fadd ninf double %z, 1.0
%op = call double @llvm.fmuladd.f64(double %ninf.x, double %ninf.y, double %ninf.z)
%cmp = fcmp une double %op, 0x7ff0000000000000
ret i1 %cmp
}
declare double @llvm.fmuladd.f64(double, double, double)