submilli-wasm 0.2.0

A WebAssembly interpreter with a wasmtime-compatible API, built for fast compilation and startup
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

//! Inline `visit_*` lowering of table ops: the bulk-memory table ops (`table.init/copy`,
//! `elem.drop`) and `table.get/set/size/grow/fill`. Reference *value* ops (`ref.null` etc.) live
//! in [`super::ref_`]. Infallible arms still return `Result<()>` for the uniform visitor delegation.
#![allow(clippy::unnecessary_wraps)]

use super::Translator;
use crate::module::op::Op;
use crate::Result;

/// Inline lowering of table ops (bulk-memory `table.init/copy`, `elem.drop`, and
/// `table.get/set/size/grow/fill`). Each carries its own stack effect.
impl Translator<'_> {
    pub(in crate::module::compile) fn visit_table_init(
        &mut self,
        elem_index: u32,
        table: u32,
    ) -> Result<()> {
        if self.reachable {
            self.consume(3, |s| Op::TableInit {
                elem: elem_index,
                table,
                s,
            });
        }
        Ok(())
    }

    pub(in crate::module::compile) fn visit_table_copy(
        &mut self,
        dst_table: u32,
        src_table: u32,
    ) -> Result<()> {
        if self.reachable {
            self.consume(3, |s| Op::TableCopy {
                dst_table,
                src_table,
                s,
            });
        }
        Ok(())
    }

    pub(in crate::module::compile) fn visit_elem_drop(&mut self, elem_index: u32) -> Result<()> {
        if self.reachable {
            self.emit(Op::ElemDrop(elem_index));
        }
        Ok(())
    }

    pub(in crate::module::compile) fn visit_table_get(&mut self, table: u32) -> Result<()> {
        if self.reachable {
            self.in_place(1, |s| Op::TableGet(table, s));
        }
        Ok(())
    }

    pub(in crate::module::compile) fn visit_table_set(&mut self, table: u32) -> Result<()> {
        if self.reachable {
            self.consume(2, |s| Op::TableSet(table, s));
        }
        Ok(())
    }

    pub(in crate::module::compile) fn visit_table_size(&mut self, table: u32) -> Result<()> {
        if self.reachable {
            self.constop(|s| Op::TableSize(table, s));
        }
        Ok(())
    }

    pub(in crate::module::compile) fn visit_table_grow(&mut self, table: u32) -> Result<()> {
        if self.reachable {
            self.in_place(2, |s| Op::TableGrow(table, s));
        }
        Ok(())
    }

    pub(in crate::module::compile) fn visit_table_fill(&mut self, table: u32) -> Result<()> {
        if self.reachable {
            self.consume(3, |s| Op::TableFill(table, s));
        }
        Ok(())
    }
}