Document heap.c, 3

4 files changed, 147 insertions, 128 deletions

diff --git a/arm9/src/error_message_reset.c b/arm9/src/error_message_reset.c
index f028f038..520a5077 100644
--- a/arm9/src/error_message_reset.c
+++ b/arm9/src/error_message_reset.c
@@ -46,7 +46,7 @@ THUMB_FUNC void PrintErrorMessageAndReset()
         OS_SetArenaHi(OS_ARENA_MAIN, OS_GetInitArenaHi(OS_ARENA_MAIN));
         OS_SetArenaLo(OS_ARENA_MAIN, OS_GetInitArenaLo(OS_ARENA_MAIN));
 
-        FUN_020166C8(UNK_020FF4A4, NELEMS(UNK_020FF4A4), 1, 0);
+        InitHeapSystem(UNK_020FF4A4, NELEMS(UNK_020FF4A4), 1, 0);
         FUN_0200E3A0(PM_LCD_TOP, 0);
         FUN_0200E3A0(PM_LCD_BOTTOM, 0);
 
diff --git a/arm9/src/game_init.c b/arm9/src/game_init.c
index 05b1f9bd..f907d646 100644
--- a/arm9/src/game_init.c
+++ b/arm9/src/game_init.c
@@ -142,7 +142,7 @@ void FUN_02015FC8(void)
     {
         csum++;
     }
-    FUN_020166C8(UNK_020EDB10, NELEMS(UNK_020EDB10), 92, csum);
+    InitHeapSystem(UNK_020EDB10, NELEMS(UNK_020EDB10), 92, csum);
 }
 
 void InitSystemForTheGame(void)
diff --git a/arm9/src/heap.c b/arm9/src/heap.c
index 79763865..ba3776ac 100644
--- a/arm9/src/heap.c
+++ b/arm9/src/heap.c
@@ -4,12 +4,32 @@
 #include "NNS_FND_expheap.h"
 #include "NNS_FND_allocator.h"
 
-struct UnkStruct_020166C8 UNK_021C4D28;
+struct HeapInfo
+{
+    NNSFndHeapHandle *heapHandles;
+    NNSFndHeapHandle *parentHeapHandles;
+    void **subHeapRawPtrs;
+    u16 *numMemBlocks;
+    u8 *heapIdxs;
+    u16 totalNumHeaps;
+    u16 nTemplates;
+    u16 maxHeaps;
+    u16 unallocatedHeapId;
+};
+
+typedef struct MemoryBlock
+{
+    u8 filler_00[12];
+    u32 heapId:8;
+    u32 filler_0D:24;
+} MemoryBlock;
 
