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

use super::Executor;
use crate::{
    core::{hint, UntypedVal},
    engine::bytecode::{Const16, GlobalIdx, Register},
    store::StoreInner,
};

#[cfg(doc)]
use crate::engine::bytecode::Instruction;

impl<'engine> Executor<'engine> {
    /// Executes an [`Instruction::GlobalGet`].
    #[inline(always)]
    pub fn execute_global_get(&mut self, store: &StoreInner, result: Register, global: GlobalIdx) {
        let value = match u32::from(global) {
            0 => unsafe { self.cache.global.get() },
            _ => {
                hint::cold();
                let global = self.get_global(global);
                store.resolve_global(&global).get_untyped()
            }
        };
        self.set_register(result, value);
        self.next_instr()
    }

    /// Executes an [`Instruction::GlobalSet`].
    #[inline(always)]
    pub fn execute_global_set(
        &mut self,
        store: &mut StoreInner,
        global: GlobalIdx,
        input: Register,
    ) {
        let input = self.get_register(input);
        self.execute_global_set_impl(store, global, input)
    }

    /// Executes an [`Instruction::GlobalSetI32Imm16`].
    #[inline(always)]
    pub fn execute_global_set_i32imm16(
        &mut self,
        store: &mut StoreInner,
        global: GlobalIdx,
        input: Const16<i32>,
    ) {
        let input = i32::from(input).into();
        self.execute_global_set_impl(store, global, input)
    }

    /// Executes an [`Instruction::GlobalSetI64Imm16`].
    #[inline(always)]
    pub fn execute_global_set_i64imm16(
        &mut self,
        store: &mut StoreInner,
        global: GlobalIdx,
        input: Const16<i64>,
    ) {
        let input = i64::from(input).into();
        self.execute_global_set_impl(store, global, input)
    }

    /// Executes a generic `global.set` instruction.
    #[inline(always)]
    fn execute_global_set_impl(
        &mut self,
        store: &mut StoreInner,
        global: GlobalIdx,
        new_value: UntypedVal,
    ) {
        match u32::from(global) {
            0 => unsafe { self.cache.global.set(new_value) },
            _ => {
                hint::cold();
                let global = self.get_global(global);
                store.resolve_global_mut(&global).set_untyped(new_value)
            }
        };
        self.next_instr()
    }
}