Merge from rustc

Author: RalfJung

src/intrinsics/atomic.rs

@@ -20,7 +20,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
         intrinsic_name: &str,
         args: &[OpTy<'tcx, Provenance>],
         dest: &MPlaceTy<'tcx, Provenance>,
-    ) -> InterpResult<'tcx, bool> {
+    ) -> InterpResult<'tcx, EmulateItemResult> {
         let this = self.eval_context_mut();
 
         let intrinsic_structure: Vec<_> = intrinsic_name.split('_').collect();
@@ -114,9 +114,9 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 this.atomic_rmw_op(args, dest, AtomicOp::Max, rw_ord(ord)?)?;
             }
 
-            _ => return Ok(false),
+            _ => return Ok(EmulateItemResult::NotSupported),
         }
-        Ok(true)
+        Ok(EmulateItemResult::NeedsJumping)
     }
 }
 

src/intrinsics/mod.rs

@@ -37,58 +37,38 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
         let intrinsic_name = this.tcx.item_name(instance.def_id());
         let intrinsic_name = intrinsic_name.as_str();
 
-        // Handle intrinsics without return place.
-        match intrinsic_name {
-            "abort" => {
-                throw_machine_stop!(TerminationInfo::Abort(
-                    "the program aborted execution".to_owned()
-                ))
-            }
-            _ => {}
-        }
-
-        // All remaining supported intrinsics have a return place.
-        let ret = match ret {
-            // FIXME: add fallback body support once we actually have a diverging intrinsic with a fallback body
-            None => throw_unsup_format!("unimplemented (diverging) intrinsic: `{intrinsic_name}`"),
-            Some(p) => p,
-        };
-
-        // Some intrinsics are special and need the "ret".
-        match intrinsic_name {
-            "catch_unwind" => {
-                this.handle_catch_unwind(args, dest, ret)?;
-                return Ok(None);
-            }
-            _ => {}
-        }
-
-        // The rest jumps to `ret` immediately.
-        if !this.emulate_intrinsic_by_name(intrinsic_name, instance.args, args, dest)? {
-            // We haven't handled the intrinsic, let's see if we can use a fallback body.
-            if this.tcx.intrinsic(instance.def_id()).unwrap().must_be_overridden {
-                throw_unsup_format!("unimplemented intrinsic: `{intrinsic_name}`")
+        match this.emulate_intrinsic_by_name(intrinsic_name, instance.args, args, dest, ret)? {
+            EmulateItemResult::NotSupported => {
+                // We haven't handled the intrinsic, let's see if we can use a fallback body.
+                if this.tcx.intrinsic(instance.def_id()).unwrap().must_be_overridden {
+                    throw_unsup_format!("unimplemented intrinsic: `{intrinsic_name}`")
+                }
+                let intrinsic_fallback_checks_ub = Symbol::intern("intrinsic_fallback_checks_ub");
+                if this
+                    .tcx
+                    .get_attrs_by_path(
+                        instance.def_id(),
+                        &[sym::miri, intrinsic_fallback_checks_ub],
+                    )
+                    .next()
+                    .is_none()
+                {
+                    throw_unsup_format!(
+                        "miri can only use intrinsic fallback bodies that check UB. After verifying that `{intrinsic_name}` does so, add the `#[miri::intrinsic_fallback_checks_ub]` attribute to it; also ping @rust-lang/miri when you do that"
+                    );
+                }
+                Ok(Some(ty::Instance {
+                    def: ty::InstanceDef::Item(instance.def_id()),
+                    args: instance.args,
+                }))
             }
-            let intrinsic_fallback_checks_ub = Symbol::intern("intrinsic_fallback_checks_ub");
-            if this
-                .tcx
-                .get_attrs_by_path(instance.def_id(), &[sym::miri, intrinsic_fallback_checks_ub])
-                .next()
-                .is_none()
-            {
-                throw_unsup_format!(
-                    "miri can only use intrinsic fallback bodies that check UB. After verifying that `{intrinsic_name}` does so, add the `#[miri::intrinsic_fallback_checks_ub]` attribute to it; also ping @rust-lang/miri when you do that"
-                );
+            EmulateItemResult::NeedsJumping => {
+                trace!("{:?}", this.dump_place(&dest.clone().into()));
+                this.return_to_block(ret)?;
+                Ok(None)
             }
-            return Ok(Some(ty::Instance {
-                def: ty::InstanceDef::Item(instance.def_id()),
-                args: instance.args,
-            }));
+            EmulateItemResult::AlreadyJumped => Ok(None),
         }
-
-        trace!("{:?}", this.dump_place(&dest.clone().into()));
-        this.go_to_block(ret);
-        Ok(None)
     }
 
     /// Emulates a Miri-supported intrinsic (not supported by the core engine).
@@ -99,7 +79,8 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
         generic_args: ty::GenericArgsRef<'tcx>,
         args: &[OpTy<'tcx, Provenance>],
         dest: &MPlaceTy<'tcx, Provenance>,
-    ) -> InterpResult<'tcx, bool> {
+        ret: Option<mir::BasicBlock>,
+    ) -> InterpResult<'tcx, EmulateItemResult> {
         let this = self.eval_context_mut();
 
         if let Some(name) = intrinsic_name.strip_prefix("atomic_") {
@@ -110,6 +91,17 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
         }
 
         match intrinsic_name {
+            "abort" => {
+                throw_machine_stop!(TerminationInfo::Abort(
+                    "the program aborted execution".to_owned()
+                ));
+            }
+            "catch_unwind" => {
+                this.handle_catch_unwind(args, dest, ret)?;
+                // THis pushed a stack frame, don't jump to `ret`.
+                return Ok(EmulateItemResult::AlreadyJumped);
+            }
+
             // Raw memory accesses
             "volatile_load" => {
                 let [place] = check_arg_count(args)?;
@@ -433,9 +425,9 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 throw_machine_stop!(TerminationInfo::Abort(format!("trace/breakpoint trap")))
             }
 
-            _ => return Ok(false),
+            _ => return Ok(EmulateItemResult::NotSupported),
         }
 
-        Ok(true)
+        Ok(EmulateItemResult::NeedsJumping)
     }
 }

