llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-llvm-transforms Author: Matt Arsenault (arsenm) <details> <summary>Changes</summary> Teach SimplifyDemandedFPClass to do this, although this is not yet applied directly to the cast. --- Patch is 27.46 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/177769.diff 3 Files Affected: - (modified) llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp (+11-11) - (modified) llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-fptrunc-round.ll (+31-21) - (modified) llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-fptrunc.ll (+19-19) ``````````diff diff --git a/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp b/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp index de05e3b73f519..9ed68073cf518 100644 --- a/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp +++ b/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp @@ -2204,11 +2204,11 @@ simplifyDemandedFPClassMinMax(KnownFPClass &Known, Intrinsic::ID IID, /*IsCanonicalizing=*/true); } -static Value *simplifyDemandedUseFPClassFPTrunc(InstCombinerImpl &IC, - Instruction &I, - FPClassTest DemandedMask, - KnownFPClass &Known, - unsigned Depth) { +static Value * +simplifyDemandedUseFPClassFPTrunc(InstCombinerImpl &IC, Instruction &I, + FastMathFlags FMF, FPClassTest DemandedMask, + KnownFPClass &Known, unsigned Depth) { + FPClassTest SrcDemandedMask = DemandedMask; // Zero results may have been rounded from subnormal or normal sources. @@ -2235,8 +2235,8 @@ static Value *simplifyDemandedUseFPClassFPTrunc(InstCombinerImpl &IC, Known = KnownFPClass::fptrunc(KnownSrc); Known.knownNot(~DemandedMask); - return getFPClassConstant(I.getType(), Known.KnownFPClasses, - /*IsCanonicalizing=*/true); + return simplifyDemandedFPClassResult(&I, FMF, DemandedMask, Known, + {KnownSrc}); } Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I, @@ -2639,8 +2639,8 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I, return nullptr; } case Instruction::FPTrunc: - return simplifyDemandedUseFPClassFPTrunc(*this, *I, DemandedMask, Known, - Depth); + return simplifyDemandedUseFPClassFPTrunc(*this, *I, FMF, DemandedMask, + Known, Depth); case Instruction::FPExt: { FPClassTest SrcDemandedMask = DemandedMask; @@ -3074,8 +3074,8 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I, return nullptr; } case Intrinsic::fptrunc_round: - return simplifyDemandedUseFPClassFPTrunc(*this, *CI, DemandedMask, Known, - Depth); + return simplifyDemandedUseFPClassFPTrunc(*this, *CI, FMF, DemandedMask, + Known, Depth); case Intrinsic::canonicalize: { Type *EltTy = VTy->getScalarType(); diff --git a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-fptrunc-round.ll b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-fptrunc-round.ll index c32196503344f..7ec16b0d9dc96 100644 --- a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-fptrunc-round.ll +++ b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-fptrunc-round.ll @@ -30,7 +30,7 @@ declare nofpclass(nan inf pnorm sub zero) float @returns_nnorm_f32() define nofpclass(inf norm sub zero qnan) half @ret_only_snan__fptrunc(float %x) { ; CHECK-LABEL: define nofpclass(qnan inf zero sub norm) half @ret_only_snan__fptrunc( ; CHECK-SAME: float [[X:%.*]]) { -; CHECK-NEXT: [[RESULT:%.*]] = call half @llvm.fptrunc.round.f16.f32(float [[X]], metadata !"round.downward") +; CHECK-NEXT: [[RESULT:%.*]] = call ninf half @llvm.fptrunc.round.f16.f32(float [[X]], metadata !"round.downward") ; CHECK-NEXT: ret half [[RESULT]] ; %result = call half @llvm.fptrunc.round.f16.f32(float %x, metadata !"round.downward") @@ -58,7 +58,7 @@ define nofpclass(inf norm sub zero) half @ret_only_nan__fptrunc(float %x) { define nofpclass(nan norm sub zero) half @ret_only_inf__fptrunc(float %x) { ; CHECK-LABEL: define nofpclass(nan zero sub norm) half @ret_only_inf__fptrunc( ; CHECK-SAME: float [[X:%.*]]) { -; CHECK-NEXT: [[RESULT:%.*]] = call half @llvm.fptrunc.round.f16.f32(float [[X]], metadata !"round.downward") +; CHECK-NEXT: [[RESULT:%.*]] = call nnan half @llvm.fptrunc.round.f16.f32(float [[X]], metadata !"round.downward") ; CHECK-NEXT: ret half [[RESULT]] ; %result = call half @llvm.fptrunc.round.f16.f32(float %x, metadata !"round.downward") @@ -86,7 +86,7 @@ define nofpclass(nan ninf norm sub zero) half @ret_only_pinf__fptrunc(float %x) define nofpclass(inf nan norm sub) half @ret_only_zero__fptrunc(float %x) { ; CHECK-LABEL: define nofpclass(nan inf sub norm) half @ret_only_zero__fptrunc( ; CHECK-SAME: float [[X:%.*]]) { -; CHECK-NEXT: [[RESULT:%.*]] = call half @llvm.fptrunc.round.f16.f32(float [[X]], metadata !"round.downward") +; CHECK-NEXT: [[RESULT:%.*]] = call nnan ninf half @llvm.fptrunc.round.f16.f32(float [[X]], metadata !"round.downward") ; CHECK-NEXT: ret half [[RESULT]] ; %result = call half @llvm.fptrunc.round.f16.f32(float %x, metadata !"round.downward") @@ -116,7 +116,7 @@ define nofpclass(nan) half @ret_no_nan__fptrunc__select_nan_or_unknown(i1 %cond, ; CHECK-LABEL: define nofpclass(nan) half @ret_no_nan__fptrunc__select_nan_or_unknown( ; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN:%.*]]) { ; CHECK-NEXT: [[NAN:%.*]] = call float @returns_nan_f32() -; CHECK-NEXT: [[RESULT:%.*]] = call half @llvm.fptrunc.round.f16.f32(float [[UNKNOWN]], metadata !"round.downward") +; CHECK-NEXT: [[RESULT:%.*]] = call nnan half @llvm.fptrunc.round.f16.f32(float [[UNKNOWN]], metadata !"round.downward") ; CHECK-NEXT: ret half [[RESULT]] ; %nan = call float @returns_nan_f32() @@ -158,7 +158,7 @@ define nofpclass(inf) half @ret_no_inf__fptrunc__select_inf_or_unknown(i1 %cond, ; CHECK-LABEL: define nofpclass(inf) half @ret_no_inf__fptrunc__select_inf_or_unknown( ; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN:%.*]]) { ; CHECK-NEXT: [[INF:%.*]] = call float @returns_inf_f32() -; CHECK-NEXT: [[RESULT:%.*]] = call half @llvm.fptrunc.round.f16.f32(float [[UNKNOWN]], metadata !"round.downward") +; CHECK-NEXT: [[RESULT:%.*]] = call ninf half @llvm.fptrunc.round.f16.f32(float [[UNKNOWN]], metadata !"round.downward") ; CHECK-NEXT: ret half [[RESULT]] ; %inf = call float @returns_inf_f32() @@ -172,7 +172,7 @@ define nofpclass(nan inf) half @ret_no_inf_no_nan__fptrunc__select_inf_or_nan_or ; CHECK-LABEL: define nofpclass(nan inf) half @ret_no_inf_no_nan__fptrunc__select_inf_or_nan_or_unknown( ; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN:%.*]]) { ; CHECK-NEXT: [[INF_OR_NAN:%.*]] = call float @returns_inf_or_nan_f32() -; CHECK-NEXT: [[RESULT:%.*]] = call half @llvm.fptrunc.round.f16.f32(float [[UNKNOWN]], metadata !"round.downward") +; CHECK-NEXT: [[RESULT:%.*]] = call nnan ninf half @llvm.fptrunc.round.f16.f32(float [[UNKNOWN]], metadata !"round.downward") ; CHECK-NEXT: ret half [[RESULT]] ; %inf.or.nan = call float @returns_inf_or_nan_f32() @@ -257,7 +257,7 @@ define nofpclass(nan pinf pnorm psub pzero) half @ret_no_positive_no_nan__fptrun ; CHECK-LABEL: define nofpclass(nan pinf pzero psub pnorm) half @ret_no_positive_no_nan__fptrunc__select_positive_nan_or_unknown( ; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN:%.*]]) { ; CHECK-NEXT: [[POSITIVE_OR_NAN:%.*]] = call float @returns_positive_or_nan_f32() -; CHECK-NEXT: [[RESULT:%.*]] = call half @llvm.fptrunc.round.f16.f32(float [[UNKNOWN]], metadata !"round.downward") +; CHECK-NEXT: [[RESULT:%.*]] = call nnan half @llvm.fptrunc.round.f16.f32(float [[UNKNOWN]], metadata !"round.downward") ; CHECK-NEXT: ret half [[RESULT]] ; %positive.or.nan = call float @returns_positive_or_nan_f32() @@ -300,7 +300,7 @@ define nofpclass(nan ninf nnorm nsub nzero) half @ret_no_negative_no_nan__fptrun ; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) half @ret_no_negative_no_nan__fptrunc__select_negative_nan_or_unknown( ; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN:%.*]]) { ; CHECK-NEXT: [[NEGATIVE_OR_NAN:%.*]] = call float @returns_negative_or_nan_f32() -; CHECK-NEXT: [[RESULT:%.*]] = call half @llvm.fptrunc.round.f16.f32(float [[UNKNOWN]], metadata !"round.downward") +; CHECK-NEXT: [[RESULT:%.*]] = call nnan half @llvm.fptrunc.round.f16.f32(float [[UNKNOWN]], metadata !"round.downward") ; CHECK-NEXT: ret half [[RESULT]] ; %negative.or.nan = call float @returns_negative_or_nan_f32() @@ -312,7 +312,7 @@ define nofpclass(nan ninf nnorm nsub nzero) half @ret_no_negative_no_nan__fptrun define nofpclass(snan) half @ret_no_snan__fptrunc__always_zero() { ; CHECK-LABEL: define nofpclass(snan) half @ret_no_snan__fptrunc__always_zero() { ; CHECK-NEXT: [[ZERO:%.*]] = call float @returns_zero_f32() -; CHECK-NEXT: [[RESULT:%.*]] = call half @llvm.fptrunc.round.f16.f32(float [[ZERO]], metadata !"round.downward") +; CHECK-NEXT: [[RESULT:%.*]] = call nnan half @llvm.fptrunc.round.f16.f32(float [[ZERO]], metadata !"round.downward") ; CHECK-NEXT: ret half [[RESULT]] ; %zero = call float @returns_zero_f32() @@ -334,7 +334,7 @@ define nofpclass(snan) half @ret_no_snan__fptrunc__always_zero_or_nan() { define nofpclass(snan) half @ret_no_snan__fptrunc__always_inf() { ; CHECK-LABEL: define nofpclass(snan) half @ret_no_snan__fptrunc__always_inf() { ; CHECK-NEXT: [[INF:%.*]] = call float @returns_inf_f32() -; CHECK-NEXT: [[RESULT:%.*]] = call half @llvm.fptrunc.round.f16.f32(float [[INF]], metadata !"round.downward") +; CHECK-NEXT: [[RESULT:%.*]] = call nnan half @llvm.fptrunc.round.f16.f32(float [[INF]], metadata !"round.downward") ; CHECK-NEXT: ret half [[RESULT]] ; %inf = call float @returns_inf_f32() @@ -356,7 +356,7 @@ define nofpclass(snan) half @ret_no_snan__fptrunc__always_inf_or_nan() { define nofpclass(inf nan norm zero) half @ret_only_sub__fptrunc(float %x) { ; CHECK-LABEL: define nofpclass(nan inf zero norm) half @ret_only_sub__fptrunc( ; CHECK-SAME: float [[X:%.*]]) { -; CHECK-NEXT: [[RESULT:%.*]] = call half @llvm.fptrunc.round.f16.f32(float [[X]], metadata !"round.downward") +; CHECK-NEXT: [[RESULT:%.*]] = call nnan ninf half @llvm.fptrunc.round.f16.f32(float [[X]], metadata !"round.downward") ; CHECK-NEXT: ret half [[RESULT]] ; %result = call half @llvm.fptrunc.round.f16.f32(float %x, metadata !"round.downward") @@ -366,7 +366,7 @@ define nofpclass(inf nan norm zero) half @ret_only_sub__fptrunc(float %x) { define nofpclass(inf nan norm zero nsub) half @ret_only_psub__fptrunc(float %x) { ; CHECK-LABEL: define nofpclass(nan inf zero nsub norm) half @ret_only_psub__fptrunc( ; CHECK-SAME: float [[X:%.*]]) { -; CHECK-NEXT: [[RESULT:%.*]] = call half @llvm.fptrunc.round.f16.f32(float [[X]], metadata !"round.downward") +; CHECK-NEXT: [[RESULT:%.*]] = call nnan ninf half @llvm.fptrunc.round.f16.f32(float [[X]], metadata !"round.downward") ; CHECK-NEXT: ret half [[RESULT]] ; %result = call half @llvm.fptrunc.round.f16.f32(float %x, metadata !"round.downward") @@ -376,7 +376,7 @@ define nofpclass(inf nan norm zero nsub) half @ret_only_psub__fptrunc(float %x) define nofpclass(inf nan norm zero psub) half @ret_only_nsub__fptrunc(float %x) { ; CHECK-LABEL: define nofpclass(nan inf zero psub norm) half @ret_only_nsub__fptrunc( ; CHECK-SAME: float [[X:%.*]]) { -; CHECK-NEXT: [[RESULT:%.*]] = call half @llvm.fptrunc.round.f16.f32(float [[X]], metadata !"round.downward") +; CHECK-NEXT: [[RESULT:%.*]] = call nnan ninf half @llvm.fptrunc.round.f16.f32(float [[X]], metadata !"round.downward") ; CHECK-NEXT: ret half [[RESULT]] ; %result = call half @llvm.fptrunc.round.f16.f32(float %x, metadata !"round.downward") @@ -386,7 +386,7 @@ define nofpclass(inf nan norm zero psub) half @ret_only_nsub__fptrunc(float %x) define nofpclass(inf nan norm) half @ret_only_sub_zero__fptrunc(float %x) { ; CHECK-LABEL: define nofpclass(nan inf norm) half @ret_only_sub_zero__fptrunc( ; CHECK-SAME: float [[X:%.*]]) { -; CHECK-NEXT: [[RESULT:%.*]] = call half @llvm.fptrunc.round.f16.f32(float [[X]], metadata !"round.downward") +; CHECK-NEXT: [[RESULT:%.*]] = call nnan ninf half @llvm.fptrunc.round.f16.f32(float [[X]], metadata !"round.downward") ; CHECK-NEXT: ret half [[RESULT]] ; %result = call half @llvm.fptrunc.round.f16.f32(float %x, metadata !"round.downward") @@ -396,7 +396,7 @@ define nofpclass(inf nan norm) half @ret_only_sub_zero__fptrunc(float %x) { define nofpclass(inf nan norm nzero nsub) half @ret_only_psub_pzero__fptrunc(float %x) { ; CHECK-LABEL: define nofpclass(nan inf nzero nsub norm) half @ret_only_psub_pzero__fptrunc( ; CHECK-SAME: float [[X:%.*]]) { -; CHECK-NEXT: [[RESULT:%.*]] = call half @llvm.fptrunc.round.f16.f32(float [[X]], metadata !"round.downward") +; CHECK-NEXT: [[RESULT:%.*]] = call nnan ninf half @llvm.fptrunc.round.f16.f32(float [[X]], metadata !"round.downward") ; CHECK-NEXT: ret half [[RESULT]] ; %result = call half @llvm.fptrunc.round.f16.f32(float %x, metadata !"round.downward") @@ -406,7 +406,7 @@ define nofpclass(inf nan norm nzero nsub) half @ret_only_psub_pzero__fptrunc(flo define nofpclass(inf nan norm pzero psub) half @ret_only_nsub_nzero__fptrunc(float %x) { ; CHECK-LABEL: define nofpclass(nan inf pzero psub norm) half @ret_only_nsub_nzero__fptrunc( ; CHECK-SAME: float [[X:%.*]]) { -; CHECK-NEXT: [[RESULT:%.*]] = call half @llvm.fptrunc.round.f16.f32(float [[X]], metadata !"round.downward") +; CHECK-NEXT: [[RESULT:%.*]] = call nnan ninf half @llvm.fptrunc.round.f16.f32(float [[X]], metadata !"round.downward") ; CHECK-NEXT: ret half [[RESULT]] ; %result = call half @llvm.fptrunc.round.f16.f32(float %x, metadata !"round.downward") @@ -417,7 +417,7 @@ define nofpclass(inf nan norm pzero psub) half @ret_only_nsub_nzero__fptrunc(flo define nofpclass(ninf) half @ret_no_ninf__fptrunc__inf() { ; CHECK-LABEL: define nofpclass(ninf) half @ret_no_ninf__fptrunc__inf() { ; CHECK-NEXT: [[INF:%.*]] = call float @returns_inf_f32() -; CHECK-NEXT: [[RESULT:%.*]] = call half @llvm.fptrunc.round.f16.f32(float 0x7FF0000000000000, metadata !"round.downward") +; CHECK-NEXT: [[RESULT:%.*]] = call nnan half @llvm.fptrunc.round.f16.f32(float 0x7FF0000000000000, metadata !"round.downward") ; CHECK-NEXT: ret half [[RESULT]] ; %inf = call float @returns_inf_f32() @@ -429,7 +429,7 @@ define nofpclass(ninf) half @ret_no_ninf__fptrunc__inf() { define nofpclass(pinf) half @ret_no_pinf__fptrunc__inf() { ; CHECK-LABEL: define nofpclass(pinf) half @ret_no_pinf__fptrunc__inf() { ; CHECK-NEXT: [[INF:%.*]] = call float @returns_inf_f32() -; CHECK-NEXT: [[RESULT:%.*]] = call half @llvm.fptrunc.round.f16.f32(float 0xFFF0000000000000, metadata !"round.downward") +; CHECK-NEXT: [[RESULT:%.*]] = call nnan half @llvm.fptrunc.round.f16.f32(float 0xFFF0000000000000, metadata !"round.downward") ; CHECK-NEXT: ret half [[RESULT]] ; %inf = call float @returns_inf_f32() @@ -569,7 +569,7 @@ define nofpclass(inf norm sub nzero) half @pzero_demands_pnorm_source(i1 %cond, ; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN:%.*]]) { ; CHECK-NEXT: [[PNORM:%.*]] = call float @returns_pnorm_f32() ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], float [[PNORM]], float [[UNKNOWN]] -; CHECK-NEXT: [[RESULT:%.*]] = call half @llvm.fptrunc.round.f16.f32(float [[SELECT]], metadata !"round.downward") +; CHECK-NEXT: [[RESULT:%.*]] = call ninf half @llvm.fptrunc.round.f16.f32(float [[SELECT]], metadata !"round.downward") ; CHECK-NEXT: ret half [[RESULT]] ; %pnorm = call float @returns_pnorm_f32() @@ -584,7 +584,7 @@ define nofpclass(inf norm sub pzero) half @nzero_demands_pnorm_source(i1 %cond, ; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN:%.*]]) { ; CHECK-NEXT: [[NNORM:%.*]] = call float @returns_nnorm_f32() ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], float [[NNORM]], float [[UNKNOWN]] -; CHECK-NEXT: [[RESULT:%.*]] = call half @llvm.fptrunc.round.f16.f32(float [[SELECT]], metadata !"round.downward") +; CHECK-NEXT: [[RESULT:%.*]] = call ninf half @llvm.fptrunc.round.f16.f32(float [[SELECT]], metadata !"round.downward") ; CHECK-NEXT: ret half [[RESULT]] ; %nnorm = call float @returns_nnorm_f32() @@ -599,7 +599,7 @@ define nofpclass(inf norm sub) half @zero_demands_norm_source(i1 %cond, float %u ; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN:%.*]]) { ; CHECK-NEXT: [[NORM:%.*]] = call float @returns_norm_f32() ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], float [[NORM]], float [[UNKNOWN]] -; CHECK-NEXT: [[RESULT:%.*]] = call half @llvm.fptrunc.round.f16.f32(float [[SELECT]], metadata !"round.downward") +; CHECK-NEXT: [[RESULT:%.*]] = call ninf half @llvm.fptrunc.round.f16.f32(float [[SELECT]], metadata !"round.downward") ; CHECK-NEXT: ret half [[RESULT]] ; %norm = call float @returns_norm_f32() @@ -607,3 +607,13 @@ define nofpclass(inf norm sub) half @zero_demands_norm_source(i1 %cond, float %u %result = call half @llvm.fptrunc.round.f16.f32(float %select, metadata !"round.downward") ret half %result } + +define nofpclass(nan) half @ret_no_nan__fptrunc_drop_noundef(float %x) { +; CHECK-LABEL: define nofpclass(nan) half @ret_no_nan__fptrunc_drop_noundef( +; CHECK-SAME: float [[X:%.*]]) { +; CHECK-NEXT: [[RESULT:%.*]] = call nnan half @llvm.fptrunc.round.f16.f32(float [[X]], metadata !"round.downward") +; CHECK-NEXT: ret half [[RESULT]] +; + %result = call noundef half @llvm.fptrunc.round.f16.f32(float %x, metadata !"round.downward"), !unknown.md !{} + ret half %result +} diff --git a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-fptrunc.ll b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-fptrunc.ll index eae99c2b5cff8..c06e190728a3f 100644 --- a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-fptrunc.ll +++ b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-fptrunc.ll @@ -30,7 +30,7 @@ declare nofpclass(nan inf pnorm sub zero) float @returns_nnorm_f32() define nofpclass(inf norm sub zero qnan) half @ret_only_snan__fptrunc(float %x) { ; CHECK-LABEL: define nofpclass(qnan inf zero sub norm) half @ret_only_snan__fptrunc( ; CHECK-SAME: float [[X:%.*]]) { -; CHECK-NEXT: [[RESULT:%.*]] = fptrunc float [[X]] to half +; CHECK-NEXT: [[RESULT:%.*]] = fptrunc ninf float [[X]] to half ; CHECK-NEXT: ret half [[RESULT]] ; %result = fptrunc float %x to half @@ -58,7 +58,7 @@ define nofpclass(inf norm sub zero) half @ret_only_nan__fptrunc(float %x) { define nofpclass(nan norm sub zero) half @ret_only_inf__fptrunc(float %x) { ; CHECK-LABEL: define nofpclass(nan zero sub norm) half @ret_only_inf__fptrunc( ; CHECK-SAME: float [[X:%.*]]) { -; CHECK-NEXT: [[RESULT:%.*]] = fptrunc float [[X]] to half +; CHECK-NEXT: [[RESULT:%.*]] = fptrunc nnan float [[X]] to half ; CHECK-NEXT: ret half [[RESULT]] ; %result = fptrunc float %x to half @@ -86,7 +86,7 @@ define nofpclass(nan ninf norm sub zero) half @ret_only_pinf__fptrunc(float %x) define nofpclass(inf nan norm sub) half @ret_only_zero__fptrunc(float %x) { ; CHECK-LABEL: define nofpclass(nan inf sub norm) half @ret_only_zero__fptrunc( ; CHECK-SAME: float [[X:%.*]]) { -; CHECK-NEXT: [[RESULT:%.*]] = fptrunc float [[X]] to half +; CHECK-NEXT: [[RESULT:%.*]] = fptrunc nnan ninf float [[X]] to half ; CHECK-NEXT: ret half [[RESULT]] ; %result = fptrunc float %x to half @@ -116,7 +116,7 @@ define nofpclass(nan) half @ret_no_nan__fptrunc__select_nan_or_unknown(i1 %cond, ; CHECK-LABEL: define nofpclass(nan) half @ret_no_nan__fptrunc__select_nan_or_unknown( ; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN:%.*]]) { ; CHECK-NEXT: [[NAN:%.*]] = call float @returns_nan_f32() -; CHECK-NEXT: [[RESULT:%.*]] = fptrunc float [[UNKNOWN]] to half +; CHECK-NEXT: [[RESULT:%.*]] = fptrunc nnan float [[UNKNOWN]] to half ; CHECK-NEXT: ret half [[RESULT]] ; %nan = call float @returns_nan_f32() @@ -158,7 +158,7 @@ define nofpclass(inf) half @ret_no_inf__fptrunc__select_inf_or_unknown(i1 %cond, ; CHECK-LABEL: define nofpclass(inf) half @ret_no_inf__fptrunc__select_inf_or_unknown( ; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN:%.*]]) { ; CHECK-NEXT: [[INF:%.*]] = call float @returns_inf_f32() -; CHECK-NEXT: [[RESULT:%.*]] = fptrunc float [[UNKNOWN]] to half +; CHECK-NEXT: [[RESULT:%.*]] = fptrunc ninf float [[UNKNOWN]] to half ; CHECK-NEXT: ret half [[RESULT]] ; %inf... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/177769 _______________________________________________ llvm-branch-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
