Fix detection of aarch64 host on Windows

Author: arlosi

Cargo.toml

@@ -95,14 +95,14 @@ features = [
   "shlobj",
   "shtypes",
   "synchapi",
-  "sysinfoapi",
   "tlhelp32",
   "userenv",
   "winbase",
   "winerror",
   "winioctl",
   "winnt",
   "winuser",
+  "wow64apiset",
 ]
 version = "0.3"
 

src/dist/dist.rs

@@ -228,24 +228,30 @@ impl TargetTriple {
     pub(crate) fn from_host() -> Option<Self> {
         #[cfg(windows)]
         fn inner() -> Option<TargetTriple> {
-            use std::mem;
-            use winapi::um::sysinfoapi::GetNativeSystemInfo;
+            use winapi::um::processthreadsapi::GetCurrentProcess;
+            use winapi::um::wow64apiset::IsWow64Process2;
 
             // First detect architecture
-            const PROCESSOR_ARCHITECTURE_AMD64: u16 = 9;
-            const PROCESSOR_ARCHITECTURE_INTEL: u16 = 0;
-            const PROCESSOR_ARCHITECTURE_ARM64: u16 = 12;
-
-            let mut sys_info;
-            unsafe {
-                sys_info = mem::zeroed();
-                GetNativeSystemInfo(&mut sys_info);
-            }
+            const IMAGE_FILE_MACHINE_ARM64: u16 = 0xAA64;
+            const IMAGE_FILE_MACHINE_AMD64: u16 = 0x8664;
+            const IMAGE_FILE_MACHINE_I386: u16 = 0x014c;
+
+            let native_machine = unsafe {
+                // cannot fail; handle does not need to be closed.
+                let process = GetCurrentProcess();
+                let mut _machine = 0;
+                let mut native_machine = 0;
+                // native_machine is the native architecture of host system.
+                if IsWow64Process2(process, &mut _machine, &mut native_machine) == 0 {
+                    return None;
+                }
+                native_machine
+            };
 
-            let arch = match unsafe { sys_info.u.s() }.wProcessorArchitecture {
-                PROCESSOR_ARCHITECTURE_AMD64 => "x86_64",
-                PROCESSOR_ARCHITECTURE_INTEL => "i686",
-                PROCESSOR_ARCHITECTURE_ARM64 => "aarch64",
+            let arch = match native_machine {
+                IMAGE_FILE_MACHINE_AMD64 => "x86_64",
+                IMAGE_FILE_MACHINE_I386 => "i686",
+                IMAGE_FILE_MACHINE_ARM64 => "aarch64",
                 _ => return None,
             };
 
@@ -328,12 +334,12 @@ impl TargetTriple {
         let ret = if partial_self.os != partial_other.os {
             false
         } else if partial_self.os.as_deref() == Some("pc-windows") {
-            // Windows is a special case here, we know we can run 32bit on 64bit
-            // and we know we can run gnu and msvc on the same system
-            // We don't immediately assume we can cross between x86 and aarch64 though
+            // Windows is a special case here: we can run gnu and msvc on the same system,
+            // i686 can run on x86_64, and both x86_64 and i686 can run on aarch64 through emulation
             (partial_self.arch == partial_other.arch)
                 || (partial_self.arch.as_deref() == Some("x86_64")
                     && partial_other.arch.as_deref() == Some("i686"))
+                || partial_self.arch.as_deref() == Some("aarch64")
         } else {
             // For other OSes, for now, we assume other toolchains won't run
             false