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

vm::ptr refactoring (operators improved) 

vm::pptr, vm::bpptr added for PS3
is_le_t added
sizeof32() added (32-bit sizeof macro)
This commit is contained in:
Nekotekina 2015-06-15 00:52:22 +03:00
parent 8c62a893a9
commit 3064560027
22 changed files with 321 additions and 422 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
Utilities/BEType.h
View File

@ -888,6 +888,14 @@ template<typename T> struct le_t
//}
};
template<typename T> struct is_le_t : public std::integral_constant<bool, false>
{
};
template<typename T> struct is_le_t<le_t<T>> : public std::integral_constant<bool, true>
{
};
template<typename T> struct to_le
{
using type = std::conditional_t<std::is_arithmetic<T>::value || std::is_enum<T>::value, le_t<T>, T>;

2
rpcs3/Emu/ARMv7/ARMv7Callback.h
View File

@ -5,7 +5,7 @@
namespace vm
{
template<typename AT, typename RT, typename... T>
force_inline RT _ptr_base<RT(T...), 1, AT>::operator()(ARMv7Context& context, T... args) const
force_inline RT _ptr_base<RT(T...), AT>::operator()(ARMv7Context& context, T... args) const
{
return psv_func_detail::func_caller<RT, T...>::call(context, vm::cast(this->addr()), args...);
}

564
rpcs3/Emu/Memory/vm_ptr.h
View File

@ -5,7 +5,7 @@ struct ARMv7Context;
namespace vm
{
template<typename T, int lvl = 1, typename AT = u32>
template<typename T, typename AT = u32>
struct _ptr_base
{
AT m_addr;
@ -15,84 +15,14 @@ namespace vm
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)");
static const u32 address_size = 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 + (to_ne_t<AT> count) const { return make(m_addr + count * address_size); }
_ptr_base operator - (to_ne_t<AT> count) const { return make(m_addr - count * address_size); }
force_inline bool operator <(const _ptr_base& right) const { return m_addr < right.m_addr; }
force_inline bool operator <=(const _ptr_base& right) const { return m_addr <= right.m_addr; }
force_inline bool operator >(const _ptr_base& right) const { return m_addr > right.m_addr; }
force_inline bool operator >=(const _ptr_base& right) const { return m_addr >= right.m_addr; }
force_inline bool operator ==(const _ptr_base& right) const { return m_addr == right.m_addr; }
force_inline bool operator !=(const _ptr_base& right) const { return m_addr != right.m_addr; }
force_inline bool operator ==(const nullptr_t& right) const { return m_addr == 0; }
force_inline bool operator !=(const nullptr_t& right) const { return m_addr != 0; }
explicit operator bool() const { return m_addr != 0; }
force_inline _ptr_base<T, lvl - 1, std::conditional_t<is_be_t<T>::value, to_be_t<AT>, AT>> operator *() const
{
AT addr = convert_le_be<AT>(read64(convert_le_be<u32>(m_addr)));
return (_ptr_base<T, lvl - 1, std::conditional_t<is_be_t<T>::value, to_be_t<AT>, AT>>&)addr;
}
force_inline _ptr_base<T, lvl - 1, std::conditional_t<is_be_t<T>::value, to_be_t<AT>, AT>> operator [](AT index) const
{
AT addr = convert_le_be<AT>(read64(convert_le_be<u32>(m_addr + 8 * index)));
return (_ptr_base<T, lvl - 1, std::conditional_t<is_be_t<T>::value, to_be_t<AT>, AT>>&)addr;
}
template<typename AT2> operator _ptr_base<T, lvl, AT2>() const
{
return{ convert_le_be<AT2>(m_addr) };
}
AT addr() const
{
return m_addr;
}
template<typename U> void set(U&& value)
template<typename CT> std::enable_if_t<std::is_assignable<AT&, CT>::value> set(const CT& value)
{
m_addr = convert_le_be<AT>(value);
m_addr = value;
}
template<typename AT2 = AT> static _ptr_base make(const AT2& addr)
@ -100,106 +30,6 @@ namespace vm
return{ convert_le_be<AT>(addr) };
}
_ptr_base& operator = (const _ptr_base& right) = default;
};
template<typename T, typename AT>
struct _ptr_base<T, 1, AT>
{
AT m_addr;
using type = T;
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)");
force_inline static const u32 data_size()
{
return convert_le_be<AT>(sizeof(T));
}
force_inline 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 + (to_ne_t<AT> count) const { return make(convert_le_be<AT>(convert_le_be<decltype(count)>(m_addr) +count * convert_le_be<decltype(count)>(data_size()))); }
_ptr_base operator - (to_ne_t<AT> count) const { return make(convert_le_be<AT>(convert_le_be<decltype(count)>(m_addr) -count * convert_le_be<decltype(count)>(data_size()))); }
force_inline T& operator *() const
{
return vm::get_ref<T>(vm::cast(m_addr));
}
force_inline T& operator [](to_ne_t<AT> index) const
{
return vm::get_ref<T>(vm::cast(m_addr + data_size() * index));
}
force_inline bool operator <(const _ptr_base& right) const { return m_addr < right.m_addr; }
force_inline bool operator <=(const _ptr_base& right) const { return m_addr <= right.m_addr; }
force_inline bool operator >(const _ptr_base& right) const { return m_addr > right.m_addr; }
force_inline bool operator >=(const _ptr_base& right) const { return m_addr >= right.m_addr; }
force_inline bool operator ==(const _ptr_base& right) const { return m_addr == right.m_addr; }
force_inline bool operator !=(const _ptr_base& right) const { return m_addr != right.m_addr; }
force_inline bool operator ==(const nullptr_t& right) const { return m_addr == 0; }
force_inline 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(); }
template<typename AT2> operator _ptr_base<T, 1, AT2>() const
{
return{ convert_le_be<AT2>(m_addr) };
}
AT addr() const
{
return m_addr;
}
template<typename U> void set(U&& value)
{
m_addr = convert_le_be<AT>(value);
}
T* get_ptr() const
{
return vm::get_ptr<T>(vm::cast(m_addr));
@ -209,134 +39,59 @@ namespace vm
{
return vm::priv_ptr<T>(vm::cast(m_addr));
}
template<typename AT2 = AT> static _ptr_base make(const AT2& addr)
{
return{ convert_le_be<AT>(addr) };
}
_ptr_base& operator = (const _ptr_base& right) = default;
};
template<typename AT>
struct _ptr_base<void, 1, AT>
{
AT m_addr;
AT addr() const
{
return m_addr;
}
template<typename U>
void set(U&& value)
{
m_addr = convert_le_be<AT>(value);
}
void* get_ptr() const
{
return vm::get_ptr<void>(vm::cast(m_addr));
}
void* priv_ptr() const
{
return vm::priv_ptr<void>(vm::cast(m_addr));
}
explicit operator void*() const
T* operator ->() const
{
return get_ptr();
}
force_inline bool operator <(const _ptr_base& right) const { return m_addr < right.m_addr; }
force_inline bool operator <=(const _ptr_base& right) const { return m_addr <= right.m_addr; }
force_inline bool operator >(const _ptr_base& right) const { return m_addr > right.m_addr; }
force_inline bool operator >=(const _ptr_base& right) const { return m_addr >= right.m_addr; }
force_inline bool operator ==(const _ptr_base& right) const { return m_addr == right.m_addr; }
force_inline bool operator !=(const _ptr_base& right) const { return m_addr != right.m_addr; }
force_inline bool operator ==(const nullptr_t& right) const { return m_addr == 0; }
force_inline bool operator !=(const nullptr_t& right) const { return m_addr != 0; }
explicit operator bool() const { return m_addr != 0; }
template<typename AT2> operator _ptr_base<void, 1, AT2>() const
template<int X = 0> std::add_lvalue_reference_t<T> operator [](u32 index) const
{
return{ convert_le_be<AT2>(m_addr) };
return vm::get_ref<T>(vm::cast(m_addr + sizeof32(T) * index));
}
template<typename AT2> operator _ptr_base<const void, 1, AT2>() const
template<typename AT2> operator _ptr_base<T, AT2>() const
{
return{ convert_le_be<AT2>(m_addr) };
return{ convert_le_be<AT2>(vm::cast(m_addr)) };
}
template<typename AT2 = AT> static _ptr_base make(const AT2& addr)
template<typename AT2> operator std::enable_if_t<!std::is_const<T>::value, _ptr_base<const T, AT2>>() const
{
return{ convert_le_be<AT>(addr) };
return{ convert_le_be<AT2>(vm::cast(m_addr)) };
}
_ptr_base& operator = (const _ptr_base& right) = default;
};
template<typename AT>
struct _ptr_base<const void, 1, AT>
{
AT m_addr;
AT addr() const
{
return m_addr;
}
template<typename U>
void set(U&& value)
{
m_addr = convert_le_be<AT>(value);
}
const void* get_ptr() const
{
return vm::get_ptr<const void>(vm::cast(m_addr));
}
const void* priv_ptr() const
{
return vm::priv_ptr<const void>(vm::cast(m_addr));
}
explicit operator const void*() const
explicit operator T*() const
{
return get_ptr();
}
force_inline bool operator <(const _ptr_base& right) const { return m_addr < right.m_addr; }
force_inline bool operator <=(const _ptr_base& right) const { return m_addr <= right.m_addr; }
force_inline bool operator >(const _ptr_base& right) const { return m_addr > right.m_addr; }
force_inline bool operator >=(const _ptr_base& right) const { return m_addr >= right.m_addr; }
force_inline bool operator ==(const _ptr_base& right) const { return m_addr == right.m_addr; }
force_inline bool operator !=(const _ptr_base& right) const { return m_addr != right.m_addr; }
force_inline bool operator ==(const nullptr_t& right) const { return m_addr == 0; }
force_inline bool operator !=(const nullptr_t& right) const { return m_addr != 0; }
explicit operator bool() const { return m_addr != 0; }
template<typename AT2> operator _ptr_base<const void, 1, AT2>() const
explicit operator bool() const
{
return{ convert_le_be<AT2>(m_addr) };
return m_addr != 0;
}
template<typename AT2 = AT> static _ptr_base make(const AT2& addr)
{
return{ convert_le_be<AT>(addr) };
}
_ptr_base& operator = (const _ptr_base& right) = default;
};
template<typename AT, typename RT, typename ...T>
struct _ptr_base<RT(T...), 1, AT>
struct _ptr_base<RT(T...), AT>
{
AT m_addr;
typedef RT(type)(T...);
using type = func_def<RT(T...)>;
AT addr() const
{
return m_addr;
}
template<typename CT> std::enable_if_t<std::is_assignable<AT&, CT>::value> set(const CT& value)
{
m_addr = value;
}
template<typename AT2 = AT> static _ptr_base make(const AT2& addr)
{
return{ convert_le_be<AT>(addr) };
}
// defined in CB_FUNC.h, call using specified PPU thread context
RT operator()(PPUThread& CPU, T... args) const;
@ -347,48 +102,31 @@ namespace vm
// defined in CB_FUNC.h, call using current PPU thread context
RT operator()(T... args) const;
AT addr() const
// conversion to function object
operator std::function<type>() const
{
return m_addr;
const u32 addr = vm::cast(m_addr);
return [addr](T... args) -> RT
{
return _ptr_base<RT(T...)>{ addr }(args...);
};
}
template<typename U>
void set(U&& value)
// conversion to another function pointer
template<typename AT2> operator _ptr_base<type, AT2>() const
{
m_addr = convert_le_be<AT>(value);
return{ convert_le_be<AT2>(vm::cast(m_addr)) };
}
force_inline bool operator <(const _ptr_base& right) const { return m_addr < right.m_addr; }
force_inline bool operator <=(const _ptr_base& right) const { return m_addr <= right.m_addr; }
force_inline bool operator >(const _ptr_base& right) const { return m_addr > right.m_addr; }
force_inline bool operator >=(const _ptr_base& right) const { return m_addr >= right.m_addr; }
force_inline bool operator ==(const _ptr_base& right) const { return m_addr == right.m_addr; }
force_inline bool operator !=(const _ptr_base& right) const { return m_addr != right.m_addr; }
force_inline bool operator ==(const nullptr_t& right) const { return m_addr == 0; }
force_inline bool operator !=(const nullptr_t& right) const { return m_addr != 0; }
explicit operator bool() const { return m_addr != 0; }
template<typename AT2> operator _ptr_base<type, 1, AT2>() const
explicit operator bool() const
{
return{ convert_le_be<AT2>(m_addr) };
return m_addr != 0;
}
template<typename AT2 = AT> static _ptr_base make(const AT2& addr)
{
return{ convert_le_be<AT>(addr) };
}
operator const std::function<type>() const
{
const AT addr = convert_le_be<AT>(m_addr);
return [addr](T... args) -> RT { return make(addr)(args...); };
}
_ptr_base& operator = (const _ptr_base& right) = default;
};
template<typename AT, typename RT, typename ...T>
struct _ptr_base<RT(*)(T...), 1, AT>
struct _ptr_base<RT(*)(T...), AT>
{
AT m_addr;
@ -396,39 +134,51 @@ namespace vm
};
// Native endianness pointer to LE data
template<typename T, int lvl = 1, typename AT = u32> using ptrl = _ptr_base<to_le_t<T>, lvl, AT>;
template<typename T, typename AT = u32> using ptrl = _ptr_base<to_le_t<T>, AT>;
// Native endianness pointer to BE data
template<typename T, int lvl = 1, typename AT = u32> using ptrb = _ptr_base<to_be_t<T>, lvl, AT>;
template<typename T, typename AT = u32> using ptrb = _ptr_base<to_be_t<T>, AT>;
// BE pointer to LE data
template<typename T, int lvl = 1, typename AT = u32> using bptrl = _ptr_base<to_le_t<T>, lvl, to_be_t<AT>>;
template<typename T, typename AT = u32> using bptrl = _ptr_base<to_le_t<T>, to_be_t<AT>>;
// BE pointer to BE data
template<typename T, int lvl = 1, typename AT = u32> using bptrb = _ptr_base<to_be_t<T>, lvl, to_be_t<AT>>;
template<typename T, typename AT = u32> using bptrb = _ptr_base<to_be_t<T>, to_be_t<AT>>;
// LE pointer to LE data
template<typename T, int lvl = 1, typename AT = u32> using lptrl = _ptr_base<to_le_t<T>, lvl, to_le_t<AT>>;
template<typename T, typename AT = u32> using lptrl = _ptr_base<to_le_t<T>, to_le_t<AT>>;
// LE pointer to BE data
template<typename T, int lvl = 1, typename AT = u32> using lptrb = _ptr_base<to_be_t<T>, lvl, to_le_t<AT>>;
template<typename T, typename AT = u32> using lptrb = _ptr_base<to_be_t<T>, to_le_t<AT>>;
namespace ps3
{
// default pointer for PS3 HLE functions (Native endianness pointer to BE data)
template<typename T, int lvl = 1, typename AT = u32> using ptr = ptrb<T, lvl, AT>;
template<typename T, typename AT = u32> using ptr = ptrb<T, AT>;
// default pointer to pointer for PS3 HLE functions (Native endianness pointer to BE pointer to BE data)
template<typename T, typename AT = u32, typename AT2 = u32> using pptr = ptr<ptr<T, AT2>, AT>;
// default pointer for PS3 HLE structures (BE pointer to BE data)
template<typename T, int lvl = 1, typename AT = u32> using bptr = bptrb<T, lvl, AT>;
template<typename T, typename AT = u32> using bptr = bptrb<T, AT>;
// default pointer to pointer for PS3 HLE structures (BE pointer to BE pointer to BE data)
template<typename T, typename AT = u32, typename AT2 = u32> using bpptr = bptr<ptr<T, AT2>, AT>;
}
namespace psv
{
// default pointer for PSV HLE functions (Native endianness pointer to LE data)
template<typename T, int lvl = 1, typename AT = u32> using ptr = ptrl<T, lvl, AT>;
template<typename T> using ptr = ptrl<T>;
// default pointer to pointer for PSV HLE functions (Native endianness pointer to LE pointer to LE data)
template<typename T> using pptr = ptr<ptr<T>>;
// default pointer for PSV HLE structures (LE pointer to LE data)
template<typename T, int lvl = 1, typename AT = u32> using lptr = lptrl<T, lvl, AT>;
template<typename T> using lptr = lptrl<T>;
// default pointer to pointer for PSV HLE structures (LE pointer to LE pointer to LE data)
template<typename T> using lpptr = lptr<ptr<T>>;
}
// PS3 emulation is main now, so lets it be as default
@ -436,7 +186,7 @@ namespace vm
struct null_t
{
template<typename T, int lvl, typename AT> operator _ptr_base<T, lvl, AT>() const
template<typename T, typename AT> operator _ptr_base<T, AT>() const
{
return{};
}
@ -444,49 +194,171 @@ namespace vm
// vm::null is convertible to any vm::ptr type as null pointer in virtual memory
static null_t null;
// 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> using if_comparable_t = std::enable_if_t<
std::is_void<T1>::value ||
std::is_void<T2>::value ||
std::is_same<std::remove_cv_t<T1>, std::remove_cv_t<T2>>::value,
RT>;
}
// external specialization for is_be_t<>
// indirection operator for vm::_ptr_base
template<typename T, typename AT> std::enable_if_t<!std::is_void<T>::value, T&> operator *(const vm::_ptr_base<T, AT>& ptr)
{
return vm::get_ref<T>(vm::cast(ptr.m_addr));
}
template<typename T, int lvl, typename AT>
struct is_be_t<vm::_ptr_base<T, lvl, AT>> : public std::integral_constant<bool, is_be_t<AT>::value>
// postfix increment operator for vm::_ptr_base
template<typename T, typename AT> std::enable_if_t<!std::is_void<T>::value, 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> std::enable_if_t<!std::is_void<T>::value, 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> std::enable_if_t<!std::is_void<T>::value, 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> std::enable_if_t<!std::is_void<T>::value, 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> std::enable_if_t<!std::is_void<T>::value, 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> std::enable_if_t<!std::is_void<T>::value, 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;
}
// addition operator for vm::_ptr_base (pointer + integer)
template<typename T, typename AT> std::enable_if_t<!std::is_void<T>::value, vm::_ptr_base<T, AT>> operator +(const vm::_ptr_base<T, AT>& ptr, to_ne_t<AT> count)
{
return{ convert_le_be<AT>(ptr.m_addr + count * sizeof32(T)) };
}
// subtraction operator for vm::_ptr_base (pointer - integer)
template<typename T, typename AT> std::enable_if_t<!std::is_void<T>::value, vm::_ptr_base<T, AT>> operator -(const vm::_ptr_base<T, AT>& ptr, to_ne_t<AT> count)
{
return{ convert_le_be<AT>(ptr.m_addr - count * sizeof32(T)) };
}
// pointer difference operator for vm::_ptr_base
template<typename T1, typename AT1, typename T2, typename AT2> std::enable_if_t<
!std::is_void<T1>::value &&
!std::is_void<T2>::value &&
std::is_same<std::remove_cv_t<T1>, std::remove_cv_t<T2>>::value,
u32> operator -(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
{
return static_cast<u32>((left.m_addr - right.m_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)
{
return left.m_addr == right.m_addr;
}
// 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)
{
return left.m_addr != right.m_addr;
}
// 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)
{
return left.m_addr < right.m_addr;
}
// 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)
{
return left.m_addr <= right.m_addr;
}
// 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)
{
return left.m_addr > right.m_addr;
}
// 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)
{
return left.m_addr >= right.m_addr;
}
// external specialization for is_be_t<> (true if AT is be_t<>)
template<typename T, typename AT>
struct is_be_t<vm::_ptr_base<T, AT>> : public std::integral_constant<bool, is_be_t<AT>::value>
{
};
// external specialization for to_ne_t<>
// external specialization for is_le_t<> (true if AT is le_t<>)
template<typename T, int lvl, typename AT>
struct to_ne<vm::_ptr_base<T, lvl, AT>>
template<typename T, typename AT>
struct is_le_t<vm::_ptr_base<T, AT>> : public std::integral_constant<bool, is_le_t<AT>::value>
{
using type = vm::_ptr_base<T, lvl, to_ne_t<AT>>;
};
// external specialization for to_be_t<>
// external specialization for to_ne_t<> (change AT endianness to native)
template<typename T, int lvl, typename AT>
struct to_be<vm::_ptr_base<T, lvl, AT>>
template<typename T, typename AT>
struct to_ne<vm::_ptr_base<T, AT>>
{
using type = vm::_ptr_base<T, lvl, to_be_t<AT>>;
using type = vm::_ptr_base<T, to_ne_t<AT>>;
};
// external specialization for to_le_t<> (not used)
// external specialization for to_be_t<> (change AT endianness to BE)
template<typename T, int lvl, typename AT>
struct to_le<vm::_ptr_base<T, lvl, AT>>
template<typename T, typename AT>
struct to_be<vm::_ptr_base<T, AT>>
{
using type = vm::_ptr_base<T, lvl, to_le_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>>;
};
namespace fmt
{
// external specialization for fmt::format function
template<typename T, int lvl, typename AT>
struct unveil<vm::_ptr_base<T, lvl, 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, lvl, AT>& arg)
force_inline static result_type get_value(const vm::_ptr_base<T, AT>& arg)
{
return unveil<AT>::get_value(arg.addr());
}
@ -498,17 +370,17 @@ namespace fmt
template<typename T, bool is_enum>
struct cast_ppu_gpr;
template<typename T, int lvl, typename AT>
struct cast_ppu_gpr<vm::_ptr_base<T, lvl, 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, lvl, AT>& value)
force_inline static 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, lvl, AT> from_gpr(const u64 reg)
force_inline static vm::_ptr_base<T, AT> from_gpr(const u64 reg)
{
return vm::_ptr_base<T, lvl, AT>::make(cast_ppu_gpr<AT, std::is_enum<AT>::value>::from_gpr(reg));
return vm::_ptr_base<T, AT>::make(cast_ppu_gpr<AT, std::is_enum<AT>::value>::from_gpr(reg));
}
};
@ -517,16 +389,16 @@ struct cast_ppu_gpr<vm::_ptr_base<T, lvl, AT>, false>
template<typename T, bool is_enum>
struct cast_armv7_gpr;
template<typename T, int lvl, typename AT>
struct cast_armv7_gpr<vm::_ptr_base<T, lvl, 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, lvl, AT>& value)
force_inline static 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, lvl, AT> from_gpr(const u32 reg)
force_inline static vm::_ptr_base<T, AT> from_gpr(const u32 reg)
{
return vm::_ptr_base<T, lvl, AT>::make(cast_armv7_gpr<AT, std::is_enum<AT>::value>::from_gpr(reg));
return vm::_ptr_base<T, AT>::make(cast_armv7_gpr<AT, std::is_enum<AT>::value>::from_gpr(reg));
}
};

