Use -Zjit-mode in miri

bjorn3 · bjorn3 · commit 037f86f43001 · 2026-01-12T15:27:08.000Z
If cargo gets native support for -Zjit-mode, this should allow
simplifying cargo-miri a fair bit.
diff --git a/src/tools/miri/src/bin/miri.rs b/src/tools/miri/src/bin/miri.rs
@@ -18,6 +18,7 @@ extern crate rustc_hir_analysis;
 extern crate rustc_interface;
 extern crate rustc_log;
 extern crate rustc_middle;
+extern crate rustc_query_system;
 extern crate rustc_session;
 extern crate rustc_span;
 extern crate rustc_target;
@@ -38,9 +39,12 @@ extern crate tikv_jemalloc_sys as _;
 
 mod log;
 
+use std::any::Any;
+use std::cell::RefCell;
 use std::env;
 use std::num::{NonZero, NonZeroI32};
 use std::ops::Range;
+use std::process::ExitCode;
 use std::rc::Rc;
 use std::str::FromStr;
 use std::sync::Once;
@@ -52,6 +56,8 @@ use miri::{
 };
 use rustc_abi::ExternAbi;
 use rustc_codegen_ssa::traits::CodegenBackend;
+use rustc_codegen_ssa::{CodegenResults, TargetConfig};
+use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::sync::{self, DynSync};
 use rustc_driver::Compilation;
 use rustc_hir::def_id::LOCAL_CRATE;
