Add support for Native ARM64 and x64 if available

Author: dpaoliello

dev-tools/cc-test/msvc2.exe

@@ -1,8 +1,8 @@
 [package]
 name = "gen-windows-sys-binding"
 version = "0.0.0"
-edition = "2018"
+edition = "2021"
 publish = false
 
 [dependencies]
-windows-bindgen = "0.49"
+windows-bindgen = "0.53"

dev-tools/gen-windows-sys-binding/Cargo.toml

@@ -2,64 +2,78 @@
 //! https://github.com/rust-lang/rust/blob/master/src/tools/generate-windows-sys/src/main.rs
 
 use std::{
-    fs,
-    io::{self, Write},
+    fs::{self, OpenOptions},
+    io::{self, Read, Seek, SeekFrom, Write},
 };
 
 /// This is printed to the file before the rest of the contents.
 const PRELUDE: &str = r#"// This file is autogenerated.
 //
-// To add bindings, edit windows_sys.lst then run:
+// To add bindings, edit windows_sys.lst or windows_sys_no_link.lst then run:
 //
 // ```
 // cd generate-windows-sys/
 // cargo run
 // ```
 "#;
 
-const POSTLUDE: &str = r#"
-/// Adapted from
-/// [`core::ptr::invalid_mut()`](https://doc.rust-lang.org/src/core/ptr/mod.rs.html#600-607).
-///
-/// This function should actually use `core::mem::transmute` but due to msrv
-/// we use `as` casting instead.
-///
-/// Once msrv is bumped to 1.56, replace this with `core::mem::transmute` since
-/// it is const stablised in 1.56
-///
-/// NOTE that once supports `strict_provenance` we would also have to update
-/// this.
-const fn invalid_mut<T>(addr: usize) -> *mut T {
-    addr as *mut T
+fn generate_bindings<P, F>(api_list: P, out_path: &str, modify_contents: F) -> io::Result<()>
+where
+    P: AsRef<std::path::Path>,
+    F: FnOnce(String) -> String,
+{
+    // Load the list of APIs
+    let buffer = fs::read_to_string(api_list).expect("failed to read list");
+    let names = buffer.lines().filter_map(|line| {
+        let line = line.trim();
+        if line.is_empty() || line.starts_with("//") {
+            None
+        } else {
+            Some(line)
+        }
+    });
+
+    windows_bindgen::bindgen(
+        ["--config", "std", "flatten", "--out", out_path, "--filter"]
+            .into_iter()
+            .chain(names),
+    )
+    .expect("running bindgen failed");
+
+    let mut out_file = OpenOptions::new()
+        .read(true)
+        .write(true)
+        .create(false)
+        .open(out_path)?;
+    let mut contents = String::new();
+    out_file.read_to_string(&mut contents)?;
+
+    let contents = modify_contents(contents);
+
+    out_file.seek(SeekFrom::Start(0))?;
+    out_file.set_len(0)?;
+    out_file.write_all(PRELUDE.as_bytes())?;
+    out_file.write_all(contents.as_bytes())?;
+
+    Ok(())
 }
-"#;
 
 fn main() -> io::Result<()> {
     let manifest_dir = env!("CARGO_MANIFEST_DIR");
-    // Load the list of APIs
-    let buffer = fs::read_to_string(format!("{manifest_dir}/windows_sys.list"))
-        .expect("failed to read windows_sys.list");
-    let names: Vec<&str> = buffer
-        .lines()
-        .filter_map(|line| {
-            let line = line.trim();
-            if line.is_empty() || line.starts_with("//") {
-                None
-            } else {
-                Some(line)
-            }
-        })
-        .collect();
-
-    // Write the bindings to windows-sys.rs
-    let bindings =
-        windows_bindgen::standalone_std(&names).replace("::core::ptr::invalid_mut", "invalid_mut");
+    // Generate regular bindings.
+    generate_bindings(
+        format!("{manifest_dir}/windows_sys.list"),
+        &format!("{manifest_dir}/../../src/windows/windows_sys.rs"),
+        |contents| contents,
+    )?;
 
-    let mut f = fs::File::create(format!("{manifest_dir}/../../src/windows/windows_sys.rs"))
-        .expect("failed to create windows_sys.rs");
-    f.write_all(PRELUDE.as_bytes())?;
-    f.write_all(bindings.as_bytes())?;
-    f.write_all(POSTLUDE.as_bytes())?;
+    // Generate bindings without #[link] attributes - this is useful if you want the signature of a
+    // function (e.g., for GetProcAddress) but don't want to link to it.
+    generate_bindings(
+        format!("{manifest_dir}/windows_sys_no_link.list"),
+        &format!("{manifest_dir}/../../src/windows/windows_sys_no_link.rs"),
+        |contents| contents.replace("#[link(", "// #[link("),
+    )?;
 
     Ok(())
 }

dev-tools/gen-windows-sys-binding/src/main.rs

@@ -11,6 +11,7 @@ Windows.Win32.Foundation.WAIT_OBJECT_0
 Windows.Win32.Foundation.WAIT_TIMEOUT
 Windows.Win32.Foundation.WAIT_FAILED
 Windows.Win32.Foundation.WAIT_ABANDONED
+Windows.Win32.Foundation.FreeLibrary
 
 Windows.Win32.System.Com.SAFEARRAY
 Windows.Win32.System.Com.SAFEARRAYBOUND
@@ -19,6 +20,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 +35,12 @@ 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.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

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

@@ -0,0 +1 @@
+Windows.Win32.System.Threading.GetMachineTypeAttributes

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

@@ -24,7 +24,7 @@ use std::{
 };
 
 pub fn initialize() -> Result<(), HRESULT> {
-    let err = unsafe { CoInitializeEx(null(), COINIT_MULTITHREADED) };
+    let err = unsafe { CoInitializeEx(null(), COINIT_MULTITHREADED as u32) };
     if err != S_OK && err != S_FALSE {
         // S_FALSE just means COM is already initialized
         Err(err)

src/windows/com.rs

@@ -163,6 +163,11 @@ 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::{
+        FreeLibrary, GetProcAddress, LoadLibraryA, UserEnabled, HMODULE, IMAGE_FILE_MACHINE_AMD64,
+        S_OK,
+    };
+    use crate::windows::windows_sys_no_link::GetMachineTypeAttributes;
     use std::convert::TryFrom;
     use std::env;
     use std::ffi::OsString;
@@ -199,6 +204,52 @@ mod impl_ {
         include: Vec<PathBuf>,
     }
 
+    struct LibraryHandle(HMODULE);
+
+    impl LibraryHandle {
+        fn new(name: &[u8]) -> Option<Self> {
+            let handle = unsafe { LoadLibraryA(name.as_ptr() as _) };
+            (!handle.is_null()).then(|| Self(handle))
+        }
+
+        /// Get a function pointer to a function in the library.
+        /// SAFETY: The caller must ensure that the function signature matches the actual function.
+        /// The easiest way to do this is to add an entry to windows_sys_no_link.list and use the
+        /// generated function for `func_signature`.
+        unsafe fn get_proc_address<F>(&self, name: &[u8], _func_signature: &F) -> Option<F> {
+            let symbol = unsafe { GetProcAddress(self.0, name.as_ptr() as _) };
+            symbol.map(|symbol| unsafe { mem::transmute_copy(&symbol) })
+        }
+    }
+
+    impl Drop for LibraryHandle {
+        fn drop(&mut self) {
+            unsafe { FreeLibrary(self.0) };
+        }
+    }
+
+    fn is_amd64_emulation_supported() -> bool {
+        if let Some(kernel32) = LibraryHandle::new(b"kernel32.dll\0") {
+            // GetMachineTypeAttributes is only available on Win11 22000+.
+            if let Some(get_machine_type_attributes) = unsafe {
+                kernel32.get_proc_address(b"GetMachineTypeAttributes\0", &GetMachineTypeAttributes)
+            } {
+                let mut attributes = Default::default();
+                if unsafe { get_machine_type_attributes(IMAGE_FILE_MACHINE_AMD64, &mut attributes) }
+                    == S_OK
+                {
+                    (attributes & UserEnabled) != 0
+                } else {
+                    false
+                }
+            } else {
+                false
+            }
+        } else {
+            false
+        }
+    }
+
     impl MsvcTool {
         fn new(tool: PathBuf) -> MsvcTool {
             MsvcTool {
@@ -226,7 +277,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.
@@ -483,34 +533,41 @@ mod impl_ {
         let version = vs15plus_vc_read_version(instance_path)?;
 
         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)?;
         // The directory layout here is MSVC/bin/Host$host/$target/
         let path = instance_path.join(r"VC\Tools\MSVC").join(version);
         // We use the first available host architecture that can build for the target
         let (host_path, host) = hosts.iter().find_map(|&x| {
-            let candidate = path.join("bin").join(&format!("Host{}", x));
-            if candidate.join(&target).exists() {
+            let candidate = path.join("bin").join(format!("Host{}", x));
+            if candidate.join(target).exists() {
                 Some((candidate, x))
             } else {
                 None
             }
         })?;
         // This is the path to the toolchain for a particular target, running
         // on a given host
-        let bin_path = host_path.join(&target);
+        let bin_path = host_path.join(target);
         // But! we also need PATH to contain the target directory for the host
         // architecture, because it contains dlls like mspdb140.dll compiled for
         // the host architecture.
-        let host_dylib_path = host_path.join(&host.to_lowercase());
-        let lib_path = path.join("lib").join(&target);
+        let host_dylib_path = host_path.join(host.to_lowercase());
+        let lib_path = path.join("lib").join(target);
         let alt_lib_path = (target == "arm64ec").then(|| path.join("lib").join("arm64ec"));
         let include_path = path.join("include");
         Some((

src/windows/find_tools.rs

@@ -6,6 +6,8 @@ pub mod find_tools;
 
 #[cfg(windows)]
 pub(crate) mod windows_sys;
+#[cfg(windows)]
+pub(crate) mod windows_sys_no_link;
 
 #[cfg(windows)]
 mod registry;