archive/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-07-13 10:18:40 +12:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Merge branch 'master' of https://github.com/DHrpcs3/rpcs3

Browse source
This commit is contained in:
elisha464 2014-01-18 23:36:42 +02:00
commit 4e4dd43646
36 changed files with 1375 additions and 447 deletions
Download patch file Download diff file Expand all files Collapse all files

172
rpcs3/Emu/Memory/Memory.h
View file

@ -419,12 +419,27 @@ public:
{
}
u32 GetAddr() const { return m_addr; }
__forceinline u32 GetAddr() const { return m_addr; }
bool IsGood() const
__forceinline bool IsGood() const
{
return Memory.IsGoodAddr(m_addr, sizeof(T));
}
__forceinline operator u32() const
{
return m_addr;
}
__forceinline bool operator != (nullptr_t) const
{
return m_addr != 0;
}
__forceinline bool operator == (nullptr_t) const
{
return m_addr == 0;
}
};
template<typename T>
@ -435,6 +450,9 @@ public:
{
}
template<typename NT> operator mem_ptr_t<NT>&() { return (mem_ptr_t<NT>&)*this; }
template<typename NT> operator const mem_ptr_t<NT>&() const { return (const mem_ptr_t<NT>&)*this; }
T* operator -> ()
{
return (T*)&Memory[this->m_addr];
@ -513,8 +531,6 @@ public:
return (const T&)Memory[this->m_addr + sizeof(T) * index];
}
operator bool() const { return this->m_addr == 0; }
bool operator == (mem_ptr_t right) const { return this->m_addr == right.m_addr; }
bool operator != (mem_ptr_t right) const { return this->m_addr != right.m_addr; }
bool operator > (mem_ptr_t right) const { return this->m_addr > right.m_addr; }
@ -530,6 +546,32 @@ public:
bool operator <= (T* right) const { return (T*)&Memory[this->m_addr] <= right; }
};
template<>
class mem_ptr_t<void> : public mem_base_t<u8>
{
public:
mem_ptr_t(u32 addr) : mem_base_t<u8>(addr)
{
}
template<typename NT> operator mem_ptr_t<NT>&() { return (mem_ptr_t<NT>&)*this; }
template<typename NT> operator const mem_ptr_t<NT>&() const { return (const mem_ptr_t<NT>&)*this; }
bool operator == (mem_ptr_t right) const { return this->m_addr == right.m_addr; }
bool operator != (mem_ptr_t right) const { return this->m_addr != right.m_addr; }
bool operator > (mem_ptr_t right) const { return this->m_addr > right.m_addr; }
bool operator < (mem_ptr_t right) const { return this->m_addr < right.m_addr; }
bool operator >= (mem_ptr_t right) const { return this->m_addr >= right.m_addr; }
bool operator <= (mem_ptr_t right) const { return this->m_addr <= right.m_addr; }
bool operator == (void* right) const { return (void*)&Memory[this->m_addr] == right; }
bool operator != (void* right) const { return (void*)&Memory[this->m_addr] != right; }
bool operator > (void* right) const { return (void*)&Memory[this->m_addr] > right; }
bool operator < (void* right) const { return (void*)&Memory[this->m_addr] < right; }
bool operator >= (void* right) const { return (void*)&Memory[this->m_addr] >= right; }
bool operator <= (void* right) const { return (void*)&Memory[this->m_addr] <= right; }
};
template<typename T> static bool operator == (T* left, mem_ptr_t<T> right) { return left == (T*)&Memory[right.GetAddr()]; }
template<typename T> static bool operator != (T* left, mem_ptr_t<T> right) { return left != (T*)&Memory[right.GetAddr()]; }
template<typename T> static bool operator > (T* left, mem_ptr_t<T> right) { return left > (T*)&Memory[right.GetAddr()]; }
@ -551,6 +593,11 @@ public:
return *this;
}
__forceinline T GetValue()
{
return (be_t<T>&)Memory[this->m_addr];
}
operator const T() const
{
return (be_t<T>&)Memory[this->m_addr];
@ -639,6 +686,123 @@ public:
void SetAddr(const u64 addr) { m_addr = addr; }
};
template<typename T> class mem_func_ptr_t;
template<typename RT>
class mem_func_ptr_t<RT (*)()> : public mem_base_t<u64>
{
__forceinline void call_func(bool is_async)
{
Callback cb;
cb.SetAddr(m_addr);
cb.Branch(!is_async);
}
public:
__forceinline void operator()()
{
call_func(false);
}
__forceinline void async()
{
call_func(true);
}
};
template<typename RT, typename T1>
class mem_func_ptr_t<RT (*)(T1)> : public mem_base_t<u64>
{
__forceinline void call_func(bool is_async, T1 a1)
{
Callback cb;
cb.SetAddr(m_addr);
cb.Handle(a1);
cb.Branch(!is_async);
}
public:
__forceinline void operator()(T1 a1)
{
call_func(false, a1);
}
__forceinline void async(T1 a1)
{
call_func(true, a1);
}
};
template<typename RT, typename T1, typename T2>
class mem_func_ptr_t<RT (*)(T1, T2)> : public mem_base_t<u64>
{
__forceinline void call_func(bool is_async, T1 a1, T2 a2)
{
Callback cb;
cb.SetAddr(m_addr);
cb.Handle(a1, a2);
cb.Branch(!is_async);
}
public:
__forceinline void operator()(T1 a1, T2 a2)
{
call_func(false, a1, a2);
}
__forceinline void async(T1 a1, T2 a2)
{
call_func(true, a1, a2);
}
};
template<typename RT, typename T1, typename T2, typename T3>
class mem_func_ptr_t<RT (*)(T1, T2, T3)> : public mem_base_t<u64>
{
__forceinline void call_func(bool is_async, T1 a1, T2 a2, T3 a3)
{
Callback cb;
cb.SetAddr(m_addr);
cb.Handle(a1, a2, a3);
cb.Branch(!is_async);
}
public:
__forceinline void operator()(T1 a1, T2 a2, T3 a3)
{
call_func(false, a1, a2, a3);
}
__forceinline void async(T1 a1, T2 a2, T3 a3)
{
call_func(true, a1, a2, a3);
}
};
template<typename RT, typename T1, typename T2, typename T3, typename T4>
class mem_func_ptr_t<RT (*)(T1, T2, T3, T4)> : public mem_base_t<u64>
{
__forceinline void call_func(bool is_async, T1 a1, T2 a2, T3 a3, T4 a4)
{
Callback cb;
cb.SetAddr(m_addr);
cb.Handle(a1, a2, a3, a4);
cb.Branch(!is_async);
}
public:
__forceinline void operator()(T1 a1, T2 a2, T3 a3, T4 a4)
{
call_func(false, a1, a2, a3, a4);
}
__forceinline void async(T1 a1, T2 a2, T3 a3, T4 a4)
{
call_func(true, a1, a2, a3, a4);
}
};
template<typename T>
class MemoryAllocator
{