[llvm-branch-commits] [llvm] ADT: Add utility functions for comparing FPClassTest (PR #175380)
via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Sat Jan 10 11:37:47 PST 2026
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
More information about the llvm-branch-commits
mailing list