[llvm-branch-commits] [llvm] [InstCombine][NFC] Move SimplifyDemandedUseFPClass functions verbatim to InstCombineSimplifyDemandedFP.cpp (PR #244969)

Eric Ross via llvm-branch-commits llvm-branch-commits at lists.llvm.org
Sat Nov 21 15:46:24 PST 2026


https://github.com/ZERICO2005 created https://github.com/llvm/llvm-project/pull/244969

None

>From b6d8f9a2a127014c279a9c12244e4c031f5bdcdb Mon Sep 17 00:00:00 2001
From: zerico <zerico2005 at gmail.com>
Date: Sat, 21 Nov 2026 15:49:58 -0700
Subject: [PATCH] [InstCombine][NFC] Move SimplifyDemandedUseFPClass functions
 verbatim to InstCombineSimplifyDemandedFP.cpp

---
 .../lib/Transforms/InstCombine/CMakeLists.txt |    1 +
 .../InstCombineSimplifyDemanded.cpp           | 1913 ----------------
 .../InstCombineSimplifyDemandedFP.cpp         | 1938 +++++++++++++++++
 .../llvm/lib/Transforms/InstCombine/BUILD.gn  |    1 +
 4 files changed, 1940 insertions(+), 1913 deletions(-)
 create mode 100644 llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemandedFP.cpp

diff --git a/llvm/lib/Transforms/InstCombine/CMakeLists.txt b/llvm/lib/Transforms/InstCombine/CMakeLists.txt
index 4b3d513630553c..39b5ee57c62a0c 100644
--- a/llvm/lib/Transforms/InstCombine/CMakeLists.txt
+++ b/llvm/lib/Transforms/InstCombine/CMakeLists.txt
@@ -19,6 +19,7 @@ add_llvm_component_library(LLVMInstCombine
   InstCombineSelect.cpp
   InstCombineShifts.cpp
   InstCombineSimplifyDemanded.cpp
+  InstCombineSimplifyDemandedFP.cpp
   InstCombineVectorOps.cpp
 
   ADDITIONAL_HEADER_DIRS
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp b/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
index f94e05aa23d156..6d48718d4ed6f4 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
@@ -136,19 +136,6 @@ bool InstCombinerImpl::SimplifyDemandedInstructionBits(Instruction &Inst) {
   return SimplifyDemandedInstructionBits(Inst, Known);
 }
 
-bool InstCombinerImpl::SimplifyDemandedInstructionFPClass(Instruction &Inst) {
-  KnownFPClass Known;
-
-  Value *V = SimplifyDemandedUseFPClass(&Inst, fcAllFlags, Known,
-                                        SQ.getWithInstruction(&Inst));
-  if (!V)
-    return false;
-  if (V == &Inst)
-    return true;
-  replaceInstUsesWith(Inst, V);
-  return true;
-}
-
 /// This form of SimplifyDemandedBits simplifies the specified instruction
 /// operand if possible, updating it in place. It returns true if it made any
 /// change and false otherwise.
@@ -2099,1903 +2086,3 @@ Value *InstCombinerImpl::SimplifyDemandedVectorElts(Value *V,
 
   return MadeChange ? I : nullptr;
 }
-
-/// For floating-point classes that resolve to a single bit pattern, return that
-/// value.
-static Constant *getFPClassConstant(Type *Ty, FPClassTest Mask,
-                                    bool IsCanonicalizing = false) {
-  if (Mask == fcNone)
-    return PoisonValue::get(Ty);
-
-  if (Mask == fcPosZero)
-    return Constant::getNullValue(Ty);
-
-  // TODO: Support aggregate types that are allowed by FPMathOperator.
-  if (Ty->isAggregateType())
-    return nullptr;
-
-  // Turn any possible snans into quiet if we can.
-  if (Mask == fcNan && IsCanonicalizing)
-    return ConstantFP::getQNaN(Ty);
-
-  switch (Mask) {
-  case fcNegZero:
-    return ConstantFP::getZero(Ty, true);
-  case fcPosInf:
-    return ConstantFP::getInfinity(Ty);
-  case fcNegInf:
-    return ConstantFP::getInfinity(Ty, true);
-  case fcQNan:
-    // Payload bits cannot be dropped for pure signbit operations.
-    return IsCanonicalizing ? ConstantFP::getQNaN(Ty) : nullptr;
-  default:
-    return nullptr;
-  }
-}
-
-/// Perform multiple-use aware simplfications for fabs(\p Src). Returns a
-/// replacement value if it's simplified, otherwise nullptr. Updates \p Known
-/// with the known fpclass if not simplified.
-static Value *simplifyDemandedFPClassFabs(KnownFPClass &Known, Value *Src,
-                                          FPClassTest DemandedMask,
-                                          KnownFPClass KnownSrc, bool NSZ) {
-  if ((DemandedMask & fcNan) == fcNone)
-    KnownSrc.knownNot(fcNan);
-  if ((DemandedMask & fcInf) == fcNone)
-    KnownSrc.knownNot(fcInf);
-
-  if (KnownSrc.getSignBit() == false ||
-      ((DemandedMask & fcNan) == fcNone && KnownSrc.isKnownNever(fcNegative)))
-    return Src;
-
-  // If the only sign bit difference is due to -0, ignore it with nsz
-  if (NSZ &&
-      KnownSrc.isKnownNever(KnownFPClass::OrderedLessThanZeroMask | fcNan))
-    return Src;
-
-  Known = KnownFPClass::fabs(KnownSrc);
-  Known.knownNot(~DemandedMask);
-  return nullptr;
-}
-
-/// Try to set an inferred no-nans or no-infs in \p FMF. \p ValidResults is a
-/// mask of known valid results for the operator (already computed from the
-/// result, and the known operand inputs in \p Known)
-static FastMathFlags inferFastMathValueFlags(FastMathFlags FMF,
-                                             FPClassTest ValidResults,
-                                             ArrayRef<KnownFPClass> Known) {
-  if (!FMF.noNaNs() && (ValidResults & fcNan) == fcNone) {
-    if (all_of(Known, [](const KnownFPClass KnownSrc) {
-          return KnownSrc.isKnownNeverNaN();
-        }))
-      FMF.setNoNaNs();
-  }
-
-  if (!FMF.noInfs() && (ValidResults & fcInf) == fcNone) {
-    if (all_of(Known, [](const KnownFPClass KnownSrc) {
-          return KnownSrc.isKnownNeverInfinity();
-        }))
-      FMF.setNoInfs();
-  }
-
-  return FMF;
-}
-
-static FPClassTest adjustDemandedMaskFromFlags(FPClassTest DemandedMask,
-                                               FastMathFlags FMF) {
-  if (FMF.noNaNs())
-    DemandedMask &= ~fcNan;
-
-  if (FMF.noInfs())
-    DemandedMask &= ~fcInf;
-  return DemandedMask;
-}
-
-/// Apply epilog fixups to a floating-point intrinsic. See if the result can
-/// fold to a constant, or apply fast math flags.
-static Value *simplifyDemandedFPClassResult(Instruction *FPOp,
-                                            FastMathFlags FMF,
-                                            FPClassTest DemandedMask,
-                                            KnownFPClass &Known,
-                                            ArrayRef<KnownFPClass> KnownSrcs) {
-  FPClassTest ValidResults = DemandedMask & Known.getKnownFPClasses();
-  Constant *SingleVal = getFPClassConstant(FPOp->getType(), ValidResults,
-                                           /*IsCanonicalizing=*/true);
-  if (SingleVal)
-    return SingleVal;
-
-  FastMathFlags InferredFMF =
-      inferFastMathValueFlags(FMF, ValidResults, KnownSrcs);
-  if (InferredFMF != FMF) {
-    FPOp->dropUBImplyingAttrsAndMetadata();
-    FPOp->setFastMathFlags(InferredFMF);
-    return FPOp;
-  }
-
-  return nullptr;
-}
-
-/// Perform multiple-use aware simplfications for fneg(fabs(\p Src)). Returns a
-/// replacement value if it's simplified, otherwise nullptr. Updates \p Known
-/// with the known fpclass if not simplified.
-static Value *simplifyDemandedFPClassFnegFabs(KnownFPClass &Known, Value *Src,
-                                              FPClassTest DemandedMask,
-                                              KnownFPClass KnownSrc, bool NSZ) {
-  if ((DemandedMask & fcNan) == fcNone)
-    KnownSrc.knownNot(fcNan);
-  if ((DemandedMask & fcInf) == fcNone)
-    KnownSrc.knownNot(fcInf);
-
-  // If the source value is known negative, we can directly fold to it.
-  if (KnownSrc.getSignBit() == true)
-    return Src;
-
-  // If the only sign bit difference is for 0, ignore it with nsz.
-  if (NSZ &&
-      KnownSrc.isKnownNever(KnownFPClass::OrderedGreaterThanZeroMask | fcNan))
-    return Src;
-
-  Known = KnownFPClass::fneg(KnownFPClass::fabs(KnownSrc));
-  Known.knownNot(~DemandedMask);
-  return nullptr;
-}
-
-static Value *simplifyDemandedFPClassCopysignMag(Value *MagSrc,
-                                                 FPClassTest DemandedMask,
-                                                 KnownFPClass KnownSrc,
-                                                 bool NSZ) {
-  if (NSZ) {
-    constexpr FPClassTest NegOrZero = fcNegative | fcPosZero;
-    constexpr FPClassTest PosOrZero = fcPositive | fcNegZero;
-
-    if ((DemandedMask & ~NegOrZero) == fcNone &&
-        KnownSrc.isKnownAlways(NegOrZero))
-      return MagSrc;
-
-    if ((DemandedMask & ~PosOrZero) == fcNone &&
-        KnownSrc.isKnownAlways(PosOrZero))
-      return MagSrc;
-  } else {
-    if ((DemandedMask & ~fcNegative) == fcNone && KnownSrc.getSignBit() == true)
-      return MagSrc;
-
-    if ((DemandedMask & ~fcPositive) == fcNone &&
-        KnownSrc.getSignBit() == false)
-      return MagSrc;
-  }
-
-  return nullptr;
-}
-
-static Value *
-simplifyDemandedFPClassMinMax(KnownFPClass &Known, Intrinsic::ID IID,
-                              const CallInst *CI, FPClassTest DemandedMask,
-                              KnownFPClass KnownLHS, KnownFPClass KnownRHS,
-                              const Function &F, bool NSZ) {
-  bool OrderedZeroSign = !NSZ;
-
-  KnownFPClass::MinMaxKind OpKind;
-  switch (IID) {
-  case Intrinsic::maximum: {
-    OpKind = KnownFPClass::MinMaxKind::maximum;
-
-    // If one operand is known greater than the other, it must be that
-    // operand unless the other is a nan.
-    if (cannotOrderStrictlyLess(KnownLHS.getKnownFPClasses(),
-                                KnownRHS.getKnownFPClasses(),
-                                OrderedZeroSign) &&
-        KnownRHS.isKnownNever(fcNan))
-      return CI->getArgOperand(0);
-
-    if (cannotOrderStrictlyGreater(KnownLHS.getKnownFPClasses(),
-                                   KnownRHS.getKnownFPClasses(),
-                                   OrderedZeroSign) &&
-        KnownLHS.isKnownNever(fcNan))
-      return CI->getArgOperand(1);
-
-    break;
-  }
-  case Intrinsic::minimum: {
-    OpKind = KnownFPClass::MinMaxKind::minimum;
-
-    // If one operand is known less than the other, it must be that operand
-    // unless the other is a nan.
-    if (cannotOrderStrictlyGreater(KnownLHS.getKnownFPClasses(),
-                                   KnownRHS.getKnownFPClasses(),
-                                   OrderedZeroSign) &&
-        KnownRHS.isKnownNever(fcNan))
-      return CI->getArgOperand(0);
-
-    if (cannotOrderStrictlyLess(KnownLHS.getKnownFPClasses(),
-                                KnownRHS.getKnownFPClasses(),
-                                OrderedZeroSign) &&
-        KnownLHS.isKnownNever(fcNan))
-      return CI->getArgOperand(1);
-
-    break;
-  }
-  case Intrinsic::maxnum:
-  case Intrinsic::maximumnum: {
-    OpKind = IID == Intrinsic::maxnum ? KnownFPClass::MinMaxKind::maxnum
-                                      : KnownFPClass::MinMaxKind::maximumnum;
-
-    if (cannotOrderStrictlyLess(KnownLHS.getKnownFPClasses(),
-                                KnownRHS.getKnownFPClasses(),
-                                OrderedZeroSign) &&
-        KnownLHS.isKnownNever(fcNan))
-      return CI->getArgOperand(0);
-
-    if (cannotOrderStrictlyGreater(KnownLHS.getKnownFPClasses(),
-                                   KnownRHS.getKnownFPClasses(),
-                                   OrderedZeroSign) &&
-        KnownRHS.isKnownNever(fcNan))
-      return CI->getArgOperand(1);
-
-    break;
-  }
-  case Intrinsic::minnum:
-  case Intrinsic::minimumnum: {
-    OpKind = IID == Intrinsic::minnum ? KnownFPClass::MinMaxKind::minnum
-                                      : KnownFPClass::MinMaxKind::minimumnum;
-
-    if (cannotOrderStrictlyGreater(KnownLHS.getKnownFPClasses(),
-                                   KnownRHS.getKnownFPClasses(),
-                                   OrderedZeroSign) &&
-        KnownLHS.isKnownNever(fcNan))
-      return CI->getArgOperand(0);
-
-    if (cannotOrderStrictlyLess(KnownLHS.getKnownFPClasses(),
-                                KnownRHS.getKnownFPClasses(),
-                                OrderedZeroSign) &&
-        KnownRHS.isKnownNever(fcNan))
-      return CI->getArgOperand(1);
-
-    break;
-  }
-  default:
-    llvm_unreachable("not a min/max intrinsic");
-  }
-
-  Type *EltTy = CI->getType()->getScalarType();
-  DenormalMode Mode = F.getDenormalMode(EltTy->getFltSemantics());
-  Known = KnownFPClass::minMaxLike(KnownLHS, KnownRHS, OpKind, Mode);
-  Known.knownNot(~DemandedMask);
-
-  return getFPClassConstant(CI->getType(), Known.getKnownFPClasses(),
-                            /*IsCanonicalizing=*/true);
-}
-
-static Value *
-simplifyDemandedUseFPClassFPTrunc(InstCombinerImpl &IC, Instruction &I,
-                                  FastMathFlags FMF, FPClassTest DemandedMask,
-                                  KnownFPClass &Known, const SimplifyQuery &SQ,
-                                  unsigned Depth) {
-  const fltSemantics &DstTy = I.getType()->getScalarType()->getFltSemantics();
-  const fltSemantics &SrcTy =
-      I.getOperand(0)->getType()->getScalarType()->getFltSemantics();
-
-  const Function *Fn = I.getFunction();
-  DenormalMode DstMode =
-      Fn ? Fn->getDenormalMode(DstTy) : DenormalMode::getDynamic();
-  DenormalMode SrcMode =
-      Fn ? Fn->getDenormalMode(SrcTy) : DenormalMode::getDynamic();
-
-  FPClassTest SrcDemandedMask = DemandedMask;
-  if (DemandedMask & fcNan)
-    SrcDemandedMask |= fcNan;
-
-  // Zero results may have been rounded from subnormal or normal sources.
-  if (DemandedMask & fcNegZero)
-    SrcDemandedMask |= fcNegSubnormal | fcNegNormal;
-  if (DemandedMask & fcPosZero)
-    SrcDemandedMask |= fcPosSubnormal | fcPosNormal;
-
-  // Subnormal results may have been normal in the source type
-  if (DemandedMask & fcNegSubnormal)
-    SrcDemandedMask |= fcNegNormal;
-  if (DemandedMask & fcPosSubnormal)
-    SrcDemandedMask |= fcPosNormal;
-
-  const bool SubnormalNeverProducesNormal =
-      DstTy.minExponent > SrcTy.minExponent;
-
-  // A subnormal input may round to a normal value in the destination type.
-  // For example: bf16 = fptrunc(f32) and f80 = fptrunc(f128).
-  if (!SubnormalNeverProducesNormal) {
-    // TODO: Refine based on the rounding mode.
-    if (DemandedMask & fcNegNormal)
-      SrcDemandedMask |= fcNegSubnormal;
-    if (DemandedMask & fcPosNormal)
-      SrcDemandedMask |= fcPosSubnormal;
-  }
-
-  if (DemandedMask & fcPosInf)
-    SrcDemandedMask |= fcPosNormal;
-  if (DemandedMask & fcNegInf)
-    SrcDemandedMask |= fcNegNormal;
-
-  // TODO: This is a conservative approach for determining the actual input and
-  // output denormal mode used by fptrunc.
-  if (DstMode != DenormalMode::getIEEE() ||
-      SrcMode != DenormalMode::getIEEE()) {
-    // Input subnormals may flush to zero, and output subnormals may also flush
-    // to zero. The result can be subnormal (and flushed to zero) even if the
-    // input is normal.
-    if ((DemandedMask & fcZero) != fcNone)
-      SrcDemandedMask |= fcSubnormal | fcNormal;
-  }
-
-  KnownFPClass KnownSrc;
-  if (IC.SimplifyDemandedFPClass(&I, 0, SrcDemandedMask, KnownSrc, SQ,
-                                 Depth + 1))
-    return &I;
-
-  Known = KnownFPClass::fptrunc(KnownSrc, DstTy, SrcTy, DstMode, SrcMode);
-  Known.knownNot(~DemandedMask);
-
-  return simplifyDemandedFPClassResult(&I, FMF, DemandedMask, Known,
-                                       {KnownSrc});
-}
-
-Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
-                                                    FPClassTest DemandedMask,
-                                                    KnownFPClass &Known,
-                                                    const SimplifyQuery &SQ,
-                                                    unsigned Depth) {
-  assert(Depth <= MaxAnalysisRecursionDepth && "Limit Search Depth");
-  assert(Known == KnownFPClass() && "expected uninitialized state");
-
-  Type *VTy = I->getType();
-
-  FastMathFlags FMF;
-  if (auto *FPOp = dyn_cast<FPMathOperator>(I)) {
-    FMF = FPOp->getFastMathFlags();
-    DemandedMask = adjustDemandedMaskFromFlags(DemandedMask, FMF);
-  }
-
-  switch (I->getOpcode()) {
-  case Instruction::FNeg: {
-    // Special case fneg(fabs(x))
-
-    Value *FNegSrc = I->getOperand(0);
-    Value *FNegFAbsSrc;
-    if (match(FNegSrc, m_OneUse(m_FAbs(m_Value(FNegFAbsSrc))))) {
-      KnownFPClass KnownSrc;
-      if (SimplifyDemandedFPClass(cast<Instruction>(FNegSrc), 0,
-                                  llvm::unknown_sign(DemandedMask), KnownSrc,
-                                  SQ, Depth + 1))
-        return I;
-
-      FastMathFlags FabsFMF = cast<FPMathOperator>(FNegSrc)->getFastMathFlags();
-      FPClassTest ThisDemandedMask =
-          adjustDemandedMaskFromFlags(DemandedMask, FabsFMF);
-
-      bool IsNSZ = FMF.noSignedZeros() || FabsFMF.noSignedZeros();
-      if (Value *Simplified = simplifyDemandedFPClassFnegFabs(
-              Known, FNegFAbsSrc, ThisDemandedMask, KnownSrc, IsNSZ))
-        return Simplified;
-
-      if ((ThisDemandedMask & fcNan) == fcNone)
-        KnownSrc.knownNot(fcNan);
-      if ((ThisDemandedMask & fcInf) == fcNone)
-        KnownSrc.knownNot(fcInf);
-
-      // fneg(fabs(x)) => fneg(x)
-      if (KnownSrc.getSignBit() == false)
-        return replaceOperand(*I, 0, FNegFAbsSrc);
-
-      // fneg(fabs(x)) => fneg(x), ignoring -0 if nsz.
-      if (IsNSZ &&
-          KnownSrc.isKnownNever(KnownFPClass::OrderedLessThanZeroMask | fcNan))
-        return replaceOperand(*I, 0, FNegFAbsSrc);
-
-      break;
-    }
-
-    if (SimplifyDemandedFPClass(I, 0, llvm::fneg(DemandedMask), Known, SQ,
-                                Depth + 1))
-      return I;
-    Known.fneg();
-    Known.knownNot(~DemandedMask);
-    break;
-  }
-  case Instruction::FAdd:
-  case Instruction::FSub: {
-    KnownFPClass KnownLHS, KnownRHS;
-
-    // fadd x, x can be handled more aggressively.
-    if (I->getOperand(0) == I->getOperand(1) &&
-        I->getOpcode() == Instruction::FAdd &&
-        isGuaranteedNotToBeUndef(I->getOperand(0), SQ.AC, SQ.CtxI, SQ.DT,
-                                 Depth + 1)) {
-      Type *EltTy = VTy->getScalarType();
-      DenormalMode Mode = F.getDenormalMode(EltTy->getFltSemantics());
-
-      FPClassTest SrcDemandedMask = DemandedMask;
-      if (DemandedMask & fcNan)
-        SrcDemandedMask |= fcNan;
-
-      // Doubling a subnormal could have resulted in a normal value.
-      if (DemandedMask & fcPosNormal)
-        SrcDemandedMask |= fcPosSubnormal;
-      if (DemandedMask & fcNegNormal)
-        SrcDemandedMask |= fcNegSubnormal;
-
-      // Doubling a subnormal may produce 0 if FTZ/DAZ.
-      if (Mode != DenormalMode::getIEEE()) {
-        if (DemandedMask & fcPosZero) {
-          SrcDemandedMask |= fcPosSubnormal;
-
-          if (Mode.inputsMayBePositiveZero() || Mode.outputsMayBePositiveZero())
-            SrcDemandedMask |= fcNegSubnormal;
-        }
-
-        if (DemandedMask & fcNegZero)
-          SrcDemandedMask |= fcNegSubnormal;
-      }
-
-      // Doubling a normal could have resulted in an infinity.
-      if (DemandedMask & fcPosInf)
-        SrcDemandedMask |= fcPosNormal;
-      if (DemandedMask & fcNegInf)
-        SrcDemandedMask |= fcNegNormal;
-
-      if (SimplifyDemandedFPClass(I, 0, SrcDemandedMask, KnownLHS, SQ,
-                                  Depth + 1))
-        return I;
-
-      Known = KnownFPClass::fadd_self(KnownLHS, RoundingMode::NearestTiesToEven,
-                                      Mode);
-      KnownRHS = KnownLHS;
-    } else {
-      FPClassTest SrcDemandedMask = fcFinite;
-
-      // inf + (-inf) = nan
-      if (DemandedMask & fcNan)
-        SrcDemandedMask |= fcNan | fcInf;
-
-      if (DemandedMask & fcInf)
-        SrcDemandedMask |= fcInf;
-
-      if (SimplifyDemandedFPClass(I, 1, SrcDemandedMask, KnownRHS, SQ,
-                                  Depth + 1) ||
-          SimplifyDemandedFPClass(I, 0, SrcDemandedMask, KnownLHS, SQ,
-                                  Depth + 1))
-        return I;
-
-      Type *EltTy = VTy->getScalarType();
-      DenormalMode Mode = F.getDenormalMode(EltTy->getFltSemantics());
-
-      Known = I->getOpcode() == Instruction::FAdd
-                  ? KnownFPClass::fadd(KnownLHS, KnownRHS,
-                                       RoundingMode::NearestTiesToEven, Mode)
-                  : KnownFPClass::fsub(KnownLHS, KnownRHS,
-                                       RoundingMode::NearestTiesToEven, Mode);
-    }
-
-    Known.knownNot(~DemandedMask);
-
-    if (Constant *SingleVal = getFPClassConstant(VTy, Known.getKnownFPClasses(),
-                                                 /*IsCanonicalizing=*/true))
-      return SingleVal;
-
-    // Propagate known result to simplify edge case checks.
-    bool ResultNotNan = (DemandedMask & fcNan) == fcNone;
-
-    // With nnan: X + {+/-}Inf --> {+/-}Inf
-    if (ResultNotNan && I->getOpcode() == Instruction::FAdd &&
-        KnownRHS.isKnownAlways(fcInf | fcNan) && KnownLHS.isKnownNever(fcNan))
-      return I->getOperand(1);
-
-    // With nnan: {+/-}Inf + X --> {+/-}Inf
-    // With nnan: {+/-}Inf - X --> {+/-}Inf
-    if (ResultNotNan && KnownLHS.isKnownAlways(fcInf | fcNan) &&
-        KnownRHS.isKnownNever(fcNan))
-      return I->getOperand(0);
-
-    FastMathFlags InferredFMF = inferFastMathValueFlags(
-        FMF, Known.getKnownFPClasses(), {KnownLHS, KnownRHS});
-    if (InferredFMF != FMF) {
-      I->setFastMathFlags(InferredFMF);
-      return I;
-    }
-
-    return nullptr;
-  }
-  case Instruction::FMul: {
-    KnownFPClass KnownLHS, KnownRHS;
-
-    Value *X = I->getOperand(0);
-    Value *Y = I->getOperand(1);
-
-    FPClassTest SrcDemandedMask =
-        DemandedMask & (fcNan | fcZero | fcSubnormal | fcNormal);
-
-    if (DemandedMask & fcInf) {
-      // mul x, inf = inf
-      // mul large_x, large_y = inf
-      SrcDemandedMask |= fcSubnormal | fcNormal | fcInf;
-    }
-
-    if (DemandedMask & fcNan) {
-      // mul +/-inf, 0 => nan
-      SrcDemandedMask |= fcZero | fcInf | fcNan;
-
-      // TODO: Mode check
-      // mul +/-inf, sub => nan if daz
-      SrcDemandedMask |= fcSubnormal;
-    }
-
-    // mul normal, subnormal = normal
-    // Normal inputs may result in underflow.
-    if (DemandedMask & (fcNormal | fcSubnormal))
-      SrcDemandedMask |= fcNormal | fcSubnormal;
-
-    if (DemandedMask & fcZero)
-      SrcDemandedMask |= fcNormal | fcSubnormal;
-
-    if (X == Y &&
-        isGuaranteedNotToBeUndef(X, SQ.AC, SQ.CtxI, SQ.DT, Depth + 1)) {
-      if (SimplifyDemandedFPClass(I, 0, SrcDemandedMask, KnownLHS, SQ,
-                                  Depth + 1))
-        return I;
-      Type *EltTy = VTy->getScalarType();
-
-      DenormalMode Mode = F.getDenormalMode(EltTy->getFltSemantics());
-      Known = KnownFPClass::square(KnownLHS, Mode);
-      Known.knownNot(~DemandedMask);
-
-      if (Constant *Folded = getFPClassConstant(VTy, Known.getKnownFPClasses(),
-                                                /*IsCanonicalizing=*/true))
-        return Folded;
-
-      if (Known.isKnownAlways(fcPosZero | fcPosInf | fcNan) &&
-          KnownLHS.isKnownNever(fcSubnormal | fcNormal)) {
-        // We can skip the fabs if the source was already known positive.
-        if (KnownLHS.isKnownAlways(fcPositive))
-          return X;
-
-        // => fabs(x), in case this was a -inf or -0.
-        // Note: Dropping canonicalize.
-        IRBuilderBase::InsertPointGuard Guard(Builder);
-        Builder.SetInsertPoint(I);
-        Value *Fabs = Builder.CreateFAbs(X, FMF);
-        Fabs->takeName(I);
-        return Fabs;
-      }
-
-      return nullptr;
-    }
-
-    if (SimplifyDemandedFPClass(I, 1, SrcDemandedMask, KnownRHS, SQ,
-                                Depth + 1) ||
-        SimplifyDemandedFPClass(I, 0, SrcDemandedMask, KnownLHS, SQ, Depth + 1))
-      return I;
-
-    if (FMF.noInfs()) {
-      // Flag implies inputs cannot be infinity.
-      KnownLHS.knownNot(fcInf);
-      KnownRHS.knownNot(fcInf);
-    }
-
-    bool NonNanResult = (DemandedMask & fcNan) == fcNone;
-
-    // With no-nans/no-infs:
-    // X * 0.0 --> copysign(0.0, X)
-    // X * -0.0 --> copysign(0.0, -X)
-    if ((NonNanResult || KnownLHS.isKnownNeverInfOrNaN()) &&
-        KnownRHS.isKnownAlways(fcPosZero | fcNan)) {
-      IRBuilderBase::InsertPointGuard Guard(Builder);
-      Builder.SetInsertPoint(I);
-
-      // => copysign(+0, lhs)
-      // Note: Dropping canonicalize
-      Value *Copysign = Builder.CreateCopySign(Y, X, FMF);
-      Copysign->takeName(I);
-      return Copysign;
-    }
-
-    if (KnownLHS.isKnownAlways(fcPosZero | fcNan) &&
-        (NonNanResult || KnownRHS.isKnownNeverInfOrNaN())) {
-      IRBuilderBase::InsertPointGuard Guard(Builder);
-      Builder.SetInsertPoint(I);
-
-      // => copysign(+0, rhs)
-      // Note: Dropping canonicalize
-      Value *Copysign = Builder.CreateCopySign(X, Y, FMF);
-      Copysign->takeName(I);
-      return Copysign;
-    }
-
-    if ((NonNanResult || KnownLHS.isKnownNeverInfOrNaN()) &&
-        KnownRHS.isKnownAlways(fcNegZero | fcNan)) {
-      IRBuilderBase::InsertPointGuard Guard(Builder);
-      Builder.SetInsertPoint(I);
-
-      // => copysign(0, fneg(lhs))
-      // Note: Dropping canonicalize
-      Value *Copysign =
-          Builder.CreateCopySign(Y, Builder.CreateFNegFMF(X, FMF), FMF);
-      Copysign->takeName(I);
-      return Copysign;
-    }
-
-    if (KnownLHS.isKnownAlways(fcNegZero | fcNan) &&
-        (NonNanResult || KnownRHS.isKnownNeverInfOrNaN())) {
-      IRBuilderBase::InsertPointGuard Guard(Builder);
-      Builder.SetInsertPoint(I);
-
-      // => copysign(+0, fneg(rhs))
-      // Note: Dropping canonicalize
-      Value *Copysign =
-          Builder.CreateCopySign(X, Builder.CreateFNegFMF(Y, FMF), FMF);
-      Copysign->takeName(I);
-      return Copysign;
-    }
-
-    Type *EltTy = VTy->getScalarType();
-    DenormalMode Mode = F.getDenormalMode(EltTy->getFltSemantics());
-
-    if (KnownLHS.isKnownAlways(fcInf | fcNan) &&
-        (KnownRHS.isKnownNeverNaN() &&
-         KnownRHS.cannotBeOrderedGreaterEqZero(Mode))) {
-      IRBuilderBase::InsertPointGuard Guard(Builder);
-      Builder.SetInsertPoint(I);
-
-      // Note: Dropping canonicalize
-      Value *Neg = Builder.CreateFNegFMF(X, FMF);
-      Neg->takeName(I);
-      return Neg;
-    }
-
-    if (KnownRHS.isKnownAlways(fcInf | fcNan) &&
-        (KnownLHS.isKnownNeverNaN() &&
-         KnownLHS.cannotBeOrderedGreaterEqZero(Mode))) {
-      IRBuilderBase::InsertPointGuard Guard(Builder);
-      Builder.SetInsertPoint(I);
-
-      // Note: Dropping canonicalize
-      Value *Neg = Builder.CreateFNegFMF(Y, FMF);
-      Neg->takeName(I);
-      return Neg;
-    }
-
-    Known = KnownFPClass::fmul(KnownLHS, KnownRHS, Mode);
-    Known.knownNot(~DemandedMask);
-
-    if (Constant *SingleVal = getFPClassConstant(VTy, Known.getKnownFPClasses(),
-                                                 /*IsCanonicalizing=*/true))
-      return SingleVal;
-
-    FastMathFlags InferredFMF = inferFastMathValueFlags(
-        FMF, Known.getKnownFPClasses(), {KnownLHS, KnownRHS});
-    if (InferredFMF != FMF) {
-      I->setFastMathFlags(InferredFMF);
-      return I;
-    }
-
-    return nullptr;
-  }
-  case Instruction::FDiv: {
-    Value *X = I->getOperand(0);
-    Value *Y = I->getOperand(1);
-    if (X == Y &&
-        isGuaranteedNotToBeUndef(X, SQ.AC, SQ.CtxI, SQ.DT, Depth + 1)) {
-      // If the source is 0, inf or nan, the result is a nan
-      IRBuilderBase::InsertPointGuard Guard(Builder);
-      Builder.SetInsertPoint(I);
-
-      Value *IsZeroOrNan = Builder.CreateFCmpFMF(
-          FCmpInst::FCMP_UEQ, I->getOperand(0), ConstantFP::getZero(VTy), FMF);
-
-      Value *Fabs = Builder.CreateFAbs(I->getOperand(0), FMF);
-      Value *IsInfOrNan = Builder.CreateFCmpFMF(
-          FCmpInst::FCMP_UEQ, Fabs, ConstantFP::getInfinity(VTy), FMF);
-
-      Value *IsInfOrZeroOrNan = Builder.CreateOr(IsInfOrNan, IsZeroOrNan);
-
-      return Builder.CreateSelectFMFWithUnknownProfile(
-          IsInfOrZeroOrNan, ConstantFP::getQNaN(VTy),
-          ConstantFP::get(
-              VTy, APFloat::getOne(VTy->getScalarType()->getFltSemantics())),
-          FMF, DEBUG_TYPE);
-    }
-
-    Type *EltTy = VTy->getScalarType();
-    DenormalMode Mode = F.getDenormalMode(EltTy->getFltSemantics());
-
-    // Every output class could require denormal inputs (except for the
-    // degenerate case of only-nan results, without DAZ).
-    FPClassTest SrcDemandedMask = (DemandedMask & fcNan) | fcSubnormal;
-
-    // Normal inputs may result in underflow.
-    // x / x = 1.0 for non0/inf/nan
-    // -x = +y / -z
-    // -x = -y / +z
-    if (DemandedMask & (fcSubnormal | fcNormal))
-      SrcDemandedMask |= fcNormal;
-
-    if (DemandedMask & fcNan) {
-      // 0 / 0 = nan
-      // inf / inf = nan
-
-      // Subnormal is added in case of DAZ, but this isn't strictly
-      // necessary. Every other input class implies a possible subnormal source,
-      // so this only could matter in the degenerate case of only-nan results.
-      SrcDemandedMask |= fcZero | fcInf | fcNan;
-    }
-
-    // Zero outputs may be the result of underflow.
-    if (DemandedMask & fcZero)
-      SrcDemandedMask |= fcNormal | fcSubnormal;
-
-    FPClassTest LHSDemandedMask = SrcDemandedMask;
-    FPClassTest RHSDemandedMask = SrcDemandedMask;
-
-    // 0 / inf = 0
-    if (DemandedMask & fcZero) {
-      assert((LHSDemandedMask & fcSubnormal) &&
-             "should not have to worry about daz here");
-      LHSDemandedMask |= fcZero;
-      RHSDemandedMask |= fcInf;
-    }
-
-    // x / 0 = inf
-    // large_normal / small_normal = inf
-    // inf / 1 = inf
-    // large_normal / subnormal = inf
-    if (DemandedMask & fcInf) {
-      LHSDemandedMask |= fcInf | fcNormal | fcSubnormal;
-      RHSDemandedMask |= fcZero | fcSubnormal | fcNormal;
-    }
-
-    KnownFPClass KnownLHS, KnownRHS;
-    if (SimplifyDemandedFPClass(I, 0, LHSDemandedMask, KnownLHS, SQ,
-                                Depth + 1) ||
-        SimplifyDemandedFPClass(I, 1, RHSDemandedMask, KnownRHS, SQ, Depth + 1))
-      return I;
-
-    bool ResultNotNan = (DemandedMask & fcNan) == fcNone;
-    bool ResultNotInf = (DemandedMask & fcInf) == fcNone;
-
-    // Replacing 0/x with a zero is only valid when the divisor can't be
-    // (logical) zero, since 0/0 is NaN -- unless NaN results aren't demanded. A
-    // subnormal divisor can flush to zero under a flushing denormal mode.
-    bool CanIgnoreZeroByZeroNan =
-        ResultNotNan || KnownRHS.isKnownNeverLogicalZero(Mode);
-
-    // nsz [+-]0 / x -> 0
-    if (FMF.noSignedZeros() && KnownLHS.isKnownAlways(fcZero) &&
-        KnownRHS.isKnownNeverNaN() && CanIgnoreZeroByZeroNan)
-      return ConstantFP::getZero(VTy);
-
-    if (KnownLHS.isKnownAlways(fcPosZero) && KnownRHS.isKnownNeverNaN() &&
-        CanIgnoreZeroByZeroNan) {
-      IRBuilderBase::InsertPointGuard Guard(Builder);
-      Builder.SetInsertPoint(I);
-
-      // nnan +0 / x -> copysign(0, rhs)
-      // TODO: -0 / x => copysign(0, fneg(rhs))
-      Value *Copysign = Builder.CreateCopySign(X, Y, FMF);
-      Copysign->takeName(I);
-      return Copysign;
-    }
-
-    if (!ResultNotInf &&
-        ((ResultNotNan || (KnownLHS.isKnownNeverNaN() &&
-                           KnownLHS.isKnownNeverLogicalZero(Mode))) &&
-         (KnownRHS.isKnownAlways(fcPosZero) ||
-          (FMF.noSignedZeros() && KnownRHS.isKnownAlways(fcZero))))) {
-      IRBuilderBase::InsertPointGuard Guard(Builder);
-      Builder.SetInsertPoint(I);
-
-      // nnan x / 0 => copysign(inf, x);
-      // nnan nsz x / -0 => copysign(inf, x);
-      Value *Copysign =
-          Builder.CreateCopySign(ConstantFP::getInfinity(VTy), X, FMF);
-      Copysign->takeName(I);
-      return Copysign;
-    }
-
-    // nnan ninf X / [-]0.0 -> poison
-    if (ResultNotNan && ResultNotInf && KnownRHS.isKnownAlways(fcZero))
-      return PoisonValue::get(VTy);
-
-    Known = KnownFPClass::fdiv(KnownLHS, KnownRHS, Mode);
-    Known.knownNot(~DemandedMask);
-
-    if (Constant *SingleVal = getFPClassConstant(VTy, Known.getKnownFPClasses(),
-                                                 /*IsCanonicalizing=*/true))
-      return SingleVal;
-
-    FastMathFlags InferredFMF = inferFastMathValueFlags(
-        FMF, Known.getKnownFPClasses(), {KnownLHS, KnownRHS});
-    if (InferredFMF != FMF) {
-      I->setFastMathFlags(InferredFMF);
-      return I;
-    }
-
-    return nullptr;
-  }
-  case Instruction::FPTrunc:
-    return simplifyDemandedUseFPClassFPTrunc(*this, *I, FMF, DemandedMask,
-                                             Known, SQ, Depth);
-  case Instruction::FPExt: {
-    const fltSemantics &DstTy = VTy->getScalarType()->getFltSemantics();
-    const fltSemantics &SrcTy =
-        I->getOperand(0)->getType()->getScalarType()->getFltSemantics();
-
-    const DenormalMode DstMode = F.getDenormalMode(DstTy);
-    const DenormalMode SrcMode = F.getDenormalMode(SrcTy);
-
-    FPClassTest SrcDemandedMask = DemandedMask;
-    if (DemandedMask & fcNan)
-      SrcDemandedMask |= fcNan;
-
-    // No subnormal result does not imply not-subnormal in the source type.
-    if ((DemandedMask & fcNegNormal) != fcNone)
-      SrcDemandedMask |= fcNegSubnormal;
-    if ((DemandedMask & fcPosNormal) != fcNone)
-      SrcDemandedMask |= fcPosSubnormal;
-
-    // TODO: This is a conservative approach for determining the actual input
-    // and output denormal mode used by fpext.
-    if (DstMode != DenormalMode::getIEEE() ||
-        SrcMode != DenormalMode::getIEEE()) {
-      // We are assuming that normal values will never produce subnormal results
-      // for fpext. This assumption is incorrect for ppcf128 = fpext(f80).
-      if ((DemandedMask & fcZero) != fcNone)
-        SrcDemandedMask |= fcSubnormal;
-    }
-
-    // TODO: Properly handle ppcf128 = fpext(f80) (since f80 has a larger
-    // exponent range than ppcf128).
-
-    KnownFPClass KnownSrc;
-    if (SimplifyDemandedFPClass(I, 0, SrcDemandedMask, KnownSrc, SQ, Depth + 1))
-      return I;
-
-    Known = KnownFPClass::fpext(KnownSrc, DstTy, SrcTy, DstMode, SrcMode);
-    Known.knownNot(~DemandedMask);
-
-    return simplifyDemandedFPClassResult(I, FMF, DemandedMask, Known,
-                                         {KnownSrc});
-  }
-  case Instruction::Call: {
-    CallInst *CI = cast<CallInst>(I);
-    const Intrinsic::ID IID = CI->getIntrinsicID();
-    switch (IID) {
-    case Intrinsic::fabs: {
-      KnownFPClass KnownSrc;
-      if (SimplifyDemandedFPClass(I, 0, llvm::inverse_fabs(DemandedMask),
-                                  KnownSrc, SQ, Depth + 1))
-        return I;
-
-      if (Value *Simplified = simplifyDemandedFPClassFabs(
-              Known, CI->getArgOperand(0), DemandedMask, KnownSrc,
-              FMF.noSignedZeros()))
-        return Simplified;
-      break;
-    }
-    case Intrinsic::arithmetic_fence:
-      if (SimplifyDemandedFPClass(I, 0, DemandedMask, Known, SQ, Depth + 1))
-        return I;
-      break;
-    case Intrinsic::copysign: {
-      // Flip on more potentially demanded classes
-      const FPClassTest DemandedMaskAnySign = llvm::unknown_sign(DemandedMask);
-      KnownFPClass KnownMag;
-      if (SimplifyDemandedFPClass(CI, 0, DemandedMaskAnySign, KnownMag, SQ,
-                                  Depth + 1))
-        return I;
-
-      if ((DemandedMask & fcNegative) == DemandedMask &&
-          CI->getArgOperand(1) != ConstantFP::get(VTy, -1.0)) {
-        // Roundabout way of replacing with fneg(fabs)
-        CI->setOperand(1, ConstantFP::get(VTy, -1.0));
-        return I;
-      }
-
-      if ((DemandedMask & fcPositive) == DemandedMask &&
-          CI->getArgOperand(1) != ConstantFP::getZero(VTy)) {
-        // Roundabout way of replacing with fabs
-        CI->setOperand(1, ConstantFP::getZero(VTy));
-        return I;
-      }
-
-      if (Value *Simplified = simplifyDemandedFPClassCopysignMag(
-              CI->getArgOperand(0), DemandedMask, KnownMag,
-              FMF.noSignedZeros()))
-        return Simplified;
-
-      KnownFPClass KnownSign =
-          computeKnownFPClass(CI->getArgOperand(1), fcAllFlags, SQ, Depth + 1);
-      if (KnownMag.getSignBit() && KnownSign.getSignBit() &&
-          *KnownMag.getSignBit() == *KnownSign.getSignBit())
-        return CI->getOperand(0);
-
-      // TODO: Call argument attribute not considered
-      // Input implied not-nan from flag.
-      if (FMF.noNaNs())
-        KnownSign.knownNot(fcNan);
-
-      if (KnownSign.getSignBit() == false &&
-          CI->getArgOperand(1) != ConstantFP::getZero(VTy)) {
-        CI->dropUBImplyingAttrsAndMetadata();
-        CI->setOperand(1, ConstantFP::getZero(VTy));
-        return I;
-      }
-
-      if (KnownSign.getSignBit() == true &&
-          CI->getArgOperand(1) != ConstantFP::get(VTy, -1.0)) {
-        CI->dropUBImplyingAttrsAndMetadata();
-        CI->setOperand(1, ConstantFP::get(VTy, -1.0));
-        return I;
-      }
-
-      Known = KnownFPClass::copysign(KnownMag, KnownSign);
-      Known.knownNot(~DemandedMask);
-      break;
-    }
-    case Intrinsic::fma:
-    case Intrinsic::fmuladd: {
-      // Keep in mind that fma can rule out NaN in places that fmuladd cannot.
-
-      // We can't do any simplification on the source besides stripping out
-      // unneeded nans.
-      FPClassTest SrcDemandedMask = DemandedMask | ~fcNan;
-      if (DemandedMask & fcNan)
-        SrcDemandedMask |= fcNan;
-
-      KnownFPClass KnownSrc[3];
-
-      const bool IsFMA = IID == Intrinsic::fma;
-
-      Type *EltTy = VTy->getScalarType();
-      if (CI->getArgOperand(0) == CI->getArgOperand(1) &&
-          isGuaranteedNotToBeUndef(CI->getArgOperand(0), SQ.AC, SQ.CtxI, SQ.DT,
-                                   Depth + 1)) {
-        if (SimplifyDemandedFPClass(CI, 0, SrcDemandedMask, KnownSrc[0], SQ,
-                                    Depth + 1) ||
-            SimplifyDemandedFPClass(CI, 2, SrcDemandedMask, KnownSrc[2], SQ,
-                                    Depth + 1))
-          return I;
-
-        KnownSrc[1] = KnownSrc[0];
-        DenormalMode Mode = F.getDenormalMode(EltTy->getFltSemantics());
-        Known = IsFMA ? KnownFPClass::fma_square(KnownSrc[0], KnownSrc[2], Mode)
-                      : KnownFPClass::fmuladd_square(KnownSrc[0], KnownSrc[2],
-                                                     Mode);
-      } else {
-        for (int OpIdx = 0; OpIdx != 3; ++OpIdx) {
-          if (SimplifyDemandedFPClass(CI, OpIdx, SrcDemandedMask,
-                                      KnownSrc[OpIdx], SQ, Depth + 1))
-            return CI;
-        }
-
-        DenormalMode Mode = F.getDenormalMode(EltTy->getFltSemantics());
-        Known = IsFMA ? KnownFPClass::fma(KnownSrc[0], KnownSrc[1], KnownSrc[2],
-                                          Mode)
-                      : KnownFPClass::fmuladd(KnownSrc[0], KnownSrc[1],
-                                              KnownSrc[2], Mode);
-      }
-
-      return simplifyDemandedFPClassResult(CI, FMF, DemandedMask, Known,
-                                           {KnownSrc});
-    }
-    case Intrinsic::maximum:
-    case Intrinsic::minimum:
-    case Intrinsic::maximumnum:
-    case Intrinsic::minimumnum:
-    case Intrinsic::maxnum:
-    case Intrinsic::minnum: {
-      const bool PropagateNaN =
-          IID == Intrinsic::maximum || IID == Intrinsic::minimum;
-
-      // We can't tell much based on the demanded result without inspecting the
-      // operands (e.g., a known-positive result could have been clamped), but
-      // we can still prune known-nan inputs.
-      FPClassTest SrcDemandedMask =
-          PropagateNaN && ((DemandedMask & fcNan) == fcNone)
-              ? DemandedMask | ~fcNan
-              : fcAllFlags;
-
-      KnownFPClass KnownLHS, KnownRHS;
-      if (SimplifyDemandedFPClass(CI, 1, SrcDemandedMask, KnownRHS, SQ,
-                                  Depth + 1) ||
-          SimplifyDemandedFPClass(CI, 0, SrcDemandedMask, KnownLHS, SQ,
-                                  Depth + 1))
-        return I;
-
-      Value *Simplified =
-          simplifyDemandedFPClassMinMax(Known, IID, CI, DemandedMask, KnownLHS,
-                                        KnownRHS, F, FMF.noSignedZeros());
-      if (Simplified)
-        return Simplified;
-
-      auto *FPOp = cast<FPMathOperator>(CI);
-
-      FPClassTest ValidResults = DemandedMask & Known.getKnownFPClasses();
-      FastMathFlags InferredFMF = FMF;
-
-      if (!FMF.noSignedZeros()) {
-        // Add NSZ flag if we know the result will not be sensitive to the sign
-        // of 0.
-        FPClassTest ZeroMask = fcZero;
-
-        Type *EltTy = VTy->getScalarType();
-        DenormalMode Mode = F.getDenormalMode(EltTy->getFltSemantics());
-        if (Mode != DenormalMode::getIEEE())
-          ZeroMask |= fcSubnormal;
-
-        bool ResultNotLogical0 = (ValidResults & ZeroMask) == fcNone;
-        if (ResultNotLogical0 || ((KnownLHS.isKnownNeverLogicalNegZero(Mode) ||
-                                   KnownRHS.isKnownNeverLogicalPosZero(Mode)) &&
-                                  (KnownLHS.isKnownNeverLogicalPosZero(Mode) ||
-                                   KnownRHS.isKnownNeverLogicalNegZero(Mode))))
-          InferredFMF.setNoSignedZeros(true);
-      }
-
-      if (!FMF.noNaNs() &&
-          ((PropagateNaN && (ValidResults & fcNan) == fcNone) ||
-           (KnownLHS.isKnownNeverNaN() && KnownRHS.isKnownNeverNaN()))) {
-        CI->dropUBImplyingAttrsAndMetadata();
-        InferredFMF.setNoNaNs(true);
-      }
-
-      if (InferredFMF != FMF) {
-        CI->setFastMathFlags(InferredFMF);
-        return FPOp;
-      }
-
-      return nullptr;
-    }
-    case Intrinsic::exp:
-    case Intrinsic::exp2:
-    case Intrinsic::exp10: {
-      if ((DemandedMask & fcPositive) == fcNone) {
-        // Only returns positive values or nans.
-        if ((DemandedMask & fcNan) == fcNone)
-          return PoisonValue::get(VTy);
-
-        // Only need nan propagation.
-        if ((DemandedMask & ~fcNan) == fcNone)
-          return ConstantFP::getQNaN(VTy);
-
-        return CI->getArgOperand(0);
-      }
-
-      FPClassTest SrcDemandedMask = DemandedMask & fcNan;
-      if (DemandedMask & fcNan)
-        SrcDemandedMask |= fcNan;
-
-      if (DemandedMask & fcZero) {
-        // exp(-infinity) = 0
-        SrcDemandedMask |= fcNegInf;
-
-        // exp(-largest_normal) = 0
-        //
-        // Negative numbers of sufficiently large magnitude underflow to 0. No
-        // subnormal input has a 0 result.
-        SrcDemandedMask |= fcNegNormal;
-      }
-
-      if (DemandedMask & fcPosSubnormal) {
-        // Negative numbers of sufficiently large magnitude underflow to 0. No
-        // subnormal input has a 0 result.
-        SrcDemandedMask |= fcNegNormal;
-      }
-
-      if (DemandedMask & fcPosNormal) {
-        // exp(0) = 1
-        // exp(+/- smallest_normal) = 1
-        // exp(+/- largest_denormal) = 1
-        // exp(+/- smallest_denormal) = 1
-        // exp(-1) = pos normal
-        SrcDemandedMask |= fcNormal | fcSubnormal | fcZero;
-      }
-
-      // exp(inf), exp(largest_normal) = inf
-      if (DemandedMask & fcPosInf)
-        SrcDemandedMask |= fcPosInf | fcPosNormal;
-
-      KnownFPClass KnownSrc;
-
-      // TODO: This could really make use of KnownFPClass of specific value
-      // range, (i.e., close enough to 1)
-      if (SimplifyDemandedFPClass(I, 0, SrcDemandedMask, KnownSrc, SQ,
-                                  Depth + 1))
-        return I;
-
-      // exp(+/-0 | subnormal) = 1
-      if (KnownSrc.isKnownAlways(fcZero | fcSubnormal))
-        return ConstantFP::get(VTy, 1.0);
-
-      // Only perform nan propagation.
-      // Note: Dropping canonicalize / quiet of signaling nan.
-      if (KnownSrc.isKnownAlways(fcNan))
-        return CI->getArgOperand(0);
-
-      // exp(0 | subnormal | +inf | nan) => x + 1.0
-      if (KnownSrc.isKnownAlways(fcZero | fcSubnormal | fcPosInf | fcNan)) {
-        IRBuilderBase::InsertPointGuard Guard(Builder);
-        Builder.SetInsertPoint(CI);
-
-        // fadd +/-0, 1.0 => 1.0
-        // fadd subnormal, 1.0 => 1.0
-        // fadd +inf, 1.0 => +inf
-        // fadd nan, 1.0 => nan
-        return Builder.CreateFAddFMF(CI->getArgOperand(0),
-                                     ConstantFP::get(VTy, 1.0), FMF);
-      }
-
-      if (KnownSrc.isKnownAlways(fcInf | fcNan)) {
-        // exp(-inf) = 0
-        // exp(+inf) = +inf
-        IRBuilderBase::InsertPointGuard Guard(Builder);
-        Builder.SetInsertPoint(CI);
-
-        // Note: Dropping canonicalize / quiet of signaling nan.
-        Value *X = CI->getArgOperand(0);
-        Value *IsPosInfOrNan = Builder.CreateFCmpFMF(
-            FCmpInst::FCMP_UEQ, X, ConstantFP::getInfinity(VTy), FMF);
-        // We do not know whether an infinity or a NaN is more likely here,
-        // so mark the branch weights as unkown.
-        Value *ZeroOrInf = Builder.CreateSelectFMFWithUnknownProfile(
-            IsPosInfOrNan, X, ConstantFP::getZero(VTy), FMF, DEBUG_TYPE);
-        return ZeroOrInf;
-      }
-
-      Known = KnownFPClass::exp(KnownSrc);
-      Known.knownNot(~DemandedMask);
-
-      return simplifyDemandedFPClassResult(CI, FMF, DemandedMask, Known,
-                                           KnownSrc);
-    }
-    case Intrinsic::log:
-    case Intrinsic::log2:
-    case Intrinsic::log10: {
-      Type *EltTy = VTy->getScalarType();
-      bool IsMultiUnitFPType = EltTy->isMultiUnitFPType();
-
-      FPClassTest DemandedSrcMask = DemandedMask & (fcNan | fcPosInf);
-      if (DemandedMask & fcNan)
-        DemandedSrcMask |= fcNan;
-
-      DenormalMode Mode = F.getDenormalMode(EltTy->getFltSemantics());
-
-      // log(x) can be negative zero or subnormal if x is close to +1.0 for the
-      // PPCDoubleDouble type.
-      if (IsMultiUnitFPType && (DemandedMask & (fcNegZero | fcSubnormal))) {
-        DemandedSrcMask |= fcPosNormal;
-        // Note that DoubleAPFloat::isDenormal considers 1.0 + DBL_TRUE_MIN to
-        // be denormal, which APFloat::classify treats as fcSubnormal.
-        DemandedSrcMask |= fcPosSubnormal;
-      }
-
-      // log(x < 0) = nan
-      if (DemandedMask & fcNan)
-        DemandedSrcMask |= (fcNegative & ~fcNegZero);
-
-      // log(0) = -inf
-      if (DemandedMask & fcNegInf) {
-        DemandedSrcMask |= fcZero;
-
-        // Subnormals may be treated as logical zero.
-        if (Mode.inputsMayBeZero())
-          DemandedSrcMask |= fcSubnormal;
-      }
-
-      if (DemandedMask & fcNormal)
-        DemandedSrcMask |= fcNormal | fcSubnormal;
-
-      // log(1) = 0
-      if (DemandedMask & fcZero)
-        DemandedSrcMask |= fcPosNormal;
-
-      KnownFPClass KnownSrc;
-      if (SimplifyDemandedFPClass(I, 0, DemandedSrcMask, KnownSrc, SQ,
-                                  Depth + 1))
-        return I;
-
-      Known = KnownFPClass::log(KnownSrc, Mode, IsMultiUnitFPType);
-      Known.knownNot(~DemandedMask);
-
-      return simplifyDemandedFPClassResult(CI, FMF, DemandedMask, Known,
-                                           KnownSrc);
-    }
-    case Intrinsic::sqrt: {
-      Type *EltTy = VTy->getScalarType();
-      DenormalMode Mode = F.getDenormalMode(EltTy->getFltSemantics());
-
-      // Be explicit about the DemandedSrcMask so we do not miss anything.
-      FPClassTest DemandedSrcMask = fcNone;
-      if (DemandedMask & fcSNan)
-        DemandedSrcMask |= fcSNan;
-      if (DemandedMask & fcQNan)
-        DemandedSrcMask |=
-            fcQNan | fcSNan | fcNegInf | fcNegNormal | fcNegSubnormal;
-      if (DemandedMask & fcNegZero) {
-        DemandedSrcMask |= fcNegZero;
-        if (Mode.Input == DenormalMode::PreserveSign ||
-            Mode.Input == DenormalMode::Dynamic)
-          DemandedSrcMask |= fcNegSubnormal;
-      }
-      if (DemandedMask & fcPosZero) {
-        DemandedSrcMask |= fcPosZero;
-        if (Mode.inputsMayBeZero())
-          DemandedSrcMask |= fcPosSubnormal;
-        if (Mode.inputsMayBePositiveZero())
-          DemandedSrcMask |= fcNegSubnormal;
-      }
-      if (DemandedMask & fcPosNormal)
-        DemandedSrcMask |= fcPosSubnormal | fcPosNormal;
-      if (DemandedMask & fcPosInf)
-        DemandedSrcMask |= fcPosInf;
-
-      KnownFPClass KnownSrc;
-      if (SimplifyDemandedFPClass(I, 0, DemandedSrcMask, KnownSrc, SQ,
-                                  Depth + 1))
-        return I;
-
-      KnownSrc.knownNot(~DemandedSrcMask);
-
-      // sqrt(-x) = nan, but be careful of negative subnormals flushed to 0.
-      // TODO: This becomes redundant if KnownFPClass::sqrt rules out
-      // fcPosNormal.
-      if (KnownSrc.isKnownNever(fcPositive) &&
-          KnownSrc.isKnownNeverLogicalZero(Mode))
-        return ConstantFP::getQNaN(VTy);
-
-      Known = KnownFPClass::sqrt(KnownSrc, Mode);
-      Known.knownNot(~DemandedMask);
-
-      if (Known.getKnownFPClasses() == fcZero) {
-        if (FMF.noSignedZeros())
-          return ConstantFP::getZero(VTy);
-        IRBuilderBase::InsertPointGuard Guard(Builder);
-        Builder.SetInsertPoint(CI);
-
-        Value *Copysign = Builder.CreateCopySign(ConstantFP::getZero(VTy),
-                                                 CI->getArgOperand(0), FMF);
-        Copysign->takeName(CI);
-        return Copysign;
-      }
-
-      // TODO: fold sqrt(x) -> x when x is nan | pinf | zero
-
-      return simplifyDemandedFPClassResult(CI, FMF, DemandedMask, Known,
-                                           {KnownSrc});
-    }
-    case Intrinsic::ldexp: {
-      Type *EltTy = VTy->getScalarType();
-      const fltSemantics &FltSem = EltTy->getFltSemantics();
-      DenormalMode Mode = F.getDenormalMode(FltSem);
-
-      FPClassTest SrcDemandedMask = fcNone;
-      if (DemandedMask & fcNan)
-        SrcDemandedMask |= fcNan;
-
-      if (DemandedMask & fcPosInf)
-        SrcDemandedMask |= fcPosInf | fcPosNormal | fcPosSubnormal;
-      if (DemandedMask & fcNegInf)
-        SrcDemandedMask |= fcNegInf | fcNegNormal | fcNegSubnormal;
-
-      if (DemandedMask & (fcPosNormal | fcPosSubnormal))
-        SrcDemandedMask |= fcPosNormal | fcPosSubnormal;
-      if (DemandedMask & (fcNegNormal | fcNegSubnormal))
-        SrcDemandedMask |= fcNegNormal | fcNegSubnormal;
-
-      // Note: If we refine based on KnownExpBits in the future, then this
-      // denormal handling code will need to be updated.
-      if (DemandedMask & fcPosZero) {
-        SrcDemandedMask |= fcPosFinite;
-        if (Mode.inputsMayBePositiveZero())
-          SrcDemandedMask |= fcNegSubnormal;
-        if (Mode.outputsMayBePositiveZero())
-          SrcDemandedMask |= fcNegNormal | fcNegSubnormal;
-      }
-      if (DemandedMask & fcNegZero)
-        SrcDemandedMask |= fcNegFinite;
-
-      KnownFPClass KnownSrc;
-      if (SimplifyDemandedFPClass(CI, 0, SrcDemandedMask, KnownSrc, SQ,
-                                  Depth + 1))
-        return CI;
-
-      KnownBits KnownExpBits =
-          ::computeKnownBits(CI->getArgOperand(1), SQ, Depth + 1);
-
-      Known = KnownFPClass::ldexp(KnownSrc, KnownExpBits, FltSem, Mode);
-      Known.knownNot(~DemandedMask);
-
-      return simplifyDemandedFPClassResult(CI, FMF, DemandedMask, Known,
-                                           {KnownSrc});
-    }
-    case Intrinsic::trunc:
-    case Intrinsic::floor:
-    case Intrinsic::ceil:
-    case Intrinsic::rint:
-    case Intrinsic::nearbyint:
-    case Intrinsic::round:
-    case Intrinsic::roundeven: {
-      Type *EltTy = VTy->getScalarType();
-      DenormalMode Mode = F.getDenormalMode(EltTy->getFltSemantics());
-
-      FPClassTest DemandedSrcMask = DemandedMask;
-      if (DemandedMask & fcNan)
-        DemandedSrcMask |= fcNan;
-
-      const bool IsMultiUnitFPType = EltTy->isMultiUnitFPType();
-      // Rounding a finite multi-unit value may overflow to an infinity.
-      if (IsMultiUnitFPType) {
-        if (IID != Intrinsic::trunc && IID != Intrinsic::floor &&
-            (DemandedMask & fcPosInf))
-          DemandedSrcMask |= fcPosNormal;
-        if (IID != Intrinsic::trunc && IID != Intrinsic::ceil &&
-            (DemandedMask & fcNegInf))
-          DemandedSrcMask |= fcNegNormal;
-      }
-
-      // Zero results imply valid subnormal sources.
-      if (DemandedMask & fcNegZero)
-        DemandedSrcMask |= fcNegSubnormal | fcNegNormal;
-
-      if (DemandedMask & fcPosZero) {
-        DemandedSrcMask |= fcPosSubnormal | fcPosNormal;
-        if (Mode.inputsMayBePositiveZero())
-          DemandedSrcMask |= fcNegSubnormal;
-      }
-
-      // Rounding a subnormal away from zero may produce a normal value.
-      if (DemandedMask & fcNegNormal)
-        DemandedSrcMask |= fcNegSubnormal;
-      if (DemandedMask & fcPosNormal)
-        DemandedSrcMask |= fcPosSubnormal;
-
-      KnownFPClass KnownSrc;
-      if (SimplifyDemandedFPClass(CI, 0, DemandedSrcMask, KnownSrc, SQ,
-                                  Depth + 1))
-        return I;
-
-      // Note: Possibly dropping snan quiet.
-      if (KnownSrc.isKnownAlways(fcInf | fcNan | fcZero))
-        return CI->getArgOperand(0);
-
-      bool IsRoundNearestOrTrunc =
-          IID == Intrinsic::round || IID == Intrinsic::roundeven ||
-          IID == Intrinsic::nearbyint || IID == Intrinsic::rint ||
-          IID == Intrinsic::trunc;
-
-      if ((IID == Intrinsic::floor || IsRoundNearestOrTrunc) &&
-          KnownSrc.isKnownAlways(fcPosZero | fcPosSubnormal))
-        return ConstantFP::getZero(VTy);
-
-      if ((IID == Intrinsic::ceil || IsRoundNearestOrTrunc) &&
-          KnownSrc.isKnownAlways(fcNegZero | fcNegSubnormal) &&
-          !Mode.inputsMayBePositiveZero())
-        return ConstantFP::getZero(VTy, true);
-
-      if (IID == Intrinsic::floor && KnownSrc.isKnownAlways(fcNegSubnormal) &&
-          !Mode.inputsMayBeZero())
-        return ConstantFP::get(VTy, -1.0);
-
-      if (IID == Intrinsic::ceil && KnownSrc.isKnownAlways(fcPosSubnormal) &&
-          !Mode.inputsMayBeZero())
-        return ConstantFP::get(VTy, 1.0);
-
-      switch (IID) {
-      case Intrinsic::trunc:
-        Known = KnownFPClass::trunc(KnownSrc, Mode);
-        break;
-      case Intrinsic::floor:
-        Known = KnownFPClass::floor(KnownSrc, IsMultiUnitFPType, Mode);
-        break;
-      case Intrinsic::ceil:
-        Known = KnownFPClass::ceil(KnownSrc, IsMultiUnitFPType, Mode);
-        break;
-      default:
-        Known =
-            KnownFPClass::roundToIntegral(KnownSrc, IsMultiUnitFPType, Mode);
-        break;
-      }
-
-      Known.knownNot(~DemandedMask);
-
-      if (Constant *SingleVal =
-              getFPClassConstant(VTy, Known.getKnownFPClasses(),
-                                 /*IsCanonicalizing=*/true))
-        return SingleVal;
-
-      if ((IID == Intrinsic::trunc || IsRoundNearestOrTrunc) &&
-          KnownSrc.isKnownAlways(fcZero | fcSubnormal) &&
-          (!Mode.inputsMayBePositiveZero() ||
-           KnownSrc.isKnownNever(fcNegSubnormal))) {
-        IRBuilderBase::InsertPointGuard Guard(Builder);
-        Builder.SetInsertPoint(CI);
-
-        Value *Copysign = Builder.CreateCopySign(ConstantFP::getZero(VTy),
-                                                 CI->getArgOperand(0));
-        Copysign->takeName(CI);
-        return Copysign;
-      }
-
-      FastMathFlags InferredFMF =
-          inferFastMathValueFlags(FMF, Known.getKnownFPClasses(), KnownSrc);
-      if (InferredFMF != FMF) {
-        CI->dropUBImplyingAttrsAndMetadata();
-        CI->setFastMathFlags(InferredFMF);
-        return CI;
-      }
-
-      return nullptr;
-    }
-    case Intrinsic::fptrunc_round:
-      return simplifyDemandedUseFPClassFPTrunc(*this, *CI, FMF, DemandedMask,
-                                               Known, SQ, Depth);
-    case Intrinsic::canonicalize: {
-      Type *EltTy = VTy->getScalarType();
-
-      if (EltTy->isIEEELikeFPTy()) {
-        const fltSemantics &Flt = EltTy->getFltSemantics();
-        DenormalMode Mode = F.getDenormalMode(Flt);
-
-        FPClassTest SrcDemandedMask = DemandedMask;
-
-        // A demanded quiet nan result may have come from a signaling nan, so we
-        // need to expand the demanded mask.
-        if ((DemandedMask & fcQNan) != fcNone)
-          SrcDemandedMask |= fcSNan;
-
-        if (Mode != DenormalMode::getIEEE()) {
-          // Any zero results may have come from flushed denormals.
-          if (DemandedMask & fcPosZero) {
-            SrcDemandedMask |= fcPosSubnormal;
-            if (Mode.inputsMayBePositiveZero() ||
-                Mode.outputsMayBePositiveZero())
-              SrcDemandedMask |= fcNegSubnormal;
-          }
-          if (DemandedMask & fcNegZero)
-            SrcDemandedMask |= fcNegSubnormal;
-        }
-
-        if (Mode == DenormalMode::getPreserveSign()) {
-          // If a denormal input will be flushed, and we don't need zeros, we
-          // don't need denormals either.
-          if ((DemandedMask & fcPosZero) == fcNone)
-            SrcDemandedMask &= ~fcPosSubnormal;
-
-          if ((DemandedMask & fcNegZero) == fcNone)
-            SrcDemandedMask &= ~fcNegSubnormal;
-        }
-
-        KnownFPClass KnownSrc;
-
-        // Simplify upstream operations before trying to simplify this call.
-        if (SimplifyDemandedFPClass(I, 0, SrcDemandedMask, KnownSrc, SQ,
-                                    Depth + 1))
-          return I;
-
-        // Perform the canonicalization to see if this folded to a constant.
-        Known = KnownFPClass::canonicalize(KnownSrc, Flt, Mode);
-        Known.knownNot(~DemandedMask);
-
-        if (Constant *SingleVal =
-                getFPClassConstant(VTy, Known.getKnownFPClasses()))
-          return SingleVal;
-
-        // For IEEE handling, there is only a bit change for nan inputs, so we
-        // can drop it if we do not demand nan results or we know the input
-        // isn't a nan.
-        // Otherwise, we also need to avoid denormal inputs to drop the
-        // canonicalize.
-        if (KnownSrc.isKnownNeverNaN() && (Mode == DenormalMode::getIEEE() ||
-                                           KnownSrc.isKnownNeverSubnormal()))
-          return CI->getArgOperand(0);
-
-        FastMathFlags InferredFMF =
-            inferFastMathValueFlags(FMF, Known.getKnownFPClasses(), KnownSrc);
-        if (InferredFMF != FMF) {
-          CI->dropUBImplyingAttrsAndMetadata();
-          CI->setFastMathFlags(InferredFMF);
-          return CI;
-        }
-
-        return nullptr;
-      }
-
-      [[fallthrough]];
-    }
-    default:
-      Known = computeKnownFPClass(I, DemandedMask, SQ, Depth + 1);
-      Known.knownNot(~DemandedMask);
-      break;
-    }
-
-    break;
-  }
-  case Instruction::Select: {
-    KnownFPClass KnownLHS, KnownRHS;
-    if (SimplifyDemandedFPClass(I, 2, DemandedMask, KnownRHS, SQ, Depth + 1) ||
-        SimplifyDemandedFPClass(I, 1, DemandedMask, KnownLHS, SQ, Depth + 1))
-      return I;
-
-    if (KnownLHS.isKnownNever(DemandedMask))
-      return I->getOperand(2);
-    if (KnownRHS.isKnownNever(DemandedMask))
-      return I->getOperand(1);
-
-    adjustKnownFPClassForSelectArm(KnownLHS, I->getOperand(0), I->getOperand(1),
-                                   /*Invert=*/false, SQ, Depth);
-    adjustKnownFPClassForSelectArm(KnownRHS, I->getOperand(0), I->getOperand(2),
-                                   /*Invert=*/true, SQ, Depth);
-    Known = KnownLHS.intersectWith(KnownRHS);
-    Known.knownNot(~DemandedMask);
-    break;
-  }
-  case Instruction::ExtractElement: {
-    // TODO: Handle demanded element mask
-    if (SimplifyDemandedFPClass(I, 0, DemandedMask, Known, SQ, Depth + 1))
-      return I;
-    Known.knownNot(~DemandedMask);
-    break;
-  }
-  case Instruction::InsertElement: {
-    KnownFPClass KnownInserted, KnownVec;
-    if (SimplifyDemandedFPClass(I, 1, DemandedMask, KnownInserted, SQ,
-                                Depth + 1) ||
-        SimplifyDemandedFPClass(I, 0, DemandedMask, KnownVec, SQ, Depth + 1))
-      return I;
-
-    // TODO: Use demanded elements logic from computeKnownFPClass
-    Known = KnownVec | KnownInserted;
-    Known.knownNot(~DemandedMask);
-    break;
-  }
-  case Instruction::ShuffleVector: {
-    KnownFPClass KnownLHS, KnownRHS;
-    if (SimplifyDemandedFPClass(I, 1, DemandedMask, KnownRHS, SQ, Depth + 1) ||
-        SimplifyDemandedFPClass(I, 0, DemandedMask, KnownLHS, SQ, Depth + 1))
-      return I;
-
-    // TODO: This is overly conservative and should consider demanded elements,
-    // and splats.
-    Known = KnownLHS | KnownRHS;
-    Known.knownNot(~DemandedMask);
-    break;
-  }
-  case Instruction::InsertValue: {
-    KnownFPClass KnownAgg, KnownElt;
-    if (SimplifyDemandedFPClass(I, 0, DemandedMask, KnownAgg, SQ, Depth + 1) ||
-        SimplifyDemandedFPClass(I, 1, DemandedMask, KnownElt, SQ, Depth + 1))
-      return I;
-
-    Known = KnownAgg | KnownElt;
-    break;
-  }
-  case Instruction::ExtractValue: {
-    Value *ExtractSrc;
-    if (match(I, m_ExtractValue<0>(m_OneUse(m_Value(ExtractSrc))))) {
-      if (auto *II = dyn_cast<IntrinsicInst>(ExtractSrc)) {
-        const Intrinsic::ID IID = II->getIntrinsicID();
-        switch (IID) {
-        case Intrinsic::frexp: {
-          FPClassTest SrcDemandedMask = fcNone;
-
-          if (DemandedMask & fcNan)
-            SrcDemandedMask |= fcNan;
-
-          // Positive subnormals and negative subnormals could become positive
-          // zero.
-          if (DemandedMask & fcPosZero)
-            SrcDemandedMask |= fcPosZero | fcSubnormal;
-
-          // Negative subnormals could become negative zero.
-          if (DemandedMask & fcNegZero)
-            SrcDemandedMask |= fcNegZero | fcNegSubnormal;
-
-          if (DemandedMask & (fcNegNormal | fcNegSubnormal))
-            SrcDemandedMask |= fcNegNormal | fcNegSubnormal;
-          if (DemandedMask & (fcPosNormal | fcPosSubnormal))
-            SrcDemandedMask |= fcPosNormal | fcPosSubnormal;
-
-          if (DemandedMask & fcPosInf)
-            SrcDemandedMask |= fcPosInf;
-          if (DemandedMask & fcNegInf)
-            SrcDemandedMask |= fcNegInf;
-
-          KnownFPClass KnownSrc;
-          if (SimplifyDemandedFPClass(II, 0, SrcDemandedMask, KnownSrc, SQ,
-                                      Depth + 1))
-            return I;
-
-          Type *EltTy = VTy->getScalarType();
-          DenormalMode Mode = F.getDenormalMode(EltTy->getFltSemantics());
-
-          Known = KnownFPClass::frexp_mant(KnownSrc, Mode);
-          Known.setKnownFPClasses(Known.getKnownFPClasses() & DemandedMask);
-
-          if (Constant *SingleVal =
-                  getFPClassConstant(VTy, Known.getKnownFPClasses(),
-                                     /*IsCanonicalizing=*/true))
-            return SingleVal;
-
-          // frexp returns zero, infinity, and NaN inputs unchanged.
-          if (KnownSrc.isKnownAlways(fcZero | fcInf | fcNan))
-            return II->getArgOperand(0);
-
-          return nullptr;
-        }
-        default:
-          break;
-        }
-      }
-    }
-
-    KnownFPClass KnownSrc;
-    if (SimplifyDemandedFPClass(I, 0, DemandedMask, KnownSrc, SQ, Depth + 1))
-      return I;
-    Known = KnownSrc;
-    break;
-  }
-  case Instruction::PHI: {
-    const unsigned PhiRecursionLimit = MaxAnalysisRecursionDepth - 2;
-    if (Depth >= PhiRecursionLimit)
-      break;
-
-    PHINode *P = cast<PHINode>(I);
-    SimplifyQuery ContextSQ = SQ.getWithoutCondContext();
-
-    bool First = true;
-    bool Changed = false;
-    for (unsigned I = 0, E = P->getNumIncomingValues(); I != E; ++I) {
-      // TODO: Better support for self recursive phi
-      BasicBlock *PredBB = P->getIncomingBlock(I);
-      const Instruction *CtxI = PredBB->getTerminator();
-
-      // Attempt to simplify all incoming edges at a time. If we simplify one
-      // incoming edge, the phi may fold away, losing information on a later
-      // visit.
-      KnownFPClass KnownSrc;
-      if (SimplifyDemandedFPClass(
-              P, P->getOperandNumForIncomingValue(I), DemandedMask, KnownSrc,
-              ContextSQ.getWithInstruction(CtxI), Depth + 1)) {
-        // Fixup the other block references to the simplified value.
-        P->setIncomingValueForBlock(PredBB, P->getIncomingValue(I));
-        Changed = true;
-      }
-
-      if (First) {
-        Known = KnownSrc;
-        First = false;
-      } else {
-        Known |= KnownSrc;
-      }
-    }
-
-    if (Changed)
-      return P;
-
-    Known.knownNot(~DemandedMask);
-    break;
-  }
-  default:
-    Known = computeKnownFPClass(I, DemandedMask, SQ, Depth + 1);
-    Known.knownNot(~DemandedMask);
-    break;
-  }
-
-  return getFPClassConstant(VTy, Known.getKnownFPClasses());
-}
-
-/// Helper routine of SimplifyDemandedUseFPClass. It computes Known
-/// floating-point classes. It also tries to handle simplifications that can be
-/// done based on DemandedMask, but without modifying the Instruction.
-Value *InstCombinerImpl::SimplifyMultipleUseDemandedFPClass(
-    Instruction *I, FPClassTest DemandedMask, KnownFPClass &Known,
-    const SimplifyQuery &SQ, unsigned Depth) {
-  FastMathFlags FMF;
-  if (auto *FPOp = dyn_cast<FPMathOperator>(I)) {
-    FMF = FPOp->getFastMathFlags();
-    DemandedMask = adjustDemandedMaskFromFlags(DemandedMask, FMF);
-  }
-
-  switch (I->getOpcode()) {
-  case Instruction::Select: {
-    // TODO: Can we infer which side it came from based on adjusted result
-    // class?
-    KnownFPClass KnownRHS =
-        computeKnownFPClass(I->getOperand(2), DemandedMask, SQ, Depth + 1);
-    if (KnownRHS.isKnownNever(DemandedMask))
-      return I->getOperand(1);
-
-    KnownFPClass KnownLHS =
-        computeKnownFPClass(I->getOperand(1), DemandedMask, SQ, Depth + 1);
-    if (KnownLHS.isKnownNever(DemandedMask))
-      return I->getOperand(2);
-
-    adjustKnownFPClassForSelectArm(KnownLHS, I->getOperand(0), I->getOperand(1),
-                                   /*Invert=*/false, SQ, Depth);
-    adjustKnownFPClassForSelectArm(KnownRHS, I->getOperand(0), I->getOperand(2),
-                                   /*Invert=*/true, SQ, Depth);
-    Known = KnownLHS.intersectWith(KnownRHS);
-    Known.knownNot(~DemandedMask);
-    break;
-  }
-  case Instruction::FNeg: {
-    // Special case fneg(fabs(x))
-    Value *Src;
-
-    Value *FNegSrc = I->getOperand(0);
-    if (!match(FNegSrc, m_FAbs(m_Value(Src)))) {
-      Known = computeKnownFPClass(I, DemandedMask, SQ, Depth + 1);
-      break;
-    }
-
-    KnownFPClass KnownSrc = computeKnownFPClass(Src, fcAllFlags, SQ, Depth + 1);
-
-    FastMathFlags FabsFMF = cast<FPMathOperator>(FNegSrc)->getFastMathFlags();
-    FPClassTest ThisDemandedMask =
-        adjustDemandedMaskFromFlags(DemandedMask, FabsFMF);
-
-    // We cannot apply the NSZ logic with multiple uses. We can apply it if the
-    // inner fabs has it and this is the only use.
-    if (Value *Simplified = simplifyDemandedFPClassFnegFabs(
-            Known, Src, ThisDemandedMask, KnownSrc, /*NSZ=*/false))
-      return Simplified;
-    break;
-  }
-  case Instruction::Call: {
-    const CallInst *CI = cast<CallInst>(I);
-    const Intrinsic::ID IID = CI->getIntrinsicID();
-    switch (IID) {
-    case Intrinsic::fabs: {
-      Value *Src = CI->getArgOperand(0);
-      KnownFPClass KnownSrc =
-          computeKnownFPClass(Src, fcAllFlags, SQ, Depth + 1);
-
-      // NSZ cannot be applied in multiple use case (maybe it could if all uses
-      // were known nsz)
-      if (Value *Simplified = simplifyDemandedFPClassFabs(
-              Known, CI->getArgOperand(0), DemandedMask, KnownSrc,
-              /*NSZ=*/false))
-        return Simplified;
-      break;
-    }
-    case Intrinsic::copysign: {
-      Value *Mag = CI->getArgOperand(0);
-      Value *Sign = CI->getArgOperand(1);
-      KnownFPClass KnownMag =
-          computeKnownFPClass(Mag, fcAllFlags, SQ, Depth + 1);
-
-      // Rule out some cases by magnitude, which may help prove the sign bit is
-      // one direction or the other.
-      KnownMag.knownNot(~llvm::unknown_sign(DemandedMask));
-
-      // Cannot use nsz in the multiple use case.
-      if (Value *Simplified = simplifyDemandedFPClassCopysignMag(
-              Mag, DemandedMask, KnownMag, /*NSZ=*/false))
-        return Simplified;
-
-      KnownFPClass KnownSign =
-          computeKnownFPClass(Sign, fcAllFlags, SQ, Depth + 1);
-
-      if (FMF.noInfs())
-        KnownSign.knownNot(fcInf);
-      if (FMF.noNaNs())
-        KnownSign.knownNot(fcNan);
-
-      if (KnownSign.getSignBit() && KnownMag.getSignBit() &&
-          *KnownSign.getSignBit() == *KnownMag.getSignBit())
-        return Mag;
-
-      Known = KnownFPClass::copysign(KnownMag, KnownSign);
-      break;
-    }
-    case Intrinsic::maxnum:
-    case Intrinsic::minnum:
-    case Intrinsic::maximum:
-    case Intrinsic::minimum:
-    case Intrinsic::maximumnum:
-    case Intrinsic::minimumnum: {
-      KnownFPClass KnownRHS = computeKnownFPClass(CI->getArgOperand(1),
-                                                  DemandedMask, SQ, Depth + 1);
-      if (KnownRHS.isUnknown())
-        return nullptr;
-
-      KnownFPClass KnownLHS = computeKnownFPClass(CI->getArgOperand(0),
-                                                  DemandedMask, SQ, Depth + 1);
-
-      // Cannot use NSZ in the multiple use case.
-      return simplifyDemandedFPClassMinMax(Known, IID, CI, DemandedMask,
-                                           KnownLHS, KnownRHS, F,
-                                           /*NSZ=*/false);
-    }
-    default:
-      break;
-    }
-
-    [[fallthrough]];
-  }
-  default:
-    Known = computeKnownFPClass(I, DemandedMask, SQ, Depth + 1);
-    Known.knownNot(~DemandedMask);
-    break;
-  }
-
-  return getFPClassConstant(I->getType(), Known.getKnownFPClasses());
-}
-
-bool InstCombinerImpl::SimplifyDemandedFPClass(Instruction *I, unsigned OpNo,
-                                               FPClassTest DemandedMask,
-                                               KnownFPClass &Known,
-                                               const SimplifyQuery &SQ,
-                                               unsigned Depth) {
-  Use &U = I->getOperandUse(OpNo);
-  Value *V = U.get();
-  Type *VTy = V->getType();
-
-  if (DemandedMask == fcNone) {
-    if (isa<PoisonValue>(V))
-      return false;
-    replaceUse(U, PoisonValue::get(VTy));
-    return true;
-  }
-
-  // Handle constant
-  Instruction *VInst = dyn_cast<Instruction>(V);
-  if (!VInst) {
-    // Handle constants and arguments
-    Known = computeKnownFPClass(V, fcAllFlags, SQ, Depth);
-    Known.knownNot(~DemandedMask);
-
-    if (Known.getKnownFPClasses() == fcNone) {
-      if (isa<PoisonValue>(V))
-        return false;
-      replaceUse(U, PoisonValue::get(VTy));
-      return true;
-    }
-
-    // Do not try to replace values which are already constants (unless we are
-    // folding to poison). Doing so could promote poison elements to non-poison
-    // constants.
-    if (isa<Constant>(V))
-      return false;
-
-    Value *FoldedToConst = getFPClassConstant(VTy, Known.getKnownFPClasses());
-    if (!FoldedToConst || FoldedToConst == V)
-      return false;
-
-    replaceUse(U, FoldedToConst);
-    return true;
-  }
-
-  if (Depth == MaxAnalysisRecursionDepth) {
-    Known.knownNot(~DemandedMask);
-    return false;
-  }
-
-  Value *NewVal;
-
-  if (VInst->hasOneUse()) {
-    // If the instruction has one use, we can directly simplify it.
-    NewVal = SimplifyDemandedUseFPClass(VInst, DemandedMask, Known, SQ, Depth);
-  } else {
-    // If there are multiple uses of this instruction, then we can simplify
-    // VInst to some other value, but not modify the instruction.
-    NewVal = SimplifyMultipleUseDemandedFPClass(VInst, DemandedMask, Known, SQ,
-                                                Depth);
-  }
-
-  if (!NewVal)
-    return false;
-  // Recursion through a PHI may have already replaced this use. If the
-  // recursive simplification only changed V in place, do not restore it.
-  if (NewVal == V && U.get() != V)
-    return true;
-  if (Instruction *OpInst = dyn_cast<Instruction>(U))
-    salvageDebugInfo(*OpInst);
-
-  replaceUse(U, NewVal);
-  return true;
-}
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemandedFP.cpp b/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemandedFP.cpp
new file mode 100644
index 00000000000000..d474eec309a8d5
--- /dev/null
+++ b/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemandedFP.cpp
@@ -0,0 +1,1938 @@
+//===- InstCombineSimplifyDemandedFP.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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains logic for simplifying floating-point instructions based on
+// information about how they are used.
+//
+//===----------------------------------------------------------------------===//
+
+#include "InstCombineInternal.h"
+#include "llvm/Analysis/ValueTracking.h"
+#include "llvm/IR/IntrinsicInst.h"
+#include "llvm/IR/PatternMatch.h"
+#include "llvm/Support/KnownBits.h"
+#include "llvm/Support/KnownFPClass.h"
+#include "llvm/Transforms/InstCombine/InstCombiner.h"
+
+using namespace llvm;
+using namespace llvm::PatternMatch;
+
+#define DEBUG_TYPE "instcombine"
+
+bool InstCombinerImpl::SimplifyDemandedInstructionFPClass(Instruction &Inst) {
+  KnownFPClass Known;
+
+  Value *V = SimplifyDemandedUseFPClass(&Inst, fcAllFlags, Known,
+                                        SQ.getWithInstruction(&Inst));
+  if (!V)
+    return false;
+  if (V == &Inst)
+    return true;
+  replaceInstUsesWith(Inst, V);
+  return true;
+}
+
+/// For floating-point classes that resolve to a single bit pattern, return that
+/// value.
+static Constant *getFPClassConstant(Type *Ty, FPClassTest Mask,
+                                    bool IsCanonicalizing = false) {
+  if (Mask == fcNone)
+    return PoisonValue::get(Ty);
+
+  if (Mask == fcPosZero)
+    return Constant::getNullValue(Ty);
+
+  // TODO: Support aggregate types that are allowed by FPMathOperator.
+  if (Ty->isAggregateType())
+    return nullptr;
+
+  // Turn any possible snans into quiet if we can.
+  if (Mask == fcNan && IsCanonicalizing)
+    return ConstantFP::getQNaN(Ty);
+
+  switch (Mask) {
+  case fcNegZero:
+    return ConstantFP::getZero(Ty, true);
+  case fcPosInf:
+    return ConstantFP::getInfinity(Ty);
+  case fcNegInf:
+    return ConstantFP::getInfinity(Ty, true);
+  case fcQNan:
+    // Payload bits cannot be dropped for pure signbit operations.
+    return IsCanonicalizing ? ConstantFP::getQNaN(Ty) : nullptr;
+  default:
+    return nullptr;
+  }
+}
+
+/// Perform multiple-use aware simplfications for fabs(\p Src). Returns a
+/// replacement value if it's simplified, otherwise nullptr. Updates \p Known
+/// with the known fpclass if not simplified.
+static Value *simplifyDemandedFPClassFabs(KnownFPClass &Known, Value *Src,
+                                          FPClassTest DemandedMask,
+                                          KnownFPClass KnownSrc, bool NSZ) {
+  if ((DemandedMask & fcNan) == fcNone)
+    KnownSrc.knownNot(fcNan);
+  if ((DemandedMask & fcInf) == fcNone)
+    KnownSrc.knownNot(fcInf);
+
+  if (KnownSrc.getSignBit() == false ||
+      ((DemandedMask & fcNan) == fcNone && KnownSrc.isKnownNever(fcNegative)))
+    return Src;
+
+  // If the only sign bit difference is due to -0, ignore it with nsz
+  if (NSZ &&
+      KnownSrc.isKnownNever(KnownFPClass::OrderedLessThanZeroMask | fcNan))
+    return Src;
+
+  Known = KnownFPClass::fabs(KnownSrc);
+  Known.knownNot(~DemandedMask);
+  return nullptr;
+}
+
+/// Try to set an inferred no-nans or no-infs in \p FMF. \p ValidResults is a
+/// mask of known valid results for the operator (already computed from the
+/// result, and the known operand inputs in \p Known)
+static FastMathFlags inferFastMathValueFlags(FastMathFlags FMF,
+                                             FPClassTest ValidResults,
+                                             ArrayRef<KnownFPClass> Known) {
+  if (!FMF.noNaNs() && (ValidResults & fcNan) == fcNone) {
+    if (all_of(Known, [](const KnownFPClass KnownSrc) {
+          return KnownSrc.isKnownNeverNaN();
+        }))
+      FMF.setNoNaNs();
+  }
+
+  if (!FMF.noInfs() && (ValidResults & fcInf) == fcNone) {
+    if (all_of(Known, [](const KnownFPClass KnownSrc) {
+          return KnownSrc.isKnownNeverInfinity();
+        }))
+      FMF.setNoInfs();
+  }
+
+  return FMF;
+}
+
+static FPClassTest adjustDemandedMaskFromFlags(FPClassTest DemandedMask,
+                                               FastMathFlags FMF) {
+  if (FMF.noNaNs())
+    DemandedMask &= ~fcNan;
+
+  if (FMF.noInfs())
+    DemandedMask &= ~fcInf;
+  return DemandedMask;
+}
+
+/// Apply epilog fixups to a floating-point intrinsic. See if the result can
+/// fold to a constant, or apply fast math flags.
+static Value *simplifyDemandedFPClassResult(Instruction *FPOp,
+                                            FastMathFlags FMF,
+                                            FPClassTest DemandedMask,
+                                            KnownFPClass &Known,
+                                            ArrayRef<KnownFPClass> KnownSrcs) {
+  FPClassTest ValidResults = DemandedMask & Known.getKnownFPClasses();
+  Constant *SingleVal = getFPClassConstant(FPOp->getType(), ValidResults,
+                                           /*IsCanonicalizing=*/true);
+  if (SingleVal)
+    return SingleVal;
+
+  FastMathFlags InferredFMF =
+      inferFastMathValueFlags(FMF, ValidResults, KnownSrcs);
+  if (InferredFMF != FMF) {
+    FPOp->dropUBImplyingAttrsAndMetadata();
+    FPOp->setFastMathFlags(InferredFMF);
+    return FPOp;
+  }
+
+  return nullptr;
+}
+
+/// Perform multiple-use aware simplfications for fneg(fabs(\p Src)). Returns a
+/// replacement value if it's simplified, otherwise nullptr. Updates \p Known
+/// with the known fpclass if not simplified.
+static Value *simplifyDemandedFPClassFnegFabs(KnownFPClass &Known, Value *Src,
+                                              FPClassTest DemandedMask,
+                                              KnownFPClass KnownSrc, bool NSZ) {
+  if ((DemandedMask & fcNan) == fcNone)
+    KnownSrc.knownNot(fcNan);
+  if ((DemandedMask & fcInf) == fcNone)
+    KnownSrc.knownNot(fcInf);
+
+  // If the source value is known negative, we can directly fold to it.
+  if (KnownSrc.getSignBit() == true)
+    return Src;
+
+  // If the only sign bit difference is for 0, ignore it with nsz.
+  if (NSZ &&
+      KnownSrc.isKnownNever(KnownFPClass::OrderedGreaterThanZeroMask | fcNan))
+    return Src;
+
+  Known = KnownFPClass::fneg(KnownFPClass::fabs(KnownSrc));
+  Known.knownNot(~DemandedMask);
+  return nullptr;
+}
+
+static Value *simplifyDemandedFPClassCopysignMag(Value *MagSrc,
+                                                 FPClassTest DemandedMask,
+                                                 KnownFPClass KnownSrc,
+                                                 bool NSZ) {
+  if (NSZ) {
+    constexpr FPClassTest NegOrZero = fcNegative | fcPosZero;
+    constexpr FPClassTest PosOrZero = fcPositive | fcNegZero;
+
+    if ((DemandedMask & ~NegOrZero) == fcNone &&
+        KnownSrc.isKnownAlways(NegOrZero))
+      return MagSrc;
+
+    if ((DemandedMask & ~PosOrZero) == fcNone &&
+        KnownSrc.isKnownAlways(PosOrZero))
+      return MagSrc;
+  } else {
+    if ((DemandedMask & ~fcNegative) == fcNone && KnownSrc.getSignBit() == true)
+      return MagSrc;
+
+    if ((DemandedMask & ~fcPositive) == fcNone &&
+        KnownSrc.getSignBit() == false)
+      return MagSrc;
+  }
+
+  return nullptr;
+}
+
+static Value *
+simplifyDemandedFPClassMinMax(KnownFPClass &Known, Intrinsic::ID IID,
+                              const CallInst *CI, FPClassTest DemandedMask,
+                              KnownFPClass KnownLHS, KnownFPClass KnownRHS,
+                              const Function &F, bool NSZ) {
+  bool OrderedZeroSign = !NSZ;
+
+  KnownFPClass::MinMaxKind OpKind;
+  switch (IID) {
+  case Intrinsic::maximum: {
+    OpKind = KnownFPClass::MinMaxKind::maximum;
+
+    // If one operand is known greater than the other, it must be that
+    // operand unless the other is a nan.
+    if (cannotOrderStrictlyLess(KnownLHS.getKnownFPClasses(),
+                                KnownRHS.getKnownFPClasses(),
+                                OrderedZeroSign) &&
+        KnownRHS.isKnownNever(fcNan))
+      return CI->getArgOperand(0);
+
+    if (cannotOrderStrictlyGreater(KnownLHS.getKnownFPClasses(),
+                                   KnownRHS.getKnownFPClasses(),
+                                   OrderedZeroSign) &&
+        KnownLHS.isKnownNever(fcNan))
+      return CI->getArgOperand(1);
+
+    break;
+  }
+  case Intrinsic::minimum: {
+    OpKind = KnownFPClass::MinMaxKind::minimum;
+
+    // If one operand is known less than the other, it must be that operand
+    // unless the other is a nan.
+    if (cannotOrderStrictlyGreater(KnownLHS.getKnownFPClasses(),
+                                   KnownRHS.getKnownFPClasses(),
+                                   OrderedZeroSign) &&
+        KnownRHS.isKnownNever(fcNan))
+      return CI->getArgOperand(0);
+
+    if (cannotOrderStrictlyLess(KnownLHS.getKnownFPClasses(),
+                                KnownRHS.getKnownFPClasses(),
+                                OrderedZeroSign) &&
+        KnownLHS.isKnownNever(fcNan))
+      return CI->getArgOperand(1);
+
+    break;
+  }
+  case Intrinsic::maxnum:
+  case Intrinsic::maximumnum: {
+    OpKind = IID == Intrinsic::maxnum ? KnownFPClass::MinMaxKind::maxnum
+                                      : KnownFPClass::MinMaxKind::maximumnum;
+
+    if (cannotOrderStrictlyLess(KnownLHS.getKnownFPClasses(),
+                                KnownRHS.getKnownFPClasses(),
+                                OrderedZeroSign) &&
+        KnownLHS.isKnownNever(fcNan))
+      return CI->getArgOperand(0);
+
+    if (cannotOrderStrictlyGreater(KnownLHS.getKnownFPClasses(),
+                                   KnownRHS.getKnownFPClasses(),
+                                   OrderedZeroSign) &&
+        KnownRHS.isKnownNever(fcNan))
+      return CI->getArgOperand(1);
+
+    break;
+  }
+  case Intrinsic::minnum:
+  case Intrinsic::minimumnum: {
+    OpKind = IID == Intrinsic::minnum ? KnownFPClass::MinMaxKind::minnum
+                                      : KnownFPClass::MinMaxKind::minimumnum;
+
+    if (cannotOrderStrictlyGreater(KnownLHS.getKnownFPClasses(),
+                                   KnownRHS.getKnownFPClasses(),
+                                   OrderedZeroSign) &&
+        KnownLHS.isKnownNever(fcNan))
+      return CI->getArgOperand(0);
+
+    if (cannotOrderStrictlyLess(KnownLHS.getKnownFPClasses(),
+                                KnownRHS.getKnownFPClasses(),
+                                OrderedZeroSign) &&
+        KnownRHS.isKnownNever(fcNan))
+      return CI->getArgOperand(1);
+
+    break;
+  }
+  default:
+    llvm_unreachable("not a min/max intrinsic");
+  }
+
+  Type *EltTy = CI->getType()->getScalarType();
+  DenormalMode Mode = F.getDenormalMode(EltTy->getFltSemantics());
+  Known = KnownFPClass::minMaxLike(KnownLHS, KnownRHS, OpKind, Mode);
+  Known.knownNot(~DemandedMask);
+
+  return getFPClassConstant(CI->getType(), Known.getKnownFPClasses(),
+                            /*IsCanonicalizing=*/true);
+}
+
+static Value *
+simplifyDemandedUseFPClassFPTrunc(InstCombinerImpl &IC, Instruction &I,
+                                  FastMathFlags FMF, FPClassTest DemandedMask,
+                                  KnownFPClass &Known, const SimplifyQuery &SQ,
+                                  unsigned Depth) {
+  const fltSemantics &DstTy = I.getType()->getScalarType()->getFltSemantics();
+  const fltSemantics &SrcTy =
+      I.getOperand(0)->getType()->getScalarType()->getFltSemantics();
+
+  const Function *Fn = I.getFunction();
+  DenormalMode DstMode =
+      Fn ? Fn->getDenormalMode(DstTy) : DenormalMode::getDynamic();
+  DenormalMode SrcMode =
+      Fn ? Fn->getDenormalMode(SrcTy) : DenormalMode::getDynamic();
+
+  FPClassTest SrcDemandedMask = DemandedMask;
+  if (DemandedMask & fcNan)
+    SrcDemandedMask |= fcNan;
+
+  // Zero results may have been rounded from subnormal or normal sources.
+  if (DemandedMask & fcNegZero)
+    SrcDemandedMask |= fcNegSubnormal | fcNegNormal;
+  if (DemandedMask & fcPosZero)
+    SrcDemandedMask |= fcPosSubnormal | fcPosNormal;
+
+  // Subnormal results may have been normal in the source type
+  if (DemandedMask & fcNegSubnormal)
+    SrcDemandedMask |= fcNegNormal;
+  if (DemandedMask & fcPosSubnormal)
+    SrcDemandedMask |= fcPosNormal;
+
+  const bool SubnormalNeverProducesNormal =
+      DstTy.minExponent > SrcTy.minExponent;
+
+  // A subnormal input may round to a normal value in the destination type.
+  // For example: bf16 = fptrunc(f32) and f80 = fptrunc(f128).
+  if (!SubnormalNeverProducesNormal) {
+    // TODO: Refine based on the rounding mode.
+    if (DemandedMask & fcNegNormal)
+      SrcDemandedMask |= fcNegSubnormal;
+    if (DemandedMask & fcPosNormal)
+      SrcDemandedMask |= fcPosSubnormal;
+  }
+
+  if (DemandedMask & fcPosInf)
+    SrcDemandedMask |= fcPosNormal;
+  if (DemandedMask & fcNegInf)
+    SrcDemandedMask |= fcNegNormal;
+
+  // TODO: This is a conservative approach for determining the actual input and
+  // output denormal mode used by fptrunc.
+  if (DstMode != DenormalMode::getIEEE() ||
+      SrcMode != DenormalMode::getIEEE()) {
+    // Input subnormals may flush to zero, and output subnormals may also flush
+    // to zero. The result can be subnormal (and flushed to zero) even if the
+    // input is normal.
+    if ((DemandedMask & fcZero) != fcNone)
+      SrcDemandedMask |= fcSubnormal | fcNormal;
+  }
+
+  KnownFPClass KnownSrc;
+  if (IC.SimplifyDemandedFPClass(&I, 0, SrcDemandedMask, KnownSrc, SQ,
+                                 Depth + 1))
+    return &I;
+
+  Known = KnownFPClass::fptrunc(KnownSrc, DstTy, SrcTy, DstMode, SrcMode);
+  Known.knownNot(~DemandedMask);
+
+  return simplifyDemandedFPClassResult(&I, FMF, DemandedMask, Known,
+                                       {KnownSrc});
+}
+
+Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
+                                                    FPClassTest DemandedMask,
+                                                    KnownFPClass &Known,
+                                                    const SimplifyQuery &SQ,
+                                                    unsigned Depth) {
+  assert(Depth <= MaxAnalysisRecursionDepth && "Limit Search Depth");
+  assert(Known == KnownFPClass() && "expected uninitialized state");
+
+  Type *VTy = I->getType();
+
+  FastMathFlags FMF;
+  if (auto *FPOp = dyn_cast<FPMathOperator>(I)) {
+    FMF = FPOp->getFastMathFlags();
+    DemandedMask = adjustDemandedMaskFromFlags(DemandedMask, FMF);
+  }
+
+  switch (I->getOpcode()) {
+  case Instruction::FNeg: {
+    // Special case fneg(fabs(x))
+
+    Value *FNegSrc = I->getOperand(0);
+    Value *FNegFAbsSrc;
+    if (match(FNegSrc, m_OneUse(m_FAbs(m_Value(FNegFAbsSrc))))) {
+      KnownFPClass KnownSrc;
+      if (SimplifyDemandedFPClass(cast<Instruction>(FNegSrc), 0,
+                                  llvm::unknown_sign(DemandedMask), KnownSrc,
+                                  SQ, Depth + 1))
+        return I;
+
+      FastMathFlags FabsFMF = cast<FPMathOperator>(FNegSrc)->getFastMathFlags();
+      FPClassTest ThisDemandedMask =
+          adjustDemandedMaskFromFlags(DemandedMask, FabsFMF);
+
+      bool IsNSZ = FMF.noSignedZeros() || FabsFMF.noSignedZeros();
+      if (Value *Simplified = simplifyDemandedFPClassFnegFabs(
+              Known, FNegFAbsSrc, ThisDemandedMask, KnownSrc, IsNSZ))
+        return Simplified;
+
+      if ((ThisDemandedMask & fcNan) == fcNone)
+        KnownSrc.knownNot(fcNan);
+      if ((ThisDemandedMask & fcInf) == fcNone)
+        KnownSrc.knownNot(fcInf);
+
+      // fneg(fabs(x)) => fneg(x)
+      if (KnownSrc.getSignBit() == false)
+        return replaceOperand(*I, 0, FNegFAbsSrc);
+
+      // fneg(fabs(x)) => fneg(x), ignoring -0 if nsz.
+      if (IsNSZ &&
+          KnownSrc.isKnownNever(KnownFPClass::OrderedLessThanZeroMask | fcNan))
+        return replaceOperand(*I, 0, FNegFAbsSrc);
+
+      break;
+    }
+
+    if (SimplifyDemandedFPClass(I, 0, llvm::fneg(DemandedMask), Known, SQ,
+                                Depth + 1))
+      return I;
+    Known.fneg();
+    Known.knownNot(~DemandedMask);
+    break;
+  }
+  case Instruction::FAdd:
+  case Instruction::FSub: {
+    KnownFPClass KnownLHS, KnownRHS;
+
+    // fadd x, x can be handled more aggressively.
+    if (I->getOperand(0) == I->getOperand(1) &&
+        I->getOpcode() == Instruction::FAdd &&
+        isGuaranteedNotToBeUndef(I->getOperand(0), SQ.AC, SQ.CtxI, SQ.DT,
+                                 Depth + 1)) {
+      Type *EltTy = VTy->getScalarType();
+      DenormalMode Mode = F.getDenormalMode(EltTy->getFltSemantics());
+
+      FPClassTest SrcDemandedMask = DemandedMask;
+      if (DemandedMask & fcNan)
+        SrcDemandedMask |= fcNan;
+
+      // Doubling a subnormal could have resulted in a normal value.
+      if (DemandedMask & fcPosNormal)
+        SrcDemandedMask |= fcPosSubnormal;
+      if (DemandedMask & fcNegNormal)
+        SrcDemandedMask |= fcNegSubnormal;
+
+      // Doubling a subnormal may produce 0 if FTZ/DAZ.
+      if (Mode != DenormalMode::getIEEE()) {
+        if (DemandedMask & fcPosZero) {
+          SrcDemandedMask |= fcPosSubnormal;
+
+          if (Mode.inputsMayBePositiveZero() || Mode.outputsMayBePositiveZero())
+            SrcDemandedMask |= fcNegSubnormal;
+        }
+
+        if (DemandedMask & fcNegZero)
+          SrcDemandedMask |= fcNegSubnormal;
+      }
+
+      // Doubling a normal could have resulted in an infinity.
+      if (DemandedMask & fcPosInf)
+        SrcDemandedMask |= fcPosNormal;
+      if (DemandedMask & fcNegInf)
+        SrcDemandedMask |= fcNegNormal;
+
+      if (SimplifyDemandedFPClass(I, 0, SrcDemandedMask, KnownLHS, SQ,
+                                  Depth + 1))
+        return I;
+
+      Known = KnownFPClass::fadd_self(KnownLHS, RoundingMode::NearestTiesToEven,
+                                      Mode);
+      KnownRHS = KnownLHS;
+    } else {
+      FPClassTest SrcDemandedMask = fcFinite;
+
+      // inf + (-inf) = nan
+      if (DemandedMask & fcNan)
+        SrcDemandedMask |= fcNan | fcInf;
+
+      if (DemandedMask & fcInf)
+        SrcDemandedMask |= fcInf;
+
+      if (SimplifyDemandedFPClass(I, 1, SrcDemandedMask, KnownRHS, SQ,
+                                  Depth + 1) ||
+          SimplifyDemandedFPClass(I, 0, SrcDemandedMask, KnownLHS, SQ,
+                                  Depth + 1))
+        return I;
+
+      Type *EltTy = VTy->getScalarType();
+      DenormalMode Mode = F.getDenormalMode(EltTy->getFltSemantics());
+
+      Known = I->getOpcode() == Instruction::FAdd
+                  ? KnownFPClass::fadd(KnownLHS, KnownRHS,
+                                       RoundingMode::NearestTiesToEven, Mode)
+                  : KnownFPClass::fsub(KnownLHS, KnownRHS,
+                                       RoundingMode::NearestTiesToEven, Mode);
+    }
+
+    Known.knownNot(~DemandedMask);
+
+    if (Constant *SingleVal = getFPClassConstant(VTy, Known.getKnownFPClasses(),
+                                                 /*IsCanonicalizing=*/true))
+      return SingleVal;
+
+    // Propagate known result to simplify edge case checks.
+    bool ResultNotNan = (DemandedMask & fcNan) == fcNone;
+
+    // With nnan: X + {+/-}Inf --> {+/-}Inf
+    if (ResultNotNan && I->getOpcode() == Instruction::FAdd &&
+        KnownRHS.isKnownAlways(fcInf | fcNan) && KnownLHS.isKnownNever(fcNan))
+      return I->getOperand(1);
+
+    // With nnan: {+/-}Inf + X --> {+/-}Inf
+    // With nnan: {+/-}Inf - X --> {+/-}Inf
+    if (ResultNotNan && KnownLHS.isKnownAlways(fcInf | fcNan) &&
+        KnownRHS.isKnownNever(fcNan))
+      return I->getOperand(0);
+
+    FastMathFlags InferredFMF = inferFastMathValueFlags(
+        FMF, Known.getKnownFPClasses(), {KnownLHS, KnownRHS});
+    if (InferredFMF != FMF) {
+      I->setFastMathFlags(InferredFMF);
+      return I;
+    }
+
+    return nullptr;
+  }
+  case Instruction::FMul: {
+    KnownFPClass KnownLHS, KnownRHS;
+
+    Value *X = I->getOperand(0);
+    Value *Y = I->getOperand(1);
+
+    FPClassTest SrcDemandedMask =
+        DemandedMask & (fcNan | fcZero | fcSubnormal | fcNormal);
+
+    if (DemandedMask & fcInf) {
+      // mul x, inf = inf
+      // mul large_x, large_y = inf
+      SrcDemandedMask |= fcSubnormal | fcNormal | fcInf;
+    }
+
+    if (DemandedMask & fcNan) {
+      // mul +/-inf, 0 => nan
+      SrcDemandedMask |= fcZero | fcInf | fcNan;
+
+      // TODO: Mode check
+      // mul +/-inf, sub => nan if daz
+      SrcDemandedMask |= fcSubnormal;
+    }
+
+    // mul normal, subnormal = normal
+    // Normal inputs may result in underflow.
+    if (DemandedMask & (fcNormal | fcSubnormal))
+      SrcDemandedMask |= fcNormal | fcSubnormal;
+
+    if (DemandedMask & fcZero)
+      SrcDemandedMask |= fcNormal | fcSubnormal;
+
+    if (X == Y &&
+        isGuaranteedNotToBeUndef(X, SQ.AC, SQ.CtxI, SQ.DT, Depth + 1)) {
+      if (SimplifyDemandedFPClass(I, 0, SrcDemandedMask, KnownLHS, SQ,
+                                  Depth + 1))
+        return I;
+      Type *EltTy = VTy->getScalarType();
+
+      DenormalMode Mode = F.getDenormalMode(EltTy->getFltSemantics());
+      Known = KnownFPClass::square(KnownLHS, Mode);
+      Known.knownNot(~DemandedMask);
+
+      if (Constant *Folded = getFPClassConstant(VTy, Known.getKnownFPClasses(),
+                                                /*IsCanonicalizing=*/true))
+        return Folded;
+
+      if (Known.isKnownAlways(fcPosZero | fcPosInf | fcNan) &&
+          KnownLHS.isKnownNever(fcSubnormal | fcNormal)) {
+        // We can skip the fabs if the source was already known positive.
+        if (KnownLHS.isKnownAlways(fcPositive))
+          return X;
+
+        // => fabs(x), in case this was a -inf or -0.
+        // Note: Dropping canonicalize.
+        IRBuilderBase::InsertPointGuard Guard(Builder);
+        Builder.SetInsertPoint(I);
+        Value *Fabs = Builder.CreateFAbs(X, FMF);
+        Fabs->takeName(I);
+        return Fabs;
+      }
+
+      return nullptr;
+    }
+
+    if (SimplifyDemandedFPClass(I, 1, SrcDemandedMask, KnownRHS, SQ,
+                                Depth + 1) ||
+        SimplifyDemandedFPClass(I, 0, SrcDemandedMask, KnownLHS, SQ, Depth + 1))
+      return I;
+
+    if (FMF.noInfs()) {
+      // Flag implies inputs cannot be infinity.
+      KnownLHS.knownNot(fcInf);
+      KnownRHS.knownNot(fcInf);
+    }
+
+    bool NonNanResult = (DemandedMask & fcNan) == fcNone;
+
+    // With no-nans/no-infs:
+    // X * 0.0 --> copysign(0.0, X)
+    // X * -0.0 --> copysign(0.0, -X)
+    if ((NonNanResult || KnownLHS.isKnownNeverInfOrNaN()) &&
+        KnownRHS.isKnownAlways(fcPosZero | fcNan)) {
+      IRBuilderBase::InsertPointGuard Guard(Builder);
+      Builder.SetInsertPoint(I);
+
+      // => copysign(+0, lhs)
+      // Note: Dropping canonicalize
+      Value *Copysign = Builder.CreateCopySign(Y, X, FMF);
+      Copysign->takeName(I);
+      return Copysign;
+    }
+
+    if (KnownLHS.isKnownAlways(fcPosZero | fcNan) &&
+        (NonNanResult || KnownRHS.isKnownNeverInfOrNaN())) {
+      IRBuilderBase::InsertPointGuard Guard(Builder);
+      Builder.SetInsertPoint(I);
+
+      // => copysign(+0, rhs)
+      // Note: Dropping canonicalize
+      Value *Copysign = Builder.CreateCopySign(X, Y, FMF);
+      Copysign->takeName(I);
+      return Copysign;
+    }
+
+    if ((NonNanResult || KnownLHS.isKnownNeverInfOrNaN()) &&
+        KnownRHS.isKnownAlways(fcNegZero | fcNan)) {
+      IRBuilderBase::InsertPointGuard Guard(Builder);
+      Builder.SetInsertPoint(I);
+
+      // => copysign(0, fneg(lhs))
+      // Note: Dropping canonicalize
+      Value *Copysign =
+          Builder.CreateCopySign(Y, Builder.CreateFNegFMF(X, FMF), FMF);
+      Copysign->takeName(I);
+      return Copysign;
+    }
+
+    if (KnownLHS.isKnownAlways(fcNegZero | fcNan) &&
+        (NonNanResult || KnownRHS.isKnownNeverInfOrNaN())) {
+      IRBuilderBase::InsertPointGuard Guard(Builder);
+      Builder.SetInsertPoint(I);
+
+      // => copysign(+0, fneg(rhs))
+      // Note: Dropping canonicalize
+      Value *Copysign =
+          Builder.CreateCopySign(X, Builder.CreateFNegFMF(Y, FMF), FMF);
+      Copysign->takeName(I);
+      return Copysign;
+    }
+
+    Type *EltTy = VTy->getScalarType();
+    DenormalMode Mode = F.getDenormalMode(EltTy->getFltSemantics());
+
+    if (KnownLHS.isKnownAlways(fcInf | fcNan) &&
+        (KnownRHS.isKnownNeverNaN() &&
+         KnownRHS.cannotBeOrderedGreaterEqZero(Mode))) {
+      IRBuilderBase::InsertPointGuard Guard(Builder);
+      Builder.SetInsertPoint(I);
+
+      // Note: Dropping canonicalize
+      Value *Neg = Builder.CreateFNegFMF(X, FMF);
+      Neg->takeName(I);
+      return Neg;
+    }
+
+    if (KnownRHS.isKnownAlways(fcInf | fcNan) &&
+        (KnownLHS.isKnownNeverNaN() &&
+         KnownLHS.cannotBeOrderedGreaterEqZero(Mode))) {
+      IRBuilderBase::InsertPointGuard Guard(Builder);
+      Builder.SetInsertPoint(I);
+
+      // Note: Dropping canonicalize
+      Value *Neg = Builder.CreateFNegFMF(Y, FMF);
+      Neg->takeName(I);
+      return Neg;
+    }
+
+    Known = KnownFPClass::fmul(KnownLHS, KnownRHS, Mode);
+    Known.knownNot(~DemandedMask);
+
+    if (Constant *SingleVal = getFPClassConstant(VTy, Known.getKnownFPClasses(),
+                                                 /*IsCanonicalizing=*/true))
+      return SingleVal;
+
+    FastMathFlags InferredFMF = inferFastMathValueFlags(
+        FMF, Known.getKnownFPClasses(), {KnownLHS, KnownRHS});
+    if (InferredFMF != FMF) {
+      I->setFastMathFlags(InferredFMF);
+      return I;
+    }
+
+    return nullptr;
+  }
+  case Instruction::FDiv: {
+    Value *X = I->getOperand(0);
+    Value *Y = I->getOperand(1);
+    if (X == Y &&
+        isGuaranteedNotToBeUndef(X, SQ.AC, SQ.CtxI, SQ.DT, Depth + 1)) {
+      // If the source is 0, inf or nan, the result is a nan
+      IRBuilderBase::InsertPointGuard Guard(Builder);
+      Builder.SetInsertPoint(I);
+
+      Value *IsZeroOrNan = Builder.CreateFCmpFMF(
+          FCmpInst::FCMP_UEQ, I->getOperand(0), ConstantFP::getZero(VTy), FMF);
+
+      Value *Fabs = Builder.CreateFAbs(I->getOperand(0), FMF);
+      Value *IsInfOrNan = Builder.CreateFCmpFMF(
+          FCmpInst::FCMP_UEQ, Fabs, ConstantFP::getInfinity(VTy), FMF);
+
+      Value *IsInfOrZeroOrNan = Builder.CreateOr(IsInfOrNan, IsZeroOrNan);
+
+      return Builder.CreateSelectFMFWithUnknownProfile(
+          IsInfOrZeroOrNan, ConstantFP::getQNaN(VTy),
+          ConstantFP::get(
+              VTy, APFloat::getOne(VTy->getScalarType()->getFltSemantics())),
+          FMF, DEBUG_TYPE);
+    }
+
+    Type *EltTy = VTy->getScalarType();
+    DenormalMode Mode = F.getDenormalMode(EltTy->getFltSemantics());
+
+    // Every output class could require denormal inputs (except for the
+    // degenerate case of only-nan results, without DAZ).
+    FPClassTest SrcDemandedMask = (DemandedMask & fcNan) | fcSubnormal;
+
+    // Normal inputs may result in underflow.
+    // x / x = 1.0 for non0/inf/nan
+    // -x = +y / -z
+    // -x = -y / +z
+    if (DemandedMask & (fcSubnormal | fcNormal))
+      SrcDemandedMask |= fcNormal;
+
+    if (DemandedMask & fcNan) {
+      // 0 / 0 = nan
+      // inf / inf = nan
+
+      // Subnormal is added in case of DAZ, but this isn't strictly
+      // necessary. Every other input class implies a possible subnormal source,
+      // so this only could matter in the degenerate case of only-nan results.
+      SrcDemandedMask |= fcZero | fcInf | fcNan;
+    }
+
+    // Zero outputs may be the result of underflow.
+    if (DemandedMask & fcZero)
+      SrcDemandedMask |= fcNormal | fcSubnormal;
+
+    FPClassTest LHSDemandedMask = SrcDemandedMask;
+    FPClassTest RHSDemandedMask = SrcDemandedMask;
+
+    // 0 / inf = 0
+    if (DemandedMask & fcZero) {
+      assert((LHSDemandedMask & fcSubnormal) &&
+             "should not have to worry about daz here");
+      LHSDemandedMask |= fcZero;
+      RHSDemandedMask |= fcInf;
+    }
+
+    // x / 0 = inf
+    // large_normal / small_normal = inf
+    // inf / 1 = inf
+    // large_normal / subnormal = inf
+    if (DemandedMask & fcInf) {
+      LHSDemandedMask |= fcInf | fcNormal | fcSubnormal;
+      RHSDemandedMask |= fcZero | fcSubnormal | fcNormal;
+    }
+
+    KnownFPClass KnownLHS, KnownRHS;
+    if (SimplifyDemandedFPClass(I, 0, LHSDemandedMask, KnownLHS, SQ,
+                                Depth + 1) ||
+        SimplifyDemandedFPClass(I, 1, RHSDemandedMask, KnownRHS, SQ, Depth + 1))
+      return I;
+
+    bool ResultNotNan = (DemandedMask & fcNan) == fcNone;
+    bool ResultNotInf = (DemandedMask & fcInf) == fcNone;
+
+    // Replacing 0/x with a zero is only valid when the divisor can't be
+    // (logical) zero, since 0/0 is NaN -- unless NaN results aren't demanded. A
+    // subnormal divisor can flush to zero under a flushing denormal mode.
+    bool CanIgnoreZeroByZeroNan =
+        ResultNotNan || KnownRHS.isKnownNeverLogicalZero(Mode);
+
+    // nsz [+-]0 / x -> 0
+    if (FMF.noSignedZeros() && KnownLHS.isKnownAlways(fcZero) &&
+        KnownRHS.isKnownNeverNaN() && CanIgnoreZeroByZeroNan)
+      return ConstantFP::getZero(VTy);
+
+    if (KnownLHS.isKnownAlways(fcPosZero) && KnownRHS.isKnownNeverNaN() &&
+        CanIgnoreZeroByZeroNan) {
+      IRBuilderBase::InsertPointGuard Guard(Builder);
+      Builder.SetInsertPoint(I);
+
+      // nnan +0 / x -> copysign(0, rhs)
+      // TODO: -0 / x => copysign(0, fneg(rhs))
+      Value *Copysign = Builder.CreateCopySign(X, Y, FMF);
+      Copysign->takeName(I);
+      return Copysign;
+    }
+
+    if (!ResultNotInf &&
+        ((ResultNotNan || (KnownLHS.isKnownNeverNaN() &&
+                           KnownLHS.isKnownNeverLogicalZero(Mode))) &&
+         (KnownRHS.isKnownAlways(fcPosZero) ||
+          (FMF.noSignedZeros() && KnownRHS.isKnownAlways(fcZero))))) {
+      IRBuilderBase::InsertPointGuard Guard(Builder);
+      Builder.SetInsertPoint(I);
+
+      // nnan x / 0 => copysign(inf, x);
+      // nnan nsz x / -0 => copysign(inf, x);
+      Value *Copysign =
+          Builder.CreateCopySign(ConstantFP::getInfinity(VTy), X, FMF);
+      Copysign->takeName(I);
+      return Copysign;
+    }
+
+    // nnan ninf X / [-]0.0 -> poison
+    if (ResultNotNan && ResultNotInf && KnownRHS.isKnownAlways(fcZero))
+      return PoisonValue::get(VTy);
+
+    Known = KnownFPClass::fdiv(KnownLHS, KnownRHS, Mode);
+    Known.knownNot(~DemandedMask);
+
+    if (Constant *SingleVal = getFPClassConstant(VTy, Known.getKnownFPClasses(),
+                                                 /*IsCanonicalizing=*/true))
+      return SingleVal;
+
+    FastMathFlags InferredFMF = inferFastMathValueFlags(
+        FMF, Known.getKnownFPClasses(), {KnownLHS, KnownRHS});
+    if (InferredFMF != FMF) {
+      I->setFastMathFlags(InferredFMF);
+      return I;
+    }
+
+    return nullptr;
+  }
+  case Instruction::FPTrunc:
+    return simplifyDemandedUseFPClassFPTrunc(*this, *I, FMF, DemandedMask,
+                                             Known, SQ, Depth);
+  case Instruction::FPExt: {
+    const fltSemantics &DstTy = VTy->getScalarType()->getFltSemantics();
+    const fltSemantics &SrcTy =
+        I->getOperand(0)->getType()->getScalarType()->getFltSemantics();
+
+    const DenormalMode DstMode = F.getDenormalMode(DstTy);
+    const DenormalMode SrcMode = F.getDenormalMode(SrcTy);
+
+    FPClassTest SrcDemandedMask = DemandedMask;
+    if (DemandedMask & fcNan)
+      SrcDemandedMask |= fcNan;
+
+    // No subnormal result does not imply not-subnormal in the source type.
+    if ((DemandedMask & fcNegNormal) != fcNone)
+      SrcDemandedMask |= fcNegSubnormal;
+    if ((DemandedMask & fcPosNormal) != fcNone)
+      SrcDemandedMask |= fcPosSubnormal;
+
+    // TODO: This is a conservative approach for determining the actual input
+    // and output denormal mode used by fpext.
+    if (DstMode != DenormalMode::getIEEE() ||
+        SrcMode != DenormalMode::getIEEE()) {
+      // We are assuming that normal values will never produce subnormal results
+      // for fpext. This assumption is incorrect for ppcf128 = fpext(f80).
+      if ((DemandedMask & fcZero) != fcNone)
+        SrcDemandedMask |= fcSubnormal;
+    }
+
+    // TODO: Properly handle ppcf128 = fpext(f80) (since f80 has a larger
+    // exponent range than ppcf128).
+
+    KnownFPClass KnownSrc;
+    if (SimplifyDemandedFPClass(I, 0, SrcDemandedMask, KnownSrc, SQ, Depth + 1))
+      return I;
+
+    Known = KnownFPClass::fpext(KnownSrc, DstTy, SrcTy, DstMode, SrcMode);
+    Known.knownNot(~DemandedMask);
+
+    return simplifyDemandedFPClassResult(I, FMF, DemandedMask, Known,
+                                         {KnownSrc});
+  }
+  case Instruction::Call: {
+    CallInst *CI = cast<CallInst>(I);
+    const Intrinsic::ID IID = CI->getIntrinsicID();
+    switch (IID) {
+    case Intrinsic::fabs: {
+      KnownFPClass KnownSrc;
+      if (SimplifyDemandedFPClass(I, 0, llvm::inverse_fabs(DemandedMask),
+                                  KnownSrc, SQ, Depth + 1))
+        return I;
+
+      if (Value *Simplified = simplifyDemandedFPClassFabs(
+              Known, CI->getArgOperand(0), DemandedMask, KnownSrc,
+              FMF.noSignedZeros()))
+        return Simplified;
+      break;
+    }
+    case Intrinsic::arithmetic_fence:
+      if (SimplifyDemandedFPClass(I, 0, DemandedMask, Known, SQ, Depth + 1))
+        return I;
+      break;
+    case Intrinsic::copysign: {
+      // Flip on more potentially demanded classes
+      const FPClassTest DemandedMaskAnySign = llvm::unknown_sign(DemandedMask);
+      KnownFPClass KnownMag;
+      if (SimplifyDemandedFPClass(CI, 0, DemandedMaskAnySign, KnownMag, SQ,
+                                  Depth + 1))
+        return I;
+
+      if ((DemandedMask & fcNegative) == DemandedMask &&
+          CI->getArgOperand(1) != ConstantFP::get(VTy, -1.0)) {
+        // Roundabout way of replacing with fneg(fabs)
+        CI->setOperand(1, ConstantFP::get(VTy, -1.0));
+        return I;
+      }
+
+      if ((DemandedMask & fcPositive) == DemandedMask &&
+          CI->getArgOperand(1) != ConstantFP::getZero(VTy)) {
+        // Roundabout way of replacing with fabs
+        CI->setOperand(1, ConstantFP::getZero(VTy));
+        return I;
+      }
+
+      if (Value *Simplified = simplifyDemandedFPClassCopysignMag(
+              CI->getArgOperand(0), DemandedMask, KnownMag,
+              FMF.noSignedZeros()))
+        return Simplified;
+
+      KnownFPClass KnownSign =
+          computeKnownFPClass(CI->getArgOperand(1), fcAllFlags, SQ, Depth + 1);
+      if (KnownMag.getSignBit() && KnownSign.getSignBit() &&
+          *KnownMag.getSignBit() == *KnownSign.getSignBit())
+        return CI->getOperand(0);
+
+      // TODO: Call argument attribute not considered
+      // Input implied not-nan from flag.
+      if (FMF.noNaNs())
+        KnownSign.knownNot(fcNan);
+
+      if (KnownSign.getSignBit() == false &&
+          CI->getArgOperand(1) != ConstantFP::getZero(VTy)) {
+        CI->dropUBImplyingAttrsAndMetadata();
+        CI->setOperand(1, ConstantFP::getZero(VTy));
+        return I;
+      }
+
+      if (KnownSign.getSignBit() == true &&
+          CI->getArgOperand(1) != ConstantFP::get(VTy, -1.0)) {
+        CI->dropUBImplyingAttrsAndMetadata();
+        CI->setOperand(1, ConstantFP::get(VTy, -1.0));
+        return I;
+      }
+
+      Known = KnownFPClass::copysign(KnownMag, KnownSign);
+      Known.knownNot(~DemandedMask);
+      break;
+    }
+    case Intrinsic::fma:
+    case Intrinsic::fmuladd: {
+      // Keep in mind that fma can rule out NaN in places that fmuladd cannot.
+
+      // We can't do any simplification on the source besides stripping out
+      // unneeded nans.
+      FPClassTest SrcDemandedMask = DemandedMask | ~fcNan;
+      if (DemandedMask & fcNan)
+        SrcDemandedMask |= fcNan;
+
+      KnownFPClass KnownSrc[3];
+
+      const bool IsFMA = IID == Intrinsic::fma;
+
+      Type *EltTy = VTy->getScalarType();
+      if (CI->getArgOperand(0) == CI->getArgOperand(1) &&
+          isGuaranteedNotToBeUndef(CI->getArgOperand(0), SQ.AC, SQ.CtxI, SQ.DT,
+                                   Depth + 1)) {
+        if (SimplifyDemandedFPClass(CI, 0, SrcDemandedMask, KnownSrc[0], SQ,
+                                    Depth + 1) ||
+            SimplifyDemandedFPClass(CI, 2, SrcDemandedMask, KnownSrc[2], SQ,
+                                    Depth + 1))
+          return I;
+
+        KnownSrc[1] = KnownSrc[0];
+        DenormalMode Mode = F.getDenormalMode(EltTy->getFltSemantics());
+        Known = IsFMA ? KnownFPClass::fma_square(KnownSrc[0], KnownSrc[2], Mode)
+                      : KnownFPClass::fmuladd_square(KnownSrc[0], KnownSrc[2],
+                                                     Mode);
+      } else {
+        for (int OpIdx = 0; OpIdx != 3; ++OpIdx) {
+          if (SimplifyDemandedFPClass(CI, OpIdx, SrcDemandedMask,
+                                      KnownSrc[OpIdx], SQ, Depth + 1))
+            return CI;
+        }
+
+        DenormalMode Mode = F.getDenormalMode(EltTy->getFltSemantics());
+        Known = IsFMA ? KnownFPClass::fma(KnownSrc[0], KnownSrc[1], KnownSrc[2],
+                                          Mode)
+                      : KnownFPClass::fmuladd(KnownSrc[0], KnownSrc[1],
+                                              KnownSrc[2], Mode);
+      }
+
+      return simplifyDemandedFPClassResult(CI, FMF, DemandedMask, Known,
+                                           {KnownSrc});
+    }
+    case Intrinsic::maximum:
+    case Intrinsic::minimum:
+    case Intrinsic::maximumnum:
+    case Intrinsic::minimumnum:
+    case Intrinsic::maxnum:
+    case Intrinsic::minnum: {
+      const bool PropagateNaN =
+          IID == Intrinsic::maximum || IID == Intrinsic::minimum;
+
+      // We can't tell much based on the demanded result without inspecting the
+      // operands (e.g., a known-positive result could have been clamped), but
+      // we can still prune known-nan inputs.
+      FPClassTest SrcDemandedMask =
+          PropagateNaN && ((DemandedMask & fcNan) == fcNone)
+              ? DemandedMask | ~fcNan
+              : fcAllFlags;
+
+      KnownFPClass KnownLHS, KnownRHS;
+      if (SimplifyDemandedFPClass(CI, 1, SrcDemandedMask, KnownRHS, SQ,
+                                  Depth + 1) ||
+          SimplifyDemandedFPClass(CI, 0, SrcDemandedMask, KnownLHS, SQ,
+                                  Depth + 1))
+        return I;
+
+      Value *Simplified =
+          simplifyDemandedFPClassMinMax(Known, IID, CI, DemandedMask, KnownLHS,
+                                        KnownRHS, F, FMF.noSignedZeros());
+      if (Simplified)
+        return Simplified;
+
+      auto *FPOp = cast<FPMathOperator>(CI);
+
+      FPClassTest ValidResults = DemandedMask & Known.getKnownFPClasses();
+      FastMathFlags InferredFMF = FMF;
+
+      if (!FMF.noSignedZeros()) {
+        // Add NSZ flag if we know the result will not be sensitive to the sign
+        // of 0.
+        FPClassTest ZeroMask = fcZero;
+
+        Type *EltTy = VTy->getScalarType();
+        DenormalMode Mode = F.getDenormalMode(EltTy->getFltSemantics());
+        if (Mode != DenormalMode::getIEEE())
+          ZeroMask |= fcSubnormal;
+
+        bool ResultNotLogical0 = (ValidResults & ZeroMask) == fcNone;
+        if (ResultNotLogical0 || ((KnownLHS.isKnownNeverLogicalNegZero(Mode) ||
+                                   KnownRHS.isKnownNeverLogicalPosZero(Mode)) &&
+                                  (KnownLHS.isKnownNeverLogicalPosZero(Mode) ||
+                                   KnownRHS.isKnownNeverLogicalNegZero(Mode))))
+          InferredFMF.setNoSignedZeros(true);
+      }
+
+      if (!FMF.noNaNs() &&
+          ((PropagateNaN && (ValidResults & fcNan) == fcNone) ||
+           (KnownLHS.isKnownNeverNaN() && KnownRHS.isKnownNeverNaN()))) {
+        CI->dropUBImplyingAttrsAndMetadata();
+        InferredFMF.setNoNaNs(true);
+      }
+
+      if (InferredFMF != FMF) {
+        CI->setFastMathFlags(InferredFMF);
+        return FPOp;
+      }
+
+      return nullptr;
+    }
+    case Intrinsic::exp:
+    case Intrinsic::exp2:
+    case Intrinsic::exp10: {
+      if ((DemandedMask & fcPositive) == fcNone) {
+        // Only returns positive values or nans.
+        if ((DemandedMask & fcNan) == fcNone)
+          return PoisonValue::get(VTy);
+
+        // Only need nan propagation.
+        if ((DemandedMask & ~fcNan) == fcNone)
+          return ConstantFP::getQNaN(VTy);
+
+        return CI->getArgOperand(0);
+      }
+
+      FPClassTest SrcDemandedMask = DemandedMask & fcNan;
+      if (DemandedMask & fcNan)
+        SrcDemandedMask |= fcNan;
+
+      if (DemandedMask & fcZero) {
+        // exp(-infinity) = 0
+        SrcDemandedMask |= fcNegInf;
+
+        // exp(-largest_normal) = 0
+        //
+        // Negative numbers of sufficiently large magnitude underflow to 0. No
+        // subnormal input has a 0 result.
+        SrcDemandedMask |= fcNegNormal;
+      }
+
+      if (DemandedMask & fcPosSubnormal) {
+        // Negative numbers of sufficiently large magnitude underflow to 0. No
+        // subnormal input has a 0 result.
+        SrcDemandedMask |= fcNegNormal;
+      }
+
+      if (DemandedMask & fcPosNormal) {
+        // exp(0) = 1
+        // exp(+/- smallest_normal) = 1
+        // exp(+/- largest_denormal) = 1
+        // exp(+/- smallest_denormal) = 1
+        // exp(-1) = pos normal
+        SrcDemandedMask |= fcNormal | fcSubnormal | fcZero;
+      }
+
+      // exp(inf), exp(largest_normal) = inf
+      if (DemandedMask & fcPosInf)
+        SrcDemandedMask |= fcPosInf | fcPosNormal;
+
+      KnownFPClass KnownSrc;
+
+      // TODO: This could really make use of KnownFPClass of specific value
+      // range, (i.e., close enough to 1)
+      if (SimplifyDemandedFPClass(I, 0, SrcDemandedMask, KnownSrc, SQ,
+                                  Depth + 1))
+        return I;
+
+      // exp(+/-0 | subnormal) = 1
+      if (KnownSrc.isKnownAlways(fcZero | fcSubnormal))
+        return ConstantFP::get(VTy, 1.0);
+
+      // Only perform nan propagation.
+      // Note: Dropping canonicalize / quiet of signaling nan.
+      if (KnownSrc.isKnownAlways(fcNan))
+        return CI->getArgOperand(0);
+
+      // exp(0 | subnormal | +inf | nan) => x + 1.0
+      if (KnownSrc.isKnownAlways(fcZero | fcSubnormal | fcPosInf | fcNan)) {
+        IRBuilderBase::InsertPointGuard Guard(Builder);
+        Builder.SetInsertPoint(CI);
+
+        // fadd +/-0, 1.0 => 1.0
+        // fadd subnormal, 1.0 => 1.0
+        // fadd +inf, 1.0 => +inf
+        // fadd nan, 1.0 => nan
+        return Builder.CreateFAddFMF(CI->getArgOperand(0),
+                                     ConstantFP::get(VTy, 1.0), FMF);
+      }
+
+      if (KnownSrc.isKnownAlways(fcInf | fcNan)) {
+        // exp(-inf) = 0
+        // exp(+inf) = +inf
+        IRBuilderBase::InsertPointGuard Guard(Builder);
+        Builder.SetInsertPoint(CI);
+
+        // Note: Dropping canonicalize / quiet of signaling nan.
+        Value *X = CI->getArgOperand(0);
+        Value *IsPosInfOrNan = Builder.CreateFCmpFMF(
+            FCmpInst::FCMP_UEQ, X, ConstantFP::getInfinity(VTy), FMF);
+        // We do not know whether an infinity or a NaN is more likely here,
+        // so mark the branch weights as unkown.
+        Value *ZeroOrInf = Builder.CreateSelectFMFWithUnknownProfile(
+            IsPosInfOrNan, X, ConstantFP::getZero(VTy), FMF, DEBUG_TYPE);
+        return ZeroOrInf;
+      }
+
+      Known = KnownFPClass::exp(KnownSrc);
+      Known.knownNot(~DemandedMask);
+
+      return simplifyDemandedFPClassResult(CI, FMF, DemandedMask, Known,
+                                           KnownSrc);
+    }
+    case Intrinsic::log:
+    case Intrinsic::log2:
+    case Intrinsic::log10: {
+      Type *EltTy = VTy->getScalarType();
+      bool IsMultiUnitFPType = EltTy->isMultiUnitFPType();
+
+      FPClassTest DemandedSrcMask = DemandedMask & (fcNan | fcPosInf);
+      if (DemandedMask & fcNan)
+        DemandedSrcMask |= fcNan;
+
+      DenormalMode Mode = F.getDenormalMode(EltTy->getFltSemantics());
+
+      // log(x) can be negative zero or subnormal if x is close to +1.0 for the
+      // PPCDoubleDouble type.
+      if (IsMultiUnitFPType && (DemandedMask & (fcNegZero | fcSubnormal))) {
+        DemandedSrcMask |= fcPosNormal;
+        // Note that DoubleAPFloat::isDenormal considers 1.0 + DBL_TRUE_MIN to
+        // be denormal, which APFloat::classify treats as fcSubnormal.
+        DemandedSrcMask |= fcPosSubnormal;
+      }
+
+      // log(x < 0) = nan
+      if (DemandedMask & fcNan)
+        DemandedSrcMask |= (fcNegative & ~fcNegZero);
+
+      // log(0) = -inf
+      if (DemandedMask & fcNegInf) {
+        DemandedSrcMask |= fcZero;
+
+        // Subnormals may be treated as logical zero.
+        if (Mode.inputsMayBeZero())
+          DemandedSrcMask |= fcSubnormal;
+      }
+
+      if (DemandedMask & fcNormal)
+        DemandedSrcMask |= fcNormal | fcSubnormal;
+
+      // log(1) = 0
+      if (DemandedMask & fcZero)
+        DemandedSrcMask |= fcPosNormal;
+
+      KnownFPClass KnownSrc;
+      if (SimplifyDemandedFPClass(I, 0, DemandedSrcMask, KnownSrc, SQ,
+                                  Depth + 1))
+        return I;
+
+      Known = KnownFPClass::log(KnownSrc, Mode, IsMultiUnitFPType);
+      Known.knownNot(~DemandedMask);
+
+      return simplifyDemandedFPClassResult(CI, FMF, DemandedMask, Known,
+                                           KnownSrc);
+    }
+    case Intrinsic::sqrt: {
+      Type *EltTy = VTy->getScalarType();
+      DenormalMode Mode = F.getDenormalMode(EltTy->getFltSemantics());
+
+      // Be explicit about the DemandedSrcMask so we do not miss anything.
+      FPClassTest DemandedSrcMask = fcNone;
+      if (DemandedMask & fcSNan)
+        DemandedSrcMask |= fcSNan;
+      if (DemandedMask & fcQNan)
+        DemandedSrcMask |=
+            fcQNan | fcSNan | fcNegInf | fcNegNormal | fcNegSubnormal;
+      if (DemandedMask & fcNegZero) {
+        DemandedSrcMask |= fcNegZero;
+        if (Mode.Input == DenormalMode::PreserveSign ||
+            Mode.Input == DenormalMode::Dynamic)
+          DemandedSrcMask |= fcNegSubnormal;
+      }
+      if (DemandedMask & fcPosZero) {
+        DemandedSrcMask |= fcPosZero;
+        if (Mode.inputsMayBeZero())
+          DemandedSrcMask |= fcPosSubnormal;
+        if (Mode.inputsMayBePositiveZero())
+          DemandedSrcMask |= fcNegSubnormal;
+      }
+      if (DemandedMask & fcPosNormal)
+        DemandedSrcMask |= fcPosSubnormal | fcPosNormal;
+      if (DemandedMask & fcPosInf)
+        DemandedSrcMask |= fcPosInf;
+
+      KnownFPClass KnownSrc;
+      if (SimplifyDemandedFPClass(I, 0, DemandedSrcMask, KnownSrc, SQ,
+                                  Depth + 1))
+        return I;
+
+      KnownSrc.knownNot(~DemandedSrcMask);
+
+      // sqrt(-x) = nan, but be careful of negative subnormals flushed to 0.
+      // TODO: This becomes redundant if KnownFPClass::sqrt rules out
+      // fcPosNormal.
+      if (KnownSrc.isKnownNever(fcPositive) &&
+          KnownSrc.isKnownNeverLogicalZero(Mode))
+        return ConstantFP::getQNaN(VTy);
+
+      Known = KnownFPClass::sqrt(KnownSrc, Mode);
+      Known.knownNot(~DemandedMask);
+
+      if (Known.getKnownFPClasses() == fcZero) {
+        if (FMF.noSignedZeros())
+          return ConstantFP::getZero(VTy);
+        IRBuilderBase::InsertPointGuard Guard(Builder);
+        Builder.SetInsertPoint(CI);
+
+        Value *Copysign = Builder.CreateCopySign(ConstantFP::getZero(VTy),
+                                                 CI->getArgOperand(0), FMF);
+        Copysign->takeName(CI);
+        return Copysign;
+      }
+
+      // TODO: fold sqrt(x) -> x when x is nan | pinf | zero
+
+      return simplifyDemandedFPClassResult(CI, FMF, DemandedMask, Known,
+                                           {KnownSrc});
+    }
+    case Intrinsic::ldexp: {
+      Type *EltTy = VTy->getScalarType();
+      const fltSemantics &FltSem = EltTy->getFltSemantics();
+      DenormalMode Mode = F.getDenormalMode(FltSem);
+
+      FPClassTest SrcDemandedMask = fcNone;
+      if (DemandedMask & fcNan)
+        SrcDemandedMask |= fcNan;
+
+      if (DemandedMask & fcPosInf)
+        SrcDemandedMask |= fcPosInf | fcPosNormal | fcPosSubnormal;
+      if (DemandedMask & fcNegInf)
+        SrcDemandedMask |= fcNegInf | fcNegNormal | fcNegSubnormal;
+
+      if (DemandedMask & (fcPosNormal | fcPosSubnormal))
+        SrcDemandedMask |= fcPosNormal | fcPosSubnormal;
+      if (DemandedMask & (fcNegNormal | fcNegSubnormal))
+        SrcDemandedMask |= fcNegNormal | fcNegSubnormal;
+
+      // Note: If we refine based on KnownExpBits in the future, then this
+      // denormal handling code will need to be updated.
+      if (DemandedMask & fcPosZero) {
+        SrcDemandedMask |= fcPosFinite;
+        if (Mode.inputsMayBePositiveZero())
+          SrcDemandedMask |= fcNegSubnormal;
+        if (Mode.outputsMayBePositiveZero())
+          SrcDemandedMask |= fcNegNormal | fcNegSubnormal;
+      }
+      if (DemandedMask & fcNegZero)
+        SrcDemandedMask |= fcNegFinite;
+
+      KnownFPClass KnownSrc;
+      if (SimplifyDemandedFPClass(CI, 0, SrcDemandedMask, KnownSrc, SQ,
+                                  Depth + 1))
+        return CI;
+
+      KnownBits KnownExpBits =
+          ::computeKnownBits(CI->getArgOperand(1), SQ, Depth + 1);
+
+      Known = KnownFPClass::ldexp(KnownSrc, KnownExpBits, FltSem, Mode);
+      Known.knownNot(~DemandedMask);
+
+      return simplifyDemandedFPClassResult(CI, FMF, DemandedMask, Known,
+                                           {KnownSrc});
+    }
+    case Intrinsic::trunc:
+    case Intrinsic::floor:
+    case Intrinsic::ceil:
+    case Intrinsic::rint:
+    case Intrinsic::nearbyint:
+    case Intrinsic::round:
+    case Intrinsic::roundeven: {
+      Type *EltTy = VTy->getScalarType();
+      DenormalMode Mode = F.getDenormalMode(EltTy->getFltSemantics());
+
+      FPClassTest DemandedSrcMask = DemandedMask;
+      if (DemandedMask & fcNan)
+        DemandedSrcMask |= fcNan;
+
+      const bool IsMultiUnitFPType = EltTy->isMultiUnitFPType();
+      // Rounding a finite multi-unit value may overflow to an infinity.
+      if (IsMultiUnitFPType) {
+        if (IID != Intrinsic::trunc && IID != Intrinsic::floor &&
+            (DemandedMask & fcPosInf))
+          DemandedSrcMask |= fcPosNormal;
+        if (IID != Intrinsic::trunc && IID != Intrinsic::ceil &&
+            (DemandedMask & fcNegInf))
+          DemandedSrcMask |= fcNegNormal;
+      }
+
+      // Zero results imply valid subnormal sources.
+      if (DemandedMask & fcNegZero)
+        DemandedSrcMask |= fcNegSubnormal | fcNegNormal;
+
+      if (DemandedMask & fcPosZero) {
+        DemandedSrcMask |= fcPosSubnormal | fcPosNormal;
+        if (Mode.inputsMayBePositiveZero())
+          DemandedSrcMask |= fcNegSubnormal;
+      }
+
+      // Rounding a subnormal away from zero may produce a normal value.
+      if (DemandedMask & fcNegNormal)
+        DemandedSrcMask |= fcNegSubnormal;
+      if (DemandedMask & fcPosNormal)
+        DemandedSrcMask |= fcPosSubnormal;
+
+      KnownFPClass KnownSrc;
+      if (SimplifyDemandedFPClass(CI, 0, DemandedSrcMask, KnownSrc, SQ,
+                                  Depth + 1))
+        return I;
+
+      // Note: Possibly dropping snan quiet.
+      if (KnownSrc.isKnownAlways(fcInf | fcNan | fcZero))
+        return CI->getArgOperand(0);
+
+      bool IsRoundNearestOrTrunc =
+          IID == Intrinsic::round || IID == Intrinsic::roundeven ||
+          IID == Intrinsic::nearbyint || IID == Intrinsic::rint ||
+          IID == Intrinsic::trunc;
+
+      if ((IID == Intrinsic::floor || IsRoundNearestOrTrunc) &&
+          KnownSrc.isKnownAlways(fcPosZero | fcPosSubnormal))
+        return ConstantFP::getZero(VTy);
+
+      if ((IID == Intrinsic::ceil || IsRoundNearestOrTrunc) &&
+          KnownSrc.isKnownAlways(fcNegZero | fcNegSubnormal) &&
+          !Mode.inputsMayBePositiveZero())
+        return ConstantFP::getZero(VTy, true);
+
+      if (IID == Intrinsic::floor && KnownSrc.isKnownAlways(fcNegSubnormal) &&
+          !Mode.inputsMayBeZero())
+        return ConstantFP::get(VTy, -1.0);
+
+      if (IID == Intrinsic::ceil && KnownSrc.isKnownAlways(fcPosSubnormal) &&
+          !Mode.inputsMayBeZero())
+        return ConstantFP::get(VTy, 1.0);
+
+      switch (IID) {
+      case Intrinsic::trunc:
+        Known = KnownFPClass::trunc(KnownSrc, Mode);
+        break;
+      case Intrinsic::floor:
+        Known = KnownFPClass::floor(KnownSrc, IsMultiUnitFPType, Mode);
+        break;
+      case Intrinsic::ceil:
+        Known = KnownFPClass::ceil(KnownSrc, IsMultiUnitFPType, Mode);
+        break;
+      default:
+        Known =
+            KnownFPClass::roundToIntegral(KnownSrc, IsMultiUnitFPType, Mode);
+        break;
+      }
+
+      Known.knownNot(~DemandedMask);
+
+      if (Constant *SingleVal =
+              getFPClassConstant(VTy, Known.getKnownFPClasses(),
+                                 /*IsCanonicalizing=*/true))
+        return SingleVal;
+
+      if ((IID == Intrinsic::trunc || IsRoundNearestOrTrunc) &&
+          KnownSrc.isKnownAlways(fcZero | fcSubnormal) &&
+          (!Mode.inputsMayBePositiveZero() ||
+           KnownSrc.isKnownNever(fcNegSubnormal))) {
+        IRBuilderBase::InsertPointGuard Guard(Builder);
+        Builder.SetInsertPoint(CI);
+
+        Value *Copysign = Builder.CreateCopySign(ConstantFP::getZero(VTy),
+                                                 CI->getArgOperand(0));
+        Copysign->takeName(CI);
+        return Copysign;
+      }
+
+      FastMathFlags InferredFMF =
+          inferFastMathValueFlags(FMF, Known.getKnownFPClasses(), KnownSrc);
+      if (InferredFMF != FMF) {
+        CI->dropUBImplyingAttrsAndMetadata();
+        CI->setFastMathFlags(InferredFMF);
+        return CI;
+      }
+
+      return nullptr;
+    }
+    case Intrinsic::fptrunc_round:
+      return simplifyDemandedUseFPClassFPTrunc(*this, *CI, FMF, DemandedMask,
+                                               Known, SQ, Depth);
+    case Intrinsic::canonicalize: {
+      Type *EltTy = VTy->getScalarType();
+
+      if (EltTy->isIEEELikeFPTy()) {
+        const fltSemantics &Flt = EltTy->getFltSemantics();
+        DenormalMode Mode = F.getDenormalMode(Flt);
+
+        FPClassTest SrcDemandedMask = DemandedMask;
+
+        // A demanded quiet nan result may have come from a signaling nan, so we
+        // need to expand the demanded mask.
+        if ((DemandedMask & fcQNan) != fcNone)
+          SrcDemandedMask |= fcSNan;
+
+        if (Mode != DenormalMode::getIEEE()) {
+          // Any zero results may have come from flushed denormals.
+          if (DemandedMask & fcPosZero) {
+            SrcDemandedMask |= fcPosSubnormal;
+            if (Mode.inputsMayBePositiveZero() ||
+                Mode.outputsMayBePositiveZero())
+              SrcDemandedMask |= fcNegSubnormal;
+          }
+          if (DemandedMask & fcNegZero)
+            SrcDemandedMask |= fcNegSubnormal;
+        }
+
+        if (Mode == DenormalMode::getPreserveSign()) {
+          // If a denormal input will be flushed, and we don't need zeros, we
+          // don't need denormals either.
+          if ((DemandedMask & fcPosZero) == fcNone)
+            SrcDemandedMask &= ~fcPosSubnormal;
+
+          if ((DemandedMask & fcNegZero) == fcNone)
+            SrcDemandedMask &= ~fcNegSubnormal;
+        }
+
+        KnownFPClass KnownSrc;
+
+        // Simplify upstream operations before trying to simplify this call.
+        if (SimplifyDemandedFPClass(I, 0, SrcDemandedMask, KnownSrc, SQ,
+                                    Depth + 1))
+          return I;
+
+        // Perform the canonicalization to see if this folded to a constant.
+        Known = KnownFPClass::canonicalize(KnownSrc, Flt, Mode);
+        Known.knownNot(~DemandedMask);
+
+        if (Constant *SingleVal =
+                getFPClassConstant(VTy, Known.getKnownFPClasses()))
+          return SingleVal;
+
+        // For IEEE handling, there is only a bit change for nan inputs, so we
+        // can drop it if we do not demand nan results or we know the input
+        // isn't a nan.
+        // Otherwise, we also need to avoid denormal inputs to drop the
+        // canonicalize.
+        if (KnownSrc.isKnownNeverNaN() && (Mode == DenormalMode::getIEEE() ||
+                                           KnownSrc.isKnownNeverSubnormal()))
+          return CI->getArgOperand(0);
+
+        FastMathFlags InferredFMF =
+            inferFastMathValueFlags(FMF, Known.getKnownFPClasses(), KnownSrc);
+        if (InferredFMF != FMF) {
+          CI->dropUBImplyingAttrsAndMetadata();
+          CI->setFastMathFlags(InferredFMF);
+          return CI;
+        }
+
+        return nullptr;
+      }
+
+      [[fallthrough]];
+    }
+    default:
+      Known = computeKnownFPClass(I, DemandedMask, SQ, Depth + 1);
+      Known.knownNot(~DemandedMask);
+      break;
+    }
+
+    break;
+  }
+  case Instruction::Select: {
+    KnownFPClass KnownLHS, KnownRHS;
+    if (SimplifyDemandedFPClass(I, 2, DemandedMask, KnownRHS, SQ, Depth + 1) ||
+        SimplifyDemandedFPClass(I, 1, DemandedMask, KnownLHS, SQ, Depth + 1))
+      return I;
+
+    if (KnownLHS.isKnownNever(DemandedMask))
+      return I->getOperand(2);
+    if (KnownRHS.isKnownNever(DemandedMask))
+      return I->getOperand(1);
+
+    adjustKnownFPClassForSelectArm(KnownLHS, I->getOperand(0), I->getOperand(1),
+                                   /*Invert=*/false, SQ, Depth);
+    adjustKnownFPClassForSelectArm(KnownRHS, I->getOperand(0), I->getOperand(2),
+                                   /*Invert=*/true, SQ, Depth);
+    Known = KnownLHS.intersectWith(KnownRHS);
+    Known.knownNot(~DemandedMask);
+    break;
+  }
+  case Instruction::ExtractElement: {
+    // TODO: Handle demanded element mask
+    if (SimplifyDemandedFPClass(I, 0, DemandedMask, Known, SQ, Depth + 1))
+      return I;
+    Known.knownNot(~DemandedMask);
+    break;
+  }
+  case Instruction::InsertElement: {
+    KnownFPClass KnownInserted, KnownVec;
+    if (SimplifyDemandedFPClass(I, 1, DemandedMask, KnownInserted, SQ,
+                                Depth + 1) ||
+        SimplifyDemandedFPClass(I, 0, DemandedMask, KnownVec, SQ, Depth + 1))
+      return I;
+
+    // TODO: Use demanded elements logic from computeKnownFPClass
+    Known = KnownVec | KnownInserted;
+    Known.knownNot(~DemandedMask);
+    break;
+  }
+  case Instruction::ShuffleVector: {
+    KnownFPClass KnownLHS, KnownRHS;
+    if (SimplifyDemandedFPClass(I, 1, DemandedMask, KnownRHS, SQ, Depth + 1) ||
+        SimplifyDemandedFPClass(I, 0, DemandedMask, KnownLHS, SQ, Depth + 1))
+      return I;
+
+    // TODO: This is overly conservative and should consider demanded elements,
+    // and splats.
+    Known = KnownLHS | KnownRHS;
+    Known.knownNot(~DemandedMask);
+    break;
+  }
+  case Instruction::InsertValue: {
+    KnownFPClass KnownAgg, KnownElt;
+    if (SimplifyDemandedFPClass(I, 0, DemandedMask, KnownAgg, SQ, Depth + 1) ||
+        SimplifyDemandedFPClass(I, 1, DemandedMask, KnownElt, SQ, Depth + 1))
+      return I;
+
+    Known = KnownAgg | KnownElt;
+    break;
+  }
+  case Instruction::ExtractValue: {
+    Value *ExtractSrc;
+    if (match(I, m_ExtractValue<0>(m_OneUse(m_Value(ExtractSrc))))) {
+      if (auto *II = dyn_cast<IntrinsicInst>(ExtractSrc)) {
+        const Intrinsic::ID IID = II->getIntrinsicID();
+        switch (IID) {
+        case Intrinsic::frexp: {
+          FPClassTest SrcDemandedMask = fcNone;
+
+          if (DemandedMask & fcNan)
+            SrcDemandedMask |= fcNan;
+
+          // Positive subnormals and negative subnormals could become positive
+          // zero.
+          if (DemandedMask & fcPosZero)
+            SrcDemandedMask |= fcPosZero | fcSubnormal;
+
+          // Negative subnormals could become negative zero.
+          if (DemandedMask & fcNegZero)
+            SrcDemandedMask |= fcNegZero | fcNegSubnormal;
+
+          if (DemandedMask & (fcNegNormal | fcNegSubnormal))
+            SrcDemandedMask |= fcNegNormal | fcNegSubnormal;
+          if (DemandedMask & (fcPosNormal | fcPosSubnormal))
+            SrcDemandedMask |= fcPosNormal | fcPosSubnormal;
+
+          if (DemandedMask & fcPosInf)
+            SrcDemandedMask |= fcPosInf;
+          if (DemandedMask & fcNegInf)
+            SrcDemandedMask |= fcNegInf;
+
+          KnownFPClass KnownSrc;
+          if (SimplifyDemandedFPClass(II, 0, SrcDemandedMask, KnownSrc, SQ,
+                                      Depth + 1))
+            return I;
+
+          Type *EltTy = VTy->getScalarType();
+          DenormalMode Mode = F.getDenormalMode(EltTy->getFltSemantics());
+
+          Known = KnownFPClass::frexp_mant(KnownSrc, Mode);
+          Known.setKnownFPClasses(Known.getKnownFPClasses() & DemandedMask);
+
+          if (Constant *SingleVal =
+                  getFPClassConstant(VTy, Known.getKnownFPClasses(),
+                                     /*IsCanonicalizing=*/true))
+            return SingleVal;
+
+          // frexp returns zero, infinity, and NaN inputs unchanged.
+          if (KnownSrc.isKnownAlways(fcZero | fcInf | fcNan))
+            return II->getArgOperand(0);
+
+          return nullptr;
+        }
+        default:
+          break;
+        }
+      }
+    }
+
+    KnownFPClass KnownSrc;
+    if (SimplifyDemandedFPClass(I, 0, DemandedMask, KnownSrc, SQ, Depth + 1))
+      return I;
+    Known = KnownSrc;
+    break;
+  }
+  case Instruction::PHI: {
+    const unsigned PhiRecursionLimit = MaxAnalysisRecursionDepth - 2;
+    if (Depth >= PhiRecursionLimit)
+      break;
+
+    PHINode *P = cast<PHINode>(I);
+    SimplifyQuery ContextSQ = SQ.getWithoutCondContext();
+
+    bool First = true;
+    bool Changed = false;
+    for (unsigned I = 0, E = P->getNumIncomingValues(); I != E; ++I) {
+      // TODO: Better support for self recursive phi
+      BasicBlock *PredBB = P->getIncomingBlock(I);
+      const Instruction *CtxI = PredBB->getTerminator();
+
+      // Attempt to simplify all incoming edges at a time. If we simplify one
+      // incoming edge, the phi may fold away, losing information on a later
+      // visit.
+      KnownFPClass KnownSrc;
+      if (SimplifyDemandedFPClass(
+              P, P->getOperandNumForIncomingValue(I), DemandedMask, KnownSrc,
+              ContextSQ.getWithInstruction(CtxI), Depth + 1)) {
+        // Fixup the other block references to the simplified value.
+        P->setIncomingValueForBlock(PredBB, P->getIncomingValue(I));
+        Changed = true;
+      }
+
+      if (First) {
+        Known = KnownSrc;
+        First = false;
+      } else {
+        Known |= KnownSrc;
+      }
+    }
+
+    if (Changed)
+      return P;
+
+    Known.knownNot(~DemandedMask);
+    break;
+  }
+  default:
+    Known = computeKnownFPClass(I, DemandedMask, SQ, Depth + 1);
+    Known.knownNot(~DemandedMask);
+    break;
+  }
+
+  return getFPClassConstant(VTy, Known.getKnownFPClasses());
+}
+
+/// Helper routine of SimplifyDemandedUseFPClass. It computes Known
+/// floating-point classes. It also tries to handle simplifications that can be
+/// done based on DemandedMask, but without modifying the Instruction.
+Value *InstCombinerImpl::SimplifyMultipleUseDemandedFPClass(
+    Instruction *I, FPClassTest DemandedMask, KnownFPClass &Known,
+    const SimplifyQuery &SQ, unsigned Depth) {
+  FastMathFlags FMF;
+  if (auto *FPOp = dyn_cast<FPMathOperator>(I)) {
+    FMF = FPOp->getFastMathFlags();
+    DemandedMask = adjustDemandedMaskFromFlags(DemandedMask, FMF);
+  }
+
+  switch (I->getOpcode()) {
+  case Instruction::Select: {
+    // TODO: Can we infer which side it came from based on adjusted result
+    // class?
+    KnownFPClass KnownRHS =
+        computeKnownFPClass(I->getOperand(2), DemandedMask, SQ, Depth + 1);
+    if (KnownRHS.isKnownNever(DemandedMask))
+      return I->getOperand(1);
+
+    KnownFPClass KnownLHS =
+        computeKnownFPClass(I->getOperand(1), DemandedMask, SQ, Depth + 1);
+    if (KnownLHS.isKnownNever(DemandedMask))
+      return I->getOperand(2);
+
+    adjustKnownFPClassForSelectArm(KnownLHS, I->getOperand(0), I->getOperand(1),
+                                   /*Invert=*/false, SQ, Depth);
+    adjustKnownFPClassForSelectArm(KnownRHS, I->getOperand(0), I->getOperand(2),
+                                   /*Invert=*/true, SQ, Depth);
+    Known = KnownLHS.intersectWith(KnownRHS);
+    Known.knownNot(~DemandedMask);
+    break;
+  }
+  case Instruction::FNeg: {
+    // Special case fneg(fabs(x))
+    Value *Src;
+
+    Value *FNegSrc = I->getOperand(0);
+    if (!match(FNegSrc, m_FAbs(m_Value(Src)))) {
+      Known = computeKnownFPClass(I, DemandedMask, SQ, Depth + 1);
+      break;
+    }
+
+    KnownFPClass KnownSrc = computeKnownFPClass(Src, fcAllFlags, SQ, Depth + 1);
+
+    FastMathFlags FabsFMF = cast<FPMathOperator>(FNegSrc)->getFastMathFlags();
+    FPClassTest ThisDemandedMask =
+        adjustDemandedMaskFromFlags(DemandedMask, FabsFMF);
+
+    // We cannot apply the NSZ logic with multiple uses. We can apply it if the
+    // inner fabs has it and this is the only use.
+    if (Value *Simplified = simplifyDemandedFPClassFnegFabs(
+            Known, Src, ThisDemandedMask, KnownSrc, /*NSZ=*/false))
+      return Simplified;
+    break;
+  }
+  case Instruction::Call: {
+    const CallInst *CI = cast<CallInst>(I);
+    const Intrinsic::ID IID = CI->getIntrinsicID();
+    switch (IID) {
+    case Intrinsic::fabs: {
+      Value *Src = CI->getArgOperand(0);
+      KnownFPClass KnownSrc =
+          computeKnownFPClass(Src, fcAllFlags, SQ, Depth + 1);
+
+      // NSZ cannot be applied in multiple use case (maybe it could if all uses
+      // were known nsz)
+      if (Value *Simplified = simplifyDemandedFPClassFabs(
+              Known, CI->getArgOperand(0), DemandedMask, KnownSrc,
+              /*NSZ=*/false))
+        return Simplified;
+      break;
+    }
+    case Intrinsic::copysign: {
+      Value *Mag = CI->getArgOperand(0);
+      Value *Sign = CI->getArgOperand(1);
+      KnownFPClass KnownMag =
+          computeKnownFPClass(Mag, fcAllFlags, SQ, Depth + 1);
+
+      // Rule out some cases by magnitude, which may help prove the sign bit is
+      // one direction or the other.
+      KnownMag.knownNot(~llvm::unknown_sign(DemandedMask));
+
+      // Cannot use nsz in the multiple use case.
+      if (Value *Simplified = simplifyDemandedFPClassCopysignMag(
+              Mag, DemandedMask, KnownMag, /*NSZ=*/false))
+        return Simplified;
+
+      KnownFPClass KnownSign =
+          computeKnownFPClass(Sign, fcAllFlags, SQ, Depth + 1);
+
+      if (FMF.noInfs())
+        KnownSign.knownNot(fcInf);
+      if (FMF.noNaNs())
+        KnownSign.knownNot(fcNan);
+
+      if (KnownSign.getSignBit() && KnownMag.getSignBit() &&
+          *KnownSign.getSignBit() == *KnownMag.getSignBit())
+        return Mag;
+
+      Known = KnownFPClass::copysign(KnownMag, KnownSign);
+      break;
+    }
+    case Intrinsic::maxnum:
+    case Intrinsic::minnum:
+    case Intrinsic::maximum:
+    case Intrinsic::minimum:
+    case Intrinsic::maximumnum:
+    case Intrinsic::minimumnum: {
+      KnownFPClass KnownRHS = computeKnownFPClass(CI->getArgOperand(1),
+                                                  DemandedMask, SQ, Depth + 1);
+      if (KnownRHS.isUnknown())
+        return nullptr;
+
+      KnownFPClass KnownLHS = computeKnownFPClass(CI->getArgOperand(0),
+                                                  DemandedMask, SQ, Depth + 1);
+
+      // Cannot use NSZ in the multiple use case.
+      return simplifyDemandedFPClassMinMax(Known, IID, CI, DemandedMask,
+                                           KnownLHS, KnownRHS, F,
+                                           /*NSZ=*/false);
+    }
+    default:
+      break;
+    }
+
+    [[fallthrough]];
+  }
+  default:
+    Known = computeKnownFPClass(I, DemandedMask, SQ, Depth + 1);
+    Known.knownNot(~DemandedMask);
+    break;
+  }
+
+  return getFPClassConstant(I->getType(), Known.getKnownFPClasses());
+}
+
+bool InstCombinerImpl::SimplifyDemandedFPClass(Instruction *I, unsigned OpNo,
+                                               FPClassTest DemandedMask,
+                                               KnownFPClass &Known,
+                                               const SimplifyQuery &SQ,
+                                               unsigned Depth) {
+  Use &U = I->getOperandUse(OpNo);
+  Value *V = U.get();
+  Type *VTy = V->getType();
+
+  if (DemandedMask == fcNone) {
+    if (isa<PoisonValue>(V))
+      return false;
+    replaceUse(U, PoisonValue::get(VTy));
+    return true;
+  }
+
+  // Handle constant
+  Instruction *VInst = dyn_cast<Instruction>(V);
+  if (!VInst) {
+    // Handle constants and arguments
+    Known = computeKnownFPClass(V, fcAllFlags, SQ, Depth);
+    Known.knownNot(~DemandedMask);
+
+    if (Known.getKnownFPClasses() == fcNone) {
+      if (isa<PoisonValue>(V))
+        return false;
+      replaceUse(U, PoisonValue::get(VTy));
+      return true;
+    }
+
+    // Do not try to replace values which are already constants (unless we are
+    // folding to poison). Doing so could promote poison elements to non-poison
+    // constants.
+    if (isa<Constant>(V))
+      return false;
+
+    Value *FoldedToConst = getFPClassConstant(VTy, Known.getKnownFPClasses());
+    if (!FoldedToConst || FoldedToConst == V)
+      return false;
+
+    replaceUse(U, FoldedToConst);
+    return true;
+  }
+
+  if (Depth == MaxAnalysisRecursionDepth) {
+    Known.knownNot(~DemandedMask);
+    return false;
+  }
+
+  Value *NewVal;
+
+  if (VInst->hasOneUse()) {
+    // If the instruction has one use, we can directly simplify it.
+    NewVal = SimplifyDemandedUseFPClass(VInst, DemandedMask, Known, SQ, Depth);
+  } else {
+    // If there are multiple uses of this instruction, then we can simplify
+    // VInst to some other value, but not modify the instruction.
+    NewVal = SimplifyMultipleUseDemandedFPClass(VInst, DemandedMask, Known, SQ,
+                                                Depth);
+  }
+
+  if (!NewVal)
+    return false;
+  // Recursion through a PHI may have already replaced this use. If the
+  // recursive simplification only changed V in place, do not restore it.
+  if (NewVal == V && U.get() != V)
+    return true;
+  if (Instruction *OpInst = dyn_cast<Instruction>(U))
+    salvageDebugInfo(*OpInst);
+
+  replaceUse(U, NewVal);
+  return true;
+}
diff --git a/llvm/utils/gn/secondary/llvm/lib/Transforms/InstCombine/BUILD.gn b/llvm/utils/gn/secondary/llvm/lib/Transforms/InstCombine/BUILD.gn
index 79f422dabbf201..478a9cbb986178 100644
--- a/llvm/utils/gn/secondary/llvm/lib/Transforms/InstCombine/BUILD.gn
+++ b/llvm/utils/gn/secondary/llvm/lib/Transforms/InstCombine/BUILD.gn
@@ -30,6 +30,7 @@ static_library("InstCombine") {
     "InstCombineSelect.cpp",
     "InstCombineShifts.cpp",
     "InstCombineSimplifyDemanded.cpp",
+    "InstCombineSimplifyDemandedFP.cpp",
     "InstCombineVectorOps.cpp",
     "InstructionCombining.cpp",
   ]



More information about the llvm-branch-commits mailing list