Move build-manifest target lists to rustc target metadata

Mark-Simulacrum · Mark-Simulacrum · commit 7ee4357dd16d · 2025-11-16T08:29:10.000-05:00
This ensures that as long as the target metadata is updated to reflect
the current state (tier 3 vs 1/2, host toolchain support), the manifest
will also be updated. This avoids an extremely common 'oops' when we
move targets between tiers.

This mostly removes a bunch of tier 3 targets from manifests. I didn't
spot check against produced artifacts but given that they are tier 3
it's probably reasonable to leave it as-is and bug reporters can fix the
target metadata in rustc (or we can stop producing artifacts).

Follow-up work would ideally lint the artifact list as part of
nightly/beta/stable builds as well, but for now this is simple and
hopefully removes at common source of extra PRs when modifying targets.
diff --git a/compiler/rustc_target/src/spec/targets/aarch64_pc_windows_gnullvm.rs b/compiler/rustc_target/src/spec/targets/aarch64_pc_windows_gnullvm.rs
@@ -17,7 +17,7 @@ pub(crate) fn target() -> Target {
         metadata: TargetMetadata {
             description: Some("ARM64 MinGW (Windows 10+), LLVM ABI".into()),
             tier: Some(2),
-            host_tools: Some(false),
+            host_tools: Some(true),
             std: Some(true),
         },
         pointer_width: 64,
diff --git a/compiler/rustc_target/src/spec/targets/i586_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/i586_unknown_linux_gnu.rs
@@ -5,5 +5,11 @@ pub(crate) fn target() -> Target {
     base.rustc_abi = None; // overwrite the SSE2 ABI set by the base target
     base.cpu = "pentium".into();
     base.llvm_target = "i586-unknown-linux-gnu".into();
+    base.metadata = crate::spec::TargetMetadata {
+        description: Some("32-bit Linux (kernel 3.2, glibc 2.17+)".into()),
+        tier: Some(2),
+        host_tools: Some(false),
+        std: Some(true),
+    };
     base
 }
diff --git a/compiler/rustc_target/src/spec/targets/sparcv9_sun_solaris.rs b/compiler/rustc_target/src/spec/targets/sparcv9_sun_solaris.rs
@@ -18,7 +18,7 @@ pub(crate) fn target() -> Target {
         metadata: TargetMetadata {
             description: Some("SPARC Solaris 11.4".into()),
             tier: Some(2),
-            host_tools: Some(false),
+            host_tools: Some(true),
             std: Some(true),
         },
         pointer_width: 64,
diff --git a/compiler/rustc_target/src/spec/targets/wasm32_wasip2.rs b/compiler/rustc_target/src/spec/targets/wasm32_wasip2.rs
@@ -63,7 +63,7 @@ pub(crate) fn target() -> Target {
         llvm_target: "wasm32-wasip2".into(),
         metadata: TargetMetadata {
             description: Some("WebAssembly".into()),
-            tier: Some(3),
+            tier: Some(2),
             host_tools: Some(false),
             std: Some(true),
         },
diff --git a/compiler/rustc_target/src/spec/targets/wasm32_wasip3.rs b/compiler/rustc_target/src/spec/targets/wasm32_wasip3.rs
@@ -15,6 +15,12 @@ pub(crate) fn target() -> Target {
     // and this may grow over time as more features are supported.
     let mut target = super::wasm32_wasip2::target();
     target.llvm_target = "wasm32-wasip3".into();
+    target.metadata = crate::spec::TargetMetadata {
+        description: Some("WebAssembly".into()),
+        tier: Some(3),
+        host_tools: Some(false),
+        std: Some(true),
+    };
     target.options.env = Env::P3;
     target
 }
diff --git a/compiler/rustc_target/src/spec/targets/x86_64_pc_solaris.rs b/compiler/rustc_target/src/spec/targets/x86_64_pc_solaris.rs
@@ -20,7 +20,7 @@ pub(crate) fn target() -> Target {
         metadata: TargetMetadata {
             description: Some("64-bit Solaris 11.4".into()),
             tier: Some(2),
-            host_tools: Some(false),
+            host_tools: Some(true),
             std: Some(true),
         },
         pointer_width: 64,
diff --git a/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnullvm.rs b/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnullvm.rs
@@ -14,7 +14,7 @@ pub(crate) fn target() -> Target {
         metadata: TargetMetadata {
             description: Some("64-bit x86 MinGW (Windows 10+), LLVM ABI".into()),
             tier: Some(2),
-            host_tools: Some(false),
+            host_tools: Some(true),
             std: Some(true),
         },
         pointer_width: 64,
diff --git a/src/bootstrap/src/core/build_steps/dist.rs b/src/bootstrap/src/core/build_steps/dist.rs
@@ -22,7 +22,7 @@ use tracing::instrument;
 use crate::core::build_steps::compile::{get_codegen_backend_file, normalize_codegen_backend_name};
 use crate::core::build_steps::doc::DocumentationFormat;
 use crate::core::build_steps::tool::{
-    self, RustcPrivateCompilers, Tool, ToolTargetBuildMode, get_tool_target_compiler,
+    self, RustcPrivateCompilers, ToolTargetBuildMode, get_tool_target_compiler,
 };
 use crate::core::build_steps::vendor::{VENDOR_DIR, Vendor};
 use crate::core::build_steps::{compile, llvm};
@@ -2695,10 +2695,13 @@ impl Step for BuildManifest {
     }
 
     fn run(self, builder: &Builder<'_>) -> GeneratedTarball {
-        let build_manifest = builder.tool_exe(Tool::BuildManifest);
+        let build_manifest = builder.ensure(tool::BuildManifest {
+            compiler: builder.compiler(1, builder.config.host_target),
+            target: builder.config.host_target,
+        });
 
         let tarball = Tarball::new(builder, "build-manifest", &self.target.triple);
-        tarball.add_file(&build_manifest, "bin", FileType::Executable);
+        tarball.add_file(&build_manifest.tool_path, "bin", FileType::Executable);
         tarball.generate()
     }
 
diff --git a/src/bootstrap/src/core/build_steps/run.rs b/src/bootstrap/src/core/build_steps/run.rs
@@ -37,7 +37,14 @@ impl Step for BuildManifest {
     fn run(self, builder: &Builder<'_>) {
         // This gets called by `promote-release`
         // (https://github.com/rust-lang/promote-release).
-        let mut cmd = builder.tool_cmd(Tool::BuildManifest);
+        let mut cmd = command(
+            builder
+                .ensure(tool::BuildManifest {
+                    compiler: builder.compiler(1, builder.config.host_target),
+                    target: builder.config.host_target,
+                })
+                .tool_path,
+        );
         let sign = builder.config.dist_sign_folder.as_ref().unwrap_or_else(|| {
             panic!("\n\nfailed to specify `dist.sign-folder` in `bootstrap.toml`\n\n")
         });
diff --git a/src/bootstrap/src/core/build_steps/tool.rs b/src/bootstrap/src/core/build_steps/tool.rs
@@ -485,7 +485,6 @@ bootstrap_tool!(
     Linkchecker, "src/tools/linkchecker", "linkchecker";
     CargoTest, "src/tools/cargotest", "cargotest";
     Compiletest, "src/tools/compiletest", "compiletest";
-    BuildManifest, "src/tools/build-manifest", "build-manifest";
     RemoteTestClient, "src/tools/remote-test-client", "remote-test-client";
     RustInstaller, "src/tools/rust-installer", "rust-installer";
     RustdocTheme, "src/tools/rustdoc-themes", "rustdoc-themes";
@@ -1268,6 +1267,49 @@ impl Step for LibcxxVersionTool {
     }
 }
 
+#[derive(Debug, Clone, Hash, PartialEq, Eq)]
+pub struct BuildManifest {
+    pub compiler: Compiler,
+    pub target: TargetSelection,
+}
+
+impl Step for BuildManifest {
+    type Output = ToolBuildResult;
+
+    fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
+        run.path("src/tools/build-manifest")
+    }
+
+    fn make_run(run: RunConfig<'_>) {
+        run.builder.ensure(BuildManifest {
+            compiler: run.builder.compiler(1, run.builder.config.host_target),
+            target: run.target,
+        });
+    }
+
+    fn run(self, builder: &Builder<'_>) -> ToolBuildResult {
+        // Building with the beta compiler will produce a broken build-manifest that doesn't support
+        // recently stabilized targets/hosts.
+        assert!(self.compiler.stage != 0);
+        builder.ensure(ToolBuild {
+            build_compiler: self.compiler,
+            target: self.target,
+            tool: "build-manifest",
+            mode: Mode::ToolStd,
+            path: "src/tools/build-manifest",
+            source_type: SourceType::InTree,
+            extra_features: vec![],
+            allow_features: "",
+            cargo_args: vec![],
+            artifact_kind: ToolArtifactKind::Binary,
+        })
+    }
+
+    fn metadata(&self) -> Option<StepMetadata> {
+        Some(StepMetadata::build("build-manifest", self.target).built_by(self.compiler))
+    }
+}
+
 /// Represents which compilers are involved in the compilation of a tool
 /// that depends on compiler internals (`rustc_private`).
 /// Their compilation looks like this:
diff --git a/src/tools/build-manifest/Cargo.toml b/src/tools/build-manifest/Cargo.toml
@@ -14,3 +14,7 @@ tar = "0.4.29"
 sha2 = "0.10.1"
 rayon = "1.5.1"
 hex = "0.4.2"
+
+[build-dependencies]
+serde = "1"
+serde_json = "1"
diff --git a/src/tools/build-manifest/build.rs b/src/tools/build-manifest/build.rs
@@ -0,0 +1,69 @@
+use std::fmt::Write;
+use std::path::PathBuf;
+use std::process::{Command, Stdio};
+
+#[derive(Default, Debug)]
+pub(crate) struct RustcTargets {
+    /// Targets with host tool artifacts.
+    pub(crate) hosts: Vec<String>,
+
+    /// Targets without host tool artifacts.
+    pub(crate) targets: Vec<String>,
+}
+
+fn collect_rustc_targets() -> RustcTargets {
+    let rustc_path = std::env::var("RUSTC").expect("RUSTC set");
+    let output = Command::new(&rustc_path)
+        .arg("--print=all-target-specs-json")
+        .arg("-Zunstable-options")
+        .stderr(Stdio::inherit())
+        .output()
+        .unwrap();
+    assert!(output.status.success());
+    let json: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
+
+    let mut rustc_targets = RustcTargets::default();
+    for (target, json) in json.as_object().unwrap().iter() {
+        let Some(tier) = json["metadata"]["tier"].as_u64() else {
+            eprintln!("skipping {target}: no tier in metadata");
+            continue;
+        };
+        let host_tools: Option<bool> =
+            serde_json::from_value(json["metadata"]["host_tools"].clone()).unwrap();
+
+        if !(tier == 1 || tier == 2) {
+            eprintln!("ignoring {target}: tier {tier} insufficient for target to be in manifest");
+            continue;
+        }
+
+        if host_tools == Some(true) {
+            rustc_targets.hosts.push(target.to_owned());
+            rustc_targets.targets.push(target.to_owned());
+        } else {
+            rustc_targets.targets.push(target.to_owned());
+        }
+    }
+
+    rustc_targets
+}
+
+fn main() {
+    let targets = collect_rustc_targets();
+
+    let mut output = String::new();
+
+    writeln!(output, "static HOSTS: &[&str] = &[").unwrap();
+    for host in targets.hosts {
+        writeln!(output, "    {:?},", host).unwrap();
+    }
+    writeln!(output, "];").unwrap();
+
+    writeln!(output, "static TARGETS: &[&str] = &[").unwrap();
+    for target in targets.targets {
+        writeln!(output, "    {:?},", target).unwrap();
+    }
+    writeln!(output, "];").unwrap();
+
+    std::fs::write(PathBuf::from(std::env::var_os("OUT_DIR").unwrap()).join("targets.rs"), output)
+        .unwrap();
+}
diff --git a/src/tools/build-manifest/src/main.rs b/src/tools/build-manifest/src/main.rs
