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

References

include/llvm/ADT/BitVector.h
   78   static_assert(BITWORD_SIZE == 64 || BITWORD_SIZE == 32,
   78   static_assert(BITWORD_SIZE == 64 || BITWORD_SIZE == 32,
   95       WordRef = &b.Bits[Idx / BITWORD_SIZE];
   96       BitPos = Idx % BITWORD_SIZE;
  189     for (unsigned i = 0; i < Size / BITWORD_SIZE; ++i)
  194     if (unsigned Remainder = Size % BITWORD_SIZE)
  195       return Bits[Size / BITWORD_SIZE] == (1UL << Remainder) - 1;
  212     unsigned FirstWord = Begin / BITWORD_SIZE;
  213     unsigned LastWord = (End - 1) / BITWORD_SIZE;
  220         unsigned FirstBit = Begin % BITWORD_SIZE;
  225         unsigned LastBit = (End - 1) % BITWORD_SIZE;
  229         return i * BITWORD_SIZE + countTrailingZeros(Copy);
  241     unsigned LastWord = (End - 1) / BITWORD_SIZE;
  242     unsigned FirstWord = Begin / BITWORD_SIZE;
  249         unsigned LastBit = (End - 1) % BITWORD_SIZE;
  254         unsigned FirstBit = Begin % BITWORD_SIZE;
  259         return (CurrentWord + 1) * BITWORD_SIZE - countLeadingZeros(Copy) - 1;
  272     unsigned FirstWord = Begin / BITWORD_SIZE;
  273     unsigned LastWord = (End - 1) / BITWORD_SIZE;
  280         unsigned FirstBit = Begin % BITWORD_SIZE;
  285         unsigned LastBit = (End - 1) % BITWORD_SIZE;
  289         unsigned Result = i * BITWORD_SIZE + countTrailingOnes(Copy);
  303     unsigned LastWord = (End - 1) / BITWORD_SIZE;
  304     unsigned FirstWord = Begin / BITWORD_SIZE;
  311         unsigned LastBit = (End - 1) % BITWORD_SIZE;
  316         unsigned FirstBit = Begin % BITWORD_SIZE;
  322             (CurrentWord + 1) * BITWORD_SIZE - countLeadingOnes(Copy) - 1;
  405     Bits[Idx / BITWORD_SIZE] |= BitWord(1) << (Idx % BITWORD_SIZE);
  405     Bits[Idx / BITWORD_SIZE] |= BitWord(1) << (Idx % BITWORD_SIZE);
  416     if (I / BITWORD_SIZE == E / BITWORD_SIZE) {
  416     if (I / BITWORD_SIZE == E / BITWORD_SIZE) {
  417       BitWord EMask = 1UL << (E % BITWORD_SIZE);
  418       BitWord IMask = 1UL << (I % BITWORD_SIZE);
  420       Bits[I / BITWORD_SIZE] |= Mask;
  424     BitWord PrefixMask = ~0UL << (I % BITWORD_SIZE);
  425     Bits[I / BITWORD_SIZE] |= PrefixMask;
  426     I = alignTo(I, BITWORD_SIZE);
  428     for (; I + BITWORD_SIZE <= E; I += BITWORD_SIZE)
  428     for (; I + BITWORD_SIZE <= E; I += BITWORD_SIZE)
  429       Bits[I / BITWORD_SIZE] = ~0UL;
  431     BitWord PostfixMask = (1UL << (E % BITWORD_SIZE)) - 1;
  433       Bits[I / BITWORD_SIZE] |= PostfixMask;
  444     Bits[Idx / BITWORD_SIZE] &= ~(BitWord(1) << (Idx % BITWORD_SIZE));
  444     Bits[Idx / BITWORD_SIZE] &= ~(BitWord(1) << (Idx % BITWORD_SIZE));
  455     if (I / BITWORD_SIZE == E / BITWORD_SIZE) {
  455     if (I / BITWORD_SIZE == E / BITWORD_SIZE) {
  456       BitWord EMask = 1UL << (E % BITWORD_SIZE);
  457       BitWord IMask = 1UL << (I % BITWORD_SIZE);
  459       Bits[I / BITWORD_SIZE] &= ~Mask;
  463     BitWord PrefixMask = ~0UL << (I % BITWORD_SIZE);
  464     Bits[I / BITWORD_SIZE] &= ~PrefixMask;
  465     I = alignTo(I, BITWORD_SIZE);
  467     for (; I + BITWORD_SIZE <= E; I += BITWORD_SIZE)
  467     for (; I + BITWORD_SIZE <= E; I += BITWORD_SIZE)
  468       Bits[I / BITWORD_SIZE] = 0UL;
  470     BitWord PostfixMask = (1UL << (E % BITWORD_SIZE)) - 1;
  472       Bits[I / BITWORD_SIZE] &= ~PostfixMask;
  485     Bits[Idx / BITWORD_SIZE] ^= BitWord(1) << (Idx % BITWORD_SIZE);
  485     Bits[Idx / BITWORD_SIZE] ^= BitWord(1) << (Idx % BITWORD_SIZE);
  497     BitWord Mask = BitWord(1) << (Idx % BITWORD_SIZE);
  498     return (Bits[Idx / BITWORD_SIZE] & Mask) != 0;
  626     wordShr(N / BITWORD_SIZE);
  628     unsigned BitDistance = N % BITWORD_SIZE;
  655     const unsigned LSH = BITWORD_SIZE - BitDistance;
  675     wordShl(N / BITWORD_SIZE);
  677     unsigned BitDistance = N % BITWORD_SIZE;
  705     const unsigned RSH = BITWORD_SIZE - BitDistance;
  853     unsigned Result = WordIndex * BITWORD_SIZE + countTrailingOnes(Word);
  858     return (S + BITWORD_SIZE-1) / BITWORD_SIZE;
  858     return (S + BITWORD_SIZE-1) / BITWORD_SIZE;
  869     unsigned ExtraBits = Size % BITWORD_SIZE;
  900     static_assert(BITWORD_SIZE % 32 == 0, "Unsupported BitWord size.");
  902     const unsigned Scale = BITWORD_SIZE / 32;
  907       for (unsigned b = 0; b != BITWORD_SIZE; b += 32) {
  928   size_t getBitCapacity() const { return Bits.size() * BITWORD_SIZE; }