miri ignores `-Ctarget-cpu` since `nightly-2025-11-10`

[usamoi]

I tried this code:

fn main() {
    dbg!(cfg!(target_feature = "avx2"));
}

RUSTFLAGS="-Ctarget-cpu=x86-64-v3" cargo miri run

I expected to see this happen:

[src/main.rs:2:5] cfg!(target_feature = "avx2") = true

Instead, this happened:

[src/main.rs:2:5] cfg!(target_feature = "avx2") = false

If -Ctarget-feature is used:

RUSTFLAGS="-Ctarget-feature=+avx2" cargo miri run

[src/main.rs:2:5] cfg!(target_feature = "avx2") = true

If -Zcodegen-backend=llvm is used:

RUSTFLAGS="-Ctarget-cpu=x86-64-v3 -Zcodegen-backend=llvm" cargo miri run

[src/main.rs:2:5] cfg!(target_feature = "avx2") = true

Meta

rustc 1.93.0-nightly (6647be936 2025-11-09)
binary: rustc
commit-hash: 6647be93640686a2a443a49f15c3390b68c8b5dd
commit-date: 2025-11-09
host: x86_64-unknown-linux-gnu
release: 1.93.0-nightly
LLVM version: 21.1.3

nightly-2025-11-09 works but nightly-2025-11-10 doesn't. So probably it's caused by #148734.

[bjorn3]

This is caused by rust-lang/miri#4648. Basically miri no longer uses LLVM at all, so it also skips the code that queries the target features from LLVM and instead does it's own target feature computation. Rustc doesn't know anything about which -Ctarget-cpu corresponds to which -Ctarget-features.

[bjorn3]

cc @RalfJung the fact that rustc doesn't know about -Ctarget-cpu is a bit unfortunate.

[RalfJung]

Ah... yeah we should really have a test for that.

Can this be easily fixed with the dummy codegen backend, or do we have to switch back to the LLVM backend for now?

[RalfJung]

And while we are at it, we also should have a test to check that target features that are declared via target options (but are not mandatory via the ABI) are enabled.

armv7_unknown_linux_gnueabihf seems to be a good target for that, assuming that one of these can be queried via cfg!: +v7,+vfp3,+thumb2.

[bjorn3]

Can this be easily fixed with the dummy codegen backend

We could hard code a map from target-cpu to target-features I guess.

And while we are at it, we also should have a test to check that target features that are declared via target options (but are not mandatory via the ABI) are enabled.

-Ctarget-features works with the dummy backend. #149173 causes the target spec features to also be respected. In either case target_cpu and -Ctarget-cpu are not respected due to rustc not knowing which target cpu corresponds to which target features. But yeah, there should be a test for that.

[RalfJung]

We could hard code a map from target-cpu to target-features I guess.

That sounds like a permanent game of whack-a-mole, in particular if that map is not used by default... (i.e. only with Miri and non-default codegen backends)

[bjorn3]

cg_clif doesn't support -Ctarget-cpu either (aside from -Ctarget-cpu=native which unlike LLVM in cg_clif doesn't detect the host cpu and derives the target features from that, but directly checks for target feature availability) because no such map exists in rustc. Perhaps it could be automatically generated by cg_llvm by querying LLVM and then checked that it is still accurate with a tidy check?

[RalfJung]

This seems like a good discussion to have with more of t-compiler, and in particular the GCC backend folks. Many years ago the choice was made that we'll just use LLVM for this since we didn't want to carry a CPU table, but a lot has changed since then. I don't have a strong opinion, except I'd prefer if the mechanism could be backend-independent. If this means the backend can no longer influence cfg(target_features), that might then actually allow us to do some larger cleanup of the entire target feature handling during session setup.

But for Miri this used to work so I'd rather fix the regression without waiting for a solution for this long-standing problem. Changing Miri to use the dummy backend was a risky change, we knew that, so we shouldn't hesitate to revert when problems show up. We can always re-land that change later.

