Link rustc/std tools into the correct sysroot

When copying tool binaries, we were linking them into the sysroot of the
compiler that built the binaries. This makes no sense, the binaries are
for the next sysroot. So when the stage0 compiler builds clippy, this
clippy belongs into stage1, and when the stage1 compiler builds clippy,
this clippy belongs into stage2.
This puts it right next to the librustc_driver it actually links
against.
Additionally, we `ensure(Assemble)` of this librustc_driver such that
the tool will be working as expected.
To run the tool manually, we still need to set LD_LIBRARY_PATH, but now
with this, setting the rpath to `$ORIGIN/../lib` (like the `rustc` and
`rustdoc` binaries) should be possible as future work now.

Rustdoc, with its special treatment, was already getting the correct
behavior.

Author: Noratrieb

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

@@ -78,8 +78,13 @@ impl Step for ToolBuild {
 
         match self.mode {
             Mode::ToolRustc => {
-                builder.ensure(compile::Std::new(compiler, compiler.host));
-                builder.ensure(compile::Rustc::new(compiler, target));
+                let linked_against_compiler = compiler.with_stage(compiler.stage + 1);
+                // When building a tool that links against rustc,
+                // we need the rustc to link against and its std to be present and ready in the syroot.
+                builder.ensure(compile::Std::new(
+                    linked_against_compiler,
+                    linked_against_compiler.host,
+                ));
             }
             Mode::ToolStd => builder.ensure(compile::Std::new(compiler, target)),
             Mode::ToolBootstrap => {} // uses downloaded stage0 compiler libs
@@ -770,8 +775,8 @@ macro_rules! tool_extended {
        $($name:ident,
        $path:expr,
        $tool_name:expr,
+       mode = $mode:expr,
        stable = $stable:expr
-       $(,tool_std = $tool_std:literal)?
        $(,allow_features = $allow_features:expr)?
        $(,add_bins_to_sysroot = $add_bins_to_sysroot:expr)?
        ;)+) => {
@@ -820,15 +825,16 @@ macro_rules! tool_extended {
                     compiler: $sel.compiler,
                     target: $sel.target,
                     tool: $tool_name,
-                    mode: if false $(|| $tool_std)? { Mode::ToolStd } else { Mode::ToolRustc },
+                    mode: $mode,
                     path: $path,
                     extra_features: $sel.extra_features,
                     source_type: SourceType::InTree,
                     allow_features: concat!($($allow_features)*),
                 });
 
-                if (false $(|| !$add_bins_to_sysroot.is_empty())?) && $sel.compiler.stage > 0 {
-                    let bindir = $builder.sysroot($sel.compiler).join("bin");
+                if (false $(|| !$add_bins_to_sysroot.is_empty())?) {
+                    // As usual, we copy the tool into the next sysroot, as it links against the compiler in that sysroot.
+                    let bindir = $builder.sysroot($sel.compiler.with_stage($sel.compiler.stage + 1)).join("bin");
                     t!(fs::create_dir_all(&bindir));
 
                     #[allow(unused_variables)]
@@ -857,17 +863,17 @@ macro_rules! tool_extended {
 // NOTE: Most submodule updates for tools are handled by bootstrap.py, since they're needed just to
 // invoke Cargo to build bootstrap. See the comment there for more details.
 tool_extended!((self, builder),
-    Cargofmt, "src/tools/rustfmt", "cargo-fmt", stable=true;
-    CargoClippy, "src/tools/clippy", "cargo-clippy", stable=true;
-    Clippy, "src/tools/clippy", "clippy-driver", stable=true, add_bins_to_sysroot = ["clippy-driver", "cargo-clippy"];
-    Miri, "src/tools/miri", "miri", stable=false, add_bins_to_sysroot = ["miri"];
-    CargoMiri, "src/tools/miri/cargo-miri", "cargo-miri", stable=true, add_bins_to_sysroot = ["cargo-miri"];
+    Cargofmt, "src/tools/rustfmt", "cargo-fmt", mode=Mode::ToolRustc, stable=true;
+    CargoClippy, "src/tools/clippy", "cargo-clippy", mode= Mode::ToolRustc, stable=true;
+    Clippy, "src/tools/clippy", "clippy-driver", mode=Mode::ToolRustc, stable=true, add_bins_to_sysroot = ["clippy-driver", "cargo-clippy"];
+    Miri, "src/tools/miri", "miri", mode= Mode::ToolRustc, stable=false, add_bins_to_sysroot = ["miri"];
+    CargoMiri, "src/tools/miri/cargo-miri", "cargo-miri", mode=Mode::ToolRustc, stable=true, add_bins_to_sysroot = ["cargo-miri"];
     // FIXME: tool_std is not quite right, we shouldn't allow nightly features.
     // But `builder.cargo` doesn't know how to handle ToolBootstrap in stages other than 0,
     // and this is close enough for now.
-    Rls, "src/tools/rls", "rls", stable=true, tool_std=true;
-    RustDemangler, "src/tools/rust-demangler", "rust-demangler", stable=false, tool_std=true;
-    Rustfmt, "src/tools/rustfmt", "rustfmt", stable=true, add_bins_to_sysroot = ["rustfmt", "cargo-fmt"];
+    Rls, "src/tools/rls", "rls", mode=Mode::ToolStd, stable=true;
+    RustDemangler, "src/tools/rust-demangler", "rust-demangler", mode=Mode::ToolStd, stable=false;
+    Rustfmt, "src/tools/rustfmt", "rustfmt", mode=Mode::ToolRustc, stable=true, add_bins_to_sysroot = ["rustfmt", "cargo-fmt"];
 );
 
 impl<'a> Builder<'a> {