Fix returned strings and lists in async wasmtime code

Fixes #141

Author: tailhook

crates/gen-wasmtime/src/lib.rs

@@ -1874,34 +1874,42 @@ impl Bindgen for FunctionBindgen<'_> {
                     self.gen.needs_copy_slice = true;
                     self.needs_functions
                         .insert(free.to_string(), NeededFunction::Free);
-                    let (stringify, align) = match element {
-                        Type::Char => (true, 1),
-                        _ => (false, self.gen.sizes.align(element)),
+                    let (stringify, align, el_size) = match element {
+                        Type::Char => (true, 1, 1),
+                        _ => (
+                            false,
+                            self.sizes().align(element),
+                            self.sizes().size(element),
+                        ),
                     };
                     let tmp = self.tmp();
                     self.push_str(&format!("let ptr{} = {};\n", tmp, operands[0]));
                     self.push_str(&format!("let len{} = {};\n", tmp, operands[1]));
-                    let result = format!(
+                    self.push_str(&format!(
                         "
-                                copy_slice(
-                                    &mut caller,
-                                    memory,
-                                    func_{},
-                                    ptr{tmp}, len{tmp}, {}
-                                )?
-                            ",
-                        free,
+                            let data{tmp} = copy_slice(
+                                &mut caller,
+                                memory,
+                                ptr{tmp}, len{tmp}, {}
+                            )?;
+                        ",
                         align,
-                        tmp = tmp
+                        tmp = tmp,
+                    ));
+                    self.call_intrinsic(
+                        free,
+                        // we use normal multiplication here as copy_slice has
+                        // already verified that multiplied size fits i32
+                        format!("(ptr{tmp}, len{tmp} * {}, {})", el_size, align, tmp = tmp),
                     );
                     if stringify {
                         results.push(format!(
-                            "String::from_utf8({})
+                            "String::from_utf8(data{})
                                     .map_err(|_| wasmtime::Trap::new(\"invalid utf-8\"))?",
-                            result
+                            tmp,
                         ));
                     } else {
-                        results.push(result);
+                        results.push(format!("data{}", tmp));
                     }
                 }
                 None => {

crates/wasmtime/src/lib.rs

@@ -137,7 +137,6 @@ pub mod rt {
     pub fn copy_slice<T: Endian>(
         store: impl AsContextMut,
         memory: &Memory,
-        free: &TypedFunc<(i32, i32, i32), ()>,
         base: i32,
         len: i32,
         align: i32,
@@ -150,9 +149,7 @@ pub mod rt {
             .get(base as usize..)
             .and_then(|s| s.get(..size as usize))
             .ok_or_else(|| Trap::new("out of bounds read"))?;
-        let result = Le::from_slice(slice).iter().map(|s| s.get()).collect();
-        free.call(store, (base, size as i32, align))?;
-        Ok(result)
+        Ok(Le::from_slice(slice).iter().map(|s| s.get()).collect())
     }
 
     macro_rules! as_traits {