Members/tobaru/cbc/CbC_llvm: lib/Support/APInt.cpp comparison

comparison lib/Support/APInt.cpp @ 83:60c9769439b8

LLVM 3.7

author	Tatsuki IHA <e125716@ie.u-ryukyu.ac.jp>
date	Wed, 18 Feb 2015 14:55:36 +0900
parents	54457678186b
children	afa8332a0e37

comparison

equal deleted inserted replaced

-:af83660cff7b
+:60c9769439b8
 unsigned numWords = getNumWords();
 uint64_t *val = getMemory(numWords);
 for (unsigned i = 0; i < numWords; ++i)
 val[i] = pVal[i] ^ RHS.pVal[i];
+APInt Result(val, getBitWidth());
 // 0^0==1 so clear the high bits in case they got set.
-return APInt(val, getBitWidth()).clearUnusedBits();
+Result.clearUnusedBits();
+return Result;
 }
 APInt APInt::operator*(const APInt& RHS) const {
 assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
 if (isSingleWord())
 assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
 if (isSingleWord())
 return APInt(BitWidth, VAL + RHS.VAL);
 APInt Result(BitWidth, 0);
 add(Result.pVal, this->pVal, RHS.pVal, getNumWords());
-return Result.clearUnusedBits();
+Result.clearUnusedBits();
+return Result;
 }
 APInt APInt::operator-(const APInt& RHS) const {
 assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
 if (isSingleWord())
 return APInt(BitWidth, VAL - RHS.VAL);
 APInt Result(BitWidth, 0);
 sub(Result.pVal, this->pVal, RHS.pVal, getNumWords());
-return Result.clearUnusedBits();
+Result.clearUnusedBits();
+return Result;
 }
 bool APInt::EqualSlowCase(const APInt& RHS) const {
 // Get some facts about the number of bits used in the two operands.
 unsigned n1 = getActiveBits();
 return Count;
 }
 unsigned APInt::countLeadingOnes() const {
 if (isSingleWord())
-return CountLeadingOnes_64(VAL << (APINT_BITS_PER_WORD - BitWidth));
+return llvm::countLeadingOnes(VAL << (APINT_BITS_PER_WORD - BitWidth));
 unsigned highWordBits = BitWidth % APINT_BITS_PER_WORD;
 unsigned shift;
 if (!highWordBits) {
 highWordBits = APINT_BITS_PER_WORD;
 shift = 0;
 } else {
 shift = APINT_BITS_PER_WORD - highWordBits;
 }
 int i = getNumWords() - 1;
-unsigned Count = CountLeadingOnes_64(pVal[i] << shift);
+unsigned Count = llvm::countLeadingOnes(pVal[i] << shift);
 if (Count == highWordBits) {
 for (i--; i >= 0; --i) {
 if (pVal[i] == -1ULL)
 Count += APINT_BITS_PER_WORD;
 else {
-Count += CountLeadingOnes_64(pVal[i]);
+Count += llvm::countLeadingOnes(pVal[i]);
 break;
 }
 }
 }
 return Count;
 unsigned Count = 0;
 unsigned i = 0;
 for (; i < getNumWords() && pVal[i] == -1ULL; ++i)
 Count += APINT_BITS_PER_WORD;
 if (i < getNumWords())
-Count += CountTrailingOnes_64(pVal[i]);
+Count += llvm::countTrailingOnes(pVal[i]);
 return std::min(Count, BitWidth);
 }
 unsigned APInt::countPopulationSlowCase() const {
 unsigned Count = 0;
 for (unsigned i = 0; i < getNumWords(); ++i)
-Count += CountPopulation_64(pVal[i]);
+Count += llvm::countPopulation(pVal[i]);
 return Count;
 }
 /// Perform a logical right-shift from Src to Dst, which must be equal or
 /// non-overlapping, of Words words, by Shift, which must be less than 64.
 // Remaining words are 0 or -1, just assign them.
 uint64_t fillValue = (isNegative() ? -1ULL : 0);
 for (unsigned i = breakWord+1; i < getNumWords(); ++i)
 val[i] = fillValue;
-return APInt(val, BitWidth).clearUnusedBits();
+APInt Result(val, BitWidth);
+Result.clearUnusedBits();
+return Result;
 }
 /// Logical right-shift this APInt by shiftAmt.
 /// @brief Logical right-shift function.
 APInt APInt::lshr(const APInt &shiftAmt) const {
 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) {
 lshrNear(val, pVal, getNumWords(), shiftAmt);
-return APInt(val, BitWidth).clearUnusedBits();
+APInt Result(val, BitWidth);
+Result.clearUnusedBits();
+return Result;
 }
 // Compute some values needed by the remaining shift algorithms
 unsigned wordShift = shiftAmt % APINT_BITS_PER_WORD;
 unsigned offset = shiftAmt / APINT_BITS_PER_WORD;
 if (wordShift == 0) {
 for (unsigned i = 0; i < getNumWords() - offset; ++i)
 val[i] = pVal[i+offset];
 for (unsigned i = getNumWords()-offset; i < getNumWords(); i++)
 val[i] = 0;
-return APInt(val,BitWidth).clearUnusedBits();
+APInt Result(val, BitWidth);
+Result.clearUnusedBits();
+return Result;
 }
 // Shift the low order words
 unsigned breakWord = getNumWords() - offset -1;
 for (unsigned i = 0; i < breakWord; ++i)
 val[breakWord] = pVal[breakWord+offset] >> wordShift;
 // Remaining words are 0
 for (unsigned i = breakWord+1; i < getNumWords(); ++i)
 val[i] = 0;
