mirror of
https://github.com/Druthulu/BFM-decomp
synced 2026-09-26 21:36:06 -04:00
e44bc787ebb232c090aaa00c595555ca95ce2bfc
535 Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
 Drew T
|
e44bc787eb |
feat(phase-29): func_80135EB0 banked (289 ins) — 418-site pointer-shape decl axis, R22 140/140
The largest target on the T14 census: 138 members x 289 ins = 39,882 templated instructions at stake. conform_decls --check showed 418 sites in 3 forms, pointer-type-only with NO narrowing warning and no return-type change — the func_80179B74 shape that banked 137/137. Applied (418 sites / 414 files), gated (jtbl carve succeeded first try), R22 clean-fleet 140 passed / 0 failed of 140. Committed BEFORE the family bank because jtbl_family_bank refuses to run on a dirty tree — its per-sibling revert restores from HEAD, so an uncommitted axis would be destroyed. The tool enforcing H4 in code, correctly. Also recorded: family_sweep REFUSED this family rather than returning 0/137 — func_80135EB0 is has_mid_jr, and §53's carve law says a carve-less sweep there yields "a 0% that is a TOOL artifact, not a wall". That refusal is the good version of today's pattern: every false wall untangled this session (func_8016B6BC 0/137, the 4 fabricated CC1-FAILs, Phase-28's B2 0/8) came from a tool that ANSWERED instead of refusing. |
||
|
Drew T
|
a776d3248b |
feat(phase-29): func_8014CF04 + func_8015D1B8 families swept 273/273 (R22 140/140)
BANKED 273 member-matches / 0 failed across 137 overlays (func_8014CF04 136 + func_8015D1B8 137). R22 clean-fleet 140 passed / 0 failed of 140; report fail-closed green (dedup 1886/0, C1 coverage 239604/239604, 0 NON_MATCHING). MEASURED from the committed digests, not projected: fn-count 317,898 -> 318,171 (+273); instr-weighted 83.2 -> 83.4% (+26,770 ins); distinct-code 72.3 -> 72.5% (+129 unique fns). A USEFUL NEGATIVE RESULT: both families swept cleanly across ov_SC07_006/007/010/011 — the same four overlays that refused func_80176218's sweep earlier today. So that set is not broken; the 4/137 refusal is family-specific (the _jr_8016AE5C.c carve), which is the per-sibling INTEGRATION signal §59 describes rather than a codegen or overlay-level wall. Carried, still not concluded. SESSION-22 total: 3 exemplars + 406 members = 409 functions. |
||
|
Drew T
|
ad57c16e61 |
feat(phase-29): func_8014CF04 + func_8015D1B8 banked; conform_decls had 3 defects R22 caught (§98)
THE BANK: the T14 PLUMBING census showed func_8014CF04 blocking THREE drafts at once. Conforming its
decl axis banked func_8014CF04 + func_8015D1B8 (func_80135260 is a genuine DIFF, agreeing with its
independent SESSION-21 diagnosis). R22 clean-fleet 140/140; report fail-closed green (dedup 1886/0,
0 NON_MATCHING). fn-count 317,896 -> 317,898; distinct 66,110 -> 66,111.
BUT THE AXIS WAS A 1,748-FILE T2 WRITE SET (the --check per-form counts read "1"), and R22 came back
139/140 -- TWICE -- on a change the per-binary gate called BYTE-IDENTICAL. Three defects (§98):
1. THE REGEX CROSSED NEWLINES. `[^;]*` matches '\n', so a match starting at a DEFINITION line ran
past the `{` to the first `;`, swallowing `s32 func_8014CF04(...) {` PLUS the register pin on the
next line and replacing both with a prototype -> undefined reference. Fixed to `[^;{\n]*`: a
definition is now unmatchable by construction.
2. IT REWROTE INSIDE COMMENTS (H5, 3 lines). Now scans cdecl._mask() and rewrites by SPAN (R33 --
that length-preserving primitive already existed for exactly this).
3. THE REAL CAUSE -- IT ASSUMED ONE SIGNATURE FITS THE FLEET. ov_SC07_006 carries its own banked
definition with a DIFFERENT byte-true signature ((s32,s32,void*) vs (s32,void*,void*)), under a
decl marked "per-overlay-local decl (byte-true sig); do NOT re-macroize". That is the Phase-16
loose-typing wall inside a tool that structurally assumes it away. NEW RULE: a TU that DEFINES the
function owns its own declarations; a fleet axis is meaningful only for CONSUMING TUs. This grows
more common as banking proceeds -- every overlay that banks a function becomes an exception.
Then the R32 completion assertion cried wolf on its own by-design skip ("HALF-AXIS -- DO NOT BUILD"
for a complete rewrite): an assertion must be exact about its DOMAIN, not just its condition. Scoped
to consuming TUs -> 1,747 sites, 1 excluded by design. Also hardened to PLAN -> VALIDATE -> WRITE;
the refusal path had aborted mid-write while claiming nothing was modified, creating the very
half-axis §85 calls a guaranteed break.
META (R22's premise, re-earned): after fixing defect 1 I EXPECTED R22 to pass; it failed again for an
unrelated reason, and an individual `make build` of the failing binary SUCCEEDED by reusing objects
the clean run rebuilds. An incremental pass does not refute a clean-tree failure.
|
||
|
Drew T
|
ea1d6587d6 |
feat(phase-29): func_80176218 family swept 133/137 (R22 140/140)
+134 functions banked total for this exemplar (1 + 133 members). Measured from the committed progress.fleet.md, not projected: fn-count 317,762 -> 317,896; instr-weighted 82.9 -> 83.2% (+43,818 ins); distinct-code 71.5 -> 72.3% (+126 unique fns — these members are genuine byte- VARIANTS that each count distinctly, not free dedup). VERIFY: R22 clean-fleet (make clean && extract-all && check-all) -> 140 passed, 0 failed of 140. make report fail-closed green: dedup-check 1886 validated / 0 failed, C1 coverage 239604/239604, 0 NON_MATCHING in any default build (G4). THE 4 FAILURES ARE CARRIED, NOT CONCLUDED. All four are ov_SC07_006/007/010/011 and all four differ from the other 133 in exactly one way: their sibling TU is _jr_8016AE5C.c, not _jr_801734BC.c — carved under func_8016AE5C, which was banked and swept in SESSION-21. That is the SAME four overlays and the SAME carve the SESSION-21 checkpoint flagged as "worth checking first" for func_8016B6BC's 0/137, which turned out to be a transitive type-carry (§94) rather than a wall. Each sibling reverted its byte-neutral self-decl edit cleanly, so no dead diff is left behind. Per §59 a sweep failure is a per-sibling INTEGRATION signal, not a codegen verdict — read one sibling's real gate result (COMPILE-fail vs byte-DIFF) before concluding. |
||
|
Drew T
|
8c36ede849 |
feat(phase-29): func_80176218 banked (45,126 templ ins) + reconcile_tu span/R32 fix
THE DRAFT was failing in a CHAIN, one "next conflict" per gate cycle. Applied §95's own diagnostic law instead — splice once, dump EVERY cc1 error — and the whole set named the cause immediately: three errors on TWO axes (one data decl, two callee decls), not three problems. THE DATA ERROR WAS reconcile_tu AGAIN, ONE SHAPE DOWN (§96). split_statements returns comment- STRIPPED text WITH SPANS; the rewrite re-found each planned statement by comparing that text to a raw LINE, so `extern u8 D_80078E78; /* cur base ($s5) */` never matched. The decl was left unconformed WHILE THE USE-CAST PASS STILL FIRED -> a draft whose uses are cast for the TU's storage against the draft's own declaration -> cc1 reports `conflicting types` AT THE VERY DECL THE TOOL JUST CLAIMED TO FIX, exit 0, "reconciled: 3 symbols". FIX: rewrite by SPAN (the primitive existed — its docstring says spans are preserved *because drafts get rewritten*). Plus the R32 assertion the old code was missing: it had a dropped_check counter incremented in two places and NEVER COMPARED — "a loud failure nobody counts is exactly as invisible as a silent one" in miniature. Now declarators-in vs -out AND a per-symbol check that each planned tu.declaration() actually landed, both as `!!` notes so --strict exits non-zero. MEASURED: 3 -> 4 data symbols reconciled on the same draft; trailing comments preserved (H5). THE TWO CALLEE CONFLICTS were the other axis (reconcile_tu skips kind=='func' by construction): cast_call_sites (§20) conformed func_80177AD4 (TU `void (int, unsigned int)`) and func_80178298 (TU `(u32*, u8*, short, short)`) and cast each call site to the draft's intended widths. GATE: verified 1 / failed 0, d19c9580 BYTE-IDENTICAL. Write set is one overlay-local TU = T1 per the §63/§85 blast-radius taxonomy, so the per-binary gate is sufficient; the ×137 sweep is the T2 case and takes a full R22. |
||
|
Drew T
|
1670fe293c |
feat(phase-29): func_8016B6BC 0/137 -> 137/137 — it was a TYPE-CARRY failure, not a wall
The family that failed its sweep twice (once in the 274-member batch, once after the §91 guard) and looked like the §86 bimodal 'some families just don't template' case. It was not. DIAGNOSIS (§59 + §93): spliced ONE sibling and read cc1 directly. It reported `c`, `v`, `off` undeclared — ordinary locals that ARE declared in the remapped body. cc1 says 'undeclared' because it aborted the declaration block at an unknown TYPE and every later declaration fell out with it. Read the FIRST error, not the loudest: a visibly-declared variable reported undeclared means suspect its type. THE LIFT MUST BE TRANSITIVE. Lifting the type the body names directly (M8_8016B6BC) changed nothing — still 0/137. The real set was four, found by following each definition's own references: M8_8016B6BC -> Prim_8016B6BC -> Vtx_8016B6BC (named only inside Prim's body) -> DVec_8016B6BC. lift_types.py --apply, byte-gated ALONE first (neutral, d19c9580 unchanged), then swept. RESULT 0/137 -> 137/137, zero failures. R22 clean-fleet 140/140. cookbook §94. Cost of not diagnosing: this family sat recorded as 'doesn't template' across two sessions. Pointed at one sibling's real stderr it took under an hour and was worth 137 members. |
||
|
Drew T
|
b659ed6da2 | feat(phase-29): func_8014D820 family swept 137/137 (0 failed) | ||
|
Drew T
|
7d9dd6deca |
feat(phase-29): func_8014D820 banked (41,952 ins) + conform_decls scalar-narrowing guard
WAVE 2 (9 never-drafted exemplars, ultracode): 9/9 returned, 5 MATCH / 4 near, 2.25M tokens. BANKED: func_8014D820 (304 ins ×138) — and its agent ROOT-CAUSED the failure I left undiagnosed. It was never an assembler problem: cc1 exit 33, `conflicting types for 'Ent'` vs engine_types.h:434, surfaced by the recipe's `set -o pipefail` and MISATTRIBUTED to `as` because `as` is the last stage in the pipe (Makefile:560). Fixed by moving V4/Desc/Ent to BLOCK scope — byte-neutral and collision-proof across all 138 member TUs. Vindicates flagging it to the agent as UNVERIFIED rather than passing my own guess forward as fact (§88e). R22 clean-fleet 140/140. NEW GUARD — SCALAR NARROWING IS NOT CALLER-NEUTRAL (byte-proven, and it cost 3 gate cycles): conform_decls treated all decl type changes alike. A POINTER change is caller-neutral (func_80179B74 conformed 1,600 sites s16*/short* -> u16* and stayed byte-identical fleet-wide). A SCALAR WIDTH change is NOT: narrowing `s32 a0` -> `u16 param_1` changes argument promotion at every call site. MEASURED on func_80175DA8: decls reverted -> gate says PLUMBING; conform applied -> gate says DIFF. The conform did not fix the draft, it changed the CALLERS. Now warned explicitly (not refused — the draft's sig is still byte-truth for the callee and the gate arbitrates), with the instruction that a DIFF after this conform means examine the callers (§17a-1 pair), not the body. Verified the guard discriminates: fires on func_80175DA8 (s32->u16), silent on func_80179B74. STILL OPEN from wave 2: func_80176218 + func_80175AB8 (DATA-symbol conflicts, D_80078EB4 / D_8011F7BC -> reconcile_decls) · func_80175DA8 + func_80135EB0 (need the §17a-1 caller pair, not a bare conform) · 4 near-misses with precise residuals recorded (func_80176734 129 length-drift, func_80140958 49 inverted-hoist, func_80177B5C 19 sched tie, func_8017C974 83 -> permuter). |
||
|
Drew T
|
acc8d762a0 |
feat(phase-29): func_80179B74 family swept 137/137 (R22 140/140)
134/134 BANKED on the remainder after 3/3 on the probe — the FOURTH full-family sweep this session, all four unblocked by the --like role guard, three of them 100%. R22 clean-fleet: extract-all 139/139, check-all 140 passed / 0 failed. |
||
|
Drew T
|
5ec8aa77af | feat(phase-29): func_80179B74 family probe 3/3 banked | ||
|
Drew T
|
2985f306d9 |
feat(phase-29): func_80179B74 banked — conform_decls cleared it as pointer-type-only (R22 140/140)
1,600 decl sites across 523 files, in THREE different forms (s16 *a0 / short * / short *p), conformed to the byte-true 'void func_80179B74(u16 *p)'. conform_decls ALLOWED this one: the arity is unchanged, so no 0-arg call site can break, and the return is unchanged, so §85's precondition does not apply. Gated BYTE-IDENTICAL; R22 clean-fleet 140/140. The tool has now refused one axis (func_8015B950, correctly — it would have broken 138 binaries) and cleared another (this one, correctly). Both verdicts held under R22. |
||
|
Drew T
|
6b9e2b7f33 |
feat(phase-29): func_8016AE5C family swept 136/137 (R22 140/140)
133/134 BANKED on the remainder after 3/3 on the probe. ONE sibling refused (ov_SC03_108, gate-fail) and is left as a stub rather than forced — a 136/137 recorded honestly beats a 137/137 that needed a shortcut. Third full-family sweep this session, all three unblocked by the --like role guard. R22 clean-fleet: extract-all 139/139, check-all 140 passed / 0 failed. |
||
|
Drew T
|
7804d75230 | feat(phase-29): func_8016AE5C family probe 3/3 banked | ||
|
Drew T
|
d4c4a4d563 |
feat(phase-29): func_8015B950 family swept 137/137 (R22 140/140)
134/134 BANKED on the remainder after 3/3 on the probe — the second clean full-family sweep this session, both unblocked by the --like role guard. func_8015B950 is stubbed in NO overlay. R22 clean-fleet: extract-all 139/139, check-all 140 passed / 0 failed. At 271 ins x 137 members this is the session's largest single family by instruction weight. |
||
|
Drew T
|
8b52bdb30b | feat(phase-29): func_8015B950 family probe 3/3 banked (each whole-binary gated) | ||
|
Drew T
|
f459f53083 |
feat(phase-29): func_8015B950 banked — ONE cast unlocked the 925-site axis that broke 138 binaries
The same axis that broke 138 of 140 binaries an hour ago now lands clean, because conform_decls' NEW arity guard located the actual obstruction instead of leaving me to absorb it by hand. THE OBSTRUCTION WAS ONE LINE. Conforming `extern s32 func_8015B950(void)` -> `(s32 arg0)` turns every 0-arg CALL SITE into `too few arguments`. My hand attempt assumed those were spread across the 926 TUs and would need 926 casts (the func_8012AAAC precedent, where it really was 137 separate sites). They are not: there is exactly ONE call, in `src/shared/engine_core.h`'s `DEFINE_func_8015BEE4()` macro body — expanded into all 926 TUs by the preprocessor. func_8015BEE4 is a THUNK: `return func_8015B950();` with $a0 passing straight through from its own caller. So the 0-arg call shape is byte-CORRECT and must be preserved, not fixed — `return ((s32 (*)(void))func_8015B950)();` keeps it exactly (§17a-1; gcc folds the cast of a known symbol to a direct jal, and the s32 return is unchanged so the thunk's value still flows). Sequence: 1 cast -> conform_decls --apply (925 sites, R32 completion assertion: 0 remaining) -> gate BANKED byte-identical -> R22 clean-fleet extract-all 139/139, check-all 140 passed / 0 failed. The draft's 2 callee-decl conflicts (func_801725A4, func_80147078) dissolved with the axis. Worth 37,398 templatable ins; the ×137 family sweep is next. |
||
|
Drew T
|
7c1640888f |
feat(phase-29): func_8016AE5C banked + tools/conform_decls.py; a 138-binary break R22 caught
BANKED: func_8016AE5C (85 ins ×138). R22 clean-fleet 140/140.
⚠️ I BROKE 138 OF 140 BINARIES AND R22 CAUGHT IT — the per-binary gate could not.
Conforming func_8015B950's decl from `(void)` to its byte-true `(s32 arg0)` across 926 sites gated
BYTE-IDENTICAL on ov_SC01_077 and broke 138 other binaries with Error 33. §63/§85 exactly: a T2
write set is provable only by R22, and the binary the gate authorises is not the binary that breaks.
MECHANISM: conforming a decl to a signature that TAKES parameters makes every existing 0-ARG CALL
SITE a hard `too few arguments` error once a prototype is in scope. Not a declaration-only change.
PROCESS NOTE (mine): a first R22 reported 138 failures, an individual rebuild of a "failing" binary
said BYTE-IDENTICAL, and I nearly filed it as a flake. The second clean R22 reproduced it exactly —
the individual build passed only by reusing objects the clean run rebuilds. An incremental pass does
not refute a clean-tree failure; that is R22's whole premise, pointed at me. Reverted to a known-good
baseline (a stray jr_isolate region file was also in the tree) and redid the one good bank cleanly.
NEW tools/conform_decls.py — because applying this axis by hand three times in one session is how a
half-axis happens. Derives the byte-true signature from the DRAFT's definition (§58b), rewrites EVERY
site, asserts completion (R32). Encodes both preconditions: the §85 return axis (refuse if any caller
consumes the return) and a NEW arity precondition (refuse if 0-arg call sites exist, naming the cost).
The guard immediately gave a better diagnosis than my hand-fix had: func_8015B950's 0-arg call is in
ONE place — src/shared/engine_core.h, a DEFINE macro body — expanded into all 926 TUs. That fix is a
SINGLE cast, not 926 edits. Named as the next step rather than run on tired context.
Also lands cookbook §91 (the --like role trap) from the previous step.
|
||
|
Drew T
|
ab3ac83a41 |
feat(phase-29): func_8012AAAC family swept 137/137 — the --like guard unblocked the whole class
- 134/134 BANKED on the remainder (after 3/3 on the probe) => the family is 137/137, ZERO failures. func_8012AAAC is now stubbed in NO overlay. R22 clean-fleet: extract-all 139/139, check-all 140 passed / 0 failed. - FLEET 81.9 -> 82.0% instr · 89.60 -> 89.64% fn-count · distinct-code 69.3 -> 69.5%. - THE METRIC POINT, reproduced twice in one session and in BOTH directions: this jtbl family is byte-VARIANT (each overlay's table holds its own addresses), so every member is a genuinely new unique function and distinct-code MOVED. The h_seq PURE families swept earlier added 274 members and moved distinct-code by +0.0, because those members were already counted via their shared exemplar. SESSION-20's routing rule, now byte-demonstrated: target byte-VARIANT families to move RE-completeness; high-reach h_exact families move only the display number. - cookbook §91 — "a structure-TRANSFER is only valid where the structure corresponds": the --like role trap, plus the three-hypothesis trail (two wrong, and instructive: the sibling call-site casts were a real defect that fixed nothing, and my own carve-alone test was a false lead that departed from the tool's real sequence). The law: any "same family => same structure" transfer must state which structural fact it assumes and CHECK it on both sides — and a tool that drops an error class it cannot act on should still SURFACE it, because a bare `gate-fail` repeated 137 times cost far more than printing one line would have. |
||
|
Drew T
|
a5e5ea45ef |
fix(phase-29): jtbl_carve — guard the --like role-transfer; the ×137 sweep goes 0/3 -> 3/3
ROOT CAUSE of the 0/3 (found by reading the tool's ACTUAL invocation, not by guessing): jtbl_family_bank calls `jtbl_carve <sibling> --func <fn> --like <exemplar_ov>`, and the role-transfer keys on the SUBSEG ROLE (`ov_SC01_077_a` -> `_a`). Its premise — "same family => same span structure" — silently breaks when the exemplar and the sibling host the function in subsegs with DIFFERENT roles, which happens whenever the exemplar has a split the sibling does not. MEASURED: func_8012AAAC lives in `ov_SC01_077_a` (role `_a`) in the exemplar but in the MAIN subseg (role ``) in every sibling. The transfer therefore looked up `ov_SC01_077` — an unrelated SEVEN-table span belonging to entirely different functions — and stamped those starts onto a sibling span holding one table. jtbl_rodata_pads then refused with `consumed 1 rodata .align(s) but 2 pad spec(s) given — table-count drift`, and jtbl_family_bank deliberately does NOT treat that error as isolate-fixable, so all 137 siblings returned a bare `gate-fail` with the cause discarded. THE FIX: transfer only when the exemplar's subseg for THIS FUNCTION has the sibling's role; otherwise derive the span from the sibling's own carve (which was already computing it correctly). Fail-open is not acceptable here — a wrong table set corrupts the image, so the guard defaults to local derivation. MEASURED RESULT: the 3-member probe goes 0/3 -> 3/3 BANKED. R22 clean-fleet: extract-all 139/139, check-all 140 passed / 0 failed. Two earlier hypotheses were tested and are recorded honestly in CURRENT_PHASE.md: the sibling call-site casts (real conflict, fixed, byte-neutral — but NOT the blocker) and my own carve-alone test (which fails by construction for this shape, because a stub object does not emit the table its 2-entry spec describes — the tool splices the body BEFORE building, so its path is the valid one). |
||
|
Drew T
|
c1d2adab29 |
fix(phase-29): cast the 137 sibling 0-arg call sites of func_8012AAAC (byte-neutral, R22 140/140)
The ×137 member sweep returned 0/3, and §53/§86 say a 0% is a diagnosis task, not a verdict. Diagnosed: every sibling TU has the IDENTICAL shape to ov_SC01_077 — the INCLUDE_ASM stub, then 'extern void func_8012AAAC();', then a 0-arg call LATER in the same file. Splicing the definition in puts a prototype in scope, so gcc rejects the call with 'too few arguments' — the exact failure the exemplar hit, reproduced 137 times. Measured, not assumed: 137 sibling TUs hold BOTH the stub and a 0-arg call — exactly the member count. Cast one call site per TU to ((void (*)(void))func_8012AAAC)() (§17a-1; gcc folds the cast of a known symbol to a direct jal). The 137 'extern void func_8012AAAC();' DECLARATIONS were deliberately left alone — an early count of '274 sites' was the calls AND the externs, and casting an extern would have been meaningless churn. Byte-neutrality PROVEN before committing, not asserted: R22 clean-fleet extract-all 139/139, check-all 140 passed / 0 failed. This must be committed BEFORE the sweep because jtbl_family_bank reverts each sibling from HEAD — an uncommitted fix would be reverted by the very tool that needs it. |
||
|
Drew T
|
2cc49d0310 |
feat(phase-29): SESSION-21 — func_8012AAAC banked via the §81 carve chain (R22 140/140)
The first jtbl-routed bank of the session, and it validates the whole chain end-to-end:
1. jtbl_carve SPLIT-TABLE repair (this session): jtbl_801D7FB0 28 -> 50 words (112 -> 200 B),
authorized by func_8012AAAC's own `sltiu 0x32`.
2. NEW FIX — SINGLE-TABLE PREDECESSOR: adding a second table to a subseg whose existing carve was
single-table lost the FIRST table's start entirely (new_offs has only the new one;
overlay_jtbl_addrs cannot see the old one because its owner is banked and extract PRUNED the
stub .s; and single-table carves persist no tables= to rebase). The span then failed its own
validator with "first must equal the span start" — the invariant naming the missing entry.
A single-table carve spans exactly its one table, so ITS SPAN START *IS* THAT TABLE'S START:
inference, not persistence, so it also works for spans carved before tables= existed. This is
the RECOVERABLE half of the documented func_8013F350 lesson (that one was a pre-§8e merged
DOUBLE — two tables, no record, genuinely unrecoverable).
Result: ov_SC01_077_a JTBL_PADS := 0,0 tables=+0x0,+0x14. Carve alone byte-gated BYTE-IDENTICAL
BEFORE the bank was attempted (§81 step 2).
3. ARITY axis, all-or-nothing: 1,244 decl sites / 1,240 files `(void)` -> `()` + an R32 completion
assertion (old-form remaining: 0).
4. ONE call-site cast: the definition lands at line 811 and a 0-arg call sits at 822, so gcc sees
the prototype and rejects it — `((void (*)(void))func_8012AAAC)()` (§17a-1; gcc folds the cast
of a known symbol to a direct jal). Only 1 of the 1,386 fleet-wide 0-arg call sites needed it:
the others see only the `extern ()` decl, which permits a 0-arg call.
DIAGNOSIS NOTE: the failure read CC1-FAIL with only a warning visible under make. Running the
pipeline stage-by-stage (cpp | cc1 | maspsx | jtbl_rodata_pads | as) put it on cc1 rc=33, and cc1's
own stderr named it exactly: "too few arguments to function func_8012AAAC" at line 994. Isolating
the stage was what turned an opaque Error 33 into a one-line fix.
R22 clean-fleet: extract-all 139/139, check-all 140 passed / 0 failed.
family_sweep correctly REFUSED this exemplar (§53: a jr-family must route through
jtbl_family_bank.py; "a 0% from this path would be a TOOL artifact, not a wall") — the ×137 member
sweep is the next step and needs a clean tree, which this commit provides.
|
||
|
Drew T
|
5be4c21480 |
feat(phase-29): SESSION-21 — the ×138 member sweep: 274 members from 3 exemplar cracks (R22 140/140)
- family_sweep --hseq over the 3 newly-banked exemplars: BANKED 274 member-matches / 137 failed across 137 overlays, for ~0 agent tokens. Session total: 3 exemplars + 274 members = 277 fns. - THE STALE-MAP STEP, hit and handled: the first sweep returned "0 matched-exemplar families" because .run/family_hseq.json still listed the fresh cracks as draft-ov077. Regenerated (matched-sib families 60 -> 63) and the sweep found them — the documented bank-x1 -> regen -> sweep path (memory crack-wave-sweep-map-regen). - §86 REPRODUCED CLEANLY: 2 of 3 families templated ~137/137; the third failed ~137/137. Not a rate — a BIMODALITY. One probe per family, then sweep or skip; never a blended pool average. - R22 clean-fleet: extract-all 139/139, check-all 140 passed / 0 failed (second clean-tree verification this session). dedup 1886/0, C1 coverage 239,604/239,604, 0 NON_MATCHING (G4). - FLEET 81.7 -> 81.9% instr · 89.52 -> 89.60% fn-count · distinct-code 69.3% UNCHANGED — correct and expected: these are h_seq PURE propagation-class families, and SESSION-20's routing rule says propagation moves only the DISPLAY metric (members were already counted once via their exemplar). To move RE-completeness, target byte-VARIANT families. Stated plainly so the next session picks targets by the metric it means to move. - drive-by: family_sweep --help crashed (argparse %-expands help text; a literal "0%" needed "0%%"). |
||
|
Drew T
|
2ce6c5fade |
feat(phase-29): SESSION-21 — 3 family exemplars banked + the §85 return-axis widen (R22 140/140)
BANKED (whole-binary byte-gate, the sole arbiter): func_8014D2A0 (80 ins ×138) · func_80158638
(87 ×138) · func_8016B6BC (94 ×138). Stubs in ov_SC01_077: 150 -> 147, 0 new stubs.
R22 CLEAN-FLEET: extract-all 139/139, check-all 140 passed / 0 failed. dedup 1886/0,
0 NON_MATCHING (G4). Fleet 81.7% instr / 69.3% distinct-code / 89.52% fn-count.
- WAVE STOPPED at Drew's request with 15/24 agents returned, ALL 15 status=match. Only the
completed drafts were gated; in-flight ones are still being written (§90d).
- PRE-GATE, both oracles, all 15: match_one MATCH + reloc_verify ALL RESOLVED. Routed 7 plain /
8 to the §81 jtbl carve chain.
- THE BLOCKER, MEASURED: 7 of 7 plain drafts failed PLUMBING, 0 DIFF, 0 compiler walls — the same
shape as SESSION-20's T0.2. §58b applies: the draft sig is byte-TRUTH (it MATCHed), the header
decl is the stale stub-era guess, so conform the DECLS.
- §85 RETURN-AXIS WIDEN, all-or-nothing: 3,471 decl sites / 1,736 files, precondition verified
(ZERO callers consume the return => byte-neutral by construction) + an R32 completion assertion
(old-form decls remaining: 0). func_8014D820's s32 return is load-bearing — forcing `void` costs
2 instructions (302 vs 304), so the decls had to move, not the draft.
TWO HONESTY ITEMS:
1. I REPORTED "0 of 7 banked"; the true number was already 2. My diagnostic pass printed only
lines starting with "- func_" (the failures) and hid its own successes while I read it for
error text. A script that prints only failures cannot tell you it succeeded — the R32
silent-skip shape aimed at my own instrumentation. Ground truth is the stub count (§55b(3)).
2. A REAL FINDING fell out of that mistake: same drafts, same tree, minutes apart — gate_stage's
full ladder banked 0/7 while bare harvest_verify banked 2/7. The LADDER REGRESSED two drafts
the bare gate accepts (§19's "sig_unify regresses already-canonical drafts", one level up, and
the exact mirror of SESSION-20's missing-ladder false 33%). Neither "always ladder" nor "never
ladder" is right — run both, let the byte-gate arbitrate. One build per draft.
OPEN: func_8014D820 still a stub — after the widen its error moved from `conflicting types` to an
assembler-stage failure, not finished diagnosing. Recorded as open, NOT as a wall.
|
||
|
Drew T
|
d2a79deff2 |
feat(phase-29): ALL THREE BEHEMOTHS BANKED — func_80183814 (5,122), func_8017DC1C (1,518), func_8017D2DC (1,586)
Zero functions >1000 ins remain unmatched anywhere in the fleet. func_80183814 (5,122 ins — the LARGEST function in the game) — round 2 closed it: length 5127->5122 exact, structural residual 36->0, register-sensitive 1201->0, frame -256 -> -0xF8 exact, saves 10 -> .mask 0x807f0000 exact. Verified independently (R14): match_one MATCH (5122 ins). ROUND 1's DIAGNOSIS WAS WRONG and the agent refuted it properly: the +5 length was a SYMPTOM, not the lever, and the §83d max_reg/cse.c:8340 story does not hold — a 15-line reproducer reproduced the case-0/3 CSE exactly (so it cannot be max_reg-gated), max_qty only gates extension ACROSS blocks, and the target leaves $s7/$fp unused (no pressure story). Confirmed from a second direction: C01 has the identical two groups over the identical symbols with ZERO residual, because a `break` puts a CODE_LABEL between them. The two biggest levers were pure DECLARATION SCOPE (§45/§76), not pins. func_8017DC1C (1,518) — MATCH first round, pin-free, zero __asm__ dials. NOT a jr fn (0 mid-fn jr). func_8017D2DC (1,586) — MATCH first round (banked in the previous commit). BANKING ORDER MATTERS — a new failure mode found and worked around: banking func_8017DC1C BEFORE the carve chain broke the build. Its draft establishes the canon for 39 previously-undeclared externs; jr_isolate_all's re-partition (overlay_src_split) then DROPPED ALL 39 across the new split boundary (`D_801C1EB0 undeclared`), leaving them in NEITHER file. The §77 preamble-drop class, in a third tool. FIX = ordering, not patching: run the §81 carve chain FIRST on a clean tree (gated BYTE-IDENTICAL), then bank. Reverted, re-sequenced, both banked clean. R22 clean-fleet 140/140 BYTE-IDENTICAL; tools-health OK; dedup 1886/0; 0 NON_MATCHING (G4). Fleet: instr 81.6 -> 81.7% · distinct-code 69.1 -> 69.3% · fn-count 89.52%. |
||
|
Drew T
|
09b1993059 |
feat(phase-29): T0.7 sweep (104 members) + BEHEMOTH func_8017D2DC banked (1,586 ins)
T0.7 — the §86 one-member probe applied to the remaining FREE families: 9 LIVE / 6 DEAD / 5 unstaged. The three highest-value families by raw size (18,084 / 11,234 / 10,880 ins) all probed DEAD — the probe skipped them instead of burning ~400 gate cycles rediscovering it. Swept the 9 live: 104 banked, 8 of 9 families fully cleared (func_8017BEF8 has 8 stragglers). BEHEMOTH 2 of 3: func_8017D2DC (1,586 ins, ov_SC01_001) MATCHED and BANKED — closed in ONE agent round, pin-free. Verified independently (R14): match_one MATCH (1586 ins). §81 carve chain: the agent predicted step 1 unnecessary; jtbl_carve REFUSED (the subseg already hosts a .rodata carve and the new table's start != span start). The refusal was RIGHT and is the instruction to run step 1 — jr_isolate_all --only (2 fns/1 object) -> BYTE-IDENTICAL, then jtbl_carve -> BYTE-IDENTICAL, then the ladder banked it. R22 clean-fleet 140/140 BYTE-IDENTICAL; tools-health OK; dedup 1886/0; 0 NON_MATCHING (G4). Fleet: instr 81.5 -> 81.6% · distinct-code 69.0 -> 69.1% · fn-count 89.49 -> 89.52%. |
||
|
Drew T
|
c2566010f2 |
feat(phase-29): --allow-pins sweep — 268 banked; pin templatability is PER-FAMILY (cookbook §86)
The §42e pin guard refuses any family whose exemplar carries `register __asm__` pins: 680 of the top
8 FREE families' 1,083 members (63%) were skipped BEFORE any gate ran. Re-run with --allow-pins,
letting the byte-gate arbitrate (G3/P9): 268 banked, and ZERO cc1 crashes across hundreds of pinned
compiles — confirming the SIGABRT the guard was written against was Phase 27's extract_unit
macro-drop, NOT a compiler limit. The guard is protecting against a bug that no longer exists.
THE LAW (§86): templatability is a PER-FAMILY property, not a per-member rate.
func_801749C8 137/137 = 100% func_80133AB0 4/136
func_8014C6F4 137/137 = 100% func_8014CF04 0/137
func_80143D28 0/136
Two families at 100%, three at ~1%. MY REPORTED "37%" WAS AN ARTEFACT: a 19-member sample that
straddled families reported their AVERAGE and hid the bimodality. Sample PER-FAMILY, never per-pool.
=> PROCEDURE, now the default: probe ONE member per pinned family; bank -> sweep the family; fail ->
skip entirely. The blanket sweep spent ~412 futile gate cycles (60% of the run) on three families
that were never going to bank; the 1-member probe reduces that to 5 probes + 2 sweeps.
Left explicitly UNDIAGNOSED (do not guess): why two families template and three do not. Likely axis
is caller-saved pins spanning a `jal` (§74's corrupting form) vs pins fixing only a local allocno.
Diagnose BEFORE extending --allow-pins fleet-wide — the byte-gate makes a wrong guess free, but a
wrong PROCEDURE costs a sweep.
R22 clean-fleet 140/140 BYTE-IDENTICAL; tools-health OK; dedup 1886/0; 0 NON_MATCHING (G4).
Fleet: instr 81.3 -> 81.5% · distinct-code 69.0% · fn-count 89.41 -> 89.49%.
|
||
|
Drew T
|
52e6522f1b |
feat(phase-29): T0.5 — FREE-subset sweep, 3 families fully banked (389 members, +37,713 ins)
Re-derived the T0.1 decomposition post-harvest (it was stale by 395 banked members): zero-crack pool 76 fams / 347,892 ins -> 73 fams / 290,850 ins (the harvest came out of it) FREE (sweepable, non-jr, non-O0) -> 58 fams / 167,368 ins Swept the top FREE families through the gate_stage ladder (sample 8/8 first, then the rest): 389 banked; func_801463A0 / func_8017B490 / func_80156670 now stubbed in ZERO overlays. R22 clean-fleet 140/140 BYTE-IDENTICAL; tools-health OK; dedup 1886/0; 0 NON_MATCHING (G4). Fleet: instr 81.0 -> 81.3% (10,645,711 -> 10,683,424) · distinct-code 68.8 -> 69.0% · fn-count 89.30 -> 89.41%. THE BLOCKER HAS MOVED — it is now OUR OWN PIN GUARD, not gcc and not declarations. Of the 1,083 candidate members in the top 8 FREE families, 680 (63%) were refused by the §42e pinned-exemplar guard BEFORE any gate ran; only 403 reached staging. Two pieces of evidence say the guard may now be over-conservative: SESSION-19 banked func_8017A4AC x134 WITH pins once the byte-gate arbitrated, and Phase 27 dissolved the cc1 SIGABRT that motivated it (it was the extract_unit macro-drop, not a compiler limit). Next probe: --allow-pins on a sample of 8, byte-gated. MY OWN SCRIPT BUG, fixed + negative-controlled: the sweep loop globbed `.run/sweep/*/`, which also matches gate_stage's INTERMEDIATE ladder dirs (-cn, -cn-cast, -cn-cast-rc, -s2in, -s2in-uni). Those were called as if they were binaries -> 24 phantom "PARTIAL 0/1" lines inflating notbanked to 56 when the true failure count was ZERO (stub counts 0/0/0 are the ground truth). Fixed by requiring config/splat.<ov>.yaml to exist; negative control confirms phantoms are skipped and real binaries kept. |
||
|
Drew T
|
015ebff536 |
feat(phase-29): §84 family fully harvested — 123/123 members, 0 failed (+29,280 ins, +27,840 distinct)
The derived-offset recompute swept the whole func_8013D53C family: 119 banked / 0 failed on top of the 4 earlier; func_8013D53C is now stubbed in ZERO overlays. R22 clean-fleet 140/140 BYTE-IDENTICAL; tools-health OK; dedup 1886/0; 0 NON_MATCHING (G4). RECIPE (and it is NOT the return-axis recipe — sampling caught this): §84 derived-offset -> per-member literal recompute AND the gate_stage ladder. With the recompute alone the sample was 0/8; through the ladder it was 3/3, then 119/119. Had I reused the return-axis recipe (plain harvest_verify, which banked 272/272 there) I would have swept 123 members to zero banks and mis-concluded the fix was wrong. Probe-before-scale. METRIC FINDING worth carrying: this harvest moved instr +29,280 AND distinct-code +27,840, while the return-axis harvest moved instr +26,928 and distinct-code +0. §84-class members are byte-VARIANTS so each is a new unique function; propagation-class members were already counted once via their shared exemplar. => §84-class work moves the RE-COMPLETENESS number; propagation moves only the DISPLAY one. Session fleet: 80.6 -> 81.0% instr · 68.2 -> 68.8% distinct-code · 89.18 -> 89.30% fn-count. |
||
|
Drew T
|
9d9cd58028 |
feat(phase-29): T0.4 harvest — 272 return-axis members banked (+26,928 ins) + the §84 recompute in family_remap
THE §85 WIDEN PAID OFF AS PREDICTED. It is a ONE-TIME fleet edit, so once committed the
`conflicting types` blocker was gone for EVERY member of both families at once:
- sample 8 first (probe-before-scale): 8/8 banked with PLAIN harvest_verify, no ladder needed
- full sweep: 264 banked / 0 failed across 132 overlays; 10 skipped as not-stub
- total 272 members ~= 27k ins, ZERO agent tokens
R22 clean-fleet 140/140 BYTE-IDENTICAL; dedup 1886/0; 0 NON_MATCHING (G4).
Fleet: instr 80.6 -> 80.8% (10,589,503 -> 10,616,431, +26,928) · fn-count 89.19 -> 89.26%.
distinct-code UNCHANGED at 68.3% — propagation moves the DISPLAY metric, not the RE-completeness
one (the SESSION-19 split, reconfirmed).
§84 RECOMPUTE now implemented in tools/family_remap.py (fix_derived_offsets), wired into all three
apply_remap call sites as a PRE-pass on the exemplar body (the literal is ambiguous as a substitution
token, so it cannot be a table entry):
correct_literal = mapped(aliased_sym) - mapped(base_sym)
Verified by negative control: the hand-solved case recomputes 0x20 -> 0x18 exactly, and a site whose
target endpoint is NOT a mapped symbol is left byte-for-byte alone AND REPORTED in info
["derived_offsets"] (R32 — a silent skip is a defect, and a silent skip is how this bug survived).
|
||
|
Drew T
|
772b5c4e02 |
feat(phase-29): the RETURN-axis fleet widen — 2 more families unlocked (cookbook §85); 140/140
Continues the "see why and try again" chain. Diagnosed all 4 T0.2 failures to 4 DISTINCT causes: func_8013D53C 240x123 §84 derived-offset remap bug -> BANKED (previous commit) func_8012CC88 105x137 §73/§30#2 RETURN-axis conflict -> BANKED here func_8014D12C 93x137 §73/§30#2 RETURN-axis conflict -> BANKED here func_80144090 154x136 LENGTH-DRIFT (+13 B, ~3 ins long) -> genuine codegen, real work THE FAILURE THAT TAUGHT THE FIX: widening only src/shared/engine_core.h banked the member in the TARGET overlay and BROKE ov_SC01_077 (R22 139/140) — the source overlay carries its OWN local `extern void func_X(...)` decls, so a shared-header-only widen puts them in direct conflict. The per-binary gate passed while breaking a binary it never built (§63/§61: a T2 write set is only provable by R22). A half-done axis is a guaranteed break, not a smaller win. THE FIX: do the WHOLE axis — 3,668 `extern void` decl sites across 2,688 files widened to `s32`, 0 remaining (R32 completion assertion). Precondition verified first: 0 callers consume the return value, so the widen is byte-neutral by construction. R22 clean-fleet 140/140 BYTE-IDENTICAL; tools-health OK; dedup 1886/0; 0 NON_MATCHING (G4). MY OWN ERROR, recorded (§85 trap): I first spot-checked ov_SC01_077 with `make build | grep | head; echo rc=$?` and read rc=0 as success — that is the exit status of `head`, not make, and the output had no BYTE-IDENTICAL line. I reported a false BYTE-IDENTICAL in the interim. Assert on the SUCCESS STRING, never on $? after a pipe. Fleet: instr 80.6% (10,589,503) · distinct-code 68.3% (3,846,656) · fn-count 89.19%. |
||
|
Drew T
|
b6bb04ecff |
feat(phase-29): CRACK THE PLUMBING FAILURE — the derived-offset remap bug (cookbook §84); func_8013D53C banked
Drew: "if it fails, see why and try again with new knowledge." It failed twice, then banked.
ROOT CAUSE, byte-proven: a family_remap member reached match_one MATCH (240 ins) and failed the
whole-binary gate by ONE BYTE. The exemplar carries a deliberate matching idiom — reach a symbol via
a DIFFERENT symbol plus a literal offset, so gcc cannot CSE the two %hi/%lo pairs:
(*(S9*)&D_801DAA78) = *(S9*)(&D_801DA998 + 0x20); /* same addr as &D_801DA9B8 */
family_remap substitutes the symbol NAMES correctly and leaves the literal 0x20 — but 0x20 is not a
constant of the algorithm, it is the DISTANCE BETWEEN TWO PER-OVERLAY SYMBOLS:
exemplar 0x801DA998 + 0x20 = 0x801DA9B8 OK
member 0x801A5778 + 0x20 = 0x801A5798 WRONG (real symbol 0x801A5790)
member 0x801A5778 + 0x18 = 0x801A5790 correct
match_one MASKS HI16/LO16 so it is STRUCTURALLY BLIND to this — the §81 blindness in its DATA form.
TWO FIXES WERE EACH INDIVIDUALLY INSUFFICIENT: the byte fix alone re-failed as PLUMBING; the ladder
alone re-failed as DIFF. Together -> BANKED, R22 clean-fleet 140/140.
TWO LADDER CORRECTIONS (my own T0.2 error): bare harvest_verify is the LAST RUNG, not the ladder —
gate_stage runs canon_resident_calls -> cast_call_sites -> reconcile_tu -> ARITY -> sig_unify ->
harvest_verify, so T0.2's "8/8 PLUMBING" measured the UN-RECOVERED rate. And reconcile_decls.py is
RETIRED (R33, superseded by reconcile_tu): asking "what does the FLEET call this symbol?" is wrong by
construction in a loosely-typed engine (548 of its answers conflicted, rewriting 60 of 196 drafts) —
so Drew's suggested tool would have made it worse.
SCOPE, MEASURED (not over-generalised, §80): the idiom appears at only 5 sites corpus-wide — BUT one
gates a 123-member family (133 staged drafts all carry the un-recomputed +0x20 with different
per-overlay bases), so the mechanical fix is worth ~240 ins x 123 ~= 29,520 ins. It does NOT explain
the pool generally: func_80144090 / func_8012CC88 / func_8014D12C have ZERO derived-offset sites and
fail for a different, still-undiagnosed cause.
THE FIX IS MECHANICAL: correct_literal = mapped(aliased_sym) - mapped(base_sym). The remap already
holds both mappings, and the exemplar's own comment names the aliased symbol.
Also observed: the ARITY pre-pass left 40 TUs of caller-decl edits after a 0-bank run (same hygiene
bug as --normalize-self-decls, twice in one session) — reverted, both binaries byte-identical.
|
||
|
Drew T
|
d3e6d6a702 |
feat(phase-29): T0.2 gate probe — the FREE pool is PLUMBING-blocked, not wall-blocked (4 banked)
MEASURED, not projected (R14): 12 gate attempts across ov_SC01_000 + ov_SC01_001, one draft per build for clean attribution. - 4 BANKED (func_8017B490 x2, func_801463A0 x2); 8 failed; **0 DIFF — zero compiler walls** - all 8 failures are the §75a/def-side declaration class: `conflicting types for 'D_800A651C'` (DATA sym) and `conflicting types for 'func_8013D53C'` (the member's OWN def-side decl) - => raw conversion 33%, but the ceiling is NOT 33%: the blocker is declaration plumbing, which this project has named tools for. Plumbing recovery has out-earned drafting in every phase that measured both (P19 fix_arity_callers, P28 dedup_extend 6,174 members / 95.6% from one new mode) TWO CORRECTIONS TO MY OWN T0.1 POOL MATH, both downward: - 2 of the 8 top "FREE" families were refused outright by the §42e pinned-exemplar guard (the 270 skips) => "FREE" does NOT imply sweepable; pins are a third blocker the decomposition missed. Recoverable (--allow-pins; SESSION-19 banked pinned families x134), but I mis-labelled them - n_templatable counts the matched exemplar, so every T0.1 family figure is ~1 member (~0.7%) high NEGATIVE RESULT (§80, scoped to this base): --fix-def-sig REGRESSES this class — 0 banked and 2 PLUMBING became CC1-FAIL despite targeting the same error text. Do not re-buy without re-testing. NAMED NEXT LEVER: family_sweep --normalize-self-decls, whose help text cites fixing "the conflicting types for func_X that blocked 133/137 of func_801670E4" — exactly this failure. Gate-phase transform, so it cannot run under --stage-only, and --limit caps FAMILIES not MEMBERS => needs a full ~123-member family run. Highest-value outstanding probe, zero agent tokens. R22 clean-fleet 140/140 BYTE-IDENTICAL; tools-health/dedup 1886/0; 0 NON_MATCHING (G4). Fleet: instr 80.6% (10,589,065) · distinct-code 68.3% (3,846,416) · fn-count 89.19%. |
||
|
Drew T
|
661f5aa751 |
feat(phase-29): bank func_8017C730 x ov_SC03_013 (+1,061 ins) via the §81 carve chain
The SESSION-19 handoff's item 1, closed as specified — no drafting, no agent. - §77 MINIMAL CLOSURE (519 lines, not the 2,993-line whole-file carry): 18 gte_* macros + 5 externs + the bandsetup static-inline helper -> match_one MATCH (1061 ins) - §81 chain, each step byte-gated before the next: jr_isolate_all --only (2 fns/1 object) -> BYTE-IDENTICAL; jtbl_carve --func (single-table, 44-piece interleave) -> BYTE-IDENTICAL; harvest_verify --chunk 1 -> verified 1 / failed 0, 7042bc71 BYTE-IDENTICAL - R22 clean-fleet 140/140 from a genuinely clean tree; tools-health OK; dedup 1886/0; 0 NON_MATCHING (G4). FLEET distinct-code 3,845,161 -> 3,846,222 = 68.3% (+1,061, all distinct — a behemoth-class bank, not a propagation); instr-weighted 80.6% - No §75a class spoke: the exemplar's ApplyMatrixSV(void*,void*,void*) canon fix was already carried, so the declarations were clean and it banked first try - cookbook §77: the ladder CLOSED with all four rungs measured (-56 -> -34 -> MATCH-but-uncommittable -> MATCH+BANKED), plus a NEW subsection — the CANDIDATE gate and the REAL gate need DIFFERENT preambles (match_one compiles standalone, so a shared-type body's CC1-FAIL is a report about the PROBE, not the draft; the types header goes in a throwaway probe copy, never in the banked draft) - FINDING, flagged not acted on (P5d): that shortcut already leaked an ABSOLUTE include path into 21 git-tracked files / 23 lines. All 21 verified semantically no-op (guarded engine_types.h via engine_core.h at line 2) => removal is byte-neutral, but cpp must still find the literal path, so those TUs cannot preprocess on any clone not at /home/musashi/bfm-decomp. Invisible to every byte-gate (R34's null-oracle shape, aimed at portability). Proposed as the next task. |
||
|
Drew T
|
109ce6a2c3 |
feat(phase-29): BEHEMOTH #6 func_8017C730 BANKED (1,061 ins) + §82 two source-shape oracles
- CRACKED at xHigh and VERIFIED INDEPENDENTLY: match_one MATCH (1061 ins); agent re-matched 3x from clean runs (100% register-masked AND register-kept, all 10 regions, frame 0x270 exact). §81 carve chain clean first try: jr_isolate_all --only -> byte-identical cacaf7c2 -> jtbl_carve (43-piece set) -> byte-identical -> bank -> R22 clean-fleet 140/140, tools-health OK. instr 80.6%; distinct-code 3,844,100 -> 3,845,161. - WHAT IT IS: the matched base func_8017CA80 + camera height-band cull + distance-driven CLUT fade. func_8004974C (TransposeMatrix) sits in a 36-ins prologue deriving a Y band; the part-level `lim >= g.otz` cull is GONE; flat arms gain an `sz < lim` near-plane cull. The base+one-extra-callee fingerprint predicted this exactly. - §82 ORACLE 1 -- A DUPLICATED `addiu $aN,$sp,K` ACROSS A `jal` MEANS THE BLOCK WAS INLINED. `&X` on any non-first local always creates a pseudo and CSE always merges two of them (expr.c:6260 ADDR_EXPR -> force_operand(..., NULL); exception: virtual-stack-vars offset 0). So the same stack address re-materialised at two sites separated by a jal means CSE was PREVENTED from merging => not the same function body. 17 non-inline spellings failed; a `static inline` helper reproduced the prologue BYTE-FOR-BYTE first try. Reusable probe: scan the ~1,200 built objects for that signature in NON-INCLUDE_ASM functions. - §82 ORACLE 2 -- SCALAR vs AGGREGATE DECIDES *WHEN* A STACK SLOT IS ALLOCATED: lazily at first `&` for a scalar, AT DECLARATION for an aggregate. Six GTE result words had to be six separate longs, not a struct, or they don't land after the inlined helper's temps and the frame isn't 0x270. Second-order: it also flips MEM_IN_STRUCT_P (§30's /s) -- with one word a fixed-address scalar, ((PolyF3*)pkt)->rgbc stops aliasing it, so a store needed respelling to keep the target's nop. A scalar-vs-struct choice is simultaneously a frame-layout AND an aliasing decision. - BANKING FOOTNOTE (§75a class A): first bank rejected `conflicting types for ApplyMatrixSV` -- draft (MATRIX2*, SVECTOR2*, SVECTOR2*) vs the TU/fleet canon (void*, void*, void*), 2,286 of 2,835 sites. Conforming the decl is byte-neutral and banked first try. On a jr function expect BOTH gates to speak: the carve chain answers the jump table, §75a answers the declarations. - Also reproduced: §78 (reuse a busy variable), §80(i) (a lever went -8 -> exactly neutral as the base moved), §72 (a register pin made it worse). - AGENT'S OWN CAVEAT, recorded not hidden: one zero-byte __asm__ keeps a vestigial `mnc = hmid` alive that flow.c would delete (costing 10 ins + the 0x130 spill slot). Emits nothing, compile is 1061 exact, but it is a documented stand-in -- 12 natural spellings measured, all DCE'd. |
||
|
Drew T
|
faf4547345 |
feat(phase-29): func_8017C954 BANKED — jr carve chain cleared; a shared type was PRESENT but INVISIBLE
- BANKED (1,194 ins, ×1 distinct-code). Chain cleared, each step byte-gated before the next was
built on it: one-line fix to jr_isolate_all._engine_types() -> jr_isolate_all --only
func_8017C954 (2 fns / 1 object, NOT the bare 47-fn / 21-object resegment) -> BYTE-IDENTICAL
b7b0d4ae -> jtbl_carve --func func_8017C954 (44-piece carve set + interleave order) ->
BYTE-IDENTICAL -> harvest_verify VERIFIED BYTE-IDENTICAL -> R22 clean-fleet 140/140,
tools-health OK. instr 80.5 -> 80.6%; distinct-code 3,842,906 -> 3,844,100.
- THE DEFECT (tools/jr_isolate_all.py): _engine_types() harvested shared type names with four
patterns -- `typedef ... X;`, `} X;`, forward-decl `struct X;`, fn-ptr typedef -- and a TAGGED
DEFINITION WITH A BODY matches NONE of them. So `struct PW8017E6D8 { int w; }
__attribute__((packed));` at engine_types.h:658 was present in the shared header yet invisible
to the carried-type check, and `extern struct PW8017E6D8 D_801E1EC4;` could not be placed.
MEASURED BLAST RADIUS: 77 such tags in engine_types.h were invisible. One added pattern fixes
all 77.
- WHY THIS COST 20 MINUTES INSTEAD OF A MYSTERY BYTE-DIFF THREE PHASES LATER: the Phase-26 audit
had already turned this predicate's SILENT DROP into a LOUD REFUSAL. The original bug dropped
4,040 col-0 decls, 683 of them function PROTOTYPES -- and a dropped prototype is a SILENT
BYTE-CHANGER (C89 implicit `int f()`; return type drives delay-slot fill in this codebase). The
refusal named the exact symbols and the exact remedy. A loud "I cannot place this" is worth far
more than a green build -- the audit paying for itself, live.
- §81: the 3-step jr-carve chain + why match_one CANNOT see the problem (it masks jal/HI16/LO16,
so a jump-table function reports MATCH while the whole-binary gate reports DIFF, correctly).
Detect with `grep -cE 'jr \$(v0|v1|a0|t[0-9])'` on the target .s + a jtbl_ in asm/<ov>/data/.
ALWAYS use --only: bare would have resegmented 47 jr-functions across 21 objects.
|
||
|
Drew T
|
8b828f1ea6 |
feat(phase-29): BEHEMOTH func_8017BF14 CLOSED — 45 -> 0 (4,763 ins, the largest match yet)
- 45 -> 37 -> 33 -> 21 -> 11 -> 3 -> 2 -> 0, reproduced 3x from independent work dirs. Verified independently before believing it (R14): match_one MATCH (4763 ins), then harvest_verify --binary ov_SC03_116 BYTE-IDENTICAL, then R22 clean-fleet 140 passed, 0 failed of 140. distinct-code 3,838,143 -> 3,842,906 = 68.1% -> 68.2%. instr 80.5%. Agent was interrupted by a weekly API limit and RESUMED FROM ITS TRANSCRIPT -- its round-2 harness survived, nothing was re-derived. - §80 THE PROCESS CORRECTION, worth more than the match: A DO-NOT-RE-BUY ENTRY IS SCOPED TO ITS BASE, NOT TO THE FUNCTION. Three of round 1's ~40 measured negatives INVERTED on round 2's base -- the same edit (qsingle23) measured 1,040 mismatched on the 45-base and 11 on the 21-base. Re-testing the round-1 negative list cost ~20s and produced THREE of the seven winning levers. Such a table records (edit, base) -> result, NOT edit -> useless; after any lever that moves the base materially, RE-RUN THE NEGATIVE LIST. This retroactively qualifies every do-not-re-buy table in the cookbook (§45, §60b, §75a, §76, §78, §79). Concrete: round 1 measured "removing the va->$t2 pin costs 4% elsewhere" => keep the pin; on a base with c0..c3 at function scope, removing those pins is worth 21->13. Same experiment, opposite conclusion. - MY FLAGGED "#1 MOVE" LOST, and the failure is the finding. I briefed variable REUSE (§45-A / RC-14) as the top lever because it took func_8017F510 from 97->10. Swept in full here: EVERY merge lost, 43-3294 across 8 merges. Reason: the TRI and QUAD grants did not differ by RANK but by IDENTITY -- two independent allocno sets, and re-ranking inside one set cannot fix a two-set problem. Diagnose ranking-vs-identity before reaching for a merge. The actual fix (c0..c3 at FUNCTION scope, 33->21) was read off the two matched relatives (b5:310, b4:338) and confirmed against the target -- the 4th time today that reading a matched relative beat the clever lever. - PIN'S HIDDEN COST, cited: combine_regs' hard-register branch (local-alloc.c:1795, reached from :1295 with already_dead==0) records the pinned reg in qty_phys_sugg UNCONDITIONALLY -- no death guard. A pin invites local-alloc to tie producer chains into it. New cure R7: a zero-byte __asm__ ref keeping the pinned value live past the temp so find_free_reg can't honour the suggestion -- closed the last 2 ins (c1->$a0 is uniquely load-bearing; every alternative pin lost 64 ins). - §78's attribution primitive RUN and REPRODUCED: under -fno-schedule-insns, -fno-schedule-insns2 and both, order unchanged => the rgb transposition was never a sched.c decision. - Cold-start economics complete: round 1 = decode + exact length + exact frame + 99.06%; round 2 = the last 45, and cheaper. Budget TWO passes at this size. 5th source copy-paste artefact found. |
||
|
Drew T
|
a1f1a948af |
feat(phase-29): h_norm-remappable pool — +4,919 ins banked, no cracking, no agent
- BANKED (each whole-binary byte-gated; make check-all -> 140 passed, 0 failed of 140): func_80130D48 ×4 (1,064) · func_8018F3E4 (478) · func_8018B3D0 (478) · 13 × 223-ins siblings of func_8017E6D8 (2,899). distinct-code 3,833,224 -> 3,838,143 = 68.0% -> 68.1%. - TWO OF MY OWN COUNTS COLLAPSED UNDER SCRUTINY BEFORE I ACTED ON EITHER (R14/R35): "func_8017CA80's family = 102 unmatched" was really 13 -- my count tallied family members whose NAME appears as a stub anywhere in the fleet, not instances actually unmatched (a semantics error, not arithmetic). "56,267 ins remappable" was really 8,114 -- 86% was the known -O0 / deferred set (the func_80144B9C whale, the func_8013C414 cluster). I nearly recommended a target on the first number. - THE §77 CARRY GAP IS THE DOMINANT COST OF MECHANICAL REMAP: 23 of 27 first-pass CC1-FAILs. NEW .run/giants/s19_remap_tu.py sources the preamble from the exemplar's OVERLAY TU (the block between the previous top-level `}` and the def), applies family_remap's own substitution map, and adds the two includes match_one never adds -> 21 drafts went 0 MATCH -> 14 MATCH. The 13 223-ins siblings share ONE exemplar, so a single preamble fix cleared all 13. - USEFUL ASYMMETRY: func_8018F3E4/func_8018B3D0 FAILED match_one but BANKED in the whole-binary gate -- the real TU supplies decls the standalone compile lacks. A match_one CC1 FAIL is not a reason to skip the real gate on a remapped sibling. - RESIDUAL 3,195 ins, causes NAMED not guessed: func_8017D5C0 (952) matches standalone, gate reports `conflicting types for memcpy` = the §58 red-herring (a warning from an unrelated TU position; SESSION-14 hit the same label and the true cause needed a hand-splice + real cc1 stderr). func_80166994 ×3 + func_8016A290 ×4 still CC1-FAIL after the TU carry. - FULL R22 DEFERRED DELIBERATELY: make clean wipes asm/, which the concurrently-running BF14 agent reads on every probe. This batch changed only src/*.c (no config), so check-all is sound; the clean R22 must still run once the agent finishes. |
||
|
Drew T
|
f9a2de3edd |
feat(phase-29): BEHEMOTH #2 func_8017D960 CRACKED (1806 -> 0) + its 5-member family = 16,690 ins
- CRACKED pin-free at xHigh (Opus 5 agent), then ALL FOUR family siblings banked via §40 remap, each MATCHING FIRST TRY: ov_SC03_090 (the crack) · ov_SC03_089 · ov_SC03_104 · func_8017E778 @ ov_SC03_091 · func_8017CD9C @ ov_SC03_102 (the last two cross-address). Verified independently before believing the report (R14): match_one MATCH (3338 ins), then harvest_verify BYTE-IDENTICAL on all five binaries, then R22 clean-fleet 140/140. - METRICS: distinct-code 3,816,534 -> 3,833,224 (+16,690) = 67.7% -> 68.0%, the first percentage-point movement in that metric all session. instr-weighted 80.3% -> 80.5%. Session distinct-code total +19,712 ins, ALL from the three behemoths; propagation gave +0. - MY BRIEF WAS WRONG IN AN INSTRUCTIVE WAY -> §78. I said a negative length drift means "missing instructions". The 4 absent instructions were 4 emit tails × 1 nop -- delay slots the target could NOT FILL because the register it wanted was still live. otp at function scope has 4 deaths -> fails local-alloc.c:472 -> global allocno in $a2 -> via global.c:668-671 pushes tp off $a1 -> the 0xFFFFFF mask is free early -> maspsx hoists it into the slot. Declaring otp PER EMIT ARM fixed the whole drift in one edit (3334->3338, 1806->333). SECOND TIME IN ONE SESSION a "structural"-looking residual was an allocno-class choice (the first: F510's "scheduling" transposition, §76). A nop present in the target but absent from the draft is usually a register-liveness fact, not missing code. - TWO MORE REUSABLE FINDINGS (§78): gcc-2.7.2 fold NEVER leaves a literal first in an `|` chain (7 parenthesisations, all reassociate) -- so `or acc, var, K` first in the target means K was a VARIABLE in the source, an asm->source read that retires a whole sweep family. And "make it a variable" has TWO separable effects (fold-opacity vs a new allocno): a fresh short-lived local fixes structure and wrecks allocation (690 mismatched, damage ~300 ins away); reuse a busy one. - ECONOMICS: 9 levers, each necessary by drop-one ablation, and 5 of the 9 were read straight off the MATCHED relatives func_8017F510 (cracked earlier today) and func_8017CA80. Crack the smaller family member first -- it is a lever library for the larger one. - NEW TOOL .run/giants/s19_remap_family.py: family_remap + the §77 preamble carry in one step (reproduces the exemplar's FULL file-scope preamble with the tool's own substitution map applied). Took the 4 siblings from "4 rounds of CC1 FAIL each" to MATCH first try, ×4. |
||
|
Drew T
|
130b9407b1 |
feat(phase-29): func_8017F5B4 (1,511 ins) banked MECHANICALLY off behemoth #3 — ~0 agent tokens
- func_8017F5B4 @ ov_SC02_031 shares behemoth #3's h_norm AND h_seq (96fe0455c344 / 9a6bd2b91fd4) with a different h_exact = the same instruction stream differing only in masked reloc fields. The §40 family_remap case exactly, so NO agent was spent: family_remap --addr 0x8017F510 --from ov_SC03_006 --to ov_SC02_031 --to-addr 0x8017F5B4 substituted 52 per-overlay symbols correctly on the FIRST invocation. - match_one -> MATCH (1511 ins); harvest_verify --binary ov_SC02_031 -> BYTE-IDENTICAL; R22 clean-fleet 140 passed, 0 failed of 140. - DISTINCT-CODE 3,815,023 -> 3,816,534 (+1,511). With behemoth #3 that is +3,022 distinct-code instructions from the two behemoths, versus +0 from every propagation win this session. - ALL the work was PREAMBLE, none of it the body -> cookbook §77. Four CC1 FAIL rounds, each naming one construct the extractor drops: (1) multi-line `typedef struct {...} PolyGT4;` -- family_remap's backward walk accepts a line only if it STARTS with extern/typedef/comment, and a multi-line typedef ENDS with `} PolyGT4;`, so the walk halts there AND LOSES EVERYTHING ABOVE IT; (2) hence the file-scope extern block above the #define BOXTEST/ATTEN block; (3) the exemplar's own #include lines (PolyFT3/PolyFT4 live in engine_types.h). - THIRD CONFIRMATION TODAY OF ONE DEFECT CLASS, NOW ACROSS TWO TOOLS. §75b found dedup_propagate dropping a file-scope #define and PREDICTED the generalisation; family_remap then dropped a typedef, an extern block, and the includes. RULE (§77): after any mechanical template/propagate step, diff the exemplar's full file-scope preamble against what the tool emitted. A CC1 FAIL on a remapped sibling is a PREAMBLE report until proven otherwise -- it says nothing about whether the remap was right. - Artifact preserved: .run/giants/s19_func_8017F5B4_remap.c |
||
|
Drew T
|
3ffff74f5b |
feat(phase-29): BEHEMOTH #3 func_8017F510 CRACKED — 97 -> MATCH (1,511 ins), pin-free
- BANKED into ov_SC03_006 through the whole-binary byte-gate (G3/P9); R22 clean-fleet 140 passed, 0 failed of 140. Verified independently before believing the agent's report (R14): match_one -> MATCH (1511 ins), then harvest_verify -> BYTE-IDENTICAL. - DISTINCT-CODE 3,813,512 -> 3,815,023 = +1,511, EXACTLY the function's instruction count and the ONLY distinct-code movement of the entire session. Reach is ×1 by sig, no propagation -- which is precisely why it moves the metric propagation cannot touch. instr 80.3%, fn 89.18%. - EFFORT EXPERIMENT (Drew): behemoths #1-#3 were worked at High; this is the first at xHigh (Opus 5 agent). It closed a residual the lower tier had fully localized but could not move, and that 3,663 permuter candidates at base 97 had failed to improve by even 1. - MECHANISM -> cookbook §76: the allocno CLASS (local vs global) is the dominant regalloc lever and C reaches it ONLY through declaration scope and variable reuse -- unreachable by statement order, expression shape, pins, or random search, which is exactly why the permuter was spent. (1) `otp` per emit ARM: 4 deaths -> four 1-death local pseudos (local-alloc.c:472); its second-order effect via global.c:668-671 (local placements re-marked as HARD regs for global-alloc) had made the target's otp=$a0 STRUCTURALLY IMPOSSIBLE, visible as hard-reg 4 in the `;; N conflicts:` tail of the .greg dump. (2) `cb` reused as the unlit rgbc temp: refs 27->39 lifts its global.c:594 allocno_compare priority past `tp`, flipping the 3-colouring -> 97 -> 10. (3) one shared `rgbw` temp -> 10 -> 2. (4) mny-before-my + one zero-byte __asm__ at the head of the tri cull block -> MATCH. - THREE CORRECTIONS TO MY OWN BRIEF, all byte-evidenced: residual B was never a scheduling residual (it fell out free with lever 2 -- a register grant seen as a schedule diff); residual A is RTL EXPANSION order, proven with -fno-schedule-insns AND -fno-schedule-insns2 (source order survives both -- that attribution primitive is the reusable bit); residual C had no single c3 seed (c3 has no lever of its own, it moves only when cb out-ranks tp). - FIXED a latent SHARED-HEADER defect, pre-existing and unrelated to the draft: src/shared/engine_types.h closed its include guard at line 1174 of 1259, leaving 11 typedefs / 85 lines OUTSIDE the guard since the crack-wave lift. A TU including it twice re-declares them and gcc-2.7.2 rejects a repeated typedef even when identical -> `conflicting types for Blk16_956C`. Guard moved to EOF; byte-neutral. - ARTIFACTS TRACKED (R20): .run/giants/s19_func_8017F510_b4.c (130-line dossier) + s19_f510_report.md, whose ~50-row do-not-re-buy table is arguably worth more than the match, + the s19_* analysis tooling. - STRETCH, MEASURED: func_8017F5B4 (1,511 ins, ov_SC02_031) has a DIFFERENT h_exact -- not a dedup sibling, a family_remap TEMPLATE candidate off the b4 source. |
||
|
Drew T
|
6e9cbda926 |
feat(phase-29): func_80174CB0 ×3 -> ×135 (§75c pair); the census predicted the residual exactly
- dedup_extend banked 132 / 179 planned across 135 binaries: func_80174CB0 VERIFIED in 132, FAILED in exactly 3. 123 ins × 132 = 16,236 ins. - THE PREDICTION HELD TO THE OVERLAY. The blocker breakdown across the original 134-binary sweep was 131 class-B (func_8012F14C arity split) / 3 class-A (func_80012ABC, census 73 s32 vs 7 s16). Fixing class B alone banked 132 and left 3 -- precisely the class-A set. A diagnosis that predicts WHICH members will still fail, and is right, is much stronger evidence than one that explains failures after the fact; same shape as §75b predicting that the 3 stuck members would be exactly the 3 files carrying the __volatile__ spelling of SHB. - FLEET: instr-weighted 80.2% -> 80.3% (10,539,723 -> 10,555,959); fn-count 89.14% -> 89.18%; distinct-code 67.7% UNCHANGED (propagation moves coverage, not distinct-RE -- fresh cracks are the only lever there). dedup 1886 validated / 0 failed, C1 coverage 239,604/239,604. 0 NON_MATCHING (G4). - R22 clean-fleet: make clean && extract-all && check-all -> 140 passed, 0 failed of 140. - cookbook §75c committed with this batch. The 3 residual overlays need the 7 `s16` func_80012ABC decls normalized -- worth 3 overlays only, so do it only if trivially cheap. |
||
|
Drew T
|
398e653c92 |
fix(phase-29): §75a class-B remedy is the FULL §17a-1 pair — decl AND call-site cast
- The K&R-decl-only probe was HALF the fix, and cc1 said so exactly:
ov_SC01_001_jr_801734BC.c:2616: too many arguments to function `func_8012F14C'
`()` dissolves the DECLARATION conflict (the failure class moved PLUMBING -> CC1-FAIL), but the
composite type after the TU's earlier `void func_8012F14C(s32);` prototype is still 1-param, so
the macro's 3-arg CALL is a hard error. Reproduced by hand-splicing the macro into
ov_SC01_001 and reading real cc1 stderr rather than trusting the classifier's `Error 33`.
- FIX = the other half of §17a-1 (what cast_call_sites.py does, and what §20 established): cast
the call site so it does not depend on the TU's prototype at all —
((void (*)(s32, s32, s32))func_8012F14C)((s32)&mtx, (s32)&vec, (s32)&out)
gcc-2.7.2 folds a cast of a KNOWN function symbol back to a direct `jal`, so the bytes are
unchanged. Decl stays `()` so it cannot conflict in either declaration order.
- BYTE-GATED on the full existing radius: ov_SC07_006 7ca772be · 007 b3b95547 · 011 9885af74 —
all BYTE-IDENTICAL.
- LESSON for §75a class B: the remedy is the PAIR, never the decl alone. A decl-only change moves
the error from `conflicting types` to `too many arguments` and looks like a new wall.
|
||
|
Drew T
|
8f63c1a8e0 |
probe(phase-29): §75a class-B — K&R () for the carried func_8012F14C decl (func_80174CB0)
- The class-B arity split (1944 `(s32)` vs 968 `(s32,s32,s32)`) blocked func_80174CB0 in 131 of 134 overlays: the macro carried the 3-param prototype, the failing TU declares the 1-param one FIRST (ov_SC01_001: TU@328 vs instantiation@2616), so cc1 sees two prototypes of different arity and rejects. - Per cdecl.compatible's MEASURED gcc-2.7.2 behaviour a no-prototype `()` is accepted in BOTH orders here: prototype-first + ()-second always; ()-first + prototype-second when no parameter is altered by default promotion -- and all three args are s32, which does not promote. So one K&R decl should satisfy both populations regardless of where each TU declares it. - Call site UNCHANGED (`func_8012F14C((s32)&mtx, (s32)&vec, (s32)&out)`): with a K&R decl the args pass under default promotions, and s32 args are unaffected -> same codegen. - BYTE-GATED on the full existing radius before extending: ov_SC07_006 7ca772be · 007 b3b95547 · 011 9885af74 -- all BYTE-IDENTICAL. The extend result is the real test of the prediction. |
||
|
Drew T
|
3bbfe21596 |
feat(phase-29): func_80165CA0 ×3 -> ×135 via ENGINE_SHB; +22 fns ×1; §75b (the carried-#define gap)
- dedup_extend banked 157 / 478 planned across 135 binaries: func_80165CA0 (99 ins) ×135 (~+0.10pp) + 22 other functions ×1 picked up in the 3 overlays the first sweep excluded. - FLEET: instr-weighted 80.1% -> 80.2% (10,525,534 -> 10,539,723, +14,189 ins); fn-count 89.09% -> 89.14%; distinct-code 67.7% (unchanged — propagation moves coverage, not distinct-RE). dedup 1886 validated / 0 failed, C1 coverage 239,472/239,472. 0 NON_MATCHING (G4). - R22 clean-fleet: make clean && extract-all && check-all -> 140 passed, 0 failed of 140. - §75b — extraction lifts `extern`s but NOT file-scope `#define`s, so a body matched with a macro in its preamble compiles only where that overlay's define is in scope ABOVE the splice point. Signature is a LINK error (`undefined reference`), never `conflicting types`: an unexpanded SHB(x) parses as a call to an undeclared function. The diagnosis PREDICTED the membership — the 3 stuck members are exactly the 3 files carrying the __volatile__ spelling of SHB, i.e. the function's own preamble still sitting above its own instantiation. - R14/R35 IN ACTION: the full-sweep census REVERSED the ranking I had just committed. I put the class-A normalization first at "~+0.13pp if it reaches ×138"; measured across all 134 it is worth 3 overlays (func_80012ABC 3, func_8012F14C 131). The cheap win was the one I ranked third. §75a's "collect across the whole sweep before scoping" earned itself immediately. - NEXT (specified, not guessed): func_80174CB0 is class B on func_8012F14C (1944 `(s32)` vs 968 `(s32,s32,s32)`). The macro carries the 3-param prototype; the failing TU declares the 1-param one FIRST (ov_SC01_001: TU@328 vs instantiation@2616) -> two prototypes, different arity -> reject. Per cdecl.compatible's MEASURED rule a K&R `extern void func_8012F14C();` is accepted BOTH ways round here (prototype-first + `()`-second always; `()`-first + prototype-second when no param default-promotes, and s32 does not) -> it should satisfy both populations in either order. One-line probe on the carried decl, byte-gate the 3 members, then extend. |
||
|
Drew T
|
364ddd7055 |
fix(phase-29): ENGINE_SHB — the carried-#define gap that capped func_80165CA0 at ×3
- CAUSE (measured, not guessed): the 132 extend failures were `undefined reference to 'SHB'` --
a LINK error, not a type conflict. SHB is not a symbol; it is a file-scope
`#define SHB(x) __asm__(...)` sign-extension barrier. A body's preamble can carry `#define`s
as well as `extern`s, but extraction lifts only the externs -- so the `#define` was left behind
in the source overlay. In ov_SC01_077 it sits literally BETWEEN the two carried externs and the
instantiation:
extern s32 D_8011D030;
extern s32 D_80126728;
#define SHB(x) __asm__ __volatile__("" : "=r"(x) : "0"(x))
DEFINE_func_80165CA0()
The other 132 overlays DO define SHB -- ~300 lines further down the file (stub @4462 vs
#define @4781 in ov_SC01_001), i.e. BELOW the splice point, so the preprocessor never expands
it and cc1 emits a call to an undeclared `SHB`. Pure ORDERING; nothing was missing.
- Also explains why the 3 current members are EXACTLY the 3 files carrying the __volatile__ SHB
spelling: that define is the function's own preamble, still sitting above its instantiation.
- FIX: engine_core.h owns the barrier as ENGINE_SHB (distinct name, so the overlays' own SHB --
which exists in BOTH a volatile and a non-volatile spelling -- can never collide), and
DEFINE_func_80165CA0's 7 uses now call it. Volatile form: what the 3 banked members compile
with today. The body is now self-contained wherever it is instantiated.
- BYTE-GATED the full existing blast radius: ov_SC01_077 d19c9580 · ov_SC01_000 9052dc0e ·
ov_SC07_006 7ca772be -- all BYTE-IDENTICAL.
- This is the dedup_propagate counterpart of Phase-27's family_remap._carry_macros (§75b).
|
||
|
Drew T
|
39127535da |
feat(phase-29): func_8014F3E8 ×4 -> ×138 via dedup_extend; §75a enumerates the exclusion classes
- THE NORMALIZATION PAID: one `dedup_extend --binaries <the 134 excluded>` banked 134/400
planned -- func_8014F3E8 VERIFIED in ALL 134 -> ×138 total (+4,288 ins), no drafting at all.
A 4-overlay island became full fleet reach because the carried extern finally agreed.
- FLEET: instr-weighted 80.0% -> 80.1% (10,509,526 -> 10,525,534 = +16,008 ins, exactly the
projected 84×138 + 32×138); fn-count 89.02% -> 89.09%; distinct-code 67.7% (unchanged, as
expected -- propagation moves coverage, not distinct-RE). dedup 1884 -> 1886 validated / 0
failed, C1 coverage 239,315/239,315. 0 NON_MATCHING (G4).
- R22 clean-fleet: make clean && extract-all && check-all -> 140 passed, 0 failed of 140.
- §75a — "PROPAGATION-CAPPED" IS AT LEAST THREE CLASSES, and the classifier names which:
A minority spelling `conflicting types` + a lopsided census (1710 vs 4) -> normalize, cheap
B genuine arity split same message, TWO real populations (func_8012F14C: 1944 `(s32)` vs
968 `(s32,s32,s32)`) -> the §29 loose-typing wall; a K&R `()` MAY satisfy
both but is order-dependent -> PROBE, do not normalize on a guess
C missing extern `undefined reference to 'SHB'` -- a LINK error, unrelated to types
The discriminator is one grep (census the symbol cc1 named) and it decides the remedy.
- R14 self-correction recorded: I predicted func_80174CB0 was "the identical class". It is class
A in KIND but on DIFFERENT symbols, and different ones per overlay (func_80012ABC at
ov_SC01_000 where the minority is on the TARGET side; func_8012F14C at ov_SC01_001 = class B).
One member's error names one blocker, not the blocker set -- collect the classifier's line
across the whole sweep before scoping a fix.
- func_80174CB0 (×3) and func_80165CA0 stay capped, each now with a named cause and a named next
probe -- not a wall verdict.
|
||
|
Drew T
|
2fcb8de6bf |
fix(phase-29): normalize func_8014F468 to the fleet-canonical s32 (unblocks the ×138 reach) + §75
- THE PROPAGATION CAP WAS A MINORITY-SPELLING SOURCE OVERLAY, byte-censused:
extern s32 func_8014F468(void); 1710 | s32 func_8014F468(void) 134 <- fleet canon
extern void func_8014F468(void); 20 | void func_8014F468(void) 4 <- the outlier
and ALL 4 `void` definitions are ov_SC07_{006,007,010,011} — the overlay the F3E8 body was
banked from. dedup_propagate carries the source overlay's file-scope externs into the shared
macro VERBATIM, so the macro inherited `extern void` and the 134 overlays that define the
symbol `s32` rejected it. Propagation landed on exactly that 4-overlay island.
- The exclusion message ("byte-diverge / irreconcilable") is provably the wrong cause: members
are selected BY h_exact, so all 138 are byte-identical by construction. It is a COMPILE
conflict, never a byte one (same defect family as §68's mislabel, same tool).
- NORMALIZED the 24 minority occurrences to s32 (4 definitions + 19 overlay externs + the 1
line in the freshly-authored macro). func_8014F468 is a pure inline-asm $sp-switch trampoline
— no C-level value flow — and 134 overlays already PROVED s32 is byte-correct for the
identical function. Fleet is now uniform: 1730 extern s32 + 138 s32 defs, 0 `void`.
- BYTE-GATED the complete blast radius (the 4 instantiators of DEFINE_func_8014F3E8):
ov_SC07_006 7ca772be · 007 b3b95547 · 010 d7b5875d · 011 9885af74 — all BYTE-IDENTICAL.
- cookbook §75: census the carried extern before believing an exclusion message; prefer a
majority-spelling source overlay; always pass --recover; after normalizing use dedup_extend
(the body is already a macro) not dedup_propagate --addr.
|
||
|
Drew T
|
10ea5ff653 |
feat(phase-29): propagate the widen batch — func_8014D4C0 ×138; func_8014F3E8 ×4 (cause measured)
- func_8014D4C0 (84 ins) PROPAGATED ×138: all 138 overlays rebuilt byte-identical, group
E_func_8014D4C0 registered. 84×138 = 11,592 ins.
- func_8014F3E8 (32 ins) propagated ×4 only (the ov_SC07_{006,007,010,011} island), 134
overlays excluded one at a time.
- TWO FINDINGS, both measured:
(1) THE FIRST RUN'S "drop" WAS A FLAG OMISSION, NOT A WALL. Without --recover,
dedup_propagate takes the historical all-or-nothing path on the first culprit overlay,
so ONE divergent member cost the whole group (×0). With --recover, Part A excludes just
the culprit -> ×4 instead of dropped. Always pass --recover on a targeted --addr run.
(2) THE EXCLUSION CAUSE IS A MINORITY-SPELLING SOURCE OVERLAY, not byte divergence. The
sigs prove all 138 members share ONE h_exact (2ccf344d), so nothing diverges in bytes.
The macro carries the source overlay's `extern void func_8014F468(void);` while the
fleet census is 1,710 `extern s32` + 134 `s32` definitions vs 20 `extern void` + 4
`void` definitions -- and all 4 `void` definitions are ov_SC07_{006,007,010,011}, i.e.
the source overlay I banked from is the OUTLIER. The macro inherited the minority
spelling and silently capped its own reach at that island.
- => the fix is NORMALIZATION (24 occurrences), not a reconciliation engine; the follow-up
commit flips the SC07 minority to the fleet-canonical s32 and re-propagates.
- R22 clean-fleet: make clean && extract-all && check-all -> 140 passed, 0 failed of 140.
|
||
|
Drew T
|
1c0d29d91d |
feat(phase-29): §30#2 widen batch — func_8014F3E8 + func_8014D4C0 banked; §73 (the two axes)
- FLEET WIDEN (T2, one edit): extern void -> extern s32 for func_8014F3E8 + func_8014D4C0 across src/** (16 decls in engine_core.h + 5,079 in 3,459 overlay .c; 0 `extern void` left, 0 pre-existing `extern s32`). Scope re-verified against the tree first (R14/R35): the SESSION-18 counts reproduce exactly and no decl exists outside the `extern void <name>` shape in any .c/.h under src/. - BYTE-NEUTRALITY OF THE WIDEN ISOLATED FIRST: ov_SC07_006 7ca772be + ov_SC01_000 9052dc0e BYTE-IDENTICAL before splicing any draft (ov_SC01_000 chosen because it instantiates the two return-CASTING macros — the only sites a decl's return type could touch codegen). - BANKED into ov_SC07_006 (both ×1, both reach ×138 by sig: single h_exact across 138/138): func_8014F3E8 (32 ins) on gate 1; func_8014D4C0 (84 ins) on gate 2. - FINDING -> cookbook §73: the widen fixed only HALF the conflict. A def-side self-decl conflict has TWO independent axes — RETURN (fleet macro-widen, T2, R22-mandatory) and PARAMS (canonical param types + casts at each USE, T0, no fleet edit). func_8014D4C0 failed the first gate on the PARAM axis (canon `void*` vs draft `u16*`); the §17a-1 move applied to the def's own signature banked it with nothing outside the draft touched. Diagnose the axis before reaching for the expensive fix. - R22 clean-fleet: make clean && extract-all && check-all -> 140 passed, 0 failed of 140. make report: dedup 1884 validated / 0 failed, C1 coverage 239039/239039, 0 NON_MATCHING (G4). Fleet 80.0% instr / 67.7% distinct / 89.02% fn-count (the ×138 propagation is the value). |
||
|
Drew T
|
ba35785ec4 |
feat(phase-29): bank func_801777BC (59 ins) x138 — the giv-init base-register lever (§70)
- MATCH (59 ins), real-TU verified by the agent before handing back (cc1 rc=0, 59/59, 0 diffs). - Propagated x138 with ZERO exclusions -> confirms the ×3 cap on func_80174CB0 was purely the carried-extern collision: a body with no externs propagates clean. - R22 clean-fleet 140/140, 0 failed. dedup-check 1884 validated / 0 failed, C1 coverage complete. - FLEET CROSSES 80.0% instr-weighted (10,509,526 / 13,141,652); fn-count 89.02%; distinct 67.7%. - THE LEVER (cookbook §70): residual was ONE instruction, addiu $t0,$t1,0xC vs $t0,$a0,0xC -- a giv based on a copy of the param. Reading gcc-2.7.2 loop.c/cse.c proved the natural form can never emit the target: cse.c:make_regs_eqv makes the copy canonical (it out-lives a0) and loop.c:update_reg_last_use won't extend a0's last-use (giv-init UID >= max_uid_for_loop). Fix: walk the PARAMETER itself, so record_initial sees the biv init as hard reg (reg:SI 4), valid_initial_value_p accepts it (precondition: no calls), and emit_iv_add_mult bases the giv on $a0 -- yielding both required instructions free. - META: this compiler-source reasoning was done by an ORDINARY Opus 5 drafting agent, unprompted -- the tier Phase 23 reserved for Fable5. One data point, recorded as such; the cheap action is to give routine drafting agents the gcc source path. |