Lines Matching defs:FMF

4063                                FastMathFlags FMF, const SimplifyQuery &Q,
4115     if (FMF.noNaNs() ||
4133     return computeKnownFPClass(LHS, FMF, InterestedFlags, 0, Q);
4246       if (!FMF.noNaNs())
4253       if ((FMF.noNaNs() || Known.isKnownNeverNaN()) &&
4290                               FastMathFlags FMF, const SimplifyQuery &Q) {
4291   return ::simplifyFCmpInst(Predicate, LHS, RHS, FMF, Q, RecursionLimit);
5583 static Value *simplifyFNegInst(Value *Op, FastMathFlags FMF,
5596 Value *llvm::simplifyFNegInst(Value *Op, FastMathFlags FMF,
5598   return ::simplifyFNegInst(Op, FMF, Q, RecursionLimit);
5645 static Constant *simplifyFPOp(ArrayRef<Value *> Ops, FastMathFlags FMF,
5662     if (FMF.noNaNs() && (IsNan || IsUndef))
5664     if (FMF.noInfs() && (IsInf || IsUndef))
5687 simplifyFAddInst(Value *Op0, Value *Op1, FastMathFlags FMF,
5695   if (Constant *C = simplifyFPOp({Op0, Op1}, FMF, Q, ExBehavior, Rounding))
5703   if (canIgnoreSNaN(ExBehavior, FMF) &&
5705        FMF.noSignedZeros()))
5710   if (canIgnoreSNaN(ExBehavior, FMF))
5712         (FMF.noSignedZeros() || cannotBeNegativeZero(Op0, /*Depth=*/0, Q)))
5718   if (FMF.noNaNs()) {
5742   if (FMF.noSignedZeros() && FMF.allowReassoc() &&
5753 simplifyFSubInst(Value *Op0, Value *Op1, FastMathFlags FMF,
5761   if (Constant *C = simplifyFPOp({Op0, Op1}, FMF, Q, ExBehavior, Rounding))
5765   if (canIgnoreSNaN(ExBehavior, FMF) &&
5767        FMF.noSignedZeros()))
5772   if (canIgnoreSNaN(ExBehavior, FMF))
5774         (FMF.noSignedZeros() || cannotBeNegativeZero(Op0, /*Depth=*/0, Q)))
5780   if (canIgnoreSNaN(ExBehavior, FMF))
5786   if (canIgnoreSNaN(ExBehavior, FMF))
5787     if (FMF.noSignedZeros() && match(Op0, m_AnyZeroFP()) &&
5795   if (FMF.noNaNs()) {
5811   if (FMF.noSignedZeros() && FMF.allowReassoc() &&
5819 static Value *simplifyFMAFMul(Value *Op0, Value *Op1, FastMathFlags FMF,
5823   if (Constant *C = simplifyFPOp({Op0, Op1}, FMF, Q, ExBehavior, Rounding))
5839     if (FMF.noNaNs() && FMF.noSignedZeros())
5843         computeKnownFPClass(Op0, FMF, fcInf | fcNan, /*Depth=*/0, Q);
5859   if (Op0 == Op1 && match(Op0, m_Sqrt(m_Value(X))) && FMF.allowReassoc() &&
5860       FMF.noNaNs() && FMF.noSignedZeros())
5868 simplifyFMulInst(Value *Op0, Value *Op1, FastMathFlags FMF,
5877   return simplifyFMAFMul(Op0, Op1, FMF, Q, MaxRecurse, ExBehavior, Rounding);
5880 Value *llvm::simplifyFAddInst(Value *Op0, Value *Op1, FastMathFlags FMF,
5884   return ::simplifyFAddInst(Op0, Op1, FMF, Q, RecursionLimit, ExBehavior,
5888 Value *llvm::simplifyFSubInst(Value *Op0, Value *Op1, FastMathFlags FMF,
5892   return ::simplifyFSubInst(Op0, Op1, FMF, Q, RecursionLimit, ExBehavior,
5896 Value *llvm::simplifyFMulInst(Value *Op0, Value *Op1, FastMathFlags FMF,
5900   return ::simplifyFMulInst(Op0, Op1, FMF, Q, RecursionLimit, ExBehavior,
5904 Value *llvm::simplifyFMAFMul(Value *Op0, Value *Op1, FastMathFlags FMF,
5908   return ::simplifyFMAFMul(Op0, Op1, FMF, Q, RecursionLimit, ExBehavior,
5913 simplifyFDivInst(Value *Op0, Value *Op1, FastMathFlags FMF,
5921   if (Constant *C = simplifyFPOp({Op0, Op1}, FMF, Q, ExBehavior, Rounding))
5934   if (FMF.noNaNs() && FMF.noSignedZeros() && match(Op0, m_AnyZeroFP()))
5937   if (FMF.noNaNs()) {
5945     if (FMF.allowReassoc() && match(Op0, m_c_FMul(m_Value(X), m_Specific(Op1))))
5956     if (FMF.noInfs() && match(Op1, m_AnyZeroFP()))
5963 Value *llvm::simplifyFDivInst(Value *Op0, Value *Op1, FastMathFlags FMF,
5967   return ::simplifyFDivInst(Op0, Op1, FMF, Q, RecursionLimit, ExBehavior,
5972 simplifyFRemInst(Value *Op0, Value *Op1, FastMathFlags FMF,
5980   if (Constant *C = simplifyFPOp({Op0, Op1}, FMF, Q, ExBehavior, Rounding))
5989   if (FMF.noNaNs()) {
6001 Value *llvm::simplifyFRemInst(Value *Op0, Value *Op1, FastMathFlags FMF,
6005   return ::simplifyFRemInst(Op0, Op1, FMF, Q, RecursionLimit, ExBehavior,
6027                              const FastMathFlags &FMF, const SimplifyQuery &Q,
6031     return simplifyFNegInst(Op, FMF, Q, MaxRecurse);
6041 Value *llvm::simplifyUnOp(unsigned Opcode, Value *Op, FastMathFlags FMF,
6043   return ::simplifyFPUnOp(Opcode, Op, FMF, Q, RecursionLimit);
6100                             const FastMathFlags &FMF, const SimplifyQuery &Q,
6104     return simplifyFAddInst(LHS, RHS, FMF, Q, MaxRecurse);
6106     return simplifyFSubInst(LHS, RHS, FMF, Q, MaxRecurse);
6108     return simplifyFMulInst(LHS, RHS, FMF, Q, MaxRecurse);
6110     return simplifyFDivInst(LHS, RHS, FMF, Q, MaxRecurse);
6122                            FastMathFlags FMF, const SimplifyQuery &Q) {
6123   return ::simplifyBinOp(Opcode, LHS, RHS, FMF, Q, RecursionLimit);