mirror of
https://github.com/RPCS3/rpcs3.git
synced 2024-11-22 18:53:28 +01:00
290 lines
7.0 KiB
C++
290 lines
7.0 KiB
C++
#pragma once
|
|
|
|
#include "util/types.hpp"
|
|
#include "Utilities/StrFmt.h"
|
|
|
|
#ifndef _MSC_VER
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Weffc++"
|
|
#endif
|
|
|
|
template <typename T, uint N>
|
|
struct bf_base
|
|
{
|
|
using type = T;
|
|
using vtype = std::common_type_t<type>;
|
|
using utype = std::make_unsigned_t<vtype>;
|
|
|
|
static constexpr bool can_be_packed = N < (sizeof(int) * 8 + (std::is_unsigned_v<vtype> ? 1 : 0)) && sizeof(vtype) > sizeof(int);
|
|
using compact_type = std::conditional_t<can_be_packed, std::conditional_t<std::is_unsigned_v<vtype>, uint, int>, vtype>;
|
|
|
|
// Datatype bitsize
|
|
static constexpr uint bitmax = sizeof(T) * 8; static_assert(N - 1 < bitmax, "bf_base<> error: N out of bounds");
|
|
|
|
// Field bitsize
|
|
static constexpr uint bitsize = N;
|
|
|
|
// All ones mask
|
|
static constexpr utype mask1 = static_cast<utype>(~static_cast<utype>(0));
|
|
|
|
// Value mask
|
|
static constexpr utype vmask = mask1 >> (bitmax - bitsize);
|
|
|
|
protected:
|
|
type m_data;
|
|
};
|
|
|
|
// Bitfield accessor (N bits from I position, 0 is LSB)
|
|
template <typename T, uint I, uint N>
|
|
struct bf_t : bf_base<T, N>
|
|
{
|
|
using type = typename bf_t::type;
|
|
using vtype = typename bf_t::vtype;
|
|
using utype = typename bf_t::utype;
|
|
using compact_type = typename bf_t::compact_type;
|
|
|
|
// Field offset
|
|
static constexpr uint bitpos = I; static_assert(bitpos + N <= bf_t::bitmax, "bf_t<> error: I out of bounds");
|
|
|
|
// Get bitmask of size N, at I pos
|
|
static constexpr utype data_mask()
|
|
{
|
|
return static_cast<utype>(static_cast<utype>(bf_t::mask1 >> (bf_t::bitmax - bf_t::bitsize)) << bitpos);
|
|
}
|
|
|
|
// Bitfield extraction
|
|
static constexpr compact_type extract(const T& data) noexcept
|
|
{
|
|
if constexpr (std::is_signed_v<T>)
|
|
{
|
|
// Load signed value (sign-extended)
|
|
return static_cast<compact_type>(static_cast<vtype>(static_cast<utype>(data) << (bf_t::bitmax - bitpos - N)) >> (bf_t::bitmax - N));
|
|
}
|
|
else
|
|
{
|
|
// Load unsigned value
|
|
return static_cast<compact_type>((static_cast<utype>(data) >> bitpos) & bf_t::vmask);
|
|
}
|
|
}
|
|
|
|
// Bitfield insertion
|
|
static constexpr vtype insert(compact_type value)
|
|
{
|
|
return static_cast<vtype>((value & bf_t::vmask) << bitpos);
|
|
}
|
|
|
|
// Load bitfield value
|
|
constexpr operator compact_type() const noexcept
|
|
{
|
|
return extract(this->m_data);
|
|
}
|
|
|
|
// Load raw data with mask applied
|
|
constexpr T unshifted() const
|
|
{
|
|
return static_cast<T>(this->m_data & data_mask());
|
|
}
|
|
|
|
// Optimized bool conversion (must be removed if inappropriate)
|
|
explicit constexpr operator bool() const noexcept
|
|
{
|
|
return unshifted() != 0u;
|
|
}
|
|
|
|
// Store bitfield value
|
|
bf_t& operator =(compact_type value) noexcept
|
|
{
|
|
this->m_data = static_cast<vtype>((this->m_data & ~data_mask()) | insert(value));
|
|
return *this;
|
|
}
|
|
|
|
compact_type operator ++(int)
|
|
{
|
|
compact_type result = *this;
|
|
*this = static_cast<compact_type>(result + 1u);
|
|
return result;
|
|
}
|
|
|
|
bf_t& operator ++()
|
|
{
|
|
return *this = static_cast<compact_type>(*this + 1u);
|
|
}
|
|
|
|
compact_type operator --(int)
|
|
{
|
|
compact_type result = *this;
|
|
*this = static_cast<compact_type>(result - 1u);
|
|
return result;
|
|
}
|
|
|
|
bf_t& operator --()
|
|
{
|
|
return *this = static_cast<compact_type>(*this - 1u);
|
|
}
|
|
|
|
bf_t& operator +=(compact_type right)
|
|
{
|
|
return *this = static_cast<compact_type>(*this + right);
|
|
}
|
|
|
|
bf_t& operator -=(compact_type right)
|
|
{
|
|
return *this = static_cast<compact_type>(*this - right);
|
|
}
|
|
|
|
bf_t& operator *=(compact_type right)
|
|
{
|
|
return *this = static_cast<compact_type>(*this * right);
|
|
}
|
|
|
|
bf_t& operator &=(compact_type right)
|
|
{
|
|
this->m_data &= static_cast<vtype>(((static_cast<utype>(right + 0u) & bf_t::vmask) << bitpos) | ~(bf_t::vmask << bitpos));
|
|
return *this;
|
|
}
|
|
|
|
bf_t& operator |=(compact_type right)
|
|
{
|
|
this->m_data |= static_cast<vtype>((static_cast<utype>(right + 0u) & bf_t::vmask) << bitpos);
|
|
return *this;
|
|
}
|
|
|
|
bf_t& operator ^=(compact_type right)
|
|
{
|
|
this->m_data ^= static_cast<vtype>((static_cast<utype>(right + 0u) & bf_t::vmask) << bitpos);
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
template <typename T, uint I, uint N>
|
|
struct std::common_type<bf_t<T, I, N>, bf_t<T, I, N>> : std::common_type<T> {};
|
|
|
|
template <typename T, uint I, uint N, typename T2>
|
|
struct std::common_type<bf_t<T, I, N>, T2> : std::common_type<T2, std::common_type_t<T>> {};
|
|
|
|
template <typename T, uint I, uint N, typename T2>
|
|
struct std::common_type<T2, bf_t<T, I, N>> : std::common_type<std::common_type_t<T>, T2> {};
|
|
|
|
// Field pack (concatenated from left to right)
|
|
template <typename F = void, typename... Fields>
|
|
struct cf_t : bf_base<typename F::type, F::bitsize + cf_t<Fields...>::bitsize>
|
|
{
|
|
using type = typename cf_t::type;
|
|
using vtype = typename cf_t::vtype;
|
|
using utype = typename cf_t::utype;
|
|
using compact_type = typename cf_t::compact_type;
|
|
|
|
// Get disjunction of all "data" masks of concatenated values
|
|
static constexpr vtype data_mask()
|
|
{
|
|
return static_cast<vtype>(F::data_mask() | cf_t<Fields...>::data_mask());
|
|
}
|
|
|
|
// Extract all bitfields and concatenate
|
|
static constexpr compact_type extract(const type& data)
|
|
{
|
|
return static_cast<compact_type>(static_cast<utype>(F::extract(data)) << cf_t<Fields...>::bitsize | cf_t<Fields...>::extract(data));
|
|
}
|
|
|
|
// Split bitfields and insert them
|
|
static constexpr vtype insert(compact_type value)
|
|
{
|
|
return static_cast<vtype>(F::insert(value >> cf_t<Fields...>::bitsize) | cf_t<Fields...>::insert(value));
|
|
}
|
|
|
|
// Load value
|
|
constexpr operator compact_type() const noexcept
|
|
{
|
|
return extract(this->m_data);
|
|
}
|
|
|
|
// Store value
|
|
cf_t& operator =(compact_type value) noexcept
|
|
{
|
|
this->m_data = (this->m_data & ~data_mask()) | insert(value);
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
// Empty field pack (recursion terminator)
|
|
template <>
|
|
struct cf_t<void>
|
|
{
|
|
static constexpr uint bitsize = 0;
|
|
|
|
static constexpr uint data_mask()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
template <typename T>
|
|
static constexpr auto extract(const T&) -> decltype(+T())
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
template <typename T>
|
|
static constexpr T insert(T /*value*/)
|
|
{
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
// Fixed field (provides constant values in field pack)
|
|
template <typename T, T V, uint N>
|
|
struct ff_t : bf_base<T, N>
|
|
{
|
|
using type = typename ff_t::type;
|
|
using vtype = typename ff_t::vtype;
|
|
|
|
// Return constant value
|
|
static constexpr vtype extract(const type&)
|
|
{
|
|
static_assert((V & ff_t::vmask) == V, "ff_t<> error: V out of bounds");
|
|
return V;
|
|
}
|
|
|
|
// Get value
|
|
constexpr operator vtype() const noexcept
|
|
{
|
|
return V;
|
|
}
|
|
};
|
|
|
|
#ifndef _MSC_VER
|
|
#pragma GCC diagnostic pop
|
|
#endif
|
|
|
|
template <typename T, uint I, uint N>
|
|
struct fmt_unveil<bf_t<T, I, N>, void>
|
|
{
|
|
using type = typename fmt_unveil<std::common_type_t<T>>::type;
|
|
|
|
static inline auto get(const bf_t<T, I, N>& bf)
|
|
{
|
|
return fmt_unveil<type>::get(bf);
|
|
}
|
|
};
|
|
|
|
template <typename F, typename... Fields>
|
|
struct fmt_unveil<cf_t<F, Fields...>, void>
|
|
{
|
|
using type = typename fmt_unveil<std::common_type_t<typename F::type>>::type;
|
|
|
|
static inline auto get(const cf_t<F, Fields...>& cf)
|
|
{
|
|
return fmt_unveil<type>::get(cf);
|
|
}
|
|
};
|
|
|
|
template <typename T, T V, uint N>
|
|
struct fmt_unveil<ff_t<T, V, N>, void>
|
|
{
|
|
using type = typename fmt_unveil<std::common_type_t<T>>::type;
|
|
|
|
static inline auto get(const ff_t<T, V, N>& ff)
|
|
{
|
|
return fmt_unveil<type>::get(ff);
|
|
}
|
|
};
|