21
rpcs3/Emu/Memory/vm_ref.h
View File

@ -9,6 +9,8 @@ namespace vm
static_assert(!std::is_pointer<T>::value, "vm::_ref_base<> error: invalid type (pointer)");
static_assert(!std::is_reference<T>::value, "vm::_ref_base<> error: invalid type (reference)");
static_assert(!std::is_function<T>::value, "vm::_ref_base<> error: invalid type (function)");
static_assert(!std::is_void<T>::value, "vm::_ref_base<> error: invalid type (void)");
AT addr() const
{
@ -98,24 +100,31 @@ namespace vm
namespace psv
{
// default reference for PSV HLE functions (Native endianness reference to LE data)
template<typename T, typename AT = u32> using ref = refl<T, AT>;
template<typename T> using ref = refl<T>;
// default reference for PSV HLE structures (LE reference to LE data)
template<typename T, typename AT = u32> using lref = lrefl<T, AT>;
template<typename T> using lref = lrefl<T>;
}
//PS3 emulation is main now, so lets it be as default
using namespace ps3;
}
// external specialization for is_be_t<>
// external specialization for is_be_t<> (true if AT's endianness is BE)
template<typename T, typename AT>
struct is_be_t<vm::_ref_base<T, AT>> : public std::integral_constant<bool, is_be_t<AT>::value>
{
};
// external specialization for to_ne_t<>
// external specialization for is_le_t<> (true if AT's endianness is LE)
template<typename T, typename AT>
struct is_le_t<vm::_ref_base<T, AT>> : public std::integral_constant<bool, is_le_t<AT>::value>
{
};
// external specialization for to_ne_t<> (change AT's endianness to native)
template<typename T, typename AT>
struct to_ne<vm::_ref_base<T, AT>>
@ -123,7 +132,7 @@ struct to_ne<vm::_ref_base<T, AT>>
using type = vm::_ref_base<T, to_ne_t<AT>>;
};
// external specialization for to_be_t<>
// external specialization for to_be_t<> (change AT's endianness to BE)
template<typename T, typename AT>
struct to_be<vm::_ref_base<T, AT>>
@ -131,7 +140,7 @@ struct to_be<vm::_ref_base<T, AT>>
using type = vm::_ref_base<T, to_be_t<AT>>;
};
// external specialization for to_le_t<> (not used)
// external specialization for to_le_t<> (change AT's endianness to LE)
template<typename T, typename AT>
struct to_le<vm::_ref_base<T, AT>>