-return APInt(val, BitWidth).clearUnusedBits();
+APInt Result(val, BitWidth);
+Result.clearUnusedBits();
+return Result;
 }
 /// Left-shift this APInt by shiftAmt.
 /// @brief Left-shift function.
 APInt APInt::shl(const APInt &shiftAmt) const {
 uint64_t carry = 0;
 for (unsigned i = 0; i < getNumWords(); i++) {
 val[i] = pVal[i] << shiftAmt | carry;
 carry = pVal[i] >> (APINT_BITS_PER_WORD - shiftAmt);
 }
-return APInt(val, BitWidth).clearUnusedBits();
+APInt Result(val, BitWidth);
+Result.clearUnusedBits();
+return Result;
 }
 // Compute some values needed by the remaining shift algorithms
 unsigned wordShift = shiftAmt % APINT_BITS_PER_WORD;
 unsigned offset = shiftAmt / APINT_BITS_PER_WORD;
 if (wordShift == 0) {
 for (unsigned i = 0; i < offset; i++)
 val[i] = 0;
 for (unsigned i = offset; i < getNumWords(); i++)
 val[i] = pVal[i-offset];
-return APInt(val,BitWidth).clearUnusedBits();
+APInt Result(val, BitWidth);
+Result.clearUnusedBits();
+return Result;
 }
 // Copy whole words from this to Result.
 unsigned i = getNumWords() - 1;
 for (; i > offset; --i)
 val[i] = pVal[i-offset] << wordShift |
 pVal[i-offset-1] >> (APINT_BITS_PER_WORD - wordShift);
 val[offset] = pVal[0] << wordShift;
 for (i = 0; i < offset; ++i)
 val[i] = 0;
-return APInt(val, BitWidth).clearUnusedBits();
+APInt Result(val, BitWidth);
+Result.clearUnusedBits();
+return Result;
 }
 APInt APInt::rotl(const APInt &rotateAmt) const {
 return rotl((unsigned)rotateAmt.getLimitedValue(BitWidth));
 }
 #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
-// was adapted to APINt from a wikipedia article on such computations.
+// was adapted to APInt from a wikipedia article on such computations.
 // See http://www.wikipedia.org/ and go to the page named
 // Calculate_an_integer_square_root.
 unsigned nbits = BitWidth, i = 4;
 APInt testy(BitWidth, 16);
 APInt x_old(BitWidth, 1);
 return this->urem(RHS);
 }
 void APInt::udivrem(const APInt &LHS, const APInt &RHS,
 APInt &Quotient, APInt &Remainder) {
+assert(LHS.BitWidth == RHS.BitWidth && "Bit widths must be the same");
+// First, deal with the easy case
+if (LHS.isSingleWord()) {
+assert(RHS.VAL != 0 && "Divide by zero?");
+uint64_t QuotVal = LHS.VAL / RHS.VAL;
+uint64_t RemVal = LHS.VAL % RHS.VAL;
+Quotient = APInt(LHS.BitWidth, QuotVal);
+Remainder = APInt(LHS.BitWidth, RemVal);
+return;
+}
 // Get some size facts about the dividend and divisor
 unsigned lhsBits  = LHS.getActiveBits();
 unsigned lhsWords = !lhsBits ? 0 : (APInt::whichWord(lhsBits - 1) + 1);
 unsigned rhsBits  = RHS.getActiveBits();
 unsigned rhsWords = !rhsBits ? 0 : (APInt::whichWord(rhsBits - 1) + 1);
 else
 Overflow = false;
 return Res;
 }
-APInt APInt::sshl_ov(unsigned ShAmt, bool &Overflow) const {
+APInt APInt::sshl_ov(const APInt &ShAmt, bool &Overflow) const {
-Overflow = ShAmt >= getBitWidth();
+Overflow = ShAmt.uge(getBitWidth());
 if (Overflow)
-ShAmt = getBitWidth()-1;
+return APInt(BitWidth, 0);
 if (isNonNegative()) // Don't allow sign change.
-Overflow = ShAmt >= countLeadingZeros();
+Overflow = ShAmt.uge(countLeadingZeros());
 else
-Overflow = ShAmt >= countLeadingOnes();
+Overflow = ShAmt.uge(countLeadingOnes());
+return *this << ShAmt;
+}
+APInt APInt::ushl_ov(const APInt &ShAmt, bool &Overflow) const {
+Overflow = ShAmt.uge(getBitWidth());
+if (Overflow)
+return APInt(BitWidth, 0);
+Overflow = ShAmt.ugt(countLeadingZeros());
 return *this << ShAmt;
 }
 // This implements a variety of operations on a representation of
 // arbitrary precision, two's-complement, bignum integer values.
 // Assumed by lowHalf, highHalf, partMSB and partLSB.  A fairly safe
 // and unrestricting assumption.
-#define COMPILE_TIME_ASSERT(cond) extern int CTAssert[(cond) ? 1 : -1]
+static_assert(integerPartWidth % 2 == 0, "Part width must be divisible by 2!");
-COMPILE_TIME_ASSERT(integerPartWidth % 2 == 0);
 /* Some handy functions local to this file.  */
 namespace {
 /* Returns the integer part with the least significant BITS set.

Mercurial > hg > Members > tobaru > cbc > CbC_llvm

comparison lib/Support/APInt.cpp @ 83:60c9769439b8