feat: support *-pc-windows-gnullvm targets

christhomas · chyyran · commit 6e46b00ce270 · 2026-05-12T01:23:32.000+09:00
The winfsp DLL ships only MSVC-format .lib import libraries, but
lld-link (used by both *-pc-windows-msvc and *-pc-windows-gnullvm Rust
toolchains) consumes those COFF imports natively. The previous build
gates on `target_env == "msvc"` and panics on every other env, even
though gnullvm is fully capable of linking against the same archives.

Changes:
  * winfsp-sys/build.rs:
    - Introduce a `LinkEnv { Msvc, GnuLlvm }` enum so the linkage env
      flows through the build script as a typed value rather than
      stringly-typed flags. Architecture/clang-target selection and
      delay-load syntax both branch on the enum, which flattens the
      nested arch/env match logic and makes each case explicit.
    - Detect gnullvm via target_env=="gnu" + target_abi=="llvm" and
      use mingw clang target strings (`aarch64-w64-mingw32` etc.) for
      bindgen so it picks up llvm-mingw's bundled `windows.h` instead
      of the absent MSVC SDK headers; struct layout stays MS-ABI.
    - Force C11 + auto-include `&lt;assert.h&gt;` for gnullvm so the
      `static_assert(...)` in winfsp/fsctl.h parses (mingw clang
      defaults to C99).
    - Skip `delayimp` on gnullvm (rustc has no search path for it; the
      lld-link `--delayload` lowering provides the helper itself).
    - Emit `-Wl,--delayload=foo.dll` for gnullvm vs `/DELAYLOAD:foo.dll`
      for msvc — ld.lld in mingw mode rejects the MSVC slash form.
    - `system()` now tries `SOFTWARE\\WinFsp` as a fallback after
      `SOFTWARE\\WOW6432Node\\WinFsp`, so ARM64 native installs (which
      register outside WOW6432Node) still resolve headers and libs.
  * winfsp/src/init.rs:
    - Mirror the typed `LinkEnv` in winfsp_link_delayload, with explicit
      Msvc / GnuLlvm cases — no fallthrough to GNU linkage; anything
      that isn't one of the two recognised envs panics with
      `unsupported triple`.
    - Read CARGO_CFG_TARGET_* instead of cfg!() so cross-built build
      scripts get the target's view rather than the host's.
    - get_system_winfsp() falls back to `SOFTWARE\\WinFsp` after the
      WOW6432Node lookup, mirroring the build-time change.
diff --git a/winfsp-sys/build.rs b/winfsp-sys/build.rs
@@ -29,10 +29,17 @@ fn system() -> String {
         panic!("'system' feature not supported for cross-platform compilation.");
     }
 
-    let directory = LOCAL_MACHINE
-        .open("SOFTWARE\\WOW6432Node\\WinFsp")
-        .ok()
-        .and_then(|u| u.get_string("InstallDir").ok())
+    // 32-bit installers land in WOW6432Node; ARM64 native installers
+    // write directly under SOFTWARE. Try both so that an ARM64 host
+    // with a native WinFsp install still resolves headers + libs.
+    let directory = ["SOFTWARE\\WOW6432Node\\WinFsp", "SOFTWARE\\WinFsp"]
+        .iter()
+        .find_map(|p| {
+            LOCAL_MACHINE
+                .open(p)
+                .ok()
+                .and_then(|u| u.get_string("InstallDir").ok())
+        })
         .expect("WinFsp installation directory not found.");
 
     println!("cargo:rustc-link-search={}/lib", directory);
@@ -81,6 +88,41 @@ fn copy_winfsp_dll(winfsp_lib: &str) {
     }
 }
 
