src/bootstrap/compile.rs

   1 //! Implementation of compiling various phases of the compiler and standard
   2 //! library.
   3 //!
   4 //! This module contains some of the real meat in the rustbuild build system
   5 //! which is where Cargo is used to compile the standard library, libtest, and
   6 //! the compiler. This module is also responsible for assembling the sysroot as it
   7 //! goes along from the output of the previous stage.
   8
   9 use std::borrow::Cow;
  10 use std::collections::HashSet;
  11 use std::env;
  12 use std::fs;
  13 use std::io::prelude::*;
  14 use std::io::BufReader;
  15 use std::path::{Path, PathBuf};
  16 use std::process::{Command, Stdio};
  17 use std::str;
  18
  19 use serde::Deserialize;
  20
  21 use crate::builder::crate_description;
  22 use crate::builder::Cargo;
  23 use crate::builder::{Builder, Kind, RunConfig, ShouldRun, Step};
  24 use crate::cache::{Interned, INTERNER};
  25 use crate::config::{LlvmLibunwind, RustcLto, TargetSelection};
  26 use crate::dist;
  27 use crate::native;
  28 use crate::tool::SourceType;
  29 use crate::util::get_clang_cl_resource_dir;
  30 use crate::util::{exe, is_debug_info, is_dylib, output, symlink_dir, t, up_to_date};
  31 use crate::LLVM_TOOLS;
  32 use crate::{CLang, Compiler, DependencyType, GitRepo, Mode};
  33
  34 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
  35 pub struct Std {
  36     pub target: TargetSelection,
  37     pub compiler: Compiler,
  38     /// Whether to build only a subset of crates in the standard library.
  39     ///
  40     /// This shouldn't be used from other steps; see the comment on [`Rustc`].
  41     crates: Interned<Vec<String>>,
  42 }
  43
  44 impl Std {
  45     pub fn new(compiler: Compiler, target: TargetSelection) -> Self {
  46         Self { target, compiler, crates: Default::default() }
  47     }
  48 }
  49
  50 impl Step for Std {
  51     type Output = ();
  52     const DEFAULT: bool = true;
  53
  54     fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
  55         // When downloading stage1, the standard library has already been copied to the sysroot, so
  56         // there's no need to rebuild it.
  57         let builder = run.builder;
  58         run.crate_or_deps("test")
  59             .path("library")
  60             .lazy_default_condition(Box::new(|| !builder.download_rustc()))
  61     }
  62
  63     fn make_run(run: RunConfig<'_>) {
  64         // Normally, people will pass *just* library if they pass it.
  65         // But it's possible (although strange) to pass something like `library std core`.
  66         // Build all crates anyway, as if they hadn't passed the other args.
  67         let has_library =
  68             run.paths.iter().any(|set| set.assert_single_path().path.ends_with("library"));
  69         let crates = if has_library { Default::default() } else { run.cargo_crates_in_set() };
  70         run.builder.ensure(Std {
  71             compiler: run.builder.compiler(run.builder.top_stage, run.build_triple()),
  72             target: run.target,
  73             crates,
  74         });
  75     }
  76
  77     /// Builds the standard library.
  78     ///
  79     /// This will build the standard library for a particular stage of the build
  80     /// using the `compiler` targeting the `target` architecture. The artifacts
  81     /// created will also be linked into the sysroot directory.
  82     fn run(self, builder: &Builder<'_>) {
  83         let target = self.target;
  84         let compiler = self.compiler;
  85
  86         // These artifacts were already copied (in `impl Step for Sysroot`).
  87         // Don't recompile them.
  88         // NOTE: the ABI of the beta compiler is different from the ABI of the downloaded compiler,
  89         // so its artifacts can't be reused.
  90         if builder.download_rustc() && compiler.stage != 0 {
  91             return;
  92         }
  93
  94         if builder.config.keep_stage.contains(&compiler.stage)
  95             || builder.config.keep_stage_std.contains(&compiler.stage)
  96         {
  97             builder.info("Warning: Using a potentially old libstd. This may not behave well.");
  98             builder.ensure(StdLink::from_std(self, compiler));
  99             return;
 100         }
 101
 102         builder.update_submodule(&Path::new("library").join("stdarch"));
 103
 104         // Profiler information requires LLVM's compiler-rt
 105         if builder.config.profiler {
 106             builder.update_submodule(&Path::new("src/llvm-project"));
 107         }
 108
 109         let mut target_deps = builder.ensure(StartupObjects { compiler, target });
 110
 111         let compiler_to_use = builder.compiler_for(compiler.stage, compiler.host, target);
 112         if compiler_to_use != compiler {
 113             builder.ensure(Std::new(compiler_to_use, target));
 114             builder.info(&format!(
 115                 "Uplifting stage1 library ({} -> {})",
 116                 compiler_to_use.host, target
 117             ));
 118
 119             // Even if we're not building std this stage, the new sysroot must
 120             // still contain the third party objects needed by various targets.
 121             copy_third_party_objects(builder, &compiler, target);
 122             copy_self_contained_objects(builder, &compiler, target);
 123
 124             builder.ensure(StdLink::from_std(self, compiler_to_use));
 125             return;
 126         }
 127
 128         target_deps.extend(copy_third_party_objects(builder, &compiler, target));
 129         target_deps.extend(copy_self_contained_objects(builder, &compiler, target));
 130
 131         let mut cargo = builder.cargo(compiler, Mode::Std, SourceType::InTree, target, "build");
 132         std_cargo(builder, target, compiler.stage, &mut cargo);
 133         for krate in &*self.crates {
 134             cargo.arg("-p").arg(krate);
 135         }
 136
 137         builder.info(&format!(
 138             "Building{} stage{} library artifacts ({} -> {})",
 139             crate_description(&self.crates),
 140             compiler.stage,
 141             &compiler.host,
 142             target,
 143         ));
 144         run_cargo(
 145             builder,
 146             cargo,
 147             vec![],
 148             &libstd_stamp(builder, compiler, target),
 149             target_deps,
 150             false,
 151             false,
 152         );
 153
 154         builder.ensure(StdLink::from_std(
 155             self,
 156             builder.compiler(compiler.stage, builder.config.build),
 157         ));
 158     }
 159 }
 160
 161 fn copy_and_stamp(
 162     builder: &Builder<'_>,
 163     libdir: &Path,
 164     sourcedir: &Path,
 165     name: &str,
 166     target_deps: &mut Vec<(PathBuf, DependencyType)>,
 167     dependency_type: DependencyType,
 168 ) {
 169     let target = libdir.join(name);
 170     builder.copy(&sourcedir.join(name), &target);
 171
 172     target_deps.push((target, dependency_type));
 173 }
 174
 175 fn copy_llvm_libunwind(builder: &Builder<'_>, target: TargetSelection, libdir: &Path) -> PathBuf {
 176     let libunwind_path = builder.ensure(native::Libunwind { target });
 177     let libunwind_source = libunwind_path.join("libunwind.a");
 178     let libunwind_target = libdir.join("libunwind.a");
 179     builder.copy(&libunwind_source, &libunwind_target);
 180     libunwind_target
 181 }
 182
 183 /// Copies third party objects needed by various targets.
 184 fn copy_third_party_objects(
 185     builder: &Builder<'_>,
 186     compiler: &Compiler,
 187     target: TargetSelection,
 188 ) -> Vec<(PathBuf, DependencyType)> {
 189     let mut target_deps = vec![];
 190
 191     // FIXME: remove this in 2021
 192     if target == "x86_64-fortanix-unknown-sgx" {
 193         if env::var_os("X86_FORTANIX_SGX_LIBS").is_some() {
 194             builder.info("Warning: X86_FORTANIX_SGX_LIBS environment variable is ignored, libunwind is now compiled as part of rustbuild");
 195         }
 196     }
 197
 198     if builder.config.sanitizers_enabled(target) && compiler.stage != 0 {
 199         // The sanitizers are only copied in stage1 or above,
 200         // to avoid creating dependency on LLVM.
 201         target_deps.extend(
 202             copy_sanitizers(builder, &compiler, target)
 203                 .into_iter()
 204                 .map(|d| (d, DependencyType::Target)),
 205         );
 206     }
 207
 208     if target == "x86_64-fortanix-unknown-sgx"
 209         || builder.config.llvm_libunwind(target) == LlvmLibunwind::InTree
 210             && (target.contains("linux") || target.contains("fuchsia"))
 211     {
 212         let libunwind_path =
 213             copy_llvm_libunwind(builder, target, &builder.sysroot_libdir(*compiler, target));
 214         target_deps.push((libunwind_path, DependencyType::Target));
 215     }
 216
 217     target_deps
 218 }
 219
 220 /// Copies third party objects needed by various targets for self-contained linkage.
 221 fn copy_self_contained_objects(
 222     builder: &Builder<'_>,
 223     compiler: &Compiler,
 224     target: TargetSelection,
 225 ) -> Vec<(PathBuf, DependencyType)> {
 226     let libdir_self_contained = builder.sysroot_libdir(*compiler, target).join("self-contained");
 227     t!(fs::create_dir_all(&libdir_self_contained));
 228     let mut target_deps = vec![];
 229
 230     // Copies the libc and CRT objects.
 231     //
 232     // rustc historically provides a more self-contained installation for musl targets
 233     // not requiring the presence of a native musl toolchain. For example, it can fall back
 234     // to using gcc from a glibc-targeting toolchain for linking.
 235     // To do that we have to distribute musl startup objects as a part of Rust toolchain
 236     // and link with them manually in the self-contained mode.
 237     if target.contains("musl") {
 238         let srcdir = builder.musl_libdir(target).unwrap_or_else(|| {
 239             panic!("Target {:?} does not have a \"musl-libdir\" key", target.triple)
 240         });
 241         for &obj in &["libc.a", "crt1.o", "Scrt1.o", "rcrt1.o", "crti.o", "crtn.o"] {
 242             copy_and_stamp(
 243                 builder,
 244                 &libdir_self_contained,
 245                 &srcdir,
 246                 obj,
 247                 &mut target_deps,
 248                 DependencyType::TargetSelfContained,
 249             );
 250         }
 251         let crt_path = builder.ensure(native::CrtBeginEnd { target });
 252         for &obj in &["crtbegin.o", "crtbeginS.o", "crtend.o", "crtendS.o"] {
 253             let src = crt_path.join(obj);
 254             let target = libdir_self_contained.join(obj);
 255             builder.copy(&src, &target);
 256             target_deps.push((target, DependencyType::TargetSelfContained));
 257         }
 258
 259         if !target.starts_with("s390x") {
 260             let libunwind_path = copy_llvm_libunwind(builder, target, &libdir_self_contained);
 261             target_deps.push((libunwind_path, DependencyType::TargetSelfContained));
 262         }
 263     } else if target.ends_with("-wasi") {
 264         let srcdir = builder
 265             .wasi_root(target)
 266             .unwrap_or_else(|| {
 267                 panic!("Target {:?} does not have a \"wasi-root\" key", target.triple)
 268             })
 269             .join("lib/wasm32-wasi");
 270         for &obj in &["libc.a", "crt1-command.o", "crt1-reactor.o"] {
 271             copy_and_stamp(
 272                 builder,
 273                 &libdir_self_contained,
 274                 &srcdir,
 275                 obj,
 276                 &mut target_deps,
 277                 DependencyType::TargetSelfContained,
 278             );
 279         }
 280     } else if target.ends_with("windows-gnu") {
 281         for obj in ["crt2.o", "dllcrt2.o"].iter() {
 282             let src = compiler_file(builder, builder.cc(target), target, CLang::C, obj);
 283             let target = libdir_self_contained.join(obj);
 284             builder.copy(&src, &target);
 285             target_deps.push((target, DependencyType::TargetSelfContained));
 286         }
 287     }
 288
 289     target_deps
 290 }
 291
 292 /// Configure cargo to compile the standard library, adding appropriate env vars
 293 /// and such.
 294 pub fn std_cargo(builder: &Builder<'_>, target: TargetSelection, stage: u32, cargo: &mut Cargo) {
 295     if let Some(target) = env::var_os("MACOSX_STD_DEPLOYMENT_TARGET") {
 296         cargo.env("MACOSX_DEPLOYMENT_TARGET", target);
 297     }
 298
 299     // Determine if we're going to compile in optimized C intrinsics to
 300     // the `compiler-builtins` crate. These intrinsics live in LLVM's
 301     // `compiler-rt` repository, but our `src/llvm-project` submodule isn't
 302     // always checked out, so we need to conditionally look for this. (e.g. if
 303     // an external LLVM is used we skip the LLVM submodule checkout).
 304     //
 305     // Note that this shouldn't affect the correctness of `compiler-builtins`,
 306     // but only its speed. Some intrinsics in C haven't been translated to Rust
 307     // yet but that's pretty rare. Other intrinsics have optimized
 308     // implementations in C which have only had slower versions ported to Rust,
 309     // so we favor the C version where we can, but it's not critical.
 310     //
 311     // If `compiler-rt` is available ensure that the `c` feature of the
 312     // `compiler-builtins` crate is enabled and it's configured to learn where
 313     // `compiler-rt` is located.
 314     let compiler_builtins_root = builder.src.join("src/llvm-project/compiler-rt");
 315     let compiler_builtins_c_feature = if compiler_builtins_root.exists() {
 316         // Note that `libprofiler_builtins/build.rs` also computes this so if
 317         // you're changing something here please also change that.
 318         cargo.env("RUST_COMPILER_RT_ROOT", &compiler_builtins_root);
 319         " compiler-builtins-c"
 320     } else {
 321         ""
 322     };
 323
 324     let mut features = String::new();
 325
 326     // Cranelift doesn't support `asm`.
 327     if stage != 0 && builder.config.default_codegen_backend().unwrap_or_default() == "cranelift" {
 328         features += " compiler-builtins-no-asm";
 329     }
 330
 331     if builder.no_std(target) == Some(true) {
 332         features += " compiler-builtins-mem";
 333         if !target.starts_with("bpf") {
 334             features.push_str(compiler_builtins_c_feature);
 335         }
 336
 337         // for no-std targets we only compile a few no_std crates
 338         cargo
 339             .args(&["-p", "alloc"])
 340             .arg("--manifest-path")
 341             .arg(builder.src.join("library/alloc/Cargo.toml"))
 342             .arg("--features")
 343             .arg(features);
 344     } else {
 345         features += &builder.std_features(target);
 346         features.push_str(compiler_builtins_c_feature);
 347
 348         cargo
 349             .arg("--features")
 350             .arg(features)
 351             .arg("--manifest-path")
 352             .arg(builder.src.join("library/test/Cargo.toml"));
 353
 354         // Help the libc crate compile by assisting it in finding various
 355         // sysroot native libraries.
 356         if target.contains("musl") {
 357             if let Some(p) = builder.musl_libdir(target) {
 358                 let root = format!("native={}", p.to_str().unwrap());
 359                 cargo.rustflag("-L").rustflag(&root);
 360             }
 361         }
 362
 363         if target.ends_with("-wasi") {
 364             if let Some(p) = builder.wasi_root(target) {
 365                 let root = format!("native={}/lib/wasm32-wasi", p.to_str().unwrap());
 366                 cargo.rustflag("-L").rustflag(&root);
 367             }
 368         }
 369     }
 370
 371     // By default, rustc uses `-Cembed-bitcode=yes`, and Cargo overrides that
 372     // with `-Cembed-bitcode=no` for non-LTO builds. However, libstd must be
 373     // built with bitcode so that the produced rlibs can be used for both LTO
 374     // builds (which use bitcode) and non-LTO builds (which use object code).
 375     // So we override the override here!
 376     //
 377     // But we don't bother for the stage 0 compiler because it's never used
 378     // with LTO.
 379     if stage >= 1 {
 380         cargo.rustflag("-Cembed-bitcode=yes");
 381     }
 382     if builder.config.rust_lto == RustcLto::Off {
 383         cargo.rustflag("-Clto=off");
 384     }
 385
 386     // By default, rustc does not include unwind tables unless they are required
 387     // for a particular target. They are not required by RISC-V targets, but
 388     // compiling the standard library with them means that users can get
 389     // backtraces without having to recompile the standard library themselves.
 390     //
 391     // This choice was discussed in https://github.com/rust-lang/rust/pull/69890
 392     if target.contains("riscv") {
 393         cargo.rustflag("-Cforce-unwind-tables=yes");
 394     }
 395
 396     let html_root =
 397         format!("-Zcrate-attr=doc(html_root_url=\"{}/\")", builder.doc_rust_lang_org_channel(),);
 398     cargo.rustflag(&html_root);
 399     cargo.rustdocflag(&html_root);
 400 }
 401
 402 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 403 struct StdLink {
 404     pub compiler: Compiler,
 405     pub target_compiler: Compiler,
 406     pub target: TargetSelection,
 407     /// Not actually used; only present to make sure the cache invalidation is correct.
 408     crates: Interned<Vec<String>>,
 409 }
 410
 411 impl StdLink {
 412     fn from_std(std: Std, host_compiler: Compiler) -> Self {
 413         Self {
 414             compiler: host_compiler,
 415             target_compiler: std.compiler,
 416             target: std.target,
 417             crates: std.crates,
 418         }
 419     }
 420 }
 421
 422 impl Step for StdLink {
 423     type Output = ();
 424
 425     fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
 426         run.never()
 427     }
 428
 429     /// Link all libstd rlibs/dylibs into the sysroot location.
 430     ///
 431     /// Links those artifacts generated by `compiler` to the `stage` compiler's
 432     /// sysroot for the specified `host` and `target`.
 433     ///
 434     /// Note that this assumes that `compiler` has already generated the libstd
 435     /// libraries for `target`, and this method will find them in the relevant
 436     /// output directory.
 437     fn run(self, builder: &Builder<'_>) {
 438         let compiler = self.compiler;
 439         let target_compiler = self.target_compiler;
 440         let target = self.target;
 441         builder.info(&format!(
 442             "Copying stage{} library from stage{} ({} -> {} / {})",
 443             target_compiler.stage, compiler.stage, &compiler.host, target_compiler.host, target
 444         ));
 445         let libdir = builder.sysroot_libdir(target_compiler, target);
 446         let hostdir = builder.sysroot_libdir(target_compiler, compiler.host);
 447         add_to_sysroot(builder, &libdir, &hostdir, &libstd_stamp(builder, compiler, target));
 448     }
 449 }
 450
 451 /// Copies sanitizer runtime libraries into target libdir.
 452 fn copy_sanitizers(
 453     builder: &Builder<'_>,
 454     compiler: &Compiler,
 455     target: TargetSelection,
 456 ) -> Vec<PathBuf> {
 457     let runtimes: Vec<native::SanitizerRuntime> = builder.ensure(native::Sanitizers { target });
 458
 459     if builder.config.dry_run() {
 460         return Vec::new();
 461     }
 462
 463     let mut target_deps = Vec::new();
 464     let libdir = builder.sysroot_libdir(*compiler, target);
 465
 466     for runtime in &runtimes {
 467         let dst = libdir.join(&runtime.name);
 468         builder.copy(&runtime.path, &dst);
 469
 470         if target == "x86_64-apple-darwin" || target == "aarch64-apple-darwin" {
 471             // Update the library’s install name to reflect that it has been renamed.
 472             apple_darwin_update_library_name(&dst, &format!("@rpath/{}", &runtime.name));
 473             // Upon renaming the install name, the code signature of the file will invalidate,
 474             // so we will sign it again.
 475             apple_darwin_sign_file(&dst);
 476         }
 477
 478         target_deps.push(dst);
 479     }
 480
 481     target_deps
 482 }
 483
 484 fn apple_darwin_update_library_name(library_path: &Path, new_name: &str) {
 485     let status = Command::new("install_name_tool")
 486         .arg("-id")
 487         .arg(new_name)
 488         .arg(library_path)
 489         .status()
 490         .expect("failed to execute `install_name_tool`");
 491     assert!(status.success());
 492 }
 493
 494 fn apple_darwin_sign_file(file_path: &Path) {
 495     let status = Command::new("codesign")
 496         .arg("-f") // Force to rewrite the existing signature
 497         .arg("-s")
 498         .arg("-")
 499         .arg(file_path)
 500         .status()
 501         .expect("failed to execute `codesign`");
 502     assert!(status.success());
 503 }
 504
 505 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 506 pub struct StartupObjects {
 507     pub compiler: Compiler,
 508     pub target: TargetSelection,
 509 }
 510
 511 impl Step for StartupObjects {
 512     type Output = Vec<(PathBuf, DependencyType)>;
 513
 514     fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
 515         run.path("library/rtstartup")
 516     }
 517
 518     fn make_run(run: RunConfig<'_>) {
 519         run.builder.ensure(StartupObjects {
 520             compiler: run.builder.compiler(run.builder.top_stage, run.build_triple()),
 521             target: run.target,
 522         });
 523     }
 524
 525     /// Builds and prepare startup objects like rsbegin.o and rsend.o
 526     ///
 527     /// These are primarily used on Windows right now for linking executables/dlls.
 528     /// They don't require any library support as they're just plain old object
 529     /// files, so we just use the nightly snapshot compiler to always build them (as
 530     /// no other compilers are guaranteed to be available).
 531     fn run(self, builder: &Builder<'_>) -> Vec<(PathBuf, DependencyType)> {
 532         let for_compiler = self.compiler;
 533         let target = self.target;
 534         if !target.ends_with("windows-gnu") {
 535             return vec![];
 536         }
 537
 538         let mut target_deps = vec![];
 539
 540         let src_dir = &builder.src.join("library").join("rtstartup");
 541         let dst_dir = &builder.native_dir(target).join("rtstartup");
 542         let sysroot_dir = &builder.sysroot_libdir(for_compiler, target);
 543         t!(fs::create_dir_all(dst_dir));
 544
 545         for file in &["rsbegin", "rsend"] {
 546             let src_file = &src_dir.join(file.to_string() + ".rs");
 547             let dst_file = &dst_dir.join(file.to_string() + ".o");
 548             if !up_to_date(src_file, dst_file) {
 549                 let mut cmd = Command::new(&builder.initial_rustc);
 550                 cmd.env("RUSTC_BOOTSTRAP", "1");
 551                 if !builder.local_rebuild {
 552                     // a local_rebuild compiler already has stage1 features
 553                     cmd.arg("--cfg").arg("bootstrap");
 554                 }
 555                 builder.run(
 556                     cmd.arg("--target")
 557                         .arg(target.rustc_target_arg())
 558                         .arg("--emit=obj")
 559                         .arg("-o")
 560                         .arg(dst_file)
 561                         .arg(src_file),
 562                 );
 563             }
 564
 565             let target = sysroot_dir.join((*file).to_string() + ".o");
 566             builder.copy(dst_file, &target);
 567             target_deps.push((target, DependencyType::Target));
 568         }
 569
 570         target_deps
 571     }
 572 }
 573
 574 #[derive(Debug, PartialOrd, Ord, Copy, Clone, PartialEq, Eq, Hash)]
 575 pub struct Rustc {
 576     pub target: TargetSelection,
 577     pub compiler: Compiler,
 578     /// Whether to build a subset of crates, rather than the whole compiler.
 579     ///
 580     /// This should only be requested by the user, not used within rustbuild itself.
 581     /// Using it within rustbuild can lead to confusing situation where lints are replayed
 582     /// in two different steps.
 583     crates: Interned<Vec<String>>,
 584 }
 585
 586 impl Rustc {
 587     pub fn new(compiler: Compiler, target: TargetSelection) -> Self {
 588         Self { target, compiler, crates: Default::default() }
 589     }
 590 }
 591
 592 impl Step for Rustc {
 593     type Output = ();
 594     const ONLY_HOSTS: bool = true;
 595     const DEFAULT: bool = false;
 596
 597     fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
 598         let mut crates = run.builder.in_tree_crates("rustc-main", None);
 599         for (i, krate) in crates.iter().enumerate() {
 600             if krate.name == "rustc-main" {
 601                 crates.swap_remove(i);
 602                 break;
 603             }
 604         }
 605         run.crates(crates)
 606     }
 607
 608     fn make_run(run: RunConfig<'_>) {
 609         let crates = run.cargo_crates_in_set();
 610         run.builder.ensure(Rustc {
 611             compiler: run.builder.compiler(run.builder.top_stage, run.build_triple()),
 612             target: run.target,
 613             crates,
 614         });
 615     }
 616
 617     /// Builds the compiler.
 618     ///
 619     /// This will build the compiler for a particular stage of the build using
 620     /// the `compiler` targeting the `target` architecture. The artifacts
 621     /// created will also be linked into the sysroot directory.
 622     fn run(self, builder: &Builder<'_>) {
 623         let compiler = self.compiler;
 624         let target = self.target;
 625
 626         // NOTE: the ABI of the beta compiler is different from the ABI of the downloaded compiler,
 627         // so its artifacts can't be reused.
 628         if builder.download_rustc() && compiler.stage != 0 {
 629             // Copy the existing artifacts instead of rebuilding them.
 630             // NOTE: this path is only taken for tools linking to rustc-dev.
 631             builder.ensure(Sysroot { compiler });
 632             return;
 633         }
 634
 635         builder.ensure(Std::new(compiler, target));
 636
 637         if builder.config.keep_stage.contains(&compiler.stage) {
 638             builder.info("Warning: Using a potentially old librustc. This may not behave well.");
 639             builder.info("Warning: Use `--keep-stage-std` if you want to rebuild the compiler when it changes");
 640             builder.ensure(RustcLink::from_rustc(self, compiler));
 641             return;
 642         }
 643
 644         let compiler_to_use = builder.compiler_for(compiler.stage, compiler.host, target);
 645         if compiler_to_use != compiler {
 646             builder.ensure(Rustc::new(compiler_to_use, target));
 647             builder
 648                 .info(&format!("Uplifting stage1 rustc ({} -> {})", builder.config.build, target));
 649             builder.ensure(RustcLink::from_rustc(self, compiler_to_use));
 650             return;
 651         }
 652
 653         // Ensure that build scripts and proc macros have a std / libproc_macro to link against.
 654         builder.ensure(Std::new(
 655             builder.compiler(self.compiler.stage, builder.config.build),
 656             builder.config.build,
 657         ));
 658
 659         let mut cargo = builder.cargo(compiler, Mode::Rustc, SourceType::InTree, target, "build");
 660         rustc_cargo(builder, &mut cargo, target);
 661
 662         if builder.config.rust_profile_use.is_some()
 663             && builder.config.rust_profile_generate.is_some()
 664         {
 665             panic!("Cannot use and generate PGO profiles at the same time");
 666         }
 667
 668         // With LLD, we can use ICF (identical code folding) to reduce the executable size
 669         // of librustc_driver/rustc and to improve i-cache utilization.
 670         //
 671         // -Wl,[link options] doesn't work on MSVC. However, /OPT:ICF (technically /OPT:REF,ICF)
 672         // is already on by default in MSVC optimized builds, which is interpreted as --icf=all:
 673         // https://github.com/llvm/llvm-project/blob/3329cec2f79185bafd678f310fafadba2a8c76d2/lld/COFF/Driver.cpp#L1746
 674         // https://github.com/rust-lang/rust/blob/f22819bcce4abaff7d1246a56eec493418f9f4ee/compiler/rustc_codegen_ssa/src/back/linker.rs#L827
 675         if builder.config.use_lld && !compiler.host.contains("msvc") {
 676             cargo.rustflag("-Clink-args=-Wl,--icf=all");
 677         }
 678
 679         let is_collecting = if let Some(path) = &builder.config.rust_profile_generate {
 680             if compiler.stage == 1 {
 681                 cargo.rustflag(&format!("-Cprofile-generate={}", path));
 682                 // Apparently necessary to avoid overflowing the counters during
 683                 // a Cargo build profile
 684                 cargo.rustflag("-Cllvm-args=-vp-counters-per-site=4");
 685                 true
 686             } else {
 687                 false
 688             }
 689         } else if let Some(path) = &builder.config.rust_profile_use {
 690             if compiler.stage == 1 {
 691                 cargo.rustflag(&format!("-Cprofile-use={}", path));
 692                 cargo.rustflag("-Cllvm-args=-pgo-warn-missing-function");
 693                 true
 694             } else {
 695                 false
 696             }
 697         } else {
 698             false
 699         };
 700         if is_collecting {
 701             // Ensure paths to Rust sources are relative, not absolute.
 702             cargo.rustflag(&format!(
 703                 "-Cllvm-args=-static-func-strip-dirname-prefix={}",
 704                 builder.config.src.components().count()
 705             ));
 706         }
 707
 708         // We currently don't support cross-crate LTO in stage0. This also isn't hugely necessary
 709         // and may just be a time sink.
 710         if compiler.stage != 0 {
 711             match builder.config.rust_lto {
 712                 RustcLto::Thin | RustcLto::Fat => {
 713                     // Since using LTO for optimizing dylibs is currently experimental,
 714                     // we need to pass -Zdylib-lto.
 715                     cargo.rustflag("-Zdylib-lto");
 716                     // Cargo by default passes `-Cembed-bitcode=no` and doesn't pass `-Clto` when
 717                     // compiling dylibs (and their dependencies), even when LTO is enabled for the
 718                     // crate. Therefore, we need to override `-Clto` and `-Cembed-bitcode` here.
 719                     let lto_type = match builder.config.rust_lto {
 720                         RustcLto::Thin => "thin",
 721                         RustcLto::Fat => "fat",
 722                         _ => unreachable!(),
 723                     };
 724                     cargo.rustflag(&format!("-Clto={}", lto_type));
 725                     cargo.rustflag("-Cembed-bitcode=yes");
 726                 }
 727                 RustcLto::ThinLocal => { /* Do nothing, this is the default */ }
 728                 RustcLto::Off => {
 729                     cargo.rustflag("-Clto=off");
 730                 }
 731             }
 732         } else {
 733             if builder.config.rust_lto == RustcLto::Off {
 734                 cargo.rustflag("-Clto=off");
 735             }
 736         }
 737
 738         for krate in &*self.crates {
 739             cargo.arg("-p").arg(krate);
 740         }
 741
 742         builder.info(&format!(
 743             "Building{} stage{} compiler artifacts ({} -> {})",
 744             crate_description(&self.crates),
 745             compiler.stage,
 746             &compiler.host,
 747             target,
 748         ));
 749         run_cargo(
 750             builder,
 751             cargo,
 752             vec![],
 753             &librustc_stamp(builder, compiler, target),
 754             vec![],
 755             false,
 756             true, // Only ship rustc_driver.so and .rmeta files, not all intermediate .rlib files.
 757         );
 758
 759         builder.ensure(RustcLink::from_rustc(
 760             self,
 761             builder.compiler(compiler.stage, builder.config.build),
 762         ));
 763     }
 764 }
 765
 766 pub fn rustc_cargo(builder: &Builder<'_>, cargo: &mut Cargo, target: TargetSelection) {
 767     cargo
 768         .arg("--features")
 769         .arg(builder.rustc_features(builder.kind))
 770         .arg("--manifest-path")
 771         .arg(builder.src.join("compiler/rustc/Cargo.toml"));
 772     rustc_cargo_env(builder, cargo, target);
 773 }
 774
 775 pub fn rustc_cargo_env(builder: &Builder<'_>, cargo: &mut Cargo, target: TargetSelection) {
 776     // Set some configuration variables picked up by build scripts and
 777     // the compiler alike
 778     cargo
 779         .env("CFG_RELEASE", builder.rust_release())
 780         .env("CFG_RELEASE_CHANNEL", &builder.config.channel)
 781         .env("CFG_VERSION", builder.rust_version());
 782
 783     if let Some(backend) = builder.config.default_codegen_backend() {
 784         cargo.env("CFG_DEFAULT_CODEGEN_BACKEND", backend);
 785     }
 786
 787     let libdir_relative = builder.config.libdir_relative().unwrap_or_else(|| Path::new("lib"));
 788     let target_config = builder.config.target_config.get(&target);
 789
 790     cargo.env("CFG_LIBDIR_RELATIVE", libdir_relative);
 791
 792     if let Some(ref ver_date) = builder.rust_info().commit_date() {
 793         cargo.env("CFG_VER_DATE", ver_date);
 794     }
 795     if let Some(ref ver_hash) = builder.rust_info().sha() {
 796         cargo.env("CFG_VER_HASH", ver_hash);
 797     }
 798     if !builder.unstable_features() {
 799         cargo.env("CFG_DISABLE_UNSTABLE_FEATURES", "1");
 800     }
 801
 802     // Prefer the current target's own default_linker, else a globally
 803     // specified one.
 804     if let Some(s) = target_config.and_then(|c| c.default_linker.as_ref()) {
 805         cargo.env("CFG_DEFAULT_LINKER", s);
 806     } else if let Some(ref s) = builder.config.rustc_default_linker {
 807         cargo.env("CFG_DEFAULT_LINKER", s);
 808     }
 809
 810     if builder.config.rustc_parallel {
 811         // keep in sync with `bootstrap/lib.rs:Build::rustc_features`
 812         // `cfg` option for rustc, `features` option for cargo, for conditional compilation
 813         cargo.rustflag("--cfg=parallel_compiler");
 814         cargo.rustdocflag("--cfg=parallel_compiler");
 815     }
 816     if builder.config.rust_verify_llvm_ir {
 817         cargo.env("RUSTC_VERIFY_LLVM_IR", "1");
 818     }
 819
 820     // Pass down configuration from the LLVM build into the build of
 821     // rustc_llvm and rustc_codegen_llvm.
 822     //
 823     // Note that this is disabled if LLVM itself is disabled or we're in a check
 824     // build. If we are in a check build we still go ahead here presuming we've
 825     // detected that LLVM is already built and good to go which helps prevent
 826     // busting caches (e.g. like #71152).
 827     if builder.config.llvm_enabled()
 828         && (builder.kind != Kind::Check
 829             || crate::native::prebuilt_llvm_config(builder, target).is_ok())
 830     {
 831         if builder.is_rust_llvm(target) {
 832             cargo.env("LLVM_RUSTLLVM", "1");
 833         }
 834         let native::LlvmResult { llvm_config, .. } = builder.ensure(native::Llvm { target });
 835         cargo.env("LLVM_CONFIG", &llvm_config);
 836         if let Some(s) = target_config.and_then(|c| c.llvm_config.as_ref()) {
 837             cargo.env("CFG_LLVM_ROOT", s);
 838         }
 839
 840         // Some LLVM linker flags (-L and -l) may be needed to link `rustc_llvm`. Its build script
 841         // expects these to be passed via the `LLVM_LINKER_FLAGS` env variable, separated by
 842         // whitespace.
 843         //
 844         // For example:
 845         // - on windows, when `clang-cl` is used with instrumentation, we need to manually add
 846         // clang's runtime library resource directory so that the profiler runtime library can be
 847         // found. This is to avoid the linker errors about undefined references to
 848         // `__llvm_profile_instrument_memop` when linking `rustc_driver`.
 849         let mut llvm_linker_flags = String::new();
 850         if builder.config.llvm_profile_generate && target.contains("msvc") {
 851             if let Some(ref clang_cl_path) = builder.config.llvm_clang_cl {
 852                 // Add clang's runtime library directory to the search path
 853                 let clang_rt_dir = get_clang_cl_resource_dir(clang_cl_path);
 854                 llvm_linker_flags.push_str(&format!("-L{}", clang_rt_dir.display()));
 855             }
 856         }
 857
 858         // The config can also specify its own llvm linker flags.
 859         if let Some(ref s) = builder.config.llvm_ldflags {
 860             if !llvm_linker_flags.is_empty() {
 861                 llvm_linker_flags.push_str(" ");
 862             }
 863             llvm_linker_flags.push_str(s);
 864         }
 865
 866         // Set the linker flags via the env var that `rustc_llvm`'s build script will read.
 867         if !llvm_linker_flags.is_empty() {
 868             cargo.env("LLVM_LINKER_FLAGS", llvm_linker_flags);
 869         }
 870
 871         // Building with a static libstdc++ is only supported on linux right now,
 872         // not for MSVC or macOS
 873         if builder.config.llvm_static_stdcpp
 874             && !target.contains("freebsd")
 875             && !target.contains("msvc")
 876             && !target.contains("apple")
 877             && !target.contains("solaris")
 878         {
 879             let file = compiler_file(
 880                 builder,
 881                 builder.cxx(target).unwrap(),
 882                 target,
 883                 CLang::Cxx,
 884                 "libstdc++.a",
 885             );
 886             cargo.env("LLVM_STATIC_STDCPP", file);
 887         }
 888         if builder.llvm_link_shared() {
 889             cargo.env("LLVM_LINK_SHARED", "1");
 890         }
 891         if builder.config.llvm_use_libcxx {
 892             cargo.env("LLVM_USE_LIBCXX", "1");
 893         }
 894         if builder.config.llvm_optimize && !builder.config.llvm_release_debuginfo {
 895             cargo.env("LLVM_NDEBUG", "1");
 896         }
 897     }
 898 }
 899
 900 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 901 struct RustcLink {
 902     pub compiler: Compiler,
 903     pub target_compiler: Compiler,
 904     pub target: TargetSelection,
 905     /// Not actually used; only present to make sure the cache invalidation is correct.
 906     crates: Interned<Vec<String>>,
 907 }
 908
 909 impl RustcLink {
 910     fn from_rustc(rustc: Rustc, host_compiler: Compiler) -> Self {
 911         Self {
 912             compiler: host_compiler,
 913             target_compiler: rustc.compiler,
 914             target: rustc.target,
 915             crates: rustc.crates,
 916         }
 917     }
 918 }
 919
 920 impl Step for RustcLink {
 921     type Output = ();
 922
 923     fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
 924         run.never()
 925     }
 926
 927     /// Same as `std_link`, only for librustc
 928     fn run(self, builder: &Builder<'_>) {
 929         let compiler = self.compiler;
 930         let target_compiler = self.target_compiler;
 931         let target = self.target;
 932         builder.info(&format!(
 933             "Copying stage{} rustc from stage{} ({} -> {} / {})",
 934             target_compiler.stage, compiler.stage, &compiler.host, target_compiler.host, target
 935         ));
 936         add_to_sysroot(
 937             builder,
 938             &builder.sysroot_libdir(target_compiler, target),
 939             &builder.sysroot_libdir(target_compiler, compiler.host),
 940             &librustc_stamp(builder, compiler, target),
 941         );
 942     }
 943 }
 944
 945 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 946 pub struct CodegenBackend {
 947     pub target: TargetSelection,
 948     pub compiler: Compiler,
 949     pub backend: Interned<String>,
 950 }
 951
 952 impl Step for CodegenBackend {
 953     type Output = ();
 954     const ONLY_HOSTS: bool = true;
 955     // Only the backends specified in the `codegen-backends` entry of `config.toml` are built.
 956     const DEFAULT: bool = true;
 957
 958     fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
 959         run.paths(&["compiler/rustc_codegen_cranelift", "compiler/rustc_codegen_gcc"])
 960     }
 961
 962     fn make_run(run: RunConfig<'_>) {
 963         for &backend in &run.builder.config.rust_codegen_backends {
 964             if backend == "llvm" {
 965                 continue; // Already built as part of rustc
 966             }
 967
 968             run.builder.ensure(CodegenBackend {
 969                 target: run.target,
 970                 compiler: run.builder.compiler(run.builder.top_stage, run.build_triple()),
 971                 backend,
 972             });
 973         }
 974     }
 975
 976     fn run(self, builder: &Builder<'_>) {
 977         let compiler = self.compiler;
 978         let target = self.target;
 979         let backend = self.backend;
 980
 981         builder.ensure(Rustc::new(compiler, target));
 982
 983         if builder.config.keep_stage.contains(&compiler.stage) {
 984             builder.info(
 985                 "Warning: Using a potentially old codegen backend. \
 986                 This may not behave well.",
 987             );
 988             // Codegen backends are linked separately from this step today, so we don't do
 989             // anything here.
 990             return;
 991         }
 992
 993         let compiler_to_use = builder.compiler_for(compiler.stage, compiler.host, target);
 994         if compiler_to_use != compiler {
 995             builder.ensure(CodegenBackend { compiler: compiler_to_use, target, backend });
 996             return;
 997         }
 998
 999         let out_dir = builder.cargo_out(compiler, Mode::Codegen, target);
1000
1001         let mut cargo = builder.cargo(compiler, Mode::Codegen, SourceType::InTree, target, "build");
1002         cargo
1003             .arg("--manifest-path")
1004             .arg(builder.src.join(format!("compiler/rustc_codegen_{}/Cargo.toml", backend)));
1005         rustc_cargo_env(builder, &mut cargo, target);
1006
1007         let tmp_stamp = out_dir.join(".tmp.stamp");
1008
1009         builder.info(&format!(
1010             "Building stage{} codegen backend {} ({} -> {})",
1011             compiler.stage, backend, &compiler.host, target
1012         ));
1013         let files = run_cargo(builder, cargo, vec![], &tmp_stamp, vec![], false, false);
1014         if builder.config.dry_run() {
1015             return;
1016         }
1017         let mut files = files.into_iter().filter(|f| {
1018             let filename = f.file_name().unwrap().to_str().unwrap();
1019             is_dylib(filename) && filename.contains("rustc_codegen_")
1020         });
1021         let codegen_backend = match files.next() {
1022             Some(f) => f,
1023             None => panic!("no dylibs built for codegen backend?"),
1024         };
1025         if let Some(f) = files.next() {
1026             panic!(
1027                 "codegen backend built two dylibs:\n{}\n{}",
1028                 codegen_backend.display(),
1029                 f.display()
1030             );
1031         }
1032         let stamp = codegen_backend_stamp(builder, compiler, target, backend);
1033         let codegen_backend = codegen_backend.to_str().unwrap();
1034         t!(fs::write(&stamp, &codegen_backend));
1035     }
1036 }
1037
1038 /// Creates the `codegen-backends` folder for a compiler that's about to be
1039 /// assembled as a complete compiler.
1040 ///
1041 /// This will take the codegen artifacts produced by `compiler` and link them
1042 /// into an appropriate location for `target_compiler` to be a functional
1043 /// compiler.
1044 fn copy_codegen_backends_to_sysroot(
1045     builder: &Builder<'_>,
1046     compiler: Compiler,
1047     target_compiler: Compiler,
1048 ) {
1049     let target = target_compiler.host;
1050
1051     // Note that this step is different than all the other `*Link` steps in
1052     // that it's not assembling a bunch of libraries but rather is primarily
1053     // moving the codegen backend into place. The codegen backend of rustc is
1054     // not linked into the main compiler by default but is rather dynamically
1055     // selected at runtime for inclusion.
1056     //
1057     // Here we're looking for the output dylib of the `CodegenBackend` step and
1058     // we're copying that into the `codegen-backends` folder.
1059     let dst = builder.sysroot_codegen_backends(target_compiler);
1060     t!(fs::create_dir_all(&dst), dst);
1061
1062     if builder.config.dry_run() {
1063         return;
1064     }
1065
1066     for backend in builder.config.rust_codegen_backends.iter() {
1067         if backend == "llvm" {
1068             continue; // Already built as part of rustc
1069         }
1070
1071         let stamp = codegen_backend_stamp(builder, compiler, target, *backend);
1072         let dylib = t!(fs::read_to_string(&stamp));
1073         let file = Path::new(&dylib);
1074         let filename = file.file_name().unwrap().to_str().unwrap();
1075         // change `librustc_codegen_cranelift-xxxxxx.so` to
1076         // `librustc_codegen_cranelift-release.so`
1077         let target_filename = {
1078             let dash = filename.find('-').unwrap();
1079             let dot = filename.find('.').unwrap();
1080             format!("{}-{}{}", &filename[..dash], builder.rust_release(), &filename[dot..])
1081         };
1082         builder.copy(&file, &dst.join(target_filename));
1083     }
1084 }
1085
1086 /// Cargo's output path for the standard library in a given stage, compiled
1087 /// by a particular compiler for the specified target.
1088 pub fn libstd_stamp(builder: &Builder<'_>, compiler: Compiler, target: TargetSelection) -> PathBuf {
1089     builder.cargo_out(compiler, Mode::Std, target).join(".libstd.stamp")
1090 }
1091
1092 /// Cargo's output path for librustc in a given stage, compiled by a particular
1093 /// compiler for the specified target.
1094 pub fn librustc_stamp(
1095     builder: &Builder<'_>,
1096     compiler: Compiler,
1097     target: TargetSelection,
1098 ) -> PathBuf {
1099     builder.cargo_out(compiler, Mode::Rustc, target).join(".librustc.stamp")
1100 }
1101
1102 /// Cargo's output path for librustc_codegen_llvm in a given stage, compiled by a particular
1103 /// compiler for the specified target and backend.
1104 fn codegen_backend_stamp(
1105     builder: &Builder<'_>,
1106     compiler: Compiler,
1107     target: TargetSelection,
1108     backend: Interned<String>,
1109 ) -> PathBuf {
1110     builder
1111         .cargo_out(compiler, Mode::Codegen, target)
1112         .join(format!(".librustc_codegen_{}.stamp", backend))
1113 }
1114
1115 pub fn compiler_file(
1116     builder: &Builder<'_>,
1117     compiler: &Path,
1118     target: TargetSelection,
1119     c: CLang,
1120     file: &str,
1121 ) -> PathBuf {
1122     let mut cmd = Command::new(compiler);
1123     cmd.args(builder.cflags(target, GitRepo::Rustc, c));
1124     cmd.arg(format!("-print-file-name={}", file));
1125     let out = output(&mut cmd);
1126     PathBuf::from(out.trim())
1127 }
1128
1129 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
1130 pub struct Sysroot {
1131     pub compiler: Compiler,
1132 }
1133
1134 impl Step for Sysroot {
1135     type Output = Interned<PathBuf>;
1136
1137     fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
1138         run.never()
1139     }
1140
1141     /// Returns the sysroot for the `compiler` specified that *this build system
1142     /// generates*.
1143     ///
1144     /// That is, the sysroot for the stage0 compiler is not what the compiler
1145     /// thinks it is by default, but it's the same as the default for stages
1146     /// 1-3.
1147     fn run(self, builder: &Builder<'_>) -> Interned<PathBuf> {
1148         let compiler = self.compiler;
1149         let host_dir = builder.out.join(&compiler.host.triple);
1150
1151         let sysroot_dir = |stage| {
1152             if stage == 0 {
1153                 host_dir.join("stage0-sysroot")
1154             } else if builder.download_rustc() && compiler.stage != builder.top_stage {
1155                 host_dir.join("ci-rustc-sysroot")
1156             } else {
1157                 host_dir.join(format!("stage{}", stage))
1158             }
1159         };
1160         let sysroot = sysroot_dir(compiler.stage);
1161
1162         let _ = fs::remove_dir_all(&sysroot);
1163         t!(fs::create_dir_all(&sysroot));
1164
1165         // If we're downloading a compiler from CI, we can use the same compiler for all stages other than 0.
1166         if builder.download_rustc() && compiler.stage != 0 {
1167             assert_eq!(
1168                 builder.config.build, compiler.host,
1169                 "Cross-compiling is not yet supported with `download-rustc`",
1170             );
1171
1172             // #102002, cleanup old toolchain folders when using download-rustc so people don't use them by accident.
1173             for stage in 0..=2 {
1174                 if stage != compiler.stage {
1175                     let dir = sysroot_dir(stage);
1176                     if !dir.ends_with("ci-rustc-sysroot") {
1177                         let _ = fs::remove_dir_all(dir);
1178                     }
1179                 }
1180             }
1181
1182             // Copy the compiler into the correct sysroot.
1183             let ci_rustc_dir =
1184                 builder.config.out.join(&*builder.config.build.triple).join("ci-rustc");
1185             builder.cp_r(&ci_rustc_dir, &sysroot);
1186             return INTERNER.intern_path(sysroot);
1187         }
1188
1189         // Symlink the source root into the same location inside the sysroot,
1190         // where `rust-src` component would go (`$sysroot/lib/rustlib/src/rust`),
1191         // so that any tools relying on `rust-src` also work for local builds,
1192         // and also for translating the virtual `/rustc/$hash` back to the real
1193         // directory (for running tests with `rust.remap-debuginfo = true`).
1194         let sysroot_lib_rustlib_src = sysroot.join("lib/rustlib/src");
1195         t!(fs::create_dir_all(&sysroot_lib_rustlib_src));
1196         let sysroot_lib_rustlib_src_rust = sysroot_lib_rustlib_src.join("rust");
1197         if let Err(e) = symlink_dir(&builder.config, &builder.src, &sysroot_lib_rustlib_src_rust) {
1198             eprintln!(
1199                 "warning: creating symbolic link `{}` to `{}` failed with {}",
1200                 sysroot_lib_rustlib_src_rust.display(),
1201                 builder.src.display(),
1202                 e,
1203             );
1204             if builder.config.rust_remap_debuginfo {
1205                 eprintln!(
1206                     "warning: some `tests/ui` tests will fail when lacking `{}`",
1207                     sysroot_lib_rustlib_src_rust.display(),
1208                 );
1209             }
1210         }
1211         // Same for the rustc-src component.
1212         let sysroot_lib_rustlib_rustcsrc = sysroot.join("lib/rustlib/rustc-src");
1213         t!(fs::create_dir_all(&sysroot_lib_rustlib_rustcsrc));
1214         let sysroot_lib_rustlib_rustcsrc_rust = sysroot_lib_rustlib_rustcsrc.join("rust");
1215         if let Err(e) =
1216             symlink_dir(&builder.config, &builder.src, &sysroot_lib_rustlib_rustcsrc_rust)
1217         {
1218             eprintln!(
1219                 "warning: creating symbolic link `{}` to `{}` failed with {}",
1220                 sysroot_lib_rustlib_rustcsrc_rust.display(),
1221                 builder.src.display(),
1222                 e,
1223             );
1224         }
1225
1226         INTERNER.intern_path(sysroot)
1227     }
1228 }
1229
1230 #[derive(Debug, Copy, PartialOrd, Ord, Clone, PartialEq, Eq, Hash)]
1231 pub struct Assemble {
1232     /// The compiler which we will produce in this step. Assemble itself will
1233     /// take care of ensuring that the necessary prerequisites to do so exist,
1234     /// that is, this target can be a stage2 compiler and Assemble will build
1235     /// previous stages for you.
1236     pub target_compiler: Compiler,
1237 }
1238
1239 impl Step for Assemble {
1240     type Output = Compiler;
1241     const ONLY_HOSTS: bool = true;
1242
1243     fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
1244         run.path("compiler/rustc").path("compiler")
1245     }
1246
1247     fn make_run(run: RunConfig<'_>) {
1248         run.builder.ensure(Assemble {
1249             target_compiler: run.builder.compiler(run.builder.top_stage + 1, run.target),
1250         });
1251     }
1252
1253     /// Prepare a new compiler from the artifacts in `stage`
1254     ///
1255     /// This will assemble a compiler in `build/$host/stage$stage`. The compiler
1256     /// must have been previously produced by the `stage - 1` builder.build
1257     /// compiler.
1258     fn run(self, builder: &Builder<'_>) -> Compiler {
1259         let target_compiler = self.target_compiler;
1260
1261         if target_compiler.stage == 0 {
1262             assert_eq!(
1263                 builder.config.build, target_compiler.host,
1264                 "Cannot obtain compiler for non-native build triple at stage 0"
1265             );
1266             // The stage 0 compiler for the build triple is always pre-built.
1267             return target_compiler;
1268         }
1269
1270         // Get the compiler that we'll use to bootstrap ourselves.
1271         //
1272         // Note that this is where the recursive nature of the bootstrap
1273         // happens, as this will request the previous stage's compiler on
1274         // downwards to stage 0.
1275         //
1276         // Also note that we're building a compiler for the host platform. We
1277         // only assume that we can run `build` artifacts, which means that to
1278         // produce some other architecture compiler we need to start from
1279         // `build` to get there.
1280         //
1281         // FIXME: It may be faster if we build just a stage 1 compiler and then
1282         //        use that to bootstrap this compiler forward.
1283         let build_compiler = builder.compiler(target_compiler.stage - 1, builder.config.build);
1284
1285         // If we're downloading a compiler from CI, we can use the same compiler for all stages other than 0.
1286         if builder.download_rustc() {
1287             builder.ensure(Sysroot { compiler: target_compiler });
1288             return target_compiler;
1289         }
1290
1291         // Build the libraries for this compiler to link to (i.e., the libraries
1292         // it uses at runtime). NOTE: Crates the target compiler compiles don't
1293         // link to these. (FIXME: Is that correct? It seems to be correct most
1294         // of the time but I think we do link to these for stage2/bin compilers
1295         // when not performing a full bootstrap).
1296         builder.ensure(Rustc::new(build_compiler, target_compiler.host));
1297
1298         for &backend in builder.config.rust_codegen_backends.iter() {
1299             if backend == "llvm" {
1300                 continue; // Already built as part of rustc
1301             }
1302
1303             builder.ensure(CodegenBackend {
1304                 compiler: build_compiler,
1305                 target: target_compiler.host,
1306                 backend,
1307             });
1308         }
1309
1310         let lld_install = if builder.config.lld_enabled {
1311             Some(builder.ensure(native::Lld { target: target_compiler.host }))
1312         } else {
1313             None
1314         };
1315
1316         let stage = target_compiler.stage;
1317         let host = target_compiler.host;
1318         builder.info(&format!("Assembling stage{} compiler ({})", stage, host));
1319
1320         // Link in all dylibs to the libdir
1321         let stamp = librustc_stamp(builder, build_compiler, target_compiler.host);
1322         let proc_macros = builder
1323             .read_stamp_file(&stamp)
1324             .into_iter()
1325             .filter_map(|(path, dependency_type)| {
1326                 if dependency_type == DependencyType::Host {
1327                     Some(path.file_name().unwrap().to_owned().into_string().unwrap())
1328                 } else {
1329                     None
1330                 }
1331             })
1332             .collect::<HashSet<_>>();
1333
1334         let sysroot = builder.sysroot(target_compiler);
1335         let rustc_libdir = builder.rustc_libdir(target_compiler);
1336         t!(fs::create_dir_all(&rustc_libdir));
1337         let src_libdir = builder.sysroot_libdir(build_compiler, host);
1338         for f in builder.read_dir(&src_libdir) {
1339             let filename = f.file_name().into_string().unwrap();
1340             if (is_dylib(&filename) || is_debug_info(&filename)) && !proc_macros.contains(&filename)
1341             {
1342                 builder.copy(&f.path(), &rustc_libdir.join(&filename));
1343             }
1344         }
1345
1346         copy_codegen_backends_to_sysroot(builder, build_compiler, target_compiler);
1347
1348         // We prepend this bin directory to the user PATH when linking Rust binaries. To
1349         // avoid shadowing the system LLD we rename the LLD we provide to `rust-lld`.
1350         let libdir = builder.sysroot_libdir(target_compiler, target_compiler.host);
1351         let libdir_bin = libdir.parent().unwrap().join("bin");
1352         t!(fs::create_dir_all(&libdir_bin));
1353         if let Some(lld_install) = lld_install {
1354             let src_exe = exe("lld", target_compiler.host);
1355             let dst_exe = exe("rust-lld", target_compiler.host);
1356             builder.copy(&lld_install.join("bin").join(&src_exe), &libdir_bin.join(&dst_exe));
1357             // for `-Z gcc-ld=lld`
1358             let gcc_ld_dir = libdir_bin.join("gcc-ld");
1359             t!(fs::create_dir(&gcc_ld_dir));
1360             let lld_wrapper_exe = builder.ensure(crate::tool::LldWrapper {
1361                 compiler: build_compiler,
1362                 target: target_compiler.host,
1363             });
1364             for name in crate::LLD_FILE_NAMES {
1365                 builder.copy(&lld_wrapper_exe, &gcc_ld_dir.join(exe(name, target_compiler.host)));
1366             }
1367         }
1368
1369         if builder.config.rust_codegen_backends.contains(&INTERNER.intern_str("llvm")) {
1370             let native::LlvmResult { llvm_config, .. } =
1371                 builder.ensure(native::Llvm { target: target_compiler.host });
1372             if !builder.config.dry_run() {
1373                 let llvm_bin_dir = output(Command::new(llvm_config).arg("--bindir"));
1374                 let llvm_bin_dir = Path::new(llvm_bin_dir.trim());
1375
1376                 // Since we've already built the LLVM tools, install them to the sysroot.
1377                 // This is the equivalent of installing the `llvm-tools-preview` component via
1378                 // rustup, and lets developers use a locally built toolchain to
1379                 // build projects that expect llvm tools to be present in the sysroot
1380                 // (e.g. the `bootimage` crate).
1381                 for tool in LLVM_TOOLS {
1382                     let tool_exe = exe(tool, target_compiler.host);
1383                     let src_path = llvm_bin_dir.join(&tool_exe);
1384                     // When using `download-ci-llvm`, some of the tools
1385                     // may not exist, so skip trying to copy them.
1386                     if src_path.exists() {
1387                         builder.copy(&src_path, &libdir_bin.join(&tool_exe));
1388                     }
1389                 }
1390             }
1391         }
1392
1393         // Ensure that `libLLVM.so` ends up in the newly build compiler directory,
1394         // so that it can be found when the newly built `rustc` is run.
1395         dist::maybe_install_llvm_runtime(builder, target_compiler.host, &sysroot);
1396         dist::maybe_install_llvm_target(builder, target_compiler.host, &sysroot);
1397
1398         // Link the compiler binary itself into place
1399         let out_dir = builder.cargo_out(build_compiler, Mode::Rustc, host);
1400         let rustc = out_dir.join(exe("rustc-main", host));
1401         let bindir = sysroot.join("bin");
1402         t!(fs::create_dir_all(&bindir));
1403         let compiler = builder.rustc(target_compiler);
1404         builder.copy(&rustc, &compiler);
1405
1406         target_compiler
1407     }
1408 }
1409
1410 /// Link some files into a rustc sysroot.
1411 ///
1412 /// For a particular stage this will link the file listed in `stamp` into the
1413 /// `sysroot_dst` provided.
1414 pub fn add_to_sysroot(
1415     builder: &Builder<'_>,
1416     sysroot_dst: &Path,
1417     sysroot_host_dst: &Path,
1418     stamp: &Path,
1419 ) {
1420     let self_contained_dst = &sysroot_dst.join("self-contained");
1421     t!(fs::create_dir_all(&sysroot_dst));
1422     t!(fs::create_dir_all(&sysroot_host_dst));
1423     t!(fs::create_dir_all(&self_contained_dst));
1424     for (path, dependency_type) in builder.read_stamp_file(stamp) {
1425         let dst = match dependency_type {
1426             DependencyType::Host => sysroot_host_dst,
1427             DependencyType::Target => sysroot_dst,
1428             DependencyType::TargetSelfContained => self_contained_dst,
1429         };
1430         builder.copy(&path, &dst.join(path.file_name().unwrap()));
1431     }
1432 }
1433
1434 pub fn run_cargo(
1435     builder: &Builder<'_>,
1436     cargo: Cargo,
1437     tail_args: Vec<String>,
1438     stamp: &Path,
1439     additional_target_deps: Vec<(PathBuf, DependencyType)>,
1440     is_check: bool,
1441     rlib_only_metadata: bool,
1442 ) -> Vec<PathBuf> {
1443     if builder.config.dry_run() {
1444         return Vec::new();
1445     }
1446
1447     // `target_root_dir` looks like $dir/$target/release
1448     let target_root_dir = stamp.parent().unwrap();
1449     // `target_deps_dir` looks like $dir/$target/release/deps
1450     let target_deps_dir = target_root_dir.join("deps");
1451     // `host_root_dir` looks like $dir/release
1452     let host_root_dir = target_root_dir
1453         .parent()
1454         .unwrap() // chop off `release`
1455         .parent()
1456         .unwrap() // chop off `$target`
1457         .join(target_root_dir.file_name().unwrap());
1458
1459     // Spawn Cargo slurping up its JSON output. We'll start building up the
1460     // `deps` array of all files it generated along with a `toplevel` array of
1461     // files we need to probe for later.
1462     let mut deps = Vec::new();
1463     let mut toplevel = Vec::new();
1464     let ok = stream_cargo(builder, cargo, tail_args, &mut |msg| {
1465         let (filenames, crate_types) = match msg {
1466             CargoMessage::CompilerArtifact {
1467                 filenames,
1468                 target: CargoTarget { crate_types },
1469                 ..
1470             } => (filenames, crate_types),
1471             _ => return,
1472         };
1473         for filename in filenames {
1474             // Skip files like executables
1475             let mut keep = false;
1476             if filename.ends_with(".lib")
1477                 || filename.ends_with(".a")
1478                 || is_debug_info(&filename)
1479                 || is_dylib(&filename)
1480             {
1481                 // Always keep native libraries, rust dylibs and debuginfo
1482                 keep = true;
1483             }
1484             if is_check && filename.ends_with(".rmeta") {
1485                 // During check builds we need to keep crate metadata
1486                 keep = true;
1487             } else if rlib_only_metadata {
1488                 if filename.contains("jemalloc_sys") || filename.contains("rustc_smir") {
1489                     // jemalloc_sys and rustc_smir are not linked into librustc_driver.so,
1490                     // so we need to distribute them as rlib to be able to use them.
1491                     keep |= filename.ends_with(".rlib");
1492                 } else {
1493                     // Distribute the rest of the rustc crates as rmeta files only to reduce
1494                     // the tarball sizes by about 50%. The object files are linked into
1495                     // librustc_driver.so, so it is still possible to link against them.
1496                     keep |= filename.ends_with(".rmeta");
1497                 }
1498             } else {
1499                 // In all other cases keep all rlibs
1500                 keep |= filename.ends_with(".rlib");
1501             }
1502
1503             if !keep {
1504                 continue;
1505             }
1506
1507             let filename = Path::new(&*filename);
1508
1509             // If this was an output file in the "host dir" we don't actually
1510             // worry about it, it's not relevant for us
1511             if filename.starts_with(&host_root_dir) {
1512                 // Unless it's a proc macro used in the compiler
1513                 if crate_types.iter().any(|t| t == "proc-macro") {
1514                     deps.push((filename.to_path_buf(), DependencyType::Host));
1515                 }
1516                 continue;
1517             }
1518
1519             // If this was output in the `deps` dir then this is a precise file
1520             // name (hash included) so we start tracking it.
1521             if filename.starts_with(&target_deps_dir) {
1522                 deps.push((filename.to_path_buf(), DependencyType::Target));
1523                 continue;
1524             }
1525
1526             // Otherwise this was a "top level artifact" which right now doesn't
1527             // have a hash in the name, but there's a version of this file in
1528             // the `deps` folder which *does* have a hash in the name. That's
1529             // the one we'll want to we'll probe for it later.
1530             //
1531             // We do not use `Path::file_stem` or `Path::extension` here,
1532             // because some generated files may have multiple extensions e.g.
1533             // `std-<hash>.dll.lib` on Windows. The aforementioned methods only
1534             // split the file name by the last extension (`.lib`) while we need
1535             // to split by all extensions (`.dll.lib`).
1536             let expected_len = t!(filename.metadata()).len();
1537             let filename = filename.file_name().unwrap().to_str().unwrap();
1538             let mut parts = filename.splitn(2, '.');
1539             let file_stem = parts.next().unwrap().to_owned();
1540             let extension = parts.next().unwrap().to_owned();
1541
1542             toplevel.push((file_stem, extension, expected_len));
1543         }
1544     });
1545
1546     if !ok {
1547         crate::detail_exit(1);
1548     }
1549
1550     // Ok now we need to actually find all the files listed in `toplevel`. We've
1551     // got a list of prefix/extensions and we basically just need to find the
1552     // most recent file in the `deps` folder corresponding to each one.
1553     let contents = t!(target_deps_dir.read_dir())
1554         .map(|e| t!(e))
1555         .map(|e| (e.path(), e.file_name().into_string().unwrap(), t!(e.metadata())))
1556         .collect::<Vec<_>>();
1557     for (prefix, extension, expected_len) in toplevel {
1558         let candidates = contents.iter().filter(|&&(_, ref filename, ref meta)| {
1559             meta.len() == expected_len
1560                 && filename
1561                     .strip_prefix(&prefix[..])
1562                     .map(|s| s.starts_with('-') && s.ends_with(&extension[..]))
1563                     .unwrap_or(false)
1564         });
1565         let max = candidates.max_by_key(|&&(_, _, ref metadata)| {
1566             metadata.modified().expect("mtime should be available on all relevant OSes")
1567         });
1568         let path_to_add = match max {
1569             Some(triple) => triple.0.to_str().unwrap(),
1570             None => panic!("no output generated for {:?} {:?}", prefix, extension),
1571         };
1572         if is_dylib(path_to_add) {
1573             let candidate = format!("{}.lib", path_to_add);
1574             let candidate = PathBuf::from(candidate);
1575             if candidate.exists() {
1576                 deps.push((candidate, DependencyType::Target));
1577             }
1578         }
1579         deps.push((path_to_add.into(), DependencyType::Target));
1580     }
1581
1582     deps.extend(additional_target_deps);
1583     deps.sort();
1584     let mut new_contents = Vec::new();
1585     for (dep, dependency_type) in deps.iter() {
1586         new_contents.extend(match *dependency_type {
1587             DependencyType::Host => b"h",
1588             DependencyType::Target => b"t",
1589             DependencyType::TargetSelfContained => b"s",
1590         });
1591         new_contents.extend(dep.to_str().unwrap().as_bytes());
1592         new_contents.extend(b"\0");
1593     }
1594     t!(fs::write(&stamp, &new_contents));
1595     deps.into_iter().map(|(d, _)| d).collect()
1596 }
1597
1598 pub fn stream_cargo(
1599     builder: &Builder<'_>,
1600     cargo: Cargo,
1601     tail_args: Vec<String>,
1602     cb: &mut dyn FnMut(CargoMessage<'_>),
1603 ) -> bool {
1604     let mut cargo = Command::from(cargo);
1605     if builder.config.dry_run() {
1606         return true;
1607     }
1608     // Instruct Cargo to give us json messages on stdout, critically leaving
1609     // stderr as piped so we can get those pretty colors.
1610     let mut message_format = if builder.config.json_output {
1611         String::from("json")
1612     } else {
1613         String::from("json-render-diagnostics")
1614     };
1615     if let Some(s) = &builder.config.rustc_error_format {
1616         message_format.push_str(",json-diagnostic-");
1617         message_format.push_str(s);
1618     }
1619     cargo.arg("--message-format").arg(message_format).stdout(Stdio::piped());
1620
1621     for arg in tail_args {
1622         cargo.arg(arg);
1623     }
1624
1625     builder.verbose(&format!("running: {:?}", cargo));
1626     let mut child = match cargo.spawn() {
1627         Ok(child) => child,
1628         Err(e) => panic!("failed to execute command: {:?}\nerror: {}", cargo, e),
1629     };
1630
1631     // Spawn Cargo slurping up its JSON output. We'll start building up the
1632     // `deps` array of all files it generated along with a `toplevel` array of
1633     // files we need to probe for later.
1634     let stdout = BufReader::new(child.stdout.take().unwrap());
1635     for line in stdout.lines() {
1636         let line = t!(line);
1637         match serde_json::from_str::<CargoMessage<'_>>(&line) {
1638             Ok(msg) => {
1639                 if builder.config.json_output {
1640                     // Forward JSON to stdout.
1641                     println!("{}", line);
1642                 }
1643                 cb(msg)
1644             }
1645             // If this was informational, just print it out and continue
1646             Err(_) => println!("{}", line),
1647         }
1648     }
1649
1650     // Make sure Cargo actually succeeded after we read all of its stdout.
1651     let status = t!(child.wait());
1652     if builder.is_verbose() && !status.success() {
1653         eprintln!(
1654             "command did not execute successfully: {:?}\n\
1655                   expected success, got: {}",
1656             cargo, status
1657         );
1658     }
1659     status.success()
1660 }
1661
1662 #[derive(Deserialize)]
1663 pub struct CargoTarget<'a> {
1664     crate_types: Vec<Cow<'a, str>>,
1665 }
1666
1667 #[derive(Deserialize)]
1668 #[serde(tag = "reason", rename_all = "kebab-case")]
1669 pub enum CargoMessage<'a> {
1670     CompilerArtifact {
1671         package_id: Cow<'a, str>,
1672         features: Vec<Cow<'a, str>>,
1673         filenames: Vec<Cow<'a, str>>,
1674         target: CargoTarget<'a>,
1675     },
1676     BuildScriptExecuted {
1677         package_id: Cow<'a, str>,
1678     },
1679     BuildFinished {
1680         success: bool,
1681     },
1682 }