diff --git a/crates/core_arch/src/lib.rs b/crates/core_arch/src/lib.rs
index bd4de67445..9aa8680d61 100644
--- a/crates/core_arch/src/lib.rs
+++ b/crates/core_arch/src/lib.rs
@@ -12,7 +12,6 @@
     simd_ffi,
     proc_macro_hygiene,
     stmt_expr_attributes,
-    core_intrinsics,
     intrinsics,
     no_core,
     rustc_attrs,
@@ -85,4 +84,136 @@ pub mod arch {
 }
 
 #[allow(unused_imports)]
-use core::{convert, ffi, hint, intrinsics, marker, mem, ops, ptr, sync};
+use core::{convert, ffi, hint, marker, mem, ops, ptr, sync};
+
+// `core` is changing the feature name for the `intrinsics` module.
+// To permit that transition, we avoid using that feature for now.
+mod intrinsics {
+    extern "rust-intrinsic" {
+        /// Emits a `!nontemporal` store according to LLVM (see their docs).
+        /// Probably will never become stable.
+        #[rustc_nounwind]
+        pub fn nontemporal_store<T>(ptr: *mut T, val: T);
+
+        /// Stores a value if the current value is the same as the `old` value.
+        ///
+        /// The stabilized version of this intrinsic is available on the
+        /// [`atomic`] types via the `compare_exchange` method by passing
+        /// [`Ordering::Relaxed`] as both the success and failure parameters.
+        /// For example, [`AtomicBool::compare_exchange`].
+        #[rustc_nounwind]
+        pub fn atomic_cxchg_relaxed_relaxed<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool);
+        /// Stores a value if the current value is the same as the `old` value.
+        ///
+        /// The stabilized version of this intrinsic is available on the
+        /// [`atomic`] types via the `compare_exchange` method by passing
+        /// [`Ordering::Relaxed`] and [`Ordering::Acquire`] as the success and failure parameters.
+        /// For example, [`AtomicBool::compare_exchange`].
+        #[rustc_nounwind]
+        pub fn atomic_cxchg_relaxed_acquire<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool);
+        /// Stores a value if the current value is the same as the `old` value.
+        ///
+        /// The stabilized version of this intrinsic is available on the
+        /// [`atomic`] types via the `compare_exchange` method by passing
+        /// [`Ordering::Relaxed`] and [`Ordering::SeqCst`] as the success and failure parameters.
+        /// For example, [`AtomicBool::compare_exchange`].
+        #[rustc_nounwind]
+        pub fn atomic_cxchg_relaxed_seqcst<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool);
+        /// Stores a value if the current value is the same as the `old` value.
+        ///
+        /// The stabilized version of this intrinsic is available on the
+        /// [`atomic`] types via the `compare_exchange` method by passing
+        /// [`Ordering::Acquire`] and [`Ordering::Relaxed`] as the success and failure parameters.
+        /// For example, [`AtomicBool::compare_exchange`].
+        #[rustc_nounwind]
+        pub fn atomic_cxchg_acquire_relaxed<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool);
+        /// Stores a value if the current value is the same as the `old` value.
+        ///
+        /// The stabilized version of this intrinsic is available on the
+        /// [`atomic`] types via the `compare_exchange` method by passing
+        /// [`Ordering::Acquire`] as both the success and failure parameters.
+        /// For example, [`AtomicBool::compare_exchange`].
+        #[rustc_nounwind]
+        pub fn atomic_cxchg_acquire_acquire<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool);
+        /// Stores a value if the current value is the same as the `old` value.
+        ///
+        /// The stabilized version of this intrinsic is available on the
+        /// [`atomic`] types via the `compare_exchange` method by passing
+        /// [`Ordering::Acquire`] and [`Ordering::SeqCst`] as the success and failure parameters.
+        /// For example, [`AtomicBool::compare_exchange`].
+        #[rustc_nounwind]
+        pub fn atomic_cxchg_acquire_seqcst<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool);
+        /// Stores a value if the current value is the same as the `old` value.
+        ///
+        /// The stabilized version of this intrinsic is available on the
+        /// [`atomic`] types via the `compare_exchange` method by passing
+        /// [`Ordering::Release`] and [`Ordering::Relaxed`] as the success and failure parameters.
+        /// For example, [`AtomicBool::compare_exchange`].
+        #[rustc_nounwind]
+        pub fn atomic_cxchg_release_relaxed<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool);
+        /// Stores a value if the current value is the same as the `old` value.
+        ///
+        /// The stabilized version of this intrinsic is available on the
+        /// [`atomic`] types via the `compare_exchange` method by passing
+        /// [`Ordering::Release`] and [`Ordering::Acquire`] as the success and failure parameters.
+        /// For example, [`AtomicBool::compare_exchange`].
+        #[rustc_nounwind]
+        pub fn atomic_cxchg_release_acquire<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool);
+        /// Stores a value if the current value is the same as the `old` value.
+        ///
+        /// The stabilized version of this intrinsic is available on the
+        /// [`atomic`] types via the `compare_exchange` method by passing
+        /// [`Ordering::Release`] and [`Ordering::SeqCst`] as the success and failure parameters.
+        /// For example, [`AtomicBool::compare_exchange`].
+        #[rustc_nounwind]
+        pub fn atomic_cxchg_release_seqcst<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool);
+        /// Stores a value if the current value is the same as the `old` value.
+        ///
+        /// The stabilized version of this intrinsic is available on the
+        /// [`atomic`] types via the `compare_exchange` method by passing
+        /// [`Ordering::AcqRel`] and [`Ordering::Relaxed`] as the success and failure parameters.
+        /// For example, [`AtomicBool::compare_exchange`].
+        #[rustc_nounwind]
+        pub fn atomic_cxchg_acqrel_relaxed<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool);
+        /// Stores a value if the current value is the same as the `old` value.
+        ///
+        /// The stabilized version of this intrinsic is available on the
+        /// [`atomic`] types via the `compare_exchange` method by passing
+        /// [`Ordering::AcqRel`] and [`Ordering::Acquire`] as the success and failure parameters.
+        /// For example, [`AtomicBool::compare_exchange`].
+        #[rustc_nounwind]
+        pub fn atomic_cxchg_acqrel_acquire<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool);
+        /// Stores a value if the current value is the same as the `old` value.
+        ///
+        /// The stabilized version of this intrinsic is available on the
+        /// [`atomic`] types via the `compare_exchange` method by passing
+        /// [`Ordering::AcqRel`] and [`Ordering::SeqCst`] as the success and failure parameters.
+        /// For example, [`AtomicBool::compare_exchange`].
+        #[rustc_nounwind]
+        pub fn atomic_cxchg_acqrel_seqcst<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool);
+        /// Stores a value if the current value is the same as the `old` value.
+        ///
+        /// The stabilized version of this intrinsic is available on the
+        /// [`atomic`] types via the `compare_exchange` method by passing
+        /// [`Ordering::SeqCst`] and [`Ordering::Relaxed`] as the success and failure parameters.
+        /// For example, [`AtomicBool::compare_exchange`].
+        #[rustc_nounwind]
+        pub fn atomic_cxchg_seqcst_relaxed<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool);
+        /// Stores a value if the current value is the same as the `old` value.
+        ///
+        /// The stabilized version of this intrinsic is available on the
+        /// [`atomic`] types via the `compare_exchange` method by passing
+        /// [`Ordering::SeqCst`] and [`Ordering::Acquire`] as the success and failure parameters.
+        /// For example, [`AtomicBool::compare_exchange`].
+        #[rustc_nounwind]
+        pub fn atomic_cxchg_seqcst_acquire<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool);
+        /// Stores a value if the current value is the same as the `old` value.
+        ///
+        /// The stabilized version of this intrinsic is available on the
+        /// [`atomic`] types via the `compare_exchange` method by passing
+        /// [`Ordering::SeqCst`] as both the success and failure parameters.
+        /// For example, [`AtomicBool::compare_exchange`].
+        #[rustc_nounwind]
+        pub fn atomic_cxchg_seqcst_seqcst<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool);
+    }
+}