RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-25 20:23:11 +01:00
Code Issues Projects Releases Wiki Activity

Revert "[llvm-profdata] Add SaturatingAdd/SaturatingMultiply Helper Functions"

Browse Source 
Not ready for merge.

llvm-svn: 253415
This commit is contained in:
Nathan Slingerland 2015-11-18 00:55:15 +00:00
parent f11a4c60a1
commit 07e999d3a8
4 changed files with 9 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/llvm/ProfileData/InstrProf.h
View File

@ -226,7 +226,7 @@ struct InstrProfValueSiteRecord {
while (I != IE && I->Value < J->Value)
++I;
if (I != IE && I->Value == J->Value) {
I->Count = SaturatingAdd(I->Count, J->Count);
I->Count += J->Count;
++I;
continue;
}

10
include/llvm/ProfileData/SampleProf.h
View File

@ -173,7 +173,10 @@ public:
/// Sample counts accumulate using saturating arithmetic, to avoid wrapping
/// around unsigned integers.
void addSamples(uint64_t S) {
NumSamples = SaturatingAdd(NumSamples, S);
if (NumSamples <= std::numeric_limits<uint64_t>::max() - S)
NumSamples += S;
else
NumSamples = std::numeric_limits<uint64_t>::max();
}
/// Add called function \p F with samples \p S.
@ -182,7 +185,10 @@ public:
/// around unsigned integers.
void addCalledTarget(StringRef F, uint64_t S) {
uint64_t &TargetSamples = CallTargets[F];
TargetSamples = SaturatingAdd(TargetSamples, S);
if (TargetSamples <= std::numeric_limits<uint64_t>::max() - S)
TargetSamples += S;
else
TargetSamples = std::numeric_limits<uint64_t>::max();
}
/// Return true if this sample record contains function calls.

26
include/llvm/Support/MathExtras.h
View File

@ -653,32 +653,6 @@ inline int64_t SignExtend64(uint64_t X, unsigned B) {
return int64_t(X << (64 - B)) >> (64 - B);
}
/// \brief Add two unsigned integers, X and Y, of type T.
/// Clamp the result to the maximum representable value of T on overflow.
template <typename T>
typename std::enable_if<std::is_unsigned<T>::value, T>::type
SaturatingAdd(T X, T Y) {
// Hacker's Delight, p. 29
T Z = X + Y;
if (Z < X || Z < Y)
return std::numeric_limits<T>::max();
else
return Z;
}
/// \brief Multiply two unsigned integers, X and Y, of type T.
/// Clamp the result to the maximum representable value of T on overflow.
template <typename T>
typename std::enable_if<std::is_unsigned<T>::value, T>::type
SaturatingMultiply(T X, T Y) {
// Hacker's Delight, p. 30
T Z = X * Y;
if (Y != 0 && Z / Y != X)
return std::numeric_limits<T>::max();
else
return Z;
}
extern const float huge_valf;
} // End llvm namespace

48
unittests/Support/MathExtrasTest.cpp
View File

@ -190,52 +190,4 @@ TEST(MathExtras, RoundUpToAlignment) {
EXPECT_EQ(552u, RoundUpToAlignment(321, 255, 42));
}
template<typename T>
void SaturatingAddTestHelper()
{
EXPECT_EQ(static_cast<T>(3),
SaturatingAdd(static_cast<T>(1), static_cast<T>(2)));
EXPECT_EQ(std::numeric_limits<T>::max(),
SaturatingAdd(std::numeric_limits<T>::max(), static_cast<T>(1)));
EXPECT_EQ(std::numeric_limits<T>::max(),
SaturatingAdd(static_cast<T>(1), std::numeric_limits<T>::max()));
EXPECT_EQ(std::numeric_limits<T>::max(),
SaturatingAdd(std::numeric_limits<T>::max(),
std::numeric_limits<T>::max()));
}
TEST(MathExtras, SaturatingAdd) {
SaturatingAddTestHelper<uint8_t>();
SaturatingAddTestHelper<uint16_t>();
SaturatingAddTestHelper<uint32_t>();
SaturatingAddTestHelper<uint64_t>();
}
template<typename T>
void SaturatingMultiplyTestHelper()
{
EXPECT_EQ(static_cast<T>(0),
SaturatingMultiply(static_cast<T>(1), static_cast<T>(0)));
EXPECT_EQ(static_cast<T>(0),
SaturatingMultiply(static_cast<T>(0), static_cast<T>(1)));
EXPECT_EQ(static_cast<T>(6),
SaturatingMultiply(static_cast<T>(2), static_cast<T>(3)));
EXPECT_EQ(std::numeric_limits<T>::max(),
SaturatingMultiply(std::numeric_limits<T>::max(),
static_cast<T>(2)));
EXPECT_EQ(std::numeric_limits<T>::max(),
SaturatingMultiply(static_cast<T>(2),
std::numeric_limits<T>::max()));
EXPECT_EQ(std::numeric_limits<T>::max(),
SaturatingMultiply(std::numeric_limits<T>::max(),
std::numeric_limits<T>::max()));
}
TEST(MathExtras, SaturatingMultiply) {
SaturatingMultiplyTestHelper<uint8_t>();
SaturatingMultiplyTestHelper<uint16_t>();
SaturatingMultiplyTestHelper<uint32_t>();
SaturatingMultiplyTestHelper<uint64_t>();
}
}