This is an archive of the discontinued LLVM Phabricator instance.

Differential D50582

ValueTracking: Handle more instructions in isKnownNeverNaN
ClosedPublic

Authored by arsenm on Aug 10 2018, 2:24 PM.

Details

Reviewers
spatel
scanon

Diff Detail

Event Timeline

arsenm created this revision.Aug 10 2018, 2:24 PM
Herald added a subscriber: wdng. · View Herald TranscriptAug 10 2018, 2:24 PM
spatel added inline comments.Aug 12 2018, 2:47 PM
lib/Analysis/ValueTracking.cpp
2921–2923

Remove stale comment.

2933–2937

Why are these not the same as fdiv/frem? I think we need to account for inf math that produces nan with these operators:
inf + -inf = nan
inf - inf = nan
0.0 * inf = nan

arsenm updated this revision to Diff 161259.Aug 17 2018, 8:21 AM

Don't handle fadd etc.

spatel added a comment.Aug 17 2018, 1:39 PM

Please add the tests with baseline CHECKs as a preliminary commit, then rebase this.

arsenm updated this revision to Diff 161341.Aug 17 2018, 2:59 PM
spatel added inline comments.Aug 19 2018, 10:46 AM
lib/Analysis/ValueTracking.cpp
2921–2923

Comment is still here. Also, we should have tests for sitofp/uitofp.

arsenm added inline comments.Aug 19 2018, 11:11 AM
lib/Analysis/ValueTracking.cpp
2921–2923

The tests are there for sitofp/uitofp, just apparently somehow the fcmp ord was already optimizing away before

arsenm added inline comments.Aug 19 2018, 11:47 PM
lib/Analysis/ValueTracking.cpp
2921–2923

It looks like foldFCmpIntToFPConst specifically handles the case of these with an fcmp ord

spatel accepted this revision.Aug 20 2018, 5:17 AM

LGTM

lib/Analysis/ValueTracking.cpp
2921–2923

Ah, I see. Sorry, I didn't see the existing tests. We can test this patch more directly and improve efficiency with a small edit in instsimplify, but that can be a follow-up. Please do remove or edit the TODO comment here if there are planned improvements.

This revision is now accepted and ready to land.Aug 20 2018, 5:17 AM
arsenm closed this revision.Aug 20 2018, 9:51 AM

r340187

spatel mentioned this in rL340276: [InstSimplify] add tests for FP uno/ord with nnan; NFC.Aug 21 2018, 6:34 AM
spatel mentioned this in rL340279: [InstSimplify] use isKnownNeverNaN to fold more fcmp ord/uno.Aug 21 2018, 7:46 AM

Revision Contents

PathSize
lib/
Analysis/
27 lines
test/
Transforms/
InstCombine/
208 lines

Diff 160179

lib/Analysis/ValueTracking.cpp

