Cranelift Codegen Optimization

Cranelift is the optimizing compiler backend inside Wasmtime. Its design point is fast compilation, so the machine code it emits leaves measurable performance on the table compared to LLVM-class backends: in the mid-end rewrite rules (written in the ISLE DSL), the e-graph optimizer and its cost model, the x86-64 instruction selector, and the vendored regalloc2 register allocator. Improving generated code without materially slowing the compiler is exactly the trade-off production compiler engineers navigate.

Correctness makes this unforgiving: WebAssembly semantics pin down exact float results and NaN propagation, integer division/remainder edges, shift-count masking, trap conditions and their ordering; a rewrite rule that is almost right miscompiles real programs.

The agent must make the native code Cranelift generates run faster, without making the compiler itself do materially more work to compile. What counts is the machine code emitted for a WebAssembly module, not how fast Wasmtime itself runs. All changes are confined to the Wasmtime source tree at /app/wasmtime/, written as .rs and .isle sources.

• /app/perf-check models the full performance requirement: it rebuilds the compiler, measures the generated code for the visible workloads against the unmodified compiler, and separately reports compile work on the biggest modules as a ratio to the baseline.
• Compile time is a constraint, not free: the guidance is to stay within about +10% of baseline compile work; a runtime win bought by a much slower compile does not count.
• Every workload's reference output and every spec test that passes today must still pass; one regression is as bad as making no change.
• Cargo is offline with a fully vendored dependency graph: Cargo.toml, Cargo.lock, cargo config, and build.rs files are fixed, so no new dependencies can be added.

The full pinned Wasmtime source tree with a warm target/ for incremental rebuilds, regalloc2 vendored as an editable path dependency, and the Wasm spec and misc test suites. Ten visible benchmark workloads ship as pre-built .wasmwith inputs and the unmodified compiler's recorded outputs: an interpreter, compression codecs, SQLite, crypto, and loop/recursion micro-kernels drawn largely from the Sightglass corpus.

/app/perf-check is the self-check loop: rebuild, compile every workload, measure the generated code deterministically, and compare against the baseline (with --wast for the spec suites and wasmtime-baseline on PATH for manual A/B). The measurement stack in /app/performance/ (per-address attribution plus per-opcode pricing) and the baseline measurements are all visible. The machine is offline with a pinned Rust toolchain preinstalled.

A clean-room verifier in a separate container reconstructs the scored tree from pristine Wasmtime sources plus only the agent's .rs/.isle edits, rebuilds it, and scores ten held-out workloads: same corpus families as the visible set (SIMD, compression, regex, crypto, jump-table and integer kernels) but never seen by the agent.

• The metric is deterministic simulated work, not wall-clock: per-address execution counts are restricted to the code Cranelift generated (excluding Wasmtime startup), and each opcode is priced by a reciprocal-throughput cost table derived from uops.info, with codegen pinned to x86-64-v3.
• Correctness gates run first: must-pass and must-fail canary suites, two passes over the full spec suites (nothing that passes on the reference may regress), edge-case binaries, and every workload's output compared against the reference compiler's build. Any failure zeroes the result.
• The scored speedup is outlier-dampened (held down to the geometric mean that survives dropping the single best workload), then mapped on a convex curve with a 0.5% deadband reaching full credit at a 1.20x geomean. A one-sided compile-work penalty multiplies the result: free within +10% of baseline, linear to zero at +20%.
• A single workload "improving" by more than 2.5x is treated as implausible and zeroed for review; modified sources that reach an external code generator are rejected; a compiler that fails to build or to run a workload the baseline handles scores zero.