From 1b7c4d8a2f9046f071dfa3b8e7080069eb573c3d Mon Sep 17 00:00:00 2001 From: Chris Spegal Date: Tue, 10 Oct 2023 10:59:26 -0400 Subject: [PATCH] Move to Endian agnostic read/write functions; add kernel --- src/Cafe/CafeSystem.cpp | 8 +- src/Cafe/Filesystem/fsc.cpp | 30 +-- src/Cafe/Filesystem/fsc.h | 1 + src/Cafe/Filesystem/fscDeviceHostFS.cpp | 8 +- src/Cafe/HW/MMU/MMU.cpp | 32 ++-- src/Cafe/IOSU/ODM/iosu_odm.cpp | 20 ++ src/Cafe/IOSU/ODM/iosu_odm.h | 3 + src/Cafe/IOSU/PDM/iosu_pdm.cpp | 9 + src/Cafe/IOSU/PDM/iosu_pdm.h | 3 + src/Cafe/IOSU/fsa/iosu_fsa.cpp | 40 ++-- src/Cafe/IOSU/fsa/iosu_fsa.h | 4 +- src/Cafe/IOSU/kernel/iosu_kernel.cpp | 132 ++++++++++++- src/Cafe/IOSU/kernel/iosu_kernel.h | 3 + src/Cafe/OS/libs/coreinit/coreinit.cpp | 8 +- src/Cafe/OS/libs/coreinit/coreinit_Alarm.cpp | 16 +- .../OS/libs/coreinit/coreinit_DynLoad.cpp | 16 +- src/Cafe/OS/libs/coreinit/coreinit_Init.cpp | 8 +- .../OS/libs/coreinit/coreinit_LockedCache.cpp | 4 +- src/Cafe/OS/libs/coreinit/coreinit_MEM.cpp | 8 +- .../libs/coreinit/coreinit_MemoryMapping.cpp | 17 +- .../OS/libs/coreinit/coreinit_SysHeap.cpp | 8 +- src/Cafe/OS/libs/coreinit/coreinit_Thread.cpp | 16 +- src/Cafe/OS/libs/dmae/dmae.cpp | 4 +- src/Cafe/OS/libs/nlibcurl/nlibcurl.cpp | 4 +- src/Cafe/OS/libs/nn_act/nn_act.cpp | 8 +- src/Cafe/OS/libs/nn_aoc/nn_aoc.cpp | 8 +- src/Cafe/OS/libs/nn_boss/nn_boss.cpp | 4 +- src/Cafe/OS/libs/nn_ndm/nn_ndm.cpp | 4 +- src/Cafe/OS/libs/nn_olv/nn_olv.cpp | 4 +- src/Cafe/OS/libs/nn_temp/nn_temp.cpp | 4 +- src/Cafe/OS/libs/nsyshid/nsyshid.cpp | 8 +- src/Cafe/OS/libs/nsysnet/nsysnet.cpp | 32 ++-- src/Cafe/OS/libs/padscore/padscore.cpp | 8 +- src/util/helpers/Serializer.cpp | 175 ++++++++++++------ src/util/helpers/Serializer.h | 33 +++- 35 files changed, 468 insertions(+), 222 deletions(-) diff --git a/src/Cafe/CafeSystem.cpp b/src/Cafe/CafeSystem.cpp index 8340a179..66d76ef5 100644 --- a/src/Cafe/CafeSystem.cpp +++ b/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); diff --git a/src/Cafe/Filesystem/fsc.cpp b/src/Cafe/Filesystem/fsc.cpp index 48a2e1b7..7bb5e466 100644 --- a/src/Cafe/Filesystem/fsc.cpp +++ b/src/Cafe/Filesystem/fsc.cpp @@ -737,31 +737,31 @@ void fsc_init() } template <> -void MemStreamWriter::writeBE(const FSCVirtualFile::FSCDirIteratorState& v) +void MemStreamWriter::write(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)Child::DIRECTORY_ITERATOR); - writer.writeBE(m_path); - writer.writeBE(m_folders.size()); + writer.write((uint32)Child::DIRECTORY_ITERATOR); + writer.write(m_path); + writer.write(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()) + switch ((Child)reader.read()) { case Child::DIRECTORY_ITERATOR: { - std::string path = reader.readBE(); + std::string path = reader.read(); std::vector folders{}; - size_t size = reader.readBE(); + size_t size = reader.read(); 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(); - FSC_ACCESS_FLAG flags = (FSC_ACCESS_FLAG)reader.readBE(); + std::string path = reader.read(); + FSC_ACCESS_FLAG flags = (FSC_ACCESS_FLAG)reader.read(); sint32 status{}; file = FSCVirtualFile_Host::OpenFile(path, flags, status); - file->fscSetSeek(reader.readBE()); + file->fscSetSeek(reader.read()); 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; diff --git a/src/Cafe/Filesystem/fsc.h b/src/Cafe/Filesystem/fsc.h index 8d9ab032..b3b66d04 100644 --- a/src/Cafe/Filesystem/fsc.h +++ b/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) diff --git a/src/Cafe/Filesystem/fscDeviceHostFS.cpp b/src/Cafe/Filesystem/fscDeviceHostFS.cpp index 12b15024..47ae761f 100644 --- a/src/Cafe/Filesystem/fscDeviceHostFS.cpp +++ b/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)Child::HOST); - writer.writeBE(m_path->string()); - writer.writeBE((uint32)m_accessFlags); - writer.writeBE(m_seek); + writer.write((uint32)Child::HOST); + writer.write(m_path->string()); + writer.write((uint32)m_accessFlags); + writer.write(m_seek); FSCVirtualFile::Save(writer); } diff --git a/src/Cafe/HW/MMU/MMU.cpp b/src/Cafe/HW/MMU/MMU.cpp index e65e62f9..3c05c805 100644 --- a/src/Cafe/HW/MMU/MMU.cpp +++ b/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); - writeBE((uint8)v.areaId); - writeBE((uint8)v.flags); - writeBE(v.name); - writeBE(v.size); - writeBE(v.initSize); + write(v.baseAddress); + write((uint8)v.areaId); + write((uint8)v.flags); + write(v.name); + write(v.size); + write(v.initSize); } template <> -void MemStreamReader::readBE(MMURange& mmuRange) +void MemStreamReader::read(MMURange& mmuRange) { bool needsMapped = readBool(); mmuRange.m_isMapped = false; - mmuRange.baseAddress = readBE(); - mmuRange.areaId = (MMU_MEM_AREA_ID)readBE(); - mmuRange.flags = (MMURange::MFLAG)readBE(); - mmuRange.name = readBE(); - mmuRange.size = readBE(); - mmuRange.initSize = readBE(); + mmuRange.baseAddress = read(); + mmuRange.areaId = (MMU_MEM_AREA_ID)read(); + mmuRange.flags = (MMURange::MFLAG)read(); + mmuRange.name = read(); + mmuRange.size = read(); + mmuRange.initSize = read(); 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(*itr); + s.read(*itr); if (itr->isMapped()) { s.readData(memory_base + itr->getBase(), itr->getSize()); diff --git a/src/Cafe/IOSU/ODM/iosu_odm.cpp b/src/Cafe/IOSU/ODM/iosu_odm.cpp index 3dc8e431..086c887a 100644 --- a/src/Cafe/IOSU/ODM/iosu_odm.cpp +++ b/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)) diff --git a/src/Cafe/IOSU/ODM/iosu_odm.h b/src/Cafe/IOSU/ODM/iosu_odm.h index f5f721a1..98ea7714 100644 --- a/src/Cafe/IOSU/ODM/iosu_odm.h +++ b/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(); } diff --git a/src/Cafe/IOSU/PDM/iosu_pdm.cpp b/src/Cafe/IOSU/PDM/iosu_pdm.cpp index 45b4a1d8..9a2af40a 100644 --- a/src/Cafe/IOSU/PDM/iosu_pdm.cpp +++ b/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 diff --git a/src/Cafe/IOSU/PDM/iosu_pdm.h b/src/Cafe/IOSU/PDM/iosu_pdm.h index fbafbc02..b4d0a735 100644 --- a/src/Cafe/IOSU/PDM/iosu_pdm.h +++ b/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(); diff --git a/src/Cafe/IOSU/fsa/iosu_fsa.cpp b/src/Cafe/IOSU/fsa/iosu_fsa.cpp index fdb7dee4..b24607a3 100644 --- a/src/Cafe/IOSU/fsa/iosu_fsa.cpp +++ b/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.writeBE(sFileHandleTable); + s.write(sDirHandleTable); + 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.readBE(sFileHandleTable); + s.read(sDirHandleTable); + s.read(sFileHandleTable); } } // namespace fsa } // namespace iosu \ No newline at end of file diff --git a/src/Cafe/IOSU/fsa/iosu_fsa.h b/src/Cafe/IOSU/fsa/iosu_fsa.h index d5fb2118..49c36a2d 100644 --- a/src/Cafe/IOSU/fsa/iosu_fsa.h +++ b/src/Cafe/IOSU/fsa/iosu_fsa.h @@ -214,7 +214,7 @@ namespace iosu void Initialize(); void Shutdown(); - void Save(MemStreamWriter& writer); - void Restore(MemStreamReader& reader); + void save(MemStreamWriter& writer); + void restore(MemStreamReader& reader); } // namespace fsa } // namespace iosu diff --git a/src/Cafe/IOSU/kernel/iosu_kernel.cpp b/src/Cafe/IOSU/kernel/iosu_kernel.cpp index 680170bc..651b763f 100644 --- a/src/Cafe/IOSU/kernel/iosu_kernel.cpp +++ b/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,10 +549,138 @@ namespace iosu return IOS_ERROR_OK; } + + void Initialize() { _IPCInitDispatchablePool(); } } +} + +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(sMsgQueuePool.size()); + for (const auto& i : sMsgQueuePool) + s.write(i); + + s.write(sDeviceResources.size()); + for (const auto& i : sDeviceResources) + s.write(i); + + s.writeMPTR(sIPCDispatchableCommandPool); + + size_t sIPCFreeDispatchableCommandsSize = sIPCFreeDispatchableCommands.size(); + s.write(sIPCFreeDispatchableCommandsSize); + while (sIPCFreeDispatchableCommandsSize) + { + IOSDispatchableCommand* front = sIPCFreeDispatchableCommands.front(); + sIPCFreeDispatchableCommands.pop(); + s.writePTR(front); + sIPCFreeDispatchableCommands.push(front); + sIPCFreeDispatchableCommandsSize--; + } + + s.write(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() == sMsgQueuePool.size()); + for (auto& i : sMsgQueuePool) + s.read(i); + + cemu_assert(s.read() == sDeviceResources.size()); + for (auto& i : sDeviceResources) + s.read(i); + + s.readMPTR(sIPCDispatchableCommandPool); + + size_t sIPCFreeDispatchableCommandsSize = s.read(); + 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() == MAX_NUM_ACTIVE_DEV_HANDLES); + for (uint32 i = 0; i < MAX_NUM_ACTIVE_DEV_HANDLES; i++) + s.read(sActiveDeviceHandles[i]); + } + } } \ No newline at end of file diff --git a/src/Cafe/IOSU/kernel/iosu_kernel.h b/src/Cafe/IOSU/kernel/iosu_kernel.h index 2b82374e..5a7da791 100644 --- a/src/Cafe/IOSU/kernel/iosu_kernel.h +++ b/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(); } } \ No newline at end of file diff --git a/src/Cafe/OS/libs/coreinit/coreinit.cpp b/src/Cafe/OS/libs/coreinit/coreinit.cpp index e573c11d..91f444d8 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit.cpp +++ b/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.writeBE(placeholderFontSize); + s.write(placeholderFont); + 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.readBE(placeholderFontSize); + s.read(placeholderFont); + s.read(placeholderFontSize); coreinit_Init_Restore(s); coreinit::SysHeap_Restore(s); diff --git a/src/Cafe/OS/libs/coreinit/coreinit_Alarm.cpp b/src/Cafe/OS/libs/coreinit/coreinit_Alarm.cpp index bfc975fc..d0b124dd 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_Alarm.cpp +++ b/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.writeBE(itr.second->getNextFire()); + s.write(memory_getVirtualOffsetFromPointer(itr.first)); + 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 timeOffset = currentTime - s.read(); - size_t alms = s.readBE(); + size_t alms = s.read(); for (size_t alm = 0; alm < alms; alm++) { - OSAlarm_t* alarm = (OSAlarm_t*)memory_getPointerFromVirtualOffset(s.readBE()); + OSAlarm_t* alarm = (OSAlarm_t*)memory_getPointerFromVirtualOffset(s.read()); 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() + timeOffset; + uint64 nextFire = s.read() + timeOffset; __OSLockScheduler(); g_activeAlarms[alarm] = OSHostAlarmCreate(nextFire, period, __OSHostAlarmTriggered, nullptr); __OSUnlockScheduler(); diff --git a/src/Cafe/OS/libs/coreinit/coreinit_DynLoad.cpp b/src/Cafe/OS/libs/coreinit/coreinit_DynLoad.cpp index 35e1447c..b464ac45 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_DynLoad.cpp +++ b/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.writeBE(_osDynLoadFuncFree); - s.writeBE(_osDynLoadTLSFuncAlloc); - s.writeBE(_osDynLoadTLSFuncFree); + s.write(_osDynLoadFuncAlloc); + s.write(_osDynLoadFuncFree); + s.write(_osDynLoadTLSFuncAlloc); + s.write(_osDynLoadTLSFuncFree); } void DynLoad_Restore(MemStreamReader& s) { s.readSection("coreinit_DynLoad"); - s.readBE(_osDynLoadFuncAlloc); - s.readBE(_osDynLoadFuncFree); - s.readBE(_osDynLoadTLSFuncAlloc); - s.readBE(_osDynLoadTLSFuncFree); + s.read(_osDynLoadFuncAlloc); + s.read(_osDynLoadFuncFree); + s.read(_osDynLoadTLSFuncAlloc); + s.read(_osDynLoadTLSFuncFree); } void InitializeDynLoad() diff --git a/src/Cafe/OS/libs/coreinit/coreinit_Init.cpp b/src/Cafe/OS/libs/coreinit/coreinit_Init.cpp index 0d7cb477..f75d45ff 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_Init.cpp +++ b/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); } \ No newline at end of file diff --git a/src/Cafe/OS/libs/coreinit/coreinit_LockedCache.cpp b/src/Cafe/OS/libs/coreinit/coreinit_LockedCache.cpp index 05fd1645..a51dccf4 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_LockedCache.cpp +++ b/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() diff --git a/src/Cafe/OS/libs/coreinit/coreinit_MEM.cpp b/src/Cafe/OS/libs/coreinit/coreinit_MEM.cpp index e7594de1..dd2c3864 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_MEM.cpp +++ b/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.writeBE(g_heapTableCount); + s.write(sysAreaAllocatorOffset); + 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.readBE(g_heapTableCount); + s.read(sysAreaAllocatorOffset); + s.read(g_heapTableCount); s.readData(g_heapTable, sizeof(MEMHeapBase) * MEM_MAX_HEAP_TABLE); s.readBool(g_slockInitialized); s.readBool(g_listsInitialized); diff --git a/src/Cafe/OS/libs/coreinit/coreinit_MemoryMapping.cpp b/src/Cafe/OS/libs/coreinit/coreinit_MemoryMapping.cpp index 626a4daa..0be5ce08 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_MemoryMapping.cpp +++ b/src/Cafe/OS/libs/coreinit/coreinit_MemoryMapping.cpp @@ -155,26 +155,25 @@ namespace coreinit void MemoryMapping_Save(MemStreamWriter& s) { - s.writeSection("coreinit_MemoryMapping "); - s.writeBE(s_allocatedVirtMemory.size()); + s.writeSection("coreinit_MemoryMapping"); + s.write(s_allocatedVirtMemory.size()); for (auto i : s_allocatedVirtMemory) { - s.writeBE(i.virtualAddress); - s.writeBE(i.size); - s.writeBE(i.alignment); + s.write(i.virtualAddress); + s.write(i.size); + s.write(i.alignment); } } void MemoryMapping_Restore(MemStreamReader& s) { - s.readSection("coreinit_MemoryMapping "); - s.readPODVector(s_allocatedVirtMemory); - uint32 s_allocatedVirtMemorySize = s.readBE(); + s.readSection("coreinit_MemoryMapping"); + uint32 s_allocatedVirtMemorySize = s.read(); s_allocatedVirtMemory.clear(); s_allocatedVirtMemory.reserve(s_allocatedVirtMemorySize); for (sint32 i = 0; i < s_allocatedVirtMemorySize; i++) { - s_allocatedVirtMemory.push_back(OSVirtMemoryEntry(s.readBE(), s.readBE(), s.readBE())); + s_allocatedVirtMemory.push_back(OSVirtMemoryEntry(s.read(), s.read(), s.read())); } } diff --git a/src/Cafe/OS/libs/coreinit/coreinit_SysHeap.cpp b/src/Cafe/OS/libs/coreinit/coreinit_SysHeap.cpp index 43d5bbf7..7603c513 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_SysHeap.cpp +++ b/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.writeBE(_sysHeapFreeCounter); + s.write(_sysHeapAllocCounter); + s.write(_sysHeapFreeCounter); } void SysHeap_Restore(MemStreamReader& s) { s.readSection("coreinit_SysHeap"); s.readData(_sysHeapHandle, sizeof(MEMHeapBase)); - s.readBE(_sysHeapAllocCounter); - s.readBE(_sysHeapFreeCounter); + s.read(_sysHeapAllocCounter); + s.read(_sysHeapFreeCounter); } void InitializeSysHeap() diff --git a/src/Cafe/OS/libs/coreinit/coreinit_Thread.cpp b/src/Cafe/OS/libs/coreinit/coreinit_Thread.cpp index 3237cf61..bce0955c 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_Thread.cpp +++ b/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()); + sSchedulerActive.store(s.read()); s.readMPTR(g_activeThreadQueue); s.readMPTR(g_coreRunQueue); - sint32 prevActiveThreadCount = s.readBE(); + sint32 prevActiveThreadCount = s.read(); for (sint32 i = 0; i < prevActiveThreadCount; i++) { - MPTR threadMPTR = s.readBE(); + MPTR threadMPTR = s.read(); 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); diff --git a/src/Cafe/OS/libs/dmae/dmae.cpp b/src/Cafe/OS/libs/dmae/dmae.cpp index 1a02f61a..1d12328c 100644 --- a/src/Cafe/OS/libs/dmae/dmae.cpp +++ b/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() diff --git a/src/Cafe/OS/libs/nlibcurl/nlibcurl.cpp b/src/Cafe/OS/libs/nlibcurl/nlibcurl.cpp index fafa21ed..c6545768 100644 --- a/src/Cafe/OS/libs/nlibcurl/nlibcurl.cpp +++ b/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); diff --git a/src/Cafe/OS/libs/nn_act/nn_act.cpp b/src/Cafe/OS/libs/nn_act/nn_act.cpp index f9b52871..ff465c88 100644 --- a/src/Cafe/OS/libs/nn_act/nn_act.cpp +++ b/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.writeBE((uint32)g_isParentalControlCheckEnabled); + s.write(nn::act::g_initializeCount); + s.write((uint32)g_isParentalControlCheckEnabled); } void nnAct_restore(MemStreamReader& s) { s.readSection("nn_act"); - s.readBE(nn::act::g_initializeCount); - g_isParentalControlCheckEnabled = s.readBE(); + s.read(nn::act::g_initializeCount); + g_isParentalControlCheckEnabled = s.read(); } // register account functions diff --git a/src/Cafe/OS/libs/nn_aoc/nn_aoc.cpp b/src/Cafe/OS/libs/nn_aoc/nn_aoc.cpp index 2071153a..dfd4df2f 100644 --- a/src/Cafe/OS/libs/nn_aoc/nn_aoc.cpp +++ b/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(sAocCache.size()); + s.write(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 sAocCacheSize = s.read(); sAocCache.clear(); sAocCache.reserve(sAocCacheSize); for (sint32 i = 0; i < sAocCacheSize; i++) { - sAocCache.emplace_back(s.readBE()); + sAocCache.emplace_back(s.read()); } s.readBool(sAocCacheGenerated); } diff --git a/src/Cafe/OS/libs/nn_boss/nn_boss.cpp b/src/Cafe/OS/libs/nn_boss/nn_boss.cpp index f71be91f..67a0bb76 100644 --- a/src/Cafe/OS/libs/nn_boss/nn_boss.cpp +++ b/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); } diff --git a/src/Cafe/OS/libs/nn_ndm/nn_ndm.cpp b/src/Cafe/OS/libs/nn_ndm/nn_ndm.cpp index c50641c4..b47fbf76 100644 --- a/src/Cafe/OS/libs/nn_ndm/nn_ndm.cpp +++ b/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() diff --git a/src/Cafe/OS/libs/nn_olv/nn_olv.cpp b/src/Cafe/OS/libs/nn_olv/nn_olv.cpp index 94223bb6..73e19175 100644 --- a/src/Cafe/OS/libs/nn_olv/nn_olv.cpp +++ b/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); diff --git a/src/Cafe/OS/libs/nn_temp/nn_temp.cpp b/src/Cafe/OS/libs/nn_temp/nn_temp.cpp index b904f5b2..be0d7fe3 100644 --- a/src/Cafe/OS/libs/nn_temp/nn_temp.cpp +++ b/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() diff --git a/src/Cafe/OS/libs/nsyshid/nsyshid.cpp b/src/Cafe/OS/libs/nsyshid/nsyshid.cpp index 129e5a93..62e4df8d 100644 --- a/src/Cafe/OS/libs/nsyshid/nsyshid.cpp +++ b/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(); i++) + for (size_t i = 0; i < s.read(); i++) _devicePoolMask.set(i); } diff --git a/src/Cafe/OS/libs/nsysnet/nsysnet.cpp b/src/Cafe/OS/libs/nsysnet/nsysnet.cpp index aa8d454f..b136df51 100644 --- a/src/Cafe/OS/libs/nsysnet/nsysnet.cpp +++ b/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); - writeBE(v.clientPKI); + write(v.sslVersion); + write(v.clientPKI); - writeBE(v.serverPKIs.size()); + write(v.serverPKIs.size()); for (auto i : v.serverPKIs) - writeBE(i); + write(i); - writeBE(v.serverCustomPKIs.size()); + write(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); - readBE(v.clientPKI); + read(v.sslVersion); + read(v.clientPKI); - uint32 serverPKIsSize = readBE(); + uint32 serverPKIsSize = read(); v.serverPKIs.clear(); for (uint32 i = 0; i < serverPKIsSize; i++) - v.serverPKIs.insert(readBE()); + v.serverPKIs.insert(read()); - uint32 serverCustomPKIsSize = readBE(); + uint32 serverCustomPKIsSize = read(); 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(nsysnet::g_nsslInternalStates.size()); + s.write(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 g_nsslInternalStatesSize = s.read(); 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); diff --git a/src/Cafe/OS/libs/padscore/padscore.cpp b/src/Cafe/OS/libs/padscore/padscore.cpp index fb9e2cf4..f6531d32 100644 --- a/src/Cafe/OS/libs/padscore/padscore.cpp +++ b/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(); + g_wpad_state = (WPADState_t)s.read(); } void load() diff --git a/src/util/helpers/Serializer.cpp b/src/util/helpers/Serializer.cpp index 5a76337b..fd63b93c 100644 --- a/src/util/helpers/Serializer.cpp +++ b/src/util/helpers/Serializer.cpp @@ -1,5 +1,91 @@ #include "Serializer.h" +// read return + +template +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(); +template uint16 MemStreamReader::read(); +template uint32 MemStreamReader::read(); +template uint32be MemStreamReader::read(); +template uint64 MemStreamReader::read(); +template int MemStreamReader::read(); + +template<> +std::string MemStreamReader::read() +{ + std::string s; + uint32 stringSize = read(); + 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 +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(); + 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() == sec_str); +} + // readBE return template @@ -19,7 +105,6 @@ template uint8 MemStreamReader::readBE(); template uint16 MemStreamReader::readBE(); template uint32 MemStreamReader::readBE(); template uint64 MemStreamReader::readBE(); -template int MemStreamReader::readBE(); template<> std::string MemStreamReader::readBE() @@ -39,45 +124,6 @@ std::string MemStreamReader::readBE() return s; } -// readBE void - -template -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(); - 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 @@ -94,15 +140,39 @@ T MemStreamReader::readLE() } template uint8 MemStreamReader::readLE(); -template uint16 MemStreamReader::readLE(); template uint32 MemStreamReader::readLE(); +template uint64 MemStreamReader::readLE(); -// readSection +// write void -void MemStreamReader::readSection(const char* sec) +template +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(const std::string& v) +{ + write((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() == 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(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 uint16& v); +template void MemStreamWriter::writeLE(const uint64& 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); -} \ No newline at end of file diff --git a/src/util/helpers/Serializer.h b/src/util/helpers/Serializer.h index 0e493254..5d854e48 100644 --- a/src/util/helpers/Serializer.h +++ b/src/util/helpers/Serializer.h @@ -8,14 +8,21 @@ public: m_cursorPos = 0; } + template T read(); + template void read(T& v); template T readBE(); template void readBE(T& v); template T readLE(); + void readAtomic(std::atomic& v) + { + v.store(readBool()); + } + template void readAtomic(std::atomic& v) { - v.store(readBE()); + v.store(read()); } template @@ -48,29 +55,29 @@ public: template void readPTR(T& v) { - v = (T)(memory_base + readBE()); + v = (T)(memory_base + read()); } template class C, typename T> void readMPTR(C& v) { - v = (T*)(memory_base + readBE()); + v = (T*)(memory_base + read()); } template class C, typename T, size_t c, size_t a> void readMPTR(C& v) { - v = (T*)(memory_base + readBE()); + v = (T*)(memory_base + read()); } void readBool(bool& v) { - v = readBE(); + v = read(); } bool readBool() { - return readBE(); + return read(); } void readSection(const char* sec); @@ -212,13 +219,19 @@ public: } } + template void write(const T& v); template void writeBE(const T& v); template void writeLE(const T& v); + void writeAtomic(const std::atomic& v) + { + writeBool(v.load()); + } + template void writeAtomic(const std::atomic& v) { - writeBE(v.load()); + write(v.load()); } template @@ -232,18 +245,18 @@ public: template void writePTR(const T& v) { - writeBE((uint32)((uint8*)v - (uint8*)memory_base)); + write((uint32)((uint8*)v - (uint8*)memory_base)); } template 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);