A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
refactor recursive reentrance checks (#12349)
Joel Diceb856261dde3e
diff --git a/crates/c-api/include/wasmtime/trap.h b/crates/c-api/include/wasmtime/trap.hindex 51c0d21147..9f251363e7 100644--- a/crates/c-api/include/wasmtime/trap.h+++ b/crates/c-api/include/wasmtime/trap.h@@ -47,12 +47,6 @@ enum wasmtime_trap_code_enum {WASMTIME_TRAP_CODE_UNREACHABLE_CODE_REACHED,/// Execution has potentially run too long and may be interrupted.WASMTIME_TRAP_CODE_INTERRUPT,- /// When the `component-model` feature is enabled this trap represents a- /// function that was `canon lift`'d, then `canon lower`'d, then called.- /// This combination of creation of a function in the component model- /// generates a function that always traps and, when called, produces this- /// flavor of trap.- WASMTIME_TRAP_CODE_ALWAYS_TRAP_ADAPTER,/// Execution has run out of the configured fuel amount.WASMTIME_TRAP_CODE_OUT_OF_FUEL,/// Used to indicate that a trap was raised by atomic wait operations on non@@ -74,9 +68,47 @@ enum wasmtime_trap_code_enum {/// Async-lifted export failed to produce a result by calling `task.return`/// before returning `STATUS_DONE` and/or after all host tasks completed.WASMTIME_TRAP_CODE_NO_ASYNC_RESULT,+ /// We are suspending to a tag for which there is no active handler.+ WASMTIME_TRAP_CODE_UNHANDLED_TAG,+ /// Attempt to resume a continuation twice.+ WASMTIME_TRAP_CODE_CONTINUATION_ALREADY_CONSUMED,/// A Pulley opcode was executed at runtime when the opcode was disabled at/// compile time.WASMTIME_TRAP_CODE_DISABLED_OPCODE,+ /// Async event loop deadlocked; i.e. it cannot make further progress given+ /// that all host tasks have completed and any/all host-owned stream/future+ /// handles have been dropped.+ WASMTIME_TRAP_CODE_ASYNC_DEADLOCK,+ /// When the `component-model` feature is enabled this trap represents a+ /// scenario where a component instance tried to call an import or intrinsic+ /// when it wasn't allowed to, e.g. from a post-return function.+ WASMTIME_TRAP_CODE_CANNOT_LEAVE_COMPONENT,+ /// A synchronous task attempted to make a potentially blocking call prior+ /// to returning.+ WASMTIME_TRAP_CODE_CANNOT_BLOCK_SYNC_TASK,+ /// A component tried to lift a `char` with an invalid bit pattern.+ WASMTIME_TRAP_CODE_INVALID_CHAR,+ /// Debug assertion generated for a fused adapter regarding the expected+ /// completion of a string encoding operation.+ WASMTIME_TRAP_CODE_DEBUG_ASSERT_STRING_ENCODING_FINISHED,+ /// Debug assertion generated for a fused adapter regarding a string+ /// encoding operation.+ WASMTIME_TRAP_CODE_DEBUG_ASSERT_EQUAL_CODE_UNITS,+ /// Debug assertion generated for a fused adapter regarding the alignment of+ /// a pointer.+ WASMTIME_TRAP_CODE_DEBUG_ASSERT_POINTER_ALIGNED,+ /// Debug assertion generated for a fused adapter regarding the upper bits+ /// of a 64-bit value.+ WASMTIME_TRAP_CODE_DEBUG_ASSERT_UPPER_BITS_UNSET,+ /// A component tried to lift or lower a string past the end of its memory.+ WASMTIME_TRAP_CODE_STRING_OUT_OF_BOUNDS,+ /// A component tried to lift or lower a list past the end of its memory.+ WASMTIME_TRAP_CODE_LIST_OUT_OF_BOUNDS,+ /// A component used an invalid discriminant when lowering a variant value.+ WASMTIME_TRAP_CODE_INVALID_DISCRIMINANT,+ /// A component passed an unaligned pointer when lifting or lowering a+ /// value.+ WASMTIME_TRAP_CODE_UNALIGNED_POINTER,};/**diff --git a/crates/c-api/src/trap.rs b/crates/c-api/src/trap.rsindex 9a8b6b7f86..1eb3a1c508 100644--- a/crates/c-api/src/trap.rs+++ b/crates/c-api/src/trap.rs@@ -2,6 +2,46 @@ use crate::{wasm_frame_vec_t, wasm_instance_t, wasm_name_t, wasm_store_t};use std::cell::OnceCell;use wasmtime::{Error, Trap, WasmBacktrace, format_err};+// Help ensure the Rust enum matches the C one. If any of these assertions+// fail, please update both this code and `trap.h` to sync them with+// `trap_encoding.rs`.+const _: () = {+ assert!(Trap::StackOverflow as u8 == 0);+ assert!(Trap::MemoryOutOfBounds as u8 == 1);+ assert!(Trap::HeapMisaligned as u8 == 2);+ assert!(Trap::TableOutOfBounds as u8 == 3);+ assert!(Trap::IndirectCallToNull as u8 == 4);+ assert!(Trap::BadSignature as u8 == 5);+ assert!(Trap::IntegerOverflow as u8 == 6);+ assert!(Trap::IntegerDivisionByZero as u8 == 7);+ assert!(Trap::BadConversionToInteger as u8 == 8);+ assert!(Trap::UnreachableCodeReached as u8 == 9);+ assert!(Trap::Interrupt as u8 == 10);+ assert!(Trap::OutOfFuel as u8 == 11);+ assert!(Trap::AtomicWaitNonSharedMemory as u8 == 12);+ assert!(Trap::NullReference as u8 == 13);+ assert!(Trap::ArrayOutOfBounds as u8 == 14);+ assert!(Trap::AllocationTooLarge as u8 == 15);+ assert!(Trap::CastFailure as u8 == 16);+ assert!(Trap::CannotEnterComponent as u8 == 17);+ assert!(Trap::NoAsyncResult as u8 == 18);+ assert!(Trap::UnhandledTag as u8 == 19);+ assert!(Trap::ContinuationAlreadyConsumed as u8 == 20);+ assert!(Trap::DisabledOpcode as u8 == 21);+ assert!(Trap::AsyncDeadlock as u8 == 22);+ assert!(Trap::CannotLeaveComponent as u8 == 23);+ assert!(Trap::CannotBlockSyncTask as u8 == 24);+ assert!(Trap::InvalidChar as u8 == 25);+ assert!(Trap::DebugAssertStringEncodingFinished as u8 == 26);+ assert!(Trap::DebugAssertEqualCodeUnits as u8 == 27);+ assert!(Trap::DebugAssertPointerAligned as u8 == 28);+ assert!(Trap::DebugAssertUpperBitsUnset as u8 == 29);+ assert!(Trap::StringOutOfBounds as u8 == 30);+ assert!(Trap::ListOutOfBounds as u8 == 31);+ assert!(Trap::InvalidDiscriminant as u8 == 32);+ assert!(Trap::UnalignedPointer as u8 == 33);+};+#[repr(C)]pub struct wasm_trap_t {pub(crate) error: Error,diff --git a/crates/c-api/tests/trap.cc b/crates/c-api/tests/trap.ccindex ec059d7929..7b41e37190 100644--- a/crates/c-api/tests/trap.cc+++ b/crates/c-api/tests/trap.cc@@ -60,7 +60,6 @@ TEST(Trap, Codes) {TEST_CODE(BAD_CONVERSION_TO_INTEGER);TEST_CODE(UNREACHABLE_CODE_REACHED);TEST_CODE(INTERRUPT);- TEST_CODE(ALWAYS_TRAP_ADAPTER);TEST_CODE(OUT_OF_FUEL);TEST_CODE(ATOMIC_WAIT_NON_SHARED_MEMORY);TEST_CODE(NULL_REFERENCE);diff --git a/crates/component-macro/tests/expanded/char_concurrent.rs b/crates/component-macro/tests/expanded/char_concurrent.rsindex cd266fa9b8..41963cad84 100644--- a/crates/component-macro/tests/expanded/char_concurrent.rs+++ b/crates/component-macro/tests/expanded/char_concurrent.rs@@ -191,12 +191,12 @@ pub mod foo {use wasmtime::component::__internal::Box;pub trait HostWithStore: wasmtime::component::HasData + Send {/// A function that accepts a character- fn take_char<T>(+ fn take_char<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: char,) -> impl ::core::future::Future<Output = ()> + Send;/// A function that returns a character- fn return_char<T>(+ fn return_char<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = char> + Send;}diff --git a/crates/component-macro/tests/expanded/conventions_concurrent.rs b/crates/component-macro/tests/expanded/conventions_concurrent.rsindex 7306158989..a5678bed85 100644--- a/crates/component-macro/tests/expanded/conventions_concurrent.rs+++ b/crates/component-macro/tests/expanded/conventions_concurrent.rs@@ -224,29 +224,29 @@ pub mod foo {);};pub trait HostWithStore: wasmtime::component::HasData + Send {- fn kebab_case<T>(+ fn kebab_case<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = ()> + Send;- fn foo<T>(+ fn foo<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: LudicrousSpeed,) -> impl ::core::future::Future<Output = ()> + Send;- fn function_with_dashes<T>(+ fn function_with_dashes<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = ()> + Send;- fn function_with_no_weird_characters<T>(+ fn function_with_no_weird_characters<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = ()> + Send;- fn apple<T>(+ fn apple<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = ()> + Send;- fn apple_pear<T>(+ fn apple_pear<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = ()> + Send;- fn apple_pear_grape<T>(+ fn apple_pear_grape<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = ()> + Send;- fn a0<T>(+ fn a0<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = ()> + Send;/// Comment out identifiers that collide when mapped to snake_case, for now; see@@ -254,17 +254,17 @@ pub mod foo {/// APPLE: func()/// APPLE-pear-GRAPE: func()/// apple-PEAR-grape: func()- fn is_xml<T>(+ fn is_xml<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = ()> + Send;- fn explicit<T>(+ fn explicit<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = ()> + Send;- fn explicit_kebab<T>(+ fn explicit_kebab<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = ()> + Send;/// Identifiers with the same name as keywords are quoted.- fn bool<T>(+ fn bool<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = ()> + Send;}diff --git a/crates/component-macro/tests/expanded/dead-code_concurrent.rs b/crates/component-macro/tests/expanded/dead-code_concurrent.rsindex a277b8c7de..b1277ba78c 100644--- a/crates/component-macro/tests/expanded/dead-code_concurrent.rs+++ b/crates/component-macro/tests/expanded/dead-code_concurrent.rs@@ -206,7 +206,7 @@ pub mod a {);};pub trait HostWithStore: wasmtime::component::HasData + Send {- fn f<T>(+ fn f<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = LiveType> + Send;}diff --git a/crates/component-macro/tests/expanded/direct-import_concurrent.rs b/crates/component-macro/tests/expanded/direct-import_concurrent.rsindex 81606a4d8e..b2da9df1ec 100644--- a/crates/component-macro/tests/expanded/direct-import_concurrent.rs+++ b/crates/component-macro/tests/expanded/direct-import_concurrent.rs@@ -99,7 +99,7 @@ pub struct FooIndices {}/// [`Linker`]: wasmtime::component::Linkerpub struct Foo {}pub trait FooImportsWithStore: wasmtime::component::HasData + Send {- fn foo<T>(+ fn foo<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = ()> + Send;}diff --git a/crates/component-macro/tests/expanded/flags_concurrent.rs b/crates/component-macro/tests/expanded/flags_concurrent.rsindex fa3e3b8906..6830b97029 100644--- a/crates/component-macro/tests/expanded/flags_concurrent.rs+++ b/crates/component-macro/tests/expanded/flags_concurrent.rs@@ -304,31 +304,31 @@ pub mod foo {assert!(4 == < Flag64 as wasmtime::component::ComponentType >::ALIGN32);};pub trait HostWithStore: wasmtime::component::HasData + Send {- fn roundtrip_flag1<T>(+ fn roundtrip_flag1<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: Flag1,) -> impl ::core::future::Future<Output = Flag1> + Send;- fn roundtrip_flag2<T>(+ fn roundtrip_flag2<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: Flag2,) -> impl ::core::future::Future<Output = Flag2> + Send;- fn roundtrip_flag4<T>(+ fn roundtrip_flag4<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: Flag4,) -> impl ::core::future::Future<Output = Flag4> + Send;- fn roundtrip_flag8<T>(+ fn roundtrip_flag8<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: Flag8,) -> impl ::core::future::Future<Output = Flag8> + Send;- fn roundtrip_flag16<T>(+ fn roundtrip_flag16<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: Flag16,) -> impl ::core::future::Future<Output = Flag16> + Send;- fn roundtrip_flag32<T>(+ fn roundtrip_flag32<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: Flag32,) -> impl ::core::future::Future<Output = Flag32> + Send;- fn roundtrip_flag64<T>(+ fn roundtrip_flag64<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: Flag64,) -> impl ::core::future::Future<Output = Flag64> + Send;diff --git a/crates/component-macro/tests/expanded/floats_concurrent.rs b/crates/component-macro/tests/expanded/floats_concurrent.rsindex 14361bf3d4..1d9a72f092 100644--- a/crates/component-macro/tests/expanded/floats_concurrent.rs+++ b/crates/component-macro/tests/expanded/floats_concurrent.rs@@ -192,18 +192,18 @@ pub mod foo {#[allow(unused_imports)]use wasmtime::component::__internal::Box;pub trait HostWithStore: wasmtime::component::HasData + Send {- fn f32_param<T>(+ fn f32_param<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: f32,) -> impl ::core::future::Future<Output = ()> + Send;- fn f64_param<T>(+ fn f64_param<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: f64,) -> impl ::core::future::Future<Output = ()> + Send;- fn f32_result<T>(+ fn f32_result<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = f32> + Send;- fn f64_result<T>(+ fn f64_result<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = f64> + Send;}diff --git a/crates/component-macro/tests/expanded/host-world_concurrent.rs b/crates/component-macro/tests/expanded/host-world_concurrent.rsindex a5e3b741ac..8e49386e3c 100644--- a/crates/component-macro/tests/expanded/host-world_concurrent.rs+++ b/crates/component-macro/tests/expanded/host-world_concurrent.rs@@ -99,7 +99,7 @@ pub struct Host_Indices {}/// [`Linker`]: wasmtime::component::Linkerpub struct Host_ {}pub trait Host_ImportsWithStore: wasmtime::component::HasData + Send {- fn foo<T>(+ fn foo<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = ()> + Send;}diff --git a/crates/component-macro/tests/expanded/integers_concurrent.rs b/crates/component-macro/tests/expanded/integers_concurrent.rsindex aceff239d6..43959402cd 100644--- a/crates/component-macro/tests/expanded/integers_concurrent.rs+++ b/crates/component-macro/tests/expanded/integers_concurrent.rs@@ -192,39 +192,39 @@ pub mod foo {#[allow(unused_imports)]use wasmtime::component::__internal::Box;pub trait HostWithStore: wasmtime::component::HasData + Send {- fn a1<T>(+ fn a1<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: u8,) -> impl ::core::future::Future<Output = ()> + Send;- fn a2<T>(+ fn a2<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: i8,) -> impl ::core::future::Future<Output = ()> + Send;- fn a3<T>(+ fn a3<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: u16,) -> impl ::core::future::Future<Output = ()> + Send;- fn a4<T>(+ fn a4<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: i16,) -> impl ::core::future::Future<Output = ()> + Send;- fn a5<T>(+ fn a5<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: u32,) -> impl ::core::future::Future<Output = ()> + Send;- fn a6<T>(+ fn a6<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: i32,) -> impl ::core::future::Future<Output = ()> + Send;- fn a7<T>(+ fn a7<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: u64,) -> impl ::core::future::Future<Output = ()> + Send;- fn a8<T>(+ fn a8<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: i64,) -> impl ::core::future::Future<Output = ()> + Send;- fn a9<T>(+ fn a9<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,p1: u8,p2: i8,@@ -235,31 +235,31 @@ pub mod foo {p7: u64,p8: i64,) -> impl ::core::future::Future<Output = ()> + Send;- fn r1<T>(+ fn r1<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = u8> + Send;- fn r2<T>(+ fn r2<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = i8> + Send;- fn r3<T>(+ fn r3<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = u16> + Send;- fn r4<T>(+ fn r4<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = i16> + Send;- fn r5<T>(+ fn r5<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = u32> + Send;- fn r6<T>(+ fn r6<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = i32> + Send;- fn r7<T>(+ fn r7<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = u64> + Send;- fn r8<T>(+ fn r8<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = i64> + Send;- fn pair_ret<T>(+ fn pair_ret<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = (i64, u8)> + Send;}diff --git a/crates/component-macro/tests/expanded/lists_concurrent.rs b/crates/component-macro/tests/expanded/lists_concurrent.rsindex 13a868eba2..1739476f6b 100644--- a/crates/component-macro/tests/expanded/lists_concurrent.rs+++ b/crates/component-macro/tests/expanded/lists_concurrent.rs@@ -370,116 +370,116 @@ pub mod foo {);};pub trait HostWithStore: wasmtime::component::HasData + Send {- fn list_u8_param<T>(+ fn list_u8_param<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: wasmtime::component::__internal::Vec<u8>,) -> impl ::core::future::Future<Output = ()> + Send;- fn list_u16_param<T>(+ fn list_u16_param<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: wasmtime::component::__internal::Vec<u16>,) -> impl ::core::future::Future<Output = ()> + Send;- fn list_u32_param<T>(+ fn list_u32_param<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: wasmtime::component::__internal::Vec<u32>,) -> impl ::core::future::Future<Output = ()> + Send;- fn list_u64_param<T>(+ fn list_u64_param<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: wasmtime::component::__internal::Vec<u64>,) -> impl ::core::future::Future<Output = ()> + Send;- fn list_s8_param<T>(+ fn list_s8_param<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: wasmtime::component::__internal::Vec<i8>,) -> impl ::core::future::Future<Output = ()> + Send;- fn list_s16_param<T>(+ fn list_s16_param<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: wasmtime::component::__internal::Vec<i16>,) -> impl ::core::future::Future<Output = ()> + Send;- fn list_s32_param<T>(+ fn list_s32_param<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: wasmtime::component::__internal::Vec<i32>,) -> impl ::core::future::Future<Output = ()> + Send;- fn list_s64_param<T>(+ fn list_s64_param<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: wasmtime::component::__internal::Vec<i64>,) -> impl ::core::future::Future<Output = ()> + Send;- fn list_f32_param<T>(+ fn list_f32_param<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: wasmtime::component::__internal::Vec<f32>,) -> impl ::core::future::Future<Output = ()> + Send;- fn list_f64_param<T>(+ fn list_f64_param<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: wasmtime::component::__internal::Vec<f64>,) -> impl ::core::future::Future<Output = ()> + Send;- fn list_u8_ret<T>(+ fn list_u8_ret<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = wasmtime::component::__internal::Vec<u8>,> + Send;- fn list_u16_ret<T>(+ fn list_u16_ret<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = wasmtime::component::__internal::Vec<u16>,> + Send;- fn list_u32_ret<T>(+ fn list_u32_ret<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = wasmtime::component::__internal::Vec<u32>,> + Send;- fn list_u64_ret<T>(+ fn list_u64_ret<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = wasmtime::component::__internal::Vec<u64>,> + Send;- fn list_s8_ret<T>(+ fn list_s8_ret<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = wasmtime::component::__internal::Vec<i8>,> + Send;- fn list_s16_ret<T>(+ fn list_s16_ret<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = wasmtime::component::__internal::Vec<i16>,> + Send;- fn list_s32_ret<T>(+ fn list_s32_ret<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = wasmtime::component::__internal::Vec<i32>,> + Send;- fn list_s64_ret<T>(+ fn list_s64_ret<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = wasmtime::component::__internal::Vec<i64>,> + Send;- fn list_f32_ret<T>(+ fn list_f32_ret<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = wasmtime::component::__internal::Vec<f32>,> + Send;- fn list_f64_ret<T>(+ fn list_f64_ret<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = wasmtime::component::__internal::Vec<f64>,> + Send;- fn tuple_list<T>(+ fn tuple_list<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: wasmtime::component::__internal::Vec<(u8, i8)>,) -> impl ::core::future::Future<Output = wasmtime::component::__internal::Vec<(i64, u32)>,> + Send;- fn string_list_arg<T>(+ fn string_list_arg<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,a: wasmtime::component::__internal::Vec<wasmtime::component::__internal::String,>,) -> impl ::core::future::Future<Output = ()> + Send;- fn string_list_ret<T>(+ fn string_list_ret<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = wasmtime::component::__internal::Vec<wasmtime::component::__internal::String,>,> + Send;- fn tuple_string_list<T>(+ fn tuple_string_list<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: wasmtime::component::__internal::Vec<(u8, wasmtime::component::__internal::String),@@ -489,7 +489,7 @@ pub mod foo {(wasmtime::component::__internal::String, u8),>,> + Send;- fn string_list<T>(+ fn string_list<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: wasmtime::component::__internal::Vec<wasmtime::component::__internal::String,@@ -499,25 +499,25 @@ pub mod foo {wasmtime::component::__internal::String,>,> + Send;- fn record_list<T>(+ fn record_list<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: wasmtime::component::__internal::Vec<SomeRecord>,) -> impl ::core::future::Future<Output = wasmtime::component::__internal::Vec<OtherRecord>,> + Send;- fn record_list_reverse<T>(+ fn record_list_reverse<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: wasmtime::component::__internal::Vec<OtherRecord>,) -> impl ::core::future::Future<Output = wasmtime::component::__internal::Vec<SomeRecord>,> + Send;- fn variant_list<T>(+ fn variant_list<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: wasmtime::component::__internal::Vec<SomeVariant>,) -> impl ::core::future::Future<Output = wasmtime::component::__internal::Vec<OtherVariant>,> + Send;- fn load_store_everything<T>(+ fn load_store_everything<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,a: LoadStoreAllSizes,) -> impl ::core::future::Future<Output = LoadStoreAllSizes> + Send;diff --git a/crates/component-macro/tests/expanded/many-arguments_concurrent.rs b/crates/component-macro/tests/expanded/many-arguments_concurrent.rsindex 32b4e7ab57..2eb2eab788 100644--- a/crates/component-macro/tests/expanded/many-arguments_concurrent.rs+++ b/crates/component-macro/tests/expanded/many-arguments_concurrent.rs@@ -273,7 +273,7 @@ pub mod foo {);};pub trait HostWithStore: wasmtime::component::HasData + Send {- fn many_args<T>(+ fn many_args<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,a1: u64,a2: u64,@@ -292,7 +292,7 @@ pub mod foo {a15: u64,a16: u64,) -> impl ::core::future::Future<Output = ()> + Send;- fn big_argument<T>(+ fn big_argument<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: BigStruct,) -> impl ::core::future::Future<Output = ()> + Send;diff --git a/crates/component-macro/tests/expanded/multiversion_concurrent.rs b/crates/component-macro/tests/expanded/multiversion_concurrent.rsindex 0153166b6a..e7451285c0 100644--- a/crates/component-macro/tests/expanded/multiversion_concurrent.rs+++ b/crates/component-macro/tests/expanded/multiversion_concurrent.rs@@ -201,7 +201,7 @@ pub mod my {#[allow(unused_imports)]use wasmtime::component::__internal::Box;pub trait HostWithStore: wasmtime::component::HasData + Send {- fn x<T>(+ fn x<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = ()> + Send;}@@ -237,7 +237,7 @@ pub mod my {#[allow(unused_imports)]use wasmtime::component::__internal::Box;pub trait HostWithStore: wasmtime::component::HasData + Send {- fn x<T>(+ fn x<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = ()> + Send;}diff --git a/crates/component-macro/tests/expanded/records_concurrent.rs b/crates/component-macro/tests/expanded/records_concurrent.rsindex 2c78b24500..dd97f8e22d 100644--- a/crates/component-macro/tests/expanded/records_concurrent.rs+++ b/crates/component-macro/tests/expanded/records_concurrent.rs@@ -347,42 +347,42 @@ pub mod foo {);};pub trait HostWithStore: wasmtime::component::HasData + Send {- fn tuple_arg<T>(+ fn tuple_arg<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: (char, u32),) -> impl ::core::future::Future<Output = ()> + Send;- fn tuple_result<T>(+ fn tuple_result<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = (char, u32)> + Send;- fn empty_arg<T>(+ fn empty_arg<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: Empty,) -> impl ::core::future::Future<Output = ()> + Send;- fn empty_result<T>(+ fn empty_result<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = Empty> + Send;- fn scalar_arg<T>(+ fn scalar_arg<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: Scalars,) -> impl ::core::future::Future<Output = ()> + Send;- fn scalar_result<T>(+ fn scalar_result<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = Scalars> + Send;- fn flags_arg<T>(+ fn flags_arg<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: ReallyFlags,) -> impl ::core::future::Future<Output = ()> + Send;- fn flags_result<T>(+ fn flags_result<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = ReallyFlags> + Send;- fn aggregate_arg<T>(+ fn aggregate_arg<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: Aggregates,) -> impl ::core::future::Future<Output = ()> + Send;- fn aggregate_result<T>(+ fn aggregate_result<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = Aggregates> + Send;- fn typedef_inout<T>(+ fn typedef_inout<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,e: TupleTypedef2,) -> impl ::core::future::Future<Output = i32> + Send;diff --git a/crates/component-macro/tests/expanded/rename_concurrent.rs b/crates/component-macro/tests/expanded/rename_concurrent.rsindex 5f036f6cdd..45bea98538 100644--- a/crates/component-macro/tests/expanded/rename_concurrent.rs+++ b/crates/component-macro/tests/expanded/rename_concurrent.rs@@ -216,7 +216,7 @@ pub mod foo {assert!(4 == < Thing as wasmtime::component::ComponentType >::ALIGN32);};pub trait HostWithStore: wasmtime::component::HasData + Send {- fn foo<T>(+ fn foo<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = Thing> + Send;}diff --git a/crates/component-macro/tests/expanded/resources-import_concurrent.rs b/crates/component-macro/tests/expanded/resources-import_concurrent.rsindex ea6347bc06..8b77ffc65b 100644--- a/crates/component-macro/tests/expanded/resources-import_concurrent.rs+++ b/crates/component-macro/tests/expanded/resources-import_concurrent.rs@@ -6,16 +6,16 @@ pub trait HostWorldResourceWithStore: wasmtime::component::HasData + Send {) -> impl ::core::future::Future<Output = wasmtime::Result<()>> + SendwhereSelf: Sized;- fn new<T>(+ fn new<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = wasmtime::component::Resource<WorldResource>,> + Send;- fn foo<T>(+ fn foo<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,self_: wasmtime::component::Resource<WorldResource>,) -> impl ::core::future::Future<Output = ()> + Send;- fn static_foo<T>(+ fn static_foo<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = ()> + Send;}@@ -128,7 +128,7 @@ pub struct TheWorld {some_world_func2: wasmtime::component::Func,}pub trait TheWorldImportsWithStore: wasmtime::component::HasData + HostWorldResourceWithStore + Send {- fn some_world_func<T>(+ fn some_world_func<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = wasmtime::component::Resource<WorldResource>,@@ -391,15 +391,15 @@ pub mod foo {) -> impl ::core::future::Future<Output = wasmtime::Result<()>> + SendwhereSelf: Sized;- fn new<T>(+ fn new<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = wasmtime::component::Resource<Bar>,> + Send;- fn static_a<T>(+ fn static_a<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = u32> + Send;- fn method_a<T>(+ fn method_a<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,self_: wasmtime::component::Resource<Bar>,) -> impl ::core::future::Future<Output = u32> + Send;@@ -469,7 +469,7 @@ pub mod foo {) -> impl ::core::future::Future<Output = wasmtime::Result<()>> + SendwhereSelf: Sized;- fn new<T>(+ fn new<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = Result<@@ -481,89 +481,89 @@ pub mod foo {pub trait HostFallible: Send {}impl<_T: HostFallible + ?Sized + Send> HostFallible for &mut _T {}pub trait HostWithStore: wasmtime::component::HasData + HostBarWithStore + HostFallibleWithStore + Send {- fn bar_own_arg<T>(+ fn bar_own_arg<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: wasmtime::component::Resource<Bar>,) -> impl ::core::future::Future<Output = ()> + Send;- fn bar_borrow_arg<T>(+ fn bar_borrow_arg<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: wasmtime::component::Resource<Bar>,) -> impl ::core::future::Future<Output = ()> + Send;- fn bar_result<T>(+ fn bar_result<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = wasmtime::component::Resource<Bar>,> + Send;- fn tuple_own_arg<T>(+ fn tuple_own_arg<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: (wasmtime::component::Resource<Bar>, u32),) -> impl ::core::future::Future<Output = ()> + Send;- fn tuple_borrow_arg<T>(+ fn tuple_borrow_arg<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: (wasmtime::component::Resource<Bar>, u32),) -> impl ::core::future::Future<Output = ()> + Send;- fn tuple_result<T>(+ fn tuple_result<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = (wasmtime::component::Resource<Bar>, u32),> + Send;- fn option_own_arg<T>(+ fn option_own_arg<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: Option<wasmtime::component::Resource<Bar>>,) -> impl ::core::future::Future<Output = ()> + Send;- fn option_borrow_arg<T>(+ fn option_borrow_arg<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: Option<wasmtime::component::Resource<Bar>>,) -> impl ::core::future::Future<Output = ()> + Send;- fn option_result<T>(+ fn option_result<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = Option<wasmtime::component::Resource<Bar>>,> + Send;- fn result_own_arg<T>(+ fn result_own_arg<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: Result<wasmtime::component::Resource<Bar>, ()>,) -> impl ::core::future::Future<Output = ()> + Send;- fn result_borrow_arg<T>(+ fn result_borrow_arg<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: Result<wasmtime::component::Resource<Bar>, ()>,) -> impl ::core::future::Future<Output = ()> + Send;- fn result_result<T>(+ fn result_result<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = Result<wasmtime::component::Resource<Bar>, ()>,> + Send;- fn list_own_arg<T>(+ fn list_own_arg<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: wasmtime::component::__internal::Vec<wasmtime::component::Resource<Bar>,>,) -> impl ::core::future::Future<Output = ()> + Send;- fn list_borrow_arg<T>(+ fn list_borrow_arg<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: wasmtime::component::__internal::Vec<wasmtime::component::Resource<Bar>,>,) -> impl ::core::future::Future<Output = ()> + Send;- fn list_result<T>(+ fn list_result<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = wasmtime::component::__internal::Vec<wasmtime::component::Resource<Bar>,>,> + Send;- fn record_own_arg<T>(+ fn record_own_arg<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: NestedOwn,) -> impl ::core::future::Future<Output = ()> + Send;- fn record_borrow_arg<T>(+ fn record_borrow_arg<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: NestedBorrow,) -> impl ::core::future::Future<Output = ()> + Send;- fn record_result<T>(+ fn record_result<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = NestedOwn> + Send;- fn func_with_handle_typedef<T>(+ fn func_with_handle_typedef<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: SomeHandle,) -> impl ::core::future::Future<Output = ()> + Send;@@ -1014,7 +1014,7 @@ pub mod foo {use wasmtime::component::__internal::Box;pub type A = super::super::super::foo::foo::long_use_chain3::A;pub trait HostWithStore: wasmtime::component::HasData + Send {- fn foo<T>(+ fn foo<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = wasmtime::component::Resource<A>,diff --git a/crates/component-macro/tests/expanded/share-types_concurrent.rs b/crates/component-macro/tests/expanded/share-types_concurrent.rsindex 8d2d4e406b..4966d78fb6 100644--- a/crates/component-macro/tests/expanded/share-types_concurrent.rs+++ b/crates/component-macro/tests/expanded/share-types_concurrent.rs@@ -265,7 +265,7 @@ pub mod http_fetch {assert!(4 == < Response as wasmtime::component::ComponentType >::ALIGN32);};pub trait HostWithStore: wasmtime::component::HasData + Send {- fn fetch_request<T>(+ fn fetch_request<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,request: Request,) -> impl ::core::future::Future<Output = Response> + Send;diff --git a/crates/component-macro/tests/expanded/simple-functions_concurrent.rs b/crates/component-macro/tests/expanded/simple-functions_concurrent.rsindex bab73ac4a3..f7b043e721 100644--- a/crates/component-macro/tests/expanded/simple-functions_concurrent.rs+++ b/crates/component-macro/tests/expanded/simple-functions_concurrent.rs@@ -192,25 +192,25 @@ pub mod foo {#[allow(unused_imports)]use wasmtime::component::__internal::Box;pub trait HostWithStore: wasmtime::component::HasData + Send {- fn f1<T>(+ fn f1<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = ()> + Send;- fn f2<T>(+ fn f2<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,a: u32,) -> impl ::core::future::Future<Output = ()> + Send;- fn f3<T>(+ fn f3<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,a: u32,b: u32,) -> impl ::core::future::Future<Output = ()> + Send;- fn f4<T>(+ fn f4<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = u32> + Send;- fn f5<T>(+ fn f5<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = (u32, u32)> + Send;- fn f6<T>(+ fn f6<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,a: u32,b: u32,diff --git a/crates/component-macro/tests/expanded/simple-lists_concurrent.rs b/crates/component-macro/tests/expanded/simple-lists_concurrent.rsindex 8eaf44b90c..8e0c428b1d 100644--- a/crates/component-macro/tests/expanded/simple-lists_concurrent.rs+++ b/crates/component-macro/tests/expanded/simple-lists_concurrent.rs@@ -192,16 +192,16 @@ pub mod foo {#[allow(unused_imports)]use wasmtime::component::__internal::Box;pub trait HostWithStore: wasmtime::component::HasData + Send {- fn simple_list1<T>(+ fn simple_list1<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,l: wasmtime::component::__internal::Vec<u32>,) -> impl ::core::future::Future<Output = ()> + Send;- fn simple_list2<T>(+ fn simple_list2<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = wasmtime::component::__internal::Vec<u32>,> + Send;- fn simple_list3<T>(+ fn simple_list3<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,a: wasmtime::component::__internal::Vec<u32>,b: wasmtime::component::__internal::Vec<u32>,@@ -211,7 +211,7 @@ pub mod foo {wasmtime::component::__internal::Vec<u32>,),> + Send;- fn simple_list4<T>(+ fn simple_list4<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,l: wasmtime::component::__internal::Vec<wasmtime::component::__internal::Vec<u32>,diff --git a/crates/component-macro/tests/expanded/simple-wasi_concurrent.rs b/crates/component-macro/tests/expanded/simple-wasi_concurrent.rsindex 94cd4b0c7a..629d6b81eb 100644--- a/crates/component-macro/tests/expanded/simple-wasi_concurrent.rs+++ b/crates/component-macro/tests/expanded/simple-wasi_concurrent.rs@@ -246,10 +246,10 @@ pub mod foo {assert!(1 == < Errno as wasmtime::component::ComponentType >::ALIGN32);};pub trait HostWithStore: wasmtime::component::HasData + Send {- fn create_directory_at<T>(+ fn create_directory_at<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = Result<(), Errno>> + Send;- fn stat<T>(+ fn stat<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = Result<DescriptorStat, Errno>,diff --git a/crates/component-macro/tests/expanded/small-anonymous_concurrent.rs b/crates/component-macro/tests/expanded/small-anonymous_concurrent.rsindex c33b98a1f5..10033c54a9 100644--- a/crates/component-macro/tests/expanded/small-anonymous_concurrent.rs+++ b/crates/component-macro/tests/expanded/small-anonymous_concurrent.rs@@ -235,7 +235,7 @@ pub mod foo {assert!(1 == < Error as wasmtime::component::ComponentType >::ALIGN32);};pub trait HostWithStore: wasmtime::component::HasData + Send {- fn option_test<T>(+ fn option_test<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = Result<diff --git a/crates/component-macro/tests/expanded/smoke_concurrent.rs b/crates/component-macro/tests/expanded/smoke_concurrent.rsindex db37d59b58..2754c31736 100644--- a/crates/component-macro/tests/expanded/smoke_concurrent.rs+++ b/crates/component-macro/tests/expanded/smoke_concurrent.rs@@ -179,7 +179,7 @@ pub mod imports {#[allow(unused_imports)]use wasmtime::component::__internal::Box;pub trait HostWithStore: wasmtime::component::HasData + Send {- fn y<T>(+ fn y<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = ()> + Send;}diff --git a/crates/component-macro/tests/expanded/strings_concurrent.rs b/crates/component-macro/tests/expanded/strings_concurrent.rsindex 40ece95cc2..190835af96 100644--- a/crates/component-macro/tests/expanded/strings_concurrent.rs+++ b/crates/component-macro/tests/expanded/strings_concurrent.rs@@ -192,16 +192,16 @@ pub mod foo {#[allow(unused_imports)]use wasmtime::component::__internal::Box;pub trait HostWithStore: wasmtime::component::HasData + Send {- fn a<T>(+ fn a<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: wasmtime::component::__internal::String,) -> impl ::core::future::Future<Output = ()> + Send;- fn b<T>(+ fn b<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = wasmtime::component::__internal::String,> + Send;- fn c<T>(+ fn c<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,a: wasmtime::component::__internal::String,b: wasmtime::component::__internal::String,diff --git a/crates/component-macro/tests/expanded/unstable-features_concurrent.rs b/crates/component-macro/tests/expanded/unstable-features_concurrent.rsindex 10fa5d11c8..14157466b2 100644--- a/crates/component-macro/tests/expanded/unstable-features_concurrent.rs+++ b/crates/component-macro/tests/expanded/unstable-features_concurrent.rs@@ -86,7 +86,7 @@ pub trait HostBazWithStore: wasmtime::component::HasData + Send {) -> impl ::core::future::Future<Output = wasmtime::Result<()>> + SendwhereSelf: Sized;- fn foo<T>(+ fn foo<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,self_: wasmtime::component::Resource<Baz>,) -> impl ::core::future::Future<Output = ()> + Send;@@ -194,7 +194,7 @@ pub struct TheWorldIndices {}/// [`Linker`]: wasmtime::component::Linkerpub struct TheWorld {}pub trait TheWorldImportsWithStore: wasmtime::component::HasData + HostBazWithStore + Send {- fn foo<T>(+ fn foo<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = ()> + Send;}@@ -399,7 +399,7 @@ pub mod foo {) -> impl ::core::future::Future<Output = wasmtime::Result<()>> + SendwhereSelf: Sized;- fn foo<T>(+ fn foo<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,self_: wasmtime::component::Resource<Bar>,) -> impl ::core::future::Future<Output = ()> + Send;@@ -407,7 +407,7 @@ pub mod foo {pub trait HostBar: Send {}impl<_T: HostBar + ?Sized + Send> HostBar for &mut _T {}pub trait HostWithStore: wasmtime::component::HasData + HostBarWithStore + Send {- fn foo<T>(+ fn foo<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = ()> + Send;}diff --git a/crates/component-macro/tests/expanded/unversioned-foo_concurrent.rs b/crates/component-macro/tests/expanded/unversioned-foo_concurrent.rsindex 1ec481afba..c658c7b0dd 100644--- a/crates/component-macro/tests/expanded/unversioned-foo_concurrent.rs+++ b/crates/component-macro/tests/expanded/unversioned-foo_concurrent.rs@@ -209,7 +209,7 @@ pub mod foo {assert!(4 == < Error as wasmtime::component::ComponentType >::ALIGN32);};pub trait HostWithStore: wasmtime::component::HasData + Send {- fn g<T>(+ fn g<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = Result<(), Error>> + Send;}diff --git a/crates/component-macro/tests/expanded/use-paths_concurrent.rs b/crates/component-macro/tests/expanded/use-paths_concurrent.rsindex a275a676c1..0cc1d8b813 100644--- a/crates/component-macro/tests/expanded/use-paths_concurrent.rs+++ b/crates/component-macro/tests/expanded/use-paths_concurrent.rs@@ -203,7 +203,7 @@ pub mod foo {assert!(1 == < Foo as wasmtime::component::ComponentType >::ALIGN32);};pub trait HostWithStore: wasmtime::component::HasData + Send {- fn a<T>(+ fn a<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = Foo> + Send;}@@ -242,7 +242,7 @@ pub mod foo {assert!(1 == < Foo as wasmtime::component::ComponentType >::ALIGN32);};pub trait HostWithStore: wasmtime::component::HasData + Send {- fn a<T>(+ fn a<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = Foo> + Send;}@@ -281,7 +281,7 @@ pub mod foo {assert!(1 == < Foo as wasmtime::component::ComponentType >::ALIGN32);};pub trait HostWithStore: wasmtime::component::HasData + Send {- fn a<T>(+ fn a<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = Foo> + Send;}@@ -322,7 +322,7 @@ pub mod d {assert!(1 == < Foo as wasmtime::component::ComponentType >::ALIGN32);};pub trait HostWithStore: wasmtime::component::HasData + Send {- fn b<T>(+ fn b<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = Foo> + Send;}diff --git a/crates/component-macro/tests/expanded/variants_concurrent.rs b/crates/component-macro/tests/expanded/variants_concurrent.rsindex 25e0b0d623..10c7ca604c 100644--- a/crates/component-macro/tests/expanded/variants_concurrent.rs+++ b/crates/component-macro/tests/expanded/variants_concurrent.rs@@ -464,28 +464,28 @@ pub mod foo {assert!(4 == < IsClone as wasmtime::component::ComponentType >::ALIGN32);};pub trait HostWithStore: wasmtime::component::HasData + Send {- fn e1_arg<T>(+ fn e1_arg<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: E1,) -> impl ::core::future::Future<Output = ()> + Send;- fn e1_result<T>(+ fn e1_result<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = E1> + Send;- fn v1_arg<T>(+ fn v1_arg<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: V1,) -> impl ::core::future::Future<Output = ()> + Send;- fn v1_result<T>(+ fn v1_result<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = V1> + Send;- fn bool_arg<T>(+ fn bool_arg<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,x: bool,) -> impl ::core::future::Future<Output = ()> + Send;- fn bool_result<T>(+ fn bool_result<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = bool> + Send;- fn option_arg<T>(+ fn option_arg<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,a: Option<bool>,b: Option<()>,@@ -494,7 +494,7 @@ pub mod foo {e: Option<f32>,g: Option<Option<bool>>,) -> impl ::core::future::Future<Output = ()> + Send;- fn option_result<T>(+ fn option_result<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = (@@ -506,7 +506,7 @@ pub mod foo {Option<Option<bool>>,),> + Send;- fn casts<T>(+ fn casts<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,a: Casts1,b: Casts2,@@ -517,7 +517,7 @@ pub mod foo {) -> impl ::core::future::Future<Output = (Casts1, Casts2, Casts3, Casts4, Casts5, Casts6),> + Send;- fn result_arg<T>(+ fn result_arg<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,a: Result<(), ()>,b: Result<(), E1>,@@ -529,7 +529,7 @@ pub mod foo {wasmtime::component::__internal::Vec<u8>,>,) -> impl ::core::future::Future<Output = ()> + Send;- fn result_result<T>(+ fn result_result<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = (@@ -544,36 +544,36 @@ pub mod foo {>,),> + Send;- fn return_result_sugar<T>(+ fn return_result_sugar<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = Result<i32, MyErrno>> + Send;- fn return_result_sugar2<T>(+ fn return_result_sugar2<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = Result<(), MyErrno>> + Send;- fn return_result_sugar3<T>(+ fn return_result_sugar3<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = Result<MyErrno, MyErrno>,> + Send;- fn return_result_sugar4<T>(+ fn return_result_sugar4<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = Result<(i32, u32), MyErrno>,> + Send;- fn return_option_sugar<T>(+ fn return_option_sugar<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = Option<i32>> + Send;- fn return_option_sugar2<T>(+ fn return_option_sugar2<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = Option<MyErrno>> + Send;- fn result_simple<T>(+ fn result_simple<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = Result<u32, i32>> + Send;- fn is_clone_arg<T>(+ fn is_clone_arg<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,a: IsClone,) -> impl ::core::future::Future<Output = ()> + Send;- fn is_clone_return<T>(+ fn is_clone_return<T: Send>(accessor: &wasmtime::component::Accessor<T, Self>,) -> impl ::core::future::Future<Output = IsClone> + Send;}diff --git a/crates/cranelift/src/compiler/component.rs b/crates/cranelift/src/compiler/component.rsindex 2d7578c5af..fc583c0682 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_ALWAYS, TRAP_CANNOT_ENTER, TRAP_INTERNAL_ASSERT, compiler::Compiler};+use crate::{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};@@ -20,7 +20,6 @@ struct TrampolineCompiler<'a> {offsets: VMComponentOffsets<u8>,block0: ir::Block,signature: &'a WasmFuncType,- tunables: &'a Tunables,}/// What host functions can be called, used in `translate_hostcall` below.@@ -100,7 +99,6 @@ impl<'a> TrampolineCompiler<'a> {component: &'a Component,types: &'a ComponentTypesBuilder,signature: &'a WasmFuncType,- tunables: &'a Tunables,) -> TrampolineCompiler<'a> {let isa = &*compiler.isa;let func = ir::Function::with_name_signature(@@ -117,7 +115,6 @@ impl<'a> TrampolineCompiler<'a> {offsets: VMComponentOffsets::new(isa.pointer_bytes(), component),block0,signature,- tunables,}}@@ -160,21 +157,6 @@ impl<'a> TrampolineCompiler<'a> {},);}- Trampoline::AlwaysTrap => {- if self.tunables.signals_based_traps {- self.builder.ins().trap(TRAP_ALWAYS);- return;- }- self.translate_libcall(- host::trap,- TrapSentinel::Falsy,- WasmArgs::InRegisters,- |me, params| {- let code = wasmtime_environ::Trap::AlwaysTrapAdapter as u8;- params.push(me.builder.ins().iconst(ir::types::I32, i64::from(code)));- },- );- }Trampoline::ResourceNew { instance, ty } => {// Currently this only supports resources represented by `i32`assert_eq!(self.signature.params()[0], WasmValType::I32);@@ -1130,13 +1112,8 @@ impl<'a> TrampolineCompiler<'a> {// brif should_run_destructor, run_destructor_block, return_block//// run_destructor_block:- // ;; test may_enter, but only if the component instances- // ;; differ- // flags = load.i32 vmctx+$instance_flags_offset- // masked = band flags, $FLAG_MAY_ENTER- // trapz masked, CANNOT_ENTER_CODE- //- // ;; set may_block to false, saving the old value to restore later+ // ;; set may_block to false, saving the old value to restore+ // ;; later, but only if the component instances differ// old_may_block = load.i32 vmctx+$may_block_offset// store 0, vmctx+$may_block_offset//@@ -1184,25 +1161,13 @@ impl<'a> TrampolineCompiler<'a> {self.builder.switch_to_block(run_destructor_block);- // If this is a defined resource within the component itself then a- // check needs to be emitted for the `may_enter` flag. Note though- // that this check 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 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.let old_may_block = if let Some(def) = resource_def {if self.types[resource].unwrap_concrete_instance() != def.instance {- let flags = self.builder.ins().load(- ir::types::I32,- trusted,- vmctx,- i32::try_from(self.offsets.instance_flags(def.instance)).unwrap(),- );- let masked = self- .builder- .ins()- .band_imm(flags, i64::from(FLAG_MAY_ENTER));- self.builder.ins().trapz(masked, TRAP_CANNOT_ENTER);-// Stash the old value of `may_block` and then set it to false.let old_may_block = self.builder.ins().load(ir::types::I32,@@ -1434,7 +1399,7 @@ impl ComponentCompiler for Compiler {types: &ComponentTypesBuilder,key: FuncKey,abi: Abi,- tunables: &Tunables,+ _tunables: &Tunables,symbol: &str,) -> Result<CompiledFunctionBody> {let (abi2, trampoline_index) = key.unwrap_component_trampoline();@@ -1466,14 +1431,7 @@ impl ComponentCompiler for Compiler {}let mut compiler = self.function_compiler();- let mut c = TrampolineCompiler::new(- self,- &mut compiler,- &component.component,- types,- sig,- tunables,- );+ let mut c = TrampolineCompiler::new(self, &mut compiler, &component.component, types, sig);// If we are crossing the Wasm-to-native boundary, we need to save the// exit FP and return address for stack walking purposes. However, we@@ -1512,7 +1470,7 @@ impl ComponentCompiler for Compiler {fn compile_intrinsic(&self,- tunables: &Tunables,+ _tunables: &Tunables,component: &ComponentTranslation,types: &ComponentTypesBuilder,intrinsic: UnsafeIntrinsic,@@ -1557,7 +1515,6 @@ impl ComponentCompiler for Compiler {&component.component,&types,&wasm_func_ty,- tunables,);match intrinsic {diff --git a/crates/cranelift/src/lib.rs b/crates/cranelift/src/lib.rsindex b44e3cde44..5ebcf2bcd1 100644--- a/crates/cranelift/src/lib.rs+++ b/crates/cranelift/src/lib.rs@@ -48,10 +48,6 @@ use self::compiler::Compiler;const TRAP_INTERNAL_ASSERT: TrapCode = TrapCode::unwrap_user(1);const TRAP_OFFSET: u8 = 2;-pub const TRAP_ALWAYS: TrapCode =- TrapCode::unwrap_user(Trap::AlwaysTrapAdapter as u8 + TRAP_OFFSET);-pub const TRAP_CANNOT_ENTER: TrapCode =- TrapCode::unwrap_user(Trap::CannotEnterComponent 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/dfg.rs b/crates/environ/src/component/dfg.rsindex 5f5a3b84fa..1c7e991074 100644--- a/crates/environ/src/component/dfg.rs+++ b/crates/environ/src/component/dfg.rs@@ -326,7 +326,6 @@ pub enum Trampoline {to: MemoryId,to64: bool,},- AlwaysTrap,ResourceNew {instance: RuntimeComponentInstanceIndex,ty: TypeResourceTableIndex,@@ -945,7 +944,6 @@ impl LinearizeDfg<'_> {to: self.runtime_memory(*to),to64: *to64,},- Trampoline::AlwaysTrap => info::Trampoline::AlwaysTrap,Trampoline::ResourceNew { instance, ty } => info::Trampoline::ResourceNew {instance: *instance,ty: *ty,diff --git a/crates/environ/src/component/info.rs b/crates/environ/src/component/info.rsindex 65a12aebdb..ea1cb94f7e 100644--- a/crates/environ/src/component/info.rs+++ b/crates/environ/src/component/info.rs@@ -734,10 +734,6 @@ pub enum Trampoline {to64: bool,},- /// A small adapter which simply traps, used for degenerate lift/lower- /// combinations.- AlwaysTrap,-/// A `resource.new` intrinsic which will inject a new resource into the/// table specified.ResourceNew {@@ -1199,7 +1195,6 @@ impl Trampoline {let to = if *to64 { "64" } else { "32" };format!("component-transcode-{op}-m{from}-m{to}")}- AlwaysTrap => format!("component-always-trap"),ResourceNew { ty, .. } => format!("component-resource-new[{}]", ty.as_u32()),ResourceRep { ty, .. } => format!("component-resource-rep[{}]", ty.as_u32()),ResourceDrop { ty, .. } => format!("component-resource-drop[{}]", ty.as_u32()),diff --git a/crates/environ/src/component/translate/adapt.rs b/crates/environ/src/component/translate/adapt.rsindex 2f66974a7a..d528099a20 100644--- a/crates/environ/src/component/translate/adapt.rs+++ b/crates/environ/src/component/translate/adapt.rs@@ -166,6 +166,9 @@ pub struct AdapterOptions {/// The Wasmtime-assigned component instance index where the options were/// originally specified.pub instance: RuntimeComponentInstanceIndex,+ /// The ancestors (i.e. chain of instantiating instances) of the instance+ /// specified in the `instance` field.+ pub ancestors: Vec<RuntimeComponentInstanceIndex>,/// How strings are encoded.pub string_encoding: StringEncoding,/// The async callback function used by these options, if specified.diff --git a/crates/environ/src/component/translate/inline.rs b/crates/environ/src/component/translate/inline.rsindex afff24fc41..b6004c62ce 100644--- a/crates/environ/src/component/translate/inline.rs+++ b/crates/environ/src/component/translate/inline.rs@@ -386,7 +386,7 @@ impl<'a> Inliner<'a> {// Process the initializer and if it started the instantiation// of another component then we push that frame on the stack to// continue onwards.- Some(init) => match self.initializer(frame, types, init)? {+ Some(init) => match self.initializer(frames, types, init)? {Some(new_frame) => {frames.push((new_frame, types.resources_mut().clone()));}@@ -422,12 +422,13 @@ impl<'a> Inliner<'a> {fn initializer(&mut self,- frame: &mut InlinerFrame<'a>,+ frames: &mut Vec<(InlinerFrame<'a>, ResourcesBuilder)>,types: &mut ComponentTypesBuilder,initializer: &'a LocalInitializer,) -> Result<Option<InlinerFrame<'a>>> {use LocalInitializer::*;+ let (frame, _) = frames.last_mut().unwrap();match initializer {// When a component imports an item the actual definition of the// item is looked up here (not at runtime) via its name. The@@ -512,7 +513,8 @@ impl<'a> Inliner<'a> {} => {let lower_ty =types.convert_component_func_type(frame.translation.types_ref(), *lower_ty)?;- let options_lower = self.adapter_options(frame, types, options);+ let options_lower = self.adapter_options(frames, types, options);+ let (frame, _) = frames.last_mut().unwrap();let lower_core_type = options_lower.core_type;let func = match &frame.component_funcs[*func] {// If this component function was originally a host import@@ -533,45 +535,8 @@ impl<'a> Inliner<'a> {dfg::CoreDef::Trampoline(index)}- // This case handles when a lifted function is later- // lowered, and both the lowering and the lifting are- // happening within the same component instance.- //- // In this situation if the `canon.lower`'d function is- // called then it immediately sets `may_enter` to `false`.- // When calling the callee, however, that's `canon.lift`- // which immediately traps if `may_enter` is `false`. That- // means that this pairing of functions creates a function- // that always traps.- //- // When closely reading the spec though the precise trap- // that comes out can be somewhat variable. Technically the- // function yielded here is one that should validate the- // arguments by lifting them, and then trap. This means that- // the trap could be different depending on whether all- // arguments are valid for now. This was discussed in- // WebAssembly/component-model#51 somewhat and the- // conclusion was that we can probably get away with "always- // trap" here.- //- // The `CoreDef::AlwaysTrap` variant here is used to- // indicate that this function is valid but if something- // actually calls it then it just generates a trap- // immediately.- ComponentFuncDef::Lifted {- options: options_lift,- ..- } if options_lift.instance == options_lower.instance => {- let index = self- .result- .trampolines- .push((lower_core_type, dfg::Trampoline::AlwaysTrap));- dfg::CoreDef::Trampoline(index)- }-- // Lowering a lifted function where the destination- // component is different than the source component means- // that a "fused adapter" was just identified.+ // Lowering a lifted functio means that a "fused adapter"+ // was just identified.//// Metadata about this fused adapter is recorded in the// `Adapters` output of this compilation pass. Currently the@@ -624,7 +589,8 @@ impl<'a> Inliner<'a> {// plumbed through to exports or a fused adapter later on.Lift(ty, func, options) => {let ty = types.convert_component_func_type(frame.translation.types_ref(), *ty)?;- let options = self.adapter_options(frame, types, options);+ let options = self.adapter_options(frames, types, options);+ let (frame, _) = frames.last_mut().unwrap();let func = frame.funcs[*func].1.clone();frame.component_funcs@@ -724,7 +690,8 @@ impl<'a> Inliner<'a> {.collect::<Result<_>>()?;let results = types.new_tuple_type(results);let func = options.core_type;- let options = self.adapter_options(frame, types, options);+ let options = self.adapter_options(frames, types, options);+ let (frame, _) = frames.last_mut().unwrap();let options = self.canonical_options(options);let index = self.result.trampolines.push((func,@@ -756,7 +723,8 @@ impl<'a> Inliner<'a> {}WaitableSetWait { options } => {let func = options.core_type;- let options = self.adapter_options(frame, types, options);+ let options = self.adapter_options(frames, types, options);+ let (frame, _) = frames.last_mut().unwrap();let options = self.canonical_options(options);let index = self.result.trampolines.push((func,@@ -769,7 +737,8 @@ impl<'a> Inliner<'a> {}WaitableSetPoll { options } => {let func = options.core_type;- let options = self.adapter_options(frame, types, options);+ let options = self.adapter_options(frames, types, options);+ let (frame, _) = frames.last_mut().unwrap();let options = self.canonical_options(options);let index = self.result.trampolines.push((func,@@ -849,7 +818,8 @@ impl<'a> Inliner<'a> {unreachable!()};let func = options.core_type;- let options = self.adapter_options(frame, types, options);+ let options = self.adapter_options(frames, types, options);+ let (frame, _) = frames.last_mut().unwrap();let options = self.canonical_options(options);let index = self.result.trampolines.push((func,@@ -868,7 +838,8 @@ impl<'a> Inliner<'a> {unreachable!()};let func = options.core_type;- let options = self.adapter_options(frame, types, options);+ let options = self.adapter_options(frames, types, options);+ let (frame, _) = frames.last_mut().unwrap();let options = self.canonical_options(options);let index = self.result.trampolines.push((func,@@ -964,7 +935,8 @@ impl<'a> Inliner<'a> {unreachable!()};let func = options.core_type;- let options = self.adapter_options(frame, types, options);+ let options = self.adapter_options(frames, types, options);+ let (frame, _) = frames.last_mut().unwrap();let options = self.canonical_options(options);let index = self.result.trampolines.push((func,@@ -983,7 +955,8 @@ impl<'a> Inliner<'a> {unreachable!()};let func = options.core_type;- let options = self.adapter_options(frame, types, options);+ let options = self.adapter_options(frames, types, options);+ let (frame, _) = frames.last_mut().unwrap();let options = self.canonical_options(options);let index = self.result.trampolines.push((func,@@ -1060,7 +1033,8 @@ impl<'a> Inliner<'a> {ErrorContextNew { options } => {let ty = types.error_context_table_type()?;let func = options.core_type;- let options = self.adapter_options(frame, types, options);+ let options = self.adapter_options(frames, types, options);+ let (frame, _) = frames.last_mut().unwrap();let options = self.canonical_options(options);let index = self.result.trampolines.push((func,@@ -1075,7 +1049,8 @@ impl<'a> Inliner<'a> {ErrorContextDebugMessage { options } => {let ty = types.error_context_table_type()?;let func = options.core_type;- let options = self.adapter_options(frame, types, options);+ let options = self.adapter_options(frames, types, options);+ let (frame, _) = frames.last_mut().unwrap();let options = self.canonical_options(options);let index = self.result.trampolines.push((func,@@ -1559,10 +1534,11 @@ impl<'a> Inliner<'a> {/// specified into a runtime representation.fn adapter_options(&mut self,- frame: &InlinerFrame<'a>,+ frames: &mut Vec<(InlinerFrame<'a>, ResourcesBuilder)>,types: &ComponentTypesBuilder,options: &LocalCanonicalOptions,) -> AdapterOptions {+ let (frame, _) = frames.last_mut().unwrap();let data_model = match options.data_model {LocalDataModel::Gc {} => DataModel::Gc {},LocalDataModel::LinearMemory { memory, realloc } => {@@ -1584,6 +1560,12 @@ impl<'a> Inliner<'a> {let post_return = options.post_return.map(|i| frame.funcs[i].1.clone());AdapterOptions {instance: frame.instance,+ ancestors: frames+ .iter()+ .rev()+ .skip(1)+ .map(|(frame, _)| frame.instance)+ .collect(),string_encoding: options.string_encoding,callback,post_return,diff --git a/crates/environ/src/component/vmcomponent_offsets.rs b/crates/environ/src/component/vmcomponent_offsets.rsindex 6743dbba2f..2fc76f7e03 100644--- a/crates/environ/src/component/vmcomponent_offsets.rs+++ b/crates/environ/src/component/vmcomponent_offsets.rs@@ -29,10 +29,6 @@ pub const VMCOMPONENT_MAGIC: u32 = u32::from_le_bytes(*b"comp");/// canonical ABI flag `may_leave`pub const FLAG_MAY_LEAVE: i32 = 1 << 0;-/// Flag for the `VMComponentContext::flags` field which corresponds to the-/// canonical ABI flag `may_enter`-pub const FLAG_MAY_ENTER: i32 = 1 << 1;-/// Flag for the `VMComponentContext::flags` field which is set whenever a/// function is called to indicate that `post_return` must be called next.pub const FLAG_NEEDS_POST_RETURN: i32 = 1 << 2;diff --git a/crates/environ/src/fact.rs b/crates/environ/src/fact.rsindex 686c0ba96b..77011665a0 100644--- a/crates/environ/src/fact.rs+++ b/crates/environ/src/fact.rs@@ -114,9 +114,6 @@ struct AdapterData {/// The core wasm function that this adapter will be calling (the original/// function that was `canon lift`'d)callee: FuncIndex,- /// FIXME(#4185) should be plumbed and handled as part of the new reentrance- /// rules not yet implemented here.- called_as_export: bool,}/// Configuration options which apply at the "global adapter" level.@@ -124,7 +121,12 @@ struct AdapterData {/// These options are typically unique per-adapter and generally aren't needed/// when translating recursive types within an adapter.struct AdapterOptions {+ /// The Wasmtime-assigned component instance index where the options were+ /// originally specified.instance: RuntimeComponentInstanceIndex,+ /// The ancestors (i.e. chain of instantiating instances) of the instance+ /// specified in the `instance` field.+ ancestors: Vec<RuntimeComponentInstanceIndex>,/// The ascribed type of this adapter.ty: TypeFuncIndex,/// The global that represents the instance flags for where this adapter@@ -307,9 +309,6 @@ impl<'a> Module<'a> {lift,lower,callee,- // FIXME(#4185) should be plumbed and handled as part of the new- // reentrance rules not yet implemented here.- called_as_export: true,},);@@ -321,6 +320,7 @@ impl<'a> Module<'a> {fn import_options(&mut self, ty: TypeFuncIndex, options: &AdapterOptionsDfg) -> AdapterOptions {let AdapterOptionsDfg {instance,+ ancestors,string_encoding,post_return: _, // handled abovecallback,@@ -399,6 +399,7 @@ impl<'a> Module<'a> {AdapterOptions {instance: *instance,+ ancestors: ancestors.clone(),ty,flags,post_return: None,diff --git a/crates/environ/src/fact/trampoline.rs b/crates/environ/src/fact/trampoline.rsindex 2df0b1e6ba..d3bdecc42b 100644--- a/crates/environ/src/fact/trampoline.rs+++ b/crates/environ/src/fact/trampoline.rs@@ -16,8 +16,8 @@//! can be somewhat arbitrary, an intentional decision.use crate::component::{- CanonicalAbiInfo, ComponentTypesBuilder, FLAG_MAY_ENTER, FLAG_MAY_LEAVE, FixedEncoding as FE,- FlatType, InterfaceType, MAX_FLAT_ASYNC_PARAMS, MAX_FLAT_PARAMS, PREPARE_ASYNC_NO_RESULT,+ CanonicalAbiInfo, ComponentTypesBuilder, FLAG_MAY_LEAVE, FixedEncoding as FE, FlatType,+ InterfaceType, MAX_FLAT_ASYNC_PARAMS, MAX_FLAT_PARAMS, PREPARE_ASYNC_NO_RESULT,PREPARE_ASYNC_WITH_RESULT, START_FLAG_ASYNC_CALLEE, StringEncoding, Transcode,TypeComponentLocalErrorContextTableIndex, TypeEnumIndex, TypeFixedLengthListIndex,TypeFlagsIndex, TypeFutureTableIndex, TypeListIndex, TypeOptionIndex, TypeRecordIndex,@@ -114,6 +114,19 @@ pub(super) fn compile(module: &mut Module<'_>, adapter: &AdapterData) {)}+ // If the lift and lower instances are equal, or if one is an ancestor of+ // the other, we trap unconditionally. This ensures that recursive+ // reentrance via an adapter is impossible.+ if adapter.lift.instance == adapter.lower.instance+ || adapter.lower.ancestors.contains(&adapter.lift.instance)+ || adapter.lift.ancestors.contains(&adapter.lower.instance)+ {+ let (mut compiler, _, _) = compiler(module, adapter);+ compiler.trap(Trap::CannotEnterComponent);+ compiler.finish();+ return;+ }+// This closure compiles a function to be exported to the host which host to// lift the parameters from the caller and lower them to the callee.//@@ -739,20 +752,6 @@ impl<'a, 'b> Compiler<'a, 'b> {FLAG_MAY_LEAVE,Trap::CannotLeaveComponent,);- if adapter.called_as_export {- self.trap_if_not_flag(- adapter.lift.flags,- FLAG_MAY_ENTER,- Trap::CannotEnterComponent,- );- self.set_flag(adapter.lift.flags, FLAG_MAY_ENTER, false);- } else if self.module.debug {- self.assert_not_flag(- adapter.lift.flags,- FLAG_MAY_ENTER,- Trap::DebugAssertMayEnterUnset,- );- }let task_may_block = self.module.import_task_may_block();let old_task_may_block = if self.types[adapter.lift.ty].async_ {@@ -831,9 +830,6 @@ impl<'a, 'b> Compiler<'a, 'b> {}self.instruction(Call(func.as_u32()));}- if adapter.called_as_export {- self.set_flag(adapter.lift.flags, FLAG_MAY_ENTER, true);- }for tmp in temps {self.free_temp_local(tmp);@@ -3399,15 +3395,6 @@ impl<'a, 'b> Compiler<'a, 'b> {self.instruction(End);}- fn assert_not_flag(&mut self, flags_global: GlobalIndex, flag_to_test: i32, trap: Trap) {- self.instruction(GlobalGet(flags_global.as_u32()));- self.instruction(I32Const(flag_to_test));- self.instruction(I32And);- self.instruction(If(BlockType::Empty));- self.trap(trap);- self.instruction(End);- }-fn set_flag(&mut self, flags_global: GlobalIndex, flag_to_set: i32, value: bool) {self.instruction(GlobalGet(flags_global.as_u32()));if value {diff --git a/crates/environ/src/trap_encoding.rs b/crates/environ/src/trap_encoding.rsindex 95bc95c704..f9d22368eb 100644--- a/crates/environ/src/trap_encoding.rs+++ b/crates/environ/src/trap_encoding.rs@@ -16,7 +16,7 @@ pub struct TrapInformation {// The code can be accessed from the c-api, where the possible values are// translated into enum values defined there://-// * `wasm_trap_code` in c-api/src/trap.rs, and+// * the const assertions in c-api/src/trap.rs, and// * `wasmtime_trap_code_enum` in c-api/include/wasmtime/trap.h.//// These need to be kept in sync.@@ -57,13 +57,6 @@ pub enum Trap {/// Execution has potentially run too long and may be interrupted.Interrupt,- /// When the `component-model` feature is enabled this trap represents a- /// function that was `canon lift`'d, then `canon lower`'d, then called.- /// This combination of creation of a function in the component model- /// generates a function that always traps and, when called, produces this- /// flavor of trap.- AlwaysTrapAdapter,-/// When wasm code is configured to consume fuel and it runs out of fuel/// then this trap will be raised.OutOfFuel,@@ -128,13 +121,6 @@ pub enum Trap {/// encoding operation.DebugAssertEqualCodeUnits,- /// Debug assertion generated for a fused adapter regarding the expected- /// value of the `may_enter` flag for an instance.- ///- /// TODO: Remove this once- /// https://github.com/bytecodealliance/wasmtime/pull/12153 has been merged.- DebugAssertMayEnterUnset,-/// Debug assertion generated for a fused adapter regarding the alignment of/// a pointer.DebugAssertPointerAligned,@@ -155,7 +141,8 @@ pub enum Trap {/// A component passed an unaligned pointer when lifting or lowering a/// value.UnalignedPointer,- // if adding a variant here be sure to update the `check!` macro below+ // if adding a variant here be sure to update the `check!` macro below, and+ // remember to update `trap.rs` and `trap.h` as mentioned above}impl Trap {@@ -183,7 +170,6 @@ impl Trap {BadConversionToIntegerUnreachableCodeReachedInterrupt- AlwaysTrapAdapterOutOfFuelAtomicWaitNonSharedMemoryNullReference@@ -201,7 +187,6 @@ impl Trap {InvalidCharDebugAssertStringEncodingFinishedDebugAssertEqualCodeUnits- DebugAssertMayEnterUnsetDebugAssertPointerAlignedDebugAssertUpperBitsUnsetStringOutOfBounds@@ -230,7 +215,6 @@ impl fmt::Display for Trap {BadConversionToInteger => "invalid conversion to integer",UnreachableCodeReached => "wasm `unreachable` instruction executed",Interrupt => "interrupt",- AlwaysTrapAdapter => "degenerate component adapter called",OutOfFuel => "all fuel consumed by WebAssembly",AtomicWaitNonSharedMemory => "atomic wait on non-shared memory",NullReference => "null reference",@@ -248,7 +232,6 @@ impl fmt::Display for Trap {InvalidChar => "invalid `char` bit pattern",DebugAssertStringEncodingFinished => "should have finished string encoding",DebugAssertEqualCodeUnits => "code units should be equal",- DebugAssertMayEnterUnset => "`may_enter` flag should be unset",DebugAssertPointerAligned => "pointer should be aligned",DebugAssertUpperBitsUnset => "upper bits should be unset",StringOutOfBounds => "string content out-of-bounds",diff --git a/crates/misc/component-async-tests/src/round_trip.rs b/crates/misc/component-async-tests/src/round_trip.rsindex d8894c5473..7308abfece 100644--- a/crates/misc/component-async-tests/src/round_trip.rs+++ b/crates/misc/component-async-tests/src/round_trip.rs@@ -6,6 +6,7 @@ pub mod bindings {wasmtime::component::bindgen!({path: "wit",world: "round-trip",+ imports: { default: trappable },});}@@ -18,9 +19,9 @@ pub mod non_concurrent_export_bindings {}impl bindings::local::local::baz::HostWithStore for Ctx {- async fn foo<T>(_: &Accessor<T, Self>, s: String) -> String {+ async fn foo<T>(_: &Accessor<T, Self>, s: String) -> wasmtime::Result<String> {crate::util::sleep(Duration::from_millis(10)).await;- format!("{s} - entered host - exited host")+ Ok(format!("{s} - entered host - exited host"))}}diff --git a/crates/misc/component-async-tests/tests/scenario/round_trip.rs b/crates/misc/component-async-tests/tests/scenario/round_trip.rsindex b2a14c30f1..ac4d444de3 100644--- a/crates/misc/component-async-tests/tests/scenario/round_trip.rs+++ b/crates/misc/component-async-tests/tests/scenario/round_trip.rs@@ -12,9 +12,11 @@ use futures::{channel::oneshot,stream::{FuturesUnordered, TryStreamExt},};-use wasmtime::component::{Accessor, AccessorTask, HasSelf, Instance, Linker, ResourceTable, Val};-use wasmtime::{Engine, Result, Store, format_err};-use wasmtime_wasi::WasiCtxBuilder;+use wasmtime::component::{+ Accessor, AccessorTask, HasData, HasSelf, Instance, Linker, ResourceTable, Val,+};+use wasmtime::{Engine, Result, Store, Trap, format_err};+use wasmtime_wasi::{WasiCtx, WasiCtxBuilder, WasiCtxView, WasiView};#[tokio::test]pub async fn async_round_trip_stackful() -> Result<()> {@@ -203,6 +205,143 @@ pub async fn async_round_trip_stackless_sync_import() -> Result<()> {.await}+#[tokio::test]+pub async fn async_round_trip_stackless_recurse() -> Result<()> {+ test_round_trip_recurse(+ test_programs_artifacts::ASYNC_ROUND_TRIP_STACKLESS_COMPONENT,+ false,+ )+ .await+}++#[tokio::test]+pub async fn async_round_trip_stackless_recurse_trap() -> Result<()> {+ let error = test_round_trip_recurse(+ test_programs_artifacts::ASYNC_ROUND_TRIP_STACKLESS_COMPONENT,+ true,+ )+ .await+ .unwrap_err();++ assert_eq!(error.downcast::<Trap>()?, Trap::CannotEnterComponent);++ Ok(())+}++#[tokio::test]+pub async fn async_round_trip_synchronous_recurse() -> Result<()> {+ test_round_trip_recurse(+ test_programs_artifacts::ASYNC_ROUND_TRIP_SYNCHRONOUS_COMPONENT,+ false,+ )+ .await+}++#[tokio::test]+pub async fn async_round_trip_synchronous_recurse_trap() -> Result<()> {+ let error = test_round_trip_recurse(+ test_programs_artifacts::ASYNC_ROUND_TRIP_SYNCHRONOUS_COMPONENT,+ true,+ )+ .await+ .unwrap_err();++ assert_eq!(error.downcast::<Trap>()?, Trap::CannotEnterComponent);++ Ok(())+}++async fn test_round_trip_recurse(component: &str, same_instance: bool) -> Result<()> {+ pub struct MyCtx {+ wasi: WasiCtx,+ table: ResourceTable,+ instance: Option<Arc<Instance>>,+ }++ impl WasiView for MyCtx {+ fn ctx(&mut self) -> WasiCtxView<'_> {+ WasiCtxView {+ ctx: &mut self.wasi,+ table: &mut self.table,+ }+ }+ }++ impl HasData for MyCtx {+ type Data<'a> = &'a mut Self;+ }++ impl component_async_tests::round_trip::bindings::local::local::baz::HostWithStore for MyCtx {+ async fn foo<T: Send>(accessor: &Accessor<T, Self>, s: String) -> wasmtime::Result<String> {+ if let Some(instance) = accessor.with(|mut access| access.get().instance.take()) {+ run(accessor, &instance).await?;+ accessor.with(|mut access| access.get().instance = Some(instance));+ }+ Ok(format!("{s} - entered host - exited host"))+ }+ }++ impl component_async_tests::round_trip::bindings::local::local::baz::Host for MyCtx {}++ async fn run<T: Send>(accessor: &Accessor<T, MyCtx>, instance: &Instance) -> Result<()> {+ let round_trip = accessor.with(|mut access| {+ component_async_tests::round_trip::bindings::RoundTrip::new(&mut access, &instance)+ })?;++ let input = "hello, world!";+ let expected = "hello, world! - entered guest - entered host - exited host - exited guest";++ let actual = round_trip+ .local_local_baz()+ .call_foo(accessor, input.into())+ .await?;++ assert_eq!(expected, actual);++ Ok(())+ }++ let engine = Engine::new(&config())?;++ let mut linker = Linker::new(&engine);++ wasmtime_wasi::p2::add_to_linker_async(&mut linker)?;+ component_async_tests::round_trip::bindings::local::local::baz::add_to_linker::<_, MyCtx>(+ &mut linker,+ |ctx| ctx,+ )?;++ let component = make_component(&engine, &[component]).await?;++ let mut store = Store::new(+ &engine,+ MyCtx {+ wasi: WasiCtxBuilder::new().inherit_stdio().build(),+ table: ResourceTable::default(),+ instance: None,+ },+ );++ let instance = Arc::new(linker.instantiate_async(&mut store, &component).await?);+ store.data_mut().instance = Some(instance.clone());++ let instance = if same_instance {+ instance+ } else {+ Arc::new(linker.instantiate_async(&mut store, &component).await?)+ };++ store+ .run_concurrent(async move |accessor| {+ run(&accessor.with_getter(|ctx| ctx), &instance).await+ })+ .await??;++ store.assert_concurrent_state_empty();++ Ok(())+}+pub async fn test_round_trip(components: &[&str],inputs_and_outputs: &[(&str, &str)],diff --git a/crates/wasmtime/src/runtime/component/concurrent.rs b/crates/wasmtime/src/runtime/component/concurrent.rsindex 2ad06ef271..e8198a4a38 100644--- a/crates/wasmtime/src/runtime/component/concurrent.rs+++ b/crates/wasmtime/src/runtime/component/concurrent.rs@@ -51,15 +51,12 @@//! in host functions.use crate::component::func::{self, Func};-use crate::component::store::StoreComponentInstanceId;use crate::component::{- ComponentInstanceId, HasData, HasSelf, Instance, Resource, ResourceTable, ResourceTableError,+ HasData, HasSelf, Instance, Resource, ResourceTable, ResourceTableError, RuntimeInstance,};use crate::fiber::{self, StoreFiber, StoreFiberYield};use crate::store::{Store, StoreId, StoreInner, StoreOpaque, StoreToken};-use crate::vm::component::{- CallContext, ComponentInstance, HandleTable, InstanceFlags, ResourceTables,-};+use crate::vm::component::{CallContext, ComponentInstance, HandleTable, ResourceTables};use crate::vm::{AlwaysMut, SendSyncPtr, VMFuncRef, VMMemoryDefinition, VMStore};use crate::{AsContext, AsContextMut, FuncType, Result, StoreContext, StoreContextMut, ValRaw, ValType,@@ -444,7 +441,7 @@ where/// Run the specified closure, passing it mutable access to the store.////// This function is one of the main building blocks of the [`Accessor`]- /// type. This yields synchronous, blocking, access to store via an+ /// type. This yields synchronous, blocking, access to the store via an/// [`Access`]. The [`Access`] implements [`AsContextMut`] in addition to/// providing the ability to access `D` via [`Access::get`]. Note that the/// `fun` here is given only temporary access to the store and `T`/`D`@@ -720,7 +717,7 @@ pub(crate) enum WaitResult {pub(crate) fn poll_and_block<R: Send + Sync + 'static>(store: &mut dyn VMStore,future: impl Future<Output = Result<R>> + Send + 'static,- caller_instance: RuntimeComponentInstanceIndex,+ caller_instance: RuntimeInstance,) -> Result<R> {let state = store.concurrent_state_mut();@@ -852,7 +849,7 @@ fn handle_guest_call(store: &mut dyn VMStore, call: GuestCall) -> Result<()> {.take().unwrap();- let code = callback(store, runtime_instance.index, event, handle)?;+ let code = callback(store, event, handle)?;store.concurrent_state_mut()@@ -1386,18 +1383,89 @@ impl<T> StoreContextMut<'_, T> {}}-#[derive(Debug, Copy, Clone)]-pub struct RuntimeInstance {- pub instance: ComponentInstanceId,- pub index: RuntimeComponentInstanceIndex,-}-impl StoreOpaque {+ /// Determine whether the specified instance may be entered from the host.+ ///+ /// We return `true` here only if all of the following hold:+ ///+ /// - The top-level instance is not already on the current task's call stack.+ /// - The instance is not in need of a post-return function call.+ /// - `self` has not been poisoned due to a trap.+ pub(crate) fn may_enter(&mut self, instance: RuntimeInstance) -> bool {+ let state = self.concurrent_state_mut();+ if let Some(caller) = state.guest_thread {+ instance != state.get_mut(caller.task).unwrap().instance+ && self.may_enter_from_caller(caller.task, instance)+ } else {+ self.may_enter_at_all(instance)+ }+ }++ fn may_enter_at_all(&self, instance: RuntimeInstance) -> bool {+ if self.trapped() {+ return false;+ }++ let flags = self+ .component_instance(instance.instance)+ .instance_flags(instance.index);++ unsafe { !flags.needs_post_return() }+ }++ /// Variation of `may_enter` which takes a `TableId<GuestTask>` representing+ /// the callee.+ fn may_enter_task(&mut self, task: TableId<GuestTask>) -> bool {+ let instance = self.concurrent_state_mut().get_mut(task).unwrap().instance;+ self.may_enter_from_caller(task, instance)+ }++ /// Variation of `may_enter` which takes a `TableId<GuestTask>` representing+ /// the caller, plus a `RuntimeInstance` representing the callee.+ fn may_enter_from_caller(+ &mut self,+ mut guest_task: TableId<GuestTask>,+ instance: RuntimeInstance,+ ) -> bool {+ self.may_enter_at_all(instance) && {+ let state = self.concurrent_state_mut();+ let guest_instance = instance.instance;+ loop {+ // Note that we only compare top-level instance IDs here. The+ // idea is that the host is not allowed to recursively enter a+ // top-level instance even if the specific leaf instance is not+ // on the stack. This the behavior defined in the spec, and it+ // allows us to elide runtime checks in guest-to-guest adapters.+ let next_thread = match &state.get_mut(guest_task).unwrap().caller {+ Caller::Host { caller: None, .. } => break true,+ &Caller::Host {+ caller: Some(caller),+ ..+ } => {+ let instance = state.get_mut(caller.task).unwrap().instance;+ if instance.instance == guest_instance {+ break false;+ } else {+ caller+ }+ }+ &Caller::Guest { thread, instance } => {+ if instance.instance == guest_instance {+ break false;+ } else {+ thread+ }+ }+ };+ guest_task = next_thread.task;+ }+ }+ }+/// Helper function to retrieve the `ConcurrentInstanceState` for the/// specified instance.fn instance_state(&mut self, instance: RuntimeInstance) -> &mut ConcurrentInstanceState {- StoreComponentInstanceId::new(self.id(), instance.instance)- .get_mut(self)+ self.component_instance_mut(instance.instance).instance_state(instance.index).concurrent_state()}@@ -1405,8 +1473,7 @@ impl StoreOpaque {/// Helper function to retrieve the `HandleTable` for the specified/// instance.fn handle_table(&mut self, instance: RuntimeInstance) -> &mut HandleTable {- StoreComponentInstanceId::new(self.id(), instance.instance)- .get_mut(self)+ self.component_instance_mut(instance.instance).instance_state(instance.index).handle_table()}@@ -1420,8 +1487,7 @@ impl StoreOpaque {let old_thread = state.guest_thread.take();if let Some(old_thread) = old_thread {let instance = state.get_mut(old_thread.task).unwrap().instance.instance;- StoreComponentInstanceId::new(self.id(), instance)- .get_mut(self)+ self.component_instance_mut(instance).set_task_may_block(false)}@@ -1443,8 +1509,7 @@ impl StoreOpaque {let guest_thread = state.guest_thread.unwrap();let instance = state.get_mut(guest_thread.task).unwrap().instance.instance;let may_block = self.concurrent_state_mut().may_block(guest_thread.task);- StoreComponentInstanceId::new(self.id(), instance)- .get_mut(self)+ self.component_instance_mut(instance).set_task_may_block(may_block)}@@ -1452,9 +1517,7 @@ impl StoreOpaque {let state = self.concurrent_state_mut();let task = state.guest_thread.unwrap().task;let instance = state.get_mut(task).unwrap().instance.instance;- let task_may_block = StoreComponentInstanceId::new(self.id(), instance)- .get_mut(self)- .get_task_may_block();+ let task_may_block = self.component_instance(instance).get_task_may_block();if task_may_block {Ok(())@@ -1894,7 +1957,6 @@ impl Instance {callee: SendSyncPtr<VMFuncRef>,param_count: usize,result_count: usize,- flags: Option<InstanceFlags>,async_: bool,callback: Option<SendSyncPtr<VMFuncRef>>,post_return: Option<SendSyncPtr<VMFuncRef>>,@@ -1919,7 +1981,6 @@ impl Instance {callee: SendSyncPtr<VMFuncRef>,param_count: usize,result_count: usize,- flags: Option<InstanceFlags>,) -> impl FnOnce(&mut dyn VMStore) -> Result<[MaybeUninit<ValRaw>; MAX_FLAT_PARAMS]>+ Send+ Sync@@ -1934,7 +1995,6 @@ impl Instance {.get_mut(guest_thread.thread)?.state = GuestThreadState::Running;let task = store.concurrent_state_mut().get_mut(guest_thread.task)?;- let may_enter_after_call = task.call_post_return_automatically();let lower = task.lower_params.take().unwrap();lower(store, &mut storage[..param_count])?;@@ -1944,9 +2004,6 @@ impl Instance {// SAFETY: Per the contract documented in `make_call's`// documentation, `callee` must be a valid pointer.unsafe {- if let Some(mut flags) = flags {- flags.set_may_enter(false);- }crate::Func::call_unchecked_raw(&mut store,callee.as_non_null(),@@ -1956,9 +2013,6 @@ impl Instance {).unwrap(),)?;- if let Some(mut flags) = flags {- flags.set_may_enter(may_enter_after_call);- }}Ok(storage)@@ -1975,7 +2029,6 @@ impl Instance {callee,param_count,result_count,- flags,)};@@ -2131,7 +2184,6 @@ impl Instance {unsafe {flags.set_may_leave(true);- flags.set_may_enter(true);}}@@ -2345,11 +2397,16 @@ impl Instance {},Caller::Guest {thread: old_thread.unwrap(),- instance: caller_instance,+ instance: RuntimeInstance {+ instance: self.id().instance(),+ index: caller_instance,+ },},None,- self,- callee_instance,+ RuntimeInstance {+ instance: self.id().instance(),+ index: callee_instance,+ },callee_async,)?;@@ -2360,10 +2417,6 @@ impl Instance {let state = store.0.concurrent_state_mut();if let Some(old_thread) = old_thread {- if !state.may_enter(guest_task) {- bail!(crate::Trap::CannotEnterComponent);- }-state.get_mut(old_thread.task)?.subtasks.insert(guest_task);};@@ -2387,14 +2440,10 @@ impl Instance {unsafe fn call_callback<T>(self,mut store: StoreContextMut<T>,- callee_instance: RuntimeComponentInstanceIndex,function: SendSyncPtr<VMFuncRef>,event: Event,handle: u32,- may_enter_after_call: bool,) -> Result<u32> {- let mut flags = self.id().get(store.0).instance_flags(callee_instance);-let (ordinal, result) = event.parts();let params = &mut [ValRaw::u32(ordinal),@@ -2406,13 +2455,11 @@ impl Instance {// `component::Options`. Per `wasmparser` callback signature// validation, we know it takes three parameters and returns one.unsafe {- flags.set_may_enter(false);crate::Func::call_unchecked_raw(&mut store,function.as_non_null(),params.as_mut_slice().into(),)?;- flags.set_may_enter(may_enter_after_call);}Ok(params[0].get_u32())}@@ -2445,9 +2492,6 @@ impl Instance {let state = store.0.concurrent_state_mut();let guest_thread = state.guest_thread.unwrap();let callee_async = state.get_mut(guest_thread.task)?.async_function;- let may_enter_after_call = state- .get_mut(guest_thread.task)?- .call_post_return_automatically();let callee = SendSyncPtr::new(NonNull::new(callee).unwrap());let param_count = usize::try_from(param_count).unwrap();assert!(param_count <= MAX_FLAT_PARAMS);@@ -2460,18 +2504,9 @@ impl Instance {// the callback and related context as part of the task so we can// call it later when needed.let callback = SendSyncPtr::new(NonNull::new(callback).unwrap());- task.callback = Some(Box::new(move |store, runtime_instance, event, handle| {+ task.callback = Some(Box::new(move |store, event, handle| {let store = token.as_context_mut(store);- unsafe {- self.call_callback::<T>(- store,- runtime_instance,- callback,- event,- handle,- may_enter_after_call,- )- }+ unsafe { self.call_callback::<T>(store, callback, event, handle) }}));}@@ -2487,14 +2522,6 @@ impl Instance {let caller = *caller;let caller_instance = *runtime_instance;- let callee_instance = task.instance;-- let instance_flags = if callback.is_null() {- None- } else {- Some(self.id().get(store.0).instance_flags(callee_instance.index))- };-// Queue the call as a "high priority" work item.unsafe {self.queue_call(@@ -2503,7 +2530,6 @@ impl Instance {callee,param_count,result_count,- instance_flags,(flags & START_FLAG_ASYNC_CALLEE) != 0,NonNull::new(callback).map(SendSyncPtr::new),NonNull::new(post_return).map(SendSyncPtr::new),@@ -2567,10 +2593,7 @@ impl Instance {// waitable and return the status.let handle = store.0- .handle_table(RuntimeInstance {- instance: self.id().instance(),- index: caller_instance,- })+ .handle_table(caller_instance).subtask_insert_guest(guest_thread.task.rep())?;store.0@@ -2679,7 +2702,13 @@ impl Instance {// We create a new host task even though it might complete immediately// (in which case we won't need to pass a waitable back to the guest).// If it does complete immediately, we'll remove it before we return.- let task = state.push(HostTask::new(caller_instance, Some(join_handle)))?;+ let task = state.push(HostTask::new(+ RuntimeInstance {+ instance: self.id().instance(),+ index: caller_instance,+ },+ Some(join_handle),+ ))?;log::trace!("new host task child of {caller:?}: {task:?}");@@ -3034,7 +3063,13 @@ impl Instance {// Since waitables can neither be passed between instances nor forged,// this should never fail unless there's a bug in Wasmtime, but we check// here to be sure:- assert_eq!(expected_caller_instance, caller_instance);+ assert_eq!(+ expected_caller_instance,+ RuntimeInstance {+ instance: self.id().instance(),+ index: caller_instance+ }+ );log::trace!("subtask_drop {waitable:?} (handle {task_id})");Ok(())}@@ -3462,7 +3497,13 @@ impl Instance {// Since waitables can neither be passed between instances nor forged,// this should never fail unless there's a bug in Wasmtime, but we check// here to be sure:- assert_eq!(expected_caller_instance, caller_instance);+ assert_eq!(+ expected_caller_instance,+ RuntimeInstance {+ instance: self.id().instance(),+ index: caller_instance+ }+ );log::trace!("subtask_cancel {waitable:?} (handle {task_id})");@@ -4091,15 +4132,12 @@ type HostTaskFuture = Pin<Box<dyn Future<Output = Result<()>> + Send + 'static>>/// Represents the state of a pending host task.struct HostTask {common: WaitableCommon,- caller_instance: RuntimeComponentInstanceIndex,+ caller_instance: RuntimeInstance,join_handle: Option<JoinHandle>,}impl HostTask {- fn new(- caller_instance: RuntimeComponentInstanceIndex,- join_handle: Option<JoinHandle>,- ) -> Self {+ fn new(caller_instance: RuntimeInstance, join_handle: Option<JoinHandle>) -> Self {Self {common: WaitableCommon::default(),caller_instance,@@ -4114,12 +4152,7 @@ impl TableDebug for HostTask {}}-type CallbackFn = Box<- dyn Fn(&mut dyn VMStore, RuntimeComponentInstanceIndex, Event, u32) -> Result<u32>- + Send- + Sync- + 'static,->;+type CallbackFn = Box<dyn Fn(&mut dyn VMStore, Event, u32) -> Result<u32> + Send + Sync + 'static>;/// Represents the caller of a given guest task.enum Caller {@@ -4139,6 +4172,11 @@ enum Caller {host_future_present: bool,/// If true, call `post-return` function (if any) automatically.call_post_return_automatically: bool,+ /// If `Some`, represents the `QualifiedThreadId` caller of the host+ /// function which called back into a guest. Note that this thread+ /// could belong to an entirely unrelated top-level component instance+ /// than the one the host called into.+ caller: Option<QualifiedThreadId>,},/// Another guest thread called the guest taskGuest {@@ -4149,7 +4187,7 @@ enum Caller {/// 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: RuntimeComponentInstanceIndex,+ instance: RuntimeInstance,},}@@ -4389,8 +4427,7 @@ impl GuestTask {lift_result: LiftResult,caller: Caller,callback: Option<CallbackFn>,- component_instance: Instance,- instance: RuntimeComponentInstanceIndex,+ instance: RuntimeInstance,async_function: bool,) -> Result<Self> {let sync_call_set = state.push(WaitableSet::default())?;@@ -4420,10 +4457,7 @@ impl GuestTask {starting_sent: false,subtasks: HashSet::new(),sync_call_set,- instance: RuntimeInstance {- instance: component_instance.id().instance(),- index: instance,- },+ instance,event: None,function_index: None,exited: false,@@ -4472,7 +4506,9 @@ impl GuestTask {};}}- Caller::Host { exit_tx, .. } => {+ Caller::Host {+ exit_tx, caller, ..+ } => {for subtask in &self.subtasks {state.get_mut(*subtask)?.caller = Caller::Host {tx: None,@@ -4482,6 +4518,7 @@ impl GuestTask {exit_tx: exit_tx.clone(),host_future_present: false,call_post_return_automatically: true,+ caller: *caller,};}}@@ -4925,40 +4962,6 @@ impl ConcurrentState {}}- /// Determine whether the instance associated with the specified guest task- /// may be entered (i.e. is not already on the async call stack).- ///- /// This is an additional check on top of the "may_enter" instance flag;- /// it's needed because async-lifted exports with callback functions must- /// not call their own instances directly or indirectly, and due to the- /// "stackless" nature of callback-enabled guest tasks this may happen even- /// if there are no activation records on the stack (i.e. the "may_enter"- /// field is `true`) for that instance.- fn may_enter(&mut self, mut guest_task: TableId<GuestTask>) -> bool {- let guest_instance = self.get_mut(guest_task).unwrap().instance;-- // Walk the task tree back to the root, looking for potential- // reentrance.- //- // TODO: This could be optimized by maintaining a per-`GuestTask` bitset- // such that each bit represents and instance which has been entered by- // that task or an ancestor of that task, in which case this would be a- // constant time check.- loop {- let next_thread = match &self.get_mut(guest_task).unwrap().caller {- Caller::Host { .. } => break true,- Caller::Guest { thread, instance } => {- if *instance == guest_instance.index {- break false;- } else {- *thread- }- }- };- guest_task = next_thread.task;- }- }-/// Implements the `context.get` intrinsic.pub(crate) fn context_get(&mut self, slot: u32) -> Result<u32> {let thread = self.guest_thread.unwrap();@@ -5174,6 +5177,7 @@ pub(crate) fn prepare_call<T, R>(let (tx, rx) = oneshot::channel();let (exit_tx, exit_rx) = oneshot::channel();+ let caller = state.guest_thread;let mut task = GuestTask::new(state,Box::new(for_any_lower(move |store, params| {@@ -5192,30 +5196,22 @@ pub(crate) fn prepare_call<T, R>(exit_tx: Arc::new(exit_tx),host_future_present,call_post_return_automatically,+ caller,},callback.map(|callback| {let callback = SendSyncPtr::new(callback);let instance = handle.instance();- Box::new(- move |store: &mut dyn VMStore, runtime_instance, event, handle| {- let store = token.as_context_mut(store);- // SAFETY: Per the contract of `prepare_call`, the callback- // will remain valid at least as long is this task exists.- unsafe {- instance.call_callback(- store,- runtime_instance,- callback,- event,- handle,- call_post_return_automatically,- )- }- },- ) as CallbackFn+ Box::new(move |store: &mut dyn VMStore, event, handle| {+ let store = token.as_context_mut(store);+ // SAFETY: Per the contract of `prepare_call`, the callback+ // will remain valid at least as long is this task exists.+ unsafe { instance.call_callback(store, callback, event, handle) }+ }) as CallbackFn}),- handle.instance(),- component_instance,+ RuntimeInstance {+ instance: handle.instance().id().instance(),+ index: component_instance,+ },async_function,)?;task.function_index = Some(handle.index());@@ -5224,6 +5220,10 @@ pub(crate) fn prepare_call<T, R>(let thread = state.push(GuestThread::new_implicit(task))?;state.get_mut(task)?.threads.insert(thread);+ if !store.0.may_enter_task(task) {+ bail!(crate::Trap::CannotEnterComponent);+ }+Ok(PreparedCall {handle,thread: QualifiedThreadId { task, thread },@@ -5273,7 +5273,7 @@ fn queue_call0<T: 'static>(guest_thread: QualifiedThreadId,param_count: usize,) -> Result<()> {- let (_options, flags, _ty, raw_options) = handle.abi_info(store.0);+ let (_options, _, _ty, raw_options) = handle.abi_info(store.0);let is_concurrent = raw_options.async_;let callback = raw_options.callback;let instance = handle.instance();@@ -5286,12 +5286,6 @@ fn queue_call0<T: 'static>(log::trace!("queueing call {guest_thread:?}");- let instance_flags = if callback.is_none() {- None- } else {- Some(flags)- };-// SAFETY: `callee`, `callback`, and `post_return` are valid pointers// (with signatures appropriate for this call) and will remain valid as// long as this instance is valid.@@ -5302,7 +5296,6 @@ fn queue_call0<T: 'static>(SendSyncPtr::new(callee),param_count,1,- instance_flags,is_concurrent,callback,post_return.map(SendSyncPtr::new),diff --git a/crates/wasmtime/src/runtime/component/concurrent_disabled.rs b/crates/wasmtime/src/runtime/component/concurrent_disabled.rsindex 2843cd5b2f..0437c1f540 100644--- a/crates/wasmtime/src/runtime/component/concurrent_disabled.rs+++ b/crates/wasmtime/src/runtime/component/concurrent_disabled.rs@@ -1,6 +1,6 @@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;@@ -155,4 +155,16 @@ impl StoreOpaque {pub(crate) fn check_blocking(&mut self) -> Result<()> {Ok(())}++ pub(crate) fn may_enter(&mut self, instance: RuntimeInstance) -> bool {+ if self.trapped() {+ return false;+ }++ let flags = self+ .component_instance(instance.instance)+ .instance_flags(instance.index);++ unsafe { !flags.needs_post_return() }+ }}diff --git a/crates/wasmtime/src/runtime/component/func.rs b/crates/wasmtime/src/runtime/component/func.rsindex 2abb0b4b8b..0cbbff714f 100644--- a/crates/wasmtime/src/runtime/component/func.rs+++ b/crates/wasmtime/src/runtime/component/func.rs@@ -1,3 +1,4 @@+use crate::component::RuntimeInstance;use crate::component::instance::Instance;use crate::component::matching::InstanceType;use crate::component::storage::storage_as_slice;@@ -614,6 +615,15 @@ impl Func {LowerReturn: Copy,{let export = self.lifted_core_func(store.0);+ let (_options, _flags, _ty, raw_options) = self.abi_info(store.0);+ let instance = RuntimeInstance {+ instance: self.instance.id().instance(),+ index: raw_options.instance,+ };++ if !store.0.may_enter(instance) {+ bail!(crate::Trap::CannotEnterComponent);+ }#[repr(C)]union Union<Params: Copy, Return: Copy> {@@ -788,9 +798,6 @@ impl Func {);let post_return_arg = post_return_arg.expect("calling post_return on wrong function");- // This is a sanity-check assert which shouldn't ever trip.- assert!(!flags.may_enter());-// Unset the "needs post return" flag now that post-return is being// processed. This will cause future invocations of this method to// panic, even if the function call below traps.@@ -802,10 +809,6 @@ impl Func {// If the function actually had a `post-return` configured in its// canonical options that's executed here.- //- // Note that if this traps (returns an error) this function- // intentionally leaves the instance in a "poisoned" state where it- // can no longer be entered because `may_enter` is `false`.if let Some(func) = post_return {crate::Func::call_unchecked_raw(&mut store,@@ -816,9 +819,8 @@ impl Func {}// And finally if everything completed successfully then the "may- // enter" and "may leave" flags are set to `true` again here which- // enables further use of the component.- flags.set_may_enter(true);+ // leave" flags is set to `true` again here which enables further+ // use of the component.flags.set_may_leave(true);let (calls, host_table, _, instance) = store@@ -943,26 +945,12 @@ impl Func {fn with_lower_context<T>(self,mut store: StoreContextMut<T>,- may_enter: bool,+ call_post_return_automatically: bool,lower: impl FnOnce(&mut LowerContext<T>, InterfaceType) -> Result<()>,) -> Result<()> {let (options_idx, mut flags, ty, options) = self.abi_info(store.0);let async_ = options.async_;- // Test the "may enter" flag which is a "lock" on this instance.- // This is immediately set to `false` afterwards and note that- // there's no on-cleanup setting this flag back to true. That's an- // intentional design aspect where if anything goes wrong internally- // from this point on the instance is considered "poisoned" and can- // never be entered again. The only time this flag is set to `true`- // again is after post-return logic has completed successfully.- unsafe {- if !flags.may_enter() {- bail!(crate::Trap::CannotEnterComponent);- }- flags.set_may_enter(false);- }-// Perform the actual lowering, where while this is running the// component is forbidden from calling imports.unsafe {@@ -975,14 +963,10 @@ impl Func {unsafe { flags.set_may_leave(true) };result?;- // If this is an async function and `may_enter == true` then we're- // allowed to reenter the component at this point, and otherwise flag a- // post-return call being required as we're about to enter wasm and- // afterwards need a post-return.+ // If needed, flag a post-return call being required as we're about to+ // enter wasm and afterwards need a post-return.unsafe {- if may_enter && async_ {- flags.set_may_enter(true);- } else {+ if !(call_post_return_automatically && async_) {flags.set_needs_post_return(true);}}diff --git a/crates/wasmtime/src/runtime/component/func/host.rs b/crates/wasmtime/src/runtime/component/func/host.rsindex 9c27afef8b..29de061653 100644--- a/crates/wasmtime/src/runtime/component/func/host.rs+++ b/crates/wasmtime/src/runtime/component/func/host.rs@@ -1,5 +1,7 @@//! Implementation of calling Rust-defined functions from components.+#[cfg(feature = "component-model-async")]+use crate::component::RuntimeInstance;#[cfg(feature = "component-model-async")]use crate::component::concurrent;#[cfg(feature = "component-model-async")]@@ -339,9 +341,14 @@ wherelet ret = match self.run(store.as_context_mut(), params) {HostResult::Done(result) => result?,#[cfg(feature = "component-model-async")]- HostResult::Future(future) => {- concurrent::poll_and_block(store.0, future, caller_instance)?- }+ HostResult::Future(future) => concurrent::poll_and_block(+ store.0,+ future,+ RuntimeInstance {+ instance: instance.id().instance(),+ index: caller_instance,+ },+ )?,};let mut lower = LowerContext::new(store, options, instance);diff --git a/crates/wasmtime/src/runtime/component/func/options.rs b/crates/wasmtime/src/runtime/component/func/options.rsindex 02a04df69a..55df5005cc 100644--- a/crates/wasmtime/src/runtime/component/func/options.rs+++ b/crates/wasmtime/src/runtime/component/func/options.rs@@ -2,12 +2,10 @@ use crate::StoreContextMut;use crate::component::concurrent::ConcurrentState;use crate::component::matching::InstanceType;use crate::component::resources::{HostResourceData, HostResourceIndex, HostResourceTables};-use crate::component::{Instance, ResourceType};+use crate::component::{Instance, ResourceType, RuntimeInstance};use crate::prelude::*;use crate::runtime::vm::VMFuncRef;-use crate::runtime::vm::component::{- CallContexts, ComponentInstance, HandleTable, InstanceFlags, ResourceTables,-};+use crate::runtime::vm::component::{CallContexts, ComponentInstance, HandleTable, ResourceTables};use crate::store::{StoreId, StoreOpaque};use alloc::sync::Arc;use core::pin::Pin;@@ -260,10 +258,10 @@ impl<'a, T: 'static> LowerContext<'a, T> {&mut self,rep: u32,dtor: Option<NonNull<VMFuncRef>>,- flags: Option<InstanceFlags>,+ instance: Option<RuntimeInstance>,) -> Result<HostResourceIndex> {self.resource_tables()- .host_resource_lower_own(rep, dtor, flags)+ .host_resource_lower_own(rep, dtor, instance)}/// Returns the underlying resource type for the `ty` table specified.@@ -422,10 +420,10 @@ impl<'a> LiftContext<'a> {&mut self,ty: TypeResourceTableIndex,idx: u32,- ) -> Result<(u32, Option<NonNull<VMFuncRef>>, Option<InstanceFlags>)> {+ ) -> Result<(u32, Option<NonNull<VMFuncRef>>, Option<RuntimeInstance>)> {let idx = self.resource_tables().guest_resource_lift_own(idx, ty)?;- let (dtor, flags) = self.instance.dtor_and_flags(ty);- Ok((idx, dtor, flags))+ let (dtor, instance) = self.instance.dtor_and_instance(ty);+ Ok((idx, dtor, instance))}/// Lifts a `borrow` resource from the guest at the `idx` specified.@@ -443,10 +441,10 @@ impl<'a> LiftContext<'a> {&mut self,rep: u32,dtor: Option<NonNull<VMFuncRef>>,- flags: Option<InstanceFlags>,+ instance: Option<RuntimeInstance>,) -> Result<HostResourceIndex> {self.resource_tables()- .host_resource_lower_own(rep, dtor, flags)+ .host_resource_lower_own(rep, dtor, instance)}/// Lowers a resource into the host-owned table, returning the index it wasdiff --git a/crates/wasmtime/src/runtime/component/mod.rs b/crates/wasmtime/src/runtime/component/mod.rsindex 38896e2e2a..a641c02d8d 100644--- a/crates/wasmtime/src/runtime/component/mod.rs+++ b/crates/wasmtime/src/runtime/component/mod.rs@@ -139,7 +139,7 @@ pub use self::values::Val;pub(crate) use self::instance::RuntimeImport;pub(crate) use self::resources::HostResourceData;-pub(crate) use self::store::ComponentInstanceId;+pub(crate) use self::store::{ComponentInstanceId, RuntimeInstance};// Re-export wasm_wave crate so the compatible version of this dep doesn't have to be// tracked separately from wasmtime.diff --git a/crates/wasmtime/src/runtime/component/resources/any.rs b/crates/wasmtime/src/runtime/component/resources/any.rsindex 343b331bcc..052c6ae5b4 100644--- a/crates/wasmtime/src/runtime/component/resources/any.rs+++ b/crates/wasmtime/src/runtime/component/resources/any.rs@@ -192,11 +192,9 @@ impl ResourceAny {// Note that this should be safe because the raw pointer access in// `flags` is valid due to `store` being the owner of the flags and// flags are never destroyed within the store.- if let Some(flags) = slot.flags {- unsafe {- if !flags.may_enter() {- bail!(Trap::CannotEnterComponent);- }+ if let Some(instance) = slot.instance {+ if !store.0.may_enter(instance) {+ bail!(Trap::CannotEnterComponent);}}diff --git a/crates/wasmtime/src/runtime/component/resources/host_tables.rs b/crates/wasmtime/src/runtime/component/resources/host_tables.rsindex a5e9656881..3ef7253897 100644--- a/crates/wasmtime/src/runtime/component/resources/host_tables.rs+++ b/crates/wasmtime/src/runtime/component/resources/host_tables.rs@@ -21,9 +21,8 @@//! the own is removed or otherwise taken out.use crate::prelude::*;-use crate::runtime::vm::component::{- InstanceFlags, ResourceTables, TypedResource, TypedResourceIndex,-};+use crate::runtime::component::RuntimeInstance;+use crate::runtime::vm::component::{ResourceTables, TypedResource, TypedResourceIndex};use crate::runtime::vm::{SendSyncPtr, VMFuncRef};use crate::store::StoreOpaque;use core::ptr::NonNull;@@ -69,7 +68,7 @@ pub struct HostResourceData {#[derive(Copy, Clone)]pub struct TableSlot {generation: u32,- pub(super) flags: Option<InstanceFlags>,+ pub(super) instance: Option<RuntimeInstance>,pub(super) dtor: Option<SendSyncPtr<VMFuncRef>>,}@@ -144,16 +143,16 @@ impl<'a> HostResourceTables<'a> {/// will point to the `rep` specified. The returned index is suitable for/// conversion into either [`Resource`] or [`ResourceAny`].///- /// The `dtor` and instance `flags` are specified as well to know what+ /// The `dtor` and instance `instance` are specified as well to know what/// destructor to run when this resource is destroyed.pub fn host_resource_lower_own(&mut self,rep: u32,dtor: Option<NonNull<VMFuncRef>>,- flags: Option<InstanceFlags>,+ instance: Option<RuntimeInstance>,) -> Result<HostResourceIndex> {let idx = self.tables.resource_lower_own(TypedResource::Host(rep))?;- Ok(self.new_host_index(idx, dtor, flags))+ Ok(self.new_host_index(idx, dtor, instance))}/// See [`HostResourceTables::host_resource_lower_own`].@@ -208,12 +207,12 @@ impl<'a> HostResourceTables<'a> {&mut self,idx: u32,dtor: Option<NonNull<VMFuncRef>>,- flags: Option<InstanceFlags>,+ instance: Option<RuntimeInstance>,) -> HostResourceIndex {let list = &mut self.host_resource_data.table_slot_metadata;let info = TableSlot {generation: self.host_resource_data.cur_generation,- flags,+ instance,dtor: dtor.map(SendSyncPtr::new),};match list.get_mut(idx as usize) {@@ -225,7 +224,7 @@ impl<'a> HostResourceTables<'a> {assert_eq!(idx, 1);list.push(TableSlot {generation: 0,- flags: None,+ instance: None,dtor: None,});}diff --git a/crates/wasmtime/src/runtime/component/store.rs b/crates/wasmtime/src/runtime/component/store.rsindex c24070c7ee..0b2d571aa5 100644--- a/crates/wasmtime/src/runtime/component/store.rs+++ b/crates/wasmtime/src/runtime/component/store.rs@@ -6,16 +6,36 @@ use crate::store::{StoreData, StoreId, StoreOpaque};use alloc::vec::Vec;use core::pin::Pin;use wasmtime_environ::PrimaryMap;+use wasmtime_environ::component::RuntimeComponentInstanceIndex;#[derive(Default)]pub struct ComponentStoreData {instances: PrimaryMap<ComponentInstanceId, Option<OwnedComponentInstance>>,++ /// Whether an instance belonging to this store has trapped.+ trapped: bool,}#[derive(Copy, Clone, Debug, PartialEq, Eq)]pub struct ComponentInstanceId(u32);wasmtime_environ::entity_impl!(ComponentInstanceId);+#[derive(Debug, Copy, Clone, PartialEq, Eq)]+pub struct RuntimeInstance {+ pub instance: ComponentInstanceId,+ pub index: RuntimeComponentInstanceIndex,+}++impl StoreOpaque {+ pub(crate) fn trapped(&self) -> bool {+ self.store_data().components.trapped+ }++ pub(crate) fn set_trapped(&mut self) {+ self.store_data_mut().components.trapped = true;+ }+}+impl StoreData {pub(crate) fn push_component_instance(&mut self,@@ -85,6 +105,14 @@ impl StoreOpaque {pub(crate) fn component_instance(&self, id: ComponentInstanceId) -> &ComponentInstance {self.store_data().component_instance(id)}++ #[cfg(feature = "component-model-async")]+ pub(crate) fn component_instance_mut(+ &mut self,+ id: ComponentInstanceId,+ ) -> Pin<&mut ComponentInstance> {+ self.store_data_mut().component_instance_mut(id)+ }}/// A type used to represent an allocated `ComponentInstance` located within adiff --git a/crates/wasmtime/src/runtime/func.rs b/crates/wasmtime/src/runtime/func.rsindex ae4ec58da3..dd347a11b5 100644--- a/crates/wasmtime/src/runtime/func.rs+++ b/crates/wasmtime/src/runtime/func.rs@@ -1510,6 +1510,10 @@ pub(crate) fn invoke_wasm_and_catch_traps<T>(return Err(trap);}let result = crate::runtime::vm::catch_traps(store, &mut previous_runtime_state, closure);+ #[cfg(feature = "component-model")]+ if result.is_err() {+ store.0.set_trapped();+ }core::mem::drop(previous_runtime_state);store.0.call_hook(CallHook::ReturningFromWasm)?;resultdiff --git a/crates/wasmtime/src/runtime/vm/component.rs b/crates/wasmtime/src/runtime/vm/component.rsindex 35feb448d6..89ebc4796e 100644--- a/crates/wasmtime/src/runtime/vm/component.rs+++ b/crates/wasmtime/src/runtime/vm/component.rs@@ -9,9 +9,9 @@use crate::Result;use crate::component::{Component, Instance, InstancePre, ResourceType, RuntimeImport};use crate::module::ModuleRegistry;-use crate::runtime::component::ComponentInstanceId;#[cfg(feature = "component-model-async")]use crate::runtime::component::concurrent::ConcurrentInstanceState;+use crate::runtime::component::{ComponentInstanceId, RuntimeInstance};use crate::runtime::vm::instance::{InstanceLayout, OwnedInstance, OwnedVMContext};use crate::runtime::vm::vmcontext::VMFunctionBody;use crate::runtime::vm::{@@ -700,7 +700,7 @@ impl ComponentInstance {// SAFETY: this is a valid initialization of all globals which are// 32-bit values.unsafe {- *def.as_i32_mut() = FLAG_MAY_ENTER | FLAG_MAY_LEAVE;+ *def.as_i32_mut() = FLAG_MAY_LEAVE;self.instance_flags(i).as_raw().write(def);}}@@ -880,18 +880,20 @@ impl ComponentInstance {////// This will lookup the origin definition of the `ty` table and return the/// destructor/flags for that.- pub fn dtor_and_flags(+ pub fn dtor_and_instance(&self,ty: TypeResourceTableIndex,- ) -> (Option<NonNull<VMFuncRef>>, Option<InstanceFlags>) {+ ) -> (Option<NonNull<VMFuncRef>>, Option<RuntimeInstance>) {let resource = self.component.types()[ty].unwrap_concrete_ty();let dtor = self.resource_destructor(resource);let component = self.component.env_component();- let flags = component.defined_resource_index(resource).map(|i| {- let instance = component.defined_resource_instances[i];- self.instance_flags(instance)- });- (dtor, flags)+ let instance = component+ .defined_resource_index(resource)+ .map(|i| RuntimeInstance {+ instance: self.id(),+ index: component.defined_resource_instances[i],+ });+ (dtor, instance)}/// Returns the store-local id that points to this component.@@ -1121,22 +1123,6 @@ impl InstanceFlags {}}- #[inline]- pub unsafe fn may_enter(&self) -> bool {- unsafe { *self.as_raw().as_ref().as_i32() & FLAG_MAY_ENTER != 0 }- }-- #[inline]- pub unsafe fn set_may_enter(&mut self, val: bool) {- unsafe {- if val {- *self.as_raw().as_mut().as_i32_mut() |= FLAG_MAY_ENTER;- } else {- *self.as_raw().as_mut().as_i32_mut() &= !FLAG_MAY_ENTER;- }- }- }-#[inline]pub unsafe fn needs_post_return(&self) -> bool {unsafe { *self.as_raw().as_ref().as_i32() & FLAG_NEEDS_POST_RETURN != 0 }diff --git a/crates/wasmtime/src/runtime/vm/component/libcalls.rs b/crates/wasmtime/src/runtime/vm/component/libcalls.rsindex ae3d18edb6..bb426e98e1 100644--- a/crates/wasmtime/src/runtime/vm/component/libcalls.rs+++ b/crates/wasmtime/src/runtime/vm/component/libcalls.rs@@ -5,7 +5,9 @@ use crate::component::Instance;use crate::component::concurrent::WaitResult;use crate::prelude::*;#[cfg(feature = "component-model-async")]-use crate::runtime::component::concurrent::{ResourcePair, RuntimeInstance};+use crate::runtime::component::RuntimeInstance;+#[cfg(feature = "component-model-async")]+use crate::runtime::component::concurrent::ResourcePair;use crate::runtime::vm::component::{ComponentInstance, VMComponentContext};use crate::runtime::vm::{HostResultHasUnwindSentinel, VMStore, VmSafe};use core::cell::Cell;diff --git a/crates/wit-bindgen/src/lib.rs b/crates/wit-bindgen/src/lib.rsindex 5fd35d7d9d..426768977f 100644--- a/crates/wit-bindgen/src/lib.rs+++ b/crates/wit-bindgen/src/lib.rs@@ -2636,7 +2636,7 @@ impl<'a> InterfaceGenerator<'a> {if flags.contains(FunctionFlags::STORE | FunctionFlags::ASYNC) {uwrite!(self.src,- "<T>(accessor: &{wt}::component::Accessor<T, Self>, "+ "<T: Send>(accessor: &{wt}::component::Accessor<T, Self>, ");} else if flags.contains(FunctionFlags::STORE) {uwrite!(self.src, "<T>(host: {wt}::component::Access<T, Self>, ");diff --git a/tests/all/component_model/func.rs b/tests/all/component_model/func.rsindex d0e8dc924f..f35a8a1e26 100644--- a/tests/all/component_model/func.rs+++ b/tests/all/component_model/func.rs@@ -183,8 +183,7 @@ fn integers() -> Result<()> {let engine = super::engine();let component = Component::new(&engine, component)?;let mut store = Store::new(&engine, ());- let new_instance = |store: &mut Store<()>| Linker::new(&engine).instantiate(store, &component);- let instance = new_instance(&mut store)?;+ let instance = Linker::new(&engine).instantiate(&mut store, &component)?;// Passing in 100 is valid for all primitivesinstance@@ -213,46 +212,62 @@ fn integers() -> Result<()> {.call_and_post_return(&mut store, (100,))?;// This specific wasm instance traps if any value other than 100 is passed- new_instance(&mut store)?- .get_typed_func::<(u8,), ()>(&mut store, "take-u8")?- .call(&mut store, (101,))- .unwrap_err()- .downcast::<Trap>()?;- new_instance(&mut store)?- .get_typed_func::<(i8,), ()>(&mut store, "take-s8")?- .call(&mut store, (101,))- .unwrap_err()- .downcast::<Trap>()?;- new_instance(&mut store)?- .get_typed_func::<(u16,), ()>(&mut store, "take-u16")?- .call(&mut store, (101,))- .unwrap_err()- .downcast::<Trap>()?;- new_instance(&mut store)?- .get_typed_func::<(i16,), ()>(&mut store, "take-s16")?- .call(&mut store, (101,))- .unwrap_err()- .downcast::<Trap>()?;- new_instance(&mut store)?- .get_typed_func::<(u32,), ()>(&mut store, "take-u32")?- .call(&mut store, (101,))- .unwrap_err()- .downcast::<Trap>()?;- new_instance(&mut store)?- .get_typed_func::<(i32,), ()>(&mut store, "take-s32")?- .call(&mut store, (101,))- .unwrap_err()- .downcast::<Trap>()?;- new_instance(&mut store)?- .get_typed_func::<(u64,), ()>(&mut store, "take-u64")?- .call(&mut store, (101,))- .unwrap_err()- .downcast::<Trap>()?;- new_instance(&mut store)?- .get_typed_func::<(i64,), ()>(&mut store, "take-s64")?- .call(&mut store, (101,))- .unwrap_err()- .downcast::<Trap>()?;+ with_new_instance(&engine, &component, |store, instance| {+ instance+ .get_typed_func::<(u8,), ()>(&mut *store, "take-u8")?+ .call(store, (101,))+ .unwrap_err()+ .downcast::<Trap>()+ })?;+ with_new_instance(&engine, &component, |store, instance| {+ instance+ .get_typed_func::<(i8,), ()>(&mut *store, "take-s8")?+ .call(store, (101,))+ .unwrap_err()+ .downcast::<Trap>()+ })?;+ with_new_instance(&engine, &component, |store, instance| {+ instance+ .get_typed_func::<(u16,), ()>(&mut *store, "take-u16")?+ .call(store, (101,))+ .unwrap_err()+ .downcast::<Trap>()+ })?;+ with_new_instance(&engine, &component, |store, instance| {+ instance+ .get_typed_func::<(i16,), ()>(&mut *store, "take-s16")?+ .call(store, (101,))+ .unwrap_err()+ .downcast::<Trap>()+ })?;+ with_new_instance(&engine, &component, |store, instance| {+ instance+ .get_typed_func::<(u32,), ()>(&mut *store, "take-u32")?+ .call(store, (101,))+ .unwrap_err()+ .downcast::<Trap>()+ })?;+ with_new_instance(&engine, &component, |store, instance| {+ instance+ .get_typed_func::<(i32,), ()>(&mut *store, "take-s32")?+ .call(store, (101,))+ .unwrap_err()+ .downcast::<Trap>()+ })?;+ with_new_instance(&engine, &component, |store, instance| {+ instance+ .get_typed_func::<(u64,), ()>(&mut *store, "take-u64")?+ .call(store, (101,))+ .unwrap_err()+ .downcast::<Trap>()+ })?;+ with_new_instance(&engine, &component, |store, instance| {+ instance+ .get_typed_func::<(i64,), ()>(&mut *store, "take-s64")?+ .call(store, (101,))+ .unwrap_err()+ .downcast::<Trap>()+ })?;// Zero can be returned as any integerassert_eq!(@@ -1991,35 +2006,39 @@ fn some_traps() -> Result<()> {let engine = super::engine();let component = Component::new(&engine, component)?;- let mut store = Store::new(&engine, ());- let instance = |store: &mut Store<()>| Linker::new(&engine).instantiate(store, &component);// This should fail when calling the allocator function for the argument- let err = instance(&mut store)?- .get_typed_func::<(&[u8],), ()>(&mut store, "take-list-unreachable")?- .call(&mut store, (&[],))- .unwrap_err()- .downcast::<Trap>()?;+ let err = with_new_instance(&engine, &component, |store, instance| {+ instance+ .get_typed_func::<(&[u8],), ()>(&mut *store, "take-list-unreachable")?+ .call(store, (&[],))+ .unwrap_err()+ .downcast::<Trap>()+ })?;assert_eq!(err, Trap::UnreachableCodeReached);// This should fail when calling the allocator function for the argument- let err = instance(&mut store)?- .get_typed_func::<(&str,), ()>(&mut store, "take-string-unreachable")?- .call(&mut store, ("",))- .unwrap_err()- .downcast::<Trap>()?;+ let err = with_new_instance(&engine, &component, |store, instance| {+ instance+ .get_typed_func::<(&str,), ()>(&mut *store, "take-string-unreachable")?+ .call(store, ("",))+ .unwrap_err()+ .downcast::<Trap>()+ })?;assert_eq!(err, Trap::UnreachableCodeReached);// This should fail when calling the allocator function for the space// to store the arguments (before arguments are even lowered)- let err = instance(&mut store)?- .get_typed_func::<(&str, &str, &str, &str, &str, &str, &str, &str, &str, &str), ()>(- &mut store,- "take-many-unreachable",- )?- .call(&mut store, ("", "", "", "", "", "", "", "", "", ""))- .unwrap_err()- .downcast::<Trap>()?;+ let err = with_new_instance(&engine, &component, |store, instance| {+ instance+ .get_typed_func::<(&str, &str, &str, &str, &str, &str, &str, &str, &str, &str), ()>(+ &mut *store,+ "take-many-unreachable",+ )?+ .call(store, ("", "", "", "", "", "", "", "", "", ""))+ .unwrap_err()+ .downcast::<Trap>()+ })?;assert_eq!(err, Trap::UnreachableCodeReached);// Assert that when the base pointer returned by malloc is out of bounds@@ -2036,87 +2055,115 @@ fn some_traps() -> Result<()> {"{err:?}",);}- let err = instance(&mut store)?- .get_typed_func::<(&[u8],), ()>(&mut store, "take-list-base-oob")?- .call(&mut store, (&[],))- .unwrap_err();+ let err = with_new_instance(&engine, &component, |store, instance| {+ instance+ .get_typed_func::<(&[u8],), ()>(&mut *store, "take-list-base-oob")?+ .call(store, (&[],))+ })+ .unwrap_err();assert_oob(&err);- let err = instance(&mut store)?- .get_typed_func::<(&[u8],), ()>(&mut store, "take-list-base-oob")?- .call(&mut store, (&[1],))- .unwrap_err();+ let err = with_new_instance(&engine, &component, |store, instance| {+ instance+ .get_typed_func::<(&[u8],), ()>(&mut *store, "take-list-base-oob")?+ .call(store, (&[1],))+ })+ .unwrap_err();assert_oob(&err);- let err = instance(&mut store)?- .get_typed_func::<(&str,), ()>(&mut store, "take-string-base-oob")?- .call(&mut store, ("",))- .unwrap_err();+ let err = with_new_instance(&engine, &component, |store, instance| {+ instance+ .get_typed_func::<(&str,), ()>(&mut *store, "take-string-base-oob")?+ .call(store, ("",))+ })+ .unwrap_err();assert_oob(&err);- let err = instance(&mut store)?- .get_typed_func::<(&str,), ()>(&mut store, "take-string-base-oob")?- .call(&mut store, ("x",))- .unwrap_err();+ let err = with_new_instance(&engine, &component, |store, instance| {+ instance+ .get_typed_func::<(&str,), ()>(&mut *store, "take-string-base-oob")?+ .call(store, ("x",))+ })+ .unwrap_err();assert_oob(&err);- let err = instance(&mut store)?- .get_typed_func::<(&str, &str, &str, &str, &str, &str, &str, &str, &str, &str), ()>(- &mut store,- "take-many-base-oob",- )?- .call(&mut store, ("", "", "", "", "", "", "", "", "", ""))- .unwrap_err();+ let err = with_new_instance(&engine, &component, |store, instance| {+ instance+ .get_typed_func::<(&str, &str, &str, &str, &str, &str, &str, &str, &str, &str), ()>(+ &mut *store,+ "take-many-base-oob",+ )?+ .call(store, ("", "", "", "", "", "", "", "", "", ""))+ })+ .unwrap_err();assert_oob(&err);// Test here that when the returned pointer from malloc is one byte from the// end of memory that empty things are fine, but larger things are not.- instance(&mut store)?- .get_typed_func::<(&[u8],), ()>(&mut store, "take-list-end-oob")?- .call_and_post_return(&mut store, (&[],))?;- instance(&mut store)?- .get_typed_func::<(&[u8],), ()>(&mut store, "take-list-end-oob")?- .call_and_post_return(&mut store, (&[1, 2, 3, 4],))?;- let err = instance(&mut store)?- .get_typed_func::<(&[u8],), ()>(&mut store, "take-list-end-oob")?- .call(&mut store, (&[1, 2, 3, 4, 5],))- .unwrap_err();+ with_new_instance(&engine, &component, |store, instance| {+ instance+ .get_typed_func::<(&[u8],), ()>(&mut *store, "take-list-end-oob")?+ .call_and_post_return(store, (&[],))+ })?;+ with_new_instance(&engine, &component, |store, instance| {+ instance+ .get_typed_func::<(&[u8],), ()>(&mut *store, "take-list-end-oob")?+ .call_and_post_return(store, (&[1, 2, 3, 4],))+ })?;+ let err = with_new_instance(&engine, &component, |store, instance| {+ instance+ .get_typed_func::<(&[u8],), ()>(&mut *store, "take-list-end-oob")?+ .call(store, (&[1, 2, 3, 4, 5],))+ })+ .unwrap_err();assert_oob(&err);- instance(&mut store)?- .get_typed_func::<(&str,), ()>(&mut store, "take-string-end-oob")?- .call_and_post_return(&mut store, ("",))?;- instance(&mut store)?- .get_typed_func::<(&str,), ()>(&mut store, "take-string-end-oob")?- .call_and_post_return(&mut store, ("abcd",))?;- let err = instance(&mut store)?- .get_typed_func::<(&str,), ()>(&mut store, "take-string-end-oob")?- .call(&mut store, ("abcde",))- .unwrap_err();+ with_new_instance(&engine, &component, |store, instance| {+ instance+ .get_typed_func::<(&str,), ()>(&mut *store, "take-string-end-oob")?+ .call_and_post_return(store, ("",))+ })?;+ with_new_instance(&engine, &component, |store, instance| {+ instance+ .get_typed_func::<(&str,), ()>(&mut *store, "take-string-end-oob")?+ .call_and_post_return(store, ("abcd",))+ })?;+ let err = with_new_instance(&engine, &component, |store, instance| {+ instance+ .get_typed_func::<(&str,), ()>(&mut *store, "take-string-end-oob")?+ .call(store, ("abcde",))+ })+ .unwrap_err();assert_oob(&err);- let err = instance(&mut store)?- .get_typed_func::<(&str, &str, &str, &str, &str, &str, &str, &str, &str, &str), ()>(- &mut store,- "take-many-end-oob",- )?- .call(&mut store, ("", "", "", "", "", "", "", "", "", ""))- .unwrap_err();+ let err = with_new_instance(&engine, &component, |store, instance| {+ instance+ .get_typed_func::<(&str, &str, &str, &str, &str, &str, &str, &str, &str, &str), ()>(+ &mut *store,+ "take-many-end-oob",+ )?+ .call(store, ("", "", "", "", "", "", "", "", "", ""))+ })+ .unwrap_err();assert_oob(&err);// For this function the first allocation, the space to store all the// arguments, is in-bounds but then all further allocations, such as for// each individual string, are all out of bounds.- let err = instance(&mut store)?- .get_typed_func::<(&str, &str, &str, &str, &str, &str, &str, &str, &str, &str), ()>(- &mut store,- "take-many-second-oob",- )?- .call(&mut store, ("", "", "", "", "", "", "", "", "", ""))- .unwrap_err();+ let err = with_new_instance(&engine, &component, |store, instance| {+ instance+ .get_typed_func::<(&str, &str, &str, &str, &str, &str, &str, &str, &str, &str), ()>(+ &mut *store,+ "take-many-second-oob",+ )?+ .call(store, ("", "", "", "", "", "", "", "", "", ""))+ })+ .unwrap_err();assert_oob(&err);- let err = instance(&mut store)?- .get_typed_func::<(&str, &str, &str, &str, &str, &str, &str, &str, &str, &str), ()>(- &mut store,- "take-many-second-oob",- )?- .call(&mut store, ("", "", "", "", "", "", "", "", "", "x"))- .unwrap_err();+ let err = with_new_instance(&engine, &component, |store, instance| {+ instance+ .get_typed_func::<(&str, &str, &str, &str, &str, &str, &str, &str, &str, &str), ()>(+ &mut *store,+ "take-many-second-oob",+ )?+ .call(store, ("", "", "", "", "", "", "", "", "", "x"))+ })+ .unwrap_err();assert_oob(&err);Ok(())}@@ -3223,24 +3270,39 @@ fn errors_that_poison_instance() -> Result<()> {let engine = super::engine();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 f1 = instance.get_typed_func::<(), ()>(&mut store, "f1")?;- let f2 = instance.get_typed_func::<(), ()>(&mut store, "f2")?;- assert_unreachable(f1.call(&mut store, ()));- assert_poisoned(f1.call(&mut store, ()));- assert_poisoned(f2.call(&mut store, ()));- let instance = linker.instantiate(&mut store, &component)?;- let f3 = instance.get_typed_func::<(&str,), ()>(&mut store, "f3")?;- assert_unreachable(f3.call(&mut store, ("x",)));- assert_poisoned(f3.call(&mut store, ("x",)));+ {+ let mut store = Store::new(&engine, ());+ let instance = linker.instantiate(&mut store, &component)?;+ let f1 = instance.get_typed_func::<(), ()>(&mut store, "f1")?;+ let f2 = instance.get_typed_func::<(), ()>(&mut store, "f2")?;+ assert_unreachable(f1.call(&mut store, ()));+ assert_poisoned(f1.call(&mut store, ()));+ assert_poisoned(f2.call(&mut store, ()));+ }- let instance = linker.instantiate(&mut store, &component)?;- let f4 = instance.get_typed_func::<(), (WasmStr,)>(&mut store, "f4")?;- assert!(f4.call(&mut store, ()).is_err());- assert_poisoned(f4.call(&mut store, ()));+ {+ let mut store = Store::new(&engine, ());+ let instance = linker.instantiate(&mut store, &component)?;+ let f3 = instance.get_typed_func::<(&str,), ()>(&mut store, "f3")?;+ assert_unreachable(f3.call(&mut store, ("x",)));+ assert_poisoned(f3.call(&mut store, ("x",)));++ // Since we actually poison the store, even an unrelated instance will+ // be considered poisoned:+ let instance = linker.instantiate(&mut store, &component)?;+ let f3 = instance.get_typed_func::<(&str,), ()>(&mut store, "f3")?;+ assert_poisoned(f3.call(&mut store, ("x",)));+ }++ {+ let mut store = Store::new(&engine, ());+ let instance = linker.instantiate(&mut store, &component)?;+ let f4 = instance.get_typed_func::<(), (WasmStr,)>(&mut store, "f4")?;+ assert!(f4.call(&mut store, ()).is_err());+ assert_poisoned(f4.call(&mut store, ()));+ }return Ok(());@@ -3316,3 +3378,98 @@ fn run_export_with_internal_adapter() -> Result<()> {assert_eq!(run.call(&mut store, ())?, (5,));Ok(())}++enum RecurseKind {+ AThenA,+ AThenB,+ AThenBThenA,+}++#[test]+fn recurse() -> Result<()> {+ test_recurse(RecurseKind::AThenB)+}++#[test]+fn recurse_trap() -> Result<()> {+ let error = test_recurse(RecurseKind::AThenA).unwrap_err();++ assert_eq!(error.downcast::<Trap>()?, Trap::CannotEnterComponent);++ Ok(())+}++#[test]+fn recurse_more_trap() -> Result<()> {+ let error = test_recurse(RecurseKind::AThenBThenA).unwrap_err();++ assert_eq!(error.downcast::<Trap>()?, Trap::CannotEnterComponent);++ Ok(())+}++fn test_recurse(kind: RecurseKind) -> Result<()> {+ #[derive(Default)]+ struct Ctx {+ instances: Vec<Arc<Instance>>,+ }++ let component = r#"+(component+ (import "import" (func $import))+ (core func $import (canon lower (func $import)))+ (core module $m+ (func $import (import "" "import"))+ (func (export "export") call $import)+ )+ (core instance $m (instantiate $m (with "" (instance+ (export "import" (func $import))+ ))))+ (func (export "export") (canon lift (core func $m "export")))+)+"#;+ let engine = super::engine();+ let component = Component::new(&engine, component)?;+ let mut store = Store::new(&engine, Ctx::default());+ let mut linker = Linker::<Ctx>::new(&engine);+ linker.root().func_wrap("import", |mut store, (): ()| {+ if let Some(instance) = store.data_mut().instances.pop() {+ let run = instance.get_typed_func::<(), ()>(&mut store, "export")?;+ run.call(&mut store, ())?;+ store.data_mut().instances.push(instance);+ }+ Ok(())+ })?;+ let instance = Arc::new(linker.instantiate(&mut store, &component)?);+ let instance = match kind {+ RecurseKind::AThenA => {+ store.data_mut().instances.push(instance.clone());+ instance+ }+ RecurseKind::AThenB => {+ let other = Arc::new(linker.instantiate(&mut store, &component)?);+ store.data_mut().instances.push(other);+ instance+ }+ RecurseKind::AThenBThenA => {+ store.data_mut().instances.push(instance.clone());+ let other = Arc::new(linker.instantiate(&mut store, &component)?);+ store.data_mut().instances.push(other);+ instance+ }+ };++ let run = instance.get_typed_func::<(), ()>(&mut store, "export")?;+ run.call(&mut store, ())?;+ Ok(())+}++fn with_new_instance<T>(+ engine: &Engine,+ component: &Component,+ fun: impl Fn(&mut Store<()>, Instance) -> wasmtime::Result<T>,+) -> wasmtime::Result<T> {+ let mut store = Store::new(engine, ());+ let instance = Linker::new(engine).instantiate(&mut store, component)?;+ fun(&mut store, instance)+}diff --git a/tests/all/component_model/import.rs b/tests/all/component_model/import.rsindex 3ab9c50d81..b83e0cd95d 100644--- a/tests/all/component_model/import.rs+++ b/tests/all/component_model/import.rs@@ -348,55 +348,63 @@ fn attempt_to_leave_during_malloc() -> Result<()> {Ok(("hello".to_string(),))})?;let component = Component::new(&engine, component)?;- let mut store = Store::new(&engine, ());- // Assert that during a host import if we return values to wasm that a trap- // happens if we try to leave the instance.- let trap = linker- .instantiate(&mut store, &component)?- .get_typed_func::<(), ()>(&mut store, "run")?- .call(&mut store, ())- .unwrap_err();- assert!(- format!("{trap:?}").contains("cannot leave component instance"),- "bad trap: {trap:?}",- );+ {+ let mut store = Store::new(&engine, ());++ // Assert that during a host import if we return values to wasm that a trap+ // happens if we try to leave the instance.+ let trap = linker+ .instantiate(&mut store, &component)?+ .get_typed_func::<(), ()>(&mut store, "run")?+ .call(&mut store, ())+ .unwrap_err();+ assert!(+ format!("{trap:?}").contains("cannot leave component instance"),+ "bad trap: {trap:?}",+ );++ let trace = trap.downcast_ref::<WasmBacktrace>().unwrap().frames();+ assert_eq!(trace.len(), 4);++ // This was our entry point...+ assert_eq!(trace[3].module().name(), Some("m"));+ assert_eq!(trace[3].func_name(), Some("run"));++ // ... which called an imported function which ends up being originally+ // defined by the shim instance. The shim instance then does an indirect+ // call through a table which goes to the `canon.lower`'d host function+ assert_eq!(trace[2].module().name(), Some("host_shim"));+ assert_eq!(trace[2].func_name(), Some("shim_ret_string"));++ // ... and the lowered host function will call realloc to allocate space for+ // the result+ assert_eq!(trace[1].module().name(), Some("m"));+ assert_eq!(trace[1].func_name(), Some("realloc"));++ // ... but realloc calls the shim instance and tries to exit the+ // component, triggering a dynamic trap+ assert_eq!(trace[0].module().name(), Some("host_shim"));+ assert_eq!(trace[0].func_name(), Some("shim_thunk"));+ }++ {+ let mut store = Store::new(&engine, ());++ // In addition to the above trap also ensure that when we enter a wasm+ // component if we try to leave while lowering then that's also a dynamic+ // trap.+ let trap = linker+ .instantiate(&mut store, &component)?+ .get_typed_func::<(&str,), ()>(&mut store, "take-string")?+ .call(&mut store, ("x",))+ .unwrap_err();+ assert!(+ format!("{trap:?}").contains("cannot leave component instance"),+ "bad trap: {trap:?}",+ );+ }- let trace = trap.downcast_ref::<WasmBacktrace>().unwrap().frames();- assert_eq!(trace.len(), 4);-- // This was our entry point...- assert_eq!(trace[3].module().name(), Some("m"));- assert_eq!(trace[3].func_name(), Some("run"));-- // ... which called an imported function which ends up being originally- // defined by the shim instance. The shim instance then does an indirect- // call through a table which goes to the `canon.lower`'d host function- assert_eq!(trace[2].module().name(), Some("host_shim"));- assert_eq!(trace[2].func_name(), Some("shim_ret_string"));-- // ... and the lowered host function will call realloc to allocate space for- // the result- assert_eq!(trace[1].module().name(), Some("m"));- assert_eq!(trace[1].func_name(), Some("realloc"));-- // ... but realloc calls the shim instance and tries to exit the- // component, triggering a dynamic trap- assert_eq!(trace[0].module().name(), Some("host_shim"));- assert_eq!(trace[0].func_name(), Some("shim_thunk"));-- // In addition to the above trap also ensure that when we enter a wasm- // component if we try to leave while lowering then that's also a dynamic- // trap.- let trap = linker- .instantiate(&mut store, &component)?- .get_typed_func::<(&str,), ()>(&mut store, "take-string")?- .call(&mut store, ("x",))- .unwrap_err();- assert!(- format!("{trap:?}").contains("cannot leave component instance"),- "bad trap: {trap:?}",- );Ok(())}@@ -1048,28 +1056,34 @@ fn bad_import_alignment() -> Result<()> {-> Result<()> { unreachable!() },)?;let component = Component::new(&engine, component)?;- let mut store = Store::new(&engine, ());- let trap = linker- .instantiate(&mut store, &component)?- .get_typed_func::<(), ()>(&mut store, "unaligned-retptr2")?- .call(&mut store, ())- .unwrap_err();- assert!(- format!("{trap:?}").contains("pointer not aligned"),- "{}",- trap- );- let trap = linker- .instantiate(&mut store, &component)?- .get_typed_func::<(), ()>(&mut store, "unaligned-argptr2")?- .call(&mut store, ())- .unwrap_err();- assert!(- format!("{trap:?}").contains("pointer not aligned"),- "{}",- trap- );+ {+ let mut store = Store::new(&engine, ());+ let trap = linker+ .instantiate(&mut store, &component)?+ .get_typed_func::<(), ()>(&mut store, "unaligned-retptr2")?+ .call(&mut store, ())+ .unwrap_err();+ assert!(+ format!("{trap:?}").contains("pointer not aligned"),+ "{}",+ trap+ );+ }++ {+ let mut store = Store::new(&engine, ());+ let trap = linker+ .instantiate(&mut store, &component)?+ .get_typed_func::<(), ()>(&mut store, "unaligned-argptr2")?+ .call(&mut store, ())+ .unwrap_err();+ assert!(+ format!("{trap:?}").contains("pointer not aligned"),+ "{}",+ trap+ );+ }Ok(())}diff --git a/tests/all/component_model/strings.rs b/tests/all/component_model/strings.rsindex 3caabf4325..ce60ea10fd 100644--- a/tests/all/component_model/strings.rs+++ b/tests/all/component_model/strings.rs@@ -314,10 +314,10 @@ fn test_ptr_overflow(engine: &Engine, src: &str, dst: &str) -> Result<()> {);let component = Component::new(engine, &component)?;- let mut store = Store::new(engine, ());- let mut test_overflow = |size: u32| -> Result<()> {+ let test_overflow = |size: u32| -> Result<()> {println!("src={src} dst={dst} size={size:#x}");+ let mut store = Store::new(engine, ());let instance = Linker::new(engine).instantiate(&mut store, &component)?;let func = instance.get_typed_func::<(u32,), ()>(&mut store, "f")?;let trap = funcdiff --git a/tests/component-model b/tests/component-modelindex 48603cbc04..ac37fe92a2 160000--- a/tests/component-model+++ b/tests/component-model@@ -1 +1 @@-Subproject commit 48603cbc04dbb3e69cefba5b259941876459fb8d+Subproject commit ac37fe92a21865aa8ca84b5bcbeb2da3746b6dc8diff --git a/tests/disas/component-model/direct-adapter-calls-inlining.wat b/tests/disas/component-model/direct-adapter-calls-inlining.watindex 6c8f4fb6d8..5ebe6f42ab 100644--- a/tests/disas/component-model/direct-adapter-calls-inlining.wat+++ b/tests/disas/component-model/direct-adapter-calls-inlining.wat@@ -64,8 +64,8 @@;; 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+96-;; gv10 = load.i64 notrap aligned readonly can_move gv7+144+;; 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@@ -91,74 +91,51 @@;; brif v18, block4, block5;;;; block4:-;; v92 = load.i64 notrap aligned readonly can_move v5+72-;; v93 = load.i64 notrap aligned readonly can_move v5+88-;; v19 = iconst.i32 24-;; call_indirect sig1, v92(v93, v5, v19) ; v19 = 24+;; v21 = load.i64 notrap aligned readonly can_move v5+72+;; v20 = load.i64 notrap aligned readonly can_move v5+88+;; v19 = iconst.i32 23+;; call_indirect sig1, v21(v20, v5, v19) ; v19 = 23;; trap user11;;;; block5:-;; v22 = load.i64 notrap aligned readonly can_move v5+96+;; v22 = load.i64 notrap aligned readonly can_move v5+144;; v23 = load.i32 notrap aligned table v22-;; v24 = iconst.i32 2-;; v25 = band v23, v24 ; v24 = 2-;; v81 = iconst.i32 0-;; v82 = icmp eq v25, v81 ; v81 = 0-;; v28 = uextend.i32 v82-;; brif v28, block6, block7+;; 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+;; jump block6;;;; block6:-;; v21 = load.i64 notrap aligned readonly can_move v5+72-;; v20 = load.i64 notrap aligned readonly can_move v5+88-;; v29 = iconst.i32 18-;; call_indirect sig1, v21(v20, v5, v29) ; v29 = 18-;; trap user11+;; jump block7;;;; block7:-;; v34 = iconst.i32 -3-;; v35 = band.i32 v23, v34 ; v34 = -3-;; store notrap aligned table v35, v22-;; v37 = load.i64 notrap aligned readonly can_move v5+144-;; v38 = load.i32 notrap aligned table v37-;; v83 = iconst.i32 0-;; store notrap aligned table v83, v37 ; v83 = 0-;; v42 = load.i32 notrap aligned table v22-;; v43 = iconst.i32 -2-;; v44 = band v42, v43 ; v43 = -2-;; store notrap aligned table v44, v22-;; v84 = iconst.i32 1-;; v85 = bor v42, v84 ; v84 = 1-;; store notrap aligned table v85, v22;; jump block8;;;; block8:-;; jump block9-;;-;; block9:-;; jump block10-;;-;; block10:-;; v55 = load.i32 notrap aligned table v12-;; v86 = iconst.i32 -2-;; v87 = band v55, v86 ; v86 = -2-;; store notrap aligned table v87, v12-;; v88 = iconst.i32 1-;; v89 = bor v55, v88 ; v88 = 1-;; store notrap aligned table v89, v12-;; v65 = load.i32 notrap aligned table v22-;; v90 = iconst.i32 2-;; v91 = bor v65, v90 ; v90 = 2-;; store notrap aligned table v91, v22-;; store.i32 notrap aligned table v38, v37+;; 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;; jump block3;;;; block3:-;; jump block11+;; jump block9;;-;; block11:+;; block9:;; @00f0 jump block1;;;; block1:-;; v72 = iconst.i32 1276-;; @00f0 return v72 ; v72 = 1276+;; v52 = iconst.i32 1276+;; @00f0 return v52 ; v52 = 1276;; }diff --git a/tests/disas/component-model/direct-adapter-calls-x64.wat b/tests/disas/component-model/direct-adapter-calls-x64.watindex e1ef652561..d6d1684ba1 100644--- a/tests/disas/component-model/direct-adapter-calls-x64.wat+++ b/tests/disas/component-model/direct-adapter-calls-x64.wat@@ -87,61 +87,47 @@;; movq 0x10(%r10), %r10;; addq $0x30, %r10;; cmpq %rsp, %r10-;; ja 0x14e+;; ja 0x113;; 79: subq $0x20, %rsp;; movq %rbx, (%rsp);; movq %r12, 8(%rsp);; movq %r14, 0x10(%rsp)-;; movq %r15, 0x18(%rsp)-;; movq 0x78(%rdi), %r12-;; movl (%r12), %r8d-;; testl $1, %r8d-;; je 0x13a-;; a5: movq 0x60(%rdi), %rbx-;; movl (%rbx), %r9d-;; testl $2, %r9d-;; je 0x126-;; b9: andl $0xfffffffd, %r9d-;; movl %r9d, (%rbx)-;; movq 0x90(%rdi), %r14-;; movq %rdi, %r10-;; movl (%r14), %r15d-;; movl $0, (%r14)-;; movl (%rbx), %esi-;; movq %rsi, %rax-;; andl $0xfffffffe, %eax-;; movl %eax, (%rbx)-;; orl $1, %esi-;; movl %esi, (%rbx)-;; movq 0x40(%r10), %rdi-;; movq %r10, %rsi+;; 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;; callq 0-;; movl (%r12), %ecx-;; movq %rcx, %rdx-;; andl $0xfffffffe, %edx-;; movl %edx, (%r12)+;; movl (%r14), %ecx+;; movq %rcx, %r8+;; andl $0xfffffffe, %r8d+;; movl %r8d, (%r14);; orl $1, %ecx-;; movl %ecx, (%r12)-;; orl $2, (%rbx)-;; movl %r15d, (%r14)+;; movl %ecx, (%r14)+;; movl %r12d, (%rbx);; movq (%rsp), %rbx;; movq 8(%rsp), %r12;; movq 0x10(%rsp), %r14-;; movq 0x18(%rsp), %r15;; addq $0x20, %rsp;; movq %rbp, %rsp;; popq %rbp;; retq-;; 126: movq %rdi, %rsi-;; 129: movq 0x48(%rsi), %rax-;; 12d: movq 0x58(%rsi), %rdi-;; 131: movl $0x12, %edx-;; 136: callq *%rax-;; 138: ud2-;; 13a: movq %rdi, %rsi-;; 13d: movq 0x48(%rsi), %rcx-;; 141: movq 0x58(%rsi), %rdi-;; 145: movl $0x18, %edx-;; 14a: callq *%rcx-;; 14c: ud2-;; 14e: ud2+;; ff: movq %rdi, %rsi+;; 102: movq 0x48(%rsi), %rax+;; 106: movq 0x58(%rsi), %rdi+;; 10a: movl $0x17, %edx+;; 10f: callq *%rax+;; 111: ud2+;; 113: ud2diff --git a/tests/disas/component-model/direct-adapter-calls.wat b/tests/disas/component-model/direct-adapter-calls.watindex ef9478ab57..26d94affea 100644--- a/tests/disas/component-model/direct-adapter-calls.wat+++ b/tests/disas/component-model/direct-adapter-calls.wat@@ -97,8 +97,8 @@;; 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+96-;; gv6 = load.i64 notrap aligned readonly can_move gv3+144+;; gv5 = load.i64 notrap aligned readonly can_move gv3+144+;; gv6 = 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@@ -115,58 +115,35 @@;; @0098 brif v10, block2, block3;;;; block2:-;; v94 = load.i64 notrap aligned readonly can_move v0+72-;; v95 = load.i64 notrap aligned readonly can_move v0+88-;; @009a v11 = iconst.i32 24-;; @009c call_indirect sig0, v94(v95, v0, v11) ; v11 = 24+;; @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;;;; block3:-;; @00a0 v15 = load.i64 notrap aligned readonly can_move v0+96+;; @00a0 v15 = load.i64 notrap aligned readonly can_move v0+144;; @00a0 v16 = load.i32 notrap aligned table v15-;; @00a2 v17 = iconst.i32 2-;; @00a4 v18 = band v16, v17 ; v17 = 2-;; v86 = iconst.i32 0-;; v87 = icmp eq v18, v86 ; v86 = 0-;; @00a5 v20 = uextend.i32 v87-;; @00a6 brif v20, block4, block5-;;-;; block4:-;; @009c v14 = load.i64 notrap aligned readonly can_move v0+72-;; @009c v13 = load.i64 notrap aligned readonly can_move v0+88-;; @00a8 v21 = iconst.i32 18-;; @00aa call_indirect sig0, v14(v13, v0, v21) ; v21 = 18-;; @00ac trap user11-;;-;; block5:-;; @00b0 v27 = iconst.i32 -3-;; @00b2 v28 = band.i32 v16, v27 ; v27 = -3-;; @00b3 store notrap aligned table v28, v15-;; @00b5 v30 = load.i64 notrap aligned readonly can_move v0+144-;; @00b5 v31 = load.i32 notrap aligned table v30-;; v88 = iconst.i32 0-;; @00bb store notrap aligned table v88, v30 ; v88 = 0-;; @00bd v35 = load.i32 notrap aligned table v15-;; @00bf v36 = iconst.i32 -2-;; @00c1 v37 = band v35, v36 ; v36 = -2-;; @00c2 store notrap aligned table v37, v15-;; v89 = iconst.i32 1-;; v90 = bor v35, v89 ; v89 = 1-;; @00cb store notrap aligned table v90, v15-;; @00cd v45 = load.i64 notrap aligned readonly can_move v0+64-;; @00cd v46 = call fn0(v45, v0, v2)-;; @00d1 v48 = load.i32 notrap aligned table v5-;; @00d5 v50 = band v48, v36 ; v36 = -2-;; @00d6 store notrap aligned table v50, v5-;; v91 = bor v48, v89 ; v89 = 1-;; @00df store notrap aligned table v91, v5-;; @00e1 v58 = load.i32 notrap aligned table v15-;; v92 = iconst.i32 2-;; v93 = bor v58, v92 ; v92 = 2-;; @00e6 store notrap aligned table v93, v15-;; @00ea store notrap aligned table v31, v30-;; @00ec jump block1+;; 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;;;; block1:-;; @00ec return v46+;; @00d0 return v31;; }diff --git a/tests/disas/gc/drc/array-fill.wat b/tests/disas/gc/drc/array-fill.watindex c29a4de194..f11bbf3235 100644--- a/tests/disas/gc/drc/array-fill.wat+++ b/tests/disas/gc/drc/array-fill.wat@@ -20,7 +20,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i64, v5: i32):-;; @0027 trapz v2, user16+;; @0027 trapz v2, user15;; @0027 v41 = load.i64 notrap aligned readonly can_move v0+8;; @0027 v7 = load.i64 notrap aligned readonly can_move v41+24;; @0027 v6 = uextend.i64 v2@@ -28,9 +28,9 @@;; @0027 v9 = iconst.i64 24;; @0027 v10 = iadd v8, v9 ; v9 = 24;; @0027 v11 = load.i32 notrap aligned readonly v10-;; @0027 v12 = uadd_overflow_trap v3, v5, user17+;; @0027 v12 = uadd_overflow_trap v3, v5, user16;; @0027 v13 = icmp ugt v12, v11-;; @0027 trapnz v13, user17+;; @0027 trapnz v13, user16;; @0027 v15 = uextend.i64 v11;; v43 = iconst.i64 3;; v44 = ishl v15, v43 ; v43 = 3diff --git a/tests/disas/gc/drc/array-get-s.wat b/tests/disas/gc/drc/array-get-s.watindex 65a77207b1..5183060689 100644--- a/tests/disas/gc/drc/array-get-s.wat+++ b/tests/disas/gc/drc/array-get-s.wat@@ -20,7 +20,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32, v3: i32):-;; @0022 trapz v2, user16+;; @0022 trapz v2, user15;; @0022 v34 = load.i64 notrap aligned readonly can_move v0+8;; @0022 v6 = load.i64 notrap aligned readonly can_move v34+24;; @0022 v5 = uextend.i64 v2@@ -29,7 +29,7 @@;; @0022 v9 = iadd v7, v8 ; v8 = 24;; @0022 v10 = load.i32 notrap aligned readonly v9;; @0022 v11 = icmp ult v3, v10-;; @0022 trapz v11, user17+;; @0022 trapz v11, user16;; @0022 v13 = uextend.i64 v10;; v33 = iconst.i64 32;; @0022 v15 = ushr v13, v33 ; v33 = 32diff --git a/tests/disas/gc/drc/array-get-u.wat b/tests/disas/gc/drc/array-get-u.watindex 6d8a36878e..8c9ce0a979 100644--- a/tests/disas/gc/drc/array-get-u.wat+++ b/tests/disas/gc/drc/array-get-u.wat@@ -20,7 +20,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32, v3: i32):-;; @0022 trapz v2, user16+;; @0022 trapz v2, user15;; @0022 v34 = load.i64 notrap aligned readonly can_move v0+8;; @0022 v6 = load.i64 notrap aligned readonly can_move v34+24;; @0022 v5 = uextend.i64 v2@@ -29,7 +29,7 @@;; @0022 v9 = iadd v7, v8 ; v8 = 24;; @0022 v10 = load.i32 notrap aligned readonly v9;; @0022 v11 = icmp ult v3, v10-;; @0022 trapz v11, user17+;; @0022 trapz v11, user16;; @0022 v13 = uextend.i64 v10;; v33 = iconst.i64 32;; @0022 v15 = ushr v13, v33 ; v33 = 32diff --git a/tests/disas/gc/drc/array-get.wat b/tests/disas/gc/drc/array-get.watindex 306faaf2af..8aaf3770c3 100644--- a/tests/disas/gc/drc/array-get.wat+++ b/tests/disas/gc/drc/array-get.wat@@ -20,7 +20,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32, v3: i32):-;; @0022 trapz v2, user16+;; @0022 trapz v2, user15;; @0022 v33 = load.i64 notrap aligned readonly can_move v0+8;; @0022 v6 = load.i64 notrap aligned readonly can_move v33+24;; @0022 v5 = uextend.i64 v2@@ -29,7 +29,7 @@;; @0022 v9 = iadd v7, v8 ; v8 = 24;; @0022 v10 = load.i32 notrap aligned readonly v9;; @0022 v11 = icmp ult v3, v10-;; @0022 trapz v11, user17+;; @0022 trapz v11, user16;; @0022 v13 = uextend.i64 v10;; v35 = iconst.i64 3;; v36 = ishl v13, v35 ; v35 = 3diff --git a/tests/disas/gc/drc/array-len.wat b/tests/disas/gc/drc/array-len.watindex 58f5357213..444db28ad6 100644--- a/tests/disas/gc/drc/array-len.wat+++ b/tests/disas/gc/drc/array-len.wat@@ -20,7 +20,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32):-;; @001f trapz v2, user16+;; @001f trapz v2, user15;; @001f v10 = load.i64 notrap aligned readonly can_move v0+8;; @001f v5 = load.i64 notrap aligned readonly can_move v10+24;; @001f v4 = uextend.i64 v2diff --git a/tests/disas/gc/drc/array-new.wat b/tests/disas/gc/drc/array-new.watindex f2edee849f..fd30585c07 100644--- a/tests/disas/gc/drc/array-new.wat+++ b/tests/disas/gc/drc/array-new.wat@@ -26,11 +26,11 @@;; v36 = ishl v6, v35 ; v35 = 3;; v33 = iconst.i64 32;; @0022 v8 = ushr v36, v33 ; v33 = 32-;; @0022 trapnz v8, user18+;; @0022 trapnz v8, user17;; @0022 v5 = iconst.i32 32;; v42 = iconst.i32 3;; v43 = ishl v3, v42 ; v42 = 3-;; @0022 v10 = uadd_overflow_trap v5, v43, user18 ; v5 = 32+;; @0022 v10 = uadd_overflow_trap v5, v43, user17 ; v5 = 32;; @0022 v12 = iconst.i32 -1476395008;; @0022 v13 = iconst.i32 0;; v40 = iconst.i32 8diff --git a/tests/disas/gc/drc/array-set.wat b/tests/disas/gc/drc/array-set.watindex b053ebb23b..c88b126502 100644--- a/tests/disas/gc/drc/array-set.wat+++ b/tests/disas/gc/drc/array-set.wat@@ -20,7 +20,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i64):-;; @0024 trapz v2, user16+;; @0024 trapz v2, user15;; @0024 v32 = load.i64 notrap aligned readonly can_move v0+8;; @0024 v6 = load.i64 notrap aligned readonly can_move v32+24;; @0024 v5 = uextend.i64 v2@@ -29,7 +29,7 @@;; @0024 v9 = iadd v7, v8 ; v8 = 24;; @0024 v10 = load.i32 notrap aligned readonly v9;; @0024 v11 = icmp ult v3, v10-;; @0024 trapz v11, user17+;; @0024 trapz v11, user16;; @0024 v13 = uextend.i64 v10;; v34 = iconst.i64 3;; v35 = ishl v13, v34 ; v34 = 3diff --git a/tests/disas/gc/drc/funcref-in-gc-heap-get.wat b/tests/disas/gc/drc/funcref-in-gc-heap-get.watindex a0752b7806..d0dd4fe7e9 100644--- a/tests/disas/gc/drc/funcref-in-gc-heap-get.wat+++ b/tests/disas/gc/drc/funcref-in-gc-heap-get.wat@@ -22,7 +22,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32):-;; @0020 trapz v2, user16+;; @0020 trapz v2, user15;; @0020 v13 = load.i64 notrap aligned readonly can_move v0+8;; @0020 v5 = load.i64 notrap aligned readonly can_move v13+24;; @0020 v4 = uextend.i64 v2diff --git a/tests/disas/gc/drc/funcref-in-gc-heap-set.wat b/tests/disas/gc/drc/funcref-in-gc-heap-set.watindex 2cd534a9a2..7f82110b0b 100644--- a/tests/disas/gc/drc/funcref-in-gc-heap-set.wat+++ b/tests/disas/gc/drc/funcref-in-gc-heap-set.wat@@ -22,7 +22,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32, v3: i64):-;; @0022 trapz v2, user16+;; @0022 trapz v2, user15;; @0022 v10 = call fn0(v0, v3);; @0022 v11 = ireduce.i32 v10;; @0022 v12 = load.i64 notrap aligned readonly can_move v0+8diff --git a/tests/disas/gc/drc/multiple-array-get.wat b/tests/disas/gc/drc/multiple-array-get.watindex 04159cf156..4b4cabdf1c 100644--- a/tests/disas/gc/drc/multiple-array-get.wat+++ b/tests/disas/gc/drc/multiple-array-get.wat@@ -21,7 +21,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32):-;; @0024 trapz v2, user16+;; @0024 trapz v2, user15;; @0024 v65 = load.i64 notrap aligned readonly can_move v0+8;; @0024 v8 = load.i64 notrap aligned readonly can_move v65+24;; @0024 v7 = uextend.i64 v2@@ -30,7 +30,7 @@;; @0024 v11 = iadd v9, v10 ; v10 = 24;; @0024 v12 = load.i32 notrap aligned readonly v11;; @0024 v13 = icmp ult v3, v12-;; @0024 trapz v13, user17+;; @0024 trapz v13, user16;; @0024 v15 = uextend.i64 v12;; v67 = iconst.i64 3;; v68 = ishl v15, v67 ; v67 = 3@@ -51,7 +51,7 @@;; @0024 v30 = isub v27, v29;; @0024 v31 = load.i64 notrap aligned little v30;; @002b v38 = icmp ult v4, v12-;; @002b trapz v38, user17+;; @002b trapz v38, user16;; v86 = ishl v4, v77 ; v77 = 3;; @002b v48 = iadd v86, v19 ; v19 = 32;; @002b v53 = isub v20, v48diff --git a/tests/disas/gc/drc/multiple-struct-get.wat b/tests/disas/gc/drc/multiple-struct-get.watindex 35ef796ac4..bc1f3bc782 100644--- a/tests/disas/gc/drc/multiple-struct-get.wat+++ b/tests/disas/gc/drc/multiple-struct-get.wat@@ -22,7 +22,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32):-;; @0023 trapz v2, user16+;; @0023 trapz v2, user15;; @0023 v20 = load.i64 notrap aligned readonly can_move v0+8;; @0023 v6 = load.i64 notrap aligned readonly can_move v20+24;; @0023 v5 = uextend.i64 v2diff --git a/tests/disas/gc/drc/ref-cast.wat b/tests/disas/gc/drc/ref-cast.watindex 83fad1e6c0..4056ef24b3 100644--- a/tests/disas/gc/drc/ref-cast.wat+++ b/tests/disas/gc/drc/ref-cast.wat@@ -57,7 +57,7 @@;; @001e jump block4(v23);;;; block4(v24: i32):-;; @001e trapz v24, user19+;; @001e trapz v24, user18;; v25 = load.i32 notrap v36;; @0021 jump block1;;diff --git a/tests/disas/gc/drc/struct-get.wat b/tests/disas/gc/drc/struct-get.watindex c0221c3e1f..0c87b1bf42 100644--- a/tests/disas/gc/drc/struct-get.wat+++ b/tests/disas/gc/drc/struct-get.wat@@ -34,7 +34,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32):-;; @0033 trapz v2, user16+;; @0033 trapz v2, user15;; @0033 v10 = load.i64 notrap aligned readonly can_move v0+8;; @0033 v5 = load.i64 notrap aligned readonly can_move v10+24;; @0033 v4 = uextend.i64 v2@@ -59,7 +59,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32):-;; @003c trapz v2, user16+;; @003c trapz v2, user15;; @003c v11 = load.i64 notrap aligned readonly can_move v0+8;; @003c v5 = load.i64 notrap aligned readonly can_move v11+24;; @003c v4 = uextend.i64 v2@@ -85,7 +85,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32):-;; @0045 trapz v2, user16+;; @0045 trapz v2, user15;; @0045 v11 = load.i64 notrap aligned readonly can_move v0+8;; @0045 v5 = load.i64 notrap aligned readonly can_move v11+24;; @0045 v4 = uextend.i64 v2@@ -111,7 +111,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32):-;; @004e trapz v2, user16+;; @004e trapz v2, user15;; @004e v58 = load.i64 notrap aligned readonly can_move v0+8;; @004e v5 = load.i64 notrap aligned readonly can_move v58+24;; @004e v4 = uextend.i64 v2diff --git a/tests/disas/gc/drc/struct-set.wat b/tests/disas/gc/drc/struct-set.watindex a762954a46..118899ecbc 100644--- a/tests/disas/gc/drc/struct-set.wat+++ b/tests/disas/gc/drc/struct-set.wat@@ -30,7 +30,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32, v3: f32):-;; @0034 trapz v2, user16+;; @0034 trapz v2, user15;; @0034 v9 = load.i64 notrap aligned readonly can_move v0+8;; @0034 v5 = load.i64 notrap aligned readonly can_move v9+24;; @0034 v4 = uextend.i64 v2@@ -55,7 +55,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32, v3: i32):-;; @003f trapz v2, user16+;; @003f trapz v2, user15;; @003f v9 = load.i64 notrap aligned readonly can_move v0+8;; @003f v5 = load.i64 notrap aligned readonly can_move v9+24;; @003f v4 = uextend.i64 v2@@ -82,7 +82,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32, v3: i32):-;; @004a trapz v2, user16+;; @004a trapz v2, user15;; @004a v59 = load.i64 notrap aligned readonly can_move v0+8;; @004a v5 = load.i64 notrap aligned readonly can_move v59+24;; @004a v4 = uextend.i64 v2diff --git a/tests/disas/gc/null/array-fill.wat b/tests/disas/gc/null/array-fill.watindex 2ddc505ea8..2dd07bec43 100644--- a/tests/disas/gc/null/array-fill.wat+++ b/tests/disas/gc/null/array-fill.wat@@ -20,7 +20,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i64, v5: i32):-;; @0027 trapz v2, user16+;; @0027 trapz v2, user15;; @0027 v41 = load.i64 notrap aligned readonly can_move v0+8;; @0027 v7 = load.i64 notrap aligned readonly can_move v41+24;; @0027 v6 = uextend.i64 v2@@ -28,9 +28,9 @@;; @0027 v9 = iconst.i64 8;; @0027 v10 = iadd v8, v9 ; v9 = 8;; @0027 v11 = load.i32 notrap aligned readonly v10-;; @0027 v12 = uadd_overflow_trap v3, v5, user17+;; @0027 v12 = uadd_overflow_trap v3, v5, user16;; @0027 v13 = icmp ugt v12, v11-;; @0027 trapnz v13, user17+;; @0027 trapnz v13, user16;; @0027 v15 = uextend.i64 v11;; v43 = iconst.i64 3;; v44 = ishl v15, v43 ; v43 = 3diff --git a/tests/disas/gc/null/array-get-s.wat b/tests/disas/gc/null/array-get-s.watindex d33eb7715b..0a04f752e7 100644--- a/tests/disas/gc/null/array-get-s.wat+++ b/tests/disas/gc/null/array-get-s.wat@@ -20,7 +20,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32, v3: i32):-;; @0022 trapz v2, user16+;; @0022 trapz v2, user15;; @0022 v34 = load.i64 notrap aligned readonly can_move v0+8;; @0022 v6 = load.i64 notrap aligned readonly can_move v34+24;; @0022 v5 = uextend.i64 v2@@ -29,7 +29,7 @@;; @0022 v9 = iadd v7, v8 ; v8 = 8;; @0022 v10 = load.i32 notrap aligned readonly v9;; @0022 v11 = icmp ult v3, v10-;; @0022 trapz v11, user17+;; @0022 trapz v11, user16;; @0022 v13 = uextend.i64 v10;; v33 = iconst.i64 32;; @0022 v15 = ushr v13, v33 ; v33 = 32diff --git a/tests/disas/gc/null/array-get-u.wat b/tests/disas/gc/null/array-get-u.watindex de64885a7d..8f2f564f7f 100644--- a/tests/disas/gc/null/array-get-u.wat+++ b/tests/disas/gc/null/array-get-u.wat@@ -20,7 +20,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32, v3: i32):-;; @0022 trapz v2, user16+;; @0022 trapz v2, user15;; @0022 v34 = load.i64 notrap aligned readonly can_move v0+8;; @0022 v6 = load.i64 notrap aligned readonly can_move v34+24;; @0022 v5 = uextend.i64 v2@@ -29,7 +29,7 @@;; @0022 v9 = iadd v7, v8 ; v8 = 8;; @0022 v10 = load.i32 notrap aligned readonly v9;; @0022 v11 = icmp ult v3, v10-;; @0022 trapz v11, user17+;; @0022 trapz v11, user16;; @0022 v13 = uextend.i64 v10;; v33 = iconst.i64 32;; @0022 v15 = ushr v13, v33 ; v33 = 32diff --git a/tests/disas/gc/null/array-get.wat b/tests/disas/gc/null/array-get.watindex f03c2b8d1c..4037eb150d 100644--- a/tests/disas/gc/null/array-get.wat+++ b/tests/disas/gc/null/array-get.wat@@ -20,7 +20,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32, v3: i32):-;; @0022 trapz v2, user16+;; @0022 trapz v2, user15;; @0022 v33 = load.i64 notrap aligned readonly can_move v0+8;; @0022 v6 = load.i64 notrap aligned readonly can_move v33+24;; @0022 v5 = uextend.i64 v2@@ -29,7 +29,7 @@;; @0022 v9 = iadd v7, v8 ; v8 = 8;; @0022 v10 = load.i32 notrap aligned readonly v9;; @0022 v11 = icmp ult v3, v10-;; @0022 trapz v11, user17+;; @0022 trapz v11, user16;; @0022 v13 = uextend.i64 v10;; v35 = iconst.i64 3;; v36 = ishl v13, v35 ; v35 = 3diff --git a/tests/disas/gc/null/array-len.wat b/tests/disas/gc/null/array-len.watindex 31ac5e588b..e551e1e921 100644--- a/tests/disas/gc/null/array-len.wat+++ b/tests/disas/gc/null/array-len.wat@@ -20,7 +20,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32):-;; @001f trapz v2, user16+;; @001f trapz v2, user15;; @001f v10 = load.i64 notrap aligned readonly can_move v0+8;; @001f v5 = load.i64 notrap aligned readonly can_move v10+24;; @001f v4 = uextend.i64 v2diff --git a/tests/disas/gc/null/array-new-fixed-of-gc-refs.wat b/tests/disas/gc/null/array-new-fixed-of-gc-refs.watindex 59623535ef..57f8d27b25 100644--- a/tests/disas/gc/null/array-new-fixed-of-gc-refs.wat+++ b/tests/disas/gc/null/array-new-fixed-of-gc-refs.wat@@ -34,11 +34,11 @@;; @0025 v17 = load.i64 notrap aligned readonly v0+32;; @0025 v18 = load.i32 notrap aligned v17;; v82 = iconst.i32 7-;; @0025 v21 = uadd_overflow_trap v18, v82, user18 ; v82 = 7+;; @0025 v21 = uadd_overflow_trap v18, v82, user17 ; v82 = 7;; v89 = iconst.i32 -8;; @0025 v23 = band v21, v89 ; v89 = -8;; v74 = iconst.i32 24-;; @0025 v24 = uadd_overflow_trap v23, v74, user18 ; v74 = 24+;; @0025 v24 = uadd_overflow_trap v23, v74, user17 ; v74 = 24;; @0025 v56 = load.i64 notrap aligned readonly can_move v0+8;; @0025 v26 = load.i64 notrap aligned v56+32;; @0025 v25 = uextend.i64 v24diff --git a/tests/disas/gc/null/array-new-fixed.wat b/tests/disas/gc/null/array-new-fixed.watindex 4c96c8c34f..36422419ee 100644--- a/tests/disas/gc/null/array-new-fixed.wat+++ b/tests/disas/gc/null/array-new-fixed.wat@@ -25,11 +25,11 @@;; @0025 v17 = load.i64 notrap aligned readonly v0+32;; @0025 v18 = load.i32 notrap aligned v17;; v73 = iconst.i32 7-;; @0025 v21 = uadd_overflow_trap v18, v73, user18 ; v73 = 7+;; @0025 v21 = uadd_overflow_trap v18, v73, user17 ; v73 = 7;; v80 = iconst.i32 -8;; @0025 v23 = band v21, v80 ; v80 = -8;; v65 = iconst.i32 40-;; @0025 v24 = uadd_overflow_trap v23, v65, user18 ; v65 = 40+;; @0025 v24 = uadd_overflow_trap v23, v65, user17 ; v65 = 40;; @0025 v50 = load.i64 notrap aligned readonly can_move v0+8;; @0025 v26 = load.i64 notrap aligned v50+32;; @0025 v25 = uextend.i64 v24diff --git a/tests/disas/gc/null/array-new.wat b/tests/disas/gc/null/array-new.watindex d7d430bfe8..cd144cbb97 100644--- a/tests/disas/gc/null/array-new.wat+++ b/tests/disas/gc/null/array-new.wat@@ -27,21 +27,21 @@;; v56 = ishl v6, v55 ; v55 = 3;; v53 = iconst.i64 32;; @0022 v8 = ushr v56, v53 ; v53 = 32-;; @0022 trapnz v8, user18+;; @0022 trapnz v8, user17;; @0022 v5 = iconst.i32 16;; v62 = iconst.i32 3;; v63 = ishl v3, v62 ; v62 = 3-;; @0022 v10 = uadd_overflow_trap v5, v63, user18 ; v5 = 16+;; @0022 v10 = uadd_overflow_trap v5, v63, user17 ; v5 = 16;; @0022 v12 = iconst.i32 -67108864;; @0022 v13 = band v10, v12 ; v12 = -67108864-;; @0022 trapnz v13, user18+;; @0022 trapnz v13, user17;; @0022 v15 = load.i64 notrap aligned readonly v0+32;; @0022 v16 = load.i32 notrap aligned v15;; v66 = iconst.i32 7-;; @0022 v19 = uadd_overflow_trap v16, v66, user18 ; v66 = 7+;; @0022 v19 = uadd_overflow_trap v16, v66, user17 ; v66 = 7;; v73 = iconst.i32 -8;; @0022 v21 = band v19, v73 ; v73 = -8-;; @0022 v22 = uadd_overflow_trap v21, v10, user18+;; @0022 v22 = uadd_overflow_trap v21, v10, user17;; @0022 v51 = load.i64 notrap aligned readonly can_move v0+8;; @0022 v24 = load.i64 notrap aligned v51+32;; @0022 v23 = uextend.i64 v22diff --git a/tests/disas/gc/null/array-set.wat b/tests/disas/gc/null/array-set.watindex 0c13a75c47..2f2540d42e 100644--- a/tests/disas/gc/null/array-set.wat+++ b/tests/disas/gc/null/array-set.wat@@ -20,7 +20,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i64):-;; @0024 trapz v2, user16+;; @0024 trapz v2, user15;; @0024 v32 = load.i64 notrap aligned readonly can_move v0+8;; @0024 v6 = load.i64 notrap aligned readonly can_move v32+24;; @0024 v5 = uextend.i64 v2@@ -29,7 +29,7 @@;; @0024 v9 = iadd v7, v8 ; v8 = 8;; @0024 v10 = load.i32 notrap aligned readonly v9;; @0024 v11 = icmp ult v3, v10-;; @0024 trapz v11, user17+;; @0024 trapz v11, user16;; @0024 v13 = uextend.i64 v10;; v34 = iconst.i64 3;; v35 = ishl v13, v34 ; v34 = 3diff --git a/tests/disas/gc/null/funcref-in-gc-heap-get.wat b/tests/disas/gc/null/funcref-in-gc-heap-get.watindex 417531ae00..78e4178a67 100644--- a/tests/disas/gc/null/funcref-in-gc-heap-get.wat+++ b/tests/disas/gc/null/funcref-in-gc-heap-get.wat@@ -22,7 +22,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32):-;; @0020 trapz v2, user16+;; @0020 trapz v2, user15;; @0020 v13 = load.i64 notrap aligned readonly can_move v0+8;; @0020 v5 = load.i64 notrap aligned readonly can_move v13+24;; @0020 v4 = uextend.i64 v2diff --git a/tests/disas/gc/null/funcref-in-gc-heap-new.wat b/tests/disas/gc/null/funcref-in-gc-heap-new.watindex d2f8b7f83c..baef7b3e99 100644--- a/tests/disas/gc/null/funcref-in-gc-heap-new.wat+++ b/tests/disas/gc/null/funcref-in-gc-heap-new.wat@@ -27,11 +27,11 @@;; @0020 v9 = load.i64 notrap aligned readonly v0+32;; @0020 v10 = load.i32 notrap aligned v9;; v47 = iconst.i32 7-;; @0020 v13 = uadd_overflow_trap v10, v47, user18 ; v47 = 7+;; @0020 v13 = uadd_overflow_trap v10, v47, user17 ; v47 = 7;; v54 = iconst.i32 -8;; @0020 v15 = band v13, v54 ; v54 = -8;; @0020 v4 = iconst.i32 16-;; @0020 v16 = uadd_overflow_trap v15, v4, user18 ; v4 = 16+;; @0020 v16 = uadd_overflow_trap v15, v4, user17 ; v4 = 16;; @0020 v38 = load.i64 notrap aligned readonly can_move v0+8;; @0020 v18 = load.i64 notrap aligned v38+32;; @0020 v17 = uextend.i64 v16diff --git a/tests/disas/gc/null/funcref-in-gc-heap-set.wat b/tests/disas/gc/null/funcref-in-gc-heap-set.watindex aeed15a95b..02f060375c 100644--- a/tests/disas/gc/null/funcref-in-gc-heap-set.wat+++ b/tests/disas/gc/null/funcref-in-gc-heap-set.wat@@ -22,7 +22,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32, v3: i64):-;; @0022 trapz v2, user16+;; @0022 trapz v2, user15;; @0022 v10 = call fn0(v0, v3);; @0022 v11 = ireduce.i32 v10;; @0022 v12 = load.i64 notrap aligned readonly can_move v0+8diff --git a/tests/disas/gc/null/multiple-array-get.wat b/tests/disas/gc/null/multiple-array-get.watindex dfe6fe6656..0e7fc6d469 100644--- a/tests/disas/gc/null/multiple-array-get.wat+++ b/tests/disas/gc/null/multiple-array-get.wat@@ -21,7 +21,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32):-;; @0024 trapz v2, user16+;; @0024 trapz v2, user15;; @0024 v65 = load.i64 notrap aligned readonly can_move v0+8;; @0024 v8 = load.i64 notrap aligned readonly can_move v65+24;; @0024 v7 = uextend.i64 v2@@ -30,7 +30,7 @@;; @0024 v11 = iadd v9, v10 ; v10 = 8;; @0024 v12 = load.i32 notrap aligned readonly v11;; @0024 v13 = icmp ult v3, v12-;; @0024 trapz v13, user17+;; @0024 trapz v13, user16;; @0024 v15 = uextend.i64 v12;; v67 = iconst.i64 3;; v68 = ishl v15, v67 ; v67 = 3@@ -51,7 +51,7 @@;; @0024 v30 = isub v27, v29;; @0024 v31 = load.i64 notrap aligned little v30;; @002b v38 = icmp ult v4, v12-;; @002b trapz v38, user17+;; @002b trapz v38, user16;; v86 = ishl v4, v77 ; v77 = 3;; @002b v48 = iadd v86, v19 ; v19 = 16;; @002b v53 = isub v20, v48diff --git a/tests/disas/gc/null/multiple-struct-get.wat b/tests/disas/gc/null/multiple-struct-get.watindex 9896429ba2..dce103bd7b 100644--- a/tests/disas/gc/null/multiple-struct-get.wat+++ b/tests/disas/gc/null/multiple-struct-get.wat@@ -22,7 +22,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32):-;; @0023 trapz v2, user16+;; @0023 trapz v2, user15;; @0023 v20 = load.i64 notrap aligned readonly can_move v0+8;; @0023 v6 = load.i64 notrap aligned readonly can_move v20+24;; @0023 v5 = uextend.i64 v2diff --git a/tests/disas/gc/null/ref-cast.wat b/tests/disas/gc/null/ref-cast.watindex 12e19ab587..ce6c41a8d3 100644--- a/tests/disas/gc/null/ref-cast.wat+++ b/tests/disas/gc/null/ref-cast.wat@@ -57,7 +57,7 @@;; @001e jump block4(v23);;;; block4(v24: i32):-;; @001e trapz v24, user19+;; @001e trapz v24, user18;; v25 = load.i32 notrap v36;; @0021 jump block1;;diff --git a/tests/disas/gc/null/struct-get.wat b/tests/disas/gc/null/struct-get.watindex 87a6dff893..ef75daf799 100644--- a/tests/disas/gc/null/struct-get.wat+++ b/tests/disas/gc/null/struct-get.wat@@ -34,7 +34,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32):-;; @0033 trapz v2, user16+;; @0033 trapz v2, user15;; @0033 v10 = load.i64 notrap aligned readonly can_move v0+8;; @0033 v5 = load.i64 notrap aligned readonly can_move v10+24;; @0033 v4 = uextend.i64 v2@@ -59,7 +59,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32):-;; @003c trapz v2, user16+;; @003c trapz v2, user15;; @003c v11 = load.i64 notrap aligned readonly can_move v0+8;; @003c v5 = load.i64 notrap aligned readonly can_move v11+24;; @003c v4 = uextend.i64 v2@@ -85,7 +85,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32):-;; @0045 trapz v2, user16+;; @0045 trapz v2, user15;; @0045 v11 = load.i64 notrap aligned readonly can_move v0+8;; @0045 v5 = load.i64 notrap aligned readonly can_move v11+24;; @0045 v4 = uextend.i64 v2@@ -111,7 +111,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32):-;; @004e trapz v2, user16+;; @004e trapz v2, user15;; @004e v10 = load.i64 notrap aligned readonly can_move v0+8;; @004e v5 = load.i64 notrap aligned readonly can_move v10+24;; @004e v4 = uextend.i64 v2diff --git a/tests/disas/gc/null/struct-new-default.wat b/tests/disas/gc/null/struct-new-default.watindex 537dbde6d0..092c3deda1 100644--- a/tests/disas/gc/null/struct-new-default.wat+++ b/tests/disas/gc/null/struct-new-default.wat@@ -27,11 +27,11 @@;; @0021 v11 = load.i64 notrap aligned readonly v0+32;; @0021 v12 = load.i32 notrap aligned v11;; v49 = iconst.i32 7-;; @0021 v15 = uadd_overflow_trap v12, v49, user18 ; v49 = 7+;; @0021 v15 = uadd_overflow_trap v12, v49, user17 ; v49 = 7;; v56 = iconst.i32 -8;; @0021 v17 = band v15, v56 ; v56 = -8;; @0021 v6 = iconst.i32 24-;; @0021 v18 = uadd_overflow_trap v17, v6, user18 ; v6 = 24+;; @0021 v18 = uadd_overflow_trap v17, v6, user17 ; v6 = 24;; @0021 v41 = load.i64 notrap aligned readonly can_move v0+8;; @0021 v20 = load.i64 notrap aligned v41+32;; @0021 v19 = uextend.i64 v18diff --git a/tests/disas/gc/null/struct-new.wat b/tests/disas/gc/null/struct-new.watindex 6797807015..e9f75c07b4 100644--- a/tests/disas/gc/null/struct-new.wat+++ b/tests/disas/gc/null/struct-new.wat@@ -30,11 +30,11 @@;; @002a v11 = load.i64 notrap aligned readonly v0+32;; @002a v12 = load.i32 notrap aligned v11;; v53 = iconst.i32 7-;; @002a v15 = uadd_overflow_trap v12, v53, user18 ; v53 = 7+;; @002a v15 = uadd_overflow_trap v12, v53, user17 ; v53 = 7;; v60 = iconst.i32 -8;; @002a v17 = band v15, v60 ; v60 = -8;; @002a v6 = iconst.i32 24-;; @002a v18 = uadd_overflow_trap v17, v6, user18 ; v6 = 24+;; @002a v18 = uadd_overflow_trap v17, v6, user17 ; v6 = 24;; @002a v43 = load.i64 notrap aligned readonly can_move v0+8;; @002a v20 = load.i64 notrap aligned v43+32;; @002a v19 = uextend.i64 v18diff --git a/tests/disas/gc/null/struct-set.wat b/tests/disas/gc/null/struct-set.watindex fc82d6e27d..f467789666 100644--- a/tests/disas/gc/null/struct-set.wat+++ b/tests/disas/gc/null/struct-set.wat@@ -30,7 +30,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32, v3: f32):-;; @0034 trapz v2, user16+;; @0034 trapz v2, user15;; @0034 v9 = load.i64 notrap aligned readonly can_move v0+8;; @0034 v5 = load.i64 notrap aligned readonly can_move v9+24;; @0034 v4 = uextend.i64 v2@@ -55,7 +55,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32, v3: i32):-;; @003f trapz v2, user16+;; @003f trapz v2, user15;; @003f v9 = load.i64 notrap aligned readonly can_move v0+8;; @003f v5 = load.i64 notrap aligned readonly can_move v9+24;; @003f v4 = uextend.i64 v2@@ -80,7 +80,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32, v3: i32):-;; @004a trapz v2, user16+;; @004a trapz v2, user15;; @004a v9 = load.i64 notrap aligned readonly can_move v0+8;; @004a v5 = load.i64 notrap aligned readonly can_move v9+24;; @004a v4 = uextend.i64 v2diff --git a/tests/disas/gc/null/v128-fields.wat b/tests/disas/gc/null/v128-fields.watindex 9f08bb7356..f721d0f216 100644--- a/tests/disas/gc/null/v128-fields.wat+++ b/tests/disas/gc/null/v128-fields.wat@@ -22,7 +22,7 @@;; stack_limit = gv2;;;; block0(v0: i64, v1: i64, v2: i32):-;; @0022 trapz v2, user16+;; @0022 trapz v2, user15;; @0022 v19 = load.i64 notrap aligned readonly can_move v0+8;; @0022 v5 = load.i64 notrap aligned readonly can_move v19+24;; @0022 v4 = uextend.i64 v2diff --git a/tests/disas/stack-switching/resume-suspend-data-passing.wat b/tests/disas/stack-switching/resume-suspend-data-passing.watindex b24ba2288e..95d4d42a70 100644--- a/tests/disas/stack-switching/resume-suspend-data-passing.wat+++ b/tests/disas/stack-switching/resume-suspend-data-passing.wat@@ -68,7 +68,7 @@;; block4(v11: i64, v12: i64, v52: i32):;; v73 = iconst.i64 1;; v74 = icmp eq v11, v73 ; v73 = 1-;; @0044 trapnz v74, user22+;; @0044 trapnz v74, user21;; @0044 jump block5;;;; block5:@@ -159,7 +159,7 @@;; block0(v0: i64, v1: i64):;; @0056 v2 = iconst.i32 0;; @0056 v4 = call fn0(v0, v2) ; v2 = 0-;; @0058 trapz v4, user16+;; @0058 trapz v4, user15;; @0058 v8 = call fn1(v0, v4, v2, v2) ; v2 = 0, v2 = 0;; @0058 v9 = load.i64 notrap aligned v8+72;; @0058 v11 = uextend.i128 v9@@ -188,13 +188,13 @@;;;; block5:;; @0062 v18 = ireduce.i64 v16-;; @0062 trapz v18, user16+;; @0062 trapz v18, user15;; @0062 v21 = load.i64 notrap aligned v18+72;; v128 = iconst.i64 64;; v129 = ushr.i128 v16, v128 ; v128 = 64;; @0062 v20 = ireduce.i64 v129;; @0062 v22 = icmp eq v21, v20-;; @0062 trapz v22, user23+;; @0062 trapz v22, user22;; v130 = iconst.i64 1;; v131 = iadd v21, v130 ; v130 = 1;; @0062 store notrap aligned v131, v18+72diff --git a/tests/disas/stack-switching/resume-suspend.wat b/tests/disas/stack-switching/resume-suspend.watindex 1f09b66632..2600a0c36a 100644--- a/tests/disas/stack-switching/resume-suspend.wat+++ b/tests/disas/stack-switching/resume-suspend.wat@@ -41,7 +41,7 @@;; block2(v8: i64, v9: i64):;; v62 = iconst.i64 1;; v63 = icmp eq v8, v62 ; v62 = 1-;; @003b trapnz v63, user22+;; @003b trapnz v63, user21;; @003b jump block3;;;; block3:@@ -120,7 +120,7 @@;; block0(v0: i64, v1: i64):;; @0043 v7 = iconst.i32 0;; @0043 v9 = call fn0(v0, v7) ; v7 = 0-;; @0045 trapz v9, user16+;; @0045 trapz v9, user15;; @0045 v13 = call fn1(v0, v9, v7, v7) ; v7 = 0, v7 = 0;; @0045 v14 = load.i64 notrap aligned v13+72;; @004e jump block3@@ -131,14 +131,14 @@;; v134 = ishl v16, v130 ; v130 = 64;; v136 = ireduce.i64 v134;; v138 = bor v136, v13-;; @004e trapz v138, user16+;; @004e trapz v138, user15;; @004e v24 = load.i64 notrap aligned v138+72;; @0045 v15 = uextend.i128 v13;; @0045 v18 = bor v134, v15;; v140 = ushr v18, v130 ; v130 = 64;; @004e v23 = ireduce.i64 v140;; @004e v25 = icmp eq v24, v23-;; @004e trapz v25, user23+;; @004e trapz v25, user22;; v125 = iconst.i64 1;; @004e v26 = iadd v24, v125 ; v125 = 1;; @004e store notrap aligned v26, v138+72diff --git a/tests/disas/stack-switching/symmetric-switch.wat b/tests/disas/stack-switching/symmetric-switch.watindex 666fcd8406..8423e68e50 100644--- a/tests/disas/stack-switching/symmetric-switch.wat+++ b/tests/disas/stack-switching/symmetric-switch.wat@@ -40,7 +40,7 @@;; block0(v0: i64, v1: i64):;; @003a v2 = iconst.i32 1;; @003a v4 = call fn0(v0, v2) ; v2 = 1-;; @003c trapz v4, user16+;; @003c trapz v4, user15;; @003c v5 = iconst.i32 1;; @003c v6 = iconst.i32 0;; @003c v8 = call fn1(v0, v4, v5, v6) ; v5 = 1, v6 = 0@@ -56,10 +56,10 @@;; v137 = uextend.i128 v136 ; v136 = 64;; @003e v16 = ushr v13, v137;; @003e v17 = ireduce.i64 v16-;; @003e trapz v15, user16+;; @003e trapz v15, user15;; @003e v18 = load.i64 notrap aligned v15+72;; @003e v19 = icmp eq v18, v17-;; @003e trapz v19, user23+;; @003e trapz v19, user22;; v135 = iconst.i64 1;; @003e v20 = iadd v18, v135 ; v135 = 1;; @003e store notrap aligned v20, v15+72@@ -73,7 +73,7 @@;; block2(v26: i64, v27: i64):;; v133 = iconst.i64 1;; @003e v28 = icmp eq v26, v133 ; v133 = 1-;; @003e trapnz v28, user22+;; @003e trapnz v28, user21;; @003e jump block3;;;; block3:@@ -255,7 +255,7 @@;; block0(v0: i64, v1: i64):;; @0047 v2 = iconst.i32 0;; @0047 v4 = call fn0(v0, v2) ; v2 = 0-;; @0049 trapz v4, user16+;; @0049 trapz v4, user15;; @0049 v5 = iconst.i32 0;; @0049 v6 = iconst.i32 0;; @0049 v8 = call fn1(v0, v4, v5, v6) ; v5 = 0, v6 = 0@@ -274,10 +274,10 @@;; v110 = uextend.i128 v109 ; v109 = 64;; @004b v16 = ushr.i128 v13, v110;; @004b v17 = ireduce.i64 v16-;; @004b trapz v15, user16+;; @004b trapz v15, user15;; @004b v18 = load.i64 notrap aligned v15+72;; @004b v19 = icmp eq v18, v17-;; @004b trapz v19, user23+;; @004b trapz v19, user22;; v108 = iconst.i64 1;; @004b v20 = iadd v18, v108 ; v108 = 1;; @004b store notrap aligned v20, v15+72diff --git a/tests/disas/typed-funcrefs-eager-init.wat b/tests/disas/typed-funcrefs-eager-init.watindex 94b71da01a..a2011f17c1 100644--- a/tests/disas/typed-funcrefs-eager-init.wat+++ b/tests/disas/typed-funcrefs-eager-init.wat@@ -140,13 +140,13 @@;; v48 = iconst.i64 8;; @0048 v14 = iadd v12, v48 ; v48 = 8;; @0048 v17 = load.i64 user5 aligned table v14-;; @004a v18 = load.i64 user16 aligned readonly v17+8+;; @004a v18 = load.i64 user15 aligned readonly v17+8;; @004a v19 = load.i64 notrap aligned readonly v17+24;; @004a v20 = call_indirect sig0, v18(v19, v0, v2, v3, v4, v5);; v56 = iconst.i64 16;; @005b v28 = iadd v12, v56 ; v56 = 16;; @005b v31 = load.i64 user5 aligned table v28-;; @005d v32 = load.i64 user16 aligned readonly v31+8+;; @005d v32 = load.i64 user15 aligned readonly v31+8;; @005d v33 = load.i64 notrap aligned readonly v31+24;; @005d v34 = call_indirect sig0, v32(v33, v0, v2, v3, v4, v5);; @0066 jump block1@@ -196,11 +196,11 @@;;;; block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):;; @009e v9 = load.i64 notrap aligned table v0+64-;; @00a0 v10 = load.i64 user16 aligned readonly v9+8+;; @00a0 v10 = load.i64 user15 aligned readonly v9+8;; @00a0 v11 = load.i64 notrap aligned readonly v9+24;; @00a0 v12 = call_indirect sig0, v10(v11, v0, v2, v3, v4, v5);; @00af v15 = load.i64 notrap aligned table v0+80-;; @00b1 v16 = load.i64 user16 aligned readonly v15+8+;; @00b1 v16 = load.i64 user15 aligned readonly v15+8;; @00b1 v17 = load.i64 notrap aligned readonly v15+24;; @00b1 v18 = call_indirect sig0, v16(v17, v0, v2, v3, v4, v5);; @00ba jump block1diff --git a/tests/disas/typed-funcrefs.wat b/tests/disas/typed-funcrefs.watindex 32082555f2..bfed93b39d 100644--- a/tests/disas/typed-funcrefs.wat+++ b/tests/disas/typed-funcrefs.wat@@ -153,7 +153,7 @@;; @0048 jump block3(v23);;;; block3(v19: i64):-;; @004a v24 = load.i64 user16 aligned readonly v19+8+;; @004a v24 = load.i64 user15 aligned readonly v19+8;; @004a v25 = load.i64 notrap aligned readonly v19+24;; @004a v26 = call_indirect sig1, v24(v25, v0, v2, v3, v4, v5);; v76 = iconst.i64 16@@ -170,7 +170,7 @@;; @005b jump block5(v48);;;; block5(v44: i64):-;; @005d v49 = load.i64 user16 aligned readonly v44+8+;; @005d v49 = load.i64 user15 aligned readonly v44+8;; @005d v50 = load.i64 notrap aligned readonly v44+24;; @005d v51 = call_indirect sig1, v49(v50, v0, v2, v3, v4, v5);; @0066 jump block1@@ -244,11 +244,11 @@;;;; block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):;; @009e v9 = load.i64 notrap aligned table v0+64-;; @00a0 v10 = load.i64 user16 aligned readonly v9+8+;; @00a0 v10 = load.i64 user15 aligned readonly v9+8;; @00a0 v11 = load.i64 notrap aligned readonly v9+24;; @00a0 v12 = call_indirect sig0, v10(v11, v0, v2, v3, v4, v5);; @00af v15 = load.i64 notrap aligned table v0+80-;; @00b1 v16 = load.i64 user16 aligned readonly v15+8+;; @00b1 v16 = load.i64 user15 aligned readonly v15+8;; @00b1 v17 = load.i64 notrap aligned readonly v15+24;; @00b1 v18 = call_indirect sig0, v16(v17, v0, v2, v3, v4, v5);; @00ba jump block1diff --git a/tests/misc_testsuite/component-model/adapter.wast b/tests/misc_testsuite/component-model/adapter.wastindex 0ca70a1dc6..8432d5841a 100644--- a/tests/misc_testsuite/component-model/adapter.wast+++ b/tests/misc_testsuite/component-model/adapter.wast@@ -112,7 +112,7 @@(with "" (instance (export "" (func $f2)))))))- "degenerate component adapter called")+ "cannot enter component instance");; fiddling with 0-sized lists(component $cdiff --git a/tests/misc_testsuite/component-model/async/backpressure-deadlock.wast b/tests/misc_testsuite/component-model/async/backpressure-deadlock.wastindex 5a45f89302..06e6df3df4 100644--- a/tests/misc_testsuite/component-model/async/backpressure-deadlock.wast+++ b/tests/misc_testsuite/component-model/async/backpressure-deadlock.wast@@ -38,60 +38,71 @@)(instance $A (instantiate $A))- (core module $libc (memory (export "mem") 1))- (core instance $libc (instantiate $libc))-- (core func $f (canon lower (func $A "f") async (memory $libc "mem")))- (core func $turn-on-backpressure (canon lower (func $A "turn-on-backpressure")))- (core func $waitable-set.new (canon waitable-set.new))- (core func $waitable.join (canon waitable.join))- (core func $waitable-set.wait (canon waitable-set.wait (memory $libc "mem")))-- (core module $m- (import "" "f" (func $f (result i32)))- (import "" "turn-on-backpressure" (func $turn-on-backpressure))- (import "" "waitable-set.new" (func $waitable-set.new (result i32)))- (import "" "waitable.join" (func $waitable.join (param i32 i32)))- (import "" "waitable-set.wait" (func $waitable-set.wait (param i32 i32) (result i32)))-- (func (export "f")- (local $status i32)- (local $set i32)- call $turn-on-backpressure-- (local.set $status (call $f))-- ;; low 4 bits should be "STARTING == 0"- (i32.ne- (i32.const 0)- (i32.and- (local.get $status)- (i32.const 0xf)))- if unreachable end-- ;; make a new waitable set and join our subtask into it- (local.set $set (call $waitable-set.new))- (call $waitable.join- (i32.shr_u (local.get $status) (i32.const 4))- (local.get $set))-- ;; block waiting for our task, which should deadlock (?)- (call $waitable-set.wait (local.get $set) (i32.const 0))- unreachable+ (component $B+ (import "A" (instance $A+ (export "f" (func))+ (export "turn-on-backpressure" (func))+ ))++ (core module $libc (memory (export "mem") 1))+ (core instance $libc (instantiate $libc))++ (core func $f (canon lower (func $A "f") async (memory $libc "mem")))+ (core func $turn-on-backpressure (canon lower (func $A "turn-on-backpressure")))+ (core func $waitable-set.new (canon waitable-set.new))+ (core func $waitable.join (canon waitable.join))+ (core func $waitable-set.wait (canon waitable-set.wait (memory $libc "mem")))++ (core module $m+ (import "" "f" (func $f (result i32)))+ (import "" "turn-on-backpressure" (func $turn-on-backpressure))+ (import "" "waitable-set.new" (func $waitable-set.new (result i32)))+ (import "" "waitable.join" (func $waitable.join (param i32 i32)))+ (import "" "waitable-set.wait" (func $waitable-set.wait (param i32 i32) (result i32)))++ (func (export "f")+ (local $status i32)+ (local $set i32)+ call $turn-on-backpressure++ (local.set $status (call $f))++ ;; low 4 bits should be "STARTING == 0"+ (i32.ne+ (i32.const 0)+ (i32.and+ (local.get $status)+ (i32.const 0xf)))+ if unreachable end++ ;; make a new waitable set and join our subtask into it+ (local.set $set (call $waitable-set.new))+ (call $waitable.join+ (i32.shr_u (local.get $status) (i32.const 4))+ (local.get $set))++ ;; block waiting for our task, which should deadlock (?)+ (call $waitable-set.wait (local.get $set) (i32.const 0))+ unreachable+ ))++ (core instance $i (instantiate $m+ (with "" (instance+ (export "f" (func $f))+ (export "turn-on-backpressure" (func $turn-on-backpressure))+ (export "waitable-set.new" (func $waitable-set.new))+ (export "waitable.join" (func $waitable.join))+ (export "waitable-set.wait" (func $waitable-set.wait))+ ))+ ))++ (func (export "f") async (canon lift (core func $i "f"))))- (core instance $i (instantiate $m- (with "" (instance- (export "f" (func $f))- (export "turn-on-backpressure" (func $turn-on-backpressure))- (export "waitable-set.new" (func $waitable-set.new))- (export "waitable.join" (func $waitable.join))- (export "waitable-set.wait" (func $waitable-set.wait))- ))- ))+ (instance $B (instantiate $B (with "A" (instance $A))))- (func (export "f") async (canon lift (core func $i "f")))+ (func (export "f") (alias export $B "f")))(assert_trap (invoke "f") "deadlock detected")diff --git a/tests/misc_testsuite/component-model/async/future-cancel-write-completed.wast b/tests/misc_testsuite/component-model/async/future-cancel-write-completed.wastindex 82a689baaf..40a15db92f 100644--- a/tests/misc_testsuite/component-model/async/future-cancel-write-completed.wast+++ b/tests/misc_testsuite/component-model/async/future-cancel-write-completed.wast@@ -42,55 +42,64 @@)(instance $c (instantiate $c))- (core func $new (canon future.new $f))- (core module $libc (memory (export "mem") 1))- (core instance $libc (instantiate $libc))- (core func $write (canon future.write $f async (memory $libc "mem")))- (core func $cancel (canon future.cancel-write $f))- (core func $drain (canon lower (func $c "f")))- (core module $m- (import "" "new" (func $new (result i64)))- (import "" "write" (func $write (param i32 i32) (result i32)))- (import "" "cancel" (func $cancel (param i32) (result i32)))- (import "" "drain" (func $drain (param i32)))-- (func (export "f") (result i32)- (local $read i32)- (local $write i32)- (local $new i64)-- (local.set $new (call $new))- (local.set $read (i32.wrap_i64 (local.get $new)))- (local.set $write (i32.wrap_i64 (i64.shr_u (local.get $new) (i64.const 32))))-- ;; start a write- local.get $write- i32.const 0- call $write- i32.const -1- i32.ne- if unreachable end-- ;; drain the read end- local.get $read- call $drain-- ;; cancel the write, returning the result- local.get $write- call $cancel+ (component $d+ (import "c" (instance $c+ (export "f" (func (param "x" $f)))+ ))++ (core func $new (canon future.new $f))+ (core module $libc (memory (export "mem") 1))+ (core instance $libc (instantiate $libc))+ (core func $write (canon future.write $f async (memory $libc "mem")))+ (core func $cancel (canon future.cancel-write $f))+ (core func $drain (canon lower (func $c "f")))+ (core module $m+ (import "" "new" (func $new (result i64)))+ (import "" "write" (func $write (param i32 i32) (result i32)))+ (import "" "cancel" (func $cancel (param i32) (result i32)))+ (import "" "drain" (func $drain (param i32)))++ (func (export "f") (result i32)+ (local $read i32)+ (local $write i32)+ (local $new i64)++ (local.set $new (call $new))+ (local.set $read (i32.wrap_i64 (local.get $new)))+ (local.set $write (i32.wrap_i64 (i64.shr_u (local.get $new) (i64.const 32))))++ ;; start a write+ local.get $write+ i32.const 0+ call $write+ i32.const -1+ i32.ne+ if unreachable end++ ;; drain the read end+ local.get $read+ call $drain++ ;; cancel the write, returning the result+ local.get $write+ call $cancel+ ))- )- (core instance $i (instantiate $m- (with "" (instance- (export "new" (func $new))- (export "write" (func $write))- (export "cancel" (func $cancel))- (export "drain" (func $drain))+ (core instance $i (instantiate $m+ (with "" (instance+ (export "new" (func $new))+ (export "write" (func $write))+ (export "cancel" (func $cancel))+ (export "drain" (func $drain))+ ))))- ))- (func (export "f") async (result u32) (canon lift (core func $i "f")))+ (func (export "f") async (result u32) (canon lift (core func $i "f")))+ )+ (instance $d (instantiate $d (with "c" (instance $c))))++ (func (export "f") (alias export $d "f")))(assert_return (invoke "f") (u32.const 0))diff --git a/tests/misc_testsuite/component-model/async/future-read.wast b/tests/misc_testsuite/component-model/async/future-read.wastindex ec80f85796..523dfb3f2c 100644--- a/tests/misc_testsuite/component-model/async/future-read.wast+++ b/tests/misc_testsuite/component-model/async/future-read.wast@@ -30,27 +30,35 @@)(instance $child (instantiate $child))- (type $future (future))- (core func $new (canon future.new $future))- (core func $child-run (canon lower (func $child "run")))-- (core module $m- (import "" "new" (func $new (result i64)))- (import "" "child-run" (func $child-run (param i32)))-- (func (export "run")- (call $child-run (i32.wrap_i64 (call $new)))+ (component $other-child+ (type $future (future))+ (import "child" (instance $child+ (export "run" (func async (param "x" $future)))+ ))++ (core func $new (canon future.new $future))+ (core func $child-run (canon lower (func $child "run")))+ (core module $m+ (import "" "new" (func $new (result i64)))+ (import "" "child-run" (func $child-run (param i32)))++ (func (export "run")+ (call $child-run (i32.wrap_i64 (call $new)))+ ))- )- (core instance $i (instantiate $m- (with "" (instance- (export "new" (func $new))- (export "child-run" (func $child-run))+ (core instance $i (instantiate $m+ (with "" (instance+ (export "new" (func $new))+ (export "child-run" (func $child-run))+ ))))- ))++ (func (export "run") async+ (canon lift (core func $i "run")))+ )+ (instance $other-child (instantiate $other-child (with "child" (instance $child))))- (func (export "run") async- (canon lift (core func $i "run")))+ (func (export "run") (alias export $other-child "run")));; We expect deadlock since the write end is leaked:@@ -83,27 +91,35 @@)(instance $child (instantiate $child))- (type $future (future))- (core func $new (canon future.new $future))- (core func $child-run (canon lower (func $child "run")))-- (core module $m- (import "" "new" (func $new (result i64)))- (import "" "child-run" (func $child-run (param i32)))-- (func (export "run")- (call $child-run (i32.wrap_i64 (call $new)))+ (component $other-child+ (type $future (future))+ (import "child" (instance $child+ (export "run" (func (param "x" $future)))+ ))+ (core func $new (canon future.new $future))+ (core func $child-run (canon lower (func $child "run")))++ (core module $m+ (import "" "new" (func $new (result i64)))+ (import "" "child-run" (func $child-run (param i32)))++ (func (export "run")+ (call $child-run (i32.wrap_i64 (call $new)))+ ))- )- (core instance $i (instantiate $m- (with "" (instance- (export "new" (func $new))- (export "child-run" (func $child-run))+ (core instance $i (instantiate $m+ (with "" (instance+ (export "new" (func $new))+ (export "child-run" (func $child-run))+ ))))- ))++ (func (export "run")+ (canon lift (core func $i "run")))+ )+ (instance $other-child (instantiate $other-child (with "child" (instance $child))))- (func (export "run")- (canon lift (core func $i "run")))+ (func (export "run") (alias export $other-child "run")))(assert_return (invoke "run"))@@ -139,27 +155,35 @@)(instance $child (instantiate $child))- (type $future (future))- (core func $new (canon future.new $future))- (core func $child-run (canon lower (func $child "run")))-- (core module $m- (import "" "new" (func $new (result i64)))- (import "" "child-run" (func $child-run (param i32)))-- (func (export "run")- (call $child-run (i32.wrap_i64 (call $new)))+ (component $other-child+ (type $future (future))+ (import "child" (instance $child+ (export "run" (func async (param "x" $future)))+ ))+ (core func $new (canon future.new $future))+ (core func $child-run (canon lower (func $child "run")))++ (core module $m+ (import "" "new" (func $new (result i64)))+ (import "" "child-run" (func $child-run (param i32)))++ (func (export "run")+ (call $child-run (i32.wrap_i64 (call $new)))+ ))- )- (core instance $i (instantiate $m- (with "" (instance- (export "new" (func $new))- (export "child-run" (func $child-run))+ (core instance $i (instantiate $m+ (with "" (instance+ (export "new" (func $new))+ (export "child-run" (func $child-run))+ ))))- ))++ (func (export "run") async+ (canon lift (core func $i "run")))+ )+ (instance $other-child (instantiate $other-child (with "child" (instance $child))))- (func (export "run") async- (canon lift (core func $i "run")))+ (func (export "run") (alias export $other-child "run")));; We expect deadlock since the write end is leaked:@@ -200,27 +224,35 @@)(instance $child (instantiate $child))- (type $future (future))- (core func $new (canon future.new $future))- (core func $child-run (canon lower (func $child "run")))-- (core module $m- (import "" "new" (func $new (result i64)))- (import "" "child-run" (func $child-run (param i32)))-- (func (export "run")- (call $child-run (i32.wrap_i64 (call $new)))+ (component $other-child+ (type $future (future))+ (import "child" (instance $child+ (export "run" (func (param "x" $future)))+ ))+ (core func $new (canon future.new $future))+ (core func $child-run (canon lower (func $child "run")))++ (core module $m+ (import "" "new" (func $new (result i64)))+ (import "" "child-run" (func $child-run (param i32)))++ (func (export "run")+ (call $child-run (i32.wrap_i64 (call $new)))+ ))- )- (core instance $i (instantiate $m- (with "" (instance- (export "new" (func $new))- (export "child-run" (func $child-run))+ (core instance $i (instantiate $m+ (with "" (instance+ (export "new" (func $new))+ (export "child-run" (func $child-run))+ ))))- ))++ (func (export "run") async+ (canon lift (core func $i "run")))+ )+ (instance $other-child (instantiate $other-child (with "child" (instance $child))))- (func (export "run") async- (canon lift (core func $i "run")))+ (func (export "run") (alias export $other-child "run")))(assert_return (invoke "run"))diff --git a/tests/misc_testsuite/component-model/async/reenter-during-yield.wast b/tests/misc_testsuite/component-model/async/reenter-during-yield.wastnew file mode 100644index 0000000000..61fcb12ae1--- /dev/null+++ b/tests/misc_testsuite/component-model/async/reenter-during-yield.wast@@ -0,0 +1,82 @@+;;! component_model_async = true+;;! reference_types = true+;;! gc_types = true+;;! multi_memory = true++(component+ (component $a+ (core module $a+ (import "" "yield" (func $yield (result i32)))++ (func (export "yield-loop") (result i32)+ ;; simulate `waitable-set.poll` with a yield loop+ (loop+ call $yield+ drop+ br 0+ )+ unreachable+ )++ ;; not reached+ (func (export "callback") (param i32 i32 i32) (result i32) unreachable)++ (func (export "noop"))+ )+ (core func $yield (canon thread.yield))+ (core instance $a (instantiate $a+ (with "" (instance+ (export "yield" (func $yield))+ ))+ ))+ (func (export "yield-loop") async+ (canon lift+ (core func $a "yield-loop")+ async+ (callback (func $a "callback"))+ )+ )+ (func (export "noop") (canon lift (core func $a "noop")))+ )+ (instance $a (instantiate $a))++ (component $b+ (import "yield-loop" (func $yield-loop async))+ (import "noop" (func $noop))++ (core func $yield-loop (canon lower (func $yield-loop) async))+ (core func $noop (canon lower (func $noop)))++ (core module $b+ (import "" "yield-loop" (func $yield-loop (result i32)))+ (import "" "noop" (func $noop))++ (func (export "run")+ ;; call `yield-loop`, double-check it's in the "started" state.+ call $yield-loop+ i32.const 0xf+ i32.and+ i32.const 1+ i32.ne+ if unreachable end++ ;; now try to reenter the other component with some other function.+ call $noop+ )+ )+ (core instance $b (instantiate $b+ (with "" (instance+ (export "yield-loop" (func $yield-loop))+ (export "noop" (func $noop))+ ))+ ))+ (func (export "run") async (canon lift (core func $b "run")))+ )+ (instance $b (instantiate $b+ (with "yield-loop" (func $a "yield-loop"))+ (with "noop" (func $a "noop"))+ ))+ (export "run" (func $b "run"))+)++(assert_return (invoke "run"))diff --git a/tests/misc_testsuite/component-model/async/wait-forever.wast b/tests/misc_testsuite/component-model/async/wait-forever.wastindex 7f73f2ee99..718fd3142d 100644--- a/tests/misc_testsuite/component-model/async/wait-forever.wast+++ b/tests/misc_testsuite/component-model/async/wait-forever.wast@@ -35,22 +35,30 @@)(instance $child (instantiate $child))- (core func $child-run (canon lower (func $child "run")))-- (core module $m- (import "" "child-run" (func $child-run))-- (func (export "run")- (call $child-run))- )- (core instance $i (instantiate $m- (with "" (instance- (export "child-run" (func $child-run))+ (component $other-child+ (import "child" (instance $child+ (export "run" (func async))))- ))++ (core func $child-run (canon lower (func $child "run")))+ (core module $m+ (import "" "child-run" (func $child-run))++ (func (export "run")+ (call $child-run))+ )+ (core instance $i (instantiate $m+ (with "" (instance+ (export "child-run" (func $child-run))+ ))+ ))++ (func (export "run") async+ (canon lift (core func $i "run")))+ )+ (instance $other-child (instantiate $other-child (with "child" (instance $child))))- (func (export "run") async- (canon lift (core func $i "run")))+ (func (export "run") (alias export $other-child "run")))(assert_trap (invoke "run") "deadlock detected")