From b70fb3a728cd9fdefc38ed790c6f6ed438fe8280 Mon Sep 17 00:00:00 2001 From: Drew T <50529377+Druthulu@users.noreply.github.com> Date: Wed, 22 Jul 2026 00:41:58 -0600 Subject: [PATCH] =?UTF-8?q?feat(phase-29):=20func=5F80135A4C=20family=20sw?= =?UTF-8?q?eep=20probe=20=E2=80=94=20ov=5FSC01=5F000=20banked=20(mechanism?= =?UTF-8?q?=20validated)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- config/overlays.mk | 2 +- config/splat.ov_SC01_000.yaml | 33 +- src/ov_SC01_000/ov_SC01_000_jr_8012ACE0.c | 429 -------- src/ov_SC01_000/ov_SC01_000_jr_80135A4C.c | 1215 +++++++++++++++++++++ 4 files changed, 1234 insertions(+), 445 deletions(-) create mode 100644 src/ov_SC01_000/ov_SC01_000_jr_80135A4C.c diff --git a/config/overlays.mk b/config/overlays.mk index 29026c0bd..a594c53b4 100644 --- a/config/overlays.mk +++ b/config/overlays.mk @@ -129,7 +129,7 @@ ov_SC01_000_ELF := $(ov_SC01_000_OUT).elf ov_SC01_000_MAPFILE := $(ov_SC01_000_OUT).map ov_SC01_000_LD_SCRIPT := $(ov_SC01_000_OUT).ld ov_SC01_000_SPLAT_YAML := config/splat.ov_SC01_000.yaml -ov_SC01_000_JTBL_INTERLEAVE := --order tail.data.o,ov_SC01_000_jr_8012ACE0.o,tail2.data.o,ov_SC01_000_jr_801380E0.o,tail3.data.o,ov_SC01_000_jr_8013F350.o,tail4.data.o,ov_SC01_000_jr_8013FFD8.o,tail5.data.o,ov_SC01_000_jr_80140608.o,tail6.data.o,ov_SC01_000_jr_8015444C.o,tail7.data.o,ov_SC01_000_jr_80154C24.o,ov_SC01_000_jr_801588CC.o,tail8.data.o,ov_SC01_000_jr_80159C84.o,tail9.data.o,ov_SC01_000_jr_8015A3C8.o,tail10.data.o,ov_SC01_000_jr_8015AE2C.o,tail11.data.o,ov_SC01_000_jr_8015C32C.o,tail12.data.o,ov_SC01_000_jr_8016AB6C.o,tail13.data.o,ov_SC01_000_jr_801734BC.o,tail14.data.o,ov_SC01_000_jr_80178D40.o,tail15.data.o,ov_SC01_000_jr_8017A4AC.o,tail16.data.o,ov_SC01_000_jr_8017AE2C.o,ov_SC01_000_jr_8017BEBC.o,tail17.data.o,trailing.o # Phase-26 §8 jtbl-rodata carve +ov_SC01_000_JTBL_INTERLEAVE := --order tail.data.o,ov_SC01_000_jr_8012ACE0.o,tail2.data.o,ov_SC01_000_jr_80135A4C.o,tail3.data.o,ov_SC01_000_jr_801380E0.o,tail4.data.o,ov_SC01_000_jr_8013F350.o,tail5.data.o,ov_SC01_000_jr_8013FFD8.o,tail6.data.o,ov_SC01_000_jr_80140608.o,tail7.data.o,ov_SC01_000_jr_8015444C.o,tail8.data.o,ov_SC01_000_jr_80154C24.o,ov_SC01_000_jr_801588CC.o,tail9.data.o,ov_SC01_000_jr_80159C84.o,tail10.data.o,ov_SC01_000_jr_8015A3C8.o,tail11.data.o,ov_SC01_000_jr_8015AE2C.o,tail12.data.o,ov_SC01_000_jr_8015C32C.o,tail13.data.o,ov_SC01_000_jr_8016AB6C.o,tail14.data.o,ov_SC01_000_jr_801734BC.o,tail15.data.o,ov_SC01_000_jr_80178D40.o,tail16.data.o,ov_SC01_000_jr_8017A4AC.o,tail17.data.o,ov_SC01_000_jr_8017AE2C.o,ov_SC01_000_jr_8017BEBC.o,tail18.data.o,trailing.o # Phase-26 §8 jtbl-rodata carve build/src/ov_SC01_000/ov_SC01_000_jr_8012ACE0.o: JTBL_PADS := 0,0 # §8e pads (jtbl_carve.py) build/src/ov_SC01_000/ov_SC01_000_jr_8013F350.o: JTBL_PADS := 0,0 # §8e pads (jtbl_carve.py) tables=+0x0,+0x20 build/src/ov_SC01_000/ov_SC01_000_jr_80154C24.o: JTBL_PADS := 0,0 # §8e pads (jtbl_carve.py) tables=+0x0,+0x24 diff --git a/config/splat.ov_SC01_000.yaml b/config/splat.ov_SC01_000.yaml index be8edbb0b..365856f79 100644 --- a/config/splat.ov_SC01_000.yaml +++ b/config/splat.ov_SC01_000.yaml @@ -95,6 +95,7 @@ segments: # - [0x0, rodata, head] - [0x0, c, ov_SC01_000] - [0x2b88, c, ov_SC01_000_jr_8012ACE0] + - [0xd8f4, c, ov_SC01_000_jr_80135A4C] - [0xff88, c, ov_SC01_000_jr_801380E0] - [0x171f8, c, ov_SC01_000_jr_8013F350] - [0x17e80, c, ov_SC01_000_jr_8013FFD8] @@ -117,38 +118,40 @@ segments: - [0x56a64, data, tail] - [0x7b1c4, .rodata, ov_SC01_000_jr_8012ACE0] # Phase-26 §8 jtbl-rodata carve (jtbl_carve.py) - [0x7b2a4, data, tail2] + - [0x7b2d4, .rodata, ov_SC01_000_jr_80135A4C] # Phase-26 §8 jtbl-rodata carve (jtbl_carve.py) + - [0x7b2e8, data, tail3] - [0x7b33c, .rodata, ov_SC01_000_jr_801380E0] # Phase-26 §8 jtbl-rodata carve (jtbl_carve.py) - - [0x7b3a0, data, tail3] + - [0x7b3a0, data, tail4] - [0x7b9ac, .rodata, ov_SC01_000_jr_8013F350] # Phase-26 §8 jtbl-rodata carve (jtbl_carve.py) - - [0x7b9e0, data, tail4] + - [0x7b9e0, data, tail5] - [0x7b9e4, .rodata, ov_SC01_000_jr_8013FFD8] # Phase-26 §8 jtbl-rodata carve (jtbl_carve.py) - - [0x7ba18, data, tail5] + - [0x7ba18, data, tail6] - [0x7ba54, .rodata, ov_SC01_000_jr_80140608] # Phase-26 §8 jtbl-rodata carve (jtbl_carve.py) - - [0x7ba68, data, tail6] + - [0x7ba68, data, tail7] - [0x7ba80, .rodata, ov_SC01_000_jr_8015444C] # Phase-26 §8 jtbl-rodata carve (jtbl_carve.py) - - [0x7baec, data, tail7] + - [0x7baec, data, tail8] - [0x7bb5c, .rodata, ov_SC01_000_jr_80154C24] # Phase-26 §8 jtbl-rodata carve (jtbl_carve.py) - [0x7bba0, .rodata, ov_SC01_000_jr_801588CC] # Phase-26 §8 jtbl-rodata carve (jtbl_carve.py) - - [0x7bbe8, data, tail8] + - [0x7bbe8, data, tail9] - [0x7bc48, .rodata, ov_SC01_000_jr_80159C84] # Phase-26 §8 jtbl-rodata carve (jtbl_carve.py) - - [0x7bc7c, data, tail9] + - [0x7bc7c, data, tail10] - [0x7bc80, .rodata, ov_SC01_000_jr_8015A3C8] # Phase-26 §8 jtbl-rodata carve (jtbl_carve.py) - - [0x7bc9c, data, tail10] + - [0x7bc9c, data, tail11] - [0x7bca0, .rodata, ov_SC01_000_jr_8015AE2C] # Phase-26 §8 jtbl-rodata carve (jtbl_carve.py) - - [0x7bcbc, data, tail11] + - [0x7bcbc, data, tail12] - [0x7bce0, .rodata, ov_SC01_000_jr_8015C32C] # Phase-26 §8 jtbl-rodata carve (jtbl_carve.py) - - [0x7bcfc, data, tail12] + - [0x7bcfc, data, tail13] - [0x7bd14, .rodata, ov_SC01_000_jr_8016AB6C] # Phase-26 §8 jtbl-rodata carve (jtbl_carve.py) - - [0x7bd34, data, tail13] + - [0x7bd34, data, tail14] - [0x7bdb4, .rodata, ov_SC01_000_jr_801734BC] # Phase-26 §8 jtbl-rodata carve (jtbl_carve.py) - - [0x7bdc8, data, tail14] + - [0x7bdc8, data, tail15] - [0x7bf70, .rodata, ov_SC01_000_jr_80178D40] # Phase-26 §8 jtbl-rodata carve (jtbl_carve.py) - - [0x7c0e8, data, tail15] + - [0x7c0e8, data, tail16] - [0x7c178, .rodata, ov_SC01_000_jr_8017A4AC] # Phase-26 §8 jtbl-rodata carve (jtbl_carve.py) - - [0x7c204, data, tail16] + - [0x7c204, data, tail17] - [0x7c208, .rodata, ov_SC01_000_jr_8017AE2C] # Phase-26 §8 jtbl-rodata carve (jtbl_carve.py) - [0x7c21c, .rodata, ov_SC01_000_jr_8017BEBC] # Phase-26 §8 jtbl-rodata carve (jtbl_carve.py) - - [0x7c23c, data, tail17] + - [0x7c23c, data, tail18] - [0x7D78C, bin, trailing] # final 3 bytes (EOF not 4-aligned; spimdisasm drops a partial word) - [0x7D78F] # EOF marker = the 0.4.dec byte length # @TRAILING@ (above) is replaced by tools/new_overlay.sh: for a non-4-aligned overlay it becomes diff --git a/src/ov_SC01_000/ov_SC01_000_jr_8012ACE0.c b/src/ov_SC01_000/ov_SC01_000_jr_8012ACE0.c index 22b7ec215..a8563f810 100644 --- a/src/ov_SC01_000/ov_SC01_000_jr_8012ACE0.c +++ b/src/ov_SC01_000/ov_SC01_000_jr_8012ACE0.c @@ -3016,432 +3016,3 @@ s16 func_80135480(void *param_1, s32 param_2, s16 *param_3, s16 *param_4) INCLUDE_ASM("asm/ov_SC01_000/nonmatchings/ov_SC01_000_jr_8012ACE0", func_80135888); - -INCLUDE_ASM("asm/ov_SC01_000/nonmatchings/ov_SC01_000_jr_8012ACE0", func_80135A4C); - -INCLUDE_ASM("asm/ov_SC01_000/nonmatchings/ov_SC01_000_jr_8012ACE0", func_80135D20); - -INCLUDE_ASM("asm/ov_SC01_000/nonmatchings/ov_SC01_000_jr_8012ACE0", func_80135EB0); - - -s32 func_80136334(void *arg0, s32 arg1, s32 arg2) { - extern u8 D_801152A8[]; - extern s16 D_801152AA; - extern s16 D_801152AC; - extern s16 D_80126722; - extern s16 D_80126724; - register s32 a1v __asm__("$11"); - register s32 a2v __asm__("$12"); - register s32 n __asm__("$5"); - register s16 *b4 __asm__("$7"); - s32 d; - s32 dx; - s32 denom; - s32 result; - s32 frame_pad[2]; - (void)&frame_pad; - __asm__("" : "=r"(a1v) : "0"(arg1)); - a2v = arg2; - - if (!(arg1 & 1)) { - dx = (s16) arg2 - (*(s16 **)&D_8017F198)[2]; - d = dx; - denom = -(*(s16 **)&D_8017F1A4)[2]; - } else { - denom = (*(s16 **)&D_8017F1A4)[2]; - d = (*(s16 **)&D_8017F198)[2] - (s16) arg2; - dx = -d; - } - n = -d; - { - register s16 *b8 __asm__("$6") = *(s16 **)&D_8017F1A4; - u16 *ac = *(u16 **)&D_8017F198; - b4 = D_8017F1A0; - b4[0] = ac[0] + n * b8[0] / denom; - b4[1] = ac[1] + n * b8[1] / denom; - b4[2] = ac[2] + dx; - } - - if (b4[0] < M2C_FIELD(arg0, s16 *, 4)) return 0; - if (M2C_FIELD(arg0, s16 *, 6) < b4[0]) return 0; - if (b4[1] < M2C_FIELD(arg0, s16 *, 8)) return 0; - if (M2C_FIELD(arg0, s16 *, 0xA) < b4[1]) return 0; - if (a1v & 0x8000) { - u16 *b0 = *(u16 **)&D_8017F19C; - b4[0] = b0[0]; - b4[1] = b0[1]; - } - D_801152AA = 0; - (*(s16 *)D_801152A8) = 0; - if (a1v & 1) { - D_8017F1A0[2] = a2v + 2; - __asm__ __volatile__(""); - D_801152AC = 0xFFF; - } else { - D_801152AC = -0xFFF; - D_8017F1A0[2] = a2v - 2; - } - __asm__ __volatile__("" :: "r"(a1v), "r"(a2v)); - (*(s16 *)D_80126720) = (M2C_FIELD(arg0, s16 *, 4) + M2C_FIELD(arg0, s16 *, 6)) >> 1; - D_80126722 = (M2C_FIELD(arg0, s16 *, 8) + M2C_FIELD(arg0, s16 *, 0xA)) >> 1; - result = 1; - D_80126724 = (M2C_FIELD(arg0, s16 *, 0xC) + M2C_FIELD(arg0, s16 *, 0xE)) >> 1; - return result; -} - - -INCLUDE_ASM("asm/ov_SC01_000/nonmatchings/ov_SC01_000_jr_8012ACE0", func_801365B8); - - -// @class: pointer-type — pointer-vs-array reconcile for func_80136824 (ov_SC01_077_a) -// D_8017F198/B0/B8 are file-scope `extern u8`, D_8017F1A0 is `extern s32 []`; each HOLDS a -// pointer value that the target loads via lw then derefs. Read as pointer via *(T**)&sym. -// D_8017F1A0 must be a SCALAR pointer (not s32[]) — as an array it decays and gcc CSEs the -// base address into a held reg (lui;addiu;lw 0(reg)) across the 3 reloads; as a scalar -// pointer it folds %lo (lui;lw %lo). Retype all 3 file-TU occurrences (byte-neutral: the -// siblings read it once via *(u16**)&sym == direct lw either way). - -s32 func_80136824(s32 arg0, s32 arg1, s32 arg2) { - extern u8 D_801152A8[]; - extern s16 D_801152AA; - extern s16 D_801152AC; - extern s16 D_80126722; - extern s16 D_80126724; - - register u16 *ac __asm__("$4"); - register s16 *b8 __asm__("$6"); - register s16 *b4 __asm__("$9"); - register s32 r __asm__("$3"); - register s32 pos __asm__("$12"); - register s32 a1v __asm__("$5"); - s16 temp_v0; - s16 temp_v1; - s32 var_a3; - s16 var_v0_3; - s32 temp_a1; - s32 var_t0; - s32 var_v1; - s16 *b4b; - u16 *p; - - __asm__ ("" : "=r"(a1v) : "0"(arg1)); - pos = arg2; - if (!(a1v & 1)) { - var_t0 = (s16) arg2 - (*(s16 **)&D_8017F198)[1]; - var_v1 = var_t0; - var_a3 = -(*(s16 **)&D_8017F1A4)[1]; - } else { - var_a3 = (*(s16 **)&D_8017F1A4)[1]; - var_v1 = (*(s16 **)&D_8017F198)[1] - (s16) arg2; - var_t0 = -var_v1; - } - b8 = (*(s16 **)&D_8017F1A4); - ac = (*(u16 **)&D_8017F198); - b4 = D_8017F1A0; - temp_a1 = -var_v1; - r = (temp_a1 * b8[0]) / var_a3; - b4[0] = ac[0] + r; - b4[1] = ac[1] + var_t0; - r = (temp_a1 * b8[2]) / var_a3; - temp_v0 = ac[2] + r; - b4[2] = temp_v0; - temp_v1 = b4[0]; - if (temp_v1 < M2C_FIELD(((void *)arg0), s16 *, 4)) { - return 0; - } - if (M2C_FIELD(((void *)arg0), s16 *, 6) < temp_v1) { - return 0; - } - if (temp_v0 < M2C_FIELD(((void *)arg0), s16 *, 0xC)) { - return 0; - } - if (M2C_FIELD(((void *)arg0), s16 *, 0xE) < temp_v0) { - return 0; - } - if (arg1 & 0x8000) { - p = (*(u16 **)&D_8017F19C); - b4[0] = (s16) p[0]; - b4[2] = (s16) p[2]; - } - D_801152AC = 0; - (*(s16 *)D_801152A8) = 0; - if (arg1 & 1) { - b4b = D_8017F1A0; - D_801152AA = 0xFFF; - __asm__ __volatile__(""); - var_v0_3 = pos + 2; - } else { - b4b = D_8017F1A0; - D_801152AA = -0xFFF; - __asm__ __volatile__(""); - var_v0_3 = pos - 2; - } - b4b[1] = var_v0_3; - __asm__ __volatile__("" :: "r"(pos)); - (*(s16 *)D_80126720) = (s16) ((s32) (M2C_FIELD(((void *)arg0), s16 *, 4) + M2C_FIELD(((void *)arg0), s16 *, 6)) >> 1); - D_80126722 = (s16) ((s32) (M2C_FIELD(((void *)arg0), s16 *, 8) + M2C_FIELD(((void *)arg0), s16 *, 0xA)) >> 1); - D_80126724 = (s16) ((s32) (M2C_FIELD(((void *)arg0), s16 *, 0xC) + M2C_FIELD(((void *)arg0), s16 *, 0xE)) >> 1); - return 1; -} - - -// @class: schedule -// @stuck: none — MATCH (76 ins, relocation-masked). Key lever: the D_80126720/22/24 tail is a -// global-short RMW `+=`. Writing it via a cast `*(u16*)&SYM = *(u16*)&SYM + x` makes gcc CSE -// the address into a base reg (base-reuse) for ALL three — but the target only base-reuses -// D_80126720 (a SCHEDULER artifact: its addr-lui fills the load-delay slot after the pb4[4] -// load, and since $v0 is live it lands in $a0, reused for load+store). D_80126722/24 use the -// plain inline 2-lui form. Fix = DIRECT scalar RMW `SYM = SYM + x` (no &/cast) → inline %hi/%lo; -// the scheduler alone forces base-reuse on #1. Also: `s16 D_80126724 = D_80126724 + int` emits -// LHU (gcc-2.7.2 drops the sign-extend because the sum is truncated to 16b on the sh) — so the -// canonical s16 decl is byte-safe here (no u16 retype needed, keeps the sign-sensitive callers). - - -extern s16 *D_8017F1A0; /* holds a pointer value (*(u16**)&D_8017F1A0) */ - -s32 func_80136A94(s32 a0, s32 a1, s32 a2, s32 a3) { - extern void ApplyMatrixSV(void *m, void *v0, void *v1); - extern void ApplyRotMatrix(void *v0, void *v1); - extern u16 D_80126722; - extern s16 D_80126724; - extern s16 D_801152AA; - extern s16 D_801152AC; - - s32 out[4]; - u16 *pb4; - - if (a0) { - ApplyMatrixSV((void *)a3, *(void **)&D_8017F1A0, *(void **)&D_8017F1A0); - ApplyMatrixSV((void *)a3, (void *)D_80126720, (void *)D_80126720); - ApplyRotMatrix((void *)D_801152A8, (void *)out); - *(s16 *)D_801152A8 = out[0]; - D_801152AA = out[1]; - D_801152AC = out[2]; - } - - pb4 = *(u16 **)&D_8017F1A0; - *(s16 *)(a2) = pb4[0] + *(s32 *)(a1 + 0x48); - *(s16 *)(a2 + 2) = pb4[1] + *(s32 *)(a1 + 0x4C); - *(s16 *)(a2 + 4) = pb4[2] + *(s32 *)(a1 + 0x50); - - *(u16 *)D_80126720 = *(u16 *)D_80126720 + *(s32 *)(a1 + 0x48); - D_80126722 = D_80126722 + *(s32 *)(a1 + 0x4C); - D_80126724 = D_80126724 + *(s32 *)(a1 + 0x50); -} - - - -DEFINE_func_80136BC4() /* dedup: shared engine-core @0x80136BC4 (src/shared) */ - -DEFINE_func_80136C1C() /* dedup: shared engine-core @0x80136C1C (src/shared) */ - -DEFINE_func_80136C3C() /* dedup: shared engine-core @0x80136C3C (src/shared) */ - -DEFINE_func_80136C44() /* dedup: shared engine-core @0x80136C44 (src/shared) */ - -DEFINE_func_80136C4C() /* dedup: shared engine-core @0x80136C4C (src/shared) */ - - -extern unsigned short D_800B99F0; -extern void (*D_8017F1B4[])(void); - -void func_80136C54(void) -{ - D_8017F1B4[D_800B99F0](); -} - - -// @class: struct -// @stuck: none — MATCH (28 ins). 10-byte 1-aligned struct copy (S10_80136C90{char s[10]}) from global D_801A3488 into a stack buffer, then func_8001534C(0,&buf,0x78,0x10,0,0). gcc emits the block move as 2 unaligned words (lwl/lwr+swl/swr) + 2 bytes (lb/sb). - -typedef struct { char s[10]; } S10_80136C90; - -s32 func_80136C90() -{ - extern void func_8001534C(int, void *, int, int, int, int); - extern S10_80136C90 D_801A3488; - - S10_80136C90 buf = D_801A3488; - func_8001534C(0, &buf, 0x78, 0x10, 0, 0); -} - - - -DEFINE_func_80136D00() /* dedup: shared engine-core @0x80136D00 (src/shared) */ - -DEFINE_func_80136D08() /* dedup: shared engine-core @0x80136D08 (src/shared) */ - -DEFINE_func_80136DFC() /* dedup: shared engine-core @0x80136DFC (src/shared) */ - -DEFINE_func_80136EC4() /* dedup: shared engine-core @0x80136EC4 (src/shared) */ - -DEFINE_func_80136ECC() /* dedup: shared engine-core @0x80136ECC (src/shared) */ - -INCLUDE_ASM("asm/ov_SC01_000/nonmatchings/ov_SC01_000_jr_8012ACE0", func_80136F3C); - -DEFINE_func_80137030() /* dedup: shared engine-core @0x80137030 (src/shared) */ - -INCLUDE_ASM("asm/ov_SC01_000/nonmatchings/ov_SC01_000_jr_8012ACE0", func_80137178); - -DEFINE_func_801372B0() /* dedup: shared engine-core @0x801372B0 (src/shared) */ - -DEFINE_func_801375EC() /* dedup: shared engine-core @0x801375EC (src/shared) */ - -INCLUDE_ASM("asm/ov_SC01_000/nonmatchings/ov_SC01_000_jr_8012ACE0", func_80137614); - -DEFINE_func_8013767C() /* dedup: shared engine-core @0x8013767C (src/shared) */ - -DEFINE_func_801376C8() /* dedup: shared engine-core @0x801376C8 (src/shared) */ - -INCLUDE_ASM("asm/ov_SC01_000/nonmatchings/ov_SC01_000_jr_8012ACE0", func_801376E8); - -DEFINE_func_801377B4() /* dedup: shared engine-core @0x801377B4 (src/shared) */ - -DEFINE_func_80137840() /* dedup: shared engine-core @0x80137840 (src/shared) */ - -INCLUDE_ASM("asm/ov_SC01_000/nonmatchings/ov_SC01_000_jr_8012ACE0", func_801378F0); - -DEFINE_func_801379D8() /* dedup: shared engine-core @0x801379D8 (src/shared) */ - -DEFINE_func_801379EC() /* dedup: shared engine-core @0x801379EC (src/shared) */ - - -// @class: regalloc-order (walker-family, §52/§52a) — PIN-FREE -// Role-swap ($s0<->$s2 between loop1 and loops2/3) is driven by DENSITY (K2), not pins: -// - loop1 pointer has an extra ref (p != D_80127524 compare) -> wins $s0; index -> $s2 -// - loop2/3 index has >= pointer refs -> wins $s0; pointer -> $s2 -// Separate per-loop pointer/index vars => separate pseudos => can take different regs. - - -extern void func_80138BE0(s32 a0); -extern void func_80137BD8(s32 a0); -extern void func_8013A380(void); - -void func_801379FC(void) { - - extern s32 D_80127524; - extern s32 D_80127548[]; - extern s32 D_801269F0; - extern s16 D_801269F4; - extern s32 D_801269F8; - s32 i; - - (*(s32 *)D_80127548) = 0x24; - if ((D_80127524 != 0) && (*(s32 *)D_80127524 != 0)) { - s32 p; - s32 idx; - func_80138BE0(D_80127524); - i = 0; - p = (s32)&D_801269F0; - idx = 0; - do { - if ((p != D_80127524) && (*(s32 *)((s32)&D_801269F0 + idx) != 0)) { - func_80138BE0(p); - } - p = p + 0x4c; - i = i + 1; - idx = idx + 0x4c; - } while (i < 3); - } else { - s32 p; - s32 idx; - i = 0; - p = (s32)&D_801269F0; - idx = 0; - do { - if (*(s32 *)((s32)&D_801269F0 + idx) != 0) { - func_80138BE0(p); - } - p = p + 0x4c; - i = i + 1; - idx = idx + 0x4c; - } while (i < 3); - } - - { - s32 p; - s32 idx; - s32 flags; - i = 0; - p = (s32)&D_801269F0; - idx = 0; - do { - if (*(s16 *)((s32)&D_801269F4 + idx) != 0) { - if (*(s32 *)((s32)&D_801269F0 + idx) != 0) { - flags = *(s32 *)((s32)&D_801269F8 + idx); - if ((flags & 0x1000) != 0) { - if ((flags & 0x2000) == 0) { - func_80137BD8(p); - } - } - } - } - p = p + 0x4c; - i = i + 1; - idx = idx + 0x4c; - } while (i < 3); - } - - func_8013A380(); -} - - - -// @class: remat -// @stuck: target CSEs &D_801269F0 once for load+call arg; force via local pointer -extern s32 D_80127548[]; -extern int D_8017F208; -extern int D_801269F0; -extern void func_80138BE0(int p); - -void func_80137B80(void) { - int *p = &D_801269F0; - (*(int *)&D_80127548) = 0x24; - if (*p != 0) { - ((void (*)(int *))func_80138BE0)(p); - } - D_8017F208 += 1; -} - - -DEFINE_func_80137BD8() /* dedup: shared engine-core @0x80137BD8 (src/shared) */ - - -// @class: plumbing -// @stuck: none — MATCH (51 ins). Three globals stored/loaded around 3 calls; &D_801269F0 held in $s1, arg1 in $s0 across calls; return reloads global D_800A5E60. - -extern unsigned char D_80126A0E; -extern short D_80126A0A; -extern s16 D_801269F4; -extern int D_800A5E60; -extern int D_8017F208; -extern int D_801269F0; - -extern void func_801392FC(); -extern void func_80137DD4(s32 a0, u8 *a1, u8 *a2); -extern void func_80139680(s32 a0, u8 *a1); - -int func_80137D08(int arg0, int arg1, short arg2) -{ - unsigned char buf[3]; - - D_800A5E60 = arg0; - D_80126A0A = arg2; - ((void (*)(void *, int, int))func_801392FC)(&D_801269F0, D_80126A0E, arg1); - if ((*(short *)&D_801269F4) == 7) { - buf[0] = 0x39; - buf[1] = 0xFF; - buf[2] = 0x71; - ((void (*)(void *, void *, int))func_80137DD4)(&D_801269F0, buf, arg1); - } else if ((*(short *)&D_801269F4) == 3) { - if (D_8017F208 & 4) { - ((void (*)(void *, int))func_80139680)(&D_801269F0, arg1); - } - } - return D_800A5E60; -} - - -DEFINE_func_80137DD4() /* dedup: shared engine-core @0x80137DD4 (src/shared) */ - -DEFINE_func_80137FD8() /* dedup: shared engine-core @0x80137FD8 (src/shared) */ diff --git a/src/ov_SC01_000/ov_SC01_000_jr_80135A4C.c b/src/ov_SC01_000/ov_SC01_000_jr_80135A4C.c new file mode 100644 index 000000000..d394dd0d6 --- /dev/null +++ b/src/ov_SC01_000/ov_SC01_000_jr_80135A4C.c @@ -0,0 +1,1215 @@ +#include "common.h" +#include "../shared/engine_core.h" + +/* ==== Phase-26 §8b carried decl layer (jr_isolate_all.py) =================== + * The file-scope decl environment from earlier code regions of this object — + * file-local types, col-0 decls, DEFINE_func macro externs, and each earlier + * definition's implied prototype (types first, then decls in original order). + * Decls emit no code => byte-neutral. See cookbook §8c. */ +typedef struct { int a; short cmd; short b; } Elem_8012ACE0_8012ACE0; /* 8-byte element, cmd @ +4 */ +typedef struct { char pad[0x90]; Elem_8012ACE0_8012ACE0 *list; } Owner_8012ACE0_8012ACE0; /* list ptr @ +0x90 */ +struct S8012C658 { + u16 unk0; + u16 unk2; + u16 unk4; + s16 unk6; + s16 unk8; + s16 unkA; + s16 unkC; + s16 unkE; + s32 unk10; +}; +struct S8012D664_8012D664 { short a, b, c; }; +typedef struct Entry_8012DDA4 { + u16 active; + unsigned char pad[0x10C - 2]; +} Entry_8012DDA4; +typedef struct { s32 m[3][3]; s32 t[3]; } MATRIX; +typedef struct { s32 vx, vy, vz; } VECTOR; +typedef struct { s16 h[8]; } Buf; +typedef struct { char _b[8]; } M8_801312D0; /* size 8, alignment 1 -> unaligned copy */ +typedef struct { u16 f0, f2, f4; s16 f6; } Box_80133784; +typedef struct { s16 x, y, z; } Vec3s; +typedef struct { + u16 f0; /* 0x0 */ + u16 f2; /* 0x2 */ + u16 f4; /* 0x4 */ + s16 f6; /* 0x6 */ +} Foo_80134510_80134510; +typedef struct { + /* 0x00 */ u16 f0; + /* 0x02 */ s16 f2; + /* 0x04 */ s16 f4; + /* 0x06 */ s16 f6; + /* 0x08 */ s16 f8; + /* 0x0A */ s16 fa; + /* 0x0C */ s16 fc; + /* 0x0E */ s16 fe; + /* 0x10 */ s16 f10; + /* 0x12 */ s16 f12; + /* 0x14 */ s16 f14; +} S0_801347A0; +typedef struct { + /* 0x0 */ s16 f0; + /* 0x2 */ s16 f2; + /* 0x4 */ s16 f4; + /* 0x6 */ s16 f6; +} Elem_801347A0; +typedef struct { + /* 0x0 */ u16 f0; + /* 0x2 */ u16 f2; + /* 0x4 */ u16 f4; + /* 0x6 */ u16 f6; +} SVec_801347A0; +extern void func_80128288(void); +extern void func_80128158(void); +extern void func_801285E4(void); +extern void func_80128178(void); +extern void func_80128678(void); +extern void func_80128198(void); +extern void func_80128714(void); +extern void func_801281B8(void); +extern void func_8013E67C(void); +extern void func_801281D8(void); +extern void func_8013E558(void); +extern void func_801281F8(void); +extern s32 D_801A3234; +extern s32 func_80128218(void); +extern void func_80128A28(void); +extern void func_80128228(void); +extern void func_80128AF4(void); +extern void func_80128248(void); +extern void func_801282EC(void); +extern void func_80128268(void); +extern u16 D_800B99F6; +extern void (*D_8017EEA0[])(void); +extern void func_80011B7C(int); +extern void func_801282CC(void); +extern void func_8001C0C8(void); +extern void func_80015310(void); +extern void func_80129258(void); +extern void func_801378F0(void); +extern void func_80010E14(void); +extern s16 currentLocationId; +extern s32 func_80029504(void); +extern s32 func_800CF854(s32); +extern s32 func_80128998(void); +extern s32 func_801289F0(void); +extern s32 func_801288E8(s32); +extern s32 func_80128940(s32); +extern s32 func_80029178(s32); +extern s32 func_801288B0(void); +extern void func_80011C10(void); +extern void func_8012832C(void); +extern void func_80129220(void); +extern void func_80011E24(void); +extern void func_80128C14(void); +extern void func_8002AEF8(void); +extern void func_800CFBBC(void); +extern void SsUtReverbOff(void); +extern void func_8013C98C(void); +extern void func_80129C40(s32 a0); +extern void func_800D0630(void); +extern void func_80145CEC(void); +extern void func_80144B9C(void); +extern u8 D_800B9A17; +extern u8 D_800B9A10; +extern void func_80128420(void); +extern s32 func_800D0588(void); +extern void func_801284B8(void); +extern void func_80175308(void); +extern void func_8016E8F0(void); +extern void func_80175494(void); +extern u8 D_800B9A64; +extern void func_801284F0(void); +extern void func_80146074(void); +extern void func_8012853C(void); +extern void func_80178608(void); +extern void func_8002D4C8(s32 a0, s32 a1); +extern s32 func_80011A3C(void); +extern short currentLocationId; +extern short D_800B99F2; +extern void func_80128564(void); +extern u8 D_800B9A11; +extern void func_801285D4(void); +extern s32 func_800D18DC(void); +extern void func_8014607C(void); +extern void func_801287B8(void); +extern s32 D_801A43DC; +extern void func_80029444(void); +extern void func_800D1754(void); +extern s32 D_80126B58; +extern s32 D_801A5878; +extern u16 D_800B99DA; +extern void func_80129CF8(void); +extern void func_8017849C(void); +extern void func_8014FDF4(struct S8014FDF4 *a0); +extern s32 func_801505FC(s32 a0); +extern void func_801508B4(void *a0); +extern void func_80165E90(void); +extern void func_801627E8(void); +extern void func_80162B1C(void); +extern void func_80165CA0(void); +extern void func_80129010(void); +extern void func_8013CA14(void); +extern void func_800190AC(void); +extern void func_8012956C(void); +extern void func_8016E95C(void); +extern void func_801754A8(void); +extern void func_8013BC7C(void); +extern void func_8013BCDC(void); +extern void func_801379FC(void); +extern void func_8001212C(void); +extern void func_8001ABBC(s32 a0, s32 a1, void *a2, s32 a3, s32 sp10); +extern u8 D_800AEFD0; +extern int D_800C7C60; +extern int *D_800C7C64; +extern int D_800A2E20; +extern int D_800AF558; +extern int D_801A3234; +extern int func_801288E8(int arg0); +extern u8 D_800AF560; +extern s32 func_80128940(s32 _arg0); +extern int D_800AECB0; +extern u8 D_800AECB8; +extern void func_8001ABBC(s32 a0, s32 a1, void *a2, s32 a3, s32 a4); +extern s16 D_800B9A00; +extern M2C_UNK (*D_8017EBDC)(); +extern s16 (*D_8017EBE0)(); +extern M2C_UNK (*D_8017EBE8)(); +extern s32 (*D_8017EBEC)(); +extern s32 D_801A43D8; +extern void func_80010AE0(s32 a0); +extern void func_80018450(s32 a0, s32 a1); +extern void func_800183E0(s32 a0); +extern void func_80128D60(s32 a0, s32 *a1, s32 *a2); +extern s32 func_80128DB4(s32 a0, s32 *a1); +extern void func_80128EA8(s32 a0, s32 a1, s32 a2); +extern M2C_UNK D_801A3238; +extern void func_80128FAC(u16 *arg0); +extern s16 D_8011DB2C; +extern s16 D_8011DB30; +extern s32 D_80126AEC; +extern u8 *func_8012913C(s32 a0); +extern u8 * func_801290DC(s32 a0, u8 *a1); +extern void func_8001D074(s32 a, s32 b); +extern u8 *func_801291C0(void); +extern s32 func_8001CC3C(s32 a0, s32 a1, s32 a2, s32 a3); +extern u8 * func_8012913C(s32 arg0); +extern void func_80016714(void *a0, s32 a1); +extern u8 * func_801291C0(void); +extern void func_80129248(s16 a0); +extern void func_801292C8(u8 *a0); +extern void func_8012927C(void); +extern void func_8012931C(struct vec *a0); +extern void func_80129350(s32 a0, s32 a1); +extern void func_80129374(s32 a0, s32 a1); +extern s16 D_800B9AAC[]; +extern s16 D_800B9AAE[]; +extern s16 D_800B9AB0[]; +extern s16 D_800B9AB2[]; +extern s16 D_800B9AB4[]; +extern s16 D_800B9AB6[]; +extern s16 D_800B9AB8[]; +extern s16 D_800B9ABA[]; +extern void func_80129398(void); +extern s16 D_80114EE0; +extern void func_80129428(void); +extern void func_8012943C(void); +extern s32 D_8005128C; +extern u8 D_800B9A78; +extern void func_801298F4(void *arg0); +extern void func_801299C8(s32 a, s32 b, s32 c); +extern void func_8012944C(void); +extern unsigned short D_800B99F0; +extern void func_8012A328(void); +extern void func_80053308(s32); +extern s32 func_80012F74(s32, s32, s32, s32); /* canonical s32 (engine_core); (s16)-cast the return for the sll/sra */ +extern void GsSetRefView2L(void *); +extern s8 D_801150D6; /* canonical (engine_core macro): s8 — access via *(u8*)& for lbu */ +extern u8 D_80127504; +extern s32 D_80126E60[]; +extern s32 D_80126F04[]; +extern u8 D_80126948[]; /* canonical (sibling): u8[] — cast (s32*) at use */ +extern s32 D_80126FA8[]; +extern struct BigCopy D_80126DB8;/* canonical (engine_core macro): struct BigCopy — (s32*)& at use */ +extern u8 D_800AF630[]; /* canonical (sibling): u8[] — cast (s32*) at use */ +extern s32 D_800AE688[]; +extern s32 D_801151D4; /* canonical (10 siblings): scalar s32 — store (s32)ptr */ +extern void func_8012A018(s32 a, s32 b); +extern void func_80129FF4(void); +extern u16 D_80126B5E; +extern u16 D_80126B62; +extern u16 D_80126B66; +extern s16 D_80126940; +extern s16 D_80126942; +extern s16 D_80126944; +extern void func_8012A048(void *a0, s32 a1, u8 a2); +extern void *memcpy(void *, const void *, unsigned int); +extern void func_8012A094(s32 a0); +extern void func_8012A100(s8 a0); +extern void func_8012A0E0(void); +extern s8 D_801150D6; +extern s32 D_80120204; +extern s32 D_80120200; +extern s32 D_8012020C; +extern s32 D_80120208; +extern s16 D_80120218; +extern s16 D_80120210; +extern s16 D_8012021A; +extern s16 D_80120212; +extern s16 D_8012021C; +extern s16 D_80120214; +extern s16 D_80120226; +extern s16 D_80120220; +extern s16 D_80120228; +extern s16 D_80120222; +extern s16 D_8012022A; +extern s16 D_80120224; +extern s32 D_80120294; +extern s16 D_80120298; +extern s16 D_8012029A; +extern void func_8012A110(void); +extern s8 D_801152C0; +extern void func_8012A2F4(void); +extern s16 D_80127080; +extern s16 D_801152C2; +extern void func_8012A304(s32 a0, s32 a1); +extern s32 D_801151D4; +extern struct BigCopy D_80126DB8; +extern struct BigCopy D_80114EE8; +extern void func_8012A4BC(void); +extern void func_8012A598(void *a0); +extern void func_8012A568(void (*a0)(void)); +extern void func_8012A62C(s32); +extern void func_8012A5F8(void (*a0)(void), s32 a1); +extern void func_8012A62C(s32 a0); +extern void func_8012A7D4(void *a0, void *a1); +extern s32 func_8012A6D0(void *a0, void *a1); +extern s16 func_8012A68C(void); +extern s16 func_8012A79C(s16 *a0, s16 *a1); +extern s16 func_8012A758(void); +extern s32 ratan2(s32 a0, s32 a1); +extern void func_8012A7D4(void *arg0, void *arg1); +extern void func_8012AAAC(void); +extern void func_8012A828(s32 a0, void * a1); +extern int func_8012ACE0(void *a0); +extern void func_8012A860(void *a0, int a1); +extern void func_8012A8B0(u8 *a0, s32 a1); +extern void func_8012A8E8(void); +extern u8 D_801202A0[]; +extern u16 D_801270C0; +extern void func_8012A988(u8 *a0); +extern void func_8012A908(void); +extern s32 func_8012ACE0(void *a0); +extern M2C_UNK D_8017EF34; +extern void func_8012ACA0(void *arg0); +extern s32 func_8012ACE0(void *o); +extern void func_8012AD44(s32 *a0, s16 a1); +extern s32 func_8012AD50(void * arg0); +extern void func_8012AD64(void *arg0, s32 arg1); +extern void func_8012AD6C(void *a0); +extern void func_8012AD80(s32 a0); +extern void func_8012ADE4(u8 *a0); +extern s32 *D_80126B78; +extern s32 *D_80126B90; +extern s32 func_80135888(s32 a0, s32 a1, s32 a2, s32 a3); +extern s32 func_80013478(s32 a0, s32 a1); +extern s32 func_8012AE00(s32 a0); +extern s32 func_8012AF0C(s32 a0, s32 a1); +extern s32 func_80134510(s32 arg); +extern s32 func_8012B030(u8 *a0); +extern int func_80047948(int a0); +extern int func_8004787C(int a0); +extern void func_8012B0B4(unsigned int *param_1, int param_2, int param_3); +extern void func_800484EC(s32 a0, s32 a1, s32 a2); +extern void func_8012B14C(s32 a0, s32 a1); +extern void func_8012B178(s32 a0, s32 a1); +extern void func_8012B1B4(s32 a0, s32 a1); +extern void func_8012B200(u8 *a0); +extern void func_8012B21C(void *a0); +extern void func_8012B23C(s32 a0); +extern void func_8012B260(u8 *a0); +extern void func_80049CAC(s32 a0, s32 a1); +extern void func_8012B2CC(s32 a0); +extern void RotMatrixYXZ(void *m, void *p); +extern void func_8012B370(int a0); +extern void func_8004978C(s16 *a0, void *a1); +extern void func_8012B414(int a0); +extern s32 func_8012B608(s32 a0, s32 a1, s32 a2); +extern s32 func_8012B6D4(s16 *a0, s16 *a1); +extern s32 func_8012B70C(s16 *a0, s16 *a1); +extern s32 ratan2(s32 x, s32 y); +extern s32 func_8012B744(void *a0, void *a1); +extern s16 D_80126CB8; +extern s16 D_80126CB4; +extern s32 func_8012B864(s32 a0); +extern s32 func_8012B8A4(s16 *a0); +extern s32 func_8012B8E4(s32 arg0, s32 arg1); +extern s32 func_8012BA10(s32 arg0, s32 arg1); +extern s32 func_8012BB3C(s32 arg0, s32 arg1, u32 arg2, s32 arg3); +extern void Square0(s32 *a0, s32 *a1); +extern s32 func_8012BC60(struct Vec *a0, struct Vec *a1); +extern s16 D_80126CBA; +extern s32 func_8012BCCC(s32 a0); +extern void func_80013350(s32 a0, void *a1); +extern u8 D_80126B5C; +extern void func_8012BD14(s32 a0); +extern s32 func_8012BDBC(s32 a0, s32 a1); +extern s32 func_8012BD3C(s32 a0, s32 a1, s32 a2); +extern void func_8012BE98(s32 a0, u16 *a1); +extern void func_8012BE54(s32 a0); +extern s32 func_800132BC(s32 a0, s32 a1); +extern void func_8012BE98(s32 arg0, u16 * arg1); +extern s32 func_8012BEE8(s32 a0); +extern s32 func_8012BF10(s32 a0, s32 a1); +extern void func_8012BF4C(void *arg0, s32 arg1); +extern void func_8012BF54(void *a0); +extern void func_8012BF68(void *a0); +extern s16 D_80126CB0; +extern s32 func_8012BF7C(s16 *a0); +extern s16 D_80126CAC; +extern short D_80126CAE; +extern int func_8012BFA8(short *a0); +extern s32 D_801274D4; +extern s32 D_801274E0; +extern s32 func_8012C044(s32 a0); +extern void func_8012C218(void *a0); +extern void func_8012C098(void *param_1); +extern s32 func_8012C0EC(s32 a0); +extern void func_8012C194(void); +extern void func_8001CFDC(s32 a, s32 b); +extern void func_8012C1B8(void); +extern u8 D_800B3DF0[]; +extern s32 func_8012C1DC(s32 a0); +extern u8 D_80126720[]; +extern u16 * func_8012C284(u16 *a0); +extern u8 D_80120194[]; +extern s32 func_8012C2D0(void); +extern s32 func_8012C31C(void); +extern void func_8012CAE4(void *a0); +extern void func_8001C214(s32 a0, s32 a1); +extern u8 D_80078EAE; +extern s32 func_8012C354(s32 a0, s32 a1); +extern void func_8001C810(s32 a0, s32 a1); +extern s32 func_8012C438(s32 a0, s32 a1); +extern s32 func_8012C890(s32 a0, s32 a1, s32 a2); +extern s32 func_8012C51C(void *a0, s32 a1); +extern s32 func_8012C588(s32 a0, s32 a1); +extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2); +extern void func_8012C724(s32 a0, s32 a1); +extern s32 func_8012C750(s32 a0); +extern s32 func_8012C820(u8 *a0); +extern s32 D_80182418; +extern s16 D_801270C4; +extern u16 D_801274E4[]; +extern s32 D_8011DB08; +extern s32 func_8012CB64(s32 arg0, s32 arg1, s32 arg2, s32 arg3, s32 arg4); +extern void func_8012CC88(s32 a, s32 b, s32 c); +extern u8 D_800D3918[]; +extern void func_8012CBA4(s32 a0); +extern void func_8012CBCC(s32 a0); +extern void func_8012CBF4(s32 a0); +extern void func_8012CC1C(s32 arg0, s32 arg1); +extern void func_8012CC40(s32 arg0, s32 arg1); +extern void func_8012CC88(s32 a0, s32 a1, s32 a2); +extern void func_8012CC64(s32 a0, s32 a1); +extern s32 func_80133784(s32 a0, void *a1, s32 a2); +extern s32 func_8012CE2C(s32 a0); +extern s32 func_8012CEB0(s32 a0, s32 a1, s32 a2); +extern void func_8012CFA8(s32 arg0); +extern void func_8012F214(s32 a0, s32 a1, s32 a2); +extern void func_8012D3B4(s32 arg0, s32 arg1, s32 arg2); +extern void func_8012D098(u16 *param_1, u32 param_2); +extern void func_8012D098(); +extern void func_8012D38C(int a0); +extern void func_8012D3AC(void); +extern s32 AddPrim(s32, void *); +extern s32 RotTransPers(s32, s32, s32 *, s32 *); +extern void SetLineF2(void *); +extern void *func_80010A08(s32); +extern void func_8004914C(void *); +extern void func_800491AC(void *); +extern s32 D_800A651C; +extern u8 D_800AF648; +extern s16 D_800B9A02; +extern void func_8012D4B4(s32 arg0, s32 arg1, s32 arg2, s32 arg3); +extern void func_8012D5DC(void); +extern s16 D_80126B98; +extern s32 func_8012DEB8(s32 a0, s32 a1, s32 a2); +extern s32 func_8012D5E4(s32 a0, s32 a1, s32 a2, s32 a3); +extern int func_8012D664(); +extern void func_8012D624(s32 a0); +extern int func_8012D664(int arg0, int arg1, int arg2); +extern s32 func_8012D714(s32 param_1, u32 param_2); +extern void func_8012F568(s32 a0, s32 a1, s32 a2, s32 a3, s32 a4, s32 a5); +extern void func_8014C978(void); +extern M2C_UNK D_8017EF4C; +extern M2C_UNK D_8017EF54; +extern s32 func_8012DB84(void); +extern s32 func_8012DE2C(s32 a0); +extern s32 func_8012DDA4(void); +extern s32 func_8012DBD0(s32 arg0, s32 arg1, s32 arg2, s32 arg3); +extern s32 func_8012DDA4(); +extern s32 func_8012DF34(s32 a0, s32 a1, s32 a2); +extern s16 D_80126B9A; +extern u8 D_801152A8[]; +extern void func_8012DFBC(void); +extern void func_8012DFCC(void); +extern void func_8012E014(void); +extern void func_8012E138(void); +extern void func_8012DFD4(u8 *a0); +extern s32 func_8012E27C(void); +extern void func_8012E284(void); +extern s32 GetTPage(s32, s32, s32, s32); +extern s32 func_8005A600(s32, s32, s32, s32, s32); +extern void func_8012E28C(s32 arg0, s32 arg1); +extern void func_8004914C(void *a0); +extern void func_800491AC(void *a0); +extern void func_8012E32C(void); +extern s32 func_8012E470(s32 a0); +extern void func_8012E4C8(s32 a0); +extern s32 func_8012E504(s32 a0, s32 a1); +extern s32 func_8012E544(s32 a0); +extern s32 func_8012E57C(s32 a0, s32 a1); +extern s32 RotTransPers(s32 a0, s32 a1, s32 *a2, s32 *a3); +extern void func_8012E5CC(s32 param_1, u16 param_2, u16 param_3); +extern void func_8012E688(s32 param_1, u16 param_2, u16 param_3); +extern s32 func_8012E778(int param_1, int param_2); +extern void func_8012E88C(u8 *a0); +extern void func_8012E8A8(u8 *a0); +extern void func_8012E8C4(u8 *a0); +extern void func_8012E8E0(s32 a0, s32 a1); +extern void func_8016AA50(int, int); +extern void func_8016B428(int); +extern void func_80019064(void *); +extern int D_8017EF5C; +extern void func_8012E9C0(int param_1); +extern void func_8012EA90(s32 param_1, s32 param_2, s32 *param_3); +extern void func_8012EC04(s32 param_1, s32 param_2, s32 *param_3); +extern s32 func_8002A4FC(s32 a0); +extern s32 func_8012EECC(s32 a0); +extern void func_8012EFB8(s32 a0); +extern void func_8012EF34(s32 a0, s32 a1); +extern void func_8012EF70(s32 a0, s32 a1); +extern void ApplyTransposeMatrixLV(void *a0, void *a1, void *a2); +extern void func_8012F038(int param_1, short *param_2, short *param_3); +extern void func_8012F0BC(s32 *a0, s32 *a1, s32 *a2); +extern void RotTransSV(s32 a0, s32 a1, void *a2); +extern void func_8012F14C(s32 a0, s32 a1, s32 a2); +extern void func_8012F1A4(s32 *a0, s32 a1, s32 *a2); +extern void func_8012F2E8(s32 a0, s32 a1, s32 a2); +extern s16 D_80126CB6; +extern void func_8012F374(s32 a0, s32 a1); +extern void *memcpy(void *, const void *, u32); +extern u8 D_80126C38; +extern u8 D_80126C40; +extern u16 D_80126B94; +extern u16 D_80126B96; +extern void func_8012F568(s32 param_1, s32 param_2, s32 param_3, s32 param_4, s32 param_5, s32 param_6); +extern void func_80131B14(); +extern void func_80131E00(struct S80131E00 *a0, s32 a1); +extern s32 func_80131A34(s32, s32); +extern void func_80131CA8(int a0, int a1); +extern void func_8012F5F4(s32 arg0); +extern void func_80131C78(s32 a0); +extern void func_8012F68C(s32 arg0); +extern void func_8012F75C(s32 a0); +extern s32 func_8012BEE8(s32); +extern void func_8012F7B4(s32 a0); +extern void func_80131170(); +extern void func_80131CA8(); +extern unsigned char D_8017EF78[]; +extern void func_8012F828(int param_1); +extern void func_80131340(s32 a0); +extern void func_8012F87C(s32 a0); +extern void func_80131170(s32 a0, s32 a1, s32 a2); +extern u8 D_8017EF84[]; +extern void func_8012F8C8(u8* arg0); +extern void func_8012F91C(s32 a0); +extern s32 func_80131A34(s32 a0, s32 a1); +extern void func_80131CA8(s32 a0, s32 a1); +extern void func_8012F968(s32 param_1); +extern void func_801319E0(s32 a0); +extern s32 func_80143B6C(s32 a0, s32 a1); +extern void func_8012FB54(s32 a0); +extern void func_8012FC30(s32 a0); +extern void func_8012FCA4(int a0); +extern s32 func_8012FCC4(s32 param_1); +extern void func_8012FDA8(int param_1); +extern void func_8012FE70(s32 a0); +extern void func_8012FF00(s32 a0); +extern void func_8012FF4C(s32 a0); +extern void func_80130D48(s32 a0); +extern void func_8012FF98(u8 *a0); +extern s32 func_80131AC8(void *a0); +extern void func_8013001C(void *a0); +extern void func_80130088(void *a0); +extern s32 func_8012BCCC(s32); +extern void func_801300F4(s32 a0); +extern void func_801301E8(u8 *a0); +extern void func_80130278(s32 arg0); +extern void func_80130314(s32 a0); +extern void func_80130360(s32 a0); +extern void func_8012E364(void); +extern void func_801303A0(s32 a0); +extern void func_801303EC(void *a0); +extern void func_80143CD4(s32 a0); +extern void func_800CB0E8(s32 a0); +extern void func_80130438(s32 a0); +extern void func_801319E0(int); +extern int func_80131D68(int, int); +extern int func_8012BEE8(int); +extern void func_80131CA8(int, int); +extern void func_80130514(int param_1); +extern void func_801305CC(u8 *a0); +extern void func_8012CBF4(s32); +extern s32 func_80131D68(s32 a0, s32 a1); +extern void func_80130650(s32 a0); +extern s32 func_80146A6C(s32 a0, void *a1, s32 a2, s32 a3, s32 a4, s32 a5, s32 a6); +extern void func_80130740(void *a0, u16 *a1); +extern s32 func_801312D0(s32 a0, void *a1); +extern void func_801307B0(s32 a0); +extern void func_80130858(s32 a0); +extern void func_80130898(u8 *a0); +extern void func_801308DC(s32 a0); +extern void func_80166244(); +extern void func_80130974(int param_1); +extern void func_80130A18(u8 *a0); +extern void func_80130AC4(s32 a0); +extern int func_80131A34(int a0, int a1); +extern void func_80130AF0(int param_1); +extern void (*D_8017EF98[])(void); +extern void func_80130D0C(void *a0); +extern s32 rand(void); +extern u8 D_80078E78[]; +extern u16 D_80078EB2; +extern u16 D_80078EB4; +extern s16 D_8017EFE8[]; +extern s16 D_8017F018[]; +extern s16 D_8017F078[]; +extern s16 D_8017F080[]; +extern s16 D_8017F0A0[]; +extern void func_80130D48(s32 arg0); +extern void func_80131170(s32 p, s32 b, s32 c); +extern s32 func_801312D0(s32 param_1, void *param_2); +extern void func_80131E00(); +extern s32 D_801A4400; +extern s32 D_801A4404; +extern void func_8002A04C(s32 a0); +extern void func_801319E0(s32 arg0); +extern s32 func_80131CF4(s32 a0); +extern int func_80131D68(int a0, int a1); +extern void (*D_8017F0D8[])(struct S80131E00 *a0); +extern void func_80131E38(u8 *a0); +extern void func_80131E7C(s32 a0); +extern void func_80131EE4(void); +extern void (*D_8017F130[])(void); +extern void func_80131EEC(void *a0); +extern void (*D_8017F178[])(void); +extern void func_80131F28(void *a0); +extern void (*D_8017F180[])(void); +extern void func_80131F64(void *a0); +extern void (*D_8017F188[])(void); +extern void func_80131FA0(void *a0); +extern void (*D_8017F190[])(void); +extern void func_80131FDC(void *a0); +extern void func_801320D0(void); +extern void func_8001C214(int, int); +extern int D_8017F138; +extern void func_801320D8(int param_1); +extern s32 func_80132144(s32 param_1); +extern int D_8017F158; +extern void func_801321B0(int param_1); +extern int D_8017F168; +extern void func_8013221C(int param_1); +extern void func_8005C324(int dst, int src, int n) __asm__("memcpy"); /* Phase-24: 0x8005C324 is named memcpy for overlays (whale needs it); keep the non-builtin C name here (else built-in codegen), emit via asm-label */ +extern void func_801325B8(int a0, int a1, int a2, int a3, int a4); +extern void func_80132288(int *param_1, int *param_2, int param_3); +extern void func_801325B8(s32 a0, s32 a1, s32 a2, s32 a3, s32 a4); +extern void func_8013240C(s32 a0); +extern void memcpy(); +extern void gteMIMefunc(); +extern void func_801325B8(int dst, int src, int m0, int mm, int arg5); +extern void func_8013277C(void); +extern void func_80020F34(s32 a0, s32 a1); +extern void func_80054514(s32 a0, s32 a1); +extern void func_80132784(s32 a0, s32 a1, u32 a2); +extern s32 VectorNormalSS(void *a0, void *a1); +extern void func_80132DC4(s32 a0, s32 a1, s32 a2); +extern s32 func_80132E6C(s16 *a0); +extern void func_80132EC4(void *a0, s16 a1); +extern s32 func_80132EF4(s32 a0, s32 a1); +extern void func_801330E0(s16 *a0, s16 *a1, s32 a2); +extern void func_80133060(u8 *a0, s32 *a1, s32 a2); +extern void func_8013339C(short *param_1, short *param_2); +extern s32 func_8013361C(s16 *a0, s16 *a1, s16 *a2, s16 *a3); +extern s32 D_801A4448; +extern s32 D_801A444C[]; +extern int D_801A4450; +extern void func_80136BC4(s32 a0); +extern void func_801336E8(void *a0, int a1, int a2); +extern void func_80136BC4(s32); +extern void func_8013373C(s16 arg0); +extern s32 func_80133784(s32 arg0, void *arg1, s32 arg2); +extern s32 func_80133CD4(); +extern s32 func_80134310(Vec3s *a0, Vec3s *a1, s32 a2); +extern s32 func_8013435C(s16 *a0, s16 *a1, s32 a2, s16 *a3); +extern s32 func_801343C4(s32 angle, s32 p1, s32 p2); +extern s32 func_80134510(s32 param); +extern s32 func_801345F8(s32 arg); +extern s32 func_801347A0(s32 arg0, s32 arg1, s32 arg2, s32 arg3); +extern s32 func_80134A28(s32 a0, s32 a1, s32 a2); +extern int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4); +extern s32 func_80134C20(s32 arg0, s32 arg1, s32 arg2, s32 arg3); +extern s32 func_80134FB8(s32 a0, s32 a1, s32 a2); +extern s32 func_80135004(s32 arg0, s32 p1, s32 p2); +extern u8 D_8017F19C; +extern u8 D_8017F198; +extern s16 *D_8017F1A0; +extern u8 D_8017F1A4; +extern int D_801A4448; +extern u16 D_801A4458; +extern int func_80134A74(int, s16, s16, int); +extern int func_80135168(u16 arg0, u16 *p1, u16 *p2); +extern s16 func_80135480(void *param_1, s32 param_2, s16 *param_3, s16 *param_4); +/* ==== end §8b carried decl layer ==== */ + + +s32 func_80135A4C(s32 a0, s32 a1, s32 *a2, s32 a3) { + typedef struct { u16 f0, f2, f4; s16 f6; } Box; + typedef struct { s8 c[8]; } Blk8; + typedef struct { s16 x, y, z; } V3; + extern s16 func_80135480(void *param_1, s32 param_2, s16 *param_3, s16 *param_4); + extern s32 func_80135EB0(s32 *p, s32 v); + extern s32 func_80136A94(s32 a0, s32 a1, s32 a2, s32 a3); + extern s32 func_80133AB0(s16, s16, s16, s32); + extern u8 D_8017F198; + extern u8 D_8017F19C; + extern s16 *D_8017F1A0; + extern s16 D_801A4454; + extern u16 D_801A4458; + extern s32 D_801A445C; + extern s32 D_801A447C; + extern u8 D_801152A8[]; + extern u8 D_801152B0; + + s32 *p; + register s32 s7 __asm__("$23"); + s32 flag; + s32 acc; + s16 i; + s32 eq; + s32 ret; + s32 frame_pad[8]; + (void)&frame_pad; + + switch (((s32 (*)(void))func_80135480)()) { + case 0: + return 0; + case 1: + s7 = a0 + 0x34; + p = (s32 *)((a1 & 0xFFFFFFF) | 0x80000000); + flag = 0; + break; + case 2: + s7 = a0 + 0x34; + p = (s32 *)((a1 & 0xFFFFFFF) | 0x80000000); + flag = 1; + break; + case 3: + s7 = a0 + 0x34; + p = (s32 *)&D_801A447C; + flag = 0; + break; + case 4: + s7 = (s32)&D_801A445C; + p = (s32 *)&D_801A447C; + flag = 1; + break; + } + + acc = 0; + if (a1 < 0) { + if (func_80135EB0(p, -0x8000) == 0) { + p = (s32 *)*p; + if (p == 0) return 0; + loop: + if (func_80135EB0(p, -0x8000) == 0) goto next; + } + docall: + func_80136A94(flag, a0, a3, s7); + return 1; + next: + p = (s32 *)*p; + __asm__ __volatile__(""); + if (p != 0) goto loop; + return 0; + } + + i = 0; + *(s16 *)((*(u8 **)&D_8017F198) + 6) = -0x7FFF; + *(s16 *)((*(u8 **)&D_8017F19C) + 6) = 0x7FFF; + D_801A4458 = 0; + D_801A4454 = 0; + { + s32 t = 0; + if (((V3 *)a2)->x == ((V3 *)a3)->x && ((V3 *)a2)->y == ((V3 *)a3)->y) { + s32 zt = (((V3 *)a2)->z == ((V3 *)a3)->z); + __asm__("addu %0,%1,$zero" : "=r"(t) : "r"(zt)); + } + eq = t; + } + + while (1) { + ret = func_80133AB0(0, (s16)(*(Box **)&D_8017F198)->f0, (s16)(*(Box **)&D_8017F198)->f4, (s32)p); + if (ret == 0) goto out; + acc |= ret; + if (eq != 0) goto out; + { + s16 old = i; + i = i + 1; + if (old >= 5) return 0; + } + } + +out: + if ((s16)acc != 0 || D_801A4454 != 0) { + if ((*(Box **)&D_8017F198)->f6 >= -0xBCB) { + *(Blk8 *)D_801152A8 = *(Blk8 *)&D_801152B0; + } + (*(Box **)&D_8017F1A0)->f0 = (*(Box **)&D_8017F19C)->f0; + (*(Box **)&D_8017F1A0)->f2 = (*(Box **)&D_8017F19C)->f2; + (*(Box **)&D_8017F1A0)->f4 = (*(Box **)&D_8017F19C)->f4; + goto docall; + } + return 0; +} + +INCLUDE_ASM("asm/ov_SC01_000/nonmatchings/ov_SC01_000_jr_80135A4C", func_80135D20); + +INCLUDE_ASM("asm/ov_SC01_000/nonmatchings/ov_SC01_000_jr_80135A4C", func_80135EB0); + + +s32 func_80136334(void *arg0, s32 arg1, s32 arg2) { + extern u8 D_801152A8[]; + extern s16 D_801152AA; + extern s16 D_801152AC; + extern s16 D_80126722; + extern s16 D_80126724; + register s32 a1v __asm__("$11"); + register s32 a2v __asm__("$12"); + register s32 n __asm__("$5"); + register s16 *b4 __asm__("$7"); + s32 d; + s32 dx; + s32 denom; + s32 result; + s32 frame_pad[2]; + (void)&frame_pad; + __asm__("" : "=r"(a1v) : "0"(arg1)); + a2v = arg2; + + if (!(arg1 & 1)) { + dx = (s16) arg2 - (*(s16 **)&D_8017F198)[2]; + d = dx; + denom = -(*(s16 **)&D_8017F1A4)[2]; + } else { + denom = (*(s16 **)&D_8017F1A4)[2]; + d = (*(s16 **)&D_8017F198)[2] - (s16) arg2; + dx = -d; + } + n = -d; + { + register s16 *b8 __asm__("$6") = *(s16 **)&D_8017F1A4; + u16 *ac = *(u16 **)&D_8017F198; + b4 = D_8017F1A0; + b4[0] = ac[0] + n * b8[0] / denom; + b4[1] = ac[1] + n * b8[1] / denom; + b4[2] = ac[2] + dx; + } + + if (b4[0] < M2C_FIELD(arg0, s16 *, 4)) return 0; + if (M2C_FIELD(arg0, s16 *, 6) < b4[0]) return 0; + if (b4[1] < M2C_FIELD(arg0, s16 *, 8)) return 0; + if (M2C_FIELD(arg0, s16 *, 0xA) < b4[1]) return 0; + if (a1v & 0x8000) { + u16 *b0 = *(u16 **)&D_8017F19C; + b4[0] = b0[0]; + b4[1] = b0[1]; + } + D_801152AA = 0; + (*(s16 *)D_801152A8) = 0; + if (a1v & 1) { + D_8017F1A0[2] = a2v + 2; + __asm__ __volatile__(""); + D_801152AC = 0xFFF; + } else { + D_801152AC = -0xFFF; + D_8017F1A0[2] = a2v - 2; + } + __asm__ __volatile__("" :: "r"(a1v), "r"(a2v)); + (*(s16 *)D_80126720) = (M2C_FIELD(arg0, s16 *, 4) + M2C_FIELD(arg0, s16 *, 6)) >> 1; + D_80126722 = (M2C_FIELD(arg0, s16 *, 8) + M2C_FIELD(arg0, s16 *, 0xA)) >> 1; + result = 1; + D_80126724 = (M2C_FIELD(arg0, s16 *, 0xC) + M2C_FIELD(arg0, s16 *, 0xE)) >> 1; + return result; +} + + +INCLUDE_ASM("asm/ov_SC01_000/nonmatchings/ov_SC01_000_jr_80135A4C", func_801365B8); + + +// @class: pointer-type — pointer-vs-array reconcile for func_80136824 (ov_SC01_077_a) +// D_8017F198/B0/B8 are file-scope `extern u8`, D_8017F1A0 is `extern s32 []`; each HOLDS a +// pointer value that the target loads via lw then derefs. Read as pointer via *(T**)&sym. +// D_8017F1A0 must be a SCALAR pointer (not s32[]) — as an array it decays and gcc CSEs the +// base address into a held reg (lui;addiu;lw 0(reg)) across the 3 reloads; as a scalar +// pointer it folds %lo (lui;lw %lo). Retype all 3 file-TU occurrences (byte-neutral: the +// siblings read it once via *(u16**)&sym == direct lw either way). + +s32 func_80136824(s32 arg0, s32 arg1, s32 arg2) { + extern u8 D_801152A8[]; + extern s16 D_801152AA; + extern s16 D_801152AC; + extern s16 D_80126722; + extern s16 D_80126724; + + register u16 *ac __asm__("$4"); + register s16 *b8 __asm__("$6"); + register s16 *b4 __asm__("$9"); + register s32 r __asm__("$3"); + register s32 pos __asm__("$12"); + register s32 a1v __asm__("$5"); + s16 temp_v0; + s16 temp_v1; + s32 var_a3; + s16 var_v0_3; + s32 temp_a1; + s32 var_t0; + s32 var_v1; + s16 *b4b; + u16 *p; + + __asm__ ("" : "=r"(a1v) : "0"(arg1)); + pos = arg2; + if (!(a1v & 1)) { + var_t0 = (s16) arg2 - (*(s16 **)&D_8017F198)[1]; + var_v1 = var_t0; + var_a3 = -(*(s16 **)&D_8017F1A4)[1]; + } else { + var_a3 = (*(s16 **)&D_8017F1A4)[1]; + var_v1 = (*(s16 **)&D_8017F198)[1] - (s16) arg2; + var_t0 = -var_v1; + } + b8 = (*(s16 **)&D_8017F1A4); + ac = (*(u16 **)&D_8017F198); + b4 = D_8017F1A0; + temp_a1 = -var_v1; + r = (temp_a1 * b8[0]) / var_a3; + b4[0] = ac[0] + r; + b4[1] = ac[1] + var_t0; + r = (temp_a1 * b8[2]) / var_a3; + temp_v0 = ac[2] + r; + b4[2] = temp_v0; + temp_v1 = b4[0]; + if (temp_v1 < M2C_FIELD(((void *)arg0), s16 *, 4)) { + return 0; + } + if (M2C_FIELD(((void *)arg0), s16 *, 6) < temp_v1) { + return 0; + } + if (temp_v0 < M2C_FIELD(((void *)arg0), s16 *, 0xC)) { + return 0; + } + if (M2C_FIELD(((void *)arg0), s16 *, 0xE) < temp_v0) { + return 0; + } + if (arg1 & 0x8000) { + p = (*(u16 **)&D_8017F19C); + b4[0] = (s16) p[0]; + b4[2] = (s16) p[2]; + } + D_801152AC = 0; + (*(s16 *)D_801152A8) = 0; + if (arg1 & 1) { + b4b = D_8017F1A0; + D_801152AA = 0xFFF; + __asm__ __volatile__(""); + var_v0_3 = pos + 2; + } else { + b4b = D_8017F1A0; + D_801152AA = -0xFFF; + __asm__ __volatile__(""); + var_v0_3 = pos - 2; + } + b4b[1] = var_v0_3; + __asm__ __volatile__("" :: "r"(pos)); + (*(s16 *)D_80126720) = (s16) ((s32) (M2C_FIELD(((void *)arg0), s16 *, 4) + M2C_FIELD(((void *)arg0), s16 *, 6)) >> 1); + D_80126722 = (s16) ((s32) (M2C_FIELD(((void *)arg0), s16 *, 8) + M2C_FIELD(((void *)arg0), s16 *, 0xA)) >> 1); + D_80126724 = (s16) ((s32) (M2C_FIELD(((void *)arg0), s16 *, 0xC) + M2C_FIELD(((void *)arg0), s16 *, 0xE)) >> 1); + return 1; +} + + +// @class: schedule +// @stuck: none — MATCH (76 ins, relocation-masked). Key lever: the D_80126720/22/24 tail is a +// global-short RMW `+=`. Writing it via a cast `*(u16*)&SYM = *(u16*)&SYM + x` makes gcc CSE +// the address into a base reg (base-reuse) for ALL three — but the target only base-reuses +// D_80126720 (a SCHEDULER artifact: its addr-lui fills the load-delay slot after the pb4[4] +// load, and since $v0 is live it lands in $a0, reused for load+store). D_80126722/24 use the +// plain inline 2-lui form. Fix = DIRECT scalar RMW `SYM = SYM + x` (no &/cast) → inline %hi/%lo; +// the scheduler alone forces base-reuse on #1. Also: `s16 D_80126724 = D_80126724 + int` emits +// LHU (gcc-2.7.2 drops the sign-extend because the sum is truncated to 16b on the sh) — so the +// canonical s16 decl is byte-safe here (no u16 retype needed, keeps the sign-sensitive callers). + + +extern s16 *D_8017F1A0; /* holds a pointer value (*(u16**)&D_8017F1A0) */ + +s32 func_80136A94(s32 a0, s32 a1, s32 a2, s32 a3) { + extern void ApplyMatrixSV(void *m, void *v0, void *v1); + extern void ApplyRotMatrix(void *v0, void *v1); + extern u16 D_80126722; + extern s16 D_80126724; + extern s16 D_801152AA; + extern s16 D_801152AC; + + s32 out[4]; + u16 *pb4; + + if (a0) { + ApplyMatrixSV((void *)a3, *(void **)&D_8017F1A0, *(void **)&D_8017F1A0); + ApplyMatrixSV((void *)a3, (void *)D_80126720, (void *)D_80126720); + ApplyRotMatrix((void *)D_801152A8, (void *)out); + *(s16 *)D_801152A8 = out[0]; + D_801152AA = out[1]; + D_801152AC = out[2]; + } + + pb4 = *(u16 **)&D_8017F1A0; + *(s16 *)(a2) = pb4[0] + *(s32 *)(a1 + 0x48); + *(s16 *)(a2 + 2) = pb4[1] + *(s32 *)(a1 + 0x4C); + *(s16 *)(a2 + 4) = pb4[2] + *(s32 *)(a1 + 0x50); + + *(u16 *)D_80126720 = *(u16 *)D_80126720 + *(s32 *)(a1 + 0x48); + D_80126722 = D_80126722 + *(s32 *)(a1 + 0x4C); + D_80126724 = D_80126724 + *(s32 *)(a1 + 0x50); +} + + + +DEFINE_func_80136BC4() /* dedup: shared engine-core @0x80136BC4 (src/shared) */ + +DEFINE_func_80136C1C() /* dedup: shared engine-core @0x80136C1C (src/shared) */ + +DEFINE_func_80136C3C() /* dedup: shared engine-core @0x80136C3C (src/shared) */ + +DEFINE_func_80136C44() /* dedup: shared engine-core @0x80136C44 (src/shared) */ + +DEFINE_func_80136C4C() /* dedup: shared engine-core @0x80136C4C (src/shared) */ + + +extern unsigned short D_800B99F0; +extern void (*D_8017F1B4[])(void); + +void func_80136C54(void) +{ + D_8017F1B4[D_800B99F0](); +} + + +// @class: struct +// @stuck: none — MATCH (28 ins). 10-byte 1-aligned struct copy (S10_80136C90{char s[10]}) from global D_801A3488 into a stack buffer, then func_8001534C(0,&buf,0x78,0x10,0,0). gcc emits the block move as 2 unaligned words (lwl/lwr+swl/swr) + 2 bytes (lb/sb). + +typedef struct { char s[10]; } S10_80136C90; + +s32 func_80136C90() +{ + extern void func_8001534C(int, void *, int, int, int, int); + extern S10_80136C90 D_801A3488; + + S10_80136C90 buf = D_801A3488; + func_8001534C(0, &buf, 0x78, 0x10, 0, 0); +} + + + +DEFINE_func_80136D00() /* dedup: shared engine-core @0x80136D00 (src/shared) */ + +DEFINE_func_80136D08() /* dedup: shared engine-core @0x80136D08 (src/shared) */ + +DEFINE_func_80136DFC() /* dedup: shared engine-core @0x80136DFC (src/shared) */ + +DEFINE_func_80136EC4() /* dedup: shared engine-core @0x80136EC4 (src/shared) */ + +DEFINE_func_80136ECC() /* dedup: shared engine-core @0x80136ECC (src/shared) */ + +INCLUDE_ASM("asm/ov_SC01_000/nonmatchings/ov_SC01_000_jr_80135A4C", func_80136F3C); + +DEFINE_func_80137030() /* dedup: shared engine-core @0x80137030 (src/shared) */ + +INCLUDE_ASM("asm/ov_SC01_000/nonmatchings/ov_SC01_000_jr_80135A4C", func_80137178); + +DEFINE_func_801372B0() /* dedup: shared engine-core @0x801372B0 (src/shared) */ + +DEFINE_func_801375EC() /* dedup: shared engine-core @0x801375EC (src/shared) */ + +INCLUDE_ASM("asm/ov_SC01_000/nonmatchings/ov_SC01_000_jr_80135A4C", func_80137614); + +DEFINE_func_8013767C() /* dedup: shared engine-core @0x8013767C (src/shared) */ + +DEFINE_func_801376C8() /* dedup: shared engine-core @0x801376C8 (src/shared) */ + +INCLUDE_ASM("asm/ov_SC01_000/nonmatchings/ov_SC01_000_jr_80135A4C", func_801376E8); + +DEFINE_func_801377B4() /* dedup: shared engine-core @0x801377B4 (src/shared) */ + +DEFINE_func_80137840() /* dedup: shared engine-core @0x80137840 (src/shared) */ + +INCLUDE_ASM("asm/ov_SC01_000/nonmatchings/ov_SC01_000_jr_80135A4C", func_801378F0); + +DEFINE_func_801379D8() /* dedup: shared engine-core @0x801379D8 (src/shared) */ + +DEFINE_func_801379EC() /* dedup: shared engine-core @0x801379EC (src/shared) */ + + +// @class: regalloc-order (walker-family, §52/§52a) — PIN-FREE +// Role-swap ($s0<->$s2 between loop1 and loops2/3) is driven by DENSITY (K2), not pins: +// - loop1 pointer has an extra ref (p != D_80127524 compare) -> wins $s0; index -> $s2 +// - loop2/3 index has >= pointer refs -> wins $s0; pointer -> $s2 +// Separate per-loop pointer/index vars => separate pseudos => can take different regs. + + +extern void func_80138BE0(s32 a0); +extern void func_80137BD8(s32 a0); +extern void func_8013A380(void); + +void func_801379FC(void) { + + extern s32 D_80127524; + extern s32 D_80127548[]; + extern s32 D_801269F0; + extern s16 D_801269F4; + extern s32 D_801269F8; + s32 i; + + (*(s32 *)D_80127548) = 0x24; + if ((D_80127524 != 0) && (*(s32 *)D_80127524 != 0)) { + s32 p; + s32 idx; + func_80138BE0(D_80127524); + i = 0; + p = (s32)&D_801269F0; + idx = 0; + do { + if ((p != D_80127524) && (*(s32 *)((s32)&D_801269F0 + idx) != 0)) { + func_80138BE0(p); + } + p = p + 0x4c; + i = i + 1; + idx = idx + 0x4c; + } while (i < 3); + } else { + s32 p; + s32 idx; + i = 0; + p = (s32)&D_801269F0; + idx = 0; + do { + if (*(s32 *)((s32)&D_801269F0 + idx) != 0) { + func_80138BE0(p); + } + p = p + 0x4c; + i = i + 1; + idx = idx + 0x4c; + } while (i < 3); + } + + { + s32 p; + s32 idx; + s32 flags; + i = 0; + p = (s32)&D_801269F0; + idx = 0; + do { + if (*(s16 *)((s32)&D_801269F4 + idx) != 0) { + if (*(s32 *)((s32)&D_801269F0 + idx) != 0) { + flags = *(s32 *)((s32)&D_801269F8 + idx); + if ((flags & 0x1000) != 0) { + if ((flags & 0x2000) == 0) { + func_80137BD8(p); + } + } + } + } + p = p + 0x4c; + i = i + 1; + idx = idx + 0x4c; + } while (i < 3); + } + + func_8013A380(); +} + + + +// @class: remat +// @stuck: target CSEs &D_801269F0 once for load+call arg; force via local pointer +extern s32 D_80127548[]; +extern int D_8017F208; +extern int D_801269F0; +extern void func_80138BE0(int p); + +void func_80137B80(void) { + int *p = &D_801269F0; + (*(int *)&D_80127548) = 0x24; + if (*p != 0) { + ((void (*)(int *))func_80138BE0)(p); + } + D_8017F208 += 1; +} + + +DEFINE_func_80137BD8() /* dedup: shared engine-core @0x80137BD8 (src/shared) */ + + +// @class: plumbing +// @stuck: none — MATCH (51 ins). Three globals stored/loaded around 3 calls; &D_801269F0 held in $s1, arg1 in $s0 across calls; return reloads global D_800A5E60. + +extern unsigned char D_80126A0E; +extern short D_80126A0A; +extern s16 D_801269F4; +extern int D_800A5E60; +extern int D_8017F208; +extern int D_801269F0; + +extern void func_801392FC(); +extern void func_80137DD4(s32 a0, u8 *a1, u8 *a2); +extern void func_80139680(s32 a0, u8 *a1); + +int func_80137D08(int arg0, int arg1, short arg2) +{ + unsigned char buf[3]; + + D_800A5E60 = arg0; + D_80126A0A = arg2; + ((void (*)(void *, int, int))func_801392FC)(&D_801269F0, D_80126A0E, arg1); + if ((*(short *)&D_801269F4) == 7) { + buf[0] = 0x39; + buf[1] = 0xFF; + buf[2] = 0x71; + ((void (*)(void *, void *, int))func_80137DD4)(&D_801269F0, buf, arg1); + } else if ((*(short *)&D_801269F4) == 3) { + if (D_8017F208 & 4) { + ((void (*)(void *, int))func_80139680)(&D_801269F0, arg1); + } + } + return D_800A5E60; +} + + +DEFINE_func_80137DD4() /* dedup: shared engine-core @0x80137DD4 (src/shared) */ + +DEFINE_func_80137FD8() /* dedup: shared engine-core @0x80137FD8 (src/shared) */ +