32
rpcs3/Emu/Memory/vm_var.h
View File

@ -108,24 +108,24 @@ namespace vm
}
*/
template<typename AT> operator _ptr_base<T, 1, AT>() const
template<typename AT> operator _ptr_base<T, AT>() const
{
return _ptr_base<T, 1, AT>::make(m_addr);
return _ptr_base<T, AT>::make(m_addr);
}
template<typename AT> operator _ptr_base<const T, 1, AT>() const
template<typename AT> operator _ptr_base<const T, AT>() const
{
return _ptr_base<const T, 1, AT>::make(m_addr);
return _ptr_base<const T, AT>::make(m_addr);
}
template<typename AT> operator _ptr_base<void, 1, AT>() const
template<typename AT> operator _ptr_base<void, AT>() const
{
return _ptr_base<void, 1, AT>::make(m_addr);
return _ptr_base<void, AT>::make(m_addr);
}
template<typename AT> operator _ptr_base<const void, 1, AT>() const
template<typename AT> operator _ptr_base<const void, AT>() const
{
return _ptr_base<const void, 1, AT>::make(m_addr);
return _ptr_base<const void, AT>::make(m_addr);
}
operator T&()
@ -614,24 +614,24 @@ namespace vm
}
*/
template<typename AT> operator _ptr_base<T, 1, AT>() const
template<typename AT> operator _ptr_base<T, AT>() const
{
return _ptr_base<T, 1, AT>::make(m_data.addr);
return _ptr_base<T, AT>::make(m_data.addr);
}
template<typename AT> operator _ptr_base<const T, 1, AT>() const
template<typename AT> operator _ptr_base<const T, AT>() const
{
return _ptr_base<const T, 1, AT>::make(m_data.addr);
return _ptr_base<const T, AT>::make(m_data.addr);
}
template<typename AT> operator _ptr_base<void, 1, AT>() const
template<typename AT> operator _ptr_base<void, AT>() const
{
return _ptr_base<void, 1, AT>::make(m_data.addr);
return _ptr_base<void, AT>::make(m_data.addr);
}
template<typename AT> operator _ptr_base<const void, 1, AT>() const
template<typename AT> operator _ptr_base<const void, AT>() const
{
return _ptr_base<const void, 1, AT>::make(m_data.addr);
return _ptr_base<const void, AT>::make(m_data.addr);
}
operator T&()

