Commit 11d1573b authored by Jay Foad's avatar Jay Foad
Browse files

[APFloat] Make use of new overloaded comparison operators. NFC. 

Reviewers: ekatz, spatel, jfb, tlively, craig.topper, RKSimon, nikic, scanon

Subscribers: arsenm, jvesely, nhaehnle, hiraditya, dexonsmith, kerbowa, llvm-commits

Tags: #llvm

Differential Revision: https://reviews.llvm.org/D75744
parent 6c61edcb

llvm/include/llvm/ADT/APFloat.h

+4 −4
Original line number Diff line number Diff line
@@ -1277,7 +1277,7 @@ inline APFloat minnum(const APFloat &A, const APFloat &B) { 
    return B;

  if (B.isNaN())

    return A;

  return (B.compare(A) == APFloat::cmpLessThan) ? B : A;

  return B < A ? B : A;

}



/// Implements IEEE maxNum semantics. Returns the larger of the 2 arguments if
@@ -1288,7 +1288,7 @@ inline APFloat maxnum(const APFloat &A, const APFloat &B) { 
    return B;

  if (B.isNaN())

    return A;

  return (A.compare(B) == APFloat::cmpLessThan) ? B : A;

  return A < B ? B : A;

}



/// Implements IEEE 754-2018 minimum semantics. Returns the smaller of 2
@@ -1301,7 +1301,7 @@ inline APFloat minimum(const APFloat &A, const APFloat &B) { 
    return B;

  if (A.isZero() && B.isZero() && (A.isNegative() != B.isNegative()))

    return A.isNegative() ? A : B;

  return (B.compare(A) == APFloat::cmpLessThan) ? B : A;

  return B < A ? B : A;

}



/// Implements IEEE 754-2018 maximum semantics. Returns the larger of 2
@@ -1314,7 +1314,7 @@ inline APFloat maximum(const APFloat &A, const APFloat &B) { 
    return B;

  if (A.isZero() && B.isZero() && (A.isNegative() != B.isNegative()))

    return A.isNegative() ? B : A;

  return (A.compare(B) == APFloat::cmpLessThan) ? B : A;

  return A < B ? B : A;

}



} // namespace llvm

llvm/lib/Analysis/ConstantFolding.cpp

