wasmer_vm/
vmcontext.rs

1// This file contains code from external sources.
2// Attributions: https://github.com/wasmerio/wasmer/blob/main/docs/ATTRIBUTIONS.md
3
4//! This file declares `VMContext` and several related structs which contain
5//! fields that compiled wasm code accesses directly.
6
7use crate::VMFunctionBody;
8use crate::VMTable;
9use crate::global::VMGlobal;
10use crate::instance::Instance;
11use crate::memory::VMMemory;
12use crate::store::InternalStoreHandle;
13use crate::trap::{Trap, TrapCode};
14use crate::{VMBuiltinFunctionIndex, VMFunction};
15use std::convert::TryFrom;
16use std::hash::{Hash, Hasher};
17use std::ptr::{self, NonNull};
18use std::sync::atomic::{AtomicU32, AtomicU64, Ordering};
19use wasmer_types::RawValue;
20
21/// Union representing the first parameter passed when calling a function.
22///
23/// It may either be a pointer to the [`VMContext`] if it's a Wasm function
24/// or a pointer to arbitrary data controlled by the host if it's a host function.
25#[derive(Copy, Clone, Eq)]
26#[repr(C)]
27pub union VMFunctionContext {
28    /// Wasm functions take a pointer to [`VMContext`].
29    pub vmctx: *mut VMContext,
30    /// Host functions can have custom environments.
31    pub host_env: *mut std::ffi::c_void,
32}
33
34impl VMFunctionContext {
35    /// Check whether the pointer stored is null or not.
36    pub fn is_null(&self) -> bool {
37        unsafe { self.host_env.is_null() }
38    }
39}
40
41impl std::fmt::Debug for VMFunctionContext {
42    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
43        f.debug_struct("VMFunctionContext")
44            .field("vmctx_or_hostenv", unsafe { &self.host_env })
45            .finish()
46    }
47}
48
49impl std::cmp::PartialEq for VMFunctionContext {
50    fn eq(&self, rhs: &Self) -> bool {
51        unsafe { std::ptr::eq(self.host_env, rhs.host_env) }
52    }
53}
54
55impl std::hash::Hash for VMFunctionContext {
56    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
57        unsafe {
58            self.vmctx.hash(state);
59        }
60    }
61}
62
63/// An imported function.
64#[derive(Debug, Copy, Clone)]
65#[repr(C)]
66pub struct VMFunctionImport {
67    /// A pointer to the imported function body.
68    pub body: *const VMFunctionBody,
69
70    /// A pointer to the `VMContext` that owns the function or host env data.
71    pub environment: VMFunctionContext,
72
73    /// Handle to the `VMFunction` in the context.
74    pub handle: InternalStoreHandle<VMFunction>,
75
76    /// Flag if the function requires extra the m0 argument (used for m0 optimization dispatch).
77    pub include_m0_param: bool,
78}
79
80#[cfg(test)]
81mod test_vmfunction_import {
82    use super::VMFunctionImport;
83    use memoffset::offset_of;
84    use std::mem::size_of;
85    use wasmer_types::ModuleInfo;
86    use wasmer_types::VMOffsets;
87
88    #[test]
89    fn check_vmfunction_import_offsets() {
90        let module = ModuleInfo::new();
91        let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module);
92        assert_eq!(
93            size_of::<VMFunctionImport>(),
94            usize::from(offsets.size_of_vmfunction_import())
95        );
96        assert_eq!(
97            offset_of!(VMFunctionImport, body),
98            usize::from(offsets.vmfunction_import_body())
99        );
100        assert_eq!(
101            offset_of!(VMFunctionImport, environment),
102            usize::from(offsets.vmfunction_import_vmctx())
103        );
104    }
105}
106
107/// The `VMDynamicFunctionContext` is the context that dynamic
108/// functions will receive when called (rather than `vmctx`).
109/// A dynamic function is a function for which we don't know the signature
110/// until runtime.
111///
112/// As such, we need to expose the dynamic function `context`
113/// containing the relevant context for running the function indicated
114/// in `address`.
115#[repr(C)]
116pub struct VMDynamicFunctionContext<T> {
117    /// The address of the inner dynamic function.
118    ///
119    /// Note: The function must be on the form of
120    /// `(*mut T, SignatureIndex, *mut i128)`.
121    pub address: *const VMFunctionBody,
122
123    /// The context that the inner dynamic function will receive.
124    pub ctx: T,
125}
126
127// The `ctx` itself must be `Send`, `address` can be passed between
128// threads because all usage is `unsafe` and synchronized.
129unsafe impl<T: Sized + Send + Sync> Send for VMDynamicFunctionContext<T> {}
130// The `ctx` itself must be `Sync`, `address` can be shared between
131// threads because all usage is `unsafe` and synchronized.
132unsafe impl<T: Sized + Send + Sync> Sync for VMDynamicFunctionContext<T> {}
133
134impl<T: Sized + Clone + Send + Sync> Clone for VMDynamicFunctionContext<T> {
135    fn clone(&self) -> Self {
136        Self {
137            address: self.address,
138            ctx: self.ctx.clone(),
139        }
140    }
141}
142
143#[cfg(test)]
144mod test_vmdynamicfunction_import_context {
145    use super::VMDynamicFunctionContext;
146    use crate::VMOffsets;
147    use memoffset::offset_of;
148    use std::mem::size_of;
149    use wasmer_types::ModuleInfo;
150
151    #[test]
152    fn check_vmdynamicfunction_import_context_offsets() {
153        let module = ModuleInfo::new();
154        let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module);
155        assert_eq!(
156            size_of::<VMDynamicFunctionContext<usize>>(),
157            usize::from(offsets.size_of_vmdynamicfunction_import_context())
158        );
159        assert_eq!(
160            offset_of!(VMDynamicFunctionContext<usize>, address),
161            usize::from(offsets.vmdynamicfunction_import_context_address())
162        );
163        assert_eq!(
164            offset_of!(VMDynamicFunctionContext<usize>, ctx),
165            usize::from(offsets.vmdynamicfunction_import_context_ctx())
166        );
167    }
168}
169
170/// A function kind is a calling convention into and out of wasm code.
171#[derive(Debug, Copy, Clone, Eq, PartialEq)]
172#[repr(C)]
173pub enum VMFunctionKind {
174    /// A static function has the native signature:
175    /// `extern "C" (vmctx, arg1, arg2...) -> (result1, result2, ...)`.
176    ///
177    /// This is the default for functions that are defined:
178    /// 1. In the Host, natively
179    /// 2. In the WebAssembly file
180    Static,
181
182    /// A dynamic function has the native signature:
183    /// `extern "C" (ctx, &[Value]) -> Vec<Value>`.
184    ///
185    /// This is the default for functions that are defined:
186    /// 1. In the Host, dynamically
187    Dynamic,
188}
189
190/// The fields compiled code needs to access to utilize a WebAssembly table
191/// imported from another instance.
192#[derive(Clone)]
193#[repr(C)]
194pub struct VMTableImport {
195    /// A pointer to the imported table description.
196    pub definition: NonNull<VMTableDefinition>,
197
198    /// Handle to the `VMTable` in the context.
199    pub handle: InternalStoreHandle<VMTable>,
200}
201
202#[cfg(test)]
203mod test_vmtable_import {
204    use super::VMTableImport;
205    use crate::VMOffsets;
206    use memoffset::offset_of;
207    use std::mem::size_of;
208    use wasmer_types::ModuleInfo;
209
210    #[test]
211    fn check_vmtable_import_offsets() {
212        let module = ModuleInfo::new();
213        let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module);
214        assert_eq!(
215            size_of::<VMTableImport>(),
216            usize::from(offsets.size_of_vmtable_import())
217        );
218        assert_eq!(
219            offset_of!(VMTableImport, definition),
220            usize::from(offsets.vmtable_import_definition())
221        );
222    }
223}
224
225/// The fields compiled code needs to access to utilize a WebAssembly linear
226/// memory imported from another instance.
227#[derive(Clone)]
228#[repr(C)]
229pub struct VMMemoryImport {
230    /// A pointer to the imported memory description.
231    pub definition: NonNull<VMMemoryDefinition>,
232
233    /// A handle to the `Memory` that owns the memory description.
234    pub handle: InternalStoreHandle<VMMemory>,
235}
236
237#[cfg(test)]
238mod test_vmmemory_import {
239    use super::VMMemoryImport;
240    use crate::VMOffsets;
241    use memoffset::offset_of;
242    use std::mem::size_of;
243    use wasmer_types::ModuleInfo;
244
245    #[test]
246    fn check_vmmemory_import_offsets() {
247        let module = ModuleInfo::new();
248        let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module);
249        assert_eq!(
250            size_of::<VMMemoryImport>(),
251            usize::from(offsets.size_of_vmmemory_import())
252        );
253        assert_eq!(
254            offset_of!(VMMemoryImport, definition),
255            usize::from(offsets.vmmemory_import_definition())
256        );
257        assert_eq!(
258            offset_of!(VMMemoryImport, handle),
259            usize::from(offsets.vmmemory_import_handle())
260        );
261    }
262}
263
264/// The fields compiled code needs to access to utilize a WebAssembly global
265/// variable imported from another instance.
266#[derive(Clone)]
267#[repr(C)]
268pub struct VMGlobalImport {
269    /// A pointer to the imported global variable description.
270    pub definition: NonNull<VMGlobalDefinition>,
271
272    /// A handle to the `Global` that owns the global description.
273    pub handle: InternalStoreHandle<VMGlobal>,
274}
275
276/// # Safety
277/// This data is safe to share between threads because it's plain data that
278/// is the user's responsibility to synchronize. Additionally, all operations
279/// on `from` are thread-safe through the use of a mutex in [`VMGlobal`].
280unsafe impl Send for VMGlobalImport {}
281/// # Safety
282/// This data is safe to share between threads because it's plain data that
283/// is the user's responsibility to synchronize. And because it's `Clone`, there's
284/// really no difference between passing it by reference or by value as far as
285/// correctness in a multi-threaded context is concerned.
286unsafe impl Sync for VMGlobalImport {}
287
288#[cfg(test)]
289mod test_vmglobal_import {
290    use super::VMGlobalImport;
291    use crate::VMOffsets;
292    use memoffset::offset_of;
293    use std::mem::size_of;
294    use wasmer_types::ModuleInfo;
295
296    #[test]
297    fn check_vmglobal_import_offsets() {
298        let module = ModuleInfo::new();
299        let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module);
300        assert_eq!(
301            size_of::<VMGlobalImport>(),
302            usize::from(offsets.size_of_vmglobal_import())
303        );
304        assert_eq!(
305            offset_of!(VMGlobalImport, definition),
306            usize::from(offsets.vmglobal_import_definition())
307        );
308    }
309}
310
311/// Do an unsynchronized, non-atomic `memory.copy` for the memory.
312///
313/// # Errors
314///
315/// Returns a `Trap` error when the source or destination ranges are out of
316/// bounds.
317///
318/// # Safety
319/// The memory is not copied atomically and is not synchronized: it's the
320/// caller's responsibility to synchronize.
321pub(crate) unsafe fn memory_copy(
322    mem: &VMMemoryDefinition,
323    dst: u32,
324    src: u32,
325    len: u32,
326) -> Result<(), Trap> {
327    unsafe {
328        // https://webassembly.github.io/reference-types/core/exec/instructions.html#exec-memory-copy
329        if src
330            .checked_add(len)
331            .is_none_or(|n| usize::try_from(n).unwrap() > mem.current_length)
332            || dst
333                .checked_add(len)
334                .is_none_or(|m| usize::try_from(m).unwrap() > mem.current_length)
335        {
336            return Err(Trap::lib(TrapCode::HeapAccessOutOfBounds));
337        }
338
339        let dst = usize::try_from(dst).unwrap();
340        let src = usize::try_from(src).unwrap();
341
342        // Bounds and casts are checked above, by this point we know that
343        // everything is safe.
344        let dst = mem.base.add(dst);
345        let src = mem.base.add(src);
346        ptr::copy(src, dst, len as usize);
347
348        Ok(())
349    }
350}
351
352/// Perform the `memory.fill` operation for the memory in an unsynchronized,
353/// non-atomic way.
354///
355/// # Errors
356///
357/// Returns a `Trap` error if the memory range is out of bounds.
358///
359/// # Safety
360/// The memory is not filled atomically and is not synchronized: it's the
361/// caller's responsibility to synchronize.
362pub(crate) unsafe fn memory_fill(
363    mem: &VMMemoryDefinition,
364    dst: u32,
365    val: u32,
366    len: u32,
367) -> Result<(), Trap> {
368    unsafe {
369        if dst
370            .checked_add(len)
371            .is_none_or(|m| usize::try_from(m).unwrap() > mem.current_length)
372        {
373            return Err(Trap::lib(TrapCode::HeapAccessOutOfBounds));
374        }
375
376        let dst = isize::try_from(dst).unwrap();
377        let val = val as u8;
378
379        // Bounds and casts are checked above, by this point we know that
380        // everything is safe.
381        let dst = mem.base.offset(dst);
382        ptr::write_bytes(dst, val, len as usize);
383
384        Ok(())
385    }
386}
387
388/// Perform the `memory32.atomic.check32` operation for the memory. Return 0 if same, 1 if different
389///
390/// # Errors
391///
392/// Returns a `Trap` error if the memory range is out of bounds or 32bits unligned.
393///
394/// # Safety
395/// memory access is unsafe
396pub(crate) unsafe fn memory32_atomic_check32(
397    mem: &VMMemoryDefinition,
398    dst: u32,
399    val: u32,
400) -> Result<u32, Trap> {
401    unsafe {
402        if usize::try_from(dst).unwrap() > mem.current_length {
403            return Err(Trap::lib(TrapCode::HeapAccessOutOfBounds));
404        }
405
406        let dst = isize::try_from(dst).unwrap();
407        if dst & 0b11 != 0 {
408            return Err(Trap::lib(TrapCode::UnalignedAtomic));
409        }
410
411        // Bounds and casts are checked above, by this point we know that
412        // everything is safe.
413        let dst = mem.base.offset(dst) as *mut u32;
414        let read_val = AtomicU32::from_ptr(dst).load(Ordering::Acquire);
415        let ret = if read_val == val { 0 } else { 1 };
416        Ok(ret)
417    }
418}
419
420/// Perform the `memory32.atomic.check64` operation for the memory. Return 0 if same, 1 if different
421///
422/// # Errors
423///
424/// Returns a `Trap` error if the memory range is out of bounds or 64bits unaligned.
425///
426/// # Safety
427/// memory access is unsafe
428pub(crate) unsafe fn memory32_atomic_check64(
429    mem: &VMMemoryDefinition,
430    dst: u32,
431    val: u64,
432) -> Result<u32, Trap> {
433    unsafe {
434        if usize::try_from(dst).unwrap() > mem.current_length {
435            return Err(Trap::lib(TrapCode::HeapAccessOutOfBounds));
436        }
437
438        let dst = isize::try_from(dst).unwrap();
439        if dst & 0b111 != 0 {
440            return Err(Trap::lib(TrapCode::UnalignedAtomic));
441        }
442
443        // Bounds and casts are checked above, by this point we know that
444        // everything is safe.
445        let dst = mem.base.offset(dst) as *mut u64;
446        let read_val = AtomicU64::from_ptr(dst).load(Ordering::Acquire);
447        let ret = if read_val == val { 0 } else { 1 };
448        Ok(ret)
449    }
450}
451
452/// The fields compiled code needs to access to utilize a WebAssembly table
453/// defined within the instance.
454#[derive(Debug, Clone, Copy)]
455#[repr(C)]
456pub struct VMTableDefinition {
457    /// Pointer to the table data.
458    pub base: *mut u8,
459
460    /// The current number of elements in the table.
461    pub current_elements: u32,
462}
463
464#[cfg(test)]
465mod test_vmtable_definition {
466    use super::VMTableDefinition;
467    use crate::VMOffsets;
468    use memoffset::offset_of;
469    use std::mem::size_of;
470    use wasmer_types::ModuleInfo;
471
472    #[test]
473    fn check_vmtable_definition_offsets() {
474        let module = ModuleInfo::new();
475        let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module);
476        assert_eq!(
477            size_of::<VMTableDefinition>(),
478            usize::from(offsets.size_of_vmtable_definition())
479        );
480        assert_eq!(
481            offset_of!(VMTableDefinition, base),
482            usize::from(offsets.vmtable_definition_base())
483        );
484        assert_eq!(
485            offset_of!(VMTableDefinition, current_elements),
486            usize::from(offsets.vmtable_definition_current_elements())
487        );
488    }
489}
490
491/// The storage for a WebAssembly global defined within the instance.
492///
493/// TODO: Pack the globals more densely, rather than using the same size
494/// for every type.
495#[derive(Debug, Clone)]
496#[repr(C, align(16))]
497pub struct VMGlobalDefinition {
498    /// Raw value of the global.
499    pub val: RawValue,
500}
501
502#[cfg(test)]
503mod test_vmglobal_definition {
504    use super::VMGlobalDefinition;
505    use crate::{VMFuncRef, VMOffsets};
506    use more_asserts::assert_ge;
507    use std::mem::{align_of, size_of};
508    use wasmer_types::ModuleInfo;
509
510    #[test]
511    fn check_vmglobal_definition_alignment() {
512        assert_ge!(align_of::<VMGlobalDefinition>(), align_of::<i32>());
513        assert_ge!(align_of::<VMGlobalDefinition>(), align_of::<i64>());
514        assert_ge!(align_of::<VMGlobalDefinition>(), align_of::<f32>());
515        assert_ge!(align_of::<VMGlobalDefinition>(), align_of::<f64>());
516        assert_ge!(align_of::<VMGlobalDefinition>(), align_of::<VMFuncRef>());
517        assert_ge!(align_of::<VMGlobalDefinition>(), align_of::<[u8; 16]>());
518    }
519
520    #[test]
521    fn check_vmglobal_definition_offsets() {
522        let module = ModuleInfo::new();
523        let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module);
524        assert_eq!(
525            size_of::<VMGlobalDefinition>(),
526            usize::from(offsets.size_of_vmglobal_local())
527        );
528    }
529
530    #[test]
531    fn check_vmglobal_begins_aligned() {
532        let module = ModuleInfo::new();
533        let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module);
534        assert_eq!(offsets.vmctx_globals_begin() % 16, 0);
535    }
536}
537
538impl VMGlobalDefinition {
539    /// Construct a `VMGlobalDefinition`.
540    pub fn new() -> Self {
541        Self {
542            val: Default::default(),
543        }
544    }
545}
546
547/// A tag index, unique within the Store in which the instance was created.
548/// Usable for translating module-local tag indices to store-unique ones.
549#[repr(C)]
550#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
551pub struct VMSharedTagIndex(u32);
552
553impl VMSharedTagIndex {
554    /// Create a new `VMSharedTagIndex`.
555    pub fn new(value: u32) -> Self {
556        Self(value)
557    }
558
559    /// Get the inner value.
560    pub fn index(&self) -> u32 {
561        self.0
562    }
563}
564
565/// An index into the shared signature registry, usable for checking signatures
566/// at indirect calls.
567#[repr(C)]
568#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
569#[derive(Debug, Eq, PartialEq, Clone, Copy, Hash)]
570pub struct VMSignatureHash(u32);
571
572impl VMSignatureHash {
573    /// Create a new `VMSignatureHash`.
574    pub fn new(value: u32) -> Self {
575        Self(value)
576    }
577}
578
579/// The VM caller-checked "anyfunc" record, for caller-side signature checking.
580/// It consists of the actual function pointer and a signature id to be checked
581/// by the caller.
582#[derive(Debug, Clone, Copy)]
583#[repr(C)]
584pub struct VMCallerCheckedAnyfunc {
585    /// Function body.
586    pub func_ptr: *const VMFunctionBody,
587    /// Function signature id.
588    pub type_signature_hash: VMSignatureHash,
589    /// Function `VMContext` or host env.
590    pub vmctx: VMFunctionContext,
591    /// Address of the function call trampoline to invoke this function using
592    /// a dynamic argument list.
593    pub call_trampoline: VMTrampoline,
594    // If more elements are added here, remember to add offset_of tests below!
595}
596
597unsafe extern "C" fn null_call_trampoline(
598    _vmctx: *mut VMContext,
599    _callee: *const VMFunctionBody,
600    _values: *mut RawValue,
601) {
602    unreachable!("null funcref trampoline should never be invoked");
603}
604
605impl VMCallerCheckedAnyfunc {
606    /// Construct the sentinel value for an uninitialized `funcref` table entry.
607    pub fn null() -> Self {
608        Self {
609            func_ptr: ptr::null(),
610            type_signature_hash: VMSignatureHash(0),
611            vmctx: VMFunctionContext {
612                host_env: ptr::null_mut(),
613            },
614            call_trampoline: null_call_trampoline,
615        }
616    }
617}
618
619impl PartialEq for VMCallerCheckedAnyfunc {
620    fn eq(&self, other: &Self) -> bool {
621        self.func_ptr == other.func_ptr
622            && self.type_signature_hash == other.type_signature_hash
623            && self.vmctx == other.vmctx
624            && ptr::fn_addr_eq(self.call_trampoline, other.call_trampoline)
625    }
626}
627
628impl Eq for VMCallerCheckedAnyfunc {}
629
630impl Hash for VMCallerCheckedAnyfunc {
631    fn hash<H: Hasher>(&self, state: &mut H) {
632        self.func_ptr.hash(state);
633        self.type_signature_hash.hash(state);
634        self.vmctx.hash(state);
635        ptr::hash(self.call_trampoline as *const (), state);
636    }
637}
638
639#[cfg(test)]
640mod test_vmcaller_checked_anyfunc {
641    use super::VMCallerCheckedAnyfunc;
642    use crate::VMOffsets;
643    use memoffset::offset_of;
644    use std::mem::size_of;
645    use wasmer_types::ModuleInfo;
646
647    #[test]
648    fn check_vmcaller_checked_anyfunc_offsets() {
649        let module = ModuleInfo::new();
650        let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module);
651        assert_eq!(
652            size_of::<VMCallerCheckedAnyfunc>(),
653            usize::from(offsets.size_of_vmcaller_checked_anyfunc())
654        );
655        assert_eq!(
656            offset_of!(VMCallerCheckedAnyfunc, func_ptr),
657            usize::from(offsets.vmcaller_checked_anyfunc_func_ptr())
658        );
659        assert_eq!(
660            offset_of!(VMCallerCheckedAnyfunc, type_signature_hash),
661            usize::from(offsets.vmcaller_checked_anyfunc_signature_hash())
662        );
663        assert_eq!(
664            offset_of!(VMCallerCheckedAnyfunc, vmctx),
665            usize::from(offsets.vmcaller_checked_anyfunc_vmctx())
666        );
667    }
668}
669
670/// An array that stores addresses of builtin functions. We translate code
671/// to use indirect calls. This way, we don't have to patch the code.
672#[repr(C)]
673pub struct VMBuiltinFunctionsArray {
674    ptrs: [usize; Self::len()],
675}
676
677impl VMBuiltinFunctionsArray {
678    pub const fn len() -> usize {
679        VMBuiltinFunctionIndex::builtin_functions_total_number() as usize
680    }
681
682    pub fn initialized() -> Self {
683        use crate::libcalls::*;
684
685        let mut ptrs = [0; Self::len()];
686
687        ptrs[VMBuiltinFunctionIndex::get_memory32_grow_index().index() as *const () as usize] =
688            wasmer_vm_memory32_grow as *const () as usize;
689        ptrs[VMBuiltinFunctionIndex::get_imported_memory32_grow_index().index() as *const ()
690            as usize] = wasmer_vm_imported_memory32_grow as *const () as usize;
691        ptrs[VMBuiltinFunctionIndex::get_memory32_size_index().index() as *const () as usize] =
692            wasmer_vm_memory32_size as *const () as usize;
693        ptrs[VMBuiltinFunctionIndex::get_imported_memory32_size_index().index() as *const ()
694            as usize] = wasmer_vm_imported_memory32_size as *const () as usize;
695        ptrs[VMBuiltinFunctionIndex::get_table_copy_index().index() as *const () as usize] =
696            wasmer_vm_table_copy as *const () as usize;
697        ptrs[VMBuiltinFunctionIndex::get_table_init_index().index() as *const () as usize] =
698            wasmer_vm_table_init as *const () as usize;
699        ptrs[VMBuiltinFunctionIndex::get_elem_drop_index().index() as *const () as usize] =
700            wasmer_vm_elem_drop as *const () as usize;
701        ptrs[VMBuiltinFunctionIndex::get_memory_copy_index().index() as *const () as usize] =
702            wasmer_vm_memory32_copy as *const () as usize;
703        ptrs[VMBuiltinFunctionIndex::get_imported_memory_copy_index().index() as *const ()
704            as usize] = wasmer_vm_imported_memory32_copy as *const () as usize;
705        ptrs[VMBuiltinFunctionIndex::get_memory_fill_index().index() as *const () as usize] =
706            wasmer_vm_memory32_fill as *const () as usize;
707        ptrs[VMBuiltinFunctionIndex::get_imported_memory_fill_index().index() as *const ()
708            as usize] = wasmer_vm_imported_memory32_fill as *const () as usize;
709        ptrs[VMBuiltinFunctionIndex::get_memory_init_index().index() as *const () as usize] =
710            wasmer_vm_memory32_init as *const () as usize;
711        ptrs[VMBuiltinFunctionIndex::get_data_drop_index().index() as *const () as usize] =
712            wasmer_vm_data_drop as *const () as usize;
713        ptrs[VMBuiltinFunctionIndex::get_raise_trap_index().index() as *const () as usize] =
714            wasmer_vm_raise_trap as *const () as usize;
715        ptrs[VMBuiltinFunctionIndex::get_table_size_index().index() as *const () as usize] =
716            wasmer_vm_table_size as *const () as usize;
717        ptrs[VMBuiltinFunctionIndex::get_imported_table_size_index().index() as *const ()
718            as usize] = wasmer_vm_imported_table_size as *const () as usize;
719        ptrs[VMBuiltinFunctionIndex::get_table_grow_index().index() as *const () as usize] =
720            wasmer_vm_table_grow as *const () as usize;
721        ptrs[VMBuiltinFunctionIndex::get_imported_table_grow_index().index() as *const ()
722            as usize] = wasmer_vm_imported_table_grow as *const () as usize;
723        ptrs[VMBuiltinFunctionIndex::get_table_get_index().index() as *const () as usize] =
724            wasmer_vm_table_get as *const () as usize;
725        ptrs[VMBuiltinFunctionIndex::get_imported_table_get_index().index() as *const ()
726            as usize] = wasmer_vm_imported_table_get as *const () as usize;
727        ptrs[VMBuiltinFunctionIndex::get_table_set_index().index() as usize] =
728            wasmer_vm_table_set as *const () as usize;
729        ptrs[VMBuiltinFunctionIndex::get_imported_table_set_index().index() as usize] =
730            wasmer_vm_imported_table_set as *const () as usize;
731        ptrs[VMBuiltinFunctionIndex::get_func_ref_index().index() as usize] =
732            wasmer_vm_func_ref as *const () as usize;
733        ptrs[VMBuiltinFunctionIndex::get_table_fill_index().index() as usize] =
734            wasmer_vm_table_fill as *const () as usize;
735        ptrs[VMBuiltinFunctionIndex::get_memory_atomic_wait32_index().index() as usize] =
736            wasmer_vm_memory32_atomic_wait32 as *const () as usize;
737        ptrs[VMBuiltinFunctionIndex::get_imported_memory_atomic_wait32_index().index() as usize] =
738            wasmer_vm_imported_memory32_atomic_wait32 as *const () as usize;
739        ptrs[VMBuiltinFunctionIndex::get_memory_atomic_wait64_index().index() as usize] =
740            wasmer_vm_memory32_atomic_wait64 as *const () as usize;
741        ptrs[VMBuiltinFunctionIndex::get_imported_memory_atomic_wait64_index().index() as usize] =
742            wasmer_vm_imported_memory32_atomic_wait64 as *const () as usize;
743        ptrs[VMBuiltinFunctionIndex::get_memory_atomic_notify_index().index() as usize] =
744            wasmer_vm_memory32_atomic_notify as *const () as usize;
745        ptrs[VMBuiltinFunctionIndex::get_imported_memory_atomic_notify_index().index() as usize] =
746            wasmer_vm_imported_memory32_atomic_notify as *const () as usize;
747        ptrs[VMBuiltinFunctionIndex::get_imported_debug_usize_index().index() as usize] =
748            wasmer_vm_dbg_usize as *const () as usize;
749        ptrs[VMBuiltinFunctionIndex::get_imported_debug_str_index().index() as usize] =
750            wasmer_vm_dbg_str as *const () as usize;
751        ptrs[VMBuiltinFunctionIndex::get_imported_personality2_index().index() as usize] =
752            wasmer_eh_personality2 as *const () as usize;
753        ptrs[VMBuiltinFunctionIndex::get_imported_alloc_exception_index().index() as usize] =
754            wasmer_vm_alloc_exception as *const () as usize;
755        ptrs[VMBuiltinFunctionIndex::get_imported_throw_index().index() as usize] =
756            wasmer_vm_throw as *const () as usize;
757        ptrs[VMBuiltinFunctionIndex::get_imported_read_exnref_index().index() as usize] =
758            wasmer_vm_read_exnref as *const () as usize;
759        ptrs[VMBuiltinFunctionIndex::get_imported_exception_into_exnref_index().index() as usize] =
760            wasmer_vm_exception_into_exnref as *const () as usize;
761
762        debug_assert!(ptrs.iter().cloned().all(|p| p != 0));
763
764        Self { ptrs }
765    }
766}
767
768/// The VM "context", which is pointed to by the `vmctx` arg in the compiler.
769/// This has information about globals, memories, tables, and other runtime
770/// state associated with the current instance.
771///
772/// The struct here is empty, as the sizes of these fields are dynamic, and
773/// we can't describe them in Rust's type system. Sufficient memory is
774/// allocated at runtime.
775///
776/// TODO: We could move the globals into the `vmctx` allocation too.
777#[derive(Debug)]
778#[repr(C, align(16))] // align 16 since globals are aligned to that and contained inside
779pub struct VMContext {}
780
781impl VMContext {
782    /// Return a mutable reference to the associated `Instance`.
783    ///
784    /// # Safety
785    /// This is unsafe because it doesn't work on just any `VMContext`, it must
786    /// be a `VMContext` allocated as part of an `Instance`.
787    #[allow(clippy::cast_ptr_alignment)]
788    #[inline]
789    pub(crate) unsafe fn instance(&self) -> &Instance {
790        unsafe {
791            &*((self as *const Self as *mut u8).offset(-Instance::vmctx_offset())
792                as *const Instance)
793        }
794    }
795
796    #[inline]
797    pub(crate) unsafe fn instance_mut(&mut self) -> &mut Instance {
798        unsafe {
799            &mut *((self as *const Self as *mut u8).offset(-Instance::vmctx_offset())
800                as *mut Instance)
801        }
802    }
803}
804
805/// The type for tramplines in the VM.
806pub type VMTrampoline = unsafe extern "C" fn(
807    *mut VMContext,        // callee vmctx
808    *const VMFunctionBody, // function we're actually calling
809    *mut RawValue,         // space for arguments and return values
810);
811
812/// The fields compiled code needs to access to utilize a WebAssembly linear
813/// memory defined within the instance, namely the start address and the
814/// size in bytes.
815#[derive(Debug, Copy, Clone)]
816#[repr(C)]
817pub struct VMMemoryDefinition {
818    /// The start address which is always valid, even if the memory grows.
819    pub base: *mut u8,
820
821    /// The current logical size of this linear memory in bytes.
822    pub current_length: usize,
823}
824
825/// # Safety
826/// This data is safe to share between threads because it's plain data that
827/// is the user's responsibility to synchronize.
828unsafe impl Send for VMMemoryDefinition {}
829/// # Safety
830/// This data is safe to share between threads because it's plain data that
831/// is the user's responsibility to synchronize. And it's `Copy` so there's
832/// really no difference between passing it by reference or by value as far as
833/// correctness in a multi-threaded context is concerned.
834unsafe impl Sync for VMMemoryDefinition {}
835
836#[cfg(test)]
837mod test_vmmemory_definition {
838    use super::VMMemoryDefinition;
839    use crate::VMOffsets;
840    use memoffset::offset_of;
841    use std::mem::size_of;
842    use wasmer_types::ModuleInfo;
843
844    #[test]
845    fn check_vmmemory_definition_offsets() {
846        let module = ModuleInfo::new();
847        let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module);
848        assert_eq!(
849            size_of::<VMMemoryDefinition>(),
850            usize::from(offsets.size_of_vmmemory_definition())
851        );
852        assert_eq!(
853            offset_of!(VMMemoryDefinition, base),
854            usize::from(offsets.vmmemory_definition_base())
855        );
856        assert_eq!(
857            offset_of!(VMMemoryDefinition, current_length),
858            usize::from(offsets.vmmemory_definition_current_length())
859        );
860    }
861}
wasmer_vm/vmcontext.rs

wasmer_vm/
vmcontext.rs
