Finish context saving/restoration

src/emulator/memory_manager.cpp

@@ -84,17 +84,52 @@ static void serialize(utils::buffer_serializer& buffer, const memory_manager::re
 static void deserialize(utils::buffer_deserializer& buffer, memory_manager::reserved_region& region)
 {
 	region.length = static_cast<size_t>(buffer.read<uint64_t>());
-	region.committed_regions = buffer.read_map<uint64_t, memory_manager::committed_region>();
+	buffer.read_map(region.committed_regions);
 }
 
 void memory_manager::serialize_memory_state(utils::buffer_serializer& buffer) const
 {
 	buffer.write_map(this->reserved_regions_);
+
+	if (!this->use_in_place_serialization())
+	{
+		std::vector<uint8_t> data{};
+
+		for (const auto& reserved_region : this->reserved_regions_)
+		{
+			for (const auto& region : reserved_region.second.committed_regions)
+			{
+				data.resize(region.second.length);
+
+				this->read_memory(region.first, data.data(), region.second.length);
+
+				buffer.write(data.data(), region.second.length);
+			}
+		}
+	}
 }
 
 void memory_manager::deserialize_memory_state(utils::buffer_deserializer& buffer)
 {
-	this->reserved_regions_ = buffer.read_map<uint64_t, reserved_region>();
+	buffer.read_map(this->reserved_regions_);
+
+	if (!this->use_in_place_serialization())
+	{
+		std::vector<uint8_t> data{};
+
+		for (const auto& reserved_region : this->reserved_regions_)
+		{
+			for (const auto& region : reserved_region.second.committed_regions)
+			{
+				data.resize(region.second.length);
+
+				buffer.read(data.data(), region.second.length);
+
+				this->map_memory(region.first, region.second.length, region.second.pemissions);
+				this->write_memory(region.first, data.data(), region.second.length);
+			}
+		}
+	}
 }
 
 bool memory_manager::protect_memory(const uint64_t address, const size_t size, const memory_permission permissions,

src/emulator/memory_manager.hpp

@@ -45,8 +45,8 @@ class memory_manager
 		this->write_memory(address, &value, sizeof(value));
 	}
 
-	virtual void read_memory(uint64_t address, void* data, size_t size) = 0;
-	virtual bool try_read_memory(uint64_t address, void* data, size_t size) = 0;
+	virtual void read_memory(uint64_t address, void* data, size_t size) const = 0;
+	virtual bool try_read_memory(uint64_t address, void* data, size_t size) const = 0;
 	virtual void write_memory(uint64_t address, const void* data, size_t size) = 0;
 
 	bool protect_memory(uint64_t address, size_t size, memory_permission permissions,
@@ -75,10 +75,22 @@ class memory_manager
 		return allocation_base;
 	}
 
+	bool use_in_place_serialization() const
+	{
+		return this->in_place_serialization_;
+	}
+
+	void set_in_place_serialization(const bool value)
+	{
+		this->in_place_serialization_ = value;
+	}
+
 private:
 	using reserved_region_map = std::map<uint64_t, reserved_region>;
 	reserved_region_map reserved_regions_{};
 
+	bool in_place_serialization_{false};
+
 	reserved_region_map::iterator find_reserved_region(uint64_t address);
 	bool overlaps_reserved_region(uint64_t address, size_t size) const;