[llvm] add GenericFloatingPointPredicateUtils (llvm#140254)

add `GenericFloatingPointPredicateUtils` in order to generalize
effects of floating point comparisons on `KnownFPClass` for both IR and
MIR.

---------

Co-authored-by: Matt Arsenault <[email protected]>

Author: tgymnich

llvm/include/llvm/ADT/GenericFloatingPointPredicateUtils.h

@@ -0,0 +1,73 @@
+//===- llvm/Analysis/FloatingPointPredicateUtils.h ------------*- C++ -*---===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ANALYSIS_FLOATINGPOINTPREDICATEUTILS_H
+#define LLVM_ANALYSIS_FLOATINGPOINTPREDICATEUTILS_H
+
+#include "llvm/ADT/GenericFloatingPointPredicateUtils.h"
+#include "llvm/IR/SSAContext.h"
+
+namespace llvm {
+
+using FloatingPointPredicateUtils =
+    GenericFloatingPointPredicateUtils<SSAContext>;
+
+/// Returns a pair of values, which if passed to llvm.is.fpclass, returns the
+/// same result as an fcmp with the given operands.
+///
+/// If \p LookThroughSrc is true, consider the input value when computing the
+/// mask.
+///
+/// If \p LookThroughSrc is false, ignore the source value (i.e. the first pair
+/// element will always be LHS.
+inline std::pair<Value *, FPClassTest>
+fcmpToClassTest(FCmpInst::Predicate Pred, const Function &F, Value *LHS,
+                Value *RHS, bool LookThroughSrc = true) {
+  return FloatingPointPredicateUtils::fcmpToClassTest(Pred, F, LHS, RHS,
+                                                      LookThroughSrc = true);
+}
+
+/// Returns a pair of values, which if passed to llvm.is.fpclass, returns the
+/// same result as an fcmp with the given operands.
+///
+/// If \p LookThroughSrc is true, consider the input value when computing the
+/// mask.
+///
+/// If \p LookThroughSrc is false, ignore the source value (i.e. the first pair
+/// element will always be LHS.
+inline std::pair<Value *, FPClassTest>
+fcmpToClassTest(FCmpInst::Predicate Pred, const Function &F, Value *LHS,
+                const APFloat *ConstRHS, bool LookThroughSrc = true) {
+  return FloatingPointPredicateUtils::fcmpToClassTest(Pred, F, LHS, *ConstRHS,
+                                                      LookThroughSrc);
+}
+
+inline std::tuple<Value *, FPClassTest, FPClassTest>
+fcmpImpliesClass(CmpInst::Predicate Pred, const Function &F, Value *LHS,
+                 FPClassTest RHSClass, bool LookThroughSrc = true) {
+  return FloatingPointPredicateUtils::fcmpImpliesClass(Pred, F, LHS, RHSClass,
+                                                       LookThroughSrc);
+}
+
+inline std::tuple<Value *, FPClassTest, FPClassTest>
+fcmpImpliesClass(CmpInst::Predicate Pred, const Function &F, Value *LHS,
+                 const APFloat &ConstRHS, bool LookThroughSrc = true) {
+  return FloatingPointPredicateUtils::fcmpImpliesClass(Pred, F, LHS, ConstRHS,
+                                                       LookThroughSrc);
+}
+
+inline std::tuple<Value *, FPClassTest, FPClassTest>
+fcmpImpliesClass(CmpInst::Predicate Pred, const Function &F, Value *LHS,
+                 Value *RHS, bool LookThroughSrc = true) {
+  return FloatingPointPredicateUtils::fcmpImpliesClass(Pred, F, LHS, RHS,
+                                                       LookThroughSrc);
+}
+
+} // namespace llvm
+
+#endif // LLVM_ANALYSIS_FLOATINGPOINTPREDICATEUTILS_H

llvm/include/llvm/Analysis/FloatingPointPredicateUtils.h

@@ -213,49 +213,6 @@ Intrinsic::ID getIntrinsicForCallSite(const CallBase &CB,
 bool isSignBitCheck(ICmpInst::Predicate Pred, const APInt &RHS,
                     bool &TrueIfSigned);
 
-/// Returns a pair of values, which if passed to llvm.is.fpclass, returns the
-/// same result as an fcmp with the given operands.
-///
-/// If \p LookThroughSrc is true, consider the input value when computing the
-/// mask.
-///
-/// If \p LookThroughSrc is false, ignore the source value (i.e. the first pair
-/// element will always be LHS.
-std::pair<Value *, FPClassTest> fcmpToClassTest(CmpInst::Predicate Pred,
-                                                const Function &F, Value *LHS,
-                                                Value *RHS,
-                                                bool LookThroughSrc = true);
-std::pair<Value *, FPClassTest> fcmpToClassTest(CmpInst::Predicate Pred,
-                                                const Function &F, Value *LHS,
-                                                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<Value *, FPClassTest, FPClassTest>
-fcmpImpliesClass(CmpInst::Predicate Pred, const Function &F, Value *LHS,
-                 Value *RHS, bool LookThroughSrc = true);
-std::tuple<Value *, FPClassTest, FPClassTest>
-fcmpImpliesClass(CmpInst::Predicate Pred, const Function &F, Value *LHS,
-                 FPClassTest RHS, bool LookThroughSrc = true);
-std::tuple<Value *, FPClassTest, FPClassTest>
-fcmpImpliesClass(CmpInst::Predicate Pred, const Function &F, Value *LHS,
-                 const APFloat &RHS, bool LookThroughSrc = true);
-
 /// Determine which floating-point classes are valid for \p V, and return them
 /// in KnownFPClass bit sets.
 ///

llvm/include/llvm/Analysis/ValueTracking.h

@@ -0,0 +1,46 @@
+//===-- MachineFloatingPointModeUtils.h -----*- C++ ---------------------*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CODEGEN_MACHINEFLOATINGPOINTPREDICATEUTILS_H
+#define LLVM_CODEGEN_MACHINEFLOATINGPOINTPREDICATEUTILS_H
+
+#include "llvm/ADT/GenericFloatingPointPredicateUtils.h"
+#include "llvm/CodeGen/MachineSSAContext.h"
+
+namespace llvm {
+
+using MachineFloatingPointPredicateUtils =
+    GenericFloatingPointPredicateUtils<MachineSSAContext>;
+
+/// 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.
+///
+inline std::tuple<Register, FPClassTest, FPClassTest>
+fcmpImpliesClass(CmpInst::Predicate Pred, const MachineFunction &MF,
+                 Register LHS, Register RHS, bool LookThroughSrc = true) {
+  return MachineFloatingPointPredicateUtils::fcmpImpliesClass(
+      Pred, MF, LHS, RHS, LookThroughSrc);
+}
+
+} // namespace llvm
+
+#endif // LLVM_CODEGEN_MACHINEFLOATINGPOINTPREDICATEUTILS_H

llvm/include/llvm/CodeGen/MachineFloatingPointPredicateUtils.h

@@ -74,6 +74,7 @@ add_llvm_component_library(LLVMAnalysis
   DXILResource.cpp
   DXILMetadataAnalysis.cpp
   EphemeralValuesCache.cpp
+  FloatingPointPredicateUtils.cpp
   FunctionPropertiesAnalysis.cpp
   GlobalsModRef.cpp
   GuardUtils.cpp

llvm/lib/Analysis/CMakeLists.txt

@@ -0,0 +1,41 @@
+//===- FloatingPointPredicateUtils.cpp ------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Analysis/FloatingPointPredicateUtils.h"
+#include "llvm/IR/PatternMatch.h"
+#include <optional>
+
+namespace llvm {
+
+using namespace PatternMatch;
+
+template <>
+DenormalMode FloatingPointPredicateUtils::queryDenormalMode(const Function &F,
+                                                            Value *Val) {
+  Type *Ty = Val->getType()->getScalarType();
+  return F.getDenormalMode(Ty->getFltSemantics());
+}
+
+template <>
+bool FloatingPointPredicateUtils::lookThroughFAbs(const Function &F, Value *LHS,
+                                                  Value *&Src) {
+  return match(LHS, m_FAbs(m_Value(Src)));
+}
+
+template <>
+std::optional<APFloat>
+FloatingPointPredicateUtils::matchConstantFloat(const Function &F, Value *Val) {
+  const APFloat *ConstVal;
+
+  if (!match(Val, m_APFloatAllowPoison(ConstVal)))
+    return std::nullopt;
+
+  return *ConstVal;
+}
+
+} // namespace llvm

llvm/lib/Analysis/FloatingPointPredicateUtils.cpp

@@ -26,6 +26,7 @@
 #include "llvm/Analysis/CaptureTracking.h"
 #include "llvm/Analysis/CmpInstAnalysis.h"
 #include "llvm/Analysis/ConstantFolding.h"
+#include "llvm/Analysis/FloatingPointPredicateUtils.h"
 #include "llvm/Analysis/InstSimplifyFolder.h"
 #include "llvm/Analysis/Loads.h"
 #include "llvm/Analysis/LoopAnalysisManager.h"