mirror of
https://github.com/zeldaret/tww.git
synced 2026-06-03 10:31:17 -04:00
Jcw87
477 lines
13 KiB
C++
477 lines
13 KiB
C++
//
|
|
// Generated by dtk
|
|
// Translation Unit: JKRHeap.cpp
|
|
//
|
|
|
|
#include "JSystem/JKernel/JKRHeap.h"
|
|
#include "JSystem/JUtility/JUTAssert.h"
|
|
#include "dolphin/os/OS.h"
|
|
#include "dolphin/types.h"
|
|
#include "global.h"
|
|
|
|
bool JKRHeap::sDefaultFillFlag = true;
|
|
JKRHeap* JKRHeap::sSystemHeap;
|
|
JKRHeap* JKRHeap::sCurrentHeap;
|
|
JKRHeap* JKRHeap::sRootHeap;
|
|
JKRErrorHandler JKRHeap::mErrorHandler;
|
|
|
|
/* 802B0100-802B0224 .text __ct__7JKRHeapFPvUlP7JKRHeapb */
|
|
JKRHeap::JKRHeap(void* data, u32 size, JKRHeap* parent, bool errorFlag) : JKRDisposer(), mChildTree(this), mDisposerList() {
|
|
OSInitMutex(&mMutex);
|
|
mSize = size;
|
|
mStart = (u8*)data;
|
|
mEnd = (u8*)data + size;
|
|
|
|
if (parent == NULL) {
|
|
becomeSystemHeap();
|
|
becomeCurrentHeap();
|
|
} else {
|
|
parent->mChildTree.appendChild(&mChildTree);
|
|
|
|
if (getSystemHeap() == getRootHeap()) {
|
|
becomeSystemHeap();
|
|
}
|
|
|
|
if (getCurrentHeap() == getRootHeap()) {
|
|
becomeCurrentHeap();
|
|
}
|
|
}
|
|
|
|
mErrorFlag = errorFlag;
|
|
if (mErrorFlag == true && mErrorHandler == NULL) {
|
|
mErrorHandler = JKRDefaultMemoryErrorRoutine;
|
|
}
|
|
|
|
mDebugFill = sDefaultFillFlag;
|
|
mInitFlag = false;
|
|
}
|
|
|
|
/* 802B0224-802B0338 .text __dt__7JKRHeapFv */
|
|
JKRHeap::~JKRHeap() {
|
|
mChildTree.getParent()->removeChild(&mChildTree);
|
|
JSUTree<JKRHeap>* nextRootHeap = sRootHeap->mChildTree.getFirstChild();
|
|
|
|
if (sCurrentHeap == this) {
|
|
sCurrentHeap = !nextRootHeap ? sRootHeap : nextRootHeap->getObject();
|
|
}
|
|
|
|
if (sSystemHeap == this) {
|
|
sSystemHeap = !nextRootHeap ? sRootHeap : nextRootHeap->getObject();
|
|
}
|
|
}
|
|
|
|
void* JKRHeap::mCodeStart;
|
|
void* JKRHeap::mCodeEnd;
|
|
void* JKRHeap::mUserRamStart;
|
|
void* JKRHeap::mUserRamEnd;
|
|
u32 JKRHeap::mMemorySize;
|
|
|
|
/* 802B0338-802B03E8 .text initArena__7JKRHeapFPPcPUli */
|
|
bool JKRHeap::initArena(char** memory, u32* size, int maxHeaps) {
|
|
void* ram_start;
|
|
void* ram_end;
|
|
void* arenaStart;
|
|
|
|
void* arenaLo = OSGetArenaLo();
|
|
void* arenaHi = OSGetArenaHi();
|
|
if (arenaLo == arenaHi)
|
|
return false;
|
|
|
|
arenaStart = OSInitAlloc(arenaLo, arenaHi, maxHeaps);
|
|
ram_start = OSRoundUpPtr(arenaStart, 0x20);
|
|
ram_end = OSRoundDownPtr(arenaHi, 0x20);
|
|
|
|
OSBootInfo* codeStart = (OSBootInfo*)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 = (u32)ram_end - (u32)ram_start;
|
|
return true;
|
|
}
|
|
|
|
/* 802B03E8-802B03F8 .text becomeSystemHeap__7JKRHeapFv */
|
|
JKRHeap* JKRHeap::becomeSystemHeap() {
|
|
JKRHeap* prev = sSystemHeap;
|
|
sSystemHeap = this;
|
|
return prev;
|
|
}
|
|
|
|
/* 802B03F8-802B0408 .text becomeCurrentHeap__7JKRHeapFv */
|
|
JKRHeap* JKRHeap::becomeCurrentHeap() {
|
|
JKRHeap* prev = sCurrentHeap;
|
|
sCurrentHeap = this;
|
|
return prev;
|
|
}
|
|
|
|
/* 802B0408-802B0434 .text destroy__7JKRHeapFv */
|
|
void JKRHeap::destroy() {
|
|
do_destroy();
|
|
}
|
|
|
|
/* 802B0434-802B0494 .text alloc__7JKRHeapFUliP7JKRHeap */
|
|
void* JKRHeap::alloc(u32 size, int alignment, JKRHeap* heap) {
|
|
if (heap != NULL) {
|
|
return heap->alloc(size, alignment);
|
|
}
|
|
|
|
if (sCurrentHeap != NULL) {
|
|
return sCurrentHeap->alloc(size, alignment);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void dummy1(JKRHeap* heap) {
|
|
JUT_ASSERT(0, heap != 0);
|
|
}
|
|
|
|
/* 802B0494-802B0518 .text alloc__7JKRHeapFUli */
|
|
void* JKRHeap::alloc(u32 size, int alignment) {
|
|
if (mInitFlag) {
|
|
JUT_WARN(308, "alloc %x byte in heap %x", size, this);
|
|
}
|
|
return do_alloc(size, alignment);
|
|
}
|
|
|
|
/* 802B0518-802B0560 .text free__7JKRHeapFPvP7JKRHeap */
|
|
void JKRHeap::free(void* ptr, JKRHeap* heap) {
|
|
if (!heap) {
|
|
heap = findFromRoot(ptr);
|
|
if (!heap)
|
|
return;
|
|
}
|
|
|
|
heap->free(ptr);
|
|
}
|
|
|
|
/* 802B0560-802B05DC .text free__7JKRHeapFPv */
|
|
void JKRHeap::free(void* ptr) {
|
|
if (mInitFlag) {
|
|
JUT_WARN(356, "free %x in heap %x", ptr, this);
|
|
}
|
|
do_free(ptr);
|
|
}
|
|
|
|
/* 802B05DC-802B0634 .text callAllDisposer__7JKRHeapFv */
|
|
void JKRHeap::callAllDisposer() {
|
|
JSUListIterator<JKRDisposer> iterator;
|
|
|
|
while ((iterator = mDisposerList.getFirst()) != mDisposerList.getEnd()) {
|
|
iterator->~JKRDisposer();
|
|
}
|
|
}
|
|
|
|
/* 802B0634-802B069C .text freeAll__7JKRHeapFv */
|
|
void JKRHeap::freeAll() {
|
|
if (mInitFlag) {
|
|
JUT_WARN(408, "freeAll in heap %x", this);
|
|
}
|
|
do_freeAll();
|
|
}
|
|
|
|
/* 802B069C-802B0704 .text freeTail__7JKRHeapFv */
|
|
void JKRHeap::freeTail() {
|
|
if (mInitFlag) {
|
|
JUT_WARN(422, "freeTail in heap %x", this);
|
|
}
|
|
do_freeTail();
|
|
}
|
|
|
|
/* 802B0704-802B0764 .text resize__7JKRHeapFPvUlP7JKRHeap */
|
|
s32 JKRHeap::resize(void* ptr, u32 size, JKRHeap* heap) {
|
|
if (!heap) {
|
|
heap = findFromRoot(ptr);
|
|
if (!heap)
|
|
return -1;
|
|
}
|
|
|
|
return heap->resize(ptr, size);
|
|
}
|
|
|
|
/* 802B0764-802B07EC .text resize__7JKRHeapFPvUl */
|
|
s32 JKRHeap::resize(void* ptr, u32 size) {
|
|
if (mInitFlag) {
|
|
JUT_WARN(466, "resize block %x into %x in heap %x", ptr, size, this);
|
|
}
|
|
return do_resize(ptr, size);
|
|
}
|
|
|
|
/* 802B07EC-802B083C .text getSize__7JKRHeapFPvP7JKRHeap */
|
|
s32 JKRHeap::getSize(void* ptr, JKRHeap* heap) {
|
|
if (!heap) {
|
|
heap = findFromRoot(ptr);
|
|
if (!heap)
|
|
return -1;
|
|
}
|
|
|
|
return heap->getSize(ptr);
|
|
}
|
|
|
|
/* 802B083C-802B0868 .text getSize__7JKRHeapFPv */
|
|
s32 JKRHeap::getSize(void* ptr) {
|
|
return do_getSize(ptr);
|
|
}
|
|
|
|
/* 802B0868-802B0894 .text getFreeSize__7JKRHeapFv */
|
|
s32 JKRHeap::getFreeSize() {
|
|
return do_getFreeSize();
|
|
}
|
|
|
|
/* 802B0894-802B08C0 .text getMaxFreeBlock__7JKRHeapFv */
|
|
void* JKRHeap::getMaxFreeBlock() {
|
|
return do_getMaxFreeBlock();
|
|
}
|
|
|
|
/* 802B08C0-802B08EC .text getTotalFreeSize__7JKRHeapFv */
|
|
s32 JKRHeap::getTotalFreeSize() {
|
|
return do_getTotalFreeSize();
|
|
}
|
|
|
|
/* 802B08EC-802B0918 .text getCurrentGroupId__7JKRHeapFv */
|
|
u8 JKRHeap::getCurrentGroupId() {
|
|
return do_getCurrentGroupId();
|
|
}
|
|
|
|
static void dummy2() {
|
|
OSReport("change heap ID into %x in heap %x");
|
|
}
|
|
|
|
/* 802B0918-802B0978 .text getMaxAllocatableSize__7JKRHeapFi */
|
|
u32 JKRHeap::getMaxAllocatableSize(int alignment) {
|
|
u32 maxFreeBlock = (u32)getMaxFreeBlock();
|
|
u32 ptrOffset = (alignment - 1) & alignment - (maxFreeBlock & 0xf);
|
|
return ~(alignment - 1) & (getFreeSize() - ptrOffset);
|
|
}
|
|
|
|
/* 802B0978-802B09B0 .text findFromRoot__7JKRHeapFPv */
|
|
JKRHeap* JKRHeap::findFromRoot(void* ptr) {
|
|
if (sRootHeap) {
|
|
return sRootHeap->find(ptr);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/* 802B09B0-802B0A58 .text find__7JKRHeapCFPv */
|
|
JKRHeap* JKRHeap::find(void* memory) const {
|
|
if (mStart <= memory && memory < mEnd) {
|
|
if (mChildTree.getNumChildren() != 0) {
|
|
for (JSUTreeIterator<JKRHeap> iterator(mChildTree.getFirstChild());
|
|
iterator != mChildTree.getEndChild(); ++iterator)
|
|
{
|
|
JKRHeap* result = iterator->find(memory);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
|
|
return const_cast<JKRHeap*>(this);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/* 802B0A58-802B0AEC .text dispose_subroutine__7JKRHeapFUlUl */
|
|
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)
|
|
{
|
|
JKRDisposer* disposer = iterator.getObject();
|
|
|
|
if ((void*)begin <= disposer && disposer < (void*)end) {
|
|
disposer->~JKRDisposer();
|
|
|
|
if (last_iterator == NULL) {
|
|
next_iterator = mDisposerList.getFirst();
|
|
} else {
|
|
next_iterator = last_iterator;
|
|
next_iterator++;
|
|
}
|
|
} else {
|
|
last_iterator = iterator;
|
|
next_iterator = iterator;
|
|
next_iterator++;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* 802B0AEC-802B0B14 .text dispose__7JKRHeapFPvUl */
|
|
bool JKRHeap::dispose(void* ptr, u32 size) {
|
|
dispose_subroutine((u32)ptr, (u32)ptr + size);
|
|
return false;
|
|
}
|
|
|
|
/* 802B0B14-802B0B34 .text dispose__7JKRHeapFPvPv */
|
|
void JKRHeap::dispose(void* begin, void* end) {
|
|
dispose_subroutine((u32)begin, (u32)end);
|
|
}
|
|
|
|
/* 802B0B34-802B0B8C .text dispose__7JKRHeapFv */
|
|
void JKRHeap::dispose() {
|
|
JSUListIterator<JKRDisposer> iterator;
|
|
while ((iterator = mDisposerList.getFirst()) != mDisposerList.getEnd()) {
|
|
iterator->~JKRDisposer();
|
|
}
|
|
}
|
|
|
|
/* 802B0B8C-802B0BB4 .text copyMemory__7JKRHeapFPvPvUl */
|
|
void JKRHeap::copyMemory(void* dst, void* src, u32 size) {
|
|
u32 count = (size + 3) / 4;
|
|
|
|
u32* dst_32 = (u32*)dst;
|
|
u32* src_32 = (u32*)src;
|
|
while (count > 0) {
|
|
*dst_32 = *src_32;
|
|
dst_32++;
|
|
src_32++;
|
|
count--;
|
|
}
|
|
}
|
|
|
|
/* 802B0BB4-802B0C08 .text JKRDefaultMemoryErrorRoutine__FPvUli */
|
|
void JKRDefaultMemoryErrorRoutine(void* heap, u32 size, int alignment) {
|
|
OSReport("Error: Cannot allocate memory %d(0x%x)byte in %d byte alignment from %08x\n", size, size, alignment, heap);
|
|
OSPanic(__FILE__, 767, "abort\n");
|
|
}
|
|
|
|
/* 802B0C08-802B0C18 .text setErrorFlag__7JKRHeapFb */
|
|
bool JKRHeap::setErrorFlag(bool errorFlag) {
|
|
bool prev = mErrorFlag;
|
|
mErrorFlag = errorFlag;
|
|
return prev;
|
|
}
|
|
|
|
/* 802B0C18-802B0C38 .text setErrorHandler__7JKRHeapFPFPvUli_v */
|
|
JKRErrorHandler JKRHeap::setErrorHandler(JKRErrorHandler errorHandler) {
|
|
JKRErrorHandler prev = mErrorHandler;
|
|
|
|
if (!errorHandler) {
|
|
errorHandler = JKRDefaultMemoryErrorRoutine;
|
|
}
|
|
|
|
mErrorHandler = errorHandler;
|
|
return prev;
|
|
}
|
|
|
|
/* 802B0C38-802B0C60 .text __nw__FUl */
|
|
void* operator new(size_t size) {
|
|
return JKRHeap::alloc(size, 4, NULL);
|
|
}
|
|
|
|
/* 802B0C60-802B0C84 .text __nw__FUli */
|
|
void* operator new(size_t size, int alignment) {
|
|
return JKRHeap::alloc(size, alignment, NULL);
|
|
}
|
|
|
|
/* 802B0C84-802B0CB0 .text __nw__FUlP7JKRHeapi */
|
|
void* operator new(size_t size, JKRHeap* heap, int alignment) {
|
|
return JKRHeap::alloc(size, alignment, heap);
|
|
}
|
|
|
|
/* 802B0CB0-802B0CD8 .text __nwa__FUl */
|
|
void* operator new[](size_t size) {
|
|
return JKRHeap::alloc(size, 4, NULL);
|
|
}
|
|
|
|
/* 802B0CD8-802B0CFC .text __nwa__FUli */
|
|
void* operator new[](size_t size, int alignment) {
|
|
return JKRHeap::alloc(size, alignment, NULL);
|
|
}
|
|
|
|
/* 802B0CFC-802B0D28 .text __nwa__FUlP7JKRHeapi */
|
|
void* operator new[](size_t size, JKRHeap* heap, int alignment) {
|
|
return JKRHeap::alloc(size, alignment, heap);
|
|
}
|
|
|
|
/* 802B0D28-802B0D4C .text __dl__FPv */
|
|
void operator delete(void* ptr) {
|
|
JKRHeap::free(ptr, NULL);
|
|
}
|
|
|
|
/* 802B0D4C-802B0D70 .text __dla__FPv */
|
|
void operator delete[](void* ptr) {
|
|
JKRHeap::free(ptr, NULL);
|
|
}
|
|
|
|
static void dummy3() {
|
|
#if VERSION != VERSION_JPN
|
|
OSReport("\x1B[41;37m:::addr %08x size %08x: Freeされた領域が浸食されている (%08x=%02x)\n\x1B[m");
|
|
#endif
|
|
OSReport("%s");
|
|
OSReport("heap unchanged");
|
|
OSReport("**** heap changed ****");
|
|
OSReport("location : [%s:%d]");
|
|
OSReport("**** heap changed : old ****");
|
|
OSReport("**** heap changed : new ****");
|
|
}
|
|
|
|
/* 802B0D70-802B0E14 .text state_register__7JKRHeapCFPQ27JKRHeap6TStateUl */
|
|
void JKRHeap::state_register(JKRHeap::TState* p, u32 id) const {
|
|
#if VERSION == VERSION_JP
|
|
JUT_ASSERT(1034, p != 0);
|
|
JUT_ASSERT(1035, p->getHeap() == this);
|
|
#else
|
|
JUT_ASSERT(1090, p != 0);
|
|
JUT_ASSERT(1091, p->getHeap() == this);
|
|
#endif
|
|
}
|
|
|
|
/* 802B0E14-802B0E9C .text state_compare__7JKRHeapCFRCQ27JKRHeap6TStateRCQ27JKRHeap6TState */
|
|
bool JKRHeap::state_compare(const JKRHeap::TState& r1, const JKRHeap::TState& r2) const {
|
|
#if VERSION == VERSION_JP
|
|
JUT_ASSERT(1043, r1.getHeap() == r2.getHeap());
|
|
#else
|
|
JUT_ASSERT(1099, r1.getHeap() == r2.getHeap());
|
|
#endif
|
|
return r1.getCheckCode() == r2.getCheckCode();
|
|
}
|
|
|
|
static void dummy4() {
|
|
OSReport("heap : %p / %p");
|
|
OSReport("check-code : 0x%08x / 0x%08x");
|
|
OSReport("id : 0x%08x / 0x%08x");
|
|
OSReport("used size : %10u / %10u");
|
|
}
|
|
|
|
/* 802B0E9C-802B0F24 .text state_dump__7JKRHeapCFRCQ27JKRHeap6TState */
|
|
void JKRHeap::state_dump(const JKRHeap::TState& p) const {
|
|
#if VERSION == VERSION_JP
|
|
JUT_LOG(1067, "check-code : 0x%08x", p.getCheckCode());
|
|
JUT_LOG(1068, "id : 0x%08x", p.getId());
|
|
JUT_LOG(1069, "used size : %u", p.getUsedSize());
|
|
#else
|
|
JUT_LOG(1123, "check-code : 0x%08x", p.getCheckCode());
|
|
JUT_LOG(1124, "id : 0x%08x", p.getId());
|
|
JUT_LOG(1125, "used size : %u", p.getUsedSize());
|
|
#endif
|
|
}
|
|
|
|
/* 802B0F24-802B0F2C .text do_changeGroupID__7JKRHeapFUc */
|
|
s32 JKRHeap::do_changeGroupID(u8 param_0) {
|
|
return 0;
|
|
}
|
|
|
|
/* 802B0F2C-802B0F34 .text do_getCurrentGroupId__7JKRHeapFv */
|
|
u8 JKRHeap::do_getCurrentGroupId() {
|
|
return 0;
|
|
}
|
|
|
|
#if VERSION == VERSION_JP
|
|
static void dummy5() {
|
|
OSReport("\x1B[41;37m:::addr %08x size %08x: Freeされた領域が浸食されている (%08x=%02x)\n\x1B[m");
|
|
}
|
|
#endif
|