diff --git a/llvm/include/llvm/Analysis/ValueTracking.h b/llvm/include/llvm/Analysis/ValueTracking.h index 695f2fecae885..bc571a702f717 100644 --- a/llvm/include/llvm/Analysis/ValueTracking.h +++ b/llvm/include/llvm/Analysis/ValueTracking.h @@ -235,6 +235,40 @@ std::pair fcmpToClassTest(CmpInst::Predicate Pred, const APFloat *ConstRHS, bool LookThroughSrc = true); +/// Compute the possible floating-point classes that \p LHS could be based on +/// fcmp \Pred \p LHS, \p RHS. +/// +/// Returns { TestedValue, ClassesIfTrue, ClassesIfFalse } +/// +/// If the compare returns an exact class test, ClassesIfTrue == ~ClassesIfFalse +/// +/// This is a less exact version of fcmpToClassTest (e.g. fcmpToClassTest will +/// only succeed for a test of x > 0 implies positive, but not x > 1). +/// +/// If \p LookThroughSrc is true, consider the input value when computing the +/// mask. This may look through sign bit operations. +/// +/// If \p LookThroughSrc is false, ignore the source value (i.e. the first pair +/// element will always be LHS. +/// +std::tuple +fcmpImpliesClass(CmpInst::Predicate Pred, const Function &F, Value *LHS, + Value *RHS, bool LookThroughSrc = true); +std::tuple +fcmpImpliesClass(CmpInst::Predicate Pred, const Function &F, Value *LHS, + FPClassTest RHS, bool LookThroughSrc = true); +std::tuple +fcmpImpliesClass(CmpInst::Predicate Pred, const Function &F, Value *LHS, + const APFloat &RHS, bool LookThroughSrc = true); + +#if 0 +inline std::tuple +fcmpImpliesClass(CmpInst::Predicate Pred, const Function &F, Value *LHS, + const APFloat &RHS, bool LookThroughSrc = true) { + return fcmpImpliesClass(Pred, F, LHS, RHS.classify(), LookThroughSrc); +} +#endif + struct KnownFPClass { /// Floating-point classes the value could be one of. FPClassTest KnownFPClasses = fcAllFlags; diff --git a/llvm/lib/Analysis/ValueTracking.cpp b/llvm/lib/Analysis/ValueTracking.cpp index c4153b824c37e..ccacc75d50c67 100644 --- a/llvm/lib/Analysis/ValueTracking.cpp +++ b/llvm/lib/Analysis/ValueTracking.cpp @@ -4016,67 +4016,106 @@ std::pair llvm::fcmpToClassTest(FCmpInst::Predicate Pred, std::pair llvm::fcmpToClassTest(FCmpInst::Predicate Pred, const Function &F, Value *LHS, const APFloat *ConstRHS, bool LookThroughSrc) { + + auto [Src, ClassIfTrue, ClassIfFalse] = fcmpImpliesClass(Pred, + F, + LHS, + *ConstRHS, LookThroughSrc); + if (Src && ClassIfTrue == ~ClassIfFalse) + return {Src, ClassIfTrue}; + return {nullptr, fcAllFlags}; +} + +/// Return the return value for fcmpImpliesClass for a compare that produces an +/// exact class test. +static std::tuple +exactClass(Value *V, FPClassTest M) { + return {V, M, ~M}; +} + +std::tuple +llvm::fcmpImpliesClass(CmpInst::Predicate Pred, const Function &F, Value *LHS, + FPClassTest RHSClass, bool LookThroughSrc) { + assert(RHSClass != fcNone); + + FPClassTest OrigClass = RHSClass; + + Value *Src = LHS; + const bool IsNegativeRHS = (RHSClass & fcNegative) == RHSClass; + const bool IsPositiveRHS = (RHSClass & fcPositive) == RHSClass; + const bool IsNaN = (RHSClass & ~fcNan) == fcNone; + + if (IsNaN) { + // fcmp o__ x, nan -> false + // fcmp u__ x, nan -> true + return exactClass(Src, CmpInst::isOrdered(Pred) ? fcNone : fcAllFlags); + } + // fcmp ord x, zero|normal|subnormal|inf -> ~fcNan - if (Pred == FCmpInst::FCMP_ORD && !ConstRHS->isNaN()) - return {LHS, ~fcNan}; + if (Pred == FCmpInst::FCMP_ORD) + return {Src, ~fcNan, fcNan}; // fcmp uno x, zero|normal|subnormal|inf -> fcNan - if (Pred == FCmpInst::FCMP_UNO && !ConstRHS->isNaN()) - return {LHS, fcNan}; + if (Pred == FCmpInst::FCMP_UNO) + return {Src, fcNan, ~fcNan}; - if (ConstRHS->isZero()) { + const bool IsFabs = LookThroughSrc && match(LHS, m_FAbs(m_Value(Src))); + if (IsFabs) + RHSClass = llvm::fneg(RHSClass); + + const bool IsZero = (RHSClass & fcZero) == RHSClass; + if (IsZero) { // Compares with fcNone are only exactly equal to fcZero if input denormals // are not flushed. // TODO: Handle DAZ by expanding masks to cover subnormal cases. if (Pred != FCmpInst::FCMP_ORD && Pred != FCmpInst::FCMP_UNO && !inputDenormalIsIEEE(F, LHS->getType())) - return {nullptr, fcNone}; + return {nullptr, fcAllFlags, fcAllFlags}; switch (Pred) { case FCmpInst::FCMP_OEQ: // Match x == 0.0 - return {LHS, fcZero}; + return exactClass(Src, fcZero); case FCmpInst::FCMP_UEQ: // Match isnan(x) || (x == 0.0) - return {LHS, fcZero | fcNan}; + return exactClass(Src, fcZero | fcNan); case FCmpInst::FCMP_UNE: // Match (x != 0.0) - return {LHS, ~fcZero}; + return exactClass(Src, ~fcZero); case FCmpInst::FCMP_ONE: // Match !isnan(x) && x != 0.0 - return {LHS, ~fcNan & ~fcZero}; + return exactClass(Src, ~fcNan & ~fcZero); case FCmpInst::FCMP_ORD: // Canonical form of ord/uno is with a zero. We could also handle // non-canonical other non-NaN constants or LHS == RHS. - return {LHS, ~fcNan}; + return exactClass(Src, ~fcNan); case FCmpInst::FCMP_UNO: - return {LHS, fcNan}; + return exactClass(Src, fcNan); case FCmpInst::FCMP_OGT: // x > 0 - return {LHS, fcPosSubnormal | fcPosNormal | fcPosInf}; + return exactClass(Src, fcPosSubnormal | fcPosNormal | fcPosInf); case FCmpInst::FCMP_UGT: // isnan(x) || x > 0 - return {LHS, fcPosSubnormal | fcPosNormal | fcPosInf | fcNan}; + return exactClass(Src, fcPosSubnormal | fcPosNormal | fcPosInf | fcNan); case FCmpInst::FCMP_OGE: // x >= 0 - return {LHS, fcPositive | fcNegZero}; + return exactClass(Src, fcPositive | fcNegZero); case FCmpInst::FCMP_UGE: // isnan(x) || x >= 0 - return {LHS, fcPositive | fcNegZero | fcNan}; + return exactClass(Src, fcPositive | fcNegZero | fcNan); case FCmpInst::FCMP_OLT: // x < 0 - return {LHS, fcNegSubnormal | fcNegNormal | fcNegInf}; + return exactClass(Src, fcNegSubnormal | fcNegNormal | fcNegInf); case FCmpInst::FCMP_ULT: // isnan(x) || x < 0 - return {LHS, fcNegSubnormal | fcNegNormal | fcNegInf | fcNan}; + return exactClass(Src, fcNegSubnormal | fcNegNormal | fcNegInf | fcNan); case FCmpInst::FCMP_OLE: // x <= 0 - return {LHS, fcNegative | fcPosZero}; + return exactClass(Src, fcNegative | fcPosZero); case FCmpInst::FCMP_ULE: // isnan(x) || x <= 0 - return {LHS, fcNegative | fcPosZero | fcNan}; + return exactClass(Src, fcNegative | fcPosZero | fcNan); default: break; } - return {nullptr, fcNone}; + return {nullptr, fcAllFlags, fcAllFlags}; } - Value *Src = LHS; - const bool IsFabs = LookThroughSrc && match(LHS, m_FAbs(m_Value(Src))); + const bool IsDenormalRHS = (RHSClass & fcSubnormal) == RHSClass; - // Compute the test mask that would return true for the ordered comparisons. - FPClassTest Mask; + const bool IsInf = (RHSClass & fcInf) == RHSClass; + if (IsInf) { + FPClassTest Mask = fcAllFlags; - if (ConstRHS->isInfinity()) { switch (Pred) { case FCmpInst::FCMP_OEQ: case FCmpInst::FCMP_UNE: { @@ -4091,8 +4130,7 @@ llvm::fcmpToClassTest(FCmpInst::Predicate Pred, const Function &F, Value *LHS, // fcmp une fabs(x), +inf -> is_fpclass x, ~fcInf // fcmp une x, -inf -> is_fpclass x, ~fcNegInf // fcmp une fabs(x), -inf -> is_fpclass x, fcAllFlags -> true - - if (ConstRHS->isNegative()) { + if (IsNegativeRHS) { Mask = fcNegInf; if (IsFabs) Mask = fcNone; @@ -4101,7 +4139,6 @@ llvm::fcmpToClassTest(FCmpInst::Predicate Pred, const Function &F, Value *LHS, if (IsFabs) Mask |= fcNegInf; } - break; } case FCmpInst::FCMP_ONE: @@ -4116,7 +4153,7 @@ llvm::fcmpToClassTest(FCmpInst::Predicate Pred, const Function &F, Value *LHS, // fcmp ueq (fabs x), +inf -> is_fpclass x, fcInf|fcNan // fcmp ueq x, -inf -> is_fpclass x, fcNegInf|fcNan // fcmp ueq fabs(x), -inf -> is_fpclass x, fcNan - if (ConstRHS->isNegative()) { + if (IsNegativeRHS) { Mask = ~fcNegInf & ~fcNan; if (IsFabs) Mask = ~fcNan; @@ -4130,7 +4167,7 @@ llvm::fcmpToClassTest(FCmpInst::Predicate Pred, const Function &F, Value *LHS, } case FCmpInst::FCMP_OLT: case FCmpInst::FCMP_UGE: { - if (ConstRHS->isNegative()) { + if (IsNegativeRHS) { // No value is ordered and less than negative infinity. // All values are unordered with or at least negative infinity. // fcmp olt x, -inf -> false @@ -4150,8 +4187,8 @@ llvm::fcmpToClassTest(FCmpInst::Predicate Pred, const Function &F, Value *LHS, } case FCmpInst::FCMP_OGE: case FCmpInst::FCMP_ULT: { - if (ConstRHS->isNegative()) // TODO - return {nullptr, fcNone}; + if (IsNegativeRHS) // TODO + return {nullptr, fcAllFlags, fcAllFlags}; // fcmp oge fabs(x), +inf -> fcInf // fcmp oge x, +inf -> fcPosInf @@ -4164,17 +4201,138 @@ llvm::fcmpToClassTest(FCmpInst::Predicate Pred, const Function &F, Value *LHS, } case FCmpInst::FCMP_OGT: case FCmpInst::FCMP_ULE: { - if (ConstRHS->isNegative()) - return {nullptr, fcNone}; + if (IsNegativeRHS) + return {nullptr, fcAllFlags, fcAllFlags}; // No value is ordered and greater than infinity. Mask = fcNone; break; } default: - return {nullptr, fcNone}; + return {nullptr, fcAllFlags, fcAllFlags}; + } + + // Invert the comparison for the unordered cases. + if (FCmpInst::isUnordered(Pred)) + Mask = ~Mask; + + return exactClass(Src, Mask); + } + + if (Pred == FCmpInst::FCMP_OEQ) { + return {Src, RHSClass, fcAllFlags}; + + if (Pred == FCmpInst::FCMP_UEQ) { + FPClassTest Class = RHSClass | fcNan; + return {Src, Class, ~fcNan}; + } + + if (Pred == FCmpInst::FCMP_ONE) + return {Src, ~fcNan, RHSClass}; + + if (Pred == FCmpInst::FCMP_UNE) + return {Src, fcAllFlags, RHSClass}; + + assert((RHSClass == fcPosNormal || RHSClass == fcNegNormal || RHSClass == fcNormal || + RHSClass == fcPosSubnormal || RHSClass == fcNegSubnormal || RHSClass == fcSubnormal) && + "should have been recognized as an exact class test"); + + if (IsNegativeRHS) { + // TODO: Handle fneg(fabs) + if (IsFabs) { + // fabs(x) o> -k -> fcmp ord x, x + // fabs(x) u> -k -> true + // fabs(x) o< -k -> false + // fabs(x) u< -k -> fcmp uno x, x + switch (Pred) { + case FCmpInst::FCMP_OGT: + case FCmpInst::FCMP_OGE: + return {Src, ~fcNan, fcNan}; + case FCmpInst::FCMP_UGT: + case FCmpInst::FCMP_UGE: + return {Src, fcAllFlags, fcNone}; + case FCmpInst::FCMP_OLT: + case FCmpInst::FCMP_OLE: + return {Src, fcNone, fcAllFlags}; + case FCmpInst::FCMP_ULT: + case FCmpInst::FCMP_ULE: + return {Src, fcNan, ~fcNan}; + default: + break; + } + + return {nullptr, fcAllFlags, fcAllFlags}; + } + + FPClassTest ClassesLE = fcNegInf | fcNegNormal; + FPClassTest ClassesGE = fcPositive | fcNegZero | fcNegSubnormal; + + if (IsDenormalRHS) + ClassesLE |= fcNegSubnormal; + else + ClassesGE |= fcNegNormal; + + switch (Pred) { + case FCmpInst::FCMP_OGT: + case FCmpInst::FCMP_OGE: + return {Src, ClassesGE, ~ClassesGE | RHSClass}; + case FCmpInst::FCMP_UGT: + case FCmpInst::FCMP_UGE: + return {Src, ClassesGE | fcNan, ~(ClassesGE | fcNan) | RHSClass}; + case FCmpInst::FCMP_OLT: + case FCmpInst::FCMP_OLE: + return {Src, ClassesLE, ~ClassesLE | RHSClass}; + case FCmpInst::FCMP_ULT: + case FCmpInst::FCMP_ULE: + return {Src, ClassesLE | fcNan, ~(ClassesLE | fcNan) | RHSClass}; + default: + break; + } + } else if (IsPositiveRHS) { + FPClassTest ClassesGE = fcPosNormal | fcPosInf; + FPClassTest ClassesLE = fcNegative | fcPosZero | fcPosNormal; + if (IsDenormalRHS) + ClassesGE |= fcPosNormal; + else + ClassesLE |= fcPosSubnormal; + + FPClassTest FalseClasses = RHSClass; + if (IsFabs) { + ClassesGE = llvm::inverse_fabs(ClassesGE); + ClassesLE = llvm::inverse_fabs(ClassesLE); + } + + switch (Pred) { + case FCmpInst::FCMP_OGT: + case FCmpInst::FCMP_OGE: + return {Src, ClassesGE, ~ClassesGE | FalseClasses}; + case FCmpInst::FCMP_UGT: + case FCmpInst::FCMP_UGE: + return {Src, ClassesGE | fcNan, ~(ClassesGE | fcNan) | FalseClasses}; + case FCmpInst::FCMP_OLT: + case FCmpInst::FCMP_OLE: + return {Src, ClassesLE, ~ClassesLE | FalseClasses}; + case FCmpInst::FCMP_ULT: + case FCmpInst::FCMP_ULE: + return {Src, ClassesLE | fcNan, ~(ClassesLE | fcNan) | FalseClasses}; + default: + break; } - } else if (ConstRHS->isSmallestNormalized() && !ConstRHS->isNegative()) { + } + + return {nullptr, fcAllFlags, fcAllFlags}; +} + +std::tuple +llvm::fcmpImpliesClass(CmpInst::Predicate Pred, const Function &F, Value *LHS, + const APFloat &ConstRHS, bool LookThroughSrc) { + // We can refine checks against smallest normal / largest denormal to an + // exact class test. + if (!ConstRHS.isNegative() && ConstRHS.isSmallestNormalized()) { + Value *Src = LHS; + const bool IsFabs = LookThroughSrc && match(LHS, m_FAbs(m_Value(Src))); + + FPClassTest Mask; // Match pattern that's used in __builtin_isnormal. switch (Pred) { case FCmpInst::FCMP_OLT: @@ -4201,20 +4359,28 @@ llvm::fcmpToClassTest(FCmpInst::Predicate Pred, const Function &F, Value *LHS, break; } default: - return {nullptr, fcNone}; + // xxx - am i tested + return {nullptr, fcAllFlags, fcAllFlags}; + return fcmpImpliesClass(Pred, F, LHS, ConstRHS.classify(), LookThroughSrc); } - } else if (ConstRHS->isNaN()) { - // fcmp o__ x, nan -> false - // fcmp u__ x, nan -> true - Mask = fcNone; - } else - return {nullptr, fcNone}; - // Invert the comparison for the unordered cases. - if (FCmpInst::isUnordered(Pred)) - Mask = ~Mask; + // Invert the comparison for the unordered cases. + if (FCmpInst::isUnordered(Pred)) + Mask = ~Mask; - return {Src, Mask}; + return exactClass(Src, Mask); + } + + return fcmpImpliesClass(Pred, F, LHS, ConstRHS.classify(), LookThroughSrc); +} + +std::tuple +llvm::fcmpImpliesClass(CmpInst::Predicate Pred, const Function &F, Value *LHS, + Value *RHS, bool LookThroughSrc) { + const APFloat *ConstRHS; + if (!match(RHS, m_APFloatAllowUndef(ConstRHS))) + return {nullptr, fcAllFlags, fcNone}; + return fcmpImpliesClass(Pred, F, LHS, *ConstRHS, LookThroughSrc); } static FPClassTest computeKnownFPClassFromAssumes(const Value *V, @@ -4241,18 +4407,22 @@ static FPClassTest computeKnownFPClassFromAssumes(const Value *V, Value *LHS, *RHS; uint64_t ClassVal = 0; if (match(I->getArgOperand(0), m_FCmp(Pred, m_Value(LHS), m_Value(RHS)))) { - auto [TestedValue, TestedMask] = - fcmpToClassTest(Pred, *F, LHS, RHS, true); - // First see if we can fold in fabs/fneg into the test. - if (TestedValue == V) - KnownFromAssume &= TestedMask; - else { - // Try again without the lookthrough if we found a different source - // value. - auto [TestedValue, TestedMask] = - fcmpToClassTest(Pred, *F, LHS, RHS, false); - if (TestedValue == V) - KnownFromAssume &= TestedMask; + const APFloat *CRHS; + if (match(RHS, m_APFloat(CRHS))) { + // First see if we can fold in fabs/fneg into the test. + auto [CmpVal, MaskIfTrue, MaskIfFalse] = + fcmpImpliesClass(Pred, *F, LHS, *CRHS, true); + if (CmpVal == V) + KnownFromAssume &= (MaskIfTrue & ~MaskIfFalse); + + else { + // Try again without the lookthrough if we found a different source + // value. + auto [CmpVal, MaskIfTrue, MaskIfFalse] = + fcmpImpliesClass(Pred, *F, LHS, *CRHS, false); + if (CmpVal == V) + KnownFromAssume &= (MaskIfTrue & ~MaskIfFalse); + } } } else if (match(I->getArgOperand(0), m_Intrinsic( @@ -4400,7 +4570,8 @@ void computeKnownFPClass(const Value *V, const APInt &DemandedElts, FPClassTest FilterRHS = fcAllFlags; Value *TestedValue = nullptr; - FPClassTest TestedMask = fcNone; + FPClassTest MaskIfTrue = fcAllFlags; + FPClassTest MaskIfFalse = fcAllFlags; uint64_t ClassVal = 0; const Function *F = cast(Op)->getFunction(); CmpInst::Predicate Pred; @@ -4412,20 +4583,22 @@ void computeKnownFPClass(const Value *V, const APInt &DemandedElts, // TODO: In some degenerate cases we can infer something if we try again // without looking through sign operations. bool LookThroughFAbsFNeg = CmpLHS != LHS && CmpLHS != RHS; - std::tie(TestedValue, TestedMask) = - fcmpToClassTest(Pred, *F, CmpLHS, CmpRHS, LookThroughFAbsFNeg); + std::tie(TestedValue, MaskIfTrue, MaskIfFalse) = + fcmpImpliesClass(Pred, *F, CmpLHS, CmpRHS, LookThroughFAbsFNeg); } else if (match(Cond, m_Intrinsic( m_Value(TestedValue), m_ConstantInt(ClassVal)))) { - TestedMask = static_cast(ClassVal); + FPClassTest TestedMask = static_cast(ClassVal); + MaskIfTrue = TestedMask; + MaskIfFalse = ~TestedMask; } if (TestedValue == LHS) { // match !isnan(x) ? x : y - FilterLHS = TestedMask; - } else if (TestedValue == RHS) { + FilterLHS = MaskIfTrue; + } else if (TestedValue == RHS) { // && IsExactClass // match !isnan(x) ? y : x - FilterRHS = ~TestedMask; + FilterRHS = MaskIfFalse; } KnownFPClass Known2; diff --git a/llvm/lib/Target/AMDGPU/AMDGPULegalizerInfo.cpp b/llvm/lib/Target/AMDGPU/AMDGPULegalizerInfo.cpp index 421fc41ad3b62..e20f4adeab33d 100644 --- a/llvm/lib/Target/AMDGPU/AMDGPULegalizerInfo.cpp +++ b/llvm/lib/Target/AMDGPU/AMDGPULegalizerInfo.cpp @@ -1931,7 +1931,7 @@ AMDGPULegalizerInfo::AMDGPULegalizerInfo(const GCNSubtarget &ST_, .scalarize(0); getActionDefinitionsBuilder({ - // TODO: Verify V_BFI_B32 is generated from expanded bit ops + // TODO: Verify V_BFI_B32 is generated from expanded bit ops (it's not) G_FCOPYSIGN, G_ATOMIC_CMPXCHG_WITH_SUCCESS, diff --git a/llvm/test/Transforms/Attributor/nofpclass-implied-by-fcmp.ll b/llvm/test/Transforms/Attributor/nofpclass-implied-by-fcmp.ll index 396b8c84fc898..f75d575f8f55f 100644 --- a/llvm/test/Transforms/Attributor/nofpclass-implied-by-fcmp.ll +++ b/llvm/test/Transforms/Attributor/nofpclass-implied-by-fcmp.ll @@ -11,7 +11,7 @@ declare void @llvm.assume(i1 noundef) ; can't be +inf define float @clamp_is_ogt_1_to_1(float %arg) { -; CHECK-LABEL: define float @clamp_is_ogt_1_to_1( +; CHECK-LABEL: define nofpclass(pinf) float @clamp_is_ogt_1_to_1( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2:[0-9]+]] { ; CHECK-NEXT: [[IS_OGT_1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OGT_1]], float 1.000000e+00, float [[ARG]] @@ -23,7 +23,7 @@ define float @clamp_is_ogt_1_to_1(float %arg) { } define float @clamp_is_ogt_1_to_1_commute(float %arg) { -; CHECK-LABEL: define float @clamp_is_ogt_1_to_1_commute( +; CHECK-LABEL: define nofpclass(pinf) float @clamp_is_ogt_1_to_1_commute( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_ULE_1:%.*]] = fcmp ule float [[ARG]], 1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ULE_1]], float [[ARG]], float 1.000000e+00 @@ -36,7 +36,7 @@ define float @clamp_is_ogt_1_to_1_commute(float %arg) { ; can't be +inf or nan define float @clamp_is_ugt_1_to_1(float %arg) { -; CHECK-LABEL: define float @clamp_is_ugt_1_to_1( +; CHECK-LABEL: define nofpclass(nan pinf) float @clamp_is_ugt_1_to_1( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_UGT_1:%.*]] = fcmp ugt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UGT_1]], float 1.000000e+00, float [[ARG]] @@ -49,7 +49,7 @@ define float @clamp_is_ugt_1_to_1(float %arg) { ; can't be +inf or nan define float @clamp_is_ugt_1_to_1_commute(float %arg) { -; CHECK-LABEL: define float @clamp_is_ugt_1_to_1_commute( +; CHECK-LABEL: define nofpclass(nan pinf) float @clamp_is_ugt_1_to_1_commute( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_OLE_1:%.*]] = fcmp ole float [[ARG]], 1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OLE_1]], float [[ARG]], float 1.000000e+00 @@ -62,7 +62,7 @@ define float @clamp_is_ugt_1_to_1_commute(float %arg) { ; can't be +inf define float @clamp_is_oge_1_to_1(float %arg) { -; CHECK-LABEL: define float @clamp_is_oge_1_to_1( +; CHECK-LABEL: define nofpclass(pinf) float @clamp_is_oge_1_to_1( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_OGE_1:%.*]] = fcmp oge float [[ARG]], 1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OGE_1]], float 1.000000e+00, float [[ARG]] @@ -74,7 +74,7 @@ define float @clamp_is_oge_1_to_1(float %arg) { } define float @clamp_is_oge_1_to_1_commute(float %arg) { -; CHECK-LABEL: define float @clamp_is_oge_1_to_1_commute( +; CHECK-LABEL: define nofpclass(pinf) float @clamp_is_oge_1_to_1_commute( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_ULT_1:%.*]] = fcmp ult float [[ARG]], 1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ULT_1]], float [[ARG]], float 1.000000e+00 @@ -87,7 +87,7 @@ define float @clamp_is_oge_1_to_1_commute(float %arg) { ; can't be +inf or nan define float @clamp_is_uge_1_to_1(float %arg) { -; CHECK-LABEL: define float @clamp_is_uge_1_to_1( +; CHECK-LABEL: define nofpclass(nan pinf) float @clamp_is_uge_1_to_1( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_UGT_1:%.*]] = fcmp uge float [[ARG]], 1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UGT_1]], float 1.000000e+00, float [[ARG]] @@ -100,7 +100,7 @@ define float @clamp_is_uge_1_to_1(float %arg) { ; can't be negative, zero, or denormal define float @clamp_is_olt_1_to_1(float %arg) { -; CHECK-LABEL: define float @clamp_is_olt_1_to_1( +; CHECK-LABEL: define nofpclass(ninf zero sub nnorm) float @clamp_is_olt_1_to_1( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_OLT_1:%.*]] = fcmp olt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OLT_1]], float 1.000000e+00, float [[ARG]] @@ -113,7 +113,7 @@ define float @clamp_is_olt_1_to_1(float %arg) { ; can't be negative, zero, or denormal define float @clamp_is_olt_1_to_1_commute(float %arg) { -; CHECK-LABEL: define float @clamp_is_olt_1_to_1_commute( +; CHECK-LABEL: define nofpclass(ninf zero sub nnorm) float @clamp_is_olt_1_to_1_commute( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_UGE_1:%.*]] = fcmp uge float [[ARG]], 1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UGE_1]], float [[ARG]], float 1.000000e+00 @@ -126,7 +126,7 @@ define float @clamp_is_olt_1_to_1_commute(float %arg) { ; can't be negative or zero, nan or denormal define float @clamp_is_ult_1_to_1(float %arg) { -; CHECK-LABEL: define float @clamp_is_ult_1_to_1( +; CHECK-LABEL: define nofpclass(nan ninf zero sub nnorm) float @clamp_is_ult_1_to_1( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_ULT_1:%.*]] = fcmp ult float [[ARG]], 1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ULT_1]], float 1.000000e+00, float [[ARG]] @@ -139,7 +139,7 @@ define float @clamp_is_ult_1_to_1(float %arg) { ; can't be negative or zero, nan or denormal define float @clamp_is_ult_1_to_1_commute(float %arg) { -; CHECK-LABEL: define float @clamp_is_ult_1_to_1_commute( +; CHECK-LABEL: define nofpclass(nan ninf zero sub nnorm) float @clamp_is_ult_1_to_1_commute( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_OGE_1:%.*]] = fcmp oge float [[ARG]], 1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OGE_1]], float [[ARG]], float 1.000000e+00 @@ -152,7 +152,7 @@ define float @clamp_is_ult_1_to_1_commute(float %arg) { ; can't be negative, zero or denormal define float @clamp_is_ole_1_to_1(float %arg) { -; CHECK-LABEL: define float @clamp_is_ole_1_to_1( +; CHECK-LABEL: define nofpclass(ninf zero sub nnorm) float @clamp_is_ole_1_to_1( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_OLE_1:%.*]] = fcmp ole float [[ARG]], 1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OLE_1]], float 1.000000e+00, float [[ARG]] @@ -165,7 +165,7 @@ define float @clamp_is_ole_1_to_1(float %arg) { ; can't be negative or zero, nan or denormal define float @clamp_is_ule_1_to_1(float %arg) { -; CHECK-LABEL: define float @clamp_is_ule_1_to_1( +; CHECK-LABEL: define nofpclass(nan ninf zero sub nnorm) float @clamp_is_ule_1_to_1( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_ULE_1:%.*]] = fcmp ule float [[ARG]], 1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ULE_1]], float 1.000000e+00, float [[ARG]] @@ -178,7 +178,7 @@ define float @clamp_is_ule_1_to_1(float %arg) { ; can't be negative or denormal define float @clamp_is_olt_1_to_0(float %arg) { -; CHECK-LABEL: define float @clamp_is_olt_1_to_0( +; CHECK-LABEL: define nofpclass(ninf nzero sub nnorm) float @clamp_is_olt_1_to_0( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_OLT_1:%.*]] = fcmp olt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OLT_1]], float 0.000000e+00, float [[ARG]] @@ -191,7 +191,7 @@ define float @clamp_is_olt_1_to_0(float %arg) { ; can't be negative, nan or denormal define float @clamp_is_ult_1_to_0(float %arg) { -; CHECK-LABEL: define float @clamp_is_ult_1_to_0( +; CHECK-LABEL: define nofpclass(ninf nzero sub nnorm) float @clamp_is_ult_1_to_0( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_ULT_1:%.*]] = fcmp olt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ULT_1]], float 0.000000e+00, float [[ARG]] @@ -204,7 +204,7 @@ define float @clamp_is_ult_1_to_0(float %arg) { ; can't be negative or denormal define float @clamp_is_ole_1_to_0(float %arg) { -; CHECK-LABEL: define float @clamp_is_ole_1_to_0( +; CHECK-LABEL: define nofpclass(ninf nzero sub nnorm) float @clamp_is_ole_1_to_0( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_OLE_1:%.*]] = fcmp ole float [[ARG]], 1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OLE_1]], float 0.000000e+00, float [[ARG]] @@ -217,7 +217,7 @@ define float @clamp_is_ole_1_to_0(float %arg) { ; can't be negative or denormal define float @clamp_is_ole_1_to_0_commute(float %arg) { -; CHECK-LABEL: define float @clamp_is_ole_1_to_0_commute( +; CHECK-LABEL: define nofpclass(ninf nzero sub nnorm) float @clamp_is_ole_1_to_0_commute( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_UGT_1:%.*]] = fcmp ugt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UGT_1]], float [[ARG]], float 0.000000e+00 @@ -230,7 +230,7 @@ define float @clamp_is_ole_1_to_0_commute(float %arg) { ; can't be negative or denormal define float @clamp_is_ule_1_to_0(float %arg) { -; CHECK-LABEL: define float @clamp_is_ule_1_to_0( +; CHECK-LABEL: define nofpclass(ninf nzero sub nnorm) float @clamp_is_ule_1_to_0( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_ULE_1:%.*]] = fcmp ole float [[ARG]], 1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ULE_1]], float 0.000000e+00, float [[ARG]] @@ -243,7 +243,7 @@ define float @clamp_is_ule_1_to_0(float %arg) { ; can't be positive, zero or denormal define float @clamp_is_ogt_neg1_to_neg1(float %arg) { -; CHECK-LABEL: define float @clamp_is_ogt_neg1_to_neg1( +; CHECK-LABEL: define nofpclass(pinf zero sub pnorm) float @clamp_is_ogt_neg1_to_neg1( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_OGT_NEG1:%.*]] = fcmp ogt float [[ARG]], -1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OGT_NEG1]], float -1.000000e+00, float [[ARG]] @@ -256,7 +256,7 @@ define float @clamp_is_ogt_neg1_to_neg1(float %arg) { ; can't be positive, zero, nan or denormal define float @clamp_is_ugt_neg1_to_neg1(float %arg) { -; CHECK-LABEL: define float @clamp_is_ugt_neg1_to_neg1( +; CHECK-LABEL: define nofpclass(nan pinf zero sub pnorm) float @clamp_is_ugt_neg1_to_neg1( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_UGT_NEG1:%.*]] = fcmp ugt float [[ARG]], -1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UGT_NEG1]], float -1.000000e+00, float [[ARG]] @@ -269,7 +269,7 @@ define float @clamp_is_ugt_neg1_to_neg1(float %arg) { ; can't be positive or denormal define float @clamp_is_ogt_neg1_to_0(float %arg) { -; CHECK-LABEL: define float @clamp_is_ogt_neg1_to_0( +; CHECK-LABEL: define nofpclass(pinf nzero sub pnorm) float @clamp_is_ogt_neg1_to_0( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_OGT_NEG1:%.*]] = fcmp ogt float [[ARG]], -1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OGT_NEG1]], float 0.000000e+00, float [[ARG]] @@ -282,7 +282,7 @@ define float @clamp_is_ogt_neg1_to_0(float %arg) { ; can't be positive, nan or denormal define float @clamp_is_ugt_neg1_to_0(float %arg) { -; CHECK-LABEL: define float @clamp_is_ugt_neg1_to_0( +; CHECK-LABEL: define nofpclass(nan pinf nzero sub pnorm) float @clamp_is_ugt_neg1_to_0( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_UGT_NEG1:%.*]] = fcmp ugt float [[ARG]], -1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UGT_NEG1]], float 0.000000e+00, float [[ARG]] @@ -295,7 +295,7 @@ define float @clamp_is_ugt_neg1_to_0(float %arg) { ; can't be -inf define float @clamp_is_olt_neg1_to_neg1_commute(float %arg) { -; CHECK-LABEL: define float @clamp_is_olt_neg1_to_neg1_commute( +; CHECK-LABEL: define nofpclass(ninf) float @clamp_is_olt_neg1_to_neg1_commute( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_UGE_NEG1:%.*]] = fcmp uge float [[ARG]], -1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UGE_NEG1]], float [[ARG]], float -1.000000e+00 @@ -308,7 +308,7 @@ define float @clamp_is_olt_neg1_to_neg1_commute(float %arg) { ; can't be -inf define float @clamp_is_olt_neg1_to_neg1(float %arg) { -; CHECK-LABEL: define float @clamp_is_olt_neg1_to_neg1( +; CHECK-LABEL: define nofpclass(ninf) float @clamp_is_olt_neg1_to_neg1( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OLT_NEG1]], float -1.000000e+00, float [[ARG]] @@ -321,7 +321,7 @@ define float @clamp_is_olt_neg1_to_neg1(float %arg) { ; can't be -inf or nan define float @clamp_is_ult_neg1_to_neg1(float %arg) { -; CHECK-LABEL: define float @clamp_is_ult_neg1_to_neg1( +; CHECK-LABEL: define nofpclass(nan ninf) float @clamp_is_ult_neg1_to_neg1( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_ULT_NEG1:%.*]] = fcmp ult float [[ARG]], -1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ULT_NEG1]], float -1.000000e+00, float [[ARG]] @@ -334,7 +334,7 @@ define float @clamp_is_ult_neg1_to_neg1(float %arg) { ; can't be -inf or nan define float @clamp_is_ult_neg1_to_neg1_commute(float %arg) { -; CHECK-LABEL: define float @clamp_is_ult_neg1_to_neg1_commute( +; CHECK-LABEL: define nofpclass(nan ninf) float @clamp_is_ult_neg1_to_neg1_commute( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_OGE_NEG1:%.*]] = fcmp oge float [[ARG]], -1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OGE_NEG1]], float [[ARG]], float -1.000000e+00 @@ -351,7 +351,7 @@ define float @clamp_is_ult_neg1_to_neg1_commute(float %arg) { ; Must be 1, only posnormal define float @fcmp_oeq_1_else_1(float %arg) { -; CHECK-LABEL: define float @fcmp_oeq_1_else_1( +; CHECK-LABEL: define nofpclass(nan inf zero sub nnorm) float @fcmp_oeq_1_else_1( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_OEQ_1:%.*]] = fcmp oeq float [[ARG]], 1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OEQ_1]], float [[ARG]], float 1.000000e+00 @@ -364,7 +364,7 @@ define float @fcmp_oeq_1_else_1(float %arg) { ; Don't know anything define float @fcmp_one_1_else_1(float %arg) { -; CHECK-LABEL: define float @fcmp_one_1_else_1( +; CHECK-LABEL: define nofpclass(nan) float @fcmp_one_1_else_1( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_ONE_1:%.*]] = fcmp one float [[ARG]], 1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ONE_1]], float [[ARG]], float 1.000000e+00 @@ -377,7 +377,7 @@ define float @fcmp_one_1_else_1(float %arg) { ; must be 1 define float @fcmp_one_1_1_else_arg(float %arg) { -; CHECK-LABEL: define float @fcmp_one_1_1_else_arg( +; CHECK-LABEL: define nofpclass(nan inf zero sub nnorm) float @fcmp_one_1_1_else_arg( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_ONE_1:%.*]] = fcmp one float [[ARG]], 1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ONE_1]], float 1.000000e+00, float [[ARG]] @@ -390,7 +390,7 @@ define float @fcmp_one_1_1_else_arg(float %arg) { ; must be 1 define float @fcmp_une_1_1_else_arg(float %arg) { -; CHECK-LABEL: define float @fcmp_une_1_1_else_arg( +; CHECK-LABEL: define nofpclass(nan inf zero sub nnorm) float @fcmp_une_1_1_else_arg( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_UNE_1:%.*]] = fcmp une float [[ARG]], 1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UNE_1]], float 1.000000e+00, float [[ARG]] @@ -403,7 +403,7 @@ define float @fcmp_une_1_1_else_arg(float %arg) { ; Must be -1, only negnormal define float @fcmp_oeq_neg1_else_neg1(float %arg) { -; CHECK-LABEL: define float @fcmp_oeq_neg1_else_neg1( +; CHECK-LABEL: define nofpclass(nan inf zero sub pnorm) float @fcmp_oeq_neg1_else_neg1( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_OEQ_NEG1:%.*]] = fcmp oeq float [[ARG]], -1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OEQ_NEG1]], float [[ARG]], float -1.000000e+00 @@ -416,7 +416,7 @@ define float @fcmp_oeq_neg1_else_neg1(float %arg) { ; Don't know anything define float @fcmp_one_neg1_else_neg1(float %arg) { -; CHECK-LABEL: define float @fcmp_one_neg1_else_neg1( +; CHECK-LABEL: define nofpclass(nan) float @fcmp_one_neg1_else_neg1( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_ONE_NEG1:%.*]] = fcmp one float [[ARG]], -1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ONE_NEG1]], float [[ARG]], float -1.000000e+00 @@ -512,7 +512,7 @@ define float @if_fcmp_one_0_1_else_arg(float %arg) { } define float @if_fcmp_one_1_arg_else_0(float %arg) { -; CHECK-LABEL: define float @if_fcmp_one_1_arg_else_0( +; CHECK-LABEL: define nofpclass(nan) float @if_fcmp_one_1_arg_else_0( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_ONE_1:%.*]] = fcmp one float [[ARG]], 1.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ONE_1]], float [[ARG]], float 0.000000e+00 @@ -524,7 +524,7 @@ define float @if_fcmp_one_1_arg_else_0(float %arg) { } define float @fcmp_fabs_oeq_1_else_1(float %arg) { -; CHECK-LABEL: define float @fcmp_fabs_oeq_1_else_1( +; CHECK-LABEL: define nofpclass(nan inf zero sub) float @fcmp_fabs_oeq_1_else_1( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4:[0-9]+]] ; CHECK-NEXT: [[FABS_IS_OEQ_1:%.*]] = fcmp oeq float [[FABS_ARG]], 1.000000e+00 @@ -552,7 +552,7 @@ define float @fcmp_fabs_oeq_1_0_else_arg(float %arg) { } define float @fcmp_fabs_ueq_1_0_else_arg(float %arg) { -; CHECK-LABEL: define float @fcmp_fabs_ueq_1_0_else_arg( +; CHECK-LABEL: define nofpclass(nan) float @fcmp_fabs_ueq_1_0_else_arg( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[FABS_IS_UEQ_1:%.*]] = fcmp ueq float [[FABS_ARG]], 1.000000e+00 @@ -566,7 +566,7 @@ define float @fcmp_fabs_ueq_1_0_else_arg(float %arg) { } define float @fcmp_fabs_one_1_arg_else_0(float %arg) { -; CHECK-LABEL: define float @fcmp_fabs_one_1_arg_else_0( +; CHECK-LABEL: define nofpclass(nan) float @fcmp_fabs_one_1_arg_else_0( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[FABS_IS_ONE_1:%.*]] = fcmp one float [[FABS_ARG]], 1.000000e+00 @@ -594,7 +594,7 @@ define float @fcmp_fabs_une_1_arg_else_0(float %arg) { } define float @fcmp_fabs_one_1_0_else_arg(float %arg) { -; CHECK-LABEL: define float @fcmp_fabs_one_1_0_else_arg( +; CHECK-LABEL: define nofpclass(nan inf nzero sub pnorm) float @fcmp_fabs_one_1_0_else_arg( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[FABS_IS_ONE_1:%.*]] = fcmp one float [[FABS_ARG]], 1.000000e+00 @@ -608,7 +608,7 @@ define float @fcmp_fabs_one_1_0_else_arg(float %arg) { } define float @fcmp_fabs_une_1_0_else_arg(float %arg) { -; CHECK-LABEL: define float @fcmp_fabs_une_1_0_else_arg( +; CHECK-LABEL: define nofpclass(nan inf nzero sub pnorm) float @fcmp_fabs_une_1_0_else_arg( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[FABS_IS_UNE_1:%.*]] = fcmp une float [[FABS_ARG]], 1.000000e+00 @@ -622,7 +622,7 @@ define float @fcmp_fabs_une_1_0_else_arg(float %arg) { } define float @fcmp_fabs_one_1_neg2_else_arg(float %arg) { -; CHECK-LABEL: define float @fcmp_fabs_one_1_neg2_else_arg( +; CHECK-LABEL: define nofpclass(nan inf zero sub pnorm) float @fcmp_fabs_one_1_neg2_else_arg( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[FABS_IS_ONE_1:%.*]] = fcmp one float [[FABS_ARG]], 1.000000e+00 @@ -640,7 +640,7 @@ define float @fcmp_fabs_one_1_neg2_else_arg(float %arg) { ;--------------------------------------------------------------------- define float @clamp_olt_largest_denormal_0.0(float %arg) { -; CHECK-LABEL: define float @clamp_olt_largest_denormal_0.0( +; CHECK-LABEL: define nofpclass(ninf nzero nsub norm) float @clamp_olt_largest_denormal_0.0( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_OLT_LARGEST_DENORMAL:%.*]] = fcmp olt float [[ARG]], 0x380FFFFFC0000000 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OLT_LARGEST_DENORMAL]], float 0.000000e+00, float [[ARG]] @@ -652,7 +652,7 @@ define float @clamp_olt_largest_denormal_0.0(float %arg) { } define float @clamp_ole_largest_denormal_0.0(float %arg) { -; CHECK-LABEL: define float @clamp_ole_largest_denormal_0.0( +; CHECK-LABEL: define nofpclass(ninf nzero nsub norm) float @clamp_ole_largest_denormal_0.0( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_OLE_LARGEST_DENORMAL:%.*]] = fcmp ole float [[ARG]], 0x380FFFFFC0000000 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OLE_LARGEST_DENORMAL]], float 0.000000e+00, float [[ARG]] @@ -664,7 +664,7 @@ define float @clamp_ole_largest_denormal_0.0(float %arg) { } define float @clamp_ult_largest_denormal_0.0(float %arg) { -; CHECK-LABEL: define float @clamp_ult_largest_denormal_0.0( +; CHECK-LABEL: define nofpclass(nan ninf nzero nsub norm) float @clamp_ult_largest_denormal_0.0( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_ULT_LARGEST_DENORMAL:%.*]] = fcmp ult float [[ARG]], 0x380FFFFFC0000000 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ULT_LARGEST_DENORMAL]], float 0.000000e+00, float [[ARG]] @@ -676,7 +676,7 @@ define float @clamp_ult_largest_denormal_0.0(float %arg) { } define float @clamp_ule_largest_denormal_0.0(float %arg) { -; CHECK-LABEL: define float @clamp_ule_largest_denormal_0.0( +; CHECK-LABEL: define nofpclass(nan ninf nzero nsub norm) float @clamp_ule_largest_denormal_0.0( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_ULE_LARGEST_DENORMAL:%.*]] = fcmp ule float [[ARG]], 0x380FFFFFC0000000 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ULE_LARGEST_DENORMAL]], float 0.000000e+00, float [[ARG]] @@ -688,7 +688,7 @@ define float @clamp_ule_largest_denormal_0.0(float %arg) { } define float @clamp_ogt_largest_denormal_0.0(float %arg) { -; CHECK-LABEL: define float @clamp_ogt_largest_denormal_0.0( +; CHECK-LABEL: define nofpclass(ninf nzero sub nnorm) float @clamp_ogt_largest_denormal_0.0( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_OGT_LARGEST_DENORMAL:%.*]] = fcmp ugt float [[ARG]], 0x380FFFFFC0000000 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OGT_LARGEST_DENORMAL]], float [[ARG]], float 0.000000e+00 @@ -700,7 +700,7 @@ define float @clamp_ogt_largest_denormal_0.0(float %arg) { } define float @clamp_oge_largest_denormal_0.0(float %arg) { -; CHECK-LABEL: define float @clamp_oge_largest_denormal_0.0( +; CHECK-LABEL: define nofpclass(nan ninf nzero sub nnorm) float @clamp_oge_largest_denormal_0.0( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_OGE_LARGEST_DENORMAL:%.*]] = fcmp oge float [[ARG]], 0x380FFFFFC0000000 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OGE_LARGEST_DENORMAL]], float [[ARG]], float 0.000000e+00 @@ -712,7 +712,7 @@ define float @clamp_oge_largest_denormal_0.0(float %arg) { } define float @clamp_ugt_largest_denormal_0.0(float %arg) { -; CHECK-LABEL: define float @clamp_ugt_largest_denormal_0.0( +; CHECK-LABEL: define nofpclass(ninf nzero sub nnorm) float @clamp_ugt_largest_denormal_0.0( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_UGT_LARGEST_DENORMAL:%.*]] = fcmp ugt float [[ARG]], 0x380FFFFFC0000000 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UGT_LARGEST_DENORMAL]], float [[ARG]], float 0.000000e+00 @@ -724,7 +724,7 @@ define float @clamp_ugt_largest_denormal_0.0(float %arg) { } define float @clamp_uge_largest_denormal_0.0(float %arg) { -; CHECK-LABEL: define float @clamp_uge_largest_denormal_0.0( +; CHECK-LABEL: define nofpclass(ninf nzero sub nnorm) float @clamp_uge_largest_denormal_0.0( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_UGE_LARGEST_DENORMAL:%.*]] = fcmp uge float [[ARG]], 0x380FFFFFC0000000 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UGE_LARGEST_DENORMAL]], float [[ARG]], float 0.000000e+00 @@ -736,7 +736,7 @@ define float @clamp_uge_largest_denormal_0.0(float %arg) { } define float @fcmp_oeq_largest_denormal_arg_else_0.0(float %arg) { -; CHECK-LABEL: define float @fcmp_oeq_largest_denormal_arg_else_0.0( +; CHECK-LABEL: define nofpclass(nan inf nzero nsub norm) float @fcmp_oeq_largest_denormal_arg_else_0.0( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_OEQ_LARGEST_DENORMAL:%.*]] = fcmp oeq float [[ARG]], 0x380FFFFFC0000000 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OEQ_LARGEST_DENORMAL]], float [[ARG]], float 0.000000e+00 @@ -753,7 +753,7 @@ define float @fcmp_oeq_largest_denormal_arg_else_0.0(float %arg) { ; can't be inf define float @clamp_fabs_value_ogt_1_to_1_copysign(float %arg) { -; CHECK-LABEL: define float @clamp_fabs_value_ogt_1_to_1_copysign( +; CHECK-LABEL: define nofpclass(inf) float @clamp_fabs_value_ogt_1_to_1_copysign( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[FABS_IS_OGT_1:%.*]] = fcmp ogt float [[FABS_ARG]], 1.000000e+00 @@ -770,7 +770,7 @@ define float @clamp_fabs_value_ogt_1_to_1_copysign(float %arg) { ; can't be inf define float @clamp_fabs_value_oge_1_to_1_copysign(float %arg) { -; CHECK-LABEL: define float @clamp_fabs_value_oge_1_to_1_copysign( +; CHECK-LABEL: define nofpclass(inf) float @clamp_fabs_value_oge_1_to_1_copysign( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[FABS_IS_OGE_1:%.*]] = fcmp oge float [[FABS_ARG]], 1.000000e+00 @@ -787,7 +787,7 @@ define float @clamp_fabs_value_oge_1_to_1_copysign(float %arg) { ; can't be inf or nan define float @clamp_fabs_value_olt_1_to_1_copysign(float %arg) { -; CHECK-LABEL: define float @clamp_fabs_value_olt_1_to_1_copysign( +; CHECK-LABEL: define nofpclass(nan inf) float @clamp_fabs_value_olt_1_to_1_copysign( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[FABS_IS_OLT_1:%.*]] = fcmp olt float [[FABS_ARG]], 1.000000e+00 @@ -804,7 +804,7 @@ define float @clamp_fabs_value_olt_1_to_1_copysign(float %arg) { ; can't be inf or nan define float @clamp_fabs_value_ole_1_to_1_copysign(float %arg) { -; CHECK-LABEL: define float @clamp_fabs_value_ole_1_to_1_copysign( +; CHECK-LABEL: define nofpclass(nan inf) float @clamp_fabs_value_ole_1_to_1_copysign( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[FABS_IS_OLE_1:%.*]] = fcmp ole float [[FABS_ARG]], 1.000000e+00 @@ -821,7 +821,7 @@ define float @clamp_fabs_value_ole_1_to_1_copysign(float %arg) { ; can't be inf or nan define float @clamp_fabs_value_ugt_1_to_1_copysign(float %arg) { -; CHECK-LABEL: define float @clamp_fabs_value_ugt_1_to_1_copysign( +; CHECK-LABEL: define nofpclass(nan inf) float @clamp_fabs_value_ugt_1_to_1_copysign( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[FABS_IS_UGT_1:%.*]] = fcmp ugt float [[FABS_ARG]], 1.000000e+00 @@ -838,7 +838,7 @@ define float @clamp_fabs_value_ugt_1_to_1_copysign(float %arg) { ; can't be inf or nan define float @clamp_fabs_value_uge_1_to_1_copysign(float %arg) { -; CHECK-LABEL: define float @clamp_fabs_value_uge_1_to_1_copysign( +; CHECK-LABEL: define nofpclass(nan inf) float @clamp_fabs_value_uge_1_to_1_copysign( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[FABS_IS_UGE_1:%.*]] = fcmp ugt float [[FABS_ARG]], 1.000000e+00 @@ -855,7 +855,7 @@ define float @clamp_fabs_value_uge_1_to_1_copysign(float %arg) { ; can't be inf define float @clamp_fabs_value_ult_1_to_1_copysign(float %arg) { -; CHECK-LABEL: define float @clamp_fabs_value_ult_1_to_1_copysign( +; CHECK-LABEL: define nofpclass(inf) float @clamp_fabs_value_ult_1_to_1_copysign( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[FABS_IS_ULT_1:%.*]] = fcmp ult float [[FABS_ARG]], 1.000000e+00 @@ -872,7 +872,7 @@ define float @clamp_fabs_value_ult_1_to_1_copysign(float %arg) { ; can't be inf define float @clamp_fabs_value_ule_1_to_1_copysign(float %arg) { -; CHECK-LABEL: define float @clamp_fabs_value_ule_1_to_1_copysign( +; CHECK-LABEL: define nofpclass(inf) float @clamp_fabs_value_ule_1_to_1_copysign( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[FABS_IS_ULE_1:%.*]] = fcmp ule float [[FABS_ARG]], 1.000000e+00 @@ -893,7 +893,7 @@ define float @clamp_fabs_value_ule_1_to_1_copysign(float %arg) { ; Can't be +inf define float @clamp_is_ogt_largest_normal_to_largest_normal(float %arg) { -; CHECK-LABEL: define float @clamp_is_ogt_largest_normal_to_largest_normal( +; CHECK-LABEL: define nofpclass(pinf) float @clamp_is_ogt_largest_normal_to_largest_normal( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_OGT_LARGEST_NORMAL:%.*]] = fcmp ogt float [[ARG]], 0x47EFFFFFE0000000 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OGT_LARGEST_NORMAL]], float 0x47EFFFFFE0000000, float [[ARG]] @@ -906,7 +906,7 @@ define float @clamp_is_ogt_largest_normal_to_largest_normal(float %arg) { ; Can't be +inf define float @clamp_is_oge_largest_normal_to_largest_normal(float %arg) { -; CHECK-LABEL: define float @clamp_is_oge_largest_normal_to_largest_normal( +; CHECK-LABEL: define nofpclass(pinf) float @clamp_is_oge_largest_normal_to_largest_normal( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_OGE_LARGEST_NORMAL:%.*]] = fcmp oge float [[ARG]], 0x47EFFFFFE0000000 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OGE_LARGEST_NORMAL]], float 0x47EFFFFFE0000000, float [[ARG]] @@ -919,7 +919,7 @@ define float @clamp_is_oge_largest_normal_to_largest_normal(float %arg) { ; Can't be +inf or nan define float @clamp_is_ugt_largest_normal_to_largest_normal(float %arg) { -; CHECK-LABEL: define float @clamp_is_ugt_largest_normal_to_largest_normal( +; CHECK-LABEL: define nofpclass(nan pinf) float @clamp_is_ugt_largest_normal_to_largest_normal( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_UGT_LARGEST_NORMAL:%.*]] = fcmp ugt float [[ARG]], 0x47EFFFFFE0000000 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UGT_LARGEST_NORMAL]], float 0x47EFFFFFE0000000, float [[ARG]] @@ -932,7 +932,7 @@ define float @clamp_is_ugt_largest_normal_to_largest_normal(float %arg) { ; Can't be +inf or nan define float @clamp_is_uge_largest_normal_to_largest_normal(float %arg) { -; CHECK-LABEL: define float @clamp_is_uge_largest_normal_to_largest_normal( +; CHECK-LABEL: define nofpclass(nan pinf) float @clamp_is_uge_largest_normal_to_largest_normal( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[IS_UGE_LARGEST_NORMAL:%.*]] = fcmp uge float [[ARG]], 0x47EFFFFFE0000000 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UGE_LARGEST_NORMAL]], float 0x47EFFFFFE0000000, float [[ARG]] @@ -945,7 +945,7 @@ define float @clamp_is_uge_largest_normal_to_largest_normal(float %arg) { ; Can't be +inf or -inf define float @clamp_fabs_is_ogt_largest_normal_to_largest_normal(float %arg) { -; CHECK-LABEL: define float @clamp_fabs_is_ogt_largest_normal_to_largest_normal( +; CHECK-LABEL: define nofpclass(inf) float @clamp_fabs_is_ogt_largest_normal_to_largest_normal( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[IS_OGT_LARGEST_NORMAL:%.*]] = fcmp ogt float [[FABS_ARG]], 0x47EFFFFFE0000000 @@ -960,7 +960,7 @@ define float @clamp_fabs_is_ogt_largest_normal_to_largest_normal(float %arg) { ; Can't be +inf or -inf define float @clamp_fabs_is_oge_largest_normal_to_largest_normal(float %arg) { -; CHECK-LABEL: define float @clamp_fabs_is_oge_largest_normal_to_largest_normal( +; CHECK-LABEL: define nofpclass(inf) float @clamp_fabs_is_oge_largest_normal_to_largest_normal( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[IS_OGE_LARGEST_NORMAL:%.*]] = fcmp oge float [[FABS_ARG]], 0x47EFFFFFE0000000 @@ -975,7 +975,7 @@ define float @clamp_fabs_is_oge_largest_normal_to_largest_normal(float %arg) { ; Can't be +inf or -inf or nan define float @clamp_fabs_is_ugt_largest_normal_to_largest_normal(float %arg) { -; CHECK-LABEL: define float @clamp_fabs_is_ugt_largest_normal_to_largest_normal( +; CHECK-LABEL: define nofpclass(nan inf) float @clamp_fabs_is_ugt_largest_normal_to_largest_normal( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[IS_UGT_LARGEST_NORMAL:%.*]] = fcmp ugt float [[FABS_ARG]], 0x47EFFFFFE0000000 @@ -990,7 +990,7 @@ define float @clamp_fabs_is_ugt_largest_normal_to_largest_normal(float %arg) { ; Can't be +inf or -inf or nan define float @clamp_fabs_is_uge_largest_normal_to_largest_normal(float %arg) { -; CHECK-LABEL: define float @clamp_fabs_is_uge_largest_normal_to_largest_normal( +; CHECK-LABEL: define nofpclass(nan inf) float @clamp_fabs_is_uge_largest_normal_to_largest_normal( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[IS_UGT_LARGEST_NORMAL:%.*]] = fcmp uge float [[FABS_ARG]], 0x47EFFFFFE0000000 @@ -1009,7 +1009,7 @@ define float @clamp_fabs_is_uge_largest_normal_to_largest_normal(float %arg) { ; can't be negative or positive subnormal define float @clamp_fabs_ogt_smallest_normal_to_zero(float %arg) { -; CHECK-LABEL: define float @clamp_fabs_ogt_smallest_normal_to_zero( +; CHECK-LABEL: define nofpclass(inf pnorm) float @clamp_fabs_ogt_smallest_normal_to_zero( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[IS_OGT_SMALLEST_NORMAL:%.*]] = fcmp ogt float [[FABS_ARG]], 0x3810000000000000 @@ -1055,7 +1055,7 @@ define float @clamp_fabs_olt_smallest_normal_to_zero(float %arg) { ; can't be negative or subnormal define float @clamp_fabs_ole_smallest_normal_to_zero(float %arg) { -; CHECK-LABEL: define float @clamp_fabs_ole_smallest_normal_to_zero( +; CHECK-LABEL: define nofpclass(nzero sub pnorm) float @clamp_fabs_ole_smallest_normal_to_zero( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[IS_OLE_SMALLEST_NORMAL:%.*]] = fcmp ole float [[FABS_ARG]], 0x3810000000000000 @@ -1083,7 +1083,7 @@ define float @clamp_fabs_is_is_olt_smallest_normal_to_0(float %arg) { } define float @clamp_fabs_is_is_ole_smallest_normal_to_0(float %arg) { -; CHECK-LABEL: define float @clamp_fabs_is_is_ole_smallest_normal_to_0( +; CHECK-LABEL: define nofpclass(nzero sub pnorm) float @clamp_fabs_is_is_ole_smallest_normal_to_0( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[IS_OLE_SMALLEST_NORMAL:%.*]] = fcmp ole float [[FABS_ARG]], 0x3810000000000000 @@ -1111,7 +1111,7 @@ define float @clamp_fabs_oeq_smallest_normal_to_zero(float %arg) { } define float @clamp_fabs_one_smallest_normal_to_zero(float %arg) { -; CHECK-LABEL: define float @clamp_fabs_one_smallest_normal_to_zero( +; CHECK-LABEL: define nofpclass(nan inf nzero sub pnorm) float @clamp_fabs_one_smallest_normal_to_zero( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[IS_ONE_SMALLEST_NORMAL:%.*]] = fcmp one float [[FABS_ARG]], 0x3810000000000000 @@ -1125,7 +1125,7 @@ define float @clamp_fabs_one_smallest_normal_to_zero(float %arg) { } define float @clamp_fabs_ueq_smallest_normal_to_zero(float %arg) { -; CHECK-LABEL: define float @clamp_fabs_ueq_smallest_normal_to_zero( +; CHECK-LABEL: define nofpclass(nan) float @clamp_fabs_ueq_smallest_normal_to_zero( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[IS_UEQ_SMALLEST_NORMAL:%.*]] = fcmp ueq float [[FABS_ARG]], 0x3810000000000000 @@ -1139,7 +1139,7 @@ define float @clamp_fabs_ueq_smallest_normal_to_zero(float %arg) { } define float @clamp_fabs_une_smallest_normal_to_zero(float %arg) { -; CHECK-LABEL: define float @clamp_fabs_une_smallest_normal_to_zero( +; CHECK-LABEL: define nofpclass(nan inf nzero sub pnorm) float @clamp_fabs_une_smallest_normal_to_zero( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[IS_UNE_SMALLEST_NORMAL:%.*]] = fcmp une float [[FABS_ARG]], 0x3810000000000000 @@ -1179,7 +1179,7 @@ define float @clamp_fabs_ole_neg1_to_neg1(float %arg) { } define float @clamp_fabs_ult_neg1_to_neg1(float %arg) { -; CHECK-LABEL: define float @clamp_fabs_ult_neg1_to_neg1( +; CHECK-LABEL: define nofpclass(nan) float @clamp_fabs_ult_neg1_to_neg1( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[FABS_IS_ULT_NEG1:%.*]] = fcmp ult float [[FABS_ARG]], -1.000000e+00 @@ -1193,7 +1193,7 @@ define float @clamp_fabs_ult_neg1_to_neg1(float %arg) { } define float @clamp_fabs_ule_neg1_to_neg1(float %arg) { -; CHECK-LABEL: define float @clamp_fabs_ule_neg1_to_neg1( +; CHECK-LABEL: define nofpclass(nan) float @clamp_fabs_ule_neg1_to_neg1( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[FABS_IS_ULE_NEG1:%.*]] = fcmp ule float [[FABS_ARG]], -1.000000e+00 @@ -1207,7 +1207,7 @@ define float @clamp_fabs_ule_neg1_to_neg1(float %arg) { } define float @clamp_fabs_ogt_neg1_to_neg1(float %arg) { -; CHECK-LABEL: define float @clamp_fabs_ogt_neg1_to_neg1( +; CHECK-LABEL: define nofpclass(inf zero sub pnorm) float @clamp_fabs_ogt_neg1_to_neg1( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[FABS_IS_OGT_NEG1:%.*]] = fcmp ogt float [[FABS_ARG]], -1.000000e+00 @@ -1221,7 +1221,7 @@ define float @clamp_fabs_ogt_neg1_to_neg1(float %arg) { } define float @clamp_fabs_oge_neg1_to_neg1(float %arg) { -; CHECK-LABEL: define float @clamp_fabs_oge_neg1_to_neg1( +; CHECK-LABEL: define nofpclass(inf zero sub pnorm) float @clamp_fabs_oge_neg1_to_neg1( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[FABS_IS_OGE_NEG1:%.*]] = fcmp oge float [[FABS_ARG]], -1.000000e+00 @@ -1268,7 +1268,7 @@ define float @clamp_fabs_oeq_neg1_to_neg1(float %arg) { } define float @clamp_fabs_ueq_neg1_to_neg1(float %arg) { -; CHECK-LABEL: define float @clamp_fabs_ueq_neg1_to_neg1( +; CHECK-LABEL: define nofpclass(nan) float @clamp_fabs_ueq_neg1_to_neg1( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[FABS_IS_UEQ_NEG1:%.*]] = fcmp ueq float [[FABS_ARG]], -1.000000e+00 @@ -1282,7 +1282,7 @@ define float @clamp_fabs_ueq_neg1_to_neg1(float %arg) { } define float @clamp_fabs_one_neg1_to_neg1(float %arg) { -; CHECK-LABEL: define float @clamp_fabs_one_neg1_to_neg1( +; CHECK-LABEL: define nofpclass(nan inf zero sub) float @clamp_fabs_one_neg1_to_neg1( ; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[FABS_IS_ONE_NEG1:%.*]] = fcmp one float [[FABS_ARG]], -1.000000e+00 @@ -1311,8 +1311,8 @@ define float @clamp_fabs_une_neg1_to_neg1(float %arg) { ;--------------------------------------------------------------------- define float @ret_assumed_ogt_1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_ogt_1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3:[0-9]+]] { +; CHECK-LABEL: define nofpclass(nan ninf zero sub nnorm) float @ret_assumed_ogt_1( +; CHECK-SAME: float returned nofpclass(nan ninf zero sub nnorm) [[ARG:%.*]]) #[[ATTR3:[0-9]+]] { ; CHECK-NEXT: [[OGT_1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OGT_1]]) #[[ATTR5:[0-9]+]] ; CHECK-NEXT: ret float [[ARG]] @@ -1323,8 +1323,8 @@ define float @ret_assumed_ogt_1(float %arg) { } define float @ret_assumed_oge_1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_oge_1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(nan ninf zero sub nnorm) float @ret_assumed_oge_1( +; CHECK-SAME: float returned nofpclass(nan ninf zero sub nnorm) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[OGE_1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OGE_1]]) #[[ATTR5]] ; CHECK-NEXT: ret float [[ARG]] @@ -1335,8 +1335,8 @@ define float @ret_assumed_oge_1(float %arg) { } define float @ret_assumed_olt_1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_olt_1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(nan pinf) float @ret_assumed_olt_1( +; CHECK-SAME: float returned nofpclass(nan pinf) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[OLT_1:%.*]] = fcmp olt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OLT_1]]) #[[ATTR5]] ; CHECK-NEXT: ret float [[ARG]] @@ -1347,8 +1347,8 @@ define float @ret_assumed_olt_1(float %arg) { } define float @ret_assumed_ole_1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_ole_1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(nan pinf) float @ret_assumed_ole_1( +; CHECK-SAME: float returned nofpclass(nan pinf) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[OLE_1:%.*]] = fcmp ole float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OLE_1]]) #[[ATTR5]] ; CHECK-NEXT: ret float [[ARG]] @@ -1359,8 +1359,8 @@ define float @ret_assumed_ole_1(float %arg) { } define float @ret_assumed_ugt_1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_ugt_1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(ninf zero sub nnorm) float @ret_assumed_ugt_1( +; CHECK-SAME: float returned nofpclass(ninf zero sub nnorm) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[UGT_1:%.*]] = fcmp ugt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[UGT_1]]) #[[ATTR5]] ; CHECK-NEXT: ret float [[ARG]] @@ -1371,8 +1371,8 @@ define float @ret_assumed_ugt_1(float %arg) { } define float @ret_assumed_uge_1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_uge_1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(ninf zero sub nnorm) float @ret_assumed_uge_1( +; CHECK-SAME: float returned nofpclass(ninf zero sub nnorm) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[UGE_1:%.*]] = fcmp uge float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[UGE_1]]) #[[ATTR5]] ; CHECK-NEXT: ret float [[ARG]] @@ -1383,8 +1383,8 @@ define float @ret_assumed_uge_1(float %arg) { } define float @ret_assumed_ult_1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_ult_1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(pinf) float @ret_assumed_ult_1( +; CHECK-SAME: float returned nofpclass(pinf) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[ULT_1:%.*]] = fcmp ult float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[ULT_1]]) #[[ATTR5]] ; CHECK-NEXT: ret float [[ARG]] @@ -1395,8 +1395,8 @@ define float @ret_assumed_ult_1(float %arg) { } define float @ret_assumed_ule_1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_ule_1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(pinf) float @ret_assumed_ule_1( +; CHECK-SAME: float returned nofpclass(pinf) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[ULE_1:%.*]] = fcmp ule float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[ULE_1]]) #[[ATTR5]] ; CHECK-NEXT: ret float [[ARG]] @@ -1407,8 +1407,8 @@ define float @ret_assumed_ule_1(float %arg) { } define float @ret_assumed_fabs_ogt_1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_fabs_ogt_1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(nan zero sub) float @ret_assumed_fabs_ogt_1( +; CHECK-SAME: float returned nofpclass(nan zero sub) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[ARG_FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[OGT_1:%.*]] = fcmp ogt float [[ARG_FABS]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OGT_1]]) #[[ATTR5]] @@ -1421,8 +1421,8 @@ define float @ret_assumed_fabs_ogt_1(float %arg) { } define float @ret_assumed_fabs_oge_1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_fabs_oge_1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(nan zero sub) float @ret_assumed_fabs_oge_1( +; CHECK-SAME: float returned nofpclass(nan zero sub) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[ARG_FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[OGE_1:%.*]] = fcmp oge float [[ARG_FABS]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OGE_1]]) #[[ATTR5]] @@ -1435,8 +1435,8 @@ define float @ret_assumed_fabs_oge_1(float %arg) { } define float @ret_assumed_fabs_olt_1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_fabs_olt_1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(nan inf) float @ret_assumed_fabs_olt_1( +; CHECK-SAME: float returned nofpclass(nan inf) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[ARG_FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[OLT_1:%.*]] = fcmp olt float [[ARG_FABS]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OLT_1]]) #[[ATTR5]] @@ -1449,8 +1449,8 @@ define float @ret_assumed_fabs_olt_1(float %arg) { } define float @ret_assumed_fabs_ole_1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_fabs_ole_1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(nan inf) float @ret_assumed_fabs_ole_1( +; CHECK-SAME: float returned nofpclass(nan inf) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[ARG_FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[OLE_1:%.*]] = fcmp olt float [[ARG_FABS]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OLE_1]]) #[[ATTR5]] @@ -1463,8 +1463,8 @@ define float @ret_assumed_fabs_ole_1(float %arg) { } define float @ret_assumed_fabs_ugt_1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_fabs_ugt_1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(zero sub) float @ret_assumed_fabs_ugt_1( +; CHECK-SAME: float returned nofpclass(zero sub) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[ARG_FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[UGT_1:%.*]] = fcmp ugt float [[ARG_FABS]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[UGT_1]]) #[[ATTR5]] @@ -1477,8 +1477,8 @@ define float @ret_assumed_fabs_ugt_1(float %arg) { } define float @ret_assumed_fabs_uge_1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_fabs_uge_1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(zero sub) float @ret_assumed_fabs_uge_1( +; CHECK-SAME: float returned nofpclass(zero sub) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[ARG_FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[UGE_1:%.*]] = fcmp ugt float [[ARG_FABS]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[UGE_1]]) #[[ATTR5]] @@ -1491,8 +1491,8 @@ define float @ret_assumed_fabs_uge_1(float %arg) { } define float @ret_assumed_fabs_ult_1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_fabs_ult_1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(inf) float @ret_assumed_fabs_ult_1( +; CHECK-SAME: float returned nofpclass(inf) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[ARG_FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[ULT_1:%.*]] = fcmp ult float [[ARG_FABS]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[ULT_1]]) #[[ATTR5]] @@ -1505,8 +1505,8 @@ define float @ret_assumed_fabs_ult_1(float %arg) { } define float @ret_assumed_fabs_ule_1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_fabs_ule_1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(inf) float @ret_assumed_fabs_ule_1( +; CHECK-SAME: float returned nofpclass(inf) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[ARG_FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[ULE_1:%.*]] = fcmp ule float [[ARG_FABS]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[ULE_1]]) #[[ATTR5]] @@ -1519,8 +1519,8 @@ define float @ret_assumed_fabs_ule_1(float %arg) { } define float @ret_assumed_ogt_neg1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_ogt_neg1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(nan ninf) float @ret_assumed_ogt_neg1( +; CHECK-SAME: float returned nofpclass(nan ninf) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[OGT_NEG1:%.*]] = fcmp ogt float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OGT_NEG1]]) #[[ATTR5]] ; CHECK-NEXT: ret float [[ARG]] @@ -1531,8 +1531,8 @@ define float @ret_assumed_ogt_neg1(float %arg) { } define float @ret_assumed_oge_neg1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_oge_neg1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(nan ninf) float @ret_assumed_oge_neg1( +; CHECK-SAME: float returned nofpclass(nan ninf) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[OGE_NEG1:%.*]] = fcmp ogt float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OGE_NEG1]]) #[[ATTR5]] ; CHECK-NEXT: ret float [[ARG]] @@ -1543,8 +1543,8 @@ define float @ret_assumed_oge_neg1(float %arg) { } define float @ret_assumed_olt_neg1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_olt_neg1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(nan pinf zero sub pnorm) float @ret_assumed_olt_neg1( +; CHECK-SAME: float returned nofpclass(nan pinf zero sub pnorm) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OLT_NEG1]]) #[[ATTR5]] ; CHECK-NEXT: ret float [[ARG]] @@ -1555,8 +1555,8 @@ define float @ret_assumed_olt_neg1(float %arg) { } define float @ret_assumed_ole_neg1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_ole_neg1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(nan pinf zero sub pnorm) float @ret_assumed_ole_neg1( +; CHECK-SAME: float returned nofpclass(nan pinf zero sub pnorm) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[OLE_NEG1:%.*]] = fcmp ole float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OLE_NEG1]]) #[[ATTR5]] ; CHECK-NEXT: ret float [[ARG]] @@ -1567,8 +1567,8 @@ define float @ret_assumed_ole_neg1(float %arg) { } define float @ret_assumed_ugt_neg1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_ugt_neg1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(ninf) float @ret_assumed_ugt_neg1( +; CHECK-SAME: float returned nofpclass(ninf) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[UGT_NEG1:%.*]] = fcmp ugt float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[UGT_NEG1]]) #[[ATTR5]] ; CHECK-NEXT: ret float [[ARG]] @@ -1579,8 +1579,8 @@ define float @ret_assumed_ugt_neg1(float %arg) { } define float @ret_assumed_uge_neg1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_uge_neg1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(ninf) float @ret_assumed_uge_neg1( +; CHECK-SAME: float returned nofpclass(ninf) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[UGE_NEG1:%.*]] = fcmp uge float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[UGE_NEG1]]) #[[ATTR5]] ; CHECK-NEXT: ret float [[ARG]] @@ -1591,8 +1591,8 @@ define float @ret_assumed_uge_neg1(float %arg) { } define float @ret_assumed_ult_neg1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_ult_neg1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(pinf zero sub pnorm) float @ret_assumed_ult_neg1( +; CHECK-SAME: float returned nofpclass(pinf zero sub pnorm) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[ULT_NEG1:%.*]] = fcmp ult float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[ULT_NEG1]]) #[[ATTR5]] ; CHECK-NEXT: ret float [[ARG]] @@ -1603,8 +1603,8 @@ define float @ret_assumed_ult_neg1(float %arg) { } define float @ret_assumed_ule_neg1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_ule_neg1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(pinf zero sub pnorm) float @ret_assumed_ule_neg1( +; CHECK-SAME: float returned nofpclass(pinf zero sub pnorm) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[ULE_NEG1:%.*]] = fcmp ule float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[ULE_NEG1]]) #[[ATTR5]] ; CHECK-NEXT: ret float [[ARG]] @@ -1615,8 +1615,8 @@ define float @ret_assumed_ule_neg1(float %arg) { } define float @ret_assumed_oeq_1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_oeq_1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(nan inf zero sub nnorm) float @ret_assumed_oeq_1( +; CHECK-SAME: float returned nofpclass(nan inf zero sub nnorm) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[OEQ_1:%.*]] = fcmp oeq float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OEQ_1]]) #[[ATTR5]] ; CHECK-NEXT: ret float [[ARG]] @@ -1627,8 +1627,8 @@ define float @ret_assumed_oeq_1(float %arg) { } define float @ret_assumed_ueq_1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_ueq_1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(inf zero sub nnorm) float @ret_assumed_ueq_1( +; CHECK-SAME: float returned nofpclass(inf zero sub nnorm) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[UEQ_1:%.*]] = fcmp ueq float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[UEQ_1]]) #[[ATTR5]] ; CHECK-NEXT: ret float [[ARG]] @@ -1639,8 +1639,8 @@ define float @ret_assumed_ueq_1(float %arg) { } define float @ret_assumed_one_1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_one_1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(nan) float @ret_assumed_one_1( +; CHECK-SAME: float returned nofpclass(nan) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[ONE_1:%.*]] = fcmp one float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[ONE_1]]) #[[ATTR5]] ; CHECK-NEXT: ret float [[ARG]] @@ -1651,8 +1651,8 @@ define float @ret_assumed_one_1(float %arg) { } define float @ret_assumed_one_neg1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_one_neg1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(nan) float @ret_assumed_one_neg1( +; CHECK-SAME: float returned nofpclass(nan) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[ONE_NEG1:%.*]] = fcmp one float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[ONE_NEG1]]) #[[ATTR5]] ; CHECK-NEXT: ret float [[ARG]] @@ -1687,8 +1687,8 @@ define float @ret_assumed_une_1(float %arg) { } define float @ret_assumed_fabs_oeq_1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_fabs_oeq_1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(nan inf zero sub pnorm) float @ret_assumed_fabs_oeq_1( +; CHECK-SAME: float returned nofpclass(nan inf zero sub pnorm) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[ARG_FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[OEQ_1:%.*]] = fcmp oeq float [[ARG_FABS]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OEQ_1]]) #[[ATTR5]] @@ -1701,8 +1701,8 @@ define float @ret_assumed_fabs_oeq_1(float %arg) { } define float @ret_assumed_fabs_ueq_1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_fabs_ueq_1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(inf zero sub pnorm) float @ret_assumed_fabs_ueq_1( +; CHECK-SAME: float returned nofpclass(inf zero sub pnorm) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[ARG_FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[UEQ_1:%.*]] = fcmp ueq float [[ARG_FABS]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[UEQ_1]]) #[[ATTR5]] @@ -1715,8 +1715,8 @@ define float @ret_assumed_fabs_ueq_1(float %arg) { } define float @ret_assumed_fabs_one_1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_fabs_one_1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(nan) float @ret_assumed_fabs_one_1( +; CHECK-SAME: float returned nofpclass(nan) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[ARG_FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[ONE_1:%.*]] = fcmp one float [[ARG_FABS]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[ONE_1]]) #[[ATTR5]] @@ -1729,8 +1729,8 @@ define float @ret_assumed_fabs_one_1(float %arg) { } define float @ret_assumed_fabs_une_1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_fabs_une_1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(nan) float @ret_assumed_fabs_une_1( +; CHECK-SAME: float returned nofpclass(nan) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[ARG_FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[UNE_1:%.*]] = fcmp one float [[ARG_FABS]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[UNE_1]]) #[[ATTR5]] @@ -1743,8 +1743,8 @@ define float @ret_assumed_fabs_une_1(float %arg) { } define float @ret_assumed_fabs_oeq_neg1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_fabs_oeq_neg1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(nan inf zero sub nnorm) float @ret_assumed_fabs_oeq_neg1( +; CHECK-SAME: float returned nofpclass(nan inf zero sub nnorm) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: call void @llvm.assume(i1 noundef false) #[[ATTR5]] ; CHECK-NEXT: ret float [[ARG]] ; @@ -1755,8 +1755,8 @@ define float @ret_assumed_fabs_oeq_neg1(float %arg) { } define float @ret_assumed_fabs_ueq_neg1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_fabs_ueq_neg1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(inf zero sub nnorm) float @ret_assumed_fabs_ueq_neg1( +; CHECK-SAME: float returned nofpclass(inf zero sub nnorm) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[ARG_FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[UEQ_NEG1:%.*]] = fcmp ueq float [[ARG_FABS]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[UEQ_NEG1]]) #[[ATTR5]] @@ -1769,8 +1769,8 @@ define float @ret_assumed_fabs_ueq_neg1(float %arg) { } define float @ret_assumed_fabs_one_neg1(float %arg) { -; CHECK-LABEL: define float @ret_assumed_fabs_one_neg1( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(nan) float @ret_assumed_fabs_one_neg1( +; CHECK-SAME: float returned nofpclass(nan) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[ARG_FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[ONE_NEG1:%.*]] = fcmp one float [[ARG_FABS]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[ONE_NEG1]]) #[[ATTR5]] @@ -2228,8 +2228,8 @@ define float @ret_assumed_uge_known_negative(float %arg, float %unknown) { ;--------------------------------------------------------------------- define float @assume_oeq_smallest_normal(float %arg) { -; CHECK-LABEL: define float @assume_oeq_smallest_normal( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(nan inf zero sub nnorm) float @assume_oeq_smallest_normal( +; CHECK-SAME: float returned nofpclass(nan inf zero sub nnorm) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[IS_OEQ_SMALLEST_NORMAL:%.*]] = fcmp oeq float [[ARG]], 0x3810000000000000 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_OEQ_SMALLEST_NORMAL]]) #[[ATTR5]] ; CHECK-NEXT: ret float [[ARG]] @@ -2240,8 +2240,8 @@ define float @assume_oeq_smallest_normal(float %arg) { } define float @assume_one_smallest_normal(float %arg) { -; CHECK-LABEL: define float @assume_one_smallest_normal( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(nan) float @assume_one_smallest_normal( +; CHECK-SAME: float returned nofpclass(nan) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[IS_ONE_SMALLEST_NORMAL:%.*]] = fcmp one float [[ARG]], 0x3810000000000000 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_ONE_SMALLEST_NORMAL]]) #[[ATTR5]] ; CHECK-NEXT: ret float [[ARG]] @@ -2252,8 +2252,8 @@ define float @assume_one_smallest_normal(float %arg) { } define float @assume_ueq_smallest_normal(float %arg) { -; CHECK-LABEL: define float @assume_ueq_smallest_normal( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(inf zero sub nnorm) float @assume_ueq_smallest_normal( +; CHECK-SAME: float returned nofpclass(inf zero sub nnorm) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[IS_UEQ_SMALLEST_NORMAL:%.*]] = fcmp ueq float [[ARG]], 0x3810000000000000 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_UEQ_SMALLEST_NORMAL]]) #[[ATTR5]] ; CHECK-NEXT: ret float [[ARG]] @@ -2300,8 +2300,8 @@ define float @assume_uno_smallest_normal(float %arg) { } define float @assume_fabs_oeq_smallest_normal(float %arg) { -; CHECK-LABEL: define float @assume_fabs_oeq_smallest_normal( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(nan inf zero sub pnorm) float @assume_fabs_oeq_smallest_normal( +; CHECK-SAME: float returned nofpclass(nan inf zero sub pnorm) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[IS_OEQ_SMALLEST_NORMAL:%.*]] = fcmp oeq float [[FABS_ARG]], 0x3810000000000000 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_OEQ_SMALLEST_NORMAL]]) #[[ATTR5]] @@ -2314,8 +2314,8 @@ define float @assume_fabs_oeq_smallest_normal(float %arg) { } define float @assume_fabs_one_smallest_normal(float %arg) { -; CHECK-LABEL: define float @assume_fabs_one_smallest_normal( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(nan) float @assume_fabs_one_smallest_normal( +; CHECK-SAME: float returned nofpclass(nan) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[IS_ONE_SMALLEST_NORMAL:%.*]] = fcmp one float [[FABS_ARG]], 0x3810000000000000 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_ONE_SMALLEST_NORMAL]]) #[[ATTR5]] @@ -2328,8 +2328,8 @@ define float @assume_fabs_one_smallest_normal(float %arg) { } define float @assume_fabs_ueq_smallest_normal(float %arg) { -; CHECK-LABEL: define float @assume_fabs_ueq_smallest_normal( -; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(inf zero sub pnorm) float @assume_fabs_ueq_smallest_normal( +; CHECK-SAME: float returned nofpclass(inf zero sub pnorm) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]] ; CHECK-NEXT: [[IS_UEQ_SMALLEST_NORMAL:%.*]] = fcmp ueq float [[FABS_ARG]], 0x3810000000000000 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_UEQ_SMALLEST_NORMAL]]) #[[ATTR5]] @@ -2384,8 +2384,8 @@ define float @assume_fabs_uno_smallest_normal(float %arg) { } define float @assume_oeq_smallest_normal_known_pos(float nofpclass(ninf nsub nnorm nzero) %arg) { -; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @assume_oeq_smallest_normal_known_pos( -; CHECK-SAME: float returned nofpclass(ninf nzero nsub nnorm) [[ARG:%.*]]) #[[ATTR3]] { +; CHECK-LABEL: define nofpclass(nan inf zero sub nnorm) float @assume_oeq_smallest_normal_known_pos( +; CHECK-SAME: float returned nofpclass(nan inf zero sub nnorm) [[ARG:%.*]]) #[[ATTR3]] { ; CHECK-NEXT: [[IS_OEQ_SMALLEST_NORMAL:%.*]] = fcmp oeq float [[ARG]], 0x3810000000000000 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_OEQ_SMALLEST_NORMAL]]) #[[ATTR5]] ; CHECK-NEXT: ret float [[ARG]] diff --git a/llvm/test/Transforms/InstSimplify/assume-fcmp-constant-implies-class.ll b/llvm/test/Transforms/InstSimplify/assume-fcmp-constant-implies-class.ll index e6d5e409bbabf..c23b65d121264 100644 --- a/llvm/test/Transforms/InstSimplify/assume-fcmp-constant-implies-class.ll +++ b/llvm/test/Transforms/InstSimplify/assume-fcmp-constant-implies-class.ll @@ -16,8 +16,7 @@ define i1 @assume_olt_neg1__oeq_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %olt.neg1 = fcmp olt float %arg, -1.0 call void @llvm.assume(i1 %olt.neg1) @@ -30,8 +29,7 @@ define i1 @assume_olt_neg1__ogt_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ogt float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %olt.neg1 = fcmp olt float %arg, -1.0 call void @llvm.assume(i1 %olt.neg1) @@ -44,8 +42,7 @@ define i1 @assume_olt_neg1__oge_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp oge float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %olt.neg1 = fcmp olt float %arg, -1.0 call void @llvm.assume(i1 %olt.neg1) @@ -58,8 +55,7 @@ define i1 @assume_olt_neg1__olt_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp olt float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %olt.neg1 = fcmp olt float %arg, -1.0 call void @llvm.assume(i1 %olt.neg1) @@ -72,8 +68,7 @@ define i1 @assume_olt_neg1__ole_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ole float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %olt.neg1 = fcmp olt float %arg, -1.0 call void @llvm.assume(i1 %olt.neg1) @@ -86,8 +81,7 @@ define i1 @assume_olt_neg1__one_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp one float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %olt.neg1 = fcmp olt float %arg, -1.0 call void @llvm.assume(i1 %olt.neg1) @@ -100,8 +94,7 @@ define i1 @assume_olt_neg1__ord_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ord float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %olt.neg1 = fcmp olt float %arg, -1.0 call void @llvm.assume(i1 %olt.neg1) @@ -114,8 +107,7 @@ define i1 @assume_olt_neg1__ueq_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ueq float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %olt.neg1 = fcmp olt float %arg, -1.0 call void @llvm.assume(i1 %olt.neg1) @@ -128,8 +120,7 @@ define i1 @assume_olt_neg1__ugt_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ugt float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %olt.neg1 = fcmp olt float %arg, -1.0 call void @llvm.assume(i1 %olt.neg1) @@ -142,8 +133,7 @@ define i1 @assume_olt_neg1__uge_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp uge float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %olt.neg1 = fcmp olt float %arg, -1.0 call void @llvm.assume(i1 %olt.neg1) @@ -156,8 +146,7 @@ define i1 @assume_olt_neg1__ult_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ult float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %olt.neg1 = fcmp olt float %arg, -1.0 call void @llvm.assume(i1 %olt.neg1) @@ -170,8 +159,7 @@ define i1 @assume_olt_neg1__ule_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ule float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %olt.neg1 = fcmp olt float %arg, -1.0 call void @llvm.assume(i1 %olt.neg1) @@ -184,8 +172,7 @@ define i1 @assume_olt_neg1__une_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp une float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %olt.neg1 = fcmp olt float %arg, -1.0 call void @llvm.assume(i1 %olt.neg1) @@ -198,8 +185,7 @@ define i1 @assume_olt_neg1__uno_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp uno float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %olt.neg1 = fcmp olt float %arg, -1.0 call void @llvm.assume(i1 %olt.neg1) @@ -216,8 +202,7 @@ define i1 @assume_ole_neg1__oeq_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLE_NEG1:%.*]] = fcmp ole float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %ole.neg1 = fcmp ole float %arg, -1.0 call void @llvm.assume(i1 %ole.neg1) @@ -230,8 +215,7 @@ define i1 @assume_ole_neg1__ogt_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLE_NEG1:%.*]] = fcmp ole float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ogt float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %ole.neg1 = fcmp ole float %arg, -1.0 call void @llvm.assume(i1 %ole.neg1) @@ -244,8 +228,7 @@ define i1 @assume_ole_neg1__oge_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLE_NEG1:%.*]] = fcmp ole float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp oge float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %ole.neg1 = fcmp ole float %arg, -1.0 call void @llvm.assume(i1 %ole.neg1) @@ -258,8 +241,7 @@ define i1 @assume_ole_neg1__olt_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLE_NEG1:%.*]] = fcmp ole float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp olt float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %ole.neg1 = fcmp ole float %arg, -1.0 call void @llvm.assume(i1 %ole.neg1) @@ -272,8 +254,7 @@ define i1 @assume_ole_neg1__ole_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLE_NEG1:%.*]] = fcmp ole float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ole float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %ole.neg1 = fcmp ole float %arg, -1.0 call void @llvm.assume(i1 %ole.neg1) @@ -286,8 +267,7 @@ define i1 @assume_ole_neg1__one_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLE_NEG1:%.*]] = fcmp ole float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp one float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %ole.neg1 = fcmp ole float %arg, -1.0 call void @llvm.assume(i1 %ole.neg1) @@ -300,8 +280,7 @@ define i1 @assume_ole_neg1__ord_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLE_NEG1:%.*]] = fcmp ole float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ord float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %ole.neg1 = fcmp ole float %arg, -1.0 call void @llvm.assume(i1 %ole.neg1) @@ -314,8 +293,7 @@ define i1 @assume_ole_neg1__ueq_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLE_NEG1:%.*]] = fcmp ole float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ueq float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %ole.neg1 = fcmp ole float %arg, -1.0 call void @llvm.assume(i1 %ole.neg1) @@ -328,8 +306,7 @@ define i1 @assume_ole_neg1__ugt_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLE_NEG1:%.*]] = fcmp ole float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ugt float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %ole.neg1 = fcmp ole float %arg, -1.0 call void @llvm.assume(i1 %ole.neg1) @@ -342,8 +319,7 @@ define i1 @assume_ole_neg1__uge_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLE_NEG1:%.*]] = fcmp ole float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp uge float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %ole.neg1 = fcmp ole float %arg, -1.0 call void @llvm.assume(i1 %ole.neg1) @@ -356,8 +332,7 @@ define i1 @assume_ole_neg1__ult_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLE_NEG1:%.*]] = fcmp ole float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ult float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %ole.neg1 = fcmp ole float %arg, -1.0 call void @llvm.assume(i1 %ole.neg1) @@ -370,8 +345,7 @@ define i1 @assume_ole_neg1__ule_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLE_NEG1:%.*]] = fcmp ole float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ule float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %ole.neg1 = fcmp ole float %arg, -1.0 call void @llvm.assume(i1 %ole.neg1) @@ -384,8 +358,7 @@ define i1 @assume_ole_neg1__une_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLE_NEG1:%.*]] = fcmp ole float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp une float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %ole.neg1 = fcmp ole float %arg, -1.0 call void @llvm.assume(i1 %ole.neg1) @@ -398,8 +371,7 @@ define i1 @assume_ole_neg1__uno_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLE_NEG1:%.*]] = fcmp ole float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp uno float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %ole.neg1 = fcmp ole float %arg, -1.0 call void @llvm.assume(i1 %ole.neg1) @@ -500,8 +472,7 @@ define i1 @assume_ogt_neg1__ord_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGT_NEG1:%.*]] = fcmp ogt float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ord float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %ogt.neg1 = fcmp ogt float %arg, -1.0 call void @llvm.assume(i1 %ogt.neg1) @@ -598,8 +569,7 @@ define i1 @assume_ogt_neg1__uno_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGT_NEG1:%.*]] = fcmp ogt float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp uno float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %ogt.neg1 = fcmp ogt float %arg, -1.0 call void @llvm.assume(i1 %ogt.neg1) @@ -700,8 +670,7 @@ define i1 @assume_oge_neg1__ord_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGE_NEG1:%.*]] = fcmp oge float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ord float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %oge.neg1 = fcmp oge float %arg, -1.0 call void @llvm.assume(i1 %oge.neg1) @@ -798,8 +767,7 @@ define i1 @assume_oge_neg1__uno_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGE_NEG1:%.*]] = fcmp oge float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp uno float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %oge.neg1 = fcmp oge float %arg, -1.0 call void @llvm.assume(i1 %oge.neg1) @@ -1216,8 +1184,7 @@ define i1 @assume_ule_neg1__oeq_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[ULE_NEG1:%.*]] = fcmp ule float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[ULE_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %ule.neg1 = fcmp ule float %arg, -1.0 call void @llvm.assume(i1 %ule.neg1) @@ -1230,8 +1197,7 @@ define i1 @assume_ule_neg1__ogt_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[ULE_NEG1:%.*]] = fcmp ule float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[ULE_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ogt float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %ule.neg1 = fcmp ule float %arg, -1.0 call void @llvm.assume(i1 %ule.neg1) @@ -1244,8 +1210,7 @@ define i1 @assume_ule_neg1__oge_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[ULE_NEG1:%.*]] = fcmp ule float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[ULE_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp oge float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %ule.neg1 = fcmp ule float %arg, -1.0 call void @llvm.assume(i1 %ule.neg1) @@ -1356,8 +1321,7 @@ define i1 @assume_ule_neg1__ult_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[ULE_NEG1:%.*]] = fcmp ule float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[ULE_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ult float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %ule.neg1 = fcmp ule float %arg, -1.0 call void @llvm.assume(i1 %ule.neg1) @@ -1370,8 +1334,7 @@ define i1 @assume_ule_neg1__ule_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[ULE_NEG1:%.*]] = fcmp ule float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[ULE_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ule float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %ule.neg1 = fcmp ule float %arg, -1.0 call void @llvm.assume(i1 %ule.neg1) @@ -1384,8 +1347,7 @@ define i1 @assume_ule_neg1__une_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[ULE_NEG1:%.*]] = fcmp ule float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[ULE_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp une float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %ule.neg1 = fcmp ule float %arg, -1.0 call void @llvm.assume(i1 %ule.neg1) @@ -1416,8 +1378,7 @@ define i1 @assume_ult_neg1__oeq_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[ULT_NEG1:%.*]] = fcmp ult float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[ULT_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %ult.neg1 = fcmp ult float %arg, -1.0 call void @llvm.assume(i1 %ult.neg1) @@ -1430,8 +1391,7 @@ define i1 @assume_ult_neg1__ogt_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[ULT_NEG1:%.*]] = fcmp ult float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[ULT_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ogt float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %ult.neg1 = fcmp ult float %arg, -1.0 call void @llvm.assume(i1 %ult.neg1) @@ -1444,8 +1404,7 @@ define i1 @assume_ult_neg1__oge_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[ULT_NEG1:%.*]] = fcmp ult float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[ULT_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp oge float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %ult.neg1 = fcmp ult float %arg, -1.0 call void @llvm.assume(i1 %ult.neg1) @@ -1556,8 +1515,7 @@ define i1 @assume_ult_neg1__ult_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[ULT_NEG1:%.*]] = fcmp ult float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[ULT_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ult float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %ult.neg1 = fcmp ult float %arg, -1.0 call void @llvm.assume(i1 %ult.neg1) @@ -1570,8 +1528,7 @@ define i1 @assume_ult_neg1__ule_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[ULT_NEG1:%.*]] = fcmp ult float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[ULT_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ule float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %ult.neg1 = fcmp ult float %arg, -1.0 call void @llvm.assume(i1 %ult.neg1) @@ -1584,8 +1541,7 @@ define i1 @assume_ult_neg1__une_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[ULT_NEG1:%.*]] = fcmp ult float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[ULT_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp une float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %ult.neg1 = fcmp ult float %arg, -1.0 call void @llvm.assume(i1 %ult.neg1) @@ -1823,8 +1779,7 @@ define i1 @assume_olt_pos1__ord_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLT_POS1:%.*]] = fcmp olt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ord float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %olt.pos1 = fcmp olt float %arg, 1.0 call void @llvm.assume(i1 %olt.pos1) @@ -1921,8 +1876,7 @@ define i1 @assume_olt_pos1__uno_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLT_POS1:%.*]] = fcmp olt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp uno float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %olt.pos1 = fcmp olt float %arg, 1.0 call void @llvm.assume(i1 %olt.pos1) @@ -2023,8 +1977,7 @@ define i1 @assume_ole_pos1__ord_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLE_POS1:%.*]] = fcmp ole float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ord float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %ole.pos1 = fcmp ole float %arg, 1.0 call void @llvm.assume(i1 %ole.pos1) @@ -2121,8 +2074,7 @@ define i1 @assume_ole_pos1__uno_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLE_POS1:%.*]] = fcmp ole float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp uno float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %ole.pos1 = fcmp ole float %arg, 1.0 call void @llvm.assume(i1 %ole.pos1) @@ -2139,8 +2091,7 @@ define i1 @assume_ogt_pos1__oeq_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGT_POS1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %ogt.pos1 = fcmp ogt float %arg, 1.0 call void @llvm.assume(i1 %ogt.pos1) @@ -2153,8 +2104,7 @@ define i1 @assume_ogt_pos1__ogt_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGT_POS1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ogt float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %ogt.pos1 = fcmp ogt float %arg, 1.0 call void @llvm.assume(i1 %ogt.pos1) @@ -2167,8 +2117,7 @@ define i1 @assume_ogt_pos1__oge_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGT_POS1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp oge float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %ogt.pos1 = fcmp ogt float %arg, 1.0 call void @llvm.assume(i1 %ogt.pos1) @@ -2181,8 +2130,7 @@ define i1 @assume_ogt_pos1__olt_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGT_POS1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp olt float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %ogt.pos1 = fcmp ogt float %arg, 1.0 call void @llvm.assume(i1 %ogt.pos1) @@ -2195,8 +2143,7 @@ define i1 @assume_ogt_pos1__ole_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGT_POS1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ole float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %ogt.pos1 = fcmp ogt float %arg, 1.0 call void @llvm.assume(i1 %ogt.pos1) @@ -2209,8 +2156,7 @@ define i1 @assume_ogt_pos1__one_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGT_POS1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp one float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %ogt.pos1 = fcmp ogt float %arg, 1.0 call void @llvm.assume(i1 %ogt.pos1) @@ -2223,8 +2169,7 @@ define i1 @assume_ogt_pos1__ord_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGT_POS1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ord float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %ogt.pos1 = fcmp ogt float %arg, 1.0 call void @llvm.assume(i1 %ogt.pos1) @@ -2237,8 +2182,7 @@ define i1 @assume_ogt_pos1__ueq_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGT_POS1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ueq float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %ogt.pos1 = fcmp ogt float %arg, 1.0 call void @llvm.assume(i1 %ogt.pos1) @@ -2251,8 +2195,7 @@ define i1 @assume_ogt_pos1__ugt_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGT_POS1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ugt float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %ogt.pos1 = fcmp ogt float %arg, 1.0 call void @llvm.assume(i1 %ogt.pos1) @@ -2265,8 +2208,7 @@ define i1 @assume_ogt_pos1__uge_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGT_POS1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp uge float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %ogt.pos1 = fcmp ogt float %arg, 1.0 call void @llvm.assume(i1 %ogt.pos1) @@ -2279,8 +2221,7 @@ define i1 @assume_ogt_pos1__ult_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGT_POS1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ult float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %ogt.pos1 = fcmp ogt float %arg, 1.0 call void @llvm.assume(i1 %ogt.pos1) @@ -2293,8 +2234,7 @@ define i1 @assume_ogt_pos1__ule_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGT_POS1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ule float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %ogt.pos1 = fcmp ogt float %arg, 1.0 call void @llvm.assume(i1 %ogt.pos1) @@ -2307,8 +2247,7 @@ define i1 @assume_ogt_pos1__une_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGT_POS1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp une float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %ogt.pos1 = fcmp ogt float %arg, 1.0 call void @llvm.assume(i1 %ogt.pos1) @@ -2321,8 +2260,7 @@ define i1 @assume_ogt_pos1__uno_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGT_POS1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp uno float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %ogt.pos1 = fcmp ogt float %arg, 1.0 call void @llvm.assume(i1 %ogt.pos1) @@ -2339,8 +2277,7 @@ define i1 @assume_oge_pos1__oeq_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGE_POS1:%.*]] = fcmp oge float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %oge.pos1 = fcmp oge float %arg, 1.0 call void @llvm.assume(i1 %oge.pos1) @@ -2353,8 +2290,7 @@ define i1 @assume_oge_pos1__ogt_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGE_POS1:%.*]] = fcmp oge float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ogt float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %oge.pos1 = fcmp oge float %arg, 1.0 call void @llvm.assume(i1 %oge.pos1) @@ -2367,8 +2303,7 @@ define i1 @assume_oge_pos1__oge_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGE_POS1:%.*]] = fcmp oge float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp oge float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %oge.pos1 = fcmp oge float %arg, 1.0 call void @llvm.assume(i1 %oge.pos1) @@ -2381,8 +2316,7 @@ define i1 @assume_oge_pos1__olt_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGE_POS1:%.*]] = fcmp oge float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp olt float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %oge.pos1 = fcmp oge float %arg, 1.0 call void @llvm.assume(i1 %oge.pos1) @@ -2395,8 +2329,7 @@ define i1 @assume_oge_pos1__ole_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGE_POS1:%.*]] = fcmp oge float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ole float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %oge.pos1 = fcmp oge float %arg, 1.0 call void @llvm.assume(i1 %oge.pos1) @@ -2409,8 +2342,7 @@ define i1 @assume_oge_pos1__one_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGE_POS1:%.*]] = fcmp oge float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp one float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %oge.pos1 = fcmp oge float %arg, 1.0 call void @llvm.assume(i1 %oge.pos1) @@ -2423,8 +2355,7 @@ define i1 @assume_oge_pos1__ord_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGE_POS1:%.*]] = fcmp oge float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ord float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %oge.pos1 = fcmp oge float %arg, 1.0 call void @llvm.assume(i1 %oge.pos1) @@ -2437,8 +2368,7 @@ define i1 @assume_oge_pos1__ueq_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGE_POS1:%.*]] = fcmp oge float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ueq float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %oge.pos1 = fcmp oge float %arg, 1.0 call void @llvm.assume(i1 %oge.pos1) @@ -2451,8 +2381,7 @@ define i1 @assume_oge_pos1__ugt_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGE_POS1:%.*]] = fcmp oge float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ugt float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %oge.pos1 = fcmp oge float %arg, 1.0 call void @llvm.assume(i1 %oge.pos1) @@ -2465,8 +2394,7 @@ define i1 @assume_oge_pos1__uge_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGE_POS1:%.*]] = fcmp oge float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp uge float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %oge.pos1 = fcmp oge float %arg, 1.0 call void @llvm.assume(i1 %oge.pos1) @@ -2479,8 +2407,7 @@ define i1 @assume_oge_pos1__ult_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGE_POS1:%.*]] = fcmp oge float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ult float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %oge.pos1 = fcmp oge float %arg, 1.0 call void @llvm.assume(i1 %oge.pos1) @@ -2493,8 +2420,7 @@ define i1 @assume_oge_pos1__ule_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGE_POS1:%.*]] = fcmp oge float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ule float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %oge.pos1 = fcmp oge float %arg, 1.0 call void @llvm.assume(i1 %oge.pos1) @@ -2507,8 +2433,7 @@ define i1 @assume_oge_pos1__une_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGE_POS1:%.*]] = fcmp oge float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp une float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %oge.pos1 = fcmp oge float %arg, 1.0 call void @llvm.assume(i1 %oge.pos1) @@ -2521,8 +2446,7 @@ define i1 @assume_oge_pos1__uno_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OGE_POS1:%.*]] = fcmp oge float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp uno float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %oge.pos1 = fcmp oge float %arg, 1.0 call void @llvm.assume(i1 %oge.pos1) @@ -2539,8 +2463,7 @@ define i1 @assume_ugt_pos1__oeq_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[UGT_POS1:%.*]] = fcmp ugt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %ugt.pos1 = fcmp ugt float %arg, 1.0 call void @llvm.assume(i1 %ugt.pos1) @@ -2581,8 +2504,7 @@ define i1 @assume_ugt_pos1__olt_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[UGT_POS1:%.*]] = fcmp ugt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp olt float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %ugt.pos1 = fcmp ugt float %arg, 1.0 call void @llvm.assume(i1 %ugt.pos1) @@ -2595,8 +2517,7 @@ define i1 @assume_ugt_pos1__ole_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[UGT_POS1:%.*]] = fcmp ugt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ole float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %ugt.pos1 = fcmp ugt float %arg, 1.0 call void @llvm.assume(i1 %ugt.pos1) @@ -2651,8 +2572,7 @@ define i1 @assume_ugt_pos1__ugt_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[UGT_POS1:%.*]] = fcmp ugt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ugt float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %ugt.pos1 = fcmp ugt float %arg, 1.0 call void @llvm.assume(i1 %ugt.pos1) @@ -2665,8 +2585,7 @@ define i1 @assume_ugt_pos1__uge_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[UGT_POS1:%.*]] = fcmp ugt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp uge float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %ugt.pos1 = fcmp ugt float %arg, 1.0 call void @llvm.assume(i1 %ugt.pos1) @@ -2707,8 +2626,7 @@ define i1 @assume_ugt_pos1__une_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[UGT_POS1:%.*]] = fcmp ugt float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp une float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %ugt.pos1 = fcmp ugt float %arg, 1.0 call void @llvm.assume(i1 %ugt.pos1) @@ -2739,8 +2657,7 @@ define i1 @assume_uge_pos1__oeq_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[UGE_POS1:%.*]] = fcmp uge float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %uge.pos1 = fcmp uge float %arg, 1.0 call void @llvm.assume(i1 %uge.pos1) @@ -2781,8 +2698,7 @@ define i1 @assume_uge_pos1__olt_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[UGE_POS1:%.*]] = fcmp uge float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp olt float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %uge.pos1 = fcmp uge float %arg, 1.0 call void @llvm.assume(i1 %uge.pos1) @@ -2795,8 +2711,7 @@ define i1 @assume_uge_pos1__ole_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[UGE_POS1:%.*]] = fcmp uge float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ole float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %uge.pos1 = fcmp uge float %arg, 1.0 call void @llvm.assume(i1 %uge.pos1) @@ -2851,8 +2766,7 @@ define i1 @assume_uge_pos1__ugt_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[UGE_POS1:%.*]] = fcmp uge float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ugt float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %uge.pos1 = fcmp uge float %arg, 1.0 call void @llvm.assume(i1 %uge.pos1) @@ -2865,8 +2779,7 @@ define i1 @assume_uge_pos1__uge_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[UGE_POS1:%.*]] = fcmp uge float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp uge float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %uge.pos1 = fcmp uge float %arg, 1.0 call void @llvm.assume(i1 %uge.pos1) @@ -2907,8 +2820,7 @@ define i1 @assume_uge_pos1__une_0(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[UGE_POS1:%.*]] = fcmp uge float [[ARG]], 1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_POS1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp une float [[ARG]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %uge.pos1 = fcmp uge float %arg, 1.0 call void @llvm.assume(i1 %uge.pos1) @@ -2939,8 +2851,7 @@ define i1 @assume_olt_neg1__oeq_inf(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq float [[ARG]], 0x7FF0000000000000 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %olt.neg1 = fcmp olt float %arg, -1.0 call void @llvm.assume(i1 %olt.neg1) @@ -2953,8 +2864,7 @@ define i1 @assume_olt_neg1__one_inf(float %arg) { ; CHECK-SAME: float [[ARG:%.*]]) { ; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 ; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp one float [[ARG]], 0x7FF0000000000000 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 true ; %olt.neg1 = fcmp olt float %arg, -1.0 call void @llvm.assume(i1 %olt.neg1) diff --git a/llvm/unittests/Analysis/ValueTrackingTest.cpp b/llvm/unittests/Analysis/ValueTrackingTest.cpp index 4eed22d224588..5bd1bb37e678e 100644 --- a/llvm/unittests/Analysis/ValueTrackingTest.cpp +++ b/llvm/unittests/Analysis/ValueTrackingTest.cpp @@ -1848,13 +1848,13 @@ TEST_F(ComputeKnownFPClassTest, FCmpToClassTest_NInf) { fcmpToClassTest(CmpInst::FCMP_OGT, *A3->getFunction(), A3->getOperand(0), A3->getOperand(1)); EXPECT_EQ(nullptr, OgtVal); - EXPECT_EQ(fcNone, OgtClass); + EXPECT_EQ(fcAllFlags, OgtClass); auto [UleVal, UleClass] = fcmpToClassTest(CmpInst::FCMP_ULE, *A4->getFunction(), A4->getOperand(0), A4->getOperand(1)); EXPECT_EQ(nullptr, UleVal); - EXPECT_EQ(fcNone, UleClass); + EXPECT_EQ(fcAllFlags, UleClass); } TEST_F(ComputeKnownFPClassTest, FCmpToClassTest_PInf) { @@ -1881,13 +1881,13 @@ TEST_F(ComputeKnownFPClassTest, FCmpToClassTest_PInf) { fcmpToClassTest(CmpInst::FCMP_OLE, *A3->getFunction(), A3->getOperand(0), A3->getOperand(1)); EXPECT_EQ(nullptr, OleVal); - EXPECT_EQ(fcNone, OleClass); + EXPECT_EQ(fcAllFlags, OleClass); auto [UgtVal, UgtClass] = fcmpToClassTest(CmpInst::FCMP_UGT, *A4->getFunction(), A4->getOperand(0), A4->getOperand(1)); EXPECT_EQ(nullptr, UgtVal); - EXPECT_EQ(fcNone, UgtClass); + EXPECT_EQ(fcAllFlags, UgtClass); } TEST_F(ComputeKnownFPClassTest, SqrtNszSignBit) {