Add env variable to indicate the build type.

Build scripts in some cases need to know if the build is a cross
build or a native build.

Set the CARGO_BUILD_TYPE env variable for build scripts so that
they can properly determine the build type being performed.

Author: jameshilliard

src/cargo/core/compiler/build_context/target_info.rs

@@ -673,6 +673,9 @@ pub struct RustcTargetData<'cfg> {
     /// empty if the `--target` flag is not passed.
     target_config: HashMap<CompileTarget, TargetConfig>,
     target_info: HashMap<CompileTarget, TargetInfo>,
+
+    /// True if a `--target` flag is passed.
+    is_cross: bool,
 }
 
 impl<'cfg> RustcTargetData<'cfg> {
@@ -697,10 +700,13 @@ impl<'cfg> RustcTargetData<'cfg> {
         // `--target` flag is not specified. Since the unit_dependency code
         // needs access to the target config data, create a copy so that it
         // can be found. See `rebuild_unit_graph_shared` for why this is done.
-        if requested_kinds.iter().any(CompileKind::is_host) {
+        let is_cross = if requested_kinds.iter().any(CompileKind::is_host) {
             let ct = CompileTarget::new(&rustc.host)?;
             target_info.insert(ct, host_info.clone());
             target_config.insert(ct, config.target_cfg_triple(&rustc.host)?);
+            false
+        } else {
+            true
         };
 
         let mut res = RustcTargetData {
@@ -711,6 +717,7 @@ impl<'cfg> RustcTargetData<'cfg> {
             host_info,
             target_config,
             target_info,
+            is_cross,
         };
 
         // Get all kinds we currently know about.
@@ -798,6 +805,10 @@ impl<'cfg> RustcTargetData<'cfg> {
     pub fn script_override(&self, lib_name: &str, kind: CompileKind) -> Option<&BuildOutput> {
         self.target_config(kind).links_overrides.get(lib_name)
     }
+
+    pub fn is_cross(&self) -> bool {
+        self.is_cross
+    }
 }
 
 /// Structure used to deal with Rustdoc fingerprinting

src/cargo/core/compiler/custom_build.rs

@@ -198,6 +198,13 @@ fn build_work(cx: &mut Context<'_, '_>, unit: &Unit) -> CargoResult<Job> {
                 ProfileRoot::Debug => "debug",
             },
         )
+        .env(
+            "CARGO_BUILD_TYPE",
+            match &bcx.target_data.is_cross() {
+                true => "cross",
+                false => "native",
+            },
+        )
         .env("HOST", &bcx.host_triple())
         .env("RUSTC", &bcx.rustc().path)
         .env("RUSTDOC", &*bcx.config.rustdoc()?)

src/doc/src/reference/environment-variables.md

@@ -273,6 +273,9 @@ let out_dir = env::var("OUT_DIR").unwrap();
 `out_dir` will now contain the value of `OUT_DIR`.
 
 * `CARGO` — Path to the `cargo` binary performing the build.
+* `CARGO_BUILD_TYPE` — The type of build being performed.
+                       `cross` when the build target is overridden.
+                       `native` when a build target is not specified(default).
 * `CARGO_MANIFEST_DIR` — The directory containing the manifest for the package
                          being built (the package containing the build
                          script). Also note that this is the value of the

tests/testsuite/build_script.rs

@@ -115,6 +115,7 @@ fn custom_build_env_vars() {
                 let rustdoc = env::var("RUSTDOC").unwrap();
                 assert_eq!(rustdoc, "rustdoc");
 
+                assert_eq!(env::var("CARGO_BUILD_TYPE").unwrap(), "native");
                 assert!(env::var("RUSTC_LINKER").is_err());
             }}
         "#,
@@ -153,6 +154,7 @@ fn custom_build_env_var_rustc_linker() {
             use std::env;
 
             fn main() {
+                assert_eq!(env::var("CARGO_BUILD_TYPE").unwrap(), "cross");
                 assert!(env::var("RUSTC_LINKER").unwrap().ends_with("/path/to/linker"));
             }
             "#,
@@ -226,6 +228,7 @@ fn custom_build_env_var_rustc_linker_host_target() {
             use std::env;
 
             fn main() {
+                assert_eq!(env::var("CARGO_BUILD_TYPE").unwrap(), "cross");
                 assert!(env::var("RUSTC_LINKER").unwrap().ends_with("/path/to/linker"));
             }
             "#,
@@ -263,6 +266,7 @@ fn custom_build_env_var_rustc_linker_host_target_env() {
             use std::env;
 
             fn main() {
+                assert_eq!(env::var("CARGO_BUILD_TYPE").unwrap(), "cross");
                 assert!(env::var("RUSTC_LINKER").unwrap().ends_with("/path/to/linker"));
             }
             "#,
@@ -487,6 +491,7 @@ fn custom_build_env_var_rustc_linker_cross_arch_host() {
             use std::env;
 
             fn main() {
+                assert_eq!(env::var("CARGO_BUILD_TYPE").unwrap(), "cross");
                 assert!(env::var("RUSTC_LINKER").unwrap().ends_with("/path/to/target/linker"));
             }
             "#,
@@ -923,6 +928,7 @@ fn overrides_and_links() {
             r#"
                 use std::env;
                 fn main() {
+                    assert_eq!(env::var("CARGO_BUILD_TYPE").unwrap(), "native");
                     assert_eq!(env::var("DEP_FOO_FOO").ok().expect("FOO missing"),
                                "bar");
                     assert_eq!(env::var("DEP_FOO_BAR").ok().expect("BAR missing"),
@@ -1028,6 +1034,7 @@ fn links_passes_env_vars() {
             r#"
                 use std::env;
                 fn main() {
+                    assert_eq!(env::var("CARGO_BUILD_TYPE").unwrap(), "native");
                     assert_eq!(env::var("DEP_FOO_FOO").unwrap(), "bar");
                     assert_eq!(env::var("DEP_FOO_BAR").unwrap(), "baz");
                 }
@@ -1151,6 +1158,7 @@ fn rebuild_continues_to_pass_env_vars() {
             r#"
                 use std::env;
                 fn main() {
+                    assert_eq!(env::var("CARGO_BUILD_TYPE").unwrap(), "native");
                     assert_eq!(env::var("DEP_FOO_FOO").unwrap(), "bar");
                     assert_eq!(env::var("DEP_FOO_BAR").unwrap(), "baz");
                 }