add component-model-async/fused.wast test

This is another piece of bytecodealliance#9582 which I'm splitting out to make review easier.

This test exercises fused adapter generation for various flavors of
intercomponent async->async, async->sync, and sync->async calls.

The remaining changes fill in some TODOs to make the test pass.

Signed-off-by: Joel Dice <[email protected]>

Author: dicej

crates/cranelift/src/compiler/component.rs

@@ -3,7 +3,7 @@
 use crate::{compiler::Compiler, TRAP_ALWAYS, TRAP_CANNOT_ENTER, TRAP_INTERNAL_ASSERT};
 use anyhow::Result;
 use cranelift_codegen::ir::condcodes::IntCC;
-use cranelift_codegen::ir::{self, InstBuilder, MemFlags};
+use cranelift_codegen::ir::{self, InstBuilder, MemFlags, Value};
 use cranelift_codegen::isa::{CallConv, TargetIsa};
 use cranelift_frontend::FunctionBuilder;
 use std::any::Any;
@@ -98,7 +98,7 @@ impl<'a> TrampolineCompiler<'a> {
                 _ = instance;
                 todo!()
             }
-            Trampoline::TaskReturn => todo!(),
+            Trampoline::TaskReturn => self.translate_task_return_call(),
             Trampoline::TaskWait {
                 instance,
                 async_,
@@ -196,12 +196,12 @@ impl<'a> TrampolineCompiler<'a> {
             Trampoline::ResourceDrop(ty) => self.translate_resource_drop(*ty),
             Trampoline::ResourceTransferOwn => {
                 self.translate_resource_libcall(host::resource_transfer_own, |me, rets| {
-                    rets[0] = me.raise_if_resource_trapped(rets[0]);
+                    rets[0] = me.raise_if_i32_trapped(rets[0]);
                 })
             }
             Trampoline::ResourceTransferBorrow => {
                 self.translate_resource_libcall(host::resource_transfer_borrow, |me, rets| {
-                    rets[0] = me.raise_if_resource_trapped(rets[0]);
+                    rets[0] = me.raise_if_i32_trapped(rets[0]);
                 })
             }
             Trampoline::ResourceEnterCall => {
@@ -212,14 +212,17 @@ impl<'a> TrampolineCompiler<'a> {
                     me.raise_if_host_trapped(rets.pop().unwrap());
                 })
             }
-            Trampoline::AsyncEnterCall => todo!(),
+            Trampoline::AsyncEnterCall => {
+                self.translate_async_enter_or_exit(host::async_enter, None, ir::types::I8)
+            }
             Trampoline::AsyncExitCall {
                 callback,
                 post_return,
-            } => {
-                _ = (callback, post_return);
-                todo!()
-            }
+            } => self.translate_async_enter_or_exit(
+                host::async_exit,
+                Some((*callback, *post_return)),
+                ir::types::I64,
+            ),
             Trampoline::FutureTransfer => {
                 _ = host::future_transfer;
                 todo!()
@@ -235,25 +238,18 @@ impl<'a> TrampolineCompiler<'a> {
         }
     }
 
