diff --git a/.run/P36/agents/ORDER.tsv b/.run/P36/agents/ORDER.tsv index 067ad8447..8acd74a50 100644 --- a/.run/P36/agents/ORDER.tsv +++ b/.run/P36/agents/ORDER.tsv @@ -1,6 +1,16 @@ rank fn alias copies best needed kinds regs tu -101 func_801818A4 ov_SC02_031 2 1 1 pin $16 src/ov_SC02_031/ov_SC02_031_jr_8017AE2C.c -30 func_8018486C ov_SC03_091 3 21 3 pin $19,$22,$23 src/ov_SC03_091/ov_SC03_091_jr_8018326C.c -3 func_80181408 ov_SC06_010 4 26 2 barrier,pin $4 src/ov_SC06_010/ov_SC06_010_jr_8017A4AC.c -4 func_80183CC4 ov_SC03_094 3 27 4 keepalive,pin $16,$2,$3 src/ov_SC03_094/ov_SC03_094_jr_8017BEBC.c -25 func_8017DAB8 ov_SC02_026 3 30 2 pin $16,$2 src/ov_SC02_026/ov_SC02_026_jr_8017C180.c +60 func_8018B9D4 ov_SC06_018 2 1 1 pin $0 src/ov_SC06_018/ov_SC06_018_jr_80187AEC.c +23 func_801A1E94 md_SC07_004 1 1 1 pin $4 src/md_SC07_004/md_SC07_004.c +101 func_801A5C44 md_SC07_004 1 1 1 pin $4 src/md_SC07_004/md_SC07_004.c +232 func_801AB818 md_SC07_004 1 1 1 barrier src/md_SC07_004/md_SC07_004.c +20 func_80037144 main 1 2 1 barrier src/800_c.c +41 func_800384A8 main 1 2 1 pin $4 src/800_c.c +4 func_80187DD0 ov_SC06_018 1 2 1 pin $2 src/ov_SC06_018/ov_SC06_018_jr_80187AEC.c +47 func_8018AD74 ov_SC06_018 1 2 1 launder src/ov_SC06_018/ov_SC06_018_jr_80187AEC.c +127 func_80035210 main 1 4 1 pin $3 src/800_b_2.c +18 func_80036FB0 main 1 4 1 keepalive src/800_c.c +141 func_80183B9C ov_SC02_017 1 4 1 barrier src/ov_SC02_017/ov_SC02_017_jr_8017DF34.c +200 func_80186770 ov_SC02_017 1 4 1 pin $6 src/ov_SC02_017/ov_SC02_017_jr_8017DF34.c +85 func_80030F80 main 1 5 1 barrier src/800_b_2.c +163 func_80184754 ov_SC02_017 1 8 1 launder src/ov_SC02_017/ov_SC02_017_jr_8017DF34.c +118 func_800348A8 main 1 9 1 keepalive src/800_b_2.c diff --git a/.run/P36/agents/main__func_80030F80/body_free.c b/.run/P36/agents/main__func_80030F80/body_free.c new file mode 100644 index 000000000..fd16b570e --- /dev/null +++ b/.run/P36/agents/main__func_80030F80/body_free.c @@ -0,0 +1,178 @@ +void func_80030F80(void) +{ + u8 *p; + u8 *sv; + u8 *w; + const u16 *q; + const u16 *r; + s32 *tbl; + s32 vb; + s32 mask; + VoiceF80 *e; + u32 m; + u32 v; + s16 n; + s16 t; + u8 flag; + u8 st; + s32 dsp; + u16 idx; + u16 h; + s32 i; + + sv = D_800A4988 + 0x576; + p = D_800A4988; + i = 0; + tbl = D_80073140; + w = D_800A4988 + 0x572; + r = D_8007319E; + q = D_800731A0; + for (; i < 8; i++, p += 0x54) { + flag = 0; + p[0x4E] &= 0x7F; + if (p[0x4E] != 0) { + *(s32 *)(p + 0x4) += 1; + if (*(s32 *)p != 0) { + *(s32 *)p -= 1; + if (*(s32 *)p == 0) { + func_8002EFF8(1, tbl[*(u16 *)(p + 0xA)]); + func_800316F8((s32)p); + } + } else { + if (p[0x4E] >= 2) { + p[0x4E] -= 1; + } else { + idx = *(u16 *)(p + 0xA); + dsp = sv[idx]; + switch (dsp) { + case 3: + mask = tbl[*(u16 *)(p + 0xA)]; + p[0x50] = 0; + func_8002EFF8(0, mask); + /* fallthrough */ + case 0: + p[0x4E] = 0; + if (*(s32 *)(p + 0x40) != 0) { + (*(void (**)(s32, s32))(p + 0x40))(p[0x51], *(s32 *)(p + 0x44)); + } + *(s32 *)(p + 0x40) = 0; + break; + case 2: + if (p[0x50] != 0) { + func_8003D3B4(idx, 1); + p[0x50] = 0; + } + break; + } + } + if (p[0x4C] != 0) { + h = *(u16 *)(p + 0x4A) - 0x220; + *(u16 *)(p + 0x4A) = h; + flag = 1; + if ((s16)h <= 0) { + *(u16 *)(p + 0x4A) = 0; + p[0x4C] = 0; + p[0x50] = 1; + D_800A4C6D[i * 0x48] = 1; + func_8002EFF8(0, tbl[*(u16 *)(p + 0xA)]); + } + } + if (p[0x4F] != 0) { + flag = 1; + p[0x4F] = 0; + } + if (p[0x37] & 2) { + if (*(s32 *)(p + 0x1C) >= 0) { + *(s32 *)(p + 0x18) += *(u16 *)(p + 0x32); + if (*(s32 *)(p + 0x18) >= *(s32 *)(p + 0x1C)) { + *(s32 *)(p + 0x18) = *(s32 *)(p + 0x1C); + p[0x37] &= 0xFD; + } + } else { + *(s32 *)(p + 0x18) -= *(u16 *)(p + 0x32); + if (*(s32 *)(p + 0x18) <= *(s32 *)(p + 0x1C)) { + *(s32 *)(p + 0x18) = *(s32 *)(p + 0x1C); + p[0x37] &= 0xFD; + } + } + flag = 1; + } + if ((D_800A4F19 != 0 && p[0x53] != 0) || flag) { + n = p[0x35]; + if (n != 0) { + t = n + (*(s32 *)(p + 0x18) >> 8); + n = t; + if (p[0x53] != 0) { + t = p[0x53] + t; + if (t < 0x42) { + n = 1; + } else { + t -= 0x40; + n = t; + if (t >= 0x80) { + n = 0x7F; + } + } + } + } + if (flag || n != p[0x52]) { + m = D_8006AA30[p[0x34]]; + m = (m * *(s16 *)w) >> 7; + m = (m * *(s16 *)(p + 0x48)) >> 7; + if (flag) { + m = (m * ((s16)*(u16 *)(p + 0x4A) >> 7)) >> 8; + } + vb = (s32)w - 0x2D2; + e = (VoiceF80 *)(i * 0x48 + vb); + e->unk00 = tbl[*(u16 *)(p + 0xA)]; + if (n != 0) { + if (w[0x1F] != 0) { + v = (m * q[0x7F - n]) >> 14; + e->unk08 = v; + v = (m * r[n]) >> 14; + e->unk0A = v; + } else { + v = (m * D_8007321E) >> 14; + e->unk0A = v; + e->unk08 = v; + } + } else { + v = m; + e->unk0A = v; + e->unk08 = v; + } + e->unk40 = *(u16 *)(p + 0xA); + if (e->unk44 != 0) { + e->unk04 |= 3; + } else { + e->unk44 = 1; + e->unk04 = 3; + } + p[0x52] = n; + } + } + func_800314DC((struct Obj *)p); + h = *(u16 *)(p + 0x12); + if (h != 0) { + h -= 1; + *(u16 *)(p + 0x12) = h; + if (h == 0) { + func_80031988((struct Ent30D80 *)p); + mask = tbl[*(u16 *)(p + 0xA)]; + p[0x50] = 0; + func_8002EFF8(0, mask); + if (*(s32 *)(p + 0x40) != 0) { + (*(void (**)(s32, s32))(p + 0x40))(p[0x51], *(s32 *)(p + 0x44)); + } + *(s32 *)(p + 0x40) = 0; + } + } + } + } else { + st = sv[*(u16 *)(p + 0xA)]; + if (st == 0 || st == 3) { + D_800C7D2C &= ~tbl[*(u16 *)(p + 0xA)]; + } + } + } +} diff --git a/.run/P36/agents/main__func_80030F80/body_tree.c b/.run/P36/agents/main__func_80030F80/body_tree.c new file mode 100644 index 000000000..203933c9c --- /dev/null +++ b/.run/P36/agents/main__func_80030F80/body_tree.c @@ -0,0 +1,179 @@ +void func_80030F80(void) +{ + u8 *p; + u8 *sv; + u8 *w; + const u16 *q; + const u16 *r; + s32 *tbl; + s32 vb; + s32 mask; + VoiceF80 *e; + u32 m; + u32 v; + s16 n; + s16 t; + u8 flag; + u8 st; + s32 dsp; + u16 idx; + u16 h; + s32 i; + + sv = D_800A4988 + 0x576; + p = D_800A4988; + i = 0; + tbl = D_80073140; + w = D_800A4988 + 0x572; + r = D_8007319E; + q = D_800731A0; + for (; i < 8; i++, p += 0x54) { + flag = 0; + p[0x4E] &= 0x7F; + if (p[0x4E] != 0) { + *(s32 *)(p + 0x4) += 1; + if (*(s32 *)p != 0) { + *(s32 *)p -= 1; + if (*(s32 *)p == 0) { + func_8002EFF8(1, tbl[*(u16 *)(p + 0xA)]); + func_800316F8((s32)p); + } + } else { + if (p[0x4E] >= 2) { + p[0x4E] -= 1; + } else { + idx = *(u16 *)(p + 0xA); + dsp = sv[idx]; + __asm__("" : : : "memory"); // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus9) + switch (dsp) { + case 3: + mask = tbl[*(u16 *)(p + 0xA)]; + p[0x50] = 0; + func_8002EFF8(0, mask); + /* fallthrough */ + case 0: + p[0x4E] = 0; + if (*(s32 *)(p + 0x40) != 0) { + (*(void (**)(s32, s32))(p + 0x40))(p[0x51], *(s32 *)(p + 0x44)); + } + *(s32 *)(p + 0x40) = 0; + break; + case 2: + if (p[0x50] != 0) { + func_8003D3B4(idx, 1); + p[0x50] = 0; + } + break; + } + } + if (p[0x4C] != 0) { + h = *(u16 *)(p + 0x4A) - 0x220; + *(u16 *)(p + 0x4A) = h; + flag = 1; + if ((s16)h <= 0) { + *(u16 *)(p + 0x4A) = 0; + p[0x4C] = 0; + p[0x50] = 1; + D_800A4C6D[i * 0x48] = 1; + func_8002EFF8(0, tbl[*(u16 *)(p + 0xA)]); + } + } + if (p[0x4F] != 0) { + flag = 1; + p[0x4F] = 0; + } + if (p[0x37] & 2) { + if (*(s32 *)(p + 0x1C) >= 0) { + *(s32 *)(p + 0x18) += *(u16 *)(p + 0x32); + if (*(s32 *)(p + 0x18) >= *(s32 *)(p + 0x1C)) { + *(s32 *)(p + 0x18) = *(s32 *)(p + 0x1C); + p[0x37] &= 0xFD; + } + } else { + *(s32 *)(p + 0x18) -= *(u16 *)(p + 0x32); + if (*(s32 *)(p + 0x18) <= *(s32 *)(p + 0x1C)) { + *(s32 *)(p + 0x18) = *(s32 *)(p + 0x1C); + p[0x37] &= 0xFD; + } + } + flag = 1; + } + if ((D_800A4F19 != 0 && p[0x53] != 0) || flag) { + n = p[0x35]; + if (n != 0) { + t = n + (*(s32 *)(p + 0x18) >> 8); + n = t; + if (p[0x53] != 0) { + t = p[0x53] + t; + if (t < 0x42) { + n = 1; + } else { + t -= 0x40; + n = t; + if (t >= 0x80) { + n = 0x7F; + } + } + } + } + if (flag || n != p[0x52]) { + m = D_8006AA30[p[0x34]]; + m = (m * *(s16 *)w) >> 7; + m = (m * *(s16 *)(p + 0x48)) >> 7; + if (flag) { + m = (m * ((s16)*(u16 *)(p + 0x4A) >> 7)) >> 8; + } + vb = (s32)w - 0x2D2; + e = (VoiceF80 *)(i * 0x48 + vb); + e->unk00 = tbl[*(u16 *)(p + 0xA)]; + if (n != 0) { + if (w[0x1F] != 0) { + v = (m * q[0x7F - n]) >> 14; + e->unk08 = v; + v = (m * r[n]) >> 14; + e->unk0A = v; + } else { + v = (m * D_8007321E) >> 14; + e->unk0A = v; + e->unk08 = v; + } + } else { + v = m; + e->unk0A = v; + e->unk08 = v; + } + e->unk40 = *(u16 *)(p + 0xA); + if (e->unk44 != 0) { + e->unk04 |= 3; + } else { + e->unk44 = 1; + e->unk04 = 3; + } + p[0x52] = n; + } + } + func_800314DC((struct Obj *)p); + h = *(u16 *)(p + 0x12); + if (h != 0) { + h -= 1; + *(u16 *)(p + 0x12) = h; + if (h == 0) { + func_80031988((struct Ent30D80 *)p); + mask = tbl[*(u16 *)(p + 0xA)]; + p[0x50] = 0; + func_8002EFF8(0, mask); + if (*(s32 *)(p + 0x40) != 0) { + (*(void (**)(s32, s32))(p + 0x40))(p[0x51], *(s32 *)(p + 0x44)); + } + *(s32 *)(p + 0x40) = 0; + } + } + } + } else { + st = sv[*(u16 *)(p + 0xA)]; + if (st == 0 || st == 3) { + D_800C7D2C &= ~tbl[*(u16 *)(p + 0xA)]; + } + } + } +} diff --git a/.run/P36/agents/main__func_80030F80/history.txt b/.run/P36/agents/main__func_80030F80/history.txt new file mode 100644 index 000000000..500528343 --- /dev/null +++ b/.run/P36/agents/main__func_80030F80/history.txt @@ -0,0 +1,14 @@ +g6b: verdict NO-MATCH start 19 best 5 compiles 329 path R6 inline mask @3755 +best-scoring single candidates of the last trace (move -> score [residual class]): + R6 inline mask @3755 -> 5 [ORDER] (from 19) + R7 block @3744 -> 5 [ORDER] (from 5) + R6 inline dsp @3752 -> 5 [ORDER] (from 5) + R8 temp tmp0 @3744 -> 5 [ORDER] (from 5) + R5 swap + @3808 -> 5 [ORDER] (from 5) + R7 do-while @3744 -> 5 [ORDER] (from 5) + R8 base tmp0 @3744 -> 5 [ORDER] (from 5) + R5 swap + @3811 -> 5 [ORDER] (from 5) + R9 swap-stmts @3737 -> 5 [ORDER] (from 5) + R7 block @3742 -> 5 [ORDER] (from 5) + R7 do-while @3742 -> 5 [ORDER] (from 5) + R9 swap-stmts @3734 -> 5 [ORDER] (from 5) diff --git a/.run/P36/agents/main__func_80030F80/neighbours.txt b/.run/P36/agents/main__func_80030F80/neighbours.txt new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/.run/P36/agents/main__func_80030F80/neighbours.txt @@ -0,0 +1 @@ + diff --git a/.run/P36/agents/main__func_80030F80/related.txt b/.run/P36/agents/main__func_80030F80/related.txt new file mode 100644 index 000000000..9bdf26e80 --- /dev/null +++ b/.run/P36/agents/main__func_80030F80/related.txt @@ -0,0 +1 @@ +=== lever-free bodies in main sharing a callee or global with func_80030F80 (0 found; top 6 by shared symbols) — read them for the SHAPE === diff --git a/.run/P36/agents/main__func_80030F80/residual.txt b/.run/P36/agents/main__func_80030F80/residual.txt new file mode 100644 index 000000000..fc211f171 --- /dev/null +++ b/.run/P36/agents/main__func_80030F80/residual.txt @@ -0,0 +1,35 @@ +src/800_b_2.c:func_80030F80: score 19 (COUNT; mine 341 ins, target 343) — not yet + replace mine[25:26] target[25:26] + 25 beqz v0,4b84 | beqz v0,4b8c + replace mine[35:36] target[35:36] + 35 bnez v0,4bcc | bnez v0,4bd4 + replace mine[46:47] target[46:47] + 46 j 4bd0 | j 4bd8 + replace mine[53:54] target[53:54] + 53 j 4838 | j 4840 + replace mine[60:61] target[60:61] + 60 beq v1,v0,481c | beq v1,v0,4824 + replace mine[64:65] target[64:65] + 64 beqz v1,47f4 | beqz v1,47fc + replace mine[66:67] target[66:67] + 66 j 4838 | j 4840 + replace mine[69:71] target[69:74] + 69 bne v1,v0,4838 | bne v1,v0,4840 + 70 sll v0,a0,0x2 | move a0,zero + 71 -- | lhu v0,0(s0) + 72 -- | nop + 73 -- | sll v0,v0,0x2 + delete mine[73:74] target[76:76] + 73 move a0,zero | -- + replace mine[84:85] target[86:87] + 84 j 4838 | j 4840 + replace mine[137:138] target[139:140] + 137 j 4908 | j 4910 + replace mine[251:252] target[253:254] + 251 j 4ad8 | j 4ae0 + replace mine[267:268] target[269:270] + 267 j 4b04 | j 4b0c + replace mine[302:303] target[304:305] + 302 j 4bcc | j 4bd4 + replace mine[326:327] target[328:329] + 326 bnez v0,471c | bnez v0,471c diff --git a/.run/P36/agents/main__func_80030F80/sites.txt b/.run/P36/agents/main__func_80030F80/sites.txt new file mode 100644 index 000000000..26e6dd8b7 --- /dev/null +++ b/.run/P36/agents/main__func_80030F80/sites.txt @@ -0,0 +1 @@ +NEEDED barrier memory line 3755 diff --git a/.run/P36/agents/main__func_80030F80/tu.txt b/.run/P36/agents/main__func_80030F80/tu.txt new file mode 100644 index 000000000..d71daccec --- /dev/null +++ b/.run/P36/agents/main__func_80030F80/tu.txt @@ -0,0 +1,2 @@ +src/800_b_2.c +func_80030F80 diff --git a/.run/P36/agents/main__func_800348A8/body.c b/.run/P36/agents/main__func_800348A8/body.c new file mode 100644 index 000000000..d208d63e5 --- /dev/null +++ b/.run/P36/agents/main__func_800348A8/body.c @@ -0,0 +1,26 @@ +s32 func_800348A8(u32 arg0) { + u16 *p; + u16 *q; + s32 i; + u32 lo; + u32 hi; + s32 five; + + p = D_800A46E8; + i = 0; + five = 5; + lo = arg0 & 0xFFFF; + hi = arg0 >> 16; + q = p + 3; + do { + if (p[0] == five && q[-1] == lo) { + if (hi == 0 || q[0] == hi) { + return i + 1; + } + } + i++; + q += 0x2A; + p += 0x2A; + } while (i < 8); + return 0; +} diff --git a/.run/P36/agents/main__func_800348A8/body_free.c b/.run/P36/agents/main__func_800348A8/body_free.c new file mode 100644 index 000000000..d208d63e5 --- /dev/null +++ b/.run/P36/agents/main__func_800348A8/body_free.c @@ -0,0 +1,26 @@ +s32 func_800348A8(u32 arg0) { + u16 *p; + u16 *q; + s32 i; + u32 lo; + u32 hi; + s32 five; + + p = D_800A46E8; + i = 0; + five = 5; + lo = arg0 & 0xFFFF; + hi = arg0 >> 16; + q = p + 3; + do { + if (p[0] == five && q[-1] == lo) { + if (hi == 0 || q[0] == hi) { + return i + 1; + } + } + i++; + q += 0x2A; + p += 0x2A; + } while (i < 8); + return 0; +} diff --git a/.run/P36/agents/main__func_800348A8/body_tree.c b/.run/P36/agents/main__func_800348A8/body_tree.c new file mode 100644 index 000000000..1b4b5e6ea --- /dev/null +++ b/.run/P36/agents/main__func_800348A8/body_tree.c @@ -0,0 +1,27 @@ +s32 func_800348A8(u32 arg0) { + u16 *p; + u16 *q; + s32 i; + u32 lo; + u32 hi; + s32 five; + + p = D_800A46E8; + i = 0; + five = 5; + lo = arg0 & 0xFFFF; + hi = arg0 >> 16; + q = p + 3; + do { + __asm__ ("" :: "r"(i), "r"(i)); // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus9) + if (p[0] == five && q[-1] == lo) { + if (hi == 0 || q[0] == hi) { + return i + 1; + } + } + i++; + q += 0x2A; + p += 0x2A; + } while (i < 8); + return 0; +} diff --git a/.run/P36/agents/main__func_800348A8/history.txt b/.run/P36/agents/main__func_800348A8/history.txt new file mode 100644 index 000000000..7fc3d5ade --- /dev/null +++ b/.run/P36/agents/main__func_800348A8/history.txt @@ -0,0 +1,14 @@ +g6b: verdict NO-MATCH start 9 best 9 compiles 302 path +best-scoring single candidates of the last trace (move -> score [residual class]): + R10 param-copy arg0 @7069 -> 9 [REG] (from 9) + R7 block @7082 -> 9 [REG] (from 9) + R9 swap-stmts @7082 -> 9 [MIXED] (from 9) + R7 do-while @7082 -> 9 [REG] (from 9) + R7 block @7071 -> 9 [REG] (from 9) + R7 do-while @7071 -> 9 [REG] (from 9) + R7 block @7072 -> 9 [REG] (from 9) + R7 block @7075 -> 9 [REG] (from 9) + R7 block @7083 -> 9 [REG] (from 9) + R7 do-while @7083 -> 9 [REG] (from 9) + R7 block @7070 -> 9 [REG] (from 9) + R7 block @7073 -> 9 [REG] (from 9) diff --git a/.run/P36/agents/main__func_800348A8/neighbours.txt b/.run/P36/agents/main__func_800348A8/neighbours.txt new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/.run/P36/agents/main__func_800348A8/neighbours.txt @@ -0,0 +1 @@ + diff --git a/.run/P36/agents/main__func_800348A8/related.txt b/.run/P36/agents/main__func_800348A8/related.txt new file mode 100644 index 000000000..477f3a6ea --- /dev/null +++ b/.run/P36/agents/main__func_800348A8/related.txt @@ -0,0 +1 @@ +=== lever-free bodies in main sharing a callee or global with func_800348A8 (0 found; top 6 by shared symbols) — read them for the SHAPE === diff --git a/.run/P36/agents/main__func_800348A8/residual.txt b/.run/P36/agents/main__func_800348A8/residual.txt new file mode 100644 index 000000000..071896ca9 --- /dev/null +++ b/.run/P36/agents/main__func_800348A8/residual.txt @@ -0,0 +1,16 @@ +src/800_b_2.c:func_800348A8: score 9 (REG-caller; mine 29 ins, target 29) — not yet + register pairs (mine -> target, count): a1->v1 x6, v1->a1 x5 + replace mine[2:3] target[2:3] + 2 move a1,zero | move v1,zero + replace mine[6:7] target[6:7] + 6 addiu v1,a2,6 | addiu a1,a2,6 + replace mine[11:12] target[11:12] + 11 lhu v0,-2(v1) | lhu v0,-2(a1) + replace mine[16:18] target[16:18] + 16 addiu v0,a1,1 | addiu v0,v1,1 + 17 lhu v0,0(v1) | lhu v0,0(a1) + replace mine[20:24] target[20:24] + 20 addiu v0,a1,1 | addiu v0,v1,1 + 21 addiu a1,a1,1 | addiu v1,v1,1 + 22 addiu v1,v1,84 | addiu a1,a1,84 + 23 slti v0,a1,8 | slti v0,v1,8 diff --git a/.run/P36/agents/main__func_800348A8/sites.txt b/.run/P36/agents/main__func_800348A8/sites.txt new file mode 100644 index 000000000..c93822080 --- /dev/null +++ b/.run/P36/agents/main__func_800348A8/sites.txt @@ -0,0 +1 @@ +NEEDED keepalive line 7082 diff --git a/.run/P36/agents/main__func_800348A8/tu.txt b/.run/P36/agents/main__func_800348A8/tu.txt new file mode 100644 index 000000000..b93806fd6 --- /dev/null +++ b/.run/P36/agents/main__func_800348A8/tu.txt @@ -0,0 +1,2 @@ +src/800_b_2.c +func_800348A8 diff --git a/.run/P36/agents/main__func_80035210/body_free.c b/.run/P36/agents/main__func_80035210/body_free.c new file mode 100644 index 000000000..2fa57272b --- /dev/null +++ b/.run/P36/agents/main__func_80035210/body_free.c @@ -0,0 +1,10 @@ +void func_80035210(s32 a0, s32 a1) +{ + s32 v1; + + v1 = D_80076218; + func_8003C498(v1); + SpuWrite(a0, a1); + v1 = D_80076218; + D_80076218 = v1 + a1; +} diff --git a/.run/P36/agents/main__func_80035210/body_tree.c b/.run/P36/agents/main__func_80035210/body_tree.c new file mode 100644 index 000000000..f2980f60c --- /dev/null +++ b/.run/P36/agents/main__func_80035210/body_tree.c @@ -0,0 +1,10 @@ +void func_80035210(s32 a0, s32 a1) +{ + register s32 v1 __asm__("$3"); // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus9) + + v1 = D_80076218; + func_8003C498(v1); + SpuWrite(a0, a1); + v1 = D_80076218; + D_80076218 = v1 + a1; +} diff --git a/.run/P36/agents/main__func_80035210/history.txt b/.run/P36/agents/main__func_80035210/history.txt new file mode 100644 index 000000000..184725fc9 --- /dev/null +++ b/.run/P36/agents/main__func_80035210/history.txt @@ -0,0 +1,14 @@ +g6b: verdict NO-MATCH start 4 best 4 compiles 170 path +best-scoring single candidates of the last trace (move -> score [residual class]): + R6 inline v1 @7522 -> 4 [REG] (from 4) + R10 param-copy a0 @7521 -> 4 [REG] (from 4) + R7 block @7523 -> 4 [REG] (from 4) + R6 inline v1 @7525 -> 4 [REG] (from 4) + R10 param-copy a1 @7521 -> 4 [REG] (from 4) + R7 block @7524 -> 4 [REG] (from 4) + R7 block @7522 -> 4 [REG] (from 4) + R7 block @7525 -> 4 [REG] (from 4) + R7 do-while @7525 -> 4 [REG] (from 4) + R7 block @7526 -> 4 [REG] (from 4) + R6 inline v1 @7524 -> 4 [REG] (from 4) + R10 param-copy a0 @7521 -> 4 [REG] (from 4) diff --git a/.run/P36/agents/main__func_80035210/neighbours.txt b/.run/P36/agents/main__func_80035210/neighbours.txt new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/.run/P36/agents/main__func_80035210/neighbours.txt @@ -0,0 +1 @@ + diff --git a/.run/P36/agents/main__func_80035210/related.txt b/.run/P36/agents/main__func_80035210/related.txt new file mode 100644 index 000000000..585839dd8 --- /dev/null +++ b/.run/P36/agents/main__func_80035210/related.txt @@ -0,0 +1 @@ +=== lever-free bodies in main sharing a callee or global with func_80035210 (0 found; top 6 by shared symbols) — read them for the SHAPE === diff --git a/.run/P36/agents/main__func_80035210/residual.txt b/.run/P36/agents/main__func_80035210/residual.txt new file mode 100644 index 000000000..1ed34a9b2 --- /dev/null +++ b/.run/P36/agents/main__func_80035210/residual.txt @@ -0,0 +1,9 @@ +src/800_b_2.c:func_80035210: score 4 (REG-caller; mine 24 ins, target 24) — not yet + register pairs (mine -> target, count): v0->v1 x6 + replace mine[12:14] target[12:14] + 12 lui v0,0x0 | lui v1,0x0 + 13 lw v0,0(v0) | lw v1,0(v1) + replace mine[15:16] target[15:16] + 15 addu v0,v0,s1 | addu v1,v1,s1 + replace mine[17:18] target[17:18] + 17 sw v0,0(at) | sw v1,0(at) diff --git a/.run/P36/agents/main__func_80035210/sites.txt b/.run/P36/agents/main__func_80035210/sites.txt new file mode 100644 index 000000000..6a8263da4 --- /dev/null +++ b/.run/P36/agents/main__func_80035210/sites.txt @@ -0,0 +1 @@ +NEEDED pin $3 line 7525 diff --git a/.run/P36/agents/main__func_80035210/tu.txt b/.run/P36/agents/main__func_80035210/tu.txt new file mode 100644 index 000000000..f79c13cd3 --- /dev/null +++ b/.run/P36/agents/main__func_80035210/tu.txt @@ -0,0 +1,2 @@ +src/800_b_2.c +func_80035210 diff --git a/.run/P36/agents/main__func_80036FB0/body_free.c b/.run/P36/agents/main__func_80036FB0/body_free.c new file mode 100644 index 000000000..2cfed4a66 --- /dev/null +++ b/.run/P36/agents/main__func_80036FB0/body_free.c @@ -0,0 +1,21 @@ +void func_80036FB0(s32 arg0, s32 arg1) { + extern s32 D_8006AEE8; + extern s32 D_80078F10; + f64 hole; + s32 count; + s32 i; + s32 *p; + + if (D_8006AEE8 > 0) { + i = 0; + count = D_8006AEE8; + p = &D_80078F10; + do { + if (*p == arg0) { + *p = arg1; + } + p++; + i++; + } while (i < count); + } +} diff --git a/.run/P36/agents/main__func_80036FB0/body_tree.c b/.run/P36/agents/main__func_80036FB0/body_tree.c new file mode 100644 index 000000000..229915aa3 --- /dev/null +++ b/.run/P36/agents/main__func_80036FB0/body_tree.c @@ -0,0 +1,23 @@ +void func_80036FB0(s32 arg0, s32 arg1) { + extern s32 D_8006AEE8; + extern s32 D_80078F10; + f64 hole; + s32 count; + s32 i; + s32 *p; + + __asm__ volatile("" :: // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus9) + "m"(hole)); + if (D_8006AEE8 > 0) { + i = 0; + count = D_8006AEE8; + p = &D_80078F10; + do { + if (*p == arg0) { + *p = arg1; + } + p++; + i++; + } while (i < count); + } +} diff --git a/.run/P36/agents/main__func_80036FB0/history.txt b/.run/P36/agents/main__func_80036FB0/history.txt new file mode 100644 index 000000000..9ee2bb4df --- /dev/null +++ b/.run/P36/agents/main__func_80036FB0/history.txt @@ -0,0 +1,14 @@ +g6b: verdict NO-MATCH start 4 best 4 compiles 213 path +best-scoring single candidates of the last trace (move -> score [residual class]): + R7 block @1627 -> 4 [COUNT] (from 4) + R9 swap-stmts @1626 -> 4 [COUNT] (from 4) + R10 param-copy arg0 @1617 -> 4 [COUNT] (from 4) + R7 do-while @1627 -> 4 [COUNT] (from 4) + R10 param-copy arg1 @1617 -> 4 [COUNT] (from 4) + R7 block @1626 -> 4 [COUNT] (from 4) + R7 do-while @1626 -> 4 [COUNT] (from 4) + R7 block @1624 -> 4 [COUNT] (from 4) + R7 do-while @1624 -> 4 [COUNT] (from 4) + R7 block @1619 -> 4 [COUNT] (from 4) + R7 do-while @1619 -> 4 [COUNT] (from 4) + R7 block @1620 -> 4 [COUNT] (from 4) diff --git a/.run/P36/agents/main__func_80036FB0/neighbours.txt b/.run/P36/agents/main__func_80036FB0/neighbours.txt new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/.run/P36/agents/main__func_80036FB0/neighbours.txt @@ -0,0 +1 @@ + diff --git a/.run/P36/agents/main__func_80036FB0/related.txt b/.run/P36/agents/main__func_80036FB0/related.txt new file mode 100644 index 000000000..ccf212e71 --- /dev/null +++ b/.run/P36/agents/main__func_80036FB0/related.txt @@ -0,0 +1 @@ +=== lever-free bodies in main sharing a callee or global with func_80036FB0 (0 found; top 6 by shared symbols) — read them for the SHAPE === diff --git a/.run/P36/agents/main__func_80036FB0/residual.txt b/.run/P36/agents/main__func_80036FB0/residual.txt new file mode 100644 index 000000000..466bd00fe --- /dev/null +++ b/.run/P36/agents/main__func_80036FB0/residual.txt @@ -0,0 +1,8 @@ +src/800_c.c:func_80036FB0: score 4 (COUNT; mine 20 ins, target 21) — not yet + insert mine[0:0] target[0:1] + 0 -- | addiu sp,sp,-8 + replace mine[3:5] target[4:5] + 3 blez v0,1d88 | blez v0,1d88 + 4 nop | -- + insert mine[18:18] target[18:19] + 18 -- | addiu sp,sp,8 diff --git a/.run/P36/agents/main__func_80036FB0/sites.txt b/.run/P36/agents/main__func_80036FB0/sites.txt new file mode 100644 index 000000000..041509be3 --- /dev/null +++ b/.run/P36/agents/main__func_80036FB0/sites.txt @@ -0,0 +1 @@ +NEEDED keepalive line 1618 diff --git a/.run/P36/agents/main__func_80036FB0/tu.txt b/.run/P36/agents/main__func_80036FB0/tu.txt new file mode 100644 index 000000000..2db939415 --- /dev/null +++ b/.run/P36/agents/main__func_80036FB0/tu.txt @@ -0,0 +1,2 @@ +src/800_c.c +func_80036FB0 diff --git a/.run/P36/agents/main__func_80037144/body_free.c b/.run/P36/agents/main__func_80037144/body_free.c new file mode 100644 index 000000000..07020a2c6 --- /dev/null +++ b/.run/P36/agents/main__func_80037144/body_free.c @@ -0,0 +1,57 @@ +void func_80037144(s32 idx) { + s32 i; + s32 k; + s32 t; + s32 v; + s32 one; + s32 ent; + + for (i = 0; i < 5; i++) { + if (D_80076244[i].unk0D == 0) { + break; + } + } + if (i < 5) { + one = 1; + D_80076244[i].unk00 = (s32)D_800BA320; + /* scheduling barrier: the slot stores and the D_80065438 load DO disambiguate here + * (both /s and both varying -> memrefs_conflict_p:614 falls through to + * find_symbolic_term and the two symbols differ), so without this gcc hoists the + * D_80065438 load above all the slot stores and permutes the head block. + * Emits zero instructions. */ + D_80076244[i].unk0C = 0; + D_80076244[i].unk0D = one; + D_80076244[i].unk04 = idx | 0x2000; + D_80076244[i].unk0E = 4; + v = D_800652F0[D_80065438[idx].f0]; + D_800A469C = v; + D_80076244[i].unk08 = v; + k = 4; + if (D_800A46B0 == 0) { + if (D_800A46A0 == (D_80065438[idx].f0 | 0x4000)) { + D_80076244[i].unk04 |= 0x1000; + goto after; + } + t = D_800A46A2; + D_800A46B0 = one; + } else { + t = D_800A46A2; + } + if (t >= 0) { + func_800415A8(t); + D_800A46A2 = -1; + } + after: + if (i == 0) { + D_8007622C[0] = (s32)D_800BA320; + ent = D_800A463C[k].unk00; + D_80076228.v = (s32)D_800BA320; + D_80076240[0].unk00 = 0; + D_80076243.v = 1; + D_80076242.v = 0; + D_80076294.v = 0; + D_80076238.v = ent; + } + } + D_8007629C = 0; +} diff --git a/.run/P36/agents/main__func_80037144/body_tree.c b/.run/P36/agents/main__func_80037144/body_tree.c new file mode 100644 index 000000000..d63b6ede6 --- /dev/null +++ b/.run/P36/agents/main__func_80037144/body_tree.c @@ -0,0 +1,58 @@ +void func_80037144(s32 idx) { + s32 i; + s32 k; + s32 t; + s32 v; + s32 one; + s32 ent; + + for (i = 0; i < 5; i++) { + if (D_80076244[i].unk0D == 0) { + break; + } + } + if (i < 5) { + one = 1; + D_80076244[i].unk00 = (s32)D_800BA320; + /* scheduling barrier: the slot stores and the D_80065438 load DO disambiguate here + * (both /s and both varying -> memrefs_conflict_p:614 falls through to + * find_symbolic_term and the two symbols differ), so without this gcc hoists the + * D_80065438 load above all the slot stores and permutes the head block. + * Emits zero instructions. */ + __asm__ __volatile__("" ::: "memory"); // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus9) + D_80076244[i].unk0C = 0; + D_80076244[i].unk0D = one; + D_80076244[i].unk04 = idx | 0x2000; + D_80076244[i].unk0E = 4; + v = D_800652F0[D_80065438[idx].f0]; + D_800A469C = v; + D_80076244[i].unk08 = v; + k = 4; + if (D_800A46B0 == 0) { + if (D_800A46A0 == (D_80065438[idx].f0 | 0x4000)) { + D_80076244[i].unk04 |= 0x1000; + goto after; + } + t = D_800A46A2; + D_800A46B0 = one; + } else { + t = D_800A46A2; + } + if (t >= 0) { + func_800415A8(t); + D_800A46A2 = -1; + } + after: + if (i == 0) { + D_8007622C[0] = (s32)D_800BA320; + ent = D_800A463C[k].unk00; + D_80076228.v = (s32)D_800BA320; + D_80076240[0].unk00 = 0; + D_80076243.v = 1; + D_80076242.v = 0; + D_80076294.v = 0; + D_80076238.v = ent; + } + } + D_8007629C = 0; +} diff --git a/.run/P36/agents/main__func_80037144/history.txt b/.run/P36/agents/main__func_80037144/history.txt new file mode 100644 index 000000000..9b35aa227 --- /dev/null +++ b/.run/P36/agents/main__func_80037144/history.txt @@ -0,0 +1,14 @@ +g6b: verdict NO-MATCH start 16 best 2 compiles 326 path R7 do-while @1799 +best-scoring single candidates of the last trace (move -> score [residual class]): + R7 do-while @1799 -> 2 [ORDER] (from 16) + R9 swap-stmts @1788 -> 2 [ORDER] (from 2) + R7 block @1788 -> 2 [ORDER] (from 2) + R10 param-copy idx @1781 -> 2 [ORDER] (from 2) + R7 block @1789 -> 2 [ORDER] (from 2) + R12 width one s32->u16 @1779 -> 2 [ORDER] (from 2) + R7 block @1795 -> 2 [ORDER] (from 2) + R12 width one s32->s16 @1779 -> 2 [ORDER] (from 2) + R9 swap-stmts @1801 -> 2 [ORDER] (from 2) + R12 width one s32->u8 @1779 -> 2 [ORDER] (from 2) + R9 swap-stmts @1808 -> 2 [ORDER] (from 2) + R7 block @1796 -> 2 [ORDER] (from 2) diff --git a/.run/P36/agents/main__func_80037144/neighbours.txt b/.run/P36/agents/main__func_80037144/neighbours.txt new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/.run/P36/agents/main__func_80037144/neighbours.txt @@ -0,0 +1 @@ + diff --git a/.run/P36/agents/main__func_80037144/related.txt b/.run/P36/agents/main__func_80037144/related.txt new file mode 100644 index 000000000..d86fd33b8 --- /dev/null +++ b/.run/P36/agents/main__func_80037144/related.txt @@ -0,0 +1 @@ +=== lever-free bodies in main sharing a callee or global with func_80037144 (0 found; top 6 by shared symbols) — read them for the SHAPE === diff --git a/.run/P36/agents/main__func_80037144/residual.txt b/.run/P36/agents/main__func_80037144/residual.txt new file mode 100644 index 000000000..0b94b0bfe --- /dev/null +++ b/.run/P36/agents/main__func_80037144/residual.txt @@ -0,0 +1,25 @@ +src/800_c.c:func_80037144: score 16 (COUNT; mine 123 ins, target 124) — not yet + register pairs (mine -> target, count): v1->v0 x1 + replace mine[17:18] target[17:18] + 17 beqz v0,20a0 | beqz v0,20a4 + insert mine[19:19] target[19:21] + 19 -- | lui v0,0x0 + 20 -- | addiu v0,v0,0 + insert mine[20:20] target[22:25] + 20 -- | lui at,0x0 + 21 -- | addu at,at,a1 + 22 -- | sw v0,0(at) + replace mine[42:45] target[47:50] + 42 lw v1,0(at) | lw v0,0(at) + 43 lui v0,0x0 | lui at,0x0 + 44 addiu v0,v0,0 | sw v0,0(at) + replace mine[50:55] target[55:56] + 50 lui at,0x0 | nop + 51 sw v1,0(at) | -- + 52 lui at,0x0 | -- + 53 addu at,at,a1 | -- + 54 sw v1,8(at) | -- + replace mine[73:74] target[74:75] + 73 j 2040 | j 2044 + replace mine[79:80] target[80:81] + 79 j 2020 | j 2024 diff --git a/.run/P36/agents/main__func_80037144/sites.txt b/.run/P36/agents/main__func_80037144/sites.txt new file mode 100644 index 000000000..d589d2b8d --- /dev/null +++ b/.run/P36/agents/main__func_80037144/sites.txt @@ -0,0 +1 @@ +NEEDED barrier memory line 1795 diff --git a/.run/P36/agents/main__func_80037144/tu.txt b/.run/P36/agents/main__func_80037144/tu.txt new file mode 100644 index 000000000..82dcbd7c5 --- /dev/null +++ b/.run/P36/agents/main__func_80037144/tu.txt @@ -0,0 +1,2 @@ +src/800_c.c +func_80037144 diff --git a/.run/P36/agents/main__func_800384A8/body.c b/.run/P36/agents/main__func_800384A8/body.c new file mode 100644 index 000000000..d4bcee0d5 --- /dev/null +++ b/.run/P36/agents/main__func_800384A8/body.c @@ -0,0 +1,38 @@ +void func_800384A8(s32 arg0) { + u8 *entry; + u8 *p; + u8 *q; + s32 j; + u8 *b; + s32 *m; + s32 *mb; + s32 i; + s32 one; + + entry = &D_800B9CD8[arg0 * 0x1FC]; + p = entry + 0x1A; + i = 0; + one = 1; + mb = (s32 *)D_80073140; + D_800A4F1D = 1; + entry[0x1FA] = 0; + for (; i < 0x10; i++) { + q = p + 9; + j = 0; + b = D_800C6E2D; + m = mb; + for (; j < 0x10; j++) { + if (*q++ != 0) { + b[1] = one; + b[0] = 0; + func_8003916C(j); + func_8002EFF8(0, *m); + } + m++; + b += 0x60; + } + p += 0x1A; + } + D_800A4F1D = 0; + *(s32 *)entry = *(s32 *)(entry + 4); +} diff --git a/.run/P36/agents/main__func_800384A8/body_free.c b/.run/P36/agents/main__func_800384A8/body_free.c new file mode 100644 index 000000000..4345477b1 --- /dev/null +++ b/.run/P36/agents/main__func_800384A8/body_free.c @@ -0,0 +1,39 @@ +void func_800384A8(s16 arg0) { + s32 raw; + u8 *entry; + u8 *p; + u8 *q; + s32 j; + u8 *b; + s32 *m; + s32 *mb; + s32 i; + s32 one; + + entry = &D_800B9CD8[raw * 0x1FC]; + p = entry + 0x1A; + i = 0; + one = 1; + mb = (s32 *)D_80073140; + D_800A4F1D = 1; + entry[0x1FA] = 0; + for (; i < 0x10; i++) { + q = p + 9; + j = 0; + b = D_800C6E2D; + m = mb; + for (; j < 0x10; j++) { + if (*q++ != 0) { + b[1] = one; + b[0] = 0; + func_8003916C(j); + func_8002EFF8(0, *m); + } + m++; + b += 0x60; + } + p += 0x1A; + } + D_800A4F1D = 0; + *(s32 *)entry = *(s32 *)(entry + 4); +} diff --git a/.run/P36/agents/main__func_800384A8/body_tree.c b/.run/P36/agents/main__func_800384A8/body_tree.c new file mode 100644 index 000000000..066e22072 --- /dev/null +++ b/.run/P36/agents/main__func_800384A8/body_tree.c @@ -0,0 +1,39 @@ +void func_800384A8(s16 arg0) { + register s32 raw __asm__("$4"); // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus9) + u8 *entry; + u8 *p; + u8 *q; + s32 j; + u8 *b; + s32 *m; + s32 *mb; + s32 i; + s32 one; + + entry = &D_800B9CD8[raw * 0x1FC]; + p = entry + 0x1A; + i = 0; + one = 1; + mb = (s32 *)D_80073140; + D_800A4F1D = 1; + entry[0x1FA] = 0; + for (; i < 0x10; i++) { + q = p + 9; + j = 0; + b = D_800C6E2D; + m = mb; + for (; j < 0x10; j++) { + if (*q++ != 0) { + b[1] = one; + b[0] = 0; + func_8003916C(j); + func_8002EFF8(0, *m); + } + m++; + b += 0x60; + } + p += 0x1A; + } + D_800A4F1D = 0; + *(s32 *)entry = *(s32 *)(entry + 4); +} diff --git a/.run/P36/agents/main__func_800384A8/history.txt b/.run/P36/agents/main__func_800384A8/history.txt new file mode 100644 index 000000000..e9b2b5a62 --- /dev/null +++ b/.run/P36/agents/main__func_800384A8/history.txt @@ -0,0 +1,14 @@ +g6b: verdict NO-MATCH start 2 best 2 compiles 325 path +best-scoring single candidates of the last trace (move -> score [residual class]): + R8 temp tmp0 @2669 -> 2 [REG] (from 2) + R14 param-width arg0 s16->s32 @2632 -> 2 [REG] (from 2) + R7 block @2644 -> 2 [REG] (from 2) + R4 decl-move raw 0->1 -> 2 [REG] (from 2) + R8 base tmp0 @2669 -> 2 [REG] (from 2) + R14 param-width arg0 s16->u16 @2632 -> 2 [REG] (from 2) + R4 decl-move raw 0->2 -> 2 [REG] (from 2) + R7 block @2645 -> 2 [REG] (from 2) + R4 decl-move raw 0->3 -> 2 [REG] (from 2) + R4 decl-move raw 0->4 -> 2 [REG] (from 2) + R7 block @2646 -> 2 [REG] (from 2) + R9 swap-stmts @2648 -> 2 [REG] (from 2) diff --git a/.run/P36/agents/main__func_800384A8/neighbours.txt b/.run/P36/agents/main__func_800384A8/neighbours.txt new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/.run/P36/agents/main__func_800384A8/neighbours.txt @@ -0,0 +1 @@ + diff --git a/.run/P36/agents/main__func_800384A8/related.txt b/.run/P36/agents/main__func_800384A8/related.txt new file mode 100644 index 000000000..892d89773 --- /dev/null +++ b/.run/P36/agents/main__func_800384A8/related.txt @@ -0,0 +1 @@ +=== lever-free bodies in main sharing a callee or global with func_800384A8 (0 found; top 6 by shared symbols) — read them for the SHAPE === diff --git a/.run/P36/agents/main__func_800384A8/residual.txt b/.run/P36/agents/main__func_800384A8/residual.txt new file mode 100644 index 000000000..f5998eb72 --- /dev/null +++ b/.run/P36/agents/main__func_800384A8/residual.txt @@ -0,0 +1,5 @@ +src/800_c.c:func_800384A8: score 2 (REG-caller; mine 70 ins, target 70) — not yet + register pairs (mine -> target, count): v1->a0 x2 + replace mine[1:3] target[1:3] + 1 sll v0,v1,0x7 | sll v0,a0,0x7 + 2 subu v0,v0,v1 | subu v0,v0,a0 diff --git a/.run/P36/agents/main__func_800384A8/sites.txt b/.run/P36/agents/main__func_800384A8/sites.txt new file mode 100644 index 000000000..e7eb3dd26 --- /dev/null +++ b/.run/P36/agents/main__func_800384A8/sites.txt @@ -0,0 +1 @@ +NEEDED pin $4 line 2633 diff --git a/.run/P36/agents/main__func_800384A8/tu.txt b/.run/P36/agents/main__func_800384A8/tu.txt new file mode 100644 index 000000000..5dd7242b2 --- /dev/null +++ b/.run/P36/agents/main__func_800384A8/tu.txt @@ -0,0 +1,2 @@ +src/800_c.c +func_800384A8 diff --git a/.run/P36/agents/md_SC07_004__func_801A1E94/body_free.c b/.run/P36/agents/md_SC07_004__func_801A1E94/body_free.c new file mode 100644 index 000000000..8581309f9 --- /dev/null +++ b/.run/P36/agents/md_SC07_004__func_801A1E94/body_free.c @@ -0,0 +1,21 @@ +void func_801A1E94(void) +{ + s32 param_1; + s32 p; + s32 *s0; + s32 *s1; + + p = param_1; + s0 = (s32 *)p; + s1 = &D_801BF01C; + func_8001C924(*(s32 *)(p + 0x20), s1); + func_80132288(&D_801F8724, &D_801AFB58, *s1); + *(s16 *)(p + 0xA) = -0x240; + *(s16 *)(p + 0xE) = 0x30; + *(s32 *)(p + 0xD4) = func_801A8528(p); + func_80178B18(p, (s32)&D_801AFCF8); + *(s32 *)(p + 0x1C) = 0x60; + *(s16 *)(p + 0x100) = 0xFF; + *(s16 *)(p + 0x84) = 0; + func_8012AD44((s32 *)p, 0xE); +} diff --git a/.run/P36/agents/md_SC07_004__func_801A1E94/body_tree.c b/.run/P36/agents/md_SC07_004__func_801A1E94/body_tree.c new file mode 100644 index 000000000..0f695701d --- /dev/null +++ b/.run/P36/agents/md_SC07_004__func_801A1E94/body_tree.c @@ -0,0 +1,21 @@ +void func_801A1E94(void) +{ + register s32 param_1 __asm__("$4"); // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus9) + s32 p; + s32 *s0; + s32 *s1; + + p = param_1; + s0 = (s32 *)p; + s1 = &D_801BF01C; + func_8001C924(*(s32 *)(p + 0x20), s1); + func_80132288(&D_801F8724, &D_801AFB58, *s1); + *(s16 *)(p + 0xA) = -0x240; + *(s16 *)(p + 0xE) = 0x30; + *(s32 *)(p + 0xD4) = func_801A8528(p); + func_80178B18(p, (s32)&D_801AFCF8); + *(s32 *)(p + 0x1C) = 0x60; + *(s16 *)(p + 0x100) = 0xFF; + *(s16 *)(p + 0x84) = 0; + func_8012AD44((s32 *)p, 0xE); +} diff --git a/.run/P36/agents/md_SC07_004__func_801A1E94/history.txt b/.run/P36/agents/md_SC07_004__func_801A1E94/history.txt new file mode 100644 index 000000000..d76b5e5c9 --- /dev/null +++ b/.run/P36/agents/md_SC07_004__func_801A1E94/history.txt @@ -0,0 +1,15 @@ +g6b: verdict NO-MATCH start 14 best 1 compiles 312 path R12 width p s32->u16 @1187 +s8: verdict NO-MATCH start 14 best 1 compiles 246 path R12 width p s32->u16 @1187 +best-scoring single candidates of the last trace (move -> score [residual class]): + R12 width p s32->u16 @1187 -> 1 [OTHER] (from 14) + R12 width p s32->u8 @1187 -> 1 [OTHER] (from 14) + R12 width param_1 s32->u16 @1186 -> 1 [OTHER] (from 14) + R12 width param_1 s32->u8 @1186 -> 1 [OTHER] (from 14) + R4 decl-move param_1 0->1 -> 1 [OTHER] (from 1) + R7 block @1191 -> 1 [OTHER] (from 1) + R8 temp tmp0 @1194 -> 1 [OTHER] (from 1) + R9 swap-stmts @1191 -> 1 [OTHER] (from 1) + R12 width param_1 s32->u16 @1186 -> 1 [OTHER] (from 1) + R18 bystander @1193->1191 -> 1 [OTHER] (from 1) + R4 decl-move param_1 0->2 -> 1 [OTHER] (from 1) + R8 base tmp0 @1194 -> 1 [OTHER] (from 1) diff --git a/.run/P36/agents/md_SC07_004__func_801A1E94/neighbours.txt b/.run/P36/agents/md_SC07_004__func_801A1E94/neighbours.txt new file mode 100644 index 000000000..02091e67b --- /dev/null +++ b/.run/P36/agents/md_SC07_004__func_801A1E94/neighbours.txt @@ -0,0 +1,3 @@ +--- every @class/@stuck/@crack note in this translation unit --- +// @class: loose-typing +// @stuck: none — MATCH (99 ins). short* for param_2/param_3: gcc emits lh where sign is live (<<1 for signed div), lhu where truncated to short (arith result / direct copy) diff --git a/.run/P36/agents/md_SC07_004__func_801A1E94/related.txt b/.run/P36/agents/md_SC07_004__func_801A1E94/related.txt new file mode 100644 index 000000000..c1c8ef002 --- /dev/null +++ b/.run/P36/agents/md_SC07_004__func_801A1E94/related.txt @@ -0,0 +1,179 @@ +=== lever-free bodies in md_SC07_004 sharing a callee or global with func_801A1E94 (45 found; top 6 by shared symbols) — read them for the SHAPE === +--- func_801A66DC (src/md_SC07_004/md_SC07_004.c:4346) shares 5: D_801BF01C D_801F8724 func_8001C924 func_80132288 func_801A8528 --- +void func_801A66DC(s32 a0) { + s32 *sp; + u8 pad[8]; + + switch (*(u16 *)(a0 + 0x34)) { + case 0: + sp = &D_801BF01C; + func_8001C924(*(s32 *)(a0 + 0x20), sp); + func_8012B2CC(a0); + func_801A39D0(a0); + func_80132288(&D_801F8724, D_801AFB78, *sp); + D_8019FF8A |= 1; + *(s32 *)(a0 + 0xD4) = func_801A8528(a0); + func_801A85A8(a0, 0x28080A0, 0, 0x200); + func_801A8A64(a0); + func_8017FA74(); + *(u16 *)(a0 + 0x34) += 1; + break; + case 1: + func_8013240C((s32)&D_801F8724); + if (D_801F8730 & 0x4000) { + func_801A18F4(a0); + } + break; + } +} + +--- func_801A3744 (src/md_SC07_004/md_SC07_004.c:2284) shares 3: D_801BF01C D_801F8724 func_80132288 --- +void func_801A3744(s32 a0) { + *(s16 *)(a0 + 0xE6) = 4; + func_80132288(&D_801F8724, D_801AFB8C, D_801BF01C); + *(s16 *)(a0 + 0x100) = -0x40; +} + +--- func_801A2F34 (src/md_SC07_004/md_SC07_004.c:1919) shares 3: D_801F8724 func_8001C924 func_80132288 --- +void func_801A2F34(s32 a0) { + s16 *p; + s32 *s2; + s32 *s0; + s16 v1; + s32 v0; + + v1 = *(s16 *)(a0 + 0xE6); + s2 = D_80126B58; + if (v1 == 0) { + p = &D_801F872A; + *p = (s16)D_80126CE0 >> 1; + func_8013240C((s32)p - 6); + if ((D_801F8730 & 0x4000) != 0) { + *(u16 *)(a0 + 0xE6) = *(u16 *)(a0 + 0xE6) + 1; + } + } else if (v1 != 1) { + if (*(s16 *)(a0 + 0x98) == 0 && *(s16 *)&D_80126CE0 >= D_801AFB90) { + s0 = &D_801BC9EC; + func_8001C924(*(s32 *)(a0 + 0x20), s0); + *(s32 *)(*(s32 *)(a0 + 0x20) + 0x20) = (s32)D_80063548; + *(s16 *)(a0 + 0xE6) = 0; + func_80132288(&D_801F8724, &D_801AFAB8, *s0); + } + } + if ((D_800B99DA & 1) != 0) { + if (*(s16 *)((s32)s2 + 0x188) > 0) { + *(s16 *)((s32)s2 + 0x188) = *(s16 *)((s32)s2 + 0x188) - 1; + } + } + if (*(s16 *)((s32)s2 + 0x188) == 0) { + v0 = *(u16 *)(a0 + 0xF8) + 1; + *(u16 *)(a0 + 0xF8) = v0; + if ((s16)v0 >= 0x19) { + func_8014CBD8(); + func_801A3114((s32 *)a0); + } + } else { + *(u16 *)(a0 + 0xF8) = 0; + } +} + +--- func_801A3798 (src/md_SC07_004/md_SC07_004.c:2330) shares 3: D_801F8724 func_8001C924 func_80132288 --- +s32 func_801A3798(s32 s0, s32 arg1) { + s32 v0; + s32 v1; + u16 y; + s32 t; + s32 p; + u16 f9; + + y = arg1 + 0; + v0 = ((s32 (*)(s32, s32))func_801A395C)(s0, (s16)(*(u16 *)(s0 + 0x100) - 0x240)); + v1 = *(s16 *)(s0 + 0xE6); + if (v1 >= 0) { + func_8013240C((s32)&D_801F8724); + if (D_801F8730 & 0x4000) { + t = *(u16 *)(s0 + 0xE6) - 1; + *(u16 *)(s0 + 0xE6) = t; + t <<= 16; + v1 = t >> 16; + if (v1 >= 0) { + if (v1 >= 3) { + if (v1 != 3) { + goto other; + } + func_8001C924(*(s32 *)(s0 + 0x20), &D_801BC9EC); + if (*(s32 *)(s0 + 0xD4) != 0) { + func_801A7D18(*(s32 *)(s0 + 0xD4)); + *(s32 *)(s0 + 0xD4) = 0; + } + func_801A3A6C((u8 *)s0); + *(u16 *)(s0 + 0x100) = 0; + func_8012B2CC(s0); + if ((arg1 << 16) != 0) { + *(s32 *)(s0 + 0xD4) = func_801A8564(s0); + } + } + func_80132288(&D_801F8724, D_801AFB7C[*(s16 *)(s0 + 0xE6)], D_801BC9EC); + goto ret0; + } + other: + func_8001C924(*(s32 *)(s0 + 0x20), D_801B6E94); + func_8012A860((void *)s0, (int)&D_801EF9A8); + if ((y << 16) != 0) { + f9 = D_8019FF8A & 0xFFF7; + p = *(s32 *)(s0 + 0xD4); + D_8019FF8A = f9; + if (p != 0) { + func_801292C8((u8 *)p); + } + } + } + ret0: + return 0; + } + return (*(s16 *)(s0 + 0x98) == 0) && (v0 != 0); +} + +--- func_801A4A18 (src/md_SC07_004/md_SC07_004.c:3163) shares 2: func_8012AD44 func_80132288 --- +void func_801A4A18(s32 a0) +{ + s16 cond; + s32 mirror; + + cond = *(s16 *)(a0 + 0x70); + mirror = *(s32 *)(a0 + 0xCC); + + if (cond == 0) { + func_80132288(&D_801F8888, &D_801B007C, D_801B75EC); + if (mirror != 0) { + func_80132288(&D_801F8898, &D_801B00B4, (*(s32 *)D_801B80FC)); + } + } + + *(s16 *)(a0 + 0x84) = 0; + func_8012AD44((s32 *)a0, 2); +} + +--- func_801A2364 (src/md_SC07_004/md_SC07_004.c:1416) shares 2: func_8012AD44 func_80178B18 --- +void func_801A2364(s32 a0) +{ + s32 flag; + + func_80178B18(a0, (s32)&D_801AFD8C); + flag = *(s32 *)(a0 + 0xD4); + *(s32 *)(a0 + 0x1C) = 0x20; + (*(u16 *)&D_801F8868) = 0; + if (flag != 0) { + ((void (*)(s32 arg0))func_801A7D18)(flag); + *(s32 *)(a0 + 0xD4) = 0; + func_801A36F0((void *)a0); + } + func_8012AD44((s32 *)a0, 0xF); + func_800D0C48(1); + D_801F8720 = 0; + func_8002A088(0x320); + func_8002A2D4(0x64); + func_8002A544(0x190); + func_8002A7B4(0x12C); +} + diff --git a/.run/P36/agents/md_SC07_004__func_801A1E94/residual.txt b/.run/P36/agents/md_SC07_004__func_801A1E94/residual.txt new file mode 100644 index 000000000..d1ef4aba1 --- /dev/null +++ b/.run/P36/agents/md_SC07_004__func_801A1E94/residual.txt @@ -0,0 +1,24 @@ +src/md_SC07_004/md_SC07_004.c:func_801A1E94: score 14 (COUNT; mine 41 ins, target 42) — not yet + register pairs (mine -> target, count): s1->s0 x6, s0->s1 x2 + replace mine[2:4] target[2:6] + 2 lui s0,0x0 | move s0,a0 + 3 addiu s0,s0,0 | sw s1,20(sp) + 4 -- | lui s1,0x0 + 5 -- | addiu s1,s1,0 + replace mine[5:7] target[7:8] + 5 sw s1,20(sp) | lw a0,32(s0) + 6 lw a0,32(s1) | -- + replace mine[8:9] target[9:10] + 8 move a1,s0 | move a1,s1 + replace mine[11:12] target[12:13] + 11 lw a2,0(s0) | lw a2,0(s1) + replace mine[16:17] target[17:18] + 16 move a0,s1 | move a0,s0 + replace mine[18:19] target[19:20] + 18 sh v0,10(s1) | sh v0,10(s0) + replace mine[21:23] target[22:24] + 21 sh v0,14(s1) | sh v0,14(s0) + 22 move a0,s1 | move a0,s0 + replace mine[26:28] target[27:29] + 26 sw v0,212(s1) | sw v0,212(s0) + 27 move a0,s1 | move a0,s0 diff --git a/.run/P36/agents/md_SC07_004__func_801A1E94/sites.txt b/.run/P36/agents/md_SC07_004__func_801A1E94/sites.txt new file mode 100644 index 000000000..851a30c51 --- /dev/null +++ b/.run/P36/agents/md_SC07_004__func_801A1E94/sites.txt @@ -0,0 +1 @@ +NEEDED pin $4 line 1187 diff --git a/.run/P36/agents/md_SC07_004__func_801A1E94/tu.txt b/.run/P36/agents/md_SC07_004__func_801A1E94/tu.txt new file mode 100644 index 000000000..c43ad225e --- /dev/null +++ b/.run/P36/agents/md_SC07_004__func_801A1E94/tu.txt @@ -0,0 +1,2 @@ +src/md_SC07_004/md_SC07_004.c +func_801A1E94 diff --git a/.run/P36/agents/md_SC07_004__func_801A5C44/body_free.c b/.run/P36/agents/md_SC07_004__func_801A5C44/body_free.c new file mode 100644 index 000000000..040c197c4 --- /dev/null +++ b/.run/P36/agents/md_SC07_004__func_801A5C44/body_free.c @@ -0,0 +1,16 @@ +void func_801A5C44(void) { + s32 a0; + s32 s0 = a0; + s32 s2; + s32 s1; + s32 temp; + + temp = *(s16 *)(s0 + 0x100); + s2 = *(s32 *)(s0 + 0xCC); + s1 = *(s32 *)(s0 + 0xD4); + temp = func_8004787C(temp) >> 4; + *(s16 *)(s2 + 0x18) = *(u16 *)(s1 + (*(s16 *)(s0 + 0x70) * 4)) + temp; + temp = func_8004787C(*(s16 *)(s0 + 0x100) + 0x800) >> 4; + *(s16 *)(s2 + 0x1A) = *(u16 *)(s1 + (*(s16 *)(s0 + 0x70) * 4) + 2) + temp; + *(u16 *)(s0 + 0x100) += 0x40; +} diff --git a/.run/P36/agents/md_SC07_004__func_801A5C44/body_tree.c b/.run/P36/agents/md_SC07_004__func_801A5C44/body_tree.c new file mode 100644 index 000000000..bd4244e89 --- /dev/null +++ b/.run/P36/agents/md_SC07_004__func_801A5C44/body_tree.c @@ -0,0 +1,16 @@ +void func_801A5C44(void) { + register s32 a0 __asm__("$4"); // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus9) + s32 s0 = a0; + s32 s2; + s32 s1; + s32 temp; + + temp = *(s16 *)(s0 + 0x100); + s2 = *(s32 *)(s0 + 0xCC); + s1 = *(s32 *)(s0 + 0xD4); + temp = func_8004787C(temp) >> 4; + *(s16 *)(s2 + 0x18) = *(u16 *)(s1 + (*(s16 *)(s0 + 0x70) * 4)) + temp; + temp = func_8004787C(*(s16 *)(s0 + 0x100) + 0x800) >> 4; + *(s16 *)(s2 + 0x1A) = *(u16 *)(s1 + (*(s16 *)(s0 + 0x70) * 4) + 2) + temp; + *(u16 *)(s0 + 0x100) += 0x40; +} diff --git a/.run/P36/agents/md_SC07_004__func_801A5C44/history.txt b/.run/P36/agents/md_SC07_004__func_801A5C44/history.txt new file mode 100644 index 000000000..682b01adc --- /dev/null +++ b/.run/P36/agents/md_SC07_004__func_801A5C44/history.txt @@ -0,0 +1,14 @@ +s5: verdict NO-MATCH start 15 best 1 compiles 184 path R12 width s0 s32->u16 @3902 +best-scoring single candidates of the last trace (move -> score [residual class]): + R12 width s0 s32->u16 @3902 -> 1 [OTHER] (from 15) + R5 swap + @3911 -> 1 [OTHER] (from 1) + R7 block @3907 -> 1 [OTHER] (from 1) + R8 temp tmp0 @3907 -> 1 [OTHER] (from 1) + R9 swap-stmts @3907 -> 1 [OTHER] (from 1) + R12 width a0 s32->u16 @3901 -> 1 [OTHER] (from 1) + R5 swap + @3913 -> 1 [OTHER] (from 1) + R6 inline temp @3910 -> 1 [OTHER] (from 1) + R8 base tmp0 @3907 -> 1 [OTHER] (from 1) + R12 width a0 s32->s16 @3901 -> 1 [OTHER] (from 1) + R18 bystander @3907->3910 -> 1 [OTHER] (from 1) + R6 inline temp @3912 -> 1 [OTHER] (from 1) diff --git a/.run/P36/agents/md_SC07_004__func_801A5C44/neighbours.txt b/.run/P36/agents/md_SC07_004__func_801A5C44/neighbours.txt new file mode 100644 index 000000000..02091e67b --- /dev/null +++ b/.run/P36/agents/md_SC07_004__func_801A5C44/neighbours.txt @@ -0,0 +1,3 @@ +--- every @class/@stuck/@crack note in this translation unit --- +// @class: loose-typing +// @stuck: none — MATCH (99 ins). short* for param_2/param_3: gcc emits lh where sign is live (<<1 for signed div), lhu where truncated to short (arith result / direct copy) diff --git a/.run/P36/agents/md_SC07_004__func_801A5C44/related.txt b/.run/P36/agents/md_SC07_004__func_801A5C44/related.txt new file mode 100644 index 000000000..881828682 --- /dev/null +++ b/.run/P36/agents/md_SC07_004__func_801A5C44/related.txt @@ -0,0 +1,171 @@ +=== lever-free bodies in md_SC07_004 sharing a callee or global with func_801A5C44 (7 found; top 6 by shared symbols) — read them for the SHAPE === +--- func_801A4060 (src/md_SC07_004/md_SC07_004.c:2703) shares 1: func_8004787C --- +void func_801A4060(s32 a0) { + *(s16 *)(*(s32 *)(a0 + 0x20) + 0x18) = (func_8004787C(*(s16 *)(a0 + 0xFE)) >> 3) + 0x1000; + *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1A) = (func_8004787C(*(s16 *)(a0 + 0xFE) + 0x800) >> 3) + 0x1000; + *(u16 *)(a0 + 0xFE) += 0x80; +} + +--- func_801A36A8 (src/md_SC07_004/md_SC07_004.c:2241) shares 1: func_8004787C --- +void func_801A36A8(s32 a0) { + s16 v; + + v = *(u16 *)((s32)a0 + 0x108) + 0x30; + *(u16 *)((s32)a0 + 0x108) = v; + *(s16 *)((s32)a0 + 0x52) = func_8004787C(v) >> 8; +} + +--- func_801AE060 (src/md_SC07_004/md_SC07_004.c:9832) shares 1: func_8004787C --- +void func_801AE060(s32 a0) { + s32 s0 = a0; + s32 t; + s32 *p = &D_800B9AA8; + + *p = *p - 0x300; + + t = *(u16 *)(s0 + 0xFE); + t += 0x18; + *(u16 *)(s0 + 0xFE) = t; + D_800B9AA4 = func_8004787C((s16)t) + 0x2700; + D_800B9AA6 = func_8004787C(*(s16 *)(s0 + 0xFE) + 0x400) + 0x2700; + + D_800B9AB8 -= 1; + D_800B9ABA += 1; + + switch (*(u16 *)(s0 + 0x34)) { + case 0: + *(u16 *)(s0 + 0x34) = *(u16 *)(s0 + 0x34) + 1; + break; + case 1: + func_801ACD4C(); + break; + } +} + +--- func_801A7B08 (src/md_SC07_004/md_SC07_004.c:5187) shares 1: func_8004787C --- +void func_801A7B08(s32 arg0) { + s32 s0; + u8 *p; + s0 = arg0; + func_801A8440(s0); + + switch (*(s16 *)((s32)s0 + 0x2C)) { + case 0: { + s16 t = *(s16 *)(*(s32 *)((s32)s0 + 0x20) + 0x18); + if (t >= 0x401) { + *(s16 *)(*(s32 *)((s32)s0 + 0x20) + 0x18) = t - 0xA0; + *(u16 *)(*(s32 *)((s32)s0 + 0x20) + 0x1A) = *(u16 *)(*(s32 *)((s32)s0 + 0x20) + 0x18); + } + p = &D_801F88BA; + if (*p < 0xF0) { + *p += 0xC; + } + if ((*(s16 *)(*(s32 *)((s32)s0 + 0x20) + 0x18) < 0x401) && + (*p >= 0xF0)) { + *(u16 *)((s32)s0 + 0x2A) = 0; + *(u16 *)((s32)s0 + 0x2C) += 1; + } + break; + } + + case 1: + *(u16 *)((s32)s0 + 0x2A) += 0x40; + *(s16 *)(*(s32 *)((s32)s0 + 0x20) + 0x18) = + (func_8004787C(*(s16 *)((s32)s0 + 0x2A)) >> 5) + 0x400; + *(s16 *)(*(s32 *)((s32)s0 + 0x20) + 0x1A) = + (func_8004787C(*(s16 *)((s32)s0 + 0x2A) + 0x800) >> 5) + 0x400; + break; + } +} + +--- func_801A8990 (src/md_SC07_004/md_SC07_004.c:5858) shares 1: func_8004787C --- +void func_801A8990(void *a0) +{ + extern void func_80049CAC(s32 a0, s32 a1); + extern void func_8004914C(void *a0); + extern void func_800491AC(void *a0); + extern s32 func_8004787C(s32 a0); + extern void RotTransSV(s32 a0, s32 a1, void *a2); + + SV_801A8990 vec; /* sp+0x10 */ + MTX_801A8990 mtx; /* sp+0x18 */ + MTX_801A8990 *mp; + s32 flag[3]; /* sp+0x38 */ + s32 v1; + s32 prod; + + mp = &mtx; + func_80049CAC(*(s32 *)((s32)a0 + 0x20) + 0x10, (s32)mp); + + mtx.t[0] = *(s16 *)((s32)a0 + 0x104); + mtx.t[1] = *(s16 *)((s32)a0 + 0x106); + mtx.t[2] = *(s16 *)((s32)a0 + 0x108); + + func_8004914C(mp); + func_800491AC(mp); + + vec.vy = 0; + vec.vx = 0; + + prod = func_8004787C(*(s16 *)((s32)a0 + 0x100)); + v1 = *(s16 *)((s32)a0 + 0xFE); + vec.vz = v1 + ((v1 * prod) >> 15); + + RotTransSV((s32)&vec, (s32)&vec, &flag[0]); + + *(s16 *)((s32)a0 + 0x6) = vec.vx; + *(s16 *)((s32)a0 + 0xA) = vec.vy; + *(s16 *)((s32)a0 + 0xE) = vec.vz; +} + +--- func_801AAF8C (src/md_SC07_004/md_SC07_004.c:7564) shares 1: func_8004787C --- +s32 func_801AAF8C(SV_801AAF8C *src, SV_801AAF8C *ofs, s32 arg2) +{ + MTX_801AAF8C mtx; /* sp+0x18 */ + SV_801AAF8C rot; /* sp+0x38 */ + SV_801AAF8C pos; /* sp+0x40 */ + SV_801AAF8C sv; /* sp+0x48 */ + s32 flag; /* sp+0x50 */ + s32 dx, dy, dz; + s32 ang; + s32 s; + s32 t; + + pos = *src; + if (ofs != 0) { + pos.vx += ofs->vx; + pos.vy += ofs->vy; + pos.vz += ofs->vz; + } + + dz = D_80126B66 - pos.vz; + dx = D_80126B5E - pos.vx; + t = pos.vy + 0x20; + dy = D_80126B62 - t; + + ang = (ratan2(-dz, dx) - 0x400) & 0xFFF; + rot.vy = ang; + s = func_80047948(ang); + dz = (dz * s + dx * func_8004787C(rot.vy)) >> 12; + rot.vx = ratan2(dy, -dz); + rot.vz = 0; + func_80049CAC((s32)&rot, (s32)&mtx); + + func_8004914C(&mtx); + mtx.t[0] = pos.vx; + mtx.t[1] = pos.vy; + mtx.t[2] = pos.vz; + func_800491AC(&mtx); + + sv.vy = 0; + sv.vx = 0; + sv.vz = -arg2; + RotTransSV((s32)&sv, (s32)&sv, &flag); + + if (func_80135888((s32)D_80126B78, (s32)D_80126B90, (s32)&pos, (s32)&sv) != 0) { + func_8012F568(1, 1, 0, 0xA, (s32)&sv, (s32)D_801152A8); + return 1; + } + return 0; +} + diff --git a/.run/P36/agents/md_SC07_004__func_801A5C44/residual.txt b/.run/P36/agents/md_SC07_004__func_801A5C44/residual.txt new file mode 100644 index 000000000..f1dbce887 --- /dev/null +++ b/.run/P36/agents/md_SC07_004__func_801A5C44/residual.txt @@ -0,0 +1,26 @@ +src/md_SC07_004/md_SC07_004.c:func_801A5C44: score 15 (COUNT; mine 40 ins, target 41) — not yet + register pairs (mine -> target, count): s2->s0 x5, s0->s1 x2, s1->s2 x2 + insert mine[1:1] target[1:3] + 1 -- | sw s0,16(sp) + 2 -- | move s0,a0 + replace mine[4:8] target[6:9] + 4 sw s0,16(sp) | lh a0,256(s0) + 5 lh a0,256(s2) | lw s2,204(s0) + 6 lw s1,204(s2) | lw s1,212(s0) + 7 lw s0,212(s2) | -- + replace mine[10:11] target[11:12] + 10 lh v1,112(s2) | lh v1,112(s0) + replace mine[13:14] target[14:15] + 13 addu v1,v1,s0 | addu v1,v1,s1 + replace mine[17:19] target[18:20] + 17 sh v1,24(s1) | sh v1,24(s2) + 18 lh a0,256(s2) | lh a0,256(s0) + replace mine[21:22] target[22:23] + 21 lh v1,112(s2) | lh v1,112(s0) + replace mine[24:25] target[25:26] + 24 addu v1,v1,s0 | addu v1,v1,s1 + replace mine[28:30] target[29:31] + 28 sh v1,26(s1) | sh v1,26(s2) + 29 lhu v0,256(s2) | lhu v0,256(s0) + replace mine[32:33] target[33:34] + 32 sh v0,256(s2) | sh v0,256(s0) diff --git a/.run/P36/agents/md_SC07_004__func_801A5C44/sites.txt b/.run/P36/agents/md_SC07_004__func_801A5C44/sites.txt new file mode 100644 index 000000000..047a4944c --- /dev/null +++ b/.run/P36/agents/md_SC07_004__func_801A5C44/sites.txt @@ -0,0 +1 @@ +NEEDED pin $4 line 3901 diff --git a/.run/P36/agents/md_SC07_004__func_801A5C44/tu.txt b/.run/P36/agents/md_SC07_004__func_801A5C44/tu.txt new file mode 100644 index 000000000..c9334c519 --- /dev/null +++ b/.run/P36/agents/md_SC07_004__func_801A5C44/tu.txt @@ -0,0 +1,2 @@ +src/md_SC07_004/md_SC07_004.c +func_801A5C44 diff --git a/.run/P36/agents/md_SC07_004__func_801AB818/body_free.c b/.run/P36/agents/md_SC07_004__func_801AB818/body_free.c new file mode 100644 index 000000000..40daecd13 --- /dev/null +++ b/.run/P36/agents/md_SC07_004__func_801AB818/body_free.c @@ -0,0 +1,27 @@ +void func_801AB818(void *a0) { + u8 *s1 = *(u8 **)((s32)a0 + 0x24); + + if (*(s32 *)((s32)a0 + 0x1C) != 0) { + U16x2N tmp; + s32 cur; + s32 addend; + + *(s32 *)((s32)a0 + 0x1C) -= 1; + func_801A8440((s32)a0); + + *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x18) -= 0x370; + *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x1A) = *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x18); + + cur = *(s32 *)(s1 + 0); + addend = *(s32 *)((s32)a0 + 0x30); + *(s32 *)&tmp = cur; + /* §22-ADDENDUM: a plain memory clobber, not `volatile`. It defeats + * flow.c's last_mem_set dead-store rule so the FIRST store to the + * temp survives, without pinning either store's schedule. Without + * it the target's `sw $v0,0x10($sp)` at idx 24 is deleted. */ + *(s32 *)&tmp = cur + addend; + *(U16x2N *)(s1 + 0) = tmp; + } else { + func_801292C8((u8 *)a0); + } +} diff --git a/.run/P36/agents/md_SC07_004__func_801AB818/body_tree.c b/.run/P36/agents/md_SC07_004__func_801AB818/body_tree.c new file mode 100644 index 000000000..f093236f0 --- /dev/null +++ b/.run/P36/agents/md_SC07_004__func_801AB818/body_tree.c @@ -0,0 +1,28 @@ +void func_801AB818(void *a0) { + u8 *s1 = *(u8 **)((s32)a0 + 0x24); + + if (*(s32 *)((s32)a0 + 0x1C) != 0) { + U16x2N tmp; + s32 cur; + s32 addend; + + *(s32 *)((s32)a0 + 0x1C) -= 1; + func_801A8440((s32)a0); + + *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x18) -= 0x370; + *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x1A) = *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x18); + + cur = *(s32 *)(s1 + 0); + addend = *(s32 *)((s32)a0 + 0x30); + *(s32 *)&tmp = cur; + /* §22-ADDENDUM: a plain memory clobber, not `volatile`. It defeats + * flow.c's last_mem_set dead-store rule so the FIRST store to the + * temp survives, without pinning either store's schedule. Without + * it the target's `sw $v0,0x10($sp)` at idx 24 is deleted. */ + __asm__("" ::: "memory"); // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus9) + *(s32 *)&tmp = cur + addend; + *(U16x2N *)(s1 + 0) = tmp; + } else { + func_801292C8((u8 *)a0); + } +} diff --git a/.run/P36/agents/md_SC07_004__func_801AB818/history.txt b/.run/P36/agents/md_SC07_004__func_801AB818/history.txt new file mode 100644 index 000000000..4fafcc8a8 --- /dev/null +++ b/.run/P36/agents/md_SC07_004__func_801AB818/history.txt @@ -0,0 +1,14 @@ +s5: verdict NO-MATCH start 1 best 1 compiles 191 path +best-scoring single candidates of the last trace (move -> score [residual class]): + R7 block @7975 -> 1 [OTHER] (from 1) + R8 temp tmp0 @7975 -> 1 [OTHER] (from 1) + R10 param-copy a0 @7962 -> 1 [OTHER] (from 1) + R8 base tmp0 @7975 -> 1 [OTHER] (from 1) + R7 block @7974 -> 1 [OTHER] (from 1) + R8 temp tmp0 @7974 -> 1 [OTHER] (from 1) + R7 do-while @7974 -> 1 [OTHER] (from 1) + R8 base tmp0 @7974 -> 1 [OTHER] (from 1) + R18 bystander @7969->7971 -> 1 [OTHER] (from 1) + R7 block @7976 -> 1 [OTHER] (from 1) + R8 base-shared tmp0 @7974 -> 1 [OTHER] (from 1) + R7 do-while @7976 -> 1 [OTHER] (from 1) diff --git a/.run/P36/agents/md_SC07_004__func_801AB818/neighbours.txt b/.run/P36/agents/md_SC07_004__func_801AB818/neighbours.txt new file mode 100644 index 000000000..02091e67b --- /dev/null +++ b/.run/P36/agents/md_SC07_004__func_801AB818/neighbours.txt @@ -0,0 +1,3 @@ +--- every @class/@stuck/@crack note in this translation unit --- +// @class: loose-typing +// @stuck: none — MATCH (99 ins). short* for param_2/param_3: gcc emits lh where sign is live (<<1 for signed div), lhu where truncated to short (arith result / direct copy) diff --git a/.run/P36/agents/md_SC07_004__func_801AB818/related.txt b/.run/P36/agents/md_SC07_004__func_801AB818/related.txt new file mode 100644 index 000000000..43d334ab0 --- /dev/null +++ b/.run/P36/agents/md_SC07_004__func_801AB818/related.txt @@ -0,0 +1,148 @@ +=== lever-free bodies in md_SC07_004 sharing a callee or global with func_801AB818 (14 found; top 6 by shared symbols) — read them for the SHAPE === +--- func_801AC234 (src/md_SC07_004/md_SC07_004.c:8407) shares 1: func_801292C8 --- +void func_801AC234(void *a0) +{ + extern void func_801292C8(u8 *a0); + extern void func_8012931C(struct vec *a0); + + func_8012931C((struct vec *)a0); + if (func_80128ED8(*(s32 *)((char *)a0 + 0x20), (s32 *)((char *)a0 + 0x24)) != 0 || + (*(s16 *)((char *)a0 + 0x2C) != 2 && *(s16 *)((char *)a0 + 0xA) >= -0x200)) { + func_801292C8((u8 *)a0); + } +} + +--- func_801A72DC (src/md_SC07_004/md_SC07_004.c:4857) shares 1: func_801292C8 --- +void func_801A72DC(void *a0) +{ + extern void func_801292C8(u8 *a0); + extern void func_8012931C(struct vec *a0); + + s32 v0; + + v0 = *(u16 *)((s32)a0 + 0x2C) + 1; + *(u16 *)((s32)a0 + 0x2C) = v0; + if ((s16)v0 >= 4) { + func_801292C8((u8 *)a0); + return; + } + func_8012931C((struct vec *)a0); + *(s32 *)(*(s32 *)((s32)a0 + 0x20) + 0x20) = + (s32)D_801F8744 + (*(s16 *)((s32)a0 + 0x2C) << 6); +} + +--- func_801AC940 (src/md_SC07_004/md_SC07_004.c:8702) shares 1: func_801292C8 --- +void func_801AC940(s32 arg0) +{ + extern void func_801292C8(u8 *a0); + extern void func_8012931C(struct vec *a0); + + s32 a1 = arg0; + s32 v0; + s16 v1; + + v0 = *(s32 *)(a1 + 0x1C); + if (v0 == 0) { + func_801292C8((u8 *)a1); + return; + } + v0 = v0 - 1; + *(s32 *)(a1 + 0x1C) = v0; + if ((v0 & 3) == 0 && *(s16 *)(a1 + 0x2C) < 3) { + v1 = *(s16 *)(a1 + 0x2C); + v1 = v1 + 1; + *(s16 *)(a1 + 0x2C) = v1; + *(s32 *)(*(s32 *)(a1 + 0x20) + 0x20) = (s32)&D_801F88B8 + (v1 << 6); + } + func_8012931C((struct vec *)a1); +} + +--- func_801AE520 (src/md_SC07_004/md_SC07_004.c:10070) shares 1: func_801292C8 --- +void func_801AE520(void *a0) { + u8 *s1 = D_801F8D98 + ((*(u16 *)((s32)a0 + 0x2E) & 3) << 6); + + if (*(s32 *)((s32)a0 + 0x1C) != 0) { + U16x2L tmp; + + *(s32 *)((s32)a0 + 0x1C) -= 1; + func_801AD55C(a0); + + *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x18) += 0x700; + *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x1A) = *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x18); + *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x14) += 0x60; + + *(s32 *)&tmp = *(s32 *)(s1 + 0); + *(s32 *)&tmp -= D_801B07FC[0]; + *(U16x2L *)(s1 + 0) = tmp; + + *(s32 *)&tmp = *(s32 *)(s1 + 4); + *(s32 *)&tmp -= D_801B0800[0]; + *(U16x2L *)(s1 + 4) = tmp; + + } else { + func_801292C8((u8 *)a0); + } +} + +--- func_801ACA88 (src/md_SC07_004/md_SC07_004.c:8764) shares 1: func_801292C8 --- +void func_801ACA88(void *a0) +{ + extern void func_801292C8(u8 *a0); + extern void func_8012931C(struct vec *a0); + extern void func_8017E5D4(void *a0); + extern void func_8017E1E8(void *a0, void *a1, void *a2); + + s16 buf[4]; + s32 v0; + + v0 = *(s32 *)((s32)a0 + 0x1C); + if (v0 == 0) { + if (*(void **)((s32)a0 + 0x2C) != NULL) { + func_8017E5D4(*(void **)((s32)a0 + 0x2C)); + } + func_801292C8((u8 *)a0); + } else { + *(s32 *)((s32)a0 + 0x1C) = v0 - 1; + func_8012931C((struct vec *)a0); + + buf[0] = *(u16 *)((s32)a0 + 0x6); + buf[1] = *(u16 *)((s32)a0 + 0xA); + buf[2] = *(u16 *)((s32)a0 + 0xE); + + if (*(void **)((s32)a0 + 0x2C) != NULL) { + func_8017E1E8(*(void **)((s32)a0 + 0x2C), &buf[0], NULL); + } + } +} + +--- func_801AF1EC (src/md_SC07_004/md_SC07_004.c:10596) shares 1: func_801292C8 --- +void func_801AF1EC(void *a0) { + if (*(u16 *)((s32)a0 + 0x2) == 0) { + func_801AF2EC(a0); + return; + } + + if (*(s32 *)((s32)a0 + 0x1C) != 0) { + *(s32 *)((s32)a0 + 0x1C) -= 1; + func_8012931C((struct vec *)a0); + + if (*(s16 *)((s32)a0 + 0x32) == 0) { + u16 t = *(u16 *)((s32)a0 + 0xA) + 0x1000; + if (t >= 0x1001) { + func_801292C8((u8 *)a0); + return; + } + } + } else { + func_801292C8((u8 *)a0); + return; + } + + *(s32 *)((s32)a0 + 0x14) += *(s32 *)((s32)a0 + 0x34); + *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x14) += *(u16 *)((s32)a0 + 0x30); + *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x8) = *(u16 *)((s32)a0 + 0x6); + *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0xA) = *(u16 *)((s32)a0 + 0xA); + *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0xC) = *(u16 *)((s32)a0 + 0xE); + func_801AF368((void *)*(s32 *)((s32)a0 + 0x20)); +} + diff --git a/.run/P36/agents/md_SC07_004__func_801AB818/residual.txt b/.run/P36/agents/md_SC07_004__func_801AB818/residual.txt new file mode 100644 index 000000000..a3691f216 --- /dev/null +++ b/.run/P36/agents/md_SC07_004__func_801AB818/residual.txt @@ -0,0 +1,3 @@ +src/md_SC07_004/md_SC07_004.c:func_801AB818: score 1 (OTHER; mine 42 ins, target 42) — not yet + replace mine[24:25] target[24:25] + 24 nop | sw v0,16(sp) diff --git a/.run/P36/agents/md_SC07_004__func_801AB818/sites.txt b/.run/P36/agents/md_SC07_004__func_801AB818/sites.txt new file mode 100644 index 000000000..98921ea6c --- /dev/null +++ b/.run/P36/agents/md_SC07_004__func_801AB818/sites.txt @@ -0,0 +1 @@ +NEEDED barrier memory line 8002 diff --git a/.run/P36/agents/md_SC07_004__func_801AB818/tu.txt b/.run/P36/agents/md_SC07_004__func_801AB818/tu.txt new file mode 100644 index 000000000..59c61343f --- /dev/null +++ b/.run/P36/agents/md_SC07_004__func_801AB818/tu.txt @@ -0,0 +1,2 @@ +src/md_SC07_004/md_SC07_004.c +func_801AB818 diff --git a/.run/P36/agents/ov_SC02_017__func_80183B9C/body.c b/.run/P36/agents/ov_SC02_017__func_80183B9C/body.c new file mode 100644 index 000000000..3a03f35e2 --- /dev/null +++ b/.run/P36/agents/ov_SC02_017__func_80183B9C/body.c @@ -0,0 +1,23 @@ +void func_80183B9C(u8 *arg0) { + extern int func_80178970(void); + extern void func_80178D18(void); + extern void func_8017F644(void); + extern s32 D_801270C8; + extern s32 D_801EF9F8; + extern void func_8002D4C8(s32 a0, s32 a1); + extern void func_801836A8(void*); + + D_801270C8 = 1; + if (*(u16 *)(arg0 + 0x34) == 0) { + if (((s32 (*)(u8 *))func_80178970)(arg0) != 0) { + ((void (*)(s32))func_80178D18)((s32)arg0); + if (D_801EF9F8 != 0) { + func_8017F644(); + } + *(u16 *)(arg0 + 0x34) = 1; + } + } else { + func_8002D4C8(0x13, 0); + ((s32 (*)(u8 *))func_801836A8)(arg0); + } +} diff --git a/.run/P36/agents/ov_SC02_017__func_80183B9C/body_free.c b/.run/P36/agents/ov_SC02_017__func_80183B9C/body_free.c new file mode 100644 index 000000000..0311e709a --- /dev/null +++ b/.run/P36/agents/ov_SC02_017__func_80183B9C/body_free.c @@ -0,0 +1,23 @@ +void func_80183B9C(u8 *arg0) { + extern int func_80178970(void); + extern void func_80178D18(void); + extern void func_8017F644(void); + extern s32 D_801270C8; + extern s32 D_801EF9F8; + extern void func_8002D4C8(s32 a0, s32 a1); + extern void func_801836A8(void*); + + D_801270C8 = 1; + if (*(u16 *)(arg0 + 0x34) == 0) { + if (func_80178970() != 0) { + ((void (*)(s32))func_80178D18)((s32)arg0); + if (D_801EF9F8 != 0) { + func_8017F644(); + } + *(u16 *)(arg0 + 0x34) = 1; + } + } else { + func_8002D4C8(0x13, 0); + ((s32 (*)(u8 *))func_801836A8)(arg0); + } +} diff --git a/.run/P36/agents/ov_SC02_017__func_80183B9C/body_tree.c b/.run/P36/agents/ov_SC02_017__func_80183B9C/body_tree.c new file mode 100644 index 000000000..11e85979d --- /dev/null +++ b/.run/P36/agents/ov_SC02_017__func_80183B9C/body_tree.c @@ -0,0 +1,24 @@ +void func_80183B9C(u8 *arg0) { + extern int func_80178970(void); + extern void func_80178D18(void); + extern void func_8017F644(void); + extern s32 D_801270C8; + extern s32 D_801EF9F8; + extern void func_8002D4C8(s32 a0, s32 a1); + extern void func_801836A8(void*); + + D_801270C8 = 1; + if (*(u16 *)(arg0 + 0x34) == 0) { + if (func_80178970() != 0) { + ((void (*)(s32))func_80178D18)((s32)arg0); + if (D_801EF9F8 != 0) { + func_8017F644(); + } + *(u16 *)(arg0 + 0x34) = 1; + } + } else { + __asm__ __volatile__(""); // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus8) + func_8002D4C8(0x13, 0); + ((s32 (*)(u8 *))func_801836A8)(arg0); + } +} diff --git a/.run/P36/agents/ov_SC02_017__func_80183B9C/history.txt b/.run/P36/agents/ov_SC02_017__func_80183B9C/history.txt new file mode 100644 index 000000000..3ab1c3062 --- /dev/null +++ b/.run/P36/agents/ov_SC02_017__func_80183B9C/history.txt @@ -0,0 +1,14 @@ +s5: verdict NO-MATCH start 4 best 4 compiles 50 path +best-scoring single candidates of the last trace (move -> score [residual class]): + R7 block @6515 -> 4 [COUNT] (from 4) + R9 swap-stmts @6518 -> 4 [ORDER] (from 4) + R7 do-while @6515 -> 4 [COUNT] (from 4) + R7 block @6508 -> 4 [COUNT] (from 4) + R7 block @6513 -> 4 [COUNT] (from 4) + R7 do-while @6513 -> 4 [COUNT] (from 4) + R7 block @6518 -> 4 [COUNT] (from 4) + R7 do-while @6518 -> 4 [COUNT] (from 4) + R7 block @6511 -> 4 [COUNT] (from 4) + R7 do-while @6511 -> 4 [COUNT] (from 4) + R7 block @6519 -> 4 [COUNT] (from 4) + R7 do-while @6519 -> 4 [COUNT] (from 4) diff --git a/.run/P36/agents/ov_SC02_017__func_80183B9C/neighbours.txt b/.run/P36/agents/ov_SC02_017__func_80183B9C/neighbours.txt new file mode 100644 index 000000000..20b5a229a --- /dev/null +++ b/.run/P36/agents/ov_SC02_017__func_80183B9C/neighbours.txt @@ -0,0 +1,15 @@ +--- every @class/@stuck/@crack note in this translation unit --- +// @class: struct +// @stuck: none — MATCH (array-of-fnptr %lo-fold + signed-halfword guard) +// @class: struct +// @stuck: none — MATCH (array-of-fnptr %lo-fold + signed-halfword guard) +// @class: struct +// @stuck: none — MATCH (array-of-fnptr %lo-fold + signed-halfword guard) +// @class: straight-derive +// @stuck: none — MATCH (52 ins) on iteration 1, confirmed by rtu_match. +// @class: structural (STRENGTH/mflo!=lw -> MATCH) +// @stuck: none - MATCH (41 ins), match_one + rtu_match. +// @class: regalloc (WIDTH/li!=addu -> MATCH) +// @stuck: none — MATCH (58 ins), match_one + rtu_match. PIN-FREE (no register __asm__). +// @class: plumbing +// @stuck: none — MATCH (52 ins), iteration 1. Keys: (1) §3-T4 — Ghidra inverted the arms; the diff --git a/.run/P36/agents/ov_SC02_017__func_80183B9C/related.txt b/.run/P36/agents/ov_SC02_017__func_80183B9C/related.txt new file mode 100644 index 000000000..97d70ce62 --- /dev/null +++ b/.run/P36/agents/ov_SC02_017__func_80183B9C/related.txt @@ -0,0 +1,76 @@ +=== lever-free bodies in ov_SC02_017 sharing a callee or global with func_80183B9C (53 found; top 6 by shared symbols) — read them for the SHAPE === +--- func_80181250 (src/ov_SC02_017/ov_SC02_017_jr_8017DF34.c:4694) shares 2: func_80178970 func_80178D18 --- +void func_80181250(void *arg0) { + if (func_80178970() == 1) { + ((void (*)(void *))func_80178D18)(arg0); + *(s16 *)((s32)arg0 + 2) = 3; + } +} + +--- func_8017D058 (src/shared/ov/func_8017D058__2a8e3f10.h:3) shares 2: func_80178970 func_80178D18 --- +void func_8017D058(s32 a0) { + extern int func_80178970(void); + extern void func_80178D18(void); + s32 rand_val = rand(); + + func_8017C294(a0, rand_val & 0xF); + if (((s32 (*)(s32))func_80178970)(a0) == 0) { + return; + } + ((void (*)(s32))func_80178D18)(a0); + *(s16 *)(a0 + 0x2) = 1; +} + +--- func_80183940 (src/ov_SC02_017/ov_SC02_017_jr_8017DF34.c:6369) shares 2: D_801EF9F8 func_8002D4C8 --- +void func_80183940(s32 a0) { + extern s32 D_8018EE50; + extern s32 D_801EF9F8; + extern void func_80178CBC(s32 a0, s32 a1); + extern void func_8002D4C8(s32 a0, s32 a1); + + *(s16 *)(a0 + 0x2) = 3; + *(s16 *)(a0 + 0x34) = 0; + func_80178CBC(a0, (s32)&D_8018EE50); + D_801EF9F8 = 0; + func_8002D4C8(0x12, 0); +} + +--- func_801833FC (src/ov_SC02_017/ov_SC02_017_jr_8017DF34.c:6126) shares 2: func_80178970 func_80178D18 --- +void func_801833FC(s32 arg0) { + s32 var_s1; + + var_s1 = func_80029504(); + ((s32 (*)(s32 *, s32, s32))func_8018347C)((s32 *)arg0, 0x190, 0); + if (((s32 (*)(s32))func_80178970)(arg0) == 0) { + return; + } + ((void (*)(s32))func_80178D18)(arg0); + if (var_s1 < 0x10E) { + func_80029514(0x10E); + } + *(u16 *)((s32)arg0 + 0x2) -= 1; +} + +--- func_8017CFAC (src/ov_SC02_017/ov_SC02_017_jr_8017AE2C.c:4026) shares 2: func_80178970 func_80178D18 --- +void func_8017CFAC(s32 a0) { + extern void func_8002955C(void); + extern s32 func_8002953C(void); + extern void func_8002AC00(s32 arg0); + u8 *p = *(u8 **)(a0 + 0xDC); + + if (func_80178970() != 0) { + ((void (*)(s32))func_80178D18)(a0); + func_800291A0(*p + 0x3A, 1); + func_8002955C(); + if ((u32)func_8002953C() >= 0x23U) { + func_8002AC00(0x25); + } + *(u16 *)(a0 + 2) += 1; + } +} + +--- func_80186100 (src/ov_SC02_017/ov_SC02_017_jr_8017DF34.c:8269) shares 1: func_8002D4C8 --- + void func_80186100(void) { + func_8002D4C8(0x6AA, 0); + } + diff --git a/.run/P36/agents/ov_SC02_017__func_80183B9C/residual.txt b/.run/P36/agents/ov_SC02_017__func_80183B9C/residual.txt new file mode 100644 index 000000000..c16e2ee18 --- /dev/null +++ b/.run/P36/agents/ov_SC02_017__func_80183B9C/residual.txt @@ -0,0 +1,9 @@ +src/ov_SC02_017/ov_SC02_017_jr_8017DF34.c:func_80183B9C: score 4 (COUNT; mine 36 ins, target 37) — not yet + replace mine[10:11] target[10:11] + 10 li a0,19 | nop + replace mine[13:14] target[13:14] + 13 beqz v0,5ce4 | beqz v0,5ce8 + replace mine[25:26] target[25:26] + 25 j 5ce4 | j 5ce8 + insert mine[27:27] target[27:28] + 27 -- | li a0,19 diff --git a/.run/P36/agents/ov_SC02_017__func_80183B9C/sites.txt b/.run/P36/agents/ov_SC02_017__func_80183B9C/sites.txt new file mode 100644 index 000000000..995ef6d52 --- /dev/null +++ b/.run/P36/agents/ov_SC02_017__func_80183B9C/sites.txt @@ -0,0 +1 @@ +NEEDED barrier line 6715 diff --git a/.run/P36/agents/ov_SC02_017__func_80183B9C/tu.txt b/.run/P36/agents/ov_SC02_017__func_80183B9C/tu.txt new file mode 100644 index 000000000..51602bd2f --- /dev/null +++ b/.run/P36/agents/ov_SC02_017__func_80183B9C/tu.txt @@ -0,0 +1,2 @@ +src/ov_SC02_017/ov_SC02_017_jr_8017DF34.c +func_80183B9C diff --git a/.run/P36/agents/ov_SC02_017__func_80184754/body_free.c b/.run/P36/agents/ov_SC02_017__func_80184754/body_free.c new file mode 100644 index 000000000..10839f202 --- /dev/null +++ b/.run/P36/agents/ov_SC02_017__func_80184754/body_free.c @@ -0,0 +1,26 @@ +void func_80184754(void *a0) +{ + s32 s0 = (s32)a0; + s32 s1; + + + s1 = *(s32 *)(s0 + 0x64); + + if (*(s16 *)(s0 + 0xFC) != *(s16 *)(s1 + 0x36)) { + ((void (*)(void))func_8012C218)(); + return; + } + + if (*(s32 *)(s1 + 0x1C) == 0) { + func_80132288(&D_801EFA68, &D_801CC38C, D_801CCE84); + } else { + *(s32 *)(s0 + 0x4) = *(s32 *)(s1 + 0x4); + *(s32 *)(s0 + 0x8) = *(s32 *)(s1 + 0x8); + *(s32 *)(s0 + 0xC) = *(s32 *)(s1 + 0xC); + *(SV4x_80184754 *)(*(s32 *)(s0 + 0x20) + 0x10) = *(SV4x_80184754 *)(*(s32 *)(s1 + 0x20) + 0x10); + *(SV4x_80184754 *)(*(s32 *)(s0 + 0x20) + 0x18) = *(SV4x_80184754 *)(*(s32 *)(s1 + 0x20) + 0x18); + *(u16 *)(*(s32 *)(s0 + 0x20) + 0x2C) = *(u16 *)(*(s32 *)(s1 + 0x20) + 0x2C); + *(s32 *)(*(s32 *)(s0 + 0x20) + 0x4) = *(s32 *)(*(s32 *)(s1 + 0x20) + 0x4); + func_8013240C((s32)&D_801EFA68); + } +} diff --git a/.run/P36/agents/ov_SC02_017__func_80184754/body_tree.c b/.run/P36/agents/ov_SC02_017__func_80184754/body_tree.c new file mode 100644 index 000000000..5e747b2b9 --- /dev/null +++ b/.run/P36/agents/ov_SC02_017__func_80184754/body_tree.c @@ -0,0 +1,27 @@ +void func_80184754(void *a0) +{ + s32 s0 = (s32)a0; + s32 s1; + + __asm__ __volatile__("" : "=r"(s0) : "0"(s0)); // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus8) + + s1 = *(s32 *)(s0 + 0x64); + + if (*(s16 *)(s0 + 0xFC) != *(s16 *)(s1 + 0x36)) { + ((void (*)(void))func_8012C218)(); + return; + } + + if (*(s32 *)(s1 + 0x1C) == 0) { + func_80132288(&D_801EFA68, &D_801CC38C, D_801CCE84); + } else { + *(s32 *)(s0 + 0x4) = *(s32 *)(s1 + 0x4); + *(s32 *)(s0 + 0x8) = *(s32 *)(s1 + 0x8); + *(s32 *)(s0 + 0xC) = *(s32 *)(s1 + 0xC); + *(SV4x_80184754 *)(*(s32 *)(s0 + 0x20) + 0x10) = *(SV4x_80184754 *)(*(s32 *)(s1 + 0x20) + 0x10); + *(SV4x_80184754 *)(*(s32 *)(s0 + 0x20) + 0x18) = *(SV4x_80184754 *)(*(s32 *)(s1 + 0x20) + 0x18); + *(u16 *)(*(s32 *)(s0 + 0x20) + 0x2C) = *(u16 *)(*(s32 *)(s1 + 0x20) + 0x2C); + *(s32 *)(*(s32 *)(s0 + 0x20) + 0x4) = *(s32 *)(*(s32 *)(s1 + 0x20) + 0x4); + func_8013240C((s32)&D_801EFA68); + } +} diff --git a/.run/P36/agents/ov_SC02_017__func_80184754/history.txt b/.run/P36/agents/ov_SC02_017__func_80184754/history.txt new file mode 100644 index 000000000..92166b47b --- /dev/null +++ b/.run/P36/agents/ov_SC02_017__func_80184754/history.txt @@ -0,0 +1,14 @@ +s5: verdict NO-MATCH start 22 best 8 compiles 184 path R7 do-while @7124 +best-scoring single candidates of the last trace (move -> score [residual class]): + R7 do-while @7124 -> 8 [COUNT] (from 22) + R7 block @7122 -> 8 [COUNT] (from 8) + R8 base-shared tmp0 @7122 -> 8 [COUNT] (from 8) + R7 block @7123 -> 8 [COUNT] (from 8) + R7 do-while @7123 -> 8 [COUNT] (from 8) + R7 block @7125 -> 8 [COUNT] (from 8) + R7 do-while @7125 -> 8 [COUNT] (from 8) + R7 block @7112 -> 8 [COUNT] (from 8) + R8 temp tmp0 @7121 -> 8 [COUNT] (from 8) + R7 do-while @7112 -> 8 [COUNT] (from 8) + R8 base tmp0 @7121 -> 8 [COUNT] (from 8) + R7 block @7121 -> 8 [COUNT] (from 8) diff --git a/.run/P36/agents/ov_SC02_017__func_80184754/neighbours.txt b/.run/P36/agents/ov_SC02_017__func_80184754/neighbours.txt new file mode 100644 index 000000000..20b5a229a --- /dev/null +++ b/.run/P36/agents/ov_SC02_017__func_80184754/neighbours.txt @@ -0,0 +1,15 @@ +--- every @class/@stuck/@crack note in this translation unit --- +// @class: struct +// @stuck: none — MATCH (array-of-fnptr %lo-fold + signed-halfword guard) +// @class: struct +// @stuck: none — MATCH (array-of-fnptr %lo-fold + signed-halfword guard) +// @class: struct +// @stuck: none — MATCH (array-of-fnptr %lo-fold + signed-halfword guard) +// @class: straight-derive +// @stuck: none — MATCH (52 ins) on iteration 1, confirmed by rtu_match. +// @class: structural (STRENGTH/mflo!=lw -> MATCH) +// @stuck: none - MATCH (41 ins), match_one + rtu_match. +// @class: regalloc (WIDTH/li!=addu -> MATCH) +// @stuck: none — MATCH (58 ins), match_one + rtu_match. PIN-FREE (no register __asm__). +// @class: plumbing +// @stuck: none — MATCH (52 ins), iteration 1. Keys: (1) §3-T4 — Ghidra inverted the arms; the diff --git a/.run/P36/agents/ov_SC02_017__func_80184754/related.txt b/.run/P36/agents/ov_SC02_017__func_80184754/related.txt new file mode 100644 index 000000000..75a139e88 --- /dev/null +++ b/.run/P36/agents/ov_SC02_017__func_80184754/related.txt @@ -0,0 +1,61 @@ +=== lever-free bodies in ov_SC02_017 sharing a callee or global with func_80184754 (34 found; top 6 by shared symbols) — read them for the SHAPE === +--- func_801846B8 (src/ov_SC02_017/ov_SC02_017_jr_8017DF34.c:7037) shares 4: D_801CC38C D_801CCE84 D_801EFA68 func_80132288 --- +void func_801846B8(void *arg0) +{ + s32 s1 = (s32)arg0; + s32 *p; + s32 v0; + + do { v0 = ((s32 (*)(void))func_8012C1B8)(); } while (0); + *(s32 *)(s1 + 0x20) = v0; + if (v0 == 0) { + ((void (*)(s32))func_8012CAE4)(s1); + } else { + p = &D_801CCE84; + ((void (*)(s32, s32))func_8001C214)(v0, (s32)p); + *(u16 *)(s1 + 0xFC) = *(u16 *)(*(s32 *)(s1 + 0x64) + 0x36); + *(u16 *)(s1 + 0x2) = 1; + ((void (*)(s32, void *))func_8012A828)(s1, aD8018A800); + ((void (*)(s32 *, s32 *, s32))func_80132288)(&D_801EFA68, &D_801CC38C, *p); + } +} + +--- func_8017D038 (src/ov_SC02_017/ov_SC02_017_jr_8017AE2C.c:4045) shares 1: func_8012C218 --- + void func_8017D038(void) { + ((void (*)(void))func_8012C218)(); + } + +--- func_80188F20 (src/ov_SC02_017/ov_SC02_017_jr_80186C64.c:4908) shares 1: func_8012C218 --- + s32 func_80188F20(void * arg0) + { + *(short *)((char *)arg0 + 0x2) = 2; + ((void (*)(s32 *))func_8012C218)(*(s32 **)((char *)arg0 + 0xcc)); + } + +--- func_801439C0 (src/shared/ov/func_801439C0.h:5) shares 1: func_8012C218 --- +void func_801439C0(u8 *a0) { + if (a0 != 0) { + func_80016714(*(void **)(a0 + 0xCC), 0x38); + func_8012C218(a0); + } +} + +--- func_80180590 (src/ov_SC02_017/ov_SC02_017_jr_8017DF34.c:4128) shares 1: func_8012C218 --- +void func_80180590(void *arg0) { + if (*(s32 *)((s32)arg0 + 0xCC) != 0) { + func_8012C218(*(void **)((s32)arg0 + 0xCC)); + } + func_8012C218(arg0); +} + +--- func_80142778 (src/shared/ov/func_80142778.h:4) shares 1: func_8012C218 --- +void func_80142778(u8 *a1) { + u8 *a0 = *(u8 **)(a1 + 0x20); + *(u16 *)(a0 + 0x18) = *(u16 *)(a0 + 0x18) - 0x800; + *(u16 *)(a0 + 0x1A) = *(u16 *)(a0 + 0x1A) - 0x800; + *(u16 *)(a1 + 0xA) = *(u16 *)(a1 + 0xA) + 0x10; + if (*(s16 *)(a0 + 0x18) <= 0) { + func_8012C218(a1); + } +} + diff --git a/.run/P36/agents/ov_SC02_017__func_80184754/residual.txt b/.run/P36/agents/ov_SC02_017__func_80184754/residual.txt new file mode 100644 index 000000000..bddcad95a --- /dev/null +++ b/.run/P36/agents/ov_SC02_017__func_80184754/residual.txt @@ -0,0 +1,36 @@ +src/ov_SC02_017/ov_SC02_017_jr_8017DF34.c:func_80184754: score 22 (COUNT; mine 72 ins, target 73) — not yet + register pairs (mine -> target, count): t0->t1 x10, t1->t0 x7, a0->t0 x2 + insert mine[1:1] target[1:2] + 1 -- | move t0,a0 + replace mine[2:5] target[3:6] + 2 lw t0,100(a0) | lw t1,100(t0) + 3 lh v1,252(a0) | lh v1,252(t0) + 4 lh v0,54(t0) | lh v0,54(t1) + replace mine[7:8] target[8:9] + 7 move t1,a0 | nop + replace mine[10:11] target[11:12] + 10 j 6930 | j 6934 + replace mine[12:13] target[13:14] + 12 lw v0,28(t0) | lw v0,28(t1) + replace mine[24:25] target[25:26] + 24 j 6930 | j 6934 + replace mine[26:30] target[27:31] + 26 lw v0,4(t0) | lw v0,4(t1) + 27 lw v1,32(t1) | lw v1,32(t0) + 28 sw v0,4(t1) | sw v0,4(t0) + 29 lw v0,8(t0) | lw v0,8(t1) + replace mine[31:33] target[32:34] + 31 sw v0,8(t1) | sw v0,8(t0) + 32 lw v0,12(t0) | lw v0,12(t1) + replace mine[34:36] target[35:37] + 34 sw v0,12(t1) | sw v0,12(t0) + 35 lw v0,32(t0) | lw v0,32(t1) + replace mine[45:47] target[46:48] + 45 lw v1,32(t1) | lw v1,32(t0) + 46 lw v0,32(t0) | lw v0,32(t1) + replace mine[56:58] target[57:59] + 56 lw v0,32(t0) | lw v0,32(t1) + 57 lw v1,32(t1) | lw v1,32(t0) + replace mine[61:63] target[62:64] + 61 lw v0,32(t0) | lw v0,32(t1) + 62 lw v1,32(t1) | lw v1,32(t0) diff --git a/.run/P36/agents/ov_SC02_017__func_80184754/sites.txt b/.run/P36/agents/ov_SC02_017__func_80184754/sites.txt new file mode 100644 index 000000000..418ec36e2 --- /dev/null +++ b/.run/P36/agents/ov_SC02_017__func_80184754/sites.txt @@ -0,0 +1 @@ +NEEDED launder line 7305 diff --git a/.run/P36/agents/ov_SC02_017__func_80184754/tu.txt b/.run/P36/agents/ov_SC02_017__func_80184754/tu.txt new file mode 100644 index 000000000..7093f97a2 --- /dev/null +++ b/.run/P36/agents/ov_SC02_017__func_80184754/tu.txt @@ -0,0 +1,2 @@ +src/ov_SC02_017/ov_SC02_017_jr_8017DF34.c +func_80184754 diff --git a/.run/P36/agents/ov_SC02_017__func_80186770/body_free.c b/.run/P36/agents/ov_SC02_017__func_80186770/body_free.c new file mode 100644 index 000000000..81fc27fbf --- /dev/null +++ b/.run/P36/agents/ov_SC02_017__func_80186770/body_free.c @@ -0,0 +1,109 @@ +void func_80186770(s32 param_1) +{ + struct { s32 vx, vy, vz, pad; } vec; + s32 v; + s32 d; + s32 b178arg; + void *target; + + switch (*(u16 *)(param_1 + 0x34)) { + case 0: + v = func_8012B8E4(param_1, 4); + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12) += v; + if (*(s32 *)(param_1 + 0x1C) == 0xF) { + func_80142414(param_1, -0x78); + func_8002D4C8(0x6A9, 0); + } + if (func_8012BEE8(param_1) != 0) { + *(s16 *)(param_1 + 0x2) = 3; + if ((*(u16 *)(param_1 + 0x86) & 2) != 0) { + *(s16 *)(param_1 + 0x34) = 1; + *(s32 *)(param_1 + 0x1C) = 0x28; + if ((*(u16 *)(param_1 + 0x70) & 0x200) != 0) { + func_8012A828(param_1, &D_801E1AFC); + } else { + func_8012A828(param_1, &D_801E11DC); + } + *(u16 *)(param_1 + 0xFE) = 0; + } else { + *(s16 *)(param_1 + 0x34) = 0; + func_8012A828(param_1, &D_801E1264); + *(s32 *)(param_1 + 0x1C) = 0x19; + *(u16 *)(param_1 + 0x86) |= 2; + } + } + break; + case 1: + v = func_8012B8E4(param_1, 6); + b178arg = D_801D619C; + { + u16 *pp; + s32 nv; + + pp = (u16 *)(*(s32 *)(param_1 + 0x20) + 0x12); + nv = *pp + v; + *pp = nv; + } + func_8012B178(param_1, b178arg); + d = ((s32 (*)(s32))func_8012CBA4)(param_1); + if ((d & 0x1000) != 0) { + func_80131E00(param_1, 0x12); + } else if (d != 0x2000) { + func_8012ADE4((u8 *)param_1); + } + func_80185F88(param_1); + v = *(u16 *)(param_1 + 0xFE) - 1; + *(u16 *)(param_1 + 0xFE) = v; + if ((v << 16) <= 0) { + func_80143B6C(param_1, 0); + *(u16 *)(param_1 + 0xFE) = 8; + } + if ((*(u16 *)(param_1 + 0x70) & 0x200) != 0) { + func_80186C38(param_1, 0x11); + } + target = (void *)(param_1 + 0x88); + vec.vx = *(s16 *)(param_1 + 6) - *(s16 *)(param_1 + 0x88); + vec.vy = 0; + vec.vz = *(s16 *)(param_1 + 0xE) - *(s16 *)(param_1 + 0x8C); + Square0(&vec.vx, &vec.vx); + if (vec.vx + vec.vz > 0x8FFFF || (d = func_8012BCCC(param_1), d > 0x24000)) { + *(s16 *)(param_1 + 0x2) = 1; + *(s16 *)(param_1 + 0x34) = 0; + *(u16 *)(param_1 + 0x5C) = 0xAA10; + *(s32 *)(param_1 + 0x1C) = (rand() & 0x1F) + 0x28; + vec.vx = *(s16 *)(param_1 + 6) - *(s16 *)(param_1 + 0x88); + vec.vy = 0; + vec.vz = *(s16 *)(param_1 + 0xE) - *(s16 *)(param_1 + 0x8C); + Square0(&vec.vx, &vec.vx); + if (vec.vx + vec.vz > 0x8FFFF) { + *(u16 *)(param_1 + 0xFC) = func_8012B744((void *)(param_1 + 4), target); + } else { + s32 t = rand() & 0x3FF; + s32 off = t - 0x200; + + if (off < 0) { + off = t - 0x500; + } else { + off = t + 0x100; + } + *(u16 *)(param_1 + 0xFC) = + (*(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12) + off) & 0xFFF; + } + func_8012A828(param_1, &D_801E1134); + } + if ((*(u16 *)(param_1 + 0x70) & 0x100) == 0) { + if (func_8012BD3C(param_1, 0x400, 0x1000) != 0) { + if ((*(u16 *)(param_1 + 0x70) & 0xF00) == 0) { + ((void (*)(s32))func_80186B08)(param_1); + } else { + func_80186B34(param_1); + } + } + } else { + if (func_8012BD3C(param_1, 0x400, 0x40000) != 0) { + func_80186B7C(param_1); + } + } + break; + } +} diff --git a/.run/P36/agents/ov_SC02_017__func_80186770/body_tree.c b/.run/P36/agents/ov_SC02_017__func_80186770/body_tree.c new file mode 100644 index 000000000..c1164a698 --- /dev/null +++ b/.run/P36/agents/ov_SC02_017__func_80186770/body_tree.c @@ -0,0 +1,109 @@ +void func_80186770(s32 param_1) +{ + struct { s32 vx, vy, vz, pad; } vec; + s32 v; + s32 d; + s32 b178arg; + void *target; + + switch (*(u16 *)(param_1 + 0x34)) { + case 0: + v = func_8012B8E4(param_1, 4); + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12) += v; + if (*(s32 *)(param_1 + 0x1C) == 0xF) { + func_80142414(param_1, -0x78); + func_8002D4C8(0x6A9, 0); + } + if (func_8012BEE8(param_1) != 0) { + *(s16 *)(param_1 + 0x2) = 3; + if ((*(u16 *)(param_1 + 0x86) & 2) != 0) { + *(s16 *)(param_1 + 0x34) = 1; + *(s32 *)(param_1 + 0x1C) = 0x28; + if ((*(u16 *)(param_1 + 0x70) & 0x200) != 0) { + func_8012A828(param_1, &D_801E1AFC); + } else { + func_8012A828(param_1, &D_801E11DC); + } + *(u16 *)(param_1 + 0xFE) = 0; + } else { + *(s16 *)(param_1 + 0x34) = 0; + func_8012A828(param_1, &D_801E1264); + *(s32 *)(param_1 + 0x1C) = 0x19; + *(u16 *)(param_1 + 0x86) |= 2; + } + } + break; + case 1: + v = func_8012B8E4(param_1, 6); + b178arg = D_801D619C; + { + u16 *pp; + register s32 nv __asm__("$6"); // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus8) + + pp = (u16 *)(*(s32 *)(param_1 + 0x20) + 0x12); + nv = *pp + v; + *pp = nv; + } + func_8012B178(param_1, b178arg); + d = ((s32 (*)(s32))func_8012CBA4)(param_1); + if ((d & 0x1000) != 0) { + func_80131E00(param_1, 0x12); + } else if (d != 0x2000) { + func_8012ADE4((u8 *)param_1); + } + func_80185F88(param_1); + v = *(u16 *)(param_1 + 0xFE) - 1; + *(u16 *)(param_1 + 0xFE) = v; + if ((v << 16) <= 0) { + func_80143B6C(param_1, 0); + *(u16 *)(param_1 + 0xFE) = 8; + } + if ((*(u16 *)(param_1 + 0x70) & 0x200) != 0) { + func_80186C38(param_1, 0x11); + } + target = (void *)(param_1 + 0x88); + vec.vx = *(s16 *)(param_1 + 6) - *(s16 *)(param_1 + 0x88); + vec.vy = 0; + vec.vz = *(s16 *)(param_1 + 0xE) - *(s16 *)(param_1 + 0x8C); + Square0(&vec.vx, &vec.vx); + if (vec.vx + vec.vz > 0x8FFFF || (d = func_8012BCCC(param_1), d > 0x24000)) { + *(s16 *)(param_1 + 0x2) = 1; + *(s16 *)(param_1 + 0x34) = 0; + *(u16 *)(param_1 + 0x5C) = 0xAA10; + *(s32 *)(param_1 + 0x1C) = (rand() & 0x1F) + 0x28; + vec.vx = *(s16 *)(param_1 + 6) - *(s16 *)(param_1 + 0x88); + vec.vy = 0; + vec.vz = *(s16 *)(param_1 + 0xE) - *(s16 *)(param_1 + 0x8C); + Square0(&vec.vx, &vec.vx); + if (vec.vx + vec.vz > 0x8FFFF) { + *(u16 *)(param_1 + 0xFC) = func_8012B744((void *)(param_1 + 4), target); + } else { + s32 t = rand() & 0x3FF; + s32 off = t - 0x200; + + if (off < 0) { + off = t - 0x500; + } else { + off = t + 0x100; + } + *(u16 *)(param_1 + 0xFC) = + (*(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12) + off) & 0xFFF; + } + func_8012A828(param_1, &D_801E1134); + } + if ((*(u16 *)(param_1 + 0x70) & 0x100) == 0) { + if (func_8012BD3C(param_1, 0x400, 0x1000) != 0) { + if ((*(u16 *)(param_1 + 0x70) & 0xF00) == 0) { + ((void (*)(s32))func_80186B08)(param_1); + } else { + func_80186B34(param_1); + } + } + } else { + if (func_8012BD3C(param_1, 0x400, 0x40000) != 0) { + func_80186B7C(param_1); + } + } + break; + } +} diff --git a/.run/P36/agents/ov_SC02_017__func_80186770/history.txt b/.run/P36/agents/ov_SC02_017__func_80186770/history.txt new file mode 100644 index 000000000..efb14f5ca --- /dev/null +++ b/.run/P36/agents/ov_SC02_017__func_80186770/history.txt @@ -0,0 +1,14 @@ +s5: verdict NO-MATCH start 4 best 4 compiles 188 path +best-scoring single candidates of the last trace (move -> score [residual class]): + R5 swap + @8656 -> 4 [REG] (from 4) + R10 param-copy param_1 @8620 -> 4 [REG] (from 4) + R7 block @8650 -> 4 [REG] (from 4) + R8 base tmp0 @8644 -> 4 [REG] (from 4) + R9 swap-stmts @8643 -> 4 [REG] (from 4) + R6 inline nv @8656 -> 4 [REG] (from 4) + R8 temp tmp0 @8655 -> 4 [REG] (from 4) + R7 block @8649 -> 4 [REG] (from 4) + R6 inline v @8623 -> 4 [REG] (from 4) + R8 base tmp0 @8655 -> 4 [REG] (from 4) + R8 hoist tmp0 @8656 -> 4 [REG] (from 4) + R7 block @8644 -> 4 [REG] (from 4) diff --git a/.run/P36/agents/ov_SC02_017__func_80186770/neighbours.txt b/.run/P36/agents/ov_SC02_017__func_80186770/neighbours.txt new file mode 100644 index 000000000..20b5a229a --- /dev/null +++ b/.run/P36/agents/ov_SC02_017__func_80186770/neighbours.txt @@ -0,0 +1,15 @@ +--- every @class/@stuck/@crack note in this translation unit --- +// @class: struct +// @stuck: none — MATCH (array-of-fnptr %lo-fold + signed-halfword guard) +// @class: struct +// @stuck: none — MATCH (array-of-fnptr %lo-fold + signed-halfword guard) +// @class: struct +// @stuck: none — MATCH (array-of-fnptr %lo-fold + signed-halfword guard) +// @class: straight-derive +// @stuck: none — MATCH (52 ins) on iteration 1, confirmed by rtu_match. +// @class: structural (STRENGTH/mflo!=lw -> MATCH) +// @stuck: none - MATCH (41 ins), match_one + rtu_match. +// @class: regalloc (WIDTH/li!=addu -> MATCH) +// @stuck: none — MATCH (58 ins), match_one + rtu_match. PIN-FREE (no register __asm__). +// @class: plumbing +// @stuck: none — MATCH (52 ins), iteration 1. Keys: (1) §3-T4 — Ghidra inverted the arms; the diff --git a/.run/P36/agents/ov_SC02_017__func_80186770/related.txt b/.run/P36/agents/ov_SC02_017__func_80186770/related.txt new file mode 100644 index 000000000..b9742041d --- /dev/null +++ b/.run/P36/agents/ov_SC02_017__func_80186770/related.txt @@ -0,0 +1,291 @@ +=== lever-free bodies in ov_SC02_017 sharing a callee or global with func_80186770 (159 found; top 6 by shared symbols) — read them for the SHAPE === +--- func_80186C64 (src/ov_SC02_017/ov_SC02_017_jr_80186C64.c:3238) shares 10: func_8012A828 func_8012ADE4 func_8012B178 func_8012B8E4 func_8012BD3C func_8012BEE8 func_8012CBA4 func_80131E00 func_80143B6C func_80185F88 --- +void func_80186C64(s32 a0) { + switch (*(u16 *)(a0 + 0x34)) { + case 0: + if (*(s32 *)(a0 + 0x1C) == 7) { + func_8012D5E4(a0, (s32)&D_801D61B0, (s32)(&D_801D61B0 + 8), 0xB); + } + break; + + case 1: + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) += func_8012B8E4(a0, 6); + break; + + case 2: + if (*(s32 *)(a0 + 0x1C) == 0xA) { + func_8012D5E4(a0, (s32)&D_801D61B0, (s32)(&D_801D61B0 + 8), 0xB); + } + break; + + case 3: { + s32 flag; + s32 v; + s16 t; + + if (*(s32 *)(a0 + 0x1C) == *(s32 *)(a0 + 0x1C) / 10 * 10) { + D_801EFA78 += 0x10000; + } + func_8012B178(a0, D_801EFA78); + v = ((s32 (*)(s32))func_8012CBA4)(a0); + if (v & 0x1000) { + ((void (*)(s32, s32))func_80131E00)(a0, 0x12); + flag = 0; + } else if (v == 0x2000) { + flag = 1; + } else { + ((void (*)(s32))func_8012ADE4)(a0); + flag = 1; + } + ((void (*)(s32))func_80185F88)(a0); + func_8012D5E4(a0, (s32)&D_801D61B0, (s32)(&D_801D61B0 + 8), 0x11); + t = *(u16 *)(a0 + 0xFE) - 1; + *(u16 *)(a0 + 0xFE) = t; + if (t <= 0) { + func_80143B6C(a0, 0); + *(s16 *)(a0 + 0xFE) = -(D_801EFA78 / 0x10000); + } + if (flag == 1) { + *(s16 *)(a0 + 2) = 2; + *(u16 *)(a0 + 0x34) = 0; + func_8012A828(a0, (void *)&D_801E0FEC); + } + break; + } + + case 5: + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) += func_8012B8E4(a0, 6); + if (*(s32 *)(a0 + 0x1C) == 0xC) { + func_80187178(a0); + } + break; + } + + if (func_8012BEE8(a0)) { + switch (*(u16 *)(a0 + 0x34)) { + case 0: + if (func_8012BD3C(a0, 0x400, 0x4000)) { + *(u16 *)(a0 + 0x34) += 1; + func_8012A828(a0, (void *)&D_801E0F44); + *(s32 *)(a0 + 0x1C) = 0xA; + } else { + *(s16 *)(a0 + 2) = 2; + *(u16 *)(a0 + 0x34) = 0; + func_8012A828(a0, (void *)&D_801E0FEC); + } + break; + + case 1: + *(u16 *)(a0 + 0x34) = 2; + *(s32 *)(a0 + 0x1C) = 0x18; + func_8012A828(a0, (void *)&D_801E13FC); + break; + + case 2: + case 4: + *(s16 *)(a0 + 2) = 2; + *(u16 *)(a0 + 0x34) = 0; + func_8012A828(a0, (void *)&D_801E0FEC); + break; + + case 3: + *(s32 *)(a0 + 0x1C) = 0xA; + *(u16 *)(a0 + 0x34) += 1; + break; + + case 5: { + s16 t; + + t = *(u16 *)(a0 + 0x100) - 1; + *(u16 *)(a0 + 0x100) = t; + if (t == 0) { + *(s16 *)(a0 + 2) = 8; + func_8012A828(a0, (void *)&D_801E1A04); + } else { + *(s32 *)(a0 + 0x1C) = 0x1E; + } + break; + } + } + } +} + +--- func_801863B8 (src/ov_SC02_017/ov_SC02_017_jr_8017DF34.c:8411) shares 7: func_8012ADE4 func_8012B178 func_8012BD3C func_8012BEE8 func_8012CBA4 func_80131E00 func_80185F88 --- +void func_801863B8(s32 a0) { + struct { s32 vx, vy, vz, pad; } vec; + s32 v0; + + if (*(s32 *)(a0 + 0x1C) > 7) { + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) += + func_8012B608(*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12), + *(s16 *)(a0 + 0xFC), 8); + } + + vec.vx = *(s16 *)(a0 + 0x6) - *(s16 *)(a0 + 0x88); + vec.vy = 0; + vec.vz = *(s16 *)(a0 + 0xE) - *(s16 *)(a0 + 0x8C); + Square0(&vec.vx, &vec.vx); + + if (vec.vx + vec.vz <= 0x8FFFF && func_8012BD3C(a0, 0x300, 0x24000) != 0) { + func_801866C8(a0); + } else { + func_8012B178(a0, D_801D6198); + v0 = ((s32 (*)(s32))func_8012CBA4)(a0); + if ((v0 & 0x1000) != 0) { + func_80131E00(a0, 0x12); + } else if (v0 != 0x2000) { + func_8012ADE4((u8 *)a0); + } + func_80185F88(a0); + if (func_8012BEE8(a0) != 0) { + ((void (*)(s32))func_80186500)(a0); + } + } +} + +--- func_80187044 (src/ov_SC02_017/ov_SC02_017_jr_80186C64.c:3386) shares 6: D_801E11DC D_801E1264 D_801E1AFC func_8012A828 func_8012BEE8 func_80143B6C --- +void func_80187044(s32 a0) { + s32 v0; + + func_8012AD80(a0); + if (*(u16 *)(a0 + 0x70) & 0x2000) { + v0 = *(u16 *)(a0 + 0xFE) - 1; + *(u16 *)(a0 + 0xFE) = v0; + if ((s16)v0 <= 0) { + func_80143B6C(a0, 0); + *(u16 *)(a0 + 0xFE) = 8; + } + if (*(u16 *)(a0 + 0x70) & 0x200) { + func_8012D5E4(a0, (s32)&D_801D61B0, (s32)&D_801D61B0 + 8, 0x11); + } + } + if (func_8012BEE8(a0)) { + *(u16 *)(a0 + 0x86) |= 2; + *(s16 *)(a0 + 0x2) = 3; + if (*(u16 *)(a0 + 0x86) & 2) { + *(s16 *)(a0 + 0x34) = 1; + *(s32 *)(a0 + 0x1C) = 0x28; + if (*(u16 *)(a0 + 0x70) & 0x200) { + func_8012A828(a0, &D_801E1AFC); + } else { + func_8012A828(a0, &D_801E11DC); + } + *(u16 *)(a0 + 0xFE) = 0; + } else { + *(s16 *)(a0 + 0x34) = 0; + func_8012A828(a0, &D_801E1264); + *(s32 *)(a0 + 0x1C) = 0x19; + *(u16 *)(a0 + 0x86) |= 2; + } + } +} + +--- func_80187298 (src/ov_SC02_017/ov_SC02_017_jr_80186C64.c:3489) shares 6: D_801E11DC D_801E1264 D_801E1AFC func_8012A828 func_8012BEE8 func_80143B6C --- +void func_80187298(s32 a0) { + D_87298 d; + s32 t; + s32 v1; + s32 p; + u16 sc; + + switch (*(u16 *)(a0 + 0x34)) { + case 0: + d.x = (u16)D_80126B5E; + d.z = (u16)D_80126B66; + d.vx = *(s16 *)(a0 + 6) - (s32)(s16)D_80126B5E; + d.vy = 0; + d.vz = *(s16 *)(a0 + 0xE) - (s32)(s16)D_80126B66; + Square0(&d.vx, &d.vx); + if (0x10000 < d.vx + d.vz) return; + if (func_8012E778(a0, 0xA000C8) != 0) return; + *(u16 *)(a0 + 0x34) = *(u16 *)(a0 + 0x34) + 1; + func_8012B23C(a0); + *(s32 *)(*(s32 *)(a0 + 0x20) + 4) = *(s32 *)(*(s32 *)(a0 + 0x20) + 4) & 0x7FFFFFFF; + func_80143970(a0); + return; + case 1: + if ((((s32 (*)(s32))func_8012CBCC)(a0) & 0x2000) == 0) return; + func_80143B6C(a0, 1); + *(u16 *)(a0 + 0x34) = *(u16 *)(a0 + 0x34) + 1; + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x2C) = *(u16 *)(*(s32 *)(a0 + 0x20) + 0x2C) | 0x10; + *(s32 *)(a0 + 0x1C) = 0x10; + /* fall through */ + case 2: + t = func_8004787C((*(u32 *)(a0 + 0x1C) << 7) & 0x780); + sc = ((t << 9) >> 12) + 0x1000; + p = *(s32 *)(a0 + 0x20); + *(s16 *)(p + 0x1C) = sc; + *(s16 *)(p + 0x18) = sc; + *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1A) = 0x1000 - ((t << 10) >> 12); + if (func_8012BEE8(a0) != 0) { + *(u16 *)(a0 + 2) = 3; + if (*(u16 *)(a0 + 0x86) & 2) { + *(u16 *)(a0 + 0x34) = 1; + *(s32 *)(a0 + 0x1C) = 0x28; + if (*(u16 *)(a0 + 0x70) & 0x200) { + func_8012A828(a0, &D_801E1AFC); + } else { + func_8012A828(a0, &D_801E11DC); + } + *(u16 *)(a0 + 0xFE) = 0; + } else { + *(u16 *)(a0 + 0x34) = 0; + func_8012A828(a0, &D_801E1264); + *(s32 *)(a0 + 0x1C) = 0x19; + *(u16 *)(a0 + 0x86) |= 2; + } + v1 = *(s32 *)(a0 + 0x20); + *(u16 *)(v1 + 0x2C) &= 0xFFEF; + } + break; + default: + return; + } +} + +--- func_80184E38 (src/ov_SC02_017/ov_SC02_017_jr_8017DF34.c:7386) shares 5: func_8012B178 func_8012B8E4 func_8012BCCC func_8012BD3C func_8012BEE8 --- +void func_80184E38(s32 a0) { + s32 s0 = a0; + if (func_8012BD3C(s0, 0x400, 0x10000) == 1) { + if (func_8012BCCC(s0) < 0x3001) { + *(s16 *)(s0 + 2) = 8; + return; + } + *(u16 *)(*(s32 *)(s0 + 0x20) + 0x12) = + func_8012B8E4(s0, (s16)(rand() % 11 + 10)) + *(u16 *)(*(s32 *)(s0 + 0x20) + 0x12); + func_8012B178(s0, 0xFFFE0000); + if (func_80185D10(s0) == 0) { + return; + } + } else { + if (func_80185D10(s0) == 0) { + *(s16 *)(s0 + 2) = 0xA; + *(s32 *)(s0 + 0xDC) |= 0x40; + return; + } + } + if (func_8012BEE8(s0) != 0) { + func_80185C68(s0); + } +} + +--- func_80184C58 (src/ov_SC02_017/ov_SC02_017_jr_8017DF34.c:7320) shares 4: func_8012A828 func_8012B8E4 func_8012BCCC func_8012BEE8 --- +void func_80184C58(s32 a0) { + s32 v; + + if (*(u16 *)(a0 + 0x34) == 0) { + if (func_8012BCCC(a0) <= 0x10000) { + func_8001C924(*(s32 *)(a0 + 0x20), (void *)&D_801D29A8); + func_8012A828(a0, (void *)&(*(u8 *)D_801D5AD4)); + *(s32 *)(a0 + 0x1C) = 0x1E; + *(u16 *)(a0 + 0x34) += 1; + } + } else { + v = func_8012B8E4(a0, 0xA); + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) += v; + if (func_8012BEE8(a0) != 0 || v == 0) { + *(s16 *)(a0 + 0x2) = 5; + } + } +} + diff --git a/.run/P36/agents/ov_SC02_017__func_80186770/residual.txt b/.run/P36/agents/ov_SC02_017__func_80186770/residual.txt new file mode 100644 index 000000000..eb830b601 --- /dev/null +++ b/.run/P36/agents/ov_SC02_017__func_80186770/residual.txt @@ -0,0 +1,10 @@ +src/ov_SC02_017/ov_SC02_017_jr_8017DF34.c:func_80186770: score 4 (REG-caller; mine 230 ins, target 230) — not yet + register pairs (mine -> target, count): v1->a2 x4, a2->v1 x3 + replace mine[72:73] target[72:73] + 72 lw a2,32(s0) | lw v1,32(s0) + replace mine[74:75] target[74:75] + 74 lhu v1,18(a2) | lhu a2,18(v1) + replace mine[77:78] target[77:78] + 77 addu v1,v1,v0 | addu a2,a2,v0 + replace mine[79:80] target[79:80] + 79 sh v1,18(a2) | sh a2,18(v1) diff --git a/.run/P36/agents/ov_SC02_017__func_80186770/sites.txt b/.run/P36/agents/ov_SC02_017__func_80186770/sites.txt new file mode 100644 index 000000000..3c9857d05 --- /dev/null +++ b/.run/P36/agents/ov_SC02_017__func_80186770/sites.txt @@ -0,0 +1,3 @@ +REMOVED pin $3 line 8849 +NEEDED pin $6 line 8850 +REMOVED pin $2 line 8890 diff --git a/.run/P36/agents/ov_SC02_017__func_80186770/tu.txt b/.run/P36/agents/ov_SC02_017__func_80186770/tu.txt new file mode 100644 index 000000000..ccd84c227 --- /dev/null +++ b/.run/P36/agents/ov_SC02_017__func_80186770/tu.txt @@ -0,0 +1,2 @@ +src/ov_SC02_017/ov_SC02_017_jr_8017DF34.c +func_80186770 diff --git a/.run/P36/agents/ov_SC06_018__func_80187DD0/body_free.c b/.run/P36/agents/ov_SC06_018__func_80187DD0/body_free.c new file mode 100644 index 000000000..68025791e --- /dev/null +++ b/.run/P36/agents/ov_SC06_018__func_80187DD0/body_free.c @@ -0,0 +1,99 @@ +void func_80187DD0(s32 param_1) +{ + s32 t1 = *(s32 *)(param_1 + 0x64); + s32 pad[2]; + + if (*(s16 *)(t1 + 0x36) != *(s16 *)(param_1 + 0x10A)) { + func_8012C218((void *)param_1); + return; + } + { + if ((*(u32 *)(t1 + 0xE0) & 4) != 0) { + func_8012E8A8((u8 *)param_1); + return; + } + { + s32 a2 = *(s32 *)(*(s32 *)(t1 + 0x20) + 0x20); + s32 a3 = param_1 + 0xFC; + + if (a2 != 0) { + if ((a2 & 0x1000000) != 0) { + s32 a1 = a2 & 0xFEFFFFFF; + u32 v0; + u32 a0; + u32 v1a; + u32 v1b; + u32 v0b; + u32 v1; + + *(u16 *)(param_1 + 0x102) = *(u16 *)(a1 + 0x66); + + v0 = *(u32 *)(a1 + 0x60); + a0 = *(u8 *)(a1 + 0x61); + v1a = (v0 & 0xF) << 8; + a0 = a0 | v1a; + v1b = ((s32)v0 >> 16) & 0xFF; + v0b = (v0 & 0xF0) << 4; + v1 = v1b | v0b; + *(u16 *)(param_1 + 0x104) = (u16)a0; + *(u16 *)(param_1 + 0x106) = (u16)v1; + + *(s16 *)(param_1 + 0xFC) = (s8)*(u8 *)(a1 + 0x63); + *(s16 *)(param_1 + 0xFE) = (s8)*(u8 *)(a1 + 0x64); + *(s16 *)(param_1 + 0x100) = (s8)*(u8 *)(a1 + 0x65); + } else { + *(UAlign12 *)(param_1 + 0xFC) = *(UAlign12 *)(a2 + 0x90); + } + *(s32 *)(*(s32 *)(param_1 + 0x20) + 0x20) = a3; + } + + if ((*(u32 *)(t1 + 0xE0) & 0x80) != 0) { + if (*(u16 *)(param_1 + 0x34) == 0) { + s16 sVar2 = *(u16 *)(param_1 + 0x108) + 0x40; + *(s16 *)(param_1 + 0x108) = sVar2; + if (sVar2 > 0x200) { + *(u16 *)(param_1 + 0x108) = 0x200; + *(s16 *)(param_1 + 0x34) = *(s16 *)(param_1 + 0x34) + 1; + } + } else { + u16 uVar3 = *(u16 *)(param_1 + 0x108) - 0x80; + *(u16 *)(param_1 + 0x108) = uVar3; + if ((s16)uVar3 < 0) { + *(u16 *)(param_1 + 0x108) = 0; + *(u16 *)(param_1 + 0x34) = 0; + *(u32 *)(t1 + 0xE0) = *(u32 *)(t1 + 0xE0) & ~0x80; + } + } + } + + *(u16 *)(a3 + 6) = *(u16 *)(a3 + 6) + *(u16 *)(param_1 + 0x108); + + *(u32 *)(param_1 + 4) = *(u32 *)(t1 + 4); + *(u32 *)(param_1 + 8) = *(u32 *)(t1 + 8); + *(u32 *)(param_1 + 0xC) = *(u32 *)(t1 + 0xC); + + *(UAlign8 *)(param_1 + 0x50) = *(UAlign8 *)(t1 + 0x50); + + { + s32 dst = *(s32 *)(param_1 + 0x20); + s32 src = *(s32 *)(t1 + 0x20); + *(UAlign8 *)(dst + 0x10) = *(UAlign8 *)(src + 0x10); + } + { + s32 dst = *(s32 *)(param_1 + 0x20); + s32 src = *(s32 *)(t1 + 0x20); + *(UAlign8 *)(dst + 0x18) = *(UAlign8 *)(src + 0x18); + } + { + s32 src = *(s32 *)(t1 + 0x20); + s32 dst = *(s32 *)(param_1 + 0x20); + *(u32 *)(dst + 4) = *(u32 *)(src + 4); + } + { + s32 src = *(s32 *)(t1 + 0x20); + s32 dst = *(s32 *)(param_1 + 0x20); + *(u16 *)(dst + 0x2C) = *(u16 *)(src + 0x2C); + } + } + } +} diff --git a/.run/P36/agents/ov_SC06_018__func_80187DD0/body_tree.c b/.run/P36/agents/ov_SC06_018__func_80187DD0/body_tree.c new file mode 100644 index 000000000..ef8c7da44 --- /dev/null +++ b/.run/P36/agents/ov_SC06_018__func_80187DD0/body_tree.c @@ -0,0 +1,99 @@ +void func_80187DD0(s32 param_1) +{ + s32 t1 = *(s32 *)(param_1 + 0x64); + s32 pad[2]; + + if (*(s16 *)(t1 + 0x36) != *(s16 *)(param_1 + 0x10A)) { + func_8012C218((void *)param_1); + return; + } + { + if ((*(u32 *)(t1 + 0xE0) & 4) != 0) { + func_8012E8A8((u8 *)param_1); + return; + } + { + s32 a2 = *(s32 *)(*(s32 *)(t1 + 0x20) + 0x20); + s32 a3 = param_1 + 0xFC; + + if (a2 != 0) { + if ((a2 & 0x1000000) != 0) { + s32 a1 = a2 & 0xFEFFFFFF; + register u32 v0 __asm__("$2"); // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus9) + u32 a0; + u32 v1a; + u32 v1b; + u32 v0b; + u32 v1; + + *(u16 *)(param_1 + 0x102) = *(u16 *)(a1 + 0x66); + + v0 = *(u32 *)(a1 + 0x60); + a0 = *(u8 *)(a1 + 0x61); + v1a = (v0 & 0xF) << 8; + a0 = a0 | v1a; + v1b = ((s32)v0 >> 16) & 0xFF; + v0b = (v0 & 0xF0) << 4; + v1 = v1b | v0b; + *(u16 *)(param_1 + 0x104) = (u16)a0; + *(u16 *)(param_1 + 0x106) = (u16)v1; + + *(s16 *)(param_1 + 0xFC) = (s8)*(u8 *)(a1 + 0x63); + *(s16 *)(param_1 + 0xFE) = (s8)*(u8 *)(a1 + 0x64); + *(s16 *)(param_1 + 0x100) = (s8)*(u8 *)(a1 + 0x65); + } else { + *(UAlign12 *)(param_1 + 0xFC) = *(UAlign12 *)(a2 + 0x90); + } + *(s32 *)(*(s32 *)(param_1 + 0x20) + 0x20) = a3; + } + + if ((*(u32 *)(t1 + 0xE0) & 0x80) != 0) { + if (*(u16 *)(param_1 + 0x34) == 0) { + s16 sVar2 = *(u16 *)(param_1 + 0x108) + 0x40; + *(s16 *)(param_1 + 0x108) = sVar2; + if (sVar2 > 0x200) { + *(u16 *)(param_1 + 0x108) = 0x200; + *(s16 *)(param_1 + 0x34) = *(s16 *)(param_1 + 0x34) + 1; + } + } else { + u16 uVar3 = *(u16 *)(param_1 + 0x108) - 0x80; + *(u16 *)(param_1 + 0x108) = uVar3; + if ((s16)uVar3 < 0) { + *(u16 *)(param_1 + 0x108) = 0; + *(u16 *)(param_1 + 0x34) = 0; + *(u32 *)(t1 + 0xE0) = *(u32 *)(t1 + 0xE0) & ~0x80; + } + } + } + + *(u16 *)(a3 + 6) = *(u16 *)(a3 + 6) + *(u16 *)(param_1 + 0x108); + + *(u32 *)(param_1 + 4) = *(u32 *)(t1 + 4); + *(u32 *)(param_1 + 8) = *(u32 *)(t1 + 8); + *(u32 *)(param_1 + 0xC) = *(u32 *)(t1 + 0xC); + + *(UAlign8 *)(param_1 + 0x50) = *(UAlign8 *)(t1 + 0x50); + + { + s32 dst = *(s32 *)(param_1 + 0x20); + s32 src = *(s32 *)(t1 + 0x20); + *(UAlign8 *)(dst + 0x10) = *(UAlign8 *)(src + 0x10); + } + { + s32 dst = *(s32 *)(param_1 + 0x20); + s32 src = *(s32 *)(t1 + 0x20); + *(UAlign8 *)(dst + 0x18) = *(UAlign8 *)(src + 0x18); + } + { + s32 src = *(s32 *)(t1 + 0x20); + s32 dst = *(s32 *)(param_1 + 0x20); + *(u32 *)(dst + 4) = *(u32 *)(src + 4); + } + { + s32 src = *(s32 *)(t1 + 0x20); + s32 dst = *(s32 *)(param_1 + 0x20); + *(u16 *)(dst + 0x2C) = *(u16 *)(src + 0x2C); + } + } + } +} diff --git a/.run/P36/agents/ov_SC06_018__func_80187DD0/history.txt b/.run/P36/agents/ov_SC06_018__func_80187DD0/history.txt new file mode 100644 index 000000000..a6fedab51 --- /dev/null +++ b/.run/P36/agents/ov_SC06_018__func_80187DD0/history.txt @@ -0,0 +1,14 @@ +s5: verdict NO-MATCH start 10 best 2 compiles 187 path R5 swap | @3131 + R6 inline a0 @3128 +best-scoring single candidates of the last trace (move -> score [residual class]): + R6 inline a0 @3128 -> 2 [REG] (from 8) + R6 inline a0 @3127 -> 6 [MIXED] (from 9) + R6 inline a0 @3128 -> 6 [MIXED] (from 9) + R5 swap | @3131 -> 8 [REG] (from 10) + R8 temp tmp0 @3123 -> 8 [REG] (from 8) + R5 swap | @3128 -> 8 [REG] (from 8) + R18 bystander @3128->3131 -> 8 [REG] (from 8) + R7 block @3123 -> 8 [REG] (from 8) + R9 swap-stmts @3125 -> 8 [REG] (from 8) + R6 inline v1a @3127 -> 8 [REG] (from 8) + R8 base tmp0 @3123 -> 8 [REG] (from 8) + R18 bystander @3132->3129 -> 8 [REG] (from 8) diff --git a/.run/P36/agents/ov_SC06_018__func_80187DD0/neighbours.txt b/.run/P36/agents/ov_SC06_018__func_80187DD0/neighbours.txt new file mode 100644 index 000000000..b5e4f0747 --- /dev/null +++ b/.run/P36/agents/ov_SC06_018__func_80187DD0/neighbours.txt @@ -0,0 +1,27 @@ +=== THIS FUNCTION'S OWN HEADER (func_80187DD0, line 3095) — read it in full === +/* §48-C2: lwl/lwr/swl/swr block copy == a plain struct assign of a 2-byte-aligned struct */ + +--- every @class/@stuck/@crack note in this translation unit --- +// @class: struct +// @stuck: none — MATCH (276 ins, relocation-masked). Verified BOTH standalone (match_one) and +// @class: branch-polarity +// @stuck: none — MATCH (32 ins), iteration 2. §3-T4: gcc-2.7.2 lays this out as +// @class: struct +// @stuck: none — §136c SIBLING-FIRST. Near-twin (byte-identical template) = func_80186160 in +// @class: loose-typing +// @stuck: none — MATCH (99 ins). short* for param_2/param_3: gcc emits lh where sign is live (<<1 for signed div), lhu where truncated to short (arith result / direct copy) +// @class: regalloc-order +// @stuck: none -- see match_one output. +// @class: regalloc-order +// @stuck: none -- see match_one output. +// @class: regalloc-order +// @stuck: none — MATCH (277 ins). p pinned $s1; e/spawn-ptr coalesce $s0; counter $s2; const2 hoisted $s3. + * @class: regalloc-order + * @stuck: none — MATCH (248 ins), iteration 2. + * @class: regalloc-order + * @class: regalloc-order + * @stuck: none — MATCH (170 ins), iteration 3. Body was E188 verbatim on +// @class: none +// @stuck: none — MATCH (397/397 ins, match_one + rtu_match). +// @class: other +// @stuck: none — MATCH (478 ins, relocation-masked byte-identical) diff --git a/.run/P36/agents/ov_SC06_018__func_80187DD0/related.txt b/.run/P36/agents/ov_SC06_018__func_80187DD0/related.txt new file mode 100644 index 000000000..59cdf09a3 --- /dev/null +++ b/.run/P36/agents/ov_SC06_018__func_80187DD0/related.txt @@ -0,0 +1,146 @@ +=== lever-free bodies in ov_SC06_018 sharing a callee or global with func_80187DD0 (51 found; top 6 by shared symbols) — read them for the SHAPE === +--- func_80187AEC (src/ov_SC06_018/ov_SC06_018_jr_80187AEC.c:2992) shares 2: func_8012C218 func_8012E8A8 --- +void func_80187AEC(s32 param_1) +{ + s32 iVar; + s32 t; + u16 st; + u16 uVar1; + s32 pad[1]; /* see key (2): forces the 0x20 frame — never referenced */ + + if (0xf < *(s16 *)(param_1 + 0xA)) { + func_8012C218((void *)param_1); + return; + } + switch (*(u16 *)(param_1 + 0x34)) { + case 0: + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) = + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) + *(u16 *)(param_1 + 0xFC); + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12) = + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12) + *(u16 *)(param_1 + 0xFE); + if ((((s32 (*)(s32, s32))func_8012CC40)( + param_1, + ((*(u16 *)(param_1 + 0x70) & 0xF) * 8) + (s32)&D_801B5400) & + 0x2000) == 0) { + return; + } + iVar = *(s32 *)(param_1 + 0x1C) + 1; + *(s32 *)(param_1 + 0x1C) = iVar; + if (iVar >= 4) { + if ((*(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) & 0xFFFU) > 0x800U) { + *(u16 *)(param_1 + 0x102) = 0xC00; + } else { + *(u16 *)(param_1 + 0x102) = 0x400; + } + t = *(u16 *)(param_1 + 0x70) & 0xF; + if (t < 4 && t != 0) { + *(u16 *)(param_1 + 0x102) = *(u16 *)(param_1 + 0x102) + 0x400; + } + *(s32 *)(param_1 + 0x1C) = 0x1E; + *(u16 *)(param_1 + 0x34) = *(u16 *)(param_1 + 0x34) + 1; + } else { + *(s32 *)(param_1 + 0x14) = -(0x80000 / iVar); + func_80143B6C(param_1, 1); + } + return; + case 1: + iVar = func_8012B608((s32)*(s16 *)(*(s32 *)(param_1 + 0x20) + 0x10), + (s32)*(s16 *)(param_1 + 0x102), 4); + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) = + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) + iVar; + if (func_8012BEE8(param_1) == 0) { + return; + } + st = *(u16 *)(param_1 + 0x34); + *(s32 *)(param_1 + 0x1C) = 0x1E; + *(u16 *)(param_1 + 0x34) = st + 1; + if ((*(s16 *)(param_1 + 0x70) & 0x8000) != 0) { + *(u16 *)(param_1 + 0x34) = st + 2; + } else if ((*(s16 *)(param_1 + 0x70) & 0xF) == 4) { + *(u16 *)(param_1 + 0x34) = 4; + *(s32 *)(param_1 + 0x1C) = 0x1E; + } + return; + case 2: + func_8012E8C4((u8 *)param_1); + if (func_8012BEE8(param_1) == 1) { + func_8012C218((void *)param_1); + } + return; + case 3: + if (*(s16 *)(*(s32 *)(param_1 + 0x64) + 0x36) != *(s16 *)(param_1 + 0x10A) && + *(s32 *)(param_1 + 0xE0) == 0) { + *(s32 *)(param_1 + 0x1C) = 0x1E; + uVar1 = 2; + if ((*(u16 *)(param_1 + 0x70) & 0xF) == 4) { + uVar1 = 4; + } + *(u16 *)(param_1 + 0x34) = uVar1; + *(s32 *)(param_1 + 0xE0) = 1; + } + return; + case 4: + if (func_8012BEE8(param_1) != 0) { + *(s32 *)(param_1 + 0x1C) = 0xA; + *(u16 *)(param_1 + 0x34) = *(u16 *)(param_1 + 0x34) + 1; + func_8012E8A8((u8 *)param_1); + func_80189000(param_1, 1); + } + return; + case 5: + if (func_8018944C(param_1, 0x60, 0xA0) == 1) { + func_8012C218((void *)param_1); + } + return; + } +} + +--- func_801439C0 (src/shared/ov/func_801439C0.h:5) shares 1: func_8012C218 --- +void func_801439C0(u8 *a0) { + if (a0 != 0) { + func_80016714(*(void **)(a0 + 0xCC), 0x38); + func_8012C218(a0); + } +} + +--- func_80186894 (src/ov_SC06_018/ov_SC06_018_jr_80186270.c:3174) shares 1: func_8012E8A8 --- +void func_80186894(s32 a0) { + s32 s0 = a0; + *(u16 *)(s0 + 0x5C) = 0; + func_8012E8A8(s0); + *(s32 *)(s0 + 0x1C) = 0xA; + func_80189000(s0, (*(u16 *)(s0 + 0x70) & 0xF) + 2); +} + +--- func_80188D54 (src/ov_SC06_018/ov_SC06_018_jr_80187AEC.c:3786) shares 1: func_8012E8A8 --- +void func_80188D54(void *a0) +{ + ((void (*)(void *))func_8012E8A8)(a0); + *(u32 *)(a0 + 0x1C) = 0xA; + *(u16 *)(a0 + 0x5C) = 0; + *(u16 *)(a0 + 0x2) = 0xA; +} + +--- func_80142778 (src/shared/ov/func_80142778.h:4) shares 1: func_8012C218 --- +void func_80142778(u8 *a1) { + u8 *a0 = *(u8 **)(a1 + 0x20); + *(u16 *)(a0 + 0x18) = *(u16 *)(a0 + 0x18) - 0x800; + *(u16 *)(a0 + 0x1A) = *(u16 *)(a0 + 0x1A) - 0x800; + *(u16 *)(a1 + 0xA) = *(u16 *)(a1 + 0xA) + 0x10; + if (*(s16 *)(a0 + 0x18) <= 0) { + func_8012C218(a1); + } +} + +--- func_8012C098 (src/shared/ov/func_8012C098.h:4) shares 1: func_8012C218 --- +void func_8012C098(void *param_1) +{ + int iVar1; + iVar1 = *(int *)((char *)param_1 + 0x68); + if ((iVar1 != 0) && ((*(short *)((char *)param_1 + 0x72) & 0x8000) != 0)) { + *(unsigned short *)(iVar1 + 10) = *(unsigned short *)(iVar1 + 10) & 0x7fff; + } + func_8012C218(param_1); + return; +} + diff --git a/.run/P36/agents/ov_SC06_018__func_80187DD0/residual.txt b/.run/P36/agents/ov_SC06_018__func_80187DD0/residual.txt new file mode 100644 index 000000000..110a674cc --- /dev/null +++ b/.run/P36/agents/ov_SC06_018__func_80187DD0/residual.txt @@ -0,0 +1,15 @@ +src/ov_SC06_018/ov_SC06_018_jr_80187AEC.c:func_80187DD0: score 10 (REG-caller; mine 174 ins, target 174) — not yet + register pairs (mine -> target, count): v0->v1 x10, v1->v0 x8 + replace mine[37:38] target[37:38] + 37 lw v1,96(a1) | lw v0,96(a1) + replace mine[39:47] target[39:47] + 39 andi v0,v1,0xf | andi v1,v0,0xf + 40 sll v0,v0,0x8 | sll v1,v1,0x8 + 41 or a0,a0,v0 | or a0,a0,v1 + 42 sra v0,v1,0x10 | sra v1,v0,0x10 + 43 andi v0,v0,0xff | andi v1,v1,0xff + 44 andi v1,v1,0xf0 | andi v0,v0,0xf0 + 45 sll v1,v1,0x4 | sll v0,v0,0x4 + 46 or v0,v0,v1 | or v1,v1,v0 + replace mine[48:49] target[48:49] + 48 sh v0,262(t0) | sh v1,262(t0) diff --git a/.run/P36/agents/ov_SC06_018__func_80187DD0/sites.txt b/.run/P36/agents/ov_SC06_018__func_80187DD0/sites.txt new file mode 100644 index 000000000..21f9f1e45 --- /dev/null +++ b/.run/P36/agents/ov_SC06_018__func_80187DD0/sites.txt @@ -0,0 +1 @@ +NEEDED pin $2 line 3116 diff --git a/.run/P36/agents/ov_SC06_018__func_80187DD0/tu.txt b/.run/P36/agents/ov_SC06_018__func_80187DD0/tu.txt new file mode 100644 index 000000000..183a8fc9e --- /dev/null +++ b/.run/P36/agents/ov_SC06_018__func_80187DD0/tu.txt @@ -0,0 +1,2 @@ +src/ov_SC06_018/ov_SC06_018_jr_80187AEC.c +func_80187DD0 diff --git a/.run/P36/agents/ov_SC06_018__func_8018AD74/body_free.c b/.run/P36/agents/ov_SC06_018__func_8018AD74/body_free.c new file mode 100644 index 000000000..3ed9325d4 --- /dev/null +++ b/.run/P36/agents/ov_SC06_018__func_8018AD74/body_free.c @@ -0,0 +1,27 @@ +void func_8018AD74(s32 p1, s32 p2, s32 p3, s32 p4) +{ + /* [T51] block-scoped decls (house idiom in this TU, cf. func_8018AF88): a file-scope + decl of these symbols would constrain every LATER function in the object. */ + extern Blk20_8018AF88 D_800AE620; + extern s32 func_8012C658(s32, s32, s32); + extern void RotMatrixY(s32 a0, void *a1); + extern void func_800484EC(s32, s32, s32); + extern u8 D_801CD468[]; + + Blk20_8018AF88 local_30; /* sp+0x10 */ + Blk20_8018AF88 *m; + s32 obj; + s32 out[3]; /* sp+0x30, only [0] and [2] used */ + + local_30 = D_800AE620; + obj = func_8012C658((s16)p2, (s16)p3, p1); + if (obj != 0) { + m = &local_30; + *(u16 *)(obj + 0xA) = *(u16 *)(obj + 0xA) - 0x80; + RotMatrixY((s16)p4, m); + func_800484EC((s32)m, (s32)&D_801CD468, (s32)out); + *(s32 *)(obj + 0x10) = out[0]; + *(s32 *)(obj + 0x14) = 0xFFD80000; + *(s32 *)(obj + 0x18) = out[2]; + } +} diff --git a/.run/P36/agents/ov_SC06_018__func_8018AD74/body_tree.c b/.run/P36/agents/ov_SC06_018__func_8018AD74/body_tree.c new file mode 100644 index 000000000..ea1b1b916 --- /dev/null +++ b/.run/P36/agents/ov_SC06_018__func_8018AD74/body_tree.c @@ -0,0 +1,28 @@ +void func_8018AD74(s32 p1, s32 p2, s32 p3, s32 p4) +{ + /* [T51] block-scoped decls (house idiom in this TU, cf. func_8018AF88): a file-scope + decl of these symbols would constrain every LATER function in the object. */ + extern Blk20_8018AF88 D_800AE620; + extern s32 func_8012C658(s32, s32, s32); + extern void RotMatrixY(s32 a0, void *a1); + extern void func_800484EC(s32, s32, s32); + extern u8 D_801CD468[]; + + Blk20_8018AF88 local_30; /* sp+0x10 */ + Blk20_8018AF88 *m; + s32 obj; + s32 out[3]; /* sp+0x30, only [0] and [2] used */ + + local_30 = D_800AE620; + obj = func_8012C658((s16)p2, (s16)p3, p1); + if (obj != 0) { + __asm__("" : "=r"(obj) : "0"(obj)); /* §350 birthing-boost kill; 0 bytes */ // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus9) + m = &local_30; + *(u16 *)(obj + 0xA) = *(u16 *)(obj + 0xA) - 0x80; + RotMatrixY((s16)p4, m); + func_800484EC((s32)m, (s32)&D_801CD468, (s32)out); + *(s32 *)(obj + 0x10) = out[0]; + *(s32 *)(obj + 0x14) = 0xFFD80000; + *(s32 *)(obj + 0x18) = out[2]; + } +} diff --git a/.run/P36/agents/ov_SC06_018__func_8018AD74/history.txt b/.run/P36/agents/ov_SC06_018__func_8018AD74/history.txt new file mode 100644 index 000000000..e4a476b69 --- /dev/null +++ b/.run/P36/agents/ov_SC06_018__func_8018AD74/history.txt @@ -0,0 +1,14 @@ +s5: verdict NO-MATCH start 5 best 2 compiles 176 path R18 bystander @5393->5397 +best-scoring single candidates of the last trace (move -> score [residual class]): + R18 bystander @5393->5397 -> 2 [COUNT] (from 5) + R18 bystander @5393->5398 -> 2 [COUNT] (from 5) + R18 bystander @5393->5399 -> 2 [COUNT] (from 5) + R7 block @5390 -> 2 [COUNT] (from 2) + R7 block @5391 -> 2 [COUNT] (from 2) + R7 block @5393 -> 2 [COUNT] (from 2) + R7 block @5394 -> 2 [COUNT] (from 2) + R7 block @5395 -> 2 [COUNT] (from 2) + R7 block @5396 -> 2 [COUNT] (from 2) + R7 block @5397 -> 2 [COUNT] (from 2) + R7 block @5398 -> 2 [COUNT] (from 2) + R7 block @5390 -> 2 [COUNT] (from 2) diff --git a/.run/P36/agents/ov_SC06_018__func_8018AD74/neighbours.txt b/.run/P36/agents/ov_SC06_018__func_8018AD74/neighbours.txt new file mode 100644 index 000000000..b1d430c91 --- /dev/null +++ b/.run/P36/agents/ov_SC06_018__func_8018AD74/neighbours.txt @@ -0,0 +1,24 @@ +--- every @class/@stuck/@crack note in this translation unit --- +// @class: struct +// @stuck: none — MATCH (276 ins, relocation-masked). Verified BOTH standalone (match_one) and +// @class: branch-polarity +// @stuck: none — MATCH (32 ins), iteration 2. §3-T4: gcc-2.7.2 lays this out as +// @class: struct +// @stuck: none — §136c SIBLING-FIRST. Near-twin (byte-identical template) = func_80186160 in +// @class: loose-typing +// @stuck: none — MATCH (99 ins). short* for param_2/param_3: gcc emits lh where sign is live (<<1 for signed div), lhu where truncated to short (arith result / direct copy) +// @class: regalloc-order +// @stuck: none -- see match_one output. +// @class: regalloc-order +// @stuck: none -- see match_one output. +// @class: regalloc-order +// @stuck: none — MATCH (277 ins). p pinned $s1; e/spawn-ptr coalesce $s0; counter $s2; const2 hoisted $s3. + * @class: regalloc-order + * @stuck: none — MATCH (248 ins), iteration 2. + * @class: regalloc-order + * @class: regalloc-order + * @stuck: none — MATCH (170 ins), iteration 3. Body was E188 verbatim on +// @class: none +// @stuck: none — MATCH (397/397 ins, match_one + rtu_match). +// @class: other +// @stuck: none — MATCH (478 ins, relocation-masked byte-identical) diff --git a/.run/P36/agents/ov_SC06_018__func_8018AD74/related.txt b/.run/P36/agents/ov_SC06_018__func_8018AD74/related.txt new file mode 100644 index 000000000..dbcc11821 --- /dev/null +++ b/.run/P36/agents/ov_SC06_018__func_8018AD74/related.txt @@ -0,0 +1,116 @@ +=== lever-free bodies in ov_SC06_018 sharing a callee or global with func_8018AD74 (41 found; top 6 by shared symbols) — read them for the SHAPE === +--- func_8018AF88 (src/ov_SC06_018/ov_SC06_018_jr_80187AEC.c:5472) shares 2: D_800AE620 func_800484EC --- +void func_8018AF88(s32 param_1) +{ + /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every + LATER function in this TU, which blocks a byte-true decl of a different type. + Declaration-only move (cookbook §103); the whole-binary byte-gate is the arbiter. */ + extern Blk20_8018AF88 D_800AE620; + Blk20_8018AF88 local_30; + Blk20_8018AF88 *m; + s32 iVar1; + s32 iVar2; + + local_30 = D_800AE620; + iVar1 = func_8012B8A4((s16 *)param_1); + m = &local_30; + RotMatrixY(iVar1, m); + ((void (*)(void *, void *, s32))func_800484EC)(m, &D_801CD498, param_1 + 0x10); + *(s32 *)(param_1 + 0x14) = 0xFFDC0000; + *(s32 *)(param_1 + 0xE0) = 0xFFDC0000; + *(s32 *)(param_1 + 0x1C) = 0x10; + iVar2 = rand(); + *(u16 *)(param_1 + 0x106) = iVar2 & 0x70; + iVar2 = rand(); + *(u16 *)(param_1 + 0x108) = iVar2 & 0x70; + func_8012AD44((s32 *)param_1, 1); +} + +--- func_80189000 (src/ov_SC06_018/ov_SC06_018_jr_80187AEC.c:3976) shares 2: func_800484EC func_8012C658 --- +void func_80189000(s32 a0, s32 a1) { + s32 buf10[8]; /* sp+0x10 (0x20) - func_80049CAC out / func_800484EC in */ + s32 g40[4]; /* sp+0x30, only [0..2] used - func_800484EC vec3 arg */ + u16 g30[4]; /* sp+0x40, only [0..2] used - func_80049CAC vec3 arg */ + unsigned int buf48[2]; /* sp+0x48 (8) - func_8012B0B4 output */ + unsigned int *p48; + s32 i; + s32 baseY; + s32 e; + u32 uVar; + s32 scratch; + s32 tmp; + + i = 0; + p48 = buf48; + baseY = 0x100; + do { + e = func_80132EF4(a0, 0x23); + if (e != 0) { + *(s16 *)(e + 0x34) = rand() % 0x4000 + 0x1000; + *(u16 *)(*(s32 *)(e + 0x20) + 0x2c) = 0xc008; + + func_8012B0B4(p48, rand() % 0x1000, rand() % 0x58); + + tmp = *(s32 *)buf48; + *(s16 *)(e + 6) = *(s16 *)(e + 6) + (s16)tmp; + *(s16 *)(e + 0xe) = *(s16 *)(e + 0xe) + (s16)(tmp >> 16); + + tmp = rand(); + scratch = tmp % 0x80; + uVar = rand(); + g30[0] = (uVar & 1) == 0 ? -scratch + 0x400 : scratch + 0x400; + + scratch = rand() % 0xc0; + uVar = rand(); + g30[1] = (uVar & 1) != 0 ? baseY + scratch : baseY - scratch; + + g30[2] = 0; + g40[1] = 0; + g40[0] = 0; + g40[2] = (rand() % 4 + 3) << 16; + + ((void (*)(void *, void *))func_80049CAC)(g30, buf10); + ((void (*)(void *, void *, s32))func_800484EC)(buf10, g40, e + 0x10); + } + i++; + baseY += 0x200; + } while (i < 8); + + e = func_80132EF4(a0, 0x23); + if (e != 0) { + *(u16 *)(e + 0x34) = 0x7ff1; + *(u16 *)(*(s32 *)(e + 0x20) + 0x2c) = 0xc004; + *(s32 *)(e + 0x14) = 0xfffb0000; + } + + i = 0; + do { + func_8012C658(0x29d, (u16)a1, a0); + i++; + } while (i < 4); + + ((s32 (*)())func_80189E60)(a0, 0x95e); +} + +--- func_8012B14C (src/shared/ov/func_8012B14C.h:4) shares 1: func_800484EC --- +void func_8012B14C(s32 a0, s32 a1) { + func_800484EC(*(s32 *)((s32)a0 + 0x20) + 0x34, a1, (s32)a0 + 0x10); +} + +--- func_80143994 (src/shared/ov/func_80143994.h:4) shares 1: func_8012C658 --- +void func_80143994(s32 a0, s32 a1) { + func_8012C658(0x1B, (s16)a1, a0); +} + +--- func_80143C74 (src/shared/ov/func_80143C74.h:4) shares 1: func_8012C658 --- +void func_80143C74(s32 a0, s32 a1) { + func_8012C658(0x205, a1, a0); +} + +--- func_80143CD4 (src/shared/ov/func_80143CD4.h:4) shares 1: func_8012C658 --- +void func_80143CD4(s32 a0) { + func_8012C658(0x39, 0, a0); + func_8012C658(0x39, 1, a0); + func_8012C658(0x39, 2, a0); +} + diff --git a/.run/P36/agents/ov_SC06_018__func_8018AD74/residual.txt b/.run/P36/agents/ov_SC06_018__func_8018AD74/residual.txt new file mode 100644 index 000000000..11b51ab1b --- /dev/null +++ b/.run/P36/agents/ov_SC06_018__func_8018AD74/residual.txt @@ -0,0 +1,9 @@ +src/ov_SC06_018/ov_SC06_018_jr_80187AEC.c:func_8018AD74: score 5 (COUNT; mine 60 ins, target 60) — not yet + insert mine[29:29] target[29:30] + 29 -- | jal 0 + replace mine[30:31] target[31:33] + 30 jal 0 | move s0,v0 + 31 -- | beqz s0,335c + delete mine[32:34] target[34:34] + 32 move s0,v0 | -- + 33 beqz s0,335c | -- diff --git a/.run/P36/agents/ov_SC06_018__func_8018AD74/sites.txt b/.run/P36/agents/ov_SC06_018__func_8018AD74/sites.txt new file mode 100644 index 000000000..a1f135d81 --- /dev/null +++ b/.run/P36/agents/ov_SC06_018__func_8018AD74/sites.txt @@ -0,0 +1 @@ +NEEDED launder line 5417 diff --git a/.run/P36/agents/ov_SC06_018__func_8018AD74/tu.txt b/.run/P36/agents/ov_SC06_018__func_8018AD74/tu.txt new file mode 100644 index 000000000..cfbe72aad --- /dev/null +++ b/.run/P36/agents/ov_SC06_018__func_8018AD74/tu.txt @@ -0,0 +1,2 @@ +src/ov_SC06_018/ov_SC06_018_jr_80187AEC.c +func_8018AD74 diff --git a/.run/P36/agents/ov_SC06_018__func_8018B9D4/body_free.c b/.run/P36/agents/ov_SC06_018__func_8018B9D4/body_free.c new file mode 100644 index 000000000..476f5dc4b --- /dev/null +++ b/.run/P36/agents/ov_SC06_018__func_8018B9D4/body_free.c @@ -0,0 +1,47 @@ +void func_8018B9D4(s32 param_1) +{ + struct { u16 a; u16 b; s16 c; u16 d; } t1; + struct { u16 a; u16 b; s16 c; u16 d; } t2; + s32 r1, r2, r3, r4; + s32 pad[2]; + s32 var_ea; + s32 var_fe; + s32 var_a0; + s32 var_v0; + + func_8018BCC4((void *)param_1, 0, (u16 *)(param_1 + 0xE8), 0x81818); + func_8018BCC4((void *)param_1, 1, (u16 *)(param_1 + 0xE8), 0x204040); + t1.b = 0; + t1.a = 0; + t1.c = -*(u16 *)(param_1 + 0xE8); + t2.b = 0; + t2.a = 0; + t2.c = -*(u16 *)(param_1 + 0xEA); + (void)r1; (void)r2; (void)r3; (void)r4; (void)pad; + if (func_8012DEB8(param_1, &t1, &t2) != 0) { + D_80126B96 = 0x4018; + D_80126B98 = 0x96; + } + var_ea = *(s16 *)(param_1 + 0xEA); + var_fe = *(s16 *)(param_1 + 0xFE); + var_a0 = var_ea + 0; + if (var_ea < var_fe) { + var_v0 = var_a0 + 0x40; + *(s16 *)(param_1 + 0xEA) = var_v0; + if ((var_v0 << 16) >> 16 >= *(s16 *)(param_1 + 0xFE)) { + *(s16 *)(param_1 + 0xEA) = *(s16 *)(param_1 + 0xFE); + func_8018BC40(param_1); + } + } else { + var_v0 = *(u16 *)(param_1 + 0xE8) + 0x40; + *(u16 *)(param_1 + 0xE8) = var_v0; + if ((var_v0 << 16) >> 16 < *(s16 *)(param_1 + 0xFE)) { + return; + } + if (*(s32 *)(param_1 + 0xCC) != 0) { + func_80016714((void *)*(s32 *)(param_1 + 0xCC), 0x38); + } + *(s32 *)(*(s32 *)(param_1 + 0x64) + 0xD0) = 0; + func_8012C218((void *)param_1); + } +} diff --git a/.run/P36/agents/ov_SC06_018__func_8018B9D4/body_tree.c b/.run/P36/agents/ov_SC06_018__func_8018B9D4/body_tree.c new file mode 100644 index 000000000..683bce0e1 --- /dev/null +++ b/.run/P36/agents/ov_SC06_018__func_8018B9D4/body_tree.c @@ -0,0 +1,48 @@ +void func_8018B9D4(s32 param_1) +{ + struct { u16 a; u16 b; s16 c; u16 d; } t1; + struct { u16 a; u16 b; s16 c; u16 d; } t2; + s32 r1, r2, r3, r4; + s32 pad[2]; + s32 var_ea; + s32 var_fe; + s32 var_a0; + s32 var_v0; + register s32 zr __asm__("$0"); // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus9) + + func_8018BCC4((void *)param_1, 0, (u16 *)(param_1 + 0xE8), 0x81818); + func_8018BCC4((void *)param_1, 1, (u16 *)(param_1 + 0xE8), 0x204040); + t1.b = 0; + t1.a = 0; + t1.c = -*(u16 *)(param_1 + 0xE8); + t2.b = 0; + t2.a = 0; + t2.c = -*(u16 *)(param_1 + 0xEA); + (void)r1; (void)r2; (void)r3; (void)r4; (void)pad; + if (func_8012DEB8(param_1, &t1, &t2) != 0) { + D_80126B96 = 0x4018; + D_80126B98 = 0x96; + } + var_ea = *(s16 *)(param_1 + 0xEA); + var_fe = *(s16 *)(param_1 + 0xFE); + var_a0 = var_ea + zr; + if (var_ea < var_fe) { + var_v0 = var_a0 + 0x40; + *(s16 *)(param_1 + 0xEA) = var_v0; + if ((var_v0 << 16) >> 16 >= *(s16 *)(param_1 + 0xFE)) { + *(s16 *)(param_1 + 0xEA) = *(s16 *)(param_1 + 0xFE); + func_8018BC40(param_1); + } + } else { + var_v0 = *(u16 *)(param_1 + 0xE8) + 0x40; + *(u16 *)(param_1 + 0xE8) = var_v0; + if ((var_v0 << 16) >> 16 < *(s16 *)(param_1 + 0xFE)) { + return; + } + if (*(s32 *)(param_1 + 0xCC) != 0) { + func_80016714((void *)*(s32 *)(param_1 + 0xCC), 0x38); + } + *(s32 *)(*(s32 *)(param_1 + 0x64) + 0xD0) = 0; + func_8012C218((void *)param_1); + } +} diff --git a/.run/P36/agents/ov_SC06_018__func_8018B9D4/history.txt b/.run/P36/agents/ov_SC06_018__func_8018B9D4/history.txt new file mode 100644 index 000000000..956a6d96c --- /dev/null +++ b/.run/P36/agents/ov_SC06_018__func_8018B9D4/history.txt @@ -0,0 +1,14 @@ +g6b: verdict NO-MATCH start 5 best 1 compiles 318 path R12 width var_a0 s32->u16 @5914 + R8 temp tmp0 @5930 + R12 width tmp0 s16->u16 @5916 +best-scoring single candidates of the last trace (move -> score [residual class]): + R12 width tmp0 s16->u16 @5916 -> 1 [OTHER] (from 4) + R12 width var_a0 s32->u16 @5914 -> 4 [COUNT] (from 5) + R6 inline var_fe @5931 -> 4 [COUNT] (from 4) + R8 temp tmp0 @5930 -> 4 [COUNT] (from 4) + R7 block @5930 -> 4 [COUNT] (from 4) + R9 swap-stmts @5930 -> 4 [COUNT] (from 4) + R8 base tmp0 @5930 -> 4 [COUNT] (from 4) + R7 do-while @5930 -> 4 [COUNT] (from 4) + R8 temp tmp0 @5937 -> 4 [COUNT] (from 4) + R7 block @5937 -> 4 [COUNT] (from 4) + R9 swap-stmts @5931 -> 4 [COUNT] (from 4) + R8 base tmp0 @5937 -> 4 [COUNT] (from 4) diff --git a/.run/P36/agents/ov_SC06_018__func_8018B9D4/neighbours.txt b/.run/P36/agents/ov_SC06_018__func_8018B9D4/neighbours.txt new file mode 100644 index 000000000..b1d430c91 --- /dev/null +++ b/.run/P36/agents/ov_SC06_018__func_8018B9D4/neighbours.txt @@ -0,0 +1,24 @@ +--- every @class/@stuck/@crack note in this translation unit --- +// @class: struct +// @stuck: none — MATCH (276 ins, relocation-masked). Verified BOTH standalone (match_one) and +// @class: branch-polarity +// @stuck: none — MATCH (32 ins), iteration 2. §3-T4: gcc-2.7.2 lays this out as +// @class: struct +// @stuck: none — §136c SIBLING-FIRST. Near-twin (byte-identical template) = func_80186160 in +// @class: loose-typing +// @stuck: none — MATCH (99 ins). short* for param_2/param_3: gcc emits lh where sign is live (<<1 for signed div), lhu where truncated to short (arith result / direct copy) +// @class: regalloc-order +// @stuck: none -- see match_one output. +// @class: regalloc-order +// @stuck: none -- see match_one output. +// @class: regalloc-order +// @stuck: none — MATCH (277 ins). p pinned $s1; e/spawn-ptr coalesce $s0; counter $s2; const2 hoisted $s3. + * @class: regalloc-order + * @stuck: none — MATCH (248 ins), iteration 2. + * @class: regalloc-order + * @class: regalloc-order + * @stuck: none — MATCH (170 ins), iteration 3. Body was E188 verbatim on +// @class: none +// @stuck: none — MATCH (397/397 ins, match_one + rtu_match). +// @class: other +// @stuck: none — MATCH (478 ins, relocation-masked byte-identical) diff --git a/.run/P36/agents/ov_SC06_018__func_8018B9D4/related.txt b/.run/P36/agents/ov_SC06_018__func_8018B9D4/related.txt new file mode 100644 index 000000000..5b4fb49d1 --- /dev/null +++ b/.run/P36/agents/ov_SC06_018__func_8018B9D4/related.txt @@ -0,0 +1,283 @@ +=== lever-free bodies in ov_SC06_018 sharing a callee or global with func_8018B9D4 (81 found; top 6 by shared symbols) — read them for the SHAPE === +--- func_80191320 (src/ov_SC06_018/ov_SC06_018_jr_8019059C.c:3282) shares 3: D_80126B96 func_80016714 func_8012C218 --- +void func_80191320(s32 arg0) { + s32 h; + s32 e; + s32 e2; + u16 tmp; + u16 tmp2; + u16 t34d; + u16 t34a; + u16 t34b; + u16 t34c; + s16 hn0; + s16 hn4; + s32 cnt; + u8 *p; + u8 *src; + s32 i; + s32 c; + u16 *v; + SV_80191320 sp10; + SV_80191320 sp18; + SV_80191320 sp20; + SV_80191320 sp28; + u32 col[2]; + s32 pad1[2]; + + if (*(s16 *)(arg0 + 0x100) != *(s16 *)(*(s32 *)(arg0 + 0x64) + 0x36)) { + h = *(s32 *)(arg0 + 0xCC); + if (h != 0) { + func_80016714((void *)h, 0x38); + } + goto kill; + } + + switch (*(u16 *)(arg0 + 0x34)) { + case 0: + ((s32 *)*(s32 *)(arg0 + 0x64))[7] = ((s32 *)*(s32 *)(arg0 + 0x64))[7] + 1; + src = (u8 *)(arg0 + 0xDC); + *(u32 *)((u8 *)col + 4) = 0x4040FF; + p = D_801D57F0; + i = 0; + do { + i++; + if (*(s16 *)(p + 0xE) == 0) { + *(Blk8_80191320 *)(p + 8) = *(Blk8_80191320 *)src; + *(Blk4_80191320 *)p = *(Blk4_80191320 *)((u8 *)col + 4); + c = p[0] >> 3; + p[4] = c; + if (c == 0) { + p[4] = 1; + } + c = p[1] >> 3; + p[5] = c; + if (c == 0) { + p[5] = 1; + } + c = p[2] >> 3; + p[6] = c; + if (c == 0) { + p[6] = 1; + } + break; + } + p += 0x10; + } while (i < 0x20); + hn0 = *(u16 *)(src + 6) - 0x100; + *(s16 *)(src + 6) = hn0; + if (hn0 == 0) { + e = func_8012C194(); + if (e != 0) { + *(s32 *)(arg0 + 0xCC) = e; + func_8001CD9C(e, &D_801D59F0); + *(u16 *)(e + 8) = *(u16 *)(arg0 + 6); + *(u16 *)(e + 0xA) = *(u16 *)(arg0 + 0xA); + tmp = *(u16 *)(arg0 + 0xE); + *(s32 *)(e + 4) = *(s32 *)(e + 4) | 0x50000000; + *(u16 *)(e + 0x18) = *(u16 *)(e + 0x1A) = 0x80; + *(u16 *)(e + 0x2C) = 0xC006; + *(u16 *)(e + 0xC) = tmp; + } + t34a = *(u16 *)(arg0 + 0x34); + *(s32 *)(arg0 + 0x1C) = 8; + *(u16 *)(arg0 + 0x34) = t34a + 1; + } + break; + + case 1: + ((s32 *)*(s32 *)(arg0 + 0x64))[7] = ((s32 *)*(s32 *)(arg0 + 0x64))[7] + 1; + e = *(s32 *)(arg0 + 0xCC); + if (*(s16 *)(e + 0x18) < 0x500) { + *(s16 *)(e + 0x18) = *(s16 *)(e + 0x18) + 0xC0; + *(u16 *)(e + 0x1A) = *(u16 *)(e + 0x1A) + 0xC0; + } + if (func_8012BEE8(arg0) != 0) { + *(u16 *)(arg0 + 0x102) = 0; + *(u16 *)(arg0 + 0x34) = *(u16 *)(arg0 + 0x34) + 1; + func_8002D4C8(0x9B9, 0); + } + break; + + case 2: + v = (u16 *)(arg0 + 0xE4); + ((s32 *)*(s32 *)(arg0 + 0x64))[7] = ((s32 *)*(s32 *)(arg0 + 0x64))[7] + 1; + func_8018F060(arg0, 0, v, 0x81818); + func_8018F060(arg0, 1, v, 0x204040); + sp10.vx = sp10.vy = 0; + sp10.vz = -*(u16 *)(arg0 + 0xE4); + sp18.vx = sp18.vy = 0; + sp18.vz = -*(u16 *)(arg0 + 0xE6); + if (func_8012D5E4(arg0, (s32)&sp10, (s32)&sp18, 0x96) != 0) { + D_80126B96 = 0x4018; + } + sp10.vx = sp10.vy = 0; + sp10.vz = -*(u16 *)(arg0 + 0xE6); + *(u16 *)(arg0 + 0xE6) = *(u16 *)(arg0 + 0xE6) + 0x40; + sp18.vx = sp18.vy = 0; + sp18.vz = -*(u16 *)(arg0 + 0xE6); + func_8012F214(arg0, (s32)&sp10, (s32)&sp20); + func_8012F214(arg0, (s32)&sp18, (s32)&sp28); + if (func_80133784(0x11, &sp20, (s32)&sp28) != 0) { + func_8012F038(*(s32 *)(arg0 + 0x20) + 0x34, (short *)&sp28, (short *)&sp20); + t34d = *(u16 *)(arg0 + 0x34) + 1; + *(u16 *)(arg0 + 0xE6) = -sp20.vz; + *(u16 *)(arg0 + 0x34) = t34d; + *(u16 *)(arg0 + 0xDC) = sp28.vx; + *(u16 *)(arg0 + 0xDE) = sp28.vy; + *(u16 *)(arg0 + 0xE0) = sp28.vz; + e2 = func_80132EF4(arg0, 0x23); + if (e2 != 0) { + *(u16 *)(e2 + 6) = *(u16 *)(arg0 + 0xDC); + *(u16 *)(e2 + 0xA) = *(u16 *)(arg0 + 0xDE); + tmp2 = *(u16 *)(arg0 + 0xE0); + *(u16 *)(e2 + 0x34) = 0x3001; + *(u16 *)(e2 + 0xE) = tmp2; + *(u16 *)(*(s32 *)(e2 + 0x20) + 0x2C) = 0xC008; + *(s32 *)(*(s32 *)(e2 + 0x20) + 4) = *(s32 *)(*(s32 *)(e2 + 0x20) + 4) | 0x50000000; + } + *(s32 *)(arg0 + 0x1C) = 0x1E; + *(u16 *)(arg0 + 0x102) = 1; + break; + } + if (*(s16 *)(arg0 + 0xE6) < 0x800) { + break; + } + t34b = *(u16 *)(arg0 + 0x34); + *(s32 *)(arg0 + 0x1C) = 0x1E; + *(u16 *)(arg0 + 0x34) = t34b + 1; + break; + + case 3: + v = (u16 *)(arg0 + 0xE4); + ((s32 *)*(s32 *)(arg0 + 0x64))[7] = ((s32 *)*(s32 *)(arg0 + 0x64))[7] + 1; + func_8018F060(arg0, 0, v, 0x81818); + func_8018F060(arg0, 1, v, 0x204040); + sp10.vx = sp10.vy = 0; + sp10.vz = -*(u16 *)(arg0 + 0xE4); + sp18.vx = sp18.vy = 0; + sp18.vz = -*(u16 *)(arg0 + 0xE6); + if (*(s16 *)(arg0 + 0x102) != 0) { + func_8012F214(arg0, (s32)&sp18, (s32)&sp28); + e = func_80143C74(arg0, 0); + if (e != 0) { + *(u16 *)(e + 6) = sp28.vx; + *(u16 *)(e + 0xA) = sp28.vy; + *(u16 *)(e + 0xE) = sp28.vz; + *(s32 *)(e + 0x10) = ((rand() & 0x7F) - 0x40) << 12; + *(s16 *)(e + 0x16) = -0x10; + *(s32 *)(e + 0x18) = ((rand() & 0x7F) - 0x40) << 12; + } + } + if (func_8012D5E4(arg0, (s32)&sp10, (s32)&sp18, 0x96) != 0) { + D_80126B96 = 0x4018; + } + cnt = *(s32 *)(arg0 + 0x1C) - 1; + *(s32 *)(arg0 + 0x1C) = cnt; + if (cnt == 0) { + e = *(s32 *)(arg0 + 0xCC); + if (e != 0) { + func_80016714((void *)e, 0x38); + t34c = *(u16 *)(arg0 + 0x34); + *(s32 *)(arg0 + 0xCC) = 0; + *(u16 *)(arg0 + 0x34) = t34c + 1; + } + } + break; + + case 4: + v = (u16 *)(arg0 + 0xE4); + func_8018F060(arg0, 0, v, 0x81818); + func_8018F060(arg0, 1, v, 0x204040); + sp10.vx = sp10.vy = 0; + sp10.vz = -*(u16 *)(arg0 + 0xE4); + sp18.vx = sp18.vy = 0; + sp18.vz = -*(u16 *)(arg0 + 0xE6); + if (*(s16 *)(arg0 + 0x102) != 0) { + func_8012F214(arg0, (s32)&sp18, (s32)&sp28); + e = func_80143C74(arg0, 0); + if (e != 0) { + *(u16 *)(e + 6) = sp28.vx; + *(u16 *)(e + 0xA) = sp28.vy; + *(u16 *)(e + 0xE) = sp28.vz; + *(s32 *)(e + 0x10) = ((rand() & 0x7F) - 0x40) << 12; + *(s16 *)(e + 0x16) = -0x10; + *(s32 *)(e + 0x18) = ((rand() & 0x7F) - 0x40) << 12; + } + } + if (func_8012D5E4(arg0, (s32)&sp10, (s32)&sp18, 0x96) != 0) { + D_80126B96 = 0x4018; + } + hn4 = v[0] + 0x40; + v[0] = hn4; + if (hn4 < *(s16 *)(v + 1)) { + break; + } + kill: + func_8012C218((void *)arg0); + return; + } + + func_8018F694(); + if (D_801D59F0 == 0xFF) { + *(Blk4_80191320 *)&D_801D59F0 = *(Blk4_80191320 *)D_801D3B1C; + } else { + *(Blk4_80191320 *)&D_801D59F0 = *(Blk4_80191320 *)D_801D3B14; + } +} + +--- func_801439C0 (src/shared/ov/func_801439C0.h:5) shares 2: func_80016714 func_8012C218 --- +void func_801439C0(u8 *a0) { + if (a0 != 0) { + func_80016714(*(void **)(a0 + 0xCC), 0x38); + func_8012C218(a0); + } +} + +--- func_8012D5E4 (src/shared/ov/func_8012D5E4.h:5) shares 2: D_80126B98 func_8012DEB8 --- +s32 func_8012D5E4(s32 a0, s32 a1, s32 a2, s32 a3) { + if (func_8012DEB8(a0, a1, a2) != 0) { + D_80126B98 = a3; + return 1; + } + return 0; +} + +--- func_8012F568 (src/shared/ov/func_8012F568.h:10) shares 2: D_80126B96 D_80126B98 --- +void func_8012F568(s32 param_1, s32 param_2, s32 param_3, s32 param_4, s32 param_5, s32 param_6) +{ + do { memcpy(&D_80126C38, param_5, 8); } while (0); + memcpy(&D_80126C40, param_6, 8); + D_80126B96 = param_2; + D_80126B9A = param_3; + D_80126B98 = param_4; + D_80126B94 = D_80126B94 | param_1; +} + +--- func_8014462C (src/shared/ov/func_8014462C.h:7) shares 2: func_80016714 func_8012C218 --- +void func_8014462C(u8 *a0) { + u8 *s1 = *(u8 **)(a0 + 0xCC); + func_8012AD80((s32)a0); + *(u16 *)(s1 + 8) = *(u16 *)(a0 + 6); + *(u16 *)(s1 + 0xA) = *(u16 *)(a0 + 0xA); + *(u16 *)(s1 + 0xC) = *(u16 *)(a0 + 0xE); + if (func_80128ED8(s1, a0 + 0xD0)) { + func_80016714(s1, 0x38); + func_8012C218(a0); + } +} + +--- func_8018BB18 (src/ov_SC06_018/ov_SC06_018_jr_80187AEC.c:5957) shares 2: func_80016714 func_8012C218 --- +void func_8018BB18(void *a0) { + D_801CD4D0[*(u16 *)((s32)a0 + 0x2)](); + if (*(u16 *)a0 != 0) { + if ((*(s16 *)(*(s32 *)((s32)a0 + 0x64) + 0x36) != *(s16 *)((s32)a0 + 0x100)) || + (*(u16 *)(*(s32 *)((s32)a0 + 0x64) + 0x2) == 4)) { + if (*(s32 *)((s32)a0 + 0xCC) != 0) { + func_80016714((void *)(*(s32 *)((s32)a0 + 0xCC)), 0x38); + } + func_8012C218(a0); + } + } +} + diff --git a/.run/P36/agents/ov_SC06_018__func_8018B9D4/residual.txt b/.run/P36/agents/ov_SC06_018__func_8018B9D4/residual.txt new file mode 100644 index 000000000..9c9516933 --- /dev/null +++ b/.run/P36/agents/ov_SC06_018__func_8018B9D4/residual.txt @@ -0,0 +1,9 @@ +src/ov_SC06_018/ov_SC06_018_jr_80187AEC.c:func_8018B9D4: score 5 (MIXED; mine 81 ins, target 81) — not yet + register pairs (mine -> target, count): v1->v0 x2, v0->v1 x2, v1->a0 x1 + replace mine[38:42] target[38:42] + 38 lh v1,234(s1) | lh v0,234(s1) + 39 lh v0,254(s1) | lh v1,254(s1) + 40 nop | move a0,v0 + 41 slt v0,v1,v0 | slt v0,v0,v1 + replace mine[43:44] target[43:44] + 43 addiu v0,v1,64 | addiu v0,a0,64 diff --git a/.run/P36/agents/ov_SC06_018__func_8018B9D4/sites.txt b/.run/P36/agents/ov_SC06_018__func_8018B9D4/sites.txt new file mode 100644 index 000000000..c9d91b6f8 --- /dev/null +++ b/.run/P36/agents/ov_SC06_018__func_8018B9D4/sites.txt @@ -0,0 +1 @@ +NEEDED pin $0 line 5940 diff --git a/.run/P36/agents/ov_SC06_018__func_8018B9D4/tu.txt b/.run/P36/agents/ov_SC06_018__func_8018B9D4/tu.txt new file mode 100644 index 000000000..666ea4de4 --- /dev/null +++ b/.run/P36/agents/ov_SC06_018__func_8018B9D4/tu.txt @@ -0,0 +1,2 @@ +src/ov_SC06_018/ov_SC06_018_jr_80187AEC.c +func_8018B9D4 diff --git a/.run/P36/delever/calibration.json b/.run/P36/delever/calibration.json index 72208435a..d236596d4 100644 --- a/.run/P36/delever/calibration.json +++ b/.run/P36/delever/calibration.json @@ -1,7 +1,7 @@ { - "head": "8fb959e07", + "head": "c5786dac6", "stamp": "15956e4a96c4", - "generated": "2026-09-11 00:14", + "generated": "2026-09-11 00:27", "aliases": [ "main", "ov_SC03_014", @@ -21,207 +21,207 @@ "main": { "objects": 85, "identical": 85, - "seconds": 11.181, - "mean_s": 0.132 + "seconds": 10.756, + "mean_s": 0.127 }, "ov_SC03_014": { "objects": 32, "identical": 32, - "seconds": 7.3580000000000005, - "mean_s": 0.23 + "seconds": 6.919000000000001, + "mean_s": 0.216 }, "ov_SC03_015": { "objects": 32, "identical": 32, - "seconds": 6.9399999999999995, - "mean_s": 0.217 + "seconds": 6.4350000000000005, + "mean_s": 0.201 }, "ov_SC04_011": { "objects": 28, "identical": 28, - "seconds": 6.489000000000001, - "mean_s": 0.232 + "seconds": 5.906000000000001, + "mean_s": 0.211 } }, "per_object_seconds": { - "build/src/800.o": 1.113, - "build/src/800_b.o": 0.155, - "build/src/800_b_2.o": 0.451, - "build/src/800_b_o0a.o": 0.149, - "build/src/800_c.o": 0.318, - "build/src/800b2.o": 0.14, - "build/src/apicard1.o": 0.129, - "build/src/apicard2.o": 0.1, - "build/src/apicard3.o": 0.084, - "build/src/apicard4.o": 0.104, - "build/src/apicard5.o": 0.091, - "build/src/apicard6.o": 0.099, - "build/src/apicard7.o": 0.099, - "build/src/boot.o": 0.109, - "build/src/gap.o": 0.094, - "build/src/libapi1.o": 0.145, - "build/src/libapi2.o": 0.076, - "build/src/libc2_1.o": 0.125, - "build/src/libc2_2.o": 0.067, - "build/src/libcd1.o": 0.134, - "build/src/libcd2.o": 0.106, - "build/src/libetc.o": 0.116, - "build/src/libgpu.o": 0.138, - "build/src/libgpu2.o": 0.138, - "build/src/libgs1.o": 0.136, - "build/src/libgs2.o": 0.131, - "build/src/libgs3.o": 0.127, - "build/src/libgs4.o": 0.114, - "build/src/libgs5.o": 0.112, - "build/src/libgs6.o": 0.107, - "build/src/libgs7.o": 0.097, - "build/src/libgs8.o": 0.122, - "build/src/libgte1.o": 0.105, - "build/src/libgte10.o": 0.084, - "build/src/libgte11.o": 0.093, - "build/src/libgte12.o": 0.092, - "build/src/libgte13.o": 0.091, - "build/src/libgte14.o": 0.119, - "build/src/libgte15.o": 0.17, - "build/src/libgte16.o": 0.142, - "build/src/libgte17.o": 0.11, - "build/src/libgte18.o": 0.161, - "build/src/libgte19.o": 0.174, - "build/src/libgte2.o": 0.163, - "build/src/libgte20.o": 0.096, - "build/src/libgte21.o": 0.112, - "build/src/libgte22.o": 0.101, - "build/src/libgte23.o": 0.099, - "build/src/libgte24.o": 0.09, - "build/src/libgte25.o": 0.095, - "build/src/libgte26.o": 0.079, - "build/src/libgte27.o": 0.097, - "build/src/libgte28.o": 0.103, - "build/src/libgte29.o": 0.089, - "build/src/libgte3.o": 0.133, - "build/src/libgte30.o": 0.156, - "build/src/libgte4.o": 0.137, - "build/src/libgte5.o": 0.152, - "build/src/libgte6.o": 0.097, - "build/src/libgte7.o": 0.089, - "build/src/libgte8.o": 0.135, - "build/src/libgte9.o": 0.083, - "build/src/libmcrd1.o": 0.118, - "build/src/libmcrd2.o": 0.121, - "build/src/libpad1.o": 0.14, - "build/src/libpad2.o": 0.089, - "build/src/sgap.o": 0.102, - "build/src/sgap_2.o": 0.099, - "build/src/sgap_3.o": 0.098, - "build/src/sgap_4.o": 0.107, - "build/src/sgap_5.o": 0.087, - "build/src/sgap_6.o": 0.119, - "build/src/sgap_8.o": 0.125, - "build/src/snd1.o": 0.192, - "build/src/snd10.o": 0.092, - "build/src/snd11.o": 0.078, - "build/src/snd12.o": 0.11, - "build/src/snd2.o": 0.089, - "build/src/snd3.o": 0.08, - "build/src/snd4.o": 0.136, - "build/src/snd5.o": 0.075, - "build/src/snd6.o": 0.094, - "build/src/snd7.o": 0.115, - "build/src/snd8.o": 0.138, - "build/src/snd9.o": 0.104, - "build/src/ov_SC03_014/ov_SC03_014.o": 0.194, - "build/src/ov_SC03_014/ov_SC03_014_after.o": 0.735, - "build/src/ov_SC03_014/ov_SC03_014_jr_8012ACE0.o": 0.684, - "build/src/ov_SC03_014/ov_SC03_014_jr_80135888.o": 0.093, - "build/src/ov_SC03_014/ov_SC03_014_jr_80135A4C.o": 0.094, - "build/src/ov_SC03_014/ov_SC03_014_jr_80135D20.o": 0.172, - "build/src/ov_SC03_014/ov_SC03_014_jr_801380E0.o": 0.266, - "build/src/ov_SC03_014/ov_SC03_014_jr_8013C98C.o": 0.227, - "build/src/ov_SC03_014/ov_SC03_014_jr_8013F350.o": 0.148, - "build/src/ov_SC03_014/ov_SC03_014_jr_8013FFD8.o": 0.14, - "build/src/ov_SC03_014/ov_SC03_014_jr_80140608.o": 0.278, - "build/src/ov_SC03_014/ov_SC03_014_jr_8015444C.o": 0.13, - "build/src/ov_SC03_014/ov_SC03_014_jr_80154C24.o": 0.306, - "build/src/ov_SC03_014/ov_SC03_014_jr_801588CC.o": 0.124, - "build/src/ov_SC03_014/ov_SC03_014_jr_80159C84.o": 0.156, - "build/src/ov_SC03_014/ov_SC03_014_jr_8015A3C8.o": 0.105, - "build/src/ov_SC03_014/ov_SC03_014_jr_8015AE2C.o": 0.131, - "build/src/ov_SC03_014/ov_SC03_014_jr_8015C32C.o": 0.708, - "build/src/ov_SC03_014/ov_SC03_014_jr_8016AB6C.o": 0.462, - "build/src/ov_SC03_014/ov_SC03_014_jr_80171B4C.o": 0.143, - "build/src/ov_SC03_014/ov_SC03_014_jr_801734BC.o": 0.34, - "build/src/ov_SC03_014/ov_SC03_014_jr_801789AC.o": 0.122, - "build/src/ov_SC03_014/ov_SC03_014_jr_80178D40.o": 0.149, + "build/src/800.o": 1.069, + "build/src/800_b.o": 0.17, + "build/src/800_b_2.o": 0.446, + "build/src/800_b_o0a.o": 0.106, + "build/src/800_c.o": 0.328, + "build/src/800b2.o": 0.145, + "build/src/apicard1.o": 0.113, + "build/src/apicard2.o": 0.077, + "build/src/apicard3.o": 0.103, + "build/src/apicard4.o": 0.118, + "build/src/apicard5.o": 0.088, + "build/src/apicard6.o": 0.092, + "build/src/apicard7.o": 0.136, + "build/src/boot.o": 0.116, + "build/src/gap.o": 0.148, + "build/src/libapi1.o": 0.073, + "build/src/libapi2.o": 0.099, + "build/src/libc2_1.o": 0.094, + "build/src/libc2_2.o": 0.118, + "build/src/libcd1.o": 0.088, + "build/src/libcd2.o": 0.112, + "build/src/libetc.o": 0.081, + "build/src/libgpu.o": 0.095, + "build/src/libgpu2.o": 0.154, + "build/src/libgs1.o": 0.104, + "build/src/libgs2.o": 0.121, + "build/src/libgs3.o": 0.1, + "build/src/libgs4.o": 0.13, + "build/src/libgs5.o": 0.084, + "build/src/libgs6.o": 0.103, + "build/src/libgs7.o": 0.107, + "build/src/libgs8.o": 0.078, + "build/src/libgte1.o": 0.081, + "build/src/libgte10.o": 0.172, + "build/src/libgte11.o": 0.076, + "build/src/libgte12.o": 0.149, + "build/src/libgte13.o": 0.097, + "build/src/libgte14.o": 0.104, + "build/src/libgte15.o": 0.102, + "build/src/libgte16.o": 0.112, + "build/src/libgte17.o": 0.088, + "build/src/libgte18.o": 0.127, + "build/src/libgte19.o": 0.137, + "build/src/libgte2.o": 0.148, + "build/src/libgte20.o": 0.101, + "build/src/libgte21.o": 0.089, + "build/src/libgte22.o": 0.116, + "build/src/libgte23.o": 0.149, + "build/src/libgte24.o": 0.093, + "build/src/libgte25.o": 0.098, + "build/src/libgte26.o": 0.153, + "build/src/libgte27.o": 0.083, + "build/src/libgte28.o": 0.099, + "build/src/libgte29.o": 0.118, + "build/src/libgte3.o": 0.091, + "build/src/libgte30.o": 0.078, + "build/src/libgte4.o": 0.076, + "build/src/libgte5.o": 0.11, + "build/src/libgte6.o": 0.099, + "build/src/libgte7.o": 0.102, + "build/src/libgte8.o": 0.125, + "build/src/libgte9.o": 0.076, + "build/src/libmcrd1.o": 0.121, + "build/src/libmcrd2.o": 0.133, + "build/src/libpad1.o": 0.093, + "build/src/libpad2.o": 0.084, + "build/src/sgap.o": 0.147, + "build/src/sgap_2.o": 0.102, + "build/src/sgap_3.o": 0.081, + "build/src/sgap_4.o": 0.086, + "build/src/sgap_5.o": 0.106, + "build/src/sgap_6.o": 0.141, + "build/src/sgap_8.o": 0.09, + "build/src/snd1.o": 0.119, + "build/src/snd10.o": 0.103, + "build/src/snd11.o": 0.094, + "build/src/snd12.o": 0.166, + "build/src/snd2.o": 0.1, + "build/src/snd3.o": 0.079, + "build/src/snd4.o": 0.106, + "build/src/snd5.o": 0.093, + "build/src/snd6.o": 0.104, + "build/src/snd7.o": 0.148, + "build/src/snd8.o": 0.118, + "build/src/snd9.o": 0.097, + "build/src/ov_SC03_014/ov_SC03_014.o": 0.214, + "build/src/ov_SC03_014/ov_SC03_014_after.o": 0.737, + "build/src/ov_SC03_014/ov_SC03_014_jr_8012ACE0.o": 0.535, + "build/src/ov_SC03_014/ov_SC03_014_jr_80135888.o": 0.12, + "build/src/ov_SC03_014/ov_SC03_014_jr_80135A4C.o": 0.118, + "build/src/ov_SC03_014/ov_SC03_014_jr_80135D20.o": 0.148, + "build/src/ov_SC03_014/ov_SC03_014_jr_801380E0.o": 0.225, + "build/src/ov_SC03_014/ov_SC03_014_jr_8013C98C.o": 0.189, + "build/src/ov_SC03_014/ov_SC03_014_jr_8013F350.o": 0.104, + "build/src/ov_SC03_014/ov_SC03_014_jr_8013FFD8.o": 0.115, + "build/src/ov_SC03_014/ov_SC03_014_jr_80140608.o": 0.242, + "build/src/ov_SC03_014/ov_SC03_014_jr_8015444C.o": 0.102, + "build/src/ov_SC03_014/ov_SC03_014_jr_80154C24.o": 0.243, + "build/src/ov_SC03_014/ov_SC03_014_jr_801588CC.o": 0.161, + "build/src/ov_SC03_014/ov_SC03_014_jr_80159C84.o": 0.1, + "build/src/ov_SC03_014/ov_SC03_014_jr_8015A3C8.o": 0.122, + "build/src/ov_SC03_014/ov_SC03_014_jr_8015AE2C.o": 0.129, + "build/src/ov_SC03_014/ov_SC03_014_jr_8015C32C.o": 0.661, + "build/src/ov_SC03_014/ov_SC03_014_jr_8016AB6C.o": 0.392, + "build/src/ov_SC03_014/ov_SC03_014_jr_80171B4C.o": 0.146, + "build/src/ov_SC03_014/ov_SC03_014_jr_801734BC.o": 0.27, + "build/src/ov_SC03_014/ov_SC03_014_jr_801789AC.o": 0.112, + "build/src/ov_SC03_014/ov_SC03_014_jr_80178D40.o": 0.151, "build/src/ov_SC03_014/ov_SC03_014_jr_8017A4AC.o": 0.11, - "build/src/ov_SC03_014/ov_SC03_014_jr_8017AE2C.o": 0.202, - "build/src/ov_SC03_014/ov_SC03_014_jr_8017EB7C.o": 0.269, - "build/src/ov_SC03_014/ov_SC03_014_jr_80184440.o": 0.073, - "build/src/ov_SC03_014/ov_SC03_014_jr_801848E4.o": 0.35, - "build/src/ov_SC03_014/ov_SC03_014_o0b.o": 0.09, - "build/src/ov_SC03_014/ov_SC03_014_o0c.o": 0.133, - "build/src/ov_SC03_014/ov_SC03_014_o0d.o": 0.111, - "build/src/ov_SC03_014/ov_SC03_014_o0e.o": 0.113, - "build/src/ov_SC03_015/ov_SC03_015.o": 0.28, - "build/src/ov_SC03_015/ov_SC03_015_after.o": 0.688, - "build/src/ov_SC03_015/ov_SC03_015_jr_8012ACE0.o": 0.533, - "build/src/ov_SC03_015/ov_SC03_015_jr_80135888.o": 0.107, - "build/src/ov_SC03_015/ov_SC03_015_jr_80135A4C.o": 0.083, - "build/src/ov_SC03_015/ov_SC03_015_jr_80135D20.o": 0.173, - "build/src/ov_SC03_015/ov_SC03_015_jr_801380E0.o": 0.238, - "build/src/ov_SC03_015/ov_SC03_015_jr_8013C98C.o": 0.159, - "build/src/ov_SC03_015/ov_SC03_015_jr_8013F350.o": 0.102, - "build/src/ov_SC03_015/ov_SC03_015_jr_8013FFD8.o": 0.105, - "build/src/ov_SC03_015/ov_SC03_015_jr_80140608.o": 0.332, - "build/src/ov_SC03_015/ov_SC03_015_jr_8015444C.o": 0.1, - "build/src/ov_SC03_015/ov_SC03_015_jr_80154C24.o": 0.238, - "build/src/ov_SC03_015/ov_SC03_015_jr_801588CC.o": 0.14, - "build/src/ov_SC03_015/ov_SC03_015_jr_80159C84.o": 0.093, - "build/src/ov_SC03_015/ov_SC03_015_jr_8015A3C8.o": 0.096, - "build/src/ov_SC03_015/ov_SC03_015_jr_8015AE2C.o": 0.129, - "build/src/ov_SC03_015/ov_SC03_015_jr_8015C32C.o": 0.704, - "build/src/ov_SC03_015/ov_SC03_015_jr_8016AB6C.o": 0.367, - "build/src/ov_SC03_015/ov_SC03_015_jr_80171B4C.o": 0.14, - "build/src/ov_SC03_015/ov_SC03_015_jr_801734BC.o": 0.318, - "build/src/ov_SC03_015/ov_SC03_015_jr_801789AC.o": 0.083, - "build/src/ov_SC03_015/ov_SC03_015_jr_80178D40.o": 0.156, - "build/src/ov_SC03_015/ov_SC03_015_jr_8017A4AC.o": 0.115, - "build/src/ov_SC03_015/ov_SC03_015_jr_8017AE2C.o": 0.232, - "build/src/ov_SC03_015/ov_SC03_015_jr_8017EB7C.o": 0.321, - "build/src/ov_SC03_015/ov_SC03_015_jr_80184440.o": 0.115, - "build/src/ov_SC03_015/ov_SC03_015_jr_801848E4.o": 0.389, + "build/src/ov_SC03_014/ov_SC03_014_jr_8017AE2C.o": 0.249, + "build/src/ov_SC03_014/ov_SC03_014_jr_8017EB7C.o": 0.307, + "build/src/ov_SC03_014/ov_SC03_014_jr_80184440.o": 0.11, + "build/src/ov_SC03_014/ov_SC03_014_jr_801848E4.o": 0.369, + "build/src/ov_SC03_014/ov_SC03_014_o0b.o": 0.078, + "build/src/ov_SC03_014/ov_SC03_014_o0c.o": 0.118, + "build/src/ov_SC03_014/ov_SC03_014_o0d.o": 0.082, + "build/src/ov_SC03_014/ov_SC03_014_o0e.o": 0.16, + "build/src/ov_SC03_015/ov_SC03_015.o": 0.227, + "build/src/ov_SC03_015/ov_SC03_015_after.o": 0.626, + "build/src/ov_SC03_015/ov_SC03_015_jr_8012ACE0.o": 0.478, + "build/src/ov_SC03_015/ov_SC03_015_jr_80135888.o": 0.113, + "build/src/ov_SC03_015/ov_SC03_015_jr_80135A4C.o": 0.074, + "build/src/ov_SC03_015/ov_SC03_015_jr_80135D20.o": 0.164, + "build/src/ov_SC03_015/ov_SC03_015_jr_801380E0.o": 0.214, + "build/src/ov_SC03_015/ov_SC03_015_jr_8013C98C.o": 0.155, + "build/src/ov_SC03_015/ov_SC03_015_jr_8013F350.o": 0.119, + "build/src/ov_SC03_015/ov_SC03_015_jr_8013FFD8.o": 0.112, + "build/src/ov_SC03_015/ov_SC03_015_jr_80140608.o": 0.249, + "build/src/ov_SC03_015/ov_SC03_015_jr_8015444C.o": 0.129, + "build/src/ov_SC03_015/ov_SC03_015_jr_80154C24.o": 0.259, + "build/src/ov_SC03_015/ov_SC03_015_jr_801588CC.o": 0.149, + "build/src/ov_SC03_015/ov_SC03_015_jr_80159C84.o": 0.102, + "build/src/ov_SC03_015/ov_SC03_015_jr_8015A3C8.o": 0.107, + "build/src/ov_SC03_015/ov_SC03_015_jr_8015AE2C.o": 0.117, + "build/src/ov_SC03_015/ov_SC03_015_jr_8015C32C.o": 0.624, + "build/src/ov_SC03_015/ov_SC03_015_jr_8016AB6C.o": 0.361, + "build/src/ov_SC03_015/ov_SC03_015_jr_80171B4C.o": 0.181, + "build/src/ov_SC03_015/ov_SC03_015_jr_801734BC.o": 0.255, + "build/src/ov_SC03_015/ov_SC03_015_jr_801789AC.o": 0.105, + "build/src/ov_SC03_015/ov_SC03_015_jr_80178D40.o": 0.17, + "build/src/ov_SC03_015/ov_SC03_015_jr_8017A4AC.o": 0.096, + "build/src/ov_SC03_015/ov_SC03_015_jr_8017AE2C.o": 0.219, + "build/src/ov_SC03_015/ov_SC03_015_jr_8017EB7C.o": 0.248, + "build/src/ov_SC03_015/ov_SC03_015_jr_80184440.o": 0.093, + "build/src/ov_SC03_015/ov_SC03_015_jr_801848E4.o": 0.335, "build/src/ov_SC03_015/ov_SC03_015_o0b.o": 0.075, - "build/src/ov_SC03_015/ov_SC03_015_o0c.o": 0.103, - "build/src/ov_SC03_015/ov_SC03_015_o0d.o": 0.096, - "build/src/ov_SC03_015/ov_SC03_015_o0e.o": 0.13, - "build/src/ov_SC04_011/ov_SC04_011.o": 0.222, - "build/src/ov_SC04_011/ov_SC04_011_after.o": 0.734, - "build/src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.o": 0.492, - "build/src/ov_SC04_011/ov_SC04_011_jr_80135888.o": 0.113, - "build/src/ov_SC04_011/ov_SC04_011_jr_80135A4C.o": 0.086, + "build/src/ov_SC03_015/ov_SC03_015_o0c.o": 0.102, + "build/src/ov_SC03_015/ov_SC03_015_o0d.o": 0.09, + "build/src/ov_SC03_015/ov_SC03_015_o0e.o": 0.087, + "build/src/ov_SC04_011/ov_SC04_011.o": 0.218, + "build/src/ov_SC04_011/ov_SC04_011_after.o": 0.628, + "build/src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.o": 0.497, + "build/src/ov_SC04_011/ov_SC04_011_jr_80135888.o": 0.076, + "build/src/ov_SC04_011/ov_SC04_011_jr_80135A4C.o": 0.085, "build/src/ov_SC04_011/ov_SC04_011_jr_80135D20.o": 0.169, - "build/src/ov_SC04_011/ov_SC04_011_jr_801380E0.o": 0.222, - "build/src/ov_SC04_011/ov_SC04_011_jr_8013C98C.o": 0.181, - "build/src/ov_SC04_011/ov_SC04_011_jr_8013F350.o": 0.104, - "build/src/ov_SC04_011/ov_SC04_011_jr_8013FFD8.o": 0.088, - "build/src/ov_SC04_011/ov_SC04_011_jr_80140608.o": 0.253, - "build/src/ov_SC04_011/ov_SC04_011_jr_8015444C.o": 0.119, - "build/src/ov_SC04_011/ov_SC04_011_jr_80154C24.o": 0.235, - "build/src/ov_SC04_011/ov_SC04_011_jr_801588CC.o": 0.121, - "build/src/ov_SC04_011/ov_SC04_011_jr_80159C84.o": 0.12, - "build/src/ov_SC04_011/ov_SC04_011_jr_8015A3C8.o": 0.129, + "build/src/ov_SC04_011/ov_SC04_011_jr_801380E0.o": 0.193, + "build/src/ov_SC04_011/ov_SC04_011_jr_8013C98C.o": 0.205, + "build/src/ov_SC04_011/ov_SC04_011_jr_8013F350.o": 0.093, + "build/src/ov_SC04_011/ov_SC04_011_jr_8013FFD8.o": 0.112, + "build/src/ov_SC04_011/ov_SC04_011_jr_80140608.o": 0.234, + "build/src/ov_SC04_011/ov_SC04_011_jr_8015444C.o": 0.125, + "build/src/ov_SC04_011/ov_SC04_011_jr_80154C24.o": 0.22, + "build/src/ov_SC04_011/ov_SC04_011_jr_801588CC.o": 0.112, + "build/src/ov_SC04_011/ov_SC04_011_jr_80159C84.o": 0.093, + "build/src/ov_SC04_011/ov_SC04_011_jr_8015A3C8.o": 0.095, "build/src/ov_SC04_011/ov_SC04_011_jr_8015AE2C.o": 0.127, - "build/src/ov_SC04_011/ov_SC04_011_jr_8015C32C.o": 0.589, - "build/src/ov_SC04_011/ov_SC04_011_jr_8016AB6C.o": 0.347, - "build/src/ov_SC04_011/ov_SC04_011_jr_80171B4C.o": 0.166, - "build/src/ov_SC04_011/ov_SC04_011_jr_801734BC.o": 0.26, - "build/src/ov_SC04_011/ov_SC04_011_jr_801789AC.o": 0.092, - "build/src/ov_SC04_011/ov_SC04_011_jr_80178D40.o": 0.162, - "build/src/ov_SC04_011/ov_SC04_011_jr_8017A4AC.o": 0.159, - "build/src/ov_SC04_011/ov_SC04_011_jr_8017AE2C.o": 0.219, - "build/src/ov_SC04_011/ov_SC04_011_jr_8017D494.o": 0.804, - "build/src/ov_SC04_011/ov_SC04_011_o0b.o": 0.079, - "build/src/ov_SC04_011/ov_SC04_011_o0c.o": 0.097 + "build/src/ov_SC04_011/ov_SC04_011_jr_8015C32C.o": 0.537, + "build/src/ov_SC04_011/ov_SC04_011_jr_8016AB6C.o": 0.305, + "build/src/ov_SC04_011/ov_SC04_011_jr_80171B4C.o": 0.146, + "build/src/ov_SC04_011/ov_SC04_011_jr_801734BC.o": 0.261, + "build/src/ov_SC04_011/ov_SC04_011_jr_801789AC.o": 0.095, + "build/src/ov_SC04_011/ov_SC04_011_jr_80178D40.o": 0.152, + "build/src/ov_SC04_011/ov_SC04_011_jr_8017A4AC.o": 0.098, + "build/src/ov_SC04_011/ov_SC04_011_jr_8017AE2C.o": 0.138, + "build/src/ov_SC04_011/ov_SC04_011_jr_8017D494.o": 0.722, + "build/src/ov_SC04_011/ov_SC04_011_o0b.o": 0.082, + "build/src/ov_SC04_011/ov_SC04_011_o0c.o": 0.088 }, "ok": true, - "seconds": 4.1 + "seconds": 3.7 } diff --git a/.run/P36/delever/ledger.jsonl b/.run/P36/delever/ledger.jsonl index 9d7c6fbc7..5e07fb6dc 100644 --- a/.run/P36/delever/ledger.jsonl +++ b/.run/P36/delever/ledger.jsonl @@ -29354,3 +29354,9 @@ {"ts": "2026-09-11 00:21:40", "label": "s104_part3", "rung": "E", "calib": {"head": "8fb959e07", "stamp": "15956e4a96c4"}, "tu": "src/shared/ov/func_80177AD4.h", "fn": "func_80177AD4", "addr": 2149022420, "aliases": null, "header": true, "includers": 136, "nhash_before": "0c37726b4e4080d2d9008872081c96c674f95353", "nhash_after": "9d8dcc4968288cfdcff871a75212d36a39cd785e", "source": "delever_regen R20 chain-narrow b+c -> s16", "verdict": "LEVER-FREE", "sites": [], "compiles": 141, "seconds": 32.269, "objects": ["build/src/ov_MAIN_012/ov_MAIN_012_jr_80171B4C.o", "build/src/ov_SC01_000/ov_SC01_000_jr_801734BC.o", "build/src/ov_SC01_001/ov_SC01_001_jr_801734BC.o", "build/src/ov_SC01_004/ov_SC01_004_jr_801734BC.o", "build/src/ov_SC01_005/ov_SC01_005_jr_801734BC.o", "build/src/ov_SC01_006/ov_SC01_006_jr_801734BC.o", "build/src/ov_SC01_008/ov_SC01_008_jr_801734BC.o", "build/src/ov_SC01_009/ov_SC01_009_jr_801734BC.o", "build/src/ov_SC01_074/ov_SC01_074_jr_801734BC.o", "build/src/ov_SC01_077/ov_SC01_077_jr_801734BC.o", "build/src/ov_SC01_080/ov_SC01_080_jr_801734BC.o", "build/src/ov_SC01_084/ov_SC01_084_jr_801734BC.o", "build/src/ov_SC02_000/ov_SC02_000_jr_801734BC.o", "build/src/ov_SC02_003/ov_SC02_003_jr_801734BC.o", "build/src/ov_SC02_004/ov_SC02_004_jr_801734BC.o", "build/src/ov_SC02_005/ov_SC02_005_jr_801734BC.o", "build/src/ov_SC02_011/ov_SC02_011_jr_801734BC.o", "build/src/ov_SC02_015/ov_SC02_015_jr_801734BC.o", "build/src/ov_SC02_016/ov_SC02_016_jr_801734BC.o", "build/src/ov_SC02_017/ov_SC02_017_jr_801734BC.o", "build/src/ov_SC02_021/ov_SC02_021_jr_801734BC.o", "build/src/ov_SC02_026/ov_SC02_026_jr_801734BC.o", "build/src/ov_SC02_027/ov_SC02_027_jr_801734BC.o", "build/src/ov_SC02_028/ov_SC02_028_jr_801734BC.o", "build/src/ov_SC02_031/ov_SC02_031_jr_801734BC.o", "build/src/ov_SC02_035/ov_SC02_035_jr_801734BC.o", "build/src/ov_SC02_037/ov_SC02_037_jr_80171B4C.o", "build/src/ov_SC02_039/ov_SC02_039_jr_801734BC.o", "build/src/ov_SC02_041/ov_SC02_041_jr_801734BC.o", "build/src/ov_SC03_001/ov_SC03_001_jr_801734BC.o", "build/src/ov_SC03_002/ov_SC03_002_jr_801734BC.o", "build/src/ov_SC03_003/ov_SC03_003_jr_801734BC.o", "build/src/ov_SC03_006/ov_SC03_006_jr_801734BC.o", "build/src/ov_SC03_007/ov_SC03_007_jr_801734BC.o", "build/src/ov_SC03_010/ov_SC03_010_jr_801734BC.o", "build/src/ov_SC03_011/ov_SC03_011_jr_801734BC.o", "build/src/ov_SC03_012/ov_SC03_012_jr_801734BC.o", "build/src/ov_SC03_013/ov_SC03_013_jr_801734BC.o", "build/src/ov_SC03_014/ov_SC03_014_jr_801734BC.o", "build/src/ov_SC03_015/ov_SC03_015_jr_801734BC.o", "build/src/ov_SC03_023/ov_SC03_023_jr_801734BC.o", "build/src/ov_SC03_024/ov_SC03_024_jr_801734BC.o", "build/src/ov_SC03_028/ov_SC03_028_jr_801734BC.o", "build/src/ov_SC03_029/ov_SC03_029_jr_801734BC.o", "build/src/ov_SC03_030/ov_SC03_030_jr_801734BC.o", "build/src/ov_SC03_031/ov_SC03_031_jr_801734BC.o", "build/src/ov_SC03_089/ov_SC03_089_jr_801734BC.o", "build/src/ov_SC03_090/ov_SC03_090_jr_801734BC.o", "build/src/ov_SC03_091/ov_SC03_091_jr_801734BC.o", "build/src/ov_SC03_092/ov_SC03_092_jr_801734BC.o", "build/src/ov_SC03_093/ov_SC03_093_jr_801734BC.o", "build/src/ov_SC03_094/ov_SC03_094_jr_801734BC.o", "build/src/ov_SC03_095/ov_SC03_095_jr_801734BC.o", "build/src/ov_SC03_096/ov_SC03_096_jr_801734BC.o", "build/src/ov_SC03_097/ov_SC03_097_jr_801734BC.o", "build/src/ov_SC03_098/ov_SC03_098_jr_801734BC.o", "build/src/ov_SC03_099/ov_SC03_099_jr_801734BC.o", "build/src/ov_SC03_100/ov_SC03_100_jr_801734BC.o", "build/src/ov_SC03_101/ov_SC03_101_jr_801734BC.o", "build/src/ov_SC03_102/ov_SC03_102_jr_801734BC.o", "build/src/ov_SC03_103/ov_SC03_103_jr_801734BC.o", "build/src/ov_SC03_104/ov_SC03_104_jr_801734BC.o", "build/src/ov_SC03_105/ov_SC03_105_jr_801734BC.o", "build/src/ov_SC03_107/ov_SC03_107_jr_80171B4C.o", "build/src/ov_SC03_108/ov_SC03_108_jr_801734BC.o", "build/src/ov_SC03_109/ov_SC03_109_jr_801734BC.o", "build/src/ov_SC03_110/ov_SC03_110_jr_801734BC.o", "build/src/ov_SC03_111/ov_SC03_111_jr_801734BC.o", "build/src/ov_SC03_112/ov_SC03_112_jr_801734BC.o", "build/src/ov_SC03_113/ov_SC03_113_jr_801734BC.o", "build/src/ov_SC03_114/ov_SC03_114_jr_801734BC.o", "build/src/ov_SC03_115/ov_SC03_115_jr_801734BC.o", "build/src/ov_SC03_116/ov_SC03_116_jr_801734BC.o", "build/src/ov_SC03_117/ov_SC03_117_jr_801734BC.o", "build/src/ov_SC03_118/ov_SC03_118_jr_801734BC.o", "build/src/ov_SC03_119/ov_SC03_119_jr_801734BC.o", "build/src/ov_SC03_121/ov_SC03_121_jr_801734BC.o", "build/src/ov_SC03_124/ov_SC03_124_jr_801734BC.o", "build/src/ov_SC03_125/ov_SC03_125_jr_801734BC.o", "build/src/ov_SC03_126/ov_SC03_126_jr_801734BC.o", "build/src/ov_SC04_000/ov_SC04_000_jr_801734BC.o", "build/src/ov_SC04_002/ov_SC04_002_jr_801734BC.o", "build/src/ov_SC04_003/ov_SC04_003_jr_801734BC.o", "build/src/ov_SC04_004/ov_SC04_004_jr_801734BC.o", "build/src/ov_SC04_005/ov_SC04_005_jr_801734BC.o", "build/src/ov_SC04_006/ov_SC04_006_jr_801734BC.o", "build/src/ov_SC04_007/ov_SC04_007_jr_801734BC.o", "build/src/ov_SC04_008/ov_SC04_008_jr_801734BC.o", "build/src/ov_SC04_009/ov_SC04_009_jr_801734BC.o", "build/src/ov_SC04_010/ov_SC04_010_jr_801734BC.o", "build/src/ov_SC04_011/ov_SC04_011_jr_801734BC.o", "build/src/ov_SC04_012/ov_SC04_012_jr_801734BC.o", "build/src/ov_SC04_015/ov_SC04_015_jr_801734BC.o", "build/src/ov_SC04_016/ov_SC04_016_jr_801734BC.o", "build/src/ov_SC04_018/ov_SC04_018_jr_801734BC.o", "build/src/ov_SC04_019/ov_SC04_019_jr_801734BC.o", "build/src/ov_SC04_020/ov_SC04_020_jr_801734BC.o", "build/src/ov_SC04_021/ov_SC04_021_jr_801734BC.o", "build/src/ov_SC05_000/ov_SC05_000_jr_801734BC.o", "build/src/ov_SC05_001/ov_SC05_001_jr_801734BC.o", "build/src/ov_SC05_002/ov_SC05_002_jr_801734BC.o", "build/src/ov_SC05_003/ov_SC05_003_jr_801734BC.o", "build/src/ov_SC05_004/ov_SC05_004_jr_801734BC.o", "build/src/ov_SC05_005/ov_SC05_005_jr_801734BC.o", "build/src/ov_SC05_006/ov_SC05_006_jr_801734BC.o", "build/src/ov_SC05_007/ov_SC05_007_jr_801734BC.o", "build/src/ov_SC05_008/ov_SC05_008_jr_801734BC.o", "build/src/ov_SC05_009/ov_SC05_009_jr_801734BC.o", "build/src/ov_SC05_010/ov_SC05_010_jr_801734BC.o", "build/src/ov_SC05_011/ov_SC05_011_jr_801734BC.o", "build/src/ov_SC05_017/ov_SC05_017_jr_801734BC.o", "build/src/ov_SC05_018/ov_SC05_018_jr_801734BC.o", "build/src/ov_SC05_019/ov_SC05_019_jr_801734BC.o", "build/src/ov_SC06_000/ov_SC06_000_jr_801734BC.o", "build/src/ov_SC06_006/ov_SC06_006_jr_801734BC.o", "build/src/ov_SC06_008/ov_SC06_008_jr_801734BC.o", "build/src/ov_SC06_010/ov_SC06_010_jr_801734BC.o", "build/src/ov_SC06_011/ov_SC06_011_jr_801734BC.o", "build/src/ov_SC06_013/ov_SC06_013_jr_801734BC.o", "build/src/ov_SC06_014/ov_SC06_014_jr_801734BC.o", "build/src/ov_SC06_015/ov_SC06_015_jr_801734BC.o", "build/src/ov_SC06_016/ov_SC06_016_jr_801734BC.o", "build/src/ov_SC06_018/ov_SC06_018_jr_801734BC.o", "build/src/ov_SC06_020/ov_SC06_020_jr_801734BC.o", "build/src/ov_SC06_022/ov_SC06_022_jr_801734BC.o", "build/src/ov_SC06_024/ov_SC06_024_jr_801734BC.o", "build/src/ov_SC06_025/ov_SC06_025_jr_801734BC.o", "build/src/ov_SC06_027/ov_SC06_027_jr_801734BC.o", "build/src/ov_SC06_029/ov_SC06_029_jr_801734BC.o", "build/src/ov_SC06_030/ov_SC06_030_jr_801734BC.o", "build/src/ov_SC06_032/ov_SC06_032_jr_801734BC.o", "build/src/ov_SC06_033/ov_SC06_033_jr_801734BC.o", "build/src/ov_SC07_000/ov_SC07_000_jr_801734BC.o", "build/src/ov_SC07_001/ov_SC07_001_jr_801734BC.o", "build/src/ov_SC07_002/ov_SC07_002_jr_801734BC.o", "build/src/ov_SC07_006/ov_SC07_006_jr_80171B4C.o", "build/src/ov_SC07_007/ov_SC07_007_jr_80171B4C.o", "build/src/ov_SC07_008/ov_SC07_008_jr_801734BC.o", "build/src/ov_SC07_009/ov_SC07_009_jr_801734BC.o", "build/src/ov_SC07_010/ov_SC07_010_jr_80171B4C.o", "build/src/ov_SC07_011/ov_SC07_011_jr_80171B4C.o"], "before_text": "void func_80177AD4(int param_1, unsigned int param_2) {\n unsigned int c;\n register unsigned int b __asm__(\"$3\"); // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B headers1)\n char *base; short i; int f; int t;\n f = 0x100; i = 0; base = (char *)param_1;\n do {\n c = (param_2 << 16) >> 28;\n b = c;\n if ((c != 0) || (i == 3) || (i == 1)) f = 0;\n param_2 = param_2 << 4; i = i + 1;\n t = *(unsigned short *)(base + 0x1e);\n *(unsigned short *)(base + 0x1e) = f | (t & ~0x100);\n base[0x20] = b * 8 + 8;\n base = base + 0x14;\n } while (i < 4);\n}\n", "after_text": "void func_80177AD4(int param_1, unsigned int param_2) {\n short c;\n short b;\n char *base; short i; int f; int t;\n f = 0x100; i = 0; base = (char *)param_1;\n do {\n c = (param_2 << 16) >> 28;\n b = c;\n if ((c != 0) || (i == 3) || (i == 1)) f = 0;\n param_2 = param_2 << 4; i = i + 1;\n t = *(unsigned short *)(base + 0x1e);\n *(unsigned short *)(base + 0x1e) = f | (t & ~0x100);\n base[0x20] = b * 8 + 8;\n base = base + 0x14;\n } while (i < 4);\n}\n"} {"ts": "2026-09-11 00:21:52", "label": "s104_part3", "rung": "E", "calib": {"head": "8fb959e07", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_024/ov_SC06_024_jr_80186F00.c", "fn": "func_8018A950", "addr": 2149099856, "aliases": null, "header": false, "includers": 0, "nhash_before": "3fdf93f5d145bf865cd1b1bd4cf3e89b91ed8c41", "nhash_after": "853dff35c8307982eba40c518b80e1a3b249fa9d", "source": "delever_regen R7 do-while @14", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.252, "objects": ["build/src/ov_SC06_024/ov_SC06_024_jr_80186F00.o"], "before_text": "s32 func_8018A950(s32 param_1) {\n\n extern signed char D_801D443C[];\n int self = ((int)param_1);\n int iVar6;\n int iVar1;\n unsigned char buf[0x34];\n signed char *p;\n short i;\n int dest;\n int td;\n unsigned short t;\n\n iVar1 = *(int *)(self + 0x1c);\n iVar6 = *(int *)(self + 0x20);\n *(int *)(self + 0x1c) = iVar1 + 1;\n if (iVar1 < 2) {\n p = D_801D443C;\n i = 0;\n dest = *(int *)(self + 0xcc);\n t = *(unsigned short *)(self + 0x70);\n *(short *)(buf + 0x0c) = 0;\n *(short *)(buf + 0x0a) = 0;\n *(short *)(buf + 0x08) = 0;\n *(short *)(buf + 0x1c) = 0;\n *(short *)(buf + 0x14) = 0;\n *(short *)(buf + 0x04) = 0;\n buf[0x22] = 0;\n buf[0x21] = 0;\n buf[0x20] = 0;\n buf[0x2a] = 0;\n buf[0x29] = 0;\n buf[0x28] = 0;\n buf[0x2e] = 0;\n buf[0x2d] = 0;\n buf[0x2c] = 0;\n *(int *)(buf + 0x30) = 0x50000000;\n buf[0x25] = t;\n buf[0x26] = t;\n buf[0x24] = t;\n do {\n *(short *)(buf + 0x00) = *p++;\n *(short *)(buf + 0x02) = *p++;\n *(short *)(buf + 0x10) = *p++;\n *(short *)(buf + 0x12) = *p++;\n *(short *)(buf + 0x18) = *p++;\n *(short *)(buf + 0x1a) = *p--;\n func_80017758(buf, (void *)dest);\n i++;\n } while (i < 4);\n\n td = *(int *)(self + 0xd0);\n if (td != 0) {\n dest = td;\n p = D_801D443C;\n i = 0;\n t = *(unsigned short *)(self + 0x70);\n *(short *)(buf + 0x0c) = 0;\n *(short *)(buf + 0x0a) = 0;\n *(short *)(buf + 0x08) = 0;\n *(short *)(buf + 0x1c) = 0;\n *(short *)(buf + 0x14) = 0;\n *(short *)(buf + 0x04) = 0;\n buf[0x22] = 0;\n buf[0x21] = 0;\n buf[0x20] = 0;\n buf[0x2a] = 0;\n buf[0x29] = 0;\n buf[0x28] = 0;\n buf[0x2e] = 0;\n buf[0x2d] = 0;\n buf[0x2c] = 0;\n *(int *)(buf + 0x30) = 0x50000000;\n buf[0x25] = t;\n buf[0x26] = t;\n buf[0x24] = t;\n do {\n *(short *)(buf + 0x00) = *p++;\n *(short *)(buf + 0x02) = *p++;\n *(short *)(buf + 0x10) = *p++;\n *(short *)(buf + 0x12) = *p++;\n *(short *)(buf + 0x18) = *p++;\n *(short *)(buf + 0x1a) = *p--;\n func_80017758(buf, (void *)dest);\n i++;\n } while (i < 4);\n }\n *(short *)(self + 0x70) = *(short *)(self + 0x70) >> 1;\n *(unsigned short *)(iVar6 + 0x2c) |= 1;\n } else {\n __asm__ __volatile__(\"\" : \"=r\"(self) : \"0\"(self)); // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus9)\n ((void (*)(void *))func_8012C218)((void *)self);\n }\n}\n", "after_text": "s32 func_8018A950(s32 param_1) {\n\n extern signed char D_801D443C[];\n int self = ((int)param_1);\n int iVar6;\n int iVar1;\n unsigned char buf[0x34];\n signed char *p;\n short i;\n int dest;\n int td;\n unsigned short t;\n\n do { iVar1 = *(int *)(self + 0x1c); } while (0); // !FAKE: do-while \u2014 a LOOP-note scheduling barrier (sched.c:2058-2074; P36 R7)\n iVar6 = *(int *)(self + 0x20);\n *(int *)(self + 0x1c) = iVar1 + 1;\n if (iVar1 < 2) {\n p = D_801D443C;\n i = 0;\n dest = *(int *)(self + 0xcc);\n t = *(unsigned short *)(self + 0x70);\n *(short *)(buf + 0x0c) = 0;\n *(short *)(buf + 0x0a) = 0;\n *(short *)(buf + 0x08) = 0;\n *(short *)(buf + 0x1c) = 0;\n *(short *)(buf + 0x14) = 0;\n *(short *)(buf + 0x04) = 0;\n buf[0x22] = 0;\n buf[0x21] = 0;\n buf[0x20] = 0;\n buf[0x2a] = 0;\n buf[0x29] = 0;\n buf[0x28] = 0;\n buf[0x2e] = 0;\n buf[0x2d] = 0;\n buf[0x2c] = 0;\n *(int *)(buf + 0x30) = 0x50000000;\n buf[0x25] = t;\n buf[0x26] = t;\n buf[0x24] = t;\n do {\n *(short *)(buf + 0x00) = *p++;\n *(short *)(buf + 0x02) = *p++;\n *(short *)(buf + 0x10) = *p++;\n *(short *)(buf + 0x12) = *p++;\n *(short *)(buf + 0x18) = *p++;\n *(short *)(buf + 0x1a) = *p--;\n func_80017758(buf, (void *)dest);\n i++;\n } while (i < 4);\n\n td = *(int *)(self + 0xd0);\n if (td != 0) {\n dest = td;\n p = D_801D443C;\n i = 0;\n t = *(unsigned short *)(self + 0x70);\n *(short *)(buf + 0x0c) = 0;\n *(short *)(buf + 0x0a) = 0;\n *(short *)(buf + 0x08) = 0;\n *(short *)(buf + 0x1c) = 0;\n *(short *)(buf + 0x14) = 0;\n *(short *)(buf + 0x04) = 0;\n buf[0x22] = 0;\n buf[0x21] = 0;\n buf[0x20] = 0;\n buf[0x2a] = 0;\n buf[0x29] = 0;\n buf[0x28] = 0;\n buf[0x2e] = 0;\n buf[0x2d] = 0;\n buf[0x2c] = 0;\n *(int *)(buf + 0x30) = 0x50000000;\n buf[0x25] = t;\n buf[0x26] = t;\n buf[0x24] = t;\n do {\n *(short *)(buf + 0x00) = *p++;\n *(short *)(buf + 0x02) = *p++;\n *(short *)(buf + 0x10) = *p++;\n *(short *)(buf + 0x12) = *p++;\n *(short *)(buf + 0x18) = *p++;\n *(short *)(buf + 0x1a) = *p--;\n func_80017758(buf, (void *)dest);\n i++;\n } while (i < 4);\n }\n *(short *)(self + 0x70) = *(short *)(self + 0x70) >> 1;\n *(unsigned short *)(iVar6 + 0x2c) |= 1;\n } else {\n ((void (*)(void *))func_8012C218)((void *)self);\n }\n}\n"} {"ts": "2026-09-11 00:22:09", "label": "s104_part3", "rung": "E", "calib": {"head": "8fb959e07", "stamp": "15956e4a96c4"}, "tu": "src/shared/ov/func_8017CDF0__922320b0.h", "fn": "func_8017CDF0", "addr": 2149043696, "aliases": null, "header": true, "includers": 2, "nhash_before": "298ee32f2933b6d6cfb559b7109145b3236c5a49", "nhash_after": "40bd148c6f13234be45e5bd5ab4871a0dcf45a8f", "source": "delever_regen R12 width code s32->s16 @29", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.391, "objects": ["build/src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.o", "build/src/ov_SC07_001/ov_SC07_001_jr_8017BEBC.o"], "before_text": "void func_8017CDF0(s32 a0, s32 a1, s32 a2)\n{\n\n extern s32 func_800491EC(void);\n extern void func_800547D8(s32, MATRIX2_8017CDF0 *);\n extern void func_80052E38(MATRIX2_8017CDF0 *);\n extern u8 *D_800A5E60;\n extern u8 D_800A6610[];\n\n DVECTOR2_8017CDF0 tmpxy[4];\n SVECTOR2_8017CDF0 box[8];\n SVECTOR2_8017CDF0 sxy[8];\n SVECTOR2_8017CDF0 tri[4];\n MATRIX2_8017CDF0 mtx;\n struct { long otz, flag, opz, sz0, sz1, sz2, sz3; } g;\n\n s32 lim;\n s32 nparts;\n s32 j;\n u32 nprim;\n u32 i;\n Part_8017CDF0 *part;\n Prim_8017CDF0 *prim;\n u8 *pkt;\n u32 ot;\n u8 *vtx;\n u8 *va, *vb, *vc, *vd;\n u32 w;\n s32 code;\n u32 wx, wy, wz, wzh;\n s32 xa32, xb32, t32;\n s32 xmn1, xmx1, xmn2, xmx2;\n s32 mnc, mxc;\n s16 my, mny, mx, mn;\n\n if (*(s32 *)a0 != 0) {\n return;\n }\n\n lim = func_800491EC() + *(s32 *)(a0 + 0x64);\n func_800547D8(a2, &mtx);\n func_80052E38(&mtx);\n\n pkt = D_800A5E60;\n part = (Part_8017CDF0 *)(a1 + 0x14);\n nparts = *(s32 *)(a1 + 8);\n vtx = *(u8 **)(a1 + 0x10);\n ot = (u32)&D_800A6610[(*(u16 *)&D_800B9A02) << 14];\n\n for (j = 0; j < nparts; j++, part++) {\n wx = part->xx;\n mn = wx;\n mx = wx >> 16;\n wy = part->yy;\n mny = wy;\n my = wy >> 16;\n wz = part->zz;\n wzh = wz >> 16;\n box[0].vx = mn; box[0].vy = mny; box[0].vz = wz;\n box[1].vx = mx; box[1].vy = mny; box[1].vz = wz;\n box[2].vx = mn; box[2].vy = mny; box[2].vz = wzh;\n box[3].vx = mx; box[3].vy = mny; box[3].vz = wzh;\n\n gte_ldv3c(&box[0]);\n gte_rtpt();\n gte_stsxy3(&sxy[0], &sxy[1], &sxy[2]);\n gte_ldv0(&box[3]);\n gte_rtps();\n /* the far-face corners are filled inside the RTPS latency window \u2014 the\n volatile asms are hard sched barriers, so this ordering is SOURCE order */\n box[4].vx = mn; box[4].vy = my; box[4].vz = wz;\n box[5].vx = mx; box[5].vy = my; box[5].vz = wz;\n box[6].vx = mn; box[6].vy = my; box[6].vz = wzh;\n box[7].vx = mx; box[7].vy = my; box[7].vz = wzh;\n gte_stsxy(&sxy[3]);\n gte_ldv3c(&box[4]);\n gte_rtpt();\n gte_stsxy3(&sxy[4], &sxy[5], &sxy[6]);\n gte_ldv0(&box[7]);\n gte_rtps();\n gte_stsxy(&sxy[7]);\n gte_stszotz(&g.otz);\n\n if (lim >= g.otz) {\n xa32 = sxy[0].vx;\n xb32 = sxy[1].vx;\n if (xb32 < xa32) { xmx1 = xa32; xmn1 = xb32; } else { xmn1 = xa32; xmx1 = xb32; }\n t32 = sxy[2].vx;\n if (xmx1 < t32) xmx1 = t32; else if (t32 < xmn1) xmn1 = t32;\n t32 = sxy[3].vx;\n if (xmx1 < t32) xmx1 = t32; else if (t32 < xmn1) xmn1 = t32;\n xa32 = sxy[4].vx;\n xb32 = sxy[5].vx;\n if (xb32 < xa32) { xmx2 = xa32; xmn2 = xb32; } else { xmn2 = xa32; xmx2 = xb32; }\n t32 = sxy[6].vx;\n if (xmx2 < t32) xmx2 = t32; else if (t32 < xmn2) xmn2 = t32;\n t32 = sxy[7].vx;\n if (xmx2 < t32) xmx2 = t32; else if (t32 < xmn2) xmn2 = t32;\n mnc = xmn1;\n if (xmn2 < xmn1) mnc = xmn2;\n mxc = xmx1;\n if (mxc < xmx2) mxc = xmx2;\n if ((s16)mxc >= -0xA0 && (s16)mnc < 0xA1) {\n xa32 = sxy[0].vy;\n xb32 = sxy[1].vy;\n if (xb32 < xa32) { xmx1 = xa32; xmn1 = xb32; } else { xmn1 = xa32; xmx1 = xb32; }\n t32 = sxy[2].vy;\n if (xmx1 < t32) xmx1 = t32; else if (t32 < xmn1) xmn1 = t32;\n t32 = sxy[3].vy;\n if (xmx1 < t32) xmx1 = t32; else if (t32 < xmn1) xmn1 = t32;\n xa32 = sxy[4].vy;\n xb32 = sxy[5].vy;\n if (xb32 < xa32) { xmx2 = xa32; xmn2 = xb32; } else { xmn2 = xa32; xmx2 = xb32; }\n t32 = sxy[6].vy;\n if (xmx2 < t32) xmx2 = t32; else if (t32 < xmn2) xmn2 = t32;\n t32 = sxy[7].vy;\n if (xmx2 < t32) xmx2 = t32; else if (t32 < xmn2) xmn2 = t32;\n mnc = xmn1;\n if (xmn2 < xmn1) mnc = xmn2;\n mxc = xmx1;\n if (mxc < xmx2) mxc = xmx2;\n if ((s16)mxc >= -0x6E && (s16)mnc < 0x6F) {\n prim = (Prim_8017CDF0 *)part->prim;\n nprim = part->nprim;\n for (i = 0; i < nprim; i++, prim++) {\n w = prim->w1;\n va = vtx + (w & 0xFFFF);\n vb = vtx + (w >> 16);\n w = prim->w2;\n tri[0] = *(SVECTOR2_8017CDF0 *)va;\n tri[1] = *(SVECTOR2_8017CDF0 *)vb;\n vc = vtx + (w & 0xFFFF);\n w = w >> 16;\n tri[2] = *(SVECTOR2_8017CDF0 *)vc;\n gte_ldv3c(&tri[0]);\n gte_rtpt();\n gte_stflg(&g.flag);\n if (!(g.flag & 0x7F85E000)) {\n gte_nclip();\n code = w & 7;\n vd = vtx + (w & 0xFFF8);\n gte_stopz(&g.opz);\n if (g.opz > 0) {\n switch (code) {\n case 6:\n case 7:\n gte_stsxy3_ft3(pkt);\n gte_stsz3(&g.sz0, &g.sz1, &g.sz2);\n if (((PolyFT3_8017CDF0 *)pkt)->x0 > ((PolyFT3_8017CDF0 *)pkt)->x1) {\n mx = ((PolyFT3_8017CDF0 *)pkt)->x0;\n mn = ((PolyFT3_8017CDF0 *)pkt)->x1;\n } else {\n mn = ((PolyFT3_8017CDF0 *)pkt)->x0;\n mx = ((PolyFT3_8017CDF0 *)pkt)->x1;\n }\n if (((PolyFT3_8017CDF0 *)pkt)->x2 > mx) mx = ((PolyFT3_8017CDF0 *)pkt)->x2;\n else if (((PolyFT3_8017CDF0 *)pkt)->x2 < mn) mn = ((PolyFT3_8017CDF0 *)pkt)->x2;\n if (mx >= -0xA0 && mn < 0xA1) {\n if (((PolyFT3_8017CDF0 *)pkt)->y0 > ((PolyFT3_8017CDF0 *)pkt)->y1) {\n my = ((PolyFT3_8017CDF0 *)pkt)->y0;\n mny = ((PolyFT3_8017CDF0 *)pkt)->y1;\n } else {\n mny = ((PolyFT3_8017CDF0 *)pkt)->y0;\n my = ((PolyFT3_8017CDF0 *)pkt)->y1;\n }\n if (((PolyFT3_8017CDF0 *)pkt)->y2 > my) my = ((PolyFT3_8017CDF0 *)pkt)->y2;\n else if (((PolyFT3_8017CDF0 *)pkt)->y2 < mny) mny = ((PolyFT3_8017CDF0 *)pkt)->y2;\n if (my >= -0x6E && mny < 0x6F) {\n s32 za;\n u32 *otp;\n u32 *tp;\n u32 c0;\n if (g.sz0 > g.sz1) {\n za = g.sz0;\n if (za < g.sz2) za = g.sz2;\n } else {\n za = g.sz1;\n if (za < g.sz2) za = g.sz2;\n }\n tp = (u32 *)prim->w0;\n c0 = tp[0];\n g.opz = za;\n ((PolyFT3_8017CDF0 *)pkt)->rgbc = c0;\n ((PolyFT3_8017CDF0 *)pkt)->uvc0 = tp[1];\n ((PolyFT3_8017CDF0 *)pkt)->uvp1 = tp[2];\n ((PolyFT3_8017CDF0 *)pkt)->uv2 = tp[3];\n otp = (u32 *)(((za >> 2) << 2) + ot);\n *(u32 *)pkt = (*otp & 0xFFFFFF) | 0x7000000;\n *otp = (*otp & 0xFF000000) | ((u32)pkt & 0xFFFFFF);\n pkt += 0x28;\n }\n }\n break;\n case 2:\n case 3:\n gte_stsxy3c(&tmpxy[0]);\n tri[3] = *(SVECTOR2_8017CDF0 *)vd;\n gte_ldv0(&tri[3]);\n gte_rtps();\n if (tmpxy[0].vx > tmpxy[1].vx) {\n mx = tmpxy[0].vx;\n mn = tmpxy[1].vx;\n } else {\n mn = tmpxy[0].vx;\n mx = tmpxy[1].vx;\n }\n if (tmpxy[2].vx > mx) mx = tmpxy[2].vx;\n else if (tmpxy[2].vx < mn) mn = tmpxy[2].vx;\n if (tmpxy[0].vy > tmpxy[1].vy) {\n my = tmpxy[0].vy;\n mny = tmpxy[1].vy;\n } else {\n mny = tmpxy[0].vy;\n my = tmpxy[1].vy;\n }\n if (tmpxy[2].vy > my) my = tmpxy[2].vy;\n else if (tmpxy[2].vy < mny) mny = tmpxy[2].vy;\n gte_stflg(&g.flag);\n if (!(g.flag & 0x7F85E000)) {\n gte_stsz4(&g.sz0, &g.sz1, &g.sz2, &g.sz3);\n gte_stsxy((long *)&((PolyFT4_8017CDF0 *)pkt)->x3);\n if (((PolyFT4_8017CDF0 *)pkt)->x3 < mn) mn = ((PolyFT4_8017CDF0 *)pkt)->x3;\n else if (mx < ((PolyFT4_8017CDF0 *)pkt)->x3) mx = ((PolyFT4_8017CDF0 *)pkt)->x3;\n if (mx >= -0xA0 && mn < 0xA1) {\n if (((PolyFT4_8017CDF0 *)pkt)->y3 < mny) mny = ((PolyFT4_8017CDF0 *)pkt)->y3;\n else if (my < ((PolyFT4_8017CDF0 *)pkt)->y3) my = ((PolyFT4_8017CDF0 *)pkt)->y3;\n if (my >= -0x6E && mny < 0x6F) {\n s32 za, zb;\n u32 *otp;\n u32 *tp;\n u32 c0;\n u32 uvw;\n zb = g.sz2;\n if (zb < g.sz3) zb = g.sz3;\n za = g.sz0;\n if (za < g.sz1) za = g.sz1;\n if (za < zb) za = zb;\n g.opz = za;\n *(u32 *)&((PolyFT4_8017CDF0 *)pkt)->x0 = *(u32 *)&tmpxy[0];\n *(u32 *)&((PolyFT4_8017CDF0 *)pkt)->x1 = *(u32 *)&tmpxy[1];\n *(u32 *)&((PolyFT4_8017CDF0 *)pkt)->x2 = *(u32 *)&tmpxy[2];\n tp = (u32 *)prim->w0;\n ((PolyFT4_8017CDF0 *)pkt)->rgbc = tp[0];\n ((PolyFT4_8017CDF0 *)pkt)->uvc0 = tp[1];\n ((PolyFT4_8017CDF0 *)pkt)->uvp1 = tp[2];\n uvw = tp[3];\n ((PolyFT4_8017CDF0 *)pkt)->uv2 = uvw;\n ((PolyFT4_8017CDF0 *)pkt)->uv3 = uvw >> 16;\n otp = (u32 *)(((za >> 2) << 2) + ot);\n *(u32 *)pkt = (*otp & 0xFFFFFF) | 0x9000000;\n *otp = (*otp & 0xFF000000) | ((u32)pkt & 0xFFFFFF);\n pkt += 0x28;\n }\n }\n }\n break;\n }\n }\n }\n }\n }\n }\n }\n /* \u00a747 live-length slider: +1 static insn inside the loop-bound\n pseudo's range only (past the tri-base's last use) \u2014 splits the\n $fp contest toward &tri[0] so the bound spills, as the target does */\n __asm__ volatile (\"\"); // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B headers2)\n }\n D_800A5E60 = pkt;\n}\n", "after_text": "void func_8017CDF0(s32 a0, s32 a1, s32 a2)\n{\n\n extern s32 func_800491EC(void);\n extern void func_800547D8(s32, MATRIX2_8017CDF0 *);\n extern void func_80052E38(MATRIX2_8017CDF0 *);\n extern u8 *D_800A5E60;\n extern u8 D_800A6610[];\n\n DVECTOR2_8017CDF0 tmpxy[4];\n SVECTOR2_8017CDF0 box[8];\n SVECTOR2_8017CDF0 sxy[8];\n SVECTOR2_8017CDF0 tri[4];\n MATRIX2_8017CDF0 mtx;\n struct { long otz, flag, opz, sz0, sz1, sz2, sz3; } g;\n\n s32 lim;\n s32 nparts;\n s32 j;\n u32 nprim;\n u32 i;\n Part_8017CDF0 *part;\n Prim_8017CDF0 *prim;\n u8 *pkt;\n u32 ot;\n u8 *vtx;\n u8 *va, *vb, *vc, *vd;\n u32 w;\n s16 code;\n u32 wx, wy, wz, wzh;\n s32 xa32, xb32, t32;\n s32 xmn1, xmx1, xmn2, xmx2;\n s32 mnc, mxc;\n s16 my, mny, mx, mn;\n\n if (*(s32 *)a0 != 0) {\n return;\n }\n\n lim = func_800491EC() + *(s32 *)(a0 + 0x64);\n func_800547D8(a2, &mtx);\n func_80052E38(&mtx);\n\n pkt = D_800A5E60;\n part = (Part_8017CDF0 *)(a1 + 0x14);\n nparts = *(s32 *)(a1 + 8);\n vtx = *(u8 **)(a1 + 0x10);\n ot = (u32)&D_800A6610[(*(u16 *)&D_800B9A02) << 14];\n\n for (j = 0; j < nparts; j++, part++) {\n wx = part->xx;\n mn = wx;\n mx = wx >> 16;\n wy = part->yy;\n mny = wy;\n my = wy >> 16;\n wz = part->zz;\n wzh = wz >> 16;\n box[0].vx = mn; box[0].vy = mny; box[0].vz = wz;\n box[1].vx = mx; box[1].vy = mny; box[1].vz = wz;\n box[2].vx = mn; box[2].vy = mny; box[2].vz = wzh;\n box[3].vx = mx; box[3].vy = mny; box[3].vz = wzh;\n\n gte_ldv3c(&box[0]);\n gte_rtpt();\n gte_stsxy3(&sxy[0], &sxy[1], &sxy[2]);\n gte_ldv0(&box[3]);\n gte_rtps();\n /* the far-face corners are filled inside the RTPS latency window \u2014 the\n volatile asms are hard sched barriers, so this ordering is SOURCE order */\n box[4].vx = mn; box[4].vy = my; box[4].vz = wz;\n box[5].vx = mx; box[5].vy = my; box[5].vz = wz;\n box[6].vx = mn; box[6].vy = my; box[6].vz = wzh;\n box[7].vx = mx; box[7].vy = my; box[7].vz = wzh;\n gte_stsxy(&sxy[3]);\n gte_ldv3c(&box[4]);\n gte_rtpt();\n gte_stsxy3(&sxy[4], &sxy[5], &sxy[6]);\n gte_ldv0(&box[7]);\n gte_rtps();\n gte_stsxy(&sxy[7]);\n gte_stszotz(&g.otz);\n\n if (lim >= g.otz) {\n xa32 = sxy[0].vx;\n xb32 = sxy[1].vx;\n if (xb32 < xa32) { xmx1 = xa32; xmn1 = xb32; } else { xmn1 = xa32; xmx1 = xb32; }\n t32 = sxy[2].vx;\n if (xmx1 < t32) xmx1 = t32; else if (t32 < xmn1) xmn1 = t32;\n t32 = sxy[3].vx;\n if (xmx1 < t32) xmx1 = t32; else if (t32 < xmn1) xmn1 = t32;\n xa32 = sxy[4].vx;\n xb32 = sxy[5].vx;\n if (xb32 < xa32) { xmx2 = xa32; xmn2 = xb32; } else { xmn2 = xa32; xmx2 = xb32; }\n t32 = sxy[6].vx;\n if (xmx2 < t32) xmx2 = t32; else if (t32 < xmn2) xmn2 = t32;\n t32 = sxy[7].vx;\n if (xmx2 < t32) xmx2 = t32; else if (t32 < xmn2) xmn2 = t32;\n mnc = xmn1;\n if (xmn2 < xmn1) mnc = xmn2;\n mxc = xmx1;\n if (mxc < xmx2) mxc = xmx2;\n if ((s16)mxc >= -0xA0 && (s16)mnc < 0xA1) {\n xa32 = sxy[0].vy;\n xb32 = sxy[1].vy;\n if (xb32 < xa32) { xmx1 = xa32; xmn1 = xb32; } else { xmn1 = xa32; xmx1 = xb32; }\n t32 = sxy[2].vy;\n if (xmx1 < t32) xmx1 = t32; else if (t32 < xmn1) xmn1 = t32;\n t32 = sxy[3].vy;\n if (xmx1 < t32) xmx1 = t32; else if (t32 < xmn1) xmn1 = t32;\n xa32 = sxy[4].vy;\n xb32 = sxy[5].vy;\n if (xb32 < xa32) { xmx2 = xa32; xmn2 = xb32; } else { xmn2 = xa32; xmx2 = xb32; }\n t32 = sxy[6].vy;\n if (xmx2 < t32) xmx2 = t32; else if (t32 < xmn2) xmn2 = t32;\n t32 = sxy[7].vy;\n if (xmx2 < t32) xmx2 = t32; else if (t32 < xmn2) xmn2 = t32;\n mnc = xmn1;\n if (xmn2 < xmn1) mnc = xmn2;\n mxc = xmx1;\n if (mxc < xmx2) mxc = xmx2;\n if ((s16)mxc >= -0x6E && (s16)mnc < 0x6F) {\n prim = (Prim_8017CDF0 *)part->prim;\n nprim = part->nprim;\n for (i = 0; i < nprim; i++, prim++) {\n w = prim->w1;\n va = vtx + (w & 0xFFFF);\n vb = vtx + (w >> 16);\n w = prim->w2;\n tri[0] = *(SVECTOR2_8017CDF0 *)va;\n tri[1] = *(SVECTOR2_8017CDF0 *)vb;\n vc = vtx + (w & 0xFFFF);\n w = w >> 16;\n tri[2] = *(SVECTOR2_8017CDF0 *)vc;\n gte_ldv3c(&tri[0]);\n gte_rtpt();\n gte_stflg(&g.flag);\n if (!(g.flag & 0x7F85E000)) {\n gte_nclip();\n code = w & 7;\n vd = vtx + (w & 0xFFF8);\n gte_stopz(&g.opz);\n if (g.opz > 0) {\n switch (code) {\n case 6:\n case 7:\n gte_stsxy3_ft3(pkt);\n gte_stsz3(&g.sz0, &g.sz1, &g.sz2);\n if (((PolyFT3_8017CDF0 *)pkt)->x0 > ((PolyFT3_8017CDF0 *)pkt)->x1) {\n mx = ((PolyFT3_8017CDF0 *)pkt)->x0;\n mn = ((PolyFT3_8017CDF0 *)pkt)->x1;\n } else {\n mn = ((PolyFT3_8017CDF0 *)pkt)->x0;\n mx = ((PolyFT3_8017CDF0 *)pkt)->x1;\n }\n if (((PolyFT3_8017CDF0 *)pkt)->x2 > mx) mx = ((PolyFT3_8017CDF0 *)pkt)->x2;\n else if (((PolyFT3_8017CDF0 *)pkt)->x2 < mn) mn = ((PolyFT3_8017CDF0 *)pkt)->x2;\n if (mx >= -0xA0 && mn < 0xA1) {\n if (((PolyFT3_8017CDF0 *)pkt)->y0 > ((PolyFT3_8017CDF0 *)pkt)->y1) {\n my = ((PolyFT3_8017CDF0 *)pkt)->y0;\n mny = ((PolyFT3_8017CDF0 *)pkt)->y1;\n } else {\n mny = ((PolyFT3_8017CDF0 *)pkt)->y0;\n my = ((PolyFT3_8017CDF0 *)pkt)->y1;\n }\n if (((PolyFT3_8017CDF0 *)pkt)->y2 > my) my = ((PolyFT3_8017CDF0 *)pkt)->y2;\n else if (((PolyFT3_8017CDF0 *)pkt)->y2 < mny) mny = ((PolyFT3_8017CDF0 *)pkt)->y2;\n if (my >= -0x6E && mny < 0x6F) {\n s32 za;\n u32 *otp;\n u32 *tp;\n u32 c0;\n if (g.sz0 > g.sz1) {\n za = g.sz0;\n if (za < g.sz2) za = g.sz2;\n } else {\n za = g.sz1;\n if (za < g.sz2) za = g.sz2;\n }\n tp = (u32 *)prim->w0;\n c0 = tp[0];\n g.opz = za;\n ((PolyFT3_8017CDF0 *)pkt)->rgbc = c0;\n ((PolyFT3_8017CDF0 *)pkt)->uvc0 = tp[1];\n ((PolyFT3_8017CDF0 *)pkt)->uvp1 = tp[2];\n ((PolyFT3_8017CDF0 *)pkt)->uv2 = tp[3];\n otp = (u32 *)(((za >> 2) << 2) + ot);\n *(u32 *)pkt = (*otp & 0xFFFFFF) | 0x7000000;\n *otp = (*otp & 0xFF000000) | ((u32)pkt & 0xFFFFFF);\n pkt += 0x28;\n }\n }\n break;\n case 2:\n case 3:\n gte_stsxy3c(&tmpxy[0]);\n tri[3] = *(SVECTOR2_8017CDF0 *)vd;\n gte_ldv0(&tri[3]);\n gte_rtps();\n if (tmpxy[0].vx > tmpxy[1].vx) {\n mx = tmpxy[0].vx;\n mn = tmpxy[1].vx;\n } else {\n mn = tmpxy[0].vx;\n mx = tmpxy[1].vx;\n }\n if (tmpxy[2].vx > mx) mx = tmpxy[2].vx;\n else if (tmpxy[2].vx < mn) mn = tmpxy[2].vx;\n if (tmpxy[0].vy > tmpxy[1].vy) {\n my = tmpxy[0].vy;\n mny = tmpxy[1].vy;\n } else {\n mny = tmpxy[0].vy;\n my = tmpxy[1].vy;\n }\n if (tmpxy[2].vy > my) my = tmpxy[2].vy;\n else if (tmpxy[2].vy < mny) mny = tmpxy[2].vy;\n gte_stflg(&g.flag);\n if (!(g.flag & 0x7F85E000)) {\n gte_stsz4(&g.sz0, &g.sz1, &g.sz2, &g.sz3);\n gte_stsxy((long *)&((PolyFT4_8017CDF0 *)pkt)->x3);\n if (((PolyFT4_8017CDF0 *)pkt)->x3 < mn) mn = ((PolyFT4_8017CDF0 *)pkt)->x3;\n else if (mx < ((PolyFT4_8017CDF0 *)pkt)->x3) mx = ((PolyFT4_8017CDF0 *)pkt)->x3;\n if (mx >= -0xA0 && mn < 0xA1) {\n if (((PolyFT4_8017CDF0 *)pkt)->y3 < mny) mny = ((PolyFT4_8017CDF0 *)pkt)->y3;\n else if (my < ((PolyFT4_8017CDF0 *)pkt)->y3) my = ((PolyFT4_8017CDF0 *)pkt)->y3;\n if (my >= -0x6E && mny < 0x6F) {\n s32 za, zb;\n u32 *otp;\n u32 *tp;\n u32 c0;\n u32 uvw;\n zb = g.sz2;\n if (zb < g.sz3) zb = g.sz3;\n za = g.sz0;\n if (za < g.sz1) za = g.sz1;\n if (za < zb) za = zb;\n g.opz = za;\n *(u32 *)&((PolyFT4_8017CDF0 *)pkt)->x0 = *(u32 *)&tmpxy[0];\n *(u32 *)&((PolyFT4_8017CDF0 *)pkt)->x1 = *(u32 *)&tmpxy[1];\n *(u32 *)&((PolyFT4_8017CDF0 *)pkt)->x2 = *(u32 *)&tmpxy[2];\n tp = (u32 *)prim->w0;\n ((PolyFT4_8017CDF0 *)pkt)->rgbc = tp[0];\n ((PolyFT4_8017CDF0 *)pkt)->uvc0 = tp[1];\n ((PolyFT4_8017CDF0 *)pkt)->uvp1 = tp[2];\n uvw = tp[3];\n ((PolyFT4_8017CDF0 *)pkt)->uv2 = uvw;\n ((PolyFT4_8017CDF0 *)pkt)->uv3 = uvw >> 16;\n otp = (u32 *)(((za >> 2) << 2) + ot);\n *(u32 *)pkt = (*otp & 0xFFFFFF) | 0x9000000;\n *otp = (*otp & 0xFF000000) | ((u32)pkt & 0xFFFFFF);\n pkt += 0x28;\n }\n }\n }\n break;\n }\n }\n }\n }\n }\n }\n }\n /* \u00a747 live-length slider: +1 static insn inside the loop-bound\n pseudo's range only (past the tri-base's last use) \u2014 splits the\n $fp contest toward &tri[0] so the bound spills, as the target does */\n }\n D_800A5E60 = pkt;\n}\n"} +{"ts": "2026-09-11 00:29:21", "label": "s104_part3", "rung": "E", "calib": {"head": "c5786dac6", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c", "fn": "func_8017E724", "addr": 2149050148, "aliases": null, "header": false, "includers": 0, "nhash_before": "eb8353a8682b4208cfb06061e711690cf73a14c0", "nhash_after": "11a3a1014aa66244accd69e13ce221ff360d6a12", "source": "delever_regen R18 bystander @20->18", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.304, "objects": ["build/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.o"], "before_text": "void func_8017E724(s32 param_1)\n{\n s16 arr[3];\n s32 a;\n register s32 cur __asm__(\"$16\"); // !FAKE: pin $16 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n register s32 ang __asm__(\"$17\"); // !FAKE: pin $17 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n s32 d;\n s32 d2;\n s32 t;\n s16 rot;\n s32 *base;\n\n a = ratan2(*(s16 *)&D_80126B5E, *(s16 *)&D_80126B66) & 0xFFF;\n *(s16 *)(param_1 + 0x22) = a;\n cur = (a + 0x400) & 0xFFF;\n base = &D_80126B58;\n d2 = (*(u16 *)((s32)D_80126B78 + 0x12) - cur) & 0xFFF;\n ang = cur;\n cur = a;\n rot = func_80047948(d2) / 32;\n *(s16 *)(param_1 + 0x2E) = -(func_8004787C(ang) * rot) / 4096;\n *(s16 *)(param_1 + 0x32) = -(func_80047948(ang) * rot) / 4096;\n\n arr[0] = D_80126B5E;\n arr[2] = D_80126B66;\n d = -0x480 - D_80126B62;\n if (D_80126B62 <= 0xFB7F) {\n t = (s16)d;\n if (t >= 0) {\n if (t >= 0x81) {\n goto L858;\n }\n t = -0x480;\n goto L868;\n }\n if (-t < 0x81) {\n goto L864;\n }\n L858:\n t = *(u16 *)((s32)base + 0xA) + 0x80;\n goto L868;\n L864:\n t = -0x480;\n } else {\n t = -0x480;\n }\nL868:\n arr[1] = t;\n func_8017E8A0(param_1, (s32)arr);\n func_8017EA68(param_1);\n}\n", "after_text": "void func_8017E724(s32 param_1)\n{\n s16 arr[3];\n s32 a;\n s32 cur;\n s32 ang;\n s32 d;\n s32 d2;\n s32 t;\n s16 rot;\n s32 *base;\n\n a = ratan2(*(s16 *)&D_80126B5E, *(s16 *)&D_80126B66) & 0xFFF;\n *(s16 *)(param_1 + 0x22) = a;\n cur = (a + 0x400) & 0xFFF;\n base = &D_80126B58;\n d2 = (*(u16 *)((s32)D_80126B78 + 0x12) - cur) & 0xFFF;\n rot = func_80047948(d2) / 32;\n ang = cur;\n cur = a;\n *(s16 *)(param_1 + 0x2E) = -(func_8004787C(ang) * rot) / 4096;\n *(s16 *)(param_1 + 0x32) = -(func_80047948(ang) * rot) / 4096;\n\n arr[0] = D_80126B5E;\n arr[2] = D_80126B66;\n d = -0x480 - D_80126B62;\n if (D_80126B62 <= 0xFB7F) {\n t = (s16)d;\n if (t >= 0) {\n if (t >= 0x81) {\n goto L858;\n }\n t = -0x480;\n goto L868;\n }\n if (-t < 0x81) {\n goto L864;\n }\n L858:\n t = *(u16 *)((s32)base + 0xA) + 0x80;\n goto L868;\n L864:\n t = -0x480;\n } else {\n t = -0x480;\n }\nL868:\n arr[1] = t;\n func_8017E8A0(param_1, (s32)arr);\n func_8017EA68(param_1);\n}\n"} +{"ts": "2026-09-11 00:29:27", "label": "s104_part3", "rung": "E", "calib": {"head": "c5786dac6", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC01_000/ov_SC01_000_jr_8017BEBC.c", "fn": "func_8017E3A0", "addr": 2149049248, "aliases": null, "header": false, "includers": 0, "nhash_before": "a59331b9a1899b9250c21027826214a3d7585c85", "nhash_after": "3a2e1d86f184e9c742cf620edb538219d5f18710", "source": "delever_regen R7 do-while @33", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.163, "objects": ["build/src/ov_SC01_000/ov_SC01_000_jr_8017BEBC.o"], "before_text": "void func_8017E3A0(s32 a0, s32 a1, s32 a2, s32 a3, s32 arg4, s32 arg5)\n{\n extern u8 *D_800A5E60;\n extern u8 D_800AF630[];\n extern u8 D_800AA608[];\n\n u8 *prim;\n u8 *fl;\n u32 *q;\n u32 *addrw;\n u32 v1;\n u32 val;\n u32 mlo, mhi;\n volatile s32 pad;\n\n prim = D_800A5E60;\n fl = D_800AF630;\n prim[3] = 4;\n prim[7] = 0x50;\n if (arg5 == 0) {\n prim[0xC] = 0xFF;\n prim[0xE] = 0;\n prim[0xD] = 0;\n prim[4] = arg4;\n prim[6] = 0;\n } else {\n prim[0xE] = 0xFF;\n prim[0xD] = 0;\n prim[0xC] = 0;\n prim[6] = arg4;\n prim[4] = 0;\n }\n prim[5] = 0;\n __asm__ __volatile__(\"\"); // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus10)\n mlo = 0xFFFFFF;\n ((u16 *)prim)[5] = a1;\n mhi = 0xFF000000;\n ((u16 *)prim)[4] = a0;\n ((u16 *)prim)[8] = a2;\n ((u16 *)prim)[9] = a3;\n *(u32 *)prim = (*(u32 *)prim & mhi) | (*(u32 *)&D_800AA608[*(u16 *)(fl + 0xA3D2) << 14] & mlo);\n q = (u32 *)D_800AA608;\n addrw = (u32 *)((s32)q + (*(u16 *)(fl + 0xA3D2) << 14));\n v1 = (u32)prim & mlo;\n val = *addrw;\n D_800A5E60 = (prim += 20);\n *addrw = (val & mhi) | v1;\n}\n", "after_text": "void func_8017E3A0(s32 a0, s32 a1, s32 a2, s32 a3, s32 arg4, s32 arg5)\n{\n extern u8 *D_800A5E60;\n extern u8 D_800AF630[];\n extern u8 D_800AA608[];\n\n u8 *prim;\n u8 *fl;\n u32 *q;\n u32 *addrw;\n u32 v1;\n u32 val;\n u32 mlo, mhi;\n volatile s32 pad;\n\n prim = D_800A5E60;\n fl = D_800AF630;\n prim[3] = 4;\n prim[7] = 0x50;\n if (arg5 == 0) {\n prim[0xC] = 0xFF;\n prim[0xE] = 0;\n prim[0xD] = 0;\n prim[4] = arg4;\n prim[6] = 0;\n } else {\n prim[0xE] = 0xFF;\n prim[0xD] = 0;\n prim[0xC] = 0;\n prim[6] = arg4;\n prim[4] = 0;\n }\n do { prim[5] = 0; } while (0); // !FAKE: do-while \u2014 a LOOP-note scheduling barrier (sched.c:2058-2074; P36 R7)\n mlo = 0xFFFFFF;\n ((u16 *)prim)[5] = a1;\n mhi = 0xFF000000;\n ((u16 *)prim)[4] = a0;\n ((u16 *)prim)[8] = a2;\n ((u16 *)prim)[9] = a3;\n *(u32 *)prim = (*(u32 *)prim & mhi) | (*(u32 *)&D_800AA608[*(u16 *)(fl + 0xA3D2) << 14] & mlo);\n q = (u32 *)D_800AA608;\n addrw = (u32 *)((s32)q + (*(u16 *)(fl + 0xA3D2) << 14));\n v1 = (u32)prim & mlo;\n val = *addrw;\n D_800A5E60 = (prim += 20);\n *addrw = (val & mhi) | v1;\n}\n"} +{"ts": "2026-09-11 00:29:30", "label": "s104_part3", "rung": "E", "calib": {"head": "c5786dac6", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_001/ov_SC03_001_jr_80184F64.c", "fn": "func_80185B54", "addr": 2149079892, "aliases": null, "header": false, "includers": 0, "nhash_before": "201bcc330aa875339fc212e7a3dcfc29fd94dd91", "nhash_after": "df3952572d365b61c05182052b5037bfafead900", "source": "delever_regen R21 chain tt=*(s32 *)((char *)s0 + 0xD4) @41", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.134, "objects": ["build/src/ov_SC03_001/ov_SC03_001_jr_80184F64.o"], "before_text": "void func_80185B54(void *arg0) {\n extern short D_80192864;\n extern short D_8019286C;\n extern short D_80192874;\n register s32 tc __asm__(\"$3\"); // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus10)\n register s32 p68 __asm__(\"$2\"); // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus10)\n s32 tt;\n void *s0 = arg0;\n\n if (func_8018727C(arg0, &D_80192874) != 0) {\n tc = ((s32 (*)(void))func_80029504)();\n if (tc < 20) {\n tt = 2;\n } else if (tc < 30) {\n tt = 7;\n } else if (tc < 100) {\n tt = 31;\n } else if (tc < 110) {\n *(s16 *)((char *)s0 + 2) = 12;\n *(s16 *)((char *)s0 + 0x34) = 0;\n func_8012E8E0((s32)s0, (s32)&D_8019286C);\n func_8012E88C((s32)s0);\n func_80187344((void *)s0);\n func_8014CB68();\n func_8012C588(343, (s32)s0);\n goto after;\n } else {\n tt = tc < 130;\n if (tt != 0) {\n tt = 18;\n } else {\n tt = 23;\n }\n }\n *(s16 *)((char *)s0 + 2) = tt;\n func_80187778((s32 *)s0, (s32)&D_80192864);\n goto after;\n after:\n p68 = *(s32 *)((char *)s0 + 0x68);\n *(s16 *)(p68 + 0xC) = 32767;\n tt = func_801788B8((s32)s0, (s32)&func_801856A8);\n *(s32 *)((char *)s0 + 0xD4) = tt;\n func_8012E8E0(tt, (s32)&D_80192864);\n }\n}\n", "after_text": "void func_80185B54(void *arg0) {\n extern short D_80192864;\n extern short D_8019286C;\n extern short D_80192874;\n s32 tc;\n s32 p68;\n s32 tt;\n void *s0 = arg0;\n\n if (func_8018727C(arg0, &D_80192874) != 0) {\n tc = ((s32 (*)(void))func_80029504)();\n if (tc < 20) {\n tt = 2;\n } else if (tc < 30) {\n tt = 7;\n } else if (tc < 100) {\n tt = 31;\n } else if (tc < 110) {\n *(s16 *)((char *)s0 + 2) = 12;\n *(s16 *)((char *)s0 + 0x34) = 0;\n func_8012E8E0((s32)s0, (s32)&D_8019286C);\n func_8012E88C((s32)s0);\n func_80187344((void *)s0);\n func_8014CB68();\n func_8012C588(343, (s32)s0);\n goto after;\n } else {\n tt = tc < 130;\n if (tt != 0) {\n tt = 18;\n } else {\n tt = 23;\n }\n }\n *(s16 *)((char *)s0 + 2) = tt;\n func_80187778((s32 *)s0, (s32)&D_80192864);\n goto after;\n after:\n p68 = *(s32 *)((char *)s0 + 0x68);\n *(s16 *)(p68 + 0xC) = 32767;\n tt = *(s32 *)((char *)s0 + 0xD4) = func_801788B8((s32)s0, (s32)&func_801856A8);\n func_8012E8E0(tt, (s32)&D_80192864);\n }\n}\n"} +{"ts": "2026-09-11 00:29:34", "label": "s104_part3", "rung": "E", "calib": {"head": "c5786dac6", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_003/ov_SC05_003_jr_8017BEBC.c", "fn": "func_8017F4FC", "addr": 2149053692, "aliases": null, "header": false, "includers": 0, "nhash_before": "6f54eef895515ae932c9f5b1721fb463a4eb07ec", "nhash_after": "689b9a686cb704a164991271db2c0c8919f834da", "source": "delever_regen R18 bystander @34->37", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.304, "objects": ["build/src/ov_SC05_003/ov_SC05_003_jr_8017BEBC.o"], "before_text": "void func_8017F4FC(void *a0) {\n s32 s0 = (s32)a0;\n s32 p20a;\n\n *(s16 *)(s0 + 0x76) = 0;\n\n if (*(s32 *)(s0 + 0xE4) == 0) {\n p20a = *(s32 *)(s0 + 0x20);\n *(u8 *)(s0 + 0xC1) = 0;\n *(s16 *)(s0 + 0x2) = 1;\n *(s32 *)(p20a + 0x4) |= 0x80000000;\n\n {\n s32 p20b = *(s32 *)(s0 + 0x20);\n *(s16 *)(s0 + 0x5E) = 0;\n *(s16 *)(s0 + 0x5C) = 0;\n *(s16 *)(p20b + 0x14) = 0;\n *(s16 *)(p20b + 0x12) = 0;\n *(s16 *)(p20b + 0x10) = 0;\n }\n\n {\n s32 p20c = *(s32 *)(s0 + 0x20);\n *(u16 *)(p20c + 0x1C) = 0x1000;\n *(u16 *)(p20c + 0x1A) = 0x1000;\n *(u16 *)(p20c + 0x18) = 0x1000;\n }\n\n {\n register u16 t88 __asm__(\"$2\") = *(u16 *)(s0 + 0x88); // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus9)\n register u16 t8A __asm__(\"$3\") = *(u16 *)(s0 + 0x8A); // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus9)\n *(s16 *)(s0 + 0xDE) = 0;\n *(s16 *)(s0 + 0xAA) = 0;\n *(u16 *)(s0 + 0xE) = *(u16 *)(s0 + 0x8C);\n *(u16 *)(s0 + 0x6) = t88;\n *(u16 *)(s0 + 0xA) = t8A;\n func_8012A828(s0, (s32)&D_801A410C);\n }\n func_8012B2CC(s0);\n func_8002A04C(s0);\n\n if (*(s32 *)(s0 + 0xCC) != 0) {\n func_801439C0(*(s32 *)(s0 + 0xCC));\n }\n } else {\n s32 p68;\n\n if ((*(s16 *)(s0 + 0x70) & 0x8000) == 0) {\n p68 = *(s32 *)(s0 + 0x68);\n if (p68 != 0) {\n if (*(s16 *)(s0 + 0x72) & 0x8000) {\n *(u16 *)(p68 + 0xA) = *(u16 *)(p68 + 0xA) & 0x7FFF;\n }\n }\n }\n func_8012C218((void *)s0);\n }\n}\n", "after_text": "void func_8017F4FC(void *a0) {\n s32 s0 = (s32)a0;\n s32 p20a;\n\n *(s16 *)(s0 + 0x76) = 0;\n\n if (*(s32 *)(s0 + 0xE4) == 0) {\n p20a = *(s32 *)(s0 + 0x20);\n *(u8 *)(s0 + 0xC1) = 0;\n *(s16 *)(s0 + 0x2) = 1;\n *(s32 *)(p20a + 0x4) |= 0x80000000;\n\n {\n s32 p20b = *(s32 *)(s0 + 0x20);\n *(s16 *)(s0 + 0x5E) = 0;\n *(s16 *)(s0 + 0x5C) = 0;\n *(s16 *)(p20b + 0x14) = 0;\n *(s16 *)(p20b + 0x12) = 0;\n *(s16 *)(p20b + 0x10) = 0;\n }\n\n {\n s32 p20c = *(s32 *)(s0 + 0x20);\n *(u16 *)(p20c + 0x1C) = 0x1000;\n *(u16 *)(p20c + 0x1A) = 0x1000;\n *(u16 *)(p20c + 0x18) = 0x1000;\n }\n\n {\n u16 t88 = *(u16 *)(s0 + 0x88);\n u16 t8A = *(u16 *)(s0 + 0x8A);\n *(s16 *)(s0 + 0xDE) = 0;\n *(s16 *)(s0 + 0xAA) = 0;\n *(u16 *)(s0 + 0x6) = t88;\n *(u16 *)(s0 + 0xA) = t8A;\n *(u16 *)(s0 + 0xE) = *(u16 *)(s0 + 0x8C);\n func_8012A828(s0, (s32)&D_801A410C);\n }\n func_8012B2CC(s0);\n func_8002A04C(s0);\n\n if (*(s32 *)(s0 + 0xCC) != 0) {\n func_801439C0(*(s32 *)(s0 + 0xCC));\n }\n } else {\n s32 p68;\n\n if ((*(s16 *)(s0 + 0x70) & 0x8000) == 0) {\n p68 = *(s32 *)(s0 + 0x68);\n if (p68 != 0) {\n if (*(s16 *)(s0 + 0x72) & 0x8000) {\n *(u16 *)(p68 + 0xA) = *(u16 *)(p68 + 0xA) & 0x7FFF;\n }\n }\n }\n func_8012C218((void *)s0);\n }\n}\n"} +{"ts": "2026-09-11 00:29:44", "label": "s104_part3", "rung": "E", "calib": {"head": "c5786dac6", "stamp": "15956e4a96c4"}, "tu": "src/800.c", "fn": "func_80020DA4", "addr": 2147618212, "aliases": null, "header": false, "includers": 0, "nhash_before": "13e7efd861982042ce5742382c2f8f7f7570312b", "nhash_after": "a8c50e1cadade326eb90b2f012730fe85cafd19f", "source": "delever_regen R7 do-while @30", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.8, "objects": ["build/src/800.o"], "before_text": "void func_80020DA4(s32 a0, s32 a1) {\n u16 *src = (u16 *)a0;\n s16 *dst = (s16 *)a1;\n s32 tbl = (s32)D_800636D4;\n\n s32 p0, p1, p2;\n s32 e0;\n s32 e1;\n s32 addr1, addr2;\n s32 hi0, lo0, hi1, lo1, hi2, lo2;\n s32 m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13;\n s32 p_ab, p_ac, p1v;\n s32 frame_pad[3]; (void)&frame_pad;\n\n p0 = src[0] & 0xFFF;\n e0 = *(s32 *)((p0 << 2) + tbl);\n p2 = src[2] & 0xFFF;\n addr2 = (p2 << 2) + tbl;\n hi0 = e0 >> 16;\n lo2 = *(s16 *)addr2;\n m1 = hi0 * lo2;\n hi2 = *(s16 *)(addr2 + 2);\n m2 = hi0 * hi2;\n p1 = src[1] & 0xFFF;\n __asm__(\"\" : \"=r\"(p1) : \"0\"(p1)); // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus9)\n addr1 = (p1 << 2) + tbl;\n lo0 = (s16)e0;\n lo1 = *(s16 *)addr1;\n m3 = lo0 * lo1;\n e1 = *(s32 *)addr1;\n hi1 = e1 >> 16;\n m4 = hi2 * hi1;\n p_ab = m3 >> 12;\n m5 = p_ab * hi2;\n p_ac = m2 >> 12;\n m6 = p_ac * lo1;\n m7 = lo0 * lo2;\n m8 = lo2 * hi1;\n m9 = p_ab * lo2;\n m10 = hi1 * lo0;\n m11 = hi1 * hi0;\n p1v = m1 >> 12;\n m12 = p1v * lo1;\n __asm__(\"\" : \"=r\"(e1) : \"0\"(e1)); // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus9)\n dst[6] = -e1;\n dst[0] = m4 >> 12;\n dst[3] = m8 >> 12;\n dst[7] = m10 >> 12;\n m13 = lo0 * hi2;\n dst[8] = m11 >> 12;\n dst[1] = (m5 >> 12) - p1v;\n dst[2] = (m6 >> 12) + (m7 >> 12);\n dst[4] = (m9 >> 12) + p_ac;\n dst[5] = (m12 >> 12) - (m13 >> 12);\n}\n", "after_text": "void func_80020DA4(s32 a0, s32 a1) {\n u16 *src = (u16 *)a0;\n s16 *dst = (s16 *)a1;\n s32 tbl = (s32)D_800636D4;\n\n s32 p0, p1, p2;\n s32 e0;\n s32 e1;\n s32 addr1, addr2;\n s32 hi0, lo0, hi1, lo1, hi2, lo2;\n s32 m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13;\n s32 p_ab, p_ac, p1v;\n s32 frame_pad[3]; (void)&frame_pad;\n\n p0 = src[0] & 0xFFF;\n e0 = *(s32 *)((p0 << 2) + tbl);\n p2 = src[2] & 0xFFF;\n addr2 = (p2 << 2) + tbl;\n hi0 = e0 >> 16;\n lo2 = *(s16 *)addr2;\n m1 = hi0 * lo2;\n hi2 = *(s16 *)(addr2 + 2);\n m2 = hi0 * hi2;\n p1 = src[1] & 0xFFF;\n addr1 = (p1 << 2) + tbl;\n lo0 = (s16)e0;\n lo1 = *(s16 *)addr1;\n m3 = lo0 * lo1;\n e1 = *(s32 *)addr1;\n do { hi1 = e1 >> 16; } while (0); // !FAKE: do-while \u2014 a LOOP-note scheduling barrier (sched.c:2058-2074; P36 R7)\n m4 = hi2 * hi1;\n p_ab = m3 >> 12;\n m5 = p_ab * hi2;\n p_ac = m2 >> 12;\n m6 = p_ac * lo1;\n m7 = lo0 * lo2;\n m8 = lo2 * hi1;\n m9 = p_ab * lo2;\n m10 = hi1 * lo0;\n m11 = hi1 * hi0;\n p1v = m1 >> 12;\n m12 = p1v * lo1;\n dst[6] = -e1;\n dst[0] = m4 >> 12;\n dst[3] = m8 >> 12;\n dst[7] = m10 >> 12;\n m13 = lo0 * hi2;\n dst[8] = m11 >> 12;\n dst[1] = (m5 >> 12) - p1v;\n dst[2] = (m6 >> 12) + (m7 >> 12);\n dst[4] = (m9 >> 12) + p_ac;\n dst[5] = (m12 >> 12) - (m13 >> 12);\n}\n"} +{"ts": "2026-09-11 00:31:49", "label": "s104_part3", "rung": "E", "calib": {"head": "c5786dac6", "stamp": "15956e4a96c4"}, "tu": "src/shared/ov/func_80169A4C.h", "fn": "func_80169A4C", "addr": 2148964940, "aliases": null, "header": true, "includers": 136, "nhash_before": "2d4362e1f7ae619b90da288fbea9eed673478abc", "nhash_after": "3f927a2b9f52ec6c6d564fa3faed57f5ca351745", "source": "delever_regen R18 bystander @19->14", "verdict": "LEVER-FREE", "sites": [], "compiles": 141, "seconds": 71.031, "objects": ["build/src/ov_MAIN_012/ov_MAIN_012_jr_8015A3C8.o", "build/src/ov_SC01_000/ov_SC01_000_jr_8015C32C.o", "build/src/ov_SC01_001/ov_SC01_001_jr_8015C32C.o", "build/src/ov_SC01_004/ov_SC01_004_jr_8015C32C.o", "build/src/ov_SC01_005/ov_SC01_005_jr_8015C32C.o", "build/src/ov_SC01_006/ov_SC01_006_jr_8015C32C.o", "build/src/ov_SC01_008/ov_SC01_008_jr_8015C32C.o", "build/src/ov_SC01_009/ov_SC01_009_jr_8015C32C.o", "build/src/ov_SC01_074/ov_SC01_074_jr_8015C32C.o", "build/src/ov_SC01_077/ov_SC01_077_jr_8015C32C.o", "build/src/ov_SC01_080/ov_SC01_080_jr_8015C32C.o", "build/src/ov_SC01_084/ov_SC01_084_jr_8015C32C.o", "build/src/ov_SC02_000/ov_SC02_000_jr_8015C32C.o", "build/src/ov_SC02_003/ov_SC02_003_jr_8015C32C.o", "build/src/ov_SC02_004/ov_SC02_004_jr_8015C32C.o", "build/src/ov_SC02_005/ov_SC02_005_jr_8015C32C.o", "build/src/ov_SC02_011/ov_SC02_011_jr_8015C32C.o", "build/src/ov_SC02_015/ov_SC02_015_jr_8015C32C.o", "build/src/ov_SC02_016/ov_SC02_016_jr_8015C32C.o", "build/src/ov_SC02_017/ov_SC02_017_jr_8015C32C.o", "build/src/ov_SC02_021/ov_SC02_021_jr_8015C32C.o", "build/src/ov_SC02_026/ov_SC02_026_jr_8015C32C.o", "build/src/ov_SC02_027/ov_SC02_027_jr_8015C32C.o", "build/src/ov_SC02_028/ov_SC02_028_jr_8015C32C.o", "build/src/ov_SC02_031/ov_SC02_031_jr_8015C32C.o", "build/src/ov_SC02_035/ov_SC02_035_jr_8015C32C.o", "build/src/ov_SC02_037/ov_SC02_037_jr_8015A3C8.o", "build/src/ov_SC02_039/ov_SC02_039_jr_8015C32C.o", "build/src/ov_SC02_041/ov_SC02_041_jr_8015C32C.o", "build/src/ov_SC03_001/ov_SC03_001_jr_8015C32C.o", "build/src/ov_SC03_002/ov_SC03_002_jr_8015C32C.o", "build/src/ov_SC03_003/ov_SC03_003_jr_8015C32C.o", "build/src/ov_SC03_006/ov_SC03_006_jr_8015C32C.o", "build/src/ov_SC03_007/ov_SC03_007_jr_8015C32C.o", "build/src/ov_SC03_010/ov_SC03_010_jr_8015C32C.o", "build/src/ov_SC03_011/ov_SC03_011_jr_8015C32C.o", "build/src/ov_SC03_012/ov_SC03_012_jr_8015C32C.o", "build/src/ov_SC03_013/ov_SC03_013_jr_8015C32C.o", "build/src/ov_SC03_014/ov_SC03_014_jr_8015C32C.o", "build/src/ov_SC03_015/ov_SC03_015_jr_8015C32C.o", "build/src/ov_SC03_023/ov_SC03_023_jr_8015C32C.o", "build/src/ov_SC03_024/ov_SC03_024_jr_8015C32C.o", "build/src/ov_SC03_028/ov_SC03_028_jr_8015C32C.o", "build/src/ov_SC03_029/ov_SC03_029_jr_8015C32C.o", "build/src/ov_SC03_030/ov_SC03_030_jr_8015C32C.o", "build/src/ov_SC03_031/ov_SC03_031_jr_8015C32C.o", "build/src/ov_SC03_089/ov_SC03_089_jr_8015C32C.o", "build/src/ov_SC03_090/ov_SC03_090_jr_8015C32C.o", "build/src/ov_SC03_091/ov_SC03_091_jr_8015C32C.o", "build/src/ov_SC03_092/ov_SC03_092_jr_8015C32C.o", "build/src/ov_SC03_093/ov_SC03_093_jr_8015C32C.o", "build/src/ov_SC03_094/ov_SC03_094_jr_8015C32C.o", "build/src/ov_SC03_095/ov_SC03_095_jr_8015C32C.o", "build/src/ov_SC03_096/ov_SC03_096_jr_8015C32C.o", "build/src/ov_SC03_097/ov_SC03_097_jr_8015C32C.o", "build/src/ov_SC03_098/ov_SC03_098_jr_8015C32C.o", "build/src/ov_SC03_099/ov_SC03_099_jr_8015C32C.o", "build/src/ov_SC03_100/ov_SC03_100_jr_8015C32C.o", "build/src/ov_SC03_101/ov_SC03_101_jr_8015C32C.o", "build/src/ov_SC03_102/ov_SC03_102_jr_8015C32C.o", "build/src/ov_SC03_103/ov_SC03_103_jr_8015C32C.o", "build/src/ov_SC03_104/ov_SC03_104_jr_8015C32C.o", "build/src/ov_SC03_105/ov_SC03_105_jr_8015C32C.o", "build/src/ov_SC03_107/ov_SC03_107_jr_8015A3C8.o", "build/src/ov_SC03_108/ov_SC03_108_jr_8015C32C.o", "build/src/ov_SC03_109/ov_SC03_109_jr_8015C32C.o", "build/src/ov_SC03_110/ov_SC03_110_jr_8015C32C.o", "build/src/ov_SC03_111/ov_SC03_111_jr_8015C32C.o", "build/src/ov_SC03_112/ov_SC03_112_jr_8015C32C.o", "build/src/ov_SC03_113/ov_SC03_113_jr_8015C32C.o", "build/src/ov_SC03_114/ov_SC03_114_jr_8015C32C.o", "build/src/ov_SC03_115/ov_SC03_115_jr_8015C32C.o", "build/src/ov_SC03_116/ov_SC03_116_jr_8015C32C.o", "build/src/ov_SC03_117/ov_SC03_117_jr_8015C32C.o", "build/src/ov_SC03_118/ov_SC03_118_jr_8015C32C.o", "build/src/ov_SC03_119/ov_SC03_119_jr_8015C32C.o", "build/src/ov_SC03_121/ov_SC03_121_jr_8015C32C.o", "build/src/ov_SC03_124/ov_SC03_124_jr_8015C32C.o", "build/src/ov_SC03_125/ov_SC03_125_jr_8015C32C.o", "build/src/ov_SC03_126/ov_SC03_126_jr_8015C32C.o", "build/src/ov_SC04_000/ov_SC04_000_jr_8015C32C.o", "build/src/ov_SC04_002/ov_SC04_002_jr_8015C32C.o", "build/src/ov_SC04_003/ov_SC04_003_jr_8015C32C.o", "build/src/ov_SC04_004/ov_SC04_004_jr_8015C32C.o", "build/src/ov_SC04_005/ov_SC04_005_jr_8015C32C.o", "build/src/ov_SC04_006/ov_SC04_006_jr_8015C32C.o", "build/src/ov_SC04_007/ov_SC04_007_jr_8015C32C.o", "build/src/ov_SC04_008/ov_SC04_008_jr_8015C32C.o", "build/src/ov_SC04_009/ov_SC04_009_jr_8015C32C.o", "build/src/ov_SC04_010/ov_SC04_010_jr_8015C32C.o", "build/src/ov_SC04_011/ov_SC04_011_jr_8015C32C.o", "build/src/ov_SC04_012/ov_SC04_012_jr_8015C32C.o", "build/src/ov_SC04_015/ov_SC04_015_jr_8015C32C.o", "build/src/ov_SC04_016/ov_SC04_016_jr_8015C32C.o", "build/src/ov_SC04_018/ov_SC04_018_jr_8015C32C.o", "build/src/ov_SC04_019/ov_SC04_019_jr_8015C32C.o", "build/src/ov_SC04_020/ov_SC04_020_jr_8015C32C.o", "build/src/ov_SC04_021/ov_SC04_021_jr_8015C32C.o", "build/src/ov_SC05_000/ov_SC05_000_jr_8015C32C.o", "build/src/ov_SC05_001/ov_SC05_001_jr_8015C32C.o", "build/src/ov_SC05_002/ov_SC05_002_jr_8015C32C.o", "build/src/ov_SC05_003/ov_SC05_003_jr_8015C32C.o", "build/src/ov_SC05_004/ov_SC05_004_jr_8015C32C.o", "build/src/ov_SC05_005/ov_SC05_005_jr_8015C32C.o", "build/src/ov_SC05_006/ov_SC05_006_jr_8015C32C.o", "build/src/ov_SC05_007/ov_SC05_007_jr_8015C32C.o", "build/src/ov_SC05_008/ov_SC05_008_jr_8015C32C.o", "build/src/ov_SC05_009/ov_SC05_009_jr_8015C32C.o", "build/src/ov_SC05_010/ov_SC05_010_jr_8015C32C.o", "build/src/ov_SC05_011/ov_SC05_011_jr_8015C32C.o", "build/src/ov_SC05_017/ov_SC05_017_jr_8015C32C.o", "build/src/ov_SC05_018/ov_SC05_018_jr_8015C32C.o", "build/src/ov_SC05_019/ov_SC05_019_jr_8015C32C.o", "build/src/ov_SC06_000/ov_SC06_000_jr_8015C32C.o", "build/src/ov_SC06_006/ov_SC06_006_jr_8015C32C.o", "build/src/ov_SC06_008/ov_SC06_008_jr_8015C32C.o", "build/src/ov_SC06_010/ov_SC06_010_jr_8015C32C.o", "build/src/ov_SC06_011/ov_SC06_011_jr_8015C32C.o", "build/src/ov_SC06_013/ov_SC06_013_jr_8015C32C.o", "build/src/ov_SC06_014/ov_SC06_014_jr_8015C32C.o", "build/src/ov_SC06_015/ov_SC06_015_jr_8015C32C.o", "build/src/ov_SC06_016/ov_SC06_016_jr_8015C32C.o", "build/src/ov_SC06_018/ov_SC06_018_jr_8015C32C.o", "build/src/ov_SC06_020/ov_SC06_020_jr_8015C32C.o", "build/src/ov_SC06_022/ov_SC06_022_jr_8015C32C.o", "build/src/ov_SC06_024/ov_SC06_024_jr_8015C32C.o", "build/src/ov_SC06_025/ov_SC06_025_jr_8015C32C.o", "build/src/ov_SC06_027/ov_SC06_027_jr_8015C32C.o", "build/src/ov_SC06_029/ov_SC06_029_jr_8015C32C.o", "build/src/ov_SC06_030/ov_SC06_030_jr_8015C32C.o", "build/src/ov_SC06_032/ov_SC06_032_jr_8015C32C.o", "build/src/ov_SC06_033/ov_SC06_033_jr_8015C32C.o", "build/src/ov_SC07_000/ov_SC07_000_jr_8015C32C.o", "build/src/ov_SC07_001/ov_SC07_001_jr_8015C32C.o", "build/src/ov_SC07_002/ov_SC07_002_jr_8015C32C.o", "build/src/ov_SC07_006/ov_SC07_006_jr_8015C32C.o", "build/src/ov_SC07_007/ov_SC07_007_jr_8015C32C.o", "build/src/ov_SC07_008/ov_SC07_008_jr_8015C32C.o", "build/src/ov_SC07_009/ov_SC07_009_jr_8015C32C.o", "build/src/ov_SC07_010/ov_SC07_010_jr_8015C32C.o", "build/src/ov_SC07_011/ov_SC07_011_jr_8015C32C.o"], "before_text": "s32 func_80169A4C(s32 a0, s32 a1) {\n void *arg0 = (void *)a0;\n void *arg1 = (void *)a1;\n u8 buf[0x5C]; /* spans $sp+0x10 .. $sp+0x6B */\n u8 *p = buf + 0x38; /* $sp+0x48, passed to first 3 calls */\n u8 v1;\n s8 v0;\n u16 t2c;\n u8 *q; /* $sp+0x68, first call a0 */\n s32 m5; /* -5 -> $v1 */\n s32 p5; /* 5 -> $v0 */\n q = buf + 0x58;\n __asm__(\"\" : : \"r\"(q)); // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B headers1)\n m5 = -5;\n __asm__(\"\" : : \"r\"(m5)); // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B headers1)\n p5 = 5;\n *(s16 *)(buf + 0x18) = p5; /* 0x28 */\n *(s16 *)(buf + 0x10) = p5; /* 0x20 */\n *(s16 *)(buf + 0x1a) = p5; /* 0x2A */\n *(s16 *)(buf + 0x0a) = p5; /* 0x1A */\n *(s16 *)(buf + 0x08) = m5; /* 0x18 */\n *(s16 *)(buf + 0x00) = m5; /* 0x10 */\n *(s16 *)(buf + 0x12) = m5; /* 0x22 */\n *(s16 *)(buf + 0x02) = m5; /* 0x12 */\n *(s16 *)(buf + 0x1c) = 0; /* 0x2C */\n *(s16 *)(buf + 0x14) = 0; /* 0x24 */\n *(s16 *)(buf + 0x0c) = 0; /* 0x1C */\n *(s16 *)(buf + 0x04) = 0; /* 0x14 */\n v1 = *(u8 *)((u8 *)arg0 + 0x30);\n *(s32 *)(buf + 0x30) = 0x50000000; /* 0x40 */\n v0 = (s8)(v1 >> 2);\n *(u8 *)(buf + 0x2e) = v1; /* 0x3E */\n *(u8 *)(buf + 0x2a) = v1; /* 0x3A */\n *(u8 *)(buf + 0x26) = v1; /* 0x36 */\n *(u8 *)(buf + 0x22) = v1; /* 0x32 */\n *(s8 *)(buf + 0x2d) = v0; /* 0x3D */\n *(s8 *)(buf + 0x29) = v0; /* 0x39 */\n *(s8 *)(buf + 0x25) = v0; /* 0x35 */\n *(s8 *)(buf + 0x21) = v0; /* 0x31 */\n *(s8 *)(buf + 0x2c) = v0; /* 0x3C */\n *(s8 *)(buf + 0x28) = v0; /* 0x38 */\n *(s8 *)(buf + 0x24) = v0; /* 0x34 */\n *(s8 *)(buf + 0x20) = v0; /* 0x30 */\n t2c = *(u16 *)((u8 *)arg0 + 0x2c);\n *(u16 *)(q + 0x02) = t2c; /* 0x6A */\n *(u16 *)(q + 0x00) = t2c; /* 0x68 */\n func_80017DC4(q, p);\n func_80048EAC(arg1, p);\n *(s32 *)(buf + 0x4c) = (s32)*(s16 *)((u8 *)arg0 + 6); /* 0x5C */\n *(s32 *)(buf + 0x50) = (s32)*(s16 *)((u8 *)arg0 + 0xa); /* 0x60 */\n *(s32 *)(buf + 0x54) = (s32)*(s16 *)((u8 *)arg0 + 0xe); /* 0x64 */\n func_80017758(buf + 0x00, p);\n *(s16 *)(buf + 0x00) = -7; /* 0x10 */\n *(s16 *)(buf + 0x10) = 0; /* 0x20 */\n *(s16 *)(buf + 0x08) = 0; /* 0x18 */\n *(s16 *)(buf + 0x18) = 7; /* 0x28 */\n *(s16 *)(buf + 0x1a) = 0; /* 0x2A */\n *(s16 *)(buf + 0x02) = 0; /* 0x12 */\n *(s16 *)(buf + 0x0a) = 7; /* 0x1A */\n *(s16 *)(buf + 0x12) = -7; /* 0x22 */\n func_80017758(buf + 0x00, p);\n}\n", "after_text": "s32 func_80169A4C(s32 a0, s32 a1) {\n void *arg0 = (void *)a0;\n void *arg1 = (void *)a1;\n u8 buf[0x5C]; /* spans $sp+0x10 .. $sp+0x6B */\n u8 *p = buf + 0x38; /* $sp+0x48, passed to first 3 calls */\n u8 v1;\n s8 v0;\n u16 t2c;\n u8 *q; /* $sp+0x68, first call a0 */\n s32 m5; /* -5 -> $v1 */\n s32 p5; /* 5 -> $v0 */\n q = buf + 0x58;\n m5 = -5;\n *(s16 *)(buf + 0x08) = m5; /* 0x18 */\n p5 = 5;\n *(s16 *)(buf + 0x18) = p5; /* 0x28 */\n *(s16 *)(buf + 0x10) = p5; /* 0x20 */\n *(s16 *)(buf + 0x1a) = p5; /* 0x2A */\n *(s16 *)(buf + 0x0a) = p5; /* 0x1A */\n *(s16 *)(buf + 0x00) = m5; /* 0x10 */\n *(s16 *)(buf + 0x12) = m5; /* 0x22 */\n *(s16 *)(buf + 0x02) = m5; /* 0x12 */\n *(s16 *)(buf + 0x1c) = 0; /* 0x2C */\n *(s16 *)(buf + 0x14) = 0; /* 0x24 */\n *(s16 *)(buf + 0x0c) = 0; /* 0x1C */\n *(s16 *)(buf + 0x04) = 0; /* 0x14 */\n v1 = *(u8 *)((u8 *)arg0 + 0x30);\n *(s32 *)(buf + 0x30) = 0x50000000; /* 0x40 */\n v0 = (s8)(v1 >> 2);\n *(u8 *)(buf + 0x2e) = v1; /* 0x3E */\n *(u8 *)(buf + 0x2a) = v1; /* 0x3A */\n *(u8 *)(buf + 0x26) = v1; /* 0x36 */\n *(u8 *)(buf + 0x22) = v1; /* 0x32 */\n *(s8 *)(buf + 0x2d) = v0; /* 0x3D */\n *(s8 *)(buf + 0x29) = v0; /* 0x39 */\n *(s8 *)(buf + 0x25) = v0; /* 0x35 */\n *(s8 *)(buf + 0x21) = v0; /* 0x31 */\n *(s8 *)(buf + 0x2c) = v0; /* 0x3C */\n *(s8 *)(buf + 0x28) = v0; /* 0x38 */\n *(s8 *)(buf + 0x24) = v0; /* 0x34 */\n *(s8 *)(buf + 0x20) = v0; /* 0x30 */\n t2c = *(u16 *)((u8 *)arg0 + 0x2c);\n *(u16 *)(q + 0x02) = t2c; /* 0x6A */\n *(u16 *)(q + 0x00) = t2c; /* 0x68 */\n func_80017DC4(q, p);\n func_80048EAC(arg1, p);\n *(s32 *)(buf + 0x4c) = (s32)*(s16 *)((u8 *)arg0 + 6); /* 0x5C */\n *(s32 *)(buf + 0x50) = (s32)*(s16 *)((u8 *)arg0 + 0xa); /* 0x60 */\n *(s32 *)(buf + 0x54) = (s32)*(s16 *)((u8 *)arg0 + 0xe); /* 0x64 */\n func_80017758(buf + 0x00, p);\n *(s16 *)(buf + 0x00) = -7; /* 0x10 */\n *(s16 *)(buf + 0x10) = 0; /* 0x20 */\n *(s16 *)(buf + 0x08) = 0; /* 0x18 */\n *(s16 *)(buf + 0x18) = 7; /* 0x28 */\n *(s16 *)(buf + 0x1a) = 0; /* 0x2A */\n *(s16 *)(buf + 0x02) = 0; /* 0x12 */\n *(s16 *)(buf + 0x0a) = 7; /* 0x1A */\n *(s16 *)(buf + 0x12) = -7; /* 0x22 */\n func_80017758(buf + 0x00, p);\n}\n"} diff --git a/src/800.c b/src/800.c index c88d81980..9c7e1f1de 100644 --- a/src/800.c +++ b/src/800.c @@ -12740,13 +12740,12 @@ void func_80020DA4(s32 a0, s32 a1) { hi2 = *(s16 *)(addr2 + 2); m2 = hi0 * hi2; p1 = src[1] & 0xFFF; - __asm__("" : "=r"(p1) : "0"(p1)); // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus9) addr1 = (p1 << 2) + tbl; lo0 = (s16)e0; lo1 = *(s16 *)addr1; m3 = lo0 * lo1; e1 = *(s32 *)addr1; - hi1 = e1 >> 16; + do { hi1 = e1 >> 16; } while (0); // !FAKE: do-while — a LOOP-note scheduling barrier (sched.c:2058-2074; P36 R7) m4 = hi2 * hi1; p_ab = m3 >> 12; m5 = p_ab * hi2; @@ -12759,7 +12758,6 @@ void func_80020DA4(s32 a0, s32 a1) { m11 = hi1 * hi0; p1v = m1 >> 12; m12 = p1v * lo1; - __asm__("" : "=r"(e1) : "0"(e1)); // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus9) dst[6] = -e1; dst[0] = m4 >> 12; dst[3] = m8 >> 12; diff --git a/src/ov_SC01_000/ov_SC01_000_jr_8017BEBC.c b/src/ov_SC01_000/ov_SC01_000_jr_8017BEBC.c index 4dd441c87..68c48cbc6 100644 --- a/src/ov_SC01_000/ov_SC01_000_jr_8017BEBC.c +++ b/src/ov_SC01_000/ov_SC01_000_jr_8017BEBC.c @@ -3567,8 +3567,7 @@ void func_8017E3A0(s32 a0, s32 a1, s32 a2, s32 a3, s32 arg4, s32 arg5) prim[6] = arg4; prim[4] = 0; } - prim[5] = 0; - __asm__ __volatile__(""); // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus10) + do { prim[5] = 0; } while (0); // !FAKE: do-while — a LOOP-note scheduling barrier (sched.c:2058-2074; P36 R7) mlo = 0xFFFFFF; ((u16 *)prim)[5] = a1; mhi = 0xFF000000; diff --git a/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c b/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c index 36c21cecf..7525c5190 100644 --- a/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c +++ b/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c @@ -4576,8 +4576,8 @@ void func_8017E724(s32 param_1) { s16 arr[3]; s32 a; - register s32 cur __asm__("$16"); // !FAKE: pin $16 — NEEDED DIFFERS (P36 rung B tus7) - register s32 ang __asm__("$17"); // !FAKE: pin $17 — NEEDED DIFFERS (P36 rung B tus7) + s32 cur; + s32 ang; s32 d; s32 d2; s32 t; @@ -4589,9 +4589,9 @@ void func_8017E724(s32 param_1) cur = (a + 0x400) & 0xFFF; base = &D_80126B58; d2 = (*(u16 *)((s32)D_80126B78 + 0x12) - cur) & 0xFFF; + rot = func_80047948(d2) / 32; ang = cur; cur = a; - rot = func_80047948(d2) / 32; *(s16 *)(param_1 + 0x2E) = -(func_8004787C(ang) * rot) / 4096; *(s16 *)(param_1 + 0x32) = -(func_80047948(ang) * rot) / 4096; diff --git a/src/ov_SC03_001/ov_SC03_001_jr_80184F64.c b/src/ov_SC03_001/ov_SC03_001_jr_80184F64.c index c92169070..92c45587a 100644 --- a/src/ov_SC03_001/ov_SC03_001_jr_80184F64.c +++ b/src/ov_SC03_001/ov_SC03_001_jr_80184F64.c @@ -3594,8 +3594,8 @@ void func_80185B54(void *arg0) { extern short D_80192864; extern short D_8019286C; extern short D_80192874; - register s32 tc __asm__("$3"); // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus10) - register s32 p68 __asm__("$2"); // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus10) + s32 tc; + s32 p68; s32 tt; void *s0 = arg0; @@ -3630,8 +3630,7 @@ void func_80185B54(void *arg0) { after: p68 = *(s32 *)((char *)s0 + 0x68); *(s16 *)(p68 + 0xC) = 32767; - tt = func_801788B8((s32)s0, (s32)&func_801856A8); - *(s32 *)((char *)s0 + 0xD4) = tt; + tt = *(s32 *)((char *)s0 + 0xD4) = func_801788B8((s32)s0, (s32)&func_801856A8); func_8012E8E0(tt, (s32)&D_80192864); } } diff --git a/src/ov_SC05_003/ov_SC05_003_jr_8017BEBC.c b/src/ov_SC05_003/ov_SC05_003_jr_8017BEBC.c index 70eed86c6..c097f1ba3 100644 --- a/src/ov_SC05_003/ov_SC05_003_jr_8017BEBC.c +++ b/src/ov_SC05_003/ov_SC05_003_jr_8017BEBC.c @@ -4178,13 +4178,13 @@ void func_8017F4FC(void *a0) { } { - register u16 t88 __asm__("$2") = *(u16 *)(s0 + 0x88); // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus9) - register u16 t8A __asm__("$3") = *(u16 *)(s0 + 0x8A); // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus9) + u16 t88 = *(u16 *)(s0 + 0x88); + u16 t8A = *(u16 *)(s0 + 0x8A); *(s16 *)(s0 + 0xDE) = 0; *(s16 *)(s0 + 0xAA) = 0; - *(u16 *)(s0 + 0xE) = *(u16 *)(s0 + 0x8C); *(u16 *)(s0 + 0x6) = t88; *(u16 *)(s0 + 0xA) = t8A; + *(u16 *)(s0 + 0xE) = *(u16 *)(s0 + 0x8C); func_8012A828(s0, (s32)&D_801A410C); } func_8012B2CC(s0); diff --git a/src/shared/ov/func_80169A4C.h b/src/shared/ov/func_80169A4C.h index 4efe01331..2fb94bcad 100644 --- a/src/shared/ov/func_80169A4C.h +++ b/src/shared/ov/func_80169A4C.h @@ -15,15 +15,13 @@ s32 func_80169A4C(s32 a0, s32 a1) { s32 m5; /* -5 -> $v1 */ s32 p5; /* 5 -> $v0 */ q = buf + 0x58; - __asm__("" : : "r"(q)); // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B headers1) m5 = -5; - __asm__("" : : "r"(m5)); // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B headers1) + *(s16 *)(buf + 0x08) = m5; /* 0x18 */ p5 = 5; *(s16 *)(buf + 0x18) = p5; /* 0x28 */ *(s16 *)(buf + 0x10) = p5; /* 0x20 */ *(s16 *)(buf + 0x1a) = p5; /* 0x2A */ *(s16 *)(buf + 0x0a) = p5; /* 0x1A */ - *(s16 *)(buf + 0x08) = m5; /* 0x18 */ *(s16 *)(buf + 0x00) = m5; /* 0x10 */ *(s16 *)(buf + 0x12) = m5; /* 0x22 */ *(s16 *)(buf + 0x02) = m5; /* 0x12 */