wasmtime/runtime/func/
typed.rs

1use super::invoke_wasm_and_catch_traps;
2use crate::prelude::*;
3use crate::runtime::vm::{VMFuncRef, VMOpaqueContext};
4use crate::store::{AutoAssertNoGc, StoreOpaque};
5use crate::{
6    AsContext, AsContextMut, Engine, Func, FuncType, HeapType, NoFunc, RefType, StoreContextMut,
7    ValRaw, ValType,
8};
9use core::ffi::c_void;
10use core::marker;
11use core::mem::{self, MaybeUninit};
12use core::ptr::{self, NonNull};
13use wasmtime_environ::VMSharedTypeIndex;
14
15/// A statically typed WebAssembly function.
16///
17/// Values of this type represent statically type-checked WebAssembly functions.
18/// The function within a [`TypedFunc`] is statically known to have `Params` as its
19/// parameters and `Results` as its results.
20///
21/// This structure is created via [`Func::typed`] or [`TypedFunc::new_unchecked`].
22/// For more documentation about this see those methods.
23pub struct TypedFunc<Params, Results> {
24    _a: marker::PhantomData<fn(Params) -> Results>,
25    ty: FuncType,
26    func: Func,
27}
28
29impl<Params, Results> Clone for TypedFunc<Params, Results> {
30    fn clone(&self) -> TypedFunc<Params, Results> {
31        Self {
32            _a: marker::PhantomData,
33            ty: self.ty.clone(),
34            func: self.func,
35        }
36    }
37}
38
39impl<Params, Results> TypedFunc<Params, Results>
40where
41    Params: WasmParams,
42    Results: WasmResults,
43{
44    /// An unchecked version of [`Func::typed`] which does not perform a
45    /// typecheck and simply assumes that the type declared here matches the
46    /// type of this function.
47    ///
48    /// The semantics of this function are the same as [`Func::typed`] except
49    /// that no error is returned because no typechecking is done.
50    ///
51    /// # Unsafety
52    ///
53    /// This function only safe to call if `typed` would otherwise return `Ok`
54    /// for the same `Params` and `Results` specified. If `typed` would return
55    /// an error then the returned `TypedFunc` is memory unsafe to invoke.
56    pub unsafe fn new_unchecked(store: impl AsContext, func: Func) -> TypedFunc<Params, Results> {
57        let store = store.as_context().0;
58        Self::_new_unchecked(store, func)
59    }
60
61    pub(crate) unsafe fn _new_unchecked(
62        store: &StoreOpaque,
63        func: Func,
64    ) -> TypedFunc<Params, Results> {
65        let ty = func.load_ty(store);
66        TypedFunc {
67            _a: marker::PhantomData,
68            ty,
69            func,
70        }
71    }
72
73    /// Returns the underlying [`Func`] that this is wrapping, losing the static
74    /// type information in the process.
75    pub fn func(&self) -> &Func {
76        &self.func
77    }
78
79    /// Invokes this WebAssembly function with the specified parameters.
80    ///
81    /// Returns either the results of the call, or a [`Trap`] if one happened.
82    ///
83    /// For more information, see the [`Func::typed`] and [`Func::call`]
84    /// documentation.
85    ///
86    /// # Errors
87    ///
88    /// For more information on errors see the documentation on [`Func::call`].
89    ///
90    /// # Panics
91    ///
92    /// This function will panic if it is called when the underlying [`Func`] is
93    /// connected to an asynchronous store.
94    ///
95    /// [`Trap`]: crate::Trap
96    pub fn call(&self, mut store: impl AsContextMut, params: Params) -> Result<Results> {
97        let mut store = store.as_context_mut();
98        assert!(
99            !store.0.async_support(),
100            "must use `call_async` with async stores"
101        );
102
103        #[cfg(feature = "gc")]
104        if Self::need_gc_before_call_raw(store.0, &params) {
105            store.gc(None);
106        }
107
108        let func = self.func.vm_func_ref(store.0);
109        unsafe { Self::call_raw(&mut store, &self.ty, func, params) }
110    }
111
112    /// Invokes this WebAssembly function with the specified parameters.
113    ///
114    /// Returns either the results of the call, or a [`Trap`] if one happened.
115    ///
116    /// For more information, see the [`Func::typed`] and [`Func::call_async`]
117    /// documentation.
118    ///
119    /// # Errors
120    ///
121    /// For more information on errors see the documentation on [`Func::call`].
122    ///
123    /// # Panics
124    ///
125    /// This function will panic if it is called when the underlying [`Func`] is
126    /// connected to a synchronous store.
127    ///
128    /// [`Trap`]: crate::Trap
129    #[cfg(feature = "async")]
130    pub async fn call_async<T>(
131        &self,
132        mut store: impl AsContextMut<Data = T>,
133        params: Params,
134    ) -> Result<Results>
135    where
136        T: Send,
137    {
138        let mut store = store.as_context_mut();
139        assert!(
140            store.0.async_support(),
141            "must use `call` with non-async stores"
142        );
143
144        #[cfg(feature = "gc")]
145        if Self::need_gc_before_call_raw(store.0, &params) {
146            store.gc_async(None).await?;
147        }
148
149        store
150            .on_fiber(|store| {
151                let func = self.func.vm_func_ref(store.0);
152                unsafe { Self::call_raw(store, &self.ty, func, params) }
153            })
154            .await?
155    }
156
157    #[inline]
158    #[cfg(feature = "gc")]
159    pub(crate) fn need_gc_before_call_raw(_store: &StoreOpaque, _params: &Params) -> bool {
160        {
161            // See the comment in `Func::call_impl_check_args`.
162            let num_gc_refs = _params.vmgcref_pointing_to_object_count();
163            if let Some(num_gc_refs) = core::num::NonZeroUsize::new(num_gc_refs) {
164                return _store
165                    .unwrap_gc_store()
166                    .gc_heap
167                    .need_gc_before_entering_wasm(num_gc_refs);
168            }
169        }
170
171        false
172    }
173
174    /// Do a raw call of a typed function.
175    ///
176    /// # Safety
177    ///
178    /// `func` must be of the given type.
179    ///
180    /// If `Self::need_gc_before_call_raw`, then the caller must have done a GC
181    /// just before calling this method.
182    pub(crate) unsafe fn call_raw<T>(
183        store: &mut StoreContextMut<'_, T>,
184        ty: &FuncType,
185        func: ptr::NonNull<VMFuncRef>,
186        params: Params,
187    ) -> Result<Results> {
188        // double-check that params/results match for this function's type in
189        // debug mode.
190        if cfg!(debug_assertions) {
191            Self::debug_typecheck(store.0, func.as_ref().type_index);
192        }
193
194        // Validate that all runtime values flowing into this store indeed
195        // belong within this store, otherwise it would be unsafe for store
196        // values to cross each other.
197
198        union Storage<T: Copy, U: Copy> {
199            params: MaybeUninit<T>,
200            results: U,
201        }
202
203        let mut storage = Storage::<Params::ValRawStorage, Results::ValRawStorage> {
204            params: MaybeUninit::uninit(),
205        };
206
207        {
208            let mut store = AutoAssertNoGc::new(store.0);
209            params.store(&mut store, ty, &mut storage.params)?;
210        }
211
212        // Try to capture only a single variable (a tuple) in the closure below.
213        // This means the size of the closure is one pointer and is much more
214        // efficient to move in memory. This closure is actually invoked on the
215        // other side of a C++ shim, so it can never be inlined enough to make
216        // the memory go away, so the size matters here for performance.
217        let mut captures = (func, storage);
218
219        let result = invoke_wasm_and_catch_traps(store, |caller, vm| {
220            let (func_ref, storage) = &mut captures;
221            let storage_len = mem::size_of_val::<Storage<_, _>>(storage) / mem::size_of::<ValRaw>();
222            let storage: *mut Storage<_, _> = storage;
223            let storage = storage.cast::<ValRaw>();
224            let storage = core::ptr::slice_from_raw_parts_mut(storage, storage_len);
225            let storage = NonNull::new(storage).unwrap();
226            func_ref
227                .as_ref()
228                .array_call(vm, VMOpaqueContext::from_vmcontext(caller), storage)
229        });
230
231        let (_, storage) = captures;
232        result?;
233
234        let mut store = AutoAssertNoGc::new(store.0);
235        Ok(Results::load(&mut store, &storage.results))
236    }
237
238    /// Purely a debug-mode assertion, not actually used in release builds.
239    fn debug_typecheck(store: &StoreOpaque, func: VMSharedTypeIndex) {
240        let ty = FuncType::from_shared_type_index(store.engine(), func);
241        Params::typecheck(store.engine(), ty.params(), TypeCheckPosition::Param)
242            .expect("params should match");
243        Results::typecheck(store.engine(), ty.results(), TypeCheckPosition::Result)
244            .expect("results should match");
245    }
246}
247
248#[doc(hidden)]
249#[derive(Copy, Clone)]
250pub enum TypeCheckPosition {
251    Param,
252    Result,
253}
254
255/// A trait implemented for types which can be arguments and results for
256/// closures passed to [`Func::wrap`] as well as parameters to [`Func::typed`].
257///
258/// This trait should not be implemented by user types. This trait may change at
259/// any time internally. The types which implement this trait, however, are
260/// stable over time.
261///
262/// For more information see [`Func::wrap`] and [`Func::typed`]
263pub unsafe trait WasmTy: Send {
264    // Do a "static" (aka at time of `func.typed::<P, R>()`) ahead-of-time type
265    // check for this type at the given position. You probably don't need to
266    // override this trait method.
267    #[doc(hidden)]
268    #[inline]
269    fn typecheck(engine: &Engine, actual: ValType, position: TypeCheckPosition) -> Result<()> {
270        let expected = Self::valtype();
271        debug_assert!(expected.comes_from_same_engine(engine));
272        debug_assert!(actual.comes_from_same_engine(engine));
273        match position {
274            // The caller is expecting to receive a `T` and the callee is
275            // actually returning a `U`, so ensure that `U <: T`.
276            TypeCheckPosition::Result => actual.ensure_matches(engine, &expected),
277            // The caller is expecting to pass a `T` and the callee is expecting
278            // to receive a `U`, so ensure that `T <: U`.
279            TypeCheckPosition::Param => match (expected.as_ref(), actual.as_ref()) {
280                // ... except that this technically-correct check would overly
281                // restrict the usefulness of our typed function APIs for the
282                // specific case of concrete reference types. Let's work through
283                // an example.
284                //
285                // Consider functions that take a `(ref param $some_func_type)`
286                // parameter:
287                //
288                // * We cannot have a static `wasmtime::SomeFuncTypeRef` type
289                //   that implements `WasmTy` specifically for `(ref null
290                //   $some_func_type)` because Wasm modules, and their types,
291                //   are loaded dynamically at runtime.
292                //
293                // * Therefore the embedder's only option for `T <: (ref null
294                //   $some_func_type)` is `T = (ref null nofunc)` aka
295                //   `Option<wasmtime::NoFunc>`.
296                //
297                // * But that static type means they can *only* pass in the null
298                //   function reference as an argument to the typed function.
299                //   This is way too restrictive! For ergonomics, we want them
300                //   to be able to pass in a `wasmtime::Func` whose type is
301                //   `$some_func_type`!
302                //
303                // To lift this constraint and enable better ergonomics for
304                // embedders, we allow `top(T) <: top(U)` -- i.e. they are part
305                // of the same type hierarchy and a dynamic cast could possibly
306                // succeed -- for the specific case of concrete heap type
307                // parameters, and fall back to dynamic type checks on the
308                // arguments passed to each invocation, as necessary.
309                (Some(expected_ref), Some(actual_ref)) if actual_ref.heap_type().is_concrete() => {
310                    expected_ref
311                        .heap_type()
312                        .top()
313                        .ensure_matches(engine, &actual_ref.heap_type().top())
314                }
315                _ => expected.ensure_matches(engine, &actual),
316            },
317        }
318    }
319
320    // The value type that this Type represents.
321    #[doc(hidden)]
322    fn valtype() -> ValType;
323
324    #[doc(hidden)]
325    fn may_gc() -> bool {
326        match Self::valtype() {
327            ValType::Ref(_) => true,
328            ValType::I32 | ValType::I64 | ValType::F32 | ValType::F64 | ValType::V128 => false,
329        }
330    }
331
332    // Dynamic checks that this value is being used with the correct store
333    // context.
334    #[doc(hidden)]
335    fn compatible_with_store(&self, store: &StoreOpaque) -> bool;
336
337    // Dynamic checks that `self <: actual` for concrete type arguments. See the
338    // comment above in `WasmTy::typecheck`.
339    //
340    // Only ever called for concrete reference type arguments, so any type which
341    // is not in a type hierarchy with concrete reference types can implement
342    // this with `unreachable!()`.
343    #[doc(hidden)]
344    fn dynamic_concrete_type_check(
345        &self,
346        store: &StoreOpaque,
347        nullable: bool,
348        actual: &HeapType,
349    ) -> Result<()>;
350
351    // Is this a GC-managed reference that actually points to a GC object? That
352    // is, `self` is *not* an `i31`, null reference, or uninhabited type.
353    //
354    // Note that it is okay if this returns false positives (i.e. `true` for
355    // `Rooted<AnyRef>` without actually looking up the rooted `anyref` in the
356    // store and reflecting on it to determine whether it is actually an
357    // `i31`). However, it is not okay if this returns false negatives.
358    #[doc(hidden)]
359    #[inline]
360    fn is_vmgcref_and_points_to_object(&self) -> bool {
361        Self::valtype().is_vmgcref_type_and_points_to_object()
362    }
363
364    // Store `self` into `ptr`.
365    //
366    // NB: We _must not_ trigger a GC when passing refs from host code into Wasm
367    // (e.g. returned from a host function or passed as arguments to a Wasm
368    // function). After insertion into the activations table, the reference is
369    // no longer rooted. If multiple references are being sent from the host
370    // into Wasm and we allowed GCs during insertion, then the following events
371    // could happen:
372    //
373    // * Reference A is inserted into the activations table. This does not
374    //   trigger a GC, but does fill the table to capacity.
375    //
376    // * The caller's reference to A is removed. Now the only reference to A is
377    //   from the activations table.
378    //
379    // * Reference B is inserted into the activations table. Because the table
380    //   is at capacity, a GC is triggered.
381    //
382    // * A is reclaimed because the only reference keeping it alive was the
383    //   activation table's reference (it isn't inside any Wasm frames on the
384    //   stack yet, so stack scanning and stack maps don't increment its
385    //   reference count).
386    //
387    // * We transfer control to Wasm, giving it A and B. Wasm uses A. That's a
388    //   use-after-free bug.
389    //
390    // In conclusion, to prevent uses-after-free bugs, we cannot GC while
391    // converting types into their raw ABI forms.
392    #[doc(hidden)]
393    fn store(self, store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()>;
394
395    // Load a version of `Self` from the `ptr` provided.
396    //
397    // # Safety
398    //
399    // This function is unsafe as it's up to the caller to ensure that `ptr` is
400    // valid for this given type.
401    #[doc(hidden)]
402    unsafe fn load(store: &mut AutoAssertNoGc<'_>, ptr: &ValRaw) -> Self;
403}
404
405macro_rules! integers {
406    ($($primitive:ident/$get_primitive:ident => $ty:ident)*) => ($(
407        unsafe impl WasmTy for $primitive {
408            #[inline]
409            fn valtype() -> ValType {
410                ValType::$ty
411            }
412            #[inline]
413            fn compatible_with_store(&self, _: &StoreOpaque) -> bool {
414                true
415            }
416            #[inline]
417            fn dynamic_concrete_type_check(&self, _: &StoreOpaque, _: bool, _: &HeapType) -> Result<()> {
418                unreachable!()
419            }
420            #[inline]
421            fn store(self, _store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
422                ptr.write(ValRaw::$primitive(self));
423                Ok(())
424            }
425            #[inline]
426            unsafe fn load(_store: &mut AutoAssertNoGc<'_>, ptr: &ValRaw) -> Self {
427                ptr.$get_primitive()
428            }
429        }
430    )*)
431}
432
433integers! {
434    i32/get_i32 => I32
435    i64/get_i64 => I64
436    u32/get_u32 => I32
437    u64/get_u64 => I64
438}
439
440macro_rules! floats {
441    ($($float:ident/$int:ident/$get_float:ident => $ty:ident)*) => ($(
442        unsafe impl WasmTy for $float {
443            #[inline]
444            fn valtype() -> ValType {
445                ValType::$ty
446            }
447            #[inline]
448            fn compatible_with_store(&self, _: &StoreOpaque) -> bool {
449                true
450            }
451            #[inline]
452            fn dynamic_concrete_type_check(&self, _: &StoreOpaque, _: bool, _: &HeapType) -> Result<()> {
453                unreachable!()
454            }
455            #[inline]
456            fn store(self, _store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
457                ptr.write(ValRaw::$float(self.to_bits()));
458                Ok(())
459            }
460            #[inline]
461            unsafe fn load(_store: &mut AutoAssertNoGc<'_>, ptr: &ValRaw) -> Self {
462                $float::from_bits(ptr.$get_float())
463            }
464        }
465    )*)
466}
467
468floats! {
469    f32/u32/get_f32 => F32
470    f64/u64/get_f64 => F64
471}
472
473unsafe impl WasmTy for NoFunc {
474    #[inline]
475    fn valtype() -> ValType {
476        ValType::Ref(RefType::new(false, HeapType::NoFunc))
477    }
478
479    #[inline]
480    fn compatible_with_store(&self, _store: &StoreOpaque) -> bool {
481        match self._inner {}
482    }
483
484    #[inline]
485    fn dynamic_concrete_type_check(&self, _: &StoreOpaque, _: bool, _: &HeapType) -> Result<()> {
486        match self._inner {}
487    }
488
489    #[inline]
490    fn is_vmgcref_and_points_to_object(&self) -> bool {
491        match self._inner {}
492    }
493
494    #[inline]
495    fn store(self, _store: &mut AutoAssertNoGc<'_>, _ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
496        match self._inner {}
497    }
498
499    #[inline]
500    unsafe fn load(_store: &mut AutoAssertNoGc<'_>, _ptr: &ValRaw) -> Self {
501        unreachable!("NoFunc is uninhabited")
502    }
503}
504
505unsafe impl WasmTy for Option<NoFunc> {
506    #[inline]
507    fn valtype() -> ValType {
508        ValType::Ref(RefType::new(true, HeapType::NoFunc))
509    }
510
511    #[inline]
512    fn compatible_with_store(&self, _store: &StoreOpaque) -> bool {
513        true
514    }
515
516    #[inline]
517    fn dynamic_concrete_type_check(
518        &self,
519        _: &StoreOpaque,
520        nullable: bool,
521        ty: &HeapType,
522    ) -> Result<()> {
523        if nullable {
524            // `(ref null nofunc) <: (ref null $f)` for all function types `$f`.
525            Ok(())
526        } else {
527            bail!("argument type mismatch: expected non-nullable (ref {ty}), found null reference")
528        }
529    }
530
531    #[inline]
532    fn store(self, _store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
533        ptr.write(ValRaw::funcref(ptr::null_mut()));
534        Ok(())
535    }
536
537    #[inline]
538    unsafe fn load(_store: &mut AutoAssertNoGc<'_>, _ptr: &ValRaw) -> Self {
539        None
540    }
541}
542
543unsafe impl WasmTy for Func {
544    #[inline]
545    fn valtype() -> ValType {
546        ValType::Ref(RefType::new(false, HeapType::Func))
547    }
548
549    #[inline]
550    fn compatible_with_store(&self, store: &StoreOpaque) -> bool {
551        store.store_data().contains(self.0)
552    }
553
554    #[inline]
555    fn dynamic_concrete_type_check(
556        &self,
557        store: &StoreOpaque,
558        _nullable: bool,
559        expected: &HeapType,
560    ) -> Result<()> {
561        let expected = expected.unwrap_concrete_func();
562        self.ensure_matches_ty(store, expected)
563            .context("argument type mismatch for reference to concrete type")
564    }
565
566    #[inline]
567    fn store(self, store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
568        let abi = self.vm_func_ref(store);
569        ptr.write(ValRaw::funcref(abi.cast::<c_void>().as_ptr()));
570        Ok(())
571    }
572
573    #[inline]
574    unsafe fn load(store: &mut AutoAssertNoGc<'_>, ptr: &ValRaw) -> Self {
575        let p = NonNull::new(ptr.get_funcref()).unwrap().cast();
576        Func::from_vm_func_ref(store, p)
577    }
578}
579
580unsafe impl WasmTy for Option<Func> {
581    #[inline]
582    fn valtype() -> ValType {
583        ValType::FUNCREF
584    }
585
586    #[inline]
587    fn compatible_with_store(&self, store: &StoreOpaque) -> bool {
588        if let Some(f) = self {
589            store.store_data().contains(f.0)
590        } else {
591            true
592        }
593    }
594
595    fn dynamic_concrete_type_check(
596        &self,
597        store: &StoreOpaque,
598        nullable: bool,
599        expected: &HeapType,
600    ) -> Result<()> {
601        if let Some(f) = self {
602            let expected = expected.unwrap_concrete_func();
603            f.ensure_matches_ty(store, expected)
604                .context("argument type mismatch for reference to concrete type")
605        } else if nullable {
606            Ok(())
607        } else {
608            bail!("argument type mismatch: expected non-nullable (ref {expected}), found null reference")
609        }
610    }
611
612    #[inline]
613    fn store(self, store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
614        let raw = if let Some(f) = self {
615            f.vm_func_ref(store).as_ptr()
616        } else {
617            ptr::null_mut()
618        };
619        ptr.write(ValRaw::funcref(raw.cast::<c_void>()));
620        Ok(())
621    }
622
623    #[inline]
624    unsafe fn load(store: &mut AutoAssertNoGc<'_>, ptr: &ValRaw) -> Self {
625        let ptr = NonNull::new(ptr.get_funcref())?.cast();
626        Some(Func::from_vm_func_ref(store, ptr))
627    }
628}
629
630/// A trait used for [`Func::typed`] and with [`TypedFunc`] to represent the set of
631/// parameters for wasm functions.
632///
633/// This is implemented for bare types that can be passed to wasm as well as
634/// tuples of those types.
635pub unsafe trait WasmParams: Send {
636    #[doc(hidden)]
637    type ValRawStorage: Copy;
638
639    #[doc(hidden)]
640    fn typecheck(
641        engine: &Engine,
642        params: impl ExactSizeIterator<Item = crate::ValType>,
643        position: TypeCheckPosition,
644    ) -> Result<()>;
645
646    #[doc(hidden)]
647    fn vmgcref_pointing_to_object_count(&self) -> usize;
648
649    #[doc(hidden)]
650    fn store(
651        self,
652        store: &mut AutoAssertNoGc<'_>,
653        func_ty: &FuncType,
654        dst: &mut MaybeUninit<Self::ValRawStorage>,
655    ) -> Result<()>;
656}
657
658// Forward an impl from `T` to `(T,)` for convenience if there's only one
659// parameter.
660unsafe impl<T> WasmParams for T
661where
662    T: WasmTy,
663{
664    type ValRawStorage = <(T,) as WasmParams>::ValRawStorage;
665
666    fn typecheck(
667        engine: &Engine,
668        params: impl ExactSizeIterator<Item = crate::ValType>,
669        position: TypeCheckPosition,
670    ) -> Result<()> {
671        <(T,) as WasmParams>::typecheck(engine, params, position)
672    }
673
674    #[inline]
675    fn vmgcref_pointing_to_object_count(&self) -> usize {
676        T::is_vmgcref_and_points_to_object(self) as usize
677    }
678
679    #[inline]
680    fn store(
681        self,
682        store: &mut AutoAssertNoGc<'_>,
683        func_ty: &FuncType,
684        dst: &mut MaybeUninit<Self::ValRawStorage>,
685    ) -> Result<()> {
686        <(T,) as WasmParams>::store((self,), store, func_ty, dst)
687    }
688}
689
690macro_rules! impl_wasm_params {
691    ($n:tt $($t:ident)*) => {
692        #[allow(non_snake_case)]
693        unsafe impl<$($t: WasmTy,)*> WasmParams for ($($t,)*) {
694            type ValRawStorage = [ValRaw; $n];
695
696            fn typecheck(
697                _engine: &Engine,
698                mut params: impl ExactSizeIterator<Item = crate::ValType>,
699                _position: TypeCheckPosition,
700            ) -> Result<()> {
701                let mut _n = 0;
702
703                $(
704                    match params.next() {
705                        Some(t) => {
706                            _n += 1;
707                            $t::typecheck(_engine, t, _position)?
708                        },
709                        None => bail!("expected {} types, found {}", $n, params.len() + _n),
710                    }
711                )*
712
713                match params.next() {
714                    None => Ok(()),
715                    Some(_) => {
716                        _n += 1;
717                        bail!("expected {} types, found {}", $n, params.len() + _n)
718                    },
719                }
720            }
721
722            #[inline]
723            fn vmgcref_pointing_to_object_count(&self) -> usize {
724                let ($($t,)*) = self;
725                0 $(
726                    + $t.is_vmgcref_and_points_to_object() as usize
727                )*
728            }
729
730
731            #[inline]
732            fn store(
733                self,
734                _store: &mut AutoAssertNoGc<'_>,
735                _func_ty: &FuncType,
736                _ptr: &mut MaybeUninit<Self::ValRawStorage>,
737            ) -> Result<()> {
738                let ($($t,)*) = self;
739
740                let mut _i = 0;
741                $(
742                    if !$t.compatible_with_store(_store) {
743                        bail!("attempt to pass cross-`Store` value to Wasm as function argument");
744                    }
745
746                    if $t::valtype().is_ref() {
747                        let param_ty = _func_ty.param(_i).unwrap();
748                        let ref_ty = param_ty.unwrap_ref();
749                        let heap_ty = ref_ty.heap_type();
750                        if heap_ty.is_concrete() {
751                            $t.dynamic_concrete_type_check(_store, ref_ty.is_nullable(), heap_ty)?;
752                        }
753                    }
754
755                    let dst = map_maybe_uninit!(_ptr[_i]);
756                    $t.store(_store, dst)?;
757
758                    _i += 1;
759                )*
760                Ok(())
761            }
762        }
763    };
764}
765
766for_each_function_signature!(impl_wasm_params);
767
768/// A trait used for [`Func::typed`] and with [`TypedFunc`] to represent the set of
769/// results for wasm functions.
770pub unsafe trait WasmResults: WasmParams {
771    #[doc(hidden)]
772    unsafe fn load(store: &mut AutoAssertNoGc<'_>, abi: &Self::ValRawStorage) -> Self;
773}
774
775// Forwards from a bare type `T` to the 1-tuple type `(T,)`
776unsafe impl<T: WasmTy> WasmResults for T {
777    unsafe fn load(store: &mut AutoAssertNoGc<'_>, abi: &Self::ValRawStorage) -> Self {
778        <(T,) as WasmResults>::load(store, abi).0
779    }
780}
781
782macro_rules! impl_wasm_results {
783    ($n:tt $($t:ident)*) => {
784        #[allow(non_snake_case, unused_variables)]
785        unsafe impl<$($t: WasmTy,)*> WasmResults for ($($t,)*) {
786            unsafe fn load(store: &mut AutoAssertNoGc<'_>, abi: &Self::ValRawStorage) -> Self {
787                let [$($t,)*] = abi;
788                ($($t::load(store, $t),)*)
789            }
790        }
791    };
792}
793
794for_each_function_signature!(impl_wasm_results);