archive/Cemu
1
0
Fork 0
mirror of https://github.com/cemu-project/Cemu.git synced 2025-07-04 05:51:19 +12:00
Code Issues Projects Releases Packages Wiki Activity Actions

Refactoring, save/restore additional libs

Browse source
This commit is contained in:
Chris Spegal 2023-10-08 10:34:45 -04:00
parent 288c8d9854
commit 35f6e67903
87 changed files with 1024 additions and 717 deletions
Download patch file Download diff file Expand all files Collapse all files

26
src/Cafe/CafeSystem.cpp
View file

@ -1007,13 +1007,10 @@ namespace CafeSystem
writer.writeData(LatteGPUState.contextRegister, sizeof(LatteGPUState.contextRegister));
writer.writeData(LatteGPUState.contextRegisterShadowAddr, sizeof(LatteGPUState.contextRegister));
writer.writeData(LatteGPUState.sharedArea, sizeof(gx2GPUSharedArea_t));
// cpu
ci_Save(writer);
coreinit::ci_Alarm_Save(writer);
ci_Callbacks_Save(writer);
coreinit::ci_FS_Save(writer);
ci_Init_Save(writer);
coreinit::ci_Thread_Save(writer);
nn::temp::save(writer);
nn::aoc::save(writer);
osLib_save(writer);
iosu::fsa::Save(writer);
FileStream* stream = FileStream::createFile(path);
@ -1034,10 +1031,6 @@ namespace CafeSystem
assert(data.has_value());
MemStreamReader reader(data->data(), data->size());
bool recreate = false;
if (recreate)
coreinit::__OSDeleteAllActivePPCThreads();
// memory
DestroyMemorySpace();
memory_Deserialize(reader);
@ -1045,13 +1038,10 @@ namespace CafeSystem
reader.readData(LatteGPUState.contextRegister, sizeof(LatteGPUState.contextRegister));
reader.readData(LatteGPUState.contextRegisterShadowAddr, sizeof(LatteGPUState.contextRegister));
reader.readData(LatteGPUState.sharedArea, sizeof(gx2GPUSharedArea_t));
// cpu
ci_Restore(reader);
coreinit::ci_Alarm_Restore(reader);
ci_Callbacks_Restore(reader);
coreinit::ci_FS_Restore(reader);
ci_Init_Restore(reader);
coreinit::ci_Thread_Restore(reader, recreate);
nn::temp::restore(reader);
nn::aoc::restore(reader);
osLib_restore(reader);
iosu::fsa::Restore(reader);
cemuLog_log(LogType::SaveStates, "Loaded state from {}.", path);

53
src/Cafe/Filesystem/fsc.cpp
View file

@ -285,8 +285,6 @@ FSCMountPathNode* fsc_lookupPathVirtualNode(const char* path, sint32 priority)
class FSCVirtualFileDirectoryIterator : public FSCVirtualFile
{
public:
void Save(MemStreamWriter& writer) override;
sint32 fscGetType() override
{
return FSC_TYPE_DIRECTORY;
@ -340,6 +338,8 @@ public:
dirIterator->dirEntries.emplace_back(dirEntry);
}
void Save(MemStreamWriter& writer) override;
private:
void PopulateIterationList()
{
@ -736,11 +736,39 @@ void fsc_init()
fsc_reset();
}
template <>
void MemStreamWriter::writeBE<FSCVirtualFile::FSCDirIteratorState>(const FSCVirtualFile::FSCDirIteratorState& v)
{
writeBE(v.index);
writePODVector(v.dirEntries);
}
template <>
void MemStreamReader::readBE(FSCVirtualFile::FSCDirIteratorState& v)
{
readBE(v.index);
readPODVector(v.dirEntries);
}
void FSCVirtualFile::Save(MemStreamWriter& writer)
{
writer.writeBE(dirIterator != nullptr);
writer.writeBool(dirIterator != nullptr);
if (dirIterator) writer.writeBE(*dirIterator);
writer.writeBool(m_isAppend);
}
void FSCVirtualFileDirectoryIterator::Save(MemStreamWriter& writer)
{
writer.writeBE<uint32>((uint32)Child::DIRECTORY_ITERATOR);
writer.writeBE(m_path);
writer.writeBE<uint32>(m_folders.size());
for (auto& folder : m_folders)
{
folder->Save(writer);
}
FSCVirtualFile::Save(writer);
}
#include "Cafe/Filesystem/fscDeviceHostFS.h"
FSCVirtualFile* FSCVirtualFile::Restore(MemStreamReader& reader)
@ -752,7 +780,7 @@ FSCVirtualFile* FSCVirtualFile::Restore(MemStreamReader& reader)
{
std::string path = reader.readBE<std::string>();
std::vector<FSCVirtualFile*> folders{};
size_t size = reader.readBE<size_t>();
size_t size = reader.readBE<uint32>();
for (size_t i = 0; i < size; i++)
{
folders.push_back(Restore(reader));
@ -772,22 +800,11 @@ FSCVirtualFile* FSCVirtualFile::Restore(MemStreamReader& reader)
default:
throw std::exception("Not implemented");
}
if (reader.readBE<bool>())
if (reader.readBool())
{
file->dirIterator = new FSCDirIteratorState;
*file->dirIterator = reader.readBE<FSCDirIteratorState>();
reader.readBE(*file->dirIterator);
}
reader.readBool(file->m_isAppend);
return file;
}
void FSCVirtualFileDirectoryIterator::Save(MemStreamWriter& writer)
{
writer.writeBE<uint32>((uint32)Child::DIRECTORY_ITERATOR);
writer.writeBE(m_path);
writer.writeBE(m_folders.size());
for (auto& folder : m_folders)
{
folder->Save(writer);
}
FSCVirtualFile::Save(writer);
}

1
src/Cafe/Filesystem/fsc.h
View file

@ -38,7 +38,6 @@ 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)

22
src/Cafe/Filesystem/fscDeviceHostFS.cpp
View file

@ -157,19 +157,6 @@ bool FSCVirtualFile_Host::fscDirNext(FSCDirEntry* dirEntry)
return true;
}
void FSCVirtualFile_Host::Save(MemStreamWriter& writer)
{
writer.writeBE<uint32>((uint32)Child::HOST);
writer.writeBE(m_path->string());
writer.writeBE((uint32)m_accessFlags);
writer.writeBE(m_seek);
FSCVirtualFile::Save(writer);
}
FSCVirtualFile* FSCVirtualFile_Host::OpenFile(const fs::path& path, FSC_ACCESS_FLAG accessFlags, sint32& fscStatus)
{
if (!HAS_FLAG(accessFlags, FSC_ACCESS_FLAG::OPEN_FILE) && !HAS_FLAG(accessFlags, FSC_ACCESS_FLAG::OPEN_DIR))
@ -309,3 +296,12 @@ bool FSCDeviceHostFS_Mount(std::string_view mountPath, std::string_view hostTarg
{
return fsc_mount(mountPath, hostTargetPath, &fscDeviceHostFSC::instance(), nullptr, priority) == FSC_STATUS_OK;
}
void FSCVirtualFile_Host::Save(MemStreamWriter& writer)
{
writer.writeBE<uint32>((uint32)Child::HOST);
writer.writeBE(m_path->string());
writer.writeBE((uint32)m_accessFlags);
writer.writeBE(m_seek);
FSCVirtualFile::Save(writer);
}

3
src/Cafe/Filesystem/fscDeviceHostFS.h
View file

@ -3,7 +3,6 @@
class FSCVirtualFile_Host : public FSCVirtualFile
{
public:
void Save(MemStreamWriter& writer) override;
static FSCVirtualFile* OpenFile(const fs::path& path, FSC_ACCESS_FLAG accessFlags, sint32& fscStatus);
~FSCVirtualFile_Host() override;
@ -19,6 +18,8 @@ public:
void fscSetFileLength(uint64 endOffset) override;
bool fscDirNext(FSCDirEntry* dirEntry) override;
void Save(MemStreamWriter& writer) override;
private:
FSCVirtualFile_Host(uint32 type) : m_type(type) {};

10
src/Cafe/Filesystem/fscDeviceWua.cpp
View file

@ -15,11 +15,6 @@ protected:
};
public:
void Save(MemStreamWriter& writer) override
{
throw std::exception("Not implemented");
}
sint32 fscGetType() override
{
return m_fscType;
@ -112,6 +107,11 @@ public:
return true;
}
void Save(MemStreamWriter& writer) override
{
throw std::exception("Not implemented");
}
private:
ZArchiveReader* m_archive{nullptr};
sint32 m_fscType;

10
src/Cafe/Filesystem/fscDeviceWud.cpp
View file

@ -22,11 +22,6 @@ protected:
}
public:
void Save(MemStreamWriter& writer) override
{
throw std::exception("Not implemented");
}
sint32 fscGetType() override
{
return m_fscType;
@ -113,6 +108,11 @@ public:
return true;
}
void Save(MemStreamWriter& writer) override
{
throw std::exception("Not implemented");
}
private:
FSTVolume* m_volume{nullptr};
sint32 m_fscType;

44
src/Cafe/HW/MMU/MMU.cpp
View file

@ -80,37 +80,22 @@ MMURange* memory_getMMURangeByAddress(MPTR address)
return nullptr;
}
bool MMURange::serializeImpl(MemStreamWriter& streamWriter)
{
streamWriter.writeBE<bool>(this->m_isMapped);
if (m_isMapped)
{
streamWriter.writeBE(this->baseAddress);
streamWriter.writeBE<uint8>((uint8)this->areaId);
streamWriter.writeBE<uint8>((uint8)this->flags);
streamWriter.writeBE(this->name);
streamWriter.writeBE(this->size);
streamWriter.writeBE(this->initSize);
}
return true;
}
template<>
void MemStreamWriter::writeBE<MMURange>(const MMURange& v)
void MemStreamWriter::writeBE(const MMURange& v)
{
writeBE(v.m_isMapped);
writeBool(v.m_isMapped);
writeBE(v.baseAddress);
writeBE<uint8>((uint8)v.areaId);
writeBE<uint8>((uint8)v.flags);
writeBE((uint8)v.areaId);
writeBE((uint8)v.flags);
writeBE(v.name);
writeBE(v.size);
writeBE(v.initSize);
}
template <>
void MemStreamReader::readBE<MMURange>(MMURange& mmuRange)
void MemStreamReader::readBE(MMURange& mmuRange)
{
bool needsMapped = readBE<bool>();
bool needsMapped = readBool();
mmuRange.m_isMapped = false;
mmuRange.baseAddress = readBE<uint32>();
mmuRange.areaId = (MMU_MEM_AREA_ID)readBE<uint8>();
@ -122,23 +107,6 @@ void MemStreamReader::readBE<MMURange>(MMURange& mmuRange)
mmuRange.mapMem();
}
bool MMURange::deserializeImpl(MemStreamReader& streamReader)
{
m_isMapped = streamReader.readBE<bool>();
if (m_isMapped)
{
baseAddress = streamReader.readBE<uint32>();
areaId = (MMU_MEM_AREA_ID)streamReader.readBE<uint8>();
this->flags = (MFLAG)streamReader.readBE<uint8>();
this->name = streamReader.readBE<std::string>();
this->size = streamReader.readBE<uint32>();
this->initSize = streamReader.readBE<uint32>();
m_isMapped = false;
mapMem();
}
return true;
}
MMURange::MMURange(const uint32 baseAddress, const uint32 size, MMU_MEM_AREA_ID areaId, const std::string_view name, MFLAG flags) : baseAddress(baseAddress), size(size), initSize(size), areaId(areaId), name(name), flags(flags)
{
g_mmuRanges.emplace_back(this);

3
src/Cafe/HW/MMU/MMU.h
View file

@ -51,9 +51,6 @@ struct MMURange
FLAG_MAP_EARLY = (1 << 1), // map at Cemu launch, normally memory is mapped when a game is loaded
};
bool serializeImpl(MemStreamWriter& streamWriter);
bool deserializeImpl(MemStreamReader& streamReader);
MMURange(const uint32 baseAddress, const uint32 size, MMU_MEM_AREA_ID areaId, const std::string_view name, MFLAG flags = (MFLAG)0);
void mapMem();