[bjorn3]

I thought of an alternative: Use the LLVM codegen backend, but only for the target_config method, not for building rlibs and the like. I don't think the changes are too bad:

 compiler/rustc_interface/src/interface.rs |  5 +++--
 compiler/rustc_interface/src/util.rs      | 10 ++++++++--
 src/tools/miri/src/bin/miri.rs            | 29 ++++++++++++++++++++++++++++-
 src/tools/miri/src/lib.rs                 |  1 -
 4 files changed, 39 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_interface/src/interface.rs b/compiler/rustc_interface/src/interface.rs
index af1c35774a6..c0f8f33692e 100644
--- a/compiler/rustc_interface/src/interface.rs
+++ b/compiler/rustc_interface/src/interface.rs
@@ -24,6 +24,7 @@
 use rustc_session::{CompilerIO, EarlyDiagCtxt, Session, lint};
 use rustc_span::source_map::{FileLoader, RealFileLoader, SourceMapInputs};
 use rustc_span::{FileName, sym};
+use rustc_target::spec::Target;
 use tracing::trace;
 
 use crate::util;
@@ -385,7 +386,7 @@ pub struct Config {
     /// custom driver where the custom codegen backend has arbitrary data."
     /// (See #102759.)
     pub make_codegen_backend:
-        Option<Box<dyn FnOnce(&config::Options) -> Box<dyn CodegenBackend> + Send>>,
+        Option<Box<dyn FnOnce(&config::Options, &Target) -> Box<dyn CodegenBackend> + Send>>,
 
     /// Registry of diagnostics codes.
     pub registry: Registry,
@@ -453,7 +454,7 @@ pub fn run_compiler<R: Send>(config: Config, f: impl FnOnce(&Compiler) -> R + Se
                 Some(make_codegen_backend) => {
                     // N.B. `make_codegen_backend` takes precedence over
                     // `target.default_codegen_backend`, which is ignored in this case.
-                    make_codegen_backend(&config.opts)
+                    make_codegen_backend(&config.opts, &target)
                 }
             };
 
diff --git a/compiler/rustc_interface/src/util.rs b/compiler/rustc_interface/src/util.rs
index 2e100a6215c..8a71f82d0d8 100644
--- a/compiler/rustc_interface/src/util.rs
+++ b/compiler/rustc_interface/src/util.rs
@@ -339,7 +339,7 @@ pub fn get_codegen_backend(
             filename if filename.contains('.') => {
                 load_backend_from_dylib(early_dcx, filename.as_ref())
             }
-            "dummy" => || Box::new(DummyCodegenBackend),
+            "dummy" => || Box::new(DummyCodegenBackend { target_config_override: None }),
             #[cfg(feature = "llvm")]
             "llvm" => rustc_codegen_llvm::LlvmCodegenBackend::new,
             backend_name => get_codegen_sysroot(early_dcx, sysroot, backend_name),
@@ -352,7 +352,9 @@ pub fn get_codegen_backend(
     unsafe { load() }
 }
 
-struct DummyCodegenBackend;
+pub struct DummyCodegenBackend {
+    pub target_config_override: Option<Box<dyn Fn(&Session) -> TargetConfig>>,
+}
 
 impl CodegenBackend for DummyCodegenBackend {
     fn locale_resource(&self) -> &'static str {
@@ -364,6 +366,10 @@ fn name(&self) -> &'static str {
     }
 
     fn target_config(&self, sess: &Session) -> TargetConfig {
+        if let Some(target_config_override) = &self.target_config_override {
+            return target_config_override(sess);
+        }
+
         let (target_features, unstable_target_features) = cfg_target_feature::<0>(
             sess,
             |_feature| Default::default(),
diff --git a/src/tools/miri/src/bin/miri.rs b/src/tools/miri/src/bin/miri.rs
index 9f1ff238359..c9e0b99c221 100644
--- a/src/tools/miri/src/bin/miri.rs
+++ b/src/tools/miri/src/bin/miri.rs
@@ -10,6 +10,7 @@
 
 // The rustc crates we need
 extern crate rustc_abi;
+extern crate rustc_codegen_ssa;
 extern crate rustc_data_structures;
 extern crate rustc_driver;
 extern crate rustc_hir;
@@ -19,6 +20,7 @@
 extern crate rustc_middle;
 extern crate rustc_session;
 extern crate rustc_span;
+extern crate rustc_target;
 
 /// See docs in https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc/src/main.rs
 /// and https://github.com/rust-lang/rust/pull/146627 for why we need this.
@@ -43,12 +45,14 @@
     ProvenanceMode, TreeBorrowsParams, ValidationMode, run_genmc_mode,
 };
 use rustc_abi::ExternAbi;
+use rustc_codegen_ssa::traits::CodegenBackend;
 use rustc_data_structures::sync::{self, DynSync};
 use rustc_driver::Compilation;
 use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_hir::{self as hir, Node};
 use rustc_hir_analysis::check::check_function_signature;
 use rustc_interface::interface::Config;
+use rustc_interface::util::DummyCodegenBackend;
 use rustc_log::tracing::debug;
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use rustc_middle::middle::exported_symbols::{
@@ -58,8 +62,9 @@
 use rustc_middle::traits::{ObligationCause, ObligationCauseCode};
 use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_session::EarlyDiagCtxt;
-use rustc_session::config::{CrateType, ErrorOutputType, OptLevel};
+use rustc_session::config::{CrateType, ErrorOutputType, OptLevel, Options};
 use rustc_span::def_id::DefId;
+use rustc_target::spec::Target;
 
 use crate::log::setup::{deinit_loggers, init_early_loggers, init_late_loggers};
 
@@ -161,7 +166,27 @@ fn run_many_seeds(
     }
 }
 
+fn make_codegen_backend(opts: &Options, target: &Target) -> Box<dyn CodegenBackend> {
+    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);
+
+    Box::new(DummyCodegenBackend {
+        target_config_override: Some(Box::new(move |sess| {
+            target_config_backend.init(sess);
+            target_config_backend.target_config(sess)
+        })),
+    })
+}
+
 impl rustc_driver::Callbacks for MiriCompilerCalls {
+    fn config(&mut self, config: &mut rustc_interface::interface::Config) {
+        config.make_codegen_backend = Some(Box::new(make_codegen_backend));
+    }
+
     fn after_analysis<'tcx>(
         &mut self,
         _: &rustc_interface::interface::Compiler,
@@ -244,6 +269,8 @@ struct MiriBeRustCompilerCalls {
 impl rustc_driver::Callbacks for MiriBeRustCompilerCalls {
     #[allow(rustc::potential_query_instability)] // rustc_codegen_ssa (where this code is copied from) also allows this lint
     fn config(&mut self, config: &mut Config) {
+        config.make_codegen_backend = Some(Box::new(make_codegen_backend));
+
         if config.opts.prints.is_empty() && self.target_crate {
             #[allow(rustc::bad_opt_access)] // tcx does not exist yet
             {
diff --git a/src/tools/miri/src/lib.rs b/src/tools/miri/src/lib.rs
index 5ec2e8edd85..b30395b738b 100644
--- a/src/tools/miri/src/lib.rs
+++ b/src/tools/miri/src/lib.rs
@@ -165,7 +165,6 @@ pub mod native_lib {
 /// Also disable the MIR pass that inserts an alignment check on every pointer dereference. Miri
 /// does that too, and with a better error message.
 pub const MIRI_DEFAULT_ARGS: &[&str] = &[
-    "-Zcodegen-backend=dummy",
     "--cfg=miri",
     "-Zalways-encode-mir",
     "-Zextra-const-ub-checks",

Edit: #149323