From 60cfed1d6cfa6e6d0270994e9b8b8fb97468a490 Mon Sep 17 00:00:00 2001 From: Max Date: Thu, 5 Nov 2020 23:28:38 -0500 Subject: add two nonmatching ifdefs to code_801DD8C0 --- src/code_801DD8C0.cpp | 204 +++++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 179 insertions(+), 25 deletions(-) (limited to 'src/code_801DD8C0.cpp') diff --git a/src/code_801DD8C0.cpp b/src/code_801DD8C0.cpp index 43f6fa4..f27222e 100644 --- a/src/code_801DD8C0.cpp +++ b/src/code_801DD8C0.cpp @@ -25,6 +25,7 @@ struct gUnkClass10 #if 1 +// caller provides a linked list of gUnkClass8 // TODO: gUnkClass10 constructor? gUnkClass10* func_801DD8C0(gUnkClass10* p1, gUnkClass8* p2) { @@ -79,22 +80,33 @@ static inline BOOL helper_2(gUnkClass7* p1) return !helper_1(p1) && !(p1->unk6 & 0x10); } + +static inline BOOL TestFunction(gUnkClass7* ptr) +{ + return ptr->unk0 && ptr->unk6 & 0x1; +} + +// if bit 4 is cleared, clear bit 0 +static inline void ClearFunction(gUnkClass7* ptr) +{ + if (!(ptr->unk6 & 0x10)) + ptr->unk6 &= ~0x1; +} + // TODO: "flag"s are the results of inline functions? -#define NONMATCHING #ifdef NONMATCHING +// r4/r6 regswap void func_801DD9C8(gUnkClass10* p1, float p2) { if (p1->unk4) { - BOOL flag = FALSE; - if (p1->unk4->unk0 && (p1->unk4->unk6 & 0x1)) - flag = TRUE; - if (flag) { + if (TestFunction(p1->unk4)) { func_801DD5C8(p1->unk4, p2); func_801DD7FC(p1->unk4, p1, 0); BOOL flag2 = TRUE; //r4 + u16* new_var = &p1->unk4->unk6; if (!(p1->unk4->unk6 & 0x8)) { - flag = FALSE; - if (p1->unk4->unk0 && (p1->unk4->unk6 & 0x1)) + BOOL flag = FALSE; + if (p1->unk4->unk0 && (*new_var & 0x1)) flag = TRUE; if (flag) flag2 = FALSE; @@ -189,7 +201,6 @@ gUnkClass8* func_801DDA94(gUnkClass10* p1, u16 p2) } // set unk4 member of p1 -// TODO: parameterized base class constructor? void func_801DDABC(gUnkClass10* p1, u16 p2, u16 p3, float p4, float p5) { gUnkClass7* r6 = p1->unk4; @@ -204,7 +215,7 @@ void func_801DDABC(gUnkClass10* p1, u16 p2, u16 p3, float p4, float p5) r4->unkC = p4; r4->unk8 = p5; r4->unk4 = p3 & 0xFF; - r4->unk6 = 3; + r4->unk6 = 0x3; } } } @@ -250,9 +261,23 @@ gUnkClass10* func_801DDC08(gUnkClass10* p1, s32 p2) return p1; } +static inline void InlineFunction(gUnkClass10* p1, gUnkClass7* p2) +{ + func_801DD7FC(p2, p1, 0); + BOOL r4 = TRUE; + if (!(p2->unk6 & 0x8)) { + BOOL r3 = helper_1(p2); + if (r3) + r4 = FALSE; + } + if (r4 && !(p2->unk6 & 0x10)) { + p2->unk6 &= ~0x1; + } +} // derived class method calling base class method? -// NONMATCHING +#ifdef NONMATCHING +// regswaps and instruction ordering void func_801DDC84(gUnkClass10* p1, float p2) { if (p1->unk4) { @@ -275,7 +300,7 @@ void func_801DDC84(gUnkClass10* p1, float p2) func_801DD7FC(p1->unk4, p1, 0); BOOL r4 = TRUE; if (!(p1->unk4->unk6 & 0x8)) { - BOOL r3 = helper_1(p1->unk4); + BOOL r3 = p1->unk4->unk0 && (p1->unk4->unk6 & 0x1); if (r3) r4 = FALSE; } @@ -287,7 +312,7 @@ void func_801DDC84(gUnkClass10* p1, float p2) func_801DD7FC(p1->unk8, p1, 0); BOOL r4 = TRUE; if (!(p1->unk8->unk6 & 0x8)) { - BOOL r3 = helper_1(p1->unk8); + BOOL r3 = p1->unk8->unk0 && (p1->unk8->unk6 & 0x1); if (r3) r4 = FALSE; } @@ -298,35 +323,164 @@ void func_801DDC84(gUnkClass10* p1, float p2) } } } +#else +asm void func_801DDC84(gUnkClass10* p1, float p2) +{ + nofralloc +/* 801DDC84 001D98E4 94 21 FF E0 */ stwu r1, -0x20(r1) +/* 801DDC88 001D98E8 7C 08 02 A6 */ mflr r0 +/* 801DDC8C 001D98EC 90 01 00 24 */ stw r0, 0x24(r1) +/* 801DDC90 001D98F0 DB E1 00 18 */ stfd f31, 0x18(r1) +/* 801DDC94 001D98F4 FF E0 08 90 */ fmr f31, f1 +/* 801DDC98 001D98F8 93 E1 00 14 */ stw r31, 0x14(r1) +/* 801DDC9C 001D98FC 7C 7F 1B 78 */ mr r31, r3 +/* 801DDCA0 001D9900 93 C1 00 10 */ stw r30, 0x10(r1) +/* 801DDCA4 001D9904 93 A1 00 0C */ stw r29, 0xc(r1) +/* 801DDCA8 001D9908 80 83 00 04 */ lwz r4, 4(r3) +/* 801DDCAC 001D990C 2C 04 00 00 */ cmpwi r4, 0 +/* 801DDCB0 001D9910 41 82 01 7C */ beq lbl_801DDE2C +/* 801DDCB4 001D9914 80 04 00 00 */ lwz r0, 0(r4) +/* 801DDCB8 001D9918 3B A0 00 00 */ li r29, 0 +/* 801DDCBC 001D991C 2C 00 00 00 */ cmpwi r0, 0 +/* 801DDCC0 001D9920 41 82 00 14 */ beq lbl_801DDCD4 +/* 801DDCC4 001D9924 A0 04 00 06 */ lhz r0, 6(r4) +/* 801DDCC8 001D9928 54 00 07 FF */ clrlwi. r0, r0, 0x1f +/* 801DDCCC 001D992C 41 82 00 08 */ beq lbl_801DDCD4 +/* 801DDCD0 001D9930 3B A0 00 01 */ li r29, 1 +lbl_801DDCD4: +/* 801DDCD4 001D9934 80 A3 00 08 */ lwz r5, 8(r3) +/* 801DDCD8 001D9938 3B C0 00 00 */ li r30, 0 +/* 801DDCDC 001D993C 2C 05 00 00 */ cmpwi r5, 0 +/* 801DDCE0 001D9940 41 82 00 30 */ beq lbl_801DDD10 +/* 801DDCE4 001D9944 80 05 00 00 */ lwz r0, 0(r5) +/* 801DDCE8 001D9948 38 60 00 00 */ li r3, 0 +/* 801DDCEC 001D994C 2C 00 00 00 */ cmpwi r0, 0 +/* 801DDCF0 001D9950 41 82 00 14 */ beq lbl_801DDD04 +/* 801DDCF4 001D9954 A0 05 00 06 */ lhz r0, 6(r5) +/* 801DDCF8 001D9958 54 00 07 FF */ clrlwi. r0, r0, 0x1f +/* 801DDCFC 001D995C 41 82 00 08 */ beq lbl_801DDD04 +/* 801DDD00 001D9960 38 60 00 01 */ li r3, 1 +lbl_801DDD04: +/* 801DDD04 001D9964 2C 03 00 00 */ cmpwi r3, 0 +/* 801DDD08 001D9968 41 82 00 08 */ beq lbl_801DDD10 +/* 801DDD0C 001D996C 3B C0 00 01 */ li r30, 1 +lbl_801DDD10: +/* 801DDD10 001D9970 2C 1D 00 00 */ cmpwi r29, 0 +/* 801DDD14 001D9974 41 82 00 10 */ beq lbl_801DDD24 +/* 801DDD18 001D9978 FC 20 F8 90 */ fmr f1, f31 +/* 801DDD1C 001D997C 7C 83 23 78 */ mr r3, r4 +/* 801DDD20 001D9980 4B FF F8 A9 */ bl func_801DD5C8 +lbl_801DDD24: +/* 801DDD24 001D9984 2C 1E 00 00 */ cmpwi r30, 0 +/* 801DDD28 001D9988 41 82 00 24 */ beq lbl_801DDD4C +/* 801DDD2C 001D998C FC 20 F8 90 */ fmr f1, f31 +/* 801DDD30 001D9990 80 7F 00 08 */ lwz r3, 8(r31) +/* 801DDD34 001D9994 4B FF F8 95 */ bl func_801DD5C8 +/* 801DDD38 001D9998 80 7F 00 04 */ lwz r3, 4(r31) +/* 801DDD3C 001D999C 3B A0 00 01 */ li r29, 1 +/* 801DDD40 001D99A0 A0 03 00 06 */ lhz r0, 6(r3) +/* 801DDD44 001D99A4 60 00 00 02 */ ori r0, r0, 2 +/* 801DDD48 001D99A8 B0 03 00 06 */ sth r0, 6(r3) +lbl_801DDD4C: +/* 801DDD4C 001D99AC 2C 1D 00 00 */ cmpwi r29, 0 +/* 801DDD50 001D99B0 41 82 00 6C */ beq lbl_801DDDBC +/* 801DDD54 001D99B4 80 7F 00 04 */ lwz r3, 4(r31) +/* 801DDD58 001D99B8 7F E4 FB 78 */ mr r4, r31 +/* 801DDD5C 001D99BC 38 A0 00 00 */ li r5, 0 +/* 801DDD60 001D99C0 4B FF FA 9D */ bl func_801DD7FC +/* 801DDD64 001D99C4 80 DF 00 04 */ lwz r6, 4(r31) +/* 801DDD68 001D99C8 38 80 00 01 */ li r4, 1 +/* 801DDD6C 001D99CC A0 A6 00 06 */ lhz r5, 6(r6) +/* 801DDD70 001D99D0 54 A0 07 39 */ rlwinm. r0, r5, 0, 0x1c, 0x1c +/* 801DDD74 001D99D4 40 82 00 2C */ bne lbl_801DDDA0 +/* 801DDD78 001D99D8 80 06 00 00 */ lwz r0, 0(r6) +/* 801DDD7C 001D99DC 38 60 00 00 */ li r3, 0 +/* 801DDD80 001D99E0 2C 00 00 00 */ cmpwi r0, 0 +/* 801DDD84 001D99E4 41 82 00 10 */ beq lbl_801DDD94 +/* 801DDD88 001D99E8 54 A0 07 FF */ clrlwi. r0, r5, 0x1f +/* 801DDD8C 001D99EC 41 82 00 08 */ beq lbl_801DDD94 +/* 801DDD90 001D99F0 38 60 00 01 */ li r3, 1 +lbl_801DDD94: +/* 801DDD94 001D99F4 2C 03 00 00 */ cmpwi r3, 0 +/* 801DDD98 001D99F8 41 82 00 08 */ beq lbl_801DDDA0 +/* 801DDD9C 001D99FC 38 80 00 00 */ li r4, 0 +lbl_801DDDA0: +/* 801DDDA0 001D9A00 2C 04 00 00 */ cmpwi r4, 0 +/* 801DDDA4 001D9A04 41 82 00 18 */ beq lbl_801DDDBC +/* 801DDDA8 001D9A08 A0 66 00 06 */ lhz r3, 6(r6) +/* 801DDDAC 001D9A0C 54 60 06 F7 */ rlwinm. r0, r3, 0, 0x1b, 0x1b +/* 801DDDB0 001D9A10 40 82 00 0C */ bne lbl_801DDDBC +/* 801DDDB4 001D9A14 54 60 04 3C */ rlwinm r0, r3, 0, 0x10, 0x1e +/* 801DDDB8 001D9A18 B0 06 00 06 */ sth r0, 6(r6) +lbl_801DDDBC: +/* 801DDDBC 001D9A1C 2C 1E 00 00 */ cmpwi r30, 0 +/* 801DDDC0 001D9A20 41 82 00 6C */ beq lbl_801DDE2C +/* 801DDDC4 001D9A24 80 7F 00 08 */ lwz r3, 8(r31) +/* 801DDDC8 001D9A28 7F E4 FB 78 */ mr r4, r31 +/* 801DDDCC 001D9A2C 38 A0 00 01 */ li r5, 1 +/* 801DDDD0 001D9A30 4B FF FA 2D */ bl func_801DD7FC +/* 801DDDD4 001D9A34 80 DF 00 08 */ lwz r6, 8(r31) +/* 801DDDD8 001D9A38 38 80 00 01 */ li r4, 1 +/* 801DDDDC 001D9A3C A0 A6 00 06 */ lhz r5, 6(r6) +/* 801DDDE0 001D9A40 54 A0 07 39 */ rlwinm. r0, r5, 0, 0x1c, 0x1c +/* 801DDDE4 001D9A44 40 82 00 2C */ bne lbl_801DDE10 +/* 801DDDE8 001D9A48 80 06 00 00 */ lwz r0, 0(r6) +/* 801DDDEC 001D9A4C 38 60 00 00 */ li r3, 0 +/* 801DDDF0 001D9A50 2C 00 00 00 */ cmpwi r0, 0 +/* 801DDDF4 001D9A54 41 82 00 10 */ beq lbl_801DDE04 +/* 801DDDF8 001D9A58 54 A0 07 FF */ clrlwi. r0, r5, 0x1f +/* 801DDDFC 001D9A5C 41 82 00 08 */ beq lbl_801DDE04 +/* 801DDE00 001D9A60 38 60 00 01 */ li r3, 1 +lbl_801DDE04: +/* 801DDE04 001D9A64 2C 03 00 00 */ cmpwi r3, 0 +/* 801DDE08 001D9A68 41 82 00 08 */ beq lbl_801DDE10 +/* 801DDE0C 001D9A6C 38 80 00 00 */ li r4, 0 +lbl_801DDE10: +/* 801DDE10 001D9A70 2C 04 00 00 */ cmpwi r4, 0 +/* 801DDE14 001D9A74 41 82 00 18 */ beq lbl_801DDE2C +/* 801DDE18 001D9A78 A0 66 00 06 */ lhz r3, 6(r6) +/* 801DDE1C 001D9A7C 54 60 06 F7 */ rlwinm. r0, r3, 0, 0x1b, 0x1b +/* 801DDE20 001D9A80 40 82 00 0C */ bne lbl_801DDE2C +/* 801DDE24 001D9A84 54 60 04 3C */ rlwinm r0, r3, 0, 0x10, 0x1e +/* 801DDE28 001D9A88 B0 06 00 06 */ sth r0, 6(r6) +lbl_801DDE2C: +/* 801DDE2C 001D9A8C 80 01 00 24 */ lwz r0, 0x24(r1) +/* 801DDE30 001D9A90 CB E1 00 18 */ lfd f31, 0x18(r1) +/* 801DDE34 001D9A94 83 E1 00 14 */ lwz r31, 0x14(r1) +/* 801DDE38 001D9A98 83 C1 00 10 */ lwz r30, 0x10(r1) +/* 801DDE3C 001D9A9C 83 A1 00 0C */ lwz r29, 0xc(r1) +/* 801DDE40 001D9AA0 7C 08 03 A6 */ mtlr r0 +/* 801DDE44 001D9AA4 38 21 00 20 */ addi r1, r1, 0x20 +/* 801DDE48 001D9AA8 4E 80 00 20 */ blr +} +#pragma peephole on +#endif + // TODO: inlining -// TODO: parameterized derived class constructor? // This matches void func_801DDE4C(gUnkClass10* p1, u16 p2, u16 p3, float p4, float p5) { if (p1->unk8) { - BOOL r6 = FALSE; p1->unkC = 0.0f; - if (p1->unk8->unk0 && (p1->unk8->unk6 & 0x1)) { - r6 = TRUE; - } - if (r6 && !(p1->unk8->unk6 & 0x10)) { - p1->unk8->unk6 &= ~0x1; + if (TestFunction(p1->unk8)) { + ClearFunction(p1->unk8); } } func_801DDABC(p1, p2, p3, p4, p5); } +// NOTE: nearly identical to func_801DDABC. Modifies unk8 instead of unk4, and initializes p1->unkC + +// Populate structure referenced by unk8, attaching it to a gUnkClass8 with the matching id // derived class method? // matches -void func_801DDEA0(gUnkClass10* p1, u16 p2, u16 p3, float p4, float p5, float p6) +void func_801DDEA0(gUnkClass10* p1, u16 id, u16 p3, float p4, float p5, float p6) { if (p1->unk8) { - if (!(p1->unk8->unk6 & 0x10)) { - p1->unk8->unk6 &= ~0x1; - } - gUnkClass8* r3 = func_801DDA94(p1, p2); - + ClearFunction(p1->unk8); + // TODO: 5 parameter inline function? + gUnkClass8* r3 = func_801DDA94(p1, id); if (r3) { gUnkClass7* r4 = p1->unk8; if (!(r4->unk6 & 0x10)) { -- cgit v1.2.3