Some OOT transfers, some renaming, etc (#75)

* Progress on various files

* gfxprint stuff

* split some rodata, add iconv for rodata string parsing

* z_std_dma rodata

* 2 nonmatchings in gfxprint

* mtxuty-cvt ok

* more

* match a function in idle.c

* progress

* Cleanup

* Rename BgPolygon to CollisionPoly

* progress

* some effect stuff

* more effect progress

* updates

* made suggested changes

* z_effect_soft_sprite_old_init mostly ok

Co-authored-by: Lucas Shaw <lucas.shaw1123@gmail.com>
Co-authored-by: Rozelette <Rozelette@users.noreply.github.com>

5 files changed, 145 insertions, 153 deletions

diff --git a/src/boot_O2_g3/boot_main.c b/src/boot_O2_g3/boot_main.c
index 81daac81c..15f975124 100644
--- a/src/boot_O2_g3/boot_main.c
+++ b/src/boot_O2_g3/boot_main.c
@@ -2,13 +2,13 @@
 #include <global.h>
 
 void bootproc(void) {
-    StackCheck_Init(&sBootThreadInfo, sBootThreadStack, &sBootThreadStack[1024], 0, -1, "boot");
+    StackCheck_Init(&sBootThreadInfo, sBootThreadStack, sBootThreadStack + sizeof(sBootThreadStack), 0, -1, "boot");
     osMemSize = osGetMemSize();
     func_800818F4();
     osInitialize();
     osUnmapTLBAll();
     gCartHandle = osCartRomInit();
-    StackCheck_Init(&sIdleThreadInfo, sIdleThreadStack, &sIdleThreadStack[1024], 0, 256, "idle");
-    osCreateThread(&sIdleThread, 1, (osCreateThread_func)Idle_ThreadEntry, 0, &sIdleThreadStack[1024], 12);
+    StackCheck_Init(&sIdleThreadInfo, sIdleThreadStack, sIdleThreadStack + sizeof(sIdleThreadStack), 0, 256, "idle");
+    osCreateThread(&sIdleThread, 1, Idle_ThreadEntry, NULL, sIdleThreadStack + sizeof(sIdleThreadStack), 12);
     osStartThread(&sIdleThread);
 }
diff --git a/src/boot_O2_g3/idle.c b/src/boot_O2_g3/idle.c
index fdc330543..3da1cb5f7 100644
--- a/src/boot_O2_g3/idle.c
+++ b/src/boot_O2_g3/idle.c
@@ -8,23 +8,20 @@ u32 gViConfigFeatures = 0x42;
 f32 gViConfigXScale = 1.0f;
 f32 gViConfigYScale = 1.0f;
 
-void Idle_ClearMemory(void* begin, void* end){
+void Idle_ClearMemory(const void* begin, const void* end) {
     if (begin < end) {
         bzero(begin, (s32)(int)end - (int)begin);
     }
 }
 
-#ifdef NON_MATCHING
-// This loop shouldn't unroll
 void Idle_InitFramebuffer(u32* ptr, u32 numBytes, u32 value) {
+    s32 temp = sizeof(u32);
+
     while (numBytes) {
         *ptr++ = value;
-        numBytes -= sizeof(u32);
+        numBytes -= temp;
     }
 }
-#else
-#pragma GLOBAL_ASM("./asm/non_matchings/boot/idle/Idle_InitFramebuffer.asm")
-#endif
 
 void Idle_InitScreen(void) {
     Idle_InitFramebuffer((u32*)&gFramebuffer1, 0x25800, 0x00010001);
@@ -58,7 +55,7 @@ void Idle_InitCodeAndMemory(void) {
     DmaMgr_SendRequestImpl(&dmaReq, (u32)&code_text_start, (u32)_codeSegmentRomStart, (u32)_codeSegmentRomEnd - (u32)_codeSegmentRomStart, 0, &queue, 0);
     Idle_InitScreen();
     Idle_InitMemory();
-    osRecvMesg(&queue, 0, 1);
+    osRecvMesg(&queue, NULL, 1);
 
     sDmaMgrDmaBuffSize = oldSize;
 
@@ -69,15 +66,15 @@ void Idle_InitCodeAndMemory(void) {
 #endif
 
 void Main_ThreadEntry(void* arg) {
-    StackCheck_Init(&irqmgrStackEntry, &irqmgrStack, &irqmgrStack[1280], 0, 256, "irqmgr");
-    IrqMgr_Create(&irqmgrContext, &irqmgrStackEntry, 18, 1);
-    Dmamgr_Start();
+    StackCheck_Init(&sIrqMgrStackInfo, sIrqMgrStack, sIrqMgrStack + sizeof(sIrqMgrStack), 0, 256, "irqmgr");
+    IrqMgr_Init(&gIrqMgr, &sIrqMgrStackInfo, 18, 1);
+    DmaMgr_Start();
     Idle_InitCodeAndMemory();
     main(arg);
-    Dmamgr_Stop();
+    DmaMgr_Stop();
 }
 
-void func_8008038C(void) {
+void Idle_InitVideo(void) {
     osCreateViManager(254);
 
     gViConfigFeatures = 66;
@@ -87,15 +84,15 @@ void func_8008038C(void) {
     switch (osTvType) {
     case 1:
         D_8009B290 = 2;
-        D_8009B240 = osViModeNtscLan1;
+        gViConfigMode = osViModeNtscLan1;
         break;
     case 2:
         D_8009B290 = 30;
-        D_8009B240 = osViModeMpalLan1;
+        gViConfigMode = osViModeMpalLan1;
         break;
     case 0:
         D_8009B290 = 44;
-        D_8009B240 = D_800980E0;
+        gViConfigMode = osViModeFpalLan1;
         gViConfigYScale = 0.833f;
         break;
     }
@@ -104,11 +101,11 @@ void func_8008038C(void) {
 }
 
 void Idle_ThreadEntry(void* arg) {
-    func_8008038C();
-    osCreatePiManager(150, &D_8009B228, D_8009B160, 50);
-    StackCheck_Init(&mainStackEntry, &mainStack, &mainStack[2304], 0, 1024, "main");
-    osCreateThread(&mainOSThread, 3, (osCreateThread_func)Main_ThreadEntry, arg, &mainStack[2304], 12);
-    osStartThread(&mainOSThread);
+    Idle_InitVideo();
+    osCreatePiManager(150, &gPiMgrCmdQ, sPiMgrCmdBuff, ARRAY_COUNT(sPiMgrCmdBuff));
+    StackCheck_Init(&sMainStackInfo, sMainStack, sMainStack + sizeof(sMainStack), 0, 1024, "main");
+    osCreateThread(&gMainThread, 3, Main_ThreadEntry, arg, sMainStack + sizeof(sMainStack), 12);
+    osStartThread(&gMainThread);
     osSetThreadPri(NULL, 0);
 
     for(;;);
diff --git a/src/boot_O2_g3/irqmgr.c b/src/boot_O2_g3/irqmgr.c
index 14c3e9bd6..cc3c917f2 100644
--- a/src/boot_O2_g3/irqmgr.c
+++ b/src/boot_O2_g3/irqmgr.c
@@ -155,7 +155,7 @@ void IrqMgr_ThreadEntry(IrqMgr* irqmgr) {
     }
 }
 
-void IrqMgr_Create(IrqMgr* irqmgr, void* stack, OSPri pri, u8 retraceCount) {
+void IrqMgr_Init(IrqMgr* irqmgr, void* stack, OSPri pri, u8 retraceCount) {
     irqmgr->callbacks = NULL;
     irqmgr->verticalRetraceMesg.type = 1;
     irqmgr->prenmiMsg.type = 4;
diff --git a/src/boot_O2_g3/viconfig.c b/src/boot_O2_g3/viconfig.c
index c36f9b2e2..64f3d4ec9 100644
--- a/src/boot_O2_g3/viconfig.c
+++ b/src/boot_O2_g3/viconfig.c
@@ -1,9 +1,8 @@
 #include <ultra64.h>
 #include <global.h>
 
-#ifdef NON_MATCHING
-void ViConfig_UpdateVi(u32 arg0) {
-    if (arg0 != 0) {
+void ViConfig_UpdateVi(u32 mode) {
+    if (mode != 0) {
         switch (osTvType) {
         case 2:
             osViSetMode(&osViModeMpalLan1);
@@ -17,7 +16,6 @@ void ViConfig_UpdateVi(u32 arg0) {
             break;
         }
 
-		// TODO v0 is used here instead of a0. Is this a 7.1 optimization?
         if (gViConfigFeatures != 0) {
             osViSetSpecialFeatures(gViConfigFeatures);
         }
@@ -26,13 +24,12 @@ void ViConfig_UpdateVi(u32 arg0) {
             osViSetYScale(1);
         }
     } else {
-        osViSetMode(&D_8009B240);
+        osViSetMode(&gViConfigMode);
 
         if (gViConfigAdditionalScanLines != 0) {
             func_80087E00(gViConfigAdditionalScanLines);
         }
 
-		// TODO v0 is used here instead of a0. Is this a 7.1 optimization?
         if (gViConfigFeatures != 0) {
             osViSetSpecialFeatures(gViConfigFeatures);
         }
@@ -46,11 +43,9 @@ void ViConfig_UpdateVi(u32 arg0) {
         }
     }
 
-    gViConfigUseDefault = arg0;
+    gViConfigUseDefault = mode;
 }
-#else
-#pragma GLOBAL_ASM("./asm/non_matchings/boot/viconfig/ViConfig_UpdateVi.asm")
-#endif
+
 
 void ViConfig_UpdateBlack(void) {
     if (gViConfigUseDefault != 0) {
diff --git a/src/boot_O2_g3/z_std_dma.c b/src/boot_O2_g3/z_std_dma.c
index 2f617eb03..e7c153a49 100644
--- a/src/boot_O2_g3/z_std_dma.c
+++ b/src/boot_O2_g3/z_std_dma.c
@@ -1,45 +1,45 @@
 #include <ultra64.h>
 #include <global.h>
 
-UNK_TYPE4 sDmaMgrDmaBuffSize = 0x2000;
+u32 sDmaMgrDmaBuffSize = 0x2000;
 
-s32 DmaMgr_DMARomToRam(u32 a0, void* a1, u32 a2) {
-    OSIoMesg sp60;
-    OSMesgQueue sp48;
-    OSMesg sp44;
+s32 DmaMgr_DMARomToRam(u32 rom, void* ram, u32 size) {
+    OSIoMesg ioMsg;
+    OSMesgQueue queue;
+    OSMesg msg[1];
     s32 ret;
-    u32 s0 = sDmaMgrDmaBuffSize;
-
-    osInvalDCache(a1, a2);
-    osCreateMesgQueue(&sp48, &sp44, 1);
-
-    if (s0 != 0) {
-        while (s0 < a2) {
-            sp60.hdr.pri = 0;
-            sp60.hdr.retQueue = &sp48;
-            sp60.devAddr = (u32)a0;
-            sp60.dramAddr = a1;
-            sp60.size = s0;
-            ret = osEPiStartDma(gCartHandle, &sp60, 0);
+    u32 buffSize = sDmaMgrDmaBuffSize;
+
+    osInvalDCache(ram, size);
+    osCreateMesgQueue(&queue, msg, ARRAY_COUNT(msg));
+
+    if (buffSize != 0) {
+        while (buffSize < size) {
+            ioMsg.hdr.pri = 0;
+            ioMsg.hdr.retQueue = &queue;
+            ioMsg.devAddr = (u32)rom;
+            ioMsg.dramAddr = ram;
+            ioMsg.size = buffSize;
+            ret = osEPiStartDma(gCartHandle, &ioMsg, 0);
             if (ret) goto END;
 
-            osRecvMesg(&sp48, NULL, 1);
-            a2 -= s0;
-            a0 = a0 + s0;
-            a1 = (u8*)a1 + s0;
+            osRecvMesg(&queue, NULL, 1);
+            size -= buffSize;
+            rom = rom + buffSize;
+            ram = (u8*)ram + buffSize;
         }
     }
-    sp60.hdr.pri = 0;
-    sp60.hdr.retQueue = &sp48;
-    sp60.devAddr = (u32)a0;
-    sp60.dramAddr = a1;
-    sp60.size = (u32)a2;
-    ret = osEPiStartDma(gCartHandle, &sp60, 0);
+    ioMsg.hdr.pri = 0;
+    ioMsg.hdr.retQueue = &queue;
+    ioMsg.devAddr = (u32)rom;
+    ioMsg.dramAddr = ram;
+    ioMsg.size = (u32)size;
+    ret = osEPiStartDma(gCartHandle, &ioMsg, 0);
     if (ret) goto END;
 
-    osRecvMesg(&sp48, NULL, 1);
+    osRecvMesg(&queue, NULL, 1);
 
-    osInvalDCache(a1, a2);
+    osInvalDCache(ram, size);
 
 END:
     return ret;
@@ -49,12 +49,12 @@ void DmaMgr_DmaCallback0(OSPiHandle* pihandle, OSIoMesg* mb, s32 direction) {
     osEPiStartDma(pihandle, mb, direction);
 }
 
-DmaEntry* Dmamgr_FindDmaEntry(u32 a0) {
+DmaEntry* DmaMgr_FindDmaEntry(u32 vrom) {
     DmaEntry* curr;
 
     for (curr = dmadata; curr->vromEnd != 0; curr++) {
-        if (a0 < curr->vromStart) continue;
-        if (a0 >= curr->vromEnd) continue;
+        if (vrom < curr->vromStart) continue;
+        if (vrom >= curr->vromEnd) continue;
 
         return curr;
     }
@@ -62,16 +62,16 @@ DmaEntry* Dmamgr_FindDmaEntry(u32 a0) {
     return NULL;
 }
 
-u32 Dmamgr_TranslateVromToRom(u32 a0) {
-    DmaEntry* v0 = Dmamgr_FindDmaEntry(a0);
+u32 DmaMgr_TranslateVromToRom(u32 vrom) {
+    DmaEntry* entry = DmaMgr_FindDmaEntry(vrom);
 
-    if (v0 != NULL) {
-        if (v0->romEnd == 0) {
-            return a0 + v0->romStart - v0->vromStart;
+    if (entry != NULL) {
+        if (entry->romEnd == 0) {
+            return vrom + entry->romStart - entry->vromStart;
         }
 
-        if (a0 == v0->vromStart) {
-            return v0->romStart;
+        if (vrom == entry->vromStart) {
+            return entry->romStart;
         }
 
         return -1;
@@ -80,86 +80,86 @@ u32 Dmamgr_TranslateVromToRom(u32 a0) {
     return -1;
 }
 
-s32 Dmamgr_FindDmaIndex(u32 a0) {
-    DmaEntry* v0 = Dmamgr_FindDmaEntry(a0);
+s32 DmaMgr_FindDmaIndex(u32 vrom) {
+    DmaEntry* entry = DmaMgr_FindDmaEntry(vrom);
 
-    if (v0 != NULL) {
-		return v0 - dmadata;
+    if (entry != NULL) {
+		return entry - dmadata;
     }
 
     return -1;
 }
 
-// TODO this should be a string
-char* func_800809F4(u32 a0) {
-    return &D_800981C0[0];
+const char* func_800809F4(u32 a0) {
+    return "??";
 }
 
-#ifdef NON_MATCHING
-void DmaMgr_ProcessMsg(DmaRequest* a0) {
-    u32 sp34;
-    u32 sp30;
-    UNK_TYPE sp2C;
-    UNK_TYPE sp28;
-    UNK_TYPE sp24;
-    UNK_TYPE sp20;
-    s32 sp1C;
-    UNK_TYPE sp18;
-
-    sp34 = a0->vromStart;
-    sp30 = a0->dramAddr;
-    sp2C = a0->size;
-
-    sp1C = Dmamgr_FindDmaIndex(sp34);
-
-    if ((sp1C >= 0) && (sp1C < numDmaEntries)) {
-        if (dmadata[sp1C].romEnd == 0) {
-            if (dmadata[sp1C].vromEnd < (sp2C + sp34)) {
-                Fault_AddHungupAndCrash(dmamgrString800981C4, 499);
+void DmaMgr_ProcessMsg(DmaRequest* req) {
+    u32 vrom;
+    void* ram;
+    u32 size;
+    u32 romStart;
+    u32 romSize;
+    DmaEntry* dmaEntry;
+    s32 index;
+
+    vrom = req->vromAddr;
+    ram = req->dramAddr;
+    size = req->size;
+
+    index = DmaMgr_FindDmaIndex(vrom);
+   
+    if ((index >= 0) && (index < numDmaEntries)) {
+        dmaEntry = &dmadata[index];
+        if (dmaEntry->romEnd == 0) {
+            if (dmaEntry->vromEnd < (vrom + size)) {
+                Fault_AddHungupAndCrash("../z_std_dma.c", 499);
             }
-            DmaMgr_DMARomToRam((dmadata[sp1C].romStart + sp34) - dmadata[sp1C].vromStart, (u8*)sp30, sp2C);
+            DmaMgr_DMARomToRam((dmaEntry->romStart + vrom) - dmaEntry->vromStart, (u8*)ram, size);
             return;
         }
 
-        // TODO this part is arranged slightly different is ASM
-        sp24 = dmadata[sp1C].romEnd - dmadata[sp1C].romStart;
-        sp28 = dmadata[sp1C].romStart;
+        romSize = dmaEntry->romEnd - dmaEntry->romStart;
+        romStart = dmaEntry->romStart;
 
-        if (sp34 != dmadata[sp1C].vromStart) {
-            Fault_AddHungupAndCrash(dmamgrString800981D4, 518);
+        if (vrom != dmaEntry->vromStart) {
+            Fault_AddHungupAndCrash("../z_std_dma.c", 518);
         }
 
-        if (sp2C != (dmadata[sp1C].vromEnd - dmadata[sp1C].vromStart)) {
-            Fault_AddHungupAndCrash(dmamgrString800981E4, 525);
+        if (size != (dmaEntry->vromEnd - dmaEntry->vromStart)) {
+            Fault_AddHungupAndCrash("../z_std_dma.c", 525);
         }
 
         osSetThreadPri(NULL, 10);
-        Yaz0_Decompress(sp28, sp30, sp24);
+        Yaz0_Decompress(romStart, ram, romSize);
         osSetThreadPri(NULL, 17);
     } else {
-        Fault_AddHungupAndCrash(dmamgrString800981F4, 558);
+        Fault_AddHungupAndCrash("../z_std_dma.c", 558);
     }
 }
-#else
-#pragma GLOBAL_ASM("./asm/non_matchings/boot/z_std_dma/DmaMgr_ProcessMsg.asm")
-#endif
 
-void Dmamgr_ThreadEntry(void* a0) {
-    OSMesg sp34;
-	u32 pad;
-    DmaRequest* s0;
-
-    for (;;) {
-        osRecvMesg(&dmamgrMsq, &sp34, 1);
-        if (sp34 == NULL) return;
-        s0 = (DmaRequest*)sp34;
-        DmaMgr_ProcessMsg(s0);
-        if (s0->notifyQueue == NULL) continue;
-        osSendMesg(s0->notifyQueue, s0->notifyMsg, 0);
+void DmaMgr_ThreadEntry(void* a0) {
+    OSMesg msg;
+    DmaRequest* req;
+
+    while (1) {
+        osRecvMesg(&sDmaMgrMsgQueue, &msg, OS_MESG_BLOCK);
+        
+        if (msg == NULL) {
+            break;
+        }
+    
+        req = (DmaRequest *)msg;
+
+        DmaMgr_ProcessMsg(req);
+        if (req->notifyQueue) {
+            osSendMesg(req->notifyQueue, req->notifyMsg, OS_MESG_NOBLOCK);
+        }
+        
     }
 }
 
-s32 DmaMgr_SendRequestImpl(DmaRequest* request, void* vramStart, u32 vromStart, u32 size, UNK_TYPE4 unused, OSMesgQueue* callback, void* callbackMesg) {
+s32 DmaMgr_SendRequestImpl(DmaRequest* request, void* vramStart, u32 vromStart, u32 size, UNK_TYPE4 unused, OSMesgQueue* queue, OSMesg msg) {
     if (gIrqMgrResetStatus >= 2) {
         return -2;
     }
@@ -168,56 +168,56 @@ s32 DmaMgr_SendRequestImpl(DmaRequest* request, void* vramStart, u32 vromStart,
     request->dramAddr = vramStart;
     request->size = size;
     request->unk14 = 0;
-    request->notifyQueue = callback;
-    request->notifyMsg = callbackMesg;
+    request->notifyQueue = queue;
+    request->notifyMsg = msg;
 
-    osSendMesg(&dmamgrMsq, request, 1);
+    osSendMesg(&sDmaMgrMsgQueue, request, OS_MESG_BLOCK);
 
     return 0;
 }
 
 s32 DmaMgr_SendRequest0(void* vramStart, u32 vromStart, u32 size) {
-	DmaRequest sp48;
-    OSMesgQueue sp30;
-    OSMesg sp2C;
+	DmaRequest req;
+    OSMesgQueue queue;
+    OSMesg msg[1];
 	s32 ret;
 
-    osCreateMesgQueue(&sp30, &sp2C, 1);
+    osCreateMesgQueue(&queue, msg, ARRAY_COUNT(msg));
 
-	ret = DmaMgr_SendRequestImpl(&sp48, vramStart, vromStart, size, 0, &sp30, 0);
+	ret = DmaMgr_SendRequestImpl(&req, vramStart, vromStart, size, 0, &queue, NULL);
 
 	if (ret == -1) {
 		return ret;
 	} else {
-		osRecvMesg(&sp30, NULL, 1);
+		osRecvMesg(&queue, NULL, OS_MESG_BLOCK);
 	}
 
 	return 0;
 }
 
+const char dmamgrThreadName[] = "dmamgr";
+
 #ifdef NON_MATCHING
 // TODO missing a useless move initializing v0, and some reorderings
-void Dmamgr_Start() {
-	DmaEntry* v0;
-	u32 v1;
-	DmaMgr_DMARomToRam((u32)_dmadataSegmentRomStart, dmadata, (u32)_dmadataSegmentRomEnd - (u32)_dmadataSegmentRomStart);
-
-	for (v0 = dmadata, v1 = 0; v0->vromEnd != 0; v0++, v1++);
-
-	numDmaEntries = v1;
+void DmaMgr_Start() {
+	DmaEntry* iter;
+	u32 idx;
 
-	osCreateMesgQueue(&dmamgrMsq, dmamgrMsqMessages, 32);
+	DmaMgr_DMARomToRam((u32)_dmadataSegmentRomStart, dmadata, (u32)(_dmadataSegmentRomEnd - _dmadataSegmentRomStart));
 
-	StackCheck_Init(&dmamgrStackEntry, &dmamgrStack, &dmamgrStack[1280], 0, 256, dmamgrThreadName);
+	for (iter = dmadata, idx = 0; iter->vromEnd != 0; iter++, idx++);
 
-	osCreateThread(&dmamgrOSThread, 18, Dmamgr_ThreadEntry, NULL, &dmamgrStack[1280], 17);
+	numDmaEntries = idx;
 
-	osStartThread(&dmamgrOSThread);
+	osCreateMesgQueue(&sDmaMgrMsgQueue, sDmaMgrMsgs, ARRAY_COUNT(sDmaMgrMsgs));
+	StackCheck_Init(&sDmaMgrStackInfo, sDmaMgrStack, sDmaMgrStack + sizeof(sDmaMgrStack), 0, 256, dmamgrThreadName);
+	osCreateThread(&sDmaMgrThread, 18, DmaMgr_ThreadEntry, NULL, sDmaMgrStack + sizeof(sDmaMgrStack), 17);
+	osStartThread(&sDmaMgrThread);
 }
 #else
-#pragma GLOBAL_ASM("./asm/non_matchings/boot/z_std_dma/Dmamgr_Start.asm")
+#pragma GLOBAL_ASM("./asm/non_matchings/boot/z_std_dma/DmaMgr_Start.asm")
 #endif
 
-void Dmamgr_Stop() {
-    osSendMesg(&dmamgrMsq, NULL, 1);
+void DmaMgr_Stop() {
+    osSendMesg(&sDmaMgrMsgQueue, NULL, OS_MESG_BLOCK);
 }