src/intrinsics/simd.rs

@@ -23,7 +23,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
         generic_args: ty::GenericArgsRef<'tcx>,
         args: &[OpTy<'tcx, Provenance>],
         dest: &MPlaceTy<'tcx, Provenance>,
-    ) -> InterpResult<'tcx, bool> {
+    ) -> InterpResult<'tcx, EmulateItemResult> {
         let this = self.eval_context_mut();
         match intrinsic_name {
             #[rustfmt::skip]
@@ -744,9 +744,9 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 }
             }
 
-            _ => return Ok(false),
+            _ => return Ok(EmulateItemResult::NotSupported),
         }
-        Ok(true)
+        Ok(EmulateItemResult::NeedsJumping)
     }
 
     fn fminmax_op(

src/lib.rs

@@ -103,6 +103,7 @@ pub use crate::shims::os_str::EvalContextExt as _;
 pub use crate::shims::panic::{CatchUnwindData, EvalContextExt as _};
 pub use crate::shims::time::EvalContextExt as _;
 pub use crate::shims::tls::TlsData;
+pub use crate::shims::EmulateItemResult;
 
 pub use crate::alloc_addresses::{EvalContextExt as _, ProvenanceMode};
 pub use crate::borrow_tracker::stacked_borrows::{

src/shims/alloc.rs

@@ -4,7 +4,6 @@ use rustc_ast::expand::allocator::AllocatorKind;
 use rustc_target::abi::{Align, Size};
 
 use crate::*;
-use shims::foreign_items::EmulateForeignItemResult;
 
 /// Check some basic requirements for this allocation request:
 /// non-zero size, power-of-two alignment.
@@ -55,12 +54,12 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
     fn emulate_allocator(
         &mut self,
         default: impl FnOnce(&mut MiriInterpCx<'mir, 'tcx>) -> InterpResult<'tcx>,
-    ) -> InterpResult<'tcx, EmulateForeignItemResult> {
+    ) -> InterpResult<'tcx, EmulateItemResult> {
         let this = self.eval_context_mut();
 
         let Some(allocator_kind) = this.tcx.allocator_kind(()) else {
             // in real code, this symbol does not exist without an allocator
-            return Ok(EmulateForeignItemResult::NotSupported);
+            return Ok(EmulateItemResult::NotSupported);
         };
 
         match allocator_kind {
@@ -70,11 +69,11 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 // and not execute any Miri shim. Somewhat unintuitively doing so is done
                 // by returning `NotSupported`, which triggers the `lookup_exported_symbol`
                 // fallback case in `emulate_foreign_item`.
-                return Ok(EmulateForeignItemResult::NotSupported);
+                return Ok(EmulateItemResult::NotSupported);
             }
             AllocatorKind::Default => {
                 default(this)?;
-                Ok(EmulateForeignItemResult::NeedsJumping)
+                Ok(EmulateItemResult::NeedsJumping)
             }
         }
     }