136
src/Cafe/IOSU/fsa/iosu_fsa.cpp
View file

@ -36,7 +36,9 @@ namespace iosu
}
};
std::array<FSAClient, 624> sFSAClientArray;
static constexpr int const sFSAClientArraySize = 624;
std::array<FSAClient, sFSAClientArraySize> sFSAClientArray;
IOS_ERROR FSAAllocateClient(sint32& indexOut)
{
@ -229,9 +231,10 @@ namespace iosu
return it.fscFile;
}
static constexpr int const m_handleTableSize = 0x3C0;
private:
uint32 m_currentCounter = 1;
std::array<_FSAHandleResource, 0x3C0> m_handleTable;
std::array<_FSAHandleResource, m_handleTableSize> m_handleTable;
};
_FSAHandleTable sFileHandleTable;
@ -908,113 +911,76 @@ namespace iosu
} // namespace iosu
template <>
void MemStreamWriter::writeBE<FSCDirEntry>(const FSCDirEntry& v);
template <>
FSCDirEntry MemStreamReader::readBE<FSCDirEntry>();
template <>
FSCVirtualFile::FSCDirIteratorState MemStreamReader::readBE<FSCVirtualFile::FSCDirIteratorState>();
template <>
void MemStreamWriter::writeBE<FSCVirtualFile::FSCDirIteratorState>(const FSCVirtualFile::FSCDirIteratorState& v);
void MemStreamWriter::writeBE(const iosu::fsa::FSAClient& v)
{
writeBE(v.workingDirectory);
writeBool(v.isAllocated);
}
template <>
void MemStreamWriter::writeBE<iosu::fsa::_FSAHandleTable>(const iosu::fsa::_FSAHandleTable& v)
void MemStreamReader::readBE(iosu::fsa::FSAClient& v)
{
readBE(v.workingDirectory);
readBool(v.isAllocated);
}
template <>
void MemStreamWriter::writeBE(const iosu::fsa::_FSAHandleTable& v)
{
writeBE(v.m_currentCounter);
for (int i = 0; i < 0x3C0; i++)
for (sint32 i = 0; i < v.m_handleTableSize; i++)
{
writeBE(v.m_handleTable[i].handleCheckValue);
writeBE(v.m_handleTable[i].isAllocated);
writeBE(v.m_handleTable[i].fscFile != nullptr);
writeBool(v.m_handleTable[i].isAllocated);
writeBool(v.m_handleTable[i].fscFile != nullptr);
if (v.m_handleTable[i].fscFile != nullptr) v.m_handleTable[i].fscFile->Save(*this);
}
}
template <>
iosu::fsa::_FSAHandleTable MemStreamReader::readBE<iosu::fsa::_FSAHandleTable>()
void MemStreamReader::readBE(iosu::fsa::_FSAHandleTable& v)
{
iosu::fsa::_FSAHandleTable table{};
table.m_currentCounter = readBE<uint32>();
for (int i = 0; i < 0x3C0; i++)
readBE(v.m_currentCounter);
for (sint32 i = 0; i < v.m_handleTableSize; i++)
{
table.m_handleTable[i].handleCheckValue = readBE<uint16>();
table.m_handleTable[i].isAllocated = readBE<bool>();
if (readBE<bool>()) table.m_handleTable[i].fscFile = FSCVirtualFile::Restore(*this);
}
return table;
}
readBE(v.m_handleTable[i].handleCheckValue);
readBool(v.m_handleTable[i].isAllocated);
template <>
void MemStreamWriter::writeBE<FSCVirtualFile::FSCDirIteratorState>(const FSCVirtualFile::FSCDirIteratorState& v)
{
writeBE(v.index);
writeBE(v.dirEntries.size());
for (int i = 0; i < v.dirEntries.size(); i++)
{
writeBE(v.dirEntries[i]);
if (readBool()) v.m_handleTable[i].fscFile = FSCVirtualFile::Restore(*this);
}
}
template <>
void MemStreamWriter::writeBE<FSCDirEntry>(const FSCDirEntry& v)
namespace iosu
{
writeData(v.path, FSC_MAX_DIR_NAME_LENGTH);
writeBE(v.isDirectory);
writeBE(v.isFile);
writeBE(v.fileSize);
}
template <>
FSCDirEntry MemStreamReader::readBE<FSCDirEntry>()
{
FSCDirEntry entry{};
readData(entry.path, FSC_MAX_DIR_NAME_LENGTH);
entry.isDirectory = readBE<bool>();
entry.isFile = readBE<bool>();
entry.fileSize = readBE<uint32>();
return entry;
}
template <>
FSCVirtualFile::FSCDirIteratorState MemStreamReader::readBE<FSCVirtualFile::FSCDirIteratorState>()
{
FSCVirtualFile::FSCDirIteratorState state{};
state.index = readBE<sint32>();
size_t size = readBE<size_t>();
for (size_t i = 0; i < size; i++)
namespace fsa
{
state.dirEntries[i] = readBE<FSCDirEntry>();
void Save(MemStreamWriter& s)
{
s.writeSection("iosu_fsa");
s.writeBE(sFSAIoMsgQueue);
s.writeMPTR(_m_sFSAIoMsgQueueMsgBuffer);
for (sint32 i = 0; i < sFSAClientArraySize; i++)
{
s.writeBE(sFSAClientArray[i]);
}
return state;
}
namespace iosu::fsa
{
void Save(MemStreamWriter& writer)
{
writer.writeData("iosu_fsa_S", 15);
writer.writeBE(sFSAIoMsgQueue);
for (size_t i = 0; i < 352; i++)
{
writer.writeBE(_m_sFSAIoMsgQueueMsgBuffer[i]);
}
writer.writeBE(sDirHandleTable);
writer.writeBE(sFileHandleTable);
s.writeBE(sDirHandleTable);
s.writeBE(sFileHandleTable);
}
void Restore(MemStreamReader& reader)
void Restore(MemStreamReader& s)
{
char section[16] = { '\0' };
reader.readData(section, 15);
cemu_assert_debug(strcmp(section, "iosu_fsa_S") == 0);
s.readSection("iosu_fsa");
s.readBE(sFSAIoMsgQueue);
s.readMPTR(_m_sFSAIoMsgQueueMsgBuffer);
sFSAIoMsgQueue = reader.readBE<IOSMsgQueueId>();
for (size_t i = 0; i < 352; i++)
for (sint32 i = 0; i < sFSAClientArraySize; i++)
{
_m_sFSAIoMsgQueueMsgBuffer[i] = reader.readBE<iosu::kernel::IOSMessage>();
s.readBE(sFSAClientArray[i]);
}
sDirHandleTable = reader.readBE<_FSAHandleTable>();
sFileHandleTable = reader.readBE<_FSAHandleTable>();
s.readBE(sDirHandleTable);
s.readBE(sFileHandleTable);
}
}
} // namespace fsa
} // namespace iosu

41
src/Cafe/OS/common/OSCommon.cpp
View file

@ -185,6 +185,47 @@ void osLib_returnFromFunction64(PPCInterpreter_t* hCPU, uint64 returnValue64)
hCPU->instructionPointer = hCPU->spr.LR;
}
void osLib_save(MemStreamWriter& s)
{
coreinit_save(s);
dmae_save(s);
padscore::save(s);
nnAct_save(s);
nn::acp::save(s);
nnBoss_save(s);
nn::nfp::save(s);
nnUds_save(s);
nn::ndm::save(s);
nn::save::save(s);
nsysnet_save(s);
nn::fp::save(s);
nn::olv::save(s);
nlibcurl::save(s);
nsyshid::save(s);
camera::save(s);
procui_save(s);
}
void osLib_restore(MemStreamReader& s)
{
coreinit_restore(s);
dmae_restore(s);
padscore::restore(s);
nnAct_restore(s);
nn::acp::restore(s);
nnBoss_restore(s);
nn::nfp::restore(s);
nnUds_restore(s);
nn::ndm::restore(s);
nn::save::restore(s);
nsysnet_restore(s);
nn::fp::restore(s);
nn::olv::restore(s);
nlibcurl::restore(s);
nsyshid::restore(s);
camera::restore(s);
procui_restore(s);
}
void osLib_load()
{
// load HLE modules

3
src/Cafe/OS/common/OSCommon.h
View file

@ -6,6 +6,9 @@ struct PPCInterpreter_t;
#define OSLIB_FUNCTIONTABLE_TYPE_FUNCTION (1)
#define OSLIB_FUNCTIONTABLE_TYPE_POINTER (2)
void osLib_save(MemStreamWriter& s);
void osLib_restore(MemStreamReader& s);
void osLib_load();
void osLib_generateHashFromName(const char* name, uint32* hashA, uint32* hashB);
sint32 osLib_getFunctionIndex(const char* libraryName, const char* functionName);

24
src/Cafe/OS/libs/camera/camera.cpp
View file

@ -242,6 +242,29 @@ namespace camera
g_cameraCounter = 0;
}
void save(MemStreamWriter& s)
{
s.writeSection("camera");
s.writePODVector(g_table_cameraHandles);
s.writePODVector(g_activeCameraInstances);
s.writeAtomic(g_cameraCounter);
s.writeMPTR(g_alarm_camera);
s.writeMPTR(g_cameraHandlerParam);
}
void restore(MemStreamReader& s)
{
s.readSection("camera");
std::unique_lock<std::recursive_mutex> _lock(g_mutex_camera);
s.readPODVector(g_table_cameraHandles);
s.readPODVector(g_activeCameraInstances);
s.readAtomic(g_cameraCounter);
s.readMPTR(g_alarm_camera);
s.readMPTR(g_cameraHandlerParam);
}
void load()
{
reset();
@ -254,4 +277,3 @@ namespace camera
cafeExportRegister("camera", CAMSubmitTargetSurface, LogType::Placeholder);
}
}

3
src/Cafe/OS/libs/camera/camera.h
View file

@ -6,5 +6,8 @@ namespace camera
sint32 CAMOpen(sint32 camHandle);
sint32 CAMClose(sint32 camHandle);
void save(MemStreamWriter& s);
void restore(MemStreamReader& s);
void load();
};

82
src/Cafe/OS/libs/coreinit/coreinit.cpp
View file

@ -316,54 +316,64 @@ namespace coreinit
}
};
void ci_Save(MemStreamWriter& s)
void coreinit_save(MemStreamWriter& s)
{
s.writeData("ci_S", 15);
s.writeSection("coreinit");
s.writeData(gCoreinitData, sizeof(coreinitData_t));
s.writeBE(placeholderFont);
s.writeBE(placeholderFontSize);
using namespace coreinit;
ci_CodeGen_Save(s);
ci_DynLoad_Save(s);
ci_FG_Save(s);
ci_GHS_Save(s);
ci_IPC_Save(s);
ci_LockedCache_Save(s);
ci_MEM_Save(s);
ci_MemoryMapping_Save(s);
ci_MessageQueue_Save(s);
ci_OverlayArena_Save(s);
ci_Sync_Save(s);
ci_SysHeap_Save(s);
ci_SystemInfo_Save(s);
coreinit_Init_Save(s);
coreinit::SysHeap_Save(s);
coreinit::Thread_Save(s);
coreinit::MEM_Save(s);
coreinit::FG_Save(s);
coreinit::OverlayArena_Save(s);
coreinit::DynLoad_Save(s);
coreinit::GHS_Save(s);
coreinit::LockedCache_Save(s);
coreinit::Alarm_Save(s);
coreinit::FS_Save(s);
coreinit::SystemInfo_Save(s);
coreinit::Synchronization_Save(s);
coreinit::MessageQueue_Save(s);
coreinit::IPC_Save(s);
coreinit::MemoryMapping_Save(s);
coreinit::CodeGen_Save(s);
coreinit_Callbacks_Save(s);
}
void ci_Restore(MemStreamReader& s)
void coreinit_restore(MemStreamReader& s)
{
char section[16] = { '\0' };
s.readData(section, 15);
cemu_assert_debug(strcmp(section, "ci_S") == 0);
s.readSection("coreinit");
bool recreate = false;
if (recreate)
coreinit::__OSDeleteAllActivePPCThreads();
s.readData(gCoreinitData, sizeof(coreinitData_t));
placeholderFont = s.readBE<MPTR>();
placeholderFontSize = s.readBE<sint32>();
s.readBE(placeholderFont);
s.readBE(placeholderFontSize);
using namespace coreinit;
ci_CodeGen_Restore(s);
ci_DynLoad_Restore(s);
ci_FG_Restore(s);
ci_GHS_Restore(s);
ci_IPC_Restore(s);
ci_LockedCache_Restore(s);
ci_MEM_Restore(s);
ci_MemoryMapping_Restore(s);
ci_MessageQueue_Restore(s);
ci_OverlayArena_Restore(s);
ci_Sync_Restore(s);
ci_SysHeap_Restore(s);
ci_SystemInfo_Restore(s);
coreinit_Init_Restore(s);
coreinit::SysHeap_Restore(s);
coreinit::Thread_Restore(s, recreate);
coreinit::MEM_Restore(s);
coreinit::FG_Restore(s);
coreinit::OverlayArena_Restore(s);
coreinit::DynLoad_Restore(s);
coreinit::GHS_Restore(s);
coreinit::LockedCache_Restore(s);
coreinit::Alarm_Restore(s);
coreinit::FS_Restore(s);
coreinit::SystemInfo_Restore(s);
coreinit::Synchronization_Restore(s);
coreinit::MessageQueue_Restore(s);
coreinit::IPC_Restore(s);
coreinit::MemoryMapping_Restore(s);
coreinit::CodeGen_Restore(s);
coreinit_Callbacks_Restore(s);
}
void coreinit_load()