@@ -67,8 +73,9 @@ use rustc_middle::middle::exported_symbols::{
 use rustc_middle::query::LocalCrate;
 use rustc_middle::traits::{ObligationCause, ObligationCauseCode};
 use rustc_middle::ty::{self, Ty, TyCtxt};
-use rustc_session::EarlyDiagCtxt;
-use rustc_session::config::{CrateType, ErrorOutputType, OptLevel, Options};
+use rustc_query_system::dep_graph::{WorkProduct, WorkProductId};
+use rustc_session::config::{CrateType, ErrorOutputType, OptLevel, Options, OutputFilenames};
+use rustc_session::{EarlyDiagCtxt, Session};
 use rustc_span::def_id::DefId;
 use rustc_target::spec::Target;
 
@@ -193,15 +200,64 @@ fn make_miri_codegen_backend(opts: &Options, target: &Target) -> Box<dyn Codegen
 }
 
 impl rustc_driver::Callbacks for MiriCompilerCalls {
-    fn config(&mut self, config: &mut rustc_interface::interface::Config) {
-        config.make_codegen_backend = Some(Box::new(make_miri_codegen_backend));
+    fn config(&mut self, config: &mut Config) {
+        let mut miri_config = self.miri_config.take();
+        let mut many_seeds = self.many_seeds.take();
+
+        config.make_codegen_backend = Some(Box::new(move |opts, target| {
+            let early_dcx = EarlyDiagCtxt::new(opts.error_format);
+
+            // Use the target_config method of the default codegen backend (eg LLVM) to ensure the
+            // calculated target features match said backend by respecting eg -Ctarget-cpu.
+            let target_config_backend =
+                rustc_interface::util::get_codegen_backend(&early_dcx, &opts.sysroot, None, target);
+            let target_config_backend_init = Once::new();
+
+            Box::new(MiriCodegenBackend {
+                miri_config: RefCell::new(miri_config.take()),
+                many_seeds: RefCell::new(many_seeds.take()),
+                target_config_override: Box::new(move |sess| {
+                    target_config_backend_init.call_once(|| target_config_backend.init(sess));
+                    target_config_backend.target_config(sess)
+                }),
+            })
+        }));
     }
+}
 
-    fn after_analysis<'tcx>(
-        &mut self,
-        _: &rustc_interface::interface::Compiler,
-        tcx: TyCtxt<'tcx>,
-    ) -> Compilation {
+struct MiriCodegenBackend {
+    miri_config: RefCell<Option<MiriConfig>>,
+    many_seeds: RefCell<Option<ManySeedsConfig>>,
+    target_config_override: Box<dyn Fn(&Session) -> TargetConfig>,
+}
+
+impl CodegenBackend for MiriCodegenBackend {
+    fn name(&self) -> &'static str {
+        "miri"
+    }
+
+    fn locale_resource(&self) -> &'static str {
+        ""
+    }
+
+    fn target_config(&self, sess: &Session) -> TargetConfig {
+        (self.target_config_override)(sess)
+    }
+
+    fn codegen_crate<'tcx>(&self, _tcx: TyCtxt<'tcx>) -> Box<dyn Any> {
+        unreachable!()
+    }
+
+    fn join_codegen(
+        &self,
+        _ongoing_codegen: Box<dyn Any>,
+        _sess: &Session,
+        _outputs: &OutputFilenames,
+    ) -> (CodegenResults, FxIndexMap<WorkProductId, WorkProduct>) {
+        unreachable!()
+    }
+
+    fn jit_crate<'tcx>(&self, tcx: TyCtxt<'tcx>, mut args: Vec<String>) -> ExitCode {
         // Compilation is done, interpretation is starting. Deal with diagnostics from the
         // compilation part. We cannot call `sess.finish_diagnostics()` as then "aborting due to
         // previous errors" gets printed twice.
@@ -219,9 +275,10 @@ impl rustc_driver::Callbacks for MiriCompilerCalls {
         let (entry_def_id, entry_type) = entry_fn(tcx);
 
         // Obtain and complete the Miri configuration.
-        let mut config = self.miri_config.take().expect("after_analysis must only be called once");
+        let config = self.miri_config.take().expect("after_analysis must only be called once");
+
         // Add filename to `miri` arguments.
-        config.args.insert(0, tcx.sess.io.input.filestem().to_string());
+        args.insert(0, tcx.sess.io.input.filestem().to_string());
 
         // Adjust working directory for interpretation.
         if let Some(cwd) = env::var_os("MIRI_CWD") {
@@ -245,20 +302,27 @@ impl rustc_driver::Callbacks for MiriCompilerCalls {
 
         // Invoke the interpreter.
         let res = if config.genmc_config.is_some() {
-            assert!(self.many_seeds.is_none());
+            assert!(self.many_seeds.borrow().is_none());
             run_genmc_mode(tcx, &config, |genmc_ctx: Rc<GenmcCtx>| {
-                miri::eval_entry(tcx, entry_def_id, entry_type, &config, Some(genmc_ctx))
+                miri::eval_entry(tcx, entry_def_id, entry_type, &args, &config, Some(genmc_ctx))
             })
         } else if let Some(many_seeds) = self.many_seeds.take() {
             assert!(config.seed.is_none());
             run_many_seeds(many_seeds, |seed| {
                 let mut config = config.clone();
                 config.seed = Some(seed);
                 eprintln!("Trying seed: {seed}");
-                miri::eval_entry(tcx, entry_def_id, entry_type, &config, /* genmc_ctx */ None)
+                miri::eval_entry(
+                    tcx,
+                    entry_def_id,
+                    entry_type,
+                    &args,
+                    &config,
+                    /* genmc_ctx */ None,
+                )
             })
         } else {
-            miri::eval_entry(tcx, entry_def_id, entry_type, &config, None)
+            miri::eval_entry(tcx, entry_def_id, entry_type, &args, &config, None)
         };
         // Process interpreter result.
         if let Err(return_code) = res {
@@ -486,6 +550,7 @@ fn main() {
 
     let mut rustc_args = vec![];
     let mut after_dashdash = false;
+    let mut guest_args = vec![];
 
     // Note that we require values to be given with `=`, not with a space.
     // This matches how rustc parses `-Z`.
@@ -498,7 +563,7 @@ fn main() {
             rustc_args.extend(miri::MIRI_DEFAULT_ARGS.iter().map(ToString::to_string));
         } else if after_dashdash {
             // Everything that comes after `--` is forwarded to the interpreted crate.
-            miri_config.args.push(arg);
+            guest_args.push(arg);
         } else if arg == "--" {
             after_dashdash = true;
         } else if arg == "-Zmiri-disable-validation" {
@@ -745,7 +810,6 @@ fn main() {
         many_seeds.map(|seeds| ManySeedsConfig { seeds, keep_going: many_seeds_keep_going });
 
     debug!("rustc arguments: {:?}", rustc_args);
-    debug!("crate arguments: {:?}", miri_config.args);
     if !miri_config.native_lib.is_empty() && miri_config.native_lib_enable_tracing {
         // SAFETY: No other threads are running
         #[cfg(all(unix, feature = "native-lib"))]
@@ -756,5 +820,9 @@ fn main() {
             );
         }
     }
+    rustc_args.push("-Zjit-mode".to_owned());
+    rustc_args.push("--".to_owned());
+    rustc_args.extend(guest_args);
+
     run_compiler_and_exit(&rustc_args, &mut MiriCompilerCalls::new(miri_config, many_seeds))
 }
diff --git a/src/tools/miri/src/eval.rs b/src/tools/miri/src/eval.rs
@@ -54,8 +54,6 @@ pub struct MiriConfig {
     pub forwarded_env_vars: Vec<String>,
     /// Additional environment variables that should be set in the interpreted program.
     pub set_env_vars: FxHashMap<String, String>,
-    /// Command-line arguments passed to the interpreted program.
-    pub args: Vec<String>,
     /// The seed to use when non-determinism or randomness are required (e.g. ptr-to-int cast, `getrandom()`).
     pub seed: Option<u64>,
     /// The stacked borrows pointer ids to report about.
@@ -130,7 +128,6 @@ impl Default for MiriConfig {
             ignore_leaks: false,
             forwarded_env_vars: vec![],
             set_env_vars: FxHashMap::default(),
-            args: vec![],
             seed: None,
             tracked_pointer_tags: FxHashSet::default(),
             tracked_alloc_ids: FxHashSet::default(),
@@ -276,6 +273,7 @@ pub fn create_ecx<'tcx>(
     tcx: TyCtxt<'tcx>,
     entry_id: DefId,
     entry_type: MiriEntryFnType,
+    args: &[String],
     config: &MiriConfig,
     genmc_ctx: Option<Rc<GenmcCtx>>,
 ) -> InterpResult<'tcx, InterpCx<'tcx, MiriMachine<'tcx>>> {
@@ -299,12 +297,11 @@ pub fn create_ecx<'tcx>(
     }
 
     // Compute argc and argv from `config.args`.
-    let argc =
-        ImmTy::from_int(i64::try_from(config.args.len()).unwrap(), ecx.machine.layouts.isize);
+    let argc = ImmTy::from_int(i64::try_from(args.len()).unwrap(), ecx.machine.layouts.isize);
     let argv = {
         // Put each argument in memory, collect pointers.
-        let mut argvs = Vec::<Immediate<Provenance>>::with_capacity(config.args.len());
-        for arg in config.args.iter() {
+        let mut argvs = Vec::<Immediate<Provenance>>::with_capacity(args.len());
+        for arg in args.iter() {
             // Make space for `0` terminator.
             let size = u64::try_from(arg.len()).unwrap().strict_add(1);
             let arg_type = Ty::new_array(tcx, tcx.types.u8, size);
@@ -342,7 +339,7 @@ pub fn create_ecx<'tcx>(
         // Store command line as UTF-16 for Windows `GetCommandLineW`.
         if tcx.sess.target.os == Os::Windows {
             // Construct a command string with all the arguments.
-            let cmd_utf16: Vec<u16> = args_to_utf16_command_string(config.args.iter());
+            let cmd_utf16: Vec<u16> = args_to_utf16_command_string(args.iter());
 
             let cmd_type =
                 Ty::new_array(tcx, tcx.types.u16, u64::try_from(cmd_utf16.len()).unwrap());
@@ -458,13 +455,15 @@ pub fn eval_entry<'tcx>(
     tcx: TyCtxt<'tcx>,
     entry_id: DefId,
     entry_type: MiriEntryFnType,
+    args: &[String],
     config: &MiriConfig,
     genmc_ctx: Option<Rc<GenmcCtx>>,
 ) -> Result<(), NonZeroI32> {
     // Copy setting before we move `config`.
     let ignore_leaks = config.ignore_leaks;
 
-    let mut ecx = match create_ecx(tcx, entry_id, entry_type, config, genmc_ctx).report_err() {
+    let mut ecx = match create_ecx(tcx, entry_id, entry_type, args, config, genmc_ctx).report_err()
+    {
         Ok(v) => v,
         Err(err) => {
             let (kind, backtrace) = err.into_parts();
