Enable automatic cross-compilation in run-make tests

Kobzol · Kobzol · commit cbc3f76d68d0 · 2025-03-05T18:25:56.000+01:00
diff --git a/src/tools/run-make-support/src/external_deps/rustc.rs b/src/tools/run-make-support/src/external_deps/rustc.rs
@@ -6,7 +6,7 @@ use crate::command::Command;
 use crate::env::env_var;
 use crate::path_helpers::cwd;
 use crate::util::set_host_compiler_dylib_path;
-use crate::{is_aix, is_darwin, is_msvc, is_windows, uname};
+use crate::{is_aix, is_darwin, is_msvc, is_windows, target, uname};
 
 /// Construct a new `rustc` invocation. This will automatically set the library
 /// search path as `-L cwd()`. Use [`bare_rustc`] to avoid this.
@@ -52,12 +52,17 @@ impl Rustc {
     // `rustc` invocation constructor methods
 
     /// Construct a new `rustc` invocation. This will automatically set the library
-    /// search path as `-L cwd()`. Use [`bare_rustc`] to avoid this.
+    /// search path as `-L cwd()` and also the compilation target.
+    /// Use [`bare_rustc`] to avoid this.
     #[track_caller]
     pub fn new() -> Self {
         let mut cmd = setup_common();
         cmd.arg("-L").arg(cwd());
-        Self { cmd }
+
+        let mut rustc = Self { cmd };
+        // Automatically support cross-compilation
+        rustc.target(target());
+        rustc
     }
 
     /// Construct a bare `rustc` invocation with no flags set.
diff --git a/tests/run-make/amdgpu-kd/rmake.rs b/tests/run-make/amdgpu-kd/rmake.rs
@@ -6,10 +6,10 @@
 //@ needs-llvm-components: amdgpu
 //@ needs-rust-lld
 
-use run_make_support::{llvm_readobj, rustc};
+use run_make_support::{bare_rustc, llvm_readobj};
 
 fn main() {
-    rustc()
+    bare_rustc()
         .crate_name("foo")
         .target("amdgcn-amd-amdhsa")
         .arg("-Ctarget-cpu=gfx900")
diff --git a/tests/run-make/apple-deployment-target/rmake.rs b/tests/run-make/apple-deployment-target/rmake.rs
@@ -41,7 +41,6 @@ fn main() {
 
     // Remove env vars to get `rustc`'s default
     let output = rustc()
-        .target(target())
         .env_remove("MACOSX_DEPLOYMENT_TARGET")
         .env_remove("IPHONEOS_DEPLOYMENT_TARGET")
         .env_remove("WATCHOS_DEPLOYMENT_TARGET")
@@ -58,7 +57,6 @@ fn main() {
     run_in_tmpdir(|| {
         let rustc = || {
             let mut rustc = rustc();
-            rustc.target(target());
             rustc.crate_type("lib");
             rustc.emit("obj");
             rustc.input("foo.rs");
@@ -82,7 +80,6 @@ fn main() {
 
         let rustc = || {
             let mut rustc = rustc();
-            rustc.target(target());
             rustc.crate_type("dylib");
             rustc.input("foo.rs");
             rustc.output("libfoo.dylib");
@@ -108,7 +105,6 @@ fn main() {
     run_in_tmpdir(|| {
         let rustc = || {
             let mut rustc = rustc();
-            rustc.target(target());
             rustc.crate_type("bin");
             rustc.input("foo.rs");
             rustc.output("foo");
@@ -147,7 +143,6 @@ fn main() {
     run_in_tmpdir(|| {
         let rustc = || {
             let mut rustc = rustc();
-            rustc.target(target());
             rustc.incremental("incremental");
             rustc.crate_type("lib");
             rustc.emit("obj");
diff --git a/tests/run-make/apple-sdk-version/rmake.rs b/tests/run-make/apple-sdk-version/rmake.rs
@@ -24,8 +24,7 @@ fn has_sdk_version(file: &str, version: &str) {
 
 fn main() {
     // Fetch rustc's inferred deployment target.
-    let current_deployment_target =
-        rustc().target(target()).print("deployment-target").run().stdout_utf8();
+    let current_deployment_target = rustc().print("deployment-target").run().stdout_utf8();
     let current_deployment_target = current_deployment_target.split('=').last().unwrap().trim();
 
     // Fetch current SDK version via. xcrun.
@@ -45,15 +44,15 @@ fn main() {
     let current_sdk_version = current_sdk_version.trim();
 
     // Check the SDK version in the object file produced by the codegen backend.
-    rustc().target(target()).crate_type("lib").emit("obj").input("foo.rs").output("foo.o").run();
+    rustc().crate_type("lib").emit("obj").input("foo.rs").output("foo.o").run();
     // Set to 0, which means not set or "n/a".
     has_sdk_version("foo.o", "n/a");
 
     // Check the SDK version in the .rmeta file, as set in `create_object_file`.
     //
     // This is just to ensure that we don't set some odd version in `create_object_file`,
     // if the rmeta file is packed in a different way in the future, this can safely be removed.
-    rustc().target(target()).crate_type("rlib").input("foo.rs").output("libfoo.rlib").run();
+    rustc().crate_type("rlib").input("foo.rs").output("libfoo.rlib").run();
     // Extra .rmeta file (which is encoded as an object file).
     cmd("ar").arg("-x").arg("libfoo.rlib").arg("lib.rmeta").run();
     has_sdk_version("lib.rmeta", "n/a");
@@ -69,7 +68,6 @@ fn main() {
         // Test with clang
         let file_name = format!("foo_cc{file_ext}");
         rustc()
-            .target(target())
             .crate_type("bin")
             .arg("-Clinker-flavor=gcc")
             .input("foo.rs")
@@ -80,7 +78,6 @@ fn main() {
         // Test with ld64
         let file_name = format!("foo_ld{file_ext}");
         rustc()
-            .target(target())
             .crate_type("bin")
             .arg("-Clinker-flavor=ld")
             .input("foo.rs")
diff --git a/tests/run-make/atomic-lock-free/rmake.rs b/tests/run-make/atomic-lock-free/rmake.rs
@@ -3,10 +3,10 @@
 
 //@ only-linux
 
-use run_make_support::{llvm_components_contain, llvm_readobj, rustc};
+use run_make_support::{bare_rustc, llvm_components_contain, llvm_readobj};
 
 fn compile(target: &str) {
-    rustc().input("atomic_lock_free.rs").target(target).run();
+    bare_rustc().input("atomic_lock_free.rs").target(target).run();
 }
 
 fn check() {
diff --git a/tests/run-make/avr-rjmp-offset/rmake.rs b/tests/run-make/avr-rjmp-offset/rmake.rs
@@ -15,10 +15,10 @@
 // crashes... so I'm going to disable this test for windows for now.
 //@ ignore-windows-gnu
 
-use run_make_support::{llvm_objdump, rustc};
+use run_make_support::{bare_rustc, llvm_objdump};
 
 fn main() {
-    rustc()
+    bare_rustc()
         .input("avr-rjmp-offsets.rs")
         .opt_level("s")
         .panic("abort")
diff --git a/tests/run-make/comment-section/rmake.rs b/tests/run-make/comment-section/rmake.rs
@@ -7,12 +7,12 @@
 // FIXME(jieyouxu): check cross-compile setup
 //@ ignore-cross-compile
 
-use run_make_support::{cwd, env_var, llvm_readobj, rfs, rustc};
+use run_make_support::{bare_rustc, cwd, env_var, llvm_readobj, rfs};
 
 fn main() {
     let target = env_var("TARGET");
 
-    rustc()
+    bare_rustc()
         .arg("-")
         .stdin_buf("fn main() {}")
         .emit("link,obj")
diff --git a/tests/run-make/llvm-ident/rmake.rs b/tests/run-make/llvm-ident/rmake.rs
@@ -16,7 +16,6 @@ fn main() {
         .arg("-Csave-temps")
         .codegen_units(16)
         .opt_level("2")
-        .target(&env_var("TARGET"))
         .stdin_buf("fn main(){}")
         .run();
 
diff --git a/tests/run-make/min-global-align/rmake.rs b/tests/run-make/min-global-align/rmake.rs
@@ -7,17 +7,21 @@
 // Reason: this test is specific to linux, considering compilation is targeted
 // towards linux architectures only.
 
-use run_make_support::{assert_count_is, llvm_components_contain, rfs, rustc};
+use run_make_support::{assert_count_is, bare_rustc, llvm_components_contain, rfs};
 
 fn main() {
     // Most targets are happy with default alignment -- take i686 for example.
     if llvm_components_contain("x86") {
-        rustc().target("i686-unknown-linux-gnu").emit("llvm-ir").input("min_global_align.rs").run();
+        bare_rustc()
+            .target("i686-unknown-linux-gnu")
+            .emit("llvm-ir")
+            .input("min_global_align.rs")
+            .run();
         assert_count_is(3, rfs::read_to_string("min_global_align.ll"), "align 1");
     }
     // SystemZ requires even alignment for PC-relative addressing.
     if llvm_components_contain("systemz") {
-        rustc()
+        bare_rustc()
             .target("s390x-unknown-linux-gnu")
             .emit("llvm-ir")
             .input("min_global_align.rs")
diff --git a/tests/run-make/mismatching-target-triples/rmake.rs b/tests/run-make/mismatching-target-triples/rmake.rs
@@ -5,11 +5,16 @@
 // error message is used.
 // See https://github.com/rust-lang/rust/issues/10814
 
-use run_make_support::rustc;
+use run_make_support::bare_rustc;
 
 fn main() {
-    rustc().input("foo.rs").target("i686-unknown-linux-gnu").run();
-    rustc().input("bar.rs").target("x86_64-unknown-linux-gnu").run_fail().assert_stderr_contains(
-        r#"couldn't find crate `foo` with expected target triple x86_64-unknown-linux-gnu"#,
-    );
+    bare_rustc().input("foo.rs").target("i686-unknown-linux-gnu").run();
+    bare_rustc()
+        .input("bar.rs")
+        .library_search_path(".")
+        .target("x86_64-unknown-linux-gnu")
+        .run_fail()
+        .assert_stderr_contains(
+            r#"couldn't find crate `foo` with expected target triple x86_64-unknown-linux-gnu"#,
+        );
 }
diff --git a/tests/run-make/mte-ffi/rmake.rs b/tests/run-make/mte-ffi/rmake.rs
@@ -22,11 +22,7 @@ fn run_test(variant: &str) {
         flags
     };
     println!("{variant} test...");
-    rustc()
-        .input(format!("foo_{variant}.rs"))
-        .target(target())
-        .linker("aarch64-linux-gnu-gcc")
-        .run();
+    rustc().input(format!("foo_{variant}.rs")).linker("aarch64-linux-gnu-gcc").run();
     gcc()
         .input(format!("bar_{variant}.c"))
         .input(dynamic_lib_name("foo"))
diff --git a/tests/run-make/musl-default-linking/rmake.rs b/tests/run-make/musl-default-linking/rmake.rs
@@ -1,4 +1,4 @@
-use run_make_support::{rustc, serde_json};
+use run_make_support::{bare_rustc, rustc, serde_json};
 
 // Please do NOT add more targets to this list!
 // Per https://github.com/rust-lang/compiler-team/issues/422,
@@ -36,7 +36,7 @@ fn main() {
             continue;
         }
 
-        let target_spec_json = rustc()
+        let target_spec_json = bare_rustc()
             .print("target-spec-json")
             .target(target)
             .arg("-Zunstable-options")
diff --git a/tests/run-make/print-cfg/rmake.rs b/tests/run-make/print-cfg/rmake.rs
@@ -14,7 +14,7 @@ use std::collections::HashSet;
 use std::iter::FromIterator;
 use std::path::PathBuf;
 
-use run_make_support::{rfs, rustc};
+use run_make_support::{bare_rustc, rfs};
 
 struct PrintCfg {
     target: &'static str,
@@ -86,7 +86,7 @@ fn check(PrintCfg { target, includes, disallow }: PrintCfg) {
 
     // --print=cfg
     {
-        let output = rustc().target(target).print("cfg").run();
+        let output = bare_rustc().target(target).print("cfg").run();
         let stdout = output.stdout_utf8();
 
         check_(&stdout, includes, disallow);
@@ -96,7 +96,7 @@ fn check(PrintCfg { target, includes, disallow }: PrintCfg) {
     {
         let tmp_path = PathBuf::from(format!("{target}.cfg"));
 
-        rustc().target(target).print(&format!("cfg={}", tmp_path.display())).run();
+        bare_rustc().target(target).print(&format!("cfg={}", tmp_path.display())).run();
 
         let output = rfs::read_to_string(&tmp_path);
 
diff --git a/tests/run-make/print-target-cpus-native/rmake.rs b/tests/run-make/print-target-cpus-native/rmake.rs
@@ -2,7 +2,7 @@
 //@ needs-llvm-components: aarch64 x86
 // FIXME(#132514): Is needs-llvm-components actually necessary for this test?
 
-use run_make_support::{assert_contains_regex, rfs, rustc, target};
+use run_make_support::{assert_contains_regex, bare_rustc, rfs, rustc, target};
 
 // Test that when querying `--print=target-cpus` for a target with the same
 // architecture as the host, the first CPU is "native" with a suitable remark.
@@ -17,7 +17,7 @@ fn main() {
 
     // With an explicit target that happens to be the host.
     let host = target(); // Because of ignore-cross-compile, assume host == target.
-    rustc().print("target-cpus").target(host).run().assert_stdout_contains_regex(expected);
+    bare_rustc().print("target-cpus").target(host).run().assert_stdout_contains_regex(expected);
 
     // With an explicit output path.
     rustc().print("target-cpus=./xyzzy.txt").run().assert_stdout_equals("");
@@ -34,6 +34,10 @@ fn main() {
     };
     for target in cross_targets {
         println!("Trying target: {target}");
-        rustc().print("target-cpus").target(target).run().assert_stdout_contains_regex(expected);
+        bare_rustc()
+            .print("target-cpus")
+            .target(target)
+            .run()
+            .assert_stdout_contains_regex(expected);
     }
 }
diff --git a/tests/run-make/print-to-output/rmake.rs b/tests/run-make/print-to-output/rmake.rs
@@ -9,7 +9,7 @@
 
 use std::path::PathBuf;
 
-use run_make_support::{rfs, rustc, target};
+use run_make_support::{bare_rustc, rfs, target};
 
 struct Option<'a> {
     target: &'a str,
@@ -44,13 +44,16 @@ fn check(args: Option) {
     }
 
     // --print={option}
-    let stdout = rustc().target(args.target).print(args.option).run().stdout_utf8();
+    let stdout = bare_rustc().target(args.target).print(args.option).run().stdout_utf8();
 
     // --print={option}=PATH
     let output = {
         let tmp_path = PathBuf::from(format!("{}.txt", args.option));
 
-        rustc().target(args.target).print(&format!("{}={}", args.option, tmp_path.display())).run();
+        bare_rustc()
+            .target(args.target)
+            .print(&format!("{}={}", args.option, tmp_path.display()))
+            .run();
 
         rfs::read_to_string(&tmp_path)
     };
diff --git a/tests/run-make/rust-lld-custom-target/rmake.rs b/tests/run-make/rust-lld-custom-target/rmake.rs
@@ -8,13 +8,13 @@
 //@ needs-rust-lld
 //@ only-x86_64-unknown-linux-gnu
 
+use run_make_support::bare_rustc;
 use run_make_support::regex::Regex;
-use run_make_support::rustc;
 
 fn main() {
     // Compile to a custom target spec with rust-lld enabled by default. We'll check that by asking
     // the linker to display its version number with a link-arg.
-    let output = rustc()
+    let output = bare_rustc()
         .crate_type("cdylib")
         .arg("-Wlinker-messages")
         .target("custom-target.json")
@@ -28,7 +28,7 @@ fn main() {
     );
 
     // But it can also be disabled via linker features.
-    let output = rustc()
+    let output = bare_rustc()
         .crate_type("cdylib")
         .arg("-Wlinker-messages")
         .target("custom-target.json")
diff --git a/tests/run-make/rustc-macro-dep-files/rmake.rs b/tests/run-make/rustc-macro-dep-files/rmake.rs
@@ -8,7 +8,7 @@ use run_make_support::{diff, rustc, target};
 
 fn main() {
     rustc().input("foo.rs").run();
-    rustc().input("bar.rs").target(target()).emit("dep-info").run();
+    rustc().input("bar.rs").emit("dep-info").run();
     // The emitted file should not contain "proc-macro source".
     diff().expected_file("correct.d").actual_file("bar.d").run();
 }
diff --git a/tests/run-make/rustdoc-target-spec-json-path/rmake.rs b/tests/run-make/rustdoc-target-spec-json-path/rmake.rs
@@ -1,10 +1,10 @@
 // Test that rustdoc will properly canonicalize the target spec json path just like rustc.
 
-use run_make_support::{cwd, rustc, rustdoc};
+use run_make_support::{bare_rustc, cwd, rustdoc};
 
 fn main() {
     let out_dir = "rustdoc-target-spec-json-path";
-    rustc().crate_type("lib").input("dummy_core.rs").target("target.json").run();
+    bare_rustc().crate_type("lib").input("dummy_core.rs").target("target.json").run();
     rustdoc()
         .input("my_crate.rs")
         .out_dir(out_dir)
diff --git a/tests/run-make/simd-ffi/rmake.rs b/tests/run-make/simd-ffi/rmake.rs
@@ -5,7 +5,7 @@
 // Note that this test does not check linking or binary execution.
 // See https://github.com/rust-lang/rust/pull/21233
 
-use run_make_support::{llvm_components_contain, rustc};
+use run_make_support::{bare_rustc, llvm_components_contain};
 
 fn main() {
     let mut targets = Vec::new();
@@ -52,7 +52,7 @@ fn main() {
         // enabled by-default for i686 and ARM; these features will be invalid
         // on some platforms, but LLVM just prints a warning so that's fine for
         // now.
-        rustc()
+        bare_rustc()
             .target(&target)
             .emit("llvm-ir,asm")
             .input("simd.rs")
diff --git a/tests/run-make/static-pie/rmake.rs b/tests/run-make/static-pie/rmake.rs
diff --git a/tests/run-make/sysroot-crates-are-unstable/rmake.rs b/tests/run-make/sysroot-crates-are-unstable/rmake.rs
diff --git a/tests/run-make/target-specs/rmake.rs b/tests/run-make/target-specs/rmake.rs
diff --git a/tests/run-make/target-without-atomic-cas/rmake.rs b/tests/run-make/target-without-atomic-cas/rmake.rs

Original file line number	Diff line number	Diff line change
`@@ -3,10 +3,10 @@`
`3`	`3`
`4`	`4`	`//@ only-linux`
`5`	`5`
`6`		`-use run_make_support::{llvm_components_contain, llvm_readobj, rustc};`
	`6`	`+use run_make_support::{bare_rustc, llvm_components_contain, llvm_readobj};`
`7`	`7`
`8`	`8`	`fn compile(target: &str) {`
`9`		`- rustc().input("atomic_lock_free.rs").target(target).run();`
	`9`	`+ bare_rustc().input("atomic_lock_free.rs").target(target).run();`
`10`	`10`	`}`
`11`	`11`
`12`	`12`	`fn check() {`