Add `assert_target_os_is_unix` function

[rust.git] / src / helpers.rs

diff --git a/src/helpers.rs b/src/helpers.rs
index d9a7edcc11350936ff55e5a7aa3a7155f9064a3a..134f556bf120456e6933d3ec43909a63a6194cb9 100644 (file)
--- a/src/helpers.rs
+++ b/src/helpers.rs
@@ -255,7 +255,7 @@ fn call_function(
         }
 
         // Push frame.
-        let mir = &*this.load_mir(f.def, None)?;
+        let mir = this.load_mir(f.def, None)?;
         this.push_stack_frame(f, mir, dest, stack_pop)?;
 
         // Initialize arguments.
@@ -493,6 +493,17 @@ fn assert_target_os(&self, target_os: &str, name: &str) {
         )
     }
 
+    /// Helper function used inside the shims of foreign functions to assert that the target OS
+    /// is part of the UNIX family. It panics showing a message with the `name` of the foreign function
+    /// if this is not the case.
+    fn assert_target_os_is_unix(&self, name: &str) {
+        assert!(
+            target_os_is_unix(self.eval_context_ref().tcx.sess.target.os.as_ref()),
+            "`{}` is only available for supported UNIX family targets",
+            name,
+        );
+    }
+
     /// Get last error variable as a place, lazily allocating thread-local storage for it if
     /// necessary.
     fn last_error_place(&mut self) -> InterpResult<'tcx, MPlaceTy<'tcx, Tag>> {
@@ -681,7 +692,7 @@ fn read_c_str<'a>(&'a self, ptr: Pointer<Option<Tag>>) -> InterpResult<'tcx, &'a
             // FIXME: We are re-getting the allocation each time around the loop.
             // Would be nice if we could somehow "extend" an existing AllocRange.
             let alloc = this.get_ptr_alloc(ptr.offset(len, this)?, size1, Align::ONE)?.unwrap(); // not a ZST, so we will get a result
-            let byte = alloc.read_scalar(alloc_range(Size::ZERO, size1))?.to_u8()?;
+            let byte = alloc.read_integer(Size::ZERO, size1)?.to_u8()?;
             if byte == 0 {
                 break;
             } else {
@@ -703,7 +714,7 @@ fn read_wide_str(&self, mut ptr: Pointer<Option<Tag>>) -> InterpResult<'tcx, Vec
             // FIXME: We are re-getting the allocation each time around the loop.
             // Would be nice if we could somehow "extend" an existing AllocRange.
             let alloc = this.get_ptr_alloc(ptr, size2, align2)?.unwrap(); // not a ZST, so we will get a result
-            let wchar = alloc.read_scalar(alloc_range(Size::ZERO, size2))?.to_u16()?;
+            let wchar = alloc.read_integer(Size::ZERO, size2)?.to_u16()?;
             if wchar == 0 {
                 break;
             } else {
@@ -729,10 +740,22 @@ fn check_abi<'a>(&self, abi: Abi, exp_abi: Abi) -> InterpResult<'a, ()> {
 
     fn frame_in_std(&self) -> bool {
         let this = self.eval_context_ref();
-        this.tcx.lang_items().start_fn().map_or(false, |start_fn| {
-            this.tcx.def_path(this.frame().instance.def_id()).krate
-                == this.tcx.def_path(start_fn).krate
-        })
+        let Some(start_fn) = this.tcx.lang_items().start_fn() else {
+            // no_std situations
+            return false;
+        };
+        let frame = this.frame();
+        // Make an attempt to get at the instance of the function this is inlined from.
+        let instance: Option<_> = try {
+            let scope = frame.current_source_info()?.scope;
+            let inlined_parent = frame.body.source_scopes[scope].inlined_parent_scope?;
+            let source = &frame.body.source_scopes[inlined_parent];
+            source.inlined.expect("inlined_parent_scope points to scope without inline info").0
+        };
+        // Fall back to the instance of the function itself.
+        let instance = instance.unwrap_or(frame.instance);
+        // Now check if this is in the same crate as start_fn.
+        this.tcx.def_path(instance.def_id()).krate == this.tcx.def_path(start_fn).krate
     }
 
     /// Handler that should be called when unsupported functionality is encountered.
@@ -817,7 +840,7 @@ pub struct CurrentSpan<'a, 'mir, 'tcx> {
 
 impl<'a, 'mir, 'tcx> CurrentSpan<'a, 'mir, 'tcx> {
     pub fn get(&mut self) -> Span {
-        *self.span.get_or_insert_with(|| Self::current_span(&self.machine))
+        *self.span.get_or_insert_with(|| Self::current_span(self.machine))
     }
 
     #[inline(never)]
@@ -825,7 +848,7 @@ fn current_span(machine: &Evaluator<'_, '_>) -> Span {
         machine
             .threads
             .active_thread_stack()
-            .into_iter()
+            .iter()
             .rev()
             .find(|frame| {
                 let def_id = frame.instance.def_id();
@@ -858,7 +881,7 @@ pub fn isolation_abort_error<'tcx>(name: &str) -> InterpResult<'tcx> {
 
 /// Retrieve the list of local crates that should have been passed by cargo-miri in
 /// MIRI_LOCAL_CRATES and turn them into `CrateNum`s.
-pub fn get_local_crates(tcx: &TyCtxt<'_>) -> Vec<CrateNum> {
+pub fn get_local_crates(tcx: TyCtxt<'_>) -> Vec<CrateNum> {
     // Convert the local crate names from the passed-in config into CrateNums so that they can
     // be looked up quickly during execution
     let local_crate_names = std::env::var("MIRI_LOCAL_CRATES")
@@ -883,3 +906,9 @@ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "[{:#x}..{:#x}]", self.0.start.bytes(), self.0.end().bytes())
     }
 }
+
+/// Helper function used inside the shims of foreign functions to check that
+/// `target_os` is a supported UNIX OS.
+pub fn target_os_is_unix(target_os: &str) -> bool {
+    matches!(target_os, "linux" | "macos")
+}