Move to Endian agnostic read/write functions; add kernel

src/Cafe/CafeSystem.cpp

@@ -1011,7 +1011,9 @@ namespace CafeSystem
 		nn::temp::save(writer);
 		nn::aoc::save(writer);
 		osLib_save(writer);
-		iosu::fsa::Save(writer);
+		iosu::kernel::save(writer);
+		iosu::fsa::save(writer);
+		iosu::odm::save(writer);
 
 		FileStream* stream = FileStream::createFile(path);
 		stream->writeData(writer.getResult().data(), writer.getResult().size_bytes());
@@ -1042,7 +1044,9 @@ namespace CafeSystem
 		nn::temp::restore(reader);
 		nn::aoc::restore(reader);
 		osLib_restore(reader);
-		iosu::fsa::Restore(reader);
+		iosu::kernel::restore(reader);
+		iosu::fsa::restore(reader);
+		iosu::odm::restore(reader);
 
 		cemuLog_log(LogType::SaveStates, "Loaded state from {}.", path);
 

src/Cafe/Filesystem/fsc.cpp

@@ -737,31 +737,31 @@ void fsc_init()
 }
 
 template <>
-void MemStreamWriter::writeBE<FSCVirtualFile::FSCDirIteratorState>(const FSCVirtualFile::FSCDirIteratorState& v)
+void MemStreamWriter::write<FSCVirtualFile::FSCDirIteratorState>(const FSCVirtualFile::FSCDirIteratorState& v)
 {
-	writeBE(v.index);
+	write(v.index);
 	writePODVector(v.dirEntries);
 }
 
 template <>
