Remove allocation when calling functions

Instead of allocating an array of arg pointers, use the variable arguments signature m3_CallV.

Author: jimpo

src/function.rs

@@ -7,7 +7,7 @@ use core::str;
 use crate::error::{Error, Result};
 use crate::runtime::Runtime;
 use crate::utils::cstr_to_str;
-use crate::{Module, WasmArgs, WasmType};
+use crate::{Module, WasmArg, WasmArgs, WasmType};
 
 /// Calling Context for a host function.
 pub struct CallContext<'cc> {
@@ -136,11 +136,7 @@ where
         })
     }
 
-    fn call_impl(&self, args: Args) -> Result<Ret> {
-        let mut argv = args.ptrs_vec();
-        let result =
-            unsafe { ffi::m3_Call(self.raw.as_ptr(), argv.len() as u32, argv.as_mut_ptr()) };
-        Error::from_ffi_res(result)?;
+    fn get_call_result(&self) -> Result<Ret> {
         unsafe {
             let mut ret = core::mem::MaybeUninit::<Ret>::uninit();
             let result = ffi::m3_GetResultsV(self.raw.as_ptr(), ret.as_mut_ptr());
@@ -168,7 +164,9 @@ macro_rules! func_call_impl {
             #[inline]
             #[allow(non_snake_case, clippy::too_many_arguments)]
             pub fn call(&self, $($types: $types),*) -> Result<Ret> {
-                self.call_impl(($($types,)*))
+                let result = unsafe { ffi::m3_CallV(self.raw.as_ptr(), $($types,)*) };
+                Error::from_ffi_res(result)?;
+                self.get_call_result()
             }
         }
     };
@@ -178,13 +176,15 @@ func_call_impl!(A, B, C, D, E, F, G, H, J, K, L, M, N, O, P, Q);
 impl<'rt, ARG, Ret> Function<'rt, ARG, Ret>
 where
     Ret: WasmType,
-    ARG: crate::WasmArg,
+    ARG: WasmArg,
 {
     /// Calls this function with the given parameter.
     /// This is implemented with variable arguments depending on the functions Args type.
     #[inline]
     pub fn call(&self, arg: ARG) -> Result<Ret> {
-        self.call_impl(arg)
+        let result = unsafe { ffi::m3_CallV(self.raw.as_ptr(), arg) };
+        Error::from_ffi_res(result)?;
+        self.get_call_result()
     }
 }
 
@@ -196,6 +196,8 @@ where
     /// This is implemented with variable arguments depending on the functions Args type.
     #[inline]
     pub fn call(&self) -> Result<Ret> {
-        self.call_impl(())
+        let result = unsafe { ffi::m3_CallV(self.raw.as_ptr()) };
+        Error::from_ffi_res(result)?;
+        self.get_call_result()
     }
 }

src/ty.rs

@@ -1,4 +1,3 @@
-use alloc::vec;
 use alloc::vec::Vec;
 
 // this module looks like a mess, lots of doc(hidden) attributes since rust traits cant have private functions
@@ -39,8 +38,6 @@ pub trait WasmArgs {
     fn sealed_() -> private::Seal;
     #[doc(hidden)]
     fn append_signature(buffer: &mut Vec<cty::c_char>);
-    #[doc(hidden)]
-    fn ptrs_vec(&self) -> Vec<*const cty::c_void>;
 }
 
 impl WasmArg for i32 {}
@@ -207,10 +204,6 @@ impl WasmArgs for () {
     }
     #[doc(hidden)]
     fn append_signature(_buffer: &mut Vec<cty::c_char>) {}
-    #[doc(hidden)]
-    fn ptrs_vec(&self) -> Vec<*const cty::c_void> {
-        Vec::new()
-    }
 }
 
 /// Unary functions
@@ -238,10 +231,6 @@ where
     fn append_signature(buffer: &mut Vec<cty::c_char>) {
         buffer.push(T::SIGNATURE as cty::c_char);
     }
-    #[doc(hidden)]
-    fn ptrs_vec(&self) -> Vec<*const cty::c_void> {
-        vec![self as *const T as *const cty::c_void]
-    }
 }
 
 macro_rules! args_impl {
@@ -292,12 +281,6 @@ macro_rules! args_impl {
                     buffer.push($types::SIGNATURE as cty::c_char);
                 )*
             }
-            #[doc(hidden)]
-            fn ptrs_vec(&self) -> Vec<*const cty::c_void> {
-                #[allow(non_snake_case)]
-                let ($($types,)*) = self;
-                vec![$($types as *const $types as *const cty::c_void,)*]
-            }
         }
     };
 }