[llvm] [Valuetracking] Use all FPClasses ordering information for min/max (PR #199651)

[Niklas Ulvinge via llvm-commits]

================
@@ -107,36 +107,32 @@ KnownFPClass KnownFPClass::minMaxLike(const KnownFPClass &LHS_,
        Kind == MinMaxKind::minimumnum || Kind == MinMaxKind::maximumnum))
     Known.knownNot(fcNan);
 
+  FPClassTest Excluded = fcNone;
   if (Kind == MinMaxKind::maxnum || Kind == MinMaxKind::maximumnum) {
-    // If at least one operand is known to be positive, the result must be
-    // positive.
-    if ((KnownLHS.cannotBeOrderedLessThanZero() &&
-         KnownLHS.isKnownNeverNaN()) ||
-        (KnownRHS.cannotBeOrderedLessThanZero() && KnownRHS.isKnownNeverNaN()))
-      Known.knownNot(KnownFPClass::OrderedLessThanZeroMask);
+    if (KnownLHS.isKnownNeverNaN())
+      Excluded |= orderedStrictlyLess(KnownLHS.KnownFPClasses);
+    if (KnownRHS.isKnownNeverNaN())
+      Excluded |= orderedStrictlyLess(KnownRHS.KnownFPClasses);
   } else if (Kind == MinMaxKind::maximum) {
-    // If at least one operand is known to be positive, the result must be
-    // positive.
-    if (KnownLHS.cannotBeOrderedLessThanZero() ||
-        KnownRHS.cannotBeOrderedLessThanZero())
-      Known.knownNot(KnownFPClass::OrderedLessThanZeroMask);
+    Excluded = orderedStrictlyLess(KnownLHS.KnownFPClasses) |
+               orderedStrictlyLess(KnownRHS.KnownFPClasses);
   } else if (Kind == MinMaxKind::minnum || Kind == MinMaxKind::minimumnum) {
-    // If at least one operand is known to be negative, the result must be
-    // negative.
-    if ((KnownLHS.cannotBeOrderedGreaterThanZero() &&
-         KnownLHS.isKnownNeverNaN()) ||
-        (KnownRHS.cannotBeOrderedGreaterThanZero() &&
-         KnownRHS.isKnownNeverNaN()))
-      Known.knownNot(KnownFPClass::OrderedGreaterThanZeroMask);
+    if (KnownLHS.isKnownNeverNaN())
+      Excluded |= orderedStrictlyGreater(KnownLHS.KnownFPClasses);
+    if (KnownRHS.isKnownNeverNaN())
+      Excluded |= orderedStrictlyGreater(KnownRHS.KnownFPClasses);
   } else if (Kind == MinMaxKind::minimum) {
-    // If at least one operand is known to be negative, the result must be
-    // negative.
-    if (KnownLHS.cannotBeOrderedGreaterThanZero() ||
-        KnownRHS.cannotBeOrderedGreaterThanZero())
-      Known.knownNot(KnownFPClass::OrderedGreaterThanZeroMask);
+    Excluded = orderedStrictlyGreater(KnownLHS.KnownFPClasses) |
+               orderedStrictlyGreater(KnownRHS.KnownFPClasses);
   } else
     llvm_unreachable("unhandled intrinsic");
 
+  // We cannot exclude just one zero since the operation may be NSZ
+  if ((Excluded & fcZero) != fcZero)
+    Excluded &= ~fcZero;
----------------
nulvinge wrote:

I wrote a test that enumerated all cases for denormals, comparing this and the previous verison, and found no cases where the mode affected the result and where the result differed.

https://github.com/llvm/llvm-project/pull/199651