A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
consistently create thread and task when entering component instance (#12379)
Joel Diceb271e4526c42
diff --git a/crates/cranelift/src/compiler/component.rs b/crates/cranelift/src/compiler/component.rsindex fc583c0682..6a6c5b8224 100644--- a/crates/cranelift/src/compiler/component.rs+++ b/crates/cranelift/src/compiler/component.rs@@ -1,6 +1,6 @@//! Compilation support for the component model.-use crate::{TRAP_INTERNAL_ASSERT, compiler::Compiler};+use crate::{TRAP_CANNOT_LEAVE_COMPONENT, TRAP_INTERNAL_ASSERT, compiler::Compiler};use cranelift_codegen::ir::condcodes::IntCC;use cranelift_codegen::ir::{self, InstBuilder, MemFlags, Value};use cranelift_codegen::isa::{CallConv, TargetIsa};@@ -722,6 +722,22 @@ impl<'a> TrampolineCompiler<'a> {|_, _| {},);}+ Trampoline::EnterSyncCall => {+ self.translate_libcall(+ host::enter_sync_call,+ TrapSentinel::Falsy,+ WasmArgs::InRegisters,+ |_, _| {},+ );+ }+ Trampoline::ExitSyncCall => {+ self.translate_libcall(+ host::exit_sync_call,+ TrapSentinel::Falsy,+ WasmArgs::InRegisters,+ |_, _| {},+ );+ }Trampoline::ContextGet { instance, slot } => {self.translate_libcall(host::context_get,@@ -1112,11 +1128,22 @@ impl<'a> TrampolineCompiler<'a> {// brif should_run_destructor, run_destructor_block, return_block//// run_destructor_block:+ // ;; test may_leave, but only if the component instances+ // ;; differ+ // flags = load.i32 vmctx+$instance_flags_offset+ // masked = band flags, $FLAG_MAY_LEAVE+ // trapz masked, $TRAP_CANNOT_LEAVE_COMPONENT+ //// ;; set may_block to false, saving the old value to restore- // ;; later, but only if the component instances differ+ // ;; later, but only if the component instances differ and+ // ;; concurrency is enabled// old_may_block = load.i32 vmctx+$may_block_offset// store 0, vmctx+$may_block_offset//+ // ;; call enter_sync_call, but only if the component instances+ // ;; differ and concurrency is enabled+ // ...+ //// ;; ============================================================// ;; this is conditionally emitted based on whether the resource// ;; has a destructor or not, and can be statically omitted@@ -1132,6 +1159,12 @@ impl<'a> TrampolineCompiler<'a> {// ;; restore old value of may_block// store old_may_block, vmctx+$may_block_offset//+ // ;; if needed, call exit_sync_call+ // ...+ //+ // ;; if needed, restore the old value of may_block+ // store old_may_block, vmctx+$may_block_offset+ //// jump return_block//// return_block:@@ -1161,29 +1194,69 @@ impl<'a> TrampolineCompiler<'a> {self.builder.switch_to_block(run_destructor_block);- // If this is a defined resource within the component itself then the- // `may_block` field must be updated. Note though that this update can- // be elided if the resource table resides in the same component- // instance that defined the resource as the component is calling- // itself.+ // If this is a component-defined resource, the `may_leave` flag must be+ // checked. Additionally, if concurrency is enabled, the `may_block`+ // field must be updated and `enter_sync_call` called. Note though that+ // all of that may be elided if the resource table resides in the same+ // component instance that defined the resource as the component is+ // calling itself.let old_may_block = if let Some(def) = resource_def {if self.types[resource].unwrap_concrete_instance() != def.instance {- // Stash the old value of `may_block` and then set it to false.- let old_may_block = self.builder.ins().load(+ let flags = self.builder.ins().load(ir::types::I32,trusted,vmctx,- i32::try_from(self.offsets.task_may_block()).unwrap(),- );- let zero = self.builder.ins().iconst(ir::types::I32, i64::from(0));- self.builder.ins().store(- ir::MemFlags::trusted(),- zero,- vmctx,- i32::try_from(self.offsets.task_may_block()).unwrap(),+ i32::try_from(+ self.offsets+ .instance_flags(self.types[resource].unwrap_concrete_instance()),+ )+ .unwrap(),);+ let masked = self+ .builder+ .ins()+ .band_imm(flags, i64::from(FLAG_MAY_LEAVE));+ self.builder+ .ins()+ .trapz(masked, TRAP_CANNOT_LEAVE_COMPONENT);++ if self.compiler.tunables.component_model_concurrency {+ // Stash the old value of `may_block` and then set it to false.+ let old_may_block = self.builder.ins().load(+ ir::types::I32,+ trusted,+ vmctx,+ i32::try_from(self.offsets.task_may_block()).unwrap(),+ );+ let zero = self.builder.ins().iconst(ir::types::I32, i64::from(0));+ self.builder.ins().store(+ ir::MemFlags::trusted(),+ zero,+ vmctx,+ i32::try_from(self.offsets.task_may_block()).unwrap(),+ );- Some(old_may_block)+ // Call `enter_sync_call`+ //+ // FIXME: Apply the optimizations described in #12311.+ let host_args = vec![+ vmctx,+ self.builder+ .ins()+ .iconst(ir::types::I32, i64::from(instance.as_u32())),+ self.builder.ins().iconst(ir::types::I32, i64::from(0)),+ self.builder+ .ins()+ .iconst(ir::types::I32, i64::from(def.instance.as_u32())),+ ];+ let call = self.call_libcall(vmctx, host::enter_sync_call, &host_args);+ let result = self.builder.func.dfg.inst_results(call).get(0).copied();+ self.raise_if_host_trapped(result.unwrap());++ Some(old_may_block)+ } else {+ None+ }} else {None}@@ -1240,6 +1313,14 @@ impl<'a> TrampolineCompiler<'a> {}if let Some(old_may_block) = old_may_block {+ // Call `exit_sync_call`+ //+ // FIXME: Apply the optimizations described in #12311.+ let call = self.call_libcall(vmctx, host::exit_sync_call, &[vmctx]);+ let result = self.builder.func.dfg.inst_results(call).get(0).copied();+ self.raise_if_host_trapped(result.unwrap());++ // Restore the old value of `may_block`self.builder.ins().store(ir::MemFlags::trusted(),old_may_block,diff --git a/crates/cranelift/src/lib.rs b/crates/cranelift/src/lib.rsindex 5ebcf2bcd1..1d1ac61cfc 100644--- a/crates/cranelift/src/lib.rs+++ b/crates/cranelift/src/lib.rs@@ -48,6 +48,8 @@ use self::compiler::Compiler;const TRAP_INTERNAL_ASSERT: TrapCode = TrapCode::unwrap_user(1);const TRAP_OFFSET: u8 = 2;+pub const TRAP_CANNOT_LEAVE_COMPONENT: TrapCode =+ TrapCode::unwrap_user(Trap::CannotLeaveComponent as u8 + TRAP_OFFSET);pub const TRAP_INDIRECT_CALL_TO_NULL: TrapCode =TrapCode::unwrap_user(Trap::IndirectCallToNull as u8 + TRAP_OFFSET);pub const TRAP_BAD_SIGNATURE: TrapCode =diff --git a/crates/environ/src/component.rs b/crates/environ/src/component.rsindex 377a98fe95..edc02acac5 100644--- a/crates/environ/src/component.rs+++ b/crates/environ/src/component.rs@@ -99,6 +99,11 @@ macro_rules! foreach_builtin_component_function {resource_enter_call(vmctx: vmctx);resource_exit_call(vmctx: vmctx) -> bool;+ #[cfg(feature = "component-model-async")]+ enter_sync_call(vmctx: vmctx, caller_instance: u32, callee_async: u32, callee_instance: u32) -> bool;+ #[cfg(feature = "component-model-async")]+ exit_sync_call(vmctx: vmctx) -> bool;+#[cfg(feature = "component-model-async")]backpressure_modify(vmctx: vmctx, caller_instance: u32, increment: u8) -> bool;#[cfg(feature = "component-model-async")]diff --git a/crates/environ/src/component/dfg.rs b/crates/environ/src/component/dfg.rsindex 1c7e991074..f1c4cef3f4 100644--- a/crates/environ/src/component/dfg.rs+++ b/crates/environ/src/component/dfg.rs@@ -160,7 +160,7 @@ pub enum SideEffect {/// as traps and the core wasm `start` function which may call component/// imports. Instantiation order from the original component must be done in/// the same order.- Instance(InstanceId),+ Instance(InstanceId, RuntimeComponentInstanceIndex),/// A resource was declared in this component.///@@ -476,6 +476,8 @@ pub enum Trampoline {StreamTransfer,ErrorContextTransfer,Trap,+ EnterSyncCall,+ ExitSyncCall,ContextGet {instance: RuntimeComponentInstanceIndex,slot: u32,@@ -721,8 +723,8 @@ enum RuntimeInstance {impl LinearizeDfg<'_> {fn side_effect(&mut self, effect: &SideEffect) {match effect {- SideEffect::Instance(i) => {- self.instantiate(*i, &self.dfg.instances[*i]);+ SideEffect::Instance(i, ci) => {+ self.instantiate(*i, &self.dfg.instances[*i], *ci);}SideEffect::Resource(i) => {self.resource(*i, &self.dfg.resources[*i]);@@ -730,7 +732,12 @@ impl LinearizeDfg<'_> {}}- fn instantiate(&mut self, instance: InstanceId, args: &Instance) {+ fn instantiate(+ &mut self,+ instance: InstanceId,+ args: &Instance,+ component_instance: RuntimeComponentInstanceIndex,+ ) {log::trace!("creating instance {instance:?}");let instantiation = match args {Instance::Static(index, args) => InstantiateModule::Static(@@ -751,8 +758,10 @@ impl LinearizeDfg<'_> {),};let index = RuntimeInstanceIndex::new(self.runtime_instances.len());- self.initializers- .push(GlobalInitializer::InstantiateModule(instantiation));+ self.initializers.push(GlobalInitializer::InstantiateModule(+ instantiation,+ Some(component_instance),+ ));let prev = self.runtime_instances.insert(RuntimeInstance::Normal(instance), index);@@ -1156,6 +1165,8 @@ impl LinearizeDfg<'_> {Trampoline::StreamTransfer => info::Trampoline::StreamTransfer,Trampoline::ErrorContextTransfer => info::Trampoline::ErrorContextTransfer,Trampoline::Trap => info::Trampoline::Trap,+ Trampoline::EnterSyncCall => info::Trampoline::EnterSyncCall,+ Trampoline::ExitSyncCall => info::Trampoline::ExitSyncCall,Trampoline::ContextGet { instance, slot } => info::Trampoline::ContextGet {instance: *instance,slot: *slot,@@ -1242,7 +1253,7 @@ impl LinearizeDfg<'_> {let (module_index, args) = &me.dfg.adapter_modules[adapter_module];let args = args.iter().map(|arg| me.core_def(arg)).collect();let instantiate = InstantiateModule::Static(*module_index, args);- GlobalInitializer::InstantiateModule(instantiate)+ GlobalInitializer::InstantiateModule(instantiate, None)},|_, init| init,)diff --git a/crates/environ/src/component/info.rs b/crates/environ/src/component/info.rsindex ea1cb94f7e..2aff54ae68 100644--- a/crates/environ/src/component/info.rs+++ b/crates/environ/src/component/info.rs@@ -243,7 +243,10 @@ pub enum GlobalInitializer {/// involve running the `start` function of the instance as well if it's/// specified. This largely delegates to the same standard instantiation/// process as the rest of the core wasm machinery already uses.- InstantiateModule(InstantiateModule),+ ///+ /// The second field represents the component instance to which the module+ /// belongs, if applicable. This will be `None` for adapter modules.+ InstantiateModule(InstantiateModule, Option<RuntimeComponentInstanceIndex>),/// A host function is being lowered, creating a core wasm function.///@@ -1109,6 +1112,13 @@ pub enum Trampoline {/// code.Trap,+ /// An intrinsic used by FACT-generated modules to push a task onto the+ /// stack for a sync-to-sync, guest-to-guest call.+ EnterSyncCall,+ /// An intrinsic used by FACT-generated modules to pop the task previously+ /// pushed by `EnterSyncCall`.+ ExitSyncCall,+/// Intrinsic used to implement the `context.get` component model builtin.////// The payload here represents that this is accessing the Nth slot of local@@ -1238,6 +1248,8 @@ impl Trampoline {StreamTransfer => format!("stream-transfer"),ErrorContextTransfer => format!("error-context-transfer"),Trap => format!("trap"),+ EnterSyncCall => format!("enter-sync-call"),+ ExitSyncCall => format!("exit-sync-call"),ContextGet { .. } => format!("context-get"),ContextSet { .. } => format!("context-set"),ThreadIndex => format!("thread-index"),diff --git a/crates/environ/src/component/translate.rs b/crates/environ/src/component/translate.rsindex 99b8ae3b9e..78bdb0307e 100644--- a/crates/environ/src/component/translate.rs+++ b/crates/environ/src/component/translate.rs@@ -551,7 +551,7 @@ impl<'a, 'data> Translator<'a, 'data> {PrimaryMap::<RuntimeInstanceIndex, PackedOption<StaticModuleIndex>>::new();for init in &translation.component.initializers {match init {- GlobalInitializer::InstantiateModule(instantiation) => match instantiation {+ GlobalInitializer::InstantiateModule(instantiation, _) => match instantiation {InstantiateModule::Static(module, args) => {instantiations[*module].join(AbstractInstantiations::One(&*args));instance_to_module.push(Some(*module).into());diff --git a/crates/environ/src/component/translate/adapt.rs b/crates/environ/src/component/translate/adapt.rsindex d528099a20..618934ec70 100644--- a/crates/environ/src/component/translate/adapt.rs+++ b/crates/environ/src/component/translate/adapt.rs@@ -208,8 +208,7 @@ impl<'data> Translator<'_, 'data> {// the module using standard core wasm translation, and then fills out// the dfg metadata for each adapter.for (module_id, adapter_module) in state.adapter_modules.iter() {- let mut module =- fact::Module::new(self.types.types(), self.tunables.debug_adapter_modules);+ let mut module = fact::Module::new(self.types.types(), self.tunables);let mut names = Vec::with_capacity(adapter_module.adapters.len());for adapter in adapter_module.adapters.iter() {let name = format!("adapter{}", adapter.as_u32());@@ -349,6 +348,8 @@ fn fact_import_to_core_def(simple_intrinsic(dfg::Trampoline::ErrorContextTransfer)}fact::Import::Trap => simple_intrinsic(dfg::Trampoline::Trap),+ fact::Import::EnterSyncCall => simple_intrinsic(dfg::Trampoline::EnterSyncCall),+ fact::Import::ExitSyncCall => simple_intrinsic(dfg::Trampoline::ExitSyncCall),}}diff --git a/crates/environ/src/component/translate/inline.rs b/crates/environ/src/component/translate/inline.rsindex b6004c62ce..8492b9e04a 100644--- a/crates/environ/src/component/translate/inline.rs+++ b/crates/environ/src/component/translate/inline.rs@@ -1216,7 +1216,7 @@ impl<'a> Inliner<'a> {self.result.side_effects- .push(dfg::SideEffect::Instance(instance));+ .push(dfg::SideEffect::Instance(instance, frame.instance));frame.module_instancesdiff --git a/crates/environ/src/fact.rs b/crates/environ/src/fact.rsindex 77011665a0..f3a131ba15 100644--- a/crates/environ/src/fact.rs+++ b/crates/environ/src/fact.rs@@ -24,7 +24,7 @@ use crate::component::{RuntimeComponentInstanceIndex, StringEncoding, Transcode, TypeFuncIndex,};use crate::fact::transcode::Transcoder;-use crate::{EntityRef, FuncIndex, GlobalIndex, MemoryIndex, PrimaryMap};+use crate::{EntityRef, FuncIndex, GlobalIndex, MemoryIndex, PrimaryMap, Tunables};use crate::{ModuleInternedTypeIndex, prelude::*};use std::collections::HashMap;use wasm_encoder::*;@@ -52,8 +52,8 @@ pub static PREPARE_CALL_FIXED_PARAMS: &[ValType] = &[/// Representation of an adapter module.pub struct Module<'a> {- /// Whether or not debug code is inserted into the adapters themselves.- debug: bool,+ /// Compilation configuration+ tunables: &'a Tunables,/// Type information from the creator of this `Module`types: &'a ComponentTypesBuilder,@@ -88,6 +88,9 @@ pub struct Module<'a> {imported_stream_transfer: Option<FuncIndex>,imported_error_context_transfer: Option<FuncIndex>,+ imported_enter_sync_call: Option<FuncIndex>,+ imported_exit_sync_call: Option<FuncIndex>,+imported_trap: Option<FuncIndex>,// Current status of index spaces from the imports generated so far.@@ -241,9 +244,9 @@ enum HelperLocation {impl<'a> Module<'a> {/// Creates an empty module.- pub fn new(types: &'a ComponentTypesBuilder, debug: bool) -> Module<'a> {+ pub fn new(types: &'a ComponentTypesBuilder, tunables: &'a Tunables) -> Module<'a> {Module {- debug,+ tunables,types,core_types: Default::default(),core_imports: Default::default(),@@ -264,6 +267,8 @@ impl<'a> Module<'a> {imported_future_transfer: None,imported_stream_transfer: None,imported_error_context_transfer: None,+ imported_enter_sync_call: None,+ imported_exit_sync_call: None,imported_trap: None,exports: Vec::new(),task_may_block: None,@@ -737,6 +742,28 @@ impl<'a> Module<'a> {)}+ fn import_enter_sync_call(&mut self) -> FuncIndex {+ self.import_simple(+ "async",+ "enter-sync-call",+ &[ValType::I32; 3],+ &[],+ Import::EnterSyncCall,+ |me| &mut me.imported_enter_sync_call,+ )+ }++ fn import_exit_sync_call(&mut self) -> FuncIndex {+ self.import_simple(+ "async",+ "exit-sync-call",+ &[],+ &[],+ Import::ExitSyncCall,+ |me| &mut me.imported_exit_sync_call,+ )+ }+fn import_trap(&mut self) -> FuncIndex {self.import_simple("runtime",@@ -893,6 +920,13 @@ pub enum Import {ErrorContextTransfer,/// An intrinsic for trapping the instance with a specific trap code.Trap,+ /// An intrinsic used by FACT-generated modules to check whether an instance+ /// may be entered for a sync-to-sync call and push a task onto the stack if+ /// so.+ EnterSyncCall,+ /// An intrinsic used by FACT-generated modules to pop the task previously+ /// pushed by `EnterSyncCall`.+ ExitSyncCall,}impl Options {diff --git a/crates/environ/src/fact/trampoline.rs b/crates/environ/src/fact/trampoline.rsindex 928fdaa72e..160949ae06 100644--- a/crates/environ/src/fact/trampoline.rs+++ b/crates/environ/src/fact/trampoline.rs@@ -180,6 +180,8 @@ pub(super) fn compile(module: &mut Module<'_>, adapter: &AdapterData) {compiler.compile_sync_to_sync_adapter(adapter, &lower_sig, &lift_sig)}(true, true) => {+ assert!(module.tunables.component_model_concurrency);+// In the async->async case, we must compile a couple of helper functions://// - `async-start`: copies the parameters from the caller to the callee@@ -207,6 +209,8 @@ pub(super) fn compile(module: &mut Module<'_>, adapter: &AdapterData) {);}(false, true) => {+ assert!(module.tunables.component_model_concurrency);+// Like the async->async case above, for the sync->async case we// also need `async-start` and `async-return` helper functions to// allow the callee to asynchronously "pull" the parameters and@@ -231,6 +235,8 @@ pub(super) fn compile(module: &mut Module<'_>, adapter: &AdapterData) {);}(true, false) => {+ assert!(module.tunables.component_model_concurrency);+// As with the async->async and sync->async cases above, for the// async->sync case we use `async-start` and `async-return` helper// functions. Here, those functions allow the host to enforce@@ -753,21 +759,46 @@ impl<'a, 'b> Compiler<'a, 'b> {Trap::CannotLeaveComponent,);- let task_may_block = self.module.import_task_may_block();- let old_task_may_block = if self.types[adapter.lift.ty].async_ {- self.instruction(GlobalGet(task_may_block.as_u32()));- self.instruction(I32Eqz);- self.instruction(If(BlockType::Empty));- self.trap(Trap::CannotBlockSyncTask);- self.instruction(End);- None- } else {+ let old_task_may_block = if self.module.tunables.component_model_concurrency {+ // Save, clear, and later restore the `may_block` field.let task_may_block = self.module.import_task_may_block();- self.instruction(GlobalGet(task_may_block.as_u32()));- let old_task_may_block = self.local_set_new_tmp(ValType::I32);- self.instruction(I32Const(0));- self.instruction(GlobalSet(task_may_block.as_u32()));- Some(old_task_may_block)+ let old_task_may_block = if self.types[adapter.lift.ty].async_ {+ self.instruction(GlobalGet(task_may_block.as_u32()));+ self.instruction(I32Eqz);+ self.instruction(If(BlockType::Empty));+ self.trap(Trap::CannotBlockSyncTask);+ self.instruction(End);+ None+ } else {+ let task_may_block = self.module.import_task_may_block();+ self.instruction(GlobalGet(task_may_block.as_u32()));+ let old_task_may_block = self.local_set_new_tmp(ValType::I32);+ self.instruction(I32Const(0));+ self.instruction(GlobalSet(task_may_block.as_u32()));+ Some(old_task_may_block)+ };++ // Push a task onto the current task stack.+ //+ // FIXME: Apply the optimizations described in #12311.++ self.instruction(I32Const(+ i32::try_from(adapter.lower.instance.as_u32()).unwrap(),+ ));+ self.instruction(I32Const(if self.types[adapter.lift.ty].async_ {+ 1+ } else {+ 0+ }));+ self.instruction(I32Const(+ i32::try_from(adapter.lift.instance.as_u32()).unwrap(),+ ));+ let enter_sync_call = self.module.import_enter_sync_call();+ self.instruction(Call(enter_sync_call.as_u32()));++ old_task_may_block+ } else {+ None};if self.emit_resource_call {@@ -840,11 +871,20 @@ impl<'a, 'b> Compiler<'a, 'b> {self.instruction(Call(exit.as_u32()));}- if let Some(old_task_may_block) = old_task_may_block {- let task_may_block = self.module.import_task_may_block();- self.instruction(LocalGet(old_task_may_block.idx));- self.instruction(GlobalSet(task_may_block.as_u32()));- self.free_temp_local(old_task_may_block);+ if self.module.tunables.component_model_concurrency {+ // Pop the task we pushed earlier off of the current task stack.+ //+ // FIXME: Apply the optimizations described in #12311.+ let exit_sync_call = self.module.import_exit_sync_call();+ self.instruction(Call(exit_sync_call.as_u32()));++ // Restore old `may_block_field`+ if let Some(old_task_may_block) = old_task_may_block {+ let task_may_block = self.module.import_task_may_block();+ self.instruction(LocalGet(old_task_may_block.idx));+ self.instruction(GlobalSet(task_may_block.as_u32()));+ self.free_temp_local(old_task_may_block);+ }}self.finish()@@ -1953,7 +1993,7 @@ impl<'a, 'b> Compiler<'a, 'b> {// In debug mode verify the first result consumed the entire string,// otherwise simply discard it.- if self.module.debug {+ if self.module.tunables.debug_adapter_modules {self.instruction(LocalGet(src.len.idx));self.instruction(LocalGet(src_len_tmp.idx));self.ptr_sub(src_mem_opts);@@ -1980,7 +2020,7 @@ impl<'a, 'b> Compiler<'a, 'b> {// If the first transcode was enough then assert that the returned// amount of destination items written equals the byte size.- if self.module.debug {+ if self.module.tunables.debug_adapter_modules {self.instruction(Else);self.instruction(LocalGet(dst.len.idx));@@ -2151,7 +2191,7 @@ impl<'a, 'b> Compiler<'a, 'b> {// Assert that the untagged code unit length is the same as the// source code unit length.- if self.module.debug {+ if self.module.tunables.debug_adapter_modules {self.instruction(LocalGet(dst.len.idx));self.ptr_uconst(dst_mem_opts, !UTF16_TAG);self.ptr_and(dst_mem_opts);@@ -3424,7 +3464,7 @@ impl<'a, 'b> Compiler<'a, 'b> {fn assert_aligned(&mut self, ty: &InterfaceType, mem: &Memory) {let mem_opts = mem.mem_opts();- if !self.module.debug {+ if !self.module.tunables.debug_adapter_modules {return;}let align = self.types.align(mem_opts, ty);@@ -3614,7 +3654,7 @@ impl<'a, 'b> Compiler<'a, 'b> {}fn assert_i64_upper_bits_not_set(&mut self, local: u32) {- if !self.module.debug {+ if !self.module.tunables.debug_adapter_modules {return;}self.instruction(LocalGet(local));diff --git a/crates/environ/src/tunables.rs b/crates/environ/src/tunables.rsindex e68acedb81..5a958a313a 100644--- a/crates/environ/src/tunables.rs+++ b/crates/environ/src/tunables.rs@@ -140,6 +140,10 @@ define_tunables! {/// The general size threshold for the sum of the caller's and callee's/// sizes, past which we will generally not inline calls anymore.pub inlining_sum_size_threshold: u32,++ /// Whether any component model feature related to concurrency is+ /// enabled.+ pub component_model_concurrency: bool,}pub struct ConfigTunables {@@ -215,6 +219,7 @@ impl Tunables {inlining_small_callee_size: 50,inlining_sum_size_threshold: 2000,debug_guest: false,+ component_model_concurrency: true,}}diff --git a/crates/test-programs/src/bin/async_yield_caller_cancel.rs b/crates/test-programs/src/bin/async_yield_caller_cancel.rsindex 807f644ee5..01e1ddd6ec 100644--- a/crates/test-programs/src/bin/async_yield_caller_cancel.rs+++ b/crates/test-programs/src/bin/async_yield_caller_cancel.rs@@ -9,10 +9,7 @@ mod bindings {}use {- bindings::{- exports::local::local::run::Guest,- local::local::{continue_, ready},- },+ bindings::{exports::local::local::run::Guest, local::local::continue_},test_programs::async_::{STATUS_RETURNED, STATUS_STARTED, subtask_cancel},};@@ -31,8 +28,6 @@ struct Component;impl Guest for Component {async fn run() {- let thing = ready::Thing::new();- thing.set_ready(true);continue_::set_continue(true);unsafe {diff --git a/crates/wasmtime/src/config.rs b/crates/wasmtime/src/config.rsindex 8998bac2b3..d500ed9c37 100644--- a/crates/wasmtime/src/config.rs+++ b/crates/wasmtime/src/config.rs@@ -2430,6 +2430,11 @@ impl Config {);}+ #[cfg(feature = "component-model")]+ {+ tunables.component_model_concurrency = self.cm_concurrency_enabled();+ }+Ok((tunables, features))}@@ -2922,17 +2927,13 @@ impl Config {#[inline]pub(crate) fn cm_concurrency_enabled(&self) -> bool {cfg!(feature = "component-model-async")- && (self.enabled_features.contains(WasmFeatures::CM_ASYNC)- || self- .enabled_features- .contains(WasmFeatures::CM_ASYNC_BUILTINS)- || self- .enabled_features- .contains(WasmFeatures::CM_ASYNC_STACKFUL)- || self.enabled_features.contains(WasmFeatures::CM_THREADING)- || self- .enabled_features- .contains(WasmFeatures::CM_ERROR_CONTEXT))+ && self.enabled_features.intersects(+ WasmFeatures::CM_ASYNC+ | WasmFeatures::CM_ASYNC_BUILTINS+ | WasmFeatures::CM_ASYNC_STACKFUL+ | WasmFeatures::CM_THREADING+ | WasmFeatures::CM_ERROR_CONTEXT,+ )}}diff --git a/crates/wasmtime/src/engine/serialization.rs b/crates/wasmtime/src/engine/serialization.rsindex 3584e07b06..1901839712 100644--- a/crates/wasmtime/src/engine/serialization.rs+++ b/crates/wasmtime/src/engine/serialization.rs@@ -285,6 +285,7 @@ impl Metadata<'_> {inlining_intra_module,inlining_small_callee_size,inlining_sum_size_threshold,+ component_model_concurrency,// This doesn't affect compilation, it's just a runtime setting.memory_reservation_for_growth: _,@@ -365,6 +366,11 @@ impl Metadata<'_> {other.inlining_sum_size_threshold,"function inlining sum-size threshold",)?;+ Self::check_bool(+ component_model_concurrency,+ other.component_model_concurrency,+ "component model concurrency",+ )?;Self::check_intra_module_inlining(inlining_intra_module, other.inlining_intra_module)?;Ok(())diff --git a/crates/wasmtime/src/runtime/component/component.rs b/crates/wasmtime/src/runtime/component/component.rsindex 495f859b4b..45f1e03821 100644--- a/crates/wasmtime/src/runtime/component/component.rs+++ b/crates/wasmtime/src/runtime/component/component.rs@@ -653,7 +653,7 @@ impl Component {};for init in &self.env_component().initializers {match init {- GlobalInitializer::InstantiateModule(inst) => match inst {+ GlobalInitializer::InstantiateModule(inst, _) => match inst {InstantiateModule::Static(index, _) => {let module = self.static_module(*index);resources.add(&module.resources_required());diff --git a/crates/wasmtime/src/runtime/component/concurrent.rs b/crates/wasmtime/src/runtime/component/concurrent.rsindex 52f5227d05..fcff9d5965 100644--- a/crates/wasmtime/src/runtime/component/concurrent.rs+++ b/crates/wasmtime/src/runtime/component/concurrent.rs@@ -94,6 +94,7 @@ use wasmtime_environ::component::{TypeComponentGlobalErrorContextTableIndex, TypeComponentLocalErrorContextTableIndex,TypeFuncIndex, TypeFutureTableIndex, TypeStreamTableIndex, TypeTupleIndex,};+use wasmtime_environ::packed_option::ReservedValue;pub use abort::JoinHandle;pub use future_stream_any::{FutureAny, StreamAny};@@ -720,19 +721,11 @@ pub(crate) fn poll_and_block<R: Send + Sync + 'static>(future: impl Future<Output = Result<R>> + Send + 'static,caller_instance: RuntimeInstance,) -> Result<R> {+ store.check_may_leave(caller_instance)?;+let state = store.concurrent_state_mut();- // If there is no current guest thread set, that means the host function was- // registered using e.g. `LinkerInstance::func_wrap`, in which case it- // should complete immediately.- let Some(caller) = state.guest_thread else {- return match pin!(future).poll(&mut Context::from_waker(&Waker::noop())) {- Poll::Ready(result) => result,- Poll::Pending => {- unreachable!()- }- };- };+ let caller = state.guest_thread.unwrap();// Save any existing result stashed in `GuestTask::result` so we can replace// it with the new result.@@ -1391,6 +1384,128 @@ impl<T> StoreContextMut<'_, T> {}impl StoreOpaque {+ fn check_may_leave(&mut self, instance: RuntimeInstance) -> Result<()> {+ Instance::from_wasmtime(self, instance.instance)+ .id()+ .get(self)+ .check_may_leave(instance.index)?;++ // While we're here, verify that the caller instance matches the most+ // recent task pushed onto the task stack:+ let state = self.concurrent_state_mut();+ let caller = state.guest_thread.unwrap();+ assert_eq!(state.get_mut(caller.task)?.instance, instance);++ Ok(())+ }++ /// Push a `GuestTask` onto the task stack for either a sync-to-sync,+ /// guest-to-guest call or a sync host-to-guest call.+ ///+ /// This task will only be used for the purpose of handling calls to+ /// intrinsic functions; both parameter lowering and result lifting are+ /// assumed to be taken care of elsewhere.+ pub(crate) fn enter_sync_call(+ &mut self,+ guest_caller: Option<RuntimeInstance>,+ callee_async: bool,+ callee: RuntimeInstance,+ ) -> Result<()> {+ log::trace!("enter sync call {callee:?}");++ let state = self.concurrent_state_mut();+ let thread = state.guest_thread;+ let instance = if let Some(thread) = thread {+ Some(state.get_mut(thread.task)?.instance)+ } else {+ None+ };+ let task = GuestTask::new(+ state,+ Box::new(move |_, _| unreachable!()),+ LiftResult {+ lift: Box::new(move |_, _| unreachable!()),+ ty: TypeTupleIndex::reserved_value(),+ memory: None,+ string_encoding: StringEncoding::Utf8,+ },+ if let Some(caller) = guest_caller {+ assert_eq!(caller, instance.unwrap());+ Caller::Guest {+ thread: thread.unwrap(),+ }+ } else {+ Caller::Host {+ tx: None,+ exit_tx: Arc::new(oneshot::channel().0),+ host_future_present: false,+ call_post_return_automatically: false,+ caller: state.guest_thread,+ }+ },+ None,+ callee,+ callee_async,+ )?;++ let guest_task = state.push(task)?;+ let new_thread = GuestThread::new_implicit(guest_task);+ let guest_thread = state.push(new_thread)?;+ Instance::from_wasmtime(self, callee.instance).add_guest_thread_to_instance_table(+ guest_thread,+ self,+ callee.index,+ )?;++ let state = self.concurrent_state_mut();+ state.get_mut(guest_task)?.threads.insert(guest_thread);+ if guest_caller.is_some() {+ let thread = state.guest_thread.unwrap();+ state.get_mut(thread.task)?.subtasks.insert(guest_task);+ }++ self.set_thread(Some(QualifiedThreadId {+ task: guest_task,+ thread: guest_thread,+ }));++ Ok(())+ }++ /// Pop a `GuestTask` previously pushed using `enter_sync_call`.+ pub(crate) fn exit_sync_call(&mut self, guest_caller: bool) -> Result<()> {+ let thread = self.set_thread(None).unwrap();+ let instance = self.concurrent_state_mut().get_mut(thread.task)?.instance;+ log::trace!("exit sync call {instance:?}");+ Instance::from_wasmtime(self, instance.instance).cleanup_thread(+ self,+ thread,+ instance.index,+ )?;++ let state = self.concurrent_state_mut();+ let task = state.get_mut(thread.task)?;+ let caller = match &task.caller {+ &Caller::Guest { thread } => {+ assert!(guest_caller);+ Some(thread)+ }+ &Caller::Host { caller, .. } => {+ assert!(!guest_caller);+ caller+ }+ };+ self.set_thread(caller);++ let state = self.concurrent_state_mut();+ let task = state.get_mut(thread.task)?;+ if task.ready_to_delete() {+ state.delete(thread.task)?.dispose(state, thread.task)?;+ }++ Ok(())+ }+/// Determine whether the specified instance may be entered from the host.////// We return `true` here only if all of the following hold:@@ -1409,6 +1524,11 @@ impl StoreOpaque {}}+ /// Returns `false` if the specified instance may not be entered, regardless+ /// of what's on a task's call stack.+ ///+ /// If this returns `true`, the instance may be entered as long as it isn't+ /// on the task's call stack, if applicable.fn may_enter_at_all(&self, instance: RuntimeInstance) -> bool {if self.trapped() {return false;@@ -1457,8 +1577,8 @@ impl StoreOpaque {caller}}- &Caller::Guest { thread, instance } => {- if instance.instance == guest_instance {+ &Caller::Guest { thread } => {+ if state.get_mut(thread.task).unwrap().instance.instance == guest_instance {break false;} else {thread@@ -1753,6 +1873,17 @@ impl StoreOpaque {}impl Instance {+ fn check_may_leave(+ self,+ store: &mut StoreOpaque,+ caller: RuntimeComponentInstanceIndex,+ ) -> Result<()> {+ store.check_may_leave(RuntimeInstance {+ instance: self.id().instance(),+ index: caller,+ })+ }+/// Get the next pending event for the specified task and (optional)/// waitable set, along with the waitable handle if applicable.fn get_event(@@ -2263,7 +2394,7 @@ impl Instance {string_encoding: u8,caller_info: CallerInfo,) -> Result<()> {- self.id().get(store.0).check_may_leave(caller_instance)?;+ self.check_may_leave(store.0, caller_instance)?;if let (CallerInfo::Sync { .. }, true) = (&caller_info, callee_async) {// A task may only call an async-typed function via a sync lower if@@ -2307,7 +2438,16 @@ impl Instance {let return_ = SendSyncPtr::new(NonNull::new(return_).unwrap());let token = StoreToken::new(store.as_context_mut());let state = store.0.concurrent_state_mut();- let old_thread = state.guest_thread.take();+ let old_thread = state.guest_thread.unwrap();++ assert_eq!(+ state.get_mut(old_thread.task)?.instance,+ RuntimeInstance {+ instance: self.id().instance(),+ index: caller_instance,+ }+ );+let new_task = GuestTask::new(state,Box::new(move |store, dst| {@@ -2404,13 +2544,7 @@ impl Instance {memory: NonNull::new(memory).map(SendSyncPtr::new),string_encoding: StringEncoding::from_u8(string_encoding).unwrap(),},- Caller::Guest {- thread: old_thread.unwrap(),- instance: RuntimeInstance {- instance: self.id().instance(),- index: caller_instance,- },- },+ Caller::Guest { thread: old_thread },None,RuntimeInstance {instance: self.id().instance(),@@ -2424,10 +2558,12 @@ impl Instance {let guest_thread = state.push(new_thread)?;state.get_mut(guest_task)?.threads.insert(guest_thread);- let state = store.0.concurrent_state_mut();- if let Some(old_thread) = old_thread {- state.get_mut(old_thread.task)?.subtasks.insert(guest_task);- };+ store+ .0+ .concurrent_state_mut()+ .get_mut(old_thread.task)?+ .subtasks+ .insert(guest_task);// Make the new thread the current one so that `Self::start_call` knows// which one to start.@@ -2519,17 +2655,13 @@ impl Instance {}));}- let Caller::Guest {- thread: caller,- instance: runtime_instance,- } = &task.caller- else {+ let Caller::Guest { thread: caller } = &task.caller else {// As of this writing, `start_call` is only used for guest->guest// calls.unreachable!()};let caller = *caller;- let caller_instance = *runtime_instance;+ let caller_instance = state.get_mut(caller.task)?.instance;// Queue the call as a "high priority" work item.unsafe {@@ -2808,7 +2940,8 @@ impl Instance {options: OptionsIndex,storage: &[ValRaw],) -> Result<()> {- self.id().get(store).check_may_leave(caller)?;+ self.check_may_leave(store, caller)?;+let state = store.concurrent_state_mut();let guest_thread = state.guest_thread.unwrap();let lift = state@@ -2865,7 +2998,8 @@ impl Instance {store: &mut StoreOpaque,caller: RuntimeComponentInstanceIndex,) -> Result<()> {- self.id().get(store).check_may_leave(caller)?;+ self.check_may_leave(store, caller)?;+let state = store.concurrent_state_mut();let guest_thread = state.guest_thread.unwrap();let task = state.get_mut(guest_thread.task)?;@@ -2951,7 +3085,8 @@ impl Instance {store: &mut StoreOpaque,caller_instance: RuntimeComponentInstanceIndex,) -> Result<u32> {- self.id().get_mut(store).check_may_leave(caller_instance)?;+ self.check_may_leave(store, caller_instance)?;+let set = store.concurrent_state_mut().push(WaitableSet::default())?;let handle = store.handle_table(RuntimeInstance {@@ -2970,7 +3105,8 @@ impl Instance {caller_instance: RuntimeComponentInstanceIndex,set: u32,) -> Result<()> {- self.id().get_mut(store).check_may_leave(caller_instance)?;+ self.check_may_leave(store, caller_instance)?;+let rep = store.handle_table(RuntimeInstance {instance: self.id().instance(),@@ -2999,8 +3135,9 @@ impl Instance {waitable_handle: u32,set_handle: u32,) -> Result<()> {+ self.check_may_leave(store, caller_instance)?;+let mut instance = self.id().get_mut(store);- instance.check_may_leave(caller_instance)?;let waitable =Waitable::from_instance(instance.as_mut(), caller_instance, waitable_handle)?;@@ -3028,7 +3165,8 @@ impl Instance {caller_instance: RuntimeComponentInstanceIndex,task_id: u32,) -> Result<()> {- self.id().get_mut(store).check_may_leave(caller_instance)?;+ self.check_may_leave(store, caller_instance)?;+self.waitable_join(store, caller_instance, task_id, 0)?;let (rep, is_host) = store@@ -3052,8 +3190,12 @@ impl Instance {if task.lift_result.is_some() {bail!("cannot drop a subtask which has not yet resolved");}- if let Caller::Guest { instance, .. } = &task.caller {- (Waitable::Guest(id), *instance, task.exited)+ if let &Caller::Guest { thread } = &task.caller {+ (+ Waitable::Guest(id),+ concurrent_state.get_mut(thread.task)?.instance,+ concurrent_state.get_mut(id)?.exited,+ )} else {unreachable!()}@@ -3092,7 +3234,7 @@ impl Instance {set: u32,payload: u32,) -> Result<u32> {- self.id().get(store).check_may_leave(caller)?;+ self.check_may_leave(store, caller)?;if !self.options(store, options).async_ {// The caller may only call `waitable-set.wait` from an async task@@ -3134,7 +3276,7 @@ impl Instance {set: u32,payload: u32,) -> Result<u32> {- self.id().get(store).check_may_leave(caller)?;+ self.check_may_leave(store, caller)?;let &CanonicalOptions {cancellable,@@ -3162,11 +3304,7 @@ impl Instance {/// Implements the `thread.index` intrinsic.pub(crate) fn thread_index(&self, store: &mut dyn VMStore) -> Result<u32> {- let thread_id = store- .concurrent_state_mut()- .guest_thread- .ok_or_else(|| format_err!("no current thread"))?- .thread;+ let thread_id = store.concurrent_state_mut().guest_thread.unwrap().thread;// The unwrap is safe because `instance_rep` must be `Some` by this pointOk(store.concurrent_state_mut()@@ -3185,7 +3323,7 @@ impl Instance {start_func_idx: u32,context: i32,) -> Result<u32> {- self.id().get(store.0).check_may_leave(runtime_instance)?;+ self.check_may_leave(store.0, runtime_instance)?;log::trace!("creating new thread");@@ -3321,7 +3459,7 @@ impl Instance {yielding: bool,to_thread: Option<u32>,) -> Result<WaitResult> {- self.id().get(store).check_may_leave(caller)?;+ self.check_may_leave(store, caller)?;if to_thread.is_none() {let state = store.concurrent_state_mut();@@ -3472,7 +3610,7 @@ impl Instance {async_: bool,task_id: u32,) -> Result<u32> {- self.id().get(store).check_may_leave(caller_instance)?;+ self.check_may_leave(store, caller_instance)?;if !async_ {// The caller may only sync call `subtask.cancel` from an async task@@ -3495,10 +3633,11 @@ impl Instance {)} else {let id = TableId::<GuestTask>::new(rep);- if let Caller::Guest { instance, .. } =- &store.concurrent_state_mut().get_mut(id)?.caller- {- (Waitable::Guest(id), *instance)+ if let &Caller::Guest { thread } = &store.concurrent_state_mut().get_mut(id)?.caller {+ (+ Waitable::Guest(id),+ store.concurrent_state_mut().get_mut(thread.task)?.instance,+ )} else {unreachable!()}@@ -3627,7 +3766,8 @@ impl Instance {caller: RuntimeComponentInstanceIndex,slot: u32,) -> Result<u32> {- self.id().get(store).check_may_leave(caller)?;+ self.check_may_leave(store, caller)?;+store.concurrent_state_mut().context_get(slot)}@@ -3638,7 +3778,8 @@ impl Instance {slot: u32,value: u32,) -> Result<()> {- self.id().get(store).check_may_leave(caller)?;+ self.check_may_leave(store, caller)?;+store.concurrent_state_mut().context_set(slot, value)}}@@ -3926,7 +4067,8 @@ impl<T: 'static> VMComponentAsyncStore for StoreInner<T> {future: u32,address: u32,) -> Result<u32> {- instance.id().get(self).check_may_leave(caller)?;+ instance.check_may_leave(self, caller)?;+instance.guest_write(StoreContextMut(self),@@ -3950,7 +4092,8 @@ impl<T: 'static> VMComponentAsyncStore for StoreInner<T> {future: u32,address: u32,) -> Result<u32> {- instance.id().get(self).check_may_leave(caller)?;+ instance.check_may_leave(self, caller)?;+instance.guest_read(StoreContextMut(self),@@ -3975,7 +4118,8 @@ impl<T: 'static> VMComponentAsyncStore for StoreInner<T> {address: u32,count: u32,) -> Result<u32> {- instance.id().get(self).check_may_leave(caller)?;+ instance.check_may_leave(self, caller)?;+instance.guest_write(StoreContextMut(self),@@ -4000,7 +4144,8 @@ impl<T: 'static> VMComponentAsyncStore for StoreInner<T> {address: u32,count: u32,) -> Result<u32> {- instance.id().get(self).check_may_leave(caller)?;+ instance.check_may_leave(self, caller)?;+instance.guest_read(StoreContextMut(self),@@ -4022,7 +4167,8 @@ impl<T: 'static> VMComponentAsyncStore for StoreInner<T> {ty: TypeFutureTableIndex,writer: u32,) -> Result<()> {- instance.id().get(self).check_may_leave(caller)?;+ instance.check_may_leave(self, caller)?;+instance.guest_drop_writable(self, TransmitIndex::Future(ty), writer)}@@ -4038,7 +4184,8 @@ impl<T: 'static> VMComponentAsyncStore for StoreInner<T> {address: u32,count: u32,) -> Result<u32> {- instance.id().get(self).check_may_leave(caller)?;+ instance.check_may_leave(self, caller)?;+instance.guest_write(StoreContextMut(self),@@ -4068,7 +4215,8 @@ impl<T: 'static> VMComponentAsyncStore for StoreInner<T> {address: u32,count: u32,) -> Result<u32> {- instance.id().get(self).check_may_leave(caller)?;+ instance.check_may_leave(self, caller)?;+instance.guest_read(StoreContextMut(self),@@ -4093,7 +4241,8 @@ impl<T: 'static> VMComponentAsyncStore for StoreInner<T> {ty: TypeStreamTableIndex,writer: u32,) -> Result<()> {- instance.id().get(self).check_may_leave(caller)?;+ instance.check_may_leave(self, caller)?;+instance.guest_drop_writable(self, TransmitIndex::Stream(ty), writer)}@@ -4106,7 +4255,8 @@ impl<T: 'static> VMComponentAsyncStore for StoreInner<T> {err_ctx_handle: u32,debug_msg_address: u32,) -> Result<()> {- instance.id().get(self).check_may_leave(caller)?;+ instance.check_may_leave(self, caller)?;+instance.error_context_debug_message(StoreContextMut(self),ty,@@ -4191,12 +4341,6 @@ enum Caller {Guest {/// The id of the callerthread: QualifiedThreadId,- /// The instance to use to enforce reentrance rules.- ///- /// Note that this might not be the same as the instance the caller task- /// started executing in given that one or more synchronous guest->guest- /// calls may have occurred involving multiple instances.- instance: RuntimeInstance,},}@@ -4496,10 +4640,7 @@ impl GuestTask {// Reparent any pending subtasks to the caller.match &self.caller {- Caller::Guest {- thread,- instance: runtime_instance,- } => {+ Caller::Guest { thread } => {let task_mut = state.get_mut(thread.task)?;let present = task_mut.subtasks.remove(&me);assert!(present);@@ -4509,10 +4650,7 @@ impl GuestTask {}for subtask in &self.subtasks {- state.get_mut(*subtask)?.caller = Caller::Guest {- thread: *thread,- instance: *runtime_instance,- };+ state.get_mut(*subtask)?.caller = Caller::Guest { thread: *thread };}}Caller::Host {@@ -4534,7 +4672,8 @@ impl GuestTask {}for subtask in self.subtasks {- if state.get_mut(subtask)?.exited {+ let task = state.get_mut(subtask)?;+ if task.exited && task.ready_to_delete() {Waitable::Guest(subtask).delete_from(state)?;}}diff --git a/crates/wasmtime/src/runtime/component/concurrent_disabled.rs b/crates/wasmtime/src/runtime/component/concurrent_disabled.rsindex bf71039321..fa8ea16708 100644--- a/crates/wasmtime/src/runtime/component/concurrent_disabled.rs+++ b/crates/wasmtime/src/runtime/component/concurrent_disabled.rs@@ -1,6 +1,7 @@use crate::component::func::{LiftContext, LowerContext};use crate::component::matching::InstanceType;-use crate::component::{ComponentType, Lift, Lower, Val};+use crate::component::{ComponentType, Lift, Lower, RuntimeInstance, Val};+use crate::store::StoreOpaque;use crate::{Result, bail, error::format_err};use core::convert::Infallible;use core::mem::MaybeUninit;@@ -149,3 +150,22 @@ unsafe impl Lower for StreamAny {match self.0 {}}}++impl StoreOpaque {+ pub(crate) fn enter_sync_call(+ &mut self,+ _guest_caller: Option<RuntimeInstance>,+ _callee_async: bool,+ _callee: RuntimeInstance,+ ) -> Result<()> {+ // If we've reached here, the user somehow managed to enable the+ // `component-model-async` runtime config feature without enabling the+ // corresponding compile-time feature.+ unreachable!()+ }++ pub(crate) fn exit_sync_call(&mut self, _guest_caller: bool) -> Result<()> {+ // See comment in `enter_sync_call`+ unreachable!()+ }+}diff --git a/crates/wasmtime/src/runtime/component/func.rs b/crates/wasmtime/src/runtime/component/func.rsindex eca12988d9..e56d933ab0 100644--- a/crates/wasmtime/src/runtime/component/func.rs+++ b/crates/wasmtime/src/runtime/component/func.rs@@ -610,6 +610,11 @@ impl Func {bail!(crate::Trap::CannotEnterComponent);}+ if store.engine().config().cm_concurrency_enabled() {+ let async_type = self.abi_async(store.0);+ store.0.enter_sync_call(None, async_type, instance)?;+ }+#[repr(C)]union Union<Params: Copy, Return: Copy> {params: Params,@@ -688,6 +693,7 @@ impl Func {_ => unreachable!(),},);+return Ok(val);}@@ -719,7 +725,7 @@ impl Func {pub fn post_return(&self, mut store: impl AsContextMut) -> Result<()> {let store = store.as_context_mut();store.0.validate_sync_call()?;- self.post_return_impl(store)+ self.post_return_impl(store, false)}/// Exactly like [`Self::post_return`] except for invoke WebAssembly@@ -730,10 +736,12 @@ impl Func {// Future optimization opportunity: conditionally use a fiber here since// some func's post_return will not need the async context (i.e. end up// calling async host functionality)- store.on_fiber(|store| self.post_return_impl(store)).await?+ store+ .on_fiber(|store| self.post_return_impl(store, true))+ .await?}- fn post_return_impl(&self, mut store: impl AsContextMut) -> Result<()> {+ fn post_return_impl(&self, mut store: impl AsContextMut, async_: bool) -> Result<()> {let mut store = store.as_context_mut();let index = self.index;@@ -803,6 +811,10 @@ impl Func {guest: Some(instance.instance_states()),}.exit_call()?;++ if !async_ && store.engine().config().cm_concurrency_enabled() {+ store.0.exit_sync_call(false)?;+ }}Ok(())}diff --git a/crates/wasmtime/src/runtime/component/instance.rs b/crates/wasmtime/src/runtime/component/instance.rsindex c00870e155..887313e788 100644--- a/crates/wasmtime/src/runtime/component/instance.rs+++ b/crates/wasmtime/src/runtime/component/instance.rs@@ -1,3 +1,4 @@+use crate::component::RuntimeInstance;use crate::component::func::HostFunc;use crate::component::matching::InstanceType;use crate::component::store::{ComponentInstanceId, StoreComponentInstanceId};@@ -837,7 +838,8 @@ impl<'a> Instantiator<'a> {for initializer in env_component.initializers.iter() {match initializer {- GlobalInitializer::InstantiateModule(m) => {+ GlobalInitializer::InstantiateModule(m, component_instance) => {+ let instance = self.id;let module;let imports = match m {// Since upvars are statically know we know that the@@ -867,6 +869,23 @@ impl<'a> Instantiator<'a> {}};+ let exit = if let (&Some(component_instance), true) = (+ component_instance,+ store.engine().config().cm_concurrency_enabled(),+ ) {+ store.0.enter_sync_call(+ None,+ false,+ RuntimeInstance {+ instance,+ index: component_instance,+ },+ )?;+ true+ } else {+ false+ };+// Note that the unsafety here should be ok because the// validity of the component means that type-checks have// already been performed. This means that the unsafety due@@ -880,6 +899,11 @@ impl<'a> Instantiator<'a> {crate::Instance::new_started(store, module, imports.as_ref(), asyncness).await?};++ if exit {+ store.0.exit_sync_call(false)?;+ }+self.instance_mut(store.0).push_instance_id(i.id());}@@ -1202,6 +1226,7 @@ impl<T: 'static> InstancePre<T> {.decrement_component_instance_count();e})?;+let instance = Instance::from_wasmtime(store.0, instantiator.id);store.0.push_component_instance(instance);Ok(instance)diff --git a/crates/wasmtime/src/runtime/component/resources/any.rs b/crates/wasmtime/src/runtime/component/resources/any.rsindex 642a60295e..78c417b672 100644--- a/crates/wasmtime/src/runtime/component/resources/any.rs+++ b/crates/wasmtime/src/runtime/component/resources/any.rs@@ -197,12 +197,30 @@ impl ResourceAny {};let mut args = [ValRaw::u32(rep)];+ let exit = if let (Some(instance), true) = (+ slot.instance,+ store.engine().config().cm_concurrency_enabled(),+ ) {+ store.0.enter_sync_call(None, false, instance)?;+ true+ } else {+ false+ };+// This should be safe because `dtor` has been checked to belong to the// `store` provided which means it's valid and still alive. Additionally// destructors have al been previously type-checked and are guaranteed// to take one i32 argument and return no results, so the parameters// here should be configured correctly.- unsafe { crate::Func::call_unchecked_raw(store, dtor, NonNull::from(&mut args)) }+ unsafe {+ crate::Func::call_unchecked_raw(store, dtor, NonNull::from(&mut args))?;+ }++ if exit {+ store.0.exit_sync_call(false)?;+ }++ Ok(())}fn lower_to_index<U>(&self, cx: &mut LowerContext<'_, U>, ty: InterfaceType) -> Result<u32> {diff --git a/crates/wasmtime/src/runtime/vm/component/libcalls.rs b/crates/wasmtime/src/runtime/vm/component/libcalls.rsindex bb426e98e1..e8ee548e19 100644--- a/crates/wasmtime/src/runtime/vm/component/libcalls.rs+++ b/crates/wasmtime/src/runtime/vm/component/libcalls.rs@@ -673,6 +673,32 @@ fn trap(_store: &mut dyn VMStore, _instance: Instance, code: u32) -> Result<()>.into())}+#[cfg(feature = "component-model-async")]+fn enter_sync_call(+ store: &mut dyn VMStore,+ instance: Instance,+ caller_instance: u32,+ callee_async: u32,+ callee_instance: u32,+) -> Result<()> {+ store.enter_sync_call(+ Some(RuntimeInstance {+ instance: instance.id().instance(),+ index: RuntimeComponentInstanceIndex::from_u32(caller_instance),+ }),+ callee_async != 0,+ RuntimeInstance {+ instance: instance.id().instance(),+ index: RuntimeComponentInstanceIndex::from_u32(callee_instance),+ },+ )+}++#[cfg(feature = "component-model-async")]+fn exit_sync_call(store: &mut dyn VMStore, _instance: Instance) -> Result<()> {+ store.exit_sync_call(true)+}+#[cfg(feature = "component-model-async")]fn backpressure_modify(store: &mut dyn VMStore,diff --git a/crates/wasmtime/src/runtime/vm/instance/allocator/pooling.rs b/crates/wasmtime/src/runtime/vm/instance/allocator/pooling.rsindex 0c78df7aef..3c40b8fa47 100644--- a/crates/wasmtime/src/runtime/vm/instance/allocator/pooling.rs+++ b/crates/wasmtime/src/runtime/vm/instance/allocator/pooling.rs@@ -569,12 +569,12 @@ unsafe impl InstanceAllocator for PoolingInstanceAllocator {use wasmtime_environ::component::GlobalInitializer::*;use wasmtime_environ::component::InstantiateModule;match init {- InstantiateModule(InstantiateModule::Import(_, _)) => {+ InstantiateModule(InstantiateModule::Import(_, _), _) => {num_core_instances += 1;// Can't statically account for the total vmctx size, number// of memories, and number of tables in this component.}- InstantiateModule(InstantiateModule::Static(static_module_index, _)) => {+ InstantiateModule(InstantiateModule::Static(static_module_index, _), _) => {let module = get_module(*static_module_index);let offsets = VMOffsets::new(HostPtr, &module);self.validate_module(module, &offsets)?;diff --git a/tests/all/component_model.rs b/tests/all/component_model.rsindex daa5d55348..4ad94b84eb 100644--- a/tests/all/component_model.rs+++ b/tests/all/component_model.rs@@ -3,7 +3,7 @@ use std::iter;use wasmtime::Result;use wasmtime::component::Component;use wasmtime_component_util::REALLOC_AND_FREE;-use wasmtime_test_util::component::{TypedFuncExt, async_engine, engine};+use wasmtime_test_util::component::{TypedFuncExt, async_engine, config, engine};mod aot;mod r#async;diff --git a/tests/all/component_model/func.rs b/tests/all/component_model/func.rsindex 331a623c6d..2bc1d6ad02 100644--- a/tests/all/component_model/func.rs+++ b/tests/all/component_model/func.rs@@ -3455,8 +3455,259 @@ fn test_recurse(kind: RecurseKind) -> Result<()> {}};- let run = instance.get_typed_func::<(), ()>(&mut store, "export")?;- run.call(&mut store, ())?;+ let export = instance.get_typed_func::<(), ()>(&mut store, "export")?;+ export.call(&mut store, ())?;+ Ok(())+}++#[test]+fn thread_index_during_init() -> Result<()> {+ let component = r#"+(component+ (core module $m+ (import "" "thread.index" (func $thread-index (result i32)))+ (func $start+ (if (i32.eqz (call $thread-index)) (then unreachable))+ )+ (start $start)+ )+ (core func $thread-index (canon thread.index))+ (core instance $m (instantiate $m (with "" (instance+ (export "thread.index" (func $thread-index))+ ))))+)+"#;+ let mut config = super::config();+ config.wasm_component_model_threading(true);+ let engine = Engine::new(&config)?;+ let component = Component::new(&engine, component)?;+ let mut store = Store::new(&engine, ());+ let linker = Linker::new(&engine);+ linker.instantiate(&mut store, &component)?;+ Ok(())+}++#[test]+fn thread_index_via_sync_host_call() -> Result<()> {+ let component = r#"+(component+ (core module $m+ (import "" "thread.index" (func $thread-index (result i32)))+ (func (export "run")+ (if (i32.eqz (call $thread-index)) (then unreachable))+ )+ )+ (core func $thread-index (canon thread.index))+ (core instance $m (instantiate $m (with "" (instance+ (export "thread.index" (func $thread-index))+ ))))+ (func (export "run") (canon lift (core func $m "run")))+)+"#;+ let mut config = super::config();+ config.wasm_component_model_threading(true);+ let engine = Engine::new(&config)?;+ let component = Component::new(&engine, component)?;+ let mut store = Store::new(&engine, ());+ let linker = Linker::new(&engine);+ let instance = linker.instantiate(&mut store, &component)?;+ let run = instance.get_typed_func::<(), ()>(&mut store, "run")?;+ run.call_and_post_return(&mut store, ())?;+ Ok(())+}++#[test]+fn thread_index_via_sync_host_call_post_return() -> Result<()> {+ let component = r#"+(component+ (core module $m+ (import "" "thread.index" (func $thread-index (result i32)))+ (global $index (mut i32) (i32.const 0))+ (func (export "run")+ (global.set $index (call $thread-index))+ (if (i32.eqz (global.get $index)) (then unreachable))+ )+ (func (export "run-post-return")+ (local $index i32)+ (local.set $index (call $thread-index))+ (if (i32.eqz (local.get $index)) (then unreachable))+ (if (i32.ne (local.get $index) (global.get $index)) (then unreachable))+ )+ )+ (core func $thread-index (canon thread.index))+ (core instance $m (instantiate $m (with "" (instance+ (export "thread.index" (func $thread-index))+ ))))+ (func (export "run") (canon lift (core func $m "run") (post-return (func $m "run-post-return"))))+)+"#;+ let mut config = super::config();+ config.wasm_component_model_threading(true);+ let engine = Engine::new(&config)?;+ let component = Component::new(&engine, component)?;+ let mut store = Store::new(&engine, ());+ let linker = Linker::new(&engine);+ let instance = linker.instantiate(&mut store, &component)?;+ let run = instance.get_typed_func::<(), ()>(&mut store, "run")?;+ run.call_and_post_return(&mut store, ())?;+ Ok(())+}++#[test]+fn thread_index_via_sync_host_call_cabi_realloc() -> Result<()> {+ let component = r#"+(component+ (core module $m+ (import "" "thread.index" (func $thread-index (result i32)))+ (global $index (mut i32) (i32.const 0))+ (memory (export "memory") 1)+ (func (export "realloc") (param i32 i32 i32 i32) (result i32)+ (global.set $index (call $thread-index))+ (if (i32.eqz (global.get $index)) (then unreachable))+ (i32.const 100)+ )+ (func (export "run") (param i32 i32)+ (local $index i32)+ (local.set $index (call $thread-index))+ (if (i32.eqz (local.get $index)) (then unreachable))+ (if (i32.ne (local.get $index) (global.get $index)) (then unreachable))+ )+ )+ (core func $thread-index (canon thread.index))+ (core instance $m (instantiate $m (with "" (instance+ (export "thread.index" (func $thread-index))+ ))))+ (func (export "run") (param "s" string) (canon lift+ (core func $m "run")+ (memory $m "memory")+ (realloc (func $m "realloc"))+ ))+)+"#;+ let mut config = super::config();+ config.wasm_component_model_threading(true);+ let engine = Engine::new(&config)?;+ let component = Component::new(&engine, component)?;+ let mut store = Store::new(&engine, ());+ let linker = Linker::new(&engine);+ let instance = linker.instantiate(&mut store, &component)?;+ let run = instance.get_typed_func::<(&str,), ()>(&mut store, "run")?;+ run.call_and_post_return(&mut store, ("hola",))?;+ Ok(())+}++#[test]+fn thread_index_via_resource_drop_from_host() -> Result<()> {+ let component = r#"+(component+ (core module $m+ (import "" "thread.index" (func $thread-index (result i32)))+ (func (export "dtor") (param i32)+ (if (i32.eqz (call $thread-index)) (then unreachable))+ )+ )+ (core func $thread-index (canon thread.index))+ (core instance $m (instantiate $m (with "" (instance+ (export "thread.index" (func $thread-index))+ ))))+ (type $r (resource (rep i32) (dtor (func $m "dtor"))))+ (core func $new (canon resource.new $r))+ (core module $m2+ (import "" "new" (func $new (param i32) (result i32)))+ (func (export "new") (result i32)+ (call $new (i32.const 100))+ )+ )+ (core instance $m2 (instantiate $m2 (with "" (instance+ (export "new" (func $new))+ ))))+ (func $new (result (own $r)) (canon lift (core func $m2 "new")))+ (component $c+ (import "r" (type $r (sub resource)))+ (import "new" (func $new (result (own $r))))+ (export $r-export "r" (type $r))+ (export "new" (func $new) (func (result (own $r-export))))+ )+ (instance $c (instantiate $c+ (with "r" (type $r))+ (with "new" (func $new))+ ))+ (export "i" (instance $c))+)+"#;+ let mut config = super::config();+ config.wasm_component_model_threading(true);+ let engine = Engine::new(&config)?;+ let component = Component::new(&engine, component)?;+ let mut store = Store::new(&engine, ());+ let linker = Linker::new(&engine);+ let instance = linker.instantiate(&mut store, &component)?;+ let instance_index = instance.get_export_index(&mut store, None, "i").unwrap();+ let func_index = instance+ .get_export_index(&mut store, Some(&instance_index), "new")+ .unwrap();+ let run = instance.get_typed_func::<(), (ResourceAny,)>(&mut store, &func_index)?;+ let (resource,) = run.call_and_post_return(&mut store, ())?;+ resource.resource_drop(&mut store)?;+ Ok(())+}++#[test]+fn thread_index_via_sync_host_call_and_sync_guest_call() -> Result<()> {+ let component = r#"+(component+ (component $c+ (core module $m+ (import "" "thread.index" (func $thread-index (result i32)))+ (func (export "run") (result i32)+ (call $thread-index)+ )+ )+ (core func $thread-index (canon thread.index))+ (core instance $m (instantiate $m (with "" (instance+ (export "thread.index" (func $thread-index))+ ))))+ (func (export "run") (result u32) (canon lift (core func $m "run")))+ )+ (instance $c (instantiate $c))++ (component $d+ (import "c" (instance $c+ (export "run" (func (result u32)))+ ))+ (core func $run (canon lower (func $c "run")))+ (core module $m+ (import "" "thread.index" (func $thread-index (result i32)))+ (import "" "run" (func $run (result i32)))+ (func (export "run")+ (local $mine i32)+ (local $theirs i32)+ (local.set $mine (call $thread-index))+ (if (i32.eqz (local.get $mine)) (then unreachable))+ (local.set $theirs (call $run))+ (if (i32.eqz (local.get $theirs)) (then unreachable))+ )+ )+ (core func $thread-index (canon thread.index))+ (core instance $m (instantiate $m (with "" (instance+ (export "thread.index" (func $thread-index))+ (export "run" (func $run))+ ))))+ (func (export "run") (canon lift (core func $m "run")))+ )+ (instance $d (instantiate $d (with "c" (instance $c))))+ (func (export "run") (alias export $d "run"))+)+"#;+ let mut config = super::config();+ config.wasm_component_model_threading(true);+ let engine = Engine::new(&config)?;+ let component = Component::new(&engine, component)?;+ let mut store = Store::new(&engine, ());+ let linker = Linker::new(&engine);+ let instance = linker.instantiate(&mut store, &component)?;+ let run = instance.get_typed_func::<(), ()>(&mut store, "run")?;+ run.call_and_post_return(&mut store, ())?;Ok(())}diff --git a/tests/component-model b/tests/component-modelindex ac37fe92a2..85ef742723 160000--- a/tests/component-model+++ b/tests/component-model@@ -1 +1 @@-Subproject commit ac37fe92a21865aa8ca84b5bcbeb2da3746b6dc8+Subproject commit 85ef7427231093b26eb636eba3d775f9a2f4adc0diff --git a/tests/disas/component-model/direct-adapter-calls-inlining.wat b/tests/disas/component-model/direct-adapter-calls-inlining.watindex 5ebe6f42ab..82c1aae8b1 100644--- a/tests/disas/component-model/direct-adapter-calls-inlining.wat+++ b/tests/disas/component-model/direct-adapter-calls-inlining.wat@@ -64,11 +64,10 @@;; gv6 = load.i64 notrap aligned gv5+16;; gv7 = vmctx;; gv8 = load.i64 notrap aligned readonly can_move gv7+120-;; gv9 = load.i64 notrap aligned readonly can_move gv7+144-;; gv10 = load.i64 notrap aligned readonly can_move gv7+96-;; gv11 = vmctx-;; gv12 = load.i64 notrap aligned readonly gv11+8-;; gv13 = load.i64 notrap aligned gv12+16+;; gv9 = load.i64 notrap aligned readonly can_move gv7+96+;; gv10 = vmctx+;; gv11 = load.i64 notrap aligned readonly gv10+8+;; gv12 = load.i64 notrap aligned gv11+16;; sig0 = (i64 vmctx, i64, i32) -> i32 tail;; sig1 = (i64 vmctx, i64, i32) tail;; sig2 = (i64 vmctx, i64, i32) -> i32 tail@@ -98,18 +97,14 @@;; trap user11;;;; block5:-;; v22 = load.i64 notrap aligned readonly can_move v5+144+;; v22 = load.i64 notrap aligned readonly can_move v5+96;; v23 = load.i32 notrap aligned table v22-;; v61 = iconst.i32 0-;; store notrap aligned table v61, v22 ; v61 = 0-;; v26 = load.i64 notrap aligned readonly can_move v5+96-;; v27 = load.i32 notrap aligned table v26-;; v28 = iconst.i32 -2-;; v29 = band v27, v28 ; v28 = -2-;; store notrap aligned table v29, v26-;; v62 = iconst.i32 1-;; v63 = bor v27, v62 ; v62 = 1-;; store notrap aligned table v63, v26+;; v24 = iconst.i32 -2+;; v25 = band v23, v24 ; v24 = -2+;; store notrap aligned table v25, v22+;; v56 = iconst.i32 1+;; v57 = bor v23, v56 ; v56 = 1+;; store notrap aligned table v57, v22;; jump block6;;;; block6:@@ -119,14 +114,13 @@;; jump block8;;;; block8:-;; v40 = load.i32 notrap aligned table v12-;; v64 = iconst.i32 -2-;; v65 = band v40, v64 ; v64 = -2-;; store notrap aligned table v65, v12-;; v66 = iconst.i32 1-;; v67 = bor v40, v66 ; v66 = 1-;; store notrap aligned table v67, v12-;; store.i32 notrap aligned table v23, v22+;; v36 = load.i32 notrap aligned table v12+;; v58 = iconst.i32 -2+;; v59 = band v36, v58 ; v58 = -2+;; store notrap aligned table v59, v12+;; v60 = iconst.i32 1+;; v61 = bor v36, v60 ; v60 = 1+;; store notrap aligned table v61, v12;; jump block3;;;; block3:@@ -136,6 +130,6 @@;; @00f0 jump block1;;;; block1:-;; v52 = iconst.i32 1276-;; @00f0 return v52 ; v52 = 1276+;; v47 = iconst.i32 1276+;; @00f0 return v47 ; v47 = 1276;; }diff --git a/tests/disas/component-model/direct-adapter-calls-x64.wat b/tests/disas/component-model/direct-adapter-calls-x64.watindex d6d1684ba1..4d5bece740 100644--- a/tests/disas/component-model/direct-adapter-calls-x64.wat+++ b/tests/disas/component-model/direct-adapter-calls-x64.wat@@ -85,49 +85,41 @@;; movq %rsp, %rbp;; movq 8(%rdi), %r10;; movq 0x10(%r10), %r10-;; addq $0x30, %r10+;; addq $0x20, %r10;; cmpq %rsp, %r10-;; ja 0x113-;; 79: subq $0x20, %rsp-;; movq %rbx, (%rsp)-;; movq %r12, 8(%rsp)-;; movq %r14, 0x10(%rsp)-;; movq 0x78(%rdi), %r14-;; movl (%r14), %esi-;; testl $1, %esi-;; je 0xff-;; 9e: movq 0x90(%rdi), %rbx-;; movl (%rbx), %r12d-;; movl $0, (%rbx)-;; movq 0x60(%rdi), %rcx-;; movq %rdi, %r9-;; movl (%rcx), %eax-;; movq %rax, %r8-;; andl $0xfffffffe, %r8d-;; movl %r8d, (%rcx)-;; orl $1, %eax-;; movl %eax, (%rcx)-;; movq 0x40(%r9), %rdi-;; movq %r9, %rsi+;; ja 0xf2+;; 79: subq $0x10, %rsp+;; movq %r12, (%rsp)+;; movq 0x78(%rdi), %r12+;; movl (%r12), %r10d+;; testl $1, %r10d+;; je 0xdd+;; 96: movq 0x60(%rdi), %rsi+;; movl (%rsi), %r10d+;; movq %r10, %rax+;; andl $0xfffffffe, %eax+;; movl %eax, (%rsi)+;; orl $1, %r10d+;; movl %r10d, (%rsi)+;; movq %rdi, %rax+;; movq 0x40(%rax), %rdi+;; movq %rax, %rsi;; callq 0-;; movl (%r14), %ecx-;; movq %rcx, %r8-;; andl $0xfffffffe, %r8d-;; movl %r8d, (%r14)-;; orl $1, %ecx-;; movl %ecx, (%r14)-;; movl %r12d, (%rbx)-;; movq (%rsp), %rbx-;; movq 8(%rsp), %r12-;; movq 0x10(%rsp), %r14-;; addq $0x20, %rsp+;; movl (%r12), %esi+;; movq %rsi, %rcx+;; andl $0xfffffffe, %ecx+;; movl %ecx, (%r12)+;; orl $1, %esi+;; movl %esi, (%r12)+;; movq (%rsp), %r12+;; addq $0x10, %rsp;; movq %rbp, %rsp;; popq %rbp;; retq-;; ff: movq %rdi, %rsi-;; 102: movq 0x48(%rsi), %rax-;; 106: movq 0x58(%rsi), %rdi-;; 10a: movl $0x17, %edx-;; 10f: callq *%rax-;; 111: ud2-;; 113: ud2+;; dd: movq %rdi, %rsi+;; e0: movq 0x48(%rsi), %r9+;; e4: movq 0x58(%rsi), %rdi+;; e8: movl $0x17, %edx+;; ed: callq *%r9+;; f0: ud2+;; f2: ud2diff --git a/tests/disas/component-model/direct-adapter-calls.wat b/tests/disas/component-model/direct-adapter-calls.watindex 26d94affea..f8e71a7d98 100644--- a/tests/disas/component-model/direct-adapter-calls.wat+++ b/tests/disas/component-model/direct-adapter-calls.wat@@ -97,53 +97,47 @@;; gv2 = load.i64 notrap aligned gv1+16;; gv3 = vmctx;; gv4 = load.i64 notrap aligned readonly can_move gv3+120-;; gv5 = load.i64 notrap aligned readonly can_move gv3+144-;; gv6 = load.i64 notrap aligned readonly can_move gv3+96+;; gv5 = load.i64 notrap aligned readonly can_move gv3+96;; sig0 = (i64 vmctx, i64, i32) tail;; sig1 = (i64 vmctx, i64, i32) -> i32 tail;; fn0 = colocated u0:0 sig1;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32):-;; @0092 v5 = load.i64 notrap aligned readonly can_move v0+120-;; @0092 v6 = load.i32 notrap aligned table v5-;; @0094 v7 = iconst.i32 1-;; @0096 v8 = band v6, v7 ; v7 = 1-;; @0090 v4 = iconst.i32 0-;; @0097 v9 = icmp eq v8, v4 ; v4 = 0-;; @0097 v10 = uextend.i32 v9-;; @0098 brif v10, block2, block3+;; @0077 v5 = load.i64 notrap aligned readonly can_move v0+120+;; @0077 v6 = load.i32 notrap aligned table v5+;; @0079 v7 = iconst.i32 1+;; @007b v8 = band v6, v7 ; v7 = 1+;; @0075 v4 = iconst.i32 0+;; @007c v9 = icmp eq v8, v4 ; v4 = 0+;; @007c v10 = uextend.i32 v9+;; @007d brif v10, block2, block3;;;; block2:-;; @009c v14 = load.i64 notrap aligned readonly can_move v0+72-;; @009c v13 = load.i64 notrap aligned readonly can_move v0+88-;; @009a v11 = iconst.i32 23-;; @009c call_indirect sig0, v14(v13, v0, v11) ; v11 = 23-;; @009e trap user11+;; @0081 v14 = load.i64 notrap aligned readonly can_move v0+72+;; @0081 v13 = load.i64 notrap aligned readonly can_move v0+88+;; @007f v11 = iconst.i32 23+;; @0081 call_indirect sig0, v14(v13, v0, v11) ; v11 = 23+;; @0083 trap user11;;;; block3:-;; @00a0 v15 = load.i64 notrap aligned readonly can_move v0+144-;; @00a0 v16 = load.i32 notrap aligned table v15-;; v60 = iconst.i32 0-;; @00a6 store notrap aligned table v60, v15 ; v60 = 0-;; @00a8 v19 = load.i64 notrap aligned readonly can_move v0+96-;; @00a8 v20 = load.i32 notrap aligned table v19-;; @00aa v21 = iconst.i32 -2-;; @00ac v22 = band v20, v21 ; v21 = -2-;; @00ad store notrap aligned table v22, v19-;; v61 = iconst.i32 1-;; v62 = bor v20, v61 ; v61 = 1-;; @00b6 store notrap aligned table v62, v19-;; @00b8 v30 = load.i64 notrap aligned readonly can_move v0+64-;; @00b8 v31 = call fn0(v30, v0, v2)-;; @00bc v33 = load.i32 notrap aligned table v5-;; @00c0 v35 = band v33, v21 ; v21 = -2-;; @00c1 store notrap aligned table v35, v5-;; v63 = bor v33, v61 ; v61 = 1-;; @00ca store notrap aligned table v63, v5-;; @00ce store notrap aligned table v16, v15-;; @00d0 jump block1+;; @0085 v15 = load.i64 notrap aligned readonly can_move v0+96+;; @0085 v16 = load.i32 notrap aligned table v15+;; @0087 v17 = iconst.i32 -2+;; @0089 v18 = band v16, v17 ; v17 = -2+;; @008a store notrap aligned table v18, v15+;; v52 = iconst.i32 1+;; v53 = bor v16, v52 ; v52 = 1+;; @0093 store notrap aligned table v53, v15+;; @0095 v26 = load.i64 notrap aligned readonly can_move v0+64+;; @0095 v27 = call fn0(v26, v0, v2)+;; @0099 v29 = load.i32 notrap aligned table v5+;; @009d v31 = band v29, v17 ; v17 = -2+;; @009e store notrap aligned table v31, v5+;; v54 = bor v29, v52 ; v52 = 1+;; @00a7 store notrap aligned table v54, v5+;; @00a9 jump block1;;;; block1:-;; @00d0 return v31+;; @00a9 return v27;; }diff --git a/tests/misc_testsuite/component-model/resources.wast b/tests/misc_testsuite/component-model/resources.wastindex f019c8b871..5302e7eb90 100644--- a/tests/misc_testsuite/component-model/resources.wast+++ b/tests/misc_testsuite/component-model/resources.wast@@ -16,7 +16,7 @@(local $r i32)(local.set $r (call $new (i32.const 100)))- (if (i32.ne (local.get $r) (i32.const 1)) (then (unreachable)))+ (if (i32.ne (local.get $r) (i32.const 2)) (then (unreachable)))(if (i32.ne (call $rep (local.get $r)) (i32.const 100)) (then (unreachable)))(call $drop (local.get $r))@@ -97,13 +97,13 @@;; resources assigned sequentially(local.set $r1 (call $new (i32.const 100)))- (if (i32.ne (local.get $r1) (i32.const 1)) (then (unreachable)))+ (if (i32.ne (local.get $r1) (i32.const 2)) (then (unreachable)))(local.set $r2 (call $new (i32.const 200)))- (if (i32.ne (local.get $r2) (i32.const 2)) (then (unreachable)))+ (if (i32.ne (local.get $r2) (i32.const 3)) (then (unreachable)))(local.set $r3 (call $new (i32.const 300)))- (if (i32.ne (local.get $r3) (i32.const 3)) (then (unreachable)))+ (if (i32.ne (local.get $r3) (i32.const 4)) (then (unreachable)));; representations all look good(if (i32.ne (call $rep (local.get $r1)) (i32.const 100)) (then (unreachable)))@@ -114,8 +114,8 @@(call $drop (local.get $r2))(local.set $r2 (call $new (i32.const 400)))- ;; should have reused index 1- (if (i32.ne (local.get $r2) (i32.const 2)) (then (unreachable)))+ ;; should have reused index 3+ (if (i32.ne (local.get $r2) (i32.const 3)) (then (unreachable)));; representations all look good(if (i32.ne (call $rep (local.get $r1)) (i32.const 100)) (then (unreachable)))@@ -137,13 +137,13 @@(if (i32.ne (call $rep (local.get $r3)) (i32.const 700)) (then (unreachable)));; indices should be lifo- (if (i32.ne (local.get $r1) (i32.const 3)) (then (unreachable)))- (if (i32.ne (local.get $r2) (i32.const 2)) (then (unreachable)))- (if (i32.ne (local.get $r3) (i32.const 1)) (then (unreachable)))+ (if (i32.ne (local.get $r1) (i32.const 4)) (then (unreachable)))+ (if (i32.ne (local.get $r2) (i32.const 3)) (then (unreachable)))+ (if (i32.ne (local.get $r3) (i32.const 2)) (then (unreachable)));; bump one more time(local.set $r4 (call $new (i32.const 800)))- (if (i32.ne (local.get $r4) (i32.const 4)) (then (unreachable)))+ (if (i32.ne (local.get $r4) (i32.const 5)) (then (unreachable)));; deallocate everything(call $drop (local.get $r1))@@ -243,13 +243,13 @@(local.set $r2 (call $ctor (i32.const 200)));; assert r1/r2 are sequential- (if (i32.ne (local.get $r1) (i32.const 1)) (then (unreachable)))- (if (i32.ne (local.get $r2) (i32.const 2)) (then (unreachable)))+ (if (i32.ne (local.get $r1) (i32.const 2)) (then (unreachable)))+ (if (i32.ne (local.get $r2) (i32.const 3)) (then (unreachable)));; reallocate r1 and it should be reassigned the same index(call $drop (local.get $r1))(local.set $r1 (call $ctor (i32.const 300)))- (if (i32.ne (local.get $r1) (i32.const 1)) (then (unreachable)))+ (if (i32.ne (local.get $r1) (i32.const 2)) (then (unreachable)));; internal values should match(call $assert (local.get $r1) (i32.const 300))@@ -445,7 +445,7 @@(import "" "ctor" (func $ctor (param i32) (result i32)))(func $start- (if (i32.ne (call $ctor (i32.const 100)) (i32.const 1)) (then (unreachable)))+ (if (i32.ne (call $ctor (i32.const 100)) (i32.const 2)) (then (unreachable))))(start $start))@@ -619,12 +619,12 @@(call $drop2 (call $new2 (i32.const 104)));; should be referencing the same namespace- (if (i32.ne (call $new1 (i32.const 105)) (i32.const 1)) (then (unreachable)))- (if (i32.ne (call $new2 (i32.const 105)) (i32.const 2)) (then (unreachable)))+ (if (i32.ne (call $new1 (i32.const 105)) (i32.const 2)) (then (unreachable)))+ (if (i32.ne (call $new2 (i32.const 105)) (i32.const 3)) (then (unreachable)));; use different drops out of order- (call $drop2 (i32.const 1))- (call $drop1 (i32.const 2))+ (call $drop2 (i32.const 2))+ (call $drop1 (i32.const 3)))(start $start)@@ -704,8 +704,8 @@;; indexes start at 1 and while they have distinct types they should be;; within the same table.- (if (i32.ne (local.get $r1) (i32.const 1)) (then (unreachable)))- (if (i32.ne (local.get $r2) (i32.const 2)) (then (unreachable)))+ (if (i32.ne (local.get $r1) (i32.const 2)) (then (unreachable)))+ (if (i32.ne (local.get $r2) (i32.const 3)) (then (unreachable)));; nothing should be dropped yet(if (i32.ne (call $drops) (i32.const 0)) (then (unreachable)))@@ -868,8 +868,8 @@(call $drop (local.get $r2));; table should be empty at this point, so a fresh allocation should get- ;; index 0- (if (i32.ne (call $ctor (i32.const 600)) (i32.const 1)) (then (unreachable)))+ ;; index 2+ (if (i32.ne (call $ctor (i32.const 600)) (i32.const 2)) (then (unreachable))))(start $start)