mirror of
https://github.com/RPCS3/rpcs3.git
synced 2025-07-14 10:48:36 +12:00
vm::var improved, cleanup
Mostly vm::var initialization introduced. Added vm::make_var function.
This commit is contained in:
Nekotekina
parent
cc02a147d3
commit
a974ee009e
116 changed files with 2763 additions and 3019 deletions
|
|
@ -1,12 +1,12 @@
|
|||
#pragma once
|
||||
|
||||
#include "vm_ref.h"
|
||||
|
||||
class PPUThread;
|
||||
class ARMv7Thread;
|
||||
|
||||
namespace vm
|
||||
{
|
||||
template<typename T, typename AT> struct _ref_base;
|
||||
|
||||
// helper SFINAE type for vm::_ptr_base comparison operators (enables comparison between equal types and between any type and void*)
|
||||
template<typename T1, typename T2, typename RT = void> using if_comparable_t = std::enable_if_t<
|
||||
std::is_void<T1>::value ||
|
||||
|
|
@ -14,84 +14,83 @@ namespace vm
|
|||
std::is_same<std::remove_cv_t<T1>, std::remove_cv_t<T2>>::value,
|
||||
RT>;
|
||||
|
||||
// helper SFINAE type for vm::_ptr_base pointer arithmetic operators and indirection (disabled for void and function pointers)
|
||||
template<typename T, typename RT = void> using if_arithmetical_ptr_t = std::enable_if_t<
|
||||
!std::is_void<T>::value &&
|
||||
!std::is_function<T>::value,
|
||||
RT>;
|
||||
|
||||
template<typename T, typename AT = u32>
|
||||
struct _ptr_base
|
||||
template<typename T, typename AT = u32> class _ptr_base
|
||||
{
|
||||
AT m_addr; // don't access directly
|
||||
|
||||
using type = T;
|
||||
AT m_addr;
|
||||
|
||||
static_assert(!std::is_pointer<T>::value, "vm::_ptr_base<> error: invalid type (pointer)");
|
||||
static_assert(!std::is_reference<T>::value, "vm::_ptr_base<> error: invalid type (reference)");
|
||||
|
||||
AT addr() const
|
||||
public:
|
||||
using type = T;
|
||||
using addr_type = std::remove_cv_t<AT>;
|
||||
|
||||
_ptr_base() = default;
|
||||
|
||||
constexpr _ptr_base(addr_type addr, const addr_tag_t&)
|
||||
: m_addr(addr)
|
||||
{
|
||||
}
|
||||
|
||||
constexpr addr_type addr() const
|
||||
{
|
||||
return m_addr;
|
||||
}
|
||||
|
||||
// get vm pointer to a struct member
|
||||
template<typename MT, typename T2, typename = if_comparable_t<T, T2>> _ptr_base<MT> ptr(MT T2::*const member) const
|
||||
template<typename MT, typename T2, typename = if_comparable_t<T, T2>> _ptr_base<MT> ptr(MT T2::*const mptr) const
|
||||
{
|
||||
const u32 offset = static_cast<u32>(reinterpret_cast<std::ptrdiff_t>(&(reinterpret_cast<T*>(0ull)->*member)));
|
||||
return{ VM_CAST(m_addr + offset) };
|
||||
return{ VM_CAST(m_addr) + get_offset(mptr), vm::addr };
|
||||
}
|
||||
|
||||
// get vm pointer to a struct member with array subscription
|
||||
template<typename MT, typename T2, typename = if_comparable_t<T, T2>> _ptr_base<std::remove_extent_t<MT>> ptr(MT T2::*const member, u32 index) const
|
||||
template<typename MT, typename T2, typename = if_comparable_t<T, T2>> _ptr_base<std::remove_extent_t<MT>> ptr(MT T2::*const mptr, u32 index) const
|
||||
{
|
||||
const u32 offset = static_cast<u32>(reinterpret_cast<std::ptrdiff_t>(&(reinterpret_cast<T*>(0ull)->*member)));
|
||||
return{ VM_CAST(m_addr + offset + sizeof32(T) * index) };
|
||||
return{ VM_CAST(m_addr) + get_offset(mptr) + sizeof32(T) * index, vm::addr };
|
||||
}
|
||||
|
||||
// get vm reference to a struct member
|
||||
template<typename MT, typename T2, typename = if_comparable_t<T, T2>> _ref_base<MT> ref(MT T2::*const member) const
|
||||
template<typename MT, typename T2, typename = if_comparable_t<T, T2>> _ref_base<MT> ref(MT T2::*const mptr) const
|
||||
{
|
||||
const u32 offset = static_cast<u32>(reinterpret_cast<std::ptrdiff_t>(&(reinterpret_cast<T*>(0ull)->*member)));
|
||||
return{ VM_CAST(m_addr + offset) };
|
||||
return{ VM_CAST(m_addr) + get_offset(mptr), vm::addr };
|
||||
}
|
||||
|
||||
// get vm reference to a struct member with array subscription
|
||||
template<typename MT, typename T2, typename = if_comparable_t<T, T2>> _ref_base<std::remove_extent_t<MT>> ref(MT T2::*const member, u32 index) const
|
||||
template<typename MT, typename T2, typename = if_comparable_t<T, T2>> _ref_base<std::remove_extent_t<MT>> ref(MT T2::*const mptr, u32 index) const
|
||||
{
|
||||
const u32 offset = static_cast<u32>(reinterpret_cast<std::ptrdiff_t>(&(reinterpret_cast<T*>(0ull)->*member)));
|
||||
return{ VM_CAST(m_addr + offset + sizeof32(T) * index) };
|
||||
return{ VM_CAST(m_addr) + get_offset(mptr) + sizeof32(T) * index, vm::addr };
|
||||
}
|
||||
|
||||
// get vm reference
|
||||
_ref_base<T, u32> ref() const
|
||||
{
|
||||
return{ VM_CAST(m_addr) };
|
||||
return{ VM_CAST(m_addr), vm::addr };
|
||||
}
|
||||
|
||||
template<typename CT> std::enable_if_t<std::is_assignable<AT&, CT>::value> set(const CT& value)
|
||||
/*[[deprecated("Use constructor instead")]]*/ void set(addr_type value)
|
||||
{
|
||||
m_addr = value;
|
||||
}
|
||||
|
||||
template<typename AT2 = AT> static std::enable_if_t<std::is_constructible<AT, AT2>::value, _ptr_base> make(const AT2& addr)
|
||||
/*[[deprecated("Use constructor instead")]]*/ static _ptr_base make(addr_type addr)
|
||||
{
|
||||
const AT value = addr;
|
||||
return{ value };
|
||||
return{ addr, vm::addr };
|
||||
}
|
||||
|
||||
T* get_ptr() const
|
||||
{
|
||||
return vm::get_ptr<T>(VM_CAST(m_addr));
|
||||
return static_cast<T*>(vm::base(VM_CAST(m_addr)));
|
||||
}
|
||||
|
||||
T* priv_ptr() const
|
||||
T* get_ptr_priv() const
|
||||
{
|
||||
return vm::priv_ptr<T>(VM_CAST(m_addr));
|
||||
return static_cast<T*>(vm::base_priv(VM_CAST(m_addr)));
|
||||
}
|
||||
|
||||
T* operator ->() const
|
||||
{
|
||||
static_assert(!std::is_void<T>::value, "vm::_ptr_base<> error: operator-> is not available for void pointers");
|
||||
|
||||
return get_ptr();
|
||||
}
|
||||
|
||||
|
|
@ -99,59 +98,127 @@ namespace vm
|
|||
{
|
||||
static_assert(!std::is_void<T>::value, "vm::_ptr_base<> error: operator[] is not available for void pointers");
|
||||
|
||||
return vm::get_ref<T>(VM_CAST(m_addr + sizeof32(T) * index));
|
||||
return *static_cast<T*>(vm::base(VM_CAST(m_addr) + sizeof32(T) * index));
|
||||
}
|
||||
|
||||
// enable only the conversions which are originally possible between pointer types
|
||||
template<typename T2, typename AT2, typename = std::enable_if_t<std::is_convertible<T*, T2*>::value>> operator _ptr_base<T2, AT2>() const
|
||||
{
|
||||
return{ VM_CAST(m_addr) };
|
||||
return{ VM_CAST(m_addr), vm::addr };
|
||||
}
|
||||
|
||||
template<typename T2, typename = std::enable_if_t<std::is_convertible<T*, T2*>::value>> explicit operator T2*() const
|
||||
{
|
||||
return get_ptr();
|
||||
}
|
||||
//template<typename T2, typename = std::enable_if_t<std::is_convertible<T*, T2*>::value>> explicit operator T2*() const
|
||||
//{
|
||||
// return get_ptr();
|
||||
//}
|
||||
|
||||
explicit operator bool() const
|
||||
{
|
||||
return m_addr != 0;
|
||||
}
|
||||
|
||||
// test address alignment using alignof(T)
|
||||
// Test address for arbitrary alignment: (addr & (align - 1)) != 0
|
||||
bool aligned(u32 align) const
|
||||
{
|
||||
return (m_addr & (align - 1)) == 0;
|
||||
}
|
||||
|
||||
// Test address for type's alignment using alignof(T)
|
||||
bool aligned() const
|
||||
{
|
||||
return m_addr % alignof32(T) == 0;
|
||||
static_assert(!std::is_void<T>::value, "vm::_ptr_base<> error: aligned() is not available for void pointers");
|
||||
|
||||
return aligned(alignof32(T));
|
||||
}
|
||||
|
||||
// test address for arbitrary alignment or something
|
||||
force_inline explicit_bool_t operator %(to_ne_t<AT> right) const
|
||||
// Call aligned(value)
|
||||
explicit_bool_t operator %(u32 align) const
|
||||
{
|
||||
return m_addr % right != 0;
|
||||
return aligned(align);
|
||||
}
|
||||
|
||||
_ptr_base& operator =(const _ptr_base&) = default;
|
||||
// pointer increment (postfix)
|
||||
_ptr_base operator ++(int)
|
||||
{
|
||||
static_assert(!std::is_void<T>::value, "vm::_ptr_base<> error: operator++ is not available for void pointers");
|
||||
|
||||
const addr_type result = m_addr;
|
||||
m_addr = VM_CAST(m_addr) + sizeof32(T);
|
||||
return{ result, vm::addr };
|
||||
}
|
||||
|
||||
// pointer increment (prefix)
|
||||
_ptr_base& operator ++()
|
||||
{
|
||||
static_assert(!std::is_void<T>::value, "vm::_ptr_base<> error: operator++ is not available for void pointers");
|
||||
|
||||
m_addr = VM_CAST(m_addr) + sizeof32(T);
|
||||
return *this;
|
||||
}
|
||||
|
||||
// pointer decrement (postfix)
|
||||
_ptr_base operator --(int)
|
||||
{
|
||||
static_assert(!std::is_void<T>::value, "vm::_ptr_base<> error: operator-- is not available for void pointers");
|
||||
|
||||
const addr_type result = m_addr;
|
||||
m_addr = VM_CAST(m_addr) - sizeof32(T);
|
||||
return{ result, vm::addr };
|
||||
}
|
||||
|
||||
// pointer decrement (prefix)
|
||||
_ptr_base& operator --()
|
||||
{
|
||||
static_assert(!std::is_void<T>::value, "vm::_ptr_base<> error: operator-- is not available for void pointers");
|
||||
|
||||
m_addr = VM_CAST(m_addr) - sizeof32(T);
|
||||
return *this;
|
||||
}
|
||||
|
||||
_ptr_base& operator +=(s32 count)
|
||||
{
|
||||
static_assert(!std::is_void<T>::value, "vm::_ptr_base<> error: operator+= is not available for void pointers");
|
||||
|
||||
m_addr = VM_CAST(m_addr) + count * sizeof32(T);
|
||||
return *this;
|
||||
}
|
||||
|
||||
_ptr_base& operator -=(s32 count)
|
||||
{
|
||||
static_assert(!std::is_void<T>::value, "vm::_ptr_base<> error: operator-= is not available for void pointers");
|
||||
|
||||
m_addr = VM_CAST(m_addr) - count * sizeof32(T);
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename AT, typename RT, typename... T>
|
||||
struct _ptr_base<RT(T...), AT>
|
||||
template<typename AT, typename RT, typename... T> class _ptr_base<RT(T...), AT>
|
||||
{
|
||||
AT m_addr;
|
||||
|
||||
AT addr() const
|
||||
public:
|
||||
using addr_type = std::remove_cv_t<AT>;
|
||||
|
||||
_ptr_base() = default;
|
||||
|
||||
constexpr _ptr_base(addr_type addr, const addr_tag_t&)
|
||||
: m_addr(addr)
|
||||
{
|
||||
}
|
||||
|
||||
constexpr addr_type addr() const
|
||||
{
|
||||
return m_addr;
|
||||
}
|
||||
|
||||
template<typename CT> std::enable_if_t<std::is_assignable<AT&, CT>::value> set(const CT& value)
|
||||
/*[[deprecated("Use constructor instead")]]*/ void set(addr_type value)
|
||||
{
|
||||
m_addr = value;
|
||||
}
|
||||
|
||||
template<typename AT2 = AT> static std::enable_if_t<std::is_constructible<AT, AT2>::value, _ptr_base> make(const AT2& addr)
|
||||
/*[[deprecated("Use constructor instead")]]*/ static _ptr_base make(addr_type addr)
|
||||
{
|
||||
const AT value = addr;
|
||||
return{ value };
|
||||
return{ addr, vm::addr };
|
||||
}
|
||||
|
||||
// defined in CB_FUNC.h, passing context is mandatory
|
||||
|
|
@ -163,19 +230,16 @@ namespace vm
|
|||
// conversion to another function pointer
|
||||
template<typename AT2> operator _ptr_base<RT(T...), AT2>() const
|
||||
{
|
||||
return{ VM_CAST(m_addr) };
|
||||
return{ VM_CAST(m_addr), vm::addr };
|
||||
}
|
||||
|
||||
explicit operator bool() const
|
||||
{
|
||||
return m_addr != 0;
|
||||
}
|
||||
|
||||
_ptr_base& operator =(const _ptr_base&) = default;
|
||||
};
|
||||
|
||||
template<typename AT, typename RT, typename... T>
|
||||
struct _ptr_base<RT(*)(T...), AT>
|
||||
template<typename AT, typename RT, typename... T> class _ptr_base<RT(*)(T...), AT>
|
||||
{
|
||||
AT m_addr;
|
||||
|
||||
|
|
@ -222,6 +286,18 @@ namespace vm
|
|||
|
||||
template<typename T, typename AT = u32> using cpptr = pptr<const T, AT>;
|
||||
template<typename T, typename AT = u32> using bcpptr = bpptr<const T, AT>;
|
||||
|
||||
// perform static_cast (for example, vm::ptr<void> to vm::ptr<char>)
|
||||
template<typename CT, typename T, typename AT, typename = decltype(static_cast<to_be_t<CT>*>(std::declval<T*>()))> inline _ptr_base<to_be_t<CT>> static_ptr_cast(const _ptr_base<T, AT>& other)
|
||||
{
|
||||
return{ VM_CAST(other.addr()), vm::addr };
|
||||
}
|
||||
|
||||
// perform const_cast (for example, vm::cptr<char> to vm::ptr<char>)
|
||||
template<typename CT, typename T, typename AT, typename = decltype(const_cast<to_be_t<CT>*>(std::declval<T*>()))> inline _ptr_base<to_be_t<CT>> const_ptr_cast(const _ptr_base<T, AT>& other)
|
||||
{
|
||||
return{ VM_CAST(other.addr()), vm::addr };
|
||||
}
|
||||
}
|
||||
|
||||
namespace psv
|
||||
|
|
@ -246,268 +322,203 @@ namespace vm
|
|||
|
||||
template<typename T> using cpptr = pptr<const T>;
|
||||
template<typename T> using lcpptr = lpptr<const T>;
|
||||
|
||||
// perform static_cast (for example, vm::ptr<void> to vm::ptr<char>)
|
||||
template<typename CT, typename T, typename AT, typename = decltype(static_cast<to_le_t<CT>*>(std::declval<T*>()))> inline _ptr_base<to_le_t<CT>> static_ptr_cast(const _ptr_base<T, AT>& other)
|
||||
{
|
||||
return{ VM_CAST(other.addr()), vm::addr };
|
||||
}
|
||||
|
||||
// perform const_cast (for example, vm::cptr<char> to vm::ptr<char>)
|
||||
template<typename CT, typename T, typename AT, typename = decltype(const_cast<to_le_t<CT>*>(std::declval<T*>()))> inline _ptr_base<to_le_t<CT>> const_ptr_cast(const _ptr_base<T, AT>& other)
|
||||
{
|
||||
return{ VM_CAST(other.addr()), vm::addr };
|
||||
}
|
||||
}
|
||||
|
||||
struct null_t
|
||||
{
|
||||
template<typename T, typename AT> operator _ptr_base<T, AT>() const
|
||||
{
|
||||
return{};
|
||||
return{ 0, vm::addr };
|
||||
}
|
||||
};
|
||||
|
||||
// vm::null is convertible to any vm::ptr type as null pointer in virtual memory
|
||||
static null_t null;
|
||||
|
||||
// perform static_cast (for example, vm::ptr<void> to vm::ptr<char>)
|
||||
template<typename CT, typename T, typename AT, typename = decltype(static_cast<CT*>(std::declval<T*>()))> inline _ptr_base<CT, AT> static_ptr_cast(const _ptr_base<T, AT>& other)
|
||||
// Call wait_op() for specified vm pointer
|
||||
template<typename T, typename AT, typename F, typename... Args> inline auto wait_op(named_thread_t& thread, const _ptr_base<T, AT>& ptr, F pred, Args&&... args) -> decltype(static_cast<void>(pred(args...)))
|
||||
{
|
||||
return{ other.m_addr };
|
||||
return wait_op(thread, ptr.addr(), sizeof32(T), std::move(pred), std::forward<Args>(args)...);
|
||||
}
|
||||
|
||||
// perform const_cast (for example, vm::cptr<char> to vm::ptr<char>)
|
||||
template<typename CT, typename T, typename AT, typename = decltype(const_cast<CT*>(std::declval<T*>()))> inline _ptr_base<CT, AT> const_ptr_cast(const _ptr_base<T, AT>& other)
|
||||
// Call notify_at() for specified vm pointer
|
||||
template<typename T, typename AT> inline void notify_at(const vm::_ptr_base<T, AT>& ptr)
|
||||
{
|
||||
return{ other.m_addr };
|
||||
}
|
||||
|
||||
// perform reinterpret_cast (for example, vm::ptr<char> to vm::ptr<u32>)
|
||||
template<typename CT, typename T, typename AT, typename = decltype(reinterpret_cast<CT*>(std::declval<T*>()))> inline _ptr_base<CT, AT> reinterpret_ptr_cast(const _ptr_base<T, AT>& other)
|
||||
{
|
||||
return{ other.m_addr };
|
||||
return notify_at(ptr.addr(), sizeof32(T));
|
||||
}
|
||||
}
|
||||
|
||||
// unary plus operator for vm::_ptr_base (always available)
|
||||
template<typename T, typename AT> inline vm::_ptr_base<T, AT> operator +(const vm::_ptr_base<T, AT>& ptr)
|
||||
template<typename T, typename AT> inline vm::_ptr_base<T> operator +(const vm::_ptr_base<T, AT>& ptr)
|
||||
{
|
||||
return ptr;
|
||||
}
|
||||
|
||||
// indirection operator for vm::_ptr_base
|
||||
template<typename T, typename AT> inline vm::if_arithmetical_ptr_t<T, T&> operator *(const vm::_ptr_base<T, AT>& ptr)
|
||||
template<typename T, typename AT> inline std::enable_if_t<std::is_object<T>::value, T&> operator *(const vm::_ptr_base<T, AT>& ptr)
|
||||
{
|
||||
return vm::get_ref<T>(VM_CAST(ptr.m_addr));
|
||||
}
|
||||
|
||||
// postfix increment operator for vm::_ptr_base
|
||||
template<typename T, typename AT> inline vm::if_arithmetical_ptr_t<T, vm::_ptr_base<T, AT>> operator ++(vm::_ptr_base<T, AT>& ptr, int)
|
||||
{
|
||||
const AT result = ptr.m_addr;
|
||||
ptr.m_addr += sizeof32(T);
|
||||
return{ result };
|
||||
}
|
||||
|
||||
// prefix increment operator for vm::_ptr_base
|
||||
template<typename T, typename AT> inline vm::if_arithmetical_ptr_t<T, vm::_ptr_base<T, AT>&> operator ++(vm::_ptr_base<T, AT>& ptr)
|
||||
{
|
||||
ptr.m_addr += sizeof32(T);
|
||||
return ptr;
|
||||
}
|
||||
|
||||
// postfix decrement operator for vm::_ptr_base
|
||||
template<typename T, typename AT> inline vm::if_arithmetical_ptr_t<T, vm::_ptr_base<T, AT>> operator --(vm::_ptr_base<T, AT>& ptr, int)
|
||||
{
|
||||
const AT result = ptr.m_addr;
|
||||
ptr.m_addr -= sizeof32(T);
|
||||
return{ result };
|
||||
}
|
||||
|
||||
// prefix decrement operator for vm::_ptr_base
|
||||
template<typename T, typename AT> inline vm::if_arithmetical_ptr_t<T, vm::_ptr_base<T, AT>&> operator --(vm::_ptr_base<T, AT>& ptr)
|
||||
{
|
||||
ptr.m_addr -= sizeof32(T);
|
||||
return ptr;
|
||||
}
|
||||
|
||||
// addition assignment operator for vm::_ptr_base (pointer += integer)
|
||||
template<typename T, typename AT> inline vm::if_arithmetical_ptr_t<T, vm::_ptr_base<T, AT>&> operator +=(vm::_ptr_base<T, AT>& ptr, to_ne_t<AT> count)
|
||||
{
|
||||
ptr.m_addr += count * sizeof32(T);
|
||||
return ptr;
|
||||
}
|
||||
|
||||
// subtraction assignment operator for vm::_ptr_base (pointer -= integer)
|
||||
template<typename T, typename AT> inline vm::if_arithmetical_ptr_t<T, vm::_ptr_base<T, AT>&> operator -=(vm::_ptr_base<T, AT>& ptr, to_ne_t<AT> count)
|
||||
{
|
||||
ptr.m_addr -= count * sizeof32(T);
|
||||
return ptr;
|
||||
return *ptr.get_ptr();
|
||||
}
|
||||
|
||||
// addition operator for vm::_ptr_base (pointer + integer)
|
||||
template<typename T, typename AT> inline vm::if_arithmetical_ptr_t<T, vm::_ptr_base<T, AT>> operator +(const vm::_ptr_base<T, AT>& ptr, to_ne_t<AT> count)
|
||||
template<typename T, typename AT> inline std::enable_if_t<std::is_object<T>::value, vm::_ptr_base<T>> operator +(const vm::_ptr_base<T, AT>& ptr, u32 count)
|
||||
{
|
||||
return{ ptr.m_addr + count * sizeof32(T) };
|
||||
return{ VM_CAST(ptr.addr()) + count * sizeof32(T), vm::addr };
|
||||
}
|
||||
|
||||
// addition operator for vm::_ptr_base (integer + pointer)
|
||||
template<typename T, typename AT> inline vm::if_arithmetical_ptr_t<T, vm::_ptr_base<T, AT>> operator +(to_ne_t<AT> count, const vm::_ptr_base<T, AT>& ptr)
|
||||
template<typename T, typename AT> inline std::enable_if_t<std::is_object<T>::value, vm::_ptr_base<T>> operator +(u32 count, const vm::_ptr_base<T, AT>& ptr)
|
||||
{
|
||||
return{ ptr.m_addr + count * sizeof32(T) };
|
||||
return{ VM_CAST(ptr.addr()) + count * sizeof32(T), vm::addr };
|
||||
}
|
||||
|
||||
// subtraction operator for vm::_ptr_base (pointer - integer)
|
||||
template<typename T, typename AT> inline vm::if_arithmetical_ptr_t<T, vm::_ptr_base<T, AT>> operator -(const vm::_ptr_base<T, AT>& ptr, to_ne_t<AT> count)
|
||||
template<typename T, typename AT> inline std::enable_if_t<std::is_object<T>::value, vm::_ptr_base<T>> operator -(const vm::_ptr_base<T, AT>& ptr, u32 count)
|
||||
{
|
||||
return{ ptr.m_addr - count * sizeof32(T) };
|
||||
return{ VM_CAST(ptr.addr()) - count * sizeof32(T), vm::addr };
|
||||
}
|
||||
|
||||
// pointer difference operator for vm::_ptr_base
|
||||
template<typename T1, typename AT1, typename T2, typename AT2> inline std::enable_if_t<
|
||||
!std::is_void<T1>::value &&
|
||||
!std::is_void<T2>::value &&
|
||||
!std::is_function<T1>::value &&
|
||||
!std::is_function<T2>::value &&
|
||||
std::is_object<T1>::value &&
|
||||
std::is_object<T2>::value &&
|
||||
std::is_same<std::remove_cv_t<T1>, std::remove_cv_t<T2>>::value,
|
||||
s32> operator -(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
|
||||
{
|
||||
return static_cast<s32>(left.m_addr - right.m_addr) / sizeof32(T1);
|
||||
return static_cast<s32>(VM_CAST(left.addr()) - VM_CAST(right.addr())) / sizeof32(T1);
|
||||
}
|
||||
|
||||
// comparison operator for vm::_ptr_base (pointer1 == pointer2)
|
||||
template<typename T1, typename AT1, typename T2, typename AT2> vm::if_comparable_t<T1, T2, bool> operator ==(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
|
||||
template<typename T1, typename AT1, typename T2, typename AT2> inline vm::if_comparable_t<T1, T2, bool> operator ==(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
|
||||
{
|
||||
return left.m_addr == right.m_addr;
|
||||
return left.addr() == right.addr();
|
||||
}
|
||||
|
||||
template<typename T, typename AT> bool operator ==(const vm::null_t&, const vm::_ptr_base<T, AT>& ptr)
|
||||
template<typename T, typename AT> inline bool operator ==(const vm::null_t&, const vm::_ptr_base<T, AT>& ptr)
|
||||
{
|
||||
return ptr.m_addr == 0;
|
||||
return !ptr.operator bool();
|
||||
}
|
||||
|
||||
template<typename T, typename AT> bool operator ==(const vm::_ptr_base<T, AT>& ptr, const vm::null_t&)
|
||||
template<typename T, typename AT> inline bool operator ==(const vm::_ptr_base<T, AT>& ptr, const vm::null_t&)
|
||||
{
|
||||
return ptr.m_addr == 0;
|
||||
return !ptr.operator bool();
|
||||
}
|
||||
|
||||
// comparison operator for vm::_ptr_base (pointer1 != pointer2)
|
||||
template<typename T1, typename AT1, typename T2, typename AT2> vm::if_comparable_t<T1, T2, bool> operator !=(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
|
||||
template<typename T1, typename AT1, typename T2, typename AT2> inline vm::if_comparable_t<T1, T2, bool> operator !=(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
|
||||
{
|
||||
return left.m_addr != right.m_addr;
|
||||
return left.addr() != right.addr();
|
||||
}
|
||||
|
||||
template<typename T, typename AT> bool operator !=(const vm::null_t&, const vm::_ptr_base<T, AT>& ptr)
|
||||
template<typename T, typename AT> inline bool operator !=(const vm::null_t&, const vm::_ptr_base<T, AT>& ptr)
|
||||
{
|
||||
return ptr.m_addr != 0;
|
||||
return ptr.operator bool();
|
||||
}
|
||||
|
||||
template<typename T, typename AT> bool operator !=(const vm::_ptr_base<T, AT>& ptr, const vm::null_t&)
|
||||
template<typename T, typename AT> inline bool operator !=(const vm::_ptr_base<T, AT>& ptr, const vm::null_t&)
|
||||
{
|
||||
return ptr.m_addr != 0;
|
||||
return ptr.operator bool();
|
||||
}
|
||||
|
||||
// comparison operator for vm::_ptr_base (pointer1 < pointer2)
|
||||
template<typename T1, typename AT1, typename T2, typename AT2> vm::if_comparable_t<T1, T2, bool> operator <(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
|
||||
template<typename T1, typename AT1, typename T2, typename AT2> inline vm::if_comparable_t<T1, T2, bool> operator <(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
|
||||
{
|
||||
return left.m_addr < right.m_addr;
|
||||
return left.addr() < right.addr();
|
||||
}
|
||||
|
||||
template<typename T, typename AT> bool operator <(const vm::null_t&, const vm::_ptr_base<T, AT>& ptr)
|
||||
template<typename T, typename AT> inline bool operator <(const vm::null_t&, const vm::_ptr_base<T, AT>& ptr)
|
||||
{
|
||||
return ptr.m_addr != 0;
|
||||
return ptr.operator bool();
|
||||
}
|
||||
|
||||
template<typename T, typename AT> bool operator <(const vm::_ptr_base<T, AT>&, const vm::null_t&)
|
||||
template<typename T, typename AT> inline bool operator <(const vm::_ptr_base<T, AT>&, const vm::null_t&)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// comparison operator for vm::_ptr_base (pointer1 <= pointer2)
|
||||
template<typename T1, typename AT1, typename T2, typename AT2> vm::if_comparable_t<T1, T2, bool> operator <=(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
|
||||
template<typename T1, typename AT1, typename T2, typename AT2> inline vm::if_comparable_t<T1, T2, bool> operator <=(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
|
||||
{
|
||||
return left.m_addr <= right.m_addr;
|
||||
return left.addr() <= right.addr();
|
||||
}
|
||||
|
||||
template<typename T, typename AT> bool operator <=(const vm::null_t&, const vm::_ptr_base<T, AT>&)
|
||||
template<typename T, typename AT> inline bool operator <=(const vm::null_t&, const vm::_ptr_base<T, AT>&)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename T, typename AT> bool operator <=(const vm::_ptr_base<T, AT>& ptr, const vm::null_t&)
|
||||
template<typename T, typename AT> inline bool operator <=(const vm::_ptr_base<T, AT>& ptr, const vm::null_t&)
|
||||
{
|
||||
return ptr.m_addr == 0;
|
||||
return !ptr.operator bool();
|
||||
}
|
||||
|
||||
// comparison operator for vm::_ptr_base (pointer1 > pointer2)
|
||||
template<typename T1, typename AT1, typename T2, typename AT2> vm::if_comparable_t<T1, T2, bool> operator >(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
|
||||
template<typename T1, typename AT1, typename T2, typename AT2> inline vm::if_comparable_t<T1, T2, bool> operator >(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
|
||||
{
|
||||
return left.m_addr > right.m_addr;
|
||||
return left.addr() > right.addr();
|
||||
}
|
||||
|
||||
template<typename T, typename AT> bool operator >(const vm::null_t&, const vm::_ptr_base<T, AT>&)
|
||||
template<typename T, typename AT> inline bool operator >(const vm::null_t&, const vm::_ptr_base<T, AT>&)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
template<typename T, typename AT> bool operator >(const vm::_ptr_base<T, AT>& ptr, const vm::null_t&)
|
||||
template<typename T, typename AT> inline bool operator >(const vm::_ptr_base<T, AT>& ptr, const vm::null_t&)
|
||||
{
|
||||
return ptr.m_addr != 0;
|
||||
return ptr.operator bool();
|
||||
}
|
||||
|
||||
// comparison operator for vm::_ptr_base (pointer1 >= pointer2)
|
||||
template<typename T1, typename AT1, typename T2, typename AT2> vm::if_comparable_t<T1, T2, bool> operator >=(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
|
||||
template<typename T1, typename AT1, typename T2, typename AT2> inline vm::if_comparable_t<T1, T2, bool> operator >=(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
|
||||
{
|
||||
return left.m_addr >= right.m_addr;
|
||||
return left.addr() >= right.addr();
|
||||
}
|
||||
|
||||
template<typename T, typename AT> bool operator >=(const vm::null_t&, const vm::_ptr_base<T, AT>& ptr)
|
||||
template<typename T, typename AT> inline bool operator >=(const vm::null_t&, const vm::_ptr_base<T, AT>& ptr)
|
||||
{
|
||||
return ptr.m_addr == 0;
|
||||
return !ptr.operator bool();
|
||||
}
|
||||
|
||||
template<typename T, typename AT> bool operator >=(const vm::_ptr_base<T, AT>&, const vm::null_t&)
|
||||
template<typename T, typename AT> inline bool operator >=(const vm::_ptr_base<T, AT>&, const vm::null_t&)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
// external specialization for is_be_t<> (true if AT is be_t<>)
|
||||
// external specialization for to_se<> (change AT endianness to BE/LE)
|
||||
|
||||
template<typename T, typename AT>
|
||||
struct is_be_t<vm::_ptr_base<T, AT>> : public std::integral_constant<bool, is_be_t<AT>::value>
|
||||
template<typename T, typename AT, bool Se> struct to_se<vm::_ptr_base<T, AT>, Se>
|
||||
{
|
||||
using type = vm::_ptr_base<T, typename to_se<AT, Se>::type>;
|
||||
};
|
||||
|
||||
// external specialization for is_le_t<> (true if AT is le_t<>)
|
||||
// external specialization for to_ne<> (change AT endianness to native)
|
||||
|
||||
template<typename T, typename AT>
|
||||
struct is_le_t<vm::_ptr_base<T, AT>> : public std::integral_constant<bool, is_le_t<AT>::value>
|
||||
template<typename T, typename AT> struct to_ne<vm::_ptr_base<T, AT>>
|
||||
{
|
||||
};
|
||||
|
||||
// external specialization for to_ne_t<> (change AT endianness to native)
|
||||
|
||||
template<typename T, typename AT>
|
||||
struct to_ne<vm::_ptr_base<T, AT>>
|
||||
{
|
||||
using type = vm::_ptr_base<T, to_ne_t<AT>>;
|
||||
};
|
||||
|
||||
// external specialization for to_be_t<> (change AT endianness to BE)
|
||||
|
||||
template<typename T, typename AT>
|
||||
struct to_be<vm::_ptr_base<T, AT>>
|
||||
{
|
||||
using type = vm::_ptr_base<T, to_be_t<AT>>;
|
||||
};
|
||||
|
||||
// external specialization for to_le_t<> (change AT endianness to LE)
|
||||
|
||||
template<typename T, typename AT>
|
||||
struct to_le<vm::_ptr_base<T, AT>>
|
||||
{
|
||||
using type = vm::_ptr_base<T, to_le_t<AT>>;
|
||||
using type = vm::_ptr_base<T, typename to_ne<AT>::type>;
|
||||
};
|
||||
|
||||
namespace fmt
|
||||
{
|
||||
// external specialization for fmt::format function
|
||||
|
||||
template<typename T, typename AT>
|
||||
struct unveil<vm::_ptr_base<T, AT>, false>
|
||||
template<typename T, typename AT> struct unveil<vm::_ptr_base<T, AT>, false>
|
||||
{
|
||||
using result_type = typename unveil<AT>::result_type;
|
||||
|
||||
force_inline static result_type get_value(const vm::_ptr_base<T, AT>& arg)
|
||||
static inline result_type get_value(const vm::_ptr_base<T, AT>& arg)
|
||||
{
|
||||
return unveil<AT>::get_value(arg.addr());
|
||||
}
|
||||
|
|
@ -516,38 +527,34 @@ namespace fmt
|
|||
|
||||
// external specializations for PPU GPR (SC_FUNC.h, CB_FUNC.h)
|
||||
|
||||
template<typename T, bool is_enum>
|
||||
struct cast_ppu_gpr;
|
||||
template<typename T, bool is_enum> struct cast_ppu_gpr;
|
||||
|
||||
template<typename T, typename AT>
|
||||
struct cast_ppu_gpr<vm::_ptr_base<T, AT>, false>
|
||||
template<typename T, typename AT> struct cast_ppu_gpr<vm::_ptr_base<T, AT>, false>
|
||||
{
|
||||
force_inline static u64 to_gpr(const vm::_ptr_base<T, AT>& value)
|
||||
static inline u64 to_gpr(const vm::_ptr_base<T, AT>& value)
|
||||
{
|
||||
return cast_ppu_gpr<AT, std::is_enum<AT>::value>::to_gpr(value.addr());
|
||||
}
|
||||
|
||||
force_inline static vm::_ptr_base<T, AT> from_gpr(const u64 reg)
|
||||
static inline vm::_ptr_base<T, AT> from_gpr(const u64 reg)
|
||||
{
|
||||
return vm::_ptr_base<T, AT>::make(cast_ppu_gpr<AT, std::is_enum<AT>::value>::from_gpr(reg));
|
||||
return{ cast_ppu_gpr<AT, std::is_enum<AT>::value>::from_gpr(reg), vm::addr };
|
||||
}
|
||||
};
|
||||
|
||||
// external specializations for ARMv7 GPR
|
||||
|
||||
template<typename T, bool is_enum>
|
||||
struct cast_armv7_gpr;
|
||||
template<typename T, bool is_enum> struct cast_armv7_gpr;
|
||||
|
||||
template<typename T, typename AT>
|
||||
struct cast_armv7_gpr<vm::_ptr_base<T, AT>, false>
|
||||
template<typename T, typename AT> struct cast_armv7_gpr<vm::_ptr_base<T, AT>, false>
|
||||
{
|
||||
force_inline static u32 to_gpr(const vm::_ptr_base<T, AT>& value)
|
||||
static inline u32 to_gpr(const vm::_ptr_base<T, AT>& value)
|
||||
{
|
||||
return cast_armv7_gpr<AT, std::is_enum<AT>::value>::to_gpr(value.addr());
|
||||
}
|
||||
|
||||
force_inline static vm::_ptr_base<T, AT> from_gpr(const u32 reg)
|
||||
static inline vm::_ptr_base<T, AT> from_gpr(const u32 reg)
|
||||
{
|
||||
return vm::_ptr_base<T, AT>::make(cast_armv7_gpr<AT, std::is_enum<AT>::value>::from_gpr(reg));
|
||||
return{ cast_armv7_gpr<AT, std::is_enum<AT>::value>::from_gpr(reg), vm::addr };
|
||||
}
|
||||
};
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue