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));
+}