+/// Linkage environment for the active target.
+///
+/// WinFSP ships MSVC-format `.lib` import libraries; both classic MSVC
+/// and `*-pc-windows-gnullvm` consume them through `lld-link`, so the
+/// link decisions are nearly identical between the two — but the clang
+/// `--target`, the delay-load syntax, and whether we ask rustc for
+/// `delayimp` all diverge, so we keep them as distinct cases.
+#[derive(Copy, Clone, PartialEq, Eq)]
+enum LinkEnv {
+    Msvc,
+    GnuLlvm,
+}
+
+impl LinkEnv {
+    fn detect(target_env: &str, target_abi: &str) -> Option<Self> {
+        match (target_env, target_abi) {
+            ("msvc", _) => Some(Self::Msvc),
+            ("gnu", "llvm") => Some(Self::GnuLlvm),
+            _ => None,
+        }
+    }
+
+    fn clang_target(self, target_arch: &str) -> Option<&'static str> {
+        Some(match (self, target_arch) {
+            (Self::Msvc, "x86_64") => "x86_64-pc-windows-msvc",
+            (Self::Msvc, "x86") => "x86-pc-windows-msvc",
+            (Self::Msvc, "aarch64") => "aarch64-pc-windows-msvc",
+            (Self::GnuLlvm, "x86_64") => "x86_64-w64-mingw32",
+            (Self::GnuLlvm, "x86") => "i686-w64-mingw32",
+            (Self::GnuLlvm, "aarch64") => "aarch64-w64-mingw32",
+            _ => return None,
+        })
+    }
+}
+
 fn main() {
     let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
 
@@ -95,28 +137,45 @@ fn main() {
     let target_os = env::var("CARGO_CFG_TARGET_OS").unwrap_or_else(|_| "unknown".to_string());
     let target_arch = env::var("CARGO_CFG_TARGET_ARCH").unwrap_or_else(|_| "unknown".to_string());
     let target_env = env::var("CARGO_CFG_TARGET_ENV").unwrap_or_else(|_| "unknown".to_string());
+    let target_abi = env::var("CARGO_CFG_TARGET_ABI").unwrap_or_default();
 
     if target_os != "windows" {
         panic!("WinFSP is only supported on Windows.");
     }
 
+    let link_env = LinkEnv::detect(&target_env, &target_abi)
+        .unwrap_or_else(|| panic!("unsupported triple {}", env::var("TARGET").unwrap()));
+
     #[cfg(feature = "system")]
     let link_include = system();
     #[cfg(not(feature = "system"))]
     let link_include = local();
 
-    println!("cargo:rustc-link-lib=dylib=delayimp");
-
-    // Architecture-specific configuration
-    let (winfsp_lib, clang_target) = match (target_arch.as_str(), target_env.as_str()) {
-        ("x86_64", "msvc") => ("winfsp-x64", "x86_64-pc-windows-msvc"),
-        ("x86", "msvc") => ("winfsp-x86", "x86-pc-windows-msvc"),
-        ("aarch64", "msvc") => ("winfsp-a64", "aarch64-pc-windows-msvc"),
+    let winfsp_lib = match target_arch.as_str() {
+        "x86_64" => "winfsp-x64",
+        "x86" => "winfsp-x86",
+        "aarch64" => "winfsp-a64",
         _ => panic!("unsupported triple {}", env::var("TARGET").unwrap()),
     };
+    let clang_target = link_env
+        .clang_target(&target_arch)
+        .unwrap_or_else(|| panic!("unsupported triple {}", env::var("TARGET").unwrap()));
 
     println!("cargo:rustc-link-lib=dylib={}", winfsp_lib);
-    println!("cargo:rustc-link-arg=/DELAYLOAD:{}.dll", winfsp_lib);
+    match link_env {
+        LinkEnv::Msvc => {
+            // delayimp.lib provides __delayLoadHelper2 under MSVC.
+            println!("cargo:rustc-link-lib=dylib=delayimp");
+            println!("cargo:rustc-link-arg=/DELAYLOAD:{}.dll", winfsp_lib);
+        }
+        LinkEnv::GnuLlvm => {
+            // LLVM-MinGW's libdelayimp.a isn't on rustc's link search
+            // path by default; lld-link's --delayload lowering provides
+            // the helper itself, and ld.lld in mingw mode requires the
+            // GNU-style flag rather than MSVC's `/DELAYLOAD:`.
+            println!("cargo:rustc-link-arg=-Wl,--delayload={}.dll", winfsp_lib);
+        }
+    }
 
     let bindings_path_str = out_dir.join("bindings.rs");
 
@@ -142,6 +201,18 @@ fn main() {
 
         let bindings = bindings.clang_arg(&format!("--target={}", clang_target));
 
+        // Under mingw/llvm-mingw clang defaults to C99, which rejects the
+        // `static_assert(e,m)` MSVC C extension used in winfsp/fsctl.h.
+        // C11 has it via <assert.h> macro mapping; ensure that mode + the
+        // standard headers are pulled in.
+        let bindings = match link_env {
+            LinkEnv::GnuLlvm => bindings
+                .clang_arg("-std=c11")
+                .clang_arg("-include")
+                .clang_arg("assert.h"),
+            LinkEnv::Msvc => bindings,
+        };
+
         let bindings = bindings
             .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
             .generate()
diff --git a/winfsp/src/init.rs b/winfsp/src/init.rs
@@ -17,7 +17,7 @@ use crate::Result;
 pub struct FspInit;
 
 #[cfg(feature = "system")]
-fn get_system_winfsp() -> Option<windows::core::HSTRING> {
+fn read_install_dir(subkey: PCWSTR) -> Option<std::ffi::OsString> {
     use crate::constants::MAX_PATH;
     use windows::Win32::System::Registry::{HKEY_LOCAL_MACHINE, RRF_RT_REG_SZ, RegGetValueW};
 
@@ -26,7 +26,7 @@ fn get_system_winfsp() -> Option<windows::core::HSTRING> {
     let status = unsafe {
         RegGetValueW(
             HKEY_LOCAL_MACHINE,
-            w!("SOFTWARE\\WOW6432Node\\WinFsp"),
+            subkey,
             w!("InstallDir"),
             RRF_RT_REG_SZ,
             None,
@@ -36,14 +36,17 @@ fn get_system_winfsp() -> Option<windows::core::HSTRING> {
     };
     if status.is_err() {
         return None;
-    };
-
-    let Ok(path) = U16CStr::from_slice(&path[0..(size as usize) / std::mem::size_of::<u16>()])
-    else {
-        return None;
-    };
+    }
+    let path = U16CStr::from_slice(&path[0..(size as usize) / std::mem::size_of::<u16>()]).ok()?;
+    Some(path.to_os_string())
+}
 
-    let mut directory = path.to_os_string();
+#[cfg(feature = "system")]
+fn get_system_winfsp() -> Option<windows::core::HSTRING> {
+    // 32-bit installers land in WOW6432Node; ARM64 native installers
+    // write directly under SOFTWARE.
+    let mut directory = read_install_dir(w!("SOFTWARE\\WOW6432Node\\WinFsp"))
+        .or_else(|| read_install_dir(w!("SOFTWARE\\WinFsp")))?;
     directory.push("\\bin\\");
 
     if cfg!(target_arch = "x86_64") {
@@ -113,24 +116,57 @@ pub fn winfsp_init_or_die() -> FspInit {
     FspInit
 }
 
+/// Linkage environment for the active build target.
+#[derive(Copy, Clone, PartialEq, Eq)]
+enum LinkEnv {
+    Msvc,
+    GnuLlvm,
+}
+
+impl LinkEnv {
+    fn detect(target_env: &str, target_abi: &str) -> Option<Self> {
+        match (target_env, target_abi) {
+            ("msvc", _) => Some(Self::Msvc),
+            ("gnu", "llvm") => Some(Self::GnuLlvm),
+            _ => None,
+        }
+    }
+}
+
 /// Build-time helper to enable `DELAYLOAD` linking to the system WinFSP.
 ///
-/// This function should be called from `build.rs`.
+/// This function should be called from `build.rs`. Reads target config
+/// from cargo env vars so cross-compiled build scripts work correctly.
 pub fn winfsp_link_delayload() {
-    if cfg!(all(target_os = "windows", target_env = "msvc")) {
-        if cfg!(target_arch = "x86_64") {
-            println!("cargo:rustc-link-lib=dylib=delayimp");
-            println!("cargo:rustc-link-arg=/DELAYLOAD:winfsp-x64.dll");
-        } else if cfg!(target_arch = "x86") {
-            println!("cargo:rustc-link-lib=dylib=delayimp");
-            println!("cargo:rustc-link-arg=/DELAYLOAD:winfsp-x86.dll");
-        } else if cfg!(target_arch = "aarch64") {
+    let target_os = std::env::var("CARGO_CFG_TARGET_OS").unwrap_or_default();
+    let target_env = std::env::var("CARGO_CFG_TARGET_ENV").unwrap_or_default();
+    let target_abi = std::env::var("CARGO_CFG_TARGET_ABI").unwrap_or_default();
+    let target_arch = std::env::var("CARGO_CFG_TARGET_ARCH").unwrap_or_default();
+
+    if target_os != "windows" {
+        panic!("unsupported triple");
+    }
+    let link_env = LinkEnv::detect(&target_env, &target_abi)
+        .unwrap_or_else(|| panic!("unsupported triple"));
+
+    let dll = match target_arch.as_str() {
+        "x86_64" => "winfsp-x64.dll",
+        "x86" => "winfsp-x86.dll",
+        "aarch64" => "winfsp-a64.dll",
+        _ => panic!("unsupported architecture"),
+    };
+
+    match link_env {
+        LinkEnv::Msvc => {
             println!("cargo:rustc-link-lib=dylib=delayimp");
-            println!("cargo:rustc-link-arg=/DELAYLOAD:winfsp-a64.dll");
-        } else {
-            panic!("unsupported architecture")
+            println!("cargo:rustc-link-arg=/DELAYLOAD:{dll}");
+        }
+        LinkEnv::GnuLlvm => {
+            // LLVM-MinGW's libdelayimp.a isn't on rustc's link search
+            // path by default; lld-link's --delayload lowering provides
+            // the helper itself, and ld.lld in mingw mode requires the
+            // GNU-style flag rather than MSVC's `/DELAYLOAD:`.
+            println!("cargo:rustc-link-arg=-Wl,--delayload={dll}");
         }
-    } else {
-        panic!("unsupported triple")
     }
 }
