From c6d7cc7697c67989b1f018ae2bc934f6677c09b7 Mon Sep 17 00:00:00 2001
From: cadmic <cadmic24@gmail.com>
Date: Wed, 4 Sep 2024 02:10:14 -0700
Subject: [ntsc-1.2] Match __osMalloc.c and code_800FC620.c (new/delete)
 (#2106)

* Match __osMalloc

* Match src/code/code_800FC620.c (new/delete)

* Wrap versions-specific files in ifdefs to fix compilation

* Fix bss

* Remove {FAULT,RAND,OSMALLOC}_VERSION in favor of PLATFORM_N64

* Fix __osMalloc data splits, add unused strings

* __osMalloc.h -> osMalloc.h

* Fix merge
---
 src/code/__osMalloc.c      | 885 --------------------------------------------
 src/code/__osMalloc_gc.c   | 895 +++++++++++++++++++++++++++++++++++++++++++++
 src/code/__osMalloc_n64.c  | 474 ++++++++++++++++++++++++
 src/code/code_800FC620.c   |  65 +++-
 src/code/debug_malloc.c    |   3 +-
 src/code/fault_gc.c        |  10 +-
 src/code/fault_gc_drawer.c |  11 +-
 src/code/fault_n64.c       |  11 +-
 src/code/game.c            |   1 +
 src/code/rand.c            |  13 +-
 src/code/system_malloc.c   |  13 +-
 src/code/z_malloc.c        |   3 +-
 12 files changed, 1444 insertions(+), 940 deletions(-)
 delete mode 100644 src/code/__osMalloc.c
 create mode 100644 src/code/__osMalloc_gc.c
 create mode 100644 src/code/__osMalloc_n64.c

(limited to 'src/code')

diff --git a/src/code/__osMalloc.c b/src/code/__osMalloc.c
deleted file mode 100644
index 598e16a98..000000000
--- a/src/code/__osMalloc.c
+++ /dev/null
@@ -1,885 +0,0 @@
-#include "global.h"
-#include "fault.h"
-#include "terminal.h"
-
-#define FILL_ALLOC_BLOCK_FLAG (1 << 0)
-#define FILL_FREE_BLOCK_FLAG (1 << 1)
-#define CHECK_FREE_BLOCK_FLAG (1 << 2)
-
-#define NODE_MAGIC (0x7373)
-
-#define BLOCK_UNINIT_MAGIC (0xAB)
-#define BLOCK_UNINIT_MAGIC_32 (0xABABABAB)
-#define BLOCK_ALLOC_MAGIC (0xCD)
-#define BLOCK_ALLOC_MAGIC_32 (0xCDCDCDCD)
-#define BLOCK_FREE_MAGIC (0xEF)
-#define BLOCK_FREE_MAGIC_32 (0xEFEFEFEF)
-
-#define NODE_IS_VALID(node) (((node) != NULL) && ((node)->magic == NODE_MAGIC))
-
-#if OOT_DEBUG
-
-#define NODE_GET_NEXT(node) ArenaImpl_GetNextBlock(node)
-#define NODE_GET_PREV(node) ArenaImpl_GetPrevBlock(node)
-
-#define SET_DEBUG_INFO(node, file, line, arena) ArenaImpl_SetDebugInfo(node, file, line, arena)
-
-#define FILL_ALLOC_BLOCK(arena, alloc, size)   \
-    if ((arena)->flag & FILL_ALLOC_BLOCK_FLAG) \
-    memset(alloc, BLOCK_ALLOC_MAGIC, size)
-
-#define FILL_FREE_BLOCK_HEADER(arena, node)   \
-    if ((arena)->flag & FILL_FREE_BLOCK_FLAG) \
-    memset(node, BLOCK_FREE_MAGIC, sizeof(ArenaNode))
-
-#define FILL_FREE_BLOCK_CONTENTS(arena, node) \
-    if ((arena)->flag & FILL_FREE_BLOCK_FLAG) \
-    memset((void*)((u32)(node) + sizeof(ArenaNode)), BLOCK_FREE_MAGIC, (node)->size)
-
-#define CHECK_FREE_BLOCK(arena, node)          \
-    if ((arena)->flag & CHECK_FREE_BLOCK_FLAG) \
-    __osMalloc_FreeBlockTest(arena, node)
-
-#define CHECK_ALLOC_FAILURE(arena, ptr) (void)0
-
-#else
-
-#define NODE_GET_NEXT(node) (NODE_IS_VALID((node)->next) ? (node)->next : NULL)
-#define NODE_GET_PREV(node) (NODE_IS_VALID((node)->prev) ? (node)->prev : NULL)
-
-#define SET_DEBUG_INFO(node, file, line, arena) (void)0
-#define FILL_ALLOC_BLOCK(arena, alloc, size) (void)0
-#define FILL_FREE_BLOCK_HEADER(arena, node) (void)0
-#define FILL_FREE_BLOCK_CONTENTS(arena, node) (void)0
-#define CHECK_FREE_BLOCK(arena, node) (void)0
-
-// Number of allocation failures across all arenas.
-u32 gTotalAllocFailures = 0; // "Arena_failcnt"
-
-#define CHECK_ALLOC_FAILURE(arena, ptr) \
-    do {                                \
-        if ((ptr) == NULL) {            \
-            gTotalAllocFailures++;      \
-            (arena)->allocFailures++;   \
-        }                               \
-    } while (0)
-
-#endif
-
-OSMesg sArenaLockMsg;
-
-#if OOT_DEBUG
-u32 __osMalloc_FreeBlockTest_Enable;
-
-u32 ArenaImpl_GetFillAllocBlock(Arena* arena) {
-    return (arena->flag & FILL_ALLOC_BLOCK_FLAG) != 0;
-}
-u32 ArenaImpl_GetFillFreeBlock(Arena* arena) {
-    return (arena->flag & FILL_FREE_BLOCK_FLAG) != 0;
-}
-u32 ArenaImpl_GetCheckFreeBlock(Arena* arena) {
-    return (arena->flag & CHECK_FREE_BLOCK_FLAG) != 0;
-}
-
-void ArenaImpl_SetFillAllocBlock(Arena* arena) {
-    arena->flag |= FILL_ALLOC_BLOCK_FLAG;
-}
-void ArenaImpl_SetFillFreeBlock(Arena* arena) {
-    arena->flag |= FILL_FREE_BLOCK_FLAG;
-}
-void ArenaImpl_SetCheckFreeBlock(Arena* arena) {
-    arena->flag |= CHECK_FREE_BLOCK_FLAG;
-}
-
-void ArenaImpl_UnsetFillAllocBlock(Arena* arena) {
-    arena->flag &= ~FILL_ALLOC_BLOCK_FLAG;
-}
-void ArenaImpl_UnsetFillFreeBlock(Arena* arena) {
-    arena->flag &= ~FILL_FREE_BLOCK_FLAG;
-}
-void ArenaImpl_UnsetCheckFreeBlock(Arena* arena) {
-    arena->flag &= ~CHECK_FREE_BLOCK_FLAG;
-}
-
-void ArenaImpl_SetDebugInfo(ArenaNode* node, const char* file, int line, Arena* arena) {
-    node->filename = file;
-    node->line = line;
-    node->threadId = osGetThreadId(NULL);
-    node->arena = arena;
-    node->time = osGetTime();
-}
-#endif
-
-void ArenaImpl_LockInit(Arena* arena) {
-    osCreateMesgQueue(&arena->lockQueue, &sArenaLockMsg, 1);
-}
-
-void ArenaImpl_Lock(Arena* arena) {
-    osSendMesg(&arena->lockQueue, NULL, OS_MESG_BLOCK);
-}
-
-void ArenaImpl_Unlock(Arena* arena) {
-    osRecvMesg(&arena->lockQueue, NULL, OS_MESG_BLOCK);
-}
-
-#if OOT_DEBUG
-ArenaNode* ArenaImpl_GetNextBlock(ArenaNode* node) {
-    ArenaNode* next = node->next;
-
-    if (next != NULL && (next == NULL || (next->magic != NODE_MAGIC))) {
-        osSyncPrintf(VT_COL(RED, WHITE) T("緊急事態！メモリリーク発見！ (block=%08x)\n",
-                                          "Emergency! Memory leak detected! (block=%08x)\n") VT_RST,
-                     next);
-        next = NULL;
-        node->next = NULL;
-    }
-    return next;
-}
-
-ArenaNode* ArenaImpl_GetPrevBlock(ArenaNode* node) {
-    ArenaNode* prev = node->prev;
-
-    if (prev != NULL && (prev == NULL || (prev->magic != NODE_MAGIC))) {
-        osSyncPrintf(VT_COL(RED, WHITE) T("緊急事態！メモリリーク発見！ (block=%08x)\n",
-                                          "Emergency! Memory leak detected! (block=%08x)\n") VT_RST,
-                     prev);
-        prev = NULL;
-        node->prev = NULL;
-    }
-    return prev;
-}
-#endif
-
-ArenaNode* ArenaImpl_GetLastBlock(Arena* arena) {
-    ArenaNode* last = NULL;
-    ArenaNode* iter;
-
-    if (arena != NULL && NODE_IS_VALID(arena->head)) {
-        iter = arena->head;
-        while (iter != NULL) {
-            last = iter;
-            iter = NODE_GET_NEXT(last);
-        }
-    }
-    return last;
-}
-
-void __osMallocInit(Arena* arena, void* start, u32 size) {
-    bzero(arena, sizeof(Arena));
-    ArenaImpl_LockInit(arena);
-    __osMallocAddBlock(arena, start, size);
-    arena->isInit = true;
-}
-
-void __osMallocAddBlock(Arena* arena, void* start, s32 size) {
-    s32 diff;
-    s32 size2;
-    ArenaNode* firstNode;
-    ArenaNode* lastNode;
-
-    if (start != NULL) {
-        firstNode = (ArenaNode*)ALIGN16((u32)start);
-        diff = (s32)firstNode - (s32)start;
-        size2 = (size - diff) & ~0xF;
-
-        if (size2 > (s32)sizeof(ArenaNode)) {
-#if OOT_DEBUG
-            memset(firstNode, BLOCK_UNINIT_MAGIC, size2);
-#endif
-            firstNode->next = NULL;
-            firstNode->prev = NULL;
-            firstNode->size = size2 - sizeof(ArenaNode);
-            firstNode->isFree = true;
-            firstNode->magic = NODE_MAGIC;
-            ArenaImpl_Lock(arena);
-            lastNode = ArenaImpl_GetLastBlock(arena);
-            if (lastNode == NULL) {
-                arena->head = firstNode;
-                arena->start = start;
-            } else {
-                firstNode->prev = lastNode;
-                lastNode->next = firstNode;
-            }
-            ArenaImpl_Unlock(arena);
-        }
-    }
-}
-
-#if OOT_DEBUG
-void ArenaImpl_RemoveAllBlocks(Arena* arena) {
-    ArenaNode* iter;
-    ArenaNode* next;
-
-    ArenaImpl_Lock(arena);
-
-    iter = arena->head;
-    while (iter != NULL) {
-        next = NODE_GET_NEXT(iter);
-        memset(iter, BLOCK_UNINIT_MAGIC, iter->size + sizeof(ArenaNode));
-        iter = next;
-    }
-
-    ArenaImpl_Unlock(arena);
-}
-#endif
-
-void __osMallocCleanup(Arena* arena) {
-#if OOT_DEBUG
-    ArenaImpl_RemoveAllBlocks(arena);
-#endif
-    bzero(arena, sizeof(*arena));
-}
-
-u8 __osMallocIsInitialized(Arena* arena) {
-    return arena->isInit;
-}
-
-#if OOT_DEBUG
-void __osMalloc_FreeBlockTest(Arena* arena, ArenaNode* node) {
-    ArenaNode* node2 = node;
-    u32* start;
-    u32* end;
-    u32* iter;
-
-    if (__osMalloc_FreeBlockTest_Enable) {
-        start = (u32*)((u32)node + sizeof(ArenaNode));
-        end = (u32*)((u32)start + node2->size);
-        iter = start;
-
-        while (iter < end) {
-            if (*iter != BLOCK_UNINIT_MAGIC_32 && *iter != BLOCK_FREE_MAGIC_32) {
-                osSyncPrintf(VT_COL(RED, WHITE)
-                                 T("緊急事態！メモリリーク検出！ (block=%08x s=%08x e=%08x p=%08x)\n",
-                                   "Emergency! Memory leak detected! (block=%08x s=%08x e=%08x p=%08x)\n") VT_RST,
-                             node, start, end, iter);
-                __osDisplayArena(arena);
-                return;
-            }
-            iter++;
-        }
-    }
-}
-
-void* __osMalloc_NoLockDebug(Arena* arena, u32 size, const char* file, int line) {
-    ArenaNode* iter;
-    u32 blockSize;
-    ArenaNode* newNode;
-    void* alloc = NULL;
-    ArenaNode* next;
-
-    iter = arena->head;
-    size = ALIGN16(size);
-    blockSize = ALIGN16(size) + sizeof(ArenaNode);
-
-    while (iter != NULL) {
-        if (iter->isFree && iter->size >= size) {
-            CHECK_FREE_BLOCK(arena, iter);
-
-            if (blockSize < iter->size) {
-                newNode = (ArenaNode*)((u32)iter + blockSize);
-                newNode->next = NODE_GET_NEXT(iter);
-                newNode->prev = iter;
-                newNode->size = iter->size - blockSize;
-                newNode->isFree = true;
-                newNode->magic = NODE_MAGIC;
-
-                iter->next = newNode;
-                iter->size = size;
-                next = NODE_GET_NEXT(newNode);
-                if (next) {
-                    next->prev = newNode;
-                }
-            }
-
-            iter->isFree = false;
-            SET_DEBUG_INFO(iter, file, line, arena);
-            alloc = (void*)((u32)iter + sizeof(ArenaNode));
-            FILL_ALLOC_BLOCK(arena, alloc, size);
-
-            break;
-        }
-
-        iter = NODE_GET_NEXT(iter);
-    }
-
-    return alloc;
-}
-
-void* __osMallocDebug(Arena* arena, u32 size, const char* file, int line) {
-    void* alloc;
-
-    ArenaImpl_Lock(arena);
-    alloc = __osMalloc_NoLockDebug(arena, size, file, line);
-    ArenaImpl_Unlock(arena);
-
-    return alloc;
-}
-
-void* __osMallocRDebug(Arena* arena, u32 size, const char* file, int line) {
-    ArenaNode* iter;
-    ArenaNode* newNode;
-    u32 blockSize;
-    ArenaNode* next;
-    void* allocR = NULL;
-
-    size = ALIGN16(size);
-    ArenaImpl_Lock(arena);
-    iter = ArenaImpl_GetLastBlock(arena);
-
-    while (iter != NULL) {
-        if (iter->isFree && iter->size >= size) {
-            CHECK_FREE_BLOCK(arena, iter);
-
-            blockSize = ALIGN16(size) + sizeof(ArenaNode);
-            if (blockSize < iter->size) {
-                newNode = (ArenaNode*)((u32)iter + (iter->size - size));
-                newNode->next = NODE_GET_NEXT(iter);
-                newNode->prev = iter;
-                newNode->size = size;
-                newNode->magic = NODE_MAGIC;
-
-                iter->next = newNode;
-                iter->size -= blockSize;
-                next = NODE_GET_NEXT(newNode);
-                if (next) {
-                    next->prev = newNode;
-                }
-                iter = newNode;
-            }
-
-            iter->isFree = false;
-            SET_DEBUG_INFO(iter, file, line, arena);
-            allocR = (void*)((u32)iter + sizeof(ArenaNode));
-            FILL_ALLOC_BLOCK(arena, allocR, size);
-
-            break;
-        }
-
-        iter = NODE_GET_PREV(iter);
-    }
-    ArenaImpl_Unlock(arena);
-
-    return allocR;
-}
-#endif
-
-void* __osMalloc_NoLock(Arena* arena, u32 size) {
-    ArenaNode* iter;
-    u32 blockSize;
-    ArenaNode* newNode;
-    void* alloc = NULL;
-    ArenaNode* next;
-
-    size = ALIGN16(size);
-    blockSize = ALIGN16(size) + sizeof(ArenaNode);
-    iter = arena->head;
-
-    while (iter != NULL) {
-
-        if (iter->isFree && iter->size >= size) {
-            CHECK_FREE_BLOCK(arena, iter);
-            if (blockSize < iter->size) {
-                newNode = (ArenaNode*)((u32)iter + blockSize);
-                newNode->next = NODE_GET_NEXT(iter);
-                newNode->prev = iter;
-                newNode->size = iter->size - blockSize;
-                newNode->isFree = true;
-                newNode->magic = NODE_MAGIC;
-
-                iter->next = newNode;
-                iter->size = size;
-                next = NODE_GET_NEXT(newNode);
-                if (next) {
-                    next->prev = newNode;
-                }
-            }
-
-            iter->isFree = false;
-            SET_DEBUG_INFO(iter, NULL, 0, arena);
-            alloc = (void*)((u32)iter + sizeof(ArenaNode));
-            FILL_ALLOC_BLOCK(arena, alloc, size);
-            break;
-        }
-
-        iter = NODE_GET_NEXT(iter);
-    }
-
-    CHECK_ALLOC_FAILURE(arena, alloc);
-
-    return alloc;
-}
-
-void* __osMalloc(Arena* arena, u32 size) {
-    void* alloc;
-
-    ArenaImpl_Lock(arena);
-    alloc = __osMalloc_NoLock(arena, size);
-    ArenaImpl_Unlock(arena);
-
-    return alloc;
-}
-
-void* __osMallocR(Arena* arena, u32 size) {
-    ArenaNode* iter;
-    ArenaNode* allocNode;
-    ArenaNode* newNode;
-    ArenaNode* next;
-    void* alloc = NULL;
-    u32 blockSize;
-
-    size = ALIGN16(size);
-    blockSize = ALIGN16(size) + sizeof(ArenaNode);
-    ArenaImpl_Lock(arena);
-    iter = ArenaImpl_GetLastBlock(arena);
-
-    while (iter != NULL) {
-        if (iter->isFree && iter->size >= size) {
-            CHECK_FREE_BLOCK(arena, iter);
-
-            if (blockSize < iter->size) {
-                allocNode = (ArenaNode*)((u32)iter + (iter->size - size));
-                allocNode->next = NODE_GET_NEXT(iter);
-
-                newNode = allocNode;
-                newNode->prev = iter;
-                newNode->size = size;
-                newNode->magic = NODE_MAGIC;
-
-                iter->next = newNode;
-                iter->size -= blockSize;
-                next = NODE_GET_NEXT(newNode);
-                if (next) {
-                    next->prev = newNode;
-                }
-                iter = newNode;
-            }
-
-            iter->isFree = false;
-            SET_DEBUG_INFO(iter, NULL, 0, arena);
-            alloc = (void*)((u32)iter + sizeof(ArenaNode));
-            FILL_ALLOC_BLOCK(arena, alloc, size);
-            break;
-        }
-        iter = NODE_GET_PREV(iter);
-    }
-
-    CHECK_ALLOC_FAILURE(arena, alloc);
-
-    ArenaImpl_Unlock(arena);
-
-    return alloc;
-}
-
-void __osFree_NoLock(Arena* arena, void* ptr) {
-    ArenaNode* node;
-    ArenaNode* next;
-    ArenaNode* prev;
-
-    if (ptr == NULL) {
-        return;
-    }
-
-    node = (ArenaNode*)((u32)ptr - sizeof(ArenaNode));
-    if (node == NULL || node->magic != NODE_MAGIC) {
-        PRINTF(VT_COL(RED, WHITE) T("__osFree:不正解放(%08x)\n", "__osFree: Unauthorized release (%08x)\n") VT_RST,
-               ptr);
-        return;
-    }
-    if (node->isFree) {
-        PRINTF(VT_COL(RED, WHITE) T("__osFree:二重解放(%08x)\n", "__osFree: Double release (%08x)\n") VT_RST, ptr);
-        return;
-    }
-#if OOT_DEBUG
-    if (arena != node->arena && arena != NULL) {
-        PRINTF(VT_COL(RED, WHITE)
-                   T("__osFree:確保時と違う方法で解放しようとした (%08x:%08x)\n",
-                     "__osFree:Tried to release in a different way than when it was secured (%08x:%08x)\n") VT_RST,
-               arena, node->arena);
-        return;
-    }
-#endif
-
-    next = NODE_GET_NEXT(node);
-    prev = NODE_GET_PREV(node);
-    node->isFree = true;
-    SET_DEBUG_INFO(node, NULL, 0, arena);
-
-    FILL_FREE_BLOCK_CONTENTS(arena, node);
-
-    if ((u32)next == (u32)node + sizeof(ArenaNode) + node->size && next->isFree) {
-        ArenaNode* newNext = NODE_GET_NEXT(next);
-        if (newNext != NULL) {
-            newNext->prev = node;
-        }
-
-        node->size += next->size + sizeof(ArenaNode);
-        FILL_FREE_BLOCK_HEADER(arena, next);
-        node->next = newNext;
-        next = newNext;
-    }
-
-    if (prev != NULL && prev->isFree && (u32)node == (u32)prev + sizeof(ArenaNode) + prev->size) {
-        if (next) {
-            next->prev = prev;
-        }
-        prev->next = next;
-        prev->size += node->size + sizeof(ArenaNode);
-        FILL_FREE_BLOCK_HEADER(arena, node);
-    }
-}
-
-void __osFree(Arena* arena, void* ptr) {
-    ArenaImpl_Lock(arena);
-    __osFree_NoLock(arena, ptr);
-    ArenaImpl_Unlock(arena);
-}
-
-#if OOT_DEBUG
-void __osFree_NoLockDebug(Arena* arena, void* ptr, const char* file, int line) {
-    ArenaNode* node;
-    ArenaNode* next;
-    ArenaNode* prev;
-    ArenaNode* newNext;
-
-    if (ptr == NULL) {
-        return;
-    }
-
-    node = (ArenaNode*)((u32)ptr - sizeof(ArenaNode));
-    if (node == NULL || node->magic != NODE_MAGIC) {
-        PRINTF(VT_COL(RED, WHITE)
-                   T("__osFree:不正解放(%08x) [%s:%d ]\n", "__osFree: Unauthorized release (%08x) [%s:%d ]\n") VT_RST,
-               ptr, file, line);
-        return;
-    }
-    if (node->isFree) {
-        PRINTF(VT_COL(RED, WHITE) T("__osFree:二重解放(%08x) [%s:%d ]\n", "__osFree: Double release (%08x) [%s:%d ]\n")
-                   VT_RST,
-               ptr, file, line);
-        return;
-    }
-    if (arena != node->arena && arena != NULL) {
-        PRINTF(VT_COL(RED, WHITE)
-                   T("__osFree:確保時と違う方法で解放しようとした (%08x:%08x)\n",
-                     "__osFree:Tried to release in a different way than when it was secured (%08x:%08x)\n") VT_RST,
-               arena, node->arena);
-        return;
-    }
-
-    next = NODE_GET_NEXT(node);
-    prev = NODE_GET_PREV(node);
-    node->isFree = true;
-    SET_DEBUG_INFO(node, file, line, arena);
-
-    FILL_FREE_BLOCK_CONTENTS(arena, node);
-
-    newNext = node->next;
-    if ((u32)next == (u32)node + sizeof(ArenaNode) + node->size && next->isFree) {
-        newNext = NODE_GET_NEXT(next);
-        if (newNext != NULL) {
-            newNext->prev = node;
-        }
-
-        node->size += next->size + sizeof(ArenaNode);
-        FILL_FREE_BLOCK_HEADER(arena, next);
-        node->next = newNext;
-        next = newNext;
-    }
-
-    if (prev != NULL && prev->isFree && (u32)node == (u32)prev + sizeof(ArenaNode) + prev->size) {
-        if (next != NULL) {
-            next->prev = prev;
-        }
-        prev->next = next;
-        prev->size += node->size + sizeof(ArenaNode);
-        FILL_FREE_BLOCK_HEADER(arena, node);
-    }
-}
-
-void __osFreeDebug(Arena* arena, void* ptr, const char* file, int line) {
-    ArenaImpl_Lock(arena);
-    __osFree_NoLockDebug(arena, ptr, file, line);
-    ArenaImpl_Unlock(arena);
-}
-#endif
-
-void* __osRealloc(Arena* arena, void* ptr, u32 newSize) {
-    ArenaNode* node;
-    void* newAlloc;
-    ArenaNode* next;
-    ArenaNode* newNext;
-    ArenaNode* overNext;
-    ArenaNode* newNext2;
-    ArenaNode* next2;
-    u32 sizeDiff;
-    ArenaNode* overNext2;
-    ArenaNode localCopy;
-    u32 blockSize;
-    s32 pad;
-
-    newSize = ALIGN16(newSize);
-    osSyncPrintf("__osRealloc(%08x, %d)\n", ptr, newSize);
-    ArenaImpl_Lock(arena);
-
-    if (ptr == NULL) {
-        ptr = __osMalloc_NoLock(arena, newSize);
-    } else if (newSize == 0) {
-        __osFree_NoLock(arena, ptr);
-        ptr = NULL;
-    } else {
-        node = (ArenaNode*)((u32)ptr - sizeof(ArenaNode));
-        if (newSize == node->size) {
-            osSyncPrintf(T("メモリブロックサイズが変わらないためなにもしません\n",
-                           "Does nothing because the memory block size does not change\n"));
-        } else if (node->size < newSize) {
-            next = NODE_GET_NEXT(node);
-            sizeDiff = newSize - node->size;
-            if ((u32)next == ((u32)node + node->size + sizeof(ArenaNode)) && next->isFree && next->size >= sizeDiff) {
-                osSyncPrintf(T("現メモリブロックの後ろにフリーブロックがあるので結合します\n",
-                               "Merge because there is a free block after the current memory block\n"));
-                next->size -= sizeDiff;
-                overNext = NODE_GET_NEXT(next);
-                newNext = (ArenaNode*)((u32)next + sizeDiff);
-                if (overNext != NULL) {
-                    overNext->prev = newNext;
-                }
-                node->next = newNext;
-                node->size = newSize;
-                memmove(node->next, next, sizeof(ArenaNode));
-            } else {
-                osSyncPrintf(T("新たにメモリブロックを確保して内容を移動します\n",
-                               "Allocate a new memory block and move the contents\n"));
-                newAlloc = __osMalloc_NoLock(arena, newSize);
-                if (newAlloc != NULL) {
-                    bcopy(ptr, newAlloc, node->size);
-                    __osFree_NoLock(arena, ptr);
-                }
-                ptr = newAlloc;
-            }
-        } else if (newSize < node->size) {
-            next2 = NODE_GET_NEXT(node);
-            if (next2 != NULL && next2->isFree) {
-                blockSize = ALIGN16(newSize) + sizeof(ArenaNode);
-
-                osSyncPrintf(T("現メモリブロックの後ろのフリーブロックを大きくしました\n",
-                               "Increased free block behind current memory block\n"));
-                newNext2 = (ArenaNode*)((u32)node + blockSize);
-                localCopy = *next2;
-                *newNext2 = localCopy;
-                newNext2->size += node->size - newSize;
-                node->next = newNext2;
-                node->size = newSize;
-                overNext2 = NODE_GET_NEXT(newNext2);
-                if (overNext2 != NULL) {
-                    overNext2->prev = newNext2;
-                }
-            } else if (newSize + sizeof(ArenaNode) < node->size) {
-                blockSize = ALIGN16(newSize) + sizeof(ArenaNode);
-
-                osSyncPrintf(T("現メモリブロックの後ろにフリーブロックがないので生成します\n",
-                               "Generated because there is no free block after the current memory block\n"));
-                newNext2 = (ArenaNode*)((u32)node + blockSize);
-                newNext2->next = NODE_GET_NEXT(node);
-                newNext2->prev = node;
-                newNext2->size = node->size - blockSize;
-                newNext2->isFree = true;
-                newNext2->magic = NODE_MAGIC;
-                node->next = newNext2;
-                node->size = newSize;
-                overNext2 = NODE_GET_NEXT(newNext2);
-                if (overNext2 != NULL) {
-                    overNext2->prev = newNext2;
-                }
-            } else {
-                osSyncPrintf(
-                    T("フリーブロック生成するだけの空きがありません\n", "There is no room to generate free blocks\n"));
-                ptr = NULL;
-            }
-        }
-
-        CHECK_ALLOC_FAILURE(arena, ptr);
-    }
-    ArenaImpl_Unlock(arena);
-
-    return ptr;
-}
-
-#if OOT_DEBUG
-void* __osReallocDebug(Arena* arena, void* ptr, u32 newSize, const char* file, int line) {
-    return __osRealloc(arena, ptr, newSize);
-}
-#endif
-
-void ArenaImpl_GetSizes(Arena* arena, u32* outMaxFree, u32* outFree, u32* outAlloc) {
-    ArenaNode* iter;
-
-    ArenaImpl_Lock(arena);
-
-    *outMaxFree = 0;
-    *outFree = 0;
-    *outAlloc = 0;
-
-    iter = arena->head;
-    while (iter != NULL) {
-        if (iter->isFree) {
-            *outFree += iter->size;
-            if (*outMaxFree < iter->size) {
-                *outMaxFree = iter->size;
-            }
-        } else {
-            *outAlloc += iter->size;
-        }
-
-        iter = NODE_GET_NEXT(iter);
-    }
-
-    ArenaImpl_Unlock(arena);
-}
-
-#if OOT_DEBUG
-void __osDisplayArena(Arena* arena) {
-    u32 freeSize;
-    u32 allocatedSize;
-    u32 maxFree;
-    ArenaNode* iter;
-    ArenaNode* next;
-
-    if (!__osMallocIsInitialized(arena)) {
-        osSyncPrintf(T("アリーナは初期化されていません\n", "Arena is not initialized\n"));
-        return;
-    }
-
-    ArenaImpl_Lock(arena);
-
-    maxFree = 0;
-    freeSize = 0;
-    allocatedSize = 0;
-
-    osSyncPrintf(T("アリーナの内容 (0x%08x)\n", "Arena contents (0x%08x)\n"), arena);
-    osSyncPrintf(T("メモリブロック範囲 status サイズ  [時刻  s ms us ns: TID:src:行]\n",
-                   "Memory node range status size [time s ms us ns: TID:src:line]\n"));
-
-    iter = arena->head;
-    while (iter != NULL) {
-        if (iter != NULL && iter->magic == NODE_MAGIC) {
-            next = iter->next;
-            osSyncPrintf("%08x-%08x%c %s %08x", iter, ((u32)iter + sizeof(ArenaNode) + iter->size),
-                         (next == NULL) ? '$' : (iter != next->prev ? '!' : ' '),
-                         iter->isFree ? T("空き", "Free") : T("確保", "Secure"), iter->size);
-
-            if (!iter->isFree) {
-                osSyncPrintf(" [%016llu:%2d:%s:%d]", OS_CYCLES_TO_NSEC(iter->time), iter->threadId,
-                             iter->filename != NULL ? iter->filename : "**NULL**", iter->line);
-            }
-
-            osSyncPrintf("\n");
-
-            if (iter->isFree) {
-                freeSize += iter->size;
-                if (maxFree < iter->size) {
-                    maxFree = iter->size;
-                }
-            } else {
-                allocatedSize += iter->size;
-            }
-        } else {
-            osSyncPrintf("%08x Block Invalid\n", iter);
-            next = NULL;
-        }
-        iter = next;
-    }
-
-    osSyncPrintf(T("確保ブロックサイズの合計 0x%08x バイト\n", "Total reserved node size 0x%08x bytes\n"),
-                 allocatedSize);
-    osSyncPrintf(T("空きブロックサイズの合計 0x%08x バイト\n", "Total free node size 0x%08x bytes\n"), freeSize);
-    osSyncPrintf(T("最大空きブロックサイズ   0x%08x バイト\n", "Maximum free node size 0x%08x bytes\n"), maxFree);
-
-    ArenaImpl_Unlock(arena);
-}
-#endif
-
-void ArenaImpl_FaultClient(Arena* arena) {
-    u32 freeSize;
-    u32 allocatedSize;
-    u32 maxFree;
-    ArenaNode* iter;
-    ArenaNode* next;
-
-    Fault_Printf("ARENA INFO (0x%08x)\n", arena);
-    if (!__osMallocIsInitialized(arena)) {
-        Fault_Printf("Arena is uninitalized\n", arena);
-        return;
-    }
-
-    maxFree = 0;
-    freeSize = 0;
-    allocatedSize = 0;
-
-    Fault_Printf("Memory Block Region status size\n");
-
-    iter = arena->head;
-    while (iter != NULL) {
-        if (iter != NULL && iter->magic == NODE_MAGIC) {
-            next = iter->next;
-            Fault_Printf("%08x-%08x%c %s %08x", iter, ((u32)iter + sizeof(ArenaNode) + iter->size),
-                         (!next) ? '$' : (iter != next->prev ? '!' : ' '), iter->isFree ? "F" : "A", iter->size);
-
-            Fault_Printf("\n");
-
-            if (iter->isFree) {
-                freeSize += iter->size;
-                if (maxFree < iter->size) {
-                    maxFree = iter->size;
-                }
-            } else {
-                allocatedSize += iter->size;
-            }
-        } else {
-            Fault_SetFontColor(0xF801);
-            Fault_Printf("%08x Block Invalid\n", iter);
-            next = NULL;
-        }
-        iter = next;
-    }
-
-    Fault_SetFontColor(0x7F1);
-    Fault_Printf("Total Alloc Block Size  %08x\n", allocatedSize);
-    Fault_Printf("Total Free Block Size   %08x\n", freeSize);
-    Fault_Printf("Largest Free Block Size %08x\n", maxFree);
-}
-
-u32 __osCheckArena(Arena* arena) {
-    ArenaNode* iter;
-    u32 error = 0;
-
-    ArenaImpl_Lock(arena);
-    osSyncPrintf(
-        T("アリーナの内容をチェックしています．．． (%08x)\n", "Checking the contents of the arena... (%08x)\n"),
-        arena);
-    iter = arena->head;
-    while (iter != NULL) {
-        if (iter && iter->magic == NODE_MAGIC) {
-#if OOT_DEBUG
-            osSyncPrintf(VT_COL(RED, WHITE) T("おおっと！！ (%08x %08x)\n", "Oops!! (%08x %08x)\n") VT_RST, iter,
-                         iter->magic);
-#else
-            osSyncPrintf(T("おおっと！！ (%08x %08x)\n", "Oops!! (%08x %08x)\n"), iter, iter->magic);
-#endif
-            error = 1;
-            break;
-        }
-        iter = NODE_GET_NEXT(iter);
-    }
-    if (error == 0) {
-        osSyncPrintf(T("アリーナはまだ、いけそうです\n", "The arena is still going well\n"));
-    }
-    ArenaImpl_Unlock(arena);
-
-    return error;
-}
-
-#if OOT_DEBUG
-u8 ArenaImpl_GetAllocFailures(Arena* arena) {
-    return arena->allocFailures;
-}
-#endif
diff --git a/src/code/__osMalloc_gc.c b/src/code/__osMalloc_gc.c
new file mode 100644
index 000000000..45e19532f
--- /dev/null
+++ b/src/code/__osMalloc_gc.c
@@ -0,0 +1,895 @@
+#include "global.h"
+#include "fault.h"
+#include "osMalloc.h"
+#include "terminal.h"
+
+#if PLATFORM_GC
+
+#define FILL_ALLOC_BLOCK_FLAG (1 << 0)
+#define FILL_FREE_BLOCK_FLAG (1 << 1)
+#define CHECK_FREE_BLOCK_FLAG (1 << 2)
+
+#define NODE_MAGIC 0x7373
+
+#define BLOCK_UNINIT_MAGIC 0xAB
+#define BLOCK_UNINIT_MAGIC_32 0xABABABAB
+#define BLOCK_ALLOC_MAGIC 0xCD
+#define BLOCK_ALLOC_MAGIC_32 0xCDCDCDCD
+#define BLOCK_FREE_MAGIC 0xEF
+#define BLOCK_FREE_MAGIC_32 0xEFEFEFEF
+
+#define NODE_IS_VALID(node) (((node) != NULL) && ((node)->magic == NODE_MAGIC))
+
+#if OOT_DEBUG
+
+#define NODE_GET_NEXT(node) ArenaImpl_GetNextBlock(node)
+#define NODE_GET_PREV(node) ArenaImpl_GetPrevBlock(node)
+
+#define SET_DEBUG_INFO(node, file, line, arena) ArenaImpl_SetDebugInfo(node, file, line, arena)
+
+#define FILL_UNINIT_BLOCK(arena, node, size) memset(node, BLOCK_UNINIT_MAGIC, size)
+
+#define FILL_ALLOC_BLOCK(arena, alloc, size)   \
+    if ((arena)->flag & FILL_ALLOC_BLOCK_FLAG) \
+    memset(alloc, BLOCK_ALLOC_MAGIC, size)
+
+#define FILL_FREE_BLOCK_HEADER(arena, node)   \
+    if ((arena)->flag & FILL_FREE_BLOCK_FLAG) \
+    memset(node, BLOCK_FREE_MAGIC, sizeof(ArenaNode))
+
+#define FILL_FREE_BLOCK_CONTENTS(arena, node) \
+    if ((arena)->flag & FILL_FREE_BLOCK_FLAG) \
+    memset((void*)((u32)(node) + sizeof(ArenaNode)), BLOCK_FREE_MAGIC, (node)->size)
+
+#define CHECK_FREE_BLOCK(arena, node)          \
+    if ((arena)->flag & CHECK_FREE_BLOCK_FLAG) \
+    __osMalloc_FreeBlockTest(arena, node)
+
+#define CHECK_ALLOC_FAILURE(arena, ptr) (void)0
+
+#else
+
+#define NODE_GET_NEXT(node) (NODE_IS_VALID((node)->next) ? (node)->next : NULL)
+#define NODE_GET_PREV(node) (NODE_IS_VALID((node)->prev) ? (node)->prev : NULL)
+
+#define SET_DEBUG_INFO(node, file, line, arena) (void)0
+#define FILL_UNINIT_BLOCK(arena, node, size) (void)0
+#define FILL_ALLOC_BLOCK(arena, alloc, size) (void)0
+#define FILL_FREE_BLOCK_HEADER(arena, node) (void)0
+#define FILL_FREE_BLOCK_CONTENTS(arena, node) (void)0
+#define CHECK_FREE_BLOCK(arena, node) (void)0
+
+// Number of allocation failures across all arenas.
+u32 gTotalAllocFailures = 0; // "Arena_failcnt"
+
+#define CHECK_ALLOC_FAILURE(arena, ptr) \
+    do {                                \
+        if ((ptr) == NULL) {            \
+            gTotalAllocFailures++;      \
+            (arena)->allocFailures++;   \
+        }                               \
+    } while (0)
+
+#endif
+
+OSMesg sArenaLockMsg;
+
+void __osMallocAddBlock(Arena* arena, void* start, s32 size);
+
+#if OOT_DEBUG
+u32 __osMalloc_FreeBlockTest_Enable;
+
+u32 ArenaImpl_GetFillAllocBlock(Arena* arena) {
+    return (arena->flag & FILL_ALLOC_BLOCK_FLAG) != 0;
+}
+u32 ArenaImpl_GetFillFreeBlock(Arena* arena) {
+    return (arena->flag & FILL_FREE_BLOCK_FLAG) != 0;
+}
+u32 ArenaImpl_GetCheckFreeBlock(Arena* arena) {
+    return (arena->flag & CHECK_FREE_BLOCK_FLAG) != 0;
+}
+
+void ArenaImpl_SetFillAllocBlock(Arena* arena) {
+    arena->flag |= FILL_ALLOC_BLOCK_FLAG;
+}
+void ArenaImpl_SetFillFreeBlock(Arena* arena) {
+    arena->flag |= FILL_FREE_BLOCK_FLAG;
+}
+void ArenaImpl_SetCheckFreeBlock(Arena* arena) {
+    arena->flag |= CHECK_FREE_BLOCK_FLAG;
+}
+
+void ArenaImpl_UnsetFillAllocBlock(Arena* arena) {
+    arena->flag &= ~FILL_ALLOC_BLOCK_FLAG;
+}
+void ArenaImpl_UnsetFillFreeBlock(Arena* arena) {
+    arena->flag &= ~FILL_FREE_BLOCK_FLAG;
+}
+void ArenaImpl_UnsetCheckFreeBlock(Arena* arena) {
+    arena->flag &= ~CHECK_FREE_BLOCK_FLAG;
+}
+
+void ArenaImpl_SetDebugInfo(ArenaNode* node, const char* file, int line, Arena* arena) {
+    node->filename = file;
+    node->line = line;
+    node->threadId = osGetThreadId(NULL);
+    node->arena = arena;
+    node->time = osGetTime();
+}
+#endif
+
+void ArenaImpl_LockInit(Arena* arena) {
+    osCreateMesgQueue(&arena->lockQueue, &sArenaLockMsg, 1);
+}
+
+void ArenaImpl_Lock(Arena* arena) {
+    osSendMesg(&arena->lockQueue, NULL, OS_MESG_BLOCK);
+}
+
+void ArenaImpl_Unlock(Arena* arena) {
+    osRecvMesg(&arena->lockQueue, NULL, OS_MESG_BLOCK);
+}
+
+#if OOT_DEBUG
+ArenaNode* ArenaImpl_GetNextBlock(ArenaNode* node) {
+    ArenaNode* next = node->next;
+
+    if (next != NULL && (next == NULL || (next->magic != NODE_MAGIC))) {
+        osSyncPrintf(VT_COL(RED, WHITE) T("緊急事態！メモリリーク発見！ (block=%08x)\n",
+                                          "Emergency! Memory leak detected! (block=%08x)\n") VT_RST,
+                     next);
+        next = NULL;
+        node->next = NULL;
+    }
+    return next;
+}
+
+ArenaNode* ArenaImpl_GetPrevBlock(ArenaNode* node) {
+    ArenaNode* prev = node->prev;
+
+    if (prev != NULL && (prev == NULL || (prev->magic != NODE_MAGIC))) {
+        osSyncPrintf(VT_COL(RED, WHITE) T("緊急事態！メモリリーク発見！ (block=%08x)\n",
+                                          "Emergency! Memory leak detected! (block=%08x)\n") VT_RST,
+                     prev);
+        prev = NULL;
+        node->prev = NULL;
+    }
+    return prev;
+}
+#endif
+
+ArenaNode* ArenaImpl_GetLastBlock(Arena* arena) {
+    ArenaNode* last = NULL;
+    ArenaNode* iter;
+
+    if (arena != NULL && NODE_IS_VALID(arena->head)) {
+        iter = arena->head;
+        while (iter != NULL) {
+            last = iter;
+            iter = NODE_GET_NEXT(last);
+        }
+    }
+    return last;
+}
+
+void __osMallocInit(Arena* arena, void* start, s32 size) {
+    bzero(arena, sizeof(Arena));
+    ArenaImpl_LockInit(arena);
+    __osMallocAddBlock(arena, start, size);
+    arena->isInit = true;
+}
+
+void __osMallocAddBlock(Arena* arena, void* start, s32 size) {
+    s32 diff;
+    s32 size2;
+    ArenaNode* firstNode;
+    ArenaNode* lastNode;
+
+    if (start != NULL) {
+        firstNode = (ArenaNode*)ALIGN16((u32)start);
+        diff = (s32)firstNode - (s32)start;
+        size2 = (size - diff) & ~0xF;
+
+        if (size2 > (s32)sizeof(ArenaNode)) {
+            FILL_UNINIT_BLOCK(arena, firstNode, size2);
+            firstNode->next = NULL;
+            firstNode->prev = NULL;
+            firstNode->size = size2 - sizeof(ArenaNode);
+            firstNode->isFree = true;
+            firstNode->magic = NODE_MAGIC;
+            ArenaImpl_Lock(arena);
+            lastNode = ArenaImpl_GetLastBlock(arena);
+            if (lastNode == NULL) {
+                arena->head = firstNode;
+                arena->start = start;
+            } else {
+                firstNode->prev = lastNode;
+                lastNode->next = firstNode;
+            }
+            ArenaImpl_Unlock(arena);
+        }
+    }
+}
+
+#if OOT_DEBUG
+void ArenaImpl_RemoveAllBlocks(Arena* arena) {
+    ArenaNode* iter;
+    ArenaNode* next;
+
+    ArenaImpl_Lock(arena);
+
+    iter = arena->head;
+    while (iter != NULL) {
+        next = NODE_GET_NEXT(iter);
+        memset(iter, BLOCK_UNINIT_MAGIC, iter->size + sizeof(ArenaNode));
+        iter = next;
+    }
+
+    ArenaImpl_Unlock(arena);
+}
+#endif
+
+void __osMallocCleanup(Arena* arena) {
+#if OOT_DEBUG
+    ArenaImpl_RemoveAllBlocks(arena);
+#endif
+    bzero(arena, sizeof(*arena));
+}
+
+s32 __osMallocIsInitialized(Arena* arena) {
+    return arena->isInit;
+}
+
+#if OOT_DEBUG
+void __osMalloc_FreeBlockTest(Arena* arena, ArenaNode* node) {
+    ArenaNode* node2 = node;
+    u32* start;
+    u32* end;
+    u32* iter;
+
+    if (__osMalloc_FreeBlockTest_Enable) {
+        start = (u32*)((u32)node + sizeof(ArenaNode));
+        end = (u32*)((u32)start + node2->size);
+        iter = start;
+
+        while (iter < end) {
+            if (*iter != BLOCK_UNINIT_MAGIC_32 && *iter != BLOCK_FREE_MAGIC_32) {
+                osSyncPrintf(VT_COL(RED, WHITE)
+                                 T("緊急事態！メモリリーク検出！ (block=%08x s=%08x e=%08x p=%08x)\n",
+                                   "Emergency! Memory leak detected! (block=%08x s=%08x e=%08x p=%08x)\n") VT_RST,
+                             node, start, end, iter);
+                __osDisplayArena(arena);
+                return;
+            }
+            iter++;
+        }
+    }
+}
+
+void* __osMalloc_NoLockDebug(Arena* arena, u32 size, const char* file, int line) {
+    ArenaNode* iter;
+    u32 blockSize;
+    ArenaNode* newNode;
+    void* alloc = NULL;
+    ArenaNode* next;
+
+    size = ALIGN16(size);
+    blockSize = ALIGN16(size) + sizeof(ArenaNode);
+    iter = arena->head;
+
+    while (iter != NULL) {
+        if (iter->isFree && iter->size >= size) {
+            CHECK_FREE_BLOCK(arena, iter);
+
+            if (blockSize < iter->size) {
+                newNode = (ArenaNode*)((u32)iter + blockSize);
+                newNode->next = NODE_GET_NEXT(iter);
+                newNode->prev = iter;
+                newNode->size = iter->size - blockSize;
+                newNode->isFree = true;
+                newNode->magic = NODE_MAGIC;
+
+                iter->next = newNode;
+                iter->size = size;
+                next = NODE_GET_NEXT(newNode);
+                if (next) {
+                    next->prev = newNode;
+                }
+            }
+
+            iter->isFree = false;
+            SET_DEBUG_INFO(iter, file, line, arena);
+            alloc = (void*)((u32)iter + sizeof(ArenaNode));
+            FILL_ALLOC_BLOCK(arena, alloc, size);
+
+            break;
+        }
+
+        iter = NODE_GET_NEXT(iter);
+    }
+
+    return alloc;
+}
+
+void* __osMallocDebug(Arena* arena, u32 size, const char* file, int line) {
+    void* alloc;
+
+    ArenaImpl_Lock(arena);
+    alloc = __osMalloc_NoLockDebug(arena, size, file, line);
+    ArenaImpl_Unlock(arena);
+
+    return alloc;
+}
+
+void* __osMallocRDebug(Arena* arena, u32 size, const char* file, int line) {
+    ArenaNode* iter;
+    ArenaNode* newNode;
+    u32 blockSize;
+    ArenaNode* next;
+    void* allocR = NULL;
+
+    size = ALIGN16(size);
+    ArenaImpl_Lock(arena);
+    iter = ArenaImpl_GetLastBlock(arena);
+
+    while (iter != NULL) {
+        if (iter->isFree && iter->size >= size) {
+            CHECK_FREE_BLOCK(arena, iter);
+
+            blockSize = ALIGN16(size) + sizeof(ArenaNode);
+            if (blockSize < iter->size) {
+                newNode = (ArenaNode*)((u32)iter + (iter->size - size));
+                newNode->next = NODE_GET_NEXT(iter);
+                newNode->prev = iter;
+                newNode->size = size;
+                newNode->magic = NODE_MAGIC;
+
+                iter->next = newNode;
+                iter->size -= blockSize;
+                next = NODE_GET_NEXT(newNode);
+                if (next) {
+                    next->prev = newNode;
+                }
+                iter = newNode;
+            }
+
+            iter->isFree = false;
+            SET_DEBUG_INFO(iter, file, line, arena);
+            allocR = (void*)((u32)iter + sizeof(ArenaNode));
+            FILL_ALLOC_BLOCK(arena, allocR, size);
+
+            break;
+        }
+
+        iter = NODE_GET_PREV(iter);
+    }
+
+    ArenaImpl_Unlock(arena);
+
+    return allocR;
+}
+#endif
+
+void* __osMalloc_NoLock(Arena* arena, u32 size) {
+    ArenaNode* iter;
+    u32 blockSize;
+    ArenaNode* newNode;
+    void* alloc = NULL;
+    ArenaNode* next;
+
+    size = ALIGN16(size);
+    blockSize = ALIGN16(size) + sizeof(ArenaNode);
+    iter = arena->head;
+
+    while (iter != NULL) {
+        if (iter->isFree && iter->size >= size) {
+            CHECK_FREE_BLOCK(arena, iter);
+
+            if (blockSize < iter->size) {
+                newNode = (ArenaNode*)((u32)iter + blockSize);
+                newNode->next = NODE_GET_NEXT(iter);
+                newNode->prev = iter;
+                newNode->size = iter->size - blockSize;
+                newNode->isFree = true;
+                newNode->magic = NODE_MAGIC;
+
+                iter->next = newNode;
+                iter->size = size;
+                next = NODE_GET_NEXT(newNode);
+                if (next) {
+                    next->prev = newNode;
+                }
+            }
+
+            iter->isFree = false;
+            SET_DEBUG_INFO(iter, NULL, 0, arena);
+            alloc = (void*)((u32)iter + sizeof(ArenaNode));
+            FILL_ALLOC_BLOCK(arena, alloc, size);
+
+            break;
+        }
+
+        iter = NODE_GET_NEXT(iter);
+    }
+
+    CHECK_ALLOC_FAILURE(arena, alloc);
+
+    return alloc;
+}
+
+void* __osMalloc(Arena* arena, u32 size) {
+    void* alloc;
+
+    ArenaImpl_Lock(arena);
+    alloc = __osMalloc_NoLock(arena, size);
+    ArenaImpl_Unlock(arena);
+
+    return alloc;
+}
+
+void* __osMallocR(Arena* arena, u32 size) {
+    ArenaNode* iter;
+    ArenaNode* allocNode;
+    ArenaNode* newNode;
+    ArenaNode* next;
+    void* alloc = NULL;
+    u32 blockSize;
+
+    size = ALIGN16(size);
+    blockSize = ALIGN16(size) + sizeof(ArenaNode);
+    ArenaImpl_Lock(arena);
+    iter = ArenaImpl_GetLastBlock(arena);
+
+    while (iter != NULL) {
+        if (iter->isFree && iter->size >= size) {
+            CHECK_FREE_BLOCK(arena, iter);
+
+            if (blockSize < iter->size) {
+                allocNode = (ArenaNode*)((u32)iter + (iter->size - size));
+                allocNode->next = NODE_GET_NEXT(iter);
+
+                newNode = allocNode;
+                newNode->prev = iter;
+                newNode->size = size;
+                newNode->magic = NODE_MAGIC;
+
+                iter->next = newNode;
+                iter->size -= blockSize;
+                next = NODE_GET_NEXT(newNode);
+                if (next) {
+                    next->prev = newNode;
+                }
+                iter = newNode;
+            }
+
+            iter->isFree = false;
+            SET_DEBUG_INFO(iter, NULL, 0, arena);
+            alloc = (void*)((u32)iter + sizeof(ArenaNode));
+            FILL_ALLOC_BLOCK(arena, alloc, size);
+            break;
+        }
+        iter = NODE_GET_PREV(iter);
+    }
+
+    CHECK_ALLOC_FAILURE(arena, alloc);
+
+    ArenaImpl_Unlock(arena);
+
+    return alloc;
+}
+
+void __osFree_NoLock(Arena* arena, void* ptr) {
+    ArenaNode* node;
+    ArenaNode* next;
+    ArenaNode* prev;
+
+    if (ptr == NULL) {
+        return;
+    }
+
+    node = (ArenaNode*)((u32)ptr - sizeof(ArenaNode));
+    if (!NODE_IS_VALID(node)) {
+        PRINTF(VT_COL(RED, WHITE) T("__osFree:不正解放(%08x)\n", "__osFree: Unauthorized release (%08x)\n") VT_RST,
+               ptr);
+        return;
+    }
+    if (node->isFree) {
+        PRINTF(VT_COL(RED, WHITE) T("__osFree:二重解放(%08x)\n", "__osFree: Double release (%08x)\n") VT_RST, ptr);
+        return;
+    }
+#if OOT_DEBUG
+    if (arena != node->arena && arena != NULL) {
+        PRINTF(VT_COL(RED, WHITE)
+                   T("__osFree:確保時と違う方法で解放しようとした (%08x:%08x)\n",
+                     "__osFree:Tried to release in a different way than when it was secured (%08x:%08x)\n") VT_RST,
+               arena, node->arena);
+        return;
+    }
+#endif
+
+    next = NODE_GET_NEXT(node);
+    prev = NODE_GET_PREV(node);
+    node->isFree = true;
+    SET_DEBUG_INFO(node, NULL, 0, arena);
+
+    FILL_FREE_BLOCK_CONTENTS(arena, node);
+
+    if ((u32)next == (u32)node + sizeof(ArenaNode) + node->size && next->isFree) {
+        ArenaNode* newNext = NODE_GET_NEXT(next);
+        if (newNext != NULL) {
+            newNext->prev = node;
+        }
+
+        node->size += next->size + sizeof(ArenaNode);
+        FILL_FREE_BLOCK_HEADER(arena, next);
+        node->next = newNext;
+        next = newNext;
+    }
+
+    if (prev != NULL && prev->isFree && (u32)node == (u32)prev + sizeof(ArenaNode) + prev->size) {
+        if (next) {
+            next->prev = prev;
+        }
+        prev->next = next;
+        prev->size += node->size + sizeof(ArenaNode);
+        FILL_FREE_BLOCK_HEADER(arena, node);
+    }
+}
+
+void __osFree(Arena* arena, void* ptr) {
+    ArenaImpl_Lock(arena);
+    __osFree_NoLock(arena, ptr);
+    ArenaImpl_Unlock(arena);
+}
+
+#if OOT_DEBUG
+void __osFree_NoLockDebug(Arena* arena, void* ptr, const char* file, int line) {
+    ArenaNode* node;
+    ArenaNode* next;
+    ArenaNode* prev;
+    ArenaNode* newNext;
+
+    if (ptr == NULL) {
+        return;
+    }
+
+    node = (ArenaNode*)((u32)ptr - sizeof(ArenaNode));
+    if (!NODE_IS_VALID(node)) {
+        PRINTF(VT_COL(RED, WHITE)
+                   T("__osFree:不正解放(%08x) [%s:%d ]\n", "__osFree: Unauthorized release (%08x) [%s:%d ]\n") VT_RST,
+               ptr, file, line);
+        return;
+    }
+    if (node->isFree) {
+        PRINTF(VT_COL(RED, WHITE) T("__osFree:二重解放(%08x) [%s:%d ]\n", "__osFree: Double release (%08x) [%s:%d ]\n")
+                   VT_RST,
+               ptr, file, line);
+        return;
+    }
+    if (arena != node->arena && arena != NULL) {
+        PRINTF(VT_COL(RED, WHITE)
+                   T("__osFree:確保時と違う方法で解放しようとした (%08x:%08x)\n",
+                     "__osFree:Tried to release in a different way than when it was secured (%08x:%08x)\n") VT_RST,
+               arena, node->arena);
+        return;
+    }
+
+    next = NODE_GET_NEXT(node);
+    prev = NODE_GET_PREV(node);
+    node->isFree = true;
+    SET_DEBUG_INFO(node, file, line, arena);
+
+    FILL_FREE_BLOCK_CONTENTS(arena, node);
+
+    if ((u32)next == (u32)node + sizeof(ArenaNode) + node->size && next->isFree) {
+        newNext = NODE_GET_NEXT(next);
+        if (newNext != NULL) {
+            newNext->prev = node;
+        }
+
+        node->size += next->size + sizeof(ArenaNode);
+        FILL_FREE_BLOCK_HEADER(arena, next);
+        node->next = newNext;
+        next = newNext;
+    }
+
+    if (prev != NULL && prev->isFree && (u32)node == (u32)prev + sizeof(ArenaNode) + prev->size) {
+        if (next != NULL) {
+            next->prev = prev;
+        }
+        prev->next = next;
+        prev->size += node->size + sizeof(ArenaNode);
+        FILL_FREE_BLOCK_HEADER(arena, node);
+    }
+}
+
+void __osFreeDebug(Arena* arena, void* ptr, const char* file, int line) {
+    ArenaImpl_Lock(arena);
+    __osFree_NoLockDebug(arena, ptr, file, line);
+    ArenaImpl_Unlock(arena);
+}
+#endif
+
+void* __osRealloc(Arena* arena, void* ptr, u32 newSize) {
+    ArenaNode* node;
+    void* newAlloc;
+    ArenaNode* next;
+    ArenaNode* newNext;
+    ArenaNode* overNext;
+    ArenaNode* newNext2;
+    ArenaNode* next2;
+    u32 sizeDiff;
+    ArenaNode* overNext2;
+    ArenaNode localCopy;
+    u32 blockSize;
+    s32 pad;
+
+    newSize = ALIGN16(newSize);
+    osSyncPrintf("__osRealloc(%08x, %d)\n", ptr, newSize);
+    ArenaImpl_Lock(arena);
+
+    if (ptr == NULL) {
+        ptr = __osMalloc_NoLock(arena, newSize);
+    } else if (newSize == 0) {
+        __osFree_NoLock(arena, ptr);
+        ptr = NULL;
+    } else {
+        node = (ArenaNode*)((u32)ptr - sizeof(ArenaNode));
+        if (newSize == node->size) {
+            osSyncPrintf(T("メモリブロックサイズが変わらないためなにもしません\n",
+                           "Does nothing because the memory block size does not change\n"));
+        } else if (node->size < newSize) {
+            next = NODE_GET_NEXT(node);
+            sizeDiff = newSize - node->size;
+            if ((u32)next == ((u32)node + node->size + sizeof(ArenaNode)) && next->isFree && next->size >= sizeDiff) {
+                osSyncPrintf(T("現メモリブロックの後ろにフリーブロックがあるので結合します\n",
+                               "Merge because there is a free block after the current memory block\n"));
+                next->size -= sizeDiff;
+                overNext = NODE_GET_NEXT(next);
+                newNext = (ArenaNode*)((u32)next + sizeDiff);
+                if (overNext != NULL) {
+                    overNext->prev = newNext;
+                }
+                node->next = newNext;
+                node->size = newSize;
+                memmove(node->next, next, sizeof(ArenaNode));
+            } else {
+                osSyncPrintf(T("新たにメモリブロックを確保して内容を移動します\n",
+                               "Allocate a new memory block and move the contents\n"));
+                newAlloc = __osMalloc_NoLock(arena, newSize);
+                if (newAlloc != NULL) {
+                    bcopy(ptr, newAlloc, node->size);
+                    __osFree_NoLock(arena, ptr);
+                }
+                ptr = newAlloc;
+            }
+        } else if (newSize < node->size) {
+            next2 = NODE_GET_NEXT(node);
+            if (next2 != NULL && next2->isFree) {
+                blockSize = ALIGN16(newSize) + sizeof(ArenaNode);
+
+                osSyncPrintf(T("現メモリブロックの後ろのフリーブロックを大きくしました\n",
+                               "Increased free block behind current memory block\n"));
+                newNext2 = (ArenaNode*)((u32)node + blockSize);
+                localCopy = *next2;
+                *newNext2 = localCopy;
+                newNext2->size += node->size - newSize;
+                node->next = newNext2;
+                node->size = newSize;
+                overNext2 = NODE_GET_NEXT(newNext2);
+                if (overNext2 != NULL) {
+                    overNext2->prev = newNext2;
+                }
+            } else if (newSize + sizeof(ArenaNode) < node->size) {
+                blockSize = ALIGN16(newSize) + sizeof(ArenaNode);
+
+                osSyncPrintf(T("現メモリブロックの後ろにフリーブロックがないので生成します\n",
+                               "Generated because there is no free block after the current memory block\n"));
+                newNext2 = (ArenaNode*)((u32)node + blockSize);
+                newNext2->next = NODE_GET_NEXT(node);
+                newNext2->prev = node;
+                newNext2->size = node->size - blockSize;
+                newNext2->isFree = true;
+                newNext2->magic = NODE_MAGIC;
+                node->next = newNext2;
+                node->size = newSize;
+                overNext2 = NODE_GET_NEXT(newNext2);
+                if (overNext2 != NULL) {
+                    overNext2->prev = newNext2;
+                }
+            } else {
+                osSyncPrintf(
+                    T("フリーブロック生成するだけの空きがありません\n", "There is no room to generate free blocks\n"));
+                ptr = NULL;
+            }
+        }
+
+        CHECK_ALLOC_FAILURE(arena, ptr);
+    }
+    ArenaImpl_Unlock(arena);
+
+    return ptr;
+}
+
+#if OOT_DEBUG
+void* __osReallocDebug(Arena* arena, void* ptr, u32 newSize, const char* file, int line) {
+    return __osRealloc(arena, ptr, newSize);
+}
+#endif
+
+void ArenaImpl_GetSizes(Arena* arena, u32* outMaxFree, u32* outFree, u32* outAlloc) {
+    ArenaNode* iter;
+
+    ArenaImpl_Lock(arena);
+
+    *outMaxFree = 0;
+    *outFree = 0;
+    *outAlloc = 0;
+
+    iter = arena->head;
+    while (iter != NULL) {
+        if (iter->isFree) {
+            *outFree += iter->size;
+            if (*outMaxFree < iter->size) {
+                *outMaxFree = iter->size;
+            }
+        } else {
+            *outAlloc += iter->size;
+        }
+
+        iter = NODE_GET_NEXT(iter);
+    }
+
+    ArenaImpl_Unlock(arena);
+}
+
+#if OOT_DEBUG
+void __osDisplayArena(Arena* arena) {
+    u32 freeSize;
+    u32 allocatedSize;
+    u32 maxFree;
+    ArenaNode* iter;
+    ArenaNode* next;
+
+    if (!__osMallocIsInitialized(arena)) {
+        osSyncPrintf(T("アリーナは初期化されていません\n", "Arena is not initialized\n"));
+        return;
+    }
+
+    ArenaImpl_Lock(arena);
+
+    maxFree = 0;
+    freeSize = 0;
+    allocatedSize = 0;
+
+    osSyncPrintf(T("アリーナの内容 (0x%08x)\n", "Arena contents (0x%08x)\n"), arena);
+    osSyncPrintf(T("メモリブロック範囲 status サイズ  [時刻  s ms us ns: TID:src:行]\n",
+                   "Memory node range status size [time s ms us ns: TID:src:line]\n"));
+
+    iter = arena->head;
+    while (iter != NULL) {
+        if (iter != NULL && iter->magic == NODE_MAGIC) {
+            next = iter->next;
+            osSyncPrintf("%08x-%08x%c %s %08x", iter, ((u32)iter + sizeof(ArenaNode) + iter->size),
+                         (next == NULL) ? '$' : (iter != next->prev ? '!' : ' '),
+                         iter->isFree ? T("空き", "Free") : T("確保", "Secure"), iter->size);
+
+            if (!iter->isFree) {
+                osSyncPrintf(" [%016llu:%2d:%s:%d]", OS_CYCLES_TO_NSEC(iter->time), iter->threadId,
+                             iter->filename != NULL ? iter->filename : "**NULL**", iter->line);
+            }
+
+            osSyncPrintf("\n");
+
+            if (iter->isFree) {
+                freeSize += iter->size;
+                if (maxFree < iter->size) {
+                    maxFree = iter->size;
+                }
+            } else {
+                allocatedSize += iter->size;
+            }
+        } else {
+            osSyncPrintf("%08x Block Invalid\n", iter);
+            next = NULL;
+        }
+        iter = next;
+    }
+
+    osSyncPrintf(T("確保ブロックサイズの合計 0x%08x バイト\n", "Total reserved node size 0x%08x bytes\n"),
+                 allocatedSize);
+    osSyncPrintf(T("空きブロックサイズの合計 0x%08x バイト\n", "Total free node size 0x%08x bytes\n"), freeSize);
+    osSyncPrintf(T("最大空きブロックサイズ   0x%08x バイト\n", "Maximum free node size 0x%08x bytes\n"), maxFree);
+
+    ArenaImpl_Unlock(arena);
+}
+#endif
+
+void ArenaImpl_FaultClient(Arena* arena) {
+    u32 freeSize;
+    u32 allocatedSize;
+    u32 maxFree;
+    ArenaNode* iter;
+    ArenaNode* next;
+
+    Fault_Printf("ARENA INFO (0x%08x)\n", arena);
+    if (!__osMallocIsInitialized(arena)) {
+        Fault_Printf("Arena is uninitalized\n", arena);
+        return;
+    }
+
+    maxFree = 0;
+    freeSize = 0;
+    allocatedSize = 0;
+
+    Fault_Printf("Memory Block Region status size\n");
+
+    iter = arena->head;
+    while (iter != NULL) {
+        if (iter != NULL && iter->magic == NODE_MAGIC) {
+            next = iter->next;
+            Fault_Printf("%08x-%08x%c %s %08x", iter, ((u32)iter + sizeof(ArenaNode) + iter->size),
+                         (!next) ? '$' : (iter != next->prev ? '!' : ' '), iter->isFree ? "F" : "A", iter->size);
+
+            Fault_Printf("\n");
+
+            if (iter->isFree) {
+                freeSize += iter->size;
+                if (maxFree < iter->size) {
+                    maxFree = iter->size;
+                }
+            } else {
+                allocatedSize += iter->size;
+            }
+        } else {
+            Fault_SetFontColor(0xF801);
+            Fault_Printf("%08x Block Invalid\n", iter);
+            next = NULL;
+        }
+        iter = next;
+    }
+
+    Fault_SetFontColor(0x7F1);
+    Fault_Printf("Total Alloc Block Size  %08x\n", allocatedSize);
+    Fault_Printf("Total Free Block Size   %08x\n", freeSize);
+    Fault_Printf("Largest Free Block Size %08x\n", maxFree);
+}
+
+s32 __osCheckArena(Arena* arena) {
+    ArenaNode* iter;
+    u32 error = 0;
+
+    ArenaImpl_Lock(arena);
+    osSyncPrintf(
+        T("アリーナの内容をチェックしています．．． (%08x)\n", "Checking the contents of the arena... (%08x)\n"),
+        arena);
+    iter = arena->head;
+    while (iter != NULL) {
+        //! @bug: Probably intended to be `!NODE_IS_VALID(iter)`
+        if (NODE_IS_VALID(iter)) {
+#if OOT_DEBUG
+            osSyncPrintf(VT_COL(RED, WHITE) T("おおっと！！ (%08x %08x)\n", "Oops!! (%08x %08x)\n") VT_RST, iter,
+                         iter->magic);
+#else
+            osSyncPrintf(T("おおっと！！ (%08x %08x)\n", "Oops!! (%08x %08x)\n"), iter, iter->magic);
+#endif
+            error = 1;
+            break;
+        }
+        iter = NODE_GET_NEXT(iter);
+    }
+    if (error == 0) {
+        osSyncPrintf(T("アリーナはまだ、いけそうです\n", "The arena is still going well\n"));
+    }
+    ArenaImpl_Unlock(arena);
+
+    return error;
+}
+
+#if OOT_DEBUG
+u8 ArenaImpl_GetAllocFailures(Arena* arena) {
+    return arena->allocFailures;
+}
+#endif
+
+#endif
diff --git a/src/code/__osMalloc_n64.c b/src/code/__osMalloc_n64.c
new file mode 100644
index 000000000..bd9c358af
--- /dev/null
+++ b/src/code/__osMalloc_n64.c
@@ -0,0 +1,474 @@
+#include "global.h"
+#include "fault.h"
+#include "osMalloc.h"
+
+#if PLATFORM_N64
+
+#define NODE_MAGIC 0x7373
+
+#define NODE_IS_VALID(node) ((node)->magic == NODE_MAGIC)
+
+#define NODE_GET_NEXT(node) ((node)->next)
+#define NODE_GET_PREV(node) ((node)->prev)
+
+#define SET_DEBUG_INFO(node, f, l, a)           \
+    {                                           \
+        (node)->filename = (f);                 \
+        (node)->line = (l);                     \
+        (node)->threadId = osGetThreadId(NULL); \
+        (node)->arena = (a);                    \
+        (node)->time = osGetTime();             \
+    }                                           \
+    (void)0
+
+#define FILL_ALLOC_BLOCK(arena, alloc, size) (void)0
+#define FILL_FREE_BLOCK_HEADER(arena, node) (void)0
+#define FILL_FREE_BLOCK_CONTENTS(arena, node) (void)0
+#define CHECK_FREE_BLOCK(arena, node) (void)0
+
+// Number of allocation failures across all arenas.
+u32 gTotalAllocFailures = 0; // "Arena_failcnt"
+
+#define CHECK_ALLOC_FAILURE(arena, ptr) \
+    do {                                \
+        if ((ptr) == NULL) {            \
+            gTotalAllocFailures++;      \
+            (arena)->allocFailures++;   \
+        }                               \
+    } while (0)
+
+void __osMallocInit(Arena* arena, void* start, s32 size) {
+    ArenaNode* firstNode = (ArenaNode*)ALIGN16((u32)start);
+
+    size -= (u8*)firstNode - (u8*)start;
+    size &= ~0xF;
+
+    firstNode->next = NULL;
+    firstNode->prev = NULL;
+    firstNode->size = size - sizeof(ArenaNode);
+    firstNode->isFree = true;
+    firstNode->magic = NODE_MAGIC;
+
+    arena->head = firstNode;
+    arena->start = start;
+    arena->size = size;
+}
+
+void __osMallocCleanup(Arena* arena) {
+    bzero(arena, sizeof(*arena));
+}
+
+s32 __osMallocIsInitialized(Arena* arena) {
+    return arena->start != NULL;
+}
+
+void* __osMallocDebug(Arena* arena, u32 size, const char* file, int line) {
+    ArenaNode* iter;
+    u32 blockSize;
+    ArenaNode* newNode;
+    void* alloc = NULL;
+    ArenaNode* next;
+
+    size = ALIGN16(size);
+    blockSize = ALIGN16(size) + sizeof(ArenaNode);
+    iter = arena->head;
+
+    while (iter != NULL) {
+        if (iter->isFree && iter->size >= size) {
+            CHECK_FREE_BLOCK(arena, iter);
+
+            if (blockSize < iter->size) {
+                newNode = (ArenaNode*)((u32)iter + blockSize);
+                newNode->next = NODE_GET_NEXT(iter);
+                newNode->prev = iter;
+                newNode->size = iter->size - blockSize;
+                newNode->isFree = true;
+                newNode->magic = NODE_MAGIC;
+
+                iter->next = newNode;
+                iter->size = size;
+                next = NODE_GET_NEXT(newNode);
+                if (next) {
+                    next->prev = newNode;
+                }
+            }
+
+            iter->isFree = false;
+            SET_DEBUG_INFO(iter, file, line, arena);
+            alloc = (void*)((u32)iter + sizeof(ArenaNode));
+            FILL_ALLOC_BLOCK(arena, alloc, size);
+
+            break;
+        }
+
+        iter = NODE_GET_NEXT(iter);
+    }
+
+    CHECK_ALLOC_FAILURE(arena, alloc);
+
+    return alloc;
+}
+
+void* __osMallocRDebug(Arena* arena, u32 size, const char* file, int line) {
+    ArenaNode* iter;
+    ArenaNode* newNode;
+    u32 blockSize;
+    u32 nodeSize;
+    ArenaNode* next;
+    void* allocR = NULL;
+    ArenaNode* next2;
+
+    size = ALIGN16(size);
+
+    iter = arena->head;
+    next2 = NODE_GET_NEXT(iter);
+    while (next2 != NULL) {
+        iter = next2;
+        next2 = NODE_GET_NEXT(next2);
+    }
+
+    while (iter != NULL) {
+        if (iter->isFree && iter->size >= size) {
+            CHECK_FREE_BLOCK(arena, iter);
+
+            blockSize = ALIGN16(size) + sizeof(ArenaNode);
+            nodeSize = iter->size;
+            if (blockSize < nodeSize) {
+                newNode = (ArenaNode*)((u32)iter + (iter->size - size));
+                newNode->next = NODE_GET_NEXT(iter);
+                newNode->prev = iter;
+                newNode->size = size;
+                newNode->magic = NODE_MAGIC;
+
+                iter->next = newNode;
+                iter->size -= blockSize;
+                next = NODE_GET_NEXT(newNode);
+                if (next) {
+                    next->prev = newNode;
+                }
+                iter = newNode;
+            }
+
+            iter->isFree = false;
+            SET_DEBUG_INFO(iter, file, line, arena);
+            allocR = (void*)((u32)iter + sizeof(ArenaNode));
+            FILL_ALLOC_BLOCK(arena, allocR, size);
+
+            break;
+        }
+
+        iter = NODE_GET_PREV(iter);
+    }
+
+    CHECK_ALLOC_FAILURE(arena, allocR);
+
+    return allocR;
+}
+
+void* __osMalloc(Arena* arena, u32 size) {
+    ArenaNode* iter;
+    u32 blockSize;
+    ArenaNode* newNode;
+    void* alloc = NULL;
+    ArenaNode* next;
+
+    size = ALIGN16(size);
+    blockSize = ALIGN16(size) + sizeof(ArenaNode);
+    iter = arena->head;
+
+    while (iter != NULL) {
+        if (iter->isFree && iter->size >= size) {
+            CHECK_FREE_BLOCK(arena, iter);
+
+            if (blockSize < iter->size) {
+                newNode = (ArenaNode*)((u32)iter + blockSize);
+                newNode->next = NODE_GET_NEXT(iter);
+                newNode->prev = iter;
+                newNode->size = iter->size - blockSize;
+                newNode->isFree = true;
+                newNode->magic = NODE_MAGIC;
+
+                iter->next = newNode;
+                iter->size = size;
+                next = NODE_GET_NEXT(newNode);
+                if (next) {
+                    next->prev = newNode;
+                }
+            }
+
+            iter->isFree = false;
+            SET_DEBUG_INFO(iter, NULL, 0, arena);
+            alloc = (void*)((u32)iter + sizeof(ArenaNode));
+            FILL_ALLOC_BLOCK(arena, alloc, size);
+
+            break;
+        }
+
+        iter = NODE_GET_NEXT(iter);
+    }
+
+    CHECK_ALLOC_FAILURE(arena, alloc);
+
+    return alloc;
+}
+
+void* __osMallocR(Arena* arena, u32 size) {
+    ArenaNode* iter;
+    ArenaNode* newNode;
+    u32 blockSize;
+    u32 nodeSize;
+    ArenaNode* next;
+    void* allocR = NULL;
+    ArenaNode* next2;
+
+    size = ALIGN16(size);
+
+    iter = arena->head;
+    next2 = NODE_GET_NEXT(iter);
+    while (next2 != NULL) {
+        iter = next2;
+        next2 = NODE_GET_NEXT(next2);
+    }
+
+    while (iter != NULL) {
+        if (iter->isFree && iter->size >= size) {
+            CHECK_FREE_BLOCK(arena, iter);
+
+            blockSize = ALIGN16(size) + sizeof(ArenaNode);
+            nodeSize = iter->size;
+            if (blockSize < nodeSize) {
+                newNode = (ArenaNode*)((u32)iter + (iter->size - size));
+                newNode->next = NODE_GET_NEXT(iter);
+                newNode->prev = iter;
+                newNode->size = size;
+                newNode->magic = NODE_MAGIC;
+
+                iter->next = newNode;
+                iter->size -= blockSize;
+                next = NODE_GET_NEXT(newNode);
+                if (next) {
+                    next->prev = newNode;
+                }
+                iter = newNode;
+            }
+
+            iter->isFree = false;
+            SET_DEBUG_INFO(iter, NULL, 0, arena);
+            allocR = (void*)((u32)iter + sizeof(ArenaNode));
+            FILL_ALLOC_BLOCK(arena, allocR, size);
+
+            break;
+        }
+        iter = NODE_GET_PREV(iter);
+    }
+
+    CHECK_ALLOC_FAILURE(arena, allocR);
+
+    return allocR;
+}
+
+void __osFree(Arena* arena, void* ptr) {
+    ArenaNode* node;
+    ArenaNode* next;
+    ArenaNode* prev;
+
+    if (ptr == NULL) {
+        return;
+    }
+
+    node = (ArenaNode*)((u32)ptr - sizeof(ArenaNode));
+    if (!NODE_IS_VALID(node)) {
+        (void)T("__osFree:不正解放(%08x)\n", "__osFree: Unauthorized release (%08x)\n");
+        osSetIntMask(OS_IM_ALL);
+        return;
+    }
+    if (node->isFree) {
+        (void)T("__osFree:二重解放(%08x)\n", "__osFree: Double release (%08x)\n");
+        osSetIntMask(OS_IM_ALL);
+        return;
+    }
+    if (arena != node->arena && arena != NULL) {
+        (void)T("__osFree:arena(%08x)が__osMallocのarena(%08x)と一致しない\n",
+                "__osFree:arena(%08x) and __osMalloc:arena(%08x) do not match\n");
+    }
+
+    node->isFree = true;
+    SET_DEBUG_INFO(node, NULL, 0, arena);
+
+    if (node->next != NULL) {
+        next = node->next;
+        if (next->isFree) {
+            if (next->next != NULL) {
+                next->next->prev = node;
+            }
+
+            node->size += next->size + sizeof(ArenaNode);
+            node->next = next->next;
+        }
+    }
+
+    if (node->prev != NULL) {
+        prev = node->prev;
+        if (prev->isFree) {
+            prev->size += node->size + sizeof(ArenaNode);
+            prev->next = NODE_GET_NEXT(node);
+
+            if (node->next != NULL) {
+                node->next->prev = prev;
+            }
+        }
+    }
+}
+
+void __osFreeDebug(Arena* arena, void* ptr, const char* file, int line) {
+    ArenaNode* node;
+    ArenaNode* next;
+    ArenaNode* prev;
+
+    if (ptr == NULL) {
+        return;
+    }
+
+    node = (ArenaNode*)((u32)ptr - sizeof(ArenaNode));
+    if (!NODE_IS_VALID(node)) {
+        (void)T("__osFree:不正解放(%08x)\n", "__osFree: Unauthorized release (%08x)\n");
+        osSetIntMask(OS_IM_ALL);
+        return;
+    }
+    if (node->isFree) {
+        (void)T("__osFree:二重解放(%08x)\n", "__osFree: Double release (%08x)\n");
+        osSetIntMask(OS_IM_ALL);
+        return;
+    }
+    if (arena != node->arena && arena != NULL) {
+        (void)T("__osFree:arena(%08x)が__osMallocのarena(%08x)と一致しない\n",
+                "__osFree:arena(%08x) and __osMalloc:arena(%08x) do not match\n");
+    }
+
+    node->isFree = true;
+    SET_DEBUG_INFO(node, file, line, arena);
+
+    if (node->next != NULL) {
+        next = node->next;
+        if (next->isFree) {
+            if (next->next != NULL) {
+                next->next->prev = node;
+            }
+
+            node->size += next->size + sizeof(ArenaNode);
+            node->next = next->next;
+        }
+    }
+
+    if (node->prev != NULL) {
+        prev = node->prev;
+        if (prev->isFree) {
+            prev->size += node->size + sizeof(ArenaNode);
+            prev->next = NODE_GET_NEXT(node);
+
+            if (node->next != NULL) {
+                node->next->prev = prev;
+            }
+        }
+    }
+}
+
+void* __osRealloc(Arena* arena, void* ptr, u32 newSize) {
+    ArenaNode* node;
+    void* newAlloc;
+    ArenaNode* next;
+    ArenaNode* newNext;
+    u32 sizeDiff;
+
+    (void)"__osRealloc(%08x, %d)\n";
+    osSetIntMask(OS_IM_ALL);
+
+    if (ptr == NULL) {
+        ptr = __osMalloc(arena, newSize);
+    } else if (newSize == 0) {
+        __osFree(arena, ptr);
+        ptr = NULL;
+    } else {
+        newSize = ALIGN16(newSize);
+        node = (ArenaNode*)((u32)ptr - sizeof(ArenaNode));
+        if (newSize == node->size) {
+            // Do nothing
+        } else if (node->size < newSize) {
+            next = NODE_GET_NEXT(node);
+            sizeDiff = newSize - node->size;
+            if (next != NULL && next->isFree && next->size >= sizeDiff) {
+                next->size -= sizeDiff;
+                newNext = (ArenaNode*)((u32)next + sizeDiff);
+                if (NODE_GET_NEXT(next) != NULL) {
+                    NODE_GET_NEXT(next)->prev = newNext;
+                }
+                node->next = newNext;
+                node->size = newSize;
+                memmove(node->next, next, sizeof(ArenaNode));
+            } else {
+                newAlloc = __osMalloc(arena, newSize);
+                if (newAlloc != NULL) {
+                    memcpy(ptr, newAlloc, node->size);
+                    __osFree(arena, ptr);
+                }
+                ptr = newAlloc;
+            }
+        } else if (newSize < node->size) {
+            (void)T("メモリブロックの縮小機能はまだインプリメントしていません\n",
+                    "Memory block shrinking functionality is not yet implemented\n");
+        }
+    }
+
+    CHECK_ALLOC_FAILURE(arena, ptr);
+
+    return ptr;
+}
+
+void* __osReallocDebug(Arena* arena, void* ptr, u32 newSize, const char* file, int line) {
+    return __osRealloc(arena, ptr, newSize);
+}
+
+void ArenaImpl_GetSizes(Arena* arena, u32* outMaxFree, u32* outFree, u32* outAlloc) {
+    ArenaNode* iter;
+
+    *outMaxFree = 0;
+    *outFree = 0;
+    *outAlloc = 0;
+
+    iter = arena->head;
+    while (iter != NULL) {
+        if (iter->isFree) {
+            *outFree += iter->size;
+            if (*outMaxFree < iter->size) {
+                *outMaxFree = iter->size;
+            }
+        } else {
+            *outAlloc += iter->size;
+        }
+
+        iter = NODE_GET_NEXT(iter);
+    }
+}
+
+s32 __osCheckArena(Arena* arena) {
+    ArenaNode* iter;
+
+    (void)T("アリーナの内容をチェックしています．．． (%08x)\n", "Checking the arena contents... (%08x)\n");
+    iter = arena->head;
+    while (iter != NULL) {
+        if (!NODE_IS_VALID(iter)) {
+            (void)T("おおっと！！ (%08x %08x)\n", "Oops!! (%08x %08x)\n");
+            return 1;
+        }
+        iter = NODE_GET_NEXT(iter);
+    }
+
+    (void)T("アリーナはまだ、いけそうです\n", "The arena is still going well\n");
+    return 0;
+}
+
+u8 ArenaImpl_GetAllocFailures(Arena* arena) {
+    return arena->allocFailures;
+}
+
+#endif
diff --git a/src/code/code_800FC620.c b/src/code/code_800FC620.c
index eafbe5080..4d7b7b4ef 100644
--- a/src/code/code_800FC620.c
+++ b/src/code/code_800FC620.c
@@ -1,4 +1,5 @@
 #include "global.h"
+#include "osMalloc.h"
 
 typedef void (*arg3_800FC868)(void*);
 typedef void (*arg3_800FC8D8)(void*, u32);
@@ -26,43 +27,64 @@ char D_80134488[0x18] = {
 
 // possibly some kind of new() function
 void* func_800FC800(u32 size) {
+    DECLARE_INTERRUPT_MASK
+    void* ptr;
+
+    DISABLE_INTERRUPTS();
+
     if (size == 0) {
         size = 1;
     }
 
 #if OOT_DEBUG
-    return __osMallocDebug(&gSystemArena, size, sNew, 0);
+    ptr = __osMallocDebug(&gSystemArena, size, sNew, 0);
 #else
-    return __osMalloc(&gSystemArena, size);
+    ptr = __osMalloc(&gSystemArena, size);
 #endif
+
+    RESTORE_INTERRUPTS();
+    return ptr;
 }
 
 // possibly some kind of delete() function
 void func_800FC83C(void* ptr) {
+    DECLARE_INTERRUPT_MASK
+
+    DISABLE_INTERRUPTS();
     if (ptr != NULL) {
         __osFree(&gSystemArena, ptr);
     }
+    RESTORE_INTERRUPTS();
 }
 
 void func_800FC868(void* blk, u32 nBlk, u32 blkSize, arg3_800FC868 arg3) {
+    DECLARE_INTERRUPT_MASK
     u32 pos;
 
-    for (pos = (u32)blk; pos < (u32)blk + (nBlk * blkSize); pos = (u32)pos + (blkSize & ~0)) {
+    DISABLE_INTERRUPTS();
+    for (pos = ((u32)blk & ~0); pos < (u32)blk + (nBlk * blkSize); pos = (u32)pos + (blkSize & ~0)) {
         arg3((void*)pos);
     }
+    RESTORE_INTERRUPTS();
 }
 
 void func_800FC8D8(void* blk, u32 nBlk, s32 blkSize, arg3_800FC8D8 arg3) {
+    DECLARE_INTERRUPT_MASK
     u32 pos;
 
-    for (pos = (u32)blk; pos < (u32)blk + (nBlk * blkSize); pos = (u32)pos + (blkSize & ~0)) {
+    DISABLE_INTERRUPTS();
+    for (pos = ((u32)blk & ~0); pos < (u32)blk + (nBlk * blkSize); pos = (u32)pos + (blkSize & ~0)) {
         arg3((void*)pos, 2);
     }
+    RESTORE_INTERRUPTS();
 }
 
 void* func_800FC948(void* blk, u32 nBlk, u32 blkSize, arg3_800FC948 arg3) {
+    DECLARE_INTERRUPT_MASK
     u32 pos;
 
+    DISABLE_INTERRUPTS();
+
     if (blk == NULL) {
         blk = func_800FC800(nBlk * blkSize);
     }
@@ -74,29 +96,35 @@ void* func_800FC948(void* blk, u32 nBlk, u32 blkSize, arg3_800FC948 arg3) {
             pos = (u32)pos + (blkSize & ~0);
         }
     }
+
+    RESTORE_INTERRUPTS();
     return blk;
 }
 
 void func_800FCA18(void* blk, u32 nBlk, u32 blkSize, arg3_800FCA18 arg3, s32 arg4) {
+    DECLARE_INTERRUPT_MASK
     u32 pos;
     u32 end;
 
-    if (blk == NULL) {
-        return;
-    }
-    if (arg3 != NULL) {
-        end = (u32)blk;
-        pos = (u32)end + (nBlk * blkSize);
+    DISABLE_INTERRUPTS();
 
-        while (pos > end) {
-            pos -= (s32)(blkSize & ~0);
-            arg3((void*)pos, 2);
+    if (blk != NULL) {
+        if (arg3 != NULL) {
+            end = (u32)blk;
+            pos = (u32)end + (nBlk * blkSize);
+
+            while (pos > end) {
+                pos -= (s32)(blkSize & ~0);
+                arg3((void*)pos, 2);
+            }
         }
-    }
 
-    if (arg4 != 0) {
-        func_800FC83C(blk);
+        if (arg4 != 0) {
+            func_800FC83C(blk);
+        }
     }
+
+    RESTORE_INTERRUPTS();
 }
 
 void func_800FCB34(void) {
@@ -120,6 +148,11 @@ void func_800FCB34(void) {
 }
 
 void SystemHeap_Init(void* start, u32 size) {
+#if PLATFORM_N64
+    __osMallocInit(&gSystemArena, start, size);
+#else
     SystemArena_Init(start, size);
+#endif
+
     func_800FCB34();
 }
diff --git a/src/code/debug_malloc.c b/src/code/debug_malloc.c
index 3e31f7845..5be04b23c 100644
--- a/src/code/debug_malloc.c
+++ b/src/code/debug_malloc.c
@@ -1,4 +1,5 @@
 #include "global.h"
+#include "osMalloc.h"
 
 #define LOG_SEVERITY_NOLOG 0
 #define LOG_SEVERITY_ERROR 2
@@ -125,6 +126,6 @@ void DebugArena_Cleanup(void) {
     __osMallocCleanup(&sDebugArena);
 }
 
-u8 DebugArena_IsInitialized(void) {
+s32 DebugArena_IsInitialized(void) {
     return __osMallocIsInitialized(&sDebugArena);
 }
diff --git a/src/code/fault_gc.c b/src/code/fault_gc.c
index 587f7cb24..0402573ad 100644
--- a/src/code/fault_gc.c
+++ b/src/code/fault_gc.c
@@ -40,15 +40,11 @@
  * DPad-Up may be pressed to enable sending fault pages over osSyncPrintf as well as displaying them on-screen.
  * DPad-Down disables sending fault pages over osSyncPrintf.
  */
+#if PLATFORM_GC
+
 #pragma increment_block_number "gc-eu:240 gc-eu-mq:240 gc-eu-mq-dbg:224 gc-jp:240 gc-jp-ce:240 gc-jp-mq:240 gc-us:240" \
                                "gc-us-mq:240"
 
-// Include versions.h first and redefine FAULT_VERSION
-// This allows this file to compile even when versions.h uses FAULT_N64
-#include "versions.h"
-#undef FAULT_VERSION
-#define FAULT_VERSION FAULT_GC
-
 #include "global.h"
 #include "alloca.h"
 #include "fault.h"
@@ -1336,3 +1332,5 @@ NORETURN void Fault_AddHungupAndCrash(const char* file, int line) {
     sprintf(msg, "HungUp %s:%d", file, line);
     Fault_AddHungupAndCrashImpl(msg, NULL);
 }
+
+#endif
diff --git a/src/code/fault_gc_drawer.c b/src/code/fault_gc_drawer.c
index dbdcba7e7..5cf088fca 100644
--- a/src/code/fault_gc_drawer.c
+++ b/src/code/fault_gc_drawer.c
@@ -4,17 +4,12 @@
  * Implements routines for drawing text with a fixed font directly to a framebuffer, used in displaying
  * the crash screen implemented by fault.c
  */
-
-// Include versions.h first and redefine FAULT_VERSION
-// This allows this file to compile even when versions.h uses FAULT_N64
-#include "versions.h"
-#undef FAULT_VERSION
-#define FAULT_VERSION FAULT_GC
-
 #include "global.h"
 #include "fault.h"
 #include "terminal.h"
 
+#if PLATFORM_GC
+
 typedef struct FaultDrawer {
     /* 0x00 */ u16* fb;
     /* 0x04 */ u16 w;
@@ -348,3 +343,5 @@ void Fault_InitDrawer(void) {
     bcopy(&sFaultDrawerDefault, &sFaultDrawer, sizeof(FaultDrawer));
     sFaultDrawer.fb = (u16*)(PHYS_TO_K0(osMemSize) - sizeof(u16[SCREEN_HEIGHT][SCREEN_WIDTH]));
 }
+
+#endif
diff --git a/src/code/fault_n64.c b/src/code/fault_n64.c
index da9d7bf6f..5a8dd9d1d 100644
--- a/src/code/fault_n64.c
+++ b/src/code/fault_n64.c
@@ -1,14 +1,11 @@
-// Include versions.h first and redefine FAULT_VERSION
-// This allows this file to compile even when versions.h uses FAULT_GC
-#include "versions.h"
-#undef FAULT_VERSION
-#define FAULT_VERSION FAULT_N64
-
 #include "global.h"
 #include "fault.h"
+#include "osMalloc.h"
 #include "stack.h"
 #include "terminal.h"
 
+#if PLATFORM_N64
+
 typedef struct FaultMgr {
     OSThread thread;
     char unk_1B0[0x400];
@@ -846,3 +843,5 @@ void Fault_AddHungupAndCrash(const char* file, int line) {
     sprintf(msg, "HungUp %s:%d", file, line);
     Fault_AddHungupAndCrashImpl(msg, NULL);
 }
+
+#endif
diff --git a/src/code/game.c b/src/code/game.c
index ffb8bc847..07007f6a7 100644
--- a/src/code/game.c
+++ b/src/code/game.c
@@ -1,5 +1,6 @@
 #include "global.h"
 #include "fault.h"
+#include "osMalloc.h"
 #include "terminal.h"
 #if PLATFORM_N64
 #include "n64dd.h"
diff --git a/src/code/rand.c b/src/code/rand.c
index ce2beb9e3..917b1ecfc 100644
--- a/src/code/rand.c
+++ b/src/code/rand.c
@@ -42,7 +42,6 @@
  * @note Original name: qrand.c
  */
 #include "rand.h"
-#include "versions.h"
 
 #define RAND_MULTIPLIER 1664525
 #define RAND_INCREMENT 1013904223
@@ -54,7 +53,7 @@
  */
 static u32 sRandInt = 1;
 
-#if RAND_VERSION == RAND_GC
+#if PLATFORM_GC
 /**
  * Space to store a value to be re-interpreted as a float.
  *
@@ -69,7 +68,7 @@ static fu sRandFloat;
  * @note Original name: qrand
  */
 u32 Rand_Next(void) {
-#if RAND_VERSION == RAND_N64
+#if PLATFORM_N64
     u32 next = sRandInt * RAND_MULTIPLIER + RAND_INCREMENT;
 
     sRandInt = next;
@@ -98,7 +97,7 @@ void Rand_Seed(u32 seed) {
  * @note Original name: fqrand
  */
 f32 Rand_ZeroOne(void) {
-#if RAND_VERSION == RAND_N64
+#if PLATFORM_N64
     fu v;
     f32 vf;
 
@@ -115,7 +114,7 @@ f32 Rand_ZeroOne(void) {
 #endif
 }
 
-#if RAND_VERSION == RAND_GC
+#if PLATFORM_GC
 /**
  * Returns a pseudo-random floating-point number between -0.5f and 0.5f by the same manner in which Rand_ZeroOne
  * generates its result.
@@ -164,7 +163,7 @@ u32 Rand_Next_Variable(u32* rndNum) {
  * @note Original name: fqrand_r
  */
 f32 Rand_ZeroOne_Variable(u32* rndNum) {
-#if RAND_VERSION == RAND_N64
+#if PLATFORM_N64
     fu v;
     f32 vf;
     u32 next = Rand_Next_Variable(rndNum);
@@ -180,7 +179,7 @@ f32 Rand_ZeroOne_Variable(u32* rndNum) {
 #endif
 }
 
-#if RAND_VERSION == RAND_GC
+#if PLATFORM_GC
 /**
  * Generates the next pseudo-random floating-point number between -0.5f and 0.5f from the provided rndNum.
  *
diff --git a/src/code/system_malloc.c b/src/code/system_malloc.c
index 8385a883c..de6a56b30 100644
--- a/src/code/system_malloc.c
+++ b/src/code/system_malloc.c
@@ -1,4 +1,5 @@
 #include "global.h"
+#include "osMalloc.h"
 
 #define LOG_SEVERITY_NOLOG 0
 #define LOG_SEVERITY_ERROR 2
@@ -6,16 +7,6 @@
 
 Arena gSystemArena;
 
-#if PLATFORM_N64
-#define DECLARE_INTERRUPT_MASK OSIntMask __mask;
-#define DISABLE_INTERRUPTS() __mask = osSetIntMask(OS_IM_NONE)
-#define RESTORE_INTERRUPTS() osSetIntMask(__mask)
-#else
-#define DECLARE_INTERRUPT_MASK
-#define DISABLE_INTERRUPTS() (void)0
-#define RESTORE_INTERRUPTS() (void)0
-#endif
-
 #if OOT_DEBUG
 s32 gSystemArenaLogSeverity = LOG_SEVERITY_NOLOG;
 
@@ -176,6 +167,6 @@ void SystemArena_Cleanup(void) {
     __osMallocCleanup(&gSystemArena);
 }
 
-u8 SystemArena_IsInitialized(void) {
+s32 SystemArena_IsInitialized(void) {
     return __osMallocIsInitialized(&gSystemArena);
 }
diff --git a/src/code/z_malloc.c b/src/code/z_malloc.c
index 979de62fe..5b1c5637f 100644
--- a/src/code/z_malloc.c
+++ b/src/code/z_malloc.c
@@ -1,4 +1,5 @@
 #include "global.h"
+#include "osMalloc.h"
 
 #define LOG_SEVERITY_NOLOG 0
 #define LOG_SEVERITY_ERROR 2
@@ -124,6 +125,6 @@ void ZeldaArena_Cleanup(void) {
     __osMallocCleanup(&sZeldaArena);
 }
 
-u8 ZeldaArena_IsInitialized(void) {
+s32 ZeldaArena_IsInitialized(void) {
     return __osMallocIsInitialized(&sZeldaArena);
 }
-- 
cgit v1.2.3