Simplify extern definitions for intrinsics

Deduplicate host panicking shim definitions with the wasm definitions.

Author: alexcrichton

crates/guest-rust/src/rt/async_support.rs

@@ -21,7 +21,35 @@ macro_rules! rtdebug {
             std::eprintln!($($f)*);
         }
     }
+}
+
+macro_rules! extern_wasm {
+    (
+        $(#[$extern_attr:meta])*
+        extern "C" {
+            $(
+                $(#[$func_attr:meta])*
+                $vis:vis fn $func_name:ident ( $($args:tt)* ) $(-> $ret:ty)?;
+            )*
+        }
+    ) => {
+        $(
+            #[cfg(not(target_family = "wasm"))]
+            #[allow(unused)]
+            $vis unsafe fn $func_name($($args)*) $(-> $ret)? {
+                unreachable!();
+            }
+        )*
 
+        #[cfg(target_family = "wasm")]
+        $(#[$extern_attr])*
+        extern "C" {
+            $(
+                $(#[$func_attr])*
+                $vis fn $func_name($($args)*) $(-> $ret)?;
+            )*
+        }
+    };
 }
 
 mod abi_buffer;
@@ -447,17 +475,14 @@ pub fn block_on<T: 'static>(future: impl Future<Output = T>) -> T {
 /// at this yield point. The caller should return back and exit from the task
 /// ASAP in this situation.
 pub fn yield_blocking() -> bool {
-    #[cfg(not(target_arch = "wasm32"))]
-    unsafe fn yield_() -> bool {
-        unreachable!();
+    extern_wasm! {
+        #[link(wasm_import_module = "$root")]
+        extern "C" {
+            #[link_name = "[thread-yield]"]
+            fn yield_() -> bool;
+        }
     }
 
-    #[cfg(target_arch = "wasm32")]
-    #[link(wasm_import_module = "$root")]
-    extern "C" {
-        #[link_name = "[thread-yield]"]
-        fn yield_() -> bool;
-    }
     // Note that the return value from the raw intrinsic is inverted, the
     // canonical ABI returns "did this task get cancelled" while this function
     // works as "should work continue going".
@@ -508,82 +533,62 @@ pub async fn yield_async() {
 /// called again with `enabled` set to `false`).
 #[deprecated = "use backpressure_{inc,dec} instead"]
 pub fn backpressure_set(enabled: bool) {
-    #[cfg(not(target_arch = "wasm32"))]
-    unsafe fn backpressure_set(_: i32) {
-        unreachable!();
-    }
-
-    #[cfg(target_arch = "wasm32")]
-    #[link(wasm_import_module = "$root")]
-    extern "C" {
-        #[link_name = "[backpressure-set]"]
-        fn backpressure_set(_: i32);
+    extern_wasm! {
+        #[link(wasm_import_module = "$root")]
+        extern "C" {
+            #[link_name = "[backpressure-set]"]
+            fn backpressure_set(_: i32);
+        }
     }
 
     unsafe { backpressure_set(if enabled { 1 } else { 0 }) }
 }
 
 /// Call the `backpressure.inc` canonical built-in function.
 pub fn backpressure_inc() {
-    #[cfg(not(target_arch = "wasm32"))]
-    unsafe fn backpressure_inc() {
-        unreachable!();
-    }
-
-    #[cfg(target_arch = "wasm32")]
-    #[link(wasm_import_module = "$root")]
-    extern "C" {
-        #[link_name = "[backpressure-inc]"]
-        fn backpressure_inc();
+    extern_wasm! {
+        #[link(wasm_import_module = "$root")]
+        extern "C" {
+            #[link_name = "[backpressure-inc]"]
+            fn backpressure_inc();
+        }
     }
 
     unsafe { backpressure_inc() }
 }
 
 /// Call the `backpressure.dec` canonical built-in function.
 pub fn backpressure_dec() {
-    #[cfg(not(target_arch = "wasm32"))]
-    unsafe fn backpressure_dec() {
-        unreachable!();
-    }
-
-    #[cfg(target_arch = "wasm32")]
-    #[link(wasm_import_module = "$root")]
-    extern "C" {
-        #[link_name = "[backpressure-dec]"]
-        fn backpressure_dec();
+    extern_wasm! {
+        #[link(wasm_import_module = "$root")]
+        extern "C" {
+            #[link_name = "[backpressure-dec]"]
+            fn backpressure_dec();
+        }
     }
 
     unsafe { backpressure_dec() }
 }
 
 fn context_get() -> *mut u8 {
-    #[cfg(not(target_arch = "wasm32"))]
-    unsafe fn get() -> *mut u8 {
-        unreachable!()
-    }
-
-    #[cfg(target_arch = "wasm32")]
-    #[link(wasm_import_module = "$root")]
-    extern "C" {
-        #[link_name = "[context-get-0]"]
-        fn get() -> *mut u8;
+    extern_wasm! {
+        #[link(wasm_import_module = "$root")]
+        extern "C" {
+            #[link_name = "[context-get-0]"]
+            fn get() -> *mut u8;
+        }
     }
 
     unsafe { get() }
 }
 
 unsafe fn context_set(value: *mut u8) {
-    #[cfg(not(target_arch = "wasm32"))]
-    unsafe fn set(_: *mut u8) {
-        unreachable!()
-    }
-
-    #[cfg(target_arch = "wasm32")]
-    #[link(wasm_import_module = "$root")]
-    extern "C" {
-        #[link_name = "[context-set-0]"]
-        fn set(value: *mut u8);
+    extern_wasm! {
+        #[link(wasm_import_module = "$root")]
+        extern "C" {
+            #[link_name = "[context-set-0]"]
+            fn set(value: *mut u8);
+        }
     }
 
     unsafe { set(value) }
@@ -608,16 +613,12 @@ impl TaskCancelOnDrop {
 
 impl Drop for TaskCancelOnDrop {
     fn drop(&mut self) {
-        #[cfg(not(target_arch = "wasm32"))]
-        unsafe fn cancel() {
-            unreachable!()
-        }
-
-        #[cfg(target_arch = "wasm32")]
-        #[link(wasm_import_module = "[export]$root")]
-        extern "C" {
-            #[link_name = "[task-cancel]"]
-            fn cancel();
+        extern_wasm! {
+            #[link(wasm_import_module = "[export]$root")]
+            extern "C" {
+                #[link_name = "[task-cancel]"]
+                fn cancel();
+            }
         }
 
         unsafe { cancel() }

crates/guest-rust/src/rt/async_support/cabi.rs

@@ -46,26 +46,21 @@
 
 use core::ffi::c_void;
 
-#[cfg(target_family = "wasm")]
-extern "C" {
-    /// Sets the global task pointer to `ptr` provided. Returns the previous
-    /// value.
-    ///
-    /// This function acts as a dual getter and a setter. To get the
-    /// current task pointer a dummy `ptr` can be provided (e.g. NULL) and then
-    /// it's passed back when you're done working with it. When setting the
-    /// current task pointer it's recommended to call this and then call it
-    /// again with the previous value when the tasks's work is done.
-    ///
-    /// For executors they need to ensure that the `ptr` passed in lives for
-    /// the entire lifetime of the component model task.
-    pub fn wasip3_task_set(ptr: *mut wasip3_task) -> *mut wasip3_task;
-}
-
-#[cfg(not(target_family = "wasm"))]
-pub unsafe extern "C" fn wasip3_task_set(ptr: *mut wasip3_task) -> *mut wasip3_task {
-    let _ = ptr;
-    unreachable!();
+extern_wasm! {
+    extern "C" {
+        /// Sets the global task pointer to `ptr` provided. Returns the previous
+        /// value.
+        ///
+        /// This function acts as a dual getter and a setter. To get the
+        /// current task pointer a dummy `ptr` can be provided (e.g. NULL) and then
+        /// it's passed back when you're done working with it. When setting the
+        /// current task pointer it's recommended to call this and then call it
+        /// again with the previous value when the tasks's work is done.
+        ///
+        /// For executors they need to ensure that the `ptr` passed in lives for
+        /// the entire lifetime of the component model task.
+        pub fn wasip3_task_set(ptr: *mut wasip3_task) -> *mut wasip3_task;
+    }
 }
 
 /// The first version of `wasip3_task` which implies the existence of the

crates/guest-rust/src/rt/async_support/error_context.rs

@@ -60,10 +60,7 @@ impl std::error::Error for ErrorContext {}
 
 impl Drop for ErrorContext {
     fn drop(&mut self) {
-        #[cfg(target_arch = "wasm32")]
-        unsafe {
-            drop(self.handle)
-        }
+        unsafe { drop(self.handle) }
     }
 }
 
@@ -73,22 +70,14 @@ struct RetPtr {
     len: usize,
 }
 
-#[cfg(not(target_arch = "wasm32"))]
-unsafe fn new(_: *const u8, _: usize) -> u32 {
-    unreachable!()
-}
-#[cfg(not(target_arch = "wasm32"))]
-fn debug_message(_: u32, _: &mut RetPtr) {
-    unreachable!()
-}
-
-#[cfg(target_arch = "wasm32")]
-#[link(wasm_import_module = "$root")]
-extern "C" {
-    #[link_name = "[error-context-new-utf8]"]
-    fn new(_: *const u8, _: usize) -> u32;
-    #[link_name = "[error-context-drop]"]
-    fn drop(_: u32);
-    #[link_name = "[error-context-debug-message-utf8]"]
-    fn debug_message(_: u32, _: &mut RetPtr);
+extern_wasm! {
+    #[link(wasm_import_module = "$root")]
+    extern "C" {
+        #[link_name = "[error-context-new-utf8]"]
+        fn new(_: *const u8, _: usize) -> u32;
+        #[link_name = "[error-context-drop]"]
+        fn drop(_: u32);
+        #[link_name = "[error-context-debug-message-utf8]"]
+        fn debug_message(_: u32, _: &mut RetPtr);
+    }
 }

crates/guest-rust/src/rt/async_support/subtask.rs

@@ -273,21 +273,12 @@ impl<T: Subtask> InProgress<T> {
     }
 }
 
-#[cfg(not(target_arch = "wasm32"))]
-unsafe fn drop(_: u32) {
-    unreachable!()
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-unsafe fn cancel(_: u32) -> u32 {
-    unreachable!()
-}
-
-#[cfg(target_arch = "wasm32")]
-#[link(wasm_import_module = "$root")]
-extern "C" {
-    #[link_name = "[subtask-cancel]"]
-    fn cancel(handle: u32) -> u32;
-    #[link_name = "[subtask-drop]"]
-    fn drop(handle: u32);
+extern_wasm! {
+    #[link(wasm_import_module = "$root")]
+    extern "C" {
+        #[link_name = "[subtask-cancel]"]
+        fn cancel(handle: u32) -> u32;
+        #[link_name = "[subtask-drop]"]
+        fn drop(handle: u32);
+    }
 }

crates/guest-rust/src/rt/async_support/waitable_set.rs

@@ -63,38 +63,18 @@ impl Drop for WaitableSet {
     }
 }
 
-#[cfg(not(target_arch = "wasm32"))]
-unsafe fn new() -> u32 {
-    unreachable!()
-}
-#[cfg(not(target_arch = "wasm32"))]
-unsafe fn drop(_: u32) {
-    unreachable!()
-}
-#[cfg(not(target_arch = "wasm32"))]
-unsafe fn join(_: u32, _: u32) {
-    unreachable!()
-}
-#[cfg(not(target_arch = "wasm32"))]
-unsafe fn wait(_: u32, _: *mut [u32; 2]) -> u32 {
-    unreachable!();
-}
-#[cfg(not(target_arch = "wasm32"))]
-unsafe fn poll(_: u32, _: *mut [u32; 2]) -> u32 {
-    unreachable!();
-}
-
-#[cfg(target_arch = "wasm32")]
-#[link(wasm_import_module = "$root")]
-extern "C" {
-    #[link_name = "[waitable-set-new]"]
-    fn new() -> u32;
-    #[link_name = "[waitable-set-drop]"]
-    fn drop(set: u32);
-    #[link_name = "[waitable-join]"]
-    fn join(waitable: u32, set: u32);
-    #[link_name = "[waitable-set-wait]"]
-    fn wait(_: u32, _: *mut [u32; 2]) -> u32;
-    #[link_name = "[waitable-set-poll]"]
-    fn poll(_: u32, _: *mut [u32; 2]) -> u32;
+extern_wasm! {
+    #[link(wasm_import_module = "$root")]
+    extern "C" {
+        #[link_name = "[waitable-set-new]"]
+        fn new() -> u32;
+        #[link_name = "[waitable-set-drop]"]
+        fn drop(set: u32);
+        #[link_name = "[waitable-join]"]
+        fn join(waitable: u32, set: u32);
+        #[link_name = "[waitable-set-wait]"]
+        fn wait(_: u32, _: *mut [u32; 2]) -> u32;
+        #[link_name = "[waitable-set-poll]"]
+        fn poll(_: u32, _: *mut [u32; 2]) -> u32;
+    }
 }