contrib/llvm/include/llvm/ADT/BitVector.h

   1 //===- llvm/ADT/BitVector.h - Bit vectors -----------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the BitVector class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_ADT_BITVECTOR_H
  15 #define LLVM_ADT_BITVECTOR_H
  16
  17 #include "llvm/ADT/ArrayRef.h"
  18 #include "llvm/ADT/iterator_range.h"
  19 #include "llvm/Support/MathExtras.h"
  20 #include <algorithm>
  21 #include <cassert>
  22 #include <climits>
  23 #include <cstdint>
  24 #include <cstdlib>
  25 #include <cstring>
  26 #include <utility>
  27
  28 namespace llvm {
  29
  30 /// ForwardIterator for the bits that are set.
  31 /// Iterators get invalidated when resize / reserve is called.
  32 template <typename BitVectorT> class const_set_bits_iterator_impl {
  33   const BitVectorT &Parent;
  34   int Current = 0;
  35
  36   void advance() {
  37     assert(Current != -1 && "Trying to advance past end.");
  38     Current = Parent.find_next(Current);
  39   }
  40
  41 public:
  42   const_set_bits_iterator_impl(const BitVectorT &Parent, int Current)
  43       : Parent(Parent), Current(Current) {}
  44   explicit const_set_bits_iterator_impl(const BitVectorT &Parent)
  45       : const_set_bits_iterator_impl(Parent, Parent.find_first()) {}
  46   const_set_bits_iterator_impl(const const_set_bits_iterator_impl &) = default;
  47
  48   const_set_bits_iterator_impl operator++(int) {
  49     auto Prev = *this;
  50     advance();
  51     return Prev;
  52   }
  53
  54   const_set_bits_iterator_impl &operator++() {
  55     advance();
  56     return *this;
  57   }
  58
  59   unsigned operator*() const { return Current; }
  60
  61   bool operator==(const const_set_bits_iterator_impl &Other) const {
  62     assert(&Parent == &Other.Parent &&
  63            "Comparing iterators from different BitVectors");
  64     return Current == Other.Current;
  65   }
  66
  67   bool operator!=(const const_set_bits_iterator_impl &Other) const {
  68     assert(&Parent == &Other.Parent &&
  69            "Comparing iterators from different BitVectors");
  70     return Current != Other.Current;
  71   }
  72 };
  73
  74 class BitVector {
  75   typedef unsigned long BitWord;
  76
  77   enum { BITWORD_SIZE = (unsigned)sizeof(BitWord) * CHAR_BIT };
  78
  79   static_assert(BITWORD_SIZE == 64 || BITWORD_SIZE == 32,
  80                 "Unsupported word size");
  81
  82   MutableArrayRef<BitWord> Bits; // Actual bits.
  83   unsigned Size;                 // Size of bitvector in bits.
  84
  85 public:
  86   typedef unsigned size_type;
  87   // Encapsulation of a single bit.
  88   class reference {
  89     friend class BitVector;
  90
  91     BitWord *WordRef;
  92     unsigned BitPos;
  93
  94   public:
  95     reference(BitVector &b, unsigned Idx) {
  96       WordRef = &b.Bits[Idx / BITWORD_SIZE];
  97       BitPos = Idx % BITWORD_SIZE;
  98     }
  99
 100     reference() = delete;
 101     reference(const reference&) = default;
 102
 103     reference &operator=(reference t) {
 104       *this = bool(t);
 105       return *this;
 106     }
 107
 108     reference& operator=(bool t) {
 109       if (t)
 110         *WordRef |= BitWord(1) << BitPos;
 111       else
 112         *WordRef &= ~(BitWord(1) << BitPos);
 113       return *this;
 114     }
 115
 116     operator bool() const {
 117       return ((*WordRef) & (BitWord(1) << BitPos)) != 0;
 118     }
 119   };
 120
 121   typedef const_set_bits_iterator_impl<BitVector> const_set_bits_iterator;
 122   typedef const_set_bits_iterator set_iterator;
 123
 124   const_set_bits_iterator set_bits_begin() const {
 125     return const_set_bits_iterator(*this);
 126   }
 127   const_set_bits_iterator set_bits_end() const {
 128     return const_set_bits_iterator(*this, -1);
 129   }
 130   iterator_range<const_set_bits_iterator> set_bits() const {
 131     return make_range(set_bits_begin(), set_bits_end());
 132   }
 133
 134   /// BitVector default ctor - Creates an empty bitvector.
 135   BitVector() : Size(0) {}
 136
 137   /// BitVector ctor - Creates a bitvector of specified number of bits. All
 138   /// bits are initialized to the specified value.
 139   explicit BitVector(unsigned s, bool t = false) : Size(s) {
 140     size_t Capacity = NumBitWords(s);
 141     Bits = allocate(Capacity);
 142     init_words(Bits, t);
 143     if (t)
 144       clear_unused_bits();
 145   }
 146
 147   /// BitVector copy ctor.
 148   BitVector(const BitVector &RHS) : Size(RHS.size()) {
 149     if (Size == 0) {
 150       Bits = MutableArrayRef<BitWord>();
 151       return;
 152     }
 153
 154     size_t Capacity = NumBitWords(RHS.size());
 155     Bits = allocate(Capacity);
 156     std::memcpy(Bits.data(), RHS.Bits.data(), Capacity * sizeof(BitWord));
 157   }
 158
 159   BitVector(BitVector &&RHS) : Bits(RHS.Bits), Size(RHS.Size) {
 160     RHS.Bits = MutableArrayRef<BitWord>();
 161     RHS.Size = 0;
 162   }
 163
 164   ~BitVector() { std::free(Bits.data()); }
 165
 166   /// empty - Tests whether there are no bits in this bitvector.
 167   bool empty() const { return Size == 0; }
 168
 169   /// size - Returns the number of bits in this bitvector.
 170   size_type size() const { return Size; }
 171
 172   /// count - Returns the number of bits which are set.
 173   size_type count() const {
 174     unsigned NumBits = 0;
 175     for (unsigned i = 0; i < NumBitWords(size()); ++i)
 176       NumBits += countPopulation(Bits[i]);
 177     return NumBits;
 178   }
 179
 180   /// any - Returns true if any bit is set.
 181   bool any() const {
 182     for (unsigned i = 0; i < NumBitWords(size()); ++i)
 183       if (Bits[i] != 0)
 184         return true;
 185     return false;
 186   }
 187
 188   /// all - Returns true if all bits are set.
 189   bool all() const {
 190     for (unsigned i = 0; i < Size / BITWORD_SIZE; ++i)
 191       if (Bits[i] != ~0UL)
 192         return false;
 193
 194     // If bits remain check that they are ones. The unused bits are always zero.
 195     if (unsigned Remainder = Size % BITWORD_SIZE)
 196       return Bits[Size / BITWORD_SIZE] == (1UL << Remainder) - 1;
 197
 198     return true;
 199   }
 200
 201   /// none - Returns true if none of the bits are set.
 202   bool none() const {
 203     return !any();
 204   }
 205
 206   /// find_first_in - Returns the index of the first set bit in the range
 207   /// [Begin, End).  Returns -1 if all bits in the range are unset.
 208   int find_first_in(unsigned Begin, unsigned End) const {
 209     assert(Begin <= End && End <= Size);
 210     if (Begin == End)
 211       return -1;
 212
 213     unsigned FirstWord = Begin / BITWORD_SIZE;
 214     unsigned LastWord = (End - 1) / BITWORD_SIZE;
 215
 216     // Check subsequent words.
 217     for (unsigned i = FirstWord; i <= LastWord; ++i) {
 218       BitWord Copy = Bits[i];
 219
 220       if (i == FirstWord) {
 221         unsigned FirstBit = Begin % BITWORD_SIZE;
 222         Copy &= maskTrailingZeros<BitWord>(FirstBit);
 223       }
 224
 225       if (i == LastWord) {
 226         unsigned LastBit = (End - 1) % BITWORD_SIZE;
 227         Copy &= maskTrailingOnes<BitWord>(LastBit + 1);
 228       }
 229       if (Copy != 0)
 230         return i * BITWORD_SIZE + countTrailingZeros(Copy);
 231     }
 232     return -1;
 233   }
 234
 235   /// find_last_in - Returns the index of the last set bit in the range
 236   /// [Begin, End).  Returns -1 if all bits in the range are unset.
 237   int find_last_in(unsigned Begin, unsigned End) const {
 238     assert(Begin <= End && End <= Size);
 239     if (Begin == End)
 240       return -1;
 241
 242     unsigned LastWord = (End - 1) / BITWORD_SIZE;
 243     unsigned FirstWord = Begin / BITWORD_SIZE;
 244
 245     for (unsigned i = LastWord + 1; i >= FirstWord + 1; --i) {
 246       unsigned CurrentWord = i - 1;
 247
 248       BitWord Copy = Bits[CurrentWord];
 249       if (CurrentWord == LastWord) {
 250         unsigned LastBit = (End - 1) % BITWORD_SIZE;
 251         Copy &= maskTrailingOnes<BitWord>(LastBit + 1);
 252       }
 253
 254       if (CurrentWord == FirstWord) {
 255         unsigned FirstBit = Begin % BITWORD_SIZE;
 256         Copy &= maskTrailingZeros<BitWord>(FirstBit);
 257       }
 258
 259       if (Copy != 0)
 260         return (CurrentWord + 1) * BITWORD_SIZE - countLeadingZeros(Copy) - 1;
 261     }
 262
 263     return -1;
 264   }
 265
 266   /// find_first_unset_in - Returns the index of the first unset bit in the
 267   /// range [Begin, End).  Returns -1 if all bits in the range are set.
 268   int find_first_unset_in(unsigned Begin, unsigned End) const {
 269     assert(Begin <= End && End <= Size);
 270     if (Begin == End)
 271       return -1;
 272
 273     unsigned FirstWord = Begin / BITWORD_SIZE;
 274     unsigned LastWord = (End - 1) / BITWORD_SIZE;
 275
 276     // Check subsequent words.
 277     for (unsigned i = FirstWord; i <= LastWord; ++i) {
 278       BitWord Copy = Bits[i];
 279
 280       if (i == FirstWord) {
 281         unsigned FirstBit = Begin % BITWORD_SIZE;
 282         Copy |= maskTrailingOnes<BitWord>(FirstBit);
 283       }
 284
 285       if (i == LastWord) {
 286         unsigned LastBit = (End - 1) % BITWORD_SIZE;
 287         Copy |= maskTrailingZeros<BitWord>(LastBit + 1);
 288       }
 289       if (Copy != ~0UL) {
 290         unsigned Result = i * BITWORD_SIZE + countTrailingOnes(Copy);
 291         return Result < size() ? Result : -1;
 292       }
 293     }
 294     return -1;
 295   }
 296
 297   /// find_last_unset_in - Returns the index of the last unset bit in the
 298   /// range [Begin, End).  Returns -1 if all bits in the range are set.
 299   int find_last_unset_in(unsigned Begin, unsigned End) const {
 300     assert(Begin <= End && End <= Size);
 301     if (Begin == End)
 302       return -1;
 303
 304     unsigned LastWord = (End - 1) / BITWORD_SIZE;
 305     unsigned FirstWord = Begin / BITWORD_SIZE;
 306
 307     for (unsigned i = LastWord + 1; i >= FirstWord + 1; --i) {
 308       unsigned CurrentWord = i - 1;
 309
 310       BitWord Copy = Bits[CurrentWord];
 311       if (CurrentWord == LastWord) {
 312         unsigned LastBit = (End - 1) % BITWORD_SIZE;
 313         Copy |= maskTrailingZeros<BitWord>(LastBit + 1);
 314       }
 315
 316       if (CurrentWord == FirstWord) {
 317         unsigned FirstBit = Begin % BITWORD_SIZE;
 318         Copy |= maskTrailingOnes<BitWord>(FirstBit);
 319       }
 320
 321       if (Copy != ~0UL) {
 322         unsigned Result =
 323             (CurrentWord + 1) * BITWORD_SIZE - countLeadingOnes(Copy) - 1;
 324         return Result < Size ? Result : -1;
 325       }
 326     }
 327     return -1;
 328   }
 329
 330   /// find_first - Returns the index of the first set bit, -1 if none
 331   /// of the bits are set.
 332   int find_first() const { return find_first_in(0, Size); }
 333
 334   /// find_last - Returns the index of the last set bit, -1 if none of the bits
 335   /// are set.
 336   int find_last() const { return find_last_in(0, Size); }
 337
 338   /// find_next - Returns the index of the next set bit following the
 339   /// "Prev" bit. Returns -1 if the next set bit is not found.
 340   int find_next(unsigned Prev) const { return find_first_in(Prev + 1, Size); }
 341
 342   /// find_prev - Returns the index of the first set bit that precedes the
 343   /// the bit at \p PriorTo.  Returns -1 if all previous bits are unset.
 344   int find_prev(unsigned PriorTo) const { return find_last_in(0, PriorTo); }
 345
 346   /// find_first_unset - Returns the index of the first unset bit, -1 if all
 347   /// of the bits are set.
 348   int find_first_unset() const { return find_first_unset_in(0, Size); }
 349
 350   /// find_next_unset - Returns the index of the next unset bit following the
 351   /// "Prev" bit.  Returns -1 if all remaining bits are set.
 352   int find_next_unset(unsigned Prev) const {
 353     return find_first_unset_in(Prev + 1, Size);
 354   }
 355
 356   /// find_last_unset - Returns the index of the last unset bit, -1 if all of
 357   /// the bits are set.
 358   int find_last_unset() const { return find_last_unset_in(0, Size); }
 359
 360   /// find_prev_unset - Returns the index of the first unset bit that precedes
 361   /// the bit at \p PriorTo.  Returns -1 if all previous bits are set.
 362   int find_prev_unset(unsigned PriorTo) {
 363     return find_last_unset_in(0, PriorTo);
 364   }
 365
 366   /// clear - Removes all bits from the bitvector. Does not change capacity.
 367   void clear() {
 368     Size = 0;
 369   }
 370
 371   /// resize - Grow or shrink the bitvector.
 372   void resize(unsigned N, bool t = false) {
 373     if (N > getBitCapacity()) {
 374       unsigned OldCapacity = Bits.size();
 375       grow(N);
 376       init_words(Bits.drop_front(OldCapacity), t);
 377     }
 378
 379     // Set any old unused bits that are now included in the BitVector. This
 380     // may set bits that are not included in the new vector, but we will clear
 381     // them back out below.
 382     if (N > Size)
 383       set_unused_bits(t);
 384
 385     // Update the size, and clear out any bits that are now unused
 386     unsigned OldSize = Size;
 387     Size = N;
 388     if (t || N < OldSize)
 389       clear_unused_bits();
 390   }
 391
 392   void reserve(unsigned N) {
 393     if (N > getBitCapacity())
 394       grow(N);
 395   }
 396
 397   // Set, reset, flip
 398   BitVector &set() {
 399     init_words(Bits, true);
 400     clear_unused_bits();
 401     return *this;
 402   }
 403
 404   BitVector &set(unsigned Idx) {
 405     assert(Bits.data() && "Bits never allocated");
 406     Bits[Idx / BITWORD_SIZE] |= BitWord(1) << (Idx % BITWORD_SIZE);
 407     return *this;
 408   }
 409
 410   /// set - Efficiently set a range of bits in [I, E)
 411   BitVector &set(unsigned I, unsigned E) {
 412     assert(I <= E && "Attempted to set backwards range!");
 413     assert(E <= size() && "Attempted to set out-of-bounds range!");
 414
 415     if (I == E) return *this;
 416
 417     if (I / BITWORD_SIZE == E / BITWORD_SIZE) {
 418       BitWord EMask = 1UL << (E % BITWORD_SIZE);
 419       BitWord IMask = 1UL << (I % BITWORD_SIZE);
 420       BitWord Mask = EMask - IMask;
 421       Bits[I / BITWORD_SIZE] |= Mask;
 422       return *this;
 423     }
 424
 425     BitWord PrefixMask = ~0UL << (I % BITWORD_SIZE);
 426     Bits[I / BITWORD_SIZE] |= PrefixMask;
 427     I = alignTo(I, BITWORD_SIZE);
 428
 429     for (; I + BITWORD_SIZE <= E; I += BITWORD_SIZE)
 430       Bits[I / BITWORD_SIZE] = ~0UL;
 431
 432     BitWord PostfixMask = (1UL << (E % BITWORD_SIZE)) - 1;
 433     if (I < E)
 434       Bits[I / BITWORD_SIZE] |= PostfixMask;
 435
 436     return *this;
 437   }
 438
 439   BitVector &reset() {
 440     init_words(Bits, false);
 441     return *this;
 442   }
 443
 444   BitVector &reset(unsigned Idx) {
 445     Bits[Idx / BITWORD_SIZE] &= ~(BitWord(1) << (Idx % BITWORD_SIZE));
 446     return *this;
 447   }
 448
 449   /// reset - Efficiently reset a range of bits in [I, E)
 450   BitVector &reset(unsigned I, unsigned E) {
 451     assert(I <= E && "Attempted to reset backwards range!");
 452     assert(E <= size() && "Attempted to reset out-of-bounds range!");
 453
 454     if (I == E) return *this;
 455
 456     if (I / BITWORD_SIZE == E / BITWORD_SIZE) {
 457       BitWord EMask = 1UL << (E % BITWORD_SIZE);
 458       BitWord IMask = 1UL << (I % BITWORD_SIZE);
 459       BitWord Mask = EMask - IMask;
 460       Bits[I / BITWORD_SIZE] &= ~Mask;
 461       return *this;
 462     }
 463
 464     BitWord PrefixMask = ~0UL << (I % BITWORD_SIZE);
 465     Bits[I / BITWORD_SIZE] &= ~PrefixMask;
 466     I = alignTo(I, BITWORD_SIZE);
 467
 468     for (; I + BITWORD_SIZE <= E; I += BITWORD_SIZE)
 469       Bits[I / BITWORD_SIZE] = 0UL;
 470
 471     BitWord PostfixMask = (1UL << (E % BITWORD_SIZE)) - 1;
 472     if (I < E)
 473       Bits[I / BITWORD_SIZE] &= ~PostfixMask;
 474
 475     return *this;
 476   }
 477
 478   BitVector &flip() {
 479     for (unsigned i = 0; i < NumBitWords(size()); ++i)
 480       Bits[i] = ~Bits[i];
 481     clear_unused_bits();
 482     return *this;
 483   }
 484
 485   BitVector &flip(unsigned Idx) {
 486     Bits[Idx / BITWORD_SIZE] ^= BitWord(1) << (Idx % BITWORD_SIZE);
 487     return *this;
 488   }
 489
 490   // Indexing.
 491   reference operator[](unsigned Idx) {
 492     assert (Idx < Size && "Out-of-bounds Bit access.");
 493     return reference(*this, Idx);
 494   }
 495
 496   bool operator[](unsigned Idx) const {
 497     assert (Idx < Size && "Out-of-bounds Bit access.");
 498     BitWord Mask = BitWord(1) << (Idx % BITWORD_SIZE);
 499     return (Bits[Idx / BITWORD_SIZE] & Mask) != 0;
 500   }
 501
 502   bool test(unsigned Idx) const {
 503     return (*this)[Idx];
 504   }
 505
 506   /// Test if any common bits are set.
 507   bool anyCommon(const BitVector &RHS) const {
 508     unsigned ThisWords = NumBitWords(size());
 509     unsigned RHSWords  = NumBitWords(RHS.size());
 510     for (unsigned i = 0, e = std::min(ThisWords, RHSWords); i != e; ++i)
 511       if (Bits[i] & RHS.Bits[i])
 512         return true;
 513     return false;
 514   }
 515
 516   // Comparison operators.
 517   bool operator==(const BitVector &RHS) const {
 518     unsigned ThisWords = NumBitWords(size());
 519     unsigned RHSWords  = NumBitWords(RHS.size());
 520     unsigned i;
 521     for (i = 0; i != std::min(ThisWords, RHSWords); ++i)
 522       if (Bits[i] != RHS.Bits[i])
 523         return false;
 524
 525     // Verify that any extra words are all zeros.
 526     if (i != ThisWords) {
 527       for (; i != ThisWords; ++i)
 528         if (Bits[i])
 529           return false;
 530     } else if (i != RHSWords) {
 531       for (; i != RHSWords; ++i)
 532         if (RHS.Bits[i])
 533           return false;
 534     }
 535     return true;
 536   }
 537
 538   bool operator!=(const BitVector &RHS) const {
 539     return !(*this == RHS);
 540   }
 541
 542   /// Intersection, union, disjoint union.
 543   BitVector &operator&=(const BitVector &RHS) {
 544     unsigned ThisWords = NumBitWords(size());
 545     unsigned RHSWords  = NumBitWords(RHS.size());
 546     unsigned i;
 547     for (i = 0; i != std::min(ThisWords, RHSWords); ++i)
 548       Bits[i] &= RHS.Bits[i];
 549
 550     // Any bits that are just in this bitvector become zero, because they aren't
 551     // in the RHS bit vector.  Any words only in RHS are ignored because they
 552     // are already zero in the LHS.
 553     for (; i != ThisWords; ++i)
 554       Bits[i] = 0;
 555
 556     return *this;
 557   }
 558
 559   /// reset - Reset bits that are set in RHS. Same as *this &= ~RHS.
 560   BitVector &reset(const BitVector &RHS) {
 561     unsigned ThisWords = NumBitWords(size());
 562     unsigned RHSWords  = NumBitWords(RHS.size());
 563     unsigned i;
 564     for (i = 0; i != std::min(ThisWords, RHSWords); ++i)
 565       Bits[i] &= ~RHS.Bits[i];
 566     return *this;
 567   }
 568
 569   /// test - Check if (This - RHS) is zero.
 570   /// This is the same as reset(RHS) and any().
 571   bool test(const BitVector &RHS) const {
 572     unsigned ThisWords = NumBitWords(size());
 573     unsigned RHSWords  = NumBitWords(RHS.size());
 574     unsigned i;
 575     for (i = 0; i != std::min(ThisWords, RHSWords); ++i)
 576       if ((Bits[i] & ~RHS.Bits[i]) != 0)
 577         return true;
 578
 579     for (; i != ThisWords ; ++i)
 580       if (Bits[i] != 0)
 581         return true;
 582
 583     return false;
 584   }
 585
 586   BitVector &operator|=(const BitVector &RHS) {
 587     if (size() < RHS.size())
 588       resize(RHS.size());
 589     for (size_t i = 0, e = NumBitWords(RHS.size()); i != e; ++i)
 590       Bits[i] |= RHS.Bits[i];
 591     return *this;
 592   }
 593
 594   BitVector &operator^=(const BitVector &RHS) {
 595     if (size() < RHS.size())
 596       resize(RHS.size());
 597     for (size_t i = 0, e = NumBitWords(RHS.size()); i != e; ++i)
 598       Bits[i] ^= RHS.Bits[i];
 599     return *this;
 600   }
 601
 602   BitVector &operator>>=(unsigned N) {
 603     assert(N <= Size);
 604     if (LLVM_UNLIKELY(empty() || N == 0))
 605       return *this;
 606
 607     unsigned NumWords = NumBitWords(Size);
 608     assert(NumWords >= 1);
 609
 610     wordShr(N / BITWORD_SIZE);
 611
 612     unsigned BitDistance = N % BITWORD_SIZE;
 613     if (BitDistance == 0)
 614       return *this;
 615
 616     // When the shift size is not a multiple of the word size, then we have
 617     // a tricky situation where each word in succession needs to extract some
 618     // of the bits from the next word and or them into this word while
 619     // shifting this word to make room for the new bits.  This has to be done
 620     // for every word in the array.
 621
 622     // Since we're shifting each word right, some bits will fall off the end
 623     // of each word to the right, and empty space will be created on the left.
 624     // The final word in the array will lose bits permanently, so starting at
 625     // the beginning, work forwards shifting each word to the right, and
 626     // OR'ing in the bits from the end of the next word to the beginning of
 627     // the current word.
 628
 629     // Example:
 630     //   Starting with {0xAABBCCDD, 0xEEFF0011, 0x22334455} and shifting right
 631     //   by 4 bits.
 632     // Step 1: Word[0] >>= 4           ; 0x0ABBCCDD
 633     // Step 2: Word[0] |= 0x10000000   ; 0x1ABBCCDD
 634     // Step 3: Word[1] >>= 4           ; 0x0EEFF001
 635     // Step 4: Word[1] |= 0x50000000   ; 0x5EEFF001
 636     // Step 5: Word[2] >>= 4           ; 0x02334455
 637     // Result: { 0x1ABBCCDD, 0x5EEFF001, 0x02334455 }
 638     const BitWord Mask = maskTrailingOnes<BitWord>(BitDistance);
 639     const unsigned LSH = BITWORD_SIZE - BitDistance;
 640
 641     for (unsigned I = 0; I < NumWords - 1; ++I) {
 642       Bits[I] >>= BitDistance;
 643       Bits[I] |= (Bits[I + 1] & Mask) << LSH;
 644     }
 645
 646     Bits[NumWords - 1] >>= BitDistance;
 647
 648     return *this;
 649   }
 650
 651   BitVector &operator<<=(unsigned N) {
 652     assert(N <= Size);
 653     if (LLVM_UNLIKELY(empty() || N == 0))
 654       return *this;
 655
 656     unsigned NumWords = NumBitWords(Size);
 657     assert(NumWords >= 1);
 658
 659     wordShl(N / BITWORD_SIZE);
 660
 661     unsigned BitDistance = N % BITWORD_SIZE;
 662     if (BitDistance == 0)
 663       return *this;
 664
 665     // When the shift size is not a multiple of the word size, then we have
 666     // a tricky situation where each word in succession needs to extract some
 667     // of the bits from the previous word and or them into this word while
 668     // shifting this word to make room for the new bits.  This has to be done
 669     // for every word in the array.  This is similar to the algorithm outlined
 670     // in operator>>=, but backwards.
 671
 672     // Since we're shifting each word left, some bits will fall off the end
 673     // of each word to the left, and empty space will be created on the right.
 674     // The first word in the array will lose bits permanently, so starting at
 675     // the end, work backwards shifting each word to the left, and OR'ing
 676     // in the bits from the end of the next word to the beginning of the
 677     // current word.
 678
 679     // Example:
 680     //   Starting with {0xAABBCCDD, 0xEEFF0011, 0x22334455} and shifting left
 681     //   by 4 bits.
 682     // Step 1: Word[2] <<= 4           ; 0x23344550
 683     // Step 2: Word[2] |= 0x0000000E   ; 0x2334455E
 684     // Step 3: Word[1] <<= 4           ; 0xEFF00110
 685     // Step 4: Word[1] |= 0x0000000A   ; 0xEFF0011A
 686     // Step 5: Word[0] <<= 4           ; 0xABBCCDD0
 687     // Result: { 0xABBCCDD0, 0xEFF0011A, 0x2334455E }
 688     const BitWord Mask = maskLeadingOnes<BitWord>(BitDistance);
 689     const unsigned RSH = BITWORD_SIZE - BitDistance;
 690
 691     for (int I = NumWords - 1; I > 0; --I) {
 692       Bits[I] <<= BitDistance;
 693       Bits[I] |= (Bits[I - 1] & Mask) >> RSH;
 694     }
 695     Bits[0] <<= BitDistance;
 696     clear_unused_bits();
 697
 698     return *this;
 699   }
 700
 701   // Assignment operator.
 702   const BitVector &operator=(const BitVector &RHS) {
 703     if (this == &RHS) return *this;
 704
 705     Size = RHS.size();
 706     unsigned RHSWords = NumBitWords(Size);
 707     if (Size <= getBitCapacity()) {
 708       if (Size)
 709         std::memcpy(Bits.data(), RHS.Bits.data(), RHSWords * sizeof(BitWord));
 710       clear_unused_bits();
 711       return *this;
 712     }
 713
 714     // Grow the bitvector to have enough elements.
 715     unsigned NewCapacity = RHSWords;
 716     assert(NewCapacity > 0 && "negative capacity?");
 717     auto NewBits = allocate(NewCapacity);
 718     std::memcpy(NewBits.data(), RHS.Bits.data(), NewCapacity * sizeof(BitWord));
 719
 720     // Destroy the old bits.
 721     std::free(Bits.data());
 722     Bits = NewBits;
 723
 724     return *this;
 725   }
 726
 727   const BitVector &operator=(BitVector &&RHS) {
 728     if (this == &RHS) return *this;
 729
 730     std::free(Bits.data());
 731     Bits = RHS.Bits;
 732     Size = RHS.Size;
 733
 734     RHS.Bits = MutableArrayRef<BitWord>();
 735     RHS.Size = 0;
 736
 737     return *this;
 738   }
 739
 740   void swap(BitVector &RHS) {
 741     std::swap(Bits, RHS.Bits);
 742     std::swap(Size, RHS.Size);
 743   }
 744
 745   //===--------------------------------------------------------------------===//
 746   // Portable bit mask operations.
 747   //===--------------------------------------------------------------------===//
 748   //
 749   // These methods all operate on arrays of uint32_t, each holding 32 bits. The
 750   // fixed word size makes it easier to work with literal bit vector constants
 751   // in portable code.
 752   //
 753   // The LSB in each word is the lowest numbered bit.  The size of a portable
 754   // bit mask is always a whole multiple of 32 bits.  If no bit mask size is
 755   // given, the bit mask is assumed to cover the entire BitVector.
 756
 757   /// setBitsInMask - Add '1' bits from Mask to this vector. Don't resize.
 758   /// This computes "*this |= Mask".
 759   void setBitsInMask(const uint32_t *Mask, unsigned MaskWords = ~0u) {
 760     applyMask<true, false>(Mask, MaskWords);
 761   }
 762
 763   /// clearBitsInMask - Clear any bits in this vector that are set in Mask.
 764   /// Don't resize. This computes "*this &= ~Mask".
 765   void clearBitsInMask(const uint32_t *Mask, unsigned MaskWords = ~0u) {
 766     applyMask<false, false>(Mask, MaskWords);
 767   }
 768
 769   /// setBitsNotInMask - Add a bit to this vector for every '0' bit in Mask.
 770   /// Don't resize.  This computes "*this |= ~Mask".
 771   void setBitsNotInMask(const uint32_t *Mask, unsigned MaskWords = ~0u) {
 772     applyMask<true, true>(Mask, MaskWords);
 773   }
 774
 775   /// clearBitsNotInMask - Clear a bit in this vector for every '0' bit in Mask.
 776   /// Don't resize.  This computes "*this &= Mask".
 777   void clearBitsNotInMask(const uint32_t *Mask, unsigned MaskWords = ~0u) {
 778     applyMask<false, true>(Mask, MaskWords);
 779   }
 780
 781 private:
 782   /// Perform a logical left shift of \p Count words by moving everything
 783   /// \p Count words to the right in memory.
 784   ///
 785   /// While confusing, words are stored from least significant at Bits[0] to
 786   /// most significant at Bits[NumWords-1].  A logical shift left, however,
 787   /// moves the current least significant bit to a higher logical index, and
 788   /// fills the previous least significant bits with 0.  Thus, we actually
 789   /// need to move the bytes of the memory to the right, not to the left.
 790   /// Example:
 791   ///   Words = [0xBBBBAAAA, 0xDDDDFFFF, 0x00000000, 0xDDDD0000]
 792   /// represents a BitVector where 0xBBBBAAAA contain the least significant
 793   /// bits.  So if we want to shift the BitVector left by 2 words, we need to
 794   /// turn this into 0x00000000 0x00000000 0xBBBBAAAA 0xDDDDFFFF by using a
 795   /// memmove which moves right, not left.
 796   void wordShl(uint32_t Count) {
 797     if (Count == 0)
 798       return;
 799
 800     uint32_t NumWords = NumBitWords(Size);
 801
 802     auto Src = Bits.take_front(NumWords).drop_back(Count);
 803     auto Dest = Bits.take_front(NumWords).drop_front(Count);
 804
 805     // Since we always move Word-sized chunks of data with src and dest both
 806     // aligned to a word-boundary, we don't need to worry about endianness
 807     // here.
 808     std::memmove(Dest.begin(), Src.begin(), Dest.size() * sizeof(BitWord));
 809     std::memset(Bits.data(), 0, Count * sizeof(BitWord));
 810     clear_unused_bits();
 811   }
 812
 813   /// Perform a logical right shift of \p Count words by moving those
 814   /// words to the left in memory.  See wordShl for more information.
 815   ///
 816   void wordShr(uint32_t Count) {
 817     if (Count == 0)
 818       return;
 819
 820     uint32_t NumWords = NumBitWords(Size);
 821
 822     auto Src = Bits.take_front(NumWords).drop_front(Count);
 823     auto Dest = Bits.take_front(NumWords).drop_back(Count);
 824     assert(Dest.size() == Src.size());
 825
 826     std::memmove(Dest.begin(), Src.begin(), Dest.size() * sizeof(BitWord));
 827     std::memset(Dest.end(), 0, Count * sizeof(BitWord));
 828   }
 829
 830   MutableArrayRef<BitWord> allocate(size_t NumWords) {
 831     BitWord *RawBits = static_cast<BitWord *>(
 832         safe_malloc(NumWords * sizeof(BitWord)));
 833     return MutableArrayRef<BitWord>(RawBits, NumWords);
 834   }
 835
 836   int next_unset_in_word(int WordIndex, BitWord Word) const {
 837     unsigned Result = WordIndex * BITWORD_SIZE + countTrailingOnes(Word);
 838     return Result < size() ? Result : -1;
 839   }
 840
 841   unsigned NumBitWords(unsigned S) const {
 842     return (S + BITWORD_SIZE-1) / BITWORD_SIZE;
 843   }
 844
 845   // Set the unused bits in the high words.
 846   void set_unused_bits(bool t = true) {
 847     //  Set high words first.
 848     unsigned UsedWords = NumBitWords(Size);
 849     if (Bits.size() > UsedWords)
 850       init_words(Bits.drop_front(UsedWords), t);
 851
 852     //  Then set any stray high bits of the last used word.
 853     unsigned ExtraBits = Size % BITWORD_SIZE;
 854     if (ExtraBits) {
 855       BitWord ExtraBitMask = ~0UL << ExtraBits;
 856       if (t)
 857         Bits[UsedWords-1] |= ExtraBitMask;
 858       else
 859         Bits[UsedWords-1] &= ~ExtraBitMask;
 860     }
 861   }
 862
 863   // Clear the unused bits in the high words.
 864   void clear_unused_bits() {
 865     set_unused_bits(false);
 866   }
 867
 868   void grow(unsigned NewSize) {
 869     size_t NewCapacity = std::max<size_t>(NumBitWords(NewSize), Bits.size() * 2);
 870     assert(NewCapacity > 0 && "realloc-ing zero space");
 871     BitWord *NewBits = static_cast<BitWord *>(
 872         safe_realloc(Bits.data(), NewCapacity * sizeof(BitWord)));
 873     Bits = MutableArrayRef<BitWord>(NewBits, NewCapacity);
 874     clear_unused_bits();
 875   }
 876
 877   void init_words(MutableArrayRef<BitWord> B, bool t) {
 878     if (B.size() > 0)
 879       memset(B.data(), 0 - (int)t, B.size() * sizeof(BitWord));
 880   }
 881
 882   template<bool AddBits, bool InvertMask>
 883   void applyMask(const uint32_t *Mask, unsigned MaskWords) {
 884     static_assert(BITWORD_SIZE % 32 == 0, "Unsupported BitWord size.");
 885     MaskWords = std::min(MaskWords, (size() + 31) / 32);
 886     const unsigned Scale = BITWORD_SIZE / 32;
 887     unsigned i;
 888     for (i = 0; MaskWords >= Scale; ++i, MaskWords -= Scale) {
 889       BitWord BW = Bits[i];
 890       // This inner loop should unroll completely when BITWORD_SIZE > 32.
 891       for (unsigned b = 0; b != BITWORD_SIZE; b += 32) {
 892         uint32_t M = *Mask++;
 893         if (InvertMask) M = ~M;
 894         if (AddBits) BW |=   BitWord(M) << b;
 895         else         BW &= ~(BitWord(M) << b);
 896       }
 897       Bits[i] = BW;
 898     }
 899     for (unsigned b = 0; MaskWords; b += 32, --MaskWords) {
 900       uint32_t M = *Mask++;
 901       if (InvertMask) M = ~M;
 902       if (AddBits) Bits[i] |=   BitWord(M) << b;
 903       else         Bits[i] &= ~(BitWord(M) << b);
 904     }
 905     if (AddBits)
 906       clear_unused_bits();
 907   }
 908
 909 public:
 910   /// Return the size (in bytes) of the bit vector.
 911   size_t getMemorySize() const { return Bits.size() * sizeof(BitWord); }
 912   size_t getBitCapacity() const { return Bits.size() * BITWORD_SIZE; }
 913 };
 914
 915 inline size_t capacity_in_bytes(const BitVector &X) {
 916   return X.getMemorySize();
 917 }
 918
 919 } // end namespace llvm
 920
 921 namespace std {
 922   /// Implement std::swap in terms of BitVector swap.
 923   inline void
 924   swap(llvm::BitVector &LHS, llvm::BitVector &RHS) {
 925     LHS.swap(RHS);
 926   }
 927 } // end namespace std
 928
 929 #endif // LLVM_ADT_BITVECTOR_H