Use cortex-m only on cortex-m archs.

Without this, build fails for iOS.

embassy/Cargo.toml

@@ -29,7 +29,6 @@ executor-agnostic = []
 defmt = { version = "0.3", optional = true }
 log = { version = "0.4.14", optional = true }
 
-cortex-m = "0.7.3"
 futures     = { version = "0.3.17", default-features = false, features = [ "cfg-target-has-atomic", "unstable" ] }
 pin-project = { version = "1.0.8", default-features = false }
 embassy-macros  = { version = "0.1.0", path = "../embassy-macros"}
@@ -38,12 +37,28 @@ atomic-polyfill = "0.1.5"
 critical-section = "0.2.5"
 embedded-hal = "0.2.6"
 heapless = "0.7.5"
+cfg-if = "1.0.0"
 
 # WASM dependencies
 wasm-bindgen = { version = "0.2.76", features = ["nightly"], optional = true }
 js-sys = { version = "0.3", optional = true }
 wasm-timer = { version = "0.2.5", optional = true }
 
+[target."thumbv6m-none-eabi".dependencies]
+cortex-m = "0.7.3"
+[target."thumbv7m-none-eabi".dependencies]
+cortex-m = "0.7.3"
+[target."thumbv7em-none-eabi".dependencies]
+cortex-m = "0.7.3"
+[target."thumbv7em-none-eabihf".dependencies]
+cortex-m = "0.7.3"
+[target."thumbv8m.base-none-eabi".dependencies]
+cortex-m = "0.7.3"
+[target."thumbv8m.main-none-eabi".dependencies]
+cortex-m = "0.7.3"
+[target."thumbv8m.main-none-eabihf".dependencies]
+cortex-m = "0.7.3"
+
 [dev-dependencies]
 embassy = { path = ".", features = ["executor-agnostic"] }
 futures-executor = { version = "0.3.17", features = [ "thread-pool" ] }

embassy/src/blocking_mutex/kind.rs

@@ -1,19 +1,20 @@
-use super::{CriticalSectionMutex, Mutex, NoopMutex, ThreadModeMutex};
-
 pub trait MutexKind {
-    type Mutex<T>: Mutex<Data = T>;
+    type Mutex<T>: super::Mutex<Data = T>;
 }
 
 pub enum CriticalSection {}
 impl MutexKind for CriticalSection {
-    type Mutex<T> = CriticalSectionMutex<T>;
+    type Mutex<T> = super::CriticalSectionMutex<T>;
 }
 
+#[cfg(any(cortex_m, feature = "std"))]
 pub enum ThreadMode {}
+#[cfg(any(cortex_m, feature = "std"))]
 impl MutexKind for ThreadMode {
-    type Mutex<T> = ThreadModeMutex<T>;
+    type Mutex<T> = super::ThreadModeMutex<T>;
 }
+
 pub enum Noop {}
 impl MutexKind for Noop {
-    type Mutex<T> = NoopMutex<T>;
+    type Mutex<T> = super::NoopMutex<T>;
 }

embassy/src/blocking_mutex/mod.rs

@@ -62,24 +62,30 @@ impl<T> Mutex for CriticalSectionMutex<T> {
     }
 }
 
