rwasm 0.4.3

ZK-friendly WebAssembly runtime optimized for blockchain and zero-knowledge applications
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

use crate::types::Opcode;

/// The instruction pointer to the instruction of a function on the call stack.
#[derive(Debug, Copy, Clone, PartialEq)]
#[repr(transparent)]
pub struct InstructionPtr {
    /// The pointer to the instruction.
    pub(crate) ptr: *const Opcode,
}

/// It is safe to send an [`rwasm::engine::code_map::InstructionPtr`] to another thread.
///
/// The access to the pointed-to [`Opcode`] is read-only and
/// [`Opcode`] itself is [`Send`].
///
/// However, it is not safe to share an [`rwasm::engine::code_map::InstructionPtr`] between threads
/// due to their [`rwasm::engine::code_map::InstructionPtr::offset`] method which relinks the
/// internal pointer and is not synchronized.
unsafe impl Send for InstructionPtr {}

impl InstructionPtr {
    /// Creates a new [`rwasm::engine::code_map::InstructionPtr`] for `instr`.
    #[inline]
    pub fn new(ptr: *const Opcode) -> Self {
        Self { ptr }
    }

    /// Offset the [`rwasm::engine::code_map::InstructionPtr`] by the given value.
    ///
    /// # Safety
    ///
    /// The caller is responsible for calling this method only with valid
    /// offset values so that the [`rwasm::engine::code_map::InstructionPtr`] never points out of
    /// valid bounds of the instructions of the same compiled Wasm function.
    #[inline(always)]
    pub fn offset(&mut self, by: isize) {
        // SAFETY: Within Wasm bytecode execution we are guaranteed by
        //         Wasm validation and `rwasm` codegen to never run out
        //         of valid bounds using this method.
        self.ptr = unsafe { self.ptr.offset(by) };
    }

    #[inline(always)]
    pub fn add(&mut self, delta: usize) {
        // SAFETY: Within Wasm bytecode execution we are guaranteed by
        //         Wasm validation and `rwasm` codegen to never run out
        //         of valid bounds using this method.
        self.ptr = unsafe { self.ptr.add(delta) };
    }

    /// Returns a shared reference to the currently pointed at [`Opcode`].
    ///
    /// # Safety
    ///
    /// The caller is responsible for calling this method only when it is
    /// guaranteed that the [`rwasm::engine::code_map::InstructionPtr`] is validly pointing inside
    /// the boundaries of its associated compiled Wasm function.
    #[inline(always)]
    pub fn get(&self) -> Opcode {
        // SAFETY: Within Wasm bytecode execution we are guaranteed by
        //         Wasm validation and `rwasm` codegen to never run out
        //         of valid bounds using this method.
        unsafe { *self.ptr }
    }

    #[cfg(feature = "tracing")]
    pub fn is_valid(self, max: u64) -> bool {
        self.ptr as u64 <= max
    }
}