4
rpcs3/Emu/RSX/CgBinaryProgram.h
View File

@ -301,7 +301,7 @@ public:
m_arb_shader += fmt::format("#%d ", i) + param_type + param_name + param_semantic + param_const + "\n";
offset += sizeof(CgBinaryParameter);
offset += sizeof32(CgBinaryParameter);
}
m_arb_shader += "\n";
@ -355,7 +355,7 @@ public:
m_arb_shader += fmt::format("#%d ", i) + param_type + param_name + param_semantic + param_const + "\n";
offset += sizeof(CgBinaryParameter);
offset += sizeof32(CgBinaryParameter);
}
m_arb_shader += "\n";

4
rpcs3/Emu/SysCalls/CB_FUNC.h
View File

@ -162,7 +162,7 @@ namespace cb_detail
namespace vm
{
template<typename AT, typename RT, typename... T>
force_inline RT _ptr_base<RT(T...), 1, AT>::operator()(PPUThread& CPU, T... args) const
force_inline RT _ptr_base<RT(T...), AT>::operator()(PPUThread& CPU, T... args) const
{
const auto data = vm::get_ptr<be_t<u32>>(vm::cast(m_addr));
const u32 pc = data[0];
@ -172,7 +172,7 @@ namespace vm
}
template<typename AT, typename RT, typename... T>
force_inline RT _ptr_base<RT(T...), 1, AT>::operator()(T... args) const
force_inline RT _ptr_base<RT(T...), AT>::operator()(T... args) const
{
return operator()(GetCurrentPPUThread(), args...);
}

8
rpcs3/Emu/SysCalls/Modules/cellAdec.cpp
View File

@ -792,7 +792,7 @@ s32 cellAdecGetPcm(u32 handle, vm::ptr<float> outBuffer)
return CELL_OK;
}
s32 cellAdecGetPcmItem(u32 handle, vm::ptr<vm::bptr<CellAdecPcmItem>> pcmItem)
s32 cellAdecGetPcmItem(u32 handle, vm::pptr<CellAdecPcmItem> pcmItem)
{
cellAdec.Log("cellAdecGetPcmItem(handle=0x%x, pcmItem=**0x%x)", handle, pcmItem);
@ -821,7 +821,7 @@ s32 cellAdecGetPcmItem(u32 handle, vm::ptr<vm::bptr<CellAdecPcmItem>> pcmItem)
}
pcm->pcmHandle = 0; // ???
pcm->pcmAttr.bsiInfo_addr = pcm.addr() + sizeof(CellAdecPcmItem);
pcm->pcmAttr.bsiInfo_addr = pcm.addr() + sizeof32(CellAdecPcmItem);
pcm->startAddr = 0x00000312; // invalid address (no output)
pcm->size = af.size;
pcm->status = CELL_OK;
@ -833,7 +833,7 @@ s32 cellAdecGetPcmItem(u32 handle, vm::ptr<vm::bptr<CellAdecPcmItem>> pcmItem)
if (adecIsAtracX(adec->type))
{
auto atx = vm::ptr<CellAdecAtracXInfo>::make(pcm.addr() + sizeof(CellAdecPcmItem));
auto atx = vm::ptr<CellAdecAtracXInfo>::make(pcm.addr() + sizeof32(CellAdecPcmItem));
atx->samplingFreq = frame->sample_rate;
atx->nbytes = frame->nb_samples * sizeof(float);
@ -861,7 +861,7 @@ s32 cellAdecGetPcmItem(u32 handle, vm::ptr<vm::bptr<CellAdecPcmItem>> pcmItem)
}
else if (adec->type == CELL_ADEC_TYPE_MP3)
{
auto mp3 = vm::ptr<CellAdecMP3Info>::make(pcm.addr() + sizeof(CellAdecPcmItem));
auto mp3 = vm::ptr<CellAdecMP3Info>::make(pcm.addr() + sizeof32(CellAdecPcmItem));
// TODO
memset(mp3.get_ptr(), 0, sizeof(CellAdecMP3Info));

2
rpcs3/Emu/SysCalls/Modules/cellGifDec.h
View File

@ -153,7 +153,7 @@ struct CellGifDecDataCtrlParam
be_t<u64> outputBytesPerLine;
};
//Custom structs
// Custom structs
struct GifDecoder
{
};

