[llvm] r297111 - [APInt] Add setLowBits/setHighBits methods to APInt.
Craig Topper via llvm-commits
llvm-commits at lists.llvm.org
Mon Mar 6 17:56:01 PST 2017
Author: ctopper
Date: Mon Mar 6 19:56:01 2017
New Revision: 297111
URL: http://llvm.org/viewvc/llvm-project?rev=297111&view=rev
Log:
[APInt] Add setLowBits/setHighBits methods to APInt.
Summary:
There are quite a few places in the code base that do something like the following to set the high or low bits in an APInt.
KnownZero |= APInt::getHighBitsSet(BitWidth, BitWidth - 1);
For BitWidths larger than 64 this creates a short lived APInt with malloced storage. I think it might even call malloc twice. Its better to just provide methods that can set the necessary bits without the temporary APInt.
I'll update usages that benefit in a separate patch.
Reviewers: majnemer, MatzeB, davide, RKSimon, hans
Reviewed By: hans
Subscribers: llvm-commits
Differential Revision: https://reviews.llvm.org/D30525
Modified:
llvm/trunk/include/llvm/ADT/APInt.h
llvm/trunk/lib/Support/APInt.cpp
llvm/trunk/unittests/ADT/APIntTest.cpp
Modified: llvm/trunk/include/llvm/ADT/APInt.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/APInt.h?rev=297111&r1=297110&r2=297111&view=diff
==============================================================================
--- llvm/trunk/include/llvm/ADT/APInt.h (original)
+++ llvm/trunk/include/llvm/ADT/APInt.h Mon Mar 6 19:56:01 2017
@@ -223,6 +223,9 @@ class LLVM_NODISCARD APInt {
/// out-of-line slow case for countPopulation
unsigned countPopulationSlowCase() const;
+ /// out-of-line slow case for setBits.
+ void setBitsSlowCase(unsigned loBit, unsigned hiBit);
+
public:
/// \name Constructors
/// @{
@@ -1211,7 +1214,32 @@ public:
void setBit(unsigned bitPosition);
/// Set the bits from loBit (inclusive) to hiBit (exclusive) to 1.
- void setBits(unsigned loBit, unsigned hiBit);
+ void setBits(unsigned loBit, unsigned hiBit) {
+ assert(hiBit <= BitWidth && "hiBit out of range");
+ assert(loBit <= hiBit && "loBit out of range");
+ if (loBit == hiBit)
+ return;
+ if (loBit < APINT_BITS_PER_WORD && hiBit <= APINT_BITS_PER_WORD) {
+ uint64_t mask = UINT64_MAX >> (APINT_BITS_PER_WORD - (hiBit - loBit));
+ mask <<= loBit;
+ if (isSingleWord())
+ VAL |= mask;
+ else
+ pVal[0] |= mask;
+ } else {
+ setBitsSlowCase(loBit, hiBit);
+ }
+ }
+
+ /// Set the bottom loBits bits.
+ void setLowBits(unsigned loBits) {
+ return setBits(0, loBits);
+ }
+
+ /// Set the top hiBits bits.
+ void setHighBits(unsigned hiBits) {
+ return setBits(BitWidth - hiBits, BitWidth);
+ }
/// \brief Set every bit to 0.
void clearAllBits() {
Modified: llvm/trunk/lib/Support/APInt.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Support/APInt.cpp?rev=297111&r1=297110&r2=297111&view=diff
==============================================================================
--- llvm/trunk/lib/Support/APInt.cpp (original)
+++ llvm/trunk/lib/Support/APInt.cpp Mon Mar 6 19:56:01 2017
@@ -566,37 +566,31 @@ void APInt::setBit(unsigned bitPosition)
pVal[whichWord(bitPosition)] |= maskBit(bitPosition);
}
-void APInt::setBits(unsigned loBit, unsigned hiBit) {
- assert(hiBit <= BitWidth && "hiBit out of range");
- assert(loBit <= hiBit && loBit <= BitWidth && "loBit out of range");
+void APInt::setBitsSlowCase(unsigned loBit, unsigned hiBit) {
+ unsigned loWord = whichWord(loBit);
+ unsigned hiWord = whichWord(hiBit);
- if (loBit == hiBit)
- return;
+ // Create an initial mask for the low word with zeroes below loBit.
+ uint64_t loMask = UINT64_MAX << whichBit(loBit);
- if (isSingleWord())
- *this |= APInt::getBitsSet(BitWidth, loBit, hiBit);
- else {
- unsigned hiBit1 = hiBit - 1;
- unsigned loWord = whichWord(loBit);
- unsigned hiWord = whichWord(hiBit1);
- if (loWord == hiWord) {
- // Set bits are all within the same word, create a [loBit,hiBit) mask.
- uint64_t mask = UINT64_MAX;
- mask >>= (APINT_BITS_PER_WORD - (hiBit - loBit));
- mask <<= whichBit(loBit);
- pVal[loWord] |= mask;
- } else {
- // Set bits span multiple words, create a lo mask with set bits starting
- // at loBit, a hi mask with set bits below hiBit and set all bits of the
- // words in between.
- uint64_t loMask = UINT64_MAX << whichBit(loBit);
- uint64_t hiMask = UINT64_MAX >> (64 - whichBit(hiBit1) - 1);
- pVal[loWord] |= loMask;
+ // If hiBit is not aligned, we need a high mask.
+ unsigned hiShiftAmt = whichBit(hiBit);
+ if (hiShiftAmt != 0) {
+ // Create a high mask with zeros above hiBit.
+ uint64_t hiMask = UINT64_MAX >> (APINT_BITS_PER_WORD - hiShiftAmt);
+ // If loWord and hiWord are equal, then we combine the masks. Otherwise,
+ // set the bits in hiWord.
+ if (hiWord == loWord)
+ loMask &= hiMask;
+ else
pVal[hiWord] |= hiMask;
- for (unsigned word = loWord + 1; word < hiWord; ++word)
- pVal[word] = UINT64_MAX;
- }
}
+ // Apply the mask to the low word.
+ pVal[loWord] |= loMask;
+
+ // Fill any words between loWord and hiWord with all ones.
+ for (unsigned word = loWord + 1; word < hiWord; ++word)
+ pVal[word] = UINT64_MAX;
}
/// Set the given bit to 0 whose position is given as "bitPosition".
Modified: llvm/trunk/unittests/ADT/APIntTest.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/ADT/APIntTest.cpp?rev=297111&r1=297110&r2=297111&view=diff
==============================================================================
--- llvm/trunk/unittests/ADT/APIntTest.cpp (original)
+++ llvm/trunk/unittests/ADT/APIntTest.cpp Mon Mar 6 19:56:01 2017
@@ -1565,3 +1565,124 @@ TEST(APIntTest, getHighBitsSet) {
EXPECT_EQ(0u, i64hi32.countTrailingOnes());
EXPECT_EQ(32u, i64hi32.countPopulation());
}
+
+TEST(APIntTest, setLowBits) {
+ APInt i64lo32(64, 0);
+ i64lo32.setLowBits(32);
+ EXPECT_EQ(0u, i64lo32.countLeadingOnes());
+ EXPECT_EQ(32u, i64lo32.countLeadingZeros());
+ EXPECT_EQ(32u, i64lo32.getActiveBits());
+ EXPECT_EQ(0u, i64lo32.countTrailingZeros());
+ EXPECT_EQ(32u, i64lo32.countTrailingOnes());
+ EXPECT_EQ(32u, i64lo32.countPopulation());
+
+ APInt i128lo64(128, 0);
+ i128lo64.setLowBits(64);
+ EXPECT_EQ(0u, i128lo64.countLeadingOnes());
+ EXPECT_EQ(64u, i128lo64.countLeadingZeros());
+ EXPECT_EQ(64u, i128lo64.getActiveBits());
+ EXPECT_EQ(0u, i128lo64.countTrailingZeros());
+ EXPECT_EQ(64u, i128lo64.countTrailingOnes());
+ EXPECT_EQ(64u, i128lo64.countPopulation());
+
+ APInt i128lo24(128, 0);
+ i128lo24.setLowBits(24);
+ EXPECT_EQ(0u, i128lo24.countLeadingOnes());
+ EXPECT_EQ(104u, i128lo24.countLeadingZeros());
+ EXPECT_EQ(24u, i128lo24.getActiveBits());
+ EXPECT_EQ(0u, i128lo24.countTrailingZeros());
+ EXPECT_EQ(24u, i128lo24.countTrailingOnes());
+ EXPECT_EQ(24u, i128lo24.countPopulation());
+
+ APInt i128lo104(128, 0);
+ i128lo104.setLowBits(104);
+ EXPECT_EQ(0u, i128lo104.countLeadingOnes());
+ EXPECT_EQ(24u, i128lo104.countLeadingZeros());
+ EXPECT_EQ(104u, i128lo104.getActiveBits());
+ EXPECT_EQ(0u, i128lo104.countTrailingZeros());
+ EXPECT_EQ(104u, i128lo104.countTrailingOnes());
+ EXPECT_EQ(104u, i128lo104.countPopulation());
+
+ APInt i128lo0(128, 0);
+ i128lo0.setLowBits(0);
+ EXPECT_EQ(0u, i128lo0.countLeadingOnes());
+ EXPECT_EQ(128u, i128lo0.countLeadingZeros());
+ EXPECT_EQ(0u, i128lo0.getActiveBits());
+ EXPECT_EQ(128u, i128lo0.countTrailingZeros());
+ EXPECT_EQ(0u, i128lo0.countTrailingOnes());
+ EXPECT_EQ(0u, i128lo0.countPopulation());
+
+ APInt i80lo79(80, 0);
+ i80lo79.setLowBits(79);
+ EXPECT_EQ(0u, i80lo79.countLeadingOnes());
+ EXPECT_EQ(1u, i80lo79.countLeadingZeros());
+ EXPECT_EQ(79u, i80lo79.getActiveBits());
+ EXPECT_EQ(0u, i80lo79.countTrailingZeros());
+ EXPECT_EQ(79u, i80lo79.countTrailingOnes());
+ EXPECT_EQ(79u, i80lo79.countPopulation());
+}
+
+TEST(APIntTest, setHighBits) {
+ APInt i64hi32(64, 0);
+ i64hi32.setHighBits(32);
+ EXPECT_EQ(32u, i64hi32.countLeadingOnes());
+ EXPECT_EQ(0u, i64hi32.countLeadingZeros());
+ EXPECT_EQ(64u, i64hi32.getActiveBits());
+ EXPECT_EQ(32u, i64hi32.countTrailingZeros());
+ EXPECT_EQ(0u, i64hi32.countTrailingOnes());
+ EXPECT_EQ(32u, i64hi32.countPopulation());
+
+ APInt i128hi64(128, 0);
+ i128hi64.setHighBits(64);
+ EXPECT_EQ(64u, i128hi64.countLeadingOnes());
+ EXPECT_EQ(0u, i128hi64.countLeadingZeros());
+ EXPECT_EQ(128u, i128hi64.getActiveBits());
+ EXPECT_EQ(64u, i128hi64.countTrailingZeros());
+ EXPECT_EQ(0u, i128hi64.countTrailingOnes());
+ EXPECT_EQ(64u, i128hi64.countPopulation());
+
+ APInt i128hi24(128, 0);
+ i128hi24.setHighBits(24);
+ EXPECT_EQ(24u, i128hi24.countLeadingOnes());
+ EXPECT_EQ(0u, i128hi24.countLeadingZeros());
+ EXPECT_EQ(128u, i128hi24.getActiveBits());
+ EXPECT_EQ(104u, i128hi24.countTrailingZeros());
+ EXPECT_EQ(0u, i128hi24.countTrailingOnes());
+ EXPECT_EQ(24u, i128hi24.countPopulation());
+
+ APInt i128hi104(128, 0);
+ i128hi104.setHighBits(104);
+ EXPECT_EQ(104u, i128hi104.countLeadingOnes());
+ EXPECT_EQ(0u, i128hi104.countLeadingZeros());
+ EXPECT_EQ(128u, i128hi104.getActiveBits());
+ EXPECT_EQ(24u, i128hi104.countTrailingZeros());
+ EXPECT_EQ(0u, i128hi104.countTrailingOnes());
+ EXPECT_EQ(104u, i128hi104.countPopulation());
+
+ APInt i128hi0(128, 0);
+ i128hi0.setHighBits(0);
+ EXPECT_EQ(0u, i128hi0.countLeadingOnes());
+ EXPECT_EQ(128u, i128hi0.countLeadingZeros());
+ EXPECT_EQ(0u, i128hi0.getActiveBits());
+ EXPECT_EQ(128u, i128hi0.countTrailingZeros());
+ EXPECT_EQ(0u, i128hi0.countTrailingOnes());
+ EXPECT_EQ(0u, i128hi0.countPopulation());
+
+ APInt i80hi1(80, 0);
+ i80hi1.setHighBits(1);
+ EXPECT_EQ(1u, i80hi1.countLeadingOnes());
+ EXPECT_EQ(0u, i80hi1.countLeadingZeros());
+ EXPECT_EQ(80u, i80hi1.getActiveBits());
+ EXPECT_EQ(79u, i80hi1.countTrailingZeros());
+ EXPECT_EQ(0u, i80hi1.countTrailingOnes());
+ EXPECT_EQ(1u, i80hi1.countPopulation());
+
+ APInt i32hi16(32, 0);
+ i32hi16.setHighBits(16);
+ EXPECT_EQ(16u, i32hi16.countLeadingOnes());
+ EXPECT_EQ(0u, i32hi16.countLeadingZeros());
+ EXPECT_EQ(32u, i32hi16.getActiveBits());
+ EXPECT_EQ(16u, i32hi16.countTrailingZeros());
+ EXPECT_EQ(0u, i32hi16.countTrailingOnes());
+ EXPECT_EQ(16u, i32hi16.countPopulation());
+}
More information about the llvm-commits
mailing list