-//===-- llvm/Support/APInt.h - For Arbitrary Precision Integer -*- C++ -*--===//
+//===-- llvm/ADT/APInt.h - For Arbitrary Precision Integer -----*- C++ -*--===//
//
// The LLVM Compiler Infrastructure
//
-// This file was developed by Sheng Zhou and is distributed under the
-// University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
#define LLVM_APINT_H
#include "llvm/Support/DataTypes.h"
+#include "llvm/Support/MathExtras.h"
#include <cassert>
+#include <cstring>
+#include <iosfwd>
#include <string>
-
-#define COMPILE_TIME_ASSERT(cond) extern int CTAssert[(cond) ? 1 : -1]
+#include <cstring>
namespace llvm {
-
+ class Serializer;
+ class Deserializer;
+ class FoldingSetNodeID;
+
+ template<typename T>
+ class SmallVectorImpl;
+
/* An unsigned host type used as a single part of a multi-part
bignum. */
typedef uint64_t integerPart;
const unsigned int host_char_bit = 8;
- const unsigned int integerPartWidth = host_char_bit * sizeof(integerPart);
+ const unsigned int integerPartWidth = host_char_bit *
+ static_cast<unsigned int>(sizeof(integerPart));
//===----------------------------------------------------------------------===//
// APInt Class
///
/// @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
/// This enum is used to hold the constants we needed for APInt.
enum {
- APINT_BITS_PER_WORD = sizeof(uint64_t) * 8, ///< Bits in a word
- APINT_WORD_SIZE = sizeof(uint64_t) ///< Byte size of a word
+ /// Bits in a word
+ APINT_BITS_PER_WORD = static_cast<unsigned int>(sizeof(uint64_t)) * 8,
+ /// Byte size of a word
+ APINT_WORD_SIZE = static_cast<unsigned int>(sizeof(uint64_t))
};
/// This constructor is used only internally for speed of construction of
/// @returns true if the number of bits <= 64, false otherwise.
/// @brief Determine if this APInt just has one word to store value.
- inline bool isSingleWord() const {
+ bool isSingleWord() const {
return BitWidth <= APINT_BITS_PER_WORD;
}
/// @returns the word position for the specified bit position.
/// @brief Determine which word a bit is in.
- static inline uint32_t whichWord(uint32_t bitPosition) {
+ static uint32_t whichWord(uint32_t bitPosition) {
return bitPosition / APINT_BITS_PER_WORD;
}
/// @returns the bit position in a word for the specified bit position
/// in the APInt.
/// @brief Determine which bit in a word a bit is in.
- static inline uint32_t whichBit(uint32_t bitPosition) {
+ static uint32_t whichBit(uint32_t bitPosition) {
return bitPosition % APINT_BITS_PER_WORD;
}
/// corresponding word.
/// @returns a uint64_t with only bit at "whichBit(bitPosition)" set
/// @brief Get a single bit mask.
- static inline uint64_t maskBit(uint32_t bitPosition) {
+ static uint64_t maskBit(uint32_t bitPosition) {
return 1ULL << whichBit(bitPosition);
}
/// significant word is assigned a value to ensure that those bits are
/// zero'd out.
/// @brief Clear unused high order bits
- inline APInt& clearUnusedBits() {
+ APInt& clearUnusedBits() {
// Compute how many bits are used in the final word
uint32_t wordBits = BitWidth % APINT_BITS_PER_WORD;
if (wordBits == 0)
// If all bits are used, we want to leave the value alone. This also
- // avoids the undefined behavior of >> when the shfit is the same size as
+ // avoids the undefined behavior of >> when the shift is the same size as
// the word size (64).
return *this;
- // Mask out the hight bits.
+ // Mask out the high bits.
uint64_t mask = ~uint64_t(0ULL) >> (APINT_BITS_PER_WORD - wordBits);
if (isSingleWord())
VAL &= mask;
/// @returns the corresponding word for the specified bit position.
/// @brief Get the word corresponding to a bit position
- inline uint64_t getWord(uint32_t bitPosition) const {
+ uint64_t getWord(uint32_t bitPosition) const {
return isSingleWord() ? VAL : pVal[whichWord(bitPosition)];
}
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.
/// @param numWords the number of words in bigVal
/// @param bigVal a sequence of words to form the initial value of the APInt
/// @brief Construct an APInt of numBits width, initialized as bigVal[].
- APInt(uint32_t numBits, uint32_t numWords, uint64_t bigVal[]);
-
- /// This constructor interprets Val as a string in the given radix. The
- /// interpretation stops when the first charater that is not suitable for the
- /// radix is encountered. Acceptable radix values are 2, 8, 10 and 16. It is
- /// an error for the value implied by the string to require more bits than
- /// numBits.
- /// @param numBits the bit width of the constructed APInt
- /// @param val the string to be interpreted
- /// @param radix the radix of Val to use for the intepretation
- /// @brief Construct an APInt from a string representation.
- APInt(uint32_t numBits, const std::string& val, uint8_t radix);
+ APInt(uint32_t numBits, uint32_t numWords, const uint64_t bigVal[]);
/// This constructor interprets the slen characters starting at StrStart as
/// a string in the given radix. The interpretation stops when the first
/// 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) {}
+
+ /// Profile - Used to insert APInt objects, or objects that contain APInt
+ /// objects, into FoldingSets.
+ void Profile(FoldingSetNodeID& id) const;
+
+ /// @brief Used by the Bitcode serializer to emit APInts to Bitcode.
+ void Emit(Serializer& S) const;
+
+ /// @brief Used by the Bitcode deserializer to deserialize APInts.
+ void Read(Deserializer& D);
/// @}
/// @name Value Tests
}
/// This tests the high bit of the APInt to determine if it is unset.
- /// @brief Determine if this APInt Value is positive (not negative).
- bool isPositive() const {
+ /// @brief Determine if this APInt Value is non-negative (>= 0)
+ bool isNonNegative() const {
return !isNegative();
}
- /// This tests if the value of this APInt is strictly positive (> 0).
- /// @returns true if this APInt is Positive and not zero.
- /// @brief Determine if this APInt Value is strictly positive.
- inline bool isStrictlyPositive() const {
- return isPositive() && (*this) != 0;
+ /// This tests if the value of this APInt is positive (> 0). Note
+ /// that 0 is not a positive value.
+ /// @returns true if this APInt is positive.
+ /// @brief Determine if this APInt Value is positive.
+ bool isStrictlyPositive() const {
+ return isNonNegative() && (*this) != 0;
}
/// This checks to see if the value has all bits of the APInt are set or not.
/// @brief Determine if all bits are set
- inline bool isAllOnesValue() const {
+ bool isAllOnesValue() const {
return countPopulation() == BitWidth;
}
isNegative() && countPopulation() == 1;
}
- /// @brief Check if this APInt has an N-bits integer value.
- inline bool isIntN(uint32_t N) const {
+ /// @brief Check if this APInt has an N-bits unsigned integer value.
+ bool isIntN(uint32_t N) const {
assert(N && "N == 0 ???");
if (isSingleWord()) {
return VAL == (VAL & (~0ULL >> (64 - N)));
}
}
+ /// @brief Check if this APInt has an N-bits signed integer value.
+ bool isSignedIntN(uint32_t N) const {
+ assert(N && "N == 0 ???");
+ return getMinSignedBits() <= N;
+ }
+
/// @returns true if the argument APInt value is a power of two > 0.
bool isPowerOf2() const;
/// This converts the APInt to a boolean value as a test against zero.
/// @brief Boolean conversion function.
- inline bool getBoolValue() const {
+ bool getBoolValue() const {
return *this != 0;
}
/// getSignBit - This is just a wrapper function of getSignedMinValue(), and
/// it helps code readability when we want to get a SignBit.
/// @brief Get the SignBit for a specific bit width.
- inline static APInt getSignBit(uint32_t BitWidth) {
+ static APInt getSignBit(uint32_t BitWidth) {
return getSignedMinValue(BitWidth);
}
APInt getLoBits(uint32_t numBits) const;
/// Constructs an APInt value that has a contiguous range of bits set. The
- /// bits from loBit to hiBit will be set. All other bits will be zero. For
- /// example, with parameters(32, 15, 0) you would get 0x0000FFFF. If hiBit is
- /// less than loBit then the set bits "wrap". For example, with
- /// parameters (32, 3, 28), you would get 0xF000000F.
+ /// bits from loBit (inclusive) to hiBit (exclusive) will be set. All other
+ /// bits will be zero. For example, with parameters(32, 0, 16) you would get
+ /// 0x0000FFFF. If hiBit is less than loBit then the set bits "wrap". For
+ /// example, with parameters (32, 28, 4), you would get 0xF000000F.
/// @param numBits the intended bit width of the result
/// @param loBit the index of the lowest bit set.
/// @param hiBit the index of the highest bit set.
/// @returns An APInt value with the requested bits set.
/// @brief Get a value with a block of bits set.
static APInt getBitsSet(uint32_t numBits, uint32_t loBit, uint32_t hiBit) {
- assert(hiBit < numBits && "hiBit out of range");
+ assert(hiBit <= numBits && "hiBit out of range");
assert(loBit < numBits && "loBit out of range");
if (hiBit < loBit)
- return getLowBitsSet(numBits, hiBit+1) |
- getHighBitsSet(numBits, numBits-loBit+1);
- return getLowBitsSet(numBits, hiBit-loBit+1).shl(loBit);
+ return getLowBitsSet(numBits, hiBit) |
+ getHighBitsSet(numBits, numBits-loBit);
+ return getLowBitsSet(numBits, hiBit-loBit).shl(loBit);
}
/// Constructs an APInt value that has the top hiBitsSet bits set.
/// @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
/// This function returns a pointer to the internal storage of the APInt.
/// This is useful for writing out the APInt in binary form without any
/// conversions.
- inline const uint64_t* getRawData() const {
+ const uint64_t* getRawData() const {
if (isSingleWord())
return &VAL;
return &pVal[0];
/// @{
/// @returns a new APInt value representing *this incremented by one
/// @brief Postfix increment operator.
- inline const APInt operator++(int) {
+ const APInt operator++(int) {
APInt API(*this);
++(*this);
return API;
/// @returns a new APInt representing *this decremented by one.
/// @brief Postfix decrement operator.
- inline const APInt operator--(int) {
+ const APInt operator--(int) {
APInt API(*this);
--(*this);
return API;
/// 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.
/// @brief Unary negation operator
- inline APInt operator-() const {
+ APInt operator-() const {
return APInt(BitWidth, 0) - (*this);
}
/// Performs logical negation operation on this APInt.
/// @returns true if *this is zero, false otherwise.
/// @brief Logical negation operator.
- bool operator !() const;
+ bool operator!() const;
/// @}
/// @name Assignment Operators
/// @{
/// @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
/// Shifts *this left by shiftAmt and assigns the result to *this.
/// @returns *this after shifting left by shiftAmt
/// @brief Left-shift assignment function.
- inline APInt& operator<<=(uint32_t shiftAmt) {
+ APInt& operator<<=(uint32_t shiftAmt) {
*this = shl(shiftAmt);
return *this;
}
/// 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);
}
return shl(Bits);
}
+ APInt operator<<(const APInt &Bits) const {
+ return shl(Bits);
+ }
+
/// Arithmetic right-shift this APInt by shiftAmt.
/// @brief Arithmetic right-shift function.
APInt ashr(uint32_t shiftAmt) const;
/// 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;
/// @brief Rotate right by rotateAmt.
APInt rotr(uint32_t rotateAmt) const;
+ /// Arithmetic right-shift this APInt by shiftAmt.
+ /// @brief Arithmetic right-shift function.
+ APInt ashr(const APInt &shiftAmt) const;
+
+ /// Logical right-shift this APInt by shiftAmt.
+ /// @brief Logical right-shift function.
+ APInt lshr(const APInt &shiftAmt) const;
+
+ /// Left-shift this APInt by shiftAmt.
+ /// @brief Left-shift function.
+ APInt shl(const APInt &shiftAmt) const;
+
+ /// @brief Rotate left by rotateAmt.
+ APInt rotl(const APInt &rotateAmt) const;
+
+ /// @brief Rotate right by rotateAmt.
+ APInt rotr(const APInt &rotateAmt) const;
+
/// Perform an unsigned divide operation on this APInt by RHS. Both this and
/// RHS are treated as unsigned quantities for purposes of this division.
/// @returns a new APInt value containing the division result
/// Signed divide this APInt by APInt RHS.
/// @brief Signed division function for APInt.
- inline APInt sdiv(const APInt& RHS) const {
+ APInt sdiv(const APInt& RHS) const {
if (isNegative())
if (RHS.isNegative())
return (-(*this)).udiv(-RHS);
/// Signed remainder operation on APInt.
/// @brief Function for signed remainder operation.
- inline APInt srem(const APInt& RHS) const {
+ APInt srem(const APInt& RHS) const {
if (isNegative())
if (RHS.isNegative())
return -((-(*this)).urem(-RHS));
return this->urem(RHS);
}
- /// Sometimes it is convenient to divide two APInt values and obtain both
- /// the quotient and remainder. This function does both operations in the
- /// same computation making it a little more efficient.
+ /// Sometimes it is convenient to divide two APInt values and obtain both the
+ /// quotient and remainder. This function does both operations in the same
+ /// computation making it a little more efficient. The pair of input arguments
+ /// may overlap with the pair of output arguments. It is safe to call
+ /// udivrem(X, Y, X, Y), for example.
/// @brief Dual division/remainder interface.
static void udivrem(const APInt &LHS, const APInt &RHS,
APInt &Quotient, APInt &Remainder);
/// 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.
/// relationship.
/// @returns true if *this != Val
/// @brief Inequality operator.
- inline bool operator!=(const APInt& RHS) const {
+ bool operator!=(const APInt& RHS) const {
return !((*this) == RHS);
}
/// relationship.
/// @returns true if *this != Val
/// @brief Inequality operator.
- inline bool operator!=(uint64_t Val) const {
+ bool operator!=(uint64_t Val) const {
return !((*this) == Val);
}
return !slt(RHS);
}
+ /// This operation tests if there are any pairs of corresponding bits
+ /// between this APInt and RHS that are both set.
+ bool intersects(const APInt &RHS) const {
+ return (*this & RHS) != 0;
+ }
+
/// @}
/// @name Resizing Operators
/// @{
/// @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 the total number of bits.
- inline uint32_t getBitWidth() const {
+ uint32_t getBitWidth() const {
return BitWidth;
}
/// Here one word's bitwidth equals to that of uint64_t.
/// @returns the number of words to hold the integer value of this APInt.
/// @brief Get the number of words.
- inline uint32_t getNumWords() const {
+ uint32_t getNumWords() const {
return (BitWidth + APINT_BITS_PER_WORD - 1) / APINT_BITS_PER_WORD;
}
/// bit width minus the number of leading zeros. This is used in several
/// computations to see how "wide" the value is.
/// @brief Compute the number of active bits in the value
- inline uint32_t getActiveBits() const {
+ uint32_t getActiveBits() const {
return BitWidth - countLeadingZeros();
}
/// This function returns the number of active words in the value of this
/// APInt. This is used in conjunction with getActiveData to extract the raw
/// value of the APInt.
- inline uint32_t getActiveWords() const {
+ uint32_t getActiveWords() const {
return whichWord(getActiveBits()-1) + 1;
}
/// Computes the minimum bit width for this APInt while considering it to be
/// a signed (and probably negative) value. If the value is not negative,
- /// this function returns the same value as getActiveBits(). Otherwise, it
+ /// this function returns the same value as getActiveBits()+1. Otherwise, it
/// returns the smallest bit width that will retain the negative value. For
/// example, -1 can be written as 0b1 or 0xFFFFFFFFFF. 0b1 is shorter and so
/// for -1, this function will always return 1.
/// @brief Get the minimum bit size for this signed APInt
- inline uint32_t getMinSignedBits() const {
+ uint32_t getMinSignedBits() const {
if (isNegative())
return BitWidth - countLeadingOnes() + 1;
return getActiveBits()+1;
/// uint64_t. The bitwidth must be <= 64 or the value must fit within a
/// uint64_t. Otherwise an assertion will result.
/// @brief Get zero extended value
- inline uint64_t getZExtValue() const {
+ uint64_t getZExtValue() const {
if (isSingleWord())
return VAL;
assert(getActiveBits() <= 64 && "Too many bits for uint64_t");
/// int64_t. The bit width must be <= 64 or the value must fit within an
/// int64_t. Otherwise an assertion will result.
/// @brief Get sign extended value
- inline int64_t getSExtValue() const {
+ int64_t getSExtValue() const {
if (isSingleWord())
return int64_t(VAL << (APINT_BITS_PER_WORD - BitWidth)) >>
(APINT_BITS_PER_WORD - BitWidth);
/// countLeadingZeros - This function is an APInt version of the
/// countLeadingZeros_{32,64} functions in MathExtras.h. It counts the number
/// of zeros from the most significant bit to the first one bit.
- /// @returns getNumWords() * APINT_BITS_PER_WORD if the value is zero.
+ /// @returns BitWidth if the value is zero.
/// @returns the number of zeros from the most significant bit to the first
/// one bits.
- /// @brief Count the number of leading 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 counts the number of contiguous 1 bits
- /// in the high order bits. The count stops when the first 0 bit is reached.
+ /// countLeadingOnes - This function is an APInt version of the
+ /// countLeadingOnes_{32,64} functions in MathExtras.h. It counts the number
+ /// of ones from the most significant bit to the first zero bit.
/// @returns 0 if the high order bit is not set
/// @returns the number of 1 bits from the most significant to the least
/// @brief Count the number of leading one bits.
uint32_t countLeadingOnes() const;
/// countTrailingZeros - This function is an APInt version of the
- /// countTrailingZoers_{32,64} functions in MathExtras.h. It counts
- /// the number of zeros from the least significant bit to the first one bit.
- /// @returns getNumWords() * APINT_BITS_PER_WORD if the value is zero.
+ /// countTrailingZeros_{32,64} functions in MathExtras.h. It counts
+ /// the number of zeros from the least significant bit to the first set bit.
+ /// @returns BitWidth if the value is zero.
/// @returns the number of zeros from the least significant bit to the first
/// one bit.
/// @brief Count the number of trailing zero bits.
uint32_t countTrailingZeros() const;
+ /// countTrailingOnes - This function is an APInt version of the
+ /// countTrailingOnes_{32,64} functions in MathExtras.h. It counts
+ /// the number of ones from the least significant bit to the first zero bit.
+ /// @returns BitWidth if the value is all ones.
+ /// @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 {
+ 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
/// of 1 bits in the APInt value.
/// @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
/// @{
- /// This is used internally to convert an APInt to a string.
- /// @brief Converts an APInt to a std::string
- std::string toString(uint8_t radix, bool wantSigned) const;
+ void print(std::ostream &OS, bool isSigned) const;
+
+ /// toString - Converts an APInt to a string and append it to Str. Str is
+ /// commonly a SmallString.
+ void toString(SmallVectorImpl<char> &Str, unsigned Radix, bool Signed) const;
/// Considers the APInt to be unsigned and converts it into a string in the
/// radix given. The radix can be 2, 8, 10 or 16.
- /// @returns a character interpretation of the APInt
- /// @brief Convert unsigned APInt to string representation.
- inline std::string toStringUnsigned(uint8_t radix = 10) const {
- return toString(radix, false);
+ void toStringUnsigned(SmallVectorImpl<char> &Str, unsigned Radix = 10) const {
+ return toString(Str, Radix, false);
}
- /// Considers the APInt to be unsigned and converts it into a string in the
+ /// Considers the APInt to be signed and converts it into a string in the
/// radix given. The radix can be 2, 8, 10 or 16.
- /// @returns a character interpretation of the APInt
- /// @brief Convert unsigned APInt to string representation.
- inline std::string toStringSigned(uint8_t radix = 10) const {
- return toString(radix, true);
+ void toStringSigned(SmallVectorImpl<char> &Str, unsigned Radix = 10) const {
+ return toString(Str, Radix, true);
}
+
+ /// toString - This returns the APInt as a std::string. Note that this is an
+ /// inefficient method. It is better to pass in a SmallVector/SmallString
+ /// to the methods above to avoid thrashing the heap for the string.
+ std::string toString(unsigned Radix, bool Signed) const;
+
/// @returns a byte-swapped representation of this APInt Value.
APInt byteSwap() const;
/// @{
/// @returns the floor log base 2 of this APInt.
- inline uint32_t logBase2() const {
+ uint32_t logBase2() const {
return BitWidth - 1 - countLeadingZeros();
}
/// @returns the log base 2 of this APInt if its an exact power of two, -1
/// otherwise
- inline int32_t exactLogBase2() const {
+ int32_t exactLogBase2() const {
if (!isPowerOf2())
return -1;
return logBase2();
return *this;
}
- /// @}
+ /// @returns the multiplicative inverse for a given modulo.
+ APInt multiplicativeInverse(const APInt& modulo) const;
/// @}
/// @name Building-block Operations for APInt and APFloat
/// Extract the given bit of a bignum; returns 0 or 1. Zero-based.
static int tcExtractBit(const integerPart *, unsigned int bit);
+ /// Copy the bit vector of width srcBITS from SRC, starting at bit
+ /// srcLSB, to DST, of dstCOUNT parts, such that the bit srcLSB
+ /// becomes the least significant bit of DST. All high bits above
+ /// srcBITS in DST are zero-filled.
+ static void tcExtract(integerPart *, unsigned int dstCount, const integerPart *,
+ unsigned int srcBits, unsigned int srcLSB);
+
/// Set the given bit of a bignum. Zero-based.
static void tcSetBit(integerPart *, unsigned int bit);
/// 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);
/// DST += RHS + CARRY where CARRY is zero or one. Returns the
/// carry flag.
static integerPart tcAdd(integerPart *, const integerPart *,
- integerPart carry, unsigned);
+ integerPart carry, unsigned);
/// DST -= RHS + CARRY where CARRY is zero or one. Returns the
/// carry flag.
static integerPart tcSubtract(integerPart *, const integerPart *,
- integerPart carry, unsigned);
+ integerPart carry, unsigned);
/// DST += SRC * MULTIPLIER + PART if add is true
/// DST = SRC * MULTIPLIER + PART if add is false
/// parts were zero return zero, otherwise overflow occurred and
/// return one.
static int tcMultiplyPart(integerPart *dst, const integerPart *src,
- integerPart multiplier, integerPart carry,
- unsigned int srcParts, unsigned int dstParts,
- bool add);
+ integerPart multiplier, integerPart carry,
+ unsigned int srcParts, unsigned int dstParts,
+ bool add);
/// DST = LHS * RHS, where DST has the same width as the operands
/// and is filled with the least significant parts of the result.
/// Returns one if overflow occurred, otherwise zero. DST must be
/// disjoint from both operands.
static int tcMultiply(integerPart *, const integerPart *,
- const integerPart *, unsigned);
+ const integerPart *, unsigned);
- /// DST = LHS * RHS, where DST has twice the width as the operands.
- /// No overflow occurs. DST must be disjoint from both operands.
- static void tcFullMultiply(integerPart *, const integerPart *,
- const integerPart *, unsigned);
+ /// DST = LHS * RHS, where DST has width the sum of the widths of
+ /// the operands. No overflow occurs. DST must be disjoint from
+ /// both operands. Returns the number of parts required to hold the
+ /// result.
+ static unsigned int tcFullMultiply(integerPart *, const integerPart *,
+ const integerPart *, unsigned, unsigned);
/// If RHS is zero LHS and REMAINDER are left unchanged, return one.
/// Otherwise set LHS to LHS / RHS with the fractional part
/// and are destroyed. LHS, REMAINDER and SCRATCH must be
/// distinct.
static int tcDivide(integerPart *lhs, const integerPart *rhs,
- integerPart *remainder, integerPart *scratch,
- unsigned int parts);
+ integerPart *remainder, integerPart *scratch,
+ unsigned int parts);
/// Shift a bignum left COUNT bits. Shifted in bits are zero.
/// There are no restrictions on COUNT.
static void tcShiftLeft(integerPart *, unsigned int parts,
- unsigned int count);
+ unsigned int count);
/// Shift a bignum right COUNT bits. Shifted in bits are zero.
/// There are no restrictions on COUNT.
static void tcShiftRight(integerPart *, unsigned int parts,
- unsigned int count);
+ unsigned int count);
/// The obvious AND, OR and XOR and complement operations.
static void tcAnd(integerPart *, const integerPart *, unsigned int);
/// Comparison (unsigned) of two bignums.
static int tcCompare(const integerPart *, const integerPart *,
- unsigned int);
+ unsigned int);
/// Increment a bignum in-place. Return the carry flag.
static integerPart tcIncrement(integerPart *, unsigned int);
/// Set the least significant BITS and clear the rest.
static void tcSetLeastSignificantBits(integerPart *, unsigned int,
- unsigned int bits);
+ unsigned int bits);
-#ifndef NDEBUG
/// @brief debug method
void dump() const;
-#endif
/// @}
};
return V2 != V1;
}
+inline std::ostream &operator<<(std::ostream &OS, const APInt &I) {
+ I.print(OS, true);
+ return OS;
+}
+
namespace APIntOps {
/// @brief Determine the smaller of two APInts considered to be signed.
return A.ugt(B) ? A : B;
}
-/// @brief Check if the specified APInt has a N-bits integer value.
+/// @brief Check if the specified APInt has a N-bits unsigned integer value.
inline bool isIntN(uint32_t N, const APInt& APIVal) {
return APIVal.isIntN(N);
}
+/// @brief Check if the specified APInt has a N-bits signed integer value.
+inline bool isSignedIntN(uint32_t N, const APInt& APIVal) {
+ return APIVal.isSignedIntN(N);
+}
+
/// @returns true if the argument APInt value is a sequence of ones
/// starting at the least significant bit with the remainder zero.
inline bool isMask(uint32_t numBits, const APInt& APIVal) {
- return APIVal.getBoolValue() && ((APIVal + APInt(numBits,1)) & APIVal) == 0;
+ return numBits <= APIVal.getBitWidth() &&
+ APIVal == APInt::getLowBitsSet(APIVal.getBitWidth(), numBits);
}
/// @returns true if the argument APInt value contains a sequence of ones
}
/// GreatestCommonDivisor - This function returns the greatest common
-/// divisor of the two APInt values using Enclid's algorithm.
+/// divisor of the two APInt values using Euclid's algorithm.
/// @returns the greatest common divisor of Val1 and Val2
/// @brief Compute GCD of two APInt values.
APInt GreatestCommonDivisor(const APInt& Val1, const APInt& Val2);
projects / oota-llvm.git / blobdiff