-    fn translate_lower_import(
-        &mut self,
-        index: LoweredIndex,
-        options: &CanonicalOptions,
-        lower_ty: TypeFuncIndex,
-    ) {
+    fn store_wasm_arguments(&mut self, args: &[Value]) -> (Value, Value) {
         let pointer_type = self.isa.pointer_type();
-        let args = self.builder.func.dfg.block_params(self.block0).to_vec();
-        let vmctx = args[0];
-        let wasm_func_ty = self.types[self.signature].unwrap_func();
+        let wasm_func_ty = &self.types[self.signature].unwrap_func();
 
         // Start off by spilling all the wasm arguments into a stack slot to be
         // passed to the host function.
-        let (values_vec_ptr, values_vec_len) = match self.abi {
+        match self.abi {
             Abi::Wasm => {
                 let (ptr, len) = self.compiler.allocate_stack_array_and_spill_args(
                     wasm_func_ty,
                     &mut self.builder,
-                    &args[2..],
+                    args,
                 );
                 let len = self.builder.ins().iconst(pointer_type, i64::from(len));
                 (ptr, len)
@@ -262,7 +258,163 @@ impl<'a> TrampolineCompiler<'a> {
                 let params = self.builder.func.dfg.block_params(self.block0);
                 (params[2], params[3])
             }
-        };
+        }
+    }
+
+    fn translate_task_return_call(&mut self) {
+        match self.abi {
+            Abi::Wasm => {}
+
+            // These trampolines can only actually be called by Wasm, so
+            // let's assert that here.
+            Abi::Array => {
+                self.builder.ins().trap(TRAP_INTERNAL_ASSERT);
+                return;
+            }
+        }
+
+        let args = self.builder.func.dfg.block_params(self.block0).to_vec();
+        let vmctx = args[0];
+
+        let (values_vec_ptr, values_vec_len) = self.store_wasm_arguments(&args[2..]);
+
+        let (host_sig, index) = host::task_return(self.isa, &mut self.builder.func);
+        let host_fn = self.load_libcall(vmctx, index);
+
+        let params = self.types[self.signature]
+            .unwrap_func()
+            .params()
+            .iter()
+            .map(|&v| {
+                Some(match v {
+                    WasmValType::I32 => FlatType::I32,
+                    WasmValType::I64 => FlatType::I64,
+                    WasmValType::F32 => FlatType::F32,
+                    WasmValType::F64 => FlatType::F64,
+                    _ => return None,
+                })
+            })
+            .collect::<Option<_>>();
+
+        let ty = self.builder.ins().iconst(
+            ir::types::I32,
+            i64::from(
+                params
+                    .and_then(|params| {
+                        self.types
+                            .get_task_return_type(&TypeTaskReturn { params })
+                            .map(|v| v.as_u32())
+                    })
+                    .unwrap_or(u32::MAX),
+            ),
+        );
+
+        let call = self.compiler.call_indirect_host(
+            &mut self.builder,
+            index,
+            host_sig,
+            host_fn,
+            &[vmctx, ty, values_vec_ptr, values_vec_len],
+        );
+        let succeeded = self.builder.func.dfg.inst_results(call)[0];
+        self.raise_if_host_trapped(succeeded);
+        self.builder.ins().return_(&[]);
+    }
+
+    fn translate_async_enter_or_exit(
+        &mut self,
+        get_libcall: fn(
+            &dyn TargetIsa,
+            &mut ir::Function,
+        ) -> (ir::SigRef, ComponentBuiltinFunctionIndex),
+        callback_and_post_return: Option<(
+            Option<RuntimeCallbackIndex>,
+            Option<RuntimePostReturnIndex>,
+        )>,
+        result: ir::types::Type,
+    ) {
+        match self.abi {
+            Abi::Wasm => {}
+
+            // These trampolines can only actually be called by Wasm, so
+            // let's assert that here.
+            Abi::Array => {
+                self.builder.ins().trap(TRAP_INTERNAL_ASSERT);
+                return;
+            }
+        }
+
+        let args = self.builder.func.dfg.block_params(self.block0).to_vec();
+        let vmctx = args[0];
+
+        let (host_sig, index) = get_libcall(self.isa, &mut self.builder.func);
+        let host_fn = self.load_libcall(vmctx, index);
+
+        let mut callee_args = vec![vmctx];
+
+        if let Some((callback, post_return)) = callback_and_post_return {
+            let pointer_type = self.isa.pointer_type();
+
+            // callback: *mut VMFuncRef
+            if let Some(callback) = callback {
+                callee_args.push(self.builder.ins().load(
+                    pointer_type,
+                    MemFlags::trusted(),
+                    vmctx,
+                    i32::try_from(self.offsets.runtime_callback(callback)).unwrap(),
+                ));
+            } else {
+                callee_args.push(self.builder.ins().iconst(pointer_type, 0));
+            }
+
+            // post_return: *mut VMFuncRef
+            if let Some(post_return) = post_return {
+                callee_args.push(self.builder.ins().load(
+                    pointer_type,
+                    MemFlags::trusted(),
+                    vmctx,
+                    i32::try_from(self.offsets.runtime_post_return(post_return)).unwrap(),
+                ));
+            } else {
+                callee_args.push(self.builder.ins().iconst(pointer_type, 0));
+            }
+        }
+
+        // remaining parameters
+        callee_args.extend(args[2..].iter().copied());
+
+        let call = self.compiler.call_indirect_host(
+            &mut self.builder,
+            index,
+            host_sig,
+            host_fn,
+            &callee_args,
+        );
+
+        if result == ir::types::I64 {
+            let result = self.builder.func.dfg.inst_results(call)[0];
+            let result = self.raise_if_i32_trapped(result);
+            self.abi_store_results(&[result]);
+        } else {
+            assert!(result == ir::types::I8);
+            let succeeded = self.builder.func.dfg.inst_results(call)[0];
+            self.raise_if_host_trapped(succeeded);
+            self.builder.ins().return_(&[]);
+        }
+    }
+
+    fn translate_lower_import(
+        &mut self,
+        index: LoweredIndex,
+        options: &CanonicalOptions,
+        lower_ty: TypeFuncIndex,
+    ) {
+        let pointer_type = self.isa.pointer_type();
+        let args = self.builder.func.dfg.block_params(self.block0).to_vec();
+        let vmctx = args[0];
+        let wasm_func_ty = self.types[self.signature].unwrap_func();
+
+        let (values_vec_ptr, values_vec_len) = self.store_wasm_arguments(&args[2..]);
 
         // Below this will incrementally build both the signature of the host
         // function we're calling as well as the list of arguments since the
@@ -457,7 +609,7 @@ impl<'a> TrampolineCompiler<'a> {
         );
         let call = self.call_libcall(vmctx, host::resource_new32, &host_args);
         let result = self.builder.func.dfg.inst_results(call)[0];
-        let result = self.raise_if_resource_trapped(result);
+        let result = self.raise_if_i32_trapped(result);
         self.abi_store_results(&[result]);
     }
 
@@ -486,7 +638,7 @@ impl<'a> TrampolineCompiler<'a> {
         );
         let call = self.call_libcall(vmctx, host::resource_rep32, &host_args);
         let result = self.builder.func.dfg.inst_results(call)[0];
-        let result = self.raise_if_resource_trapped(result);
+        let result = self.raise_if_i32_trapped(result);
         self.abi_store_results(&[result]);
     }
 
@@ -799,7 +951,7 @@ impl<'a> TrampolineCompiler<'a> {
         self.raise_if_host_trapped(succeeded);
     }
 
-    fn raise_if_resource_trapped(&mut self, ret: ir::Value) -> ir::Value {
+    fn raise_if_i32_trapped(&mut self, ret: ir::Value) -> ir::Value {
         let minus_one = self.builder.ins().iconst(ir::types::I64, -1);
         let succeeded = self.builder.ins().icmp(IntCC::NotEqual, ret, minus_one);
         self.raise_if_host_trapped(succeeded);

crates/environ/src/component.rs

@@ -83,6 +83,10 @@ macro_rules! foreach_builtin_component_function {
             resource_enter_call(vmctx: vmctx);
             resource_exit_call(vmctx: vmctx) -> bool;
 
+            task_return(vmctx: vmctx, ty: u32, storage: ptr_u8, storage_len: size) -> bool;
+            async_enter(vmctx: vmctx, start: ptr_u8, return_: ptr_u8, caller_instance: u32, task_return_type: u32, params: u32, results: u32) -> bool;
+            async_exit(vmctx: vmctx, callback: ptr_u8, post_return: ptr_u8, caller_instance: u32, callee: ptr_u8, callee_instance: u32, param_count: u32, result_count: u32, flags: u32) -> u64;
+
             future_transfer(vmctx: vmctx, src_idx: u32, src_table: u32, dst_table: u32) -> u64;
             stream_transfer(vmctx: vmctx, src_idx: u32, src_table: u32, dst_table: u32) -> u64;
             error_context_transfer(vmctx: vmctx, src_idx: u32, src_table: u32, dst_table: u32) -> u64;