Method ReadMemory

core/debuggerstate.cpp:621–675

DataBuffer DebuggerMemory::ReadMemory(uint64_t offset, size_t len)
{
	std::unique_lock<std::recursive_mutex> memoryLock(m_memoryMutex);

	DataBuffer result;

	// ProcessView implements read caching in a manner inspired by CPU cache:
	// Reads are aligned on 256-byte boundaries and 256 bytes long

	// Cache read start: round down addr to nearest 256 byte boundary
	size_t cacheStart = offset & (~0xffLL);
	// Cache read end: round up addr+length to nearest 256 byte boundary
	size_t cacheEnd = (offset + len + 0xFF) & (~0xffLL);
	// List of 256-byte block addresses to read into the cache to fully cover this region
	for (uint64_t block = cacheStart; block < cacheEnd; block += 0x100)
	{
		// If any block cannot be read, then return false
		if (m_errorCache.find(block) != m_errorCache.end())
		{
			return result;
		}

		auto iter = m_valueCache.find(block);
		if (iter == m_valueCache.end())
		{
			// The ReadMemory() function should return the number of bytes read
			DataBuffer buffer = m_state->GetAdapter()->ReadMemory(block, 0x100);
			// TODO: what if the buffer's size is smaller than 0x100
			if (buffer.GetLength() > 0)
			{
				m_valueCache[block] = buffer;
			}
			else
			{
				m_errorCache.insert(block);
				return result;
			}
		}

		DataBuffer cached = m_valueCache[block];
		if (offset + len < block + cached.GetLength())
		{
			// Last block
			cached = cached.GetSlice(0, offset + len - block);
		}
		// Note a block can be both the fist and the last block, so we should not put an else here
		if (offset > block)
		{
			// First block
			cached = cached.GetSlice(offset - block, cached.GetLength() - (offset - block));
		}
		result.Append(cached);
	}
	return result;
}


bool DebuggerMemory::WriteMemory(std::uintptr_t address, const DataBuffer& buffer)