[llvm-commits] [llvm] r47393 - /llvm/trunk/include/llvm/ADT/APInt.h
Dan Gohman
gohman at apple.com
Wed Feb 20 11:29:59 PST 2008
Author: djg
Date: Wed Feb 20 13:29:58 2008
New Revision: 47393
URL: http://llvm.org/viewvc/llvm-project?rev=47393&view=rev
Log:
Remove inline keywords from in-class function definitions, for
consistency.
Modified:
llvm/trunk/include/llvm/ADT/APInt.h
Modified: llvm/trunk/include/llvm/ADT/APInt.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/APInt.h?rev=47393&r1=47392&r2=47393&view=diff
==============================================================================
--- llvm/trunk/include/llvm/ADT/APInt.h (original)
+++ llvm/trunk/include/llvm/ADT/APInt.h Wed Feb 20 13:29:58 2008
@@ -87,20 +87,20 @@
/// @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;
}
@@ -109,7 +109,7 @@
/// 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);
}
@@ -118,7 +118,7 @@
/// 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)
@@ -138,7 +138,7 @@
/// @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)];
}
@@ -241,13 +241,13 @@
/// that 0 is not a positive value.
/// @returns true if this APInt is positive.
/// @brief Determine if this APInt Value is positive.
- inline bool isStrictlyPositive() const {
+ 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;
}
@@ -282,7 +282,7 @@
}
/// @brief Check if this APInt has an N-bits unsigned integer value.
- inline bool isIntN(uint32_t N) const {
+ bool isIntN(uint32_t N) const {
assert(N && "N == 0 ???");
if (isSingleWord()) {
return VAL == (VAL & (~0ULL >> (64 - N)));
@@ -293,7 +293,7 @@
}
/// @brief Check if this APInt has an N-bits signed integer value.
- inline bool isSignedIntN(uint32_t N) const {
+ bool isSignedIntN(uint32_t N) const {
assert(N && "N == 0 ???");
return getMinSignedBits() <= N;
}
@@ -306,7 +306,7 @@
/// 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;
}
@@ -344,7 +344,7 @@
/// 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);
}
@@ -430,7 +430,7 @@
/// 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];
@@ -441,7 +441,7 @@
/// @{
/// @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;
@@ -453,7 +453,7 @@
/// @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;
@@ -471,7 +471,7 @@
/// 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);
}
@@ -530,7 +530,7 @@
/// 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;
}
@@ -610,7 +610,7 @@
/// 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);
@@ -632,7 +632,7 @@
/// 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));
@@ -698,7 +698,7 @@
/// 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);
}
@@ -706,7 +706,7 @@
/// 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);
}
@@ -845,14 +845,14 @@
/// @{
/// @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;
}
@@ -860,14 +860,14 @@
/// 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;
}
@@ -878,7 +878,7 @@
/// 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;
@@ -888,7 +888,7 @@
/// 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");
@@ -899,7 +899,7 @@
/// 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);
@@ -966,7 +966,7 @@
/// 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 {
+ std::string toStringUnsigned(uint8_t radix = 10) const {
return toString(radix, false);
}
@@ -974,7 +974,7 @@
/// 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 {
+ std::string toStringSigned(uint8_t radix = 10) const {
return toString(radix, true);
}
@@ -1059,13 +1059,13 @@
/// @{
/// @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();
More information about the llvm-commits
mailing list