diff --git a/Cargo.lock b/Cargo.lock
index 0dc8d06a023..0180daa03a2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -283,7 +283,7 @@ dependencies = [
  "lazy_static",
  "libc",
  "log",
- "mach",
+ "mach2",
  "msg",
  "nix 0.25.1",
  "serde_json",
@@ -3428,6 +3428,15 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "mach2"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19b955cdeb2a02b9117f121ce63aa52d08ade45de53e48fe6a38b39c10f6f709"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "malloc_buf"
 version = "0.0.6"
diff --git a/components/background_hang_monitor/Cargo.toml b/components/background_hang_monitor/Cargo.toml
index f9ec70393e2..67eafb0dc02 100644
--- a/components/background_hang_monitor/Cargo.toml
+++ b/components/background_hang_monitor/Cargo.toml
@@ -25,7 +25,7 @@ serde_json = { workspace = true }
 lazy_static = { workspace = true }
 
 [target.'cfg(target_os = "macos")'.dependencies]
-mach = "0.3"
+mach2 = "0.4"
 
 [target.'cfg(all(target_os = "linux", not(any(target_arch = "arm", target_arch = "aarch64"))))'.dependencies]
 nix = "0.25"
diff --git a/components/background_hang_monitor/sampler_mac.rs b/components/background_hang_monitor/sampler_mac.rs
index 8121865db7f..ed85ef8d904 100644
--- a/components/background_hang_monitor/sampler_mac.rs
+++ b/components/background_hang_monitor/sampler_mac.rs
@@ -4,11 +4,11 @@
 
 use std::{panic, process};
 
-use {libc, mach};
+use {libc, mach2};
 
 use crate::sampler::{Address, NativeStack, Registers, Sampler};
 
-type MonitoredThreadId = mach::mach_types::thread_act_t;
+type MonitoredThreadId = mach2::mach_types::thread_act_t;
 
 pub struct MacOsSampler {
     thread_id: MonitoredThreadId,
@@ -17,7 +17,7 @@ pub struct MacOsSampler {
 impl MacOsSampler {
     #[allow(unsafe_code)]
     pub fn new() -> Box<dyn Sampler> {
-        let thread_id = unsafe { mach::mach_init::mach_thread_self() };
+        let thread_id = unsafe { mach2::mach_init::mach_thread_self() };
         Box::new(MacOsSampler { thread_id })
     }
 }
@@ -55,8 +55,8 @@ impl Sampler for MacOsSampler {
     }
 }
 
-fn check_kern_return(kret: mach::kern_return::kern_return_t) -> Result<(), ()> {
-    if kret != mach::kern_return::KERN_SUCCESS {
+fn check_kern_return(kret: mach2::kern_return::kern_return_t) -> Result<(), ()> {
+    if kret != mach2::kern_return::KERN_SUCCESS {
         return Err(());
     }
     Ok(())
@@ -64,30 +64,49 @@ fn check_kern_return(kret: mach::kern_return::kern_return_t) -> Result<(), ()> {
 
 #[allow(unsafe_code)]
 unsafe fn suspend_thread(thread_id: MonitoredThreadId) -> Result<(), ()> {
-    check_kern_return(mach::thread_act::thread_suspend(thread_id))
+    check_kern_return(mach2::thread_act::thread_suspend(thread_id))
 }
 
 #[allow(unsafe_code)]
 unsafe fn get_registers(thread_id: MonitoredThreadId) -> Result<Registers, ()> {
-    let mut state = mach::structs::x86_thread_state64_t::new();
-    let mut state_count = mach::structs::x86_thread_state64_t::count();
-    let kret = mach::thread_act::thread_get_state(
-        thread_id,
-        mach::thread_status::x86_THREAD_STATE64,
-        (&mut state) as *mut _ as *mut _,
-        &mut state_count,
-    );
-    check_kern_return(kret)?;
-    Ok(Registers {
-        instruction_ptr: state.__rip as Address,
-        stack_ptr: state.__rsp as Address,
-        frame_ptr: state.__rbp as Address,
-    })
+    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+    {
+        let mut state = mach2::structs::x86_thread_state64_t::new();
+        let mut state_count = mach2::structs::x86_thread_state64_t::count();
+        let kret = mach2::thread_act::thread_get_state(
+            thread_id,
+            mach2::thread_status::x86_THREAD_STATE64,
+            (&mut state) as *mut _ as *mut _,
+            &mut state_count,
+        );
+        check_kern_return(kret)?;
+        Ok(Registers {
+            instruction_ptr: state.__rip as Address,
+            stack_ptr: state.__rsp as Address,
+            frame_ptr: state.__rbp as Address,
+        })
+    }
+    #[cfg(target_arch = "aarch64")]
+    {
+        let mut state = mach2::structs::arm_thread_state64_t::new();
+        let mut state_count = mach2::structs::arm_thread_state64_t::count();
+        let kret = mach2::thread_act::thread_get_state(
+            thread_id,
+            mach2::thread_status::ARM_THREAD_STATE64,
+            (&mut state) as *mut _ as *mut _,
+            &mut state_count,
+        );
+        check_kern_return(kret)?;
+        Ok(Registers {
+            instruction_ptr: state.__pc as Address,
+            stack_ptr: state.__sp as Address,
+            frame_ptr: state.__fp as Address,
+        })
+    }
 }
-
 #[allow(unsafe_code)]
 unsafe fn resume_thread(thread_id: MonitoredThreadId) -> Result<(), ()> {
-    check_kern_return(mach::thread_act::thread_resume(thread_id))
+    check_kern_return(mach2::thread_act::thread_resume(thread_id))
 }
 
 #[allow(unsafe_code)]