15 #ifndef LLVM_ADT_SPARSEBITVECTOR_H
16 #define LLVM_ADT_SPARSEBITVECTOR_H
54 unsigned ElementIndex;
70 if (ElementIndex != RHS.ElementIndex)
73 if (Bits[
i] != RHS.Bits[
i])
79 return !(*
this == RHS);
99 void set(
unsigned Idx) {
104 bool old =
test(Idx);
116 bool test(
unsigned Idx)
const {
121 unsigned NumBits = 0;
145 &&
"Word Position outside of element");
148 Copy &= ~0UL << BitPos;
162 bool changed =
false;
164 BitWord old = changed ? 0 : Bits[
i];
166 Bits[
i] |= RHS.Bits[
i];
167 if (!changed && old != Bits[
i])
176 if (RHS.Bits[
i] & Bits[
i])
186 bool changed =
false;
191 BitWord old = changed ? 0 : Bits[
i];
193 Bits[
i] &= RHS.Bits[
i];
197 if (!changed && old != Bits[
i])
200 BecameZero = allzero;
209 bool changed =
false;
214 BitWord old = changed ? 0 : Bits[
i];
216 Bits[
i] &= ~RHS.Bits[
i];
220 if (!changed && old != Bits[
i])
223 BecameZero = allzero;
236 Bits[
i] = RHS1.Bits[
i] & ~RHS2.Bits[
i];
240 BecameZero = allzero;
244 template <
unsigned ElementSize = 128>
246 typedef std::list<SparseBitVectorElement<ElementSize>> ElementList;
247 typedef typename ElementList::iterator ElementListIter;
248 typedef typename ElementList::const_iterator ElementListConstIter;
254 ElementListIter CurrElementIter;
255 ElementList Elements;
259 ElementListIter FindLowerBound(
unsigned ElementIndex) {
261 if (Elements.empty()) {
262 CurrElementIter = Elements.begin();
263 return Elements.begin();
267 if (CurrElementIter == Elements.end())
272 ElementListIter ElementIter = CurrElementIter;
273 if (CurrElementIter->index() == ElementIndex) {
275 }
else if (CurrElementIter->index() > ElementIndex) {
276 while (ElementIter != Elements.begin()
277 && ElementIter->index() > ElementIndex)
280 while (ElementIter != Elements.end() &&
281 ElementIter->index() < ElementIndex)
284 CurrElementIter = ElementIter;
290 class SparseBitVectorIterator {
297 ElementListConstIter Iter;
309 void AdvanceToFirstNonZero() {
317 BitNumber = Iter->index() * ElementSize;
320 WordNumber = (BitNumber % ElementSize) / BITWORD_SIZE;
321 Bits = Iter->word(WordNumber);
322 Bits >>= BitPos % BITWORD_SIZE;
326 void AdvanceToNextNonZero() {
337 int NextSetBitNumber = Iter->find_next(BitNumber % ElementSize) ;
339 if (NextSetBitNumber == -1 || (BitNumber % ElementSize == 0)) {
349 BitNumber = Iter->index() * ElementSize;
350 NextSetBitNumber = Iter->find_first();
351 BitNumber += NextSetBitNumber;
352 WordNumber = (BitNumber % ElementSize) / BITWORD_SIZE;
353 Bits = Iter->word(WordNumber);
354 Bits >>= NextSetBitNumber % BITWORD_SIZE;
356 WordNumber = (NextSetBitNumber % ElementSize) / BITWORD_SIZE;
357 Bits = Iter->word(WordNumber);
358 Bits >>= NextSetBitNumber % BITWORD_SIZE;
359 BitNumber = Iter->index() * ElementSize;
360 BitNumber += NextSetBitNumber;
366 SparseBitVectorIterator() =
default;
375 AdvanceToFirstNonZero();
379 inline SparseBitVectorIterator& operator++() {
382 AdvanceToNextNonZero();
387 inline SparseBitVectorIterator operator++(
int) {
388 SparseBitVectorIterator tmp = *
this;
398 bool operator==(
const SparseBitVectorIterator &RHS)
const {
400 if (AtEnd && RHS.AtEnd)
404 return AtEnd == RHS.AtEnd && RHS.BitNumber == BitNumber;
407 bool operator!=(
const SparseBitVectorIterator &RHS)
const {
408 return !(*
this == RHS);
416 CurrElementIter = Elements.begin();
423 ElementListConstIter ElementIter = RHS.Elements.begin();
424 while (ElementIter != RHS.Elements.end()) {
429 CurrElementIter = Elements.begin ();
444 ElementListConstIter ElementIter = RHS.Elements.begin();
445 while (ElementIter != RHS.Elements.end()) {
450 CurrElementIter = Elements.begin ();
457 if (Elements.empty())
460 unsigned ElementIndex = Idx / ElementSize;
461 ElementListIter ElementIter = FindLowerBound(ElementIndex);
465 if (ElementIter == Elements.end() ||
466 ElementIter->index() != ElementIndex)
468 return ElementIter->test(Idx % ElementSize);
472 if (Elements.empty())
475 unsigned ElementIndex = Idx / ElementSize;
476 ElementListIter ElementIter = FindLowerBound(ElementIndex);
480 if (ElementIter == Elements.end() ||
481 ElementIter->index() != ElementIndex)
483 ElementIter->reset(Idx % ElementSize);
486 if (ElementIter->empty()) {
488 Elements.erase(ElementIter);
493 unsigned ElementIndex = Idx / ElementSize;
494 ElementListIter ElementIter;
495 if (Elements.empty()) {
496 ElementIter = Elements.emplace(Elements.end(), ElementIndex);
498 ElementIter = FindLowerBound(ElementIndex);
500 if (ElementIter == Elements.end() ||
501 ElementIter->index() != ElementIndex) {
505 if (ElementIter != Elements.end() &&
506 ElementIter->index() < ElementIndex)
508 ElementIter = Elements.emplace(ElementIter, ElementIndex);
511 CurrElementIter = ElementIter;
513 ElementIter->set(Idx % ElementSize);
517 bool old =
test(Idx);
526 return !(*
this == RHS);
530 ElementListConstIter Iter1 = Elements.begin();
531 ElementListConstIter Iter2 = RHS.Elements.begin();
533 for (; Iter1 != Elements.end() && Iter2 != RHS.Elements.end();
535 if (*Iter1 != *Iter2)
538 return Iter1 == Elements.end() && Iter2 == RHS.Elements.end();
546 bool changed =
false;
547 ElementListIter Iter1 = Elements.begin();
548 ElementListConstIter Iter2 = RHS.Elements.begin();
551 if (RHS.Elements.empty())
554 while (Iter2 != RHS.Elements.end()) {
555 if (Iter1 == Elements.end() || Iter1->index() > Iter2->index()) {
556 Elements.insert(Iter1, *Iter2);
559 }
else if (Iter1->index() == Iter2->index()) {
560 changed |= Iter1->unionWith(*Iter2);
567 CurrElementIter = Elements.begin();
576 bool changed =
false;
577 ElementListIter Iter1 = Elements.begin();
578 ElementListConstIter Iter2 = RHS.Elements.begin();
581 if (Elements.empty() && RHS.Elements.empty())
585 while (Iter2 != RHS.Elements.end()) {
586 if (Iter1 == Elements.end()) {
587 CurrElementIter = Elements.begin();
591 if (Iter1->index() > Iter2->index()) {
593 }
else if (Iter1->index() == Iter2->index()) {
595 changed |= Iter1->intersectWith(*Iter2, BecameZero);
597 ElementListIter IterTmp = Iter1;
599 Elements.erase(IterTmp);
605 ElementListIter IterTmp = Iter1;
607 Elements.erase(IterTmp);
611 if (Iter1 != Elements.end()) {
612 Elements.erase(Iter1, Elements.end());
615 CurrElementIter = Elements.begin();
630 bool changed =
false;
631 ElementListIter Iter1 = Elements.begin();
632 ElementListConstIter Iter2 = RHS.Elements.begin();
635 if (Elements.empty() || RHS.Elements.empty())
639 while (Iter2 != RHS.Elements.end()) {
640 if (Iter1 == Elements.end()) {
641 CurrElementIter = Elements.begin();
645 if (Iter1->index() > Iter2->index()) {
647 }
else if (Iter1->index() == Iter2->index()) {
649 changed |= Iter1->intersectWithComplement(*Iter2, BecameZero);
651 ElementListIter IterTmp = Iter1;
653 Elements.erase(IterTmp);
662 CurrElementIter = Elements.begin();
678 }
else if (
this == &RHS2) {
685 CurrElementIter = Elements.begin();
686 ElementListConstIter Iter1 = RHS1.Elements.begin();
687 ElementListConstIter Iter2 = RHS2.Elements.begin();
691 if (RHS1.Elements.empty())
695 while (Iter2 != RHS2.Elements.end()) {
696 if (Iter1 == RHS1.Elements.end())
699 if (Iter1->index() > Iter2->index()) {
701 }
else if (Iter1->index() == Iter2->index()) {
702 bool BecameZero =
false;
703 Elements.emplace_back(Iter1->index());
704 Elements.back().intersectWithComplement(*Iter1, *Iter2, BecameZero);
710 Elements.push_back(*Iter1++);
715 std::copy(Iter1, RHS1.Elements.end(), std::back_inserter(Elements));
729 ElementListConstIter Iter1 = Elements.begin();
730 ElementListConstIter Iter2 = RHS.Elements.begin();
733 if (Elements.empty() && RHS.Elements.empty())
737 while (Iter2 != RHS.Elements.end()) {
738 if (Iter1 == Elements.end())
741 if (Iter1->index() > Iter2->index()) {
743 }
else if (Iter1->index() == Iter2->index()) {
744 if (Iter1->intersects(*Iter2))
760 return (Result == RHS);
765 if (Elements.empty())
773 return Elements.empty();
777 unsigned BitCount = 0;
778 for (ElementListConstIter Iter = Elements.begin();
779 Iter != Elements.end();
781 BitCount += Iter->count();
798 template <
unsigned ElementSize>
804 template <
unsigned ElementSize>
807 return LHS->operator|=(RHS);
810 template <
unsigned ElementSize>
813 return LHS->operator&=(RHS);
816 template <
unsigned ElementSize>
824 template <
unsigned ElementSize>
825 inline SparseBitVector<ElementSize>
833 template <
unsigned ElementSize>
834 inline SparseBitVector<ElementSize>
842 template <
unsigned ElementSize>
843 inline SparseBitVector<ElementSize>
852 template <
unsigned ElementSize>
860 for (++bi; bi != be; ++bi) {
869 #endif // LLVM_ADT_SPARSEBITVECTOR_H
int find_first() const
find_first - Returns the index of the first set bit, -1 if none of the bits are set.
SparseBitVector & operator=(const SparseBitVector &RHS)
void intersectWithComplement(const SparseBitVector< ElementSize > &RHS1, const SparseBitVector< ElementSize > &RHS2)
SmallBitVector operator&(const SmallBitVector &LHS, const SmallBitVector &RHS)
bool intersects(const SparseBitVector< ElementSize > &RHS) const
bool intersectWithComplement(const SparseBitVector< ElementSize > *RHS) const
bool test(unsigned Idx) const
bool operator!=(const SparseBitVector &RHS) const
SparseBitVectorElement(unsigned Idx)
bool unionWith(const SparseBitVectorElement &RHS)
bool operator|=(const SparseBitVector &RHS)
bool operator!=(const SparseBitVectorElement &RHS) const
bool intersectWithComplement(const SparseBitVectorElement &RHS, bool &BecameZero)
int find_first() const
find_first - Returns the index of the first set bit.
void intersectWithComplement(const SparseBitVector< ElementSize > *RHS1, const SparseBitVector< ElementSize > *RHS2)
SmallBitVector operator|(const SmallBitVector &LHS, const SmallBitVector &RHS)
~SparseBitVector()=default
bool operator|=(SparseBitVector< ElementSize > &LHS, const SparseBitVector< ElementSize > *RHS)
void dump(const SparseBitVector< ElementSize > &LHS, raw_ostream &out)
std::size_t countTrailingZeros(T Val, ZeroBehavior ZB=ZB_Width)
Count number of 0's from the least significant bit to the most stopping at the first 1...
bool test_and_set(unsigned Idx)
bool operator&=(const SparseBitVector &RHS)
bool empty() const
empty - Tests whether there are no bits in this bitvector.
bool operator==(const SparseBitVector &RHS) const
BlockMass operator*(BlockMass L, BranchProbability R)
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
bool operator==(const SparseBitVectorElement &RHS) const
bool intersectWith(const SparseBitVectorElement &RHS, bool &BecameZero)
unsigned countPopulation(T Value)
Count the number of set bits in a value.
void intersectWithComplement(const SparseBitVectorElement &RHS1, const SparseBitVectorElement &RHS2, bool &BecameZero)
BitWord word(unsigned Idx) const
SparseBitVector is an implementation of a bitvector that is sparse by only storing the elements that ...
bool intersectWithComplement(const SparseBitVector &RHS)
bool test_and_set(unsigned Idx)
bool intersects(const SparseBitVector< ElementSize > *RHS) const
int find_next(unsigned Curr) const
find_next - Returns the index of the next set bit starting from the "Curr" bit.
SparseBitVector(const SparseBitVector &RHS)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
SparseBitVectorIterator iterator
This class implements an extremely fast bulk output stream that can only output to a stream...
bool operator&=(SparseBitVector< ElementSize > *LHS, const SparseBitVector< ElementSize > &RHS)
bool intersects(const SparseBitVectorElement &RHS) const
bool contains(const SparseBitVector< ElementSize > &RHS) const