wasmi 2.0.0-beta.8

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
131
132
133
134
135
136
137

// These limits mirror the WebAssembly JS-API implementation-defined limits
// (https://webassembly.github.io/spec/js-api/#limits).

use core::fmt;

const MAX_MODULE_SIZE: usize = 1_073_741_824; // 1 GiB
const MAX_TYPE_COUNT: usize = 1_000_000;
const MAX_IMPORT_COUNT: usize = 1_000_000;
const MAX_FUNC_COUNT: usize = 1_000_000;
const MAX_FUNC_PARAM_COUNT: usize = 1_000;
const MAX_FUNC_RESULT_COUNT: usize = 1_000;
const MAX_TABLE_COUNT: usize = 100_000;
const MAX_TABLE_SIZE: usize = 10_000_000;
const MAX_TABLE_INIT_SIZE: usize = 10_000_000;
const MAX_MEMORY_COUNT: usize = 100;
const MAX_GLOBAL_COUNT: usize = 1_000_000;
const MAX_EXPORT_COUNT: usize = 1_000_000;
const MAX_ELEM_COUNT: usize = 100_000;
const MAX_ELEM_SIZE: usize = 10_000_000;
const MAX_FUNC_LOCAL_COUNT: usize = 50_000;
const MAX_FUNC_BODY_SIZE: usize = 7_654_321;
const MAX_DATA_COUNT: usize = 1_000_000;
const MAX_DATA_SIZE: usize = 1_000_000;

#[derive(Debug, Copy, Clone)]
pub enum LimitsError {
    /// Wasm module contains too many bytes.
    ModuleTooBig,
    /// Wasm module uses too many types.
    TooManyTypes,
    /// Wasm module has too many imports.
    TooManyImports,
    /// Wasm module declares too many functions.
    TooManyFunctions,
    /// Function has too many parameters.
    TooManyFuncParams,
    /// Function has too many results.
    TooManyFuncResults,
    /// Wasm module has too many tables.
    TooManyTables,
    /// Table has too many elements.
    TableTooBig,
    /// Table initializer has too many elements.
    TableInitTooBig,
    /// Wasm module has too many linear memories.
    TooManyMemories,
    /// Wasm module has too many global variables.
    TooManyGlobals,
    /// Wasm module has too many exports.
    TooManyExports,
    /// Wasm module has too many element segments.
    TooManyElementSegments,
    /// Element segment has too many elements.
    ElementSegmentTooBig,
    /// Wasm module has too many data segments.
    TooManyDataSegments,
    /// Data segment contains too many bytes.
    DataSegmentTooBig,
    /// Function defines too many local variables (including parameters).
    TooManyFunctionLocals,
    /// Function body contains too many bytes.
    FunctionBodyTooBig,
    /// Instance has too many handles.
    TooManyInstanceHandles,
}

impl core::error::Error for LimitsError {}

macro_rules! impl_limits_error {
    (
        $(
            pub fn $name:ident(len: usize) -> Result<(), Self> = ($limit:expr, Self::$err:ident);
        )*
        $(;)?
    ) => {
        $(
            #[doc = concat!("Returns `Ok` if `len` does not exceed `", stringify!($limit), "`.")]
            pub fn $name(len: usize) -> Result<(), Self> {
                if len > $limit {
                    return Err(Self::$err)
                }
                Ok(())
            }
        )*
    };
}
impl LimitsError {
    impl_limits_error! {
        pub fn max_module_size(len: usize) -> Result<(), Self> = (MAX_MODULE_SIZE, Self::ModuleTooBig);
        pub fn max_type_count(len: usize) -> Result<(), Self> = (MAX_TYPE_COUNT, Self::TooManyTypes);
        pub fn max_import_count(len: usize) -> Result<(), Self> = (MAX_IMPORT_COUNT, Self::TooManyImports);
        pub fn max_func_count(len: usize) -> Result<(), Self> = (MAX_FUNC_COUNT, Self::TooManyFunctions);
        pub fn max_func_param_count(len: usize) -> Result<(), Self> = (MAX_FUNC_PARAM_COUNT, Self::TooManyFuncParams);
        pub fn max_func_result_count(len: usize) -> Result<(), Self> = (MAX_FUNC_RESULT_COUNT, Self::TooManyFuncResults);
        pub fn max_table_count(len: usize) -> Result<(), Self> = (MAX_TABLE_COUNT, Self::TooManyTables);
        pub fn max_table_size(len: usize) -> Result<(), Self> = (MAX_TABLE_SIZE, Self::TableTooBig);
        pub fn max_table_init_size(len: usize) -> Result<(), Self> = (MAX_TABLE_INIT_SIZE, Self::TableInitTooBig);
        pub fn max_memory_count(len: usize) -> Result<(), Self> = (MAX_MEMORY_COUNT, Self::TooManyMemories);
        pub fn max_global_count(len: usize) -> Result<(), Self> = (MAX_GLOBAL_COUNT, Self::TooManyGlobals);
        pub fn max_export_count(len: usize) -> Result<(), Self> = (MAX_EXPORT_COUNT, Self::TooManyExports);
        pub fn max_elem_count(len: usize) -> Result<(), Self> = (MAX_ELEM_COUNT, Self::TooManyElementSegments);
        pub fn max_elem_size(len: usize) -> Result<(), Self> = (MAX_ELEM_SIZE, Self::ElementSegmentTooBig);
        pub fn max_func_local_count(len: usize) -> Result<(), Self> = (MAX_FUNC_LOCAL_COUNT, Self::TooManyFunctionLocals);
        pub fn max_func_body_size(len: usize) -> Result<(), Self> = (MAX_FUNC_BODY_SIZE, Self::FunctionBodyTooBig);
        pub fn max_data_count(len: usize) -> Result<(), Self> = (MAX_DATA_COUNT, Self::TooManyDataSegments);
        pub fn max_data_size(len: usize) -> Result<(), Self> = (MAX_DATA_SIZE, Self::DataSegmentTooBig);
    }
}

impl fmt::Display for LimitsError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let s = match self {
            Self::ModuleTooBig => "Wasm module contains too many bytes",
            Self::TooManyTypes => "Wasm module uses too many types",
            Self::TooManyImports => "Wasm module has too many imports",
            Self::TooManyFunctions => "Wasm module declares too many functions",
            Self::TooManyFuncParams => "function has too many parameters",
            Self::TooManyFuncResults => "function has too many results",
            Self::TooManyTables => "Wasm module has too many tables",
            Self::TableTooBig => "table has too many elements",
            Self::TableInitTooBig => "table initializer has too many elements",
            Self::TooManyMemories => "Wasm module has too many linear memories",
            Self::TooManyGlobals => "Wasm module has too many global variables",
            Self::TooManyExports => "Wasm module has too many exports",
            Self::TooManyElementSegments => "Wasm module has too many element segments",
            Self::ElementSegmentTooBig => "element segment has too many elements",
            Self::TooManyDataSegments => "Wasm module has too many data segments",
            Self::DataSegmentTooBig => "data segment contains too many bytes",
            Self::TooManyFunctionLocals => {
                "function defines too many local variables (including parameters)"
            }
            Self::FunctionBodyTooBig => "function body contains too many bytes",
            Self::TooManyInstanceHandles => "instance has too many handles",
        };
        f.write_str(s)
    }
}