ValueTracking: Add start of computeKnownFPClass API

[arsenm]

Summary

Add a new compute-known-bits like function to compute all
the interesting floating point properties at once.

Eventually this should absorb all the various floating point
queries we already have.

The operators on FPClassTest should really go with the definition in FloatingPointMode.h
and are reusable in InstCombine; they're where they are to avoid merge pain for myself in
some of my other patches backed up in review

[arsenm]

ping

[jcranmer-intel]

llvm/include/llvm/Analysis/ValueTracking.h

217–221

Would it make sense instead to have a std::optional<bool> KnownSignBit here?

llvm/lib/Analysis/ValueTracking.cpp

4108–4110

This pattern is common enough that I think KnownFPClass should have a ruleOut(FPClassTest) method or something similar to implement this method.

[arsenm]

Address comments, move FPClassTest functions (FPClassTest needs additional cleanups to get it into the llvm namespace and use BitmaskEnum(

[foad]

llvm/include/llvm/Analysis/ValueTracking.h

251

You shouldn't need & fcAllFlags here.

[arsenm]

llvm/include/llvm/Analysis/ValueTracking.h

217–221

Annoyingly operator &/|/^ don't work on std::optional<bool> so I think this made some of the patch a bit uglier

llvm/lib/Analysis/ValueTracking.cpp

4108–4110

knownNot?

[arsenm]

Rebase

[arsenm]

Clean up a few more casts now that BitmaskEnum works for FPClassTest

[arsenm]

Move classify to APFloat

[nikic]

llvm/include/llvm/ADT/FloatingPointMode.h

253

Commit these NFC changes separately? It would be nice if they weren't part of the header though.

llvm/lib/Support/APFloat.cpp

5375 ↗

(On Diff #501303)

Commit this separately (with more extensive unit test coverage)?

[sepavloff]

llvm/include/llvm/ADT/FloatingPointMode.h

253

Both these functions require documentation about its meaning.

[arsenm]

Rebase

[arsenm]

ping

[nikic]

llvm/include/llvm/Analysis/ValueTracking.h

227

I don't understand your logic here. If & is supposed to be (doc comments?) an intersection, then if one side knows the sign bit and the other doesn't, shouldn't we be using the known sign bit?

It doesn't look like operator&= or commonBits() is actually used though. It may be worthwhile to split out this class into a separate header (like KnownBits) and unit test it.

[arsenm]

llvm/include/llvm/Analysis/ValueTracking.h

227

If you don't know one of the sign bits you don't know anything. & should only return true if we know both sign bits must be true

[nikic]

llvm/include/llvm/Analysis/ValueTracking.h

227

Isn't that inconsistent with what you do with the FP classes? Say the left one is fcNegative | fcPositive with SignBit unknown and the right one is fcPositive with SignBit one. Now I would expect & to return fcPositive with SignBit one, but you return fcPositive with SignBit unknown.

(I'm assuming you aren't treating & as a literally a bitwise operation on the bitwise float representation, because then the FP class handling makes no sense.)

[arsenm]

llvm/include/llvm/Analysis/ValueTracking.h

227

There are additional fixups for the known sign bit implied by the mask, like your example. This should be conservatively correct as-is. But since it's unused I can just drop this and sort it out later

[jcranmer-intel]

llvm/include/llvm/Analysis/ValueTracking.h

227

I'm with nikic here--the natural interpretation of &/| for this datastructure is intersection/union of knowledge, and the sign bit handling in & seems out-of-place compared to in other places. Without seeing uses of this method, it's not clear to me why the unknown-if-either-is-unknown should be correct for &.

[jcranmer-intel]

llvm/lib/Analysis/ValueTracking.cpp

4118–4119

Redundant with the make_scope_exit, no?

[arsenm]

Drop unused operator &, remove redundant flag part

[arsenm]

cleanup & fcAllFlags in tests

[arsenm]

Clean up another & fcAllFlags

[arsenm]

931d4098a2ebd7f1046e820164b5b6c85650d4d9

llvm/include/llvm/ADT/FloatingPointMode.h

void DenormalMode::print(raw_ostream &OS) const {
   OS << denormalModeKindName(Output) << ',' << denormalModeKindName(Input);
 }
 
 } // namespace llvm
 
 /// Floating-point class tests, supported by 'is_fpclass' intrinsic. Actual
 /// test may be an OR combination of basic tests.
 enum FPClassTest {
+  fcNone = 0x0000,
+
   fcSNan = 0x0001,
   fcQNan = 0x0002,
   fcNegInf = 0x0004,
   fcNegNormal = 0x0008,
   fcNegSubnormal = 0x0010,
   fcNegZero = 0x0020,
   fcPosZero = 0x0040,
   fcPosSubnormal = 0x0080,
   fcPosNormal = 0x0100,
   fcPosInf = 0x0200,
 
   fcNan = fcSNan | fcQNan,
   fcInf = fcPosInf | fcNegInf,
   fcNormal = fcPosNormal | fcNegNormal,
   fcSubnormal = fcPosSubnormal | fcNegSubnormal,
   fcZero = fcPosZero | fcNegZero,
   fcPosFinite = fcPosNormal | fcPosSubnormal | fcPosZero,
   fcNegFinite = fcNegNormal | fcNegSubnormal | fcNegZero,
   fcFinite = fcPosFinite | fcNegFinite,
+  fcPositive = fcPosFinite | fcPosInf,
+  fcNegative = fcNegFinite | fcNegInf,
   fcAllFlags = fcNan | fcInf | fcFinite
 };
 
+inline FPClassTest fneg(FPClassTest Mask) {
+  unsigned NewMask = Mask & fcNan;
+  if (Mask & fcNegInf)
+    NewMask |= fcPosInf;
+  if (Mask & fcNegNormal)
+    NewMask |= fcPosNormal;
+  if (Mask & fcNegSubnormal)
+    NewMask |= fcPosSubnormal;
+  if (Mask & fcNegZero)
+    NewMask |= fcPosZero;
+  if (Mask & fcPosZero)
+    NewMask |= fcNegZero;
+  if (Mask & fcPosSubnormal)
+    NewMask |= fcNegSubnormal;
+  if (Mask & fcPosNormal)
+    NewMask |= fcNegNormal;
+  if (Mask & fcPosInf)
+    NewMask |= fcNegInf;
+  return static_cast<FPClassTest>(NewMask);
+}
+
+inline FPClassTest fabs(FPClassTest Mask) {
+  unsigned NewMask = Mask & fcNan;
+  if (Mask & fcPosZero)
+    NewMask |= fcZero;
+  if (Mask & fcPosSubnormal)
+    NewMask |= fcSubnormal;
+  if (Mask & fcPosNormal)
+    NewMask |= fcNormal;
+  if (Mask & fcPosInf)
+    NewMask |= fcInf;
+  return static_cast<FPClassTest>(NewMask);
+}
+
 #endif // LLVM_ADT_FLOATINGPOINTMODE_H

llvm/include/llvm/Analysis/ValueTracking.h

unsigned ComputeMaxSignificantBits(const Value *Op, const DataLayout &DL,
                                    const Instruction *CxtI = nullptr,
                                    const DominatorTree *DT = nullptr);
 
 /// Map a call instruction to an intrinsic ID.  Libcalls which have equivalent
 /// intrinsics are treated as-if they were intrinsics.
 Intrinsic::ID getIntrinsicForCallSite(const CallBase &CB,
                                       const TargetLibraryInfo *TLI);
 
+struct KnownFPClass {
+  /// Floating-point classes the value could be one of.
+  FPClassTest KnownFPClasses = fcAllFlags;
+
+  /// std::nullopt if the sign bit is unknown, true if the sign bit is
+  /// definitely set or false if the sign bit is definitely unset.
+  std::optional<bool> SignBit;
+
+  KnownFPClass &operator&=(const KnownFPClass &RHS) {
+    KnownFPClasses =
+        static_cast<FPClassTest>(KnownFPClasses & RHS.KnownFPClasses);
+
+    if (!RHS.SignBit)
+      SignBit = std::nullopt;
+    else if (SignBit)
+      *SignBit &= *RHS.SignBit;
+
+    return *this;
+  }
+
+  KnownFPClass &operator|=(const KnownFPClass &RHS) {
+    KnownFPClasses =
+        static_cast<FPClassTest>(KnownFPClasses | RHS.KnownFPClasses);
+
+    if (SignBit != RHS.SignBit)
+      SignBit = std::nullopt;
+    return *this;
+  }
+
+  static KnownFPClass commonBits(const KnownFPClass &LHS,
+                                 const KnownFPClass &RHS) {
+    KnownFPClass Common(LHS);
+    Common &= RHS;
+    return Common;
+  }
+
+  void knownNot(FPClassTest RuleOut) {
+    KnownFPClasses =
+        static_cast<FPClassTest>(KnownFPClasses & ~RuleOut & fcAllFlags);
+  }
+
+  void fneg() {
+    KnownFPClasses = ::fneg(KnownFPClasses);
+    if (SignBit)
+      SignBit = !*SignBit;
+  }
+
+  void fabs() {
+    KnownFPClasses = ::fabs(KnownFPClasses);
+    SignBit = false;
+  }
+
+  /// Assume the sign bit is zero.
+  void signBitIsZero() {
+    KnownFPClasses = static_cast<FPClassTest>((KnownFPClasses & fcPositive) |
+                                              (KnownFPClasses & fcNan));
+    SignBit = false;
+  }
+
+  void copysign(const KnownFPClass &Sign) {
+    // Start assuming nothing about the sign.
+    SignBit = Sign.SignBit;
+    if (!SignBit)
+      return;
+
+    if (*SignBit)
+      KnownFPClasses = static_cast<FPClassTest>(KnownFPClasses & fcNegative);
+    else
+      KnownFPClasses = static_cast<FPClassTest>(KnownFPClasses & fcPositive);
+  }
+
+  void resetAll() { *this = KnownFPClass(); }
+};
+
+inline KnownFPClass operator&(KnownFPClass LHS, const KnownFPClass &RHS) {
+  LHS &= RHS;
+  return LHS;
+}
+
+inline KnownFPClass operator&(const KnownFPClass &LHS, KnownFPClass &&RHS) {
+  RHS &= LHS;
+  return std::move(RHS);
+}
+
+inline KnownFPClass operator|(KnownFPClass LHS, const KnownFPClass &RHS) {
+  LHS |= RHS;
+  return LHS;
+}
+
+inline KnownFPClass operator|(const KnownFPClass &LHS, KnownFPClass &&RHS) {
+  RHS |= LHS;
+  return std::move(RHS);
+}
+
+/// Determine which floating-point classes are valid for \p V, and return them
+/// in KnownFPClass bit sets.
+///
+/// This function is defined on values with floating-point type, values vectors
+/// of floating-point type, and arrays of floating-point type.
+
+/// \p InterestedClasses is a compile time optimization hint for which floating
+/// point classes should be queried. Queries not specified in \p
+/// InterestedClasses should be reliable if they are determined during the
+/// query.
+KnownFPClass computeKnownFPClass(
+    const Value *V, const APInt &DemandedElts, const DataLayout &DL,
+    FPClassTest InterestedClasses = fcAllFlags, unsigned Depth = 0,
+    const TargetLibraryInfo *TLI = nullptr, AssumptionCache *AC = nullptr,
+    const Instruction *CxtI = nullptr, const DominatorTree *DT = nullptr,
+    OptimizationRemarkEmitter *ORE = nullptr, bool UseInstrInfo = true);
+
+KnownFPClass computeKnownFPClass(
+    const Value *V, const DataLayout &DL,
+    FPClassTest InterestedClasses = fcAllFlags, unsigned Depth = 0,
+    const TargetLibraryInfo *TLI = nullptr, AssumptionCache *AC = nullptr,
+    const Instruction *CxtI = nullptr, const DominatorTree *DT = nullptr,
+    OptimizationRemarkEmitter *ORE = nullptr, bool UseInstrInfo = true);
+
 /// Return true if we can prove that the specified FP value is never equal to
 /// -0.0.
 bool CannotBeNegativeZero(const Value *V, const TargetLibraryInfo *TLI,
                           unsigned Depth = 0);
 
 /// Return true if we can prove that the specified FP value is either NaN or
 /// never less than -0.0.
 ///

llvm/lib/Analysis/ValueTracking.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/AssumeBundleQueries.h"
 #include "llvm/Analysis/AssumptionCache.h"
if (VFVTy && isa<Constant>(V)) {
     // All elements were confirmed not-NaN or undefined.
     return true;
   }
 
   // Was not able to prove that V never contains NaN
   return false;
 }
 
+static FPClassTest fpclassAPFloat(const APFloat &C) {
+  if (C.isZero())
+    return C.isNegative() ? fcNegZero : fcPosZero;
+  if (C.isNormal())
+    return C.isNegative() ? fcNegNormal : fcPosNormal;
+  if (C.isDenormal())
+    return C.isNegative() ? fcNegSubnormal : fcPosSubnormal;
+  if (C.isInfinity())
+    return C.isNegative() ? fcNegInf : fcPosInf;
+  assert(C.isNaN() && "Other class of FP constant");
+  return C.isSignaling() ? fcSNan : fcQNan;
+}
+
+// TODO: Merge implementations of isKnownNeverNaN, isKnownNeverInfinity,
+// CannotBeNegativeZero, cannotBeOrderedLessThanZero into here.
+void computeKnownFPClass(const Value *V, const APInt &DemandedElts,
+                         FPClassTest InterestedClasses, KnownFPClass &Known,
+                         unsigned Depth, const Query &Q,
+                         const TargetLibraryInfo *TLI) {
+  if (!DemandedElts) {
+    // No demanded elts, better to assume we don't know anything.
+    Known.resetAll();
+    return;
+  }
+
+  assert(Depth <= MaxAnalysisRecursionDepth && "Limit Search Depth");
+
+  const APFloat *C;
+  if (match(V, m_APFloat(C))) {
+    // We know all of the classes for a scalar constant or a splat vector
+    // constant!
+    Known.KnownFPClasses = fpclassAPFloat(*C);
+    Known.SignBit = C->isNegative();
+    return;
+  }
+
+  const Operator *Op = dyn_cast<Operator>(V);
+  if (!Op)
+    return;
+
+  unsigned KnownNotFromFlags = fcNone;
+  if (const FPMathOperator *FPOp = dyn_cast<FPMathOperator>(Op)) {
+    if (FPOp->hasNoNaNs())
+      KnownNotFromFlags |= fcNan;
+    if (FPOp->hasNoInfs())
+      KnownNotFromFlags |= fcInf;
+
+    // We no longer need to find out about these bits from inputs if we can
+    // assume this from flags.
+    InterestedClasses = static_cast<FPClassTest>(
+        InterestedClasses & ~KnownNotFromFlags & fcAllFlags);
+  }
+
+  auto ClearClassesFromFlags = make_scope_exit([=, &Known] {
+    Known.knownNot(static_cast<FPClassTest>(KnownNotFromFlags));
+  });
+
+  // All recursive calls that increase depth must come after this.
+  if (Depth == MaxAnalysisRecursionDepth)
+    return;
+
+  switch (Op->getOpcode()) {
+  case Instruction::FNeg: {
+    computeKnownFPClass(Op->getOperand(0), DemandedElts, InterestedClasses,
+                        Known, Depth + 1, Q, TLI);
+    Known.fneg();
+    break;
+  }
+  case Instruction::Select: {
+    KnownFPClass Known2;
+    computeKnownFPClass(Op->getOperand(1), DemandedElts, InterestedClasses,
+                        Known, Depth + 1, Q, TLI);
+    computeKnownFPClass(Op->getOperand(2), DemandedElts, InterestedClasses,
+                        Known2, Depth + 1, Q, TLI);
+    Known |= Known2;
+    break;
+  }
+  case Instruction::Call: {
+    if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(Op)) {
+      switch (II->getIntrinsicID()) {
+      case Intrinsic::fabs:
+        computeKnownFPClass(II->getArgOperand(0), DemandedElts,
+                            InterestedClasses, Known, Depth + 1, Q, TLI);
+        Known.fabs();
+        break;
+      case Intrinsic::copysign: {
+        KnownFPClass KnownSign;
+
+        computeKnownFPClass(II->getArgOperand(0), DemandedElts,
+                            InterestedClasses, Known, Depth + 1, Q, TLI);
+        computeKnownFPClass(II->getArgOperand(1), DemandedElts,
+                            InterestedClasses, KnownSign, Depth + 1, Q, TLI);
+        Known.copysign(KnownSign);
+        break;
+      }
+      default:
+        break;
+      }
+    }
+
+    break;
+  }
+  case Instruction::SIToFP:
+  case Instruction::UIToFP: {
+    // Cannot produce nan
+    Known.knownNot(fcNan);
+    if (Op->getOpcode() == Instruction::UIToFP)
+      Known.signBitIsZero();
+
+    if (InterestedClasses & fcInf) {
+      // Get width of largest magnitude integer (remove a bit if signed).
+      // This still works for a signed minimum value because the largest FP
+      // value is scaled by some fraction close to 2.0 (1.0 + 0.xxxx).
+      int IntSize = Op->getOperand(0)->getType()->getScalarSizeInBits();
+      if (Op->getOpcode() == Instruction::SIToFP)
+        --IntSize;
+
+      // If the exponent of the largest finite FP value can hold the largest
+      // integer, the result of the cast must be finite.
+      Type *FPTy = Op->getType()->getScalarType();
+      if (ilogb(APFloat::getLargest(FPTy->getFltSemantics())) >= IntSize)
+        Known.knownNot(fcInf);
+    }
+
+    break;
+  }
+  default:
+    break;
+  }
+
+  Known.KnownFPClasses =
+      static_cast<FPClassTest>(Known.KnownFPClasses & ~KnownNotFromFlags);
+
+  // TODO: Handle assumes
+}
+
+KnownFPClass llvm::computeKnownFPClass(
+    const Value *V, const APInt &DemandedElts, const DataLayout &DL,
+    FPClassTest InterestedClasses, unsigned Depth, const TargetLibraryInfo *TLI,
+    AssumptionCache *AC, const Instruction *CxtI, const DominatorTree *DT,
+    OptimizationRemarkEmitter *ORE, bool UseInstrInfo) {
+  KnownFPClass KnownClasses;
+  ::computeKnownFPClass(V, DemandedElts, InterestedClasses, KnownClasses, Depth,
+                        Query(DL, AC, safeCxtI(V, CxtI), DT, UseInstrInfo, ORE),
+                        TLI);
+  return KnownClasses;
+}
+
+KnownFPClass
+llvm::computeKnownFPClass(const Value *V, const DataLayout &DL,
+                          FPClassTest InterestedClasses, unsigned Depth,
+                          const TargetLibraryInfo *TLI, AssumptionCache *AC,
+                          const Instruction *CxtI, const DominatorTree *DT,
+                          OptimizationRemarkEmitter *ORE, bool UseInstrInfo) {
+  KnownFPClass Known;
+  auto *FVTy = dyn_cast<FixedVectorType>(V->getType());
+  APInt DemandedElts =
+      FVTy ? APInt::getAllOnes(FVTy->getNumElements()) : APInt(1, 1);
+  ::computeKnownFPClass(V, DemandedElts, InterestedClasses, Known, Depth,
+                        Query(DL, AC, safeCxtI(V, CxtI), DT, UseInstrInfo, ORE),
+                        TLI);
+  return Known;
+}
+
 Value *llvm::isBytewiseValue(Value *V, const DataLayout &DL) {
 
   // All byte-wide stores are splatable, even of arbitrary variables.
   if (V->getType()->isIntegerTy(8))
     return V;
 
   LLVMContext &Ctx = V->getContext();
 

llvm/unittests/Analysis/ValueTrackingTest.cpp

protected:
   void expectKnownBits(uint64_t Zero, uint64_t One) {
     auto Known = computeKnownBits(A, M->getDataLayout());
     ASSERT_FALSE(Known.hasConflict());
     EXPECT_EQ(Known.One.getZExtValue(), One);
     EXPECT_EQ(Known.Zero.getZExtValue(), Zero);
   }
 };
 
