Adapt to the interpreter refactor in miri

Author: WaffleLapkin

compiler/rustc_const_eval/src/interpret/terminator.rs

@@ -498,7 +498,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
     /// `with_caller_location` indicates whether the caller passed a caller location. Miri
     /// implements caller locations without argument passing, but to match `FnAbi` we need to know
     /// when those arguments are present.
-    pub(crate) fn eval_fn_call(
+    pub fn eval_fn_call(
         &mut self,
         fn_val: FnVal<'tcx, M::ExtraFnVal>,
         (caller_abi, caller_fn_abi): (Abi, &FnAbi<'tcx, Ty<'tcx>>),

src/tools/miri/src/helpers.rs

@@ -997,7 +997,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
         link_name: Symbol,
     ) -> InterpResult<'tcx, ()> {
         self.check_abi(abi, exp_abi)?;
-        if let Some((body, instance)) = self.eval_context_mut().lookup_exported_symbol(link_name)? {
+        if let Some(instance) = self.eval_context_mut().lookup_exported_symbol(link_name)? {
             // If compiler-builtins is providing the symbol, then don't treat it as a clash.
             // We'll use our built-in implementation in `emulate_foreign_item_inner` for increased
             // performance. Note that this means we won't catch any undefined behavior in
@@ -1007,6 +1007,8 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 return Ok(());
             }
 
+            let body = self.eval_context_mut().load_mir(instance.def, None)?;
+
             throw_machine_stop!(TerminationInfo::SymbolShimClashing {
                 link_name,
                 span: body.span.data(),

src/tools/miri/src/machine.rs

@@ -28,9 +28,11 @@ use rustc_middle::{
 };
 use rustc_span::def_id::{CrateNum, DefId};
 use rustc_span::{Span, SpanData, Symbol};
+use rustc_target::abi::call::FnAbi;
 use rustc_target::abi::{Align, Size};
 use rustc_target::spec::abi::Abi;
 
+use crate::shims::foreign_items::ExtraFnVal;
 use crate::{
     concurrency::{data_race, weak_memory},
     shims::unix::FileHandler,
@@ -853,7 +855,7 @@ impl<'mir, 'tcx> MiriInterpCxExt<'mir, 'tcx> for MiriInterpCx<'mir, 'tcx> {
 /// Machine hook implementations.
 impl<'mir, 'tcx> Machine<'mir, 'tcx> for MiriMachine<'mir, 'tcx> {
     type MemoryKind = MiriMemoryKind;
-    type ExtraFnVal = DynSym;
+    type ExtraFnVal = ExtraFnVal;
 
     type FrameExtra = FrameExtra<'tcx>;
     type AllocExtra = AllocExtra<'tcx>;
@@ -938,44 +940,40 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for MiriMachine<'mir, 'tcx> {
     }
 
     #[inline(always)]
-    fn find_mir_or_eval_fn(
+    fn find_mir_or_extra_fn(
         ecx: &mut MiriInterpCx<'mir, 'tcx>,
         instance: ty::Instance<'tcx>,
         abi: Abi,
-        args: &[FnArg<'tcx, Provenance>],
-        dest: &PlaceTy<'tcx, Provenance>,
-        ret: Option<mir::BasicBlock>,
-        unwind: mir::UnwindAction,
-    ) -> InterpResult<'tcx, Option<(&'mir mir::Body<'tcx>, ty::Instance<'tcx>)>> {
-        // For foreign items, try to see if we can emulate them.
+    ) -> InterpResult<'tcx, Either<&'mir mir::Body<'tcx>, ExtraFnVal>> {
+        // For foreign items, we return `ExtraFnVal::ForeignFn` to later try to see if we can
+        // emulate them.
         if ecx.tcx.is_foreign_item(instance.def_id()) {
-            // An external function call that does not have a MIR body. We either find MIR elsewhere
-            // or emulate its effect.
-            // This will be Ok(None) if we're emulating the intrinsic entirely within Miri (no need
-            // to run extra MIR), and Ok(Some(body)) if we found MIR to run for the
-            // foreign function
-            // Any needed call to `goto_block` will be performed by `emulate_foreign_item`.
-            let args = ecx.copy_fn_args(args)?; // FIXME: Should `InPlace` arguments be reset to uninit?
             let link_name = ecx.item_link_name(instance.def_id());
-            return ecx.emulate_foreign_item(link_name, abi, &args, dest, ret, unwind);
+            return Ok(Either::Right(ExtraFnVal::ForeignFn { link_name }));
         }
 
         // Otherwise, load the MIR.
-        Ok(Some((ecx.load_mir(instance.def, None)?, instance)))
+        ecx.load_mir(instance.def, None).map(Either::Left)
     }
 
     #[inline(always)]
     fn call_extra_fn(
         ecx: &mut MiriInterpCx<'mir, 'tcx>,
-        fn_val: DynSym,
-        abi: Abi,
+        fn_val: ExtraFnVal,
+        abis: (Abi, &FnAbi<'tcx, Ty<'tcx>>),
         args: &[FnArg<'tcx, Provenance>],
         dest: &PlaceTy<'tcx, Provenance>,
         ret: Option<mir::BasicBlock>,
         unwind: mir::UnwindAction,
     ) -> InterpResult<'tcx> {
-        let args = ecx.copy_fn_args(args)?; // FIXME: Should `InPlace` arguments be reset to uninit?
-        ecx.emulate_dyn_sym(fn_val, abi, &args, dest, ret, unwind)
+        match fn_val {
+            // An external function call that does not have a MIR body. We either find MIR elsewhere
+            // or emulate its effect.
+            // Any needed call to `goto_block` will be performed by `emulate_foreign_item`.
+            ExtraFnVal::ForeignFn { link_name } =>
+                ecx.emulate_foreign_item(link_name, abis, &args, dest, ret, unwind).map(|_| ()),
+            ExtraFnVal::DynSym(sym) => ecx.emulate_dyn_sym(sym, abis, &args, dest, ret, unwind),
+        }
     }
 
     #[inline(always)]

src/tools/miri/src/shims/extern_static.rs

@@ -1,6 +1,6 @@
 //! Provides the `extern static` that this platform expects.
 
-use crate::*;
+use crate::{shims::foreign_items::ExtraFnVal, *};
 
 impl<'mir, 'tcx> MiriMachine<'mir, 'tcx> {
     fn alloc_extern_static(
@@ -62,7 +62,7 @@ impl<'mir, 'tcx> MiriMachine<'mir, 'tcx> {
                 // "signal" -- just needs a non-zero pointer value (function does not even get called),
                 // but we arrange for this to call the `signal` function anyway.
                 let layout = this.machine.layouts.const_raw_ptr;
-                let ptr = this.fn_ptr(FnVal::Other(DynSym::from_str("signal")));
+                let ptr = this.fn_ptr(FnVal::Other(ExtraFnVal::DynSym(DynSym::from_str("signal"))));
                 let val = ImmTy::from_scalar(Scalar::from_pointer(ptr, this), layout);
                 Self::alloc_extern_static(this, "signal", val)?;
             }

src/tools/miri/src/shims/foreign_items.rs

@@ -6,23 +6,32 @@ use rustc_hir::{
     def::DefKind,
     def_id::{CrateNum, LOCAL_CRATE},
 };
-use rustc_middle::middle::{
-    codegen_fn_attrs::CodegenFnAttrFlags, dependency_format::Linkage,
-    exported_symbols::ExportedSymbol,
-};
 use rustc_middle::mir;
 use rustc_middle::ty;
+use rustc_middle::{
+    middle::{
+        codegen_fn_attrs::CodegenFnAttrFlags, dependency_format::Linkage,
+        exported_symbols::ExportedSymbol,
+    },
+    ty::Ty,
+};
 use rustc_session::config::CrateType;
 use rustc_span::Symbol;
 use rustc_target::{
-    abi::{Align, Size},
+    abi::{call::FnAbi, Align, Size},
     spec::abi::Abi,
 };
 
 use super::backtrace::EvalContextExt as _;
 use crate::*;
 use helpers::{ToHost, ToSoft};
 
+#[derive(Debug, Copy, Clone)]
+pub enum ExtraFnVal {
+    ForeignFn { link_name: Symbol },
+    DynSym(DynSym),
+}
+
 /// Type of dynamic symbols (for `dlsym` et al)
 #[derive(Debug, Copy, Clone)]
 pub struct DynSym(Symbol);
@@ -55,12 +64,12 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
     fn emulate_foreign_item(
         &mut self,
         link_name: Symbol,
-        abi: Abi,
-        args: &[OpTy<'tcx, Provenance>],
+        (abi, fn_abi): (Abi, &FnAbi<'tcx, Ty<'tcx>>),
+        args: &[FnArg<'tcx, Provenance>],
         dest: &PlaceTy<'tcx, Provenance>,
         ret: Option<mir::BasicBlock>,
         unwind: mir::UnwindAction,
-    ) -> InterpResult<'tcx, Option<(&'mir mir::Body<'tcx>, ty::Instance<'tcx>)>> {
+    ) -> InterpResult<'tcx, Option<()>> {
         let this = self.eval_context_mut();
         let tcx = this.tcx.tcx;
 
@@ -69,67 +78,102 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
             None =>
                 match link_name.as_str() {
                     "miri_start_panic" => {
+                        let args = this.copy_fn_args(args)?; // FIXME: Should `InPlace` arguments be reset to uninit?
+
                         // `check_shim` happens inside `handle_miri_start_panic`.
-                        this.handle_miri_start_panic(abi, link_name, args, unwind)?;
+                        this.handle_miri_start_panic(abi, link_name, &args, unwind)?;
                         return Ok(None);
                     }
                     // This matches calls to the foreign item `panic_impl`.
                     // The implementation is provided by the function with the `#[panic_handler]` attribute.
                     "panic_impl" => {
                         // We don't use `check_shim` here because we are just forwarding to the lang
-                        // item. Argument count checking will be performed when the returned `Body` is
-                        // called.
+                        // item. Argument count checking will be performed in `eval_fn_call`.
                         this.check_abi_and_shim_symbol_clash(abi, Abi::Rust, link_name)?;
                         let panic_impl_id = tcx.lang_items().panic_impl().unwrap();
                         let panic_impl_instance = ty::Instance::mono(tcx, panic_impl_id);
-                        return Ok(Some((
-                            this.load_mir(panic_impl_instance.def, None)?,
-                            panic_impl_instance,
-                        )));
+
+                        this.eval_fn_call(
+                            FnVal::Instance(panic_impl_instance),
+                            (abi, fn_abi),
+                            args,
+                            false,
+                            dest,
+                            ret,
+                            unwind,
+                        )?;
+
+                        return Ok(Some(()));
                     }
                     #[rustfmt::skip]
-                    | "exit"
+                    "exit"
                     | "ExitProcess"
                     => {
                         let exp_abi = if link_name.as_str() == "exit" {
                             Abi::C { unwind: false }
                         } else {
                             Abi::System { unwind: false }
                         };
-                        let [code] = this.check_shim(abi, exp_abi, link_name, args)?;
+                        let args = this.copy_fn_args(args)?; // FIXME: Should `InPlace` arguments be reset to uninit?
+                        let [code] = this.check_shim(abi, exp_abi, link_name, &args)?;
                         // it's really u32 for ExitProcess, but we have to put it into the `Exit` variant anyway
                         let code = this.read_scalar(code)?.to_i32()?;
                         throw_machine_stop!(TerminationInfo::Exit { code: code.into(), leak_check: false });
                     }
                     "abort" => {
-                        let [] = this.check_shim(abi, Abi::C { unwind: false }, link_name, args)?;
+                        let args = this.copy_fn_args(args)?; // FIXME: Should `InPlace` arguments be reset to uninit?
+                        let [] =
+                            this.check_shim(abi, Abi::C { unwind: false }, link_name, &args)?;
                         throw_machine_stop!(TerminationInfo::Abort(
                             "the program aborted execution".to_owned()
                         ))
                     }
                     _ => {
-                        if let Some(body) = this.lookup_exported_symbol(link_name)? {
-                            return Ok(Some(body));
+                        if let Some(instance) = this.lookup_exported_symbol(link_name)? {
+                            this.eval_fn_call(
+                                FnVal::Instance(instance),
+                                (abi, fn_abi),
+                                args,
+                                false,
+                                dest,
+                                ret,
+                                unwind,
+                            )?;
+
+                            return Ok(Some(()));
                         }
+
                         this.handle_unsupported(format!(
                             "can't call (diverging) foreign function: {link_name}"
                         ))?;
+
                         return Ok(None);
                     }
                 },
             Some(p) => p,
         };
 
         // Second: functions that return immediately.
-        match this.emulate_foreign_item_inner(link_name, abi, args, dest)? {
+        let args2 = this.copy_fn_args(args)?; // FIXME: Should `InPlace` arguments be reset to uninit?
+        match this.emulate_foreign_item_inner(link_name, abi, &args2, dest)? {
             EmulateForeignItemResult::NeedsJumping => {
                 trace!("{:?}", this.dump_place(dest));
                 this.go_to_block(ret);
             }
             EmulateForeignItemResult::AlreadyJumped => (),
             EmulateForeignItemResult::NotSupported => {
-                if let Some(body) = this.lookup_exported_symbol(link_name)? {
-                    return Ok(Some(body));
+                if let Some(instance) = this.lookup_exported_symbol(link_name)? {
+                    this.eval_fn_call(
+                        FnVal::Instance(instance),
+                        (abi, fn_abi),
+                        args,
+                        false,
+                        dest,
+                        Some(ret),
+                        unwind,
+                    )?;
+
+                    return Ok(Some(()));
                 }
 
                 this.handle_unsupported(format!(
@@ -147,13 +191,13 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
     fn emulate_dyn_sym(
         &mut self,
         sym: DynSym,
-        abi: Abi,
-        args: &[OpTy<'tcx, Provenance>],
+        abis: (Abi, &FnAbi<'tcx, Ty<'tcx>>),
+        args: &[FnArg<'tcx, Provenance>],
         dest: &PlaceTy<'tcx, Provenance>,
         ret: Option<mir::BasicBlock>,
         unwind: mir::UnwindAction,
     ) -> InterpResult<'tcx> {
-        let res = self.emulate_foreign_item(sym.0, abi, args, dest, ret, unwind)?;
+        let res = self.emulate_foreign_item(sym.0, abis, args, dest, ret, unwind)?;
         assert!(res.is_none(), "DynSyms that delegate are not supported");
         Ok(())
     }
@@ -162,7 +206,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
     fn lookup_exported_symbol(
         &mut self,
         link_name: Symbol,
-    ) -> InterpResult<'tcx, Option<(&'mir mir::Body<'tcx>, ty::Instance<'tcx>)>> {
+    ) -> InterpResult<'tcx, Option<ty::Instance<'tcx>>> {
         let this = self.eval_context_mut();
         let tcx = this.tcx.tcx;
 
@@ -246,10 +290,8 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 e.insert(instance_and_crate.map(|ic| ic.0))
             }
         };
-        match instance {
-            None => Ok(None), // no symbol with this name
-            Some(instance) => Ok(Some((this.load_mir(instance.def, None)?, instance))),
-        }
+
+        Ok(instance)
     }
 
     fn malloc(

src/tools/miri/src/shims/unix/foreign_items.rs

@@ -6,6 +6,7 @@ use rustc_span::Symbol;
 use rustc_target::abi::{Align, Size};
 use rustc_target::spec::abi::Abi;
 
+use crate::shims::foreign_items::ExtraFnVal;
 use crate::*;
 use shims::foreign_items::EmulateForeignItemResult;
 use shims::unix::fs::EvalContextExt as _;
@@ -308,7 +309,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 let symbol = this.read_pointer(symbol)?;
                 let name = this.read_c_str(symbol)?;
                 if let Ok(name) = str::from_utf8(name) && is_dyn_sym(name, &this.tcx.sess.target.os) {
-                    let ptr = this.fn_ptr(FnVal::Other(DynSym::from_str(name)));
+                    let ptr = this.fn_ptr(FnVal::Other(ExtraFnVal::DynSym(DynSym::from_str(name))));
                     this.write_pointer(ptr, dest)?;
                 } else {
                     this.write_null(dest)?;

src/tools/miri/src/shims/windows/foreign_items.rs

@@ -5,6 +5,7 @@ use rustc_span::Symbol;
 use rustc_target::abi::Size;
 use rustc_target::spec::abi::Abi;
 
+use crate::shims::foreign_items::ExtraFnVal;
 use crate::*;
 use shims::foreign_items::EmulateForeignItemResult;
 use shims::windows::handle::{EvalContextExt as _, Handle, PseudoHandle};
@@ -366,7 +367,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 if let Ok(name) = str::from_utf8(name)
                     && is_dyn_sym(name)
                 {
-                    let ptr = this.fn_ptr(FnVal::Other(DynSym::from_str(name)));
+                    let ptr = this.fn_ptr(FnVal::Other(ExtraFnVal::DynSym(DynSym::from_str(name))));
                     this.write_pointer(ptr, dest)?;
                 } else {
                     this.write_null(dest)?;