#include "llvm/DerivedTypes.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/MathExtras.h"
+#include <math.h>
+#include <limits>
#include <cstring>
#include <cstdlib>
#ifndef NDEBUG
return result;
}
-APInt::APInt(uint32_t numBits, uint64_t val) : BitWidth(numBits), VAL(0) {
+APInt::APInt(uint32_t numBits, uint64_t val, bool isSigned)
+ : BitWidth(numBits), VAL(0) {
assert(BitWidth >= IntegerType::MIN_INT_BITS && "bitwidth too small");
assert(BitWidth <= IntegerType::MAX_INT_BITS && "bitwidth too large");
if (isSingleWord())
else {
pVal = getClearedMemory(getNumWords());
pVal[0] = val;
+ if (isSigned && int64_t(val) < 0)
+ for (unsigned i = 1; i < getNumWords(); ++i)
+ pVal[i] = -1ULL;
}
clearUnusedBits();
}
APInt::APInt(uint32_t numbits, const char StrStart[], uint32_t slen,
uint8_t radix)
: BitWidth(numbits), VAL(0) {
+ assert(BitWidth >= IntegerType::MIN_INT_BITS && "bitwidth too small");
+ assert(BitWidth <= IntegerType::MAX_INT_BITS && "bitwidth too large");
fromString(numbits, StrStart, slen, radix);
}
APInt::APInt(uint32_t numbits, const std::string& Val, uint8_t radix)
: BitWidth(numbits), VAL(0) {
+ assert(BitWidth >= IntegerType::MIN_INT_BITS && "bitwidth too small");
+ assert(BitWidth <= IntegerType::MAX_INT_BITS && "bitwidth too large");
assert(!Val.empty() && "String empty?");
fromString(numbits, Val.c_str(), Val.size(), radix);
}
APInt::APInt(const APInt& that)
: BitWidth(that.BitWidth), VAL(0) {
+ assert(BitWidth >= IntegerType::MIN_INT_BITS && "bitwidth too small");
+ assert(BitWidth <= IntegerType::MAX_INT_BITS && "bitwidth too large");
if (isSingleWord())
VAL = that.VAL;
else {
}
// Set all the bits in all the words.
- for (uint32_t i = 0; i < getNumWords() - 1; ++i)
+ for (uint32_t i = 0; i < getNumWords(); ++i)
pVal[i] = -1ULL;
// Clear the unused ones
return clearUnusedBits();
return *this;
}
+uint32_t APInt::getBitsNeeded(const char* str, uint32_t slen, uint8_t radix) {
+ assert(str != 0 && "Invalid value string");
+ assert(slen > 0 && "Invalid string length");
+
+ // Each computation below needs to know if its negative
+ uint32_t isNegative = str[0] == '-';
+ if (isNegative) {
+ slen--;
+ str++;
+ }
+ // For radixes of power-of-two values, the bits required is accurately and
+ // easily computed
+ if (radix == 2)
+ return slen + isNegative;
+ if (radix == 8)
+ return slen * 3 + isNegative;
+ if (radix == 16)
+ return slen * 4 + isNegative;
+
+ // Otherwise it must be radix == 10, the hard case
+ assert(radix == 10 && "Invalid radix");
+
+ // This is grossly inefficient but accurate. We could probably do something
+ // with a computation of roughly slen*64/20 and then adjust by the value of
+ // the first few digits. But, I'm not sure how accurate that could be.
+
+ // Compute a sufficient number of bits that is always large enough but might
+ // be too large. This avoids the assertion in the constructor.
+ uint32_t sufficient = slen*64/18;
+
+ // Convert to the actual binary value.
+ APInt tmp(sufficient, str, slen, radix);
+
+ // Compute how many bits are required.
+ return isNegative + tmp.logBase2() + 1;
+}
+
uint64_t APInt::getHashValue() const {
// Put the bit width into the low order bits.
uint64_t hash = BitWidth;
APInt APInt::byteSwap() const {
assert(BitWidth >= 16 && BitWidth % 16 == 0 && "Cannot byteswap!");
if (BitWidth == 16)
- return APInt(BitWidth, ByteSwap_16(VAL));
+ return APInt(BitWidth, ByteSwap_16(uint16_t(VAL)));
else if (BitWidth == 32)
- return APInt(BitWidth, ByteSwap_32(VAL));
+ return APInt(BitWidth, ByteSwap_32(uint32_t(VAL)));
else if (BitWidth == 48) {
- uint64_t Tmp1 = ((VAL >> 32) << 16) | (VAL & 0xFFFF);
+ uint32_t Tmp1 = uint32_t(VAL >> 16);
Tmp1 = ByteSwap_32(Tmp1);
- uint64_t Tmp2 = (VAL >> 16) & 0xFFFF;
+ uint16_t Tmp2 = uint16_t(VAL);
Tmp2 = ByteSwap_16(Tmp2);
- return
- APInt(BitWidth,
- (Tmp1 & 0xff) | ((Tmp1<<16) & 0xffff00000000ULL) | (Tmp2 << 16));
+ return APInt(BitWidth, (uint64_t(Tmp2) << 32) | Tmp1);
} else if (BitWidth == 64)
return APInt(BitWidth, ByteSwap_64(VAL));
else {
// Return infinity for exponent overflow
if (exp > 1023) {
if (!isSigned || !isNeg)
- return double(1.0E300 * 1.0E300); // positive infinity
+ return std::numeric_limits<double>::infinity();
else
- return double(-1.0E300 * 1.0E300); // negative infinity
+ return -std::numeric_limits<double>::infinity();
}
exp += 1023; // Increment for 1023 bias
if (wordsBefore == wordsAfter) {
uint32_t newWordBits = width % APINT_BITS_PER_WORD;
// The extension is contained to the wordsBefore-1th word.
- uint64_t mask = (~0ULL >> (APINT_BITS_PER_WORD - newWordBits)) << wordBits;
+ uint64_t mask = ~0ULL;
+ if (newWordBits)
+ mask >>= APINT_BITS_PER_WORD - newWordBits;
+ mask <<= wordBits;
if (wordsBefore == 1)
VAL |= mask;
else
/// @brief Arithmetic right-shift function.
APInt APInt::ashr(uint32_t shiftAmt) const {
assert(shiftAmt <= BitWidth && "Invalid shift amount");
+ // Handle a degenerate case
+ if (shiftAmt == 0)
+ return *this;
+
+ // Handle single word shifts with built-in ashr
if (isSingleWord()) {
if (shiftAmt == BitWidth)
return APInt(BitWidth, 0); // undefined
}
}
- // If all the bits were shifted out, the result is 0 or -1. This avoids issues
- // with shifting by the size of the integer type, which produces undefined
- // results.
- if (shiftAmt == BitWidth)
+ // If all the bits were shifted out, the result is, technically, undefined.
+ // We return -1 if it was negative, 0 otherwise. We check this early to avoid
+ // issues in the algorithm below.
+ if (shiftAmt == BitWidth) {
if (isNegative())
return APInt(BitWidth, -1ULL);
else
return APInt(BitWidth, 0);
+ }
// Create some space for the result.
uint64_t * val = new uint64_t[getNumWords()];
- // If we are shifting less than a word, compute the shift with a simple carry
- if (shiftAmt < APINT_BITS_PER_WORD) {
- uint64_t carry = 0;
- for (int i = getNumWords()-1; i >= 0; --i) {
- val[i] = (pVal[i] >> shiftAmt) | carry;
- carry = pVal[i] << (APINT_BITS_PER_WORD - shiftAmt);
- }
- return APInt(val, BitWidth).clearUnusedBits();
- }
-
- // Compute some values needed by the remaining shift algorithms
- uint32_t wordShift = shiftAmt % APINT_BITS_PER_WORD;
- uint32_t offset = shiftAmt / APINT_BITS_PER_WORD;
+ // Compute some values needed by the following shift algorithms
+ uint32_t wordShift = shiftAmt % APINT_BITS_PER_WORD; // bits to shift per word
+ uint32_t offset = shiftAmt / APINT_BITS_PER_WORD; // word offset for shift
+ uint32_t breakWord = getNumWords() - 1 - offset; // last word affected
+ uint32_t bitsInWord = whichBit(BitWidth); // how many bits in last word?
+ if (bitsInWord == 0)
+ bitsInWord = APINT_BITS_PER_WORD;
// If we are shifting whole words, just move whole words
if (wordShift == 0) {
- for (uint32_t i = 0; i < getNumWords() - offset; ++i)
- val[i] = pVal[i+offset];
- for (uint32_t i = getNumWords()-offset; i < getNumWords(); i++)
- val[i] = (isNegative() ? -1ULL : 0);
- return APInt(val,BitWidth).clearUnusedBits();
- }
+ // Move the words containing significant bits
+ for (uint32_t i = 0; i <= breakWord; ++i)
+ val[i] = pVal[i+offset]; // move whole word
- // Shift the low order words
- uint32_t breakWord = getNumWords() - offset -1;
- for (uint32_t i = 0; i < breakWord; ++i)
- val[i] = (pVal[i+offset] >> wordShift) |
- (pVal[i+offset+1] << (APINT_BITS_PER_WORD - wordShift));
- // Shift the break word.
- uint32_t SignBit = APINT_BITS_PER_WORD - (BitWidth % APINT_BITS_PER_WORD);
- val[breakWord] = uint64_t(
- (((int64_t(pVal[breakWord+offset]) << SignBit) >> SignBit) >> wordShift));
+ // Adjust the top significant word for sign bit fill, if negative
+ if (isNegative())
+ if (bitsInWord < APINT_BITS_PER_WORD)
+ val[breakWord] |= ~0ULL << bitsInWord; // set high bits
+ } else {
+ // Shift the low order words
+ for (uint32_t i = 0; i < breakWord; ++i) {
+ // This combines the shifted corresponding word with the low bits from
+ // the next word (shifted into this word's high bits).
+ val[i] = (pVal[i+offset] >> wordShift) |
+ (pVal[i+offset+1] << (APINT_BITS_PER_WORD - wordShift));
+ }
+
+ // Shift the break word. In this case there are no bits from the next word
+ // to include in this word.
+ val[breakWord] = pVal[breakWord+offset] >> wordShift;
+
+ // Deal with sign extenstion in the break word, and possibly the word before
+ // it.
+ if (isNegative()) {
+ if (wordShift > bitsInWord) {
+ if (breakWord > 0)
+ val[breakWord-1] |=
+ ~0ULL << (APINT_BITS_PER_WORD - (wordShift - bitsInWord));
+ val[breakWord] |= ~0ULL;
+ } else
+ val[breakWord] |= (~0ULL << (bitsInWord - wordShift));
+ }
+ }
- // Remaining words are 0 or -1
+ // Remaining words are 0 or -1, just assign them.
+ uint64_t fillValue = (isNegative() ? -1ULL : 0);
for (uint32_t i = breakWord+1; i < getNumWords(); ++i)
- val[i] = (isNegative() ? -1ULL : 0);
+ val[i] = fillValue;
return APInt(val, BitWidth).clearUnusedBits();
}
/// Logical right-shift this APInt by shiftAmt.
/// @brief Logical right-shift function.
APInt APInt::lshr(uint32_t shiftAmt) const {
- if (isSingleWord())
+ if (isSingleWord()) {
if (shiftAmt == BitWidth)
return APInt(BitWidth, 0);
else
return APInt(BitWidth, this->VAL >> shiftAmt);
+ }
// If all the bits were shifted out, the result is 0. This avoids issues
// with shifting by the size of the integer type, which produces undefined
if (shiftAmt == BitWidth)
return APInt(BitWidth, 0);
+ // If none of the bits are shifted out, the result is *this. This avoids
+ // issues with shifting byt he size of the integer type, which produces
+ // undefined results in the code below. This is also an optimization.
+ if (shiftAmt == 0)
+ return *this;
+
// Create some space for the result.
uint64_t * val = new uint64_t[getNumWords()];
if (shiftAmt == BitWidth)
return APInt(BitWidth, 0);
+ // If none of the bits are shifted out, the result is *this. This avoids a
+ // lshr by the words size in the loop below which can produce incorrect
+ // results. It also avoids the expensive computation below for a common case.
+ if (shiftAmt == 0)
+ return *this;
+
// Create some space for the result.
uint64_t * val = new uint64_t[getNumWords()];
return APInt(val, BitWidth).clearUnusedBits();
}
+APInt APInt::rotl(uint32_t rotateAmt) const {
+ if (rotateAmt == 0)
+ return *this;
+ // Don't get too fancy, just use existing shift/or facilities
+ APInt hi(*this);
+ APInt lo(*this);
+ hi.shl(rotateAmt);
+ lo.lshr(BitWidth - rotateAmt);
+ return hi | lo;
+}
+
+APInt APInt::rotr(uint32_t rotateAmt) const {
+ if (rotateAmt == 0)
+ return *this;
+ // Don't get too fancy, just use existing shift/or facilities
+ APInt hi(*this);
+ APInt lo(*this);
+ lo.lshr(rotateAmt);
+ hi.shl(BitWidth - rotateAmt);
+ return hi | lo;
+}
// Square Root - this method computes and returns the square root of "this".
// Three mechanisms are used for computation. For small values (<= 5 bits),
// an IEEE double precision floating point value), then we can use the
// libc sqrt function which will probably use a hardware sqrt computation.
// This should be faster than the algorithm below.
- if (magnitude < 52)
+ if (magnitude < 52) {
+#ifdef _MSC_VER
+ // Amazingly, VC++ doesn't have round().
+ return APInt(BitWidth,
+ uint64_t(::sqrt(double(isSingleWord()?VAL:pVal[0]))) + 0.5);
+#else
return APInt(BitWidth,
uint64_t(::round(::sqrt(double(isSingleWord()?VAL:pVal[0])))));
+#endif
+ }
// Okay, all the short cuts are exhausted. We must compute it. The following
// is a classical Babylonian method for computing the square root. This code
}
// Make sure we return the closest approximation
+ // NOTE: The rounding calculation below is correct. It will produce an
+ // off-by-one discrepancy with results from pari/gp. That discrepancy has been
+ // determined to be a rounding issue with pari/gp as it begins to use a
+ // floating point representation after 192 bits. There are no discrepancies
+ // between this algorithm and pari/gp for bit widths < 192 bits.
APInt square(x_old * x_old);
APInt nextSquare((x_old + 1) * (x_old +1));
if (this->ult(square))
return x_old;
- else if (this->ule(nextSquare))
- if ((nextSquare - *this).ult(*this - square))
- return x_old + 1;
- else
+ else if (this->ule(nextSquare)) {
+ APInt midpoint((nextSquare - square).udiv(two));
+ APInt offset(*this - square);
+ if (offset.ult(midpoint))
return x_old;
- else
+ else
+ return x_old + 1;
+ } else
assert(0 && "Error in APInt::sqrt computation");
return x_old + 1;
}
return APInt(BitWidth, pVal[0] % RHS.pVal[0]);
}
- // We have to compute it the hard way. Invoke the Knute divide algorithm.
+ // We have to compute it the hard way. Invoke the Knuth divide algorithm.
APInt Remainder(1,0);
divide(*this, lhsWords, RHS, rhsWords, 0, &Remainder);
return Remainder;
}
+void APInt::udivrem(const APInt &LHS, const APInt &RHS,
+ APInt &Quotient, APInt &Remainder) {
+ // Get some size facts about the dividend and divisor
+ uint32_t lhsBits = LHS.getActiveBits();
+ uint32_t lhsWords = !lhsBits ? 0 : (APInt::whichWord(lhsBits - 1) + 1);
+ uint32_t rhsBits = RHS.getActiveBits();
+ uint32_t rhsWords = !rhsBits ? 0 : (APInt::whichWord(rhsBits - 1) + 1);
+
+ // Check the degenerate cases
+ if (lhsWords == 0) {
+ Quotient = 0; // 0 / Y ===> 0
+ Remainder = 0; // 0 % Y ===> 0
+ return;
+ }
+
+ if (lhsWords < rhsWords || LHS.ult(RHS)) {
+ Quotient = 0; // X / Y ===> 0, iff X < Y
+ Remainder = LHS; // X % Y ===> X, iff X < Y
+ return;
+ }
+
+ if (LHS == RHS) {
+ Quotient = 1; // X / X ===> 1
+ Remainder = 0; // X % X ===> 0;
+ return;
+ }
+
+ if (lhsWords == 1 && rhsWords == 1) {
+ // There is only one word to consider so use the native versions.
+ if (LHS.isSingleWord()) {
+ Quotient = APInt(LHS.getBitWidth(), LHS.VAL / RHS.VAL);
+ Remainder = APInt(LHS.getBitWidth(), LHS.VAL % RHS.VAL);
+ } else {
+ Quotient = APInt(LHS.getBitWidth(), LHS.pVal[0] / RHS.pVal[0]);
+ Remainder = APInt(LHS.getBitWidth(), LHS.pVal[0] % RHS.pVal[0]);
+ }
+ return;
+ }
+
+ // Okay, lets do it the long way
+ divide(LHS, lhsWords, RHS, rhsWords, &Quotient, &Remainder);
+}
+
void APInt::fromString(uint32_t numbits, const char *str, uint32_t slen,
uint8_t radix) {
// Check our assumptions here
bool isNeg = str[0] == '-';
if (isNeg)
str++, slen--;
- assert(slen <= numbits || radix != 2 && "Insufficient bit width");
- assert(slen*3 <= numbits || radix != 8 && "Insufficient bit width");
- assert(slen*4 <= numbits || radix != 16 && "Insufficient bit width");
- assert((slen*64)/20 <= numbits || radix != 10 && "Insufficient bit width");
+ assert((slen <= numbits || radix != 2) && "Insufficient bit width");
+ assert((slen*3 <= numbits || radix != 8) && "Insufficient bit width");
+ assert((slen*4 <= numbits || radix != 16) && "Insufficient bit width");
+ assert(((slen*64)/22 <= numbits || radix != 10) && "Insufficient bit width");
// Allocate memory
if (!isSingleWord())
// Get a digit
uint32_t digit = 0;
char cdigit = str[i];
- if (isdigit(cdigit))
- digit = cdigit - '0';
- else if (isxdigit(cdigit))
- if (cdigit >= 'a')
+ if (radix == 16) {
+ if (!isxdigit(cdigit))
+ assert(0 && "Invalid hex digit in string");
+ if (isdigit(cdigit))
+ digit = cdigit - '0';
+ else if (cdigit >= 'a')
digit = cdigit - 'a' + 10;
else if (cdigit >= 'A')
digit = cdigit - 'A' + 10;
else
- assert(0 && "huh?");
- else
+ assert(0 && "huh? we shouldn't get here");
+ } else if (isdigit(cdigit)) {
+ digit = cdigit - '0';
+ } else {
assert(0 && "Invalid character in digit string");
+ }
- // Shift or multiple the value by the radix
+ // Shift or multiply the value by the radix
if (shift)
- this->shl(shift);
+ *this <<= shift;
else
*this *= apradix;
}
if (radix != 10) {
- uint64_t mask = radix - 1;
- uint32_t shift = (radix == 16 ? 4 : radix == 8 ? 3 : 1);
- uint32_t nibbles = APINT_BITS_PER_WORD / shift;
- for (uint32_t i = 0; i < getNumWords(); ++i) {
- uint64_t value = pVal[i];
- for (uint32_t j = 0; j < nibbles; ++j) {
- result.insert(0, digits[ value & mask ]);
- value >>= shift;
+ // For the 2, 8 and 16 bit cases, we can just shift instead of divide
+ // because the number of bits per digit (1,3 and 4 respectively) divides
+ // equaly. We just shift until there value is zero.
+
+ // First, check for a zero value and just short circuit the logic below.
+ if (*this == 0)
+ result = "0";
+ else {
+ APInt tmp(*this);
+ size_t insert_at = 0;
+ if (wantSigned && this->isNegative()) {
+ // They want to print the signed version and it is a negative value
+ // Flip the bits and add one to turn it into the equivalent positive
+ // value and put a '-' in the result.
+ tmp.flip();
+ tmp++;
+ result = "-";
+ insert_at = 1;
+ }
+ // Just shift tmp right for each digit width until it becomes zero
+ uint32_t shift = (radix == 16 ? 4 : (radix == 8 ? 3 : 1));
+ uint64_t mask = radix - 1;
+ APInt zero(tmp.getBitWidth(), 0);
+ while (tmp.ne(zero)) {
+ unsigned digit = (tmp.isSingleWord() ? tmp.VAL : tmp.pVal[0]) & mask;
+ result.insert(insert_at, digits[digit]);
+ tmp = tmp.lshr(shift);
}
}
return result;
projects / oota-llvm.git / blobdiff