ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

constexpr added to BitSet.h. conflicts solved

This commit is contained in:
dhust 2016-06-25 10:58:53 -03:00
parent dba9d86b55
commit b707e199c2
1 changed files with 38 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

80
Source/Core/Common/BitSet.h
View File

@ -14,7 +14,7 @@
#include <intrin.h> #include <intrin.h>
template <typename T> template <typename T>
static inline int CountSetBits(T v) constexpr int CountSetBits(T v)
{ {
// from https://graphics.stanford.edu/~seander/bithacks.html // from https://graphics.stanford.edu/~seander/bithacks.html
// GCC has this built in, but MSVC's intrinsic will only emit the actual // GCC has this built in, but MSVC's intrinsic will only emit the actual
@ -24,60 +24,60 @@ static inline int CountSetBits(T v)
v = (v + (v >> 4)) & (T) ~(T)0 / 255 * 15; v = (v + (v >> 4)) & (T) ~(T)0 / 255 * 15;
return (T)(v * ((T) ~(T)0 / 255)) >> (sizeof(T) - 1) * 8; return (T)(v * ((T) ~(T)0 / 255)) >> (sizeof(T) - 1) * 8;
} }
static inline int LeastSignificantSetBit(u8 val) inline int LeastSignificantSetBit(u8 val)
{ {
unsigned long index; unsigned long index;
_BitScanForward(&index, val); _BitScanForward(&index, val);
return (int)index; return (int)index;
} }
static inline int LeastSignificantSetBit(u16 val) inline int LeastSignificantSetBit(u16 val)
{ {
unsigned long index; unsigned long index;
_BitScanForward(&index, val); _BitScanForward(&index, val);
return (int)index; return (int)index;
} }
static inline int LeastSignificantSetBit(u32 val) inline int LeastSignificantSetBit(u32 val)
{ {
unsigned long index; unsigned long index;
_BitScanForward(&index, val); _BitScanForward(&index, val);
return (int)index; return (int)index;
} }
static inline int LeastSignificantSetBit(u64 val) inline int LeastSignificantSetBit(u64 val)
{ {
unsigned long index; unsigned long index;
_BitScanForward64(&index, val); _BitScanForward64(&index, val);
return (int)index; return (int)index;
} }
#else #else
static inline int CountSetBits(u8 val) constexpr int CountSetBits(u8 val)
{ {
return __builtin_popcount(val); return __builtin_popcount(val);
} }
static inline int CountSetBits(u16 val) constexpr int CountSetBits(u16 val)
{ {
return __builtin_popcount(val); return __builtin_popcount(val);
} }
static inline int CountSetBits(u32 val) constexpr int CountSetBits(u32 val)
{ {
return __builtin_popcount(val); return __builtin_popcount(val);
} }
static inline int CountSetBits(u64 val) constexpr int CountSetBits(u64 val)
{ {
return __builtin_popcountll(val); return __builtin_popcountll(val);
} }
static inline int LeastSignificantSetBit(u8 val) inline int LeastSignificantSetBit(u8 val)
{ {
return __builtin_ctz(val); return __builtin_ctz(val);
} }
static inline int LeastSignificantSetBit(u16 val) inline int LeastSignificantSetBit(u16 val)
{ {
return __builtin_ctz(val); return __builtin_ctz(val);
} }
static inline int LeastSignificantSetBit(u32 val) inline int LeastSignificantSetBit(u32 val)
{ {
return __builtin_ctz(val); return __builtin_ctz(val);
} }
static inline int LeastSignificantSetBit(u64 val) inline int LeastSignificantSetBit(u64 val)
{ {
return __builtin_ctzll(val); return __builtin_ctzll(val);
} }
@ -116,9 +116,9 @@ public:
class Ref class Ref
{ {
public: public:
Ref(Ref&& other) : m_bs(other.m_bs), m_mask(other.m_mask) {} constexpr Ref(Ref&& other) : m_bs(other.m_bs), m_mask(other.m_mask) {}
Ref(BitSet* bs, IntTy mask) : m_bs(bs), m_mask(mask) {} constexpr Ref(BitSet* bs, IntTy mask) : m_bs(bs), m_mask(mask) {}
operator bool() const { return (m_bs->m_val & m_mask) != 0; } constexpr operator bool() const { return (m_bs->m_val & m_mask) != 0; }
bool operator=(bool set) bool operator=(bool set)
{ {
m_bs->m_val = (m_bs->m_val & ~m_mask) | (set ? m_mask : 0); m_bs->m_val = (m_bs->m_val & ~m_mask) | (set ? m_mask : 0);
@ -134,14 +134,13 @@ public:
class Iterator class Iterator
{ {
public: public:
Iterator(const Iterator& other) : m_val(other.m_val), m_bit(other.m_bit) {} constexpr Iterator(const Iterator& other) : m_val(other.m_val), m_bit(other.m_bit) {}
Iterator(IntTy val, int bit) : m_val(val), m_bit(bit) {} constexpr Iterator(IntTy val, int bit) : m_val(val), m_bit(bit) {}
Iterator& operator=(Iterator other) Iterator& operator=(Iterator other)
{ {
new (this) Iterator(other); new (this) Iterator(other);
return *this; return *this;
} }
int operator*() { return m_bit; }
Iterator& operator++() Iterator& operator++()
{ {
if (m_val == 0) if (m_val == 0)
@ -156,21 +155,22 @@ public:
} }
return *this; return *this;
} }
Iterator operator++(int _) Iterator operator++(int)
{ {
Iterator other(*this); Iterator other(*this);
++*this; ++*this;
return other; return other;
} }
bool operator==(Iterator other) const { return m_bit == other.m_bit; } constexpr int operator*() const { return m_bit; }
bool operator!=(Iterator other) const { return m_bit != other.m_bit; } constexpr bool operator==(Iterator other) const { return m_bit == other.m_bit; }
constexpr bool operator!=(Iterator other) const { return m_bit != other.m_bit; }
private: private:
IntTy m_val; IntTy m_val;
int m_bit; int m_bit;
}; };
BitSet() : m_val(0) {} constexpr BitSet() : m_val(0) {}
explicit BitSet(IntTy val) : m_val(val) {} constexpr explicit BitSet(IntTy val) : m_val(val) {}
BitSet(std::initializer_list<int> init) BitSet(std::initializer_list<int> init)
{ {
m_val = 0; m_val = 0;
@ -178,36 +178,32 @@ public:
m_val |= (IntTy)1 << bit; m_val |= (IntTy)1 << bit;
} }
static BitSet AllTrue(size_t count) constexpr static BitSet AllTrue(size_t count)
{ {
return BitSet(count == sizeof(IntTy) * 8 ? ~(IntTy)0 : (((IntTy)1 << count) - 1)); return BitSet(count == sizeof(IntTy) * 8 ? ~(IntTy)0 : (((IntTy)1 << count) - 1));
} }
Ref operator[](size_t bit) { return Ref(this, (IntTy)1 << bit); } Ref operator[](size_t bit) { return Ref(this, (IntTy)1 << bit); }
const Ref operator[](size_t bit) const { return (*const_cast<BitSet*>(this))[bit]; } constexpr const Ref operator[](size_t bit) const { return (*const_cast<BitSet*>(this))[bit]; }
bool operator==(BitSet other) const { return m_val == other.m_val; } constexpr bool operator==(BitSet other) const { return m_val == other.m_val; }
bool operator!=(BitSet other) const { return m_val != other.m_val; } constexpr bool operator!=(BitSet other) const { return m_val != other.m_val; }
bool operator<(BitSet other) const { return m_val < other.m_val; } constexpr bool operator<(BitSet other) const { return m_val < other.m_val; }
bool operator>(BitSet other) const { return m_val > other.m_val; } constexpr bool operator>(BitSet other) const { return m_val > other.m_val; }
BitSet operator|(BitSet other) const { return BitSet(m_val | other.m_val); } constexpr BitSet operator|(BitSet other) const { return BitSet(m_val | other.m_val); }
BitSet operator&(BitSet other) const { return BitSet(m_val & other.m_val); } constexpr BitSet operator&(BitSet other) const { return BitSet(m_val & other.m_val); }
BitSet operator^(BitSet other) const { return BitSet(m_val ^ other.m_val); } constexpr BitSet operator^(BitSet other) const { return BitSet(m_val ^ other.m_val); }
BitSet operator~() const { return BitSet(~m_val); } constexpr BitSet operator~() const { return BitSet(~m_val); }
constexpr explicit operator bool() const { return m_val != 0; }
BitSet& operator|=(BitSet other) { return *this = *this | other; } BitSet& operator|=(BitSet other) { return *this = *this | other; }
BitSet& operator&=(BitSet other) { return *this = *this & other; } BitSet& operator&=(BitSet other) { return *this = *this & other; }
BitSet& operator^=(BitSet other) { return *this = *this ^ other; } BitSet& operator^=(BitSet other) { return *this = *this ^ other; }
explicit operator bool() const { return m_val != 0; }
// Warning: Even though on modern CPUs this is a single fast instruction, // Warning: Even though on modern CPUs this is a single fast instruction,
// Dolphin's official builds do not currently assume POPCNT support on x86, // Dolphin's official builds do not currently assume POPCNT support on x86,
// so slower explicit bit twiddling is generated. Still should generally // so slower explicit bit twiddling is generated. Still should generally
// be faster than a loop. // be faster than a loop.
unsigned int Count() const { return CountSetBits(m_val); } constexpr unsigned int Count() const { return CountSetBits(m_val); }
Iterator begin() const constexpr Iterator begin() const { return ++Iterator(m_val, 0); }
{ constexpr Iterator end() const { return Iterator(m_val, -1); }
Iterator it(m_val, 0);
return ++it;
}
Iterator end() const { return Iterator(m_val, -1); }
IntTy m_val; IntTy m_val;
}; };
} }