Implement x perf as a separate tool

Cargo.lock

@@ -3453,6 +3453,13 @@ dependencies = [
  "stable_mir",
 ]
 
+[[package]]
+name = "rustc-perf-wrapper"
+version = "0.1.0"
+dependencies = [
+ "clap",
+]
+
 [[package]]
 name = "rustc-rayon"
 version = "0.5.0"

Cargo.toml

@@ -44,6 +44,7 @@ members = [
   "src/tools/rustdoc-gui-test",
   "src/tools/opt-dist",
   "src/tools/coverage-dump",
+  "src/tools/rustc-perf-wrapper",
 ]
 
 exclude = [

src/bootstrap/src/core/build_steps/mod.rs

@@ -7,7 +7,6 @@ pub(crate) mod doc;
 pub(crate) mod format;
 pub(crate) mod install;
 pub(crate) mod llvm;
-pub(crate) mod perf;
 pub(crate) mod run;
 pub(crate) mod setup;
 pub(crate) mod suggest;

src/bootstrap/src/core/build_steps/run.rs

@@ -3,17 +3,17 @@
 //! A bit of a hodge-podge as e.g. if a tool's a test fixture it should be in `build_steps::test`.
 //! If it can be reached from `./x.py run` it can go here.
 
-use std::path::PathBuf;
-use std::process::Command;
-
+use crate::core::build_steps::compile::{Std, Sysroot};
 use crate::core::build_steps::dist::distdir;
 use crate::core::build_steps::test;
-use crate::core::build_steps::tool::{self, SourceType, Tool};
+use crate::core::build_steps::tool::{self, RustcPerf, SourceType, Tool};
 use crate::core::builder::{Builder, RunConfig, ShouldRun, Step};
 use crate::core::config::flags::get_completion;
-use crate::core::config::TargetSelection;
+use crate::core::config::{DebuginfoLevel, TargetSelection};
 use crate::utils::helpers::output;
 use crate::Mode;
+use std::path::PathBuf;
+use std::process::Command;
 
 #[derive(Debug, PartialOrd, Ord, Clone, Hash, PartialEq, Eq)]
 pub struct BuildManifest;
@@ -283,3 +283,49 @@ impl Step for GenerateCompletions {
         run.builder.ensure(GenerateCompletions);
     }
 }
+
+/// Helper wrapper tool for `rustc-perf`, located at `src/tools/rustc-perf-wrapper`.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct RustfPerfWrapper;
+
+impl Step for RustfPerfWrapper {
+    type Output = ();
+
+    fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
+        run.path("src/tools/rustc-perf-wrapper").alias("perf")
+    }
+
+    fn make_run(run: RunConfig<'_>) {
+        run.builder.ensure(RustfPerfWrapper);
+    }
+
+    fn run(self, builder: &Builder<'_>) {
+        let collector = builder.ensure(RustcPerf {
+            compiler: builder.compiler(0, builder.config.build),
+            target: builder.config.build,
+        });
+
+        if builder.build.config.rust_debuginfo_level_rustc == DebuginfoLevel::None {
+            builder.info(r#"WARNING: You are compiling rustc without debuginfo, this will make profiling less useful.
+Consider setting `rust.debuginfo-level = 1` in `config.toml`."#);
+        }
+
+        let compiler = builder.compiler(builder.top_stage, builder.config.build);
+        builder.ensure(Std::new(compiler, builder.config.build));
+        let sysroot = builder.ensure(Sysroot::new(compiler));
+        let rustc = sysroot.join("bin/rustc");
+
+        let rustc_perf_dir = builder.build.tempdir().join("rustc-perf");
+        let profile_results_dir = rustc_perf_dir.join("results");
+
+        // We need to take args passed after `--` and pass them to `rustc-perf-wrapper`
+        let args = std::env::args().skip_while(|a| a != "--").skip(1);
+
+        let mut cmd = builder.tool_cmd(Tool::RustcPerfWrapper);
+        cmd.env("PERF_RUSTC", rustc)
+            .env("PERF_COLLECTOR", collector)
+            .env("PERF_RESULT_DIR", profile_results_dir)
+            .args(args);
+        builder.run(&mut cmd);
+    }
+}

src/bootstrap/src/core/build_steps/tool.rs