14
src/Cafe/OS/libs/coreinit/coreinit.h
View file

@ -11,15 +11,15 @@ void InitializeAsyncCallback();
void coreinitAsyncCallback_add(MPTR functionMPTR, uint32 numParameters, uint32 r3 = 0, uint32 r4 = 0, uint32 r5 = 0, uint32 r6 = 0, uint32 r7 = 0, uint32 r8 = 0, uint32 r9 = 0, uint32 r10 = 0);
void coreinitAsyncCallback_addWithLock(MPTR functionMPTR, uint32 numParameters, uint32 r3 = 0, uint32 r4 = 0, uint32 r5 = 0, uint32 r6 = 0, uint32 r7 = 0, uint32 r8 = 0, uint32 r9 = 0, uint32 r10 = 0);
void ci_Callbacks_Save(MemStreamWriter& s);
void ci_Callbacks_Restore(MemStreamReader& s);
void coreinit_Callbacks_Save(MemStreamWriter& s);
void coreinit_Callbacks_Restore(MemStreamReader& s);
// misc
void coreinit_load();
void coreinit_save(MemStreamWriter& s);
void coreinit_restore(MemStreamReader& s);
void ci_Save(MemStreamWriter& s);
void ci_Restore(MemStreamReader& s);
void coreinit_load();
// coreinit shared memory
@ -41,8 +41,8 @@ extern coreinitData_t* gCoreinitData;
// coreinit init
void coreinit_start(PPCInterpreter_t* hCPU);
void ci_Init_Save(MemStreamWriter& s);
void ci_Init_Restore(MemStreamReader& s);
void coreinit_Init_Save(MemStreamWriter& s);
void coreinit_Init_Restore(MemStreamReader& s);
MPTR OSAllocFromSystem(uint32 size, uint32 alignment);
void OSFreeToSystem(MPTR mem);

30
src/Cafe/OS/libs/coreinit/coreinit_Alarm.cpp
View file

