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

1321 lines
45 KiB
C++
Raw Blame History

//
// Generated By: dol2asm
// Translation Unit: JKRExpHeap
//
#include "JSystem/JKernel/JKRExpHeap.h"
#include "JSystem/JUtility/JUTException.h"
#include "dol2asm.h"
#include "dolphin/types.h"
#include "global.h"
//
// Forward References:
//
extern "C" void createRoot__10JKRExpHeapFib();
extern "C" void create__10JKRExpHeapFUlP7JKRHeapb();
extern "C" void create__10JKRExpHeapFPvUlP7JKRHeapb();
extern "C" void do_destroy__10JKRExpHeapFv();
extern "C" void __ct__10JKRExpHeapFPvUlP7JKRHeapb();
extern "C" void __dt__10JKRExpHeapFv();
extern "C" void do_alloc__10JKRExpHeapFUli();
extern "C" void allocFromHead__10JKRExpHeapFUli();
extern "C" void allocFromHead__10JKRExpHeapFUl();
extern "C" void allocFromTail__10JKRExpHeapFUli();
extern "C" void allocFromTail__10JKRExpHeapFUl();
extern "C" void do_free__10JKRExpHeapFPv();
extern "C" void do_freeAll__10JKRExpHeapFv();
extern "C" void do_freeTail__10JKRExpHeapFv();
extern "C" void do_fillFreeArea__10JKRExpHeapFv();
extern "C" void do_changeGroupID__10JKRExpHeapFUc();
extern "C" void do_resize__10JKRExpHeapFPvUl();
extern "C" void do_getSize__10JKRExpHeapFPv();
extern "C" void do_getFreeSize__10JKRExpHeapFv();
extern "C" void do_getMaxFreeBlock__10JKRExpHeapFv();
extern "C" void do_getTotalFreeSize__10JKRExpHeapFv();
extern "C" void getUsedSize__10JKRExpHeapCFUc();
extern "C" void getTotalUsedSize__10JKRExpHeapCFv();
extern "C" void appendUsedList__10JKRExpHeapFPQ210JKRExpHeap9CMemBlock();
extern "C" void
setFreeBlock__10JKRExpHeapFPQ210JKRExpHeap9CMemBlockPQ210JKRExpHeap9CMemBlockPQ210JKRExpHeap9CMemBlock();
extern "C" void removeFreeBlock__10JKRExpHeapFPQ210JKRExpHeap9CMemBlock();
extern "C" void removeUsedBlock__10JKRExpHeapFPQ210JKRExpHeap9CMemBlock();
extern "C" void recycleFreeBlock__10JKRExpHeapFPQ210JKRExpHeap9CMemBlock();
extern "C" void joinTwoBlocks__10JKRExpHeapFPQ210JKRExpHeap9CMemBlock();
extern "C" void check__10JKRExpHeapFv();
extern "C" void dump__10JKRExpHeapFv();
extern "C" void dump_sort__10JKRExpHeapFv();
extern "C" void
initiate__Q210JKRExpHeap9CMemBlockFPQ210JKRExpHeap9CMemBlockPQ210JKRExpHeap9CMemBlockUlUcUc();
extern "C" void allocFore__Q210JKRExpHeap9CMemBlockFUlUcUcUcUc();
extern "C" void allocBack__Q210JKRExpHeap9CMemBlockFUlUcUcUcUc();
extern "C" void free__Q210JKRExpHeap9CMemBlockFP10JKRExpHeap();
extern "C" void getHeapBlock__Q210JKRExpHeap9CMemBlockFPv();
extern "C" void state_register__10JKRExpHeapCFPQ27JKRHeap6TStateUl();
extern "C" void state_compare__10JKRExpHeapCFRCQ27JKRHeap6TStateRCQ27JKRHeap6TState();
extern "C" void getHeapType__10JKRExpHeapFv();
extern "C" void do_getCurrentGroupId__10JKRExpHeapFv();
extern "C" extern char const* const JKRExpHeap__stringBase0;
//
// External References:
//
extern "C" void __ct__7JKRHeapFPvUlP7JKRHeapb();
extern "C" void __dt__7JKRHeapFv();
extern "C" void initArena__7JKRHeapFPPcPUli();
extern "C" void alloc__7JKRHeapFUliP7JKRHeap();
extern "C" void free__7JKRHeapFPvP7JKRHeap();
extern "C" void callAllDisposer__7JKRHeapFv();
extern "C" void getTotalFreeSize__7JKRHeapFv();
extern "C" void getMaxAllocatableSize__7JKRHeapFi();
extern "C" void find__7JKRHeapCFPv();
extern "C" void dispose__7JKRHeapFPvUl();
extern "C" void dispose__7JKRHeapFv();
extern "C" void __dl__FPv();
extern "C" void state_dump__7JKRHeapCFRCQ27JKRHeap6TState();
extern "C" void panic_f__12JUTExceptionFPCciPCce();
extern "C" void JUTReportConsole_f(const char*, ...);
extern "C" void JUTReportConsole(const char*);
extern "C" void JUTWarningConsole_f(const char*, ...);
extern "C" void JUTWarningConsole(const char*);
extern "C" void _savegpr_25();
extern "C" void _savegpr_27();
extern "C" void _savegpr_28();
extern "C" void _savegpr_29();
extern "C" void _restgpr_25();
extern "C" void _restgpr_27();
extern "C" void _restgpr_28();
extern "C" void _restgpr_29();
extern "C" u8 sCurrentHeap__7JKRHeap[4];
extern "C" u8 sRootHeap__7JKRHeap[4];
extern "C" u8 mErrorHandler__7JKRHeap[4];
//
// Declarations:
//
/* 802CEDB4-802CEE2C 2C96F4 0078+00 0/0 1/1 0/0 .text createRoot__10JKRExpHeapFib */
JKRExpHeap* JKRExpHeap::createRoot(int param_0, bool errorFlag) {
JKRExpHeap* heap = NULL;
if (!sRootHeap) {
void* memory;
u32 memorySize;
initArena((char**)&memory, &memorySize, param_0);
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);
sRootHeap = heap;
}
heap->field_0x6e = true;
return heap;
}
/* 802CEE2C-802CEF00 2C976C 00D4+00 0/0 19/19 1/1 .text create__10JKRExpHeapFUlP7JKRHeapb
*/
#if NONMATCHING
JKRExpHeap* JKRExpHeap::create(u32 size, JKRHeap* parent, bool errorFlag) {
if (!parent) {
parent = sRootHeap;
}
if (size == 0xffffffff) {
size = parent->getMaxAllocatableSize(0x10);
}
u32 alignedSize = ALIGN_PREV(size, 0x10);
u32 expHeapSize = ALIGN_NEXT(sizeof(JKRExpHeap), 0x10);
if (alignedSize < 0xa0)
return NULL;
void* memory = alloc(alignedSize, 0x10, parent);
void* dataPtr = (u8*)memory + expHeapSize;
if (!memory) {
return NULL;
}
JKRExpHeap* newHeap =
new (memory) JKRExpHeap(dataPtr, alignedSize - expHeapSize, parent, errorFlag);
if (newHeap == NULL) {
free(memory, NULL);
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
*/
JKRExpHeap* JKRExpHeap::create(void* ptr, u32 size, JKRHeap* parent, bool errorFlag) {
JKRHeap* parent2;
if (parent == NULL) {
parent2 = sRootHeap->find(ptr);
if (!parent2)
return NULL;
} 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;
return newHeap;
}
/* 802CEFAC-802CF030 2C98EC 0084+00 1/0 0/0 0/0 .text do_destroy__10JKRExpHeapFv */
void JKRExpHeap::do_destroy() {
if (!field_0x6e) {
JKRHeap* heap = mChildTree.getParent()->getObject();
if (heap) {
this->~JKRExpHeap();
JKRHeap::free(this, heap);
}
} else {
this->~JKRExpHeap();
}
}
/* ############################################################################################## */
/* 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)
: JKRHeap(data, size, parent, errorFlag) {
field_0x6c = 0;
mCurrentGroupId = 0xff;
mHeadFreeList = (CMemBlock*)data;
mTailFreeList = mHeadFreeList;
mHeadFreeList->initiate(NULL, NULL, size - sizeof(CMemBlock), 0, 0);
mHeadUsedList = NULL;
mTailUsedList = NULL;
}
/* 802CF0C0-802CF128 2C9A00 0068+00 1/0 0/0 0/0 .text __dt__10JKRExpHeapFv */
JKRExpHeap::~JKRExpHeap() {
dispose();
}
/* 802CF128-802CF234 2C9A68 010C+00 1/0 0/0 0/0 .text do_alloc__10JKRExpHeapFUli */
void* JKRExpHeap::do_alloc(u32 size, int alignment) {
void* ptr;
lock();
if (size < 4) {
size = 4;
}
if (alignment >= 0) {
if (alignment <= 4) {
ptr = allocFromHead(size);
} else {
ptr = allocFromHead(size, alignment);
}
} else {
if (-alignment <= 4) {
ptr = allocFromTail(size);
} else {
ptr = allocFromTail(size, -alignment);
}
}
if (ptr == NULL) {
JUTWarningConsole_f(":::cannot alloc memory (0x%x byte).\n", size);
if (mErrorFlag == true) {
callErrorHandler(this, size, alignment);
}
}
unlock();
return ptr;
}
/* ############################################################################################## */
/* 80451398-8045139C 000898 0004+00 1/1 0/0 0/0 .sbss DBfoundSize */
static u32 DBfoundSize;
/* 8045139C-804513A0 00089C 0004+00 1/1 0/0 0/0 .sbss DBfoundOffset */
static u32 DBfoundOffset;
/* 804513A0-804513A4 0008A0 0004+00 1/1 0/0 0/0 .sbss DBfoundBlock */
static JKRExpHeap::CMemBlock* DBfoundBlock;
/* 804513A4-804513A8 0008A4 0004+00 1/1 0/0 0/0 .sbss DBnewFreeBlock */
static JKRExpHeap::CMemBlock* DBnewFreeBlock;
/* 804513A8-804513B0 0008A8 0004+04 1/1 0/0 0/0 .sbss DBnewUsedBlock */
static JKRExpHeap::CMemBlock* DBnewUsedBlock;
/* 802CF234-802CF490 2C9B74 025C+00 1/1 0/0 0/0 .text allocFromHead__10JKRExpHeapFUli */
#if NONMATCHING
void* JKRExpHeap::allocFromHead(u32 size, int align) {
size = ALIGN_NEXT(size, 4);
s32 foundSize = -1;
u32 foundOffset = 0;
CMemBlock* foundBlock = NULL;
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) {
continue;
}
if (foundSize <= block->getSize()) {
continue;
}
foundSize = block->getSize();
foundBlock = block;
foundOffset = offset;
if (field_0x6c != 0) {
break;
}
u32 blockSize = block->getSize();
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;
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();
removeFreeBlock(foundBlock);
CMemBlock* newUsedBlock = (CMemBlock*)((u32)foundBlock + foundOffset);
newUsedBlock->size = foundBlock->getSize() - foundOffset;
CMemBlock* newFreeBlock =
newUsedBlock->allocFore(size, mCurrentGroupId, (u8)foundOffset, 0, 0);
if (newFreeBlock) {
setFreeBlock(newFreeBlock, prev, next);
}
appendUsedList(newUsedBlock);
return newUsedBlock->getContent();
} else {
CMemBlock* prev = foundBlock->getPrevBlock();
CMemBlock* next = foundBlock->getNextBlock();
CMemBlock* newFreeBlock = foundBlock->allocFore(size, mCurrentGroupId, 0, 0, 0);
removeFreeBlock(foundBlock);
if (newFreeBlock) {
setFreeBlock(newFreeBlock, prev, next);
}
appendUsedList(foundBlock);
return foundBlock->getContent();
}
}
}
return NULL;
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void* JKRExpHeap::allocFromHead(u32 param_0, int param_1) {
nofralloc
#include "asm/JSystem/JKernel/JKRExpHeap/allocFromHead__10JKRExpHeapFUli.s"
}
#pragma pop
#endif
/* 802CF490-802CF574 2C9DD0 00E4+00 1/1 0/0 0/0 .text allocFromHead__10JKRExpHeapFUl */
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) {
continue;
}
if (foundSize <= block->getSize()) {
continue;
}
foundSize = block->getSize();
foundBlock = block;
if (field_0x6c != 0) {
break;
}
if (foundSize == size) {
break;
}
}
if (foundBlock) {
CMemBlock* newblock = foundBlock->allocFore(size, mCurrentGroupId, 0, 0, 0);
if (newblock) {
setFreeBlock(newblock, foundBlock->getPrevBlock(), foundBlock->getNextBlock());
} else {
removeFreeBlock(foundBlock);
}
appendUsedList(foundBlock);
return foundBlock->getContent();
}
return NULL;
}
/* 802CF574-802CF6D4 2C9EB4 0160+00 1/1 0/0 0/0 .text allocFromTail__10JKRExpHeapFUli */
#if 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) {
foundBlock = block;
offset = block->getSize() - usedSize;
newBlock = (CMemBlock*)start - 1;
break;
}
}
if (foundBlock != NULL) {
if (offset >= sizeof(CMemBlock)) {
newBlock->initiate(NULL, NULL, usedSize, mCurrentGroupId, -0x80);
foundBlock->size = foundBlock->size - usedSize - sizeof(CMemBlock);
appendUsedList(newBlock);
return newBlock->getContent();
} else {
if (offset != 0) {
removeFreeBlock(foundBlock);
newBlock->initiate(NULL, NULL, usedSize, mCurrentGroupId, offset | 0x80);
appendUsedList(newBlock);
return newBlock->getContent();
} else {
removeFreeBlock(foundBlock);
newBlock->initiate(NULL, NULL, usedSize, mCurrentGroupId, -0x80);
appendUsedList(newBlock);
return newBlock->getContent();
}
}
}
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) {
u32 size2 = ALIGN_NEXT(size, 4);
CMemBlock* foundBlock = NULL;
for (CMemBlock* block = mTailFreeList; block; block = block->getPrevBlock()) {
if (block->getSize() >= size2) {
foundBlock = block;
break;
}
}
if (foundBlock != NULL) {
CMemBlock* usedBlock = foundBlock->allocBack(size2, 0, 0, mCurrentGroupId, 0);
CMemBlock* freeBlock;
if (usedBlock) {
freeBlock = foundBlock;
} else {
removeFreeBlock(foundBlock);
usedBlock = foundBlock;
freeBlock = NULL;
}
if (freeBlock) {
setFreeBlock(freeBlock, foundBlock->getPrevBlock(), foundBlock->getNextBlock());
}
appendUsedList(usedBlock);
return usedBlock->getContent();
}
return NULL;
}
/* 802CF7AC-802CF820 2CA0EC 0074+00 1/0 0/0 0/0 .text do_free__10JKRExpHeapFPv */
void JKRExpHeap::do_free(void* ptr) {
lock();
if (getStartAddr() <= ptr && ptr <= getEndAddr()) {
CMemBlock* block = CMemBlock::getHeapBlock(ptr);
if (block) {
block->free(this);
}
}
unlock();
}
/* 802CF820-802CF89C 2CA160 007C+00 1/0 0/0 0/0 .text do_freeAll__10JKRExpHeapFv */
void JKRExpHeap::do_freeAll() {
lock();
JKRHeap::callAllDisposer();
mHeadFreeList = (CMemBlock*)getStartAddr();
mTailFreeList = mHeadFreeList;
mHeadFreeList->initiate(NULL, NULL, getSize() - 0x10, 0, 0);
mHeadUsedList = NULL;
mTailUsedList = NULL;
unlock();
}
/* 802CF89C-802CF924 2CA1DC 0088+00 1/0 0/0 0/0 .text do_freeTail__10JKRExpHeapFv */
#if NONMATCHING
void JKRExpHeap::do_freeTail() {
lock();
CMemBlock* block = mHeadUsedList;
while (block) {
if (block->_isTempMemBlock()) {
dispose(block->getContent(), block->getSize());
CMemBlock* next = block->getNextBlock();
block->free(this);
block = next;
} else {
block = block->getNextBlock();
}
}
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 */
}
/* 802CF928-802CF978 2CA268 0050+00 1/0 0/0 0/0 .text do_changeGroupID__10JKRExpHeapFUc
*/
u8 JKRExpHeap::do_changeGroupID(u8 param_0) {
lock();
u8 prev = mCurrentGroupId;
mCurrentGroupId = param_0;
unlock();
return prev;
}
/* 802CF978-802CFB24 2CA2B8 01AC+00 1/0 0/0 0/0 .text do_resize__10JKRExpHeapFPvUl */
#if NONMATCHING
s32 JKRExpHeap::do_resize(void* ptr, u32 size) {
lock();
CMemBlock* block = CMemBlock::getHeapBlock(ptr);
if (block == NULL || ptr < getStartAddr() || getEndAddr() < ptr) {
unlock();
return -1;
}
u32 newSize = ALIGN_NEXT(size, 4);
if (newSize == block->getSize()) {
unlock();
return newSize;
}
if (newSize > block->getSize()) {
CMemBlock* foundBlock = NULL;
for (CMemBlock* freeBlock = mHeadFreeList; freeBlock;
freeBlock = freeBlock->getNextBlock()) {
if (freeBlock == (CMemBlock*)((u32)block->getContent() + block->getSize())) {
foundBlock = freeBlock;
break;
}
}
if (foundBlock == NULL) {
unlock();
return -1;
}
if (newSize > block->getSize() + sizeof(CMemBlock) + foundBlock->getSize()) {
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);
if (newBlock) {
recycleFreeBlock(newBlock);
}
}
} else {
if (block->getSize() - newSize > 0x10) {
CMemBlock* freeBlock =
block->allocFore(newSize, block->getGroupId(), block->mFlags, 0, 0);
if (freeBlock) {
recycleFreeBlock(freeBlock);
}
}
}
unlock();
return block->getSize();
}
#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) {
lock();
CMemBlock* block = CMemBlock::getHeapBlock(ptr);
if (!block || ptr < getStartAddr() || getEndAddr() < ptr) {
unlock();
return -1;
}
unlock();
return block->getSize();
}
/* 802CFBA4-802CFC10 2CA4E4 006C+00 1/0 0/0 0/0 .text do_getFreeSize__10JKRExpHeapFv */
s32 JKRExpHeap::do_getFreeSize() {
lock();
s32 size = 0;
for (CMemBlock* block = mHeadFreeList; block; block = block->getNextBlock()) {
if (size < (s32)block->getSize()) {
size = block->getSize();
}
}
unlock();
return size;
}
/* 802CFC10-802CFC84 2CA550 0074+00 1/0 0/0 0/0 .text do_getMaxFreeBlock__10JKRExpHeapFv
*/
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();
res = block;
}
}
unlock();
return res;
}
/* 802CFC84-802CFCE8 2CA5C4 0064+00 1/0 0/0 0/0 .text do_getTotalFreeSize__10JKRExpHeapFv
*/
s32 JKRExpHeap::do_getTotalFreeSize() {
u32 size = 0;
lock();
for (CMemBlock* block = mHeadFreeList; block; block = block->getNextBlock()) {
size += block->getSize();
}
unlock();
return size;
}
/* 802CFCE8-802CFD64 2CA628 007C+00 1/1 0/0 0/0 .text getUsedSize__10JKRExpHeapCFUc */
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;
}
/* 802CFD64-802CFDCC 2CA6A4 0068+00 0/0 5/5 0/0 .text getTotalUsedSize__10JKRExpHeapCFv
*/
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;
}
/* 802CFDCC-802CFE68 2CA70C 009C+00 4/4 0/0 0/0 .text
* appendUsedList__10JKRExpHeapFPQ210JKRExpHeap9CMemBlock */
void JKRExpHeap::appendUsedList(JKRExpHeap::CMemBlock* newblock) {
if (!newblock) {
JUTException::panic_f("JKRExpHeap.cpp", 0x620, "%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;
}
newblock->mNext = NULL;
}
/* 802CFE68-802CFEB4 2CA7A8 004C+00 5/5 0/0 0/0 .text
* setFreeBlock__10JKRExpHeapFPQ210JKRExpHeap9CMemBlockPQ210JKRExpHeap9CMemBlockPQ210JKRExpHeap9CMemBlock
*/
void JKRExpHeap::setFreeBlock(CMemBlock* block, CMemBlock* prev, CMemBlock* next) {
if (prev == NULL) {
mHeadFreeList = block;
block->mPrev = NULL;
} else {
prev->mNext = block;
block->mPrev = prev;
}
if (next == NULL) {
mTailFreeList = block;
block->mNext = NULL;
} else {
next->mPrev = block;
block->mNext = next;
}
block->mMagic = 0;
}
/* 802CFEB4-802CFEE8 2CA7F4 0034+00 5/5 0/0 0/0 .text
* removeFreeBlock__10JKRExpHeapFPQ210JKRExpHeap9CMemBlock */
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 {
next->mPrev = prev;
}
}
/* 802CFEE8-802CFF1C 2CA828 0034+00 1/1 0/0 0/0 .text
* removeUsedBlock__10JKRExpHeapFPQ210JKRExpHeap9CMemBlock */
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 {
next->mPrev = prev;
}
}
/* 802CFF1C-802D00B4 2CA85C 0198+00 2/2 0/0 0/0 .text
* recycleFreeBlock__10JKRExpHeapFPQ210JKRExpHeap9CMemBlock */
#if NONMATCHING
void JKRExpHeap::recycleFreeBlock(JKRExpHeap::CMemBlock* block) {
u32 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 (!mHeadFreeList) {
block->initiate(NULL, NULL, size, 0, 0);
mHeadFreeList = block;
mTailFreeList = block;
setFreeBlock(block, NULL, NULL);
return;
}
if (mHeadFreeList >= blockEnd) {
block->initiate(NULL, NULL, size, 0, 0);
setFreeBlock(block, NULL, mHeadFreeList);
joinTwoBlocks(block);
return;
}
if (mTailFreeList <= block) {
block->initiate(NULL, NULL, size, 0, 0);
setFreeBlock(block, mTailFreeList, NULL);
joinTwoBlocks(block->getPrevBlock());
return;
}
for (CMemBlock* freeBlock = mHeadFreeList; freeBlock; freeBlock = freeBlock->getNextBlock()) {
if (freeBlock >= block || block >= freeBlock->getNextBlock()) {
continue;
}
block->mNext = freeBlock->getNextBlock();
block->mPrev = freeBlock;
freeBlock->mNext = block;
block->mNext->mPrev = block;
block->mGroupId = 0;
joinTwoBlocks(block);
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 */
#if NONMATCHING
void JKRExpHeap::joinTwoBlocks(CMemBlock* block) {
u32 endAddr = (u32)block->getContent() + block->getSize();
CMemBlock* next = block->getNextBlock();
u32 nextAddr = (u32)next - next->getAlignment();
if (endAddr > nextAddr) {
JUTWarningConsole_f(":::Heap may be broken. (block = %x)", block);
getCurrentHeap()->dump();
JUTException::panic_f("JKRExpHeap.cpp", 0x71c, "%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
/* 802D0190-802D03B8 2CAAD0 0228+00 1/0 0/0 0/0 .text check__10JKRExpHeapFv */
#if NONMATCHING
bool JKRExpHeap::check() {
lock();
int totalBytes = 0;
bool ok = true;
for (CMemBlock* block = mHeadUsedList; block; block = block->getNextBlock()) {
if (!block->isValid()) {
ok = false;
JUTWarningConsole_f(":::addr %08x: bad heap signature. (%c%c)\n", block,
block->mMagic >> 8, block->mMagic & 0xff);
}
if (block->getNextBlock()) {
if (!block->getNextBlock()->isValid()) {
ok = false;
JUTWarningConsole_f(":::addr %08x: bad next pointer (%08x)\nabort\n", block,
block->getNextBlock());
break;
}
if (block->getNextBlock()->getPrevBlock() != block) {
ok = false;
JUTWarningConsole_f(":::addr %08x: bad previous pointer (%08x)\n",
block->getNextBlock(), block->getNextBlock()->getPrevBlock());
}
} else {
if (mTailUsedList != block) {
ok = false;
JUTWarningConsole_f(":::addr %08x: bad used list(REV) (%08x)\n", block,
mTailUsedList);
}
}
totalBytes += sizeof(CMemBlock) + block->getSize() + block->getAlignment();
}
for (CMemBlock* block = mHeadFreeList; block; block = block->getNextBlock()) {
totalBytes += block->getSize() + sizeof(CMemBlock);
if (block->getNextBlock()) {
if (block->getNextBlock()->getPrevBlock() != block) {
ok = false;
JUTWarningConsole_f(":::addr %08x: bad previous pointer (%08x)\n",
block->getNextBlock(), block->getNextBlock()->getPrevBlock());
}
if ((u32)block + block->getSize() + sizeof(CMemBlock) > (u32)block->getNextBlock()) {
ok = false;
JUTWarningConsole_f(":::addr %08x: bad block size (%08x)\n", block,
block->getSize());
}
} else {
if (mTailFreeList != block) {
ok = false;
JUTWarningConsole_f(":::addr %08x: bad used list(REV) (%08x)\n", block,
mTailFreeList);
}
}
}
if (totalBytes != getSize()) {
ok = false;
JUTWarningConsole_f(":::bad total memory block size (%08X, %08X)\n", getSize(), totalBytes);
}
if (!ok) {
JUTWarningConsole(":::there is some error in this heap!\n");
}
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 */
#pragma push
#pragma force_active on
SECTION_DEAD static char const* const stringBase_8039CC8D =
" attr address: size gid aln prev_ptr nex"
"t_ptr\n";
SECTION_DEAD static char const* const stringBase_8039CCC4 = "(Used Blocks)\n";
SECTION_DEAD static char const* const stringBase_8039CCD3 = " NONE\n";
SECTION_DEAD static char const* const stringBase_8039CCDA =
"xxxxx %08x: -------- --- --- (-------- -------"
"-)\nabort\n";
SECTION_DEAD static char const* const stringBase_8039CD14 = "%s %08x: %08x %3d %3d (%08x %08x)\n";
SECTION_DEAD static char const* const stringBase_8039CD39 = " temp";
SECTION_DEAD static char const* const stringBase_8039CD3F = "alloc";
SECTION_DEAD static char const* const stringBase_8039CD45 = "(Free Blocks)\n";
SECTION_DEAD static char const* const stringBase_8039CD54 = " free";
SECTION_DEAD static char const* const stringBase_8039CD5A =
"%d / %d bytes (%6.2f%%) used (U:%d F:%d)\n";
#pragma pop
/* 80455F98-80455FA0 004598 0004+04 2/2 0/0 0/0 .sdata2 @1121 */
SECTION_SDATA2 static f32 lit_1121[1 + 1 /* padding */] = {
100.0f,
/* padding */
0.0f,
};
/* 80455FA0-80455FA8 0045A0 0008+00 2/2 0/0 0/0 .sdata2 @1123 */
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 */
#if NONMATCHING
bool JKRExpHeap::dump() {
lock();
bool result = check();
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()) {
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();
usedCount++;
}
JUTReportConsole("(Free Blocks)\n");
if (!mHeadFreeList) {
JUTReportConsole(" NONE\n");
}
for (CMemBlock* block = mHeadFreeList; block; block = block->getNextBlock()) {
JUTReportConsole_f("%s %08x: %08x %3d %3d (%08x %08x)\n", " free", block->getContent(),
block->getSize(), block->getGroupId(), block->getAlignment(),
block->getPrevBlock(), block->getNextBlock());
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,
usedCount, freeCount);
unlock();
return result;
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm bool JKRExpHeap::dump() {
nofralloc
#include "asm/JSystem/JKernel/JKRExpHeap/dump__10JKRExpHeapFv.s"
}
#pragma pop
#endif
/* 802D05CC-802D0810 2CAF0C 0244+00 1/0 0/0 0/0 .text dump_sort__10JKRExpHeapFv */
#if NONMATCHING
bool JKRExpHeap::dump_sort() {
lock();
bool result = check();
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 == NULL) {
JUTReportConsole(" NONE\n");
} else {
CMemBlock* var1 = NULL;
while (true) {
CMemBlock* block = (CMemBlock*)0xffffffff;
for (CMemBlock* iterBlock = mHeadUsedList; iterBlock;
iterBlock = iterBlock->getNextBlock()) {
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();
usedCount++;
var1 = block;
}
}
JUTReportConsole("(Free Blocks)\n");
if (mHeadFreeList == NULL) {
JUTReportConsole(" NONE\n");
}
for (CMemBlock* block = mHeadFreeList; block; block = block->getNextBlock()) {
JUTReportConsole_f("%s %08x: %08x %3d %3d (%08x %08x)\n", " free", block->getContent(),
block->getSize(), block->getGroupId(), block->getAlignment(),
block->getPrevBlock(), block->getNextBlock());
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,
usedCount, freeCount);
unlock();
return result;
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm bool JKRExpHeap::dump_sort() {
nofralloc
#include "asm/JSystem/JKernel/JKRExpHeap/dump_sort__10JKRExpHeapFv.s"
}
#pragma pop
#endif
/* 802D0810-802D0830 2CB150 0020+00 4/4 0/0 0/0 .text
* initiate__Q210JKRExpHeap9CMemBlockFPQ210JKRExpHeap9CMemBlockPQ210JKRExpHeap9CMemBlockUlUcUc */
void JKRExpHeap::CMemBlock::initiate(JKRExpHeap::CMemBlock* prev, JKRExpHeap::CMemBlock* next,
u32 size, u8 groupId, u8 alignment) {
mMagic = 'HM';
mFlags = alignment;
mGroupId = groupId;
this->size = size;
mPrev = prev;
mNext = next;
}
/* 802D0830-802D0874 2CB170 0044+00 3/3 0/0 0/0 .text
* allocFore__Q210JKRExpHeap9CMemBlockFUlUcUcUcUc */
#if NONMATCHING
JKRExpHeap::CMemBlock* JKRExpHeap::CMemBlock::allocFore(u32 size, u8 groupId1, u8 alignment1,
u8 groupId2, u8 alignment2) {
CMemBlock* block = NULL;
mGroupId = groupId1;
mFlags = alignment1;
if (getSize() >= size + sizeof(CMemBlock)) {
CMemBlock* newblock = (CMemBlock*)(size + (u32)this);
newblock[1].mGroupId = groupId2;
newblock[1].mFlags = alignment2;
newblock[1].size = this->size - (size + sizeof(CMemBlock));
this->size = size;
block = newblock + 1;
}
return block;
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JKRExpHeap::CMemBlock* JKRExpHeap::CMemBlock::allocFore(u32 param_0, u8 param_1, u8 param_2,
u8 param_3, u8 param_4) {
nofralloc
#include "asm/JSystem/JKernel/JKRExpHeap/allocFore__Q210JKRExpHeap9CMemBlockFUlUcUcUcUc.s"
}
#pragma pop
#endif
/* 802D0874-802D08CC 2CB1B4 0058+00 1/1 0/0 0/0 .text
* allocBack__Q210JKRExpHeap9CMemBlockFUlUcUcUcUc */
JKRExpHeap::CMemBlock* JKRExpHeap::CMemBlock::allocBack(u32 size, u8 groupId1, u8 alignment1,
u8 groupId2, u8 alignment2) {
CMemBlock* newblock = NULL;
if (getSize() >= size + sizeof(CMemBlock)) {
newblock = (CMemBlock*)((u32)this + getSize() - size);
newblock->mGroupId = groupId2;
newblock->mFlags = alignment2 | 0x80;
newblock->size = size;
mGroupId = groupId1;
mFlags = alignment1;
this->size -= size + sizeof(CMemBlock);
} else {
mGroupId = groupId2;
mFlags = 0x80;
}
return newblock;
}
/* 802D08CC-802D091C 2CB20C 0050+00 2/2 0/0 0/0 .text free__Q210JKRExpHeap9CMemBlockFP10JKRExpHeap
*/
int JKRExpHeap::CMemBlock::free(JKRExpHeap* heap) {
heap->removeUsedBlock(this);
heap->recycleFreeBlock(this);
return 0;
}
/* 802D091C-802D0938 2CB25C 001C+00 3/3 0/0 0/0 .text getHeapBlock__Q210JKRExpHeap9CMemBlockFPv */
JKRExpHeap::CMemBlock* JKRExpHeap::CMemBlock::getHeapBlock(void* ptr) {
if (ptr) {
CMemBlock* block = (CMemBlock*)ptr - 1;
if (block->isValid()) {
return block;
}
}
return NULL;
}
/* 802D0938-802D09E0 2CB278 00A8+00 1/0 0/0 0/0 .text
* state_register__10JKRExpHeapCFPQ27JKRHeap6TStateUl */
void JKRExpHeap::state_register(JKRHeap::TState* p, u32 param_1) const {
p->mId = param_1;
if (param_1 <= 0xff) {
p->mUsedSize = getUsedSize(param_1);
} else {
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) {
u8 groupId = block->getGroupId();
if (groupId == param_1) {
checkCode += (u32)block * 3;
}
} else {
checkCode += (u32)block * 3;
}
}
p->mCheckCode = checkCode;
}
/* 802D09E0-802D0A10 2CB320 0030+00 1/0 0/0 0/0 .text
* state_compare__10JKRExpHeapCFRCQ27JKRHeap6TStateRCQ27JKRHeap6TState */
bool JKRExpHeap::state_compare(JKRHeap::TState const& r1, JKRHeap::TState const& r2) const {
bool result = true;
if (r1.mCheckCode != r2.mCheckCode) {
result = false;
}
if (r1.mUsedSize != r2.mUsedSize) {
result = false;
}
return result;
}
/* 802D0A10-802D0A1C 2CB350 000C+00 1/0 0/0 0/0 .text getHeapType__10JKRExpHeapFv */
u32 JKRExpHeap::getHeapType() {
return 'EXPH';
}
/* 802D0A1C-802D0A24 2CB35C 0008+00 1/0 0/0 0/0 .text do_getCurrentGroupId__10JKRExpHeapFv */
u8 JKRExpHeap::do_getCurrentGroupId() {
return mCurrentGroupId;
}
/* ############################################################################################## */
/* 8039CD84-8039CDA0 0293E4 001C+00 0/0 0/0 0/0 .rodata None */
#pragma push
#pragma force_active on
SECTION_DEAD static char const* const stringBase_8039CD84 = "+---------------JKRExpHeap\n";
#pragma pop
/* 8039CDA0-8039CDD0 029400 0030+00 0/0 0/0 0/0 .rodata None */
#pragma push
#pragma force_active on
SECTION_DEAD static char const* const stringBase_8039CDA0 =
"| Align Group size ( prev , next )\n";
#pragma pop
/* 8039CDD0-8039CDE2 029430 0012+00 0/0 0/0 0/0 .rodata None */
#pragma push
#pragma force_active on
SECTION_DEAD static char const* const stringBase_8039CDD0 = "| ---- FreeFirst\n";
#pragma pop
/* 8039CDE2-8039CDEB 029442 0009+00 0/0 0/0 0/0 .rodata None */
#pragma push
#pragma force_active on
SECTION_DEAD static char const* const stringBase_8039CDE2 = "| %08x ";
#pragma pop
/* 8039CDEB-8039CE07 02944B 001C+00 0/0 0/0 0/0 .rodata None */
#pragma push
#pragma force_active on
SECTION_DEAD static char const* const stringBase_8039CDEB = "%2x %3d %6x (%08x %08x)\n";
#pragma pop
/* 8039CE07-8039CE18 029467 0011+00 0/0 0/0 0/0 .rodata None */
#pragma push
#pragma force_active on
SECTION_DEAD static char const* const stringBase_8039CE07 = "| ---- FreeLast\n";
#pragma pop
/* 8039CE18-8039CE2A 029478 0012+00 0/0 0/0 0/0 .rodata None */
#pragma push
#pragma force_active on
SECTION_DEAD static char const* const stringBase_8039CE18 = "| ---- UsedFirst\n";
#pragma pop
/* 8039CE2A-8039CE3B 02948A 0011+00 0/0 0/0 0/0 .rodata None */
#pragma push
#pragma force_active on
SECTION_DEAD static char const* const stringBase_8039CE2A = "| ---- UsedLast\n";
#pragma pop
/* 8039CE3B-8039CE50 02949B 0015+00 0/0 0/0 0/0 .rodata None */
#pragma push
#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 */
Reference in New Issue View Git Blame Copy Permalink