@@ -336,6 +336,7 @@ bootstrap_tool!(
     GenerateWindowsSys, "src/tools/generate-windows-sys", "generate-windows-sys";
     RustdocGUITest, "src/tools/rustdoc-gui-test", "rustdoc-gui-test", is_unstable_tool = true, allow_features = "test";
     CoverageDump, "src/tools/coverage-dump", "coverage-dump";
+    RustcPerfWrapper, "src/tools/rustc-perf-wrapper", "rustc-perf-wrapper";
 );
 
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]

src/bootstrap/src/core/builder.rs

@@ -959,6 +959,7 @@ impl<'a> Builder<'a> {
                 run::GenerateCopyright,
                 run::GenerateWindowsSys,
                 run::GenerateCompletions,
+                run::RustfPerfWrapper
             ),
             Kind::Setup => describe!(setup::Profile, setup::Hook, setup::Link, setup::Vscode),
             Kind::Clean => describe!(clean::CleanAll, clean::Rustc, clean::Std),
@@ -1036,7 +1037,6 @@ impl<'a> Builder<'a> {
                 path.as_ref().map_or([].as_slice(), |path| std::slice::from_ref(path)),
             ),
             Subcommand::Vendor { .. } => (Kind::Vendor, &paths[..]),
-            Subcommand::Perf { .. } => (Kind::Perf, &paths[..]),
         };
 
         Self::new_internal(build, kind, paths.to_owned())

src/bootstrap/src/core/config/config.rs

@@ -2043,17 +2043,26 @@ impl Config {
             Subcommand::Bench { .. } => flags.stage.or(bench_stage).unwrap_or(2),
             Subcommand::Dist { .. } => flags.stage.or(dist_stage).unwrap_or(2),
             Subcommand::Install { .. } => flags.stage.or(install_stage).unwrap_or(2),
-            Subcommand::Perf { .. } => flags.stage.unwrap_or(1),
             // These are all bootstrap tools, which don't depend on the compiler.
             // The stage we pass shouldn't matter, but use 0 just in case.
             Subcommand::Clean { .. }
             | Subcommand::Clippy { .. }
             | Subcommand::Fix { .. }
-            | Subcommand::Run { .. }
             | Subcommand::Setup { .. }
             | Subcommand::Format { .. }
             | Subcommand::Suggest { .. }
             | Subcommand::Vendor { .. } => flags.stage.unwrap_or(0),
+            Subcommand::Run { .. } => {
+                // We want to default to stage 1 for this specific tool/command.
+                let default = if config.paths.iter().any(|s| {
+                    s.to_str() == Some("perf") || s.to_str() == Some("src/tools/rustc-perf-wrapper")
+                }) {
+                    1
+                } else {
+                    0
+                };
+                flags.stage.unwrap_or(default)
+            }
         };
 
         // CI should always run stage 2 builds, unless it specifically states otherwise
@@ -2081,8 +2090,7 @@ impl Config {
                 | Subcommand::Setup { .. }
                 | Subcommand::Format { .. }
                 | Subcommand::Suggest { .. }
-                | Subcommand::Vendor { .. }
-                | Subcommand::Perf { .. } => {}
+                | Subcommand::Vendor { .. } => {}
             }
         }
 

src/bootstrap/src/core/config/flags.rs

@@ -469,9 +469,6 @@ Arguments:
         #[arg(long)]
         versioned_dirs: bool,
     },
-    /// Perform profiling and benchmarking of the compiler using the
-    /// `rustc-perf` benchmark suite.
-    Perf {},
 }
 
 impl Subcommand {
@@ -493,7 +490,6 @@ impl Subcommand {
             Subcommand::Setup { .. } => Kind::Setup,
             Subcommand::Suggest { .. } => Kind::Suggest,
             Subcommand::Vendor { .. } => Kind::Vendor,
-            Subcommand::Perf { .. } => Kind::Perf,
         }
     }
 

src/bootstrap/src/lib.rs

@@ -659,9 +659,6 @@ impl Build {
             Subcommand::Suggest { run } => {
                 return core::build_steps::suggest::suggest(&builder::Builder::new(self), *run);
             }
-            Subcommand::Perf { .. } => {
-                return core::build_steps::perf::perf(&builder::Builder::new(self));
-            }
             _ => (),
         }