https://github.com/arsenm updated https://github.com/llvm/llvm-project/pull/175946
>From ada4d3a94bcab2ee8242b7a720288eb428617570 Mon Sep 17 00:00:00 2001 From: Matt Arsenault <[email protected]> Date: Mon, 5 Jan 2026 18:54:13 +0100 Subject: [PATCH] InstCombine: Handle fdiv in SimplifyDemandedFPClass --- llvm/include/llvm/Support/KnownFPClass.h | 10 + llvm/lib/Analysis/ValueTracking.cpp | 36 +-- llvm/lib/Support/KnownFPClass.cpp | 46 +++ .../InstCombineSimplifyDemanded.cpp | 131 ++++++++- .../simplify-demanded-fpclass-fdiv.ll | 275 ++++++++---------- 5 files changed, 316 insertions(+), 182 deletions(-) diff --git a/llvm/include/llvm/Support/KnownFPClass.h b/llvm/include/llvm/Support/KnownFPClass.h index e2b0d20c790a9..bc3f0ff0339d2 100644 --- a/llvm/include/llvm/Support/KnownFPClass.h +++ b/llvm/include/llvm/Support/KnownFPClass.h @@ -237,6 +237,16 @@ struct KnownFPClass { return Known; } + /// Report known values for fdiv + LLVM_ABI static KnownFPClass + fdiv(const KnownFPClass &LHS, const KnownFPClass &RHS, + DenormalMode Mode = DenormalMode::getDynamic()); + + /// Report known values for fdiv + LLVM_ABI static KnownFPClass + fdiv_self(const KnownFPClass &Src, + DenormalMode Mode = DenormalMode::getDynamic()); + /// Report known values for exp, exp2 and exp10. LLVM_ABI static KnownFPClass exp(const KnownFPClass &Src); diff --git a/llvm/lib/Analysis/ValueTracking.cpp b/llvm/lib/Analysis/ValueTracking.cpp index ece8425aef698..1f33fb4571f2a 100644 --- a/llvm/lib/Analysis/ValueTracking.cpp +++ b/llvm/lib/Analysis/ValueTracking.cpp @@ -5712,39 +5712,9 @@ void computeKnownFPClass(const Value *V, const APInt &DemandedElts, Op->getType()->getScalarType()->getFltSemantics(); if (Op->getOpcode() == Instruction::FDiv) { - // Only 0/0, Inf/Inf produce NaN. - if (KnownLHS.isKnownNeverNaN() && KnownRHS.isKnownNeverNaN() && - (KnownLHS.isKnownNeverInfinity() || - KnownRHS.isKnownNeverInfinity()) && - ((F && - KnownLHS.isKnownNeverLogicalZero(F->getDenormalMode(FltSem))) || - (F && - KnownRHS.isKnownNeverLogicalZero(F->getDenormalMode(FltSem))))) { - Known.knownNot(fcNan); - } - - // xor sign bit. - // X / -0.0 is -Inf (or NaN). - // +X / +X is +X - if ((KnownLHS.isKnownNever(fcNegative) && - KnownRHS.isKnownNever(fcNegative)) || - (KnownLHS.isKnownNever(fcPositive) && - KnownRHS.isKnownNever(fcPositive))) - Known.knownNot(fcNegative); - - if ((KnownLHS.isKnownNever(fcPositive) && - KnownRHS.isKnownNever(fcNegative)) || - (KnownLHS.isKnownNever(fcNegative) && - KnownRHS.isKnownNever(fcPositive))) - Known.knownNot(fcPositive); - - // 0 / x => 0 or nan - if (KnownLHS.isKnownAlways(fcZero)) - Known.knownNot(fcSubnormal | fcNormal | fcInf); - - // x / 0 => nan or inf - if (KnownRHS.isKnownAlways(fcZero)) - Known.knownNot(fcFinite); + DenormalMode Mode = + F ? F->getDenormalMode(FltSem) : DenormalMode::getDynamic(); + Known = KnownFPClass::fdiv(KnownLHS, KnownRHS, Mode); } else { // Inf REM x and x REM 0 produce NaN. if (KnownLHS.isKnownNeverNaN() && KnownRHS.isKnownNeverNaN() && diff --git a/llvm/lib/Support/KnownFPClass.cpp b/llvm/lib/Support/KnownFPClass.cpp index ae8c4a9133897..985f05bb8793b 100644 --- a/llvm/lib/Support/KnownFPClass.cpp +++ b/llvm/lib/Support/KnownFPClass.cpp @@ -332,6 +332,52 @@ KnownFPClass KnownFPClass::fmul(const KnownFPClass &KnownLHS, return Known; } +KnownFPClass KnownFPClass::fdiv(const KnownFPClass &KnownLHS, + const KnownFPClass &KnownRHS, + DenormalMode Mode) { + KnownFPClass Known; + + // Only 0/0, Inf/Inf produce NaN. + if (KnownLHS.isKnownNeverNaN() && KnownRHS.isKnownNeverNaN() && + (KnownLHS.isKnownNeverInfinity() || KnownRHS.isKnownNeverInfinity()) && + (KnownLHS.isKnownNeverLogicalZero(Mode) || + KnownRHS.isKnownNeverLogicalZero(Mode))) { + Known.knownNot(fcNan); + } + + // xor sign bit. + // X / -0.0 is -Inf (or NaN). + // +X / +X is +X + if ((KnownLHS.isKnownNever(fcNegative) && + KnownRHS.isKnownNever(fcNegative)) || + (KnownLHS.isKnownNever(fcPositive) && KnownRHS.isKnownNever(fcPositive))) + Known.knownNot(fcNegative); + + if ((KnownLHS.isKnownNever(fcPositive) && + KnownRHS.isKnownNever(fcNegative)) || + (KnownLHS.isKnownNever(fcNegative) && KnownRHS.isKnownNever(fcPositive))) + Known.knownNot(fcPositive); + + // 0 / x => 0 or nan + if (KnownLHS.isKnownAlways(fcZero)) + Known.knownNot(fcSubnormal | fcNormal | fcInf); + + // x / 0 => nan or inf + if (KnownRHS.isKnownAlways(fcZero)) + Known.knownNot(fcFinite); + + return Known; +} + +KnownFPClass KnownFPClass::fdiv_self(const KnownFPClass &KnownSrc, + DenormalMode Mode) { + // X / X is always exactly 1.0 or a NaN. + KnownFPClass Known(fcNan | fcPosNormal); + + // Known.propagateNaN(KnownSrc); + return Known; +} + KnownFPClass KnownFPClass::exp(const KnownFPClass &KnownSrc) { KnownFPClass Known; Known.knownNot(fcNegative); diff --git a/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp b/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp index 05ed123b8be75..71bb1ac125aae 100644 --- a/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp +++ b/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp @@ -2342,6 +2342,136 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I, return nullptr; } + case Instruction::FDiv: { + Value *X = I->getOperand(0); + Value *Y = I->getOperand(1); + if (X == Y && isGuaranteedNotToBeUndef(X, SQ.AC, CxtI, SQ.DT, Depth + 1)) { + // If the source is 0, inf or nan, the result is a nan + + Value *IsZeroOrNan = Builder.CreateFCmpFMF( + FCmpInst::FCMP_UEQ, I->getOperand(0), ConstantFP::getZero(VTy), FMF); + + Value *Fabs = + Builder.CreateUnaryIntrinsic(Intrinsic::fabs, I->getOperand(0), FMF); + Value *IsInfOrNan = Builder.CreateFCmpFMF( + FCmpInst::FCMP_UEQ, Fabs, ConstantFP::getInfinity(VTy), FMF); + + Value *IsInfOrZeroOrNan = Builder.CreateOr(IsInfOrNan, IsZeroOrNan); + + return Builder.CreateSelectFMF( + IsInfOrZeroOrNan, ConstantFP::getQNaN(VTy), + ConstantFP::get( + VTy, APFloat::getOne(VTy->getScalarType()->getFltSemantics())), + FMF); + } + + Type *EltTy = VTy->getScalarType(); + DenormalMode Mode = F.getDenormalMode(EltTy->getFltSemantics()); + + // Every output class could require denormal inputs (except for the + // degenerate case of only-nan results, without DAZ). + FPClassTest SrcDemandedMask = (DemandedMask & fcNan) | fcSubnormal; + + // Normal inputs may result in underflow. + // x / x = 1.0 for non0/inf/nan + // -x = +y / -z + // -x = -y / +z + if (DemandedMask & (fcSubnormal | fcNormal)) + SrcDemandedMask |= fcNormal; + + if (DemandedMask & fcNan) { + // 0 / 0 = nan + // inf / inf = nan + + // Subnormal is added in case of DAZ, but this isn't strictly + // necessary. Every other input class implies a possible subnormal source, + // so this only could matter in the degenerate case of only-nan results. + SrcDemandedMask |= fcZero | fcInf; + } + + // Zero outputs may be the result of underflow. + if (DemandedMask & fcZero) + SrcDemandedMask |= fcNormal | fcSubnormal; + + FPClassTest LHSDemandedMask = SrcDemandedMask; + FPClassTest RHSDemandedMask = SrcDemandedMask; + + // 0 / inf = 0 + if (DemandedMask & fcZero) { + assert((LHSDemandedMask & fcSubnormal) && + "should not have to worry about daz here"); + LHSDemandedMask |= fcZero; + RHSDemandedMask |= fcInf; + } + + // x / 0 = inf + // large_normal / small_normal = inf + // inf / 1 = inf + // large_normal / subnormal = inf + if (DemandedMask & fcInf) { + LHSDemandedMask |= fcInf | fcNormal | fcSubnormal; + RHSDemandedMask |= fcZero | fcSubnormal | fcNormal; + } + + KnownFPClass KnownLHS, KnownRHS; + if (SimplifyDemandedFPClass(I, 0, LHSDemandedMask, KnownLHS, Depth + 1) || + SimplifyDemandedFPClass(I, 1, RHSDemandedMask, KnownRHS, Depth + 1)) + return I; + + bool ResultNotNan = (DemandedMask & fcNan) == fcNone; + bool ResultNotInf = (DemandedMask & fcInf) == fcNone; + if (ResultNotNan) { + KnownLHS.knownNot(fcNan); + KnownRHS.knownNot(fcNan); + } + + // nsz [+-]0 / x -> 0 + if (FMF.noSignedZeros() && KnownLHS.isKnownAlways(fcZero | fcNan) && + (ResultNotNan || KnownRHS.isKnownNeverNaN())) + return ConstantFP::getZero(VTy); + + if (KnownLHS.isKnownAlways(fcPosZero) && + (ResultNotNan || KnownRHS.isKnownNeverNaN())) { + // nnan +0 / x -> copysign(0, rhs) + // TODO: -0 / x => copysign(0, fneg(rhs)) + Value *Copysign = Builder.CreateCopySign(X, Y, FMF); + Copysign->takeName(I); + return Copysign; + } + + if (!ResultNotInf && + ((ResultNotNan || (KnownLHS.isKnownNeverNaN() && + KnownLHS.isKnownNeverLogicalZero(Mode))) && + (KnownRHS.isKnownAlways(fcPosZero) || + (FMF.noSignedZeros() && KnownRHS.isKnownAlways(fcZero))))) { + // nnan x / 0 => copysign(inf, x); + // nnan nsz x / -0 => copysign(inf, x); + Value *Copysign = + Builder.CreateCopySign(ConstantFP::getInfinity(VTy), X, FMF); + Copysign->takeName(I); + return Copysign; + } + + // nnan ninf X / [-]0.0 -> poison + if (ResultNotNan && ResultNotInf && KnownRHS.isKnownAlways(fcZero)) + return PoisonValue::get(VTy); + + Known = KnownFPClass::fdiv(KnownLHS, KnownRHS, Mode); + + FPClassTest ValidResults = DemandedMask & Known.KnownFPClasses; + if (Constant *SingleVal = + getFPClassConstant(VTy, ValidResults, /*IsCanonicalizing=*/true)) + return SingleVal; + + FastMathFlags InferredFMF = + inferFastMathValueFlagsBinOp(FMF, ValidResults, KnownLHS, KnownRHS); + if (InferredFMF != FMF) { + I->setFastMathFlags(InferredFMF); + return I; + } + + return nullptr; + } case Instruction::FPExt: { FPClassTest SrcDemandedMask = DemandedMask; @@ -2361,7 +2491,6 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I, Known = KnownFPClass::fpext(KnownSrc, DstTy, SrcTy); FPClassTest ValidResults = DemandedMask & Known.KnownFPClasses; - return getFPClassConstant(VTy, ValidResults, /*IsCanonicalizing=*/true); } case Instruction::Call: { diff --git a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-fdiv.ll b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-fdiv.ll index c6fe600290d37..7f05203c9dac0 100644 --- a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-fdiv.ll +++ b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-fdiv.ll @@ -59,8 +59,7 @@ define nofpclass(inf) half @ret_nofpclass_inf__fdiv_unknown_or_pinf(i1 %cond, ha define nofpclass(pinf pnorm psub pzero) half @ret_only_negative_results_or_nan_self(half noundef %x) { ; CHECK-LABEL: define nofpclass(pinf pzero psub pnorm) half @ret_only_negative_results_or_nan_self( ; CHECK-SAME: half noundef [[X:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X]], [[X]] -; CHECK-NEXT: ret half [[DIV]] +; CHECK-NEXT: ret half 0xH7E00 ; %div = fdiv half %x, %x ret half %div @@ -80,8 +79,7 @@ define nofpclass(pinf pnorm psub pzero nan) half @ret_only_negative_results_self define nofpclass(pinf pnorm psub pzero nan) half @ret_only_negative_results_self_maybe_undef(half %x) { ; CHECK-LABEL: define nofpclass(nan pinf pzero psub pnorm) half @ret_only_negative_results_self_maybe_undef( ; CHECK-SAME: half [[X:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X]], [[X]] -; CHECK-NEXT: ret half [[DIV]] +; CHECK-NEXT: ret half poison ; %div = fdiv half %x, %x ret half %div @@ -90,8 +88,7 @@ define nofpclass(pinf pnorm psub pzero nan) half @ret_only_negative_results_self define nofpclass(inf norm sub) half @ret_only_zero_or_nan_results_self(half noundef %x) { ; CHECK-LABEL: define nofpclass(inf sub norm) half @ret_only_zero_or_nan_results_self( ; CHECK-SAME: half noundef [[X:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X]], [[X]] -; CHECK-NEXT: ret half [[DIV]] +; CHECK-NEXT: ret half 0xH7E00 ; %div = fdiv half %x, %x ret half %div @@ -109,8 +106,7 @@ define nofpclass(inf norm sub nan) half @ret_only_zero_results_self(half noundef define nofpclass(inf norm sub zero) half @ret_only_nan_results_self(half noundef %x) { ; CHECK-LABEL: define nofpclass(inf zero sub norm) half @ret_only_nan_results_self( ; CHECK-SAME: half noundef [[X:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X]], [[X]] -; CHECK-NEXT: ret half [[DIV]] +; CHECK-NEXT: ret half 0xH7E00 ; %div = fdiv half %x, %x ret half %div @@ -119,8 +115,7 @@ define nofpclass(inf norm sub zero) half @ret_only_nan_results_self(half noundef define nofpclass(inf norm sub zero snan) half @ret_only_qnan_results_self(half noundef %x) { ; CHECK-LABEL: define nofpclass(snan inf zero sub norm) half @ret_only_qnan_results_self( ; CHECK-SAME: half noundef [[X:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X]], [[X]] -; CHECK-NEXT: ret half [[DIV]] +; CHECK-NEXT: ret half 0xH7E00 ; %div = fdiv half %x, %x ret half %div @@ -129,8 +124,7 @@ define nofpclass(inf norm sub zero snan) half @ret_only_qnan_results_self(half n define nofpclass(inf norm sub zero qnan) half @ret_only_snan_results_self(half noundef %x) { ; CHECK-LABEL: define nofpclass(qnan inf zero sub norm) half @ret_only_snan_results_self( ; CHECK-SAME: half noundef [[X:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X]], [[X]] -; CHECK-NEXT: ret half [[DIV]] +; CHECK-NEXT: ret half poison ; %div = fdiv half %x, %x ret half %div @@ -139,8 +133,7 @@ define nofpclass(inf norm sub zero qnan) half @ret_only_snan_results_self(half n define nofpclass(norm sub zero) half @ret_only_inf_or_nan_results_self(half noundef %x) { ; CHECK-LABEL: define nofpclass(zero sub norm) half @ret_only_inf_or_nan_results_self( ; CHECK-SAME: half noundef [[X:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X]], [[X]] -; CHECK-NEXT: ret half [[DIV]] +; CHECK-NEXT: ret half 0xH7E00 ; %div = fdiv half %x, %x ret half %div @@ -158,8 +151,7 @@ define nofpclass(norm sub zero nan) half @ret_only_inf_results_self(half noundef define nofpclass(ninf norm sub zero) half @ret_only_pinf_or_nan_results_self(half noundef %x) { ; CHECK-LABEL: define nofpclass(ninf zero sub norm) half @ret_only_pinf_or_nan_results_self( ; CHECK-SAME: half noundef [[X:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X]], [[X]] -; CHECK-NEXT: ret half [[DIV]] +; CHECK-NEXT: ret half 0xH7E00 ; %div = fdiv half %x, %x ret half %div @@ -187,8 +179,7 @@ define nofpclass(pinf norm sub zero nan) half @ret_only_ninf_results_self(half n define nofpclass(inf) half @ret_src_must_be_zero_self(half noundef nofpclass(nan inf norm sub) %x) { ; CHECK-LABEL: define nofpclass(inf) half @ret_src_must_be_zero_self( ; CHECK-SAME: half noundef nofpclass(nan inf sub norm) [[X:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X]], [[X]] -; CHECK-NEXT: ret half [[DIV]] +; CHECK-NEXT: ret half 0xH7E00 ; %div = fdiv half %x, %x ret half %div @@ -197,8 +188,7 @@ define nofpclass(inf) half @ret_src_must_be_zero_self(half noundef nofpclass(nan define nofpclass(inf) half @ret_src_must_be_pzero(half noundef nofpclass(nan inf norm sub nzero) %x) { ; CHECK-LABEL: define nofpclass(inf) half @ret_src_must_be_pzero( ; CHECK-SAME: half noundef nofpclass(nan inf nzero sub norm) [[X:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X]], [[X]] -; CHECK-NEXT: ret half [[DIV]] +; CHECK-NEXT: ret half 0xH7E00 ; %div = fdiv half %x, %x ret half %div @@ -207,8 +197,7 @@ define nofpclass(inf) half @ret_src_must_be_pzero(half noundef nofpclass(nan inf define nofpclass(inf) half @ret_src_must_be_nzero(half noundef nofpclass(nan inf norm sub pzero) %x) { ; CHECK-LABEL: define nofpclass(inf) half @ret_src_must_be_nzero( ; CHECK-SAME: half noundef nofpclass(nan inf pzero sub norm) [[X:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X]], [[X]] -; CHECK-NEXT: ret half [[DIV]] +; CHECK-NEXT: ret half 0xH7E00 ; %div = fdiv half %x, %x ret half %div @@ -217,8 +206,7 @@ define nofpclass(inf) half @ret_src_must_be_nzero(half noundef nofpclass(nan inf define nofpclass(inf) half @ret_src_must_be_zero_or_nan_self(half noundef nofpclass(inf norm sub) %x) { ; CHECK-LABEL: define nofpclass(inf) half @ret_src_must_be_zero_or_nan_self( ; CHECK-SAME: half noundef nofpclass(inf sub norm) [[X:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X]], [[X]] -; CHECK-NEXT: ret half [[DIV]] +; CHECK-NEXT: ret half 0xH7E00 ; %div = fdiv half %x, %x ret half %div @@ -227,8 +215,7 @@ define nofpclass(inf) half @ret_src_must_be_zero_or_nan_self(half noundef nofpcl define nofpclass(inf) half @ret_src_must_be_zero_or_nan_self__preserve_flags(half noundef nofpclass(inf norm sub) %x) { ; CHECK-LABEL: define nofpclass(inf) half @ret_src_must_be_zero_or_nan_self__preserve_flags( ; CHECK-SAME: half noundef nofpclass(inf sub norm) [[X:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv contract half [[X]], [[X]] -; CHECK-NEXT: ret half [[DIV]] +; CHECK-NEXT: ret half 0xH7E00 ; %div = fdiv contract half %x, %x ret half %div @@ -238,8 +225,7 @@ define nofpclass(inf) half @ret_src_must_be_zero_or_nan_self_other_use_input0(ha ; CHECK-LABEL: define nofpclass(inf) half @ret_src_must_be_zero_or_nan_self_other_use_input0( ; CHECK-SAME: half noundef nofpclass(inf sub norm) [[X:%.*]]) { ; CHECK-NEXT: call void @use(half [[X]]) -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X]], [[X]] -; CHECK-NEXT: ret half [[DIV]] +; CHECK-NEXT: ret half 0xH7E00 ; call void @use(half %x) %div = fdiv half %x, %x @@ -249,9 +235,8 @@ define nofpclass(inf) half @ret_src_must_be_zero_or_nan_self_other_use_input0(ha define nofpclass(inf) half @ret_src_must_be_zero_or_nan_self_other_use_input1(half noundef nofpclass(inf norm sub) %x) { ; CHECK-LABEL: define nofpclass(inf) half @ret_src_must_be_zero_or_nan_self_other_use_input1( ; CHECK-SAME: half noundef nofpclass(inf sub norm) [[X:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X]], [[X]] ; CHECK-NEXT: call void @use(half [[X]]) -; CHECK-NEXT: ret half [[DIV]] +; CHECK-NEXT: ret half 0xH7E00 ; %div = fdiv half %x, %x call void @use(half %x) @@ -261,7 +246,8 @@ define nofpclass(inf) half @ret_src_must_be_zero_or_nan_self_other_use_input1(ha define nofpclass(snan) half @ret_src_nonan_self(half noundef nofpclass(nan) %x) { ; CHECK-LABEL: define nofpclass(snan) half @ret_src_nonan_self( ; CHECK-SAME: half noundef nofpclass(nan) [[X:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X]], [[X]] +; CHECK-NEXT: [[TMP1:%.*]] = call i1 @llvm.is.fpclass.f16(half [[X]], i32 612) +; CHECK-NEXT: [[DIV:%.*]] = select i1 [[TMP1]], half 0xH7E00, half 0xH3C00 ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv half %x, %x @@ -271,8 +257,7 @@ define nofpclass(snan) half @ret_src_nonan_self(half noundef nofpclass(nan) %x) define nofpclass(nan) half @ret_nonan_self(half noundef %x) { ; CHECK-LABEL: define nofpclass(nan) half @ret_nonan_self( ; CHECK-SAME: half noundef [[X:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X]], [[X]] -; CHECK-NEXT: ret half [[DIV]] +; CHECK-NEXT: ret half 0xH3C00 ; %div = fdiv half %x, %x ret half %div @@ -281,7 +266,8 @@ define nofpclass(nan) half @ret_nonan_self(half noundef %x) { define nofpclass(snan) half @ret_src_noinf_self(half noundef nofpclass(inf) %x) { ; CHECK-LABEL: define nofpclass(snan) half @ret_src_noinf_self( ; CHECK-SAME: half noundef nofpclass(inf) [[X:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X]], [[X]] +; CHECK-NEXT: [[TMP1:%.*]] = fcmp ueq half [[X]], 0xH0000 +; CHECK-NEXT: [[DIV:%.*]] = select i1 [[TMP1]], half 0xH7E00, half 0xH3C00 ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv half %x, %x @@ -291,7 +277,8 @@ define nofpclass(snan) half @ret_src_noinf_self(half noundef nofpclass(inf) %x) define nofpclass(inf) half @ret_noinf_self(half noundef %x) { ; CHECK-LABEL: define nofpclass(inf) half @ret_noinf_self( ; CHECK-SAME: half noundef [[X:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X]], [[X]] +; CHECK-NEXT: [[TMP1:%.*]] = call i1 @llvm.is.fpclass.f16(half [[X]], i32 615) +; CHECK-NEXT: [[DIV:%.*]] = select i1 [[TMP1]], half 0xH7E00, half 0xH3C00 ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv half %x, %x @@ -301,7 +288,8 @@ define nofpclass(inf) half @ret_noinf_self(half noundef %x) { define nofpclass(snan) half @ret_src_nonan_noinf_self(half noundef nofpclass(nan inf) %x) { ; CHECK-LABEL: define nofpclass(snan) half @ret_src_nonan_noinf_self( ; CHECK-SAME: half noundef nofpclass(nan inf) [[X:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X]], [[X]] +; CHECK-NEXT: [[TMP1:%.*]] = fcmp ueq half [[X]], 0xH0000 +; CHECK-NEXT: [[DIV:%.*]] = select i1 [[TMP1]], half 0xH7E00, half 0xH3C00 ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv half %x, %x @@ -311,7 +299,9 @@ define nofpclass(snan) half @ret_src_nonan_noinf_self(half noundef nofpclass(nan define nofpclass(snan) half @ret_src_nozero_self(half noundef nofpclass(zero) %x) { ; CHECK-LABEL: define nofpclass(snan) half @ret_src_nozero_self( ; CHECK-SAME: half noundef nofpclass(zero) [[X:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X]], [[X]] +; CHECK-NEXT: [[TMP1:%.*]] = call half @llvm.fabs.f16(half [[X]]) +; CHECK-NEXT: [[TMP2:%.*]] = fcmp ueq half [[TMP1]], 0xH7C00 +; CHECK-NEXT: [[DIV:%.*]] = select i1 [[TMP2]], half 0xH7E00, half 0xH3C00 ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv half %x, %x @@ -321,7 +311,11 @@ define nofpclass(snan) half @ret_src_nozero_self(half noundef nofpclass(zero) %x define nofpclass(snan) half @ret_src_nozero_self__daz(half noundef nofpclass(zero) %x) #2 { ; CHECK-LABEL: define nofpclass(snan) half @ret_src_nozero_self__daz( ; CHECK-SAME: half noundef nofpclass(zero) [[X:%.*]]) #[[ATTR0:[0-9]+]] { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X]], [[X]] +; CHECK-NEXT: [[TMP1:%.*]] = fcmp ueq half [[X]], 0xH0000 +; CHECK-NEXT: [[TMP2:%.*]] = call half @llvm.fabs.f16(half [[X]]) +; CHECK-NEXT: [[TMP3:%.*]] = fcmp ueq half [[TMP2]], 0xH7C00 +; CHECK-NEXT: [[TMP4:%.*]] = or i1 [[TMP3]], [[TMP1]] +; CHECK-NEXT: [[DIV:%.*]] = select i1 [[TMP4]], half 0xH7E00, half 0xH3C00 ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv half %x, %x @@ -331,7 +325,9 @@ define nofpclass(snan) half @ret_src_nozero_self__daz(half noundef nofpclass(zer define nofpclass(snan) half @ret_src_nozero_nosub_self(half noundef nofpclass(sub zero) %x) { ; CHECK-LABEL: define nofpclass(snan) half @ret_src_nozero_nosub_self( ; CHECK-SAME: half noundef nofpclass(zero sub) [[X:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X]], [[X]] +; CHECK-NEXT: [[TMP1:%.*]] = call half @llvm.fabs.f16(half [[X]]) +; CHECK-NEXT: [[TMP2:%.*]] = fcmp ueq half [[TMP1]], 0xH7C00 +; CHECK-NEXT: [[DIV:%.*]] = select i1 [[TMP2]], half 0xH7E00, half 0xH3C00 ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv half %x, %x @@ -341,7 +337,11 @@ define nofpclass(snan) half @ret_src_nozero_nosub_self(half noundef nofpclass(su define nofpclass(snan) half @ret_src_nozero_nosub_self__daz(half noundef nofpclass(sub zero) %x) #2 { ; CHECK-LABEL: define nofpclass(snan) half @ret_src_nozero_nosub_self__daz( ; CHECK-SAME: half noundef nofpclass(zero sub) [[X:%.*]]) #[[ATTR0]] { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X]], [[X]] +; CHECK-NEXT: [[TMP1:%.*]] = fcmp ueq half [[X]], 0xH0000 +; CHECK-NEXT: [[TMP2:%.*]] = call half @llvm.fabs.f16(half [[X]]) +; CHECK-NEXT: [[TMP3:%.*]] = fcmp ueq half [[TMP2]], 0xH7C00 +; CHECK-NEXT: [[TMP4:%.*]] = or i1 [[TMP3]], [[TMP1]] +; CHECK-NEXT: [[DIV:%.*]] = select i1 [[TMP4]], half 0xH7E00, half 0xH3C00 ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv half %x, %x @@ -360,7 +360,8 @@ define nofpclass(snan) half @ret_fdiv_nnan_self(half noundef %x) { define nofpclass(snan) half @ret_fdiv_ninf_self(half noundef %x) { ; CHECK-LABEL: define nofpclass(snan) half @ret_fdiv_ninf_self( ; CHECK-SAME: half noundef [[X:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv ninf half [[X]], [[X]] +; CHECK-NEXT: [[TMP1:%.*]] = call i1 @llvm.is.fpclass.f16(half [[X]], i32 615) +; CHECK-NEXT: [[DIV:%.*]] = select ninf i1 [[TMP1]], half 0xH7E00, half 0xH3C00 ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv ninf half %x, %x @@ -379,8 +380,7 @@ define nofpclass(snan) half @ret_fdiv_nnan_ninf_self(half noundef %x) { define nofpclass(pnorm) half @ret_nopnorm_self(half noundef %x) { ; CHECK-LABEL: define nofpclass(pnorm) half @ret_nopnorm_self( ; CHECK-SAME: half noundef [[X:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X]], [[X]] -; CHECK-NEXT: ret half [[DIV]] +; CHECK-NEXT: ret half 0xH7E00 ; %div = fdiv half %x, %x ret half %div @@ -389,7 +389,8 @@ define nofpclass(pnorm) half @ret_nopnorm_self(half noundef %x) { define nofpclass(ninf) half @ret_noninf_self(half noundef %x) { ; CHECK-LABEL: define nofpclass(ninf) half @ret_noninf_self( ; CHECK-SAME: half noundef [[X:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X]], [[X]] +; CHECK-NEXT: [[TMP1:%.*]] = call i1 @llvm.is.fpclass.f16(half [[X]], i32 615) +; CHECK-NEXT: [[DIV:%.*]] = select i1 [[TMP1]], half 0xH7E00, half 0xH3C00 ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv half %x, %x @@ -399,7 +400,8 @@ define nofpclass(ninf) half @ret_noninf_self(half noundef %x) { define nofpclass(pinf) half @ret_nopinf_self(half noundef %x) { ; CHECK-LABEL: define nofpclass(pinf) half @ret_nopinf_self( ; CHECK-SAME: half noundef [[X:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X]], [[X]] +; CHECK-NEXT: [[TMP1:%.*]] = call i1 @llvm.is.fpclass.f16(half [[X]], i32 615) +; CHECK-NEXT: [[DIV:%.*]] = select i1 [[TMP1]], half 0xH7E00, half 0xH3C00 ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv half %x, %x @@ -409,7 +411,8 @@ define nofpclass(pinf) half @ret_nopinf_self(half noundef %x) { define nofpclass(zero) half @ret_nozero_self(half noundef %x) { ; CHECK-LABEL: define nofpclass(zero) half @ret_nozero_self( ; CHECK-SAME: half noundef [[X:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X]], [[X]] +; CHECK-NEXT: [[TMP1:%.*]] = call i1 @llvm.is.fpclass.f16(half [[X]], i32 615) +; CHECK-NEXT: [[DIV:%.*]] = select i1 [[TMP1]], half 0xH7E00, half 0xH3C00 ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv half %x, %x @@ -474,8 +477,7 @@ define nofpclass(pinf) half @ret_nofpclass_pinf__fdiv_self_unknown_or_pinf__othe define nofpclass(nzero) half @ret_src_must_be_nan_self(half noundef nofpclass(inf norm sub zero) %x) { ; CHECK-LABEL: define nofpclass(nzero) half @ret_src_must_be_nan_self( ; CHECK-SAME: half noundef nofpclass(inf zero sub norm) [[X:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X]], [[X]] -; CHECK-NEXT: ret half [[DIV]] +; CHECK-NEXT: ret half 0xH7E00 ; %div = fdiv half %x, %x ret half %div @@ -485,9 +487,7 @@ define nofpclass(nzero) half @ret_src_must_be_nan_self(half noundef nofpclass(in define nofpclass(pinf pnorm psub pzero) half @ret_only_negative_results_or_nan_fabs_xy(half %x, half nofpclass(ninf nnorm nsub nzero) %y.pos.or.nan) { ; CHECK-LABEL: define nofpclass(pinf pzero psub pnorm) half @ret_only_negative_results_or_nan_fabs_xy( ; CHECK-SAME: half [[X:%.*]], half nofpclass(ninf nzero nsub nnorm) [[Y_POS_OR_NAN:%.*]]) { -; CHECK-NEXT: [[X_FABS:%.*]] = call half @llvm.fabs.f16(half [[X]]) -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X_FABS]], [[Y_POS_OR_NAN]] -; CHECK-NEXT: ret half [[DIV]] +; CHECK-NEXT: ret half 0xH7E00 ; %x.fabs = call half @llvm.fabs.f32(half %x) %div = fdiv half %x.fabs, %y.pos.or.nan @@ -594,7 +594,7 @@ define nofpclass(ninf nan) half @ret_no_ninf_or_nan_results__lhs_known_non_inf(i ; CHECK-LABEL: define nofpclass(nan ninf) half @ret_no_ninf_or_nan_results__lhs_known_non_inf( ; CHECK-SAME: i1 [[COND:%.*]], half [[X:%.*]], half nofpclass(inf) [[Y:%.*]]) { ; CHECK-NEXT: [[X_OR_PINF:%.*]] = select i1 [[COND]], half [[X]], half 0xH7C00 -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X_OR_PINF]], [[Y]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[X_OR_PINF]], [[Y]] ; CHECK-NEXT: ret half [[DIV]] ; %x.or.pinf = select i1 %cond, half %x, half 0x7FF0000000000000 @@ -607,7 +607,7 @@ define nofpclass(pinf nan) half @ret_no_pinf_or_nan_results__lhs_known_non_inf(i ; CHECK-LABEL: define nofpclass(nan pinf) half @ret_no_pinf_or_nan_results__lhs_known_non_inf( ; CHECK-SAME: i1 [[COND:%.*]], half [[X:%.*]], half nofpclass(inf) [[Y:%.*]]) { ; CHECK-NEXT: [[X_OR_PINF:%.*]] = select i1 [[COND]], half [[X]], half 0xH7C00 -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X_OR_PINF]], [[Y]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[X_OR_PINF]], [[Y]] ; CHECK-NEXT: ret half [[DIV]] ; %x.or.pinf = select i1 %cond, half %x, half 0x7FF0000000000000 @@ -619,8 +619,7 @@ define nofpclass(pinf nan) half @ret_no_pinf_or_nan_results__lhs_known_non_inf(i define nofpclass(inf nan) half @ret_no_inf_or_nan_results__lhs_known_non_inf(i1 %cond, half %x, half nofpclass(inf) %y) { ; CHECK-LABEL: define nofpclass(nan inf) half @ret_no_inf_or_nan_results__lhs_known_non_inf( ; CHECK-SAME: i1 [[COND:%.*]], half [[X:%.*]], half nofpclass(inf) [[Y:%.*]]) { -; CHECK-NEXT: [[X_OR_PINF:%.*]] = select i1 [[COND]], half [[X]], half 0xH7C00 -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X_OR_PINF]], [[Y]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[X]], [[Y]] ; CHECK-NEXT: ret half [[DIV]] ; %x.or.pinf = select i1 %cond, half %x, half 0x7FF0000000000000 @@ -633,7 +632,7 @@ define nofpclass(inf nan) half @ret_no_inf_or_nan_results__rhs_known_non_inf(i1 ; CHECK-LABEL: define nofpclass(nan inf) half @ret_no_inf_or_nan_results__rhs_known_non_inf( ; CHECK-SAME: i1 [[COND:%.*]], half [[X:%.*]], half nofpclass(inf) [[Y:%.*]]) { ; CHECK-NEXT: [[Y_OR_PINF:%.*]] = select i1 [[COND]], half [[Y]], half 0xH7C00 -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X]], [[Y_OR_PINF]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[X]], [[Y_OR_PINF]] ; CHECK-NEXT: ret half [[DIV]] ; %y.or.pinf = select i1 %cond, half %y, half 0x7FF0000000000000 @@ -645,8 +644,7 @@ define nofpclass(inf nan) half @ret_no_inf_or_nan_results__rhs_known_non_inf(i1 define nofpclass(ninf nnorm nsub nzero) half @ret_only_positive_results_or_nan_known_negative_fdiv(half nofpclass(ninf nnorm nsub nzero) %only.positive.or.nan, half nofpclass(pinf pnorm psub pzero) %only.negative.or.nan) { ; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) half @ret_only_positive_results_or_nan_known_negative_fdiv( ; CHECK-SAME: half nofpclass(ninf nzero nsub nnorm) [[ONLY_POSITIVE_OR_NAN:%.*]], half nofpclass(pinf pzero psub pnorm) [[ONLY_NEGATIVE_OR_NAN:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[ONLY_NEGATIVE_OR_NAN]], [[ONLY_POSITIVE_OR_NAN]] -; CHECK-NEXT: ret half [[DIV]] +; CHECK-NEXT: ret half 0xH7E00 ; %div = fdiv half %only.negative.or.nan, %only.positive.or.nan ret half %div @@ -656,8 +654,7 @@ define nofpclass(ninf nnorm nsub nzero) half @ret_only_positive_results_or_nan_k define nofpclass(ninf nnorm nsub nzero nan) half @ret_only_positive_results_known_negative_fdiv(half nofpclass(ninf nnorm nsub nzero) %only.positive.or.nan, half nofpclass(pinf pnorm psub pzero) %only.negative.or.nan) { ; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) half @ret_only_positive_results_known_negative_fdiv( ; CHECK-SAME: half nofpclass(ninf nzero nsub nnorm) [[ONLY_POSITIVE_OR_NAN:%.*]], half nofpclass(pinf pzero psub pnorm) [[ONLY_NEGATIVE_OR_NAN:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[ONLY_NEGATIVE_OR_NAN]], [[ONLY_POSITIVE_OR_NAN]] -; CHECK-NEXT: ret half [[DIV]] +; CHECK-NEXT: ret half poison ; %div = fdiv half %only.negative.or.nan, %only.positive.or.nan ret half %div @@ -821,7 +818,7 @@ define nofpclass(nsub) half @ret__known_negative_nonlogical0__fdiv__known_inf_or define nofpclass(nan) half @ret_no_nan_result__known_pzero__fdiv__not_inf(half nofpclass(inf sub norm nzero) %pzero.or.nan, half nofpclass(inf nan) %not.inf.or.nan) { ; CHECK-LABEL: define nofpclass(nan) half @ret_no_nan_result__known_pzero__fdiv__not_inf( ; CHECK-SAME: half nofpclass(inf nzero sub norm) [[PZERO_OR_NAN:%.*]], half nofpclass(nan inf) [[NOT_INF_OR_NAN:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[PZERO_OR_NAN]], [[NOT_INF_OR_NAN]] +; CHECK-NEXT: [[DIV:%.*]] = call half @llvm.copysign.f16(half 0xH0000, half [[NOT_INF_OR_NAN]]) ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv half %pzero.or.nan, %not.inf.or.nan @@ -832,7 +829,7 @@ define nofpclass(nan) half @ret_no_nan_result__known_pzero__fdiv__not_inf(half n define nofpclass(nan) half @ret_no_nan_result__not_inf_or_nan__fdiv__known_pzero_or_nan(half nofpclass(inf) %not.inf.or.nan, half nofpclass(inf sub norm nzero) %pzero.or.nan) { ; CHECK-LABEL: define nofpclass(nan) half @ret_no_nan_result__not_inf_or_nan__fdiv__known_pzero_or_nan( ; CHECK-SAME: half nofpclass(inf) [[NOT_INF_OR_NAN:%.*]], half nofpclass(inf nzero sub norm) [[PZERO_OR_NAN:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[NOT_INF_OR_NAN]], [[PZERO_OR_NAN]] +; CHECK-NEXT: [[DIV:%.*]] = call half @llvm.copysign.f16(half 0xH7C00, half [[NOT_INF_OR_NAN]]) ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv half %not.inf.or.nan, %pzero.or.nan @@ -843,7 +840,7 @@ define nofpclass(nan) half @ret_no_nan_result__not_inf_or_nan__fdiv__known_pzero define nofpclass(nan) half @ret_no_nan_result__known_inf_or_nan__fdiv__known_negative_non0(half nofpclass(zero sub norm) %inf.or.nan, half nofpclass(zero pinf pnorm psub) %negative.non0) { ; CHECK-LABEL: define nofpclass(nan) half @ret_no_nan_result__known_inf_or_nan__fdiv__known_negative_non0( ; CHECK-SAME: half nofpclass(zero sub norm) [[INF_OR_NAN:%.*]], half nofpclass(pinf zero psub pnorm) [[NEGATIVE_NON0:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[INF_OR_NAN]], [[NEGATIVE_NON0]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[INF_OR_NAN]], [[NEGATIVE_NON0]] ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv half %inf.or.nan, %negative.non0 @@ -854,7 +851,7 @@ define nofpclass(nan) half @ret_no_nan_result__known_inf_or_nan__fdiv__known_neg define nofpclass(nan) half @ret_no_nan_result__known_negative_non0__fdiv__known_inf_or_nan(half nofpclass(zero pinf pnorm psub) %negative.non0, half nofpclass(zero sub norm) %inf.or.nan) { ; CHECK-LABEL: define nofpclass(nan) half @ret_no_nan_result__known_negative_non0__fdiv__known_inf_or_nan( ; CHECK-SAME: half nofpclass(pinf zero psub pnorm) [[NEGATIVE_NON0:%.*]], half nofpclass(zero sub norm) [[INF_OR_NAN:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[NEGATIVE_NON0]], [[INF_OR_NAN]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[NEGATIVE_NON0]], [[INF_OR_NAN]] ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv half %negative.non0, %inf.or.nan @@ -865,7 +862,7 @@ define nofpclass(nan) half @ret_no_nan_result__known_negative_non0__fdiv__known_ define nofpclass(inf nan) half @ret_noinf_nonan__known_pzero_or_nan__fdiv__not_inf_or_nan(half nofpclass(inf sub norm nzero) %pzero.or.nan, half %unknown) { ; CHECK-LABEL: define nofpclass(nan inf) half @ret_noinf_nonan__known_pzero_or_nan__fdiv__not_inf_or_nan( ; CHECK-SAME: half nofpclass(inf nzero sub norm) [[PZERO_OR_NAN:%.*]], half [[UNKNOWN:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[PZERO_OR_NAN]], [[UNKNOWN]] +; CHECK-NEXT: [[DIV:%.*]] = call half @llvm.copysign.f16(half 0xH0000, half [[UNKNOWN]]) ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv half %pzero.or.nan, %unknown @@ -876,7 +873,7 @@ define nofpclass(inf nan) half @ret_noinf_nonan__known_pzero_or_nan__fdiv__not_i define nofpclass(inf nan) half @ret_noinf_nonan__not_inf_or_nan__fdiv__known_pzero_or_nan(half nofpclass(inf sub norm nzero) %pzero.or.nan, half %unknown) { ; CHECK-LABEL: define nofpclass(nan inf) half @ret_noinf_nonan__not_inf_or_nan__fdiv__known_pzero_or_nan( ; CHECK-SAME: half nofpclass(inf nzero sub norm) [[PZERO_OR_NAN:%.*]], half [[UNKNOWN:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[PZERO_OR_NAN]], [[UNKNOWN]] +; CHECK-NEXT: [[DIV:%.*]] = call half @llvm.copysign.f16(half 0xH0000, half [[UNKNOWN]]) ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv half %pzero.or.nan, %unknown @@ -909,7 +906,7 @@ define nofpclass(inf) half @ret_noinf__noinf_or_nan__fdiv__known_pzero_or_nan(ha define nofpclass(nan) half @ret_nonan__known_zero_or_nan__fdiv__not_nan(half nofpclass(nan sub norm nzero) %pzero.or.inf, half nofpclass(nan) %not.nan) { ; CHECK-LABEL: define nofpclass(nan) half @ret_nonan__known_zero_or_nan__fdiv__not_nan( ; CHECK-SAME: half nofpclass(nan nzero sub norm) [[PZERO_OR_INF:%.*]], half nofpclass(nan) [[NOT_NAN:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[PZERO_OR_INF]], [[NOT_NAN]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[PZERO_OR_INF]], [[NOT_NAN]] ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv half %pzero.or.inf, %not.nan @@ -920,7 +917,7 @@ define nofpclass(nan) half @ret_nonan__known_zero_or_nan__fdiv__not_nan(half nof define nofpclass(nan) half @ret_nonan__noinf_or_nan__fdiv__known_pzero_or_nan(half nofpclass(nan) %not.nan, half nofpclass(nan sub norm nzero) %pzero.or.inf) { ; CHECK-LABEL: define nofpclass(nan) half @ret_nonan__noinf_or_nan__fdiv__known_pzero_or_nan( ; CHECK-SAME: half nofpclass(nan) [[NOT_NAN:%.*]], half nofpclass(nan nzero sub norm) [[PZERO_OR_INF:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[NOT_NAN]], [[PZERO_OR_INF]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[NOT_NAN]], [[PZERO_OR_INF]] ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv half %not.nan, %pzero.or.inf @@ -1051,8 +1048,7 @@ define nofpclass(ninf) half @ret_noninf__not_nan_neg__fdiv__known_zero_or_pos_na define nofpclass(inf norm sub zero) half @ret_only_nan_results_fdiv(half %x, half %y) { ; CHECK-LABEL: define nofpclass(inf zero sub norm) half @ret_only_nan_results_fdiv( ; CHECK-SAME: half [[X:%.*]], half [[Y:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[X]], [[Y]] -; CHECK-NEXT: ret half [[DIV]] +; CHECK-NEXT: ret half 0xH7E00 ; %div = fdiv half %x, %y ret half %div @@ -1081,7 +1077,7 @@ define nofpclass(inf norm sub zero qnan) half @ret_only_snan_results_fdiv(half % define nofpclass(nan inf) half @ret_no_nan_no_inf__fdiv_nonan_noinf__nonan_noinf(half nofpclass(inf nan) %x, half nofpclass(inf nan) %y) { ; CHECK-LABEL: define nofpclass(nan inf) half @ret_no_nan_no_inf__fdiv_nonan_noinf__nonan_noinf( ; CHECK-SAME: half nofpclass(nan inf) [[X:%.*]], half nofpclass(nan inf) [[Y:%.*]]) { -; CHECK-NEXT: [[FDIV:%.*]] = fdiv half [[X]], [[Y]] +; CHECK-NEXT: [[FDIV:%.*]] = fdiv nnan ninf half [[X]], [[Y]] ; CHECK-NEXT: ret half [[FDIV]] ; %fdiv = fdiv half %x, %y @@ -1102,7 +1098,7 @@ define nofpclass(nan) half @ret_no_nan__fdiv_zero__unknown(half %unknown) { ; CHECK-LABEL: define nofpclass(nan) half @ret_no_nan__fdiv_zero__unknown( ; CHECK-SAME: half [[UNKNOWN:%.*]]) { ; CHECK-NEXT: [[ZERO:%.*]] = call half @returns_zero() -; CHECK-NEXT: [[FDIV:%.*]] = fdiv half [[ZERO]], [[UNKNOWN]] +; CHECK-NEXT: [[FDIV:%.*]] = fdiv nnan half [[ZERO]], [[UNKNOWN]] ; CHECK-NEXT: ret half [[FDIV]] ; %zero = call half @returns_zero() @@ -1114,7 +1110,7 @@ define nofpclass(nan) half @ret_no_nan__fdiv_unknown__zero(half %unknown) { ; CHECK-LABEL: define nofpclass(nan) half @ret_no_nan__fdiv_unknown__zero( ; CHECK-SAME: half [[UNKNOWN:%.*]]) { ; CHECK-NEXT: [[ZERO:%.*]] = call half @returns_zero() -; CHECK-NEXT: [[FDIV:%.*]] = fdiv half [[UNKNOWN]], [[ZERO]] +; CHECK-NEXT: [[FDIV:%.*]] = fdiv nnan half [[UNKNOWN]], [[ZERO]] ; CHECK-NEXT: ret half [[FDIV]] ; %zero = call half @returns_zero() @@ -1126,7 +1122,7 @@ define nofpclass(nan) half @ret_no_nan__fdiv_pzero__unknown(half %unknown) { ; CHECK-LABEL: define nofpclass(nan) half @ret_no_nan__fdiv_pzero__unknown( ; CHECK-SAME: half [[UNKNOWN:%.*]]) { ; CHECK-NEXT: [[PZERO:%.*]] = call half @returns_pzero() -; CHECK-NEXT: [[FDIV:%.*]] = fdiv half [[PZERO]], [[UNKNOWN]] +; CHECK-NEXT: [[FDIV:%.*]] = call half @llvm.copysign.f16(half 0xH0000, half [[UNKNOWN]]) ; CHECK-NEXT: ret half [[FDIV]] ; %pzero = call half @returns_pzero() @@ -1138,7 +1134,7 @@ define nofpclass(nan) half @ret_no_nan__fdiv_unknown__pzero(half %unknown) { ; CHECK-LABEL: define nofpclass(nan) half @ret_no_nan__fdiv_unknown__pzero( ; CHECK-SAME: half [[UNKNOWN:%.*]]) { ; CHECK-NEXT: [[PZERO:%.*]] = call half @returns_pzero() -; CHECK-NEXT: [[FDIV:%.*]] = fdiv half [[UNKNOWN]], [[PZERO]] +; CHECK-NEXT: [[FDIV:%.*]] = call half @llvm.copysign.f16(half 0xH7C00, half [[UNKNOWN]]) ; CHECK-NEXT: ret half [[FDIV]] ; %pzero = call half @returns_pzero() @@ -1150,7 +1146,7 @@ define nofpclass(nan) half @ret_no_nan__fdiv_nzero__unknown(half %unknown) { ; CHECK-LABEL: define nofpclass(nan) half @ret_no_nan__fdiv_nzero__unknown( ; CHECK-SAME: half [[UNKNOWN:%.*]]) { ; CHECK-NEXT: [[NZERO:%.*]] = call half @returns_nzero() -; CHECK-NEXT: [[FDIV:%.*]] = fdiv half [[NZERO]], [[UNKNOWN]] +; CHECK-NEXT: [[FDIV:%.*]] = fdiv nnan half 0xH8000, [[UNKNOWN]] ; CHECK-NEXT: ret half [[FDIV]] ; %nzero = call half @returns_nzero() @@ -1162,7 +1158,7 @@ define nofpclass(nan) half @ret_no_nan__fdiv_unknown__nzero(half %unknown) { ; CHECK-LABEL: define nofpclass(nan) half @ret_no_nan__fdiv_unknown__nzero( ; CHECK-SAME: half [[UNKNOWN:%.*]]) { ; CHECK-NEXT: [[NZERO:%.*]] = call half @returns_nzero() -; CHECK-NEXT: [[FDIV:%.*]] = fdiv half [[UNKNOWN]], [[NZERO]] +; CHECK-NEXT: [[FDIV:%.*]] = fdiv nnan half [[UNKNOWN]], 0xH8000 ; CHECK-NEXT: ret half [[FDIV]] ; %nzero = call half @returns_nzero() @@ -1285,7 +1281,7 @@ define nofpclass(inf) half @ret_noinf__not_inf_or_nan__fdiv__nzero_or_nan(half n define nofpclass(nan) half @ret_nonan__nzero_or_nan__fdiv__not_inf_or_nan(half nofpclass(inf sub norm pzero) %nzero.or.nan, half nofpclass(nan) %not.nan) { ; CHECK-LABEL: define nofpclass(nan) half @ret_nonan__nzero_or_nan__fdiv__not_inf_or_nan( ; CHECK-SAME: half nofpclass(inf pzero sub norm) [[NZERO_OR_NAN:%.*]], half nofpclass(nan) [[NOT_NAN:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[NZERO_OR_NAN]], [[NOT_NAN]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half 0xH8000, [[NOT_NAN]] ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv half %nzero.or.nan, %not.nan @@ -1296,7 +1292,7 @@ define nofpclass(nan) half @ret_nonan__nzero_or_nan__fdiv__not_inf_or_nan(half n define nofpclass(nan) half @ret_nonan__not_inf_or_nan__fdiv__nzero_or_nan(half nofpclass(nan) %not.nan, half nofpclass(inf sub norm pzero) %nzero.or.nan) { ; CHECK-LABEL: define nofpclass(nan) half @ret_nonan__not_inf_or_nan__fdiv__nzero_or_nan( ; CHECK-SAME: half nofpclass(nan) [[NOT_NAN:%.*]], half nofpclass(inf pzero sub norm) [[NZERO_OR_NAN:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[NOT_NAN]], [[NZERO_OR_NAN]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[NOT_NAN]], 0xH8000 ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv half %not.nan, %nzero.or.nan @@ -1329,7 +1325,7 @@ define nofpclass(snan) half @ret_not_inf_or_nan__fdiv_ninf__nzero_or_nan(half no define nofpclass(snan) half @ret__nzero_or_nan__fdiv_nnan__not_inf_or_nan(half nofpclass(inf sub norm pzero) %nzero.or.nan, half %unknown) { ; CHECK-LABEL: define nofpclass(snan) half @ret__nzero_or_nan__fdiv_nnan__not_inf_or_nan( ; CHECK-SAME: half nofpclass(inf pzero sub norm) [[NZERO_OR_NAN:%.*]], half [[UNKNOWN:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[NZERO_OR_NAN]], [[UNKNOWN]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half 0xH8000, [[UNKNOWN]] ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv nnan half %nzero.or.nan, %unknown @@ -1340,7 +1336,7 @@ define nofpclass(snan) half @ret__nzero_or_nan__fdiv_nnan__not_inf_or_nan(half n define nofpclass(snan) half @not_inf_or_nan__fdiv_nnan__nzero_or_nan(half %unknown, half nofpclass(inf sub norm pzero) %nzero.or.nan) { ; CHECK-LABEL: define nofpclass(snan) half @not_inf_or_nan__fdiv_nnan__nzero_or_nan( ; CHECK-SAME: half [[UNKNOWN:%.*]], half nofpclass(inf pzero sub norm) [[NZERO_OR_NAN:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[UNKNOWN]], [[NZERO_OR_NAN]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[UNKNOWN]], 0xH8000 ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv nnan half %unknown, %nzero.or.nan @@ -1462,7 +1458,7 @@ define nofpclass(nan inf norm sub) half @zero_result_demands_sub_source_lhs(i1 % ; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[SUB:%.*]] = call half @returns_sub() ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[SUB]], half [[UNKNOWN0]] -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[SELECT]], [[UNKNOWN1]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[SELECT]], [[UNKNOWN1]] ; CHECK-NEXT: ret half [[DIV]] ; %sub = call half @returns_sub() @@ -1476,7 +1472,7 @@ define nofpclass(nan inf norm sub) half @zero_result_demands_sub_source_rhs(i1 % ; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[SUB:%.*]] = call half @returns_sub() ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[SUB]], half [[UNKNOWN0]] -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[UNKNOWN1]], [[SELECT]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[UNKNOWN1]], [[SELECT]] ; CHECK-NEXT: ret half [[DIV]] ; %sub = call half @returns_sub() @@ -1490,7 +1486,7 @@ define nofpclass(nan inf norm sub) half @zero_result_demands_norm_source_lhs(i1 ; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[NORM:%.*]] = call half @returns_norm() ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[NORM]], half [[UNKNOWN0]] -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[SELECT]], [[UNKNOWN1]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[SELECT]], [[UNKNOWN1]] ; CHECK-NEXT: ret half [[DIV]] ; %norm = call half @returns_norm() @@ -1504,7 +1500,7 @@ define nofpclass(nan inf norm sub) half @zero_result_demands_norm_source_rhs(i1 ; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[NORM:%.*]] = call half @returns_norm() ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[NORM]], half [[UNKNOWN0]] -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[UNKNOWN1]], [[SELECT]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[UNKNOWN1]], [[SELECT]] ; CHECK-NEXT: ret half [[DIV]] ; %norm = call half @returns_norm() @@ -1518,7 +1514,7 @@ define nofpclass(nan inf norm zero) half @sub_result_demands_norm_source_lhs(i1 ; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[NORM:%.*]] = call half @returns_norm() ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[NORM]], half [[UNKNOWN0]] -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[SELECT]], [[UNKNOWN1]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[SELECT]], [[UNKNOWN1]] ; CHECK-NEXT: ret half [[DIV]] ; %norm = call half @returns_norm() @@ -1532,7 +1528,7 @@ define nofpclass(nan inf norm zero) half @sub_result_demands_norm_source_rhs(i1 ; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[NORM:%.*]] = call half @returns_norm() ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[NORM]], half [[UNKNOWN0]] -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[UNKNOWN1]], [[SELECT]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[UNKNOWN1]], [[SELECT]] ; CHECK-NEXT: ret half [[DIV]] ; %norm = call half @returns_norm() @@ -1602,7 +1598,7 @@ define nofpclass(ninf nan zero sub) half @pinf_result_demands_zero_rhs(i1 %cond, ; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[ZERO:%.*]] = call half @returns_zero() ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[ZERO]], half [[UNKNOWN0]] -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[UNKNOWN1]], [[SELECT]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[UNKNOWN1]], [[SELECT]] ; CHECK-NEXT: ret half [[DIV]] ; %zero = call half @returns_zero() @@ -1616,7 +1612,7 @@ define nofpclass(pinf nan zero sub) half @ninf_result_demands_zero_rhs(i1 %cond, ; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[ZERO:%.*]] = call half @returns_zero() ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[ZERO]], half [[UNKNOWN0]] -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[UNKNOWN1]], [[SELECT]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[UNKNOWN1]], [[SELECT]] ; CHECK-NEXT: ret half [[DIV]] ; %zero = call half @returns_zero() @@ -1630,7 +1626,7 @@ define nofpclass(nan zero sub) half @inf_result_demands_zero_rhs(i1 %cond, half ; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[ZERO:%.*]] = call half @returns_zero() ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[ZERO]], half [[UNKNOWN0]] -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[UNKNOWN1]], [[SELECT]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[UNKNOWN1]], [[SELECT]] ; CHECK-NEXT: ret half [[DIV]] ; %zero = call half @returns_zero() @@ -1644,7 +1640,7 @@ define nofpclass(inf nan zero nnorm) half @pnorm_result_demands_pnorm_lhs(i1 %co ; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[PNORM:%.*]] = call half @returns_pnorm() ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[PNORM]], half [[UNKNOWN0]] -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[SELECT]], [[UNKNOWN1]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[SELECT]], [[UNKNOWN1]] ; CHECK-NEXT: ret half [[DIV]] ; %pnorm = call half @returns_pnorm() @@ -1658,7 +1654,7 @@ define nofpclass(inf nan zero nnorm) half @pnorm_result_demands_nnorm_lhs(i1 %co ; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[NNORM:%.*]] = call half @returns_nnorm() ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[NNORM]], half [[UNKNOWN0]] -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[SELECT]], [[UNKNOWN1]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[SELECT]], [[UNKNOWN1]] ; CHECK-NEXT: ret half [[DIV]] ; %nnorm = call half @returns_nnorm() @@ -1672,7 +1668,7 @@ define nofpclass(inf nan zero nnorm) half @pnorm_result_demands_psub_lhs(i1 %con ; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[PSUB:%.*]] = call half @returns_psub() ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[PSUB]], half [[UNKNOWN0]] -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[SELECT]], [[UNKNOWN1]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[SELECT]], [[UNKNOWN1]] ; CHECK-NEXT: ret half [[DIV]] ; %psub = call half @returns_psub() @@ -1686,7 +1682,7 @@ define nofpclass(inf nan zero nnorm) half @pnorm_result_demands_nsub_lhs(i1 %con ; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[NSUB:%.*]] = call half @returns_nsub() ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[NSUB]], half [[UNKNOWN0]] -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[SELECT]], [[UNKNOWN1]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[SELECT]], [[UNKNOWN1]] ; CHECK-NEXT: ret half [[DIV]] ; %nsub = call half @returns_nsub() @@ -1700,7 +1696,7 @@ define nofpclass(inf nan zero nnorm) half @pnorm_result_demands_pnorm_rhs(i1 %co ; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[PNORM:%.*]] = call half @returns_pnorm() ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[PNORM]], half [[UNKNOWN0]] -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[UNKNOWN1]], [[SELECT]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[UNKNOWN1]], [[SELECT]] ; CHECK-NEXT: ret half [[DIV]] ; %pnorm = call half @returns_pnorm() @@ -1714,7 +1710,7 @@ define nofpclass(inf nan zero nnorm) half @pnorm_result_demands_nnorm_rhs(i1 %co ; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[NNORM:%.*]] = call half @returns_nnorm() ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[NNORM]], half [[UNKNOWN0]] -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[UNKNOWN1]], [[SELECT]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[UNKNOWN1]], [[SELECT]] ; CHECK-NEXT: ret half [[DIV]] ; %nnorm = call half @returns_nnorm() @@ -1728,7 +1724,7 @@ define nofpclass(inf nan zero nnorm) half @pnorm_result_demands_psub_rhs(i1 %con ; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[PSUB:%.*]] = call half @returns_psub() ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[PSUB]], half [[UNKNOWN0]] -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[UNKNOWN1]], [[SELECT]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[UNKNOWN1]], [[SELECT]] ; CHECK-NEXT: ret half [[DIV]] ; %psub = call half @returns_psub() @@ -1742,7 +1738,7 @@ define nofpclass(inf nan zero nnorm) half @pnorm_result_demands_nsub_rhs(i1 %con ; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[NSUB:%.*]] = call half @returns_nsub() ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[NSUB]], half [[UNKNOWN0]] -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[UNKNOWN1]], [[SELECT]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[UNKNOWN1]], [[SELECT]] ; CHECK-NEXT: ret half [[DIV]] ; %nsub = call half @returns_nsub() @@ -1756,7 +1752,7 @@ define nofpclass(inf nan zero pnorm) half @nnorm_result_demands_pnorm_lhs(i1 %co ; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[PNORM:%.*]] = call half @returns_pnorm() ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[PNORM]], half [[UNKNOWN0]] -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[SELECT]], [[UNKNOWN1]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[SELECT]], [[UNKNOWN1]] ; CHECK-NEXT: ret half [[DIV]] ; %pnorm = call half @returns_pnorm() @@ -1828,7 +1824,7 @@ define nofpclass(nan inf norm) half @zero_result_demand_inf_rhs(i1 %cond, half % ; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[INF:%.*]] = call half @returns_inf() ; CHECK-NEXT: [[INF_OR_UNKNOWN:%.*]] = select i1 [[COND]], half [[INF]], half [[UNKNOWN0]] -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[UNKNOWN1]], [[INF_OR_UNKNOWN]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[UNKNOWN1]], [[INF_OR_UNKNOWN]] ; CHECK-NEXT: ret half [[DIV]] ; %inf = call half @returns_inf() @@ -1842,8 +1838,7 @@ define nofpclass(nan inf norm) half @zero_result_no_demand_inf_lhs(i1 %cond, hal ; CHECK-LABEL: define nofpclass(nan inf norm) half @zero_result_no_demand_inf_lhs( ; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[INF:%.*]] = call half @returns_inf() -; CHECK-NEXT: [[INF_OR_UNKNOWN:%.*]] = select i1 [[COND]], half [[INF]], half [[UNKNOWN0]] -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[INF_OR_UNKNOWN]], [[UNKNOWN1]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[UNKNOWN0]], [[UNKNOWN1]] ; CHECK-NEXT: ret half [[DIV]] ; %inf = call half @returns_inf() @@ -1857,7 +1852,7 @@ define nofpclass(nan inf sub zero) half @norm_result_demands_sub_source_lhs(i1 % ; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[SUB:%.*]] = call half @returns_sub() ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[SUB]], half [[UNKNOWN0]] -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[SELECT]], [[UNKNOWN1]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[SELECT]], [[UNKNOWN1]] ; CHECK-NEXT: ret half [[DIV]] ; %sub = call half @returns_sub() @@ -1871,7 +1866,7 @@ define nofpclass(nan inf sub zero) half @norm_result_demands_sub_source_rhs(i1 % ; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[SUB:%.*]] = call half @returns_sub() ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[SUB]], half [[UNKNOWN0]] -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[UNKNOWN1]], [[SELECT]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[UNKNOWN1]], [[SELECT]] ; CHECK-NEXT: ret half [[DIV]] ; %sub = call half @returns_sub() @@ -1885,7 +1880,7 @@ define nofpclass(inf nan norm zero) half @sub_result_demands_sub_lhs(i1 %cond, h ; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[SUB:%.*]] = call half @returns_sub() ; CHECK-NEXT: [[SUB_OR_UNKNOWN:%.*]] = select i1 [[COND]], half [[SUB]], half [[UNKNOWN0]] -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[SUB_OR_UNKNOWN]], [[UNKNOWN1]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[SUB_OR_UNKNOWN]], [[UNKNOWN1]] ; CHECK-NEXT: ret half [[DIV]] ; %sub = call half @returns_sub() @@ -1899,7 +1894,7 @@ define nofpclass(inf nan norm zero) half @sub_result_demands_sub_rhs(i1 %cond, h ; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[SUB:%.*]] = call half @returns_sub() ; CHECK-NEXT: [[SUB_OR_UNKNOWN:%.*]] = select i1 [[COND]], half [[SUB]], half [[UNKNOWN0]] -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[UNKNOWN1]], [[SUB_OR_UNKNOWN]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[UNKNOWN1]], [[SUB_OR_UNKNOWN]] ; CHECK-NEXT: ret half [[DIV]] ; %sub = call half @returns_sub() @@ -1921,8 +1916,7 @@ define nofpclass(snan) half @ret__known_zero_or_nan__fdiv__not_nan(half nofpclas define nofpclass(snan) half @ret__known_zero_or_nan__fdiv_nsz__not_nan(half nofpclass(inf sub norm) %zero.or.nan, half nofpclass(nan) %not.nan) { ; CHECK-LABEL: define nofpclass(snan) half @ret__known_zero_or_nan__fdiv_nsz__not_nan( ; CHECK-SAME: half nofpclass(inf sub norm) [[ZERO_OR_NAN:%.*]], half nofpclass(nan) [[NOT_NAN:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv nsz contract half [[ZERO_OR_NAN]], [[NOT_NAN]] -; CHECK-NEXT: ret half [[DIV]] +; CHECK-NEXT: ret half 0xH0000 ; %div = fdiv nsz contract half %zero.or.nan, %not.nan ret half %div @@ -1931,8 +1925,7 @@ define nofpclass(snan) half @ret__known_zero_or_nan__fdiv_nsz__not_nan(half nofp define nofpclass(snan) <2 x half> @ret__known_zero_or_nan__fdiv_nsz__not_nan_vec(<2 x half> nofpclass(inf sub norm) %zero.or.nan, <2 x half> nofpclass(nan) %not.nan) { ; CHECK-LABEL: define nofpclass(snan) <2 x half> @ret__known_zero_or_nan__fdiv_nsz__not_nan_vec( ; CHECK-SAME: <2 x half> nofpclass(inf sub norm) [[ZERO_OR_NAN:%.*]], <2 x half> nofpclass(nan) [[NOT_NAN:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv nsz contract <2 x half> [[ZERO_OR_NAN]], [[NOT_NAN]] -; CHECK-NEXT: ret <2 x half> [[DIV]] +; CHECK-NEXT: ret <2 x half> zeroinitializer ; %div = fdiv nsz contract <2 x half> %zero.or.nan, %not.nan ret <2 x half> %div @@ -1941,7 +1934,7 @@ define nofpclass(snan) <2 x half> @ret__known_zero_or_nan__fdiv_nsz__not_nan_vec define nofpclass(nan) half @ret_nonan__known_zero_or_nan__fdiv__unknown(half nofpclass(inf sub norm) %zero.or.nan, half %unknown) { ; CHECK-LABEL: define nofpclass(nan) half @ret_nonan__known_zero_or_nan__fdiv__unknown( ; CHECK-SAME: half nofpclass(inf sub norm) [[ZERO_OR_NAN:%.*]], half [[UNKNOWN:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[ZERO_OR_NAN]], [[UNKNOWN]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[ZERO_OR_NAN]], [[UNKNOWN]] ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv half %zero.or.nan, %unknown @@ -1951,8 +1944,7 @@ define nofpclass(nan) half @ret_nonan__known_zero_or_nan__fdiv__unknown(half nof define nofpclass(nan) half @ret_nonan__zero_or_nan__fdiv_nsz__unknown(half nofpclass(inf sub norm) %zero.or.nan, half %unknown) { ; CHECK-LABEL: define nofpclass(nan) half @ret_nonan__zero_or_nan__fdiv_nsz__unknown( ; CHECK-SAME: half nofpclass(inf sub norm) [[ZERO_OR_NAN:%.*]], half [[UNKNOWN:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv nsz contract half [[ZERO_OR_NAN]], [[UNKNOWN]] -; CHECK-NEXT: ret half [[DIV]] +; CHECK-NEXT: ret half 0xH0000 ; %div = fdiv nsz contract half %zero.or.nan, %unknown ret half %div @@ -2043,7 +2035,7 @@ define nofpclass(snan) half @ret__unknown__fdiv_nsz__zero(half %unknown, half no define nofpclass(snan) half @ret__unknown__fdiv__pzero(half %unknown, half nofpclass(inf nan sub norm nzero) %pzero) { ; CHECK-LABEL: define nofpclass(snan) half @ret__unknown__fdiv__pzero( ; CHECK-SAME: half [[UNKNOWN:%.*]], half nofpclass(nan inf nzero sub norm) [[PZERO:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[UNKNOWN]], [[PZERO]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[UNKNOWN]], 0xH0000 ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv half %unknown, %pzero @@ -2053,7 +2045,7 @@ define nofpclass(snan) half @ret__unknown__fdiv__pzero(half %unknown, half nofpc define nofpclass(snan) half @ret__unknown__fdiv_nsz__pzero(half %unknown, half nofpclass(nan inf sub norm nzero) %pzero) { ; CHECK-LABEL: define nofpclass(snan) half @ret__unknown__fdiv_nsz__pzero( ; CHECK-SAME: half [[UNKNOWN:%.*]], half nofpclass(nan inf nzero sub norm) [[PZERO:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv nsz contract half [[UNKNOWN]], [[PZERO]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nsz contract half [[UNKNOWN]], 0xH0000 ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv nsz contract half %unknown, %pzero @@ -2063,7 +2055,7 @@ define nofpclass(snan) half @ret__unknown__fdiv_nsz__pzero(half %unknown, half n define nofpclass(snan) half @ret__unknown__fdiv__nzero(half %unknown, half nofpclass(nan inf sub norm pzero) %nzero) { ; CHECK-LABEL: define nofpclass(snan) half @ret__unknown__fdiv__nzero( ; CHECK-SAME: half [[UNKNOWN:%.*]], half nofpclass(nan inf pzero sub norm) [[NZERO:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[UNKNOWN]], [[NZERO]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[UNKNOWN]], 0xH8000 ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv half %unknown, %nzero @@ -2073,7 +2065,7 @@ define nofpclass(snan) half @ret__unknown__fdiv__nzero(half %unknown, half nofpc define nofpclass(snan) half @ret__unknown__fdiv_nsz__nzero(half %unknown, half nofpclass(nan inf sub norm pzero) %nzero) { ; CHECK-LABEL: define nofpclass(snan) half @ret__unknown__fdiv_nsz__nzero( ; CHECK-SAME: half [[UNKNOWN:%.*]], half nofpclass(nan inf pzero sub norm) [[NZERO:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv nsz contract half [[UNKNOWN]], [[NZERO]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nsz contract half [[UNKNOWN]], 0xH8000 ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv nsz contract half %unknown, %nzero @@ -2083,7 +2075,7 @@ define nofpclass(snan) half @ret__unknown__fdiv_nsz__nzero(half %unknown, half n define nofpclass(nan) half @ret_nonan__unknown__fdiv__zero(half %unknown, half nofpclass(nan inf sub norm) %zero) { ; CHECK-LABEL: define nofpclass(nan) half @ret_nonan__unknown__fdiv__zero( ; CHECK-SAME: half [[UNKNOWN:%.*]], half nofpclass(nan inf sub norm) [[ZERO:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[UNKNOWN]], [[ZERO]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[UNKNOWN]], [[ZERO]] ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv half %unknown, %zero @@ -2093,7 +2085,7 @@ define nofpclass(nan) half @ret_nonan__unknown__fdiv__zero(half %unknown, half n define nofpclass(nan) half @ret_nonan__unknown__fdiv_nsz__zero(half %unknown, half nofpclass(nan inf sub norm) %zero) { ; CHECK-LABEL: define nofpclass(nan) half @ret_nonan__unknown__fdiv_nsz__zero( ; CHECK-SAME: half [[UNKNOWN:%.*]], half nofpclass(nan inf sub norm) [[ZERO:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv nsz contract half [[UNKNOWN]], [[ZERO]] +; CHECK-NEXT: [[DIV:%.*]] = call nsz contract half @llvm.copysign.f16(half 0xH7C00, half [[UNKNOWN]]) ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv nsz contract half %unknown, %zero @@ -2103,7 +2095,7 @@ define nofpclass(nan) half @ret_nonan__unknown__fdiv_nsz__zero(half %unknown, ha define nofpclass(nan) half @ret_nonan__unknown__fdiv__pzero(half %unknown, half nofpclass(inf nan sub norm nzero) %pzero) { ; CHECK-LABEL: define nofpclass(nan) half @ret_nonan__unknown__fdiv__pzero( ; CHECK-SAME: half [[UNKNOWN:%.*]], half nofpclass(nan inf nzero sub norm) [[PZERO:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[UNKNOWN]], [[PZERO]] +; CHECK-NEXT: [[DIV:%.*]] = call half @llvm.copysign.f16(half 0xH7C00, half [[UNKNOWN]]) ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv half %unknown, %pzero @@ -2113,7 +2105,7 @@ define nofpclass(nan) half @ret_nonan__unknown__fdiv__pzero(half %unknown, half define nofpclass(nan) half @ret_nonan__unknown__fdiv_nsz__pzero(half %unknown, half nofpclass(nan inf sub norm nzero) %pzero) { ; CHECK-LABEL: define nofpclass(nan) half @ret_nonan__unknown__fdiv_nsz__pzero( ; CHECK-SAME: half [[UNKNOWN:%.*]], half nofpclass(nan inf nzero sub norm) [[PZERO:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv nsz contract half [[UNKNOWN]], [[PZERO]] +; CHECK-NEXT: [[DIV:%.*]] = call nsz contract half @llvm.copysign.f16(half 0xH7C00, half [[UNKNOWN]]) ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv nsz contract half %unknown, %pzero @@ -2123,7 +2115,7 @@ define nofpclass(nan) half @ret_nonan__unknown__fdiv_nsz__pzero(half %unknown, h define nofpclass(nan) half @ret_nonan__unknown__fdiv__nzero(half %unknown, half nofpclass(nan inf sub norm pzero) %nzero) { ; CHECK-LABEL: define nofpclass(nan) half @ret_nonan__unknown__fdiv__nzero( ; CHECK-SAME: half [[UNKNOWN:%.*]], half nofpclass(nan inf pzero sub norm) [[NZERO:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[UNKNOWN]], [[NZERO]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[UNKNOWN]], 0xH8000 ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv half %unknown, %nzero @@ -2133,7 +2125,7 @@ define nofpclass(nan) half @ret_nonan__unknown__fdiv__nzero(half %unknown, half define nofpclass(nan) half @ret_nonan__unknown__fdiv_nsz__nzero(half %unknown, half nofpclass(nan inf sub norm pzero) %nzero) { ; CHECK-LABEL: define nofpclass(nan) half @ret_nonan__unknown__fdiv_nsz__nzero( ; CHECK-SAME: half [[UNKNOWN:%.*]], half nofpclass(nan inf pzero sub norm) [[NZERO:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv nsz contract half [[UNKNOWN]], [[NZERO]] +; CHECK-NEXT: [[DIV:%.*]] = call nsz contract half @llvm.copysign.f16(half 0xH7C00, half [[UNKNOWN]]) ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv nsz contract half %unknown, %nzero @@ -2153,7 +2145,7 @@ define nofpclass(snan) half @ret__not_nan__fdiv_nsz__zero(half nofpclass(nan) %n define nofpclass(snan) half @ret__not_nan_not_zero__fdiv_nsz__zero(half nofpclass(nan zero) %not.nan.or.zero, half nofpclass(nan inf sub norm) %zero) { ; CHECK-LABEL: define nofpclass(snan) half @ret__not_nan_not_zero__fdiv_nsz__zero( ; CHECK-SAME: half nofpclass(nan zero) [[NOT_NAN_OR_ZERO:%.*]], half nofpclass(nan inf sub norm) [[ZERO:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv nsz contract half [[NOT_NAN_OR_ZERO]], [[ZERO]] +; CHECK-NEXT: [[DIV:%.*]] = call nsz contract half @llvm.copysign.f16(half 0xH7C00, half [[NOT_NAN_OR_ZERO]]) ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv nsz contract half %not.nan.or.zero, %zero @@ -2183,7 +2175,7 @@ define nofpclass(snan) half @ret__not_nan_not_zero__fdiv_nsz__zero__dynamic(half define nofpclass(snan) half @ret__not_nan_not_zero_not_sub__fdiv_nsz__zero__daz(half nofpclass(nan zero sub) %not.nan.or.zero.or.sub, half nofpclass(nan inf sub norm) %zero) #2 { ; CHECK-LABEL: define nofpclass(snan) half @ret__not_nan_not_zero_not_sub__fdiv_nsz__zero__daz( ; CHECK-SAME: half nofpclass(nan zero sub) [[NOT_NAN_OR_ZERO_OR_SUB:%.*]], half nofpclass(nan inf sub norm) [[ZERO:%.*]]) #[[ATTR0]] { -; CHECK-NEXT: [[DIV:%.*]] = fdiv nsz contract half [[NOT_NAN_OR_ZERO_OR_SUB]], [[ZERO]] +; CHECK-NEXT: [[DIV:%.*]] = call nsz contract half @llvm.copysign.f16(half 0xH7C00, half [[NOT_NAN_OR_ZERO_OR_SUB]]) ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv nsz contract half %not.nan.or.zero.or.sub, %zero @@ -2193,7 +2185,7 @@ define nofpclass(snan) half @ret__not_nan_not_zero_not_sub__fdiv_nsz__zero__daz( define nofpclass(snan) half @ret__not_nan_not_zero_not_sub__fdiv_nsz__zero__dynamic(half nofpclass(nan zero sub) %not.nan.or.zero.or.sub, half nofpclass(nan inf sub norm) %zero) #3 { ; CHECK-LABEL: define nofpclass(snan) half @ret__not_nan_not_zero_not_sub__fdiv_nsz__zero__dynamic( ; CHECK-SAME: half nofpclass(nan zero sub) [[NOT_NAN_OR_ZERO_OR_SUB:%.*]], half nofpclass(nan inf sub norm) [[ZERO:%.*]]) #[[ATTR3]] { -; CHECK-NEXT: [[DIV:%.*]] = fdiv nsz contract half [[NOT_NAN_OR_ZERO_OR_SUB]], [[ZERO]] +; CHECK-NEXT: [[DIV:%.*]] = call nsz contract half @llvm.copysign.f16(half 0xH7C00, half [[NOT_NAN_OR_ZERO_OR_SUB]]) ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv nsz contract half %not.nan.or.zero.or.sub, %zero @@ -2204,8 +2196,7 @@ define nofpclass(snan) half @ret__not_nan_not_zero_not_sub__fdiv_nsz__zero__dyna define nofpclass(nan inf) half @ret_nonan_noinf__unknown__fdiv__zero_or_nan(half %unknown, half nofpclass(inf sub norm) %zero.or.nan) { ; CHECK-LABEL: define nofpclass(nan inf) half @ret_nonan_noinf__unknown__fdiv__zero_or_nan( ; CHECK-SAME: half [[UNKNOWN:%.*]], half nofpclass(inf sub norm) [[ZERO_OR_NAN:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[UNKNOWN]], [[ZERO_OR_NAN]] -; CHECK-NEXT: ret half [[DIV]] +; CHECK-NEXT: ret half poison ; %div = fdiv half %unknown, %zero.or.nan ret half %div @@ -2214,7 +2205,7 @@ define nofpclass(nan inf) half @ret_nonan_noinf__unknown__fdiv__zero_or_nan(half define nofpclass(nan) half @ret_nonan__unknown__fdiv__zero_or_nan(half %unknown, half nofpclass(inf sub norm) %zero.or.nan) { ; CHECK-LABEL: define nofpclass(nan) half @ret_nonan__unknown__fdiv__zero_or_nan( ; CHECK-SAME: half [[UNKNOWN:%.*]], half nofpclass(inf sub norm) [[ZERO_OR_NAN:%.*]]) { -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[UNKNOWN]], [[ZERO_OR_NAN]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[UNKNOWN]], [[ZERO_OR_NAN]] ; CHECK-NEXT: ret half [[DIV]] ; %div = fdiv half %unknown, %zero.or.nan @@ -2235,7 +2226,7 @@ define nofpclass(nan inf norm sub) half @zero_result_demands_subnorm_lhs__daz(i1 ; CHECK-LABEL: define nofpclass(nan inf sub norm) half @zero_result_demands_subnorm_lhs__daz( ; CHECK-SAME: i1 [[COND:%.*]], half nofpclass(nan inf zero norm) [[ONLY_SUB:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) #[[ATTR1]] { ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[UNKNOWN0]], half [[ONLY_SUB]] -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[SELECT]], [[UNKNOWN1]] +; CHECK-NEXT: [[DIV:%.*]] = fdiv nnan half [[SELECT]], [[UNKNOWN1]] ; CHECK-NEXT: ret half [[DIV]] ; %select = select i1 %cond, half %unknown0, half %only.sub @@ -2246,9 +2237,7 @@ define nofpclass(nan inf norm sub) half @zero_result_demands_subnorm_lhs__daz(i1 define nofpclass(inf norm sub zero) half @nan_result_demands_subnorm_lhs__ieee(i1 %cond, half nofpclass(nan inf zero norm) %only.sub, half %unknown0, half %unknown1) { ; CHECK-LABEL: define nofpclass(inf zero sub norm) half @nan_result_demands_subnorm_lhs__ieee( ; CHECK-SAME: i1 [[COND:%.*]], half nofpclass(nan inf zero norm) [[ONLY_SUB:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) { -; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[UNKNOWN0]], half [[ONLY_SUB]] -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[SELECT]], [[UNKNOWN1]] -; CHECK-NEXT: ret half [[DIV]] +; CHECK-NEXT: ret half 0xH7E00 ; %select = select i1 %cond, half %unknown0, half %only.sub %div = fdiv half %select, %unknown1 @@ -2258,9 +2247,7 @@ define nofpclass(inf norm sub zero) half @nan_result_demands_subnorm_lhs__ieee(i define nofpclass(inf norm sub zero) half @nan_result_demands_subnorm_rhs__ieee(i1 %cond, half nofpclass(nan inf zero norm) %only.sub, half %unknown0, half %unknown1) { ; CHECK-LABEL: define nofpclass(inf zero sub norm) half @nan_result_demands_subnorm_rhs__ieee( ; CHECK-SAME: i1 [[COND:%.*]], half nofpclass(nan inf zero norm) [[ONLY_SUB:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) { -; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[UNKNOWN0]], half [[ONLY_SUB]] -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[UNKNOWN1]], [[SELECT]] -; CHECK-NEXT: ret half [[DIV]] +; CHECK-NEXT: ret half 0xH7E00 ; %select = select i1 %cond, half %unknown0, half %only.sub %div = fdiv half %unknown1, %select @@ -2270,9 +2257,7 @@ define nofpclass(inf norm sub zero) half @nan_result_demands_subnorm_rhs__ieee(i define nofpclass(inf norm sub zero) half @nan_result_demands_subnorm_lhs__daz(i1 %cond, half nofpclass(nan inf zero norm) %only.sub, half %unknown0, half %unknown1) #2 { ; CHECK-LABEL: define nofpclass(inf zero sub norm) half @nan_result_demands_subnorm_lhs__daz( ; CHECK-SAME: i1 [[COND:%.*]], half nofpclass(nan inf zero norm) [[ONLY_SUB:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) #[[ATTR0]] { -; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[UNKNOWN0]], half [[ONLY_SUB]] -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[SELECT]], [[UNKNOWN1]] -; CHECK-NEXT: ret half [[DIV]] +; CHECK-NEXT: ret half 0xH7E00 ; %select = select i1 %cond, half %unknown0, half %only.sub %div = fdiv half %select, %unknown1 @@ -2282,9 +2267,7 @@ define nofpclass(inf norm sub zero) half @nan_result_demands_subnorm_lhs__daz(i1 define nofpclass(inf norm sub zero) half @nan_result_demands_subnorm_rhs__daz(i1 %cond, half nofpclass(nan inf zero norm) %only.sub, half %unknown0, half %unknown1) #2 { ; CHECK-LABEL: define nofpclass(inf zero sub norm) half @nan_result_demands_subnorm_rhs__daz( ; CHECK-SAME: i1 [[COND:%.*]], half nofpclass(nan inf zero norm) [[ONLY_SUB:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) #[[ATTR0]] { -; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[UNKNOWN0]], half [[ONLY_SUB]] -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[UNKNOWN1]], [[SELECT]] -; CHECK-NEXT: ret half [[DIV]] +; CHECK-NEXT: ret half 0xH7E00 ; %select = select i1 %cond, half %unknown0, half %only.sub %div = fdiv half %unknown1, %select @@ -2294,9 +2277,7 @@ define nofpclass(inf norm sub zero) half @nan_result_demands_subnorm_rhs__daz(i1 define nofpclass(inf norm sub zero) half @nan_result_demands_subnorm_lhs__dynamic(i1 %cond, half nofpclass(nan inf zero norm) %only.sub, half %unknown0, half %unknown1) #3 { ; CHECK-LABEL: define nofpclass(inf zero sub norm) half @nan_result_demands_subnorm_lhs__dynamic( ; CHECK-SAME: i1 [[COND:%.*]], half nofpclass(nan inf zero norm) [[ONLY_SUB:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) #[[ATTR3]] { -; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[UNKNOWN0]], half [[ONLY_SUB]] -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[SELECT]], [[UNKNOWN1]] -; CHECK-NEXT: ret half [[DIV]] +; CHECK-NEXT: ret half 0xH7E00 ; %select = select i1 %cond, half %unknown0, half %only.sub %div = fdiv half %select, %unknown1 @@ -2306,9 +2287,7 @@ define nofpclass(inf norm sub zero) half @nan_result_demands_subnorm_lhs__dynami define nofpclass(inf norm sub zero) half @nan_result_demands_subnorm_rhs__dynamic(i1 %cond, half nofpclass(nan inf zero norm) %only.sub, half %unknown0, half %unknown1) #3 { ; CHECK-LABEL: define nofpclass(inf zero sub norm) half @nan_result_demands_subnorm_rhs__dynamic( ; CHECK-SAME: i1 [[COND:%.*]], half nofpclass(nan inf zero norm) [[ONLY_SUB:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) #[[ATTR3]] { -; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[UNKNOWN0]], half [[ONLY_SUB]] -; CHECK-NEXT: [[DIV:%.*]] = fdiv half [[UNKNOWN1]], [[SELECT]] -; CHECK-NEXT: ret half [[DIV]] +; CHECK-NEXT: ret half 0xH7E00 ; %select = select i1 %cond, half %unknown0, half %only.sub %div = fdiv half %unknown1, %select _______________________________________________ llvm-branch-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
