dfwasm-compiler 0.1.0

The dfwasm compiler
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

/*
WASM State:
- Compile Time:
    - Functions:
        - Defined functions are indexed
        - Signatures known from Type section
        - Imported functions also occupy indices
    - Table(s)
        - Initial Size and Type (only funcref atm)
        - Maximum Size if specified
        - Static Elements using (elem)
    - Memories
        - Initial and optional max size (in 64KiB pages)
        - Export status
        - Whether shared
        - Contents are not static, but the type of memory is
    - Globals
        - Types, mutability
        - Initial values (whether it be static or import/global)
    - Imports
        - Module and field names
        - Type of import
        - Type signatures of memory/table/global
        - Index of memory/table/global
    - Exports
        - Name (not module name)
        - Type of export (func/memory/global/table)
        - Indices
- At Execution:
    - Imports
        - Resolved into actual references: i.e. functions, memories, tables, or globals
    - Execution Stack / Frame Stack
        - StackFrame[]
        - Locals stack
            - Map<localIndex, Value>
        - Operand stack
            - Value[]
    - Memories
        - Map<memoryIndex, Map<address, Value>>
        - Size of memory (can grow via `memory.grow`)
    - Global(s) State
        - Map<globalIndex, Value>
        - Mutable globals are mutable, immutable variables are constant
    - Table(s) State
        - Map<tableIndex, Value[]>
        - Can be modified at runtime
*/
use thiserror::Error;
use wasmparser::BinaryReaderError;

mod compiler;
mod df_helper;
mod operators;
mod sections;

type DFWasmResult<T> = std::result::Result<T, DFWasmError>;

#[derive(Error, Debug)]
pub enum DFWasmError {
    #[error("error: {0}")]
    ReadError(#[from] BinaryReaderError),

    #[error("error: unsupported WASM version {0}")]
    UnsupportedVersion(u16),
    #[error("error: WASM components are not supported")]
    UnsupportedComponents,
    #[error("error: WASM tags are not supported")]
    UnsupportedTags,
    #[error("error: unsupported const expr")]
    UnsupportedConstExpr,

    #[error("error: unsupported operator {op} at location {location}")]
    UnsupportedOperator { op: String, location: usize },

    #[error("error: tables have a maximum size of 10000")]
    MaximumTableSize,
    #[error("error: multiple memories are not supported")]
    MultipleMemories,
    #[error("error: multiple start methods are not supported")]
    MultipleStartMethods,

    #[error("error: found unknown section with id {0}")]
    UnknownSection(u8),
    #[error("error: unknown payload")]
    UnknownPayload,

    #[error("error: {0} are not yet implemented")]
    NotYetImplemented(&'static str),
}

pub use compiler::{DFWasmCompiler, DFWasmCompilerOptions};