falso
/
tp
mirror of https://github.com/zeldaret/tp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

clean JKernel

This commit is contained in:
TakaRikka 2023-02-26 17:50:56 -08:00
parent c54f0816ea
commit 090dcee012
30 changed files with 609 additions and 1285 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
include/JSystem/JKernel/JKRCompArchive.h
View File

@ -9,12 +9,12 @@ public:
JKRCompArchive(long, JKRArchive::EMountDirection);
virtual ~JKRCompArchive();
void open(long);
bool open(long);
/* vt[09] */ void removeResourceAll(void); /* override */
/* vt[10] */ bool removeResource(void*); /* override */
/* vt[15] */ u32 getExpandedResSize(const void*); /* override */
/* vt[15] */ u32 getExpandedResSize(const void*) const; /* override */
/* vt[16] */ void* fetchResource(SDIFileEntry*, u32*); /* override */
/* vt[17] */ void* fetchResource(void*, u32, SDIFileEntry*, u32*); /* override */
@ -23,9 +23,9 @@ private:
/* 0x00 */ // vtable
/* 0x04 */ // JKRArchive
/* 0x5C */ int field_0x5c;
/* 0x60 */ int field_0x60;
/* 0x60 */ EMountDirection mMountDirection;
/* 0x64 */ int field_0x64;
/* 0x68 */ int field_0x68;
/* 0x68 */ JKRAramBlock* field_0x68;
/* 0x6C */ int field_0x6c;
/* 0x70 */ JKRDvdFile* field_0x70;
/* 0x74 */ u32 mSizeOfMemPart;

10
include/JSystem/JSupport/JSupport.h
View File

