[llvm-commits] CVS: llvm/include/llvm/ADT/APInt.h
Reid Spencer
reid at x10sys.com
Sat Mar 24 11:09:36 PDT 2007
Changes in directory llvm/include/llvm/ADT:
APInt.h updated: 1.46 -> 1.47
---
Log message:
Clean up this interface:
1. Group similar methods into doxygen groups
2. Reorganize the groups into a consist flow.
3. Significantly improve the quality of the documentation on several methods
4. Rewrite srem and sdiv to eliminate a copy and improve readability.
5. Eliminate unneeded forward references.
---
Diffs of the changes: (+457 -312)
APInt.h | 769 ++++++++++++++++++++++++++++++++++++++--------------------------
1 files changed, 457 insertions(+), 312 deletions(-)
Index: llvm/include/llvm/ADT/APInt.h
diff -u llvm/include/llvm/ADT/APInt.h:1.46 llvm/include/llvm/ADT/APInt.h:1.47
--- llvm/include/llvm/ADT/APInt.h:1.46 Wed Mar 21 17:22:19 2007
+++ llvm/include/llvm/ADT/APInt.h Sat Mar 24 13:09:18 2007
@@ -8,7 +8,7 @@
//===----------------------------------------------------------------------===//
//
// This file implements a class to represent arbitrary precision integral
-// constant values.
+// constant values and operations on them.
//
//===----------------------------------------------------------------------===//
@@ -21,13 +21,6 @@
namespace llvm {
-/// Forward declaration.
-class APInt;
-namespace APIntOps {
- APInt udiv(const APInt& LHS, const APInt& RHS);
- APInt urem(const APInt& LHS, const APInt& RHS);
-}
-
//===----------------------------------------------------------------------===//
// APInt Class
//===----------------------------------------------------------------------===//
@@ -63,20 +56,21 @@
uint32_t BitWidth; ///< The number of bits in this APInt.
/// This union is used to store the integer value. When the
- /// integer bit-width <= 64, it uses VAL;
- /// otherwise it uses the pVal.
+ /// integer bit-width <= 64, it uses VAL, otherwise it uses pVal.
union {
uint64_t VAL; ///< Used to store the <= 64 bits integer value.
uint64_t *pVal; ///< Used to store the >64 bits integer value.
};
- /// This enum is just used to hold a constant we needed for APInt.
+ /// This enum is used to hold the constants we needed for APInt.
enum {
- APINT_BITS_PER_WORD = sizeof(uint64_t) * 8,
- APINT_WORD_SIZE = sizeof(uint64_t)
+ APINT_BITS_PER_WORD = sizeof(uint64_t) * 8, ///< Bits in a word
+ APINT_WORD_SIZE = sizeof(uint64_t) ///< Byte size of a word
};
- // Fast internal constructor
+ /// This constructor is used only internally for speed of construction of
+ /// temporaries. It is unsafe for general use so it is not public.
+ /// @brief Fast internal constructor
APInt(uint64_t* val, uint32_t bits) : BitWidth(bits), pVal(val) { }
/// @returns true if the number of bits <= 64, false otherwise.
@@ -86,26 +80,32 @@
}
/// @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) {
return bitPosition / APINT_BITS_PER_WORD;
}
/// @returns the bit position in a word for the specified bit position
- /// in APInt.
+ /// in the APInt.
+ /// @brief Determine which bit in a word a bit is in.
static inline uint32_t whichBit(uint32_t bitPosition) {
return bitPosition % APINT_BITS_PER_WORD;
}
- /// @returns a uint64_t type integer with just bit position at
- /// "whichBit(bitPosition)" setting, others zero.
+ /// This method generates and returns a uint64_t (word) mask for a single
+ /// bit at a specific bit position. This is used to mask the bit in the
+ /// 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) {
return 1ULL << whichBit(bitPosition);
}
- /// This method is used internally to clear the to "N" bits that are not used
- /// by the APInt. This is needed after the most significant word is assigned
- /// a value to ensure that those bits are zero'd out.
- /// @brief Clear high order bits
+ /// This method is used internally to clear the to "N" bits in the high order
+ /// word that are not used by the APInt. This is needed after the most
+ /// significant word is assigned a value to ensure that those bits are
+ /// zero'd out.
+ /// @brief Clear unused high order bits
inline APInt& clearUnusedBits() {
// Compute how many bits are used in the final word
uint32_t wordBits = BitWidth % APINT_BITS_PER_WORD;
@@ -131,8 +131,8 @@
}
/// This is used by the constructors that take string arguments.
- /// @brief Converts a char array into an APInt
- void fromString(uint32_t numBits, const char *StrStart, uint32_t slen,
+ /// @brief Convert a char array into an APInt
+ void fromString(uint32_t numBits, const char *strStart, uint32_t slen,
uint8_t radix);
/// This is used by the toString method to divide by the radix. It simply
@@ -150,36 +150,237 @@
#endif
public:
+ /// @name Constructors
+ /// @{
+ /// If isSigned is true then val is treated as if it were a signed value
+ /// (i.e. as an int64_t) and the appropriate sign extension to the bit width
+ /// will be done. Otherwise, no sign extension occurs (high order bits beyond
+ /// the range of val are zero filled).
+ /// @param numBits the bit width of the constructed APInt
+ /// @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);
/// Note that numWords can be smaller or larger than the corresponding bit
/// width but any extraneous bits will be dropped.
- /// @brief Create a new APInt of numBits width, initialized as bigVal[].
+ /// @param numBits the bit width of the constructed APInt
+ /// @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[]);
- /// @brief Create a new APInt by translating the string represented
- /// integer value.
- APInt(uint32_t numBits, const std::string& Val, uint8_t radix);
-
- /// @brief Create a new APInt by translating the char array represented
- /// integer value.
- APInt(uint32_t numBits, const char StrStart[], uint32_t slen, uint8_t radix);
+ /// 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);
+
+ /// This constructor interprets the slen characters starting at StrStart as
+ /// a string in the given radix. The interpretation stops when the first
+ /// character 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 strStart the start of the string to be interpreted
+ /// @param slen the maximum number of characters to interpret
+ /// @brief Construct an APInt from a string representation.
+ APInt(uint32_t numBits, const char strStart[], uint32_t slen, uint8_t radix);
+ /// Simply makes *this a copy of that.
/// @brief Copy Constructor.
- APInt(const APInt& API);
+ APInt(const APInt& that);
/// @brief Destructor.
~APInt();
- /// @brief Copy assignment operator.
- APInt& operator=(const APInt& RHS);
+ /// @}
+ /// @name Value Tests
+ /// @{
+ /// This tests the high bit of this APInt to determine if it is set.
+ /// @returns true if this APInt is negative, false otherwise
+ /// @brief Determine sign of this APInt.
+ bool isNegative() const {
+ return (*this)[BitWidth - 1];
+ }
- /// Assigns an integer value to the APInt.
- /// @brief Assignment operator.
- APInt& operator=(uint64_t RHS);
+ /// 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 {
+ 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 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 {
+ return countPopulation() == BitWidth;
+ }
+
+ /// This checks to see if the value of this APInt is the maximum unsigned
+ /// value for the APInt's bit width.
+ /// @brief Determine if this is the largest unsigned value.
+ bool isMaxValue() const {
+ return countPopulation() == BitWidth;
+ }
+
+ /// This checks to see if the value of this APInt is the maximum signed
+ /// value for the APInt's bit width.
+ /// @brief Determine if this is the largest signed value.
+ bool isMaxSignedValue() const {
+ return BitWidth == 1 ? VAL == 0 :
+ !isNegative() && countPopulation() == BitWidth - 1;
+ }
+
+ /// This checks to see if the value of this APInt is the minimum unsigned
+ /// value for the APInt's bit width.
+ /// @brief Determine if this is the smallest unsigned value.
+ bool isMinValue() const {
+ return countPopulation() == 0;
+ }
+
+ /// This checks to see if the value of this APInt is the minimum signed
+ /// value for the APInt's bit width.
+ /// @brief Determine if this is the smallest signed value.
+ bool isMinSignedValue() const {
+ return BitWidth == 1 ? VAL == 1 :
+ isNegative() && countPopulation() == 1;
+ }
+
+ /// @brief Check if this APInt has an N-bits integer value.
+ inline bool isIntN(uint32_t N) const {
+ assert(N && "N == 0 ???");
+ if (isSingleWord()) {
+ return VAL == (VAL & (~0ULL >> (64 - N)));
+ } else {
+ APInt Tmp(N, getNumWords(), pVal);
+ return Tmp == (*this);
+ }
+ }
+
+ /// @returns true if the argument APInt value is a power of two > 0.
+ bool isPowerOf2() const;
+
+ /// This converts the APInt to a boolean valy as a test against zero.
+ /// @brief Boolean conversion function.
+ inline bool getBoolValue() const {
+ return countLeadingZeros() != BitWidth;
+ }
+
+ /// @}
+ /// @name Value Generators
+ /// @{
+ /// @brief Gets maximum unsigned value of APInt for specific bit width.
+ static APInt getMaxValue(uint32_t numBits) {
+ return APInt(numBits, 0).set();
+ }
+
+ /// @brief Gets maximum signed value of APInt for a specific bit width.
+ static APInt getSignedMaxValue(uint32_t numBits) {
+ return APInt(numBits, 0).set().clear(numBits - 1);
+ }
+
+ /// @brief Gets minimum unsigned value of APInt for a specific bit width.
+ static APInt getMinValue(uint32_t numBits) {
+ return APInt(numBits, 0);
+ }
+
+ /// @brief Gets minimum signed value of APInt for a specific bit width.
+ static APInt getSignedMinValue(uint32_t numBits) {
+ return APInt(numBits, 0).set(numBits - 1);
+ }
+
+ /// 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) {
+ return getSignedMinValue(BitWidth);
+ }
+
+ /// @returns the all-ones value for an APInt of the specified bit-width.
+ /// @brief Get the all-ones value.
+ static APInt getAllOnesValue(uint32_t numBits) {
+ return APInt(numBits, 0).set();
+ }
+
+ /// @returns the '0' value for an APInt of the specified bit-width.
+ /// @brief Get the '0' value.
+ static APInt getNullValue(uint32_t numBits) {
+ return APInt(numBits, 0);
+ }
+
+ /// Get an APInt with the same BitWidth as this APInt, just zero mask
+ /// the low bits and right shift to the least significant bit.
+ /// @returns the high "numBits" bits of this APInt.
+ APInt getHiBits(uint32_t numBits) const;
- /// Increments the APInt by one.
+ /// Get an APInt with the same BitWidth as this APInt, just zero mask
+ /// the high bits.
+ /// @returns the low "numBits" bits of this APInt.
+ 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.
+ /// @param numBits the intended bit width of the result
+ /// @param hiBit the index of the highest bit set.
+ /// @param loBit the index of the lowest 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 hiBit, uint32_t loBit = 0);
+
+ /// Constructs an APInt value that has the top hiBitsSet bits set.
+ /// @param numBits the bitwidth of the result
+ /// @param hiBitsSet the number of high-order bits set in the result.
+ /// @brief Get a value with high bits set
+ static APInt getHighBitsSet(uint32_t numBits, uint32_t hiBitsSet);
+
+ /// Constructs an APInt value that has the bottom loBitsSet 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
+ static APInt getLowBitsSet(uint32_t numBits, uint32_t loBitsSet);
+
+ /// The hash value is computed as the sum of the words and the bit width.
+ /// @returns A hash value computed from the sum of the APInt words.
+ /// @brief Get a hash value based on this APInt
+ uint64_t getHashValue() const;
+
+ /// 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 {
+ if (isSingleWord())
+ return &VAL;
+ return &pVal[0];
+ }
+
+ /// @brief Set a sepcific word in the value to a new value.
+ inline void setWordToValue(uint32_t idx, uint64_t Val) {
+ assert(idx < getNumWords() && "Invalid word array index");
+ if (isSingleWord())
+ VAL = Val;
+ else
+ pVal[idx] = Val;
+ }
+
+ /// @}
+ /// @name Unary Operators
+ /// @{
+ /// @returns a new APInt value representing *this incremented by one
/// @brief Postfix increment operator.
inline const APInt operator++(int) {
APInt API(*this);
@@ -187,11 +388,11 @@
return API;
}
- /// Increments the APInt by one.
+ /// @returns *this incremented by one
/// @brief Prefix increment operator.
APInt& operator++();
- /// Decrements the APInt by one.
+ /// @returns a new APInt representing *this decremented by one.
/// @brief Postfix decrement operator.
inline const APInt operator--(int) {
APInt API(*this);
@@ -199,235 +400,291 @@
return API;
}
- /// Decrements the APInt by one.
+ /// @returns *this decremented by one.
/// @brief Prefix decrement operator.
APInt& operator--();
- /// Performs bitwise AND operation on this APInt and the given APInt& RHS,
- /// assigns the result to this APInt.
+ /// 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;
+
+ /// Negates *this using two's complement logic.
+ /// @returns An APInt value representing the negation of *this.
+ /// @brief Unary negation operator
+ inline 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;
+
+ /// @}
+ /// @name Assignment Operators
+ /// @{
+ /// @returns *this after assignment of RHS.
+ /// @brief Copy assignment operator.
+ APInt& operator=(const APInt& 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
+ /// than 64, the value is zero filled in the unspecified high order bits.
+ /// @returns *this after assignment of RHS value.
+ /// @brief Assignment operator.
+ APInt& operator=(uint64_t RHS);
+
+ /// Performs a bitwise AND operation on this APInt and RHS. The result is
+ /// assigned to *this.
+ /// @returns *this after ANDing with RHS.
/// @brief Bitwise AND assignment operator.
APInt& operator&=(const APInt& RHS);
- /// Performs bitwise OR operation on this APInt and the given APInt& RHS,
- /// assigns the result to this APInt.
+ /// Performs a bitwise OR operation on this APInt and RHS. The result is
+ /// assigned *this;
+ /// @returns *this after ORing with RHS.
/// @brief Bitwise OR assignment operator.
APInt& operator|=(const APInt& RHS);
- /// Performs bitwise XOR operation on this APInt and the given APInt& RHS,
- /// assigns the result to this APInt.
+ /// Performs a bitwise XOR operation on this APInt and RHS. The result is
+ /// assigned to *this.
+ /// @returns *this after XORing with RHS.
/// @brief Bitwise XOR assignment operator.
APInt& operator^=(const APInt& RHS);
- /// Performs a bitwise complement operation on this APInt.
- /// @brief Bitwise complement operator.
- APInt operator~() const;
-
- /// Multiplies this APInt by the given APInt& RHS and
- /// assigns the result to this APInt.
+ /// Multiplies this APInt by RHS and assigns the result to *this.
+ /// @returns *this
/// @brief Multiplication assignment operator.
APInt& operator*=(const APInt& RHS);
- /// Adds this APInt by the given APInt& RHS and
- /// assigns the result to this APInt.
+ /// Adds RHS to *this and assigns the result to *this.
+ /// @returns *this
/// @brief Addition assignment operator.
APInt& operator+=(const APInt& RHS);
- /// Subtracts this APInt by the given APInt &RHS and
- /// assigns the result to this APInt.
+ /// Subtracts RHS from *this and assigns the result to *this.
+ /// @returns *this
/// @brief Subtraction assignment operator.
APInt& operator-=(const APInt& RHS);
- /// Performs bitwise AND operation on this APInt and
- /// the given APInt& RHS.
+ /// 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) {
+ *this = shl(shiftAmt);
+ return *this;
+ }
+
+ /// @}
+ /// @name Binary Operators
+ /// @{
+ /// 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 And(const APInt& RHS) const {
return this->operator&(RHS);
}
- /// Performs bitwise OR operation on this APInt and the given APInt& 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 Or(const APInt& RHS) const {
return this->operator|(RHS);
}
- /// Performs bitwise XOR operation on this APInt and the given APInt& 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 Xor(const APInt& RHS) const {
return this->operator^(RHS);
}
- /// Performs logical negation operation on this APInt.
- /// @brief Logical negation operator.
- bool operator !() const;
-
- /// Multiplies this APInt by the given APInt& RHS.
+ /// Multiplies this APInt by RHS and returns the result.
/// @brief Multiplication operator.
APInt operator*(const APInt& RHS) const;
- /// Adds this APInt by the given APInt& RHS.
+ /// Adds RHS to this APInt and returns the result.
/// @brief Addition operator.
APInt operator+(const APInt& RHS) const;
APInt operator+(uint64_t RHS) const {
return (*this) + APInt(BitWidth, RHS);
}
-
- /// Subtracts this APInt by the given APInt& RHS
+ /// Subtracts RHS from this APInt and returns the result.
/// @brief Subtraction operator.
APInt operator-(const APInt& RHS) const;
APInt operator-(uint64_t RHS) const {
return (*this) - APInt(BitWidth, RHS);
}
- /// @brief Unary negation operator
- inline APInt operator-() const {
- return APInt(BitWidth, 0) - (*this);
+ /// Arithmetic right-shift this APInt by shiftAmt.
+ /// @brief Arithmetic right-shift function.
+ APInt ashr(uint32_t shiftAmt) const;
+
+ /// Logical right-shift this APInt by shiftAmt.
+ /// @brief Logical right-shift function.
+ APInt lshr(uint32_t shiftAmt) const;
+
+ /// Left-shift this APInt by shiftAmt.
+ /// @brief Left-shift function.
+ APInt shl(uint32_t shiftAmt) 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
+ /// @brief Unsigned division operation.
+ APInt udiv(const APInt& RHS) const;
+
+ /// Signed divide this APInt by APInt RHS.
+ /// @brief Signed division function for APInt.
+ inline APInt sdiv(const APInt& RHS) const {
+ if (isNegative())
+ if (RHS.isNegative())
+ return (-(*this)).udiv(-RHS);
+ else
+ return -((-(*this)).udiv(RHS));
+ else if (RHS.isNegative())
+ return -(this->udiv(-RHS));
+ return this->udiv(RHS);
+ }
+
+ /// Perform an Unsigned remainder operation on this APInt with RHS being the
+ /// divisor. Both this and RHS are treated as unsigned quantities for purposes
+ /// of this operation.
+ /// @returns a new APInt value containing the remainder result
+ /// @brief Unsigned remainder operation.
+ APInt urem(const APInt& RHS) const;
+
+ /// Signed remainder operation on APInt.
+ /// @brief Function for signed remainder operation.
+ inline APInt srem(const APInt& RHS) const {
+ if (isNegative())
+ if (RHS.isNegative())
+ return (-(*this)).urem(-RHS);
+ else
+ return -((-(*this)).urem(RHS));
+ else if (RHS.isNegative())
+ return -(this->urem(-RHS));
+ return this->urem(RHS);
}
+ /// @returns the bit value at bitPosition
/// @brief Array-indexing support.
bool operator[](uint32_t bitPosition) const;
- /// Compare this APInt with the given APInt& RHS
- /// for the validity of the equality relationship.
+ /// @}
+ /// @name Comparison Operators
+ /// @{
+ /// Compares this APInt with RHS for the validity of the equality
+ /// relationship.
/// @brief Equality operator.
bool operator==(const APInt& RHS) const;
- /// Compare this APInt with the given uint64_t value
- /// for the validity of the equality relationship.
+ /// 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;
- /// Compare this APInt with the given APInt& RHS
- /// for the validity of the inequality relationship.
+ /// Compares this APInt with RHS for the validity of the equality
+ /// relationship.
+ /// @returns true if *this == Val
+ /// @brief Equality comparison.
+ bool eq(const APInt &RHS) const {
+ return (*this) == RHS;
+ }
+
+ /// Compares this APInt with RHS for the validity of the inequality
+ /// relationship.
+ /// @returns true if *this != Val
/// @brief Inequality operator.
inline bool operator!=(const APInt& RHS) const {
return !((*this) == RHS);
}
- /// Compare this APInt with the given uint64_t value
- /// for the validity of the inequality relationship.
+ /// Compares this APInt with a uint64_t for the validity of the inequality
+ /// relationship.
+ /// @returns true if *this != Val
/// @brief Inequality operator.
inline bool operator!=(uint64_t Val) const {
return !((*this) == Val);
}
- /// @brief Equality comparison
- bool eq(const APInt &RHS) const {
- return (*this) == RHS;
- }
-
+ /// Compares this APInt with RHS for the validity of the inequality
+ /// relationship.
+ /// @returns true if *this != Val
/// @brief Inequality comparison
bool ne(const APInt &RHS) const {
return !((*this) == RHS);
}
+ /// Regards both *this and RHS as unsigned quantities and compares them for
+ /// the validity of the less-than relationship.
+ /// @returns true if *this < RHS when both are considered unsigned.
/// @brief Unsigned less than comparison
bool ult(const APInt& RHS) const;
+ /// Regards both *this and RHS as signed quantities and compares them for
+ /// validity of the less-than relationship.
+ /// @returns true if *this < RHS when both are considered signed.
/// @brief Signed less than comparison
bool slt(const APInt& RHS) const;
+ /// Regards both *this and RHS as unsigned quantities and compares them for
+ /// validity of the less-or-equal relationship.
+ /// @returns true if *this <= RHS when both are considered unsigned.
/// @brief Unsigned less or equal comparison
bool ule(const APInt& RHS) const {
return ult(RHS) || eq(RHS);
}
+ /// Regards both *this and RHS as signed quantities and compares them for
+ /// validity of the less-or-equal relationship.
+ /// @returns true if *this <= RHS when both are considered signed.
/// @brief Signed less or equal comparison
bool sle(const APInt& RHS) const {
return slt(RHS) || eq(RHS);
}
+ /// Regards both *this and RHS as unsigned quantities and compares them for
+ /// the validity of the greater-than relationship.
+ /// @returns true if *this > RHS when both are considered unsigned.
/// @brief Unsigned greather than comparison
bool ugt(const APInt& RHS) const {
return !ult(RHS) && !eq(RHS);
}
+ /// Regards both *this and RHS as signed quantities and compares them for
+ /// the validity of the greater-than relationship.
+ /// @returns true if *this > RHS when both are considered signed.
/// @brief Signed greather than comparison
bool sgt(const APInt& RHS) const {
return !slt(RHS) && !eq(RHS);
}
+ /// Regards both *this and RHS as unsigned quantities and compares them for
+ /// validity of the greater-or-equal relationship.
+ /// @returns true if *this >= RHS when both are considered unsigned.
/// @brief Unsigned greater or equal comparison
bool uge(const APInt& RHS) const {
return !ult(RHS);
}
+ /// Regards both *this and RHS as signed quantities and compares them for
+ /// validity of the greater-or-equal relationship.
+ /// @returns true if *this >= RHS when both are considered signed.
/// @brief Signed greather or equal comparison
bool sge(const APInt& RHS) const {
return !slt(RHS);
}
- /// This just tests the high bit of this APInt to determine if it is negative.
- /// @returns true if this APInt is negative, false otherwise
- /// @brief Determine sign of this APInt.
- bool isNegative() const {
- return (*this)[BitWidth - 1];
- }
-
- /// This just tests the high bit of the APInt to determine if the value is
- /// positove or not.
- /// @brief Determine if this APInt Value is positive.
- bool isPositive() const {
- return !isNegative();
- }
-
- /// This just tests if the value of this APInt is strictly positive (> 0).
- /// @brief Determine if this APInt Value is strictly positive.
- inline bool isStrictlyPositive() const {
- return isPositive() && (*this) != 0;
- }
-
- /// Arithmetic right-shift this APInt by shiftAmt.
- /// @brief Arithmetic right-shift function.
- APInt ashr(uint32_t shiftAmt) const;
-
- /// Logical right-shift this APInt by shiftAmt.
- /// @brief Logical right-shift function.
- APInt lshr(uint32_t shiftAmt) const;
-
- /// Left-shift this APInt by shiftAmt.
- /// @brief Left-shift function.
- APInt shl(uint32_t shiftAmt) const;
-
- /// Left-shift this APInt by shiftAmt and
- /// assigns the result to this APInt.
- /// @brief Lef-shift assignment function.
- inline APInt& operator<<=(uint32_t shiftAmt) {
- *this = shl(shiftAmt);
- return *this;
- }
-
- /// Signed divide this APInt by APInt RHS.
- /// @brief Signed division function for APInt.
- inline APInt sdiv(const APInt& RHS) const {
- bool isNegativeLHS = isNegative();
- bool isNegativeRHS = RHS.isNegative();
- APInt Result = APIntOps::udiv(
- isNegativeLHS ? -(*this) : (*this), isNegativeRHS ? -RHS : RHS);
- return isNegativeLHS != isNegativeRHS ? -Result : Result;
- }
-
- /// Unsigned divide this APInt by APInt RHS.
- /// @brief Unsigned division function for APInt.
- APInt udiv(const APInt& RHS) const;
-
- /// Signed remainder operation on APInt.
- /// @brief Function for signed remainder operation.
- inline APInt srem(const APInt& RHS) const {
- bool isNegativeLHS = isNegative();
- bool isNegativeRHS = RHS.isNegative();
- APInt Result = APIntOps::urem(
- isNegativeLHS ? -(*this) : (*this), isNegativeRHS ? -RHS : RHS);
- return isNegativeLHS ? -Result : Result;
- }
-
- /// Unsigned remainder operation on APInt.
- /// @brief Function for unsigned remainder operation.
- APInt urem(const APInt& RHS) const;
-
+ /// @}
+ /// @name Resizing Operators
+ /// @{
/// Truncate the APInt to a specified width. It is an error to specify a width
/// that is greater than or equal to the current width.
/// @brief Truncate to new width.
@@ -465,6 +722,9 @@
return zext(width);
}
+ /// @}
+ /// @name Bit Manipulation Operators
+ /// @{
/// @brief Set every bit to 1.
APInt& set();
@@ -487,12 +747,20 @@
/// @brief Toggles a given bit to its opposite value.
APInt& flip(uint32_t bitPosition);
- inline void setWordToValue(uint32_t idx, uint64_t Val) {
- assert(idx < getNumWords() && "Invalid word array index");
- if (isSingleWord())
- VAL = Val;
- else
- pVal[idx] = Val;
+ /// @}
+ /// @name Value Characterization Functions
+ /// @{
+
+ /// @returns the total number of bits.
+ inline 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 {
+ return (BitWidth + APINT_BITS_PER_WORD - 1) / APINT_BITS_PER_WORD;
}
/// This function returns the number of active bits which is defined as the
@@ -510,22 +778,6 @@
return whichWord(getActiveBits()-1) + 1;
}
- /// 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 {
- return (BitWidth + APINT_BITS_PER_WORD - 1) / APINT_BITS_PER_WORD;
- }
-
- /// 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 {
- if (isSingleWord())
- return &VAL;
- return &pVal[0];
- }
-
/// 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
@@ -561,126 +813,6 @@
assert(getActiveBits() <= 64 && "Too many bits for int64_t");
return int64_t(pVal[0]);
}
-
- /// @brief Gets maximum unsigned value of APInt for specific bit width.
- static APInt getMaxValue(uint32_t numBits) {
- return APInt(numBits, 0).set();
- }
-
- /// @brief Gets maximum signed value of APInt for a specific bit width.
- static APInt getSignedMaxValue(uint32_t numBits) {
- return APInt(numBits, 0).set().clear(numBits - 1);
- }
-
- /// @brief Gets minimum unsigned value of APInt for a specific bit width.
- static APInt getMinValue(uint32_t numBits) {
- return APInt(numBits, 0);
- }
-
- /// @brief Gets minimum signed value of APInt for a specific bit width.
- static APInt getSignedMinValue(uint32_t numBits) {
- return APInt(numBits, 0).set(numBits - 1);
- }
-
- /// 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) {
- return getSignedMinValue(BitWidth);
- }
-
- /// @returns the all-ones value for an APInt of the specified bit-width.
- /// @brief Get the all-ones value.
- static APInt getAllOnesValue(uint32_t numBits) {
- return APInt(numBits, 0).set();
- }
-
- /// @returns the '0' value for an APInt of the specified bit-width.
- /// @brief Get the '0' value.
- static APInt getNullValue(uint32_t numBits) {
- return APInt(numBits, 0);
- }
-
- /// The hash value is computed as the sum of the words and the bit width.
- /// @returns A hash value computed from the sum of the APInt words.
- /// @brief Get a hash value based on this APInt
- uint64_t getHashValue() const;
-
- /// This converts the APInt to a boolean valy as a test against zero.
- /// @brief Boolean conversion function.
- inline bool getBoolValue() const {
- return countLeadingZeros() != BitWidth;
- }
-
- /// 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 {
- return countPopulation() == BitWidth;
- }
-
- /// This checks to see if the value of this APInt is the maximum unsigned
- /// value for the APInt's bit width.
- /// @brief Determine if this is the largest unsigned value.
- bool isMaxValue() const {
- return countPopulation() == BitWidth;
- }
-
- /// This checks to see if the value of this APInt is the maximum signed
- /// value for the APInt's bit width.
- /// @brief Determine if this is the largest signed value.
- bool isMaxSignedValue() const {
- return BitWidth == 1 ? VAL == 0 :
- !isNegative() && countPopulation() == BitWidth - 1;
- }
-
- /// This checks to see if the value of this APInt is the minimum unsigned
- /// value for the APInt's bit width.
- /// @brief Determine if this is the smallest unsigned value.
- bool isMinValue() const {
- return countPopulation() == 0;
- }
-
- /// This checks to see if the value of this APInt is the minimum signed
- /// value for the APInt's bit width.
- /// @brief Determine if this is the smallest signed value.
- bool isMinSignedValue() const {
- return BitWidth == 1 ? VAL == 1 :
- isNegative() && countPopulation() == 1;
- }
-
- /// 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;
-
- /// 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 toString(uint8_t radix = 10) const {
- return toString(radix, false);
- }
-
- /// 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 toStringSigned(uint8_t radix = 10) const {
- return toString(radix, true);
- }
-
- /// Get an APInt with the same BitWidth as this APInt, just zero mask
- /// the low bits and right shift to the least significant bit.
- /// @returns the high "numBits" bits of this APInt.
- APInt getHiBits(uint32_t numBits) const;
-
- /// Get an APInt with the same BitWidth as this APInt, just zero mask
- /// the high bits.
- /// @returns the low "numBits" bits of this APInt.
- APInt getLoBits(uint32_t numBits) const;
-
- /// @returns true if the argument APInt value is a power of two > 0.
- bool isPowerOf2() const;
-
/// 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.
@@ -714,30 +846,33 @@
/// @brief Count the number of bits set.
uint32_t countPopulation() const;
- /// @returns the total number of bits.
- inline uint32_t getBitWidth() const {
- return BitWidth;
+ /// @}
+ /// @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;
+
+ /// 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 toString(uint8_t radix = 10) const {
+ return toString(radix, false);
}
- /// @brief Check if this APInt has a N-bits integer value.
- inline bool isIntN(uint32_t N) const {
- assert(N && "N == 0 ???");
- if (isSingleWord()) {
- return VAL == (VAL & (~0ULL >> (64 - N)));
- } else {
- APInt Tmp(N, getNumWords(), pVal);
- return Tmp == (*this);
- }
+ /// 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 toStringSigned(uint8_t radix = 10) const {
+ return toString(radix, true);
}
/// @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 {
- return BitWidth - 1 - countLeadingZeros();
- }
-
/// @brief Converts this APInt to a double value.
double roundToDouble(bool isSigned) const;
@@ -811,6 +946,15 @@
return clearUnusedBits();
}
+ /// @}
+ /// @name Mathematics Operations
+ /// @{
+
+ /// @returns the floor log base 2 of this APInt.
+ inline uint32_t logBase2() const {
+ return BitWidth - 1 - countLeadingZeros();
+ }
+
/// @brief Compute the square root
APInt sqrt() const;
@@ -821,6 +965,7 @@
return -(*this);
return *this;
}
+ /// @}
};
inline bool operator==(uint64_t V1, const APInt& V2) {
More information about the llvm-commits
mailing list