wasmi 2.0.0-beta.4

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
124
125
126
127
128
129
130

use crate::{
    engine::executor::handler::{
        dispatch::{Break, Control, ExecutionOutcome, decode_handler, decode_op_code},
        exec,
        state::{Freg32, Freg64, Inst, Ip, Ireg, Mem0Len, Mem0Ptr, Sp, VmState},
    },
    ir,
    ir::OpCode,
};

#[inline(always)]
pub fn fetch_handler(ip: Ip) -> Handler {
    match cfg!(feature = "indirect-dispatch") {
        true => {
            let op_code = decode_op_code(ip);
            op_code_to_handler(op_code)
        }
        false => decode_handler(ip),
    }
}

pub enum Never {}
pub type Done = Control<Never, Break>;

#[cfg(not(target_arch = "x86_64"))]
pub type Handler = fn(
    &mut VmState,
    ip: Ip,
    sp: Sp,
    mem0: Mem0Ptr,
    mem0_len: Mem0Len,
    instance: Inst,
    ireg: Ireg,
    freg32: Freg32,
    freg64: Freg64,
) -> Done;

#[cfg(target_arch = "x86_64")]
#[allow(improper_ctypes_definitions)] // not used in FFI
pub type Handler = extern "sysv64" fn(
    &mut VmState,
    ip: Ip,
    sp: Sp,
    mem0: Mem0Ptr,
    mem0_len: Mem0Len,
    instance: Inst,
    ireg: Ireg,
    freg32: Freg32,
    freg64: Freg64,
) -> Done;

macro_rules! expand_op_code_to_handler {
    ( $( $snake_case:ident => $camel_case:ident ),* $(,)? ) => {
        #[inline(always)]
        pub fn op_code_to_handler(code: OpCode) -> Handler {
            static HANDLERS: [Handler; ir::LEN_OPS] = [
                $( exec::$snake_case ),*
            ];
            // SAFETY: the `HANDLERS` table has exactly the same size as `LEN_OPS`
            //         which represents the number of [`Op`] and thus [`OpCode`]
            //         variants. Since [`OpCode`] is contiguously defined, all [`OpCode`]
            //         values are represented in the table, thus using their values as
            //         unchecked index into the `HANDLERS` table is safe.
            unsafe { *HANDLERS.get_unchecked(usize::from(u16::from(code))) }
        }
    };
}
ir::for_each_op!(expand_op_code_to_handler);

#[cfg(not(all(feature = "unstable", not(feature = "stable"))))]
macro_rules! dispatch {
    (
        $state:expr,
        $ip:expr,
        $sp:expr,
        $mem0:expr,
        $mem0_len:expr,
        $instance:expr,
        $ireg:expr,
        $freg32:expr,
        $freg64:expr $(,)?
    ) => {{
        let handler = $crate::engine::executor::handler::dispatch::backend::fetch_handler($ip);
        return handler(
            $state, $ip, $sp, $mem0, $mem0_len, $instance, $ireg, $freg32, $freg64,
        );
    }};
}

#[cfg(all(feature = "unstable", not(feature = "stable")))]
macro_rules! dispatch {
    (
        $state:expr,
        $ip:expr,
        $sp:expr,
        $mem0:expr,
        $mem0_len:expr,
        $instance:expr,
        $ireg:expr,
        $freg32:expr,
        $freg64:expr $(,)?
    ) => {{
        let handler = $crate::engine::executor::handler::dispatch::backend::fetch_handler($ip);
        become handler(
            $state, $ip, $sp, $mem0, $mem0_len, $instance, $ireg, $freg32, $freg64,
        );
    }};
}

#[expect(clippy::too_many_arguments)]
pub fn execute_until_done(
    state: &mut VmState,
    ip: Ip,
    sp: Sp,
    mem0: Mem0Ptr,
    mem0_len: Mem0Len,
    instance: Inst,
    ireg: Ireg,
    freg32: Freg32,
    freg64: Freg64,
) -> Result<Sp, ExecutionOutcome> {
    let handler = fetch_handler(ip);
    let Control::Break(reason) = handler(
        state, ip, sp, mem0, mem0_len, instance, ireg, freg32, freg64,
    );
    if let Some(trap_code) = reason.trap_code() {
        return Err(ExecutionOutcome::from(trap_code));
    }
    state.execution_outcome()
}