-void MemStreamReader::readBE(FSCVirtualFile::FSCDirIteratorState& v)
+void MemStreamReader::read(FSCVirtualFile::FSCDirIteratorState& v)
 {
-	readBE(v.index);
+	read(v.index);
 	readPODVector(v.dirEntries);
 }
 
 void FSCVirtualFile::Save(MemStreamWriter& writer)
 {
 	writer.writeBool(dirIterator != nullptr);
-	if (dirIterator) writer.writeBE(*dirIterator);
+	if (dirIterator) writer.write(*dirIterator);
 	writer.writeBool(m_isAppend);
 }
 
 void FSCVirtualFileDirectoryIterator::Save(MemStreamWriter& writer)
 {
-	writer.writeBE<uint32>((uint32)Child::DIRECTORY_ITERATOR);
+	writer.write<uint32>((uint32)Child::DIRECTORY_ITERATOR);
-	writer.writeBE(m_path);
+	writer.write(m_path);
-	writer.writeBE<uint32>(m_folders.size());
+	writer.write<uint32>(m_folders.size());
 	for (auto& folder : m_folders)
 	{
 		folder->Save(writer);
@@ -774,13 +774,13 @@ void FSCVirtualFileDirectoryIterator::Save(MemStreamWriter& writer)
 FSCVirtualFile* FSCVirtualFile::Restore(MemStreamReader& reader)
 {
 	FSCVirtualFile* file;
-	switch ((Child)reader.readBE<uint32>())
+	switch ((Child)reader.read<uint32>())
 	{
 		case Child::DIRECTORY_ITERATOR:
 		{
-			std::string path = reader.readBE<std::string>();
+			std::string path = reader.read<std::string>();
 			std::vector<FSCVirtualFile*> folders{};
-			size_t size = reader.readBE<uint32>();
+			size_t size = reader.read<uint32>();
 			for (size_t i = 0; i < size; i++)
 			{
 				folders.push_back(Restore(reader));
@@ -790,11 +790,11 @@ FSCVirtualFile* FSCVirtualFile::Restore(MemStreamReader& reader)
 		}
 		case Child::HOST:
 		{
-			std::string path = reader.readBE<std::string>();
+			std::string path = reader.read<std::string>();
-			FSC_ACCESS_FLAG flags = (FSC_ACCESS_FLAG)reader.readBE<uint32>();
+			FSC_ACCESS_FLAG flags = (FSC_ACCESS_FLAG)reader.read<uint32>();
 			sint32 status{};
 			file = FSCVirtualFile_Host::OpenFile(path, flags, status);
-			file->fscSetSeek(reader.readBE<uint64>());
+			file->fscSetSeek(reader.read<uint64>());
 			break;
 		}
 		default:
@@ -803,7 +803,7 @@ FSCVirtualFile* FSCVirtualFile::Restore(MemStreamReader& reader)
 	if (reader.readBool())
 	{
 		file->dirIterator = new FSCDirIteratorState;
-		reader.readBE(*file->dirIterator);
+		reader.read(*file->dirIterator);
 	}
 	reader.readBool(file->m_isAppend);
 	return file;

src/Cafe/Filesystem/fsc.h

@@ -38,6 +38,7 @@ DEFINE_ENUM_FLAG_OPERATORS(FSC_ACCESS_FLAG);
 #define FSC_STATUS_ALREADY_EXISTS		(3)
 // note: Unlike the native Wii U filesystem, FSC does not provide separate error codes for NOT_A_FILE and NOT_A_DIRECTORY
 // to determine them manually, open with both modes (file and dir) and check the type
+
 #define FSC_MAX_DIR_NAME_LENGTH			(256)
 #define FSC_MAX_DEVICE_PATH_LENGTH		((std::max)(260,FSA_PATH_SIZE_MAX))	// max length for FSC device paths (should be at least equal or greater than supported by host filesystem)
 

src/Cafe/Filesystem/fscDeviceHostFS.cpp

@@ -299,9 +299,9 @@ bool FSCDeviceHostFS_Mount(std::string_view mountPath, std::string_view hostTarg
 
 void FSCVirtualFile_Host::Save(MemStreamWriter& writer)
 {
-	writer.writeBE<uint32>((uint32)Child::HOST);
+	writer.write<uint32>((uint32)Child::HOST);
-	writer.writeBE(m_path->string());
+	writer.write(m_path->string());
-	writer.writeBE((uint32)m_accessFlags);
+	writer.write((uint32)m_accessFlags);
-	writer.writeBE(m_seek);
+	writer.write(m_seek);
 	FSCVirtualFile::Save(writer);
 }

src/Cafe/HW/MMU/MMU.cpp

@@ -81,28 +81,28 @@ MMURange* memory_getMMURangeByAddress(MPTR address)
 }
 
 template<>
-void MemStreamWriter::writeBE(const MMURange& v)
+void MemStreamWriter::write(const MMURange& v)
 {
 	writeBool(v.m_isMapped);
-	writeBE(v.baseAddress);
+	write(v.baseAddress);
-	writeBE((uint8)v.areaId);
+	write((uint8)v.areaId);
-	writeBE((uint8)v.flags);
+	write((uint8)v.flags);
-	writeBE(v.name);
+	write(v.name);
-	writeBE(v.size);
+	write(v.size);
-	writeBE(v.initSize);
+	write(v.initSize);
 }
 
 template <>
-void MemStreamReader::readBE(MMURange& mmuRange)
+void MemStreamReader::read(MMURange& mmuRange)
 {
 	bool needsMapped = readBool();
 	mmuRange.m_isMapped = false;
-	mmuRange.baseAddress = readBE<uint32>();
+	mmuRange.baseAddress = read<uint32>();
-	mmuRange.areaId = (MMU_MEM_AREA_ID)readBE<uint8>();
+	mmuRange.areaId = (MMU_MEM_AREA_ID)read<uint8>();
-	mmuRange.flags = (MMURange::MFLAG)readBE<uint8>();
+	mmuRange.flags = (MMURange::MFLAG)read<uint8>();
-	mmuRange.name = readBE<std::string>();
+	mmuRange.name = read<std::string>();
-	mmuRange.size = readBE<uint32>();
+	mmuRange.size = read<uint32>();
-	mmuRange.initSize = readBE<uint32>();
+	mmuRange.initSize = read<uint32>();
 	if (needsMapped)
 		mmuRange.mapMem();
 }
@@ -443,7 +443,7 @@ void memory_Serialize(MemStreamWriter& s)
 {
 	for (auto& itr : g_mmuRanges)
 	{
-		s.writeBE(*itr);
+		s.write(*itr);
 		if (itr->isMapped())
 		{
 			s.writeData(memory_base + itr->getBase(), itr->getSize());
@@ -455,7 +455,7 @@ void memory_Deserialize(MemStreamReader& s)
 {
 	for (auto& itr : g_mmuRanges)
 	{
-		s.readBE<MMURange>(*itr);
+		s.read<MMURange>(*itr);
 		if (itr->isMapped())
 		{
 			s.readData(memory_base + itr->getBase(), itr->getSize());

src/Cafe/IOSU/ODM/iosu_odm.cpp

@@ -133,6 +133,26 @@ namespace iosu
 			s_threadInitialized = false;
 		}
 
+		void save(MemStreamWriter& s)
+		{
+			s.writeSection("iosu_odm");
+			s.writeAtomic(s_requestStop);
+			s.writeAtomic(s_isRunning);
+			s.writeAtomic(s_threadInitialized);
+			s.write(s_msgQueueId);
+			s.writeMPTR(_s_msgBuffer);
+		}
+
+		void restore(MemStreamReader& s)
+		{
+			s.readSection("iosu_odm");
+			s.readAtomic(s_requestStop);
+			s.readAtomic(s_isRunning);
+			s.readAtomic(s_threadInitialized);
+			s.read(s_msgQueueId);
+			s.readMPTR(_s_msgBuffer);
+		}
+
 		void Initialize()
 		{
 			if (s_isRunning.exchange(true))

src/Cafe/IOSU/ODM/iosu_odm.h

@@ -4,6 +4,9 @@ namespace iosu
 {
 	namespace odm
 	{
+		void save(MemStreamWriter& s);
+		void restore(MemStreamReader& s);
+
 		void Initialize();
 		void Shutdown();
 	}

src/Cafe/IOSU/PDM/iosu_pdm.cpp

@@ -352,6 +352,15 @@ namespace iosu
 			}
 		}
 
+		void save(MemStreamWriter& s)
+		{
+
+		}
+		void restore(MemStreamReader& s)
+		{
+
+		}
+
 		void Initialize()
 		{
 			// todo - add support for per-account handling

src/Cafe/IOSU/PDM/iosu_pdm.h

@@ -4,6 +4,9 @@ namespace iosu
 {
 	namespace pdm
 	{
+		void save(MemStreamWriter& s);
+		void restore(MemStreamReader& s);
+
 		void Initialize();
 		void StartTrackingTime(uint64 titleId);
 		void Stop();

src/Cafe/IOSU/fsa/iosu_fsa.cpp

@@ -911,26 +911,26 @@ namespace iosu
 } // namespace iosu
 
 template <>
-void MemStreamWriter::writeBE(const iosu::fsa::FSAClient& v)
+void MemStreamWriter::write(const iosu::fsa::FSAClient& v)
 {
-	writeBE(v.workingDirectory);
+	write(v.workingDirectory);
 	writeBool(v.isAllocated);
 }
 
 template <>
-void MemStreamReader::readBE(iosu::fsa::FSAClient& v)
+void MemStreamReader::read(iosu::fsa::FSAClient& v)
 {
-	readBE(v.workingDirectory);
+	read(v.workingDirectory);
 	readBool(v.isAllocated);
 }
 
 template <>
-void MemStreamWriter::writeBE(const iosu::fsa::_FSAHandleTable& v)
+void MemStreamWriter::write(const iosu::fsa::_FSAHandleTable& v)
 {
-	writeBE(v.m_currentCounter);
+	write(v.m_currentCounter);
 	for (sint32 i = 0; i < v.m_handleTableSize; i++)
 	{
-		writeBE(v.m_handleTable[i].handleCheckValue);
+		write(v.m_handleTable[i].handleCheckValue);
 		writeBool(v.m_handleTable[i].isAllocated);
 
 		writeBool(v.m_handleTable[i].fscFile != nullptr);
@@ -939,12 +939,12 @@ void MemStreamWriter::writeBE(const iosu::fsa::_FSAHandleTable& v)
 }
 
 template <>
-void MemStreamReader::readBE(iosu::fsa::_FSAHandleTable& v)
+void MemStreamReader::read(iosu::fsa::_FSAHandleTable& v)
 {
-	readBE(v.m_currentCounter);
+	read(v.m_currentCounter);
 	for (sint32 i = 0; i < v.m_handleTableSize; i++)
 	{
-		readBE(v.m_handleTable[i].handleCheckValue);
+		read(v.m_handleTable[i].handleCheckValue);
 		readBool(v.m_handleTable[i].isAllocated);
 
 		if (readBool()) v.m_handleTable[i].fscFile = FSCVirtualFile::Restore(*this);
@@ -955,32 +955,32 @@ namespace iosu
 {
 	namespace fsa
 	{
-		void Save(MemStreamWriter& s)
+		void save(MemStreamWriter& s)
 		{
 			s.writeSection("iosu_fsa");
-			s.writeBE(sFSAIoMsgQueue);
+			s.write(sFSAIoMsgQueue);
 			s.writeMPTR(_m_sFSAIoMsgQueueMsgBuffer);
 
 			for (sint32 i = 0; i < sFSAClientArraySize; i++)
 			{
-				s.writeBE(sFSAClientArray[i]);
+				s.write(sFSAClientArray[i]);
 			}
-			s.writeBE(sDirHandleTable);
+			s.write(sDirHandleTable);
-			s.writeBE(sFileHandleTable);
+			s.write(sFileHandleTable);
 		}
 
-		void Restore(MemStreamReader& s)
+		void restore(MemStreamReader& s)
 		{
 			s.readSection("iosu_fsa");
-			s.readBE(sFSAIoMsgQueue);
+			s.read(sFSAIoMsgQueue);
 			s.readMPTR(_m_sFSAIoMsgQueueMsgBuffer);
 
 			for (sint32 i = 0; i < sFSAClientArraySize; i++)
 			{
-				s.readBE(sFSAClientArray[i]);
+				s.read(sFSAClientArray[i]);
 			}
-			s.readBE(sDirHandleTable);
+			s.read(sDirHandleTable);
-			s.readBE(sFileHandleTable);
+			s.read(sFileHandleTable);
 		}
 	} // namespace fsa
 } // namespace iosu

src/Cafe/IOSU/fsa/iosu_fsa.h

@@ -214,7 +214,7 @@ namespace iosu
 		void Initialize();
 		void Shutdown();
 
-		void Save(MemStreamWriter& writer);
+		void save(MemStreamWriter& writer);
-		void Restore(MemStreamReader& reader);
+		void restore(MemStreamReader& reader);
 	} // namespace fsa
 } // namespace iosu

src/Cafe/IOSU/kernel/iosu_kernel.cpp

@@ -217,11 +217,13 @@ namespace iosu
 
 		/* IPC */
 		
+		static constexpr size_t IOCTLV_VECTOR_ARRAY_SIZE = 8;
+
 		struct IOSDispatchableCommand
 		{
 			// stores a copy of incoming IPC requests with some extra information required for replies
 			IPCCommandBody body; // our dispatchable copy
-			IPCIoctlVector vecCopy[8]; // our copy of the Ioctlv vector array
+			IPCIoctlVector vecCopy[IOCTLV_VECTOR_ARRAY_SIZE]; // our copy of the Ioctlv vector array
 			IPCCommandBody* originalBody; // the original command that was sent to us
 			uint32 ppcCoreIndex;
 			IOSDevHandle replyHandle; // handle for outgoing replies
@@ -547,6 +549,8 @@ namespace iosu
 			return IOS_ERROR_OK;
 		}
 
+
+
 		void Initialize()
 		{
 			_IPCInitDispatchablePool();
@@ -554,3 +558,129 @@ namespace iosu
 
 	}
 }
+
+template <>
+void MemStreamWriter::write(const iosu::kernel::IOSMessageQueue& v)
+{
+	write(v.ukn00);
+	write(v.ukn04);
+	write(v.numQueuedMessages);
+	write(v.readIndex);
+	write(v.msgArraySize);
+	writeMPTR(v.msgArray);
+	write(v.queueHandle);
+	write(v.ukn1C);
+}
+
+template <>
+void MemStreamReader::read(iosu::kernel::IOSMessageQueue& v)
+{
+	read(v.ukn00);
+	read(v.ukn04);
+	read(v.numQueuedMessages);
+	read(v.readIndex);
+	read(v.msgArraySize);
+	readMPTR(v.msgArray);
+	read(v.queueHandle);
+	read(v.ukn1C);
+}
+
+template <>
+void MemStreamWriter::write(const iosu::kernel::IOSResourceManager& v)
+{
+	writeBool(v.isSet);
+	write(v.path);
+	write(v.msgQueueId);
+}
+
+template <>
+void MemStreamReader::read(iosu::kernel::IOSResourceManager& v)
+{
+	readBool(v.isSet);
+	read(v.path);
+	read(v.msgQueueId);
+}
+
+template <>
+void MemStreamWriter::write(const iosu::kernel::IPCActiveDeviceHandle& v)
+{
+	writeBool(v.isSet);
+	write(v.handleCheckValue);
+	write(v.path);
+	write(v.msgQueueId);
+	writeBool(v.hasDispatchTargetHandle);
+	write(v.dispatchTargetHandle);
+}
+
+template <>
+void MemStreamReader::read(iosu::kernel::IPCActiveDeviceHandle& v)
+{
+	readBool(v.isSet);
+	read(v.handleCheckValue);
+	read(v.path);
+	read(v.msgQueueId);
+	readBool(v.hasDispatchTargetHandle);
+	read(v.dispatchTargetHandle);
+}
+
+namespace iosu
+{
+	namespace kernel
+	{
+		void save(MemStreamWriter& s)
+		{
+			s.write<uint32>(sMsgQueuePool.size());
+			for (const auto& i : sMsgQueuePool)
+				s.write(i);
+
+			s.write<uint32>(sDeviceResources.size());
+			for (const auto& i : sDeviceResources)
+				s.write(i);
+
+			s.writeMPTR(sIPCDispatchableCommandPool);
+
+			size_t sIPCFreeDispatchableCommandsSize = sIPCFreeDispatchableCommands.size();
+			s.write<uint32>(sIPCFreeDispatchableCommandsSize);
+			while (sIPCFreeDispatchableCommandsSize)
+			{
+				IOSDispatchableCommand* front = sIPCFreeDispatchableCommands.front();
+				sIPCFreeDispatchableCommands.pop();
+				s.writePTR(front);
+				sIPCFreeDispatchableCommands.push(front);
+				sIPCFreeDispatchableCommandsSize--;
+			}
+
+			s.write<uint32>(MAX_NUM_ACTIVE_DEV_HANDLES);
+			for (uint32 i = 0; i < MAX_NUM_ACTIVE_DEV_HANDLES; i++)
+				s.write(sActiveDeviceHandles[i]);
+		}
+
+		void restore(MemStreamReader& s)
+		{
+			cemu_assert(s.read<uint32>() == sMsgQueuePool.size());
+			for (auto& i : sMsgQueuePool)
+				s.read(i);
+
+			cemu_assert(s.read<uint32>() == sDeviceResources.size());
+			for (auto& i : sDeviceResources)
+				s.read(i);
+
+			s.readMPTR(sIPCDispatchableCommandPool);
+
+			size_t sIPCFreeDispatchableCommandsSize = s.read<uint32>();
+			cemu_assert(sIPCFreeDispatchableCommandsSize == sIPCFreeDispatchableCommands.size());
+			while (!sIPCFreeDispatchableCommands.empty())
+				sIPCFreeDispatchableCommands.pop();
+			for (uint32 i = 0; i < sIPCFreeDispatchableCommandsSize; i++)
+			{
+				IOSDispatchableCommand* cmd = nullptr;
+				s.readPTR(cmd);
+				sIPCFreeDispatchableCommands.push(cmd);
+			}
+			
+			cemu_assert(s.read<uint32>() == MAX_NUM_ACTIVE_DEV_HANDLES);
+			for (uint32 i = 0; i < MAX_NUM_ACTIVE_DEV_HANDLES; i++)
+				s.read(sActiveDeviceHandles[i]);
+		}
+	}
+}

src/Cafe/IOSU/kernel/iosu_kernel.h

@@ -18,6 +18,9 @@ namespace iosu
 
 		void IPCSubmitFromCOS(uint32 ppcCoreIndex, IPCCommandBody* cmd);
 
+		void save(MemStreamWriter& s);
+		void restore(MemStreamReader& s);
+
 		void Initialize();
 	}
 }

src/Cafe/OS/libs/coreinit/coreinit.cpp

@@ -321,8 +321,8 @@ void coreinit_save(MemStreamWriter& s)
 	s.writeSection("coreinit");
 
 	s.writeData(gCoreinitData, sizeof(coreinitData_t));
-	s.writeBE(placeholderFont);
+	s.write(placeholderFont);
-	s.writeBE(placeholderFontSize);
+	s.write(placeholderFontSize);
 
 	coreinit_Init_Save(s);
 	coreinit::SysHeap_Save(s);
@@ -353,8 +353,8 @@ void coreinit_restore(MemStreamReader& s)
 		coreinit::__OSDeleteAllActivePPCThreads();
 
 	s.readData(gCoreinitData, sizeof(coreinitData_t));
-	s.readBE(placeholderFont);
+	s.read(placeholderFont);
-	s.readBE(placeholderFontSize);
+	s.read(placeholderFontSize);
 
 	coreinit_Init_Restore(s);
 	coreinit::SysHeap_Restore(s);

src/Cafe/OS/libs/coreinit/coreinit_Alarm.cpp

@@ -314,13 +314,13 @@ namespace coreinit
 		s.writeMPTR(_g_alarmThreadStack);
 		s.writeMPTR(_g_alarmThreadName);
 
-		s.writeBE(coreinit_getOSTime());
+		s.write(coreinit_getOSTime());
 
-		s.writeBE((uint64)g_activeAlarms.size());
+		s.write((uint64)g_activeAlarms.size());
 		for (auto& itr : g_activeAlarms)
 		{
-			s.writeBE(memory_getVirtualOffsetFromPointer(itr.first));
+			s.write(memory_getVirtualOffsetFromPointer(itr.first));
-			s.writeBE(itr.second->getNextFire());
+			s.write(itr.second->getNextFire());
 		}
 	}
 
@@ -336,12 +336,12 @@ namespace coreinit
 		s.readMPTR(_g_alarmThreadName);
 
 		uint64 currentTime = coreinit_getOSTime();
-		uint64_t timeOffset = currentTime - s.readBE<uint64_t>();
+		uint64_t timeOffset = currentTime - s.read<uint64_t>();
 
-		size_t alms = s.readBE<uint64>();
+		size_t alms = s.read<uint64>();
 		for (size_t alm = 0; alm < alms; alm++)
 		{
-			OSAlarm_t* alarm = (OSAlarm_t*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+			OSAlarm_t* alarm = (OSAlarm_t*)memory_getPointerFromVirtualOffset(s.read<MPTR>());
 
 			uint64 startTime = _swapEndianU64(alarm->startTime) + timeOffset;
 			uint64 nextTime = _swapEndianU64(alarm->nextTime) + timeOffset;
@@ -360,7 +360,7 @@ namespace coreinit
 			}
 			alarm->nextTime = _swapEndianU64(nextTime);
 
-			uint64 nextFire = s.readBE<uint64>() + timeOffset;
+			uint64 nextFire = s.read<uint64>() + timeOffset;
 			__OSLockScheduler();
 			g_activeAlarms[alarm] = OSHostAlarmCreate(nextFire, period, __OSHostAlarmTriggered, nullptr);
 			__OSUnlockScheduler();

src/Cafe/OS/libs/coreinit/coreinit_DynLoad.cpp

@@ -132,19 +132,19 @@ namespace coreinit
 	void DynLoad_Save(MemStreamWriter& s)
 	{
 		s.writeSection("coreinit_DynLoad");
-		s.writeBE(_osDynLoadFuncAlloc);
+		s.write(_osDynLoadFuncAlloc);
-		s.writeBE(_osDynLoadFuncFree);
+		s.write(_osDynLoadFuncFree);
-		s.writeBE(_osDynLoadTLSFuncAlloc);
+		s.write(_osDynLoadTLSFuncAlloc);
-		s.writeBE(_osDynLoadTLSFuncFree);
+		s.write(_osDynLoadTLSFuncFree);
 	}
 
 	void DynLoad_Restore(MemStreamReader& s)
 	{
 		s.readSection("coreinit_DynLoad");
-		s.readBE(_osDynLoadFuncAlloc);
+		s.read(_osDynLoadFuncAlloc);
-		s.readBE(_osDynLoadFuncFree);
+		s.read(_osDynLoadFuncFree);
-		s.readBE(_osDynLoadTLSFuncAlloc);
+		s.read(_osDynLoadTLSFuncAlloc);
-		s.readBE(_osDynLoadTLSFuncFree);
+		s.read(_osDynLoadTLSFuncFree);
 	}
 
 	void InitializeDynLoad()

src/Cafe/OS/libs/coreinit/coreinit_Init.cpp

@@ -220,16 +220,16 @@ void coreinit_Init_Save(MemStreamWriter& s)
 {
 	s.writeSection("coreinit_Init");
 	s.writeData(_coreinitInfo, sizeof(coreinitInit_t));
-	s.writeBE(argStorageIndex);
+	s.write(argStorageIndex);
 	s.writeMPTR(g_preinitUserParam);
-	s.writeBE(_coreinitTitleEntryPoint);
+	s.write(_coreinitTitleEntryPoint);
 }
 
 void coreinit_Init_Restore(MemStreamReader& s)
 {
 	s.readSection("coreinit_Init");
 	s.readData(_coreinitInfo, sizeof(coreinitInit_t));
-	s.readBE(argStorageIndex);
+	s.read(argStorageIndex);
 	s.readMPTR(g_preinitUserParam);
-	s.readBE(_coreinitTitleEntryPoint);
+	s.read(_coreinitTitleEntryPoint);
 }

src/Cafe/OS/libs/coreinit/coreinit_LockedCache.cpp

@@ -276,7 +276,7 @@ namespace coreinit
 		s.writeSection("coreinit_LockedCache");
 		s.writeData(lcCacheMask, sizeof(uint8) * PPC_CORE_COUNT * (LC_LOCKED_CACHE_SIZE + LC_LOCKED_CACHE_GRANULARITY - 1) / LC_LOCKED_CACHE_GRANULARITY);
 		s.writeData(lcAllocatedBlocks, sizeof(uint32) * PPC_CORE_COUNT);
-		s.writeBE(_lcDisableErrorCounter);
+		s.write(_lcDisableErrorCounter);
 	}
 
 	void LockedCache_Restore(MemStreamReader& s)
@@ -284,7 +284,7 @@ namespace coreinit
 		s.readSection("coreinit_LockedCache");
 		s.readData(lcCacheMask, sizeof(uint8) * PPC_CORE_COUNT * (LC_LOCKED_CACHE_SIZE + LC_LOCKED_CACHE_GRANULARITY - 1) / LC_LOCKED_CACHE_GRANULARITY);
 		s.readData(lcAllocatedBlocks, sizeof(uint32) * PPC_CORE_COUNT);
-		s.readBE(_lcDisableErrorCounter);
+		s.read(_lcDisableErrorCounter);
 	}
 
 	void InitializeLC()

src/Cafe/OS/libs/coreinit/coreinit_MEM.cpp

@@ -633,8 +633,8 @@ namespace coreinit
 	void MEM_Save(MemStreamWriter& s)
 	{
 		s.writeSection("coreinit_MEM");
-		s.writeBE(sysAreaAllocatorOffset);
+		s.write(sysAreaAllocatorOffset);
-		s.writeBE(g_heapTableCount);
+		s.write(g_heapTableCount);
 		s.writeData(g_heapTable, sizeof(MEMHeapBase) * MEM_MAX_HEAP_TABLE);
 		s.writeBool(g_slockInitialized);
 		s.writeBool(g_listsInitialized);
@@ -651,8 +651,8 @@ namespace coreinit
 	void MEM_Restore(MemStreamReader& s)
 	{
 		s.readSection("coreinit_MEM");
-		s.readBE(sysAreaAllocatorOffset);
+		s.read(sysAreaAllocatorOffset);
-		s.readBE(g_heapTableCount);
+		s.read(g_heapTableCount);
 		s.readData(g_heapTable, sizeof(MEMHeapBase) * MEM_MAX_HEAP_TABLE);
 		s.readBool(g_slockInitialized);
 		s.readBool(g_listsInitialized);

src/Cafe/OS/libs/coreinit/coreinit_MemoryMapping.cpp

@@ -156,25 +156,24 @@ namespace coreinit
 	void MemoryMapping_Save(MemStreamWriter& s)
 	{
 		s.writeSection("coreinit_MemoryMapping");
-		s.writeBE<uint32>(s_allocatedVirtMemory.size());
+		s.write<uint32>(s_allocatedVirtMemory.size());
 		for (auto i : s_allocatedVirtMemory)
 		{
-			s.writeBE(i.virtualAddress);
+			s.write(i.virtualAddress);
-			s.writeBE(i.size);
+			s.write(i.size);
-			s.writeBE(i.alignment);
+			s.write(i.alignment);
 		}
 	}
 
 	void MemoryMapping_Restore(MemStreamReader& s)
 	{
 		s.readSection("coreinit_MemoryMapping");
-		s.readPODVector(s_allocatedVirtMemory);
+		uint32 s_allocatedVirtMemorySize = s.read<uint32>();
-		uint32 s_allocatedVirtMemorySize = s.readBE<uint32>();
 		s_allocatedVirtMemory.clear();
 		s_allocatedVirtMemory.reserve(s_allocatedVirtMemorySize);
 		for (sint32 i = 0; i < s_allocatedVirtMemorySize; i++)
 		{
-			s_allocatedVirtMemory.push_back(OSVirtMemoryEntry(s.readBE<MPTR>(), s.readBE<uint32>(), s.readBE<uint32>()));
+			s_allocatedVirtMemory.push_back(OSVirtMemoryEntry(s.read<MPTR>(), s.read<uint32>(), s.read<uint32>()));
 		}
 	}
 

src/Cafe/OS/libs/coreinit/coreinit_SysHeap.cpp

@@ -36,16 +36,16 @@ namespace coreinit
 	{
 		s.writeSection("coreinit_SysHeap");
 		s.writeData(_sysHeapHandle, sizeof(MEMHeapBase));
-		s.writeBE(_sysHeapAllocCounter);
+		s.write(_sysHeapAllocCounter);
-		s.writeBE(_sysHeapFreeCounter);
+		s.write(_sysHeapFreeCounter);
 	}
 
 	void SysHeap_Restore(MemStreamReader& s)
 	{
 		s.readSection("coreinit_SysHeap");
 		s.readData(_sysHeapHandle, sizeof(MEMHeapBase));
-		s.readBE(_sysHeapAllocCounter);
+		s.read(_sysHeapAllocCounter);
-		s.readBE(_sysHeapFreeCounter);
+		s.read(_sysHeapFreeCounter);
 	}
 
 	void InitializeSysHeap()

src/Cafe/OS/libs/coreinit/coreinit_Thread.cpp

@@ -1335,19 +1335,19 @@ namespace coreinit
 	{
 		s.writeSection("coreinit_Thread");
 
-		s.writeBE((uint8)sSchedulerActive.load());
+		s.write((uint8)sSchedulerActive.load());
 		s.writeMPTR(g_activeThreadQueue);
 		s.writeMPTR(g_coreRunQueue);
 
-		s.writeBE(activeThreadCount);
+		s.write(activeThreadCount);
 		for (sint32 i = 0; i < activeThreadCount; i++)
 		{
-			s.writeBE(activeThread[i]);
+			s.write(activeThread[i]);
 		}
 		for (sint32 i = 0; i < PPC_CORE_COUNT; i++)
 		{
 			s.writePTR(__currentCoreThread[i]);
-			s.writeBE(s_lehmer_lcg[i]);
+			s.write(s_lehmer_lcg[i]);
 			s.writeMPTR(s_terminatorThreads[i].terminatorThread);
 			s.writeMPTR(s_terminatorThreads[i].threadStack);
 			s.writeMPTR(s_terminatorThreads[i].threadName);
@@ -1362,14 +1362,14 @@ namespace coreinit
 	{
 		s.readSection("coreinit_Thread");
 
-		sSchedulerActive.store(s.readBE<uint8>());
+		sSchedulerActive.store(s.read<uint8>());
 		s.readMPTR(g_activeThreadQueue);
 		s.readMPTR(g_coreRunQueue);
 
-		sint32 prevActiveThreadCount = s.readBE<sint32>();
+		sint32 prevActiveThreadCount = s.read<sint32>();
 		for (sint32 i = 0; i < prevActiveThreadCount; i++)
 		{
-			MPTR threadMPTR = s.readBE<MPTR>();
+			MPTR threadMPTR = s.read<MPTR>();
 			if (recreate)
 			{
 				__OSLockScheduler();
@@ -1385,7 +1385,7 @@ namespace coreinit
 		for (sint32 i = 0; i < PPC_CORE_COUNT; i++)
 		{
 			s.readPTR(__currentCoreThread[i]);
-			s.readBE(s_lehmer_lcg[i]);
+			s.read(s_lehmer_lcg[i]);
 			s.readMPTR(s_terminatorThreads[i].terminatorThread);
 			s.readMPTR(s_terminatorThreads[i].threadStack);
 			s.readMPTR(s_terminatorThreads[i].threadName);

src/Cafe/OS/libs/dmae/dmae.cpp

@@ -111,13 +111,13 @@ void dmaeExport_DMAEGetRetiredTimeStamp(PPCInterpreter_t* hCPU)
 void dmae_save(MemStreamWriter& s)
 {
 	s.writeSection("dmae");
-	s.writeBE(dmaeRetiredTimestamp);
+	s.write(dmaeRetiredTimestamp);
 }
 
 void dmae_restore(MemStreamReader& s)
 {
 	s.readSection("dmae");
-	s.readBE(dmaeRetiredTimestamp);
+	s.read(dmaeRetiredTimestamp);
 }
 
 void dmae_load()

src/Cafe/OS/libs/nlibcurl/nlibcurl.cpp

@@ -1357,7 +1357,7 @@ void export_curl_global_init_mem(PPCInterpreter_t* hCPU)
 void save(MemStreamWriter& s)
 {
 	s.writeSection("nlibcurl");
-	s.writeBE(g_nlibcurl.initialized);
+	s.write(g_nlibcurl.initialized);
 	s.writeMPTR(g_nlibcurl.proxyConfig);
 	s.writeMPTR(g_nlibcurl.malloc);
 	s.writeMPTR(g_nlibcurl.free);
@@ -1368,7 +1368,7 @@ void save(MemStreamWriter& s)
 void restore(MemStreamReader& s)
 {
 	s.readSection("nlibcurl");
-	s.readBE(g_nlibcurl.initialized);
+	s.read(g_nlibcurl.initialized);
 	s.readMPTR(g_nlibcurl.proxyConfig);
 	s.readMPTR(g_nlibcurl.malloc);
 	s.readMPTR(g_nlibcurl.free);

src/Cafe/OS/libs/nn_act/nn_act.cpp

@@ -667,14 +667,14 @@ void nnActExport_AcquirePrincipalIdByAccountId(PPCInterpreter_t* hCPU)
 void nnAct_save(MemStreamWriter& s)
 {
 	s.writeSection("nn_act");
-	s.writeBE(nn::act::g_initializeCount);
+	s.write(nn::act::g_initializeCount);
-	s.writeBE((uint32)g_isParentalControlCheckEnabled);
+	s.write((uint32)g_isParentalControlCheckEnabled);
 }
 void nnAct_restore(MemStreamReader& s)
 {
 	s.readSection("nn_act");
-	s.readBE(nn::act::g_initializeCount);
+	s.read(nn::act::g_initializeCount);
-	g_isParentalControlCheckEnabled = s.readBE<uint32>();
+	g_isParentalControlCheckEnabled = s.read<uint32>();
 }
 
 // register account functions

src/Cafe/OS/libs/nn_aoc/nn_aoc.cpp

@@ -152,10 +152,10 @@ namespace nn
 		void save(MemStreamWriter& s)
 		{
 			s.writeSection("nn_aoc");
-			s.writeBE<uint32>(sAocCache.size());
+			s.write<uint32>(sAocCache.size());
 			for (auto i : sAocCache)
 			{
-				s.writeBE(i.aocTitleId);
+				s.write(i.aocTitleId);
 			}
 			s.writeBool(sAocCacheGenerated);
 		}
@@ -163,12 +163,12 @@ namespace nn
 		void restore(MemStreamReader& s)
 		{
 			s.readSection("nn_aoc");
-			uint32 sAocCacheSize = s.readBE<uint32>();
+			uint32 sAocCacheSize = s.read<uint32>();
 			sAocCache.clear();
 			sAocCache.reserve(sAocCacheSize);
 			for (sint32 i = 0; i < sAocCacheSize; i++)
 			{
-				sAocCache.emplace_back(s.readBE<uint64>());
+				sAocCache.emplace_back(s.read<uint64>());
 			}
 			s.readBool(sAocCacheGenerated);
 		}

src/Cafe/OS/libs/nn_boss/nn_boss.cpp

@@ -1718,7 +1718,7 @@ void nnBoss_save(MemStreamWriter& s)
 {
 	s.writeSection("nn_boss");
 	s.writeMPTR(nn::boss::g_mutex);
-	s.writeBE(nn::boss::g_initCounter);
+	s.write(nn::boss::g_initCounter);
 	s.writeBool(nn::boss::g_isInitialized);
 }
 
@@ -1726,7 +1726,7 @@ void nnBoss_restore(MemStreamReader& s)
 {
 	s.readSection("nn_boss");
 	s.readMPTR(nn::boss::g_mutex);
-	s.readBE(nn::boss::g_initCounter);
+	s.read(nn::boss::g_initCounter);
 	s.readBool(nn::boss::g_isInitialized);
 }
 

src/Cafe/OS/libs/nn_ndm/nn_ndm.cpp

@@ -78,14 +78,14 @@ namespace nn
 		{
 			s.writeSection("nn_ndm");
 			s.writeData(s_daemonStatus, sizeof(DAEMON_STATUS) * NUM_DAEMONS);
-			s.writeBE(s_initializeRefCount);
+			s.write(s_initializeRefCount);
 		}
 
 		void restore(MemStreamReader& s)
 		{
 			s.readSection("nn_ndm");
 			s.readData(s_daemonStatus, sizeof(DAEMON_STATUS) * NUM_DAEMONS);
-			s.readBE(s_initializeRefCount);
+			s.read(s_initializeRefCount);
 		}
 
 		void load()

src/Cafe/OS/libs/nn_olv/nn_olv.cpp

@@ -118,7 +118,7 @@ namespace nn
 			s.writeMPTR(s_OlvReleaseBgThreadName);
 			s.writeData(&g_ParamPack, sizeof(ParamPackStorage));
 			s.writeData(&g_DiscoveryResults, sizeof(DiscoveryResultStorage));
-			s.writeBE(g_ReportTypes);
+			s.write(g_ReportTypes);
 			s.writeBool(g_IsInitialized);
 			s.writeBool(g_IsOnlineMode);
 			s.writeBool(g_IsOfflineDBMode);
@@ -133,7 +133,7 @@ namespace nn
 			s.readMPTR(s_OlvReleaseBgThreadName);
 			s.readData(&g_ParamPack, sizeof(ParamPackStorage));
 			s.readData(&g_DiscoveryResults, sizeof(DiscoveryResultStorage));
-			s.readBE(g_ReportTypes);
+			s.read(g_ReportTypes);
 			s.readBool(g_IsInitialized);
 			s.readBool(g_IsOnlineMode);
 			s.readBool(g_IsOfflineDBMode);

src/Cafe/OS/libs/nn_temp/nn_temp.cpp

@@ -19,13 +19,13 @@ namespace nn::temp
 	void save(MemStreamWriter& s)
 	{
 		s.writeSection("nn_temp");
-		s.writeBE(tempIdGenerator);
+		s.write(tempIdGenerator);
 	}
 
 	void restore(MemStreamReader& s)
 	{
 		s.readSection("nn_temp");
-		s.readBE(tempIdGenerator);
+		s.read(tempIdGenerator);
 	}
 
 	void Initialize()

src/Cafe/OS/libs/nsyshid/nsyshid.cpp

@@ -818,9 +818,9 @@ namespace nsyshid
 		s.writeSection("nsyshid");
 		s.writeData(firstDevice, sizeof(HIDDeviceInfo_t));
 		s.writeData(firstHIDClient, sizeof(HIDClient_t));
-		s.writeBE(_lastGeneratedHidHandle);
+		s.write(_lastGeneratedHidHandle);
 		s.writeMPTR(_devicePool);
-		s.writeBE(_devicePoolMask.count());
+		s.write(_devicePoolMask.count());
 	}
 
 	void restore(MemStreamReader& s)
@@ -828,10 +828,10 @@ namespace nsyshid
 		s.readSection("nsyshid");
 		s.readData(firstDevice, sizeof(HIDDeviceInfo_t));
 		s.readData(firstHIDClient, sizeof(HIDClient_t));
-		s.readBE(_lastGeneratedHidHandle);
+		s.read(_lastGeneratedHidHandle);
 		s.readMPTR(_devicePool);
 		_devicePoolMask.reset();
-		for (size_t i = 0; i < s.readBE<size_t>(); i++)
+		for (size_t i = 0; i < s.read<size_t>(); i++)
 			_devicePoolMask.set(i);
 	}
 

src/Cafe/OS/libs/nsysnet/nsysnet.cpp

@@ -2162,34 +2162,34 @@ namespace nsysnet
 }
 
 template<>
-void MemStreamWriter::writeBE(const nsysnet::NSSLInternalState_t& v)
+void MemStreamWriter::write(const nsysnet::NSSLInternalState_t& v)
 {
 	writeBool(v.destroyed);
-	writeBE(v.sslVersion);
+	write(v.sslVersion);
-	writeBE(v.clientPKI);
+	write(v.clientPKI);
 
-	writeBE<uint32>(v.serverPKIs.size());
+	write<uint32>(v.serverPKIs.size());
 	for (auto i : v.serverPKIs)
-		writeBE<uint32>(i);
+		write<uint32>(i);
 
-	writeBE<uint32>(v.serverCustomPKIs.size());
+	write<uint32>(v.serverCustomPKIs.size());
 	for (auto i : v.serverCustomPKIs)
 		writePODVector(i);
 }
 
 template<>
-void MemStreamReader::readBE(nsysnet::NSSLInternalState_t& v)
+void MemStreamReader::read(nsysnet::NSSLInternalState_t& v)
 {
 	readBool(v.destroyed);
-	readBE(v.sslVersion);
+	read(v.sslVersion);
-	readBE(v.clientPKI);
+	read(v.clientPKI);
 
-	uint32 serverPKIsSize = readBE<uint32>();
+	uint32 serverPKIsSize = read<uint32>();
 	v.serverPKIs.clear();
 	for (uint32 i = 0; i < serverPKIsSize; i++)
-		v.serverPKIs.insert(readBE<uint32>());
+		v.serverPKIs.insert(read<uint32>());
 
-	uint32 serverCustomPKIsSize = readBE<uint32>();
+	uint32 serverCustomPKIsSize = read<uint32>();
 	v.serverCustomPKIs.clear();
 	v.serverCustomPKIs.resize(serverCustomPKIsSize);
 	for (uint32 i = 0; i < serverCustomPKIsSize; i++)
@@ -2208,9 +2208,9 @@ void nsysnet_save(MemStreamWriter& s)
 	s.writeMPTR(_staticHostentName);
 	s.writeMPTR(_staticHostentPtrList);
 	s.writeMPTR(_staticHostentEntries);
-	s.writeBE<uint32>(nsysnet::g_nsslInternalStates.size());
+	s.write<uint32>(nsysnet::g_nsslInternalStates.size());
 	for (auto i : nsysnet::g_nsslInternalStates)
-		s.writeBE(i);
+		s.write(i);
 	s.writeBool(sockLibReady);
 	s.writeData(virtualSocketTable, sizeof(virtualSocket_t) * WU_SOCKET_LIMIT);
 }
@@ -2223,13 +2223,13 @@ void nsysnet_restore(MemStreamReader& s)
 	s.readMPTR(_staticHostentName);
 	s.readMPTR(_staticHostentPtrList);
 	s.readMPTR(_staticHostentEntries);
-	uint32 g_nsslInternalStatesSize = s.readBE<uint32>();
+	uint32 g_nsslInternalStatesSize = s.read<uint32>();
 	nsysnet::g_nsslInternalStates.clear();
 	nsysnet::g_nsslInternalStates.resize(g_nsslInternalStatesSize);
 	for (uint32 i = 0; i < g_nsslInternalStatesSize; i++)
 	{
 		nsysnet::NSSLInternalState_t t;
-		s.readBE(t);
+		s.read(t);
 		nsysnet::g_nsslInternalStates.push_back(t);
 	}
 	s.readBool(sockLibReady);

src/Cafe/OS/libs/padscore/padscore.cpp

@@ -754,9 +754,9 @@ namespace padscore
 		s.writeBool(g_kpadIsInited);
 		s.writeData(&g_padscore, sizeof(g_padscore_t));
 		s.writeData(g_kpad_ringbuffer, sizeof(KPADUnifiedWpadStatus_t));
-		s.writeBE(g_kpad_ringbuffer_length);
+		s.write(g_kpad_ringbuffer_length);
 		s.writeBool(g_wpad_callback_by_kpad);
-		s.writeBE((uint32)g_wpad_state);
+		s.write((uint32)g_wpad_state);
 	}
 
 	void restore(MemStreamReader& s)
@@ -766,9 +766,9 @@ namespace padscore
 		s.readBool(g_kpadIsInited);
 		s.readData(&g_padscore, sizeof(g_padscore_t));
 		s.readData(g_kpad_ringbuffer, sizeof(KPADUnifiedWpadStatus_t));
-		s.readBE(g_kpad_ringbuffer_length);
+		s.read(g_kpad_ringbuffer_length);
 		s.readBool(g_wpad_callback_by_kpad);
-		g_wpad_state = (WPADState_t)s.readBE<uint32>();
+		g_wpad_state = (WPADState_t)s.read<uint32>();
 	}
 
 	void load()

src/util/helpers/Serializer.cpp

@@ -1,5 +1,91 @@
 #include "Serializer.h"
 
+// read return
+
+template<typename T>
+T MemStreamReader::read()
+{
+	if (!reserveReadLength(sizeof(T)))
+		return 0;
+	const uint8* p = m_data + m_cursorPos;
+	T v;
+	std::memcpy(&v, p, sizeof(v));
+	m_cursorPos += sizeof(T);
+	return v;
+}
+
+template uint8 MemStreamReader::read<uint8>();
+template uint16 MemStreamReader::read<uint16>();
+template uint32 MemStreamReader::read<uint32>();
+template uint32be MemStreamReader::read<uint32be>();
+template uint64 MemStreamReader::read<uint64>();
+template int MemStreamReader::read<int>();
+
+template<>
+std::string MemStreamReader::read()
+{
+	std::string s;
+	uint32 stringSize = read<uint32>();
+	if (hasError())
+		return s;
+	if (stringSize >= (32 * 1024 * 1024))
+	{
+		// out of bounds read or suspiciously large string
+		m_hasError = true;
+		return std::string();
+	}
+	s.resize(stringSize);
+	readData(s.data(), stringSize);
+	return s;
+}
+
+// read void
+
+template<typename T>
+void MemStreamReader::read(T& v)
+{
+	if (reserveReadLength(sizeof(T)))
+	{
+		const uint8* p = m_data + m_cursorPos;
+		std::memcpy(&v, p, sizeof(v));
+		m_cursorPos += sizeof(T);
+	}
+}
+
+template void MemStreamReader::read(uint8& v);
+template void MemStreamReader::read(uint16& v);
+template void MemStreamReader::read(uint32& v);
+template void MemStreamReader::read(uint32be& v);
+template void MemStreamReader::read(uint64& v);
+template void MemStreamReader::read(int& v);
+
+template<>
+void MemStreamReader::read(std::string& v)
+{
+	uint32 stringSize = read<uint32>();
+	if (!hasError())
+	{
+		if (stringSize >= (32 * 1024 * 1024))
+		{
+			// out of bounds read or suspiciously large string
+			m_hasError = true;
+		}
+		else
+		{
+			v.resize(stringSize);
+			readData(v.data(), stringSize);
+		}
+	}
+}
+
+// readSection
+
+void MemStreamReader::readSection(const char* sec)
+{
+	std::string sec_str = std::string(sec);
+	cemu_assert_debug(read<std::string>() == sec_str);
+}
+
 // readBE return
 
 template<typename T>
@@ -19,7 +105,6 @@ template uint8 MemStreamReader::readBE<uint8>();
 template uint16 MemStreamReader::readBE<uint16>();
 template uint32 MemStreamReader::readBE<uint32>();
 template uint64 MemStreamReader::readBE<uint64>();
-template int MemStreamReader::readBE<int>();
 
 template<>
 std::string MemStreamReader::readBE()
@@ -39,45 +124,6 @@ std::string MemStreamReader::readBE()
 	return s;
 }
 
-// readBE void
-
-template<typename T>
-void MemStreamReader::readBE(T& v)
-{
-	if (reserveReadLength(sizeof(T)))
-	{
-		const uint8* p = m_data + m_cursorPos;
-		std::memcpy(&v, p, sizeof(v));
-		v = _BE(v);
-		m_cursorPos += sizeof(T);
-	}
-}
-
-template void MemStreamReader::readBE(uint8& v);
-template void MemStreamReader::readBE(uint16& v);
-template void MemStreamReader::readBE(uint32& v);
-template void MemStreamReader::readBE(uint64& v);
-template void MemStreamReader::readBE(int& v);
-
-template<>
-void MemStreamReader::readBE(std::string& v)
-{
-	uint32 stringSize = readBE<uint32>();
-	if (!hasError())
-	{
-		if (stringSize >= (32 * 1024 * 1024))
-		{
-			// out of bounds read or suspiciously large string
-			m_hasError = true;
-		}
-		else
-		{
-			v.resize(stringSize);
-			readData(v.data(), stringSize);
-		}
-	}
-}
-
 // readLE return
 
 template<typename T>
@@ -94,15 +140,39 @@ T MemStreamReader::readLE()
 }
 
 template uint8 MemStreamReader::readLE<uint8>();
-template uint16 MemStreamReader::readLE<uint16>();
 template uint32 MemStreamReader::readLE<uint32>();
+template uint64 MemStreamReader::readLE<uint64>();
 
-// readSection
+// write void
 
-void MemStreamReader::readSection(const char* sec)
+template<typename T>
+void MemStreamWriter::write(const T& v)
+{
+	m_buffer.resize(m_buffer.size() + sizeof(T));
+	uint8* p = m_buffer.data() + m_buffer.size() - sizeof(T);
+	std::memcpy(p, &v, sizeof(v));
+}
+
+template void MemStreamWriter::write(const int& v);
+template void MemStreamWriter::write(const uint64& v);
+template void MemStreamWriter::write(const uint32be& v);
+template void MemStreamWriter::write(const uint32& v);
+template void MemStreamWriter::write(const uint16& v);
+template void MemStreamWriter::write(const uint8& v);
+
+template<>
+void MemStreamWriter::write<std::string>(const std::string& v)
+{
+	write<uint32>((uint32)v.size());
+	writeData(v.data(), v.size());
+}
+
+// writeSection
+
+void MemStreamWriter::writeSection(const char* sec)
 {
 	std::string sec_str = std::string(sec);
-	cemu_assert_debug(readBE<std::string>() == sec_str);
+	write(sec_str);
 }
 
 // writeBE void
@@ -116,11 +186,10 @@ void MemStreamWriter::writeBE(const T& v)
 	std::memcpy(p, &tmp, sizeof(tmp));
 }
 
-template void MemStreamWriter::writeBE(const uint8& v);
-template void MemStreamWriter::writeBE(const uint16& v);
-template void MemStreamWriter::writeBE(const uint32& v);
 template void MemStreamWriter::writeBE(const uint64& v);
-template void MemStreamWriter::writeBE(const int& v);
+template void MemStreamWriter::writeBE(const uint32& v);
+template void MemStreamWriter::writeBE(const uint16& v);
+template void MemStreamWriter::writeBE(const uint8& v);
 
 template<>
 void MemStreamWriter::writeBE<std::string>(const std::string& v)
@@ -140,14 +209,6 @@ void MemStreamWriter::writeLE(const T& v)
 	std::memcpy(p, &tmp, sizeof(tmp));
 }
 
-template void MemStreamWriter::writeLE(const uint8& v);
+template void MemStreamWriter::writeLE(const uint64& v);
-template void MemStreamWriter::writeLE(const uint16& v);
 template void MemStreamWriter::writeLE(const uint32& v);
 
-// writeSection
-
-void MemStreamWriter::writeSection(const char* sec)
-{
-	std::string sec_str = std::string(sec);
-	writeBE(sec_str);
-}

src/util/helpers/Serializer.h

@@ -8,14 +8,21 @@ public:
 		m_cursorPos = 0;
 	}
 
+	template<typename T> T read();
+	template<typename T> void read(T& v);
 	template<typename T> T readBE();
 	template<typename T> void readBE(T& v);
 	template<typename T> T readLE();
 
+	void readAtomic(std::atomic<bool>& v)
+	{
+		v.store(readBool());
+	}
+
 	template<typename T>
 	void readAtomic(std::atomic<T>& v)
 	{
-		v.store(readBE<T>());
+		v.store(read<T>());
 	}
 
 	template<typename T>
@@ -48,29 +55,29 @@ public:
 	template<typename T>
 	void readPTR(T& v)
 	{
-		v = (T)(memory_base + readBE<uint32>());
+		v = (T)(memory_base + read<uint32>());
 	}
 
 	template<template<typename> class C, typename T>
 	void readMPTR(C<T>& v)
 	{
-		v = (T*)(memory_base + readBE<MPTR>());
+		v = (T*)(memory_base + read<MPTR>());
 	}
 
 	template<template<typename, size_t, size_t> class C, typename T, size_t c, size_t a>
 	void readMPTR(C<T,c,a>& v)
 	{
-		v = (T*)(memory_base + readBE<MPTR>());
+		v = (T*)(memory_base + read<MPTR>());
 	}
 
 	void readBool(bool& v)
 	{
-		v = readBE<uint8>();
+		v = read<uint8>();
 	}
 
 	bool readBool()
 	{
-		return readBE<uint8>();
+		return read<uint8>();
 	}
 
 	void readSection(const char* sec);
@@ -212,13 +219,19 @@ public:
 		}
 	}
 
+	template<typename T> void write(const T& v);
 	template<typename T> void writeBE(const T& v);
 	template<typename T> void writeLE(const T& v);
 	
+	void writeAtomic(const std::atomic<bool>& v)
+	{
+		writeBool(v.load());
+	}
+
 	template<typename T>
 	void writeAtomic(const std::atomic<T>& v)
 	{
-		writeBE(v.load());
+		write(v.load());
 	}
 
 	template<typename T>
@@ -232,18 +245,18 @@ public:
 	template<typename T>
 	void writePTR(const T& v)
 	{
-		writeBE((uint32)((uint8*)v - (uint8*)memory_base));
+		write((uint32)((uint8*)v - (uint8*)memory_base));
 	}
 
 	template<typename T>
 	void writeMPTR(const T& v)
 	{
-		writeBE(v.GetMPTR());
+		write(v.GetMPTR());
 	}
 
 	void writeBool(const bool& v)
 	{
-		writeBE((uint8)v);
+		write((uint8)v);
 	}
 
 	void writeSection(const char* sec);