[llvm] r255128 - [Support] Change SaturatingAdd()/SaturatingMultiply() to use pointer for returning overflow state
Nathan Slingerland via llvm-commits
llvm-commits at lists.llvm.org
Wed Dec 9 09:11:29 PST 2015
Author: slingn
Date: Wed Dec 9 11:11:28 2015
New Revision: 255128
URL: http://llvm.org/viewvc/llvm-project?rev=255128&view=rev
Log:
[Support] Change SaturatingAdd()/SaturatingMultiply() to use pointer for returning overflow state
Summary:
Improve SaturatingAdd()/SaturatingMultiply() to use bool * to optionally return overflow result.
This should make it clearer that the value is returned at callsites and reduces the size of the implementation.
Reviewers: davidxl, silvas
Subscribers: llvm-commits
Differential Revision: http://reviews.llvm.org/D15219
Modified:
llvm/trunk/include/llvm/ProfileData/InstrProf.h
llvm/trunk/include/llvm/Support/MathExtras.h
llvm/trunk/unittests/Support/MathExtrasTest.cpp
Modified: llvm/trunk/include/llvm/ProfileData/InstrProf.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ProfileData/InstrProf.h?rev=255128&r1=255127&r2=255128&view=diff
==============================================================================
--- llvm/trunk/include/llvm/ProfileData/InstrProf.h (original)
+++ llvm/trunk/include/llvm/ProfileData/InstrProf.h Wed Dec 9 11:11:28 2015
@@ -435,7 +435,7 @@ instrprof_error InstrProfRecord::merge(I
for (size_t I = 0, E = Other.Counts.size(); I < E; ++I) {
bool ResultOverflowed;
- Counts[I] = SaturatingAdd(Counts[I], Other.Counts[I], ResultOverflowed);
+ Counts[I] = SaturatingAdd(Counts[I], Other.Counts[I], &ResultOverflowed);
if (ResultOverflowed)
Result = instrprof_error::counter_overflow;
}
Modified: llvm/trunk/include/llvm/Support/MathExtras.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Support/MathExtras.h?rev=255128&r1=255127&r2=255128&view=diff
==============================================================================
--- llvm/trunk/include/llvm/Support/MathExtras.h (original)
+++ llvm/trunk/include/llvm/Support/MathExtras.h Wed Dec 9 11:11:28 2015
@@ -659,38 +659,34 @@ inline int64_t SignExtend64(uint64_t X,
/// representable value of type T.
template <typename T>
typename std::enable_if<std::is_unsigned<T>::value, T>::type
-SaturatingAdd(T X, T Y, bool &ResultOverflowed) {
+SaturatingAdd(T X, T Y, bool *ResultOverflowed = nullptr) {
+ bool Dummy;
+ bool &Overflowed = ResultOverflowed ? *ResultOverflowed : Dummy;
// Hacker's Delight, p. 29
T Z = X + Y;
- ResultOverflowed = (Z < X || Z < Y);
- if (ResultOverflowed)
+ Overflowed = (Z < X || Z < Y);
+ if (Overflowed)
return std::numeric_limits<T>::max();
else
return Z;
}
-/// \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) {
- bool ResultOverflowed;
- return SaturatingAdd(X, Y, ResultOverflowed);
-}
-
/// \brief Multiply two unsigned integers, X and Y, of type T.
/// Clamp the result to the maximum representable value of T on overflow.
/// ResultOverflowed indicates if the result is larger than the maximum
/// representable value of type T.
template <typename T>
typename std::enable_if<std::is_unsigned<T>::value, T>::type
-SaturatingMultiply(T X, T Y, bool &ResultOverflowed) {
+SaturatingMultiply(T X, T Y, bool *ResultOverflowed = nullptr) {
+ bool Dummy;
+ bool &Overflowed = ResultOverflowed ? *ResultOverflowed : Dummy;
+
// Hacker's Delight, p. 30 has a different algorithm, but we don't use that
// because it fails for uint16_t (where multiplication can have undefined
// behavior due to promotion to int), and requires a division in addition
// to the multiplication.
- ResultOverflowed = false;
+ Overflowed = false;
// Log2(Z) would be either Log2Z or Log2Z + 1.
// Special case: if X or Y is 0, Log2_64 gives -1, and Log2Z
@@ -702,7 +698,7 @@ SaturatingMultiply(T X, T Y, bool &Resul
return X * Y;
}
if (Log2Z > Log2Max) {
- ResultOverflowed = true;
+ Overflowed = true;
return Max;
}
@@ -711,7 +707,7 @@ SaturatingMultiply(T X, T Y, bool &Resul
// that on at the end.
T Z = (X >> 1) * Y;
if (Z & ~(Max >> 1)) {
- ResultOverflowed = true;
+ Overflowed = true;
return Max;
}
Z <<= 1;
@@ -721,15 +717,6 @@ SaturatingMultiply(T X, T Y, bool &Resul
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) {
- bool ResultOverflowed;
- return SaturatingMultiply(X, Y, ResultOverflowed);
-}
-
extern const float huge_valf;
} // End llvm namespace
Modified: llvm/trunk/unittests/Support/MathExtrasTest.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/Support/MathExtrasTest.cpp?rev=255128&r1=255127&r2=255128&view=diff
==============================================================================
--- llvm/trunk/unittests/Support/MathExtrasTest.cpp (original)
+++ llvm/trunk/unittests/Support/MathExtrasTest.cpp Wed Dec 9 11:11:28 2015
@@ -197,23 +197,23 @@ void SaturatingAddTestHelper()
bool ResultOverflowed;
EXPECT_EQ(T(3), SaturatingAdd(T(1), T(2)));
- EXPECT_EQ(T(3), SaturatingAdd(T(1), T(2), ResultOverflowed));
+ EXPECT_EQ(T(3), SaturatingAdd(T(1), T(2), &ResultOverflowed));
EXPECT_FALSE(ResultOverflowed);
EXPECT_EQ(Max, SaturatingAdd(Max, T(1)));
- EXPECT_EQ(Max, SaturatingAdd(Max, T(1), ResultOverflowed));
+ EXPECT_EQ(Max, SaturatingAdd(Max, T(1), &ResultOverflowed));
EXPECT_TRUE(ResultOverflowed);
EXPECT_EQ(Max, SaturatingAdd(T(1), T(Max - 1)));
- EXPECT_EQ(Max, SaturatingAdd(T(1), T(Max - 1), ResultOverflowed));
+ EXPECT_EQ(Max, SaturatingAdd(T(1), T(Max - 1), &ResultOverflowed));
EXPECT_FALSE(ResultOverflowed);
EXPECT_EQ(Max, SaturatingAdd(T(1), Max));
- EXPECT_EQ(Max, SaturatingAdd(T(1), Max, ResultOverflowed));
+ EXPECT_EQ(Max, SaturatingAdd(T(1), Max, &ResultOverflowed));
EXPECT_TRUE(ResultOverflowed);
EXPECT_EQ(Max, SaturatingAdd(Max, Max));
- EXPECT_EQ(Max, SaturatingAdd(Max, Max, ResultOverflowed));
+ EXPECT_EQ(Max, SaturatingAdd(Max, Max, &ResultOverflowed));
EXPECT_TRUE(ResultOverflowed);
}
@@ -232,45 +232,45 @@ void SaturatingMultiplyTestHelper()
// Test basic multiplication.
EXPECT_EQ(T(6), SaturatingMultiply(T(2), T(3)));
- EXPECT_EQ(T(6), SaturatingMultiply(T(2), T(3), ResultOverflowed));
+ EXPECT_EQ(T(6), SaturatingMultiply(T(2), T(3), &ResultOverflowed));
EXPECT_FALSE(ResultOverflowed);
EXPECT_EQ(T(6), SaturatingMultiply(T(3), T(2)));
- EXPECT_EQ(T(6), SaturatingMultiply(T(3), T(2), ResultOverflowed));
+ EXPECT_EQ(T(6), SaturatingMultiply(T(3), T(2), &ResultOverflowed));
EXPECT_FALSE(ResultOverflowed);
// Test multiplication by zero.
EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(0)));
- EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(0), ResultOverflowed));
+ EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(0), &ResultOverflowed));
EXPECT_FALSE(ResultOverflowed);
EXPECT_EQ(T(0), SaturatingMultiply(T(1), T(0)));
- EXPECT_EQ(T(0), SaturatingMultiply(T(1), T(0), ResultOverflowed));
+ EXPECT_EQ(T(0), SaturatingMultiply(T(1), T(0), &ResultOverflowed));
EXPECT_FALSE(ResultOverflowed);
EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(1)));
- EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(1), ResultOverflowed));
+ EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(1), &ResultOverflowed));
EXPECT_FALSE(ResultOverflowed);
EXPECT_EQ(T(0), SaturatingMultiply(Max, T(0)));
- EXPECT_EQ(T(0), SaturatingMultiply(Max, T(0), ResultOverflowed));
+ EXPECT_EQ(T(0), SaturatingMultiply(Max, T(0), &ResultOverflowed));
EXPECT_FALSE(ResultOverflowed);
EXPECT_EQ(T(0), SaturatingMultiply(T(0), Max));
- EXPECT_EQ(T(0), SaturatingMultiply(T(0), Max, ResultOverflowed));
+ EXPECT_EQ(T(0), SaturatingMultiply(T(0), Max, &ResultOverflowed));
EXPECT_FALSE(ResultOverflowed);
// Test multiplication by maximum value.
EXPECT_EQ(Max, SaturatingMultiply(Max, T(2)));
- EXPECT_EQ(Max, SaturatingMultiply(Max, T(2), ResultOverflowed));
+ EXPECT_EQ(Max, SaturatingMultiply(Max, T(2), &ResultOverflowed));
EXPECT_TRUE(ResultOverflowed);
EXPECT_EQ(Max, SaturatingMultiply(T(2), Max));
- EXPECT_EQ(Max, SaturatingMultiply(T(2), Max, ResultOverflowed));
+ EXPECT_EQ(Max, SaturatingMultiply(T(2), Max, &ResultOverflowed));
EXPECT_TRUE(ResultOverflowed);
EXPECT_EQ(Max, SaturatingMultiply(Max, Max));
- EXPECT_EQ(Max, SaturatingMultiply(Max, Max, ResultOverflowed));
+ EXPECT_EQ(Max, SaturatingMultiply(Max, Max, &ResultOverflowed));
EXPECT_TRUE(ResultOverflowed);
// Test interesting boundary conditions for algorithm -
@@ -286,11 +286,11 @@ void SaturatingMultiplyTestHelper()
if(OverflowExpected) {
EXPECT_EQ(Max, SaturatingMultiply(X, Y));
- EXPECT_EQ(Max, SaturatingMultiply(X, Y, ResultOverflowed));
+ EXPECT_EQ(Max, SaturatingMultiply(X, Y, &ResultOverflowed));
EXPECT_TRUE(ResultOverflowed);
} else {
EXPECT_EQ(X * Y, SaturatingMultiply(X, Y));
- EXPECT_EQ(X * Y, SaturatingMultiply(X, Y, ResultOverflowed));
+ EXPECT_EQ(X * Y, SaturatingMultiply(X, Y, &ResultOverflowed));
EXPECT_FALSE(ResultOverflowed);
}
}
More information about the llvm-commits
mailing list