-THUMB_FUNC void FUN_020166C8(const struct UnkStruct_020EDB10 *templates, u32 nTemplates, u32 totalNumHeaps, u32 pre_size)
+struct HeapInfo sHeapInfo;
+
+THUMB_FUNC void InitHeapSystem(const struct UnkStruct_020EDB10 *templates, u32 nTemplates, u32 totalNumHeaps, u32 pre_size)
 {
     void * ptr;
-    u32 unk_size, r7;
+    u32 unk_size, i;
 
     unk_size = nTemplates + 24;
 
@@ -27,7 +47,7 @@ THUMB_FUNC void FUN_020166C8(const struct UnkStruct_020EDB10 *templates, u32 nTe
         OS_AllocFromArenaLo(OS_ARENA_MAIN, pre_size, 4);
     }
 
-    UNK_021C4D28.heapHandles = (NNSFndHeapHandle*) OS_AllocFromArenaLo(
+    sHeapInfo.heapHandles = (NNSFndHeapHandle*) OS_AllocFromArenaLo(
         OS_ARENA_MAIN,
         (unk_size + 1) * sizeof(NNSFndHeapHandle)
       + unk_size * sizeof(NNSFndHeapHandle)
@@ -36,34 +56,34 @@ THUMB_FUNC void FUN_020166C8(const struct UnkStruct_020EDB10 *templates, u32 nTe
       + totalNumHeaps,
       4
     );
-    UNK_021C4D28.unk04 = UNK_021C4D28.heapHandles + (unk_size + 1);
-    UNK_021C4D28.unk08 = (void **)(UNK_021C4D28.unk04 + unk_size);
-    UNK_021C4D28.unk0c = (u16 *)(UNK_021C4D28.unk08 + unk_size);
-    UNK_021C4D28.heapIdxs = (u8 *)(UNK_021C4D28.unk0c + totalNumHeaps);
-    UNK_021C4D28.totalNumHeaps = (u16)totalNumHeaps;
-    UNK_021C4D28.nTemplates = (u16)nTemplates;
+    sHeapInfo.parentHeapHandles = sHeapInfo.heapHandles + (unk_size + 1);
+    sHeapInfo.subHeapRawPtrs = (void **)(sHeapInfo.parentHeapHandles + unk_size);
+    sHeapInfo.numMemBlocks = (u16 *)(sHeapInfo.subHeapRawPtrs + unk_size);
+    sHeapInfo.heapIdxs = (u8 *)(sHeapInfo.numMemBlocks + totalNumHeaps);
+    sHeapInfo.totalNumHeaps = (u16)totalNumHeaps;
+    sHeapInfo.nTemplates = (u16)nTemplates;
 
-    UNK_021C4D28.unk1a = (u16)unk_size;
-    UNK_021C4D28.unk18 = (u16)unk_size;
+    sHeapInfo.unallocatedHeapId = (u16)unk_size;
+    sHeapInfo.maxHeaps = (u16)unk_size;
 
-    for (r7 = 0; r7 < nTemplates; r7++)
+    for (i = 0; i < nTemplates; i++)
     {
-        switch (templates[r7].arena)
+        switch (templates[i].arena)
         {
         case OS_ARENA_MAIN:
         default:
-            ptr = OS_AllocFromArenaLo(OS_ARENA_MAIN, templates[r7].size, 4);
+            ptr = OS_AllocFromArenaLo(OS_ARENA_MAIN, templates[i].size, 4);
             break;
         case OS_ARENA_MAINEX:
-            ptr = OS_AllocFromArenaHi(OS_ARENA_MAINEX, templates[r7].size, 4);
+            ptr = OS_AllocFromArenaHi(OS_ARENA_MAINEX, templates[i].size, 4);
             break;
         }
 
         if (ptr != NULL)
         {
 
-            UNK_021C4D28.heapHandles[r7] = NNS_FndCreateExpHeap(ptr, templates[r7].size);
-            UNK_021C4D28.heapIdxs[r7] = (u8)r7;
+            sHeapInfo.heapHandles[i] = NNS_FndCreateExpHeap(ptr, templates[i].size);
+            sHeapInfo.heapIdxs[i] = (u8)i;
         }
         else
         {
@@ -71,75 +91,73 @@ THUMB_FUNC void FUN_020166C8(const struct UnkStruct_020EDB10 *templates, u32 nTe
         }
     }
 
-    while (nTemplates < unk_size + 1)
+    for (i = nTemplates; i < unk_size + 1; i++)
     {
-        UNK_021C4D28.heapHandles[nTemplates] = NULL;
-        UNK_021C4D28.heapIdxs[nTemplates] = (u8)UNK_021C4D28.unk1a;
-
-        nTemplates++;
+        sHeapInfo.heapHandles[i] = NULL;
+        sHeapInfo.heapIdxs[i] = (u8)sHeapInfo.unallocatedHeapId;
     }
 
-    while (nTemplates < totalNumHeaps)
+    while (i < totalNumHeaps)
     {
-        UNK_021C4D28.heapIdxs[nTemplates] = (u8)UNK_021C4D28.unk1a;
+        sHeapInfo.heapIdxs[i] = (u8)sHeapInfo.unallocatedHeapId;
 
-        nTemplates++;
+        i++;
     }
 
-    for (nTemplates = 0; nTemplates < totalNumHeaps; nTemplates++)
+    for (i = 0; i < totalNumHeaps; i++)
     {
-        UNK_021C4D28.unk0c[nTemplates] = 0;
+        sHeapInfo.numMemBlocks[i] = 0;
     }
 }
 
-THUMB_FUNC s32 FUN_020167F4()
+THUMB_FUNC s32 FindFirstAvailableHeapHandle()
 {
     s32 i;
     s32 j;
 
-    for (i = UNK_021C4D28.nTemplates; i < UNK_021C4D28.unk18; i++)
+    for (i = sHeapInfo.nTemplates; i < sHeapInfo.maxHeaps; i++)
     {
-        if (UNK_021C4D28.heapHandles[i] == NULL)
+        if (sHeapInfo.heapHandles[i] == NULL)
             return i;
     }
 
     return -1;
 }
 
-THUMB_FUNC u32 FUN_0201681C(u32 param0, u32 param1, u32 param2)
+THUMB_FUNC BOOL CreateHeap(u32 parent, u32 child, u32 size)
 {
-    return FUN_02016834(param0, param1, param2, 4);
+    return CreateHeapInternal(parent, child, size, 4);
 }
 
-THUMB_FUNC u32 FUN_02016828(u32 param0, u32 param1, u32 param2)
+THUMB_FUNC BOOL CreateHeapAtEnd(u32 parent, u32 child, u32 size)
 {
-    return FUN_02016834(param0, param1, param2, -4);
+    return CreateHeapInternal(parent, child, size, -4);
 }
 
-THUMB_FUNC u32 FUN_02016834(u32 param0, u32 param1, u32 size, s32 alignment)
+THUMB_FUNC BOOL CreateHeapInternal(u32 parent, u32 child, u32 size, s32 alignment)
 {
     GF_ASSERT(OS_GetProcMode() != OS_PROCMODE_IRQ);
 
-    u8 *ptr = UNK_021C4D28.heapIdxs;
-    if (UNK_021C4D28.unk1a == ptr[param1])
+    u8 *ptr = sHeapInfo.heapIdxs;
+    if (sHeapInfo.unallocatedHeapId == ptr[child])
     {
-        NNSFndHeapHandle ptr2 = UNK_021C4D28.heapHandles[ptr[param0]];
-        if (ptr2 != NULL)
+        NNSFndHeapHandle parentHeap = sHeapInfo.heapHandles[ptr[parent]];
+        if (parentHeap != NULL)
         {
-            void *ptr3 = NNS_FndAllocFromExpHeapEx(ptr2, size, alignment);
-            if (ptr3 != NULL)
+            void *newHeapAddr = NNS_FndAllocFromExpHeapEx(parentHeap, size, alignment);
+            if (newHeapAddr != NULL)
             {
-                s32 i = FUN_020167F4();
+                s32 i = FindFirstAvailableHeapHandle();
                 if (i >= 0)
                 {
-                    UNK_021C4D28.heapHandles[i] = NNS_FndCreateExpHeap(ptr3, size);
+                    sHeapInfo.heapHandles[i] = NNS_FndCreateExpHeap(newHeapAddr, size);
 
 
-                    if (UNK_021C4D28.heapHandles[i] != 0)
+                    if (sHeapInfo.heapHandles[i] != 0)
                     {
-                        UNK_021C4D28.unk04[i] = ptr2;
-                        UNK_021C4D28.unk08[i] = ptr3;
-                        UNK_021C4D28.heapIdxs[param1] = (u8)i;
+                        sHeapInfo.parentHeapHandles[i] = parentHeap;
+                        sHeapInfo.subHeapRawPtrs[i] = newHeapAddr;
+                        sHeapInfo.heapIdxs[child] = (u8)i;
 
                         return TRUE;
                     }
@@ -170,56 +188,56 @@ THUMB_FUNC u32 FUN_02016834(u32 param0, u32 param1, u32 size, s32 alignment)
     return 0;
 }
 
-THUMB_FUNC void FUN_020168D0(u32 heap_id)
+THUMB_FUNC void DestroyHeap(u32 heap_id)
 {
     GF_ASSERT (OS_GetProcMode() != OS_PROCMODE_IRQ);
 
-    NNSFndHeapHandle handle = UNK_021C4D28.heapHandles[UNK_021C4D28.heapIdxs[heap_id]];
+    NNSFndHeapHandle handle = sHeapInfo.heapHandles[sHeapInfo.heapIdxs[heap_id]];
 
     if (handle != NULL)
     {
         NNS_FndDestroyExpHeap(handle);
 
-        u8 index = UNK_021C4D28.heapIdxs[heap_id];
-        NNSFndHeapHandle ptr1 = UNK_021C4D28.unk04[index];
-        void *ptr2 = UNK_021C4D28.unk08[index];
-        if (ptr1 != NULL && ptr2 != NULL)
+        u8 index = sHeapInfo.heapIdxs[heap_id];
+        NNSFndHeapHandle parentHeap = sHeapInfo.parentHeapHandles[index];
+        void *childRaw = sHeapInfo.subHeapRawPtrs[index];
+        if (parentHeap != NULL && childRaw != NULL)
         {
-            NNS_FndFreeToExpHeap(ptr1, ptr2);
+            NNS_FndFreeToExpHeap(parentHeap, childRaw);
         }
         else
         {
             GF_ASSERT(0);
         }
 
-        UNK_021C4D28.heapHandles[UNK_021C4D28.heapIdxs[heap_id]] = NULL;
-        UNK_021C4D28.unk04[UNK_021C4D28.heapIdxs[heap_id]] = NULL;
-        UNK_021C4D28.unk08[UNK_021C4D28.heapIdxs[heap_id]] = NULL;
+        sHeapInfo.heapHandles[sHeapInfo.heapIdxs[heap_id]] = NULL;
+        sHeapInfo.parentHeapHandles[sHeapInfo.heapIdxs[heap_id]] = NULL;
+        sHeapInfo.subHeapRawPtrs[sHeapInfo.heapIdxs[heap_id]] = NULL;
 
-        UNK_021C4D28.heapIdxs[heap_id] = (u8)UNK_021C4D28.unk1a;
+        sHeapInfo.heapIdxs[heap_id] = (u8)sHeapInfo.unallocatedHeapId;
     }
 }
 
-THUMB_FUNC u32 *FUN_02016944(void *param0, u32 param1, s32 param2, u32 param3)
+THUMB_FUNC void *AllocFromHeapInternal(NNSFndHeapHandle heap, u32 size, s32 alignment, u32 heap_id)
 {
-    GF_ASSERT(param0);
+    GF_ASSERT(heap);
 
     OSIntrMode intr_mode = OS_DisableInterrupts();
-    param1 += 16;
-    u32 *ptr = (u32 *)NNS_FndAllocFromExpHeapEx(param0, param1, param2);
+    size += 16;
+    void *ptr = NNS_FndAllocFromExpHeapEx(heap, size, alignment);
 
     OS_RestoreInterrupts(intr_mode);
-    if (ptr != 0)
+    if (ptr != NULL)
     {
-        ptr[3] = (ptr[3] & ~0xff) | (param3 & 0xff);
+        ((MemoryBlock *)ptr)->heapId = heap_id;
 
-        ptr += 4;
+        ptr += sizeof(MemoryBlock);
     }
 
     return ptr;
 }
 
-THUMB_FUNC void FUN_02016988()
+THUMB_FUNC void AllocFail()
 {
     if (FUN_02031810() != 0)
     {
@@ -230,18 +248,18 @@ THUMB_FUNC void FUN_02016988()
 void *AllocFromHeap(u32 heap_id, u32 size)
 {
     void *ptr = 0;
-    if (heap_id < UNK_021C4D28.totalNumHeaps)
+    if (heap_id < sHeapInfo.totalNumHeaps)
     {
-        u8 index = UNK_021C4D28.heapIdxs[heap_id];
-        ptr = FUN_02016944(UNK_021C4D28.heapHandles[index], size, 4, heap_id);
+        u8 index = sHeapInfo.heapIdxs[heap_id];
+        ptr = AllocFromHeapInternal(sHeapInfo.heapHandles[index], size, 4, heap_id);
     }
-    if (ptr != 0)
+    if (ptr != NULL)
     {
-        UNK_021C4D28.unk0c[heap_id]++;
+        sHeapInfo.numMemBlocks[heap_id]++;
     }
     else
     {
-        FUN_02016988();
+        AllocFail();
     }
 
     return ptr;
@@ -250,19 +268,19 @@ void *AllocFromHeap(u32 heap_id, u32 size)
 void *AllocFromHeapAtEnd(u32 heap_id, u32 size)
 {
     void *ptr = 0;
-    if (heap_id < UNK_021C4D28.totalNumHeaps)
+    if (heap_id < sHeapInfo.totalNumHeaps)
     {
-        u8 index = UNK_021C4D28.heapIdxs[heap_id];
-        ptr = FUN_02016944(UNK_021C4D28.heapHandles[index], size, -4, heap_id);
+        u8 index = sHeapInfo.heapIdxs[heap_id];
+        ptr = AllocFromHeapInternal(sHeapInfo.heapHandles[index], size, -4, heap_id);
     }
 
-    if (ptr != 0)
+    if (ptr != NULL)
     {
-        UNK_021C4D28.unk0c[heap_id]++;
+        sHeapInfo.numMemBlocks[heap_id]++;
     }
     else
     {
-        FUN_02016988();
+        AllocFail();
     }
 
     return ptr;
@@ -270,23 +288,24 @@ void *AllocFromHeapAtEnd(u32 heap_id, u32 size)
 
 void FreeToHeap(void *ptr)
 {
-    u8 heap_id = (u8)((u32 *)ptr)[-1];
+    ptr -= sizeof(MemoryBlock);
+    u32 heap_id = ((MemoryBlock *)ptr)->heapId;
 
-    if ((u16)heap_id < UNK_021C4D28.totalNumHeaps)
+    if (heap_id < sHeapInfo.totalNumHeaps)
     {
-        u8 index = UNK_021C4D28.heapIdxs[heap_id];
-        void *ptr2 = UNK_021C4D28.heapHandles[index];
-        GF_ASSERT(ptr2);
+        u8 index = sHeapInfo.heapIdxs[heap_id];
+        NNSFndHeapHandle heap = sHeapInfo.heapHandles[index];
+        GF_ASSERT(heap != NULL);
 
-        if (UNK_021C4D28.unk0c[heap_id] == 0)
+        if (sHeapInfo.numMemBlocks[heap_id] == 0)
         {
-            FUN_02016B90(heap_id);
+            GF_heap_c_dummy_return_true(heap_id);
         }
-        GF_ASSERT(UNK_021C4D28.unk0c[heap_id]);
+        GF_ASSERT(sHeapInfo.numMemBlocks[heap_id] != 0);
 
-        UNK_021C4D28.unk0c[heap_id]--;
+        sHeapInfo.numMemBlocks[heap_id]--;
         OSIntrMode intr_mode = OS_DisableInterrupts();
-        NNS_FndFreeToExpHeap(ptr2, ptr - 16);
+        NNS_FndFreeToExpHeap(heap, ptr);
         OS_RestoreInterrupts(intr_mode);
         return;
     }
@@ -294,23 +313,23 @@ void FreeToHeap(void *ptr)
     GF_ASSERT(0);
 }
 
-void FreeToHeapExplicit(u32 param0, void *param1)
+void FreeToHeapExplicit(u32 heap_id, void *ptr)
 {
     GF_ASSERT (OS_GetProcMode() != OS_PROCMODE_IRQ);
 
-    if (param0 < UNK_021C4D28.totalNumHeaps)
+    if (heap_id < sHeapInfo.totalNumHeaps)
     {
-        u8 index = UNK_021C4D28.heapIdxs[param0];
-        void *ptr = UNK_021C4D28.heapHandles[index];
-        GF_ASSERT (ptr );
+        u8 index = sHeapInfo.heapIdxs[heap_id];
+        NNSFndHeapHandle heap = sHeapInfo.heapHandles[index];
+        GF_ASSERT ( heap != NULL );
 
-        u8 heap_id = (u8)((u32 *)param1)[-1];
-        GF_ASSERT (heap_id == param0);
+        ptr -= sizeof(MemoryBlock);
+        GF_ASSERT (((MemoryBlock *)ptr)->heapId == heap_id);
 
-        NNS_FndFreeToExpHeap(ptr, param1 - 16);
-        GF_ASSERT (UNK_021C4D28.unk0c[param0]);
+        NNS_FndFreeToExpHeap(heap, ptr);
+        GF_ASSERT (sHeapInfo.numMemBlocks[heap_id] != 0);
 
-        UNK_021C4D28.unk0c[param0]--;
+        sHeapInfo.numMemBlocks[heap_id]--;
         return;
     }
 
@@ -319,10 +338,10 @@ void FreeToHeapExplicit(u32 param0, void *param1)
 
 THUMB_FUNC u32 GF_ExpHeap_FndGetTotalFreeSize(u32 heap_id)
 {
-    if (heap_id < UNK_021C4D28.totalNumHeaps)
+    if (heap_id < sHeapInfo.totalNumHeaps)
     {
-        u8 index = UNK_021C4D28.heapIdxs[heap_id];
-        return NNS_FndGetTotalFreeSizeForExpHeap(UNK_021C4D28.heapHandles[index]);
+        u8 index = sHeapInfo.heapIdxs[heap_id];
+        return NNS_FndGetTotalFreeSizeForExpHeap(sHeapInfo.heapHandles[index]);
     }
 
     GF_ASSERT(0);
@@ -331,11 +350,11 @@ THUMB_FUNC u32 GF_ExpHeap_FndGetTotalFreeSize(u32 heap_id)
 
 THUMB_FUNC void GF_ExpHeap_FndInitAllocator(NNSFndAllocator * pAllocator, u32 heap_id, int alignment)
 {
-    if (heap_id < UNK_021C4D28.totalNumHeaps)
+    if (heap_id < sHeapInfo.totalNumHeaps)
     {
 
-        u8 index = UNK_021C4D28.heapIdxs[heap_id];
-        NNS_FndInitAllocatorForExpHeap(pAllocator, UNK_021C4D28.heapHandles[index], alignment);
+        u8 index = sHeapInfo.heapIdxs[heap_id];
+        NNS_FndInitAllocatorForExpHeap(pAllocator, sHeapInfo.heapHandles[index], alignment);
         return;
     }
 
@@ -351,16 +370,16 @@ THUMB_FUNC void ReallocFromHeap(void *ptr, u32 newSize)
     {
         u8 heap_id = (u8)((u32 *)ptr)[-1];
 
-        u8 index = UNK_021C4D28.heapIdxs[heap_id];
+        u8 index = sHeapInfo.heapIdxs[heap_id];
 
-        NNS_FndResizeForMBlockExpHeap(UNK_021C4D28.heapHandles[index], ptr - 16, newSize);
+        NNS_FndResizeForMBlockExpHeap(sHeapInfo.heapHandles[index], ptr - 16, newSize);
         return;
     }
     GF_ASSERT(0);
 }
 
-THUMB_FUNC u32 FUN_02016B90(u32 param0)
+THUMB_FUNC BOOL GF_heap_c_dummy_return_true(u32 heap_id)
 {
-#pragma unused(param0)
-    return 1;
+#pragma unused(heap_id)
+    return TRUE;
 }
diff --git a/arm9/src/unk_02031734.c b/arm9/src/unk_02031734.c
index 49283907..7d3b4c03 100644
--- a/arm9/src/unk_02031734.c
+++ b/arm9/src/unk_02031734.c
@@ -97,14 +97,14 @@ THUMB_FUNC void FUN_020317C0()
 
         if (UNK_021C5A00->unk3F >= 0x13)
         {
-            FUN_020168D0(0x31);
+            DestroyHeap(0x31);
         }
 
         FUN_02033ED0();
         FUN_0202E4F0();
 
         FreeToHeap(UNK_021C5A00);
-        FUN_020168D0(0xf);
+        DestroyHeap(0xf);
 
         UNK_021C5A00 = NULL;
     }
@@ -123,7 +123,7 @@ THUMB_FUNC void FUN_02031824(struct SaveBlock2 *sav2)
 {
     if (UNK_021C5A00 == NULL)
     {
-        FUN_02016828(3, 0xf, 0xe000);
+        CreateHeapAtEnd(3, 0xf, 0xe000);
         FUN_02031734(sav2, 0xa);
 
         UNK_021C5A00->unk40 = 0;
@@ -201,7 +201,7 @@ THUMB_FUNC void FUN_02031948(struct SaveBlock2 *sav2, u8 param1, u8 param2, u32
 {
     if (FUN_02030F40() == 0)
     {
-        FUN_02016828(3, 0xf, 0x7080);
+        CreateHeapAtEnd(3, 0xf, 0x7080);
         FUN_02031734(sav2, param1);
         UNK_021C5A00->unk40 = param2;
         UNK_021C5A00->unk30 = param3;
@@ -213,7 +213,7 @@ THUMB_FUNC void FUN_02031990(struct SaveBlock2 *sav2, u8 param1, u8 param2, u32
 {
     if (FUN_02030F40() == 0)
     {
-        FUN_02016828(3, 0xf, 0x7080);
+        CreateHeapAtEnd(3, 0xf, 0x7080);
         FUN_02031734(sav2, param1);
         UNK_021C5A00->unk40 = param2;
         UNK_021C5A00->unk30 = param3;
@@ -273,7 +273,7 @@ THUMB_FUNC void FUN_02031A7C(struct SaveBlock2 *sav2)
 {
     if (UNK_021C5A00 == NULL)
     {
-        if (FUN_02016828(3, 0xf, 0x7080) == 0)
+        if (CreateHeapAtEnd(3, 0xf, 0x7080) == 0)
         {
             FUN_020335E0();
         }
@@ -406,7 +406,7 @@ THUMB_FUNC void FUN_02031C74(struct SaveBlock2 *sav2, u8 param1)
 {
     if (FUN_02030F40() == 0)
     {
-        FUN_02016828(3, 0xf, 0x7080);
+        CreateHeapAtEnd(3, 0xf, 0x7080);
         FUN_02031734(sav2, param1);
         FUN_02031D20(FUN_02032E00, 0);
     }
@@ -416,7 +416,7 @@ THUMB_FUNC void FUN_02031CA8(struct SaveBlock2 *sav2, u8 param1)
 {
     if (FUN_02030F40() == 0)
     {
-        FUN_02016828(3, 0xf, 0x7080);
+        CreateHeapAtEnd(3, 0xf, 0x7080);
         FUN_02031734(sav2, param1);
         FUN_02031D20(FUN_02032E48, 0);
     }
@@ -1393,7 +1393,7 @@ THUMB_FUNC void FUN_02032BD0(struct SaveBlock2 *sav2)
 {
     if (FUN_02030F40() == 0)
     {
-        FUN_02016828(3, 0xf, 0x7000);
+        CreateHeapAtEnd(3, 0xf, 0x7000);
         FUN_02031734(sav2, 0xe);
         UNK_021C5A00->unk40 = 0;
         FUN_02031D20(FUN_02032B8C, 0);
@@ -1479,7 +1479,7 @@ THUMB_FUNC void FUN_02032D44(struct SaveBlock2 *sav2)
 {
     if (FUN_02030F40() == 0)
     {
-        FUN_02016828(3, 0xf, 0x7000);
+        CreateHeapAtEnd(3, 0xf, 0x7000);
         FUN_02031734(sav2, 0x11);
         UNK_021C5A00->unk40 = 0;
         FUN_02031D20(FUN_02032CF4, 0);
@@ -1866,7 +1866,7 @@ THUMB_FUNC void FUN_02033288(struct SaveBlock2 *sav2)
 {
     if (UNK_021C5A00 == NULL)
     {
-        FUN_02016828(3, 0xf, 0x100);
+        CreateHeapAtEnd(3, 0xf, 0x100);
         UNK_021C5A00 =
             (struct UnkStruct_02031734 *)AllocFromHeap(0xf, sizeof(struct UnkStruct_02031734));
         MI_CpuFill8(UNK_021C5A00, 0, sizeof(struct UnkStruct_02031734));
@@ -1887,7 +1887,7 @@ THUMB_FUNC void FUN_020332DC()
         FUN_020334E8(0, 0);
         FreeToHeap(UNK_021C5A00);
         UNK_021C5A00 = NULL;
-        FUN_020168D0(0xf);
+        DestroyHeap(0xf);
     }
 }
 
@@ -1895,7 +1895,7 @@ THUMB_FUNC void FUN_02033310(struct SaveBlock2 *sav2)
 {
     if (UNK_021C5A00 == NULL)
     {
-        FUN_02016828(3, 0xf, 0x100);
+        CreateHeapAtEnd(3, 0xf, 0x100);
         UNK_021C5A00 =
             (struct UnkStruct_02031734 *)AllocFromHeap(0xf, sizeof(struct UnkStruct_02031734));
         MI_CpuFill8(UNK_021C5A00, 0, sizeof(struct UnkStruct_02031734));
@@ -1915,7 +1915,7 @@ THUMB_FUNC void FUN_02033364()
         FUN_020334E8(0, 0);
         FreeToHeap(UNK_021C5A00);
         UNK_021C5A00 = NULL;
-        FUN_020168D0(0xf);
+        DestroyHeap(0xf);
     }
 }
 
@@ -1966,7 +1966,7 @@ THUMB_FUNC void FUN_0203341C()
 {
     if (FUN_0202E4C8())
     {
-        FUN_02016828(3, 0x31, 0x31000);
+        CreateHeapAtEnd(3, 0x31, 0x31000);
         if (FUN_0202F918(1, 1, 0x200, 1) != 0)
         {
             MOD05_021D74E0(UNK_021C5A00->unk28, 0x31);
@@ -1986,7 +1986,7 @@ THUMB_FUNC void *FUN_0203346C(struct SaveBlock2 *sav2, u32 param1)
     }
 
     SetSoftResetDisableMask(1);
-    FUN_02016828(3, 0xf, 0x7080);
+    CreateHeapAtEnd(3, 0xf, 0x7080);
     FUN_02031734(sav2, 0x17);
     UNK_021C5A00->unk00 = AllocFromHeap(0xf, param1);
     MI_CpuFill8(UNK_021C5A00->unk00, 0, param1);