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   // Push single bit to end of vector.
 507   void push_back(bool Val) {
 508     unsigned OldSize = Size;
 509     unsigned NewSize = Size + 1;
 510
 511     // Resize, which will insert zeros.
 512     // If we already fit then the unused bits will be already zero.
 513     if (NewSize > getBitCapacity())
 514       resize(NewSize, false);
 515     else
 516       Size = NewSize;
 517
 518     // If true, set single bit.
 519     if (Val)
 520       set(OldSize);
 521   }
 522
 523   /// Test if any common bits are set.
 524   bool anyCommon(const BitVector &RHS) const {
 525     unsigned ThisWords = NumBitWords(size());
 526     unsigned RHSWords  = NumBitWords(RHS.size());
 527     for (unsigned i = 0, e = std::min(ThisWords, RHSWords); i != e; ++i)
 528       if (Bits[i] & RHS.Bits[i])
 529         return true;
 530     return false;
 531   }
 532
 533   // Comparison operators.
 534   bool operator==(const BitVector &RHS) const {
 535     unsigned ThisWords = NumBitWords(size());
 536     unsigned RHSWords  = NumBitWords(RHS.size());
 537     unsigned i;
 538     for (i = 0; i != std::min(ThisWords, RHSWords); ++i)
 539       if (Bits[i] != RHS.Bits[i])
 540         return false;
 541
 542     // Verify that any extra words are all zeros.
 543     if (i != ThisWords) {
 544       for (; i != ThisWords; ++i)
 545         if (Bits[i])
 546           return false;
 547     } else if (i != RHSWords) {
 548       for (; i != RHSWords; ++i)
 549         if (RHS.Bits[i])
 550           return false;
 551     }
 552     return true;
 553   }
 554
 555   bool operator!=(const BitVector &RHS) const {
 556     return !(*this == RHS);
 557   }
 558
 559   /// Intersection, union, disjoint union.
 560   BitVector &operator&=(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
 567     // Any bits that are just in this bitvector become zero, because they aren't
 568     // in the RHS bit vector.  Any words only in RHS are ignored because they
 569     // are already zero in the LHS.
 570     for (; i != ThisWords; ++i)
 571       Bits[i] = 0;
 572
 573     return *this;
 574   }
 575
 576   /// reset - Reset bits that are set in RHS. Same as *this &= ~RHS.
 577   BitVector &reset(const BitVector &RHS) {
 578     unsigned ThisWords = NumBitWords(size());
 579     unsigned RHSWords  = NumBitWords(RHS.size());
 580     unsigned i;
 581     for (i = 0; i != std::min(ThisWords, RHSWords); ++i)
 582       Bits[i] &= ~RHS.Bits[i];
 583     return *this;
 584   }
 585
 586   /// test - Check if (This - RHS) is zero.
 587   /// This is the same as reset(RHS) and any().
 588   bool test(const BitVector &RHS) const {
 589     unsigned ThisWords = NumBitWords(size());
 590     unsigned RHSWords  = NumBitWords(RHS.size());
 591     unsigned i;
 592     for (i = 0; i != std::min(ThisWords, RHSWords); ++i)
 593       if ((Bits[i] & ~RHS.Bits[i]) != 0)
 594         return true;
 595
 596     for (; i != ThisWords ; ++i)
 597       if (Bits[i] != 0)
 598         return true;
 599
 600     return false;
 601   }
 602
 603   BitVector &operator|=(const BitVector &RHS) {
 604     if (size() < RHS.size())
 605       resize(RHS.size());
 606     for (size_t i = 0, e = NumBitWords(RHS.size()); i != e; ++i)
 607       Bits[i] |= RHS.Bits[i];
 608     return *this;
 609   }
 610
 611   BitVector &operator^=(const BitVector &RHS) {
 612     if (size() < RHS.size())
 613       resize(RHS.size());
 614     for (size_t i = 0, e = NumBitWords(RHS.size()); i != e; ++i)
 615       Bits[i] ^= RHS.Bits[i];
 616     return *this;
 617   }
 618
 619   BitVector &operator>>=(unsigned N) {
 620     assert(N <= Size);
 621     if (LLVM_UNLIKELY(empty() || N == 0))
 622       return *this;
 623
 624     unsigned NumWords = NumBitWords(Size);
 625     assert(NumWords >= 1);
 626
 627     wordShr(N / BITWORD_SIZE);
 628
 629     unsigned BitDistance = N % BITWORD_SIZE;
 630     if (BitDistance == 0)
 631       return *this;
 632
 633     // When the shift size is not a multiple of the word size, then we have
 634     // a tricky situation where each word in succession needs to extract some
 635     // of the bits from the next word and or them into this word while
 636     // shifting this word to make room for the new bits.  This has to be done
 637     // for every word in the array.
 638
 639     // Since we're shifting each word right, some bits will fall off the end
 640     // of each word to the right, and empty space will be created on the left.
 641     // The final word in the array will lose bits permanently, so starting at
 642     // the beginning, work forwards shifting each word to the right, and
 643     // OR'ing in the bits from the end of the next word to the beginning of
 644     // the current word.
 645
 646     // Example:
 647     //   Starting with {0xAABBCCDD, 0xEEFF0011, 0x22334455} and shifting right
 648     //   by 4 bits.
 649     // Step 1: Word[0] >>= 4           ; 0x0ABBCCDD
 650     // Step 2: Word[0] |= 0x10000000   ; 0x1ABBCCDD
 651     // Step 3: Word[1] >>= 4           ; 0x0EEFF001
 652     // Step 4: Word[1] |= 0x50000000   ; 0x5EEFF001
 653     // Step 5: Word[2] >>= 4           ; 0x02334455
 654     // Result: { 0x1ABBCCDD, 0x5EEFF001, 0x02334455 }
 655     const BitWord Mask = maskTrailingOnes<BitWord>(BitDistance);
 656     const unsigned LSH = BITWORD_SIZE - BitDistance;
 657
 658     for (unsigned I = 0; I < NumWords - 1; ++I) {
 659       Bits[I] >>= BitDistance;
 660       Bits[I] |= (Bits[I + 1] & Mask) << LSH;
 661     }
 662
 663     Bits[NumWords - 1] >>= BitDistance;
 664
 665     return *this;
 666   }
 667
 668   BitVector &operator<<=(unsigned N) {
 669     assert(N <= Size);
 670     if (LLVM_UNLIKELY(empty() || N == 0))
 671       return *this;
 672
 673     unsigned NumWords = NumBitWords(Size);
 674     assert(NumWords >= 1);
 675
 676     wordShl(N / BITWORD_SIZE);
 677
 678     unsigned BitDistance = N % BITWORD_SIZE;
 679     if (BitDistance == 0)
 680       return *this;
 681
 682     // When the shift size is not a multiple of the word size, then we have
 683     // a tricky situation where each word in succession needs to extract some
 684     // of the bits from the previous word and or them into this word while
 685     // shifting this word to make room for the new bits.  This has to be done
 686     // for every word in the array.  This is similar to the algorithm outlined
 687     // in operator>>=, but backwards.
 688
 689     // Since we're shifting each word left, some bits will fall off the end
 690     // of each word to the left, and empty space will be created on the right.
 691     // The first word in the array will lose bits permanently, so starting at
 692     // the end, work backwards shifting each word to the left, and OR'ing
 693     // in the bits from the end of the next word to the beginning of the
 694     // current word.
 695
 696     // Example:
 697     //   Starting with {0xAABBCCDD, 0xEEFF0011, 0x22334455} and shifting left
 698     //   by 4 bits.
 699     // Step 1: Word[2] <<= 4           ; 0x23344550
 700     // Step 2: Word[2] |= 0x0000000E   ; 0x2334455E
 701     // Step 3: Word[1] <<= 4           ; 0xEFF00110
 702     // Step 4: Word[1] |= 0x0000000A   ; 0xEFF0011A
 703     // Step 5: Word[0] <<= 4           ; 0xABBCCDD0
 704     // Result: { 0xABBCCDD0, 0xEFF0011A, 0x2334455E }
 705     const BitWord Mask = maskLeadingOnes<BitWord>(BitDistance);
 706     const unsigned RSH = BITWORD_SIZE - BitDistance;
 707
 708     for (int I = NumWords - 1; I > 0; --I) {
 709       Bits[I] <<= BitDistance;
 710       Bits[I] |= (Bits[I - 1] & Mask) >> RSH;
 711     }
 712     Bits[0] <<= BitDistance;
 713     clear_unused_bits();
 714
 715     return *this;
 716   }
 717
 718   // Assignment operator.
 719   const BitVector &operator=(const BitVector &RHS) {
 720     if (this == &RHS) return *this;
 721
 722     Size = RHS.size();
 723     unsigned RHSWords = NumBitWords(Size);
 724     if (Size <= getBitCapacity()) {
 725       if (Size)
 726         std::memcpy(Bits.data(), RHS.Bits.data(), RHSWords * sizeof(BitWord));
 727       clear_unused_bits();
 728       return *this;
 729     }
 730
 731     // Grow the bitvector to have enough elements.
 732     unsigned NewCapacity = RHSWords;
 733     assert(NewCapacity > 0 && "negative capacity?");
 734     auto NewBits = allocate(NewCapacity);
 735     std::memcpy(NewBits.data(), RHS.Bits.data(), NewCapacity * sizeof(BitWord));
 736
 737     // Destroy the old bits.
 738     std::free(Bits.data());
 739     Bits = NewBits;
 740
 741     return *this;
 742   }
 743
 744   const BitVector &operator=(BitVector &&RHS) {
 745     if (this == &RHS) return *this;
 746
 747     std::free(Bits.data());
 748     Bits = RHS.Bits;
 749     Size = RHS.Size;
 750
 751     RHS.Bits = MutableArrayRef<BitWord>();
 752     RHS.Size = 0;
 753
 754     return *this;
 755   }
 756
 757   void swap(BitVector &RHS) {
 758     std::swap(Bits, RHS.Bits);
 759     std::swap(Size, RHS.Size);
 760   }
 761
 762   //===--------------------------------------------------------------------===//
 763   // Portable bit mask operations.
 764   //===--------------------------------------------------------------------===//
 765   //
 766   // These methods all operate on arrays of uint32_t, each holding 32 bits. The
 767   // fixed word size makes it easier to work with literal bit vector constants
 768   // in portable code.
 769   //
 770   // The LSB in each word is the lowest numbered bit.  The size of a portable
 771   // bit mask is always a whole multiple of 32 bits.  If no bit mask size is
 772   // given, the bit mask is assumed to cover the entire BitVector.
 773
 774   /// setBitsInMask - Add '1' bits from Mask to this vector. Don't resize.
 775   /// This computes "*this |= Mask".
 776   void setBitsInMask(const uint32_t *Mask, unsigned MaskWords = ~0u) {
 777     applyMask<true, false>(Mask, MaskWords);
 778   }
 779
 780   /// clearBitsInMask - Clear any bits in this vector that are set in Mask.
 781   /// Don't resize. This computes "*this &= ~Mask".
 782   void clearBitsInMask(const uint32_t *Mask, unsigned MaskWords = ~0u) {
 783     applyMask<false, false>(Mask, MaskWords);
 784   }
 785
 786   /// setBitsNotInMask - Add a bit to this vector for every '0' bit in Mask.
 787   /// Don't resize.  This computes "*this |= ~Mask".
 788   void setBitsNotInMask(const uint32_t *Mask, unsigned MaskWords = ~0u) {
 789     applyMask<true, true>(Mask, MaskWords);
 790   }
 791
 792   /// clearBitsNotInMask - Clear a bit in this vector for every '0' bit in Mask.
 793   /// Don't resize.  This computes "*this &= Mask".
 794   void clearBitsNotInMask(const uint32_t *Mask, unsigned MaskWords = ~0u) {
 795     applyMask<false, true>(Mask, MaskWords);
 796   }
 797
 798 private:
 799   /// Perform a logical left shift of \p Count words by moving everything
 800   /// \p Count words to the right in memory.
 801   ///
 802   /// While confusing, words are stored from least significant at Bits[0] to
 803   /// most significant at Bits[NumWords-1].  A logical shift left, however,
 804   /// moves the current least significant bit to a higher logical index, and
 805   /// fills the previous least significant bits with 0.  Thus, we actually
 806   /// need to move the bytes of the memory to the right, not to the left.
 807   /// Example:
 808   ///   Words = [0xBBBBAAAA, 0xDDDDFFFF, 0x00000000, 0xDDDD0000]
 809   /// represents a BitVector where 0xBBBBAAAA contain the least significant
 810   /// bits.  So if we want to shift the BitVector left by 2 words, we need to
 811   /// turn this into 0x00000000 0x00000000 0xBBBBAAAA 0xDDDDFFFF by using a
 812   /// memmove which moves right, not left.
 813   void wordShl(uint32_t Count) {
 814     if (Count == 0)
 815       return;
 816
 817     uint32_t NumWords = NumBitWords(Size);
 818
 819     auto Src = Bits.take_front(NumWords).drop_back(Count);
 820     auto Dest = Bits.take_front(NumWords).drop_front(Count);
 821
 822     // Since we always move Word-sized chunks of data with src and dest both
 823     // aligned to a word-boundary, we don't need to worry about endianness
 824     // here.
 825     std::memmove(Dest.begin(), Src.begin(), Dest.size() * sizeof(BitWord));
 826     std::memset(Bits.data(), 0, Count * sizeof(BitWord));
 827     clear_unused_bits();
 828   }
 829
 830   /// Perform a logical right shift of \p Count words by moving those
 831   /// words to the left in memory.  See wordShl for more information.
 832   ///
 833   void wordShr(uint32_t Count) {
 834     if (Count == 0)
 835       return;
 836
 837     uint32_t NumWords = NumBitWords(Size);
 838
 839     auto Src = Bits.take_front(NumWords).drop_front(Count);
 840     auto Dest = Bits.take_front(NumWords).drop_back(Count);
 841     assert(Dest.size() == Src.size());
 842
 843     std::memmove(Dest.begin(), Src.begin(), Dest.size() * sizeof(BitWord));
 844     std::memset(Dest.end(), 0, Count * sizeof(BitWord));
 845   }
 846
 847   MutableArrayRef<BitWord> allocate(size_t NumWords) {
 848     BitWord *RawBits = static_cast<BitWord *>(
 849         safe_malloc(NumWords * sizeof(BitWord)));
 850     return MutableArrayRef<BitWord>(RawBits, NumWords);
 851   }
 852
 853   int next_unset_in_word(int WordIndex, BitWord Word) const {
 854     unsigned Result = WordIndex * BITWORD_SIZE + countTrailingOnes(Word);
 855     return Result < size() ? Result : -1;
 856   }
 857
 858   unsigned NumBitWords(unsigned S) const {
 859     return (S + BITWORD_SIZE-1) / BITWORD_SIZE;
 860   }
 861
 862   // Set the unused bits in the high words.
 863   void set_unused_bits(bool t = true) {
 864     //  Set high words first.
 865     unsigned UsedWords = NumBitWords(Size);
 866     if (Bits.size() > UsedWords)
 867       init_words(Bits.drop_front(UsedWords), t);
 868
 869     //  Then set any stray high bits of the last used word.
 870     unsigned ExtraBits = Size % BITWORD_SIZE;
 871     if (ExtraBits) {
 872       BitWord ExtraBitMask = ~0UL << ExtraBits;
 873       if (t)
 874         Bits[UsedWords-1] |= ExtraBitMask;
 875       else
 876         Bits[UsedWords-1] &= ~ExtraBitMask;
 877     }
 878   }
 879
 880   // Clear the unused bits in the high words.
 881   void clear_unused_bits() {
 882     set_unused_bits(false);
 883   }
 884
 885   void grow(unsigned NewSize) {
 886     size_t NewCapacity = std::max<size_t>(NumBitWords(NewSize), Bits.size() * 2);
 887     assert(NewCapacity > 0 && "realloc-ing zero space");
 888     BitWord *NewBits = static_cast<BitWord *>(
 889         safe_realloc(Bits.data(), NewCapacity * sizeof(BitWord)));
 890     Bits = MutableArrayRef<BitWord>(NewBits, NewCapacity);
 891     clear_unused_bits();
 892   }
 893
 894   void init_words(MutableArrayRef<BitWord> B, bool t) {
 895     if (B.size() > 0)
 896       memset(B.data(), 0 - (int)t, B.size() * sizeof(BitWord));
 897   }
 898
 899   template<bool AddBits, bool InvertMask>
 900   void applyMask(const uint32_t *Mask, unsigned MaskWords) {
 901     static_assert(BITWORD_SIZE % 32 == 0, "Unsupported BitWord size.");
 902     MaskWords = std::min(MaskWords, (size() + 31) / 32);
 903     const unsigned Scale = BITWORD_SIZE / 32;
 904     unsigned i;
 905     for (i = 0; MaskWords >= Scale; ++i, MaskWords -= Scale) {
 906       BitWord BW = Bits[i];
 907       // This inner loop should unroll completely when BITWORD_SIZE > 32.
 908       for (unsigned b = 0; b != BITWORD_SIZE; b += 32) {
 909         uint32_t M = *Mask++;
 910         if (InvertMask) M = ~M;
 911         if (AddBits) BW |=   BitWord(M) << b;
 912         else         BW &= ~(BitWord(M) << b);
 913       }
 914       Bits[i] = BW;
 915     }
 916     for (unsigned b = 0; MaskWords; b += 32, --MaskWords) {
 917       uint32_t M = *Mask++;
 918       if (InvertMask) M = ~M;
 919       if (AddBits) Bits[i] |=   BitWord(M) << b;
 920       else         Bits[i] &= ~(BitWord(M) << b);
 921     }
 922     if (AddBits)
 923       clear_unused_bits();
 924   }
 925
 926 public:
 927   /// Return the size (in bytes) of the bit vector.
 928   size_t getMemorySize() const { return Bits.size() * sizeof(BitWord); }
 929   size_t getBitCapacity() const { return Bits.size() * BITWORD_SIZE; }
 930 };
 931
 932 inline size_t capacity_in_bytes(const BitVector &X) {
 933   return X.getMemorySize();
 934 }
 935
 936 } // end namespace llvm
 937
 938 namespace std {
 939   /// Implement std::swap in terms of BitVector swap.
 940   inline void
 941   swap(llvm::BitVector &LHS, llvm::BitVector &RHS) {
 942     LHS.swap(RHS);
 943   }
 944 } // end namespace std
 945
 946 #endif // LLVM_ADT_BITVECTOR_H