wasmi 0.36.0

WebAssembly interpreter
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

//! Translation tests for all unary Wasm instructions.

mod conversion;
mod op;

use super::*;
use crate::core::{TrapCode, UntypedVal};
use std::fmt::Display;
use wasm_type::WasmTy;

/// Asserts that the unary Wasm operator `wasm_op` translates properly to a unary Wasmi instruction.
fn conversion_reg_with<I, O, E>(wasm_op: &str, expected: E)
where
    I: WasmTy,
    O: WasmTy,
    E: IntoIterator<Item = Instruction>,
{
    let param_ty = <I as WasmTy>::NAME;
    let result_ty = <O as WasmTy>::NAME;
    let wasm = format!(
        r#"
        (module
            (func (param {param_ty}) (result {result_ty})
                local.get 0
                {result_ty}.{wasm_op}
            )
        )
    "#,
    );
    TranslationTest::from_wat(&wasm)
        .expect_func_instrs(expected)
        .run();
}

/// Asserts that the unary Wasm operator `wasm_op` translates properly to a unary Wasmi instruction.
fn conversion_reg<I, O>(
    wasm_op: &str,
    make_instr: fn(result: Register, input: Register) -> Instruction,
) where
    I: WasmTy,
    O: WasmTy,
{
    let expected = [
        make_instr(Register::from_i16(1), Register::from_i16(0)),
        Instruction::return_reg(1),
    ];
    conversion_reg_with::<I, O, _>(wasm_op, expected)
}

/// Asserts that the unary Wasm operator `wasm_op` translates properly to a unary Wasmi instruction.
fn unary_reg<T>(wasm_op: &str, make_instr: fn(result: Register, input: Register) -> Instruction)
where
    T: WasmTy,
{
    conversion_reg::<T, T>(wasm_op, make_instr)
}

/// Asserts that the unary Wasm operator `wasm_op` translates properly to a unary Wasmi instruction.
fn conversion_imm<I, O>(wasm_op: &str, input: I, eval: fn(input: I) -> O)
where
    I: WasmTy,
    O: WasmTy,
    DisplayWasm<I>: Display,
{
    let param_ty = <I as WasmTy>::NAME;
    let result_ty = <O as WasmTy>::NAME;
    let wasm_input = DisplayWasm::from(input);
    let wasm = format!(
        r#"
        (module
            (func (result {result_ty})
                {param_ty}.const {wasm_input}
                {result_ty}.{wasm_op}
            )
        )
    "#,
    );
    let result = eval(input);
    let instr = <O as WasmTy>::return_imm_instr(&result);
    let mut testcase = TranslationTest::from_wat(&wasm);
    if let Instruction::ReturnReg { value } = &instr {
        assert!(value.is_const());
        testcase.expect_func(ExpectedFunc::new([instr]).consts([result]));
    } else {
        testcase.expect_func_instrs([instr]);
    }
    testcase.run();
}

/// Asserts that the unary Wasm operator `wasm_op` translates properly to a unary Wasmi instruction.
fn unary_imm<T>(wasm_op: &str, input: T, eval: fn(input: T) -> T)
where
    T: WasmTy,
    DisplayWasm<T>: Display,
{
    conversion_imm::<T, T>(wasm_op, input, eval)
}

/// Asserts that the unary Wasm operator `wasm_op` translates properly to a unary Wasmi instruction.
fn fallible_conversion_imm_err<I, O>(wasm_op: &str, input: I, eval: fn(input: I) -> TrapCode)
where
    I: WasmTy,
    O: WasmTy,
    DisplayWasm<I>: Display,
{
    let param_ty = <I as WasmTy>::NAME;
    let result_ty = <O as WasmTy>::NAME;
    let wasm_input = DisplayWasm::from(input);
    let wasm = format!(
        r#"
        (module
            (func (result {result_ty})
                {param_ty}.const {wasm_input}
                {result_ty}.{wasm_op}
            )
        )
    "#,
    );
    let trap_code = eval(input);
    TranslationTest::from_wat(&wasm)
        .expect_func_instrs([Instruction::Trap(trap_code)])
        .run();
}