+8 −16
Original line number Diff line number Diff line
@@ -2555,11 +2555,9 @@ bool llvm::isMathLibCallNoop(const CallBase *Call, 
      case LibFunc_expf:

        // FIXME: These boundaries are slightly conservative.

        if (OpC->getType()->isDoubleTy())

          return Op.compare(APFloat(-745.0)) != APFloat::cmpLessThan &&

                 Op.compare(APFloat(709.0)) != APFloat::cmpGreaterThan;

          return !(Op < APFloat(-745.0) || Op > APFloat(709.0));

        if (OpC->getType()->isFloatTy())

          return Op.compare(APFloat(-103.0f)) != APFloat::cmpLessThan &&

                 Op.compare(APFloat(88.0f)) != APFloat::cmpGreaterThan;

          return !(Op < APFloat(-103.0f) || Op > APFloat(88.0f));

        break;



      case LibFunc_exp2l:
@@ -2567,11 +2565,9 @@ bool llvm::isMathLibCallNoop(const CallBase *Call, 
      case LibFunc_exp2f:

        // FIXME: These boundaries are slightly conservative.

        if (OpC->getType()->isDoubleTy())

          return Op.compare(APFloat(-1074.0)) != APFloat::cmpLessThan &&

                 Op.compare(APFloat(1023.0)) != APFloat::cmpGreaterThan;

          return !(Op < APFloat(-1074.0) || Op > APFloat(1023.0));

        if (OpC->getType()->isFloatTy())

          return Op.compare(APFloat(-149.0f)) != APFloat::cmpLessThan &&

                 Op.compare(APFloat(127.0f)) != APFloat::cmpGreaterThan;

          return !(Op < APFloat(-149.0f) || Op > APFloat(127.0f));

        break;



      case LibFunc_sinl:
@@ -2601,10 +2597,8 @@ bool llvm::isMathLibCallNoop(const CallBase *Call, 
      case LibFunc_acosl:

      case LibFunc_acos:

      case LibFunc_acosf:

        return Op.compare(APFloat(Op.getSemantics(), "-1")) !=

                   APFloat::cmpLessThan &&

               Op.compare(APFloat(Op.getSemantics(), "1")) !=

                   APFloat::cmpGreaterThan;

        return !(Op < APFloat(Op.getSemantics(), "-1") ||

                 Op > APFloat(Op.getSemantics(), "1"));



      case LibFunc_sinh:

      case LibFunc_cosh:
@@ -2614,11 +2608,9 @@ bool llvm::isMathLibCallNoop(const CallBase *Call, 
      case LibFunc_coshl:

        // FIXME: These boundaries are slightly conservative.

        if (OpC->getType()->isDoubleTy())

          return Op.compare(APFloat(-710.0)) != APFloat::cmpLessThan &&

                 Op.compare(APFloat(710.0)) != APFloat::cmpGreaterThan;

          return !(Op < APFloat(-710.0) || Op > APFloat(710.0));

        if (OpC->getType()->isFloatTy())

          return Op.compare(APFloat(-89.0f)) != APFloat::cmpLessThan &&

                 Op.compare(APFloat(89.0f)) != APFloat::cmpGreaterThan;

          return !(Op < APFloat(-89.0f) || Op > APFloat(89.0f));

        break;



      case LibFunc_sqrtl:

llvm/lib/Analysis/InstructionSimplify.cpp

+2 −2
Original line number Diff line number Diff line
@@ -3617,9 +3617,9 @@ static Value *SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 
    // Check comparison of [minnum/maxnum with constant] with other constant.

    const APFloat *C2;

    if ((match(LHS, m_Intrinsic<Intrinsic::minnum>(m_Value(), m_APFloat(C2))) &&

         C2->compare(*C) == APFloat::cmpLessThan) ||

         *C2 < *C) ||

        (match(LHS, m_Intrinsic<Intrinsic::maxnum>(m_Value(), m_APFloat(C2))) &&

         C2->compare(*C) == APFloat::cmpGreaterThan)) {

         *C2 > *C)) {

      bool IsMaxNum =

          cast<IntrinsicInst>(LHS)->getIntrinsicID() == Intrinsic::maxnum;

      // The ordered relationship and minnum/maxnum guarantee that we do not

llvm/lib/Analysis/ValueTracking.cpp

+2 −2
Original line number Diff line number Diff line
@@ -4886,7 +4886,7 @@ static SelectPatternResult matchFastFloatClamp(CmpInst::Predicate Pred, 
    if (match(FalseVal,

              m_CombineOr(m_OrdFMin(m_Specific(CmpLHS), m_APFloat(FC2)),

                          m_UnordFMin(m_Specific(CmpLHS), m_APFloat(FC2)))) &&

        FC1->compare(*FC2) == APFloat::cmpResult::cmpLessThan)

        *FC1 < *FC2)

      return {SPF_FMAXNUM, SPNB_RETURNS_ANY, false};

    break;

  case CmpInst::FCMP_OGT:
@@ -4896,7 +4896,7 @@ static SelectPatternResult matchFastFloatClamp(CmpInst::Predicate Pred, 
    if (match(FalseVal,

              m_CombineOr(m_OrdFMax(m_Specific(CmpLHS), m_APFloat(FC2)),

                          m_UnordFMax(m_Specific(CmpLHS), m_APFloat(FC2)))) &&

        FC1->compare(*FC2) == APFloat::cmpResult::cmpGreaterThan)

        *FC1 > *FC2)

      return {SPF_FMINNUM, SPNB_RETURNS_ANY, false};

    break;

  default:

llvm/lib/IR/Metadata.cpp

+1 −1
Original line number Diff line number Diff line
@@ -934,7 +934,7 @@ MDNode *MDNode::getMostGenericFPMath(MDNode *A, MDNode *B) { 


  APFloat AVal = mdconst::extract<ConstantFP>(A->getOperand(0))->getValueAPF();

  APFloat BVal = mdconst::extract<ConstantFP>(B->getOperand(0))->getValueAPF();

  if (AVal.compare(BVal) == APFloat::cmpLessThan)

  if (AVal < BVal)

    return A;

  return B;

}