Pick assembly files based on tools, not targets

When deciding whether to use MASM assembly files or the GNU assembly
files it makes more sense to check the tool we're using to compile,
as tools are what ultimately what decide which format is supported and
accepted.

Author: nagisa

psm/build.rs

@@ -5,30 +5,30 @@ fn find_assembly(
     endian: &str,
     os: &str,
     env: &str,
-    is_windows_host: bool,
+    masm: 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") => {
-            if is_windows_host {
+            if masm {
                 Some(("src/arch/x86_msvc.asm", false))
             } else {
                 Some(("src/arch/x86_windows_gnu.s", false))
             }
         }
         ("x86_64", _, "windows", "msvc") => {
-            if is_windows_host {
+            if masm {
                 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") => {
-            if is_windows_host {
+            if masm {
                 Some(("src/arch/aarch64_armasm.asm", false))
             } else {
                 Some(("src/arch/aarch_aapcs64.s", false))
@@ -61,28 +61,6 @@ 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();
-    // 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
@@ -95,13 +73,12 @@ fn main() {
     }
 
     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
+    // and can just use clang directly.
     if cfg
         .get_compiler()
         .path()
@@ -114,6 +91,20 @@ fn main() {
     }
 
     let msvc = cfg.get_compiler().is_like_msvc();
+    let asm =
+        if let Some((asm, canswitch)) = find_assembly(&arch, &endian, &os, &env, msvc) {
+            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;
+        };
 
     if !msvc {
         cfg.flag("-xassembler-with-cpp");