Struct ForgeTier 

pub struct ForgeTier { /* private fields */ }

The forge-backed native tier, with compile observability.

Implementations

impl ForgeTier

pub fn new() -> Self

A fresh tier with zeroed counters.

pub fn function_counts(&self) -> (u32, u32)

(attempts, successes) for FUNCTION compiles.

pub fn pinned_self_call_count(&self) -> u32

The number of fused pinned-argument self-calls (CallSelfCopy) emitted across every function compile — Lever A’s observable. A nonzero value proves a scalar self-call took the fused ABI rather than per-argument frame Move staging.

pub fn region_counts(&self) -> (u32, u32)

(attempts, successes) for Main-loop REGION compiles.

pub fn regalloc_region_count(&self) -> u32

How many region compiles used the CONTIGUOUS register-allocating backend (WS-G compile_region_regalloc) rather than a per-piece stencil tier. Nonzero proves the regalloc backend fired on a real program’s hot loop.

pub fn regalloc_precise_region_count(&self) -> u32

How many PRECISE region compiles used the contiguous register-allocating backend (compile_region_regalloc_precise) rather than the per-piece precise stencil tier. Nonzero proves the in-place-mutation + reallocating- push shape (fannkuch / graph_bfs worklist) tiered through the regalloc backend — Wave 21’s lever.

pub fn regalloc_function_count(&self) -> u32

How many FUNCTION compiles used the contiguous register-allocating backend (compile_function_regalloc) rather than the per-piece stencil tier. Nonzero proves a recursive (self-calling) function tiered through the regalloc backend — the recursion cluster’s lever.

pub fn runtime_stats(&self) -> (u64, u64, u64, u64)

Runtime FUNCTION-boundary truth: (entries, completions, plain deopts, precise deopts). Entries count VM→native crossings — native self-recursion inside one entry is invisible here, which is exactly the point: a hot recursive function shows FEW entries.

Trait Implementations

impl Default for ForgeTier

fn default() -> ForgeTier

Returns the “default value” for a type.

impl NativeTier for ForgeTier

fn compile_function( &self, code: &[Op], entry_pc: usize, constants: &[Constant], param_count: u16, register_count: u16, self_fi: u16, param_kinds: &[Option<ParamKind>], ret_kind: Option<SlotKind>, ctx: &NativeCtx, callees: &[CalleeSig], ) -> Option<Box<dyn NativeFn>>

Attempt to compile the function whose bytecode is code (code[0] is the instruction at entry_pc; jump targets inside are ABSOLUTE program pcs and need rebasing by entry_pc). Return None to leave the function on the bytecode path forever.

fn compile_region( &self, code: &[Op], head_pc: usize, exit_pc: usize, constants: &[Constant], register_count: u16, named: &[bool], observed: &[ObservedKind], ctx: &NativeCtx, callees: &[CalleeSig], ) -> Option<Box<dyn RegionFn>>

Attempt to compile a loop region. code[0] is the op at head_pc (the back-edge target); the slice ends at the back-edge jump (inclusive). Every jump out of the region must target exit_pc. named[r] marks frame registers carrying a user-visible name — the only slots whose post-region values are observable (scratches are dead at statement boundaries by the compiler’s allocation discipline). observed[r] is the register’s runtime kind at this hot crossing — the speculation seed, re-checked by the guard set on every entry. Default: regions stay on bytecode.