Show First 20 Lines • Show All 2,912 Lines • ▼ Show 20 Linesbool llvm::isKnownNeverNaN(const Value *V, const TargetLibraryInfo *TLI,
unsigned Depth) { unsigned Depth) {
assert(V->getType()->isFPOrFPVectorTy() && "Querying for NaN on non-FP type"); assert(V->getType()->isFPOrFPVectorTy() && "Querying for NaN on non-FP type");
// If we're told that NaNs won't happen, assume they won't. // If we're told that NaNs won't happen, assume they won't.
if (auto *FPMathOp = dyn_cast<FPMathOperator>(V)) if (auto *FPMathOp = dyn_cast<FPMathOperator>(V))
if (FPMathOp->hasNoNaNs()) if (FPMathOp->hasNoNaNs())
return true; return true;
// TODO: Handle instructions and potentially recurse like other 'isKnown' // TODO: Handle instructions and potentially recurse like other 'isKnown'
// functions. For example, the result of sitofp is never NaN. // functions. For example, the result of sitofp is never NaN.
spatelUnsubmitted
Not Done
ReplyInline Actions

Remove stale comment.

spatel: Remove stale comment.
spatelUnsubmitted
Not Done
ReplyInline Actions

Comment is still here. Also, we should have tests for sitofp/uitofp.

spatel: Comment is still here. Also, we should have tests for sitofp/uitofp.
arsenmAuthorUnsubmitted
Not Done
ReplyInline Actions

The tests are there for sitofp/uitofp, just apparently somehow the fcmp ord was already optimizing away before

arsenm: The tests are there for sitofp/uitofp, just apparently somehow the fcmp ord was already…
arsenmAuthorUnsubmitted
Not Done
ReplyInline Actions

It looks like foldFCmpIntToFPConst specifically handles the case of these with an fcmp ord

arsenm: It looks like foldFCmpIntToFPConst specifically handles the case of these with an fcmp ord
spatelUnsubmitted
Not Done
ReplyInline Actions

Ah, I see. Sorry, I didn't see the existing tests. We can test this patch more directly and improve efficiency with a small edit in instsimplify, but that can be a follow-up. Please do remove or edit the TODO comment here if there are planned improvements.

spatel: Ah, I see. Sorry, I didn't see the existing tests. We can test this patch more directly and…
// Handle scalar constants. // Handle scalar constants.
if (auto *CFP = dyn_cast<ConstantFP>(V)) if (auto *CFP = dyn_cast<ConstantFP>(V))
return !CFP->isNaN(); return !CFP->isNaN();
if (Depth == MaxDepth) if (Depth == MaxDepth)
return false; return false;
if (auto *Inst = dyn_cast<Instruction>(V)) {
switch (Inst->getOpcode()) {
case Instruction::FAdd:
case Instruction::FMul:
case Instruction::FSub: {
return isKnownNeverNaN(Inst->getOperand(0), TLI, Depth + 1) &&
isKnownNeverNaN(Inst->getOperand(1), TLI, Depth + 1);
spatelUnsubmitted
Not Done
ReplyInline Actions

Why are these not the same as fdiv/frem? I think we need to account for inf math that produces nan with these operators:
inf + -inf = nan
inf - inf = nan
0.0 * inf = nan

spatel: Why are these not the same as fdiv/frem? I think we need to account for inf math that produces…
}
case Instruction::Select: {
return isKnownNeverNaN(Inst->getOperand(1), TLI, Depth + 1) &&
isKnownNeverNaN(Inst->getOperand(2), TLI, Depth + 1);
}
case Instruction::SIToFP:
case Instruction::UIToFP:
return true;
case Instruction::FPTrunc:
case Instruction::FPExt:
return isKnownNeverNaN(Inst->getOperand(0), TLI, Depth + 1);
case Instruction::FDiv:
case Instruction::FRem:
// TODO: Need isKnownNeverInfinity
return false;
default:
break;
}
}
if (const auto *II = dyn_cast<IntrinsicInst>(V)) { if (const auto *II = dyn_cast<IntrinsicInst>(V)) {
switch (II->getIntrinsicID()) { switch (II->getIntrinsicID()) {
case Intrinsic::canonicalize: case Intrinsic::canonicalize:
case Intrinsic::fabs: case Intrinsic::fabs:
case Intrinsic::copysign: case Intrinsic::copysign:
return isKnownNeverNaN(II->getArgOperand(0), TLI, Depth + 1); return isKnownNeverNaN(II->getArgOperand(0), TLI, Depth + 1);
case Intrinsic::sqrt: case Intrinsic::sqrt:
return isKnownNeverNaN(II->getArgOperand(0), TLI, Depth + 1) && return isKnownNeverNaN(II->getArgOperand(0), TLI, Depth + 1) &&
▲ Show 20 Lines • Show All 2,239 Lines • Show Last 20 Lines

test/Transforms/InstCombine/known-never-nan.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -instcombine %s | FileCheck %s ; RUN: opt -S -instcombine %s | FileCheck %s
declare double @func()
define i1 @nnan_call() {
; CHECK-LABEL: @nnan_call(
; CHECK-NEXT: [[OP:%.*]] = call nnan double @func()
; CHECK-NEXT: ret i1 true
;
%op = call nnan double @func()
%tmp = fcmp ord double %op, %op
ret i1 %tmp
}
define i1 @nnan_fabs_src(double %arg) { define i1 @nnan_fabs_src(double %arg) {
; CHECK-LABEL: @nnan_fabs_src( ; CHECK-LABEL: @nnan_fabs_src(
; CHECK-NEXT: ret i1 true ; CHECK-NEXT: ret i1 true
; ;
%nnan = fadd nnan double %arg, 1.0 %nnan = fadd nnan double %arg, 1.0
%op = call double @llvm.fabs.f64(double %nnan) %op = call double @llvm.fabs.f64(double %nnan)
%tmp = fcmp ord double %op, %op %tmp = fcmp ord double %op, %op
ret i1 %tmp ret i1 %tmp
Show All 38 Lines
; CHECK-NEXT: ret i1 [[TMP]] ; CHECK-NEXT: ret i1 [[TMP]]
; ;
%fabs = call double @llvm.fabs.f64(double %arg0) %fabs = call double @llvm.fabs.f64(double %arg0)
%op = call double @llvm.sqrt.f64(double %fabs) %op = call double @llvm.sqrt.f64(double %fabs)
%tmp = fcmp ord double %op, %op %tmp = fcmp ord double %op, %op
ret i1 %tmp ret i1 %tmp
} }
define i1 @known_nan_select(i1 %cond, double %arg0, double %arg1) {
; CHECK-LABEL: @known_nan_select(
; CHECK-NEXT: ret i1 true
;
%lhs = fadd nnan double %arg0, 1.0
%rhs = fadd nnan double %arg1, 2.0
%op = select i1 %cond, double %lhs, double %rhs
%tmp = fcmp ord double %op, %op
ret i1 %tmp
}
define i1 @select_maybe_nan_lhs(i1 %cond, double %lhs, double %arg1) {
; CHECK-LABEL: @select_maybe_nan_lhs(
; CHECK-NEXT: [[RHS:%.*]] = fadd nnan double [[ARG1:%.*]], 1.000000e+00
; CHECK-NEXT: [[OP:%.*]] = select i1 [[COND:%.*]], double [[LHS:%.*]], double [[RHS]]
; CHECK-NEXT: [[TMP:%.*]] = fcmp ord double [[OP]], 0.000000e+00
; CHECK-NEXT: ret i1 [[TMP]]
;
%rhs = fadd nnan double %arg1, 1.0
%op = select i1 %cond, double %lhs, double %rhs
%tmp = fcmp ord double %op, %op
ret i1 %tmp
}
define i1 @select_maybe_nan_rhs(i1 %cond, double %arg0, double %rhs) {
; CHECK-LABEL: @select_maybe_nan_rhs(
; CHECK-NEXT: [[LHS:%.*]] = fadd nnan double [[ARG0:%.*]], 1.000000e+00
; CHECK-NEXT: [[OP:%.*]] = select i1 [[COND:%.*]], double [[LHS]], double [[RHS:%.*]]
; CHECK-NEXT: [[TMP:%.*]] = fcmp ord double [[OP]], 0.000000e+00
; CHECK-NEXT: ret i1 [[TMP]]
;
%lhs = fadd nnan double %arg0, 1.0
%op = select i1 %cond, double %lhs, double %rhs
%tmp = fcmp ord double %op, %op
ret i1 %tmp
}
define i1 @nnan_fadd(double %arg0, double %arg1) {
; CHECK-LABEL: @nnan_fadd(
; CHECK-NEXT: ret i1 true
;
%nnan.arg0 = fadd nnan double %arg0, 1.0
%nnan.arg1 = fadd nnan double %arg0, 2.0
%op = fadd double %nnan.arg0, %nnan.arg1
%tmp = fcmp ord double %op, %op
ret i1 %tmp
}
define i1 @nnan_fadd_maybe_nan_lhs(double %arg0, double %arg1) {
; CHECK-LABEL: @nnan_fadd_maybe_nan_lhs(
; CHECK-NEXT: [[NNAN_ARG1:%.*]] = fadd nnan double [[ARG1:%.*]], 1.000000e+00
; CHECK-NEXT: [[OP:%.*]] = fadd double [[NNAN_ARG1]], [[ARG0:%.*]]
; CHECK-NEXT: [[TMP:%.*]] = fcmp ord double [[OP]], 0.000000e+00
; CHECK-NEXT: ret i1 [[TMP]]
;
%nnan.arg1 = fadd nnan double %arg1, 1.0
%op = fadd double %arg0, %nnan.arg1
%tmp = fcmp ord double %op, %op
ret i1 %tmp
}
define i1 @nnan_fadd_maybe_nan_rhs(double %arg0, double %arg1) {
; CHECK-LABEL: @nnan_fadd_maybe_nan_rhs(
; CHECK-NEXT: [[NNAN_ARG0:%.*]] = fadd nnan double [[ARG0:%.*]], 1.000000e+00
; CHECK-NEXT: [[OP:%.*]] = fadd double [[NNAN_ARG0]], [[ARG1:%.*]]
; CHECK-NEXT: [[TMP:%.*]] = fcmp ord double [[OP]], 0.000000e+00
; CHECK-NEXT: ret i1 [[TMP]]
;
%nnan.arg0 = fadd nnan double %arg0, 1.0
%op = fadd double %nnan.arg0, %arg1
%tmp = fcmp ord double %op, %op
ret i1 %tmp
}
define i1 @nnan_fmul(double %arg0, double %arg1) {
; CHECK-LABEL: @nnan_fmul(
; CHECK-NEXT: ret i1 true
;
%nnan.arg0 = fadd nnan double %arg0, 1.0
%nnan.arg1 = fadd nnan double %arg0, 2.0
%op = fmul double %nnan.arg0, %nnan.arg1
%tmp = fcmp ord double %op, %op
ret i1 %tmp
}
define i1 @nnan_fsub(double %arg0, double %arg1) {
; CHECK-LABEL: @nnan_fsub(
; CHECK-NEXT: ret i1 true
;
%nnan.arg0 = fadd nnan double %arg0, 1.0
%nnan.arg1 = fadd nnan double %arg0, 2.0
%op = fsub double %nnan.arg0, %nnan.arg1
%tmp = fcmp ord double %op, %op
ret i1 %tmp
}
define i1 @nnan_fneg() {
; CHECK-LABEL: @nnan_fneg(
; CHECK-NEXT: [[NNAN:%.*]] = call nnan double @func()
; CHECK-NEXT: ret i1 true
;
%nnan = call nnan double @func()
%op = fsub double -0.0, %nnan
%tmp = fcmp ord double %op, %op
ret i1 %tmp
}
define i1 @sitofp(i32 %arg0) {
; CHECK-LABEL: @sitofp(
; CHECK-NEXT: ret i1 true
;
%op = sitofp i32 %arg0 to double
%tmp = fcmp ord double %op, %op
ret i1 %tmp
}
define i1 @uitofp(i32 %arg0) {
; CHECK-LABEL: @uitofp(
; CHECK-NEXT: ret i1 true
;
%op = uitofp i32 %arg0 to double
%tmp = fcmp ord double %op, %op
ret i1 %tmp
}
define i1 @fpext(float %arg0) {
; CHECK-LABEL: @fpext(
; CHECK-NEXT: ret i1 true
;
%arg0.nnan = fadd nnan float %arg0, 1.0
%op = fpext float %arg0.nnan to double
%tmp = fcmp ord double %op, %op
ret i1 %tmp
}
define i1 @fpext_maybe_nan(float %arg0) {
; CHECK-LABEL: @fpext_maybe_nan(
; CHECK-NEXT: [[TMP:%.*]] = fcmp ord float [[ARG0:%.*]], 0.000000e+00
; CHECK-NEXT: ret i1 [[TMP]]
;
%op = fpext float %arg0 to double
%tmp = fcmp ord double %op, %op
ret i1 %tmp
}
define i1 @fptrunc(double %arg0) {
; CHECK-LABEL: @fptrunc(
; CHECK-NEXT: ret i1 true
;
%arg0.nnan = fadd nnan double %arg0, 1.0
%op = fptrunc double %arg0.nnan to float
%tmp = fcmp ord float %op, %op
ret i1 %tmp
}
define i1 @fptrunc_maybe_nan(double %arg0) {
; CHECK-LABEL: @fptrunc_maybe_nan(
; CHECK-NEXT: [[OP:%.*]] = fptrunc double [[ARG0:%.*]] to float
; CHECK-NEXT: [[TMP:%.*]] = fcmp ord float [[OP]], 0.000000e+00
; CHECK-NEXT: ret i1 [[TMP]]
;
%op = fptrunc double %arg0 to float
%tmp = fcmp ord float %op, %op
ret i1 %tmp
}
define i1 @nnan_fdiv(double %arg0, double %arg1) {
; CHECK-LABEL: @nnan_fdiv(
; CHECK-NEXT: [[NNAN_ARG0:%.*]] = fadd nnan double [[ARG0:%.*]], 1.000000e+00
; CHECK-NEXT: [[NNAN_ARG1:%.*]] = fadd nnan double [[ARG0]], 2.000000e+00
; CHECK-NEXT: [[OP:%.*]] = fdiv double [[NNAN_ARG0]], [[NNAN_ARG1]]
; CHECK-NEXT: [[TMP:%.*]] = fcmp ord double [[OP]], 0.000000e+00
; CHECK-NEXT: ret i1 [[TMP]]
;
%nnan.arg0 = fadd nnan double %arg0, 1.0
%nnan.arg1 = fadd nnan double %arg0, 2.0
%op = fdiv double %nnan.arg0, %nnan.arg1
%tmp = fcmp ord double %op, %op
ret i1 %tmp
}
define i1 @nnan_frem(double %arg0, double %arg1) {
; CHECK-LABEL: @nnan_frem(
; CHECK-NEXT: [[NNAN_ARG0:%.*]] = fadd nnan double [[ARG0:%.*]], 1.000000e+00
; CHECK-NEXT: [[NNAN_ARG1:%.*]] = fadd nnan double [[ARG0]], 2.000000e+00
; CHECK-NEXT: [[OP:%.*]] = frem double [[NNAN_ARG0]], [[NNAN_ARG1]]
; CHECK-NEXT: [[TMP:%.*]] = fcmp ord double [[OP]], 0.000000e+00
; CHECK-NEXT: ret i1 [[TMP]]
;
%nnan.arg0 = fadd nnan double %arg0, 1.0
%nnan.arg1 = fadd nnan double %arg0, 2.0
%op = frem double %nnan.arg0, %nnan.arg1
%tmp = fcmp ord double %op, %op
ret i1 %tmp
}
declare double @llvm.sqrt.f64(double) declare double @llvm.sqrt.f64(double)
declare double @llvm.fabs.f64(double) declare double @llvm.fabs.f64(double)
declare double @llvm.canonicalize.f64(double) declare double @llvm.canonicalize.f64(double)
declare double @llvm.copysign.f64(double, double) declare double @llvm.copysign.f64(double, double)