#define LLVM_APINT_H
#include "llvm/Support/DataTypes.h"
+#include "llvm/Support/MathExtras.h"
#include <cassert>
#include <iosfwd>
#include <string>
///
/// @brief Class for arbitrary precision integers.
class APInt {
-
uint32_t BitWidth; ///< The number of bits in this APInt.
/// This union is used to store the integer value. When the
const APInt &RHS, uint32_t rhsWords,
APInt *Quotient, APInt *Remainder);
+ /// out-of-line slow case for inline constructor
+ void initSlowCase(uint32_t numBits, uint64_t val, bool isSigned);
+
+ /// out-of-line slow case for inline copy constructor
+ void initSlowCase(const APInt& that);
+
+ /// out-of-line slow case for shl
+ APInt shlSlowCase(uint32_t shiftAmt) const;
+
+ /// out-of-line slow case for operator&
+ APInt AndSlowCase(const APInt& RHS) const;
+
+ /// out-of-line slow case for operator|
+ APInt OrSlowCase(const APInt& RHS) const;
+
+ /// out-of-line slow case for operator^
+ APInt XorSlowCase(const APInt& RHS) const;
+
+ /// out-of-line slow case for operator=
+ APInt& AssignSlowCase(const APInt& RHS);
+
+ /// out-of-line slow case for operator==
+ bool EqualSlowCase(const APInt& RHS) const;
+
+ /// out-of-line slow case for operator==
+ bool EqualSlowCase(uint64_t Val) const;
+
+ /// out-of-line slow case for countLeadingZeros
+ uint32_t countLeadingZerosSlowCase() const;
+
+ /// out-of-line slow case for countTrailingOnes
+ uint32_t countTrailingOnesSlowCase() const;
+
+ /// out-of-line slow case for countPopulation
+ uint32_t countPopulationSlowCase() const;
+
public:
/// @name Constructors
/// @{
/// @param val the initial value of the APInt
/// @param isSigned how to treat signedness of val
/// @brief Create a new APInt of numBits width, initialized as val.
- APInt(uint32_t numBits, uint64_t val, bool isSigned = false);
+ APInt(uint32_t numBits, uint64_t val, bool isSigned = false)
+ : BitWidth(numBits), VAL(0) {
+ assert(BitWidth && "bitwidth too small");
+ if (isSingleWord())
+ VAL = val;
+ else
+ initSlowCase(numBits, val, isSigned);
+ clearUnusedBits();
+ }
/// Note that numWords can be smaller or larger than the corresponding bit
/// width but any extraneous bits will be dropped.
/// Simply makes *this a copy of that.
/// @brief Copy Constructor.
- APInt(const APInt& that);
+ APInt(const APInt& that)
+ : BitWidth(that.BitWidth), VAL(0) {
+ assert(BitWidth && "bitwidth too small");
+ if (isSingleWord())
+ VAL = that.VAL;
+ else
+ initSlowCase(that);
+ }
/// @brief Destructor.
- ~APInt();
-
+ ~APInt() {
+ if (!isSingleWord())
+ delete [] pVal;
+ }
+
/// Default constructor that creates an uninitialized APInt. This is useful
/// for object deserialization (pair this with the static method Read).
explicit APInt() : BitWidth(1) {}
/// @param numBits the bitwidth of the result
/// @param loBitsSet the number of low-order bits set in the result.
/// @brief Get a value with low bits set
+ // XXX why isn't this inlining?
static APInt getLowBitsSet(uint32_t numBits, uint32_t loBitsSet) {
assert(loBitsSet <= numBits && "Too many bits to set!");
// Handle a degenerate case, to avoid shifting by word size
/// Performs a bitwise complement operation on this APInt.
/// @returns an APInt that is the bitwise complement of *this
/// @brief Unary bitwise complement operator.
- APInt operator~() const;
+ APInt operator~() const {
+ APInt Result(*this);
+ Result.flip();
+ return Result;
+ }
/// Negates *this using two's complement logic.
/// @returns An APInt value representing the negation of *this.
/// @{
/// @returns *this after assignment of RHS.
/// @brief Copy assignment operator.
- APInt& operator=(const APInt& RHS);
+ APInt& operator=(const APInt& RHS) {
+ // If the bitwidths are the same, we can avoid mucking with memory
+ if (isSingleWord() && RHS.isSingleWord()) {
+ VAL = RHS.VAL;
+ BitWidth = RHS.BitWidth;
+ return clearUnusedBits();
+ }
+
+ return AssignSlowCase(RHS);
+ }
/// The RHS value is assigned to *this. If the significant bits in RHS exceed
/// the bit width, the excess bits are truncated. If the bit width is larger
/// Performs a bitwise AND operation on *this and RHS.
/// @returns An APInt value representing the bitwise AND of *this and RHS.
/// @brief Bitwise AND operator.
- APInt operator&(const APInt& RHS) const;
+ APInt operator&(const APInt& RHS) const {
+ assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
+ if (isSingleWord())
+ return APInt(getBitWidth(), VAL & RHS.VAL);
+ return AndSlowCase(RHS);
+ }
APInt And(const APInt& RHS) const {
return this->operator&(RHS);
}
/// Performs a bitwise OR operation on *this and RHS.
/// @returns An APInt value representing the bitwise OR of *this and RHS.
/// @brief Bitwise OR operator.
- APInt operator|(const APInt& RHS) const;
+ APInt operator|(const APInt& RHS) const {
+ assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
+ if (isSingleWord())
+ return APInt(getBitWidth(), VAL | RHS.VAL);
+ return OrSlowCase(RHS);
+ }
APInt Or(const APInt& RHS) const {
return this->operator|(RHS);
}
/// Performs a bitwise XOR operation on *this and RHS.
/// @returns An APInt value representing the bitwise XOR of *this and RHS.
/// @brief Bitwise XOR operator.
- APInt operator^(const APInt& RHS) const;
+ APInt operator^(const APInt& RHS) const {
+ assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
+ if (isSingleWord())
+ return APInt(BitWidth, VAL ^ RHS.VAL);
+ return XorSlowCase(RHS);
+ }
APInt Xor(const APInt& RHS) const {
return this->operator^(RHS);
}
/// Left-shift this APInt by shiftAmt.
/// @brief Left-shift function.
- APInt shl(uint32_t shiftAmt) const;
+ APInt shl(uint32_t shiftAmt) const {
+ assert(shiftAmt <= BitWidth && "Invalid shift amount");
+ if (isSingleWord()) {
+ if (shiftAmt == BitWidth)
+ return APInt(BitWidth, 0); // avoid undefined shift results
+ return APInt(BitWidth, VAL << shiftAmt);
+ }
+ return shlSlowCase(shiftAmt);
+ }
/// @brief Rotate left by rotateAmt.
APInt rotl(uint32_t rotateAmt) const;
/// Compares this APInt with RHS for the validity of the equality
/// relationship.
/// @brief Equality operator.
- bool operator==(const APInt& RHS) const;
+ bool operator==(const APInt& RHS) const {
+ assert(BitWidth == RHS.BitWidth && "Comparison requires equal bit widths");
+ if (isSingleWord())
+ return VAL == RHS.VAL;
+ return EqualSlowCase(RHS);
+ }
/// Compares this APInt with a uint64_t for the validity of the equality
/// relationship.
/// @returns true if *this == Val
/// @brief Equality operator.
- bool operator==(uint64_t Val) const;
+ bool operator==(uint64_t Val) const {
+ if (isSingleWord())
+ return VAL == Val;
+ return EqualSlowCase(Val);
+ }
/// Compares this APInt with RHS for the validity of the equality
/// relationship.
/// @name Bit Manipulation Operators
/// @{
/// @brief Set every bit to 1.
- APInt& set();
+ APInt& set() {
+ if (isSingleWord()) {
+ VAL = -1ULL;
+ return clearUnusedBits();
+ }
+
+ // Set all the bits in all the words.
+ for (uint32_t i = 0; i < getNumWords(); ++i)
+ pVal[i] = -1ULL;
+ // Clear the unused ones
+ return clearUnusedBits();
+ }
/// Set the given bit to 1 whose position is given as "bitPosition".
/// @brief Set a given bit to 1.
APInt& set(uint32_t bitPosition);
/// @brief Set every bit to 0.
- APInt& clear();
+ APInt& clear() {
+ if (isSingleWord())
+ VAL = 0;
+ else
+ memset(pVal, 0, getNumWords() * APINT_WORD_SIZE);
+ return *this;
+ }
/// Set the given bit to 0 whose position is given as "bitPosition".
/// @brief Set a given bit to 0.
APInt& clear(uint32_t bitPosition);
/// @brief Toggle every bit to its opposite value.
- APInt& flip();
+ APInt& flip() {
+ if (isSingleWord()) {
+ VAL ^= -1ULL;
+ return clearUnusedBits();
+ }
+ for (uint32_t i = 0; i < getNumWords(); ++i)
+ pVal[i] ^= -1ULL;
+ return clearUnusedBits();
+ }
/// Toggle a given bit to its opposite value whose position is given
/// as "bitPosition".
/// @returns BitWidth if the value is zero.
/// @returns the number of zeros from the most significant bit to the first
/// one bits.
- uint32_t countLeadingZeros() const;
+ uint32_t countLeadingZeros() const {
+ if (isSingleWord()) {
+ uint32_t unusedBits = APINT_BITS_PER_WORD - BitWidth;
+ return CountLeadingZeros_64(VAL) - unusedBits;
+ }
+ return countLeadingZerosSlowCase();
+ }
/// countLeadingOnes - This function is an APInt version of the
/// countLeadingOnes_{32,64} functions in MathExtras.h. It counts the number
/// @returns the number of ones from the least significant bit to the first
/// zero bit.
/// @brief Count the number of trailing one bits.
- uint32_t countTrailingOnes() const;
+ uint32_t countTrailingOnes() const {
+ if (isSingleWord())
+ return CountTrailingOnes_64(VAL);
+ return countTrailingOnesSlowCase();
+ }
/// countPopulation - This function is an APInt version of the
/// countPopulation_{32,64} functions in MathExtras.h. It counts the number
/// @returns 0 if the value is zero.
/// @returns the number of set bits.
/// @brief Count the number of bits set.
- uint32_t countPopulation() const;
+ uint32_t countPopulation() const {
+ if (isSingleWord())
+ return CountPopulation_64(VAL);
+ return countPopulationSlowCase();
+ }
/// @}
/// @name Conversion Functions
/// of a number. If the input number has no bits set -1U is
/// returned.
static unsigned int tcLSB(const integerPart *, unsigned int);
- static unsigned int tcMSB(const integerPart *, unsigned int);
+ static unsigned int tcMSB(const integerPart *parts, unsigned int n);
/// Negate a bignum in-place.
static void tcNegate(integerPart *, unsigned int);
#include <cstdlib>
using namespace llvm;
-/// This enumeration just provides for internal constants used in this
-/// translation unit.
-enum {
- MIN_INT_BITS = 1, ///< Minimum number of bits that can be specified
- ///< Note that this must remain synchronized with IntegerType::MIN_INT_BITS
- MAX_INT_BITS = (1<<23)-1 ///< Maximum number of bits that can be specified
- ///< Note that this must remain synchronized with IntegerType::MAX_INT_BITS
-};
-
/// A utility function for allocating memory, checking for allocation failures,
/// and ensuring the contents are zeroed.
inline static uint64_t* getClearedMemory(uint32_t numWords) {
return result;
}
-APInt::APInt(uint32_t numBits, uint64_t val, bool isSigned)
- : BitWidth(numBits), VAL(0) {
- assert(BitWidth >= MIN_INT_BITS && "bitwidth too small");
- assert(BitWidth <= MAX_INT_BITS && "bitwidth too large");
- if (isSingleWord())
- VAL = val;
- else {
- pVal = getClearedMemory(getNumWords());
- pVal[0] = val;
- if (isSigned && int64_t(val) < 0)
- for (unsigned i = 1; i < getNumWords(); ++i)
- pVal[i] = -1ULL;
- }
- clearUnusedBits();
+void APInt::initSlowCase(uint32_t numBits, uint64_t val, bool isSigned)
+{
+ pVal = getClearedMemory(getNumWords());
+ pVal[0] = val;
+ if (isSigned && int64_t(val) < 0)
+ for (unsigned i = 1; i < getNumWords(); ++i)
+ pVal[i] = -1ULL;
}
APInt::APInt(uint32_t numBits, uint32_t numWords, const uint64_t bigVal[])
: BitWidth(numBits), VAL(0) {
- assert(BitWidth >= MIN_INT_BITS && "bitwidth too small");
- assert(BitWidth <= MAX_INT_BITS && "bitwidth too large");
+ assert(BitWidth && "bitwidth too small");
assert(bigVal && "Null pointer detected!");
if (isSingleWord())
VAL = bigVal[0];
APInt::APInt(uint32_t numbits, const char StrStart[], uint32_t slen,
uint8_t radix)
: BitWidth(numbits), VAL(0) {
- assert(BitWidth >= MIN_INT_BITS && "bitwidth too small");
- assert(BitWidth <= MAX_INT_BITS && "bitwidth too large");
+ assert(BitWidth && "bitwidth too small");
fromString(numbits, StrStart, slen, radix);
}
-APInt::APInt(const APInt& that)
- : BitWidth(that.BitWidth), VAL(0) {
- assert(BitWidth >= MIN_INT_BITS && "bitwidth too small");
- assert(BitWidth <= MAX_INT_BITS && "bitwidth too large");
- if (isSingleWord())
- VAL = that.VAL;
- else {
- pVal = getMemory(getNumWords());
- memcpy(pVal, that.pVal, getNumWords() * APINT_WORD_SIZE);
- }
-}
-
-APInt::~APInt() {
- if (!isSingleWord())
- delete [] pVal;
+void APInt::initSlowCase(const APInt& that)
+{
+ pVal = getMemory(getNumWords());
+ memcpy(pVal, that.pVal, getNumWords() * APINT_WORD_SIZE);
}
-APInt& APInt::operator=(const APInt& RHS) {
+APInt& APInt::AssignSlowCase(const APInt& RHS) {
// Don't do anything for X = X
if (this == &RHS)
return *this;
- // If the bitwidths are the same, we can avoid mucking with memory
if (BitWidth == RHS.getBitWidth()) {
- if (isSingleWord())
- VAL = RHS.VAL;
- else
- memcpy(pVal, RHS.pVal, getNumWords() * APINT_WORD_SIZE);
+ // assume same bit-width single-word case is already handled
+ assert(!isSingleWord());
+ memcpy(pVal, RHS.pVal, getNumWords() * APINT_WORD_SIZE);
return *this;
}
- if (isSingleWord())
- if (RHS.isSingleWord())
- VAL = RHS.VAL;
- else {
- VAL = 0;
- pVal = getMemory(RHS.getNumWords());
- memcpy(pVal, RHS.pVal, RHS.getNumWords() * APINT_WORD_SIZE);
- }
- else if (getNumWords() == RHS.getNumWords())
+ if (isSingleWord()) {
+ // assume case where both are single words is already handled
+ assert(!RHS.isSingleWord());
+ VAL = 0;
+ pVal = getMemory(RHS.getNumWords());
+ memcpy(pVal, RHS.pVal, RHS.getNumWords() * APINT_WORD_SIZE);
+ } else if (getNumWords() == RHS.getNumWords())
memcpy(pVal, RHS.pVal, RHS.getNumWords() * APINT_WORD_SIZE);
else if (RHS.isSingleWord()) {
delete [] pVal;
return clearUnusedBits();
}
-APInt APInt::operator&(const APInt& RHS) const {
- assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
- if (isSingleWord())
- return APInt(getBitWidth(), VAL & RHS.VAL);
-
+APInt APInt::AndSlowCase(const APInt& RHS) const {
uint32_t numWords = getNumWords();
uint64_t* val = getMemory(numWords);
for (uint32_t i = 0; i < numWords; ++i)
return APInt(val, getBitWidth());
}
-APInt APInt::operator|(const APInt& RHS) const {
- assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
- if (isSingleWord())
- return APInt(getBitWidth(), VAL | RHS.VAL);
-
+APInt APInt::OrSlowCase(const APInt& RHS) const {
uint32_t numWords = getNumWords();
uint64_t *val = getMemory(numWords);
for (uint32_t i = 0; i < numWords; ++i)
return APInt(val, getBitWidth());
}
-APInt APInt::operator^(const APInt& RHS) const {
- assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
- if (isSingleWord())
- return APInt(BitWidth, VAL ^ RHS.VAL);
-
+APInt APInt::XorSlowCase(const APInt& RHS) const {
uint32_t numWords = getNumWords();
uint64_t *val = getMemory(numWords);
for (uint32_t i = 0; i < numWords; ++i)
(isSingleWord() ? VAL : pVal[whichWord(bitPosition)])) != 0;
}
-bool APInt::operator==(const APInt& RHS) const {
- assert(BitWidth == RHS.BitWidth && "Comparison requires equal bit widths");
- if (isSingleWord())
- return VAL == RHS.VAL;
-
+bool APInt::EqualSlowCase(const APInt& RHS) const {
// Get some facts about the number of bits used in the two operands.
uint32_t n1 = getActiveBits();
uint32_t n2 = RHS.getActiveBits();
return true;
}
-bool APInt::operator==(uint64_t Val) const {
- if (isSingleWord())
- return VAL == Val;
-
+bool APInt::EqualSlowCase(uint64_t Val) const {
uint32_t n = getActiveBits();
if (n <= APINT_BITS_PER_WORD)
return pVal[0] == Val;
return *this;
}
-APInt& APInt::set() {
- if (isSingleWord()) {
- VAL = -1ULL;
- return clearUnusedBits();
- }
-
- // Set all the bits in all the words.
- for (uint32_t i = 0; i < getNumWords(); ++i)
- pVal[i] = -1ULL;
- // Clear the unused ones
- return clearUnusedBits();
-}
-
/// Set the given bit to 0 whose position is given as "bitPosition".
/// @brief Set a given bit to 0.
APInt& APInt::clear(uint32_t bitPosition) {
return *this;
}
-/// @brief Set every bit to 0.
-APInt& APInt::clear() {
- if (isSingleWord())
- VAL = 0;
- else
- memset(pVal, 0, getNumWords() * APINT_WORD_SIZE);
- return *this;
-}
-
-/// @brief Bitwise NOT operator. Performs a bitwise logical NOT operation on
-/// this APInt.
-APInt APInt::operator~() const {
- APInt Result(*this);
- Result.flip();
- return Result;
-}
-
/// @brief Toggle every bit to its opposite value.
-APInt& APInt::flip() {
- if (isSingleWord()) {
- VAL ^= -1ULL;
- return clearUnusedBits();
- }
- for (uint32_t i = 0; i < getNumWords(); ++i)
- pVal[i] ^= -1ULL;
- return clearUnusedBits();
-}
/// Toggle a given bit to its opposite value whose position is given
/// as "bitPosition".
return (!!*this) && !(*this & (*this - APInt(BitWidth,1)));
}
-uint32_t APInt::countLeadingZeros() const {
+uint32_t APInt::countLeadingZerosSlowCase() const {
uint32_t Count = 0;
- if (isSingleWord())
- Count = CountLeadingZeros_64(VAL);
- else {
- for (uint32_t i = getNumWords(); i > 0u; --i) {
- if (pVal[i-1] == 0)
- Count += APINT_BITS_PER_WORD;
- else {
- Count += CountLeadingZeros_64(pVal[i-1]);
- break;
- }
+ for (uint32_t i = getNumWords(); i > 0u; --i) {
+ if (pVal[i-1] == 0)
+ Count += APINT_BITS_PER_WORD;
+ else {
+ Count += CountLeadingZeros_64(pVal[i-1]);
+ break;
}
}
uint32_t remainder = BitWidth % APINT_BITS_PER_WORD;
return std::min(Count, BitWidth);
}
-uint32_t APInt::countTrailingOnes() const {
- if (isSingleWord())
- return std::min(uint32_t(CountTrailingOnes_64(VAL)), BitWidth);
+uint32_t APInt::countTrailingOnesSlowCase() const {
uint32_t Count = 0;
uint32_t i = 0;
for (; i < getNumWords() && pVal[i] == -1ULL; ++i)
return std::min(Count, BitWidth);
}
-uint32_t APInt::countPopulation() const {
- if (isSingleWord())
- return CountPopulation_64(VAL);
+uint32_t APInt::countPopulationSlowCase() const {
uint32_t Count = 0;
for (uint32_t i = 0; i < getNumWords(); ++i)
Count += CountPopulation_64(pVal[i]);
// Truncate to new width.
APInt &APInt::trunc(uint32_t width) {
assert(width < BitWidth && "Invalid APInt Truncate request");
- assert(width >= MIN_INT_BITS && "Can't truncate to 0 bits");
+ assert(width && "Can't truncate to 0 bits");
uint32_t wordsBefore = getNumWords();
BitWidth = width;
uint32_t wordsAfter = getNumWords();
// Sign extend to a new width.
APInt &APInt::sext(uint32_t width) {
assert(width > BitWidth && "Invalid APInt SignExtend request");
- assert(width <= MAX_INT_BITS && "Too many bits");
// If the sign bit isn't set, this is the same as zext.
if (!isNegative()) {
zext(width);
// Zero extend to a new width.
APInt &APInt::zext(uint32_t width) {
assert(width > BitWidth && "Invalid APInt ZeroExtend request");
- assert(width <= MAX_INT_BITS && "Too many bits");
uint32_t wordsBefore = getNumWords();
BitWidth = width;
uint32_t wordsAfter = getNumWords();
return shl((uint32_t)shiftAmt.getLimitedValue(BitWidth));
}
-/// Left-shift this APInt by shiftAmt.
-/// @brief Left-shift function.
-APInt APInt::shl(uint32_t shiftAmt) const {
- assert(shiftAmt <= BitWidth && "Invalid shift amount");
- if (isSingleWord()) {
- if (shiftAmt == BitWidth)
- return APInt(BitWidth, 0); // avoid undefined shift results
- return APInt(BitWidth, VAL << shiftAmt);
- }
-
+APInt APInt::shlSlowCase(uint32_t shiftAmt) const {
// If all the bits were shifted out, the result is 0. This avoids issues
// with shifting by the size of the integer type, which produces undefined
// results. We define these "undefined results" to always be 0.
projects / oota-llvm.git / commitdiff