@ -305,18 +305,18 @@ namespace coreinit
__OSUnlockScheduler();
}
void ci_Alarm_Save(MemStreamWriter& s)
void Alarm_Save(MemStreamWriter& s)
{
s.writeData("ci_A_S", 15);
s.writeSection("coreinit_Alarm");
s.writeBE(g_alarmEvent.GetMPTR());
s.writeBE(g_alarmThread.GetMPTR());
s.writeBE(_g_alarmThreadStack.GetMPTR());
s.writeBE(_g_alarmThreadName.GetMPTR());
s.writeMPTR(g_alarmEvent);
s.writeMPTR(g_alarmThread);
s.writeMPTR(_g_alarmThreadStack);
s.writeMPTR(_g_alarmThreadName);
s.writeBE(coreinit_getOSTime());
s.writeBE(g_activeAlarms.size());
s.writeBE((uint64)g_activeAlarms.size());
for (auto& itr : g_activeAlarms)
{
s.writeBE(memory_getVirtualOffsetFromPointer(itr.first));
@ -324,23 +324,21 @@ namespace coreinit
}
}
void ci_Alarm_Restore(MemStreamReader& s)
void Alarm_Restore(MemStreamReader& s)
{
OSAlarm_Shutdown();
char section[16] = { '\0' };
s.readData(section, 15);
cemu_assert_debug(strcmp(section, "ci_A_S") == 0);
s.readSection("coreinit_Alarm");
g_alarmEvent = (OSEvent*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
g_alarmThread = (OSThread_t*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
_g_alarmThreadStack = (uint8*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
_g_alarmThreadName = (char*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
s.readMPTR(g_alarmEvent);
s.readMPTR(g_alarmThread);
s.readMPTR(_g_alarmThreadStack);
s.readMPTR(_g_alarmThreadName);
uint64 currentTime = coreinit_getOSTime();
uint64_t timeOffset = currentTime - s.readBE<uint64_t>();
size_t alms = s.readBE<size_t>();
size_t alms = s.readBE<uint64>();
for (size_t alm = 0; alm < alms; alm++)
{
OSAlarm_t* alarm = (OSAlarm_t*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());

4
src/Cafe/OS/libs/coreinit/coreinit_Alarm.h
View file

@ -47,8 +47,8 @@ namespace coreinit
void OSAlarm_Shutdown();
void ci_Alarm_Save(MemStreamWriter& s);
void ci_Alarm_Restore(MemStreamReader& s);
void Alarm_Save(MemStreamWriter& s);
void Alarm_Restore(MemStreamReader& s);
void alarm_update();

62
src/Cafe/OS/libs/coreinit/coreinit_Callbacks.cpp
View file

@ -31,14 +31,14 @@ struct CoreinitAsyncCallback
s_asyncCallbackSpinlock.unlock();
}
static std::vector<struct CoreinitAsyncCallback*>* getPoolPtr()
static std::vector<struct CoreinitAsyncCallback*>& getPool()
{
return &s_asyncCallbackPool;
return s_asyncCallbackPool;
}
static std::vector<struct CoreinitAsyncCallback*>* getQueuePtr()
static std::vector<struct CoreinitAsyncCallback*>& getQueue()
{
return &s_asyncCallbackQueue;
return s_asyncCallbackQueue;
}
friend void ci_Callbacks_Save(MemStreamWriter& s);
@ -117,48 +117,26 @@ void coreinitAsyncCallback_add(MPTR functionMPTR, uint32 numParameters, uint32 r
coreinitAsyncCallback_addWithLock(functionMPTR, numParameters, r3, r4, r5, r6, r7, r8, r9, r10);
}
void ci_Callbacks_Save(MemStreamWriter& s)
void coreinit_Callbacks_Save(MemStreamWriter& s)
{
s.writeData("ci_C_S", 15);
s.writeBE(g_coreinitCallbackThread.GetMPTR());
s.writeBE(_g_coreinitCallbackThreadStack.GetMPTR());
s.writeBE(g_asyncCallbackAsync.GetMPTR());
s.writeBE(_g_coreinitCBThreadName.GetMPTR());
std::vector<struct CoreinitAsyncCallback*>* pool = CoreinitAsyncCallback::getPoolPtr();
size_t poolSize = pool->size();
s.writeBE(poolSize);
s.writeData(pool, sizeof(CoreinitAsyncCallback) * poolSize);
std::vector<struct CoreinitAsyncCallback*>* queue = CoreinitAsyncCallback::getQueuePtr();
size_t queueSize = queue->size();
s.writeBE(queueSize);
s.writeData(queue, sizeof(CoreinitAsyncCallback) * queueSize);
s.writeSection("coreinit_Callbacks");
s.writeMPTR(g_coreinitCallbackThread);
s.writeMPTR(_g_coreinitCallbackThreadStack);
s.writeMPTR(g_asyncCallbackAsync);
s.writeMPTR(_g_coreinitCBThreadName);
s.writePODVector(CoreinitAsyncCallback::getPool());
s.writePODVector(CoreinitAsyncCallback::getQueue());
}
void ci_Callbacks_Restore(MemStreamReader& s)
void coreinit_Callbacks_Restore(MemStreamReader& s)
{
char section[16] = { '\0' };
s.readData(section, 15);
cemu_assert_debug(strcmp(section, "ci_C_S") == 0);
g_coreinitCallbackThread = (OSThread_t*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
_g_coreinitCallbackThreadStack = (uint8*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
g_asyncCallbackAsync = (coreinit::OSSemaphore*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
_g_coreinitCBThreadName = (char*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
std::vector<struct CoreinitAsyncCallback*>* pool = CoreinitAsyncCallback::getPoolPtr();
size_t poolSize = s.readBE<size_t>();
pool->clear();
pool->resize(poolSize);
s.readData(pool, sizeof(CoreinitAsyncCallback) * poolSize);
std::vector<struct CoreinitAsyncCallback*>* queue = CoreinitAsyncCallback::getPoolPtr();
size_t queueSize = s.readBE<size_t>();
queue->clear();
queue->resize(queueSize);
s.readData(queue, sizeof(CoreinitAsyncCallback) * queueSize);
s.readSection("coreinit_Callbacks");
s.readMPTR(g_coreinitCallbackThread);
s.readMPTR(_g_coreinitCallbackThreadStack);
s.readMPTR(g_asyncCallbackAsync);
s.readMPTR(_g_coreinitCBThreadName);
s.readPODVector(CoreinitAsyncCallback::getPool());
s.readPODVector(CoreinitAsyncCallback::getQueue());
}
void InitializeAsyncCallback()

11
src/Cafe/OS/libs/coreinit/coreinit_CodeGen.cpp
View file

@ -136,18 +136,15 @@ namespace coreinit
return true;
}
void ci_CodeGen_Save(MemStreamWriter& s)
void CodeGen_Save(MemStreamWriter& s)
{
s.writeData("ci_CG_S", 15);
s.writeSection("coreinit_CodeGen");
s.writeData(&coreinitCodeGen, sizeof(coreinitCodeGen));
}
void ci_CodeGen_Restore(MemStreamReader& s)
void CodeGen_Restore(MemStreamReader& s)
{
char section[16] = { '\0' };
s.readData(section, 15);
cemu_assert_debug(strcmp(section, "ci_CG_S") == 0);
s.readSection("coreinit_CodeGen");
s.readData(&coreinitCodeGen, sizeof(coreinitCodeGen));
}

4
src/Cafe/OS/libs/coreinit/coreinit_CodeGen.h
View file

@ -6,8 +6,8 @@ namespace coreinit
void codeGenHandleICBI(uint32 ea);
bool codeGenShouldAvoid();
void ci_CodeGen_Save(MemStreamWriter& s);
void ci_CodeGen_Restore(MemStreamReader& s);
void CodeGen_Save(MemStreamWriter& s);
void CodeGen_Restore(MemStreamReader& s);
void InitializeCodeGen();
}

20
src/Cafe/OS/libs/coreinit/coreinit_DynLoad.cpp
View file

@ -129,26 +129,22 @@ namespace coreinit
return 0;
}
void ci_DynLoad_Save(MemStreamWriter& s)
void DynLoad_Save(MemStreamWriter& s)
{
s.writeData("ci_DL_S", 15);
s.writeSection("coreinit_DynLoad");
s.writeBE(_osDynLoadFuncAlloc);
s.writeBE(_osDynLoadFuncFree);
s.writeBE(_osDynLoadTLSFuncAlloc);
s.writeBE(_osDynLoadTLSFuncFree);
}
void ci_DynLoad_Restore(MemStreamReader& s)
void DynLoad_Restore(MemStreamReader& s)
{
char section[16] = { '\0' };
s.readData(section, 15);
cemu_assert_debug(strcmp(section, "ci_DL_S") == 0);
_osDynLoadFuncAlloc = s.readBE<MPTR>();
_osDynLoadFuncFree = s.readBE<MPTR>();
_osDynLoadTLSFuncAlloc = s.readBE<MPTR>();
_osDynLoadTLSFuncFree = s.readBE<MPTR>();
s.readSection("coreinit_DynLoad");
s.readBE(_osDynLoadFuncAlloc);
s.readBE(_osDynLoadFuncFree);
s.readBE(_osDynLoadTLSFuncAlloc);
s.readBE(_osDynLoadTLSFuncFree);
}
void InitializeDynLoad()

4
src/Cafe/OS/libs/coreinit/coreinit_DynLoad.h
View file

@ -14,8 +14,8 @@ namespace coreinit
void OSDynLoad_Release(uint32 moduleHandle);
uint32 OSDynLoad_FindExport(uint32 moduleHandle, uint32 isData, const char* exportName, betype<MPTR>* addrOut);
void ci_DynLoad_Save(MemStreamWriter& s);
void ci_DynLoad_Restore(MemStreamReader& s);
void DynLoad_Save(MemStreamWriter& s);
void DynLoad_Restore(MemStreamReader& s);
void InitializeDynLoad();
}

20
src/Cafe/OS/libs/coreinit/coreinit_FG.cpp
View file

@ -191,23 +191,19 @@ namespace coreinit
osLib_returnFromFunction(hCPU, r ? 1 : 0);
}
void ci_FG_Save(MemStreamWriter& s)
void FG_Save(MemStreamWriter& s)
{
s.writeData("ci_FG_S", 15);
s.writeBE(fgAddr.GetMPTR());
s.writeBE(fgSaveAreaAddr.GetMPTR());
s.writeSection("coreinit_FG");
s.writeMPTR(fgAddr);
s.writeMPTR(fgSaveAreaAddr);
s.writeData(&fgAreaEntries, sizeof(fgAreaEntries) * FG_BUCKET_AREA_COUNT);
}
void ci_FG_Restore(MemStreamReader& s)
void FG_Restore(MemStreamReader& s)
{
char section[16] = { '\0' };
s.readData(section, 15);
cemu_assert_debug(strcmp(section, "ci_FG_S") == 0);
fgAddr = memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
fgSaveAreaAddr = memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
s.readSection("coreinit_FG");
s.readMPTR(fgAddr);
s.readMPTR(fgSaveAreaAddr);
s.readData(&fgAreaEntries, sizeof(fgAreaEntries) * FG_BUCKET_AREA_COUNT);
}

4
src/Cafe/OS/libs/coreinit/coreinit_FG.h
View file

@ -13,8 +13,8 @@ namespace coreinit
void InitForegroundBucket();
void ci_FG_Save(MemStreamWriter& s);
void ci_FG_Restore(MemStreamReader& s);
void FG_Save(MemStreamWriter& s);
void FG_Restore(MemStreamReader& s);
void InitializeFG();
}

44
src/Cafe/OS/libs/coreinit/coreinit_FS.cpp
View file

@ -2638,38 +2638,30 @@ namespace coreinit
return FSA_RESULT::OK;
}
void ci_FS_Save(MemStreamWriter& s)
void FS_Save(MemStreamWriter& s)
{
s.writeData("ci_FS_S", 15);
s.writeSection("coreinit_FS");
s.writeData(g_fsRegisteredClientBodies, sizeof(FSClientBody_t));
s.writeBE(_sdCard01Mounted);
s.writeBE(_mlc01Mounted);
s.writeBE(_tempFSSpace.GetMPTR());
size_t s_fsa_activeClients_size = s_fsa_activeClients.size();
s.writeBE(s_fsa_activeClients_size);
s.writeData(&s_fsa_activeClients, sizeof(FSAClientHandle) * s_fsa_activeClients_size);
s.writeBE(s_fsaIpcPool.GetMPTR());
s.writeBE(s_fsaIpcPoolBuffer.GetMPTR());
s.writeBE(s_fsaIpcPoolBufferNumItems.GetMPTR());
s.writeBool(_sdCard01Mounted);
s.writeBool(_mlc01Mounted);
s.writeMPTR(_tempFSSpace);
s.writePODVector(s_fsa_activeClients);
s.writeMPTR(s_fsaIpcPool);
s.writeMPTR(s_fsaIpcPoolBuffer);
s.writeMPTR(s_fsaIpcPoolBufferNumItems);
}
void ci_FS_Restore(MemStreamReader& s)
void FS_Restore(MemStreamReader& s)
{
char section[16] = { '\0' };
s.readData(section, 15);
cemu_assert_debug(strcmp(section, "ci_FS_S") == 0);
s.readSection("coreinit_FS");
s.readData(g_fsRegisteredClientBodies, sizeof(FSClientBody_t));
_sdCard01Mounted = s.readBE<bool>();
_mlc01Mounted = s.readBE<bool>();
_tempFSSpace = memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
size_t s_fsa_activeClients_size = s.readBE<size_t>();
s_fsa_activeClients.clear();
s_fsa_activeClients.resize(s_fsa_activeClients_size);
s.readData(&s_fsa_activeClients, sizeof(FSAClientHandle) * s_fsa_activeClients_size);
s_fsaIpcPool = (IPCBufPool_t*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
s_fsaIpcPoolBuffer = memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
s_fsaIpcPoolBufferNumItems = (uint32be*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
s.readBool(_sdCard01Mounted);
s.readBool(_mlc01Mounted);
s.readMPTR(_tempFSSpace);
s.readPODVector(s_fsa_activeClients);
s.readMPTR(s_fsaIpcPool);
s.readMPTR(s_fsaIpcPoolBuffer);
s.readMPTR(s_fsaIpcPoolBufferNumItems);
}
void InitializeFS()

4
src/Cafe/OS/libs/coreinit/coreinit_FS.h
View file

@ -308,8 +308,8 @@ namespace coreinit
FS_VOLSTATE FSGetVolumeState(FSClient_t* fsClient);
void ci_FS_Save(MemStreamWriter& s);
void ci_FS_Restore(MemStreamReader& s);
void FS_Save(MemStreamWriter& s);
void FS_Restore(MemStreamReader& s);
void InitializeFS();
}; // namespace coreinit

26
src/Cafe/OS/libs/coreinit/coreinit_GHS.cpp
View file

@ -258,24 +258,22 @@ namespace coreinit
return memory_getPointerFromVirtualOffset(_swapEndianU32(tlsBlock->addr) + _swapEndianU32(tlsIndex->ukn04));
}
void ci_GHS_Save(MemStreamWriter& s)
void GHS_Save(MemStreamWriter& s)
{
s.writeData("ci_GHS_S", 15);
s.writeBE(g_ghs_data.GetMPTR());
s.writeBE(_flockMutexArray.GetMPTR());
s.writeData(_flockMutexMask, sizeof(bool) * GHS_FOPEN_MAX);
s.writeSection("coreinit_GHS");
s.writeMPTR(g_ghs_data);
s.writeMPTR(_flockMutexArray);
s.writeData(reinterpret_cast<uint8*>(_flockMutexMask), sizeof(uint8) * GHS_FOPEN_MAX);
}
void ci_GHS_Restore(MemStreamReader& s)
void GHS_Restore(MemStreamReader& s)
{
char section[16] = { '\0' };
s.readData(section, 15);
cemu_assert_debug(strcmp(section, "ci_GHS_S") == 0);
g_ghs_data = (GHSAccessibleData*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
_flockMutexArray = (coreinit::OSMutex*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
s.readData(_flockMutexMask, sizeof(bool) * GHS_FOPEN_MAX);
s.readSection("coreinit_GHS");
s.readMPTR(g_ghs_data);
s.readMPTR(_flockMutexArray);
uint8 _flockMutexMaskTmp[GHS_FOPEN_MAX] = { 0 };
s.readData(_flockMutexMaskTmp, sizeof(uint8) * GHS_FOPEN_MAX);
memcpy(_flockMutexMask, reinterpret_cast<bool*>(_flockMutexMaskTmp), sizeof(bool) * GHS_FOPEN_MAX);
}
void InitializeGHS()

4
src/Cafe/OS/libs/coreinit/coreinit_GHS.h
View file

@ -4,8 +4,8 @@ namespace coreinit
{
void PrepareGHSRuntime();
void ci_GHS_Save(MemStreamWriter& s);
void ci_GHS_Restore(MemStreamReader& s);
void GHS_Save(MemStreamWriter& s);
void GHS_Restore(MemStreamReader& s);
void InitializeGHS();
};

40
src/Cafe/OS/libs/coreinit/coreinit_IPC.cpp
View file

@ -462,32 +462,28 @@ namespace coreinit
return r;
}
void ci_IPC_Save(MemStreamWriter& s)
void IPC_Save(MemStreamWriter& s)
{
s.writeData("ci_IPC_S", 15);
s.writeBE(s_ipcResourceBuffers.GetMPTR());
s.writeBE(s_ipcDriver.GetMPTR());
s.writeBE(gIPCThread.GetMPTR());
s.writeBE(_gIPCThreadStack.GetMPTR());
s.writeBE(_gIPCThreadNameStorage.GetMPTR());
s.writeBE(gIPCThreadMsgQueue.GetMPTR());
s.writeBE(_gIPCThreadSemaphoreStorage.GetMPTR());
s.writeSection("coreinit_IPC");
s.writeMPTR(s_ipcResourceBuffers);
s.writeMPTR(s_ipcDriver);
s.writeMPTR(gIPCThread);
s.writeMPTR(_gIPCThreadStack);
s.writeMPTR(_gIPCThreadNameStorage);
s.writeMPTR(gIPCThreadMsgQueue);
s.writeMPTR(_gIPCThreadSemaphoreStorage);
}
void ci_IPC_Restore(MemStreamReader& s)
void IPC_Restore(MemStreamReader& s)
{
char section[16] = { '\0' };
s.readData(section, 15);
cemu_assert_debug(strcmp(section, "ci_IPC_S") == 0);
s_ipcResourceBuffers = (IPCResourceBuffer*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
s_ipcDriver = (IPCDriver*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
gIPCThread = (OSThread_t*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
_gIPCThreadStack = memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
_gIPCThreadNameStorage = memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
gIPCThreadMsgQueue = (OSMessageQueue*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
_gIPCThreadSemaphoreStorage = (OSMessage*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
s.readSection("coreinit_IPC");
s.readMPTR(s_ipcResourceBuffers);
s.readMPTR(s_ipcDriver);
s.readMPTR(gIPCThread);
s.readMPTR(_gIPCThreadStack);
s.readMPTR(_gIPCThreadNameStorage);
s.readMPTR(gIPCThreadMsgQueue);
s.readMPTR(_gIPCThreadSemaphoreStorage);
}
void InitializeIPC()

4
src/Cafe/OS/libs/coreinit/coreinit_IPC.h
View file

@ -12,8 +12,8 @@ namespace coreinit
IOS_ERROR IOS_Ioctlv(IOSDevHandle devHandle, uint32 requestId, uint32 numIn, uint32 numOut, IPCIoctlVector* vec);
IOS_ERROR IOS_IoctlvAsync(IOSDevHandle devHandle, uint32 requestId, uint32 numIn, uint32 numOut, IPCIoctlVector* vec, MEMPTR<void> asyncResultFunc, MEMPTR<void> asyncResultUserParam);
void ci_IPC_Save(MemStreamWriter& s);
void ci_IPC_Restore(MemStreamReader& s);
void IPC_Save(MemStreamWriter& s);
void IPC_Restore(MemStreamReader& s);
void InitializeIPC();
};

20
src/Cafe/OS/libs/coreinit/coreinit_Init.cpp
View file

@ -216,24 +216,20 @@ void coreinit_start(PPCInterpreter_t* hCPU)
hCPU->instructionPointer = _coreinitTitleEntryPoint;
}
void ci_Init_Save(MemStreamWriter& s)
void coreinit_Init_Save(MemStreamWriter& s)
{
s.writeData("ci_Init_S", 15);
s.writeSection("coreinit_Init");
s.writeData(_coreinitInfo, sizeof(coreinitInit_t));
s.writeBE(argStorageIndex);
s.writeBE(g_preinitUserParam.GetMPTR());
s.writeMPTR(g_preinitUserParam);
s.writeBE(_coreinitTitleEntryPoint);
}
void ci_Init_Restore(MemStreamReader& s)
void coreinit_Init_Restore(MemStreamReader& s)
{
char section[16] = { '\0' };
s.readData(section, 15);
cemu_assert_debug(strcmp(section, "ci_Init_S") == 0);
s.readSection("coreinit_Init");
s.readData(_coreinitInfo, sizeof(coreinitInit_t));
argStorageIndex = s.readBE<sint32>();
g_preinitUserParam = (PreinitUserHeapStruct*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
_coreinitTitleEntryPoint = s.readBE<sint32>();
s.readBE(argStorageIndex);
s.readMPTR(g_preinitUserParam);
s.readBE(_coreinitTitleEntryPoint);
}

14
src/Cafe/OS/libs/coreinit/coreinit_LockedCache.cpp
View file

@ -271,24 +271,20 @@ namespace coreinit
osLib_returnFromFunction(hCPU, 0);
}
void ci_LockedCache_Save(MemStreamWriter& s)
void LockedCache_Save(MemStreamWriter& s)
{
s.writeData("ci_LC_S", 15);
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);
}
void ci_LockedCache_Restore(MemStreamReader& s)
void LockedCache_Restore(MemStreamReader& s)
{
char section[16] = { '\0' };
s.readData(section, 15);
cemu_assert_debug(strcmp(section, "ci_LC_S") == 0);
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);
_lcDisableErrorCounter = s.readBE<sint32>();
s.readBE(_lcDisableErrorCounter);
}
void InitializeLC()

4
src/Cafe/OS/libs/coreinit/coreinit_LockedCache.h
View file

@ -2,8 +2,8 @@
namespace coreinit
{
void ci_LockedCache_Save(MemStreamWriter& s);
void ci_LockedCache_Restore(MemStreamReader& s);
void LockedCache_Save(MemStreamWriter& s);
void LockedCache_Restore(MemStreamReader& s);
void InitializeLC();
}

32
src/Cafe/OS/libs/coreinit/coreinit_MEM.cpp
View file

@ -630,44 +630,40 @@ namespace coreinit
memset(&g_list3, 0, sizeof(g_list3));
}
void ci_MEM_Save(MemStreamWriter& s)
void MEM_Save(MemStreamWriter& s)
{
s.writeData("ci_MEM_S", 15);
s.writeSection("coreinit_MEM");
s.writeBE(sysAreaAllocatorOffset);
s.writeBE(g_heapTableCount);
s.writeData(g_heapTable, sizeof(MEMHeapBase) * MEM_MAX_HEAP_TABLE);
s.writeBE(g_slockInitialized);
s.writeBE(g_listsInitialized);
s.writeBool(g_slockInitialized);
s.writeBool(g_listsInitialized);
s.writeData(&g_list1, sizeof(MEMList));
s.writeData(&g_list2, sizeof(MEMList));
s.writeData(&g_list3, sizeof(MEMList));
s.writeData(&gHeapFillValues, sizeof(uint32) * 3);
s.writeBE(gHeapGlobalLock.GetMPTR());
s.writeMPTR(gHeapGlobalLock);
s.writeData(&gDefaultHeap, sizeof(MEMHeapBase));
s.writeData(&sHeapBaseHandle, sizeof(MEMHeapBase) * 9);
s.writeBE(gDefaultHeapAllocator.GetMPTR());
s.writeMPTR(gDefaultHeapAllocator);
}
void ci_MEM_Restore(MemStreamReader& s)
void MEM_Restore(MemStreamReader& s)
{
char section[16] = { '\0' };
s.readData(section, 15);
cemu_assert_debug(strcmp(section, "ci_MEM_S") == 0);
sysAreaAllocatorOffset = s.readBE<MPTR>();
g_heapTableCount = s.readBE<sint32>();
s.readSection("coreinit_MEM");
s.readBE(sysAreaAllocatorOffset);
s.readBE(g_heapTableCount);
s.readData(g_heapTable, sizeof(MEMHeapBase) * MEM_MAX_HEAP_TABLE);
g_slockInitialized = s.readBE<bool>();
g_listsInitialized = s.readBE<bool>();
s.readBool(g_slockInitialized);
s.readBool(g_listsInitialized);
s.readData(&g_list1, sizeof(MEMList));
s.readData(&g_list2, sizeof(MEMList));
s.readData(&g_list3, sizeof(MEMList));
s.readData(&gHeapFillValues, sizeof(uint32) * 3);
gHeapGlobalLock = (OSSpinLock*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
s.readMPTR(gHeapGlobalLock);
s.readData(&gDefaultHeap, sizeof(MEMHeapBase));
s.readData(&sHeapBaseHandle, sizeof(MEMHeapBase) * 9);
gDefaultHeapAllocator = (MEMAllocatorFunc*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
s.readMPTR(gDefaultHeapAllocator);
}
void InitializeMEM()

4
src/Cafe/OS/libs/coreinit/coreinit_MEM.h
View file

@ -179,8 +179,8 @@ namespace coreinit
void InitializeMEMUnitHeap();
void ci_MEM_Save(MemStreamWriter& s);
void ci_MEM_Restore(MemStreamReader& s);
void MEM_Save(MemStreamWriter& s);
void MEM_Restore(MemStreamReader& s);
void InitializeMEM();
}

21
src/Cafe/OS/libs/coreinit/coreinit_MemoryMapping.cpp
View file

@ -153,25 +153,16 @@ namespace coreinit
return 1;
}
void ci_MemoryMapping_Save(MemStreamWriter& s)
void MemoryMapping_Save(MemStreamWriter& s)
{
s.writeData("ci_MemMap_S", 15);
size_t s_allocatedVirtMemorySize = s_allocatedVirtMemory.size();
s.writeBE(s_allocatedVirtMemorySize);
s.writeData(&s_allocatedVirtMemory, sizeof(OSVirtMemoryEntry) * s_allocatedVirtMemorySize);
s.writeSection("coreinit_MemoryMapping ");
s.writePODVector(s_allocatedVirtMemory);
}
void ci_MemoryMapping_Restore(MemStreamReader& s)
void MemoryMapping_Restore(MemStreamReader& s)
{
char section[16] = { '\0' };
s.readData(section, 15);
cemu_assert_debug(strcmp(section, "ci_MemMap_S") == 0);
size_t s_allocatedVirtMemorySize = s.readBE<size_t>();
s_allocatedVirtMemory.clear();
s_allocatedVirtMemory.resize(s_allocatedVirtMemorySize);
s.readData(&s_allocatedVirtMemory, sizeof(OSVirtMemoryEntry) * s_allocatedVirtMemorySize);
s.readSection("coreinit_MemoryMapping ");
s.readPODVector(s_allocatedVirtMemory);
}
void InitializeMemoryMapping()

4
src/Cafe/OS/libs/coreinit/coreinit_MemoryMapping.h
View file

@ -1,8 +1,8 @@
namespace coreinit
{
void ci_MemoryMapping_Save(MemStreamWriter& s);
void ci_MemoryMapping_Restore(MemStreamReader& s);
void MemoryMapping_Save(MemStreamWriter& s);
void MemoryMapping_Restore(MemStreamReader& s);
void InitializeMemoryMapping();
}

20
src/Cafe/OS/libs/coreinit/coreinit_MessageQueue.cpp
View file

@ -117,22 +117,18 @@ namespace coreinit
return g_systemMessageQueue.GetPtr();
}
void ci_MessageQueue_Save(MemStreamWriter& s)
void MessageQueue_Save(MemStreamWriter& s)
{
s.writeData("ci_MessQue_S", 15);
s.writeBE(g_systemMessageQueue.GetMPTR());
s.writeBE(_systemMessageQueueArray.GetMPTR());
s.writeSection("coreinit_MessageQueue");
s.writeMPTR(g_systemMessageQueue);
s.writeMPTR(_systemMessageQueueArray);
}
void ci_MessageQueue_Restore(MemStreamReader& s)
void MessageQueue_Restore(MemStreamReader& s)
{
char section[16] = { '\0' };
s.readData(section, 15);
cemu_assert_debug(strcmp(section, "ci_MessQue_S") == 0);
g_systemMessageQueue = (OSMessageQueue*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
_systemMessageQueueArray = (OSMessage*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
s.readSection("coreinit_MessageQueue");
s.readMPTR(g_systemMessageQueue);
s.readMPTR(_systemMessageQueueArray);
}
void InitializeMessageQueue()

4
src/Cafe/OS/libs/coreinit/coreinit_MessageQueue.h
View file

@ -36,8 +36,8 @@ namespace coreinit
bool OSPeekMessage(OSMessageQueue* msgQueue, OSMessage* msg);
sint32 OSSendMessage(OSMessageQueue* msgQueue, OSMessage* msg, uint32 flags);
void ci_MessageQueue_Save(MemStreamWriter& s);
void ci_MessageQueue_Restore(MemStreamReader& s);
void MessageQueue_Save(MemStreamWriter& s);
void MessageQueue_Restore(MemStreamReader& s);
void InitializeMessageQueue();
};

16
src/Cafe/OS/libs/coreinit/coreinit_OverlayArena.cpp
View file

@ -25,19 +25,15 @@ namespace coreinit
*areaSize = MEMORY_OVERLAY_AREA_SIZE;
}
void ci_OverlayArena_Save(MemStreamWriter& s)
void OverlayArena_Save(MemStreamWriter& s)
{
s.writeData("ci_OverArea_S", 15);
s.writeData(&g_coreinitOverlayArena, sizeof(g_coreinitOverlayArena));
s.writeSection("coreinit_OverlayArena");
s.writeBool(g_coreinitOverlayArena.isEnabled);
}
void ci_OverlayArena_Restore(MemStreamReader& s)
void OverlayArena_Restore(MemStreamReader& s)
{
char section[16] = { '\0' };
s.readData(section, 15);
cemu_assert_debug(strcmp(section, "ci_OverArea_S") == 0);
s.readData(&g_coreinitOverlayArena, sizeof(g_coreinitOverlayArena));
s.readSection("coreinit_OverlayArena");
s.readBool(g_coreinitOverlayArena.isEnabled);
}
void InitializeOverlayArena()

4
src/Cafe/OS/libs/coreinit/coreinit_OverlayArena.h
View file

@ -1,7 +1,7 @@
namespace coreinit
{
void ci_OverlayArena_Save(MemStreamWriter& s);
void ci_OverlayArena_Restore(MemStreamReader& s);
void OverlayArena_Save(MemStreamWriter& s);
void OverlayArena_Restore(MemStreamReader& s);
void InitializeOverlayArena();
};

16
src/Cafe/OS/libs/coreinit/coreinit_Synchronization.cpp
View file

@ -614,20 +614,16 @@ namespace coreinit
OSWakeupThread(&fastCond->threadQueue);
}
void ci_Sync_Save(MemStreamWriter& s)
void Synchronization_Save(MemStreamWriter& s)
{
s.writeData("ci_Sync_S", 15);
s.writeBE(g_rendezvousEvent.GetMPTR());
s.writeSection("coreinit_Synchronization");
s.writeMPTR(g_rendezvousEvent);
}
void ci_Sync_Restore(MemStreamReader& s)
void Synchronization_Restore(MemStreamReader& s)
{
char section[16] = { '\0' };
s.readData(section, 15);
cemu_assert_debug(strcmp(section, "ci_Sync_S") == 0);
g_rendezvousEvent = (OSEvent*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
s.readSection("coreinit_Synchronization");
s.readMPTR(g_rendezvousEvent);
}
/************* init ************/

16
src/Cafe/OS/libs/coreinit/coreinit_SysHeap.cpp
View file

@ -32,24 +32,20 @@ namespace coreinit
_sysHeapFreeCounter = 0;
}
void ci_SysHeap_Save(MemStreamWriter& s)
void SysHeap_Save(MemStreamWriter& s)
{
s.writeData("ci_SysHeap_S", 15);
s.writeSection("coreinit_SysHeap");
s.writeData(_sysHeapHandle, sizeof(MEMHeapBase));
s.writeBE(_sysHeapAllocCounter);
s.writeBE(_sysHeapFreeCounter);
}
void ci_SysHeap_Restore(MemStreamReader& s)
void SysHeap_Restore(MemStreamReader& s)
{
char section[16] = { '\0' };
s.readData(section, 15);
cemu_assert_debug(strcmp(section, "ci_SysHeap_S") == 0);
s.readSection("coreinit_SysHeap");
s.readData(_sysHeapHandle, sizeof(MEMHeapBase));
_sysHeapAllocCounter = s.readBE<sint32>();
_sysHeapFreeCounter = s.readBE<sint32>();
s.readBE(_sysHeapAllocCounter);
s.readBE(_sysHeapFreeCounter);
}
void InitializeSysHeap()

4
src/Cafe/OS/libs/coreinit/coreinit_SysHeap.h
View file

@ -4,8 +4,8 @@ namespace coreinit
{
void InitSysHeap();
void ci_SysHeap_Save(MemStreamWriter& s);
void ci_SysHeap_Restore(MemStreamReader& s);
void SysHeap_Save(MemStreamWriter& s);
void SysHeap_Restore(MemStreamReader& s);
void InitializeSysHeap();
}

16
src/Cafe/OS/libs/coreinit/coreinit_SystemInfo.cpp
View file

@ -10,20 +10,16 @@ namespace coreinit
return *g_system_info.GetPtr();
}
void ci_SystemInfo_Save(MemStreamWriter& s)
void SystemInfo_Save(MemStreamWriter& s)
{
s.writeData("ci_SysInfo_S", 15);
s.writeBE(g_system_info.GetMPTR());
s.writeSection("coreinit_SysInfo");
s.writeMPTR(g_system_info);
}
void ci_SystemInfo_Restore(MemStreamReader& s)
void SystemInfo_Restore(MemStreamReader& s)
{
char section[16] = { '\0' };
s.readData(section, 15);
cemu_assert_debug(strcmp(section, "ci_SysInfo_S") == 0);
g_system_info = (OSSystemInfo*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
s.readSection("coreinit_SysInfo");
s.readMPTR(g_system_info);
}
void InitializeSystemInfo()

4
src/Cafe/OS/libs/coreinit/coreinit_SystemInfo.h
View file

@ -16,8 +16,8 @@ namespace coreinit
const OSSystemInfo& OSGetSystemInfo();
void ci_SystemInfo_Save(MemStreamWriter& s);
void ci_SystemInfo_Restore(MemStreamReader& s);
void SystemInfo_Save(MemStreamWriter& s);
void SystemInfo_Restore(MemStreamReader& s);
void InitializeSystemInfo();
};

