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 1

Move to Endian agnostic read/write functions; add kernel

Browse source
This commit is contained in:
Chris Spegal 2023-10-10 10:59:26 -04:00
parent b8a83ab448
commit 1b7c4d8a2f
35 changed files with 468 additions and 222 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/Cafe/CafeSystem.cpp
View file

@ -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);

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

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

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

@ -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)

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

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

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

@ -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<uint32>();
mmuRange.areaId = (MMU_MEM_AREA_ID)readBE<uint8>();
mmuRange.flags = (MMURange::MFLAG)readBE<uint8>();
mmuRange.name = readBE<std::string>();
mmuRange.size = readBE<uint32>();
mmuRange.initSize = readBE<uint32>();
mmuRange.baseAddress = read<uint32>();
mmuRange.areaId = (MMU_MEM_AREA_ID)read<uint8>();
mmuRange.flags = (MMURange::MFLAG)read<uint8>();
mmuRange.name = read<std::string>();
mmuRange.size = read<uint32>();
mmuRange.initSize = read<uint32>();
if (needsMapped)
mmuRange.mapMem();
}
@ -443,7 +443,7 @@ void memory_Serialize(MemStreamWriter& s)
{
for (auto& itr : g_mmuRanges)
{
s.writeBE(*itr);
s.write(*itr);
if (itr->isMapped())
{
s.writeData(memory_base + itr->getBase(), itr->getSize());
@ -455,7 +455,7 @@ void memory_Deserialize(MemStreamReader& s)
{
for (auto& itr : g_mmuRanges)
{
s.readBE<MMURange>(*itr);
s.read<MMURange>(*itr);
if (itr->isMapped())
{
s.readData(memory_base + itr->getBase(), itr->getSize());

20
src/Cafe/IOSU/ODM/iosu_odm.cpp
View file

@ -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))

3
src/Cafe/IOSU/ODM/iosu_odm.h
View file

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

9
src/Cafe/IOSU/PDM/iosu_pdm.cpp
View file

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

3
src/Cafe/IOSU/PDM/iosu_pdm.h
View file

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

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

@ -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

4
src/Cafe/IOSU/fsa/iosu_fsa.h
View file

@ -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

132
src/Cafe/IOSU/kernel/iosu_kernel.cpp
View file

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

3
src/Cafe/IOSU/kernel/iosu_kernel.h
View file

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

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

@ -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);

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

@ -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>();
uint64_t timeOffset = currentTime - s.read<uint64_t>();
size_t alms = s.readBE<uint64>();
size_t alms = s.read<uint64>();
for (size_t alm = 0; alm < alms; alm++)
{
OSAlarm_t* alarm = (OSAlarm_t*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
OSAlarm_t* alarm = (OSAlarm_t*)memory_getPointerFromVirtualOffset(s.read<MPTR>());
uint64 startTime = _swapEndianU64(alarm->startTime) + timeOffset;
uint64 nextTime = _swapEndianU64(alarm->nextTime) + timeOffset;
@ -360,7 +360,7 @@ namespace coreinit
}
alarm->nextTime = _swapEndianU64(nextTime);
uint64 nextFire = s.readBE<uint64>() + timeOffset;
uint64 nextFire = s.read<uint64>() + timeOffset;
__OSLockScheduler();
g_activeAlarms[alarm] = OSHostAlarmCreate(nextFire, period, __OSHostAlarmTriggered, nullptr);
__OSUnlockScheduler();

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

@ -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()

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

@ -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);
}

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

@ -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()

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

@ -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);

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

@ -155,26 +155,25 @@ namespace coreinit
void MemoryMapping_Save(MemStreamWriter& s)
{
s.writeSection("coreinit_MemoryMapping ");
s.writeBE<uint32>(s_allocatedVirtMemory.size());
s.writeSection("coreinit_MemoryMapping");
s.write<uint32>(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<uint32>();
s.readSection("coreinit_MemoryMapping");
uint32 s_allocatedVirtMemorySize = s.read<uint32>();
s_allocatedVirtMemory.clear();
s_allocatedVirtMemory.reserve(s_allocatedVirtMemorySize);
for (sint32 i = 0; i < s_allocatedVirtMemorySize; i++)
{
s_allocatedVirtMemory.push_back(OSVirtMemoryEntry(s.readBE<MPTR>(), s.readBE<uint32>(), s.readBE<uint32>()));
s_allocatedVirtMemory.push_back(OSVirtMemoryEntry(s.read<MPTR>(), s.read<uint32>(), s.read<uint32>()));
}
}

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

@ -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()

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

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

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

@ -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()

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

@ -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);

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

@ -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<uint32>();
s.read(nn::act::g_initializeCount);
g_isParentalControlCheckEnabled = s.read<uint32>();
}
// register account functions

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

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

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

@ -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);
}

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

@ -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()

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

@ -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);

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

@ -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()

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

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

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

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

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

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

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

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

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

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