http://code.google.com/p/rpcs3/source/detail?r=44

rpcs3/Emu/Memory/Memory.cpp

@@ -0,0 +1,652 @@
+#include "stdafx.h"
+#include "Memory.h"
+#include "MemoryBlock.h"
+
+MemoryBase Memory;
+
+//MemoryBlock
+MemoryBlock::MemoryBlock()
+{
+	Init();
+}
+
+MemoryBlock::~MemoryBlock()
+{
+	Delete();
+}
+
+void MemoryBlock::Init()
+{
+	range_start = 0;
+	range_size = 0;
+
+	mem = NULL;
+}
+
+void MemoryBlock::InitMemory()
+{
+	safe_delete(mem);
+	mem = new u8[range_size];
+	memset(mem, 0, range_size);
+}
+
+void MemoryBlock::Delete()
+{
+	safe_delete(mem);
+	Init();
+}
+
+u64 MemoryBlock::FixAddr(const u64 addr) const
+{
+	return addr - GetStartAddr();
+}
+
+bool MemoryBlock::GetMemFromAddr(void* dst, const u64 addr, const u32 size)
+{
+	if(!IsMyAddress(addr)) return false;
+	if(FixAddr(addr) + size > GetSize()) return false;
+	memcpy(dst, &mem[FixAddr(addr)], size);
+	return true;
+}
+
+bool MemoryBlock::SetMemFromAddr(void* src, const u64 addr, const u32 size)
+{
+	if(!IsMyAddress(addr)) return false;
+	if(FixAddr(addr) + size > GetSize()) return false;
+	memcpy(&mem[FixAddr(addr)], src, size);
+	return true;
+}
+
+bool MemoryBlock::GetMemFFromAddr(void* dst, const u64 addr)
+{
+	if(!IsMyAddress(addr)) return false;
+	dst = &mem[FixAddr(addr)];
+	return true;
+}
+
+u8* MemoryBlock::GetMemFromAddr(const u64 addr)
+{
+	if(!IsMyAddress(addr)) return NULL;
+
+	return &mem[FixAddr(addr)];
+}
+
+MemoryBlock* MemoryBlock::SetRange(const u64 start, const u32 size)
+{
+	range_start = start;
+	range_size = size;
+
+	InitMemory();
+	return this;
+}
+
+bool MemoryBlock::SetNewSize(const u32 size)
+{
+	if(range_size >= size) return false;
+
+	u8* new_mem = (u8*)realloc(mem, size);
+	if(!new_mem)
+	{
+		ConLog.Error("Not enought free memory");
+		Emu.Pause();
+		return false;
+	}
+
+	mem = new_mem;
+	range_size = size;
+
+	return true;
+}
+
+bool MemoryBlock::IsMyAddress(const u64 addr)
+{
+	return addr >= GetStartAddr() && addr < GetEndAddr();
+}
+
+__forceinline const u8 MemoryBlock::FastRead8(const u64 addr) const
+{
+	return mem[addr];
+}
+
+__forceinline const u16 MemoryBlock::FastRead16(const u64 addr) const
+{
+	return ((u16)FastRead8(addr) << 8) | (u16)FastRead8(addr + 1);
+}
+
+__forceinline const u32 MemoryBlock::FastRead32(const u64 addr) const
+{
+	return ((u32)FastRead16(addr) << 16) | (u32)FastRead16(addr + 2);
+}
+
+__forceinline const u64 MemoryBlock::FastRead64(const u64 addr) const
+{
+	return ((u64)FastRead32(addr) << 32) | (u64)FastRead32(addr + 4);
+}
+
+__forceinline const u128 MemoryBlock::FastRead128(const u64 addr)
+{
+	u128 ret;
+	ret.hi = FastRead64(addr);
+	ret.lo = FastRead64(addr + 8);
+	return ret;
+}
+
+bool MemoryBlock::Read8(const u64 addr, u8* value)
+{
+	if(!IsMyAddress(addr))
+	{
+		*value = 0;
+		return false;
+	}
+
+	*value = FastRead8(FixAddr(addr));
+	return true;
+}
+
+bool MemoryBlock::Read16(const u64 addr, u16* value)
+{
+	if(!IsMyAddress(addr))
+	{
+		*value = 0;
+		return false;
+	}
+
+	*value = FastRead16(FixAddr(addr));
+	return true;
+}
+
+bool MemoryBlock::Read32(const u64 addr, u32* value)
+{
+	if(!IsMyAddress(addr))
+	{
+		*value = 0;
+		return false;
+	}
+
+	*value = FastRead32(FixAddr(addr));
+	return true;
+}
+
+bool MemoryBlock::Read64(const u64 addr, u64* value)
+{
+	if(!IsMyAddress(addr))
+	{
+		*value = 0;
+		return false;
+	}
+
+	*value = FastRead64(FixAddr(addr));
+	return true;
+}
+
+bool MemoryBlock::Read128(const u64 addr, u128* value)
+{
+	if(!IsMyAddress(addr))
+	{
+		*value = u128::From32(0);
+		return false;
+	}
+
+	*value = FastRead128(FixAddr(addr));
+	return true;
+}
+
+__forceinline void MemoryBlock::FastWrite8(const u64 addr, const u8 value)
+{
+	mem[addr] = value;
+}
+
+__forceinline void MemoryBlock::FastWrite16(const u64 addr, const u16 value)
+{
+	FastWrite8(addr, (u8)(value >> 8));
+	FastWrite8(addr+1, (u8)value);
+}
+
+__forceinline void MemoryBlock::FastWrite32(const u64 addr, const u32 value)
+{
+	FastWrite16(addr, (u16)(value >> 16));
+	FastWrite16(addr+2, (u16)value);
+}
+
+__forceinline void MemoryBlock::FastWrite64(const u64 addr, const u64 value)
+{
+	FastWrite32(addr, (u32)(value >> 32));
+	FastWrite32(addr+4, (u32)value);
+}
+
+__forceinline void MemoryBlock::FastWrite128(const u64 addr, const u128 value)
+{
+	FastWrite64(addr, value.hi);
+	FastWrite64(addr+8, value.lo);
+}
+
+bool MemoryBlock::Write8(const u64 addr, const u8 value)
+{
+	if(!IsMyAddress(addr)) return false;
+
+	FastWrite8(FixAddr(addr), value);
+	return true;
+}
+
+bool MemoryBlock::Write16(const u64 addr, const u16 value)
+{
+	if(!IsMyAddress(addr)) return false;
+
+	FastWrite16(FixAddr(addr), value);
+	return true;
+}
+
+bool MemoryBlock::Write32(const u64 addr, const u32 value)
+{
+	if(!IsMyAddress(addr)) return false;
+
+	FastWrite32(FixAddr(addr), value);
+	return true;
+}
+
+bool MemoryBlock::Write64(const u64 addr, const u64 value)
+{
+	if(!IsMyAddress(addr)) return false;
+
+	FastWrite64(FixAddr(addr), value);
+	return true;
+}
+
+bool MemoryBlock::Write128(const u64 addr, const u128 value)
+{
+	if(!IsMyAddress(addr)) return false;
+
+	FastWrite128(FixAddr(addr), value);
+	return true;
+}
+
+//NullMemoryBlock
+bool NullMemoryBlock::Read8(const u64 addr, u8* WXUNUSED(value))
+{
+	ConLog.Error("Read8 from null block: [%08llx]", addr);
+	Emu.Pause();
+	return false;
+}
+
+bool NullMemoryBlock::Read16(const u64 addr, u16* WXUNUSED(value))
+{
+	ConLog.Error("Read16 from null block: [%08llx]", addr);
+	Emu.Pause();
+	return false;
+}
+
+bool NullMemoryBlock::Read32(const u64 addr, u32* WXUNUSED(value))
+{
+	ConLog.Error("Read32 from null block: [%08llx]", addr);
+	Emu.Pause();
+	return false;
+}
+
+bool NullMemoryBlock::Read64(const u64 addr, u64* WXUNUSED(value))
+{
+	ConLog.Error("Read64 from null block: [%08llx]", addr);
+	Emu.Pause();
+	return false;
+}
+
+bool NullMemoryBlock::Read128(const u64 addr, u128* WXUNUSED(value))
+{
+	ConLog.Error("Read128 from null block: [%08llx]", addr);
+	Emu.Pause();
+	return false;
+}
+
+bool NullMemoryBlock::Write8(const u64 addr, const u8 value)
+{
+	ConLog.Error("Write8 to null block: [%08llx]: %x", addr, value);
+	Emu.Pause();
+	return false;
+}
+
+bool NullMemoryBlock::Write16(const u64 addr, const u16 value)
+{
+	ConLog.Error("Write16 to null block: [%08llx]: %x", addr, value);
+	Emu.Pause();
+	return false;
+}
+
+bool NullMemoryBlock::Write32(const u64 addr, const u32 value)
+{
+	ConLog.Error("Write32 to null block: [%08llx]: %x", addr, value);
+	Emu.Pause();
+	return false;
+}
+
+bool NullMemoryBlock::Write64(const u64 addr, const u64 value)
+{
+	ConLog.Error("Write64 to null block: [%08llx]: %llx", addr, value);
+	Emu.Pause();
+	return false;
+}
+
+bool NullMemoryBlock::Write128(const u64 addr, const u128 value)
+{
+	ConLog.Error("Write128 to null block: [%08llx]: %llx_%llx", addr, value.hi, value.lo);
+	Emu.Pause();
+	return false;
+}
+
+//DynamicMemoryBlock
+DynamicMemoryBlock::DynamicMemoryBlock() : m_point(0)
+	, m_max_size(0)
+{
+}
+
+bool DynamicMemoryBlock::IsInMyRange(const u64 addr)
+{
+	return addr >= GetStartAddr() && addr < GetStartAddr() + GetSize();
+}
+
+bool DynamicMemoryBlock::IsInMyRange(const u64 addr, const u32 size)
+{
+	return IsInMyRange(addr) && IsInMyRange(addr + size - 1);
+}
+
+bool DynamicMemoryBlock::IsMyAddress(const u64 addr)
+{
+	for(u32 i=0; i<m_used_mem.GetCount(); ++i)
+	{
+		if(addr >= m_used_mem[i].addr && addr < m_used_mem[i].addr + m_used_mem[i].size)
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+MemoryBlock* DynamicMemoryBlock::SetRange(const u64 start, const u32 size)
+{
+	m_max_size = size;
+	MemoryBlock::SetRange(start, 4);
+	m_point = GetStartAddr();
+
+	return this;
+}
+
+void DynamicMemoryBlock::Delete()
+{
+	m_used_mem.Clear();
+	m_free_mem.Clear();
+	m_point = 0;
+	m_max_size = 0;
+
+	MemoryBlock::Delete();
+}
+
+void DynamicMemoryBlock::UpdateSize(u64 addr, u32 size)
+{
+	u32 used_size = addr + size - GetStartAddr();
+	if(used_size > GetUsedSize()) SetNewSize(used_size);
+}
+
+void DynamicMemoryBlock::CombineFreeMem()
+{
+	if(m_free_mem.GetCount() < 2) return;
+
+	for(u32 i1=0; i1<m_free_mem.GetCount(); ++i1)
+	{
+		MemBlockInfo& u1 = m_free_mem[i1];
+		for(u32 i2=i1+1; i2<m_free_mem.GetCount(); ++i2)
+		{
+			const MemBlockInfo u2 = m_free_mem[i2];
+			if(u1.addr + u1.size != u2.addr) continue;
+			u1.size += u2.size;
+			m_free_mem.RemoveAt(i2);
+			break;
+		}
+	}
+}
+
+bool DynamicMemoryBlock::Alloc(u64 addr, u32 size)
+{
+	if(!IsInMyRange(addr, size) || IsMyAddress(addr) || IsMyAddress(addr + size - 1))
+	{
+		assert(0);
+		return false;
+	}
+
+	if(addr == m_point)
+	{
+		UpdateSize(m_point, size);
+
+		m_used_mem.AddCpy(MemBlockInfo(m_point, size));
+		memset(mem + (m_point - GetStartAddr()), 0, size);
+
+		m_point += size;
+
+		return true;
+	}
+
+	if(addr > m_point)
+	{
+		u64 free_mem_addr = GetStartAddr();
+
+		if(free_mem_addr != addr)
+		{
+			for(u32 i=0; i<m_free_mem.GetCount(); ++i)
+			{
+				if(m_free_mem[i].addr >= free_mem_addr && m_free_mem[i].addr < addr)
+				{
+					free_mem_addr = m_free_mem[i].addr + m_free_mem[i].size;
+				}
+			}
+
+			for(u32 i=0; i<m_used_mem.GetCount(); ++i)
+			{
+				if(m_used_mem[i].addr >= free_mem_addr && m_used_mem[i].addr < addr)
+				{
+					free_mem_addr = m_used_mem[i].addr + m_used_mem[i].size;
+				}
+			}
+
+			m_free_mem.AddCpy(MemBlockInfo(free_mem_addr, addr - GetStartAddr()));
+		}
+
+		UpdateSize(addr, size);
+
+		m_used_mem.AddCpy(MemBlockInfo(addr, size));
+		memset(mem + (addr - GetStartAddr()), 0, size);
+
+		m_point = addr + size;
+
+		return true;
+	}
+
+	for(u32 i=0; i<m_free_mem.GetCount(); ++i)
+	{
+		if(addr < m_free_mem[i].addr || addr >= m_free_mem[i].addr + m_free_mem[i].size
+			|| m_free_mem[i].size < size) continue;
+
+		if(m_free_mem[i].addr != addr)
+		{
+			m_free_mem.AddCpy(MemBlockInfo(m_free_mem[i].addr, addr - m_free_mem[i].addr));
+		}
+
+		if(m_free_mem[i].size != size)
+		{
+			m_free_mem.AddCpy(MemBlockInfo(m_free_mem[i].addr + size, m_free_mem[i].size - size));
+		}
+
+		m_free_mem.RemoveAt(i);
+		m_used_mem.AddCpy(MemBlockInfo(addr, size));
+
+		memset(mem + (addr - GetStartAddr()), 0, size);
+		return true;
+	}
+
+	return false;
+}
+
+u64 DynamicMemoryBlock::Alloc(u32 size)
+{
+	for(u32 i=0; i<m_free_mem.GetCount(); ++i)
+	{
+		if(m_free_mem[i].size < size) continue;
+
+		const u32 addr = m_free_mem[i].addr;
+
+		if(m_free_mem[i].size != size)
+		{
+			m_free_mem.AddCpy(MemBlockInfo(addr + size, m_free_mem[i].size - size));
+		}
+
+		m_free_mem.RemoveAt(i);
+		m_used_mem.AddCpy(MemBlockInfo(addr, size));
+
+		memset(mem + (addr - GetStartAddr()), 0, size);
+		return addr;
+	}
+
+	UpdateSize(m_point, size);
+
+	MemBlockInfo res(m_point, size);
+	m_used_mem.AddCpy(res);
+	memset(mem + (m_point - GetStartAddr()), 0, size);
+
+	m_point += size;
+
+	return res.addr;
+}
+
+bool DynamicMemoryBlock::Alloc()
+{
+	return Alloc(GetSize() - GetUsedSize()) != 0;
+}
+
+bool DynamicMemoryBlock::Free(u64 addr)
+{
+	for(u32 i=0; i<m_used_mem.GetCount(); ++i)
+	{
+		if(addr == m_used_mem[i].addr)
+		{
+			m_free_mem.AddCpy(MemBlockInfo(m_used_mem[i].addr, m_used_mem[i].size));
+			m_used_mem.RemoveAt(i);
+			CombineFreeMem();
+			return true;
+		}
+	}
+
+	return false;
+}
+
+//MemoryBase
+void MemoryBase::Write8(u64 addr, const u8 data)
+{
+	GetMemByAddr(addr).Write8(addr, data);
+}
+
+void MemoryBase::Write16(u64 addr, const u16 data)
+{
+	GetMemByAddr(addr).Write16(addr, data);
+}
+
+void MemoryBase::Write32(u64 addr, const u32 data)
+{
+	GetMemByAddr(addr).Write32(addr, data);
+}
+
+void MemoryBase::Write64(u64 addr, const u64 data)
+{
+	GetMemByAddr(addr).Write64(addr, data);
+}
+
+void MemoryBase::Write128(u64 addr, const u128 data)
+{
+	GetMemByAddr(addr).Write128(addr, data);
+}
+
+bool MemoryBase::Write8NN(u64 addr, const u8 data)
+{
+	if(!IsGoodAddr(addr)) return false;
+	Write8(addr, data);
+	return true;
+}
+
+bool MemoryBase::Write16NN(u64 addr, const u16 data)
+{
+	if(!IsGoodAddr(addr, 2)) return false;
+	Write16(addr, data);
+	return true;
+}
+
+bool MemoryBase::Write32NN(u64 addr, const u32 data)
+{
+	if(!IsGoodAddr(addr, 4)) return false;
+	Write32(addr, data);
+	return true;
+}
+
+bool MemoryBase::Write64NN(u64 addr, const u64 data)
+{
+	if(!IsGoodAddr(addr, 8)) return false;
+	Write64(addr, data);
+	return true;
+}
+
+bool MemoryBase::Write128NN(u64 addr, const u128 data)
+{
+	if(!IsGoodAddr(addr, 16)) return false;
+	Write128(addr, data);
+	return true;
+}
+
+u8 MemoryBase::Read8(u64 addr)
+{
+	MemoryBlock& mem = GetMemByAddr(addr);
+	if(mem.IsNULL())
+	{
+		mem.Read8(addr, NULL);
+		return 0;
+	}
+	return mem.FastRead8(mem.FixAddr(addr));
+}
+
+u16 MemoryBase::Read16(u64 addr)
+{
+	MemoryBlock& mem = GetMemByAddr(addr);
+	if(mem.IsNULL())
+	{
+		mem.Read16(addr, NULL);
+		return 0;
+	}
+	return mem.FastRead16(mem.FixAddr(addr));
+}
+
+u32 MemoryBase::Read32(u64 addr)
+{
+	MemoryBlock& mem = GetMemByAddr(addr);
+	if(mem.IsNULL())
+	{
+		mem.Read32(addr, NULL);
+		return 0;
+	}
+	return mem.FastRead32(mem.FixAddr(addr));
+}
+
+u64 MemoryBase::Read64(u64 addr)
+{
+	MemoryBlock& mem = GetMemByAddr(addr);
+	if(mem.IsNULL())
+	{
+		mem.Read64(addr, NULL);
+		return 0;
+	}
+	return mem.FastRead64(mem.FixAddr(addr));
+}
+
+u128 MemoryBase::Read128(u64 addr)
+{
+	MemoryBlock& mem = GetMemByAddr(addr);
+	if(mem.IsNULL())
+	{
+		mem.Read128(addr, NULL);
+		return u128::From32(0);
+	}
+	return mem.FastRead128(mem.FixAddr(addr));
+}

rpcs3/Emu/Memory/Memory.h

@@ -0,0 +1,415 @@
+#pragma once
+#include "MemoryBlock.h"
+
+class MemoryFlags
+{
+	struct Flag
+	{
+		const u64 addr;
+		const u64 waddr;
+		const u64 fid;
+
+		Flag(const u64 _addr, const u64 _waddr, const u64 _fid)
+			: addr(_addr)
+			, waddr(_waddr)
+			, fid(_fid)
+		{
+		}
+	};
+
+	Array<Flag> m_memflags;
+
+public:
+	void Add(const u64 addr, const u64 waddr, const u64 fid) {m_memflags.Add(new Flag(addr, waddr, fid));}
+	void Clear() { m_memflags.Clear(); }
+
+	bool IsFlag(const u64 addr, u64& waddr, u64& fid)
+	{
+		for(u32 i=0; i<GetCount(); i++)
+		{
+			if(m_memflags[i].addr != addr) continue;
+			fid = m_memflags[i].fid;
+			waddr = m_memflags[i].waddr;
+			return true;
+		}
+
+		return false;
+	}
+
+	u64 GetCount() const { return m_memflags.GetCount(); }
+};
+
+class MemoryBase
+{
+	NullMemoryBlock NullMem;
+
+public:
+	ArrayF<MemoryBlock> MemoryBlocks;
+
+	DynamicMemoryBlock MainMem;
+	DynamicMemoryBlock PRXMem;
+	DynamicMemoryBlock RSXCMDMem;
+	DynamicMemoryBlock MmaperMem;
+	DynamicMemoryBlock RSXFBMem;
+	DynamicMemoryBlock StackMem;
+	MemoryBlock SpuRawMem;
+	MemoryBlock SpuThrMem;
+
+	MemoryFlags MemFlags;
+
+	bool m_inited;
+
+	MemoryBase()
+	{
+		m_inited = false;
+	}
+
+	~MemoryBase()
+	{
+		Close();
+	}
+
+	static u16 Reverse16(const u16 val)
+	{
+		return ((val >> 8) & 0xff) | ((val << 8) & 0xff00);
+	}
+
+	static u32 Reverse32(const u32 val)
+	{
+		return
+			((val >> 24) & 0x000000ff) |
+			((val >>  8) & 0x0000ff00) |
+			((val <<  8) & 0x00ff0000) |
+			((val << 24) & 0xff000000);
+	}
+
+	static u64 Reverse64(const u64 val)
+	{
+		return
+			((val >> 56) & 0x00000000000000ff) |
+			((val >> 40) & 0x000000000000ff00) |
+			((val >> 24) & 0x0000000000ff0000) |
+			((val >>  8) & 0x00000000ff000000) |
+			((val <<  8) & 0x000000ff00000000) |
+			((val << 24) & 0x0000ff0000000000) |
+			((val << 40) & 0x00ff000000000000) |
+			((val << 56) & 0xff00000000000000);
+	}
+
+	template<typename T> static T Reverse(T val)
+	{
+		switch(sizeof(T))
+		{
+		case 2: return Reverse16(val);
+		case 4: return Reverse32(val);
+		case 8: return Reverse64(val);
+		}
+
+		return val;
+	}
+
+	MemoryBlock& GetMemByNum(const u8 num)
+	{
+		if(num >= MemoryBlocks.GetCount()) return NullMem;
+		return MemoryBlocks.Get(num);
+	}
+
+	MemoryBlock& GetMemByAddr(const u64 addr)
+	{
+		for(uint i=0; i<MemoryBlocks.GetCount(); ++i)
+		{
+			if(MemoryBlocks.Get(i).IsMyAddress(addr)) return MemoryBlocks[i];
+		}
+
+		return NullMem;
+	}
+
+	u8* GetMemFromAddr(const u64 addr)
+	{
+		return GetMemByAddr(addr).GetMemFromAddr(addr);
+	}
+
+	void* VirtualToRealAddr(const u64 vaddr)
+	{
+		return GetMemFromAddr(vaddr);
+	}
+
+	u64 RealToVirtualAddr(const void* addr)
+	{
+		const u32 raddr = (u32)addr;
+		for(u32 i=0; i<MemoryBlocks.GetCount(); ++i)
+		{
+			MemoryBlock& b = MemoryBlocks[i];
+			const u32 baddr = (u32)b.GetMem();
+
+			if(raddr >= baddr && raddr < baddr + b.GetSize())
+			{
+				return b.GetStartAddr() + (raddr - baddr);
+			}
+		}
+
+		return 0;
+	}
+
+	bool InitSpuRawMem(const u32 max_spu_raw)
+	{
+		//if(SpuRawMem.GetSize()) return false;
+
+		MemoryBlocks.Add(SpuRawMem.SetRange(0xe0000000, 0x100000 * max_spu_raw));
+
+		return true;
+	}
+
+	void Init()
+	{
+		if(m_inited) return;
+		m_inited = true;
+
+		ConLog.Write("Initing memory...");
+
+		MemoryBlocks.Add(MainMem.SetRange(0x00010000, 0x2FFF0000));
+		MemoryBlocks.Add(PRXMem.SetRange(0x30000000, 0x10000000));
+		MemoryBlocks.Add(RSXCMDMem.SetRange(0x40000000, 0x10000000));
+		//MemoryBlocks.Add(MmaperMem.SetRange(0xB0000000, 0x10000000));
+		MemoryBlocks.Add(RSXFBMem.SetRange(0xC0000000, 0x10000000));
+		MemoryBlocks.Add(StackMem.SetRange(0xD0000000, 0x10000000));
+		//MemoryBlocks.Add(SpuRawMem.SetRange(0xE0000000, 0x10000000));
+		//MemoryBlocks.Add(SpuThrMem.SetRange(0xF0000000, 0x10000000));
+
+		ConLog.Write("Memory initialized.");
+	}
+
+	bool IsGoodAddr(const u64 addr)
+	{
+		for(uint i=0; i<MemoryBlocks.GetCount(); ++i)
+		{
+			if(MemoryBlocks[i].IsMyAddress(addr)) return true;
+		}
+
+		return false;
+	}
+
+	bool IsGoodAddr(const u64 addr, const u32 size)
+	{
+		for(uint i=0; i<MemoryBlocks.GetCount(); ++i)
+		{
+			if( MemoryBlocks[i].IsMyAddress(addr) &&
+				MemoryBlocks[i].IsMyAddress(addr + size - 1) ) return true;
+		}
+
+		return false;
+	}
+
+	void Close()
+	{
+		if(!m_inited) return;
+		m_inited = false;
+
+		ConLog.Write("Closing memory...");
+
+		for(uint i=0; i<MemoryBlocks.GetCount(); ++i)
+		{
+			MemoryBlocks[i].Delete();
+		}
+
+		MemoryBlocks.Clear();
+		MemFlags.Clear();
+	}
+
+	void Reset()
+	{
+		if(!m_inited) return;
+
+		ConLog.Write("Resetting memory...");
+		Close();
+		Init();
+	}
+
+	void Write8(const u64 addr, const u8 data);
+	void Write16(const u64 addr, const u16 data);
+	void Write32(const u64 addr, const u32 data);
+	void Write64(const u64 addr, const u64 data);
+	void Write128(const u64 addr, const u128 data);
+
+	bool Write8NN(const u64 addr, const u8 data);
+	bool Write16NN(const u64 addr, const u16 data);
+	bool Write32NN(const u64 addr, const u32 data);
+	bool Write64NN(const u64 addr, const u64 data);
+	bool Write128NN(const u64 addr, const u128 data);
+
+	u8 Read8(const u64 addr);
+	u16 Read16(const u64 addr);
+	u32 Read32(const u64 addr);
+	u64 Read64(const u64 addr);
+	u128 Read128(const u64 addr);
+
+	template<typename T> void WriteData(const u64 addr, const T* data)
+	{
+		memcpy(GetMemFromAddr(addr), data, sizeof(T));
+	}
+
+	template<typename T> void WriteData(const u64 addr, const T data)
+	{
+		*(T*)GetMemFromAddr(addr) = data;
+	}
+
+	wxString ReadString(const u64 addr, const u64 len)
+	{
+		wxString ret = wxEmptyString;
+
+		if(len) memcpy(wxStringBuffer(ret, len), GetMemFromAddr(addr), len);
+
+		return ret;
+	}
+
+	wxString ReadString(const u64 addr)
+	{
+		wxString buf = wxEmptyString;
+
+		for(u32 i=addr; ; i++)
+		{
+			const u8 c = Read8(i);
+			if(c == 0) break;
+			buf += c;
+		}
+
+		return buf;
+	}
+
+	void WriteString(const u64 addr, const wxString& str)
+	{
+		for(u32 i=0; i<str.Length(); i++)
+		{
+			Write8(addr + i, str[i]);
+		}
+
+		Write8(addr + str.Length(), 0);
+	}
+
+	static u64 AlignAddr(const u64 addr, const u64 align)
+	{
+		return (addr + (align-1)) & ~(align-1);
+	}
+
+	u32 GetUserMemTotalSize()
+	{
+		return PRXMem.GetSize();
+	}
+
+	u32 GetUserMemAvailSize()
+	{
+		return PRXMem.GetSize() - PRXMem.GetUsedSize();
+	}
+
+	u64 Alloc(const u32 size, const u32 align)
+	{
+		return PRXMem.Alloc(AlignAddr(size, align));
+	}
+
+	bool Free(const u64 addr)
+	{
+		return PRXMem.Free(addr);
+	}
+
+	u8& operator[] (const u64 vaddr) { return *GetMemFromAddr(vaddr); }
+};
+
+extern MemoryBase Memory;
+
+template<typename T> class mem_t
+{
+	u64 addr;
+	const u64 iaddr;
+
+public:
+	mem_t(u64 _addr)
+		: addr(_addr)
+		, iaddr(_addr)
+	{
+	}
+
+	void operator = (T right)
+	{
+		switch(sizeof(T))
+		{
+		case 1: Memory.Write8(addr, right); return;
+		case 2: Memory.Write16(addr, right); return;
+		case 4: Memory.Write32(addr, right); return;
+		case 8: Memory.Write64(addr, right); return;
+		}
+
+		ConLog.Error("Bad mem_t size! (%d : 0x%llx)", sizeof(T), addr);
+	}
+
+	operator u8() const { return Memory.Read8(addr); }
+	operator u16() const { return Memory.Read16(addr); }
+	operator u32() const { return Memory.Read32(addr); }
+	operator u64() const { return Memory.Read64(addr); }
+
+	/*
+	u64 operator += (u64 right)
+	{
+		addr += right;
+		return addr;
+	}
+	*/
+	u64 operator += (T right)
+	{
+		*this = right;
+		addr += sizeof(T);
+		return addr;
+	}
+
+	T operator [] (u64 i)
+	{
+		const u64 offset = i*sizeof(T);
+		addr += offset;
+		const T ret = *this;
+		addr -= offset;
+		return ret;
+	}
+
+	void Reset() { addr = iaddr; }
+	u64 GetCurAddr() const { return addr; }
+	u64 GetAddr() const { return iaddr; }
+	u64 SetOffset(const u32 offset) { return addr += offset; }
+};
+
+class mem_class_t
+{
+	u64 addr;
+	const u64 iaddr;
+
+public:
+	mem_class_t(u64 _addr)
+		: addr(_addr)
+		, iaddr(_addr)
+	{
+	}
+
+	template<typename T> u64 operator += (T right)
+	{
+		mem_t<T> m(addr);
+		m = right;
+		addr += sizeof(T);
+		return addr;
+	}
+
+	template<typename T> operator T()
+	{
+		mem_t<T> m(addr);
+		const T ret = m;
+		addr += sizeof(T);
+		return ret;
+	}
+
+	void Reset() { addr = iaddr; }
+	u64 GetCurAddr() const { return addr; }
+	u64 GetAddr() const { return iaddr; }
+	void SetAddr(const u64 _addr) { addr = _addr; }
+};
+
+typedef mem_t<u8> mem8_t;
+typedef mem_t<u16> mem16_t;
+typedef mem_t<u32> mem32_t;
+typedef mem_t<u64> mem64_t;

rpcs3/Emu/Memory/MemoryBlock.h

@@ -0,0 +1,122 @@
+#pragma once
+
+struct MemBlockInfo
+{
+	u64 addr;
+	u32 size;
+
+	MemBlockInfo(u64 _addr, u32 _size)
+		: addr(_addr)
+		, size(_size)
+	{
+	}
+};
+
+class MemoryBlock
+{
+protected:
+	u8* mem;
+	u64 range_start;
+	u64 range_size;
+
+public:
+	MemoryBlock();
+	~MemoryBlock();
+
+private:
+	void Init();
+	void InitMemory();
+
+public:
+	virtual void Delete();
+
+	virtual bool IsNULL() { return false; }
+
+	u64 FixAddr(const u64 addr) const;
+
+	bool GetMemFromAddr(void* dst, const u64 addr, const u32 size);
+	bool SetMemFromAddr(void* src, const u64 addr, const u32 size);
+	bool GetMemFFromAddr(void* dst, const u64 addr);
+	u8* GetMemFromAddr(const u64 addr);
+
+	virtual MemoryBlock* SetRange(const u64 start, const u32 size);
+	bool SetNewSize(const u32 size);
+	virtual bool IsMyAddress(const u64 addr);
+
+	__forceinline const u8 FastRead8(const u64 addr) const;
+	__forceinline const u16 FastRead16(const u64 addr) const;
+	__forceinline const u32 FastRead32(const u64 addr) const;
+	__forceinline const u64 FastRead64(const u64 addr) const;
+	__forceinline const u128 FastRead128(const u64 addr);
+
+	virtual bool Read8(const u64 addr, u8* value);
+	virtual bool Read16(const u64 addr, u16* value);
+	virtual bool Read32(const u64 addr, u32* value);
+	virtual bool Read64(const u64 addr, u64* value);
+	virtual bool Read128(const u64 addr, u128* value);
+
+	__forceinline void FastWrite8(const u64 addr, const u8 value);
+	__forceinline void FastWrite16(const u64 addr, const u16 value);
+	__forceinline void FastWrite32(const u64 addr, const u32 value);
+	__forceinline void FastWrite64(const u64 addr, const u64 value);
+	__forceinline void FastWrite128(const u64 addr, const u128 value);
+
+	virtual bool Write8(const u64 addr, const u8 value);
+	virtual bool Write16(const u64 addr, const u16 value);
+	virtual bool Write32(const u64 addr, const u32 value);
+	virtual bool Write64(const u64 addr, const u64 value);
+	virtual bool Write128(const u64 addr, const u128 value);
+
+	const u64 GetStartAddr() const { return range_start; }
+	const u64 GetEndAddr() const { return range_start + range_size - 1; }
+	virtual const u32 GetSize() const { return range_size; }
+	void* GetMem() const { return mem; }
+};
+
+class NullMemoryBlock : public MemoryBlock
+{
+	virtual bool IsNULL() { return true; }
+	virtual bool IsMyAddress(const u64 addr) { return true; }
+
+	virtual bool Read8(const u64 addr, u8* value);
+	virtual bool Read16(const u64 addr, u16* value);
+	virtual bool Read32(const u64 addr, u32* value);
+	virtual bool Read64(const u64 addr, u64* value);
+	virtual bool Read128(const u64 addr, u128* value);
+
+	virtual bool Write8(const u64 addr, const u8 value);
+	virtual bool Write16(const u64 addr, const u16 value);
+	virtual bool Write32(const u64 addr, const u32 value);
+	virtual bool Write64(const u64 addr, const u64 value);
+	virtual bool Write128(const u64 addr, const u128 value);
+};
+
+class DynamicMemoryBlock : public MemoryBlock
+{
+	Array<MemBlockInfo> m_used_mem;
+	Array<MemBlockInfo> m_free_mem;
+	u64 m_point;
+	u32 m_max_size;
+
+public:
+	DynamicMemoryBlock();
+
+	const u32 GetSize() const { return m_max_size; }
+	const u32 GetUsedSize() const { return range_size; }
+
+	bool IsInMyRange(const u64 addr);
+	bool IsInMyRange(const u64 addr, const u32 size);
+	bool IsMyAddress(const u64 addr);
+
+	MemoryBlock* SetRange(const u64 start, const u32 size);
+
+	virtual void Delete();
+
+	void UpdateSize(u64 addr, u32 size);
+	void CombineFreeMem();
+
+	bool Alloc(u64 addr, u32 size);
+	u64 Alloc(u32 size);
+	bool Alloc();
+	bool Free(u64 addr);
+};