submilli-wasm 0.1.11

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
85
86
87
88
89
90
91
92
93
94

//! Type-section decoding: wasm rec groups → module-relative IR [`ModuleType`]s. Kinds of all
//! types are resolved first so forward/recursive references inside a rec group convert cleanly;
//! engine interning (canonical ids) happens later, in `ModuleInner::intern`.

use crate::canon::{AggKind, CompositeBody, IrField, IrStorage, IrVal, ModuleType};
use crate::module::compile::conv_valtype;
use crate::value::Finality;
use crate::{Error, Result};

fn wp_err(e: wasmparser::BinaryReaderError) -> Error {
    Error::msg(e.to_string())
}

pub(super) fn parse_types(
    out: &mut Vec<ModuleType>,
    reader: wasmparser::TypeSectionReader<'_>,
) -> Result<()> {
    let mut raw: Vec<(u32, wasmparser::SubType)> = Vec::new();
    for (group, rec) in reader.into_iter().enumerate() {
        for sub in rec.map_err(wp_err)?.into_types() {
            raw.push((group as u32, sub));
        }
    }
    let kinds: Vec<AggKind> = raw
        .iter()
        .map(|(_, s)| composite_kind(&s.composite_type.inner))
        .collect::<Result<_>>()?;
    for (g, sub) in &raw {
        let finality = if sub.is_final {
            Finality::Final
        } else {
            Finality::NonFinal
        };
        let supertype = sub.supertype_idx.and_then(|p| p.unpack().as_module_index());
        let body = conv_composite(&kinds, &sub.composite_type.inner)?;
        out.push(ModuleType {
            group: *g,
            finality,
            supertype,
            body,
        });
    }
    Ok(())
}

fn composite_kind(inner: &wasmparser::CompositeInnerType) -> Result<AggKind> {
    use wasmparser::CompositeInnerType as C;
    Ok(match inner {
        C::Func(_) => AggKind::Func,
        C::Struct(_) => AggKind::Struct,
        C::Array(_) => AggKind::Array,
        C::Cont(_) => return Err(Error::msg("continuation types not supported")),
    })
}

fn conv_composite(
    kinds: &[AggKind],
    inner: &wasmparser::CompositeInnerType,
) -> Result<CompositeBody> {
    use wasmparser::CompositeInnerType as C;
    Ok(match inner {
        C::Func(ft) => CompositeBody::Func {
            params: conv_valtypes(kinds, ft.params())?,
            results: conv_valtypes(kinds, ft.results())?,
        },
        C::Struct(st) => CompositeBody::Struct(
            st.fields
                .iter()
                .map(|f| conv_fieldtype(kinds, f))
                .collect::<Result<_>>()?,
        ),
        C::Array(at) => CompositeBody::Array(conv_fieldtype(kinds, &at.0)?),
        C::Cont(_) => return Err(Error::msg("continuation types not supported")),
    })
}

fn conv_fieldtype(kinds: &[AggKind], f: &wasmparser::FieldType) -> Result<IrField> {
    let storage = match f.element_type {
        wasmparser::StorageType::I8 => IrStorage::I8,
        wasmparser::StorageType::I16 => IrStorage::I16,
        wasmparser::StorageType::Val(v) => IrStorage::Val(conv_valtype(kinds, v)?),
    };
    Ok(IrField {
        mutable: f.mutable,
        storage,
    })
}

fn conv_valtypes(kinds: &[AggKind], tys: &[wasmparser::ValType]) -> Result<Vec<IrVal>> {
    tys.iter()
        .copied()
        .map(|t| conv_valtype(kinds, t))
        .collect()
}