mirror/tp
1
0
Fork 0
mirror of https://github.com/zeldaret/tp synced 2026-05-30 08:56:46 -04:00
Code Issues Packages Projects Releases Wiki Activity

JKernel debug (#3012)

Browse Source
This commit is contained in:
Jcw87
2026-01-04 17:22:56 -08:00
committed by GitHub
parent 1400687731
commit deb7bead20
51 changed files with 1169 additions and 971 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/JSystem/JKernel/JKRExpHeap.cpp
+258 -126
View File
@@ -5,19 +5,51 @@
#include "JSystem/JSystem.h" // IWYU pragma: keep
#include "JSystem/JKernel/JKRExpHeap.h"
#include "JSystem/JGadget/binary.h"
#include "JSystem/JSupport/JSupport.h"
#include "JSystem/JUtility/JUTConsole.h"
#include "JSystem/JUtility/JUTException.h"
#include <stdlib.h>
JKRExpHeap* JKRExpHeap::createRoot(int maxHeaps, bool errorFlag) {
JKRExpHeap* heap = NULL;
if (!sRootHeap) {
void* memory;
u32 memorySize;
initArena((char**)&memory, &memorySize, maxHeaps);
u8* start = (u8*)memory + ALIGN_NEXT(sizeof(JKRExpHeap), 0x10);
u32 alignedSize = memorySize - ALIGN_NEXT(sizeof(JKRExpHeap), 0x10);
heap = new (memory) JKRExpHeap(start, alignedSize, NULL, errorFlag);
#if !PLATFORM_GCN
u8* mem2;
u32 mem2Size;
initArena2((char**)&mem2, &mem2Size, 1);
u32 local_1c = ALIGN_NEXT(sizeof(JKRExpHeap), 0x10);
u8* local_20 = mem2 + local_1c;
u32 local_24 = mem2Size - local_1c;
#if DEBUG
if (local_20) {
u8* local_28 = local_20;
u32 local_2c = local_24;
if (isDefaultDebugFill()) {
JKRFillMemory(local_28, local_2c, JKRValue_DEBUGFILL_NOTUSE);
}
}
#endif
JKRExpHeap* heap2 = new (mem2) JKRExpHeap(local_20, local_24, NULL, errorFlag);
sRootHeap2 = heap2;
heap2->field_0x6e = true;
#endif
void* mem1;
u32 mem1Size;
initArena((char**)&mem1, &mem1Size, maxHeaps);
u32 local_3c = ALIGN_NEXT(sizeof(JKRExpHeap), 0x10);
u8* start1 = (u8*)mem1 + local_3c;
u32 alignedSize = mem1Size - local_3c;
#if DEBUG
if (start1) {
u8* local_4c = start1;
u32 local_48 = alignedSize;
if (isDefaultDebugFill()) {
JKRFillMemory(local_4c, local_48, JKRValue_DEBUGFILL_NOTUSE);
}
}
#endif
heap = new (mem1) JKRExpHeap(start1, alignedSize, NULL, errorFlag);
sRootHeap = heap;
}
heap->field_0x6e = true;
@@ -25,17 +57,20 @@ JKRExpHeap* JKRExpHeap::createRoot(int maxHeaps, bool errorFlag) {
}
JKRExpHeap* JKRExpHeap::create(u32 size, JKRHeap* parent, bool errorFlag) {
JKRExpHeap* newHeap = NULL;
if (!parent) {
parent = sRootHeap;
}
u32 expHeapSize = ALIGN_NEXT(sizeof(JKRExpHeap), 0x10);
u32 blockSize = sizeof(CMemBlock);
if (size == 0xffffffff) {
size = parent->getMaxAllocatableSize(0x10);
}
u32 alignedSize = ALIGN_PREV(size, 0x10);
u32 expHeapSize = ALIGN_NEXT(sizeof(JKRExpHeap), 0x10);
if (alignedSize < 0xa0)
if (alignedSize < expHeapSize + blockSize)
return NULL;
u8* memory = (u8*)JKRAllocFromHeap(parent, alignedSize, 0x10);
@@ -44,14 +79,21 @@ JKRExpHeap* JKRExpHeap::create(u32 size, JKRHeap* parent, bool errorFlag) {
return NULL;
}
JKRExpHeap* newHeap =
new (memory) JKRExpHeap(dataPtr, alignedSize - expHeapSize, parent, errorFlag);
newHeap = new (memory) JKRExpHeap(dataPtr, alignedSize - expHeapSize, parent, errorFlag);
if (newHeap == NULL) {
JKRFree(memory);
return NULL;
}
#if DEBUG
if (newHeap) {
u8* local_30 = dataPtr + sizeof(CMemBlock);
u32 local_34 = newHeap->mHeadFreeList->size;
if (isDefaultDebugFill()) {
JKRFillMemory(local_30, local_34, JKRValue_DEBUGFILL_NOTUSE);
}
}
#endif
newHeap->field_0x6e = false;
return newHeap;
}
@@ -59,7 +101,7 @@ JKRExpHeap* JKRExpHeap::create(u32 size, JKRHeap* parent, bool errorFlag) {
JKRExpHeap* JKRExpHeap::create(void* ptr, u32 size, JKRHeap* parent, bool errorFlag) {
JKRHeap* parent2;
if (parent == NULL) {
parent2 = sRootHeap->find(ptr);
parent2 = getRootHeap()->find(ptr);
if (!parent2)
return NULL;
} else {
@@ -71,12 +113,21 @@ JKRExpHeap* JKRExpHeap::create(void* ptr, u32 size, JKRHeap* parent, bool errorF
if (size < expHeapSize)
return NULL;
void* dataPtr = (u8*)ptr + expHeapSize;
u8* r28 = (u8*)ptr;
u8* dataPtr = r28 + expHeapSize;
u32 alignedSize = ALIGN_PREV((uintptr_t)ptr + size - (uintptr_t)dataPtr, 0x10);
if (ptr) {
newHeap = new (ptr) JKRExpHeap(dataPtr, alignedSize, parent2, errorFlag);
if (r28) {
newHeap = new (r28) JKRExpHeap(dataPtr, alignedSize, parent2, errorFlag);
}
#if DEBUG
if (newHeap) {
u8* local_30 = dataPtr + sizeof(CMemBlock);
u32 local_34 = newHeap->mHeadFreeList->size;
if (isDefaultDebugFill()) {
JKRFillMemory(local_30, local_34, JKRValue_DEBUGFILL_NOTUSE);
}
}
#endif
newHeap->field_0x6e = true;
newHeap->field_0x70 = ptr;
newHeap->field_0x74 = size;
@@ -85,13 +136,20 @@ JKRExpHeap* JKRExpHeap::create(void* ptr, u32 size, JKRHeap* parent, bool errorF
void JKRExpHeap::do_destroy() {
if (!field_0x6e) {
JKRHeap* heap = mChildTree.getParent()->getObject();
JKRHeap* heap = getParent();
if (heap) {
this->~JKRExpHeap();
JKRHeap::free(this, heap);
JKRFreeToHeap(heap, this);
}
} else {
u8* r28 = (u8*)field_0x70;
u32 r27 = field_0x74;
this->~JKRExpHeap();
#if DEBUG
if (mDebugFill) {
JKRFillMemory(r28, r27, JKRValue_DEBUGFILL_NOTUSE);
}
#endif
}
}
@@ -111,13 +169,21 @@ JKRExpHeap::~JKRExpHeap() {
}
void* JKRExpHeap::do_alloc(u32 size, int alignment) {
void* ptr;
#if DEBUG
if (alignment) {
u32 u = abs(alignment);
JUT_CONFIRM(356, u < 0x80);
JUT_CONFIRM(357, JGadget::binary::isPower2( u ));
}
#endif
lock();
if (size < 4) {
size = 4;
}
void* ptr = NULL;
if (alignment >= 0) {
if (alignment <= 4) {
ptr = allocFromHead(size);
@@ -131,10 +197,24 @@ void* JKRExpHeap::do_alloc(u32 size, int alignment) {
ptr = allocFromTail(size, -alignment);
}
}
#if DEBUG
if (ptr) {
CMemBlock* block = (CMemBlock*)((u8*)ptr - sizeof(CMemBlock));
if (mCheckMemoryFilled) {
JKRHeap::checkMemoryFilled((u8*)ptr, block->size, JKRValue_DEBUGFILL_DELETE);
}
if (mDebugFill) {
JKRFillMemory((u8*)ptr, block->size, JKRValue_DEBUGFILL_NEW);
}
if (block->getAlignment() && mDebugFill) {
JKRFillMemory((u8*)ptr - sizeof(CMemBlock) - block->getAlignment(), block->getAlignment(), JKRValue_DEBUGFILL_NEW);
}
}
#endif
if (ptr == NULL) {
JUTWarningConsole_f(":::cannot alloc memory (0x%x byte).\n", size);
if (mErrorFlag == true) {
if (getErrorFlag() == true) {
callErrorHandler(this, size, alignment);
}
}
@@ -156,14 +236,13 @@ static JKRExpHeap::CMemBlock* DBnewUsedBlock;
void* JKRExpHeap::allocFromHead(u32 size, int align) {
u32 foundOffset;
int foundSize;
CMemBlock* newFreeBlock;
CMemBlock* newUsedBlock;
CMemBlock* foundBlock;
size = ALIGN_NEXT(size, 4);
foundSize = -1;
foundOffset = 0;
foundBlock = NULL;
CMemBlock* foundBlock = NULL;
CMemBlock* newFreeBlock = NULL;
CMemBlock* newUsedBlock = NULL;
for (CMemBlock* block = mHeadFreeList; block; block = block->mNext) {
u32 offset =
@@ -183,8 +262,7 @@ void* JKRExpHeap::allocFromHead(u32 size, int align) {
break;
}
u32 blockSize = block->size;
if (blockSize == size) {
if (foundSize == size) {
break;
}
}
@@ -236,17 +314,12 @@ void* JKRExpHeap::allocFromHead(u32 size, int align) {
} else {
CMemBlock* prev = foundBlock->mPrev;
CMemBlock* next = foundBlock->mNext;
// Works but very fake match
size = (uintptr_t)foundBlock->allocFore(size, mCurrentGroupId, 0, 0, 0);
newFreeBlock = foundBlock->allocFore(size, mCurrentGroupId, 0, 0, 0);
removeFreeBlock(foundBlock);
if (size) {
setFreeBlock((CMemBlock*)size, prev, next);
if (newFreeBlock) {
setFreeBlock(newFreeBlock, prev, next);
}
// newFreeBlock = foundBlock->allocFore(size, mCurrentGroupId, 0, 0, 0);
// removeFreeBlock(foundBlock);
// if (newFreeBlock) {
// setFreeBlock(newFreeBlock, prev, next);
// }
appendUsedList(foundBlock);
return foundBlock->getContent();
}
@@ -260,16 +333,17 @@ void* JKRExpHeap::allocFromHead(u32 size) {
size = ALIGN_NEXT(size, 4);
s32 foundSize = -1;
CMemBlock* foundBlock = NULL;
for (CMemBlock* block = mHeadFreeList; block; block = block->getNextBlock()) {
if (block->getSize() < size) {
CMemBlock* newblock = NULL;
for (CMemBlock* block = mHeadFreeList; block; block = block->mNext) {
if (block->size < size) {
continue;
}
if (foundSize <= block->getSize()) {
if (foundSize <= block->size) {
continue;
}
foundSize = block->getSize();
foundSize = block->size;
foundBlock = block;
if (mAllocMode != 0) {
break;
@@ -281,9 +355,9 @@ void* JKRExpHeap::allocFromHead(u32 size) {
}
if (foundBlock) {
CMemBlock* newblock = foundBlock->allocFore(size, mCurrentGroupId, 0, 0, 0);
newblock = foundBlock->allocFore(size, mCurrentGroupId, 0, 0, 0);
if (newblock) {
setFreeBlock(newblock, foundBlock->getPrevBlock(), foundBlock->getNextBlock());
setFreeBlock(newblock, foundBlock->mPrev, foundBlock->mNext);
} else {
removeFreeBlock(foundBlock);
}
@@ -294,6 +368,7 @@ void* JKRExpHeap::allocFromHead(u32 size) {
}
void* JKRExpHeap::allocFromTail(u32 size, int align) {
u32 local_2c = 0;
u32 offset = 0;
CMemBlock* foundBlock = NULL;
CMemBlock* newBlock = NULL;
@@ -304,6 +379,7 @@ void* JKRExpHeap::allocFromTail(u32 size, int align) {
start = ALIGN_PREV((uintptr_t)block->getContent() + block->size - size, align);
usedSize = (uintptr_t)block->getContent() + block->size - start;
if (block->size >= usedSize) {
local_2c = usedSize;
foundBlock = block;
offset = block->size - usedSize;
newBlock = (CMemBlock*)start - 1;
@@ -336,18 +412,19 @@ void* JKRExpHeap::allocFromTail(u32 size, int align) {
}
void* JKRExpHeap::allocFromTail(u32 size) {
u32 size2 = ALIGN_NEXT(size, 4);
size = ALIGN_NEXT(size, 4);
CMemBlock* foundBlock = NULL;
for (CMemBlock* block = mTailFreeList; block; block = block->getPrevBlock()) {
if (block->getSize() >= size2) {
CMemBlock* freeBlock = NULL;
CMemBlock* usedBlock = NULL;
for (CMemBlock* block = mTailFreeList; block; block = block->mPrev) {
if (block->size >= size) {
foundBlock = block;
break;
}
}
if (foundBlock != NULL) {
CMemBlock* usedBlock = foundBlock->allocBack(size2, 0, 0, mCurrentGroupId, 0);
CMemBlock* freeBlock;
usedBlock = foundBlock->allocBack(size, 0, 0, mCurrentGroupId, 0);
if (usedBlock) {
freeBlock = foundBlock;
} else {
@@ -357,7 +434,7 @@ void* JKRExpHeap::allocFromTail(u32 size) {
}
if (freeBlock) {
setFreeBlock(freeBlock, foundBlock->getPrevBlock(), foundBlock->getNextBlock());
setFreeBlock(freeBlock, foundBlock->mPrev, foundBlock->mNext);
}
appendUsedList(usedBlock);
return usedBlock->getContent();
@@ -367,31 +444,42 @@ void* JKRExpHeap::allocFromTail(u32 size) {
void JKRExpHeap::do_free(void* ptr) {
lock();
if (getStartAddr() <= ptr && ptr <= getEndAddr()) {
if (mStart <= ptr && ptr <= mEnd) {
CMemBlock* block = CMemBlock::getHeapBlock(ptr);
if (block) {
block->free(this);
}
} else {
JUT_WARN(921, "free: memblock %x not in heap %x", ptr, this);
}
unlock();
}
static void dummy() {
OS_REPORT("newSize > 0");
}
void JKRExpHeap::do_freeAll() {
lock();
JKRHeap::callAllDisposer();
mHeadFreeList = (CMemBlock*)getStartAddr();
mHeadFreeList = (CMemBlock*)mStart;
mTailFreeList = mHeadFreeList;
mHeadFreeList->initiate(NULL, NULL, getSize() - 0x10, 0, 0);
mHeadFreeList->initiate(NULL, NULL, mSize - 0x10, 0, 0);
mHeadUsedList = NULL;
mTailUsedList = NULL;
#if DEBUG
if (mDebugFill) {
JKRFillMemory((u8*)(mHeadFreeList + 1), mHeadFreeList->size, JKRValue_DEBUGFILL_DELETE);
}
#endif
unlock();
}
void JKRExpHeap::do_freeTail() {
lock();
for (CMemBlock* block = mHeadUsedList; block != NULL;) {
if ((block->mFlags & 0x80) != 0) {
dispose(block + 1, block->size);
if (block->isTempMemBlock()) {
dispose(block->getContent(), block->size);
CMemBlock* temp = block->mNext;
block->free(this);
block = temp;
@@ -402,7 +490,15 @@ void JKRExpHeap::do_freeTail() {
unlock();
}
void JKRExpHeap::do_fillFreeArea() {}
void JKRExpHeap::do_fillFreeArea() {
#if DEBUG
lock();
for (CMemBlock* block = mHeadFreeList; block; block = block->mNext) {
JKRFillMemory((u8*)block->getContent(), block->size, JKRValue_DEBUGFILL_DELETE);
}
unlock();
#endif
}
s32 JKRExpHeap::do_changeGroupID(u8 param_0) {
lock();
@@ -445,6 +541,7 @@ s32 JKRExpHeap::do_resize(void* ptr, u32 size) {
return -1;
}
u32 local_24 = block->size;
removeFreeBlock(foundBlock);
block->size += foundBlock->size + sizeof(CMemBlock);
if (block->size - size > sizeof(CMemBlock)) {
@@ -453,6 +550,11 @@ s32 JKRExpHeap::do_resize(void* ptr, u32 size) {
recycleFreeBlock(newBlock);
}
}
#if DEBUG
if (mDebugFill) {
JKRFillMemory((u8*)ptr + local_24, block->size - local_24, JKRValue_DEBUGFILL_NEW);
}
#endif
} else {
if (block->size - size > sizeof(CMemBlock)) {
CMemBlock* freeBlock = block->allocFore(size, block->mGroupId, block->mFlags, 0, 0);
@@ -469,20 +571,20 @@ s32 JKRExpHeap::do_resize(void* ptr, u32 size) {
s32 JKRExpHeap::do_getSize(void* ptr) {
lock();
CMemBlock* block = CMemBlock::getHeapBlock(ptr);
if (!block || ptr < getStartAddr() || getEndAddr() < ptr) {
if (!block || ptr < mStart || mEnd < ptr) {
unlock();
return -1;
}
unlock();
return block->getSize();
return block->size;
}
s32 JKRExpHeap::do_getFreeSize() {
lock();
s32 size = 0;
for (CMemBlock* block = mHeadFreeList; block; block = block->getNextBlock()) {
if (size < (s32)block->getSize()) {
size = block->getSize();
for (CMemBlock* block = mHeadFreeList; block; block = block->mNext) {
if (size < (s32)block->size) {
size = block->size;
}
}
unlock();
@@ -493,9 +595,9 @@ void* JKRExpHeap::do_getMaxFreeBlock() {
lock();
s32 size = 0;
CMemBlock* res = NULL;
for (CMemBlock* block = mHeadFreeList; block; block = block->getNextBlock()) {
if (size < (s32)block->getSize()) {
size = block->getSize();
for (CMemBlock* block = mHeadFreeList; block; block = block->mNext) {
if (size < (s32)block->size) {
size = block->size;
res = block;
}
}
@@ -506,42 +608,46 @@ void* JKRExpHeap::do_getMaxFreeBlock() {
s32 JKRExpHeap::do_getTotalFreeSize() {
u32 size = 0;
lock();
for (CMemBlock* block = mHeadFreeList; block; block = block->getNextBlock()) {
size += block->getSize();
for (CMemBlock* block = mHeadFreeList; block; block = block->mNext) {
size += block->size;
}
unlock();
return size;
}
s32 JKRExpHeap::getUsedSize(u8 groupId) const {
JKRExpHeap* this2 = const_cast<JKRExpHeap*>(this);
this2->lock();
lock();
u32 size = 0;
for (CMemBlock* block = mHeadUsedList; block; block = block->getNextBlock()) {
u8 blockGroupId = block->getGroupId();
if (blockGroupId == groupId) {
size += block->getSize() + sizeof(CMemBlock);
for (CMemBlock* block = mHeadUsedList; block; block = block->mNext) {
if (block->mGroupId == groupId) {
size += block->size + sizeof(CMemBlock);
}
}
this2->unlock();
unlock();
return size;
}
s32 JKRExpHeap::getTotalUsedSize() const {
JKRExpHeap* this2 = const_cast<JKRExpHeap*>(this);
this2->lock();
lock();
u32 size = 0;
for (CMemBlock* block = mHeadUsedList; block; block = block->getNextBlock()) {
size += block->getSize() + sizeof(CMemBlock);
for (CMemBlock* block = mHeadUsedList; block; block = block->mNext) {
size += block->size + sizeof(CMemBlock);
}
this2->unlock();
unlock();
return size;
}
BOOL JKRExpHeap::isEmpty() {
lock();
BOOL result = !mHeadUsedList ? TRUE : FALSE;
unlock();
return result;
}
void JKRExpHeap::appendUsedList(JKRExpHeap::CMemBlock* newblock) {
if (!newblock) {
JUTException::panic(__FILE__, 1568, "bad appendUsedList\n");
@@ -621,18 +727,24 @@ void JKRExpHeap::removeUsedBlock(JKRExpHeap::CMemBlock* block) {
void JKRExpHeap::recycleFreeBlock(JKRExpHeap::CMemBlock* block) {
JKRExpHeap::CMemBlock* newBlock = block;
int size = block->size;
void* blockEnd = (u8*)block + size;
void* blockEnd = (u8*)newBlock + size;
block->mMagic = 0;
if ((block->mFlags & 0x7f) != 0) {
newBlock = (CMemBlock*)((u8*)block - (block->mFlags & 0x7f));
newBlock = (CMemBlock*)((u8*)newBlock - (block->mFlags & 0x7f));
size += (block->mFlags & 0x7f);
blockEnd = (u8*)newBlock + size;
newBlock->mGroupId = 0;
newBlock->mFlags = 0;
newBlock->size = size;
}
#if DEBUG
u8* local_24 = (u8*)(newBlock + 1);
u32 local_28 = newBlock->size;
if (mDebugFill) {
JKRFillMemory(local_24, local_28, JKRValue_DEBUGFILL_DELETE);
}
#endif
if (!mHeadFreeList) {
newBlock->initiate(NULL, NULL, size, 0, 0);
mHeadFreeList = newBlock;
@@ -676,13 +788,26 @@ void JKRExpHeap::joinTwoBlocks(CMemBlock* block) {
u32 nextAddr = (uintptr_t)next - (next->mFlags & 0x7f);
if (endAddr > nextAddr) {
JUTWarningConsole_f(":::Heap may be broken. (block = %x)", block);
JKRGetCurrentHeap()->dump();
OS_REPORT(":::block = %x\n", block);
OS_REPORT(":::joinTwoBlocks [%x %x %x][%x %x %x]\n", block, block->mFlags, block->size, block->mNext, block->mNext->mFlags, block->mNext->size);
OS_REPORT(":::: endAddr = %x\n", endAddr);
OS_REPORT(":::: nextAddr = %x\n", nextAddr);
JKRHeap* heap = JKRGetCurrentHeap();
heap->dump();
JUTException::panic(__FILE__, 1820, "Bad Block\n");
}
if (endAddr == nextAddr) {
block->size = next->size + sizeof(CMemBlock) + next->getAlignment() + block->size;
setFreeBlock(block, block->mPrev, next->mNext);
block->size = next->size + sizeof(CMemBlock) + (next->mFlags & 0x7f) + block->size;
CMemBlock* local_30 = next->mNext;
#if DEBUG
u8* local_34 = (u8*)next;
u32 local_38 = sizeof(CMemBlock);
if (mDebugFill) {
JKRFillMemory(local_34, local_38, JKRValue_DEBUGFILL_DELETE);
}
#endif
setFreeBlock(block, block->mPrev, local_30);
}
}
@@ -691,14 +816,14 @@ bool JKRExpHeap::check() {
int totalBytes = 0;
bool ok = true;
for (CMemBlock* block = mHeadUsedList; block; block = block->mNext) {
if (!block->isValid()) {
if (block->mMagic != 'HM') {
ok = false;
JUTWarningConsole_f(":::addr %08x: bad heap signature. (%c%c)\n", block,
JSUHiByte(block->mMagic), JSULoByte(block->mMagic));
}
if (block->mNext) {
if (!block->mNext->isValid()) {
if (block->mNext->mMagic != 'HM') {
ok = false;
JUTWarningConsole_f(":::addr %08x: bad next pointer (%08x)\nabort\n", block,
block->mNext);
@@ -739,6 +864,13 @@ bool JKRExpHeap::check() {
mTailFreeList);
}
}
#if DEBUG
if (mCheckMemoryFilled) {
u8* local_34 = (u8*)block->getContent();
u32 local_38 = block->size;
ok = JKRHeap::checkMemoryFilled(local_34, local_38, JKRValue_DEBUGFILL_DELETE);
}
#endif
}
if (totalBytes != mSize) {
@@ -768,7 +900,7 @@ bool JKRExpHeap::dump() {
}
for (CMemBlock* block = mHeadUsedList; block; block = block->mNext) {
if (!block->isValid()) {
if (block->mMagic != 'HM') {
JUTReportConsole_f("xxxxx %08x: -------- --- --- (-------- --------)\nabort\n",
block);
break;
@@ -794,8 +926,7 @@ bool JKRExpHeap::dump() {
freeCount++;
}
float percent = ((float)usedBytes / (float)mSize) * 100.0f;
JUTReportConsole_f("%d / %d bytes (%6.2f%%) used (U:%d F:%d)\n", usedBytes, mSize, percent,
JUTReportConsole_f("%d / %d bytes (%6.2f%%) used (U:%d F:%d)\n", usedBytes, mSize, (f32(usedBytes) / f32(mSize)) * 100.0f,
usedCount, freeCount);
unlock();
return result;
@@ -822,21 +953,18 @@ bool JKRExpHeap::dump_sort() {
}
}
if (block == (CMemBlock*)0xffffffff) {
if (uintptr_t(block) == 0xffffffff) {
break;
}
if (!block->isValid()) {
if (block->mMagic != 'HM') {
JUTReportConsole_f("xxxxx %08x: -------- --- --- (-------- --------)\nabort\n",
var1);
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->size,
block->getGroupId(), offset, block->mPrev, block->mNext);
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++;
var1 = block;
@@ -850,13 +978,12 @@ bool JKRExpHeap::dump_sort() {
for (CMemBlock* block = mHeadFreeList; block; block = block->mNext) {
JUTReportConsole_f("%s %08x: %08x %3d %3d (%08x %08x)\n", " free", block->getContent(),
block->size, block->getGroupId(), block->getAlignment(), block->mPrev,
block->size, block->mGroupId, block->getAlignment(), block->mPrev,
block->mNext);
freeCount++;
}
float percent = ((float)usedBytes / (float)mSize) * 100.0f;
JUTReportConsole_f("%d / %d bytes (%6.2f%%) used (U:%d F:%d)\n", usedBytes, mSize, percent,
JUTReportConsole_f("%d / %d bytes (%6.2f%%) used (U:%d F:%d)\n", usedBytes, mSize, (f32(usedBytes) / f32(mSize)) * 100.0f,
usedCount, freeCount);
unlock();
return result;
@@ -872,33 +999,33 @@ void JKRExpHeap::CMemBlock::initiate(JKRExpHeap::CMemBlock* prev, JKRExpHeap::CM
mNext = next;
}
JKRExpHeap::CMemBlock* JKRExpHeap::CMemBlock::allocFore(u32 size, u8 groupId1, u8 alignment1,
JKRExpHeap::CMemBlock* JKRExpHeap::CMemBlock::allocFore(u32 size1, u8 groupId1, u8 alignment1,
u8 groupId2, u8 alignment2) {
CMemBlock* block = NULL;
mGroupId = groupId1;
mFlags = alignment1;
if (getSize() >= size + sizeof(CMemBlock)) {
block = (CMemBlock*)(size + (uintptr_t)this);
if (size >= size1 + sizeof(CMemBlock)) {
block = (CMemBlock*)(size1 + (uintptr_t)this);
block[1].mGroupId = groupId2;
block[1].mFlags = alignment2;
block[1].size = this->size - (size + sizeof(CMemBlock));
this->size = size;
block[1].size = size - (size1 + sizeof(CMemBlock));
size = size1;
block = block + 1;
}
return block;
}
JKRExpHeap::CMemBlock* JKRExpHeap::CMemBlock::allocBack(u32 size, u8 groupId1, u8 alignment1,
JKRExpHeap::CMemBlock* JKRExpHeap::CMemBlock::allocBack(u32 size1, u8 groupId1, u8 alignment1,
u8 groupId2, u8 alignment2) {
CMemBlock* newblock = NULL;
if (getSize() >= size + sizeof(CMemBlock)) {
newblock = (CMemBlock*)((uintptr_t)this + getSize() - size);
if (size >= size1 + sizeof(CMemBlock)) {
newblock = (CMemBlock*)((uintptr_t)this + size - size1);
newblock->mGroupId = groupId2;
newblock->mFlags = alignment2 | 0x80;
newblock->size = size;
newblock->size = size1;
mGroupId = groupId1;
mFlags = alignment1;
this->size -= size + sizeof(CMemBlock);
this->size -= size1 + sizeof(CMemBlock);
} else {
mGroupId = groupId2;
mFlags = 0x80;
@@ -922,36 +1049,51 @@ JKRExpHeap::CMemBlock* JKRExpHeap::CMemBlock::getHeapBlock(void* ptr) {
return NULL;
}
static void dummy2() {
DEAD_STRING("+---------------JKRExpHeap\n");
DEAD_STRING("| Align Group size ( prev , next )\n");
DEAD_STRING("| ---- FreeFirst\n");
DEAD_STRING("| %08x ");
DEAD_STRING("%2x %3d %6x (%08x %08x)\n");
DEAD_STRING("| ---- FreeLast\n");
DEAD_STRING("| ---- UsedFirst\n");
DEAD_STRING("| ---- UsedLast\n");
DEAD_STRING("+---------------End\n");
}
void JKRExpHeap::state_register(JKRHeap::TState* p, u32 param_1) const {
p->mId = param_1;
JUT_ASSERT(2433, p != NULL);
JUT_ASSERT(2434, p->getHeap() == this);
void* r24 = getState_(p);
u32 r25 = param_1;
setState_u32ID_(p, param_1);
if (param_1 <= 0xff) {
p->mUsedSize = getUsedSize(param_1);
setState_uUsedSize_(p, getUsedSize(r25));
} else {
s32 freeSize = const_cast<JKRExpHeap*>(this)->getTotalFreeSize();
p->mUsedSize = getSize() - freeSize;
setState_uUsedSize_(p, getUsedSize_(const_cast<JKRExpHeap*>(this)));
}
u32 checkCode = 0;
for (CMemBlock* block = mHeadUsedList; block; block = block->getNextBlock()) {
for (CMemBlock* block = mHeadUsedList; block; block = block->mNext) {
if (param_1 <= 0xff) {
u8 groupId = block->getGroupId();
if (groupId == param_1) {
if (block->mGroupId == param_1) {
checkCode += (uintptr_t)block * 3;
}
} else {
checkCode += (uintptr_t)block * 3;
}
}
p->mCheckCode = checkCode;
setState_u32CheckCode_(p, checkCode);
}
bool JKRExpHeap::state_compare(JKRHeap::TState const& r1, JKRHeap::TState const& r2) const {
JUT_ASSERT(2481, r1.getHeap() == r2.getHeap());
bool result = true;
if (r1.mCheckCode != r2.mCheckCode) {
if (r1.getCheckCode() != r2.getCheckCode()) {
result = false;
}
if (r1.mUsedSize != r2.mUsedSize) {
if (r1.getUsedSize() != r2.getUsedSize()) {
result = false;
}
@@ -965,13 +1107,3 @@ u32 JKRExpHeap::getHeapType() {
u8 JKRExpHeap::do_getCurrentGroupId() {
return mCurrentGroupId;
}
static char* dummyLiteral1() { return "+---------------JKRExpHeap\n"; }
static char* dummyLiteral2() { return "| Align Group size ( prev , next )\n"; }
static char* dummyLiteral3() { return "| ---- FreeFirst\n"; }
static char* dummyLiteral4() { return "| %08x "; }
static char* dummyLiteral5() { return "%2x %3d %6x (%08x %08x)\n"; }
static char* dummyLiteral6() { return "| ---- FreeLast\n"; }
static char* dummyLiteral7() { return "| ---- UsedFirst\n"; }
static char* dummyLiteral8() { return "| ---- UsedLast\n"; }
static char* dummyLiteral9() { return "+---------------End\n"; }