+class ComputeKnownFPClassTest : public ValueTrackingTest {
+protected:
+  void expectKnownFPClass(unsigned KnownTrue, std::optional<bool> SignBitKnown,
+                          Instruction *TestVal = nullptr) {
+    if (!TestVal)
+      TestVal = A;
+
+    KnownFPClass Known = computeKnownFPClass(TestVal, M->getDataLayout());
+    EXPECT_EQ(KnownTrue, Known.KnownFPClasses);
+    EXPECT_EQ(SignBitKnown, Known.SignBit);
+  }
+};
 }
 
 TEST_F(MatchSelectPatternTest, SimpleFMin) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp ult float %a, 5.0\n"
       "  %A = select i1 %1, float %a, float 5.0\n"
       "  ret float %A\n"
parseAssembly(
       "  %aaa = or i32 %aa, 24\n"
       "  %bbb = or i32 %bb, 28\n"
       "  %A = mul i32 %aaa, %bbb\n"
       "  ret i32 %A\n"
       "}\n");
   expectKnownBits(/*zero*/ 95u, /*one*/ 32u);
 }
 
+TEST_F(ComputeKnownFPClassTest, SelectPos0) {
+  parseAssembly(
+      "define float @test(i1 %cond) {\n"
+      "  %A = select i1 %cond, float 0.0, float 0.0"
+      "  ret float %A\n"
+      "}\n");
+  expectKnownFPClass(fcPosZero, false);
+}
+
+TEST_F(ComputeKnownFPClassTest, SelectNeg0) {
+  parseAssembly(
+      "define float @test(i1 %cond) {\n"
+      "  %A = select i1 %cond, float -0.0, float -0.0"
+      "  ret float %A\n"
+      "}\n");
+  expectKnownFPClass(fcNegZero, true);
+}
+
+TEST_F(ComputeKnownFPClassTest, SelectPosOrNeg0) {
+  parseAssembly(
+      "define float @test(i1 %cond) {\n"
+      "  %A = select i1 %cond, float 0.0, float -0.0"
+      "  ret float %A\n"
+      "}\n");
+  expectKnownFPClass(fcZero, std::nullopt);
+}
+
+TEST_F(ComputeKnownFPClassTest, SelectPosInf) {
+  parseAssembly(
+      "define float @test(i1 %cond) {\n"
+      "  %A = select i1 %cond, float 0x7FF0000000000000, float 0x7FF0000000000000"
+      "  ret float %A\n"
+      "}\n");
+  expectKnownFPClass(fcPosInf, false);
+}
+
+TEST_F(ComputeKnownFPClassTest, SelectNegInf) {
+  parseAssembly(
+      "define float @test(i1 %cond) {\n"
+      "  %A = select i1 %cond, float 0xFFF0000000000000, float 0xFFF0000000000000"
+      "  ret float %A\n"
+      "}\n");
+  expectKnownFPClass(fcNegInf, true);
+}
+
+TEST_F(ComputeKnownFPClassTest, SelectPosOrNegInf) {
+  parseAssembly(
+      "define float @test(i1 %cond) {\n"
+      "  %A = select i1 %cond, float 0x7FF0000000000000, float 0xFFF0000000000000"
+      "  ret float %A\n"
+      "}\n");
+  expectKnownFPClass(fcInf, std::nullopt);
+}
+
+TEST_F(ComputeKnownFPClassTest, SelectNNaN) {
+  parseAssembly(
+      "define float @test(i1 %cond, float %arg0, float %arg1) {\n"
+      "  %A = select nnan i1 %cond, float %arg0, float %arg1"
+      "  ret float %A\n"
+      "}\n");
+  expectKnownFPClass(~fcNan & fcAllFlags, std::nullopt);
+}
+
+TEST_F(ComputeKnownFPClassTest, SelectNInf) {
+  parseAssembly(
+      "define float @test(i1 %cond, float %arg0, float %arg1) {\n"
+      "  %A = select ninf i1 %cond, float %arg0, float %arg1"
+      "  ret float %A\n"
+      "}\n");
+  expectKnownFPClass(~fcInf & fcAllFlags, std::nullopt);
+}
+
+TEST_F(ComputeKnownFPClassTest, SelectNNaNNInf) {
+  parseAssembly(
+      "define float @test(i1 %cond, float %arg0, float %arg1) {\n"
+      "  %A = select nnan ninf i1 %cond, float %arg0, float %arg1"
+      "  ret float %A\n"
+      "}\n");
+  expectKnownFPClass(~(fcNan | fcInf) & fcAllFlags, std::nullopt);
+}
+
+TEST_F(ComputeKnownFPClassTest, FNegNInf) {
+  parseAssembly(
+      "define float @test(float %arg) {\n"
+      "  %A = fneg ninf float %arg"
+      "  ret float %A\n"
+      "}\n");
+  expectKnownFPClass(~fcInf & fcAllFlags, std::nullopt);
+}
+
+TEST_F(ComputeKnownFPClassTest, FabsUnknown) {
+  parseAssembly(
+      "declare float @llvm.fabs.f32(float)"
+      "define float @test(float %arg) {\n"
+      "  %A = call float @llvm.fabs.f32(float %arg)"
+      "  ret float %A\n"
+      "}\n");
+  expectKnownFPClass(fcAllFlags, false);
+}
+
+TEST_F(ComputeKnownFPClassTest, FNegFabsUnknown) {
+  parseAssembly(
+      "declare float @llvm.fabs.f32(float)"
+      "define float @test(float %arg) {\n"
+      "  %fabs = call float @llvm.fabs.f32(float %arg)"
+      "  %A = fneg float %fabs"
+      "  ret float %A\n"
+      "}\n");
+  expectKnownFPClass(fcAllFlags, true);
+}
+
+TEST_F(ComputeKnownFPClassTest, NegFabsNInf) {
+  parseAssembly(
+      "declare float @llvm.fabs.f32(float)"
+      "define float @test(float %arg) {\n"
+      "  %fabs = call ninf float @llvm.fabs.f32(float %arg)"
+      "  %A = fneg float %fabs"
+      "  ret float %A\n"
+      "}\n");
+  expectKnownFPClass(~fcInf & fcAllFlags, true);
+}
+
+TEST_F(ComputeKnownFPClassTest, FNegFabsNNaN) {
+  parseAssembly(
+      "declare float @llvm.fabs.f32(float)"
+      "define float @test(float %arg) {\n"
+      "  %fabs = call nnan float @llvm.fabs.f32(float %arg)"
+      "  %A = fneg float %fabs"
+      "  ret float %A\n"
+      "}\n");
+  expectKnownFPClass(~fcNan & fcAllFlags, true);
+}
+
+TEST_F(ComputeKnownFPClassTest, CopySignNNanSrc0) {
+  parseAssembly(
+      "declare float @llvm.fabs.f32(float)\n"
+      "declare float @llvm.copysign.f32(float, float)\n"
+      "define float @test(float %arg0, float %arg1) {\n"
+      "  %fabs = call nnan float @llvm.fabs.f32(float %arg0)"
+      "  %A = call float @llvm.copysign.f32(float %fabs, float %arg1)"
+      "  ret float %A\n"
+      "}\n");
+  expectKnownFPClass(~fcNan & fcAllFlags, std::nullopt);
+}
+
+TEST_F(ComputeKnownFPClassTest, CopySignNInfSrc0_NegSign) {
+  parseAssembly(
+      "declare float @llvm.sqrt.f32(float)\n"
+      "declare float @llvm.copysign.f32(float, float)\n"
+      "define float @test(float %arg0, float %arg1) {\n"
+      "  %ninf = call ninf float @llvm.sqrt.f32(float %arg0)"
+      "  %A = call float @llvm.copysign.f32(float %ninf, float -1.0)"
+      "  ret float %A\n"
+      "}\n");
+  expectKnownFPClass(fcNegFinite, true);
+}
+
+TEST_F(ComputeKnownFPClassTest, CopySignNInfSrc0_PosSign) {
+  parseAssembly(
+      "declare float @llvm.sqrt.f32(float)\n"
+      "declare float @llvm.copysign.f32(float, float)\n"
+      "define float @test(float %arg0, float %arg1) {\n"
+      "  %ninf = call ninf float @llvm.sqrt.f32(float %arg0)"
+      "  %A = call float @llvm.copysign.f32(float %ninf, float 1.0)"
+      "  ret float %A\n"
+      "}\n");
+  expectKnownFPClass(fcPosFinite, false);
+}
+
+TEST_F(ComputeKnownFPClassTest, UIToFP) {
+  parseAssembly(
+      "define float @test(i32 %arg0, i16 %arg1) {\n"
+      "  %A = uitofp i32 %arg0 to float"
+      "  %A2 = uitofp i16 %arg1 to half"
+      "  ret float %A\n"
+      "}\n");
+  expectKnownFPClass(fcPosFinite, false, A);
+  expectKnownFPClass(fcPositive, false, A2);
+}
+
+TEST_F(ComputeKnownFPClassTest, SIToFP) {
+  parseAssembly(
+      "define float @test(i32 %arg0, i16 %arg1, i17 %arg2) {\n"
+      "  %A = sitofp i32 %arg0 to float"
+      "  %A2 = sitofp i16 %arg1 to half"
+      "  %A3 = sitofp i17 %arg2 to half"
+      "  ret float %A\n"
+      "}\n");
+  expectKnownFPClass(fcFinite, std::nullopt, A);
+  expectKnownFPClass(fcFinite, std::nullopt, A2);
+  expectKnownFPClass(~fcNan & fcAllFlags, std::nullopt, A3);
+}
+
 TEST_F(ValueTrackingTest, isNonZeroRecurrence) {
   parseAssembly(R"(
     define i1 @test(i8 %n, i8 %r) {
     entry:
       br label %loop
     loop:
       %p = phi i8 [ -1, %entry ], [ %next, %loop ]
       %next = add nsw i8 %p, -1