wasmparser 0.247.0

A simple event-driven library for parsing WebAssembly binary files.
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

use super::{Frame, MaybeType, Vec};
use core::mem;

#[derive(Clone, PartialEq)]
pub enum Transaction {
    Active(RollbackLog),
    Inactive(RollbackLogAllocations),
}

#[derive(Clone, Default, PartialEq)]
pub struct RollbackLog {
    /// A trace of operands popped. Pushes are recorded as `None`.
    pub operands: Vec<Option<MaybeType>>,

    /// A trace of frames popped. Pushes are recorded as `None`.
    pub frames: Vec<Option<Frame>>,

    /// A trace of local init indices reset at the end of a frame.
    pub inits: Vec<u32>,

    /// The local init height when transaction was begun.
    pub init_height: usize,

    /// Whether the current frame was made unreachable.
    pub unreachable: bool,
}

#[derive(Clone, Default, PartialEq)]
pub struct RollbackLogAllocations {
    operands: Vec<Option<MaybeType>>,
    frames: Vec<Option<Frame>>,
    inits: Vec<u32>,
}

impl Transaction {
    pub fn new(allocs: RollbackLogAllocations) -> Self {
        Transaction::Inactive(allocs)
    }

    pub fn begin(&mut self, init_height: usize) {
        match self {
            Transaction::Active(_) => panic!("transaction already in progress"),
            Transaction::Inactive(allocs) => {
                *self = Transaction::Active(RollbackLog::new(init_height, mem::take(allocs)))
            }
        }
    }

    pub fn end(&mut self) {
        if let Transaction::Active(log) = self {
            *self = Transaction::Inactive(mem::take(log).into_allocations())
        }
    }

    pub fn into_allocations(self) -> RollbackLogAllocations {
        match self {
            Transaction::Active(log) => log.into_allocations(),
            Transaction::Inactive(allocs) => allocs,
        }
    }

    pub fn map(&mut self, f: impl FnOnce(&mut RollbackLog)) {
        if let Transaction::Active(log) = self {
            f(log);
        }
    }
}

impl RollbackLog {
    pub fn new(init_height: usize, allocs: RollbackLogAllocations) -> Self {
        let RollbackLogAllocations {
            operands,
            frames,
            inits,
        } = allocs;
        debug_assert!(operands.is_empty());
        debug_assert!(frames.is_empty());
        debug_assert!(inits.is_empty());
        Self {
            operands,
            frames,
            inits,
            init_height,
            unreachable: false,
        }
    }

    pub fn into_allocations(self) -> RollbackLogAllocations {
        fn clear<T>(mut tmp: Vec<T>) -> Vec<T> {
            tmp.clear();
            tmp
        }
        RollbackLogAllocations {
            operands: clear(self.operands),
            frames: clear(self.frames),
            inits: clear(self.inits),
        }
    }

    pub fn record_push(&mut self) {
        self.operands.push(None);
    }

    pub fn record_pop(&mut self, ty: MaybeType) {
        self.operands.push(Some(ty));
    }

    pub fn push_ctrl(&mut self) {
        self.frames.push(None);
    }

    pub fn pop_ctrl(&mut self, frame: Frame, inits: Vec<u32>) {
        self.frames.push(Some(frame));
        self.inits.extend(inits);
    }

    pub fn set_unreachable(&mut self) {
        self.unreachable = true;
    }
}