prevent using the default cc when that'd result in a broken build

Author: pietroalbini

src/bootstrap/src/bin/broken-cc.rs

@@ -0,0 +1,47 @@
+// Show an error message when the wrong C compiler is detected. See the cc_detect module inside of
+// bootstrap for more context on why this binary was added.
+
+use std::process::ExitCode;
+
+const PREFIX: &str = "   ";
+
+fn main() -> ExitCode {
+    let mut target = None;
+    let mut detected_cc = None;
+    for arg in std::env::args() {
+        match arg.split_once('=') {
+            Some(("--broken-cc-target", t)) => target = Some(t.to_string()),
+            Some(("--broken-cc-detected", d)) => detected_cc = Some(d.to_string()),
+            _ => {}
+        }
+    }
+
+    let detected_cc = detected_cc.expect("broken-cc not invoked by bootstrap correctly");
+    let target = target.expect("broken-cc not invoked by bootstrap correctly");
+    let underscore_target = target.replace('-', "_");
+
+    eprintln!();
+    eprintln!("{PREFIX}Error: the automatic detection of the C compiler for cross-compiled");
+    eprintln!("{PREFIX}target {target} returned the C compiler also used for the");
+    eprintln!("{PREFIX}current host platform.");
+    eprintln!();
+    eprintln!("{PREFIX}This is likely wrong, and will likely result in a broken compilation");
+    eprintln!("{PREFIX}artifact. Please specify the correct C compiler for that target, either");
+    eprintln!("{PREFIX}with environment variables:");
+    eprintln!();
+    eprintln!("{PREFIX}    CC_{underscore_target}=path/to/cc");
+    eprintln!("{PREFIX}    CXX_{underscore_target}=path/to/cxx");
+    eprintln!();
+    eprintln!("{PREFIX}...or in config.toml:");
+    eprintln!();
+    eprintln!("{PREFIX}    [target.\"{target}\"]");
+    eprintln!("{PREFIX}    cc = \"path/to/cc\"");
+    eprintln!("{PREFIX}    cxx = \"path/to/cxx\"");
+    eprintln!();
+    eprintln!("{PREFIX}The detected C compiler was:");
+    eprintln!();
+    eprintln!("{PREFIX}    {detected_cc}");
+    eprintln!();
+
+    ExitCode::FAILURE
+}

src/bootstrap/src/utils/cc_detect.rs

@@ -115,6 +115,40 @@ pub fn find_target(build: &Build, target: TargetSelection) {
     }
 
     let compiler = cfg.get_compiler();
+
+    // When the cc crate cannot find the appropriate C compiler for the requested target, rather
+    // than erroring out it returns the default C compiler. In most cases, this is wrong.
+    //
+    // For example, let's say that you're cross-compiling for aarch64-unknown-none from an x86_64
+    // host, and that target is not recognized by the cc crate. In that case, the detected cc will
+    // be an x86_64 compiler, even though we're compiling for aarch64-unknown-none. If a crate then
+    // compiles some C code in its build script, the resulting rlib will have mixed AArch64 and
+    // x86_64 objects in it, and the linker will show rather unhelpful messages.
+    //
+    // To avoid the confusing error messages, we detect whether the configuration is likely broken,
+    // and if so we replace the detected C compiler with a stub binary that prints a useful error
+    // message, telling the user to manually configure their C compiler.
+    //
+    // We use a custom binary rather than erroring out directly here because some build steps might
+    // not need a C compiler at all, and it would be annoying to prevent the build in those cases.
+    let default_cc = new_cc_build(build, build.build).get_compiler();
+    if target != build.build && !compiler.is_like_clang() && compiler.path() == default_cc.path() {
+        let mut broken_cc = new_cc_build(build, target);
+        broken_cc.compiler(
+            std::env::current_exe()
+                .expect("failed to retrieve path to the bootstrap executable")
+                .parent()
+                .unwrap()
+                .join(format!("broken-cc{}", std::env::consts::EXE_SUFFIX)),
+        );
+        broken_cc.flag(&format!("--broken-cc-target={target}"));
+        broken_cc.flag(&format!("--broken-cc-detected={}", default_cc.path().display()));
+
+        build.cc.borrow_mut().insert(target, broken_cc.get_compiler());
+        build.cxx.borrow_mut().insert(target, broken_cc.get_compiler());
+        return;
+    }
+
     let ar = if let ar @ Some(..) = config.and_then(|c| c.ar.clone()) {
         ar
     } else {