JKRAramHeap and JKRAramPiece (#53)

* renamed func_XXX to _savegpr_XX

* renamed func_XXX to _restgpr_XX

* renamed func_XXX to _savefpr_XX

* renamed func_XXX to _restfpr_XX

* cleanup functions.h and moved intrisics to mwcc.h

* formatting

* cleanup functions.h

* Added include/ar/ARQ.h

* renamed func_XXX to _savegpr_25

* removed JKRAramPiece asm files

* JKRAramHeap OK, JKRAramPiece OK

* formatting

* more formatting

* Added const and removed explicit this->

* fixed merge problems

* changed mMessages[1] to mMessage

* foramatting

Co-authored-by: Julgodis <>
Co-authored-by: Pheenoh <pheenoh@gmail.com>

libs/JSystem/JKernel/JKRAramBlock.cpp

@@ -5,56 +5,56 @@
 
 JKRAramBlock::JKRAramBlock(u32 address, u32 size, u32 freeSize, u8 groupId, bool isTempMemory)
     : mBlockLink(this) {
-    this->mAddress = address;
-    this->mSize = size;
-    this->mFreeSize = freeSize;
-    this->mGroupId = groupId;
-    this->mIsTempMemory = isTempMemory;
+    mAddress = address;
+    mSize = size;
+    mFreeSize = freeSize;
+    mGroupId = groupId;
+    mIsTempMemory = isTempMemory;
 }
 
 JKRAramBlock::~JKRAramBlock() {
-    JSUList<JKRAramBlock>* list = this->mBlockLink.getSupervisor();
-    JSULink<JKRAramBlock>* prev = this->mBlockLink.getPrev();
+    JSUList<JKRAramBlock>* list = mBlockLink.getSupervisor();
+    JSULink<JKRAramBlock>* prev = mBlockLink.getPrev();
     if (prev) {
         JKRAramBlock* block = prev->getObject();
-        block->mFreeSize = this->mSize + this->mFreeSize + block->mFreeSize;
-        list->remove(&this->mBlockLink);
+        block->mFreeSize = mSize + mFreeSize + block->mFreeSize;
+        list->remove(&mBlockLink);
     } else {
-        this->mFreeSize = this->mFreeSize + this->mSize;
-        this->mSize = 0;
+        mFreeSize = mFreeSize + mSize;
+        mSize = 0;
     }
 }
 
 JKRAramBlock* JKRAramBlock::allocHead(u32 size, u8 groupId, JKRAramHeap* aramHeap) {
-    u32 address = this->mAddress;
-    u32 usedSize = this->mSize;
+    u32 address = mAddress;
+    u32 usedSize = mSize;
     u32 nextAddress = address + usedSize;
-    u32 freeSize = this->mFreeSize;
+    u32 freeSize = mFreeSize;
     u32 nextFreeSize = freeSize - size;
 
     JKRAramBlock* block = new (aramHeap->getMgrHeap(), 0)
         JKRAramBlock(nextAddress, size, nextFreeSize, groupId, false);
 
-    this->mFreeSize = 0;
-    JSULink<JKRAramBlock>* next = this->mBlockLink.getNext();
-    JSUList<JKRAramBlock>* list = this->mBlockLink.getSupervisor();
+    mFreeSize = 0;
+    JSULink<JKRAramBlock>* next = mBlockLink.getNext();
+    JSUList<JKRAramBlock>* list = mBlockLink.getSupervisor();
     list->insert(next, &block->mBlockLink);
     return block;
 }
 
 JKRAramBlock* JKRAramBlock::allocTail(u32 size, u8 groupId, JKRAramHeap* aramHeap) {
-    u32 freeSize = this->mFreeSize;
-    u32 address = this->mAddress;
-    u32 usedSize = this->mSize;
+    u32 freeSize = mFreeSize;
+    u32 address = mAddress;
+    u32 usedSize = mSize;
     u32 endAddress = address + usedSize + freeSize;
     u32 tailAddress = endAddress - size;
 
     JKRAramBlock* block =
         new (aramHeap->getMgrHeap(), 0) JKRAramBlock(tailAddress, size, 0, groupId, true);
 
-    this->mFreeSize -= size;
-    JSULink<JKRAramBlock>* next = this->mBlockLink.getNext();
-    JSUList<JKRAramBlock>* list = this->mBlockLink.getSupervisor();
+    mFreeSize -= size;
+    JSULink<JKRAramBlock>* next = mBlockLink.getNext();
+    JSUList<JKRAramBlock>* list = mBlockLink.getSupervisor();
     list->insert(next, &block->mBlockLink);
     return block;
 }

libs/JSystem/JKernel/JKRAramHeap.cpp

@@ -1,44 +1,145 @@
 #include "JSystem/JKernel/JKRAramHeap/JKRAramHeap.h"
 #include "global.h"
 
-asm JKRAramHeap::JKRAramHeap(u32, u32) {
-    nofralloc
-#include "JSystem/JKernel/JKRAramHeap/asm/func_802D2E44.s"
+#include "JSystem/JKernel/JKRAramBlock/JKRAramBlock.h"
+
+JKRAramHeap::JKRAramHeap(u32 startAddress, u32 size) {
+    OSInitMutex(&mMutex);
+
+    mHeap = JKRHeap::findFromRoot(this);
+    mSize = ALIGN_PREV(size, 0x20);
+    mHeadAddress = ALIGN_NEXT(startAddress, 0x20);
+    mTailAddress = mHeadAddress + mSize;
+    mGroupId = -1;
+
+    JKRAramBlock* block = new (mHeap, 0) JKRAramBlock(mHeadAddress, 0, mSize, -1, false);
+    lbl_8043430C.append(&block->mBlockLink);
 }
 
-asm JKRAramHeap::~JKRAramHeap(void) {
+// close match, regalloc problem in the beginning of the while loop
+#if NONMATCHING
+JKRAramHeap::~JKRAramHeap() {
+    JSUList<JKRAramBlock>* list = &lbl_8043430C;
+    JSUListIterator<JKRAramBlock> iterator = list;
+
+    while (iterator != list->getEnd()) {
+        JSUListIterator<JKRAramBlock> prev = iterator;
+        JKRAramBlock* block = prev.getObject();
+        delete block;
+    }
+}
+#else
+asm JKRAramHeap::~JKRAramHeap() {
     nofralloc
 #include "JSystem/JKernel/JKRAramHeap/asm/func_802D2F14.s"
 }
+#endif
 
-asm void JKRAramHeap::alloc(u32, JKRAramHeap::EAllocMode) {
-    nofralloc
-#include "JSystem/JKernel/JKRAramHeap/asm/func_802D2FBC.s"
+JKRAramBlock* JKRAramHeap::alloc(u32 size, JKRAramHeap::EAllocMode allocationMode) {
+    lock();
+
+    JKRAramBlock* block;
+    if (allocationMode == JKRAramHeap::HEAD) {
+        block = allocFromHead(size);
+    } else {
+        block = allocFromTail(size);
+    }
+
+    unlock();
+    return block;
 }
 
-asm void JKRAramHeap::allocFromHead(u32) {
-    nofralloc
-#include "JSystem/JKernel/JKRAramHeap/asm/func_802D3034.s"
+JKRAramBlock* JKRAramHeap::allocFromHead(u32 size) {
+    u32 alignedSize = ALIGN_NEXT(size, 0x20);
+    u32 bestFreeSize = UINT32_MAX;
+    JKRAramBlock* bestBlock = NULL;
+
+    JSUList<JKRAramBlock>* list = &lbl_8043430C;
+    for (JSUListIterator<JKRAramBlock> iterator = list; iterator != list->getEnd(); ++iterator) {
+        JKRAramBlock* block = iterator.getObject();
+        if (block->mFreeSize < alignedSize)
+            continue;
+        if (bestFreeSize <= block->mFreeSize)
+            continue;
+
+        bestFreeSize = block->mFreeSize;
+        bestBlock = block;
+
+        if (block->mFreeSize == alignedSize) {
+            break;
+        }
+    }
+
+    if (bestBlock) {
+        return bestBlock->allocHead(alignedSize, mGroupId, this);
+    }
+
+    return NULL;
 }
 
-asm void JKRAramHeap::allocFromTail(u32) {
-    nofralloc
-#include "JSystem/JKernel/JKRAramHeap/asm/func_802D30BC.s"
+JKRAramBlock* JKRAramHeap::allocFromTail(u32 size) {
+    u32 alignedSize = ALIGN_NEXT(size, 0x20);
+    JKRAramBlock* tailBlock = NULL;
+
+    JSUList<JKRAramBlock>* list = &lbl_8043430C;
+    JSUListIterator<JKRAramBlock> iterator = list->getLast();
+    for (; iterator != list->getEnd(); --iterator) {
+        JKRAramBlock* block = iterator.getObject();
+        if (block->mFreeSize >= alignedSize) {
+            tailBlock = block;
+            break;
+        }
+    }
+
+    if (tailBlock) {
+        return tailBlock->allocTail(alignedSize, mGroupId, this);
+    }
+
+    return NULL;
 }
 
-asm void JKRAramHeap::getFreeSize(void) {
-    nofralloc
-#include "JSystem/JKernel/JKRAramHeap/asm/func_802D3134.s"
+u32 JKRAramHeap::getFreeSize(void) {
+    u32 maxFreeSize = 0;
+
+    lock();
+
+    JSUList<JKRAramBlock>* list = &lbl_8043430C;
+    JSUListIterator<JKRAramBlock> iterator = list;
+    for (; iterator != list->getEnd(); ++iterator) {
+        if (iterator->mFreeSize > maxFreeSize) {
+            maxFreeSize = iterator->mFreeSize;
+        }
+    }
+
+    unlock();
+    return maxFreeSize;
 }
 
-asm void JKRAramHeap::getTotalFreeSize(void) {
-    nofralloc
-#include "JSystem/JKernel/JKRAramHeap/asm/func_802D31AC.s"
+u32 JKRAramHeap::getTotalFreeSize(void) {
+    u32 totalFreeSize = 0;
+
+    lock();
+
+    JSUList<JKRAramBlock>* list = &lbl_8043430C;
+    JSUListIterator<JKRAramBlock> iterator = list;
+    for (; iterator != list->getEnd(); ++iterator) {
+        totalFreeSize += iterator->mFreeSize;
+    }
+
+    unlock();
+    return totalFreeSize;
 }
 
-asm void JKRAramHeap::dump(void) {
-    nofralloc
-#include "JSystem/JKernel/JKRAramHeap/asm/func_802D3218.s"
+void JKRAramHeap::dump(void) {
+    lock();
+
+    JSUList<JKRAramBlock>* list = &lbl_8043430C;
+    JSUListIterator<JKRAramBlock> iterator = list;
+    for (; iterator != list->getEnd(); ++iterator) {
+        // The debug version calls OSReport
+    }
+
+    unlock();
 }
 
 #if 0

libs/JSystem/JKernel/JKRAramPiece.cpp

@@ -1,49 +1,142 @@
 #include "JSystem/JKernel/JKRAramPiece/JKRAramPiece.h"
 #include "global.h"
 
-asm void JKRAramPiece::prepareCommand(int, u32, u32, u32, JKRAramBlock*, void (*)(u32)) {
-    nofralloc
-#include "JSystem/JKernel/JKRAramPiece/asm/func_802D3574.s"
+#include "JSystem/JKernel/JKRDecomp/JKRDecomp.h"
+
+JKRAMCommand* JKRAramPiece::prepareCommand(int direction, u32 src, u32 dst, u32 length,
+                                           JKRAramBlock* block,
+                                           JKRAMCommand::AsyncCallback callback) {
+    JKRAMCommand* command = new (JKRHeap::getSystemHeap(), -4) JKRAMCommand();
+    command->mTransferDirection = direction;
+    command->mSrc = src;
+    command->mDst = dst;
+    command->mAramBlock = block;
+    command->mDataLength = length;
+    command->mCallback = callback;
+    return command;
 }
 
-asm void JKRAramPiece::sendCommand(JKRAMCommand*) {
-    nofralloc
-#include "JSystem/JKernel/JKRAramPiece/asm/func_802D35F4.s"
+void JKRAramPiece::sendCommand(JKRAMCommand* command) {
+    startDMA(command);
 }
 
-asm void JKRAramPiece::orderAsync(int, u32, u32, u32, JKRAramBlock*, void (*)(u32)) {
-    nofralloc
-#include "JSystem/JKernel/JKRAramPiece/asm/func_802D3614.s"
+JKRAMCommand* JKRAramPiece::orderAsync(int direction, u32 source, u32 destination, u32 length,
+                                       JKRAramBlock* block, JKRAMCommand::AsyncCallback callback) {
+    lock();
+    if (((source & 0x1f) != 0) || ((destination & 0x1f) != 0)) {
+        OSReport(lbl_8039D0B8, direction);           // "direction = %x\n"
+        OSReport(lbl_8039D0B8 + 0x10, source);       // "source = %x\n"
+        OSReport(lbl_8039D0B8 + 0x1D, destination);  // "destination = %x\n"
+        OSReport(lbl_8039D0B8 + 0x2F, length);       // "length = %x\n"
+
+        const char* filename = lbl_8039D0B8 + 0x3C;       // "JKRAramPiece.cpp"§
+        const char* format = lbl_8039D0B8 + 0x3C + 0x11;  // "%s"
+        const char* arg1 = lbl_8039D0B8 + 0x3C + 0x14;    // "illegal address. abort."
+        JUTException_NS_panic_f(filename, 0x6c, format, arg1);
+    }
+
+    Message* message = new (JKRHeap::getSystemHeap(), -4) Message();
+    JKRAMCommand* command =
+        JKRAramPiece::prepareCommand(direction, source, destination, length, block, callback);
+    message->field_0x00 = 1;
+    message->command = command;
+
+    OSSendMessage(&lbl_803CC138, message, OS_MESSAGE_BLOCKING);
+    if (command->mCallback != NULL) {
+        lbl_80434324.append(&command->mPieceLink);
+    }
+
+    unlock();
+    return command;
 }
 
-asm void JKRAramPiece::sync(JKRAMCommand*, int) {
-    nofralloc
-#include "JSystem/JKernel/JKRAramPiece/asm/func_802D3770.s"
+BOOL JKRAramPiece::sync(JKRAMCommand* command, int is_non_blocking) {
+    OSMessage* message;
+
+    lock();
+    if (is_non_blocking == 0) {
+        OSReceiveMessage(&command->mMessageQueue, &message, OS_MESSAGE_BLOCKING);
+        lbl_80434324.remove(&command->mPieceLink);
+        unlock();
+        return TRUE;
+    }
+
+    BOOL result = OSReceiveMessage(&command->mMessageQueue, &message, OS_MESSAGE_NON_BLOCKING);
+    if (!result) {
+        unlock();
+        return FALSE;
+    }
+
+    lbl_80434324.remove(&command->mPieceLink);
+    unlock();
+    return TRUE;
 }
 
-asm void JKRAramPiece::orderSync(int, u32, u32, u32, JKRAramBlock*) {
-    nofralloc
-#include "JSystem/JKernel/JKRAramPiece/asm/func_802D3838.s"
+BOOL JKRAramPiece::orderSync(int direction, u32 source, u32 destination, u32 length,
+                             JKRAramBlock* block) {
+    lock();
+
+    JKRAMCommand* command =
+        JKRAramPiece::orderAsync(direction, source, destination, length, block, NULL);
+    BOOL result = JKRAramPiece::sync(command, 0);
+    delete command;
+
+    unlock();
+    return result;
 }
 
-asm void JKRAramPiece::startDMA(JKRAMCommand*) {
-    nofralloc
-#include "JSystem/JKernel/JKRAramPiece/asm/func_802D38CC.s"
+void JKRAramPiece::startDMA(JKRAMCommand* command) {
+    if (command->mTransferDirection == 1) {
+        DCInvalidateRange((void*)command->mDst, command->mDataLength);
+    } else {
+        DCStoreRange((void*)command->mSrc, command->mDataLength);
+    }
+
+    ARQPostRequest(&command->mRequest, 0, command->mTransferDirection, 0, command->mSrc,
+                   command->mDst, command->mDataLength, JKRAramPiece::doneDMA);
 }
 
-asm void JKRAramPiece::doneDMA(u32) {
-    nofralloc
-#include "JSystem/JKernel/JKRAramPiece/asm/func_802D3944.s"
+void JKRAramPiece::doneDMA(u32 requestAddress) {
+    JKRAMCommand* command = (JKRAMCommand*)requestAddress;
+
+    if (command->mTransferDirection == 1) {
+        DCInvalidateRange((void*)command->mDst, command->mDataLength);
+    }
+
+    if (command->field_0x60 != 0) {
+        if (command->field_0x60 == 2) {
+            JKRDecomp::sendCommand(command->mDecompCommand);
+        }
+        return;
+    }
+
+    if (command->mCallback) {
+        (*command->mCallback)(requestAddress);
+    } else if (command->field_0x5C) {
+        OSSendMessage(command->field_0x5C, command, OS_MESSAGE_NON_BLOCKING);
+    } else {
+        OSSendMessage(&command->mMessageQueue, command, OS_MESSAGE_NON_BLOCKING);
+    }
 }
 
-asm JKRAMCommand::JKRAMCommand(void) {
-    nofralloc
-#include "JSystem/JKernel/JKRAramPiece/asm/func_802D39EC.s"
+JKRAMCommand::JKRAMCommand() : mPieceLink(this), field_0x30(this) {
+    OSInitMessageQueue(&mMessageQueue, &mMessage, 1);
+    mCallback = NULL;
+    field_0x5C = NULL;
+    field_0x60 = 0;
+    field_0x8C = NULL;
+    field_0x90 = NULL;
+    field_0x94 = NULL;
 }
 
-asm JKRAMCommand::~JKRAMCommand() {
-    nofralloc
-#include "JSystem/JKernel/JKRAramPiece/asm/func_802D3A5C.s"
+JKRAMCommand::~JKRAMCommand() {
+    if (field_0x8C)
+        delete field_0x8C;
+    if (field_0x90)
+        delete field_0x90;
+
+    if (field_0x94)
+        JKRHeap::free(field_0x94, NULL);
 }
 
 #if 0