llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-llvm-transforms Author: Matt Arsenault (arsenm) <details> <summary>Changes</summary> Add utility functions for checking if less and greater queries are known to not evaluate to true. This will permit more precise folding of min/max intrinsics. The test is kind of a mess. --- Patch is 32.29 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/175380.diff 3 Files Affected: - (modified) llvm/include/llvm/ADT/FloatingPointMode.h (+34) - (modified) llvm/lib/Support/FloatingPointMode.cpp (+61) - (modified) llvm/unittests/ADT/FloatingPointMode.cpp (+561) ``````````diff diff --git a/llvm/include/llvm/ADT/FloatingPointMode.h b/llvm/include/llvm/ADT/FloatingPointMode.h index 0605e0b4f4cf9..a462dc1dd6ce4 100644 --- a/llvm/include/llvm/ADT/FloatingPointMode.h +++ b/llvm/include/llvm/ADT/FloatingPointMode.h @@ -285,6 +285,40 @@ LLVM_ABI FPClassTest unknown_sign(FPClassTest Mask); /// Write a human readable form of \p Mask to \p OS LLVM_ABI raw_ostream &operator<<(raw_ostream &OS, FPClassTest Mask); +/// Returns true if all values in \p LHS must be less than or equal to those in +/// \p RHS. That is, the comparison `fcmp ogt LHS, RHS` will always return +/// false. +/// +/// If \p OrderedZeroSign is true, -0 will be treated as ordered less than +0, +/// unlike fcmp. +LLVM_ABI bool cannotOrderStrictlyGreater(FPClassTest LHS, FPClassTest RHS, + bool OrderedZeroSign = false); + +/// Returns true if all values in \p LHS must be less than those in \p RHS. That +/// is, the comparison `fcmp oge LHS, RHS` will always return false. +// +// If \p OrderedZeroSign is true, -0 will be treated as ordered less than +0, +// unlike fcmp. +LLVM_ABI bool cannotOrderStrictlyGreaterEq(FPClassTest LHS, FPClassTest RHS, + bool OrderedZeroSign = false); + +/// Returns true if all values in \p LHS must be greater than or equal to those +/// in \p RHS. That is, the comparison `fcmp olt LHS, RHS` will always return +/// false. +/// +/// If \p OrderedZeroSign is true, -0 will be treated as ordered less than +0, +/// unlike fcmp. +LLVM_ABI bool cannotOrderStrictlyLess(FPClassTest LHS, FPClassTest RHS, + bool OrderedZeroSign = false); + +/// Returns true if all values in \p LHS must be greater than to those in \p +/// RHS. That is, the comparison `fcmp ole LHS, RHS` will always return false. +/// +/// If \p OrderedZeroSign is true, -0 will be treated as ordered less than +0, +/// unlike fcmp. +LLVM_ABI bool cannotOrderStrictlyLessEq(FPClassTest LHS, FPClassTest RHS, + bool OrderedZeroSign = false); + } // namespace llvm #endif // LLVM_ADT_FLOATINGPOINTMODE_H diff --git a/llvm/lib/Support/FloatingPointMode.cpp b/llvm/lib/Support/FloatingPointMode.cpp index 5a2836eb82434..a4059f9ad3083 100644 --- a/llvm/lib/Support/FloatingPointMode.cpp +++ b/llvm/lib/Support/FloatingPointMode.cpp @@ -106,3 +106,64 @@ raw_ostream &llvm::operator<<(raw_ostream &OS, FPClassTest Mask) { OS << ')'; return OS; } + +static bool cannotOrderStrictlyGreaterImpl(FPClassTest LHS, FPClassTest RHS, + bool OrEqual, bool OrderedZero) { + LHS &= ~fcNan; + RHS &= ~fcNan; + + if (LHS == fcNone || RHS == fcNone) + return true; + + FPClassTest Intersect = LHS & RHS; + FPClassTest LowestBitRHS = static_cast<FPClassTest>(RHS & -RHS); + FPClassTest HighestBitLHS = static_cast<FPClassTest>(1 << Log2_32(LHS)); + + if (!OrderedZero) { + // Introduce conflict in zero bits if we're treating them as equal. + if (LowestBitRHS == fcNegZero) + LowestBitRHS = fcPosZero; + if (HighestBitLHS == fcNegZero) + HighestBitLHS = fcPosZero; + } + + if (LowestBitRHS > HighestBitLHS) { + assert(Intersect == fcNone); + return true; + } + + if (LowestBitRHS < HighestBitLHS) + return false; + + constexpr FPClassTest ExactValuesMask = fcZero | fcInf; + + if ((LowestBitRHS & ExactValuesMask) == fcNone) + return false; + + if (OrEqual) { + + return (LowestBitRHS & ExactValuesMask) == fcNone; + } + + return (LowestBitRHS & ExactValuesMask) != fcNone; +} + +bool llvm::cannotOrderStrictlyGreater(FPClassTest LHS, FPClassTest RHS, + bool OrderedZeroSign) { + return cannotOrderStrictlyGreaterImpl(LHS, RHS, false, OrderedZeroSign); +} + +bool llvm::cannotOrderStrictlyGreaterEq(FPClassTest LHS, FPClassTest RHS, + bool OrderedZeroSign) { + return cannotOrderStrictlyGreaterImpl(LHS, RHS, true, OrderedZeroSign); +} + +bool llvm::cannotOrderStrictlyLess(FPClassTest LHS, FPClassTest RHS, + bool OrderedZeroSign) { + return cannotOrderStrictlyGreaterImpl(RHS, LHS, false, OrderedZeroSign); +} + +bool llvm::cannotOrderStrictlyLessEq(FPClassTest LHS, FPClassTest RHS, + bool OrderedZeroSign) { + return cannotOrderStrictlyGreaterImpl(RHS, LHS, true, OrderedZeroSign); +} diff --git a/llvm/unittests/ADT/FloatingPointMode.cpp b/llvm/unittests/ADT/FloatingPointMode.cpp index b87507625542e..870a080cabcb7 100644 --- a/llvm/unittests/ADT/FloatingPointMode.cpp +++ b/llvm/unittests/ADT/FloatingPointMode.cpp @@ -13,6 +13,11 @@ using namespace llvm; namespace { +static constexpr FPClassTest OrderedLessThanZeroMask = + fcNegSubnormal | fcNegNormal | fcNegInf; +static constexpr FPClassTest OrderedGreaterThanZeroMask = + fcPosSubnormal | fcPosNormal | fcPosInf; + TEST(FloatingPointModeTest, ParseDenormalFPAttributeComponent) { EXPECT_EQ(DenormalMode::IEEE, parseDenormalFPAttributeComponent("ieee")); EXPECT_EQ(DenormalMode::IEEE, parseDenormalFPAttributeComponent("")); @@ -226,4 +231,560 @@ TEST(FloatingPointModeTest, DenormalModePredicates) { EXPECT_FALSE(DenormalMode::getIEEE().inputsAreZero()); EXPECT_FALSE(DenormalMode::getDynamic().inputsAreZero()); } + +#define TEST_ORDERED_LT(a, b) \ + EXPECT_TRUE(cannotOrderStrictlyGreater(a, b)); \ + EXPECT_FALSE(cannotOrderStrictlyGreater(b, a)); + +TEST(FloatingPointModeTest, cannotOrderStrictlyGreater) { + EXPECT_TRUE(cannotOrderStrictlyGreater(fcNone, fcNone)); + EXPECT_FALSE(cannotOrderStrictlyGreater(fcAllFlags, fcAllFlags)); + + EXPECT_TRUE(cannotOrderStrictlyGreater(fcNan, fcNan)); + EXPECT_TRUE(cannotOrderStrictlyGreater(fcQNan, fcQNan)); + EXPECT_TRUE(cannotOrderStrictlyGreater(fcSNan, fcSNan)); + EXPECT_TRUE(cannotOrderStrictlyGreater(fcSNan, fcQNan)); + EXPECT_TRUE(cannotOrderStrictlyGreater(fcQNan, fcSNan)); + EXPECT_TRUE(cannotOrderStrictlyGreater(fcQNan, fcNan)); + EXPECT_TRUE(cannotOrderStrictlyGreater(fcSNan, fcNan)); + + EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegInf, fcSNan)); + EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegInf, fcQNan)); + EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegInf, fcNan)); + EXPECT_TRUE(cannotOrderStrictlyGreater(fcSNan, fcNegInf)); + EXPECT_TRUE(cannotOrderStrictlyGreater(fcQNan, fcNegInf)); + EXPECT_TRUE(cannotOrderStrictlyGreater(fcNan, fcNegInf)); + EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegInf, fcNegInf)); + EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegZero, fcPosZero)); + EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegZero, fcPosZero, true)); + EXPECT_TRUE(cannotOrderStrictlyGreater(fcPosZero, fcNegZero)); + EXPECT_FALSE(cannotOrderStrictlyGreater(fcPosZero, fcNegZero, true)); + + EXPECT_TRUE(cannotOrderStrictlyGreater(fcPosZero, fcPosZero)); + EXPECT_TRUE(cannotOrderStrictlyGreater(fcPosZero, fcPosZero, true)); + + EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegZero, fcNegZero)); + EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegZero, fcNegZero, true)); + + EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegSubnormal, fcNegZero)); + EXPECT_FALSE(cannotOrderStrictlyGreater(fcNegZero, fcNegSubnormal)); + + EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegZero, fcPosSubnormal)); + EXPECT_FALSE(cannotOrderStrictlyGreater(fcPosSubnormal, fcNegZero)); + + EXPECT_FALSE(cannotOrderStrictlyGreater(fcNegZero, fcSubnormal)); + EXPECT_FALSE(cannotOrderStrictlyGreater(fcSubnormal, fcNegZero)); + + + EXPECT_TRUE(cannotOrderStrictlyGreater(fcPosZero, fcPosSubnormal)); + EXPECT_FALSE(cannotOrderStrictlyGreater(fcPosSubnormal, fcPosZero)); + + EXPECT_FALSE(cannotOrderStrictlyGreater(fcPosZero, fcNegSubnormal)); + EXPECT_FALSE(cannotOrderStrictlyGreater(fcPosZero, fcNegSubnormal, true)); + EXPECT_FALSE(cannotOrderStrictlyGreater(fcZero, fcSubnormal)); + EXPECT_FALSE(cannotOrderStrictlyGreater(fcZero, fcSubnormal, true)); + EXPECT_FALSE(cannotOrderStrictlyGreater(fcZero, fcNegSubnormal)); + + EXPECT_TRUE(cannotOrderStrictlyGreater(fcZero, fcPosSubnormal)); + EXPECT_FALSE(cannotOrderStrictlyGreater(fcPosSubnormal, fcZero)); + + TEST_ORDERED_LT(fcNegInf, fcNegNormal); + TEST_ORDERED_LT(fcNegInf, fcNegSubnormal); + TEST_ORDERED_LT(fcNegInf, fcNegZero); + TEST_ORDERED_LT(fcNegInf, fcPosZero); + TEST_ORDERED_LT(fcNegInf, fcPosSubnormal); + TEST_ORDERED_LT(fcNegInf, fcPosNormal); + TEST_ORDERED_LT(fcNegInf, fcPosInf); + + TEST_ORDERED_LT(fcNegNormal, fcPosNormal); + TEST_ORDERED_LT(fcNegNormal, fcPositive); + TEST_ORDERED_LT(fcNegNormal, fcPositive | fcNan); + TEST_ORDERED_LT(fcNegNormal | fcNan, fcPositive | fcNan); + + EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegNormal, fcPosNormal | fcNan)); + EXPECT_FALSE(cannotOrderStrictlyGreater(fcPosNormal | fcNan, fcNegNormal)); + EXPECT_FALSE( + cannotOrderStrictlyGreater(fcPosNormal | fcNan, fcNegNormal | fcNan)); + EXPECT_FALSE(cannotOrderStrictlyGreater(fcNegNormal | fcNan, fcNegNormal)); + EXPECT_FALSE( + cannotOrderStrictlyGreater(fcNegNormal | fcNan, fcNegNormal | fcNan)); + + EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegInf, ~fcNegInf)); + EXPECT_FALSE(cannotOrderStrictlyGreater(~fcNegInf, fcNegInf)); + + TEST_ORDERED_LT(fcNegInf, ~(fcNegInf | fcNan)); + TEST_ORDERED_LT(fcNegative, fcPositive); + TEST_ORDERED_LT(fcNegFinite, fcPosFinite); + TEST_ORDERED_LT(fcNegZero, fcPosInf); + TEST_ORDERED_LT(fcPosZero, fcPosInf); + TEST_ORDERED_LT(fcZero, fcPosInf); + + EXPECT_FALSE(cannotOrderStrictlyGreater(fcNegZero, fcNegInf)); + EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegInf, fcNegZero)); + + EXPECT_FALSE(cannotOrderStrictlyGreater(fcZero, fcInf)); + EXPECT_FALSE(cannotOrderStrictlyGreater(fcInf, fcZero)); + + EXPECT_FALSE(cannotOrderStrictlyGreater(fcZero, fcInf | fcNan)); + EXPECT_FALSE(cannotOrderStrictlyGreater(fcInf | fcNan, fcZero)); + + EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegInf | fcNan, fcZero)); + EXPECT_FALSE(cannotOrderStrictlyGreater(fcPosInf | fcNan, fcZero)); + + EXPECT_FALSE(cannotOrderStrictlyGreater(fcZero | fcNan, fcInf)); + EXPECT_FALSE(cannotOrderStrictlyGreater(fcInf, fcZero | fcNan)); + + TEST_ORDERED_LT(OrderedLessThanZeroMask, OrderedGreaterThanZeroMask); + TEST_ORDERED_LT(OrderedLessThanZeroMask, OrderedGreaterThanZeroMask | fcNan); + + TEST_ORDERED_LT(OrderedLessThanZeroMask | fcNegZero, + OrderedGreaterThanZeroMask); + TEST_ORDERED_LT(OrderedLessThanZeroMask | fcPosZero, + OrderedGreaterThanZeroMask); + TEST_ORDERED_LT(OrderedLessThanZeroMask | fcZero, OrderedGreaterThanZeroMask); + + EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegZero, fcPosZero)); + EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegZero, fcPosZero, true)); + EXPECT_TRUE(cannotOrderStrictlyGreater(fcPosZero, fcNegZero)); + EXPECT_FALSE(cannotOrderStrictlyGreater(fcPosZero, fcNegZero, true)); + + TEST_ORDERED_LT(fcNegZero, fcPosSubnormal); + TEST_ORDERED_LT(fcNegZero, fcPosZero | fcPosSubnormal); + TEST_ORDERED_LT(fcNegZero, OrderedGreaterThanZeroMask); + + EXPECT_FALSE(cannotOrderStrictlyGreater(OrderedLessThanZeroMask, + OrderedLessThanZeroMask | fcNan)); + EXPECT_FALSE(cannotOrderStrictlyGreater(OrderedLessThanZeroMask | fcNan, + OrderedLessThanZeroMask | fcNan)); + + TEST_ORDERED_LT(fcZero, fcPosInf); + TEST_ORDERED_LT(fcZero, fcPosInf | fcNan); + + EXPECT_TRUE(cannotOrderStrictlyGreater(fcZero | fcNan, fcPosInf)); + + TEST_ORDERED_LT(fcPosNormal, fcPosInf); + TEST_ORDERED_LT(fcPosNormal, fcPosInf | fcNan); + + TEST_ORDERED_LT(fcNegInf, fcPosInf); + TEST_ORDERED_LT(fcNegInf | fcNegZero, fcPosInf); + + EXPECT_TRUE( + cannotOrderStrictlyGreater(fcNegInf | fcNegZero, fcZero | fcPosInf)); + EXPECT_FALSE( + cannotOrderStrictlyGreater(fcZero | fcPosInf, fcNegInf | fcNegZero)); + + EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegInf | fcNegZero, + fcZero | fcPosInf, true)); + EXPECT_FALSE(cannotOrderStrictlyGreater(fcZero | fcPosInf, + fcNegInf | fcNegZero, true)); + + EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegInf | fcNegZero, + fcZero | fcPosInf | fcNan)); + EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegInf | fcNegZero, + fcPosZero | fcPosInf | fcNan)); + + EXPECT_TRUE(cannotOrderStrictlyGreater(fcPosInf, fcPosInf)); + EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegInf, fcNegInf)); + EXPECT_TRUE(cannotOrderStrictlyGreater(fcPosZero, fcPosZero)); + EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegZero, fcNegZero)); + EXPECT_FALSE(cannotOrderStrictlyGreater(fcNegSubnormal, fcNegSubnormal)); + EXPECT_FALSE(cannotOrderStrictlyGreater(fcPosSubnormal, fcPosSubnormal)); + EXPECT_FALSE(cannotOrderStrictlyGreater(fcNegNormal, fcNegNormal)); + EXPECT_FALSE(cannotOrderStrictlyGreater(fcPosNormal, fcPosNormal)); + + EXPECT_FALSE(cannotOrderStrictlyGreater(fcFinite, fcFinite)); + + EXPECT_FALSE(cannotOrderStrictlyGreater(fcFinite, fcInf)); + EXPECT_FALSE(cannotOrderStrictlyGreater(fcInf, fcInf)); + + EXPECT_FALSE(cannotOrderStrictlyGreater(fcPosInf, ~fcPosInf)); + EXPECT_TRUE(cannotOrderStrictlyGreater(~fcPosInf, fcPosInf)); + + EXPECT_TRUE(cannotOrderStrictlyGreater(fcNegInf, ~fcNegInf)); + EXPECT_FALSE(cannotOrderStrictlyGreater(~fcNegInf, fcNegInf)); +} + +TEST(FloatingPointModeTest, cannotOrderStrictlyGreaterEq) { + EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNone, fcNone)); + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcAllFlags, fcAllFlags)); + + EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNan, fcNan)); + EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcQNan, fcQNan)); + EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcSNan, fcSNan)); + EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcSNan, fcQNan)); + EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcQNan, fcSNan)); + EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcQNan, fcNan)); + EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcSNan, fcNan)); + + EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNegInf, fcSNan)); + EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNegInf, fcQNan)); + EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNegInf, fcNan)); + EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcSNan, fcNegInf)); + EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcQNan, fcNegInf)); + EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNan, fcNegInf)); + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegInf, fcNegInf)); + EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNegZero, fcPosZero, + /*OrderedZeroSign=*/true)); + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegZero, fcPosZero)); + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosZero, fcNegZero)); + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosZero, fcNegZero, + /*OrderedZeroSign=*/true)); + + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosZero, fcPosZero)); + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosZero, fcPosZero, + /*OrderedZeroSign=*/true)); + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegZero, fcNegZero)); + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegZero, fcNegZero, + /*OrderedZeroSign=*/true)); + + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(OrderedLessThanZeroMask, + OrderedLessThanZeroMask)); + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(OrderedLessThanZeroMask, + OrderedLessThanZeroMask | fcNan)); + + EXPECT_TRUE(cannotOrderStrictlyGreaterEq(OrderedLessThanZeroMask, + OrderedGreaterThanZeroMask)); + EXPECT_TRUE(cannotOrderStrictlyGreaterEq(OrderedLessThanZeroMask, + OrderedGreaterThanZeroMask | fcNan)); + + EXPECT_TRUE(cannotOrderStrictlyGreaterEq(OrderedLessThanZeroMask | fcNan, + OrderedGreaterThanZeroMask)); + + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegZero, fcNegZero | fcNan)); + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegZero | fcNan, fcNegZero)); + + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegZero, fcPosZero)); + EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNegZero, fcPosZero, + /*OrderedZeroSign=*/true)); + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosZero, fcNegZero)); + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegZero | fcNan, fcPosZero)); + EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNegZero | fcNan, fcPosZero, + /*OrderedZeroSign=*/true)); + + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosZero | fcNan, fcNegZero)); + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegZero, fcPosZero | fcNan)); + EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNegZero, fcPosZero | fcNan, + /*OrderedZeroSign=*/true)); + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosZero, fcNegZero | fcNan)); + + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegZero, fcZero)); + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcZero, fcNegZero, + /*OrderedZeroSign=*/true)); + + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcZero, fcPosZero)); + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcZero, fcPosZero, + /*OrderedZeroSign=*/true)); + + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosInf, fcPosInf)); + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosInf, fcPosInf | fcNan)); + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosInf | fcNan, fcPosInf)); + EXPECT_FALSE( + cannotOrderStrictlyGreaterEq(fcPosInf | fcNan, fcPosInf | fcNan)); + + EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNegSubnormal, fcPosZero)); + EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNegSubnormal, fcNegZero)); + EXPECT_FALSE( + cannotOrderStrictlyGreaterEq(fcNegSubnormal | fcNegZero, fcNegZero)); + + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosSubnormal, fcZero)); + EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNegSubnormal, fcZero)); + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcSubnormal, fcZero)); + + EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcZero, fcPosInf)); + EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcZero, fcPosInf | fcNan)); + EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcZero | fcNan, fcPosInf)); + + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosNormal, fcPosNormal)); + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosSubnormal, fcPosSubnormal)); + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegNormal, fcNegNormal)); + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegSubnormal, fcNegSubnormal)); + + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosNormal | fcPosSubnormal, + fcPosNormal | fcPosSubnormal)); + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegNormal | fcNegSubnormal, + fcNegNormal | fcNegSubnormal)); + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNormal, fcNormal)); + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcSubnormal, fcSubnormal)); + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcSubnormal | fcNormal, + fcSubnormal | fcNormal)); + + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegInf, fcNegInf | fcNan)); + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegInf | fcNan, fcNegInf)); + + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegSubnormal, fcNegNormal)); + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcPosSubnormal, fcNegNormal)); + + EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcPosSubnormal, fcPosNormal)); + EXPECT_TRUE(cannotOrderStrictlyGreaterEq(fcNegSubnormal, fcPosNormal)); + + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegSubnormal, fcNegInf)); + + EXPECT_FALSE( + cannotOrderStrictlyGreaterEq(fcNegInf | fcNegZero, fcZero | fcPosInf)); + EXPECT_FALSE( + cannotOrderStrictlyGreaterEq(fcZero | fcPosInf, fcNegInf | fcNegZero)); + + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegInf | fcNegZero, + fcZero | fcPosInf | fcNan)); + EXPECT_FALSE(cannotOrderStrictlyGreaterEq(fcNegInf | ... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/175380 _______________________________________________ llvm-branch-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