2
rpcs3/Emu/SysCalls/Modules/cellPng.h
View File

@ -162,7 +162,7 @@ struct CellPngPCAL
be_t<u32> equationType;
be_t<u32> numberOfParameters;
vm::bptr<char> unitName;
vm::bptr<char, 2> parameter;
vm::bpptr<char> parameter;
};
struct CellPngUnknownChunk

4
rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
View File

@ -517,7 +517,7 @@ s32 cellPngDecExtDecodeData(
s32 cellPngDecGetUnknownChunks(
CellPngDecMainHandle mainHandle,
CellPngDecSubHandle subHandle,
vm::ptr<vm::bptr<CellPngUnknownChunk>> unknownChunk,
vm::pptr<CellPngUnknownChunk> unknownChunk,
vm::ptr<u32> unknownChunkNumber)
{
UNIMPLEMENTED_FUNC(cellPngDec);
@ -618,7 +618,7 @@ s32 cellPngDecGetTextChunk(
CellPngDecMainHandle mainHandle,
CellPngDecSubHandle subHandle,
vm::ptr<u32> textInfoNum,
vm::ptr<vm::bptr<CellPngTextInfo>> textInfo)
vm::pptr<CellPngTextInfo> textInfo)
{
UNIMPLEMENTED_FUNC(cellPngDec);
return CELL_OK;

6
rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
View File

@ -1263,7 +1263,7 @@ s32 _cellSpursWorkloadFlagReceiver(vm::ptr<CellSpurs> spurs, u32 wid, u32 is_set
return CELL_OK;
}
s32 cellSpursGetWorkloadFlag(vm::ptr<CellSpurs> spurs, vm::ptr<vm::bptr<CellSpursWorkloadFlag>> flag)
s32 cellSpursGetWorkloadFlag(vm::ptr<CellSpurs> spurs, vm::pptr<CellSpursWorkloadFlag> flag)
{
cellSpurs.Warning("%s(spurs_addr=0x%x, flag_addr=0x%x)", __FUNCTION__, spurs.addr(), flag.addr());
@ -2736,7 +2736,7 @@ s32 cellSpursTasksetSetExceptionEventHandler(vm::ptr<CellSpursTaskset> taskset,
return CELL_SPURS_TASK_ERROR_INVAL;
}
if (taskset->m.exception_handler != 0)
if (taskset->m.exception_handler)
{
return CELL_SPURS_TASK_ERROR_BUSY;
}
@ -2996,7 +2996,7 @@ s32 spursTraceInitialize(vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTraceInfo> b
return CELL_SPURS_CORE_ERROR_INVAL;
}
if (spurs->m.traceBuffer != 0)
if (spurs->m.traceBuffer)
{
return CELL_SPURS_CORE_ERROR_STAT;
}

36
rpcs3/Emu/SysCalls/Modules/cellSpurs.h
View File

@ -388,8 +388,8 @@ struct CellSpurs
u8 unk0[0x20]; // 0x00 - SPU exceptionh handler 0x08 - SPU exception handler args
be_t<u64> sem; // 0x20
u8 unk1[0x8];
vm::bptr<CellSpursShutdownCompletionEventHook, 1, u64> hook; // 0x30
vm::bptr<void, 1, u64> hookArg; // 0x38
vm::bptr<CellSpursShutdownCompletionEventHook, u64> hook; // 0x30
vm::bptr<void, u64> hookArg; // 0x38
u8 unk2[0x40];
};
@ -409,7 +409,7 @@ struct CellSpurs
struct WorkloadInfo
{
vm::bptr<const void, 1, u64> addr; // Address of the executable
vm::bptr<const void, u64> addr; // Address of the executable
be_t<u64> arg; // spu argument
be_t<u32> size;
atomic_be_t<u8> uniqueId; // The unique id is the same for all workloads with the same addr
@ -423,8 +423,8 @@ struct CellSpurs
{
static const uint size = 0x10;
vm::bptr<const char, 1, u64> nameClass;
vm::bptr<const char, 1, u64> nameInstance;
vm::bptr<const char, u64> nameClass;
vm::bptr<const char, u64> nameInstance;
};
union
@ -475,7 +475,7 @@ struct CellSpurs
u8 wklStatus2[0x10]; // 0xE0
u8 wklEvent2[0x10]; // 0xF0
_sub_str1 wklF1[0x10]; // 0x100
vm::bptr<CellSpursTraceInfo, 1, u64> traceBuffer; // 0x900
vm::bptr<CellSpursTraceInfo, u64> traceBuffer; // 0x900
be_t<u32> traceStartIndex[6]; // 0x908
u8 unknown7[0x948 - 0x920]; // 0x920
be_t<u64> traceDataSize; // 0x948
@ -641,7 +641,7 @@ struct CellSpursTaskset
struct TaskInfo
{
CellSpursTaskArgument args; // 0x00
vm::bptr<u64, 1, u64> elf_addr; // 0x10
vm::bptr<u64, u64> elf_addr; // 0x10
be_t<u64> context_save_storage_and_alloc_ls_blocks; // 0x18 This is (context_save_storage_addr | allocated_ls_blocks)
CellSpursTaskLsPattern ls_pattern; // 0x20
};
@ -662,7 +662,7 @@ struct CellSpursTaskset
be_t<u128> enabled; // 0x30
be_t<u128> signalled; // 0x40
be_t<u128> waiting; // 0x50
vm::bptr<CellSpurs, 1, u64> spurs; // 0x60
vm::bptr<CellSpurs, u64> spurs; // 0x60
be_t<u64> args; // 0x68
u8 enable_clear_ls; // 0x70
u8 x71; // 0x71
@ -671,8 +671,8 @@ struct CellSpursTaskset
be_t<u32> wid; // 0x74
be_t<u64> x78; // 0x78
TaskInfo task_info[128]; // 0x80
vm::bptr<u64, 1, u64> exception_handler; // 0x1880
vm::bptr<u64, 1, u64> exception_handler_arg; // 0x1888
vm::bptr<u64, u64> exception_handler; // 0x1880
vm::bptr<u64, u64> exception_handler_arg; // 0x1888
be_t<u32> size; // 0x1890
u32 unk2; // 0x1894
u32 event_flag_id1; // 0x1898
@ -750,8 +750,8 @@ struct CellSpursTaskset2
struct TaskInfo
{
CellSpursTaskArgument args;
vm::bptr<u64, 1, u64> elf_addr;
vm::bptr<u64, 1, u64> context_save_storage; // This is (context_save_storage_addr | allocated_ls_blocks)
vm::bptr<u64, u64> elf_addr;
vm::bptr<u64, u64> context_save_storage; // This is (context_save_storage_addr | allocated_ls_blocks)
CellSpursTaskLsPattern ls_pattern;
};
@ -771,7 +771,7 @@ struct CellSpursTaskset2
be_t<u32> enabled_set[4]; // 0x30
be_t<u32> signal_received_set[4]; // 0x40
be_t<u32> waiting_set[4]; // 0x50
vm::bptr<CellSpurs, 1, u64> spurs; // 0x60
vm::bptr<CellSpurs, u64> spurs; // 0x60
be_t<u64> args; // 0x68
u8 enable_clear_ls; // 0x70
u8 x71; // 0x71
@ -780,8 +780,8 @@ struct CellSpursTaskset2
be_t<u32> wid; // 0x74
be_t<u64> x78; // 0x78
TaskInfo task_info[128]; // 0x80
vm::bptr<u64, 1, u64> exception_handler; // 0x1880
vm::bptr<u64, 1, u64> exception_handler_arg; // 0x1888
vm::bptr<u64, u64> exception_handler; // 0x1880
vm::bptr<u64, u64> exception_handler_arg; // 0x1888
be_t<u32> size; // 0x1890
u32 unk2; // 0x1894
u32 event_flag_id1; // 0x1898
@ -895,10 +895,10 @@ struct SpursKernelContext
u8 wklLocPendingContention[0x10]; // 0x190
u8 priority[0x10]; // 0x1A0
u8 x1B0[0x10]; // 0x1B0
vm::bptr<CellSpurs, 1, u64> spurs; // 0x1C0
vm::bptr<CellSpurs, u64> spurs; // 0x1C0
be_t<u32> spuNum; // 0x1C8
be_t<u32> dmaTagId; // 0x1CC
vm::bptr<const void, 1, u64> wklCurrentAddr; // 0x1D0
vm::bptr<const void, u64> wklCurrentAddr; // 0x1D0
be_t<u32> wklCurrentUniqueId; // 0x1D8
be_t<u32> wklCurrentId; // 0x1DC
be_t<u32> exitToKernelAddr; // 0x1E0
@ -932,7 +932,7 @@ struct SpursTasksetContext
u8 tempAreaTaskset[0x80]; // 0x2700
u8 tempAreaTaskInfo[0x30]; // 0x2780
be_t<u64> x27B0; // 0x27B0
vm::bptr<CellSpursTaskset, 1, u64> taskset; // 0x27B8
vm::bptr<CellSpursTaskset, u64> taskset; // 0x27B8
be_t<u32> kernelMgmtAddr; // 0x27C0
be_t<u32> syscallAddr; // 0x27C4
be_t<u32> x27C8; // 0x27C8

2
rpcs3/Emu/SysCalls/Modules/cellSync.cpp
View File

@ -1811,7 +1811,7 @@ s32 cellSyncLFQueueDepth(vm::ptr<CellSyncLFQueue> queue, vm::ptr<u32> depth)
return CELL_OK;
}
s32 _cellSyncLFQueueGetSignalAddress(vm::ptr<const CellSyncLFQueue> queue, vm::ptr<vm::bptr<void>> ppSignal)
s32 _cellSyncLFQueueGetSignalAddress(vm::ptr<const CellSyncLFQueue> queue, vm::pptr<void> ppSignal)
{
cellSync.Log("_cellSyncLFQueueGetSignalAddress(queue=*0x%x, ppSignal=**0x%x)", queue, ppSignal);

8
rpcs3/Emu/SysCalls/Modules/cellSync.h
View File

@ -71,7 +71,7 @@ struct CellSyncRwm
atomic_be_t<data_t> data;
be_t<u32> m_size;
vm::bptr<void, 1, u64> m_buffer;
vm::bptr<void, u64> m_buffer;
};
static_assert(sizeof(CellSyncRwm) == 16, "CellSyncRwm: wrong size");
@ -87,7 +87,7 @@ struct CellSyncQueue
atomic_be_t<data_t> data;
be_t<u32> m_size;
be_t<u32> m_depth;
vm::bptr<u8, 1, u64> m_buffer;
vm::bptr<u8, u64> m_buffer;
be_t<u64> reserved;
};
@ -155,7 +155,7 @@ struct CellSyncLFQueue
be_t<u32> m_size; // 0x10
be_t<u32> m_depth; // 0x14
vm::bptr<u8, 1, u64> m_buffer; // 0x18
vm::bptr<u8, u64> m_buffer; // 0x18
u8 m_bs[4]; // 0x20
be_t<CellSyncQueueDirection> m_direction; // 0x24
be_t<u32> m_v1; // 0x28
@ -164,7 +164,7 @@ struct CellSyncLFQueue
be_t<u16> m_hs1[15]; // 0x32
atomic_be_t<pop2_t> pop2; // 0x50
be_t<u16> m_hs2[15]; // 0x52
vm::bptr<void, 1, u64> m_eaSignal; // 0x70
vm::bptr<void, u64> m_eaSignal; // 0x70
be_t<u32> m_v2; // 0x78
be_t<u32> m_eq_id; // 0x7C

2
rpcs3/Emu/SysCalls/Modules/cellVdec.cpp
View File

@ -795,7 +795,7 @@ s32 _nid_a21aa896(PPUThread& CPU, u32 handle, vm::ptr<const CellVdecPicFormat2>
return cellVdecGetPicture(handle, format, outBuff);
}
s32 cellVdecGetPicItem(u32 handle, vm::ptr<vm::bptr<CellVdecPicItem>> picItem)
s32 cellVdecGetPicItem(u32 handle, vm::pptr<CellVdecPicItem> picItem)
{
cellVdec.Log("cellVdecGetPicItem(handle=0x%x, picItem=**0x%x)", handle, picItem);

2
rpcs3/Emu/SysCalls/Modules/sceNpClans.cpp
View File

@ -377,7 +377,7 @@ int sceNpClansPostChallenge(vm::ptr<SceNpClansRequestHandle> handle, u32 clanId,
if (!sceNpClansInstance.m_bSceNpClansInitialized)
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
if (data != 0)
if (data)
return SCE_NP_CLANS_ERROR_NOT_SUPPORTED;
//todo

8
rpcs3/Emu/SysCalls/lv2/sys_process.cpp
View File

@ -80,7 +80,7 @@ void sys_game_process_exitspawn(vm::ptr<const char> path, u32 argv_addr, u32 env
if (argv_addr)
{
auto argvp = vm::ptr<vm::bptr<const char>>::make(argv_addr);
auto argvp = vm::pptr<const char>::make(argv_addr);
while (argvp && *argvp)
{
argv.push_back(argvp[0].get_ptr());
@ -94,7 +94,7 @@ void sys_game_process_exitspawn(vm::ptr<const char> path, u32 argv_addr, u32 env
if (envp_addr)
{
auto envp = vm::ptr<vm::bptr<const char>>::make(envp_addr);
auto envp = vm::pptr<const char>::make(envp_addr);
while (envp && *envp)
{
env.push_back(envp[0].get_ptr());
@ -154,7 +154,7 @@ void sys_game_process_exitspawn2(vm::ptr<const char> path, u32 argv_addr, u32 en
if (argv_addr)
{
auto argvp = vm::ptr<vm::bptr<const char>>::make(argv_addr);
auto argvp = vm::pptr<const char>::make(argv_addr);
while (argvp && *argvp)
{
argv.push_back(argvp[0].get_ptr());
@ -169,7 +169,7 @@ void sys_game_process_exitspawn2(vm::ptr<const char> path, u32 argv_addr, u32 en
if (envp_addr)
{
auto envp = vm::ptr<vm::bptr<const char>>::make(envp_addr);
auto envp = vm::pptr<const char>::make(envp_addr);
while (envp && *envp)
{
env.push_back(envp[0].get_ptr());

2
rpcs3/Emu/SysCalls/lv2/sys_prx.cpp
View File

@ -140,7 +140,7 @@ s32 sys_prx_load_module(vm::ptr<const char> path, u64 flags, vm::ptr<sys_prx_loa
return prx_load_module(path.get_ptr(), flags, pOpt);
}
s32 sys_prx_load_module_list(s32 count, vm::ptr<const char, 2> path_list, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt, vm::ptr<u32> id_list)
s32 sys_prx_load_module_list(s32 count, vm::pptr<const char> path_list, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt, vm::ptr<u32> id_list)
{
sys_prx.Warning("sys_prx_load_module_list(count=%d, path_list=*0x%x, flags=0x%llx, pOpt=*0x%x, id_list=*0x%x)", count, path_list, flags, pOpt, id_list);

8
rpcs3/Emu/SysCalls/lv2/sys_prx.h
View File

@ -87,7 +87,7 @@ struct sys_prx_relocation_info_t
u8 index_value;
u8 index_addr;
be_t<u32> type;
vm::bptr<void, 1, u64> ptr;
vm::bptr<void, u64> ptr;
};
@ -102,14 +102,14 @@ struct sys_prx_start_module_option_t
{
be_t<u64> size;
be_t<u64> put;
vm::bptr<s32(int argc, vm::ptr<void> argv), 1, u64> entry_point;
vm::bptr<s32(int argc, vm::ptr<void> argv), u64> entry_point;
};
struct sys_prx_stop_module_option_t
{
be_t<u64> size;
be_t<u64> put;
vm::bptr<s32(int argc, vm::ptr<void> argv), 1, u64> entry_point;
vm::bptr<s32(int argc, vm::ptr<void> argv), u64> entry_point;
};
struct sys_prx_unload_module_option_t
@ -135,7 +135,7 @@ REG_ID_TYPE(lv2_prx_t, 0x23); // SYS_PRX_OBJECT
// SysCalls
s32 sys_prx_load_module(vm::ptr<const char> path, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt);
s32 sys_prx_load_module_list(s32 count, vm::ptr<const char, 2> path_list, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt, vm::ptr<u32> id_list);
s32 sys_prx_load_module_list(s32 count, vm::pptr<const char> path_list, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt, vm::ptr<u32> id_list);
s32 sys_prx_load_module_on_memcontainer();
s32 sys_prx_load_module_by_fd();
s32 sys_prx_load_module_on_memcontainer_by_fd();

6
rpcs3/Loader/ELF64.h
View File

@ -40,8 +40,8 @@ namespace loader
be_t<u32> p_type;
be_t<u32> p_flags;
be_t<u64> p_offset;
bptr<void, 1, u64> p_vaddr;
bptr<void, 1, u64> p_paddr;
bptr<void, u64> p_vaddr;
bptr<void, u64> p_paddr;
be_t<u64> p_filesz;
be_t<u64> p_memsz;
be_t<u64> p_align;
@ -52,7 +52,7 @@ namespace loader
be_t<u32> sh_name;
be_t<u32> sh_type;
be_t<u64> sh_flags;
bptr<void, 1, u64> sh_addr;
bptr<void, u64> sh_addr;
be_t<u64> sh_offset;
be_t<u64> sh_size;
be_t<u32> sh_link;

12
rpcs3/stdafx.h
View File

@ -57,7 +57,17 @@ template<typename T> force_inline T align(const T addr, int align)
return (addr + (align - 1)) & ~(align - 1);
}
template<typename T> using func_def = T; // workaround for MSVC bug
template<typename T> struct sizeof32_t
{
static const u32 value = static_cast<u32>(sizeof(T));
static_assert(value == sizeof(T), "sizeof32() error: sizeof() is too big");
};
// return 32 bit sizeof() to avoid widening/narrowing conversions with size_t
#define sizeof32(type) sizeof32_t<type>::value
template<typename T> using func_def = T; // workaround for MSVC bug: `using X = func_def<void()>;` instead of `using X = void();`
#include "Utilities/BEType.h"
#include "Utilities/StrFmt.h"