RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2025-02-01 05:01:59 +01:00
Code Issues Projects Releases Wiki Activity

Fix APFloat mod (committing for simonbyrne)

Browse Source 
The previous version was prone to intermediate rounding or overflow.

Differential Revision: https://reviews.llvm.org/D29346

llvm-svn: 299256
This commit is contained in:
Stephen Canon 2017-03-31 20:31:33 +00:00
parent fa8ce143bf
commit dc865d22d7
2 changed files with 74 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
lib/Support/APFloat.cpp
View File

@ -1740,44 +1740,20 @@ IEEEFloat::opStatus IEEEFloat::remainder(const IEEEFloat &rhs) {
return fs; return fs;
} }
/* Normalized llvm frem (C fmod). /* Normalized llvm frem (C fmod). */
This is not currently correct in all cases. */
IEEEFloat::opStatus IEEEFloat::mod(const IEEEFloat &rhs) { IEEEFloat::opStatus IEEEFloat::mod(const IEEEFloat &rhs) {
opStatus fs; opStatus fs;
fs = modSpecials(rhs); fs = modSpecials(rhs);
if (isFiniteNonZero() && rhs.isFiniteNonZero()) { while (isFiniteNonZero() && rhs.isFiniteNonZero() &&
IEEEFloat V = *this; compareAbsoluteValue(rhs) != cmpLessThan) {
unsigned int origSign = sign; IEEEFloat V = scalbn(rhs, ilogb(*this) - ilogb(rhs), rmNearestTiesToEven);
if (compareAbsoluteValue(V) == cmpLessThan)
fs = V.divide(rhs, rmNearestTiesToEven); V = scalbn(V, -1, rmNearestTiesToEven);
if (fs == opDivByZero) V.sign = sign;
return fs;
int parts = partCount();
integerPart *x = new integerPart[parts];
bool ignored;
fs = V.convertToInteger(makeMutableArrayRef(x, parts),
parts * integerPartWidth, true, rmTowardZero,
&ignored);
if (fs == opInvalidOp) {
delete[] x;
return fs;
}
fs = V.convertFromZeroExtendedInteger(x, parts * integerPartWidth, true,
rmNearestTiesToEven);
assert(fs==opOK); // should always work
fs = V.multiply(rhs, rmNearestTiesToEven);
assert(fs==opOK || fs==opInexact); // should not overflow or underflow
fs = subtract(V, rmNearestTiesToEven); fs = subtract(V, rmNearestTiesToEven);
assert(fs==opOK || fs==opInexact); // likewise assert(fs==opOK);
if (isZero())
sign = origSign; // IEEE754 requires this
delete[] x;
} }
return fs; return fs;
} }

67
unittests/ADT/APFloatTest.cpp
View File

@ -3192,10 +3192,73 @@ TEST(APFloatTest, frexp) {
EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1").bitwiseIsEqual(Frac)); EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1").bitwiseIsEqual(Frac));
} }
TEST(APFloatTest, mod) {
{
APFloat f1(APFloat::IEEEdouble(), "1.5");
APFloat f2(APFloat::IEEEdouble(), "1.0");
APFloat expected(APFloat::IEEEdouble(), "0.5");
EXPECT_EQ(f1.mod(f2), APFloat::opOK);
EXPECT_TRUE(f1.bitwiseIsEqual(expected));
}
{
APFloat f1(APFloat::IEEEdouble(), "0.5");
APFloat f2(APFloat::IEEEdouble(), "1.0");
APFloat expected(APFloat::IEEEdouble(), "0.5");
EXPECT_EQ(f1.mod(f2), APFloat::opOK);
EXPECT_TRUE(f1.bitwiseIsEqual(expected));
}
{
APFloat f1(APFloat::IEEEdouble(), "0x1.3333333333333p-2"); // 0.3
APFloat f2(APFloat::IEEEdouble(), "0x1.47ae147ae147bp-7"); // 0.01
APFloat expected(APFloat::IEEEdouble(),
"0x1.47ae147ae1471p-7"); // 0.009999999999999983
EXPECT_EQ(f1.mod(f2), APFloat::opOK);
EXPECT_TRUE(f1.bitwiseIsEqual(expected));
}
{
APFloat f1(APFloat::IEEEdouble(), "0x1p64"); // 1.8446744073709552e19
APFloat f2(APFloat::IEEEdouble(), "1.5");
APFloat expected(APFloat::IEEEdouble(), "1.0");
EXPECT_EQ(f1.mod(f2), APFloat::opOK);
EXPECT_TRUE(f1.bitwiseIsEqual(expected));
}
{
APFloat f1(APFloat::IEEEdouble(), "0x1p1000");
APFloat f2(APFloat::IEEEdouble(), "0x1p-1000");
APFloat expected(APFloat::IEEEdouble(), "0.0");
EXPECT_EQ(f1.mod(f2), APFloat::opOK);
EXPECT_TRUE(f1.bitwiseIsEqual(expected));
}
{
APFloat f1(APFloat::IEEEdouble(), "0.0");
APFloat f2(APFloat::IEEEdouble(), "1.0");
APFloat expected(APFloat::IEEEdouble(), "0.0");
EXPECT_EQ(f1.mod(f2), APFloat::opOK);
EXPECT_TRUE(f1.bitwiseIsEqual(expected));
}
{
APFloat f1(APFloat::IEEEdouble(), "1.0");
APFloat f2(APFloat::IEEEdouble(), "0.0");
EXPECT_EQ(f1.mod(f2), APFloat::opInvalidOp);
EXPECT_TRUE(f1.isNaN());
}
{
APFloat f1(APFloat::IEEEdouble(), "0.0");
APFloat f2(APFloat::IEEEdouble(), "0.0");
EXPECT_EQ(f1.mod(f2), APFloat::opInvalidOp);
EXPECT_TRUE(f1.isNaN());
}
{
APFloat f1 = APFloat::getInf(APFloat::IEEEdouble(), false);
APFloat f2(APFloat::IEEEdouble(), "1.0");
EXPECT_EQ(f1.mod(f2), APFloat::opInvalidOp);
EXPECT_TRUE(f1.isNaN());
}
}
TEST(APFloatTest, PPCDoubleDoubleAddSpecial) { TEST(APFloatTest, PPCDoubleDoubleAddSpecial) {
using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t,
APFloat::fltCategory, APFloat::roundingMode>; APFloat::fltCategory, APFloat::roundingMode>; DataType Data[] = {
DataType Data[] = {
// (1 + 0) + (-1 + 0) = fcZero // (1 + 0) + (-1 + 0) = fcZero
std::make_tuple(0x3ff0000000000000ull, 0, 0xbff0000000000000ull, 0, std::make_tuple(0x3ff0000000000000ull, 0, 0xbff0000000000000ull, 0,
APFloat::fcZero, APFloat::rmNearestTiesToEven), APFloat::fcZero, APFloat::rmNearestTiesToEven),