@ -1,6 +1,8 @@
#ifndef JSUPPORT_H
#define JSUPPORT_H
#include "dolphin/types.h"
template <typename T>
T* JSUConvertOffsetToPtr(const void* ptr, const void* offset) {
if (offset == NULL) {
@ -10,4 +12,12 @@ T* JSUConvertOffsetToPtr(const void* ptr, const void* offset) {
}
}
inline u8 JSULoByte(u16 in) {
return in & 0xff;
}
inline u8 JSUHiByte(u16 in) {
return in >> 8;
}
#endif

1
include/JSystem/JUtility/JUTConsole.h
View File

@ -147,5 +147,6 @@ extern "C" void JUTSetWarningConsole(JUTConsole*);
extern "C" JUTConsole* JUTGetWarningConsole();
extern "C" void JUTReportConsole_f_va(const char*, va_list);
extern "C" void JUTReportConsole_f(const char*, ...);
extern "C" void JUTWarningConsole(const char* message);
#endif /* JUTCONSOLE_H */

3
include/dolphin/os/OSAlloc.h
View File

@ -26,7 +26,8 @@ typedef u32 OSHeapHandle;
extern volatile s32 __OSCurrHeap;
#define OSRoundUp32B(v) (((u32)(v + 31) & ~31))
#define OSRoundUp32B(x) (((u32)(x) + 0x1F) & ~(0x1F))
#define OSRoundDown32B(x) (((u32)(x)) & ~(0x1F))
#define OSRoundUp(x, align) (((x) + (align)-1) & (-(align)))
#define OSRoundUpPtr(x, align) ((void*)((((u32)(x)) + (align)-1) & (~((align)-1))))

17
libs/JSystem/JKernel/JKRAram.cpp
View File

@ -124,7 +124,7 @@ JKRAram::JKRAram(u32 audio_buffer_size, u32 audio_graph_size, long priority)
u32 aramSize = ARGetSize();
mAudioMemorySize = audio_buffer_size;
if (audio_graph_size == 0xffffffff) {
if (audio_graph_size == 0xFFFFFFFF) {
mGraphMemorySize = (aramSize - audio_buffer_size) - aramBase;
mAramMemorySize = 0;
} else {
@ -171,24 +171,15 @@ void* JKRAram::run(void) {
} while (true);
}
/* ############################################################################################## */
/* 8039D078-8039D078 0296D8 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */
// #pragma push
// #pragma force_active on
// SECTION_DEAD static char const* const stringBase_8039D078 = "JKRAram.cpp";
// SECTION_DEAD static char const* const stringBase_8039D084 = "%s";
// SECTION_DEAD static char const* const stringBase_8039D087 = ":::address not 32Byte aligned.";
// #pragma pop
/* 802D2248-802D22DC 2CCB88 0094+00 2/2 0/0 0/0 .text
* checkOkAddress__7JKRAramFPUcUlP12JKRAramBlockUl */
void JKRAram::checkOkAddress(u8* addr, u32 size, JKRAramBlock* block, u32 param_4) {
if (!IS_ALIGNED((u32)addr, 0x20) && !IS_ALIGNED(size, 0x20)) {
JUTException::panic_f("JKRAram.cpp", 0xdb, "%s", ":::address not 32Byte aligned.");
JUTException::panic_f(__FILE__, 219, "%s", ":::address not 32Byte aligned.");
}
if (block && !IS_ALIGNED((u32)block->getAddress() + param_4, 0x20)) {
JUTException::panic_f("JKRAram.cpp", 0xe3, "%s", ":::address not 32Byte aligned.");
JUTException::panic_f(__FILE__, 227, "%s", ":::address not 32Byte aligned.");
}
}
@ -445,5 +436,3 @@ SECTION_DEAD static char const* const stringBase_8039D0A6 = "bad aramSync\n";
/* @stringBase0 padding */
SECTION_DEAD static char const* const pad_8039D0B4 = "\0\0\0";
#pragma pop
/* 8039D078-8039D078 0296D8 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */

74
libs/JSystem/JKernel/JKRAramArchive.cpp
View File

@ -8,19 +8,11 @@
#include "JSystem/JKernel/JKRDvdAramRipper.h"
#include "JSystem/JKernel/JKRDvdRipper.h"
#include "JSystem/JKernel/JKRFile.h"
#include "JSystem/JUtility/JUTException.h"
#include "MSL_C/MSL_Common/Src/string.h"
#include "MSL_C/math.h"
#include "dol2asm.h"
#include "dolphin/os/OSCache.h"
#include "dolphin/types.h"
//
// Types:
//
struct JUTException {
/* 802E21FC */ static void panic_f(char const*, int, char const*, ...);
};
//
// Forward References:
@ -112,9 +104,11 @@ SECTION_DATA extern void* __vt__7JKRFile[8] = {
JKRAramArchive::JKRAramArchive(s32 param_0, JKRArchive::EMountDirection mountDirection)
: JKRArchive(param_0, MOUNT_ARAM) {
mMountDirection = mountDirection;
if (!this->open(param_0)) {
return;
}
mVolumeType = 'RARC';
mVolumeName = mStringTable + mNodes->name_offset;
JKRFileLoader::sVolumeList.prepend(&mFileLoaderLink);
@ -131,19 +125,24 @@ JKRAramArchive::~JKRAramArchive() {
JKRHeap::free(entry->data, mHeap);
}
}
JKRHeap::free(mArcInfoBlock, mHeap);
mArcInfoBlock = NULL;
}
if (mExpandedSize != NULL) {
JKRHeap::free(mExpandedSize, NULL);
mExpandedSize = NULL;
}
if (mDvdFile != NULL) {
delete mDvdFile;
}
if (mBlock != NULL) {
delete mBlock;
}
JKRFileLoader::sVolumeList.remove(&mFileLoaderLink);
mIsMounted = false;
}
@ -174,6 +173,7 @@ bool JKRAramArchive::open(s32 entryNum) {
mMountMode = UNKNOWN_MOUNT_MODE;
return false;
}
SArcHeader* header = static_cast<SArcHeader*>(JKRAllocFromSysHeap(0x20, -0x20));
if (header == NULL) {
mMountMode = UNKNOWN_MOUNT_MODE;
@ -263,15 +263,18 @@ void* JKRAramArchive::fetchResource(JKRArchive::SDIFileEntry* pEntry, u32* pOutS
if (pOutSize == NULL) {
pOutSize = &outSize;
}
JKRCompression compression = JKRConvertAttrToCompressionType(pEntry->getFlags());
if (pEntry->data == NULL) {
u32 size = JKRAramArchive::fetchResource_subroutine(
pEntry->data_offset + mBlock->getAddress(), pEntry->data_size, mHeap, compression,
&outBuf);
*pOutSize = size;
if (size == NULL) {
return NULL;
}
pEntry->data = outBuf;
if (compression == COMPRESSION_YAZ0) {
this->setExpandSize(pEntry, *pOutSize);
@ -283,6 +286,7 @@ void* JKRAramArchive::fetchResource(JKRArchive::SDIFileEntry* pEntry, u32* pOutS
*pOutSize = pEntry->data_size;
}
}
return pEntry->data;
}
@ -352,6 +356,7 @@ u32 JKRAramArchive::fetchResource_subroutine(u32 src, u32 srcLength, u8* dst, u3
u32 outLen;
u32 srcSize = ALIGN_NEXT(srcLength, 0x20);
u32 dstSize = ALIGN_PREV(dstLength, 0x20);
switch (compression) {
case COMPRESSION_NONE:
if (srcSize > dstSize) {
@ -366,7 +371,7 @@ u32 JKRAramArchive::fetchResource_subroutine(u32 src, u32 srcLength, u8* dst, u3
&outLen);
return outLen;
default:
JUTException::panic_f("JKRAramArchive.cpp", 0x28F, "%s", "??? bad sequence\n");
JUTException::panic_f(__FILE__, 655, "%s", "??? bad sequence\n");
return 0;
}
}
@ -400,7 +405,7 @@ u32 JKRAramArchive::fetchResource_subroutine(u32 entryNum, u32 length, JKRHeap*
*out = tmpBufAligned;
return readLen;
default:
JUTException::panic_f("JKRAramArchive.cpp", 0x2c9, "%s", "??? bad sequence\n");
JUTException::panic_f(__FILE__, 0x2c9, "%s", "??? bad sequence\n");
return 0;
}
}
@ -420,29 +425,30 @@ asm u32 JKRAramArchive::fetchResource_subroutine(u32 param_0, u32 param_1, JKRHe
u32 JKRAramArchive::getExpandedResSize(void const* ptr) const {
if (mExpandedSize == NULL) {
return this->getResSize(ptr);
} else {
JKRArchive::SDIFileEntry* entry = this->findPtrResource(ptr);
if (entry == NULL) {
return 0xFFFFFFFF;
} else {
if (entry->getCompressFlag() == 0) {
return this->getResSize(ptr);
} else {
u32 expandSize = this->getExpandSize(entry);
if (expandSize != 0) {
return expandSize;
}
u8 tmpBuf[0x40];
SArcHeader* buf = (SArcHeader*)ALIGN_PREV((s32)&tmpBuf[0x1F], 0x20);
JKRAramToMainRam(entry->data_offset + mBlock->getAddress(), (u8*)buf, 0x20,
EXPAND_SWITCH_UNKNOWN0, 0, NULL, -1, NULL);
expandSize = JKRDecompExpandSize(buf);
// ??? casting away const?
((JKRArchive*)this)->setExpandSize(entry, expandSize);
return expandSize;
}
}
}
JKRArchive::SDIFileEntry* entry = this->findPtrResource(ptr);
if (entry == NULL) {
return 0xFFFFFFFF;
}
if (entry->getCompressFlag() == 0) {
return this->getResSize(ptr);
}
u32 expandSize = this->getExpandSize(entry);
if (expandSize != 0) {
return expandSize;
}
u8 tmpBuf[0x40];
SArcHeader* buf = (SArcHeader*)ALIGN_PREV((s32)&tmpBuf[0x1F], 0x20);
JKRAramToMainRam(entry->data_offset + mBlock->getAddress(), (u8*)buf, 0x20,
EXPAND_SWITCH_UNKNOWN0, 0, NULL, -1, NULL);
expandSize = JKRDecompExpandSize(buf);
// ??? casting away const?
((JKRArchive*)this)->setExpandSize(entry, expandSize);
return expandSize;
}
/* 802D7B90-802D7BF0 2D24D0 0060+00 1/0 0/0 0/0 .text __dt__7JKRFileFv */
@ -455,5 +461,3 @@ extern "C" asm void __dt__7JKRFileFv() {
#include "asm/JSystem/JKernel/JKRAramArchive/__dt__7JKRFileFv.s"
}
#pragma pop
/* 8039D188-8039D188 0297E8 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */

7
libs/JSystem/JKernel/JKRAramBlock.cpp
View File

@ -6,12 +6,6 @@
#include "JSystem/JKernel/JKRAramBlock.h"
#include "JSystem/JKernel/JKRAramHeap.h"
#include "JSystem/JKernel/JKRHeap.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Declarations:
//
/* 802D3304-802D3378 2CDC44 0074+00 2/2 1/1 0/0 .text __ct__12JKRAramBlockFUlUlUlUcb */
JKRAramBlock::JKRAramBlock(u32 address, u32 size, u32 freeSize, u8 groupId, bool isTempMemory)
@ -27,6 +21,7 @@ JKRAramBlock::JKRAramBlock(u32 address, u32 size, u32 freeSize, u8 groupId, bool
JKRAramBlock::~JKRAramBlock() {
JSUList<JKRAramBlock>* list = mBlockLink.getSupervisor();
JSULink<JKRAramBlock>* prev = mBlockLink.getPrev();
if (prev) {
JKRAramBlock* block = prev->getObject();
block->mFreeSize = mSize + mFreeSize + block->mFreeSize;

35
libs/JSystem/JKernel/JKRAramHeap.cpp
View File

@ -5,48 +5,20 @@
#include "JSystem/JKernel/JKRAramHeap.h"
#include "JSystem/JKernel/JKRHeap.h"
#include "dol2asm.h"
#include "global.h"
//
// Forward References:
//
extern "C" void __ct__11JKRAramHeapFUlUl();
extern "C" void __dt__11JKRAramHeapFv();
extern "C" void alloc__11JKRAramHeapFUlQ211JKRAramHeap10EAllocMode();
extern "C" void allocFromHead__11JKRAramHeapFUl();
extern "C" void allocFromTail__11JKRAramHeapFUl();
extern "C" void getFreeSize__11JKRAramHeapFv();
extern "C" void getTotalFreeSize__11JKRAramHeapFv();
extern "C" void dump__11JKRAramHeapFv();
extern "C" void __sinit_JKRAramHeap_cpp();
extern "C" void func_802D32B0(void* _this);
extern "C" u8 sAramList__11JKRAramHeap[12];
extern "C" void* __vt__11JKRAramHeap;
//
// External References:
//
// TODO: move to JKRHeap
void* operator new(u32 size);
void* operator new(u32 size, int alignment);
void* operator new(u32 size, JKRHeap* heap, int alignment);
extern "C" void findFromRoot__7JKRHeapFPv();
extern "C" void* __nw__FUlP7JKRHeapi();
extern "C" void __dl__FPv();
extern "C" void __ct__11JKRDisposerFv();
extern "C" void __dt__11JKRDisposerFv();
extern "C" void __ct__12JKRAramBlockFUlUlUlUcb();
extern "C" void allocHead__12JKRAramBlockFUlUcP11JKRAramHeap();
extern "C" void allocTail__12JKRAramBlockFUlUcP11JKRAramHeap();
extern "C" void __dt__10JSUPtrListFv();
extern "C" void initiate__10JSUPtrListFv();
extern "C" void append__10JSUPtrListFP10JSUPtrLink();
extern "C" void __register_global_object();
extern "C" void _savegpr_29();
extern "C" void _restgpr_29();
@ -54,9 +26,6 @@ extern "C" void _restgpr_29();
// Declarations:
//
/* 80434300-8043430C 061020 000C+00 1/1 0/0 0/0 .bss @297 */
static u8 lit_297[12];
/* 8043430C-80434318 06102C 000C+00 8/8 0/0 0/0 .bss sAramList__11JKRAramHeap */
JSUList<JKRAramBlock> JKRAramHeap::sAramList;
@ -206,9 +175,7 @@ void JKRAramHeap::dump(void) {
JSUList<JKRAramBlock>* list = &sAramList;
JSUListIterator<JKRAramBlock> iterator = list;
for (; iterator != list->getEnd(); ++iterator) {
// The debug version calls OSReport
}
for (; iterator != list->getEnd(); ++iterator) {}
unlock();
}

12
libs/JSystem/JKernel/JKRAramPiece.cpp
View File

@ -8,13 +8,7 @@
#include "JSystem/JKernel/JKRDecomp.h"
#include "JSystem/JKernel/JKRHeap.h"
#include "JSystem/JUtility/JUTException.h"
#include "dol2asm.h"
#include "dolphin/os/OSCache.h"
#include "dolphin/types.h"
//
// Declarations:
//
/* 802D3574-802D35F4 2CDEB4 0080+00 1/1 0/0 0/0 .text
* prepareCommand__12JKRAramPieceFiUlUlUlP12JKRAramBlockPFUl_v */
@ -49,12 +43,12 @@ OSMutex JKRAramPiece::mMutex;
JKRAMCommand* JKRAramPiece::orderAsync(int direction, u32 source, u32 destination, u32 length,
JKRAramBlock* block, JKRAMCommand::AsyncCallback callback) {
lock();
if (((source & 0x1f) != 0) || ((destination & 0x1f) != 0)) {
if ((source & 0x1f) != 0 || (destination & 0x1f) != 0) {
OSReport("direction = %x\n", direction);
OSReport("source = %x\n", source);
OSReport("destination = %x\n", destination);
OSReport("length = %x\n", length);
JUTException::panic_f("JKRAramPiece.cpp", 0x6c, "%s", "illegal address. abort.");
JUTException::panic_f(__FILE__, 108, "%s", "illegal address. abort.");
}
Message* message = new (JKRHeap::getSystemHeap(), -4) Message();
@ -167,5 +161,3 @@ JKRAMCommand::~JKRAMCommand() {
if (field_0x94)
JKRHeap::free(field_0x94, NULL);
}
/* 8039D0B8-8039D0B8 029718 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */

121
libs/JSystem/JKernel/JKRAramStream.cpp
View File

@ -9,57 +9,6 @@
#include "JSystem/JSupport/JSUFileStream.h"
#include "JSystem/JSupport/JSURandomInputStream.h"
#include "JSystem/JUtility/JUTException.h"
#include "dol2asm.h"
#include "global.h"
//
// Forward References:
//
extern "C" void create__13JKRAramStreamFl();
extern "C" void __ct__13JKRAramStreamFl();
extern "C" void __dt__13JKRAramStreamFv();
extern "C" void run__13JKRAramStreamFv();
extern "C" bool readFromAram__13JKRAramStreamFv();
extern "C" void writeToAram__13JKRAramStreamFP20JKRAramStreamCommand();
extern "C" void write_StreamToAram_Async__13JKRAramStreamFP18JSUFileInputStreamUlUlUlPUl();
extern "C" void sync__13JKRAramStreamFP20JKRAramStreamCommandi();
extern "C" void setTransBuffer__13JKRAramStreamFPUcUlP7JKRHeap();
extern "C" void __ct__20JKRAramStreamCommandFv();
extern "C" s32 getAvailable__20JSURandomInputStreamCFv(JSURandomInputStream*);
extern "C" extern char const* const JKRAramStream__stringBase0;
extern "C" u8 sMessageBuffer__13JKRAramStream[16];
extern "C" u8 sMessageQueue__13JKRAramStream[32];
extern "C" u8 sAramStreamObject__13JKRAramStream[4];
extern "C" u8 transBuffer__13JKRAramStream[4];
extern "C" u8 transSize__13JKRAramStream[4];
extern "C" u8 transHeap__13JKRAramStream[4];
//
// External References:
//
extern "C" void alloc__7JKRHeapFUliP7JKRHeap();
extern "C" void alloc__7JKRHeapFUli();
extern "C" void free__7JKRHeapFPvP7JKRHeap();
extern "C" void* __nw__FUlP7JKRHeapi();
extern "C" void __dl__FPv();
extern "C" void __ct__9JKRThreadFUlii();
extern "C" void __dt__9JKRThreadFv();
extern "C" void orderSync__12JKRAramPieceFiUlUlUlP12JKRAramBlock();
extern "C" void read__14JSUInputStreamFPvl();
extern "C" void seek__20JSURandomInputStreamFl17JSUStreamSeekFrom();
extern "C" void panic_f__12JUTExceptionFPCciPCce();
extern "C" void _savegpr_24();
extern "C" void _savegpr_26();
extern "C" void _restgpr_24();
extern "C" void _restgpr_26();
extern "C" u8 sSystemHeap__7JKRHeap[4];
extern "C" u8 sCurrentHeap__7JKRHeap[4];
//
// Declarations:
//
/* ############################################################################################## */
/* 80451408-8045140C 000908 0004+00 1/1 0/0 0/0 .sbss sAramStreamObject__13JKRAramStream
@ -97,7 +46,7 @@ JKRAramStream::JKRAramStream(long priority) : JKRThread(0xc00, 0x10, priority) {
JKRAramStream::~JKRAramStream() {}
/* 802D3C68-802D3CD8 2CE5A8 0070+00 1/0 0/0 0/0 .text run__13JKRAramStreamFv */
void* JKRAramStream::run(void) {
void* JKRAramStream::run() {
OSInitMessageQueue(&sMessageQueue, sMessageBuffer, ARRAY_SIZE(sMessageBuffer));
for (;;) {
@ -117,16 +66,13 @@ void* JKRAramStream::run(void) {
}
/* 802D3CD8-802D3CE0 2CE618 0008+00 1/1 0/0 0/0 .text readFromAram__13JKRAramStreamFv */
s32 JKRAramStream::readFromAram(void) {
s32 JKRAramStream::readFromAram() {
return 1;
}
/* ############################################################################################## */
/* 8039D120-8039D120 029780 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */
// regalloc problems
#ifdef NONMATCHING
s32 JKRAramStream::writeToAram(JKRAramStreamCommand* command) {
u32 size;
u32 dstSize = command->mSize;
u32 offset = command->mOffset;
u32 writtenLength = 0;
@ -134,31 +80,24 @@ s32 JKRAramStream::writeToAram(JKRAramStreamCommand* command) {
u8* buffer = command->mTransferBuffer;
u32 bufferSize = command->mTransferBufferSize;
JKRHeap* heap = command->mHeap;
if (buffer) {
if (bufferSize) {
size = bufferSize;
} else {
size = 0x8000;
}
command->mTransferBufferSize = size;
if (buffer) {
bufferSize = (bufferSize) ? bufferSize : 0x8000;
command->mTransferBufferSize = bufferSize;
command->mAllocatedTransferBuffer = false;
} else {
if (bufferSize) {
size = bufferSize;
} else {
size = 0x8000;
}
bufferSize = (bufferSize) ? bufferSize : 0x8000;
if (heap) {
buffer = (u8*)JKRAllocFromHeap(heap, size, -0x20);
buffer = (u8*)JKRAllocFromHeap(heap, bufferSize, -0x20);
command->mTransferBuffer = buffer;
} else {
buffer = (u8*)JKRAllocFromSysHeap(size, -0x20);
buffer = (u8*)JKRAllocFromSysHeap(bufferSize, -0x20);
command->mTransferBuffer = buffer;
}
command->mTransferBufferSize = size;
command->mTransferBufferSize = bufferSize;
command->mAllocatedTransferBuffer = true;
}
@ -169,20 +108,15 @@ s32 JKRAramStream::writeToAram(JKRAramStreamCommand* command) {
heap->dump();
}
JUTException::panic_f("JKRAramStream.cpp", 0xac, "%s", ":::Cannot alloc memory\n");
JUTException::panic_f(__FILE__, 172, "%s", ":::Cannot alloc memory\n");
}
if (buffer) {
((JSURandomInputStream*)command->mStream)->seek(offset, JSUStreamSeekFrom_SET);
command->mStream->seek(offset, JSUStreamSeekFrom_SET);
while (dstSize != 0) {
u32 length;
if (dstSize > size) {
length = size;
} else {
length = dstSize;
}
u32 length = (dstSize > bufferSize) ? bufferSize : dstSize;
s32 readLength = ((JSURandomInputStream*)command->mStream)->read(buffer, length);
s32 readLength = command->mStream->read(buffer, length);
if (readLength == 0) {
writtenLength = 0;
break;
@ -190,7 +124,7 @@ s32 JKRAramStream::writeToAram(JKRAramStreamCommand* command) {
JKRAramPcs(0, (u32)buffer, destination, length, NULL);
dstSize -= length;
writtenLength += writtenLength;
writtenLength += length;
destination += length;
if (command->mReturnSize) {
@ -204,30 +138,9 @@ s32 JKRAramStream::writeToAram(JKRAramStreamCommand* command) {
}
}
OSSendMessage(&command->mMessageQueue, (OSMessage)writtenLength, OS_MESSAGE_NON_BLOCKING);
OSSendMessage(&command->mMessageQueue, (OSMessage)writtenLength, OS_MESSAGE_NOBLOCK);
return writtenLength;
}
#else
#pragma push
#pragma force_active on
SECTION_DEAD static char const* const stringBase_8039D120 = "JKRAramStream.cpp";
SECTION_DEAD static char const* const stringBase_8039D132 = "%s";
SECTION_DEAD static char const* const stringBase_8039D135 = ":::Cannot alloc memory\n";
/* @stringBase0 padding */
SECTION_DEAD static char const* const pad_8039D14D = "\0\0";
#pragma pop
/* 802D3CE0-802D3ED0 2CE620 01F0+00 1/1 0/0 0/0 .text
* writeToAram__13JKRAramStreamFP20JKRAramStreamCommand */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm s32 JKRAramStream::writeToAram(JKRAramStreamCommand* param_0) {
nofralloc
#include "asm/JSystem/JKernel/JKRAramStream/writeToAram__13JKRAramStreamFP20JKRAramStreamCommand.s"
}
#pragma pop
#endif
/* ############################################################################################## */
/* 8045140C-80451410 00090C 0004+00 2/2 0/0 0/0 .sbss transBuffer__13JKRAramStream */
@ -322,5 +235,3 @@ JKRAramStreamCommand::JKRAramStreamCommand() {
extern "C" s32 getAvailable__20JSURandomInputStreamCFv(JSURandomInputStream* self) {
return self->getLength() - self->getPosition();
}
/* 8039D120-8039D120 029780 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */

10
libs/JSystem/JKernel/JKRArchivePri.cpp
View File

@ -7,12 +7,6 @@
#include "JSystem/JKernel/JKRHeap.h"
#include "MSL_C/MSL_Common/Src/ctype.h"
#include "MSL_C/MSL_Common/Src/string.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Declarations:
//
/* ############################################################################################## */
/* 80451420-80451428 000920 0004+04 1/1 5/5 0/0 .sbss sCurrentDirID__10JKRArchive */
@ -78,7 +72,6 @@ JKRArchive::SDIDirEntry* JKRArchive::findDirectory(const char* name, u32 directo
SDIFileEntry* fileEntry = mFiles + dirEntry->first_file_index;
for (int i = 0; i < dirEntry->num_entries; fileEntry++, i++) {
// regalloc doesn't like fileEntry->getNameHash()
if (isSameName(arcName, fileEntry->getNameOffset(), fileEntry->name_hash)) {
if (fileEntry->isDirectory()) {
return findDirectory(name, fileEntry->data_offset);
@ -95,6 +88,7 @@ JKRArchive::SDIFileEntry* JKRArchive::findTypeResource(u32 type, const char* nam
if (type) {
CArcName arcName(name);
SDIDirEntry* dirEntry = findResType(type);
if (dirEntry) {
SDIFileEntry* fileEntry = mFiles + dirEntry->first_file_index;
for (int i = 0; i < dirEntry->num_entries; fileEntry++, i++) {
@ -115,8 +109,8 @@ JKRArchive::SDIFileEntry* JKRArchive::findFsResource(const char* name, u32 direc
CArcName arcName(&name, '/');
SDIDirEntry* dirEntry = mNodes + directoryId;
SDIFileEntry* fileEntry = mFiles + dirEntry->first_file_index;
for (int i = 0; i < dirEntry->num_entries; fileEntry++, i++) {
// regalloc doesn't like fileEntry->getNameHash()
if (isSameName(arcName, fileEntry->getNameOffset(), fileEntry->name_hash)) {
if (fileEntry->isDirectory()) {
return findFsResource(name, fileEntry->data_offset);

10
libs/JSystem/JKernel/JKRArchivePub.cpp
View File

@ -12,12 +12,6 @@
#include "JSystem/JKernel/JKRFileLoader.h"
#include "JSystem/JKernel/JKRHeap.h"
#include "JSystem/JKernel/JKRMemArchive.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Declarations:
//
/* 802D5778-802D57E4 2D00B8 006C+00 2/2 0/0 0/0 .text check_mount_already__10JKRArchiveFlP7JKRHeap
*/
@ -283,7 +277,7 @@ u32 JKRArchive::readResource(void* buffer, u32 bufferSize, u16 id) {
/* 802D5FB4-802D603C 2D08F4 0088+00 1/0 2/0 0/0 .text removeResourceAll__10JKRArchiveFv
*/
void JKRArchive::removeResourceAll(void) {
void JKRArchive::removeResourceAll() {
if (mArcInfoBlock && mMountMode != MOUNT_MEM) {
SDIFileEntry* fileEntry = mFiles;
for (int i = 0; i < mArcInfoBlock->num_file_entries; fileEntry++, i++) {
@ -326,7 +320,7 @@ u32 JKRArchive::getResSize(const void* resource) const {
}
/* 802D610C-802D6150 2D0A4C 0044+00 0/0 1/1 0/0 .text countResource__10JKRArchiveCFv */
u32 JKRArchive::countResource(void) const {
u32 JKRArchive::countResource() const {
u32 count = 0;
for (int i = 0; i < mArcInfoBlock->num_file_entries; i++) {
if (mFiles[i].isUnknownFlag1()) {

80
libs/JSystem/JKernel/JKRAssertHeap.cpp
View File

@ -4,56 +4,6 @@
//
#include "JSystem/JKernel/JKRAssertHeap.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
//
// Forward References:
//
extern "C" void __ct__13JKRAssertHeapFPvUlP7JKRHeapb();
extern "C" void __dt__13JKRAssertHeapFv();
extern "C" void create__13JKRAssertHeapFP7JKRHeap();
extern "C" void do_destroy__13JKRAssertHeapFv();
extern "C" void getHeapType__13JKRAssertHeapFv();
extern "C" bool check__13JKRAssertHeapFv();
extern "C" bool dump__13JKRAssertHeapFv();
extern "C" bool dump_sort__13JKRAssertHeapFv();
extern "C" bool do_changeGroupID__13JKRAssertHeapFUc();
extern "C" bool do_getCurrentGroupId__13JKRAssertHeapFv();
extern "C" bool do_alloc__13JKRAssertHeapFUli();
extern "C" void do_free__13JKRAssertHeapFPv();
extern "C" void do_freeAll__13JKRAssertHeapFv();
extern "C" void do_freeTail__13JKRAssertHeapFv();
extern "C" void do_fillFreeArea__13JKRAssertHeapFv();
extern "C" bool do_resize__13JKRAssertHeapFPvUl();
extern "C" bool do_getSize__13JKRAssertHeapFPv();
extern "C" bool do_getFreeSize__13JKRAssertHeapFv();
extern "C" bool do_getMaxFreeBlock__13JKRAssertHeapFv();
extern "C" bool do_getTotalFreeSize__13JKRAssertHeapFv();
//
// External References:
//
extern "C" void __ct__7JKRHeapFPvUlP7JKRHeapb();
extern "C" void __dt__7JKRHeapFv();
extern "C" void alloc__7JKRHeapFUliP7JKRHeap();
extern "C" void callAllDisposer__7JKRHeapFv();
extern "C" void dispose__7JKRHeapFv();
extern "C" void __dl__FPv();
extern "C" void state_register__7JKRHeapCFPQ27JKRHeap6TStateUl();
extern "C" void state_compare__7JKRHeapCFRCQ27JKRHeap6TStateRCQ27JKRHeap6TState();
extern "C" void state_dump__7JKRHeapCFRCQ27JKRHeap6TState();
extern "C" u8 sRootHeap__7JKRHeap[4];
//
// Declarations:
//
/* 802D12C4-802D1300 2CBC04 003C+00 1/1 0/0 0/0 .text __ct__13JKRAssertHeapFPvUlP7JKRHeapb */
JKRAssertHeap::JKRAssertHeap(void* data, unsigned long size, JKRHeap* parent, bool errorFlag)
@ -83,17 +33,17 @@ JKRAssertHeap* JKRAssertHeap::create(JKRHeap* parent) {
}
/* 802D13D8-802D1408 2CBD18 0030+00 1/0 0/0 0/0 .text do_destroy__13JKRAssertHeapFv */
void JKRAssertHeap::do_destroy(void) {
void JKRAssertHeap::do_destroy() {
this->~JKRAssertHeap();
}
/* 802D1408-802D1414 2CBD48 000C+00 1/0 0/0 0/0 .text getHeapType__13JKRAssertHeapFv */
u32 JKRAssertHeap::getHeapType(void) {
u32 JKRAssertHeap::getHeapType() {
return 'ASTH';
}
/* 802D1414-802D141C 2CBD54 0008+00 1/0 0/0 0/0 .text check__13JKRAssertHeapFv */
bool JKRAssertHeap::check(void) {
bool JKRAssertHeap::check() {
return true;
}
@ -114,7 +64,7 @@ s32 JKRAssertHeap::do_changeGroupID(u8) {
}
/* 802D1434-802D143C 2CBD74 0008+00 1/0 0/0 0/0 .text do_getCurrentGroupId__13JKRAssertHeapFv */
u8 JKRAssertHeap::do_getCurrentGroupId(void) {
u8 JKRAssertHeap::do_getCurrentGroupId() {
return 0;
}
@ -124,25 +74,17 @@ void* JKRAssertHeap::do_alloc(u32, int) {
}
/* 802D1444-802D1448 2CBD84 0004+00 1/0 0/0 0/0 .text do_free__13JKRAssertHeapFPv */
void JKRAssertHeap::do_free(void* param_0) {
/* empty function */
}
void JKRAssertHeap::do_free(void* param_0) {}
/* 802D1448-802D144C 2CBD88 0004+00 1/0 0/0 0/0 .text do_freeAll__13JKRAssertHeapFv */
void JKRAssertHeap::do_freeAll() {
/* empty function */
}
void JKRAssertHeap::do_freeAll() {}
/* 802D144C-802D1450 2CBD8C 0004+00 1/0 0/0 0/0 .text do_freeTail__13JKRAssertHeapFv */
void JKRAssertHeap::do_freeTail() {
/* empty function */
}
void JKRAssertHeap::do_freeTail() {}
/* 802D1450-802D1454 2CBD90 0004+00 1/0 0/0 0/0 .text do_fillFreeArea__13JKRAssertHeapFv
*/
void JKRAssertHeap::do_fillFreeArea() {
/* empty function */
}
void JKRAssertHeap::do_fillFreeArea() {}
/* 802D1454-802D145C 2CBD94 0008+00 1/0 0/0 0/0 .text do_resize__13JKRAssertHeapFPvUl */
s32 JKRAssertHeap::do_resize(void*, u32) {
@ -156,16 +98,16 @@ s32 JKRAssertHeap::do_getSize(void*) {
/* 802D1464-802D146C 2CBDA4 0008+00 1/0 0/0 0/0 .text do_getFreeSize__13JKRAssertHeapFv
*/
s32 JKRAssertHeap::do_getFreeSize(void) {
s32 JKRAssertHeap::do_getFreeSize() {
return 0;
}
/* 802D146C-802D1474 2CBDAC 0008+00 1/0 0/0 0/0 .text do_getMaxFreeBlock__13JKRAssertHeapFv */
void* JKRAssertHeap::do_getMaxFreeBlock(void) {
void* JKRAssertHeap::do_getMaxFreeBlock() {
return NULL;
}
/* 802D1474-802D147C 2CBDB4 0008+00 1/0 0/0 0/0 .text do_getTotalFreeSize__13JKRAssertHeapFv */
s32 JKRAssertHeap::do_getTotalFreeSize(void) {
s32 JKRAssertHeap::do_getTotalFreeSize() {
return 0;
}

257
libs/JSystem/JKernel/JKRCompArchive.cpp
View File

@ -3,122 +3,15 @@
// Translation Unit: JKRCompArchive
//
// #include "JSystem/JKernel/JKRCompArchive.h"
#include "JSystem/JKernel/JKRCompArchive.h"
#include "JSystem/JKernel/JKRAram.h"
#include "JSystem/JKernel/JKRDvdAramRipper.h"
#include "JSystem/JKernel/JKRDvdArchive.h"
#include "JSystem/JKernel/JKRMemArchive.h"
#include "JSystem/JUtility/JUTException.h"
#include "MSL_C/MSL_Common/Src/string.h"
#include "MSL_C/math.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct JUTException {
/* 802E21FC */ void panic_f(char const*, int, char const*, ...);
};
struct JSUPtrLink {};
struct JSUPtrList {
/* 802DBFF0 */ void prepend(JSUPtrLink*);
/* 802DC15C */ void remove(JSUPtrLink*);
};
struct JKRMemArchive {
/* 802D6F5C */ void fetchResource_subroutine(u8*, u32, u8*, u32, int);
};
struct JKRHeap {
/* 802CE4D4 */ void alloc(u32, int);
/* 802CE474 */ void alloc(u32, int, JKRHeap*);
/* 802CE500 */ void free(void*, JKRHeap*);
/* 802CE548 */ void free(void*);
/* 802CEB18 */ void copyMemory(void*, void*, u32);
static u8 sSystemHeap[4];
};
struct JKRFileLoader {
/* 802D41D4 */ void unmount();
static u8 sVolumeList[12];
};
struct JKRExpandSwitch {};
struct JKRDvdRipper {
struct EAllocDirection {};
/* 802D9C54 */ void loadToMainRAM(s32, u8*, JKRExpandSwitch, u32, JKRHeap*,
JKRDvdRipper::EAllocDirection, u32, int*, u32*);
};
struct JKRDvdFile {
/* 802D96A0 */ JKRDvdFile(s32);
};
struct JKRDvdArchive {
/* 802D8474 */ void fetchResource_subroutine(s32, u32, u32, JKRHeap*, int, int, u8**);
/* 802D826C */ void fetchResource_subroutine(s32, u32, u32, u8*, u32, int, int);
};
struct JKRDvdAramRipper {
/* 802DA874 */ void loadToAram(s32, u32, JKRExpandSwitch, u32, u32, u32*);
};
struct JKRDecomp {
/* 802DB988 */ void orderSync(u8*, u8*, u32, u32);
};
struct JKRArchive {
struct EMountDirection {};
struct SDIFileEntry {};
struct EMountMode {};
/* 802D5A38 */ void becomeCurrent(char const*);
/* 802D5C64 */ void getResource(u32, char const*);
/* 802D5BE8 */ void getResource(char const*);
/* 802D5D8C */ void readResource(void*, u32, u32, char const*);
/* 802D5E30 */ void readResource(void*, u32, char const*);
/* 802D609C */ void detachResource(void*);
/* 802D60D8 */ void getResSize(void const*) const;
/* 802D6150 */ void countFile(char const*) const;
/* 802D61B0 */ void getFirstFile(char const*) const;
/* 802D6294 */ JKRArchive(s32, JKRArchive::EMountMode);
/* 802D6334 */ ~JKRArchive();
/* 802D6734 */ void findPtrResource(void const*) const;
/* 802D693C */ void setExpandSize(JKRArchive::SDIFileEntry*, u32);
/* 802D6978 */ void getExpandSize(JKRArchive::SDIFileEntry*) const;
};
struct JKRCompArchive {
/* 802D87D4 */ JKRCompArchive(s32, JKRArchive::EMountDirection);
/* 802D887C */ ~JKRCompArchive();
/* 802D89BC */ void open(s32);
/* 802D8F40 */ void fetchResource(JKRArchive::SDIFileEntry*, u32*);
/* 802D90C0 */ void fetchResource(void*, u32, JKRArchive::SDIFileEntry*, u32*);
/* 802D9260 */ void removeResourceAll();
/* 802D92F4 */ void removeResource(void*);
/* 802D9360 */ void getExpandedResSize(void const*) const;
};
struct JKRAramHeap {
struct EAllocMode {};
/* 802D2FBC */ void alloc(u32, JKRAramHeap::EAllocMode);
};
struct JKRAramArchive {
/* 802D7858 */ void fetchResource_subroutine(u32, u32, u8*, u32, int);
/* 802D7914 */ void fetchResource_subroutine(u32, u32, JKRHeap*, int, u8**);
};
struct JKRAram {
/* 802D233C */ void mainRamToAram(u8*, u32, u32, JKRExpandSwitch, u32, JKRHeap*, int, u32*);
/* 802D25B4 */ void aramToMainRam(u32, u8*, u32, JKRExpandSwitch, u32, JKRHeap*, int, u32*);
static u8 sAramObject[4];
};
//
// Forward References:
@ -138,7 +31,6 @@ extern "C" extern char const* const JKRCompArchive__stringBase0;
// External References:
//
SECTION_INIT void memset();
extern "C" void alloc__7JKRHeapFUliP7JKRHeap();
extern "C" void alloc__7JKRHeapFUli();
extern "C" void free__7JKRHeapFPvP7JKRHeap();
@ -177,7 +69,6 @@ extern "C" void orderSync__9JKRDecompFPUcPUcUlUl();
extern "C" void prepend__10JSUPtrListFP10JSUPtrLink();
extern "C" void remove__10JSUPtrListFP10JSUPtrLink();
extern "C" void panic_f__12JUTExceptionFPCciPCce();
extern "C" void DCInvalidateRange();
extern "C" void _savegpr_25();
extern "C" void _savegpr_26();
extern "C" void _savegpr_28();
@ -186,7 +77,6 @@ extern "C" void _restgpr_25();
extern "C" void _restgpr_26();
extern "C" void _restgpr_28();
extern "C" void _restgpr_29();
extern "C" void abs();
extern "C" u8 sVolumeList__13JKRFileLoader[12];
extern "C" u8 sSystemHeap__7JKRHeap[4];
extern "C" u8 sAramObject__7JKRAram[4];
@ -195,57 +85,60 @@ extern "C" u8 sAramObject__7JKRAram[4];
// Declarations:
//
/* ############################################################################################## */
/* 803CC3E8-803CC438 029508 0050+00 2/2 0/0 0/0 .data __vt__14JKRCompArchive */
SECTION_DATA extern void* __vt__14JKRCompArchive[20] = {
(void*)NULL /* RTTI */,
(void*)NULL,
(void*)__dt__14JKRCompArchiveFv,
(void*)unmount__13JKRFileLoaderFv,
(void*)becomeCurrent__10JKRArchiveFPCc,
(void*)getResource__10JKRArchiveFPCc,
(void*)getResource__10JKRArchiveFUlPCc,
(void*)readResource__10JKRArchiveFPvUlPCc,
(void*)readResource__10JKRArchiveFPvUlUlPCc,
(void*)removeResourceAll__14JKRCompArchiveFv,
(void*)removeResource__14JKRCompArchiveFPv,
(void*)detachResource__10JKRArchiveFPv,
(void*)getResSize__10JKRArchiveCFPCv,
(void*)countFile__10JKRArchiveCFPCc,
(void*)getFirstFile__10JKRArchiveCFPCc,
(void*)getExpandedResSize__14JKRCompArchiveCFPCv,
(void*)fetchResource__14JKRCompArchiveFPQ210JKRArchive12SDIFileEntryPUl,
(void*)fetchResource__14JKRCompArchiveFPvUlPQ210JKRArchive12SDIFileEntryPUl,
(void*)setExpandSize__10JKRArchiveFPQ210JKRArchive12SDIFileEntryUl,
(void*)getExpandSize__10JKRArchiveCFPQ210JKRArchive12SDIFileEntry,
};
/* 802D87D4-802D887C 2D3114 00A8+00 0/0 1/1 0/0 .text
* __ct__14JKRCompArchiveFlQ210JKRArchive15EMountDirection */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JKRCompArchive::JKRCompArchive(s32 param_0, JKRArchive::EMountDirection param_1) {
nofralloc
#include "asm/JSystem/JKernel/JKRCompArchive/__ct__14JKRCompArchiveFlQ210JKRArchive15EMountDirection.s"
JKRCompArchive::JKRCompArchive(s32 entryNum, JKRArchive::EMountDirection eMountDirection)
: JKRArchive(entryNum, MOUNT_COMP) {
mMountDirection = eMountDirection;
if (!open(entryNum)) {
return;
}
mVolumeType = 'RARC';
mVolumeName = &mStringTable[mNodes->name_offset];
sVolumeList.prepend(&mFileLoaderLink);
mIsMounted = true;
}
#pragma pop
/* 802D887C-802D89BC 2D31BC 0140+00 1/0 0/0 0/0 .text __dt__14JKRCompArchiveFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JKRCompArchive::~JKRCompArchive() {
nofralloc
#include "asm/JSystem/JKernel/JKRCompArchive/__dt__14JKRCompArchiveFv.s"
JKRCompArchive::~JKRCompArchive() {
if (mArcInfoBlock != NULL) {
SDIFileEntry* file = mFiles;
for (int i = 0; i < mArcInfoBlock->num_file_entries; i++) {
if (!((file->type_flags_and_name_offset >> 0x18) & 0x10) && file->data != NULL) {
JKRFreeToHeap(mHeap, file->data);
}
file++;
}
JKRFreeToHeap(mHeap, mArcInfoBlock);
mArcInfoBlock = NULL;
}
if (field_0x68 != NULL) {
delete field_0x68;
}
if (mExpandedSize != NULL) {
i_JKRFree(mExpandedSize);
mExpandedSize = NULL;
}
if (field_0x70 != NULL) {
delete field_0x70;
}
sVolumeList.remove(&mFileLoaderLink);
mIsMounted = false;
}
#pragma pop
/* 802D89BC-802D8F40 2D32FC 0584+00 1/1 0/0 0/0 .text open__14JKRCompArchiveFl */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JKRCompArchive::open(s32 param_0) {
asm bool JKRCompArchive::open(s32 param_0) {
nofralloc
#include "asm/JSystem/JKernel/JKRCompArchive/open__14JKRCompArchiveFl.s"
}
@ -256,7 +149,7 @@ asm void JKRCompArchive::open(s32 param_0) {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JKRCompArchive::fetchResource(JKRArchive::SDIFileEntry* param_0, u32* param_1) {
asm void* JKRCompArchive::fetchResource(JKRArchive::SDIFileEntry* param_0, u32* param_1) {
nofralloc
#include "asm/JSystem/JKernel/JKRCompArchive/fetchResource__14JKRCompArchiveFPQ210JKRArchive12SDIFileEntryPUl.s"
}
@ -276,33 +169,45 @@ SECTION_DEAD static char const* const stringBase_8039D236 = "illegal archive.";
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JKRCompArchive::fetchResource(void* param_0, u32 param_1,
JKRArchive::SDIFileEntry* param_2, u32* param_3) {
asm void* JKRCompArchive::fetchResource(void* param_0, u32 param_1,
JKRArchive::SDIFileEntry* param_2, u32* param_3) {
nofralloc
#include "asm/JSystem/JKernel/JKRCompArchive/fetchResource__14JKRCompArchiveFPvUlPQ210JKRArchive12SDIFileEntryPUl.s"
}
#pragma pop
/* 802D9260-802D92F4 2D3BA0 0094+00 1/0 0/0 0/0 .text removeResourceAll__14JKRCompArchiveFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JKRCompArchive::removeResourceAll() {
nofralloc
#include "asm/JSystem/JKernel/JKRCompArchive/removeResourceAll__14JKRCompArchiveFv.s"
void JKRCompArchive::removeResourceAll() {
if (mArcInfoBlock != NULL && mMountMode != MOUNT_MEM) {
SDIFileEntry* fileEntry = mFiles;
for (int i = 0; i < mArcInfoBlock->num_file_entries; i++) {
int tmp = fileEntry->type_flags_and_name_offset >> 0x18;
if (fileEntry->data != NULL) {
if (!(tmp & 0x10)) {
JKRFreeToHeap(mHeap, fileEntry->data);
}
fileEntry->data = NULL;
}
}
}
}
#pragma pop
/* 802D92F4-802D9360 2D3C34 006C+00 1/0 0/0 0/0 .text removeResource__14JKRCompArchiveFPv
*/
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JKRCompArchive::removeResource(void* param_0) {
nofralloc
#include "asm/JSystem/JKernel/JKRCompArchive/removeResource__14JKRCompArchiveFPv.s"
bool JKRCompArchive::removeResource(void* resource) {
SDIFileEntry* fileEntry = findPtrResource(resource);
if (!fileEntry)
return false;
if (!((fileEntry->type_flags_and_name_offset >> 0x18) & 0x10)) {
JKRFreeToHeap(mHeap, resource);
}
fileEntry->data = NULL;
return true;
}
#pragma pop
/* ############################################################################################## */
/* 8039D220-8039D220 029880 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */
@ -317,7 +222,7 @@ SECTION_DEAD static char const* const pad_8039D259 = "\0\0\0\0\0\0";
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JKRCompArchive::getExpandedResSize(void const* param_0) const {
asm u32 JKRCompArchive::getExpandedResSize(void const* param_0) const {
nofralloc
#include "asm/JSystem/JKernel/JKRCompArchive/getExpandedResSize__14JKRCompArchiveCFPCv.s"
}

95
libs/JSystem/JKernel/JKRDecomp.cpp
View File

@ -5,10 +5,9 @@
#include "JSystem/JKernel/JKRDecomp.h"
#include "JSystem/JKernel/JKRAramPiece.h"
#include "JSystem/JKernel/JKRHeap.h"
#include "JSystem/JKernel/JKRArchive.h"
#include "JSystem/JKernel/JKRHeap.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Forward References:
@ -80,7 +79,7 @@ JKRDecomp::JKRDecomp(long priority) : JKRThread(0x800, 0x10, priority) {
JKRDecomp::~JKRDecomp() {}
/* 802DB790-802DB858 2D60D0 00C8+00 1/0 0/0 0/0 .text run__9JKRDecompFv */
void* JKRDecomp::run(void) {
void* JKRDecomp::run() {
OSInitMessageQueue(&sMessageQueue, sMessageBuffer, 8);
for (;;) {
OSMessage message;
@ -172,26 +171,23 @@ void JKRDecomp::decode(u8* srcBuffer, u8* dstBuffer, u32 srcLength, u32 dstLengt
}
/* 802DBA58-802DBC14 2D6398 01BC+00 1/1 0/0 0/0 .text decodeSZP__9JKRDecompFPUcPUcUlUl */
// All instructions match. Wrong registers are used.
// 2 extra mr instructions
#ifdef NONMATCHING
void JKRDecomp::decodeSZP(u8* src, u8* dst, u32 srcLength, u32 dstLength) {
u32 decodedSize;
// s32 decodedSize;
s32 srcChunkOffset;
s32 count;
u32 count;
s32 dstOffset;
u32 length;
u32 counter;
u32 srcDataOffset;
u32 linkTableOffset;
s32 linkInfo;
s32 offset;
s32 i;
decodedSize = read_big_endian_u32(src + 4);
linkTableOffset = read_big_endian_u32(src + 8);
srcDataOffset = read_big_endian_u32(src + 12);
s32 decodedSize = read_big_endian_u32(src + 4);
s32 linkTableOffset = read_big_endian_u32(src + 8);
s32 srcDataOffset = read_big_endian_u32(src + 12);
dstOffset = 0;
counter = 0;
u32 counter = 0;
srcChunkOffset = 16;
u32 chunkBits;
@ -204,55 +200,50 @@ void JKRDecomp::decodeSZP(u8* src, u8* dst, u32 srcLength, u32 dstLength) {
do {
if (counter == 0) {
chunkBits = read_big_endian_u32(src + srcChunkOffset);
srcChunkOffset += 4;
counter = 32;
srcChunkOffset += sizeof(u32);
counter = sizeof(u32) * 8;
}
if (chunkBits & 0x80000000) {
if (dstLength == 0) {
dst[dstOffset] = src[srcDataOffset];
length--;
if (length == 0) {
if (length == 0)
return;
}
} else {
dstLength--;
}
dstOffset++;
srcDataOffset++;
} else {
u32 linkInfo = read_big_endian_u16(src + linkTableOffset);
linkTableOffset += 2;
linkInfo = src[linkTableOffset] << 8 | src[linkTableOffset + 1];
linkTableOffset += sizeof(u16);
offset = dstOffset - (linkInfo & 0xFFF);
count = ((s32)linkInfo) >> 12;
count = (linkInfo >> 12);
if (count == 0) {
count = (u32)src[srcDataOffset] + 0x12;
srcDataOffset++;
} else {
} else
count += 2;
}
if (count > decodedSize - dstOffset) {
if ((s32)count > decodedSize - dstOffset)
count = decodedSize - dstOffset;
}
for (i = 0; i < count; i++, dstOffset++, offset++) {
for (i = 0; i < (s32)count; i++, dstOffset++, offset++) {
if (dstLength == 0) {
dst[dstOffset] = dst[offset - 1];
length--;
if (length == 0) {
if (length == 0)
return;
}
} else {
} else
dstLength--;
}
}
}
chunkBits <<= 1;
counter--;
} while ((s32)dstLength < decodedSize);
} while (dstOffset < decodedSize);
}
#else
#pragma push
@ -267,19 +258,20 @@ asm void JKRDecomp::decodeSZP(u8* param_0, u8* param_1, u32 param_2, u32 param_3
/* 802DBC14-802DBCF8 2D6554 00E4+00 1/1 0/0 0/0 .text decodeSZS__9JKRDecompFPUcPUcUlUl */
#ifdef NONMATCHING
void JKRDecomp::decodeSZS(u8* src_buffer, u8* dst_buffer, u32 param_3, u32 param_4) {
int copyByteCount;
void JKRDecomp::decodeSZS(u8* src_buffer, u8* dst_buffer, u32 srcSize, u32 dstSize) {
u8* decompEnd;
u8* copyStart;
int chunkBitsLeft = 0;
int chunkBits;
decompEnd = dst_buffer + *(int*)(src_buffer + 4) - param_4;
if (param_3 == 0) {
s32 copyByteCount;
s32 chunkBitsLeft = 0;
s32 chunkBits;
decompEnd = dst_buffer + *(int*)(src_buffer + 4) - dstSize;
if (srcSize == 0)
return;
}
if (param_4 > *(u32*)src_buffer) {
if (dstSize > *(u32*)src_buffer)
return;
}
u8* curSrcPos = src_buffer + 0x10;
do {
if (chunkBitsLeft == 0) {
@ -288,19 +280,18 @@ void JKRDecomp::decodeSZS(u8* src_buffer, u8* dst_buffer, u32 param_3, u32 param
curSrcPos++;
}
if ((chunkBits & 0x80) != 0) {
if (param_4 == 0) {
if (dstSize == 0) {
*dst_buffer = *curSrcPos;
param_3--;
srcSize--;
dst_buffer++;
if (param_3 == 0) {
if (srcSize == 0)
return;
}
} else {
param_4--;
dstSize--;
}
curSrcPos++;
} else {
int curVal = *curSrcPos;
u8 curVal = *curSrcPos;
// load is inversed
copyStart = dst_buffer - ((curVal & 0xF) << 8 | curSrcPos[1]);
// copyByteCount = ;
@ -313,15 +304,14 @@ void JKRDecomp::decodeSZS(u8* src_buffer, u8* dst_buffer, u32 param_3, u32 param
copyByteCount = (curVal >> 4) + 2;
}
do {
if (param_4 == 0) {
if (dstSize == 0) {
*dst_buffer = *(copyStart - 1);
param_3--;
srcSize--;
dst_buffer++;
if (param_3 == 0) {
if (srcSize == 0)
return;
}
} else {
param_4--;
dstSize--;
}
copyByteCount--;
copyStart++;
@ -348,13 +338,16 @@ JKRCompression JKRDecomp::checkCompressed(u8* src) {
if (src[2] == 'y') {
return COMPRESSION_YAY0;
}
if (src[2] == 'z') {
return COMPRESSION_YAZ0;
}
}
if ((src[0] == 'A') && (src[1] == 'S') && (src[2] == 'R')) {
return COMPRESSION_ASR;
}
return COMPRESSION_NONE;
}

6
libs/JSystem/JKernel/JKRDisposer.cpp
View File

@ -5,12 +5,6 @@
#include "JSystem/JKernel/JKRDisposer.h"
#include "JSystem/JKernel/JKRHeap.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Declarations:
//
/* 802D147C-802D14E4 2CBDBC 0068+00 0/0 12/12 0/0 .text __ct__11JKRDisposerFv */
JKRDisposer::JKRDisposer() : mLink(this) {

45
libs/JSystem/JKernel/JKRDvdAramRipper.cpp
View File

@ -7,10 +7,10 @@
#include "JSystem/JKernel/JKRAram.h"
#include "JSystem/JKernel/JKRAramStream.h"
#include "JSystem/JKernel/JKRDvdFile.h"
// #include "JSystem/JSupport/JSUFileStream.h"
#include "JSystem/JSupport/JSUFileStream.h"
#include "JSystem/JSupport/JSUList.h"
#include "dol2asm.h"
#include "dolphin/os/OSCache.h"
#include "dolphin/types.h"
#include "dolphin/vi/vi.h"
#include "global.h"
@ -23,16 +23,6 @@ struct JSUList__template10 {
/* 802DB62C */ void func_802DB62C(void* _this);
};
struct JSUInputStream {
/* 802DC23C */ ~JSUInputStream();
};
struct JSUFileInputStream {
/* 802DADD8 */ ~JSUFileInputStream();
/* 802DC638 */ JSUFileInputStream(JKRFile*);
int padding[4];
};
struct JKRAramPiece {
/* 802D3838 */ void orderSync(int, u32, u32, u32, JKRAramBlock*);
};
@ -120,14 +110,17 @@ JKRAramBlock* JKRDvdAramRipper::loadToAram(JKRDvdFile* dvdFile, u32 param_1,
JKRADCommand* command =
loadToAram_Async(dvdFile, param_1, param_2, NULL, param_3, param_4, param_5);
syncAram(command, 0);
if (command->field_0x48 < 0) {
delete command;
return NULL;
}
if (param_1) {
delete command;
return (JKRAramBlock*)-1;
}
JKRAramBlock* result = command->mBlock;
delete command;
return result;
@ -147,10 +140,12 @@ JKRADCommand* JKRDvdAramRipper::loadToAram_Async(JKRDvdFile* dvdFile, u32 param_
command->field_0x3c = param_4;
command->field_0x40 = param_5;
command->field_0x44 = param_6;
if (!callCommand_Async(command)) {
delete command;
return NULL;
}
return command;
}
@ -176,6 +171,7 @@ JKRADCommand* JKRDvdAramRipper::callCommand_Async(JKRADCommand* command) {
if (command->field_0x44) {
*command->field_0x44 = 0;
}
if (dvdFile->field_0x50) {
bVar1 = false;
} else {
@ -194,17 +190,21 @@ JKRADCommand* JKRDvdAramRipper::callCommand_Async(JKRADCommand* command) {
if (DVDReadPrio(&dvdFile->mFileInfo, bufPtr, 0x20, 0, 2) >= 0) {
break;
}
if (data_804508D0 == 0) {
delete stream;
return NULL;
}
VIWaitForRetrace();
}
DCInvalidateRange(bufPtr, 0x20);
JKRCompression tmpCompression = JKRDecomp::checkCompressed(bufPtr);
if (tmpCompression == 3) {
tmpCompression = 0;
}
compression = tmpCompression;
uncompressedSize =
bufPtr[4] << 0x18 | bufPtr[5] << 0x10 | bufPtr[6] << 0x08 | bufPtr[7];
@ -212,9 +212,11 @@ JKRADCommand* JKRDvdAramRipper::callCommand_Async(JKRADCommand* command) {
uncompressedSize = command->field_0x40;
}
}
if (compression == 0) {
command->field_0x34 = 0;
}
if (command->field_0x34 == 1) {
if (command->field_0x2c == 0 && command->mBlock == NULL) {
command->mBlock =
@ -224,9 +226,11 @@ JKRADCommand* JKRDvdAramRipper::callCommand_Async(JKRADCommand* command) {
}
dvdFile->mBlock = command->mBlock;
}
if (command->mBlock) {
command->field_0x2c = command->mBlock->mAddress;
}
if (command->field_0x2c == 0) {
dvdFile->field_0x50 = NULL;
return NULL;
@ -235,14 +239,17 @@ JKRADCommand* JKRDvdAramRipper::callCommand_Async(JKRADCommand* command) {
if (command->field_0x2c == 0 && !command->mBlock) {
command->mBlock = JKRAram::getAramHeap()->alloc(fileSize, JKRAramHeap::HEAD);
}
if (command->mBlock) {
command->field_0x2c = command->mBlock->mAddress;
}
if (command->field_0x2c == 0) {
dvdFile->field_0x50 = NULL;
return NULL;
}
}
if (compression == 0) {
command->mStreamCommand = JKRAramStream::write_StreamToAram_Async(
stream, command->field_0x2c, fileSize - command->field_0x3c, command->field_0x3c,
@ -257,12 +264,14 @@ JKRADCommand* JKRDvdAramRipper::callCommand_Async(JKRADCommand* command) {
uncompressedSize, command->field_0x3c, 0,
command->field_0x44);
}
if (!command->field_0x38) {
(*((JSUList<JKRADCommand>*)&sDvdAramAsyncList)).append(&command->mLink);
} else {
command->field_0x38((u32)command);
}
}
OSUnlockMutex(&dvdFile->mMutex2);
return bVar1 == true ? command : NULL;
}
@ -281,7 +290,8 @@ asm JKRADCommand* JKRDvdAramRipper::callCommand_Async(JKRADCommand* command) {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JSUFileInputStream::~JSUFileInputStream() {
// asm JSUFileInputStream::~JSUFileInputStream() {
extern "C" asm void __dt__18JSUFileInputStreamFv() {
nofralloc
#include "asm/JSystem/JKernel/JKRDvdAramRipper/__dt__18JSUFileInputStreamFv.s"
}
@ -289,22 +299,27 @@ asm JSUFileInputStream::~JSUFileInputStream() {
/* 802DAE48-802DAF1C 2D5788 00D4+00 1/1 0/0 0/0 .text
* syncAram__16JKRDvdAramRipperFP12JKRADCommandi */
// should match when other functions using sDvdAramAsyncList are decompiled
#ifdef NONMATCHING
bool JKRDvdAramRipper::syncAram(JKRADCommand* command, int param_1) {
JKRDvdFile* dvdFile = command->mDvdFile;
OSLockMutex(&dvdFile->mMutex2);
if (command->mStreamCommand) {
JKRAramStreamCommand* var1 = JKRAramStream::sync(command->mStreamCommand, param_1);
command->field_0x48 = -(var1 == NULL);
if (param_1 != 0 && var1 == NULL) {
OSUnlockMutex(&dvdFile->mMutex2);
return false;
}
}
(*((JSUList<JKRADCommand>*)&sDvdAramAsyncList)).remove(&command->mLink);
if (command->mStreamCommand) {
delete command->mStreamCommand;
}
delete dvdFile->mFileStream;
dvdFile->field_0x50 = NULL;
OSUnlockMutex(&dvdFile->mMutex2);
@ -405,6 +420,7 @@ int JKRDecompressFromDVDToAram(JKRDvdFile* dvdFile, u32 param_1, u32 fileSize, u
OSInitMutex(&decompMutex);
data_804514A4 = true;
}
OSRestoreInterrupts(level);
OSLockMutex(&decompMutex);
u32 bufferSize = JKRDvdAramRipper::sSZSBufferSize;
@ -478,8 +494,7 @@ static asm int dmaBufferFlush(u32 param_0) {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void __sinit_JKRDvdAramRipper_cpp() {
nofralloc
asm void __sinit_JKRDvdAramRipper_cpp(){nofralloc
#include "asm/JSystem/JKernel/JKRDvdAramRipper/__sinit_JKRDvdAramRipper_cpp.s"
}
#pragma pop

19
libs/JSystem/JKernel/JKRDvdArchive.cpp
View File

@ -11,6 +11,7 @@
#include "MSL_C/math.h"
#include "MSL_C/string.h"
#include "dol2asm.h"
#include "dolphin/os/OS.h"
#include "global.h"
//
@ -74,11 +75,6 @@ extern "C" void _restgpr_29();
extern "C" u8 sVolumeList__13JKRFileLoader[12];
extern "C" u8 sSystemHeap__7JKRHeap[4];
extern "C" {
void DCInvalidateRange(void*, u32);
void DCStoreRange(void*, u32);
}
//
// Declarations:
//
@ -226,6 +222,7 @@ void* JKRDvdArchive::fetchResource(SDIFileEntry* fileEntry, u32* returnSize) {
if (resourceSize == 0) {
return NULL;
}
fileEntry->data = resourcePtr;
if (fileCompression == COMPRESSION_YAZ0) {
setExpandSize(fileEntry, *returnSize);
@ -346,12 +343,11 @@ u32 JKRDvdArchive::fetchResource_subroutine(s32 entryNum, u32 offset, u32 size,
}
case COMPRESSION_YAY0: {
JUTException::panic_f("JKRDvdArchive.cpp", 0x289, "%s",
"Sorry, not applied for SZP archive.\n");
JUTException::panic_f(__FILE__, 649, "%s", "Sorry, not applied for SZP archive.\n");
}
default: {
JUTException::panic_f("JKRDvdArchive.cpp", 0x28d, "%s", "??? bad sequence\n");
JUTException::panic_f(__FILE__, 653, "%s", "??? bad sequence\n");
return 0;
}
}
@ -414,12 +410,11 @@ u32 JKRDvdArchive::fetchResource_subroutine(s32 entryNum, u32 offset, u32 size,
}
case COMPRESSION_YAY0: {
JUTException::panic_f("JKRDvdArchive.cpp", 0x2f2, "%s",
"Sorry, not applied SZP archive.\n");
JUTException::panic_f(__FILE__, 754, "%s", "Sorry, not applied SZP archive.\n");
}
default: {
JUTException::panic_f("JKRDvdArchive.cpp", 0x2f6, "%s", "??? bad sequence\n");
JUTException::panic_f(__FILE__, 758, "%s", "??? bad sequence\n");
return 0;
}
}
@ -461,5 +456,3 @@ u32 JKRDvdArchive::getExpandedResSize(const void* resource) const {
return resourceSize;
}
/* 8039D1B0-8039D1B0 029810 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */

10
libs/JSystem/JKernel/JKRDvdFile.cpp
View File

@ -9,10 +9,6 @@
#include "dol2asm.h"
#include "global.h"
//
// Declarations:
//
/* 8043436C-80434378 06108C 000C+00 4/4 0/0 0/0 .bss sDvdList__10JKRDvdFile */
JSUList<JKRDvdFile> JKRDvdFile::sDvdList;
@ -94,7 +90,7 @@ void JKRDvdFile::close() {
mIsAvailable = false;
getDvdList().remove(&mDvdLink);
} else {
JUTException::panic_f("JKRDvdFile.cpp", 0xd5, "%s", "cannot close DVD file\n");
JUTException::panic_f(__FILE__, 213, "%s", "cannot close DVD file\n");
}
}
}
@ -105,7 +101,7 @@ s32 JKRDvdFile::readData(void* param_1, long length, long param_3) {
// The assert condition gets stringified as "( length & 0x1f ) == 0",
// with out disabling clang-format the spaces in the condition will
// get removed and the string will be incorrect.
JUT_ASSERT("JKRDvdFile.cpp", 0xee, ( length & 0x1f ) == 0);
JUT_ASSERT(__FILE__, 238, ( length & 0x1f ) == 0);
/* clang-format on */
OSLockMutex(&mMutex1);
@ -155,5 +151,3 @@ void JKRDvdFile::doneProcess(long id, DVDFileInfo* fileInfo) {
s32 JKRDvdFile::getFileSize(void) const {
return mFileInfo.length;
}
/* 8039D260-8039D260 0298C0 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */

54
libs/JSystem/JKernel/JKRDvdRipper.cpp
View File

@ -9,7 +9,6 @@
#include "MSL_C/MSL_Common/Src/string.h"
#include "dol2asm.h"
#include "dolphin/os/OSCache.h"
#include "dolphin/types.h"
#include "global.h"
//
@ -107,7 +106,7 @@ void* JKRDvdRipper::loadToMainRAM(s32 entryNumber, u8* dst, JKRExpandSwitch expa
/* 8039D290-8039D290 0298F0 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */
#pragma push
#pragma force_active on
SECTION_DEAD static char const* const stringBase_8039D290 = "JKRDvdRipper.cpp";
SECTION_DEAD static char const* const stringBase_8039D290 = __FILE__;
SECTION_DEAD static char const* const stringBase_8039D2A1 = "%s";
SECTION_DEAD static char const* const stringBase_8039D2A4 = "Sorry, not applied for SZP archive.";
SECTION_DEAD static char const* const stringBase_8039D2C8 = "Not support SZP with offset read";
@ -151,21 +150,26 @@ void* JKRDvdRipper::loadToMainRAM(JKRDvdFile* dvdFile, u8* dst, JKRExpandSwitch
}
r26 = (bufPtr[4] << 0x18) | (bufPtr[5] << 0x10) | (bufPtr[6] << 0x08) | (bufPtr[7]);
}
if (pCompression) {
*pCompression = compression;
}
if (expandSwitch == EXPAND_SWITCH_UNKNOWN1 && compression) {
if (dstLength != 0 && r26 > dstLength) {
r26 = dstLength;
}
if (!dst) {
dst = (u8*)JKRHeap::alloc(r26, allocDirection == ALLOC_DIRECTION_FORWARD ? 0x20 : -0x20,
heap);
did_alloc = true;
}
if (!dst) {
return NULL;
}
if (compression == 1) {
mem = (u8*)JKRHeap::alloc(fileSizeAligned, 0x20, heap);
if (mem == NULL && did_alloc == true) {
@ -183,10 +187,12 @@ void* JKRDvdRipper::loadToMainRAM(JKRDvdFile* dvdFile, u8* dst, JKRExpandSwitch
var2, allocDirection == ALLOC_DIRECTION_FORWARD ? 0x20 : -0x20, heap);
did_alloc = true;
}
if (!dst) {
return NULL;
}
}
if (compression == 0) {
int count = 0;
if (offset != 0) {
@ -197,31 +203,38 @@ void* JKRDvdRipper::loadToMainRAM(JKRDvdFile* dvdFile, u8* dst, JKRExpandSwitch
if (count >= 0) {
break;
}
if (count == -3 || !data_804508C8) {
if (did_alloc == true) {
JKRHeap::free(dst, NULL);
}
return NULL;
}
VIWaitForRetrace();
}
DCInvalidateRange(bufPtr, 0x20);
count = JKRDecomp::checkCompressed(bufPtr);
if (count == 3) {
count = 0;
}
}
if (count == 0 || expandSwitch == EXPAND_SWITCH_UNKNOWN2 ||
expandSwitch == EXPAND_SWITCH_UNKNOWN0) {
expandSwitch == EXPAND_SWITCH_UNKNOWN0)
{
fileSizeAligned -= offset;
if (dstLength != 0 && dstLength < fileSizeAligned) {
fileSizeAligned = dstLength;
}
while (true) {
count = DVDReadPrio(dvdFile->getFileInfo(), dst, fileSizeAligned, offset, 2);
if (count >= 0) {
break;
}
if (count == -3 || !data_804508C8) {
if (did_alloc == true) {
JKRHeap::free(dst, NULL);
@ -230,6 +243,7 @@ void* JKRDvdRipper::loadToMainRAM(JKRDvdFile* dvdFile, u8* dst, JKRExpandSwitch
}
VIWaitForRetrace();
}
if (param_8) {
*param_8 = fileSizeAligned;
}
@ -237,24 +251,25 @@ void* JKRDvdRipper::loadToMainRAM(JKRDvdFile* dvdFile, u8* dst, JKRExpandSwitch
} else if (count == 2) {
JKRDecompressFromDVD(dvdFile, dst, fileSizeAligned, dstLength, 0, offset, param_8);
} else {
JUTException::panic_f("JKRDvdRipper.cpp", 0x143, "%s",
"Sorry, not applied for SZP archive.");
JUTException::panic_f(__FILE__, 0x143, "%s", "Sorry, not applied for SZP archive.");
}
return dst;
} else if (compression == 1) {
if (offset) {
JUTException::panic_f("JKRDvdRipper.cpp", 0x14d, "%s",
"Not support SZP with offset read");
JUTException::panic_f(__FILE__, 0x14d, "%s", "Not support SZP with offset read");
}
while (true) {
int count = DVDReadPrio(dvdFile->getFileInfo(), mem, fileSizeAligned, 0, 2);
if (count >= 0) {
break;
}
if (count == -3 || !data_804508C8) {
if (did_alloc == true) {
JKRHeap::free(dst, NULL);
}
JKRHeap::free(mem, NULL);
return NULL;
}
@ -356,6 +371,7 @@ static u32 tsArea;
/* 802DA1E4-802DA35C 2D4B24 0178+00 1/1 0/0 0/0 .text
* JKRDecompressFromDVD__FP10JKRDvdFilePvUlUlUlUlPUl */
// wrong reg at the end
#ifdef NONMATCHING
static int JKRDecompressFromDVD(JKRDvdFile* dvdFile, void* dst, u32 fileSize, u32 param_3,
u32 param_4, u32 param_5, u32* param_6) {
@ -364,11 +380,13 @@ static int JKRDecompressFromDVD(JKRDvdFile* dvdFile, void* dst, u32 fileSize, u3
OSInitMutex(&decompMutex);
data_80451458 = true;
}
OSRestoreInterrupts(level);
OSLockMutex(&decompMutex);
u32 bufferSize = JKRDvdRipper::sSZSBufferSize;
szpBuf = (u8*)JKRHeap::sSystemHeap->alloc(bufferSize, -0x20);
szpEnd = szpBuf + bufferSize;
if (param_4) {
refBuf = (u8*)JKRHeap::sSystemHeap->alloc(0x1120, -4);
refEnd = refBuf + 0x1120;
@ -376,24 +394,29 @@ static int JKRDecompressFromDVD(JKRDvdFile* dvdFile, void* dst, u32 fileSize, u3
} else {
refBuf = NULL;
}
srcFile = dvdFile;
srcOffset = param_5;
transLeft = fileSize - param_5;
fileOffset = param_4;
readCount = 0;
maxDest = param_3;
if (!param_6) {
tsPtr = &tsArea;
} else {
tsPtr = param_6;
}
*tsPtr = 0;
u8* first = firstSrcData();
int result = first ? decompSZS_subroutine(first, (u8*)dst) : -1;
JKRHeap::free(szpBuf, 0);
i_JKRFree(szpBuf);
if (refBuf) {
JKRHeap::free(refBuf, 0);
i_JKRFree(refBuf);
}
DCStoreRangeNoSync(dst, *tsPtr);
OSUnlockMutex(&decompMutex);
return result;
@ -542,16 +565,19 @@ static u8* firstSrcData() {
u8* buffer = szpBuf;
u32 bufSize = szpEnd - buffer;
u32 length = transLeft < bufSize ? transLeft : bufSize;
while (true) {
int result = DVDReadPrio(srcFile->getFileInfo(), buffer, length, srcOffset, 2);
if (result >= 0) {
break;
}
if (result == -3 || !data_804508C8) {
return NULL;
}
VIWaitForRetrace();
}
DCInvalidateRange(buffer, length);
srcOffset += length;
transLeft -= length;
@ -566,9 +592,11 @@ static u8* nextSrcData(u8* param_0) {
memcpy(dest, param_0, size);
u8* end = dest + size;
u32 transSize = szpEnd - end;
if (transSize > transLeft) {
transSize = transLeft;
}
while (true) {
s32 result = DVDReadPrio(srcFile->getFileInfo(), end, transSize, srcOffset, 2);
if (result >= 0) {
@ -580,12 +608,15 @@ static u8* nextSrcData(u8* param_0) {
}
VIWaitForRetrace();
}
DCInvalidateRange(end, transSize);
srcOffset += transSize;
transLeft -= transSize;
if (transLeft == 0) {
srcLimit = end + transSize;
}
return dest;
}
#else
@ -608,8 +639,7 @@ u8 JKRDvdRipper::isErrorRetry() {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void __sinit_JKRDvdRipper_cpp() {
nofralloc
asm void __sinit_JKRDvdRipper_cpp(){nofralloc
#include "asm/JSystem/JKernel/JKRDvdRipper/__sinit_JKRDvdRipper_cpp.s"
}
#pragma pop
@ -629,5 +659,3 @@ extern "C" asm void func_802DA820(void* _this) {
#include "asm/JSystem/JKernel/JKRDvdRipper/func_802DA820.s"
}
#pragma pop
/* 8039D290-8039D290 0298F0 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */

491
libs/JSystem/JKernel/JKRExpHeap.cpp
View File

@ -4,9 +4,9 @@
//
#include "JSystem/JKernel/JKRExpHeap.h"
#include "JSystem/JSupport/JSupport.h"
#include "JSystem/JUtility/JUTException.h"
#include "dol2asm.h"
#include "dolphin/types.h"
#include "global.h"
//
@ -114,7 +114,6 @@ JKRExpHeap* JKRExpHeap::createRoot(int maxHeaps, bool errorFlag) {
/* 802CEE2C-802CEF00 2C976C 00D4+00 0/0 19/19 1/1 .text create__10JKRExpHeapFUlP7JKRHeapb
*/
#ifdef NONMATCHING
JKRExpHeap* JKRExpHeap::create(u32 size, JKRHeap* parent, bool errorFlag) {
if (!parent) {
parent = sRootHeap;
@ -129,30 +128,23 @@ JKRExpHeap* JKRExpHeap::create(u32 size, JKRHeap* parent, bool errorFlag) {
if (alignedSize < 0xa0)
return NULL;
void* memory = alloc(alignedSize, 0x10, parent);
void* dataPtr = (u8*)memory + expHeapSize;
u8* memory = (u8*)JKRAllocFromHeap(parent, alignedSize, 0x10);
u8* dataPtr = (memory + expHeapSize);
if (!memory) {
return NULL;
}
JKRExpHeap* newHeap =
new (memory) JKRExpHeap(dataPtr, alignedSize - expHeapSize, parent, errorFlag);
if (newHeap == NULL) {
free(memory, NULL);
i_JKRFree(memory);
return NULL;
};
}
newHeap->field_0x6e = false;
return newHeap;
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JKRExpHeap* JKRExpHeap::create(u32 param_0, JKRHeap* param_1, bool param_2) {
nofralloc
#include "asm/JSystem/JKernel/JKRExpHeap/create__10JKRExpHeapFUlP7JKRHeapb.s"
}
#pragma pop
#endif
/* 802CEF00-802CEFAC 2C9840 00AC+00 0/0 1/1 0/0 .text create__10JKRExpHeapFPvUlP7JKRHeapb
*/
@ -165,15 +157,18 @@ JKRExpHeap* JKRExpHeap::create(void* ptr, u32 size, JKRHeap* parent, bool errorF
} else {
parent2 = parent;
}
JKRExpHeap* newHeap = NULL;
u32 expHeapSize = ALIGN_NEXT(sizeof(JKRExpHeap), 0x10);
if (size < expHeapSize)
return NULL;
void* dataPtr = (u8*)ptr + expHeapSize;
u32 alignedSize = ALIGN_PREV((u32)ptr + size - (u32)dataPtr, 0x10);
if (ptr) {
newHeap = new (ptr) JKRExpHeap(dataPtr, alignedSize, parent2, errorFlag);
}
newHeap->field_0x6e = true;
newHeap->field_0x70 = ptr;
newHeap->field_0x74 = size;
@ -193,35 +188,6 @@ void JKRExpHeap::do_destroy() {
}
}
/* ############################################################################################## */
/* 803CBFD0-803CC030 0290F0 0060+00 2/2 0/0 0/0 .data __vt__10JKRExpHeap */
SECTION_DATA extern void* __vt__10JKRExpHeap[24] = {
(void*)NULL /* RTTI */,
(void*)NULL,
(void*)__dt__10JKRExpHeapFv,
(void*)callAllDisposer__7JKRHeapFv,
(void*)getHeapType__10JKRExpHeapFv,
(void*)check__10JKRExpHeapFv,
(void*)dump_sort__10JKRExpHeapFv,
(void*)dump__10JKRExpHeapFv,
(void*)do_destroy__10JKRExpHeapFv,
(void*)do_alloc__10JKRExpHeapFUli,
(void*)do_free__10JKRExpHeapFPv,
(void*)do_freeAll__10JKRExpHeapFv,
(void*)do_freeTail__10JKRExpHeapFv,
(void*)do_fillFreeArea__10JKRExpHeapFv,
(void*)do_resize__10JKRExpHeapFPvUl,
(void*)do_getSize__10JKRExpHeapFPv,
(void*)do_getFreeSize__10JKRExpHeapFv,
(void*)do_getMaxFreeBlock__10JKRExpHeapFv,
(void*)do_getTotalFreeSize__10JKRExpHeapFv,
(void*)do_changeGroupID__10JKRExpHeapFUc,
(void*)do_getCurrentGroupId__10JKRExpHeapFv,
(void*)state_register__10JKRExpHeapCFPQ27JKRHeap6TStateUl,
(void*)state_compare__10JKRExpHeapCFRCQ27JKRHeap6TStateRCQ27JKRHeap6TState,
(void*)state_dump__7JKRHeapCFRCQ27JKRHeap6TState,
};
/* 802CF030-802CF0C0 2C9970 0090+00 3/3 0/0 0/0 .text __ct__10JKRExpHeapFPvUlP7JKRHeapb
*/
JKRExpHeap::JKRExpHeap(void* data, u32 size, JKRHeap* parent, bool errorFlag)
@ -248,6 +214,7 @@ void* JKRExpHeap::do_alloc(u32 size, int alignment) {
if (size < 4) {
size = 4;
}
if (alignment >= 0) {
if (alignment <= 4) {
ptr = allocFromHead(size);
@ -261,6 +228,7 @@ void* JKRExpHeap::do_alloc(u32 size, int alignment) {
ptr = allocFromTail(size, -alignment);
}
}
if (ptr == NULL) {
JUTWarningConsole_f(":::cannot alloc memory (0x%x byte).\n", size);
if (mErrorFlag == true) {
@ -289,68 +257,82 @@ static JKRExpHeap::CMemBlock* DBnewFreeBlock;
static JKRExpHeap::CMemBlock* DBnewUsedBlock;
/* 802CF234-802CF490 2C9B74 025C+00 1/1 0/0 0/0 .text allocFromHead__10JKRExpHeapFUli */
// wrong register at end
#ifdef NONMATCHING
void* JKRExpHeap::allocFromHead(u32 size, int align) {
size = ALIGN_NEXT(size, 4);
s32 foundSize = -1;
u32 foundOffset = 0;
CMemBlock* foundBlock = NULL;
u32 foundOffset;
int foundSize;
CMemBlock* newFreeBlock;
CMemBlock* newUsedBlock;
CMemBlock* foundBlock;
for (CMemBlock* block = mHeadFreeList; block; block = block->getNextBlock()) {
u32 start = (u32)(block->getContent());
u32 offset = ALIGN_PREV(align - 1 + start, align) - start;
if (block->getSize() < size + offset) {
size = ALIGN_NEXT(size, 4);
foundSize = -1;
foundOffset = 0;
foundBlock = NULL;
for (CMemBlock* block = mHeadFreeList; block; block = block->mNext) {
u32 offset =
ALIGN_PREV(align - 1 + (u32)block->getContent(), align) - (u32)block->getContent();
if (block->size < size + offset) {
continue;
}
if (foundSize <= block->getSize()) {
if (foundSize <= (u32)block->size) {
continue;
}
foundSize = block->getSize();
foundSize = block->size;
foundBlock = block;
foundOffset = offset;
if (mAllocMode != 0) {
break;
}
u32 blockSize = block->getSize();
u32 blockSize = block->size;
if (blockSize == size) {
break;
}
}
DBfoundSize = foundSize;
DBfoundOffset = foundOffset;
DBfoundBlock = foundBlock;
if (foundBlock) {
if (foundOffset >= sizeof(CMemBlock)) {
CMemBlock* prev = foundBlock->getPrevBlock();
CMemBlock* next = foundBlock->getNextBlock();
CMemBlock* newUsedBlock =
foundBlock->allocFore(foundOffset - sizeof(CMemBlock), 0, 0, 0, 0);
CMemBlock* newFreeBlock;
CMemBlock* prev = foundBlock->mPrev;
CMemBlock* next = foundBlock->mNext;
newUsedBlock = foundBlock->allocFore(foundOffset - sizeof(CMemBlock), 0, 0, 0, 0);
if (newUsedBlock) {
newFreeBlock = newUsedBlock->allocFore(size, mCurrentGroupId, 0, 0, 0);
} else {
newFreeBlock = NULL;
}
if (newFreeBlock) {
setFreeBlock(foundBlock, prev, newFreeBlock);
} else {
setFreeBlock(foundBlock, prev, next);
}
if (newFreeBlock) {
setFreeBlock(newFreeBlock, foundBlock, next);
}
appendUsedList(newUsedBlock);
DBnewFreeBlock = newFreeBlock;
DBnewUsedBlock = newUsedBlock;
return newUsedBlock->getContent();
} else {
if (foundOffset != 0) {
CMemBlock* prev = foundBlock->getPrevBlock();
CMemBlock* next = foundBlock->getNextBlock();
CMemBlock* prev = foundBlock->mPrev;
CMemBlock* next = foundBlock->mNext;
removeFreeBlock(foundBlock);
CMemBlock* newUsedBlock = (CMemBlock*)((u32)foundBlock + foundOffset);
newUsedBlock->size = foundBlock->getSize() - foundOffset;
CMemBlock* newFreeBlock =
newUsedBlock = (CMemBlock*)((u32)foundBlock + foundOffset);
newUsedBlock->size = foundBlock->size - foundOffset;
newFreeBlock =
newUsedBlock->allocFore(size, mCurrentGroupId, (u8)foundOffset, 0, 0);
if (newFreeBlock) {
setFreeBlock(newFreeBlock, prev, next);
@ -358,9 +340,9 @@ void* JKRExpHeap::allocFromHead(u32 size, int align) {
appendUsedList(newUsedBlock);
return newUsedBlock->getContent();
} else {
CMemBlock* prev = foundBlock->getPrevBlock();
CMemBlock* next = foundBlock->getNextBlock();
CMemBlock* newFreeBlock = foundBlock->allocFore(size, mCurrentGroupId, 0, 0, 0);
CMemBlock* prev = foundBlock->mPrev;
CMemBlock* next = foundBlock->mNext;
newFreeBlock = foundBlock->allocFore(size, mCurrentGroupId, 0, 0, 0);
removeFreeBlock(foundBlock);
if (newFreeBlock) {
setFreeBlock(newFreeBlock, prev, next);
@ -370,6 +352,7 @@ void* JKRExpHeap::allocFromHead(u32 size, int align) {
}
}
}
return NULL;
}
#else
@ -392,18 +375,22 @@ void* JKRExpHeap::allocFromHead(u32 size) {
if (block->getSize() < size) {
continue;
}
if (foundSize <= block->getSize()) {
continue;
}
foundSize = block->getSize();
foundBlock = block;
if (mAllocMode != 0) {
break;
}
if (foundSize == size) {
break;
}
}
if (foundBlock) {
CMemBlock* newblock = foundBlock->allocFore(size, mCurrentGroupId, 0, 0, 0);
if (newblock) {
@ -418,25 +405,24 @@ void* JKRExpHeap::allocFromHead(u32 size) {
}
/* 802CF574-802CF6D4 2C9EB4 0160+00 1/1 0/0 0/0 .text allocFromTail__10JKRExpHeapFUli */
#ifdef NONMATCHING
void* JKRExpHeap::allocFromTail(u32 size, int align) {
u32 offset = 0;
CMemBlock* foundBlock = NULL;
CMemBlock* newBlock = NULL;
u32 end;
u32 start;
u32 usedSize;
for (CMemBlock* block = mTailFreeList; block; block = block->getPrevBlock()) {
end = (u32)block->getContent() + block->getSize();
start = ALIGN_PREV(end - size, align);
usedSize = end - start;
if (block->getSize() >= usedSize) {
u32 start;
for (CMemBlock* block = mTailFreeList; block; block = block->mPrev) {
start = ALIGN_PREV((u32)block->getContent() + block->size - size, align);
usedSize = (u32)block->getContent() + block->size - start;
if (block->size >= usedSize) {
foundBlock = block;
offset = block->getSize() - usedSize;
offset = block->size - usedSize;
newBlock = (CMemBlock*)start - 1;
break;
}
}
if (foundBlock != NULL) {
if (offset >= sizeof(CMemBlock)) {
newBlock->initiate(NULL, NULL, usedSize, mCurrentGroupId, -0x80);
@ -457,18 +443,9 @@ void* JKRExpHeap::allocFromTail(u32 size, int align) {
}
}
}
return NULL;
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void* JKRExpHeap::allocFromTail(u32 param_0, int param_1) {
nofralloc
#include "asm/JSystem/JKernel/JKRExpHeap/allocFromTail__10JKRExpHeapFUli.s"
}
#pragma pop
#endif
/* 802CF6D4-802CF7AC 2CA014 00D8+00 1/1 0/0 0/0 .text allocFromTail__10JKRExpHeapFUl */
void* JKRExpHeap::allocFromTail(u32 size) {
@ -480,6 +457,7 @@ void* JKRExpHeap::allocFromTail(u32 size) {
break;
}
}
if (foundBlock != NULL) {
CMemBlock* usedBlock = foundBlock->allocBack(size2, 0, 0, mCurrentGroupId, 0);
CMemBlock* freeBlock;
@ -490,6 +468,7 @@ void* JKRExpHeap::allocFromTail(u32 size) {
usedBlock = foundBlock;
freeBlock = NULL;
}
if (freeBlock) {
setFreeBlock(freeBlock, foundBlock->getPrevBlock(), foundBlock->getNextBlock());
}
@ -524,37 +503,23 @@ void JKRExpHeap::do_freeAll() {
}
/* 802CF89C-802CF924 2CA1DC 0088+00 1/0 0/0 0/0 .text do_freeTail__10JKRExpHeapFv */
#ifdef NONMATCHING
void JKRExpHeap::do_freeTail() {
lock();
CMemBlock* block = mHeadUsedList;
while (block) {
if (block->_isTempMemBlock()) {
dispose(block->getContent(), block->getSize());
CMemBlock* next = block->getNextBlock();
for (CMemBlock* block = mHeadUsedList; block != NULL;) {
if ((block->mFlags & 0x80) != 0) {
dispose(block + 1, block->size);
CMemBlock* temp = block->mNext;
block->free(this);
block = next;
block = temp;
} else {
block = block->getNextBlock();
block = block->mNext;
}
}
unlock();
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JKRExpHeap::do_freeTail() {
nofralloc
#include "asm/JSystem/JKernel/JKRExpHeap/do_freeTail__10JKRExpHeapFv.s"
}
#pragma pop
#endif
/* 802CF924-802CF928 2CA264 0004+00 1/0 0/0 0/0 .text do_fillFreeArea__10JKRExpHeapFv */
void JKRExpHeap::do_fillFreeArea() {
/* empty function */
}
void JKRExpHeap::do_fillFreeArea() {}
/* 802CF928-802CF978 2CA268 0050+00 1/0 0/0 0/0 .text do_changeGroupID__10JKRExpHeapFUc
*/
@ -567,67 +532,59 @@ s32 JKRExpHeap::do_changeGroupID(u8 param_0) {
}
/* 802CF978-802CFB24 2CA2B8 01AC+00 1/0 0/0 0/0 .text do_resize__10JKRExpHeapFPvUl */
#ifdef NONMATCHING
s32 JKRExpHeap::do_resize(void* ptr, u32 size) {
lock();
CMemBlock* block = CMemBlock::getHeapBlock(ptr);
if (block == NULL || ptr < getStartAddr() || getEndAddr() < ptr) {
if (block == NULL || ptr < mStart || mEnd < ptr) {
unlock();
return -1;
}
u32 newSize = ALIGN_NEXT(size, 4);
if (newSize == block->getSize()) {
size = ALIGN_NEXT(size, 4);
if (size == block->size) {
unlock();
return newSize;
return size;
}
if (newSize > block->getSize()) {
if (size > block->size) {
CMemBlock* foundBlock = NULL;
for (CMemBlock* freeBlock = mHeadFreeList; freeBlock;
freeBlock = freeBlock->getNextBlock()) {
if (freeBlock == (CMemBlock*)((u32)block->getContent() + block->getSize())) {
for (CMemBlock* freeBlock = mHeadFreeList; freeBlock; freeBlock = freeBlock->mNext) {
if (freeBlock == (CMemBlock*)((u32)(block + 1) + block->size)) {
foundBlock = freeBlock;
break;
}
}
if (foundBlock == NULL) {
unlock();
return -1;
}
if (newSize > block->getSize() + sizeof(CMemBlock) + foundBlock->getSize()) {
if (size > block->size + sizeof(CMemBlock) + foundBlock->size) {
unlock();
return -1;
}
removeFreeBlock(foundBlock);
block->size += foundBlock->getSize() + sizeof(CMemBlock);
if (block->getSize() - newSize > sizeof(CMemBlock)) {
CMemBlock* newBlock =
block->allocFore(newSize, block->getGroupId(), block->mFlags, 0, 0);
block->size += foundBlock->size + sizeof(CMemBlock);
if (block->size - size > sizeof(CMemBlock)) {
CMemBlock* newBlock = block->allocFore(size, block->mGroupId, block->mFlags, 0, 0);
if (newBlock) {
recycleFreeBlock(newBlock);
}
}
} else {
if (block->getSize() - newSize > 0x10) {
CMemBlock* freeBlock =
block->allocFore(newSize, block->getGroupId(), block->mFlags, 0, 0);
if (block->size - size > sizeof(CMemBlock)) {
CMemBlock* freeBlock = block->allocFore(size, block->mGroupId, block->mFlags, 0, 0);
if (freeBlock) {
recycleFreeBlock(freeBlock);
}
}
}
unlock();
return block->getSize();
return block->size;
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm s32 JKRExpHeap::do_resize(void* param_0, u32 param_1) {
nofralloc
#include "asm/JSystem/JKernel/JKRExpHeap/do_resize__10JKRExpHeapFPvUl.s"
}
#pragma pop
#endif
/* 802CFB24-802CFBA4 2CA464 0080+00 1/0 0/0 0/0 .text do_getSize__10JKRExpHeapFPv */
s32 JKRExpHeap::do_getSize(void* ptr) {
@ -687,12 +644,14 @@ s32 JKRExpHeap::getUsedSize(u8 groupId) const {
JKRExpHeap* this2 = const_cast<JKRExpHeap*>(this);
this2->lock();
u32 size = 0;
for (CMemBlock* block = mHeadUsedList; block; block = block->getNextBlock()) {
u8 blockGroupId = block->getGroupId();
if (blockGroupId == groupId) {
size += block->getSize() + sizeof(CMemBlock);
}
}
this2->unlock();
return size;
}
@ -703,9 +662,11 @@ s32 JKRExpHeap::getTotalUsedSize() const {
JKRExpHeap* this2 = const_cast<JKRExpHeap*>(this);
this2->lock();
u32 size = 0;
for (CMemBlock* block = mHeadUsedList; block; block = block->getNextBlock()) {
size += block->getSize() + sizeof(CMemBlock);
}
this2->unlock();
return size;
}
@ -714,16 +675,19 @@ s32 JKRExpHeap::getTotalUsedSize() const {
* appendUsedList__10JKRExpHeapFPQ210JKRExpHeap9CMemBlock */
void JKRExpHeap::appendUsedList(JKRExpHeap::CMemBlock* newblock) {
if (!newblock) {
JUTException::panic_f("JKRExpHeap.cpp", 0x620, "%s", "bad appendUsedList\n");
JUTException::panic_f(__FILE__, 1568, "%s", "bad appendUsedList\n");
}
CMemBlock* block = mTailUsedList;
newblock->mMagic = 'HM';
if (block) {
block->mNext = newblock;
newblock->mPrev = block;
} else {
newblock->mPrev = NULL;
}
mTailUsedList = newblock;
if (!mHeadUsedList) {
mHeadUsedList = newblock;
@ -742,6 +706,7 @@ void JKRExpHeap::setFreeBlock(CMemBlock* block, CMemBlock* prev, CMemBlock* next
prev->mNext = block;
block->mPrev = prev;
}
if (next == NULL) {
mTailFreeList = block;
block->mNext = NULL;
@ -749,6 +714,7 @@ void JKRExpHeap::setFreeBlock(CMemBlock* block, CMemBlock* prev, CMemBlock* next
next->mPrev = block;
block->mNext = next;
}
block->mMagic = 0;
}
@ -757,11 +723,13 @@ void JKRExpHeap::setFreeBlock(CMemBlock* block, CMemBlock* prev, CMemBlock* next
void JKRExpHeap::removeFreeBlock(CMemBlock* block) {
CMemBlock* prev = block->mPrev;
CMemBlock* next = block->mNext;
if (prev == NULL) {
mHeadFreeList = next;
} else {
prev->mNext = next;
}
if (next == NULL) {
mTailFreeList = prev;
} else {
@ -774,11 +742,13 @@ void JKRExpHeap::removeFreeBlock(CMemBlock* block) {
void JKRExpHeap::removeUsedBlock(JKRExpHeap::CMemBlock* block) {
CMemBlock* prev = block->mPrev;
CMemBlock* next = block->mNext;
if (prev == NULL) {
mHeadUsedList = next;
} else {
prev->mNext = next;
}
if (next == NULL) {
mTailUsedList = prev;
} else {
@ -788,143 +758,99 @@ void JKRExpHeap::removeUsedBlock(JKRExpHeap::CMemBlock* block) {
/* 802CFF1C-802D00B4 2CA85C 0198+00 2/2 0/0 0/0 .text
* recycleFreeBlock__10JKRExpHeapFPQ210JKRExpHeap9CMemBlock */
#ifdef NONMATCHING
void JKRExpHeap::recycleFreeBlock(JKRExpHeap::CMemBlock* block) {
u32 size = block->size;
JKRExpHeap::CMemBlock* newBlock = block;
int size = block->size;
void* blockEnd = (u8*)block + size;
block->mMagic = 0;
u32 offset = block->getAlignment();
if (offset) {
block = (CMemBlock*)((u8*)block - offset);
size += offset;
blockEnd = (u8*)block + size;
block->mGroupId = 0;
block->mFlags = 0;
block->size = size;
if ((block->mFlags & 0x7f) != 0) {
newBlock = (CMemBlock*)((u8*)block - (block->mFlags & 0x7f));
size += (block->mFlags & 0x7f);
blockEnd = (u8*)newBlock + size;
newBlock->mGroupId = 0;
newBlock->mFlags = 0;
newBlock->size = size;
}
if (!mHeadFreeList) {
block->initiate(NULL, NULL, size, 0, 0);
mHeadFreeList = block;
mTailFreeList = block;
setFreeBlock(block, NULL, NULL);
newBlock->initiate(NULL, NULL, size, 0, 0);
mHeadFreeList = newBlock;
mTailFreeList = newBlock;
setFreeBlock(newBlock, NULL, NULL);
return;
}
if (mHeadFreeList >= blockEnd) {
block->initiate(NULL, NULL, size, 0, 0);
setFreeBlock(block, NULL, mHeadFreeList);
joinTwoBlocks(block);
newBlock->initiate(NULL, NULL, size, 0, 0);
setFreeBlock(newBlock, NULL, mHeadFreeList);
joinTwoBlocks(newBlock);
return;
}
if (mTailFreeList <= block) {
block->initiate(NULL, NULL, size, 0, 0);
setFreeBlock(block, mTailFreeList, NULL);
joinTwoBlocks(block->getPrevBlock());
if (mTailFreeList <= newBlock) {
newBlock->initiate(NULL, NULL, size, 0, 0);
setFreeBlock(newBlock, mTailFreeList, NULL);
joinTwoBlocks(newBlock->mPrev);
return;
}
for (CMemBlock* freeBlock = mHeadFreeList; freeBlock; freeBlock = freeBlock->getNextBlock()) {
if (freeBlock >= block || block >= freeBlock->getNextBlock()) {
for (CMemBlock* freeBlock = mHeadFreeList; freeBlock; freeBlock = freeBlock->mNext) {
if (freeBlock >= newBlock || newBlock >= freeBlock->mNext) {
continue;
}
block->mNext = freeBlock->getNextBlock();
block->mPrev = freeBlock;
freeBlock->mNext = block;
block->mNext->mPrev = block;
block->mGroupId = 0;
joinTwoBlocks(block);
newBlock->mNext = freeBlock->mNext;
newBlock->mPrev = freeBlock;
freeBlock->mNext = newBlock;
newBlock->mNext->mPrev = newBlock;
newBlock->mGroupId = 0;
joinTwoBlocks(newBlock);
joinTwoBlocks(freeBlock);
return;
}
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JKRExpHeap::recycleFreeBlock(JKRExpHeap::CMemBlock* param_0) {
nofralloc
#include "asm/JSystem/JKernel/JKRExpHeap/recycleFreeBlock__10JKRExpHeapFPQ210JKRExpHeap9CMemBlock.s"
}
#pragma pop
#endif
/* ############################################################################################## */
/* 8039CAF0-8039CAF0 029150 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */
#pragma push
#pragma force_active on
SECTION_DEAD static char const* const stringBase_8039CB3B = ":::Heap may be broken. (block = %x)";
SECTION_DEAD static char const* const stringBase_8039CB5F = "Bad Block\n";
#pragma pop
/* 802D00B4-802D0190 2CA9F4 00DC+00 1/1 0/0 0/0 .text
* joinTwoBlocks__10JKRExpHeapFPQ210JKRExpHeap9CMemBlock */
#ifdef NONMATCHING
void JKRExpHeap::joinTwoBlocks(CMemBlock* block) {
u32 endAddr = (u32)block->getContent() + block->getSize();
CMemBlock* next = block->getNextBlock();
u32 nextAddr = (u32)next - next->getAlignment();
u32 endAddr = (u32)(block + 1) + block->size;
CMemBlock* next = block->mNext;
u32 nextAddr = (u32)next - (next->mFlags & 0x7f);
if (endAddr > nextAddr) {
JUTWarningConsole_f(":::Heap may be broken. (block = %x)", block);
getCurrentHeap()->dump();
JUTException::panic_f("JKRExpHeap.cpp", 0x71c, "%s", "Bad Block\n");
JKRGetCurrentHeap()->dump();
JUTException::panic_f(__FILE__, 1820, "%s", "Bad Block\n");
}
if (endAddr == nextAddr) {
block->size = next->getSize() + sizeof(CMemBlock) + next->getAlignment() + block->getSize();
setFreeBlock(block, block->getPrevBlock(), next->getNextBlock());
}
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JKRExpHeap::joinTwoBlocks(JKRExpHeap::CMemBlock* param_0) {
nofralloc
#include "asm/JSystem/JKernel/JKRExpHeap/joinTwoBlocks__10JKRExpHeapFPQ210JKRExpHeap9CMemBlock.s"
}
#pragma pop
#endif
/* ############################################################################################## */
/* 8039CAF0-8039CAF0 029150 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */
#pragma push
#pragma force_active on
SECTION_DEAD static char const* const stringBase_8039CB6A =
":::addr %08x: bad heap signature. (%c%c)\n";
SECTION_DEAD static char const* const stringBase_8039CB94 =
":::addr %08x: bad next pointer (%08x)\nabort\n";
SECTION_DEAD static char const* const stringBase_8039CBC1 =
":::addr %08x: bad previous pointer (%08x)\n";
SECTION_DEAD static char const* const stringBase_8039CBEC =
":::addr %08x: bad used list(REV) (%08x)\n";
SECTION_DEAD static char const* const stringBase_8039CC15 = ":::addr %08x: bad block size (%08x)\n";
SECTION_DEAD static char const* const stringBase_8039CC3A =
":::bad total memory block size (%08X, %08X)\n";
SECTION_DEAD static char const* const stringBase_8039CC67 =
":::there is some error in this heap!\n";
#pragma pop
if (endAddr == nextAddr) {
block->size = next->size + sizeof(CMemBlock) + next->getAlignment() + block->size;
setFreeBlock(block, block->mPrev, next->mNext);
}
}
/* 802D0190-802D03B8 2CAAD0 0228+00 1/0 0/0 0/0 .text check__10JKRExpHeapFv */
#ifdef NONMATCHING
bool JKRExpHeap::check() {
lock();
int totalBytes = 0;
bool ok = true;
for (CMemBlock* block = mHeadUsedList; block; block = block->getNextBlock()) {
for (CMemBlock* block = mHeadUsedList; block; block = block->mNext) {
if (!block->isValid()) {
ok = false;
JUTWarningConsole_f(":::addr %08x: bad heap signature. (%c%c)\n", block,
block->mMagic >> 8, block->mMagic & 0xff);
JSUHiByte(block->mMagic), JSULoByte(block->mMagic));
}
if (block->getNextBlock()) {
if (!block->getNextBlock()->isValid()) {
if (block->mNext) {
if (!block->mNext->isValid()) {
ok = false;
JUTWarningConsole_f(":::addr %08x: bad next pointer (%08x)\nabort\n", block,
block->getNextBlock());
block->mNext);
break;
}
if (block->getNextBlock()->getPrevBlock() != block) {
if (block->mNext->mPrev != block) {
ok = false;
JUTWarningConsole_f(":::addr %08x: bad previous pointer (%08x)\n",
block->getNextBlock(), block->getNextBlock()->getPrevBlock());
JUTWarningConsole_f(":::addr %08x: bad previous pointer (%08x)\n", block->mNext,
block->mNext->mPrev);
}
} else {
if (mTailUsedList != block) {
@ -933,20 +859,21 @@ bool JKRExpHeap::check() {
mTailUsedList);
}
}
totalBytes += sizeof(CMemBlock) + block->getSize() + block->getAlignment();
totalBytes += sizeof(CMemBlock) + block->size + block->getAlignment();
}
for (CMemBlock* block = mHeadFreeList; block; block = block->getNextBlock()) {
totalBytes += block->getSize() + sizeof(CMemBlock);
if (block->getNextBlock()) {
if (block->getNextBlock()->getPrevBlock() != block) {
for (CMemBlock* block = mHeadFreeList; block; block = block->mNext) {
totalBytes += block->size + sizeof(CMemBlock);
if (block->mNext) {
if (block->mNext->mPrev != block) {
ok = false;
JUTWarningConsole_f(":::addr %08x: bad previous pointer (%08x)\n",
block->getNextBlock(), block->getNextBlock()->getPrevBlock());
JUTWarningConsole_f(":::addr %08x: bad previous pointer (%08x)\n", block->mNext,
block->mNext->mPrev);
}
if ((u32)block + block->getSize() + sizeof(CMemBlock) > (u32)block->getNextBlock()) {
if ((u32)block + block->size + sizeof(CMemBlock) > (u32)block->mNext) {
ok = false;
JUTWarningConsole_f(":::addr %08x: bad block size (%08x)\n", block,
block->getSize());
JUTWarningConsole_f(":::addr %08x: bad block size (%08x)\n", block, block->size);
}
} else {
if (mTailFreeList != block) {
@ -956,9 +883,10 @@ bool JKRExpHeap::check() {
}
}
}
if (totalBytes != getSize()) {
if (totalBytes != mSize) {
ok = false;
JUTWarningConsole_f(":::bad total memory block size (%08X, %08X)\n", getSize(), totalBytes);
JUTWarningConsole_f(":::bad total memory block size (%08X, %08X)\n", mSize, totalBytes);
}
if (!ok) {
@ -968,16 +896,6 @@ bool JKRExpHeap::check() {
unlock();
return ok;
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm bool JKRExpHeap::check() {
nofralloc
#include "asm/JSystem/JKernel/JKRExpHeap/check__10JKRExpHeapFv.s"
}
#pragma pop
#endif
/* ############################################################################################## */
/* 8039CAF0-8039CAF0 029150 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */
@ -1011,6 +929,7 @@ SECTION_SDATA2 static f32 lit_1121[1 + 1 /* padding */] = {
SECTION_SDATA2 static f64 lit_1123 = 4503599627370496.0 /* cast u32 to float */;
/* 802D03B8-802D05CC 2CACF8 0214+00 1/0 0/0 0/0 .text dump__10JKRExpHeapFv */
// matches with literals
#ifdef NONMATCHING
bool JKRExpHeap::dump() {
lock();
@ -1018,39 +937,42 @@ bool JKRExpHeap::dump() {
u32 usedBytes = 0;
u32 usedCount = 0;
u32 freeCount = 0;
JUTReportConsole(" attr address: size gid aln prev_ptr next_ptr\n");
JUTReportConsole("(Used Blocks)\n");
if (!mHeadUsedList) {
JUTReportConsole(" NONE\n");
}
for (CMemBlock* block = mHeadUsedList; block; block = block->getNextBlock()) {
for (CMemBlock* block = mHeadUsedList; block; block = block->mNext) {
if (!block->isValid()) {
JUTReportConsole_f("xxxxx %08x: -------- --- --- (-------- --------)\nabort\n",
block);
break;
}
int offset = block->getAlignment();
void* content = block->getContent();
const char* type = block->_isTempMemBlock() ? " temp" : "alloc";
JUTReportConsole_f("%s %08x: %08x %3d %3d (%08x %08x)\n", type, content, block->getSize(),
block->getGroupId(), offset, block->getPrevBlock(),
block->getNextBlock());
usedBytes += sizeof(CMemBlock) + block->getSize() + block->getAlignment();
JUTReportConsole_f("%s %08x: %08x %3d %3d (%08x %08x)\n",
block->_isTempMemBlock() ? " temp" : "alloc", block->getContent(),
block->size, block->mGroupId, block->getAlignment(), block->mPrev,
block->mNext);
usedBytes += sizeof(CMemBlock) + block->size + block->getAlignment();
usedCount++;
}
JUTReportConsole("(Free Blocks)\n");
if (!mHeadFreeList) {
JUTReportConsole(" NONE\n");
}
for (CMemBlock* block = mHeadFreeList; block; block = block->getNextBlock()) {
for (CMemBlock* block = mHeadFreeList; block; block = block->mNext) {
JUTReportConsole_f("%s %08x: %08x %3d %3d (%08x %08x)\n", " free", block->getContent(),
block->getSize(), block->getGroupId(), block->getAlignment(),
block->getPrevBlock(), block->getNextBlock());
block->size, block->mGroupId, block->getAlignment(), block->mPrev,
block->mNext);
freeCount++;
}
float percent = ((float)usedBytes / (float)getSize()) * 100.0f;
JUTReportConsole_f("%d / %d bytes (%6.2f%%) used (U:%d F:%d)\n", usedBytes, getSize(), percent,
float percent = ((float)usedBytes / (float)mSize) * 100.0f;
JUTReportConsole_f("%d / %d bytes (%6.2f%%) used (U:%d F:%d)\n", usedBytes, mSize, percent,
usedCount, freeCount);
unlock();
return result;
@ -1067,6 +989,7 @@ asm bool JKRExpHeap::dump() {
#endif
/* 802D05CC-802D0810 2CAF0C 0244+00 1/0 0/0 0/0 .text dump_sort__10JKRExpHeapFv */
// using r0 instead of r4
#ifdef NONMATCHING
bool JKRExpHeap::dump_sort() {
lock();
@ -1076,48 +999,53 @@ bool JKRExpHeap::dump_sort() {
u32 freeCount = 0;
JUTReportConsole(" attr address: size gid aln prev_ptr next_ptr\n");
JUTReportConsole("(Used Blocks)\n");
if (mHeadUsedList == NULL) {
JUTReportConsole(" NONE\n");
} else {
CMemBlock* var1 = NULL;
while (true) {
CMemBlock* block = (CMemBlock*)0xffffffff;
for (CMemBlock* iterBlock = mHeadUsedList; iterBlock;
iterBlock = iterBlock->getNextBlock()) {
for (CMemBlock* iterBlock = mHeadUsedList; iterBlock; iterBlock = iterBlock->mNext) {
if (var1 < iterBlock && iterBlock < block) {
block = iterBlock;
}
}
if (block == (CMemBlock*)0xffffffff) {
break;
}
if (!block->isValid()) {
JUTReportConsole_f("xxxxx %08x: -------- --- --- (-------- --------)\nabort\n");
break;
}
int offset = block->getAlignment();
void* content = block->getContent();
const char* type = block->_isTempMemBlock() ? " temp" : "alloc";
JUTReportConsole_f("%s %08x: %08x %3d %3d (%08x %08x)\n", type, content,
block->getSize(), block->getGroupId(), offset, block->getPrevBlock(),
block->getNextBlock());
usedBytes += sizeof(CMemBlock) + block->getSize() + block->getAlignment();
JUTReportConsole_f("%s %08x: %08x %3d %3d (%08x %08x)\n", type, content, block->size,
block->getGroupId(), offset, block->mPrev, block->mNext);
usedBytes += sizeof(CMemBlock) + block->size + block->getAlignment();
usedCount++;
var1 = block;
}
}
JUTReportConsole("(Free Blocks)\n");
if (mHeadFreeList == NULL) {
JUTReportConsole(" NONE\n");
}
for (CMemBlock* block = mHeadFreeList; block; block = block->getNextBlock()) {
for (CMemBlock* block = mHeadFreeList; block; block = block->mNext) {
JUTReportConsole_f("%s %08x: %08x %3d %3d (%08x %08x)\n", " free", block->getContent(),
block->getSize(), block->getGroupId(), block->getAlignment(),
block->getPrevBlock(), block->getNextBlock());
block->size, block->getGroupId(), block->getAlignment(), block->mPrev,
block->mNext);
freeCount++;
}
float percent = ((float)usedBytes / (float)getSize()) * 100.0f;
JUTReportConsole_f("%d / %d bytes (%6.2f%%) used (U:%d F:%d)\n", usedBytes, getSize(), percent,
float percent = ((float)usedBytes / (float)mSize) * 100.0f;
JUTReportConsole_f("%d / %d bytes (%6.2f%%) used (U:%d F:%d)\n", usedBytes, mSize, percent,
usedCount, freeCount);
unlock();
return result;
@ -1212,6 +1140,7 @@ void JKRExpHeap::state_register(JKRHeap::TState* p, u32 param_1) const {
s32 freeSize = const_cast<JKRExpHeap*>(this)->getTotalFreeSize();
p->mUsedSize = getSize() - freeSize;
}
u32 checkCode = 0;
for (CMemBlock* block = mHeadUsedList; block; block = block->getNextBlock()) {
if (param_1 <= 0xff) {
@ -1233,9 +1162,11 @@ bool JKRExpHeap::state_compare(JKRHeap::TState const& r1, JKRHeap::TState const&
if (r1.mCheckCode != r2.mCheckCode) {
result = false;
}
if (r1.mUsedSize != r2.mUsedSize) {
result = false;
}
return result;
}
@ -1304,5 +1235,3 @@ SECTION_DEAD static char const* const stringBase_8039CE2A = "| ---- UsedLast\n";
#pragma force_active on
SECTION_DEAD static char const* const stringBase_8039CE3B = "+---------------End\n";
#pragma pop
/* 8039CAF0-8039CAF0 029150 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */

6
libs/JSystem/JKernel/JKRFile.cpp
View File

@ -4,14 +4,8 @@
//
#include "JSystem/JKernel/JKRFile.h"
#include "dol2asm.h"
#include "dolphin/types.h"
#include "dolphin/vi/vi.h"
//
// Declarations:
//
/* 802D9518-802D9584 2D3E58 006C+00 0/0 2/2 0/0 .text read__7JKRFileFPvll */
s32 JKRFile::read(void* data, s32 size, long offset) {
while (true) {

117
libs/JSystem/JKernel/JKRFileCache.cpp
View File

@ -9,80 +9,8 @@
#include "JSystem/JKernel/JKRHeap.h"
#include "MSL_C/MSL_Common/Src/ctype.h"
#include "MSL_C/MSL_Common/Src/string.h"
#include "dol2asm.h"
#include "global.h"
//
// Forward References:
//
extern "C" void mount__12JKRFileCacheFPCcP7JKRHeapPCc();
extern "C" void __ct__12JKRFileCacheFPCcPCc();
extern "C" void __dt__12JKRFileCacheFv();
extern "C" void becomeCurrent__12JKRFileCacheFPCc();
extern "C" void getResource__12JKRFileCacheFPCc();
extern "C" void getResource__12JKRFileCacheFUlPCc();
extern "C" void readResource__12JKRFileCacheFPvUlPCc();
extern "C" void readResource__12JKRFileCacheFPvUlUlPCc();
extern "C" void removeResourceAll__12JKRFileCacheFv();
extern "C" void removeResource__12JKRFileCacheFPv();
extern "C" void detachResource__12JKRFileCacheFPv();
extern "C" void getResSize__12JKRFileCacheCFPCv();
extern "C" void countFile__12JKRFileCacheCFPCc();
extern "C" void getFirstFile__12JKRFileCacheCFPCc();
extern "C" void findCacheBlock__12JKRFileCacheCFPCv();
extern "C" void findCacheBlock__12JKRFileCacheCFUl();
extern "C" void findFile__12JKRFileCacheCFPcPCc();
extern "C" void getDvdPathName__12JKRFileCacheCFPCc();
extern "C" void convStrLower__12JKRFileCacheCFPc();
extern "C" void __ct__Q212JKRFileCache11CCacheBlockFUlUlPCv();
extern "C" void getFsResource__12JKRFileCacheFPCc();
extern "C" void getNameResource__12JKRFileCacheFUlPCc();
extern "C" void readFsResource__12JKRFileCacheFPvUlPCc();
extern "C" void readNameResource__12JKRFileCacheFPvUlUlPCc();
extern "C" extern char const* const JKRFileCache__stringBase0;
//
// External References:
//
extern "C" void alloc__7JKRHeapFUliP7JKRHeap();
extern "C" void alloc__7JKRHeapFUli();
extern "C" void free__7JKRHeapFPvP7JKRHeap();
extern "C" void free__7JKRHeapFPv();
extern "C" void findFromRoot__7JKRHeapFPv();
extern "C" void* __nw__FUlP7JKRHeapi();
extern "C" void __dl__FPv();
extern "C" void __ct__13JKRFileLoaderFv();
extern "C" void __dt__13JKRFileLoaderFv();
extern "C" void unmount__13JKRFileLoaderFv();
extern "C" void __ct__12JKRDvdFinderFPCc();
extern "C" void read__7JKRFileFPvll();
extern "C" void __ct__10JKRDvdFileFPCc();
extern "C" void __dt__10JKRDvdFileFv();
extern "C" void __ct__10JSUPtrLinkFPv();
extern "C" void __dt__10JSUPtrLinkFv();
extern "C" void __dt__10JSUPtrListFv();
extern "C" void initiate__10JSUPtrListFv();
extern "C" void append__10JSUPtrListFP10JSUPtrLink();
extern "C" void prepend__10JSUPtrListFP10JSUPtrLink();
extern "C" void remove__10JSUPtrListFP10JSUPtrLink();
extern "C" void _savegpr_26();
extern "C" void _savegpr_27();
extern "C" void _savegpr_28();
extern "C" void _savegpr_29();
extern "C" void _restgpr_26();
extern "C" void _restgpr_27();
extern "C" void _restgpr_28();
extern "C" void _restgpr_29();
extern "C" u8 sVolumeList__13JKRFileLoader[12];
extern "C" u8 sSystemHeap__7JKRHeap[4];
extern "C" u8 sCurrentVolume__13JKRFileLoader[4 + 4 /* padding */];
//
// Declarations:
//
/* 802D49B4-802D4AB4 2CF2F4 0100+00 0/0 2/2 0/0 .text mount__12JKRFileCacheFPCcP7JKRHeapPCc */
JKRFileCache* JKRFileCache::mount(const char* path, JKRHeap* heap, const char* param_3) {
if (!path || *path != '/') {
@ -111,16 +39,6 @@ JKRFileCache* JKRFileCache::mount(const char* path, JKRHeap* heap, const char* p
return new (heap, 0) JKRFileCache(path, param_3);
}
/* ############################################################################################## */
/* 8039D158-8039D158 0297B8 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */
// #pragma push
// #pragma force_active on
// SECTION_DEAD static char const* const stringBase_8039D158 = "/";
// SECTION_DEAD static char const* const stringBase_8039D15A = "dvd";
// /* @stringBase0 padding */
// SECTION_DEAD static char const* const pad_8039D15E = "\0";
// #pragma pop
/* 802D4AB4-802D4C70 2CF3F4 01BC+00 1/1 0/0 0/0 .text __ct__12JKRFileCacheFPCcPCc */
JKRFileCache::JKRFileCache(const char* path, const char* volume) : mCacheBlockList() {
mParentHeap = JKRHeap::findFromRoot(this);
@ -181,35 +99,23 @@ JKRFileCache::~JKRFileCache() {
/* 802D4D44-802D4DD8 2CF684 0094+00 1/0 0/0 0/0 .text becomeCurrent__12JKRFileCacheFPCc
*/
#ifdef NONMATCHING
bool JKRFileCache::becomeCurrent(const char* path) {
char* name = getDvdPathName(path);
BOOL result = DVDChangeDir(name);
bool didChangeDir = (result != 0);
if (didChangeDir) {
setCurrentVolume(this);
JKRFreeToSysHeap(mCurrentPath);
char* dvdPathName = getDvdPathName(path);
mCurrentPath = name;
if (mCurrentPath[1]) {
bool result = DVDChangeDir(dvdPathName);
if (result) {
sCurrentVolume = this;
JKRHeap::sSystemHeap->free(mCurrentPath);
mCurrentPath = dvdPathName;
if (mCurrentPath[1] != '\0') {
strcat(mCurrentPath, "/");
}
} else {
JKRFreeToSysHeap(name);
JKRHeap::sSystemHeap->free(dvdPathName);
}
return didChangeDir;
return result;
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm bool JKRFileCache::becomeCurrent(char const* param_0) {
nofralloc
#include "asm/JSystem/JKernel/JKRFileCache/becomeCurrent__12JKRFileCacheFPCc.s"
}
#pragma pop
#endif
/* 802D4DD8-802D4EDC 2CF718 0104+00 1/0 0/0 0/0 .text getResource__12JKRFileCacheFPCc */
void* JKRFileCache::getResource(const char* path) {
@ -217,11 +123,11 @@ void* JKRFileCache::getResource(const char* path) {
void* buffer = NULL;
char* name = getDvdPathName(path);
JKRDvdFile dvdFile(name);
if (dvdFile.isAvailable()) {
CCacheBlock* cacheBlock = findCacheBlock(dvdFile.getFileID());
if (!cacheBlock) {
// dvdFile.getFileSize() not inlined
u32 fileSize = dvdFile.getFileInfo()->length;
u32 alignedSize = ALIGN_NEXT(fileSize, 0x20);
buffer = JKRAllocFromHeap(mParentHeap, alignedSize, 0x20);
@ -272,7 +178,6 @@ u32 JKRFileCache::readResource(void* dst, u32 dstLength, const char* path) {
// will would never exit the loop.
loop:
if (dvdFile.isAvailable()) {
// dvdFile.getFileSize() not inlined
u32 fileSize = dvdFile.getFileInfo()->length;
resourceSize = ALIGN_NEXT(fileSize, 0x20);
dstLength = ALIGN_PREV(dstLength, 0x20);
@ -531,5 +436,3 @@ u32 JKRFileCache::readFsResource(void* dst, u32 dstLength, const char* path) {
u32 JKRFileCache::readNameResource(void* dst, u32 dstLength, u32 type, const char* path) {
return readResource(dst, dstLength, type, path);
}
/* 8039D158-8039D158 0297B8 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */

1
libs/JSystem/JKernel/JKRFileFinder.cpp
View File

@ -6,7 +6,6 @@
#include "JSystem/JKernel/JKRFileFinder.h"
#include "JSystem/JKernel/JKRArchive.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Forward References:

9
libs/JSystem/JKernel/JKRFileLoader.cpp
View File

@ -180,14 +180,9 @@ SECTION_DEAD static char const* const pad_8039D152 = "\0\0\0\0\0";
SECTION_SDATA static char rootPath[2] = "/";
/* 802D44C4-802D45A0 2CEE04 00DC+00 1/1 0/0 0/0 .text fetchVolumeName__13JKRFileLoaderFPclPCc */
// matches, but lbl_804508C0 is accessed through r13
// matches, but rootPath is accessed through r13
#ifdef NONMATCHING
const char* JKRFileLoader::fetchVolumeName(char* buffer, long bufferSize, const char* path) {
// lbl_803D2D18 = MSL_C::__lower_map
// lbl_8039D150 = JKernel::@stringBase0 "/"
// lbl_804508C0 = JKernel::rootPath$2498 "/"
// lbl_803D2D18 = MSL_C::__lower_map
if (strcmp(path, "/") == 0) {
strcpy(buffer, rootPath);
return rootPath;
@ -228,5 +223,3 @@ asm const char* JKRFileLoader::fetchVolumeName(char* param_0, s32 param_1, char
}
#pragma pop
#endif
/* 8039D150-8039D150 0297B0 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */

244
libs/JSystem/JKernel/JKRHeap.cpp
View File

@ -1,99 +1,25 @@
//
// Generated By: dol2asm
// Translation Unit: JKRHeap
//
/**
* JKRHeap.cpp
* JSystem Heap Framework
*/
#include "JSystem/JKernel/JKRHeap.h"
#include "JSystem/JUtility/JUTAssert.h"
#include "JSystem/JUtility/JUTException.h"
#include "dol2asm.h"
#include "global.h"
//
// Forward References:
//
extern "C" void __ct__7JKRHeapFPvUlP7JKRHeapb();
extern "C" void __dt__7JKRHeapFv();
extern "C" void initArena__7JKRHeapFPPcPUli();
extern "C" void becomeSystemHeap__7JKRHeapFv();
extern "C" void becomeCurrentHeap__7JKRHeapFv();
extern "C" void destroy__7JKRHeapFv();
extern "C" void alloc__7JKRHeapFUliP7JKRHeap();
extern "C" void alloc__7JKRHeapFUli();
extern "C" void free__7JKRHeapFPvP7JKRHeap();
extern "C" void free__7JKRHeapFPv();
extern "C" void callAllDisposer__7JKRHeapFv();
extern "C" void freeAll__7JKRHeapFv();
extern "C" void freeTail__7JKRHeapFv();
extern "C" void resize__7JKRHeapFPvUlP7JKRHeap();
extern "C" void resize__7JKRHeapFPvUl();
extern "C" void getSize__7JKRHeapFPvP7JKRHeap();
extern "C" void getSize__7JKRHeapFPv();
extern "C" void getFreeSize__7JKRHeapFv();
extern "C" void getMaxFreeBlock__7JKRHeapFv();
extern "C" void getTotalFreeSize__7JKRHeapFv();
extern "C" void changeGroupID__7JKRHeapFUc();
extern "C" void getMaxAllocatableSize__7JKRHeapFi();
extern "C" void findFromRoot__7JKRHeapFPv();
extern "C" void find__7JKRHeapCFPv();
extern "C" void findAllHeap__7JKRHeapCFPv();
extern "C" void dispose_subroutine__7JKRHeapFUlUl();
extern "C" void dispose__7JKRHeapFPvUl();
extern "C" void dispose__7JKRHeapFPvPv();
extern "C" void dispose__7JKRHeapFv();
extern "C" void copyMemory__7JKRHeapFPvPvUl();
extern "C" void JKRDefaultMemoryErrorRoutine__FPvUli();
extern "C" void setErrorFlag__7JKRHeapFb();
extern "C" void setErrorHandler__7JKRHeapFPFPvUli_v();
extern "C" void isSubHeap__7JKRHeapCFP7JKRHeap();
extern "C" void* __nw__FUl();
extern "C" void* __nw__FUli();
extern "C" void* __nw__FUlP7JKRHeapi();
extern "C" void* __nwa__FUl();
extern "C" void* __nwa__FUli();
extern "C" void* __nwa__FUlP7JKRHeapi();
extern "C" void __dl__FPv();
extern "C" void __dla__FPv();
extern "C" void state_register__7JKRHeapCFPQ27JKRHeap6TStateUl();
extern "C" void state_compare__7JKRHeapCFRCQ27JKRHeap6TStateRCQ27JKRHeap6TState();
extern "C" void state_dump__7JKRHeapCFRCQ27JKRHeap6TState();
extern "C" bool do_changeGroupID__7JKRHeapFUc();
extern "C" bool do_getCurrentGroupId__7JKRHeapFv();
extern "C" extern char const* const JKRHeap__stringBase0;
extern "C" u8 sSystemHeap__7JKRHeap[4];
extern "C" u8 sCurrentHeap__7JKRHeap[4];
extern "C" u8 sRootHeap__7JKRHeap[4];
extern "C" u8 mErrorHandler__7JKRHeap[4];
extern "C" u8 mCodeStart__7JKRHeap[4];
extern "C" u8 mCodeEnd__7JKRHeap[4];
extern "C" u8 mUserRamStart__7JKRHeap[4];
extern "C" u8 mUserRamEnd__7JKRHeap[4];
extern "C" u8 mMemorySize__7JKRHeap[4];
//
// External References:
//
extern "C" bool dump_sort__7JKRHeapFv();
extern "C" void __ct__11JKRDisposerFv();
extern "C" void __dt__11JKRDisposerFv();
extern "C" void __ct__10JSUPtrLinkFPv();
extern "C" void __dt__10JSUPtrLinkFv();
extern "C" void __dt__10JSUPtrListFv();
extern "C" void initiate__10JSUPtrListFv();
extern "C" void append__10JSUPtrListFP10JSUPtrLink();
extern "C" void remove__10JSUPtrListFP10JSUPtrLink();
extern "C" void panic_f__12JUTExceptionFPCciPCce();
extern "C" void _savegpr_26();
extern "C" void _savegpr_27();
extern "C" void _savegpr_28();
extern "C" void _savegpr_29();
extern "C" void _restgpr_26();
extern "C" void _restgpr_27();
extern "C" void _restgpr_28();
extern "C" void _restgpr_29();
extern "C" void* __vt__7JKRHeap;
//
// Declarations:
@ -131,13 +57,14 @@ JKRHeap::JKRHeap(void* data, u32 size, JKRHeap* parent, bool errorFlag)
if (getSystemHeap() == getRootHeap()) {
becomeSystemHeap();
}
if (getCurrentHeap() == getRootHeap()) {
becomeCurrentHeap();
}
}
mErrorFlag = errorFlag;
if ((mErrorFlag == true) && (mErrorHandler == NULL)) {
if (mErrorFlag == true && mErrorHandler == NULL) {
mErrorHandler = JKRDefaultMemoryErrorRoutine;
}
@ -147,45 +74,16 @@ JKRHeap::JKRHeap(void* data, u32 size, JKRHeap* parent, bool errorFlag)
}
/* 802CE264-802CE378 2C8BA4 0114+00 1/0 3/3 0/0 .text __dt__7JKRHeapFv */
// using the wrong register for storing the results
#ifdef NONMATCHING
JKRHeap::~JKRHeap() {
JSUTree<JKRHeap>* parent = mChildTree.getParent();
parent->removeChild(&mChildTree);
mChildTree.getParent()->removeChild(&mChildTree);
JSUTree<JKRHeap>* nextRootHeap = sRootHeap->mChildTree.getFirstChild();
JSUTree<JKRHeap>* nextRootHeap = getRootHeap()->mChildTree.getFirstChild();
if (sCurrentHeap == this)
sCurrentHeap = !nextRootHeap ? sRootHeap : nextRootHeap->getObject();
JKRHeap* rootHeap = getRootHeap();
JKRHeap* currentHeap = getCurrentHeap();
if (currentHeap == this) {
if (!nextRootHeap) {
currentHeap = rootHeap;
} else {
currentHeap = nextRootHeap->getObject();
}
}
setCurrentHeap(currentHeap);
JKRHeap* systemHeap = getSystemHeap();
if (systemHeap == this) {
if (!nextRootHeap) {
systemHeap = rootHeap;
} else {
systemHeap = nextRootHeap->getObject();
}
}
setSystemHeap(systemHeap);
if (sSystemHeap == this)
sSystemHeap = !nextRootHeap ? sRootHeap : nextRootHeap->getObject();
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JKRHeap::~JKRHeap() {
nofralloc
#include "asm/JSystem/JKernel/JKRHeap/__dt__7JKRHeapFv.s"
}
#pragma pop
#endif
/* ############################################################################################## */
/* 80451384-80451388 000884 0004+00 1/1 1/1 0/0 .sbss mCodeStart__7JKRHeap */
@ -205,42 +103,46 @@ u32 JKRHeap::mMemorySize;
/* 802CE378-802CE428 2C8CB8 00B0+00 0/0 1/1 0/0 .text initArena__7JKRHeapFPPcPUli */
bool JKRHeap::initArena(char** memory, u32* size, int maxHeaps) {
u32 ram_start;
u32 ram_end;
void* ram;
void* ram_start;
void* ram_end;
void* arenaStart;
void* low = OSGetArenaLo();
void* high = OSGetArenaHi();
if (low == high)
void* arenaLo = OSGetArenaLo();
void* arenaHi = OSGetArenaHi();
if (arenaLo == arenaHi)
return false;
ram = OSInitAlloc(low, high, maxHeaps);
ram_start = ALIGN_NEXT((u32)ram, 0x20);
ram_end = ALIGN_PREV((u32)high, 0x20);
GLOBAL_MEMORY* globalMemory = (GLOBAL_MEMORY*)OSPhysicalToCached(0);
mCodeStart = globalMemory;
mCodeEnd = (void*)ram_start;
mUserRamStart = (void*)ram_start;
mUserRamEnd = (void*)ram_end;
mMemorySize = globalMemory->memory_size;
OSSetArenaLo((void*)ram_end);
OSSetArenaHi((void*)ram_end);
arenaStart = OSInitAlloc(arenaLo, arenaHi, maxHeaps);
ram_start = (void*)ALIGN_NEXT((u32)arenaStart, 0x20);
ram_end = (void*)ALIGN_PREV((u32)arenaHi, 0x20);
GLOBAL_MEMORY* codeStart = (GLOBAL_MEMORY*)OSPhysicalToCached(0);
mCodeStart = codeStart;
mCodeEnd = ram_start;
mUserRamStart = ram_start;
mUserRamEnd = ram_end;
mMemorySize = codeStart->memory_size;
OSSetArenaLo(ram_end);
OSSetArenaHi(ram_end);
*memory = (char*)ram_start;
*size = ram_end - ram_start;
*size = (u32)ram_end - (u32)ram_start;
return true;
}
/* 802CE428-802CE438 2C8D68 0010+00 1/1 0/0 0/0 .text becomeSystemHeap__7JKRHeapFv */
JKRHeap* JKRHeap::becomeSystemHeap() {
JKRHeap* prev = JKRHeap::getSystemHeap();
setSystemHeap(this);
JKRHeap* prev = sSystemHeap;
sSystemHeap = this;
return prev;
}
/* 802CE438-802CE448 2C8D78 0010+00 1/1 22/22 1/1 .text becomeCurrentHeap__7JKRHeapFv */
JKRHeap* JKRHeap::becomeCurrentHeap() {
JKRHeap* prev = getCurrentHeap();
setCurrentHeap(this);
JKRHeap* prev = sCurrentHeap;
sCurrentHeap = this;
return prev;
}
@ -255,8 +157,8 @@ void* JKRHeap::alloc(u32 size, int alignment, JKRHeap* heap) {
return heap->alloc(size, alignment);
}
if (getCurrentHeap() != NULL) {
return getCurrentHeap()->alloc(size, alignment);
if (sCurrentHeap != NULL) {
return sCurrentHeap->alloc(size, alignment);
}
return NULL;
@ -284,6 +186,16 @@ void JKRHeap::free(void* ptr) {
}
/* 802CE574-802CE5CC 2C8EB4 0058+00 1/0 5/2 0/0 .text callAllDisposer__7JKRHeapFv */
// missing stack var
#ifdef NONMATCHING
void JKRHeap::callAllDisposer() {
JSUListIterator<JKRDisposer> iterator;
while (iterator = mDisposerList.getFirst(), iterator != mDisposerList.getEnd()) {
iterator->~JKRDisposer();
}
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
@ -292,6 +204,7 @@ asm void JKRHeap::callAllDisposer() {
#include "asm/JSystem/JKernel/JKRHeap/callAllDisposer__7JKRHeapFv.s"
}
#pragma pop
#endif
/* 802CE5CC-802CE5F8 2C8F0C 002C+00 0/0 12/12 0/0 .text freeAll__7JKRHeapFv */
void JKRHeap::freeAll() {
@ -351,8 +264,8 @@ s32 JKRHeap::getTotalFreeSize() {
}
/* 802CE7B0-802CE7DC 2C90F0 002C+00 0/0 1/1 0/0 .text changeGroupID__7JKRHeapFUc */
s32 JKRHeap::changeGroupID(u8 param_1) {
return do_changeGroupID(param_1);
s32 JKRHeap::changeGroupID(u8 groupID) {
return do_changeGroupID(groupID);
}
/* 802CE7DC-802CE83C 2C911C 0060+00 0/0 2/2 0/0 .text getMaxAllocatableSize__7JKRHeapFi
@ -381,16 +294,15 @@ asm u32 JKRHeap::getMaxAllocatableSize(int param_0) {
/* 802CE83C-802CE894 2C917C 0058+00 3/3 8/8 0/0 .text findFromRoot__7JKRHeapFPv */
JKRHeap* JKRHeap::findFromRoot(void* ptr) {
JKRHeap* rootHeap = getRootHeap();
if (rootHeap == NULL) {
if (sRootHeap == NULL) {
return NULL;
}
if (rootHeap->getStartAddr() <= ptr && ptr < rootHeap->getEndAddr()) {
return rootHeap->find(ptr);
if (sRootHeap->mStart <= ptr && ptr < sRootHeap->mEnd) {
return sRootHeap->find(ptr);
}
return rootHeap->findAllHeap(ptr);
return sRootHeap->findAllHeap(ptr);
}
/* 802CE894-802CE93C 2C91D4 00A8+00 1/1 1/1 0/0 .text find__7JKRHeapCFPv */
@ -415,21 +327,20 @@ JKRHeap* JKRHeap::find(void* memory) const {
/* 802CE93C-802CE9E4 2C927C 00A8+00 1/1 0/0 0/0 .text findAllHeap__7JKRHeapCFPv */
JKRHeap* JKRHeap::findAllHeap(void* ptr) const {
const JSUTree<JKRHeap>& tree = mChildTree;
if (tree.getNumChildren() != 0) {
JSUTreeIterator<JKRHeap> iterator;
for (iterator = tree.getFirstChild(); iterator != tree.getEndChild(); iterator++) {
JKRHeap* child = iterator.getObject();
JKRHeap* result = child->findAllHeap(ptr);
if (mChildTree.getNumChildren() != 0) {
for (JSUTreeIterator<JKRHeap> iterator(mChildTree.getFirstChild());
iterator != mChildTree.getEndChild(); ++iterator)
{
JKRHeap* result = iterator->findAllHeap(ptr);
if (result) {
return result;
}
}
}
if (getStartAddr() <= ptr && ptr < getEndAddr()) {
// todo: not sure about this... casting away const for now.
return (JKRHeap*)this;
if (mStart <= ptr && ptr < mEnd) {
return const_cast<JKRHeap*>(this);
}
return NULL;
@ -441,6 +352,7 @@ void JKRHeap::dispose_subroutine(u32 begin, u32 end) {
JSUListIterator<JKRDisposer> last_iterator;
JSUListIterator<JKRDisposer> next_iterator;
JSUListIterator<JKRDisposer> iterator;
for (iterator = mDisposerList.getFirst(); iterator != mDisposerList.getEnd();
iterator = next_iterator)
{
@ -448,6 +360,7 @@ void JKRHeap::dispose_subroutine(u32 begin, u32 end) {
if ((void*)begin <= disposer && disposer < (void*)end) {
disposer->~JKRDisposer();
if (last_iterator == NULL) {
next_iterator = mDisposerList.getFirst();
} else {
@ -513,7 +426,7 @@ void JKRHeap::copyMemory(void* dst, void* src, u32 size) {
/* 802CEB40-802CEB78 2C9480 0038+00 2/2 0/0 0/0 .text JKRDefaultMemoryErrorRoutine__FPvUli */
void JKRDefaultMemoryErrorRoutine(void* heap, u32 size, int alignment) {
JUTException::panic_f("JKRHeap.cpp", 0x33f, "%s", "abort\n");
JUTException::panic_f(__FILE__, 831, "%s", "abort\n");
}
/* 802CEB78-802CEB88 2C94B8 0010+00 0/0 2/2 0/0 .text setErrorFlag__7JKRHeapFb */
@ -541,17 +454,16 @@ bool JKRHeap::isSubHeap(JKRHeap* heap) const {
if (!heap)
return false;
const JSUTree<JKRHeap>& tree = mChildTree;
if (tree.getNumChildren() != 0) {
if (mChildTree.getNumChildren() != 0) {
JSUTreeIterator<JKRHeap> iterator;
for (iterator = tree.getFirstChild(); iterator != tree.getEndChild(); ++iterator) {
JKRHeap* child = iterator.getObject();
if (child == heap) {
for (iterator = mChildTree.getFirstChild(); iterator != mChildTree.getEndChild();
++iterator)
{
if (iterator.getObject() == heap) {
return true;
}
bool is_sub_heap = child->isSubHeap(heap);
if (is_sub_heap) {
if (iterator.getObject()->isSubHeap(heap)) {
return true;
}
}
@ -603,14 +515,14 @@ void operator delete[](void* ptr) {
/* 802CED84-802CED88 2C96C4 0004+00 1/0 1/0 0/0 .text
* state_register__7JKRHeapCFPQ27JKRHeap6TStateUl */
void JKRHeap::state_register(JKRHeap::TState* p, u32 id) const {
JUT_ASSERT("JKRHeap.cpp", 0x4bd, p != 0);
JUT_ASSERT("JKRHeap.cpp", 0x4be, p->getHeap() == this);
JUT_ASSERT(__FILE__, 1213, p != 0);
JUT_ASSERT(__FILE__, 1214, p->getHeap() == this);
}
/* 802CED88-802CEDA0 2C96C8 0018+00 1/0 1/0 0/0 .text
* state_compare__7JKRHeapCFRCQ27JKRHeap6TStateRCQ27JKRHeap6TState */
bool JKRHeap::state_compare(JKRHeap::TState const& r1, JKRHeap::TState const& r2) const {
JUT_ASSERT("JKRHeap.cpp", 0x4c6, r1.getHeap() == r2.getHeap());
JUT_ASSERT(__FILE__, 1222, r1.getHeap() == r2.getHeap());
return r1.getCheckCode() == r2.getCheckCode();
}
@ -630,5 +542,3 @@ s32 JKRHeap::do_changeGroupID(u8 param_0) {
u8 JKRHeap::do_getCurrentGroupId() {
return 0;
}
/* 8039CAD8-8039CAD8 029138 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */

102
libs/JSystem/JKernel/JKRMemArchive.cpp
View File

@ -9,85 +9,6 @@
#include "JSystem/JUtility/JUTException.h"
#include "MSL_C/MSL_Common/Src/string.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
// struct JUTException {
// /* 802E21FC */ void panic_f(char const*, int, char const*, ...);
// };
// struct JSUPtrLink {};
// struct JSUPtrList {
// /* 802DBFF0 */ void prepend(JSUPtrLink*);
// /* 802DC15C */ void remove(JSUPtrLink*);
// };
// struct JKRMemBreakFlag {};
// struct JKRArchive {
// struct EMountDirection {};
// struct SDIFileEntry {};
// struct EMountMode {};
// /* 802D5A38 */ void becomeCurrent(char const*);
// /* 802D5C64 */ void getResource(u32, char const*);
// /* 802D5BE8 */ void getResource(char const*);
// /* 802D5D8C */ void readResource(void*, u32, u32, char const*);
// /* 802D5E30 */ void readResource(void*, u32, char const*);
// /* 802D609C */ void detachResource(void*);
// /* 802D60D8 */ void getResSize(void const*) const;
// /* 802D6150 */ void countFile(char const*) const;
// /* 802D61B0 */ void getFirstFile(char const*) const;
// /* 802D6294 */ JKRArchive(s32, JKRArchive::EMountMode);
// /* 802D6334 */ ~JKRArchive();
// /* 802D6734 */ void findPtrResource(void const*) const;
// /* 802D693C */ void setExpandSize(JKRArchive::SDIFileEntry*, u32);
// /* 802D6978 */ void getExpandSize(JKRArchive::SDIFileEntry*) const;
// };
// struct JKRMemArchive {
// /* 802D6A6C */ JKRMemArchive(void*, u32, JKRMemBreakFlag);
// /* 802D69B8 */ JKRMemArchive(s32, JKRArchive::EMountDirection);
// /* 802D6B24 */ ~JKRMemArchive();
// /* 802D6BCC */ void open(s32, JKRArchive::EMountDirection);
// /* 802D6D30 */ void open(void*, u32, JKRMemBreakFlag);
// /* 802D6E10 */ void fetchResource(void*, u32, JKRArchive::SDIFileEntry*, u32*);
// /* 802D6DDC */ void fetchResource(JKRArchive::SDIFileEntry*, u32*);
// /* 802D6ED0 */ void removeResourceAll();
// /* 802D6F20 */ void removeResource(void*);
// /* 802D6F5C */ void fetchResource_subroutine(u8*, u32, u8*, u32, int);
// /* 802D7030 */ void getExpandedResSize(void const*) const;
// };
// struct JKRHeap {
// /* 802CE500 */ void free(void*, JKRHeap*);
// /* 802CE83C */ void findFromRoot(void*);
// };
// struct JKRFileLoader {
// /* 802D41D4 */ void unmount();
// static u8 sVolumeList[12];
// };
// struct JKRExpandSwitch {};
// struct JKRDvdRipper {
// struct EAllocDirection {};
// /* 802D9C54 */ void loadToMainRAM(s32, u8*, JKRExpandSwitch, u32, JKRHeap*,
// JKRDvdRipper::EAllocDirection, u32, int*, u32*);
// };
// struct JKRDecomp {
// /* 802DB988 */ void orderSync(u8*, u8*, u32, u32);
// };
//
// Forward References:
@ -209,16 +130,16 @@ bool JKRMemArchive::open(long entryNum, JKRArchive::EMountDirection mountDirecti
if (mMountDirection == JKRArchive::MOUNT_DIRECTION_HEAD) {
u32 loadedSize;
mArcHeader = (SArcHeader*)JKRDvdRipper::loadToMainRAM(
entryNum, NULL, EXPAND_SWITCH_UNKNOWN1, 0, mHeap, JKRDvdRipper::ALLOC_DIRECTION_FORWARD, 0,
&mCompression, &loadedSize);
entryNum, NULL, EXPAND_SWITCH_UNKNOWN1, 0, mHeap, JKRDvdRipper::ALLOC_DIRECTION_FORWARD,
0, &mCompression, &loadedSize);
if (mArcHeader) {
DCInvalidateRange(mArcHeader, loadedSize);
}
} else {
u32 loadedSize;
mArcHeader = (SArcHeader*)JKRDvdRipper::loadToMainRAM(
entryNum, NULL, EXPAND_SWITCH_UNKNOWN1, 0, mHeap, JKRDvdRipper::ALLOC_DIRECTION_BACKWARD, 0,
&mCompression, &loadedSize);
entryNum, NULL, EXPAND_SWITCH_UNKNOWN1, 0, mHeap,
JKRDvdRipper::ALLOC_DIRECTION_BACKWARD, 0, &mCompression, &loadedSize);
if (mArcHeader) {
DCInvalidateRange(mArcHeader, loadedSize);
}
@ -354,17 +275,6 @@ bool JKRMemArchive::removeResource(void* resource) {
return true;
}
/* ############################################################################################## */
/* 8039D160-8039D160 0297C0 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */
// #pragma push
// #pragma force_active on
// SECTION_DEAD static char const* const stringBase_8039D160 = "JKRMemArchive.cpp";
// SECTION_DEAD static char const* const stringBase_8039D172 = "%s";
// SECTION_DEAD static char const* const stringBase_8039D175 = "??? bad sequence\n";
// /* @stringBase0 padding */
// SECTION_DEAD static char const* const pad_8039D187 = "";
// #pragma pop
/* 802D6F5C-802D7030 2D189C 00D4+00 1/1 1/1 0/0 .text
* fetchResource_subroutine__13JKRMemArchiveFPUcUlPUcUli */
u32 JKRMemArchive::fetchResource_subroutine(u8* src, u32 srcLength, u8* dst, u32 dstLength,
@ -390,7 +300,7 @@ u32 JKRMemArchive::fetchResource_subroutine(u8* src, u32 srcLength, u8* dst, u32
return srcLength;
default: {
JUTException::panic_f("JKRMemArchive.cpp", 0x2d3, "%s", "??? bad sequence\n");
JUTException::panic_f(__FILE__, 723, "%s", "??? bad sequence\n");
} break;
}
@ -409,5 +319,3 @@ u32 JKRMemArchive::getExpandedResSize(const void* resource) const {
return JKRDecompExpandSize((SArcHeader*)resource);
}
}
/* 8039D160-8039D160 0297C0 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */

12
libs/JSystem/JKernel/JKRSolidHeap.cpp
View File

@ -149,8 +149,8 @@ void* JKRSolidHeap::do_alloc(u32 size, int alignment) {
// TODO(Julgodis): JUTAssertion::setConfirmMessage
if (alignment != 0) {
int u = abs(alignment);
JUT_ASSERT("JKRSolidHeap.cpp", 0xdb, u < 0x80);
JUT_ASSERT("JKRSolidHeap.cpp", 0xdc, JGadget::binary::isPower2(u));
JUT_ASSERT(__FILE__, 0xdb, u < 0x80);
JUT_ASSERT(__FILE__, 0xdc, JGadget::binary::isPower2(u));
}
#endif
@ -318,8 +318,8 @@ bool JKRSolidHeap::dump(void) {
// full match expect using the wrong register
#ifdef NONMATCHING
void JKRSolidHeap::state_register(JKRHeap::TState* p, u32 id) const {
JUT_ASSERT("JKRSolidHeap.cpp", 0x25c, p != 0);
JUT_ASSERT("JKRSolidHeap.cpp", 0x25d, p->getHeap() == this);
JUT_ASSERT(__FILE__, 0x25c, p != 0);
JUT_ASSERT(__FILE__, 0x25d, p->getHeap() == this);
getState_(p);
setState_u32ID_(p, id);
@ -340,7 +340,7 @@ asm void JKRSolidHeap::state_register(JKRHeap::TState* param_0, u32 param_1) con
/* 802D1258-802D1288 2CBB98 0030+00 1/0 0/0 0/0 .text
* state_compare__12JKRSolidHeapCFRCQ27JKRHeap6TStateRCQ27JKRHeap6TState */
bool JKRSolidHeap::state_compare(JKRHeap::TState const& r1, JKRHeap::TState const& r2) const {
JUT_ASSERT("JKRSolidHeap.cpp", 0x278, r1.getHeap() == r2.getHeap());
JUT_ASSERT(__FILE__, 632, r1.getHeap() == r2.getHeap());
bool result = true;
if (r1.getCheckCode() != r2.getCheckCode()) {
@ -373,5 +373,3 @@ void* JKRSolidHeap::do_getMaxFreeBlock(void) {
s32 JKRSolidHeap::do_getTotalFreeSize(void) {
return getFreeSize();
}
/* 8039CE50-8039CE50 0294B0 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */

36
libs/JSystem/JKernel/JKRThread.cpp
View File

@ -6,29 +6,9 @@
#include "JSystem/JKernel/JKRThread.h"
#include "JSystem/JKernel/JKRExpHeap.h"
#include "JSystem/JUtility/JUTAssert.h"
#include "JSystem/JUtility/JUTConsole.h"
#include "MSL_C/MSL_Common/Src/printf.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct JUTConsole {
/* 802E75EC */ void clear();
/* 802E7BB8 */ void print_f(char const*, ...);
/* 802E7C38 */ void print(char const*);
};
//
// External References:
//
extern "C" void JUTWarningConsole(const char*);
//
// Declarations:
//
/* 8043428C-80434298 060FAC 000C+00 5/6 0/0 0/0 .bss sThreadList__9JKRThread */
JSUList<JKRThread> JKRThread::sThreadList(0);
@ -164,7 +144,7 @@ JKRThreadSwitch::JKRThreadSwitch(JKRHeap* param_0) {
/* 802D1A14-802D1A70 2CC354 005C+00 0/0 1/1 0/0 .text createManager__15JKRThreadSwitchFP7JKRHeap
*/
JKRThreadSwitch* JKRThreadSwitch::createManager(JKRHeap* heap) {
JUT_ASSERT("JKRThread.cpp", 0x157, sManager == 0);
JUT_ASSERT(__FILE__, 343, sManager == 0);
if (!heap) {
heap = JKRGetCurrentHeap();
@ -245,8 +225,7 @@ void JKRThreadSwitch::callback(OSThread* current, OSThread* next) {
} else {
switch (thread->getCurrentHeapError()) {
case 0:
JUT_PANIC("JKRThread.cpp", 0x1fc,
"JKRThreadSwitch: currentHeap destroyed.");
JUT_PANIC(__FILE__, 508, "JKRThreadSwitch: currentHeap destroyed.");
break;
case 1:
JUTWarningConsole("JKRThreadSwitch: currentHeap destroyed.\n");
@ -345,13 +324,6 @@ void JKRThreadSwitch::draw(JKRThreadName_* thread_name_list) {
/* 802D1E4C-802D1E94 2CC78C 0048+00 1/0 0/0 0/0 .text __dt__15JKRThreadSwitchFv */
JKRThreadSwitch::~JKRThreadSwitch() {}
/* ############################################################################################## */
/* 80434298-804342A4 060FB8 000C+00 0/1 0/0 0/0 .bss @989 */
// #pragma push
// #pragma force_active on
// static u8 lit_989[12];
// #pragma pop
/* 804342A4-804342B0 060FC4 000C+00 0/1 0/0 0/0 .bss sTaskList__7JKRTask */
#pragma push
#pragma force_active on
@ -364,5 +336,3 @@ JSUList<JKRTask> JKRTask::sTaskList;
#pragma force_active on
u8 JKRTask::sEndMesgQueue[32];
#pragma pop
/* 8039CFA8-8039CFA8 029608 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */

2
libs/JSystem/JUtility/JUTConsole.cpp
View File

@ -501,5 +501,3 @@ void JUTWarningConsole_f(const char* fmt, ...) {
void JUTWarningConsole(const char* message) {
JUTReportConsole_f("%s", message);
}
/* 8039D9A8-8039D9A8 02A008 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */