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

* 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 <[email protected]>

---------

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

Author: alexcrichton

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(),
                         });

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 });
         }
     }
 }

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!(),
                     },

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!(),
                     },

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()
         };