1use std::env;2use std::ffi::{OsStr, OsString};3use std::path::{Path, PathBuf};45use super::{Builder, Kind};6use crate::core::build_steps::test;7use crate::core::build_steps::tool::SourceType;8use crate::core::config::SplitDebuginfo;9use crate::core::config::flags::Color;10use crate::utils::build_stamp;11use crate::utils::helpers::{self, LldThreads, check_cfg_arg, linker_flags};12use crate::{13    BootstrapCommand, CLang, Compiler, Config, DryRun, EXTRA_CHECK_CFGS, GitRepo, Mode,14    RemapScheme, TargetSelection, command, prepare_behaviour_dump_dir, t,15};1617/// Represents flag values in `String` form with whitespace delimiter to pass it to the compiler18/// later.19///20/// `-Z crate-attr` flags will be applied recursively on the target code using the21/// `rustc_parse::parser::Parser`. See `rustc_builtin_macros::cmdline_attrs::inject` for more22/// information.23#[derive(Debug, Clone)]24struct Rustflags(String, TargetSelection);2526impl Rustflags {27    fn new(target: TargetSelection) -> Rustflags {28        Rustflags(String::new(), target)29    }3031    /// By default, cargo will pick up on various variables in the environment. However, bootstrap32    /// reuses those variables to pass additional flags to rustdoc, so by default they get33    /// overridden. Explicitly add back any previous value in the environment.34    ///35    /// `prefix` is usually `RUSTFLAGS` or `RUSTDOCFLAGS`.36    fn propagate_cargo_env(&mut self, prefix: &str) {37        // Inherit `RUSTFLAGS` by default ...38        self.env(prefix);3940        // ... and also handle target-specific env RUSTFLAGS if they're configured.41        let target_specific = format!("CARGO_TARGET_{}_{}", crate::envify(&self.1.triple), prefix);42        self.env(&target_specific);43    }4445    fn env(&mut self, env: &str) {46        if let Ok(s) = env::var(env) {47            for part in s.split(' ') {48                self.arg(part);49            }50        }51    }5253    fn arg(&mut self, arg: &str) -> &mut Self {54        assert_eq!(arg.split(' ').count(), 1);55        if !self.0.is_empty() {56            self.0.push(' ');57        }58        self.0.push_str(arg);59        self60    }6162    fn propagate_rustflag_envs(&mut self, build_compiler_stage: u32) {63        self.propagate_cargo_env("RUSTFLAGS");64        if build_compiler_stage != 0 {65            self.env("RUSTFLAGS_NOT_BOOTSTRAP");66        } else {67            self.env("RUSTFLAGS_BOOTSTRAP");68            self.arg("--cfg=bootstrap");69        }70    }71}7273/// Flags that are passed to the `rustc` shim binary. These flags will only be applied when74/// compiling host code, i.e. when `--target` is unset.75#[derive(Debug, Default)]76struct HostFlags {77    rustc: Vec<String>,78}7980impl HostFlags {81    const SEPARATOR: &'static str = " ";8283    /// Adds a host rustc flag.84    fn arg<S: Into<String>>(&mut self, flag: S) {85        let value = flag.into().trim().to_string();86        assert!(!value.contains(Self::SEPARATOR));87        self.rustc.push(value);88    }8990    /// Encodes all the flags into a single string.91    fn encode(self) -> String {92        self.rustc.join(Self::SEPARATOR)93    }94}9596#[derive(Debug)]97pub struct Cargo {98    command: BootstrapCommand,99    args: Vec<OsString>,100    compiler: Compiler,101    mode: Mode,102    target: TargetSelection,103    rustflags: Rustflags,104    rustdocflags: Rustflags,105    hostflags: HostFlags,106    allow_features: String,107    build_compiler_stage: u32,108    extra_rustflags: Vec<String>,109    profile: Option<&'static str>,110}111112impl Cargo {113    /// Calls [`Builder::cargo`] and [`Cargo::configure_linker`] to prepare an invocation of `cargo`114    /// to be run.115    #[track_caller]116    pub fn new(117        builder: &Builder<'_>,118        compiler: Compiler,119        mode: Mode,120        source_type: SourceType,121        target: TargetSelection,122        cmd_kind: Kind,123    ) -> Cargo {124        let mut cargo = builder.cargo(compiler, mode, source_type, target, cmd_kind);125        if target.synthetic {126            cargo.arg("-Zjson-target-spec");127        }128129        match cmd_kind {130            // No need to configure the target linker for these command types.131            Kind::Clean | Kind::Check | Kind::Format | Kind::Setup => {}132            _ => {133                cargo.configure_linker(builder);134            }135        }136137        cargo138    }139140    pub fn release_build(&mut self, release_build: bool) {141        self.profile = if release_build { Some("release") } else { None };142    }143144    pub fn profile(&mut self, profile: &'static str) {145        self.profile = Some(profile);146    }147148    pub fn compiler(&self) -> Compiler {149        self.compiler150    }151152    pub fn mode(&self) -> Mode {153        self.mode154    }155156    pub fn into_cmd(self) -> BootstrapCommand {157        self.into()158    }159160    /// Same as [`Cargo::new`] except this one doesn't configure the linker with161    /// [`Cargo::configure_linker`].162    #[track_caller]163    pub fn new_for_mir_opt_tests(164        builder: &Builder<'_>,165        compiler: Compiler,166        mode: Mode,167        source_type: SourceType,168        target: TargetSelection,169        cmd_kind: Kind,170    ) -> Cargo {171        let mut cargo = builder.cargo(compiler, mode, source_type, target, cmd_kind);172        if target.synthetic {173            cargo.arg("-Zjson-target-spec");174        }175        cargo176    }177178    pub fn rustdocflag(&mut self, arg: &str) -> &mut Cargo {179        self.rustdocflags.arg(arg);180        self181    }182183    pub fn rustflag(&mut self, arg: &str) -> &mut Cargo {184        self.rustflags.arg(arg);185        self186    }187188    pub fn arg(&mut self, arg: impl AsRef<OsStr>) -> &mut Cargo {189        self.args.push(arg.as_ref().into());190        self191    }192193    pub fn args<I, S>(&mut self, args: I) -> &mut Cargo194    where195        I: IntoIterator<Item = S>,196        S: AsRef<OsStr>,197    {198        for arg in args {199            self.arg(arg.as_ref());200        }201        self202    }203204    /// Add an env var to the cargo command instance. Note that `RUSTFLAGS`/`RUSTDOCFLAGS` must go205    /// through [`Cargo::rustdocflags`] and [`Cargo::rustflags`] because inconsistent `RUSTFLAGS`206    /// and `RUSTDOCFLAGS` usages will trigger spurious rebuilds.207    pub fn env(&mut self, key: impl AsRef<OsStr>, value: impl AsRef<OsStr>) -> &mut Cargo {208        assert_ne!(key.as_ref(), "RUSTFLAGS");209        assert_ne!(key.as_ref(), "RUSTDOCFLAGS");210        self.command.env(key.as_ref(), value.as_ref());211        self212    }213214    /// Append a value to an env var of the cargo command instance.215    /// If the variable was unset previously, this is equivalent to [`Cargo::env`].216    /// If the variable was already set, this will append `delimiter` and then `value` to it.217    ///218    /// Note that this only considers the existence of the env. var. configured on this `Cargo`219    /// instance. It does not look at the environment of this process.220    pub fn append_to_env(221        &mut self,222        key: impl AsRef<OsStr>,223        value: impl AsRef<OsStr>,224        delimiter: impl AsRef<OsStr>,225    ) -> &mut Cargo {226        assert_ne!(key.as_ref(), "RUSTFLAGS");227        assert_ne!(key.as_ref(), "RUSTDOCFLAGS");228229        let key = key.as_ref();230        if let Some((_, Some(previous_value))) = self.command.get_envs().find(|(k, _)| *k == key) {231            let mut combined: OsString = previous_value.to_os_string();232            combined.push(delimiter.as_ref());233            combined.push(value.as_ref());234            self.env(key, combined)235        } else {236            self.env(key, value)237        }238    }239240    pub fn add_rustc_lib_path(&mut self, builder: &Builder<'_>) {241        builder.add_rustc_lib_path(self.compiler, &mut self.command);242    }243244    pub fn current_dir(&mut self, dir: &Path) -> &mut Cargo {245        self.command.current_dir(dir);246        self247    }248249    /// Adds nightly-only features that this invocation is allowed to use.250    ///251    /// By default, all nightly features are allowed. Once this is called, it will be restricted to252    /// the given set.253    pub fn allow_features(&mut self, features: &str) -> &mut Cargo {254        if !self.allow_features.is_empty() {255            self.allow_features.push(',');256        }257        self.allow_features.push_str(features);258        self259    }260261    // FIXME(onur-ozkan): Add coverage to make sure modifications to this function262    // doesn't cause cache invalidations (e.g., #130108).263    fn configure_linker(&mut self, builder: &Builder<'_>) -> &mut Cargo {264        let target = self.target;265        let compiler = self.compiler;266267        // Dealing with rpath here is a little special, so let's go into some268        // detail. First off, `-rpath` is a linker option on Unix platforms269        // which adds to the runtime dynamic loader path when looking for270        // dynamic libraries. We use this by default on Unix platforms to ensure271        // that our nightlies behave the same on Windows, that is they work out272        // of the box. This can be disabled by setting `rpath = false` in `[rust]`273        // table of `bootstrap.toml`274        //275        // Ok, so the astute might be wondering "why isn't `-C rpath` used276        // here?" and that is indeed a good question to ask. This codegen277        // option is the compiler's current interface to generating an rpath.278        // Unfortunately it doesn't quite suffice for us. The flag currently279        // takes no value as an argument, so the compiler calculates what it280        // should pass to the linker as `-rpath`. This unfortunately is based on281        // the **compile time** directory structure which when building with282        // Cargo will be very different than the runtime directory structure.283        //284        // All that's a really long winded way of saying that if we use285        // `-Crpath` then the executables generated have the wrong rpath of286        // something like `$ORIGIN/deps` when in fact the way we distribute287        // rustc requires the rpath to be `$ORIGIN/../lib`.288        //289        // So, all in all, to set up the correct rpath we pass the linker290        // argument manually via `-C link-args=-Wl,-rpath,...`. Plus isn't it291        // fun to pass a flag to a tool to pass a flag to pass a flag to a tool292        // to change a flag in a binary?293        if builder.config.rpath_enabled(target) && helpers::use_host_linker(target) {294            let libdir = builder.sysroot_libdir_relative(compiler).to_str().unwrap();295            let rpath = if target.contains("apple") {296                // Note that we need to take one extra step on macOS to also pass297                // `-Wl,-instal_name,@rpath/...` to get things to work right. To298                // do that we pass a weird flag to the compiler to get it to do299                // so. Note that this is definitely a hack, and we should likely300                // flesh out rpath support more fully in the future.301                self.rustflags.arg("-Zosx-rpath-install-name");302                Some(format!("-Wl,-rpath,@loader_path/../{libdir}"))303            } else if !target.is_windows()304                && !target.contains("cygwin")305                && !target.contains("aix")306                && !target.contains("xous")307            {308                self.rustflags.arg("-Clink-args=-Wl,-z,origin");309                Some(format!("-Wl,-rpath,$ORIGIN/../{libdir}"))310            } else {311                None312            };313            if let Some(rpath) = rpath {314                self.rustflags.arg(&format!("-Clink-args={rpath}"));315            }316        }317318        // We need to set host linker flags for compiling build scripts and proc-macros.319        // This is done the same way as the target linker flags below, so cargo won't see320        // any fingerprint difference between host==target versus cross-compiled targets321        // when it comes to those host build artifacts.322        if let Some(host_linker) = builder.linker(compiler.host) {323            let host = crate::envify(&compiler.host.triple);324            self.command.env(format!("CARGO_TARGET_{host}_LINKER"), host_linker);325        }326        for arg in linker_flags(builder, compiler.host, LldThreads::Yes) {327            self.hostflags.arg(&arg);328        }329330        if let Some(target_linker) = builder.linker(target) {331            let target = crate::envify(&target.triple);332            self.command.env(format!("CARGO_TARGET_{target}_LINKER"), target_linker);333        }334        // We want to set -Clinker using Cargo, therefore we only call `linker_flags` and not335        // `linker_args` here. Cargo will pass that to both rustc and rustdoc invocations.336        for flag in linker_flags(builder, target, LldThreads::Yes) {337            self.rustflags.arg(&flag);338        }339        for arg in linker_flags(builder, target, LldThreads::Yes) {340            self.rustdocflags.arg(&arg);341        }342343        if !builder.config.dry_run() && builder.cc[&target].args().iter().any(|arg| arg == "-gz") {344            self.rustflags.arg("-Clink-arg=-gz");345        }346347        // Ignore linker warnings for now. These are complicated to fix and don't affect the build.348        // FIXME: we should really investigate these...349        self.rustflags.arg("-Alinker-messages");350351        // Throughout the build Cargo can execute a number of build scripts352        // compiling C/C++ code and we need to pass compilers, archivers, flags, etc353        // obtained previously to those build scripts.354        // Build scripts use either the `cc` crate or `configure/make` so we pass355        // the options through environment variables that are fetched and understood by both.356        //357        // FIXME: the guard against msvc shouldn't need to be here358        if target.is_msvc() {359            if let Some(ref cl) = builder.config.llvm_clang_cl {360                // FIXME: There is a bug in Clang 18 when building for ARM64:361                // https://github.com/llvm/llvm-project/pull/81849. This is362                // fixed in LLVM 19, but can't be backported.363                if !target.starts_with("aarch64") && !target.starts_with("arm64ec") {364                    self.command.env("CC", cl).env("CXX", cl);365                }366            }367        } else {368            let ccache = builder.config.ccache.as_ref();369            let ccacheify = |s: &Path| {370                let ccache = match ccache {371                    Some(ref s) => s,372                    None => return s.display().to_string(),373                };374                // FIXME: the cc-rs crate only recognizes the literal strings375                // `ccache` and `sccache` when doing caching compilations, so we376                // mirror that here. It should probably be fixed upstream to377                // accept a new env var or otherwise work with custom ccache378                // vars.379                match &ccache[..] {380                    "ccache" | "sccache" => format!("{} {}", ccache, s.display()),381                    _ => s.display().to_string(),382                }383            };384            let triple_underscored = target.triple.replace('-', "_");385            let cc = ccacheify(&builder.cc(target));386            self.command.env(format!("CC_{triple_underscored}"), &cc);387388            // Extend `CXXFLAGS_$TARGET` with our extra flags.389            let env = format!("CFLAGS_{triple_underscored}");390            let mut cflags =391                builder.cc_unhandled_cflags(target, GitRepo::Rustc, CLang::C).join(" ");392            if let Ok(var) = std::env::var(&env) {393                cflags.push(' ');394                cflags.push_str(&var);395            }396            self.command.env(env, &cflags);397398            if let Some(ar) = builder.ar(target) {399                let ranlib = format!("{} s", ar.display());400                self.command401                    .env(format!("AR_{triple_underscored}"), ar)402                    .env(format!("RANLIB_{triple_underscored}"), ranlib);403            }404405            if let Ok(cxx) = builder.cxx(target) {406                let cxx = ccacheify(&cxx);407                self.command.env(format!("CXX_{triple_underscored}"), &cxx);408409                // Extend `CXXFLAGS_$TARGET` with our extra flags.410                let env = format!("CXXFLAGS_{triple_underscored}");411                let mut cxxflags =412                    builder.cc_unhandled_cflags(target, GitRepo::Rustc, CLang::Cxx).join(" ");413                if let Ok(var) = std::env::var(&env) {414                    cxxflags.push(' ');415                    cxxflags.push_str(&var);416                }417                self.command.env(&env, cxxflags);418            }419        }420421        self422    }423}424425impl From<Cargo> for BootstrapCommand {426    fn from(mut cargo: Cargo) -> BootstrapCommand {427        if let Some(profile) = cargo.profile {428            cargo.args.insert(0, format!("--profile={profile}").into());429        }430431        for arg in &cargo.extra_rustflags {432            cargo.rustflags.arg(arg);433            cargo.rustdocflags.arg(arg);434        }435436        // Propagate the envs here at the very end to make sure they override any previously set flags.437        cargo.rustflags.propagate_rustflag_envs(cargo.build_compiler_stage);438        cargo.rustdocflags.propagate_rustflag_envs(cargo.build_compiler_stage);439440        cargo.rustdocflags.propagate_cargo_env("RUSTDOCFLAGS");441442        if cargo.build_compiler_stage == 0 {443            cargo.rustdocflags.env("RUSTDOCFLAGS_BOOTSTRAP");444            if let Ok(s) = env::var("CARGOFLAGS_BOOTSTRAP") {445                cargo.args(s.split_whitespace());446            }447        } else {448            cargo.rustdocflags.env("RUSTDOCFLAGS_NOT_BOOTSTRAP");449            if let Ok(s) = env::var("CARGOFLAGS_NOT_BOOTSTRAP") {450                cargo.args(s.split_whitespace());451            }452        }453454        if let Ok(s) = env::var("CARGOFLAGS") {455            cargo.args(s.split_whitespace());456        }457458        cargo.command.args(cargo.args);459460        let rustflags = &cargo.rustflags.0;461        if !rustflags.is_empty() {462            cargo.command.env("RUSTFLAGS", rustflags);463        }464465        let rustdocflags = &cargo.rustdocflags.0;466        if !rustdocflags.is_empty() {467            cargo.command.env("RUSTDOCFLAGS", rustdocflags);468        }469470        let encoded_hostflags = cargo.hostflags.encode();471        if !encoded_hostflags.is_empty() {472            cargo.command.env("RUSTC_HOST_FLAGS", encoded_hostflags);473        }474475        if !cargo.allow_features.is_empty() {476            cargo.command.env("RUSTC_ALLOW_FEATURES", cargo.allow_features);477        }478479        cargo.command480    }481}482483impl Builder<'_> {484    /// Like [`Builder::cargo`], but only passes flags that are valid for all commands.485    #[track_caller]486    pub fn bare_cargo(487        &self,488        compiler: Compiler,489        mode: Mode,490        target: TargetSelection,491        cmd_kind: Kind,492    ) -> BootstrapCommand {493        let mut cargo = match cmd_kind {494            Kind::Clippy => {495                let mut cargo = self.cargo_clippy_cmd(compiler);496                cargo.arg(cmd_kind.as_str());497                cargo498            }499            Kind::MiriSetup => {500                let mut cargo = self.cargo_miri_cmd(compiler);501                cargo.arg("miri").arg("setup");502                cargo503            }504            Kind::MiriTest => {505                let mut cargo = self.cargo_miri_cmd(compiler);506                cargo.arg("miri").arg("test");507                cargo508            }509            _ => {510                let mut cargo = command(&self.initial_cargo);511                cargo.arg(cmd_kind.as_str());512                cargo513            }514        };515516        // Optionally suppress cargo output.517        if self.config.quiet {518            cargo.arg("--quiet");519        }520521        // Run cargo from the source root so it can find .cargo/config.522        // This matters when using vendoring and the working directory is outside the repository.523        cargo.current_dir(&self.src);524525        let out_dir = self.stage_out(compiler, mode);526        cargo.env("CARGO_TARGET_DIR", &out_dir);527528        // Set this unconditionally. Cargo silently ignores `CARGO_BUILD_WARNINGS` when `-Z529        // warnings` isn't present, which is hard to debug, and it's not worth the effort to keep530        // them in sync.531        cargo.arg("-Zwarnings");532533        // Bootstrap makes a lot of assumptions about the artifacts produced in the target534        // directory. If users override the "build directory" using `build-dir`535        // (https://doc.rust-lang.org/nightly/cargo/reference/unstable.html#build-dir), then536        // bootstrap couldn't find these artifacts. So we forcefully override that option to our537        // target directory here.538        // In the future, we could attempt to read the build-dir location from Cargo and actually539        // respect it.540        cargo.env("CARGO_BUILD_BUILD_DIR", &out_dir);541542        // Found with `rg "init_env_logger\("`. If anyone uses `init_env_logger`543        // from out of tree it shouldn't matter, since x.py is only used for544        // building in-tree.545        let color_logs = ["RUSTDOC_LOG_COLOR", "RUSTC_LOG_COLOR", "RUST_LOG_COLOR"];546        match self.build.config.color {547            Color::Always => {548                cargo.arg("--color=always");549                for log in &color_logs {550                    cargo.env(log, "always");551                }552            }553            Color::Never => {554                cargo.arg("--color=never");555                for log in &color_logs {556                    cargo.env(log, "never");557                }558            }559            Color::Auto => {} // nothing to do560        }561562        if cmd_kind != Kind::Install {563            cargo.arg("--target").arg(target.rustc_target_arg());564        } else {565            assert_eq!(target, compiler.host);566        }567568        // Bootstrap only supports modern FIFO jobservers. Older pipe-based jobservers can run into569        // "invalid file descriptor" errors, as the jobserver file descriptors are not inherited by570        // scripts like bootstrap.py, while the environment variable is propagated. So, we pass571        // MAKEFLAGS only if we detect a FIFO jobserver, otherwise we clear it.572        let has_modern_jobserver = env::var("MAKEFLAGS")573            .map(|flags| flags.contains("--jobserver-auth=fifo:"))574            .unwrap_or(false);575576        if !has_modern_jobserver {577            cargo.env_remove("MAKEFLAGS");578            cargo.env_remove("MFLAGS");579        }580581        cargo582    }583584    /// This will create a [`BootstrapCommand`] that represents a pending execution of cargo. This585    /// cargo will be configured to use `compiler` as the actual rustc compiler, its output will be586    /// scoped by `mode`'s output directory, it will pass the `--target` flag for the specified587    /// `target`, and will be executing the Cargo command `cmd`. `cmd` can be `miri-cmd` for588    /// commands to be run with Miri.589    #[track_caller]590    fn cargo(591        &self,592        compiler: Compiler,593        mode: Mode,594        source_type: SourceType,595        target: TargetSelection,596        cmd_kind: Kind,597    ) -> Cargo {598        let mut cargo = self.bare_cargo(compiler, mode, target, cmd_kind);599        let out_dir = self.stage_out(compiler, mode);600601        let mut hostflags = HostFlags::default();602603        // Codegen backends are not yet tracked by -Zbinary-dep-depinfo,604        // so we need to explicitly clear out if they've been updated.605        for backend in self.codegen_backends(compiler) {606            build_stamp::clear_if_dirty(self, &out_dir, &backend);607        }608609        if self.config.cmd.timings() {610            cargo.arg("--timings");611        }612613        if cmd_kind == Kind::Doc {614            let my_out = match mode {615                // This is the intended out directory for compiler documentation.616                Mode::Rustc | Mode::ToolRustcPrivate | Mode::ToolBootstrap | Mode::ToolTarget => {617                    self.compiler_doc_out(target)618                }619                Mode::Std => {620                    if self.config.cmd.json() {621                        out_dir.join(target).join("json-doc")622                    } else {623                        out_dir.join(target).join("doc")624                    }625                }626                _ => panic!("doc mode {mode:?} not expected"),627            };628            let rustdoc = self.rustdoc_for_compiler(compiler);629            build_stamp::clear_if_dirty(self, &my_out, &rustdoc);630        }631632        let profile_var = |name: &str| cargo_profile_var(name, &self.config, mode);633634        // See comment in rustc_llvm/build.rs for why this is necessary, largely llvm-config635        // needs to not accidentally link to libLLVM in stage0/lib.636        cargo.env("REAL_LIBRARY_PATH_VAR", helpers::dylib_path_var());637        if let Some(e) = env::var_os(helpers::dylib_path_var()) {638            cargo.env("REAL_LIBRARY_PATH", e);639        }640641        // Set a flag for `check`/`clippy`/`fix`, so that certain build642        // scripts can do less work (i.e. not building/requiring LLVM).643        if matches!(cmd_kind, Kind::Check | Kind::Clippy | Kind::Fix) {644            // If we've not yet built LLVM, or it's stale, then bust645            // the rustc_llvm cache. That will always work, even though it646            // may mean that on the next non-check build we'll need to rebuild647            // rustc_llvm. But if LLVM is stale, that'll be a tiny amount648            // of work comparatively, and we'd likely need to rebuild it anyway,649            // so that's okay.650            if crate::core::build_steps::llvm::prebuilt_llvm_config(self, target, false)651                .should_build()652            {653                cargo.env("RUST_CHECK", "1");654            }655        }656657        let build_compiler_stage = if compiler.stage == 0 && self.local_rebuild {658            // Assume the local-rebuild rustc already has stage1 features.659            1660        } else {661            compiler.stage662        };663664        // We synthetically interpret a stage0 compiler used to build tools as a665        // "raw" compiler in that it's the exact snapshot we download. For things like666        // ToolRustcPrivate, we would have to use the artificial stage0-sysroot compiler instead.667        let use_snapshot =668            mode == Mode::ToolBootstrap || (mode == Mode::ToolTarget && build_compiler_stage == 0);669        assert!(!use_snapshot || build_compiler_stage == 0 || self.local_rebuild);670671        let sysroot = if use_snapshot {672            self.rustc_snapshot_sysroot().to_path_buf()673        } else {674            self.sysroot(compiler)675        };676        let libdir = self.rustc_libdir(compiler);677678        let sysroot_str = sysroot.as_os_str().to_str().expect("sysroot should be UTF-8");679        if self.is_verbose() && !matches!(self.config.get_dry_run(), DryRun::SelfCheck) {680            println!("using sysroot {sysroot_str}");681        }682683        let mut rustflags = Rustflags::new(target);684685        if cmd_kind == Kind::Clippy {686            // clippy overwrites sysroot if we pass it to cargo.687            // Pass it directly to clippy instead.688            // NOTE: this can't be fixed in clippy because we explicitly don't set `RUSTC`,689            // so it has no way of knowing the sysroot.690            rustflags.arg("--sysroot");691            rustflags.arg(sysroot_str);692        }693694        // By default, windows-rs depends on a native library that doesn't get copied into the695        // sysroot. Passing this cfg enables raw-dylib support instead, which makes the native696        // library unnecessary. This can be removed when windows-rs enables raw-dylib697        // unconditionally.698        if let Mode::Rustc | Mode::ToolRustcPrivate | Mode::ToolBootstrap | Mode::ToolTarget = mode699        {700            rustflags.arg("--cfg=windows_raw_dylib");701        }702703        // When unset, follow the default of the compiler flag - the compiler, tools and std use v0704        if let Some(usm) = self.config.rust_new_symbol_mangling {705            rustflags.arg(if usm {706                "-Csymbol-mangling-version=v0"707            } else {708                "-Csymbol-mangling-version=legacy"709            });710        }711712        // Always enable move/copy annotations for profiler visibility (non-stage0 only).713        // Note that -Zannotate-moves is only effective with debugging info enabled.714        if build_compiler_stage >= 1 {715            if let Some(limit) = self.config.rust_annotate_moves_size_limit {716                rustflags.arg(&format!("-Zannotate-moves={limit}"));717            } else {718                rustflags.arg("-Zannotate-moves");719            }720        }721722        // FIXME: the following components don't build with `-Zrandomize-layout` yet:723        // - rust-analyzer, due to the rowan crate724        // so we exclude an entire category of steps here due to lack of fine-grained control over725        // rustflags.726        if self.config.rust_randomize_layout && mode != Mode::ToolRustcPrivate {727            rustflags.arg("-Zrandomize-layout");728        }729730        // Enable compile-time checking of `cfg` names, values and Cargo `features`.731        //732        // Note: `std`, `alloc` and `core` imports some dependencies by #[path] (like733        // backtrace, core_simd, std_float, ...), those dependencies have their own734        // features but cargo isn't involved in the #[path] process and so cannot pass the735        // complete list of features, so for that reason we don't enable checking of736        // features for std crates.737        if mode == Mode::Std {738            rustflags.arg("--check-cfg=cfg(feature,values(any()))");739        }740741        // Add extra cfg not defined in/by rustc742        //743        // Note: Although it would seems that "-Zunstable-options" to `rustflags` is useless as744        // cargo would implicitly add it, it was discover that sometimes bootstrap only use745        // `rustflags` without `cargo` making it required.746        rustflags.arg("-Zunstable-options");747748        // Add parallel frontend threads configuration749        if let Some(threads) = self.config.rust_parallel_frontend_threads {750            rustflags.arg(&format!("-Zthreads={threads}"));751        }752753        for (restricted_mode, name, values) in EXTRA_CHECK_CFGS {754            if restricted_mode.is_none() || *restricted_mode == Some(mode) {755                rustflags.arg(&check_cfg_arg(name, *values));756757                if *name == "bootstrap" {758                    // Cargo doesn't pass RUSTFLAGS to proc_macros:759                    // https://github.com/rust-lang/cargo/issues/4423760                    // Thus, if we are on stage 0, we explicitly set `--cfg=bootstrap`.761                    // We also declare that the flag is expected, which we need to do to not762                    // get warnings about it being unexpected.763                    hostflags.arg(check_cfg_arg(name, *values));764                }765            }766        }767768        // FIXME(rust-lang/cargo#5754) we shouldn't be using special command arguments769        // to the host invocation here, but rather Cargo should know what flags to pass rustc770        // itself.771        if build_compiler_stage == 0 {772            hostflags.arg("--cfg=bootstrap");773        }774775        // FIXME: It might be better to use the same value for both `RUSTFLAGS` and `RUSTDOCFLAGS`,776        // but this breaks CI. At the very least, stage0 `rustdoc` needs `--cfg bootstrap`. See777        // #71458.778        let mut rustdocflags = rustflags.clone();779780        match mode {781            Mode::Std | Mode::ToolBootstrap | Mode::ToolStd | Mode::ToolTarget => {}782            Mode::Rustc | Mode::Codegen | Mode::ToolRustcPrivate => {783                // Build proc macros both for the host and the target unless proc-macros are not784                // supported by the target.785                if target != compiler.host && cmd_kind != Kind::Check {786                    let error = self787                        .rustc_cmd(compiler)788                        .arg("--target")789                        .arg(target.rustc_target_arg())790                        // FIXME(#152709): -Zunstable-options is to handle JSON targets.791                        // Remove when JSON targets are stabilized.792                        .arg("-Zunstable-options")793                        .env("RUSTC_BOOTSTRAP", "1")794                        .arg("--print=file-names")795                        .arg("--crate-type=proc-macro")796                        .arg("-")797                        .stdin(std::process::Stdio::null())798                        .run_capture(self)799                        .stderr();800801                    let not_supported = error802                        .lines()803                        .any(|line| line.contains("unsupported crate type `proc-macro`"));804                    if !not_supported {805                        cargo.arg("-Zdual-proc-macros");806                        rustflags.arg("-Zdual-proc-macros");807                    }808                }809            }810        }811812        // This tells Cargo (and in turn, rustc) to output more complete813        // dependency information.  Most importantly for bootstrap, this814        // includes sysroot artifacts, like libstd, which means that we don't815        // need to track those in bootstrap (an error prone process!). This816        // feature is currently unstable as there may be some bugs and such, but817        // it represents a big improvement in bootstrap's reliability on818        // rebuilds, so we're using it here.819        //820        // For some additional context, see #63470 (the PR originally adding821        // this), as well as #63012 which is the tracking issue for this822        // feature on the rustc side.823        cargo.arg("-Zbinary-dep-depinfo");824        let allow_features = match mode {825            Mode::ToolBootstrap | Mode::ToolStd | Mode::ToolTarget => {826                // Restrict the allowed features so we don't depend on nightly827                // accidentally.828                //829                // binary-dep-depinfo is used by bootstrap itself for all830                // compilations.831                //832                // Lots of tools depend on proc_macro2 and proc-macro-error.833                // Those have build scripts which assume nightly features are834                // available if the `rustc` version is "nighty" or "dev". See835                // bin/rustc.rs for why that is a problem. Instead of labeling836                // those features for each individual tool that needs them,837                // just blanket allow them here.838                //839                // If this is ever removed, be sure to add something else in840                // its place to keep the restrictions in place (or make a way841                // to unset RUSTC_BOOTSTRAP).842                "binary-dep-depinfo,proc_macro_span,proc_macro_span_shrink,proc_macro_diagnostic"843                    .to_string()844            }845            Mode::Std | Mode::Rustc | Mode::Codegen | Mode::ToolRustcPrivate => String::new(),846        };847848        cargo.arg("-j").arg(self.jobs().to_string());849850        // Make cargo emit diagnostics relative to the rustc src dir.851        cargo.arg(format!("-Zroot-dir={}", self.src.display()));852853        if self.config.compile_time_deps {854            // Build only build scripts and proc-macros for rust-analyzer when requested.855            cargo.arg("-Zunstable-options");856            cargo.arg("--compile-time-deps");857        }858859        // FIXME: Temporary fix for https://github.com/rust-lang/cargo/issues/3005860        // Force cargo to output binaries with disambiguating hashes in the name861        let mut metadata = if compiler.stage == 0 {862            // Treat stage0 like a special channel, whether it's a normal prior-863            // release rustc or a local rebuild with the same version, so we864            // never mix these libraries by accident.865            "bootstrap".to_string()866        } else {867            self.config.channel.to_string()868        };869        // We want to make sure that none of the dependencies between870        // std/test/rustc unify with one another. This is done for weird linkage871        // reasons but the gist of the problem is that if librustc, libtest, and872        // libstd all depend on libc from crates.io (which they actually do) we873        // want to make sure they all get distinct versions. Things get really874        // weird if we try to unify all these dependencies right now, namely875        // around how many times the library is linked in dynamic libraries and876        // such. If rustc were a static executable or if we didn't ship dylibs877        // this wouldn't be a problem, but we do, so it is. This is in general878        // just here to make sure things build right. If you can remove this and879        // things still build right, please do!880        match mode {881            Mode::Std => metadata.push_str("std"),882            // When we're building rustc tools, they're built with a search path883            // that contains things built during the rustc build. For example,884            // bitflags is built during the rustc build, and is a dependency of885            // rustdoc as well. We're building rustdoc in a different target886            // directory, though, which means that Cargo will rebuild the887            // dependency. When we go on to build rustdoc, we'll look for888            // bitflags, and find two different copies: one built during the889            // rustc step and one that we just built. This isn't always a890            // problem, somehow -- not really clear why -- but we know that this891            // fixes things.892            Mode::ToolRustcPrivate => metadata.push_str("tool-rustc"),893            // Same for codegen backends.894            Mode::Codegen => metadata.push_str("codegen"),895            _ => {}896        }897        // `rustc_driver`'s version number is always `0.0.0`, which can cause linker search path898        // problems on side-by-side installs because we don't include the version number of the899        // `rustc_driver` being built. This can cause builds of different version numbers to produce900        // `librustc_driver*.so` artifacts that end up with identical filename hashes.901        metadata.push_str(&self.version);902903        cargo.env("__CARGO_DEFAULT_LIB_METADATA", &metadata);904905        if cmd_kind == Kind::Clippy {906            rustflags.arg("-Zforce-unstable-if-unmarked");907        }908909        rustflags.arg("-Zmacro-backtrace");910911        // Clear the output directory if the real rustc we're using has changed;912        // Cargo cannot detect this as it thinks rustc is bootstrap/debug/rustc.913        //914        // Avoid doing this during dry run as that usually means the relevant915        // compiler is not yet linked/copied properly.916        //917        // Only clear out the directory if we're compiling std; otherwise, we918        // should let Cargo take care of things for us (via depdep info)919        if !self.config.dry_run() && mode == Mode::Std && cmd_kind == Kind::Build {920            build_stamp::clear_if_dirty(self, &out_dir, &self.rustc(compiler));921        }922923        let rustdoc_path = match cmd_kind {924            Kind::Doc | Kind::Test | Kind::MiriTest => self.rustdoc_for_compiler(compiler),925            _ => PathBuf::from("/path/to/nowhere/rustdoc/not/required"),926        };927928        // Customize the compiler we're running. Specify the compiler to cargo929        // as our shim and then pass it some various options used to configure930        // how the actual compiler itself is called.931        //932        // These variables are primarily all read by933        // src/bootstrap/bin/{rustc.rs,rustdoc.rs}934        cargo935            .env("RUSTBUILD_NATIVE_DIR", self.native_dir(target))936            .env("RUSTC_REAL", self.rustc(compiler))937            .env("RUSTC_STAGE", build_compiler_stage.to_string())938            .env("RUSTC_SYSROOT", sysroot)939            .env("RUSTC_LIBDIR", &libdir)940            .env("RUSTDOC_LIBDIR", libdir)941            .env("RUSTDOC", self.bootstrap_out.join("rustdoc"))942            .env("RUSTDOC_REAL", rustdoc_path)943            .env("RUSTC_ERROR_METADATA_DST", self.extended_error_dir());944945        if self.config.rust_break_on_ice {946            cargo.env("RUSTC_BREAK_ON_ICE", "1");947        }948949        // Set RUSTC_WRAPPER to the bootstrap shim, which switches between beta and in-tree950        // sysroot depending on whether we're building build scripts.951        // NOTE: we intentionally use RUSTC_WRAPPER so that we can support clippy - RUSTC is not952        // respected by clippy-driver; RUSTC_WRAPPER happens earlier, before clippy runs.953        cargo.env("RUSTC_WRAPPER", self.bootstrap_out.join("rustc"));954        // NOTE: we also need to set RUSTC so cargo can run `rustc -vV`; apparently that ignores RUSTC_WRAPPER >:(955        cargo.env("RUSTC", self.bootstrap_out.join("rustc"));956957        // Someone might have set some previous rustc wrapper (e.g.958        // sccache) before bootstrap overrode it. Respect that variable.959        if let Some(existing_wrapper) = env::var_os("RUSTC_WRAPPER") {960            cargo.env("RUSTC_WRAPPER_REAL", existing_wrapper);961        }962963        // If this is for `miri-test`, prepare the sysroots.964        if cmd_kind == Kind::MiriTest {965            self.std(compiler, compiler.host);966            let host_sysroot = self.sysroot(compiler);967            let miri_sysroot = test::Miri::build_miri_sysroot(self, compiler, target);968            cargo.env("MIRI_SYSROOT", &miri_sysroot);969            cargo.env("MIRI_HOST_SYSROOT", &host_sysroot);970        }971972        cargo.env(profile_var("STRIP"), self.config.rust_strip.to_string());973974        if let Some(stack_protector) = &self.config.rust_stack_protector {975            rustflags.arg(&format!("-Zstack-protector={stack_protector}"));976        }977978        let debuginfo_level = match mode {979            Mode::Rustc | Mode::Codegen => self.config.rust_debuginfo_level_rustc,980            Mode::Std => self.config.rust_debuginfo_level_std,981            Mode::ToolBootstrap | Mode::ToolStd | Mode::ToolRustcPrivate | Mode::ToolTarget => {982                self.config.rust_debuginfo_level_tools983            }984        };985        cargo.env(profile_var("DEBUG"), debuginfo_level.to_string());986        if let Some(opt_level) = &self.config.rust_optimize.get_opt_level() {987            cargo.env(profile_var("OPT_LEVEL"), opt_level);988        }989        cargo.env(990            profile_var("DEBUG_ASSERTIONS"),991            match mode {992                Mode::Std => self.config.std_debug_assertions,993                Mode::Rustc | Mode::Codegen => self.config.rustc_debug_assertions,994                Mode::ToolBootstrap | Mode::ToolStd | Mode::ToolRustcPrivate | Mode::ToolTarget => {995                    self.config.tools_debug_assertions996                }997            }998            .to_string(),999        );1000        cargo.env(1001            profile_var("OVERFLOW_CHECKS"),1002            if mode == Mode::Std {1003                self.config.rust_overflow_checks_std.to_string()1004            } else {1005                self.config.rust_overflow_checks.to_string()1006            },1007        );10081009        match self.config.split_debuginfo(target) {1010            SplitDebuginfo::Packed => rustflags.arg("-Csplit-debuginfo=packed"),1011            SplitDebuginfo::Unpacked => rustflags.arg("-Csplit-debuginfo=unpacked"),1012            SplitDebuginfo::Off => rustflags.arg("-Csplit-debuginfo=off"),1013        };10141015        if self.config.cmd.bless() {1016            // Bless `expect!` tests.1017            cargo.env("UPDATE_EXPECT", "1");1018        }10191020        // Set an environment variable that tells the rustc/rustdoc wrapper1021        // binary to pass `-Zforce-unstable-if-unmarked` to the real compiler.1022        match mode {1023            // Any library crate that's part of the sysroot should be marked unstable1024            // (including third-party dependencies), unless it uses a staged_api1025            // `#![stable(..)]` attribute to explicitly mark itself stable.1026            Mode::Std | Mode::Codegen | Mode::Rustc => {1027                cargo.env("RUSTC_FORCE_UNSTABLE", "1");1028            }10291030            // For everything else, crate stability shouldn't matter, so don't set a flag.1031            Mode::ToolBootstrap | Mode::ToolRustcPrivate | Mode::ToolStd | Mode::ToolTarget => {}1032        }10331034        if let Some(x) = self.crt_static(target) {1035            if x {1036                rustflags.arg("-Ctarget-feature=+crt-static");1037            } else {1038                rustflags.arg("-Ctarget-feature=-crt-static");1039            }1040        }10411042        if let Some(x) = self.crt_static(compiler.host) {1043            let sign = if x { "+" } else { "-" };1044            hostflags.arg(format!("-Ctarget-feature={sign}crt-static"));1045        }10461047        // `rustc` needs to know the remapping scheme, in order to know how to reverse it (unremap)1048        // later. Two env vars are set and made available to the compiler1049        //1050        // - `CFG_VIRTUAL_RUST_SOURCE_BASE_DIR`: `rust-src` remap scheme (`NonCompiler`)1051        // - `CFG_VIRTUAL_RUSTC_DEV_SOURCE_BASE_DIR`: `rustc-dev` remap scheme (`Compiler`)1052        //1053        // Keep this scheme in sync with `rustc_metadata::rmeta::decoder`'s1054        // `try_to_translate_virtual_to_real`.1055        //1056        // `RUSTC_DEBUGINFO_MAP` is used to pass through to the underlying rustc1057        // `--remap-path-prefix`.1058        match mode {1059            Mode::Rustc | Mode::Codegen => {1060                if let Some(ref map_to) =1061                    self.build.debuginfo_map_to(GitRepo::Rustc, RemapScheme::NonCompiler)1062                {1063                    // Tell the compiler which prefix was used for remapping the standard library1064                    cargo.env("CFG_VIRTUAL_RUST_SOURCE_BASE_DIR", map_to);1065                }10661067                if let Some(ref map_to) =1068                    self.build.debuginfo_map_to(GitRepo::Rustc, RemapScheme::Compiler)1069                {1070                    // Tell the compiler which prefix was used for remapping the compiler it-self1071                    cargo.env("CFG_VIRTUAL_RUSTC_DEV_SOURCE_BASE_DIR", map_to);10721073                    // When building compiler sources, we want to apply the compiler remap scheme.1074                    let map = [1075                        // Cargo use relative paths for workspace members, so let's remap those.1076                        format!("compiler/={map_to}/compiler"),1077                        // rustc creates absolute paths (in part bc of the `rust-src` unremap1078                        // and for working directory) so let's remap the build directory as well.1079                        format!("{}={map_to}", self.build.src.display()),1080                        // remap OUT_DIR so they don't leak into artifacts.1081                        format!("{}={map_to}/out", self.build.out.display()),1082                    ]1083                    .join("\t");1084                    cargo.env("RUSTC_DEBUGINFO_MAP", map);1085                }1086            }1087            Mode::Std1088            | Mode::ToolBootstrap1089            | Mode::ToolRustcPrivate1090            | Mode::ToolStd1091            | Mode::ToolTarget => {1092                if let Some(ref map_to) =1093                    self.build.debuginfo_map_to(GitRepo::Rustc, RemapScheme::NonCompiler)1094                {1095                    // When building the standard library sources, we want to apply the std remap scheme.1096                    let map = [1097                        // Cargo use relative paths for workspace members, so let's remap those.1098                        format!("library/={map_to}/library"),1099                        // rustc creates absolute paths (in part bc of the `rust-src` unremap1100                        // and for working directory) so let's remap the build directory as well.1101                        format!("{}={map_to}", self.build.src.display()),1102                        // remap OUT_DIR so they don't leak into artifacts.1103                        format!("{}={map_to}/out", self.build.out.display()),1104                    ]1105                    .join("\t");1106                    cargo.env("RUSTC_DEBUGINFO_MAP", map);1107                }1108            }1109        }11101111        if self.config.rust_remap_debuginfo {1112            let mut env_var = OsString::new();1113            if let Some(vendor) = self.build.vendored_crates_path() {1114                env_var.push(vendor);1115                env_var.push("=/rust/deps");1116            } else {1117                let registry_src = t!(home::cargo_home()).join("registry").join("src");1118                for entry in t!(std::fs::read_dir(registry_src)) {1119                    if !env_var.is_empty() {1120                        env_var.push("\t");1121                    }1122                    env_var.push(t!(entry).path());1123                    env_var.push("=/rust/deps");1124                }1125            }1126            cargo.env("RUSTC_CARGO_REGISTRY_SRC_TO_REMAP", env_var);1127        }11281129        // Enable usage of unstable features1130        cargo.env("RUSTC_BOOTSTRAP", "1");11311132        if matches!(mode, Mode::Std) {1133            cargo.arg("-Zno-embed-metadata");1134        }11351136        if self.config.dump_bootstrap_shims {1137            prepare_behaviour_dump_dir(self.build);11381139            cargo1140                .env("DUMP_BOOTSTRAP_SHIMS", self.build.out.join("bootstrap-shims-dump"))1141                .env("BUILD_OUT", &self.build.out)1142                .env("CARGO_HOME", t!(home::cargo_home()));1143        };11441145        self.add_rust_test_threads(&mut cargo);11461147        // Almost all of the crates that we compile as part of the bootstrap may1148        // have a build script, including the standard library. To compile a1149        // build script, however, it itself needs a standard library! This1150        // introduces a bit of a pickle when we're compiling the standard1151        // library itself.1152        //1153        // To work around this we actually end up using the snapshot compiler1154        // (stage0) for compiling build scripts of the standard library itself.1155        // The stage0 compiler is guaranteed to have a libstd available for use.1156        //1157        // For other crates, however, we know that we've already got a standard1158        // library up and running, so we can use the normal compiler to compile1159        // build scripts in that situation.1160        if mode == Mode::Std {1161            cargo1162                .env("RUSTC_SNAPSHOT", &self.initial_rustc)1163                .env("RUSTC_SNAPSHOT_LIBDIR", self.rustc_snapshot_libdir());1164        } else {1165            cargo1166                .env("RUSTC_SNAPSHOT", self.rustc(compiler))1167                .env("RUSTC_SNAPSHOT_LIBDIR", self.rustc_libdir(compiler));1168        }11691170        // Tools that use compiler libraries may inherit the `-lLLVM` link1171        // requirement, but the `-L` library path is not propagated across1172        // separate Cargo projects. We can add LLVM's library path to the1173        // rustc args as a workaround.1174        if (mode == Mode::ToolRustcPrivate || mode == Mode::Codegen)1175            && let Some(llvm_config) = self.llvm_config(target)1176        {1177            let llvm_libdir =1178                command(llvm_config).cached().arg("--libdir").run_capture_stdout(self).stdout();1179            if target.is_msvc() {1180                rustflags.arg(&format!("-Clink-arg=-LIBPATH:{llvm_libdir}"));1181            } else {1182                rustflags.arg(&format!("-Clink-arg=-L{llvm_libdir}"));1183            }1184        }11851186        // Compile everything except libraries and proc macros with the more1187        // efficient initial-exec TLS model. This doesn't work with `dlopen`,1188        // so we can't use it by default in general, but we can use it for tools1189        // and our own internal libraries.1190        //1191        // Cygwin only supports emutls.1192        if !mode.must_support_dlopen()1193            && !target.triple.starts_with("powerpc-")1194            && !target.triple.contains("cygwin")1195        {1196            cargo.env("RUSTC_TLS_MODEL_INITIAL_EXEC", "1");1197        }11981199        // Ignore incremental modes except for stage0, since we're1200        // not guaranteeing correctness across builds if the compiler1201        // is changing under your feet.1202        if self.config.incremental && compiler.stage == 0 {1203            cargo.env("CARGO_INCREMENTAL", "1");1204        } else {1205            // Don't rely on any default setting for incr. comp. in Cargo1206            cargo.env("CARGO_INCREMENTAL", "0");1207        }12081209        if let Some(ref on_fail) = self.config.on_fail {1210            cargo.env("RUSTC_ON_FAIL", on_fail);1211        }12121213        if self.config.print_step_timings {1214            cargo.env("RUSTC_PRINT_STEP_TIMINGS", "1");1215        }12161217        if self.config.print_step_rusage {1218            cargo.env("RUSTC_PRINT_STEP_RUSAGE", "1");1219        }12201221        if self.config.backtrace_on_ice {1222            cargo.env("RUSTC_BACKTRACE_ON_ICE", "1");1223        }12241225        if self.verbosity >= 2 {1226            // This provides very useful logs especially when debugging build cache-related stuff.1227            cargo.env("CARGO_LOG", "cargo::core::compiler::fingerprint=info");1228        }12291230        cargo.env("RUSTC_VERBOSE", self.verbosity.to_string());12311232        // Downstream forks of the Rust compiler might want to use a custom libc to add support for1233        // targets that are not yet available upstream. Adding a patch to replace libc with a1234        // custom one would cause compilation errors though, because Cargo would interpret the1235        // custom libc as part of the workspace, and apply the check-cfg lints on it.1236        //1237        // The libc build script emits check-cfg flags only when this environment variable is set,1238        // so this line allows the use of custom libcs.1239        cargo.env("LIBC_CHECK_CFG", "1");12401241        let mut lint_flags = Vec::new();12421243        // Lints for all in-tree code: compiler, rustdoc, cranelift, gcc,1244        // clippy, rustfmt, rust-analyzer, etc.1245        if source_type == SourceType::InTree {1246            // When extending this list, add the new lints to the RUSTFLAGS of the1247            // build_bootstrap function of src/bootstrap/bootstrap.py as well as1248            // some code doesn't go through this `rustc` wrapper.1249            lint_flags.push("-Wrust_2018_idioms");1250            lint_flags.push("-Wunused_lifetimes");12511252            if self.config.deny_warnings {1253                // We use this instead of `lint_flags` so that we don't have to rebuild all1254                // workspace dependencies when `deny-warnings` changes, but we still get an error1255                // immediately instead of having to wait until the next rebuild.1256                cargo.env("CARGO_BUILD_WARNINGS", "deny");1257            }12581259            rustdocflags.arg("-Wrustdoc::invalid_codeblock_attributes");1260        }12611262        // Lints just for `compiler/` crates.1263        if mode == Mode::Rustc {1264            lint_flags.push("-Wrustc::internal");1265            lint_flags.push("-Drustc::symbol_intern_string_literal");1266            // FIXME(edition_2024): Change this to `-Wrust_2024_idioms` when all1267            // of the individual lints are satisfied.1268            lint_flags.push("-Wkeyword_idents_2024");1269            lint_flags.push("-Wunreachable_pub");1270            lint_flags.push("-Wunsafe_op_in_unsafe_fn");1271            lint_flags.push("-Wunused_crate_dependencies");1272        }12731274        // This does not use RUSTFLAGS for two reasons.1275        // - Due to caching issues with Cargo. Clippy is treated as an "in1276        //   tree" tool, but shares the same cache as other "submodule" tools.1277        //   With these options set in RUSTFLAGS, that causes *every* shared1278        //   dependency to be rebuilt. By injecting this into the rustc1279        //   wrapper, this circumvents Cargo's fingerprint detection. This is1280        //   fine because lint flags are always ignored in dependencies.1281        //   Eventually this should be fixed via better support from Cargo.1282        // - RUSTFLAGS is ignored for proc macro crates that are being built on1283        //   the host (because `--target` is given). But we want the lint flags1284        //   to be applied to proc macro crates.1285        cargo.env("RUSTC_LINT_FLAGS", lint_flags.join(" "));12861287        if self.config.rust_frame_pointers {1288            rustflags.arg("-Cforce-frame-pointers=true");1289        }12901291        // If Control Flow Guard is enabled, pass the `control-flow-guard` flag to rustc1292        // when compiling the standard library, since this might be linked into the final outputs1293        // produced by rustc. Since this mitigation is only available on Windows, only enable it1294        // for the standard library in case the compiler is run on a non-Windows platform.1295        if cfg!(windows) && mode == Mode::Std && self.config.control_flow_guard {1296            rustflags.arg("-Ccontrol-flow-guard");1297        }12981299        // If EHCont Guard is enabled, pass the `-Zehcont-guard` flag to rustc when compiling the1300        // standard library, since this might be linked into the final outputs produced by rustc.1301        // Since this mitigation is only available on Windows, only enable it for the standard1302        // library in case the compiler is run on a non-Windows platform.1303        if cfg!(windows) && mode == Mode::Std && self.config.ehcont_guard {1304            rustflags.arg("-Zehcont-guard");1305        }13061307        // Optionally override the rc.exe when compiling rustc on Windows.1308        if let Some(windows_rc) = &self.config.windows_rc {1309            cargo.env("RUSTC_WINDOWS_RC", windows_rc);1310        }13111312        // For `cargo doc` invocations, make rustdoc print the Rust version into the docs1313        // This replaces spaces with tabs because RUSTDOCFLAGS does not1314        // support arguments with regular spaces. Hopefully someday Cargo will1315        // have space support.1316        let rust_version = self.rust_version().replace(' ', "\t");1317        rustdocflags.arg("--crate-version").arg(&rust_version);13181319        // Environment variables *required* throughout the build13201321        // The host this new compiler is being *built* on.1322        cargo.env("CFG_COMPILER_BUILD_TRIPLE", compiler.host.triple);13231324        // Set this for all builds to make sure doc builds also get it.1325        cargo.env("CFG_RELEASE_CHANNEL", &self.config.channel);13261327        // verbose cargo output is very noisy, so only enable it with -vv1328        for _ in 0..self.verbosity.saturating_sub(1) {1329            cargo.arg("--verbose");1330        }13311332        match (mode, self.config.rust_codegen_units_std, self.config.rust_codegen_units) {1333            (Mode::Std, Some(n), _) | (_, _, Some(n)) => {1334                cargo.env(profile_var("CODEGEN_UNITS"), n.to_string());1335            }1336            _ => {1337                // Don't set anything1338            }1339        }13401341        if self.config.locked_deps {1342            cargo.arg("--locked");1343        }1344        if self.config.vendor || self.is_sudo {1345            cargo.arg("--frozen");1346        }13471348        // Try to use a sysroot-relative bindir, in case it was configured absolutely.1349        cargo.env("RUSTC_INSTALL_BINDIR", self.config.bindir_relative());13501351        if self.config.is_running_on_ci() {1352            // Tell cargo to use colored output for nicer logs in CI, even1353            // though CI isn't printing to a terminal.1354            // Also set an explicit `TERM=xterm` so that cargo doesn't warn1355            // about TERM not being set.1356            cargo.env("TERM", "xterm").args(["--color=always"]);1357        };13581359        // When we build Rust dylibs they're all intended for intermediate1360        // usage, so make sure we pass the -Cprefer-dynamic flag instead of1361        // linking all deps statically into the dylib.1362        if matches!(mode, Mode::Std) {1363            rustflags.arg("-Cprefer-dynamic");1364        }1365        if matches!(mode, Mode::Rustc) && !self.link_std_into_rustc_driver(target) {1366            rustflags.arg("-Cprefer-dynamic");1367        }13681369        cargo.env(1370            "RUSTC_LINK_STD_INTO_RUSTC_DRIVER",1371            if self.link_std_into_rustc_driver(target) { "1" } else { "0" },1372        );13731374        // When building incrementally we default to a lower ThinLTO import limit1375        // (unless explicitly specified otherwise). This will produce a somewhat1376        // slower code but give way better compile times.1377        {1378            let limit = match self.config.rust_thin_lto_import_instr_limit {1379                Some(limit) => Some(limit),1380                None if self.config.incremental => Some(10),1381                _ => None,1382            };13831384            if let Some(limit) = limit1385                && (build_compiler_stage == 01386                    || self.config.default_codegen_backend(target).is_llvm())1387            {1388                rustflags.arg(&format!("-Cllvm-args=-import-instr-limit={limit}"));1389            }1390        }13911392        if matches!(mode, Mode::Std) {1393            if let Some(mir_opt_level) = self.config.rust_validate_mir_opts {1394                rustflags.arg("-Zvalidate-mir");1395                rustflags.arg(&format!("-Zmir-opt-level={mir_opt_level}"));1396            }1397            if self.config.rust_randomize_layout {1398                rustflags.arg("--cfg=randomized_layouts");1399            }1400            // Always enable inlining MIR when building the standard library.1401            // Without this flag, MIR inlining is disabled when incremental compilation is enabled.1402            // That causes some mir-opt tests which inline functions from the standard library to1403            // break when incremental compilation is enabled. So this overrides the "no inlining1404            // during incremental builds" heuristic for the standard library.1405            rustflags.arg("-Zinline-mir");14061407            // Similarly, we need to keep debug info for functions inlined into other std functions,1408            // even if we're not going to output debuginfo for the crate we're currently building,1409            // so that it'll be available when downstream consumers of std try to use it.1410            rustflags.arg("-Zinline-mir-preserve-debug");14111412            rustflags.arg("-Zmir_strip_debuginfo=locals-in-tiny-functions");1413        }14141415        // take target-specific extra rustflags if any otherwise take `rust.rustflags`1416        let extra_rustflags = self1417            .config1418            .target_config1419            .get(&target)1420            .map(|t| &t.rustflags)1421            .unwrap_or(&self.config.rust_rustflags)1422            .clone();14231424        let profile =1425            if matches!(cmd_kind, Kind::Bench | Kind::Miri | Kind::MiriSetup | Kind::MiriTest) {1426                // Use the default profile for bench/miri1427                None1428            } else {1429                match (mode, self.config.rust_optimize.is_release()) {1430                    // Some std configuration exists in its own profile1431                    (Mode::Std, _) => Some("dist"),1432                    (_, true) => Some("release"),1433                    (_, false) => Some("dev"),1434                }1435            };14361437        Cargo {1438            command: cargo,1439            args: vec![],1440            compiler,1441            mode,1442            target,1443            rustflags,1444            rustdocflags,1445            hostflags,1446            allow_features,1447            build_compiler_stage,1448            extra_rustflags,1449            profile,1450        }1451    }1452}14531454pub fn cargo_profile_var(name: &str, config: &Config, mode: Mode) -> String {1455    let profile = match (mode, config.rust_optimize.is_release()) {1456        // Some std configuration exists in its own profile1457        (Mode::Std, _) => "DIST",1458        (_, true) => "RELEASE",1459        (_, false) => "DEV",1460    };1461    format!("CARGO_PROFILE_{profile}_{name}")1462}