[llvm-commits] CVS: llvm/include/llvm/ADT/APInt.h
Zhou Sheng
zhousheng00 at gmail.com
Tue Feb 6 21:58:54 PST 2007
Changes in directory llvm/include/llvm/ADT:
APInt.h updated: 1.2 -> 1.3
---
Log message:
As Chris suggested, fixed some problems. (This is the first part.)
---
Diffs of the changes: (+47 -21)
APInt.h | 68 ++++++++++++++++++++++++++++++++++++++++++++--------------------
1 files changed, 47 insertions(+), 21 deletions(-)
Index: llvm/include/llvm/ADT/APInt.h
diff -u llvm/include/llvm/ADT/APInt.h:1.2 llvm/include/llvm/ADT/APInt.h:1.3
--- llvm/include/llvm/ADT/APInt.h:1.2 Mon Feb 5 23:59:47 2007
+++ llvm/include/llvm/ADT/APInt.h Tue Feb 6 23:58:38 2007
@@ -45,7 +45,7 @@
friend double APIntToDouble(const APInt& APIVal);
friend float APIntToFloat(const APInt& APIVal);
- unsigned bitsnum; ///< The number of bits.
+ unsigned BitsNum; ///< The number of bits.
bool isSigned; ///< The sign flag for this APInt.
/// This union is used to store the integer value. When the
@@ -64,22 +64,22 @@
/// 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 numWords() const {
- return bitsnum < 1 ? 0 : (bitsnum + APINT_BITS_PER_WORD - 1) /
- APINT_BITS_PER_WORD;
+ inline unsigned getNumWords() const {
+ return (BitsNum + APINT_BITS_PER_WORD - 1) / APINT_BITS_PER_WORD;
}
/// @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
- { return bitsnum <= APINT_BITS_PER_WORD; }
+ { return BitsNum <= APINT_BITS_PER_WORD; }
/// @returns the word position for the specified bit position.
static inline unsigned whichWord(unsigned bitPosition)
{ return bitPosition / APINT_BITS_PER_WORD; }
/// @returns the byte position for the specified bit position.
- static inline unsigned whichByte(unsigned bitPosition);
+ 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.
@@ -93,10 +93,10 @@
inline void TruncToBits() {
if (isSingleWord())
- VAL &= ~uint64_t(0ULL) >> (APINT_BITS_PER_WORD - bitsnum);
+ VAL &= ~uint64_t(0ULL) >> (APINT_BITS_PER_WORD - BitsNum);
else
- pVal[numWords() - 1] &= ~uint64_t(0ULL) >>
- (APINT_BITS_PER_WORD - (whichBit(bitsnum - 1) + 1));
+ pVal[getNumWords() - 1] &= ~uint64_t(0ULL) >>
+ (APINT_BITS_PER_WORD - (whichBit(BitsNum - 1) + 1));
}
/// @returns the corresponding word for the specified bit position.
@@ -108,6 +108,9 @@
inline uint64_t getWord(unsigned bitPosition) const
{ return isSingleWord() ? VAL : pVal[whichWord(bitPosition)]; }
+ /// @brief Converts a char array into an integer.
+ void StrToAPInt(const char *StrStart, unsigned slen, uint8_t radix);
+
public:
/// @brief Create a new APInt of numBits bit-width, and initialized as val.
APInt(uint64_t val = 0, unsigned numBits = APINT_BITS_PER_WORD,
@@ -119,7 +122,11 @@
/// @brief Create a new APInt by translating the string represented
/// integer value.
- APInt(std::string& Val, uint8_t radix = 10, bool sign = false);
+ APInt(const std::string& Val, uint8_t radix = 10, bool sign = false);
+
+ /// @brief Create a new APInt by translating the char array represented
+ /// integer value.
+ APInt(const char StrStart[], unsigned slen, uint8_t radix, bool sign = false);
/// @brief Copy Constructor.
APInt(const APInt& API);
@@ -136,7 +143,10 @@
/// Increments the APInt by one.
/// @brief Postfix increment operator.
- const APInt operator++(int);
+ inline const APInt operator++(int) {
+ APInt API(*this);
+ return ++API;
+ }
/// Increments the APInt by one.
/// @brief Prefix increment operator.
@@ -144,7 +154,10 @@
/// Decrements the APInt by one.
/// @brief Postfix decrement operator.
- const APInt operator--(int);
+ inline const APInt operator--(int) {
+ APInt API(*this);
+ return --API;
+ }
/// Decrements the APInt by one.
/// @brief Prefix decrement operator.
@@ -264,11 +277,25 @@
/// @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.
+ /// @brief Equality operator.
+ bool operator==(uint64_t Val) const;
+
/// Compare this APInt with the given APInt& RHS
/// for the validity of the inequality relationship.
/// @brief Inequality operator.
- bool operator!=(const APInt& RHS) const;
+ 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.
+ /// @brief Inequality operator.
+ inline bool operator!=(uint64_t Val) const {
+ return !((*this) == Val);
+ }
+
/// Compare this APInt with the given APInt& RHS for
/// the validity of the less-than relationship.
/// @brief Less-than operator.
@@ -293,11 +320,10 @@
/// word, just returns VAL, otherwise pVal[0].
inline uint64_t getValue() {
if (isSingleWord())
- return isSigned ? ((int64_t(VAL) << (APINT_BITS_PER_WORD - bitsnum)) >>
- (APINT_BITS_PER_WORD - bitsnum)) :
+ return isSigned ? ((int64_t(VAL) << (APINT_BITS_PER_WORD - BitsNum)) >>
+ (APINT_BITS_PER_WORD - BitsNum)) :
VAL;
- else
- return pVal[0];
+ assert(0 && "This APInt's bitwidth > 64");
}
/// @returns the largest value for an APInt of the specified bit-width and
@@ -344,12 +370,12 @@
/// @returns a character interpretation of the APInt.
std::string to_string(uint8_t radix = 10) const;
- /// Get an APInt with the same bitsnum as this APInt, just zero mask
+ /// Get an APInt with the same BitsNum 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 HiBits(unsigned numBits) const;
- /// Get an APInt with the same bitsnum as this APInt, just zero mask
+ /// Get an APInt with the same BitsNum as this APInt, just zero mask
/// the high bits.
/// @returns the low "numBits" bits of this APInt.
APInt LoBits(unsigned numBits) const;
@@ -372,7 +398,7 @@
/// @returns the total number of bits.
inline unsigned getNumBits() const
- { return bitsnum; }
+ { return BitsNum; }
};
@@ -404,7 +430,7 @@
/// @returns the floor log base 2 of the specified APInt value.
inline APInt LogBase2(const APInt& APIVal) {
- return APIVal.numWords() * APInt::APINT_BITS_PER_WORD -
+ return APIVal.getNumWords() * APInt::APINT_BITS_PER_WORD -
APIVal.CountLeadingZeros();
}
More information about the llvm-commits
mailing list