// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-///
+///
/// \file
/// \brief This file implements a class to represent arbitrary precision
/// integral constant values and operations on them.
#include <string>
namespace llvm {
- class Deserializer;
- class FoldingSetNodeID;
- class Serializer;
- class StringRef;
- class hash_code;
- class raw_ostream;
+class FoldingSetNodeID;
+class StringRef;
+class hash_code;
+class raw_ostream;
- template<typename T>
- class SmallVectorImpl;
+template <typename T> class SmallVectorImpl;
- // An unsigned host type used as a single part of a multi-part
- // bignum.
- typedef uint64_t integerPart;
+// 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 *
- static_cast<unsigned int>(sizeof(integerPart));
+const unsigned int host_char_bit = 8;
+const unsigned int integerPartWidth =
+ host_char_bit * static_cast<unsigned int>(sizeof(integerPart));
//===----------------------------------------------------------------------===//
// APInt Class
/// uses in its IR. This simplifies its use for LLVM.
///
class APInt {
- unsigned BitWidth; ///< The number of bits in this APInt.
+ unsigned 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 pVal.
union {
- uint64_t VAL; ///< Used to store the <= 64 bits integer value.
- uint64_t *pVal; ///< Used to store the >64 bits integer value.
+ 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 used to hold the constants we needed for APInt.
enum {
/// Bits in a word
- APINT_BITS_PER_WORD = static_cast<unsigned int>(sizeof(uint64_t)) *
- CHAR_BIT,
+ APINT_BITS_PER_WORD =
+ static_cast<unsigned int>(sizeof(uint64_t)) * CHAR_BIT,
/// Byte size of a word
APINT_WORD_SIZE = static_cast<unsigned int>(sizeof(uint64_t))
};
+ friend struct DenseMapAPIntKeyInfo;
+
/// \brief 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.
- APInt(uint64_t* val, unsigned bits) : BitWidth(bits), pVal(val) { }
+ APInt(uint64_t *val, unsigned bits) : BitWidth(bits), pVal(val) {}
/// \brief Determine if this APInt just has one word to store value.
///
/// \returns true if the number of bits <= 64, false otherwise.
- bool isSingleWord() const {
- return BitWidth <= APINT_BITS_PER_WORD;
- }
+ bool isSingleWord() const { return BitWidth <= APINT_BITS_PER_WORD; }
/// \brief Determine which word a bit is in.
///
/// \brief Clear unused high order bits
///
- /// This method is used internally to clear the to "N" bits in the high order
+ /// This method is used internally to clear the top "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.
- APInt& clearUnusedBits() {
+ APInt &clearUnusedBits() {
// Compute how many bits are used in the final word
unsigned wordBits = BitWidth % APINT_BITS_PER_WORD;
if (wordBits == 0)
/// provides a more convenient form of divide for internal use since KnuthDiv
/// has specific constraints on its inputs. If those constraints are not met
/// then it provides a simpler form of divide.
- static void divide(const APInt LHS, unsigned lhsWords,
- const APInt &RHS, unsigned rhsWords,
- APInt *Quotient, APInt *Remainder);
+ static void divide(const APInt LHS, unsigned lhsWords, const APInt &RHS,
+ unsigned rhsWords, APInt *Quotient, APInt *Remainder);
/// out-of-line slow case for inline constructor
void initSlowCase(unsigned numBits, uint64_t val, bool isSigned);
void initFromArray(ArrayRef<uint64_t> array);
/// out-of-line slow case for inline copy constructor
- void initSlowCase(const APInt& that);
+ void initSlowCase(const APInt &that);
/// out-of-line slow case for shl
APInt shlSlowCase(unsigned shiftAmt) const;
/// out-of-line slow case for operator&
- APInt AndSlowCase(const APInt& RHS) const;
+ APInt AndSlowCase(const APInt &RHS) const;
/// out-of-line slow case for operator|
- APInt OrSlowCase(const APInt& RHS) const;
+ APInt OrSlowCase(const APInt &RHS) const;
/// out-of-line slow case for operator^
- APInt XorSlowCase(const APInt& RHS) const;
+ APInt XorSlowCase(const APInt &RHS) const;
/// out-of-line slow case for operator=
- APInt& AssignSlowCase(const APInt& RHS);
+ APInt &AssignSlowCase(const APInt &RHS);
/// out-of-line slow case for operator==
- bool EqualSlowCase(const APInt& RHS) const;
+ bool EqualSlowCase(const APInt &RHS) const;
/// out-of-line slow case for operator==
bool EqualSlowCase(uint64_t Val) const;
/// \param val the initial value of the APInt
/// \param isSigned how to treat signedness of val
APInt(unsigned numBits, uint64_t val, bool isSigned = false)
- : BitWidth(numBits), VAL(0) {
+ : BitWidth(numBits), VAL(0) {
assert(BitWidth && "bitwidth too small");
if (isSingleWord())
VAL = val;
/// This constructor interprets the string \p str in the given radix. The
/// interpretation stops when the first character that is not suitable for the
/// radix is encountered, or the end of the string. Acceptable radix values
- /// are 2, 8, 10, 16, and 36. It is an error for the value implied by the
+ /// are 2, 8, 10, 16, and 36. 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 str the string to be interpreted
- /// \param radix the radix to use for the conversion
+ /// \param radix the radix to use for the conversion
APInt(unsigned numBits, StringRef str, uint8_t radix);
/// Simply makes *this a copy of that.
/// @brief Copy Constructor.
- APInt(const APInt& that)
- : BitWidth(that.BitWidth), VAL(0) {
- assert(BitWidth && "bitwidth too small");
+ APInt(const APInt &that) : BitWidth(that.BitWidth), VAL(0) {
if (isSingleWord())
VAL = that.VAL;
else
initSlowCase(that);
}
-#if LLVM_HAS_RVALUE_REFERENCES
/// \brief Move Constructor.
- APInt(APInt&& that) : BitWidth(that.BitWidth), VAL(that.VAL) {
+ APInt(APInt &&that) : BitWidth(that.BitWidth), VAL(that.VAL) {
that.BitWidth = 0;
}
-#endif
/// \brief Destructor.
~APInt() {
- if (!isSingleWord())
- delete [] pVal;
+ if (needsCleanup())
+ delete[] pVal;
}
- /// \brief Default constructor that creates an uninitialized APInt.
+ /// \brief Default constructor that creates an uninteresting APInt
+ /// representing a 1-bit zero value.
///
/// This is useful for object deserialization (pair this with the static
/// method Read).
- explicit APInt() : BitWidth(1) {}
+ explicit APInt() : BitWidth(1), VAL(0) {}
+
+ /// \brief Returns whether this instance allocated memory.
+ bool needsCleanup() const { return !isSingleWord(); }
/// Used to insert APInt objects, or objects that contain APInt objects, into
/// FoldingSets.
- void Profile(FoldingSetNodeID& id) const;
+ void Profile(FoldingSetNodeID &id) const;
/// @}
/// \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
- bool isNegative() const {
- return (*this)[BitWidth - 1];
- }
+ bool isNegative() const { return (*this)[BitWidth - 1]; }
/// \brief Determine if this APInt Value is non-negative (>= 0)
///
/// This tests the high bit of the APInt to determine if it is unset.
- bool isNonNegative() const {
- return !isNegative();
- }
+ bool isNonNegative() const { return !isNegative(); }
/// \brief Determine if this APInt Value is positive.
///
/// that 0 is not a positive value.
///
/// \returns true if this APInt is positive.
- bool isStrictlyPositive() const {
- return isNonNegative() && !!*this;
- }
+ bool isStrictlyPositive() const { return isNonNegative() && !!*this; }
/// \brief Determine if all bits are set
///
/// This checks to see if the value has all bits of the APInt are set or not.
bool isAllOnesValue() const {
- return countPopulation() == BitWidth;
+ if (isSingleWord())
+ return VAL == ~integerPart(0) >> (APINT_BITS_PER_WORD - BitWidth);
+ return countPopulationSlowCase() == BitWidth;
}
/// \brief Determine if this is the largest unsigned value.
///
/// This checks to see if the value of this APInt is the maximum unsigned
/// value for the APInt's bit width.
- bool isMaxValue() const {
- return countPopulation() == BitWidth;
- }
+ bool isMaxValue() const { return isAllOnesValue(); }
/// \brief Determine if this is the largest signed value.
///
/// This checks to see if the value of this APInt is the maximum signed
/// value for the APInt's bit width.
bool isMaxSignedValue() const {
- return BitWidth == 1 ? VAL == 0 :
- !isNegative() && countPopulation() == BitWidth - 1;
+ return !isNegative() && countPopulation() == BitWidth - 1;
}
/// \brief Determine if this is the smallest unsigned value.
///
/// This checks to see if the value of this APInt is the minimum unsigned
/// value for the APInt's bit width.
- bool isMinValue() const {
- return !*this;
- }
+ bool isMinValue() const { return !*this; }
/// \brief Determine if this is the smallest signed value.
///
/// This checks to see if the value of this APInt is the minimum signed
/// value for the APInt's bit width.
bool isMinSignedValue() const {
- return BitWidth == 1 ? VAL == 1 : isNegative() && isPowerOf2();
+ return isNegative() && isPowerOf2();
}
/// \brief Check if this APInt has an N-bits unsigned integer value.
/// \brief Convert APInt to a boolean value.
///
/// This converts the APInt to a boolean value as a test against zero.
- bool getBoolValue() const {
- return !!*this;
- }
+ bool getBoolValue() const { return !!*this; }
/// If this value is smaller than the specified limit, return it, otherwise
/// return the limit value. This causes the value to saturate to the limit.
uint64_t getLimitedValue(uint64_t Limit = ~0ULL) const {
- return (getActiveBits() > 64 || getZExtValue() > Limit) ?
- Limit : getZExtValue();
+ return (getActiveBits() > 64 || getZExtValue() > Limit) ? Limit
+ : getZExtValue();
}
+ /// \brief Check if the APInt consists of a repeated bit pattern.
+ ///
+ /// e.g. 0x01010101 satisfies isSplat(8).
+ /// \param SplatSizeInBits The size of the pattern in bits. Must divide bit
+ /// width without remainder.
+ bool isSplat(unsigned SplatSizeInBits) const;
+
/// @}
/// \name Value Generators
/// @{
}
/// \brief Gets minimum unsigned value of APInt for a specific bit width.
- static APInt getMinValue(unsigned numBits) {
- return APInt(numBits, 0);
- }
+ static APInt getMinValue(unsigned numBits) { return APInt(numBits, 0); }
/// \brief Gets minimum signed value of APInt for a specific bit width.
static APInt getSignedMinValue(unsigned numBits) {
/// \brief Get the '0' value.
///
/// \returns the '0' value for an APInt of the specified bit-width.
- static APInt getNullValue(unsigned numBits) {
- return APInt(numBits, 0);
- }
+ static APInt getNullValue(unsigned numBits) { return APInt(numBits, 0); }
/// \brief Compute an APInt containing numBits highbits from this APInt.
///
Res.setBit(BitNo);
return Res;
}
-
+
/// \brief Get a value with a block of bits set.
///
/// Constructs an APInt value that has a contiguous range of bits set. The
assert(loBit < numBits && "loBit out of range");
if (hiBit < loBit)
return getLowBitsSet(numBits, hiBit) |
- getHighBitsSet(numBits, numBits-loBit);
- return getLowBitsSet(numBits, hiBit-loBit).shl(loBit);
+ getHighBitsSet(numBits, numBits - loBit);
+ return getLowBitsSet(numBits, hiBit - loBit).shl(loBit);
}
/// \brief Get a value with high bits set
return I1.zext(I2.getBitWidth()) == I2;
}
-
+
/// \brief Overload to compute a hash_code for an APInt value.
friend hash_code hash_value(const APInt &Arg);
/// 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.
- const uint64_t* getRawData() const {
+ const uint64_t *getRawData() const {
if (isSingleWord())
return &VAL;
return &pVal[0];
/// \brief Prefix increment operator.
///
/// \returns *this incremented by one
- APInt& operator++();
+ APInt &operator++();
/// \brief Postfix decrement operator.
///
/// \brief Prefix decrement operator.
///
/// \returns *this decremented by one.
- APInt& operator--();
+ APInt &operator--();
/// \brief Unary bitwise complement operator.
///
/// Negates *this using two's complement logic.
///
/// \returns An APInt value representing the negation of *this.
- APInt operator-() const {
- return APInt(BitWidth, 0) - (*this);
- }
+ APInt operator-() const { return APInt(BitWidth, 0) - (*this); }
/// \brief Logical negation operator.
///
/// \brief Copy assignment operator.
///
/// \returns *this after assignment of RHS.
- 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;
return AssignSlowCase(RHS);
}
-#if LLVM_HAS_RVALUE_REFERENCES
/// @brief Move assignment operator.
- APInt& operator=(APInt&& that) {
- if (!isSingleWord())
- delete [] pVal;
+ APInt &operator=(APInt &&that) {
+ if (!isSingleWord()) {
+ // The MSVC STL shipped in 2013 requires that self move assignment be a
+ // no-op. Otherwise algorithms like stable_sort will produce answers
+ // where half of the output is left in a moved-from state.
+ if (this == &that)
+ return *this;
+ delete[] pVal;
+ }
- BitWidth = that.BitWidth;
- VAL = that.VAL;
+ // Use memcpy so that type based alias analysis sees both VAL and pVal
+ // as modified.
+ memcpy(&VAL, &that.VAL, sizeof(uint64_t));
+ // If 'this == &that', avoid zeroing our own bitwidth by storing to 'that'
+ // first.
+ unsigned ThatBitWidth = that.BitWidth;
that.BitWidth = 0;
+ BitWidth = ThatBitWidth;
return *this;
}
-#endif
/// \brief Assignment operator.
///
/// than 64, the value is zero filled in the unspecified high order bits.
///
/// \returns *this after assignment of RHS value.
- APInt& operator=(uint64_t RHS);
+ APInt &operator=(uint64_t RHS);
/// \brief Bitwise AND assignment operator.
///
/// assigned to *this.
///
/// \returns *this after ANDing with RHS.
- APInt& operator&=(const APInt& RHS);
+ APInt &operator&=(const APInt &RHS);
/// \brief Bitwise OR assignment operator.
///
/// assigned *this;
///
/// \returns *this after ORing with RHS.
- APInt& operator|=(const APInt& RHS);
+ APInt &operator|=(const APInt &RHS);
/// \brief Bitwise OR assignment operator.
///
/// Performs a bitwise OR operation on this APInt and RHS. RHS is
/// logically zero-extended or truncated to match the bit-width of
/// the LHS.
- APInt& operator|=(uint64_t RHS) {
+ APInt &operator|=(uint64_t RHS) {
if (isSingleWord()) {
VAL |= RHS;
clearUnusedBits();
/// assigned to *this.
///
/// \returns *this after XORing with RHS.
- APInt& operator^=(const APInt& RHS);
+ APInt &operator^=(const APInt &RHS);
/// \brief Multiplication assignment operator.
///
/// Multiplies this APInt by RHS and assigns the result to *this.
///
/// \returns *this
- APInt& operator*=(const APInt& RHS);
+ APInt &operator*=(const APInt &RHS);
/// \brief Addition assignment operator.
///
/// Adds RHS to *this and assigns the result to *this.
///
/// \returns *this
- APInt& operator+=(const APInt& RHS);
+ APInt &operator+=(const APInt &RHS);
/// \brief Subtraction assignment operator.
///
/// Subtracts RHS from *this and assigns the result to *this.
///
/// \returns *this
- APInt& operator-=(const APInt& RHS);
+ APInt &operator-=(const APInt &RHS);
/// \brief Left-shift assignment function.
///
/// Shifts *this left by shiftAmt and assigns the result to *this.
///
/// \returns *this after shifting left by shiftAmt
- APInt& operator<<=(unsigned shiftAmt) {
+ APInt &operator<<=(unsigned 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.
- 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 {
+ APInt LLVM_ATTRIBUTE_UNUSED_RESULT 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.
- 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);
/// \brief Bitwise OR function.
///
- /// Performs a bitwise or on *this and RHS. This is implemented bny simply
+ /// Performs a bitwise or on *this and RHS. This is implemented by simply
/// calling operator|.
///
/// \returns An APInt value representing the bitwise OR of *this and RHS.
- APInt Or(const APInt& RHS) const {
+ APInt LLVM_ATTRIBUTE_UNUSED_RESULT 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.
- 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);
/// through the usage of operator^.
///
/// \returns An APInt value representing the bitwise XOR of *this and RHS.
- APInt Xor(const APInt& RHS) const {
+ APInt LLVM_ATTRIBUTE_UNUSED_RESULT Xor(const APInt &RHS) const {
return this->operator^(RHS);
}
/// \brief Multiplication operator.
///
/// Multiplies this APInt by RHS and returns the result.
- APInt operator*(const APInt& RHS) const;
+ APInt operator*(const APInt &RHS) const;
/// \brief Addition operator.
///
/// Adds RHS to this APInt and returns the result.
- APInt operator+(const APInt& RHS) const;
- APInt operator+(uint64_t RHS) const {
- return (*this) + APInt(BitWidth, RHS);
- }
+ APInt operator+(const APInt &RHS) const;
+ APInt operator+(uint64_t RHS) const { return (*this) + APInt(BitWidth, RHS); }
/// \brief Subtraction operator.
///
/// Subtracts RHS from this APInt and returns the result.
- APInt operator-(const APInt& RHS) const;
- APInt operator-(uint64_t RHS) const {
- return (*this) - APInt(BitWidth, RHS);
- }
+ APInt operator-(const APInt &RHS) const;
+ APInt operator-(uint64_t RHS) const { return (*this) - APInt(BitWidth, RHS); }
/// \brief Left logical shift operator.
///
/// Shifts this APInt left by \p Bits and returns the result.
- APInt operator<<(unsigned Bits) const {
- return shl(Bits);
- }
+ APInt operator<<(unsigned Bits) const { return shl(Bits); }
/// \brief Left logical shift operator.
///
/// Shifts this APInt left by \p Bits and returns the result.
- APInt operator<<(const APInt &Bits) const {
- return shl(Bits);
- }
+ APInt operator<<(const APInt &Bits) const { return shl(Bits); }
/// \brief Arithmetic right-shift function.
///
/// Arithmetic right-shift this APInt by shiftAmt.
- APInt ashr(unsigned shiftAmt) const;
+ APInt LLVM_ATTRIBUTE_UNUSED_RESULT ashr(unsigned shiftAmt) const;
/// \brief Logical right-shift function.
///
/// Logical right-shift this APInt by shiftAmt.
- APInt lshr(unsigned shiftAmt) const;
+ APInt LLVM_ATTRIBUTE_UNUSED_RESULT lshr(unsigned shiftAmt) const;
/// \brief Left-shift function.
///
/// Left-shift this APInt by shiftAmt.
- APInt shl(unsigned shiftAmt) const {
+ APInt LLVM_ATTRIBUTE_UNUSED_RESULT shl(unsigned shiftAmt) const {
assert(shiftAmt <= BitWidth && "Invalid shift amount");
if (isSingleWord()) {
if (shiftAmt >= BitWidth)
}
/// \brief Rotate left by rotateAmt.
- APInt rotl(unsigned rotateAmt) const;
+ APInt LLVM_ATTRIBUTE_UNUSED_RESULT rotl(unsigned rotateAmt) const;
/// \brief Rotate right by rotateAmt.
- APInt rotr(unsigned rotateAmt) const;
+ APInt LLVM_ATTRIBUTE_UNUSED_RESULT rotr(unsigned rotateAmt) const;
/// \brief Arithmetic right-shift function.
///
/// Arithmetic right-shift this APInt by shiftAmt.
- APInt ashr(const APInt &shiftAmt) const;
+ APInt LLVM_ATTRIBUTE_UNUSED_RESULT ashr(const APInt &shiftAmt) const;
/// \brief Logical right-shift function.
///
/// Logical right-shift this APInt by shiftAmt.
- APInt lshr(const APInt &shiftAmt) const;
+ APInt LLVM_ATTRIBUTE_UNUSED_RESULT lshr(const APInt &shiftAmt) const;
/// \brief Left-shift function.
///
/// Left-shift this APInt by shiftAmt.
- APInt shl(const APInt &shiftAmt) const;
+ APInt LLVM_ATTRIBUTE_UNUSED_RESULT shl(const APInt &shiftAmt) const;
/// \brief Rotate left by rotateAmt.
- APInt rotl(const APInt &rotateAmt) const;
+ APInt LLVM_ATTRIBUTE_UNUSED_RESULT rotl(const APInt &rotateAmt) const;
/// \brief Rotate right by rotateAmt.
- APInt rotr(const APInt &rotateAmt) const;
+ APInt LLVM_ATTRIBUTE_UNUSED_RESULT rotr(const APInt &rotateAmt) const;
/// \brief Unsigned division operation.
///
/// RHS are treated as unsigned quantities for purposes of this division.
///
/// \returns a new APInt value containing the division result
- APInt udiv(const APInt &RHS) const;
+ APInt LLVM_ATTRIBUTE_UNUSED_RESULT udiv(const APInt &RHS) const;
/// \brief Signed division function for APInt.
///
/// Signed divide this APInt by APInt RHS.
- APInt sdiv(const APInt &RHS) const;
+ APInt LLVM_ATTRIBUTE_UNUSED_RESULT sdiv(const APInt &RHS) const;
/// \brief Unsigned remainder operation.
///
/// is *this.
///
/// \returns a new APInt value containing the remainder result
- APInt urem(const APInt &RHS) const;
+ APInt LLVM_ATTRIBUTE_UNUSED_RESULT urem(const APInt &RHS) const;
/// \brief Function for signed remainder operation.
///
/// Signed remainder operation on APInt.
- APInt srem(const APInt &RHS) const;
+ APInt LLVM_ATTRIBUTE_UNUSED_RESULT srem(const APInt &RHS) const;
/// \brief Dual division/remainder interface.
///
/// 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.
- static void udivrem(const APInt &LHS, const APInt &RHS,
- APInt &Quotient, APInt &Remainder);
-
- static void sdivrem(const APInt &LHS, const APInt &RHS,
- APInt &Quotient, APInt &Remainder);
+ static void udivrem(const APInt &LHS, const APInt &RHS, APInt &Quotient,
+ APInt &Remainder);
+ static void sdivrem(const APInt &LHS, const APInt &RHS, APInt &Quotient,
+ APInt &Remainder);
// Operations that return overflow indicators.
APInt sadd_ov(const APInt &RHS, bool &Overflow) const;
APInt sdiv_ov(const APInt &RHS, bool &Overflow) const;
APInt smul_ov(const APInt &RHS, bool &Overflow) const;
APInt umul_ov(const APInt &RHS, bool &Overflow) const;
- APInt sshl_ov(unsigned Amt, bool &Overflow) const;
+ APInt sshl_ov(const APInt &Amt, bool &Overflow) const;
+ APInt ushl_ov(const APInt &Amt, bool &Overflow) const;
/// \brief Array-indexing support.
///
bool operator[](unsigned bitPosition) const {
assert(bitPosition < getBitWidth() && "Bit position out of bounds!");
return (maskBit(bitPosition) &
- (isSingleWord() ? VAL : pVal[whichWord(bitPosition)])) != 0;
+ (isSingleWord() ? VAL : pVal[whichWord(bitPosition)])) !=
+ 0;
}
/// @}
///
/// Compares this APInt with RHS for the validity of the equality
/// relationship.
- 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;
/// relationship.
///
/// \returns true if *this == Val
- bool eq(const APInt &RHS) const {
- return (*this) == RHS;
- }
+ bool eq(const APInt &RHS) const { return (*this) == RHS; }
/// \brief Inequality operator.
///
/// relationship.
///
/// \returns true if *this != Val
- bool operator!=(const APInt& RHS) const {
- return !((*this) == RHS);
- }
+ bool operator!=(const APInt &RHS) const { return !((*this) == RHS); }
/// \brief Inequality operator.
///
/// relationship.
///
/// \returns true if *this != Val
- bool operator!=(uint64_t Val) const {
- return !((*this) == Val);
- }
+ bool operator!=(uint64_t Val) const { return !((*this) == Val); }
/// \brief Inequality comparison
///
/// relationship.
///
/// \returns true if *this != Val
- bool ne(const APInt &RHS) const {
- return !((*this) == RHS);
- }
+ bool ne(const APInt &RHS) const { return !((*this) == RHS); }
/// \brief Unsigned less than comparison
///
///
/// \returns true if *this < RHS when considered unsigned.
bool ult(uint64_t RHS) const {
- return ult(APInt(getBitWidth(), RHS));
+ return getActiveBits() > 64 ? false : getZExtValue() < RHS;
}
/// \brief Signed less than comparison
/// validity of the less-than relationship.
///
/// \returns true if *this < RHS when both are considered signed.
- bool slt(const APInt& RHS) const;
+ bool slt(const APInt &RHS) const;
/// \brief Signed less than comparison
///
/// the validity of the less-than relationship.
///
/// \returns true if *this < RHS when considered signed.
- bool slt(uint64_t RHS) const {
- return slt(APInt(getBitWidth(), RHS));
+ bool slt(int64_t RHS) const {
+ return getMinSignedBits() > 64 ? isNegative() : getSExtValue() < RHS;
}
/// \brief Unsigned less or equal comparison
/// validity of the less-or-equal relationship.
///
/// \returns true if *this <= RHS when both are considered unsigned.
- bool ule(const APInt& RHS) const {
- return ult(RHS) || eq(RHS);
- }
+ bool ule(const APInt &RHS) const { return ult(RHS) || eq(RHS); }
/// \brief Unsigned less or equal comparison
///
/// the validity of the less-or-equal relationship.
///
/// \returns true if *this <= RHS when considered unsigned.
- bool ule(uint64_t RHS) const {
- return ule(APInt(getBitWidth(), RHS));
- }
+ bool ule(uint64_t RHS) const { return !ugt(RHS); }
/// \brief Signed less or equal comparison
///
/// validity of the less-or-equal relationship.
///
/// \returns true if *this <= RHS when both are considered signed.
- bool sle(const APInt& RHS) const {
- return slt(RHS) || eq(RHS);
- }
+ bool sle(const APInt &RHS) const { return slt(RHS) || eq(RHS); }
/// \brief Signed less or equal comparison
///
/// validity of the less-or-equal relationship.
///
/// \returns true if *this <= RHS when considered signed.
- bool sle(uint64_t RHS) const {
- return sle(APInt(getBitWidth(), RHS));
- }
+ bool sle(uint64_t RHS) const { return !sgt(RHS); }
/// \brief Unsigned greather than comparison
///
/// the validity of the greater-than relationship.
///
/// \returns true if *this > RHS when both are considered unsigned.
- bool ugt(const APInt& RHS) const {
- return !ult(RHS) && !eq(RHS);
- }
+ bool ugt(const APInt &RHS) const { return !ult(RHS) && !eq(RHS); }
/// \brief Unsigned greater than comparison
///
///
/// \returns true if *this > RHS when considered unsigned.
bool ugt(uint64_t RHS) const {
- return ugt(APInt(getBitWidth(), RHS));
+ return getActiveBits() > 64 ? true : getZExtValue() > RHS;
}
/// \brief Signed greather than comparison
/// validity of the greater-than relationship.
///
/// \returns true if *this > RHS when both are considered signed.
- bool sgt(const APInt& RHS) const {
- return !slt(RHS) && !eq(RHS);
- }
+ bool sgt(const APInt &RHS) const { return !slt(RHS) && !eq(RHS); }
/// \brief Signed greater than comparison
///
/// the validity of the greater-than relationship.
///
/// \returns true if *this > RHS when considered signed.
- bool sgt(uint64_t RHS) const {
- return sgt(APInt(getBitWidth(), RHS));
+ bool sgt(int64_t RHS) const {
+ return getMinSignedBits() > 64 ? !isNegative() : getSExtValue() > RHS;
}
/// \brief Unsigned greater or equal comparison
/// validity of the greater-or-equal relationship.
///
/// \returns true if *this >= RHS when both are considered unsigned.
- bool uge(const APInt& RHS) const {
- return !ult(RHS);
- }
+ bool uge(const APInt &RHS) const { return !ult(RHS); }
/// \brief Unsigned greater or equal comparison
///
/// the validity of the greater-or-equal relationship.
///
/// \returns true if *this >= RHS when considered unsigned.
- bool uge(uint64_t RHS) const {
- return uge(APInt(getBitWidth(), RHS));
- }
+ bool uge(uint64_t RHS) const { return !ult(RHS); }
/// \brief Signed greather or equal comparison
///
/// validity of the greater-or-equal relationship.
///
/// \returns true if *this >= RHS when both are considered signed.
- bool sge(const APInt& RHS) const {
- return !slt(RHS);
- }
+ bool sge(const APInt &RHS) const { return !slt(RHS); }
/// \brief Signed greater or equal comparison
///
/// the validity of the greater-or-equal relationship.
///
/// \returns true if *this >= RHS when considered signed.
- bool sge(uint64_t RHS) const {
- return sge(APInt(getBitWidth(), RHS));
- }
+ bool sge(int64_t RHS) const { 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;
- }
+ bool intersects(const APInt &RHS) const { return (*this & RHS) != 0; }
/// @}
/// \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.
- APInt trunc(unsigned width) const;
+ APInt LLVM_ATTRIBUTE_UNUSED_RESULT trunc(unsigned width) const;
/// \brief Sign extend to a new width.
///
/// 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.
- APInt sext(unsigned width) const;
+ APInt LLVM_ATTRIBUTE_UNUSED_RESULT sext(unsigned width) const;
/// \brief Zero extend to a new width.
///
/// This operation zero extends the APInt to a new width. The 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.
- APInt zext(unsigned width) const;
+ APInt LLVM_ATTRIBUTE_UNUSED_RESULT zext(unsigned width) const;
/// \brief Sign extend or truncate to width
///
/// Make this APInt have the bit width given by \p width. The value is sign
/// extended, truncated, or left alone to make it that width.
- APInt sextOrTrunc(unsigned width) const;
+ APInt LLVM_ATTRIBUTE_UNUSED_RESULT sextOrTrunc(unsigned width) const;
/// \brief Zero extend or truncate to width
///
/// Make this APInt have the bit width given by \p width. The value is zero
/// extended, truncated, or left alone to make it that width.
- APInt zextOrTrunc(unsigned width) const;
+ APInt LLVM_ATTRIBUTE_UNUSED_RESULT zextOrTrunc(unsigned width) const;
/// \brief Sign extend or truncate to width
///
/// Make this APInt have the bit width given by \p width. The value is sign
/// extended, or left alone to make it that width.
- APInt sextOrSelf(unsigned width) const;
+ APInt LLVM_ATTRIBUTE_UNUSED_RESULT sextOrSelf(unsigned width) const;
/// \brief Zero extend or truncate to width
///
/// Make this APInt have the bit width given by \p width. The value is zero
/// extended, or left alone to make it that width.
- APInt zextOrSelf(unsigned width) const;
+ APInt LLVM_ATTRIBUTE_UNUSED_RESULT zextOrSelf(unsigned width) const;
/// @}
/// \name Bit Manipulation Operators
/// @{
/// \brief Return the number of bits in the APInt.
- unsigned getBitWidth() const {
- return BitWidth;
- }
+ unsigned getBitWidth() const { return BitWidth; }
/// \brief Get the number of words.
///
/// Here one word's bitwidth equals to that of uint64_t.
///
/// \returns the number of words to hold the integer value of this APInt.
- unsigned getNumWords() const {
- return getNumWords(BitWidth);
- }
+ unsigned getNumWords() const { return getNumWords(BitWidth); }
/// \brief Get the number of words.
///
/// \returns the number of words to hold the integer value with a given bit
/// width.
static unsigned getNumWords(unsigned BitWidth) {
- return (BitWidth + APINT_BITS_PER_WORD - 1) / APINT_BITS_PER_WORD;
+ return ((uint64_t)BitWidth + APINT_BITS_PER_WORD - 1) / APINT_BITS_PER_WORD;
}
/// \brief Compute the number of active bits in the value
/// 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.
- unsigned getActiveBits() const {
- return BitWidth - countLeadingZeros();
- }
+ unsigned getActiveBits() const { return BitWidth - countLeadingZeros(); }
/// \brief Compute the number of active words in the value of this APInt.
///
unsigned getMinSignedBits() const {
if (isNegative())
return BitWidth - countLeadingOnes() + 1;
- return getActiveBits()+1;
+ return getActiveBits() + 1;
}
/// \brief Get zero extended value
int64_t getSExtValue() const {
if (isSingleWord())
return int64_t(VAL << (APINT_BITS_PER_WORD - BitWidth)) >>
- (APINT_BITS_PER_WORD - BitWidth);
+ (APINT_BITS_PER_WORD - BitWidth);
assert(getMinSignedBits() <= 64 && "Too many bits for int64_t");
return int64_t(pVal[0]);
}
/// equivalent of the string given by \p str.
static unsigned getBitsNeeded(StringRef str, uint8_t radix);
- /// \brief Count the number of zeros from the msb to the first one bit.
+ /// \brief The APInt version of the countLeadingZeros functions in
+ /// MathExtras.h.
///
- /// 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.
+ /// It counts the number of zeros from the most significant bit to the first
+ /// one bit.
///
/// \returns BitWidth if the value is zero, otherwise returns the number of
- /// zeros from the most significant bit to the first one bits.
+ /// zeros from the most significant bit to the first one bits.
unsigned countLeadingZeros() const {
if (isSingleWord()) {
unsigned unusedBits = APINT_BITS_PER_WORD - BitWidth;
- return CountLeadingZeros_64(VAL) - unusedBits;
+ return llvm::countLeadingZeros(VAL) - unusedBits;
}
return countLeadingZerosSlowCase();
}
/// \brief Count the number of leading one bits.
///
- /// This function is an APInt version of the countLeadingOnes_{32,64}
+ /// This function is an APInt version of the countLeadingOnes
/// functions in MathExtras.h. It counts the number of ones from the most
/// significant bit to the first zero bit.
///
/// \brief Count the number of trailing zero bits.
///
- /// This function is an APInt version of the countTrailingZeros_{32,64}
+ /// This function is an APInt version of the countTrailingZeros
/// functions in MathExtras.h. It counts the number of zeros from the least
/// significant bit to the first set bit.
///
/// \brief Count the number of trailing one bits.
///
- /// This function is an APInt version of the countTrailingOnes_{32,64}
+ /// This function is an APInt version of the countTrailingOnes
/// functions in MathExtras.h. It counts the number of ones from the least
/// significant bit to the first zero bit.
///
/// of ones from the least significant bit to the first zero bit.
unsigned countTrailingOnes() const {
if (isSingleWord())
- return CountTrailingOnes_64(VAL);
+ return llvm::countTrailingOnes(VAL);
return countTrailingOnesSlowCase();
}
/// \brief Count the number of bits set.
///
- /// This function is an APInt version of the countPopulation_{32,64} functions
+ /// This function is an APInt version of the countPopulation functions
/// in MathExtras.h. It counts the number of 1 bits in the APInt value.
///
/// \returns 0 if the value is zero, otherwise returns the number of set bits.
unsigned countPopulation() const {
if (isSingleWord())
- return CountPopulation_64(VAL);
+ return llvm::countPopulation(VAL);
return countPopulationSlowCase();
}
std::string toString(unsigned Radix, bool Signed) const;
/// \returns a byte-swapped representation of this APInt Value.
- APInt byteSwap() const;
+ APInt LLVM_ATTRIBUTE_UNUSED_RESULT byteSwap() const;
/// \brief Converts this APInt to a double value.
double roundToDouble(bool isSigned) const;
/// \brief Converts this unsigned APInt to a double value.
- double roundToDouble() const {
- return roundToDouble(false);
- }
+ double roundToDouble() const { return roundToDouble(false); }
/// \brief Converts this signed APInt to a double value.
- double signedRoundToDouble() const {
- return roundToDouble(true);
- }
+ double signedRoundToDouble() const { return roundToDouble(true); }
/// \brief Converts APInt bits to a double
///
///
/// The conversion does not do a translation from double to integer, it just
/// re-interprets the bits of the double.
- static APInt doubleToBits(double V) {
+ static APInt LLVM_ATTRIBUTE_UNUSED_RESULT doubleToBits(double V) {
union {
uint64_t I;
double D;
///
/// The conversion does not do a translation from float to integer, it just
/// re-interprets the bits of the float.
- static APInt floatToBits(float V) {
+ static APInt LLVM_ATTRIBUTE_UNUSED_RESULT floatToBits(float V) {
union {
unsigned I;
float F;
/// @{
/// \returns the floor log base 2 of this APInt.
- unsigned logBase2() const {
- return BitWidth - 1 - countLeadingZeros();
- }
+ unsigned logBase2() const { return BitWidth - 1 - countLeadingZeros(); }
/// \returns the ceil log base 2 of this APInt.
unsigned ceilLogBase2() const {
return BitWidth - (*this - 1).countLeadingZeros();
}
+ /// \returns the nearest log base 2 of this APInt. Ties round up.
+ ///
+ /// NOTE: When we have a BitWidth of 1, we define:
+ ///
+ /// log2(0) = UINT32_MAX
+ /// log2(1) = 0
+ ///
+ /// to get around any mathematical concerns resulting from
+ /// referencing 2 in a space where 2 does no exist.
+ unsigned nearestLogBase2() const {
+ // Special case when we have a bitwidth of 1. If VAL is 1, then we
+ // get 0. If VAL is 0, we get UINT64_MAX which gets truncated to
+ // UINT32_MAX.
+ if (BitWidth == 1)
+ return VAL - 1;
+
+ // Handle the zero case.
+ if (!getBoolValue())
+ return UINT32_MAX;
+
+ // The non-zero case is handled by computing:
+ //
+ // nearestLogBase2(x) = logBase2(x) + x[logBase2(x)-1].
+ //
+ // where x[i] is referring to the value of the ith bit of x.
+ unsigned lg = logBase2();
+ return lg + unsigned((*this)[lg - 1]);
+ }
+
/// \returns the log base 2 of this APInt if its an exact power of two, -1
/// otherwise
int32_t exactLogBase2() const {
}
/// \brief Compute the square root
- APInt sqrt() const;
+ APInt LLVM_ATTRIBUTE_UNUSED_RESULT sqrt() const;
/// \brief Get the absolute value;
///
/// If *this is < 0 then return -(*this), otherwise *this;
- APInt abs() const {
+ APInt LLVM_ATTRIBUTE_UNUSED_RESULT abs() const {
if (isNegative())
return -(*this);
return *this;
}
/// \returns the multiplicative inverse for a given modulo.
- APInt multiplicativeInverse(const APInt& modulo) const;
+ APInt multiplicativeInverse(const APInt &modulo) const;
/// @}
/// \name Support for division by constant
/// 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);
+ const integerPart *, unsigned int srcBits,
+ unsigned int srcLSB);
/// Set the given bit of a bignum. Zero-based.
static void tcSetBit(integerPart *, unsigned int bit);
/// 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);
+ static int tcMultiply(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
static void tcComplement(integerPart *, unsigned int);
/// Comparison (unsigned) of two bignums.
- static int tcCompare(const integerPart *, const integerPart *,
- unsigned int);
+ static int tcCompare(const integerPart *, const integerPart *, unsigned int);
/// Increment a bignum in-place. Return the carry flag.
static integerPart tcIncrement(integerPart *, unsigned int);
+ /// Decrement a bignum in-place. Return the borrow flag.
+ static integerPart tcDecrement(integerPart *, unsigned int);
+
/// Set the least significant BITS and clear the rest.
static void tcSetLeastSignificantBits(integerPart *, unsigned int,
unsigned int bits);
/// Magic data for optimising signed division by a constant.
struct APInt::ms {
- APInt m; ///< magic number
- unsigned s; ///< shift amount
+ APInt m; ///< magic number
+ unsigned s; ///< shift amount
};
/// Magic data for optimising unsigned division by a constant.
struct APInt::mu {
- APInt m; ///< magic number
- bool a; ///< add indicator
- unsigned s; ///< shift amount
+ APInt m; ///< magic number
+ bool a; ///< add indicator
+ unsigned s; ///< shift amount
};
-inline bool operator==(uint64_t V1, const APInt& V2) {
- return V2 == V1;
-}
+inline bool operator==(uint64_t V1, const APInt &V2) { return V2 == V1; }
-inline bool operator!=(uint64_t V1, const APInt& V2) {
- return V2 != V1;
-}
+inline bool operator!=(uint64_t V1, const APInt &V2) { return V2 != V1; }
inline raw_ostream &operator<<(raw_ostream &OS, const APInt &I) {
I.print(OS, true);
namespace APIntOps {
/// \brief Determine the smaller of two APInts considered to be signed.
-inline APInt smin(const APInt &A, const APInt &B) {
- return A.slt(B) ? A : B;
-}
+inline APInt smin(const APInt &A, const APInt &B) { return A.slt(B) ? A : B; }
/// \brief Determine the larger of two APInts considered to be signed.
-inline APInt smax(const APInt &A, const APInt &B) {
- return A.sgt(B) ? A : B;
-}
+inline APInt smax(const APInt &A, const APInt &B) { return A.sgt(B) ? A : B; }
/// \brief Determine the smaller of two APInts considered to be signed.
-inline APInt umin(const APInt &A, const APInt &B) {
- return A.ult(B) ? A : B;
-}
+inline APInt umin(const APInt &A, const APInt &B) { return A.ult(B) ? A : B; }
/// \brief Determine the larger of two APInts considered to be unsigned.
-inline APInt umax(const APInt &A, const APInt &B) {
- return A.ugt(B) ? A : B;
-}
+inline APInt umax(const APInt &A, const APInt &B) { return A.ugt(B) ? A : B; }
/// \brief Check if the specified APInt has a N-bits unsigned integer value.
-inline bool isIntN(unsigned N, const APInt& APIVal) {
- return APIVal.isIntN(N);
-}
+inline bool isIntN(unsigned N, const APInt &APIVal) { return APIVal.isIntN(N); }
/// \brief Check if the specified APInt has a N-bits signed integer value.
-inline bool isSignedIntN(unsigned N, const APInt& APIVal) {
+inline bool isSignedIntN(unsigned 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(unsigned numBits, const APInt& APIVal) {
+inline bool isMask(unsigned numBits, const APInt &APIVal) {
return numBits <= APIVal.getBitWidth() &&
- APIVal == APInt::getLowBitsSet(APIVal.getBitWidth(), numBits);
+ APIVal == APInt::getLowBitsSet(APIVal.getBitWidth(), numBits);
}
/// \brief Return true if the argument APInt value contains a sequence of ones
/// with the remainder zero.
-inline bool isShiftedMask(unsigned numBits, const APInt& APIVal) {
- return isMask(numBits, (APIVal - APInt(numBits,1)) | APIVal);
+inline bool isShiftedMask(unsigned numBits, const APInt &APIVal) {
+ return isMask(numBits, (APIVal - APInt(numBits, 1)) | APIVal);
}
/// \brief Returns a byte-swapped representation of the specified APInt Value.
-inline APInt byteSwap(const APInt& APIVal) {
- return APIVal.byteSwap();
-}
+inline APInt byteSwap(const APInt &APIVal) { return APIVal.byteSwap(); }
/// \brief Returns the floor log base 2 of the specified APInt value.
-inline unsigned logBase2(const APInt& APIVal) {
- return APIVal.logBase2();
-}
+inline unsigned logBase2(const APInt &APIVal) { return APIVal.logBase2(); }
/// \brief Compute GCD of two APInt values.
///
/// using Euclid's algorithm.
///
/// \returns the greatest common divisor of Val1 and Val2
-APInt GreatestCommonDivisor(const APInt& Val1, const APInt& Val2);
+APInt GreatestCommonDivisor(const APInt &Val1, const APInt &Val2);
/// \brief Converts the given APInt to a double value.
///
/// Treats the APInt as an unsigned value for conversion purposes.
-inline double RoundAPIntToDouble(const APInt& APIVal) {
+inline double RoundAPIntToDouble(const APInt &APIVal) {
return APIVal.roundToDouble();
}
/// \brief Converts the given APInt to a double value.
///
/// Treats the APInt as a signed value for conversion purposes.
-inline double RoundSignedAPIntToDouble(const APInt& APIVal) {
+inline double RoundSignedAPIntToDouble(const APInt &APIVal) {
return APIVal.signedRoundToDouble();
}
/// \brief Converts the given APInt to a float vlalue.
-inline float RoundAPIntToFloat(const APInt& APIVal) {
+inline float RoundAPIntToFloat(const APInt &APIVal) {
return float(RoundAPIntToDouble(APIVal));
}
/// \brief Converts the given APInt to a float value.
///
/// Treast the APInt as a signed value for conversion purposes.
-inline float RoundSignedAPIntToFloat(const APInt& APIVal) {
+inline float RoundSignedAPIntToFloat(const APInt &APIVal) {
return float(APIVal.signedRoundToDouble());
}
/// \brief Arithmetic right-shift function.
///
/// Arithmetic right-shift the APInt by shiftAmt.
-inline APInt ashr(const APInt& LHS, unsigned shiftAmt) {
+inline APInt ashr(const APInt &LHS, unsigned shiftAmt) {
return LHS.ashr(shiftAmt);
}
/// \brief Logical right-shift function.
///
/// Logical right-shift the APInt by shiftAmt.
-inline APInt lshr(const APInt& LHS, unsigned shiftAmt) {
+inline APInt lshr(const APInt &LHS, unsigned shiftAmt) {
return LHS.lshr(shiftAmt);
}
/// \brief Left-shift function.
///
/// Left-shift the APInt by shiftAmt.
-inline APInt shl(const APInt& LHS, unsigned shiftAmt) {
+inline APInt shl(const APInt &LHS, unsigned shiftAmt) {
return LHS.shl(shiftAmt);
}
/// \brief Signed division function for APInt.
///
/// Signed divide APInt LHS by APInt RHS.
-inline APInt sdiv(const APInt& LHS, const APInt& RHS) {
- return LHS.sdiv(RHS);
-}
+inline APInt sdiv(const APInt &LHS, const APInt &RHS) { return LHS.sdiv(RHS); }
/// \brief Unsigned division function for APInt.
///
/// Unsigned divide APInt LHS by APInt RHS.
-inline APInt udiv(const APInt& LHS, const APInt& RHS) {
- return LHS.udiv(RHS);
-}
+inline APInt udiv(const APInt &LHS, const APInt &RHS) { return LHS.udiv(RHS); }
/// \brief Function for signed remainder operation.
///
/// Signed remainder operation on APInt.
-inline APInt srem(const APInt& LHS, const APInt& RHS) {
- return LHS.srem(RHS);
-}
+inline APInt srem(const APInt &LHS, const APInt &RHS) { return LHS.srem(RHS); }
/// \brief Function for unsigned remainder operation.
///
/// Unsigned remainder operation on APInt.
-inline APInt urem(const APInt& LHS, const APInt& RHS) {
- return LHS.urem(RHS);
-}
+inline APInt urem(const APInt &LHS, const APInt &RHS) { return LHS.urem(RHS); }
/// \brief Function for multiplication operation.
///
/// Performs multiplication on APInt values.
-inline APInt mul(const APInt& LHS, const APInt& RHS) {
- return LHS * RHS;
-}
+inline APInt mul(const APInt &LHS, const APInt &RHS) { return LHS * RHS; }
/// \brief Function for addition operation.
///
/// Performs addition on APInt values.
-inline APInt add(const APInt& LHS, const APInt& RHS) {
- return LHS + RHS;
-}
+inline APInt add(const APInt &LHS, const APInt &RHS) { return LHS + RHS; }
/// \brief Function for subtraction operation.
///
/// Performs subtraction on APInt values.
-inline APInt sub(const APInt& LHS, const APInt& RHS) {
- return LHS - RHS;
-}
+inline APInt sub(const APInt &LHS, const APInt &RHS) { return LHS - RHS; }
/// \brief Bitwise AND function for APInt.
///
/// Performs bitwise AND operation on APInt LHS and
/// APInt RHS.
-inline APInt And(const APInt& LHS, const APInt& RHS) {
- return LHS & RHS;
-}
+inline APInt And(const APInt &LHS, const APInt &RHS) { return LHS & RHS; }
/// \brief Bitwise OR function for APInt.
///
/// Performs bitwise OR operation on APInt LHS and APInt RHS.
-inline APInt Or(const APInt& LHS, const APInt& RHS) {
- return LHS | RHS;
-}
+inline APInt Or(const APInt &LHS, const APInt &RHS) { return LHS | RHS; }
/// \brief Bitwise XOR function for APInt.
///
/// Performs bitwise XOR operation on APInt.
-inline APInt Xor(const APInt& LHS, const APInt& RHS) {
- return LHS ^ RHS;
-}
+inline APInt Xor(const APInt &LHS, const APInt &RHS) { return LHS ^ RHS; }
/// \brief Bitwise complement function.
///
/// Performs a bitwise complement operation on APInt.
-inline APInt Not(const APInt& APIVal) {
- return ~APIVal;
-}
+inline APInt Not(const APInt &APIVal) { return ~APIVal; }
} // End of APIntOps namespace
- // See friend declaration above. This additional declaration is required in
- // order to compile LLVM with IBM xlC compiler.
- hash_code hash_value(const APInt &Arg);
+// See friend declaration above. This additional declaration is required in
+// order to compile LLVM with IBM xlC compiler.
+hash_code hash_value(const APInt &Arg);
} // End of llvm namespace
#endif
projects / oota-llvm.git / blobdiff