wasmtime: Overhaul trampolines

RELEASES.md

@@ -8,6 +8,18 @@ Unreleased.
 
 ### Changed
 
+* Overhauled the way that Wasmtime calls into Wasm and Wasm calls back out to
+  the host. Instead of chaining together trampolines to convert between calling
+  conventions, we now represent `funcref`s with multiple function pointers, one
+  per calling convention. This paves the way for supporting Wasm tail calls and
+  also results in ~10% speed ups to a variety of function call benchmarks,
+  however there are some slight compiled Wasm module code size regressions
+  (which can be alleviated by disabling optional `.eh_frame`
+  generation). Additionally, in the C API the `wasmtime_func_call_unchecked`
+  function gained one more parameter, which is the capacity of the
+  args-and-results
+  buffer. [#6262](https://github.com/bytecodealliance/wasmtime/pull/6262)
+
 --------------------------------------------------------------------------------
 
 ## 8.0.0

benches/call.rs

@@ -166,7 +166,7 @@ fn bench_host_to_wasm<Params, Results>(
                 space[i] = param.to_raw(&mut *store);
             }
             untyped
-                .call_unchecked(&mut *store, space.as_mut_ptr())
+                .call_unchecked(&mut *store, space.as_mut_ptr(), space.len())
                 .unwrap();
             for (i, expected) in results.iter().enumerate() {
                 assert_vals_eq(

benches/instantiation.rs

@@ -44,6 +44,10 @@ fn bench_sequential(c: &mut Criterion, path: &Path) {
                 panic!("failed to load benchmark `{}`: {:?}", path.display(), e)
             });
             let mut linker = Linker::new(&engine);
+            // Add these imports so we can benchmark instantiation of Sightglass
+            // benchmark programs.
+            linker.func_wrap("bench", "start", || {}).unwrap();
+            linker.func_wrap("bench", "end", || {}).unwrap();
             wasmtime_wasi::add_to_linker(&mut linker, |cx| cx).unwrap();
             let pre = linker
                 .instantiate_pre(&module)
@@ -74,6 +78,10 @@ fn bench_parallel(c: &mut Criterion, path: &Path) {
             let module =
                 Module::from_file(&engine, path).expect("failed to load WASI example module");
             let mut linker = Linker::new(&engine);
+            // Add these imports so we can benchmark instantiation of Sightglass
+            // benchmark programs.
+            linker.func_wrap("bench", "start", || {}).unwrap();
+            linker.func_wrap("bench", "end", || {}).unwrap();
             wasmtime_wasi::add_to_linker(&mut linker, |cx| cx).unwrap();
             let pre = Arc::new(
                 linker

crates/c-api/include/wasmtime/func.h

@@ -233,6 +233,8 @@ WASM_API_EXTERN wasmtime_error_t *wasmtime_func_call(
  *
  * * The `args_and_results` pointer has enough space to hold all the parameters
  *   and all the results (but not at the same time).
+ * * The `args_and_results_len` contains the length of the `args_and_results`
+ *   buffer.
  * * Parameters must all be configured as if they were the correct type.
  * * Values such as `externref` and `funcref` are valid within the store being
  *   called.
@@ -245,6 +247,7 @@ WASM_API_EXTERN wasmtime_error_t *wasmtime_func_call_unchecked(
     wasmtime_context_t *store,
     const wasmtime_func_t *func,
     wasmtime_val_raw_t *args_and_results,
+    size_t args_and_results_len,
     wasm_trap_t **trap
 );
 

crates/c-api/src/func.rs

@@ -365,9 +365,10 @@ pub unsafe extern "C" fn wasmtime_func_call_unchecked(
     store: CStoreContextMut<'_>,
     func: &Func,
     args_and_results: *mut ValRaw,
+    args_and_results_len: usize,
     trap_ret: &mut *mut wasm_trap_t,
 ) -> Option<Box<wasmtime_error_t>> {
-    match func.call_unchecked(store, args_and_results) {
+    match func.call_unchecked(store, args_and_results, args_and_results_len) {
         Ok(()) => None,
         Err(trap) => store_err(trap, trap_ret),
     }

crates/cranelift-shared/src/obj.rs

@@ -161,7 +161,7 @@ impl<'a> ModuleTextBuilder<'a> {
                     // loop could also be updated to forward the relocation to
                     // the final object file as well.
                     panic!(
-                        "unresolved relocation could not be procesed against \
+                        "unresolved relocation could not be processed against \
                          {index:?}: {r:?}"
                     );
                 }