-/// A "mutex" that only allows borrowing from thread mode.
+#[cfg(any(cortex_m, feature = "std"))]
-///
+pub use thread_mode_mutex::*;
-/// # Safety
+#[cfg(any(cortex_m, feature = "std"))]
-///
+mod thread_mode_mutex {
-/// **This Mutex is only safe on single-core systems.**
+    use super::*;
-///
+
-/// On multi-core systems, a `ThreadModeMutex` **is not sufficient** to ensure exclusive access.
+    /// A "mutex" that only allows borrowing from thread mode.
-pub struct ThreadModeMutex<T> {
+    ///
+    /// # Safety
+    ///
+    /// **This Mutex is only safe on single-core systems.**
+    ///
+    /// On multi-core systems, a `ThreadModeMutex` **is not sufficient** to ensure exclusive access.
+    pub struct ThreadModeMutex<T> {
         inner: UnsafeCell<T>,
-}
+    }
 
-// NOTE: ThreadModeMutex only allows borrowing from one execution context ever: thread mode.
+    // NOTE: ThreadModeMutex only allows borrowing from one execution context ever: thread mode.
-// Therefore it cannot be used to send non-sendable stuff between execution contexts, so it can
+    // Therefore it cannot be used to send non-sendable stuff between execution contexts, so it can
-// be Send+Sync even if T is not Send (unlike CriticalSectionMutex)
+    // be Send+Sync even if T is not Send (unlike CriticalSectionMutex)
-unsafe impl<T> Sync for ThreadModeMutex<T> {}
+    unsafe impl<T> Sync for ThreadModeMutex<T> {}
-unsafe impl<T> Send for ThreadModeMutex<T> {}
+    unsafe impl<T> Send for ThreadModeMutex<T> {}
 
-impl<T> ThreadModeMutex<T> {
+    impl<T> ThreadModeMutex<T> {
         /// Creates a new mutex
         pub const fn new(value: T) -> Self {
             ThreadModeMutex {
@@ -95,9 +101,9 @@ impl<T> ThreadModeMutex<T> {
             );
             unsafe { &*self.inner.get() }
         }
-}
+    }
 
-impl<T> Mutex for ThreadModeMutex<T> {
+    impl<T> Mutex for ThreadModeMutex<T> {
         type Data = T;
 
         fn new(data: T) -> Self {
@@ -107,9 +113,9 @@ impl<T> Mutex for ThreadModeMutex<T> {
         fn lock<R>(&self, f: impl FnOnce(&Self::Data) -> R) -> R {
             f(self.borrow())
         }
-}
+    }
 
-impl<T> Drop for ThreadModeMutex<T> {
+    impl<T> Drop for ThreadModeMutex<T> {
         fn drop(&mut self) {
             // Only allow dropping from thread mode. Dropping calls drop on the inner `T`, so
             // `drop` needs the same guarantees as `lock`. `ThreadModeMutex<T>` is Send even if
@@ -122,15 +128,16 @@ impl<T> Drop for ThreadModeMutex<T> {
 
             // Drop of the inner `T` happens after this.
         }
-}
+    }
 
-pub fn in_thread_mode() -> bool {
+    pub fn in_thread_mode() -> bool {
         #[cfg(feature = "std")]
         return Some("main") == std::thread::current().name();
 
         #[cfg(not(feature = "std"))]
         return cortex_m::peripheral::SCB::vect_active()
             == cortex_m::peripheral::scb::VectActive::ThreadMode;
+    }
 }
 
 /// A "mutex" that does nothing and cannot be shared between threads.

embassy/src/executor/mod.rs

@@ -2,12 +2,25 @@
 
 #![deny(missing_docs)]
 
-#[cfg_attr(feature = "std", path = "arch/std.rs")]
+cfg_if::cfg_if! {
-#[cfg_attr(feature = "wasm", path = "arch/wasm.rs")]
+    if #[cfg(cortex_m)] {
-#[cfg_attr(not(any(feature = "std", feature = "wasm")), path = "arch/arm.rs")]
+        #[path="arch/cortex_m.rs"]
-mod arch;
+        mod arch;
-pub mod raw;
+        pub use arch::*;
-mod spawner;
+    }
+    else if #[cfg(feature="wasm")] {
+        #[path="arch/wasm.rs"]
+        mod arch;
+        pub use arch::*;
+    }
+    else if #[cfg(feature="std")] {
+        #[path="arch/std.rs"]
+        mod arch;
+        pub use arch::*;
+    }
+}
 
-pub use arch::*;
+pub mod raw;
+
+mod spawner;
 pub use spawner::*;

embassy/src/lib.rs

@@ -13,6 +13,7 @@ pub mod channel;
 pub mod waitqueue;
 
 pub mod executor;
+#[cfg(cortex_m)]
 pub mod interrupt;
 pub mod io;
 #[cfg(feature = "time")]