update cfgs

Author: nia-e

src/alloc_addresses/mod.rs

@@ -478,7 +478,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     /// provenances should be exposed. Note that if `prepare_exposed_for_native_call` was not
     /// called before the FFI (with `paranoid` set to false) then some of the writes may be
     /// lost!
-    #[cfg(all(unix, any(target_arch = "x86", target_arch = "x86_64")))]
+    #[cfg(target_os = "linux")]
     fn apply_events(&mut self, _events: crate::shims::trace::MemEvents) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
         let _exposed: Vec<AllocId> =

src/alloc_bytes.rs

@@ -5,7 +5,7 @@ use std::{alloc, slice};
 use rustc_abi::{Align, Size};
 use rustc_middle::mir::interpret::AllocBytes;
 
-#[cfg(all(unix, any(target_arch = "x86", target_arch = "x86_64")))]
+#[cfg(target_os = "linux")]
 use crate::discrete_alloc::MachineAlloc;
 use crate::helpers::ToU64 as _;
 
@@ -42,9 +42,9 @@ impl Drop for MiriAllocBytes {
 
         // SAFETY: Invariant, `self.ptr` points to memory allocated with `self.layout`.
         unsafe {
-            #[cfg(all(unix, any(target_arch = "x86", target_arch = "x86_64")))]
+            #[cfg(target_os = "linux")]
             MachineAlloc::dealloc(self.ptr, alloc_layout);
-            #[cfg(not(all(unix, any(target_arch = "x86", target_arch = "x86_64"))))]
+            #[cfg(not(target_os = "linux"))]
             alloc::dealloc(self.ptr, alloc_layout);
         }
     }
@@ -100,11 +100,11 @@ impl AllocBytes for MiriAllocBytes {
         let align = align.bytes();
         // SAFETY: `alloc_fn` will only be used with `size != 0`.
         let alloc_fn = |layout| unsafe {
-            #[cfg(all(unix, any(target_arch = "x86", target_arch = "x86_64")))]
+            #[cfg(target_os = "linux")]
             {
                 MachineAlloc::alloc(layout)
             }
-            #[cfg(not(all(unix, any(target_arch = "x86", target_arch = "x86_64"))))]
+            #[cfg(not(target_os = "linux"))]
             {
                 alloc::alloc(layout)
             }
@@ -124,11 +124,11 @@ impl AllocBytes for MiriAllocBytes {
         let align = align.bytes();
         // SAFETY: `alloc_fn` will only be used with `size != 0`.
         let alloc_fn = |layout| unsafe {
-            #[cfg(all(unix, any(target_arch = "x86", target_arch = "x86_64")))]
+            #[cfg(target_os = "linux")]
             {
                 MachineAlloc::alloc_zeroed(layout)
             }
-            #[cfg(not(all(unix, any(target_arch = "x86", target_arch = "x86_64"))))]
+            #[cfg(not(target_os = "linux"))]
             {
                 alloc::alloc_zeroed(layout)
             }

src/bin/miri.rs

@@ -132,7 +132,9 @@ fn entry_fn(tcx: TyCtxt<'_>) -> (DefId, MiriEntryFnType) {
 
 /// If for whatever reason the supervisor process exists but can't see that
 /// we died, inform it manually.
+#[inline]
 fn exit(return_code: i32) -> ! {
+    #[cfg(target_os = "linux")]
     miri::kill_sv(return_code);
     std::process::exit(return_code)
 }

src/lib.rs

@@ -76,7 +76,7 @@ mod borrow_tracker;
 mod clock;
 mod concurrency;
 mod diagnostics;
-#[cfg(all(unix, any(target_arch = "x86", target_arch = "x86_64")))]
+#[cfg(target_os = "linux")]
 mod discrete_alloc;
 mod eval;
 mod helpers;
@@ -100,6 +100,7 @@ use rustc_middle::{bug, span_bug};
 use tracing::{info, trace};
 
 // Let bin/miri.rs kill the supervisor process.
+#[cfg(target_os = "linux")]
 pub use crate::shims::trace::kill_sv;
 
 // Type aliases that set the provenance parameter.

src/machine.rs

@@ -739,7 +739,7 @@ impl<'tcx> MiriMachine<'tcx> {
                 // undefined behaviour in Miri itself!
                 (
                     unsafe {
-                        #[cfg(all(unix, any(target_arch = "x86", target_arch = "x86_64")))]
+                        #[cfg(target_os = "linux")]
                         discrete_alloc::MachineAlloc::enable();
                         libloading::Library::new(lib_file_path)
                             .expect("failed to read specified extern shared object file")

src/shims/mod.rs

@@ -19,7 +19,7 @@ pub mod os_str;
 pub mod panic;
 pub mod time;
 pub mod tls;
-#[cfg(all(unix, any(target_arch = "x86", target_arch = "x86_64")))]
+#[cfg(target_os = "linux")]
 pub mod trace;
 
 pub use self::files::FdTable;

src/shims/native_lib.rs

@@ -181,15 +181,15 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         }
 
         // Prepare all exposed memory, depending on whether we have a supervisor process.
-        #[cfg(all(unix, any(target_arch = "x86", target_arch = "x86_64")))]
+        #[cfg(target_os = "linux")]
         if super::trace::Supervisor::init().is_ok() {
             this.prepare_exposed_for_native_call(false)?;
         } else {
             //this.prepare_exposed_for_native_call(true)?;
             //eprintln!("Oh noes!")
             panic!("No ptrace!");
         }
-        #[cfg(not(all(unix, any(target_arch = "x86", target_arch = "x86_64"))))]
+        #[cfg(not(target_os = "linux"))]
         this.prepare_exposed_for_native_call(true)?;
 
         // Convert them to `libffi::high::Arg` type.
@@ -200,7 +200,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
         // Call the function and store output, depending on return type in the function signature.
         let ret = this.call_native_with_args(link_name, dest, code_ptr, libffi_args)?;
-        #[cfg(all(unix, any(target_arch = "x86", target_arch = "x86_64")))]
+        #[cfg(target_os = "linux")]
         if let Some(events) = super::trace::Supervisor::get_events() {
             this.apply_events(events)?;
         }
@@ -209,7 +209,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     }
 }
 
-#[cfg(all(unix, any(target_arch = "x86", target_arch = "x86_64")))]
+#[cfg(target_os = "linux")]
 unsafe fn do_native_call<T: libffi::high::CType>(ptr: CodePtr, args: &[ffi::Arg<'_>]) -> T {
     use shims::trace::Supervisor;
 
@@ -221,7 +221,7 @@ unsafe fn do_native_call<T: libffi::high::CType>(ptr: CodePtr, args: &[ffi::Arg<
     }
 }
 
-#[cfg(not(all(unix, any(target_arch = "x86", target_arch = "x86_64"))))]
+#[cfg(not(target_os = "linux"))]
 #[inline(always)]
 unsafe fn do_native_call<T: libffi::high::CType>(ptr: CodePtr, args: &[ffi::Arg<'_>]) -> T {
     unsafe { ffi::call(ptr, args) }