A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
Use generic array-to-wasm trampolines for components (#11932)
Alex Crichton75808d8c7b22
diff --git a/crates/cranelift/src/compiler.rs b/crates/cranelift/src/compiler.rsindex 0c001f6b18..4b0dfd38d6 100644--- a/crates/cranelift/src/compiler.rs+++ b/crates/cranelift/src/compiler.rs@@ -36,8 +36,9 @@ use wasmtime_environ::{Abi, AddressMapSection, BuiltinFunctionIndex, CacheStore, CompileError, CompiledFunctionBody,DefinedFuncIndex, FlagValue, FrameInstPos, FrameStackShape, FrameStateSlotBuilder,FrameTableBuilder, FuncKey, FunctionBodyData, FunctionLoc, HostCall, InliningCompiler,- ModuleTranslation, ModuleTypesBuilder, PtrSize, StackMapSection, StaticModuleIndex,- TrapEncodingBuilder, TrapSentinel, TripleExt, Tunables, VMOffsets, WasmFuncType, WasmValType,+ ModuleInternedTypeIndex, ModuleTranslation, ModuleTypesBuilder, PtrSize, StackMapSection,+ StaticModuleIndex, TrapEncodingBuilder, TrapSentinel, TripleExt, Tunables, WasmFuncType,+ WasmValType,};use wasmtime_unwinder::ExceptionTableBuilder;@@ -354,140 +355,20 @@ impl wasmtime_environ::Compiler for Compiler {key: FuncKey,symbol: &str,) -> Result<CompiledFunctionBody, CompileError> {- log::trace!("compiling array-to-wasm trampoline: {key:?} = {symbol:?}");-let (module_index, def_func_index) = key.unwrap_array_to_wasm_trampoline();- debug_assert_eq!(translation.module_index(), module_index);-let func_index = translation.module.func_index(def_func_index);let sig = translation.module.functions[func_index].signature.unwrap_module_type_index();- let wasm_func_ty = types[sig].unwrap_func();-- let isa = &*self.isa;- let pointer_type = isa.pointer_type();- let wasm_call_sig = wasm_call_signature(isa, wasm_func_ty, &self.tunables);- let array_call_sig = array_call_signature(isa);-- let mut compiler = self.function_compiler();- let func = ir::Function::with_name_signature(key_to_name(key), array_call_sig);- let (mut builder, block0) = compiler.builder(func);-- let try_call_block = builder.create_block();- builder.ins().jump(try_call_block, []);- builder.switch_to_block(try_call_block);-- let (vmctx, caller_vmctx, values_vec_ptr, values_vec_len) = {- let params = builder.func.dfg.block_params(block0);- (params[0], params[1], params[2], params[3])- };-- // First load the actual arguments out of the array.- let mut args = self.load_values_from_array(- wasm_func_ty.params(),- &mut builder,- values_vec_ptr,- values_vec_len,- );- args.insert(0, caller_vmctx);- args.insert(0, vmctx);-- // Just before we enter Wasm, save our context information.- //- // Assert that we were really given a core Wasm vmctx, since that's- // what we are assuming with our offsets below.- self.debug_assert_vmctx_kind(&mut builder, vmctx, wasmtime_environ::VMCONTEXT_MAGIC);- let offsets = VMOffsets::new(isa.pointer_bytes(), &translation.module);- let vm_store_context_offset = offsets.ptr.vmctx_store_context();- save_last_wasm_entry_context(- &mut builder,- pointer_type,- &offsets.ptr,- vm_store_context_offset.into(),- vmctx,- try_call_block,- );-- // Create the invocation of wasm, which is notably done with a- // `try_call` with an exception handler that's used to handle traps.- let normal_return = builder.create_block();- let exceptional_return = builder.create_block();- let normal_return_values = wasm_call_sig- .returns- .iter()- .map(|ty| {- builder- .func- .dfg- .append_block_param(normal_return, ty.value_type)- })- .collect::<Vec<_>>();-- // Then call the Wasm function with those arguments.- let callee_key = FuncKey::DefinedWasmFunction(module_index, def_func_index);- let signature = builder.func.import_signature(wasm_call_sig.clone());- let callee = {- let (namespace, index) = callee_key.into_raw_parts();- let name = ir::ExternalName::User(- builder- .func- .declare_imported_user_function(ir::UserExternalName { namespace, index }),- );- builder.func.dfg.ext_funcs.push(ir::ExtFuncData {- name,- signature,- colocated: true,- })- };-- let dfg = &mut builder.func.dfg;- let exception_table = dfg.exception_tables.push(ir::ExceptionTableData::new(- signature,- ir::BlockCall::new(- normal_return,- (0..wasm_call_sig.returns.len())- .map(|i| ir::BlockArg::TryCallRet(i.try_into().unwrap())),- &mut dfg.value_lists,- ),- [ir::ExceptionTableItem::Default(ir::BlockCall::new(- exceptional_return,- None,- &mut dfg.value_lists,- ))],- ));- builder.ins().try_call(callee, &args, exception_table);-- builder.seal_block(try_call_block);- builder.seal_block(normal_return);- builder.seal_block(exceptional_return);-- // On the normal return path store all the results in the array we were- // provided and return "true" for "returned successfully".- builder.switch_to_block(normal_return);- self.store_values_to_array(- &mut builder,- wasm_func_ty.returns(),- &normal_return_values,- values_vec_ptr,- values_vec_len,- );- let true_return = builder.ins().iconst(ir::types::I8, 1);- builder.ins().return_(&[true_return]);-- // On the exceptional return path just return "false" for "did not- // succeed". Note that register restoration is part of the `try_call`- // and handler implementation.- builder.switch_to_block(exceptional_return);- let false_return = builder.ins().iconst(ir::types::I8, 0);- builder.ins().return_(&[false_return]);-- builder.finalize();-- Ok(CompiledFunctionBody {- code: box_dyn_any_compiler_context(Some(compiler.cx)),- needs_gc_heap: false,- })+ self.array_to_wasm_trampoline(+ key,+ FuncKey::DefinedWasmFunction(module_index, def_func_index),+ types,+ sig,+ symbol,+ self.isa.pointer_bytes().vmctx_store_context().into(),+ wasmtime_environ::VMCONTEXT_MAGIC,+ )}fn compile_wasm_to_array_trampoline(@@ -1345,6 +1226,142 @@ impl Compiler {);builder.ins().trapz(is_expected_vmctx, TRAP_INTERNAL_ASSERT);}++ fn array_to_wasm_trampoline(+ &self,+ trampoline_key: FuncKey,+ callee_key: FuncKey,+ types: &ModuleTypesBuilder,+ callee_sig: ModuleInternedTypeIndex,+ symbol: &str,+ vm_store_context_offset: u32,+ expected_vmctx_magic: u32,+ ) -> Result<CompiledFunctionBody, CompileError> {+ log::trace!("compiling array-to-wasm trampoline: {trampoline_key:?} = {symbol:?}");++ let wasm_func_ty = types[callee_sig].unwrap_func();++ let isa = &*self.isa;+ let pointer_type = isa.pointer_type();+ let wasm_call_sig = wasm_call_signature(isa, wasm_func_ty, &self.tunables);+ let array_call_sig = array_call_signature(isa);++ let mut compiler = self.function_compiler();+ let func = ir::Function::with_name_signature(key_to_name(trampoline_key), array_call_sig);+ let (mut builder, block0) = compiler.builder(func);++ let try_call_block = builder.create_block();+ builder.ins().jump(try_call_block, []);+ builder.switch_to_block(try_call_block);++ let (vmctx, caller_vmctx, values_vec_ptr, values_vec_len) = {+ let params = builder.func.dfg.block_params(block0);+ (params[0], params[1], params[2], params[3])+ };++ // First load the actual arguments out of the array.+ let mut args = self.load_values_from_array(+ wasm_func_ty.params(),+ &mut builder,+ values_vec_ptr,+ values_vec_len,+ );+ args.insert(0, caller_vmctx);+ args.insert(0, vmctx);++ // Just before we enter Wasm, save our context information.+ //+ // Assert that we were really given a core Wasm vmctx, since that's+ // what we are assuming with our offsets below.+ self.debug_assert_vmctx_kind(&mut builder, vmctx, expected_vmctx_magic);+ save_last_wasm_entry_context(+ &mut builder,+ pointer_type,+ &self.isa.pointer_bytes(),+ vm_store_context_offset,+ vmctx,+ try_call_block,+ );++ // Create the invocation of wasm, which is notably done with a+ // `try_call` with an exception handler that's used to handle traps.+ let normal_return = builder.create_block();+ let exceptional_return = builder.create_block();+ let normal_return_values = wasm_call_sig+ .returns+ .iter()+ .map(|ty| {+ builder+ .func+ .dfg+ .append_block_param(normal_return, ty.value_type)+ })+ .collect::<Vec<_>>();++ // Then call the Wasm function with those arguments.+ let signature = builder.func.import_signature(wasm_call_sig.clone());+ let callee = {+ let (namespace, index) = callee_key.into_raw_parts();+ let name = ir::ExternalName::User(+ builder+ .func+ .declare_imported_user_function(ir::UserExternalName { namespace, index }),+ );+ builder.func.dfg.ext_funcs.push(ir::ExtFuncData {+ name,+ signature,+ colocated: true,+ })+ };++ let dfg = &mut builder.func.dfg;+ let exception_table = dfg.exception_tables.push(ir::ExceptionTableData::new(+ signature,+ ir::BlockCall::new(+ normal_return,+ (0..wasm_call_sig.returns.len())+ .map(|i| ir::BlockArg::TryCallRet(i.try_into().unwrap())),+ &mut dfg.value_lists,+ ),+ [ir::ExceptionTableItem::Default(ir::BlockCall::new(+ exceptional_return,+ None,+ &mut dfg.value_lists,+ ))],+ ));+ builder.ins().try_call(callee, &args, exception_table);++ builder.seal_block(try_call_block);+ builder.seal_block(normal_return);+ builder.seal_block(exceptional_return);++ // On the normal return path store all the results in the array we were+ // provided and return "true" for "returned successfully".+ builder.switch_to_block(normal_return);+ self.store_values_to_array(+ &mut builder,+ wasm_func_ty.returns(),+ &normal_return_values,+ values_vec_ptr,+ values_vec_len,+ );+ let true_return = builder.ins().iconst(ir::types::I8, 1);+ builder.ins().return_(&[true_return]);++ // On the exceptional return path just return "false" for "did not+ // succeed". Note that register restoration is part of the `try_call`+ // and handler implementation.+ builder.switch_to_block(exceptional_return);+ let false_return = builder.ins().iconst(ir::types::I8, 0);+ builder.ins().return_(&[false_return]);++ builder.finalize();++ Ok(CompiledFunctionBody {+ code: box_dyn_any_compiler_context(Some(compiler.cx)),+ needs_gc_heap: false,+ })+ }}struct FunctionCompiler<'a> {@@ -1572,7 +1589,7 @@ fn clif_to_env_frame_tables<'a>(fn save_last_wasm_entry_context(builder: &mut FunctionBuilder,pointer_type: ir::Type,- ptr_size: &impl PtrSize,+ ptr_size: &dyn PtrSize,vm_store_context_offset: u32,vmctx: Value,block: ir::Block,diff --git a/crates/cranelift/src/compiler/component.rs b/crates/cranelift/src/compiler/component.rsindex 533c150b11..6e7ebdefb7 100644--- a/crates/cranelift/src/compiler/component.rs+++ b/crates/cranelift/src/compiler/component.rs@@ -1442,11 +1442,32 @@ impl ComponentCompiler for Compiler {key: FuncKey,abi: Abi,tunables: &Tunables,- _symbol: &str,+ symbol: &str,) -> Result<CompiledFunctionBody> {let (abi2, trampoline_index) = key.unwrap_component_trampoline();debug_assert_eq!(abi, abi2);+ match abi {+ // Fall through to the trampoline compiler.+ Abi::Wasm => {}++ // Implement the array-abi trampoline in terms of calling the+ // wasm-abi trampoline.+ Abi::Array => {+ let offsets =+ VMComponentOffsets::new(self.isa.pointer_bytes(), &component.component);+ return Ok(self.array_to_wasm_trampoline(+ key,+ FuncKey::ComponentTrampoline(Abi::Wasm, trampoline_index),+ types.module_types_builder(),+ component.component.trampolines[trampoline_index],+ symbol,+ offsets.vm_store_context(),+ wasmtime_environ::component::VMCOMPONENT_MAGIC,+ )?);+ }+ }+let mut compiler = self.function_compiler();let mut c = TrampolineCompiler::new(self,diff --git a/tests/all/component_model/resources.rs b/tests/all/component_model/resources.rsindex 373c123ffa..6aca26688c 100644--- a/tests/all/component_model/resources.rs+++ b/tests/all/component_model/resources.rs@@ -1641,3 +1641,35 @@ fn resource_dynamic_not_static() -> Result<()> {Ok(())}++#[test]+fn intrinsic_trampolines() -> Result<()> {+ let engine = super::engine();+ let mut store = Store::new(&engine, ());+ let linker = Linker::new(&engine);+ let c = Component::new(+ &engine,+ r#"+(component+ (type $r' (resource (rep i32)))+ (export $r "r" (type $r'))++ (core func $new (canon resource.new $r))+ (core func $rep (canon resource.rep $r))++ (func (export "new") (param "x" u32) (result (own $r))+ (canon lift (core func $new)))+ (func (export "rep") (param "x" (borrow $r)) (result u32)+ (canon lift (core func $rep)))+)+"#,+ )?;+ let i = linker.instantiate(&mut store, &c)?;+ let new = i.get_typed_func::<(u32,), (ResourceAny,)>(&mut store, "new")?;+ let rep = i.get_typed_func::<(ResourceAny,), (u32,)>(&mut store, "rep")?;++ let r = new.call(&mut store, (42,))?.0;+ new.post_return(&mut store)?;+ assert!(rep.call(&mut store, (r,)).is_err());+ Ok(())+}