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