#define LLVM_APINT_H
#include "llvm/Support/DataTypes.h"
+#include <cassert>
#include <string>
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
//===----------------------------------------------------------------------===//
///
/// @brief Class for arbitrary precision integers.
///
+/// Note: In this class, all bit/byte/word positions are zero-based.
+///
class APInt {
- /// Friend Functions of APInt Declared here. For detailed comments,
- /// see bottom of this file.
- friend bool isIntN(unsigned N, const APInt& APIVal);
- friend APInt ByteSwap(const APInt& APIVal);
- friend APInt LogBase2(const APInt& APIVal);
- friend double APIntToDouble(const APInt& APIVal);
- friend float APIntToFloat(const APInt& APIVal);
-
- unsigned bitsnum; ///< The number of bits.
- bool isSigned; ///< The sign flag for this APInt.
+ unsigned BitsNum; ///< The number of bits.
/// This union is used to store the integer value. When the
- /// integer bit-width <= 64, it is used as an uint64_t;
- /// otherwise it uses an uint64_t array.
+ /// integer bit-width <= 64, it uses VAL;
+ /// otherwise it uses the 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 constant we needed for APInt.
+ /// This enum is just used to hold a constant we needed for APInt.
enum {
APINT_BITS_PER_WORD = sizeof(uint64_t) * 8
};
- /// @returns the number of words to hold the integer value of this APInt.
/// Here one word's bitwidth equals to that of uint64_t.
- /// @brief Get the number of the words.
- inline unsigned numWords() const {
- return bitsnum < 1 ? 0 : (bitsnum + APINT_BITS_PER_WORD - 1) /
- APINT_BITS_PER_WORD;
+ /// @returns the number of words to hold the integer value of this APInt.
+ /// @brief Get the number of words.
+ 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.
- /// Note: the bitPosition and the return value are zero-based.
static inline unsigned whichWord(unsigned bitPosition)
{ return bitPosition / APINT_BITS_PER_WORD; }
/// @returns the byte position for the specified bit position.
- /// Note: the bitPosition and the return value are zero-based.
- 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.
- /// Note: the bitPosition and the return value are zero-based.
static inline unsigned whichBit(unsigned bitPosition)
{ return bitPosition % APINT_BITS_PER_WORD; }
/// @returns a uint64_t type integer with just bit position at
/// "whichBit(bitPosition)" setting, others zero.
- /// Note: the bitPosition and the return value are zero-based.
static inline uint64_t maskBit(unsigned bitPosition)
{ return (static_cast<uint64_t>(1)) << whichBit(bitPosition); }
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.
- /// Note: the bitPosition is zero-based.
- inline uint64_t& getWord(unsigned bitPosition);
+ 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.
- /// Note: the bitPosition is zero-based.
- inline uint64_t getWord(unsigned bitPosition) const;
-
- /// mul_1 - This function performs the multiplication operation on a
- /// large integer (represented as a integer array) and a uint64_t integer.
- /// @returns the carry of the multiplication.
- static uint64_t mul_1(uint64_t dest[], uint64_t x[],
- unsigned len, uint64_t y);
-
- /// mul - This function performs the multiplication operation on two large
- /// integers (represented as integer arrays).
- static void mul(uint64_t dest[], uint64_t x[], unsigned xlen,
- uint64_t y[], unsigned ylen);
-
- /// add_1 - This function performs the addition operation on a large integer
- /// and a uint64_t integer.
- /// @returns the carry of the addtion.
- static uint64_t add_1(uint64_t dest[], uint64_t x[],
- unsigned len, uint64_t y);
-
- /// add - This function performs the addtion operation on two large integers.
- static uint64_t add(uint64_t dest[], uint64_t x[],
- uint64_t y[], unsigned len);
-
- /// sub_1 - This function performs the subtraction operation on a large
- /// integer and a uint64_t integer.
- static uint64_t sub_1(uint64_t x[], unsigned len, uint64_t y);
-
- /// sub - This function performs the subtraction operation on two large
- /// integers.
- static uint64_t sub(uint64_t dest[], uint64_t x[],
- uint64_t y[], unsigned len);
-
- /// unitDiv - This function divides uint64_t N by unsigned D.
- /// @returns (remainder << 32) + quotient.
- /// @assumes (N >> 32) < D.
- static uint64_t unitDiv(uint64_t N, unsigned D);
-
- /// subMul - This function subtract x[len-1 : 0] * y from
- /// dest[offset+len-1 : offset].
- /// @returns the most significant word of the product, minus borrow-out from
- /// the subtraction.
- static unsigned subMul(unsigned dest[], unsigned offset,
- unsigned x[], unsigned len, unsigned y);
-
- /// div - This function divides the large integer zds[] by y[].
- /// The remainder ends up in zds[ny-1 : 0].
- /// The quotient ends up in zds[ny : nx].
- /// @assumes nx > ny and (int)y[ny-1] < 0.
- static void div(unsigned zds[], unsigned nx, unsigned y[], unsigned ny);
-
- /// lshift - This function shifts x[len-1 : 0] by shiftAmt, and store the
- /// "len" least significant words of the result in
- /// dest[d_offset+len-1 : d_offset].
- /// @returns the bits shifted out from the most significant digit.
- static uint64_t lshift(uint64_t dest[], unsigned d_offset,
- uint64_t x[], unsigned len, unsigned shiftAmt);
+ 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:
- /// Create a new APInt of numBits bit-width, and initalized as val.
- APInt(uint64_t val = 0, unsigned numBits = APINT_BITS_PER_WORD,
- bool sign = false);
+ /// @brief Create a new APInt of numBits bit-width, and initialized as val.
+ APInt(uint64_t val = 0, unsigned numBits = APINT_BITS_PER_WORD);
- /// Create a new APInt of numBits bit-width, and initalized as bigVal[].
- APInt(unsigned numBits, uint64_t bigVal[], bool sign = false);
+ /// @brief Create a new APInt of numBits bit-width, and initialized as
+ /// bigVal[].
+ APInt(unsigned numBits, uint64_t bigVal[]);
- /// Create a new APInt by translating the string represented integer value.
- APInt(std::string& Val, uint8_t radix = 10, bool sign = false);
+ /// @brief Create a new APInt by translating the string represented
+ /// integer value.
+ APInt(const std::string& Val, uint8_t radix = 10);
- /// Copy Constructor.
+ /// @brief Create a new APInt by translating the char array represented
+ /// integer value.
+ APInt(const char StrStart[], unsigned slen, uint8_t radix);
+
+ /// @brief Copy Constructor.
APInt(const APInt& API);
- /// Destructor.
+ /// @brief Destructor.
~APInt();
- /// @brief Copy assignment operator. Create a new object from the given
- /// APInt one by initialization.
+ /// @brief Copy assignment operator.
APInt& operator=(const APInt& RHS);
- /// @brief Assignment operator. Assigns a common case integer value to
- /// the APInt.
+ /// Assigns an integer value to the APInt.
+ /// @brief Assignment operator.
APInt& operator=(uint64_t RHS);
- /// @brief Postfix increment operator. Increments the APInt by one.
- const APInt operator++(int);
+ /// Increments the APInt by one.
+ /// @brief Postfix increment operator.
+ inline const APInt operator++(int) {
+ APInt API(*this);
+ return ++API;
+ }
- /// @brief Prefix increment operator. Increments the APInt by one.
+ /// Increments the APInt by one.
+ /// @brief Prefix increment operator.
APInt& operator++();
- /// @brief Postfix decrement operator. Decrements the APInt by one.
- const APInt operator--(int);
+ /// Decrements the APInt by one.
+ /// @brief Postfix decrement operator.
+ inline const APInt operator--(int) {
+ APInt API(*this);
+ return --API;
+ }
- /// @brief Prefix decrement operator. Decrements the APInt by one.
+ /// Decrements the APInt by one.
+ /// @brief Prefix decrement operator.
APInt& operator--();
- /// @brief Bitwise AND assignment operator. Performs bitwise AND operation on
- /// this APInt and the given APInt& RHS, assigns the result to this APInt.
+ /// Performs bitwise AND operation on this APInt and the given APInt& RHS,
+ /// assigns the result to this APInt.
+ /// @brief Bitwise AND assignment operator.
APInt& operator&=(const APInt& RHS);
- /// @brief Bitwise OR assignment operator. Performs bitwise OR operation on
- /// this APInt and the given APInt& RHS, assigns the result to this APInt.
+ /// Performs bitwise OR operation on this APInt and the given APInt& RHS,
+ /// assigns the result to this APInt.
+ /// @brief Bitwise OR assignment operator.
APInt& operator|=(const APInt& RHS);
- /// @brief Bitwise XOR assignment operator. Performs bitwise XOR operation on
- /// this APInt and the given APInt& RHS, assigns the result to this APInt.
+ /// Performs bitwise XOR operation on this APInt and the given APInt& RHS,
+ /// assigns the result to this APInt.
+ /// @brief Bitwise XOR assignment operator.
APInt& operator^=(const APInt& RHS);
- /// @brief Left-shift assignment operator. Left-shift the APInt by shiftAmt
- /// and assigns the result to this APInt.
- APInt& operator<<=(unsigned shiftAmt);
-
- /// @brief Right-shift assignment operator. Right-shift the APInt by shiftAmt
- /// and assigns the result to this APInt.
- APInt& operator>>=(unsigned shiftAmt);
-
- /// @brief Bitwise complement operator. Performs a bitwise complement
- /// operation on this APInt.
+ /// Performs a bitwise complement operation on this APInt.
+ /// @brief Bitwise complement operator.
APInt operator~() const;
- /// @brief Multiplication assignment operator. Multiplies this APInt by the
- /// given APInt& RHS and assigns the result to this APInt.
+ /// Multiplies this APInt by the given APInt& RHS and
+ /// assigns the result to this APInt.
+ /// @brief Multiplication assignment operator.
APInt& operator*=(const APInt& RHS);
- /// @brief Division assignment operator. Divides this APInt by the given APInt
- /// &RHS and assigns the result to this APInt.
- APInt& operator/=(const APInt& RHS);
-
- /// @brief Addition assignment operator. Adds this APInt by the given APInt&
- /// RHS and assigns the result to this APInt.
+ /// Adds this APInt by the given APInt& RHS and
+ /// assigns the result to this APInt.
+ /// @brief Addition assignment operator.
APInt& operator+=(const APInt& RHS);
- /// @brief Subtraction assignment operator. Subtracts this APInt by the given
- /// APInt &RHS and assigns the result to this APInt.
+ /// Subtracts this APInt by the given APInt &RHS and
+ /// assigns the result to this APInt.
+ /// @brief Subtraction assignment operator.
APInt& operator-=(const APInt& RHS);
- /// @brief Remainder assignment operator. Yields the remainder from the
- /// division of this APInt by the given APInt& RHS and assigns the remainder
- /// to this APInt.
- APInt& operator%=(const APInt& RHS);
-
- /// @brief Bitwise AND operator. Performs bitwise AND operation on this APInt
- /// and the given APInt& RHS.
+ /// Performs bitwise AND operation on this APInt and
+ /// the given APInt& RHS.
+ /// @brief Bitwise AND operator.
APInt operator&(const APInt& RHS) const;
- /// @brief Bitwise OR operator. Performs bitwise OR operation on this APInt
- /// and the given APInt& RHS.
+ /// Performs bitwise OR operation on this APInt and the given APInt& RHS.
+ /// @brief Bitwise OR operator.
APInt operator|(const APInt& RHS) const;
- /// @brief Bitwise XOR operator. Performs bitwise XOR operation on this APInt
- /// and the given APInt& RHS.
+ /// Performs bitwise XOR operation on this APInt and the given APInt& RHS.
+ /// @brief Bitwise XOR operator.
APInt operator^(const APInt& RHS) const;
- /// @brief Logical AND operator. Performs logical AND operation on this APInt
- /// and the given APInt& RHS.
+ /// Performs logical AND operation on this APInt and the given APInt& RHS.
+ /// @brief Logical AND operator.
bool operator&&(const APInt& RHS) const;
- /// @brief Logical OR operator. Performs logical OR operation on this APInt
- /// and the given APInt& RHS.
+ /// Performs logical OR operation on this APInt and the given APInt& RHS.
+ /// @brief Logical OR operator.
bool operator||(const APInt& RHS) const;
- /// @brief Logical negation operator. Performs logical negation operation on
- /// this APInt.
+ /// Performs logical negation operation on this APInt.
+ /// @brief Logical negation operator.
bool operator !() const;
- /// @brief Multiplication operator. Multiplies this APInt by the given APInt&
- /// RHS.
+ /// Multiplies this APInt by the given APInt& RHS.
+ /// @brief Multiplication operator.
APInt operator*(const APInt& RHS) const;
- /// @brief Division operator. Divides this APInt by the given APInt& RHS.
- APInt operator/(const APInt& RHS) const;
-
- /// @brief Remainder operator. Yields the remainder from the division of this
- /// APInt and the given APInt& RHS.
- APInt operator%(const APInt& RHS) const;
-
- /// @brief Addition operator. Adds this APInt by the given APInt& RHS.
+ /// Adds this APInt by the given APInt& RHS.
+ /// @brief Addition operator.
APInt operator+(const APInt& RHS) const;
- /// @brief Subtraction operator. Subtracts this APInt by the given APInt& RHS
+ /// Subtracts this APInt by the given APInt& RHS
+ /// @brief Subtraction operator.
APInt operator-(const APInt& RHS) const;
- /// @brief Left-shift operator. Left-shift the APInt by shiftAmt.
- APInt operator<<(unsigned shiftAmt) const;
-
- /// @brief Right-shift operator. Right-shift the APInt by shiftAmt.
- APInt operator>>(unsigned shiftAmt) const;
+ ///
+ inline APInt operator-() const {
+ return APInt(0, BitsNum) - (*this);
+ }
/// @brief Array-indexing support.
bool operator[](unsigned bitPosition) const;
- /// @brief Equality operator. Compare this APInt with the given APInt& RHS
+ /// Compare this APInt with the given APInt& RHS
/// for the validity of the equality relationship.
+ /// @brief Equality operator.
bool operator==(const APInt& RHS) const;
- /// @brief Inequality operator. Compare this APInt with the given APInt& RHS
+ /// 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.
- bool operator!=(const APInt& RHS) const;
+ /// @brief Inequality operator.
+ inline bool operator!=(const APInt& RHS) const {
+ return !((*this) == RHS);
+ }
- /// @brief Less-than operator. Compare this APInt with the given APInt& RHS
- /// for the validity of the less-than relationship.
+ /// 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.
bool operator <(const APInt& RHS) const;
- /// @brief Less-than-or-equal operator. Compare this APInt with the given
- /// APInt& RHS for the validity of the less-than-or-equal relationship.
+ /// Compare this APInt with the given APInt& RHS for the validity
+ /// of the less-than-or-equal relationship.
+ /// @brief Less-than-or-equal operator.
bool operator<=(const APInt& RHS) const;
- /// @brief Greater-than operator. Compare this APInt with the given APInt& RHS
- /// for the validity of the greater-than relationship.
+ /// Compare this APInt with the given APInt& RHS for the validity
+ /// of the greater-than relationship.
+ /// @brief Greater-than operator.
bool operator> (const APInt& RHS) const;
- /// @brief Greater-than-or-equal operator. Compare this APInt with the given
- /// APInt& RHS for the validity of the greater-than-or-equal relationship.
+ /// @brief Greater-than-or-equal operator.
+ /// Compare this APInt with the given APInt& RHS for the validity
+ /// of the greater-than-or-equal relationship.
bool operator>=(const APInt& RHS) const;
/// @returns a uint64_t value from this APInt. If this APInt contains a single
/// 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)) :
- VAL;
- else
+ return VAL;
+ unsigned n = getNumWords() * 64 - CountLeadingZeros();
+ if (n <= 64)
return pVal[0];
+ assert(0 && "This APInt's bitwidth > 64");
}
/// @returns the largest value for an APInt of the specified bit-width and
/// @brief Set every bit to 1.
APInt& set();
- /// Set the given bit to 1 whose poition is given as "bitPosition".
+ /// Set the given bit to 1 whose position is given as "bitPosition".
/// @brief Set a given bit to 1.
APInt& set(unsigned bitPosition);
/// @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
+ /// 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
+ /// the high bits.
/// @returns the low "numBits" bits of this APInt.
APInt LoBits(unsigned numBits) const;
/// @returns true if the argument APInt value is a power of two > 0.
inline const bool isPowerOf2() const {
- return *this && !(*this & (*this - 1));
+ return (!!*this) && !(*this & (*this - 1));
}
/// @returns the number of zeros from the most significant bit to the first
/// @returns the total number of bits.
inline unsigned getNumBits() const
- { return bitsnum; }
+ { return BitsNum; }
+
+ /// @brief Check if this APInt has a N-bits integer value.
+ inline bool isIntN(unsigned N) const {
+ if (isSingleWord()) {
+ return VAL == VAL & (~uint64_t(0ULL) >> (64 - N));
+ } else {
+ APInt Tmp(N, pVal);
+ return Tmp == (*this);
+ }
+ }
+
+ /// @returns a byte-swapped representation of this APInt Value.
+ APInt ByteSwap() const;
+
+ /// @returns the floor log base 2 of this APInt.
+ inline unsigned LogBase2() const {
+ return getNumWords() * APINT_BITS_PER_WORD -
+ CountLeadingZeros();
+ }
+
+ /// @brief Converts this APInt to a double value.
+ double APIntRoundToDouble(bool isSigned = false) const;
+
+ /// Arithmetic right-shift this APInt by shiftAmt.
+ /// @brief Arithmetic right-shift function.
+ APInt ashr(unsigned shiftAmt) const;
+
+ /// Logical right-shift this APInt by shiftAmt.
+ /// @brief Logical right-shift function.
+ APInt lshr(unsigned shiftAmt) const;
+
+ /// Left-shift this APInt by shiftAmt.
+ /// @brief Left-shift function.
+ APInt shl(unsigned shiftAmt) const;
+
+ /// Signed divide this APInt by APInt RHS.
+ /// @brief Signed division function for APInt.
+ inline APInt sdiv(const APInt& RHS) const {
+ bool isSignedLHS = (*this)[BitsNum - 1], isSignedRHS = RHS[RHS.BitsNum - 1];
+ APInt API = APIntOps::udiv(isSignedLHS ? -(*this) : (*this), isSignedRHS ? -RHS : RHS);
+ return isSignedLHS != isSignedRHS ? -API : API;;
+ }
+
+ /// 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 isSignedLHS = (*this)[BitsNum - 1], isSignedRHS = RHS[RHS.BitsNum - 1];
+ APInt API = APIntOps::urem(isSignedLHS ? -(*this) : (*this), isSignedRHS ? -RHS : RHS);
+ return isSignedLHS ? -API : API;
+ }
+
+ /// Unsigned remainder operation on APInt.
+ /// @brief Function for unsigned remainder operation.
+ APInt urem(const APInt& RHS) const;
};
+namespace APIntOps {
+
/// @brief Check if the specified APInt has a N-bits integer value.
inline bool isIntN(unsigned N, const APInt& APIVal) {
- if (APIVal.isSingleWord()) {
- APInt Tmp(N, APIVal.VAL);
- return Tmp == APIVal;
- } else {
- APInt Tmp(N, APIVal.pVal);
- return Tmp == APIVal;
- }
+ return APIVal.isIntN(N);
}
/// @returns true if the argument APInt value is a sequence of ones
}
/// @returns a byte-swapped representation of the specified APInt Value.
-APInt ByteSwap(const APInt& APIVal);
+inline APInt ByteSwap(const APInt& APIVal) {
+ return APIVal.ByteSwap();
+}
/// @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 -
- APIVal.CountLeadingZeros();
+inline unsigned LogBase2(const APInt& APIVal) {
+ return APIVal.LogBase2();
}
/// @returns the greatest common divisor of the two values
/// using Euclid's algorithm.
APInt GreatestCommonDivisor(const APInt& API1, const APInt& API2);
-/// @returns the bit equivalent double.
-/// If the APInt numBits > 64, truncated first and then convert to double.
-inline double APIntToDouble(const APInt& APIVal) {
- uint64_t value = APIVal.isSingleWord() ? APIVal.VAL : APIVal.pVal[0];
- union {
- uint64_t I;
- double D;
- } T;
- T.I = value;
- return T.D;
+/// @brief Converts the given APInt to a double value.
+inline double APIntRoundToDouble(const APInt& APIVal, bool isSigned = false) {
+ return APIVal.APIntRoundToDouble(isSigned);
}
-/// @returns the bit equivalent float.
-/// If the APInt numBits > 32, truncated first and then convert to double.
-inline float APIntToFloat(const APInt& APIVal) {
- unsigned value = APIVal.isSingleWord() ? APIVal.VAL : APIVal.pVal[0];
- union {
- unsigned I;
- float F;
- } T;
- T.I = value;
- return T.F;
+/// @brief Converts the given APInt to a float vlalue.
+inline float APIntRoundToFloat(const APInt& APIVal) {
+ return float(APIntRoundToDouble(APIVal));
}
-/// @returns the bit equivalent APInt.
-inline APInt DoubleToAPInt(double Double) {
- union {
- uint64_t L;
- double D;
- } T;
- T.D = Double;
- return APInt(T.L);
+/// @brief Converts the given double value into a APInt.
+APInt DoubleRoundToAPInt(double Double);
+
+/// @brief Converts the given float value into a APInt.
+inline APInt FloatRoundToAPInt(float Float) {
+ return DoubleRoundToAPInt(double(Float));
}
-/// @returns the bit equivalent APInt.
-inline APInt FloatToAPInt(float Float) {
- union {
- uint32_t I;
- float F;
- } T;
- T.F = Float;
- return APInt(uint64_t(T.I));
+/// Arithmetic right-shift the APInt by shiftAmt.
+/// @brief Arithmetic right-shift function.
+inline APInt ashr(const APInt& LHS, unsigned 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) {
+ return LHS.lshr(shiftAmt);
+}
+
+/// Left-shift the APInt by shiftAmt.
+/// @brief Left-shift function.
+inline APInt shl(const APInt& LHS, unsigned shiftAmt) {
+ return LHS.shl(shiftAmt);
+}
+
+/// Signed divide APInt LHS by APInt RHS.
+/// @brief Signed division function for APInt.
+inline APInt sdiv(const APInt& LHS, const APInt& RHS) {
+ return LHS.sdiv(RHS);
+}
+
+/// Unsigned divide APInt LHS by APInt RHS.
+/// @brief Unsigned division function for APInt.
+inline APInt udiv(const APInt& LHS, const APInt& RHS) {
+ return LHS.udiv(RHS);
}
+/// Signed remainder operation on APInt.
+/// @brief Function for signed remainder operation.
+inline APInt srem(const APInt& LHS, const APInt& RHS) {
+ return LHS.srem(RHS);
+}
+
+/// Unsigned remainder operation on APInt.
+/// @brief Function for unsigned remainder operation.
+inline APInt urem(const APInt& LHS, const APInt& RHS) {
+ return LHS.urem(RHS);
+}
+
+/// Performs multiplication on APInt values.
+/// @brief Function for multiplication operation.
+inline APInt mul(const APInt& LHS, const APInt& RHS) {
+ return LHS * RHS;
+}
+
+/// Performs addition on APInt values.
+/// @brief Function for addition operation.
+inline APInt add(const APInt& LHS, const APInt& RHS) {
+ return LHS + RHS;
+}
+
+/// Performs subtraction on APInt values.
+/// @brief Function for subtraction operation.
+inline APInt sub(const APInt& LHS, const APInt& RHS) {
+ return LHS - RHS;
+}
+
+/// Performs bitwise AND operation on APInt LHS and
+/// APInt RHS.
+/// @brief Bitwise AND function for APInt.
+inline APInt And(const APInt& LHS, const APInt& RHS) {
+ return LHS & RHS;
+}
+
+/// Performs bitwise OR operation on APInt LHS and APInt RHS.
+/// @brief Bitwise OR function for APInt.
+inline APInt Or(const APInt& LHS, const APInt& RHS) {
+ return LHS | RHS;
+}
+
+/// Performs bitwise XOR operation on APInt.
+/// @brief Bitwise XOR function for APInt.
+inline APInt Xor(const APInt& LHS, const APInt& RHS) {
+ return LHS ^ RHS;
+}
+
+/// Performs a bitwise complement operation on APInt.
+/// @brief Bitwise complement function.
+inline APInt Not(const APInt& APIVal) {
+ return ~APIVal;
+}
+
+} // End of APIntOps namespace
+
} // End of llvm namespace
#endif
projects / oota-llvm.git / blobdiff