Struct cranelift_wasm::DummyFuncEnvironment

pub struct DummyFuncEnvironment<'dummy_environment> {
    pub mod_info: &'dummy_environment DummyModuleInfo,
    pub heaps: PrimaryMap<Heap, HeapData>,
    /* private fields */
}

The FuncEnvironment implementation for use by the DummyEnvironment.

Fields

mod_info: &'dummy_environment DummyModuleInfo

This function environment’s module info.

heaps: PrimaryMap<Heap, HeapData>

Heaps we have created to implement Wasm linear memories.

Implementations

impl<'dummy_environment> DummyFuncEnvironment<'dummy_environment>

pub fn new(
    mod_info: &'dummy_environment DummyModuleInfo,
    expected_reachability: Option<ExpectedReachability>
) -> Self

Construct a new DummyFuncEnvironment.

pub fn vmctx_sig(&self, sigidx: TypeIndex) -> Signature

Create a signature for sigidx amended with a vmctx argument after the standard wasm arguments.

Trait Implementations

impl<'dummy_environment> FuncEnvironment for DummyFuncEnvironment<'dummy_environment>

fn make_global(
    &mut self,
    func: &mut Function,
    index: GlobalIndex
) -> WasmResult<GlobalVariable>

Set up the necessary preamble definitions in func to access the global variable identified by index.

fn heaps(&self) -> &PrimaryMap<Heap, HeapData>

Get the heaps for this function environment.

fn make_heap(
    &mut self,
    func: &mut Function,
    _index: MemoryIndex
) -> WasmResult<Heap>

Set up the necessary preamble definitions in func to access the linear memory identified by index.

fn make_table(
    &mut self,
    func: &mut Function,
    _index: TableIndex
) -> WasmResult<Table>

Set up the necessary preamble definitions in func to access the table identified by index.

fn make_indirect_sig(
    &mut self,
    func: &mut Function,
    index: TypeIndex
) -> WasmResult<SigRef>

Set up a signature definition in the preamble of func that can be used for an indirect call with signature index.

fn make_direct_func(
    &mut self,
    func: &mut Function,
    index: FuncIndex
) -> WasmResult<FuncRef>

Set up an external function definition in the preamble of func that can be used to directly call the function index.

fn before_translate_operator(
    &mut self,
    _op: &Operator<'_>,
    _builder: &mut FunctionBuilder<'_>,
    state: &FuncTranslationState
) -> WasmResult<()>

Optional callback for the FunctionEnvironment performing this translation to maintain internal state or prepare custom state for the operator to translate

fn after_translate_operator(
    &mut self,
    _op: &Operator<'_>,
    _builder: &mut FunctionBuilder<'_>,
    state: &FuncTranslationState
) -> WasmResult<()>

Optional callback for the FunctionEnvironment performing this translation to maintain internal state or finalize custom state for the operator that was translated

fn after_translate_function(
    &mut self,
    _builder: &mut FunctionBuilder<'_>,
    _state: &FuncTranslationState
) -> WasmResult<()>

Optional callback for the FunctionEnvironment performing this translation to perform work after the function body is translated.

fn translate_call_indirect(
    &mut self,
    builder: &mut FunctionBuilder<'_>,
    _table_index: TableIndex,
    _table: Table,
    _sig_index: TypeIndex,
    sig_ref: SigRef,
    callee: Value,
    call_args: &[Value]
) -> WasmResult<Inst>

Translate a call_indirect WebAssembly instruction at pos.

fn translate_call(
    &mut self,
    pos: FuncCursor<'_>,
    _callee_index: FuncIndex,
    callee: FuncRef,
    call_args: &[Value]
) -> WasmResult<Inst>

Translate a call WebAssembly instruction at pos.

fn translate_memory_grow(
    &mut self,
    pos: FuncCursor<'_>,
    _index: MemoryIndex,
    _heap: Heap,
    _val: Value
) -> WasmResult<Value>

Translate a memory.grow WebAssembly instruction.

fn translate_memory_size(
    &mut self,
    pos: FuncCursor<'_>,
    _index: MemoryIndex,
    _heap: Heap
) -> WasmResult<Value>

Translates a memory.size WebAssembly instruction.

fn translate_memory_copy(
    &mut self,
    _pos: FuncCursor<'_>,
    _src_index: MemoryIndex,
    _src_heap: Heap,
    _dst_index: MemoryIndex,
    _dst_heap: Heap,
    _dst: Value,
    _src: Value,
    _len: Value
) -> WasmResult<()>

Translate a memory.copy WebAssembly instruction.

fn translate_memory_fill(
    &mut self,
    _pos: FuncCursor<'_>,
    _index: MemoryIndex,
    _heap: Heap,
    _dst: Value,
    _val: Value,
    _len: Value
) -> WasmResult<()>

Translate a memory.fill WebAssembly instruction.

fn translate_memory_init(
    &mut self,
    _pos: FuncCursor<'_>,
    _index: MemoryIndex,
    _heap: Heap,
    _seg_index: u32,
    _dst: Value,
    _src: Value,
    _len: Value
) -> WasmResult<()>

Translate a memory.init WebAssembly instruction.

fn translate_data_drop(
    &mut self,
    _pos: FuncCursor<'_>,
    _seg_index: u32
) -> WasmResult<()>

Translate a data.drop WebAssembly instruction.

fn translate_table_size(
    &mut self,
    pos: FuncCursor<'_>,
    _index: TableIndex,
    _table: Table
) -> WasmResult<Value>

Translate a table.size WebAssembly instruction.

fn translate_table_grow(
    &mut self,
    pos: FuncCursor<'_>,
    _table_index: TableIndex,
    _table: Table,
    _delta: Value,
    _init_value: Value
) -> WasmResult<Value>

