Add support for Native ARM64 and x64 if available

Author: dpaoliello

dev-tools/gen-windows-sys-binding/windows_sys.list

@@ -19,6 +19,9 @@ Windows.Win32.System.Com.COINIT_MULTITHREADED
 Windows.Win32.System.Com.CoCreateInstance
 Windows.Win32.System.Com.CoInitializeEx
 
+Windows.Win32.System.LibraryLoader.GetProcAddress
+Windows.Win32.System.LibraryLoader.LoadLibraryA
+
 Windows.Win32.System.Pipes.PeekNamedPipe
 
 Windows.Win32.System.Registry.RegCloseKey
@@ -31,9 +34,13 @@ Windows.Win32.System.Registry.KEY_READ
 Windows.Win32.System.Registry.KEY_WOW64_32KEY
 Windows.Win32.System.Registry.REG_SZ
 
+Windows.Win32.System.SystemInformation.IMAGE_FILE_MACHINE_AMD64
+
+Windows.Win32.System.Threading.GetMachineTypeAttributes
 Windows.Win32.System.Threading.ReleaseSemaphore
 Windows.Win32.System.Threading.WaitForSingleObject
 Windows.Win32.System.Threading.SEMAPHORE_MODIFY_STATE
 Windows.Win32.System.Threading.THREAD_SYNCHRONIZE
+Windows.Win32.System.Threading.UserEnabled
 
 Windows.Win32.System.WindowsProgramming.OpenSemaphoreA

src/windows/find_tools.rs

