mirror of
https://github.com/RPCS3/rpcs3.git
synced 2025-07-09 00:11:24 +12:00
563 lines
16 KiB
C++
563 lines
16 KiB
C++
#pragma once
|
|
|
|
class CPUThread;
|
|
|
|
namespace vm
|
|
{
|
|
template<typename T, int lvl = 1, typename AT = u32>
|
|
class _ptr_base
|
|
{
|
|
AT m_addr;
|
|
|
|
public:
|
|
typedef typename std::remove_cv<T>::type type;
|
|
static const u32 address_size = (u32)sizeof(AT);
|
|
|
|
_ptr_base operator++ (int)
|
|
{
|
|
AT result = m_addr;
|
|
m_addr += address_size;
|
|
return make(result);
|
|
}
|
|
|
|
_ptr_base& operator++ ()
|
|
{
|
|
m_addr += address_size;
|
|
return *this;
|
|
}
|
|
|
|
_ptr_base operator-- (int)
|
|
{
|
|
AT result = m_addr;
|
|
m_addr -= address_size;
|
|
return make(result);
|
|
}
|
|
|
|
_ptr_base& operator-- ()
|
|
{
|
|
m_addr -= address_size;
|
|
return *this;
|
|
}
|
|
|
|
_ptr_base& operator += (AT count)
|
|
{
|
|
m_addr += count * address_size;
|
|
return *this;
|
|
}
|
|
|
|
_ptr_base& operator -= (AT count)
|
|
{
|
|
m_addr -= count * address_size;
|
|
return *this;
|
|
}
|
|
|
|
_ptr_base operator + (typename remove_be_t<AT>::type count) const { return make(m_addr + count * address_size); }
|
|
_ptr_base operator + (typename to_be_t<AT>::type count) const { return make(m_addr + count * address_size); }
|
|
_ptr_base operator - (typename remove_be_t<AT>::type count) const { return make(m_addr - count * address_size); }
|
|
_ptr_base operator - (typename to_be_t<AT>::type count) const { return make(m_addr - count * address_size); }
|
|
|
|
__forceinline bool operator <(const _ptr_base& right) const { return m_addr < right.m_addr; }
|
|
__forceinline bool operator <=(const _ptr_base& right) const { return m_addr <= right.m_addr; }
|
|
__forceinline bool operator >(const _ptr_base& right) const { return m_addr > right.m_addr; }
|
|
__forceinline bool operator >=(const _ptr_base& right) const { return m_addr >= right.m_addr; }
|
|
__forceinline bool operator ==(const _ptr_base& right) const { return m_addr == right.m_addr; }
|
|
__forceinline bool operator !=(const _ptr_base& right) const { return m_addr != right.m_addr; }
|
|
__forceinline bool operator ==(const nullptr_t& right) const { return m_addr == 0; }
|
|
__forceinline bool operator !=(const nullptr_t& right) const { return m_addr != 0; }
|
|
explicit operator bool() const { return m_addr != 0; }
|
|
|
|
__forceinline _ptr_base<T, lvl - 1, std::conditional<is_be_t<T>::value, typename to_be_t<AT>::type, AT>>& operator *() const
|
|
{
|
|
return vm::get_ref<_ptr_base<T, lvl - 1, std::conditional<is_be_t<T>::value, typename to_be_t<AT>::type, AT>>>(vm::cast(m_addr));
|
|
}
|
|
|
|
__forceinline _ptr_base<T, lvl - 1, std::conditional<is_be_t<T>::value, typename to_be_t<AT>::type, AT>>& operator [](AT index) const
|
|
{
|
|
return vm::get_ref<_ptr_base<T, lvl - 1, std::conditional<is_be_t<T>::value, typename to_be_t<AT>::type, AT>>>(vm::cast(m_addr + sizeof(AT)* index));
|
|
}
|
|
|
|
//typedef typename invert_be_t<AT>::type AT2;
|
|
|
|
template<typename AT2>
|
|
operator const _ptr_base<T, lvl, AT2>() const
|
|
{
|
|
typename std::remove_const<AT2>::type addr = convert_le_be<AT2>(m_addr);
|
|
return (_ptr_base<T, lvl, AT2>&)addr;
|
|
}
|
|
|
|
AT addr() const
|
|
{
|
|
return m_addr;
|
|
}
|
|
|
|
void set(const AT value)
|
|
{
|
|
m_addr = value;
|
|
}
|
|
|
|
static _ptr_base make(AT addr)
|
|
{
|
|
return (_ptr_base&)addr;
|
|
}
|
|
|
|
_ptr_base& operator = (const _ptr_base& right) = default;
|
|
};
|
|
|
|
template<typename T, typename AT>
|
|
class _ptr_base<T, 1, AT>
|
|
{
|
|
AT m_addr;
|
|
|
|
public:
|
|
typedef typename std::remove_cv<T>::type type;
|
|
static const u32 data_size = (u32)sizeof(T);
|
|
|
|
__forceinline T* const operator -> () const
|
|
{
|
|
return vm::get_ptr<T>(vm::cast(m_addr));
|
|
}
|
|
|
|
_ptr_base operator++ (int)
|
|
{
|
|
AT result = m_addr;
|
|
m_addr += data_size;
|
|
return make(result);
|
|
}
|
|
|
|
_ptr_base& operator++ ()
|
|
{
|
|
m_addr += data_size;
|
|
return *this;
|
|
}
|
|
|
|
_ptr_base operator-- (int)
|
|
{
|
|
AT result = m_addr;
|
|
m_addr -= data_size;
|
|
return make(result);
|
|
}
|
|
|
|
_ptr_base& operator-- ()
|
|
{
|
|
m_addr -= data_size;
|
|
return *this;
|
|
}
|
|
|
|
_ptr_base& operator += (AT count)
|
|
{
|
|
m_addr += count * data_size;
|
|
return *this;
|
|
}
|
|
|
|
_ptr_base& operator -= (AT count)
|
|
{
|
|
m_addr -= count * data_size;
|
|
return *this;
|
|
}
|
|
|
|
_ptr_base operator + (typename remove_be_t<AT>::type count) const { return make(m_addr + count * data_size); }
|
|
_ptr_base operator + (typename to_be_t<AT>::type count) const { return make(m_addr + count * data_size); }
|
|
_ptr_base operator - (typename remove_be_t<AT>::type count) const { return make(m_addr - count * data_size); }
|
|
_ptr_base operator - (typename to_be_t<AT>::type count) const { return make(m_addr - count * data_size); }
|
|
|
|
__forceinline T& operator *() const
|
|
{
|
|
return vm::get_ref<T>(vm::cast(m_addr));
|
|
}
|
|
|
|
__forceinline T& operator [](typename remove_be_t<AT>::type index) const
|
|
{
|
|
return vm::get_ref<T>(vm::cast(m_addr + data_size * index));
|
|
}
|
|
|
|
__forceinline T& operator [](typename to_be_t<AT>::forced_type index) const
|
|
{
|
|
return vm::get_ref<T>(vm::cast(m_addr + data_size * index));
|
|
}
|
|
|
|
__forceinline bool operator <(const _ptr_base& right) const { return m_addr < right.m_addr; }
|
|
__forceinline bool operator <=(const _ptr_base& right) const { return m_addr <= right.m_addr; }
|
|
__forceinline bool operator >(const _ptr_base& right) const { return m_addr > right.m_addr; }
|
|
__forceinline bool operator >=(const _ptr_base& right) const { return m_addr >= right.m_addr; }
|
|
__forceinline bool operator ==(const _ptr_base& right) const { return m_addr == right.m_addr; }
|
|
__forceinline bool operator !=(const _ptr_base& right) const { return m_addr != right.m_addr; }
|
|
__forceinline bool operator ==(const nullptr_t& right) const { return m_addr == 0; }
|
|
__forceinline bool operator !=(const nullptr_t& right) const { return m_addr != 0; }
|
|
explicit operator bool() const { return m_addr != 0; }
|
|
explicit operator T*() const { return get_ptr(); }
|
|
|
|
/*
|
|
operator _ref_base<T, AT>()
|
|
{
|
|
return _ref_base<T, AT>::make(m_addr);
|
|
}
|
|
|
|
operator const _ref_base<T, AT>() const
|
|
{
|
|
return _ref_base<T, AT>::make(m_addr);
|
|
}
|
|
*/
|
|
|
|
AT addr() const
|
|
{
|
|
return m_addr;
|
|
}
|
|
|
|
template<typename U>
|
|
void set(U&& value)
|
|
{
|
|
m_addr = convert_le_be<AT>(value);
|
|
}
|
|
|
|
/*
|
|
operator T*() const
|
|
{
|
|
return get_ptr();
|
|
}
|
|
*/
|
|
//typedef typename invert_be_t<AT>::type AT2;
|
|
|
|
template<typename AT2>
|
|
operator const _ptr_base<T, 1, AT2>() const
|
|
{
|
|
typename std::remove_const<AT2>::type addr = convert_le_be<AT2>(m_addr);
|
|
return (_ptr_base<T, 1, AT2>&)addr;
|
|
}
|
|
|
|
T* get_ptr() const
|
|
{
|
|
return vm::get_ptr<T>(vm::cast(m_addr));
|
|
}
|
|
|
|
static _ptr_base make(AT addr)
|
|
{
|
|
return (_ptr_base&)addr;
|
|
}
|
|
|
|
_ptr_base& operator = (const _ptr_base& right) = default;
|
|
};
|
|
|
|
template<typename AT>
|
|
class _ptr_base<void, 1, AT>
|
|
{
|
|
AT m_addr;
|
|
|
|
public:
|
|
AT addr() const
|
|
{
|
|
return m_addr;
|
|
}
|
|
|
|
void set(const AT value)
|
|
{
|
|
m_addr = value;
|
|
}
|
|
|
|
void* get_ptr() const
|
|
{
|
|
return vm::get_ptr<void>(vm::cast(m_addr));
|
|
}
|
|
|
|
explicit operator void*() const
|
|
{
|
|
return get_ptr();
|
|
}
|
|
|
|
__forceinline bool operator <(const _ptr_base& right) const { return m_addr < right.m_addr; }
|
|
__forceinline bool operator <=(const _ptr_base& right) const { return m_addr <= right.m_addr; }
|
|
__forceinline bool operator >(const _ptr_base& right) const { return m_addr > right.m_addr; }
|
|
__forceinline bool operator >=(const _ptr_base& right) const { return m_addr >= right.m_addr; }
|
|
__forceinline bool operator ==(const _ptr_base& right) const { return m_addr == right.m_addr; }
|
|
__forceinline bool operator !=(const _ptr_base& right) const { return m_addr != right.m_addr; }
|
|
__forceinline bool operator ==(const nullptr_t& right) const { return m_addr == 0; }
|
|
__forceinline bool operator !=(const nullptr_t& right) const { return m_addr != 0; }
|
|
explicit operator bool() const { return m_addr != 0; }
|
|
|
|
//typedef typename invert_be_t<AT>::type AT2;
|
|
|
|
template<typename AT2>
|
|
operator const _ptr_base<void, 1, AT2>() const
|
|
{
|
|
typename std::remove_const<AT2>::type addr = convert_le_be<AT2>(m_addr);
|
|
return (_ptr_base<void, 1, AT2>&)addr;
|
|
}
|
|
|
|
template<typename AT2>
|
|
operator const _ptr_base<const void, 1, AT2>() const
|
|
{
|
|
typename std::remove_const<AT2>::type addr = convert_le_be<AT2>(m_addr);
|
|
return (_ptr_base<const void, 1, AT2>&)addr;
|
|
}
|
|
|
|
static _ptr_base make(AT addr)
|
|
{
|
|
return (_ptr_base&)addr;
|
|
}
|
|
|
|
_ptr_base& operator = (const _ptr_base& right) = default;
|
|
};
|
|
|
|
template<typename AT>
|
|
class _ptr_base<const void, 1, AT>
|
|
{
|
|
AT m_addr;
|
|
|
|
public:
|
|
AT addr() const
|
|
{
|
|
return m_addr;
|
|
}
|
|
|
|
void set(const AT value)
|
|
{
|
|
m_addr = value;
|
|
}
|
|
|
|
const void* get_ptr() const
|
|
{
|
|
return vm::get_ptr<const void>(vm::cast(m_addr));
|
|
}
|
|
|
|
explicit operator const void*() const
|
|
{
|
|
return get_ptr();
|
|
}
|
|
|
|
__forceinline bool operator <(const _ptr_base& right) const { return m_addr < right.m_addr; }
|
|
__forceinline bool operator <=(const _ptr_base& right) const { return m_addr <= right.m_addr; }
|
|
__forceinline bool operator >(const _ptr_base& right) const { return m_addr > right.m_addr; }
|
|
__forceinline bool operator >=(const _ptr_base& right) const { return m_addr >= right.m_addr; }
|
|
__forceinline bool operator ==(const _ptr_base& right) const { return m_addr == right.m_addr; }
|
|
__forceinline bool operator !=(const _ptr_base& right) const { return m_addr != right.m_addr; }
|
|
__forceinline bool operator ==(const nullptr_t& right) const { return m_addr == 0; }
|
|
__forceinline bool operator !=(const nullptr_t& right) const { return m_addr != 0; }
|
|
explicit operator bool() const { return m_addr != 0; }
|
|
|
|
//typedef typename invert_be_t<AT>::type AT2;
|
|
|
|
template<typename AT2>
|
|
operator const _ptr_base<const void, 1, AT2>() const
|
|
{
|
|
typename std::remove_const<AT2>::type addr = convert_le_be<AT2>(m_addr);
|
|
return (_ptr_base<const void, 1, AT2>&)addr;
|
|
}
|
|
|
|
static _ptr_base make(AT addr)
|
|
{
|
|
return (_ptr_base&)addr;
|
|
}
|
|
|
|
_ptr_base& operator = (const _ptr_base& right) = default;
|
|
};
|
|
|
|
template<typename AT, typename RT, typename ...T>
|
|
class _ptr_base<RT(*)(T...), 1, AT>
|
|
{
|
|
AT m_addr;
|
|
|
|
public:
|
|
typedef RT(*type)(T...);
|
|
|
|
RT operator()(CPUThread& CPU, T... args) const; // defined in CB_FUNC.h, call using specified CPU thread context
|
|
|
|
RT operator()(T... args) const; // defined in CB_FUNC.h, call using current CPU thread context
|
|
|
|
AT addr() const
|
|
{
|
|
return m_addr;
|
|
}
|
|
|
|
void set(const AT value)
|
|
{
|
|
m_addr = value;
|
|
}
|
|
|
|
__forceinline bool operator <(const _ptr_base& right) const { return m_addr < right.m_addr; }
|
|
__forceinline bool operator <=(const _ptr_base& right) const { return m_addr <= right.m_addr; }
|
|
__forceinline bool operator >(const _ptr_base& right) const { return m_addr > right.m_addr; }
|
|
__forceinline bool operator >=(const _ptr_base& right) const { return m_addr >= right.m_addr; }
|
|
__forceinline bool operator ==(const _ptr_base& right) const { return m_addr == right.m_addr; }
|
|
__forceinline bool operator !=(const _ptr_base& right) const { return m_addr != right.m_addr; }
|
|
__forceinline bool operator ==(const nullptr_t& right) const { return m_addr == 0; }
|
|
__forceinline bool operator !=(const nullptr_t& right) const { return m_addr != 0; }
|
|
explicit operator bool() const { return m_addr != 0; }
|
|
|
|
//typedef typename invert_be_t<AT>::type AT2;
|
|
|
|
template<typename AT2>
|
|
operator const _ptr_base<RT(*)(T...), 1, AT2>() const
|
|
{
|
|
typename std::remove_const<AT2>::type addr = convert_le_be<AT2>(m_addr);
|
|
return (_ptr_base<RT(*)(T...), 1, AT2>&)addr;
|
|
}
|
|
|
|
static _ptr_base make(AT addr)
|
|
{
|
|
return (_ptr_base&)addr;
|
|
}
|
|
|
|
operator const std::function<RT(T...)>() const
|
|
{
|
|
typename std::remove_const<AT>::type addr = convert_le_be<AT>(m_addr);
|
|
return [addr](T... args) -> RT { return make(addr)(args...); };
|
|
}
|
|
|
|
_ptr_base& operator = (const _ptr_base& right) = default;
|
|
};
|
|
|
|
//BE pointer to LE data
|
|
template<typename T, int lvl = 1, typename AT = u32> struct bptrl : public _ptr_base<T, lvl, typename to_be_t<AT>::type>
|
|
{
|
|
static bptrl make(AT addr)
|
|
{
|
|
return (bptrl&)_ptr_base<T, lvl, typename to_be_t<AT>::type>::make(convert_le_be<typename to_be_t<AT>::type>(addr));
|
|
}
|
|
|
|
using _ptr_base<T, lvl, typename to_be_t<AT>::type>::operator=;
|
|
};
|
|
|
|
//BE pointer to BE data
|
|
template<typename T, int lvl = 1, typename AT = u32> struct bptrb : public _ptr_base<typename to_be_t<T>::type, lvl, typename to_be_t<AT>::type>
|
|
{
|
|
static bptrb make(AT addr)
|
|
{
|
|
return (bptrb&)_ptr_base<typename to_be_t<T>::type, lvl, typename to_be_t<AT>::type>::make(convert_le_be<typename to_be_t<AT>::type>(addr));
|
|
}
|
|
|
|
using _ptr_base<typename to_be_t<T>::type, lvl, typename to_be_t<AT>::type>::operator=;
|
|
};
|
|
|
|
//LE pointer to BE data
|
|
template<typename T, int lvl = 1, typename AT = u32> struct lptrb : public _ptr_base<typename to_be_t<T>::type, lvl, AT>
|
|
{
|
|
static lptrb make(AT addr)
|
|
{
|
|
return (lptrb&)_ptr_base<typename to_be_t<T>::type, lvl, AT>::make(addr);
|
|
}
|
|
|
|
using _ptr_base<typename to_be_t<T>::type, lvl, AT>::operator=;
|
|
};
|
|
|
|
//LE pointer to LE data
|
|
template<typename T, int lvl = 1, typename AT = u32> struct lptrl : public _ptr_base<T, lvl, AT>
|
|
{
|
|
static lptrl make(AT addr)
|
|
{
|
|
return (lptrl&)_ptr_base<T, lvl, AT>::make(addr);
|
|
}
|
|
|
|
using _ptr_base<T, lvl, AT>::operator=;
|
|
};
|
|
|
|
namespace ps3
|
|
{
|
|
template<typename T, int lvl = 1, typename AT = u32> struct ptr;
|
|
template<typename T, int lvl = 1, typename AT = u32> struct bptr;
|
|
|
|
//default pointer for HLE functions (LE pointer to BE data)
|
|
template<typename T, int lvl, typename AT> struct ptr : public lptrb<T, lvl, AT>
|
|
{
|
|
static ptr make(AT addr)
|
|
{
|
|
return (ptr&)lptrb<T, lvl, AT>::make(addr);
|
|
}
|
|
|
|
vm::ps3::bptr<T, lvl, AT> to_be() const
|
|
{
|
|
return vm::ps3::bptr<T, lvl, AT>::make(addr());
|
|
}
|
|
|
|
using lptrb<T, lvl, AT>::operator=;
|
|
};
|
|
|
|
//default pointer for HLE structures (BE pointer to BE data)
|
|
template<typename T, int lvl, typename AT> struct bptr : public bptrb<T, lvl, AT>
|
|
{
|
|
static bptr make(AT addr)
|
|
{
|
|
return (bptr&)bptrb<T, lvl, AT>::make(addr);
|
|
}
|
|
|
|
vm::ps3::ptr<T, lvl, AT> to_le() const
|
|
{
|
|
return vm::ps3::ptr<T, lvl, AT>::make(addr());
|
|
}
|
|
|
|
using bptrb<T, lvl, AT>::operator=;
|
|
};
|
|
}
|
|
|
|
namespace psv
|
|
{
|
|
//default pointer for HLE functions & structures (LE pointer to LE data)
|
|
template<typename T, int lvl = 1, typename AT = u32> struct ptr : public lptrl<T, lvl, AT>
|
|
{
|
|
static ptr make(AT addr)
|
|
{
|
|
return (ptr&)lptrl<T, lvl, AT>::make(addr);
|
|
}
|
|
|
|
using lptrl<T, lvl, AT>::operator=;
|
|
};
|
|
}
|
|
|
|
//PS3 emulation is main now, so lets it be as default
|
|
using namespace ps3;
|
|
}
|
|
|
|
namespace fmt
|
|
{
|
|
// external specializations for fmt::format function
|
|
|
|
template<typename T, int lvl, typename AT>
|
|
struct unveil<vm::ps3::ptr<T, lvl, AT>, false>
|
|
{
|
|
typedef typename unveil<AT>::result_type result_type;
|
|
|
|
__forceinline static result_type get_value(const vm::ps3::ptr<T, lvl, AT>& arg)
|
|
{
|
|
return unveil<AT>::get_value(arg.addr());
|
|
}
|
|
};
|
|
|
|
template<typename T, int lvl, typename AT>
|
|
struct unveil<vm::ps3::bptr<T, lvl, AT>, false>
|
|
{
|
|
typedef typename unveil<AT>::result_type result_type;
|
|
|
|
__forceinline static result_type get_value(const vm::ps3::bptr<T, lvl, AT>& arg)
|
|
{
|
|
return unveil<AT>::get_value(arg.addr());
|
|
}
|
|
};
|
|
|
|
template<typename T, int lvl, typename AT>
|
|
struct unveil<vm::psv::ptr<T, lvl, AT>, false>
|
|
{
|
|
typedef typename unveil<AT>::result_type result_type;
|
|
|
|
__forceinline static result_type get_value(const vm::psv::ptr<T, lvl, AT>& arg)
|
|
{
|
|
return unveil<AT>::get_value(arg.addr());
|
|
}
|
|
};
|
|
}
|
|
|
|
// external specializations for PPU GPR (SC_FUNC.h, CB_FUNC.h)
|
|
|
|
template<typename T, bool is_enum>
|
|
struct cast_ppu_gpr;
|
|
|
|
template<typename T, int lvl, typename AT>
|
|
struct cast_ppu_gpr<vm::ps3::ptr<T, lvl, AT>, false>
|
|
{
|
|
__forceinline static u64 to_gpr(const vm::ps3::ptr<T, lvl, AT>& value)
|
|
{
|
|
return value.addr();
|
|
}
|
|
|
|
__forceinline static vm::ps3::ptr<T, lvl, AT> from_gpr(const u64 reg)
|
|
{
|
|
return vm::ps3::ptr<T, lvl, AT>::make(cast_ppu_gpr<AT, std::is_enum<AT>::value>::from_gpr(reg));
|
|
}
|
|
};
|