[llvm] r184356 - [APFloat] Converted all references to APFloat::isNormal => APFloat::isFiniteNonZero.
Michael Gottesman
mgottesman at apple.com
Wed Jun 19 14:23:18 PDT 2013
Author: mgottesman
Date: Wed Jun 19 16:23:18 2013
New Revision: 184356
URL: http://llvm.org/viewvc/llvm-project?rev=184356&view=rev
Log:
[APFloat] Converted all references to APFloat::isNormal => APFloat::isFiniteNonZero.
Turns out all the references were in llvm and not in clang.
Modified:
llvm/trunk/include/llvm/ADT/APFloat.h
llvm/trunk/lib/IR/Verifier.cpp
llvm/trunk/lib/Support/APFloat.cpp
llvm/trunk/lib/Transforms/InstCombine/InstCombineAddSub.cpp
llvm/trunk/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp
Modified: llvm/trunk/include/llvm/ADT/APFloat.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/APFloat.h?rev=184356&r1=184355&r2=184356&view=diff
==============================================================================
--- llvm/trunk/include/llvm/ADT/APFloat.h (original)
+++ llvm/trunk/include/llvm/ADT/APFloat.h Wed Jun 19 16:23:18 2013
@@ -362,7 +362,7 @@ public:
///
/// The current implementation of isNormal() differs from this by treating
/// subnormal values as normal values.
- bool isIEEENormal() const { return !isDenormal() && isNormal(); }
+ bool isIEEENormal() const { return !isDenormal() && isFiniteNonZero(); }
/// Returns true if and only if the current value is zero, subnormal, or
/// normal.
Modified: llvm/trunk/lib/IR/Verifier.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/IR/Verifier.cpp?rev=184356&r1=184355&r2=184356&view=diff
==============================================================================
--- llvm/trunk/lib/IR/Verifier.cpp (original)
+++ llvm/trunk/lib/IR/Verifier.cpp Wed Jun 19 16:23:18 2013
@@ -1955,7 +1955,7 @@ void Verifier::visitInstruction(Instruct
Value *Op0 = MD->getOperand(0);
if (ConstantFP *CFP0 = dyn_cast_or_null<ConstantFP>(Op0)) {
APFloat Accuracy = CFP0->getValueAPF();
- Assert1(Accuracy.isNormal() && !Accuracy.isNegative(),
+ Assert1(Accuracy.isFiniteNonZero() && !Accuracy.isNegative(),
"fpmath accuracy not a positive number!", &I);
} else {
Assert1(false, "invalid fpmath accuracy!", &I);
Modified: llvm/trunk/lib/Support/APFloat.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Support/APFloat.cpp?rev=184356&r1=184355&r2=184356&view=diff
==============================================================================
--- llvm/trunk/lib/Support/APFloat.cpp (original)
+++ llvm/trunk/lib/Support/APFloat.cpp Wed Jun 19 16:23:18 2013
@@ -679,7 +679,7 @@ APFloat::operator=(const APFloat &rhs)
bool
APFloat::isDenormal() const {
- return isNormal() && (exponent == semantics->minExponent) &&
+ return isFiniteNonZero() && (exponent == semantics->minExponent) &&
(APInt::tcExtractBit(significandParts(),
semantics->precision - 1) == 0);
}
@@ -689,7 +689,7 @@ APFloat::isSmallest() const {
// The smallest number by magnitude in our format will be the smallest
// denormal, i.e. the floating point number with exponent being minimum
// exponent and significand bitwise equal to 1 (i.e. with MSB equal to 0).
- return isNormal() && exponent == semantics->minExponent &&
+ return isFiniteNonZero() && exponent == semantics->minExponent &&
significandMSB() == 0;
}
@@ -741,7 +741,7 @@ bool
APFloat::isLargest() const {
// The largest number by magnitude in our format will be the floating point
// number with maximum exponent and with significand that is all ones.
- return isNormal() && exponent == semantics->maxExponent
+ return isFiniteNonZero() && exponent == semantics->maxExponent
&& isSignificandAllOnes();
}
Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombineAddSub.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineAddSub.cpp?rev=184356&r1=184355&r2=184356&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/InstCombine/InstCombineAddSub.cpp (original)
+++ llvm/trunk/lib/Transforms/InstCombine/InstCombineAddSub.cpp Wed Jun 19 16:23:18 2013
@@ -488,7 +488,7 @@ Value *FAddCombine::performFactorization
createFSub(AddSub0, AddSub1);
if (ConstantFP *CFP = dyn_cast<ConstantFP>(NewAddSub)) {
const APFloat &F = CFP->getValueAPF();
- if (!F.isNormal() || F.isDenormal())
+ if (!F.isFiniteNonZero() || F.isDenormal())
return 0;
}
Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp?rev=184356&r1=184355&r2=184356&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp (original)
+++ llvm/trunk/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp Wed Jun 19 16:23:18 2013
@@ -338,13 +338,13 @@ static bool isFMulOrFDivWithConstant(Val
if (C0 && C1)
return false;
- return (C0 && C0->getValueAPF().isNormal()) ||
- (C1 && C1->getValueAPF().isNormal());
+ return (C0 && C0->getValueAPF().isFiniteNonZero()) ||
+ (C1 && C1->getValueAPF().isFiniteNonZero());
}
static bool isNormalFp(const ConstantFP *C) {
const APFloat &Flt = C->getValueAPF();
- return Flt.isNormal() && !Flt.isDenormal();
+ return Flt.isFiniteNonZero() && !Flt.isDenormal();
}
/// foldFMulConst() is a helper routine of InstCombiner::visitFMul().
@@ -423,7 +423,7 @@ Instruction *InstCombiner::visitFMul(Bin
return NV;
ConstantFP *C = dyn_cast<ConstantFP>(Op1);
- if (C && AllowReassociate && C->getValueAPF().isNormal()) {
+ if (C && AllowReassociate && C->getValueAPF().isFiniteNonZero()) {
// Let MDC denote an expression in one of these forms:
// X * C, C/X, X/C, where C is a constant.
//
@@ -450,7 +450,7 @@ Instruction *InstCombiner::visitFMul(Bin
Swap = true;
}
- if (C1 && C1->getValueAPF().isNormal() &&
+ if (C1 && C1->getValueAPF().isFiniteNonZero() &&
isFMulOrFDivWithConstant(Opnd0)) {
Value *M1 = ConstantExpr::getFMul(C1, C);
Value *M0 = isNormalFp(cast<ConstantFP>(M1)) ?
@@ -858,7 +858,7 @@ static Instruction *CvtFDivConstToRecipr
APFloat Reciprocal(FpVal.getSemantics());
bool Cvt = FpVal.getExactInverse(&Reciprocal);
- if (!Cvt && AllowReciprocal && FpVal.isNormal()) {
+ if (!Cvt && AllowReciprocal && FpVal.isFiniteNonZero()) {
Reciprocal = APFloat(FpVal.getSemantics(), 1.0f);
(void)Reciprocal.divide(FpVal, APFloat::rmNearestTiesToEven);
Cvt = !Reciprocal.isDenormal();
@@ -893,14 +893,14 @@ Instruction *InstCombiner::visitFDiv(Bin
//
Constant *C = ConstantExpr::getFDiv(C1, C2);
const APFloat &F = cast<ConstantFP>(C)->getValueAPF();
- if (F.isNormal() && !F.isDenormal())
+ if (F.isFiniteNonZero() && !F.isDenormal())
Res = BinaryOperator::CreateFMul(X, C);
} else if (match(Op0, m_FDiv(m_Value(X), m_ConstantFP(C1)))) {
// (X/C1)/C2 => X /(C2*C1) [=> X * 1/(C2*C1) if reciprocal is allowed]
//
Constant *C = ConstantExpr::getFMul(C1, C2);
const APFloat &F = cast<ConstantFP>(C)->getValueAPF();
- if (F.isNormal() && !F.isDenormal()) {
+ if (F.isFiniteNonZero() && !F.isDenormal()) {
Res = CvtFDivConstToReciprocal(X, cast<ConstantFP>(C),
AllowReciprocal);
if (!Res)
@@ -941,7 +941,7 @@ Instruction *InstCombiner::visitFDiv(Bin
if (Fold) {
const APFloat &FoldC = cast<ConstantFP>(Fold)->getValueAPF();
- if (FoldC.isNormal() && !FoldC.isDenormal()) {
+ if (FoldC.isFiniteNonZero() && !FoldC.isDenormal()) {
Instruction *R = CreateDiv ?
BinaryOperator::CreateFDiv(Fold, X) :
BinaryOperator::CreateFMul(X, Fold);
More information about the llvm-commits
mailing list