BFM-decomp

mirror/BFM-decomp

Fork 0

mirror of https://github.com/Druthulu/BFM-decomp synced 2026-09-27 22:45:39 -04:00

Commit Graph

Author	SHA1	Message	Date
Drew T	56e2d808ab	feat(phase-29): T56 — wire the tu-scope lever into family_sweep; func_80144090 0/136 -> 136/136 T55's two-part next step as one job. +20,944 instructions banked. 1. THE LEVER WAS UNREACHABLE FROM THE PATH MOST FAMILIES USE (cookbook §107) §103 was wired into jtbl_family_bank only (T53), and that tool runs for has_mid_jr families. Everything else sweeps through family_sweep, which gates via PLAIN harvest_verify by design — so the lever existed, was byte-proven, and most families could not reach it. The symptom was indistinguishable from a compiler wall: func_80144090 swept 0/136 with `conflicting types for D_800A651C`. Why it does not violate the plain-harvest_verify rule: that rule exists because gate_stage's transforms PERTURB A CORRECT DRAFT (§19/T3). The tu-scope never touches the draft — it moves a DECLARATION IN THE TARGET TU. The test is not "is it a transform" but "does it change the draft?" Reused the existing undo instead of inventing one: family_sweep already snapshots TUs it edits at staging time (--normalize-self-decls) and reverts on a final MISMATCH (not byte-neutral) AND on a zero-bank group (§61 undo law — no dead diff). The tu-scope shares that dict and inherits both backstops; renamed nsd_snapshots -> tu_snapshots. Default ON with --no-tu-scope to A/B it (the T24 --allow-pins precedent): byte-neutral by construction, a no-op when nothing collides, auto-reverted when it buys nothing. 2. THE DUPLICATE-DECL REFUSAL RELAXED — AND IT DID NOT MATTER scope_tu_externs refused N>1 file-scope decls as "ambiguous"; duplicate-IDENTICAL externs are legal C, so N identical decls are one decl written N times. Now compares whitespace-collapsed forms and refuses only on genuine disagreement. MEASURED, and my hypothesis was WRONG: D_800B9A02 is 3 decls in 2 DIFFERENT forms, so it was correctly refused all along — the family banked 136/136 without it. RESULT: func_80144090 0/136 -> 136/136, 0 failed, with NO change to any draft. GATES: R22 clean-fleet 140 passed, 0 failed of 140. tools-health OK (corpus 0 PHANTOM + 0 TRUNCATED, cdecl, audit-binaries, report/lint/dedup 1886/0). 0 NON_MATCHING (G4). METRICS (reconciled against make report): instr-weighted 85.7% -> 85.8% 11258063 -> 11279007 = +20,944 ins fn-count 90.65% -> 90.69% 320656 -> 320792 = +136 distinct-code 76.4% -> 76.4% +0 (67812 unique, UNCHANGED) FLAGGING the third row rather than explaining it away: 136 banked functions moved distinct-code by ZERO, where T52's 132 moved it by +125, and both families are classed PURE. I do not have a verified cause and will not invent one — either a real property of this family or a gap in the metric. Worth one probe before that number is quoted again.	2026-07-28 20:15:11 -06:00
Drew T	bcd44badc9	fix(phase-29): T55 — frontier re-mapped; 2 families swept, 0 banked, both blockers diagnosed to the line Honest result: NO YIELD. What it produced is a re-measured frontier, a real fix to my own T53 work, and both failures diagnosed rather than left as "0/N". FRONTIER RE-MAPPED (T52's +132 moved it): family_hseq -> 2,647 target families, 513 substantial, 64 with a banked exemplar AND live stubs. Caveat recorded: the top two by byte-weight (0x8013c414 180KB, 0x8013c0f8 84KB) are -O0, and _o0 families are already measured at ~1/137 — do not be drawn by their weight. FAMILY 1 func_8014032C (183 ins x 136 ~ 25,000 ins): sample 0/8, last_err empty. Read one sibling's real gate result (§53/§59) past the -j16 interleave and the §58 memcpy red herring — TWO causes: (1) conflicting types for D_80115128 — the T48/T51 class, which tu-scoped should have caught; (2) jtbl_rodata_pads "more rodata .align than pad specs — table-count drift vs the carve", a DISTINCT class jtbl_family_bank's own comment documents as NOT isolate-fixable (§91 --like role trap). After fixing (1): still 0/8. Cause 2 is the live blocker — carve work, not decl work. NOT ground further; it is a documented wall. THE T53 DEFECT, FOUND AND FIXED: contested() scanned only the draft's BLOCK-scope externs, because T51's motivating family had them hand-written in the body. But gather_externs carries decls in at FILE scope, and those are exactly the ones scope_data_externs.fix DROPS when the TU already declares the symbol — its give-up branch, the fatal case the lever exists for. Measured: scope_data_fix dropped 3 symbols while contested() returned []. So the stage never fired on its own class. Now scope-independent; regression-checked against T51's case using the pre-T51 TU from git (old == new, added []), and it now finds D_80115128 on the T55 target. FAMILY 2 func_80144090 (154 ins x 136 ~ 21,000 ins), chosen because has_mid_jr=False avoids the carve: 0/136. Diagnosed: conflicting types for D_800A651C (2210 vs 379) — the SAME class. family_sweep gates via PLAIN harvest_verify by design, so it never sees the tu-scoped lever, which lives only in jtbl_family_bank. Probed: the lever would move D_800A651C + D_800AF648 (deletion-only) and REFUSES D_800B9A02 as "3 file-scope decls above (ambiguous)" — an over-conservative refusal, since duplicate-IDENTICAL externs are legal C. THE FINDING: the same decl-scope collision class gates the frontier's mechanical families — it cost T52's family 133 of 137 siblings, and it blocks both families probed here. The lever exists and is byte-proven; it is not reachable from the sweep path most families use. No src/ or config/ change: no bank, no metric move. Tree verified clean after every probe.	2026-07-28 19:56:19 -06:00
Drew T	a524142eb5	feat(phase-29): T51 — the fleet-wide decl-scoping tool; func_80135260's 132 siblings unblocked Item 1 off the SESSION-23 list. T48 proved the lever by hand on the exemplar, T50 located the same blocker in every sibling; this builds the tool, measures the population, applies it fleet-wide, and gates it. It BANKS NOTHING — it removes the blocker. The sweep is the next task. MEASURED BEFORE BUILDING (R35). The blocker census over all 132 still-stubbed siblings is perfectly uniform: 132/132 carry it, 3 contested symbols each, EXACTLY ONE file-scope decl statement per (TU, sym), ZERO file-scope references below the decl (so the deletion is always safe), 660 block-scope re-declarations needed. THE TOOL: tools/scope_tu_externs.py — the TU-side complement of scope_data_externs.py (§8d). §8d fixes the incoming DRAFT and has a give-up branch that DROPS the draft's own decl when the TU already declares the symbol at file scope. Right when the types agree; fatal when the byte-true draft needs a different one — which is exactly how 132 byte-true siblings gate-failed wearing a codegen wall's costume. This moves the TU's OWN file-scope decl down into every later function that references the symbol and lacks its own block-scope decl, then deletes the file-scope line. FILE(u8 D_x) ... then BLOCK(u16 D_x) below it -> conflicting types (the 132 failures) (no file-scope decl) ... BLOCK(u8) ... BLOCK(u16 ) -> builds; each fn owns its own view - contested set DERIVED, never hand-listed (R33): the remapped draft's block-scope D_ externs intersected with the TU's file-scope decls above the splice point; --family does it per sibling - built on cdecl.split_statements/_mask (R33), not a 7th regex: depth-0 spans (a fn definition flushes at its closing '}' — a column-0 test is NOT a file-scope test, m2c emits goto labels at column 0 inside bodies) + length-preserving comment/string masking. That masking is what kills the comment-scanning false-positive class still open as item 3. - REFUSES LOUDLY, never skips silently (R32): >1 file-scope decl above the splice point; a file-scope statement below the decl referencing the symbol; an unlocatable body brace - coverage asserted as a DELTA (R32): file-scope -1, block-scope +len(consumers). An absolute "a block-scope decl exists" check would have passed VACUOUSLY — these TUs already carry ~18 legitimate block-scope decls of the same symbols VERIFIED IN TWO STEPS (T48's structure — why a 132-file edit was safe to make): 1. the move ALONE on ov_SC01_000 -> make build -> 9052dc0e BYTE-IDENTICAL, then reverted 2. fleet-wide -> R22 clean-fleet (make clean && extract-all && check-all) -> 140 passed, 0 failed of 140; make tools-health OK (corpus 0 PHANTOM + 0 TRUNCATED, cdecl, audit-binaries, report/lint/dedup 1886/0). Metrics UNCHANGED at 85.5% instr / 76.1% distinct / 90.62% fn-count — the correct result for a declaration-only change. The diff is uniform to the line: all 132 files +11/-3. A second --family run reports 132 nothing-to-do, 0 refused (idempotent). Deliberately NOT done: wiring this as an automatic jtbl_family_bank stage. That waits until the sweep measures the payoff — folding an unproven pre-pass into the gate is the same unmeasured premise this phase keeps catching. Also preserves .run/near6/g5260_a.c (the T48 raw crack body, allowlisted) — the sweep may need it for --raw. cookbook §103 + SETUP tool-inventory row (R21).	2026-07-28 16:44:46 -06:00

Author

SHA1

Message

Date

Drew T

56e2d808ab

feat(phase-29): T56 — wire the tu-scope lever into family_sweep; func_80144090 0/136 -> 136/136

T55's two-part next step as one job. +20,944 instructions banked.

1. THE LEVER WAS UNREACHABLE FROM THE PATH MOST FAMILIES USE (cookbook §107)
   §103 was wired into jtbl_family_bank only (T53), and that tool runs for has_mid_jr families.
   Everything else sweeps through family_sweep, which gates via PLAIN harvest_verify by design — so
   the lever existed, was byte-proven, and most families could not reach it. The symptom was
   indistinguishable from a compiler wall: func_80144090 swept 0/136 with `conflicting types for
   D_800A651C`.
   Why it does not violate the plain-harvest_verify rule: that rule exists because gate_stage's
   transforms PERTURB A CORRECT DRAFT (§19/T3). The tu-scope never touches the draft — it moves a
   DECLARATION IN THE TARGET TU. The test is not "is it a transform" but "does it change the draft?"
   Reused the existing undo instead of inventing one: family_sweep already snapshots TUs it edits at
   staging time (--normalize-self-decls) and reverts on a final MISMATCH (not byte-neutral) AND on a
   zero-bank group (§61 undo law — no dead diff). The tu-scope shares that dict and inherits both
   backstops; renamed nsd_snapshots -> tu_snapshots. Default ON with --no-tu-scope to A/B it (the T24
   --allow-pins precedent): byte-neutral by construction, a no-op when nothing collides, auto-reverted
   when it buys nothing.

2. THE DUPLICATE-DECL REFUSAL RELAXED — AND IT DID NOT MATTER
   scope_tu_externs refused N>1 file-scope decls as "ambiguous"; duplicate-IDENTICAL externs are legal
   C, so N identical decls are one decl written N times. Now compares whitespace-collapsed forms and
   refuses only on genuine disagreement. MEASURED, and my hypothesis was WRONG: D_800B9A02 is 3 decls
   in 2 DIFFERENT forms, so it was correctly refused all along — the family banked 136/136 without it.

RESULT: func_80144090 0/136 -> 136/136, 0 failed, with NO change to any draft.

GATES: R22 clean-fleet 140 passed, 0 failed of 140. tools-health OK (corpus 0 PHANTOM + 0 TRUNCATED,
cdecl, audit-binaries, report/lint/dedup 1886/0). 0 NON_MATCHING (G4).

METRICS (reconciled against make report):
  instr-weighted  85.7% -> 85.8%   11258063 -> 11279007 = +20,944 ins
  fn-count       90.65% -> 90.69%  320656 -> 320792 = +136
  distinct-code   76.4% -> 76.4%   +0 (67812 unique, UNCHANGED)
FLAGGING the third row rather than explaining it away: 136 banked functions moved distinct-code by
ZERO, where T52's 132 moved it by +125, and both families are classed PURE. I do not have a verified
cause and will not invent one — either a real property of this family or a gap in the metric. Worth
one probe before that number is quoted again.

2026-07-28 20:15:11 -06:00

Drew T

bcd44badc9

fix(phase-29): T55 — frontier re-mapped; 2 families swept, 0 banked, both blockers diagnosed to the line

Honest result: NO YIELD. What it produced is a re-measured frontier, a real fix to my own T53 work,
and both failures diagnosed rather than left as "0/N".

FRONTIER RE-MAPPED (T52's +132 moved it): family_hseq -> 2,647 target families, 513 substantial,
64 with a banked exemplar AND live stubs. Caveat recorded: the top two by byte-weight (0x8013c414
180KB, 0x8013c0f8 84KB) are -O0, and _o0 families are already measured at ~1/137 — do not be drawn
by their weight.

FAMILY 1 func_8014032C (183 ins x 136 ~ 25,000 ins): sample 0/8, last_err empty. Read one sibling's
real gate result (§53/§59) past the -j16 interleave and the §58 memcpy red herring — TWO causes:
  (1) conflicting types for D_80115128 — the T48/T51 class, which tu-scoped should have caught;
  (2) jtbl_rodata_pads "more rodata .align than pad specs — table-count drift vs the carve", a
      DISTINCT class jtbl_family_bank's own comment documents as NOT isolate-fixable (§91 --like
      role trap).
After fixing (1): still 0/8. Cause 2 is the live blocker — carve work, not decl work. NOT ground
further; it is a documented wall.

THE T53 DEFECT, FOUND AND FIXED: contested() scanned only the draft's BLOCK-scope externs, because
T51's motivating family had them hand-written in the body. But gather_externs carries decls in at
FILE scope, and those are exactly the ones scope_data_externs.fix DROPS when the TU already declares
the symbol — its give-up branch, the fatal case the lever exists for. Measured: scope_data_fix
dropped 3 symbols while contested() returned []. So the stage never fired on its own class. Now
scope-independent; regression-checked against T51's case using the pre-T51 TU from git (old ==
new, added []), and it now finds D_80115128 on the T55 target.

FAMILY 2 func_80144090 (154 ins x 136 ~ 21,000 ins), chosen because has_mid_jr=False avoids the
carve: 0/136. Diagnosed: conflicting types for D_800A651C (2210 vs 379) — the SAME class.
family_sweep gates via PLAIN harvest_verify by design, so it never sees the tu-scoped lever, which
lives only in jtbl_family_bank. Probed: the lever would move D_800A651C + D_800AF648 (deletion-only)
and REFUSES D_800B9A02 as "3 file-scope decls above (ambiguous)" — an over-conservative refusal,
since duplicate-IDENTICAL externs are legal C.

THE FINDING: the same decl-scope collision class gates the frontier's mechanical families — it cost
T52's family 133 of 137 siblings, and it blocks both families probed here. The lever exists and is
byte-proven; it is not reachable from the sweep path most families use.

No src/ or config/ change: no bank, no metric move. Tree verified clean after every probe.

2026-07-28 19:56:19 -06:00

Drew T

a524142eb5

feat(phase-29): T51 — the fleet-wide decl-scoping tool; func_80135260's 132 siblings unblocked

Item 1 off the SESSION-23 list. T48 proved the lever by hand on the exemplar, T50 located the same
blocker in every sibling; this builds the tool, measures the population, applies it fleet-wide, and
gates it. It BANKS NOTHING — it removes the blocker. The sweep is the next task.

MEASURED BEFORE BUILDING (R35). The blocker census over all 132 still-stubbed siblings is perfectly
uniform: 132/132 carry it, 3 contested symbols each, EXACTLY ONE file-scope decl statement per
(TU, sym), ZERO file-scope references below the decl (so the deletion is always safe), 660
block-scope re-declarations needed.

THE TOOL: tools/scope_tu_externs.py — the TU-side complement of scope_data_externs.py (§8d). §8d
fixes the incoming DRAFT and has a give-up branch that DROPS the draft's own decl when the TU already
declares the symbol at file scope. Right when the types agree; fatal when the byte-true draft needs a
different one — which is exactly how 132 byte-true siblings gate-failed wearing a codegen wall's
costume. This moves the TU's OWN file-scope decl down into every later function that references the
symbol and lacks its own block-scope decl, then deletes the file-scope line.

  FILE(u8 D_x) ... then BLOCK(u16 *D_x) below it  ->  conflicting types    (the 132 failures)
  (no file-scope decl) ... BLOCK(u8) ... BLOCK(u16 *)  ->  builds; each fn owns its own view

- contested set DERIVED, never hand-listed (R33): the remapped draft's block-scope D_ externs
  intersected with the TU's file-scope decls above the splice point; --family does it per sibling
- built on cdecl.split_statements/_mask (R33), not a 7th regex: depth-0 spans (a fn definition
  flushes at its closing '}' — a column-0 test is NOT a file-scope test, m2c emits goto labels at
  column 0 inside bodies) + length-preserving comment/string masking. That masking is what kills the
  comment-scanning false-positive class still open as item 3.
- REFUSES LOUDLY, never skips silently (R32): >1 file-scope decl above the splice point; a
  file-scope statement below the decl referencing the symbol; an unlocatable body brace
- coverage asserted as a DELTA (R32): file-scope -1, block-scope +len(consumers). An absolute
  "a block-scope decl exists" check would have passed VACUOUSLY — these TUs already carry ~18
  legitimate block-scope decls of the same symbols

VERIFIED IN TWO STEPS (T48's structure — why a 132-file edit was safe to make):
  1. the move ALONE on ov_SC01_000 -> make build -> 9052dc0e BYTE-IDENTICAL, then reverted
  2. fleet-wide -> R22 clean-fleet (make clean && extract-all && check-all) -> 140 passed, 0 failed
     of 140; make tools-health OK (corpus 0 PHANTOM + 0 TRUNCATED, cdecl, audit-binaries,
     report/lint/dedup 1886/0). Metrics UNCHANGED at 85.5% instr / 76.1% distinct / 90.62% fn-count
     — the correct result for a declaration-only change.

The diff is uniform to the line: all 132 files +11/-3. A second --family run reports 132
nothing-to-do, 0 refused (idempotent).

Deliberately NOT done: wiring this as an automatic jtbl_family_bank stage. That waits until the
sweep measures the payoff — folding an unproven pre-pass into the gate is the same unmeasured
premise this phase keeps catching.

Also preserves .run/near6/g5260_a.c (the T48 raw crack body, allowlisted) — the sweep may need it
for --raw.

cookbook §103 + SETUP tool-inventory row (R21).

2026-07-28 16:44:46 -06:00

3 Commits