release/v0.6.0 PR-C: eliminate_dead_stores — full backward liveness (-0.4% on calculator.wasm)

[avrabe]

Summary

Third PR of v0.6.0. Stacks on PR #95 (which stacks on PR #94). When PRs #94 and #95 land, this auto-retargets to main.

A new pass eliminate_dead_stores doing per-position dead-store elimination via backward liveness walking the structured wasm instruction tree. Path-sensitive complement to PR-B (eliminate_dead_locals): catches dead writes even when the target local IS read elsewhere in the function — by computing live-after sets correctly across all wasm structured control flow.

Pick #3 from the v0.6.0 wasm-opt-gap research agent's plan, taken in full (Option C).

Why "full liveness" not the simpler middle option

The user picked the most ambitious scope. The simpler "branch-aware adjacent-LocalSet" middle option would catch the obvious cases but miss the interesting one: write before an if where both arms overwrite. That requires computing live-before-if = live-in-then ∪ live-in-else. Once you do that properly, you've already done full structured-wasm liveness. So full liveness it is.

Algorithm

Backward walk over the instruction tree, propagating a LiveSet = BTreeSet<u32> at each position. A LocalSet/LocalTee is dead iff its target local is not in the live-after set.

Construct	Liveness rule
Block { body }	br N targets end-of-block ⇒ break-target liveness = live-after-block
If { then, else }	live-before-if = live-in-then ∪ live-in-else
Loop { body }	conservative v1: every local read anywhere in body is live throughout body and live just before loop. Avoids fixpoint iteration; sound but loses precision inside loops. Loop fixpoint is a follow-up (~100 LOC).
Br N	live ← label_stack[depth - 1 - N] (no fall-through)
BrIf N	live ∪= label_stack[...] (taken vs fall-through)
BrTable [...]	live ∪= ⋃ over all targets ∪ default
Return / Unreachable	live ← ∅ (no continuation)
Call / CallIndirect	no effect (don't access caller's locals)

The label stack mirrors wasm's nesting: outermost first, innermost last. br N counts from innermost-out, so target = stack[len - 1 - N].

Write-ID tracking (the trickiest engineering bit)

Identifying which LocalSet/LocalTee is dead across two walks (analyze backward, apply forward) needs a stable ID. I use a counter that:

• starts at total_writes (pre-counted in a forward sweep)
• DECREMENTS during backward analysis as writes are encountered
• the decremented value is the write's forward-walk-order ID

The apply phase walks forward, increments a parallel counter, and looks up dead_writes by ID. Because both walks use mirrored deterministic structural recursion, IDs align without tree paths or unsafe pointers.

Trap-effecting instructions (load, store, div)

May trap and end the function early. We compute liveness under the no-trap assumption: writes are removed only if dead on the no-trap continuation. If a trap intervenes, no later instruction observes the local — so removal remains sound. The conservative direction is correct here.

Pipeline order

... → simplify-locals → dead-stores → dead-locals

dead-stores BEFORE dead-locals: a write-only local with dead-only writes becomes a fully-unused local, which dead-locals then drops in the same pipeline run. Synergistic.

Measurement

Workload	Effect
gale_in_baseline.wasm (1.9 KB kernel FFI)	unchanged at 804 B (PR-B already exhausts this workload's pattern — pure write-without-read; PR-C's path-sensitive cases don't appear here)
calculator.wasm (2.3 MB component)	2,337,724 → 2,327,794 bytes (-0.4%, ~10 KB) with --passes dead-stores alone. Output validates.

The gale-zero-effect and calculator-real-effect together confirm: PR-C's value is on workloads with branchier dead-store patterns. It scales with workload complexity.

Stack-effect rules (same as PR-B)

Original	Stack effect	Substitute	Why
LocalSet idx	[T] -> []	Drop	Drop also [T] -> []
LocalTee idx	[T] -> [T]	(removed)	Value passes through

The branch_aware_keeps_partial_use test pins this — if we got it wrong, the validator would reject (an uninitialized read is type-error in wasm).

Tests (6 new)

• overwritten_in_straight_line — two writes, no read between; first is dead.
• preserves_live_writes — single live write must survive untouched.
• branch_aware_keeps_partial_use — write before if; if-not-taken path reaches the local.get directly. Write IS LIVE on that path and MUST survive. The hardest case — Drop'ing it would expose an uninitialized read.
• both_arms_overwrite — write before if where BOTH arms overwrite. live-before-if = ∅, outer write is dead. Tests union-of-arm-deads.
• return_kills_continuation — write followed by Return. live ← ∅ after Return; write is dead.
• localtee_dead_removed — dead Tee removed (not Drop'd); stack [T] -> [T] passes through.

All 303 tests pass (258 lib + 28 + 17).

Follow-ups not in this PR

• Loop fixpoint precision (~100 LOC) — replace conservative loop body approximation with proper fixpoint iteration on the back-edge. Adds dead-store catches inside loops.
• Const+drop peephole in vacuum (~10 LOC) — clean up i32.const X; drop patterns left by PR-B/PR-C neutralization.

🤖 Generated with Claude Code