Update support for p3 to match the latest wasm-tools (#1198)

alexcrichton · dicej · web-flow · commit 1d8cbb92b7ae · 2025-03-07T18:35:25.000Z
* Update wasm-tools dependencies

* Fixes from wasm-tools update to p3 support

Fix the name and signature of various intrinsics in the Rust bindings
generator for p3 support. This is detected by updating wasm-tools in the
wasip3-prototyping repository which requires changes here.

* minimal stub of waitable-set support

This is temporary (and relies on the host to ignore the waitable-set parameter)
until we have proper waitable-set support, which I'll work on soon.

Signed-off-by: Joel Dice &lt;joel.dice@fermyon.com&gt;

---------

Signed-off-by: Joel Dice &lt;joel.dice@fermyon.com&gt;
Co-authored-by: Joel Dice &lt;joel.dice@fermyon.com&gt;
diff --git a/crates/core/src/abi.rs b/crates/core/src/abi.rs
@@ -985,7 +985,7 @@ impl<'a, B: Bindgen> Generator<'a, B> {
 
                         assert_eq!(self.stack.len(), 2);
                         self.emit(&Instruction::AsyncCallWasm {
-                            name: &format!("[async]{}", func.name),
+                            name: &format!("[async-lower]{}", func.name),
                             size: params_size.size_wasm32(),
                             align: params_align.align_wasm32(),
                         });
diff --git a/crates/guest-rust/rt/src/async_support.rs b/crates/guest-rust/rt/src/async_support.rs
@@ -388,7 +388,7 @@ impl ErrorContext {
         {
             #[link(wasm_import_module = "$root")]
             extern "C" {
-                #[link_name = "[error-context-new;encoding=utf8]"]
+                #[link_name = "[error-context-new-utf8]"]
                 fn context_new(_: *const u8, _: usize) -> i32;
             }
 
@@ -427,7 +427,7 @@ impl ErrorContext {
             }
             #[link(wasm_import_module = "$root")]
             extern "C" {
-                #[link_name = "[error-context-debug-message;encoding=utf8;realloc=cabi_realloc]"]
+                #[link_name = "[error-context-debug-message-utf8]"]
                 fn error_context_debug_message(_: u32, _: &mut RetPtr);
             }
 
@@ -484,7 +484,7 @@ pub fn spawn(future: impl Future<Output = ()> + 'static) {
     unsafe { SPAWNED.push(Box::pin(future)) }
 }
 
-fn task_wait(state: &mut FutureState) {
+fn waitable_set_wait(state: &mut FutureState) {
     #[cfg(not(target_arch = "wasm32"))]
     {
         _ = state;
@@ -495,21 +495,22 @@ fn task_wait(state: &mut FutureState) {
     {
         #[link(wasm_import_module = "$root")]
         extern "C" {
-            #[link_name = "[task-wait]"]
-            fn wait(_: *mut i32) -> i32;
+            #[link_name = "[waitable-set-wait]"]
+            fn wait(_: u32, _: *mut i32) -> i32;
         }
         let mut payload = [0i32; 2];
         unsafe {
-            let event0 = wait(payload.as_mut_ptr());
+            // TODO: provide a real waitable-set here:
+            let event0 = wait(0, payload.as_mut_ptr());
             callback(state as *mut _ as _, event0, payload[0], payload[1]);
         }
     }
 }
 
 /// Run the specified future to completion, returning the result.
 ///
-/// This uses `task.wait` to poll for progress on any in-progress calls to
-/// async-lowered imports as necessary.
+/// This uses `waitable-set.wait` to poll for progress on any in-progress calls
+/// to async-lowered imports as necessary.
 // TODO: refactor so `'static` bounds aren't necessary
 pub fn block_on<T: 'static>(future: impl Future<Output = T> + 'static) -> T {
     let (tx, mut rx) = oneshot::channel();
@@ -524,12 +525,12 @@ pub fn block_on<T: 'static>(future: impl Future<Output = T> + 'static) -> T {
     loop {
         match unsafe { poll(state) } {
             Poll::Ready(()) => break rx.try_recv().unwrap().unwrap(),
-            Poll::Pending => task_wait(state),
+            Poll::Pending => waitable_set_wait(state),
         }
     }
 }
 
-/// Call the `task.yield` canonical built-in function.
+/// Call the `yield` canonical built-in function.
 ///
 /// This yields control to the host temporarily, allowing other tasks to make
 /// progress.  It's a good idea to call this inside a busy loop which does not
@@ -544,7 +545,7 @@ pub fn task_yield() {
     {
         #[link(wasm_import_module = "$root")]
         extern "C" {
-            #[link_name = "[task-yield]"]
+            #[link_name = "[yield]"]
             fn yield_();
         }
         unsafe {
@@ -553,12 +554,12 @@ pub fn task_yield() {
     }
 }
 
-/// Call the `task.backpressure` canonical built-in function.
+/// Call the `backpressure.set` canonical built-in function.
 ///
 /// When `enabled` is `true`, this tells the host to defer any new calls to this
-/// component instance until further notice (i.e. until `task.backpressure` is
+/// component instance until further notice (i.e. until `backpressure.set` is
 /// called again with `enabled` set to `false`).
-pub fn task_backpressure(enabled: bool) {
+pub fn backpressure_set(enabled: bool) {
     #[cfg(not(target_arch = "wasm32"))]
     {
         _ = enabled;
@@ -569,11 +570,11 @@ pub fn task_backpressure(enabled: bool) {
     {
         #[link(wasm_import_module = "$root")]
         extern "C" {
-            #[link_name = "[task-backpressure]"]
-            fn backpressure(_: i32);
+            #[link_name = "[backpressure-set]"]
+            fn backpressure_set(_: i32);
         }
         unsafe {
-            backpressure(if enabled { 1 } else { 0 });
+            backpressure_set(if enabled { 1 } else { 0 });
         }
     }
 }
diff --git a/crates/guest-rust/rt/src/async_support/future_support.rs b/crates/guest-rust/rt/src/async_support/future_support.rs
@@ -25,7 +25,7 @@ pub struct FutureVtable<T> {
     pub cancel_write: unsafe extern "C" fn(future: u32) -> u32,
     pub cancel_read: unsafe extern "C" fn(future: u32) -> u32,
     pub close_writable: unsafe extern "C" fn(future: u32, err_ctx: u32),
-    pub close_readable: unsafe extern "C" fn(future: u32),
+    pub close_readable: unsafe extern "C" fn(future: u32, err_ctx: u32),
     pub new: unsafe extern "C" fn() -> u32,
 }
 
@@ -418,7 +418,9 @@ impl<T> Drop for FutureReader<T> {
                         }
                         Handle::Read | Handle::LocalClosed => unsafe {
                             entry.remove();
-                            (self.vtable.close_readable)(handle);
+                            // TODO: expose `0` here as an error context in the
+                            // API (or auto-fill-in? unsure).
+                            (self.vtable.close_readable)(handle, 0);
                         },
                         Handle::Write | Handle::WriteClosedErr(_) => unreachable!(),
                     },
diff --git a/crates/guest-rust/rt/src/async_support/stream_support.rs b/crates/guest-rust/rt/src/async_support/stream_support.rs
@@ -38,7 +38,7 @@ pub struct StreamVtable<T> {
     pub cancel_write: unsafe extern "C" fn(future: u32) -> u32,
     pub cancel_read: unsafe extern "C" fn(future: u32) -> u32,
     pub close_writable: unsafe extern "C" fn(future: u32, err_ctx: u32),
-    pub close_readable: unsafe extern "C" fn(future: u32),
+    pub close_readable: unsafe extern "C" fn(future: u32, err_ctx: u32),
     pub new: unsafe extern "C" fn() -> u32,
 }
 
@@ -487,7 +487,9 @@ impl<T> Drop for StreamReader<T> {
                         }
                         Handle::Read | Handle::LocalClosed => unsafe {
                             entry.remove();
-                            (self.vtable.close_readable)(handle);
+                            // TODO: expose `0` here as an error context in the
+                            // API (or auto-fill-in? unsure).
+                            (self.vtable.close_readable)(handle, 0);
                         },
                         Handle::Write | Handle::WriteClosedErr(_) => unreachable!(),
                     },
diff --git a/crates/rust/src/interface.rs b/crates/rust/src/interface.rs
@@ -578,7 +578,7 @@ pub mod vtable{ordinal} {{
     #[cfg(not(target_arch = "wasm32"))]
     unsafe extern "C" fn close_writable(_: u32, _: u32) {{ unreachable!() }}
     #[cfg(not(target_arch = "wasm32"))]
-    unsafe extern "C" fn close_readable(_: u32) {{ unreachable!() }}
+    unsafe extern "C" fn close_readable(_: u32, _: u32) {{ unreachable!() }}
     #[cfg(not(target_arch = "wasm32"))]
     unsafe extern "C" fn new() -> u32 {{ unreachable!() }}
     #[cfg(not(target_arch = "wasm32"))]
@@ -598,12 +598,10 @@ pub mod vtable{ordinal} {{
         #[link_name = "[future-close-writable-{index}]{func_name}"]
         fn close_writable(_: u32, _: u32);
         #[link_name = "[future-close-readable-{index}]{func_name}"]
-        fn close_readable(_: u32);
-        #[link_name = "[future-new-{index}]{func_name}"]
-        fn new() -> u32;
-        #[link_name = "[async][future-read-{index}]{func_name}"]
+        fn close_readable(_: u32, _: u32);
+        #[link_name = "[async-lower][future-read-{index}]{func_name}"]
         fn start_read(_: u32, _: *mut u8) -> u32;
-        #[link_name = "[async][future-write-{index}]{func_name}"]
+        #[link_name = "[async-lower][future-write-{index}]{func_name}"]
         fn start_write(_: u32, _: *mut u8) -> u32;
     }}
 
@@ -762,7 +760,7 @@ pub mod vtable{ordinal} {{
     #[cfg(not(target_arch = "wasm32"))]
     unsafe extern "C" fn close_writable(_: u32, _: u32) {{ unreachable!() }}
     #[cfg(not(target_arch = "wasm32"))]
-    unsafe extern "C" fn close_readable(_: u32) {{ unreachable!() }}
+    unsafe extern "C" fn close_readable(_: u32, _: u32) {{ unreachable!() }}
     #[cfg(not(target_arch = "wasm32"))]
     unsafe extern "C" fn new() -> u32 {{ unreachable!() }}
     #[cfg(not(target_arch = "wasm32"))]
@@ -782,12 +780,10 @@ pub mod vtable{ordinal} {{
         #[link_name = "[stream-close-writable-{index}]{func_name}"]
         fn close_writable(_: u32, _: u32);
         #[link_name = "[stream-close-readable-{index}]{func_name}"]
-        fn close_readable(_: u32);
-        #[link_name = "[stream-new-{index}]{func_name}"]
-        fn new() -> u32;
-        #[link_name = "[async][stream-read-{index}]{func_name}"]
+        fn close_readable(_: u32, _: u32);
+        #[link_name = "[async-lower][stream-read-{index}]{func_name}"]
         fn start_read(_: u32, _: *mut u8, _: u32) -> u32;
-        #[link_name = "[async][stream-write-{index}]{func_name}"]
+        #[link_name = "[async-lower][stream-write-{index}]{func_name}"]
         fn start_write(_: u32, _: *mut u8, _: u32) -> u32;
     }}
 
@@ -817,7 +813,7 @@ pub mod vtable{ordinal} {{
             return;
         }
 
-        self.generate_payloads("[import-payload]", func, interface);
+        self.generate_payloads("", func, interface);
 
         let async_ = match &self.gen.opts.async_ {
             AsyncConfig::None => false,
@@ -924,7 +920,7 @@ pub mod vtable{ordinal} {{
     ) {
         let name_snake = func.name.to_snake_case().replace('.', "_");
 
-        self.generate_payloads("[export-payload]", func, interface);
+        self.generate_payloads("[export]", func, interface);
 
         uwrite!(
             self.src,
@@ -1051,7 +1047,7 @@ pub mod vtable{ordinal} {{
         let export_prefix = self.gen.opts.export_prefix.as_deref().unwrap_or("");
         let export_name = func.legacy_core_export_name(wasm_module_export_name.as_deref());
         let export_name = if async_ {
-            format!("[async]{export_name}")
+            format!("[async-lift]{export_name}")
         } else {
             export_name.to_string()
         };

Original file line number	Diff line number	Diff line change
`@@ -388,7 +388,7 @@ impl ErrorContext {`
`388`	`388`	`{`
`389`	`389`	`#[link(wasm_import_module = "$root")]`
`390`	`390`	`extern "C" {`
`391`		`- #[link_name = "[error-context-new;encoding=utf8]"]`
	`391`	`+ #[link_name = "[error-context-new-utf8]"]`
`392`	`392`	`fn context_new(_: *const u8, _: usize) -> i32;`
`393`	`393`	`}`
`394`	`394`
`@@ -427,7 +427,7 @@ impl ErrorContext {`
`427`	`427`	`}`
`428`	`428`	`#[link(wasm_import_module = "$root")]`
`429`	`429`	`extern "C" {`
`430`		`- #[link_name = "[error-context-debug-message;encoding=utf8;realloc=cabi_realloc]"]`
	`430`	`+ #[link_name = "[error-context-debug-message-utf8]"]`
`431`	`431`	`fn error_context_debug_message(_: u32, _: &mut RetPtr);`
`432`	`432`	`}`
`433`	`433`
`@@ -484,7 +484,7 @@ pub fn spawn(future: impl Future<Output = ()> + 'static) {`
`484`	`484`	`unsafe { SPAWNED.push(Box::pin(future)) }`
`485`	`485`	`}`
`486`	`486`
`487`		`-fn task_wait(state: &mut FutureState) {`
	`487`	`+fn waitable_set_wait(state: &mut FutureState) {`
`488`	`488`	`#[cfg(not(target_arch = "wasm32"))]`
`489`	`489`	`{`
`490`	`490`	`_ = state;`
`@@ -495,21 +495,22 @@ fn task_wait(state: &mut FutureState) {`
`495`	`495`	`{`
`496`	`496`	`#[link(wasm_import_module = "$root")]`
`497`	`497`	`extern "C" {`
`498`		`- #[link_name = "[task-wait]"]`
`499`		`- fn wait(_: *mut i32) -> i32;`
	`498`	`+ #[link_name = "[waitable-set-wait]"]`
	`499`	`+ fn wait(_: u32, _: *mut i32) -> i32;`
`500`	`500`	`}`
`501`	`501`	`let mut payload = [0i32; 2];`
`502`	`502`	`unsafe {`
`503`		`- let event0 = wait(payload.as_mut_ptr());`
	`503`	`+ // TODO: provide a real waitable-set here:`
	`504`	`+ let event0 = wait(0, payload.as_mut_ptr());`
`504`	`505`	`callback(state as *mut _ as _, event0, payload[0], payload[1]);`
`505`	`506`	`}`
`506`	`507`	`}`
`507`	`508`	`}`
`508`	`509`
`509`	`510`	`/// Run the specified future to completion, returning the result.`
`510`	`511`	`///`
`511`		-/// This uses `task.wait` to poll for progress on any in-progress calls to
`512`		`-/// async-lowered imports as necessary.`
	`512`	+/// This uses `waitable-set.wait` to poll for progress on any in-progress calls
	`513`	`+/// to async-lowered imports as necessary.`
`513`	`514`	// TODO: refactor so `'static` bounds aren't necessary
`514`	`515`	`pub fn block_on<T: 'static>(future: impl Future<Output = T> + 'static) -> T {`
`515`	`516`	`let (tx, mut rx) = oneshot::channel();`
`@@ -524,12 +525,12 @@ pub fn block_on<T: 'static>(future: impl Future<Output = T> + 'static) -> T {`
`524`	`525`	`loop {`
`525`	`526`	`match unsafe { poll(state) } {`
`526`	`527`	`Poll::Ready(()) => break rx.try_recv().unwrap().unwrap(),`
`527`		`- Poll::Pending => task_wait(state),`
	`528`	`+ Poll::Pending => waitable_set_wait(state),`
`528`	`529`	`}`
`529`	`530`	`}`
`530`	`531`	`}`
`531`	`532`
`532`		-/// Call the `task.yield` canonical built-in function.
	`533`	+/// Call the `yield` canonical built-in function.
`533`	`534`	`///`
`534`	`535`	`/// This yields control to the host temporarily, allowing other tasks to make`
`535`	`536`	`/// progress. It's a good idea to call this inside a busy loop which does not`
`@@ -544,7 +545,7 @@ pub fn task_yield() {`
`544`	`545`	`{`
`545`	`546`	`#[link(wasm_import_module = "$root")]`
`546`	`547`	`extern "C" {`
`547`		`- #[link_name = "[task-yield]"]`
	`548`	`+ #[link_name = "[yield]"]`
`548`	`549`	`fn yield_();`
`549`	`550`	`}`
`550`	`551`	`unsafe {`
`@@ -553,12 +554,12 @@ pub fn task_yield() {`
`553`	`554`	`}`
`554`	`555`	`}`
`555`	`556`
`556`		-/// Call the `task.backpressure` canonical built-in function.
	`557`	+/// Call the `backpressure.set` canonical built-in function.
`557`	`558`	`///`
`558`	`559`	/// When `enabled` is `true`, this tells the host to defer any new calls to this
`559`		-/// component instance until further notice (i.e. until `task.backpressure` is
	`560`	+/// component instance until further notice (i.e. until `backpressure.set` is
`560`	`561`	/// called again with `enabled` set to `false`).
`561`		`-pub fn task_backpressure(enabled: bool) {`
	`562`	`+pub fn backpressure_set(enabled: bool) {`
`562`	`563`	`#[cfg(not(target_arch = "wasm32"))]`
`563`	`564`	`{`
`564`	`565`	`_ = enabled;`
`@@ -569,11 +570,11 @@ pub fn task_backpressure(enabled: bool) {`
`569`	`570`	`{`
`570`	`571`	`#[link(wasm_import_module = "$root")]`
`571`	`572`	`extern "C" {`
`572`		`- #[link_name = "[task-backpressure]"]`
`573`		`- fn backpressure(_: i32);`
	`573`	`+ #[link_name = "[backpressure-set]"]`
	`574`	`+ fn backpressure_set(_: i32);`
`574`	`575`	`}`
`575`	`576`	`unsafe {`
`576`		`- backpressure(if enabled { 1 } else { 0 });`
	`577`	`+ backpressure_set(if enabled { 1 } else { 0 });`
`577`	`578`	`}`
`578`	`579`	`}`
`579`	`580`	`}`