projects
/
oota-llvm.git
/ blobdiff
commit
grep
author
committer
pickaxe
?
search:
re
summary
|
shortlog
|
log
|
commit
|
commitdiff
|
tree
raw
|
inline
| side by side
[llvm-dwp] Add coverage for both the presence and absence of type units, and fix...
[oota-llvm.git]
/
include
/
llvm
/
ADT
/
BitVector.h
diff --git
a/include/llvm/ADT/BitVector.h
b/include/llvm/ADT/BitVector.h
index 3789db4e45d3a6c9e9efa05ff2438a9f8dfd8e3c..ad00d51f99e9f472c20f5027d63140a9b5267b71 100644
(file)
--- a/
include/llvm/ADT/BitVector.h
+++ b/
include/llvm/ADT/BitVector.h
@@
-29,11
+29,15
@@
class BitVector {
enum { BITWORD_SIZE = (unsigned)sizeof(BitWord) * CHAR_BIT };
enum { BITWORD_SIZE = (unsigned)sizeof(BitWord) * CHAR_BIT };
+ static_assert(BITWORD_SIZE == 64 || BITWORD_SIZE == 32,
+ "Unsupported word size");
+
BitWord *Bits; // Actual bits.
unsigned Size; // Size of bitvector in bits.
BitWord *Bits; // Actual bits.
unsigned Size; // Size of bitvector in bits.
- unsigned Capacity; //
Size of allocated memory in BitWord
.
+ unsigned Capacity; //
Number of BitWords allocated in the Bits array
.
public:
public:
+ typedef unsigned size_type;
// Encapsulation of a single bit.
class reference {
friend class BitVector;
// Encapsulation of a single bit.
class reference {
friend class BitVector;
@@
-49,7
+53,7
@@
public:
BitPos = Idx % BITWORD_SIZE;
}
BitPos = Idx % BITWORD_SIZE;
}
- ~reference() {}
+ reference(const reference&) = default;
reference &operator=(reference t) {
*this = bool(t);
reference &operator=(reference t) {
*this = bool(t);
@@
-58,21
+62,21
@@
public:
reference& operator=(bool t) {
if (t)
reference& operator=(bool t) {
if (t)
- *WordRef |=
1L
<< BitPos;
+ *WordRef |=
BitWord(1)
<< BitPos;
else
else
- *WordRef &= ~(
1L
<< BitPos);
+ *WordRef &= ~(
BitWord(1)
<< BitPos);
return *this;
}
operator bool() const {
return *this;
}
operator bool() const {
- return ((*WordRef) & (
1L
<< BitPos)) ? true : false;
+ return ((*WordRef) & (
BitWord(1)
<< BitPos)) ? true : false;
}
};
/// BitVector default ctor - Creates an empty bitvector.
BitVector() : Size(0), Capacity(0) {
}
};
/// BitVector default ctor - Creates an empty bitvector.
BitVector() : Size(0), Capacity(0) {
- Bits =
0
;
+ Bits =
nullptr
;
}
/// BitVector ctor - Creates a bitvector of specified number of bits. All
}
/// BitVector ctor - Creates a bitvector of specified number of bits. All
@@
-88,7
+92,7
@@
public:
/// BitVector copy ctor.
BitVector(const BitVector &RHS) : Size(RHS.size()) {
if (Size == 0) {
/// BitVector copy ctor.
BitVector(const BitVector &RHS) : Size(RHS.size()) {
if (Size == 0) {
- Bits =
0
;
+ Bits =
nullptr
;
Capacity = 0;
return;
}
Capacity = 0;
return;
}
@@
-98,12
+102,10
@@
public:
std::memcpy(Bits, RHS.Bits, Capacity * sizeof(BitWord));
}
std::memcpy(Bits, RHS.Bits, Capacity * sizeof(BitWord));
}
-#if LLVM_HAS_RVALUE_REFERENCES
BitVector(BitVector &&RHS)
: Bits(RHS.Bits), Size(RHS.Size), Capacity(RHS.Capacity) {
BitVector(BitVector &&RHS)
: Bits(RHS.Bits), Size(RHS.Size), Capacity(RHS.Capacity) {
- RHS.Bits =
0
;
+ RHS.Bits =
nullptr
;
}
}
-#endif
~BitVector() {
std::free(Bits);
~BitVector() {
std::free(Bits);
@@
-113,18
+115,13
@@
public:
bool empty() const { return Size == 0; }
/// size - Returns the number of bits in this bitvector.
bool empty() const { return Size == 0; }
/// size - Returns the number of bits in this bitvector.
-
unsigned
size() const { return Size; }
+
size_type
size() const { return Size; }
/// count - Returns the number of bits which are set.
/// count - Returns the number of bits which are set.
-
unsigned
count() const {
+
size_type
count() const {
unsigned NumBits = 0;
for (unsigned i = 0; i < NumBitWords(size()); ++i)
unsigned NumBits = 0;
for (unsigned i = 0; i < NumBitWords(size()); ++i)
- if (sizeof(BitWord) == 4)
- NumBits += CountPopulation_32((uint32_t)Bits[i]);
- else if (sizeof(BitWord) == 8)
- NumBits += CountPopulation_64(Bits[i]);
- else
- llvm_unreachable("Unsupported!");
+ NumBits += countPopulation(Bits[i]);
return NumBits;
}
return NumBits;
}
@@
-138,8
+135,15
@@
public:
/// all - Returns true if all bits are set.
bool all() const {
/// all - Returns true if all bits are set.
bool all() const {
- // TODO: Optimize this.
- return count() == size();
+ for (unsigned i = 0; i < Size / BITWORD_SIZE; ++i)
+ if (Bits[i] != ~0UL)
+ return false;
+
+ // If bits remain check that they are ones. The unused bits are always zero.
+ if (unsigned Remainder = Size % BITWORD_SIZE)
+ return Bits[Size / BITWORD_SIZE] == (1UL << Remainder) - 1;
+
+ return true;
}
/// none - Returns true if none of the bits are set.
}
/// none - Returns true if none of the bits are set.
@@
-151,13
+155,8
@@
public:
/// of the bits are set.
int find_first() const {
for (unsigned i = 0; i < NumBitWords(size()); ++i)
/// of the bits are set.
int find_first() const {
for (unsigned i = 0; i < NumBitWords(size()); ++i)
- if (Bits[i] != 0) {
- if (sizeof(BitWord) == 4)
- return i * BITWORD_SIZE + countTrailingZeros((uint32_t)Bits[i]);
- if (sizeof(BitWord) == 8)
- return i * BITWORD_SIZE + countTrailingZeros(Bits[i]);
- llvm_unreachable("Unsupported!");
- }
+ if (Bits[i] != 0)
+ return i * BITWORD_SIZE + countTrailingZeros(Bits[i]);
return -1;
}
return -1;
}
@@
-174,23
+173,13
@@
public:
// Mask off previous bits.
Copy &= ~0UL << BitPos;
// Mask off previous bits.
Copy &= ~0UL << BitPos;
- if (Copy != 0) {
- if (sizeof(BitWord) == 4)
- return WordPos * BITWORD_SIZE + countTrailingZeros((uint32_t)Copy);
- if (sizeof(BitWord) == 8)
- return WordPos * BITWORD_SIZE + countTrailingZeros(Copy);
- llvm_unreachable("Unsupported!");
- }
+ if (Copy != 0)
+ return WordPos * BITWORD_SIZE + countTrailingZeros(Copy);
// Check subsequent words.
for (unsigned i = WordPos+1; i < NumBitWords(size()); ++i)
// Check subsequent words.
for (unsigned i = WordPos+1; i < NumBitWords(size()); ++i)
- if (Bits[i] != 0) {
- if (sizeof(BitWord) == 4)
- return i * BITWORD_SIZE + countTrailingZeros((uint32_t)Bits[i]);
- if (sizeof(BitWord) == 8)
- return i * BITWORD_SIZE + countTrailingZeros(Bits[i]);
- llvm_unreachable("Unsupported!");
- }
+ if (Bits[i] != 0)
+ return i * BITWORD_SIZE + countTrailingZeros(Bits[i]);
return -1;
}
return -1;
}
@@
-233,7
+222,8
@@
public:
}
BitVector &set(unsigned Idx) {
}
BitVector &set(unsigned Idx) {
- Bits[Idx / BITWORD_SIZE] |= 1L << (Idx % BITWORD_SIZE);
+ assert(Bits && "Bits never allocated");
+ Bits[Idx / BITWORD_SIZE] |= BitWord(1) << (Idx % BITWORD_SIZE);
return *this;
}
return *this;
}
@@
-260,7
+250,8
@@
public:
Bits[I / BITWORD_SIZE] = ~0UL;
BitWord PostfixMask = (1UL << (E % BITWORD_SIZE)) - 1;
Bits[I / BITWORD_SIZE] = ~0UL;
BitWord PostfixMask = (1UL << (E % BITWORD_SIZE)) - 1;
- Bits[I / BITWORD_SIZE] |= PostfixMask;
+ if (I < E)
+ Bits[I / BITWORD_SIZE] |= PostfixMask;
return *this;
}
return *this;
}
@@
-271,7
+262,7
@@
public:
}
BitVector &reset(unsigned Idx) {
}
BitVector &reset(unsigned Idx) {
- Bits[Idx / BITWORD_SIZE] &= ~(
1L
<< (Idx % BITWORD_SIZE));
+ Bits[Idx / BITWORD_SIZE] &= ~(
BitWord(1)
<< (Idx % BITWORD_SIZE));
return *this;
}
return *this;
}
@@
-298,7
+289,8
@@
public:
Bits[I / BITWORD_SIZE] = 0UL;
BitWord PostfixMask = (1UL << (E % BITWORD_SIZE)) - 1;
Bits[I / BITWORD_SIZE] = 0UL;
BitWord PostfixMask = (1UL << (E % BITWORD_SIZE)) - 1;
- Bits[I / BITWORD_SIZE] &= ~PostfixMask;
+ if (I < E)
+ Bits[I / BITWORD_SIZE] &= ~PostfixMask;
return *this;
}
return *this;
}
@@
-311,7
+303,7
@@
public:
}
BitVector &flip(unsigned Idx) {
}
BitVector &flip(unsigned Idx) {
- Bits[Idx / BITWORD_SIZE] ^=
1L
<< (Idx % BITWORD_SIZE);
+ Bits[Idx / BITWORD_SIZE] ^=
BitWord(1)
<< (Idx % BITWORD_SIZE);
return *this;
}
return *this;
}
@@
-323,7
+315,7
@@
public:
bool operator[](unsigned Idx) const {
assert (Idx < Size && "Out-of-bounds Bit access.");
bool operator[](unsigned Idx) const {
assert (Idx < Size && "Out-of-bounds Bit access.");
- BitWord Mask =
1L
<< (Idx % BITWORD_SIZE);
+ BitWord Mask =
BitWord(1)
<< (Idx % BITWORD_SIZE);
return (Bits[Idx / BITWORD_SIZE] & Mask) != 0;
}
return (Bits[Idx / BITWORD_SIZE] & Mask) != 0;
}
@@
-442,6
+434,7
@@
public:
// Grow the bitvector to have enough elements.
Capacity = RHSWords;
// Grow the bitvector to have enough elements.
Capacity = RHSWords;
+ assert(Capacity > 0 && "negative capacity?");
BitWord *NewBits = (BitWord *)std::malloc(Capacity * sizeof(BitWord));
std::memcpy(NewBits, RHS.Bits, Capacity * sizeof(BitWord));
BitWord *NewBits = (BitWord *)std::malloc(Capacity * sizeof(BitWord));
std::memcpy(NewBits, RHS.Bits, Capacity * sizeof(BitWord));
@@
-452,7
+445,6
@@
public:
return *this;
}
return *this;
}
-#if LLVM_HAS_RVALUE_REFERENCES
const BitVector &operator=(BitVector &&RHS) {
if (this == &RHS) return *this;
const BitVector &operator=(BitVector &&RHS) {
if (this == &RHS) return *this;
@@
-461,11
+453,10
@@
public:
Size = RHS.Size;
Capacity = RHS.Capacity;
Size = RHS.Size;
Capacity = RHS.Capacity;
- RHS.Bits =
0
;
+ RHS.Bits =
nullptr
;
return *this;
}
return *this;
}
-#endif
void swap(BitVector &RHS) {
std::swap(Bits, RHS.Bits);
void swap(BitVector &RHS) {
std::swap(Bits, RHS.Bits);
@@
-539,6
+530,7
@@
private:
void grow(unsigned NewSize) {
Capacity = std::max(NumBitWords(NewSize), Capacity * 2);
void grow(unsigned NewSize) {
Capacity = std::max(NumBitWords(NewSize), Capacity * 2);
+ assert(Capacity > 0 && "realloc-ing zero space");
Bits = (BitWord *)std::realloc(Bits, Capacity * sizeof(BitWord));
clear_unused_bits();
Bits = (BitWord *)std::realloc(Bits, Capacity * sizeof(BitWord));
clear_unused_bits();
@@
-550,7
+542,7
@@
private:
template<bool AddBits, bool InvertMask>
void applyMask(const uint32_t *Mask, unsigned MaskWords) {
template<bool AddBits, bool InvertMask>
void applyMask(const uint32_t *Mask, unsigned MaskWords) {
-
assert(BITWORD_SIZE % 32 == 0 &&
"Unsupported BitWord size.");
+
static_assert(BITWORD_SIZE % 32 == 0,
"Unsupported BitWord size.");
MaskWords = std::min(MaskWords, (size() + 31) / 32);
const unsigned Scale = BITWORD_SIZE / 32;
unsigned i;
MaskWords = std::min(MaskWords, (size() + 31) / 32);
const unsigned Scale = BITWORD_SIZE / 32;
unsigned i;
@@
-574,8
+566,16
@@
private:
if (AddBits)
clear_unused_bits();
}
if (AddBits)
clear_unused_bits();
}
+
+public:
+ /// Return the size (in bytes) of the bit vector.
+ size_t getMemorySize() const { return Capacity * sizeof(BitWord); }
};
};
+static inline size_t capacity_in_bytes(const BitVector &X) {
+ return X.getMemorySize();
+}
+
} // End llvm namespace
namespace std {
} // End llvm namespace
namespace std {