Struct LoweringBuilder 

pub struct LoweringBuilder { /* private fields */ }

Scratchpad shared across per-instruction lower_* calls when walking a Cranelift cl::Function.

Owns three bidirectional Cranelift → lowered-id maps (values, blocks, stack slots) plus a monotonic id allocator for each of the two id namespaces (LoweredValueId and LoweredBlockId).

The wave-2 lowering driver constructs a LoweringBuilder, pre-allocates ids for entry-block params and constants via Self::get_or_alloc_value / Self::bind_value, then calls each per-family lower_* function in turn (crate::lower_arith::lower_arith_inst et al.) by passing the builder’s internals through Self::value_map_mut and Self::next_value_id_mut. The result is an ordered list of crate::lowered_ir::LoweredOps with consistent SSA numbering.

See the module docs for the namespace rules.

Implementations

impl LoweringBuilder

pub fn new() -> Self

Construct an empty builder. Both id counters start at 0 and all three maps are empty.

pub fn alloc_value(&mut self) -> LoweredValueId

Allocate a fresh LoweredValueId and return it. Increments the value-id counter. Does not bind the id to any Cranelift Value; callers wanting a Value → id binding should use Self::get_or_alloc_value or Self::bind_value instead.

pub fn alloc_block(&mut self) -> LoweredBlockId

Allocate a fresh LoweredBlockId and return it. Increments the block-id counter. Independent of Self::alloc_value.

pub fn get_or_alloc_value(&mut self, v: Value) -> LoweredValueId

Get the LoweredValueId for a Cranelift cl::Value, allocating one if it’s the first time we’ve seen it.

This is the workhorse for entry-block param setup: the driver iterates over dfg.block_params(entry) and calls this for each param to seed the value-map before walking the body. It’s also safe to call repeatedly for the same value — subsequent calls return the existing id without advancing the counter.

pub fn get_or_alloc_block(&mut self, b: Block) -> LoweredBlockId

Get the LoweredBlockId for a Cranelift cl::Block, allocating one if it’s the first time we’ve seen it.

Used by crate::lower_cf when it encounters a branch target: the target block may not yet have been walked, but its lowered id needs to be embedded in the Br/CondBr/Switch op now.

pub fn get_or_alloc_stack_slot(&mut self, ss: StackSlot) -> LoweredValueId

Get the alloca-pointer LoweredValueId for a Cranelift cl::StackSlot, allocating one (from the value-id counter) if it’s the first time we’ve seen it.

crate::lower_memory uses this for stack_load / stack_store: every reference to the same StackSlot resolves to the same alloca pointer SSA value, so the downstream mem2reg pass can rewrite all uses uniformly.

pub fn lookup_value(&self, v: Value) -> Option<LoweredValueId>

Look up an existing LoweredValueId for a Cranelift cl::Value. Returns None if no binding exists yet.

Use this when you want to probe the map without side effects (e.g. assertions, debugging, or when a missing operand should fail rather than allocate). For the eager-allocate flavour use Self::get_or_alloc_value.

pub fn lookup_block(&self, b: Block) -> Option<LoweredBlockId>

Look up an existing LoweredBlockId for a Cranelift cl::Block. Returns None if no binding exists yet.

pub fn lookup_stack_slot(&self, ss: StackSlot) -> Option<LoweredValueId>

Look up an existing stack-slot alloca-pointer id for a Cranelift cl::StackSlot. Returns None if no binding exists yet.

pub fn bind_value( &mut self, v: Value, id: LoweredValueId, ) -> Option<LoweredValueId>

Bind a Cranelift cl::Value to a specific (already-allocated) LoweredValueId.

Does not advance the value-id counter — this is purely a name assignment. Returns the previous binding for v, if any (mirroring HashMap::insert).

Used by per-family lower_* functions that prefer the wave-1 idiom of allocating the result id via *next_id and inserting it directly: those callers reach for Self::next_value_id_mut / Self::value_map_mut today, but bind_value is the cleaner option when the caller already has the id in hand.

pub fn bind_stack_slot( &mut self, ss: StackSlot, id: LoweredValueId, ) -> Option<LoweredValueId>

Bind a Cranelift cl::StackSlot to a specific (already-allocated) alloca-pointer LoweredValueId, returning the previous binding if any (mirroring HashMap::insert).

jit HIGH fix (finding 3): the W2.4 driver lifts the builder’s stack-slot map out into a local &mut HashMap so it can hand a &mut to the memory-lowering context. Without a way to write entries back, every new stack slot allocated during memory lowering was DROPPED on return — so a later stack_load/stack_store of the same slot would call Self::get_or_alloc_stack_slot, miss, and allocate a fresh alloca pointer, splitting one logical slot into several distinct allocas (a miscompile). The driver now reinserts each entry of the local map through this method after lowering, so repeated references to one slot resolve to the same alloca id.

Unlike Self::get_or_alloc_stack_slot, this does not advance the value-id counter — the id was already allocated by the memory lowering against the same shared counter.

pub fn value_map_mut(&mut self) -> &mut HashMap<Value, LoweredValueId>

Mutable access to the inner value_map.

Provided for compatibility with the wave-1 per-family lowerings (e.g. crate::lower_arith::lower_arith_inst) that already accept &mut HashMap<cl::Value, LoweredValueId> directly. The borrow is tied to &mut self, so the builder cannot be otherwise mutated for the duration.

pub fn next_value_id_mut(&mut self) -> &mut LoweredValueId

Mutable access to the inner next_value_id counter.

Companion to Self::value_map_mut: per-family lowerings receive both and update them in lockstep. Direct mutation here is equivalent to calling Self::alloc_value manually.

pub fn value_map(&self) -> &HashMap<Value, LoweredValueId>

Read-only view of the value_map. Handy for tests, fingerprinting, and the wave-2 driver’s post-walk verification.

pub fn block_map(&self) -> &HashMap<Block, LoweredBlockId>

Read-only view of the block_map. Used by crate::lower_cf when it only needs to look up branch targets that the driver has already seeded.

pub fn stack_slot_map(&self) -> &HashMap<StackSlot, LoweredValueId>

Read-only view of the stack_slot_map.

pub fn split_borrow_for_memory( &mut self, ) -> (&HashMap<Value, LoweredValueId>, &mut HashMap<StackSlot, LoweredValueId>, &mut LoweredValueId)

Split-borrow accessor for the memory-lowering family.

Returns (&value_map, &mut stack_slot_map, &mut next_value_id) in a single call so the caller gets disjoint borrows of three distinct fields — exactly the shape MemLowerContext needs (value map read, stack-slot map + counter mutated).

jit MED fix (finding 6): the W2.4 driver previously CLONED the whole value_map on every memory instruction (builder.value_map().clone()) because the borrow checker couldn’t see the three accessors were disjoint — making the driver O(V·M) (values × memory instructions). This method performs the field split once, in safe code, so the memory context borrows the live map directly with no per-instruction allocation.

Trait Implementations

impl Default for LoweringBuilder

fn default() -> Self

Returns the “default value” for a type.