[llvm-commits] CVS: llvm/include/llvm/ADT/APInt.h
Reid Spencer
reid at x10sys.com
Sun Feb 18 10:42:51 PST 2007
Changes in directory llvm/include/llvm/ADT:
APInt.h updated: 1.12 -> 1.13
---
Log message:
1. "unsigned" -> "uint32_t" to gaurantee its bit width on all platforms.
Size matters in this case.
2. Remove the unused whichByte private function, which was also broken.
3. Remove the non-const overload of the getWord function, getWord() is
never used as an lvalue.
4. Rename some local variables for clarity (e.g. API -> Result).
---
Diffs of the changes: (+47 -56)
APInt.h | 103 +++++++++++++++++++++++++++++-----------------------------------
1 files changed, 47 insertions(+), 56 deletions(-)
Index: llvm/include/llvm/ADT/APInt.h
diff -u llvm/include/llvm/ADT/APInt.h:1.12 llvm/include/llvm/ADT/APInt.h:1.13
--- llvm/include/llvm/ADT/APInt.h:1.12 Sat Feb 17 18:44:22 2007
+++ llvm/include/llvm/ADT/APInt.h Sun Feb 18 12:42:35 2007
@@ -59,7 +59,8 @@
///
/// @brief Class for arbitrary precision integers.
class APInt {
- unsigned BitWidth; ///< The number of bits in this APInt.
+public:
+ 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;
@@ -77,7 +78,7 @@
/// 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 unsigned getNumWords() const {
+ inline uint32_t getNumWords() const {
return (BitWidth + APINT_BITS_PER_WORD - 1) / APINT_BITS_PER_WORD;
}
@@ -88,24 +89,19 @@
}
/// @returns the word position for the specified bit position.
- static inline unsigned whichWord(unsigned bitPosition) {
+ static inline uint32_t whichWord(uint32_t bitPosition) {
return bitPosition / APINT_BITS_PER_WORD;
}
- /// @returns the byte position for the specified bit position.
- static inline unsigned whichByte(unsigned bitPosition) {
- return (bitPosition % APINT_BITS_PER_WORD) / 8;
- }
-
/// @returns the bit position in a word for the specified bit position
/// in APInt.
- static inline unsigned whichBit(unsigned bitPosition) {
+ 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.
- static inline uint64_t maskBit(unsigned bitPosition) {
+ static inline uint64_t maskBit(uint32_t bitPosition) {
return (static_cast<uint64_t>(1)) << whichBit(bitPosition);
}
@@ -122,35 +118,30 @@
}
/// @returns the corresponding word for the specified bit position.
- inline uint64_t& getWord(unsigned bitPosition) {
- return isSingleWord() ? VAL : pVal[whichWord(bitPosition)];
- }
-
- /// @returns the corresponding word for the specified bit position.
/// This is a constant version.
- inline uint64_t getWord(unsigned bitPosition) const {
+ inline uint64_t getWord(uint32_t bitPosition) const {
return isSingleWord() ? VAL : pVal[whichWord(bitPosition)];
}
/// @brief Converts a char array into an integer.
- void fromString(unsigned numBits, const char *StrStart, unsigned slen,
+ void fromString(uint32_t numBits, const char *StrStart, uint32_t slen,
uint8_t radix);
public:
/// @brief Create a new APInt of numBits bit-width, and initialized as val.
- APInt(unsigned numBits, uint64_t val);
+ APInt(uint32_t numBits, uint64_t val);
/// @brief Create a new APInt of numBits bit-width, and initialized as
/// bigVal[].
- APInt(unsigned numBits, unsigned numWords, uint64_t bigVal[]);
+ APInt(uint32_t numBits, uint32_t numWords, uint64_t bigVal[]);
/// @brief Create a new APInt by translating the string represented
/// integer value.
- APInt(unsigned numBits, const std::string& Val, uint8_t radix);
+ 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(unsigned numBits, const char StrStart[], unsigned slen, uint8_t radix);
+ APInt(uint32_t numBits, const char StrStart[], uint32_t slen, uint8_t radix);
/// @brief Copy Constructor.
APInt(const APInt& API);
@@ -258,7 +249,7 @@
}
/// @brief Array-indexing support.
- bool operator[](unsigned bitPosition) const;
+ bool operator[](uint32_t bitPosition) const;
/// Compare this APInt with the given APInt& RHS
/// for the validity of the equality relationship.
@@ -332,24 +323,24 @@
/// Arithmetic right-shift this APInt by shiftAmt.
/// @brief Arithmetic right-shift function.
- APInt ashr(unsigned shiftAmt) const;
+ APInt ashr(uint32_t shiftAmt) const;
/// Logical right-shift this APInt by shiftAmt.
/// @brief Logical right-shift function.
- APInt lshr(unsigned shiftAmt) const;
+ APInt lshr(uint32_t shiftAmt) const;
/// Left-shift this APInt by shiftAmt.
/// @brief Left-shift function.
- APInt shl(unsigned shiftAmt) const;
+ APInt shl(uint32_t shiftAmt) const;
/// Signed divide this APInt by APInt RHS.
/// @brief Signed division function for APInt.
inline APInt sdiv(const APInt& RHS) const {
bool isNegativeLHS = (*this)[BitWidth - 1];
bool isNegativeRHS = RHS[RHS.BitWidth - 1];
- APInt API = APIntOps::udiv(
+ APInt Result = APIntOps::udiv(
isNegativeLHS ? -(*this) : (*this), isNegativeRHS ? -RHS : RHS);
- return isNegativeLHS != isNegativeRHS ? -API : API;;
+ return isNegativeLHS != isNegativeRHS ? -Result : Result;
}
/// Unsigned divide this APInt by APInt RHS.
@@ -361,9 +352,9 @@
inline APInt srem(const APInt& RHS) const {
bool isNegativeLHS = (*this)[BitWidth - 1];
bool isNegativeRHS = RHS[RHS.BitWidth - 1];
- APInt API = APIntOps::urem(
+ APInt Result = APIntOps::urem(
isNegativeLHS ? -(*this) : (*this), isNegativeRHS ? -RHS : RHS);
- return isNegativeLHS ? -API : API;
+ return isNegativeLHS ? -Result : Result;
}
/// Unsigned remainder operation on APInt.
@@ -373,34 +364,34 @@
/// 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.
- void trunc(unsigned width);
+ void trunc(uint32_t width);
/// This operation sign extends the APInt to a new width. If the high order
/// bit is set, the fill on the left will be done with 1 bits, otherwise zero.
/// It is an error to specify a width that is less than or equal to the
/// current width.
/// @brief Sign extend to a new width.
- void sext(unsigned width);
+ void sext(uint32_t width);
/// This operation zero extends the APInt to a new width. Thie high order bits
/// are filled with 0 bits. It is an error to specify a width that is less
/// than or equal to the current width.
/// @brief Zero extend to a new width.
- void zext(unsigned width);
+ void zext(uint32_t width);
/// @brief Set every bit to 1.
APInt& set();
/// Set the given bit to 1 whose position is given as "bitPosition".
/// @brief Set a given bit to 1.
- APInt& set(unsigned bitPosition);
+ APInt& set(uint32_t bitPosition);
/// @brief Set every bit to 0.
APInt& clear();
/// Set the given bit to 0 whose position is given as "bitPosition".
/// @brief Set a given bit to 0.
- APInt& clear(unsigned bitPosition);
+ APInt& clear(uint32_t bitPosition);
/// @brief Toggle every bit to its opposite value.
APInt& flip();
@@ -408,13 +399,13 @@
/// Toggle a given bit to its opposite value whose position is given
/// as "bitPosition".
/// @brief Toggles a given bit to its opposite value.
- APInt& flip(unsigned bitPosition);
+ APInt& flip(uint32_t bitPosition);
/// This function returns the number of active bits which is defined as the
/// 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 unsigned getActiveBits() const {
+ inline uint32_t getActiveBits() const {
return getNumWords() * APINT_BITS_PER_WORD - countLeadingZeros();
}
@@ -424,7 +415,7 @@
if (isSingleWord())
return isSigned ? int64_t(VAL << (64 - BitWidth)) >>
(64 - BitWidth) : VAL;
- unsigned n = getActiveBits();
+ uint32_t n = getActiveBits();
if (n <= 64)
return pVal[0];
assert(0 && "This APInt's bitwidth > 64");
@@ -434,20 +425,20 @@
/// if isSign == true, it should be largest signed value, otherwise largest
/// unsigned value.
/// @brief Gets max value of the APInt with bitwidth <= 64.
- static APInt getMaxValue(unsigned numBits, bool isSign);
+ static APInt getMaxValue(uint32_t numBits, bool isSign);
/// @returns the smallest value for an APInt of the given bit-width and
/// if isSign == true, it should be smallest signed value, otherwise zero.
/// @brief Gets min value of the APInt with bitwidth <= 64.
- static APInt getMinValue(unsigned numBits, bool isSign);
+ static APInt getMinValue(uint32_t numBits, bool isSign);
/// @returns the all-ones value for an APInt of the specified bit-width.
/// @brief Get the all-ones value.
- static APInt getAllOnesValue(unsigned numBits);
+ static APInt getAllOnesValue(uint32_t numBits);
/// @returns the '0' value for an APInt of the specified bit-width.
/// @brief Get the '0' value.
- static APInt getNullValue(unsigned numBits);
+ static APInt getNullValue(uint32_t numBits);
/// This converts the APInt to a boolean valy as a test against zero.
/// @brief Boolean conversion function.
@@ -461,34 +452,34 @@
/// 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(unsigned numBits) const;
+ 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(unsigned numBits) const;
+ APInt getLoBits(uint32_t numBits) const;
/// @returns true if the argument APInt value is a power of two > 0.
bool isPowerOf2() const;
/// @returns the number of zeros from the most significant bit to the first
/// one bits.
- unsigned countLeadingZeros() const;
+ uint32_t countLeadingZeros() const;
/// @returns the number of zeros from the least significant bit to the first
/// one bit.
- unsigned countTrailingZeros() const;
+ uint32_t countTrailingZeros() const;
/// @returns the number of set bits.
- unsigned countPopulation() const;
+ uint32_t countPopulation() const;
/// @returns the total number of bits.
- inline unsigned getBitWidth() const {
+ inline uint32_t getBitWidth() const {
return BitWidth;
}
/// @brief Check if this APInt has a N-bits integer value.
- inline bool isIntN(unsigned N) const {
+ inline bool isIntN(uint32_t N) const {
assert(N && "N == 0 ???");
if (isSingleWord()) {
return VAL == (VAL & (~0ULL >> (64 - N)));
@@ -502,7 +493,7 @@
APInt byteSwap() const;
/// @returns the floor log base 2 of this APInt.
- inline unsigned logBase2() const {
+ inline uint32_t logBase2() const {
return getNumWords() * APINT_BITS_PER_WORD - 1 - countLeadingZeros();
}
@@ -514,19 +505,19 @@
namespace APIntOps {
/// @brief Check if the specified APInt has a N-bits integer value.
-inline bool isIntN(unsigned N, const APInt& APIVal) {
+inline bool isIntN(uint32_t N, const APInt& APIVal) {
return APIVal.isIntN(N);
}
/// @returns true if the argument APInt value is a sequence of ones
/// starting at the least significant bit with the remainder zero.
-inline const bool isMask(unsigned numBits, const APInt& APIVal) {
+inline const bool isMask(uint32_t numBits, const APInt& APIVal) {
return APIVal.getBoolValue() && ((APIVal + APInt(numBits,1)) & APIVal) == 0;
}
/// @returns true if the argument APInt value contains a sequence of ones
/// with the remainder zero.
-inline const bool isShiftedMask(unsigned numBits, const APInt& APIVal) {
+inline const bool isShiftedMask(uint32_t numBits, const APInt& APIVal) {
return isMask(numBits, (APIVal - APInt(numBits,1)) | APIVal);
}
@@ -536,7 +527,7 @@
}
/// @returns the floor log base 2 of the specified APInt value.
-inline unsigned logBase2(const APInt& APIVal) {
+inline uint32_t logBase2(const APInt& APIVal) {
return APIVal.logBase2();
}
@@ -564,19 +555,19 @@
/// Arithmetic right-shift the APInt by shiftAmt.
/// @brief Arithmetic right-shift function.
-inline APInt ashr(const APInt& LHS, unsigned shiftAmt) {
+inline APInt ashr(const APInt& LHS, uint32_t shiftAmt) {
return LHS.ashr(shiftAmt);
}
/// Logical right-shift the APInt by shiftAmt.
/// @brief Logical right-shift function.
-inline APInt lshr(const APInt& LHS, unsigned shiftAmt) {
+inline APInt lshr(const APInt& LHS, uint32_t shiftAmt) {
return LHS.lshr(shiftAmt);
}
/// Left-shift the APInt by shiftAmt.
/// @brief Left-shift function.
-inline APInt shl(const APInt& LHS, unsigned shiftAmt) {
+inline APInt shl(const APInt& LHS, uint32_t shiftAmt) {
return LHS.shl(shiftAmt);
}
More information about the llvm-commits
mailing list