@@ -163,6 +163,10 @@ mod impl_ {
     use crate::windows::registry::{RegistryKey, LOCAL_MACHINE};
     use crate::windows::setup_config::SetupConfiguration;
     use crate::windows::vs_instances::{VsInstances, VswhereInstance};
+    use crate::windows::windows_sys::{
+        GetMachineTypeAttributes, GetProcAddress, LoadLibraryA, UserEnabled,
+        IMAGE_FILE_MACHINE_AMD64, S_OK,
+    };
     use std::convert::TryFrom;
     use std::env;
     use std::ffi::OsString;
@@ -199,6 +203,35 @@ mod impl_ {
         include: Vec<PathBuf>,
     }
 
+    unsafe fn cast_to_function<F: Sized>(
+        raw_func: unsafe extern "system" fn() -> isize,
+        _func_type: &F,
+    ) -> F {
+        std::mem::transmute_copy(&raw_func)
+    }
+
+    fn is_amd64_emulation_supported() -> bool {
+        // In theory we should free the library handle, but since kernel32.dll is loaded in every
+        // process and we're a short-lived process, leaking the handles doesn't matter.
+        let kernel32 = unsafe { LoadLibraryA(b"kernel32.dll\0".as_ptr() as _) };
+        if let Some(get_machine_type_attributes) =
+            unsafe { GetProcAddress(kernel32, b"GetMachineTypeAttributes\0".as_ptr() as _) }
+        {
+            let mut attributes = Default::default();
+            let get_machine_type_attributes =
+                unsafe { cast_to_function(get_machine_type_attributes, &GetMachineTypeAttributes) };
+            if unsafe {
+                get_machine_type_attributes(IMAGE_FILE_MACHINE_AMD64, &mut attributes) == S_OK
+            } {
+                (attributes & UserEnabled) != 0
+            } else {
+                false
+            }
+        } else {
+            false
+        }
+    }
+
     impl MsvcTool {
         fn new(tool: PathBuf) -> MsvcTool {
             MsvcTool {
@@ -226,7 +259,6 @@ mod impl_ {
 
     /// Checks to see if the `VSCMD_ARG_TGT_ARCH` environment variable matches the
     /// given target's arch. Returns `None` if the variable does not exist.
-    #[cfg(windows)]
     fn is_vscmd_target(target: TargetArch<'_>) -> Option<bool> {
         let vscmd_arch = env::var("VSCMD_ARG_TGT_ARCH").ok()?;
         // Convert the Rust target arch to its VS arch equivalent.
@@ -482,13 +514,21 @@ mod impl_ {
     ) -> Option<(PathBuf, PathBuf, PathBuf, PathBuf, Option<PathBuf>, PathBuf)> {
         let version = vs15plus_vc_read_version(instance_path)?;
 
+        let _ = is_amd64_emulation_supported();
         let hosts = match host_arch() {
-            X86 => vec!["X86"],
-            X86_64 => vec!["X64"],
-            // Starting with VS 17.3, there is a natively hosted compiler on ARM64.
-            // On older versions of VS, we use the x86 toolchain under emulation.
-            // We don't want to overcomplicate compatibility checks, so we ignore x64 emulation.
-            AARCH64 => vec!["ARM64", "X86"],
+            X86 => &["X86"],
+            X86_64 => &["X64"],
+            // Starting with VS 17.4, there is a natively hosted compiler on ARM64:
+            // https://devblogs.microsoft.com/visualstudio/arm64-visual-studio-is-officially-here/
+            // On older versions of VS, we use x64 if running under emulation is supported,
+            // otherwise use x86.
+            AARCH64 => {
+                if is_amd64_emulation_supported() {
+                    &["ARM64", "X64", "X86"][..]
+                } else {
+                    &["ARM64", "X86"]
+                }
+            }
             _ => return None,
         };
         let target = lib_subdir(target)?;

src/windows/windows_sys.rs

@@ -54,6 +54,21 @@ extern "system" {
     ) -> WIN32_ERROR;
 }
 #[link(name = "kernel32")]
+extern "system" {
+    pub fn GetMachineTypeAttributes(
+        machine: u16,
+        machinetypeattributes: *mut MACHINE_ATTRIBUTES,
+    ) -> HRESULT;
+}
+#[link(name = "kernel32")]
+extern "system" {
+    pub fn GetProcAddress(hmodule: HMODULE, lpprocname: PCSTR) -> FARPROC;
+}
+#[link(name = "kernel32")]
+extern "system" {
+    pub fn LoadLibraryA(lplibfilename: PCSTR) -> HMODULE;
+}
+#[link(name = "kernel32")]
 extern "system" {
     pub fn OpenSemaphoreA(dwdesiredaccess: u32, binherithandle: BOOL, lpname: PCSTR) -> HANDLE;
 }
@@ -112,6 +127,7 @@ pub const COINIT_MULTITHREADED: COINIT = 0i32;
 pub const ERROR_NO_MORE_ITEMS: WIN32_ERROR = 259u32;
 pub const ERROR_SUCCESS: WIN32_ERROR = 0u32;
 pub const FALSE: BOOL = 0i32;
+pub type FARPROC = ::core::option::Option<unsafe extern "system" fn() -> isize>;
 #[repr(C)]
 pub struct FILETIME {
     pub dwLowDateTime: u32,
@@ -149,10 +165,14 @@ impl ::core::clone::Clone for GUID {
 pub type HANDLE = *mut ::core::ffi::c_void;
 pub type HKEY = *mut ::core::ffi::c_void;
 pub const HKEY_LOCAL_MACHINE: HKEY = invalid_mut(-2147483646i32 as _);
+pub type HMODULE = *mut ::core::ffi::c_void;
 pub type HRESULT = i32;
+pub type IMAGE_FILE_MACHINE = u16;
+pub const IMAGE_FILE_MACHINE_AMD64: IMAGE_FILE_MACHINE = 34404u16;
 pub type IUnknown = *mut ::core::ffi::c_void;
 pub const KEY_READ: REG_SAM_FLAGS = 131097u32;
 pub const KEY_WOW64_32KEY: REG_SAM_FLAGS = 512u32;
+pub type MACHINE_ATTRIBUTES = i32;
 pub type PCSTR = *const u8;
 pub type PCWSTR = *const u16;
 pub type PWSTR = *mut u16;
@@ -191,6 +211,7 @@ pub const S_FALSE: HRESULT = 1i32;
 pub const S_OK: HRESULT = 0i32;
 pub type THREAD_ACCESS_RIGHTS = u32;
 pub const THREAD_SYNCHRONIZE: THREAD_ACCESS_RIGHTS = 1048576u32;
+pub const UserEnabled: MACHINE_ATTRIBUTES = 1i32;
 pub const WAIT_ABANDONED: WIN32_ERROR = 128u32;
 pub const WAIT_FAILED: WIN32_ERROR = 4294967295u32;
 pub const WAIT_OBJECT_0: WIN32_ERROR = 0u32;