reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

include/llvm/ADT/APFloat.h
  143   static const unsigned integerPartWidth = APInt::APINT_BITS_PER_WORD;
include/llvm/ADT/APInt.h
  114   bool isSingleWord() const { return BitWidth <= APINT_BITS_PER_WORD; }
  120     return bitPosition / APINT_BITS_PER_WORD;
  128     return bitPosition % APINT_BITS_PER_WORD;
  149     unsigned WordBits = ((BitWidth-1) % APINT_BITS_PER_WORD) + 1;
  152     uint64_t mask = WORDTYPE_MAX >> (APINT_BITS_PER_WORD - WordBits);
  397       return U.VAL == WORDTYPE_MAX >> (APINT_BITS_PER_WORD - BitWidth);
  498       return U.VAL == (WORDTYPE_MAX >> (APINT_BITS_PER_WORD - numBits));
  958         U.VAL = SExtVAL >> (APINT_BITS_PER_WORD - 1); // Fill with sign bit.
 1427     if (loBit < APINT_BITS_PER_WORD && hiBit <= APINT_BITS_PER_WORD) {
 1427     if (loBit < APINT_BITS_PER_WORD && hiBit <= APINT_BITS_PER_WORD) {
 1428       uint64_t mask = WORDTYPE_MAX >> (APINT_BITS_PER_WORD - (hiBit - loBit));
 1537     return ((uint64_t)BitWidth + APINT_BITS_PER_WORD - 1) / APINT_BITS_PER_WORD;
 1537     return ((uint64_t)BitWidth + APINT_BITS_PER_WORD - 1) / APINT_BITS_PER_WORD;
 1610       unsigned unusedBits = APINT_BITS_PER_WORD - BitWidth;
 1626       return llvm::countLeadingOnes(U.VAL << (APINT_BITS_PER_WORD - BitWidth));
lib/Support/APInt.cpp
  314     uint64_t hiMask = WORDTYPE_MAX >> (APINT_BITS_PER_WORD - hiShiftAmt);
  358     uint64_t mask = WORDTYPE_MAX >> (APINT_BITS_PER_WORD - subBitWidth);
  370     uint64_t mask = WORDTYPE_MAX >> (APINT_BITS_PER_WORD - subBitWidth);
  379     unsigned numWholeSubWords = subBitWidth / APINT_BITS_PER_WORD;
  384     unsigned remainingBits = subBitWidth % APINT_BITS_PER_WORD;
  386       uint64_t mask = WORDTYPE_MAX >> (APINT_BITS_PER_WORD - remainingBits);
  462     DestPtr[word] = (w0 >> loBit) | (w1 << (APINT_BITS_PER_WORD - loBit));
  592       Count += APINT_BITS_PER_WORD;
  599   unsigned Mod = BitWidth % APINT_BITS_PER_WORD;
  600   Count -= Mod > 0 ? APINT_BITS_PER_WORD - Mod : 0;
  605   unsigned highWordBits = BitWidth % APINT_BITS_PER_WORD;
  608     highWordBits = APINT_BITS_PER_WORD;
  611     shift = APINT_BITS_PER_WORD - highWordBits;
  618         Count += APINT_BITS_PER_WORD;
  632     Count += APINT_BITS_PER_WORD;
  642     Count += APINT_BITS_PER_WORD;
  688   APInt Result(getNumWords() * APINT_BITS_PER_WORD, 0);
  812   if (isSingleWord() || getActiveBits() <= APINT_BITS_PER_WORD) {
  853     uint64_t hibits = Tmp.U.pVal[hiWord] << (52 - n % APINT_BITS_PER_WORD);
  854     uint64_t lobits = Tmp.U.pVal[hiWord-1] >> (11 + n % APINT_BITS_PER_WORD);
  859   uint64_t sign = isNeg ? (1ULL << (APINT_BITS_PER_WORD - 1)) : 0;
  869   if (width <= APINT_BITS_PER_WORD)
  876   for (i = 0; i != width / APINT_BITS_PER_WORD; i++)
  880   unsigned bits = (0 - width) % APINT_BITS_PER_WORD;
  891   if (Width <= APINT_BITS_PER_WORD)
  902                    ((BitWidth - 1) % APINT_BITS_PER_WORD) + 1);
  915   if (width <= APINT_BITS_PER_WORD)
  975   unsigned WordShift = ShiftAmt / APINT_BITS_PER_WORD;
  976   unsigned BitShift = ShiftAmt % APINT_BITS_PER_WORD;
  982         U.pVal[getNumWords() - 1], ((BitWidth - 1) % APINT_BITS_PER_WORD) + 1);
  991                     (U.pVal[i + WordShift + 1] << (APINT_BITS_PER_WORD - BitShift));
  997           SignExtend64(U.pVal[WordsToMove - 1], APINT_BITS_PER_WORD - BitShift);
 2285 static_assert(APInt::APINT_BITS_PER_WORD % 2 == 0,
 2293   assert(bits != 0 && bits <= APInt::APINT_BITS_PER_WORD);
 2295   return ~(APInt::WordType) 0 >> (APInt::APINT_BITS_PER_WORD - bits);
 2300   return part & lowBitMask(APInt::APINT_BITS_PER_WORD / 2);
 2305   return part >> (APInt::APINT_BITS_PER_WORD / 2);
 2367       return lsb + i * APINT_BITS_PER_WORD;
 2383       return msb + n * APINT_BITS_PER_WORD;
 2397   unsigned dstParts = (srcBits + APINT_BITS_PER_WORD - 1) / APINT_BITS_PER_WORD;
 2397   unsigned dstParts = (srcBits + APINT_BITS_PER_WORD - 1) / APINT_BITS_PER_WORD;
 2400   unsigned firstSrcPart = srcLSB / APINT_BITS_PER_WORD;
 2403   unsigned shift = srcLSB % APINT_BITS_PER_WORD;
 2409   unsigned n = dstParts * APINT_BITS_PER_WORD - shift;
 2413                           << n % APINT_BITS_PER_WORD);
 2415     if (srcBits % APINT_BITS_PER_WORD)
 2416       dst[dstParts - 1] &= lowBitMask (srcBits % APINT_BITS_PER_WORD);
 2548       mid <<= APINT_BITS_PER_WORD / 2;
 2555       mid <<= APINT_BITS_PER_WORD / 2;
 2654   shiftCount = parts * APINT_BITS_PER_WORD - shiftCount;
 2655   unsigned n = shiftCount / APINT_BITS_PER_WORD;
 2656   WordType mask = (WordType) 1 << (shiftCount % APINT_BITS_PER_WORD);
 2677       mask = (WordType) 1 << (APINT_BITS_PER_WORD - 1);
 2693   unsigned WordShift = std::min(Count / APINT_BITS_PER_WORD, Words);
 2694   unsigned BitShift = Count % APINT_BITS_PER_WORD;
 2704           Dst[Words - WordShift - 1] >> (APINT_BITS_PER_WORD - BitShift);
 2720   unsigned WordShift = std::min(Count / APINT_BITS_PER_WORD, Words);
 2721   unsigned BitShift = Count % APINT_BITS_PER_WORD;
 2731         Dst[i] |= Dst[i + WordShift + 1] << (APINT_BITS_PER_WORD - BitShift);
 2780   while (bits > APINT_BITS_PER_WORD) {
 2782     bits -= APINT_BITS_PER_WORD;
 2786     dst[i++] = ~(WordType) 0 >> (APINT_BITS_PER_WORD - bits);
unittests/ADT/APIntTest.cpp
  574   APInt A2(APInt::APINT_BITS_PER_WORD*4, E2);
 1545     APInt::WordType singleWord = ~APInt::WordType(0) << (APInt::APINT_BITS_PER_WORD - 1);
 1622   APInt A2(APInt::APINT_BITS_PER_WORD*4, E2);
 1624     for (unsigned j = 0; j < APInt::APINT_BITS_PER_WORD; ++j) {
 1626                 A2[i*APInt::APINT_BITS_PER_WORD + j]);
 1661   APInt A4(APInt::APINT_BITS_PER_WORD*4, I4);
 1666   APInt A5(APInt::APINT_BITS_PER_WORD*4, I5);
 1671   APInt A6(APInt::APINT_BITS_PER_WORD*4, I6);