Translate a table.grow WebAssembly instruction.

fn translate_table_get(
    &mut self,
    builder: &mut FunctionBuilder<'_>,
    _table_index: TableIndex,
    _table: Table,
    _index: Value
) -> WasmResult<Value>

Translate a table.get WebAssembly instruction.

fn translate_table_set(
    &mut self,
    _builder: &mut FunctionBuilder<'_>,
    _table_index: TableIndex,
    _table: Table,
    _value: Value,
    _index: Value
) -> WasmResult<()>

Translate a table.set WebAssembly instruction.

fn translate_table_copy(
    &mut self,
    _pos: FuncCursor<'_>,
    _dst_index: TableIndex,
    _dst_table: Table,
    _src_index: TableIndex,
    _src_table: Table,
    _dst: Value,
    _src: Value,
    _len: Value
) -> WasmResult<()>

Translate a table.copy WebAssembly instruction.

fn translate_table_fill(
    &mut self,
    _pos: FuncCursor<'_>,
    _table_index: TableIndex,
    _dst: Value,
    _val: Value,
    _len: Value
) -> WasmResult<()>

Translate a table.fill WebAssembly instruction.

fn translate_table_init(
    &mut self,
    _pos: FuncCursor<'_>,
    _seg_index: u32,
    _table_index: TableIndex,
    _table: Table,
    _dst: Value,
    _src: Value,
    _len: Value
) -> WasmResult<()>

Translate a table.init WebAssembly instruction.

fn translate_elem_drop(
    &mut self,
    _pos: FuncCursor<'_>,
    _seg_index: u32
) -> WasmResult<()>

Translate a elem.drop WebAssembly instruction.

fn translate_ref_func(
    &mut self,
    pos: FuncCursor<'_>,
    _func_index: FuncIndex
) -> WasmResult<Value>

Translate a ref.func WebAssembly instruction.

fn translate_custom_global_get(
    &mut self,
    pos: FuncCursor<'_>,
    _global_index: GlobalIndex
) -> WasmResult<Value>

Translate a global.get WebAssembly instruction at pos for a global that is custom.

fn translate_custom_global_set(
    &mut self,
    _pos: FuncCursor<'_>,
    _global_index: GlobalIndex,
    _val: Value
) -> WasmResult<()>

Translate a global.set WebAssembly instruction at pos for a global that is custom.

fn translate_atomic_wait(
    &mut self,
    pos: FuncCursor<'_>,
    _index: MemoryIndex,
    _heap: Heap,
    _addr: Value,
    _expected: Value,
    _timeout: Value
) -> WasmResult<Value>

Translate an i32.atomic.wait or i64.atomic.wait WebAssembly instruction. The index provided identifies the linear memory containing the value to wait on, and heap is the heap reference returned by make_heap for the same index. Whether the waited-on value is 32- or 64-bit can be determined by examining the type of expected, which must be only I32 or I64.

fn translate_atomic_notify(
    &mut self,
    pos: FuncCursor<'_>,
    _index: MemoryIndex,
    _heap: Heap,
    _addr: Value,
    _count: Value
) -> WasmResult<Value>

Translate an atomic.notify WebAssembly instruction. The index provided identifies the linear memory containing the value to wait on, and heap is the heap reference returned by make_heap for the same index.

fn unsigned_add_overflow_condition(&self) -> IntCC

Returns the target ISA’s condition to check for unsigned addition overflowing.

fn is_wasm_parameter(&self, signature: &Signature, index: usize) -> bool

Is the given parameter of the given function a wasm-level parameter, as opposed to a hidden parameter added for use by the implementation?

fn is_wasm_return(&self, signature: &Signature, index: usize) -> bool

Is the given return of the given function a wasm-level parameter, as opposed to a hidden parameter added for use by the implementation?

fn after_locals(&mut self, num_locals_defined: usize)

Called after the locals for a function have been parsed, and the number of variables defined by this function is provided.

fn translate_ref_null(
    &mut self,
    pos: FuncCursor<'_>,
    ty: WasmType
) -> WasmResult<Value>

Translate a ref.null T WebAssembly instruction.

fn translate_ref_is_null(
    &mut self,
    pos: FuncCursor<'_>,
    value: Value
) -> WasmResult<Value>

Translate a ref.is_null WebAssembly instruction.

fn translate_loop_header(
    &mut self,
    _builder: &mut FunctionBuilder<'_>
) -> WasmResult<()>

Emit code at the beginning of every wasm loop.

fn before_unconditionally_trapping_memory_access(
    &mut self,
    _builder: &mut FunctionBuilder<'_>
) -> WasmResult<()>

Optional callback for the FuncEnvironment performing this translation to maintain, prepare, or finalize custom, internal state when we statically determine that a Wasm memory access will unconditionally trap, rendering the rest of the block unreachable. Called just before the unconditional trap is emitted.

fn before_translate_function(
    &mut self,
    _builder: &mut FunctionBuilder<'_>,
    _state: &FuncTranslationState
) -> WasmResult<()>

Optional callback for the FunctionEnvironment performing this translation to perform work before the function body is translated.

impl<'dummy_environment> TargetEnvironment for DummyFuncEnvironment<'dummy_environment>

fn target_config(&self) -> TargetFrontendConfig

Get the information needed to produce Cranelift IR for the given target.

fn heap_access_spectre_mitigation(&self) -> bool

Whether to enable Spectre mitigations for heap accesses.

fn pointer_type(&self) -> Type

Get the Cranelift integer type to use for native pointers.

fn pointer_bytes(&self) -> u8

Get the size of a native pointer, in bytes.

fn reference_type(&self, ty: WasmType) -> Type

Get the Cranelift reference type to use for the given Wasm reference type.