Fix cross compilation for Windows

Author: Jake-Shadle

psm/build.rs

@@ -1,15 +1,39 @@
 extern crate cc;
 
-fn find_assembly(arch: &str, endian: &str, os: &str, env: &str) -> Option<(&'static str, bool)> {
+fn find_assembly(
+    arch: &str,
+    endian: &str,
+    os: &str,
+    env: &str,
+    is_windows_host: bool,
+) -> Option<(&'static str, bool)> {
     match (arch, endian, os, env) {
         // The implementations for stack switching exist, but, officially, doing so without Fibers
         // is not supported in Windows. For x86_64 the implementation actually works locally,
         // but failed tests in CI (???). Might want to have a feature for experimental support
         // here.
-        ("x86", _, "windows", "msvc") => Some(("src/arch/x86_msvc.asm", false)),
-        ("x86_64", _, "windows", "msvc") => Some(("src/arch/x86_64_msvc.asm", false)),
+        ("x86", _, "windows", "msvc") => {
+            if is_windows_host {
+                Some(("src/arch/x86_msvc.asm", false))
+            } else {
+                Some(("src/arch/x86_windows_gnu.s", false))
+            }
+        }
+        ("x86_64", _, "windows", "msvc") => {
+            if is_windows_host {
+                Some(("src/arch/x86_64_msvc.asm", false))
+            } else {
+                Some(("src/arch/x86_64_windows_gnu.s", false))
+            }
+        }
         ("arm", _, "windows", "msvc") => Some(("src/arch/arm_armasm.asm", false)),
-        ("aarch64", _, "windows", "msvc") => Some(("src/arch/aarch64_armasm.asm", false)),
+        ("aarch64", _, "windows", "msvc") => {
+            if is_windows_host {
+                Some(("src/arch/aarch64_armasm.asm", false))
+            } else {
+                Some(("src/arch/aarch_aapcs64.s", false))
+            }
+        }
         ("x86", _, "windows", _) => Some(("src/arch/x86_windows_gnu.s", false)),
         ("x86_64", _, "windows", _) => Some(("src/arch/x86_64_windows_gnu.s", false)),
 
@@ -37,21 +61,58 @@ fn main() {
     let env = ::std::env::var("CARGO_CFG_TARGET_ENV").unwrap();
     let os = ::std::env::var("CARGO_CFG_TARGET_OS").unwrap();
     let endian = ::std::env::var("CARGO_CFG_TARGET_ENDIAN").unwrap();
-    let asm = if let Some((asm, canswitch)) = find_assembly(&arch, &endian, &os, &env) {
-        println!("cargo:rustc-cfg=asm");
-        if canswitch {
-            println!("cargo:rustc-cfg=switchable_stack")
-        }
-        asm
-    } else {
-        println!(
-            "cargo:warning=Target {}-{}-{} has no assembly files!",
-            arch, os, env
-        );
-        return;
-    };
+    // Handle cross compilation scenarios where we're using eg clang-cl
+    // from a non-windows host, as by default cc will automatically try and
+    // run the appropriate Microsoft assembler for the target architecture
+    // if we give it a .asm file
+    let is_windows_host = std::env::var("HOST")
+        .unwrap_or_default()
+        .contains("-windows-");
+
+    let asm =
+        if let Some((asm, canswitch)) = find_assembly(&arch, &endian, &os, &env, is_windows_host) {
+            println!("cargo:rustc-cfg=asm");
+            if canswitch {
+                println!("cargo:rustc-cfg=switchable_stack")
+            }
+            asm
+        } else {
+            println!(
+                "cargo:warning=Target {}-{}-{} has no assembly files!",
+                arch, os, env
+            );
+            return;
+        };
+
+    // We are only assembling a single file and any flags in the environment probably
+    // don't apply in this case, so we don't want to use them. Unfortunately, cc
+    // doesn't provide a way to clear/ignore flags set from the environment, so
+    // we manually remove them instead
+    for key in
+        std::env::vars().filter_map(|(k, _)| if k.contains("CFLAGS") { Some(k) } else { None })
+    {
+        std::env::remove_var(key);
+    }
 
     let mut cfg = cc::Build::new();
+
+    // There seems to be a bug with clang-cl where using
+    // `/clang:-xassembler-with-cpp` is apparently accepted (ie no warnings
+    // about unused/unknown arguments), but results in the same exact error
+    // as if the flag was not present, so instead we take advantage of the
+    // fact that we're not actually compiling any C/C++ code, only assembling
+    // and can just use clang directly
+    if cfg
+        .get_compiler()
+        .path()
+        .file_name()
+        .and_then(|f| f.to_str())
+        .map(|fname| fname.contains("clang-cl"))
+        .unwrap_or(false)
+    {
+        cfg.compiler("clang");
+    }
+
     let msvc = cfg.get_compiler().is_like_msvc();
 
     if !msvc {