6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-13 20:32:21 +00:00
Code Issues Projects Releases Wiki Activity

IEEE-754R 5.7.2 General Operations is* operations (except for isCanonical).

Browse Source 
Specifically the following work was done:

1. If the operation was not implemented, I implemented it.

2. If the operation was already implemented, I just moved its location
in the APFloat header into the IEEE-754R 5.7.2 section. If the name was
incorrect, I put in a comment giving the true IEEE-754R name.

Also unittests have been added for all of the functions which did not
already have a unittest.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@183179 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Michael Gottesman 2013-06-04 03:46:25 +00:00
parent f3d3952a8c
commit b30718af1a
2 changed files with 103 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
include/llvm/ADT/APFloat.h
View File

@ -346,22 +346,57 @@ public:
unsigned int convertToHexString(char *dst, unsigned int hexDigits,
bool upperCase, roundingMode) const;
/// \name IEEE-754R 5.7.2 General operations.
/// @{
/// IEEE-754R isSignMinus: Returns true if and only if the current value is
/// negative.
///
/// This applies to zeros and NaNs as well.
bool isNegative() const { return sign; }
/// IEEE-754R isNormal: Returns true if and only if the current value is normal.
///
/// This implies that the current value of the float is not zero, subnormal,
/// infinite, or NaN following the definition of normality from IEEE-754R.
///
/// The current implementation of isNormal() differs from this by treating
/// subnormal values as normal values.
bool isIEEENormal() const { return !isDenormal() && isNormal(); }
/// Returns true if and only if the current value is zero, subnormal, or
/// normal.
///
/// This means that the value is not infinite or NaN.
bool isFinite() const { return !isNaN() && !isInfinity(); }
/// Returns true if and only if the float is plus or minus zero.
bool isZero() const { return category == fcZero; }
/// IEEE-754R isSubnormal(): Returns true if and only if the float is a
/// denormal.
bool isDenormal() const;
/// IEEE-754R isInfinite(): Returns true if and only if the float is infinity.
bool isInfinity() const { return category == fcInfinity; }
/// Returns true if and only if the float is a quiet or signaling NaN.
bool isNaN() const { return category == fcNaN; }
/// Returns true if and only if the float is a signaling NaN.
bool isSignaling() const;
/// @}
/// \name Simple Queries
/// @{
fltCategory getCategory() const { return category; }
const fltSemantics &getSemantics() const { return *semantics; }
bool isZero() const { return category == fcZero; }
bool isNonZero() const { return category != fcZero; }
bool isNormal() const { return category == fcNormal; }
bool isNaN() const { return category == fcNaN; }
bool isInfinity() const { return category == fcInfinity; }
bool isNegative() const { return sign; }
bool isPosZero() const { return isZero() && !isNegative(); }
bool isNegZero() const { return isZero() && isNegative(); }
bool isDenormal() const;
/// IEEE-754R 5.7.2: isSignaling. Returns true if this is a signaling NaN.
bool isSignaling() const;
/// @}

61
unittests/ADT/APFloatTest.cpp
View File

@ -1397,4 +1397,65 @@ TEST(APFloatTest, PPCDoubleDouble) {
EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
#endif
}
TEST(APFloatTest, isNegative) {
APFloat t(APFloat::IEEEsingle, "0x1p+0");
EXPECT_FALSE(t.isNegative());
t = APFloat(APFloat::IEEEsingle, "-0x1p+0");
EXPECT_TRUE(t.isNegative());
EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isNegative());
EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle, true).isNegative());
EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isNegative());
EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle, true).isNegative());
EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isNegative());
EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle, true).isNegative());
EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isNegative());
EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, true).isNegative());
}
TEST(APFloatTest, isIEEENormal) {
APFloat t(APFloat::IEEEsingle, "0x1p+0");
EXPECT_TRUE(t.isIEEENormal());
EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isIEEENormal());
EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isIEEENormal());
EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isIEEENormal());
EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isIEEENormal());
EXPECT_FALSE(APFloat(APFloat::IEEEsingle, "0x1p-159").isIEEENormal());
}
TEST(APFloatTest, isFinite) {
APFloat t(APFloat::IEEEsingle, "0x1p+0");
EXPECT_TRUE(t.isFinite());
EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isFinite());
EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle, false).isFinite());
EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isFinite());
EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isFinite());
EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "0x1p-159").isFinite());
}
TEST(APFloatTest, isInfinity) {
APFloat t(APFloat::IEEEsingle, "0x1p+0");
EXPECT_FALSE(t.isInfinity());
EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle, false).isInfinity());
EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isInfinity());
EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isInfinity());
EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isInfinity());
EXPECT_FALSE(APFloat(APFloat::IEEEsingle, "0x1p-159").isInfinity());
}
TEST(APFloatTest, isNaN) {
APFloat t(APFloat::IEEEsingle, "0x1p+0");
EXPECT_FALSE(t.isNaN());
EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isNaN());
EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isNaN());
EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle, false).isNaN());
EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, false).isNaN());
EXPECT_FALSE(APFloat(APFloat::IEEEsingle, "0x1p-159").isNaN());
}
}