mirror/BFM-decomp
1
0
Fork 0
mirror of https://github.com/Druthulu/BFM-decomp synced 2026-10-01 15:43:06 -04:00
Code Issues Packages Projects Releases Wiki Activity

fix(phase-26): jr_isolate_all empty-region0 skip — cutting an already-isolated region's non-leader works

Browse Source 
Cutting func_80178D40 out of ov_SC01_000_jr_801734BC adds the region's banked LEADER (0x801734BC)
as a cut too (the one-carve-per-object rule), making region 0 EMPTY (the object's first item IS the
first cut) — and region 1's derived name equals the object name, so emitting region 0 duplicated the
line exactly -> splat "segments out of order". Skip an empty region 0; region 1 rightly claims the
object's offset and name. First sibling then banks through the full chain (isolation validation
green -> carve -> --raw remap -> stage ladder -> whole-binary gate): ov_SC01_000 BANKED, included
here. The remaining 132 siblings sweep next.
This commit is contained in:
Drew T
2026-07-13 22:14:57 -06:00
parent 7e4165676d
commit 07ebb5658d
5 changed files with 4221 additions and 739 deletions
Download Patch File Download Diff File Expand all files Collapse all files
config/overlays.mk
+1 -1
View File
@@ -109,7 +109,7 @@ ov_SC01_000_ELF := $(ov_SC01_000_OUT).elf
ov_SC01_000_MAPFILE := $(ov_SC01_000_OUT).map
ov_SC01_000_LD_SCRIPT := $(ov_SC01_000_OUT).ld
ov_SC01_000_SPLAT_YAML := config/splat.ov_SC01_000.yaml
ov_SC01_000_JTBL_INTERLEAVE := --order tail.data.o,ov_SC01_000.o,tail2.data.o,ov_SC01_000_jr_8015AE2C.o,tail3.data.o,ov_SC01_000_jr_801734BC.o,tail4.data.o,ov_SC01_000_jr_8017BEBC.o,tail5.data.o,trailing.o # Phase-26 §8 jtbl-rodata carve
ov_SC01_000_JTBL_INTERLEAVE := --order tail.data.o,ov_SC01_000.o,tail2.data.o,ov_SC01_000_jr_8015AE2C.o,tail3.data.o,ov_SC01_000_jr_801734BC.o,tail4.data.o,ov_SC01_000_jr_80178D40.o,tail5.data.o,ov_SC01_000_jr_8017BEBC.o,tail6.data.o,trailing.o # Phase-26 §8 jtbl-rodata carve
ov_SC01_000_CHECK_SHA := config/check.ov_SC01_000.sha
ov_SC01_000_SYMBOLS := config/symbols.ov_SC01_000.txt
ov_SC01_000_SIG := .run/sig.ov_SC01_000.jsonl
config/splat.ov_SC01_000.yaml
+4 -1
View File
@@ -98,6 +98,7 @@ segments:
- [0x1d64c, c, ov_SC01_000_after]
- [0x32cd4, c, ov_SC01_000_jr_8015AE2C]
- [0x4b364, c, ov_SC01_000_jr_801734BC]
- [0x50be8, c, ov_SC01_000_jr_80178D40]
- [0x53d64, c, ov_SC01_000_jr_8017BEBC]
- [0x56a64, data, tail]
- [0x7b1c4, .rodata, ov_SC01_000] # Phase-26 §8 jtbl-rodata carve (jtbl_carve.py)
@@ -106,8 +107,10 @@ segments:
- [0x7bcbc, data, tail3]
- [0x7bdb4, .rodata, ov_SC01_000_jr_801734BC] # Phase-26 §8 jtbl-rodata carve (jtbl_carve.py)
- [0x7bdc8, data, tail4]
- [0x7bf70, .rodata, ov_SC01_000_jr_80178D40] # Phase-26 §8 jtbl-rodata carve (jtbl_carve.py)
- [0x7c0e8, data, tail5]
- [0x7c21c, .rodata, ov_SC01_000_jr_8017BEBC] # Phase-26 §8 jtbl-rodata carve (jtbl_carve.py)
- [0x7c23c, data, tail5]
- [0x7c23c, data, tail6]
- [0x7D78C, bin, trailing] # final 3 bytes (EOF not 4-aligned; spimdisasm drops a partial word)
- [0x7D78F] # EOF marker = the 0.4.dec byte length
# @TRAILING@ (above) is replaced by tools/new_overlay.sh: for a non-4-aligned overlay it becomes
src/ov_SC01_000/ov_SC01_000_jr_801734BC.c
-737
View File
@@ -3106,740 +3106,3 @@ void func_80178D18(void) {
D_801A58E4 = 0;
func_80174714();
}
INCLUDE_ASM("asm/ov_SC01_000/nonmatchings/ov_SC01_000_jr_801734BC", func_80178D40);
DEFINE_func_80179B28() /* dedup: shared engine-core @0x80179B28 (src/shared) */
INCLUDE_ASM("asm/ov_SC01_000/nonmatchings/ov_SC01_000_jr_801734BC", func_80179B74);
DEFINE_func_80179D30() /* dedup: shared engine-core @0x80179D30 (src/shared) */
DEFINE_func_80179D78() /* dedup: shared engine-core @0x80179D78 (src/shared) */
DEFINE_func_80179DCC() /* dedup: shared engine-core @0x80179DCC (src/shared) */
DEFINE_func_80179DF8() /* dedup: shared engine-core @0x80179DF8 (src/shared) */
DEFINE_func_80179E1C() /* dedup: shared engine-core @0x80179E1C (src/shared) */
DEFINE_func_80179E48() /* dedup: shared engine-core @0x80179E48 (src/shared) */
DEFINE_func_80179E74() /* dedup: shared engine-core @0x80179E74 (src/shared) */
DEFINE_func_80179EA0() /* dedup: shared engine-core @0x80179EA0 (src/shared) */
DEFINE_func_80179EE8() /* dedup: shared engine-core @0x80179EE8 (src/shared) */
DEFINE_func_80179F14() /* dedup: shared engine-core @0x80179F14 (src/shared) */
DEFINE_func_80179F44() /* dedup: shared engine-core @0x80179F44 (src/shared) */
DEFINE_func_80179F6C() /* dedup: shared engine-core @0x80179F6C (src/shared) */
DEFINE_func_80179F98() /* dedup: shared engine-core @0x80179F98 (src/shared) */
DEFINE_func_80179FEC() /* dedup: shared engine-core @0x80179FEC (src/shared) */
DEFINE_func_8017A040() /* dedup: shared engine-core @0x8017A040 (src/shared) */
extern void func_80179B74(s16 *a0);
extern s32 D_801A568C;
void func_8017A094(s32 arg0) {
s16 sp10;
D_801A568C = arg0;
sp10 = 0x15;
func_80179B74(&sp10);
}
extern void func_80179B74(s16 *a0);
extern s32 D_801A568C;
void func_8017A0C4(s32 arg0) {
s16 sp10;
D_801A568C = arg0;
sp10 = 0x16;
func_80179B74(&sp10);
}
DEFINE_func_8017A0F4() /* dedup: shared engine-core @0x8017A0F4 (src/shared) */
DEFINE_func_8017A11C() /* dedup: shared engine-core @0x8017A11C (src/shared) */
extern s32 D_801A56B4;
extern void func_80179B74(s16 *a0);
void func_8017A144(s32 a0) {
s16 sp10;
sp10 = 0x1B;
func_80179B74(&sp10);
D_801A56B4 = a0;
}
DEFINE_func_8017A180() /* dedup: shared engine-core @0x8017A180 (src/shared) */
DEFINE_func_8017A1A8() /* dedup: shared engine-core @0x8017A1A8 (src/shared) */
DEFINE_func_8017A1D0() /* dedup: shared engine-core @0x8017A1D0 (src/shared) */
DEFINE_func_8017A1F8() /* dedup: shared engine-core @0x8017A1F8 (src/shared) */
DEFINE_func_8017A220() /* dedup: shared engine-core @0x8017A220 (src/shared) */
DEFINE_func_8017A248() /* dedup: shared engine-core @0x8017A248 (src/shared) */
DEFINE_func_8017A270() /* dedup: shared engine-core @0x8017A270 (src/shared) */
DEFINE_func_8017A298() /* dedup: shared engine-core @0x8017A298 (src/shared) */
DEFINE_func_8017A2C0() /* dedup: shared engine-core @0x8017A2C0 (src/shared) */
DEFINE_func_8017A2E8() /* dedup: shared engine-core @0x8017A2E8 (src/shared) */
DEFINE_func_8017A310() /* dedup: shared engine-core @0x8017A310 (src/shared) */
DEFINE_func_8017A338() /* dedup: shared engine-core @0x8017A338 (src/shared) */
DEFINE_func_8017A360() /* dedup: shared engine-core @0x8017A360 (src/shared) */
DEFINE_func_8017A388() /* dedup: shared engine-core @0x8017A388 (src/shared) */
extern s16 D_801A5670;
s32 func_8017A3B0(void) {
switch (D_801A5670) {
case 0:
return 1;
case 1:
return 0;
default:
return 1;
}
}
// @class: regalloc-order
// @stuck: none — MATCH
extern short D_801A56AC;
extern short D_801A56A8;
extern int func_800D0CA0(int);
extern int func_8001AAA0(void);
extern int func_800D0CE0(void);
int func_8017A3D8(void)
{
switch (D_801A56AC) {
case 0:
func_800D0CA0(1);
D_801A56AC = D_801A56AC + 1;
return 0;
case 100:
{
register int a __asm__("$4");
a = D_801A56A8;
if (a != -1) {
return func_8001AAA0() != 0;
}
return func_800D0CE0() == 1;
}
default:
D_801A56AC = D_801A56AC + 1;
if (D_801A56AC < 0x1E) {
return 0;
}
D_801A56AC = 100;
return 0;
}
}
INCLUDE_ASM("asm/ov_SC01_000/nonmatchings/ov_SC01_000_jr_801734BC", func_8017A4AC);
DEFINE_func_8017AD0C() /* dedup: shared engine-core @0x8017AD0C (src/shared) */
DEFINE_func_8017ADE8() /* dedup: shared engine-core @0x8017ADE8 (src/shared) */
DEFINE_func_8017AE08() /* dedup: shared engine-core @0x8017AE08 (src/shared) */
INCLUDE_ASM("asm/ov_SC01_000/nonmatchings/ov_SC01_000_jr_801734BC", func_8017AE2C);
// @class: plumbing
// @stuck: none — MATCH
void func_8017B0E4(int param_1, int param_2)
{
extern s16 D_801A56EC;
extern s16 D_801A56EE;
extern s16 D_801A56F0;
extern s16 D_801A56E4;
extern s16 D_801A56E6;
extern s16 D_801A56E8;
*(s32 *)(((s32)param_1) + 0x48) = (s16)func_80012C6C((s32)*(s16 *)(((s32)param_1) + 0x48), (s32)D_801A56EC, (s32)((s16)param_2));
*(s32 *)(((s32)param_1) + 0x4C) = (s16)func_80012C6C((s32)*(s16 *)(((s32)param_1) + 0x4C), (s32)D_801A56EE, (s32)((s16)param_2));
*(s32 *)(((s32)param_1) + 0x50) = (s16)func_80012C6C((s32)*(s16 *)(((s32)param_1) + 0x50), (s32)D_801A56F0, (s32)((s16)param_2));
*(s32 *)(((s32)param_1) + 0x3C) = (s16)func_80012C6C((s32)*(s16 *)(((s32)param_1) + 0x3C), (s32)D_801A56E4, (s32)((s16)param_2));
*(s32 *)(((s32)param_1) + 0x40) = (s16)func_80012C6C((s32)*(s16 *)(((s32)param_1) + 0x40), (s32)D_801A56E6, (s32)((s16)param_2));
*(s32 *)(((s32)param_1) + 0x44) = (s16)func_80012C6C((s32)*(s16 *)(((s32)param_1) + 0x44), (s32)D_801A56E8, (s32)((s16)param_2));
}
extern u16 D_80126B5E;
extern u16 D_80126B62;
extern u16 D_80126B66;
extern s16 D_801A5674;
extern u16 D_801A56F4;
extern u16 D_801A56F6;
extern u16 D_801A56F8;
extern s16 D_801A5870;
void func_8017B1D8(void) {
func_8012A418();
D_801A5870 = 0;
D_801A5674 = 0;
D_801A56F4 = D_80126B5E;
D_801A56F6 = D_80126B62;
D_801A56F8 = D_80126B66;
}
// @class: regalloc-order — simplified sibling of matched func_8017B614.
// @stuck: none. Block-moves are align-1 struct-assigns (u8[8]) -> emit_block_move
// (unaligned lwl/lwr/swl/swr), ZERO memcpy-symbol reference, so the TU's `extern memcpy`
// (which turned the old draft's memcpy into a CALL -> DIFF 64) can't drift this.
// $16 pin + in-place re-tie keeps param_2 in $a1 until the >=0xB branch, then $s0 for loads.
typedef struct { u8 b[8]; } Blk8_8017B238_8017B238;
s32 func_8017B238(s32 param_1, s32 param_2)
{
extern void func_8012F214(s32 a0, s32 a1, s32 a2);
extern s32 func_8017BE60(void *a0);
extern u8 D_80182548[];
extern s16 D_801A56EC;
extern s16 D_801A56E4;
extern u8 D_8012694C;
u8 buf[16];
if (((u32)param_2) >= 0xB) {
register u8 *src __asm__("$16");
__asm__ __volatile__("" : "=r"(src) : "0"((u8 *)((u32)param_2)));
*(Blk8_8017B238_8017B238 *)&buf[0] = *(Blk8_8017B238_8017B238 *)src;
*(Blk8_8017B238_8017B238 *)&buf[8] = *(Blk8_8017B238_8017B238 *)(src + 8);
} else {
s32 a1addr = (s32)&D_80182548[((u32)param_2) * 0x10];
s32 a2addr = (s32)&D_80182548[((u32)param_2) * 0x10 + 8];
func_8012F214(param_1, a1addr, (s32)&buf[0]);
func_8012F214(param_1, a2addr, (s32)&buf[8]);
}
{
s16 *p794 = &D_801A56EC;
s16 *p78C = &D_801A56E4;
*(Blk8_8017B238_8017B238 *)p794 = *(Blk8_8017B238_8017B238 *)&buf[0];
*(Blk8_8017B238_8017B238 *)p78C = *(Blk8_8017B238_8017B238 *)&buf[8];
func_8012A018((s32)func_8017BE60, 0);
D_8012694C = 0;
D_801A5870 = 1;
D_801A5674 = 0;
}
}
// @class: struct
// @stuck: none — MATCH (74 ins)
typedef struct { s16 a, b, c, d; } SV4_8017B368; /* 8 bytes, align 2 -> lwl/lwr/swl/swr copy */
typedef struct { SV4_8017B368 x, y; } Pair16_8017B368; /* 16-byte stride array element */
s32 func_8017B368(s32 param)
{
extern void func_8017BA3C(s32 param_1, s32 param_2);
extern void func_8012F214(s32 a0, s32 a1, s32 a2);
extern SV4_8017B368 D_801A5694;
extern SV4_8017B368 D_801A569C;
extern s16 D_801A56EC;
extern s16 D_801A56E4;
extern u16 D_80182548;
SV4_8017B368 loc0;
SV4_8017B368 loc1;
u32 n = (u32)&D_801A5694;
((void (*)(void))func_8017BA3C)();
if (n >= 0xB) {
loc0 = *(SV4_8017B368 *)n;
loc1 = D_801A569C;
} else {
s32 ax = (s32)&((Pair16_8017B368 *)&D_80182548)[n].x;
s32 ay = (s32)&((Pair16_8017B368 *)&D_80182548)[n].y;
func_8012F214(param, ax, (s32)&loc0);
func_8012F214(param, ay, (s32)&loc1);
}
(*(SV4_8017B368 *)&D_801A56EC) = loc0;
(*(SV4_8017B368 *)&D_801A56E4) = loc1;
D_801A5870 = 1;
D_801A5674 = 0;
}
INCLUDE_ASM("asm/ov_SC01_000/nonmatchings/ov_SC01_000_jr_801734BC", func_8017B490);
// @class: regalloc-order + T1 memcpy-builtin→call re-crack
// @stuck: 0 (iso). Register lever = $16 pin + in-place re-tie on the memcpy-branch src (keeps
// param_2 in $a1 until the branch, then $s0 for the loads). Block-moves are align-1 struct-assigns
// (u8[8]) so they lower via emit_block_move (movstrsi/move_by_pieces) with ZERO memcpy-symbol
// reference — TU-independent, so the sibling TU's `extern memcpy` (which disables the builtin and
// turned the old inlined block-move into a CALL) can no longer drift this.
typedef struct { u8 b[8]; } Blk8_8017B614;
s32 func_8017B614(s32 param_1, s32 param_2)
{
extern void func_8012F214(s32 a0, s32 a1, s32 a2);
extern void func_80129CF8(void);
extern s32 func_8017BE60(void *a0);
extern u8 D_80182548[];
extern s16 D_801A56EC;
extern s16 D_801A56EE;
extern s16 D_801A56F0;
extern s16 D_801A56E4;
extern s16 D_801A56E6;
extern s16 D_801A56E8;
extern u8 D_8012694C;
extern s32 D_80126998;
extern s32 D_80126984;
extern s32 D_80126988;
extern s32 D_8012698C;
u8 buf[16];
if (((u32)param_2) >= 0xB) {
register u8 *src __asm__("$16");
__asm__ __volatile__("" : "=r"(src) : "0"((u8 *)((u32)param_2)));
*(Blk8_8017B614 *)&buf[0] = *(Blk8_8017B614 *)src;
*(Blk8_8017B614 *)&buf[8] = *(Blk8_8017B614 *)(src + 8);
} else {
s32 a1addr = (s32)&D_80182548[((u32)param_2) * 0x10];
s32 a2addr = (s32)&D_80182548[((u32)param_2) * 0x10 + 8];
func_8012F214(param_1, a1addr, (s32)&buf[0]);
func_8012F214(param_1, a2addr, (s32)&buf[8]);
}
{
s16 *p794 = &D_801A56EC;
s16 *p78C = &D_801A56E4;
*(Blk8_8017B614 *)p794 = *(Blk8_8017B614 *)&buf[0];
*(Blk8_8017B614 *)p78C = *(Blk8_8017B614 *)&buf[8];
((void(*)(s32, s32))func_8012A018)((s32)func_8017BE60, 0);
{
s32 v794, v796, v798, v78C, v78E, v790;
D_8012694C = 0;
v794 = *p794;
v796 = D_801A56EE;
v798 = D_801A56F0;
v78C = *p78C;
v78E = D_801A56E6;
v790 = D_801A56E8;
__asm__ __volatile__("");
D_801A5870 = 1;
D_801A5674 = 0x1E;
D_80126990 = v794;
D_80126994 = v796;
D_80126998 = v798;
D_80126984 = v78C;
D_80126988 = v78E;
D_8012698C = v790;
}
func_80129CF8();
}
}
// @class: plumbing
// @stuck: none — MATCH
extern s32 D_80114F30;
extern s32 D_80114F34;
extern s32 D_80114F38;
extern s32 D_80114F24;
extern s32 D_80114F28;
extern s32 D_80114F2C;
extern u8 D_8012694C;
extern s16 D_801A5674;
extern s16 D_801A56EC;
extern s16 D_801A56EE;
extern s16 D_801A56F0;
extern s16 D_801A56E4;
extern s16 D_801A56E6;
extern s16 D_801A56E8;
void func_8017B7A8(void)
{
D_8012694C = 1;
D_801A5674 = 0;
D_801A56EC = (s16) D_80114F30;
D_801A56EE = (s16) D_80114F34;
D_801A56F0 = (s16) D_80114F38;
D_801A56E4 = (s16) D_80114F24;
D_801A56E6 = (s16) D_80114F28;
D_801A56E8 = (s16) D_80114F2C;
}
extern s32 D_801151D4;
extern s16 D_801A5704;
extern s16 D_801A5706;
extern s16 D_801A5708;
extern s16 D_801A570C;
extern s16 D_801A570E;
extern s16 D_801A5710;
void func_8017B824(void) {
D_801A5704 = (s16) M2C_FIELD(D_801151D4, s32 *, 0x48);
D_801A5706 = (s16) M2C_FIELD(D_801151D4, s32 *, 0x4C);
D_801A5708 = (s16) M2C_FIELD(D_801151D4, s32 *, 0x50);
D_801A570C = (s16) M2C_FIELD(D_801151D4, s32 *, 0x3C);
D_801A570E = (s16) M2C_FIELD(D_801151D4, s32 *, 0x40);
D_801A5710 = (s16) M2C_FIELD(D_801151D4, s32 *, 0x44);
}
// @class: schedule
// @stuck: none — MATCH
extern s16 D_801A5704;
extern s16 D_801A5706;
extern s16 D_801A5708;
extern s16 D_801A570C;
extern s16 D_801A570E;
extern s16 D_801A5710;
extern s32 D_80114F30;
extern s32 D_80114F34;
extern s32 D_80114F38;
extern s32 D_80114F24;
extern s32 D_80114F28;
extern s32 D_80114F2C;
void func_8017B880(void)
{
D_80114F30 = D_801A5704;
D_80114F34 = D_801A5706;
D_80114F38 = D_801A5708;
D_80114F24 = D_801A570C;
D_80114F28 = D_801A570E;
D_80114F2C = D_801A5710;
}
// @class: struct
// @stuck: none — MATCH
/* 16-byte unaligned block copy from param to two adjacent align-1 globals.
src[0..7] -> (*(S8_8017B8E8 *)&D_801A56EC), src[8..15] -> (*(S8_8017B8E8 *)&D_801A56E4) (source order).
An 8-byte struct of u8 has alignment 1, so gcc copies it via lwl/lwr+swl/swr. */
typedef struct { unsigned char b[8]; } S8_8017B8E8;
s32 func_8017B8E8(s32 src) {
(*(S8_8017B8E8 *)&D_801A56EC) = ((S8_8017B8E8 *)src)[0];
(*(S8_8017B8E8 *)&D_801A56E4) = ((S8_8017B8E8 *)src)[1];
}
// @class: struct
// @stuck: none — MATCH (63 ins)
extern u16 D_80126B5E;
extern u16 D_80126B62;
extern u16 D_80126B66;
extern u16 D_801A56F4;
extern u16 D_801A56F6;
extern u16 D_801A56F8;
extern s32 D_80114F30;
extern s32 D_80114F34;
extern s32 D_80114F38;
extern s32 D_80114F24;
extern s32 D_80114F28;
extern s32 D_80114F2C;
extern u8 D_8012694C;
extern s16 D_801A5674;
extern short D_801A56FC;
extern short D_801A56FE;
extern short D_801A5700;
extern s16 D_801A56EC;
extern s16 D_801A56EE;
extern s16 D_801A56F0;
extern s16 D_801A56E4;
extern s16 D_801A56E6;
extern s16 D_801A56E8;
void func_8017B940(void)
{
s32 buf[3];
D_8012694C = 2;
buf[0] = (*(s16 *)&D_80126B5E) - (*(s16 *)&D_801A56F4);
buf[1] = (*(s16 *)&D_80126B62) - (*(s16 *)&D_801A56F6);
buf[2] = (*(s16 *)&D_80126B66) - (*(s16 *)&D_801A56F8);
(*(s16 *)&D_801A56FC) = buf[0];
(*(s16 *)&D_801A56FE) = buf[1];
(*(s16 *)&D_801A5700) = buf[2];
D_801A56EC = D_80114F30 + buf[0];
D_801A5674 = 0;
D_801A56EE = D_80114F34 + buf[1];
D_801A56F0 = D_80114F38 + buf[2];
D_801A56E4 = D_80114F24 + buf[0];
D_801A56E6 = D_80114F28 + buf[1];
D_801A56E8 = D_80114F2C + buf[2];
}
// @class: struct
// @stuck: none — MATCH (62 ins)
extern void func_8012F214(s32 a0, s32 a1, s32 a2);
extern void func_80049CAC(s32 a0, s32 a1);
extern void func_8004914C(void *a0);
extern void func_800491AC(void *a0);
extern void RotTransSV(void *a0, void *a1, void *a2);
/* short-only (align 2) struct -> the 8-byte struct copy emits lwl/lwr/swl/swr */
/* PSX MATRIX: 3x3 short rotation + pad + 3 long translation (offset 0x14) */
extern SV4 D_801A5694;
extern SV4 D_801A569C;
void func_8017BA3C(s32 param_1, s32 param_2)
{
SV4 v0; /* sp+0x10 : func_80049CAC arg0 */
MTX mtx; /* sp+0x18 : MATRIX, t[] at sp+0x2c */
SV4 v1; /* sp+0x38 : RotTransSV arg0 */
SV4 svec; /* sp+0x40 : func_8012F214 out */
SV4 buf1; /* sp+0x48 : RotTransSV arg1 (-> D_801A569C) */
SV4 buf2; /* sp+0x50 : RotTransSV arg2 */
func_8012F214(param_1, param_2, (s32)&svec);
D_801A5694 = svec;
v0.a = -*(s16 *)(param_2 + 0xc);
v0.b = *(u16 *)(param_2 + 8);
v0.c = 0;
v1.a = 0;
v1.b = 0;
v1.c = -*(s16 *)(param_2 + 0xa);
((void (*)(void *, void *))func_80049CAC)(&v0, &mtx);
mtx.t[0] = (s32)svec.a;
mtx.t[1] = (s32)svec.b;
mtx.t[2] = (s32)svec.c;
func_8004914C(&mtx);
func_800491AC(&mtx);
RotTransSV(&v1, &buf1, &buf2);
D_801A569C = buf1;
}
// @class: struct
// @stuck: none — MATCH (65 ins)
#include "common.h"
typedef struct { s16 a, b, c, d; } SV4_8017BB34;
typedef struct { s16 m[3][3]; s16 pad; s32 t[3]; } MTX_8017BB34;
s32 func_8017BB34(s32 param_1, s32 param_2)
{
SV4_8017BB34 v0; /* sp+0x10 : func_80049CAC arg0 */
MTX_8017BB34 mtx; /* sp+0x18 : MATRIX, t[] at sp+0x2c */
SV4_8017BB34 v1; /* sp+0x38 : RotTransSV arg0 */
SV4_8017BB34 svec; /* sp+0x40 */
SV4_8017BB34 buf1; /* sp+0x48 : RotTransSV arg1 (-> (*(SV4_8017BB34*)&D_801A569C)) */
SV4_8017BB34 buf2; /* sp+0x50 : RotTransSV arg2 */
svec = *(SV4_8017BB34 *)param_2;
(*(SV4_8017BB34*)&D_801A5694) = svec;
v0.a = -*(s16 *)(param_2 + 0xc);
v0.b = *(u16 *)(param_2 + 8);
v0.c = 0;
v1.a = 0;
v1.b = 0;
v1.c = -*(s16 *)(param_2 + 0xa);
((void (*)(void *, void *))func_80049CAC)(&v0, &mtx);
mtx.t[0] = (s32)svec.a;
mtx.t[1] = (s32)svec.b;
mtx.t[2] = (s32)svec.c;
func_8004914C(&mtx);
func_800491AC(&mtx);
RotTransSV(&v1, &buf1, &buf2);
(*(SV4_8017BB34*)&D_801A569C) = buf1;
}
// @class: regalloc-order
// @stuck: pending self-check — register order param=$s2 counter=$s1 ptr=$s0
extern void (*D_801A56BC[10])(int);
void func_8017BC38(int param_1)
{
register int i __asm__("$17");
register void (**p)(int) __asm__("$16");
i = 0;
p = D_801A56BC;
do {
if (*p != (void (*)(int))0) {
(*p)(param_1);
}
i = i + 1;
p = p + 1;
} while (i < 10);
return;
}
// @class: plumbing
// @stuck: none — MATCH (expected); short-typed global increment + signed compare, store-2 on overflow
extern void func_8017B0E4(int, int);
extern s16 D_801A5674;
extern s16 D_801A5870;
void func_8017BCA0(int param_1) {
func_8017B0E4(param_1, 0xC);
D_801A5674 = D_801A5674 + 1;
if (D_801A5674 >= 0x1F) {
D_801A5870 = 2;
}
}
// @class: plumbing
// @stuck: none — MATCH expected (simple short-increment + guarded call)
extern s16 D_801A5674;
extern s16 D_801A5870;
extern void func_8017B0E4(int, int);
extern void func_8012A4BC(void);
void func_8017BCF4(int param_1)
{
func_8017B0E4(param_1, 6);
D_801A5674 = D_801A5674 + 1;
if (0x18 < D_801A5674) {
func_8012A4BC();
D_801A5870 = 0;
}
return;
}
// @class: regalloc-order
// @stuck: none — MATCH (branch-polarity invert: fn-ptr non-zero call is the fall-through arm)
extern void func_8017B0E4(int, int);
extern void func_8012A4BC(void);
extern s16 D_801A5674;
extern void (*D_801A56B8)(void);
extern short D_801A56FC;
extern short D_801A56FE;
extern short D_801A5700;
extern s16 D_801A5870;
extern s32 D_80114F24;
extern s32 D_80114F28;
extern s32 D_80114F2C;
extern s32 D_80114F30;
extern s32 D_80114F34;
extern s32 D_80114F38;
void func_8017BD50(int param_1)
{
func_8017B0E4(param_1, 6);
D_801A5674 = D_801A5674 + 1;
if (D_801A5674 >= 0x19) {
if (D_801A56B8 != 0) {
(*D_801A56B8)();
} else {
D_80114F30 = D_80114F30 + D_801A56FC;
D_80114F34 = D_80114F34 + D_801A56FE;
D_80114F38 = D_80114F38 + D_801A5700;
D_80114F24 = D_80114F24 + D_801A56FC;
D_80114F28 = D_80114F28 + D_801A56FE;
D_80114F2C = D_80114F2C + D_801A5700;
func_8012A4BC();
}
D_801A5870 = 0;
}
}
extern void (*D_801825E8[])(void);
void func_8017BE60(void *a0) {
D_801825E8[*(u8 *)((s32)a0 + 0x4)]();
}
DEFINE_func_8017BE9C() /* dedup: shared engine-core @0x8017BE9C (src/shared) */
DEFINE_func_8017BEA4() /* dedup: shared engine-core @0x8017BEA4 (src/shared) */
DEFINE_func_8017BEAC() /* dedup: shared engine-core @0x8017BEAC (src/shared) */
DEFINE_func_8017BEB4() /* dedup: shared engine-core @0x8017BEB4 (src/shared) */
src/ov_SC01_000/ov_SC01_000_jr_80178D40.c
+4209
View File
File diff suppressed because it is too large Load Diff
tools/jr_isolate_all.py
+7
View File
@@ -211,6 +211,13 @@ def build_new_config(ov, p):
cfg_block = []
ambient = []
for (lo, hi, items) in regions:
# EMPTY region 0: the object's first item IS the first cut (an already-isolated region
# whose leading jr is being cut again, e.g. cutting func_80178D40 out of
# ov_SC01_000_jr_801734BC — the leader 0x801734BC is a cut too, per the banked-jr rule).
# Emitting it would duplicate region 1's line exactly (same offset, and subseg_name(lo)
# == nm when the object is already named _jr_<leader>) → splat "segments out of order".
if lo is None and not items:
continue
sub = nm if lo is None else subseg_name(ov, lo)
off = (s if lo is None else lo) - base
cfg_block.append(f"{ind}- [{hex(off)}, c, {sub}]")