52
src/Cafe/OS/libs/coreinit/coreinit_Thread.cpp
View file

@ -1331,12 +1331,13 @@ namespace coreinit
}
}
void ci_Thread_Save(MemStreamWriter& s)
void Thread_Save(MemStreamWriter& s)
{
s.writeData("ci_T_S", 15);
s.writeSection("coreinit_Thread");
s.writeBE(g_activeThreadQueue.GetMPTR());
s.writeBE(g_coreRunQueue.GetMPTR());
s.writeBE((uint8)sSchedulerActive.load());
s.writeMPTR(g_activeThreadQueue);
s.writeMPTR(g_coreRunQueue);
s.writeBE(activeThreadCount);
for (sint32 i = 0; i < activeThreadCount; i++)
@ -1345,25 +1346,25 @@ namespace coreinit
}
for (sint32 i = 0; i < PPC_CORE_COUNT; i++)
{
s.writeBE(memory_getVirtualOffsetFromPointer(__currentCoreThread[i]));
s.writePTR(__currentCoreThread[i]);
s.writeBE(s_lehmer_lcg[i]);
s.writeBE(s_terminatorThreads[i].terminatorThread.GetMPTR());
s.writeBE(s_terminatorThreads[i].threadStack.GetMPTR());
s.writeBE(s_terminatorThreads[i].threadName.GetMPTR());
s.writeBE(s_terminatorThreads[i].semaphoreQueuedDeallocators.GetMPTR());
s.writeMPTR(s_terminatorThreads[i].terminatorThread);
s.writeMPTR(s_terminatorThreads[i].threadStack);
s.writeMPTR(s_terminatorThreads[i].threadName);
s.writeMPTR(s_terminatorThreads[i].semaphoreQueuedDeallocators);
s.writeMPTR(_defaultThreadName[i]);
}
s.writeBE(s_defaultThreads.GetMPTR());
s.writeBE(s_stack.GetMPTR());
s.writeMPTR(s_defaultThreads);
s.writeMPTR(s_stack);
}
void ci_Thread_Restore(MemStreamReader& s, bool recreate)
void Thread_Restore(MemStreamReader& s, bool recreate)
{
char section[16] = { '\0' };
s.readData(section,15);
cemu_assert_debug(strcmp(section, "ci_T_S") == 0);
s.readSection("coreinit_Thread");
g_activeThreadQueue = (OSThreadQueue*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
g_coreRunQueue = (OSThreadQueue*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
sSchedulerActive.store(s.readBE<uint8>());
s.readMPTR(g_activeThreadQueue);
s.readMPTR(g_coreRunQueue);
sint32 prevActiveThreadCount = s.readBE<sint32>();
for (sint32 i = 0; i < prevActiveThreadCount; i++)
@ -1383,15 +1384,16 @@ namespace coreinit
}
for (sint32 i = 0; i < PPC_CORE_COUNT; i++)
{
__currentCoreThread[i] = (OSThread_t*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
s_lehmer_lcg[i] = s.readBE<uint32>();
s_terminatorThreads[i].terminatorThread = (OSThread_t*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
s_terminatorThreads[i].threadStack = (uint8*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
s_terminatorThreads[i].threadName = (char*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
s_terminatorThreads[i].semaphoreQueuedDeallocators = (OSSemaphore*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
s.readPTR(__currentCoreThread[i]);
s.readBE(s_lehmer_lcg[i]);
s.readMPTR(s_terminatorThreads[i].terminatorThread);
s.readMPTR(s_terminatorThreads[i].threadStack);
s.readMPTR(s_terminatorThreads[i].threadName);
s.readMPTR(s_terminatorThreads[i].semaphoreQueuedDeallocators);
s.readMPTR(_defaultThreadName[i]);
}
s_defaultThreads = (OSThread_t*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
s_stack = (uint8*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
s.readMPTR(s_defaultThreads);
s.readMPTR(s_stack);
}
void SuspendActiveThreads()

8
src/Cafe/OS/libs/coreinit/coreinit_Thread.h
View file

@ -496,15 +496,15 @@ static_assert(sizeof(OSThread_t) == 0x6A0-4); // todo - determine correct size
namespace coreinit
{
void ci_Thread_Save(MemStreamWriter& s);
void ci_Thread_Restore(MemStreamReader& s, bool recreate);
void Thread_Save(MemStreamWriter& s);
void Thread_Restore(MemStreamReader& s, bool recreate);
void SuspendActiveThreads();
void ResumeActiveThreads();
void InitializeThread();
void ci_Sync_Save(MemStreamWriter& s);
void ci_Sync_Restore(MemStreamReader& s);
void Synchronization_Save(MemStreamWriter& s);
void Synchronization_Restore(MemStreamReader& s);
void InitializeConcurrency();

11
src/Cafe/OS/libs/dmae/dmae.cpp
View file

@ -108,6 +108,17 @@ void dmaeExport_DMAEGetRetiredTimeStamp(PPCInterpreter_t* hCPU)
osLib_returnFromFunction64(hCPU, dmaeRetiredTimestamp);
}
void dmae_save(MemStreamWriter& s)
{
s.writeSection("dmae");
s.writeBE(dmaeRetiredTimestamp);
}
void dmae_restore(MemStreamReader& s)
{
s.readSection("dmae");
s.readBE(dmaeRetiredTimestamp);
}
void dmae_load()
{

3
src/Cafe/OS/libs/dmae/dmae.h
View file

@ -1 +1,4 @@
void dmae_save(MemStreamWriter& s);
void dmae_restore(MemStreamReader& s);
void dmae_load();

23
src/Cafe/OS/libs/nlibcurl/nlibcurl.cpp
View file

@ -1354,6 +1354,29 @@ void export_curl_global_init_mem(PPCInterpreter_t* hCPU)
osLib_returnFromFunction(hCPU, result);
}
void save(MemStreamWriter& s)
{
s.writeSection("nlibcurl");
s.writeBE(g_nlibcurl.initialized);
s.writeMPTR(g_nlibcurl.proxyConfig);
s.writeMPTR(g_nlibcurl.malloc);
s.writeMPTR(g_nlibcurl.free);
s.writeMPTR(g_nlibcurl.realloc);
s.writeMPTR(g_nlibcurl.strdup);
s.writeMPTR(g_nlibcurl.calloc);
}
void restore(MemStreamReader& s)
{
s.readSection("nlibcurl");
s.readBE(g_nlibcurl.initialized);
s.readMPTR(g_nlibcurl.proxyConfig);
s.readMPTR(g_nlibcurl.malloc);
s.readMPTR(g_nlibcurl.free);
s.readMPTR(g_nlibcurl.realloc);
s.readMPTR(g_nlibcurl.strdup);
s.readMPTR(g_nlibcurl.calloc);
}
void load()
{
osLib_addFunction("nlibcurl", "curl_global_init_mem", export_curl_global_init_mem);

3
src/Cafe/OS/libs/nlibcurl/nlibcurl.h
View file

@ -2,5 +2,8 @@
namespace nlibcurl
{
void save(MemStreamWriter& s);
void restore(MemStreamReader& s);
void load();
}

12
src/Cafe/OS/libs/nn_acp/nn_acp.cpp
View file

@ -490,6 +490,18 @@ namespace acp
osLib_returnFromFunction(hCPU, 0);
}
void save(MemStreamWriter& s)
{
s.writeSection("nn_acp");
s.writeBool(sSaveDirMounted);
}
void restore(MemStreamReader& s)
{
s.readSection("nn_acp");
s.readBool(sSaveDirMounted);
}
void load()
{
cafeExportRegister("nn_acp", ACPCheckApplicationDeviceEmulation, LogType::Placeholder);

3
src/Cafe/OS/libs/nn_acp/nn_acp.h
View file

@ -24,6 +24,9 @@ namespace acp
ACPStatus ACPCreateSaveDir(uint32 persistentId, ACPDeviceType type);
ACPStatus ACPUpdateSaveTimeStamp(uint32 persistentId, uint64 titleId, ACPDeviceType deviceType);;
void save(MemStreamWriter& s);
void restore(MemStreamReader& s);
void load();
}
}

13
src/Cafe/OS/libs/nn_act/nn_act.cpp
View file

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

3
src/Cafe/OS/libs/nn_act/nn_act.h
View file

@ -33,4 +33,7 @@ namespace act
}
}
void nnAct_save(MemStreamWriter& s);
void nnAct_restore(MemStreamReader& s);
void nnAct_load();

15
src/Cafe/OS/libs/nn_aoc/nn_aoc.cpp
View file

@ -36,6 +36,7 @@ namespace nn
struct AOCCacheEntry
{
AOCCacheEntry() {};
AOCCacheEntry(uint64 titleId) : aocTitleId(titleId) {};
uint64 aocTitleId;
@ -149,6 +150,20 @@ namespace nn
return AOC_RESULT::ERROR_OK;
}
void save(MemStreamWriter& s)
{
s.writeSection("nn_aoc");
s.writePODVector(sAocCache);
s.writeBool(sAocCacheGenerated);
}
void restore(MemStreamReader& s)
{
s.readSection("nn_aoc");
s.readPODVector(sAocCache);
s.readBool(sAocCacheGenerated);
}
void Initialize()
{
cafeExportRegister("nn_aoc", AOC_CalculateWorkBufferSize, LogType::NN_AOC);

3
src/Cafe/OS/libs/nn_aoc/nn_aoc.h
View file

@ -2,6 +2,9 @@ namespace nn
{
namespace aoc
{
void save(MemStreamWriter& s);
void restore(MemStreamReader& s);
void Initialize();
}
}

16
src/Cafe/OS/libs/nn_boss/nn_boss.cpp
View file

@ -1714,6 +1714,22 @@ void nnBossNsDataExport_seek(PPCInterpreter_t* hCPU)
osLib_returnFromFunction(hCPU, r);
}
void nnBoss_save(MemStreamWriter& s)
{
s.writeSection("nn_boss");
s.writeMPTR(nn::boss::g_mutex);
s.writeBE(nn::boss::g_initCounter);
s.writeBool(nn::boss::g_isInitialized);
}
void nnBoss_restore(MemStreamReader& s)
{
s.readSection("nn_boss");
s.readMPTR(nn::boss::g_mutex);
s.readBE(nn::boss::g_initCounter);
s.readBool(nn::boss::g_isInitialized);
}
void nnBoss_load()
{
OSInitMutexEx(&nn::boss::g_mutex, nullptr);

3
src/Cafe/OS/libs/nn_boss/nn_boss.h
View file

@ -1 +1,4 @@
void nnBoss_save(MemStreamWriter& s);
void nnBoss_restore(MemStreamReader& s);
void nnBoss_load();

12
src/Cafe/OS/libs/nn_fp/nn_fp.cpp
View file

@ -739,6 +739,18 @@ namespace nn
osLib_returnFromFunction(hCPU, fpdRequest->returnCode);
}
void save(MemStreamWriter& s)
{
s.writeSection("nn_fp");
s.writeData(&g_fp, sizeof(g_fp));
}
void restore(MemStreamReader& s)
{
s.readSection("nn_fp");
s.readData(&g_fp, sizeof(g_fp));
}
void load()
{
osLib_addFunction("nn_fp", "Initialize__Q2_2nn2fpFv", export_Initialize);

3
src/Cafe/OS/libs/nn_fp/nn_fp.h
View file

@ -3,6 +3,9 @@ namespace nn
{
namespace fp
{
void save(MemStreamWriter& s);
void restore(MemStreamReader& s);
void load();
}
}

14
src/Cafe/OS/libs/nn_ndm/nn_ndm.cpp
View file

@ -74,6 +74,20 @@ namespace nn
return BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_NDM, 0);
}
void save(MemStreamWriter& s)
{
s.writeSection("nn_ndm");
s.writeData(s_daemonStatus, sizeof(DAEMON_STATUS) * NUM_DAEMONS);
s.writeBE(s_initializeRefCount);
}
void restore(MemStreamReader& s)
{
s.readSection("nn_ndm");
s.readData(s_daemonStatus, sizeof(DAEMON_STATUS) * NUM_DAEMONS);
s.readBE(s_initializeRefCount);
}
void load()
{
for(size_t i=0; i<NUM_DAEMONS; i++)

3
src/Cafe/OS/libs/nn_ndm/nn_ndm.h
View file

@ -2,6 +2,9 @@ namespace nn
{
namespace ndm
{
void save(MemStreamWriter& s);
void restore(MemStreamReader& s);
void load();
}
}

12
src/Cafe/OS/libs/nn_nfp/nn_nfp.cpp
View file

@ -1015,6 +1015,18 @@ namespace nn::nfp
osLib_addFunction("nn_nfp", "GetAmiiboSettingsArgs__Q2_2nn3nfpFPQ3_2nn3nfp18AmiiboSettingsArgs", nnNfpExport_GetAmiiboSettingsArgs);
}
void save(MemStreamWriter& s)
{
s.writeSection("nn_nfp");
s.writeData(&nfp_data, sizeof(nfp_data));
}
void restore(MemStreamReader& s)
{
s.readSection("nn_nfp");
s.readData(&nfp_data, sizeof(nfp_data));
}
void load()
{
nnNfp_load(); // legacy interface, update these to use cafeExportRegister / cafeExportRegisterFunc

3
src/Cafe/OS/libs/nn_nfp/nn_nfp.h
View file

@ -2,6 +2,9 @@
namespace nn::nfp
{
void save(MemStreamWriter& s);
void restore(MemStreamReader& s);
void load();
}

34
src/Cafe/OS/libs/nn_olv/nn_olv.cpp
View file

@ -110,6 +110,40 @@ namespace nn
static_assert(GetErrorCodeImpl(0xa119c600) == 1155004);
void save(MemStreamWriter& s)
{
s.writeSection("nn_olv");
s.writeMPTR(s_OlvReleaseBgThread);
s.writeMPTR(s_OlvReleaseBgThreadStack);
s.writeMPTR(s_OlvReleaseBgThreadName);
s.writeData(&g_ParamPack, sizeof(ParamPackStorage));
s.writeData(&g_DiscoveryResults, sizeof(DiscoveryResultStorage));
s.writeBE(g_ReportTypes);
s.writeBool(g_IsInitialized);
s.writeBool(g_IsOnlineMode);
s.writeBool(g_IsOfflineDBMode);
s.writeBool(OfflineDB_Initialized());
}
void restore(MemStreamReader& s)
{
s.readSection("nn_olv");
s.readMPTR(s_OlvReleaseBgThread);
s.readMPTR(s_OlvReleaseBgThreadStack);
s.readMPTR(s_OlvReleaseBgThreadName);
s.readData(&g_ParamPack, sizeof(ParamPackStorage));
s.readData(&g_DiscoveryResults, sizeof(DiscoveryResultStorage));
s.readBE(g_ReportTypes);
s.readBool(g_IsInitialized);
s.readBool(g_IsOnlineMode);
s.readBool(g_IsOfflineDBMode);
if (s.readBool())
{
OfflineDB_Shutdown();
OfflineDB_LazyInit();
}
}
void load()
{
g_ReportTypes = 0;

3
src/Cafe/OS/libs/nn_olv/nn_olv.h
View file

@ -18,6 +18,9 @@ namespace nn
sint32 GetOlvAccessKey(uint32_t* pOutKey);
void save(MemStreamWriter& s);
void restore(MemStreamReader& s);
void load();
void unload();
}

5
src/Cafe/OS/libs/nn_olv/nn_olv_OfflineDB.cpp
View file

@ -17,6 +17,11 @@ namespace nn
bool g_offlineDBInitialized = false;
ZArchiveReader* g_offlineDBArchive{nullptr};
bool OfflineDB_Initialized()
{
return g_offlineDBInitialized;
}
void OfflineDB_LazyInit()
{
std::scoped_lock _l(g_offlineDBMutex);

4
src/Cafe/OS/libs/nn_olv/nn_olv_OfflineDB.h
View file

@ -6,7 +6,9 @@ namespace nn
{
namespace olv
{
void OfflineDB_Init();
bool OfflineDB_Initialized();
void OfflineDB_LazyInit();
void OfflineDB_Shutdown();
nnResult OfflineDB_DownloadPostDataListParam_DownloadPostDataList(DownloadedTopicData* downloadedTopicData, DownloadedPostData* downloadedPostData, uint32be* postCountOut, uint32 maxCount, DownloadPostDataListParam* param);

12
src/Cafe/OS/libs/nn_save/nn_save.cpp
View file

@ -1521,6 +1521,18 @@ namespace save
osLib_returnFromFunction(hCPU, result);
}
void save(MemStreamWriter& s)
{
s.writeSection("nn_save");
s.writeMPTR(g_nn_save);
}
void restore(MemStreamReader& s)
{
s.readSection("nn_save");
s.readMPTR(g_nn_save);
}
void load()
{

3
src/Cafe/OS/libs/nn_save/nn_save.h
View file

@ -4,6 +4,9 @@ namespace nn
{
namespace save
{
void save(MemStreamWriter& s);
void restore(MemStreamReader& s);
void load();
void ResetToDefaultState();

12
src/Cafe/OS/libs/nn_temp/nn_temp.cpp
View file

@ -16,6 +16,18 @@ namespace nn::temp
osLib_returnFromFunction(hCPU, 0);
}
void save(MemStreamWriter& s)
{
s.writeSection("nn_temp");
s.writeBE(tempIdGenerator);
}
void restore(MemStreamReader& s)
{
s.readSection("nn_temp");
s.readBE(tempIdGenerator);
}
void Initialize()
{
osLib_addFunction("nn_temp", "TEMPCreateAndInitTempDir", nnTempExport_TEMPCreateAndInitTempDir);

3
src/Cafe/OS/libs/nn_temp/nn_temp.h
View file

@ -2,5 +2,8 @@
namespace nn::temp
{
void save(MemStreamWriter& s);
void restore(MemStreamReader& s);
void Initialize();
};

12
src/Cafe/OS/libs/nn_uds/nn_uds.cpp
View file

@ -15,6 +15,18 @@ void nnUdsExport___sti___11_uds_Api_cpp_f5d9abb2(PPCInterpreter_t* hCPU)
osLib_returnFromFunction(hCPU, memory_getVirtualOffsetFromPointer(udsWorkspace));
}
void nnUds_save(MemStreamWriter& s)
{
s.writeSection("nn_uds");
s.writeData(udsWorkspace, sizeof(udsWorkspace_t));
}
void nnUds_restore(MemStreamReader& s)
{
s.readSection("nn_uds");
s.readData(udsWorkspace, sizeof(udsWorkspace_t));
}
/*
* Load UDS functions
*/

3
src/Cafe/OS/libs/nn_uds/nn_uds.h
View file

@ -1 +1,4 @@
void nnUds_save(MemStreamWriter& s);
void nnUds_restore(MemStreamReader& s);
void nnUds_load();

22
src/Cafe/OS/libs/nsyshid/nsyshid.cpp
View file

@ -813,6 +813,28 @@ namespace nsyshid
osLib_returnFromFunction(hCPU, 0);
}
void save(MemStreamWriter& s)
{
s.writeSection("nsyshid");
s.writeData(firstDevice, sizeof(HIDDeviceInfo_t));
s.writeData(firstHIDClient, sizeof(HIDClient_t));
s.writeBE(_lastGeneratedHidHandle);
s.writeMPTR(_devicePool);
s.writeBE(_devicePoolMask.count());
}
void restore(MemStreamReader& s)
{
s.readSection("nsyshid");
s.readData(firstDevice, sizeof(HIDDeviceInfo_t));
s.readData(firstHIDClient, sizeof(HIDClient_t));
s.readBE(_lastGeneratedHidHandle);
s.readMPTR(_devicePool);
_devicePoolMask.reset();
for (size_t i = 0; i < s.readBE<size_t>(); i++)
_devicePoolMask.set(i);
}
void load()
{
osLib_addFunction("nsyshid", "HIDAddClient", export_HIDAddClient);

3
src/Cafe/OS/libs/nsyshid/nsyshid.h
View file

@ -1,5 +1,8 @@
#pragma once
namespace nsyshid
{
void save(MemStreamWriter& s);
void restore(MemStreamReader& s);
void load();
}

26
src/Cafe/OS/libs/nsysnet/nsysnet.cpp
View file

@ -2161,6 +2161,32 @@ namespace nsysnet
}
}
void nsysnet_save(MemStreamWriter& s)
{
s.writeSection("nsysnet");
s.writeMPTR(_ntoa_tempString);
s.writeMPTR(_staticHostent);
s.writeMPTR(_staticHostentName);
s.writeMPTR(_staticHostentPtrList);
s.writeMPTR(_staticHostentEntries);
s.writePODVector(nsysnet::g_nsslInternalStates);
s.writeBool(sockLibReady);
s.writeData(virtualSocketTable, sizeof(virtualSocket_t) * WU_SOCKET_LIMIT);
}
void nsysnet_restore(MemStreamReader& s)
{
s.readSection("nsysnet");
s.readMPTR(_ntoa_tempString);
s.readMPTR(_staticHostent);
s.readMPTR(_staticHostentName);
s.readMPTR(_staticHostentPtrList);
s.readMPTR(_staticHostentEntries);
s.readPODVector(nsysnet::g_nsslInternalStates);
s.readBool(sockLibReady);
s.readData(virtualSocketTable, sizeof(virtualSocket_t) * WU_SOCKET_LIMIT);
}
// register nsysnet functions
void nsysnet_load()
{

3
src/Cafe/OS/libs/nsysnet/nsysnet.h
View file

@ -12,6 +12,9 @@
typedef signed int WUSOCKET;
void nsysnet_save(MemStreamWriter& s);
void nsysnet_restore(MemStreamReader& s);
void nsysnet_load();
WUSOCKET nsysnet_createVirtualSocketFromExistingSocket(SOCKET existingSocket);
void nsysnet_notifyCloseSharedSocket(SOCKET existingSocket);

27
src/Cafe/OS/libs/padscore/padscore.cpp
View file

@ -53,7 +53,8 @@ namespace padscore
WPADState_t g_wpad_state = kWPADStateMaster;
struct {
struct g_padscore_t
{
SysAllocator<coreinit::OSAlarm_t> alarm;
bool kpad_initialized = false;
@ -746,6 +747,30 @@ namespace padscore
OSSetPeriodicAlarm(&g_padscore.alarm, start_tick, period_tick, handler);
}
void save(MemStreamWriter& s)
{
s.writeSection("padscore");
s.writeBool(debugUseDRC1);
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.writeBool(g_wpad_callback_by_kpad);
s.writeBE((uint32)g_wpad_state);
}
void restore(MemStreamReader& s)
{
s.readSection("padscore");
s.readBool(debugUseDRC1);
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.readBool(g_wpad_callback_by_kpad);
g_wpad_state = (WPADState_t)s.readBE<uint32>();
}
void load()
{
cafeExportRegister("padscore", WPADIsMplsAttached, LogType::InputAPI);

3
src/Cafe/OS/libs/padscore/padscore.h
View file

@ -4,6 +4,9 @@
namespace padscore
{
void save(MemStreamWriter& s);
void restore(MemStreamReader& s);
void start();
void load();
}

10
src/Cafe/OS/libs/proc_ui/proc_ui.cpp
View file

@ -49,6 +49,16 @@ void ProcUI_SendForegroundMessage()
}
}
void procui_save(MemStreamWriter& s)
{
s.writeSection("proc_ui");
}
void procui_restore(MemStreamReader& s)
{
s.readSection("proc_ui");
}
void procui_load()
{
cafeExportRegister("proc_ui", ProcUIRegisterCallback, LogType::ProcUi);

3
src/Cafe/OS/libs/proc_ui/proc_ui.h
View file

@ -1,4 +1,7 @@
void procui_save(MemStreamWriter& s);
void procui_restore(MemStreamReader& s);
void procui_load();
void ProcUI_SendForegroundMessage();

229
src/util/helpers/Serializer.cpp
View file

@ -1,66 +1,25 @@
#include "Serializer.h"
template<>
uint8 MemStreamReader::readBE()
// readBE return
template<typename T>
T MemStreamReader::readBE()
{
if (!reserveReadLength(sizeof(uint8)))
if (!reserveReadLength(sizeof(T)))
return 0;
uint8 v = m_data[m_cursorPos];
m_cursorPos += sizeof(uint8);
const uint8* p = m_data + m_cursorPos;
T v;
std::memcpy(&v, p, sizeof(v));
v = _BE(v);
m_cursorPos += sizeof(T);
return v;
}
template<>
uint16 MemStreamReader::readBE()
{
if (!reserveReadLength(sizeof(uint16)))
return 0;
const uint8* p = m_data + m_cursorPos;
uint16 v;
std::memcpy(&v, p, sizeof(v));
v = _BE(v);
m_cursorPos += sizeof(uint16);
return v;
}
template<>
uint32 MemStreamReader::readBE()
{
if (!reserveReadLength(sizeof(uint32)))
return 0;
const uint8* p = m_data + m_cursorPos;
uint32 v;
std::memcpy(&v, p, sizeof(v));
v = _BE(v);
m_cursorPos += sizeof(uint32);
return v;
}
template<>
sint32 MemStreamReader::readBE()
{
if (!reserveReadLength(sizeof(sint32)))
return 0;
const uint8* p = m_data + m_cursorPos;
sint32 v;
std::memcpy(&v, p, sizeof(v));
v = _BE(v);
m_cursorPos += sizeof(sint32);
return v;
}
template<>
uint64 MemStreamReader::readBE()
{
if (!reserveReadLength(sizeof(uint64)))
return 0;
const uint8* p = m_data + m_cursorPos;
uint64 v;
std::memcpy(&v, p, sizeof(v));
v = _BE(v);
m_cursorPos += sizeof(uint64);
return v;
}
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()
@ -80,94 +39,88 @@ std::string MemStreamReader::readBE()
return s;
}
template<>
uint8 MemStreamReader::readLE()
// readBE void
template<typename T>
void MemStreamReader::readBE(T& v)
{
return readBE<uint8>();
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<>
uint32 MemStreamReader::readLE()
void MemStreamReader::readBE(std::string& v)
{
if (!reserveReadLength(sizeof(uint32)))
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>
T MemStreamReader::readLE()
{
if (!reserveReadLength(sizeof(T)))
return 0;
const uint8* p = m_data + m_cursorPos;
uint32 v;
T v;
std::memcpy(&v, p, sizeof(v));
v = _LE(v);
m_cursorPos += sizeof(uint32);
m_cursorPos += sizeof(T);
return v;
}
template<>
uint64 MemStreamReader::readLE()
template uint8 MemStreamReader::readLE<uint8>();
template uint16 MemStreamReader::readLE<uint16>();
template uint32 MemStreamReader::readLE<uint32>();
// readSection
void MemStreamReader::readSection(const char* sec)
{
if (!reserveReadLength(sizeof(uint64)))
return 0;
const uint8* p = m_data + m_cursorPos;
uint64 v;
std::memcpy(&v, p, sizeof(v));
v = _LE(v);
m_cursorPos += sizeof(uint64);
return v;
std::string sec_str = std::string(sec);
cemu_assert_debug(readBE<std::string>() == sec_str);
}
template<>
void MemStreamWriter::writeBE<uint64>(const uint64& v)
// writeBE void
template<typename T>
void MemStreamWriter::writeBE(const T& v)
{
m_buffer.resize(m_buffer.size() + 8);
uint8* p = m_buffer.data() + m_buffer.size() - 8;
uint64 tmp = _BE(v);
m_buffer.resize(m_buffer.size() + sizeof(T));
uint8* p = m_buffer.data() + m_buffer.size() - sizeof(T);
T tmp = _BE(v);
std::memcpy(p, &tmp, sizeof(tmp));
}
template<>
void MemStreamWriter::writeBE<uint32>(const uint32& v)
{
m_buffer.resize(m_buffer.size() + 4);
uint8* p = m_buffer.data() + m_buffer.size() - 4;
uint32 tmp = _BE(v);
std::memcpy(p, &tmp, sizeof(tmp));
}
template<>
void MemStreamWriter::writeBE<sint32>(const sint32& v)
{
m_buffer.resize(m_buffer.size() + 4);
uint8* p = m_buffer.data() + m_buffer.size() - 4;
uint32 tmp = _BE(v);
std::memcpy(p, &tmp, sizeof(tmp));
}
template<>
void MemStreamWriter::writeBE<uint16>(const uint16& v)
{
m_buffer.resize(m_buffer.size() + 2);
uint8* p = m_buffer.data() + m_buffer.size() - 2;
uint16 tmp = _BE(v);
std::memcpy(p, &tmp, sizeof(tmp));
}
template<>
void MemStreamWriter::writeBE<uint8>(const uint8& v)
{
m_buffer.emplace_back(v);
}
template<>
void MemStreamWriter::writeBE<bool>(const bool& v)
{
writeData(&v, sizeof(bool));
}
template<>
bool MemStreamReader::readBE<bool>()
{
bool v{ false };
readData(&v, sizeof(bool));
return v;
}
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<std::string>(const std::string& v)
@ -176,21 +129,25 @@ void MemStreamWriter::writeBE<std::string>(const std::string& v)
writeData(v.data(), v.size());
}
template<>
void MemStreamWriter::writeLE<uint64>(const uint64& v)
// writeLE void
template<typename T>
void MemStreamWriter::writeLE(const T& v)
{
m_buffer.resize(m_buffer.size() + 8);
uint8* p = m_buffer.data() + m_buffer.size() - 8;
uint64 tmp = _LE(v);
m_buffer.resize(m_buffer.size() + sizeof(T));
uint8* p = m_buffer.data() + m_buffer.size() - sizeof(T);
T tmp = _LE(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 uint32& v);
template<>
void MemStreamWriter::writeLE<uint32>(const uint32& v)
// writeSection
void MemStreamWriter::writeSection(const char* sec)
{
m_buffer.resize(m_buffer.size() + 4);
uint8* p = m_buffer.data() + m_buffer.size() - 4;
uint32 tmp = _LE(v);
std::memcpy(p, &tmp, sizeof(tmp));
std::string sec_str = std::string(sec);
writeBE(sec_str);
}

86
src/util/helpers/Serializer.h
View file

@ -12,6 +12,12 @@ public:
template<typename T> void readBE(T& v);
template<typename T> T readLE();
template<typename T>
void readAtomic(std::atomic<T>& v)
{
v.store(readBE<T>());
}
template<typename T>
std::vector<T> readPODVector()
{
@ -27,6 +33,48 @@ public:
return v;
}
template<typename T>
void readPODVector(std::vector<T>& v)
{
uint32 numElements = readBE<uint32>();
if (!hasError())
{
v.reserve(numElements);
v.resize(numElements);
readData(v.data(), v.size() * sizeof(T));
}
}
template<typename T>
void readPTR(T& v)
{
v = (T)(memory_base + readBE<uint32>());
}
template<template<typename> class C, typename T>
void readMPTR(C<T>& v)
{
v = (T*)(memory_base + readBE<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>());
}
void readBool(bool& v)
{
v = readBE<uint8>();
}
bool readBool()
{
return readBE<uint8>();
}
void readSection(const char* sec);
// read string terminated by newline character (or end of stream)
// will also trim off any carriage return
std::string_view readLine()
@ -70,6 +118,13 @@ public:
}
bool readData(void* ptr, size_t size)
{
if (readBE<uint8>())
{
ptr = NULL;
return false;
}
else
{
if (m_cursorPos + size > m_size)
{
@ -81,6 +136,7 @@ public:
m_cursorPos += (sint32)size;
return true;
}
}
std::span<uint8> readDataNoCopy(size_t size)
{
@ -146,22 +202,52 @@ public:
}
void writeData(const void* ptr, size_t size)
{
writeBE((uint8)(ptr == NULL));
if (ptr)
{
m_buffer.resize(m_buffer.size() + size);
uint8* p = m_buffer.data() + m_buffer.size() - size;
memcpy(p, ptr, size);
}
}
template<typename T> void writeBE(const T& v);
template<typename T> void writeLE(const T& v);
template<typename T>
void writeAtomic(const std::atomic<T>& v)
{
writeBE(v.load());
}
template<typename T>
void writePODVector(const std::vector<T>& v)
{
cemu_assert(std::is_trivial_v<T>);
writeBE<uint32>(v.size());
writeData(v.data(), v.size() * sizeof(T));
}
template<typename T>
void writePTR(const T& v)
{
writeBE((uint32)((uint8*)v - (uint8*)memory_base));
}
template<typename T>
void writeMPTR(const T& v)
{
writeBE(v.GetMPTR());
}
void writeBool(const bool& v)
{
writeBE((uint8)v);
}
void writeSection(const char* sec);
// get result buffer without copy
// resets internal state
void getResultAndReset(std::vector<uint8>& data)