Struct wasmer_compiler_cranelift::translator::func_state::FuncTranslationState

pub struct FuncTranslationState {
    pub(crate) stack: Vec<Value>,
    pub(crate) control_stack: Vec<ControlStackFrame>,
    pub(crate) reachable: bool,
    globals: HashMap<GlobalIndex, GlobalVariable>,
    heaps: HashMap<MemoryIndex, Heap>,
    signatures: HashMap<SignatureIndex, (SigRef, usize)>,
    functions: HashMap<FunctionIndex, (FuncRef, usize)>,
}

Contains information passed along during a function’s translation and that records:

• The current value and control stacks.
• The depth of the two unreachable control blocks stacks, that are manipulated when translating unreachable code;

Fields

stack: Vec<Value>

A stack of values corresponding to the active values in the input wasm function at this point.

control_stack: Vec<ControlStackFrame>

A stack of active control flow operations at this point in the input wasm function.

reachable: bool

Is the current translation state still reachable? This is false when translating operators like End, Return, or Unreachable.

globals: HashMap<GlobalIndex, GlobalVariable>

heaps: HashMap<MemoryIndex, Heap>

signatures: HashMap<SignatureIndex, (SigRef, usize)>

functions: HashMap<FunctionIndex, (FuncRef, usize)>

Implementations

impl FuncTranslationState

pub fn reachable(&self) -> bool

True if the current translation state expresses reachable code, false if it is unreachable.

impl FuncTranslationState

pub(crate) fn new() -> Self

Construct a new, empty, FuncTranslationState

fn clear(&mut self)

pub(crate) fn initialize(&mut self, sig: &Signature, exit_block: Block)

Initialize the state for compiling a function with the given signature.

This resets the state to containing only a single block representing the whole function. The exit block is the last block in the function which will contain the return instruction.

pub(crate) fn push1(&mut self, val: Value)

Push a value.

pub(crate) fn pushn(&mut self, vals: &[Value])

Push multiple values.

pub(crate) fn pop1(&mut self) -> Value

Pop one value.

pub(crate) fn peek1(&self) -> Value

Peek at the top of the stack without popping it.

pub(crate) fn pop2(&mut self) -> (Value, Value)

Pop two values. Return them in the order they were pushed.

pub(crate) fn pop3(&mut self) -> (Value, Value, Value)

Pop three values. Return them in the order they were pushed.

fn ensure_length_is_at_least(&self, n: usize)

Helper to ensure the stack size is at least as big as n; note that due to debug_assert this will not execute in non-optimized builds.

pub(crate) fn popn(&mut self, n: usize)

Pop the top n values on the stack.

The popped values are not returned. Use peekn to look at them before popping.

pub(crate) fn peekn(&self, n: usize) -> &[Value]

Peek at the top n values on the stack in the order they were pushed.

pub(crate) fn peekn_mut(&mut self, n: usize) -> &mut [Value]

Peek at the top n values on the stack in the order they were pushed.

pub(crate) fn push_block( &mut self, following_code: Block, num_param_types: usize, num_result_types: usize, )

Push a block on the control stack.

pub(crate) fn push_loop( &mut self, header: Block, following_code: Block, num_param_types: usize, num_result_types: usize, )

Push a loop on the control stack.

pub(crate) fn push_if( &mut self, destination: Block, else_data: ElseData, num_param_types: usize, num_result_types: usize, blocktype: BlockType, )

Push an if on the control stack.

impl FuncTranslationState

Methods for handling entity references.

pub(crate) fn get_global<FE: FuncEnvironment + ?Sized>( &mut self, func: &mut Function, index: u32, environ: &mut FE, ) -> WasmResult<GlobalVariable>

Get the GlobalVariable reference that should be used to access the global variable index. Create the reference if necessary. Also return the WebAssembly type of the global.

pub(crate) fn get_heap<FE: FuncEnvironment + ?Sized>( &mut self, func: &mut Function, index: u32, environ: &mut FE, ) -> WasmResult<Heap>

Get the Heap reference that should be used to access linear memory index. Create the reference if necessary.

pub(crate) fn get_indirect_sig<FE: FuncEnvironment + ?Sized>( &mut self, func: &mut Function, index: u32, environ: &mut FE, ) -> WasmResult<(SigRef, usize)>

Get the SigRef reference that should be used to make an indirect call with signature index. Also return the number of WebAssembly arguments in the signature.

Create the signature if necessary.

pub(crate) fn get_direct_func<FE: FuncEnvironment + ?Sized>( &mut self, func: &mut Function, index: u32, environ: &mut FE, ) -> WasmResult<(FuncRef, usize)>

Get the FuncRef reference that should be used to make a direct call to function index. Also return the number of WebAssembly arguments in the signature.

Create the function reference if necessary.